save the titlebarLayout in the default config
[dana/openbox.git] / src / openbox.cc
1 // openbox.cc for Openbox
2 // Copyright (c) 2001 Sean 'Shaleh' Perry <shaleh@debian.org>
3 // Copyright (c) 1997 - 2000 Brad Hughes (bhughes@tcac.net)
4 //
5 // Permission is hereby granted, free of charge, to any person obtaining a
6 // copy of this software and associated documentation files (the "Software"),
7 // to deal in the Software without restriction, including without limitation
8 // the rights to use, copy, modify, merge, publish, distribute, sublicense,
9 // and/or sell copies of the Software, and to permit persons to whom the
10 // Software is furnished to do so, subject to the following conditions:
11 //
12 // The above copyright notice and this permission notice shall be included in
13 // all copies or substantial portions of the Software.
14 //
15 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
18 // THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
20 // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
21 // DEALINGS IN THE SOFTWARE.
22
23 // stupid macros needed to access some functions in version 2 of the GNU C
24 // library
25 #ifndef   _GNU_SOURCE
26 #define   _GNU_SOURCE
27 #endif // _GNU_SOURCE
28
29 #ifdef    HAVE_CONFIG_H
30 #  include "../config.h"
31 #endif // HAVE_CONFIG_H
32
33 #include <X11/Xlib.h>
34 #include <X11/Xutil.h>
35 #include <X11/Xresource.h>
36 #include <X11/Xatom.h>
37 #include <X11/keysym.h>
38
39 #ifdef    SHAPE
40 #include <X11/extensions/shape.h>
41 #endif // SHAPE
42
43 #include "i18n.h"
44 #include "openbox.h"
45 #include "Basemenu.h"
46 #include "Clientmenu.h"
47 #include "Rootmenu.h"
48 #include "Screen.h"
49
50 #ifdef    SLIT
51 #include "Slit.h"
52 #endif // SLIT
53
54 #include "Toolbar.h"
55 #include "Window.h"
56 #include "Workspace.h"
57 #include "Workspacemenu.h"
58 #include "Util.h"
59
60 #include <string>
61 #include <algorithm>
62
63 #ifdef    HAVE_STDIO_H
64 #  include <stdio.h>
65 #endif // HAVE_STDIO_H
66
67 #ifdef    HAVE_STDLIB_H
68 #  include <stdlib.h>
69 #endif // HAVE_STDLIB_H
70
71 #ifdef    HAVE_STRING_H
72 #  include <string.h>
73 #endif // HAVE_STRING_H
74
75 #ifdef    HAVE_UNISTD_H
76 #  include <sys/types.h>
77 #  include <unistd.h>
78 #endif // HAVE_UNISTD_H
79
80 #ifdef    HAVE_SYS_PARAM_H
81 #  include <sys/param.h>
82 #endif // HAVE_SYS_PARAM_H
83
84 #ifndef   MAXPATHLEN
85 #define   MAXPATHLEN 255
86 #endif // MAXPATHLEN
87
88 #ifdef    HAVE_SYS_SELECT_H
89 #  include <sys/select.h>
90 #endif // HAVE_SYS_SELECT_H
91
92 #ifdef    HAVE_SIGNAL_H
93 #  include <signal.h>
94 #endif // HAVE_SIGNAL_H
95
96 #ifdef    HAVE_SYS_SIGNAL_H
97 #  include <sys/signal.h>
98 #endif // HAVE_SYS_SIGNAL_H
99
100 #ifdef    HAVE_SYS_STAT_H
101 #  include <sys/types.h>
102 #  include <sys/stat.h>
103 #endif // HAVE_SYS_STAT_H
104
105 #ifdef    TIME_WITH_SYS_TIME
106 #  include <sys/time.h>
107 #  include <time.h>
108 #else // !TIME_WITH_SYS_TIME
109 #  ifdef    HAVE_SYS_TIME_H
110 #    include <sys/time.h>
111 #  else // !HAVE_SYS_TIME_H
112 #    include <time.h>
113 #  endif // HAVE_SYS_TIME_H
114 #endif // TIME_WITH_SYS_TIME
115
116 #ifdef    HAVE_LIBGEN_H
117 #  include <libgen.h>
118 #endif // HAVE_LIBGEN_H
119
120 #ifndef   HAVE_BASENAME
121 static inline char *basename (char *s) {
122   char *save = s;
123
124   while (*s) if (*s++ == '/') save = s;
125
126   return save;
127 }
128 #endif // HAVE_BASENAME
129
130
131 // X event scanner for enter/leave notifies - adapted from twm
132 typedef struct scanargs {
133   Window w;
134   Bool leave, inferior, enter;
135 } scanargs;
136
137 static Bool queueScanner(Display *, XEvent *e, char *args) {
138   if ((e->type == LeaveNotify) &&
139       (e->xcrossing.window == ((scanargs *) args)->w) &&
140       (e->xcrossing.mode == NotifyNormal)) {
141     ((scanargs *) args)->leave = True;
142     ((scanargs *) args)->inferior = (e->xcrossing.detail == NotifyInferior);
143   } else if ((e->type == EnterNotify) &&
144              (e->xcrossing.mode == NotifyUngrab)) {
145     ((scanargs *) args)->enter = True;
146   }
147
148   return False;
149 }
150
151 Openbox *openbox;
152
153
154 Openbox::Openbox(int m_argc, char **m_argv, char *dpy_name, char *rc)
155   : BaseDisplay(m_argv[0], dpy_name) {
156   grab();
157
158   if (! XSupportsLocale())
159     fprintf(stderr, "X server does not support locale\n");
160
161   if (XSetLocaleModifiers("") == NULL)
162     fprintf(stderr, "cannot set locale modifiers\n");
163
164   ::openbox = this;
165   argc = m_argc;
166   argv = m_argv;
167   if (rc == NULL) {
168     char *homedir = getenv("HOME");
169
170     rc_file = new char[strlen(homedir) + strlen("/.openbox/rc") + 1];
171     sprintf(rc_file, "%s/.openbox", homedir);
172
173     // try to make sure the ~/.openbox directory exists
174     mkdir(rc_file, S_IREAD | S_IWRITE | S_IEXEC | S_IRGRP | S_IWGRP | S_IXGRP |
175           S_IROTH | S_IWOTH | S_IXOTH);
176     
177     sprintf(rc_file, "%s/.openbox/rc", homedir);
178   } else {
179     rc_file = bstrdup(rc);
180   }
181   config.setFile(rc_file);
182
183   no_focus = False;
184
185   resource.menu_file = resource.style_file = NULL;
186   resource.titlebar_layout = NULL;
187   resource.auto_raise_delay.tv_sec = resource.auto_raise_delay.tv_usec = 0;
188
189   focused_window = masked_window = NULL;
190   masked = None;
191
192   windowSearchList = new LinkedList<WindowSearch>;
193   menuSearchList = new LinkedList<MenuSearch>;
194
195 #ifdef    SLIT
196   slitSearchList = new LinkedList<SlitSearch>;
197 #endif // SLIT
198
199   toolbarSearchList = new LinkedList<ToolbarSearch>;
200   groupSearchList = new LinkedList<WindowSearch>;
201
202   menuTimestamps = new LinkedList<MenuTimestamp>;
203
204   load();
205
206 #ifdef    HAVE_GETPID
207   openbox_pid = XInternAtom(getXDisplay(), "_BLACKBOX_PID", False);
208 #endif // HAVE_GETPID
209
210   screenList = new LinkedList<BScreen>;
211   for (int i = 0; i < getNumberOfScreens(); i++) {
212     BScreen *screen = new BScreen(*this, i, config);
213
214     if (! screen->isScreenManaged()) {
215       delete screen;
216       continue;
217     }
218
219     screenList->insert(screen);
220   }
221
222   if (! screenList->count()) {
223     fprintf(stderr,
224             i18n->getMessage(openboxSet, openboxNoManagableScreens,
225                "Openbox::Openbox: no managable screens found, aborting.\n"));
226     ::exit(3);
227   }
228
229   // save current settings and default values
230   save();
231   
232   XSynchronize(getXDisplay(), False);
233   XSync(getXDisplay(), False);
234
235   reconfigure_wait = reread_menu_wait = False;
236
237   timer = new BTimer(*this, *this);
238   timer->setTimeout(0);
239   timer->fireOnce(True);
240
241   ungrab();
242 }
243
244
245 Openbox::~Openbox() {
246   while (screenList->count())
247     delete screenList->remove(0);
248
249   while (menuTimestamps->count()) {
250     MenuTimestamp *ts = menuTimestamps->remove(0);
251
252     if (ts->filename)
253       delete [] ts->filename;
254
255     delete ts;
256   }
257
258   if (resource.menu_file)
259     delete [] resource.menu_file;
260
261   if (resource.style_file)
262     delete [] resource.style_file;
263
264   if (resource.titlebar_layout)
265     delete [] resource.titlebar_layout;
266
267   delete timer;
268
269   delete screenList;
270   delete menuTimestamps;
271
272   delete windowSearchList;
273   delete menuSearchList;
274   delete toolbarSearchList;
275   delete groupSearchList;
276
277   delete [] rc_file;
278
279 #ifdef    SLIT
280   delete slitSearchList;
281 #endif // SLIT
282 }
283
284
285 void Openbox::process_event(XEvent *e) {
286   if ((masked == e->xany.window) && masked_window &&
287       (e->type == MotionNotify)) {
288     last_time = e->xmotion.time;
289     masked_window->motionNotifyEvent(&e->xmotion);
290
291     return;
292   }
293
294   switch (e->type) {
295   case ButtonPress: {
296     // strip the lock key modifiers
297     e->xbutton.state &= ~(NumLockMask | ScrollLockMask | LockMask);
298
299     last_time = e->xbutton.time;
300
301     OpenboxWindow *win = (OpenboxWindow *) 0;
302     Basemenu *menu = (Basemenu *) 0;
303
304 #ifdef    SLIT
305     Slit *slit = (Slit *) 0;
306 #endif // SLIT
307
308     Toolbar *tbar = (Toolbar *) 0;
309
310     if ((win = searchWindow(e->xbutton.window))) {
311       win->buttonPressEvent(&e->xbutton);
312
313       if (e->xbutton.button == 1)
314         win->installColormap(True);
315     } else if ((menu = searchMenu(e->xbutton.window))) {
316       menu->buttonPressEvent(&e->xbutton);
317
318 #ifdef    SLIT
319     } else if ((slit = searchSlit(e->xbutton.window))) {
320       slit->buttonPressEvent(&e->xbutton);
321 #endif // SLIT
322
323     } else if ((tbar = searchToolbar(e->xbutton.window))) {
324       tbar->buttonPressEvent(&e->xbutton);
325     } else {
326       LinkedListIterator<BScreen> it(screenList);
327       BScreen *screen = it.current();
328       for (; screen; it++, screen = it.current()) {
329         if (e->xbutton.window == screen->getRootWindow()) {
330           if (e->xbutton.button == 1) {
331             if (! screen->isRootColormapInstalled())
332               screen->getImageControl()->installRootColormap();
333
334             if (screen->getWorkspacemenu()->isVisible())
335               screen->getWorkspacemenu()->hide();
336
337             if (screen->getRootmenu()->isVisible())
338               screen->getRootmenu()->hide();
339           } else if (e->xbutton.button == 2) {
340             int mx = e->xbutton.x_root -
341               (screen->getWorkspacemenu()->getWidth() / 2);
342             int my = e->xbutton.y_root -
343               (screen->getWorkspacemenu()->getTitleHeight() / 2);
344
345             if (mx < 0) mx = 0;
346             if (my < 0) my = 0;
347
348             if (mx + screen->getWorkspacemenu()->getWidth() >
349                 screen->size().w())
350               mx = screen->size().w() -
351                 screen->getWorkspacemenu()->getWidth() -
352                 screen->getBorderWidth();
353
354             if (my + screen->getWorkspacemenu()->getHeight() >
355                 screen->size().h())
356               my = screen->size().h() -
357                 screen->getWorkspacemenu()->getHeight() -
358                 screen->getBorderWidth();
359
360             screen->getWorkspacemenu()->move(mx, my);
361
362             if (! screen->getWorkspacemenu()->isVisible()) {
363               screen->getWorkspacemenu()->removeParent();
364               screen->getWorkspacemenu()->show();
365             }
366           } else if (e->xbutton.button == 3) {
367             int mx = e->xbutton.x_root -
368               (screen->getRootmenu()->getWidth() / 2);
369             int my = e->xbutton.y_root -
370               (screen->getRootmenu()->getTitleHeight() / 2);
371
372             if (mx < 0) mx = 0;
373             if (my < 0) my = 0;
374
375             if (mx + screen->getRootmenu()->getWidth() > screen->size().w())
376               mx = screen->size().w() -
377                 screen->getRootmenu()->getWidth() -
378                 screen->getBorderWidth();
379
380             if (my + screen->getRootmenu()->getHeight() > screen->size().h())
381                 my = screen->size().h() -
382                   screen->getRootmenu()->getHeight() -
383                   screen->getBorderWidth();
384
385             screen->getRootmenu()->move(mx, my);
386
387             if (! screen->getRootmenu()->isVisible()) {
388               checkMenu();
389               screen->getRootmenu()->show();
390             }
391           } else if (e->xbutton.button == 4) {
392             if ((screen->getCurrentWorkspaceID() + 1) >
393                 screen->getWorkspaceCount() - 1)
394               screen->changeWorkspaceID(0);
395             else
396               screen->changeWorkspaceID(screen->getCurrentWorkspaceID() + 1);
397           } else if (e->xbutton.button == 5) {
398             if ((screen->getCurrentWorkspaceID() - 1) < 0)
399               screen->changeWorkspaceID(screen->getWorkspaceCount() - 1);
400             else
401               screen->changeWorkspaceID(screen->getCurrentWorkspaceID() - 1);
402           }
403         }
404       }
405     }
406
407     break;
408   }
409
410   case ButtonRelease: {
411     // strip the lock key modifiers
412     e->xbutton.state &= ~(NumLockMask | ScrollLockMask | LockMask);
413
414     last_time = e->xbutton.time;
415
416     OpenboxWindow *win = (OpenboxWindow *) 0;
417     Basemenu *menu = (Basemenu *) 0;
418     Toolbar *tbar = (Toolbar *) 0;
419
420     if ((win = searchWindow(e->xbutton.window)))
421       win->buttonReleaseEvent(&e->xbutton);
422     else if ((menu = searchMenu(e->xbutton.window)))
423       menu->buttonReleaseEvent(&e->xbutton);
424     else if ((tbar = searchToolbar(e->xbutton.window)))
425       tbar->buttonReleaseEvent(&e->xbutton);
426
427     break;
428   }
429
430   case ConfigureRequest: {
431     OpenboxWindow *win = (OpenboxWindow *) 0;
432
433 #ifdef    SLIT
434     Slit *slit = (Slit *) 0;
435 #endif // SLIT
436
437     if ((win = searchWindow(e->xconfigurerequest.window))) {
438       win->configureRequestEvent(&e->xconfigurerequest);
439
440 #ifdef    SLIT
441     } else if ((slit = searchSlit(e->xconfigurerequest.window))) {
442       slit->configureRequestEvent(&e->xconfigurerequest);
443 #endif // SLIT
444
445     } else {
446       grab();
447
448       if (validateWindow(e->xconfigurerequest.window)) {
449         XWindowChanges xwc;
450
451         xwc.x = e->xconfigurerequest.x;
452         xwc.y = e->xconfigurerequest.y;
453         xwc.width = e->xconfigurerequest.width;
454         xwc.height = e->xconfigurerequest.height;
455         xwc.border_width = e->xconfigurerequest.border_width;
456         xwc.sibling = e->xconfigurerequest.above;
457         xwc.stack_mode = e->xconfigurerequest.detail;
458
459         XConfigureWindow(getXDisplay(), e->xconfigurerequest.window,
460                          e->xconfigurerequest.value_mask, &xwc);
461       }
462
463       ungrab();
464     }
465
466     break;
467   }
468
469   case MapRequest: {
470 #ifdef    DEBUG
471     fprintf(stderr,
472             i18n->getMessage(openboxSet, openboxMapRequest,
473                  "Openbox::process_event(): MapRequest for 0x%lx\n"),
474             e->xmaprequest.window);
475 #endif // DEBUG
476
477     OpenboxWindow *win = searchWindow(e->xmaprequest.window);
478
479     if (! win)
480       win = new OpenboxWindow(*this, e->xmaprequest.window);
481
482     if ((win = searchWindow(e->xmaprequest.window)))
483       win->mapRequestEvent(&e->xmaprequest);
484
485     break;
486   }
487
488   case MapNotify: {
489     OpenboxWindow *win = searchWindow(e->xmap.window);
490
491     if (win)
492       win->mapNotifyEvent(&e->xmap);
493
494       break;
495   }
496
497   case UnmapNotify: {
498     OpenboxWindow *win = (OpenboxWindow *) 0;
499
500 #ifdef    SLIT
501     Slit *slit = (Slit *) 0;
502 #endif // SLIT
503
504     if ((win = searchWindow(e->xunmap.window))) {
505       win->unmapNotifyEvent(&e->xunmap);
506       if (focused_window == win)
507         focused_window = (OpenboxWindow *) 0;
508 #ifdef    SLIT
509     } else if ((slit = searchSlit(e->xunmap.window))) {
510       slit->removeClient(e->xunmap.window);
511 #endif // SLIT
512
513     }
514
515     break;
516   }
517
518   case DestroyNotify: {
519     OpenboxWindow *win = (OpenboxWindow *) 0;
520
521 #ifdef    SLIT
522     Slit *slit = (Slit *) 0;
523 #endif // SLIT
524
525     if ((win = searchWindow(e->xdestroywindow.window))) {
526       win->destroyNotifyEvent(&e->xdestroywindow);
527       if (focused_window == win)
528         focused_window = (OpenboxWindow *) 0;
529 #ifdef    SLIT
530     } else if ((slit = searchSlit(e->xdestroywindow.window))) {
531       slit->removeClient(e->xdestroywindow.window, False);
532 #endif // SLIT
533     }
534
535     break;
536   }
537
538   case MotionNotify: {
539     // strip the lock key modifiers
540     e->xbutton.state &= ~(NumLockMask | ScrollLockMask | LockMask);
541     
542     last_time = e->xmotion.time;
543
544     OpenboxWindow *win = (OpenboxWindow *) 0;
545     Basemenu *menu = (Basemenu *) 0;
546
547     if ((win = searchWindow(e->xmotion.window)))
548       win->motionNotifyEvent(&e->xmotion);
549     else if ((menu = searchMenu(e->xmotion.window)))
550       menu->motionNotifyEvent(&e->xmotion);
551
552     break;
553   }
554
555   case PropertyNotify: {
556     last_time = e->xproperty.time;
557
558     if (e->xproperty.state != PropertyDelete) {
559       OpenboxWindow *win = searchWindow(e->xproperty.window);
560
561       if (win)
562         win->propertyNotifyEvent(e->xproperty.atom);
563     }
564
565     break;
566   }
567
568   case EnterNotify: {
569     last_time = e->xcrossing.time;
570
571     BScreen *screen = (BScreen *) 0;
572     OpenboxWindow *win = (OpenboxWindow *) 0;
573     Basemenu *menu = (Basemenu *) 0;
574     Toolbar *tbar = (Toolbar *) 0;
575
576 #ifdef    SLIT
577     Slit *slit = (Slit *) 0;
578 #endif // SLIT
579
580     if (e->xcrossing.mode == NotifyGrab) break;
581
582     XEvent dummy;
583     scanargs sa;
584     sa.w = e->xcrossing.window;
585     sa.enter = sa.leave = False;
586     XCheckIfEvent(getXDisplay(), &dummy, queueScanner, (char *) &sa);
587
588     if ((e->xcrossing.window == e->xcrossing.root) &&
589         (screen = searchScreen(e->xcrossing.window))) {
590       screen->getImageControl()->installRootColormap();
591     } else if ((win = searchWindow(e->xcrossing.window))) {
592       if (win->getScreen()->sloppyFocus() &&
593           (! win->isFocused()) && (! no_focus)) {
594         grab();
595
596         if (((! sa.leave) || sa.inferior) && win->isVisible() &&
597             win->setInputFocus())
598           win->installColormap(True);
599
600         ungrab();
601       }
602     } else if ((menu = searchMenu(e->xcrossing.window))) {
603       menu->enterNotifyEvent(&e->xcrossing);
604     } else if ((tbar = searchToolbar(e->xcrossing.window))) {
605       tbar->enterNotifyEvent(&e->xcrossing);
606 #ifdef    SLIT
607     } else if ((slit = searchSlit(e->xcrossing.window))) {
608       slit->enterNotifyEvent(&e->xcrossing);
609 #endif // SLIT
610     }
611     break;
612   }
613
614   case LeaveNotify: {
615     last_time = e->xcrossing.time;
616
617     OpenboxWindow *win = (OpenboxWindow *) 0;
618     Basemenu *menu = (Basemenu *) 0;
619     Toolbar *tbar = (Toolbar *) 0;
620
621 #ifdef    SLIT
622     Slit *slit = (Slit *) 0;
623 #endif // SLIT
624
625     if ((menu = searchMenu(e->xcrossing.window)))
626       menu->leaveNotifyEvent(&e->xcrossing);
627     else if ((win = searchWindow(e->xcrossing.window)))
628       win->installColormap(False);
629     else if ((tbar = searchToolbar(e->xcrossing.window)))
630       tbar->leaveNotifyEvent(&e->xcrossing);
631 #ifdef    SLIT
632     else if ((slit = searchSlit(e->xcrossing.window)))
633       slit->leaveNotifyEvent(&e->xcrossing);
634 #endif // SLIT
635
636     break;
637   }
638
639   case Expose: {
640     OpenboxWindow *win = (OpenboxWindow *) 0;
641     Basemenu *menu = (Basemenu *) 0;
642     Toolbar *tbar = (Toolbar *) 0;
643
644     if ((win = searchWindow(e->xexpose.window)))
645       win->exposeEvent(&e->xexpose);
646     else if ((menu = searchMenu(e->xexpose.window)))
647       menu->exposeEvent(&e->xexpose);
648     else if ((tbar = searchToolbar(e->xexpose.window)))
649       tbar->exposeEvent(&e->xexpose);
650
651     break;
652   }
653
654   case KeyPress: {
655     Toolbar *tbar = searchToolbar(e->xkey.window);
656
657     if (tbar && tbar->isEditing())
658       tbar->keyPressEvent(&e->xkey);
659
660     break;
661   }
662
663   case ColormapNotify: {
664     BScreen *screen = searchScreen(e->xcolormap.window);
665
666     if (screen)
667       screen->setRootColormapInstalled((e->xcolormap.state ==
668                                         ColormapInstalled) ? True : False);
669
670     break;
671   }
672
673   case FocusIn: {
674     if (e->xfocus.mode == NotifyUngrab || e->xfocus.detail == NotifyPointer)
675       break;
676
677     OpenboxWindow *win = searchWindow(e->xfocus.window);
678     if (win && ! win->isFocused())
679       setFocusedWindow(win);
680
681     break;
682   }
683
684   case FocusOut:
685     break;
686
687   case ClientMessage: {
688     if (e->xclient.format == 32) {
689       if (e->xclient.message_type == getWMChangeStateAtom()) {
690         OpenboxWindow *win = searchWindow(e->xclient.window);
691         if (! win || ! win->validateClient()) return;
692
693         if (e->xclient.data.l[0] == IconicState)
694           win->iconify();
695         if (e->xclient.data.l[0] == NormalState)
696           win->deiconify();
697       } else if (e->xclient.message_type == getOpenboxChangeWorkspaceAtom()) {
698         BScreen *screen = searchScreen(e->xclient.window);
699
700         if (screen && e->xclient.data.l[0] >= 0 &&
701             e->xclient.data.l[0] < screen->getWorkspaceCount())
702           screen->changeWorkspaceID(e->xclient.data.l[0]);
703       } else if (e->xclient.message_type == getOpenboxChangeWindowFocusAtom()) {
704         OpenboxWindow *win = searchWindow(e->xclient.window);
705
706         if (win && win->isVisible() && win->setInputFocus())
707           win->installColormap(True);
708       } else if (e->xclient.message_type == getOpenboxCycleWindowFocusAtom()) {
709         BScreen *screen = searchScreen(e->xclient.window);
710
711         if (screen) {
712           if (! e->xclient.data.l[0])
713             screen->prevFocus();
714           else
715             screen->nextFocus();
716         }
717       } else if (e->xclient.message_type == getOpenboxChangeAttributesAtom()) {
718         OpenboxWindow *win = searchWindow(e->xclient.window);
719
720         if (win && win->validateClient()) {
721           OpenboxHints net;
722           net.flags = e->xclient.data.l[0];
723           net.attrib = e->xclient.data.l[1];
724           net.workspace = e->xclient.data.l[2];
725           net.stack = e->xclient.data.l[3];
726           net.decoration = e->xclient.data.l[4];
727
728           win->changeOpenboxHints(&net);
729         }
730       }
731     }
732
733     break;
734   }
735
736
737   default: {
738 #ifdef    SHAPE
739     if (e->type == getShapeEventBase()) {
740       XShapeEvent *shape_event = (XShapeEvent *) e;
741       OpenboxWindow *win = (OpenboxWindow *) 0;
742
743       if ((win = searchWindow(e->xany.window)) ||
744           (shape_event->kind != ShapeBounding))
745         win->shapeEvent(shape_event);
746     }
747 #endif // SHAPE
748
749   }
750   } // switch
751 }
752
753
754 Bool Openbox::handleSignal(int sig) {
755   switch (sig) {
756   case SIGHUP:
757   case SIGUSR1:
758     reconfigure();
759     break;
760
761   case SIGUSR2:
762     rereadMenu();
763     break;
764
765   case SIGPIPE:
766   case SIGSEGV:
767   case SIGFPE:
768   case SIGINT:
769   case SIGTERM:
770     shutdown();
771
772   default:
773     return False;
774   }
775
776   return True;
777 }
778
779
780 BScreen *Openbox::searchScreen(Window window) {
781   LinkedListIterator<BScreen> it(screenList);
782
783   for (BScreen *curr = it.current(); curr; it++, curr = it.current()) {
784     if (curr->getRootWindow() == window) {
785       return curr;
786     }
787   }
788
789   return (BScreen *) 0;
790 }
791
792
793 OpenboxWindow *Openbox::searchWindow(Window window) {
794   LinkedListIterator<WindowSearch> it(windowSearchList);
795
796   for (WindowSearch *tmp = it.current(); tmp; it++, tmp = it.current()) {
797       if (tmp->getWindow() == window) {
798         return tmp->getData();
799       }
800   }
801
802   return (OpenboxWindow *) 0;
803 }
804
805
806 OpenboxWindow *Openbox::searchGroup(Window window, OpenboxWindow *win) {
807   OpenboxWindow *w = (OpenboxWindow *) 0;
808   LinkedListIterator<WindowSearch> it(groupSearchList);
809
810   for (WindowSearch *tmp = it.current(); tmp; it++, tmp = it.current()) {
811     if (tmp->getWindow() == window) {
812       w = tmp->getData();
813       if (w->getClientWindow() != win->getClientWindow())
814         return win;
815     }
816   }
817
818   return (OpenboxWindow *) 0;
819 }
820
821
822 Basemenu *Openbox::searchMenu(Window window) {
823   LinkedListIterator<MenuSearch> it(menuSearchList);
824
825   for (MenuSearch *tmp = it.current(); tmp; it++, tmp = it.current()) {
826     if (tmp->getWindow() == window)
827       return tmp->getData();
828   }
829
830   return (Basemenu *) 0;
831 }
832
833
834 Toolbar *Openbox::searchToolbar(Window window) {
835   LinkedListIterator<ToolbarSearch> it(toolbarSearchList);
836
837   for (ToolbarSearch *tmp = it.current(); tmp; it++, tmp = it.current()) {
838     if (tmp->getWindow() == window)
839       return tmp->getData();
840   }
841
842   return (Toolbar *) 0;
843 }
844
845
846 #ifdef    SLIT
847 Slit *Openbox::searchSlit(Window window) {
848   LinkedListIterator<SlitSearch> it(slitSearchList);
849
850   for (SlitSearch *tmp = it.current(); tmp; it++, tmp = it.current()) {
851     if (tmp->getWindow() == window)
852       return tmp->getData();
853   }
854
855   return (Slit *) 0;
856 }
857 #endif // SLIT
858
859
860 void Openbox::saveWindowSearch(Window window, OpenboxWindow *data) {
861   windowSearchList->insert(new WindowSearch(window, data));
862 }
863
864
865 void Openbox::saveGroupSearch(Window window, OpenboxWindow *data) {
866   groupSearchList->insert(new WindowSearch(window, data));
867 }
868
869
870 void Openbox::saveMenuSearch(Window window, Basemenu *data) {
871   menuSearchList->insert(new MenuSearch(window, data));
872 }
873
874
875 void Openbox::saveToolbarSearch(Window window, Toolbar *data) {
876   toolbarSearchList->insert(new ToolbarSearch(window, data));
877 }
878
879
880 #ifdef    SLIT
881 void Openbox::saveSlitSearch(Window window, Slit *data) {
882   slitSearchList->insert(new SlitSearch(window, data));
883 }
884 #endif // SLIT
885
886
887 void Openbox::removeWindowSearch(Window window) {
888   LinkedListIterator<WindowSearch> it(windowSearchList);
889   for (WindowSearch *tmp = it.current(); tmp; it++, tmp = it.current()) {
890     if (tmp->getWindow() == window) {
891       windowSearchList->remove(tmp);
892       delete tmp;
893       break;
894     }
895   }
896 }
897
898
899 void Openbox::removeGroupSearch(Window window) {
900   LinkedListIterator<WindowSearch> it(groupSearchList);
901   for (WindowSearch *tmp = it.current(); tmp; it++, tmp = it.current()) {
902     if (tmp->getWindow() == window) {
903       groupSearchList->remove(tmp);
904       delete tmp;
905       break;
906     }
907   }
908 }
909
910
911 void Openbox::removeMenuSearch(Window window) {
912   LinkedListIterator<MenuSearch> it(menuSearchList);
913   for (MenuSearch *tmp = it.current(); tmp; it++, tmp = it.current()) {
914     if (tmp->getWindow() == window) {
915       menuSearchList->remove(tmp);
916       delete tmp;
917       break;
918     }
919   }
920 }
921
922
923 void Openbox::removeToolbarSearch(Window window) {
924   LinkedListIterator<ToolbarSearch> it(toolbarSearchList);
925   for (ToolbarSearch *tmp = it.current(); tmp; it++, tmp = it.current()) {
926     if (tmp->getWindow() == window) {
927       toolbarSearchList->remove(tmp);
928       delete tmp;
929       break;
930     }
931   }
932 }
933
934
935 #ifdef    SLIT
936 void Openbox::removeSlitSearch(Window window) {
937   LinkedListIterator<SlitSearch> it(slitSearchList);
938   for (SlitSearch *tmp = it.current(); tmp; it++, tmp = it.current()) {
939     if (tmp->getWindow() == window) {
940       slitSearchList->remove(tmp);
941       delete tmp;
942       break;
943     }
944   }
945 }
946 #endif // SLIT
947
948
949 void Openbox::restart(const char *prog) {
950   shutdown();
951
952   if (prog) {
953     execlp(prog, prog, NULL);
954     perror(prog);
955   }
956
957   // fall back in case the above execlp doesn't work
958   execvp(argv[0], argv);
959   execvp(basename(argv[0]), argv);
960 }
961
962
963 void Openbox::shutdown() {
964   BaseDisplay::shutdown();
965
966   XSetInputFocus(getXDisplay(), PointerRoot, None, CurrentTime);
967
968   LinkedListIterator<BScreen> it(screenList);
969   for (BScreen *s = it.current(); s; it++, s = it.current())
970     s->shutdown();
971
972   XSync(getXDisplay(), False);
973 }
974
975
976 void Openbox::save() {
977   config.setAutoSave(false);
978   
979   // save all values as they are so that the defaults will be written to the rc
980   // file
981   
982   config.setValue("session.menuFile", getMenuFilename());
983   config.setValue("session.colorsPerChannel",
984                   resource.colors_per_channel);
985   config.setValue("session.styleFile", resource.style_file);
986   config.setValue("session.titlebarLayout", resource.titlebar_layout);
987   config.setValue("session.doubleClickInterval",
988                   (long)resource.double_click_interval);
989   config.setValue("session.autoRaiseDelay",
990           ((resource.auto_raise_delay.tv_sec * 1000) +
991            (resource.auto_raise_delay.tv_usec / 1000)));
992   config.setValue("session.cacheLife", (long)resource.cache_life / 60000);
993   config.setValue("session.cacheMax", (long)resource.cache_max);
994
995   LinkedListIterator<BScreen> it(screenList);
996   for (BScreen *s = it.current(); s != NULL; it++, s = it.current()) {
997     s->save();
998     s->getToolbar()->save();
999 #ifdef    SLIT
1000     s->getSlit()->save();
1001 #endif // SLIT
1002   }
1003
1004   config.setAutoSave(true);
1005   config.save();
1006 }
1007
1008 void Openbox::load() {
1009   if (!config.load())
1010     config.create();
1011
1012   std::string s;
1013   long l;
1014   
1015   if (resource.menu_file)
1016     delete [] resource.menu_file;
1017   if (config.getValue("session.menuFile", "Session.MenuFile", s))
1018     resource.menu_file = bstrdup(s.c_str());
1019   else
1020     resource.menu_file = bstrdup(DEFAULTMENU);
1021
1022   if (config.getValue("session.colorsPerChannel", "Session.ColorsPerChannel",
1023                       l))
1024     resource.colors_per_channel = (l < 2 ? 2 : (l > 6 ? 6 : l)); // >= 2, <= 6
1025   else
1026     resource.colors_per_channel = 4;
1027
1028   if (resource.style_file)
1029     delete [] resource.style_file;
1030   if (config.getValue("session.styleFile", "Session.StyleFile", s))
1031     resource.style_file = bstrdup(s.c_str());
1032   else
1033     resource.style_file = bstrdup(DEFAULTSTYLE);
1034
1035   if (resource.titlebar_layout)
1036     delete [] resource.titlebar_layout;
1037   if (config.getValue("session.titlebarLayout", "Session.TitlebarLayout", s))
1038     resource.titlebar_layout = bstrdup(s.c_str());
1039   else
1040     resource.titlebar_layout = bstrdup("ILMC");
1041
1042   if (config.getValue("session.doubleClickInterval",
1043                       "Session.DoubleClickInterval", l))
1044     resource.double_click_interval = l;
1045   else
1046     resource.double_click_interval = 250;
1047
1048   if (!config.getValue("session.autoRaiseDelay", "Session.AutoRaiseDelay", l))
1049     resource.auto_raise_delay.tv_usec = l;
1050   else
1051     resource.auto_raise_delay.tv_usec = 400;
1052   resource.auto_raise_delay.tv_sec = resource.auto_raise_delay.tv_usec / 1000;
1053   resource.auto_raise_delay.tv_usec -=
1054     (resource.auto_raise_delay.tv_sec * 1000);
1055   resource.auto_raise_delay.tv_usec *= 1000;
1056
1057   if (config.getValue("session.cacheLife", "Session.CacheLife", l))
1058     resource.cache_life = l;
1059   else
1060     resource.cache_life = 51;
1061   resource.cache_life *= 60000;
1062
1063   if (config.getValue("session.cacheMax", "Session.CacheMax", l))
1064     resource.cache_max = l;
1065   else
1066     resource.cache_max = 200;
1067 }
1068
1069
1070 void Openbox::reconfigure() {
1071   reconfigure_wait = True;
1072
1073   if (! timer->isTiming()) timer->start();
1074 }
1075
1076
1077 void Openbox::real_reconfigure() {
1078   grab();
1079
1080   load();
1081   
1082   for (int i = 0, n = menuTimestamps->count(); i < n; i++) {
1083     MenuTimestamp *ts = menuTimestamps->remove(0);
1084
1085     if (ts) {
1086       if (ts->filename)
1087         delete [] ts->filename;
1088
1089       delete ts;
1090     }
1091   }
1092
1093   LinkedListIterator<BScreen> it(screenList);
1094   for (BScreen *screen = it.current(); screen; it++, screen = it.current()) {
1095     screen->reconfigure();
1096   }
1097
1098   ungrab();
1099 }
1100
1101
1102 void Openbox::checkMenu() {
1103   Bool reread = False;
1104   LinkedListIterator<MenuTimestamp> it(menuTimestamps);
1105   for (MenuTimestamp *tmp = it.current(); tmp && (! reread);
1106        it++, tmp = it.current()) {
1107     struct stat buf;
1108
1109     if (! stat(tmp->filename, &buf)) {
1110       if (tmp->timestamp != buf.st_ctime)
1111         reread = True;
1112     } else {
1113       reread = True;
1114     }
1115   }
1116
1117   if (reread) rereadMenu();
1118 }
1119
1120
1121 void Openbox::rereadMenu() {
1122   reread_menu_wait = True;
1123
1124   if (! timer->isTiming()) timer->start();
1125 }
1126
1127
1128 void Openbox::real_rereadMenu() {
1129   for (int i = 0, n = menuTimestamps->count(); i < n; i++) {
1130     MenuTimestamp *ts = menuTimestamps->remove(0);
1131
1132     if (ts) {
1133       if (ts->filename)
1134         delete [] ts->filename;
1135
1136       delete ts;
1137     }
1138   }
1139
1140   LinkedListIterator<BScreen> it(screenList);
1141   for (BScreen *screen = it.current(); screen; it++, screen = it.current())
1142     screen->rereadMenu();
1143 }
1144
1145
1146 void Openbox::setStyleFilename(const char *filename) {
1147   if (resource.style_file)
1148     delete [] resource.style_file;
1149
1150   resource.style_file = bstrdup(filename);
1151   config.setValue("session.styleFile", resource.style_file);
1152 }
1153
1154
1155 void Openbox::setMenuFilename(const char *filename) {
1156   Bool found = False;
1157
1158   LinkedListIterator<MenuTimestamp> it(menuTimestamps);
1159   for (MenuTimestamp *tmp = it.current(); tmp && (! found);
1160        it++, tmp = it.current()) {
1161     if (! strcmp(tmp->filename, filename)) found = True;
1162   }
1163   if (! found) {
1164     struct stat buf;
1165
1166     if (! stat(filename, &buf)) {
1167       MenuTimestamp *ts = new MenuTimestamp;
1168
1169       ts->filename = bstrdup(filename);
1170       ts->timestamp = buf.st_ctime;
1171
1172       menuTimestamps->insert(ts);
1173     }
1174   }
1175 }
1176
1177
1178 void Openbox::timeout() {
1179   if (reconfigure_wait)
1180     real_reconfigure();
1181
1182   if (reread_menu_wait)
1183     real_rereadMenu();
1184
1185   reconfigure_wait = reread_menu_wait = False;
1186 }
1187
1188
1189 void Openbox::setFocusedWindow(OpenboxWindow *win) {
1190   BScreen *old_screen = (BScreen *) 0, *screen = (BScreen *) 0;
1191   OpenboxWindow *old_win = (OpenboxWindow *) 0;
1192   Toolbar *old_tbar = (Toolbar *) 0, *tbar = (Toolbar *) 0;
1193   Workspace *old_wkspc = (Workspace *) 0, *wkspc = (Workspace *) 0;
1194
1195   if (focused_window) {
1196     old_win = focused_window;
1197     old_screen = old_win->getScreen();
1198     old_tbar = old_screen->getToolbar();
1199     old_wkspc = old_screen->getWorkspace(old_win->getWorkspaceNumber());
1200
1201     old_win->setFocusFlag(False);
1202     old_wkspc->getMenu()->setItemSelected(old_win->getWindowNumber(), False);
1203   }
1204
1205   if (win && ! win->isIconic()) {
1206     screen = win->getScreen();
1207     tbar = screen->getToolbar();
1208     wkspc = screen->getWorkspace(win->getWorkspaceNumber());
1209
1210     focused_window = win;
1211
1212     win->setFocusFlag(True);
1213     wkspc->getMenu()->setItemSelected(win->getWindowNumber(), True);
1214   } else {
1215     focused_window = (OpenboxWindow *) 0;
1216   }
1217
1218   if (tbar)
1219     tbar->redrawWindowLabel(True);
1220   if (screen)
1221     screen->updateNetizenWindowFocus();
1222
1223   if (old_tbar && old_tbar != tbar)
1224     old_tbar->redrawWindowLabel(True);
1225   if (old_screen && old_screen != screen)
1226     old_screen->updateNetizenWindowFocus();
1227 }