diff options
Diffstat (limited to 'uisimulator/x11/screenhack.c')
-rw-r--r-- | uisimulator/x11/screenhack.c | 669 |
1 files changed, 335 insertions, 334 deletions
diff --git a/uisimulator/x11/screenhack.c b/uisimulator/x11/screenhack.c index f4f5aaa348..34613dfab4 100644 --- a/uisimulator/x11/screenhack.c +++ b/uisimulator/x11/screenhack.c | |||
@@ -97,77 +97,77 @@ static XrmOptionDescRec *merged_options; | |||
97 | static int merged_options_size; | 97 | static int merged_options_size; |
98 | static char **merged_defaults; | 98 | static char **merged_defaults; |
99 | 99 | ||
100 | static void | 100 | static void merge_options (void) |
101 | merge_options (void) | ||
102 | { | 101 | { |
103 | int def_opts_size, opts_size; | 102 | int def_opts_size, opts_size; |
104 | int def_defaults_size, defaults_size; | 103 | int def_defaults_size, defaults_size; |
105 | 104 | ||
106 | for (def_opts_size = 0; default_options[def_opts_size].option; | 105 | for (def_opts_size = 0; default_options[def_opts_size].option; |
107 | def_opts_size++) | 106 | def_opts_size++) |
108 | ; | 107 | ; |
109 | for (opts_size = 0; options[opts_size].option; opts_size++) | 108 | for (opts_size = 0; options[opts_size].option; opts_size++) |
110 | ; | 109 | ; |
111 | 110 | ||
112 | merged_options_size = def_opts_size + opts_size; | 111 | merged_options_size = def_opts_size + opts_size; |
113 | merged_options = (XrmOptionDescRec *) | 112 | merged_options = (XrmOptionDescRec *) |
114 | malloc ((merged_options_size + 1) * sizeof(*default_options)); | 113 | malloc ((merged_options_size + 1) * sizeof(*default_options)); |
115 | memcpy (merged_options, default_options, | 114 | memcpy (merged_options, default_options, |
116 | (def_opts_size * sizeof(*default_options))); | 115 | (def_opts_size * sizeof(*default_options))); |
117 | memcpy (merged_options + def_opts_size, options, | 116 | memcpy (merged_options + def_opts_size, options, |
118 | ((opts_size + 1) * sizeof(*default_options))); | 117 | ((opts_size + 1) * sizeof(*default_options))); |
119 | 118 | ||
120 | for (def_defaults_size = 0; default_defaults[def_defaults_size]; | 119 | for (def_defaults_size = 0; default_defaults[def_defaults_size]; |
121 | def_defaults_size++) | 120 | def_defaults_size++) |
122 | ; | 121 | ; |
123 | for (defaults_size = 0; defaults[defaults_size]; defaults_size++) | 122 | for (defaults_size = 0; defaults[defaults_size]; defaults_size++) |
124 | ; | 123 | ; |
125 | merged_defaults = (char **) | 124 | |
126 | malloc ((def_defaults_size + defaults_size + 1) * sizeof (*defaults));; | 125 | merged_defaults = (char **) |
127 | memcpy (merged_defaults, default_defaults, | 126 | malloc ((def_defaults_size + defaults_size + 1) * sizeof (*defaults)); |
128 | def_defaults_size * sizeof(*defaults)); | 127 | |
129 | memcpy (merged_defaults + def_defaults_size, defaults, | 128 | memcpy (merged_defaults, default_defaults, |
130 | (defaults_size + 1) * sizeof(*defaults)); | 129 | def_defaults_size * sizeof(*defaults)); |
131 | 130 | memcpy (merged_defaults + def_defaults_size, defaults, | |
132 | /* This totally sucks. Xt should behave like this by default. | 131 | (defaults_size + 1) * sizeof(*defaults)); |
133 | If the string in `defaults' looks like ".foo", change that | 132 | |
134 | to "Progclass.foo". | 133 | /* This totally sucks. Xt should behave like this by default. |
135 | */ | 134 | If the string in `defaults' looks like ".foo", change that |
136 | { | 135 | to "Progclass.foo". |
137 | char **s; | 136 | */ |
138 | for (s = merged_defaults; *s; s++) | 137 | { |
139 | if (**s == '.') | 138 | char **s; |
140 | { | 139 | for (s = merged_defaults; *s; s++) |
141 | const char *oldr = *s; | 140 | if (**s == '.') |
142 | char *newr = (char *) malloc(strlen(oldr) + strlen(progclass) + 3); | 141 | { |
143 | strcpy (newr, progclass); | 142 | const char *oldr = *s; |
144 | strcat (newr, oldr); | 143 | char *newr = (char *) malloc(strlen(oldr) |
145 | *s = newr; | 144 | + strlen(progclass) + 3); |
146 | } | 145 | strcpy (newr, progclass); |
147 | } | 146 | strcat (newr, oldr); |
147 | *s = newr; | ||
148 | } | ||
149 | } | ||
148 | } | 150 | } |
149 | 151 | ||
150 | 152 | ||
151 | /* Make the X errors print out the name of this program, so we have some | 153 | /* Make the X errors print out the name of this program, so we have some |
152 | clue which one has a bug when they die under the screensaver. | 154 | clue which one has a bug when they die under the screensaver. |
153 | */ | 155 | */ |
154 | 156 | ||
155 | static int | 157 | static int screenhack_ehandler (Display *dpy, XErrorEvent *error) |
156 | screenhack_ehandler (Display *dpy, XErrorEvent *error) | ||
157 | { | 158 | { |
158 | fprintf (stderr, "\nX error in %s:\n", progname); | 159 | fprintf (stderr, "\nX error in %s:\n", progname); |
159 | if (XmuPrintDefaultErrorMessage (dpy, error, stderr)) | 160 | if (XmuPrintDefaultErrorMessage (dpy, error, stderr)) |
160 | exit (-1); | 161 | exit (-1); |
161 | else | 162 | else |
162 | fprintf (stderr, " (nonfatal.)\n"); | 163 | fprintf (stderr, " (nonfatal.)\n"); |
163 | return 0; | 164 | return 0; |
164 | } | 165 | } |
165 | 166 | ||
166 | static Bool | 167 | static Bool MapNotify_event_p (Display *dpy, XEvent *event, XPointer window) |
167 | MapNotify_event_p (Display *dpy, XEvent *event, XPointer window) | ||
168 | { | 168 | { |
169 | return (event->xany.type == MapNotify && | 169 | return (event->xany.type == MapNotify && |
170 | event->xvisibility.window == (Window) window); | 170 | event->xvisibility.window == (Window) window); |
171 | } | 171 | } |
172 | 172 | ||
173 | 173 | ||
@@ -181,8 +181,7 @@ static Atom XA_WM_PROTOCOLS, XA_WM_DELETE_WINDOW; | |||
181 | /* Dead-trivial event handling: exits if "q" or "ESC" are typed. | 181 | /* Dead-trivial event handling: exits if "q" or "ESC" are typed. |
182 | Exit if the WM_PROTOCOLS WM_DELETE_WINDOW ClientMessage is received. | 182 | Exit if the WM_PROTOCOLS WM_DELETE_WINDOW ClientMessage is received. |
183 | */ | 183 | */ |
184 | int | 184 | int screenhack_handle_event (Display *dpy, XEvent *event) |
185 | screenhack_handle_event (Display *dpy, XEvent *event) | ||
186 | { | 185 | { |
187 | int key=0; | 186 | int key=0; |
188 | switch (event->xany.type) | 187 | switch (event->xany.type) |
@@ -193,26 +192,28 @@ screenhack_handle_event (Display *dpy, XEvent *event) | |||
193 | unsigned char c = 0; | 192 | unsigned char c = 0; |
194 | XLookupString (&event->xkey, &c, 1, &keysym, 0); | 193 | XLookupString (&event->xkey, &c, 1, &keysym, 0); |
195 | if (! (keysym >= XK_Shift_L && keysym <= XK_Hyper_R)) | 194 | if (! (keysym >= XK_Shift_L && keysym <= XK_Hyper_R)) |
196 | XBell (dpy, 0); /* beep for non-chord keys */ | 195 | XBell (dpy, 0); /* beep for non-chord keys */ |
197 | key = keysym; | 196 | key = keysym; |
198 | fprintf(stderr, "KEY PRESSED: %c (%02x)\n", c, c); | 197 | /* fprintf(stderr, "KEY PRESSED: %c (%02x)\n", c, c); */ |
199 | } | 198 | } |
200 | break; | 199 | break; |
201 | case ResizeRequest: | 200 | case ResizeRequest: |
202 | screen_resized(event->xresizerequest.width, event->xresizerequest.height); | 201 | screen_resized(event->xresizerequest.width, |
202 | event->xresizerequest.height); | ||
203 | screen_redraw(); | 203 | screen_redraw(); |
204 | fprintf(stderr, "WINDOW RESIZED to width %d height %d\n", | 204 | fprintf(stderr, "WINDOW RESIZED to width %d height %d\n", |
205 | event->xresizerequest.width, event->xresizerequest.height); | 205 | event->xresizerequest.width, event->xresizerequest.height); |
206 | break; | 206 | break; |
207 | default: | 207 | default: |
208 | fprintf(stderr, "EVENT: %d (see /usr/include/X11/X.h)\n", | 208 | /* fprintf(stderr, "EVENT: %d (see /usr/include/X11/X.h)\n", |
209 | event->xany.type); | 209 | event->xany.type); |
210 | */ | ||
210 | break; | 211 | break; |
211 | case Expose: | 212 | case Expose: |
212 | screen_redraw(); | 213 | screen_redraw(); |
213 | fprintf(stderr, "EXPOSE: x: %d y: %d width: %d height: %d\n", | 214 | fprintf(stderr, "EXPOSE: x: %d y: %d width: %d height: %d\n", |
214 | event->xexpose.x, event->xexpose.y, | 215 | event->xexpose.x, event->xexpose.y, |
215 | event->xexpose.width, event->xexpose.height); | 216 | event->xexpose.width, event->xexpose.height); |
216 | break; | 217 | break; |
217 | case ButtonPress: | 218 | case ButtonPress: |
218 | fprintf(stderr, "BUTTON PRESSED\n"); | 219 | fprintf(stderr, "BUTTON PRESSED\n"); |
@@ -221,23 +222,23 @@ screenhack_handle_event (Display *dpy, XEvent *event) | |||
221 | { | 222 | { |
222 | if (event->xclient.message_type != XA_WM_PROTOCOLS) | 223 | if (event->xclient.message_type != XA_WM_PROTOCOLS) |
223 | { | 224 | { |
224 | char *s = XGetAtomName(dpy, event->xclient.message_type); | 225 | char *s = XGetAtomName(dpy, event->xclient.message_type); |
225 | if (!s) s = "(null)"; | 226 | if (!s) s = "(null)"; |
226 | fprintf (stderr, "%s: unknown ClientMessage %s received!\n", | 227 | fprintf (stderr, "%s: unknown ClientMessage %s received!\n", |
227 | progname, s); | 228 | progname, s); |
228 | } | 229 | } |
229 | else if (event->xclient.data.l[0] != XA_WM_DELETE_WINDOW) | 230 | else if (event->xclient.data.l[0] != XA_WM_DELETE_WINDOW) |
230 | { | 231 | { |
231 | char *s1 = XGetAtomName(dpy, event->xclient.message_type); | 232 | char *s1 = XGetAtomName(dpy, event->xclient.message_type); |
232 | char *s2 = XGetAtomName(dpy, event->xclient.data.l[0]); | 233 | char *s2 = XGetAtomName(dpy, event->xclient.data.l[0]); |
233 | if (!s1) s1 = "(null)"; | 234 | if (!s1) s1 = "(null)"; |
234 | if (!s2) s2 = "(null)"; | 235 | if (!s2) s2 = "(null)"; |
235 | fprintf (stderr, "%s: unknown ClientMessage %s[%s] received!\n", | 236 | fprintf (stderr, "%s: unknown ClientMessage %s[%s] received!\n", |
236 | progname, s1, s2); | 237 | progname, s1, s2); |
237 | } | 238 | } |
238 | else | 239 | else |
239 | { | 240 | { |
240 | exit (0); | 241 | exit (0); |
241 | } | 242 | } |
242 | } | 243 | } |
243 | break; | 244 | break; |
@@ -246,15 +247,14 @@ screenhack_handle_event (Display *dpy, XEvent *event) | |||
246 | } | 247 | } |
247 | 248 | ||
248 | 249 | ||
249 | int | 250 | int screenhack_handle_events (void) |
250 | screenhack_handle_events (void) | ||
251 | { | 251 | { |
252 | int key=0; | 252 | int key=0; |
253 | while (XPending (dpy)) | 253 | while (XPending (dpy)) |
254 | { | 254 | { |
255 | XEvent event; | 255 | XEvent event; |
256 | XNextEvent (dpy, &event); | 256 | XNextEvent (dpy, &event); |
257 | key=screenhack_handle_event (dpy, &event); | 257 | key=screenhack_handle_event (dpy, &event); |
258 | } | 258 | } |
259 | return key; | 259 | return key; |
260 | } | 260 | } |
@@ -264,33 +264,34 @@ static Visual * | |||
264 | pick_visual (Screen *screen) | 264 | pick_visual (Screen *screen) |
265 | { | 265 | { |
266 | #ifdef USE_GL | 266 | #ifdef USE_GL |
267 | /* If we're linking against GL (that is, this is the version of screenhack.o | 267 | /* If we're linking against GL (that is, this is the version of |
268 | that the GL hacks will use, which is different from the one that the | 268 | screenhack.o that the GL hacks will use, which is different from the |
269 | non-GL hacks will use) then try to pick the "best" visual by interrogating | 269 | one that the non-GL hacks will use) then try to pick the "best" visual |
270 | the GL library instead of by asking Xlib. GL knows better. | 270 | by interrogating the GL library instead of by asking Xlib. GL knows |
271 | */ | 271 | better. |
272 | Visual *v = 0; | 272 | */ |
273 | char *string = get_string_resource ("visualID", "VisualID"); | 273 | Visual *v = 0; |
274 | char *s; | 274 | char *string = get_string_resource ("visualID", "VisualID"); |
275 | 275 | char *s; | |
276 | if (string) | 276 | |
277 | for (s = string; *s; s++) | 277 | if (string) |
278 | if (isupper (*s)) *s = _tolower (*s); | 278 | for (s = string; *s; s++) |
279 | 279 | if (isupper (*s)) *s = _tolower (*s); | |
280 | if (!string || !*string || | 280 | |
281 | !strcmp (string, "gl") || | 281 | if (!string || !*string || |
282 | !strcmp (string, "best") || | 282 | !strcmp (string, "gl") || |
283 | !strcmp (string, "color") || | 283 | !strcmp (string, "best") || |
284 | !strcmp (string, "default")) | 284 | !strcmp (string, "color") || |
285 | v = get_gl_visual (screen); /* from ../utils/visual-gl.c */ | 285 | !strcmp (string, "default")) |
286 | 286 | v = get_gl_visual (screen); /* from ../utils/visual-gl.c */ | |
287 | if (string) | 287 | |
288 | free (string); | 288 | if (string) |
289 | if (v) | 289 | free (string); |
290 | return v; | 290 | if (v) |
291 | return v; | ||
291 | #endif /* USE_GL */ | 292 | #endif /* USE_GL */ |
292 | 293 | ||
293 | return get_visual_resource (screen, "visualID", "VisualID", False); | 294 | return get_visual_resource (screen, "visualID", "VisualID", False); |
294 | } | 295 | } |
295 | 296 | ||
296 | 297 | ||
@@ -299,278 +300,278 @@ pick_visual (Screen *screen) | |||
299 | "-window-id 0x2c00001 -install") and complain, since when drawing | 300 | "-window-id 0x2c00001 -install") and complain, since when drawing |
300 | on an existing window, we have no choice about these things. | 301 | on an existing window, we have no choice about these things. |
301 | */ | 302 | */ |
302 | static void | 303 | static void visual_warning (Screen *screen, Window window, Visual *visual, |
303 | visual_warning (Screen *screen, Window window, Visual *visual, Colormap cmap, | 304 | Colormap cmap, Bool window_p) |
304 | Bool window_p) | ||
305 | { | 305 | { |
306 | char *visual_string = get_string_resource ("visualID", "VisualID"); | 306 | char *visual_string = get_string_resource ("visualID", "VisualID"); |
307 | Visual *desired_visual = pick_visual (screen); | 307 | Visual *desired_visual = pick_visual (screen); |
308 | char win[100]; | 308 | char win[100]; |
309 | char why[100]; | 309 | char why[100]; |
310 | 310 | ||
311 | if (window == RootWindowOfScreen (screen)) | 311 | if (window == RootWindowOfScreen (screen)) |
312 | strcpy (win, "root window"); | 312 | strcpy (win, "root window"); |
313 | else | 313 | else |
314 | sprintf (win, "window 0x%x", (unsigned long) window); | 314 | sprintf (win, "window 0x%x", (unsigned long) window); |
315 | 315 | ||
316 | if (window_p) | 316 | if (window_p) |
317 | sprintf (why, "-window-id 0x%x", (unsigned long) window); | 317 | sprintf (why, "-window-id 0x%x", (unsigned long) window); |
318 | else | 318 | else |
319 | strcpy (why, "-root"); | 319 | strcpy (why, "-root"); |
320 | 320 | ||
321 | if (visual_string && *visual_string) | 321 | if (visual_string && *visual_string) |
322 | { | 322 | { |
323 | char *s; | 323 | char *s; |
324 | for (s = visual_string; *s; s++) | 324 | for (s = visual_string; *s; s++) |
325 | if (isupper (*s)) *s = _tolower (*s); | 325 | if (isupper (*s)) *s = _tolower (*s); |
326 | 326 | ||
327 | if (!strcmp (visual_string, "default") || | 327 | if (!strcmp (visual_string, "default") || |
328 | !strcmp (visual_string, "default") || | 328 | !strcmp (visual_string, "default") || |
329 | !strcmp (visual_string, "best")) | 329 | !strcmp (visual_string, "best")) |
330 | /* don't warn about these, just silently DWIM. */ | 330 | /* don't warn about these, just silently DWIM. */ |
331 | ; | 331 | ; |
332 | else if (visual != desired_visual) | 332 | else if (visual != desired_visual) |
333 | { | 333 | { |
334 | fprintf (stderr, "%s: ignoring `-visual %s' because of `%s'.\n", | 334 | fprintf (stderr, "%s: ignoring `-visual %s' because of `%s'.\n", |
335 | progname, visual_string, why); | 335 | progname, visual_string, why); |
336 | fprintf (stderr, "%s: using %s's visual 0x%x.\n", | 336 | fprintf (stderr, "%s: using %s's visual 0x%x.\n", |
337 | progname, win, XVisualIDFromVisual (visual)); | 337 | progname, win, XVisualIDFromVisual (visual)); |
338 | } | 338 | } |
339 | free (visual_string); | 339 | free (visual_string); |
340 | } | 340 | } |
341 | 341 | ||
342 | if (visual == DefaultVisualOfScreen (screen) && | 342 | if (visual == DefaultVisualOfScreen (screen) && |
343 | has_writable_cells (screen, visual) && | 343 | has_writable_cells (screen, visual) && |
344 | get_boolean_resource ("installColormap", "InstallColormap")) | 344 | get_boolean_resource ("installColormap", "InstallColormap")) |
345 | { | 345 | { |
346 | fprintf (stderr, "%s: ignoring `-install' because of `%s'.\n", | 346 | fprintf (stderr, "%s: ignoring `-install' because of `%s'.\n", |
347 | progname, why); | 347 | progname, why); |
348 | fprintf (stderr, "%s: using %s's colormap 0x%x.\n", | 348 | fprintf (stderr, "%s: using %s's colormap 0x%x.\n", |
349 | progname, win, (unsigned long) cmap); | 349 | progname, win, (unsigned long) cmap); |
350 | } | 350 | } |
351 | } | 351 | } |
352 | 352 | ||
353 | 353 | ||
354 | int | 354 | int main (int argc, char **argv) |
355 | main (int argc, char **argv) | ||
356 | { | 355 | { |
357 | Widget toplevel; | 356 | Widget toplevel; |
358 | Display *dpy; | 357 | Display *dpy; |
359 | Window window; | 358 | Window window; |
360 | Screen *screen; | 359 | Screen *screen; |
361 | Visual *visual; | 360 | Visual *visual; |
362 | Colormap cmap; | 361 | Colormap cmap; |
363 | Bool root_p; | 362 | Bool root_p; |
364 | Window on_window = 0; | 363 | Window on_window = 0; |
365 | XEvent event; | 364 | XEvent event; |
366 | Boolean dont_clear /*, dont_map */; | 365 | Boolean dont_clear /*, dont_map */; |
367 | char version[255]; | 366 | char version[255]; |
368 | 367 | ||
369 | #ifdef XLOCKMORE | 368 | #ifdef XLOCKMORE |
370 | pre_merge_options (); | 369 | pre_merge_options (); |
371 | #endif | 370 | #endif |
372 | merge_options (); | 371 | merge_options (); |
373 | 372 | ||
374 | #ifdef __sgi | 373 | #ifdef __sgi |
375 | /* We have to do this on SGI to prevent the background color from being | 374 | /* We have to do this on SGI to prevent the background color from being |
376 | overridden by the current desktop color scheme (we'd like our backgrounds | 375 | overridden by the current desktop color scheme (we'd like our |
377 | to be black, thanks.) This should be the same as setting the | 376 | backgrounds to be black, thanks.) This should be the same as setting |
378 | "*useSchemes: none" resource, but it's not -- if that resource is | 377 | the "*useSchemes: none" resource, but it's not -- if that resource is |
379 | present in the `default_defaults' above, it doesn't work, though it | 378 | present in the `default_defaults' above, it doesn't work, though it |
380 | does work when passed as an -xrm arg on the command line. So screw it, | 379 | does work when passed as an -xrm arg on the command line. So screw it, |
381 | turn them off from C instead. | 380 | turn them off from C instead. |
382 | */ | 381 | */ |
383 | SgiUseSchemes ("none"); | 382 | SgiUseSchemes ("none"); |
384 | #endif /* __sgi */ | 383 | #endif /* __sgi */ |
385 | 384 | ||
386 | toplevel = XtAppInitialize (&app, progclass, merged_options, | 385 | toplevel = XtAppInitialize (&app, progclass, merged_options, |
387 | merged_options_size, &argc, argv, | 386 | merged_options_size, &argc, argv, |
388 | merged_defaults, 0, 0); | 387 | merged_defaults, 0, 0); |
389 | dpy = XtDisplay (toplevel); | 388 | dpy = XtDisplay (toplevel); |
390 | screen = XtScreen (toplevel); | 389 | screen = XtScreen (toplevel); |
391 | db = XtDatabase (dpy); | 390 | db = XtDatabase (dpy); |
392 | 391 | ||
393 | XtGetApplicationNameAndClass (dpy, &progname, &progclass); | 392 | XtGetApplicationNameAndClass (dpy, &progname, &progclass); |
394 | 393 | ||
395 | /* half-assed way of avoiding buffer-overrun attacks. */ | 394 | /* half-assed way of avoiding buffer-overrun attacks. */ |
396 | if (strlen (progname) >= 100) progname[100] = 0; | 395 | if (strlen (progname) >= 100) progname[100] = 0; |
397 | 396 | ||
398 | XSetErrorHandler (screenhack_ehandler); | 397 | XSetErrorHandler (screenhack_ehandler); |
399 | 398 | ||
400 | XA_WM_PROTOCOLS = XInternAtom (dpy, "WM_PROTOCOLS", False); | 399 | XA_WM_PROTOCOLS = XInternAtom (dpy, "WM_PROTOCOLS", False); |
401 | XA_WM_DELETE_WINDOW = XInternAtom (dpy, "WM_DELETE_WINDOW", False); | 400 | XA_WM_DELETE_WINDOW = XInternAtom (dpy, "WM_DELETE_WINDOW", False); |
402 | 401 | ||
403 | 402 | ||
404 | if (argc > 1) | 403 | if (argc > 1) |
405 | { | 404 | { |
406 | const char *s; | 405 | const char *s; |
407 | int i; | 406 | int i; |
408 | int x = 18; | 407 | int x = 18; |
409 | int end = 78; | 408 | int end = 78; |
410 | Bool help_p = !strcmp(argv[1], "-help"); | 409 | Bool help_p = !strcmp(argv[1], "-help"); |
411 | fprintf (stderr, "%s\n", version); | 410 | fprintf (stderr, "%s\n", version); |
412 | for (s = progclass; *s; s++) fprintf(stderr, " "); | 411 | for (s = progclass; *s; s++) fprintf(stderr, " "); |
413 | fprintf (stderr, " eXcellent GUI\n\n"); | 412 | fprintf (stderr, " eXcellent GUI\n\n"); |
414 | 413 | ||
415 | if (!help_p) | 414 | if (!help_p) |
416 | fprintf(stderr, "Unrecognised option: %s\n", argv[1]); | 415 | fprintf(stderr, "Unrecognised option: %s\n", argv[1]); |
417 | fprintf (stderr, "Options include: "); | 416 | fprintf (stderr, "Options include: "); |
418 | for (i = 0; i < merged_options_size; i++) | 417 | for (i = 0; i < merged_options_size; i++) |
419 | { | 418 | { |
420 | char *sw = merged_options [i].option; | 419 | char *sw = merged_options [i].option; |
421 | Bool argp = (merged_options [i].argKind == XrmoptionSepArg); | 420 | Bool argp = (merged_options [i].argKind == XrmoptionSepArg); |
422 | int size = strlen (sw) + (argp ? 6 : 0) + 2; | 421 | int size = strlen (sw) + (argp ? 6 : 0) + 2; |
423 | if (x + size >= end) | 422 | if (x + size >= end) |
424 | { | 423 | { |
425 | fprintf (stderr, "\n\t\t "); | 424 | fprintf (stderr, "\n\t\t "); |
426 | x = 18; | 425 | x = 18; |
427 | } | 426 | } |
428 | x += size; | 427 | x += size; |
429 | fprintf (stderr, "%s", sw); | 428 | fprintf (stderr, "%s", sw); |
430 | if (argp) fprintf (stderr, " <arg>"); | 429 | if (argp) fprintf (stderr, " <arg>"); |
431 | if (i != merged_options_size - 1) fprintf (stderr, ", "); | 430 | if (i != merged_options_size - 1) fprintf (stderr, ", "); |
432 | } | 431 | } |
433 | fprintf (stderr, ".\n"); | 432 | fprintf (stderr, ".\n"); |
434 | exit (help_p ? 0 : 1); | 433 | exit (help_p ? 0 : 1); |
435 | } | 434 | } |
436 | 435 | ||
437 | dont_clear = get_boolean_resource ("dontClearRoot", "Boolean"); | 436 | dont_clear = get_boolean_resource ("dontClearRoot", "Boolean"); |
438 | /*dont_map = get_boolean_resource ("dontMapWindow", "Boolean"); */ | 437 | /*dont_map = get_boolean_resource ("dontMapWindow", "Boolean"); */ |
439 | mono_p = get_boolean_resource ("mono", "Boolean"); | 438 | mono_p = get_boolean_resource ("mono", "Boolean"); |
440 | if (CellsOfScreen (DefaultScreenOfDisplay (dpy)) <= 2) | 439 | if (CellsOfScreen (DefaultScreenOfDisplay (dpy)) <= 2) |
441 | mono_p = True; | 440 | mono_p = True; |
442 | 441 | ||
443 | root_p = get_boolean_resource ("root", "Boolean"); | 442 | root_p = get_boolean_resource ("root", "Boolean"); |
444 | 443 | ||
445 | { | 444 | { |
446 | char *s = get_string_resource ("windowID", "WindowID"); | 445 | char *s = get_string_resource ("windowID", "WindowID"); |
447 | if (s && *s) | 446 | if (s && *s) |
448 | on_window = get_integer_resource ("windowID", "WindowID"); | 447 | on_window = get_integer_resource ("windowID", "WindowID"); |
449 | if (s) free (s); | 448 | if (s) free (s); |
450 | } | 449 | } |
451 | 450 | ||
452 | if (on_window) | 451 | if (on_window) |
453 | { | 452 | { |
454 | XWindowAttributes xgwa; | 453 | XWindowAttributes xgwa; |
455 | window = (Window) on_window; | 454 | window = (Window) on_window; |
456 | XtDestroyWidget (toplevel); | 455 | XtDestroyWidget (toplevel); |
457 | XGetWindowAttributes (dpy, window, &xgwa); | 456 | XGetWindowAttributes (dpy, window, &xgwa); |
458 | cmap = xgwa.colormap; | 457 | cmap = xgwa.colormap; |
459 | visual = xgwa.visual; | 458 | visual = xgwa.visual; |
460 | visual_warning (screen, window, visual, cmap, True); | 459 | visual_warning (screen, window, visual, cmap, True); |
461 | } | 460 | } |
462 | else if (root_p) | 461 | else if (root_p) |
463 | { | 462 | { |
464 | XWindowAttributes xgwa; | 463 | XWindowAttributes xgwa; |
465 | window = RootWindowOfScreen (XtScreen (toplevel)); | 464 | window = RootWindowOfScreen (XtScreen (toplevel)); |
466 | XtDestroyWidget (toplevel); | 465 | XtDestroyWidget (toplevel); |
467 | XGetWindowAttributes (dpy, window, &xgwa); | 466 | XGetWindowAttributes (dpy, window, &xgwa); |
468 | cmap = xgwa.colormap; | 467 | cmap = xgwa.colormap; |
469 | visual = xgwa.visual; | 468 | visual = xgwa.visual; |
470 | visual_warning (screen, window, visual, cmap, False); | 469 | visual_warning (screen, window, visual, cmap, False); |
471 | } | 470 | } |
472 | else | 471 | else |
473 | { | 472 | { |
474 | Boolean def_visual_p; | 473 | Boolean def_visual_p; |
475 | visual = pick_visual (screen); | 474 | visual = pick_visual (screen); |
476 | 475 | ||
477 | if (toplevel->core.width <= 0) | 476 | if (toplevel->core.width <= 0) |
478 | toplevel->core.width = 600; | 477 | toplevel->core.width = 600; |
479 | if (toplevel->core.height <= 0) | 478 | if (toplevel->core.height <= 0) |
480 | toplevel->core.height = 480; | 479 | toplevel->core.height = 480; |
481 | 480 | ||
482 | def_visual_p = (visual == DefaultVisualOfScreen (screen)); | 481 | def_visual_p = (visual == DefaultVisualOfScreen (screen)); |
483 | 482 | ||
484 | if (!def_visual_p) | 483 | if (!def_visual_p) |
485 | { | 484 | { |
486 | unsigned int bg, bd; | 485 | unsigned int bg, bd; |
487 | Widget new; | 486 | Widget new; |
488 | 487 | ||
489 | cmap = XCreateColormap (dpy, RootWindowOfScreen(screen), | 488 | cmap = XCreateColormap (dpy, RootWindowOfScreen(screen), |
490 | visual, AllocNone); | 489 | visual, AllocNone); |
491 | bg = get_pixel_resource ("background", "Background", dpy, cmap); | 490 | bg = get_pixel_resource ("background", "Background", dpy, cmap); |
492 | bd = get_pixel_resource ("borderColor", "Foreground", dpy, cmap); | 491 | bd = get_pixel_resource ("borderColor", "Foreground", dpy, cmap); |
493 | 492 | ||
494 | new = XtVaAppCreateShell (progname, progclass, | 493 | new = XtVaAppCreateShell (progname, progclass, |
495 | topLevelShellWidgetClass, dpy, | 494 | topLevelShellWidgetClass, dpy, |
496 | XtNmappedWhenManaged, False, | 495 | XtNmappedWhenManaged, False, |
497 | XtNvisual, visual, | 496 | XtNvisual, visual, |
498 | XtNdepth, visual_depth (screen, visual), | 497 | XtNdepth, visual_depth (screen, visual), |
499 | XtNwidth, toplevel->core.width, | 498 | XtNwidth, toplevel->core.width, |
500 | XtNheight, toplevel->core.height, | 499 | XtNheight, toplevel->core.height, |
501 | XtNcolormap, cmap, | 500 | XtNcolormap, cmap, |
502 | XtNbackground, (Pixel) bg, | 501 | XtNbackground, (Pixel) bg, |
503 | XtNborderColor, (Pixel) bd, | 502 | XtNborderColor, (Pixel) bd, |
504 | XtNinput, True, /* for WM_HINTS */ | 503 | XtNinput, True, /* for WM_HINTS */ |
505 | 0); | 504 | 0); |
506 | XtDestroyWidget (toplevel); | 505 | XtDestroyWidget (toplevel); |
507 | toplevel = new; | 506 | toplevel = new; |
508 | XtRealizeWidget (toplevel); | 507 | XtRealizeWidget (toplevel); |
509 | window = XtWindow (toplevel); | 508 | window = XtWindow (toplevel); |
510 | } | 509 | } |
511 | else | 510 | else |
512 | { | 511 | { |
513 | XtVaSetValues (toplevel, | 512 | XtVaSetValues (toplevel, |
514 | XtNmappedWhenManaged, False, | 513 | XtNmappedWhenManaged, False, |
515 | XtNinput, True, /* for WM_HINTS */ | 514 | XtNinput, True, /* for WM_HINTS */ |
516 | 0); | 515 | 0); |
517 | XtRealizeWidget (toplevel); | 516 | XtRealizeWidget (toplevel); |
518 | window = XtWindow (toplevel); | 517 | window = XtWindow (toplevel); |
519 | 518 | ||
520 | if (get_boolean_resource ("installColormap", "InstallColormap")) | 519 | if (get_boolean_resource ("installColormap", "InstallColormap")) |
521 | { | 520 | { |
522 | cmap = XCreateColormap (dpy, window, | 521 | cmap = XCreateColormap (dpy, window, |
523 | DefaultVisualOfScreen (XtScreen (toplevel)), | 522 | DefaultVisualOfScreen (XtScreen |
524 | AllocNone); | 523 | (toplevel)), |
525 | XSetWindowColormap (dpy, window, cmap); | 524 | AllocNone); |
526 | } | 525 | XSetWindowColormap (dpy, window, cmap); |
527 | else | 526 | } |
528 | { | 527 | else |
529 | cmap = DefaultColormap (dpy, DefaultScreen (dpy)); | 528 | { |
530 | } | 529 | cmap = DefaultColormap (dpy, DefaultScreen (dpy)); |
531 | } | 530 | } |
531 | } | ||
532 | 532 | ||
533 | /* | 533 | /* |
534 | if (dont_map) | 534 | if (dont_map) |
535 | { | 535 | { |
536 | XtVaSetValues (toplevel, XtNmappedWhenManaged, False, 0); | 536 | XtVaSetValues (toplevel, XtNmappedWhenManaged, False, 0); |
537 | XtRealizeWidget (toplevel); | 537 | XtRealizeWidget (toplevel); |
538 | } | 538 | } |
539 | else | 539 | else |
540 | */ | 540 | */ |
541 | { | 541 | { |
542 | XtPopup (toplevel, XtGrabNone); | 542 | XtPopup (toplevel, XtGrabNone); |
543 | } | 543 | } |
544 | 544 | ||
545 | XtVaSetValues(toplevel, XtNtitle, version, 0); | 545 | XtVaSetValues(toplevel, XtNtitle, version, 0); |
546 | 546 | ||
547 | /* For screenhack_handle_events(): select KeyPress, and | 547 | /* For screenhack_handle_events(): select KeyPress, and |
548 | announce that we accept WM_DELETE_WINDOW. */ | 548 | announce that we accept WM_DELETE_WINDOW. */ |
549 | { | 549 | { |
550 | XWindowAttributes xgwa; | 550 | XWindowAttributes xgwa; |
551 | XGetWindowAttributes (dpy, window, &xgwa); | 551 | XGetWindowAttributes (dpy, window, &xgwa); |
552 | XSelectInput (dpy, window, | 552 | XSelectInput (dpy, window, |
553 | xgwa.your_event_mask | KeyPressMask | ButtonPressMask | ResizeRedirectMask | ExposureMask); | 553 | xgwa.your_event_mask | KeyPressMask | |
554 | XChangeProperty (dpy, window, XA_WM_PROTOCOLS, XA_ATOM, 32, | 554 | ButtonPressMask | ResizeRedirectMask | ExposureMask); |
555 | PropModeReplace, | 555 | XChangeProperty (dpy, window, XA_WM_PROTOCOLS, XA_ATOM, 32, |
556 | (unsigned char *) &XA_WM_DELETE_WINDOW, 1); | 556 | PropModeReplace, |
557 | } | 557 | (unsigned char *) &XA_WM_DELETE_WINDOW, 1); |
558 | } | ||
558 | } | 559 | } |
559 | 560 | ||
560 | if (!dont_clear) | 561 | if (!dont_clear) |
561 | { | 562 | { |
562 | XSetWindowBackground (dpy, window, | 563 | XSetWindowBackground (dpy, window, |
563 | get_pixel_resource ("background", "Background", | 564 | get_pixel_resource ("background", "Background", |
564 | dpy, cmap)); | 565 | dpy, cmap)); |
565 | XClearWindow (dpy, window); | 566 | XClearWindow (dpy, window); |
566 | } | 567 | } |
567 | 568 | ||
568 | if (!root_p && !on_window) | 569 | if (!root_p && !on_window) |
569 | /* wait for it to be mapped */ | 570 | /* wait for it to be mapped */ |
570 | XIfEvent (dpy, &event, MapNotify_event_p, (XPointer) window); | 571 | XIfEvent (dpy, &event, MapNotify_event_p, (XPointer) window); |
571 | 572 | ||
572 | XSync (dpy, False); | 573 | XSync (dpy, False); |
573 | 574 | ||
574 | screenhack (dpy, window); /* doesn't return */ | 575 | screenhack (dpy, window); /* doesn't return */ |
575 | return 0; | 576 | return 0; |
576 | } | 577 | } |