![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to menu.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / new / X / xterm|
Return to menu.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / new / X / xterm |
1.1 ! root 1: /* ! 2: * $Source: /u1/X/xterm/RCS/menu.c,v $ ! 3: * $Header: menu.c,v 10.101 86/12/01 17:52:43 swick Rel $ ! 4: */ ! 5: ! 6: #ifdef MODEMENU ! 7: #include "X/Xlib.h" ! 8: #include "menu.h" ! 9: ! 10: #ifndef lint ! 11: static char sccs_id[] = "@(#)menu.c\tX10/6.6B\t12/26/86"; ! 12: #endif lint ! 13: ! 14: #define FALSE 0 ! 15: #define TRUE 1 ! 16: #define InvertPlane 1 ! 17: #define SetStateFlags(item) item->itemFlags = (item->itemFlags &\ ! 18: ~(itemStateMask | itemChanged)) |\ ! 19: ((item->itemFlags & itemSetMask) >>\ ! 20: itemSetMaskShift) ! 21: ! 22: ! 23: static short Check_MarkBits[] = { ! 24: 0x0100, 0x0180, 0x00c0, 0x0060, ! 25: 0x0031, 0x001b, 0x000e, 0x0004 ! 26: }; ! 27: static short Check_GrayBits[] = { ! 28: 0x0100, 0x0080, 0x0040, 0x0020, ! 29: 0x0011, 0x000a, 0x0004, 0x0000 ! 30: }; ! 31: static short Default_CursorBits[] = { ! 32: 0x0000, 0x0002, 0x0006, 0x000e, ! 33: 0x001e, 0x003e, 0x007e, 0x00fe, ! 34: 0x01fe, 0x003e, 0x0036, 0x0062, ! 35: 0x0060, 0x00c0, 0x00c0, 0x0000 ! 36: }; ! 37: static short Default_GrayBits[] = { ! 38: 0xaaaa, 0x5555, 0xaaaa, 0x5555, ! 39: 0xaaaa, 0x5555, 0xaaaa, 0x5555, ! 40: 0xaaaa, 0x5555, 0xaaaa, 0x5555, ! 41: 0xaaaa, 0x5555, 0xaaaa, 0x5555, ! 42: }; ! 43: static short Default_MaskBits[] = { ! 44: 0x0003, 0x0007, 0x000f, 0x001f, ! 45: 0x003f, 0x007f, 0x00ff, 0x01ff, ! 46: 0x03ff, 0x07ff, 0x007f, 0x00f7, ! 47: 0x00f3, 0x01e1, 0x01e0, 0x01c0 ! 48: }; ! 49: static char def_menu_font[] = "vtsingle"; ! 50: ! 51: Pixmap Gray_Tile; ! 52: Menu Menu_Default; ! 53: Cursor Menu_DefaultCursor; ! 54: char *Menu_DefaultFont; ! 55: FontInfo *Menu_DefaultFontInfo; ! 56: ! 57: /* ! 58: * AddMenuItem() adds a menu item to an existing menu, at the end of the ! 59: * list, which are number sequentially from zero. The menuitem index is ! 60: * return, or -1 if failed. ! 61: */ ! 62: ! 63: AddMenuItem(menu, text) ! 64: register Menu *menu; ! 65: register char *text; ! 66: { ! 67: register MenuItem *menuitem, **next; ! 68: register int i; ! 69: extern char *malloc(); ! 70: ! 71: if(!menu || !text || (menuitem = (MenuItem *)malloc(sizeof(MenuItem))) ! 72: == (MenuItem *)0) ! 73: return(-1); ! 74: bzero((char *)menuitem, sizeof(MenuItem)); ! 75: menuitem->itemText = text; ! 76: menuitem->itemTextLength = strlen(text); ! 77: for(i = 0, next = &menu->menuItems ; *next ; i++) ! 78: next = &(*next)->nextItem; ! 79: *next = menuitem; ! 80: menu->menuFlags |= menuChanged; ! 81: return(i); ! 82: } ! 83: ! 84: /* ! 85: * DisposeItem() releases the memory allocated for the given indexed ! 86: * menuitem. Nonzero is returned if an item was actual disposed of. ! 87: */ ! 88: DisposeItem(menu, i) ! 89: register Menu *menu; ! 90: register int i; ! 91: { ! 92: register MenuItem **next, **last, *menuitem; ! 93: ! 94: if(!menu || i < 0) ! 95: return(0); ! 96: next = &menu->menuItems; ! 97: do { ! 98: if(!*next) ! 99: return(0); ! 100: last = next; ! 101: next = &(*next)->nextItem; ! 102: } while(i-- > 0); ! 103: menuitem = *last; ! 104: *last = *next; ! 105: free(menuitem); ! 106: return(1); ! 107: } ! 108: ! 109: /* ! 110: * DisposeMenu() releases the memory allocated for the given menu. ! 111: */ ! 112: DisposeMenu(menu) ! 113: register Menu *menu; ! 114: { ! 115: static Unmap_Menu(); ! 116: ! 117: if(!menu) ! 118: return; ! 119: if(menu->menuFlags & menuMapped) ! 120: Unmap_Menu(menu); ! 121: while(DisposeItem(menu, 0)); ! 122: if(menu->menuWindow) ! 123: XDestroyWindow(menu->menuWindow); ! 124: if(menu->menuSaved) ! 125: XFreePixmap(menu->menuSaved); ! 126: free(menu); ! 127: } ! 128: ! 129: InitMenu(name) ! 130: register char *name; ! 131: { ! 132: register char *cp; ! 133: register Bitmap bit; ! 134: ! 135: /* ! 136: * If the gray tile hasn't been set up, do it now. ! 137: */ ! 138: if(!Gray_Tile) { ! 139: if(!(bit = XStoreBitmap(grayWidth, grayHeight, ! 140: Default_GrayBits))) ! 141: return; ! 142: Gray_Tile = XMakePixmap(bit, WhitePixel, BlackPixel); ! 143: XFreeBitmap(bit); ! 144: } ! 145: Menu_Default.menuFlags = menuChanged; ! 146: if((cp = XGetDefault(name, "MenuFreeze")) && strcmp(cp, "on") == 0) ! 147: Menu_Default.menuFlags |= menuFreeze; ! 148: if((cp = XGetDefault(name, "MenuSave")) && strcmp(cp, "on") == 0) ! 149: Menu_Default.menuFlags |= menuSaveMenu; ! 150: Menu_Default.menuInitialItem = -1; ! 151: Menu_Default.menuBorderWidth = (cp = XGetDefault(name, "MenuBorder")) ? ! 152: atoi(cp) : 2; ! 153: Menu_Default.menuItemPad = (cp = XGetDefault(name, "MenuPad")) ? ! 154: atoi(cp) : 3; ! 155: Menu_DefaultFont = (cp = XGetDefault(name, "MenuFont")) ? cp : ! 156: def_menu_font; ! 157: }; ! 158: ! 159: /* ! 160: * ItemFlags returns the state of item "n" of the menu. ! 161: */ ! 162: ItemFlags(menu, n) ! 163: register Menu *menu; ! 164: register int n; ! 165: { ! 166: register MenuItem *item; ! 167: ! 168: if(!menu || !menu->menuItems || n < 0) ! 169: return(-1); ! 170: for(item = menu->menuItems ; n > 0 ; n--) ! 171: if(!(item = item->nextItem)) ! 172: return(0); ! 173: return((item->itemFlags & itemSetMask) >> itemSetMaskShift); ! 174: } ! 175: ! 176: /* ! 177: * ItemText changes the text of item "n" of the menu. ! 178: */ ! 179: ItemText(menu, n, text) ! 180: register Menu *menu; ! 181: register int n; ! 182: char *text; ! 183: { ! 184: register MenuItem *item; ! 185: ! 186: if(!menu || !menu->menuItems || n < 0 || !text) ! 187: return(0); ! 188: for(item = menu->menuItems ; n > 0 ; n--) ! 189: if(!(item = item->nextItem)) ! 190: return(0); ! 191: item->itemText = text; ! 192: menu->menuFlags |= menuChanged; ! 193: return(1); ! 194: } ! 195: ! 196: /* ! 197: * NewMenu() returns a pointer to an initialized new Menu structure, or NULL ! 198: * if failed. ! 199: * ! 200: * The Menu structure _menuDefault contains the default menu settings. ! 201: */ ! 202: Menu *NewMenu(name, reverse) ! 203: char *name; ! 204: int reverse; ! 205: { ! 206: register Menu *menu; ! 207: register int fg, bg; ! 208: extern char *malloc(); ! 209: ! 210: /* ! 211: * If the GrayTile hasn't been defined, InitMenu() was never ! 212: * run, so exit. ! 213: */ ! 214: if(!Gray_Tile) ! 215: return((Menu *)0); ! 216: /* ! 217: * Allocate the memory for the menu structure. ! 218: */ ! 219: if((menu = (Menu *)malloc(sizeof(Menu))) == (Menu *)0) ! 220: return((Menu *)0); ! 221: /* ! 222: * Initialize to default values. ! 223: */ ! 224: *menu = Menu_Default; ! 225: /* ! 226: * If the menu font hasn't yet been gotten, go get it. ! 227: */ ! 228: if(!menu->menuFontInfo) { ! 229: if(!Menu_DefaultFontInfo && !(Menu_DefaultFontInfo = ! 230: XOpenFont(Menu_DefaultFont))) ! 231: return((Menu *)0); ! 232: menu->menuFontInfo = Menu_DefaultFontInfo; ! 233: } ! 234: /* ! 235: * If the menu cursor hasn't been given, make a default one. ! 236: */ ! 237: if(!menu->menuCursor) { ! 238: if(!Menu_DefaultCursor) { ! 239: if(reverse) { ! 240: fg = WhitePixel; ! 241: bg = BlackPixel; ! 242: } else { ! 243: fg = BlackPixel; ! 244: bg = WhitePixel; ! 245: } ! 246: if(!(Menu_DefaultCursor = ! 247: XCreateCursor(defaultCursorWidth, defaultCursorHeight, ! 248: Default_CursorBits, Default_MaskBits, defaultCursorX, ! 249: defaultCursorY, fg, bg, GXcopy))) ! 250: return((Menu *)0); ! 251: } ! 252: menu->menuCursor = Menu_DefaultCursor; ! 253: } ! 254: /* ! 255: * Initialze the default background and border pixmaps and foreground ! 256: * and background colors (black and white). ! 257: */ ! 258: if(reverse) { ! 259: menu->menuBgTile = BlackPixmap; ! 260: menu->menuFgColor = WhitePixel; ! 261: menu->menuBgColor = BlackPixel; ! 262: } else { ! 263: menu->menuBgTile = WhitePixmap; ! 264: menu->menuFgColor = BlackPixel; ! 265: menu->menuBgColor = WhitePixel; ! 266: } ! 267: /* ! 268: * Set the menu title. If name is NULL or is an empty string, no ! 269: * title will be displayed. ! 270: */ ! 271: if(name && *name) { ! 272: menu->menuTitleLength = strlen(menu->menuTitle = name); ! 273: menu->menuTitleWidth = XStringWidth(name, menu->menuFontInfo, ! 274: 0, 0); ! 275: menu->menuItemTop = menu->menuFontInfo->height + 2 * ! 276: menu->menuItemPad + 1; ! 277: } else ! 278: menu->menuTitleLength = menu->menuTitleWidth = ! 279: menu->menuItemTop = 0; ! 280: return(menu); ! 281: } ! 282: ! 283: /* ! 284: * SetItemCheck sets the check state of item "n" of the menu to "state". ! 285: */ ! 286: SetItemCheck(menu, n, state) ! 287: register Menu *menu; ! 288: register int n; ! 289: int state; ! 290: { ! 291: register MenuItem *item; ! 292: ! 293: if(!menu || !menu->menuItems || n < 0) ! 294: return(0); ! 295: for(item = menu->menuItems ; n > 0 ; n--) ! 296: if(!(item = item->nextItem)) ! 297: return(0); ! 298: if(state) ! 299: item->itemFlags |= itemSetChecked; ! 300: else ! 301: item->itemFlags &= ~itemSetChecked; ! 302: if(((item->itemFlags & itemSetMask) >> itemSetMaskShift) != ! 303: (item->itemFlags & itemStateMask)) { ! 304: item->itemFlags |= itemChanged; ! 305: menu->menuFlags |= menuItemChanged; ! 306: } else ! 307: item->itemFlags &= ~itemChanged; ! 308: return(1); ! 309: } ! 310: ! 311: /* ! 312: * SetItemDisable sets the disable state of item "n" of the menu to "state". ! 313: */ ! 314: SetItemDisable(menu, n, state) ! 315: register Menu *menu; ! 316: register int n; ! 317: int state; ! 318: { ! 319: register MenuItem *item; ! 320: ! 321: if(!menu || !menu->menuItems || n < 0) ! 322: return(0); ! 323: for(item = menu->menuItems ; n > 0 ; n--) ! 324: if(!(item = item->nextItem)) ! 325: return(0); ! 326: if(state) ! 327: item->itemFlags |= itemSetDisabled; ! 328: else ! 329: item->itemFlags &= ~itemSetDisabled; ! 330: if(((item->itemFlags & itemSetMask) >> itemSetMaskShift) != ! 331: (item->itemFlags & itemStateMask)) { ! 332: item->itemFlags |= itemChanged; ! 333: menu->menuFlags |= menuItemChanged; ! 334: } else ! 335: item->itemFlags &= ~itemChanged; ! 336: return(1); ! 337: } ! 338: ! 339: /* ! 340: * TrackMenu does most of the work of displaying the menu and tracking the ! 341: * mouse. ! 342: */ ! 343: TrackMenu(menu, event) ! 344: register Menu *menu; ! 345: register XButtonPressedEvent *event; ! 346: { ! 347: register MenuItem *item; ! 348: register int i, button; ! 349: register MenuItem *hilited_item = (MenuItem *)0; ! 350: register int drawn; ! 351: XButtonReleasedEvent ev; ! 352: register int changed; ! 353: int y, n, hilited_y, hilited_n, in_window; ! 354: static MenuItem *Mouse_InItem(), *Y_InItem(); ! 355: static Unmap_Menu(); ! 356: ! 357: /* ! 358: * Check that things are reasonable. ! 359: */ ! 360: if(!menu || !event || !menu->menuItems || event->type != ButtonPressed) ! 361: return(-1); ! 362: /* ! 363: * Set the changed flag and clear the menu changed flags. ! 364: */ ! 365: changed = menu->menuFlags & (menuChanged | menuItemChanged); ! 366: /* ! 367: * If the entire menu has changed, throw away any saved pixmap and ! 368: * then call RecalcMenu(). ! 369: */ ! 370: if(changed & menuChanged) { ! 371: if(menu->menuSaved) ! 372: XFreePixmap(menu->menuSaved); ! 373: menu->menuSaved = (Pixmap)0; ! 374: if(!Recalc_Menu(menu)) ! 375: return(-1); ! 376: changed &= ~menuItemChanged; ! 377: } ! 378: /* ! 379: * Now if the window was never created, go ahead and make it. Otherwise ! 380: * if the menu has changed, resize the window. ! 381: */ ! 382: if(!menu->menuWindow) { ! 383: if((menu->menuWindow = XCreateWindow(RootWindow, 0, 0, ! 384: menu->menuWidth, menu->menuHeight, menu->menuBorderWidth, ! 385: Gray_Tile, menu->menuBgTile)) == (Window)0) ! 386: return(-1); ! 387: XDefineCursor(menu->menuWindow, menu->menuCursor); ! 388: XSelectInput(menu->menuWindow, ExposeWindow | EnterWindow | ! 389: LeaveWindow | MouseMoved | ButtonReleased); ! 390: } else if(changed & menuChanged) ! 391: XChangeWindow(menu->menuWindow, menu->menuWidth, ! 392: menu->menuHeight); ! 393: /* ! 394: * Figure out where the menu is supposed to go, from the initial button ! 395: * press, and move the window there. Then map the menu. ! 396: */ ! 397: if(!Move_Menu(menu, event) || !Map_Menu(menu)) ! 398: return(-1); ! 399: /* ! 400: * Try to grab the mouse, over a period of 10 seconds. ! 401: */ ! 402: for(i = 10 ; ; ) { ! 403: if(XGrabMouse(menu->menuWindow, menu->menuCursor, ! 404: ButtonReleased | EnterWindow | LeaveWindow | MouseMoved)) ! 405: break; ! 406: if(--i <= 0) { ! 407: Unmap_Menu(menu); ! 408: return(-1); ! 409: } ! 410: sleep(1); ! 411: } ! 412: /* ! 413: * Save away the button that was pressed and use it to match a ! 414: * corresponding ButtonReleased event. ! 415: */ ! 416: button = event->detail & 03; ! 417: /* ! 418: * Now process events for the menu window. ! 419: */ ! 420: drawn = 0; ! 421: for( ; ; ) { ! 422: XNextEvent(&ev); ! 423: if(ev.type != ButtonReleased && ev.window != menu->menuWindow) { ! 424: if(menu->menuEventHandler) ! 425: (*menu->menuEventHandler)(&ev); ! 426: continue; ! 427: } ! 428: switch(ev.type) { ! 429: case ExposeWindow: ! 430: /* ! 431: * If we have a saved pixmap, display it. Otherwise ! 432: * redraw the menu and save it away. ! 433: */ ! 434: if(menu->menuSaved) { ! 435: XPixmapPut(menu->menuWindow, 0, 0, 0, 0, ! 436: menu->menuWidth, menu->menuHeight, ! 437: menu->menuSaved, GXcopy, AllPlanes); ! 438: /* ! 439: * If the menuItemChanged flag is still set, ! 440: * then we need to redraw certain menu items. ! 441: * ("i" is the vertical position of the top ! 442: * of the current item.) ! 443: */ ! 444: if(changed & menuItemChanged) { ! 445: i = menu->menuItemTop; ! 446: for(item = menu->menuItems ; item ; ! 447: item = item->nextItem) { ! 448: if(item->itemFlags & ! 449: itemChanged) ! 450: Modify_Item(menu, item, ! 451: i); ! 452: i += item->itemHeight; ! 453: } ! 454: } ! 455: } else ! 456: Draw_Menu(menu); ! 457: /* ! 458: * If the menu has changed in any way and we want to ! 459: * save the menu, throw away any existing save menu ! 460: * image and make a new one. ! 461: */ ! 462: XFlush(); ! 463: if(changed && (menu->menuFlags & menuSaveMenu)) { ! 464: if(menu->menuSaved) ! 465: XFreePixmap(menu->menuSaved); ! 466: menu->menuSaved = XPixmapSave(menu->menuWindow, ! 467: 0, 0, menu->menuWidth, menu->menuHeight); ! 468: } ! 469: /* ! 470: * See which item the cursor may currently be in. If ! 471: * it is in a non-disabled item, hilite it. ! 472: */ ! 473: if(hilited_item = Mouse_InItem(menu, &hilited_y, ! 474: &hilited_n, &in_window)) ! 475: XPixFill(menu->menuWindow, 0, hilited_y, ! 476: menu->menuWidth, hilited_item->itemHeight, ! 477: BlackPixmap, (Bitmap)0, GXinvert, InvertPlane); ! 478: drawn++; ! 479: break; ! 480: case EnterWindow: ! 481: in_window = TRUE; ! 482: /* drop through */ ! 483: case MouseMoved: ! 484: if(!drawn || !in_window) ! 485: break; ! 486: /* ! 487: * See which item the cursor may currently be in. If ! 488: * the item has changed, unhilite the old one and ! 489: * then hilited the new one. ! 490: */ ! 491: y = ((XEnterWindowEvent *)&ev)->y; ! 492: if((item = Y_InItem(menu, &y, &n)) != hilited_item) { ! 493: if(hilited_item) ! 494: XPixFill(menu->menuWindow, 0, ! 495: hilited_y, menu->menuWidth, ! 496: hilited_item->itemHeight, BlackPixmap, ! 497: (Bitmap)0, GXinvert, InvertPlane); ! 498: if(hilited_item = item) { ! 499: XPixFill(menu->menuWindow, 0, ! 500: hilited_y = y, menu->menuWidth, ! 501: item->itemHeight, BlackPixmap, ! 502: (Bitmap)0, GXinvert, InvertPlane); ! 503: hilited_n = n; ! 504: } ! 505: } ! 506: break; ! 507: case LeaveWindow: ! 508: if(!drawn) ! 509: break; ! 510: /* ! 511: * Unhilite any window that is currently hilited. ! 512: */ ! 513: if(hilited_item) { ! 514: XPixFill(menu->menuWindow, 0, hilited_y, ! 515: menu->menuWidth, hilited_item->itemHeight, ! 516: BlackPixmap, (Bitmap)0, GXinvert, InvertPlane); ! 517: hilited_item = (MenuItem *)0; ! 518: } ! 519: in_window = FALSE; ! 520: break; ! 521: case ButtonReleased: ! 522: /* ! 523: * If the correct button was released, ungrab the mouse ! 524: * and return the index number of any selected menu ! 525: * item. ! 526: */ ! 527: if((ev.detail & 0x3) == button) { ! 528: if(in_window) { ! 529: y = ((XButtonReleasedEvent *)&ev)->y; ! 530: if((item = Y_InItem(menu, &y, &n)) != ! 531: hilited_item) { ! 532: if(hilited_item) ! 533: XPixFill(menu->menuWindow, 0, ! 534: hilited_y, menu->menuWidth, ! 535: hilited_item->itemHeight, ! 536: BlackPixmap, (Bitmap)0, ! 537: GXinvert, InvertPlane); ! 538: if(hilited_item = item) { ! 539: XPixFill(menu->menuWindow, 0, ! 540: hilited_y = y, menu->menuWidth, ! 541: hilited_item->itemHeight, ! 542: BlackPixmap, (Bitmap)0, ! 543: GXinvert, InvertPlane); ! 544: hilited_n = n; ! 545: } ! 546: } ! 547: } ! 548: XUngrabMouse(); ! 549: menu->menuFlags &= ~(menuChanged | ! 550: menuItemChanged); ! 551: Unmap_Menu(menu); ! 552: XFlush(); ! 553: if(hilited_item) ! 554: return(menu->menuInitialItem = ! 555: hilited_n); ! 556: return(-1); ! 557: } ! 558: break; ! 559: } ! 560: } ! 561: } ! 562: ! 563: /* ! 564: * Recalculate all of the various menu and item variables. ! 565: */ ! 566: static Recalc_Menu(menu) ! 567: register Menu *menu; ! 568: { ! 569: register MenuItem *item; ! 570: register int max, i, height, fontheight; ! 571: ! 572: /* ! 573: * We must have already gotten the menu font. ! 574: */ ! 575: if(!menu->menuFontInfo) ! 576: return(0); ! 577: /* ! 578: * Initialize the various max width variables. ! 579: */ ! 580: fontheight = menu->menuFontInfo->height; ! 581: height = menu->menuItemTop; ! 582: menu->menuMaxTextWidth = menu->menuTitleWidth; ! 583: /* ! 584: * The item height is the maximum of the font height and the ! 585: * checkbox height. ! 586: */ ! 587: max = fontheight; ! 588: if(checkMarkHeight > max) ! 589: max = checkMarkHeight; ! 590: /* ! 591: * Go through the menu item list. ! 592: */ ! 593: for(item = menu->menuItems ; item ; item = item->nextItem) { ! 594: /* ! 595: * If the item text is a single dash, we assume this is ! 596: * a line separator and treat it special. ! 597: */ ! 598: if(strcmp(item->itemText, "-") == 0) ! 599: height += (item->itemHeight = lineSeparatorHeight); ! 600: else { ! 601: height += (item->itemHeight = max); ! 602: /* ! 603: * Check the text width with the max value stored in ! 604: * menu. ! 605: */ ! 606: if((item->itemTextWidth = XStringWidth(item->itemText, ! 607: menu->menuFontInfo, 0, 0)) > menu->menuMaxTextWidth) ! 608: menu->menuMaxTextWidth = item->itemTextWidth; ! 609: } ! 610: /* ! 611: * If the itemChanged flag is set, set the state bits. ! 612: */ ! 613: if(item->itemFlags & itemChanged) { ! 614: item->itemFlags = (item->itemFlags & ~itemStateMask) | ! 615: ((item->itemFlags & itemSetMask) >> itemSetMaskShift); ! 616: item->itemFlags &= ~itemChanged; ! 617: } ! 618: } ! 619: /* ! 620: * Set the menu height and then set the menu width. ! 621: */ ! 622: menu->menuHeight = height; ! 623: menu->menuWidth = 3 * menu->menuItemPad + menu->menuMaxTextWidth + ! 624: checkMarkWidth; ! 625: return(1); ! 626: } ! 627: ! 628: /* ! 629: * Figure out where to popup the menu, relative to the where the button was ! 630: * pressed. ! 631: */ ! 632: static Move_Menu(menu, ev) ! 633: register Menu *menu; ! 634: XButtonPressedEvent *ev; ! 635: { ! 636: register MenuItem *item; ! 637: register int n, x, y; ! 638: int ev_x, ev_y; ! 639: int total_width; ! 640: Window subw; ! 641: extern int dropmenu; /* XXX */ ! 642: ! 643: /* ! 644: * Get the coordinates of the mouse when the button was pressed. ! 645: */ ! 646: XInterpretLocator(RootWindow, &ev_x, &ev_y, &subw, ev->location); ! 647: /* ! 648: * Try to popup the menu so that the cursor is centered within the ! 649: * width of the menu, but compensate if that would run it outside ! 650: * the display area. ! 651: */ ! 652: total_width = menu->menuWidth + 2 * menu->menuBorderWidth; ! 653: if((x = ev_x - total_width / 2) < 0) ! 654: x = 0; ! 655: else if(x + total_width > DisplayWidth()) ! 656: x = DisplayWidth() - total_width; ! 657: if (dropmenu) ! 658: y = 0; ! 659: else if(menu->menuInitialItem >= 0) { ! 660: /* ! 661: * If we have an inital item, try to popup the menu centered ! 662: * vertically within this item. ! 663: * ! 664: * Look through the item list. "y" is the vertical position ! 665: * of the top of the current item and "n" is the item number. ! 666: */ ! 667: y = menu->menuItemTop + menu->menuBorderWidth; ! 668: for(n = 0, item = menu->menuItems ; ; n++) { ! 669: /* ! 670: * On finding the intial item, center within this item. ! 671: */ ! 672: if(n == menu->menuInitialItem) { ! 673: y += item->itemHeight / 2; ! 674: break; ! 675: } ! 676: y += item->itemHeight; ! 677: /* ! 678: * If we run out of items, turn off the initial item ! 679: * and treat this as if no initial item. ! 680: */ ! 681: if(!(item = item->nextItem)) { ! 682: menu->menuInitialItem = -1; ! 683: goto noInitial; ! 684: } ! 685: } ! 686: /* ! 687: * If no initial item, try to popup the menu centered in the item ! 688: * nearest the center of the menu. ! 689: */ ! 690: } else { ! 691: noInitial: ! 692: /* ! 693: * Look through the item list. "y" is the vertical position ! 694: * of the top of the current item and "n" is the vertical ! 695: * position of the center of the menu. ! 696: */ ! 697: y = menu->menuItemTop + menu->menuBorderWidth; ! 698: for(n = menu->menuHeight / 2, item = menu->menuItems ; item ; ! 699: item = item->nextItem) ! 700: /* ! 701: * If the center of the menu is in this item, we ! 702: * center within this item. ! 703: */ ! 704: if((y += item->itemHeight) > n) { ! 705: y -= item->itemHeight / 2; ! 706: break; ! 707: } ! 708: } ! 709: /* ! 710: * If the menu extends above outside of the display, warp ! 711: * the mouse vertically so the menu will all show up. ! 712: */ ! 713: if((y = ev_y - y) < 0) { ! 714: XWarpMouse(RootWindow, ev_x, ev_y - y); ! 715: y = 0; ! 716: } else if((n = y + menu->menuHeight + 2 * menu->menuBorderWidth ! 717: - DisplayHeight()) > 0) { ! 718: XWarpMouse(RootWindow, ev_x, ev_y - n); ! 719: y -= n; ! 720: } ! 721: XMoveWindow(menu->menuWindow, x, y); ! 722: /* ! 723: * If we are in freeze mode, save what will be the coordinates of ! 724: * the save image. ! 725: */ ! 726: if(menu->menuFlags & menuFreeze) { ! 727: menu->menuSavedImageX = x; ! 728: menu->menuSavedImageY = y; ! 729: } ! 730: return(1); ! 731: } ! 732: ! 733: /* ! 734: * Map the menu window. ! 735: */ ! 736: static Map_Menu(menu) ! 737: register Menu *menu; ! 738: { ! 739: register int i; ! 740: ! 741: /* ! 742: * If we are in freeze mode, save the pixmap underneath where the menu ! 743: * will be (including the border). ! 744: */ ! 745: if(menu->menuFlags & menuFreeze) { ! 746: XGrabServer(); ! 747: i = 2 * menu->menuBorderWidth; ! 748: if((menu->menuSavedImage = XPixmapSave(RootWindow, ! 749: menu->menuSavedImageX, menu->menuSavedImageY, menu->menuWidth ! 750: + i, menu->menuHeight + i)) == (Pixmap)0) ! 751: return(0); ! 752: } ! 753: /* ! 754: * Actually map the window. ! 755: */ ! 756: XMapWindow(menu->menuWindow); ! 757: menu->menuFlags |= menuMapped; ! 758: return(1); ! 759: } ! 760: ! 761: /* ! 762: * Draw the entire menu in the blank window. ! 763: */ ! 764: static Draw_Menu(menu) ! 765: register Menu *menu; ! 766: { ! 767: register MenuItem *item; ! 768: register int top = menu->menuItemTop; ! 769: register int x = menu->menuItemPad; ! 770: register int y, dim; ! 771: ! 772: /* ! 773: * If we have a menu title, draw it first, centered and hilited. ! 774: */ ! 775: if(menu->menuTitleLength) { ! 776: XPixSet(menu->menuWindow, 0, 0, menu->menuWidth, ! 777: top - 1, menu->menuFgColor); ! 778: XText(menu->menuWindow, (menu->menuWidth - ! 779: menu->menuTitleWidth) / 2, menu->menuItemPad, menu->menuTitle, ! 780: menu->menuTitleLength, menu->menuFontInfo->id, ! 781: menu->menuBgColor, menu->menuFgColor); ! 782: } ! 783: /* ! 784: * For each item in the list, first draw any check mark and then ! 785: * draw the rest of it. ! 786: */ ! 787: for(item = menu->menuItems ; item ; item = item->nextItem) { ! 788: SetStateFlags(item); ! 789: dim = (item->itemFlags & itemDisabled); ! 790: /* ! 791: * Draw the check mark, possibly dimmed, wherever is necessary. ! 792: */ ! 793: if(item->itemFlags & itemChecked) { ! 794: XBitmapBitsPut(menu->menuWindow, x, y = top + ! 795: (item->itemHeight - checkMarkHeight) / 2, ! 796: checkMarkWidth, checkMarkHeight, dim ? Check_GrayBits : ! 797: Check_MarkBits, menu->menuFgColor, menu->menuBgColor, ! 798: (Bitmap)0, GXcopy, AllPlanes); ! 799: } ! 800: /* ! 801: * Draw the item, possibly dimmed. ! 802: */ ! 803: Draw_Item(menu, item, top, dim); ! 804: top += item->itemHeight; ! 805: } ! 806: } ! 807: ! 808: /* ! 809: * Modify the item at vertical position y. This routine is table driven and ! 810: * the state and set bits are each 2 bits long, contiguous, the least ! 811: * significant bits in the flag word and with the state bits in bits 0 & 1. ! 812: */ ! 813: ! 814: #define drawCheck 0x10 ! 815: #define removeCheck 0x08 ! 816: #define dimCheck 0x04 ! 817: #define drawItem 0x02 ! 818: #define dimItem 0x01 ! 819: ! 820: static char Modify_Table[] = { ! 821: 0x00, 0x02, 0x08, 0x0a, 0x01, 0x00, 0x09, 0x08, ! 822: 0x10, 0x12, 0x00, 0x12, 0x15, 0x14, 0x05, 0x00 ! 823: }; ! 824: ! 825: static Modify_Item(menu, item, top) ! 826: register Menu *menu; ! 827: register MenuItem *item; ! 828: int top; ! 829: { ! 830: register int x = menu->menuItemPad; ! 831: register int y; ! 832: register int center = top + item->itemHeight / 2; ! 833: register int func = Modify_Table[item->itemFlags & ! 834: (itemStateMask | itemSetMask)]; ! 835: ! 836: /* ! 837: * If we really won't be making a change, return. ! 838: */ ! 839: if(func == 0) ! 840: return; ! 841: /* ! 842: * Draw the check mark if needed, possibly dimmed. ! 843: */ ! 844: y = center - (checkMarkHeight / 2); ! 845: if(func & (drawCheck | dimCheck)) ! 846: XBitmapBitsPut(menu->menuWindow, x, y, checkMarkWidth, ! 847: checkMarkHeight, (func & dimCheck) ? Check_GrayBits : ! 848: Check_MarkBits, menu->menuFgColor, menu->menuBgColor, ! 849: (Bitmap)0, GXcopy, AllPlanes); ! 850: /* ! 851: * Remove the check mark if needed. ! 852: */ ! 853: if(func & removeCheck) ! 854: XTileSet(menu->menuWindow, x, y, checkMarkWidth, ! 855: checkMarkHeight, menu->menuBgTile); ! 856: /* ! 857: * Call Draw_Item if we need to draw or dim the item. ! 858: */ ! 859: if((x = func & dimItem) || (func & drawItem)) ! 860: Draw_Item(menu, item, top, x); ! 861: /* ! 862: * Update state flags. ! 863: */ ! 864: SetStateFlags(item); ! 865: } ! 866: ! 867: /* ! 868: * Draw the item (less check mark) at vertical position y. ! 869: * Dim the item if "dim" is set. ! 870: */ ! 871: static Draw_Item(menu, item, y, dim) ! 872: register Menu *menu; ! 873: register MenuItem *item; ! 874: register int y; ! 875: int dim; ! 876: { ! 877: register int x = 2 * menu->menuItemPad + checkMarkWidth; ! 878: register int center = y + item->itemHeight / 2; ! 879: ! 880: /* ! 881: * If the item text is a single dash, draw a separating line. ! 882: */ ! 883: if(strcmp(item->itemText, "-") == 0) { ! 884: XLine(menu->menuWindow, 0, center, menu->menuWidth, center, ! 885: 1, 1, menu->menuFgColor, GXcopy, AllPlanes); ! 886: return; ! 887: } ! 888: /* ! 889: * Draw and/or dim the text, centered vertically. ! 890: */ ! 891: y = center - (menu->menuFontInfo->height / 2); ! 892: if(dim) { ! 893: XTileSet(menu->menuWindow, x, y, item->itemTextWidth, ! 894: menu->menuFontInfo->height, Gray_Tile); ! 895: XTextPad(menu->menuWindow, x, y, item->itemText, ! 896: item->itemTextLength, menu->menuFontInfo->id, 0, 0, ! 897: menu->menuFgColor, menu->menuBgColor, menu->menuFgColor ? ! 898: GXand : GXor, AllPlanes); ! 899: } else ! 900: XText(menu->menuWindow, x, y, item->itemText, ! 901: item->itemTextLength, menu->menuFontInfo->id, ! 902: menu->menuFgColor, menu->menuBgColor); ! 903: } ! 904: ! 905: /* ! 906: * Determine which enabled menu item the mouse is currently in. Return the ! 907: * top position of this item and its item number. Set inwindow to whether ! 908: * we are or not. ! 909: */ ! 910: static MenuItem *Mouse_InItem(menu, top, n, inwindow) ! 911: register Menu *menu; ! 912: int *top, *n, *inwindow; ! 913: { ! 914: int x, y; ! 915: Window subw; ! 916: static MenuItem *Y_InItem(); ! 917: ! 918: /* ! 919: * Find out where the mouse is. If its not in the menu window, ! 920: * return NULL. ! 921: */ ! 922: XQueryMouse(RootWindow, &x, &y, &subw); ! 923: if(subw != menu->menuWindow) { ! 924: *inwindow = FALSE; ! 925: return((MenuItem *)0); ! 926: } ! 927: *inwindow = TRUE; ! 928: /* ! 929: * Now get the coordinates relative to the menu window. ! 930: */ ! 931: XInterpretLocator(menu->menuWindow, &x, &y, &subw, (x << 16) | y); ! 932: /* ! 933: * Call Y_InItem(). ! 934: */ ! 935: *top = y; ! 936: return(Y_InItem(menu, top, n)); ! 937: } ! 938: ! 939: /* ! 940: * Return which enabled item the locator is in. Also return the ! 941: * top position of this item and its item number. Initial y passed ! 942: * in top. ! 943: */ ! 944: static MenuItem *Y_InItem(menu, top, n) ! 945: register Menu *menu; ! 946: int *top, *n; ! 947: { ! 948: register MenuItem *item; ! 949: register int t, i; ! 950: register int y = *top; ! 951: Window subw; ! 952: ! 953: /* ! 954: * Go through the item list. "t" is the vertical position of the ! 955: * current item and "i" is its item number. ! 956: */ ! 957: t = menu->menuItemTop; ! 958: /* ! 959: * If the mouse is before the first item, return. ! 960: */ ! 961: if(y < t) ! 962: return((MenuItem *)0); ! 963: for(i = 0, item = menu->menuItems ; item ; i++, item = item->nextItem) { ! 964: /* ! 965: * If the y coordinate is within this menu item, then return. ! 966: * But don't return disable items. ! 967: */ ! 968: if(t + item->itemHeight > y) { ! 969: if(item->itemFlags & itemDisabled) ! 970: return((MenuItem *)0); ! 971: *top = t; ! 972: *n = i; ! 973: return(item); ! 974: } ! 975: t += item->itemHeight; ! 976: } ! 977: /* ! 978: * Should never get here. ! 979: */ ! 980: return((MenuItem *)0); ! 981: } ! 982: ! 983: /* ! 984: * Unmap_Menu() unmaps a menu, if it is currently mapped. ! 985: */ ! 986: static Unmap_Menu(menu) ! 987: register Menu *menu; ! 988: { ! 989: register int i; ! 990: ! 991: if(!menu || !(menu->menuFlags & menuMapped)) ! 992: return; ! 993: if(menu->menuFlags & menuFreeze) { ! 994: XUnmapTransparent(menu->menuWindow); ! 995: i = 2 * menu->menuBorderWidth; ! 996: XPixmapPut(RootWindow, 0, 0, menu->menuSavedImageX, ! 997: menu->menuSavedImageY, menu->menuWidth + i, ! 998: menu->menuHeight + i, menu->menuSavedImage, ! 999: GXcopy, AllPlanes); ! 1000: XFreePixmap(menu->menuSavedImage); ! 1001: XUngrabServer(); ! 1002: } else ! 1003: XUnmapWindow(menu->menuWindow); ! 1004: menu->menuFlags &= ~menuMapped; ! 1005: } ! 1006: #endif MODEMENU
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.