![[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 [Research Unix] / researchv9 / X11 / src / X.V11R1 / clients / xterm|
Return to menu.c CVS log | Up to [Research Unix] / researchv9 / X11 / src / X.V11R1 / clients / xterm |
1.1 root 1: /*
2: * $Source: /u1/X11/clients/xterm/RCS/menu.c,v $
3: * $Header: menu.c,v 1.28 87/09/11 22:31:28 rws Exp $
4: */
5:
6: #include <X11/copyright.h>
7:
8: /*
9: * Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
10: *
11: * All Rights Reserved
12: *
13: * Permission to use, copy, modify, and distribute this software and its
14: * documentation for any purpose and without fee is hereby granted,
15: * provided that the above copyright notice appear in all copies and that
16: * both that copyright notice and this permission notice appear in
17: * supporting documentation, and that the name of Digital Equipment
18: * Corporation not be used in advertising or publicity pertaining to
19: * distribution of the software without specific, written prior permission.
20: *
21: *
22: * DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
23: * ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
24: * DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
25: * ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
26: * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
27: * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
28: * SOFTWARE.
29: */
30:
31: #include <stdio.h>
32: #ifdef MODEMENU
33: #include <X11/Xlib.h>
34: #include <X11/Intrinsic.h>
35: #include <X11/Xutil.h>
36: #include <X11/Xatom.h>
37: #include <X11/cursorfont.h>
38: #include <X11/Xtlib.h>
39: #include "menu.h"
40: #include <setjmp.h>
41: #include "ptyx.h"
42: #include "data.h"
43:
44: #ifndef lint
45: static char rcs_id[] = "$Header: menu.c,v 1.28 87/09/11 22:31:28 rws Exp $";
46: #endif lint
47:
48: #define DEFMENUBORDER 2
49: #define DEFMENUPAD 3
50:
51: #define XtNxterm "xterm"
52: #define XtCApp "App"
53:
54: #define XOR(a,b) ((a&(~b)) | ((~a)&b))
55:
56: #define SetStateFlags(item) item->itemFlags = (item->itemFlags &\
57: ~(itemStateMask | itemChanged)) |\
58: ((item->itemFlags & itemSetMask) >>\
59: itemSetMaskShift)
60:
61:
62: static char Check_MarkBits[] = {
63: 0x00, 0x01, 0x80, 0x01, 0xc0, 0x00, 0x60, 0x00,
64: 0x31, 0x00, 0x1b, 0x00, 0x0e, 0x00, 0x04, 0x00
65: };
66: static char Default_CursorBits[] = {
67: 0x00, 0x00, 0x02, 0x00, 0x06, 0x00, 0x0e, 0x00,
68: 0x1e, 0x00, 0x3e, 0x00, 0x7e, 0x00, 0xfe, 0x00,
69: 0xfe, 0x01, 0x3e, 0x00, 0x36, 0x00, 0x62, 0x00,
70: 0x60, 0x00, 0xc0, 0x00, 0xc0, 0x00, 0x00, 0x00
71: };
72: static char Default_MaskBits[] = {
73: 0x03, 0x00, 0x07, 0x00, 0x0f, 0x00, 0x1f, 0x00,
74: 0x3f, 0x00, 0x7f, 0x00, 0xff, 0x00, 0xff, 0x01,
75: 0xff, 0x03, 0xff, 0x07, 0x7f, 0x00, 0xf7, 0x00,
76: 0xf3, 0x00, 0xe1, 0x01, 0xe0, 0x01, 0xc0, 0x01
77: };
78:
79: static GC MenuGC, MenuInverseGC, MenuInvertGC, MenuGrayGC;
80: static int gotGCs = FALSE;
81:
82: Pixmap Gray_Tile, Check_Tile;
83: Menu Menu_Default;
84: Cursor Menu_DefaultCursor;
85: char *Menu_DefaultFont;
86:
87: extern XrmNameList nameList;
88: extern XrmClassList classList;
89: extern EventDoNothing();
90:
91: static int default_menuBorder = DEFMENUBORDER;
92: static int default_menuPad = DEFMENUPAD;
93: static char *defaultNULL = NULL;
94:
95: static Resource resourceList[] = {
96: {"menuBorder", "MenuBorder", XrmRInt, sizeof(int),
97: (caddr_t) &Menu_Default.menuBorderWidth, (caddr_t) &default_menuBorder},
98: {"menuFont", XtCFont, XrmRString, sizeof(char *),
99: (caddr_t) &Menu_DefaultFont, (caddr_t) &defaultNULL},
100: {"menuPad", "MenuPad", XrmRInt, sizeof(int),
101: (caddr_t) &Menu_Default.menuItemPad, (caddr_t) &default_menuPad}
102: };
103:
104: /*
105: * AddMenuItem() adds a menu item to an existing menu, at the end of the
106: * list, which are number sequentially from zero. The menuitem index is
107: * return, or -1 if failed.
108: */
109:
110: AddMenuItem(menu, text)
111: register Menu *menu;
112: register char *text;
113: {
114: register MenuItem *menuitem, **next;
115: register int i;
116: extern char *malloc();
117:
118: if(!menu || !text || (menuitem = (MenuItem *)malloc(sizeof(MenuItem)))
119: == (MenuItem *)0)
120: return(-1);
121: bzero((char *)menuitem, sizeof(MenuItem));
122: menuitem->itemText = text;
123: menuitem->itemTextLength = strlen(text);
124: for(i = 0, next = &menu->menuItems ; *next ; i++)
125: next = &(*next)->nextItem;
126: *next = menuitem;
127: menu->menuFlags |= menuChanged;
128: return(i);
129: }
130:
131: /*
132: * DisposeItem() releases the memory allocated for the given indexed
133: * menuitem. Nonzero is returned if an item was actual disposed of.
134: */
135: DisposeItem(menu, i)
136: register Menu *menu;
137: register int i;
138: {
139: register MenuItem **next, **last, *menuitem;
140:
141: if(!menu || i < 0)
142: return(0);
143: next = &menu->menuItems;
144: do {
145: if(!*next)
146: return(0);
147: last = next;
148: next = &(*next)->nextItem;
149: } while(i-- > 0);
150: menuitem = *last;
151: *last = *next;
152: free(menuitem);
153: return(1);
154: }
155:
156: /*
157: * DisposeMenu() releases the memory allocated for the given menu.
158: */
159: DisposeMenu(menu)
160: register Menu *menu;
161: {
162: register TScreen *screen = &term.screen;
163: static Unmap_Menu();
164:
165: if(!menu)
166: return;
167: if(menu->menuFlags & menuMapped)
168: Unmap_Menu(menu);
169: while(DisposeItem(menu, 0));
170: if(menu->menuWindow)
171: XDestroyWindow(screen->display, menu->menuWindow);
172: if(menu->menuSaved)
173: XFreePixmap(screen->display, menu->menuSaved);
174: free(menu);
175: }
176:
177: InitMenu(name)
178: register char *name;
179: {
180: register TScreen *screen = &term.screen;
181: register char *cp;
182: extern Pixmap make_gray();
183: Display *dpy = screen->display;
184:
185: /*
186: * If the gray tile hasn't been set up, do it now.
187: */
188: if(!Gray_Tile)
189: Gray_Tile = make_gray(WhitePixel(dpy, DefaultScreen(dpy)),
190: BlackPixel(dpy, DefaultScreen(dpy)), 1);
191: if (!Check_Tile) {
192: Check_Tile = Make_tile(checkMarkWidth, checkMarkHeight,
193: Check_MarkBits, BlackPixel(dpy, DefaultScreen(dpy)),
194: WhitePixel(dpy, DefaultScreen(dpy)),
195: DefaultDepth(dpy, DefaultScreen(dpy)));
196: }
197: Menu_Default.menuFlags = menuChanged;
198: /* if((cp = XGetDefault(dpy, name, "MenuFreeze")) && XStrCmp(cp, "on") == 0)
199: Menu_Default.menuFlags |= menuFreeze;
200: if((cp = XGetDefault(dpy, name, "MenuSave")) && XStrCmp(cp, "on") == 0)
201: Menu_Default.menuFlags |= menuSaveMenu;
202: */
203: Menu_Default.menuInitialItem = -1;
204: XtGetResources( dpy, resourceList, XtNumber(resourceList),
205: (ArgList) NULL, 0, DefaultRootWindow(dpy),
206: XtNxterm, XtCApp, &nameList, &classList );
207:
208: /* would be nice if (Xrm)CvtStringToFontStruct didn't complain
209: * when the font didn't exist! */
210: if (Menu_DefaultFont != NULL) {
211: Menu_Default.menuFontInfo = XLoadQueryFont(dpy, Menu_DefaultFont);
212: if (!Menu_Default.menuFontInfo)
213: Menu_DefaultFont = NULL;
214: }
215:
216: /* actually, we need to know whether the fid is valid anyway */
217: if (Menu_DefaultFont == NULL) {
218: Menu_Default.menuFontInfo = screen->fnt_norm;
219: MenugcFontMask = VTgcFontMask;
220: }
221: };
222:
223: /*
224: * ItemFlags returns the state of item "n" of the menu.
225: */
226: ItemFlags(menu, n)
227: register Menu *menu;
228: register int n;
229: {
230: register MenuItem *item;
231:
232: if(!menu || !menu->menuItems || n < 0)
233: return(-1);
234: for(item = menu->menuItems ; n > 0 ; n--)
235: if(!(item = item->nextItem))
236: return(0);
237: return((item->itemFlags & itemSetMask) >> itemSetMaskShift);
238: }
239:
240: /*
241: * ItemText changes the text of item "n" of the menu.
242: */
243: ItemText(menu, n, text)
244: register Menu *menu;
245: register int n;
246: char *text;
247: {
248: register MenuItem *item;
249:
250: if(!menu || !menu->menuItems || n < 0 || !text)
251: return(0);
252: for(item = menu->menuItems ; n > 0 ; n--)
253: if(!(item = item->nextItem))
254: return(0);
255: item->itemText = text;
256: menu->menuFlags |= menuChanged;
257: return(1);
258: }
259:
260: /*
261: * NewMenu() returns a pointer to an initialized new Menu structure, or NULL
262: * if failed.
263: *
264: * The Menu structure _menuDefault contains the default menu settings.
265: */
266: Menu *NewMenu(name, reverse)
267: char *name;
268: int reverse;
269: {
270: register Menu *menu;
271: register int fg, bg;
272: register TScreen *screen = &term.screen;
273: XGCValues xgc;
274: extern char *malloc();
275: extern XFontStruct *XLoadQueryFont();
276: register Display *dpy = screen->display;
277:
278: /*
279: * If the GrayTile hasn't been defined, InitMenu() was never
280: * run, so exit.
281: */
282: if(!Gray_Tile)
283: return((Menu *)0);
284: /*
285: * Allocate the memory for the menu structure.
286: */
287: if((menu = (Menu *)malloc(sizeof(Menu))) == (Menu *)0)
288: return((Menu *)0);
289: /*
290: * Initialize to default values.
291: */
292: *menu = Menu_Default;
293: /*
294: * If the menu cursor hasn't been given, make a default one.
295: */
296: if(!menu->menuCursor) {
297: if(!Menu_DefaultCursor) {
298: if(reverse) {
299: fg = WhitePixel(dpy,
300: DefaultScreen(dpy));
301: bg = BlackPixel(dpy,
302: DefaultScreen(dpy));
303: } else {
304: fg = BlackPixel(dpy,
305: DefaultScreen(dpy));
306: bg = WhitePixel(dpy,
307: DefaultScreen(dpy));
308: }
309: if(!(Menu_DefaultCursor =
310: XCreateFontCursor(dpy, XC_left_ptr)))
311: return((Menu *)0);
312: }
313: menu->menuCursor = Menu_DefaultCursor;
314: }
315: /*
316: * Initialze the default background and border pixmaps and foreground
317: * and background colors (black and white).
318: */
319: if(reverse) {
320: menu->menuFgColor = WhitePixel(dpy,
321: DefaultScreen(dpy));
322: menu->menuBgColor = BlackPixel(dpy,
323: DefaultScreen(dpy));
324: } else {
325: menu->menuFgColor = BlackPixel(dpy,
326: DefaultScreen(dpy));
327: menu->menuBgColor = WhitePixel(dpy,
328: DefaultScreen(dpy));
329: }
330: if(!gotGCs) {
331: xgc.foreground = menu->menuFgColor;
332: xgc.function = GXinvert;
333: xgc.plane_mask = XOR(menu->menuFgColor, menu->menuBgColor);
334: MenuInvertGC = XCreateGC(dpy, DefaultRootWindow(dpy),
335: GCForeground+GCFunction+GCPlaneMask, &xgc);
336: xgc.foreground = menu->menuFgColor;
337: xgc.background = menu->menuBgColor;
338: xgc.font = menu->menuFontInfo->fid;
339: xgc.function = GXcopy;
340: xgc.fill_style = FillSolid;
341: MenuGC = XCreateGC(dpy, DefaultRootWindow(dpy),
342: MenugcFontMask+GCForeground+GCBackground+GCFunction+GCFillStyle,
343: &xgc);
344: xgc.foreground = menu->menuBgColor;
345: xgc.background = menu->menuFgColor;
346: xgc.font = menu->menuFontInfo->fid;
347: xgc.function = GXcopy;
348: xgc.fill_style = FillSolid;
349: MenuInverseGC = XCreateGC(dpy, DefaultRootWindow(dpy),
350: MenugcFontMask+GCForeground+GCBackground+GCFunction+GCFillStyle,
351: &xgc);
352: xgc.foreground = menu->menuFgColor;
353: xgc.background = menu->menuBgColor;
354: xgc.function = menu->menuFgColor ? GXor : GXand;
355: /* xgc.function = GXcopy;*/
356: xgc.stipple = Gray_Tile;
357: xgc.fill_style = FillStippled;
358: MenuGrayGC = XCreateGC(dpy, DefaultRootWindow(dpy),
359: GCStipple+GCFillStyle+MenugcFontMask
360: +GCForeground+GCBackground+GCFunction,
361: &xgc);
362: gotGCs = TRUE;
363: }
364: /*
365: * Set the menu title. If name is NULL or is an empty string, no
366: * title will be displayed.
367: */
368: if(name && *name) {
369: menu->menuTitleLength = strlen(menu->menuTitle = name);
370: menu->menuTitleWidth = XTextWidth(menu->menuFontInfo, name,
371: menu->menuTitleLength);
372: menu->menuItemTop = menu->menuFontInfo->ascent +
373: menu->menuFontInfo->descent + 2 * menu->menuItemPad + 1;
374: } else
375: menu->menuTitleLength = menu->menuTitleWidth =
376: menu->menuItemTop = 0;
377: return(menu);
378: }
379:
380: /*
381: * SetItemCheck sets the check state of item "n" of the menu to "state".
382: */
383: SetItemCheck(menu, n, state)
384: register Menu *menu;
385: register int n;
386: int state;
387: {
388: register MenuItem *item;
389:
390: if(!menu || !menu->menuItems || n < 0)
391: return(0);
392: for(item = menu->menuItems ; n > 0 ; n--)
393: if(!(item = item->nextItem))
394: return(0);
395: if(state)
396: item->itemFlags |= itemSetChecked;
397: else
398: item->itemFlags &= ~itemSetChecked;
399: if(((item->itemFlags & itemSetMask) >> itemSetMaskShift) !=
400: (item->itemFlags & itemStateMask)) {
401: item->itemFlags |= itemChanged;
402: menu->menuFlags |= menuItemChanged;
403: } else
404: item->itemFlags &= ~itemChanged;
405: return(1);
406: }
407:
408: /*
409: * SetItemDisable sets the disable state of item "n" of the menu to "state".
410: */
411: SetItemDisable(menu, n, state)
412: register Menu *menu;
413: register int n;
414: int state;
415: {
416: register MenuItem *item;
417:
418: if(!menu || !menu->menuItems || n < 0)
419: return(0);
420: for(item = menu->menuItems ; n > 0 ; n--)
421: if(!(item = item->nextItem))
422: return(0);
423: if(state)
424: item->itemFlags |= itemSetDisabled;
425: else
426: item->itemFlags &= ~itemSetDisabled;
427: if(((item->itemFlags & itemSetMask) >> itemSetMaskShift) !=
428: (item->itemFlags & itemStateMask)) {
429: item->itemFlags |= itemChanged;
430: menu->menuFlags |= menuItemChanged;
431: } else
432: item->itemFlags &= ~itemChanged;
433: return(1);
434: }
435:
436: static Menu *menu;
437: static MenuItem *item;
438: static int i;
439: static MenuItem *hilited_item;
440: static int drawn;
441: static int changed;
442: int y, n, hilited_y, hilited_n, in_window;
443: static MenuItem *Mouse_InItem(), *Y_InItem();
444: static Unmap_Menu();
445:
446: XtEventReturnCode MenuExposeWindow(event, eventdata)
447: register XEvent *event;
448: caddr_t eventdata;
449: {
450: register TScreen *screen = &term.screen;
451: /*
452: * If we have a saved pixmap, display it. Otherwise
453: * redraw the menu and save it away.
454: */
455: if (event->type == NoExpose) return;
456: if(menu->menuSaved) {
457: XCopyArea(screen->display, menu->menuSaved, menu->menuWindow,
458: MenuGC, 0, 0,
459: menu->menuWidth, menu->menuHeight, 0, 0);
460: /*
461: * If the menuItemChanged flag is still set,
462: * then we need to redraw certain menu items.
463: * ("i" is the vertical position of the top
464: * of the current item.)
465: */
466: if(changed & menuItemChanged) {
467: i = menu->menuItemTop;
468: for(item = menu->menuItems ; item ;
469: item = item->nextItem) {
470: if(item->itemFlags & itemChanged)
471: Modify_Item(menu, item, i);
472: i += item->itemHeight;
473: }
474: }
475: } else
476: Draw_Menu(menu);
477: /*
478: * If the menu has changed in any way and we want to
479: * save the menu, throw away any existing save menu
480: * image and make a new one.
481: */
482: XFlush(screen->display);
483: if(changed && (menu->menuFlags & menuSaveMenu)) {
484: if(menu->menuSaved)
485: XFreePixmap(screen->display, menu->menuSaved);
486: /* menu->menuSaved = XPixmapSave(screen->display,
487: menu->menuWindow, 0, 0, menu->menuWidth, menu->menuHeight);
488: */
489: }
490: /*
491: * See which item the cursor may currently be in. If
492: * it is in a non-disabled item, hilite it.
493: */
494: if(hilited_item = Mouse_InItem(menu, &hilited_y, &hilited_n))
495: XFillRectangle(screen->display, menu->menuWindow,
496: MenuInvertGC, 0, hilited_y,
497: menu->menuWidth, hilited_item->itemHeight);
498: drawn++;
499: return (XteventHandled);
500: }
501:
502: XtEventReturnCode MenuMouseMoved(event, eventdata)
503: XButtonEvent *event;
504: caddr_t eventdata;
505: {
506: register TScreen *screen = &term.screen;
507: if(!drawn || !in_window)
508: return;
509: /*
510: * See which item the cursor may currently be in. If
511: * the item has changed, unhilite the old one and
512: * then hilited the new one.
513: */
514: y = event->y;
515: if((item = Y_InItem(menu, &y, &n)) != hilited_item) {
516: if(hilited_item)
517: XFillRectangle(screen->display, menu->menuWindow,
518: MenuInvertGC, 0, hilited_y,
519: menu->menuWidth, hilited_item->itemHeight);
520: if(hilited_item = item) {
521: XFillRectangle(screen->display, menu->menuWindow,
522: MenuInvertGC, 0,
523: hilited_y = y, menu->menuWidth, item->itemHeight);
524: hilited_n = n;
525: }
526: }
527: return (XteventHandled);
528: }
529:
530: XtEventReturnCode MenuEnterWindow(event, eventdata)
531: XEvent *event;
532: caddr_t eventdata;
533: {
534: in_window = TRUE;
535: return (MenuMouseMoved(event, eventdata));
536: }
537:
538: XtEventReturnCode MenuLeaveWindow(event, eventdata)
539: XEvent *event;
540: caddr_t eventdata;
541: {
542: register TScreen *screen = &term.screen;
543: if(!drawn)
544: return (XteventHandled);
545: /*
546: * Unhilite any window that is currently hilited.
547: */
548: if(hilited_item) {
549: XFillRectangle(screen->display, menu->menuWindow,
550: MenuInvertGC, 0, hilited_y,
551: menu->menuWidth, hilited_item->itemHeight);
552: hilited_item = (MenuItem *)0;
553: }
554: in_window = FALSE;
555: return (XteventHandled);
556: }
557:
558: XtEventReturnCode MenuButtonReleased(event, eventdata)
559: XButtonEvent *event;
560: caddr_t eventdata;
561: {
562: register TScreen *screen = &term.screen;
563: extern FinishModeMenu();
564:
565: /*
566: * return the index number of any selected menu
567: * item.
568: */
569:
570: if (! AllButtonsUp(event->state, event->button))
571: return(XteventHandled);
572:
573: XUngrabPointer(screen->display, CurrentTime);
574:
575: if(in_window) {
576: y = event->y;
577: if((item = Y_InItem(menu, &y, &n)) != hilited_item) {
578: if(hilited_item)
579: XFillRectangle(screen->display, menu->menuWindow,
580: MenuInvertGC, 0,
581: hilited_y, menu->menuWidth,
582: hilited_item->itemHeight);
583: if(hilited_item = item) {
584: XFillRectangle(screen->display, menu->menuWindow,
585: MenuInvertGC, 0,
586: hilited_y = y, menu->menuWidth,
587: hilited_item->itemHeight);
588: hilited_n = n;
589: }
590: }
591: }
592: XFlush(screen->display);
593: menu->menuFlags &= ~(menuChanged | menuItemChanged);
594: Unmap_Menu(menu);
595: drawn = 0;
596: if(hilited_item)
597: FinishModeMenu(menu->menuInitialItem = hilited_n);
598: else
599: FinishModeMenu(-1);
600: return (XteventHandled);
601: }
602:
603: /*
604: * TrackMenu does most of the work of displaying the menu and tracking the
605: * mouse.
606: */
607: TrackMenu(lmenu, event)
608: register Menu *lmenu;
609: register XButtonPressedEvent *event;
610: {
611: register TScreen *screen = &term.screen;
612: XButtonReleasedEvent ev;
613: XSetWindowAttributes attr;
614:
615: menu = lmenu;
616: hilited_item = (MenuItem *)0;
617: /*
618: * Check that things are reasonable.
619: */
620: if(!menu || !event || !menu->menuItems || event->type != ButtonPress)
621: return(-1);
622: /*
623: * Set the changed flag and clear the menu changed flags.
624: */
625: changed = menu->menuFlags & (menuChanged | menuItemChanged);
626: /*
627: * If the entire menu has changed, throw away any saved pixmap and
628: * then call RecalcMenu().
629: */
630: if(changed & menuChanged) {
631: if(menu->menuSaved)
632: XFreePixmap(screen->display, menu->menuSaved);
633: menu->menuSaved = (Pixmap)0;
634: if(!Recalc_Menu(menu))
635: return(-1);
636: changed &= ~menuItemChanged;
637: }
638: /*
639: * Now if the window was never created, go ahead and make it. Otherwise
640: * if the menu has changed, resize the window.
641: */
642: if(!menu->menuWindow) {
643: attr.override_redirect = TRUE;
644: attr.border_pixmap = make_gray(
645: WhitePixel(screen->display, DefaultScreen(screen->display)),
646: BlackPixel(screen->display, DefaultScreen(screen->display)),
647: DefaultDepth(screen->display, DefaultScreen(screen->display)));
648: attr.background_pixel = menu->menuBgColor;
649: attr.cursor = menu->menuCursor;
650: if((menu->menuWindow = XCreateWindow(screen->display,
651: DefaultRootWindow(screen->display), 0, 0,
652: menu->menuWidth, menu->menuHeight, menu->menuBorderWidth,
653: 0, CopyFromParent, CopyFromParent,
654: CWBorderPixmap+CWBackPixel+CWOverrideRedirect+CWCursor,
655: &attr)) == (Window)0)
656: return(-1);
657:
658:
659: XtSetEventHandler(screen->display, menu->menuWindow,
660: (XtEventHandler) MenuExposeWindow, ExposureMask,
661: (caddr_t)NULL);
662: XtSetEventHandler(screen->display, menu->menuWindow,
663: (XtEventHandler) MenuEnterWindow, EnterWindowMask,
664: (caddr_t)NULL);
665: XtSetEventHandler(screen->display, menu->menuWindow,
666: (XtEventHandler) MenuLeaveWindow, LeaveWindowMask,
667: (caddr_t)NULL);
668: XtSetEventHandler(screen->display, menu->menuWindow,
669: (XtEventHandler) MenuMouseMoved, PointerMotionMask,
670: (caddr_t)NULL);
671: XtSetEventHandler(screen->display, menu->menuWindow,
672: (XtEventHandler) MenuButtonReleased, ButtonReleaseMask,
673: (caddr_t)NULL);
674: XtSetEventHandler(screen->display, menu->menuWindow,
675: (XtEventHandler) EventDoNothing, ButtonPressMask,
676: (caddr_t)NULL);
677: } else if(changed & menuChanged)
678: XResizeWindow(screen->display, menu->menuWindow,
679: menu->menuWidth, menu->menuHeight);
680: /*
681: * Figure out where the menu is supposed to go, from the initial button
682: * press, and move the window there. Then map the menu.
683: */
684: if(!Move_Menu(menu, event) || !Map_Menu(menu))
685: return(-1);
686:
687: menuWindow = menu->menuWindow;
688: in_window = TRUE;
689: XGrabPointer(screen->display, menu->menuWindow, FALSE,
690: ExposureMask | EnterWindowMask | LeaveWindowMask | PointerMotionMask
691: | ButtonReleaseMask | ButtonPressMask,
692: GrabModeAsync, GrabModeAsync, None, menu->menuCursor, CurrentTime
693: );
694: }
695:
696: /*
697: * Recalculate all of the various menu and item variables.
698: */
699: static Recalc_Menu(menu)
700: register Menu *menu;
701: {
702: register MenuItem *item;
703: register int max, i, height, fontheight;
704:
705: /*
706: * We must have already gotten the menu font.
707: */
708: if(!menu->menuFontInfo)
709: return(0);
710: /*
711: * Initialize the various max width variables.
712: */
713: fontheight = menu->menuFontInfo->ascent + menu->menuFontInfo->descent;
714: height = menu->menuItemTop;
715: menu->menuMaxTextWidth = menu->menuTitleWidth;
716: /*
717: * The item height is the maximum of the font height and the
718: * checkbox height.
719: */
720: max = fontheight;
721: if(checkMarkHeight > max)
722: max = checkMarkHeight;
723: /*
724: * Go through the menu item list.
725: */
726: for(item = menu->menuItems ; item ; item = item->nextItem) {
727: /*
728: * If the item text is a single dash, we assume this is
729: * a line separator and treat it special.
730: */
731: if(XStrCmp(item->itemText, "-") == 0)
732: height += (item->itemHeight = lineSeparatorHeight);
733: else {
734: height += (item->itemHeight = max);
735: /*
736: * Check the text width with the max value stored in
737: * menu.
738: */
739: if((item->itemTextWidth = XTextWidth(
740: menu->menuFontInfo, item->itemText,
741: strlen(item->itemText))) > menu->menuMaxTextWidth)
742: menu->menuMaxTextWidth = item->itemTextWidth;
743: }
744: /*
745: * If the itemChanged flag is set, set the state bits.
746: */
747: if(item->itemFlags & itemChanged) {
748: item->itemFlags = (item->itemFlags & ~itemStateMask) |
749: ((item->itemFlags & itemSetMask) >> itemSetMaskShift);
750: item->itemFlags &= ~itemChanged;
751: }
752: }
753: /*
754: * Set the menu height and then set the menu width.
755: */
756: menu->menuHeight = height;
757: menu->menuWidth = 3 * menu->menuItemPad + menu->menuMaxTextWidth +
758: checkMarkWidth;
759: return(1);
760: }
761:
762: /*
763: * Figure out where to popup the menu, relative to the where the button was
764: * pressed.
765: */
766: static Move_Menu(menu, ev)
767: register Menu *menu;
768: XButtonPressedEvent *ev;
769: {
770: register MenuItem *item;
771: register int n, x, y;
772: register TScreen *screen = &term.screen;
773: int total_width;
774: Window subw;
775: /*
776: * Try to popup the menu so that the cursor is centered within the
777: * width of the menu, but compensate if that would run it outside
778: * the display area.
779: */
780: total_width = menu->menuWidth + 2 * menu->menuBorderWidth;
781: if((x = ev->x_root - total_width / 2) < 0)
782: x = 0;
783: else if(x + total_width > DisplayWidth(screen->display,
784: DefaultScreen(screen->display)))
785: x = DisplayWidth(screen->display,
786: DefaultScreen(screen->display)) - total_width;
787: /*
788: * If the menu extends above outside of the display, warp
789: * the mouse vertically so the menu will all show up.
790: */
791: if((y = ev->y_root) < 0) {
792: /* don't bother warping pointer
793: XWarpPointer(screen->display, None,
794: DefaultRootWindow(screen->display), 0, 0, 0, 0, ev->x_root,
795: 0);
796: */
797: y = 0;
798: } else if((n = y + menu->menuHeight + 2 * menu->menuBorderWidth -
799: DisplayHeight(screen->display, DefaultScreen(screen->display))) > 0) {
800: /* don't bother warping pointer
801: XWarpPointer(screen->display, None,
802: DefaultRootWindow(screen->display), 0, 0, 0, 0, ev->x_root,
803: ev->y_root - n);
804: */
805: y -= n;
806: }
807: XMoveWindow(screen->display, menu->menuWindow, x, y);
808: /*
809: * If we are in freeze mode, save what will be the coordinates of
810: * the save image.
811: */
812: if(menu->menuFlags & menuFreeze) {
813: menu->menuSavedImageX = x;
814: menu->menuSavedImageY = y;
815: }
816: return(1);
817: }
818:
819: /*
820: * Map the menu window.
821: */
822: static Map_Menu(menu)
823: register Menu *menu;
824: {
825: register int i;
826: register TScreen *screen = &term.screen;
827:
828: /*
829: * If we are in freeze mode, save the pixmap underneath where the menu
830: * will be (including the border).
831: */
832: if(menu->menuFlags & menuFreeze) {
833: XGrabServer(screen->display);
834: i = 2 * menu->menuBorderWidth;
835: /* if((menu->menuSavedImage = XPixmapSave(screen->display,
836: DefaultRootWindow(screen->display),
837: menu->menuSavedImageX, menu->menuSavedImageY, menu->menuWidth
838: + i, menu->menuHeight + i)) == (Pixmap)0)
839: */
840: return(0);
841: }
842: /*
843: * Actually map the window.
844: */
845: XMapRaised(screen->display, menu->menuWindow);
846: menu->menuFlags |= menuMapped;
847: return(1);
848: }
849:
850: /*
851: * Draw the entire menu in the blank window.
852: */
853: static Draw_Menu(menu)
854: register Menu *menu;
855: {
856: register MenuItem *item;
857: register int top = menu->menuItemTop;
858: register int x = menu->menuItemPad;
859: register int y, dim;
860: register TScreen *screen = &term.screen;
861:
862: /*
863: * If we have a menu title, draw it first, centered and hilited.
864: */
865: if(menu->menuTitleLength) {
866: XFillRectangle(screen->display, menu->menuWindow,
867: MenuGC, 0, 0, menu->menuWidth, top - 1);
868: XDrawImageString(screen->display, menu->menuWindow,
869: MenuInverseGC, (menu->menuWidth -
870: menu->menuTitleWidth) / 2,
871: menu->menuItemPad+menu->menuFontInfo->ascent,
872: menu->menuTitle, menu->menuTitleLength);
873: }
874: /*
875: * For each item in the list, first draw any check mark and then
876: * draw the rest of it.
877: */
878: for(item = menu->menuItems ; item ; item = item->nextItem) {
879: SetStateFlags(item);
880: dim = (item->itemFlags & itemDisabled);
881: /*
882: * Draw the check mark, possibly dimmed, wherever is necessary.
883: */
884: if(item->itemFlags & itemChecked) {
885: XCopyArea(screen->display,
886: Check_Tile, menu->menuWindow,
887: dim ? MenuGrayGC : MenuGC,
888: 0, 0, checkMarkWidth, checkMarkHeight, x,
889: y = top + (item->itemHeight - checkMarkHeight) / 2);
890: }
891: /*
892: * Draw the item, possibly dimmed.
893: */
894: Draw_Item(menu, item, top, dim);
895: top += item->itemHeight;
896: }
897: }
898:
899: /*
900: * Modify the item at vertical position y. This routine is table driven and
901: * the state and set bits are each 2 bits long, contiguous, the least
902: * significant bits in the flag word and with the state bits in bits 0 & 1.
903: */
904:
905: #define drawCheck 0x10
906: #define removeCheck 0x08
907: #define dimCheck 0x04
908: #define drawItem 0x02
909: #define dimItem 0x01
910:
911: static char Modify_Table[] = {
912: 0x00, 0x02, 0x08, 0x0a, 0x01, 0x00, 0x09, 0x08,
913: 0x10, 0x12, 0x00, 0x12, 0x15, 0x14, 0x05, 0x00
914: };
915:
916: static Modify_Item(menu, item, top)
917: register Menu *menu;
918: register MenuItem *item;
919: int top;
920: {
921: register int x = menu->menuItemPad;
922: register int y;
923: register int center = top + item->itemHeight / 2;
924: register int func = Modify_Table[item->itemFlags &
925: (itemStateMask | itemSetMask)];
926: register TScreen *screen = &term.screen;
927:
928: /*
929: * If we really won't be making a change, return.
930: */
931: if(func == 0)
932: return;
933: /*
934: * Draw the check mark if needed, possibly dimmed.
935: */
936: y = center - (checkMarkHeight / 2);
937: if(func & (drawCheck | dimCheck))
938: XCopyArea(screen->display,
939: Check_Tile, menu->menuWindow,
940: (func & dimCheck) ? MenuGrayGC : MenuGC,
941: 0, 0, checkMarkWidth, checkMarkHeight, x,
942: y = top + (item->itemHeight - checkMarkHeight) / 2);
943: /*
944: * Remove the check mark if needed.
945: */
946: if(func & removeCheck)
947: XClearArea(screen->display, menu->menuWindow,
948: x, y, checkMarkWidth, checkMarkHeight);
949: /*
950: * Call Draw_Item if we need to draw or dim the item.
951: */
952: if((x = func & dimItem) || (func & drawItem))
953: Draw_Item(menu, item, top, x);
954: /*
955: * Update state flags.
956: */
957: SetStateFlags(item);
958: }
959:
960: /*
961: * Draw the item (less check mark) at vertical position y.
962: * Dim the item if "dim" is set.
963: */
964: static Draw_Item(menu, item, y, dim)
965: register Menu *menu;
966: register MenuItem *item;
967: register int y;
968: int dim;
969: {
970: register int x = 2 * menu->menuItemPad + checkMarkWidth;
971: register int center = y + item->itemHeight / 2;
972: register TScreen *screen = &term.screen;
973:
974: /*
975: * If the item text is a single dash, draw a separating line.
976: */
977: if(XStrCmp(item->itemText, "-") == 0) {
978: XDrawLine(screen->display, menu->menuWindow, MenuGC,
979: 0, center, menu->menuWidth, center);
980: return;
981: }
982: /*
983: * Draw and/or dim the text, centered vertically.
984: */
985: y = center -
986: ((menu->menuFontInfo->ascent + menu->menuFontInfo->descent)/ 2);
987: if(dim) {
988: XDrawString(screen->display, menu->menuWindow, MenuGrayGC,
989: x, y+menu->menuFontInfo->ascent,
990: item->itemText, item->itemTextLength);
991: } else
992: XDrawImageString(screen->display, menu->menuWindow,
993: MenuGC, x, y+menu->menuFontInfo->ascent,
994: item->itemText, item->itemTextLength);
995: }
996:
997: /*
998: * Determine which enabled menu item the mouse is currently in. Return the
999: * top position of this item and its item number. Set inwindow to whether
1000: * we are or not.
1001: */
1002: static MenuItem *Mouse_InItem(menu, top, n)
1003: register Menu *menu;
1004: int *top, *n;
1005: {
1006: int x, y, rootx, rooty, mask;
1007: Window subw, root;
1008: static MenuItem *Y_InItem();
1009: register TScreen *screen = &term.screen;
1010:
1011: /*
1012: * Find out where the mouse is. If its not in the menu window,
1013: * return NULL.
1014: */
1015: XQueryPointer(screen->display, menu->menuWindow,
1016: &root, &subw, &rootx, &rooty, &x, &y, &mask);
1017: if((x <0) || (y < 0) ||
1018: (x > menu->menuWidth) || (y > menu->menuHeight)) {
1019: return((MenuItem *)0);
1020: }
1021: /*
1022: * Call Y_InItem().
1023: */
1024: *top = y;
1025: return(Y_InItem(menu, top, n));
1026: }
1027:
1028: /*
1029: * Return which enabled item the locator is in. Also return the
1030: * top position of this item and its item number. Initial y passed
1031: * in top.
1032: */
1033: static MenuItem *Y_InItem(menu, top, n)
1034: register Menu *menu;
1035: int *top, *n;
1036: {
1037: register MenuItem *item;
1038: register int t, i;
1039: register int y = *top;
1040: Window subw;
1041:
1042: /*
1043: * Go through the item list. "t" is the vertical position of the
1044: * current item and "i" is its item number.
1045: */
1046: t = menu->menuItemTop;
1047: /*
1048: * If the mouse is before the first item, return.
1049: */
1050: if(y < t)
1051: return((MenuItem *)0);
1052: for(i = 0, item = menu->menuItems ; item ; i++, item = item->nextItem) {
1053: /*
1054: * If the y coordinate is within this menu item, then return.
1055: * But don't return disable items.
1056: */
1057: if(t + item->itemHeight > y) {
1058: if(item->itemFlags & itemDisabled)
1059: return((MenuItem *)0);
1060: *top = t;
1061: *n = i;
1062: return(item);
1063: }
1064: t += item->itemHeight;
1065: }
1066: /*
1067: * Should never get here.
1068: */
1069: return((MenuItem *)0);
1070: }
1071:
1072: /*
1073: * Unmap_Menu() unmaps a menu, if it is currently mapped.
1074: */
1075: static Unmap_Menu(menu)
1076: register Menu *menu;
1077: {
1078: register int i;
1079: register TScreen *screen = &term.screen;
1080:
1081: if(!menu || !(menu->menuFlags & menuMapped))
1082: return;
1083: if(menu->menuFlags & menuFreeze) {
1084: XUnmapWindow(screen->display, menu->menuWindow);
1085: i = 2 * menu->menuBorderWidth;
1086: XCopyArea(screen->display,
1087: menu->menuSavedImage, DefaultRootWindow(screen->display),
1088: MenuGC, 0, 0, menu->menuWidth + i,
1089: menu->menuHeight + i, menu->menuSavedImageX,
1090: menu->menuSavedImageY);
1091: XFreePixmap(screen->display, menu->menuSavedImage);
1092: XUngrabServer(screen->display);
1093: } else
1094: XUnmapWindow(screen->display, menu->menuWindow);
1095: menu->menuFlags &= ~menuMapped;
1096: }
1097: #endif MODEMENU
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.