mirror of
https://git.savannah.gnu.org/git/emacs.git
synced 2024-11-26 07:33:47 +00:00
bc511a64f6
Most of this change is to boilerplate commentary such as license URLs. This change was prompted by ftp://ftp.gnu.org's going-away party, planned for November. Change these FTP URLs to https://ftp.gnu.org instead. Make similar changes for URLs to other organizations moving away from FTP. Also, change HTTP to HTTPS for URLs to gnu.org and fsf.org when this works, as this will further help defend against man-in-the-middle attacks (for this part I omitted the MS-DOS and MS-Windows sources and the test tarballs to keep the workload down). HTTPS is not fully working to lists.gnu.org so I left those URLs alone for now.
839 lines
22 KiB
C
839 lines
22 KiB
C
/* The lwlib interface to Athena widgets.
|
||
|
||
Copyright (C) 1993 Chuck Thompson <cthomp@cs.uiuc.edu>
|
||
Copyright (C) 1994, 2001-2017 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. If not, see <https://www.gnu.org/licenses/>. */
|
||
|
||
#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) emacs_abort (); /* not implemented */
|
||
if (text_input_slot) emacs_abort (); /* not implemented */
|
||
if (radio_box) emacs_abort (); /* not implemented */
|
||
if (list) emacs_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) emacs_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))
|
||
emacs_abort ();
|
||
XtVaGetValues (shell, XtNnumChildren, &nkids, NULL);
|
||
XtVaGetValues (shell, XtNchildren, &kids, NULL);
|
||
if (!kids || !*kids)
|
||
emacs_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) emacs_abort ();
|
||
|
||
{
|
||
widget_info *info = lw_get_widget_info (id);
|
||
if (! info) emacs_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}
|
||
};
|