diff options
Diffstat (limited to 'lwlib')
| -rw-r--r-- | lwlib/ChangeLog | 279 | ||||
| -rw-r--r-- | lwlib/Makefile.in | 32 | ||||
| -rw-r--r-- | lwlib/lwlib-Xaw.c | 653 | ||||
| -rw-r--r-- | lwlib/lwlib-Xaw.h | 16 | ||||
| -rw-r--r-- | lwlib/lwlib-Xlw.c | 67 | ||||
| -rw-r--r-- | lwlib/lwlib-Xlw.h | 18 | ||||
| -rw-r--r-- | lwlib/lwlib-Xm.c | 399 | ||||
| -rw-r--r-- | lwlib/lwlib-Xm.h | 26 | ||||
| -rw-r--r-- | lwlib/lwlib-int.h | 21 | ||||
| -rw-r--r-- | lwlib/lwlib-utils.c | 29 | ||||
| -rw-r--r-- | lwlib/lwlib-utils.h | 18 | ||||
| -rw-r--r-- | lwlib/lwlib.c | 402 | ||||
| -rw-r--r-- | lwlib/lwlib.h | 82 | ||||
| -rw-r--r-- | lwlib/xlwmenu.c | 789 | ||||
| -rw-r--r-- | lwlib/xlwmenu.h | 9 | ||||
| -rw-r--r-- | lwlib/xlwmenuP.h | 17 |
16 files changed, 1554 insertions, 1303 deletions
diff --git a/lwlib/ChangeLog b/lwlib/ChangeLog index 6244a9b04d6..5c5b4fcb975 100644 --- a/lwlib/ChangeLog +++ b/lwlib/ChangeLog @@ -1,12 +1,275 @@ -2011-01-23 Werner Meisner <weme24@gmx.net> +2011-01-25 Werner Meisner <weme24@gmx.net> * lwlib-Xm.c (xm_update_menu): Avoid a NULL pointer dereference (Bug#7690). +2010-09-26 Dan Nicolaescu <dann@ics.uci.edu> + + Use const for some pointer arguments. + * lwlib.h (my_strcasecmp, safe_strcmp, name_to_widget) + (find_in_table, dialog_spec_p, lw_separator_p): + * lwlib.c (my_strcasecmp, safe_strcmp, name_to_widget) + (find_in_table, dialog_spec_p, lw_separator_p): Use const. + +2010-09-20 Dan Nicolaescu <dann@ics.uci.edu> + + * lwlib.h (lw_register_widget, lw_create_widget): + * lwlib.c (allocate_widget_info, lw_register_widget) + (lw_create_widget, separator_table): Use const. + +2010-07-29 Dan Nicolaescu <dann@ics.uci.edu> + + * xlwmenu.c (abort_gracefully): Mark as NO_RETURN. + +2010-07-26 Dan Nicolaescu <dann@ics.uci.edu> + + * xlwmenu.h (xlwmenu_window_p, xlwmenu_redisplay): Add declarations. + +2010-07-12 Andreas Schwab <schwab@linux-m68k.org> + + * Makefile.in (C_WARNINGS_SWITCH, PROFILING_CFLAGS): Set from + substitution. + (ALL_CFLAGS): Add ${C_WARNINGS_SWITCH} and ${PROFILING_CFLAGS}. + +2010-07-08 Jan Djärv <jan.h.d@swipnet.se> + + * xlwmenu.c (size_menu_item): Change from K&R to prototype. + Change label_width and height to int. + (draw_arrow, draw_shadow_rectangle, draw_shadow_rhombus) + (draw_separator, display_menu, fit_to_screen, motion_event_is_in_menu) + (map_event_to_widget_value): Reformat. + (display_menu_item): Change from K&R to prototype. + + * lwlib.c (allocate_widget_info, lw_register_widget): Change from K&R + to prototype. + (lw_internal_update_other_instances, merge_widget_value): Reformat. + + * lwlib-int.h (widget_creation_function): Fix prototype. + + * lwlib-Xm.c (x_print_complete_resource_name) + (make_destroyed_instance, free_destroyed_instance, first_child) + (lw_motif_widget_p, resource_motif_string, destroy_all_children) + (xm_arm_callback, xm_update_label, xm_update_list) + (xm_update_pushbutton, xm_update_cascadebutton) + (xm_update_toggle, xm_update_radiobox, make_menu_in_widget) + (update_one_menu_entry, xm_update_menu, xm_update_text) + (xm_update_text_field, xm_update_one_widget) + (xm_update_one_value, activate_button, dialog_key_cb) + (make_dialog, mark_dead_instance_destroyed) + (find_matching_instance, recenter_widget, recycle_instance) + (xm_create_dialog, make_menubar, remove_grabs, make_popup_menu) + (make_main, xm_destroy_instance, xm_popup_menu) + (set_min_dialog_size, xm_pop_instance, do_call) + (xm_internal_update_other_instances, xm_generic_callback) + (xm_nosel_callback, xm_pull_down_callback, xm_pop_down_callback) + (xm_set_keyboard_focus, xm_set_main_areas, xm_manage_resizing): Change + from K&R to prototype. + + * lwlib-Xlw.c (x_print_complete_resource_name): Change from K&R to + prototype. + (xlw_update_one_value): Reformat. + + * lwlib-Xaw.c (xaw_generic_callback, command_reset) + (xaw_update_one_value): Reformat. + (xaw_update_one_widget): Reformat and remove dead code. + (xaw_scrollbar_scroll, xaw_scrollbar_jump, xaw_create_scrollbar) + (xaw_update_scrollbar): Remove (not used). + (make_dialog): Change from K&R to prototype. Remove dead code. + (xaw_creation_table): Remove scrollbar entry. + +2010-07-08 Dan Nicolaescu <dann@ics.uci.edu> + + * lwlib.c (allocate_widget_instance, get_widget_info) + (get_widget_instance, find_instance, set_one_value) + (update_one_widget_instance, update_all_widget_values) + (lw_modify_all_widgets, lw_get_widget, lw_make_widget) + (lw_create_widget, lw_pop_all_widgets, lw_show_busy) + (lw_refigure_widget, lw_allow_resizing): Remove alternative K&R + declarations. + * lwlib-Xlw.c (xlw_update_one_widget): + (xlw_pop_instance): Likewise. + * lwlib-Xaw.c (xaw_update_one_widget, xaw_pop_instance): + Likewise. + * lwlib-Xm.c (P_): Remove. + +2010-07-07 Andreas Schwab <schwab@linux-m68k.org> + + * lwlib.c (lwlib_memset, lwlib_bcopy): Remove. + (malloc_widget_value, free_widget_info, allocate_widget_instance) + (lw_separator_p): Replace lwlib_memset, lwlib_bcopy, bzero, bcmp by + memset, memcpy, memcmp. + * lwlib-utils.c (XtApplyToWidgets): Likewise. + * xlwmenu.c (XlwMenuInitialize): Likewise. + * lwlib.h (lwlib_bcopy): Remove declaration. + +2010-07-05 Jan Djärv <jan.h.d@swipnet.se> + + * xlwmenu.c (XlwMenuSetValues, XlwMenuInitialize): Correct prototype. + (display_menu_item): Remove unused variable gi. + (make_windows_if_needed): Remove unused variable screen. + (XlwMenuRedisplay): Remove unused variable i. + + * lwlib-Xaw.c: Include <ctype.h> for isdigit. + (fill_xft_data, set_text): Remove unused variable screen. + (draw_text): Cast bp to FcChar8*. + (find_xft_data): Return 0 if inst or xft_data is not set. + (wm_delete_window): Correct prototype. Initialize widget to 0 + and return if widget is still 0 after loop. + +2010-07-04 Dan Nicolaescu <dann@ics.uci.edu> + + * lwlib-Xaw.c: Convert function definitions to standard C. + * lwlib-Xlw.c: + * lwlib-utils.c: + * lwlib.c: + * lwlib.h: + * xlwmenu.c: Likewise. + +2010-07-02 Jan Djärv <jan.h.d@swipnet.se> + + * lwlib-Xm.c: Remove __P and P_ from .c and .m files. + * lwlib-Xm.c: + * lwlib.c: + * xlwmenu.c: Likewise. + + Remove P_ and __P macros. + * lwlib-Xaw.h: Remove P_ and __P macros. + * lwlib-Xlw.h: + * lwlib-Xm.h: + * lwlib-int.h: + * lwlib-utils.h: + * lwlib.h: Likewise. + +2010-05-15 Glenn Morris <rgm@gnu.org> + + * Makefile.in (mostlyclean): Remove references to non-existent files. + +2010-05-13 Jan Djärv <jan.h.d@swipnet.se> + + * lwlib-Xaw.c (make_dialog): Remove extra arg to XtVaGetSubresources. + +2010-05-08 Jan Djärv <jan.h.d@swipnet.se> + + * xlwmenu.c (XlwMenuDestroy): Remove XtDestroyWidget on subwidgets + (Bug #6127). + 2010-05-07 Chong Yidong <cyd@stupidchicken.com> * Version 23.2 released. +2010-05-06 Glenn Morris <rgm@gnu.org> + + * Makefile.in (CPP, LN_S, TOP, LN): Remove unused variables. + +2010-05-04 Glenn Morris <rgm@gnu.org> + + * Makefile.in (C_SWITCH_SYSTEM, C_SWITCH_MACHINE): + Use @C_SWITCH_SYSTEM@, @C_SWITCH_MACHINE@ instead of + @c_switch_system@, @c_switch_machine@. + +2010-04-27 Dan Nicolaescu <dann@ics.uci.edu> + + * Makefile.in (C_SWITCH_X_SYSTEM): Define using autoconf. + +2010-04-21 Jan Djärv <jan.h.d@swipnet.se> + + * xlwmenu.c (expose_cb): + * lwlib-Xaw.c (fill_xft_data): Declarations before code. + +2010-04-17 Jan Djärv <jan.h.d@swipnet.se> + + * xlwmenu.c: Include Shell.h, remove duplicate declaration of + XlwMenuRedisplay. + (display_menu_item): Replace ws->window with ws->pixmap, remove + call to XftDrawRect. + (display_menu): Remove this and that argument. + Remove just_compute_this_one_p. Fill pixmap at start and copy it to + window at end. + (expose_cb): New function. + (make_windows_if_needed): Replace XCreateWindow with XtCreatePopup. + Add eventhandler for expose to expose_cb. Remove creation of xft_draw. + (create_pixmap_for_menu): New function. + (remap_menubar): Pop down menus that aren't the same as in old_stack. + Set width, heigh, x, y on widget with XtVaSetValues. + Call create_pixmap_for_menu. + Replace XUnmapWindow with XtPopdown. + Remowe two last parameters to display_menu. + (map_event_to_widget_value, XlwMenuRedisplay, Key, Select) + (pop_up_menu): Remowe two last parameters to display_menu. + (XlwMenuRealize): Call create_pixmap_for_menu, set w and pixmap. + Remove call to XftDrawCreate. + (XlwMenuDestroy): Free pixmap. Call XtDestroyWidget instead of + XDestroyWindow. + (handle_motion_event): Only call handle_single_motion_event once. + (set_window_type): New function. + (make_windows_if_needed, XlwMenuRealize): Call set_window_type. + + * xlwmenuP.h (window_state): Add pixmap and w. + +2010-04-16 YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp> + + * xlwmenu.c (facename_changed): Put function in #ifdef HAVE_XFT. + +2010-04-11 Dan Nicolaescu <dann@ics.uci.edu> + + * Makefile.in (C_SWITCH_SYSTEM, C_SWITCH_MACHINE) + (C_SWITCH_X_SITE): Define using autoconf. + +2010-04-11 Jan Djärv <jan.h.d@swipnet.se> + + * lwlib-Xaw.c (widget_xft_data): New for Xft data. + (fill_xft_data, openFont, get_text_width_and_height) + (draw_text, set_text, find_xft_data, command_press) + (command_reset): New functions. + (xaw_update_one_widget): Call set_text for dialog and buttons + if HAVE_XFT. Also set internalHeight for buttons. + (xaw_destroy_instance): Free all Xft related data. + (button_actions, buttonTrans): New structures. + (make_dialog): Call XtAppAddActions for button_actions. + Find xft font to use and call fill_xft_data for widgets. + (xaw_create_dialog): Pass instance parameter to make_dialog. + + * lwlib-int.h (_widget_instance): Add Xft data if HAVE_XFT. + Override translations for buttons. If depth is 16 or more, tell + Xaw3d to not be nice to colormap. + Remove separator widget, use XtNhorizDistance on first right button + instead. + +2010-04-08 Jan Djärv <jan.h.d@swipnet.se> + + * xlwmenu.c (xlwmenu_default_font): Make static. + (xlwMenuResources): Add XtNfaceName and XtNdefaultFace. + (string_width): Use XftTextExtentsUtf8 if HAVE_XFT. + (MENU_FONT_HEIGHT, MENU_FONT_ASCENT): Add versions for + HAVE_XFT. + (size_menu): Set max_rest_width in window_state structure. + (display_menu_item): If HAVE_XFT and xft_draw is set, use + XftDrawRect and XftDrawStringUtf8 to draw text. + (make_windows_if_needed): Set max_rest_width and xft_draw + in windows[i]. + (openXftFont): New. + (XlwMenuInitialize): Call openXftFont if HAVE_XFT. If mw->menu.font + is not set, load font fixed and save it in xlwmenu_default_font. + (XlwMenuInitialize): Set max_rest_width and xft_draw in windows[0]. + (XlwMenuClassInitialize): Initialize xlwmenu_default_font. + (XlwMenuRealize): Set xft_fg, xft_bg, xft_disabled_fg and + windows[0].xft_draw if xft_font is set. + (XlwMenuDestroy): Destroy all xft_draw and close xft_font. + (facename_changed): New. + (XlwMenuSetValues): Call facename_changed. If face name did change, + close old fonts and destroy xft_draw:s. Then create new ones. + + * xlwmenu.h (XtNfaceName, XtCFaceName, XtNdefaultFace, + XtCDefaultFace): New. + + * xlwmenuP.h (_window_state): Add max_rest_width and xft_draw. + (_XlwMenu_part): Add faceName,xft_fg, xft_bg, xft_disabled_fg and + xft_font. + +2010-03-10 Chong Yidong <cyd@stupidchicken.com> + + * Branch for 23.2. + 2009-10-19 Dan Nicolaescu <dann@ics.uci.edu> * xlwmenu.c: @@ -145,7 +408,7 @@ * xlwmenu.c (xlwMenuResources) [HAVE_X_I18N]: Use a fontset for the `font' resource. - (string_width) [HAVE_X_I18N]: Use XmbTextExtents; + (string_width) [HAVE_X_I18N]: Use XmbTextExtents. (MENU_FONT_HEIGHT, MENU_FONT_ASCENT): New macros. (arrow_width, toggle_button_width, size_menu_item, draw_arrow) (draw_toggle, draw_radio, display_menu_item): Use them. @@ -770,11 +1033,6 @@ [USE_XAW]: Include <X11/Xaw/Paned.h>. (lwlib_memset, lwlib_bcopy): Explicitly declare return type. -1997-12-20 Richard Stallman <rms@delysid.gnu.org> - - * lwlib-Xm.c (update_one_menu_entry): - Add conditional in case XmNpositionIndex is missing. - 1997-12-20 Richard Stallman <rms@psilocin.gnu.org> * lwlib-Xm.c (update_one_menu_entry): @@ -1055,12 +1313,6 @@ cascade button itself. This works around a Motif SIGSEGV in the function `InSharedMenuHierarchy'. -1994-10-29 Richard Stallman <rms@duality.gnu.ai.mit.edu> - - * xlwmenu.c (xlwmenu_default_font): New global variable. - (XlwMenuInitialize): Use xlwmenu_default_font to default - the font if necessary. Make mw, itself, an argument. - 1994-10-26 Richard Stallman <rms@duality.gnu.ai.mit.edu> * xlwmenu.c (pop_up_menu): Pass a Display * to x_catch_errors, etc. @@ -1414,4 +1666,3 @@ You should have received a copy of the GNU General Public License along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. -;;; arch-tag: 0cd8ab87-d764-40d9-b86d-d00c71887a9e diff --git a/lwlib/Makefile.in b/lwlib/Makefile.in index 501188c67ef..49adfe4dd44 100644 --- a/lwlib/Makefile.in +++ b/lwlib/Makefile.in @@ -1,6 +1,6 @@ # Copyright (C) 1992, 1993 Lucid, Inc. -# Copyright (C) 1994, 2001, 2002, 2003, 2004, 2005, 2006, -# 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc. +# Copyright (C) 1994, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, +# 2009, 2010, 2011 Free Software Foundation, Inc. # # This file is part of the Lucid Widget Library. # @@ -26,34 +26,34 @@ srcdir=@srcdir@ VPATH=@srcdir@ C_SWITCH_X_SITE=@C_SWITCH_X_SITE@ +C_SWITCH_X_SYSTEM=@C_SWITCH_X_SYSTEM@ +C_SWITCH_SYSTEM=@C_SWITCH_SYSTEM@ +C_SWITCH_MACHINE=@C_SWITCH_MACHINE@ +C_WARNINGS_SWITCH = @C_WARNINGS_SWITCH@ +PROFILING_CFLAGS = @PROFILING_CFLAGS@ CC=@CC@ CFLAGS=@CFLAGS@ -CPP=@CPP@ CPPFLAGS=@CPPFLAGS@ -LN_S=@LN_S@ RANLIB=@RANLIB@ # See below--@X_TOOLKIT_TYPE@ is used below. USE_X_TOOLKIT=@X_TOOLKIT_TYPE@ - TOP = . +AR = ar cq +RM = rm -f - AR = ar cq - - LN = ln -s - RM = rm -f - - LUCID_OBJS = lwlib-Xlw.o xlwmenu.o lwlib-Xaw.o - MOTIF_OBJS = lwlib-Xm.o +LUCID_OBJS = lwlib-Xlw.o xlwmenu.o lwlib-Xaw.o +MOTIF_OBJS = lwlib-Xm.o TOOLKIT_DEFINES = - TOOLKIT_OBJS = $(@X_TOOLKIT_TYPE@_OBJS) +TOOLKIT_OBJS = $(@X_TOOLKIT_TYPE@_OBJS) - OBJS = lwlib.o $(TOOLKIT_OBJS) lwlib-utils.o +OBJS = lwlib.o $(TOOLKIT_OBJS) lwlib-utils.o # ../src is needed to find config.h. ALL_CFLAGS= $(C_SWITCH_SYSTEM) $(C_SWITCH_X_SITE) \ - $(C_SWITCH_X_SYSTEM) $(C_SWITCH_MACHINE) $(CFLAGS) \ + $(C_SWITCH_X_SYSTEM) $(C_SWITCH_MACHINE) \ + ${C_WARNINGS_SWITCH} ${PROFILING_CFLAGS} $(CFLAGS) \ -DHAVE_CONFIG_H -Demacs -I. -I../src -I${srcdir} -I${srcdir}/../src .c.o: @@ -78,7 +78,7 @@ lwlib-Xm.o: lwlib-Xm.c lwlib-Xm.h lwlib.h lwlib-int.h lwlib-utils.h xlwmenu.o: xlwmenu.c xlwmenu.h lwlib.h xlwmenuP.h mostlyclean: - $(RM) *.o core errs ,* *.a .emacs_* make.log MakeOut \#* + $(RM) *.o core liblw.a \#* clean: mostlyclean distclean: clean diff --git a/lwlib/lwlib-Xaw.c b/lwlib/lwlib-Xaw.c index 22bd8523c36..ba7740a4520 100644 --- a/lwlib/lwlib-Xaw.c +++ b/lwlib/lwlib-Xaw.c @@ -26,6 +26,7 @@ Boston, MA 02110-1301, USA. */ #include <stdio.h> #include <setjmp.h> +#include <ctype.h> #include "../src/lisp.h" @@ -54,111 +55,259 @@ Boston, MA 02110-1301, USA. */ #include <X11/Xatom.h> -static void xaw_generic_callback (/*Widget, XtPointer, XtPointer*/); +#ifdef HAVE_XFT +#include <X11/Xft/Xft.h> + +struct widget_xft_data +{ + Widget widget; + XftFont *xft_font; + XftDraw *xft_draw; + XftColor xft_fg, xft_bg; + int p_width, p_height; + Pixmap p; +}; + + +#endif + +static void xaw_generic_callback (Widget widget, + XtPointer closure, + XtPointer call_data); Boolean -lw_xaw_widget_p (widget) - Widget widget; +lw_xaw_widget_p (Widget widget) { return (XtIsSubclass (widget, scrollbarWidgetClass) || XtIsSubclass (widget, dialogWidgetClass)); } -#if 0 + +#ifdef HAVE_XFT static void -xaw_update_scrollbar (instance, widget, val) - widget_instance *instance; - Widget widget; - widget_value *val; +fill_xft_data (struct widget_xft_data *data, Widget widget, XftFont *font) { - if (val->scrollbar_data) + Pixel bg, fg; + XColor colors[2]; + + data->widget = widget; + data->xft_font = font; + XtVaGetValues (widget, + XtNbackground, &bg, + XtNforeground, &fg, + NULL); + + colors[0].pixel = data->xft_fg.pixel = fg; + colors[1].pixel = data->xft_bg.pixel = bg; + XQueryColors (XtDisplay (widget), + DefaultColormapOfScreen (XtScreen (widget)), + colors, 2); + + data->xft_fg.color.alpha = 0xFFFF; + data->xft_fg.color.red = colors[0].red; + data->xft_fg.color.green = colors[0].green; + data->xft_fg.color.blue = colors[0].blue; + data->xft_bg.color.alpha = 0xFFFF; + data->xft_bg.color.red = colors[1].red; + data->xft_bg.color.green = colors[1].green; + data->xft_bg.color.blue = colors[1].blue; + + data->p = None; + data->xft_draw = 0; + data->p_width = data->p_height = 0; +} + +static XftFont* +openFont (Widget widget, char *name) +{ + char *fname = name; + int screen = XScreenNumberOfScreen (XtScreen (widget)); + int len = strlen (fname), i = len-1; + XftFont *fn; + + /* Try to convert Gtk-syntax (Sans 9) to Xft syntax Sans-9. */ + while (i > 0 && isdigit (fname[i])) + --i; + if (fname[i] == ' ') { - scrollbar_values *data = val->scrollbar_data; - Dimension height, width; - Dimension pos_x, pos_y; - int widget_shown, widget_topOfThumb; - float new_shown, new_topOfThumb; - - XtVaGetValues (widget, - XtNheight, &height, - XtNwidth, &width, - XtNx, &pos_x, - XtNy, &pos_y, - XtNtopOfThumb, &widget_topOfThumb, - XtNshown, &widget_shown, - NULL); - - /* - * First size and position the scrollbar widget. - * We need to position it to second-guess the Paned widget's notion - * of what should happen when the WMShell gets resized. - */ - if (height != data->scrollbar_height || pos_y != data->scrollbar_pos) - { - XtConfigureWidget (widget, pos_x, data->scrollbar_pos, - width, data->scrollbar_height, 0); + fname = xstrdup (name); + fname[i] = '-'; + } - XtVaSetValues (widget, - XtNlength, data->scrollbar_height, - XtNthickness, width, - NULL); - } + fn = XftFontOpenName (XtDisplay (widget), screen, fname); + if (fname != name) free (fname); + + return fn; +} + +static int +get_text_width_and_height (Widget widget, char *text, + XftFont *xft_font, + int *height) +{ + int w = 0, h = 0; + char *bp = text; + + while (bp && *bp != '\0') + { + XGlyphInfo gi; + char *cp = strchr (bp, '\n'); + XftTextExtentsUtf8 (XtDisplay (widget), xft_font, + (FcChar8 *) bp, + cp ? cp - bp : strlen (bp), + &gi); + bp = cp ? cp + 1 : NULL; + h += xft_font->height; + if (w < gi.width) w = gi.width; + } + + *height = h; + return w; +} + +static void +draw_text (struct widget_xft_data *data, char *lbl, int inverse) +{ + Screen *sc = XtScreen (data->widget); + int screen = XScreenNumberOfScreen (sc); + int y = data->xft_font->ascent; + int x = inverse ? 0 : 2; + char *bp = lbl; + + data->xft_draw = XftDrawCreate (XtDisplay (data->widget), + data->p, + DefaultVisual (XtDisplay (data->widget), + screen), + DefaultColormapOfScreen (sc)); + XftDrawRect (data->xft_draw, + inverse ? &data->xft_fg : &data->xft_bg, + 0, 0, data->p_width, data->p_height); + + if (!inverse) y += 2; + while (bp && *bp != '\0') + { + char *cp = strchr (bp, '\n'); + XftDrawStringUtf8 (data->xft_draw, + inverse ? &data->xft_bg : &data->xft_fg, + data->xft_font, x, y, + (FcChar8 *) bp, + cp ? cp - bp : strlen (bp)); + bp = cp ? cp + 1 : NULL; + /* 1.2 gives reasonable line spacing. */ + y += data->xft_font->height * 1.2; + } + +} + + +static void +set_text (struct widget_xft_data *data, Widget toplevel, char *lbl, int margin) +{ + int width, height; + + width = get_text_width_and_height (data->widget, lbl, data->xft_font, + &height); + data->p_width = width + margin; + data->p_height = height + margin; + + data->p = XCreatePixmap (XtDisplay (data->widget), + XtWindow (toplevel), + data->p_width, + data->p_height, + DefaultDepthOfScreen (XtScreen (data->widget))); + draw_text (data, lbl, 0); + XtVaSetValues (data->widget, XtNbitmap, data->p, NULL); +} - /* - * Now the size the scrollbar's slider. - */ - new_shown = (float) data->slider_size / - (float) (data->maximum - data->minimum); +static struct widget_xft_data * +find_xft_data (Widget widget) +{ + widget_instance *inst = NULL; + Widget parent = XtParent (widget); + struct widget_xft_data *data = NULL; + int nr; + while (parent && !inst) + { + inst = lw_get_widget_instance (parent); + parent = XtParent (parent); + } + if (!inst || !inst->xft_data || !inst->xft_data[0].xft_font) return 0; - new_topOfThumb = (float) (data->slider_position - data->minimum) / - (float) (data->maximum - data->minimum); + for (nr = 0; data == NULL && nr < inst->nr_xft_data; ++nr) + { + if (inst->xft_data[nr].widget == widget) + data = &inst->xft_data[nr]; + } - if (new_shown > 1.0) - new_shown = 1.0; - if (new_shown < 0) - new_shown = 0; + return data; +} - if (new_topOfThumb > 1.0) - new_topOfThumb = 1.0; - if (new_topOfThumb < 0) - new_topOfThumb = 0; +static void +command_press (Widget widget, + XEvent* event, + String *params, + Cardinal *num_params) +{ + struct widget_xft_data *data = find_xft_data (widget); + if (data) + { + char *lbl; + /* Since this isn't used for rectangle buttons, use it to for armed. */ + XtVaSetValues (widget, XtNcornerRoundPercent, 1, NULL); - if (new_shown != widget_shown || new_topOfThumb != widget_topOfThumb) - XawScrollbarSetThumb (widget, new_topOfThumb, new_shown); + XtVaGetValues (widget, XtNlabel, &lbl, NULL); + draw_text (data, lbl, 1); } } -#endif -void -#ifdef PROTOTYPES -xaw_update_one_widget (widget_instance *instance, Widget widget, - widget_value *val, Boolean deep_p) -#else -xaw_update_one_widget (instance, widget, val, deep_p) - widget_instance *instance; - Widget widget; - widget_value *val; - Boolean deep_p; -#endif +static void +command_reset (Widget widget, + XEvent* event, + String *params, + Cardinal *num_params) { -#if 0 - if (XtIsSubclass (widget, scrollbarWidgetClass)) + struct widget_xft_data *data = find_xft_data (widget); + if (data) { - xaw_update_scrollbar (instance, widget, val); + Dimension cr; + XtVaGetValues (widget, XtNcornerRoundPercent, &cr, NULL); + if (cr == 1) + { + char *lbl; + XtVaSetValues (widget, XtNcornerRoundPercent, 0, NULL); + XtVaGetValues (widget, XtNlabel, &lbl, NULL); + draw_text (data, lbl, 0); + } } +} + + #endif + +void +xaw_update_one_widget (widget_instance *instance, + Widget widget, + widget_value *val, + Boolean deep_p) +{ if (XtIsSubclass (widget, dialogWidgetClass)) { - Arg al[1]; - int ac = 0; - XtSetArg (al[ac], XtNlabel, val->contents->value); ac++; - XtSetValues (widget, al, ac); + +#ifdef HAVE_XFT + if (instance->xft_data && instance->xft_data[0].xft_font) + { + set_text (&instance->xft_data[0], instance->parent, + val->contents->value, 10); + } +#endif + XtVaSetValues (widget, XtNlabel, val->contents->value, NULL); } else if (XtIsSubclass (widget, commandWidgetClass)) { Dimension bw = 0; - Arg al[3]; + Arg al[10]; + int ac = 0; XtVaGetValues (widget, XtNborderWidth, &bw, NULL); if (bw == 0) @@ -174,20 +323,39 @@ xaw_update_one_widget (instance, widget, val, deep_p) } XtSetSensitive (widget, val->enabled); - XtSetArg (al[0], XtNlabel, val->value); + XtSetArg (al[ac], XtNlabel, val->value);ac++; /* Force centered button text. Se above. */ - XtSetArg (al[1], XtNjustify, XtJustifyCenter); - XtSetValues (widget, al, 2); + XtSetArg (al[ac], XtNjustify, XtJustifyCenter);ac++; +#ifdef HAVE_XFT + if (instance->xft_data && instance->xft_data[0].xft_font) + { + int th; + int nr; + for (nr = 0; nr < instance->nr_xft_data; ++nr) + if (instance->xft_data[nr].widget == widget) + break; + if (nr < instance->nr_xft_data) + { + set_text (&instance->xft_data[nr], instance->parent, + val->value, 6); + + /* Must set internalHeight to twice the highlight thickness, + or else it gets overwritten by our pixmap. Probably a bug. */ + XtVaGetValues (widget, XtNhighlightThickness, &th, NULL); + XtSetArg (al[ac], XtNinternalHeight, 2*th);ac++; + } + } +#endif + XtSetValues (widget, al, ac); XtRemoveAllCallbacks (widget, XtNcallback); XtAddCallback (widget, XtNcallback, xaw_generic_callback, instance); } } void -xaw_update_one_value (instance, widget, val) - widget_instance *instance; - Widget widget; - widget_value *val; +xaw_update_one_value (widget_instance *instance, + Widget widget, + widget_value *val) { /* This function is not used by the scrollbars and those are the only Athena widget implemented at the moment so do nothing. */ @@ -195,9 +363,30 @@ xaw_update_one_value (instance, widget, val) } void -xaw_destroy_instance (instance) - widget_instance *instance; +xaw_destroy_instance (widget_instance *instance) { +#ifdef HAVE_XFT + if (instance->xft_data) + { + int i; + for (i = 0; i < instance->nr_xft_data; ++i) + { + if (instance->xft_data[i].xft_draw) + XftDrawDestroy (instance->xft_data[i].xft_draw); + if (instance->xft_data[i].p != None) + { + XtVaSetValues (instance->xft_data[i].widget, XtNbitmap, None, + NULL); + XFreePixmap (XtDisplay (instance->widget), + instance->xft_data[i].p); + } + } + if (instance->xft_data[0].xft_font) + XftFontClose (XtDisplay (instance->widget), + instance->xft_data[0].xft_font); + free (instance->xft_data); + } +#endif if (XtIsSubclass (instance->widget, dialogWidgetClass)) /* Need to destroy the Shell too. */ XtDestroyWidget (XtParent (instance->widget)); @@ -206,22 +395,14 @@ xaw_destroy_instance (instance) } void -xaw_popup_menu (widget, event) - Widget widget; - XEvent *event; +xaw_popup_menu (Widget widget, XEvent *event) { /* An Athena menubar has not been implemented. */ return; } void -#ifdef PROTOTYPES xaw_pop_instance (widget_instance *instance, Boolean up) -#else -xaw_pop_instance (instance, up) - widget_instance *instance; - Boolean up; -#endif { Widget widget = instance->widget; @@ -292,24 +473,39 @@ static char overrideTrans[] = /* Dialogs pop down on any key press */ static char dialogOverride[] = "<KeyPress>Escape: lwlib_delete_dialog()"; -static void wm_delete_window(); +static void wm_delete_window (Widget w, + XEvent *event, + String *params, + Cardinal *num_params); static XtActionsRec xaw_actions [] = { {"lwlib_delete_dialog", wm_delete_window} }; static Boolean actions_initted = False; +#ifdef HAVE_XFT +static XtActionsRec button_actions[] = + { + { "my_reset", command_reset }, + { "my_press", command_press }, + }; +char buttonTrans[] = + "<Leave>: reset() my_reset()\n" + "<Btn1Down>: set() my_press()\n" + "<Btn1Up>: my_reset() notify() unset()\n"; +#endif + static Widget -make_dialog (name, parent, pop_up_p, shell_title, icon_name, text_input_slot, radio_box, list, left_buttons, right_buttons) - char* name; - Widget parent; - Boolean pop_up_p; - char* shell_title; - char* icon_name; - Boolean text_input_slot; - Boolean radio_box; - Boolean list; - int left_buttons; - int right_buttons; +make_dialog (char* name, + Widget parent, + Boolean pop_up_p, + char* shell_title, + char* icon_name, + Boolean text_input_slot, + Boolean radio_box, + Boolean list, + int left_buttons, + int right_buttons, + widget_instance *instance) { Arg av [20]; int ac = 0; @@ -319,6 +515,10 @@ make_dialog (name, parent, pop_up_p, shell_title, icon_name, text_input_slot, ra Widget dialog; Widget button; XtTranslations override; +#ifdef HAVE_XFT + XftFont *xft_font = 0; + XtTranslations button_override; +#endif if (! pop_up_p) abort (); /* not implemented */ if (text_input_slot) abort (); /* not implemented */ @@ -330,6 +530,10 @@ make_dialog (name, parent, pop_up_p, shell_title, icon_name, text_input_slot, ra XtAppContext app = XtWidgetToApplicationContext (parent); XtAppAddActions (app, xaw_actions, sizeof (xaw_actions) / sizeof (xaw_actions[0])); +#ifdef HAVE_XFT + XtAppAddActions (app, button_actions, + sizeof (button_actions) / sizeof (button_actions[0])); +#endif actions_initted = True; } @@ -351,6 +555,49 @@ make_dialog (name, parent, pop_up_p, shell_title, icon_name, text_input_slot, ra override = XtParseTranslationTable (dialogOverride); XtOverrideTranslations (dialog, override); +#ifdef HAVE_XFT + { + int num; + Widget *ch = NULL; + Widget w = 0; + XtVaGetValues (dialog, + XtNnumChildren, &num, + XtNchildren, &ch, NULL); + for (i = 0; i < num; ++i) + { + if (!XtIsSubclass (ch[i], commandWidgetClass) + && XtIsSubclass (ch[i], labelWidgetClass)) + { + w = ch[i]; + break; + } + } + instance->xft_data = 0; + instance->nr_xft_data = 0; + if (w) + { + XtResource rec[] = + { { "faceName", "FaceName", XtRString, sizeof(String), 0, XtRString, + (XtPointer)"Sans-14" }}; + char *faceName; + XtVaGetSubresources (dialog, &faceName, "Dialog", "dialog", + rec, 1, (String)NULL); + if (strcmp ("none", faceName) != 0) + xft_font = openFont (dialog, faceName); + if (xft_font) + { + instance->nr_xft_data = left_buttons + right_buttons + 1; + instance->xft_data = calloc (instance->nr_xft_data, + sizeof(*instance->xft_data)); + + fill_xft_data (&instance->xft_data[0], w, xft_font); + } + } + + button_override = XtParseTranslationTable (buttonTrans); + } +#endif + bc = 0; button = 0; for (i = 0; i < left_buttons; i++) @@ -362,59 +609,63 @@ make_dialog (name, parent, pop_up_p, shell_title, icon_name, text_input_slot, ra XtSetArg (av [ac], XtNtop, XtChainBottom); ac++; XtSetArg (av [ac], XtNbottom, XtChainBottom); ac++; XtSetArg (av [ac], XtNresizable, True); ac++; +#ifdef HAVE_XAW3D + if (DefaultDepthOfScreen (XtScreen (dialog)) >= 16) + { + /* Turn of dithered shadow if we can. Looks bad */ + XtSetArg (av [ac], "beNiceToColormap", False); ac++; + } +#endif sprintf (button_name, "button%d", ++bc); button = XtCreateManagedWidget (button_name, commandWidgetClass, dialog, av, ac); +#ifdef HAVE_XFT + if (xft_font) + { + fill_xft_data (&instance->xft_data[bc], button, xft_font); + XtOverrideTranslations (button, button_override); + } +#endif } - if (right_buttons) - { - /* Create a separator - I want the separator to take up the slack between the buttons on - the right and the buttons on the left (that is I want the buttons - after the separator to be packed against the right edge of the - window) but I can't seem to make it do it. - */ - ac = 0; - XtSetArg (av [ac], XtNfromHoriz, button); ac++; -/* XtSetArg (av [ac], XtNfromVert, XtNameToWidget (dialog, "label")); ac++; */ - XtSetArg (av [ac], XtNleft, XtChainLeft); ac++; - XtSetArg (av [ac], XtNright, XtChainRight); ac++; - XtSetArg (av [ac], XtNtop, XtChainBottom); ac++; - XtSetArg (av [ac], XtNbottom, XtChainBottom); ac++; - XtSetArg (av [ac], XtNlabel, ""); ac++; - XtSetArg (av [ac], XtNwidth, 30); ac++; /* #### aaack!! */ - XtSetArg (av [ac], XtNborderWidth, 0); ac++; - XtSetArg (av [ac], XtNshapeStyle, XmuShapeRectangle); ac++; - XtSetArg (av [ac], XtNresizable, False); ac++; - XtSetArg (av [ac], XtNsensitive, False); ac++; - button = XtCreateManagedWidget ("separator", - /* labelWidgetClass, */ - /* This has to be Command to fake out - the Dialog widget... */ - commandWidgetClass, - dialog, av, ac); - } for (i = 0; i < right_buttons; i++) { ac = 0; XtSetArg (av [ac], XtNfromHoriz, button); ac++; + if (i == 0) + { + /* Separator to the other buttons. */ + XtSetArg (av [ac], XtNhorizDistance, 30); ac++; + } XtSetArg (av [ac], XtNleft, XtChainRight); ac++; XtSetArg (av [ac], XtNright, XtChainRight); ac++; XtSetArg (av [ac], XtNtop, XtChainBottom); ac++; XtSetArg (av [ac], XtNbottom, XtChainBottom); ac++; XtSetArg (av [ac], XtNresizable, True); ac++; +#ifdef HAVE_XAW3D + if (DefaultDepthOfScreen (XtScreen (dialog)) >= 16) + { + /* Turn of dithered shadow if we can. Looks bad */ + XtSetArg (av [ac], "beNiceToColormap", False); ac++; + } +#endif sprintf (button_name, "button%d", ++bc); button = XtCreateManagedWidget (button_name, commandWidgetClass, dialog, av, ac); +#ifdef HAVE_XFT + if (xft_font) + { + fill_xft_data (&instance->xft_data[bc], button, xft_font); + XtOverrideTranslations (button, button_override); + } +#endif } return dialog; } Widget -xaw_create_dialog (instance) - widget_instance* instance; +xaw_create_dialog (widget_instance *instance) { char *name = instance->info->type; Widget parent = instance->parent; @@ -472,17 +723,13 @@ xaw_create_dialog (instance) widget = make_dialog (name, parent, pop_up_p, shell_name, icon_name, text_input_slot, radio_box, - list, left_buttons, right_buttons); - + list, left_buttons, right_buttons, instance); return widget; } static void -xaw_generic_callback (widget, closure, call_data) - Widget widget; - XtPointer closure; - XtPointer call_data; +xaw_generic_callback (Widget widget, XtPointer closure, XtPointer call_data) { widget_instance *instance = (widget_instance *) closure; Widget instance_widget; @@ -502,10 +749,6 @@ xaw_generic_callback (widget, closure, call_data) id = instance->info->id; -#if 0 - user_data = NULL; - XtVaGetValues (widget, XtNuserData, &user_data, NULL); -#else /* Damn! Athena doesn't give us a way to hang our own data on the buttons, so we have to go find it... I guess this assumes that all instances of a button have the same call data. */ @@ -521,23 +764,22 @@ xaw_generic_callback (widget, closure, call_data) if (! val) abort (); user_data = val->call_data; } -#endif if (instance->info->selection_cb) instance->info->selection_cb (widget, id, user_data); } static void -wm_delete_window (w, closure, call_data) - Widget w; - XtPointer closure; - XtPointer call_data; +wm_delete_window (Widget w, + XEvent *event, + String *params, + Cardinal *num_params) { LWLIB_ID id; Cardinal nkids; int i; Widget *kids = 0; - Widget widget, shell; + Widget widget = 0, shell; if (XtIsSubclass (w, dialogWidgetClass)) shell = XtParent (w); @@ -556,6 +798,8 @@ wm_delete_window (w, closure, call_data) if (XtIsSubclass (widget, dialogWidgetClass)) break; } + if (! widget) return; + id = lw_get_widget_id (widget); if (! id) abort (); @@ -570,111 +814,9 @@ wm_delete_window (w, closure, call_data) } -/* Scrollbars */ - -#if 0 -static void -xaw_scrollbar_scroll (widget, closure, call_data) - Widget widget; - XtPointer closure; - XtPointer call_data; -{ - widget_instance *instance = (widget_instance *) closure; - LWLIB_ID id; - scroll_event event_data; - - if (!instance || widget->core.being_destroyed) - return; - - id = instance->info->id; - event_data.slider_value = 0; - event_data.time = 0; - - if ((int) call_data > 0) - event_data.action = SCROLLBAR_PAGE_DOWN; - else - event_data.action = SCROLLBAR_PAGE_UP; - - if (instance->info->pre_activate_cb) - instance->info->pre_activate_cb (widget, id, (XtPointer) &event_data); -} -#endif - -#if 0 -static void -xaw_scrollbar_jump (widget, closure, call_data) - Widget widget; - XtPointer closure; - XtPointer call_data; -{ - widget_instance *instance = (widget_instance *) closure; - LWLIB_ID id; - scroll_event event_data; - scrollbar_values *val = - (scrollbar_values *) instance->info->val->scrollbar_data; - float percent; - - if (!instance || widget->core.being_destroyed) - return; - - id = instance->info->id; - - percent = * (float *) call_data; - event_data.slider_value = - (int) (percent * (float) (val->maximum - val->minimum)) + val->minimum; - - event_data.time = 0; - event_data.action = SCROLLBAR_DRAG; - - if (instance->info->pre_activate_cb) - instance->info->pre_activate_cb (widget, id, (XtPointer) &event_data); -} -#endif - -static Widget -xaw_create_scrollbar (instance) - widget_instance *instance; -{ -#if 0 - Arg av[20]; - int ac = 0; - Dimension width; - Widget scrollbar; - - XtVaGetValues (instance->parent, XtNwidth, &width, NULL); - - XtSetArg (av[ac], XtNshowGrip, 0); ac++; - XtSetArg (av[ac], XtNresizeToPreferred, 1); ac++; - XtSetArg (av[ac], XtNallowResize, True); ac++; - XtSetArg (av[ac], XtNskipAdjust, True); ac++; - XtSetArg (av[ac], XtNwidth, width); ac++; - XtSetArg (av[ac], XtNmappedWhenManaged, True); ac++; - - scrollbar = - XtCreateWidget (instance->info->name, scrollbarWidgetClass, - instance->parent, av, ac); - - /* We have to force the border width to be 0 otherwise the - geometry manager likes to start looping for awhile... */ - XtVaSetValues (scrollbar, XtNborderWidth, 0, NULL); - - XtRemoveAllCallbacks (scrollbar, "jumpProc"); - XtRemoveAllCallbacks (scrollbar, "scrollProc"); - - XtAddCallback (scrollbar, "jumpProc", xaw_scrollbar_jump, - (XtPointer) instance); - XtAddCallback (scrollbar, "scrollProc", xaw_scrollbar_scroll, - (XtPointer) instance); - - return scrollbar; -#else - return NULL; -#endif -} static Widget -xaw_create_main (instance) - widget_instance *instance; +xaw_create_main (widget_instance *instance) { Arg al[1]; int ac; @@ -689,10 +831,7 @@ xaw_create_main (instance) widget_creation_entry xaw_creation_table [] = { - {"scrollbar", xaw_create_scrollbar}, {"main", xaw_create_main}, {NULL, NULL} }; -/* arch-tag: fbbd3589-ae1c-41a0-9142-f628cfee6564 - (do not change this comment) */ diff --git a/lwlib/lwlib-Xaw.h b/lwlib/lwlib-Xaw.h index 41b8013ee64..cf231270121 100644 --- a/lwlib/lwlib-Xaw.h +++ b/lwlib/lwlib-Xaw.h @@ -6,27 +6,25 @@ extern widget_creation_entry xaw_creation_table []; Widget -xaw_create_dialog __P ((widget_instance*)); +xaw_create_dialog (widget_instance*); Boolean -lw_xaw_widget_p __P ((Widget)); +lw_xaw_widget_p (Widget); void -xaw_update_one_widget __P ((widget_instance *, Widget, widget_value *, Boolean)); +xaw_update_one_widget (widget_instance *, Widget, widget_value *, Boolean); void -xaw_update_one_value __P ((widget_instance *, Widget, widget_value *)); +xaw_update_one_value (widget_instance *, Widget, widget_value *); void -xaw_destroy_instance __P ((widget_instance *)); +xaw_destroy_instance (widget_instance *); void -xaw_popup_menu __P ((Widget, XEvent *)); +xaw_popup_menu (Widget, XEvent *); void -xaw_pop_instance __P ((widget_instance *, Boolean)); +xaw_pop_instance (widget_instance *, Boolean); #endif /* LWLIB_XAW_H */ -/* arch-tag: 7c0fb4de-afd9-4112-9214-24b663cc1870 - (do not change this comment) */ diff --git a/lwlib/lwlib-Xlw.c b/lwlib/lwlib-Xlw.c index d6cbb3382f0..c988f1dcb49 100644 --- a/lwlib/lwlib-Xlw.c +++ b/lwlib/lwlib-Xlw.c @@ -43,8 +43,7 @@ Boston, MA 02110-1301, USA. */ This is sometimes handy to have available. */ void -x_print_complete_resource_name (widget) - Widget widget; +x_print_complete_resource_name (Widget widget) { int i; String names[100]; @@ -72,10 +71,7 @@ x_print_complete_resource_name (widget) if there isn't any highlighted menu item. */ static void -highlight_hook (w, client_data, call_data) - Widget w; - XtPointer client_data; - XtPointer call_data; +highlight_hook (Widget w, XtPointer client_data, XtPointer call_data) { widget_instance *instance = (widget_instance *) client_data; @@ -85,29 +81,20 @@ highlight_hook (w, client_data, call_data) } static void -enter_hook (w, client_data, call_data) - Widget w; - XtPointer client_data; - XtPointer call_data; +enter_hook (Widget w, XtPointer client_data, XtPointer call_data) { highlight_hook (w, client_data, call_data); } static void -leave_hook (w, client_data, call_data) - Widget w; - XtPointer client_data; - XtPointer call_data; +leave_hook (Widget w, XtPointer client_data, XtPointer call_data) { highlight_hook (w, client_data, NULL); } static void -pre_hook (w, client_data, call_data) - Widget w; - XtPointer client_data; - XtPointer call_data; +pre_hook (Widget w, XtPointer client_data, XtPointer call_data) { widget_instance* instance = (widget_instance*)client_data; widget_value* val; @@ -122,10 +109,7 @@ pre_hook (w, client_data, call_data) } static void -pick_hook (w, client_data, call_data) - Widget w; - XtPointer client_data; - XtPointer call_data; +pick_hook (Widget w, XtPointer client_data, XtPointer call_data) { widget_instance* instance = (widget_instance*)client_data; widget_value* contents_val = (widget_value*)call_data; @@ -150,8 +134,7 @@ pick_hook (w, client_data, call_data) /* creation functions */ static Widget -xlw_create_menubar (instance) - widget_instance* instance; +xlw_create_menubar (widget_instance *instance) { Widget widget; Arg al[5]; @@ -178,8 +161,7 @@ xlw_create_menubar (instance) } static Widget -xlw_create_popup_menu (instance) - widget_instance* instance; +xlw_create_popup_menu (widget_instance *instance) { Widget popup_shell = XtCreatePopupShell (instance->info->name, overrideShellWidgetClass, @@ -214,8 +196,7 @@ xlw_creation_table [] = }; Boolean -lw_lucid_widget_p (widget) - Widget widget; +lw_lucid_widget_p (Widget widget) { WidgetClass the_class = XtClass (widget); @@ -228,16 +209,8 @@ lw_lucid_widget_p (widget) } void -#ifdef PROTOTYPES xlw_update_one_widget (widget_instance* instance, Widget widget, widget_value* val, Boolean deep_p) -#else -xlw_update_one_widget (instance, widget, val, deep_p) - widget_instance* instance; - Widget widget; - widget_value* val; - Boolean deep_p; -#endif { Arg al[1]; @@ -249,29 +222,20 @@ xlw_update_one_widget (instance, widget, val, deep_p) } void -xlw_update_one_value (instance, widget, val) - widget_instance* instance; - Widget widget; - widget_value* val; +xlw_update_one_value (widget_instance *instance, + Widget widget, + widget_value *val) { return; } void -#ifdef PROTOTYPES xlw_pop_instance (widget_instance* instance, Boolean up) -#else -xlw_pop_instance (instance, up) - widget_instance* instance; - Boolean up; -#endif { } void -xlw_popup_menu (widget, event) - Widget widget; - XEvent *event; +xlw_popup_menu (Widget widget, XEvent *event) { XlwMenuWidget mw; @@ -304,12 +268,9 @@ xlw_popup_menu (widget, event) /* Destruction of instances */ void -xlw_destroy_instance (instance) - widget_instance* instance; +xlw_destroy_instance (widget_instance *instance) { if (instance->widget) XtDestroyWidget (instance->widget); } -/* arch-tag: 541e3912-477d-406e-9bf2-dbf2b7ff8c3b - (do not change this comment) */ diff --git a/lwlib/lwlib-Xlw.h b/lwlib/lwlib-Xlw.h index 36f8244101b..3b2c301c3d3 100644 --- a/lwlib/lwlib-Xlw.h +++ b/lwlib/lwlib-Xlw.h @@ -7,26 +7,24 @@ extern widget_creation_entry xlw_creation_table []; extern widget_creation_function xlw_create_dialog; Boolean -lw_lucid_widget_p __P ((Widget widget)); +lw_lucid_widget_p (Widget widget); void -xlw_update_one_widget __P ((widget_instance* instance, Widget widget, - widget_value* val, Boolean deep_p)); +xlw_update_one_widget (widget_instance* instance, Widget widget, + widget_value* val, Boolean deep_p); void -xlw_update_one_value __P ((widget_instance* instance, Widget widget, - widget_value* val)); +xlw_update_one_value (widget_instance* instance, Widget widget, + widget_value* val); void -xlw_destroy_instance __P ((widget_instance* instance)); +xlw_destroy_instance (widget_instance* instance); void -xlw_pop_instance __P ((widget_instance* instance, Boolean up)); +xlw_pop_instance (widget_instance* instance, Boolean up); void -xlw_popup_menu __P ((Widget widget, XEvent * event)); +xlw_popup_menu (Widget widget, XEvent * event); #endif /* LWLIB_XLW_H */ -/* arch-tag: e5b1511d-8992-4dad-b947-a2440d8f10a2 - (do not change this comment) */ diff --git a/lwlib/lwlib-Xm.c b/lwlib/lwlib-Xm.c index cd5580c643b..b6c2ef1b323 100644 --- a/lwlib/lwlib-Xm.c +++ b/lwlib/lwlib-Xm.c @@ -65,13 +65,6 @@ Boston, MA 02110-1301, USA. */ #include <Xm/DialogS.h> #include <Xm/Form.h> -#undef P_ -#if defined __STDC__ || defined PROTOTYPES -#define P_(X) X -#else -#define P_(X) () -#endif - enum do_call_type { pre_activate, selection, no_selection, post_activate }; @@ -86,63 +79,63 @@ typedef struct _destroyed_instance struct _destroyed_instance* next; } destroyed_instance; -static destroyed_instance *make_destroyed_instance P_ ((char *, char *, - Widget, Widget, - Boolean)); -static void free_destroyed_instance P_ ((destroyed_instance*)); -Widget first_child P_ ((Widget)); -Boolean lw_motif_widget_p P_ ((Widget)); -static XmString resource_motif_string P_ ((Widget, char *)); -static void destroy_all_children P_ ((Widget, int)); -static void xm_update_label P_ ((widget_instance *, Widget, widget_value *)); -static void xm_update_list P_ ((widget_instance *, Widget, widget_value *)); -static void xm_update_pushbutton P_ ((widget_instance *, Widget, - widget_value *)); -static void xm_update_cascadebutton P_ ((widget_instance *, Widget, - widget_value *)); -static void xm_update_toggle P_ ((widget_instance *, Widget, widget_value *)); -static void xm_update_radiobox P_ ((widget_instance *, Widget, widget_value *)); -static void make_menu_in_widget P_ ((widget_instance *, Widget, - widget_value *, int)); -static void update_one_menu_entry P_ ((widget_instance *, Widget, - widget_value *, Boolean)); -static void xm_update_menu P_ ((widget_instance *, Widget, widget_value *, - Boolean)); -static void xm_update_text P_ ((widget_instance *, Widget, widget_value *)); -static void xm_update_text_field P_ ((widget_instance *, Widget, - widget_value *)); -void xm_update_one_value P_ ((widget_instance *, Widget, widget_value *)); -static void activate_button P_ ((Widget, XtPointer, XtPointer)); -static Widget make_dialog P_ ((char *, Widget, Boolean, char *, char *, - Boolean, Boolean, Boolean, int, int)); -static destroyed_instance* find_matching_instance P_ ((widget_instance*)); -static void mark_dead_instance_destroyed P_ ((Widget, XtPointer, XtPointer)); -static void recenter_widget P_ ((Widget)); -static Widget recycle_instance P_ ((destroyed_instance*)); -Widget xm_create_dialog P_ ((widget_instance*)); -static Widget make_menubar P_ ((widget_instance*)); -static void remove_grabs P_ ((Widget, XtPointer, XtPointer)); -static Widget make_popup_menu P_ ((widget_instance*)); -static Widget make_main P_ ((widget_instance*)); -void xm_destroy_instance P_ ((widget_instance*)); -void xm_popup_menu P_ ((Widget, XEvent *)); -static void set_min_dialog_size P_ ((Widget)); -static void do_call P_ ((Widget, XtPointer, enum do_call_type)); -static void xm_generic_callback P_ ((Widget, XtPointer, XtPointer)); -static void xm_nosel_callback P_ ((Widget, XtPointer, XtPointer)); -static void xm_pull_down_callback P_ ((Widget, XtPointer, XtPointer)); -static void xm_pop_down_callback P_ ((Widget, XtPointer, XtPointer)); -void xm_set_keyboard_focus P_ ((Widget, Widget)); -void xm_set_main_areas P_ ((Widget, Widget, Widget)); -static void xm_internal_update_other_instances P_ ((Widget, XtPointer, - XtPointer)); -static void xm_arm_callback P_ ((Widget, XtPointer, XtPointer)); +static destroyed_instance *make_destroyed_instance (char *, char *, + Widget, Widget, + Boolean); +static void free_destroyed_instance (destroyed_instance*); +Widget first_child (Widget); +Boolean lw_motif_widget_p (Widget); +static XmString resource_motif_string (Widget, char *); +static void destroy_all_children (Widget, int); +static void xm_update_label (widget_instance *, Widget, widget_value *); +static void xm_update_list (widget_instance *, Widget, widget_value *); +static void xm_update_pushbutton (widget_instance *, Widget, + widget_value *); +static void xm_update_cascadebutton (widget_instance *, Widget, + widget_value *); +static void xm_update_toggle (widget_instance *, Widget, widget_value *); +static void xm_update_radiobox (widget_instance *, Widget, widget_value *); +static void make_menu_in_widget (widget_instance *, Widget, + widget_value *, int); +static void update_one_menu_entry (widget_instance *, Widget, + widget_value *, Boolean); +static void xm_update_menu (widget_instance *, Widget, widget_value *, + Boolean); +static void xm_update_text (widget_instance *, Widget, widget_value *); +static void xm_update_text_field (widget_instance *, Widget, + widget_value *); +void xm_update_one_value (widget_instance *, Widget, widget_value *); +static void activate_button (Widget, XtPointer, XtPointer); +static Widget make_dialog (char *, Widget, Boolean, char *, char *, + Boolean, Boolean, Boolean, int, int); +static destroyed_instance* find_matching_instance (widget_instance*); +static void mark_dead_instance_destroyed (Widget, XtPointer, XtPointer); +static void recenter_widget (Widget); +static Widget recycle_instance (destroyed_instance*); +Widget xm_create_dialog (widget_instance*); +static Widget make_menubar (widget_instance*); +static void remove_grabs (Widget, XtPointer, XtPointer); +static Widget make_popup_menu (widget_instance*); +static Widget make_main (widget_instance*); +void xm_destroy_instance (widget_instance*); +void xm_popup_menu (Widget, XEvent *); +static void set_min_dialog_size (Widget); +static void do_call (Widget, XtPointer, enum do_call_type); +static void xm_generic_callback (Widget, XtPointer, XtPointer); +static void xm_nosel_callback (Widget, XtPointer, XtPointer); +static void xm_pull_down_callback (Widget, XtPointer, XtPointer); +static void xm_pop_down_callback (Widget, XtPointer, XtPointer); +void xm_set_keyboard_focus (Widget, Widget); +void xm_set_main_areas (Widget, Widget, Widget); +static void xm_internal_update_other_instances (Widget, XtPointer, + XtPointer); +static void xm_arm_callback (Widget, XtPointer, XtPointer); #if 0 -void xm_update_one_widget P_ ((widget_instance *, Widget, widget_value *, - Boolean)); -void xm_pop_instance P_ ((widget_instance*, Boolean)); -void xm_manage_resizing P_ ((Widget, Boolean)); +void xm_update_one_widget (widget_instance *, Widget, widget_value *, + Boolean); +void xm_pop_instance (widget_instance*, Boolean); +void xm_manage_resizing (Widget, Boolean); #endif @@ -152,8 +145,7 @@ void xm_manage_resizing P_ ((Widget, Boolean)); This is sometimes handy to have available. */ void -x_print_complete_resource_name (widget) - Widget widget; +x_print_complete_resource_name (Widget widget) { int i; String names[100]; @@ -175,12 +167,11 @@ x_print_complete_resource_name (widget) static destroyed_instance *all_destroyed_instances = NULL; static destroyed_instance* -make_destroyed_instance (name, type, widget, parent, pop_up_p) - char* name; - char* type; - Widget widget; - Widget parent; - Boolean pop_up_p; +make_destroyed_instance (char* name, + char* type, + Widget widget, + Widget parent, + Boolean pop_up_p) { destroyed_instance* instance = (destroyed_instance*)malloc (sizeof (destroyed_instance)); @@ -194,8 +185,7 @@ make_destroyed_instance (name, type, widget, parent, pop_up_p) } static void -free_destroyed_instance (instance) - destroyed_instance* instance; +free_destroyed_instance (destroyed_instance* instance) { free (instance->name); free (instance->type); @@ -204,15 +194,13 @@ free_destroyed_instance (instance) /* motif utility functions */ Widget -first_child (widget) - Widget widget; +first_child (Widget widget) { return ((CompositeWidget)widget)->composite.children [0]; } Boolean -lw_motif_widget_p (widget) - Widget widget; +lw_motif_widget_p (Widget widget) { return XtClass (widget) == xmDialogShellWidgetClass @@ -220,9 +208,8 @@ lw_motif_widget_p (widget) } static XmString -resource_motif_string (widget, name) - Widget widget; - char* name; +resource_motif_string (Widget widget, + char* name) { XtResource resource; XmString result = 0; @@ -244,9 +231,8 @@ resource_motif_string (widget, name) starting with number FIRST_CHILD_TO_DESTROY. */ static void -destroy_all_children (widget, first_child_to_destroy) - Widget widget; - int first_child_to_destroy; +destroy_all_children (Widget widget, + int first_child_to_destroy) { Widget* children; unsigned int number; @@ -292,9 +278,7 @@ destroy_all_children (widget, first_child_to_destroy) is called. */ static void -xm_arm_callback (w, client_data, call_data) - Widget w; - XtPointer client_data, call_data; +xm_arm_callback (Widget w, XtPointer client_data, XtPointer call_data) { XmPushButtonCallbackStruct *cbs = (XmPushButtonCallbackStruct *) call_data; widget_value *wv = (widget_value *) client_data; @@ -346,10 +330,9 @@ xm_arm_callback (w, client_data, call_data) not null, and contains the label string to display. */ static void -xm_update_label (instance, widget, val) - widget_instance* instance; - Widget widget; - widget_value* val; +xm_update_label (widget_instance* instance, + Widget widget, + widget_value* val) { XmString res_string = 0; XmString built_string = 0; @@ -397,10 +380,9 @@ xm_update_label (instance, widget, val) /* update of list */ static void -xm_update_list (instance, widget, val) - widget_instance* instance; - Widget widget; - widget_value* val; +xm_update_list (widget_instance* instance, + Widget widget, + widget_value* val) { widget_value* cur; int i; @@ -421,10 +403,9 @@ xm_update_list (instance, widget, val) /* update of buttons */ static void -xm_update_pushbutton (instance, widget, val) - widget_instance* instance; - Widget widget; - widget_value* val; +xm_update_pushbutton (widget_instance* instance, + Widget widget, + widget_value* val) { XtVaSetValues (widget, XmNalignment, XmALIGNMENT_CENTER, NULL); XtRemoveAllCallbacks (widget, XmNactivateCallback); @@ -432,10 +413,9 @@ xm_update_pushbutton (instance, widget, val) } static void -xm_update_cascadebutton (instance, widget, val) - widget_instance* instance; - Widget widget; - widget_value* val; +xm_update_cascadebutton (widget_instance* instance, + Widget widget, + widget_value* val) { /* Should also rebuild the menu by calling ...update_menu... */ XtRemoveAllCallbacks (widget, XmNcascadingCallback); @@ -445,10 +425,9 @@ xm_update_cascadebutton (instance, widget, val) /* update toggle and radiobox */ static void -xm_update_toggle (instance, widget, val) - widget_instance* instance; - Widget widget; - widget_value* val; +xm_update_toggle (widget_instance* instance, + Widget widget, + widget_value* val) { XtRemoveAllCallbacks (widget, XmNvalueChangedCallback); XtAddCallback (widget, XmNvalueChangedCallback, @@ -458,10 +437,9 @@ xm_update_toggle (instance, widget, val) } static void -xm_update_radiobox (instance, widget, val) - widget_instance* instance; - Widget widget; - widget_value* val; +xm_update_radiobox (widget_instance* instance, + Widget widget, + widget_value* val) { Widget toggle; @@ -505,11 +483,10 @@ xm_update_radiobox (instance, widget, val) /* KEEP_FIRST_CHILDREN gives the number of initial children to keep. */ static void -make_menu_in_widget (instance, widget, val, keep_first_children) - widget_instance* instance; - Widget widget; - widget_value* val; - int keep_first_children; +make_menu_in_widget (widget_instance* instance, + Widget widget, + widget_value* val, + int keep_first_children) { Widget* children = 0; int num_children; @@ -662,11 +639,10 @@ make_menu_in_widget (instance, widget, val, keep_first_children) } static void -update_one_menu_entry (instance, widget, val, deep_p) - widget_instance* instance; - Widget widget; - widget_value* val; - Boolean deep_p; +update_one_menu_entry (widget_instance* instance, + Widget widget, + widget_value* val, + Boolean deep_p) { Arg al [256]; int ac; @@ -764,11 +740,10 @@ update_one_menu_entry (instance, widget, val, deep_p) } static void -xm_update_menu (instance, widget, val, deep_p) - widget_instance* instance; - Widget widget; - widget_value* val; - Boolean deep_p; +xm_update_menu (widget_instance* instance, + Widget widget, + widget_value* val, + Boolean deep_p) { Widget* children; unsigned int num_children; @@ -839,10 +814,9 @@ xm_update_menu (instance, widget, val, deep_p) /* update text widgets */ static void -xm_update_text (instance, widget, val) - widget_instance* instance; - Widget widget; - widget_value* val; +xm_update_text (widget_instance* instance, + Widget widget, + widget_value* val) { XmTextSetString (widget, val->value ? val->value : ""); XtRemoveAllCallbacks (widget, XmNactivateCallback); @@ -853,10 +827,9 @@ xm_update_text (instance, widget, val) } static void -xm_update_text_field (instance, widget, val) - widget_instance* instance; - Widget widget; - widget_value* val; +xm_update_text_field (widget_instance* instance, + Widget widget, + widget_value* val) { XmTextFieldSetString (widget, val->value ? val->value : ""); XtRemoveAllCallbacks (widget, XmNactivateCallback); @@ -870,11 +843,10 @@ xm_update_text_field (instance, widget, val) /* update a motif widget */ void -xm_update_one_widget (instance, widget, val, deep_p) - widget_instance* instance; - Widget widget; - widget_value* val; - Boolean deep_p; +xm_update_one_widget (widget_instance* instance, + Widget widget, + widget_value* val, + Boolean deep_p) { WidgetClass class; @@ -935,10 +907,9 @@ xm_update_one_widget (instance, widget, val, deep_p) /* getting the value back */ void -xm_update_one_value (instance, widget, val) - widget_instance* instance; - Widget widget; - widget_value* val; +xm_update_one_value (widget_instance* instance, + Widget widget, + widget_value* val) { WidgetClass class = XtClass (widget); widget_value *old_wv; @@ -1031,10 +1002,9 @@ xm_update_one_value (instance, widget, val) I could not find a way to do that with accelerators. */ static void -activate_button (widget, closure, call_data) - Widget widget; - XtPointer closure; - XtPointer call_data; +activate_button (Widget widget, + XtPointer closure, + XtPointer call_data) { Widget button = (Widget)closure; XtCallCallbacks (button, XmNactivateCallback, NULL); @@ -1044,11 +1014,10 @@ activate_button (widget, closure, call_data) /* Called for key press in dialogs. Used to pop down dialog on ESC. */ static void -dialog_key_cb (widget, closure, event, continue_to_dispatch) - Widget widget; - XtPointer closure; - XEvent *event; - Boolean *continue_to_dispatch; +dialog_key_cb (Widget widget, + XtPointer closure, + XEvent *event, + Boolean *continue_to_dispatch) { KeySym sym = 0; Modifiers modif_ret; @@ -1071,18 +1040,16 @@ dialog_key_cb (widget, closure, event, continue_to_dispatch) /* dialogs */ static Widget -make_dialog (name, parent, pop_up_p, shell_title, icon_name, text_input_slot, - radio_box, list, left_buttons, right_buttons) - char* name; - Widget parent; - Boolean pop_up_p; - char* shell_title; - char* icon_name; - Boolean text_input_slot; - Boolean radio_box; - Boolean list; - int left_buttons; - int right_buttons; +make_dialog (char* name, + Widget parent, + Boolean pop_up_p, + char* shell_title, + char* icon_name, + Boolean text_input_slot, + Boolean radio_box, + Boolean list, + int left_buttons, + int right_buttons) { Widget result; Widget form; @@ -1335,8 +1302,7 @@ make_dialog (name, parent, pop_up_p, shell_title, icon_name, text_input_slot, } static destroyed_instance* -find_matching_instance (instance) - widget_instance* instance; +find_matching_instance (widget_instance* instance) { destroyed_instance* cur; destroyed_instance* prev; @@ -1373,18 +1339,16 @@ find_matching_instance (instance) } static void -mark_dead_instance_destroyed (widget, closure, call_data) - Widget widget; - XtPointer closure; - XtPointer call_data; +mark_dead_instance_destroyed (Widget widget, + XtPointer closure, + XtPointer call_data) { destroyed_instance* instance = (destroyed_instance*)closure; instance->widget = NULL; } static void -recenter_widget (widget) - Widget widget; +recenter_widget (Widget widget) { Widget parent = XtParent (widget); Screen* screen = XtScreen (widget); @@ -1420,8 +1384,7 @@ recenter_widget (widget) } static Widget -recycle_instance (instance) - destroyed_instance* instance; +recycle_instance (destroyed_instance* instance) { Widget widget = instance->widget; @@ -1457,8 +1420,7 @@ recycle_instance (instance) } Widget -xm_create_dialog (instance) - widget_instance* instance; +xm_create_dialog (widget_instance* instance) { char* name = instance->info->type; Widget parent = instance->parent; @@ -1538,8 +1500,7 @@ xm_create_dialog (instance) because we have not yet managed to make it work right in Motif. */ static Widget -make_menubar (instance) - widget_instance* instance; +make_menubar (widget_instance* instance) { Arg al[3]; int ac; @@ -1550,18 +1511,16 @@ make_menubar (instance) } static void -remove_grabs (shell, closure, call_data) - Widget shell; - XtPointer closure; - XtPointer call_data; +remove_grabs (Widget shell, + XtPointer closure, + XtPointer call_data) { Widget menu = (Widget) closure; XmRemoveFromPostFromList (menu, XtParent (XtParent (menu))); } static Widget -make_popup_menu (instance) - widget_instance* instance; +make_popup_menu (widget_instance* instance) { Widget parent = instance->parent; Window parent_window = parent->core.window; @@ -1577,8 +1536,7 @@ make_popup_menu (instance) } static Widget -make_main (instance) - widget_instance* instance; +make_main (widget_instance* instance) { Widget parent = instance->parent; Widget result; @@ -1717,8 +1675,7 @@ xm_creation_table [] = /* Destruction of instances */ void -xm_destroy_instance (instance) - widget_instance* instance; +xm_destroy_instance ( widget_instance* instance) { Widget widget = instance->widget; /* recycle the dialog boxes */ @@ -1752,9 +1709,7 @@ xm_destroy_instance (instance) /* popup utility */ void -xm_popup_menu (widget, event) - Widget widget; - XEvent *event; +xm_popup_menu (Widget widget, XEvent *event) { XButtonPressedEvent dummy; @@ -1802,8 +1757,7 @@ xm_popup_menu (widget, event) } static void -set_min_dialog_size (w) - Widget w; +set_min_dialog_size (Widget w) { short width; short height; @@ -1812,9 +1766,7 @@ set_min_dialog_size (w) } void -xm_pop_instance (instance, up) - widget_instance* instance; - Boolean up; +xm_pop_instance (widget_instance* instance, Boolean up) { Widget widget = instance->widget; @@ -1843,10 +1795,9 @@ xm_pop_instance (instance, up) /* motif callback */ static void -do_call (widget, closure, type) - Widget widget; - XtPointer closure; - enum do_call_type type; +do_call (Widget widget, + XtPointer closure, + enum do_call_type type) { Arg al [256]; int ac; @@ -1903,10 +1854,9 @@ do_call (widget, closure, type) if the widget was ``destroyed'' by caching it in the all_destroyed_instances list */ static void -xm_internal_update_other_instances (widget, closure, call_data) - Widget widget; - XtPointer closure; - XtPointer call_data; +xm_internal_update_other_instances (Widget widget, + XtPointer closure, + XtPointer call_data) { Widget parent; for (parent = widget; parent; parent = XtParent (parent)) @@ -1918,20 +1868,18 @@ xm_internal_update_other_instances (widget, closure, call_data) } static void -xm_generic_callback (widget, closure, call_data) - Widget widget; - XtPointer closure; - XtPointer call_data; +xm_generic_callback (Widget widget, + XtPointer closure, + XtPointer call_data) { lw_internal_update_other_instances (widget, closure, call_data); do_call (widget, closure, selection); } static void -xm_nosel_callback (widget, closure, call_data) - Widget widget; - XtPointer closure; - XtPointer call_data; +xm_nosel_callback (Widget widget, + XtPointer closure, + XtPointer call_data) { /* This callback is only called when a dialog box is dismissed with the wm's destroy button (WM_DELETE_WINDOW.) We want the dialog @@ -1946,10 +1894,9 @@ xm_nosel_callback (widget, closure, call_data) } static void -xm_pull_down_callback (widget, closure, call_data) - Widget widget; - XtPointer closure; - XtPointer call_data; +xm_pull_down_callback (Widget widget, + XtPointer closure, + XtPointer call_data) { Widget parent = XtParent (widget); @@ -1970,10 +1917,9 @@ xm_pull_down_callback (widget, closure, call_data) menu, whether or not its submenu is visible. */ static void -xm_pop_down_callback (widget, closure, call_data) - Widget widget; - XtPointer closure; - XtPointer call_data; +xm_pop_down_callback (Widget widget, + XtPointer closure, + XtPointer call_data) { widget_instance *instance = (widget_instance *) closure; @@ -1985,9 +1931,7 @@ xm_pop_down_callback (widget, closure, call_data) /* set the keyboard focus */ void -xm_set_keyboard_focus (parent, w) - Widget parent; - Widget w; +xm_set_keyboard_focus (Widget parent, Widget w) { XmProcessTraversal (w, 0); XtSetKeyboardFocus (parent, w); @@ -1995,10 +1939,9 @@ xm_set_keyboard_focus (parent, w) /* Motif hack to set the main window areas. */ void -xm_set_main_areas (parent, menubar, work_area) - Widget parent; - Widget menubar; - Widget work_area; +xm_set_main_areas (Widget parent, + Widget menubar, + Widget work_area) { XmMainWindowSetAreas (parent, menubar, /* menubar (maybe 0) */ @@ -2010,12 +1953,8 @@ xm_set_main_areas (parent, menubar, work_area) /* Motif hack to control resizing on the menubar. */ void -xm_manage_resizing (w, flag) - Widget w; - Boolean flag; +xm_manage_resizing (Widget w, Boolean flag) { XtVaSetValues (w, XtNallowShellResize, flag, NULL); } -/* arch-tag: 73976f64-73b2-4600-aa13-d9ede20ee965 - (do not change this comment) */ diff --git a/lwlib/lwlib-Xm.h b/lwlib/lwlib-Xm.h index 3a827036f36..70f8728f765 100644 --- a/lwlib/lwlib-Xm.h +++ b/lwlib/lwlib-Xm.h @@ -26,38 +26,36 @@ Boston, MA 02110-1301, USA. */ extern widget_creation_entry xm_creation_table []; Widget -xm_create_dialog __P ((widget_instance* instance)); +xm_create_dialog (widget_instance* instance); Boolean -lw_motif_widget_p __P ((Widget widget)); +lw_motif_widget_p (Widget widget); void -xm_update_one_widget __P ((widget_instance* instance, Widget widget, - widget_value* val, Boolean deep_p)); +xm_update_one_widget (widget_instance* instance, Widget widget, + widget_value* val, Boolean deep_p); void -xm_update_one_value __P ((widget_instance* instance, Widget widget, - widget_value* val)); +xm_update_one_value (widget_instance* instance, Widget widget, + widget_value* val); void -xm_destroy_instance __P ((widget_instance* instance)); +xm_destroy_instance (widget_instance* instance); void -xm_set_keyboard_focus __P ((Widget parent, Widget w)); +xm_set_keyboard_focus (Widget parent, Widget w); void -xm_popup_menu __P ((Widget widget, XEvent *event)); +xm_popup_menu (Widget widget, XEvent *event); void -xm_pop_instance __P ((widget_instance* instance, Boolean up)); +xm_pop_instance (widget_instance* instance, Boolean up); void -xm_set_main_areas __P ((Widget parent, Widget menubar, Widget work_area)); +xm_set_main_areas (Widget parent, Widget menubar, Widget work_area); void -xm_manage_resizing __P ((Widget w, Boolean flag)); +xm_manage_resizing (Widget w, Boolean flag); #endif /* LWLIB_XM_H */ -/* arch-tag: 61561304-c146-437b-8ed3-dc33818703c6 - (do not change this comment) */ diff --git a/lwlib/lwlib-int.h b/lwlib/lwlib-int.h index e927dba2c5a..b8e1316e7a4 100644 --- a/lwlib/lwlib-int.h +++ b/lwlib/lwlib-int.h @@ -26,13 +26,19 @@ Boston, MA 02110-1301, USA. */ #include "lwlib.h" -extern char *safe_strdup __P ((const char *)); +extern char *safe_strdup (const char *); + +struct widget_xft_data; typedef struct _widget_instance { Widget widget; Widget parent; Boolean pop_up_p; +#ifdef HAVE_XFT + struct widget_xft_data *xft_data; + int nr_xft_data; +#endif struct _widget_info* info; struct _widget_instance* next; } widget_instance; @@ -52,8 +58,7 @@ typedef struct _widget_info struct _widget_info* next; } widget_info; -typedef Widget -(*widget_creation_function) (); +typedef Widget (*widget_creation_function) (widget_instance *instance); typedef struct _widget_creation_entry { @@ -64,16 +69,14 @@ typedef struct _widget_creation_entry /* update all other instances of a widget. Can be used in a callback when a widget has been used by the user */ void -lw_internal_update_other_instances __P ((Widget, XtPointer, XtPointer)); +lw_internal_update_other_instances (Widget, XtPointer, XtPointer); /* get the widget_value for a widget in a given instance */ widget_value* -lw_get_widget_value_for_widget __P ((widget_instance *, Widget)); +lw_get_widget_value_for_widget (widget_instance *, Widget); -widget_info *lw_get_widget_info __P ((LWLIB_ID)); -widget_instance * lw_get_widget_instance __P ((Widget)); +widget_info *lw_get_widget_info (LWLIB_ID); +widget_instance * lw_get_widget_instance (Widget); #endif /* LWLIB_INTERNAL_H */ -/* arch-tag: ae02f67d-ef25-421c-b956-b01a4b0aac76 - (do not change this comment) */ diff --git a/lwlib/lwlib-utils.c b/lwlib/lwlib-utils.c index 0b14933110c..0a5c553c952 100644 --- a/lwlib/lwlib-utils.c +++ b/lwlib/lwlib-utils.c @@ -42,8 +42,7 @@ Boston, MA 02110-1301, USA. */ /* Redisplay the contents of the widget, without first clearing it. */ void -XtNoClearRefreshWidget (widget) - Widget widget; +XtNoClearRefreshWidget (Widget widget) { XEvent event; @@ -67,10 +66,7 @@ XtNoClearRefreshWidget (widget) * Apply a function to all the subwidgets of a given widget recursively. */ void -XtApplyToWidgets (w, proc, arg) - Widget w; - XtApplyToWidgetsProc proc; - XtPointer arg; +XtApplyToWidgets (Widget w, XtApplyToWidgetsProc proc, XtPointer arg) { if (XtIsComposite (w)) { @@ -81,8 +77,8 @@ XtApplyToWidgets (w, proc, arg) int nkids = cw->composite.num_children; Widget *kids = (Widget *) malloc (sizeof (Widget) * nkids); int i; - lwlib_bcopy ((char *) cw->composite.children, (char *) kids, - sizeof (Widget) * nkids); + memcpy ((char *) kids, (char *) cw->composite.children, + sizeof (Widget) * nkids); for (i = 0; i < nkids; i++) /* This prevent us from using gadgets, why is it here? */ /* if (XtIsWidget (kids [i])) */ @@ -101,10 +97,7 @@ XtApplyToWidgets (w, proc, arg) * Stop as soon as the function returns non NULL and returns this as a value. */ void * -XtApplyUntilToWidgets (w, proc, arg) - Widget w; - XtApplyUntilToWidgetsProc proc; - XtPointer arg; +XtApplyUntilToWidgets (Widget w, XtApplyUntilToWidgetsProc proc, XtPointer arg) { void* result; if (XtIsComposite (w)) @@ -130,9 +123,7 @@ XtApplyUntilToWidgets (w, proc, arg) * Returns a copy of the list of all children of a composite widget */ Widget * -XtCompositeChildren (widget, number) - Widget widget; - unsigned int* number; +XtCompositeChildren (Widget widget, unsigned int *number) { CompositeWidget cw = (CompositeWidget)widget; Widget* result; @@ -153,15 +144,13 @@ XtCompositeChildren (widget, number) } Boolean -XtWidgetBeingDestroyedP (widget) - Widget widget; +XtWidgetBeingDestroyedP (Widget widget) { return widget->core.being_destroyed; } void -XtSafelyDestroyWidget (widget) - Widget widget; +XtSafelyDestroyWidget (Widget widget) { #if 0 @@ -186,5 +175,3 @@ XtSafelyDestroyWidget (widget) #endif } -/* arch-tag: f21f0a1f-2a4e-44e1-8715-7f234fe2d159 - (do not change this comment) */ diff --git a/lwlib/lwlib-utils.h b/lwlib/lwlib-utils.h index 934b0b48f4a..b988374288a 100644 --- a/lwlib/lwlib-utils.h +++ b/lwlib/lwlib-utils.h @@ -1,23 +1,21 @@ #ifndef _LWLIB_UTILS_H_ #define _LWLIB_UTILS_H_ -void XtNoClearRefreshWidget __P ((Widget)); +void XtNoClearRefreshWidget (Widget); -typedef void (*XtApplyToWidgetsProc) __P ((Widget, XtPointer)); -typedef void* (*XtApplyUntilToWidgetsProc) __P ((Widget, XtPointer)); +typedef void (*XtApplyToWidgetsProc) (Widget, XtPointer); +typedef void* (*XtApplyUntilToWidgetsProc) (Widget, XtPointer); -void XtApplyToWidgets __P ((Widget, XtApplyToWidgetsProc, XtPointer)); -void *XtApplyUntilToWidgets __P ((Widget, XtApplyUntilToWidgetsProc, XtPointer)); +void XtApplyToWidgets (Widget, XtApplyToWidgetsProc, XtPointer); +void *XtApplyUntilToWidgets (Widget, XtApplyUntilToWidgetsProc, XtPointer); -Widget *XtCompositeChildren __P ((Widget, unsigned int *)); +Widget *XtCompositeChildren (Widget, unsigned int *); /* returns True is the widget is being destroyed, False otherwise */ Boolean -XtWidgetBeingDestroyedP __P ((Widget widget)); +XtWidgetBeingDestroyedP (Widget widget); -void XtSafelyDestroyWidget __P ((Widget)); +void XtSafelyDestroyWidget (Widget); #endif /* _LWLIB_UTILS_H_ */ -/* arch-tag: 705efd86-9319-4447-80f6-16aa5b349809 - (do not change this comment) */ diff --git a/lwlib/lwlib.c b/lwlib/lwlib.c index e107c3306a5..16e70ac4708 100644 --- a/lwlib/lwlib.c +++ b/lwlib/lwlib.c @@ -66,72 +66,47 @@ static widget_info* all_widget_info = NULL; #ifdef USE_MOTIF -char *lwlib_toolkit_type = "motif"; +const char *lwlib_toolkit_type = "motif"; #else -char *lwlib_toolkit_type = "lucid"; +const char *lwlib_toolkit_type = "lucid"; #endif -static widget_value *merge_widget_value P_ ((widget_value *, - widget_value *, - int, int *)); -static void instantiate_widget_instance P_ ((widget_instance *)); -static int my_strcasecmp P_ ((char *, char *)); -static void safe_free_str P_ ((char *)); -static void free_widget_value_tree P_ ((widget_value *)); -static widget_value *copy_widget_value_tree P_ ((widget_value *, - change_type)); -static widget_info *allocate_widget_info P_ ((char *, char *, LWLIB_ID, - widget_value *, - lw_callback, lw_callback, - lw_callback, lw_callback)); -static void free_widget_info P_ ((widget_info *)); -static void mark_widget_destroyed P_ ((Widget, XtPointer, XtPointer)); -static widget_instance *allocate_widget_instance P_ ((widget_info *, - Widget, Boolean)); -static void free_widget_instance P_ ((widget_instance *)); -static widget_info *get_widget_info P_ ((LWLIB_ID, Boolean)); -static widget_instance *get_widget_instance P_ ((Widget, Boolean)); -static widget_instance *find_instance P_ ((LWLIB_ID, Widget, Boolean)); -static Boolean safe_strcmp P_ ((char *, char *)); -static Widget name_to_widget P_ ((widget_instance *, char *)); -static void set_one_value P_ ((widget_instance *, widget_value *, Boolean)); -static void update_one_widget_instance P_ ((widget_instance *, Boolean)); -static void update_all_widget_values P_ ((widget_info *, Boolean)); -static void initialize_widget_instance P_ ((widget_instance *)); -static widget_creation_function find_in_table P_ ((char *, widget_creation_entry *)); -static Boolean dialog_spec_p P_ ((char *)); -static void destroy_one_instance P_ ((widget_instance *)); -static void lw_pop_all_widgets P_ ((LWLIB_ID, Boolean)); -static Boolean get_one_value P_ ((widget_instance *, widget_value *)); -static void show_one_widget_busy P_ ((Widget, Boolean)); - -void -lwlib_memset (address, value, length) - char *address; - int value; - size_t length; -{ - int i; - - for (i = 0; i < length; i++) - address[i] = value; -} - -void -lwlib_bcopy (from, to, length) - char *from; - char *to; - int length; -{ - int i; - - for (i = 0; i < length; i++) - to[i] = from[i]; -} +static widget_value *merge_widget_value (widget_value *, + widget_value *, + int, int *); +static void instantiate_widget_instance (widget_instance *); +static int my_strcasecmp (const char *, const char *); +static void safe_free_str (char *); +static void free_widget_value_tree (widget_value *); +static widget_value *copy_widget_value_tree (widget_value *, + change_type); +static widget_info *allocate_widget_info (const char *, const char *, LWLIB_ID, + widget_value *, + lw_callback, lw_callback, + lw_callback, lw_callback); +static void free_widget_info (widget_info *); +static void mark_widget_destroyed (Widget, XtPointer, XtPointer); +static widget_instance *allocate_widget_instance (widget_info *, + Widget, Boolean); +static void free_widget_instance (widget_instance *); +static widget_info *get_widget_info (LWLIB_ID, Boolean); +static widget_instance *get_widget_instance (Widget, Boolean); +static widget_instance *find_instance (LWLIB_ID, Widget, Boolean); +static Boolean safe_strcmp (const char *, const char *); +static Widget name_to_widget (widget_instance *, const char *); +static void set_one_value (widget_instance *, widget_value *, Boolean); +static void update_one_widget_instance (widget_instance *, Boolean); +static void update_all_widget_values (widget_info *, Boolean); +static void initialize_widget_instance (widget_instance *); +static widget_creation_function find_in_table (const char *, const widget_creation_entry *); +static Boolean dialog_spec_p (const char *); +static void destroy_one_instance (widget_instance *); +static void lw_pop_all_widgets (LWLIB_ID, Boolean); +static Boolean get_one_value (widget_instance *, widget_value *); +static void show_one_widget_busy (Widget, Boolean); /* utility functions for widget_instance and widget_info */ char * -safe_strdup (s) - const char *s; +safe_strdup (const char *s) { char *result; if (! s) return 0; @@ -145,8 +120,7 @@ safe_strdup (s) /* Like strcmp but ignore differences in case. */ static int -my_strcasecmp (s1, s2) - char *s1, *s2; +my_strcasecmp (const char *s1, const char *s2) { while (1) { @@ -164,8 +138,7 @@ my_strcasecmp (s1, s2) } static void -safe_free_str (s) - char *s; +safe_free_str (char *s) { free (s); } @@ -174,7 +147,7 @@ static widget_value *widget_value_free_list = 0; static int malloc_cpt = 0; widget_value * -malloc_widget_value () +malloc_widget_value (void) { widget_value *wv; if (widget_value_free_list) @@ -188,7 +161,7 @@ malloc_widget_value () wv = (widget_value *) malloc (sizeof (widget_value)); malloc_cpt++; } - lwlib_memset ((void*) wv, 0, sizeof (widget_value)); + memset ((void*) wv, 0, sizeof (widget_value)); return wv; } @@ -196,8 +169,7 @@ malloc_widget_value () by malloc_widget_value(), and no substructures. */ void -free_widget_value (wv) - widget_value *wv; +free_widget_value (widget_value *wv) { if (wv->free_list) abort (); @@ -217,8 +189,7 @@ free_widget_value (wv) } static void -free_widget_value_tree (wv) - widget_value *wv; +free_widget_value_tree (widget_value *wv) { if (!wv) return; @@ -249,9 +220,7 @@ free_widget_value_tree (wv) } static widget_value * -copy_widget_value_tree (val, change) - widget_value* val; - change_type change; +copy_widget_value_tree (widget_value *val, change_type change) { widget_value* copy; @@ -280,16 +249,14 @@ copy_widget_value_tree (val, change) } static widget_info * -allocate_widget_info (type, name, id, val, pre_activate_cb, - selection_cb, post_activate_cb, highlight_cb) - char* type; - char* name; - LWLIB_ID id; - widget_value* val; - lw_callback pre_activate_cb; - lw_callback selection_cb; - lw_callback post_activate_cb; - lw_callback highlight_cb; +allocate_widget_info (const char* type, + const char* name, + LWLIB_ID id, + widget_value* val, + lw_callback pre_activate_cb, + lw_callback selection_cb, + lw_callback post_activate_cb, + lw_callback highlight_cb) { widget_info* info = (widget_info*)malloc (sizeof (widget_info)); info->type = safe_strdup (type); @@ -310,21 +277,17 @@ allocate_widget_info (type, name, id, val, pre_activate_cb, } static void -free_widget_info (info) - widget_info* info; +free_widget_info (widget_info *info) { safe_free_str (info->type); safe_free_str (info->name); free_widget_value_tree (info->val); - lwlib_memset ((void*)info, 0xDEADBEEF, sizeof (widget_info)); + memset ((void*)info, 0xDEADBEEF, sizeof (widget_info)); free (info); } static void -mark_widget_destroyed (widget, closure, call_data) - Widget widget; - XtPointer closure; - XtPointer call_data; +mark_widget_destroyed (Widget widget, XtPointer closure, XtPointer call_data) { widget_instance* instance = (widget_instance*)closure; @@ -333,22 +296,12 @@ mark_widget_destroyed (widget, closure, call_data) instance->widget = NULL; } -/* The messy #ifdef PROTOTYPES here and elsewhere are prompted by a - flood of warnings about argument promotion from proprietary ISO C - compilers. (etags still only makes one entry for each function.) */ static widget_instance * -#ifdef PROTOTYPES allocate_widget_instance (widget_info* info, Widget parent, Boolean pop_up_p) -#else -allocate_widget_instance (info, parent, pop_up_p) - widget_info* info; - Widget parent; - Boolean pop_up_p; -#endif { widget_instance* instance = (widget_instance*)malloc (sizeof (widget_instance)); - bzero (instance, sizeof *instance); + memset (instance, 0, sizeof *instance); instance->parent = parent; instance->pop_up_p = pop_up_p; instance->info = info; @@ -363,21 +316,14 @@ allocate_widget_instance (info, parent, pop_up_p) } static void -free_widget_instance (instance) - widget_instance* instance; +free_widget_instance (widget_instance *instance) { - lwlib_memset ((void*)instance, 0xDEADBEEF, sizeof (widget_instance)); + memset ((void*)instance, 0xDEADBEEF, sizeof (widget_instance)); free (instance); } static widget_info * -#ifdef PROTOTYPES get_widget_info (LWLIB_ID id, Boolean remove_p) -#else -get_widget_info (id, remove_p) - LWLIB_ID id; - Boolean remove_p; -#endif { widget_info* info; widget_info* prev; @@ -401,20 +347,13 @@ get_widget_info (id, remove_p) /* Internal function used by the library dependent implementation to get the widget_value for a given widget in an instance */ widget_info * -lw_get_widget_info (id) - LWLIB_ID id; +lw_get_widget_info (LWLIB_ID id) { return get_widget_info (id, 0); } static widget_instance * -#ifdef PROTOTYPES get_widget_instance (Widget widget, Boolean remove_p) -#else -get_widget_instance (widget, remove_p) - Widget widget; - Boolean remove_p; -#endif { widget_info* info; widget_instance* instance; @@ -441,21 +380,13 @@ get_widget_instance (widget, remove_p) WIDGET, or null if WIDGET is not a lwlib widget. */ widget_instance * -lw_get_widget_instance (widget) - Widget widget; +lw_get_widget_instance (Widget widget) { return get_widget_instance (widget, False); } static widget_instance* -#ifdef PROTOTYPES find_instance (LWLIB_ID id, Widget parent, Boolean pop_up_p) -#else -find_instance (id, parent, pop_up_p) - LWLIB_ID id; - Widget parent; - Boolean pop_up_p; -#endif { widget_info* info = get_widget_info (id, False); widget_instance* instance; @@ -471,9 +402,7 @@ find_instance (id, parent, pop_up_p) /* utility function for widget_value */ static Boolean -safe_strcmp (s1, s2) - char* s1; - char* s2; +safe_strcmp (const char *s1, const char *s2) { if (!!s1 ^ !!s2) return True; return (s1 && s2) ? strcmp (s1, s2) : s1 ? False : !!s2; @@ -500,11 +429,10 @@ safe_strcmp (s1, s2) static widget_value * -merge_widget_value (val1, val2, level, change_p) - widget_value* val1; - widget_value* val2; - int level; - int *change_p; +merge_widget_value (widget_value *val1, + widget_value *val2, + int level, + int *change_p) { change_type change, this_one_change; widget_value* merged_next; @@ -658,9 +586,7 @@ merge_widget_value (val1, val2, level, change_p) /* modifying the widgets */ static Widget -name_to_widget (instance, name) - widget_instance* instance; - char* name; +name_to_widget (widget_instance *instance, const char *name) { Widget widget = NULL; @@ -684,14 +610,7 @@ name_to_widget (instance, name) } static void -#ifdef PROTOTYPES set_one_value (widget_instance* instance, widget_value* val, Boolean deep_p) -#else -set_one_value (instance, val, deep_p) - widget_instance* instance; - widget_value* val; - Boolean deep_p; -#endif { Widget widget = name_to_widget (instance, val->name); @@ -713,13 +632,7 @@ set_one_value (instance, val, deep_p) } static void -#ifdef PROTOTYPES update_one_widget_instance (widget_instance* instance, Boolean deep_p) -#else -update_one_widget_instance (instance, deep_p) - widget_instance* instance; - Boolean deep_p; -#endif { widget_value *val; @@ -733,13 +646,7 @@ update_one_widget_instance (instance, deep_p) } static void -#ifdef PROTOTYPES update_all_widget_values (widget_info* info, Boolean deep_p) -#else -update_all_widget_values (info, deep_p) - widget_info* info; - Boolean deep_p; -#endif { widget_instance* instance; widget_value* val; @@ -752,14 +659,7 @@ update_all_widget_values (info, deep_p) } int -#ifdef PROTOTYPES lw_modify_all_widgets (LWLIB_ID id, widget_value* val, Boolean deep_p) -#else -lw_modify_all_widgets (id, val, deep_p) - LWLIB_ID id; - widget_value* val; - Boolean deep_p; -#endif { widget_info* info = get_widget_info (id, False); widget_value* new_val; @@ -814,8 +714,7 @@ lw_modify_all_widgets (id, val, deep_p) /* creating the widgets */ static void -initialize_widget_instance (instance) - widget_instance* instance; +initialize_widget_instance (widget_instance *instance) { widget_value* val; @@ -830,11 +729,9 @@ initialize_widget_instance (instance) static widget_creation_function -find_in_table (type, table) - char* type; - widget_creation_entry* table; +find_in_table (const char *type, const widget_creation_entry *table) { - widget_creation_entry* cur; + const widget_creation_entry* cur; for (cur = table; cur->type; cur++) if (!my_strcasecmp (type, cur->type)) return cur->function; @@ -842,8 +739,7 @@ find_in_table (type, table) } static Boolean -dialog_spec_p (name) - char* name; +dialog_spec_p (const char *name) { /* return True if name matches [EILPQeilpq][1-9][Bb] or [EILPQeilpq][1-9][Bb][Rr][1-9] */ @@ -876,8 +772,7 @@ dialog_spec_p (name) } static void -instantiate_widget_instance (instance) - widget_instance* instance; +instantiate_widget_instance (widget_instance *instance) { widget_creation_function function = NULL; @@ -928,16 +823,14 @@ instantiate_widget_instance (instance) } void -lw_register_widget (type, name, id, val, pre_activate_cb, - selection_cb, post_activate_cb, highlight_cb) - char* type; - char* name; - LWLIB_ID id; - widget_value* val; - lw_callback pre_activate_cb; - lw_callback selection_cb; - lw_callback post_activate_cb; - lw_callback highlight_cb; +lw_register_widget (const char* type, + const char* name, + LWLIB_ID id, + widget_value* val, + lw_callback pre_activate_cb, + lw_callback selection_cb, + lw_callback post_activate_cb, + lw_callback highlight_cb) { if (!get_widget_info (id, False)) allocate_widget_info (type, name, id, val, pre_activate_cb, selection_cb, @@ -945,14 +838,7 @@ lw_register_widget (type, name, id, val, pre_activate_cb, } Widget -#ifdef PROTOTYPES lw_get_widget (LWLIB_ID id, Widget parent, Boolean pop_up_p) -#else -lw_get_widget (id, parent, pop_up_p) - LWLIB_ID id; - Widget parent; - Boolean pop_up_p; -#endif { widget_instance* instance; @@ -961,14 +847,7 @@ lw_get_widget (id, parent, pop_up_p) } Widget -#ifdef PROTOTYPES lw_make_widget (LWLIB_ID id, Widget parent, Boolean pop_up_p) -#else -lw_make_widget (id, parent, pop_up_p) - LWLIB_ID id; - Widget parent; - Boolean pop_up_p; -#endif { widget_instance* instance; widget_info* info; @@ -988,25 +867,10 @@ lw_make_widget (id, parent, pop_up_p) } Widget -#ifdef PROTOTYPES -lw_create_widget (char* type, char* name, LWLIB_ID id, widget_value* val, +lw_create_widget (const char* type, const char* name, LWLIB_ID id, widget_value* val, Widget parent, Boolean pop_up_p, lw_callback pre_activate_cb, lw_callback selection_cb, lw_callback post_activate_cb, lw_callback highlight_cb) -#else -lw_create_widget (type, name, id, val, parent, pop_up_p, pre_activate_cb, - selection_cb, post_activate_cb, highlight_cb) - char* type; - char* name; - LWLIB_ID id; - widget_value* val; - Widget parent; - Boolean pop_up_p; - lw_callback pre_activate_cb; - lw_callback selection_cb; - lw_callback post_activate_cb; - lw_callback highlight_cb; -#endif { lw_register_widget (type, name, id, val, pre_activate_cb, selection_cb, post_activate_cb, highlight_cb); @@ -1016,8 +880,7 @@ lw_create_widget (type, name, id, val, parent, pop_up_p, pre_activate_cb, /* destroying the widgets */ static void -destroy_one_instance (instance) - widget_instance* instance; +destroy_one_instance (widget_instance *instance) { /* Remove the destroy callback on the widget; that callback will try to dereference the instance object (to set its widget slot to 0, since the @@ -1059,8 +922,7 @@ destroy_one_instance (instance) } void -lw_destroy_widget (w) - Widget w; +lw_destroy_widget (Widget w) { widget_instance* instance = get_widget_instance (w, True); @@ -1076,8 +938,7 @@ lw_destroy_widget (w) } void -lw_destroy_all_widgets (id) - LWLIB_ID id; +lw_destroy_all_widgets (LWLIB_ID id) { widget_info* info = get_widget_info (id, True); widget_instance* instance; @@ -1096,14 +957,14 @@ lw_destroy_all_widgets (id) } void -lw_destroy_everything () +lw_destroy_everything (void) { while (all_widget_info) lw_destroy_all_widgets (all_widget_info->id); } void -lw_destroy_all_pop_ups () +lw_destroy_all_pop_ups (void) { widget_info* info; widget_info* next; @@ -1123,7 +984,7 @@ extern Widget first_child (/* Widget */); /* garbage */ #endif Widget -lw_raise_all_pop_up_widgets () +lw_raise_all_pop_up_widgets (void) { widget_info* info; widget_instance* instance; @@ -1156,13 +1017,7 @@ lw_raise_all_pop_up_widgets () } static void -#ifdef PROTOTYPES lw_pop_all_widgets (LWLIB_ID id, Boolean up) -#else -lw_pop_all_widgets (id, up) - LWLIB_ID id; - Boolean up; -#endif { widget_info* info = get_widget_info (id, False); widget_instance* instance; @@ -1197,23 +1052,19 @@ lw_pop_all_widgets (id, up) } void -lw_pop_up_all_widgets (id) - LWLIB_ID id; +lw_pop_up_all_widgets (LWLIB_ID id) { lw_pop_all_widgets (id, True); } void -lw_pop_down_all_widgets (id) - LWLIB_ID id; +lw_pop_down_all_widgets (LWLIB_ID id) { lw_pop_all_widgets (id, False); } void -lw_popup_menu (widget, event) - Widget widget; - XEvent *event; +lw_popup_menu (Widget widget, XEvent *event) { #if defined (USE_LUCID) if (lw_lucid_widget_p (widget)) @@ -1231,9 +1082,7 @@ lw_popup_menu (widget, event) /* get the values back */ static Boolean -get_one_value (instance, val) - widget_instance* instance; - widget_value* val; +get_one_value (widget_instance *instance, widget_value *val) { Widget widget = name_to_widget (instance, val->name); @@ -1258,9 +1107,7 @@ get_one_value (instance, val) } Boolean -lw_get_some_values (id, val_out) - LWLIB_ID id; - widget_value* val_out; +lw_get_some_values (LWLIB_ID id, widget_value *val_out) { widget_info* info = get_widget_info (id, False); widget_instance* instance; @@ -1282,8 +1129,7 @@ lw_get_some_values (id, val_out) } widget_value* -lw_get_all_values (id) - LWLIB_ID id; +lw_get_all_values (LWLIB_ID id) { widget_info* info = get_widget_info (id, False); widget_value* val = info->val; @@ -1296,9 +1142,7 @@ lw_get_all_values (id) /* internal function used by the library dependent implementation to get the widget_value for a given widget in an instance */ widget_value* -lw_get_widget_value_for_widget (instance, w) - widget_instance* instance; - Widget w; +lw_get_widget_value_for_widget (widget_instance *instance, Widget w) { char* name = XtName (w); widget_value* cur; @@ -1317,10 +1161,9 @@ static Boolean lwlib_updating; modified to update other instances of the widgets. Closure should be the widget_instance. */ void -lw_internal_update_other_instances (widget, closure, call_data) - Widget widget; - XtPointer closure; - XtPointer call_data; +lw_internal_update_other_instances (Widget widget, + XtPointer closure, + XtPointer call_data) { widget_instance* instance = (widget_instance*)closure; char* name = XtName (widget); @@ -1357,8 +1200,7 @@ lw_internal_update_other_instances (widget, closure, call_data) /* get the id */ LWLIB_ID -lw_get_widget_id (w) - Widget w; +lw_get_widget_id (Widget w) { widget_instance* instance = get_widget_instance (w, False); @@ -1367,9 +1209,7 @@ lw_get_widget_id (w) /* set the keyboard focus */ void -lw_set_keyboard_focus (parent, w) - Widget parent; - Widget w; +lw_set_keyboard_focus (Widget parent, Widget w) { #if defined (USE_MOTIF) xm_set_keyboard_focus (parent, w); @@ -1380,13 +1220,7 @@ lw_set_keyboard_focus (parent, w) /* Show busy */ static void -#ifdef PROTOTYPES show_one_widget_busy (Widget w, Boolean flag) -#else -show_one_widget_busy (w, flag) - Widget w; - Boolean flag; -#endif { Pixel foreground = 0; Pixel background = 1; @@ -1405,13 +1239,7 @@ show_one_widget_busy (w, flag) } void -#ifdef PROTOTYPES lw_show_busy (Widget w, Boolean busy) -#else -lw_show_busy (w, busy) - Widget w; - Boolean busy; -#endif { widget_instance* instance = get_widget_instance (w, False); widget_info* info; @@ -1433,13 +1261,7 @@ lw_show_busy (w, busy) /* This hack exists because Lucid/Athena need to execute the strange function below to support geometry management. */ void -#ifdef PROTOTYPES lw_refigure_widget (Widget w, Boolean doit) -#else -lw_refigure_widget (w, doit) - Widget w; - Boolean doit; -#endif { #if defined (USE_XAW) XawPanedSetRefigureMode (w, doit); @@ -1455,9 +1277,7 @@ lw_refigure_widget (w, doit) /* Toolkit independent way of determining if an event window is in the menubar. */ Boolean -lw_window_is_in_menubar (win, menubar_widget) - Window win; - Widget menubar_widget; +lw_window_is_in_menubar (Window win, Widget menubar_widget) { return menubar_widget #if defined (USE_LUCID) @@ -1473,10 +1293,7 @@ lw_window_is_in_menubar (win, menubar_widget) /* Motif hack to set the main window areas. */ void -lw_set_main_areas (parent, menubar, work_area) - Widget parent; - Widget menubar; - Widget work_area; +lw_set_main_areas (Widget parent, Widget menubar, Widget work_area) { #if defined (USE_MOTIF) xm_set_main_areas (parent, menubar, work_area); @@ -1486,13 +1303,7 @@ lw_set_main_areas (parent, menubar, work_area) /* Manage resizing for Motif. This disables resizing when the menubar is about to be modified. */ void -#ifdef PROTOTYPES lw_allow_resizing (Widget w, Boolean flag) -#else -lw_allow_resizing (w, flag) - Widget w; - Boolean flag; -#endif { #if defined (USE_MOTIF) xm_manage_resizing (w, flag); @@ -1506,19 +1317,16 @@ lw_allow_resizing (w, flag) to similar ones that are supported. */ int -lw_separator_p (label, type, motif_p) - char *label; - enum menu_separator *type; - int motif_p; +lw_separator_p (const char *label, enum menu_separator *type, int motif_p) { int separator_p = 0; if (strlen (label) >= 3 - && bcmp (label, "--:", 3) == 0) + && memcmp (label, "--:", 3) == 0) { static struct separator_table { - char *name; + const char *name; enum menu_separator type; } separator_names[] = @@ -1557,13 +1365,13 @@ lw_separator_p (label, type, motif_p) } } else if (strlen (label) > 3 - && bcmp (label, "--", 2) == 0 + && memcmp (label, "--", 2) == 0 && label[2] != '-') { /* Alternative, more Emacs-style names. */ static struct separator_table { - char *name; + const char *name; enum menu_separator type; } separator_names[] = @@ -1614,5 +1422,3 @@ lw_separator_p (label, type, motif_p) return separator_p; } -/* arch-tag: 3d730f36-a441-4a71-9971-48ef3b5a4d9f - (do not change this comment) */ diff --git a/lwlib/lwlib.h b/lwlib/lwlib.h index a385dc885fd..1dea8c37f50 100644 --- a/lwlib/lwlib.h +++ b/lwlib/lwlib.h @@ -130,68 +130,64 @@ typedef struct _widget_value } widget_value; -typedef void (*lw_callback) __P ((Widget w, LWLIB_ID id, void* data)); - -void lw_register_widget __P ((char* type, char* name, LWLIB_ID id, - widget_value* val, lw_callback pre_activate_cb, - lw_callback selection_cb, - lw_callback post_activate_cb, - lw_callback highlight_cb)); -Widget lw_get_widget __P ((LWLIB_ID id, Widget parent, Boolean pop_up_p)); -Widget lw_make_widget __P ((LWLIB_ID id, Widget parent, Boolean pop_up_p)); -Widget lw_create_widget __P ((char* type, char* name, LWLIB_ID id, - widget_value* val, Widget parent, Boolean pop_up_p, - lw_callback pre_activate_cb, - lw_callback selection_cb, - lw_callback post_activate_cb, - lw_callback highlight_cb)); -LWLIB_ID lw_get_widget_id __P ((Widget w)); -int lw_modify_all_widgets __P ((LWLIB_ID id, widget_value* val, Boolean deep_p)); -void lw_destroy_widget __P ((Widget w)); -void lw_destroy_all_widgets __P ((LWLIB_ID id)); -void lw_destroy_everything __P ((void)); -void lw_destroy_all_pop_ups __P ((void)); -Widget lw_raise_all_pop_up_widgets __P ((void)); -widget_value* lw_get_all_values __P ((LWLIB_ID id)); -Boolean lw_get_some_values __P ((LWLIB_ID id, widget_value* val)); -void lw_pop_up_all_widgets __P ((LWLIB_ID id)); -void lw_pop_down_all_widgets __P ((LWLIB_ID id)); -widget_value *malloc_widget_value (); -void free_widget_value __P ((widget_value *)); -void lw_popup_menu __P ((Widget, XEvent *)); +typedef void (*lw_callback) (Widget w, LWLIB_ID id, void* data); + +void lw_register_widget (const char* type, const char* name, LWLIB_ID id, + widget_value* val, lw_callback pre_activate_cb, + lw_callback selection_cb, + lw_callback post_activate_cb, + lw_callback highlight_cb); +Widget lw_get_widget (LWLIB_ID id, Widget parent, Boolean pop_up_p); +Widget lw_make_widget (LWLIB_ID id, Widget parent, Boolean pop_up_p); +Widget lw_create_widget (const char* type, const char* name, LWLIB_ID id, + widget_value* val, Widget parent, Boolean pop_up_p, + lw_callback pre_activate_cb, + lw_callback selection_cb, + lw_callback post_activate_cb, + lw_callback highlight_cb); +LWLIB_ID lw_get_widget_id (Widget w); +int lw_modify_all_widgets (LWLIB_ID id, widget_value* val, Boolean deep_p); +void lw_destroy_widget (Widget w); +void lw_destroy_all_widgets (LWLIB_ID id); +void lw_destroy_everything (void); +void lw_destroy_all_pop_ups (void); +Widget lw_raise_all_pop_up_widgets (void); +widget_value* lw_get_all_values (LWLIB_ID id); +Boolean lw_get_some_values (LWLIB_ID id, widget_value* val); +void lw_pop_up_all_widgets (LWLIB_ID id); +void lw_pop_down_all_widgets (LWLIB_ID id); +widget_value *malloc_widget_value (void); +void free_widget_value (widget_value *); +void lw_popup_menu (Widget, XEvent *); /* Toolkit independent way of focusing on a Widget at the Xt level. */ -void lw_set_keyboard_focus __P ((Widget parent, Widget w)); +void lw_set_keyboard_focus (Widget parent, Widget w); /* Silly Energize hack to invert the "sheet" button */ -void lw_show_busy __P ((Widget w, Boolean busy)); +void lw_show_busy (Widget w, Boolean busy); /* Silly hack to assist with Lucid/Athena geometry management. */ -void lw_refigure_widget __P ((Widget w, Boolean doit)); +void lw_refigure_widget (Widget w, Boolean doit); /* Toolkit independent way of determining if an event occurred on a menubar. */ -Boolean lw_window_is_in_menubar __P ((Window win, Widget menubar_widget)); +Boolean lw_window_is_in_menubar (Window win, Widget menubar_widget); /* Manage resizing: TRUE permits resizing widget w; FALSE disallows it. */ -void lw_allow_resizing __P ((Widget w, Boolean flag)); +void lw_allow_resizing (Widget w, Boolean flag); /* Set up the main window. */ -void lw_set_main_areas __P ((Widget parent, - Widget menubar, - Widget work_area)); +void lw_set_main_areas (Widget parent, + Widget menubar, + Widget work_area); /* Value is non-zero if LABEL is a menu separator. If it is, *TYPE is set to an appropriate enumerator of type enum menu_separator. MOTIF_P non-zero means map separator types not supported by Motif to similar ones that are supported. */ -int lw_separator_p __P ((char *label, enum menu_separator *type, - int motif_p)); - -void lwlib_bcopy __P ((char*, char*, int)); +int lw_separator_p (const char *label, enum menu_separator *type, + int motif_p); #endif /* LWLIB_H */ -/* arch-tag: 44d818d5-7eb2-4d87-acd7-b992bb0d5d20 - (do not change this comment) */ diff --git a/lwlib/xlwmenu.c b/lwlib/xlwmenu.c index 860fa1966d4..c7b0556cca9 100644 --- a/lwlib/xlwmenu.c +++ b/lwlib/xlwmenu.c @@ -30,6 +30,7 @@ Boston, MA 02110-1301, USA. */ #include "lisp.h" #include <stdio.h> +#include <ctype.h> #include <sys/types.h> #if (defined __sun) && !(defined SUNOS41) @@ -43,6 +44,7 @@ Boston, MA 02110-1301, USA. */ #include <X11/ObjectP.h> #include <X11/StringDefs.h> #include <X11/cursorfont.h> +#include <X11/Shell.h> #include "xlwmenuP.h" #ifdef emacs @@ -69,7 +71,7 @@ extern char *gray_bitmap_bits; static int pointer_grabbed; static XEvent menu_post_event; -XFontStruct *xlwmenu_default_font; +static XFontStruct *xlwmenu_default_font; static char xlwMenuTranslations [] = @@ -128,6 +130,13 @@ xlwMenuResources[] = {XtNfontSet, XtCFontSet, XtRFontSet, sizeof(XFontSet), offset(menu.fontSet), XtRFontSet, NULL}, #endif +#ifdef HAVE_XFT +#define DEFAULT_FACENAME "Sans-10" + {XtNfaceName, XtCFaceName, XtRString, sizeof(String), + offset(menu.faceName), XtRString, DEFAULT_FACENAME}, + {XtNdefaultFace, XtCDefaultFace, XtRInt, sizeof(int), + offset(menu.default_face), XtRImmediate, (XtPointer)1}, +#endif {XtNfont, XtCFont, XtRFontStruct, sizeof(XFontStruct *), offset(menu.font), XtRString, "XtDefaultFont"}, {XtNforeground, XtCForeground, XtRPixel, sizeof(Pixel), @@ -176,26 +185,26 @@ xlwMenuResources[] = }; #undef offset -static Boolean XlwMenuSetValues(); -static void XlwMenuRealize(); -static void XlwMenuRedisplay(); -static void XlwMenuResize(); -static void XlwMenuInitialize(); -static void XlwMenuRedisplay(); -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 void pop_up_menu __P ((XlwMenuWidget, XButtonPressedEvent *)); - +static Boolean XlwMenuSetValues(Widget current, Widget request, Widget new, + ArgList args, Cardinal *num_args); +static void XlwMenuRealize(Widget, Mask *, XSetWindowAttributes *); +static void XlwMenuResize(Widget w); +static void XlwMenuInitialize(Widget, Widget, ArgList, Cardinal *); +static void XlwMenuRedisplay(Widget w, XEvent *ev, Region region); +static void XlwMenuDestroy(Widget w); +static void XlwMenuClassInitialize(void); +static void Start(Widget w, XEvent *ev, String *params, Cardinal *num_params); +static void Drag(Widget w, XEvent *ev, String *params, Cardinal *num_params); +static void Down(Widget w, XEvent *ev, String *params, Cardinal *num_params); +static void Up(Widget w, XEvent *ev, String *params, Cardinal *num_params); +static void Left(Widget w, XEvent *ev, String *params, Cardinal *num_params); +static void Right(Widget w, XEvent *ev, String *params, Cardinal *num_params); +static void Select(Widget w, XEvent *ev, String *params, Cardinal *num_params); +static void Key(Widget w, XEvent *ev, String *params, Cardinal *num_params); +static void Nothing(Widget w, XEvent *ev, String *params, Cardinal *num_params); +static int separator_height (enum menu_separator); +static void pop_up_menu (XlwMenuWidget, XButtonPressedEvent *); +static void abort_gracefully (Widget w) NO_RETURN; static XtActionsRec xlwMenuActionsList [] = @@ -270,9 +279,7 @@ static int next_release_must_exit; /* Ungrab pointer and keyboard */ static void -ungrab_all (w, ungrabtime) - Widget w; - Time ungrabtime; +ungrab_all (Widget w, Time ungrabtime) { XtUngrabPointer (w, ungrabtime); if (GRAB_KEYBOARD) XtUngrabKeyboard (w, ungrabtime); @@ -281,8 +288,7 @@ ungrab_all (w, ungrabtime) /* Like abort, but remove grabs from widget W before. */ static void -abort_gracefully (w) - Widget w; +abort_gracefully (Widget w) { if (XtIsShell (XtParent (w))) XtRemoveGrab (w); @@ -291,9 +297,7 @@ abort_gracefully (w) } static void -push_new_stack (mw, val) - XlwMenuWidget mw; - widget_value* val; +push_new_stack (XlwMenuWidget mw, widget_value *val) { if (!mw->menu.new_stack) { @@ -313,8 +317,7 @@ push_new_stack (mw, val) } static void -pop_new_stack_if_no_contents (mw) - XlwMenuWidget mw; +pop_new_stack_if_no_contents (XlwMenuWidget mw) { if (mw->menu.new_depth > 1) { @@ -324,9 +327,7 @@ pop_new_stack_if_no_contents (mw) } static void -make_old_stack_space (mw, n) - XlwMenuWidget mw; - int n; +make_old_stack_space (XlwMenuWidget mw, int n) { if (!mw->menu.old_stack) { @@ -346,16 +347,24 @@ make_old_stack_space (mw, n) /* Size code */ static int -string_width (mw, s) - XlwMenuWidget mw; - char *s; +string_width (XlwMenuWidget mw, char *s) { XCharStruct xcs; int drop; +#ifdef HAVE_XFT + if (mw->menu.xft_font) + { + XGlyphInfo gi; + XftTextExtentsUtf8 (XtDisplay (mw), mw->menu.xft_font, + (FcChar8 *) s, + strlen (s), &gi); + return gi.width; + } +#endif #ifdef HAVE_X_I18N - XRectangle ink, logical; if (mw->menu.fontSet) { + XRectangle ink, logical; XmbTextExtents (mw->menu.fontSet, s, strlen (s), &ink, &logical); return logical.width; } @@ -366,6 +375,20 @@ string_width (mw, s) } +#ifdef HAVE_XFT +#define MENU_FONT_HEIGHT(mw) \ + ((mw)->menu.xft_font != NULL \ + ? (mw)->menu.xft_font->height \ + : ((mw)->menu.fontSet != NULL \ + ? (mw)->menu.font_extents->max_logical_extent.height \ + : (mw)->menu.font->ascent + (mw)->menu.font->descent)) +#define MENU_FONT_ASCENT(mw) \ + ((mw)->menu.xft_font != NULL \ + ? (mw)->menu.xft_font->ascent \ + : ((mw)->menu.fontSet != NULL \ + ? - (mw)->menu.font_extents->max_logical_extent.y \ + : (mw)->menu.font->ascent)) +#else #ifdef HAVE_X_I18N #define MENU_FONT_HEIGHT(mw) \ ((mw)->menu.fontSet != NULL \ @@ -380,10 +403,10 @@ string_width (mw, s) ((mw)->menu.font->ascent + (mw)->menu.font->descent) #define MENU_FONT_ASCENT(mw) ((mw)->menu.font->ascent) #endif +#endif static int -arrow_width (mw) - XlwMenuWidget mw; +arrow_width (XlwMenuWidget mw) { return (MENU_FONT_ASCENT (mw) * 3/4) | 1; } @@ -391,8 +414,7 @@ arrow_width (mw) /* Return the width of toggle buttons of widget MW. */ static int -toggle_button_width (mw) - XlwMenuWidget mw; +toggle_button_width (XlwMenuWidget mw) { return (MENU_FONT_HEIGHT (mw) * 2 / 3) | 1; } @@ -401,8 +423,7 @@ toggle_button_width (mw) /* Return the width of radio buttons of widget MW. */ static int -radio_button_width (mw) - XlwMenuWidget mw; +radio_button_width (XlwMenuWidget mw) { return toggle_button_width (mw) * 1.41; } @@ -416,9 +437,7 @@ nameResource[] = }; static char* -resource_widget_value (mw, val) - XlwMenuWidget mw; - widget_value *val; +resource_widget_value (XlwMenuWidget mw, widget_value *val) { if (!val->toolkit_data) { @@ -454,15 +473,13 @@ resource_widget_value (mw, val) /* Returns the sizes of an item */ static void -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; +size_menu_item (XlwMenuWidget mw, + widget_value* val, + int horizontal_p, + int* label_width, + int* rest_width, + int* button_width, + int* height) { enum menu_separator separator; @@ -504,16 +521,14 @@ size_menu_item (mw, val, horizontal_p, label_width, rest_width, button_width, } static void -size_menu (mw, level) - XlwMenuWidget mw; - int level; +size_menu (XlwMenuWidget mw, int level) { - unsigned int label_width = 0; + 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 height = 0; int horizontal_p = mw->menu.horizontal && (level == 0); widget_value* val; window_state* ws; @@ -559,6 +574,7 @@ size_menu (mw, level) ws->width += 2 * mw->menu.shadow_thickness; ws->height += 2 * mw->menu.shadow_thickness; + ws->max_rest_width = max_rest_width; if (horizontal_p) { @@ -571,14 +587,13 @@ size_menu (mw, level) /* Display code */ static void -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; +draw_arrow (XlwMenuWidget mw, + Window window, + GC gc, + int x, + int y, + int width, + int down_p) { Display *dpy = XtDisplay (mw); GC top_gc = mw->menu.shadow_top_gc; @@ -635,15 +650,14 @@ draw_arrow (mw, window, gc, x, y, width, down_p) static void -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; +draw_shadow_rectangle (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; @@ -699,15 +713,14 @@ draw_shadow_rectangle (mw, window, x, y, width, height, erase_p, down_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; +draw_shadow_rhombus (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; @@ -767,10 +780,7 @@ draw_shadow_rhombus (mw, window, x, y, width, height, erase_p, down_p) toggle button is selected. */ static void -draw_toggle (mw, window, x, y, selected_p) - XlwMenuWidget mw; - Window window; - int x, y, selected_p; +draw_toggle (XlwMenuWidget mw, Window window, int x, int y, int selected_p) { int width, height; @@ -787,10 +797,7 @@ draw_toggle (mw, window, x, y, selected_p) toggle button is selected. */ static void -draw_radio (mw, window, x, y, selected_p) - XlwMenuWidget mw; - Window window; - int x, y, selected_p; +draw_radio (XlwMenuWidget mw, Window window, int x, int y, int selected_p) { int width, height; @@ -807,11 +814,12 @@ draw_radio (mw, window, x, y, selected_p) 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; +draw_separator (XlwMenuWidget mw, + Window window, + int x, + int y, + int width, + enum menu_separator type) { Display *dpy = XtDisplay (mw); XGCValues xgcv; @@ -924,8 +932,7 @@ draw_separator (mw, window, x, y, width, type) /* Return the pixel height of menu separator SEPARATOR. */ static int -separator_height (separator) - enum menu_separator separator; +separator_height (enum menu_separator separator) { switch (separator) { @@ -962,15 +969,13 @@ separator_height (separator) the menu item was. */ static void -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; +display_menu_item (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; @@ -987,6 +992,9 @@ display_menu_item (mw, val, ws, where, highlighted_p, horizontal_p, int width; enum menu_separator separator; int separator_p = lw_separator_p (val->name, &separator, 0); +#ifdef HAVE_XFT + XftColor *xftfg; +#endif /* compute the sizes of the item */ size_menu_item (mw, val, horizontal_p, &label_width, &rest_width, @@ -1024,16 +1032,19 @@ display_menu_item (mw, val, ws, where, highlighted_p, horizontal_p, else text_gc = mw->menu.disabled_gc; deco_gc = mw->menu.foreground_gc; +#ifdef HAVE_XFT + xftfg = val->enabled ? &mw->menu.xft_fg : &mw->menu.xft_disabled_fg; +#endif if (separator_p) { - draw_separator (mw, ws->window, x, y, width, separator); + draw_separator (mw, ws->pixmap, x, y, width, separator); } 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->pixmap, x, y, width, height, True, False); /* Deal with centering a menu title. */ @@ -1048,15 +1059,27 @@ display_menu_item (mw, val, ws, where, highlighted_p, horizontal_p, x_offset += ws->button_width; +#ifdef HAVE_XFT + if (ws->xft_draw) + { + int draw_y = y + v_spacing + shadow; + XftDrawStringUtf8 (ws->xft_draw, xftfg, + mw->menu.xft_font, + x_offset, draw_y + font_ascent, + (unsigned char *) display_string, + strlen (display_string)); + } + else +#endif #ifdef HAVE_X_I18N if (mw->menu.fontSet) - XmbDrawString (XtDisplay (mw), ws->window, mw->menu.fontSet, + XmbDrawString (XtDisplay (mw), ws->pixmap, mw->menu.fontSet, text_gc, x_offset, y + v_spacing + shadow + font_ascent, display_string, strlen (display_string)); else #endif - XDrawString (XtDisplay (mw), ws->window, + XDrawString (XtDisplay (mw), ws->pixmap, text_gc, x_offset, y + v_spacing + shadow + font_ascent, display_string, strlen (display_string)); @@ -1064,16 +1087,16 @@ display_menu_item (mw, val, ws, where, highlighted_p, horizontal_p, if (!horizontal_p) { if (val->button_type == BUTTON_TYPE_TOGGLE) - draw_toggle (mw, ws->window, x, y + v_spacing + shadow, + draw_toggle (mw, ws->pixmap, 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, + draw_radio (mw, ws->pixmap, x, y + v_spacing + shadow, val->selected); if (val->contents) { int a_w = arrow_width (mw); - draw_arrow (mw, ws->window, deco_gc, + draw_arrow (mw, ws->pixmap, deco_gc, x + width - a_w - mw->menu.horizontal_spacing - mw->menu.shadow_thickness, @@ -1082,9 +1105,23 @@ display_menu_item (mw, val, ws, where, highlighted_p, horizontal_p, } else if (val->key) { +#ifdef HAVE_XFT + if (ws->xft_draw) + { + int draw_x = ws->width - ws->max_rest_width + + mw->menu.arrow_spacing; + int draw_y = y + v_spacing + shadow + font_ascent; + XftDrawStringUtf8 (ws->xft_draw, xftfg, + mw->menu.xft_font, + draw_x, draw_y, + (unsigned char *) val->key, + strlen (val->key)); + } + else +#endif #ifdef HAVE_X_I18N if (mw->menu.fontSet) - XmbDrawString (XtDisplay (mw), ws->window, + XmbDrawString (XtDisplay (mw), ws->pixmap, mw->menu.fontSet, text_gc, x + label_width + mw->menu.arrow_spacing, @@ -1092,7 +1129,7 @@ display_menu_item (mw, val, ws, where, highlighted_p, horizontal_p, val->key, strlen (val->key)); else #endif - XDrawString (XtDisplay (mw), ws->window, + XDrawString (XtDisplay (mw), ws->pixmap, text_gc, x + label_width + mw->menu.arrow_spacing, y + v_spacing + shadow + font_ascent, @@ -1101,17 +1138,17 @@ display_menu_item (mw, val, ws, where, highlighted_p, horizontal_p, } else { - XDrawRectangle (XtDisplay (mw), ws->window, + XDrawRectangle (XtDisplay (mw), ws->pixmap, mw->menu.background_gc, x + shadow, y + shadow, label_width + h_spacing - 1, font_height + 2 * v_spacing - 1); - draw_shadow_rectangle (mw, ws->window, x, y, width, height, + draw_shadow_rectangle (mw, ws->pixmap, 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->pixmap, x, y, width, height, False, False); } } @@ -1121,16 +1158,12 @@ display_menu_item (mw, val, ws, where, highlighted_p, horizontal_p, } static void -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; +display_menu (XlwMenuWidget mw, + int level, + Boolean just_compute_p, + XPoint *highlighted_pos, + XPoint *hit, + widget_value **hit_return) { widget_value* val; widget_value* following_item; @@ -1138,9 +1171,6 @@ display_menu (mw, level, just_compute_p, highlighted_pos, hit, hit_return, XPoint where; 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; @@ -1159,6 +1189,11 @@ display_menu (mw, level, just_compute_p, highlighted_pos, hit, hit_return, where.y = 0; ws = &mw->menu.windows [level]; + + if (!just_compute_p) + XFillRectangle (XtDisplay (mw), ws->pixmap, mw->menu.background_gc, + 0, 0, ws->width, ws->height); + for (val = mw->menu.old_stack [level]->contents; val; val = val->next) { highlighted_p = val == following_item; @@ -1170,11 +1205,8 @@ display_menu (mw, level, just_compute_p, highlighted_pos, hit, hit_return, highlighted_pos->y = where.y; } - just_compute_this_one_p = - just_compute_p || ((this || that) && val != this && val != that); - display_menu_item (mw, val, ws, &where, highlighted_p, horizontal_p, - just_compute_this_one_p); + just_compute_p); if (highlighted_p && highlighted_pos) { @@ -1212,16 +1244,17 @@ display_menu (mw, level, just_compute_p, highlighted_pos, hit, hit_return, } if (!just_compute_p) - draw_shadow_rectangle (mw, ws->window, 0, 0, ws->width, ws->height, - False, False); + { + draw_shadow_rectangle (mw, ws->pixmap, 0, 0, ws->width, ws->height, + False, False); + XCopyArea (XtDisplay (mw), ws->pixmap, ws->window, + mw->menu.foreground_gc, 0, 0, ws->width, ws->height, 0, 0); + } } /* Motion code */ static void -set_new_state (mw, val, level) - XlwMenuWidget mw; - widget_value* val; - int level; +set_new_state (XlwMenuWidget mw, widget_value *val, int level) { int i; @@ -1232,31 +1265,48 @@ set_new_state (mw, val, level) } static void -make_windows_if_needed (mw, n) - XlwMenuWidget mw; - int n; +expose_cb (Widget widget, + XtPointer closure, + XEvent* event, + Boolean* continue_to_dispatch) +{ + XlwMenuWidget mw = (XlwMenuWidget) closure; + int i; + + *continue_to_dispatch = False; + for (i = 0; i < mw->menu.windows_length; ++i) + if (mw->menu.windows [i].w == widget) break; + if (i < mw->menu.windows_length && i < mw->menu.old_depth) + display_menu (mw, i, False, NULL, NULL, NULL); +} + +static void +set_window_type (Widget w, XlwMenuWidget mw) +{ + int popup_menu_p = mw->menu.top_depth == 1; + Atom type = XInternAtom (XtDisplay (w), + popup_menu_p + ? "_NET_WM_WINDOW_TYPE_POPUP_MENU" + : "_NET_WM_WINDOW_TYPE_DROPDOWN_MENU", + False); + + XChangeProperty (XtDisplay (w), XtWindow (w), + XInternAtom (XtDisplay (w), "_NET_WM_WINDOW_TYPE", False), + XA_ATOM, 32, PropModeReplace, + (unsigned char *)&type, 1); +} + + +static void +make_windows_if_needed (XlwMenuWidget mw, int n) { int i; int start_at; - XSetWindowAttributes xswa; - int mask; - Window root = RootWindowOfScreen (DefaultScreenOfDisplay (XtDisplay (mw))); window_state* windows; if (mw->menu.windows_length >= n) return; - xswa.save_under = True; - xswa.override_redirect = True; - xswa.background_pixel = mw->core.background_pixel; - xswa.border_pixel = mw->core.border_pixel; - xswa.event_mask = - 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 = @@ -1276,22 +1326,38 @@ make_windows_if_needed (mw, n) for (i = start_at; i < n; i++) { + Arg av[10]; + int ac = 0; windows [i].x = 0; windows [i].y = 0; windows [i].width = 1; windows [i].height = 1; - windows [i].window = - XCreateWindow (XtDisplay (mw), root, 0, 0, 1, 1, - 0, 0, CopyFromParent, CopyFromParent, mask, &xswa); - } + windows [i].max_rest_width = 0; + XtSetArg (av[ac], XtNwidth, 1); ++ac; + XtSetArg (av[ac], XtNheight, 1); ++ac; + XtSetArg (av[ac], XtNsaveUnder, True); ++ac; + XtSetArg (av[ac], XtNbackground, mw->core.background_pixel); ++ac; + XtSetArg (av[ac], XtNborderColor, mw->core.border_pixel); ++ac; + XtSetArg (av[ac], XtNborderWidth, mw->core.border_width); ++ac; + XtSetArg (av[ac], XtNcursor, mw->menu.cursor_shape); ++ac; + windows [i].w = + XtCreatePopupShell ("sub", overrideShellWidgetClass, + (Widget) mw, av, ac); + XtRealizeWidget (windows [i].w); + XtAddEventHandler (windows [i].w, ExposureMask, False, expose_cb, mw); + windows [i].window = XtWindow (windows [i].w); + windows [i].pixmap = None; +#ifdef HAVE_XFT + windows [i].xft_draw = 0; +#endif + set_window_type (windows [i].w, mw); + } } /* Value is non-zero if WINDOW is part of menu bar widget W. */ int -xlwmenu_window_p (w, window) - Widget w; - Window window; +xlwmenu_window_p (Widget w, Window window) { XlwMenuWidget mw = (XlwMenuWidget) w; int i; @@ -1305,11 +1371,10 @@ xlwmenu_window_p (w, window) /* Make the window fit in the screen */ static void -fit_to_screen (mw, ws, previous_ws, horizontal_p) - XlwMenuWidget mw; - window_state* ws; - window_state* previous_ws; - Boolean horizontal_p; +fit_to_screen (XlwMenuWidget mw, + window_state *ws, + window_state *previous_ws, + Boolean horizontal_p) { unsigned int screen_width = WidthOfScreen (XtScreen (mw)); unsigned int screen_height = HeightOfScreen (XtScreen (mw)); @@ -1361,10 +1426,36 @@ fit_to_screen (mw, ws, previous_ws, horizontal_p) } } +static void +create_pixmap_for_menu (window_state* ws, XlwMenuWidget mw) +{ + if (ws->pixmap != None) + { + XFreePixmap (XtDisplay (ws->w), ws->pixmap); + ws->pixmap = None; + } + ws->pixmap = XCreatePixmap (XtDisplay (ws->w), ws->window, + ws->width, ws->height, + DefaultDepthOfScreen (XtScreen (ws->w))); +#ifdef HAVE_XFT + if (ws->xft_draw) + XftDrawDestroy (ws->xft_draw); + if (mw->menu.xft_font) + { + int screen = XScreenNumberOfScreen (mw->core.screen); + ws->xft_draw = XftDrawCreate (XtDisplay (ws->w), + ws->pixmap, + DefaultVisual (XtDisplay (ws->w), screen), + mw->core.colormap); + } + else + ws->xft_draw = 0; +#endif +} + /* Updates old_stack from new_stack and redisplays. */ static void -remap_menubar (mw) - XlwMenuWidget mw; +remap_menubar (XlwMenuWidget mw) { int i; int last_same; @@ -1406,14 +1497,17 @@ remap_menubar (mw) /* 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]; + { + XtPopdown (mw->menu.windows [i].w); + old_stack [i] = new_stack [i]; + } mw->menu.old_depth = new_depth; /* 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); + &selection_position, NULL, NULL); /* Now place the new menus. */ for (i = last_same + 1; i < new_depth && new_stack[i]->contents; i++) @@ -1440,25 +1534,24 @@ remap_menubar (mw) fit_to_screen (mw, ws, previous_ws, mw->menu.horizontal && i == 1); - XClearWindow (XtDisplay (mw), ws->window); - XMoveResizeWindow (XtDisplay (mw), ws->window, ws->x, ws->y, - ws->width, ws->height); - XMapRaised (XtDisplay (mw), ws->window); - display_menu (mw, i, False, &selection_position, NULL, NULL, NULL, NULL); + XtVaSetValues (ws->w, XtNwidth, ws->width, XtNheight, ws->height, + XtNx, ws->x, XtNy, ws->y, NULL); + create_pixmap_for_menu (ws, mw); + XtPopup (ws->w, XtGrabNone); + display_menu (mw, i, False, &selection_position, NULL, NULL); } /* unmap the menus that popped down */ for (i = new_depth - 1; i < old_depth; i++) if (i >= new_depth || (i > 0 && !new_stack[i]->contents)) - XUnmapWindow (XtDisplay (mw), windows[i].window); + XtPopdown (windows[i].w); } static Boolean -motion_event_is_in_menu (mw, ev, level, relative_pos) - XlwMenuWidget mw; - XMotionEvent* ev; - int level; - XPoint* relative_pos; +motion_event_is_in_menu (XlwMenuWidget mw, + XMotionEvent *ev, + int level, + XPoint *relative_pos) { window_state* ws = &mw->menu.windows [level]; int shadow = level == 0 ? 0 : mw->menu.shadow_thickness; @@ -1471,11 +1564,10 @@ motion_event_is_in_menu (mw, ev, level, relative_pos) } static Boolean -map_event_to_widget_value (mw, ev, val, level) - XlwMenuWidget mw; - XMotionEvent* ev; - widget_value** val; - int* level; +map_event_to_widget_value (XlwMenuWidget mw, + XMotionEvent *ev, + widget_value **val, + int *level) { int i; XPoint relative_pos; @@ -1491,7 +1583,7 @@ map_event_to_widget_value (mw, ev, val, level) if (ws && motion_event_is_in_menu (mw, ev, i, &relative_pos)) { inside = 1; - display_menu (mw, i, True, NULL, &relative_pos, val, NULL, NULL); + display_menu (mw, i, True, NULL, &relative_pos, val); if (*val) { @@ -1514,8 +1606,7 @@ map_event_to_widget_value (mw, ev, val, level) /* Procedures */ static void -make_drawing_gcs (mw) - XlwMenuWidget mw; +make_drawing_gcs (XlwMenuWidget mw) { XGCValues xgcv; float scale; @@ -1585,8 +1676,7 @@ make_drawing_gcs (mw) } static void -release_drawing_gcs (mw) - XlwMenuWidget mw; +release_drawing_gcs (XlwMenuWidget mw) { XtReleaseGC ((Widget) mw, mw->menu.foreground_gc); XtReleaseGC ((Widget) mw, mw->menu.button_gc); @@ -1605,8 +1695,7 @@ release_drawing_gcs (mw) ? ((unsigned long) (x)) : ((unsigned long) (y))) static void -make_shadow_gcs (mw) - XlwMenuWidget mw; +make_shadow_gcs (XlwMenuWidget mw) { XGCValues xgcv; unsigned long pm = 0; @@ -1738,8 +1827,7 @@ make_shadow_gcs (mw) static void -release_shadow_gcs (mw) - XlwMenuWidget mw; +release_shadow_gcs (XlwMenuWidget mw) { Display *dpy = XtDisplay ((Widget) mw); Screen *screen = XtScreen ((Widget) mw); @@ -1758,15 +1846,48 @@ release_shadow_gcs (mw) XtReleaseGC ((Widget) mw, mw->menu.shadow_bottom_gc); } +#ifdef HAVE_XFT +static int +openXftFont (XlwMenuWidget mw) +{ + char *fname = mw->menu.faceName; + + mw->menu.xft_font = 0; + mw->menu.default_face = fname && strcmp (fname, DEFAULT_FACENAME) == 0; + + if (fname && strcmp (fname, "none") != 0) + { + int screen = XScreenNumberOfScreen (mw->core.screen); + int len = strlen (fname), i = len-1; + /* Try to convert Gtk-syntax (Sans 9) to Xft syntax Sans-9. */ + while (i > 0 && isdigit (fname[i])) + --i; + if (fname[i] == ' ') + { + fname = xstrdup (mw->menu.faceName); + fname[i] = '-'; + } + + mw->menu.xft_font = XftFontOpenName (XtDisplay (mw), screen, fname); + if (!mw->menu.xft_font) + { + fprintf (stderr, "Can't find font '%s'\n", fname); + mw->menu.xft_font = XftFontOpenName (XtDisplay (mw), screen, + DEFAULT_FACENAME); + } + } + + if (fname != mw->menu.faceName) free (fname); + + return mw->menu.xft_font != 0; +} +#endif + static void -XlwMenuInitialize (request, mw, args, num_args) - Widget request; - XlwMenuWidget mw; - ArgList args; - Cardinal *num_args; +XlwMenuInitialize (Widget request, Widget w, ArgList args, Cardinal *num_args) { /* Get the GCs and the widget size */ - + XlwMenuWidget mw = (XlwMenuWidget) w; Window window = RootWindowOfScreen (DefaultScreenOfDisplay (XtDisplay (mw))); Display* display = XtDisplay (mw); @@ -1775,11 +1896,11 @@ XlwMenuInitialize (request, mw, args, num_args) /* _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)); + memcpy (tem, mw->menu.contents, sizeof (widget_value)); mw->menu.contents = tem; #endif -/* mw->menu.cursor = XCreateFontCursor (display, mw->menu.cursor_shape); */ + /* mw->menu.cursor = XCreateFontCursor (display, mw->menu.cursor_shape); */ mw->menu.cursor = mw->menu.cursor_shape; mw->menu.gray_pixmap @@ -1787,11 +1908,24 @@ XlwMenuInitialize (request, mw, args, num_args) 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; +#ifdef HAVE_XFT + if (openXftFont (mw)) + ; + else +#endif + + if (!mw->menu.font) + { + if (!xlwmenu_default_font) + xlwmenu_default_font = XLoadQueryFont (display, "fixed"); + mw->menu.font = xlwmenu_default_font; + if (!mw->menu.font) + { + fprintf (stderr, "Menu font fixed not found, can't continue.\n"); + abort (); + } + } + #ifdef HAVE_X_I18N if (mw->menu.fontSet) mw->menu.font_extents = XExtentsOfFontSet (mw->menu.fontSet); @@ -1818,6 +1952,11 @@ XlwMenuInitialize (request, mw, args, num_args) mw->menu.windows [0].y = 0; mw->menu.windows [0].width = 0; mw->menu.windows [0].height = 0; + mw->menu.windows [0].max_rest_width = 0; + mw->menu.windows [0].pixmap = None; +#ifdef HAVE_XFT + mw->menu.windows [0].xft_draw = 0; +#endif size_menu (mw, 0); mw->core.width = mw->menu.windows [0].width; @@ -1825,15 +1964,13 @@ XlwMenuInitialize (request, mw, args, num_args) } static void -XlwMenuClassInitialize () +XlwMenuClassInitialize (void) { + xlwmenu_default_font = 0; } static void -XlwMenuRealize (w, valueMask, attributes) - Widget w; - Mask *valueMask; - XSetWindowAttributes *attributes; +XlwMenuRealize (Widget w, Mask *valueMask, XSetWindowAttributes *attributes) { XlwMenuWidget mw = (XlwMenuWidget)w; XSetWindowAttributes xswa; @@ -1856,24 +1993,48 @@ XlwMenuRealize (w, valueMask, attributes) x_uncatch_errors (); #endif + mw->menu.windows [0].w = w; mw->menu.windows [0].window = XtWindow (w); mw->menu.windows [0].x = w->core.x; mw->menu.windows [0].y = w->core.y; mw->menu.windows [0].width = w->core.width; mw->menu.windows [0].height = w->core.height; + + set_window_type (mw->menu.windows [0].w, mw); + create_pixmap_for_menu (&mw->menu.windows [0], mw); + +#ifdef HAVE_XFT + if (mw->menu.xft_font) + { + XColor colors[3]; + colors[0].pixel = mw->menu.xft_fg.pixel = mw->menu.foreground; + colors[1].pixel = mw->menu.xft_bg.pixel = mw->core.background_pixel; + colors[2].pixel = mw->menu.xft_disabled_fg.pixel + = mw->menu.disabled_foreground; + XQueryColors (XtDisplay (mw), mw->core.colormap, colors, 3); + mw->menu.xft_fg.color.alpha = 0xFFFF; + mw->menu.xft_fg.color.red = colors[0].red; + mw->menu.xft_fg.color.green = colors[0].green; + mw->menu.xft_fg.color.blue = colors[0].blue; + mw->menu.xft_bg.color.alpha = 0xFFFF; + mw->menu.xft_bg.color.red = colors[1].red; + mw->menu.xft_bg.color.green = colors[1].green; + mw->menu.xft_bg.color.blue = colors[1].blue; + mw->menu.xft_disabled_fg.color.alpha = 0xFFFF; + mw->menu.xft_disabled_fg.color.red = colors[2].red; + mw->menu.xft_disabled_fg.color.green = colors[2].green; + mw->menu.xft_disabled_fg.color.blue = colors[2].blue; + } +#endif } /* 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 (w, ev, region) - Widget w; - XEvent* ev; - Region region; +XlwMenuRedisplay (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. */ @@ -1883,8 +2044,7 @@ XlwMenuRedisplay (w, ev, region) submenu_destroyed = 0; } - for (i = 0; i < mw->menu.old_depth; i++) - display_menu (mw, i, False, NULL, NULL, NULL, NULL, NULL); + display_menu (mw, 0, False, NULL, NULL, NULL); } @@ -1892,15 +2052,13 @@ XlwMenuRedisplay (w, ev, region) over a menu item is unmapped. */ void -xlwmenu_redisplay (w) - Widget w; +xlwmenu_redisplay (Widget w) { XlwMenuRedisplay (w, NULL, None); } static void -XlwMenuDestroy (w) - Widget w; +XlwMenuDestroy (Widget w) { int i; XlwMenuWidget mw = (XlwMenuWidget) w; @@ -1942,18 +2100,45 @@ XlwMenuDestroy (w) client exits. Nice, eh? */ +#ifdef HAVE_XFT + if (mw->menu.windows [0].xft_draw) + XftDrawDestroy (mw->menu.windows [0].xft_draw); + if (mw->menu.xft_font) + XftFontClose (XtDisplay (mw), mw->menu.xft_font); +#endif + + if (mw->menu.windows [0].pixmap != None) + XFreePixmap (XtDisplay (mw), mw->menu.windows [0].pixmap); /* start from 1 because the one in slot 0 is w->core.window */ for (i = 1; i < mw->menu.windows_length; i++) - XDestroyWindow (XtDisplay (mw), mw->menu.windows [i].window); + { + if (mw->menu.windows [i].pixmap != None) + XFreePixmap (XtDisplay (mw), mw->menu.windows [i].pixmap); +#ifdef HAVE_XFT + if (mw->menu.windows [i].xft_draw) + XftDrawDestroy (mw->menu.windows [i].xft_draw); +#endif + } + if (mw->menu.windows) XtFree ((char *) mw->menu.windows); } +#ifdef HAVE_XFT +static int +facename_changed (XlwMenuWidget newmw, + XlwMenuWidget oldmw) +{ + /* This will fore a new XftFont even if the same string is set. + This is good, as rendering parameters may have changed and + we just want to do a redisplay. */ + return newmw->menu.faceName != oldmw->menu.faceName; +} +#endif + static Boolean -XlwMenuSetValues (current, request, new) - Widget current; - Widget request; - Widget new; +XlwMenuSetValues (Widget current, Widget request, Widget new, + ArgList args, Cardinal *num_args) { XlwMenuWidget oldmw = (XlwMenuWidget)current; XlwMenuWidget newmw = (XlwMenuWidget)new; @@ -1972,6 +2157,9 @@ XlwMenuSetValues (current, request, new) if (newmw->core.background_pixel != oldmw->core.background_pixel || newmw->menu.foreground != oldmw->menu.foreground +#ifdef HAVE_XFT + || facename_changed (newmw, oldmw) +#endif #ifdef HAVE_X_I18N || newmw->menu.fontSet != oldmw->menu.fontSet || (newmw->menu.fontSet == NULL && newmw->menu.font != oldmw->menu.font) @@ -2004,6 +2192,29 @@ XlwMenuSetValues (current, request, new) } } +#ifdef HAVE_XFT + if (facename_changed (newmw, oldmw)) + { + int i; + int screen = XScreenNumberOfScreen (newmw->core.screen); + if (newmw->menu.xft_font) + XftFontClose (XtDisplay (newmw), newmw->menu.xft_font); + openXftFont (newmw); + for (i = 0; i < newmw->menu.windows_length; i++) + { + if (newmw->menu.windows [i].xft_draw) + XftDrawDestroy (newmw->menu.windows [i].xft_draw); + newmw->menu.windows [i].xft_draw = 0; + } + if (newmw->menu.xft_font) + for (i = 0; i < newmw->menu.windows_length; i++) + newmw->menu.windows [i].xft_draw + = XftDrawCreate (XtDisplay (newmw), + newmw->menu.windows [i].window, + DefaultVisual (XtDisplay (newmw), screen), + newmw->core.colormap); + } +#endif #ifdef HAVE_X_I18N if (newmw->menu.fontSet != oldmw->menu.fontSet && newmw->menu.fontSet != NULL) { @@ -2016,8 +2227,7 @@ XlwMenuSetValues (current, request, new) } static void -XlwMenuResize (w) - Widget w; +XlwMenuResize (Widget w) { XlwMenuWidget mw = (XlwMenuWidget)w; @@ -2026,21 +2236,20 @@ XlwMenuResize (w) /* 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 ; + 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; + create_pixmap_for_menu (&mw->menu.windows [0], mw); } } /* Action procedures */ static void -handle_single_motion_event (mw, ev) - XlwMenuWidget mw; - XMotionEvent* ev; +handle_single_motion_event (XlwMenuWidget mw, XMotionEvent *ev) { widget_value* val; int level; @@ -2056,15 +2265,12 @@ handle_single_motion_event (mw, ev) } static void -handle_motion_event (mw, ev) - XlwMenuWidget mw; - XMotionEvent* ev; +handle_motion_event (XlwMenuWidget mw, XMotionEvent *ev) { int x = ev->x_root; int y = ev->y_root; int state = ev->state; - - handle_single_motion_event (mw, ev); + XMotionEvent oldev = *ev; /* allow motion events to be generated again */ if (ev->is_hint @@ -2076,14 +2282,12 @@ handle_motion_event (mw, ev) && ev->state == state && (ev->x_root != x || ev->y_root != y)) handle_single_motion_event (mw, ev); + else + handle_single_motion_event (mw, &oldev); } static void -Start (w, ev, params, num_params) - Widget w; - XEvent *ev; - String *params; - Cardinal *num_params; +Start (Widget w, XEvent *ev, String *params, Cardinal *num_params) { XlwMenuWidget mw = (XlwMenuWidget)w; @@ -2116,11 +2320,7 @@ Start (w, ev, params, num_params) } static void -Drag (w, ev, params, num_params) - Widget w; - XEvent *ev; - String *params; - Cardinal *num_params; +Drag (Widget w, XEvent *ev, String *params, Cardinal *num_params) { XlwMenuWidget mw = (XlwMenuWidget)w; if (mw->menu.popped_up) @@ -2130,19 +2330,12 @@ Drag (w, ev, params, 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; +Nothing (Widget w, XEvent *ev, String *params, Cardinal *num_params) { } static widget_value * -find_first_selectable (mw, item, skip_titles) - XlwMenuWidget mw; - widget_value *item; - int skip_titles; +find_first_selectable (XlwMenuWidget mw, widget_value *item, int skip_titles) { widget_value *current = item; enum menu_separator separator; @@ -2158,10 +2351,7 @@ find_first_selectable (mw, item, skip_titles) } static widget_value * -find_next_selectable (mw, item, skip_titles) - XlwMenuWidget mw; - widget_value *item; - int skip_titles; +find_next_selectable (XlwMenuWidget mw, widget_value *item, int skip_titles) { widget_value *current = item; enum menu_separator separator; @@ -2195,10 +2385,7 @@ find_next_selectable (mw, item, skip_titles) } static widget_value * -find_prev_selectable (mw, item, skip_titles) - XlwMenuWidget mw; - widget_value *item; - int skip_titles; +find_prev_selectable (XlwMenuWidget mw, widget_value *item, int skip_titles) { widget_value *current = item; widget_value *prev = item; @@ -2215,11 +2402,7 @@ find_prev_selectable (mw, item, skip_titles) } static void -Down (w, ev, params, num_params) - Widget w; - XEvent *ev; - String *params; - Cardinal *num_params; +Down (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]; @@ -2244,11 +2427,7 @@ Down (w, ev, params, num_params) } static void -Up (w, ev, params, num_params) - Widget w; - XEvent *ev; - String *params; - Cardinal *num_params; +Up (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]; @@ -2284,11 +2463,7 @@ Up (w, ev, params, num_params) } void -Left (w, ev, params, num_params) - Widget w; - XEvent *ev; - String *params; - Cardinal *num_params; +Left (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]; @@ -2324,11 +2499,7 @@ Left (w, ev, params, num_params) } void -Right (w, ev, params, num_params) - Widget w; - XEvent *ev; - String *params; - Cardinal *num_params; +Right (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]; @@ -2364,11 +2535,7 @@ Right (w, ev, params, 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; +Key (Widget w, XEvent *ev, String *params, Cardinal *num_params) { XlwMenuWidget mw = (XlwMenuWidget)w; @@ -2385,7 +2552,7 @@ Key (w, ev, params, num_params) else { XtRemoveGrab ((Widget) mw); - display_menu (mw, 0, False, NULL, NULL, NULL, NULL, NULL); + display_menu (mw, 0, False, NULL, NULL, NULL); } } @@ -2394,11 +2561,7 @@ Key (w, ev, params, num_params) } static void -Select (w, ev, params, num_params) - Widget w; - XEvent *ev; - String *params; - Cardinal *num_params; +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]; @@ -2426,7 +2589,7 @@ Select (w, ev, params, num_params) else { XtRemoveGrab ((Widget) mw); - display_menu (mw, 0, False, NULL, NULL, NULL, NULL, NULL); + display_menu (mw, 0, False, NULL, NULL, NULL); } } @@ -2437,9 +2600,7 @@ Select (w, ev, params, num_params) /* Special code to pop-up a menu */ static void -pop_up_menu (mw, event) - XlwMenuWidget mw; - XButtonPressedEvent* event; +pop_up_menu (XlwMenuWidget mw, XButtonPressedEvent *event) { int x = event->x_root; int y = event->y_root; @@ -2477,7 +2638,7 @@ pop_up_menu (mw, event) 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); + display_menu (mw, 0, False, NULL, NULL, NULL); mw->menu.windows [0].x = x + borderwidth; mw->menu.windows [0].y = y + borderwidth; mw->menu.top_depth = 1; /* Popup menus don't have a bar so top is 1 */ @@ -2530,5 +2691,3 @@ pop_up_menu (mw, event) handle_motion_event (mw, (XMotionEvent*)event); } -/* arch-tag: 657f43dd-dfd0-4cc9-910c-52935f01176e - (do not change this comment) */ diff --git a/lwlib/xlwmenu.h b/lwlib/xlwmenu.h index d219bb24925..e2b3cb95359 100644 --- a/lwlib/xlwmenu.h +++ b/lwlib/xlwmenu.h @@ -58,6 +58,10 @@ Boston, MA 02110-1301, USA. */ #define XtCResizeToPreferred "ResizeToPreferred" #define XtNallowResize "allowResize" #define XtCAllowResize "AllowResize" +#define XtNfaceName "faceName" +#define XtCFaceName "FaceName" +#define XtNdefaultFace "defaultFace" +#define XtCDefaultFace "DefaultFace" /* Motif-compatible resource names */ #define XmNshadowThickness "shadowThickness" @@ -77,7 +81,8 @@ typedef struct _XlwMenuClassRec *XlwMenuWidgetClass; extern WidgetClass xlwMenuWidgetClass; +extern int xlwmenu_window_p (Widget w, Window window); +extern void xlwmenu_redisplay (Widget); + #endif /* _XlwMenu_h */ -/* arch-tag: 0c019735-d61b-4080-be85-4fdd6e50ae07 - (do not change this comment) */ diff --git a/lwlib/xlwmenuP.h b/lwlib/xlwmenuP.h index f0b4a4ddf3a..c44a93d0a53 100644 --- a/lwlib/xlwmenuP.h +++ b/lwlib/xlwmenuP.h @@ -25,19 +25,28 @@ Boston, MA 02110-1301, USA. */ #include "xlwmenu.h" #include <X11/CoreP.h> +#ifdef HAVE_XFT +#include <X11/Xft/Xft.h> +#endif /* Elements in the stack arrays. */ typedef struct _window_state { + Widget w; Window window; + Pixmap pixmap; Position x; Position y; Dimension width; Dimension height; Dimension label_width; + int max_rest_width; /* Width of toggle buttons or radio buttons. */ Dimension button_width; +#ifdef HAVE_XFT + XftDraw* xft_draw; +#endif } window_state; @@ -49,6 +58,12 @@ typedef struct _XlwMenu_part XFontSet fontSet; XFontSetExtents *font_extents; #endif +#ifdef HAVE_XFT + String faceName; + int default_face; + XftFont* xft_font; + XftColor xft_fg, xft_bg, xft_disabled_fg; +#endif XFontStruct* font; Pixel foreground; Pixel disabled_foreground; @@ -127,5 +142,3 @@ extern XlwMenuClassRec xlwMenuClassRec; #endif /* _XlwMenuP_h */ -/* arch-tag: 18d7fc41-ffa0-47a3-a49f-3469900c7a25 - (do not change this comment) */ |