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