uuUndo/DSUtilsASG.c
2015-02-06 00:56:41 -08:00

1 line
18 KiB
C

#include <Folders.h>
#include <ImageCompression.h>
#include <AppleEvents.h>
#include "DSDialogs.h"
#include "DSUserProcs.h"
#include "DSUtilsASG.h"
PrefsHandle gPrefs = nil;
Prefs gDefaultPrefs = {
kVersion,
false,
false,
{ 0, 0 },
{ 0, 0 }
};
Handle gMapResource = nil;
extern void DoMenu ( long retVal );
#define kPrefsFileName "\puuUndo Preferences"
static Fixed gProgressPercent = 0;
//=====================================================================================
// pascal OSErr GenericProgress(short theMessage, Fixed thePercent, long refCon)
//=====================================================================================
// Generic progress procedure, which displays a dialog with a progress bar and a cancel
// button. This function can be called as often as desired; the display is never
// updated more than 6 times/second.
//=====================================================================================
pascal OSErr GenericProgress(short theMessage, Fixed thePercent, long refCon)
{
static UserItemUPP gUpdateBar = nil;
static DialogPtr gTheDialog = nil;
static long gLastTime;
OSErr theErr = noErr;
GrafPtr oldPort;
Point thePoint;
long ticks;
GetPort(&oldPort);
switch (theMessage) {
case codecProgressOpen:
if (gTheDialog = GetNewDialog(rProgressDialog, nil, (WindowPtr)-1)) {
SetPort(gTheDialog);
// set up the user item handler, either for indefinite progress
// (thePercent == kIndefProgress) or for standard progress
if (!gUpdateBar) gUpdateBar = NewUserItemProc((ProcPtr)UpdateBar);
SetItemHandle(gTheDialog, progressUser, (Handle)gUpdateBar);
SetWindowPosition(gTheDialog, (*gPrefs)->progressLoc);
UserDialogActivate(FrontWindow(), false);
ShowWindow(gTheDialog);
DrawDialog(gTheDialog);
}
// reset the last time so that we draw right away, and update the initial
// percentage
gLastTime = 0;
theErr = GenericProgress(codecProgressForceUpdatePercent, 0, refCon);
break;
case codecProgressForceUpdatePercent:
gLastTime = 0;
case codecProgressUpdatePercent:
if (gTheDialog) {
// update our user item no more than 3x a second; do this by setting the
// gProgressPercent global, and forcing an update of the bar userItem
if ((TickCount() - gLastTime) < 10L) break;
gLastTime = TickCount();
gProgressPercent = thePercent;
UpdateDialogItem(gTheDialog, progressUser);
}
break;
case codecProgressClose:
// display the final percentage and delay for an instant
GenericProgress(codecProgressForceUpdatePercent, 0x10000, refCon);
Delay(1, &ticks);
GetWindowPosition(gTheDialog, &thePoint);
(*gPrefs)->progressLoc = thePoint;
if (gTheDialog) DisposeDialog(gTheDialog);
gTheDialog = nil;
UserDialogActivate(FrontWindow(), true);
break;
}
// restore the original port and check for aborts
SetPort(oldPort);
if (theErr == noErr && theMessage != codecProgressForceUpdatePercent) theErr = (CheckAbort()) ? codecAbortErr : noErr;
// if there was an abort signalled, and the dialog is visible, hide it immediately
// to give better user feedback
if (theErr == codecAbortErr && gTheDialog && ((WindowPeek)gTheDialog)->visible) HideWindow(gTheDialog);
return theErr;
}
/*
* CheckAbort()
*
* Purpose: Scans the event queue for an aborting keypress
* Inputs: none
* Returns: true if we should abort
*
*/
Boolean CheckAbort()
{
static long gLastTime = 0;
Boolean aborted = false, callWNE = false;
EventRecord theEvent;
GrafPtr oldPort;
// if we're not in the background, ensure that we get at least 2 ticks of continuous
// operation before giving up a full amount of time to others
if ((TickCount() - gLastTime) >= 5) callWNE = true;
GetPort(&oldPort);
SetPort(FrontWindow());
// get the next event; if sleepTime is zero, check event availability first
if (callWNE || EventAvail(everyEvent, &theEvent)) {
// handle any pending events normally
while (WaitNextEvent(everyEvent, &theEvent, 0, nil)) {
// dispatch the event as appropriate
switch (theEvent.what) {
case mouseDown:
aborted = HandleAbortMouseDown(&theEvent);
break;
case keyDown:
case autoKey:
aborted = HandleAbortKeyDown(&theEvent);
break;
case updateEvt:
SetPort((WindowPtr)theEvent.message);
BeginUpdate((WindowPtr)theEvent.message);
if (((WindowPeek)theEvent.message)->windowKind == dialogKind)
UpdtDialog((DialogPtr)theEvent.message, ((DialogPtr)theEvent.message)->visRgn);
EndUpdate((WindowPtr)theEvent.message);
break;
case kHighLevelEvent:
gProcessing = true;
AEProcessAppleEvent(&theEvent);
gProcessing = false;
break;
}
}
if (callWNE) gLastTime = TickCount();
}
SetPort(oldPort);
return aborted;
}
Boolean GiveTime()
{
EventRecord theEvent;
GrafPtr oldPort;
GetPort(&oldPort);
SetPort(FrontWindow());
// handle any pending events normally
while (WaitNextEvent(everyEvent & ~(mDownMask + keyDownMask + autoKeyMask), &theEvent, 0, nil)) {
// dispatch the event as appropriate
switch (theEvent.what) {
case updateEvt:
SetPort((WindowPtr)theEvent.message);
BeginUpdate((WindowPtr)theEvent.message);
if (((WindowPeek)theEvent.message)->windowKind == dialogKind)
UpdtDialog((DialogPtr)theEvent.message, ((DialogPtr)theEvent.message)->visRgn);
EndUpdate((WindowPtr)theEvent.message);
break;
case kHighLevelEvent:
gProcessing = true;
AEProcessAppleEvent(&theEvent);
gProcessing = false;
break;
}
}
SetPort(oldPort);
return true;
}
Boolean HandleAbortMouseDown(EventRecord *theEvent)
{
Boolean aborted = false;
// handle dialog events properly; if button 3 was hit on the progress dialog,
// we abort the drawing
if (IsDialogEvent(theEvent)) {
DialogPtr theDialog;
short itemHit;
SetCursor(&qd.arrow);
if (DialogSelect(theEvent, &theDialog, &itemHit)) {
if (GetWRefCon(theDialog) == kProgressDialogID && itemHit == progressCancel) return true;
return false;
}
}
// otherwise, do it the hard way....
else {
WindowPtr theWindow;
short thePart = FindWindow(theEvent->where, &theWindow);
// track dragging and menus as normal; check specially for clicks in
// the slide show controls floating window, and beep about everything else
switch (thePart) {
case inDrag:
if (theWindow == FrontWindow()) DragWindow(theWindow, theEvent->where, &qd.screenBits.bounds);
break;
case inMenuBar:
SetCursor(&qd.arrow);
DoMenu ( MenuSelect ( theEvent->where ));
break;
default:
SysBeep(1);
break;
}
}
return aborted;
}
Boolean HandleAbortKeyDown(EventRecord *theEvent)
{
char theChar = theEvent->message & charCodeMask;
DialogPtr theDialog = FrontWindow();
Boolean aborted = false;
if (GetWRefCon(theDialog) == kProgressDialogID) {
// if escape, set the proper abort flag
if (((theEvent->modifiers & cmdKey) && theChar == '.') || theChar == 0x1b) {
long ticks;
aborted = true;
HiliteDControl(theDialog, progressCancel, 1);
Delay(8, &ticks);
HiliteDControl(theDialog, progressCancel, 0);
}
}
return aborted;
}
//=====================================================================================
// pascal void UpdateBar(DialogPtr theDialog, short theItem)
//=====================================================================================
// Draws the progress bar for the generic progress dialog, according to the percentage
// stored in the global gProgressPercent.
//=====================================================================================
pascal void UpdateBar(DialogPtr theDialog, short theItem)
{
static RGBColor gBarBackground = { 0xcccc, 0xcccc, 0xffff };
static RGBColor gBarForeground = { 0x4000, 0x4000, 0x4000 };
static RGBColor gBlack = { 0x0000, 0x0000, 0x0000 };
static RGBColor gWhite = { 0xffff, 0xffff, 0xffff };
Boolean useBW = !(((CGrafPtr)theDialog)->portVersion & 0xc000) || (*((CGrafPtr)theDialog)->portPixMap)->pixelSize == 1;
Rect itemRect, leftRect, rightRect;
Handle itemHandle;
GrafPtr oldPort;
Fixed thePercent;
short itemType;
GetPort(&oldPort);
SetPort(theDialog);
thePercent = gProgressPercent;
GetDItem(theDialog, theItem, &itemType, &itemHandle, &itemRect);
PenSize(1, 1);
if (useBW) PenPat(&qd.black);
else RGBForeColor(&gBlack);
FrameRect(&itemRect);
InsetRect(&itemRect, 1, 1);
rightRect = leftRect = itemRect;
leftRect.right = itemRect.left + FixRound(FixMul(thePercent, Long2Fix(itemRect.right - itemRect.left)));
rightRect.left = leftRect.right;
if (leftRect.right > leftRect.left) {
if (useBW) PenPat(&qd.black);
else RGBForeColor(&gBarForeground);
PaintRect(&leftRect);
}
if (rightRect.left < rightRect.right) {
if (useBW) PenPat(&qd.white);
else RGBForeColor(&gBarBackground);
PaintRect(&rightRect);
}
if (useBW) PenPat(&qd.black);
else RGBForeColor(&gBlack);
SetPort(oldPort);
}
void SetItemHandle(DialogPtr theDialog, short theItem, Handle newHandle)
{
Handle itemHandle;
short itemType;
Rect itemRect;
GetDItem(theDialog, theItem, &itemType, &itemHandle, &itemRect);
SetDItem(theDialog, theItem, itemType, newHandle, &itemRect);
}
Handle GetItemHandle(DialogPtr theDialog, short theItem)
{
Handle itemHandle;
short itemType;
Rect itemRect;
GetDItem(theDialog, theItem, &itemType, &itemHandle, &itemRect);
return itemHandle;
}
void UpdateDialogItem(DialogPtr theDialog, short theItem)
{
Handle itemHandle;
RgnHandle theRgn;
short itemType;
Rect itemRect;
GrafPtr oldPort;
if (theRgn = NewRgn()) {
GetPort(&oldPort);
SetPort(theDialog);
GetDItem(theDialog, theItem, &itemType, &itemHandle, &itemRect);
RectRgn(theRgn, &itemRect);
UpdateDialog(theDialog, theRgn);
SetPort(oldPort);
DisposeRgn(theRgn);
}
}
void HiliteDControl(DialogPtr theDialog, short theItem, short theVal)
{
Handle itemHandle;
short itemType;
Rect itemRect;
GrafPtr oldPort;
GetPort(&oldPort);
SetPort(theDialog);
GetDItem(theDialog, theItem, &itemType, &itemHandle, &itemRect);
HiliteControl((ControlHandle)itemHandle, theVal);
SetPort(oldPort);
}
//==================================================================================================================================
// OSErr LoadPrefsHandle(OSType type, short index, Handle *theHandle)
//==================================================================================================================================
// Reads the specified resource from the Pathmaker preferences file.
//==================================================================================================================================
OSErr LoadPrefsHandle(OSType type, short index, Handle *theHandle)
{
return LoadHandleFromResource(GetPrefsSpec(), type, index, theHandle);
}
//==================================================================================================================================
// OSErr SavePrefsHandle(OSType type, short index, Handle theHandle, short *id)
//==================================================================================================================================
// Saves the specified handle to the Pathmaker preferences file as a resource.
//==================================================================================================================================
OSErr SavePrefsHandle(OSType type, short index, Handle theHandle, short *id)
{
return SaveHandleAsResource(GetPrefsSpec(), 'pref', type, index, theHandle, id);
}
//==================================================================================================================================
// OSErr LoadHandleFromResource(FSSpec *file, OSType type, short index, Handle *theHandle)
// OSErr LoadHandleFromResource(short theFile, OSType type, short index, Handle *theHandle)
//==================================================================================================================================
// Reads the specified resource from the given file file and detaches it.
//==================================================================================================================================
OSErr LoadHandleFromResource(FSSpec *file, OSType type, short index, Handle *theHandle)
{
OSErr theErr = noErr;
short theFile = FSpOpenResFile(file, fsRdPerm);
if (theFile != -1) {
theErr = LoadHandleFromResource(theFile, type, index, theHandle);
CloseResFile(theFile);
} else theErr = ResError();
return theErr;
}
OSErr LoadHandleFromResource(short theFile, OSType type, short index, Handle *theHandle)
{
short oldRes = CurResFile();
UseResFile(theFile);
OSErr theErr = noErr;
if (*theHandle = Get1Resource(type, index)) DetachResource(*theHandle);
else theErr = fnfErr; // need to signal something since ResError() == 0
UseResFile(oldRes);
return theErr;
}
//==================================================================================================================================
// OSErr SaveHandleAsResource(FSSpec *file, OSType fileType, OSType type, short index, Handle *theHandle, short *id)
// OSErr SaveHandleAsResource(short theFile, OSType type, short index, Handle theHandle, short *id)
//==================================================================================================================================
// Writes the specified handle to the given file as a resource.
//==================================================================================================================================
OSErr SaveHandleAsResource(FSSpec *file, OSType fileType, OSType type, short index, Handle theHandle, short *id)
{
OSErr theErr = noErr;
FSpCreateResFile(file, kCreator, fileType, 0);
short theFile = FSpOpenResFile(file, fsRdWrPerm);
if (theFile != -1) {
theErr = SaveHandleAsResource(theFile, type, index, theHandle, id);
CloseResFile(theFile);
} else theErr = ResError();
return theErr;
}
OSErr SaveHandleAsResource(short theFile, OSType type, short index, Handle theHandle, short *id)
{
short oldRes = CurResFile();
UseResFile(theFile);
OSErr theErr = noErr;
if (id) *id = index;
Handle oldResource = Get1Resource(type, index);
if (oldResource) {
RmveResource(oldResource);
theErr = ResError();
if (theErr == noErr) {
DisposeHandle(oldResource);
UpdateResFile(theFile);
} else ReleaseResource(oldResource);
}
if (theErr == noErr) {
AddResource(theHandle, type, index, (StringPtr)"\p");
theErr = ResError();
if (theErr == noErr) {
WriteResource(theHandle);
theErr = ResError();
if (theErr == noErr) {
UpdateResFile(theFile);
theErr = ResError();
}
DetachResource(theHandle);
}
}
UseResFile(oldRes);
return theErr;
}
//==================================================================================================================================
// FSSpec *GetPrefsSpec(void)
//==================================================================================================================================
// Returns an FSSpec pointing to our preferences file.
//==================================================================================================================================
FSSpec *GetPrefsSpec(void)
{
static FSSpec theSpec = { 0, 0, "\p" };
if (!*theSpec.name) {
FindFolder(kOnSystemDisk, kPreferencesFolderType, kCreateFolder, &theSpec.vRefNum, &theSpec.parID);
FSMakeFSSpec(theSpec.vRefNum, theSpec.parID, kPrefsFileName, &theSpec);
}
return &theSpec;
}
void LoadPrefs(void)
{
Handle theHandle;
OSErr theErr = LoadPrefsHandle('Pref', 0, &theHandle);
if (theErr != noErr) {
theErr = PtrToHand(&gDefaultPrefs, &theHandle, sizeof(Prefs));
theErr = SavePrefsHandle('Pref', 0, theHandle);
}
gPrefs = (PrefsHandle)theHandle;
theErr = LoadPrefsHandle('E2Ty', 0, &theHandle);
if (theErr != noErr) {
theHandle = Get1Resource('E2Ty', 0);
if (theHandle) {
DetachResource(theHandle);
theErr = SavePrefsHandle('E2Ty', 0, theHandle);
}
}
gMapResource = theHandle;
}
void SavePrefs(void)
{
OSErr theErr = SavePrefsHandle('Pref', 0, (Handle)gPrefs);
if (theErr == noErr) theErr = SavePrefsHandle('E2Ty', 0, gMapResource);
}
void SetWindowPosition(WindowPtr theWindow, Point thePosition)
{
Point centerPos;
Rect monRect;
if (gHasCQD) monRect = (*GetMainDevice())->gdRect;
else monRect = qd.screenBits.bounds;
centerPos.h = (monRect.right - monRect.left) - (theWindow->portRect.right - theWindow->portRect.left);
centerPos.v = (monRect.bottom - monRect.top) - (theWindow->portRect.bottom - theWindow->portRect.top);
centerPos.h /= 2;
centerPos.v /= 3;
centerPos.h += monRect.left;
centerPos.v += monRect.top + 20;
if (thePosition.h || thePosition.v) {
Rect newRect = theWindow->portRect;
RgnHandle theRgn;
OffsetRect(&newRect, thePosition.h - newRect.left, thePosition.v - newRect.top);
if (theRgn = NewRgn()) {
SetRectRgn(theRgn, newRect.left + 4, newRect.top - 20 + 4, newRect.right - 4, newRect.top - 4);
SectRgn(theRgn, GetGrayRgn(), theRgn);
if (EmptyRgn(theRgn)) thePosition = centerPos;
DisposeRgn(theRgn);
}
} else thePosition = centerPos;
MoveWindow(theWindow, thePosition.h, thePosition.v, false);
}
void GetWindowPosition(WindowPtr theWindow, Point *thePosition)
{
GrafPtr oldPort;
GetPort(&oldPort);
SetPort(theWindow);
thePosition->h = thePosition->v = 0;
LocalToGlobal(thePosition);
SetPort(oldPort);
}
void ForceFolderUpdate(long dirID, short vRefNum)
{
static CInfoPBRec block;
block.hFileInfo.ioCompletion = nil;
block.hFileInfo.ioNamePtr = nil;
block.hFileInfo.ioVRefNum = vRefNum;
block.hFileInfo.ioDirID = dirID;
block.hFileInfo.ioFDirIndex = -1;
PBGetCatInfoAsync(&block);
while (block.hFileInfo.ioResult == 1) GiveTime();
GetDateTime(&block.dirInfo.ioDrMdDat);
PBSetCatInfoAsync(&block);
// while (block.hFileInfo.ioResult == 1) GiveTime();
}