summaryrefslogtreecommitdiffstats
path: root/mac/tkMacButton.c
diff options
context:
space:
mode:
Diffstat (limited to 'mac/tkMacButton.c')
-rw-r--r--mac/tkMacButton.c825
1 files changed, 825 insertions, 0 deletions
diff --git a/mac/tkMacButton.c b/mac/tkMacButton.c
new file mode 100644
index 0000000..767baff
--- /dev/null
+++ b/mac/tkMacButton.c
@@ -0,0 +1,825 @@
+/*
+ * tkMacButton.c --
+ *
+ * This file implements the Macintosh specific portion of the
+ * button widgets.
+ *
+ * Copyright (c) 1996-1997 by Sun Microsystems, Inc.
+ *
+ * See the file "license.terms" for information on usage and redistribution
+ * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
+ *
+ * SCCS: @(#) tkMacButton.c 1.18 97/11/20 18:27:21
+ */
+
+#include "tkButton.h"
+#include "tkMacInt.h"
+#include <Controls.h>
+#include <LowMem.h>
+
+/*
+ * Some defines used to control what type of control is drawn.
+ */
+
+#define DRAW_LABEL 0 /* Labels are treated genericly. */
+#define DRAW_CONTROL 1 /* Draw using the Native control. */
+#define DRAW_CUSTOM 2 /* Make our own button drawing. */
+
+/*
+ * The following structures are used to draw our controls. Rather than
+ * having many Mac controls we just use one control of each type and
+ * reuse them for all Tk widgets. When the windowRef variable is NULL
+ * it means none of the data structures have been allocated.
+ */
+
+static WindowRef windowRef = NULL;
+static CWindowRecord windowRecord;
+static ControlRef buttonHandle;
+static ControlRef checkHandle;
+static ControlRef radioHandle;
+static CCTabHandle buttonTabHandle;
+static CCTabHandle checkTabHandle;
+static CCTabHandle radioTabHandle;
+static PixMapHandle oldPixPtr;
+
+/*
+ * Forward declarations for procedures defined later in this file:
+ */
+
+static int UpdateControlColors _ANSI_ARGS_((TkButton *butPtr,
+ ControlRef controlHandle, CCTabHandle ccTabHandle,
+ RGBColor *saveColorPtr));
+static void DrawBufferedControl _ANSI_ARGS_((TkButton *butPtr,
+ GWorldPtr destPort));
+static void ChangeBackgroundWindowColor _ANSI_ARGS_((
+ WindowRef macintoshWindow, RGBColor rgbColor,
+ RGBColor *oldColor));
+static void ButtonExitProc _ANSI_ARGS_((ClientData clientData));
+
+/*
+ * The class procedure table for the button widgets.
+ */
+
+TkClassProcs tkpButtonProcs = {
+ NULL, /* createProc. */
+ TkButtonWorldChanged, /* geometryProc. */
+ NULL /* modalProc. */
+};
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * TkpCreateButton --
+ *
+ * Allocate a new TkButton structure.
+ *
+ * Results:
+ * Returns a newly allocated TkButton structure.
+ *
+ * Side effects:
+ * Registers an event handler for the widget.
+ *
+ *----------------------------------------------------------------------
+ */
+
+TkButton *
+TkpCreateButton(
+ Tk_Window tkwin)
+{
+ return (TkButton *) ckalloc(sizeof(TkButton));
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * TkpDisplayButton --
+ *
+ * This procedure is invoked to display a button widget. It is
+ * normally invoked as an idle handler.
+ *
+ * Results:
+ * None.
+ *
+ * Side effects:
+ * Commands are output to X to display the button in its
+ * current mode. The REDRAW_PENDING flag is cleared.
+ *
+ *----------------------------------------------------------------------
+ */
+
+void
+TkpDisplayButton(
+ ClientData clientData) /* Information about widget. */
+{
+ TkButton *butPtr = (TkButton *) clientData;
+ Pixmap pixmap;
+ GC gc;
+ Tk_3DBorder border;
+ int x = 0; /* Initialization only needed to stop
+ * compiler warning. */
+ int y, relief;
+ register Tk_Window tkwin = butPtr->tkwin;
+ int width, height;
+ int offset; /* 0 means this is a normal widget. 1 means
+ * it is an image button, so we offset the
+ * image to make the button appear to move
+ * up and down as the relief changes. */
+ CGrafPtr saveWorld;
+ GDHandle saveDevice;
+ GWorldPtr destPort;
+ int drawType, borderWidth;
+
+ GetGWorld(&saveWorld, &saveDevice);
+
+ butPtr->flags &= ~REDRAW_PENDING;
+ if ((butPtr->tkwin == NULL) || !Tk_IsMapped(tkwin)) {
+ return;
+ }
+
+ border = butPtr->normalBorder;
+ if ((butPtr->state == tkDisabledUid) && (butPtr->disabledFg != NULL)) {
+ gc = butPtr->disabledGC;
+ } else if ((butPtr->type == TYPE_BUTTON) && (butPtr->state == tkActiveUid)) {
+ gc = butPtr->activeTextGC;
+ border = butPtr->activeBorder;
+ } else {
+ gc = butPtr->normalTextGC;
+ }
+ if ((butPtr->flags & SELECTED) && (butPtr->state != tkActiveUid)
+ && (butPtr->selectBorder != NULL) && !butPtr->indicatorOn) {
+ border = butPtr->selectBorder;
+ }
+
+ /*
+ * Override the relief specified for the button if this is a
+ * checkbutton or radiobutton and there's no indicator.
+ */
+
+ relief = butPtr->relief;
+ if ((butPtr->type >= TYPE_CHECK_BUTTON) && !butPtr->indicatorOn) {
+ relief = (butPtr->flags & SELECTED) ? TK_RELIEF_SUNKEN
+ : TK_RELIEF_RAISED;
+ }
+
+ offset = ((butPtr->type == TYPE_BUTTON) &&
+ ((butPtr->image != NULL) || (butPtr->bitmap != None)));
+
+ /*
+ * In order to avoid screen flashes, this procedure redraws
+ * the button in a pixmap, then copies the pixmap to the
+ * screen in a single operation. This means that there's no
+ * point in time where the on-sreen image has been cleared.
+ */
+
+ pixmap = Tk_GetPixmap(butPtr->display, Tk_WindowId(tkwin),
+ Tk_Width(tkwin), Tk_Height(tkwin), Tk_Depth(tkwin));
+ Tk_Fill3DRectangle(tkwin, pixmap, butPtr->normalBorder, 0, 0,
+ Tk_Width(tkwin), Tk_Height(tkwin), 0, TK_RELIEF_FLAT);
+
+
+ if (butPtr->type == TYPE_LABEL) {
+ drawType = DRAW_LABEL;
+ } else if (butPtr->type == TYPE_BUTTON) {
+ if ((butPtr->image == None) && (butPtr->bitmap == None)) {
+ drawType = DRAW_CONTROL;
+ } else {
+ drawType = DRAW_CUSTOM;
+ }
+ } else {
+ if (butPtr->indicatorOn) {
+ drawType = DRAW_CONTROL;
+ } else {
+ drawType = DRAW_CUSTOM;
+ }
+ }
+
+ /*
+ * Draw the native portion of the buttons. Start by creating the control
+ * if it doesn't already exist. Then configure the Macintosh control from
+ * the Tk info. Finally, we call Draw1Control to draw to the screen.
+ */
+
+ if (drawType == DRAW_CONTROL) {
+ borderWidth = 0;
+
+ /*
+ * This part uses Macintosh rather than Tk calls to draw
+ * to the screen. Make sure the ports etc. are set correctly.
+ */
+
+ destPort = TkMacGetDrawablePort(pixmap);
+ SetGWorld(destPort, NULL);
+ DrawBufferedControl(butPtr, destPort);
+ }
+
+ if ((drawType == DRAW_CUSTOM) || (drawType == DRAW_LABEL)) {
+ borderWidth = butPtr->borderWidth;
+ }
+
+ /*
+ * Display image or bitmap or text for button.
+ */
+
+ if (butPtr->image != None) {
+ Tk_SizeOfImage(butPtr->image, &width, &height);
+
+ imageOrBitmap:
+ TkComputeAnchor(butPtr->anchor, tkwin, 0, 0,
+ butPtr->indicatorSpace + width, height, &x, &y);
+ x += butPtr->indicatorSpace;
+
+ x += offset;
+ y += offset;
+ if (relief == TK_RELIEF_RAISED) {
+ x -= offset;
+ y -= offset;
+ } else if (relief == TK_RELIEF_SUNKEN) {
+ x += offset;
+ y += offset;
+ }
+ if (butPtr->image != NULL) {
+ if ((butPtr->selectImage != NULL) && (butPtr->flags & SELECTED)) {
+ Tk_RedrawImage(butPtr->selectImage, 0, 0, width, height,
+ pixmap, x, y);
+ } else {
+ Tk_RedrawImage(butPtr->image, 0, 0, width, height, pixmap,
+ x, y);
+ }
+ } else {
+ XSetClipOrigin(butPtr->display, gc, x, y);
+ XCopyPlane(butPtr->display, butPtr->bitmap, pixmap, gc, 0, 0,
+ (unsigned int) width, (unsigned int) height, x, y, 1);
+ XSetClipOrigin(butPtr->display, gc, 0, 0);
+ }
+ y += height/2;
+ } else if (butPtr->bitmap != None) {
+ Tk_SizeOfBitmap(butPtr->display, butPtr->bitmap, &width, &height);
+ goto imageOrBitmap;
+ } else {
+ TkComputeAnchor(butPtr->anchor, tkwin, butPtr->padX, butPtr->padY,
+ butPtr->indicatorSpace + butPtr->textWidth, butPtr->textHeight,
+ &x, &y);
+
+ x += butPtr->indicatorSpace;
+
+ Tk_DrawTextLayout(butPtr->display, pixmap, gc, butPtr->textLayout,
+ x, y, 0, -1);
+ y += butPtr->textHeight/2;
+ }
+
+ /*
+ * If the button is disabled with a stipple rather than a special
+ * foreground color, generate the stippled effect. If the widget
+ * is selected and we use a different background color when selected,
+ * must temporarily modify the GC.
+ */
+
+ if ((butPtr->state == tkDisabledUid)
+ && ((butPtr->disabledFg == NULL) || (butPtr->image != NULL))) {
+ if ((butPtr->flags & SELECTED) && !butPtr->indicatorOn
+ && (butPtr->selectBorder != NULL)) {
+ XSetForeground(butPtr->display, butPtr->disabledGC,
+ Tk_3DBorderColor(butPtr->selectBorder)->pixel);
+ }
+ XFillRectangle(butPtr->display, pixmap, butPtr->disabledGC,
+ butPtr->inset, butPtr->inset,
+ (unsigned) (Tk_Width(tkwin) - 2*butPtr->inset),
+ (unsigned) (Tk_Height(tkwin) - 2*butPtr->inset));
+ if ((butPtr->flags & SELECTED) && !butPtr->indicatorOn
+ && (butPtr->selectBorder != NULL)) {
+ XSetForeground(butPtr->display, butPtr->disabledGC,
+ Tk_3DBorderColor(butPtr->normalBorder)->pixel);
+ }
+ }
+
+ /*
+ * Draw the border and traversal highlight last. This way, if the
+ * button's contents overflow they'll be covered up by the border.
+ */
+
+ if (relief != TK_RELIEF_FLAT) {
+ int inset = butPtr->highlightWidth;
+ Tk_Draw3DRectangle(tkwin, pixmap, border, inset, inset,
+ Tk_Width(tkwin) - 2*inset, Tk_Height(tkwin) - 2*inset,
+ butPtr->borderWidth, relief);
+ }
+
+ /*
+ * Copy the information from the off-screen pixmap onto the screen,
+ * then delete the pixmap.
+ */
+
+ XCopyArea(butPtr->display, pixmap, Tk_WindowId(tkwin),
+ butPtr->copyGC, 0, 0, (unsigned) Tk_Width(tkwin),
+ (unsigned) Tk_Height(tkwin), 0, 0);
+ Tk_FreePixmap(butPtr->display, pixmap);
+
+ SetGWorld(saveWorld, saveDevice);
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * TkpComputeButtonGeometry --
+ *
+ * After changes in a button's text or bitmap, this procedure
+ * recomputes the button's geometry and passes this information
+ * along to the geometry manager for the window.
+ *
+ * Results:
+ * None.
+ *
+ * Side effects:
+ * The button's window may change size.
+ *
+ *----------------------------------------------------------------------
+ */
+
+void
+TkpComputeButtonGeometry(
+ TkButton *butPtr) /* Button whose geometry may have changed. */
+{
+ int width, height, avgWidth;
+ Tk_FontMetrics fm;
+
+ if (butPtr->highlightWidth < 0) {
+ butPtr->highlightWidth = 0;
+ }
+ if ((butPtr->type == TYPE_BUTTON) && (butPtr->image == None)
+ && (butPtr->bitmap == None)) {
+ butPtr->inset = 0;
+ } else if ((butPtr->type != TYPE_LABEL) && butPtr->indicatorOn) {
+ butPtr->inset = 0;
+ } else {
+ butPtr->inset = butPtr->borderWidth;
+ }
+
+ /*
+ * The highlight width corresponds to the default ring on the Macintosh.
+ * As such, the highlight width is only added if the button is the default
+ * button. The actual width of the default ring is one less than the
+ * highlight width as there is also one pixel of spacing.
+ */
+
+ if (butPtr->defaultState != tkDisabledUid) {
+ butPtr->inset += butPtr->highlightWidth;
+ }
+ butPtr->indicatorSpace = 0;
+ if (butPtr->image != NULL) {
+ Tk_SizeOfImage(butPtr->image, &width, &height);
+ imageOrBitmap:
+ if (butPtr->width > 0) {
+ width = butPtr->width;
+ }
+ if (butPtr->height > 0) {
+ height = butPtr->height;
+ }
+ if ((butPtr->type >= TYPE_CHECK_BUTTON) && butPtr->indicatorOn) {
+ butPtr->indicatorSpace = height;
+ if (butPtr->type == TYPE_CHECK_BUTTON) {
+ butPtr->indicatorDiameter = (65*height)/100;
+ } else {
+ butPtr->indicatorDiameter = (75*height)/100;
+ }
+ }
+ } else if (butPtr->bitmap != None) {
+ Tk_SizeOfBitmap(butPtr->display, butPtr->bitmap, &width, &height);
+ goto imageOrBitmap;
+ } else {
+ Tk_FreeTextLayout(butPtr->textLayout);
+ butPtr->textLayout = Tk_ComputeTextLayout(butPtr->tkfont,
+ butPtr->text, -1, butPtr->wrapLength, butPtr->justify, 0,
+ &butPtr->textWidth, &butPtr->textHeight);
+
+ width = butPtr->textWidth;
+ height = butPtr->textHeight;
+ avgWidth = Tk_TextWidth(butPtr->tkfont, "0", 1);
+ Tk_GetFontMetrics(butPtr->tkfont, &fm);
+
+ if (butPtr->width > 0) {
+ width = butPtr->width * avgWidth;
+ }
+ if (butPtr->height > 0) {
+ height = butPtr->height * fm.linespace;
+ }
+ if ((butPtr->type >= TYPE_CHECK_BUTTON) && butPtr->indicatorOn) {
+ butPtr->indicatorDiameter = fm.linespace;
+ if (butPtr->type == TYPE_CHECK_BUTTON) {
+ butPtr->indicatorDiameter = (80*butPtr->indicatorDiameter)/100;
+ }
+ butPtr->indicatorSpace = butPtr->indicatorDiameter + avgWidth;
+ }
+ }
+
+ /*
+ * When issuing the geometry request, add extra space for the indicator,
+ * if any, and for the border and padding, plus if this is an image two
+ * extra pixels so the display can be offset by 1 pixel in either
+ * direction for the raised or lowered effect.
+ */
+
+ if ((butPtr->image == NULL) && (butPtr->bitmap == None)) {
+ width += 2*butPtr->padX;
+ height += 2*butPtr->padY;
+ }
+ if ((butPtr->type == TYPE_BUTTON) &&
+ ((butPtr->image != NULL) || (butPtr->bitmap != None))) {
+ width += 2;
+ height += 2;
+ }
+ Tk_GeometryRequest(butPtr->tkwin, (int) (width + butPtr->indicatorSpace
+ + 2*butPtr->inset), (int) (height + 2*butPtr->inset));
+ Tk_SetInternalBorder(butPtr->tkwin, butPtr->inset);
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * TkpDestroyButton --
+ *
+ * Free data structures associated with the button control.
+ *
+ * Results:
+ * None.
+ *
+ * Side effects:
+ * Restores the default control state.
+ *
+ *----------------------------------------------------------------------
+ */
+
+void
+TkpDestroyButton(
+ TkButton *butPtr)
+{
+ /* Do nothing. */
+}
+
+/*
+ *--------------------------------------------------------------
+ *
+ * DrawBufferedControl --
+ *
+ * This function uses a dummy Macintosh window to allow
+ * drawing Mac controls to any GWorld (including off-screen
+ * bitmaps). In addition, this code may apply custom
+ * colors passed in the TkButton.
+ *
+ * Results:
+ * None.
+ *
+ * Side effects:
+ * Control is to the GWorld. Static state created on
+ * first invocation of this routine.
+ *
+ *--------------------------------------------------------------
+ */
+
+static void
+DrawBufferedControl(
+ TkButton *butPtr, /* Tk button. */
+ GWorldPtr destPort) /* Off screen GWorld. */
+{
+ ControlRef controlHandle;
+ CCTabHandle ccTabHandle;
+ int windowColorChanged = false;
+ RGBColor saveBackColor;
+
+ if (windowRef == NULL) {
+ Rect geometry = {0, 0, 10, 10};
+ CWindowPeek windowList;
+
+ /*
+ * Create a dummy window that we can draw to. We will
+ * actually replace this windows bitmap with a the one
+ * we want to draw to at a later time. This window and
+ * the data structures attached to it are only deallocated
+ * on exit of the application.
+ */
+
+ windowRef = NewCWindow(NULL, &geometry, "\pempty", false,
+ zoomDocProc, (WindowRef) -1, true, 0);
+ if (windowRef == NULL) {
+ panic("Can't allocate buffer window.");
+ }
+
+ /*
+ * Now add the three standard controls to hidden window. We
+ * only create one of each and reuse them for every widget in
+ * Tk.
+ */
+
+ SetPort(windowRef);
+ buttonHandle = NewControl(windowRef, &geometry, "\p",
+ false, 1, 0, 1, pushButProc, (SInt32) 0);
+ checkHandle = NewControl(windowRef, &geometry, "\p",
+ false, 1, 0, 1, checkBoxProc, (SInt32) 0);
+ radioHandle = NewControl(windowRef, &geometry, "\p",
+ false, 1, 0, 1, radioButProc, (SInt32) 0);
+ ((CWindowPeek) windowRef)->visible = true;
+
+ buttonTabHandle = (CCTabHandle) NewHandle(sizeof(CtlCTab));
+ checkTabHandle = (CCTabHandle) NewHandle(sizeof(CtlCTab));
+ radioTabHandle = (CCTabHandle) NewHandle(sizeof(CtlCTab));
+
+ /*
+ * Remove our window from the window list. This way our
+ * applications and others will not be confused that this
+ * window exists - but no one knows about it.
+ */
+
+ windowList = (CWindowPeek) LMGetWindowList();
+ if (windowList == (CWindowPeek) windowRef) {
+ LMSetWindowList((WindowRef) windowList->nextWindow);
+ } else {
+ while ((windowList != NULL)
+ && (windowList->nextWindow != (CWindowPeek) windowRef)) {
+ windowList = windowList->nextWindow;
+ }
+ if (windowList != NULL) {
+ windowList->nextWindow = windowList->nextWindow->nextWindow;
+ }
+ }
+ ((CWindowPeek) windowRef)->nextWindow = NULL;
+
+ /*
+ * Create an exit handler to clean up this mess if we our
+ * unloaded etc. We need to remember the windows portPixMap
+ * so it isn't leaked.
+ *
+ * TODO: The ButtonExitProc doesn't currently work and the
+ * code it includes will crash the Mac on exit from Tk.
+
+ oldPixPtr = ((CWindowPeek) windowRef)->port.portPixMap;
+ Tcl_CreateExitHandler(ButtonExitProc, (ClientData) NULL);
+ */
+ }
+
+ /*
+ * Set up control in hidden window to match what we need
+ * to draw in the buffered window.
+ */
+
+ switch (butPtr->type) {
+ case TYPE_BUTTON:
+ controlHandle = buttonHandle;
+ ccTabHandle = buttonTabHandle;
+ break;
+ case TYPE_RADIO_BUTTON:
+ controlHandle = radioHandle;
+ ccTabHandle = radioTabHandle;
+ break;
+ case TYPE_CHECK_BUTTON:
+ controlHandle = checkHandle;
+ ccTabHandle = checkTabHandle;
+ break;
+ }
+ (**controlHandle).contrlRect.left = butPtr->inset;
+ (**controlHandle).contrlRect.top = butPtr->inset;
+ (**controlHandle).contrlRect.right = Tk_Width(butPtr->tkwin)
+ - butPtr->inset;
+ (**controlHandle).contrlRect.bottom = Tk_Height(butPtr->tkwin)
+ - butPtr->inset;
+ if ((**controlHandle).contrlVis != 255) {
+ (**controlHandle).contrlVis = 255;
+ }
+ if (butPtr->flags & SELECTED) {
+ (**controlHandle).contrlValue = 1;
+ } else {
+ (**controlHandle).contrlValue = 0;
+ }
+ if (butPtr->state == tkActiveUid) {
+ switch (butPtr->type) {
+ case TYPE_BUTTON:
+ (**controlHandle).contrlHilite = kControlButtonPart;
+ break;
+ case TYPE_RADIO_BUTTON:
+ (**controlHandle).contrlHilite = kControlRadioButtonPart;
+ break;
+ case TYPE_CHECK_BUTTON:
+ (**controlHandle).contrlHilite = kControlCheckBoxPart;
+ break;
+ }
+ } else if (butPtr->state == tkDisabledUid) {
+ (**controlHandle).contrlHilite = kControlInactivePart;
+ } else {
+ (**controlHandle).contrlHilite = kControlNoPart;
+ }
+
+ /*
+ * Now swap in the passed in GWorld for the portBits of our fake
+ * window. We also adjust various fields in the WindowRecord to make
+ * the system think this is a normal window.
+ */
+
+ ((CWindowPeek) windowRef)->port.portPixMap = destPort->portPixMap;
+ ((CWindowPeek) windowRef)->port.portRect = destPort->portRect;
+ RectRgn(((CWindowPeek) windowRef)->port.visRgn, &destPort->portRect);
+ RectRgn(((CWindowPeek) windowRef)->strucRgn, &destPort->portRect);
+ RectRgn(((CWindowPeek) windowRef)->updateRgn, &destPort->portRect);
+ RectRgn(((CWindowPeek) windowRef)->contRgn, &destPort->portRect);
+ PortChanged(windowRef);
+
+ /*
+ * Before we draw the control we must add the hidden window back to the
+ * main window list. Otherwise, radiobuttons and checkbuttons will draw
+ * incorrectly. I don't really know why - but clearly the control draw
+ * proc needs to have the controls window in the window list.
+ */
+
+ ((CWindowPeek) windowRef)->nextWindow = (CWindowPeek) LMGetWindowList();
+ LMSetWindowList(windowRef);
+
+ /*
+ * Now we can set the port to our doctered up window. We next need
+ * to muck with the colors for the port & window to draw the control
+ * with the proper Tk colors. If we need to we also draw a default
+ * ring for buttons.
+ */
+
+ SetPort(windowRef);
+ windowColorChanged = UpdateControlColors(butPtr, controlHandle,
+ ccTabHandle, &saveBackColor);
+ Draw1Control(controlHandle);
+ if ((butPtr->type == TYPE_BUTTON) &&
+ (butPtr->defaultState == tkActiveUid)) {
+ Rect box = (**controlHandle).contrlRect;
+ RGBColor rgbColor;
+
+ TkSetMacColor(butPtr->highlightColorPtr->pixel, &rgbColor);
+ RGBForeColor(&rgbColor);
+ PenSize(butPtr->highlightWidth - 1, butPtr->highlightWidth - 1);
+ InsetRect(&box, -butPtr->highlightWidth, -butPtr->highlightWidth);
+ FrameRoundRect(&box, 16, 16);
+ }
+ if (windowColorChanged) {
+ RGBColor dummyColor;
+ ChangeBackgroundWindowColor(windowRef, saveBackColor, &dummyColor);
+ }
+
+ /*
+ * Clean up: remove the hidden window from the main window list.
+ */
+
+ LMSetWindowList((WindowRef) ((CWindowPeek) windowRef)->nextWindow);
+}
+
+/*
+ *--------------------------------------------------------------
+ *
+ * UpdateControlColors --
+ *
+ * This function will review the colors used to display
+ * a Macintosh button. If any non-standard colors are
+ * used we create a custom palette for the button, populate
+ * with the colors for the button and install the palette.
+ *
+ * Results:
+ * None.
+ *
+ * Side effects:
+ * The Macintosh control may get a custom palette installed.
+ *
+ *--------------------------------------------------------------
+ */
+
+static int
+UpdateControlColors(
+ TkButton *butPtr,
+ ControlRef controlHandle,
+ CCTabHandle ccTabHandle,
+ RGBColor *saveColorPtr)
+{
+ XColor *xcolor;
+
+ xcolor = Tk_3DBorderColor(butPtr->normalBorder);
+
+ (**ccTabHandle).ccSeed = 0;
+ (**ccTabHandle).ccRider = 0;
+ (**ccTabHandle).ctSize = 3;
+ (**ccTabHandle).ctTable[0].value = cBodyColor;
+ TkSetMacColor(xcolor->pixel,
+ &(**ccTabHandle).ctTable[0].rgb);
+ (**ccTabHandle).ctTable[1].value = cTextColor;
+ TkSetMacColor(butPtr->normalFg->pixel,
+ &(**ccTabHandle).ctTable[1].rgb);
+ (**ccTabHandle).ctTable[2].value = cFrameColor;
+ TkSetMacColor(butPtr->highlightColorPtr->pixel,
+ &(**ccTabHandle).ctTable[2].rgb);
+ SetControlColor(controlHandle, ccTabHandle);
+
+ if (((xcolor->pixel >> 24) != CONTROL_BODY_PIXEL) &&
+ ((butPtr->type == TYPE_CHECK_BUTTON) ||
+ (butPtr->type == TYPE_RADIO_BUTTON))) {
+ RGBColor newColor;
+
+ TkSetMacColor(xcolor->pixel, &newColor);
+ ChangeBackgroundWindowColor((**controlHandle).contrlOwner,
+ newColor, saveColorPtr);
+ return true;
+ }
+
+ return false;
+}
+
+/*
+ *--------------------------------------------------------------
+ *
+ * ChangeBackgroundWindowColor --
+ *
+ * This procedure will change the background color entry
+ * in the Window's colortable. The system isn't notified
+ * of the change. This call should only be used to fool
+ * the drawing routines for checkboxes and radiobuttons.
+ * Any change should be temporary and be reverted after
+ * the widget is drawn.
+ *
+ * Results:
+ * None.
+ *
+ * Side effects:
+ * The Window's color table will be adjusted.
+ *
+ *--------------------------------------------------------------
+ */
+
+static void
+ChangeBackgroundWindowColor(
+ WindowRef macintoshWindow, /* A Mac window whose color to change. */
+ RGBColor rgbColor, /* The new RGB Color for the background. */
+ RGBColor *oldColor) /* The old color of the background. */
+{
+ AuxWinHandle auxWinHandle;
+ WCTabHandle winCTabHandle;
+ short ctIndex;
+ ColorSpecPtr rgbScan;
+
+ GetAuxWin(macintoshWindow, &auxWinHandle);
+ winCTabHandle = (WCTabHandle) ((**auxWinHandle).awCTable);
+
+ /*
+ * Scan through the color table until we find the content
+ * (background) color for the window. Don't tell the system
+ * about the change - it will generate damage and we will get
+ * into an infinite loop.
+ */
+
+ ctIndex = (**winCTabHandle).ctSize;
+ while (ctIndex > -1) {
+ rgbScan = ctIndex + (**winCTabHandle).ctTable;
+
+ if (rgbScan->value == wContentColor) {
+ *oldColor = rgbScan->rgb;
+ rgbScan->rgb = rgbColor;
+ break;
+ }
+ ctIndex--;
+ }
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * ButtonExitProc --
+ *
+ * This procedure is invoked just before the application exits.
+ * It frees all of the control handles, our dummy window, etc.
+ *
+ * Results:
+ * None.
+ *
+ * Side effects:
+ * Memory is freed.
+ *
+ *----------------------------------------------------------------------
+ */
+
+static void
+ButtonExitProc(clientData)
+ ClientData clientData; /* Not used. */
+{
+ Rect pixRect = {0, 0, 10, 10};
+ Rect rgnRect = {0, 0, 0, 0};
+
+ /*
+ * Restore our dummy window to it's origional state by putting it
+ * back in the window list and restoring it's bits. The destroy
+ * the controls and window.
+ */
+
+ ((CWindowPeek) windowRef)->nextWindow = (CWindowPeek) LMGetWindowList();
+ LMSetWindowList(windowRef);
+ ((CWindowPeek) windowRef)->port.portPixMap = oldPixPtr;
+ ((CWindowPeek) windowRef)->port.portRect = pixRect;
+ RectRgn(((CWindowPeek) windowRef)->port.visRgn, &rgnRect);
+ RectRgn(((CWindowPeek) windowRef)->strucRgn, &rgnRect);
+ RectRgn(((CWindowPeek) windowRef)->updateRgn, &rgnRect);
+ RectRgn(((CWindowPeek) windowRef)->contRgn, &rgnRect);
+ PortChanged(windowRef);
+
+ DisposeControl(buttonHandle);
+ DisposeControl(checkHandle);
+ DisposeControl(radioHandle);
+ DisposeWindow(windowRef);
+ windowRef = NULL;
+}