?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
create_stdcmap is never used
[wmaker-crm.git] / src / screen.c
blobecdb4983266ba83ae0ca7e05915efda3dc90c2d9
1 /* screen.c - screen management
2 *
3 * Window Maker window manager
4 *
5 * Copyright (c) 1997-2003 Alfredo K. Kojima
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License along
18 * with this program; if not, write to the Free Software Foundation, Inc.,
19 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
20 */
21
22 #include "wconfig.h"
23
24 #include <stdio.h>
25 #include <stdlib.h>
26 #include <string.h>
27
28 #include <X11/Xlib.h>
29 #include <X11/Xutil.h>
30 #include <X11/Xatom.h>
31 #ifdef SHAPE
32 #include <X11/extensions/shape.h>
33 #endif
34 #ifdef KEEP_XKB_LOCK_STATUS
35 #include <X11/XKBlib.h>
36 #endif /* KEEP_XKB_LOCK_STATUS */
37 #ifdef HAVE_XRANDR
38 #include <X11/extensions/Xrandr.h>
39 #endif
40
41 #include <wraster.h>
42 #include "WindowMaker.h"
43 #include "def_pixmaps.h"
44 #include "screen.h"
45 #include "texture.h"
46 #include "pixmap.h"
47 #include "menu.h"
48 #include "funcs.h"
49 #include "main.h"
50 #include "actions.h"
51 #include "properties.h"
52 #include "dock.h"
53 #include "resources.h"
54 #include "workspace.h"
55 #include "session.h"
56 #include "balloon.h"
57 #include "geomview.h"
58 #include "wmspec.h"
59 #include "rootmenu.h"
60
61 #include "xinerama.h"
62
63 #include <WINGs/WUtil.h>
64
65 #include "defaults.h"
66
67 #define EVENT_MASK (LeaveWindowMask|EnterWindowMask|PropertyChangeMask\
68 |SubstructureNotifyMask|PointerMotionMask \
69 |SubstructureRedirectMask|ButtonPressMask|ButtonReleaseMask\
70 |KeyPressMask|KeyReleaseMask)
71
72 /**** Global variables ****/
73 extern Cursor wCursor[WCUR_LAST];
74 extern WPreferences wPreferences;
75 extern Atom _XA_WINDOWMAKER_STATE;
76 extern Atom _XA_WINDOWMAKER_NOTICEBOARD;
77
78 extern int wScreenCount;
79
80 #ifdef KEEP_XKB_LOCK_STATUS
81 extern int wXkbSupported;
82 #endif
83 #ifdef HAVE_XRANDR
84 extern int has_randr;
85 #endif
86
87 extern WDDomain *WDWindowMaker;
88
89 /**** Local ****/
90 #define STIPPLE_WIDTH 2
91 #define STIPPLE_HEIGHT 2
92 static char STIPPLE_DATA[] = { 0x02, 0x01 };
93
94 static int CantManageScreen = 0;
95
96 static WMPropList *dApplications = NULL;
97 static WMPropList *dWorkspace;
98 static WMPropList *dDock;
99 static WMPropList *dClip;
100
101 static void make_keys(void)
102 {
103 if (dApplications != NULL)
104 return;
105
106 dApplications = WMCreatePLString("Applications");
107 dWorkspace = WMCreatePLString("Workspace");
108 dDock = WMCreatePLString("Dock");
109 dClip = WMCreatePLString("Clip");
110 }
111
112 /*
113 *----------------------------------------------------------------------
114 * alreadyRunningError--
115 * X error handler used to catch errors when trying to do
116 * XSelectInput() on the root window. These errors probably mean that
117 * there already is some other window manager running.
118 *
119 * Returns:
120 * Nothing, unless something really evil happens...
121 *
122 * Side effects:
123 * CantManageScreen is set to 1;
124 *----------------------------------------------------------------------
125 */
126 static int alreadyRunningError(Display * dpy, XErrorEvent * error)
127 {
128 CantManageScreen = 1;
129 return -1;
130 }
131
132 /*
133 *----------------------------------------------------------------------
134 * allocButtonPixmaps--
135 * Allocate pixmaps used on window operation buttons (those in the
136 * titlebar). The pixmaps are linked to the program. If XPM is supported
137 * XPM pixmaps are used otherwise, equivalent bitmaps are used.
138 *
139 * Returns:
140 * Nothing
141 *
142 * Side effects:
143 * Allocates shared pixmaps for the screen. These pixmaps should
144 * not be freed by anybody.
145 *----------------------------------------------------------------------
146 */
147 static void allocButtonPixmaps(WScreen * scr)
148 {
149 WPixmap *pix;
150
151 /* create predefined pixmaps */
152 if (wPreferences.new_style == TS_NEXT) {
153 pix = wPixmapCreateFromXPMData(scr, NEXT_CLOSE_XPM);
154 } else {
155 pix = wPixmapCreateFromXPMData(scr, PRED_CLOSE_XPM);
156 }
157 if (pix)
158 pix->shared = 1;
159 scr->b_pixmaps[WBUT_CLOSE] = pix;
160
161 if (wPreferences.new_style == TS_NEXT) {
162 pix = wPixmapCreateFromXPMData(scr, NEXT_BROKEN_CLOSE_XPM);
163 } else {
164 pix = wPixmapCreateFromXPMData(scr, PRED_BROKEN_CLOSE_XPM);
165 }
166 if (pix)
167 pix->shared = 1;
168 scr->b_pixmaps[WBUT_BROKENCLOSE] = pix;
169
170 if (wPreferences.new_style == TS_NEXT) {
171 pix = wPixmapCreateFromXPMData(scr, NEXT_ICONIFY_XPM);
172 } else {
173 pix = wPixmapCreateFromXPMData(scr, PRED_ICONIFY_XPM);
174 }
175 if (pix)
176 pix->shared = 1;
177 scr->b_pixmaps[WBUT_ICONIFY] = pix;
178 #ifdef XKB_BUTTON_HINT
179 if (wPreferences.new_style == TS_NEXT) {
180 pix = wPixmapCreateFromXPMData(scr, NEXT_XKBGROUP1_XPM);
181 } else {
182 pix = wPixmapCreateFromXPMData(scr, PRED_XKBGROUP1_XPM);
183 }
184 if (pix)
185 pix->shared = 1;
186 scr->b_pixmaps[WBUT_XKBGROUP1] = pix;
187 if (wPreferences.new_style == TS_NEXT) {
188 pix = wPixmapCreateFromXPMData(scr, NEXT_XKBGROUP2_XPM);
189 } else {
190 pix = wPixmapCreateFromXPMData(scr, PRED_XKBGROUP2_XPM);
191 }
192 if (pix)
193 pix->shared = 1;
194 scr->b_pixmaps[WBUT_XKBGROUP2] = pix;
195 if (wPreferences.new_style == TS_NEXT) {
196 pix = wPixmapCreateFromXPMData(scr, NEXT_XKBGROUP3_XPM);
197 } else {
198 pix = wPixmapCreateFromXPMData(scr, PRED_XKBGROUP3_XPM);
199 }
200 if (pix)
201 pix->shared = 1;
202 scr->b_pixmaps[WBUT_XKBGROUP3] = pix;
203 if (wPreferences.new_style == TS_NEXT) {
204 pix = wPixmapCreateFromXPMData(scr, NEXT_XKBGROUP4_XPM);
205 } else {
206 pix = wPixmapCreateFromXPMData(scr, PRED_XKBGROUP4_XPM);
207 }
208 if (pix)
209 pix->shared = 1;
210 scr->b_pixmaps[WBUT_XKBGROUP4] = pix;
211 #endif
212
213 if (wPreferences.new_style == TS_NEXT) {
214 pix = wPixmapCreateFromXPMData(scr, NEXT_KILL_XPM);
215 } else {
216 pix = wPixmapCreateFromXPMData(scr, PRED_KILL_XPM);
217 }
218 if (pix)
219 pix->shared = 1;
220 scr->b_pixmaps[WBUT_KILL] = pix;
221 }
222
223 static void draw_dot(WScreen * scr, Drawable d, int x, int y, GC gc)
224 {
225 XSetForeground(dpy, gc, scr->black_pixel);
226 XDrawLine(dpy, d, gc, x, y, x + 1, y);
227 XDrawPoint(dpy, d, gc, x, y + 1);
228 XSetForeground(dpy, gc, scr->white_pixel);
229 XDrawLine(dpy, d, gc, x + 2, y, x + 2, y + 1);
230 XDrawPoint(dpy, d, gc, x + 1, y + 1);
231 }
232
233 static WPixmap *make3Dots(WScreen * scr)
234 {
235 WPixmap *wpix;
236 GC gc2, gc;
237 XGCValues gcv;
238 Pixmap pix, mask;
239
240 gc = scr->copy_gc;
241 pix = XCreatePixmap(dpy, scr->w_win, wPreferences.icon_size, wPreferences.icon_size, scr->w_depth);
242 XSetForeground(dpy, gc, scr->black_pixel);
243 XFillRectangle(dpy, pix, gc, 0, 0, wPreferences.icon_size, wPreferences.icon_size);
244 XSetForeground(dpy, gc, scr->white_pixel);
245 draw_dot(scr, pix, 4, wPreferences.icon_size - 6, gc);
246 draw_dot(scr, pix, 9, wPreferences.icon_size - 6, gc);
247 draw_dot(scr, pix, 14, wPreferences.icon_size - 6, gc);
248
249 mask = XCreatePixmap(dpy, scr->w_win, wPreferences.icon_size, wPreferences.icon_size, 1);
250 gcv.foreground = 0;
251 gcv.graphics_exposures = False;
252 gc2 = XCreateGC(dpy, mask, GCForeground | GCGraphicsExposures, &gcv);
253 XFillRectangle(dpy, mask, gc2, 0, 0, wPreferences.icon_size, wPreferences.icon_size);
254 XSetForeground(dpy, gc2, 1);
255 XFillRectangle(dpy, mask, gc2, 4, wPreferences.icon_size - 6, 3, 2);
256 XFillRectangle(dpy, mask, gc2, 9, wPreferences.icon_size - 6, 3, 2);
257 XFillRectangle(dpy, mask, gc2, 14, wPreferences.icon_size - 6, 3, 2);
258
259 XFreeGC(dpy, gc2);
260
261 wpix = wPixmapCreate(scr, pix, mask);
262 wpix->shared = 1;
263
264 return wpix;
265 }
266
267 static void allocGCs(WScreen * scr)
268 {
269 XGCValues gcv;
270 XColor color;
271 int gcm;
272
273 scr->stipple_bitmap = XCreateBitmapFromData(dpy, scr->w_win, STIPPLE_DATA, STIPPLE_WIDTH, STIPPLE_HEIGHT);
274
275 gcv.stipple = scr->stipple_bitmap;
276 gcv.foreground = scr->white_pixel;
277 gcv.fill_style = FillStippled;
278 gcv.graphics_exposures = False;
279 gcm = GCForeground | GCStipple | GCFillStyle | GCGraphicsExposures;
280 scr->stipple_gc = XCreateGC(dpy, scr->w_win, gcm, &gcv);
281
282 /* selected icon border GCs */
283 gcv.function = GXcopy;
284 gcv.foreground = scr->white_pixel;
285 gcv.background = scr->black_pixel;
286 gcv.line_width = 1;
287 gcv.line_style = LineDoubleDash;
288 gcv.fill_style = FillSolid;
289 gcv.dash_offset = 0;
290 gcv.dashes = 4;
291 gcv.graphics_exposures = False;
292
293 gcm = GCFunction | GCGraphicsExposures;
294 gcm |= GCForeground | GCBackground;
295 gcm |= GCLineWidth | GCLineStyle;
296 gcm |= GCFillStyle;
297 gcm |= GCDashOffset | GCDashList;
298
299 scr->icon_select_gc = XCreateGC(dpy, scr->w_win, gcm, &gcv);
300
301 scr->menu_title_color[0] = WMRetainColor(scr->white);
302
303 /* don't retain scr->black here because we may alter its alpha */
304 scr->mtext_color = WMCreateRGBColor(scr->wmscreen, 0, 0, 0, True);
305 scr->dtext_color = WMCreateRGBColor(scr->wmscreen, 0, 0, 0, True);
306
307 /* frame GC */
308 wGetColor(scr, DEF_FRAME_COLOR, &color);
309 gcv.function = GXxor;
310 /* this will raise the probability of the XORed color being different
311 * of the original color in PseudoColor when not all color cells are
312 * initialized */
313 if (DefaultVisual(dpy, scr->screen)->class == PseudoColor)
314 gcv.plane_mask = (1 << (scr->depth - 1)) | 1;
315 else
316 gcv.plane_mask = AllPlanes;
317 gcv.foreground = color.pixel;
318 if (gcv.foreground == 0)
319 gcv.foreground = 1;
320 gcv.line_width = DEF_FRAME_THICKNESS;
321 gcv.subwindow_mode = IncludeInferiors;
322 gcv.graphics_exposures = False;
323 scr->frame_gc = XCreateGC(dpy, scr->root_win, GCForeground | GCGraphicsExposures
324 | GCFunction | GCSubwindowMode | GCLineWidth | GCPlaneMask, &gcv);
325
326 /* line GC */
327 gcv.foreground = color.pixel;
328
329 if (gcv.foreground == 0)
330 /* XOR:ing with a zero is not going to be of much use, so
331 in that case, we somewhat arbitrarily xor with 17 instead. */
332 gcv.foreground = 17;
333
334 gcv.function = GXxor;
335 gcv.subwindow_mode = IncludeInferiors;
336 gcv.line_width = 1;
337 gcv.cap_style = CapRound;
338 gcv.graphics_exposures = False;
339 gcm = GCForeground | GCFunction | GCSubwindowMode | GCLineWidth | GCCapStyle | GCGraphicsExposures;
340 scr->line_gc = XCreateGC(dpy, scr->root_win, gcm, &gcv);
341
342 scr->line_pixel = gcv.foreground;
343
344 /* copy GC */
345 gcv.foreground = scr->white_pixel;
346 gcv.background = scr->black_pixel;
347 gcv.graphics_exposures = False;
348 scr->copy_gc = XCreateGC(dpy, scr->w_win, GCForeground | GCBackground | GCGraphicsExposures, &gcv);
349
350 /* misc drawing GC */
351 gcv.graphics_exposures = False;
352 gcm = GCGraphicsExposures;
353 scr->draw_gc = XCreateGC(dpy, scr->w_win, gcm, &gcv);
354
355 assert(scr->stipple_bitmap != None);
356
357 /* mono GC */
358 scr->mono_gc = XCreateGC(dpy, scr->stipple_bitmap, gcm, &gcv);
359 }
360
361 static void createPixmaps(WScreen * scr)
362 {
363 WPixmap *pix;
364
365 /* load pixmaps */
366 pix = wPixmapCreateFromXBMData(scr, (char *)MENU_RADIO_INDICATOR_XBM_DATA,
367 (char *)MENU_RADIO_INDICATOR_XBM_DATA,
368 MENU_RADIO_INDICATOR_XBM_SIZE,
369 MENU_RADIO_INDICATOR_XBM_SIZE, scr->black_pixel, scr->white_pixel);
370 if (pix != NULL)
371 pix->shared = 1;
372 scr->menu_radio_indicator = pix;
373
374 pix = wPixmapCreateFromXBMData(scr, (char *)MENU_CHECK_INDICATOR_XBM_DATA,
375 (char *)MENU_CHECK_INDICATOR_XBM_DATA,
376 MENU_CHECK_INDICATOR_XBM_SIZE,
377 MENU_CHECK_INDICATOR_XBM_SIZE, scr->black_pixel, scr->white_pixel);
378 if (pix != NULL)
379 pix->shared = 1;
380 scr->menu_check_indicator = pix;
381
382 pix = wPixmapCreateFromXBMData(scr, (char *)MENU_MINI_INDICATOR_XBM_DATA,
383 (char *)MENU_MINI_INDICATOR_XBM_DATA,
384 MENU_MINI_INDICATOR_XBM_SIZE,
385 MENU_MINI_INDICATOR_XBM_SIZE, scr->black_pixel, scr->white_pixel);
386 if (pix != NULL)
387 pix->shared = 1;
388 scr->menu_mini_indicator = pix;
389
390 pix = wPixmapCreateFromXBMData(scr, (char *)MENU_HIDE_INDICATOR_XBM_DATA,
391 (char *)MENU_HIDE_INDICATOR_XBM_DATA,
392 MENU_HIDE_INDICATOR_XBM_SIZE,
393 MENU_HIDE_INDICATOR_XBM_SIZE, scr->black_pixel, scr->white_pixel);
394 if (pix != NULL)
395 pix->shared = 1;
396 scr->menu_hide_indicator = pix;
397
398 pix = wPixmapCreateFromXBMData(scr, (char *)MENU_SHADE_INDICATOR_XBM_DATA,
399 (char *)MENU_SHADE_INDICATOR_XBM_DATA,
400 MENU_SHADE_INDICATOR_XBM_SIZE,
401 MENU_SHADE_INDICATOR_XBM_SIZE, scr->black_pixel, scr->white_pixel);
402 if (pix != NULL)
403 pix->shared = 1;
404 scr->menu_shade_indicator = pix;
405
406 create_logo_image(scr);
407
408 scr->dock_dots = make3Dots(scr);
409
410 /* titlebar button pixmaps */
411 allocButtonPixmaps(scr);
412 }
413
414 void create_logo_image(WScreen *scr)
415 {
416 RImage *image = get_icon_image(scr, "Logo", "WMPanel", wPreferences.icon_size);
417
418 if (!image) {
419 wwarning(_("could not load logo image for panels: %s"), RMessageForError(RErrorCode));
420 } else {
421 WMSetApplicationIconImage(scr->wmscreen, image);
422 RReleaseImage(image);
423 }
424 }
425
426 /*
427 *----------------------------------------------------------------------
428 * createInternalWindows--
429 * Creates some windows used internally by the program. One to
430 * receive input focus when no other window can get it and another
431 * to display window geometry information during window resize/move.
432 *
433 * Returns:
434 * Nothing
435 *
436 * Side effects:
437 * Windows are created and some colors are allocated for the
438 * window background.
439 *----------------------------------------------------------------------
440 */
441 static void createInternalWindows(WScreen * scr)
442 {
443 int vmask;
444 XSetWindowAttributes attribs;
445
446 /* InputOnly window to get the focus when no other window can get it */
447 vmask = CWEventMask | CWOverrideRedirect;
448 attribs.event_mask = KeyPressMask | FocusChangeMask;
449 attribs.override_redirect = True;
450 scr->no_focus_win = XCreateWindow(dpy, scr->root_win, -10, -10, 4, 4, 0, 0,
451 InputOnly, CopyFromParent, vmask, &attribs);
452 XSelectInput(dpy, scr->no_focus_win, KeyPressMask | KeyReleaseMask);
453 XMapWindow(dpy, scr->no_focus_win);
454
455 XSetInputFocus(dpy, scr->no_focus_win, RevertToParent, CurrentTime);
456
457 /* shadow window for dock buttons */
458 vmask = CWBorderPixel | CWBackPixmap | CWBackPixel | CWCursor | CWSaveUnder | CWOverrideRedirect;
459 attribs.border_pixel = scr->black_pixel;
460 attribs.save_under = True;
461 attribs.override_redirect = True;
462 attribs.background_pixmap = None;
463 attribs.background_pixel = scr->white_pixel;
464 attribs.cursor = wCursor[WCUR_DEFAULT];
465 vmask |= CWColormap;
466 attribs.colormap = scr->w_colormap;
467 scr->dock_shadow =
468 XCreateWindow(dpy, scr->root_win, 0, 0, wPreferences.icon_size,
469 wPreferences.icon_size, 0, scr->w_depth, CopyFromParent, scr->w_visual, vmask, &attribs);
470
471 /* workspace name balloon for clip */
472 vmask = CWBackPixel | CWSaveUnder | CWOverrideRedirect | CWColormap | CWBorderPixel;
473 attribs.save_under = True;
474 attribs.override_redirect = True;
475 attribs.colormap = scr->w_colormap;
476 attribs.background_pixel = scr->icon_back_texture->normal.pixel;
477 attribs.border_pixel = 0; /* do not care */
478 scr->clip_balloon =
479 XCreateWindow(dpy, scr->root_win, 0, 0, 10, 10, 0, scr->w_depth,
480 CopyFromParent, scr->w_visual, vmask, &attribs);
481
482 /* workspace name */
483 vmask = CWBackPixel | CWSaveUnder | CWOverrideRedirect | CWColormap | CWBorderPixel;
484 attribs.save_under = True;
485 attribs.override_redirect = True;
486 attribs.colormap = scr->w_colormap;
487 attribs.background_pixel = scr->icon_back_texture->normal.pixel;
488 attribs.border_pixel = 0; /* do not care */
489 scr->workspace_name =
490 XCreateWindow(dpy, scr->root_win, 0, 0, 10, 10, 0, scr->w_depth,
491 CopyFromParent, scr->w_visual, vmask, &attribs);
492
493 /*
494 * If the window is clicked without having ButtonPress selected, the
495 * resulting event will have event.xbutton.window == root.
496 */
497 XSelectInput(dpy, scr->clip_balloon, ButtonPressMask);
498 }
499
500 /*
501 *----------------------------------------------------------------------
502 * wScreenInit--
503 * Initializes the window manager for the given screen and
504 * allocates a WScreen descriptor for it. Many resources are allocated
505 * for the screen and the root window is setup appropriately.
506 *
507 * Returns:
508 * The WScreen descriptor for the screen.
509 *
510 * Side effects:
511 * Many resources are allocated and the IconSize property is
512 * set on the root window.
513 * The program can be aborted if some fatal error occurs.
514 *
515 * TODO: User specifiable visual.
516 *----------------------------------------------------------------------
517 */
518 WScreen *wScreenInit(int screen_number)
519 {
520 WScreen *scr;
521 XIconSize icon_size[1];
522 RContextAttributes rattr;
523 long event_mask;
524 XErrorHandler oldHandler;
525 int i;
526
527 scr = wmalloc(sizeof(WScreen));
528
529 scr->stacking_list = WMCreateTreeBag();
530
531 /* initialize globals */
532 scr->screen = screen_number;
533 scr->root_win = RootWindow(dpy, screen_number);
534 scr->depth = DefaultDepth(dpy, screen_number);
535 scr->colormap = DefaultColormap(dpy, screen_number);
536
537 scr->scr_width = WidthOfScreen(ScreenOfDisplay(dpy, screen_number));
538 scr->scr_height = HeightOfScreen(ScreenOfDisplay(dpy, screen_number));
539
540 wInitXinerama(scr);
541
542 scr->usableArea = (WArea *) wmalloc(sizeof(WArea) * wXineramaHeads(scr));
543 scr->totalUsableArea = (WArea *) wmalloc(sizeof(WArea) * wXineramaHeads(scr));
544
545 for (i = 0; i < wXineramaHeads(scr); ++i) {
546 WMRect rect = wGetRectForHead(scr, i);
547 scr->usableArea[i].x1 = scr->totalUsableArea[i].x1 = rect.pos.x;
548 scr->usableArea[i].y1 = scr->totalUsableArea[i].y1 = rect.pos.y;
549 scr->usableArea[i].x2 = scr->totalUsableArea[i].x2 = rect.pos.x + rect.size.width;
550 scr->usableArea[i].y2 = scr->totalUsableArea[i].y2 = rect.pos.y + rect.size.height;
551 }
552
553 scr->fakeGroupLeaders = WMCreateArray(16);
554
555 CantManageScreen = 0;
556 oldHandler = XSetErrorHandler((XErrorHandler) alreadyRunningError);
557
558 event_mask = EVENT_MASK;
559
560 if (wPreferences.disable_root_mouse) {
561 event_mask &= ~(ButtonPressMask | ButtonReleaseMask);
562 }
563
564 XSelectInput(dpy, scr->root_win, event_mask);
565
566 #ifdef KEEP_XKB_LOCK_STATUS
567 /* Only GroupLock doesn't work correctly in my system since right-alt
568 * can change mode while holding it too - ]d
569 */
570 if (wXkbSupported) {
571 XkbSelectEvents(dpy, XkbUseCoreKbd, XkbStateNotifyMask, XkbStateNotifyMask);
572 }
573 #endif /* KEEP_XKB_LOCK_STATUS */
574
575 #ifdef HAVE_XRANDR
576 if (has_randr)
577 XRRSelectInput(dpy, scr->root_win, RRScreenChangeNotifyMask);
578 #endif
579
580 XSync(dpy, False);
581 XSetErrorHandler(oldHandler);
582
583 if (CantManageScreen) {
584 wfree(scr);
585 return NULL;
586 }
587
588 XDefineCursor(dpy, scr->root_win, wCursor[WCUR_ROOT]);
589
590 /* screen descriptor for raster graphic library */
591 rattr.flags = RC_RenderMode | RC_ColorsPerChannel | RC_StandardColormap;
592 rattr.render_mode = wPreferences.no_dithering ? RBestMatchRendering : RDitheredRendering;
593
594 /* if the std colormap stuff works ok, this will be ignored */
595 rattr.colors_per_channel = wPreferences.cmap_size;
596 if (rattr.colors_per_channel < 2)
597 rattr.colors_per_channel = 2;
598
599 /* Use standard colormap */
600 rattr.standard_colormap_mode = RUseStdColormap;
601
602 if (getWVisualID(screen_number) >= 0) {
603 rattr.flags |= RC_VisualID;
604 rattr.visualid = getWVisualID(screen_number);
605 }
606
607 scr->rcontext = RCreateContext(dpy, screen_number, &rattr);
608
609 if (!scr->rcontext && RErrorCode == RERR_STDCMAPFAIL) {
610 wwarning("%s", RMessageForError(RErrorCode));
611
612 rattr.flags &= ~RC_StandardColormap;
613 rattr.standard_colormap_mode = RUseStdColormap;
614
615 scr->rcontext = RCreateContext(dpy, screen_number, &rattr);
616 }
617
618 if (!scr->rcontext) {
619 wwarning(_("could not initialize graphics library context: %s"), RMessageForError(RErrorCode));
620 wAbort(False);
621 } else {
622 char **formats;
623 int i = 0;
624
625 formats = RSupportedFileFormats();
626 if (formats) {
627 for (i = 0; formats[i] != NULL; i++) {
628 if (strcmp(formats[i], "TIFF") == 0) {
629 scr->flags.supports_tiff = 1;
630 break;
631 }
632 }
633 }
634 }
635
636 scr->w_win = scr->rcontext->drawable;
637 scr->w_visual = scr->rcontext->visual;
638 scr->w_depth = scr->rcontext->depth;
639 scr->w_colormap = scr->rcontext->cmap;
640
641 /* create screen descriptor for WINGs */
642 scr->wmscreen = WMCreateScreenWithRContext(dpy, screen_number, scr->rcontext);
643
644 if (!scr->wmscreen) {
645 wfatal(_("could not initialize WINGs widget set"));
646 return NULL;
647 }
648
649 scr->black = WMBlackColor(scr->wmscreen);
650 scr->white = WMWhiteColor(scr->wmscreen);
651 scr->gray = WMGrayColor(scr->wmscreen);
652 scr->darkGray = WMDarkGrayColor(scr->wmscreen);
653
654 scr->black_pixel = WMColorPixel(scr->black); /*scr->rcontext->black; */
655 scr->white_pixel = WMColorPixel(scr->white); /*scr->rcontext->white; */
656 scr->light_pixel = WMColorPixel(scr->gray);
657 scr->dark_pixel = WMColorPixel(scr->darkGray);
658
659 {
660 XColor xcol;
661 /* frame boder color */
662 wGetColor(scr, FRAME_BORDER_COLOR, &xcol);
663 scr->frame_border_pixel = xcol.pixel;
664 }
665
666 /* create GCs with default values */
667 allocGCs(scr);
668
669 /* for our window manager info notice board. Need to
670 * create before reading the defaults, because it will be used there.
671 */
672 scr->info_window = XCreateSimpleWindow(dpy, scr->root_win, 0, 0, 10, 10, 0, 0, 0);
673
674 /* read defaults for this screen */
675 wReadDefaults(scr, WDWindowMaker->dictionary);
676
677 createInternalWindows(scr);
678
679 wNETWMInitStuff(scr);
680
681 /* create initial workspace */
682 wWorkspaceNew(scr);
683
684 /* create shared pixmaps */
685 createPixmaps(scr);
686
687 /* set icon sizes we can accept from clients */
688 icon_size[0].min_width = 8;
689 icon_size[0].min_height = 8;
690 icon_size[0].max_width = wPreferences.icon_size - 4;
691 icon_size[0].max_height = wPreferences.icon_size - 4;
692 icon_size[0].width_inc = 1;
693 icon_size[0].height_inc = 1;
694 XSetIconSizes(dpy, scr->root_win, icon_size, 1);
695
696 /* setup WindowMaker protocols property in the root window */
697 PropSetWMakerProtocols(scr->root_win);
698
699 /* setup our noticeboard */
700 XChangeProperty(dpy, scr->info_window, _XA_WINDOWMAKER_NOTICEBOARD,
701 XA_WINDOW, 32, PropModeReplace, (unsigned char *)&scr->info_window, 1);
702 XChangeProperty(dpy, scr->root_win, _XA_WINDOWMAKER_NOTICEBOARD,
703 XA_WINDOW, 32, PropModeReplace, (unsigned char *)&scr->info_window, 1);
704
705 #ifdef BALLOON_TEXT
706 /* initialize balloon text stuff */
707 wBalloonInitialize(scr);
708 #endif
709
710 scr->info_text_font = WMBoldSystemFontOfSize(scr->wmscreen, 12);
711
712 scr->tech_draw_font = XLoadQueryFont(dpy, "-adobe-helvetica-bold-r-*-*-12-*-*-*-*-*-*-*");
713 if (!scr->tech_draw_font)
714 scr->tech_draw_font = XLoadQueryFont(dpy, "fixed");
715
716 scr->gview = WCreateGeometryView(scr->wmscreen);
717 WMRealizeWidget(scr->gview);
718
719 wScreenUpdateUsableArea(scr);
720
721 return scr;
722 }
723
724 void wScreenUpdateUsableArea(WScreen * scr)
725 {
726 /*
727 * scr->totalUsableArea[] will become the usableArea used for Windowplacement,
728 * scr->usableArea[] will be used for iconplacement, hence no iconyard nor
729 * border.
730 */
731
732 WArea area;
733 int i, dock_head;
734 unsigned long best_area, tmp_area;
735 unsigned int size, position;
736
737 dock_head = scr->xine_info.primary_head;
738 best_area = 0;
739 size = wPreferences.workspace_border_size;
740 position = wPreferences.workspace_border_position;
741
742 if (scr->dock) {
743 WMRect rect;
744 rect.pos.x = scr->dock->x_pos;
745 rect.pos.y = scr->dock->y_pos;
746 rect.size.width = wPreferences.icon_size;
747 rect.size.height = wPreferences.icon_size;
748 dock_head = wGetHeadForRect(scr, rect);
749 }
750
751 for (i = 0; i < wXineramaHeads(scr); ++i) {
752 WMRect rect = wGetRectForHead(scr, i);
753 scr->totalUsableArea[i].x1 = rect.pos.x;
754 scr->totalUsableArea[i].y1 = rect.pos.y;
755 scr->totalUsableArea[i].x2 = rect.pos.x + rect.size.width;
756 scr->totalUsableArea[i].y2 = rect.pos.y + rect.size.height;
757
758 if (scr->dock && dock_head == i && (!scr->dock->lowered || wPreferences.no_window_over_dock)) {
759 int offset = wPreferences.icon_size + DOCK_EXTRA_SPACE;
760
761 if (scr->dock->on_right_side) {
762 scr->totalUsableArea[i].x2 -= offset;
763 } else {
764 scr->totalUsableArea[i].x1 += offset;
765 }
766 }
767
768 if (wNETWMGetUsableArea(scr, i, &area)) {
769 scr->totalUsableArea[i].x1 = WMAX(scr->totalUsableArea[i].x1, area.x1);
770 scr->totalUsableArea[i].y1 = WMAX(scr->totalUsableArea[i].y1, area.y1);
771 scr->totalUsableArea[i].x2 = WMIN(scr->totalUsableArea[i].x2, area.x2);
772 scr->totalUsableArea[i].y2 = WMIN(scr->totalUsableArea[i].y2, area.y2);
773 }
774
775 scr->usableArea[i] = scr->totalUsableArea[i];
776
777 #if 0
778 printf("usableArea[%d]: %d %d %d %d\n", i,
779 scr->usableArea[i].x1, scr->usableArea[i].x2, scr->usableArea[i].y1, scr->usableArea[i].y2);
780 #endif
781 if (wPreferences.no_window_over_icons) {
782 if (wPreferences.icon_yard & IY_VERT) {
783 if (wPreferences.icon_yard & IY_RIGHT) {
784 scr->totalUsableArea[i].x2 -= wPreferences.icon_size;
785 } else {
786 scr->totalUsableArea[i].x1 += wPreferences.icon_size;
787 }
788 } else {
789 if (wPreferences.icon_yard & IY_TOP) {
790 scr->totalUsableArea[i].y1 += wPreferences.icon_size;
791 } else {
792 scr->totalUsableArea[i].y2 -= wPreferences.icon_size;
793 }
794 }
795 }
796
797 if (scr->totalUsableArea[i].x2 - scr->totalUsableArea[i].x1 < rect.size.width / 2) {
798 scr->totalUsableArea[i].x1 = rect.pos.x;
799 scr->totalUsableArea[i].x2 = rect.pos.x + rect.size.width;
800 }
801
802 if (scr->totalUsableArea[i].y2 - scr->totalUsableArea[i].y1 < rect.size.height / 2) {
803 scr->totalUsableArea[i].y1 = rect.pos.y;
804 scr->totalUsableArea[i].y2 = rect.pos.y + rect.size.height;
805 }
806
807 tmp_area = (scr->totalUsableArea[i].x2 - scr->totalUsableArea[i].x1) *
808 (scr->totalUsableArea[i].y2 - scr->totalUsableArea[i].y1);
809
810 if (tmp_area > best_area) {
811 best_area = tmp_area;
812 area = scr->totalUsableArea[i];
813 }
814
815 if (size > 0 && position != WB_NONE) {
816 if (position & WB_LEFTRIGHT) {
817 scr->totalUsableArea[i].x1 += size;
818 scr->totalUsableArea[i].x2 -= size;
819 }
820 if (position & WB_TOPBOTTOM) {
821 scr->totalUsableArea[i].y1 += size;
822 scr->totalUsableArea[i].y2 -= size;
823 }
824 }
825 }
826
827 if (wPreferences.auto_arrange_icons)
828 wArrangeIcons(scr, True);
829 }
830
831 void wScreenRestoreState(WScreen * scr)
832 {
833 WMPropList *state;
834 char *path;
835
836 OpenRootMenu(scr, -10000, -10000, False);
837 wMenuUnmap(scr->root_menu);
838
839 make_keys();
840
841 if (wScreenCount == 1) {
842 path = wdefaultspathfordomain("WMState");
843 } else {
844 char buf[16];
845 snprintf(buf, sizeof(buf), "WMState.%i", scr->screen);
846 path = wdefaultspathfordomain(buf);
847 }
848 scr->session_state = WMReadPropListFromFile(path);
849 wfree(path);
850 if (!scr->session_state && wScreenCount > 1) {
851 path = wdefaultspathfordomain("WMState");
852 scr->session_state = WMReadPropListFromFile(path);
853 wfree(path);
854 }
855
856 if (!scr->session_state) {
857 scr->session_state = WMCreatePLDictionary(NULL, NULL);
858 }
859
860 if (!wPreferences.flags.nodock) {
861 state = WMGetFromPLDictionary(scr->session_state, dDock);
862 scr->dock = wDockRestoreState(scr, state, WM_DOCK);
863 }
864
865 if (!wPreferences.flags.noclip) {
866 state = WMGetFromPLDictionary(scr->session_state, dClip);
867 scr->clip_icon = wClipRestoreState(scr, state);
868 }
869
870 wWorkspaceRestoreState(scr);
871
872 wScreenUpdateUsableArea(scr);
873 }
874
875 void wScreenSaveState(WScreen * scr)
876 {
877 WWindow *wwin;
878 char *str;
879 WMPropList *old_state, *foo;
880
881 make_keys();
882
883 /* save state of windows */
884 wwin = scr->focused_window;
885 while (wwin) {
886 wWindowSaveState(wwin);
887 wwin = wwin->prev;
888 }
889
890 if (wPreferences.flags.noupdates)
891 return;
892
893 old_state = scr->session_state;
894 scr->session_state = WMCreatePLDictionary(NULL, NULL);
895
896 WMPLSetCaseSensitive(True);
897
898 /* save dock state to file */
899 if (!wPreferences.flags.nodock) {
900 wDockSaveState(scr, old_state);
901 } else {
902 if ((foo = WMGetFromPLDictionary(old_state, dDock)) != NULL) {
903 WMPutInPLDictionary(scr->session_state, dDock, foo);
904 }
905 }
906 if (!wPreferences.flags.noclip) {
907 wClipSaveState(scr);
908 } else {
909 if ((foo = WMGetFromPLDictionary(old_state, dClip)) != NULL) {
910 WMPutInPLDictionary(scr->session_state, dClip, foo);
911 }
912 }
913
914 wWorkspaceSaveState(scr, old_state);
915
916 if (wPreferences.save_session_on_exit) {
917 wSessionSaveState(scr);
918 } else {
919 if ((foo = WMGetFromPLDictionary(old_state, dApplications)) != NULL) {
920 WMPutInPLDictionary(scr->session_state, dApplications, foo);
921 }
922 if ((foo = WMGetFromPLDictionary(old_state, dWorkspace)) != NULL) {
923 WMPutInPLDictionary(scr->session_state, dWorkspace, foo);
924 }
925 }
926
927 /* clean up */
928 WMPLSetCaseSensitive(False);
929
930 wMenuSaveState(scr);
931
932 if (wScreenCount == 1) {
933 str = wdefaultspathfordomain("WMState");
934 } else {
935 char buf[16];
936 snprintf(buf, sizeof(buf), "WMState.%i", scr->screen);
937 str = wdefaultspathfordomain(buf);
938 }
939 if (!WMWritePropListToFile(scr->session_state, str)) {
940 werror(_("could not save session state in %s"), str);
941 }
942 wfree(str);
943 WMReleasePropList(old_state);
944 }
945
946 int wScreenBringInside(WScreen * scr, int *x, int *y, int width, int height)
947 {
948 int moved = 0;
949 int tol_w, tol_h;
950 /*
951 * With respect to the head that contains most of the window.
952 */
953 int sx1, sy1, sx2, sy2;
954
955 WMRect rect;
956 int head, flags;
957
958 rect.pos.x = *x;
959 rect.pos.y = *y;
960 rect.size.width = width;
961 rect.size.height = height;
962
963 head = wGetRectPlacementInfo(scr, rect, &flags);
964 rect = wGetRectForHead(scr, head);
965
966 sx1 = rect.pos.x;
967 sy1 = rect.pos.y;
968 sx2 = sx1 + rect.size.width;
969 sy2 = sy1 + rect.size.height;
970
971 #if 0 /* NOTE: gives funky group movement */
972 if (flags & XFLAG_MULTIPLE) {
973 /*
974 * since we span multiple heads, pull window totaly inside
975 */
976 if (*x < sx1)
977 *x = sx1, moved = 1;
978 else if (*x + width > sx2)
979 *x = sx2 - width, moved = 1;
980
981 if (*y < sy1)
982 *y = sy1, moved = 1;
983 else if (*y + height > sy2)
984 *y = sy2 - height, moved = 1;
985
986 return moved;
987 }
988 #endif
989
990 if (width > 20)
991 tol_w = width / 2;
992 else
993 tol_w = 20;
994
995 if (height > 20)
996 tol_h = height / 2;
997 else
998 tol_h = 20;
999
1000 if (*x + width < sx1 + 10)
1001 *x = sx1 - tol_w, moved = 1;
1002 else if (*x >= sx2 - 10)
1003 *x = sx2 - tol_w - 1, moved = 1;
1004
1005 if (*y < sy1 - height + 10)
1006 *y = sy1 - tol_h, moved = 1;
1007 else if (*y >= sy2 - 10)
1008 *y = sy2 - tol_h - 1, moved = 1;
1009
1010 return moved;
1011 }
1012
1013 int wScreenKeepInside(WScreen * scr, int *x, int *y, int width, int height)
1014 {
1015 int moved = 0;
1016 int sx1, sy1, sx2, sy2;
1017 WMRect rect;
1018 int head;
1019
1020 rect.pos.x = *x;
1021 rect.pos.y = *y;
1022 rect.size.width = width;
1023 rect.size.height = height;
1024
1025 head = wGetHeadForRect(scr, rect);
1026 rect = wGetRectForHead(scr, head);
1027
1028 sx1 = rect.pos.x;
1029 sy1 = rect.pos.y;
1030 sx2 = sx1 + rect.size.width;
1031 sy2 = sy1 + rect.size.height;
1032
1033 if (*x < sx1)
1034 *x = sx1, moved = 1;
1035 else if (*x + width > sx2)
1036 *x = sx2 - width, moved = 1;
1037
1038 if (*y < sy1)
1039 *y = sy1, moved = 1;
1040 else if (*y + height > sy2)
1041 *y = sy2 - height, moved = 1;
1042
1043 return moved;
1044 }
The Window Maker window manager