devs/foxbox
1
0
Fork 0
forked from len0rd/rockbox
Code Pull requests Activity

Commented out the KEY PRESSED and EVENT debug messages

Browse source 
git-svn-id: svn://svn.rockbox.org/rockbox/trunk@400 a1c6a512-1295-4272-9138-f99709370657
This commit is contained in:
Robert Hak 2002-05-03 06:51:05 +00:00
parent 1118c88639
commit 0326934e91
1 changed files with 321 additions and 320 deletions
Download patch file Download diff file Expand all files Collapse all files

641
uisimulator/x11/screenhack.c
View file

@ -97,77 +97,77 @@ static XrmOptionDescRec *merged_options;
static int merged_options_size; static int merged_options_size;
static char **merged_defaults; static char **merged_defaults;
static void static void merge_options (void)
merge_options (void)
{ {
int def_opts_size, opts_size; int def_opts_size, opts_size;
int def_defaults_size, defaults_size; int def_defaults_size, defaults_size;
for (def_opts_size = 0; default_options[def_opts_size].option; for (def_opts_size = 0; default_options[def_opts_size].option;
def_opts_size++) def_opts_size++)
; ;
for (opts_size = 0; options[opts_size].option; opts_size++) for (opts_size = 0; options[opts_size].option; opts_size++)
; ;
merged_options_size = def_opts_size + opts_size; merged_options_size = def_opts_size + opts_size;
merged_options = (XrmOptionDescRec *) merged_options = (XrmOptionDescRec *)
malloc ((merged_options_size + 1) * sizeof(*default_options)); malloc ((merged_options_size + 1) * sizeof(*default_options));
memcpy (merged_options, default_options, memcpy (merged_options, default_options,
(def_opts_size * sizeof(*default_options))); (def_opts_size * sizeof(*default_options)));
memcpy (merged_options + def_opts_size, options, memcpy (merged_options + def_opts_size, options,
((opts_size + 1) * sizeof(*default_options))); ((opts_size + 1) * sizeof(*default_options)));
for (def_defaults_size = 0; default_defaults[def_defaults_size]; for (def_defaults_size = 0; default_defaults[def_defaults_size];
def_defaults_size++) def_defaults_size++)
; ;
for (defaults_size = 0; defaults[defaults_size]; defaults_size++) for (defaults_size = 0; defaults[defaults_size]; defaults_size++)
; ;
merged_defaults = (char **)
malloc ((def_defaults_size + defaults_size + 1) * sizeof (*defaults));;
memcpy (merged_defaults, default_defaults,
def_defaults_size * sizeof(*defaults));
memcpy (merged_defaults + def_defaults_size, defaults,
(defaults_size + 1) * sizeof(*defaults));
/* This totally sucks. Xt should behave like this by default. merged_defaults = (char **)
If the string in `defaults' looks like ".foo", change that malloc ((def_defaults_size + defaults_size + 1) * sizeof (*defaults));
to "Progclass.foo".
*/ memcpy (merged_defaults, default_defaults,
{ def_defaults_size * sizeof(*defaults));
char **s; memcpy (merged_defaults + def_defaults_size, defaults,
for (s = merged_defaults; *s; s++) (defaults_size + 1) * sizeof(*defaults));
if (**s == '.')
{ /* This totally sucks. Xt should behave like this by default.
const char *oldr = *s; If the string in `defaults' looks like ".foo", change that
char *newr = (char *) malloc(strlen(oldr) + strlen(progclass) + 3); to "Progclass.foo".
strcpy (newr, progclass); */
strcat (newr, oldr); {
*s = newr; char **s;
} for (s = merged_defaults; *s; s++)
} if (**s == '.')
{
const char *oldr = *s;
char *newr = (char *) malloc(strlen(oldr)
+ strlen(progclass) + 3);
strcpy (newr, progclass);
strcat (newr, oldr);
*s = newr;
}
}
} }
/* Make the X errors print out the name of this program, so we have some /* Make the X errors print out the name of this program, so we have some
clue which one has a bug when they die under the screensaver. clue which one has a bug when they die under the screensaver.
*/ */
static int static int screenhack_ehandler (Display *dpy, XErrorEvent *error)
screenhack_ehandler (Display *dpy, XErrorEvent *error)
{ {
fprintf (stderr, "\nX error in %s:\n", progname); fprintf (stderr, "\nX error in %s:\n", progname);
if (XmuPrintDefaultErrorMessage (dpy, error, stderr)) if (XmuPrintDefaultErrorMessage (dpy, error, stderr))
exit (-1); exit (-1);
else else
fprintf (stderr, " (nonfatal.)\n"); fprintf (stderr, " (nonfatal.)\n");
return 0; return 0;
} }
static Bool static Bool MapNotify_event_p (Display *dpy, XEvent *event, XPointer window)
MapNotify_event_p (Display *dpy, XEvent *event, XPointer window)
{ {
return (event->xany.type == MapNotify && return (event->xany.type == MapNotify &&
event->xvisibility.window == (Window) window); event->xvisibility.window == (Window) window);
} }
@ -181,8 +181,7 @@ static Atom XA_WM_PROTOCOLS, XA_WM_DELETE_WINDOW;
/* Dead-trivial event handling: exits if "q" or "ESC" are typed. /* Dead-trivial event handling: exits if "q" or "ESC" are typed.
Exit if the WM_PROTOCOLS WM_DELETE_WINDOW ClientMessage is received. Exit if the WM_PROTOCOLS WM_DELETE_WINDOW ClientMessage is received.
*/ */
int int screenhack_handle_event (Display *dpy, XEvent *event)
screenhack_handle_event (Display *dpy, XEvent *event)
{ {
int key=0; int key=0;
switch (event->xany.type) switch (event->xany.type)
@ -193,26 +192,28 @@ screenhack_handle_event (Display *dpy, XEvent *event)
unsigned char c = 0; unsigned char c = 0;
XLookupString (&event->xkey, &c, 1, &keysym, 0); XLookupString (&event->xkey, &c, 1, &keysym, 0);
if (! (keysym >= XK_Shift_L && keysym <= XK_Hyper_R)) if (! (keysym >= XK_Shift_L && keysym <= XK_Hyper_R))
XBell (dpy, 0); /* beep for non-chord keys */ XBell (dpy, 0); /* beep for non-chord keys */
key = keysym; key = keysym;
fprintf(stderr, "KEY PRESSED: %c (%02x)\n", c, c); /* fprintf(stderr, "KEY PRESSED: %c (%02x)\n", c, c); */
} }
break; break;
case ResizeRequest: case ResizeRequest:
screen_resized(event->xresizerequest.width, event->xresizerequest.height); screen_resized(event->xresizerequest.width,
event->xresizerequest.height);
screen_redraw(); screen_redraw();
fprintf(stderr, "WINDOW RESIZED to width %d height %d\n", fprintf(stderr, "WINDOW RESIZED to width %d height %d\n",
event->xresizerequest.width, event->xresizerequest.height); event->xresizerequest.width, event->xresizerequest.height);
break; break;
default: default:
fprintf(stderr, "EVENT: %d (see /usr/include/X11/X.h)\n", /* fprintf(stderr, "EVENT: %d (see /usr/include/X11/X.h)\n",
event->xany.type); event->xany.type);
*/
break; break;
case Expose: case Expose:
screen_redraw(); screen_redraw();
fprintf(stderr, "EXPOSE: x: %d y: %d width: %d height: %d\n", fprintf(stderr, "EXPOSE: x: %d y: %d width: %d height: %d\n",
event->xexpose.x, event->xexpose.y, event->xexpose.x, event->xexpose.y,
event->xexpose.width, event->xexpose.height); event->xexpose.width, event->xexpose.height);
break; break;
case ButtonPress: case ButtonPress:
fprintf(stderr, "BUTTON PRESSED\n"); fprintf(stderr, "BUTTON PRESSED\n");
@ -221,23 +222,23 @@ screenhack_handle_event (Display *dpy, XEvent *event)
{ {
if (event->xclient.message_type != XA_WM_PROTOCOLS) if (event->xclient.message_type != XA_WM_PROTOCOLS)
{ {
char *s = XGetAtomName(dpy, event->xclient.message_type); char *s = XGetAtomName(dpy, event->xclient.message_type);
if (!s) s = "(null)"; if (!s) s = "(null)";
fprintf (stderr, "%s: unknown ClientMessage %s received!\n", fprintf (stderr, "%s: unknown ClientMessage %s received!\n",
progname, s); progname, s);
} }
else if (event->xclient.data.l[0] != XA_WM_DELETE_WINDOW) else if (event->xclient.data.l[0] != XA_WM_DELETE_WINDOW)
{ {
char *s1 = XGetAtomName(dpy, event->xclient.message_type); char *s1 = XGetAtomName(dpy, event->xclient.message_type);
char *s2 = XGetAtomName(dpy, event->xclient.data.l[0]); char *s2 = XGetAtomName(dpy, event->xclient.data.l[0]);
if (!s1) s1 = "(null)"; if (!s1) s1 = "(null)";
if (!s2) s2 = "(null)"; if (!s2) s2 = "(null)";
fprintf (stderr, "%s: unknown ClientMessage %s[%s] received!\n", fprintf (stderr, "%s: unknown ClientMessage %s[%s] received!\n",
progname, s1, s2); progname, s1, s2);
} }
else else
{ {
exit (0); exit (0);
} }
} }
break; break;
@ -246,15 +247,14 @@ screenhack_handle_event (Display *dpy, XEvent *event)
} }
int int screenhack_handle_events (void)
screenhack_handle_events (void)
{ {
int key=0; int key=0;
while (XPending (dpy)) while (XPending (dpy))
{ {
XEvent event; XEvent event;
XNextEvent (dpy, &event); XNextEvent (dpy, &event);
key=screenhack_handle_event (dpy, &event); key=screenhack_handle_event (dpy, &event);
} }
return key; return key;
} }
@ -264,33 +264,34 @@ static Visual *
pick_visual (Screen *screen) pick_visual (Screen *screen)
{ {
#ifdef USE_GL #ifdef USE_GL
/* If we're linking against GL (that is, this is the version of screenhack.o /* If we're linking against GL (that is, this is the version of
that the GL hacks will use, which is different from the one that the screenhack.o that the GL hacks will use, which is different from the
non-GL hacks will use) then try to pick the "best" visual by interrogating one that the non-GL hacks will use) then try to pick the "best" visual
the GL library instead of by asking Xlib. GL knows better. by interrogating the GL library instead of by asking Xlib. GL knows
*/ better.
Visual *v = 0; */
char *string = get_string_resource ("visualID", "VisualID"); Visual *v = 0;
char *s; char *string = get_string_resource ("visualID", "VisualID");
char *s;
if (string) if (string)
for (s = string; *s; s++) for (s = string; *s; s++)
if (isupper (*s)) *s = _tolower (*s); if (isupper (*s)) *s = _tolower (*s);
if (!string || !*string || if (!string || !*string ||
!strcmp (string, "gl") || !strcmp (string, "gl") ||
!strcmp (string, "best") || !strcmp (string, "best") ||
!strcmp (string, "color") || !strcmp (string, "color") ||
!strcmp (string, "default")) !strcmp (string, "default"))
v = get_gl_visual (screen); /* from ../utils/visual-gl.c */ v = get_gl_visual (screen); /* from ../utils/visual-gl.c */
if (string) if (string)
free (string); free (string);
if (v) if (v)
return v; return v;
#endif /* USE_GL */ #endif /* USE_GL */
return get_visual_resource (screen, "visualID", "VisualID", False); return get_visual_resource (screen, "visualID", "VisualID", False);
} }
@ -299,278 +300,278 @@ pick_visual (Screen *screen)
"-window-id 0x2c00001 -install") and complain, since when drawing "-window-id 0x2c00001 -install") and complain, since when drawing
on an existing window, we have no choice about these things. on an existing window, we have no choice about these things.
*/ */
static void static void visual_warning (Screen *screen, Window window, Visual *visual,
visual_warning (Screen *screen, Window window, Visual *visual, Colormap cmap, Colormap cmap, Bool window_p)
Bool window_p)
{ {
char *visual_string = get_string_resource ("visualID", "VisualID"); char *visual_string = get_string_resource ("visualID", "VisualID");
Visual *desired_visual = pick_visual (screen); Visual *desired_visual = pick_visual (screen);
char win[100]; char win[100];
char why[100]; char why[100];
if (window == RootWindowOfScreen (screen)) if (window == RootWindowOfScreen (screen))
strcpy (win, "root window"); strcpy (win, "root window");
else else
sprintf (win, "window 0x%x", (unsigned long) window); sprintf (win, "window 0x%x", (unsigned long) window);
if (window_p) if (window_p)
sprintf (why, "-window-id 0x%x", (unsigned long) window); sprintf (why, "-window-id 0x%x", (unsigned long) window);
else else
strcpy (why, "-root"); strcpy (why, "-root");
if (visual_string && *visual_string) if (visual_string && *visual_string)
{ {
char *s; char *s;
for (s = visual_string; *s; s++) for (s = visual_string; *s; s++)
if (isupper (*s)) *s = _tolower (*s); if (isupper (*s)) *s = _tolower (*s);
if (!strcmp (visual_string, "default") || if (!strcmp (visual_string, "default") ||
!strcmp (visual_string, "default") || !strcmp (visual_string, "default") ||
!strcmp (visual_string, "best")) !strcmp (visual_string, "best"))
/* don't warn about these, just silently DWIM. */ /* don't warn about these, just silently DWIM. */
; ;
else if (visual != desired_visual) else if (visual != desired_visual)
{ {
fprintf (stderr, "%s: ignoring `-visual %s' because of `%s'.\n", fprintf (stderr, "%s: ignoring `-visual %s' because of `%s'.\n",
progname, visual_string, why); progname, visual_string, why);
fprintf (stderr, "%s: using %s's visual 0x%x.\n", fprintf (stderr, "%s: using %s's visual 0x%x.\n",
progname, win, XVisualIDFromVisual (visual)); progname, win, XVisualIDFromVisual (visual));
} }
free (visual_string); free (visual_string);
} }
if (visual == DefaultVisualOfScreen (screen) && if (visual == DefaultVisualOfScreen (screen) &&
has_writable_cells (screen, visual) && has_writable_cells (screen, visual) &&
get_boolean_resource ("installColormap", "InstallColormap")) get_boolean_resource ("installColormap", "InstallColormap"))
{ {
fprintf (stderr, "%s: ignoring `-install' because of `%s'.\n", fprintf (stderr, "%s: ignoring `-install' because of `%s'.\n",
progname, why); progname, why);
fprintf (stderr, "%s: using %s's colormap 0x%x.\n", fprintf (stderr, "%s: using %s's colormap 0x%x.\n",
progname, win, (unsigned long) cmap); progname, win, (unsigned long) cmap);
} }
} }
int int main (int argc, char **argv)
main (int argc, char **argv)
{ {
Widget toplevel; Widget toplevel;
Display *dpy; Display *dpy;
Window window; Window window;
Screen *screen; Screen *screen;
Visual *visual; Visual *visual;
Colormap cmap; Colormap cmap;
Bool root_p; Bool root_p;
Window on_window = 0; Window on_window = 0;
XEvent event; XEvent event;
Boolean dont_clear /*, dont_map */; Boolean dont_clear /*, dont_map */;
char version[255]; char version[255];
#ifdef XLOCKMORE #ifdef XLOCKMORE
pre_merge_options (); pre_merge_options ();
#endif #endif
merge_options (); merge_options ();
#ifdef __sgi #ifdef __sgi
/* We have to do this on SGI to prevent the background color from being /* We have to do this on SGI to prevent the background color from being
overridden by the current desktop color scheme (we'd like our backgrounds overridden by the current desktop color scheme (we'd like our
to be black, thanks.) This should be the same as setting the backgrounds to be black, thanks.) This should be the same as setting
"*useSchemes: none" resource, but it's not -- if that resource is the "*useSchemes: none" resource, but it's not -- if that resource is
present in the `default_defaults' above, it doesn't work, though it present in the `default_defaults' above, it doesn't work, though it
does work when passed as an -xrm arg on the command line. So screw it, does work when passed as an -xrm arg on the command line. So screw it,
turn them off from C instead. turn them off from C instead.
*/ */
SgiUseSchemes ("none"); SgiUseSchemes ("none");
#endif /* __sgi */ #endif /* __sgi */
toplevel = XtAppInitialize (&app, progclass, merged_options, toplevel = XtAppInitialize (&app, progclass, merged_options,
merged_options_size, &argc, argv, merged_options_size, &argc, argv,
merged_defaults, 0, 0); merged_defaults, 0, 0);
dpy = XtDisplay (toplevel); dpy = XtDisplay (toplevel);
screen = XtScreen (toplevel); screen = XtScreen (toplevel);
db = XtDatabase (dpy); db = XtDatabase (dpy);
XtGetApplicationNameAndClass (dpy, &progname, &progclass); XtGetApplicationNameAndClass (dpy, &progname, &progclass);
/* half-assed way of avoiding buffer-overrun attacks. */ /* half-assed way of avoiding buffer-overrun attacks. */
if (strlen (progname) >= 100) progname[100] = 0; if (strlen (progname) >= 100) progname[100] = 0;
XSetErrorHandler (screenhack_ehandler); XSetErrorHandler (screenhack_ehandler);
XA_WM_PROTOCOLS = XInternAtom (dpy, "WM_PROTOCOLS", False); XA_WM_PROTOCOLS = XInternAtom (dpy, "WM_PROTOCOLS", False);
XA_WM_DELETE_WINDOW = XInternAtom (dpy, "WM_DELETE_WINDOW", False); XA_WM_DELETE_WINDOW = XInternAtom (dpy, "WM_DELETE_WINDOW", False);
if (argc > 1) if (argc > 1)
{ {
const char *s; const char *s;
int i; int i;
int x = 18; int x = 18;
int end = 78; int end = 78;
Bool help_p = !strcmp(argv[1], "-help"); Bool help_p = !strcmp(argv[1], "-help");
fprintf (stderr, "%s\n", version); fprintf (stderr, "%s\n", version);
for (s = progclass; *s; s++) fprintf(stderr, " "); for (s = progclass; *s; s++) fprintf(stderr, " ");
fprintf (stderr, " eXcellent GUI\n\n"); fprintf (stderr, " eXcellent GUI\n\n");
if (!help_p) if (!help_p)
fprintf(stderr, "Unrecognised option: %s\n", argv[1]); fprintf(stderr, "Unrecognised option: %s\n", argv[1]);
fprintf (stderr, "Options include: "); fprintf (stderr, "Options include: ");
for (i = 0; i < merged_options_size; i++) for (i = 0; i < merged_options_size; i++)
{ {
char *sw = merged_options [i].option; char *sw = merged_options [i].option;
Bool argp = (merged_options [i].argKind == XrmoptionSepArg); Bool argp = (merged_options [i].argKind == XrmoptionSepArg);
int size = strlen (sw) + (argp ? 6 : 0) + 2; int size = strlen (sw) + (argp ? 6 : 0) + 2;
if (x + size >= end) if (x + size >= end)
{ {
fprintf (stderr, "\n\t\t "); fprintf (stderr, "\n\t\t ");
x = 18; x = 18;
} }
x += size; x += size;
fprintf (stderr, "%s", sw); fprintf (stderr, "%s", sw);
if (argp) fprintf (stderr, " <arg>"); if (argp) fprintf (stderr, " <arg>");
if (i != merged_options_size - 1) fprintf (stderr, ", "); if (i != merged_options_size - 1) fprintf (stderr, ", ");
} }
fprintf (stderr, ".\n"); fprintf (stderr, ".\n");
exit (help_p ? 0 : 1); exit (help_p ? 0 : 1);
} }
dont_clear = get_boolean_resource ("dontClearRoot", "Boolean"); dont_clear = get_boolean_resource ("dontClearRoot", "Boolean");
/*dont_map = get_boolean_resource ("dontMapWindow", "Boolean"); */ /*dont_map = get_boolean_resource ("dontMapWindow", "Boolean"); */
mono_p = get_boolean_resource ("mono", "Boolean"); mono_p = get_boolean_resource ("mono", "Boolean");
if (CellsOfScreen (DefaultScreenOfDisplay (dpy)) <= 2) if (CellsOfScreen (DefaultScreenOfDisplay (dpy)) <= 2)
mono_p = True; mono_p = True;
root_p = get_boolean_resource ("root", "Boolean"); root_p = get_boolean_resource ("root", "Boolean");
{
char *s = get_string_resource ("windowID", "WindowID");
if (s && *s)
on_window = get_integer_resource ("windowID", "WindowID");
if (s) free (s);
}
if (on_window)
{ {
XWindowAttributes xgwa; char *s = get_string_resource ("windowID", "WindowID");
window = (Window) on_window; if (s && *s)
XtDestroyWidget (toplevel); on_window = get_integer_resource ("windowID", "WindowID");
XGetWindowAttributes (dpy, window, &xgwa); if (s) free (s);
cmap = xgwa.colormap;
visual = xgwa.visual;
visual_warning (screen, window, visual, cmap, True);
} }
else if (root_p)
if (on_window)
{ {
XWindowAttributes xgwa; XWindowAttributes xgwa;
window = RootWindowOfScreen (XtScreen (toplevel)); window = (Window) on_window;
XtDestroyWidget (toplevel); XtDestroyWidget (toplevel);
XGetWindowAttributes (dpy, window, &xgwa); XGetWindowAttributes (dpy, window, &xgwa);
cmap = xgwa.colormap; cmap = xgwa.colormap;
visual = xgwa.visual; visual = xgwa.visual;
visual_warning (screen, window, visual, cmap, False); visual_warning (screen, window, visual, cmap, True);
} }
else else if (root_p)
{ {
Boolean def_visual_p; XWindowAttributes xgwa;
visual = pick_visual (screen); window = RootWindowOfScreen (XtScreen (toplevel));
XtDestroyWidget (toplevel);
XGetWindowAttributes (dpy, window, &xgwa);
cmap = xgwa.colormap;
visual = xgwa.visual;
visual_warning (screen, window, visual, cmap, False);
}
else
{
Boolean def_visual_p;
visual = pick_visual (screen);
if (toplevel->core.width <= 0) if (toplevel->core.width <= 0)
toplevel->core.width = 600; toplevel->core.width = 600;
if (toplevel->core.height <= 0) if (toplevel->core.height <= 0)
toplevel->core.height = 480; toplevel->core.height = 480;
def_visual_p = (visual == DefaultVisualOfScreen (screen)); def_visual_p = (visual == DefaultVisualOfScreen (screen));
if (!def_visual_p) if (!def_visual_p)
{ {
unsigned int bg, bd; unsigned int bg, bd;
Widget new; Widget new;
cmap = XCreateColormap (dpy, RootWindowOfScreen(screen), cmap = XCreateColormap (dpy, RootWindowOfScreen(screen),
visual, AllocNone); visual, AllocNone);
bg = get_pixel_resource ("background", "Background", dpy, cmap); bg = get_pixel_resource ("background", "Background", dpy, cmap);
bd = get_pixel_resource ("borderColor", "Foreground", dpy, cmap); bd = get_pixel_resource ("borderColor", "Foreground", dpy, cmap);
new = XtVaAppCreateShell (progname, progclass, new = XtVaAppCreateShell (progname, progclass,
topLevelShellWidgetClass, dpy, topLevelShellWidgetClass, dpy,
XtNmappedWhenManaged, False, XtNmappedWhenManaged, False,
XtNvisual, visual, XtNvisual, visual,
XtNdepth, visual_depth (screen, visual), XtNdepth, visual_depth (screen, visual),
XtNwidth, toplevel->core.width, XtNwidth, toplevel->core.width,
XtNheight, toplevel->core.height, XtNheight, toplevel->core.height,
XtNcolormap, cmap, XtNcolormap, cmap,
XtNbackground, (Pixel) bg, XtNbackground, (Pixel) bg,
XtNborderColor, (Pixel) bd, XtNborderColor, (Pixel) bd,
XtNinput, True, /* for WM_HINTS */ XtNinput, True, /* for WM_HINTS */
0); 0);
XtDestroyWidget (toplevel); XtDestroyWidget (toplevel);
toplevel = new; toplevel = new;
XtRealizeWidget (toplevel); XtRealizeWidget (toplevel);
window = XtWindow (toplevel); window = XtWindow (toplevel);
} }
else else
{ {
XtVaSetValues (toplevel, XtVaSetValues (toplevel,
XtNmappedWhenManaged, False, XtNmappedWhenManaged, False,
XtNinput, True, /* for WM_HINTS */ XtNinput, True, /* for WM_HINTS */
0); 0);
XtRealizeWidget (toplevel); XtRealizeWidget (toplevel);
window = XtWindow (toplevel); window = XtWindow (toplevel);
if (get_boolean_resource ("installColormap", "InstallColormap")) if (get_boolean_resource ("installColormap", "InstallColormap"))
{ {
cmap = XCreateColormap (dpy, window, cmap = XCreateColormap (dpy, window,
DefaultVisualOfScreen (XtScreen (toplevel)), DefaultVisualOfScreen (XtScreen
AllocNone); (toplevel)),
XSetWindowColormap (dpy, window, cmap); AllocNone);
} XSetWindowColormap (dpy, window, cmap);
else }
{ else
cmap = DefaultColormap (dpy, DefaultScreen (dpy)); {
} cmap = DefaultColormap (dpy, DefaultScreen (dpy));
} }
}
/* /*
if (dont_map) if (dont_map)
{ {
XtVaSetValues (toplevel, XtNmappedWhenManaged, False, 0); XtVaSetValues (toplevel, XtNmappedWhenManaged, False, 0);
XtRealizeWidget (toplevel); XtRealizeWidget (toplevel);
} }
else else
*/ */
{ {
XtPopup (toplevel, XtGrabNone); XtPopup (toplevel, XtGrabNone);
} }
XtVaSetValues(toplevel, XtNtitle, version, 0); XtVaSetValues(toplevel, XtNtitle, version, 0);
/* For screenhack_handle_events(): select KeyPress, and /* For screenhack_handle_events(): select KeyPress, and
announce that we accept WM_DELETE_WINDOW. */ announce that we accept WM_DELETE_WINDOW. */
{ {
XWindowAttributes xgwa; XWindowAttributes xgwa;
XGetWindowAttributes (dpy, window, &xgwa); XGetWindowAttributes (dpy, window, &xgwa);
XSelectInput (dpy, window, XSelectInput (dpy, window,
xgwa.your_event_mask | KeyPressMask | ButtonPressMask | ResizeRedirectMask | ExposureMask); xgwa.your_event_mask | KeyPressMask |
XChangeProperty (dpy, window, XA_WM_PROTOCOLS, XA_ATOM, 32, ButtonPressMask | ResizeRedirectMask | ExposureMask);
PropModeReplace, XChangeProperty (dpy, window, XA_WM_PROTOCOLS, XA_ATOM, 32,
(unsigned char *) &XA_WM_DELETE_WINDOW, 1); PropModeReplace,
} (unsigned char *) &XA_WM_DELETE_WINDOW, 1);
}
} }
if (!dont_clear) if (!dont_clear)
{ {
XSetWindowBackground (dpy, window, XSetWindowBackground (dpy, window,
get_pixel_resource ("background", "Background", get_pixel_resource ("background", "Background",
dpy, cmap)); dpy, cmap));
XClearWindow (dpy, window); XClearWindow (dpy, window);
} }
if (!root_p && !on_window) if (!root_p && !on_window)
/* wait for it to be mapped */ /* wait for it to be mapped */
XIfEvent (dpy, &event, MapNotify_event_p, (XPointer) window); XIfEvent (dpy, &event, MapNotify_event_p, (XPointer) window);
XSync (dpy, False); XSync (dpy, False);
screenhack (dpy, window); /* doesn't return */ screenhack (dpy, window); /* doesn't return */
return 0; return 0;
} }