xemacs-beta: lwlib/xlwmenu.c comparison

comparison lwlib/xlwmenu.c @ 183:e121b013d1f0 r20-3b18

Import from CVS: tag r20-3b18

author	cvs
date	Mon, 13 Aug 2007 09:54:23 +0200
parents	bfd6434d15b3
children	3d6bfa290dbd

comparison

equal deleted inserted replaced

-:f07455f06202
+:e121b013d1f0
 /* Implements a lightweight menubar widget.
 Copyright (C) 1992, 1993, 1994 Lucid, Inc.
 Copyright (C) 1995 Tinker Systems and INS Engineering Corp.
 This file is part of the Lucid Widget Library.
 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
 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 XEmacs; see the file COPYING.  If not, write to
 /* simple, naieve integer maximum */
 #ifndef max
 #define max(a,b) ((a)>(b)?(a):(b))
 #endif
 static char
 xlwMenuTranslations [] =
 "<BtnDown>:	start()\n\
 <BtnMotion>:	drag()\n\
 <BtnUp>:	select()\n\
 ";
 extern Widget lw_menubar_widget;
 #define offset(field) XtOffset(XlwMenuWidget, field)
 static XtResource
 xlwMenuResources[] =
 {
 #ifdef NEED_MOTIF
 /* There are three font list resources, so that we can accept either of
 the resources *fontList: or *font:, and so that we can tell the
 difference between them being specified, and being defaulted to a
 font from the XtRString specified here. */
 {XmNtopShadowPixmap, XmCTopShadowPixmap, XtRPixmap, sizeof (Pixmap),
 offset (menu.top_shadow_pixmap), XtRImmediate, (XtPointer)None},
 {XmNbottomShadowPixmap, XmCBottomShadowPixmap, XtRPixmap, sizeof (Pixmap),
 offset (menu.bottom_shadow_pixmap), XtRImmediate, (XtPointer)None},
 {XtNopen, XtCCallback, XtRCallback, sizeof(XtPointer),
 offset(menu.open), XtRCallback, (XtPointer)NULL},
 {XtNselect, XtCCallback, XtRCallback, sizeof(XtPointer),
 offset(menu.select), XtRCallback, (XtPointer)NULL},
 {XtNmenu, XtCMenu, XtRPointer, sizeof(XtPointer),
 offset(menu.contents), XtRImmediate, (XtPointer)NULL},
 {XtNcursor, XtCCursor, XtRCursor, sizeof(Cursor),
 offset(menu.cursor_shape), XtRString, (XtPointer) "right_ptr"},
 #ifdef NEED_MOTIF
 static XFontStruct *default_font_of_font_list (XmFontList);
 #endif
 static XtActionsRec
 xlwMenuActionsList [] =
 {
 {"start",	Start},
 {"drag",	Drag},
 {"select",	Select},
 #define SuperClass ((CoreWidgetClass)&coreClassRec)
 XlwMenuClassRec xlwMenuClassRec =
 {
 {  /* CoreClass fields initialization */
 (WidgetClass) SuperClass,		/* superclass		  */
 "XlwMenu",				/* class_name		  */
 sizeof(XlwMenuRec),			/* size			  */
 XlwMenuClassInitialize,		/* class_initialize	  */
 NULL,				/* class_part_initialize  */
 FALSE,				/* class_inited		  */
 }
 else if (mw->menu.old_stack_length < n)
 {
 while (mw->menu.old_stack_length < n)
 mw->menu.old_stack_length *= 2;
 mw->menu.old_stack =
 	(widget_value**)XtRealloc ((char *)mw->menu.old_stack,
 				   mw->menu.old_stack_length *
 				   sizeof (widget_value*));
 }
 	  if (!*(in-1))		/* Overshot the NULL byte? */
 	    break;
 	}
 }
 *out = 0;
 #ifdef PRINT_XLWMENU_RESOURCE_CONVERSIONS
 printf("! Emacs*XlwMenu.%s.labelString:\t%s\n", save_out, save_in);
 printf(  "Emacs*XlwMenu.%s.labelString:\n",     save_out);
 #endif
 }
 static XtResource
 nameResource[] =
 {
 { "labelString", "LabelString", XtRString, sizeof(String),
 0, XtRImmediate, 0 }
 };
 /*
 value = "";
 for (ntimes = 1, result = (char *) string; (percent = strchr(result, '%'));
 ntimes++)
 result = &percent[1];
 result = XtMalloc ((ntimes * strlen(value)) + strlen(string) + 4);
 result[0] = '\0';
 while ((percent = strchr(string, '%')))
 {
 unsigned left_pad;
 unsigned right_pad;
 char *p;
 if (percent[1] == '%')
 	{	/* it's a real % */
 	  strncat(result, string, 1 + percent - string); /* incl % */
 	  string = &percent[2];	/* after the second '%' */
 	  continue;		/* with the while() loop */
 	}
 left_pad = 0;
 right_pad = 0;
 for (p = &percent[1]; /* test *p inside the loop */ ; p++)
 	{
 	  else
 	    {			/* bogus, copy the format as is */
 				/* out of for() loop */
 	      strncat(result, string, 1 + p - string);
 	      string= (*p ? &p[1] : p);
 	      break;
 	    }
 	}
 }
 /*
 if (mw->menu.lookup_labels)
 	{
 	  /* Convert value style name into resource style name.
 	     eg: "Free Willy" becomes "freeWilly" */
 	  massage_resource_name (val->name, massaged_name);
 	  /* If we have a value (parameter) see if we can find a "Named"
 	     resource. */
 	  if (val->value)
 	    {
 	      char named_name[1024];
 char massaged_name [1024];
 if (mw->menu.lookup_labels)
 	{
 	  massage_resource_name (val->name, massaged_name);
 	  XtGetSubresources ((Widget) mw,
 			     (XtPointer) &resourced_name,
 			     massaged_name, massaged_name,
 			     nameResource, 1, NULL, 0);
 	}
 			   x, y + mw->menu.font_ascent, &string[s], i-s);
 # else
 	  XDrawString (XtDisplay (mw), window, gc,
 		       x, y + mw->menu.font_ascent, &string[s], i-s);
 # endif /* USE_XFONTSET */
 	  XTextExtents (mw->menu.font, &string[s], i-s, &drop, &drop, &drop,
 			&xcs);
 	  x += xcs.width;
 	  s=i+3;
 	  i+=2;
 # ifdef USE_XFONTSET
 	  XmbDrawString (XtDisplay (mw), window, mw->menu.font_set, gc,
 			 x, y + mw->menu.font_ascent, &string[i], 1);
 # else
 	  XDrawString (XtDisplay (mw), window, gc,
 		       x, y + mw->menu.font_ascent, &string[i], 1);
 # endif /* USE_XFONTSET */
 	  XTextExtents (mw->menu.font, &string[i], 1, &drop, &drop, &drop,
 			&xcs);
 	  XDrawLine (XtDisplay (mw), window, gc, x - 1,
 		     y + mw->menu.font_ascent + 1,
 		     x + xcs.width - 1, y + mw->menu.font_ascent + 1 );
 	  x += xcs.width;
 }
 }
 if (string[s])
 # ifdef USE_XFONTSET
 XmbDrawString (XtDisplay (mw), window, mw->menu.font_set, gc,
 		   x, y + mw->menu.font_ascent, &string[s],
 		   strlen (&string[s]));
 # else
 	       strlen (&string[s]));
 # endif /* USE_XFONTSET */
 #endif /* NEED_MOTIF */
 }
 static void
 binding_draw (XlwMenuWidget mw, Window w, int x, int y, GC gc, char *value)
 {
 #ifdef NEED_MOTIF
 XmString xm_value = XmStringCreateLtoR(value, XmSTRING_DEFAULT_CHARSET);
 string_draw (mw, w, x, y, gc, xm_value);
 			     width, height,
 			     thickness);
 }
 }
 static void
 arrow_decoration_draw (XlwMenuWidget mw,
 		       Window window,
 		       int x, int y,
 		       unsigned width,
 		       Boolean raised)
 if (width & 0x1)
 half_width = width/2 + 1;
 else
 half_width = width/2;
 select_gc = mw->menu.background_gc;
 if (raised)
 {
 top_gc    = mw->menu.shadow_bottom_gc;
 bottom_gc = mw->menu.shadow_top_gc;
 }
 points [1].y = y + half_width;
 points [2].x = x + length - thickness;
 points [2].y = y + half_width + thickness;
 points [3].x = x + thickness;
 points [3].y = y + width - thickness;
 XFillPolygon (dpy,
 		window,
 		select_gc,
 		points,
 		4,
 		Convex,
 		CoordModeOrigin);
 /* left border */
 points [0].x = x;
 points [1].y = y + thick_med;
 points [2].x = x + thickness;
 points [2].y = y + width - thick_med;
 points [3].x = x;
 points [3].y = y + width;
 XFillPolygon (dpy, window, top_gc, points, 4, Convex, CoordModeOrigin);
 /* top border */
 points [0].x = x;
 points [0].y = y + width;
 points [1].y = y + half_width;
 points [2].x = x + length - (thickness + thickness);
 points [2].y = y + half_width;
 points [3].x = x + thickness;
 points [3].y = y + width - thick_med;
 XFillPolygon (dpy, window, bottom_gc, points, 4, Convex, CoordModeOrigin);
 /* bottom shadow */
 points [0].x = x;
 points [0].y = y;
 points [1].y = y + half_width;
 points [2].x = x + length - (thickness + thickness);
 points [2].y = y + half_width;
 points [3].x = x + thickness;
 points [3].y = y + thick_med;
 XFillPolygon (dpy, window, top_gc, points, 4, Convex, CoordModeOrigin);
 }
 static void
 toggle_decoration_draw (XlwMenuWidget mw,
 type = SHADOW_OUT;
 /*
 *    Fill internal area.
 */
 if (set)
 XFillRectangle (dpy,
 		    window,
 		    select_gc,
 		    x + thickness,
 		    y + thickness,
 		    width - (2*thickness),
 		    width - (2*thickness));
 shadow_draw(mw, window, x, y, width, width, type);
 }
 static void
 radio_decoration_draw (XlwMenuWidget mw,
 points [npoints].x = x + half_width; /* bottom inside corner */
 points [npoints++].y = y + width - thickness;
 points [npoints].x = x + thickness; /* left inside corner */
 points [npoints++].y = y + half_width;
 XFillPolygon (dpy, window, bottom_gc,
 		points, npoints, Nonconvex, CoordModeOrigin);
 npoints = 0;
 points [npoints].x = x; /* left corner */
 points [3].y = y + width - thickness;
 XFillPolygon (dpy,
 		    window,
 		    select_gc,
 		    points,
 		    4,
 		    Convex,
 		    CoordModeOrigin);
 }
 }
 int i;
 switch (type)
 {
 case SHADOW_NO_LINE: /* nothing to do */
 return;
 case SHADOW_DOUBLE_LINE:
 num_separators = 2;
 case SHADOW_SINGLE_LINE:
 top_gc = bottom_gc = mw->menu.foreground_gc;
 top_line_thickness = 1;
 bottom_gc = mw->menu.shadow_top_gc;
 top_line_thickness = mw->menu.shadow_thickness/2;
 bottom_line_thickness = mw->menu.shadow_thickness - top_line_thickness;
 break;
 }
 if (dashed)
 {
 XGCValues values;
 values.line_style = LineOnOffDash;
 if (top_line_thickness > 0)
 	XChangeGC (dpy, top_gc, GCLineStyle, &values);
 if (bottom_line_thickness > 0 && bottom_gc != top_gc)
 	XChangeGC (dpy, bottom_gc, GCLineStyle, &values);
 }
 while (num_separators--)
 {
 for (i = 0; i < top_line_thickness; i++)
 	XDrawLine (dpy, window, top_gc, x, y + i, x + width, y + i);
 for (i = 0; i < bottom_line_thickness; i++)
 	XDrawLine (dpy, window, bottom_gc,
 		   x, y + top_line_thickness + offset + i,
 		   x + width, y + top_line_thickness + offset + i);
 y += (top_line_thickness + offset + bottom_line_thickness + 1);
 }
 	return CASCADE_TYPE;
 else if (val->call_data) /* push button */
 	return BUTTON_TYPE;
 else
 	return TEXT_TYPE;
 #else
 abort();
 #endif
 }
 }
 static void
 label_button_size (XlwMenuWidget mw,
 *height = (mw->menu.font_ascent + mw->menu.font_descent +
 	     2 * mw->menu.vertical_margin +
 	     2 * mw->menu.shadow_thickness);
 /* no left column decoration */
 *toggle_width = mw->menu.horizontal_margin + mw->menu.shadow_thickness;;
 *label_width  = string_width_u (mw, resource_widget_value (mw, val));
 *bindings_width =  mw->menu.horizontal_margin + mw->menu.shadow_thickness;
 }
 static void
 		   unsigned height,
 		   unsigned label_offset,
 		   unsigned binding_tab)
 {
 int y_offset = mw->menu.shadow_thickness + mw->menu.vertical_margin;
 if (!label_offset)
 label_offset = mw->menu.shadow_thickness + mw->menu.horizontal_margin;
 /*
 *    Draw the label string.
 */
 string_draw_u (mw,
 	       window,
 	       x + label_offset, y + y_offset,
 	       mw->menu.foreground_gc,
 	       resource_widget_value (mw, val));
 }
 static void
 {
 /* inherit */
 label_button_size (mw, val, in_menubar,
 		     toggle_width, label_width, bindings_width,
 		     height);
 /* key bindings to display? */
 if (!in_menubar && val->key)
 {
 int w;
 #ifdef NEED_MOTIF
 static void
 push_button_draw (XlwMenuWidget mw,
 		  widget_value *val,
 		  Boolean       in_menubar,
 		  Boolean       highlighted,
 		  Window        window,
 		  int x, int y,
 		  unsigned width, unsigned height,
 		  unsigned      label_offset,
 		  unsigned      binding_offset)
 {
 int y_offset = mw->menu.shadow_thickness + mw->menu.vertical_margin;
 GC gc;
 shadow_type type;
 Boolean menu_pb = in_menubar && (menu_item_type (val) == BUTTON_TYPE);
 /*
 *    Draw the label string.
 */
 if (!label_offset)
 label_offset = mw->menu.shadow_thickness + mw->menu.horizontal_margin;
 if (menu_pb)
 {
 if (val->enabled)
 	gc = mw->menu.button_gc;
 else
 	gc = mw->menu.inactive_gc;
 }
 string_draw_u (mw,
 	       window,
 	       x + label_offset, y + y_offset,
 	       gc,
 	       resource_widget_value(mw, val));
 /*
 *    Draw the keybindings
 */
 if (val->key)
 {
 	}
 binding_draw (mw, window,
 		    x + binding_offset + mw->menu.column_spacing,
 		    y + y_offset, gc, val->key);
 }
 /*
 *    Draw the shadow
 */
 if (menu_pb)
 {
 if (highlighted)
 	type = SHADOW_OUT;
 else
 	type = (val->selected ? SHADOW_ETCHED_OUT : SHADOW_ETCHED_IN);
 }
 else
 {
 if (highlighted)
 	type = SHADOW_OUT;
 else
 	type = SHADOW_BACKGROUND;
 }
 shadow_draw (mw, window, x, y, width, height, type);
 }
 static unsigned int
 arrow_decoration_height (XlwMenuWidget mw)
 {
 unsigned int result =
 (mw->menu.font_ascent + mw->menu.font_descent) / (unsigned int)2;
 result += 2 * mw->menu.shadow_thickness;
 if (result > (mw->menu.font_ascent + mw->menu.font_descent))
 result = mw->menu.font_ascent + mw->menu.font_descent;
 *arrow_width += arrow_decoration_height(mw) + mw->menu.column_spacing;
 }
 }
 static void
 cascade_button_draw (XlwMenuWidget mw,
 		     widget_value *val,
 		     Boolean       in_menubar,
 		     Boolean       highlighted,
 		     Window        window,
 		     int x, int y,
 		     unsigned width, unsigned height,
 		     unsigned      label_offset,
 		     unsigned      binding_offset)
 {
 shadow_type type;
 */
 if (!in_menubar && val->contents)
 {
 int y_offset;
 unsigned arrow_height = arrow_decoration_height (mw);
 y_offset = mw->menu.shadow_thickness + mw->menu.vertical_margin +
 	(mw->menu.font_ascent+mw->menu.font_descent - arrow_height)/2;
 if (!binding_offset)
 	{
 	  unsigned s_width = string_width(mw, resource_widget_value (mw, val));
 	  if (!label_offset)
 	    label_offset = mw->menu.shadow_thickness +
 	      mw->menu.horizontal_margin;
 	  binding_offset = label_offset + s_width +  mw->menu.shadow_thickness;
 	}
 arrow_decoration_draw (mw,
 			     window,
 			     x + binding_offset + mw->menu.column_spacing,
 			     y + y_offset,
 			     arrow_height,
 			     highlighted);
 }
 /*
 *    Draw the shadow
 */
 if (highlighted)
 type = SHADOW_OUT;
 else
 type = SHADOW_BACKGROUND;
 shadow_draw(mw, window, x, y, width, height, type);
 }
 static unsigned
 toggle_decoration_height(XlwMenuWidget mw)
 unsigned rv;
 if (mw->menu.indicator_size > 0)
 rv = mw->menu.indicator_size;
 else
 rv = mw->menu.font_ascent;
 if (rv > (mw->menu.font_ascent+mw->menu.font_descent))
 rv = mw->menu.font_ascent+mw->menu.font_descent;
 return rv;
 }
 static void
 toggle_button_size (XlwMenuWidget mw,
 static void
 toggle_button_draw (XlwMenuWidget mw,
 		    widget_value *val,
 		    Boolean       in_menubar,
 		    Boolean highlighted,
 		    Window        window,
 		    int x, int y,
 		    unsigned width, unsigned height,
 		    unsigned      label_tab,
 		    unsigned      binding_tab)
 {
 int x_offset;
 int y_offset;
 unsigned t_height = toggle_decoration_height(mw);
 /*
 *    Draw a toggle.
 */
 x_offset = mw->menu.shadow_thickness + mw->menu.horizontal_margin;
 y_offset = mw->menu.shadow_thickness + mw->menu.vertical_margin;
 y_offset += (mw->menu.font_ascent + mw->menu.font_descent - t_height)/2;
 toggle_decoration_draw (mw, window, x + x_offset, y + y_offset,
 			  t_height, val->selected);
 /*
 *    Draw the pushbutton parts.
 {
 return toggle_decoration_height(mw);
 }
 static void
 radio_button_draw (XlwMenuWidget mw,
 		   widget_value *val,
 		   Boolean       in_menubar,
 		   Boolean       highlighted,
 		   Window        window,
 		   int x, int y,
 		   unsigned width, unsigned height,
 		   unsigned      label_tab,
 		   unsigned      binding_tab)
 {
 int x_offset;
 int y_offset;
 unsigned r_height = radio_decoration_height(mw);
 /*
 *    Draw a toggle.
 */
 x_offset = mw->menu.shadow_thickness + mw->menu.horizontal_margin;
 y_offset = mw->menu.shadow_thickness + mw->menu.vertical_margin;
 *label_width = 1;
 *toggle_width = *rest_width = 0;
 }
 static void
 separator_draw (XlwMenuWidget mw,
 		widget_value *val,
 		Boolean       in_menubar,
 		Boolean       highlighted,
 		Window        window,
 		int x, int y,
 		unsigned width, unsigned height,
 		unsigned      label_tab,
 		unsigned      binding_tab)
 {
 unsigned sep_width;
 		   XPoint *where,
 		   Boolean highlighted,
 		   Boolean horizontal,
 		   Boolean just_compute)
 {
 int x = where->x /* + mw->menu.shadow_thickness */ ;
 int y = where->y /* + mw->menu.shadow_thickness */ ;
 unsigned toggle_width;
 unsigned label_width;
 unsigned binding_width;
 unsigned binding_tab;
 void (*function_ptr) (XlwMenuWidget _mw,
 			widget_value *_val,
 			Boolean _in_menubar,
 			Boolean _highlighted,
 			Window        _window,
 			int _x, int _y,
 			unsigned _width, unsigned _height,
 			unsigned      _label_tab,
 			unsigned      _binding_tab);
 size_menu_item (mw, val, horizontal,
 {
 width = ws->width - 2 * mw->menu.shadow_thickness;
 toggle_width = ws->toggle_width;
 label_width = ws->label_width;
 }
 where->x += width;
 where->y += height;
 if (just_compute)
 return;
 label_tab = toggle_width;
 binding_tab = toggle_width + label_width;
 switch (menu_item_type (val))
 {
 (*function_ptr) (mw,
 		   val,
 		   horizontal,
 		   highlighted,
 		   ws->window,
 		   x, y,
 		   width, height,
 		   label_tab,
 		   binding_tab);
 }
 window_state*	ws;
 if (level >= mw->menu.old_depth)
 abort ();
 ws = &mw->menu.windows [level];
 for (val = mw->menu.old_stack [level]->contents; val; val = val->next)
 {
 size_menu_item (mw,
 		      val,
 	  if (max_rest_width < rest_width)
 	      max_rest_width = rest_width;
 	  max_height += height;
 	}
 }
 ws->height = max_height;
 ws->width = max_label_width + max_rest_width + max_toggle_width;
 ws->toggle_width = max_toggle_width;
 ws->label_width  = max_label_width;
 if (level >= mw->menu.old_depth)
 abort ();
 if (level < mw->menu.old_depth - 1)
 following_item = mw->menu.old_stack [level + 1];
 else
 {
 if (lw_menu_accelerate
 	  && level == mw->menu.old_depth - 1
 	  && mw->menu.old_stack [level]->type == CASCADE_TYPE)
 	just_compute_p = True;
 }
 #if SLOPPY_TYPES == 1
 puts("===================================================================");
 print_widget_value (following_item, 1, 0);
 #endif
 if (following_item
 && following_item->type == CASCADE_TYPE
 && following_item->contents
 && following_item->contents->type == INCREMENTAL_TYPE)
 {
 			  mw->menu.open,
 			  (XtPointer)following_item->contents);
 #if SLOPPY_TYPES == 1
 puts("==== NEW ==== NEW ==== NEW ==== NEW ==== NEW ==== NEW ==== NEW ====");
 print_widget_value(following_item, 1, 0);
 #endif
 }
 if (hit)
 *hit_return = NULL;
 	  if (horizontal_p)
 	    highlighted_pos->x = where.x;
 	  else
 	    highlighted_pos->y = where.y;
 	}
 just_compute_this_one_p =
 	just_compute_p || ((this || that) && val != this &&  val != that);
 start.x = where.x;
 start.y = where.y;
 /* Motion code */
 static void
 set_new_state (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]);
 if (val)
 push_new_stack (mw, val);
 XSetWindowAttributes xswa;
 int mask;
 #define ROOT_PARENT
 #ifdef ROOT_PARENT
 Window root = RootWindowOfScreen (DefaultScreenOfDisplay (XtDisplay (mw)));
 #endif
 window_state *windows;
 if (mw->menu.windows_length >= n)
 return;
 xswa.save_under = True;
 xswa.override_redirect = True;
 if (mw->menu.use_backing_store)
 {
 xswa.backing_store = Always;
 mask |= CWBackingStore;
 }
 if (!mw->menu.windows)
 {
 mw->menu.windows =
 	(window_state *) XtMalloc (n * sizeof (window_state));
 start_at = 0;
 windows [i].height = 1;
 windows [i].window =
 XCreateWindow (XtDisplay (mw),
 #ifdef ROOT_PARENT
 		      root,
 #else
 		      ((i >  0)
 		       ? windows[0].window
 		       : XtWindow (XtParent (mw))),
 #endif
 		      0, 0, 1, 1,
 		      0, 0, CopyFromParent, CopyFromParent, mask, &xswa);
 }
 }
 if (lw_menu_accelerate
 && last_same
 && last_same == old_depth - 1
 && old_stack [last_same]->contents)
 last_same--;
 /* Memorize the previously selected item to be able to refresh it */
 old_selection = last_same + 1 < old_depth ? old_stack [last_same + 1] : NULL;
 if (old_selection && !old_selection->enabled)
 old_selection = NULL;
 new_selection = last_same + 1 < new_depth ? new_stack [last_same + 1] : NULL;
 /* 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 */
 selection_position.x = 0;
 selection_position.y = 0;
 window_state *previous_ws = &windows [i - 1];
 window_state *ws = &windows [i];
 if (lw_menu_accelerate && i == new_depth - 1)
 	break;
 ws->x = previous_ws->x + selection_position.x;
 ws->y = previous_ws->y + selection_position.y;
 /* take into account the slab around the new menu */
 ws->y -= mw->menu.shadow_thickness;
 XMapRaised (XtDisplay (mw), ws->window);
 display_menu (mw, i, False, &selection_position, NULL, NULL, NULL, NULL);
 }
 /* unmap the menus that popped down */
 last_same = new_depth;
 if (lw_menu_accelerate
 && last_same > 1
 && new_stack [last_same - 1]->contents)
 last_same--;
 for (i = last_same - 1; i < old_depth; i++)
 if (i >= last_same || !new_stack [i]->contents)
 XUnmapWindow (XtDisplay (mw), windows [i].window);
 }
 XPoint	relative_pos;
 window_state*	ws;
 *val_ptr = NULL;
 *inside_menu = False;
 /* Find the window */
 #if 1
 for (i = mw->menu.old_depth - 1; i >= 0; i--)
 #else
 for (i = 0; i <= mw->menu.old_depth - 1; i++)
 	    xgcv.foreground = xcolor.pixel;
 	}
 }
 xgcv.background = mw->core.background_pixel;
 mw->menu.select_gc = XtGetGC ((Widget)mw, flags, &xgcv);
 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,
 				  &xgcv);
 xgcv.foreground = mw->menu.button_foreground;
 xgcv.background = mw->core.background_pixel;
 mw->menu.button_gc = XtGetGC ((Widget)mw, flags, &xgcv);
 xgcv.fill_style = FillStippled;
 xgcv.stipple = mw->menu.gray_pixmap;
 mw->menu.inactive_button_gc = XtGetGC ((Widget)mw,
 					 (flags | GCFillStyle | GCStipple),
 					 &xgcv);
 	      topc.green = MINL (65535, topc.green + 0x8000);
 	      topc.blue  = MINL (65535, topc.blue  + 0x8000);
 	      if (allocate_nearest_color (dpy, cmap, &topc))
 		{
 		  mw->menu.top_shadow_color = topc.pixel;
 		}
 	    }
 	  else
 	    {
 	      mw->menu.top_shadow_color = topc.pixel;
 	    }
 	      botc.green = MINL (65535, botc.green + 0x4000);
 	      botc.blue  = MINL (65535, botc.blue  + 0x4000);
 	      if (allocate_nearest_color (dpy, cmap, &botc))
 		{
 		  mw->menu.bottom_shadow_color = botc.pixel;
 		}
 	    }
 	  else
 	    {
 	      mw->menu.bottom_shadow_color = botc.pixel;
 	    }
 #ifdef NEED_MOTIF
 /* Find the maximal ascent/descent of the fonts in the font list
 so that all menu items can be the same height... */
 mw->menu.font_ascent  = 0;
 mw->menu.font_descent = 0;
 {
 XmFontContext context;
 #if (XmVersion >= 1002)
 XmFontListEntry fontentry;
 #else
 XmStringCharSet charset;
 #endif
 XFontStruct *font;
 if (! XmFontListInitFontContext (&context, mw->menu.font_list))
 newer equivalent, instead.  Also, it supports font sets, and the
 older function doesn't. */
 while ((fontentry = XmFontListNextEntry (context)))
 {
 	char *one_of_them;
 	XmFontType rettype;
 	one_of_them = XmFontListEntryGetFont (fontentry, &rettype);
 	if (rettype == XmFONT_IS_FONTSET)
 	  {
 	    XFontSet fontset = (XFontSet) one_of_them;
 	    XFontStruct **fontstruct_list;
 XmFontContext context;
 #if (XmVersion >= 1002)
 XmFontListEntry fontentry;
 XmFontType rettype;
 char *one_of_them;
 #else
 XmStringCharSet charset;
 #endif
 if (! XmFontListInitFontContext (&context, font_list))
 abort ();
 #if (XmVersion >= 1002)
 /* There is a BUG in the 1.2 version of XmFontListGetNextFont() (or more
 specifically, in _XmGetFirstFont()) that can cause a null pointer to be
 }
 else /* XmFONT_IS_FONT */
 {
 	font = (XFontStruct *) one_of_them;
 }
 #else
 if (! XmFontListGetNextFont (context, &charset, &font))
 abort ();
 XtFree (charset);
 #endif
 XmFontListFreeFontContext (context);
 }
 # endif /* !0 */
 if (! font) abort ();
 XlwMenuInitialize (Widget request, Widget new, 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);
 /*  mw->menu.cursor = XCreateFontCursor (display, mw->menu.cursor_shape); */
 mw->menu.cursor = mw->menu.cursor_shape;
 mw->menu.gray_pixmap =
 XCreatePixmapFromBitmapData (display, window, (char *) gray_bits,
 				 gray_width, gray_height, 1, 0, 1);
 #ifdef NEED_MOTIF
 /* The menu.font_list slot came from the *fontList resource (Motif standard.)
 The menu.font_list_2 slot came from the *font resource, for backward
 compatibility with older versions of this code, and consistency with the
 rest of emacs.  If both font and fontList are specified, we use font.
 extract_font_extents (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.pointer_grabbed        = False;
 mw->menu.next_release_must_exit = False;
 mw->menu.old_depth = 1;
-mw->menu.old_stack = (widget_value**)XtMalloc (sizeof (widget_value*));
+mw->menu.old_stack = XtNew (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 = XtNew (window_state);
 mw->menu.windows_length = 1;
 mw->menu.windows [0].x = 0;
 mw->menu.windows [0].y = 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
 }
 /* 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)
 {
 XlwMenuWidget mw = (XlwMenuWidget)w;
 int i;
 display_menu (mw, i, False, NULL, NULL, NULL, NULL, NULL);
 set_new_state (mw, NULL, mw->menu.old_depth); /* #### - ??? */
 remap_menubar (mw);		/* #### - do these two lines do anything? */
 }
 static void
 XlwMenuDestroy (Widget w)
 {
 int i;
 XlwMenuWidget mw = (XlwMenuWidget) w;
 if (mw->menu.pointer_grabbed)
 {
 XtUngrabPointer (w, CurrentTime);
 mw->menu.pointer_grabbed = False;
 }
 release_drawing_gcs (mw);
 release_shadow_gcs  (mw);
 /* this doesn't come from the resource db but is created explicitly
 so we must free it ourselves. */
 XDestroyWindow (XtDisplay (mw), mw->menu.windows [i].window);
 if (mw->menu.windows)
 XtFree ((char *) mw->menu.windows);
 }
 static Boolean
 XlwMenuSetValues (Widget current, Widget request, Widget new, ArgList args,
 		  Cardinal *num_args)
 {
 XlwMenuWidget oldmw = (XlwMenuWidget)current;
 XlwMenuWidget newmw = (XlwMenuWidget)new;
 )
 {
 release_drawing_gcs (newmw);
 make_drawing_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);
 }
 return redisplay;
 }
 static void
 XlwMenuResize (Widget w)
 {
 XlwMenuWidget mw = (XlwMenuWidget)w;
 mw->menu.windows [0].width  = mw->core.width;
 	 a disabled menu item */
 pop_new_stack_if_no_contents (mw);
 if (select_p && !stay_up) {
 	/* pop down all menus and exit */
 	mw->menu.next_release_must_exit = True;
 	set_new_state(mw, (val = NULL), 1);
 }
 }
 else
 {
 /* we wind up here when: (a) the event pops up a pull_right menu,
 	  /* popdown last menu if we're selecting the same menu item as we did
 	     last time and the XlwMenu.bounceDown resource is set, if the
 	     item is on the menubar itself, then exit. */
 	  if (level == (mw->menu.popped_up ? 0 : 1))
 	    mw->menu.next_release_must_exit = True;
 	}
 else
 	mw->menu.menu_bounce_time = 0;
 set_new_state (mw, val, level);
 }
 mw->menu.last_selected_val = val;
 remap_menubar (mw);
 /* Sync with the display.  Makes it feel better on X terms. */
 XFlush (XtDisplay (mw));
 }
 static void
 handle_single_motion_event (mw, event, select_p);
 }
 Time x_focus_timestamp_really_sucks_fix_me_better;
 static void
 Start (Widget w, XEvent *ev, String *params, Cardinal *num_params)
 {
 XlwMenuWidget mw = (XlwMenuWidget)w;
 lw_menubar_widget = w;
 lw_menu_active = True;
 if (!mw->menu.pointer_grabbed)
 {
 mw->menu.menu_post_time = ev->xbutton.time;
 mw->menu.menu_bounce_time = 0;
 mw->menu.next_release_must_exit = True;
 mw->menu.last_selected_val = NULL;
 x_focus_timestamp_really_sucks_fix_me_better =
 	((XButtonPressedEvent*)ev)->time;
 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;
 XtGrabPointer ((Widget)mw, False,
 		     (ButtonMotionMask | ButtonReleaseMask | ButtonPressMask),
 		     GrabModeAsync, GrabModeAsync,
 		     None, mw->menu.cursor_shape,
 		     ((XButtonPressedEvent*)ev)->time);
 /* handles the down like a move, slots are mostly compatible */
 handle_motion_event (mw, &ev->xmotion, True);
 }
 static void
 Drag (Widget w, XEvent *ev, String *params, Cardinal *num_params)
 {
 XlwMenuWidget mw = (XlwMenuWidget)w;
 handle_motion_event (mw, &ev->xmotion, False);
 }
 static void
 Select (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];
 lw_menu_accelerate = False;
 /* 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 || selected_item->call_data == 0)
 && (!mw->menu.next_release_must_exit
 }
 /* pop down everything */
 mw->menu.new_depth = 1;
 remap_menubar (mw);
 /* Destroy() only gets called for popup menus.  Menubar widgets aren't
 	 destroyed when their menu panes get nuked. */
 if (mw->menu.pointer_grabbed)
 {
 XtUngrabPointer ((Widget)w, ev->xmotion.time);
 mw->menu.pointer_grabbed = False;
 }
 if (mw->menu.popped_up)
 {
 mw->menu.popped_up = False;
 XtPopdown (XtParent (mw));
 }
 lw_menu_active = False;
 x_focus_timestamp_really_sucks_fix_me_better =
 ((XButtonPressedEvent*)ev)->time;
 /* callback */
 XtCallCallbackList ((Widget) mw, mw->menu.select, (XtPointer) selected_item);
 }
 /* Action procedures for keyboard accelerators */
 xlw_map_menu (Time t)
 {
 XlwMenuWidget mw = (XlwMenuWidget)lw_menubar_widget;
 lw_menu_accelerate = True;
 if (!mw->menu.pointer_grabbed)
 {
 XWindowAttributes ret;
 Window parent,root;
 Window *waste;
 unsigned int num_waste;
 lw_menu_active = True;
 mw->menu.menu_post_time = t;
 mw->menu.menu_bounce_time = 0;
 mw->menu.next_release_must_exit = True;
 mw->menu.last_selected_val = NULL;
 XtCallCallbackList ((Widget)mw, mw->menu.open, NULL);
 /* do this for keyboards too! */
 /* 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;
 */
 /* get the geometry of the menubar */
 /* there has to be a better way than this. */
 mw->menu.windows [0].x = 0;
 mw->menu.windows [0].y = 0;
 parent = XtWindow (lw_menubar_widget);
 do
 	{
 	  XGetWindowAttributes (XtDisplay (lw_menubar_widget), parent, &ret);
 	  mw->menu.windows [0].x += ret.x;
 	  mw->menu.windows [0].y += ret.y;
 	  if (parent)
 	    XQueryTree (XtDisplay (lw_menubar_widget), parent, &root, &parent, &waste,
 			&num_waste);
 	  if (waste)
 	    {
 	      XFree (waste);
 	    }
 	}
 while (parent != root);
 XtGrabPointer ((Widget)mw, False,
 		     (ButtonMotionMask | ButtonReleaseMask | ButtonPressMask),
 		     GrabModeAsync, GrabModeAsync,
 		     None, mw->menu.cursor_shape, t);
 mw->menu.pointer_grabbed = True;
 xlw_display_menu (Time t)
 {
 XlwMenuWidget mw = (XlwMenuWidget)lw_menubar_widget;
 lw_menu_accelerate = True;
 remap_menubar (mw);
 /* Sync with the display.  Makes it feel better on X terms. */
 XFlush (XtDisplay (mw));
 }
 /* push a sub menu */
 void
 xlw_kill_menus (widget_value *val)
 {
 XlwMenuWidget mw = (XlwMenuWidget)lw_menubar_widget;
 lw_menu_accelerate = False;
 mw->menu.new_depth = 1;
 remap_menubar (mw);
 if (mw->menu.pointer_grabbed)
 {
 XtUngrabPointer (lw_menubar_widget, CurrentTime);
 mw->menu.pointer_grabbed = False;
 }
 	return mw->menu.new_stack[0];
 }
 else
 if (mw->menu.new_depth >= 1)
 return mw->menu.new_stack [mw->menu.new_depth - 1];
 return NULL;
 }
 int
 xlw_menu_level (void)
 w = mw->menu.windows [0].width;
 h = mw->menu.windows [0].height;
 x -= borderwidth;
 y -= borderwidth;
 if (x < borderwidth)
 x = borderwidth;
 if (x > WidthOfScreen (screen) - w - 2 * borderwidth)
 x = WidthOfScreen (screen) - w - 2 * borderwidth;
 if (y < borderwidth)
 y = borderwidth;
 if (y > HeightOfScreen (screen) - h - 2 * borderwidth)
 y = HeightOfScreen (screen) - h - 2 * borderwidth;
 mw->menu.popped_up = True;
 XtConfigureWidget (XtParent (mw), x, y, w, h,

Mercurial > hg > xemacs-beta

comparison lwlib/xlwmenu.c @ 183:e121b013d1f0 r20-3b18