开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 通讯编程 > 查看源码
tkMacButton.c
资源名称：ns-allinone-2.33.tar.gz　[点击查看]
上传用户：rrhhcc
上传日期：2015-12-11
资源大小：54129k
文件大小：51k
源码类别：

通讯编程

开发平台：

Visual C++

tkMacButton.c：源码内容
  1. /* 
  2.  * tkMacButton.c --
  3.  *
  4.  * This file implements the Macintosh specific portion of the
  5.  * button widgets.
  6.  *
  7.  * Copyright (c) 1996-1997 by Sun Microsystems, Inc.
  8.  *
  9.  * See the file "license.terms" for information on usage and redistribution
  10.  * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
  11.  *
  12.  * RCS: @(#) $Id: tkMacButton.c,v 1.17.2.3 2004/10/27 00:37:38 davygrvy Exp $
  13.  */
  15. #include "tkButton.h"
  16. #include "tkMacInt.h"
  17. #include <Controls.h>
  18. #include <ControlDefinitions.h>
  19. #include <LowMem.h>
  20. #include <Appearance.h>
  23. #include <ToolUtils.h>
  25. /*
  26.  * Some defines used to control what type of control is drawn.
  27.  */
  29. #define DRAW_LABEL 0 /* Labels are treated genericly. */
  30. #define DRAW_CONTROL 1 /* Draw using the Native control. */
  31. #define DRAW_CUSTOM 2 /* Make our own button drawing. */
  32. #define DRAW_BEVEL 3
  34. /*
  35.  * The following structures are used to draw our controls.  Rather than
  36.  * having many Mac controls we just use one control of each type and
  37.  * reuse them for all Tk widgets.  When the windowRef variable is NULL
  38.  * it means none of the data structures have been allocated.
  39.  */
  41. static WindowRef windowRef = NULL;
  42. static CWindowRecord windowRecord;
  43. static ControlRef buttonHandle;
  44. static ControlRef checkHandle;
  45. static ControlRef radioHandle;
  46. static ControlRef smallBevelHandle;
  47. static ControlRef smallStickyBevelHandle;
  48. static ControlRef medBevelHandle;
  49. static ControlRef medStickyBevelHandle;
  50. static ControlRef largeBevelHandle;
  51. static ControlRef largeStickyBevelHandle;
  53. /*
  54.  * These are used to store the image content for
  55.  * beveled buttons - i.e. buttons with images.
  56.  */
  57.  
  58. static ControlButtonContentInfo bevelButtonContent;
  59. static OpenCPicParams picParams;
  61. static CCTabHandle buttonTabHandle;
  62. static CCTabHandle checkTabHandle;
  63. static CCTabHandle radioTabHandle;
  64. static PixMapHandle oldPixPtr;
  66. /*
  67.  * These functions are used when Appearance is present.
  68.  * By embedding all our controls in a userPane control,
  69.  * we can color the background of the text in radiobuttons
  70.  * and checkbuttons.  Thanks to Peter Gontier of Apple DTS
  71.  * for help on this one.
  72.  */
  74. static ControlRef userPaneHandle;
  75. static RGBColor gUserPaneBackground = { ~0, ~0, ~0};
  76. static pascal OSErr SetUserPaneDrawProc(ControlRef control,
  77. ControlUserPaneDrawProcPtr upp);
  78. static pascal OSErr SetUserPaneSetUpSpecialBackgroundProc(ControlRef control,
  79. ControlUserPaneBackgroundProcPtr upp);
  80. static pascal void UserPaneDraw(ControlRef control, ControlPartCode cpc);
  81. static pascal void UserPaneBackgroundProc(ControlHandle,
  82. ControlBackgroundPtr info);
  84. /*
  85.  * Forward declarations for procedures defined later in this file:
  86.  */
  88. static void ButtonEventProc _ANSI_ARGS_((
  89.     ClientData clientData, XEvent *eventPtr));
  90. static int UpdateControlColors _ANSI_ARGS_((TkButton *butPtr,
  91. ControlRef controlHandle, CCTabHandle ccTabHandle,
  92. RGBColor *saveColorPtr));
  93. static void DrawBufferedControl _ANSI_ARGS_((TkButton *butPtr,
  94. GWorldPtr destPort, GC gc, Pixmap pixmap));
  95. static void InitSampleControls();
  96. static void SetupBevelButton _ANSI_ARGS_((TkButton *butPtr,
  97. ControlRef controlHandle, 
  98. GWorldPtr destPort, GC gc, Pixmap pixmap));
  99. static void ChangeBackgroundWindowColor _ANSI_ARGS_((
  100.     WindowRef macintoshWindow, RGBColor rgbColor,
  101.     RGBColor *oldColor));
  102. static void ButtonExitProc _ANSI_ARGS_((ClientData clientData));
  104. /*
  105.  * The class procedure table for the button widgets.
  106.  */
  108. Tk_ClassProcs tkpButtonProcs = { 
  109.     sizeof(Tk_ClassProcs), /* size */
  110.     TkButtonWorldChanged, /* worldChangedProc */
  111. };
  113. /*
  114.  *----------------------------------------------------------------------
  115.  *
  116.  * TkpCreateButton --
  117.  *
  118.  * Allocate a new TkButton structure.
  119.  *
  120.  * Results:
  121.  * Returns a newly allocated TkButton structure.
  122.  *
  123.  * Side effects:
  124.  * Registers an event handler for the widget.
  125.  *
  126.  *----------------------------------------------------------------------
  127.  */
  129. TkButton *
  130. TkpCreateButton(
  131.     Tk_Window tkwin)
  132. {
  133.     TkButton *buttonPtr;
  134.     buttonPtr = (TkButton *) ckalloc(sizeof(TkButton));
  135.     Tk_CreateEventHandler(tkwin, ActivateMask,
  136.     ButtonEventProc, (ClientData) buttonPtr);
  137.     return buttonPtr;
  138. }
  140. /*
  141.  *----------------------------------------------------------------------
  142.  *
  143.  * TkpDisplayButton --
  144.  *
  145.  * This procedure is invoked to display a button widget.  It is
  146.  * normally invoked as an idle handler.
  147.  *
  148.  * Results:
  149.  * None.
  150.  *
  151.  * Side effects:
  152.  * Commands are output to X to display the button in its
  153.  * current mode.  The REDRAW_PENDING flag is cleared.
  154.  *
  155.  *----------------------------------------------------------------------
  156.  */
  158. void
  159. TkpDisplayButton(
  160.     ClientData clientData) /* Information about widget. */
  161. {
  162.     TkButton *butPtr = (TkButton *) clientData;
  163.     Pixmap pixmap;
  164.     GC gc;
  165.     Tk_3DBorder border;
  166.     int x = 0; /* Initialization only needed to stop
  167.  * compiler warning. */
  168.     int y, relief;
  169.     register Tk_Window tkwin = butPtr->tkwin;
  170.     int width, height, fullWidth, fullHeight;
  171.     int textXOffset, textYOffset;
  172.     int haveImage = 0, haveText = 0;
  173.     int offset; /* 0 means this is a normal widget.  1 means
  174.  * it is an image button, so we offset the
  175.  * image to make the button appear to move
  176.  * up and down as the relief changes. */
  177.     int hasImageOrBitmap;
  178.     CGrafPtr saveWorld;
  179.     GDHandle saveDevice;
  180.     GWorldPtr destPort;
  181.     int drawType, borderWidth;
  182.     int imageWidth, imageHeight;
  183.     int imageXOffset = 0, imageYOffset = 0; /* image information that will
  184.      * be used to restrict disabled
  185.      * pixmap as well */
  187.     GetGWorld(&saveWorld, &saveDevice);
  189.     butPtr->flags &= ~REDRAW_PENDING;
  190.     if ((butPtr->tkwin == NULL) || !Tk_IsMapped(tkwin)) {
  191. return;
  192.     }
  194.     /*
  195.      * In order to avoid screen flashes, this procedure redraws
  196.      * the button in a pixmap, then copies the pixmap to the
  197.      * screen in a single operation.  This means that there's no
  198.      * point in time where the on-sreen image has been cleared.
  199.      */
  201.     pixmap = Tk_GetPixmap(butPtr->display, Tk_WindowId(tkwin),
  202.     Tk_Width(tkwin), Tk_Height(tkwin), Tk_Depth(tkwin));
  204.     hasImageOrBitmap = ((butPtr->image != NULL) || (butPtr->bitmap != None));
  205.     offset = (butPtr->type == TYPE_BUTTON) && hasImageOrBitmap;
  207.     border = butPtr->normalBorder;
  208.     if ((butPtr->state == STATE_DISABLED) && (butPtr->disabledFg != NULL)) {
  209. gc = butPtr->disabledGC;
  210.     } else if ((butPtr->type == TYPE_BUTTON)
  211.     && (butPtr->state == STATE_ACTIVE)) {
  212. gc = butPtr->activeTextGC;
  213. border = butPtr->activeBorder;
  214.     } else {
  215. gc = butPtr->normalTextGC;
  216.     }
  217.     
  218.     if ((butPtr->flags & SELECTED) && (butPtr->state != STATE_ACTIVE)
  219.     && (butPtr->selectBorder != NULL) && !butPtr->indicatorOn) {
  220. border = butPtr->selectBorder;
  221.     }
  223.     /*
  224.      * Override the relief specified for the button if this is a
  225.      * checkbutton or radiobutton and there's no indicator.
  226.      * However, don't do this in the presence of Appearance, since
  227.      * then the bevel button will take care of the relief.
  228.      */
  230.     relief = butPtr->relief;
  232.     if ((butPtr->type >= TYPE_CHECK_BUTTON) && !butPtr->indicatorOn) { 
  233. if (!TkMacHaveAppearance() || !hasImageOrBitmap) {
  234.     if (butPtr->flags & SELECTED) {
  235. relief = TK_RELIEF_SUNKEN;
  236.     } else if (butPtr->overRelief != relief) {
  237. relief = butPtr->offRelief;
  238.     }
  239. }
  240.     }
  242.     /*
  243.      * See the comment in UpdateControlColors as to why we use the 
  244.      * highlightbackground for the border of Macintosh buttons.
  245.      */
  246.      
  247.     if (butPtr->type == TYPE_BUTTON) {
  248. Tk_Fill3DRectangle(tkwin, pixmap, butPtr->highlightBorder, 0, 0,
  249. Tk_Width(tkwin), Tk_Height(tkwin), 0, TK_RELIEF_FLAT);
  250.     } else {
  251. Tk_Fill3DRectangle(tkwin, pixmap, butPtr->normalBorder, 0, 0,
  252. Tk_Width(tkwin), Tk_Height(tkwin), 0, TK_RELIEF_FLAT);
  253.     }
  254.    
  255.     if (butPtr->type == TYPE_LABEL) {
  256. drawType = DRAW_LABEL;
  257.     } else if (butPtr->type == TYPE_BUTTON) {
  258. if (!hasImageOrBitmap) {
  259.     drawType = DRAW_CONTROL;
  260. } else if (butPtr->image != None) {
  261.     drawType = DRAW_BEVEL;
  262. } else {
  263.     /*
  264.      * TO DO - The current way the we draw bitmaps (XCopyPlane)
  265.      * uses CopyDeepMask in this one case.  The Picture recording 
  266.      * does not record this call, and so we can't use the
  267.      * Appearance bevel button here.  The only case that would
  268.      * exercise this is if you use a bitmap, with
  269.      * -data & -mask specified.  We should probably draw the 
  270.      * appearance button and overprint the image in this case.
  271.      * This just punts and draws the old-style, ugly, button.
  272.      */
  273.      
  274.     if (gc->clip_mask == 0) {
  275. drawType = DRAW_BEVEL;
  276.     } else {
  277. TkpClipMask *clipPtr = (TkpClipMask*) gc->clip_mask;
  278. if ((clipPtr->type == TKP_CLIP_PIXMAP) &&
  279. (clipPtr->value.pixmap != butPtr->bitmap)) {
  280.     drawType = DRAW_CUSTOM;
  281. } else {
  282.     drawType = DRAW_BEVEL;
  283. }
  284.     }
  285. }
  286.     } else {
  287. if (butPtr->indicatorOn) {
  288.     drawType = DRAW_CONTROL;
  289. } else if (hasImageOrBitmap) {
  290.     if (gc->clip_mask == 0) {
  291. drawType = DRAW_BEVEL;
  292.     } else {
  293. TkpClipMask *clipPtr = (TkpClipMask*) gc->clip_mask;
  294. if ((clipPtr->type == TKP_CLIP_PIXMAP) &&
  295. (clipPtr->value.pixmap != butPtr->bitmap)) {
  296.     drawType = DRAW_CUSTOM;
  297. } else {
  298.     drawType = DRAW_BEVEL;
  299. }
  300.     }
  301. } else {
  302.     drawType = DRAW_CUSTOM;
  303. }
  304.     }
  306.     /*
  307.      * Draw the native portion of the buttons. Start by creating the control
  308.      * if it doesn't already exist.  Then configure the Macintosh control from
  309.      * the Tk info.  Finally, we call Draw1Control to draw to the screen.
  310.      */
  312.     if ((drawType == DRAW_CONTROL) || 
  313.     ((drawType == DRAW_BEVEL) && TkMacHaveAppearance())) {
  314. borderWidth = 0;
  316. /*
  317.  * This part uses Macintosh rather than Tk calls to draw
  318.  * to the screen.  Make sure the ports etc. are set correctly.
  319.  */
  321. destPort = TkMacGetDrawablePort(pixmap);
  322. SetGWorld(destPort, NULL);
  323. DrawBufferedControl(butPtr, destPort, gc, pixmap);
  324.     }
  326.     if ((drawType == DRAW_CUSTOM) || (drawType == DRAW_LABEL)) {
  327. borderWidth = butPtr->borderWidth;
  328.     }
  330.     /*
  331.      * Display image or bitmap or text for button.  This has
  332.      * already been done under Appearance with the Bevel
  333.      * button types.
  334.      */
  336.     if ((drawType == DRAW_BEVEL) && TkMacHaveAppearance()) {
  337. /* Empty Body */
  338.     } else {
  339. if (butPtr->image != None) {
  340.     Tk_SizeOfImage(butPtr->image, &width, &height);
  341.     haveImage = 1;
  342. } else if (butPtr->bitmap != None) {
  343.     Tk_SizeOfBitmap(butPtr->display, butPtr->bitmap, &width, &height);
  344.     haveImage = 1;
  345. }
  346. imageWidth  = width;
  347. imageHeight = height;
  349. haveText = (butPtr->textWidth != 0 && butPtr->textHeight != 0);
  350. if (butPtr->compound != COMPOUND_NONE && haveImage && haveText) {
  351.     textXOffset = 0;
  352.     textYOffset = 0;
  353.     fullWidth = 0;
  354.     fullHeight = 0;
  355.     
  356.     switch ((enum compound) butPtr->compound) {
  357. case COMPOUND_TOP: 
  358. case COMPOUND_BOTTOM: {
  359.     /* Image is above or below text */
  360.     if (butPtr->compound == COMPOUND_TOP) {
  361. textYOffset = height + butPtr->padY;
  362.     } else {
  363. imageYOffset = butPtr->textHeight + butPtr->padY;
  364.     }
  365.     fullHeight = height + butPtr->textHeight + butPtr->padY;
  366.     fullWidth = (width > butPtr->textWidth ? width :
  367.     butPtr->textWidth);
  368.     textXOffset = (fullWidth - butPtr->textWidth)/2;
  369.     imageXOffset = (fullWidth - width)/2;
  370.     break;
  371. }
  372. case COMPOUND_LEFT:
  373. case COMPOUND_RIGHT: {
  374.     /* Image is left or right of text */
  375.     if (butPtr->compound == COMPOUND_LEFT) {
  376. textXOffset = width + butPtr->padX;
  377.     } else {
  378. imageXOffset = butPtr->textWidth + butPtr->padX;
  379.     }
  380.     fullWidth = butPtr->textWidth + butPtr->padX + width;
  381.     fullHeight = (height > butPtr->textHeight ? height :
  382.     butPtr->textHeight);
  383.     textYOffset = (fullHeight - butPtr->textHeight)/2;
  384.     imageYOffset = (fullHeight - height)/2;
  385.     break;
  386. }
  387. case COMPOUND_CENTER: {
  388.     /* Image and text are superimposed */
  389.     fullWidth = (width > butPtr->textWidth ? width :
  390.     butPtr->textWidth);
  391.     fullHeight = (height > butPtr->textHeight ? height :
  392.     butPtr->textHeight);
  393.     textXOffset = (fullWidth - butPtr->textWidth)/2;
  394.     imageXOffset = (fullWidth - width)/2;
  395.     textYOffset = (fullHeight - butPtr->textHeight)/2;
  396.     imageYOffset = (fullHeight - height)/2;
  397.     break;
  398. }
  399. case COMPOUND_NONE: {break;}
  400.     }
  401.     
  402.     TkComputeAnchor(butPtr->anchor, tkwin, butPtr->padX, butPtr->padY,
  403.     butPtr->indicatorSpace + fullWidth, fullHeight, &x, &y);
  404.     
  405.     x += butPtr->indicatorSpace;
  406.     
  407.     x += offset;
  408.     y += offset;
  409.     if (relief == TK_RELIEF_RAISED) {
  410. x -= offset;
  411. y -= offset;
  412.     } else if (relief == TK_RELIEF_SUNKEN) {
  413. x += offset;
  414. y += offset;
  415.     }
  416.     imageXOffset += x;
  417.     imageYOffset += y;
  418.     if (butPtr->image != NULL) {
  419. if ((butPtr->selectImage != NULL) &&
  420. (butPtr->flags & SELECTED)) {
  421.     Tk_RedrawImage(butPtr->selectImage, 0, 0,
  422.     width, height, pixmap, imageXOffset, imageYOffset);
  423. } else {
  424.     Tk_RedrawImage(butPtr->image, 0, 0, width,
  425.     height, pixmap, imageXOffset, imageYOffset);
  426. }
  427.     } else {
  428. XSetClipOrigin(butPtr->display, gc,
  429. imageXOffset, imageYOffset);
  430. XCopyPlane(butPtr->display, butPtr->bitmap, pixmap, gc,
  431. 0, 0, (unsigned int) width, (unsigned int) height,
  432. imageXOffset, imageYOffset, 1);
  433. XSetClipOrigin(butPtr->display, gc, 0, 0);
  434.     }
  435.     
  436.     Tk_DrawTextLayout(butPtr->display, pixmap, gc, butPtr->textLayout,
  437.     x + textXOffset, y + textYOffset, 0, -1);
  438.     Tk_UnderlineTextLayout(butPtr->display, pixmap, gc,
  439.     butPtr->textLayout, x + textXOffset, y + textYOffset,
  440.     butPtr->underline);
  441.     y += fullHeight/2;
  442. } else {
  443.     if (haveImage) {
  444. TkComputeAnchor(butPtr->anchor, tkwin, 0, 0,
  445. butPtr->indicatorSpace + width, height, &x, &y);
  446. x += butPtr->indicatorSpace;
  448. x += offset;
  449. y += offset;
  450. if (relief == TK_RELIEF_RAISED) {
  451.     x -= offset;
  452.     y -= offset;
  453. } else if (relief == TK_RELIEF_SUNKEN) {
  454.     x += offset;
  455.     y += offset;
  456. }
  457. imageXOffset += x;
  458. imageYOffset += y;
  459. if (butPtr->image != NULL) {
  460.     if ((butPtr->selectImage != NULL) &&
  461.     (butPtr->flags & SELECTED)) {
  462. Tk_RedrawImage(butPtr->selectImage, 0, 0, width,
  463. height, pixmap, imageXOffset, imageYOffset);
  464.     } else {
  465. Tk_RedrawImage(butPtr->image, 0, 0, width, height,
  466. pixmap, imageXOffset, imageYOffset);
  467.     }
  468. } else {
  469.     XSetClipOrigin(butPtr->display, gc, x, y);
  470.     XCopyPlane(butPtr->display, butPtr->bitmap, pixmap, gc,
  471.     0, 0, (unsigned int) width,
  472.     (unsigned int) height, x, y, 1);
  473.     XSetClipOrigin(butPtr->display, gc, 0, 0);
  474. }
  475. y += height/2;
  476.     } else {
  477. TkComputeAnchor(butPtr->anchor, tkwin, butPtr->padX,
  478. butPtr->padY,
  479. butPtr->indicatorSpace + butPtr->textWidth,
  480. butPtr->textHeight, &x, &y);
  482. x += butPtr->indicatorSpace;
  484. Tk_DrawTextLayout(butPtr->display, pixmap, gc,
  485. butPtr->textLayout, x, y, 0, -1);
  486. y += butPtr->textHeight/2;
  487.     }
  488. }
  489.     }
  491.     /*
  492.      * If the button is disabled with a stipple rather than a special
  493.      * foreground color, generate the stippled effect. If the widget
  494.      * is selected and we use a different background color when selected,
  495.      * must temporarily modify the GC so the stippling is the right color.
  496.      */
  498.     if ((butPtr->state == STATE_DISABLED)
  499.     && ((butPtr->disabledFg == NULL) || (butPtr->image != NULL))) {
  500. if ((butPtr->flags & SELECTED) && !butPtr->indicatorOn
  501. && (butPtr->selectBorder != NULL)) {
  502.     XSetForeground(butPtr->display, butPtr->stippleGC,
  503.     Tk_3DBorderColor(butPtr->selectBorder)->pixel);
  504. }
  505. /*
  506.  * Stipple the whole button if no disabledFg was specified,
  507.  * otherwise restrict stippling only to displayed image
  508.  */
  509. if (butPtr->disabledFg == NULL) {
  510.     XFillRectangle(butPtr->display, pixmap, butPtr->stippleGC, 0, 0,
  511.     (unsigned) Tk_Width(tkwin), (unsigned) Tk_Height(tkwin));
  512. } else {
  513.     XFillRectangle(butPtr->display, pixmap, butPtr->stippleGC,
  514.     imageXOffset, imageYOffset,
  515.     (unsigned) imageWidth, (unsigned) imageHeight);
  516. }
  517. if ((butPtr->flags & SELECTED) && !butPtr->indicatorOn
  518. && (butPtr->selectBorder != NULL)) {
  519.     XSetForeground(butPtr->display, butPtr->stippleGC,
  520.     Tk_3DBorderColor(butPtr->normalBorder)->pixel);
  521. }
  522.     }
  524.     /*
  525.      * Draw the border and traversal highlight last.  This way, if the
  526.      * button's contents overflow they'll be covered up by the border.
  527.      */
  529.     if (relief != TK_RELIEF_FLAT) {
  530. int inset = butPtr->highlightWidth;
  531. Tk_Draw3DRectangle(tkwin, pixmap, border, inset, inset,
  532. Tk_Width(tkwin) - 2*inset, Tk_Height(tkwin) - 2*inset,
  533. butPtr->borderWidth, relief);
  534.     }
  536.     /*
  537.      * Copy the information from the off-screen pixmap onto the screen,
  538.      * then delete the pixmap.
  539.      */
  541.     XCopyArea(butPtr->display, pixmap, Tk_WindowId(tkwin),
  542.     butPtr->copyGC, 0, 0, (unsigned) Tk_Width(tkwin),
  543.     (unsigned) Tk_Height(tkwin), 0, 0);
  544.     Tk_FreePixmap(butPtr->display, pixmap);
  546.     SetGWorld(saveWorld, saveDevice);
  547. }
  549. /*
  550.  *----------------------------------------------------------------------
  551.  *
  552.  * TkpComputeButtonGeometry --
  553.  *
  554.  * After changes in a button's text or bitmap, this procedure
  555.  * recomputes the button's geometry and passes this information
  556.  * along to the geometry manager for the window.
  557.  *
  558.  * Results:
  559.  * None.
  560.  *
  561.  * Side effects:
  562.  * The button's window may change size.
  563.  *
  564.  *----------------------------------------------------------------------
  565.  */
  567. void
  568. TkpComputeButtonGeometry(
  569.     TkButton *butPtr) /* Button whose geometry may have changed. */
  570. {
  571.     int width, height, avgWidth, haveImage = 0, haveText = 0;
  572.     int txtWidth, txtHeight;
  573.     Tk_FontMetrics fm;
  575.     width = 0;
  576.     height = 0;
  577.     txtWidth = 0;
  578.     txtHeight = 0;
  579.     avgWidth = 0;
  581.     /*
  582.      * First figure out the size of the contents of the button.
  583.      */
  584.      
  585.     butPtr->indicatorSpace = 0;
  586.     if (butPtr->image != NULL) {
  587. Tk_SizeOfImage(butPtr->image, &width, &height);
  588. haveImage = 1;
  589.     } else if (butPtr->bitmap != None) {
  590. Tk_SizeOfBitmap(butPtr->display, butPtr->bitmap, &width, &height);
  591. haveImage = 1;
  592.     }
  594.     if (haveImage == 0 || butPtr->compound != COMPOUND_NONE) {
  595. Tk_FreeTextLayout(butPtr->textLayout);
  596. butPtr->textLayout = Tk_ComputeTextLayout(butPtr->tkfont,
  597. Tcl_GetString(butPtr->textPtr), -1, butPtr->wrapLength,
  598. butPtr->justify, 0, &butPtr->textWidth, &butPtr->textHeight);
  600. txtWidth = butPtr->textWidth;
  601. txtHeight = butPtr->textHeight;
  602. avgWidth = Tk_TextWidth(butPtr->tkfont, "0", 1);
  603. Tk_GetFontMetrics(butPtr->tkfont, &fm);
  604. haveText = (txtWidth != 0 && txtHeight != 0);
  605.     }
  607.     /*
  608.      * If the button is compound (ie, it shows both an image and text),
  609.      * the new geometry is a combination of the image and text geometry.
  610.      * We only honor the compound bit if the button has both text and an
  611.      * image, because otherwise it is not really a compound button.
  612.      */
  614.     if (butPtr->compound != COMPOUND_NONE && haveImage && haveText) {
  615. switch ((enum compound) butPtr->compound) {
  616.     case COMPOUND_TOP:
  617.     case COMPOUND_BOTTOM: {
  618. /* Image is above or below text */
  619. height += txtHeight + butPtr->padY;
  620. width = (width > txtWidth ? width : txtWidth);
  621. break;
  622.     }
  623.     case COMPOUND_LEFT:
  624.     case COMPOUND_RIGHT: {
  625. /* Image is left or right of text */
  626. width += txtWidth + butPtr->padX;
  627. height = (height > txtHeight ? height : txtHeight);
  628. break;
  629.     }
  630.     case COMPOUND_CENTER: {
  631. /* Image and text are superimposed */
  632. width = (width > txtWidth ? width : txtWidth);
  633. height = (height > txtHeight ? height : txtHeight);
  634. break;
  635.     }
  636.     case COMPOUND_NONE: {break;}
  637. }
  638. if (butPtr->width > 0) {
  639.     width = butPtr->width;
  640. }
  641. if (butPtr->height > 0) {
  642.     height = butPtr->height;
  643. }
  645. if ((butPtr->type >= TYPE_CHECK_BUTTON) && butPtr->indicatorOn) {
  646.     butPtr->indicatorSpace = height;
  647.     if (butPtr->type == TYPE_CHECK_BUTTON) {
  648. butPtr->indicatorDiameter = (65*height)/100;
  649.     } else {
  650. butPtr->indicatorDiameter = (75*height)/100;
  651.     }
  652. }
  654. width += 2*butPtr->padX;
  655. height += 2*butPtr->padY;
  657.     } else {
  658. if (haveImage) {
  659.     if (butPtr->width > 0) {
  660. width = butPtr->width;
  661.     }
  662.     if (butPtr->height > 0) {
  663. height = butPtr->height;
  664.     }
  665.     if ((butPtr->type >= TYPE_CHECK_BUTTON) && butPtr->indicatorOn) {
  666. butPtr->indicatorSpace = height;
  667. if (butPtr->type == TYPE_CHECK_BUTTON) {
  668.     butPtr->indicatorDiameter = (65*height)/100;
  669. } else {
  670.     butPtr->indicatorDiameter = (75*height)/100;
  671. }
  672.     }
  673. } else {
  674.     width = txtWidth;
  675.     height = txtHeight;
  676.     if (butPtr->width > 0) {
  677. width = butPtr->width * avgWidth;
  678.     }
  679.     if (butPtr->height > 0) {
  680. height = butPtr->height * fm.linespace;
  681.     }
  682.     if ((butPtr->type >= TYPE_CHECK_BUTTON) && butPtr->indicatorOn) {
  683. butPtr->indicatorDiameter = fm.linespace;
  684. if (butPtr->type == TYPE_CHECK_BUTTON) {
  685.     butPtr->indicatorDiameter =
  686. (80*butPtr->indicatorDiameter)/100;
  687. }
  688. butPtr->indicatorSpace = butPtr->indicatorDiameter + avgWidth;
  689.     }
  690. }
  691.     }
  693.     /*
  694.      * Now figure out the size of the border decorations for the button.
  695.      */
  696.      
  697.     if (butPtr->highlightWidth < 0) {
  698. butPtr->highlightWidth = 0;
  699.     }
  700.     
  701.     /*
  702.      * The width and height calculation for Appearance buttons with images & 
  703.      * non-Appearance buttons with images is different.  In the latter case, 
  704.      * we add the borderwidth to the inset, since we are going to stamp a
  705.      * 3-D border over the image.  In the former, we add it to the height,
  706.      * directly, since Appearance will draw the border as part of our control.
  707.      *
  708.      * When issuing the geometry request, add extra space for the indicator,
  709.      * if any, and for the border and padding, plus if this is an image two 
  710.      * extra pixels so the display can be offset by 1 pixel in either
  711.      * direction for the raised or lowered effect.
  712.      *
  713.      * The highlight width corresponds to the default ring on the Macintosh.
  714.      * As such, the highlight width is only added if the button is the default
  715.      * button. The actual width of the default ring is one less than the
  716.      * highlight width as there is also one pixel of spacing.
  717.      * Appearance buttons with images do not have a highlight ring, because the 
  718.      * Bevel button type does not support one.
  719.      */
  721.     if ((butPtr->image == None) && (butPtr->bitmap == None)) {
  722. width += 2*butPtr->padX;
  723. height += 2*butPtr->padY;
  724.     }
  725.     
  726.     if ((butPtr->type == TYPE_BUTTON)) {
  727. if ((butPtr->image == None) && (butPtr->bitmap == None)) {
  728.     butPtr->inset = 0;
  729.     if (butPtr->defaultState != STATE_DISABLED) {
  730. butPtr->inset += butPtr->highlightWidth;
  731.     }
  732. } else if (TkMacHaveAppearance()) {
  733.     butPtr->inset = 0;
  734.     width += (2 * butPtr->borderWidth + 4);
  735.     height += (2 * butPtr->borderWidth + 4);
  736. } else {
  737.     butPtr->inset = butPtr->borderWidth;
  738.     width += 2;
  739.     height += 2;
  740.     if (butPtr->defaultState != STATE_DISABLED) {
  741. butPtr->inset += butPtr->highlightWidth;
  742.     }
  743. }
  744.     } else if ((butPtr->type != TYPE_LABEL)) {
  745. if (butPtr->indicatorOn) {
  746.     butPtr->inset = 0;
  747. } else {
  748.     /*
  749.      * Under Appearance, the Checkbutton or radiobutton with an image
  750.      * is represented by a BevelButton with the Sticky defProc...  
  751.      * So we must set its height in the same way as the Button 
  752.      * with an image or bitmap.
  753.      */
  754.     if (((butPtr->image != None) || (butPtr->bitmap != None))
  755.     && TkMacHaveAppearance()) {
  756. int border;
  757. butPtr->inset = 0;
  758. if ( butPtr->borderWidth <= 2 ) {
  759.     border = 6;
  760. }  else {
  761.     border = 2 * butPtr->borderWidth + 2;
  762. }        
  763. width += border;
  764. height += border;
  765.     } else {
  766. butPtr->inset = butPtr->borderWidth;
  767.     }
  768. }
  769.     } else {
  770. butPtr->inset = butPtr->borderWidth;
  771.     }
  775.     Tk_GeometryRequest(butPtr->tkwin, (int) (width + butPtr->indicatorSpace
  776.     + 2*butPtr->inset), (int) (height + 2*butPtr->inset));
  777.     Tk_SetInternalBorder(butPtr->tkwin, butPtr->inset);
  778. }
  780. /*
  781.  *----------------------------------------------------------------------
  782.  *
  783.  * TkpDestroyButton --
  784.  *
  785.  * Free data structures associated with the button control.
  786.  *
  787.  * Results:
  788.  * None.
  789.  *
  790.  * Side effects:
  791.  * Restores the default control state.
  792.  *
  793.  *----------------------------------------------------------------------
  794.  */
  796. void
  797. TkpDestroyButton(
  798.     TkButton *butPtr)
  799. {
  800.     /* Do nothing. */
  801. }
  803. /*
  804.  *--------------------------------------------------------------
  805.  *
  806.  * DrawBufferedControl --
  807.  *
  808.  * This function uses a dummy Macintosh window to allow
  809.  * drawing Mac controls to any GWorld (including off-screen
  810.  * bitmaps).  In addition, this code may apply custom
  811.  * colors passed in the TkButton.
  812.  *
  813.  * Results:
  814.  * None.
  815.  *
  816.  * Side effects:
  817.  * Control is to the GWorld.  Static state created on
  818.  * first invocation of this routine.
  819.  *
  820.  *--------------------------------------------------------------
  821.  */
  823. static void
  824. DrawBufferedControl(
  825.     TkButton *butPtr, /* Tk button. */
  826.     GWorldPtr destPort, /* Off screen GWorld. */
  827.     GC gc, /* The GC we are drawing into - needed for
  828.  * the bevel button */
  829.     Pixmap pixmap /* The pixmap we are drawing into - needed
  830.    for the bevel button */
  831.     )
  832. {
  833.     ControlRef controlHandle;
  834.     CCTabHandle ccTabHandle;
  835.     int windowColorChanged = false;
  836.     RGBColor saveBackColor;
  837.     int isBevel = 0;
  838.    
  839.     if (windowRef == NULL) {
  840. InitSampleControls();
  841.     }
  842.     
  843.     /*
  844.      * Now swap in the passed in GWorld for the portBits of our fake
  845.      * window. We also adjust various fields in the WindowRecord to make
  846.      * the system think this is a normal window.
  847.      * Note, we can use DrawControlInCurrentPort under Appearance, so we don't
  848.      * need to swap pixmaps.
  849.      */
  850.     
  851.     if (!TkMacHaveAppearance()) {
  852. ((CWindowPeek) windowRef)->port.portPixMap = destPort->portPixMap;
  853.     }
  854.     
  855.     ((CWindowPeek) windowRef)->port.portRect = destPort->portRect;
  856.     RectRgn(((CWindowPeek) windowRef)->port.visRgn, &destPort->portRect);
  857.     RectRgn(((CWindowPeek) windowRef)->strucRgn, &destPort->portRect);
  858.     RectRgn(((CWindowPeek) windowRef)->updateRgn, &destPort->portRect);
  859.     RectRgn(((CWindowPeek) windowRef)->contRgn, &destPort->portRect);
  860.     PortChanged(windowRef);
  861.     
  862.     /*
  863.      * Set up control in hidden window to match what we need
  864.      * to draw in the buffered window.
  865.      */
  866.      
  867.     isBevel = 0;   
  868.     switch (butPtr->type) {
  869. case TYPE_BUTTON:
  870.     if (TkMacHaveAppearance()) {
  871. if ((butPtr->image == None) && (butPtr->bitmap == None)) {
  872.     controlHandle = buttonHandle;
  873.     ccTabHandle = buttonTabHandle;
  874. } else {
  875.     if (butPtr->borderWidth <= 2) {
  876. controlHandle = smallBevelHandle;
  877.     } else if (butPtr->borderWidth == 3) {
  878. controlHandle = medBevelHandle;
  879.     } else {
  880. controlHandle = largeBevelHandle;
  881.     }
  882.     ccTabHandle = buttonTabHandle;
  883.     SetupBevelButton(butPtr, controlHandle, destPort, 
  884.     gc, pixmap);
  885.     isBevel = 1;
  886. }
  887.     } else {
  888. controlHandle = buttonHandle;
  889. ccTabHandle = buttonTabHandle;
  890.     }
  891.     break;
  892. case TYPE_RADIO_BUTTON:
  893.     if (TkMacHaveAppearance()) {
  894. if (((butPtr->image == None) && (butPtr->bitmap == None))
  895. || (butPtr->indicatorOn)) {
  896.     controlHandle = radioHandle;
  897.     ccTabHandle = radioTabHandle;
  898. } else {
  899.     if (butPtr->borderWidth <= 2) {
  900. controlHandle = smallStickyBevelHandle;
  901.     } else if (butPtr->borderWidth == 3) {
  902. controlHandle = medStickyBevelHandle;
  903.     } else {
  904. controlHandle = largeStickyBevelHandle;
  905.     }
  906.     ccTabHandle = radioTabHandle;
  907.     SetupBevelButton(butPtr, controlHandle, destPort, 
  908.     gc, pixmap);
  909.     isBevel = 1;
  910. }
  911.     } else {
  912. controlHandle = radioHandle;
  913. ccTabHandle = radioTabHandle;
  914.     }        
  915.     break;
  916. case TYPE_CHECK_BUTTON:
  917.     if (TkMacHaveAppearance()) {
  918. if (((butPtr->image == None) && (butPtr->bitmap == None))
  919. || (butPtr->indicatorOn)) {
  920.     controlHandle = checkHandle;
  921.     ccTabHandle = checkTabHandle;
  922. } else {
  923.     if (butPtr->borderWidth <= 2) {
  924. controlHandle = smallStickyBevelHandle;
  925.     } else if (butPtr->borderWidth == 3) {
  926. controlHandle = medStickyBevelHandle;
  927.     } else {
  928. controlHandle = largeStickyBevelHandle;
  929.     }
  930.     ccTabHandle = checkTabHandle;
  931.     SetupBevelButton(butPtr, controlHandle, destPort, 
  932.     gc, pixmap);
  933.     isBevel = 1;
  934. }
  935.     } else {
  936. controlHandle = checkHandle;
  937. ccTabHandle = checkTabHandle;
  938.     }        
  939.     break;
  940.     }
  941.     
  942.     (**controlHandle).contrlRect.left = butPtr->inset;
  943.     (**controlHandle).contrlRect.top = butPtr->inset;
  944.     (**controlHandle).contrlRect.right = Tk_Width(butPtr->tkwin) 
  945. - butPtr->inset;
  946.     (**controlHandle).contrlRect.bottom = Tk_Height(butPtr->tkwin) 
  947. - butPtr->inset;
  948.     
  949.     /*
  950.      * Setting the control visibility by hand does not 
  951.      * seem to work under Appearance. 
  952.      */
  953.      
  954.     if (TkMacHaveAppearance()) {
  955. SetControlVisibility(controlHandle, true, false);      
  956. (**userPaneHandle).contrlRect.left = 0;
  957. (**userPaneHandle).contrlRect.top = 0;
  958. (**userPaneHandle).contrlRect.right = Tk_Width(butPtr->tkwin);
  959. (**userPaneHandle).contrlRect.bottom = Tk_Height(butPtr->tkwin);
  960.     } else {   
  961. (**controlHandle).contrlVis = 255;
  962.     }   
  963.     
  965.     
  966.     if (butPtr->flags & SELECTED) {
  967. (**controlHandle).contrlValue = 1;
  968.     } else {
  969. (**controlHandle).contrlValue = 0;
  970.     }
  971.     
  972.     if (!tkMacAppInFront || butPtr->state == STATE_DISABLED) {
  973. (**controlHandle).contrlHilite = kControlInactivePart;
  974.     } else if (butPtr->state == STATE_ACTIVE) {
  975. if (isBevel) {
  976.     (**controlHandle).contrlHilite = kControlButtonPart;
  977. } else {
  978.     switch (butPtr->type) {
  979. case TYPE_BUTTON:
  980.     (**controlHandle).contrlHilite = kControlButtonPart;
  981.     break;
  982. case TYPE_RADIO_BUTTON:
  983.     (**controlHandle).contrlHilite = kControlRadioButtonPart;
  984.     break;
  985. case TYPE_CHECK_BUTTON:
  986.     (**controlHandle).contrlHilite = kControlCheckBoxPart;
  987.     break;
  988.     }
  989. }
  990.     } else {
  991. (**controlHandle).contrlHilite = kControlNoPart;
  992.     }
  993.     /*
  994.      * Before we draw the control we must add the hidden window back to the
  995.      * main window list.  Otherwise, radiobuttons and checkbuttons will draw
  996.      * incorrectly.  I don't really know why - but clearly the control draw
  997.      * proc needs to have the controls window in the window list.  This is not
  998.      * necessary under Appearance, and will have to go when we Carbonize Tk...
  999.      */
  1000.     if (!TkMacHaveAppearance()) {
  1001.         ((CWindowPeek) windowRef)->nextWindow = (CWindowPeek) LMGetWindowList();
  1002.         LMSetWindowList(windowRef);
  1003.     }
  1005.     /*
  1006.      * Now we can set the port to our doctered up window.  We next need
  1007.      * to muck with the colors for the port & window to draw the control
  1008.      * with the proper Tk colors.  If we need to we also draw a default
  1009.      * ring for buttons.
  1010.      * Under Appearance, we draw the control directly into destPort, and
  1011.      * just set the default control data.
  1012.      */
  1014.     if (TkMacHaveAppearance()) {
  1015. SetPort((GrafPort *) destPort);
  1016.     } else {
  1017. SetPort(windowRef);
  1018.     }
  1020.     windowColorChanged = UpdateControlColors(butPtr, controlHandle, 
  1021.     ccTabHandle, &saveBackColor);
  1023.     if ((butPtr->type == TYPE_BUTTON) && TkMacHaveAppearance()) {
  1024. Boolean isDefault;
  1026. if (butPtr->defaultState == STATE_ACTIVE) {
  1027.     isDefault = true;
  1028. } else {
  1029.     isDefault = false;
  1030. }
  1031. SetControlData(controlHandle, kControlNoPart, 
  1032. kControlPushButtonDefaultTag,
  1033. sizeof(isDefault), (Ptr) &isDefault);
  1034.     }
  1036.     if (TkMacHaveAppearance()) {
  1037. DrawControlInCurrentPort(userPaneHandle);
  1038.     } else {
  1039. Draw1Control(controlHandle);
  1040.     }
  1042.     if (!TkMacHaveAppearance() &&
  1043.     (butPtr->type == TYPE_BUTTON) && 
  1044.     (butPtr->defaultState == STATE_ACTIVE)) {
  1045. Rect box = (**controlHandle).contrlRect;
  1046. RGBColor rgbColor;
  1048. TkSetMacColor(butPtr->highlightColorPtr->pixel, &rgbColor);
  1049. RGBForeColor(&rgbColor);
  1050. PenSize(butPtr->highlightWidth - 1, butPtr->highlightWidth - 1);
  1051. InsetRect(&box, -butPtr->highlightWidth, -butPtr->highlightWidth);
  1052. FrameRoundRect(&box, 16, 16);
  1053.     }
  1054.     
  1055.     if (windowColorChanged) {
  1056. RGBColor dummyColor;
  1057. ChangeBackgroundWindowColor(windowRef, saveBackColor, &dummyColor);
  1058.     }
  1059.     
  1060.     /*
  1061.      * Clean up: remove the hidden window from the main window list, and
  1062.      * hide the control we drew.  
  1063.      */
  1065.     if (TkMacHaveAppearance()) {
  1066. SetControlVisibility(controlHandle, false, false);
  1067. if (isBevel) {
  1068.     KillPicture(bevelButtonContent.u.picture);
  1069. }     
  1070.     } else {   
  1071. (**controlHandle).contrlVis = 0;
  1072.     }   
  1073.     if (!TkMacHaveAppearance()) {    
  1074.         LMSetWindowList((WindowRef) ((CWindowPeek) windowRef)->nextWindow);
  1075.     }
  1076. }
  1078. /*
  1079.  *--------------------------------------------------------------
  1080.  *
  1081.  * InitSampleControls --
  1082.  *
  1083.  * This function initializes a dummy Macintosh window and
  1084.  * sample controls to allow drawing Mac controls to any GWorld 
  1085.  * (including off-screen bitmaps).  
  1086.  *
  1087.  * Results:
  1088.  * None.
  1089.  *
  1090.  * Side effects:
  1091.  * Controls & a window are created.
  1092.  *
  1093.  *--------------------------------------------------------------
  1094.  */
  1096. static void
  1097. InitSampleControls()
  1098. {
  1099.     Rect geometry = {0, 0, 10, 10};
  1100.     CWindowPeek windowList;
  1101.     GWorldPtr frontWin = NULL;
  1102.     TkMacWindowList *winListPtr;
  1104.     /*
  1105.      * Create a dummy window that we can draw to.  We will
  1106.      * actually replace this window's bitmap with the one
  1107.      * we want to draw to at a later time.  This window and
  1108.      * the data structures attached to it are only deallocated
  1109.      * on exit of the application.
  1110.      */
  1112.     /* 
  1113.      * This is a bit of a hack...  The problem is that under appearance,
  1114.      * taking a window out of the window list causes instability, so we can't 
  1115.      * do that.  OTOH, we need to make sure that this window is NEVER the front
  1116.      * window, or we may inadvertently send keystrokes to it...
  1117.      * So we put it BEHIND ".", and then we won't ever be able to destroy
  1118.      * ALL the windows that are above it.
  1119.      */
  1120.       
  1121.     for (winListPtr = tkMacWindowListPtr; winListPtr != NULL; 
  1122.             winListPtr = winListPtr->nextPtr) {
  1123.         frontWin = ((MacDrawable *) tkMacWindowListPtr->winPtr->privatePtr)->portPtr;
  1124.         if (strcmp(tkMacWindowListPtr->winPtr->pathName, ".") == 0) {
  1125.             break;
  1126.         }
  1127.     }
  1128.     
  1129.     windowRef = NewCWindow(NULL, &geometry, "pempty", false, 
  1130.     zoomDocProc, (WindowRef) frontWin, true, 0);
  1131.     if (windowRef == NULL) {
  1132. panic("Can't allocate buffer window.");
  1133.     }
  1135.     /*
  1136.      * Now add the three standard controls to hidden window.  We
  1137.      * only create one of each and reuse them for every widget in
  1138.      * Tk.
  1139.      * Under Appearance, we have to embed the controls in a UserPane
  1140.      * control, so that we can color the background text in 
  1141.      * radiobuttons and checkbuttons.
  1142.      */
  1144.     SetPort(windowRef);
  1146.     if (TkMacHaveAppearance()) {
  1147.     
  1148. OSErr err;
  1149. ControlRef dontCare;
  1150.     
  1151.   /* 
  1152.    * Adding UserPaneBackgroundProcs to the root control does
  1153.  * not seem to work, so we have to add another UserPane to 
  1154.  * the root control.
  1155.  */
  1156.      
  1157. err = CreateRootControl(windowRef, &dontCare);
  1158. if (err != noErr) {
  1159.     panic("Can't create root control in DrawBufferedControl");
  1160. }
  1161.     
  1162. userPaneHandle = NewControl(windowRef, &geometry, "p",
  1163. true, kControlSupportsEmbedding|kControlHasSpecialBackground, 
  1164. 0, 1, kControlUserPaneProc, (SInt32) 0);
  1165. SetUserPaneSetUpSpecialBackgroundProc(userPaneHandle,
  1166. UserPaneBackgroundProc);
  1167. SetUserPaneDrawProc(userPaneHandle, UserPaneDraw);
  1169. buttonHandle = NewControl(windowRef, &geometry, "p",
  1170. false, 1, 0, 1, kControlPushButtonProc, (SInt32) 0);
  1171. EmbedControl(buttonHandle, userPaneHandle);
  1172. checkHandle = NewControl(windowRef, &geometry, "p",
  1173. false, 1, 0, 1, kControlCheckBoxProc, (SInt32) 0);
  1174. EmbedControl(checkHandle, userPaneHandle);
  1175. radioHandle = NewControl(windowRef, &geometry, "p",
  1176. false, 1, 0, 1, kControlRadioButtonProc, (SInt32) 0);
  1177. EmbedControl(radioHandle, userPaneHandle);
  1178. smallBevelHandle = NewControl(windowRef, &geometry, "p",
  1179. false, 0, 0, 
  1180. kControlBehaviorOffsetContents << 16
  1181. | kControlContentPictHandle, 
  1182. kControlBevelButtonSmallBevelProc, (SInt32) 0);
  1183. EmbedControl(smallBevelHandle, userPaneHandle);
  1184. medBevelHandle = NewControl(windowRef, &geometry, "p",
  1185. false, 0, 0, 
  1186. kControlBehaviorOffsetContents << 16
  1187. | kControlContentPictHandle, 
  1188. kControlBevelButtonNormalBevelProc, (SInt32) 0);
  1189. EmbedControl(medBevelHandle, userPaneHandle);
  1190. largeBevelHandle = NewControl(windowRef, &geometry, "p",
  1191. false, 0, 0, 
  1192. kControlBehaviorOffsetContents << 16
  1193. | kControlContentPictHandle, 
  1194. kControlBevelButtonLargeBevelProc, (SInt32) 0);
  1195. EmbedControl(largeBevelHandle, userPaneHandle);
  1196. bevelButtonContent.contentType = kControlContentPictHandle;
  1197. smallStickyBevelHandle = NewControl(windowRef, &geometry, "p",
  1198. false, 0, 0, 
  1199. (kControlBehaviorOffsetContents
  1200. | kControlBehaviorSticky) << 16 
  1201. | kControlContentPictHandle, 
  1202. kControlBevelButtonSmallBevelProc, (SInt32) 0);
  1203. EmbedControl(smallStickyBevelHandle, userPaneHandle);
  1204. medStickyBevelHandle = NewControl(windowRef, &geometry, "p",
  1205. false, 0, 0, 
  1206. (kControlBehaviorOffsetContents
  1207. | kControlBehaviorSticky) << 16 
  1208. | kControlContentPictHandle, 
  1209. kControlBevelButtonNormalBevelProc, (SInt32) 0);
  1210. EmbedControl(medStickyBevelHandle, userPaneHandle);
  1211. largeStickyBevelHandle = NewControl(windowRef, &geometry, "p",
  1212. false, 0, 0, 
  1213. (kControlBehaviorOffsetContents
  1214. | kControlBehaviorSticky) << 16 
  1215. | kControlContentPictHandle, 
  1216. kControlBevelButtonLargeBevelProc, (SInt32) 0);
  1217. EmbedControl(largeStickyBevelHandle, userPaneHandle);
  1218.     
  1219. picParams.version = -2;
  1220. picParams.hRes = 0x00480000;
  1221. picParams.vRes = 0x00480000;
  1222. picParams.srcRect.top = 0;
  1223. picParams.srcRect.left = 0;
  1224.     
  1225. ((CWindowPeek) windowRef)->visible = true;
  1226.     } else {
  1227. buttonHandle = NewControl(windowRef, &geometry, "p",
  1228. false, 1, 0, 1, pushButProc, (SInt32) 0);
  1229. checkHandle = NewControl(windowRef, &geometry, "p",
  1230. false, 1, 0, 1, checkBoxProc, (SInt32) 0);
  1231. radioHandle = NewControl(windowRef, &geometry, "p",
  1232. false, 1, 0, 1, radioButProc, (SInt32) 0);
  1233. ((CWindowPeek) windowRef)->visible = true;
  1235. buttonTabHandle = (CCTabHandle) NewHandle(sizeof(CtlCTab));
  1236. checkTabHandle = (CCTabHandle) NewHandle(sizeof(CtlCTab));
  1237. radioTabHandle = (CCTabHandle) NewHandle(sizeof(CtlCTab));
  1238.     }
  1240.     /*
  1241.      * Remove our window from the window list. This way our
  1242.      * applications and others will not be confused that this
  1243.      * window exists - but no one knows about it.
  1244.      * I actually don't see the point of doing this, and it causes Floating
  1245.      * Window support to crash under Appearance, so I just leave it out.
  1246.      * Note that we have to do without this under Carbon, since you can't
  1247.      * go poking at the window list...
  1248.      */
  1250.     if (!TkMacHaveAppearance()) {
  1251.         windowList = (CWindowPeek) LMGetWindowList();
  1252.         if (windowList == (CWindowPeek) windowRef) {
  1253.     LMSetWindowList((WindowRef) windowList->nextWindow);
  1254.         } else {
  1255.     while ((windowList != NULL) 
  1256.     && (windowList->nextWindow != (CWindowPeek) windowRef)) {
  1257.         windowList = windowList->nextWindow;
  1258.     }
  1259.     if (windowList != NULL) {
  1260.         windowList->nextWindow = windowList->nextWindow->nextWindow;
  1261.     }
  1262.         }
  1263.         ((CWindowPeek) windowRef)->nextWindow = NULL;
  1264.     }
  1266.     /* 
  1267.      * Create an exit handler to clean up this mess if we our
  1268.      * unloaded etc.  We need to remember the windows portPixMap
  1269.      * so it isn't leaked.
  1270.      *
  1271.      * TODO: The ButtonExitProc doesn't currently work and the
  1272.      * code it includes will crash the Mac on exit from Tk.
  1273.  
  1274.      oldPixPtr = ((CWindowPeek) windowRef)->port.portPixMap;
  1275.      TkCreateExitHandler(ButtonExitProc, (ClientData) NULL);
  1276.     */
  1278. }
  1280. /*
  1281.  *--------------------------------------------------------------
  1282.  *
  1283.  * SetupBevelButton --
  1284.  *
  1285.  * Sets up the Bevel Button with image by copying the
  1286.  * source image onto the PicHandle for the button.
  1287.  *
  1288.  * Results:
  1289.  * None
  1290.  *
  1291.  * Side effects:
  1292.  * The image or bitmap for the button is copied over to a picture.
  1293.  *
  1294.  *--------------------------------------------------------------
  1295.  */
  1296. void
  1297. SetupBevelButton(
  1298.     TkButton *butPtr, /* Tk button. */
  1299.     ControlRef controlHandle,  /* The control to set this picture to */
  1300.     GWorldPtr destPort, /* Off screen GWorld. */
  1301.     GC gc, /* The GC we are drawing into - needed for
  1302.  * the bevel button */
  1303.     Pixmap pixmap /* The pixmap we are drawing into - needed
  1304.    for the bevel button */
  1305.     )
  1306. {
  1307.     int height, width;
  1308.     ControlButtonGraphicAlignment theAlignment;
  1309.     
  1310.     SetPort((GrafPtr) destPort);
  1312.     if (butPtr->image != None) {
  1313. Tk_SizeOfImage(butPtr->image, 
  1314. &width, &height);
  1315.     } else {
  1316. Tk_SizeOfBitmap(butPtr->display, butPtr->bitmap, 
  1317. &width, &height);
  1318.     }
  1319.     
  1320.     if ((butPtr->width > 0) && (butPtr->width < width)) {
  1321. width = butPtr->width;
  1322.     }
  1323.     if ((butPtr->height > 0) && (butPtr->height < height)) {
  1324. height = butPtr->height;
  1325.     }
  1326.     
  1327.     picParams.srcRect.right = width;
  1328.     picParams.srcRect.bottom = height;
  1329.     
  1330.     bevelButtonContent.u.picture = OpenCPicture(&picParams);
  1331.     
  1332.     /*
  1333.      * TO DO - There is one case where XCopyPlane calls CopyDeepMask,
  1334.      * which does not get recorded in the picture.  So the bitmap code
  1335.      * will fail in that case.
  1336.      */
  1337.      
  1338.     if ((butPtr->selectImage != NULL) && (butPtr->flags & SELECTED)) {
  1339. Tk_RedrawImage(butPtr->selectImage, 0, 0, width, height,
  1340. pixmap, 0, 0);
  1341.     } else if (butPtr->image != NULL) {
  1342. Tk_RedrawImage(butPtr->image, 0, 0, width, 
  1343. height, pixmap, 0, 0);
  1344.     } else {
  1345. XSetClipOrigin(butPtr->display, gc, 0, 0);
  1346. XCopyPlane(butPtr->display, butPtr->bitmap, pixmap, gc, 0, 0,
  1347. (unsigned int) width, (unsigned int) height, 0, 0, 1);
  1348.     }
  1349.     
  1350.     ClosePicture();
  1351.     
  1352.     SetControlData(controlHandle, kControlButtonPart,
  1353.     kControlBevelButtonContentTag,
  1354.     sizeof(ControlButtonContentInfo),
  1355.     (char *) &bevelButtonContent);
  1356.     
  1357.     if (butPtr->anchor == TK_ANCHOR_N) {
  1358. theAlignment = kControlBevelButtonAlignTop;
  1359.     } else if (butPtr->anchor == TK_ANCHOR_NE) { 
  1360. theAlignment = kControlBevelButtonAlignTopRight;
  1361.     } else if (butPtr->anchor == TK_ANCHOR_E) { 
  1362. theAlignment = kControlBevelButtonAlignRight;
  1363.     } else if (butPtr->anchor == TK_ANCHOR_SE) {
  1364. theAlignment = kControlBevelButtonAlignBottomRight;
  1365.     } else if (butPtr->anchor == TK_ANCHOR_S) {
  1366. theAlignment = kControlBevelButtonAlignBottom;
  1367.     } else if (butPtr->anchor == TK_ANCHOR_SW) {
  1368. theAlignment = kControlBevelButtonAlignBottomLeft;
  1369.     } else if (butPtr->anchor == TK_ANCHOR_W) {
  1370. theAlignment = kControlBevelButtonAlignLeft;
  1371.     } else if (butPtr->anchor == TK_ANCHOR_NW) {
  1372. theAlignment = kControlBevelButtonAlignTopLeft;
  1373.     } else if (butPtr->anchor == TK_ANCHOR_CENTER) {
  1374. theAlignment = kControlBevelButtonAlignCenter;
  1375.     }
  1377.     SetControlData(controlHandle, kControlButtonPart,
  1378.     kControlBevelButtonGraphicAlignTag,
  1379.     sizeof(ControlButtonGraphicAlignment),
  1380.     (char *) &theAlignment);
  1382. }
  1384. /*
  1385.  *--------------------------------------------------------------
  1386.  *
  1387.  * SetUserPaneDrawProc --
  1388.  *
  1389.  * Utility function to add a UserPaneDrawProc
  1390.  * to a userPane control. From MoreControls code
  1391.  * from Apple DTS.
  1392.  *
  1393.  * Results:
  1394.  * MacOS system error.
  1395.  *
  1396.  * Side effects:
  1397.  * The user pane gets a new UserPaneDrawProc.
  1398.  *
  1399.  *--------------------------------------------------------------
  1400.  */
  1401. pascal OSErr SetUserPaneDrawProc (
  1402.     ControlRef control,
  1403.     ControlUserPaneDrawProcPtr upp)
  1404. {
  1405.     ControlUserPaneDrawUPP myControlUserPaneDrawUPP;
  1406.     myControlUserPaneDrawUPP = NewControlUserPaneDrawProc(upp);
  1407.     return SetControlData (control, 
  1408.     kControlNoPart, kControlUserPaneDrawProcTag, 
  1409.     sizeof(myControlUserPaneDrawUPP), 
  1410.     (Ptr) &myControlUserPaneDrawUPP);
  1411. }
  1413. /*
  1414.  *--------------------------------------------------------------
  1415.  *
  1416.  * SetUserPaneSetUpSpecialBackgroundProc --
  1417.  *
  1418.  * Utility function to add a UserPaneBackgroundProc
  1419.  * to a userPane control
  1420.  *
  1421.  * Results:
  1422.  * MacOS system error.
  1423.  *
  1424.  * Side effects:
  1425.  * The user pane gets a new UserPaneBackgroundProc.
  1426.  *
  1427.  *--------------------------------------------------------------
  1428.  */
  1429. pascal OSErr
  1430. SetUserPaneSetUpSpecialBackgroundProc(
  1431.     ControlRef control, 
  1432.     ControlUserPaneBackgroundProcPtr upp)
  1433. {
  1434.     ControlUserPaneBackgroundUPP myControlUserPaneBackgroundUPP;
  1435.     myControlUserPaneBackgroundUPP = NewControlUserPaneBackgroundProc(upp);
  1436.     return SetControlData (control, kControlNoPart, 
  1437.     kControlUserPaneBackgroundProcTag, 
  1438.     sizeof(myControlUserPaneBackgroundUPP), 
  1439.     (Ptr) &myControlUserPaneBackgroundUPP);
  1440. }
  1442. /*
  1443.  *--------------------------------------------------------------
  1444.  *
  1445.  * UserPaneDraw --
  1446.  *
  1447.  * This function draws the background of the user pane that will 
  1448.  * lie under checkboxes and radiobuttons.
  1449.  *
  1450.  * Results:
  1451.  * None.
  1452.  *
  1453.  * Side effects:
  1454.  * The user pane gets updated to the current color.
  1455.  *
  1456.  *--------------------------------------------------------------
  1457.  */
  1458. pascal void
  1459. UserPaneDraw(
  1460.     ControlRef control,
  1461.     ControlPartCode cpc)
  1462. {
  1463.     Rect contrlRect = (**control).contrlRect;
  1464.     RGBBackColor (&gUserPaneBackground);
  1465.     EraseRect (&contrlRect);
  1466. }
  1468. /*
  1469.  *--------------------------------------------------------------
  1470.  *
  1471.  * UserPaneBackgroundProc --
  1472.  *
  1473.  * This function sets up the background of the user pane that will 
  1474.  * lie under checkboxes and radiobuttons.
  1475.  *
  1476.  * Results:
  1477.  * None.
  1478.  *
  1479.  * Side effects:
  1480.  * The user pane background gets set to the current color.
  1481.  *
  1482.  *--------------------------------------------------------------
  1483.  */
  1485. pascal void
  1486. UserPaneBackgroundProc(
  1487.     ControlHandle,
  1488.     ControlBackgroundPtr info)
  1489. {
  1490.     if (info->colorDevice) {
  1491. RGBBackColor (&gUserPaneBackground);
  1492.     }
  1493. }
  1495. /*
  1496.  *--------------------------------------------------------------
  1497.  *
  1498.  * UpdateControlColors --
  1499.  *
  1500.  * This function will review the colors used to display
  1501.  * a Macintosh button.  If any non-standard colors are
  1502.  * used we create a custom palette for the button, populate
  1503.  * with the colors for the button and install the palette.
  1504.  *
  1505.  * Under Appearance, we just set the pointer that will be
  1506.  * used by the UserPaneDrawProc.
  1507.  *
  1508.  * Results:
  1509.  * None.
  1510.  *
  1511.  * Side effects:
  1512.  * The Macintosh control may get a custom palette installed.
  1513.  *
  1514.  *--------------------------------------------------------------
  1515.  */
  1517. static int
  1518. UpdateControlColors(
  1519.     TkButton *butPtr,
  1520.     ControlRef controlHandle,
  1521.     CCTabHandle ccTabHandle,
  1522.     RGBColor *saveColorPtr)
  1523. {
  1524.     XColor *xcolor;
  1525.     
  1526.     /*
  1527.      * Under Appearance we cannot change the background of the
  1528.      * button itself.  However, the color we are setting is the color
  1529.      * of the containing userPane.  This will be the color that peeks 
  1530.      * around the rounded corners of the button.  
  1531.      * We make this the highlightbackground rather than the background,
  1532.      * because if you color the background of a frame containing a
  1533.      * button, you usually also color the highlightbackground as well,
  1534.      * or you will get a thin grey ring around the button.
  1535.      */
  1536.       
  1537.     if (TkMacHaveAppearance() && (butPtr->type == TYPE_BUTTON)) {
  1538. xcolor = Tk_3DBorderColor(butPtr->highlightBorder);
  1539.     } else {
  1540. xcolor = Tk_3DBorderColor(butPtr->normalBorder);
  1541.     }
  1542.     if (TkMacHaveAppearance()) {
  1543. TkSetMacColor(xcolor->pixel, &gUserPaneBackground);
  1544.     } else {
  1545. (**ccTabHandle).ccSeed = 0;
  1546. (**ccTabHandle).ccRider = 0;
  1547. (**ccTabHandle).ctSize = 3;
  1548. (**ccTabHandle).ctTable[0].value = cBodyColor;
  1549. TkSetMacColor(xcolor->pixel,
  1550. &(**ccTabHandle).ctTable[0].rgb);
  1551. (**ccTabHandle).ctTable[1].value = cTextColor;
  1552. TkSetMacColor(butPtr->normalFg->pixel,
  1553. &(**ccTabHandle).ctTable[1].rgb);
  1554. (**ccTabHandle).ctTable[2].value = cFrameColor;
  1555. TkSetMacColor(butPtr->highlightColorPtr->pixel,
  1556. &(**ccTabHandle).ctTable[2].rgb);
  1557. SetControlColor(controlHandle, ccTabHandle);
  1559. if (((xcolor->pixel >> 24) != CONTROL_BODY_PIXEL) && 
  1560. ((butPtr->type == TYPE_CHECK_BUTTON) ||
  1561. (butPtr->type == TYPE_RADIO_BUTTON))) {
  1562.     RGBColor newColor;
  1564.     if (TkSetMacColor(xcolor->pixel, &newColor)) {
  1565.     ChangeBackgroundWindowColor((**controlHandle).contrlOwner,
  1566.     newColor, saveColorPtr);
  1567.             }
  1568.     return true;
  1569. }
  1570.     }
  1571.     
  1572.     return false;
  1573. }
  1575. /*
  1576.  *--------------------------------------------------------------
  1577.  *
  1578.  * ChangeBackgroundWindowColor --
  1579.  *
  1580.  * This procedure will change the background color entry
  1581.  * in the Window's colortable.  The system isn't notified
  1582.  * of the change. This call should only be used to fool
  1583.  * the drawing routines for checkboxes and radiobuttons.
  1584.  * Any change should be temporary and be reverted after
  1585.  * the widget is drawn.
  1586.  *
  1587.  * Results:
  1588.  * None.
  1589.  *
  1590.  * Side effects:
  1591.  * The Window's color table will be adjusted.
  1592.  *
  1593.  *--------------------------------------------------------------
  1594.  */
  1596. static void
  1597. ChangeBackgroundWindowColor(
  1598.     WindowRef macintoshWindow, /* A Mac window whose color to change. */
  1599.     RGBColor rgbColor, /* The new RGB Color for the background. */
  1600.     RGBColor *oldColor) /* The old color of the background. */
  1601. {
  1602.     AuxWinHandle auxWinHandle;
  1603.     WCTabHandle winCTabHandle;
  1604.     short ctIndex;
  1605.     ColorSpecPtr rgbScan;
  1607.     GetAuxWin(macintoshWindow, &auxWinHandle);
  1608.     winCTabHandle = (WCTabHandle) ((**auxWinHandle).awCTable);
  1610.     /*
  1611.      * Scan through the color table until we find the content
  1612.      * (background) color for the window.  Don't tell the system
  1613.      * about the change - it will generate damage and we will get
  1614.      * into an infinite loop.
  1615.      */
  1617.     ctIndex = (**winCTabHandle).ctSize;
  1618.     while (ctIndex > -1) {
  1619. rgbScan = ctIndex + (**winCTabHandle).ctTable;
  1621. if (rgbScan->value == wContentColor) {
  1622.     *oldColor = rgbScan->rgb;
  1623.     rgbScan->rgb = rgbColor;
  1624.     break;
  1625. }
  1626. ctIndex--;
  1627.     }
  1628. }
  1630. /*
  1631.  *--------------------------------------------------------------
  1632.  *
  1633.  * ButtonEventProc --
  1634.  *
  1635.  * This procedure is invoked by the Tk dispatcher for various
  1636.  * events on buttons.
  1637.  *
  1638.  * Results:
  1639.  * None.
  1640.  *
  1641.  * Side effects:
  1642.  *      When it gets exposed, it is redisplayed.
  1643.  *
  1644.  *--------------------------------------------------------------
  1645.  */
  1647. static void
  1648. ButtonEventProc(
  1649.     ClientData clientData, /* Information about window. */
  1650.     XEvent *eventPtr) /* Information about event. */
  1651. {
  1652.     TkButton *buttonPtr = (TkButton *) clientData;
  1654.     if (eventPtr->type == ActivateNotify
  1655.             || eventPtr->type == DeactivateNotify) {
  1656.         if ((buttonPtr->tkwin == NULL) || (!Tk_IsMapped(buttonPtr->tkwin))) {
  1657.     return;
  1658.         }
  1659.         if ((buttonPtr->flags & REDRAW_PENDING) == 0) {
  1660.     Tcl_DoWhenIdle(TkpDisplayButton, (ClientData) buttonPtr);
  1661.     buttonPtr->flags |= REDRAW_PENDING;
  1662.         }
  1663.     }
  1664. }
  1666. /*
  1667.  *----------------------------------------------------------------------
  1668.  *
  1669.  * ButtonExitProc --
  1670.  *
  1671.  * This procedure is invoked just before the application exits.
  1672.  * It frees all of the control handles, our dummy window, etc.
  1673.  *
  1674.  * Results:
  1675.  * None.
  1676.  *
  1677.  * Side effects:
  1678.  * Memory is freed.
  1679.  *
  1680.  *----------------------------------------------------------------------
  1681.  */
  1683. static void
  1684. ButtonExitProc(clientData)
  1685.     ClientData clientData; /* Not used. */
  1686. {
  1687.     Rect pixRect = {0, 0, 10, 10};
  1688.     Rect rgnRect = {0, 0, 0, 0};
  1690.     /*
  1691.      * Restore our dummy window to it's origional state by putting it
  1692.      * back in the window list and restoring it's bits.  The destroy
  1693.      * the controls and window.
  1694.      */
  1695.  
  1696.     ((CWindowPeek) windowRef)->nextWindow = (CWindowPeek) LMGetWindowList();
  1697.     LMSetWindowList(windowRef);
  1698.     ((CWindowPeek) windowRef)->port.portPixMap = oldPixPtr;
  1699.     ((CWindowPeek) windowRef)->port.portRect = pixRect;
  1700.     RectRgn(((CWindowPeek) windowRef)->port.visRgn, &rgnRect);
  1701.     RectRgn(((CWindowPeek) windowRef)->strucRgn, &rgnRect);
  1702.     RectRgn(((CWindowPeek) windowRef)->updateRgn, &rgnRect);
  1703.     RectRgn(((CWindowPeek) windowRef)->contRgn, &rgnRect);
  1704.     PortChanged(windowRef);
  1706.     DisposeControl(buttonHandle);
  1707.     DisposeControl(checkHandle);
  1708.     DisposeControl(radioHandle);
  1709.     DisposeWindow(windowRef);
  1710.     windowRef = NULL;
  1711. }