GliderPRO/Sources/DialogUtils.c
John Calhoun 7a70d18ba6 First check-in.
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.
2016-01-28 08:10:38 -08:00

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);
}