Macintosh-SW/sys7.1-doc-wip
1
0
Fork 0
mirror of https://github.com/elliotnunn/sys7.1-doc-wip.git synced 2024-12-12 04:29:09 +00:00
Code Issues Projects Releases Wiki Activity
cf5093687a
sys7.1-doc-wip/Tidbits/ROM_EM/ROM_EM.c
Horst Beepmanh 33cd9271f4 SuperMarioProj.1994-02-09
2019-07-27 22:37:48 +08:00

1074 lines
26 KiB
C
Raw Blame History

/*
File: ROM_EM.c
Contains: xxx put contents here xxx
Written by: xxx put writers here xxx
Copyright: © 1992 by Apple Computer, Inc., all rights reserved.
Change History (most recent first):
<1> 11/5/92 RB first checked in
*/
/*
© 1990-1992 Apple Computer, Inc. By Ricardo Batista
This file is a ROM version of Extensions Manager based on Extensions Manager 1.8
The ROM version provides minimal functionality and looks for resources in the system
file first, so that it can be localized if nessesary. To invoke it the user needs to press
the space bar and Command keys while booting. We get called by the InstallMgr routine
in StartBoot.a, InstallMgr gets called from the SuperMario Gibbly, just before extensions
are loaded.
We first test for space-Cmd down, and if it is then we initialize enough
of the tollbox so that we are able to make windows and dialogs. We then call the
pseudo-cdev code, make our dialog and pretend that we are the control panel until the user
clicks on the close box of our window. This code comes from a Control Panel, so hang on...
Notice that we do use GetNextEvent and routines like it because those routines do
a lot of work in the background, the least we use the toolbox the more compatible
that we will be in this case. (The state of the toolbox managers at startup
varies with machines and system releases).
SPECIAL INSTRUCTIONS:
Compiled with MPW 3.2
HISTORY:
11/5/92 RB Copied some code from Extensions Manager 1.8 and made it work in ROM.
Look for resources in the system file first, then in ROM so that someone
can localize this code for other countries.
Got rid of all the sets and other functionality which is no part of my
idea of a minimal EM, such as old type INITs, menus, etc.
*/
#define SystemSixOrLater 1
#define SystemSevenOrLater true
#include <Types.h>
#include <QuickDraw.h>
#include <Files.h>
#include <Folders.h>
#include <Dialogs.h>
#include <Lists.h>
#include <Memory.h>
#include <Devices.h>
#include <Resources.h>
#include <ToolUtils.h>
#include <Events.h>
#include <SysEqu.h>
#include <Menus.h>
#include <TextEdit.h>
#include <Fonts.h>
#include <Packages.h>
#include <Traps.h>
#include <Aliases.h>
#include <ShutDown.h>
#include <TextUtils.h>
#include <SysEqu.h>
/*
This is a copy of the quickdraw globals that MPW usually allocates for us
under a5, to be really safe and compatible with the future we need to add space
for the a5 reference (tempA5) and set a5 to point there before calling InitGraf
once InitGraf is called we can initialize some of the toolbox managers and make
windows and dialogs.
*/
typedef struct {
char privates[76];
long randSeed;
BitMap screenBits;
Cursor arrow;
Pattern dkGray;
Pattern ltGray;
Pattern gray;
Pattern black;
Pattern white;
GrafPtr thePort;
long tempA5;
} qdGlob;
typedef struct {
char fileName[40];
long enabledDirID;
long disabledDirID;
short vRefNum; // must be kept for each, because next system may
Boolean enabled; // have special folders in different volumes
char filler;
long creator;
} InitInfo, *InitInfoPtr, **InitInfoH;
typedef struct {
ListHandle list;
InitInfoH files;
} cdev_data, **cdev_dataH;
// PROTOTYPES
void ShowExtensions(void);
pascal void mySetA5(long) = 0x2A5F; // move.l (sp)+,a5
extern pascal void ROM_EM_OSDISPATCH(void *);
pascal void ROM_EM(void);
cdev_dataH EM_cdev(short message, short item, short numItems, short CPanelID,
EventRecord *theEvent, cdev_dataH cdevStorage, DialogPtr CPDialog);
void ReadFiles(ListHandle list,InitInfoH files);
void SaveInfo(ListHandle list,InitInfoH files);
void RevertInfo(ListHandle list,InitInfoH files);
void AddFolder(InitInfoH files, long GoodFolder, long DisFolder, Boolean useEnabledF);
void AllInfo(ListHandle list,InitInfoH files, Boolean on);
void Add7Folders(void);
Boolean HasINIT(CInfoPBRec *info);
void ErrDlg(short id);
void Sort(InitInfoH files, long folder);
pascal Boolean UpdateFilter(DialogPtr theDialog, EventRecord *theEvent,
short *item);
void myBlockMove(void *source, void *destination, long count);
Boolean MyCompare(unsigned char *a, unsigned char *b);
#define gTime 0x020C
#define spaceK 0x00000200L
#define enterK 0x00100000L
#define returnK 0x10000000L
#define gCommandK 0x00008000L
#define bOK 1
#define bRevert 1
#define bList 2
#define bAllOff 3
#define bAllOn 4
#define kUseDisabledFolder false
#define kUseEnabledFolder true
#define okItem 1
#define cancelItem 2
// if you change these id's, change them also in ROM_EM.r
#define kEMID -15020
#define kEM_Dialog -15020
#define kNeedINITID -15020
#define kNeedNoINITID -15021
#define duplicateDlg -15021
#define kUpdateCode 1898
/*
This is the entry point of the ROM version of EM, we test for the Cmd-space bar down and if it is down
we initialize enough of the tollbox to make dialogs, then call the code that will
look like a cdev and cleanup. We also replace _OSDispatch tenmporarily, because the Process Manager
is not fully functinal yet.
*/
pascal void ROM_EM(void)
{
qdGlob myQuick;
GrafPort myPort;
KeyMap keys;
char copyright[] = {"\p© 1990-1992 Apple Computer, Inc. By Ricardo Batista"};
long oldOSDispatch;
long oldCurrentA5, oldA5;
GetKeys(&keys[0]);
if (((keys[1] & spaceK) == 0) || ((keys[1] & gCommandK) == 0)) // Cmd-space bar down ?
return;
oldCurrentA5 = *((long*) CurrentA5);
myQuick.tempA5 = (long) &myQuick.thePort;
oldA5 = SetA5((long) &myQuick.tempA5); // INIT 31 restores A5
InitGraf(&myQuick.thePort);
*(long*) CurrentA5 = (long) &myQuick.tempA5;
OpenPort(&myPort);
InitFonts();
InitWindows(); // calls InitMenus and DrawMenuBar
InitMenus();
TEInit();
InitDialogs(0L);
InitAllPacks();
InitCursor();
*((long*)DeskHook) = 0L;
*((long*)DragHook) = 0L;
*((long*)GhostWindow) = 0L;
TextFont(0);
TextSize(12);
DrawMenuBar();
oldOSDispatch = GetTrapAddress(0x8F);
SetTrapAddress((long) ROM_EM_OSDISPATCH, 0x8F);
ShowExtensions();
SetTrapAddress(oldOSDispatch, 0x8F);
ClosePort(&myPort);
*(long*)CurrentA5 = oldCurrentA5;
SetA5(oldA5);
}
/*
This function loads a dialog similar to the control panel, then calls our cdev-like code
as if we were the control panel. We close our dialog when the user
presses the closes our window. Errors are checked from the dialog, cdev code and exec of
the cdev code.
*/
void ShowExtensions()
{
DialogPtr cpDialog, theDialog;
DialogRecord dr;
long result;
EventRecord event;
GrafPtr savePort;
Boolean quit = false;
short item = 0;
Boolean dEvent;
short part;
WindowPtr w;
char theChar;
short mask = keyDownMask + mDownMask + updateMask + mUpMask + keyUpMask;
GetPort(&savePort);
cpDialog = GetNewDialog(kEM_Dialog, (Ptr) &dr, (WindowPtr) -1L);
if (!cpDialog)
return;
ShowWindow(cpDialog);
SetPort(cpDialog);
SetOrigin(89,0);
TextFont(1);
TextSize(9);
BeginUpdate(cpDialog);
DrawDialog(cpDialog);
EndUpdate(cpDialog);
result = EM_cdev(initDev, 0, 0, kEM_Dialog, &event, (cdev_dataH) 2L, cpDialog);
if (result == 1L)
SysBeep(1);
if (result > 3L) {
result = EM_cdev(updateDev, 0, 0, kEM_Dialog, &event, (cdev_dataH) result, cpDialog);
result = EM_cdev(activDev, 0, 0, kEM_Dialog, &event, (cdev_dataH) result, cpDialog);
while (!quit) {
SetPort(cpDialog);
InitCursor(); // avoid disk insert events
if (GetNextEvent(mask, &event)) {
if (event.what == updateEvt) {
BeginUpdate(cpDialog);
result = EM_cdev(updateDev, 0, 0, kEM_Dialog, &event, (cdev_dataH) result, cpDialog);
EndUpdate(cpDialog);
}
if (event.what == mouseDown) {
part = FindWindow(event.where, &w);
if (part == inGoAway) {
TrackGoAway(cpDialog, event.where);
quit = true;
}
if (part == inContent) {
dEvent = IsDialogEvent(&event);
if (DialogSelect(&event, &theDialog, &item)) {
result = EM_cdev(hitDev, item, 0, kEM_Dialog, &event, (cdev_dataH) result, cpDialog);
}
}
}
if (event.what == keyDown) {
theChar = event.message & charCodeMask;
item = theChar;
result = EM_cdev(keyEvtDev, item, 0, kEM_Dialog, &event, (cdev_dataH) result, cpDialog);
}
}
}
}
if (result > 3L)
result = EM_cdev(closeDev, 0, 0, kEM_Dialog, &event, (cdev_dataH) result, cpDialog);
CloseDialog(cpDialog);
SetPort(savePort);
}
/*
This is the main entry point of the cdev code, the Control Panel calls us
giving us a message with the action to do. When initializing we have to create
a list and add to it all the files that could have INITs.
From then on we will get called with messages like hit or key pressed, on close
we dispose from our list.
*/
cdev_dataH EM_cdev(short message, short item, short numItems, short CPanelID,
EventRecord *theEvent, cdev_dataH cdevStorage, DialogPtr CPDialog)
{
cdev_dataH myData = 0L;
short type;
Handle H;
Rect box;
short myItem;
Point cell;
Rect bounds;
ListHandle list = 0L;
InitInfoH files = 0L;
KeyMap keys;
if (cdevStorage == 0L)
return(0L);
myData = 0L;
if (message == initDev) {
SetCursor(*(GetCursor(watchCursor)));
TextFont(1);
myData = (cdev_dataH) NewHandle(sizeof(cdev_data));
if (myData == 0L)
return((cdev_dataH) 1L); // bail out
HLock((Handle) myData);
files = (InitInfoH) NewHandle(0L);
if (files == 0L)
return((cdev_dataH) 1L); // bail out
(**myData).files = files;
GetDItem(CPDialog,numItems + bList,&type,&H,&box);
box.right -= 15;
SetRect(&bounds,0,0,1,0);
cell.h = cell.v = 0;
list = LNew(&box,&bounds,cell,0,CPDialog,false,false,false,true);
if (list == 0L)
return((cdev_dataH) 1L); // bail out
(**myData).list = list;
(**list).selFlags += lNoExtend + lUseSense;
ReadFiles(list,files);
SetResLoad(true);
InitCursor();
}
else {
myData = cdevStorage; // handle is still locked
files = (**myData).files;
list = (**myData).list;
}
if (message == hitDev) {
SetResLoad(true);
myItem = item - numItems;
if (myItem == bList) {
GlobalToLocal(&(theEvent->where));
LClick(theEvent->where, shiftKey, list);
cell = LLastClick(list);
}
if (myItem == bRevert) {
RevertInfo(list, files);
LUpdate(CPDialog->visRgn, list);
}
if (myItem == bAllOff) {
AllInfo(list, files, false);
LUpdate(CPDialog->visRgn, list);
}
if (myItem == bAllOn) {
AllInfo(list, files, true);
LUpdate(CPDialog->visRgn, list);
}
}
if (message == closeDev) {
SaveInfo(list, files);
DisposHandle((Handle) files);
LDispose(list);
HUnlock((Handle) myData);
DisposHandle((Handle) myData);
myData = 0L;
GetKeys(&keys[0]);
if ((keys[1] & gCommandK) != 0)
ShutDwnStart();
}
if (message == nulDev) {
}
if (message == updateDev) {
if (CPanelID)
SetPort(CPDialog); // redundant but gets rid of warning !!!
DrawDialog(CPDialog);
GetDItem(CPDialog,numItems + bList,&type,&H,&box);
InsetRect(&box,-1,-1);
FrameRect(&box);
LUpdate(CPDialog->visRgn, list);
}
if (message == activDev) {
LActivate(true, list);
}
if (message == deactivDev) {
LActivate(false, list);
}
if (message == macDev) {
myData = (cdev_dataH) 1L;
}
return(myData);
}
// This routine determines whether a file should be added to our INIT list
// or not. If the file is capable of having an INIT then we try to find it,
// otherwise we display it. (i.e. a Finder extension)
Boolean HasINIT(CInfoPBRec *info)
{
short resFile;
register long type;
register short counter, typeCount;
long **InitTypesH, *initType;
Boolean isValid;
FSSpec file;
short err;
Boolean isFolder, wasAlias;
short len, ourFile;
type = info->hFileInfo.ioFlFndrInfo.fdType;
if (info->hFileInfo.ioFlFndrInfo.fdCreator == '7INI') // don't disable ourselves
return(false);
if (info->hFileInfo.ioFlFndrInfo.fdCreator == 'extE') // don't bother with EM Ext.
return(true);
InitTypesH = (long**) GetResource('iNIT',kNeedNoINITID);
if (!InitTypesH) {
*((short*) RomMapInsert) = mapTrue;
InitTypesH = (long**) GetResource('iNIT',kNeedNoINITID);
}
if (!InitTypesH)
return(false);
LoadResource((Handle) InitTypesH);
HLock((Handle) InitTypesH);
initType = *InitTypesH;
typeCount = GetHandleSize((Handle) InitTypesH) / 4L;
for (counter = 0; counter < typeCount; counter++) {
if (type == initType[counter])
return(true); // these files don't need an INIT, just show them
}
InitTypesH = (long**) GetResource('iNIT',kNeedINITID);
InitTypesH = (long**) GetResource('iNIT',kNeedINITID);
if (!InitTypesH) {
*((short*) RomMapInsert) = mapTrue;
InitTypesH = (long**) GetResource('iNIT',kNeedINITID);
}
if (!InitTypesH)
return(false);
LoadResource((Handle) InitTypesH);
HLock((Handle) InitTypesH);
initType = *InitTypesH;
typeCount = GetHandleSize((Handle) InitTypesH) / 4L;
isValid = false;
for (counter = 0; counter < typeCount; counter++) {
if (type == initType[counter]) {
isValid = true;
counter = typeCount + 1; // these files need an INIT
}
}
if (isValid == false)
return(false); // not a valid file
file.vRefNum = info->hFileInfo.ioVRefNum;
file.parID = info->hFileInfo.ioDirID;
len = info->hFileInfo.ioNamePtr[0];
myBlockMove(info->hFileInfo.ioNamePtr, file.name, (long) (len + 1L));
err = ResolveAliasFile(&file, true, &isFolder, &wasAlias);
if (err || isFolder)
return(false); // file not found, or volume not found
SetResLoad(false);
ourFile = CurResFile();
if (info->hFileInfo.ioFRefNum)
resFile = info->hFileInfo.ioFRefNum;
else
resFile = HOpenResFile(file.vRefNum, file.parID,(Str255) file.name, fsCurPerm);
if (resFile != -1) {
SetResLoad(false);
counter = Count1Resources('INIT');
if (info->hFileInfo.ioFRefNum == 0)
CloseResFile(resFile);
SetResLoad(true);
}
UseResFile(ourFile);
SetResLoad(true);
return(counter);
}
// This is the main routine that can go out looking for new files, it calls the appropiate
// routines to fill in the list with the right file names.
void ReadFiles(ListHandle list,InitInfoH files)
{
long **FolderTypesH = 0L;
register short counter, total;
Point cell;
InitInfoPtr pt;
short len;
long enabledFolder, disabledFolder;
Handle H;
LDoDraw(false, list);
len = (**list).dataBounds.bottom;
if (len) {
LDelRow(len,0,list);
SetHandleSize((Handle) files, 0L);
}
FolderTypesH = (long**) GetResource('FTyp',kEMID);
if (!FolderTypesH) {
*((short*) RomMapInsert) = mapTrue;
FolderTypesH = (long**) GetResource('FTyp',kEMID);
}
if (FolderTypesH) {
LoadResource((Handle) FolderTypesH);
HLock((Handle) FolderTypesH);
Add7Folders();
total = GetHandleSize((Handle) FolderTypesH) / 4;
for (counter = 0; counter < total; counter += 2) {
enabledFolder = (*FolderTypesH)[counter];
disabledFolder = (*FolderTypesH)[counter + 1];
AddFolder(files, enabledFolder, disabledFolder,
kUseEnabledFolder);
AddFolder(files, enabledFolder, disabledFolder,
kUseDisabledFolder);
Sort(files, disabledFolder); // sort before inserting in list
}
H = GetResource('iNIT',kNeedNoINITID); // the code to scan a folder
if (H) { // loaded this resources and
LoadResource(H); // left them locked, so
HUnlock(H); // lets release them
ReleaseResource(H);
}
H = GetResource('iNIT',kNeedINITID);
if (H) {
LoadResource(H);
HUnlock(H);
ReleaseResource(H);
}
total = GetHandleSize((Handle) files) / sizeof(InitInfo);
LAddRow(total,0,list);
cell.h = cell.v = 0;
HLock((Handle) files);
pt = *files;
for (counter = 0; counter < total; counter++) {
len = pt->fileName[0];
LSetCell(&(pt->fileName[1]), len, cell, list);
if (pt->enabled)
LSetSelect(true,cell,list);
cell.v++;
pt++;
}
HUnlock((Handle) files);
}
LDoDraw(true, list);
}
// This routine adds all the files in a given folder that have a type
// included in a list to the INIT list.
void AddFolder(InitInfoH files, long GoodFolder, long DisFolder, Boolean useEnabledF)
{
register short index;
short err, vRefNum;
long EnabledDirID, DisabledDirID;
CInfoPBRec info;
InitInfo anInit;
long offset;
long testDirID;
err = FindFolder(kOnSystemDisk, GoodFolder, kCreateFolder, &vRefNum, &EnabledDirID);
if (err)
return;
err = FindFolder(kOnSystemDisk, DisFolder, kCreateFolder, &vRefNum, &DisabledDirID);
if (err)
return;
if (useEnabledF)
testDirID = EnabledDirID;
else
testDirID = DisabledDirID;
index = 0;
info.hFileInfo.ioCompletion = 0L;
info.hFileInfo.ioNamePtr = (StringPtr) anInit.fileName;
info.hFileInfo.ioVRefNum = vRefNum;
anInit.vRefNum = vRefNum;
anInit.enabledDirID = EnabledDirID;
anInit.disabledDirID = DisabledDirID;
anInit.enabled = useEnabledF;
offset = GetHandleSize((Handle) files);
while (!err) {
index++;
info.hFileInfo.ioFDirIndex = index;
info.hFileInfo.ioDirID = testDirID;
info.hFileInfo.ioFlAttrib = 0;
info.hFileInfo.ioFlFndrInfo.fdFlags = 0;
info.hFileInfo.ioFRefNum = 0;
err = PBGetCatInfo(&info,false);
if (!err) {
if ((info.hFileInfo.ioFlAttrib & 16) == 0) {
anInit.creator = info.hFileInfo.ioFlFndrInfo.fdCreator;
info.hFileInfo.ioDirID = testDirID;
if (HasINIT(&info)) {
Munger((Handle) files,offset,(Ptr) 2L,0L,
(Ptr) &anInit,(long) sizeof(anInit));
offset += sizeof(anInit);
}
}
}
}
}
// We make sure that we have our "(Disabled)" folders available, if not we
// setup the system so we that we can use them.
// To do that we load our 'fld#' resource and check every folder type and
// name we have specified. If the folder type is not there
// then we also need to add it into the system's fld#.
void Add7Folders(void)
{
short vRefNum;
long dirID;
Handle sysH, ourH;
long sysSize, ourSize, fldSize;
short err;
Ptr fldPtr;
register short counter;
long folderType;
Boolean changed = false;
sysH = GetResource('fld#', 0);
ourH = GetResource('fld#', kEMID);
if (ourH == 0L) {
*((short*) RomMapInsert) = mapTrue;
ourH = GetResource('fld#', kEMID);
}
if ((sysH == 0L) || (ourH == 0L))
return;
LoadResource(sysH);
LoadResource(ourH);
HLock(ourH);
fldSize = GetHandleSize(ourH); // we have to keep track of size
fldPtr = *ourH;
sysSize = GetHandleSize(sysH);
for (counter = 0; counter < fldSize; ) {
myBlockMove(fldPtr, &folderType, 4L); // get type
ourSize = 8 + fldPtr[7]; // add type, id, string len
if (ourSize % 2)
ourSize++; // string is padded !
err = FindFolder(kOnSystemDisk, folderType, kCreateFolder, &vRefNum, &dirID);
if (err) { // need to add our folder
Munger(sysH, sysSize, (Ptr) 2L, 0L, fldPtr, ourSize);
sysSize += ourSize;
changed = true;
}
fldPtr += (Ptr) ourSize; // add offset to next fld# entry
counter += ourSize; // add bytes scanned from fld# entry
}
if (changed) {
ChangedResource(sysH);
WriteResource(sysH);
UpdateResFile(0); // update the system
sysH = GetResource('fld#', 0);
}
ReleaseResource(ourH);
}
// This is a very custom sorting rotuine, it takes the disabled folder id to match
// files agains it, it first finds the start of the folder type so that it can compare
// the disabled ones with the enabled ones and insert them at the right position.
// It also knows that it gets called after each folder type insert, so the end of the
// insert list is always the total number of records.
void Sort(InitInfoH files, long folder)
{
short startIndex, endIndex, sortStart;
register short counter, counter2;
register InitInfoPtr inits;
InitInfo tempInfo;
long dirID;
short vRefNum;
if (FindFolder(kOnSystemDisk, folder, kDontCreateFolder, &vRefNum, &dirID))
return;
HLock((Handle) files);
inits = *files;
endIndex = GetHandleSize((Handle) files) / sizeof(InitInfo);
for (counter = 0; counter < endIndex; counter++) { // find the start of this folder
if (inits[counter].disabledDirID == dirID) {
startIndex = counter;
break;
}
}
if (counter == endIndex) {
HUnlock((Handle) files); // there was only one new extension
return;
}
sortStart = startIndex;
while ((inits[sortStart].enabled) && (sortStart < endIndex))
sortStart++; // skip enabled
if (sortStart == endIndex) {
HUnlock((Handle) files); // there was only enabled extensions
return;
}
while (sortStart < endIndex) {
for (counter = startIndex; counter < endIndex; counter++) {
if (sortStart == counter) { // checking against ourselves ?
startIndex++;
sortStart++; // we are the end of it.
break;
}
else {
if (MyCompare((unsigned char*) inits[sortStart].fileName,
(unsigned char*) inits[counter].fileName)) { // a < b
tempInfo = inits[sortStart];
for (counter2 = sortStart; counter2 > counter; counter2--) {
inits[counter2] = inits[counter2 - 1];
}
inits[counter] = tempInfo;
startIndex++; // skip at least one more from enabled, since it was sorted already
break;
}
}
}
sortStart++; // one less from the disabled folder
}
HUnlock((Handle) files);
}
//
// This routine makes permanent the changes the user has made, we look at the
// "enabled" flag and compare this with the current higlight state, that way we
// can tell if the file needs to be moved from one folder to the other.
void SaveInfo(ListHandle list,InitInfoH files)
{
register short counter, total, err;
Point cell;
CMovePBRec info;
Boolean toggle;
InitInfo *initPtr;
total = GetHandleSize((Handle) files) / sizeof(InitInfo);
HLock((Handle) files);
cell.h = cell.v = 0;
for (counter = 0; counter < total; counter++) {
cell.v = counter;
toggle = false;
if (LGetSelect(false,&cell,list)) {
if (((*files)[counter]).enabled == false) {
toggle = true;
((*files)[counter]).enabled = true;
}
}
else {
if (((*files)[counter]).enabled) {
toggle = true;
((*files)[counter]).enabled = false;
}
}
if (toggle) {
initPtr = &((*files)[counter]);
info.ioCompletion = 0L;
info.ioNamePtr = initPtr->fileName;
info.ioNewName = 0L;
info.ioVRefNum = initPtr->vRefNum;
if (initPtr->enabled) {
info.ioDirID = initPtr->disabledDirID;
info.ioNewDirID = initPtr->enabledDirID;
}
else {
info.ioDirID = initPtr->enabledDirID;
info.ioNewDirID = initPtr->disabledDirID;
}
err = PBCatMove(&info,false);
if (err)
ErrDlg(duplicateDlg);
}
}
HUnlock((Handle) files);
}
//
// This function reverts the higlight state of each file to what the "enabled" flag
// was, since that flag indicates to us what folder the file comes from.
void RevertInfo(ListHandle list,InitInfoH files)
{
register short counter, total;
Point cell;
LDoDraw(false, list);
total = GetHandleSize((Handle) files) / sizeof(InitInfo);
HLock((Handle) files);
cell.h = cell.v = 0;
for (counter = 0; counter < total; counter++) {
cell.v = counter;
if (((*files)[counter]).enabled)
LSetSelect(true,cell,list);
else
LSetSelect(false,cell,list);
}
HUnlock((Handle) files);
LDoDraw(true, list);
}
//
// This function set all of the files either on or off
void AllInfo(ListHandle list,InitInfoH files, Boolean on)
{
register short counter, total;
Point cell;
LDoDraw(false, list);
total = GetHandleSize((Handle) files) / sizeof(InitInfo);
cell.h = cell.v = 0;
for (counter = 0; counter < total; counter++) {
cell.v = counter;
LSetSelect(on, cell, list);
}
LDoDraw(true, list);
}
/*
This routine shows a dialog box with the id given to it and waits for the
user to click the OK button. Mainly to show error dialogs.
*/
void ErrDlg(id)
short id;
{
GrafPtr savePort;
DialogPtr aDialog;
DialogRecord d;
short item;
Handle H;
Rect box;
GetPort(&savePort);
aDialog = GetNewDialog(id, &d, (WindowPtr) -1L);
if (!aDialog) {
*((short*) RomMapInsert) = mapTrue;
aDialog = GetNewDialog(id, &d, (WindowPtr) -1L);
}
if (!aDialog) {
SysBeep(1);
return;
}
SetPort(aDialog);
item = kUpdateCode;
InitCursor();
while (item != okItem) {
if (item == kUpdateCode) {
BeginUpdate(aDialog);
GetDItem(aDialog,okItem,&item,&H,&box);
InsetRect(&box,-4,-4);
DrawDialog(aDialog);
PenSize(3,3);
FrameRoundRect(&box,16,16);
EndUpdate(aDialog);
}
ModalDialog(UpdateFilter, &item);
}
CloseDialog(aDialog);
SetPort(savePort);
}
pascal Boolean UpdateFilter(DialogPtr theDialog,EventRecord *theEvent,short *item)
{
char theChar;
long delayed;
short type;
Rect box;
Handle H;
if (theEvent->what == updateEvt) {
*item = kUpdateCode; /* A special code so I can update screen */
return(true);
}
if ((theEvent->what == keyDown) || (theEvent->what == autoKey)) {
theChar = theEvent->message & charCodeMask;
if ((theChar == 13) || (theChar == 3)) {
*item = okItem; // or default item, one anyway
GetDItem(theDialog, okItem, &type, &H, &box);
HiliteControl((ControlHandle) H, 1);
Delay(8L, &delayed);
HiliteControl((ControlHandle) H, 0);
return(true);
}
}
return(false);
}
// faster than calling the real blockmove when the data you usually copy
// is small
void myBlockMove(void *source, void *destination, long count)
{
register Ptr s, d;
s = source;
d = destination;
while (count) {
*d++ = *s++;
count--;
}
}
// This function returns true if the first string has precedence over the second one
// otherwise it returns false. Not a very good routine when it comes to International
Boolean MyCompare(unsigned char *a, unsigned char *b)
{
register short len, counter = 1;
register char theCharA, theCharB;
len = a[0];
if (len > b[0])
len = b[0]; // compare up to the smallest common length
while (len) {
theCharA = a[counter];
theCharB = b[counter];
if ((theCharA >= 'a') && (theCharA <= 'z'))
theCharA -= 32; // make it lowercase
if ((theCharB >= 'a') && (theCharB <= 'z'))
theCharB -= 32; // make it lowercase
if (theCharA < theCharB)
return(true);
if (theCharA > theCharB)
return(false);
counter++;
len--;
}
if (a[0] < b[0])
return(true);
return(false); // equal strings, or b is longer string
}
Reference in New Issue View Git Blame Copy Permalink