Return to w_piem.c CVS log

Up to [Micropolis - Activity] / micropolis / src / sim

Annotation of micropolis/src/sim/w_piem.c, revision 1.1

1.1     ! root        1: /* w_piem.c:  Pie Menus
        !             2:  */
        !             3: 
        !             4: /*
        !             5:  *
        !             6:  * Pie Menus for Tk.
        !             7:  * Copyright (C) 1992 by Don Hopkins.
        !             8:  *
        !             9:  * This program is provided for unrestricted use, provided that this 
        !            10:  * copyright message is preserved. There is no warranty, and no author 
        !            11:  * or distributer accepts responsibility for any damage caused by this 
        !            12:  * program. 
        !            13:  * 
        !            14:  * This code and the ideas behind it were developed over time by Don Hopkins 
        !            15:  * with the support of the University of Maryland, UniPress Software, Sun
        !            16:  * Microsystems, DUX Software, the Turing Institute, and Carnegie Mellon
        !            17:  * University.  Pie menus are NOT patented or restricted, and the interface 
        !            18:  * and algorithms may be freely copied and improved upon. 
        !            19:  *
        !            20:  */
        !            21: 
        !            22: 
        !            23: #if 0
        !            24: /* workaround to make gcc work on suns */
        !            25: #ifndef SOLARIS2
        !            26: #define _PTRDIFF_T
        !            27: #define _SIZE_T
        !            28: #ifndef sgi
        !            29: typedef unsigned int size_t;
        !            30: #endif
        !            31: #endif
        !            32: #endif
        !            33: 
        !            34: #include "tkconfig.h"
        !            35: #include "default.h"
        !            36: #include "tkint.h"
        !            37: #include <X11/extensions/shape.h>
        !            38: 
        !            39: #define PI 3.1415926535897932
        !            40: #define TWO_PI 6.2831853071795865
        !            41: #define DEG_TO_RAD(d) (((d) * TWO_PI) / 360.0)
        !            42: #define RAD_TO_DEG(d) (((d) * 360.0) / TWO_PI)
        !            43: #define PIE_SPOKE_INSET 6
        !            44: #define PIE_BG_COLOR "#bfbfbf"
        !            45: #define PIE_BG_MONO WHITE
        !            46: #define PIE_ACTIVE_FG_COLOR BLACK
        !            47: #define PIE_ACTIVE_FG_MONO BLACK
        !            48: #define PIE_ACTIVE_BG_COLOR "#bfbfbf"
        !            49: #define PIE_ACTIVE_BG_MONO WHITE
        !            50: #define PIE_FG BLACK
        !            51: #define PIE_FONT "-Adobe-Helvetica-Bold-R-Normal-*-120-*"
        !            52: #define PIE_ACTIVE_BORDER_WIDTH "2"
        !            53: #define PIE_INACTIVE_RADIUS "8"
        !            54: #define PIE_INACTIVE_RADIUS_NUM 8
        !            55: #define PIE_MIN_RADIUS "16"
        !            56: #define PIE_MIN_RADIUS_NUM 16
        !            57: #define PIE_EXTRA_RADIUS "2"
        !            58: #define PIE_EXTRA_RADIUS_NUM 2
        !            59: #define PIE_BORDER_WIDTH "2"
        !            60: #define PIE_POPUP_DELAY "250"
        !            61: #define PIE_POPUP_DELAY_NUM 250
        !            62: #define PIE_ENTRY_ACTIVE_BG ((char *) NULL)
        !            63: #define PIE_ENTRY_BG ((char *) NULL)
        !            64: #define PIE_ENTRY_FONT ((char *) NULL)
        !            65: 
        !            66: #ifndef MAX
        !            67: #define MAX(x,y) ((x)>(y)?(x):(y))
        !            68: #define MIN(x,y) ((x)<(y)?(x):(y))
        !            69: #endif
        !            70: #define ABS(x)  (((x)<0)?(-(x)):(x))
        !            71: 
        !            72: static int HaveShape = -1;
        !            73: 
        !            74: /*
        !            75:  * One of the following data structures is kept for each entry of each
        !            76:  * pie menu managed by this file:
        !            77:  */
        !            78: 
        !            79: typedef struct PieMenuEntry {
        !            80:     int type;
        !            81:     struct PieMenu *piemenuPtr;
        !            82:     char *label;
        !            83:     int labelLength;
        !            84:     Pixmap bitmap;
        !            85: 
        !            86:     /*
        !            87:      * Information related to displaying entry:
        !            88:      */
        !            89: 
        !            90:     int width, height;
        !            91:     int x, y;
        !            92:     int x_offset, y_offset;
        !            93:     int label_x, label_y;
        !            94: 
        !            95:     Tk_3DBorder border;
        !            96:     Tk_3DBorder activeBorder;
        !            97:     XFontStruct *fontPtr;
        !            98:     GC textGC;
        !            99:     GC activeGC;
        !           100: 
        !           101:     /*
        !           102:      * Information used for pie menu layout & tracking:
        !           103:      */
        !           104: 
        !           105:     int slice;                 /* Desired relative slice size */
        !           106:     float angle;               /* Angle through center of slice */
        !           107:     float dx, dy;              /* Cosine and sine of angle */
        !           108:     float subtend;             /* Angle subtended by slice */
        !           109:     int quadrant;              /* Quadrant of leading edge */
        !           110:     float slope;               /* Slope of leading edge */
        !           111: 
        !           112:     /*
        !           113:      * Information used to implement this entry's action:
        !           114:      */
        !           115: 
        !           116:     char *command;
        !           117:     char *preview;
        !           118:     char *name;
        !           119: 
        !           120:     /*
        !           121:      * Miscellaneous information:
        !           122:      */
        !           123: 
        !           124:     int flags;                 /* Various flags. See below for definitions. */
        !           125: } PieMenuEntry;
        !           126: 
        !           127: /*
        !           128:  * Flag values defined for menu entries:
        !           129:  *
        !           130:  * ENTRY_NEEDS_REDISPLAY:      Non-zero means the entry should be redisplayed.
        !           131:  */
        !           132: 
        !           133: #define ENTRY_NEEDS_REDISPLAY  1
        !           134: 
        !           135: /*
        !           136:  * Types defined for PieMenuEntries:
        !           137:  */
        !           138: 
        !           139: #define COMMAND_ENTRY          0
        !           140: #define PIEMENU_ENTRY          1
        !           141: 
        !           142: /*
        !           143:  * Mask bits for above types:
        !           144:  */
        !           145: 
        !           146: #define COMMAND_MASK           TK_CONFIG_USER_BIT
        !           147: #define PIEMENU_MASK           (TK_CONFIG_USER_BIT << 1)
        !           148: #define ALL_MASK               (COMMAND_MASK | PIEMENU_MASK)
        !           149: 
        !           150: /*
        !           151:  * Configuration specs for individual menu entries:
        !           152:  */
        !           153: 
        !           154: static Tk_ConfigSpec entryConfigSpecs[] = {
        !           155:     {TK_CONFIG_BORDER, "-activebackground", (char *) NULL, (char *) NULL,
        !           156:        PIE_ENTRY_ACTIVE_BG, Tk_Offset(PieMenuEntry, activeBorder),
        !           157:        ALL_MASK|TK_CONFIG_NULL_OK},
        !           158:     {TK_CONFIG_BORDER, "-background", (char *) NULL, (char *) NULL,
        !           159:        PIE_ENTRY_BG, Tk_Offset(PieMenuEntry, border),
        !           160:        ALL_MASK|TK_CONFIG_NULL_OK},
        !           161:     {TK_CONFIG_PIXMAP, "-bitmap", (char *) NULL, (char *) NULL,
        !           162:        (char *) NULL, Tk_Offset(PieMenuEntry, bitmap),
        !           163:        ALL_MASK|TK_CONFIG_NULL_OK},
        !           164:     {TK_CONFIG_STRING, "-command", (char *) NULL, (char *) NULL,
        !           165:        (char *) NULL, Tk_Offset(PieMenuEntry, command),
        !           166:        COMMAND_MASK},
        !           167:     {TK_CONFIG_STRING, "-preview", (char *) NULL, (char *) NULL,
        !           168:        (char *) NULL, Tk_Offset(PieMenuEntry, preview),
        !           169:        ALL_MASK},
        !           170:     {TK_CONFIG_FONT, "-font", (char *) NULL, (char *) NULL,
        !           171:        PIE_ENTRY_FONT, Tk_Offset(PieMenuEntry, fontPtr),
        !           172:        ALL_MASK|TK_CONFIG_NULL_OK},
        !           173:     {TK_CONFIG_STRING, "-label", (char *) NULL, (char *) NULL,
        !           174:        (char *) NULL, Tk_Offset(PieMenuEntry, label),
        !           175:        ALL_MASK},
        !           176:     {TK_CONFIG_STRING, "-piemenu", (char *) NULL, (char *) NULL,
        !           177:         (char *) NULL, Tk_Offset(PieMenuEntry, name),
        !           178:         ALL_MASK},
        !           179:     {TK_CONFIG_INT, "-xoffset", "xOffset", "XOffset",
        !           180:        "0", Tk_Offset(PieMenuEntry, x_offset),
        !           181:         ALL_MASK},
        !           182:     {TK_CONFIG_INT, "-yoffset", "yOffset", "YOffset",
        !           183:        "0", Tk_Offset(PieMenuEntry, y_offset),
        !           184:         ALL_MASK},
        !           185:     {TK_CONFIG_END, (char *) NULL, (char *) NULL, (char *) NULL,
        !           186:        (char *) NULL, 0, 0}
        !           187: };
        !           188: 
        !           189: /*
        !           190:  * A data structure of the following type is kept for each
        !           191:  * pie menu managed by this file:
        !           192:  */
        !           193: 
        !           194: typedef struct PieMenu {
        !           195:     Tk_Window tkwin;
        !           196:     Tcl_Interp *interp;
        !           197:     char *title;
        !           198:     int titleLength;
        !           199:     char *preview;
        !           200:     PieMenuEntry **entries;
        !           201:     int numEntries;
        !           202:     int active;
        !           203:     Tk_Uid group;
        !           204:     int root_x, root_y;
        !           205:     int dx, dy;
        !           206: 
        !           207:     /*
        !           208:      * Information used when displaying widget:
        !           209:      */
        !           210: 
        !           211:     Tk_3DBorder border;
        !           212:     int borderWidth;
        !           213:     Tk_3DBorder activeBorder;
        !           214:     int activeBorderWidth;
        !           215:     XFontStruct *fontPtr;
        !           216:     XFontStruct *titlefontPtr;
        !           217:     XColor *fg;
        !           218:     GC textGC;
        !           219:     XColor *activeFg;
        !           220:     GC activeGC;
        !           221: 
        !           222:     /*
        !           223:      * Information used to layout pie menu:
        !           224:      */
        !           225: 
        !           226:     int width, height;                 /* size of the pie menu */
        !           227:     int title_x, title_y;              /* position of menu title */
        !           228:     int title_width, title_height;     /* size of menu title */
        !           229:     int initial_angle;                 /* pie menu initial angle in radians */
        !           230:     int inactive_radius;               /* inactive inner radius */
        !           231:     int min_radius;                    /* minimum label radius */
        !           232:     int fixed_radius;                  /* fixed label radius */
        !           233:     int extra_radius;                  /* extra label radius pad */
        !           234:     int label_radius;                  /* Radius of labels from menu center */
        !           235:     int center_x, center_y;            /* Menu center */
        !           236:     XSegment *segments;                        /* Line segments to draw */
        !           237: 
        !           238:     /*
        !           239:      * Miscellaneous information:
        !           240:      */
        !           241: 
        !           242:     Tk_TimerToken popup_timer_token;
        !           243:     Cursor cursor;
        !           244:     PieMenuEntry *postedPie;
        !           245:     int flags;
        !           246:     int phase;
        !           247:     int popup_delay;                   /* Delay before popup */
        !           248:     int shaped;                                /* Use SHAPE extension */
        !           249: } PieMenu;
        !           250: 
        !           251: /*
        !           252:  * Flag bits for menus:
        !           253:  *
        !           254:  * REDRAW_PENDING:             Non-zero means a DoWhenIdle handler
        !           255:  *                             has already been queued to redraw
        !           256:  *                             this window.
        !           257:  * UPDATE_PENDING:             Non-zero means a DoWhenIdle handler
        !           258:  *                             has already been queued to update
        !           259:  *                             this window.
        !           260:  * RESIZE_PENDING:             Non-zero means a call to ComputeMenuGeometry
        !           261:  *                             has already been scheduled.
        !           262:  * POPUP_PENDING:              Non-zero means a call to PopupPieMenu has
        !           263:  *                             already been scheduled.
        !           264:  */
        !           265: 
        !           266: #define REDRAW_PENDING         1
        !           267: #define UPDATE_PENDING         2
        !           268: #define RESIZE_PENDING         4
        !           269: #define POPUP_PENDING          8
        !           270: 
        !           271: /*
        !           272:  * Configuration specs valid for the menu as a whole:
        !           273:  */
        !           274: 
        !           275: static Tk_ConfigSpec configSpecs[] = {
        !           276:     {TK_CONFIG_BORDER, "-activebackground", "activeBackground", "Foreground",
        !           277:        PIE_ACTIVE_BG_COLOR, Tk_Offset(PieMenu, activeBorder),
        !           278:        TK_CONFIG_COLOR_ONLY},
        !           279:     {TK_CONFIG_BORDER, "-activebackground", "activeBackground", "Foreground",
        !           280:        PIE_ACTIVE_BG_MONO, Tk_Offset(PieMenu, activeBorder),
        !           281:        TK_CONFIG_MONO_ONLY},
        !           282:     {TK_CONFIG_PIXELS, "-activeborderwidth", "activeBorderWidth", "BorderWidth",
        !           283:        PIE_ACTIVE_BORDER_WIDTH, Tk_Offset(PieMenu, activeBorderWidth), 0},
        !           284:     {TK_CONFIG_COLOR, "-activeforeground", "activeForeground", "Background",
        !           285:        PIE_ACTIVE_FG_COLOR, Tk_Offset(PieMenu, activeFg),
        !           286:        TK_CONFIG_COLOR_ONLY},
        !           287:     {TK_CONFIG_COLOR, "-activeforeground", "activeForeground", "Background",
        !           288:        PIE_ACTIVE_FG_MONO, Tk_Offset(PieMenu, activeFg),
        !           289:        TK_CONFIG_MONO_ONLY},
        !           290:     {TK_CONFIG_BORDER, "-background", "background", "Background",
        !           291:        PIE_BG_COLOR, Tk_Offset(PieMenu, border), TK_CONFIG_COLOR_ONLY},
        !           292:     {TK_CONFIG_BORDER, "-background", "background", "Background",
        !           293:        PIE_BG_MONO, Tk_Offset(PieMenu, border), TK_CONFIG_MONO_ONLY},
        !           294:     {TK_CONFIG_SYNONYM, "-bd", "borderWidth", (char *) NULL,
        !           295:        (char *) NULL, 0, 0},
        !           296:     {TK_CONFIG_SYNONYM, "-bg", "background", (char *) NULL,
        !           297:        (char *) NULL, 0, 0},
        !           298:     {TK_CONFIG_PIXELS, "-borderwidth", "borderWidth", "BorderWidth",
        !           299:        PIE_BORDER_WIDTH, Tk_Offset(PieMenu, borderWidth), 0},
        !           300:     {TK_CONFIG_ACTIVE_CURSOR, "-cursor", "cursor", "Cursor",
        !           301:        "circle", Tk_Offset(PieMenu, cursor), TK_CONFIG_NULL_OK},
        !           302:     {TK_CONFIG_SYNONYM, "-fg", "foreground", (char *) NULL,
        !           303:        (char *) NULL, 0, 0},
        !           304:     {TK_CONFIG_COLOR, "-foreground", "foreground", "Foreground",
        !           305:         PIE_FG, Tk_Offset(PieMenu, fg), 0},
        !           306:     {TK_CONFIG_FONT, "-font", "font", "Font",
        !           307:        PIE_FONT, Tk_Offset(PieMenu, fontPtr), 0},
        !           308:     {TK_CONFIG_STRING, "-title", (char *) NULL, (char *) NULL,
        !           309:        "", Tk_Offset(PieMenu, title), 0},
        !           310:     {TK_CONFIG_STRING, "-preview", (char *) NULL, (char *) NULL,
        !           311:        "", Tk_Offset(PieMenu, preview), 0},
        !           312:     {TK_CONFIG_FONT, "-titlefont", "font", "Font",
        !           313:        PIE_FONT, Tk_Offset(PieMenu, titlefontPtr), 0},
        !           314:     {TK_CONFIG_INT, "-initialangle", "initialAngle", "InitialAngle",
        !           315:        "0", Tk_Offset(PieMenu, initial_angle), 0},
        !           316:     {TK_CONFIG_INT, "-inactiveradius", "inactiveRadius", "InactiveRadius",
        !           317:        PIE_INACTIVE_RADIUS, Tk_Offset(PieMenu, inactive_radius), 0},
        !           318:     {TK_CONFIG_INT, "-minradius", "minRadius", "MinRadius",
        !           319:         PIE_MIN_RADIUS, Tk_Offset(PieMenu, min_radius), 0},
        !           320:     {TK_CONFIG_INT, "-extraradius", "extraRadius", "ExtraRadius",
        !           321:         PIE_EXTRA_RADIUS, Tk_Offset(PieMenu, extra_radius), 0},
        !           322:     {TK_CONFIG_INT, "-fixedradius", "fixedRadius", "FixedRadius",
        !           323:        "0", Tk_Offset(PieMenu, fixed_radius), 0},
        !           324:     {TK_CONFIG_INT, "-active", "active", "Active",
        !           325:        "-1", Tk_Offset(PieMenu, active), 0},
        !           326:     {TK_CONFIG_INT, "-popupdelay", "popupDelay", "PopupDelay",
        !           327:        PIE_POPUP_DELAY, Tk_Offset(PieMenu, popup_delay), 0},
        !           328:     {TK_CONFIG_INT, "-shaped", "shaped", "Shaped",
        !           329:        "1", Tk_Offset(PieMenu, shaped), 0},
        !           330:     {TK_CONFIG_END, (char *) NULL, (char *) NULL, (char *) NULL,
        !           331:        (char *) NULL, 0, 0}
        !           332: };
        !           333: 
        !           334: /*
        !           335:  * Forward declarations for procedures defined later in this file:
        !           336:  */
        !           337: 
        !           338: int            Tk_PieMenuCmd(ClientData clientData, Tcl_Interp *interp,
        !           339:                              int argc, char **argv);
        !           340: static int     ActivatePieMenuEntry _ANSI_ARGS_((PieMenu *menuPtr,
        !           341:                    int index, int preview));
        !           342: static void    ComputePieMenuGeometry _ANSI_ARGS_((
        !           343:                    ClientData clientData));
        !           344: static int     ConfigurePieMenu _ANSI_ARGS_((Tcl_Interp *interp,
        !           345:                    PieMenu *menuPtr, int argc, char **argv,
        !           346:                    int flags));
        !           347: static int     ConfigurePieMenuEntry _ANSI_ARGS_((Tcl_Interp *interp,
        !           348:                    PieMenu *menuPtr, PieMenuEntry *mePtr, int index,
        !           349:                    int argc, char **argv, int flags));
        !           350: static void    DestroyPieMenu _ANSI_ARGS_((ClientData clientData));
        !           351: static void    DestroyPieMenuEntry _ANSI_ARGS_((ClientData clientData));
        !           352: static void    DisplayPieMenu _ANSI_ARGS_((ClientData clientData));
        !           353: static void    UpdatePieMenu _ANSI_ARGS_((ClientData clientData));
        !           354: static void    PopupPieMenu _ANSI_ARGS_((ClientData clientData));
        !           355: static void    EventuallyRedrawPieMenu _ANSI_ARGS_((PieMenu *menuPtr,
        !           356:                    int index));
        !           357: static int     GetPieMenuIndex _ANSI_ARGS_((Tcl_Interp *interp,
        !           358:                    PieMenu *menuPtr, char *string, int *indexPtr));
        !           359: static void    PieMenuEventProc _ANSI_ARGS_((ClientData clientData,
        !           360:                    XEvent *eventPtr));
        !           361: static int     PieMenuWidgetCmd _ANSI_ARGS_((ClientData clientData,
        !           362:                    Tcl_Interp *interp, int argc, char **argv));
        !           363: static int     UnpostSubPieMenu _ANSI_ARGS_((Tcl_Interp *interp,
        !           364:                    PieMenu *menuPtr));
        !           365: static void    PopupPieMenu _ANSI_ARGS_((ClientData clientData));
        !           366: static void    NowPopupPieMenu _ANSI_ARGS_((PieMenu *menuPtr));
        !           367: static void    NeverPopupPieMenu _ANSI_ARGS_((PieMenu *menuPtr));
        !           368: static void    EventuallyPopupPieMenu _ANSI_ARGS_((PieMenu *menuPtr));
        !           369: static void    DeferPopupPieMenu _ANSI_ARGS_((PieMenu *menuPtr));
        !           370: static void    ShapePieMenu _ANSI_ARGS_((PieMenu *menuPtr));
        !           371: 
        !           372: 
        !           373: /*
        !           374:  *--------------------------------------------------------------
        !           375:  *
        !           376:  * Tk_PieMenuCmd --
        !           377:  *
        !           378:  *     This procedure is invoked to process the "piemenu" Tcl
        !           379:  *     command.  Read the code and write some user documentation for
        !           380:  *     details on what it does.
        !           381:  *
        !           382:  * Results:
        !           383:  *     A standard Tcl result.
        !           384:  *
        !           385:  * Side effects:
        !           386:  *     See the user documentation for "menu", which this was based on.
        !           387:  *
        !           388:  *--------------------------------------------------------------
        !           389:  */
        !           390: 
        !           391: int
        !           392: Tk_PieMenuCmd(clientData, interp, argc, argv)
        !           393:     ClientData clientData;     /* Main window associated with
        !           394:                                 * interpreter. */
        !           395:     Tcl_Interp *interp;                /* Current interpreter. */
        !           396:     int argc;                  /* Number of arguments. */
        !           397:     char **argv;               /* Argument strings. */
        !           398: {
        !           399:     Tk_Window tkwin = (Tk_Window) clientData;
        !           400:     Tk_Window new;
        !           401:     register PieMenu *menuPtr;
        !           402:     XSetWindowAttributes atts;
        !           403: 
        !           404:     if (argc < 2) {
        !           405:        Tcl_AppendResult(interp, "wrong # args: should be \"",
        !           406:                argv[0], " pathName ?options?\"", (char *) NULL);
        !           407:        return TCL_ERROR;
        !           408:     }
        !           409: 
        !           410:     /*
        !           411:      * Create the new window.  Set override-redirect so the window
        !           412:      * manager won't add a border or argue about placement, and set
        !           413:      * save-under so that the window can pop up and down without a
        !           414:      * lot of re-drawing.
        !           415:      */
        !           416: 
        !           417:     new = Tk_CreateWindowFromPath(interp, tkwin, argv[1], "");
        !           418:     if (new == NULL) {
        !           419:        return TCL_ERROR;
        !           420:     }
        !           421:     atts.override_redirect = True;
        !           422:     atts.save_under = True;
        !           423:     Tk_ChangeWindowAttributes(new, CWOverrideRedirect|CWSaveUnder, &atts);
        !           424: 
        !           425:     /*
        !           426:      * Initialize the data structure for the menu.
        !           427:      */
        !           428: 
        !           429:     menuPtr = (PieMenu *) ckalloc(sizeof(PieMenu));
        !           430:     menuPtr->tkwin = new;
        !           431:     menuPtr->interp = interp;
        !           432:     menuPtr->title = NULL;
        !           433:     menuPtr->titleLength = 0;
        !           434:     menuPtr->preview = NULL;
        !           435:     menuPtr->entries = NULL;
        !           436:     menuPtr->numEntries = 0;
        !           437:     menuPtr->active = -1;
        !           438:     menuPtr->group = NULL; 
        !           439:     menuPtr->root_x = 0;
        !           440:     menuPtr->root_y = 0; 
        !           441:     menuPtr->border = NULL;
        !           442:     menuPtr->activeBorder = NULL;
        !           443:     menuPtr->fontPtr = NULL;
        !           444:     menuPtr->titlefontPtr = NULL;
        !           445:     menuPtr->fg = NULL;
        !           446:     menuPtr->textGC = None;
        !           447:     menuPtr->activeFg = NULL;
        !           448:     menuPtr->activeGC = None;
        !           449:     menuPtr->width = 0;
        !           450:     menuPtr->height = 0;
        !           451:     menuPtr->title_x = 0;
        !           452:     menuPtr->title_y = 0;
        !           453:     menuPtr->title_width = 0;
        !           454:     menuPtr->title_height = 0;
        !           455:     menuPtr->initial_angle = 0;
        !           456:     menuPtr->inactive_radius = PIE_INACTIVE_RADIUS_NUM;
        !           457:     menuPtr->min_radius = PIE_MIN_RADIUS_NUM;
        !           458:     menuPtr->extra_radius = PIE_EXTRA_RADIUS_NUM;
        !           459:     menuPtr->fixed_radius = 0;
        !           460:     menuPtr->label_radius = 0;
        !           461:     menuPtr->center_x = 0;
        !           462:     menuPtr->center_y = 0;
        !           463:     menuPtr->segments = NULL;
        !           464:     menuPtr->cursor = None;
        !           465:     menuPtr->postedPie = NULL;
        !           466:     menuPtr->flags = 0;
        !           467:     menuPtr->phase = 0;
        !           468:     menuPtr->shaped = 1;
        !           469:     menuPtr->popup_delay = PIE_POPUP_DELAY_NUM;
        !           470: 
        !           471:     Tk_SetClass(new, "PieMenu");
        !           472:     Tk_CreateEventHandler(menuPtr->tkwin,
        !           473:                          ExposureMask | StructureNotifyMask |
        !           474:                          ButtonPressMask | ButtonReleaseMask |
        !           475:                          PointerMotionMask,
        !           476:                          PieMenuEventProc, (ClientData) menuPtr);
        !           477:     Tcl_CreateCommand(interp, Tk_PathName(menuPtr->tkwin), PieMenuWidgetCmd,
        !           478:            (ClientData) menuPtr, (void (*)()) NULL);
        !           479:     if (ConfigurePieMenu(interp, menuPtr, argc-2, argv+2, 0) != TCL_OK) {
        !           480:        goto error;
        !           481:     }
        !           482: 
        !           483:     interp->result = Tk_PathName(menuPtr->tkwin);
        !           484:     return TCL_OK;
        !           485: 
        !           486:     error:
        !           487:     Tk_DestroyWindow(menuPtr->tkwin);
        !           488:     return TCL_ERROR;
        !           489: }
        !           490: 
        !           491: /*
        !           492:  *--------------------------------------------------------------
        !           493:  *
        !           494:  * PieMenuWidgetCmd --
        !           495:  *
        !           496:  *     This procedure is invoked to process the Tcl command
        !           497:  *     that corresponds to a widget managed by this module.
        !           498:  *     See the user documentation for details on what it does.
        !           499:  *
        !           500:  * Results:
        !           501:  *     A standard Tcl result.
        !           502:  *
        !           503:  * Side effects:
        !           504:  *     See the user documentation.
        !           505:  *
        !           506:  *--------------------------------------------------------------
        !           507:  */
        !           508: 
        !           509: static int
        !           510: PieMenuWidgetCmd(clientData, interp, argc, argv)
        !           511:     ClientData clientData;     /* Information about menu widget. */
        !           512:     Tcl_Interp *interp;                /* Current interpreter. */
        !           513:     int argc;                  /* Number of arguments. */
        !           514:     char **argv;               /* Argument strings. */
        !           515: {
        !           516:     register PieMenu *menuPtr = (PieMenu *) clientData;
        !           517:     register PieMenuEntry *mePtr;
        !           518:     int result = TCL_OK;
        !           519:     int length, type;
        !           520:     char c;
        !           521: 
        !           522:     if (argc < 2) {
        !           523:        Tcl_AppendResult(interp, "wrong # args: should be \"",
        !           524:                argv[0], " option ?arg arg ...?\"", (char *) NULL);
        !           525:        return TCL_ERROR;
        !           526:     }
        !           527:     Tk_Preserve((ClientData) menuPtr);
        !           528:     c = argv[1][0];
        !           529:     length = strlen(argv[1]);
        !           530:     if ((c == 'a') && (strncmp(argv[1], "activate", length) == 0)
        !           531:            && (length >= 2)) {
        !           532:        int index;
        !           533: 
        !           534:        if (argc != 3) {
        !           535:            Tcl_AppendResult(interp, "wrong # args: should be \"",
        !           536:                    argv[0], " activate index\"", (char *) NULL);
        !           537:            goto error;
        !           538:        }
        !           539:        if (GetPieMenuIndex(interp, menuPtr, argv[2], &index) != TCL_OK) {
        !           540:            goto error;
        !           541:        }
        !           542:        if (menuPtr->active == index) {
        !           543:            goto done;
        !           544:        }
        !           545:        result = ActivatePieMenuEntry(menuPtr, index, 1);
        !           546:        DeferPopupPieMenu(menuPtr);
        !           547:     } else if ((c == 's') && (strncmp(argv[1], "show", length) == 0)
        !           548:            && (length >= 2)) {
        !           549:        int index;
        !           550: 
        !           551:        if (argc != 2) {
        !           552:            Tcl_AppendResult(interp, "wrong # args: should be \"",
        !           553:                    argv[0], " show\"", (char *) NULL);
        !           554:            goto error;
        !           555:        }
        !           556:        NowPopupPieMenu(menuPtr);
        !           557:     } else if ((c == 'p') && (strncmp(argv[1], "pending", length) == 0)
        !           558:            && (length >= 2)) {
        !           559:        int index;
        !           560: 
        !           561:        if (argc != 2) {
        !           562:            Tcl_AppendResult(interp, "wrong # args: should be \"",
        !           563:                    argv[0], " pending\"", (char *) NULL);
        !           564:            goto error;
        !           565:        }
        !           566:        sprintf(interp->result, "%d",
        !           567:                (menuPtr->flags & POPUP_PENDING) ? 1 : 0);
        !           568:     } else if ((c == 'd') && (strncmp(argv[1], "defer", length) == 0)
        !           569:            && (length >= 2)) {
        !           570:        int index;
        !           571: 
        !           572:        if (argc != 2) {
        !           573:            Tcl_AppendResult(interp, "wrong # args: should be \"",
        !           574:                    argv[0], " defer\"", (char *) NULL);
        !           575:            goto error;
        !           576:        }
        !           577:        DeferPopupPieMenu(menuPtr);
        !           578:     } else if ((c == 'a') && (strncmp(argv[1], "add", length) == 0)
        !           579:            && (length >= 2)) {
        !           580:        PieMenuEntry **newEntries;
        !           581: 
        !           582:        if (argc < 3) {
        !           583:            Tcl_AppendResult(interp, "wrong # args: should be \"",
        !           584:                    argv[0], " add type ?options?\"", (char *) NULL);
        !           585:            goto error;
        !           586:        }
        !           587: 
        !           588:        /*
        !           589:         * Figure out the type of the new entry.
        !           590:         */
        !           591: 
        !           592:        c = argv[2][0];
        !           593:        length = strlen(argv[2]);
        !           594:        if ((c == 'c') && (strncmp(argv[2], "command", length) == 0)) {
        !           595:            type = COMMAND_ENTRY;
        !           596:        } else if ((c == 'p') && (strncmp(argv[2], "piemenu", length) == 0)) {
        !           597:            type = PIEMENU_ENTRY;
        !           598:        } else {
        !           599:            Tcl_AppendResult(interp, "bad menu entry type \"",
        !           600:                             argv[2], "\":  must be command or piemenu",
        !           601:                             (char *) NULL);
        !           602:            goto error;
        !           603:        }
        !           604: 
        !           605:        /*
        !           606:         * Add a new entry to the end of the menu's array of entries,
        !           607:         * and process options for it.
        !           608:         */
        !           609: 
        !           610:        mePtr = (PieMenuEntry *) ckalloc(sizeof(PieMenuEntry));
        !           611:        newEntries = (PieMenuEntry **) ckalloc((unsigned)
        !           612:                ((menuPtr->numEntries+1)*sizeof(PieMenuEntry *)));
        !           613:        if (menuPtr->numEntries != 0) {
        !           614:            memcpy((VOID *) newEntries, (VOID *) menuPtr->entries,
        !           615:                    menuPtr->numEntries*sizeof(PieMenuEntry *));
        !           616:            ckfree((char *) menuPtr->entries);
        !           617:        }
        !           618:        menuPtr->entries = newEntries;
        !           619:        menuPtr->entries[menuPtr->numEntries] = mePtr;
        !           620:        menuPtr->numEntries++;
        !           621:        mePtr->type = type;
        !           622:        mePtr->piemenuPtr = menuPtr;
        !           623:        mePtr->label = NULL;
        !           624:        mePtr->labelLength = 0;
        !           625:        mePtr->bitmap = None;
        !           626:        mePtr->width = 0;
        !           627:        mePtr->height = 0;
        !           628:        mePtr->x_offset = 0;
        !           629:        mePtr->y_offset = 0;
        !           630:        mePtr->label_x = 0;
        !           631:        mePtr->label_y = 0;
        !           632:        mePtr->border = NULL;
        !           633:        mePtr->activeBorder = NULL;
        !           634:        mePtr->fontPtr = NULL;
        !           635:        mePtr->textGC = None;
        !           636:        mePtr->activeGC = None;
        !           637:        mePtr->slice = 1.0;
        !           638:        mePtr->angle = 0.0;
        !           639:        mePtr->dx = 0.0;
        !           640:        mePtr->dy = 0.0;
        !           641:        mePtr->subtend = 0.0;
        !           642:        mePtr->quadrant = 0;
        !           643:        mePtr->slope = 0.0;
        !           644:        mePtr->command = NULL;
        !           645:        mePtr->preview = NULL;
        !           646:        mePtr->name = NULL;
        !           647:        mePtr->flags = 0;
        !           648:        if (ConfigurePieMenuEntry(interp, menuPtr, mePtr,
        !           649:                                  menuPtr->numEntries-1,
        !           650:                                  argc-3, argv+3, 0) != TCL_OK) {
        !           651:            DestroyPieMenuEntry((ClientData) mePtr);
        !           652:            menuPtr->numEntries--;
        !           653:            goto error;
        !           654:        }
        !           655:        if (!(menuPtr->flags & RESIZE_PENDING)) {
        !           656:            menuPtr->flags |= RESIZE_PENDING;
        !           657:            Tk_DoWhenIdle(ComputePieMenuGeometry, (ClientData) menuPtr);
        !           658:        }
        !           659:     } else if ((c == 'c') && (strncmp(argv[1], "configure", length) == 0)) {
        !           660:        if (argc == 2) {
        !           661:            result = Tk_ConfigureInfo(interp, menuPtr->tkwin, configSpecs,
        !           662:                    (char *) menuPtr, (char *) NULL, 0);
        !           663:        } else if (argc == 3) {
        !           664:            result = Tk_ConfigureInfo(interp, menuPtr->tkwin, configSpecs,
        !           665:                    (char *) menuPtr, argv[2], 0);
        !           666:        } else {
        !           667:            result = ConfigurePieMenu(interp, menuPtr, argc-2, argv+2,
        !           668:                    TK_CONFIG_ARGV_ONLY);
        !           669:        }
        !           670:     } else if ((c == 'd') && (strncmp(argv[1], "delete", length) == 0)
        !           671:            && (length >= 2)) {
        !           672:        int index, i;
        !           673: 
        !           674:        if (argc != 3) {
        !           675:            Tcl_AppendResult(interp, "wrong # args: should be \"",
        !           676:                    argv[0], " delete index\"", (char *) NULL);
        !           677:            goto error;
        !           678:        }
        !           679:        if (GetPieMenuIndex(interp, menuPtr, argv[2], &index) != TCL_OK) {
        !           680:            goto error;
        !           681:        }
        !           682:        if (index < 0) {
        !           683:            goto done;
        !           684:        }
        !           685:        Tk_EventuallyFree((ClientData) menuPtr->entries[index],
        !           686:                          DestroyPieMenuEntry);
        !           687:        for (i = index; i < menuPtr->numEntries-1; i++) {
        !           688:            menuPtr->entries[i] = menuPtr->entries[i+1];
        !           689:        }
        !           690:        menuPtr->numEntries -= 1;
        !           691:        if (menuPtr->active == index) {
        !           692:            menuPtr->active = -1;
        !           693:        } else if (menuPtr->active > index) {
        !           694:            menuPtr->active -= 1;
        !           695:        }
        !           696:        if (!(menuPtr->flags & RESIZE_PENDING)) {
        !           697:            menuPtr->flags |= RESIZE_PENDING;
        !           698:            Tk_DoWhenIdle(ComputePieMenuGeometry, (ClientData) menuPtr);
        !           699:        }
        !           700:     } else if ((c == 'e') && (length >= 3)
        !           701:            && (strncmp(argv[1], "entryconfigure", length) == 0)) {
        !           702:        int index;
        !           703: 
        !           704:        if (argc < 3) {
        !           705:            Tcl_AppendResult(interp, "wrong # args: should be \"",
        !           706:                    argv[0], " entryconfigure index ?option value ...?\"",
        !           707:                    (char *) NULL);
        !           708:            goto error;
        !           709:        }
        !           710:        if (GetPieMenuIndex(interp, menuPtr, argv[2], &index) != TCL_OK) {
        !           711:            goto error;
        !           712:        }
        !           713:        if (index < 0) {
        !           714:            goto done;
        !           715:        }
        !           716:        mePtr = menuPtr->entries[index];
        !           717:        Tk_Preserve((ClientData) mePtr);
        !           718:        if (argc == 3) {
        !           719:            result = Tk_ConfigureInfo(interp, menuPtr->tkwin, entryConfigSpecs,
        !           720:                    (char *) mePtr, (char *) NULL,
        !           721:                    COMMAND_MASK << mePtr->type);
        !           722:        } else if (argc == 4) {
        !           723:            result = Tk_ConfigureInfo(interp, menuPtr->tkwin, entryConfigSpecs,
        !           724:                    (char *) mePtr, argv[3], COMMAND_MASK << mePtr->type);
        !           725:        } else {
        !           726:            result = ConfigurePieMenuEntry(interp, menuPtr, mePtr, index,
        !           727:                                           argc-3, argv+3,
        !           728:                                           TK_CONFIG_ARGV_ONLY |
        !           729:                                             COMMAND_MASK << mePtr->type);
        !           730:        }
        !           731:        Tk_Release((ClientData) mePtr);
        !           732:     } else if ((c == 'i') && (strncmp(argv[1], "index", length) == 0)
        !           733:            && (length >= 3)) {
        !           734:        int index;
        !           735: 
        !           736:        if (argc != 3) {
        !           737:            Tcl_AppendResult(interp, "wrong # args: should be \"",
        !           738:                    argv[0], " index string\"", (char *) NULL);
        !           739:            goto error;
        !           740:        }
        !           741:        if (GetPieMenuIndex(interp, menuPtr, argv[2], &index) != TCL_OK) {
        !           742:            goto error;
        !           743:        }
        !           744:        if (index < 0) {
        !           745:            interp->result = "none";
        !           746:        } else {
        !           747:            sprintf(interp->result, "%d", index);
        !           748:        }
        !           749:     } else if ((c == 'i') && (strncmp(argv[1], "invoke", length) == 0)
        !           750:            && (length >= 3)) {
        !           751:        int index;
        !           752: 
        !           753:        if (argc != 3) {
        !           754:            Tcl_AppendResult(interp, "wrong # args: should be \"",
        !           755:                    argv[0], " invoke index\"", (char *) NULL);
        !           756:            goto error;
        !           757:        }
        !           758:        if (GetPieMenuIndex(interp, menuPtr, argv[2], &index) != TCL_OK) {
        !           759:            goto error;
        !           760:        }
        !           761:        if (index < 0) {
        !           762:            goto done;
        !           763:        }
        !           764:        mePtr = menuPtr->entries[index];
        !           765:        Tk_Preserve((ClientData) mePtr);
        !           766:        if (mePtr->command != NULL) {
        !           767:            result = Tcl_GlobalEval(interp, mePtr->command);
        !           768:        }
        !           769:        Tk_Release((ClientData) mePtr);
        !           770:     } else if ((c == 'p') && (strncmp(argv[1], "post", length) == 0)) {
        !           771:        int x, y, ix, iy, tmp, err;
        !           772:        Tk_Uid group;
        !           773: 
        !           774:        if ((argc != 4) && (argc != 5)) {
        !           775:            Tcl_AppendResult(interp, "wrong # args: should be \"",
        !           776:                    argv[0], " post x y ?group?\"", (char *) NULL);
        !           777:            goto error;
        !           778:        }
        !           779:        if ((Tcl_GetInt(interp, argv[2], &x) != TCL_OK)
        !           780:                || (Tcl_GetInt(interp, argv[3], &y) != TCL_OK)) {
        !           781:            goto error;
        !           782:        }
        !           783:        if (argc == 5) {
        !           784:            group = Tk_GetUid(argv[4]);
        !           785:        } else {
        !           786:            group = Tk_GetUid("default");
        !           787:        }
        !           788: 
        !           789:        /*
        !           790:         * Adjust the position of the menu if necessary to keep it
        !           791:         * on-screen.
        !           792:         */
        !           793: 
        !           794:        x -= menuPtr->center_x; y -= menuPtr->center_y;
        !           795: #if 0
        !           796:        ix = x; iy = y;
        !           797: 
        !           798:        tmp = WidthOfScreen(Tk_Screen(menuPtr->tkwin))
        !           799:                - Tk_Width(menuPtr->tkwin);
        !           800:        if (x > tmp) {
        !           801:            x = tmp;
        !           802:        }
        !           803:        if (x < 0) {
        !           804:            x = 0;
        !           805:        }
        !           806:        tmp = HeightOfScreen(Tk_Screen(menuPtr->tkwin))
        !           807:                - Tk_Height(menuPtr->tkwin);
        !           808:        if (y > tmp) {
        !           809:            y = tmp;
        !           810:        }
        !           811:        if (y < 0) {
        !           812:            y = 0;
        !           813:        }
        !           814: 
        !           815:        /* XXX: warp pointer by (x-ix, y-iy) upon popup */
        !           816: #endif
        !           817: 
        !           818:        Tk_MakeWindowExist(menuPtr->tkwin);
        !           819:        XRaiseWindow(Tk_Display(menuPtr->tkwin), Tk_WindowId(menuPtr->tkwin));
        !           820: 
        !           821:        Tk_MoveWindow(menuPtr->tkwin, x, y);
        !           822:        menuPtr->root_x = x + menuPtr->center_x;
        !           823:        menuPtr->root_y = y + menuPtr->center_y;
        !           824:        
        !           825:        if (Tk_IsMapped(menuPtr->tkwin)) {
        !           826:            if (group != menuPtr->group) {
        !           827:                Tk_UnshareEvents(menuPtr->tkwin, menuPtr->group);
        !           828:                Tk_ShareEvents(menuPtr->tkwin, group);
        !           829:            }
        !           830:        } else {
        !           831:            Tk_ShareEvents(menuPtr->tkwin, group);
        !           832:            EventuallyPopupPieMenu(menuPtr);
        !           833:            result = ActivatePieMenuEntry(menuPtr, -1, 1);
        !           834:        }
        !           835:        menuPtr->group = group;
        !           836:     } else if ((c == 'u') && (strncmp(argv[1], "unpost", length) == 0)) {
        !           837:        if (argc != 2) {
        !           838:            Tcl_AppendResult(interp, "wrong # args: should be \"",
        !           839:                    argv[0], " unpost\"", (char *) NULL);
        !           840:            goto error;
        !           841:        }
        !           842:        NeverPopupPieMenu(menuPtr);
        !           843:        Tk_UnshareEvents(menuPtr->tkwin, menuPtr->group);
        !           844:        Tk_UnmapWindow(menuPtr->tkwin);
        !           845:        result = ActivatePieMenuEntry(menuPtr, -1, 0);
        !           846:        if (result == TCL_OK) {
        !           847:            result = UnpostSubPieMenu(interp, menuPtr);
        !           848:        }
        !           849:     } else if ((c == 'g') && (strncmp(argv[1], "grab", length) == 0)) {
        !           850:       Tk_Window tkwin;
        !           851:       int err;
        !           852: 
        !           853:       if ((argc != 3) ||
        !           854:          ((tkwin = Tk_NameToWindow(interp, argv[2],
        !           855:                                    menuPtr->tkwin)) == NULL)) {
        !           856:        Tcl_AppendResult(interp, "wrong # args: should be \"",
        !           857:                         argv[0], " grab window\"", (char *) NULL);
        !           858:        goto error;
        !           859:       }
        !           860:       
        !           861:       err =
        !           862:        XGrabPointer(Tk_Display(tkwin),
        !           863:                     Tk_WindowId(tkwin),
        !           864:                     False,
        !           865:                     ButtonPressMask | ButtonReleaseMask |
        !           866:                     ButtonMotionMask | PointerMotionMask,
        !           867:                     GrabModeAsync, GrabModeAsync, None, None,
        !           868:                     TkCurrentTime(((TkWindow *)tkwin)->dispPtr));
        !           869:       if (err != 0) {
        !           870:        if (err == GrabNotViewable) {
        !           871:          interp->result = "grab failed: window not viewable";
        !           872:        } else if (err == AlreadyGrabbed) {
        !           873:          interp->result = "grab failed: another application has grab";
        !           874:        } else if (err == GrabFrozen) {
        !           875:          interp->result = "grab failed: keyboard or pointer frozen";
        !           876:        } else if (err == GrabInvalidTime) {
        !           877:          interp->result = "grab failed: invalid time";
        !           878:        } else {
        !           879:          char msg[100];
        !           880:          
        !           881:          sprintf(msg, "grab failed for unknown reason (code %d)",
        !           882:                  err);
        !           883:          Tcl_AppendResult(interp, msg, (char *) NULL);
        !           884:        }
        !           885:        return TCL_ERROR;
        !           886:       }
        !           887:     } else if ((c == 'u') && (strncmp(argv[1], "ungrab", length) == 0)) {
        !           888:       Tk_Window tkwin;
        !           889: 
        !           890:       if ((argc != 3) ||
        !           891:          ((tkwin = Tk_NameToWindow(interp, argv[2],
        !           892:                                    menuPtr->tkwin)) == NULL)) {
        !           893:        Tcl_AppendResult(interp, "wrong # args: should be \"",
        !           894:                         argv[0], " ungrab window\"", (char *) NULL);
        !           895:        goto error;
        !           896:       }
        !           897: 
        !           898:       XUngrabPointer(Tk_Display(tkwin),
        !           899:                     TkCurrentTime(((TkWindow *)tkwin)->dispPtr));
        !           900: 
        !           901:     } else if ((c == 'd') && (strncmp(argv[1], "distance", length) == 0)
        !           902:            && (length >= 3)) {
        !           903:        int distance;
        !           904: 
        !           905:        if (argc != 2) {
        !           906:            Tcl_AppendResult(interp, "wrong # args: should be \"",
        !           907:                    argv[0], " distance\"", (char *) NULL);
        !           908:            goto error;
        !           909:        }
        !           910:        distance = (int)(sqrt((menuPtr->dx * menuPtr->dx) + (menuPtr->dy * menuPtr->dy)) + 0.499);
        !           911:        sprintf(interp->result, "%d", distance);
        !           912:     } else if ((c == 'd') && (strncmp(argv[1], "direction", length) == 0)
        !           913:            && (length >= 3)) {
        !           914:        int direction;
        !           915: 
        !           916:        if (argc != 2) {
        !           917:            Tcl_AppendResult(interp, "wrong # args: should be \"",
        !           918:                    argv[0], " direction\"", (char *) NULL);
        !           919:            goto error;
        !           920:        }
        !           921:        direction = (int)(RAD_TO_DEG(atan2(menuPtr->dy, menuPtr->dx)) + 0.499);
        !           922:        if (direction < 0) direction += 360;
        !           923:        sprintf(interp->result, "%d", direction);
        !           924:     } else {
        !           925:        Tcl_AppendResult(interp, "bad option \"", argv[1],
        !           926:                "\": must be activate, show, add, configure, delete, ",
        !           927:                "entryconfigure, index, invoke, post, unpost, pending, ",
        !           928:                "defer, grab, or ungrab", (char *) NULL);
        !           929:        goto error;
        !           930:     }
        !           931:     done:
        !           932:     Tk_Release((ClientData) menuPtr);
        !           933:     return result;
        !           934: 
        !           935:     error:
        !           936:     Tk_Release((ClientData) menuPtr);
        !           937:     return TCL_ERROR;
        !           938: }
        !           939: 
        !           940: /*
        !           941:  *----------------------------------------------------------------------
        !           942:  *
        !           943:  * DestroyPieMenu --
        !           944:  *
        !           945:  *     This procedure is invoked by Tk_EventuallyFree or Tk_Release
        !           946:  *     to clean up the internal structure of a pie menu at a safe time
        !           947:  *     (when no-one is using it anymore).
        !           948:  *
        !           949:  * Results:
        !           950:  *     None.
        !           951:  *
        !           952:  * Side effects:
        !           953:  *     Everything associated with the pie menu is freed up.
        !           954:  *
        !           955:  *----------------------------------------------------------------------
        !           956:  */
        !           957: 
        !           958: static void
        !           959: DestroyPieMenu(clientData)
        !           960:     ClientData clientData;     /* Info about menu widget. */
        !           961: {
        !           962:     register PieMenu *menuPtr = (PieMenu *) clientData;
        !           963:     int i;
        !           964: 
        !           965:     /* Should we delete the event handler? */
        !           966: 
        !           967:     for (i = 0; i < menuPtr->numEntries; i++) {
        !           968:        DestroyPieMenuEntry((ClientData) menuPtr->entries[i]);
        !           969:     }
        !           970:     if (menuPtr->entries != NULL) {
        !           971:        ckfree((char *) menuPtr->entries);
        !           972:     }
        !           973:     if (menuPtr->border != NULL) {
        !           974:        Tk_Free3DBorder(menuPtr->border);
        !           975:     }
        !           976:     if (menuPtr->activeBorder != NULL) {
        !           977:        Tk_Free3DBorder(menuPtr->activeBorder);
        !           978:     }
        !           979:     if (menuPtr->fontPtr != NULL) {
        !           980:        Tk_FreeFontStruct(menuPtr->fontPtr);
        !           981:     }
        !           982:     if (menuPtr->fg != NULL) {
        !           983:        Tk_FreeColor(menuPtr->fg);
        !           984:     }
        !           985:     if (menuPtr->textGC != None) {
        !           986:        Tk_FreeGC(menuPtr->textGC);
        !           987:     }
        !           988:     if (menuPtr->activeFg != NULL) {
        !           989:        Tk_FreeColor(menuPtr->activeFg);
        !           990:     }
        !           991:     if (menuPtr->activeGC != None) {
        !           992:        Tk_FreeGC(menuPtr->activeGC);
        !           993:     }
        !           994:     if (menuPtr->cursor != None) {
        !           995:        Tk_FreeCursor(menuPtr->cursor);
        !           996:     }
        !           997:     ckfree((char *) menuPtr);
        !           998: }
        !           999: 
        !          1000: /*
        !          1001:  *----------------------------------------------------------------------
        !          1002:  *
        !          1003:  * DestroyPieMenuEntry --
        !          1004:  *
        !          1005:  *     This procedure is invoked by Tk_EventuallyFree or Tk_Release
        !          1006:  *     to clean up the internal structure of a pie menu entry at a safe 
        !          1007:  *     time (when no-one is using it anymore).
        !          1008:  *
        !          1009:  * Results:
        !          1010:  *     None.
        !          1011:  *
        !          1012:  * Side effects:
        !          1013:  *     Everything associated with the pie menu entry is freed up.
        !          1014:  *
        !          1015:  *----------------------------------------------------------------------
        !          1016:  */
        !          1017: 
        !          1018: static void
        !          1019: DestroyPieMenuEntry(clientData)
        !          1020:     ClientData clientData;             /* Pointer to entry to be freed. */
        !          1021: {
        !          1022:     register PieMenuEntry *mePtr = (PieMenuEntry *) clientData;
        !          1023:     PieMenu *menuPtr = mePtr->piemenuPtr;
        !          1024: 
        !          1025:     if (menuPtr->postedPie == mePtr) {
        !          1026:        if (UnpostSubPieMenu(menuPtr->interp, menuPtr)
        !          1027:                != TCL_OK) {
        !          1028:            TkBindError(menuPtr->interp);
        !          1029:        }
        !          1030:     }
        !          1031:     if (mePtr->label != NULL) {
        !          1032:        ckfree(mePtr->label);
        !          1033:     }
        !          1034:     if (mePtr->bitmap != None) {
        !          1035:        Tk_FreePixmap(mePtr->bitmap);
        !          1036:     }
        !          1037:     if (mePtr->border != NULL) {
        !          1038:        Tk_Free3DBorder(mePtr->border);
        !          1039:     }
        !          1040:     if (mePtr->activeBorder != NULL) {
        !          1041:        Tk_Free3DBorder(mePtr->activeBorder);
        !          1042:     }
        !          1043:     if (mePtr->fontPtr != NULL) {
        !          1044:        Tk_FreeFontStruct(mePtr->fontPtr);
        !          1045:     }
        !          1046:     if (mePtr->textGC != NULL) {
        !          1047:        Tk_FreeGC(mePtr->textGC);
        !          1048:     }
        !          1049:     if (mePtr->activeGC != NULL) {
        !          1050:        Tk_FreeGC(mePtr->activeGC);
        !          1051:     }
        !          1052:     if (mePtr->command != NULL) {
        !          1053:        ckfree(mePtr->command);
        !          1054:     }
        !          1055:     if (mePtr->name != NULL) {
        !          1056:        ckfree(mePtr->name);
        !          1057:     }
        !          1058:     ckfree((char *) mePtr);
        !          1059: }
        !          1060: 
        !          1061: /*
        !          1062:  *----------------------------------------------------------------------
        !          1063:  *
        !          1064:  * ConfigurePieMenu --
        !          1065:  *
        !          1066:  *     This procedure is called to process an argv/argc list, plus
        !          1067:  *     the Tk option database, in order to configure (or
        !          1068:  *     reconfigure) a menu widget.
        !          1069:  *
        !          1070:  * Results:
        !          1071:  *     The return value is a standard Tcl result.  If TCL_ERROR is
        !          1072:  *     returned, then interp->result contains an error message.
        !          1073:  *
        !          1074:  * Side effects:
        !          1075:  *     Configuration information, such as colors, font, etc. get set
        !          1076:  *     for menuPtr;  old resources get freed, if there were any.
        !          1077:  *
        !          1078:  *----------------------------------------------------------------------
        !          1079:  */
        !          1080: 
        !          1081: static int
        !          1082: ConfigurePieMenu(interp, menuPtr, argc, argv, flags)
        !          1083:     Tcl_Interp *interp;                /* Used for error reporting. */
        !          1084:     register PieMenu *menuPtr; /* Information about widget;  may or may
        !          1085:                                 * not already have values for some fields. */
        !          1086:     int argc;                  /* Number of valid entries in argv. */
        !          1087:     char **argv;               /* Arguments. */
        !          1088:     int flags;                 /* Flags to pass to Tk_ConfigureWidget. */
        !          1089: {
        !          1090:     XGCValues gcValues;
        !          1091:     GC newGC;
        !          1092:     int i;
        !          1093: 
        !          1094:     if (Tk_ConfigureWidget(interp, menuPtr->tkwin, configSpecs,
        !          1095:            argc, argv, (char *) menuPtr, flags) != TCL_OK) {
        !          1096:        return TCL_ERROR;
        !          1097:     }
        !          1098: 
        !          1099:     /*
        !          1100:      * A few options need special processing, such as setting the
        !          1101:      * background from a 3-D border, or filling in complicated
        !          1102:      * defaults that couldn't be specified to Tk_ConfigureWidget.
        !          1103:      */
        !          1104: 
        !          1105:     if (menuPtr->title == NULL) {
        !          1106:        menuPtr->titleLength = 0;
        !          1107:     } else {
        !          1108:        menuPtr->titleLength = strlen(menuPtr->title);
        !          1109:     }
        !          1110: 
        !          1111:     Tk_SetBackgroundFromBorder(menuPtr->tkwin, menuPtr->border);
        !          1112: 
        !          1113:     gcValues.font = menuPtr->fontPtr->fid;
        !          1114:     gcValues.foreground = menuPtr->fg->pixel;
        !          1115:     gcValues.background = Tk_3DBorderColor(menuPtr->border)->pixel;
        !          1116:     newGC = Tk_GetGC(menuPtr->tkwin, GCForeground|GCBackground|GCFont,
        !          1117:            &gcValues);
        !          1118:     if (menuPtr->textGC != None) {
        !          1119:        Tk_FreeGC(menuPtr->textGC);
        !          1120:     }
        !          1121:     menuPtr->textGC = newGC;
        !          1122: 
        !          1123:     gcValues.font = menuPtr->fontPtr->fid;
        !          1124:     gcValues.foreground = menuPtr->activeFg->pixel;
        !          1125:     gcValues.background = Tk_3DBorderColor(menuPtr->activeBorder)->pixel;
        !          1126:     newGC = Tk_GetGC(menuPtr->tkwin, GCForeground|GCBackground|GCFont,
        !          1127:            &gcValues);
        !          1128:     if (menuPtr->activeGC != None) {
        !          1129:        Tk_FreeGC(menuPtr->activeGC);
        !          1130:     }
        !          1131:     menuPtr->activeGC = newGC;
        !          1132: 
        !          1133:     /*
        !          1134:      * After reconfiguring a menu, we need to reconfigure all of the
        !          1135:      * entries in the menu, since some of the things in the children
        !          1136:      * (such as graphics contexts) may have to change to reflect changes
        !          1137:      * in the parent.
        !          1138:      */
        !          1139: 
        !          1140:     for (i = 0; i < menuPtr->numEntries; i++) {
        !          1141:        PieMenuEntry *mePtr;
        !          1142: 
        !          1143:        mePtr = menuPtr->entries[i];
        !          1144:        ConfigurePieMenuEntry(interp, menuPtr, mePtr, i, 0, (char **) NULL,
        !          1145:                TK_CONFIG_ARGV_ONLY | COMMAND_MASK << mePtr->type);
        !          1146:     }
        !          1147: 
        !          1148:     if (!(menuPtr->flags & RESIZE_PENDING)) {
        !          1149:        menuPtr->flags |= RESIZE_PENDING;
        !          1150:        Tk_DoWhenIdle(ComputePieMenuGeometry, (ClientData) menuPtr);
        !          1151:     }
        !          1152: 
        !          1153:     return TCL_OK;
        !          1154: }
        !          1155: 
        !          1156: /*
        !          1157:  *----------------------------------------------------------------------
        !          1158:  *
        !          1159:  * ConfigurePieMenuEntry --
        !          1160:  *
        !          1161:  *     This procedure is called to process an argv/argc list, plus
        !          1162:  *     the Tk option database, in order to configure (or
        !          1163:  *     reconfigure) one entry in a menu.
        !          1164:  *
        !          1165:  * Results:
        !          1166:  *     The return value is a standard Tcl result.  If TCL_ERROR is
        !          1167:  *     returned, then interp->result contains an error message.
        !          1168:  *
        !          1169:  * Side effects:
        !          1170:  *     Configuration information such as label and accelerator get
        !          1171:  *     set for mePtr;  old resources get freed, if there were any.
        !          1172:  *
        !          1173:  *----------------------------------------------------------------------
        !          1174:  */
        !          1175: 
        !          1176: static int
        !          1177: ConfigurePieMenuEntry(interp, menuPtr, mePtr, index, argc, argv, flags)
        !          1178:     Tcl_Interp *interp;                        /* Used for error reporting. */
        !          1179:     PieMenu *menuPtr;                  /* Information about whole menu. */
        !          1180:     register PieMenuEntry *mePtr;      /* Information about menu entry;  may
        !          1181:                                         * or may not already have values for
        !          1182:                                         * some fields. */
        !          1183:     int index;                         /* Index of mePtr within menuPtr's
        !          1184:                                         * entries. */
        !          1185:     int argc;                          /* Number of valid entries in argv. */
        !          1186:     char **argv;                       /* Arguments. */
        !          1187:     int flags;                         /* Additional flags to pass to
        !          1188:                                         * Tk_ConfigureWidget. */
        !          1189: {
        !          1190:     XGCValues gcValues;
        !          1191:     GC newGC, newActiveGC;
        !          1192: 
        !          1193:     /*
        !          1194:      * If this entry is a piemenu and the piemenu is posted, then unpost
        !          1195:      * it before reconfiguring the entry (otherwise the reconfigure might
        !          1196:      * change the name of the piemenu entry, leaving a posted menu
        !          1197:      * high and dry).
        !          1198:      */
        !          1199: 
        !          1200:     if (menuPtr->postedPie == mePtr) {
        !          1201:        if (UnpostSubPieMenu(menuPtr->interp, menuPtr)
        !          1202:                != TCL_OK) {
        !          1203:            TkBindError(menuPtr->interp);
        !          1204:        }
        !          1205:     }
        !          1206: 
        !          1207:     if (Tk_ConfigureWidget(interp, menuPtr->tkwin, entryConfigSpecs,
        !          1208:            argc, argv, (char *) mePtr,
        !          1209:            flags | (COMMAND_MASK << mePtr->type)) != TCL_OK) {
        !          1210:        return TCL_ERROR;
        !          1211:     }
        !          1212: 
        !          1213:     /*
        !          1214:      * The code below handles special configuration stuff not taken
        !          1215:      * care of by Tk_ConfigureWidget, such as special processing for
        !          1216:      * defaults, sizing strings, graphics contexts, etc.
        !          1217:      */
        !          1218: 
        !          1219:     if (mePtr->label == NULL) {
        !          1220:        mePtr->labelLength = 0;
        !          1221:     } else {
        !          1222:        mePtr->labelLength = strlen(mePtr->label);
        !          1223:     }
        !          1224: 
        !          1225:     if (index != menuPtr->active) {
        !          1226:        ActivatePieMenuEntry(menuPtr, index, 0);
        !          1227:     }
        !          1228: 
        !          1229:     if ((mePtr->fontPtr != NULL) ||
        !          1230:        (mePtr->type == PIEMENU_ENTRY)) {
        !          1231:        gcValues.foreground = menuPtr->fg->pixel;
        !          1232:        gcValues.background = Tk_3DBorderColor(
        !          1233:                (mePtr->border != NULL) ? mePtr->border : menuPtr->border)
        !          1234:                ->pixel;
        !          1235:        if (mePtr->fontPtr != NULL) {
        !          1236:          gcValues.font = mePtr->fontPtr->fid;
        !          1237:        } else {
        !          1238:          if (menuPtr->titlefontPtr != NULL)
        !          1239:            gcValues.font = menuPtr->titlefontPtr->fid;
        !          1240:          else
        !          1241:            gcValues.font = menuPtr->fontPtr->fid;
        !          1242:        }
        !          1243: 
        !          1244:        /*
        !          1245:         * Note: disable GraphicsExpose events;  we know there won't be
        !          1246:         * obscured areas when copying from an off-screen pixmap to the
        !          1247:         * screen and this gets rid of unnecessary events.
        !          1248:         */
        !          1249: 
        !          1250:        gcValues.graphics_exposures = False;
        !          1251:        newGC = Tk_GetGC(menuPtr->tkwin,
        !          1252:                GCForeground|GCBackground|GCFont|GCGraphicsExposures,
        !          1253:                &gcValues);
        !          1254: 
        !          1255:        gcValues.foreground = menuPtr->activeFg->pixel;
        !          1256:        gcValues.background = Tk_3DBorderColor(
        !          1257:                (mePtr->activeBorder != NULL) ? mePtr->activeBorder
        !          1258:                : menuPtr->activeBorder)->pixel;
        !          1259:        newActiveGC = Tk_GetGC(menuPtr->tkwin,
        !          1260:                GCForeground|GCBackground|GCFont|GCGraphicsExposures,
        !          1261:                &gcValues);
        !          1262:     } else {
        !          1263:        newGC = NULL;
        !          1264:        newActiveGC = NULL;
        !          1265:     }
        !          1266: 
        !          1267:     if (mePtr->textGC != NULL) {
        !          1268:            Tk_FreeGC(mePtr->textGC);
        !          1269:     }
        !          1270:     mePtr->textGC = newGC;
        !          1271: 
        !          1272:     if (mePtr->activeGC != NULL) {
        !          1273:            Tk_FreeGC(mePtr->activeGC);
        !          1274:     }
        !          1275:     mePtr->activeGC = newActiveGC;
        !          1276: 
        !          1277:     if (!(menuPtr->flags & RESIZE_PENDING)) {
        !          1278:        menuPtr->flags |= RESIZE_PENDING;
        !          1279:        Tk_DoWhenIdle(ComputePieMenuGeometry, (ClientData) menuPtr);
        !          1280:     }
        !          1281:     return TCL_OK;
        !          1282: }
        !          1283: 
        !          1284: /*
        !          1285:  *--------------------------------------------------------------
        !          1286:  *
        !          1287:  * ComputePieMenuGeometry --
        !          1288:  *
        !          1289:  *     This procedure is invoked to recompute the size and
        !          1290:  *     layout of a menu.  It is called as a when-idle handler so
        !          1291:  *     that it only gets done once, even if a group of changes is
        !          1292:  *     made to the menu.
        !          1293:  *
        !          1294:  * Results:
        !          1295:  *     None.
        !          1296:  *
        !          1297:  * Side effects:
        !          1298:  *     Fields of menu entries are changed to reflect their
        !          1299:  *     current positions, and the size of the menu window
        !          1300:  *     itself may be changed.
        !          1301:  *
        !          1302:  *--------------------------------------------------------------
        !          1303:  */
        !          1304: 
        !          1305: static void
        !          1306: ComputePieMenuGeometry(clientData)
        !          1307:     ClientData clientData;             /* Structure describing menu. */
        !          1308: {
        !          1309:     PieMenu *menuPtr = (PieMenu *) clientData;
        !          1310: 
        !          1311:     if (menuPtr->tkwin == NULL) {
        !          1312:        return;
        !          1313:     }
        !          1314: 
        !          1315:     LayoutPieMenu(menuPtr);
        !          1316: 
        !          1317:     if ((menuPtr->width != Tk_ReqWidth(menuPtr->tkwin)) ||
        !          1318:        (menuPtr->height != Tk_ReqHeight(menuPtr->tkwin))) {
        !          1319:        Tk_GeometryRequest(menuPtr->tkwin, menuPtr->width, menuPtr->height);
        !          1320:     } else {
        !          1321:        /*
        !          1322:         * Must always force a redisplay here if the window is mapped
        !          1323:         * (even if the size didn't change, something else might have
        !          1324:         * changed in the menu, such as a label or accelerator).  The
        !          1325:         * resize will force a redisplay above.
        !          1326:         */
        !          1327: 
        !          1328:        EventuallyRedrawPieMenu(menuPtr, -1);
        !          1329:     }
        !          1330: 
        !          1331:     menuPtr->flags &= ~RESIZE_PENDING;
        !          1332: }
        !          1333: 
        !          1334: /*
        !          1335:  *----------------------------------------------------------------------
        !          1336:  *
        !          1337:  * DisplayPieMenu --
        !          1338:  *
        !          1339:  *     This procedure is invoked to display a pie menu widget.
        !          1340:  *
        !          1341:  * Results:
        !          1342:  *     None.
        !          1343:  *
        !          1344:  * Side effects:
        !          1345:  *     Commands are output to X to display the pie menu in its
        !          1346:  *     current mode.
        !          1347:  *
        !          1348:  *----------------------------------------------------------------------
        !          1349:  */
        !          1350: 
        !          1351: static void
        !          1352: DisplayPieMenu(clientData)
        !          1353:     ClientData clientData;     /* Information about widget. */
        !          1354: {
        !          1355:     register PieMenu *menuPtr = (PieMenu *) clientData;
        !          1356:     register Tk_Window tkwin = menuPtr->tkwin;
        !          1357:     XFontStruct *fontPtr;
        !          1358:     int index;
        !          1359: 
        !          1360:     menuPtr->flags &= ~REDRAW_PENDING;
        !          1361:     if ((menuPtr->tkwin == NULL) || !Tk_IsMapped(menuPtr->tkwin)) {
        !          1362:        return;
        !          1363:     }
        !          1364: 
        !          1365:     if (menuPtr->titlefontPtr != NULL) {
        !          1366:        fontPtr = menuPtr->titlefontPtr;
        !          1367:     } else {
        !          1368:        fontPtr = menuPtr->fontPtr;
        !          1369:     }
        !          1370: 
        !          1371:     if (menuPtr->titleLength != 0) {
        !          1372:       Tk_Draw3DRectangle(Tk_Display(tkwin), Tk_WindowId(tkwin),
        !          1373:                         menuPtr->border,
        !          1374:                         menuPtr->borderWidth, menuPtr->borderWidth,
        !          1375:                         Tk_Width(tkwin) - 2*menuPtr->borderWidth,
        !          1376:                         menuPtr->title_height + 2*menuPtr->borderWidth,
        !          1377:                         menuPtr->borderWidth, TK_RELIEF_RAISED);
        !          1378: 
        !          1379:       TkDisplayChars(Tk_Display(tkwin), Tk_WindowId(tkwin), menuPtr->textGC,
        !          1380:                     fontPtr, menuPtr->title, menuPtr->titleLength,
        !          1381:                     menuPtr->title_x, menuPtr->title_y,
        !          1382:                     TK_NEWLINES_NOT_SPECIAL);
        !          1383:     }
        !          1384: 
        !          1385:     if (menuPtr->segments) { 
        !          1386:       XSetLineAttributes(Tk_Display(tkwin), menuPtr->textGC,
        !          1387:                         0, LineSolid, CapButt, JoinMiter);
        !          1388:       XDrawSegments(Tk_Display(tkwin), Tk_WindowId(tkwin),
        !          1389:                    menuPtr->textGC, menuPtr->segments, menuPtr->numEntries);
        !          1390:     }
        !          1391:     
        !          1392:     Tk_Draw3DRectangle(Tk_Display(tkwin), Tk_WindowId(tkwin), menuPtr->border,
        !          1393:                       0, 0, Tk_Width(tkwin), Tk_Height(tkwin),
        !          1394:                       menuPtr->borderWidth, TK_RELIEF_RAISED);
        !          1395: 
        !          1396:     UpdatePieMenuEntries(menuPtr);
        !          1397: }
        !          1398: 
        !          1399: /*
        !          1400:  *----------------------------------------------------------------------
        !          1401:  *
        !          1402:  * UpdatePieMenu --
        !          1403:  *
        !          1404:  *     This procedure is invoked to update a pie menu widget.
        !          1405:  *
        !          1406:  * Results:
        !          1407:  *     None.
        !          1408:  *
        !          1409:  * Side effects:
        !          1410:  *     Commands are output to X to update the pie menu in its
        !          1411:  *     current mode.
        !          1412:  *
        !          1413:  *----------------------------------------------------------------------
        !          1414:  */
        !          1415: 
        !          1416: static void
        !          1417: UpdatePieMenu(clientData)
        !          1418:     ClientData clientData;     /* Information about widget. */
        !          1419: {
        !          1420:     register PieMenu *menuPtr = (PieMenu *) clientData;
        !          1421: 
        !          1422:     menuPtr->flags &= ~UPDATE_PENDING;
        !          1423:     if ((menuPtr->tkwin == NULL) || !Tk_IsMapped(menuPtr->tkwin)) {
        !          1424:        return;
        !          1425:     }
        !          1426: 
        !          1427:     UpdatePieMenuEntries(menuPtr);
        !          1428: }
        !          1429: 
        !          1430: 
        !          1431: UpdatePieMenuEntries(menuPtr)
        !          1432:     PieMenu *menuPtr;
        !          1433: {
        !          1434:     register PieMenuEntry *mePtr;
        !          1435:     register Tk_Window tkwin = menuPtr->tkwin;
        !          1436:     XFontStruct *fontPtr;
        !          1437:     int index;
        !          1438:     GC gc;
        !          1439: 
        !          1440:     for (index = 0; index < menuPtr->numEntries; index++) {
        !          1441:        mePtr = menuPtr->entries[index];
        !          1442:        if (!(mePtr->flags & ENTRY_NEEDS_REDISPLAY)) {
        !          1443:            continue;
        !          1444:        }
        !          1445:        mePtr->flags &= ~ENTRY_NEEDS_REDISPLAY;
        !          1446: 
        !          1447:        /*
        !          1448:         * Background.
        !          1449:         */
        !          1450: 
        !          1451:        Tk_Fill3DRectangle(Tk_Display(tkwin), Tk_WindowId(tkwin),
        !          1452:                           ((mePtr->activeBorder != NULL)
        !          1453:                              ? mePtr->activeBorder
        !          1454:                              : menuPtr->activeBorder),
        !          1455:                           mePtr->x, mePtr->y,
        !          1456:                           mePtr->width, mePtr->height,
        !          1457:                           menuPtr->activeBorderWidth,
        !          1458:                           ((index == menuPtr->active)
        !          1459:                              ? TK_RELIEF_SUNKEN
        !          1460:                              : ((HaveShape && menuPtr->shaped)
        !          1461:                                   ? TK_RELIEF_RAISED
        !          1462:                                   : TK_RELIEF_FLAT)));
        !          1463: 
        !          1464:        gc = mePtr->textGC;
        !          1465:        if (gc == NULL) {
        !          1466:            gc = menuPtr->textGC;
        !          1467:        }
        !          1468: 
        !          1469:        /*
        !          1470:         * Draw label or bitmap for entry.
        !          1471:         */
        !          1472: 
        !          1473:        fontPtr = mePtr->fontPtr;
        !          1474:        if (fontPtr == NULL) {
        !          1475:            fontPtr = menuPtr->fontPtr;
        !          1476:        }
        !          1477:        if (mePtr->bitmap != None) {
        !          1478:            unsigned int width, height;
        !          1479: 
        !          1480:            Tk_SizeOfPixmap(mePtr->bitmap, &width, &height);
        !          1481:             XCopyArea(Tk_Display(tkwin), mePtr->bitmap, Tk_WindowId(tkwin),
        !          1482:                      gc, 0, 0, width, height,
        !          1483:                      mePtr->label_x, mePtr->label_y);
        !          1484:        } else {
        !          1485:            if (mePtr->label != NULL) {
        !          1486:                TkDisplayChars(Tk_Display(tkwin), Tk_WindowId(tkwin), gc,
        !          1487:                               fontPtr, mePtr->label, mePtr->labelLength,
        !          1488:                               mePtr->label_x, mePtr->label_y,
        !          1489:                               TK_NEWLINES_NOT_SPECIAL);
        !          1490:            }
        !          1491:        }
        !          1492:     }
        !          1493: }
        !          1494: 
        !          1495: /*
        !          1496:  *--------------------------------------------------------------
        !          1497:  *
        !          1498:  * GetPieMenuIndex --
        !          1499:  *
        !          1500:  *     Parse a textual index into a pie menu and return the numerical
        !          1501:  *     index of the indicated entry.
        !          1502:  *
        !          1503:  * Results:
        !          1504:  *     A standard Tcl result.  If all went well, then *indexPtr is
        !          1505:  *     filled in with the entry index corresponding to string
        !          1506:  *     (ranges from -1 to the number of entries in the pie menu minus
        !          1507:  *     one).  Otherwise an error message is left in interp->result.
        !          1508:  *
        !          1509:  * Side effects:
        !          1510:  *     None.
        !          1511:  *
        !          1512:  *--------------------------------------------------------------
        !          1513:  */
        !          1514: 
        !          1515: static int
        !          1516: GetPieMenuIndex(interp, menuPtr, string, indexPtr)
        !          1517:     Tcl_Interp *interp;                /* For error messages. */
        !          1518:     PieMenu *menuPtr;          /* Menu for which the index is being
        !          1519:                                 * specified. */
        !          1520:     char *string;              /* Specification of an entry in menu.  See
        !          1521:                                 * manual entry for valid .*/
        !          1522:     int *indexPtr;             /* Where to store converted relief. */
        !          1523: {
        !          1524:     int i, y;
        !          1525: 
        !          1526:     if ((string[0] == 'a') && (strcmp(string, "active") == 0)) {
        !          1527:        *indexPtr = menuPtr->active;
        !          1528:        return TCL_OK;
        !          1529:     }
        !          1530: 
        !          1531:     if ((string[0] == 'l') && (strcmp(string, "last") == 0)) {
        !          1532:        *indexPtr = menuPtr->numEntries-1;
        !          1533:        return TCL_OK;
        !          1534:     }
        !          1535: 
        !          1536:     if ((string[0] == 'n') && (strcmp(string, "none") == 0)) {
        !          1537:        *indexPtr = -1;
        !          1538:        return TCL_OK;
        !          1539:     }
        !          1540: 
        !          1541:     if (string[0] == '@') {
        !          1542:         char xstr[32], ystr[32];
        !          1543:         int x, y;
        !          1544: 
        !          1545:        if ((sscanf(&string[1], "%31[^,],%31[^,]", xstr, ystr) == 2) &&
        !          1546:            (Tcl_GetInt(interp, xstr,  &x) == TCL_OK) &&
        !          1547:            (Tcl_GetInt(interp, ystr,  &y) == TCL_OK)) {
        !          1548:            *indexPtr = CalcPieMenuItem(menuPtr, x, y);
        !          1549:            return TCL_OK;
        !          1550:        } else {
        !          1551:            Tcl_SetResult(interp, (char *) NULL, TCL_STATIC);
        !          1552:        }
        !          1553:     }
        !          1554: 
        !          1555:     if (isdigit(string[0])) {
        !          1556:        if (Tcl_GetInt(interp, string,  &i) == TCL_OK) {
        !          1557:            if ((i < menuPtr->numEntries) && (i >= 0)) {
        !          1558:                *indexPtr = i;
        !          1559:                return TCL_OK;
        !          1560:            }
        !          1561:        } else {
        !          1562:            Tcl_SetResult(interp, (char *) NULL, TCL_STATIC);
        !          1563:        }
        !          1564:     }
        !          1565: 
        !          1566:     for (i = 0; i < menuPtr->numEntries; i++) {
        !          1567:        char *label;
        !          1568: 
        !          1569:        label = menuPtr->entries[i]->label;
        !          1570:        if ((label != NULL)
        !          1571:                && (Tcl_StringMatch(menuPtr->entries[i]->label, string))) {
        !          1572:            *indexPtr = i;
        !          1573:            return TCL_OK;
        !          1574:        }
        !          1575:     }
        !          1576: 
        !          1577:     Tcl_AppendResult(interp, "bad menu entry index \"",
        !          1578:                     string, "\"", (char *) NULL);
        !          1579:     return TCL_ERROR;
        !          1580: }
        !          1581: 
        !          1582: /*
        !          1583:  *--------------------------------------------------------------
        !          1584:  *
        !          1585:  * PieMenuEventProc --
        !          1586:  *
        !          1587:  *     This procedure is invoked by the Tk dispatcher for various
        !          1588:  *     events on pie menus.
        !          1589:  *
        !          1590:  * Results:
        !          1591:  *     None.
        !          1592:  *
        !          1593:  * Side effects:
        !          1594:  *     When the window gets deleted, internal structures get
        !          1595:  *     cleaned up.  When it gets exposed, it is redisplayed.
        !          1596:  *
        !          1597:  *--------------------------------------------------------------
        !          1598:  */
        !          1599: 
        !          1600: static void
        !          1601: PieMenuEventProc(clientData, eventPtr)
        !          1602:     ClientData clientData;     /* Information about window. */
        !          1603:     XEvent *eventPtr;          /* Information about event. */
        !          1604: {
        !          1605:     PieMenu *menuPtr = (PieMenu *) clientData;
        !          1606:     switch (eventPtr->type) {
        !          1607:     case Expose:
        !          1608:        if (eventPtr->xexpose.count == 0) {
        !          1609:            EventuallyRedrawPieMenu(menuPtr, -1);
        !          1610:        }
        !          1611:        break;
        !          1612:     case DestroyNotify:
        !          1613:        Tcl_DeleteCommand(menuPtr->interp, Tk_PathName(menuPtr->tkwin));
        !          1614: 
        !          1615:        /*
        !          1616:         * Careful!  Must delete the event-sharing information here
        !          1617:         * rather than in DestroyPieMenu.  By the time that procedure
        !          1618:         * is called the tkwin may have been reused, resulting in some
        !          1619:         * other window accidentally being cut off from shared events.
        !          1620:         */
        !          1621: 
        !          1622:        Tk_UnshareEvents(menuPtr->tkwin, menuPtr->group);
        !          1623:        menuPtr->tkwin = NULL;
        !          1624:        if (menuPtr->flags & REDRAW_PENDING) {
        !          1625:            Tk_CancelIdleCall(DisplayPieMenu, (ClientData) menuPtr);
        !          1626:        }
        !          1627:        if (menuPtr->flags & UPDATE_PENDING) {
        !          1628:            Tk_CancelIdleCall(UpdatePieMenu, (ClientData) menuPtr);
        !          1629:        }
        !          1630:        if (menuPtr->flags & RESIZE_PENDING) {
        !          1631:            Tk_CancelIdleCall(ComputePieMenuGeometry, (ClientData) menuPtr);
        !          1632:        }
        !          1633:        if (menuPtr->flags & POPUP_PENDING) {
        !          1634:            Tk_CancelIdleCall(PopupPieMenu, (ClientData) menuPtr);
        !          1635:        }
        !          1636:        Tk_EventuallyFree((ClientData) menuPtr, DestroyPieMenu);
        !          1637:        break;
        !          1638:     case MotionNotify:
        !          1639:        break;
        !          1640:     case ButtonPress:
        !          1641:        break;
        !          1642:     case ButtonRelease:
        !          1643:        break;
        !          1644:     }
        !          1645: }
        !          1646: 
        !          1647: 
        !          1648: 
        !          1649: /*
        !          1650:  *----------------------------------------------------------------------
        !          1651:  *
        !          1652:  * EventuallyRedrawPieMenu --
        !          1653:  *
        !          1654:  *     Arrange for an entry of a pie menu, or the whole pie menu, 
        !          1655:  *     to be redisplayed at some point in the future.
        !          1656:  *
        !          1657:  * Results:
        !          1658:  *     None.
        !          1659:  *
        !          1660:  * Side effects:
        !          1661:  *     A when-idle hander is scheduled to do the redisplay, if there
        !          1662:  *     isn't one already scheduled.
        !          1663:  *
        !          1664:  *----------------------------------------------------------------------
        !          1665:  */
        !          1666: 
        !          1667: static void
        !          1668: EventuallyRedrawPieMenu(menuPtr, index)
        !          1669:     register PieMenu *menuPtr; /* Information about menu to redraw. */
        !          1670:     int index;                 /* Which entry to redraw.  If -1, then
        !          1671:                                 * all the entries in the menu are redrawn. */
        !          1672: {
        !          1673:     if (menuPtr->tkwin == NULL) {
        !          1674:        return;
        !          1675:     }
        !          1676:     if (index != -1) {
        !          1677:        menuPtr->entries[index]->flags |= ENTRY_NEEDS_REDISPLAY;
        !          1678:     } else {
        !          1679:        for (index = 0; index < menuPtr->numEntries; index++) {
        !          1680:            menuPtr->entries[index]->flags |= ENTRY_NEEDS_REDISPLAY;
        !          1681:        }
        !          1682:        index = -1;
        !          1683:     }
        !          1684:     if ((menuPtr->tkwin == NULL) || !Tk_IsMapped(menuPtr->tkwin)
        !          1685:            || (menuPtr->flags & REDRAW_PENDING)) {
        !          1686:        return;
        !          1687:     }
        !          1688: 
        !          1689:     if (index == -1) {
        !          1690:        if (menuPtr->flags & UPDATE_PENDING) {
        !          1691:            Tk_CancelIdleCall(UpdatePieMenu, (ClientData) menuPtr);
        !          1692:        }
        !          1693:        Tk_DoWhenIdle(DisplayPieMenu, (ClientData) menuPtr);
        !          1694:        menuPtr->flags |= REDRAW_PENDING;
        !          1695:     } else {
        !          1696:        Tk_DoWhenIdle(UpdatePieMenu, (ClientData) menuPtr);
        !          1697:        menuPtr->flags |= UPDATE_PENDING;
        !          1698:     }
        !          1699: }
        !          1700: 
        !          1701: 
        !          1702: static void
        !          1703: PopupPieMenu(clientData)
        !          1704:     ClientData clientData;     /* Information about widget. */
        !          1705: {
        !          1706:   register PieMenu *menuPtr = (PieMenu *) clientData;
        !          1707: 
        !          1708:   NeverPopupPieMenu(menuPtr);
        !          1709: 
        !          1710:   if (Tk_IsMapped(menuPtr->tkwin)) {
        !          1711:     return;
        !          1712:   }
        !          1713: 
        !          1714:   ShapePieMenu(menuPtr);
        !          1715:   Tk_MapWindow(menuPtr->tkwin);
        !          1716: }
        !          1717: 
        !          1718: 
        !          1719: static void
        !          1720: NowPopupPieMenu(menuPtr)
        !          1721:     register PieMenu *menuPtr;
        !          1722: {
        !          1723:   PopupPieMenu((ClientData)menuPtr);
        !          1724: }
        !          1725: 
        !          1726: 
        !          1727: static void
        !          1728: NeverPopupPieMenu(menuPtr)
        !          1729:     register PieMenu *menuPtr;
        !          1730: {
        !          1731:   if (menuPtr->flags & POPUP_PENDING) {
        !          1732:     Tk_DeleteTimerHandler(menuPtr->popup_timer_token);
        !          1733:     menuPtr->popup_timer_token = 0;
        !          1734:     menuPtr->flags &= ~POPUP_PENDING;
        !          1735:   }
        !          1736: }
        !          1737: 
        !          1738: 
        !          1739: static void
        !          1740: EventuallyPopupPieMenu(menuPtr)
        !          1741:     register PieMenu *menuPtr;
        !          1742: {
        !          1743:   NeverPopupPieMenu(menuPtr);
        !          1744: 
        !          1745:   if (Tk_IsMapped(menuPtr->tkwin)) {
        !          1746:     return;
        !          1747:   }
        !          1748: 
        !          1749:   menuPtr->popup_timer_token =
        !          1750:     Tk_CreateTimerHandler(menuPtr->popup_delay,
        !          1751:                          PopupPieMenu, (ClientData) menuPtr);
        !          1752:   menuPtr->flags |= POPUP_PENDING;
        !          1753: }
        !          1754: 
        !          1755: 
        !          1756: static void
        !          1757: DeferPopupPieMenu(menuPtr)
        !          1758:     register PieMenu *menuPtr;
        !          1759: {
        !          1760:   if (menuPtr->flags & POPUP_PENDING) {
        !          1761:     EventuallyPopupPieMenu(menuPtr);
        !          1762:   }
        !          1763: }
        !          1764: 
        !          1765: 
        !          1766: 
        !          1767: /*
        !          1768:  *--------------------------------------------------------------
        !          1769:  *
        !          1770:  * UnpostSubPieMenu --
        !          1771:  *
        !          1772:  *     This procedure unposts any submenu.
        !          1773:  *
        !          1774:  * Results:
        !          1775:  *     A standard Tcl return result.  Errors may occur in the
        !          1776:  *     Tcl commands generated to unpost submenus.
        !          1777:  *
        !          1778:  * Side effects:
        !          1779:  *     If there is already a submenu posted, it is unposted.
        !          1780:  *
        !          1781:  *--------------------------------------------------------------
        !          1782:  */
        !          1783: 
        !          1784: static int
        !          1785: UnpostSubPieMenu(interp, menuPtr)
        !          1786:     Tcl_Interp *interp;                /* Used for invoking sub-commands and
        !          1787:                                 * reporting errors. */
        !          1788:     register PieMenu *menuPtr; /* Information about menu as a whole. */
        !          1789: {
        !          1790:     char string[30];
        !          1791:     int result, x, y, win_x, win_y;
        !          1792:     unsigned int key_buttons;
        !          1793:     Window root, child;
        !          1794: 
        !          1795:     if (menuPtr->postedPie == NULL) {
        !          1796:        return TCL_OK;
        !          1797:     }
        !          1798: 
        !          1799:     result = Tcl_VarEval(interp, menuPtr->postedPie->name,
        !          1800:                         " unpost", (char *) NULL);
        !          1801:     menuPtr->postedPie = NULL;
        !          1802: 
        !          1803:     return result;
        !          1804: }
        !          1805: 
        !          1806: /*
        !          1807:  *----------------------------------------------------------------------
        !          1808:  *
        !          1809:  * ActivatePieMenuEntry --
        !          1810:  *
        !          1811:  *     This procedure is invoked to make a particular pie menu 
        !          1812:  *     entry the active one, deactivating any other entry that 
        !          1813:  *     might currently be active.
        !          1814:  *
        !          1815:  * Results:
        !          1816:  *     The return value is a standard Tcl result (errors can occur
        !          1817:  *     while posting and unposting submenus).
        !          1818:  *
        !          1819:  * Side effects:
        !          1820:  *     Pie menu entries get redisplayed, and the active entry 
        !          1821:  *     changes.  Submenus may get posted and unposted.
        !          1822:  *
        !          1823:  *----------------------------------------------------------------------
        !          1824:  */
        !          1825: 
        !          1826: static int
        !          1827: ActivatePieMenuEntry(menuPtr, index, preview)
        !          1828:     register PieMenu *menuPtr;         /* Menu in which to activate. */
        !          1829:     int index;                         /* Index of entry to activate, or
        !          1830:                                         * -1 to deactivate all entries. */
        !          1831:     int preview;                       /* 1 to execute previewer */
        !          1832: {
        !          1833:     register PieMenuEntry *mePtr;
        !          1834:     int result = TCL_OK;
        !          1835: 
        !          1836:     if (menuPtr->active >= 0) {
        !          1837:        mePtr = menuPtr->entries[menuPtr->active];
        !          1838: 
        !          1839:        EventuallyRedrawPieMenu(menuPtr, menuPtr->active);
        !          1840:     }
        !          1841:     menuPtr->active = index;
        !          1842:     if (index >= 0) {
        !          1843:        mePtr = menuPtr->entries[index];
        !          1844:        EventuallyRedrawPieMenu(menuPtr, index);
        !          1845:        if (preview) {
        !          1846:          Tk_Preserve((ClientData) mePtr);
        !          1847:          if (mePtr->preview != NULL) {
        !          1848:              result = Tcl_GlobalEval(menuPtr->interp, mePtr->preview);
        !          1849:          }
        !          1850:          Tk_Release((ClientData) mePtr);
        !          1851:        }
        !          1852:     } else {
        !          1853: /* We're doing this in tcl these days, for finer control. */
        !          1854: #if 0
        !          1855:       if (preview && menuPtr->preview) {
        !          1856:            result = Tcl_GlobalEval(menuPtr->interp, menuPtr->preview);
        !          1857:       }
        !          1858: #endif
        !          1859:     }
        !          1860:     return result;
        !          1861: }
        !          1862: 
        !          1863: 
        !          1864: /*
        !          1865:  * This pie menu tracking code determines the slice the cursor 
        !          1866:  * is in by representing slice edge angles as (quadrant, slope) 
        !          1867:  * pairs that can be quickly computed and compared. 
        !          1868:  *
        !          1869:  * The slope is defined such that it is greater than or equal to zero,
        !          1870:  * less than infinity, and increasing counter-clockwise around the menu. 
        !          1871:  * Each of the four quadrants encompasses one range of slope.
        !          1872:  *
        !          1873:  *                 Y
        !          1874:  *               ^
        !          1875:  *               |     x>0, y>=0
        !          1876:  *  x<=0, y>0 <--+       y/x
        !          1877:  *    -x/y       |        ^
        !          1878:  *        quad 1 | quad 0 |     X
        !          1879:  * -----+--------+--------+----> 
        !          1880:  *      | quad 2 | quad 3
        !          1881:  *      V        |      -x/y
        !          1882:  *   x<0, y<=0   +--> x>=0, y<0
        !          1883:  *     y/x       |
        !          1884:  *               |
        !          1885:  * 
        !          1886:  * The quadrants and slopes of the item edges are all precalculated,
        !          1887:  * during menu layout.
        !          1888:  * The quadrant and slope of the cursor must be calculated frequently
        !          1889:  * during menu tracking, so we just calculate the numerator and
        !          1890:  * denominator of the slope, and avoid an unnecessary division.
        !          1891:  * Instead of calculating "slope = numerator / denominator" then
        !          1892:  * testing "slope < it->slope", every time the cursor moves, we can
        !          1893:  * just test "numerator < (denominator * it->slope)".
        !          1894:  *
        !          1895:  * This algorithm works in a right-side-up coordinate space, but the final
        !          1896:  * results are tranformed into X-windows's up-side-down coordinate system 
        !          1897:  * by subtracting the y values from the window height. 
        !          1898:  */
        !          1899: 
        !          1900: 
        !          1901: #define CALC_QUADRANT_SLOPE(x, y, quadrant, numerator, denominator) \
        !          1902:     if ((y) > 0) (quadrant) = ((x) > 0 ? 0 : 1); \
        !          1903:     else if ((y) < 0) (quadrant) = ((x) < 0 ? 2 : 3); \
        !          1904:     else (quadrant) = ((x) > 0 ? 0 : 2); \
        !          1905:     if ((quadrant) & 1) { \
        !          1906:        (numerator) = ABS((x)); (denominator) = ABS((y)); \
        !          1907:     } else { \
        !          1908:        (numerator) = ABS((y)); (denominator) = ABS((x)); \
        !          1909:     }
        !          1910: 
        !          1911: 
        !          1912: int
        !          1913: CalcPieMenuItem(menu, x, y)
        !          1914:   PieMenu *menu;
        !          1915:   int x, y;
        !          1916: {
        !          1917:   register PieMenuEntry *it, *last_it;
        !          1918:   int i, j, order, quadrant;
        !          1919:   int numerator, denominator;
        !          1920:   int first, last_i, last_order;
        !          1921:   
        !          1922:   /*
        !          1923:    * Translate x and y from root window coordinates so they are 
        !          1924:    * relative to the menu center, in right side up coordinates.
        !          1925:    */
        !          1926:   
        !          1927:   menu->dx = x = (x - menu->root_x) + 1;
        !          1928:   menu->dy = y = (menu->root_y - y) - 1;
        !          1929:   
        !          1930:   /*
        !          1931:    * If there are no menu items,
        !          1932:    * or we are within the inactive region in the menu center,
        !          1933:    * then there is no item selected.
        !          1934:    */
        !          1935:   if ((menu->numEntries == 0) ||
        !          1936:       ((x * x) + (y * y) <
        !          1937:        (menu->inactive_radius * menu->inactive_radius))) {
        !          1938:     return(-1);
        !          1939:   }
        !          1940:   
        !          1941:   /*
        !          1942:    * If there's only one item, then that must be it. 
        !          1943:    */
        !          1944:   if (menu->numEntries == 1) {
        !          1945:     return(0);
        !          1946:   }
        !          1947:   
        !          1948:   /*
        !          1949:    * Calculate the quadrant, slope numerator, and slope denominator of
        !          1950:    * the cursor slope, to be used for comparisons.
        !          1951:    */
        !          1952:   CALC_QUADRANT_SLOPE(x, y, quadrant, numerator, denominator);
        !          1953:   
        !          1954:   /*
        !          1955:    * In most cases, during cursor tracking, the menu item that the
        !          1956:    * cursor is over will be the same as it was before (almost all
        !          1957:    * of the time), or one of the neighboring items (most of the
        !          1958:    * rest of the time). So we check those items first. But to keep
        !          1959:    * things simple, instead of actually checking the items in order of
        !          1960:    * frequency (the current, the two neighbors, then the rest), we just
        !          1961:    * start our loop around the menu items at the item *before* the
        !          1962:    * last selected menu item, so we still check the three most common
        !          1963:    * cases first (neighbor, current, neighbor, rest), without having 
        !          1964:    * to complicate the code with special cases. Another strategy, that
        !          1965:    * might be good for menus with ridiculously many items, would be
        !          1966:    * [to check the current item first, then the two neighbors, then]
        !          1967:    * to do a binary search of the menu items (since they are ordered).
        !          1968:    * But that's more complicated and you shouldn't have that many menu
        !          1969:    * items anyway.
        !          1970:    */
        !          1971:   
        !          1972:   /*
        !          1973:    * Start at the item before current one.
        !          1974:    */
        !          1975:   first = menu->active - 1;
        !          1976:   if (first < 0)
        !          1977:     first = menu->numEntries - 1;
        !          1978:   
        !          1979:   /*
        !          1980:    * Initialize last_order such that we will go through the loop
        !          1981:    * at least once, validating last_i, last_order, and last_it for
        !          1982:    * the next time through the loop.
        !          1983:    */
        !          1984:   last_i = last_order = -1;
        !          1985:   i = first;
        !          1986:   
        !          1987:   it = menu->entries[i];
        !          1988:   
        !          1989:   while (1) {
        !          1990: 
        !          1991: /* Legend: c = cursor, e = edge
        !          1992:    <cursor quad>,<edge quad>
        !          1993:          quad 1 | quad 0
        !          1994:          -------+-------
        !          1995:          quad 2 | quad 3
        !          1996: */
        !          1997: 
        !          1998:     /* Set order = 1, if shortest direction from edge to cursor is ccw */
        !          1999:     switch ((quadrant - it->quadrant) & 3) {
        !          2000: 
        !          2001: case 0: /*
        !          2002:                 0,0     1,1     2,2     3,3
        !          2003:                  |ce   ce|       |       |     
        !          2004:                --+--   --+--   --+--   --+--   
        !          2005:                  |       |     ce|       |ce
        !          2006:        */
        !          2007:       /* slope >= it->slope */
        !          2008:       order = ((float)numerator >= (float)(denominator * it->slope));
        !          2009:       break;
        !          2010: 
        !          2011: case 1: /*
        !          2012:                 1,0     2,1     3,2     0,3
        !          2013:                 c|e     e|       |       |c
        !          2014:                --+--   --+--   --+--   --+--   
        !          2015:                  |      c|      e|c      |e
        !          2016:        */
        !          2017:       order = 1;
        !          2018:       break;
        !          2019: 
        !          2020: case 2: /*
        !          2021:                 2,0     3,1     0,2     1,3
        !          2022:                  |e     e|       |c     c|
        !          2023:                --+--   --+--   --+--   --+--   
        !          2024:                 c|       |c     e|       |e
        !          2025:        */
        !          2026:       /* slope < it->slope */
        !          2027:       order = ((float)numerator < (float)(denominator * it->slope));
        !          2028:       break;
        !          2029: 
        !          2030: case 3: /*
        !          2031:                 3,0     0,1     1,2     2,3
        !          2032:                  |e     e|c     c|       |
        !          2033:                --+--   --+--   --+--   --+--   
        !          2034:                  |c      |      e|      c|e
        !          2035:        */
        !          2036:       order = 0;
        !          2037:       break;
        !          2038:     }
        !          2039: 
        !          2040:     /*
        !          2041:      * If we were counter-clockwise of the last leading edge,
        !          2042:      * and we're clockwise of this leading edge,
        !          2043:      * then we were in the last menu item.
        !          2044:      * (Note: first time through this loop last_order = -1 so we'll
        !          2045:      * go back through the loop at least once, after validating
        !          2046:      * last_order, last_i, and last_it.)
        !          2047:      */
        !          2048:     if ((last_order == 1) && (order == 0)) {
        !          2049:       return(last_i);
        !          2050:     }
        !          2051:     last_order = order;
        !          2052: 
        !          2053:     /*
        !          2054:      * Remember this menu item index, and move on to the next one
        !          2055:      * counter-clockwise around the circle.
        !          2056:      */
        !          2057:     last_i = i; last_it = it;
        !          2058:     if (++i >= menu->numEntries) {
        !          2059:       i = 0;
        !          2060:     }
        !          2061:     it = menu->entries[i];
        !          2062: 
        !          2063:     /* 
        !          2064:      * If we've checked all the others, then that must have been it. 
        !          2065:      * This saves us from checking the leading edge of the first
        !          2066:      * item again (It's also insurance against layout bugs.)
        !          2067:      */
        !          2068:     if (i == first) {
        !          2069:       return(last_i);
        !          2070:     }
        !          2071:   }
        !          2072: }
        !          2073: 
        !          2074: 
        !          2075: LayoutPieMenu(menu)
        !          2076:   PieMenu *menu;
        !          2077: {
        !          2078:   int i;
        !          2079:   int total_slice, radius;
        !          2080:   int minx, miny, maxx, maxy;
        !          2081:   float angle;
        !          2082:   PieMenuEntry *it, *last;
        !          2083:   XFontStruct *font, *titlefont;
        !          2084: 
        !          2085:   /*
        !          2086:    * Calculate the sum of the menu item slice sizes.
        !          2087:    * Each menu item will get a (slice / total_slice) sized slice of the pie.
        !          2088:    */
        !          2089:   total_slice = 0;
        !          2090:   for (i = 0; i < menu->numEntries; i++) {
        !          2091:     total_slice += menu->entries[i]->slice;
        !          2092:   }
        !          2093: 
        !          2094:   if ((titlefont = menu->titlefontPtr) == NULL)
        !          2095:     titlefont = menu->fontPtr;
        !          2096: 
        !          2097:   /*
        !          2098:    * Calculate the subtend, angle, cosine, sine, quadrant, slope,
        !          2099:    * and size of each menu item.
        !          2100:    */
        !          2101:   angle = DEG_TO_RAD(menu->initial_angle);
        !          2102:   for (i = 0; i < menu->numEntries; i++) {
        !          2103:     register float edge_dx, edge_dy, numerator, denominator, twist;
        !          2104:     register int quadrant;
        !          2105: 
        !          2106:     it = menu->entries[i];
        !          2107:     if ((font = it->fontPtr) == NULL)
        !          2108:       font = menu->fontPtr;
        !          2109: 
        !          2110:     if (it->bitmap != None) {
        !          2111:       unsigned int bitmapWidth, bitmapHeight;
        !          2112: 
        !          2113:       Tk_SizeOfPixmap(it->bitmap, &bitmapWidth, &bitmapHeight);
        !          2114:       it->height = bitmapHeight;
        !          2115:       it->width = bitmapWidth;
        !          2116:     } else {
        !          2117:       it->height = font->ascent + font->descent;
        !          2118:       if (it->label != NULL) {
        !          2119:        (void) TkMeasureChars(font, it->label,
        !          2120:                              it->labelLength, 0, (int) 100000,
        !          2121:                              TK_NEWLINES_NOT_SPECIAL, &it->width);
        !          2122:       } else {
        !          2123:        it->width = 0;
        !          2124:       }
        !          2125:     }
        !          2126:     it->height += 2*menu->activeBorderWidth + 2;
        !          2127:     it->width += 2*menu->activeBorderWidth + 2;
        !          2128: 
        !          2129:     it->subtend = TWO_PI * it->slice / total_slice;
        !          2130:     twist = it->subtend / 2.0;
        !          2131:     if (i != 0) angle += twist;
        !          2132:     it->angle = angle;
        !          2133:     it->dx = cos(angle);
        !          2134:     it->dy = sin(angle);
        !          2135:     edge_dx = cos(angle - twist);
        !          2136:     edge_dy = sin(angle - twist);
        !          2137:     CALC_QUADRANT_SLOPE(edge_dx, edge_dy, quadrant, numerator, denominator);
        !          2138:     it->quadrant = quadrant;
        !          2139:     it->slope = (float)numerator / (float)denominator;
        !          2140:     angle += twist;
        !          2141:   }
        !          2142: 
        !          2143:   if ((radius = menu->fixed_radius) == 0) {
        !          2144:     radius = menu->min_radius;
        !          2145:     if (menu->numEntries > 1) {
        !          2146:       last = menu->entries[menu->numEntries - 1];
        !          2147:       for (i = 0; i < menu->numEntries; i++) {
        !          2148:        float dx, dy, ldx, ldy;
        !          2149:        int width, height, lwidth, lheight;
        !          2150: 
        !          2151:        it = menu->entries[i];
        !          2152: 
        !          2153:        dx = it->dx;  dy = it->dy;
        !          2154:        width = it->width;  height = it->height;
        !          2155:        ldx = last->dx;  ldy = last->dy;
        !          2156:        lwidth = last->width;  lheight = last->height;
        !          2157:        while (1) {
        !          2158:          register int x, y, lx, ly, 
        !          2159:                       x0max, y0max, x1min, y1min;
        !          2160: 
        !          2161:          x = dx * radius + it->x_offset;
        !          2162:          y = dy * radius + it->y_offset;
        !          2163:          lx = ldx * radius + last->x_offset;
        !          2164:          ly = ldy * radius + last->y_offset;
        !          2165: 
        !          2166:          /* Translate x y with respect to label size and position */
        !          2167:          if (ABS(x) <= 2) {
        !          2168:            x -= width/2;
        !          2169:            if (y < 0)
        !          2170:              y -= height;
        !          2171:          } else {
        !          2172:            if (x < 0)
        !          2173:              x -= width;
        !          2174:            y -= height/2;
        !          2175:          }
        !          2176: 
        !          2177:          if (ABS(lx) <= 2) {
        !          2178:            lx -= lwidth/2;
        !          2179:            if (ly < 0)
        !          2180:              ly -= lheight;
        !          2181:          } else {
        !          2182:            if (lx < 0)
        !          2183:              lx -= lwidth;
        !          2184:            ly -= lheight/2;
        !          2185:          }
        !          2186: 
        !          2187:          /* Do rects (x y width height) and (lx ly lwidth lheight) overlap? */
        !          2188:          x0max = x > lx ? x : lx;
        !          2189:          y0max = y > ly ? y : ly;
        !          2190:          x1min = x+width < lx+lwidth ? x+width : lx+lwidth;
        !          2191:          y1min = y+height < ly+lheight ? y+height : ly+lheight;
        !          2192:          if (!((x0max < x1min) &&
        !          2193:                (y0max < y1min))) { /* If they don't overlap */
        !          2194:            /* They are far enough out, so move on. */
        !          2195:            break;
        !          2196:          }
        !          2197:          /* Push the menu radius out a step and try again */
        !          2198:          radius++;
        !          2199:        }
        !          2200:        /* Loop on to next menu item */
        !          2201:        last = it;
        !          2202:       }
        !          2203:     }
        !          2204:     radius += menu->extra_radius;
        !          2205:   }
        !          2206:   menu->label_radius = radius;
        !          2207: 
        !          2208:   /* Finally position all the menu labels at the same radius.
        !          2209:      Figure out the bounding box of the labels. */
        !          2210:   minx = miny = maxx = maxy = 0;
        !          2211:   for (i = 0; i < menu->numEntries; i++) {
        !          2212:     it = menu->entries[i];
        !          2213: 
        !          2214:     it->x = radius * it->dx + it->x_offset;
        !          2215:     it->y = radius * it->dy + it->y_offset;
        !          2216: 
        !          2217:     /* Translate x y with respect to label size and position */
        !          2218:     if (ABS(it->x) <= 2) {
        !          2219:       it->x -= it->width/2;
        !          2220:       if (it->y < 0)
        !          2221:        it->y -= it->height;
        !          2222:     } else {
        !          2223:       if (it->x < 0)
        !          2224:        it->x -= it->width;
        !          2225:       it->y -= it->height/2;
        !          2226:     }
        !          2227: 
        !          2228:     it->label_x = it->x + menu->activeBorderWidth + 1;
        !          2229:     it->label_y = it->y - menu->activeBorderWidth - 1;
        !          2230:     if (it->bitmap == None) {
        !          2231:       it->label_y -= (it->fontPtr ? it->fontPtr : menu->fontPtr)->ascent;
        !          2232:     }
        !          2233: 
        !          2234:     if (it->x < minx) minx = it->x;
        !          2235:     if ((it->x + it->width) > maxx) maxx = (it->x + it->width);
        !          2236:     if (it->y < miny) miny = it->y;
        !          2237:     if ((it->y + it->height) > maxy) maxy = (it->y + it->height);
        !          2238:   }
        !          2239: 
        !          2240:   
        !          2241:   if (menu->titleLength != 0) {
        !          2242:     menu->title_height = titlefont->ascent + titlefont->descent + 2;
        !          2243:     (void) TkMeasureChars(titlefont, menu->title,
        !          2244:                          menu->titleLength, 0, (int) 100000,
        !          2245:                          TK_NEWLINES_NOT_SPECIAL, &menu->title_width);
        !          2246:     menu->title_width += 2;
        !          2247:     if (-(menu->title_width / 2) < minx)
        !          2248:       minx = -(menu->title_width / 2);
        !          2249:     if ((menu->title_width / 2) > maxx)
        !          2250:       maxx = (menu->title_width / 2);
        !          2251:     maxy += (2 * menu->borderWidth) + menu->title_height;
        !          2252:   } else {
        !          2253:     menu->title_width = menu->title_height = 0;
        !          2254:   }
        !          2255: 
        !          2256: 
        !          2257:   minx -= 2*menu->borderWidth;  miny -= 2*menu->borderWidth;
        !          2258:   maxx += 2*menu->borderWidth;  maxy += 2*menu->borderWidth;
        !          2259: 
        !          2260:   menu->center_x = -minx;
        !          2261:   menu->center_y = maxy; /* y flip */
        !          2262:   menu->width = maxx - minx;
        !          2263:   menu->height = maxy - miny;
        !          2264: 
        !          2265: /*  menu->title_x = (menu->width - menu->title_width) / 2 + 1; */
        !          2266:   menu->title_x = menu->center_x - menu->title_width/2 + 1;
        !          2267:   menu->title_y = 2*menu->borderWidth + titlefont->ascent + 1;
        !          2268: 
        !          2269:   /* Translate the menu items to the center of the menu, in X coordinates. */
        !          2270:   for (i = 0; i < menu->numEntries; i++) {
        !          2271:     it = menu->entries[i];
        !          2272:     it->x = menu->center_x + it->x;
        !          2273:     it->y = (menu->center_y - it->y) - it->height; /* y flip */
        !          2274:     it->label_x = menu->center_x + it->label_x;
        !          2275:     it->label_y = (menu->center_y - it->label_y) - it->height; /* y flip */
        !          2276:   }
        !          2277: 
        !          2278:   if (menu->segments != NULL) {
        !          2279:       ckfree((char *)menu->segments);
        !          2280:   }
        !          2281:   menu->segments = (XSegment *)
        !          2282:     ckalloc(menu->numEntries * sizeof(XSegment));
        !          2283: 
        !          2284:   if (menu->numEntries > 1) {
        !          2285:     XSegment *seg = menu->segments;
        !          2286: 
        !          2287:     angle = DEG_TO_RAD(menu->initial_angle) -
        !          2288:             (menu->entries[0]->subtend / 2.0);
        !          2289:     for (i = 0; i < menu->numEntries; i++) {
        !          2290:       it = menu->entries[i];
        !          2291:       seg->x1 = menu->center_x + (cos(angle) * menu->inactive_radius);
        !          2292:       seg->y1 = menu->center_y - (sin(angle) * menu->inactive_radius);
        !          2293:       seg->x2 = menu->center_x +
        !          2294:        (cos(angle) * (menu->label_radius - PIE_SPOKE_INSET));
        !          2295:       seg->y2 = menu->center_y -
        !          2296:        (sin(angle) * (menu->label_radius - PIE_SPOKE_INSET));
        !          2297:       seg++;
        !          2298:       angle += it->subtend;
        !          2299:     }
        !          2300:   }
        !          2301: }
        !          2302: 
        !          2303: 
        !          2304: static void
        !          2305: ShapePieMenu(menuPtr)
        !          2306: PieMenu *menuPtr;
        !          2307: {
        !          2308:   Display *dpy;
        !          2309:   Window win, shape;
        !          2310:   GC gc;
        !          2311:   XGCValues values;
        !          2312:   PieMenuEntry *it;
        !          2313:   int i;
        !          2314: 
        !          2315:   if (HaveShape == 0)
        !          2316:     return;
        !          2317: 
        !          2318:   if (menuPtr->shaped == 0) {
        !          2319:     return;
        !          2320:   }
        !          2321: 
        !          2322:   dpy = Tk_Display(menuPtr->tkwin);
        !          2323: 
        !          2324:   if (HaveShape == -1) {
        !          2325:     int t1, t2;
        !          2326:     if (XShapeQueryExtension(dpy, &t1, &t2)) {
        !          2327:       HaveShape = 1;
        !          2328:     } else {
        !          2329:       HaveShape = 0;
        !          2330:       return;
        !          2331:     }
        !          2332:   }
        !          2333: 
        !          2334:   Tk_MakeWindowExist(menuPtr->tkwin);
        !          2335:   win = Tk_WindowId(menuPtr->tkwin);
        !          2336: 
        !          2337:   shape = XCreatePixmap(dpy, RootWindowOfScreen(Tk_Screen(menuPtr->tkwin)),
        !          2338:                        menuPtr->width, menuPtr->height, 1);
        !          2339:   gc = XCreateGC(dpy, shape, 0, &values);
        !          2340: 
        !          2341: 
        !          2342:   XSetForeground(dpy, gc, 0);
        !          2343:   XFillRectangle(dpy, shape, gc, 0, 0, menuPtr->width, menuPtr->height);
        !          2344: 
        !          2345:   XSetForeground(dpy, gc, 1);
        !          2346:   if (menuPtr->titleLength != 0) {
        !          2347:     int bw = menuPtr->borderWidth;
        !          2348: 
        !          2349:     XFillRectangle(dpy, shape, gc, bw, bw, menuPtr->width - bw*2, menuPtr->title_height + bw*2);
        !          2350:   }
        !          2351: 
        !          2352:   for (i = 0; i < menuPtr->numEntries; i++) {
        !          2353:     it = menuPtr->entries[i];
        !          2354:     XFillRectangle(dpy, shape, gc, it->x, it->y, it->width, it->height);
        !          2355:   }
        !          2356: 
        !          2357:   XFreeGC(dpy, gc);
        !          2358:   XShapeCombineMask(dpy, win, ShapeBounding, 0, 0, shape, ShapeSet);
        !          2359: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.