mirror of
https://github.com/softdorothy/GliderPRO.git
synced 2024-11-22 20:31:19 +00:00
7a70d18ba6
Sources for Glider PRO, a Macintosh game written by John Calhoun and published by Casady & Greene, Inc. I believe it was using CodeWarrior IDE to create a fat (68K and PowerPC) binary.
1 line
23 KiB
C
Executable File
1 line
23 KiB
C
Executable File
//============================================================================
|
|
//----------------------------------------------------------------------------
|
|
// DialogUtils.c
|
|
//----------------------------------------------------------------------------
|
|
//============================================================================
|
|
|
|
|
|
#include <ControlDefinitions.h>
|
|
#include <LowMem.h>
|
|
#include <NumberFormatting.h>
|
|
#include "DialogUtils.h"
|
|
#include "Externs.h"
|
|
|
|
|
|
#define kActive 0
|
|
#define kInactive 255
|
|
|
|
|
|
//============================================================== Functions
|
|
//-------------------------------------------------------------- BringUpDialog
|
|
// Given a dialog pointer and a resource ID, this function brings it upÉ
|
|
// centered, visible, and with the default button outlined.
|
|
|
|
void BringUpDialog (DialogPtr *theDialog, short dialogID)
|
|
{
|
|
// CenterDialog(dialogID);
|
|
*theDialog = GetNewDialog(dialogID, nil, kPutInFront);
|
|
if (*theDialog == nil)
|
|
RedAlert(kErrDialogDidntLoad);
|
|
SetPort((GrafPtr)*theDialog);
|
|
ShowWindow(GetDialogWindow(*theDialog));
|
|
DrawDefaultButton(*theDialog);
|
|
}
|
|
|
|
//-------------------------------------------------------------- GetPutDialogCorner
|
|
// Determines the upper left corner coordinates needed to properly centerÉ
|
|
// the standard Mac PutFile dialog (when you save files).
|
|
/*
|
|
void GetPutDialogCorner (Point *theCorner)
|
|
{
|
|
DialogTHndl dlogHandle;
|
|
Rect theScreen, dlogBounds;
|
|
Byte wasState;
|
|
|
|
theCorner->h = 64;
|
|
theCorner->v = 64;
|
|
theScreen = qd.screenBits.bounds;
|
|
theScreen.top += LMGetMBarHeight();
|
|
OffsetRect(&theScreen, -theScreen.left, -theScreen.top);
|
|
|
|
dlogHandle = (DialogTHndl)GetResource('DLOG', sfPutDialogID);
|
|
if (dlogHandle != nil)
|
|
{
|
|
wasState = HGetState((Handle)dlogHandle);
|
|
HLock((Handle)dlogHandle);
|
|
|
|
dlogBounds = (**dlogHandle).boundsRect;
|
|
OffsetRect(&dlogBounds, -dlogBounds.left, -dlogBounds.top);
|
|
|
|
theCorner->h = (theScreen.right - dlogBounds.right) / 2;
|
|
theCorner->v = (theScreen.bottom - dlogBounds.bottom) / 3;
|
|
|
|
HSetState((Handle)dlogHandle, wasState);
|
|
}
|
|
theCorner->v += LMGetMBarHeight();
|
|
}
|
|
*/
|
|
|
|
//-------------------------------------------------------------- GetPutDialogCorner
|
|
// Determines the upper left corner coordinates needed to properly centerÉ
|
|
// the standard Mac GetFile dialog (when you open files).
|
|
/*
|
|
void GetGetDialogCorner (Point *theCorner)
|
|
{
|
|
DialogTHndl dlogHandle;
|
|
Rect theScreen, dlogBounds;
|
|
Byte wasState;
|
|
|
|
theCorner->h = 64;
|
|
theCorner->v = 64;
|
|
theScreen = qd.screenBits.bounds;
|
|
theScreen.top += LMGetMBarHeight();
|
|
OffsetRect(&theScreen, -theScreen.left, -theScreen.top);
|
|
|
|
dlogHandle = (DialogTHndl)GetResource('DLOG', sfGetDialogID);
|
|
if (dlogHandle != nil)
|
|
{
|
|
wasState = HGetState((Handle)dlogHandle);
|
|
HLock((Handle)dlogHandle);
|
|
|
|
dlogBounds = (**dlogHandle).boundsRect;
|
|
OffsetRect(&dlogBounds, -dlogBounds.left, -dlogBounds.top);
|
|
|
|
theCorner->h = (theScreen.right - dlogBounds.right) / 2;
|
|
theCorner->v = (theScreen.bottom - dlogBounds.bottom) / 3;
|
|
|
|
HSetState((Handle)dlogHandle, wasState);
|
|
}
|
|
theCorner->v += LMGetMBarHeight();
|
|
}
|
|
*/
|
|
//-------------------------------------------------------------- CenterDialog
|
|
// Given a resource ID for a dialog, this function properly centers it.
|
|
/*
|
|
void CenterDialog (SInt16 dialogID)
|
|
{
|
|
DialogTHndl dlogHandle;
|
|
Rect theScreen, dlogBounds;
|
|
SInt16 hPos, vPos;
|
|
Byte wasState;
|
|
|
|
theScreen = qd.screenBits.bounds;
|
|
theScreen.top += LMGetMBarHeight();
|
|
|
|
dlogHandle = (DialogTHndl)GetResource('DLOG', dialogID);
|
|
if (dlogHandle != nil)
|
|
{
|
|
wasState = HGetState((Handle)dlogHandle);
|
|
HLock((Handle)dlogHandle);
|
|
|
|
dlogBounds = (**dlogHandle).boundsRect;
|
|
OffsetRect(&dlogBounds, -dlogBounds.left, -dlogBounds.top);
|
|
|
|
hPos = ((theScreen.right - theScreen.left) - dlogBounds.right) / 2;
|
|
vPos = ((theScreen.bottom - theScreen.top) - dlogBounds.bottom) / 3;
|
|
|
|
OffsetRect(&dlogBounds, hPos, vPos + LMGetMBarHeight());
|
|
|
|
(**dlogHandle).boundsRect = dlogBounds;
|
|
HSetState((Handle)dlogHandle, wasState);
|
|
}
|
|
}
|
|
*/
|
|
//-------------------------------------------------------------- GetDialogRect
|
|
// Determines the bounding rectangle for a given dialog.
|
|
|
|
void GetDialogRect (Rect *bounds, short dialogID)
|
|
{
|
|
DialogTHndl dlogHandle;
|
|
Byte wasState;
|
|
|
|
dlogHandle = (DialogTHndl)GetResource('DLOG', dialogID);
|
|
if (dlogHandle != nil)
|
|
{
|
|
wasState = HGetState((Handle)dlogHandle);
|
|
HLock((Handle)dlogHandle);
|
|
|
|
*bounds = (**dlogHandle).boundsRect;
|
|
HSetState((Handle)dlogHandle, wasState);
|
|
}
|
|
}
|
|
|
|
//-------------------------------------------------------------- TrueCenterDialog
|
|
// Places a dialog DEAD CENTER (as opposed to 1/3 of the way down asÉ
|
|
// is common for Mac dialog centering).
|
|
/*
|
|
void TrueCenterDialog (short dialogID)
|
|
{
|
|
DialogTHndl dlogHandle;
|
|
Rect theScreen, dlogBounds;
|
|
short hPos, vPos;
|
|
Byte wasState;
|
|
|
|
theScreen = qd.screenBits.bounds;
|
|
theScreen.top += LMGetMBarHeight();
|
|
|
|
dlogHandle = (DialogTHndl)GetResource('DLOG', dialogID);
|
|
if (dlogHandle != nil)
|
|
{
|
|
wasState = HGetState((Handle)dlogHandle);
|
|
HLock((Handle)dlogHandle);
|
|
|
|
dlogBounds = (**dlogHandle).boundsRect;
|
|
OffsetRect(&dlogBounds, theScreen.left - dlogBounds.left,
|
|
theScreen.top - dlogBounds.top);
|
|
|
|
hPos = ((theScreen.right - theScreen.left) -
|
|
(dlogBounds.right - dlogBounds.left)) / 2;
|
|
vPos = ((theScreen.bottom - theScreen.top) -
|
|
(dlogBounds.bottom - dlogBounds.top)) / 2;
|
|
|
|
OffsetRect(&dlogBounds, hPos, vPos + LMGetMBarHeight());
|
|
|
|
(**dlogHandle).boundsRect = dlogBounds;
|
|
HSetState((Handle)dlogHandle, wasState);
|
|
}
|
|
}
|
|
*/
|
|
//-------------------------------------------------------------- CenterAlert
|
|
// Given an alert ID, this function properly centers it on the main monitor.
|
|
/*
|
|
void CenterAlert (short alertID)
|
|
{
|
|
AlertTHndl alertHandle;
|
|
Rect theScreen, alertRect;
|
|
short horiOff, vertOff;
|
|
Byte wasState;
|
|
|
|
theScreen = qd.screenBits.bounds;
|
|
theScreen.top += LMGetMBarHeight();
|
|
|
|
alertHandle = (AlertTHndl)GetResource('ALRT', alertID);
|
|
if (alertHandle != nil)
|
|
{
|
|
wasState = HGetState((Handle)alertHandle);
|
|
HLock((Handle)alertHandle);
|
|
|
|
alertRect = (**alertHandle).boundsRect;
|
|
OffsetRect(&alertRect, -alertRect.left, -alertRect.top);
|
|
|
|
horiOff = ((theScreen.right - theScreen.left) - alertRect.right) / 2;
|
|
vertOff = ((theScreen.bottom - theScreen.top) - alertRect.bottom) / 3;
|
|
|
|
OffsetRect(&alertRect, horiOff, vertOff + LMGetMBarHeight());
|
|
|
|
(**alertHandle).boundsRect = alertRect;
|
|
HSetState((Handle)alertHandle, wasState);
|
|
}
|
|
}
|
|
*/
|
|
//-------------------------------------------------------------- ZoomOutDialogRect
|
|
|
|
// Given a dialog, this function does the "zoom" animation to make theÉ
|
|
// the dialog appear to expand from nothingness or zoom in at you.
|
|
/*
|
|
void ZoomOutDialogRect (short dialogID)
|
|
{
|
|
#define kSteps 16
|
|
#define kZoomDelay 1
|
|
DialogTHndl dlogHandle;
|
|
GrafPtr wasPort, tempPort;
|
|
Rect dlogBounds, zoomRect;
|
|
UInt32 dummyLong;
|
|
Byte wasState;
|
|
short wideStep, highStep, i;
|
|
|
|
GetPort(&wasPort);
|
|
|
|
tempPort = (GrafPtr)NewPtrClear(sizeof(GrafPort));
|
|
OpenPort(tempPort);
|
|
|
|
dlogHandle = (DialogTHndl)GetResource('DLOG', dialogID);
|
|
if (dlogHandle != nil)
|
|
{
|
|
wasState = HGetState((Handle)dlogHandle);
|
|
HLock((Handle)dlogHandle);
|
|
dlogBounds = (**dlogHandle).boundsRect;
|
|
HSetState((Handle)dlogHandle, wasState);
|
|
}
|
|
|
|
wideStep = ((dlogBounds.right - dlogBounds.left) / 2) / kSteps;
|
|
highStep = ((dlogBounds.bottom - dlogBounds.top) / 2) / kSteps;
|
|
|
|
SetRect(&zoomRect, dlogBounds.left + (wideStep * kSteps),
|
|
dlogBounds.top + (highStep * kSteps),
|
|
dlogBounds.right - (wideStep * kSteps),
|
|
dlogBounds.bottom - (highStep * kSteps));
|
|
GlobalToLocalRect(&zoomRect);
|
|
|
|
PenPat(GetQDGlobalsGray(&dummyPattern));
|
|
PenMode(patXor);
|
|
|
|
for (i = 0; i < kSteps; i++)
|
|
{
|
|
FrameRect(&zoomRect);
|
|
Delay(kZoomDelay, &dummyLong);
|
|
FrameRect(&zoomRect);
|
|
InsetRect(&zoomRect, -wideStep, -highStep);
|
|
}
|
|
|
|
ClosePort(tempPort);
|
|
|
|
SetPort((GrafPtr)wasPort);
|
|
}
|
|
*/
|
|
//-------------------------------------------------------------- ZoomOutAlertRect
|
|
|
|
// Like the above funciton but zooms out alerts instead of dialogs.
|
|
/*
|
|
void ZoomOutAlertRect (short alertID)
|
|
{
|
|
#define kSteps 16
|
|
#define kZoomDelay 1
|
|
AlertTHndl alertHandle;
|
|
GrafPtr wasPort, tempPort;
|
|
Rect alertBounds, zoomRect;
|
|
UInt32 dummyLong;
|
|
Byte wasState;
|
|
short wideStep, highStep, i;
|
|
|
|
GetPort(&wasPort);
|
|
|
|
tempPort = (GrafPtr)NewPtrClear(sizeof(GrafPort));
|
|
OpenPort(tempPort);
|
|
|
|
alertHandle = (AlertTHndl)GetResource('ALRT', alertID);
|
|
if (alertHandle != nil)
|
|
{
|
|
wasState = HGetState((Handle)alertHandle);
|
|
HLock((Handle)alertHandle);
|
|
alertBounds = (**alertHandle).boundsRect;
|
|
HSetState((Handle)alertHandle, wasState);
|
|
}
|
|
|
|
wideStep = ((alertBounds.right - alertBounds.left) / 2) / kSteps;
|
|
highStep = ((alertBounds.bottom - alertBounds.top) / 2) / kSteps;
|
|
|
|
SetRect(&zoomRect, alertBounds.left + (wideStep * kSteps),
|
|
alertBounds.top + (highStep * kSteps),
|
|
alertBounds.right - (wideStep * kSteps),
|
|
alertBounds.bottom - (highStep * kSteps));
|
|
GlobalToLocalRect(&zoomRect);
|
|
|
|
PenPat(GetQDGlobalsGray(&dummyPattern));
|
|
PenMode(patXor);
|
|
|
|
for (i = 0; i < kSteps; i++)
|
|
{
|
|
FrameRect(&zoomRect);
|
|
Delay(kZoomDelay, &dummyLong);
|
|
FrameRect(&zoomRect);
|
|
InsetRect(&zoomRect, -wideStep, -highStep);
|
|
}
|
|
|
|
ClosePort(tempPort);
|
|
|
|
SetPort((GrafPtr)wasPort);
|
|
}
|
|
*/
|
|
|
|
//-------------------------------------------------------------- FlashDialogButton
|
|
// Flashes the default dialog button (item = 1) so as to make it appearÉ
|
|
// as though the user clicked on it.
|
|
|
|
void FlashDialogButton (DialogPtr theDialog, short itemNumber)
|
|
{
|
|
Rect itemRect;
|
|
Handle itemHandle;
|
|
UInt32 dummyLong;
|
|
short itemType;
|
|
|
|
GetDialogItem(theDialog, itemNumber, &itemType, &itemHandle, &itemRect);
|
|
HiliteControl((ControlHandle)itemHandle, kControlButtonPart);
|
|
Delay(8, &dummyLong);
|
|
HiliteControl((ControlHandle)itemHandle, 0);
|
|
}
|
|
|
|
//-------------------------------------------------------------- DrawDefaultButton
|
|
// Draws a fat outline around the default item (item = 1). This is theÉ
|
|
// item that is selected if the user hits the Return key.
|
|
|
|
void DrawDefaultButton (DialogPtr theDialog)
|
|
{
|
|
Rect itemRect;
|
|
Handle itemHandle;
|
|
short itemType;
|
|
|
|
GetDialogItem(theDialog, 1, &itemType, &itemHandle, &itemRect);
|
|
InsetRect(&itemRect, -4, -4);
|
|
PenSize(3, 3);
|
|
FrameRoundRect(&itemRect, 16, 16);
|
|
PenNormal();
|
|
}
|
|
|
|
//-------------------------------------------------------------- GetDialogString
|
|
// Returns a string from a specific dialog item.
|
|
|
|
void GetDialogString (DialogPtr theDialog, short item, StringPtr theString)
|
|
{
|
|
Rect itemRect;
|
|
Handle itemHandle;
|
|
short itemType;
|
|
|
|
GetDialogItem(theDialog, item, &itemType, &itemHandle, &itemRect);
|
|
GetDialogItemText(itemHandle, theString);
|
|
}
|
|
|
|
//-------------------------------------------------------------- SetDialogString
|
|
// Sets a specific string to a specific dialog item.
|
|
|
|
void SetDialogString (DialogPtr theDialog, short item, StringPtr theString)
|
|
{
|
|
Rect itemRect;
|
|
Handle itemHandle;
|
|
short itemType;
|
|
|
|
GetDialogItem(theDialog, item, &itemType, &itemHandle, &itemRect);
|
|
SetDialogItemText(itemHandle, theString);
|
|
}
|
|
|
|
//-------------------------------------------------------------- GetDialogStringLen
|
|
// Returns the length of a dialog item string (text).
|
|
|
|
short GetDialogStringLen (DialogPtr theDialog, short item)
|
|
{
|
|
Rect itemRect;
|
|
Str255 theString;
|
|
Handle itemHandle;
|
|
short itemType;
|
|
|
|
GetDialogItem(theDialog, item, &itemType, &itemHandle, &itemRect);
|
|
GetDialogItemText(itemHandle, theString);
|
|
return (theString[0]);
|
|
}
|
|
|
|
//-------------------------------------------------------------- GetDialogItemValue
|
|
// Returns the value or "state" of a dialog item. For checkboxes andÉ
|
|
// radio buttons, this may be a 1 or 0.
|
|
|
|
void GetDialogItemValue (DialogPtr theDialog, short item, short *theState)
|
|
{
|
|
Rect itemRect;
|
|
Handle itemHandle;
|
|
short itemType;
|
|
|
|
GetDialogItem(theDialog, item, &itemType, &itemHandle, &itemRect);
|
|
*theState = GetControlValue((ControlHandle)itemHandle);
|
|
}
|
|
|
|
//-------------------------------------------------------------- SetDialogItemValue
|
|
// Sets a specific dialogf items value or state (can set or clearÉ
|
|
// checkboxes, radio buttons, etc.).
|
|
|
|
void SetDialogItemValue (DialogPtr theDialog, short item, short theState)
|
|
{
|
|
Rect itemRect;
|
|
Handle itemHandle;
|
|
short itemType;
|
|
|
|
GetDialogItem(theDialog, item, &itemType, &itemHandle, &itemRect);
|
|
SetControlValue((ControlHandle)itemHandle, theState);
|
|
}
|
|
|
|
//-------------------------------------------------------------- ToggleDialogItemValue
|
|
// If item is a checkbox or radio button, its state is toggled.
|
|
|
|
void ToggleDialogItemValue (DialogPtr theDialog, short item)
|
|
{
|
|
Rect itemRect;
|
|
Handle itemHandle;
|
|
short itemType, theState;
|
|
|
|
GetDialogItem(theDialog, item, &itemType, &itemHandle, &itemRect);
|
|
theState = GetControlValue((ControlHandle)itemHandle);
|
|
if (theState == 0)
|
|
theState = 1;
|
|
else
|
|
theState = 0;
|
|
SetControlValue((ControlHandle)itemHandle, theState);
|
|
}
|
|
|
|
//-------------------------------------------------------------- SetDialogNumToStr
|
|
// Function accepts an integer, converts it to a string and sets aÉ
|
|
// dialog items text to this string.
|
|
|
|
void SetDialogNumToStr (DialogPtr theDialog, short item, long theNumber)
|
|
{
|
|
Str255 theString;
|
|
Rect itemRect;
|
|
Handle itemHandle;
|
|
short itemType;
|
|
|
|
NumToString(theNumber, theString);
|
|
GetDialogItem(theDialog, item, &itemType, &itemHandle, &itemRect);
|
|
SetDialogItemText(itemHandle, theString);
|
|
}
|
|
|
|
//-------------------------------------------------------------- GetDialogNumFromStr
|
|
// Function extracts the text from a dialog item and converts it to anÉ
|
|
// integer for returning.
|
|
|
|
void GetDialogNumFromStr (DialogPtr theDialog, short item, long *theNumber)
|
|
{
|
|
Str255 theString;
|
|
Rect itemRect;
|
|
Handle itemHandle;
|
|
short itemType;
|
|
|
|
GetDialogItem(theDialog, item, &itemType, &itemHandle, &itemRect);
|
|
GetDialogItemText(itemHandle, theString);
|
|
StringToNum(theString, theNumber);
|
|
}
|
|
|
|
//-------------------------------------------------------------- GetDialogItemRect
|
|
// Returns the bounding rectangle of the specified dialog item.
|
|
|
|
void GetDialogItemRect (DialogPtr theDialog, short item, Rect *theRect)
|
|
{
|
|
Handle itemHandle;
|
|
short itemType;
|
|
|
|
GetDialogItem(theDialog, item, &itemType, &itemHandle, theRect);
|
|
}
|
|
|
|
//-------------------------------------------------------------- SetDialogItemRect
|
|
// Sets the bounding rectangle of the specified dialog item. Used toÉ
|
|
// resize or move a control.
|
|
|
|
void SetDialogItemRect (DialogPtr theDialog, short item, Rect *theRect)
|
|
{
|
|
Rect oldRect;
|
|
Handle itemHandle;
|
|
short itemType;
|
|
|
|
GetDialogItem(theDialog, item, &itemType, &itemHandle, &oldRect);
|
|
OffsetRect(&oldRect, theRect->left - oldRect.left, theRect->top - oldRect.top);
|
|
SetDialogItem(theDialog, item, itemType, itemHandle, &oldRect);
|
|
}
|
|
|
|
//-------------------------------------------------------------- OffsetDialogItemRect
|
|
// Moves a dialog item by h and v.
|
|
|
|
void OffsetDialogItemRect (DialogPtr theDialog, short item, short h, short v)
|
|
{
|
|
Rect oldRect;
|
|
Handle itemHandle;
|
|
short itemType;
|
|
|
|
GetDialogItem(theDialog, item, &itemType, &itemHandle, &oldRect);
|
|
OffsetRect(&oldRect, h, v);
|
|
SetDialogItem(theDialog, item, itemType, itemHandle, &oldRect);
|
|
}
|
|
|
|
//-------------------------------------------------------------- SelectFromRadioGroup
|
|
// Assuming a series of consecutively numbered radio buttons, this functionÉ
|
|
// clears the whole range of them but sets the one specified (as thoughÉ
|
|
// the radio buttons are linked and only one can be set at a time).
|
|
|
|
void SelectFromRadioGroup (DialogPtr dial, short which, short first, short last)
|
|
{
|
|
Rect iRect;
|
|
Handle iHandle;
|
|
short iType, i;
|
|
|
|
for (i = first; i <= last; i++)
|
|
{
|
|
GetDialogItem(dial, i, &iType, &iHandle, &iRect);
|
|
SetControlValue((ControlHandle)iHandle, (short)false);
|
|
}
|
|
|
|
GetDialogItem(dial, which, &iType, &iHandle, &iRect);
|
|
SetControlValue((ControlHandle)iHandle, (short)true);
|
|
}
|
|
|
|
//-------------------------------------------------------------- AddMenuToPopUp
|
|
// Assigns a menu handle to a pop-up dialog item - thus, giving thatÉ
|
|
// pop-up item something to pop up.
|
|
/*
|
|
void AddMenuToPopUp (DialogPtr theDialog, short whichItem, MenuHandle theMenu)
|
|
{
|
|
Rect iRect;
|
|
Handle iHandle;
|
|
short iType;
|
|
|
|
GetDialogItem(theDialog, whichItem, &iType, &iHandle, &iRect);
|
|
(**(ControlHandle)iHandle).contrlRfCon = (long)theMenu;
|
|
}
|
|
*/
|
|
//-------------------------------------------------------------- GetPopUpMenuValu
|
|
// Returns which item is currently selected in a pop-up menu.
|
|
|
|
void GetPopUpMenuValue (DialogPtr theDialog, short whichItem, short *value)
|
|
{
|
|
Rect iRect;
|
|
Handle iHandle;
|
|
short iType;
|
|
|
|
GetDialogItem(theDialog, whichItem, &iType, &iHandle, &iRect);
|
|
*value = GetControlValue((ControlHandle)iHandle);
|
|
}
|
|
|
|
//-------------------------------------------------------------- SetPopUpMenuValue
|
|
// Forces a specific item to be set (as though selected) in a pop-up menu.
|
|
|
|
void SetPopUpMenuValue (DialogPtr theDialog, short whichItem, short value)
|
|
{
|
|
Rect iRect;
|
|
Handle iHandle;
|
|
short iType;
|
|
|
|
GetDialogItem(theDialog, whichItem, &iType, &iHandle, &iRect);
|
|
SetControlValue((ControlHandle)iHandle, value);
|
|
}
|
|
|
|
//-------------------------------------------------------------- MyEnableControl
|
|
// "Un-grays" or enables a dialog item (usually a button).
|
|
|
|
void MyEnableControl (DialogPtr theDialog, short whichItem)
|
|
{
|
|
Rect iRect;
|
|
Handle iHandle;
|
|
short iType;
|
|
|
|
GetDialogItem(theDialog, whichItem, &iType, &iHandle, &iRect);
|
|
HiliteControl((ControlHandle)iHandle, kActive);
|
|
}
|
|
|
|
//-------------------------------------------------------------- MyDisableControl
|
|
// "Grays out" or disables a dialog item (usually a button).
|
|
|
|
void MyDisableControl (DialogPtr theDialog, short whichItem)
|
|
{
|
|
Rect iRect;
|
|
Handle iHandle;
|
|
short iType;
|
|
|
|
GetDialogItem(theDialog, whichItem, &iType, &iHandle, &iRect);
|
|
HiliteControl((ControlHandle)iHandle, kInactive);
|
|
}
|
|
|
|
//-------------------------------------------------------------- DrawDialogUserText
|
|
// Given a string of text and an item, this function draws the stringÉ
|
|
// within the bounding rect of the item. Dialog item assumed to beÉ
|
|
// a "user item" (invisible item with only bounds).
|
|
|
|
void DrawDialogUserText (DialogPtr dial, short item, StringPtr text, Boolean invert)
|
|
{
|
|
Rect iRect;
|
|
Handle iHandle;
|
|
Str255 newString, stringCopy;
|
|
short iType, textLong, i, inset;
|
|
|
|
TextFont(applFont);
|
|
TextSize(9);
|
|
|
|
PasStringCopy(text, stringCopy);
|
|
GetDialogItem(dial, item, &iType, &iHandle, &iRect);
|
|
if ((StringWidth(stringCopy) + 2) > (iRect.right - iRect.left))
|
|
CollapseStringToWidth(stringCopy, iRect.right - iRect.left - 2);
|
|
textLong = stringCopy[0];
|
|
for (i = 0; i < textLong; i++)
|
|
newString[i] = stringCopy[i + 1];
|
|
|
|
OffsetRect(&iRect, 0, 1);
|
|
EraseRect(&iRect);
|
|
OffsetRect(&iRect, 0, -1);
|
|
|
|
inset = ((iRect.right - iRect.left) - (StringWidth(stringCopy) + 2)) / 2;
|
|
iRect.left += inset;
|
|
iRect.right -= inset;
|
|
|
|
TETextBox(newString, textLong, &iRect, teCenter);
|
|
if (invert)
|
|
{
|
|
OffsetRect(&iRect, 0, 1);
|
|
InvertRect(&iRect);
|
|
}
|
|
}
|
|
|
|
//-------------------------------------------------------------- DrawDialogUserText
|
|
// Similar to the above function but doesn't call TETextBox(). Instead,É
|
|
// it truncates the string (and appends "É") to the end in order thatÉ
|
|
// the string fits within the dialog item's bounds.
|
|
|
|
void DrawDialogUserText2 (DialogPtr dial, short item, StringPtr text)
|
|
{
|
|
Rect iRect;
|
|
Handle iHandle;
|
|
Str255 stringCopy;
|
|
short iType;
|
|
|
|
TextFont(applFont);
|
|
TextSize(9);
|
|
|
|
PasStringCopy(text, stringCopy);
|
|
GetDialogItem(dial, item, &iType, &iHandle, &iRect);
|
|
if ((StringWidth(stringCopy) + 2) > (iRect.right - iRect.left))
|
|
CollapseStringToWidth(stringCopy, iRect.right - iRect.left - 2);
|
|
MoveTo(iRect.left, iRect.bottom);
|
|
DrawString(stringCopy);
|
|
}
|
|
|
|
//-------------------------------------------------------------- LoadDialogPICT
|
|
// Draws a 'PICT' specified by ID within the bounds of the specifiedÉ
|
|
// dialog item.
|
|
|
|
void LoadDialogPICT (DialogPtr theDialog, short item, short theID)
|
|
{
|
|
Rect iRect;
|
|
Handle iHandle;
|
|
PicHandle thePict;
|
|
short iType;
|
|
|
|
GetDialogItem(theDialog, item, &iType, &iHandle, &iRect);
|
|
thePict = GetPicture(theID);
|
|
if (thePict)
|
|
DrawPicture(thePict, &iRect);
|
|
}
|
|
|
|
//-------------------------------------------------------------- FrameDialogItem
|
|
// Given a dialog item, this function draws a box around it.
|
|
|
|
void FrameDialogItem (DialogPtr theDialog, short item)
|
|
{
|
|
Rect itemRect;
|
|
Handle itemHandle;
|
|
short itemType;
|
|
|
|
GetDialogItem(theDialog, item, &itemType, &itemHandle, &itemRect);
|
|
FrameRect(&itemRect);
|
|
}
|
|
|
|
//-------------------------------------------------------------- FrameDialogItemC
|
|
// Given a dialog item, this function draws a color (specified) box around it.
|
|
|
|
void FrameDialogItemC (DialogPtr theDialog, short item, long color)
|
|
{
|
|
RGBColor theRGBColor, wasColor;
|
|
Rect itemRect;
|
|
Handle itemHandle;
|
|
short itemType;
|
|
|
|
GetDialogItem(theDialog, item, &itemType, &itemHandle, &itemRect);
|
|
GetForeColor(&wasColor);
|
|
Index2Color(color, &theRGBColor);
|
|
RGBForeColor(&theRGBColor);
|
|
FrameRect(&itemRect);
|
|
RGBForeColor(&wasColor);
|
|
}
|
|
|
|
//-------------------------------------------------------------- FrameOvalDialogItem
|
|
// Given a dialog item, this function draws an oval around it.
|
|
|
|
void FrameOvalDialogItem (DialogPtr theDialog, short item)
|
|
{
|
|
Rect itemRect;
|
|
Handle itemHandle;
|
|
short itemType;
|
|
|
|
GetDialogItem(theDialog, item, &itemType, &itemHandle, &itemRect);
|
|
FrameOval(&itemRect);
|
|
}
|
|
|
|
//-------------------------------------------------------------- BorderDialogItem
|
|
// Given a dialog item, this function draws any combination of 4 sidesÉ
|
|
// of a box around it. Which sides get drawn is encoded in "sides".
|
|
|
|
void BorderDialogItem (DialogPtr theDialog, short item, short sides)
|
|
{
|
|
Rect itemRect;
|
|
Handle itemHandle;
|
|
short itemType;
|
|
|
|
// 1 = left
|
|
// 2 = top
|
|
// 4 = bottom
|
|
// 8 = right ... so 6 = top & bottom, 15 = all 4 sides
|
|
|
|
GetDialogItem(theDialog, item, &itemType, &itemHandle, &itemRect);
|
|
|
|
if (sides >= 8) // 8 = right
|
|
{
|
|
MoveTo(itemRect.right, itemRect.top);
|
|
LineTo(itemRect.right, itemRect.bottom);
|
|
sides -= 8;
|
|
}
|
|
if (sides >= 4) // 4 = bottom
|
|
{
|
|
MoveTo(itemRect.left, itemRect.bottom);
|
|
LineTo(itemRect.right, itemRect.bottom);
|
|
sides -= 4;
|
|
}
|
|
if (sides >= 2) // 2 = top
|
|
{
|
|
MoveTo(itemRect.left, itemRect.top - 1);
|
|
LineTo(itemRect.right, itemRect.top - 1);
|
|
sides -= 2;
|
|
}
|
|
if (sides >= 1) // 1 = left
|
|
{
|
|
MoveTo(itemRect.left - 1, itemRect.top);
|
|
LineTo(itemRect.left - 1, itemRect.bottom);
|
|
}
|
|
}
|
|
|
|
//-------------------------------------------------------------- ShadowDialogItem
|
|
// Draws a drop shadow to the right and below a specified dialog item.
|
|
|
|
void ShadowDialogItem (DialogPtr theDialog, short item, short thickness)
|
|
{
|
|
Rect itemRect;
|
|
Handle itemHandle;
|
|
short itemType;
|
|
|
|
GetDialogItem(theDialog, item, &itemType, &itemHandle, &itemRect);
|
|
PenSize(thickness, thickness);
|
|
MoveTo(itemRect.left + thickness, itemRect.bottom);
|
|
Line(itemRect.right - itemRect.left - thickness, 0);
|
|
MoveTo(itemRect.right, itemRect.top + thickness);
|
|
Line(0, itemRect.bottom - itemRect.top - thickness);
|
|
PenNormal();
|
|
}
|
|
|
|
//-------------------------------------------------------------- EraseDialogItem
|
|
// Erases (but doesn't physically remove) a dialog item.
|
|
|
|
void EraseDialogItem (DialogPtr theDialog, short item)
|
|
{
|
|
Rect itemRect;
|
|
Handle itemHandle;
|
|
short itemType;
|
|
|
|
GetDialogItem(theDialog, item, &itemType, &itemHandle, &itemRect);
|
|
EraseRect(&itemRect);
|
|
}
|
|
|