1
0
mirror of https://git.savannah.gnu.org/git/emacs.git synced 2024-12-24 10:38:38 +00:00
emacs/lwlib/lwlib-Xaw.c
Paul Eggert 620f13b061 Use ASCII tests for character types.
* admin/merge-gnulib (GNULIB_MODULES): Add c-ctype.
* lwlib/lwlib-Xaw.c, lwlib/lwlib.c, lwlib/xlwmenu.c:
Don't include <ctype.h>; no longer needed.
* lwlib/lwlib-Xaw.c (openFont):
* lwlib/xlwmenu.c (openXftFont): Test just for ASCII digits.
* src/category.c, src/dispnew.c, src/doprnt.c, src/editfns.c, src/syntax.c
* src/term.c, src/xfns.c, src/xterm.c:
Don't include <ctype.h>; was not needed.
* src/charset.c, src/doc.c, src/fileio.c, src/font.c, src/frame.c:
* src/gtkutil.c, src/image.c, src/sysdep.c, src/xfaces.c:
Include <c-ctype.h> instead of <ctype.h>.
* src/nsterm.m: Include <c-ctype.h>.
* src/charset.c (read_hex):
* src/doc.c (Fsnarf_documentation):
* src/fileio.c (IS_DRIVE) [WINDOWSNT]:
(DRIVE_LETTER) [DOS_NT]:
(Ffile_name_directory, Fexpand_file_name)
(Fsubstitute_in_file_name):
* src/font.c (font_parse_xlfd, font_parse_fcname):
* src/frame.c (x_set_font_backend):
* src/gtkutil.c (xg_get_font):
* src/image.c (xbm_scan, xpm_scan, pbm_scan_number):
* src/nsimage.m (hexchar):
* src/nsterm.m (ns_xlfd_to_fontname):
* src/sysdep.c (system_process_attributes):
* src/xfaces.c (hash_string_case_insensitive):
Use C-locale tests instead of locale-specific tests for character
types, since we want the ASCII interpretation here, not the
interpretation suitable for whatever happens to be the current locale.
2012-08-16 14:58:44 -07:00

841 lines
22 KiB
C
Raw Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/* The lwlib interface to Athena widgets.
Copyright (C) 1993 Chuck Thompson <cthomp@cs.uiuc.edu>
Copyright (C) 1994, 2001-2012 Free Software Foundation, Inc.
This file is part of the Lucid Widget Library.
The Lucid Widget Library is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 1, or (at your option)
any later version.
The Lucid Widget Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Emacs; see the file COPYING. If not, write to
the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
Boston, MA 02110-1301, USA. */
#include <config.h>
#include <stdio.h>
#include <setjmp.h>
#include <lisp.h>
#include "lwlib-Xaw.h"
#include <X11/StringDefs.h>
#include <X11/IntrinsicP.h>
#include <X11/CoreP.h>
#include <X11/Shell.h>
#ifdef HAVE_XAW3D
#include <X11/Xaw3d/Scrollbar.h>
#include <X11/Xaw3d/Paned.h>
#include <X11/Xaw3d/Dialog.h>
#include <X11/Xaw3d/Form.h>
#include <X11/Xaw3d/Command.h>
#include <X11/Xaw3d/Label.h>
#else /* !HAVE_XAW3D */
#include <X11/Xaw/Scrollbar.h>
#include <X11/Xaw/Paned.h>
#include <X11/Xaw/Dialog.h>
#include <X11/Xaw/Form.h>
#include <X11/Xaw/Command.h>
#include <X11/Xaw/Label.h>
#endif /* HAVE_XAW3D */
#include <X11/Xatom.h>
#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)
{
return (XtIsSubclass (widget, scrollbarWidgetClass) ||
XtIsSubclass (widget, dialogWidgetClass));
}
#ifdef HAVE_XFT
static void
fill_xft_data (struct widget_xft_data *data, Widget widget, XftFont *font)
{
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 && '0' <= fname[i] && fname[i] <= '9')
--i;
if (fname[i] == ' ')
{
fname = xstrdup (name);
fname[i] = '-';
}
fn = XftFontOpenName (XtDisplay (widget), screen, fname);
if (fname != name) xfree (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);
}
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;
for (nr = 0; data == NULL && nr < inst->nr_xft_data; ++nr)
{
if (inst->xft_data[nr].widget == widget)
data = &inst->xft_data[nr];
}
return data;
}
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);
XtVaGetValues (widget, XtNlabel, &lbl, NULL);
draw_text (data, lbl, 1);
}
}
static void
command_reset (Widget widget,
XEvent* event,
String *params,
Cardinal *num_params)
{
struct widget_xft_data *data = find_xft_data (widget);
if (data)
{
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))
{
#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[10];
int ac = 0;
XtVaGetValues (widget, XtNborderWidth, &bw, NULL);
if (bw == 0)
/* Don't let buttons end up with 0 borderwidth, that's ugly...
Yeah, all this should really be done through app-defaults files
or fallback resources, but that's a whole different can of worms
that I don't feel like opening right now. Making Athena widgets
not look like shit is just entirely too much work.
*/
{
XtSetArg (al[0], XtNborderWidth, 1);
XtSetValues (widget, al, 1);
}
XtSetSensitive (widget, val->enabled);
XtSetArg (al[ac], XtNlabel, val->value);ac++;
/* Force centered button text. Se above. */
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 (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. */
return;
}
void
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);
xfree (instance->xft_data);
}
#endif
if (XtIsSubclass (instance->widget, dialogWidgetClass))
/* Need to destroy the Shell too. */
XtDestroyWidget (XtParent (instance->widget));
else
XtDestroyWidget (instance->widget);
}
void
xaw_popup_menu (Widget widget, XEvent *event)
{
/* An Athena menubar has not been implemented. */
return;
}
void
xaw_pop_instance (widget_instance *instance, Boolean up)
{
Widget widget = instance->widget;
if (up)
{
if (XtIsSubclass (widget, dialogWidgetClass))
{
/* For dialogs, we need to call XtPopup on the parent instead
of calling XtManageChild on the widget.
Also we need to hack the shell's WM_PROTOCOLS to get it to
understand what the close box is supposed to do!!
*/
Display *dpy = XtDisplay (widget);
Widget shell = XtParent (widget);
Atom props [2];
int i = 0;
props [i++] = XInternAtom (dpy, "WM_DELETE_WINDOW", False);
XChangeProperty (dpy, XtWindow (shell),
XInternAtom (dpy, "WM_PROTOCOLS", False),
XA_ATOM, 32, PropModeAppend,
(unsigned char *) props, i);
/* Center the widget in its parent. Why isn't this kind of crap
done automatically? I thought toolkits were supposed to make
life easier?
*/
{
unsigned int x, y, w, h;
Widget topmost = instance->parent;
Arg args[2];
w = shell->core.width;
h = shell->core.height;
while (topmost->core.parent && XtIsRealized (topmost->core.parent))
topmost = topmost->core.parent;
if (topmost->core.width < w) x = topmost->core.x;
else x = topmost->core.x + ((topmost->core.width - w) / 2);
if (topmost->core.height < h) y = topmost->core.y;
else y = topmost->core.y + ((topmost->core.height - h) / 2);
/* Using XtMoveWidget caused the widget to come
out in the wrong place with vtwm.
Question of virtual vs real coords, perhaps. */
XtSetArg (args[0], XtNx, x);
XtSetArg (args[1], XtNy, y);
XtSetValues (shell, args, 2);
}
/* Finally, pop it up. */
XtPopup (shell, XtGrabNonexclusive);
}
else
XtManageChild (widget);
}
else
{
if (XtIsSubclass (widget, dialogWidgetClass))
XtUnmanageChild (XtParent (widget));
else
XtUnmanageChild (widget);
}
}
/* Dialog boxes */
static char overrideTrans[] =
"<Message>WM_PROTOCOLS: lwlib_delete_dialog()";
/* Dialogs pop down on any key press */
static char dialogOverride[] =
"<KeyPress>Escape: lwlib_delete_dialog()";
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 (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;
int i, bc;
char button_name [255];
Widget shell;
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 */
if (radio_box) abort (); /* not implemented */
if (list) abort (); /* not implemented */
if (! actions_initted)
{
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;
}
override = XtParseTranslationTable (overrideTrans);
ac = 0;
XtSetArg (av[ac], XtNtitle, shell_title); ac++;
XtSetArg (av[ac], XtNallowShellResize, True); ac++;
/* Don't allow any geometry request from the user. */
XtSetArg (av[ac], XtNgeometry, 0); ac++;
shell = XtCreatePopupShell ("dialog", transientShellWidgetClass,
parent, av, ac);
XtOverrideTranslations (shell, override);
ac = 0;
dialog = XtCreateManagedWidget (name, dialogWidgetClass, shell, av, ac);
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[] =
{ { "font", "Font", XtRString, sizeof(String), 0, XtRString,
(XtPointer)"Sans-10" }};
char *fontName = NULL;
XtVaGetSubresources (dialog, &fontName, "Dialog", "dialog",
rec, 1, (String)NULL);
if (fontName)
{
XFontStruct *xfn = XLoadQueryFont (XtDisplay (dialog), fontName);
if (!xfn)
xft_font = openFont (dialog, fontName);
else
XFreeFont (XtDisplay (dialog), xfn);
}
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++)
{
ac = 0;
XtSetArg (av [ac], XtNfromHoriz, button); ac++;
XtSetArg (av [ac], XtNleft, XtChainLeft); ac++;
XtSetArg (av [ac], XtNright, XtChainLeft); 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
}
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 (widget_instance *instance)
{
char *name = instance->info->type;
Widget parent = instance->parent;
Widget widget;
Boolean pop_up_p = instance->pop_up_p;
char *shell_name = 0;
char *icon_name = 0;
Boolean text_input_slot = False;
Boolean radio_box = False;
Boolean list = False;
int total_buttons;
int left_buttons = 0;
int right_buttons = 1;
switch (name [0]) {
case 'E': case 'e':
icon_name = "dbox-error";
shell_name = "Error";
break;
case 'I': case 'i':
icon_name = "dbox-info";
shell_name = "Information";
break;
case 'L': case 'l':
list = True;
icon_name = "dbox-question";
shell_name = "Prompt";
break;
case 'P': case 'p':
text_input_slot = True;
icon_name = "dbox-question";
shell_name = "Prompt";
break;
case 'Q': case 'q':
icon_name = "dbox-question";
shell_name = "Question";
break;
}
total_buttons = name [1] - '0';
if (name [3] == 'T' || name [3] == 't')
{
text_input_slot = False;
radio_box = True;
}
else if (name [3])
right_buttons = name [4] - '0';
left_buttons = total_buttons - right_buttons;
widget = make_dialog (name, parent, pop_up_p,
shell_name, icon_name, text_input_slot, radio_box,
list, left_buttons, right_buttons, instance);
return widget;
}
static void
xaw_generic_callback (Widget widget, XtPointer closure, XtPointer call_data)
{
widget_instance *instance = (widget_instance *) closure;
Widget instance_widget;
LWLIB_ID id;
XtPointer user_data;
lw_internal_update_other_instances (widget, closure, call_data);
if (! instance)
return;
if (widget->core.being_destroyed)
return;
instance_widget = instance->widget;
if (!instance_widget)
return;
id = instance->info->id;
/* 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. */
{
widget_value *val = instance->info->val->contents;
char *name = XtName (widget);
while (val)
{
if (val->name && !strcmp (val->name, name))
break;
val = val->next;
}
if (! val) abort ();
user_data = val->call_data;
}
if (instance->info->selection_cb)
instance->info->selection_cb (widget, id, user_data);
}
static void
wm_delete_window (Widget w,
XEvent *event,
String *params,
Cardinal *num_params)
{
LWLIB_ID id;
Cardinal nkids;
int i;
Widget *kids = 0;
Widget widget = 0, shell;
if (XtIsSubclass (w, dialogWidgetClass))
shell = XtParent (w);
else
shell = w;
if (! XtIsSubclass (shell, shellWidgetClass))
abort ();
XtVaGetValues (shell, XtNnumChildren, &nkids, NULL);
XtVaGetValues (shell, XtNchildren, &kids, NULL);
if (!kids || !*kids)
abort ();
for (i = 0; i < nkids; i++)
{
widget = kids[i];
if (XtIsSubclass (widget, dialogWidgetClass))
break;
}
if (! widget) return;
id = lw_get_widget_id (widget);
if (! id) abort ();
{
widget_info *info = lw_get_widget_info (id);
if (! info) abort ();
if (info->selection_cb)
info->selection_cb (widget, id, (XtPointer) -1);
}
lw_destroy_all_widgets (id);
}
static Widget
xaw_create_main (widget_instance *instance)
{
Arg al[1];
int ac;
/* Create a vertical Paned to hold menubar */
ac = 0;
XtSetArg (al[ac], XtNborderWidth, 0); ac++;
return XtCreateWidget (instance->info->name, panedWidgetClass,
instance->parent, al, ac);
}
widget_creation_entry
xaw_creation_table [] =
{
{"main", xaw_create_main},
{NULL, NULL}
};