X-Git-Url: https://code.delx.au/gnu-emacs/blobdiff_plain/ccc1cac01682ab7c0e9d72d8b022eb84684b3a44..93a16fa8a8fd1fccfd2cb15cd16681f95bd3d701:/lwlib/xlwmenu.c?ds=sidebyside diff --git a/lwlib/xlwmenu.c b/lwlib/xlwmenu.c index 6fece5cdb8..e7c783596f 100644 --- a/lwlib/xlwmenu.c +++ b/lwlib/xlwmenu.c @@ -1,15 +1,16 @@ -/* Implements a lightweight menubar widget. +/* Implements a lightweight menubar widget. Copyright (C) 1992 Lucid, Inc. + Copyright (C) 2002 Free Software Foundation, Inc. This file is part of the Lucid Widget Library. -The Lucid Widget Library is free software; you can redistribute it and/or +The Lucid Widget Library is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. The Lucid Widget Library is distributed in the hope that it will be useful, -but WITHOUT ANY WARRANTY; without even the implied warranty of +but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. @@ -20,24 +21,69 @@ Boston, MA 02111-1307, USA. */ /* Created by devin@lucid.com */ +#ifdef HAVE_CONFIG_H +#include +#endif + +#include "../src/lisp.h" + #include #include +#if (defined __sun) && !(defined SUNOS41) +#define SUNOS41 #include +#undef SUNOS41 +#else +#include +#endif #include #include #include #include -#include #include "xlwmenuP.h" +#ifdef emacs + +/* Defined in xfns.c. When config.h defines `static' as empty, we get + redefinition errors when gray_bitmap is included more than once, so + we're referring to the one include in xfns.c here. */ + +extern int gray_bitmap_width; +extern int gray_bitmap_height; +extern char *gray_bitmap_bits; + +/* Defined in xterm.c. */ +extern int x_alloc_nearest_color_for_widget __P ((Widget, Colormap, XColor*)); +extern int x_alloc_lighter_color_for_widget __P ((Widget, Display*, Colormap, + unsigned long *, + double, int)); +extern int x_catch_errors __P ((Display*)); +extern int x_uncatch_errors __P ((Display*, int)); +extern int x_had_errors_p __P ((Display*)); +extern int x_clear_errors __P ((Display*)); +extern unsigned long x_copy_dpy_color __P ((Display *, Colormap, + unsigned long)); + +/* Defined in xfaces.c. */ +extern void x_free_dpy_colors __P ((Display *, Screen *, Colormap, + unsigned long *pixels, int npixels)); +#else /* not emacs */ + +#include +#define gray_bitmap_width gray_width +#define gray_bitmap_height gray_height +#define gray_bitmap_bits gray_bits + +#endif /* not emacs */ + static int pointer_grabbed; static XEvent menu_post_event; XFontStruct *xlwmenu_default_font; -static char -xlwMenuTranslations [] = +static char +xlwMenuTranslations [] = ": start()\n\ : drag()\n\ : select()\n\ @@ -69,32 +115,46 @@ xlwMenuTranslations [] = Alt_R: nothing()\n\ Caps_Lock: nothing()\n\ Shift_Lock:nothing()\n\ +Return: select()\n\ +Down: down()\n\ +Up: up()\n\ +Left: left()\n\ +Right: right()\n\ : key()\n\ : key()\n\ "; +/* FIXME: Space should toggle toggleable menu item but not remove the menu + so you can toggle the next one without entering the menu again. */ + +/* FIXME: Should ESC close one level of menu structure or the complete menu? */ + +/* FIXME: F10 should enter the menu, the first one in the menu-bar. */ + #define offset(field) XtOffset(XlwMenuWidget, field) -static XtResource +static XtResource xlwMenuResources[] = -{ +{ {XtNfont, XtCFont, XtRFontStruct, sizeof(XFontStruct *), offset(menu.font),XtRString, "XtDefaultFont"}, {XtNforeground, XtCForeground, XtRPixel, sizeof(Pixel), offset(menu.foreground), XtRString, "XtDefaultForeground"}, + {XtNdisabledForeground, XtCDisabledForeground, XtRPixel, sizeof(Pixel), + offset(menu.disabled_foreground), XtRString, (XtPointer)NULL}, {XtNbuttonForeground, XtCButtonForeground, XtRPixel, sizeof(Pixel), offset(menu.button_foreground), XtRString, "XtDefaultForeground"}, {XtNmargin, XtCMargin, XtRDimension, sizeof(Dimension), - offset(menu.margin), XtRImmediate, (XtPointer)0}, + offset(menu.margin), XtRImmediate, (XtPointer)1}, {XtNhorizontalSpacing, XtCMargin, XtRDimension, sizeof(Dimension), offset(menu.horizontal_spacing), XtRImmediate, (XtPointer)3}, {XtNverticalSpacing, XtCMargin, XtRDimension, sizeof(Dimension), - offset(menu.vertical_spacing), XtRImmediate, (XtPointer)1}, + offset(menu.vertical_spacing), XtRImmediate, (XtPointer)2}, {XtNarrowSpacing, XtCMargin, XtRDimension, sizeof(Dimension), offset(menu.arrow_spacing), XtRImmediate, (XtPointer)10}, {XmNshadowThickness, XmCShadowThickness, XtRDimension, sizeof (Dimension), offset (menu.shadow_thickness), - XtRImmediate, (XtPointer) 2}, + XtRImmediate, (XtPointer)1}, {XmNtopShadowColor, XmCTopShadowColor, XtRPixel, sizeof (Pixel), offset (menu.top_shadow_color), XtRImmediate, (XtPointer)-1}, {XmNbottomShadowColor, XmCBottomShadowColor, XtRPixel, sizeof (Pixel), @@ -104,10 +164,12 @@ xlwMenuResources[] = {XmNbottomShadowPixmap, XmCBottomShadowPixmap, XtRPixmap, sizeof (Pixmap), offset (menu.bottom_shadow_pixmap), XtRImmediate, (XtPointer)None}, - {XtNopen, XtCCallback, XtRCallback, sizeof(XtPointer), + {XtNopen, XtCCallback, XtRCallback, sizeof(XtPointer), offset(menu.open), XtRCallback, (XtPointer)NULL}, - {XtNselect, XtCCallback, XtRCallback, sizeof(XtPointer), + {XtNselect, XtCCallback, XtRCallback, sizeof(XtPointer), offset(menu.select), XtRCallback, (XtPointer)NULL}, + {XtNhighlightCallback, XtCCallback, XtRCallback, sizeof(XtPointer), + offset(menu.highlight), XtRCallback, (XtPointer)NULL}, {XtNmenu, XtCMenu, XtRPointer, sizeof(XtPointer), offset(menu.contents), XtRImmediate, (XtPointer)NULL}, {XtNcursor, XtCCursor, XtRCursor, sizeof(Cursor), @@ -127,15 +189,24 @@ static void XlwMenuDestroy(); static void XlwMenuClassInitialize(); static void Start(); static void Drag(); +static void Down(); +static void Up(); +static void Left(); +static void Right(); static void Select(); static void Key(); static void Nothing(); +static int separator_height __P ((enum menu_separator)); -static XtActionsRec +static XtActionsRec xlwMenuActionsList [] = { {"start", Start}, {"drag", Drag}, + {"down", Down}, + {"up", Up}, + {"left", Left}, + {"right", Right}, {"select", Select}, {"key", Key}, {"nothing", Nothing}, @@ -146,7 +217,7 @@ xlwMenuActionsList [] = XlwMenuClassRec xlwMenuClassRec = { { /* CoreClass fields initialization */ - (WidgetClass) SuperClass, /* superclass */ + (WidgetClass) SuperClass, /* superclass */ "XlwMenu", /* class_name */ sizeof(XlwMenuRec), /* size */ XlwMenuClassInitialize, /* class_initialize */ @@ -188,9 +259,37 @@ WidgetClass xlwMenuWidgetClass = (WidgetClass) &xlwMenuClassRec; int submenu_destroyed; +/* For debug, if installation-directory is non-nil this is not an installed + Emacs. In that case we do not grab the keyboard to make it easier to + debug. */ +#define GRAB_KEYBOARD (EQ (Vinstallation_directory, Qnil)) + static int next_release_must_exit; /* Utilities */ + +/* Ungrab pointer and keyboard */ +static void +ungrab_all (w, ungrabtime) + Widget w; + Time ungrabtime; +{ + XtUngrabPointer (w, ungrabtime); + if (GRAB_KEYBOARD) XtUngrabKeyboard (w, ungrabtime); +} + +/* Like abort, but remove grabs from widget W before. */ + +static void +abort_gracefully (w) + Widget w; +{ + if (XtIsShell (XtParent (w))) + XtRemoveGrab (w); + ungrab_all (w, CurrentTime); + abort (); +} + static void push_new_stack (mw, val) XlwMenuWidget mw; @@ -217,7 +316,7 @@ static void pop_new_stack_if_no_contents (mw) XlwMenuWidget mw; { - if (mw->menu.new_depth) + if (mw->menu.new_depth > 1) { if (!mw->menu.new_stack [mw->menu.new_depth - 1]->contents) mw->menu.new_depth -= 1; @@ -246,15 +345,6 @@ make_old_stack_space (mw, n) } /* Size code */ -static Boolean -all_dashes_p (s) - char *s; -{ - char* p; - for (p = s; *p == '-'; p++); - return !*p; -} - int string_width (mw, s) XlwMenuWidget mw; @@ -262,7 +352,7 @@ string_width (mw, s) { XCharStruct xcs; int drop; - + XTextExtents (mw->menu.font, s, strlen (s), &drop, &drop, &drop, &xcs); return xcs.width; } @@ -271,12 +361,32 @@ static int arrow_width (mw) XlwMenuWidget mw; { - return mw->menu.font->ascent / 2 | 1; + return (mw->menu.font->ascent * 3/4) | 1; } +/* Return the width of toggle buttons of widget MW. */ + +static int +toggle_button_width (mw) + XlwMenuWidget mw; +{ + return ((mw->menu.font->ascent + mw->menu.font->descent) * 2 / 3) | 1; +} + + +/* Return the width of radio buttons of widget MW. */ + +static int +radio_button_width (mw) + XlwMenuWidget mw; +{ + return toggle_button_width (mw) * 1.41; +} + + static XtResource nameResource[] = -{ +{ {"labelString", "LabelString", XtRString, sizeof(String), 0, XtRImmediate, 0}, }; @@ -320,38 +430,52 @@ resource_widget_value (mw, val) /* Returns the sizes of an item */ static void -size_menu_item (mw, val, horizontal_p, label_width, rest_width, height) +size_menu_item (mw, val, horizontal_p, label_width, rest_width, button_width, + height) XlwMenuWidget mw; widget_value* val; int horizontal_p; int* label_width; int* rest_width; + int* button_width; int* height; { - if (all_dashes_p (val->name)) + enum menu_separator separator; + + if (lw_separator_p (val->name, &separator, 0)) { - *height = 2; + *height = separator_height (separator); *label_width = 1; *rest_width = 0; + *button_width = 0; } else { *height = mw->menu.font->ascent + mw->menu.font->descent + 2 * mw->menu.vertical_spacing + 2 * mw->menu.shadow_thickness; - + *label_width = string_width (mw, resource_widget_value (mw, val)) + mw->menu.horizontal_spacing + mw->menu.shadow_thickness; - + *rest_width = mw->menu.horizontal_spacing + mw->menu.shadow_thickness; if (!horizontal_p) { if (val->contents) + /* Add width of the arrow displayed for submenus. */ *rest_width += arrow_width (mw) + mw->menu.arrow_spacing; else if (val->key) - *rest_width += - string_width (mw, val->key) + mw->menu.arrow_spacing; + /* Add width of key equivalent string. */ + *rest_width += (string_width (mw, val->key) + + mw->menu.arrow_spacing); + + if (val->button_type == BUTTON_TYPE_TOGGLE) + *button_width = (toggle_button_width (mw) + + mw->menu.horizontal_spacing); + else if (val->button_type == BUTTON_TYPE_RADIO) + *button_width = (radio_button_width (mw) + + mw->menu.horizontal_spacing); } } } @@ -363,24 +487,27 @@ size_menu (mw, level) { unsigned int label_width = 0; int rest_width = 0; + int button_width = 0; int max_rest_width = 0; + int max_button_width = 0; unsigned int height = 0; int horizontal_p = mw->menu.horizontal && (level == 0); widget_value* val; window_state* ws; if (level >= mw->menu.old_depth) - abort (); + abort_gracefully ((Widget) mw); - ws = &mw->menu.windows [level]; + ws = &mw->menu.windows [level]; ws->width = 0; ws->height = 0; ws->label_width = 0; + ws->button_width = 0; for (val = mw->menu.old_stack [level]->contents; val; val = val->next) { size_menu_item (mw, val, horizontal_p, &label_width, &rest_width, - &height); + &button_width, &height); if (horizontal_p) { ws->width += label_width + rest_width; @@ -393,44 +520,99 @@ size_menu (mw, level) ws->label_width = label_width; if (rest_width > max_rest_width) max_rest_width = rest_width; + if (button_width > max_button_width) + max_button_width = button_width; ws->height += height; } } - + if (horizontal_p) - ws->label_width = 0; + ws->label_width = ws->button_width = 0; else - ws->width = ws->label_width + max_rest_width; + { + ws->width = ws->label_width + max_rest_width + max_button_width; + ws->button_width = max_button_width; + } ws->width += 2 * mw->menu.shadow_thickness; ws->height += 2 * mw->menu.shadow_thickness; + + if (horizontal_p) + { + ws->width += 2 * mw->menu.margin; + ws->height += 2 * mw->menu.margin; + } } /* Display code */ + static void -draw_arrow (mw, window, gc, x, y, width) +draw_arrow (mw, window, gc, x, y, width, down_p) XlwMenuWidget mw; Window window; GC gc; int x; int y; int width; + int down_p; { - XPoint points [3]; - points [0].x = x; - points [0].y = y + mw->menu.font->ascent; - points [1].x = x; - points [1].y = y; - points [2].x = x + width; - points [2].y = y + mw->menu.font->ascent / 2; - - XFillPolygon (XtDisplay (mw), window, gc, points, 3, Convex, - CoordModeOrigin); + Display *dpy = XtDisplay (mw); + GC top_gc = mw->menu.shadow_top_gc; + GC bottom_gc = mw->menu.shadow_bottom_gc; + int thickness = mw->menu.shadow_thickness; + int height = width; + XPoint pt[10]; + /* alpha = atan (0.5) + factor = (1 + sin (alpha)) / cos (alpha) */ + double factor = 1.62; + int thickness2 = thickness * factor; + + y += (mw->menu.font->ascent + mw->menu.font->descent - height) / 2; + + if (down_p) + { + GC temp; + temp = top_gc; + top_gc = bottom_gc; + bottom_gc = temp; + } + + pt[0].x = x; + pt[0].y = y + height; + pt[1].x = x + thickness; + pt[1].y = y + height - thickness2; + pt[2].x = x + thickness2; + pt[2].y = y + thickness2; + pt[3].x = x; + pt[3].y = y; + XFillPolygon (dpy, window, top_gc, pt, 4, Convex, CoordModeOrigin); + + pt[0].x = x; + pt[0].y = y; + pt[1].x = x + thickness; + pt[1].y = y + thickness2; + pt[2].x = x + width - thickness2; + pt[2].y = y + height / 2; + pt[3].x = x + width; + pt[3].y = y + height / 2; + XFillPolygon (dpy, window, top_gc, pt, 4, Convex, CoordModeOrigin); + + pt[0].x = x; + pt[0].y = y + height; + pt[1].x = x + thickness; + pt[1].y = y + height - thickness2; + pt[2].x = x + width - thickness2; + pt[2].y = y + height / 2; + pt[3].x = x + width; + pt[3].y = y + height / 2; + XFillPolygon (dpy, window, bottom_gc, pt, 4, Convex, CoordModeOrigin); } + + static void -draw_shadow_rectangle (mw, window, x, y, width, height, erase_p) +draw_shadow_rectangle (mw, window, x, y, width, height, erase_p, down_p) XlwMenuWidget mw; Window window; int x; @@ -438,12 +620,22 @@ draw_shadow_rectangle (mw, window, x, y, width, height, erase_p) int width; int height; int erase_p; + int down_p; { Display *dpy = XtDisplay (mw); GC top_gc = !erase_p ? mw->menu.shadow_top_gc : mw->menu.background_gc; GC bottom_gc = !erase_p ? mw->menu.shadow_bottom_gc : mw->menu.background_gc; int thickness = mw->menu.shadow_thickness; XPoint points [4]; + + if (!erase_p && down_p) + { + GC temp; + temp = top_gc; + top_gc = bottom_gc; + bottom_gc = temp; + } + points [0].x = x; points [0].y = y; points [1].x = x + width; @@ -483,11 +675,272 @@ draw_shadow_rectangle (mw, window, x, y, width, height, erase_p) } +static void +draw_shadow_rhombus (mw, window, x, y, width, height, erase_p, down_p) + XlwMenuWidget mw; + Window window; + int x; + int y; + int width; + int height; + int erase_p; + int down_p; +{ + Display *dpy = XtDisplay (mw); + GC top_gc = !erase_p ? mw->menu.shadow_top_gc : mw->menu.background_gc; + GC bottom_gc = !erase_p ? mw->menu.shadow_bottom_gc : mw->menu.background_gc; + int thickness = mw->menu.shadow_thickness; + XPoint points [4]; + + if (!erase_p && down_p) + { + GC temp; + temp = top_gc; + top_gc = bottom_gc; + bottom_gc = temp; + } + + points [0].x = x; + points [0].y = y + height / 2; + points [1].x = x + thickness; + points [1].y = y + height / 2; + points [2].x = x + width / 2; + points [2].y = y + thickness; + points [3].x = x + width / 2; + points [3].y = y; + XFillPolygon (dpy, window, top_gc, points, 4, Convex, CoordModeOrigin); + points [0].x = x + width / 2; + points [0].y = y; + points [1].x = x + width / 2; + points [1].y = y + thickness; + points [2].x = x + width - thickness; + points [2].y = y + height / 2; + points [3].x = x + width; + points [3].y = y + height / 2; + XFillPolygon (dpy, window, top_gc, points, 4, Convex, CoordModeOrigin); + points [0].x = x; + points [0].y = y + height / 2; + points [1].x = x + thickness; + points [1].y = y + height / 2; + points [2].x = x + width / 2; + points [2].y = y + height - thickness; + points [3].x = x + width / 2; + points [3].y = y + height; + XFillPolygon (dpy, window, bottom_gc, points, 4, Convex, CoordModeOrigin); + points [0].x = x + width / 2; + points [0].y = y + height; + points [1].x = x + width / 2; + points [1].y = y + height - thickness; + points [2].x = x + width - thickness; + points [2].y = y + height / 2; + points [3].x = x + width; + points [3].y = y + height / 2; + XFillPolygon (dpy, window, bottom_gc, points, 4, Convex, CoordModeOrigin); +} + + +/* Draw a toggle button on widget MW, X window WINDOW. X/Y is the + top-left corner of the menu item. SELECTED_P non-zero means the + toggle button is selected. */ + +static void +draw_toggle (mw, window, x, y, selected_p) + XlwMenuWidget mw; + Window window; + int x, y, selected_p; +{ + int width, height; + + width = toggle_button_width (mw); + height = width; + x += mw->menu.horizontal_spacing; + y += (mw->menu.font->ascent - height) / 2; + draw_shadow_rectangle (mw, window, x, y, width, height, False, selected_p); +} + + +/* Draw a radio button on widget MW, X window WINDOW. X/Y is the + top-left corner of the menu item. SELECTED_P non-zero means the + toggle button is selected. */ + +static void +draw_radio (mw, window, x, y, selected_p) + XlwMenuWidget mw; + Window window; + int x, y, selected_p; +{ + int width, height; + + width = radio_button_width (mw); + height = width; + x += mw->menu.horizontal_spacing; + y += (mw->menu.font->ascent - height) / 2; + draw_shadow_rhombus (mw, window, x, y, width, height, False, selected_p); +} + + +/* Draw a menu separator on widget MW, X window WINDOW. X/Y is the + top-left corner of the menu item. WIDTH is the width of the + separator to draw. TYPE is the separator type. */ + +static void +draw_separator (mw, window, x, y, width, type) + XlwMenuWidget mw; + Window window; + int x, y, width; + enum menu_separator type; +{ + Display *dpy = XtDisplay (mw); + XGCValues xgcv; + + switch (type) + { + case SEPARATOR_NO_LINE: + break; + + case SEPARATOR_SINGLE_LINE: + XDrawLine (dpy, window, mw->menu.foreground_gc, + x, y, x + width, y); + break; + + case SEPARATOR_DOUBLE_LINE: + draw_separator (mw, window, x, y, width, SEPARATOR_SINGLE_LINE); + draw_separator (mw, window, x, y + 2, width, SEPARATOR_SINGLE_LINE); + break; + + case SEPARATOR_SINGLE_DASHED_LINE: + xgcv.line_style = LineOnOffDash; + XChangeGC (dpy, mw->menu.foreground_gc, GCLineStyle, &xgcv); + XDrawLine (dpy, window, mw->menu.foreground_gc, + x, y, x + width, y); + xgcv.line_style = LineSolid; + XChangeGC (dpy, mw->menu.foreground_gc, GCLineStyle, &xgcv); + break; + + case SEPARATOR_DOUBLE_DASHED_LINE: + draw_separator (mw, window, x, y, width, + SEPARATOR_SINGLE_DASHED_LINE); + draw_separator (mw, window, x, y + 2, width, + SEPARATOR_SINGLE_DASHED_LINE); + break; + + case SEPARATOR_SHADOW_ETCHED_IN: + XDrawLine (dpy, window, mw->menu.shadow_bottom_gc, + x, y, x + width, y); + XDrawLine (dpy, window, mw->menu.shadow_top_gc, + x, y + 1, x + width, y + 1); + break; + + case SEPARATOR_SHADOW_ETCHED_OUT: + XDrawLine (dpy, window, mw->menu.shadow_top_gc, + x, y, x + width, y); + XDrawLine (dpy, window, mw->menu.shadow_bottom_gc, + x, y + 1, x + width, y + 1); + break; + + case SEPARATOR_SHADOW_ETCHED_IN_DASH: + xgcv.line_style = LineOnOffDash; + XChangeGC (dpy, mw->menu.shadow_bottom_gc, GCLineStyle, &xgcv); + XChangeGC (dpy, mw->menu.shadow_top_gc, GCLineStyle, &xgcv); + draw_separator (mw, window, x, y, width, SEPARATOR_SHADOW_ETCHED_IN); + xgcv.line_style = LineSolid; + XChangeGC (dpy, mw->menu.shadow_bottom_gc, GCLineStyle, &xgcv); + XChangeGC (dpy, mw->menu.shadow_top_gc, GCLineStyle, &xgcv); + break; + + case SEPARATOR_SHADOW_ETCHED_OUT_DASH: + xgcv.line_style = LineOnOffDash; + XChangeGC (dpy, mw->menu.shadow_bottom_gc, GCLineStyle, &xgcv); + XChangeGC (dpy, mw->menu.shadow_top_gc, GCLineStyle, &xgcv); + draw_separator (mw, window, x, y, width, SEPARATOR_SHADOW_ETCHED_OUT); + xgcv.line_style = LineSolid; + XChangeGC (dpy, mw->menu.shadow_bottom_gc, GCLineStyle, &xgcv); + XChangeGC (dpy, mw->menu.shadow_top_gc, GCLineStyle, &xgcv); + break; + + case SEPARATOR_SHADOW_DOUBLE_ETCHED_IN: + draw_separator (mw, window, x, y, width, SEPARATOR_SHADOW_ETCHED_IN); + draw_separator (mw, window, x, y + 3, width, SEPARATOR_SHADOW_ETCHED_IN); + break; + + case SEPARATOR_SHADOW_DOUBLE_ETCHED_OUT: + draw_separator (mw, window, x, y, width, + SEPARATOR_SHADOW_ETCHED_OUT); + draw_separator (mw, window, x, y + 3, width, + SEPARATOR_SHADOW_ETCHED_OUT); + break; + + case SEPARATOR_SHADOW_DOUBLE_ETCHED_IN_DASH: + xgcv.line_style = LineOnOffDash; + XChangeGC (dpy, mw->menu.shadow_bottom_gc, GCLineStyle, &xgcv); + XChangeGC (dpy, mw->menu.shadow_top_gc, GCLineStyle, &xgcv); + draw_separator (mw, window, x, y, width, + SEPARATOR_SHADOW_DOUBLE_ETCHED_IN); + xgcv.line_style = LineSolid; + XChangeGC (dpy, mw->menu.shadow_bottom_gc, GCLineStyle, &xgcv); + XChangeGC (dpy, mw->menu.shadow_top_gc, GCLineStyle, &xgcv); + break; + + case SEPARATOR_SHADOW_DOUBLE_ETCHED_OUT_DASH: + xgcv.line_style = LineOnOffDash; + XChangeGC (dpy, mw->menu.shadow_bottom_gc, GCLineStyle, &xgcv); + XChangeGC (dpy, mw->menu.shadow_top_gc, GCLineStyle, &xgcv); + draw_separator (mw, window, x, y, width, + SEPARATOR_SHADOW_DOUBLE_ETCHED_OUT); + xgcv.line_style = LineSolid; + XChangeGC (dpy, mw->menu.shadow_bottom_gc, GCLineStyle, &xgcv); + XChangeGC (dpy, mw->menu.shadow_top_gc, GCLineStyle, &xgcv); + break; + + default: + abort (); + } +} + + +/* Return the pixel height of menu separator SEPARATOR. */ + +static int +separator_height (separator) + enum menu_separator separator; +{ + switch (separator) + { + case SEPARATOR_NO_LINE: + return 2; + + case SEPARATOR_SINGLE_LINE: + case SEPARATOR_SINGLE_DASHED_LINE: + return 1; + + case SEPARATOR_DOUBLE_LINE: + case SEPARATOR_DOUBLE_DASHED_LINE: + return 3; + + case SEPARATOR_SHADOW_ETCHED_IN: + case SEPARATOR_SHADOW_ETCHED_OUT: + case SEPARATOR_SHADOW_ETCHED_IN_DASH: + case SEPARATOR_SHADOW_ETCHED_OUT_DASH: + return 2; + + case SEPARATOR_SHADOW_DOUBLE_ETCHED_IN: + case SEPARATOR_SHADOW_DOUBLE_ETCHED_OUT: + case SEPARATOR_SHADOW_DOUBLE_ETCHED_IN_DASH: + case SEPARATOR_SHADOW_DOUBLE_ETCHED_OUT_DASH: + return 5; + + default: + abort (); + } +} + + /* Display the menu item and increment where.x and where.y to show how large -** the menu item was. -*/ + the menu item was. */ + static void -display_menu_item (mw, val, ws, where, highlighted_p, horizontal_p, just_compute_p) +display_menu_item (mw, val, ws, where, highlighted_p, horizontal_p, + just_compute_p) XlwMenuWidget mw; widget_value* val; window_state* ws; @@ -501,17 +954,20 @@ display_menu_item (mw, val, ws, where, highlighted_p, horizontal_p, just_compute int font_ascent = mw->menu.font->ascent; int font_descent = mw->menu.font->descent; int shadow = mw->menu.shadow_thickness; - int separator_p = all_dashes_p (val->name); + int margin = mw->menu.margin; int h_spacing = mw->menu.horizontal_spacing; int v_spacing = mw->menu.vertical_spacing; int label_width; int rest_width; + int button_width; int height; int width; - int button_p; + enum menu_separator separator; + int separator_p = lw_separator_p (val->name, &separator, 0); /* compute the sizes of the item */ - size_menu_item (mw, val, horizontal_p, &label_width, &rest_width, &height); + size_menu_item (mw, val, horizontal_p, &label_width, &rest_width, + &button_width, &height); if (horizontal_p) width = label_width + rest_width; @@ -521,12 +977,6 @@ display_menu_item (mw, val, ws, where, highlighted_p, horizontal_p, just_compute width = ws->width - 2 * shadow; } -#if 0 - /* see if it should be a button in the menubar */ - button_p = horizontal_p && val->call_data; -#endif - button_p = 0; - /* Only highlight an enabled item that has a callback. */ if (highlighted_p) if (!val->enabled || !(val->call_data || val->contents)) @@ -539,26 +989,29 @@ display_menu_item (mw, val, ws, where, highlighted_p, horizontal_p, just_compute int x = where->x + shadow; int y = where->y + shadow; + if (horizontal_p) + { + x += margin; + y += margin; + } + /* pick the foreground and background GC. */ if (val->enabled) - text_gc = button_p ? mw->menu.button_gc : mw->menu.foreground_gc; + text_gc = mw->menu.foreground_gc; else - text_gc = - button_p ? mw->menu.inactive_button_gc : mw->menu.inactive_gc; + text_gc = mw->menu.disabled_gc; deco_gc = mw->menu.foreground_gc; if (separator_p) { - XDrawLine (XtDisplay (mw), ws->window, mw->menu.shadow_bottom_gc, - x, y, x + width, y); - XDrawLine (XtDisplay (mw), ws->window, mw->menu.shadow_top_gc, - x, y + 1, x + width, y + 1); + draw_separator (mw, ws->window, x, y, width, separator); } - else + else { int x_offset = x + h_spacing + shadow; char* display_string = resource_widget_value (mw, val); - draw_shadow_rectangle (mw, ws->window, x, y, width, height, True); + draw_shadow_rectangle (mw, ws->window, x, y, width, height, True, + False); /* Deal with centering a menu title. */ if (!horizontal_p && !val->contents && !val->call_data) @@ -568,20 +1021,32 @@ display_menu_item (mw, val, ws, where, highlighted_p, horizontal_p, just_compute if (width > l) x_offset = (width - l) >> 1; } + else if (!horizontal_p && ws->button_width) + x_offset += ws->button_width; + + XDrawString (XtDisplay (mw), ws->window, text_gc, x_offset, y + v_spacing + shadow + font_ascent, display_string, strlen (display_string)); - + if (!horizontal_p) { + if (val->button_type == BUTTON_TYPE_TOGGLE) + draw_toggle (mw, ws->window, x, y + v_spacing + shadow, + val->selected); + else if (val->button_type == BUTTON_TYPE_RADIO) + draw_radio (mw, ws->window, x, y + v_spacing + shadow, + val->selected); + if (val->contents) { int a_w = arrow_width (mw); draw_arrow (mw, ws->window, deco_gc, - x + width - arrow_width (mw) - - mw->menu.horizontal_spacing + x + width - a_w + - mw->menu.horizontal_spacing - mw->menu.shadow_thickness, - y + v_spacing + shadow, a_w); + y + v_spacing + shadow, a_w, + highlighted_p); } else if (val->key) { @@ -591,36 +1056,23 @@ display_menu_item (mw, val, ws, where, highlighted_p, horizontal_p, just_compute val->key, strlen (val->key)); } } - - else if (button_p) - { -#if 1 - XDrawRectangle (XtDisplay (mw), ws->window, deco_gc, - x + shadow, y + shadow, - label_width + h_spacing - 1, - font_ascent + font_descent + 2 * v_spacing - 1); - draw_shadow_rectangle (mw, ws->window, x, y, width, height, - False); -#else - highlighted_p = True; -#endif - } else { - XDrawRectangle (XtDisplay (mw), ws->window, + XDrawRectangle (XtDisplay (mw), ws->window, mw->menu.background_gc, x + shadow, y + shadow, label_width + h_spacing - 1, font_ascent + font_descent + 2 * v_spacing - 1); draw_shadow_rectangle (mw, ws->window, x, y, width, height, - True); + True, False); } if (highlighted_p) - draw_shadow_rectangle (mw, ws->window, x, y, width, height, False); + draw_shadow_rectangle (mw, ws->window, x, y, width, height, False, + False); } } - + where->x += width; where->y += height; } @@ -647,13 +1099,14 @@ display_menu (mw, level, just_compute_p, highlighted_pos, hit, hit_return, /* This is set nonzero if the element containing HIGHLIGHTED_POS is disabled, so that we do not return any subsequent element either. */ int no_return = 0; + enum menu_separator separator; if (level >= mw->menu.old_depth) - abort (); + abort_gracefully ((Widget) mw); if (level < mw->menu.old_depth - 1) following_item = mw->menu.old_stack [level + 1]; - else + else following_item = NULL; if (hit) @@ -673,7 +1126,7 @@ display_menu (mw, level, just_compute_p, highlighted_pos, hit, hit_return, else highlighted_pos->y = where.y; } - + just_compute_this_one_p = just_compute_p || ((this || that) && val != this && val != that); @@ -691,7 +1144,7 @@ display_menu (mw, level, just_compute_p, highlighted_pos, hit, hit_return, if (hit && !*hit_return && (horizontal_p ? hit->x < where.x : hit->y < where.y) - && !all_dashes_p (val->name) + && !lw_separator_p (val->name, &separator, 0) && !no_return) { if (val->enabled) @@ -705,9 +1158,10 @@ display_menu (mw, level, just_compute_p, highlighted_pos, hit, hit_return, else where.x = 0; } - + if (!just_compute_p) - draw_shadow_rectangle (mw, ws->window, 0, 0, ws->width, ws->height, False); + draw_shadow_rectangle (mw, ws->window, 0, 0, ws->width, ws->height, + False, False); } /* Motion code */ @@ -718,7 +1172,7 @@ set_new_state (mw, val, level) int level; { int i; - + mw->menu.new_depth = 0; for (i = 0; i < level; i++) push_new_stack (mw, mw->menu.old_stack [i]); @@ -736,7 +1190,7 @@ make_windows_if_needed (mw, n) int mask; Window root = RootWindowOfScreen (DefaultScreenOfDisplay (XtDisplay (mw))); window_state* windows; - + if (mw->menu.windows_length >= n) return; @@ -750,7 +1204,7 @@ make_windows_if_needed (mw, n) xswa.cursor = mw->menu.cursor_shape; mask = CWSaveUnder | CWOverrideRedirect | CWBackPixel | CWBorderPixel | CWEventMask | CWCursor; - + if (!mw->menu.windows) { mw->menu.windows = @@ -780,6 +1234,23 @@ make_windows_if_needed (mw, n) } } +/* Value is non-zero if WINDOW is part of menu bar widget W. */ + +int +xlwmenu_window_p (w, window) + Widget w; + Window window; +{ + XlwMenuWidget mw = (XlwMenuWidget) w; + int i; + + for (i = 0; i < mw->menu.windows_length; ++i) + if (window == mw->menu.windows[i].window) + break; + + return i < mw->menu.windows_length; +} + /* Make the window fit in the screen */ static void fit_to_screen (mw, ws, previous_ws, horizontal_p) @@ -799,7 +1270,11 @@ fit_to_screen (mw, ws, previous_ws, horizontal_p) else if (ws->x + ws->width > screen_width) { if (!horizontal_p) - ws->x = previous_ws->x - ws->width; + /* The addition of shadow-thickness for a sub-menu's position is + to reflect a similar adjustment when the menu is displayed to + the right of the invoking menu-item; it makes the sub-menu + look more `attached' to the menu-item. */ + ws->x = previous_ws->x - ws->width + mw->menu.shadow_thickness; else ws->x = screen_width - ws->width; if (ws->x < 0) @@ -829,7 +1304,7 @@ fit_to_screen (mw, ws, previous_ws, horizontal_p) ws->y = previous_ws->y - ws->height; else ws->y = screen_height - ws->height; - if (ws->y < 0) + if (ws->y < 0) ws->y = 0; } } @@ -871,6 +1346,11 @@ remap_menubar (mw) if (new_selection && !new_selection->enabled) new_selection = NULL; + /* Call callback when the hightlighted item changes. */ + if (old_selection || new_selection) + XtCallCallbackList ((Widget)mw, mw->menu.highlight, + (XtPointer) new_selection); + /* updates old_state from new_state. It has to be done now because display_menu (called below) uses the old_stack to know what to display. */ for (i = last_same + 1; i < new_depth; i++) @@ -889,12 +1369,20 @@ remap_menubar (mw) window_state *previous_ws = &windows[i - 1]; window_state *ws = &windows[i]; - ws->x - = previous_ws->x + selection_position.x + mw->menu.shadow_thickness; + ws->x = (previous_ws->x + selection_position.x + + mw->menu.shadow_thickness); + if (mw->menu.horizontal && i == 1) + ws->x += mw->menu.margin; + +#if 0 if (!mw->menu.horizontal || i > 1) ws->x += mw->menu.shadow_thickness; - ws->y - = previous_ws->y + selection_position.y + mw->menu.shadow_thickness; +#endif + + ws->y = (previous_ws->y + selection_position.y + + mw->menu.shadow_thickness); + if (mw->menu.horizontal && i == 1) + ws->y += mw->menu.margin; size_menu (mw, i); @@ -909,7 +1397,7 @@ remap_menubar (mw) /* unmap the menus that popped down */ for (i = new_depth - 1; i < old_depth; i++) - if (i >= new_depth || !new_stack[i]->contents) + if (i >= new_depth || (i > 0 && !new_stack[i]->contents)) XUnmapWindow (XtDisplay (mw), windows[i].window); } @@ -921,12 +1409,13 @@ motion_event_is_in_menu (mw, ev, level, relative_pos) XPoint* relative_pos; { window_state* ws = &mw->menu.windows [level]; - int x = level == 0 ? ws->x : ws->x + mw->menu.shadow_thickness; - int y = level == 0 ? ws->y : ws->y + mw->menu.shadow_thickness; + int shadow = level == 0 ? 0 : mw->menu.shadow_thickness; + int x = ws->x + shadow; + int y = ws->y + shadow; relative_pos->x = ev->x_root - x; relative_pos->y = ev->y_root - y; - return (x < ev->x_root && ev->x_root < x + ws->width - && y < ev->y_root && ev->y_root < y + ws->height); + return (x - shadow < ev->x_root && ev->x_root < x + ws->width + && y - shadow < ev->y_root && ev->y_root < y + ws->height); } static Boolean @@ -941,7 +1430,7 @@ map_event_to_widget_value (mw, ev, val, level) window_state* ws; *val = NULL; - + /* Find the window */ for (i = mw->menu.old_depth - 1; i >= 0; i--) { @@ -966,6 +1455,7 @@ make_drawing_gcs (mw) XlwMenuWidget mw; { XGCValues xgcv; + float scale; xgcv.font = mw->menu.font->fid; xgcv.foreground = mw->menu.foreground; @@ -973,23 +1463,51 @@ make_drawing_gcs (mw) mw->menu.foreground_gc = XtGetGC ((Widget)mw, GCFont | GCForeground | GCBackground, &xgcv); - + xgcv.font = mw->menu.font->fid; xgcv.foreground = mw->menu.button_foreground; xgcv.background = mw->core.background_pixel; mw->menu.button_gc = XtGetGC ((Widget)mw, GCFont | GCForeground | GCBackground, &xgcv); - + xgcv.font = mw->menu.font->fid; - xgcv.foreground = mw->menu.foreground; xgcv.background = mw->core.background_pixel; - xgcv.fill_style = FillStippled; - xgcv.stipple = mw->menu.gray_pixmap; - mw->menu.inactive_gc = XtGetGC ((Widget)mw, - (GCFont | GCForeground | GCBackground - | GCFillStyle | GCStipple), &xgcv); - + +#define BRIGHTNESS(color) (((color) & 0xff) + (((color) >> 8) & 0xff) + (((color) >> 16) & 0xff)) + + /* Allocate color for disabled menu-items. */ + mw->menu.disabled_foreground = mw->menu.foreground; + if (BRIGHTNESS(mw->menu.foreground) < BRIGHTNESS(mw->core.background_pixel)) + scale = 2.3; + else + scale = 0.55; + + x_alloc_lighter_color_for_widget ((Widget) mw, XtDisplay ((Widget) mw), + mw->core.colormap, + &mw->menu.disabled_foreground, + scale, + 0x8000); + + if (mw->menu.foreground == mw->menu.disabled_foreground + || mw->core.background_pixel == mw->menu.disabled_foreground) + { + /* Too few colors, use stipple. */ + xgcv.foreground = mw->menu.foreground; + xgcv.fill_style = FillStippled; + xgcv.stipple = mw->menu.gray_pixmap; + mw->menu.disabled_gc = XtGetGC ((Widget)mw, + (GCFont | GCForeground | GCBackground + | GCFillStyle | GCStipple), &xgcv); + } + else + { + /* Many colors available, use disabled pixel. */ + xgcv.foreground = mw->menu.disabled_foreground; + mw->menu.disabled_gc = XtGetGC ((Widget)mw, + (GCFont | GCForeground | GCBackground), &xgcv); + } + xgcv.font = mw->menu.font->fid; xgcv.foreground = mw->menu.button_foreground; xgcv.background = mw->core.background_pixel; @@ -998,7 +1516,7 @@ make_drawing_gcs (mw) mw->menu.inactive_button_gc = XtGetGC ((Widget)mw, (GCFont | GCForeground | GCBackground | GCFillStyle | GCStipple), &xgcv); - + xgcv.font = mw->menu.font->fid; xgcv.foreground = mw->core.background_pixel; xgcv.background = mw->menu.foreground; @@ -1013,13 +1531,13 @@ release_drawing_gcs (mw) { XtReleaseGC ((Widget) mw, mw->menu.foreground_gc); XtReleaseGC ((Widget) mw, mw->menu.button_gc); - XtReleaseGC ((Widget) mw, mw->menu.inactive_gc); + XtReleaseGC ((Widget) mw, mw->menu.disabled_gc); XtReleaseGC ((Widget) mw, mw->menu.inactive_button_gc); XtReleaseGC ((Widget) mw, mw->menu.background_gc); /* let's get some segvs if we try to use these... */ mw->menu.foreground_gc = (GC) -1; mw->menu.button_gc = (GC) -1; - mw->menu.inactive_gc = (GC) -1; + mw->menu.disabled_gc = (GC) -1; mw->menu.inactive_button_gc = (GC) -1; mw->menu.background_gc = (GC) -1; } @@ -1034,27 +1552,43 @@ make_shadow_gcs (mw) XGCValues xgcv; unsigned long pm = 0; Display *dpy = XtDisplay ((Widget) mw); - Colormap cmap = DefaultColormapOfScreen (XtScreen ((Widget) mw)); + Screen *screen = XtScreen ((Widget) mw); + Colormap cmap = mw->core.colormap; XColor topc, botc; int top_frobbed = 0, bottom_frobbed = 0; + mw->menu.free_top_shadow_color_p = 0; + mw->menu.free_bottom_shadow_color_p = 0; + if (mw->menu.top_shadow_color == -1) mw->menu.top_shadow_color = mw->core.background_pixel; + else + mw->menu.top_shadow_color = mw->menu.top_shadow_color; + if (mw->menu.bottom_shadow_color == -1) mw->menu.bottom_shadow_color = mw->menu.foreground; + else + mw->menu.bottom_shadow_color = mw->menu.bottom_shadow_color; if (mw->menu.top_shadow_color == mw->core.background_pixel || mw->menu.top_shadow_color == mw->menu.foreground) { topc.pixel = mw->core.background_pixel; +#ifdef emacs + if (x_alloc_lighter_color_for_widget ((Widget) mw, dpy, cmap, + &topc.pixel, + 1.2, 0x8000)) +#else XQueryColor (dpy, cmap, &topc); /* don't overflow/wrap! */ topc.red = MINL (65535, topc.red * 1.2); topc.green = MINL (65535, topc.green * 1.2); topc.blue = MINL (65535, topc.blue * 1.2); if (XAllocColor (dpy, cmap, &topc)) +#endif { mw->menu.top_shadow_color = topc.pixel; + mw->menu.free_top_shadow_color_p = 1; top_frobbed = 1; } } @@ -1062,33 +1596,48 @@ make_shadow_gcs (mw) mw->menu.bottom_shadow_color == mw->core.background_pixel) { botc.pixel = mw->core.background_pixel; +#ifdef emacs + if (x_alloc_lighter_color_for_widget ((Widget) mw, dpy, cmap, + &botc.pixel, + 0.6, 0x4000)) +#else XQueryColor (dpy, cmap, &botc); botc.red *= 0.6; botc.green *= 0.6; botc.blue *= 0.6; if (XAllocColor (dpy, cmap, &botc)) +#endif { mw->menu.bottom_shadow_color = botc.pixel; + mw->menu.free_bottom_shadow_color_p = 1; bottom_frobbed = 1; } } if (top_frobbed && bottom_frobbed) { - int top_avg = ((topc.red / 3) + (topc.green / 3) + (topc.blue / 3)); - int bot_avg = ((botc.red / 3) + (botc.green / 3) + (botc.blue / 3)); - if (bot_avg > top_avg) - { - Pixel tmp = mw->menu.top_shadow_color; - mw->menu.top_shadow_color = mw->menu.bottom_shadow_color; - mw->menu.bottom_shadow_color = tmp; - } - else if (topc.pixel == botc.pixel) + if (topc.pixel == botc.pixel) { if (botc.pixel == mw->menu.foreground) - mw->menu.top_shadow_color = mw->core.background_pixel; + { + if (mw->menu.free_top_shadow_color_p) + { + x_free_dpy_colors (dpy, screen, cmap, + &mw->menu.top_shadow_color, 1); + mw->menu.free_top_shadow_color_p = 0; + } + mw->menu.top_shadow_color = mw->core.background_pixel; + } else - mw->menu.bottom_shadow_color = mw->menu.foreground; + { + if (mw->menu.free_bottom_shadow_color_p) + { + x_free_dpy_colors (dpy, screen, cmap, + &mw->menu.bottom_shadow_color, 1); + mw->menu.free_bottom_shadow_color_p = 0; + } + mw->menu.bottom_shadow_color = mw->menu.foreground; + } } } @@ -1096,12 +1645,23 @@ make_shadow_gcs (mw) mw->menu.top_shadow_color == mw->core.background_pixel) { mw->menu.top_shadow_pixmap = mw->menu.gray_pixmap; + if (mw->menu.free_top_shadow_color_p) + { + x_free_dpy_colors (dpy, screen, cmap, &mw->menu.top_shadow_color, 1); + mw->menu.free_top_shadow_color_p = 0; + } mw->menu.top_shadow_color = mw->menu.foreground; } if (!mw->menu.bottom_shadow_pixmap && mw->menu.bottom_shadow_color == mw->core.background_pixel) { mw->menu.bottom_shadow_pixmap = mw->menu.gray_pixmap; + if (mw->menu.free_bottom_shadow_color_p) + { + x_free_dpy_colors (dpy, screen, cmap, + &mw->menu.bottom_shadow_color, 1); + mw->menu.free_bottom_shadow_color_p = 0; + } mw->menu.bottom_shadow_color = mw->menu.foreground; } @@ -1122,6 +1682,19 @@ static void release_shadow_gcs (mw) XlwMenuWidget mw; { + Display *dpy = XtDisplay ((Widget) mw); + Screen *screen = XtScreen ((Widget) mw); + Colormap cmap = mw->core.colormap; + Pixel px[2]; + int i = 0; + + if (mw->menu.free_top_shadow_color_p) + px[i++] = mw->menu.top_shadow_color; + if (mw->menu.free_bottom_shadow_color_p) + px[i++] = mw->menu.bottom_shadow_color; + if (i > 0) + x_free_dpy_colors (dpy, screen, cmap, px, i); + XtReleaseGC ((Widget) mw, mw->menu.shadow_top_gc); XtReleaseGC ((Widget) mw, mw->menu.shadow_bottom_gc); } @@ -1136,10 +1709,10 @@ XlwMenuInitialize (request, mw, args, num_args) /* Get the GCs and the widget size */ XSetWindowAttributes xswa; int mask; - + Window window = RootWindowOfScreen (DefaultScreenOfDisplay (XtDisplay (mw))); Display* display = XtDisplay (mw); - + #if 0 widget_value *tem = (widget_value *) XtMalloc (sizeof (widget_value)); @@ -1151,12 +1724,12 @@ XlwMenuInitialize (request, mw, args, num_args) /* mw->menu.cursor = XCreateFontCursor (display, mw->menu.cursor_shape); */ mw->menu.cursor = mw->menu.cursor_shape; - + mw->menu.gray_pixmap - = XCreatePixmapFromBitmapData (display, window, gray_bits, - gray_width, gray_height, + = XCreatePixmapFromBitmapData (display, window, gray_bitmap_bits, + gray_bitmap_width, gray_bitmap_height, (unsigned long)1, (unsigned long)0, 1); - + /* I don't understand why this ends up 0 sometimes, but it does. This kludge works around it. Can anyone find a real fix? -- rms. */ @@ -1165,23 +1738,23 @@ XlwMenuInitialize (request, mw, args, num_args) make_drawing_gcs (mw); make_shadow_gcs (mw); - + xswa.background_pixel = mw->core.background_pixel; xswa.border_pixel = mw->core.border_pixel; mask = CWBackPixel | CWBorderPixel; - + mw->menu.popped_up = False; - + mw->menu.old_depth = 1; mw->menu.old_stack = (widget_value**)XtMalloc (sizeof (widget_value*)); mw->menu.old_stack_length = 1; mw->menu.old_stack [0] = mw->menu.contents; - + mw->menu.new_depth = 0; mw->menu.new_stack = 0; mw->menu.new_stack_length = 0; push_new_stack (mw, mw->menu.contents); - + mw->menu.windows = (window_state*)XtMalloc (sizeof (window_state)); mw->menu.windows_length = 1; mw->menu.windows [0].x = 0; @@ -1189,7 +1762,7 @@ XlwMenuInitialize (request, mw, args, num_args) mw->menu.windows [0].width = 0; mw->menu.windows [0].height = 0; size_menu (mw, 0); - + mw->core.width = mw->menu.windows [0].width; mw->core.height = mw->menu.windows [0].height; } @@ -1227,7 +1800,7 @@ XlwMenuRealize (w, valueMask, attributes) /* Only the toplevel menubar/popup is a widget so it's the only one that receives expose events through Xt. So we repaint all the other panes when receiving an Expose event. */ -static void +static void XlwMenuRedisplay (w, ev, region) Widget w; XEvent* ev; @@ -1248,7 +1821,18 @@ XlwMenuRedisplay (w, ev, region) display_menu (mw, i, False, NULL, NULL, NULL, NULL, NULL); } -static void + +/* Part of a hack to make the menu redisplay when a tooltip frame + over a menu item is unmapped. */ + +void +xlwmenu_redisplay (w) + Widget w; +{ + XlwMenuRedisplay (w, NULL, None); +} + +static void XlwMenuDestroy (w) Widget w; { @@ -1256,7 +1840,7 @@ XlwMenuDestroy (w) XlwMenuWidget mw = (XlwMenuWidget) w; if (pointer_grabbed) - XtUngrabPointer ((Widget)w, CurrentTime); + ungrab_all ((Widget)w, CurrentTime); pointer_grabbed = 0; submenu_destroyed = 1; @@ -1299,7 +1883,7 @@ XlwMenuDestroy (w) XtFree ((char *) mw->menu.windows); } -static Boolean +static Boolean XlwMenuSetValues (current, request, new) Widget current; Widget request; @@ -1326,23 +1910,32 @@ XlwMenuSetValues (current, request, new) { release_drawing_gcs (newmw); make_drawing_gcs (newmw); + + release_shadow_gcs (newmw); + /* Cause the shadow colors to be recalculated. */ + newmw->menu.top_shadow_color = -1; + newmw->menu.bottom_shadow_color = -1; + make_shadow_gcs (newmw); + redisplay = True; - - for (i = 0; i < oldmw->menu.windows_length; i++) - { - XSetWindowBackground (XtDisplay (oldmw), - oldmw->menu.windows [i].window, - newmw->core.background_pixel); - /* clear windows and generate expose events */ - XClearArea (XtDisplay (oldmw), oldmw->menu.windows[i].window, - 0, 0, 0, 0, True); - } + + if (XtIsRealized (current)) + /* If the menu is currently displayed, change the display. */ + for (i = 0; i < oldmw->menu.windows_length; i++) + { + XSetWindowBackground (XtDisplay (oldmw), + oldmw->menu.windows [i].window, + newmw->core.background_pixel); + /* clear windows and generate expose events */ + XClearArea (XtDisplay (oldmw), oldmw->menu.windows[i].window, + 0, 0, 0, 0, True); + } } return redisplay; } -static void +static void XlwMenuResize (w) Widget w; { @@ -1377,7 +1970,7 @@ handle_single_motion_event (mw, ev) else set_new_state (mw, val, level); remap_menubar (mw); - + /* Sync with the display. Makes it feel better on X terms. */ XSync (XtDisplay (mw), False); } @@ -1405,7 +1998,7 @@ handle_motion_event (mw, ev) handle_single_motion_event (mw, ev); } -static void +static void Start (w, ev, params, num_params) Widget w; XEvent *ev; @@ -1417,7 +2010,7 @@ Start (w, ev, params, num_params) if (!mw->menu.popped_up) { menu_post_event = *ev; - pop_up_menu (mw, ev); + pop_up_menu (mw, (XButtonPressedEvent*) ev); } else { @@ -1434,7 +2027,7 @@ Start (w, ev, params, num_params) } } -static void +static void Drag (w, ev, params, num_params) Widget w; XEvent *ev; @@ -1457,6 +2050,192 @@ Nothing (w, ev, params, num_params) { } +widget_value * +find_first_selectable (mw, item) + XlwMenuWidget mw; + widget_value *item; +{ + widget_value *current = item; + enum menu_separator separator; + + while (lw_separator_p (current->name, &separator, 0) || !current->enabled) + if (current->next) + current=current->next; + else + return NULL; + + return current; +} + +widget_value * +find_next_selectable (mw, item) + XlwMenuWidget mw; + widget_value *item; +{ + widget_value *current = item; + enum menu_separator separator; + + while (current->next && (current=current->next) && + (lw_separator_p (current->name, &separator, 0) || !current->enabled)) + ; + + if (current == item) + { + if (mw->menu.old_depth < 2) + return current; + current = mw->menu.old_stack [mw->menu.old_depth - 2]->contents; + + while (lw_separator_p (current->name, &separator, 0) || !current->enabled) + { + if (current->next) + current=current->next; + + if (current == item) + break; + } + + } + + return current; +} + +widget_value * +find_prev_selectable (mw, item) + XlwMenuWidget mw; + widget_value *item; +{ + widget_value *current = item; + widget_value *prev = item; + + while ((current=find_next_selectable (mw, current)) != item) + { + if (prev == current) + break; + prev=current; + } + + return prev; +} + +static void +Down (w, ev, params, num_params) + Widget w; + XEvent *ev; + String *params; + Cardinal *num_params; +{ + XlwMenuWidget mw = (XlwMenuWidget) w; + widget_value* selected_item = mw->menu.old_stack [mw->menu.old_depth - 1]; + + /* Inside top-level menu-bar? */ + if (mw->menu.old_depth == 2) + /* When in the menu-bar is pressed, display the corresponding + sub-menu and select the first selectable menu item there. */ + set_new_state (mw, find_first_selectable (mw, selected_item->contents), mw->menu.old_depth); + else + /* Highlight next possible (enabled and not separator) menu item. */ + set_new_state (mw, find_next_selectable (mw, selected_item), mw->menu.old_depth - 1); + + remap_menubar (mw); +} + +static void +Up (w, ev, params, num_params) + Widget w; + XEvent *ev; + String *params; + Cardinal *num_params; +{ + XlwMenuWidget mw = (XlwMenuWidget) w; + widget_value* selected_item = mw->menu.old_stack [mw->menu.old_depth - 1]; + + /* Inside top-level menu-bar? */ + if (mw->menu.old_depth == 2) + { + /* FIXME: this is tricky. in the menu-bar should select the + last selectable item in the list. So we select the first + selectable one and find the previous selectable item. Is there + a better way? */ + set_new_state (mw, find_first_selectable (mw, selected_item->contents), mw->menu.old_depth); + remap_menubar (mw); + selected_item = mw->menu.old_stack [mw->menu.old_depth - 1]; + set_new_state (mw, find_prev_selectable (mw, selected_item), mw->menu.old_depth - 1); + } + else + /* Highlight previous (enabled and not separator) menu item. */ + set_new_state (mw, find_prev_selectable (mw, selected_item), mw->menu.old_depth - 1); + + remap_menubar (mw); +} + +static void +Left (w, ev, params, num_params) + Widget w; + XEvent *ev; + String *params; + Cardinal *num_params; +{ + XlwMenuWidget mw = (XlwMenuWidget) w; + widget_value* selected_item = mw->menu.old_stack [mw->menu.old_depth - 1]; + + /* Inside top-level menu-bar? */ + if (mw->menu.old_depth == 2) + /* When in the menu-bar is pressed, display the previous item on + the menu-bar. If the current item is the first one, highlight the + last item in the menubar (probably Help). */ + set_new_state (mw, find_prev_selectable (mw, selected_item), mw->menu.old_depth - 1); + else if (mw->menu.old_depth == 1 + && selected_item->contents) /* Is this menu item expandable? */ + { + set_new_state (mw, selected_item->contents, mw->menu.old_depth); + remap_menubar (mw); + selected_item = mw->menu.old_stack [mw->menu.old_depth - 1]; + if (!selected_item->enabled && find_first_selectable (mw, selected_item)) + set_new_state (mw, find_first_selectable (mw, selected_item), mw->menu.old_depth - 1); + } + + else + { + pop_new_stack_if_no_contents (mw); + set_new_state (mw, mw->menu.old_stack [mw->menu.old_depth - 2], mw->menu.old_depth - 2); + } + + remap_menubar (mw); +} + +static void +Right (w, ev, params, num_params) + Widget w; + XEvent *ev; + String *params; + Cardinal *num_params; +{ + XlwMenuWidget mw = (XlwMenuWidget) w; + widget_value* selected_item = mw->menu.old_stack [mw->menu.old_depth - 1]; + + /* Inside top-level menu-bar? */ + if (mw->menu.old_depth == 2) + /* When in the menu-bar is pressed, display the next item on + the menu-bar. If the current item is the last one, highlight the + first item (probably File). */ + set_new_state (mw, find_next_selectable (mw, selected_item), mw->menu.old_depth - 1); + else if (selected_item->contents) /* Is this menu item expandable? */ + { + set_new_state (mw, selected_item->contents, mw->menu.old_depth); + remap_menubar (mw); + selected_item = mw->menu.old_stack [mw->menu.old_depth - 1]; + if (!selected_item->enabled && find_first_selectable (mw, selected_item)) + set_new_state (mw, find_first_selectable (mw, selected_item), mw->menu.old_depth - 1); + } + else + { + pop_new_stack_if_no_contents (mw); + set_new_state (mw, mw->menu.old_stack [mw->menu.old_depth - 2], mw->menu.old_depth - 2); + } + + remap_menubar (mw); +} + /* Handle key press and release events while menu is popped up. Our action is to get rid of the menu. */ static void @@ -1475,7 +2254,7 @@ Key (w, ev, params, num_params) if (mw->menu.popped_up) { mw->menu.popped_up = False; - XtUngrabPointer ((Widget)mw, ev->xmotion.time); + ungrab_all ((Widget)mw, ev->xmotion.time); if (XtIsShell (XtParent ((Widget) mw))) XtPopdown (XtParent ((Widget) mw)); else @@ -1498,7 +2277,7 @@ Select (w, ev, params, num_params) { XlwMenuWidget mw = (XlwMenuWidget)w; widget_value* selected_item = mw->menu.old_stack [mw->menu.old_depth - 1]; - + /* If user releases the button quickly, without selecting anything, after the initial down-click that brought the menu up, do nothing. */ @@ -1516,7 +2295,7 @@ Select (w, ev, params, num_params) if (mw->menu.popped_up) { mw->menu.popped_up = False; - XtUngrabPointer ((Widget)mw, ev->xmotion.time); + ungrab_all ((Widget)mw, ev->xmotion.time); if (XtIsShell (XtParent ((Widget) mw))) XtPopdown (XtParent ((Widget) mw)); else @@ -1591,15 +2370,26 @@ pop_up_menu (mw, event) #ifdef emacs count = x_catch_errors (display); #endif - XtGrabPointer ((Widget)mw, False, - (PointerMotionMask - | PointerMotionHintMask - | ButtonReleaseMask - | ButtonPressMask), - GrabModeAsync, GrabModeAsync, None, - mw->menu.cursor_shape, - event->time); - pointer_grabbed = 1; + if (XtGrabPointer ((Widget)mw, False, + (PointerMotionMask + | PointerMotionHintMask + | ButtonReleaseMask + | ButtonPressMask), + GrabModeAsync, GrabModeAsync, None, + mw->menu.cursor_shape, + event->time) == Success) + { + if (! GRAB_KEYBOARD + || XtGrabKeyboard ((Widget)mw, False, GrabModeAsync, + GrabModeAsync, event->time) == Success) + { + XtSetKeyboardFocus((Widget)mw, None); + pointer_grabbed = 1; + } + else + XtUngrabPointer ((Widget)mw, event->time); + } + #ifdef emacs if (x_had_errors_p (display)) {