]> Dogcows Code - chaz/openbox/blob - src/screen.cc
WE DONT USE BASE DISPLAY FOR ANYTHING ANY MORE!!@^!*@*!! YAY
[chaz/openbox] / src / screen.cc
1 // -*- mode: C++; indent-tabs-mode: nil; c-basic-offset: 2; -*-
2
3 #ifdef HAVE_CONFIG_H
4 #include "../config.h"
5 #endif // HAVE_CONFIG_H
6
7 extern "C" {
8 #include <X11/Xatom.h>
9 #include <X11/keysym.h>
10
11 #ifdef XINERAMA
12 # include <X11/Xlib.h>
13 # include <X11/extensions/Xinerama.h>
14 #endif // XINERAMA
15
16 #ifdef HAVE_STDLIB_H
17 # include <stdlib.h>
18 #endif // HAVE_STDLIB_H
19
20 #ifdef HAVE_STRING_H
21 # include <string.h>
22 #endif // HAVE_STRING_H
23
24 #ifdef HAVE_CTYPE_H
25 # include <ctype.h>
26 #endif // HAVE_CTYPE_H
27
28 #ifdef HAVE_UNISTD_H
29 # include <sys/types.h>
30 # include <unistd.h>
31 #endif // HAVE_UNISTD_H
32
33 #ifdef HAVE_DIRENT_H
34 # include <dirent.h>
35 #endif // HAVE_DIRENT_H
36
37 #ifdef HAVE_LOCALE_H
38 # include <locale.h>
39 #endif // HAVE_LOCALE_H
40
41 #ifdef HAVE_SYS_STAT_H
42 # include <sys/stat.h>
43 #endif // HAVE_SYS_STAT_H
44
45 #ifdef HAVE_STDARG_H
46 # include <stdarg.h>
47 #endif // HAVE_STDARG_H
48 }
49
50 #include <assert.h>
51
52 #include <algorithm>
53 #include <functional>
54 #include <string>
55 using std::string;
56
57 #include "screen.hh"
58 #include "otk/font.hh"
59 #include "otk/gccache.hh"
60 #include "otk/image.hh"
61 #include "otk/assassin.hh"
62 #include "openbox.hh"
63 #include "util.hh"
64 #include "window.hh"
65 #include "workspace.hh"
66 #include "util.hh"
67 #include "xatom.hh"
68
69 #ifndef FONT_ELEMENT_SIZE
70 #define FONT_ELEMENT_SIZE 50
71 #endif // FONT_ELEMENT_SIZE
72
73 namespace ob {
74
75 static bool running = True;
76
77 static int anotherWMRunning(Display *display, XErrorEvent *) {
78 fprintf(stderr,
79 "BScreen::BScreen: an error occured while querying the X server.\n"
80 " another window manager already running on display %s.\n",
81 DisplayString(display));
82
83 running = False;
84
85 return(-1);
86 }
87
88
89 BScreen::BScreen(Blackbox *bb, unsigned int scrn) : ScreenInfo(scrn) {
90 blackbox = bb;
91 screenstr = "session.screen" + itostring(scrn) + '.';
92 config = blackbox->getConfig();
93 xatom = blackbox->getXAtom();
94
95 event_mask = ColormapChangeMask | EnterWindowMask | PropertyChangeMask |
96 SubstructureRedirectMask | ButtonPressMask | ButtonReleaseMask;
97
98 XErrorHandler old = XSetErrorHandler((XErrorHandler) anotherWMRunning);
99 XSelectInput(otk::OBDisplay::display, getRootWindow(), event_mask);
100 XSync(otk::OBDisplay::display, False);
101 XSetErrorHandler((XErrorHandler) old);
102
103 managed = running;
104 if (! managed) return;
105
106 fprintf(stderr, "BScreen::BScreen: managing screen %d "
107 "using visual 0x%lx, depth %d\n",
108 getScreenNumber(), XVisualIDFromVisual(getVisual()),
109 getDepth());
110
111 resource.wstyle.font = (otk::BFont *) 0;
112
113 geom_pixmap = None;
114
115 xatom->setSupported(this); // set-up netwm support
116 #ifdef HAVE_GETPID
117 xatom->setValue(getRootWindow(), XAtom::blackbox_pid, XAtom::cardinal,
118 (unsigned long) getpid());
119 #endif // HAVE_GETPID
120 unsigned long geometry[] = { getWidth(),
121 getHeight()};
122 xatom->setValue(getRootWindow(), XAtom::net_desktop_geometry,
123 XAtom::cardinal, geometry, 2);
124 unsigned long viewport[] = {0,0};
125 xatom->setValue(getRootWindow(), XAtom::net_desktop_viewport,
126 XAtom::cardinal, viewport, 2);
127
128
129 XDefineCursor(otk::OBDisplay::display, getRootWindow(),
130 blackbox->getSessionCursor());
131
132 updateAvailableArea();
133
134 image_control =
135 new otk::BImageControl(this, True, blackbox->getColorsPerChannel(),
136 blackbox->getCacheLife(), blackbox->getCacheMax());
137 image_control->installRootColormap();
138 root_colormap_installed = True;
139
140 load_rc();
141 LoadStyle();
142
143 XGCValues gcv;
144 gcv.foreground = WhitePixel(otk::OBDisplay::display, getScreenNumber())
145 ^ BlackPixel(otk::OBDisplay::display, getScreenNumber());
146 gcv.function = GXxor;
147 gcv.subwindow_mode = IncludeInferiors;
148 opGC = XCreateGC(otk::OBDisplay::display, getRootWindow(),
149 GCForeground | GCFunction | GCSubwindowMode, &gcv);
150
151 const char *s = "0: 0000 x 0: 0000";
152 geom_w = resource.wstyle.font->measureString(s) + resource.bevel_width * 2;
153 geom_h = resource.wstyle.font->height() + resource.bevel_width * 2;
154
155 XSetWindowAttributes attrib;
156 unsigned long mask = CWBorderPixel | CWColormap | CWSaveUnder;
157 attrib.border_pixel = getBorderColor()->pixel();
158 attrib.colormap = getColormap();
159 attrib.save_under = True;
160
161 geom_window = XCreateWindow(otk::OBDisplay::display, getRootWindow(),
162 0, 0, geom_w, geom_h, resource.border_width,
163 getDepth(), InputOutput, getVisual(),
164 mask, &attrib);
165 geom_visible = False;
166
167 otk::BTexture* texture = &(resource.wstyle.l_focus);
168 geom_pixmap = texture->render(geom_w, geom_h, geom_pixmap);
169 if (geom_pixmap == ParentRelative) {
170 texture = &(resource.wstyle.t_focus);
171 geom_pixmap = texture->render(geom_w, geom_h, geom_pixmap);
172 }
173 if (! geom_pixmap)
174 XSetWindowBackground(otk::OBDisplay::display, geom_window,
175 texture->color().pixel());
176 else
177 XSetWindowBackgroundPixmap(otk::OBDisplay::display,
178 geom_window, geom_pixmap);
179
180 if (resource.workspaces > 0) {
181 for (unsigned int i = 0; i < resource.workspaces; ++i) {
182 Workspace *wkspc = new Workspace(this, workspacesList.size());
183 workspacesList.push_back(wkspc);
184
185 }
186 } else {
187 Workspace *wkspc = new Workspace(this, workspacesList.size());
188 workspacesList.push_back(wkspc);
189 }
190 saveWorkspaceNames();
191
192 updateNetizenWorkspaceCount();
193
194 current_workspace = workspacesList.front();
195
196 xatom->setValue(getRootWindow(), XAtom::net_current_desktop,
197 XAtom::cardinal, 0); //first workspace
198
199 raiseWindows(0, 0); // this also initializes the empty stacking list
200
201 updateClientList(); // initialize the client lists, which will be empty
202 updateAvailableArea();
203
204 changeWorkspaceID(0);
205
206 unsigned int i, j, nchild;
207 Window r, p, *children;
208 XQueryTree(otk::OBDisplay::display, getRootWindow(), &r, &p,
209 &children, &nchild);
210
211 // preen the window list of all icon windows... for better dockapp support
212 for (i = 0; i < nchild; i++) {
213 if (children[i] == None) continue;
214
215 XWMHints *wmhints = XGetWMHints(otk::OBDisplay::display,
216 children[i]);
217
218 if (wmhints) {
219 if ((wmhints->flags & IconWindowHint) &&
220 (wmhints->icon_window != children[i])) {
221 for (j = 0; j < nchild; j++) {
222 if (children[j] == wmhints->icon_window) {
223 children[j] = None;
224 break;
225 }
226 }
227 }
228
229 XFree(wmhints);
230 }
231 }
232
233 // manage shown windows
234 for (i = 0; i < nchild; ++i) {
235 if (children[i] == None || ! blackbox->validateWindow(children[i]))
236 continue;
237
238 XWindowAttributes attrib;
239 if (XGetWindowAttributes(otk::OBDisplay::display, children[i], &attrib)) {
240 if (attrib.override_redirect) continue;
241
242 if (attrib.map_state != IsUnmapped) {
243 manageWindow(children[i]);
244 }
245 }
246 }
247
248 XFree(children);
249
250 // call this again just in case a window we found updates the Strut list
251 updateAvailableArea();
252 }
253
254
255 BScreen::~BScreen(void) {
256 if (! managed) return;
257
258 if (geom_pixmap != None)
259 image_control->removeImage(geom_pixmap);
260
261 if (geom_window != None)
262 XDestroyWindow(otk::OBDisplay::display, geom_window);
263
264 std::for_each(workspacesList.begin(), workspacesList.end(),
265 otk::PointerAssassin());
266
267 std::for_each(iconList.begin(), iconList.end(), otk::PointerAssassin());
268
269 while (! systrayWindowList.empty())
270 removeSystrayWindow(systrayWindowList[0]);
271
272 delete image_control;
273
274 if (resource.wstyle.font)
275 delete resource.wstyle.font;
276
277 if (resource.wstyle.close_button.mask != None)
278 XFreePixmap(otk::OBDisplay::display, resource.wstyle.close_button.mask);
279 if (resource.wstyle.max_button.mask != None)
280 XFreePixmap(otk::OBDisplay::display, resource.wstyle.max_button.mask);
281 if (resource.wstyle.icon_button.mask != None)
282 XFreePixmap(otk::OBDisplay::display, resource.wstyle.icon_button.mask);
283 if (resource.wstyle.stick_button.mask != None)
284 XFreePixmap(otk::OBDisplay::display, resource.wstyle.stick_button.mask);
285
286 resource.wstyle.max_button.mask = resource.wstyle.close_button.mask =
287 resource.wstyle.icon_button.mask =
288 resource.wstyle.stick_button.mask = None;
289
290 XFreeGC(otk::OBDisplay::display, opGC);
291 }
292
293
294 void BScreen::saveSloppyFocus(bool s) {
295 resource.sloppy_focus = s;
296
297 string fmodel;
298 if (resource.sloppy_focus) {
299 fmodel = "SloppyFocus";
300 if (resource.auto_raise) fmodel += " AutoRaise";
301 if (resource.click_raise) fmodel += " ClickRaise";
302 } else {
303 fmodel = "ClickToFocus";
304 }
305 config->setValue(screenstr + "focusModel", fmodel);
306 }
307
308
309 void BScreen::saveAutoRaise(bool a) {
310 resource.auto_raise = a;
311 saveSloppyFocus(resource.sloppy_focus);
312 }
313
314
315 void BScreen::saveClickRaise(bool c) {
316 resource.click_raise = c;
317 saveSloppyFocus(resource.sloppy_focus);
318 }
319
320
321 void BScreen::saveImageDither(bool d) {
322 image_control->setDither(d);
323 config->setValue(screenstr + "imageDither", doImageDither());
324 }
325
326
327 void BScreen::saveOpaqueMove(bool o) {
328 resource.opaque_move = o;
329 config->setValue(screenstr + "opaqueMove", resource.opaque_move);
330 }
331
332
333 void BScreen::saveFullMax(bool f) {
334 resource.full_max = f;
335 config->setValue(screenstr + "fullMaximization", resource.full_max);
336 }
337
338
339 void BScreen::saveFocusNew(bool f) {
340 resource.focus_new = f;
341 config->setValue(screenstr + "focusNewWindows", resource.focus_new);
342 }
343
344
345 void BScreen::saveFocusLast(bool f) {
346 resource.focus_last = f;
347 config->setValue(screenstr + "focusLastWindow", resource.focus_last);
348 }
349
350
351 void BScreen::saveAAFonts(bool f) {
352 resource.aa_fonts = f;
353 config->setValue(screenstr + "antialiasFonts", resource.aa_fonts);
354 reconfigure();
355 }
356
357
358 void BScreen::saveShadowFonts(bool f) {
359 resource.shadow_fonts = f;
360 config->setValue(screenstr + "dropShadowFonts", resource.shadow_fonts);
361 reconfigure();
362 }
363
364
365 void BScreen::saveWindowToEdgeSnap(int s) {
366 resource.snap_to_edges = s;
367
368 const char *snap;
369 switch (resource.snap_to_edges) {
370 case WindowNoSnap: snap = "NoSnap"; break;
371 case WindowResistance: snap = "Resistance"; break;
372 case WindowSnap: default: snap = "Snap"; break;
373 }
374 config->setValue(screenstr + "windowToEdgeSnap", snap);
375 }
376
377
378 void BScreen::saveWindowToWindowSnap(int s) {
379 resource.snap_to_windows = s;
380
381 const char *snap;
382 switch (resource.snap_to_windows) {
383 case WindowNoSnap: snap = "NoSnap"; break;
384 case WindowResistance: snap = "Resistance"; break;
385 case WindowSnap: default: snap = "Snap"; break;
386 }
387 config->setValue(screenstr + "windowToWindowSnap", snap);
388 }
389
390
391 void BScreen::saveResizeZones(unsigned int z) {
392 resource.resize_zones = z;
393 config->setValue(screenstr + "resizeZones", resource.resize_zones);
394 }
395
396
397 void BScreen::saveWindowCornerSnap(bool s) {
398 resource.window_corner_snap = s;
399 config->setValue(screenstr + "windowCornerSnap",
400 resource.window_corner_snap);
401 }
402
403
404 void BScreen::saveWorkspaces(unsigned int w) {
405 resource.workspaces = w;
406 config->setValue(screenstr + "workspaces", resource.workspaces);
407 }
408
409
410 void BScreen::savePlacementPolicy(int p) {
411 resource.placement_policy = p;
412 const char *placement;
413 switch (resource.placement_policy) {
414 case CascadePlacement: placement = "CascadePlacement"; break;
415 case UnderMousePlacement: placement = "UnderMousePlacement"; break;
416 case ClickMousePlacement: placement = "ClickMousePlacement"; break;
417 case ColSmartPlacement: placement = "ColSmartPlacement"; break;
418 case RowSmartPlacement: default: placement = "RowSmartPlacement"; break;
419 }
420 config->setValue(screenstr + "windowPlacement", placement);
421 }
422
423
424 void BScreen::saveResistanceSize(int s) {
425 resource.resistance_size = s;
426 config->setValue(screenstr + "resistanceSize",
427 resource.resistance_size);
428 }
429
430
431 void BScreen::saveSnapThreshold(int t) {
432 resource.snap_threshold = t;
433 config->setValue(screenstr + "edgeSnapThreshold",
434 resource.snap_threshold);
435 }
436
437
438 void BScreen::saveSnapOffset(int t) {
439 resource.snap_offset = t;
440 config->setValue(screenstr + "edgeSnapOffset",
441 resource.snap_offset);
442 }
443
444
445 void BScreen::saveRowPlacementDirection(int d) {
446 resource.row_direction = d;
447 config->setValue(screenstr + "rowPlacementDirection",
448 resource.row_direction == LeftRight ?
449 "LeftToRight" : "RightToLeft");
450 }
451
452
453 void BScreen::saveColPlacementDirection(int d) {
454 resource.col_direction = d;
455 config->setValue(screenstr + "colPlacementDirection",
456 resource.col_direction == TopBottom ?
457 "TopToBottom" : "BottomToTop");
458 }
459
460
461 void BScreen::saveStrftimeFormat(const std::string& format) {
462 resource.strftime_format = format;
463 config->setValue(screenstr + "strftimeFormat", resource.strftime_format);
464 }
465
466
467 void BScreen::saveWorkspaceNames() {
468 string names;
469
470 for (unsigned int i = 0; i < workspacesList.size(); ++i) {
471 names += workspacesList[i]->getName();
472 if (i < workspacesList.size() - 1)
473 names += ',';
474 }
475
476 config->setValue(screenstr + "workspaceNames", names);
477 }
478
479
480 void BScreen::savePlaceIgnoreShaded(bool i) {
481 resource.ignore_shaded = i;
482 config->setValue(screenstr + "placementIgnoreShaded",
483 resource.ignore_shaded);
484 }
485
486
487 void BScreen::savePlaceIgnoreMaximized(bool i) {
488 resource.ignore_maximized = i;
489 config->setValue(screenstr + "placementIgnoreMaximized",
490 resource.ignore_maximized);
491 }
492
493
494 void BScreen::saveAllowScrollLock(bool a) {
495 resource.allow_scroll_lock = a;
496 config->setValue(screenstr + "disableBindingsWithScrollLock",
497 resource.allow_scroll_lock);
498 }
499
500
501 void BScreen::saveWorkspaceWarping(bool w) {
502 resource.workspace_warping = w;
503 config->setValue(screenstr + "workspaceWarping",
504 resource.workspace_warping);
505 }
506
507
508 void BScreen::saveRootScrollDirection(int d) {
509 resource.root_scroll = d;
510 const char *dir;
511 switch (resource.root_scroll) {
512 case NoScroll: dir = "None"; break;
513 case ReverseScroll: dir = "Reverse"; break;
514 case NormalScroll: default: dir = "Normal"; break;
515 }
516 config->setValue(screenstr + "rootScrollDirection", dir);
517 }
518
519
520 void BScreen::save_rc(void) {
521 saveSloppyFocus(resource.sloppy_focus);
522 saveAutoRaise(resource.auto_raise);
523 saveImageDither(doImageDither());
524 saveShadowFonts(resource.shadow_fonts);
525 saveAAFonts(resource.aa_fonts);
526 saveResizeZones(resource.resize_zones);
527 saveOpaqueMove(resource.opaque_move);
528 saveFullMax(resource.full_max);
529 saveFocusNew(resource.focus_new);
530 saveFocusLast(resource.focus_last);
531 saveWindowToWindowSnap(resource.snap_to_windows);
532 saveWindowToEdgeSnap(resource.snap_to_edges);
533 saveWindowCornerSnap(resource.window_corner_snap);
534 saveWorkspaces(resource.workspaces);
535 savePlacementPolicy(resource.placement_policy);
536 saveSnapThreshold(resource.snap_threshold);
537 saveSnapOffset(resource.snap_offset);
538 saveResistanceSize(resource.resistance_size);
539 saveRowPlacementDirection(resource.row_direction);
540 saveColPlacementDirection(resource.col_direction);
541 saveStrftimeFormat(resource.strftime_format);
542 savePlaceIgnoreShaded(resource.ignore_shaded);
543 savePlaceIgnoreMaximized(resource.ignore_maximized);
544 saveAllowScrollLock(resource.allow_scroll_lock);
545 saveWorkspaceWarping(resource.workspace_warping);
546 saveRootScrollDirection(resource.root_scroll);
547 }
548
549
550 void BScreen::load_rc(void) {
551 std::string s;
552 bool b;
553
554 if (! config->getValue(screenstr + "fullMaximization", resource.full_max))
555 resource.full_max = false;
556
557 if (! config->getValue(screenstr + "focusNewWindows", resource.focus_new))
558 resource.focus_new = false;
559
560 if (! config->getValue(screenstr + "focusLastWindow", resource.focus_last))
561 resource.focus_last = false;
562
563 if (! config->getValue(screenstr + "workspaces", resource.workspaces))
564 resource.workspaces = 1;
565
566 if (! config->getValue(screenstr + "opaqueMove", resource.opaque_move))
567 resource.opaque_move = false;
568
569 if (! config->getValue(screenstr + "antialiasFonts", resource.aa_fonts))
570 resource.aa_fonts = true;
571
572 if (! resource.aa_fonts ||
573 ! config->getValue(screenstr + "dropShadowFonts", resource.shadow_fonts))
574 resource.shadow_fonts = false;
575
576 if (! config->getValue(screenstr + "resizeZones", resource.resize_zones) ||
577 (resource.resize_zones != 1 && resource.resize_zones != 2 &&
578 resource.resize_zones != 4))
579 resource.resize_zones = 4;
580
581 resource.snap_to_windows = WindowResistance;
582 if (config->getValue(screenstr + "windowToWindowSnap", s)) {
583 if (s == "NoSnap")
584 resource.snap_to_windows = WindowNoSnap;
585 else if (s == "Snap")
586 resource.snap_to_windows = WindowSnap;
587 }
588
589 resource.snap_to_edges = WindowResistance;
590 if (config->getValue(screenstr + "windowToEdgeSnap", s)) {
591 if (s == "NoSnap")
592 resource.snap_to_edges = WindowNoSnap;
593 else if (s == "Snap")
594 resource.snap_to_edges = WindowSnap;
595 }
596
597 if (! config->getValue(screenstr + "windowCornerSnap",
598 resource.window_corner_snap))
599 resource.window_corner_snap = true;
600
601 if (! config->getValue(screenstr + "imageDither", b))
602 b = true;
603 image_control->setDither(b);
604
605 if (! config->getValue(screenstr + "edgeSnapOffset",
606 resource.snap_offset))
607 resource.snap_offset = 0;
608 if (resource.snap_offset > 50) // sanity check, setting this huge would
609 resource.snap_offset = 50; // seriously suck.
610
611 if (! config->getValue(screenstr + "edgeSnapThreshold",
612 resource.snap_threshold))
613 resource.snap_threshold = 4;
614
615 if (! config->getValue(screenstr + "resistanceSize",
616 resource.resistance_size))
617 resource.resistance_size = 18;
618
619 if (config->getValue(screenstr + "rowPlacementDirection", s) &&
620 s == "RightToLeft")
621 resource.row_direction = RightLeft;
622 else
623 resource.row_direction = LeftRight;
624
625 if (config->getValue(screenstr + "colPlacementDirection", s) &&
626 s == "BottomToTop")
627 resource.col_direction = BottomTop;
628 else
629 resource.col_direction = TopBottom;
630
631 if (config->getValue(screenstr + "workspaceNames", s)) {
632 XAtom::StringVect workspaceNames;
633
634 string::const_iterator it = s.begin(), end = s.end();
635 while(1) {
636 string::const_iterator tmp = it; // current string.begin()
637 it = std::find(tmp, end, ','); // look for comma between tmp and end
638 workspaceNames.push_back(string(tmp, it)); // s[tmp:it]
639 if (it == end)
640 break;
641 ++it;
642 }
643
644 xatom->setValue(getRootWindow(), XAtom::net_desktop_names, XAtom::utf8,
645 workspaceNames);
646 }
647
648 resource.sloppy_focus = true;
649 resource.auto_raise = false;
650 resource.click_raise = false;
651 if (config->getValue(screenstr + "focusModel", s)) {
652 if (s.find("ClickToFocus") != string::npos) {
653 resource.sloppy_focus = false;
654 } else {
655 // must be sloppy
656 if (s.find("AutoRaise") != string::npos)
657 resource.auto_raise = true;
658 if (s.find("ClickRaise") != string::npos)
659 resource.click_raise = true;
660 }
661 }
662
663 if (config->getValue(screenstr + "windowPlacement", s)) {
664 if (s == "CascadePlacement")
665 resource.placement_policy = CascadePlacement;
666 else if (s == "UnderMousePlacement")
667 resource.placement_policy = UnderMousePlacement;
668 else if (s == "ClickMousePlacement")
669 resource.placement_policy = ClickMousePlacement;
670 else if (s == "ColSmartPlacement")
671 resource.placement_policy = ColSmartPlacement;
672 else //if (s == "RowSmartPlacement")
673 resource.placement_policy = RowSmartPlacement;
674 } else
675 resource.placement_policy = RowSmartPlacement;
676
677 if (! config->getValue(screenstr + "strftimeFormat",
678 resource.strftime_format))
679 resource.strftime_format = "%I:%M %p";
680
681 if (! config->getValue(screenstr + "placementIgnoreShaded",
682 resource.ignore_shaded))
683 resource.ignore_shaded = true;
684
685 if (! config->getValue(screenstr + "placementIgnoreMaximized",
686 resource.ignore_maximized))
687 resource.ignore_maximized = true;
688
689 if (! config->getValue(screenstr + "disableBindingsWithScrollLock",
690 resource.allow_scroll_lock))
691 resource.allow_scroll_lock = false;
692
693 if (! config->getValue(screenstr + "workspaceWarping",
694 resource.workspace_warping))
695 resource.workspace_warping = false;
696
697 resource.root_scroll = NormalScroll;
698 if (config->getValue(screenstr + "rootScrollDirection", s)) {
699 if (s == "None")
700 resource.root_scroll = NoScroll;
701 else if (s == "Reverse")
702 resource.root_scroll = ReverseScroll;
703 }
704 }
705
706
707 void BScreen::changeWorkspaceCount(unsigned int new_count) {
708 assert(new_count > 0);
709
710 if (new_count < workspacesList.size()) {
711 // shrink
712 for (unsigned int i = workspacesList.size(); i > new_count; --i)
713 removeLastWorkspace();
714 // removeLast already sets the current workspace to the
715 // last available one.
716 } else if (new_count > workspacesList.size()) {
717 // grow
718 for(unsigned int i = workspacesList.size(); i < new_count; ++i)
719 addWorkspace();
720 }
721 }
722
723
724 void BScreen::reconfigure(void) {
725 // don't reconfigure while saving the initial rc file, it's a waste and it
726 // breaks somethings (workspace names)
727 if (blackbox->state() == Openbox::State_Starting) return;
728
729 load_rc();
730 LoadStyle();
731
732 // we need to do this explicitly, because just loading this value from the rc
733 // does nothing
734 changeWorkspaceCount(resource.workspaces);
735
736 XGCValues gcv;
737 gcv.foreground = WhitePixel(otk::OBDisplay::display,
738 getScreenNumber());
739 gcv.function = GXinvert;
740 gcv.subwindow_mode = IncludeInferiors;
741 XChangeGC(otk::OBDisplay::display, opGC,
742 GCForeground | GCFunction | GCSubwindowMode, &gcv);
743
744 const char *s = "0: 0000 x 0: 0000";
745
746 geom_w = resource.wstyle.font->measureString(s) + resource.bevel_width * 2;
747 geom_h = resource.wstyle.font->height() + resource.bevel_width * 2;
748
749 otk::BTexture* texture = &(resource.wstyle.l_focus);
750 geom_pixmap = texture->render(geom_w, geom_h, geom_pixmap);
751 if (geom_pixmap == ParentRelative) {
752 texture = &(resource.wstyle.t_focus);
753 geom_pixmap = texture->render(geom_w, geom_h, geom_pixmap);
754 }
755 if (! geom_pixmap)
756 XSetWindowBackground(otk::OBDisplay::display, geom_window,
757 texture->color().pixel());
758 else
759 XSetWindowBackgroundPixmap(otk::OBDisplay::display,
760 geom_window, geom_pixmap);
761
762 XSetWindowBorderWidth(otk::OBDisplay::display, geom_window,
763 resource.border_width);
764 XSetWindowBorder(otk::OBDisplay::display, geom_window,
765 resource.border_color.pixel());
766
767 typedef std::vector<int> SubList;
768 SubList remember_subs;
769
770 raiseWindows(0, 0);
771
772 std::for_each(workspacesList.begin(), workspacesList.end(),
773 std::mem_fun(&Workspace::reconfigure));
774
775 BlackboxWindowList::iterator iit = iconList.begin();
776 for (; iit != iconList.end(); ++iit) {
777 BlackboxWindow *bw = *iit;
778 if (bw->validateClient())
779 bw->reconfigure();
780 }
781
782 image_control->timeout();
783 }
784
785
786 void BScreen::LoadStyle(void) {
787 Configuration style(False);
788
789 const char *sfile = blackbox->getStyleFilename();
790 if (sfile != NULL) {
791 style.setFile(sfile);
792 if (! style.load()) {
793 style.setFile(DEFAULTSTYLE);
794 if (! style.load())
795 style.create(); // hardcoded default values will be used.
796 }
797 }
798
799 // merge in the rc file
800 style.merge(config->file(), True);
801
802 string s;
803
804 // load fonts/fontsets
805 if (resource.wstyle.font)
806 delete resource.wstyle.font;
807
808 resource.wstyle.font = readDatabaseFont("window.", style);
809
810 // load window config
811 resource.wstyle.t_focus =
812 readDatabaseTexture("window.title.focus", "white", style);
813 resource.wstyle.t_unfocus =
814 readDatabaseTexture("window.title.unfocus", "black", style);
815 resource.wstyle.l_focus =
816 readDatabaseTexture("window.label.focus", "white", style);
817 resource.wstyle.l_unfocus =
818 readDatabaseTexture("window.label.unfocus", "black", style);
819 resource.wstyle.h_focus =
820 readDatabaseTexture("window.handle.focus", "white", style);
821 resource.wstyle.h_unfocus =
822 readDatabaseTexture("window.handle.unfocus", "black", style);
823 resource.wstyle.g_focus =
824 readDatabaseTexture("window.grip.focus", "white", style);
825 resource.wstyle.g_unfocus =
826 readDatabaseTexture("window.grip.unfocus", "black", style);
827 resource.wstyle.b_focus =
828 readDatabaseTexture("window.button.focus", "white", style);
829 resource.wstyle.b_unfocus =
830 readDatabaseTexture("window.button.unfocus", "black", style);
831 resource.wstyle.b_pressed =
832 readDatabaseTexture("window.button.pressed", "black", style);
833
834 //if neither of these can be found, we will use the previous resource
835 resource.wstyle.b_pressed_focus =
836 readDatabaseTexture("window.button.pressed.focus", "black", style, true);
837 resource.wstyle.b_pressed_unfocus =
838 readDatabaseTexture("window.button.pressed.unfocus", "black", style, true);
839
840 if (resource.wstyle.close_button.mask != None)
841 XFreePixmap(otk::OBDisplay::display, resource.wstyle.close_button.mask);
842 if (resource.wstyle.max_button.mask != None)
843 XFreePixmap(otk::OBDisplay::display, resource.wstyle.max_button.mask);
844 if (resource.wstyle.icon_button.mask != None)
845 XFreePixmap(otk::OBDisplay::display, resource.wstyle.icon_button.mask);
846 if (resource.wstyle.stick_button.mask != None)
847 XFreePixmap(otk::OBDisplay::display, resource.wstyle.stick_button.mask);
848
849 resource.wstyle.close_button.mask = resource.wstyle.max_button.mask =
850 resource.wstyle.icon_button.mask =
851 resource.wstyle.icon_button.mask = None;
852
853 readDatabaseMask("window.button.close.mask", resource.wstyle.close_button,
854 style);
855 readDatabaseMask("window.button.max.mask", resource.wstyle.max_button,
856 style);
857 readDatabaseMask("window.button.icon.mask", resource.wstyle.icon_button,
858 style);
859 readDatabaseMask("window.button.stick.mask", resource.wstyle.stick_button,
860 style);
861
862 // we create the window.frame texture by hand because it exists only to
863 // make the code cleaner and is not actually used for display
864 otk::BColor color = readDatabaseColor("window.frame.focusColor", "white",
865 style);
866 resource.wstyle.f_focus = otk::BTexture("solid flat", getScreenNumber(),
867 image_control);
868 resource.wstyle.f_focus.setColor(color);
869
870 color = readDatabaseColor("window.frame.unfocusColor", "white", style);
871 resource.wstyle.f_unfocus = otk::BTexture("solid flat", getScreenNumber(),
872 image_control);
873 resource.wstyle.f_unfocus.setColor(color);
874
875 resource.wstyle.l_text_focus =
876 readDatabaseColor("window.label.focus.textColor", "black", style);
877 resource.wstyle.l_text_unfocus =
878 readDatabaseColor("window.label.unfocus.textColor", "white", style);
879 resource.wstyle.b_pic_focus =
880 readDatabaseColor("window.button.focus.picColor", "black", style);
881 resource.wstyle.b_pic_unfocus =
882 readDatabaseColor("window.button.unfocus.picColor", "white", style);
883
884 resource.wstyle.justify = LeftJustify;
885 if (style.getValue("window.justify", s)) {
886 if (s == "right" || s == "Right")
887 resource.wstyle.justify = RightJustify;
888 else if (s == "center" || s == "Center")
889 resource.wstyle.justify = CenterJustify;
890 }
891
892 // sanity checks
893 if (resource.wstyle.t_focus.texture() == otk::BTexture::Parent_Relative)
894 resource.wstyle.t_focus = resource.wstyle.f_focus;
895 if (resource.wstyle.t_unfocus.texture() == otk::BTexture::Parent_Relative)
896 resource.wstyle.t_unfocus = resource.wstyle.f_unfocus;
897 if (resource.wstyle.h_focus.texture() == otk::BTexture::Parent_Relative)
898 resource.wstyle.h_focus = resource.wstyle.f_focus;
899 if (resource.wstyle.h_unfocus.texture() == otk::BTexture::Parent_Relative)
900 resource.wstyle.h_unfocus = resource.wstyle.f_unfocus;
901
902 resource.border_color =
903 readDatabaseColor("borderColor", "black", style);
904
905 // load bevel, border and handle widths
906 if (! style.getValue("handleWidth", resource.handle_width) ||
907 resource.handle_width > (getWidth() / 2) || resource.handle_width == 0)
908 resource.handle_width = 6;
909
910 if (! style.getValue("borderWidth", resource.border_width))
911 resource.border_width = 1;
912
913 if (! style.getValue("bevelWidth", resource.bevel_width) ||
914 resource.bevel_width > (getWidth() / 2) || resource.bevel_width == 0)
915 resource.bevel_width = 3;
916
917 if (! style.getValue("frameWidth", resource.frame_width) ||
918 resource.frame_width > (getWidth() / 2))
919 resource.frame_width = resource.bevel_width;
920
921 if (style.getValue("rootCommand", s))
922 bexec(s, displayString());
923 }
924
925
926 void BScreen::addIcon(BlackboxWindow *w) {
927 if (! w) return;
928
929 w->setWorkspace(BSENTINEL);
930 w->setWindowNumber(iconList.size());
931
932 iconList.push_back(w);
933 }
934
935
936 void BScreen::removeIcon(BlackboxWindow *w) {
937 if (! w) return;
938
939 iconList.remove(w);
940
941 BlackboxWindowList::iterator it = iconList.begin(),
942 end = iconList.end();
943 for (int i = 0; it != end; ++it)
944 (*it)->setWindowNumber(i++);
945 }
946
947
948 BlackboxWindow *BScreen::getIcon(unsigned int index) {
949 if (index < iconList.size()) {
950 BlackboxWindowList::iterator it = iconList.begin();
951 while (index-- > 0) // increment to index
952 ++it;
953 return *it;
954 }
955
956 return (BlackboxWindow *) 0;
957 }
958
959
960 unsigned int BScreen::addWorkspace(void) {
961 Workspace *wkspc = new Workspace(this, workspacesList.size());
962 workspacesList.push_back(wkspc);
963 saveWorkspaces(getWorkspaceCount());
964 saveWorkspaceNames();
965
966 return workspacesList.size();
967 }
968
969
970 unsigned int BScreen::removeLastWorkspace(void) {
971 if (workspacesList.size() == 1)
972 return 1;
973
974 Workspace *wkspc = workspacesList.back();
975
976 if (current_workspace->getID() == wkspc->getID())
977 changeWorkspaceID(current_workspace->getID() - 1);
978
979 wkspc->removeAll();
980
981 workspacesList.pop_back();
982 delete wkspc;
983
984 saveWorkspaces(getWorkspaceCount());
985 saveWorkspaceNames();
986
987 updateNetizenWorkspaceCount();
988
989 return workspacesList.size();
990 }
991
992
993 void BScreen::changeWorkspaceID(unsigned int id) {
994 if (! current_workspace || id == current_workspace->getID()) return;
995
996 BlackboxWindow *focused = blackbox->getFocusedWindow();
997 if (focused && focused->getScreen() == this) {
998 assert(focused->isStuck() ||
999 focused->getWorkspaceNumber() == current_workspace->getID());
1000
1001 current_workspace->setLastFocusedWindow(focused);
1002 } else {
1003 // if no window had focus, no need to store a last focus
1004 current_workspace->setLastFocusedWindow((BlackboxWindow *) 0);
1005 }
1006
1007 // when we switch workspaces, unfocus whatever was focused if it is going
1008 // to be unmapped
1009 if (focused && ! focused->isStuck())
1010 blackbox->setFocusedWindow((BlackboxWindow *) 0);
1011
1012 current_workspace->hideAll();
1013
1014 current_workspace = getWorkspace(id);
1015
1016 xatom->setValue(getRootWindow(), XAtom::net_current_desktop,
1017 XAtom::cardinal, id);
1018
1019 current_workspace->showAll();
1020
1021 int x, y, rx, ry;
1022 Window c, r;
1023 unsigned int m;
1024 BlackboxWindow *win = (BlackboxWindow *) 0;
1025 bool f = False;
1026
1027 XSync(otk::OBDisplay::display, False);
1028
1029 // If sloppy focus and we can find the client window under the pointer,
1030 // try to focus it.
1031 if (resource.sloppy_focus &&
1032 XQueryPointer(otk::OBDisplay::display, getRootWindow(), &r, &c,
1033 &rx, &ry, &x, &y, &m) &&
1034 c != None) {
1035 if ( (win = blackbox->searchWindow(c)) )
1036 f = win->setInputFocus();
1037 }
1038
1039 // If that fails, and we're doing focus_last, try to focus the last window.
1040 if (! f && resource.focus_last &&
1041 (win = current_workspace->getLastFocusedWindow()))
1042 f = win->setInputFocus();
1043
1044 /*
1045 if we found a focus target, then we set the focused window explicitly
1046 because it is possible to switch off this workspace before the x server
1047 generates the FocusIn event for the window. if that happens, openbox would
1048 lose track of what window was the 'LastFocused' window on the workspace.
1049
1050 if we did not find a focus target, then set the current focused window to
1051 nothing.
1052 */
1053 if (f)
1054 blackbox->setFocusedWindow(win);
1055 else
1056 blackbox->setFocusedWindow((BlackboxWindow *) 0);
1057 }
1058
1059
1060 /*
1061 * Set the _NET_CLIENT_LIST root window property.
1062 */
1063 void BScreen::updateClientList(void) {
1064 if (windowList.size() > 0) {
1065 Window *windows = new Window[windowList.size()];
1066 Window *win_it = windows;
1067 BlackboxWindowList::iterator it = windowList.begin();
1068 const BlackboxWindowList::iterator end = windowList.end();
1069 for (; it != end; ++it, ++win_it)
1070 *win_it = (*it)->getClientWindow();
1071 xatom->setValue(getRootWindow(), XAtom::net_client_list, XAtom::window,
1072 windows, windowList.size());
1073 delete [] windows;
1074 } else
1075 xatom->setValue(getRootWindow(), XAtom::net_client_list, XAtom::window,
1076 0, 0);
1077
1078 updateStackingList();
1079 }
1080
1081
1082 /*
1083 * Set the _NET_CLIENT_LIST_STACKING root window property.
1084 */
1085 void BScreen::updateStackingList(void) {
1086
1087 BlackboxWindowList stack_order;
1088
1089 /*
1090 * Get the stacking order from all of the workspaces.
1091 * We start with the current workspace so that the sticky windows will be
1092 * in the right order on the current workspace.
1093 * XXX: Do we need to have sticky windows in the list once for each workspace?
1094 */
1095 getCurrentWorkspace()->appendStackOrder(stack_order);
1096 for (unsigned int i = 0; i < getWorkspaceCount(); ++i)
1097 if (i != getCurrentWorkspaceID())
1098 getWorkspace(i)->appendStackOrder(stack_order);
1099
1100 if (stack_order.size() > 0) {
1101 // set the client list atoms
1102 Window *windows = new Window[stack_order.size()];
1103 Window *win_it = windows;
1104 BlackboxWindowList::iterator it = stack_order.begin(),
1105 end = stack_order.end();
1106 for (; it != end; ++it, ++win_it)
1107 *win_it = (*it)->getClientWindow();
1108 xatom->setValue(getRootWindow(), XAtom::net_client_list_stacking,
1109 XAtom::window, windows, stack_order.size());
1110 delete [] windows;
1111 } else
1112 xatom->setValue(getRootWindow(), XAtom::net_client_list_stacking,
1113 XAtom::window, 0, 0);
1114 }
1115
1116
1117 void BScreen::addSystrayWindow(Window window) {
1118 XGrabServer(otk::OBDisplay::display);
1119
1120 XSelectInput(otk::OBDisplay::display, window, StructureNotifyMask);
1121 systrayWindowList.push_back(window);
1122 xatom->setValue(getRootWindow(), XAtom::kde_net_system_tray_windows,
1123 XAtom::window,
1124 &systrayWindowList[0], systrayWindowList.size());
1125 blackbox->saveSystrayWindowSearch(window, this);
1126
1127 XUngrabServer(otk::OBDisplay::display);
1128 }
1129
1130
1131 void BScreen::removeSystrayWindow(Window window) {
1132 XGrabServer(otk::OBDisplay::display);
1133
1134 WindowList::iterator it = systrayWindowList.begin();
1135 const WindowList::iterator end = systrayWindowList.end();
1136 for (; it != end; ++it)
1137 if (*it == window) {
1138 systrayWindowList.erase(it);
1139 xatom->setValue(getRootWindow(), XAtom::kde_net_system_tray_windows,
1140 XAtom::window,
1141 &systrayWindowList[0], systrayWindowList.size());
1142 blackbox->removeSystrayWindowSearch(window);
1143 XSelectInput(otk::OBDisplay::display, window, NoEventMask);
1144 break;
1145 }
1146
1147 assert(it != end); // not a systray window
1148
1149 XUngrabServer(otk::OBDisplay::display);
1150 }
1151
1152
1153 void BScreen::manageWindow(Window w) {
1154 // is the window a KDE systray window?
1155 Window systray;
1156 if (xatom->getValue(w, XAtom::kde_net_wm_system_tray_window_for,
1157 XAtom::window, systray) && systray != None) {
1158 addSystrayWindow(w);
1159 return;
1160 }
1161
1162 // is the window a docking app
1163 XWMHints *wmhint = XGetWMHints(otk::OBDisplay::display, w);
1164 if (wmhint && (wmhint->flags & StateHint) &&
1165 wmhint->initial_state == WithdrawnState) {
1166 //slit->addClient(w);
1167 return;
1168 }
1169
1170 new BlackboxWindow(blackbox, w, this);
1171
1172 BlackboxWindow *win = blackbox->searchWindow(w);
1173 if (! win)
1174 return;
1175
1176 if (win->isDesktop()) {
1177 desktopWindowList.push_back(win->getFrameWindow());
1178 } else { // if (win->isNormal()) {
1179 // don't list desktop windows as managed windows
1180 windowList.push_back(win);
1181 updateClientList();
1182
1183 if (win->isTopmost())
1184 specialWindowList.push_back(win->getFrameWindow());
1185 }
1186
1187 XMapRequestEvent mre;
1188 mre.window = w;
1189 if (blackbox->state() == Openbox::State_Starting &&
1190 win->isNormal())
1191 win->restoreAttributes();
1192 win->mapRequestEvent(&mre);
1193 }
1194
1195
1196 void BScreen::unmanageWindow(BlackboxWindow *w, bool remap) {
1197 // is the window a KDE systray window?
1198 Window systray;
1199 if (xatom->getValue(w->getClientWindow(),
1200 XAtom::kde_net_wm_system_tray_window_for,
1201 XAtom::window, systray) && systray != None) {
1202 removeSystrayWindow(w->getClientWindow());
1203 return;
1204 }
1205
1206 w->restore(remap);
1207
1208 // Remove the modality so that its parent won't try to re-focus the window
1209 if (w->isModal()) w->setModal(False);
1210
1211 if (w->getWorkspaceNumber() != BSENTINEL &&
1212 w->getWindowNumber() != BSENTINEL) {
1213 getWorkspace(w->getWorkspaceNumber())->removeWindow(w);
1214 if (w->isStuck()) {
1215 for (unsigned int i = 0; i < getNumberOfWorkspaces(); ++i)
1216 if (i != w->getWorkspaceNumber())
1217 getWorkspace(i)->removeWindow(w, True);
1218 }
1219 } else if (w->isIconic())
1220 removeIcon(w);
1221
1222 if (w->isDesktop()) {
1223 WindowList::iterator it = desktopWindowList.begin();
1224 const WindowList::iterator end = desktopWindowList.end();
1225 for (; it != end; ++it)
1226 if (*it == w->getFrameWindow()) {
1227 desktopWindowList.erase(it);
1228 break;
1229 }
1230 assert(it != end); // the window wasnt a desktop window?
1231 } else { // if (w->isNormal()) {
1232 // we don't list desktop windows as managed windows
1233 windowList.remove(w);
1234 updateClientList();
1235
1236 if (w->isTopmost()) {
1237 WindowList::iterator it = specialWindowList.begin();
1238 const WindowList::iterator end = specialWindowList.end();
1239 for (; it != end; ++it)
1240 if (*it == w->getFrameWindow()) {
1241 specialWindowList.erase(it);
1242 break;
1243 }
1244 assert(it != end); // the window wasnt a special window?
1245 }
1246 }
1247
1248 if (blackbox->getFocusedWindow() == w)
1249 blackbox->setFocusedWindow((BlackboxWindow *) 0);
1250
1251 /*
1252 some managed windows can also be window group controllers. when
1253 unmanaging such windows, we should also delete the window group.
1254 */
1255 BWindowGroup *group = blackbox->searchGroup(w->getClientWindow());
1256 delete group;
1257
1258 delete w;
1259 }
1260
1261
1262 void BScreen::updateWorkArea(void) {
1263 if (workspacesList.size() > 0) {
1264 unsigned long *dims = new unsigned long[4 * workspacesList.size()];
1265 for (unsigned int i = 0, m = workspacesList.size(); i < m; ++i) {
1266 // XXX: this could be different for each workspace
1267 const otk::Rect &area = availableArea();
1268 dims[(i * 4) + 0] = area.x();
1269 dims[(i * 4) + 1] = area.y();
1270 dims[(i * 4) + 2] = area.width();
1271 dims[(i * 4) + 3] = area.height();
1272 }
1273 xatom->setValue(getRootWindow(), XAtom::net_workarea, XAtom::cardinal,
1274 dims, 4 * workspacesList.size());
1275 delete [] dims;
1276 } else
1277 xatom->setValue(getRootWindow(), XAtom::net_workarea, XAtom::cardinal,
1278 0, 0);
1279 }
1280
1281
1282 void BScreen::updateNetizenWorkspaceCount(void) {
1283 xatom->setValue(getRootWindow(), XAtom::net_number_of_desktops,
1284 XAtom::cardinal, workspacesList.size());
1285
1286 updateWorkArea();
1287 }
1288
1289
1290 void BScreen::updateNetizenWindowFocus(void) {
1291 Window f = ((blackbox->getFocusedWindow()) ?
1292 blackbox->getFocusedWindow()->getClientWindow() : None);
1293
1294 xatom->setValue(getRootWindow(), XAtom::net_active_window,
1295 XAtom::window, f);
1296 }
1297
1298
1299 void BScreen::raiseWindows(Window *workspace_stack, unsigned int num) {
1300 // the 13 represents the number of blackbox windows such as menus
1301 int bbwins = 15;
1302 #ifdef XINERAMA
1303 ++bbwins;
1304 #endif // XINERAMA
1305
1306 Window *session_stack = new
1307 Window[(num + specialWindowList.size() + bbwins)];
1308 unsigned int i = 0, k = num;
1309
1310 WindowList::iterator sit, send = specialWindowList.end();
1311 for (sit = specialWindowList.begin(); sit != send; ++sit)
1312 *(session_stack + i++) = *sit;
1313
1314 while (k--)
1315 *(session_stack + i++) = *(workspace_stack + k);
1316
1317 XRestackWindows(otk::OBDisplay::display, session_stack, i);
1318
1319 delete [] session_stack;
1320
1321 updateStackingList();
1322 }
1323
1324
1325 void BScreen::lowerWindows(Window *workspace_stack, unsigned int num) {
1326 assert(num > 0); // this would cause trouble in the XRaiseWindow call
1327
1328 Window *session_stack = new Window[(num + desktopWindowList.size())];
1329 unsigned int i = 0, k = num;
1330
1331 XLowerWindow(otk::OBDisplay::display, workspace_stack[0]);
1332
1333 while (k--)
1334 *(session_stack + i++) = *(workspace_stack + k);
1335
1336 WindowList::iterator dit = desktopWindowList.begin();
1337 const WindowList::iterator d_end = desktopWindowList.end();
1338 for (; dit != d_end; ++dit)
1339 *(session_stack + i++) = *dit;
1340
1341 XRestackWindows(otk::OBDisplay::display, session_stack, i);
1342
1343 delete [] session_stack;
1344
1345 updateStackingList();
1346 }
1347
1348
1349 void BScreen::reassociateWindow(BlackboxWindow *w, unsigned int wkspc_id,
1350 bool ignore_sticky) {
1351 if (! w) return;
1352
1353 if (wkspc_id == BSENTINEL)
1354 wkspc_id = current_workspace->getID();
1355
1356 if (w->getWorkspaceNumber() == wkspc_id)
1357 return;
1358
1359 if (w->isIconic()) {
1360 removeIcon(w);
1361 getWorkspace(wkspc_id)->addWindow(w);
1362 if (w->isStuck())
1363 for (unsigned int i = 0; i < getNumberOfWorkspaces(); ++i)
1364 if (i != w->getWorkspaceNumber())
1365 getWorkspace(i)->addWindow(w, True);
1366 } else if (ignore_sticky || ! w->isStuck()) {
1367 if (w->isStuck())
1368 w->stick();
1369 getWorkspace(w->getWorkspaceNumber())->removeWindow(w);
1370 getWorkspace(wkspc_id)->addWindow(w);
1371 }
1372 updateStackingList();
1373 }
1374
1375
1376 void BScreen::propagateWindowName(const BlackboxWindow *bw) {
1377 if (bw->isIconic()) {
1378 } else {
1379 }
1380 }
1381
1382
1383 void BScreen::nextFocus(void) const {
1384 BlackboxWindow *focused = blackbox->getFocusedWindow(),
1385 *next = focused;
1386
1387 if (focused &&
1388 focused->getScreen()->getScreenNumber() == getScreenNumber() &&
1389 current_workspace->getCount() > 1) {
1390 do {
1391 next = current_workspace->getNextWindowInList(next);
1392 } while (next != focused && ! next->setInputFocus());
1393
1394 if (next != focused)
1395 current_workspace->raiseWindow(next);
1396 } else if (current_workspace->getCount() > 0) {
1397 next = current_workspace->getTopWindowOnStack();
1398 next->setInputFocus();
1399 current_workspace->raiseWindow(next);
1400 }
1401 }
1402
1403
1404 void BScreen::prevFocus(void) const {
1405 BlackboxWindow *focused = blackbox->getFocusedWindow(),
1406 *next = focused;
1407
1408 if (focused) {
1409 // if window is not on this screen, ignore it
1410 if (focused->getScreen()->getScreenNumber() != getScreenNumber())
1411 focused = (BlackboxWindow*) 0;
1412 }
1413
1414 if (focused &&
1415 focused->getScreen()->getScreenNumber() == getScreenNumber() &&
1416 current_workspace->getCount() > 1) {
1417 // next is the next window to receive focus, current is a place holder
1418 do {
1419 next = current_workspace->getPrevWindowInList(next);
1420 } while (next != focused && ! next->setInputFocus());
1421
1422 if (next != focused)
1423 current_workspace->raiseWindow(next);
1424 } else if (current_workspace->getCount() > 0) {
1425 next = current_workspace->getTopWindowOnStack();
1426 next->setInputFocus();
1427 current_workspace->raiseWindow(next);
1428 }
1429 }
1430
1431
1432 void BScreen::raiseFocus(void) const {
1433 BlackboxWindow *focused = blackbox->getFocusedWindow();
1434 if (! focused)
1435 return;
1436
1437 // if on this Screen, raise it
1438 if (focused->getScreen()->getScreenNumber() == getScreenNumber()) {
1439 Workspace *workspace = getWorkspace(focused->getWorkspaceNumber());
1440 workspace->raiseWindow(focused);
1441 }
1442 }
1443
1444
1445 void BScreen::shutdown(void) {
1446 XSelectInput(otk::OBDisplay::display, getRootWindow(), NoEventMask);
1447 XSync(otk::OBDisplay::display, False);
1448
1449 while(! windowList.empty())
1450 unmanageWindow(windowList.front(), True);
1451
1452 while(! desktopWindowList.empty()) {
1453 BlackboxWindow *win = blackbox->searchWindow(desktopWindowList.front());
1454 assert(win);
1455 unmanageWindow(win, True);
1456 }
1457 }
1458
1459
1460 void BScreen::showPosition(int x, int y) {
1461 if (! geom_visible) {
1462 XMoveResizeWindow(otk::OBDisplay::display, geom_window,
1463 (getWidth() - geom_w) / 2,
1464 (getHeight() - geom_h) / 2, geom_w, geom_h);
1465 XMapWindow(otk::OBDisplay::display, geom_window);
1466 XRaiseWindow(otk::OBDisplay::display, geom_window);
1467
1468 geom_visible = True;
1469 }
1470
1471 char label[1024];
1472
1473 sprintf(label, "X: %4d x Y: %4d", x, y);
1474
1475 XClearWindow(otk::OBDisplay::display, geom_window);
1476
1477 resource.wstyle.font->drawString(geom_window,
1478 resource.bevel_width, resource.bevel_width,
1479 resource.wstyle.l_text_focus,
1480 label);
1481 }
1482
1483
1484 void BScreen::showGeometry(unsigned int gx, unsigned int gy) {
1485 if (! geom_visible) {
1486 XMoveResizeWindow(otk::OBDisplay::display, geom_window,
1487 (getWidth() - geom_w) / 2,
1488 (getHeight() - geom_h) / 2, geom_w, geom_h);
1489 XMapWindow(otk::OBDisplay::display, geom_window);
1490 XRaiseWindow(otk::OBDisplay::display, geom_window);
1491
1492 geom_visible = True;
1493 }
1494
1495 char label[1024];
1496
1497 sprintf(label, "W: %4d x H: %4d", gx, gy);
1498
1499 XClearWindow(otk::OBDisplay::display, geom_window);
1500
1501 resource.wstyle.font->drawString(geom_window,
1502 resource.bevel_width, resource.bevel_width,
1503 resource.wstyle.l_text_focus,
1504 label);
1505 }
1506
1507
1508 void BScreen::hideGeometry(void) {
1509 if (geom_visible) {
1510 XUnmapWindow(otk::OBDisplay::display, geom_window);
1511 geom_visible = False;
1512 }
1513 }
1514
1515
1516 void BScreen::addStrut(Strut *strut) {
1517 strutList.push_back(strut);
1518 }
1519
1520
1521 void BScreen::removeStrut(Strut *strut) {
1522 strutList.remove(strut);
1523 }
1524
1525
1526 const otk::Rect& BScreen::availableArea(void) const {
1527 if (doFullMax())
1528 return getRect(); // return the full screen
1529 return usableArea;
1530 }
1531
1532
1533 #ifdef XINERAMA
1534 const RectList& BScreen::allAvailableAreas(void) const {
1535 assert(isXineramaActive());
1536 assert(xineramaUsableArea.size() > 0);
1537 fprintf(stderr, "1found x %d y %d w %d h %d\n",
1538 xineramaUsableArea[0].x(), xineramaUsableArea[0].y(),
1539 xineramaUsableArea[0].width(), xineramaUsableArea[0].height());
1540 return xineramaUsableArea;
1541 }
1542 #endif // XINERAMA
1543
1544
1545 void BScreen::updateAvailableArea(void) {
1546 otk::Rect old_area = usableArea;
1547 usableArea = getRect(); // reset to full screen
1548
1549 #ifdef XINERAMA
1550 // reset to the full areas
1551 if (isXineramaActive())
1552 xineramaUsableArea = getXineramaAreas();
1553 #endif // XINERAMA
1554
1555 /* these values represent offsets from the screen edge
1556 * we look for the biggest offset on each edge and then apply them
1557 * all at once
1558 * do not be confused by the similarity to the names of Rect's members
1559 */
1560 unsigned int current_left = 0, current_right = 0, current_top = 0,
1561 current_bottom = 0;
1562
1563 StrutList::const_iterator it = strutList.begin(), end = strutList.end();
1564
1565 for(; it != end; ++it) {
1566 Strut *strut = *it;
1567 if (strut->left > current_left)
1568 current_left = strut->left;
1569 if (strut->top > current_top)
1570 current_top = strut->top;
1571 if (strut->right > current_right)
1572 current_right = strut->right;
1573 if (strut->bottom > current_bottom)
1574 current_bottom = strut->bottom;
1575 }
1576
1577 usableArea.setPos(current_left, current_top);
1578 usableArea.setSize(usableArea.width() - (current_left + current_right),
1579 usableArea.height() - (current_top + current_bottom));
1580
1581 #ifdef XINERAMA
1582 if (isXineramaActive()) {
1583 // keep each of the ximerama-defined areas inside the strut
1584 RectList::iterator xit, xend = xineramaUsableArea.end();
1585 for (xit = xineramaUsableArea.begin(); xit != xend; ++xit) {
1586 if (xit->x() < usableArea.x()) {
1587 xit->setX(usableArea.x());
1588 xit->setWidth(xit->width() - usableArea.x());
1589 }
1590 if (xit->y() < usableArea.y()) {
1591 xit->setY(usableArea.y());
1592 xit->setHeight(xit->height() - usableArea.y());
1593 }
1594 if (xit->x() + xit->width() > usableArea.width())
1595 xit->setWidth(usableArea.width() - xit->x());
1596 if (xit->y() + xit->height() > usableArea.height())
1597 xit->setHeight(usableArea.height() - xit->y());
1598 }
1599 }
1600 #endif // XINERAMA
1601
1602 if (old_area != usableArea) {
1603 BlackboxWindowList::iterator it = windowList.begin(),
1604 end = windowList.end();
1605 for (; it != end; ++it)
1606 if ((*it)->isMaximized()) (*it)->remaximize();
1607 }
1608
1609 updateWorkArea();
1610 }
1611
1612
1613 Workspace* BScreen::getWorkspace(unsigned int index) const {
1614 assert(index < workspacesList.size());
1615 return workspacesList[index];
1616 }
1617
1618
1619 void BScreen::buttonPressEvent(const XButtonEvent *xbutton) {
1620 if (xbutton->button == 1) {
1621 if (! isRootColormapInstalled())
1622 image_control->installRootColormap();
1623
1624 // mouse wheel up
1625 } else if ((xbutton->button == 4 && resource.root_scroll == NormalScroll) ||
1626 (xbutton->button == 5 && resource.root_scroll == ReverseScroll)) {
1627 if (getCurrentWorkspaceID() >= getWorkspaceCount() - 1)
1628 changeWorkspaceID(0);
1629 else
1630 changeWorkspaceID(getCurrentWorkspaceID() + 1);
1631 // mouse wheel down
1632 } else if ((xbutton->button == 5 && resource.root_scroll == NormalScroll) ||
1633 (xbutton->button == 4 && resource.root_scroll == ReverseScroll)) {
1634 if (getCurrentWorkspaceID() == 0)
1635 changeWorkspaceID(getWorkspaceCount() - 1);
1636 else
1637 changeWorkspaceID(getCurrentWorkspaceID() - 1);
1638 }
1639 }
1640
1641
1642 void BScreen::propertyNotifyEvent(const XPropertyEvent *pe) {
1643 if (pe->atom == xatom->getAtom(XAtom::net_desktop_names)) {
1644 // _NET_WM_DESKTOP_NAMES
1645 WorkspaceList::iterator it = workspacesList.begin();
1646 const WorkspaceList::iterator end = workspacesList.end();
1647 for (; it != end; ++it) {
1648 (*it)->readName(); // re-read its name from the window property
1649 //workspacemenu->changeWorkspaceLabel((*it)->getID(), (*it)->getName());
1650 }
1651 //workspacemenu->update();
1652 saveWorkspaceNames();
1653 }
1654 }
1655
1656
1657 void BScreen::toggleFocusModel(FocusModel model) {
1658 std::for_each(windowList.begin(), windowList.end(),
1659 std::mem_fun(&BlackboxWindow::ungrabButtons));
1660
1661 if (model == SloppyFocus) {
1662 saveSloppyFocus(True);
1663 } else {
1664 // we're cheating here to save writing the config file 3 times
1665 resource.auto_raise = False;
1666 resource.click_raise = False;
1667 saveSloppyFocus(False);
1668 }
1669
1670 std::for_each(windowList.begin(), windowList.end(),
1671 std::mem_fun(&BlackboxWindow::grabButtons));
1672 }
1673
1674 void BScreen::readDatabaseMask(const string &rname, PixmapMask &pixmapMask,
1675 const Configuration &style) {
1676 string s;
1677 int hx, hy; //ignored
1678 int ret = BitmapOpenFailed; //default to failure.
1679
1680 if (style.getValue(rname, s))
1681 {
1682 if (s[0] != '/' && s[0] != '~')
1683 {
1684 std::string xbmFile = std::string("~/.openbox/buttons/") + s;
1685 ret = XReadBitmapFile(otk::OBDisplay::display, getRootWindow(),
1686 expandTilde(xbmFile).c_str(), &pixmapMask.w,
1687 &pixmapMask.h, &pixmapMask.mask, &hx, &hy);
1688 } else
1689 ret = XReadBitmapFile(otk::OBDisplay::display, getRootWindow(),
1690 expandTilde(s).c_str(), &pixmapMask.w,
1691 &pixmapMask.h, &pixmapMask.mask, &hx, &hy);
1692
1693 if (ret == BitmapSuccess)
1694 return;
1695 }
1696
1697 pixmapMask.mask = None;
1698 pixmapMask.w = pixmapMask.h = 0;
1699 }
1700
1701 otk::BTexture BScreen::readDatabaseTexture(const string &rname,
1702 const string &default_color,
1703 const Configuration &style,
1704 bool allowNoTexture) {
1705 otk::BTexture texture;
1706 string s;
1707
1708 if (style.getValue(rname, s))
1709 texture = otk::BTexture(s);
1710 else if (allowNoTexture) //no default
1711 texture.setTexture(otk::BTexture::NoTexture);
1712 else
1713 texture.setTexture(otk::BTexture::Solid | otk::BTexture::Flat);
1714
1715 // associate this texture with this screen
1716 texture.setScreen(getScreenNumber());
1717 texture.setImageControl(image_control);
1718
1719 if (texture.texture() != otk::BTexture::NoTexture) {
1720 texture.setColor(readDatabaseColor(rname + ".color", default_color,
1721 style));
1722 texture.setColorTo(readDatabaseColor(rname + ".colorTo", default_color,
1723 style));
1724 texture.setBorderColor(readDatabaseColor(rname + ".borderColor",
1725 default_color, style));
1726 }
1727
1728 return texture;
1729 }
1730
1731
1732 otk::BColor BScreen::readDatabaseColor(const string &rname,
1733 const string &default_color,
1734 const Configuration &style) {
1735 otk::BColor color;
1736 string s;
1737 if (style.getValue(rname, s))
1738 color = otk::BColor(s, getScreenNumber());
1739 else
1740 color = otk::BColor(default_color, getScreenNumber());
1741 return color;
1742 }
1743
1744
1745 otk::BFont *BScreen::readDatabaseFont(const string &rbasename,
1746 const Configuration &style) {
1747 string fontname;
1748
1749 string s;
1750
1751 int i;
1752 if (style.getValue(rbasename + "xft.font", s) &&
1753 style.getValue(rbasename + "xft.size", i)) {
1754 string family = s;
1755 bool bold = False;
1756 bool italic = False;
1757 bool dropShadow = False;
1758
1759 if (style.getValue(rbasename + "xft.flags", s)) {
1760 if (s.find("bold") != string::npos)
1761 bold = True;
1762 if (s.find("italic") != string::npos)
1763 italic = True;
1764 if (s.find("shadow") != string::npos)
1765 dropShadow = True;
1766 }
1767
1768 unsigned char offset = 1;
1769 if (style.getValue(rbasename + "xft.shadow.offset", s)) {
1770 offset = atoi(s.c_str()); //doesn't detect errors
1771 if (offset > CHAR_MAX)
1772 offset = 1;
1773 }
1774
1775 unsigned char tint = 0x40;
1776 if (style.getValue(rbasename + "xft.shadow.tint", s)) {
1777 tint = atoi(s.c_str());
1778 }
1779
1780
1781 otk::BFont *b = new otk::BFont(getScreenNumber(), family, i, bold, italic,
1782 dropShadow && resource.shadow_fonts,
1783 offset, tint, resource.aa_fonts);
1784 if (b->valid())
1785 return b;
1786 delete b;
1787 }
1788
1789 exit(2); // can't continue without a font
1790 }
1791
1792 }
This page took 0.118855 seconds and 4 git commands to generate.