-/* Implements a lightweight menubar widget.
+/* Implements a lightweight menubar widget.
Copyright (C) 1992 Lucid, 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.
You should have received a copy of the GNU General Public License
-along with GNU Emacs; see the file COPYING. If not, write to
-the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
+along with GNU Emacs; see the file COPYING. If not, write to the
+Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+Boston, MA 02111-1307, USA. */
/* Created by devin@lucid.com */
-#include <stdlib.h>
-#include <unistd.h>
-#include <string.h>
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
#include <stdio.h>
#include <sys/types.h>
+#if (defined __sun) && !(defined SUNOS41)
+#define SUNOS41
+#include <X11/Xos.h>
+#undef SUNOS41
+#else
#include <X11/Xos.h>
+#endif
#include <X11/IntrinsicP.h>
+#include <X11/ObjectP.h>
#include <X11/StringDefs.h>
#include <X11/cursorfont.h>
-#include <X11/bitmaps/gray>
#include "xlwmenuP.h"
-#include <string.h>
-static char
-xlwMenuTranslations [] =
-"<BtnDown>: start()\n\
-<BtnMotion>: drag()\n\
-<BtnUp>: select()\n\
+#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 <X11/bitmaps/gray>
+#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 [] =
+"<BtnDown>: start()\n\
+<Motion>: drag()\n\
+<BtnUp>: select()\n\
+<Key>Shift_L: nothing()\n\
+<Key>Shift_R: nothing()\n\
+<Key>Meta_L: nothing()\n\
+<Key>Meta_R: nothing()\n\
+<Key>Control_L: nothing()\n\
+<Key>Control_R: nothing()\n\
+<Key>Hyper_L: nothing()\n\
+<Key>Hyper_R: nothing()\n\
+<Key>Super_L: nothing()\n\
+<Key>Super_R: nothing()\n\
+<Key>Alt_L: nothing()\n\
+<Key>Alt_R: nothing()\n\
+<Key>Caps_Lock: nothing()\n\
+<Key>Shift_Lock: nothing()\n\
+<KeyUp>Shift_L: nothing()\n\
+<KeyUp>Shift_R: nothing()\n\
+<KeyUp>Meta_L: nothing()\n\
+<KeyUp>Meta_R: nothing()\n\
+<KeyUp>Control_L: nothing()\n\
+<KeyUp>Control_R: nothing()\n\
+<KeyUp>Hyper_L: nothing()\n\
+<KeyUp>Hyper_R: nothing()\n\
+<KeyUp>Super_L: nothing()\n\
+<KeyUp>Super_R: nothing()\n\
+<KeyUp>Alt_L: nothing()\n\
+<KeyUp>Alt_R: nothing()\n\
+<KeyUp>Caps_Lock: nothing()\n\
+<KeyUp>Shift_Lock:nothing()\n\
+<Key>: key()\n\
+<KeyUp>: key()\n\
";
#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),
{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) 4},
{XtNhorizontalSpacing, XtCMargin, XtRDimension, sizeof(Dimension),
offset(menu.horizontal_spacing), XtRImmediate, (XtPointer)3},
{XtNverticalSpacing, XtCMargin, XtRDimension, sizeof(Dimension),
{XtNarrowSpacing, XtCMargin, XtRDimension, sizeof(Dimension),
offset(menu.arrow_spacing), XtRImmediate, (XtPointer)10},
- {XmNshadowThickness, XmCShadowThickness, XmRHorizontalDimension,
+ {XmNshadowThickness, XmCShadowThickness, XtRDimension,
sizeof (Dimension), offset (menu.shadow_thickness),
XtRImmediate, (XtPointer) 2},
{XmNtopShadowColor, XmCTopShadowColor, XtRPixel, sizeof (Pixel),
{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),
static void Start();
static void Drag();
static void Select();
+static void Key();
+static void Nothing();
+static int separator_height ();
-static XtActionsRec
+static XtActionsRec
xlwMenuActionsList [] =
{
{"start", Start},
{"drag", Drag},
{"select", Select},
+ {"key", Key},
+ {"nothing", Nothing},
};
#define SuperClass ((CoreWidgetClass)&coreClassRec)
XlwMenuClassRec xlwMenuClassRec =
{
{ /* CoreClass fields initialization */
- (WidgetClass) SuperClass, /* superclass */
+ (WidgetClass) SuperClass, /* superclass */
"XlwMenu", /* class_name */
sizeof(XlwMenuRec), /* size */
XlwMenuClassInitialize, /* class_initialize */
WidgetClass xlwMenuWidgetClass = (WidgetClass) &xlwMenuClassRec;
+int submenu_destroyed;
+
+static int next_release_must_exit;
+
\f/* Utilities */
+
+
+/* Like abort, but remove grabs from widget W before. */
+
+static void
+abort_gracefully (w)
+ Widget w;
+{
+ if (XtIsShell (XtParent (w)))
+ XtRemoveGrab (w);
+ XtUngrabPointer (w, CurrentTime);
+ abort ();
+}
+
static void
-push_new_stack (XlwMenuWidget mw, widget_value* val)
+push_new_stack (mw, val)
+ XlwMenuWidget mw;
+ widget_value* val;
{
if (!mw->menu.new_stack)
{
}
static void
-pop_new_stack_if_no_contents (XlwMenuWidget mw)
+pop_new_stack_if_no_contents (mw)
+ XlwMenuWidget mw;
{
if (mw->menu.new_depth)
{
}
static void
-make_old_stack_space (XlwMenuWidget mw, int n)
+make_old_stack_space (mw, n)
+ XlwMenuWidget mw;
+ int n;
{
if (!mw->menu.old_stack)
{
}
\f/* Size code */
-static Boolean
-all_dashes_p (char* s)
-{
- char* p;
- for (p = s; *p == '-'; p++);
- return !*p;
-}
-
-static int
-string_width (XlwMenuWidget mw, char* s)
+int
+string_width (mw, s)
+ XlwMenuWidget mw;
+ char *s;
{
XCharStruct xcs;
int drop;
-
+
XTextExtents (mw->menu.font, s, strlen (s), &drop, &drop, &drop, &xcs);
return xcs.width;
}
static int
-arrow_width (XlwMenuWidget mw)
+arrow_width (mw)
+ XlwMenuWidget mw;
+{
+ 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 mw->menu.font->ascent / 2 | 1;
+ return toggle_button_width (mw) * 1.41;
}
+
static XtResource
nameResource[] =
-{
+{
{"labelString", "LabelString", XtRString, sizeof(String),
0, XtRImmediate, 0},
};
static char*
-resource_widget_value (XlwMenuWidget mw, widget_value* val)
+resource_widget_value (mw, val)
+ XlwMenuWidget mw;
+ widget_value *val;
{
if (!val->toolkit_data)
{
if (!resourced_name)
resourced_name = val->name;
if (!val->value)
- complete_name = (char *) strdup (resourced_name);
+ {
+ complete_name = (char *) XtMalloc (strlen (resourced_name) + 1);
+ strcpy (complete_name, resourced_name);
+ }
else
{
int complete_length =
/* Returns the sizes of an item */
static void
-size_menu_item (XlwMenuWidget mw, widget_value* val, int horizontal_p,
- int* label_width, int* rest_width, int* 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);
}
}
}
static void
-size_menu (XlwMenuWidget mw, int level)
+size_menu (mw, level)
+ XlwMenuWidget mw;
+ int level;
{
- int label_width = 0;
+ unsigned int label_width = 0;
int rest_width = 0;
+ int button_width = 0;
int max_rest_width = 0;
- int height = 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;
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;
+ }
}
\f/* Display code */
+
static void
-draw_arrow (XlwMenuWidget mw, Window window, GC gc, int x, int y, int 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 (XlwMenuWidget mw, Window window,
- int x, int y, int width, int height, int erase_p)
+draw_shadow_rectangle (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;
points [1].x = x + width;
}
+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 (XlwMenuWidget mw, widget_value* val, window_state* ws,
- XPoint* where, Boolean highlighted_p, Boolean horizontal_p,
- Boolean 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;
+ XPoint* where;
+ Boolean highlighted_p;
+ Boolean horizontal_p;
+ Boolean just_compute_p;
{
GC deco_gc;
GC text_gc;
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;
width = ws->width - 2 * shadow;
}
- /* see if it should be a button in the menubar */
- button_p = horizontal_p && val->call_data;
-
/* Only highlight an enabled item that has a callback. */
if (highlighted_p)
if (!val->enabled || !(val->call_data || val->contents))
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.inactive_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);
- XDrawString (XtDisplay (mw), ws->window, text_gc,
- x + h_spacing + shadow,
+ 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)
+ {
+ int l = string_width (mw, display_string);
+
+ 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 + label_width + mw->menu.arrow_spacing,
- y + v_spacing + shadow, a_w);
+ x + width - a_w
+ - mw->menu.horizontal_spacing
+ - mw->menu.shadow_thickness,
+ y + v_spacing + shadow, a_w,
+ highlighted_p);
}
else if (val->key)
{
val->key, strlen (val->key));
}
}
-
- else if (button_p)
+ else
{
-#if 1
- XDrawRectangle (XtDisplay (mw), ws->window, deco_gc,
+ 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);
-#else
- highlighted_p = True;
-#endif
+ draw_shadow_rectangle (mw, ws->window, x, y, width, height,
+ 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;
}
static void
-display_menu (XlwMenuWidget mw, int level, Boolean just_compute_p,
- XPoint* highlighted_pos, XPoint* hit, widget_value** hit_return,
- widget_value* this, widget_value* that)
+display_menu (mw, level, just_compute_p, highlighted_pos, hit, hit_return,
+ this, that)
+ XlwMenuWidget mw;
+ int level;
+ Boolean just_compute_p;
+ XPoint* highlighted_pos;
+ XPoint* hit;
+ widget_value** hit_return;
+ widget_value* this;
+ widget_value* that;
{
widget_value* val;
widget_value* following_item;
int horizontal_p = mw->menu.horizontal && (level == 0);
int highlighted_p;
int just_compute_this_one_p;
+ /* 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)
else
highlighted_pos->y = where.y;
}
-
+
just_compute_this_one_p =
just_compute_p || ((this || that) && val != this && val != that);
if (hit
&& !*hit_return
&& (horizontal_p ? hit->x < where.x : hit->y < where.y)
- && !all_dashes_p (val->name))
- *hit_return = val;
+ && !lw_separator_p (val->name, &separator, 0)
+ && !no_return)
+ {
+ if (val->enabled)
+ *hit_return = val;
+ else
+ no_return = 1;
+ }
if (horizontal_p)
where.y = 0;
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);
}
\f/* Motion code */
static void
-set_new_state (XlwMenuWidget mw, widget_value* val, int level)
+set_new_state (mw, val, level)
+ XlwMenuWidget mw;
+ widget_value* val;
+ int level;
{
int i;
-
+
mw->menu.new_depth = 0;
for (i = 0; i < level; i++)
push_new_stack (mw, mw->menu.old_stack [i]);
}
static void
-make_windows_if_needed (XlwMenuWidget mw, int n)
+make_windows_if_needed (mw, n)
+ XlwMenuWidget mw;
+ int n;
{
int i;
int start_at;
int mask;
Window root = RootWindowOfScreen (DefaultScreenOfDisplay (XtDisplay (mw)));
window_state* windows;
-
+
if (mw->menu.windows_length >= n)
return;
xswa.background_pixel = mw->core.background_pixel;
xswa.border_pixel = mw->core.border_pixel;
xswa.event_mask =
- ExposureMask | ButtonMotionMask | PointerMotionHintMask
+ ExposureMask | PointerMotionMask | PointerMotionHintMask
| ButtonReleaseMask | ButtonPressMask;
xswa.cursor = mw->menu.cursor_shape;
mask = CWSaveUnder | CWOverrideRedirect | CWBackPixel | CWBorderPixel
| CWEventMask | CWCursor;
-
+
if (!mw->menu.windows)
{
mw->menu.windows =
/* Make the window fit in the screen */
static void
-fit_to_screen (XlwMenuWidget mw, window_state* ws, window_state* previous_ws,
- Boolean horizontal_p)
+fit_to_screen (mw, ws, previous_ws, horizontal_p)
+ XlwMenuWidget mw;
+ window_state* ws;
+ window_state* previous_ws;
+ Boolean horizontal_p;
{
- int screen_width = WidthOfScreen (XtScreen (mw));
- int screen_height = HeightOfScreen (XtScreen (mw));
+ unsigned int screen_width = WidthOfScreen (XtScreen (mw));
+ unsigned int screen_height = HeightOfScreen (XtScreen (mw));
+ /* 1 if we are unable to avoid an overlap between
+ this menu and the parent menu in the X dimension. */
+ int horizontal_overlap = 0;
if (ws->x < 0)
ws->x = 0;
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)
+ {
+ ws->x = 0;
+ horizontal_overlap = 1;
+ }
+ }
+ /* If we overlap in X, try to avoid overlap in Y. */
+ if (horizontal_overlap
+ && ws->y < previous_ws->y + previous_ws->height
+ && previous_ws->y < ws->y + ws->height)
+ {
+ /* Put this menu right below or right above PREVIOUS_WS
+ if there's room. */
+ if (previous_ws->y + previous_ws->height + ws->height < screen_height)
+ ws->y = previous_ws->y + previous_ws->height;
+ else if (previous_ws->y - ws->height > 0)
+ ws->y = previous_ws->y - ws->height;
}
+
if (ws->y < 0)
ws->y = 0;
else if (ws->y + ws->height > screen_height)
ws->y = previous_ws->y - ws->height;
else
ws->y = screen_height - ws->height;
+ if (ws->y < 0)
+ ws->y = 0;
}
}
/* Updates old_stack from new_stack and redisplays. */
static void
-remap_menubar (XlwMenuWidget mw)
+remap_menubar (mw)
+ XlwMenuWidget mw;
{
int i;
int last_same;
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++)
old_stack [i] = new_stack [i];
mw->menu.old_depth = new_depth;
- /* refresh the last seletion */
+ /* refresh the last selection */
selection_position.x = 0;
selection_position.y = 0;
display_menu (mw, last_same, new_selection == old_selection,
&selection_position, NULL, NULL, old_selection, new_selection);
- /* Now popup the new menus */
- for (i = last_same + 1; i < new_depth && new_stack [i]->contents; i++)
+ /* Now place the new menus. */
+ for (i = last_same + 1; i < new_depth && new_stack[i]->contents; i++)
{
- window_state* previous_ws = &windows [i - 1];
- window_state* ws = &windows [i];
+ window_state *previous_ws = &windows[i - 1];
+ window_state *ws = &windows[i];
+
+ ws->x = (previous_ws->x + selection_position.x
+ + mw->menu.shadow_thickness);
+ if (mw->menu.horizontal && i == 1)
+ ws->x += mw->menu.margin;
- ws->x =
- previous_ws->x + selection_position.x + mw->menu.shadow_thickness;
+#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);
/* unmap the menus that popped down */
for (i = new_depth - 1; i < old_depth; i++)
- if (i >= new_depth || !new_stack [i]->contents)
- XUnmapWindow (XtDisplay (mw), windows [i].window);
+ if (i >= new_depth || !new_stack[i]->contents)
+ XUnmapWindow (XtDisplay (mw), windows[i].window);
}
static Boolean
-motion_event_is_in_menu (XlwMenuWidget mw, XMotionEvent* ev, int level,
- XPoint* relative_pos)
+motion_event_is_in_menu (mw, ev, level, relative_pos)
+ XlwMenuWidget mw;
+ XMotionEvent* ev;
+ int level;
+ 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
-map_event_to_widget_value (XlwMenuWidget mw, XMotionEvent* ev,
- widget_value** val, int* level)
+map_event_to_widget_value (mw, ev, val, level)
+ XlwMenuWidget mw;
+ XMotionEvent* ev;
+ widget_value** val;
+ int* level;
{
int i;
XPoint relative_pos;
window_state* ws;
*val = NULL;
-
+
/* Find the window */
for (i = mw->menu.old_depth - 1; i >= 0; i--)
{
\f/* Procedures */
static void
-make_drawing_gcs (XlwMenuWidget mw)
+make_drawing_gcs (mw)
+ XlwMenuWidget mw;
{
XGCValues xgcv;
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;
mw->menu.inactive_gc = XtGetGC ((Widget)mw,
(GCFont | GCForeground | GCBackground
| GCFillStyle | GCStipple), &xgcv);
-
+
xgcv.font = mw->menu.font->fid;
xgcv.foreground = mw->menu.button_foreground;
xgcv.background = mw->core.background_pixel;
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;
}
static void
-release_drawing_gcs (XlwMenuWidget mw)
+release_drawing_gcs (mw)
+ XlwMenuWidget mw;
{
XtReleaseGC ((Widget) mw, mw->menu.foreground_gc);
XtReleaseGC ((Widget) mw, mw->menu.button_gc);
? ((unsigned long) (x)) : ((unsigned long) (y)))
static void
-make_shadow_gcs (XlwMenuWidget mw)
+make_shadow_gcs (mw)
+ XlwMenuWidget 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;
}
}
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;
+ }
}
}
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;
}
static void
-release_shadow_gcs (XlwMenuWidget mw)
+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);
}
static void
-XlwMenuInitialize (Widget request, Widget new, ArgList args,
- Cardinal *num_args)
+XlwMenuInitialize (request, mw, args, num_args)
+ Widget request;
+ XlwMenuWidget mw;
+ ArgList args;
+ Cardinal *num_args;
{
/* Get the GCs and the widget size */
- XlwMenuWidget mw = (XlwMenuWidget)new;
-
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));
+
+ /* _XtCreate is freeing the object that was passed to us,
+ so make a copy that we will actually keep. */
+ lwlib_bcopy (mw->menu.contents, tem, sizeof (widget_value));
+ mw->menu.contents = tem;
+#endif
+
/* 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, 1, 0, 1);
-
+
+ mw->menu.gray_pixmap
+ = 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. */
+ if (mw->menu.font == 0)
+ mw->menu.font = xlwmenu_default_font;
+
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;
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;
}
}
static void
-XlwMenuRealize (Widget w, Mask *valueMask, XSetWindowAttributes *attributes)
+XlwMenuRealize (w, valueMask, attributes)
+ Widget w;
+ Mask *valueMask;
+ XSetWindowAttributes *attributes;
{
XlwMenuWidget mw = (XlwMenuWidget)w;
XSetWindowAttributes xswa;
/* 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
-XlwMenuRedisplay (Widget w, XEvent* ev, Region region)
+static void
+XlwMenuRedisplay (w, ev, region)
+ Widget w;
+ XEvent* ev;
+ Region region;
{
XlwMenuWidget mw = (XlwMenuWidget)w;
int i;
+ /* If we have a depth beyond 1, it's because a submenu was displayed.
+ If the submenu has been destroyed, set the depth back to 1. */
+ if (submenu_destroyed)
+ {
+ mw->menu.old_depth = 1;
+ submenu_destroyed = 0;
+ }
+
for (i = 0; i < mw->menu.old_depth; i++)
display_menu (mw, i, False, NULL, NULL, NULL, NULL, NULL);
}
-static void
-XlwMenuDestroy (Widget w)
+
+/* 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;
{
int i;
XlwMenuWidget mw = (XlwMenuWidget) w;
+ if (pointer_grabbed)
+ XtUngrabPointer ((Widget)w, CurrentTime);
+ pointer_grabbed = 0;
+
+ submenu_destroyed = 1;
+
release_drawing_gcs (mw);
release_shadow_gcs (mw);
XFreePixmap (XtDisplay (mw), mw->menu.gray_pixmap);
mw->menu.gray_pixmap = (Pixmap) -1;
+#if 0
+ /* Do free mw->menu.contents because nowadays we copy it
+ during initialization. */
+ XtFree (mw->menu.contents);
+#endif
+
/* Don't free mw->menu.contents because that comes from our creator.
The `*_stack' elements are just pointers into `contents' so leave
that alone too. But free the stacks themselves. */
XtFree ((char *) mw->menu.windows);
}
-static Boolean
-XlwMenuSetValues (Widget current, Widget request, Widget new)
+static Boolean
+XlwMenuSetValues (current, request, new)
+ Widget current;
+ Widget request;
+ Widget new;
{
XlwMenuWidget oldmw = (XlwMenuWidget)current;
XlwMenuWidget newmw = (XlwMenuWidget)new;
&& newmw->menu.contents->contents
&& newmw->menu.contents->contents->change >= VISIBLE_CHANGE)
redisplay = True;
+ /* Do redisplay if the contents are entirely eliminated. */
+ if (newmw->menu.contents
+ && newmw->menu.contents->contents == 0
+ && newmw->menu.contents->change >= VISIBLE_CHANGE)
+ redisplay = True;
if (newmw->core.background_pixel != oldmw->core.background_pixel
- || newmw->menu.foreground != oldmw->menu.foreground)
+ || newmw->menu.foreground != oldmw->menu.foreground
+ || newmw->menu.font != oldmw->menu.font)
{
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
-XlwMenuResize (Widget w)
+static void
+XlwMenuResize (w)
+ Widget w;
{
XlwMenuWidget mw = (XlwMenuWidget)w;
- mw->menu.windows [0].width = mw->core.width;
- mw->menu.windows [0].height = mw->core.height;
+ if (mw->menu.popped_up)
+ {
+ /* Don't allow the popup menu to resize itself. */
+ mw->core.width = mw->menu.windows [0].width;
+ mw->core.height = mw->menu.windows [0].height;
+ mw->core.parent->core.width = mw->core.width ;
+ mw->core.parent->core.height = mw->core.height ;
+ }
+ else
+ {
+ mw->menu.windows [0].width = mw->core.width;
+ mw->menu.windows [0].height = mw->core.height;
+ }
}
\f/* Action procedures */
static void
-handle_single_motion_event (XlwMenuWidget mw, XMotionEvent* ev)
+handle_single_motion_event (mw, ev)
+ XlwMenuWidget mw;
+ XMotionEvent* ev;
{
widget_value* val;
int level;
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);
}
static void
-handle_motion_event (XlwMenuWidget mw, XMotionEvent* ev)
+handle_motion_event (mw, ev)
+ XlwMenuWidget mw;
+ XMotionEvent* ev;
{
int x = ev->x_root;
int y = ev->y_root;
handle_single_motion_event (mw, ev);
}
-static void
-Start (Widget w, XEvent *ev, String *params, Cardinal *num_params)
+static void
+Start (w, ev, params, num_params)
+ Widget w;
+ XEvent *ev;
+ String *params;
+ Cardinal *num_params;
{
XlwMenuWidget mw = (XlwMenuWidget)w;
- XtCallCallbackList ((Widget)mw, mw->menu.open, NULL);
-
- /* notes the absolute position of the menubar window */
- mw->menu.windows [0].x = ev->xmotion.x_root - ev->xmotion.x;
- mw->menu.windows [0].y = ev->xmotion.y_root - ev->xmotion.y;
+ if (!mw->menu.popped_up)
+ {
+ menu_post_event = *ev;
+ pop_up_menu (mw, (XButtonPressedEvent*) ev);
+ }
+ else
+ {
+ /* If we push a button while the menu is posted semipermanently,
+ releasing the button should always pop the menu down. */
+ next_release_must_exit = 1;
+
+ /* notes the absolute position of the menubar window */
+ mw->menu.windows [0].x = ev->xmotion.x_root - ev->xmotion.x;
+ mw->menu.windows [0].y = ev->xmotion.y_root - ev->xmotion.y;
- /* handles the down like a move, slots are compatible */
- handle_motion_event (mw, &ev->xmotion);
+ /* handles the down like a move, slots are compatible */
+ handle_motion_event (mw, &ev->xmotion);
+ }
}
-static void
-Drag (Widget w, XEvent *ev, String *params, Cardinal *num_params)
+static void
+Drag (w, ev, params, num_params)
+ Widget w;
+ XEvent *ev;
+ String *params;
+ Cardinal *num_params;
{
XlwMenuWidget mw = (XlwMenuWidget)w;
- handle_motion_event (mw, &ev->xmotion);
+ if (mw->menu.popped_up)
+ handle_motion_event (mw, &ev->xmotion);
}
-static void
-Select (Widget w, XEvent *ev, String *params, Cardinal *num_params)
+/* Do nothing.
+ This is how we handle presses and releases of modifier keys. */
+static void
+Nothing (w, ev, params, num_params)
+ Widget w;
+ XEvent *ev;
+ String *params;
+ Cardinal *num_params;
+{
+}
+
+/* Handle key press and release events while menu is popped up.
+ Our action is to get rid of the menu. */
+static void
+Key (w, ev, params, num_params)
+ Widget w;
+ XEvent *ev;
+ String *params;
+ Cardinal *num_params;
+{
+ XlwMenuWidget mw = (XlwMenuWidget)w;
+
+ /* Pop down everything. */
+ mw->menu.new_depth = 1;
+ remap_menubar (mw);
+
+ if (mw->menu.popped_up)
+ {
+ mw->menu.popped_up = False;
+ XtUngrabPointer ((Widget)mw, ev->xmotion.time);
+ if (XtIsShell (XtParent ((Widget) mw)))
+ XtPopdown (XtParent ((Widget) mw));
+ else
+ {
+ XtRemoveGrab ((Widget) mw);
+ display_menu (mw, 0, False, NULL, NULL, NULL, NULL, NULL);
+ }
+ }
+
+ /* callback */
+ XtCallCallbackList ((Widget)mw, mw->menu.select, (XtPointer)0);
+}
+
+static void
+Select (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];
-
- /* pop down everything */
+
+ /* If user releases the button quickly, without selecting anything,
+ after the initial down-click that brought the menu up,
+ do nothing. */
+ if ((selected_item == 0
+ || ((widget_value *) selected_item)->call_data == 0)
+ && !next_release_must_exit
+ && (ev->xbutton.time - menu_post_event.xbutton.time
+ < XtGetMultiClickTime (XtDisplay (w))))
+ return;
+
+ /* pop down everything. */
mw->menu.new_depth = 1;
remap_menubar (mw);
{
mw->menu.popped_up = False;
XtUngrabPointer ((Widget)mw, ev->xmotion.time);
- XtPopdown (XtParent (mw));
+ if (XtIsShell (XtParent ((Widget) mw)))
+ XtPopdown (XtParent ((Widget) mw));
+ else
+ {
+ XtRemoveGrab ((Widget) mw);
+ display_menu (mw, 0, False, NULL, NULL, NULL, NULL, NULL);
+ }
}
/* callback */
XtCallCallbackList ((Widget)mw, mw->menu.select, (XtPointer)selected_item);
-
}
\f/* Special code to pop-up a menu */
void
-pop_up_menu (XlwMenuWidget mw, XButtonPressedEvent* event)
+pop_up_menu (mw, event)
+ XlwMenuWidget mw;
+ XButtonPressedEvent* event;
{
int x = event->x_root;
int y = event->y_root;
int h;
int borderwidth = mw->menu.shadow_thickness;
Screen* screen = XtScreen (mw);
+ Display *display = XtDisplay (mw);
+ int count;
+
+ next_release_must_exit = 0;
XtCallCallbackList ((Widget)mw, mw->menu.open, NULL);
- size_menu (mw, 0);
+ if (XtIsShell (XtParent ((Widget)mw)))
+ size_menu (mw, 0);
w = mw->menu.windows [0].width;
h = mw->menu.windows [0].height;
y = HeightOfScreen (screen) - h - 2 * borderwidth;
mw->menu.popped_up = True;
- XtConfigureWidget (XtParent (mw), x, y, w, h,
- XtParent (mw)->core.border_width);
- XtPopup (XtParent (mw), XtGrabExclusive);
- display_menu (mw, 0, False, NULL, NULL, NULL, NULL, NULL);
+ if (XtIsShell (XtParent ((Widget)mw)))
+ {
+ XtConfigureWidget (XtParent ((Widget)mw), x, y, w, h,
+ XtParent ((Widget)mw)->core.border_width);
+ XtPopup (XtParent ((Widget)mw), XtGrabExclusive);
+ display_menu (mw, 0, False, NULL, NULL, NULL, NULL, NULL);
+ mw->menu.windows [0].x = x + borderwidth;
+ mw->menu.windows [0].y = y + borderwidth;
+ }
+ else
+ {
+ XEvent *ev = (XEvent *) event;
+
+ XtAddGrab ((Widget) mw, True, True);
+
+ /* notes the absolute position of the menubar window */
+ mw->menu.windows [0].x = ev->xmotion.x_root - ev->xmotion.x;
+ mw->menu.windows [0].y = ev->xmotion.y_root - ev->xmotion.y;
+ }
+
+#ifdef emacs
+ count = x_catch_errors (display);
+#endif
XtGrabPointer ((Widget)mw, False,
- (ButtonMotionMask | PointerMotionHintMask | ButtonReleaseMask
+ (PointerMotionMask
+ | PointerMotionHintMask
+ | ButtonReleaseMask
| ButtonPressMask),
- GrabModeAsync, GrabModeAsync, None, mw->menu.cursor_shape,
+ GrabModeAsync, GrabModeAsync, None,
+ mw->menu.cursor_shape,
event->time);
-
- mw->menu.windows [0].x = x + borderwidth;
- mw->menu.windows [0].y = y + borderwidth;
+ pointer_grabbed = 1;
+#ifdef emacs
+ if (x_had_errors_p (display))
+ {
+ pointer_grabbed = 0;
+ XtUngrabPointer ((Widget)mw, event->time);
+ }
+ x_uncatch_errors (display, count);
+#endif
handle_motion_event (mw, (XMotionEvent*)event);
}