WE DONT USE BASE DISPLAY FOR ANYTHING ANY MORE!!@^!*@*!! YAY
[dana/openbox.git] / src / window.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 HAVE_STRING_H
12 #  include <string.h>
13 #endif // HAVE_STRING_H
14
15 #ifdef    DEBUG
16 #  ifdef    HAVE_STDIO_H
17 #    include <stdio.h>
18 #  endif // HAVE_STDIO_H
19 #endif // DEBUG
20
21 #ifdef HAVE_STDLIB_H
22 #  include <stdlib.h>
23 #endif // HAVE_STDLIB_H
24 }
25
26 #include "blackbox.hh"
27 #include "font.hh"
28 #include "gccache.hh"
29 #include "image.hh"
30 #include "screen.hh"
31 #include "util.hh"
32 #include "window.hh"
33 #include "workspace.hh"
34
35 using std::string;
36 using std::abs;
37
38 namespace ob {
39
40 /*
41  * Initializes the class with default values/the window's set initial values.
42  */
43 BlackboxWindow::BlackboxWindow(Blackbox *b, Window w, BScreen *s) {
44   // fprintf(stderr, "BlackboxWindow size: %d bytes\n",
45   // sizeof(BlackboxWindow));
46
47 #ifdef    DEBUG
48   fprintf(stderr, "BlackboxWindow::BlackboxWindow(): creating 0x%lx\n", w);
49 #endif // DEBUG
50
51   /*
52     set timer to zero... it is initialized properly later, so we check
53     if timer is zero in the destructor, and assume that the window is not
54     fully constructed if timer is zero...
55   */
56   timer = 0;
57   blackbox = b;
58   client.window = w;
59   screen = s;
60   xatom = blackbox->getXAtom();
61
62   if (! validateClient()) {
63     delete this;
64     return;
65   }
66
67   // fetch client size and placement
68   XWindowAttributes wattrib;
69   if (! XGetWindowAttributes(otk::OBDisplay::display,
70                              client.window, &wattrib) ||
71       ! wattrib.screen || wattrib.override_redirect) {
72 #ifdef    DEBUG
73     fprintf(stderr,
74             "BlackboxWindow::BlackboxWindow(): XGetWindowAttributes failed\n");
75 #endif // DEBUG
76
77     delete this;
78     return;
79   }
80
81   // set the eventmask early in the game so that we make sure we get
82   // all the events we are interested in
83   XSetWindowAttributes attrib_set;
84   attrib_set.event_mask = PropertyChangeMask | FocusChangeMask |
85                           StructureNotifyMask;
86   attrib_set.do_not_propagate_mask = ButtonPressMask | ButtonReleaseMask |
87                                      ButtonMotionMask;
88   XChangeWindowAttributes(otk::OBDisplay::display, client.window,
89                           CWEventMask|CWDontPropagate, &attrib_set);
90
91   flags.moving = flags.resizing = flags.shaded = flags.visible =
92     flags.iconic = flags.focused = flags.stuck = flags.modal =
93     flags.send_focus_message = flags.shaped = flags.skip_taskbar =
94     flags.skip_pager = flags.fullscreen = False;
95   flags.maximized = 0;
96
97   blackbox_attrib.workspace = window_number = BSENTINEL;
98
99   blackbox_attrib.flags = blackbox_attrib.attrib = blackbox_attrib.stack = 0l;
100   blackbox_attrib.decoration = DecorNormal;
101   blackbox_attrib.premax_x = blackbox_attrib.premax_y = 0;
102   blackbox_attrib.premax_w = blackbox_attrib.premax_h = 0;
103
104   frame.border_w = 1;
105   frame.window = frame.plate = frame.title = frame.handle = None;
106   frame.close_button = frame.iconify_button = frame.maximize_button =
107     frame.stick_button = None;
108   frame.right_grip = frame.left_grip = None;
109
110   frame.ulabel_pixel = frame.flabel_pixel = frame.utitle_pixel =
111   frame.ftitle_pixel = frame.uhandle_pixel = frame.fhandle_pixel =
112     frame.ubutton_pixel = frame.fbutton_pixel = frame.uborder_pixel =
113     frame.fborder_pixel = frame.ugrip_pixel = frame.fgrip_pixel = 0;
114   frame.utitle = frame.ftitle = frame.uhandle = frame.fhandle = None;
115   frame.ulabel = frame.flabel = frame.ubutton = frame.fbutton = None;
116   frame.ugrip = frame.fgrip = None;
117
118   functions = Func_Resize | Func_Move | Func_Iconify | Func_Maximize;
119   mwm_decorations = Decor_Titlebar | Decor_Handle | Decor_Border |
120                     Decor_Iconify | Decor_Maximize;
121
122   client.normal_hint_flags = 0;
123   client.window_group = None;
124   client.transient_for = 0;
125
126   current_state = NormalState;
127
128   /*
129     set the initial size and location of client window (relative to the
130     _root window_). This position is the reference point used with the
131     window's gravity to find the window's initial position.
132   */
133   client.rect.setRect(wattrib.x, wattrib.y, wattrib.width, wattrib.height);
134   client.old_bw = wattrib.border_width;
135
136   lastButtonPressTime = 0;
137
138   timer = new BTimer(blackbox, this);
139   timer->setTimeout(blackbox->getAutoRaiseDelay());
140
141   // get size, aspect, minimum/maximum size and other hints set by the
142   // client
143
144   if (! getBlackboxHints())
145     getNetWMHints();
146
147   getWMProtocols();
148   getWMHints();
149   getWMNormalHints();
150
151   frame.window = createToplevelWindow();
152
153   blackbox->saveWindowSearch(frame.window, this);
154   
155   frame.plate = createChildWindow(frame.window, ExposureMask);
156   blackbox->saveWindowSearch(frame.plate, this);
157
158   // determine if this is a transient window
159   getTransientInfo();
160
161   // determine the window's type, so we can decide its decorations and
162   // functionality, or if we should not manage it at all
163   if (getWindowType()) {
164     // adjust the window decorations/behavior based on the window type
165     switch (window_type) {
166     case Type_Desktop:
167     case Type_Dock:
168     case Type_Menu:
169       blackbox_attrib.workspace = 0;  // we do need to belong to a workspace
170       flags.stuck = True;             // we show up on all workspaces
171     case Type_Splash:
172       // none of these windows are manipulated by the window manager
173       functions = 0;
174       break;
175
176     case Type_Toolbar:
177     case Type_Utility:
178       // these windows get less functionality
179       functions &= ~(Func_Maximize | Func_Resize | Func_Iconify);
180       break;
181
182     case Type_Dialog:
183       // dialogs cannot be maximized
184       functions &= ~Func_Maximize;
185       break;
186
187     case Type_Normal:
188       // normal windows retain all of the possible decorations and
189       // functionality
190       break;
191     }
192   } else {
193     getMWMHints();
194   }
195   
196   // further adjeust the window's decorations/behavior based on window sizes
197   if ((client.normal_hint_flags & PMinSize) &&
198       (client.normal_hint_flags & PMaxSize) &&
199       client.max_width <= client.min_width &&
200       client.max_height <= client.min_height) {
201     functions &= ~(Func_Resize | Func_Maximize);
202   }
203   
204   setAllowedActions();
205
206   setupDecor();
207   
208   if (decorations & Decor_Titlebar)
209     createTitlebar();
210
211   if (decorations & Decor_Handle)
212     createHandle();
213
214   // apply the size and gravity hint to the frame
215
216   upsize();
217
218   bool place_window = True;
219   if (blackbox->state() == Openbox::State_Starting || isTransient() ||
220       client.normal_hint_flags & (PPosition|USPosition)) {
221     applyGravity(frame.rect);
222
223     if (blackbox->state() == Openbox::State_Starting ||
224         client.rect.intersects(screen->getRect()))
225       place_window = False;
226   }
227
228   // add the window's strut. note this is done *after* placing the window.
229   screen->addStrut(&client.strut);
230   updateStrut();
231   
232   /*
233     the server needs to be grabbed here to prevent client's from sending
234     events while we are in the process of configuring their window.
235     We hold the grab until after we are done moving the window around.
236   */
237
238   XGrabServer(otk::OBDisplay::display);
239
240   associateClientWindow();
241
242   blackbox->saveWindowSearch(client.window, this);
243
244   if (blackbox_attrib.workspace >= screen->getWorkspaceCount())
245     screen->getCurrentWorkspace()->addWindow(this, place_window);
246   else
247     screen->getWorkspace(blackbox_attrib.workspace)->
248       addWindow(this, place_window);
249
250   if (! place_window) {
251     // don't need to call configure if we are letting the workspace
252     // place the window
253     configure(frame.rect.x(), frame.rect.y(),
254               frame.rect.width(), frame.rect.height());
255
256   }
257
258   positionWindows();
259
260   XUngrabServer(otk::OBDisplay::display);
261
262 #ifdef    SHAPE
263   if (blackbox->hasShapeExtensions() && flags.shaped)
264     configureShape();
265 #endif // SHAPE
266
267   // now that we know where to put the window and what it should look like
268   // we apply the decorations
269   decorate();
270
271   grabButtons();
272
273   XMapSubwindows(otk::OBDisplay::display, frame.window);
274
275   // this ensures the title, buttons, and other decor are properly displayed
276   redrawWindowFrame();
277
278   // preserve the window's initial state on first map, and its current state
279   // across a restart
280   unsigned long initial_state = current_state;
281   if (! getState())
282     current_state = initial_state;
283
284   // get sticky state from our parent window if we've got one
285   if (isTransient() && client.transient_for != (BlackboxWindow *) ~0ul &&
286       client.transient_for->isStuck() != flags.stuck)
287     flags.stuck = True;
288
289   if (flags.shaded) {
290     flags.shaded = False;
291     initial_state = current_state;
292     shade();
293
294     /*
295       At this point in the life of a window, current_state should only be set
296       to IconicState if the window was an *icon*, not if it was shaded.
297     */
298     if (initial_state != IconicState)
299       current_state = NormalState;
300   }
301
302   if (flags.stuck) {
303     flags.stuck = False;
304     stick();
305   }
306
307   if (flags.maximized && (functions & Func_Maximize))
308     remaximize();
309 }
310
311
312 BlackboxWindow::~BlackboxWindow(void) {
313 #ifdef    DEBUG
314   fprintf(stderr, "BlackboxWindow::~BlackboxWindow: destroying 0x%lx\n",
315           client.window);
316 #endif // DEBUG
317
318   if (! timer) // window not managed...
319     return;
320
321   if (flags.moving)
322     endMove();
323
324   screen->removeStrut(&client.strut);
325   screen->updateAvailableArea();
326
327   // We don't need to worry about resizing because resizing always grabs the X
328   // server. This should only ever happen if using opaque moving.
329   if (flags.moving)
330     endMove();
331
332   delete timer;
333
334   if (client.window_group) {
335     BWindowGroup *group = blackbox->searchGroup(client.window_group);
336     if (group) group->removeWindow(this);
337   }
338
339   // remove ourselves from our transient_for
340   if (isTransient()) {
341     if (client.transient_for != (BlackboxWindow *) ~0ul)
342       client.transient_for->client.transientList.remove(this);
343     client.transient_for = (BlackboxWindow*) 0;
344   }
345
346   if (client.transientList.size() > 0) {
347     // reset transient_for for all transients
348     BlackboxWindowList::iterator it, end = client.transientList.end();
349     for (it = client.transientList.begin(); it != end; ++it)
350       (*it)->client.transient_for = (BlackboxWindow*) 0;
351   }
352
353   if (frame.title)
354     destroyTitlebar();
355
356   if (frame.handle)
357     destroyHandle();
358
359   if (frame.plate) {
360     blackbox->removeWindowSearch(frame.plate);
361     XDestroyWindow(otk::OBDisplay::display, frame.plate);
362   }
363
364   if (frame.window) {
365     blackbox->removeWindowSearch(frame.window);
366     XDestroyWindow(otk::OBDisplay::display, frame.window);
367   }
368
369   blackbox->removeWindowSearch(client.window);
370 }
371
372
373 void BlackboxWindow::enableDecor(bool enable) {
374   blackbox_attrib.flags |= AttribDecoration;
375   blackbox_attrib.decoration = enable ? DecorNormal : DecorNone;
376   setupDecor();
377     
378   // we can not be shaded if we lack a titlebar
379   if (! (decorations & Decor_Titlebar) && flags.shaded)
380     shade();
381     
382   if (flags.visible && frame.window) {
383     XMapSubwindows(otk::OBDisplay::display, frame.window);
384     XMapWindow(otk::OBDisplay::display, frame.window);
385   }
386
387   reconfigure();
388   setState(current_state);
389 }
390
391
392 void BlackboxWindow::setupDecor() {
393   if (blackbox_attrib.decoration != DecorNone) {
394     // start with everything on
395     decorations = Decor_Close |
396       (mwm_decorations & Decor_Titlebar ? Decor_Titlebar : 0) |
397       (mwm_decorations & Decor_Border ? Decor_Border : 0) |
398       (mwm_decorations & Decor_Handle ? Decor_Handle : 0) |
399       (mwm_decorations & Decor_Iconify ? Decor_Iconify : 0) |
400       (mwm_decorations & Decor_Maximize ? Decor_Maximize : 0);
401
402     if (! (functions & Func_Close)) decorations &= ~Decor_Close;
403     if (! (functions & Func_Maximize)) decorations &= ~Decor_Maximize;
404     if (! (functions & Func_Iconify)) decorations &= ~Decor_Iconify;
405     if (! (functions & Func_Resize)) decorations &= ~Decor_Handle;
406
407     switch (window_type) {
408     case Type_Desktop:
409     case Type_Dock:
410     case Type_Menu:
411     case Type_Splash:
412       // none of these windows are decorated by the window manager at all
413       decorations = 0;
414       break;
415
416     case Type_Toolbar:
417     case Type_Utility:
418       decorations &= ~(Decor_Border);
419       break;
420
421     case Type_Dialog:
422       decorations &= ~Decor_Handle;
423       break;
424
425     case Type_Normal:
426       break;
427     }
428   } else {
429     decorations = 0;
430   }
431 }
432
433 /*
434  * Creates a new top level window, with a given location, size, and border
435  * width.
436  * Returns: the newly created window
437  */
438 Window BlackboxWindow::createToplevelWindow(void) {
439   XSetWindowAttributes attrib_create;
440   unsigned long create_mask = CWBackPixmap | CWBorderPixel | CWColormap |
441                               CWOverrideRedirect | CWEventMask;
442
443   attrib_create.background_pixmap = None;
444   attrib_create.colormap = screen->getColormap();
445   attrib_create.override_redirect = True;
446   attrib_create.event_mask = EnterWindowMask | LeaveWindowMask |
447                              ButtonPress;
448   /*
449     We catch button presses because other wise they get passed down to the
450     root window, which will then cause root menus to show when you click the
451     window's frame.
452   */
453
454   return XCreateWindow(otk::OBDisplay::display, screen->getRootWindow(),
455                        0, 0, 1, 1, frame.border_w, screen->getDepth(),
456                        InputOutput, screen->getVisual(), create_mask,
457                        &attrib_create);
458 }
459
460
461 /*
462  * Creates a child window, and optionally associates a given cursor with
463  * the new window.
464  */
465 Window BlackboxWindow::createChildWindow(Window parent,
466                                          unsigned long event_mask,
467                                          Cursor cursor) {
468   XSetWindowAttributes attrib_create;
469   unsigned long create_mask = CWBackPixmap | CWBorderPixel |
470                               CWEventMask;
471
472   attrib_create.background_pixmap = None;
473   attrib_create.event_mask = event_mask;
474
475   if (cursor) {
476     create_mask |= CWCursor;
477     attrib_create.cursor = cursor;
478   }
479
480   return XCreateWindow(otk::OBDisplay::display, parent, 0, 0, 1, 1, 0,
481                        screen->getDepth(), InputOutput, screen->getVisual(),
482                        create_mask, &attrib_create);
483 }
484
485
486 void BlackboxWindow::associateClientWindow(void) {
487   XSetWindowBorderWidth(otk::OBDisplay::display, client.window, 0);
488   getWMName();
489   getWMIconName();
490
491   XChangeSaveSet(otk::OBDisplay::display, client.window, SetModeInsert);
492
493   XSelectInput(otk::OBDisplay::display, frame.plate, SubstructureRedirectMask);
494
495   /*
496     note we used to grab around this call to XReparentWindow however the
497     server is now grabbed before this method is called
498   */
499   unsigned long event_mask = PropertyChangeMask | FocusChangeMask |
500                              StructureNotifyMask;
501   XSelectInput(otk::OBDisplay::display, client.window,
502                event_mask & ~StructureNotifyMask);
503   XReparentWindow(otk::OBDisplay::display, client.window, frame.plate, 0, 0);
504   XSelectInput(otk::OBDisplay::display, client.window, event_mask);
505
506   XRaiseWindow(otk::OBDisplay::display, frame.plate);
507   XMapSubwindows(otk::OBDisplay::display, frame.plate);
508
509 #ifdef    SHAPE
510   if (blackbox->hasShapeExtensions()) {
511     XShapeSelectInput(otk::OBDisplay::display, client.window,
512                       ShapeNotifyMask);
513
514     Bool shaped = False;
515     int foo;
516     unsigned int ufoo;
517
518     XShapeQueryExtents(otk::OBDisplay::display, client.window, &shaped,
519                        &foo, &foo, &ufoo, &ufoo, &foo, &foo, &foo,
520                        &ufoo, &ufoo);
521     flags.shaped = shaped;
522   }
523 #endif // SHAPE
524 }
525
526
527 void BlackboxWindow::decorate(void) {
528   otk::BTexture* texture;
529
530   texture = &(screen->getWindowStyle()->b_focus);
531   frame.fbutton = texture->render(frame.button_w, frame.button_w,
532                                   frame.fbutton);
533   if (! frame.fbutton)
534     frame.fbutton_pixel = texture->color().pixel();
535
536   texture = &(screen->getWindowStyle()->b_unfocus);
537   frame.ubutton = texture->render(frame.button_w, frame.button_w,
538                                   frame.ubutton);
539   if (! frame.ubutton)
540     frame.ubutton_pixel = texture->color().pixel();
541
542   unsigned char needsPressed = 0;
543
544   texture = &(screen->getWindowStyle()->b_pressed_focus);
545   
546   if (texture->texture() != otk::BTexture::NoTexture) {
547     frame.pfbutton = texture->render(frame.button_w, frame.button_w,
548                                      frame.pfbutton);
549     if (! frame.pfbutton)
550       frame.pfbutton_pixel = texture->color().pixel();
551   } else {
552     needsPressed = 0x1;
553   }
554
555   texture = &(screen->getWindowStyle()->b_pressed_unfocus);
556   
557   if (texture->texture() != otk::BTexture::NoTexture) {
558     frame.pubutton = texture->render(frame.button_w, frame.button_w,
559                                      frame.pubutton);
560     if (! frame.pubutton)
561       frame.pubutton = texture->color().pixel();
562   } else {
563     needsPressed |= 0x2;
564   }
565
566   // if we either pressed unfocused, or pressed focused were undefined,
567   // make them inherit from the old resource. It's a hack for sure, but
568   // it allows for some backwards and forwards compatibility.
569   if (needsPressed) {
570     texture = &(screen->getWindowStyle()->b_pressed);
571     
572     if (needsPressed & 0x1) {
573       frame.pfbutton = texture->render(frame.button_w, frame.button_w,
574                                        frame.pfbutton);
575       if (! frame.pfbutton)
576         frame.pfbutton_pixel = texture->color().pixel();
577     }
578     if (needsPressed & 0x2) {
579       frame.pubutton = texture->render(frame.button_w, frame.button_w,
580                                        frame.pubutton);
581       if (! frame.pubutton)
582         frame.pubutton = texture->color().pixel();
583     }
584     
585   }
586
587   if (decorations & Decor_Titlebar) {
588     texture = &(screen->getWindowStyle()->t_focus);
589     frame.ftitle = texture->render(frame.inside_w, frame.title_h,
590                                    frame.ftitle);
591     if (! frame.ftitle)
592       frame.ftitle_pixel = texture->color().pixel();
593
594     texture = &(screen->getWindowStyle()->t_unfocus);
595     frame.utitle = texture->render(frame.inside_w, frame.title_h,
596                                    frame.utitle);
597     if (! frame.utitle)
598       frame.utitle_pixel = texture->color().pixel();
599
600     XSetWindowBorder(otk::OBDisplay::display, frame.title,
601                      screen->getBorderColor()->pixel());
602
603     decorateLabel();
604   }
605
606   if (decorations & Decor_Border) {
607     frame.fborder_pixel = screen->getWindowStyle()->f_focus.color().pixel();
608     frame.uborder_pixel = screen->getWindowStyle()->f_unfocus.color().pixel();
609   }
610
611   if (decorations & Decor_Handle) {
612     texture = &(screen->getWindowStyle()->h_focus);
613     frame.fhandle = texture->render(frame.inside_w, frame.handle_h,
614                                     frame.fhandle);
615     if (! frame.fhandle)
616       frame.fhandle_pixel = texture->color().pixel();
617
618     texture = &(screen->getWindowStyle()->h_unfocus);
619     frame.uhandle = texture->render(frame.inside_w, frame.handle_h,
620                                     frame.uhandle);
621     if (! frame.uhandle)
622       frame.uhandle_pixel = texture->color().pixel();
623
624     texture = &(screen->getWindowStyle()->g_focus);
625     frame.fgrip = texture->render(frame.grip_w, frame.handle_h, frame.fgrip);
626     if (! frame.fgrip)
627       frame.fgrip_pixel = texture->color().pixel();
628
629     texture = &(screen->getWindowStyle()->g_unfocus);
630     frame.ugrip = texture->render(frame.grip_w, frame.handle_h, frame.ugrip);
631     if (! frame.ugrip)
632       frame.ugrip_pixel = texture->color().pixel();
633
634     XSetWindowBorder(otk::OBDisplay::display, frame.handle,
635                      screen->getBorderColor()->pixel());
636     XSetWindowBorder(otk::OBDisplay::display, frame.left_grip,
637                      screen->getBorderColor()->pixel());
638     XSetWindowBorder(otk::OBDisplay::display, frame.right_grip,
639                      screen->getBorderColor()->pixel());
640   }
641
642   XSetWindowBorder(otk::OBDisplay::display, frame.window,
643                    screen->getBorderColor()->pixel());
644 }
645
646
647 void BlackboxWindow::decorateLabel(void) {
648   otk::BTexture *texture;
649
650   texture = &(screen->getWindowStyle()->l_focus);
651   frame.flabel = texture->render(frame.label_w, frame.label_h, frame.flabel);
652   if (! frame.flabel)
653     frame.flabel_pixel = texture->color().pixel();
654
655   texture = &(screen->getWindowStyle()->l_unfocus);
656   frame.ulabel = texture->render(frame.label_w, frame.label_h, frame.ulabel);
657   if (! frame.ulabel)
658     frame.ulabel_pixel = texture->color().pixel();
659 }
660
661
662 void BlackboxWindow::createHandle(void) {
663   frame.handle = createChildWindow(frame.window,
664                                    ButtonPressMask | ButtonReleaseMask |
665                                    ButtonMotionMask | ExposureMask);
666   blackbox->saveWindowSearch(frame.handle, this);
667
668   frame.left_grip =
669     createChildWindow(frame.handle,
670                       ButtonPressMask | ButtonReleaseMask |
671                       ButtonMotionMask | ExposureMask,
672                       blackbox->getLowerLeftAngleCursor());
673   blackbox->saveWindowSearch(frame.left_grip, this);
674
675   frame.right_grip =
676     createChildWindow(frame.handle,
677                       ButtonPressMask | ButtonReleaseMask |
678                       ButtonMotionMask | ExposureMask,
679                       blackbox->getLowerRightAngleCursor());
680   blackbox->saveWindowSearch(frame.right_grip, this);
681 }
682
683
684 void BlackboxWindow::destroyHandle(void) {
685   if (frame.fhandle)
686     screen->getImageControl()->removeImage(frame.fhandle);
687
688   if (frame.uhandle)
689     screen->getImageControl()->removeImage(frame.uhandle);
690
691   if (frame.fgrip)
692     screen->getImageControl()->removeImage(frame.fgrip);
693
694   if (frame.ugrip)
695     screen->getImageControl()->removeImage(frame.ugrip);
696
697   blackbox->removeWindowSearch(frame.left_grip);
698   blackbox->removeWindowSearch(frame.right_grip);
699
700   XDestroyWindow(otk::OBDisplay::display, frame.left_grip);
701   XDestroyWindow(otk::OBDisplay::display, frame.right_grip);
702   frame.left_grip = frame.right_grip = None;
703
704   blackbox->removeWindowSearch(frame.handle);
705   XDestroyWindow(otk::OBDisplay::display, frame.handle);
706   frame.handle = None;
707 }
708
709
710 void BlackboxWindow::createTitlebar(void) {
711   frame.title = createChildWindow(frame.window,
712                                   ButtonPressMask | ButtonReleaseMask |
713                                   ButtonMotionMask | ExposureMask);
714   frame.label = createChildWindow(frame.title,
715                                   ButtonPressMask | ButtonReleaseMask |
716                                   ButtonMotionMask | ExposureMask);
717   blackbox->saveWindowSearch(frame.title, this);
718   blackbox->saveWindowSearch(frame.label, this);
719
720   if (decorations & Decor_Iconify) createIconifyButton();
721   if (decorations & Decor_Maximize) createMaximizeButton();
722   if (decorations & Decor_Close) createCloseButton();
723 }
724
725
726 void BlackboxWindow::destroyTitlebar(void) {
727   if (frame.close_button)
728     destroyCloseButton();
729
730   if (frame.iconify_button)
731     destroyIconifyButton();
732
733   if (frame.maximize_button)
734     destroyMaximizeButton();
735
736   if (frame.stick_button)
737     destroyStickyButton();
738
739   if (frame.ftitle)
740     screen->getImageControl()->removeImage(frame.ftitle);
741
742   if (frame.utitle)
743     screen->getImageControl()->removeImage(frame.utitle);
744
745   if (frame.flabel)
746     screen->getImageControl()->removeImage(frame.flabel);
747
748   if( frame.ulabel)
749     screen->getImageControl()->removeImage(frame.ulabel);
750
751   if (frame.fbutton)
752     screen->getImageControl()->removeImage(frame.fbutton);
753
754   if (frame.ubutton)
755     screen->getImageControl()->removeImage(frame.ubutton);
756
757   blackbox->removeWindowSearch(frame.title);
758   blackbox->removeWindowSearch(frame.label);
759
760   XDestroyWindow(otk::OBDisplay::display, frame.label);
761   XDestroyWindow(otk::OBDisplay::display, frame.title);
762   frame.title = frame.label = None;
763 }
764
765
766 void BlackboxWindow::createCloseButton(void) {
767   if (frame.title != None) {
768     frame.close_button = createChildWindow(frame.title,
769                                            ButtonPressMask |
770                                            ButtonReleaseMask |
771                                            ButtonMotionMask | ExposureMask);
772     blackbox->saveWindowSearch(frame.close_button, this);
773   }
774 }
775
776
777 void BlackboxWindow::destroyCloseButton(void) {
778   blackbox->removeWindowSearch(frame.close_button);
779   XDestroyWindow(otk::OBDisplay::display, frame.close_button);
780   frame.close_button = None;
781 }
782
783
784 void BlackboxWindow::createIconifyButton(void) {
785   if (frame.title != None) {
786     frame.iconify_button = createChildWindow(frame.title,
787                                              ButtonPressMask |
788                                              ButtonReleaseMask |
789                                              ButtonMotionMask | ExposureMask);
790     blackbox->saveWindowSearch(frame.iconify_button, this);
791   }
792 }
793
794
795 void BlackboxWindow::destroyIconifyButton(void) {
796   blackbox->removeWindowSearch(frame.iconify_button);
797   XDestroyWindow(otk::OBDisplay::display, frame.iconify_button);
798   frame.iconify_button = None;
799 }
800
801
802 void BlackboxWindow::createMaximizeButton(void) {
803   if (frame.title != None) {
804     frame.maximize_button = createChildWindow(frame.title,
805                                               ButtonPressMask |
806                                               ButtonReleaseMask |
807                                               ButtonMotionMask | ExposureMask);
808     blackbox->saveWindowSearch(frame.maximize_button, this);
809   }
810 }
811
812
813 void BlackboxWindow::destroyMaximizeButton(void) {
814   blackbox->removeWindowSearch(frame.maximize_button);
815   XDestroyWindow(otk::OBDisplay::display, frame.maximize_button);
816   frame.maximize_button = None;
817 }
818
819 void BlackboxWindow::createStickyButton(void) {
820   if (frame.title != None) {
821     frame.stick_button = createChildWindow(frame.title,
822                                            ButtonPressMask |
823                                            ButtonReleaseMask |
824                                            ButtonMotionMask | ExposureMask);
825     blackbox->saveWindowSearch(frame.stick_button, this);
826   }
827 }
828
829 void BlackboxWindow::destroyStickyButton(void) {
830   blackbox->removeWindowSearch(frame.stick_button);
831   XDestroyWindow(otk::OBDisplay::display, frame.stick_button);
832   frame.stick_button = None;
833 }
834
835 void BlackboxWindow::positionButtons(bool redecorate_label) {
836   string layout = blackbox->getTitlebarLayout();
837   string parsed;
838
839   bool hasclose, hasiconify, hasmaximize, haslabel, hasstick;
840   hasclose = hasiconify = hasmaximize = haslabel = hasstick = false;
841
842   string::const_iterator it, end;
843   for (it = layout.begin(), end = layout.end(); it != end; ++it) {
844     switch(*it) {
845     case 'C':
846       if (! hasclose && (decorations & Decor_Close)) {
847         hasclose = true;
848         parsed += *it;
849       }
850       break;
851     case 'I':
852       if (! hasiconify && (decorations & Decor_Iconify)) {
853         hasiconify = true;
854         parsed += *it;
855       }
856       break;
857     case 'S':
858       if (!hasstick) {
859         hasstick = true;
860         parsed += *it;
861       }
862       break;
863     case 'M':
864       if (! hasmaximize && (decorations & Decor_Maximize)) {
865         hasmaximize = true;
866         parsed += *it;
867       }
868       break;
869     case 'L':
870       if (! haslabel) {
871         haslabel = true;
872         parsed += *it;
873       }
874       break;
875     }
876   }
877   
878   if (! hasclose && frame.close_button)
879     destroyCloseButton();
880   if (! hasiconify && frame.iconify_button)
881     destroyIconifyButton();
882   if (! hasmaximize && frame.maximize_button)
883     destroyMaximizeButton();
884   if (! hasstick && frame.stick_button)
885     destroyStickyButton();
886   if (! haslabel)
887     parsed += 'L';      // require that the label be in the layout
888
889   const unsigned int bsep = frame.bevel_w + 1;  // separation between elements
890   const unsigned int by = frame.bevel_w + 1;
891   const unsigned int ty = frame.bevel_w;
892
893   frame.label_w = frame.inside_w - bsep * 2 -
894     (frame.button_w + bsep) * (parsed.size() - 1);
895
896   unsigned int x = bsep;
897   for (it = parsed.begin(), end = parsed.end(); it != end; ++it) {
898     switch(*it) {
899     case 'C':
900       if (! frame.close_button) createCloseButton();
901       XMoveResizeWindow(otk::OBDisplay::display, frame.close_button, x, by,
902                         frame.button_w, frame.button_w);
903       x += frame.button_w + bsep;
904       break;
905     case 'I':
906       if (! frame.iconify_button) createIconifyButton();
907       XMoveResizeWindow(otk::OBDisplay::display, frame.iconify_button, x, by,
908                         frame.button_w, frame.button_w);
909       x += frame.button_w + bsep;
910       break;
911     case 'S':
912       if (! frame.stick_button) createStickyButton();
913       XMoveResizeWindow(otk::OBDisplay::display, frame.stick_button, x, by,
914                         frame.button_w, frame.button_w);
915       x += frame.button_w + bsep;
916       break;
917     case 'M':
918       if (! frame.maximize_button) createMaximizeButton();
919       XMoveResizeWindow(otk::OBDisplay::display, frame.maximize_button, x, by,
920                         frame.button_w, frame.button_w);
921       x += frame.button_w + bsep;
922       break;
923     case 'L':
924       XMoveResizeWindow(otk::OBDisplay::display, frame.label, x, ty,
925                         frame.label_w, frame.label_h);
926       x += frame.label_w + bsep;
927       break;
928     }
929   }
930
931   if (redecorate_label) decorateLabel();
932   redrawLabel();
933   redrawAllButtons();
934 }
935
936
937 void BlackboxWindow::reconfigure(void) {
938   restoreGravity(client.rect);
939   upsize();
940   applyGravity(frame.rect);
941   positionWindows();
942   decorate();
943   redrawWindowFrame();
944
945   ungrabButtons();
946   grabButtons();
947 }
948
949
950 void BlackboxWindow::grabButtons(void) {
951   mod_mask = blackbox->getMouseModMask();
952
953   if (! screen->isSloppyFocus() || screen->doClickRaise())
954     // grab button 1 for changing focus/raising
955     otk::OBDisplay::grabButton(Button1, 0, frame.plate, True, ButtonPressMask,
956                                GrabModeSync, GrabModeSync, frame.plate, None,
957                                screen->allowScrollLock());
958   
959   if (functions & Func_Move)
960     otk::OBDisplay::grabButton(Button1, mod_mask, frame.window, True,
961                          ButtonReleaseMask | ButtonMotionMask, GrabModeAsync,
962                          GrabModeAsync, frame.window, None,
963                          screen->allowScrollLock());
964   if (functions & Func_Resize)
965     otk::OBDisplay::grabButton(Button3, mod_mask, frame.window, True,
966                          ButtonReleaseMask | ButtonMotionMask, GrabModeAsync,
967                          GrabModeAsync, frame.window, None,
968                          screen->allowScrollLock());
969   // alt+middle lowers the window
970   otk::OBDisplay::grabButton(Button2, mod_mask, frame.window, True,
971                        ButtonReleaseMask, GrabModeAsync, GrabModeAsync,
972                        frame.window, None, screen->allowScrollLock());
973 }
974
975
976 void BlackboxWindow::ungrabButtons(void) {
977   otk::OBDisplay::ungrabButton(Button1, 0, frame.plate);
978   otk::OBDisplay::ungrabButton(Button1, mod_mask, frame.window);
979   otk::OBDisplay::ungrabButton(Button2, mod_mask, frame.window);
980   otk::OBDisplay::ungrabButton(Button3, mod_mask, frame.window);
981 }
982
983
984 void BlackboxWindow::positionWindows(void) {
985   XMoveResizeWindow(otk::OBDisplay::display, frame.window,
986                     frame.rect.x(), frame.rect.y(), frame.inside_w,
987                     (flags.shaded) ? frame.title_h : frame.inside_h);
988   XSetWindowBorderWidth(otk::OBDisplay::display, frame.window,
989                         frame.border_w);
990   XSetWindowBorderWidth(otk::OBDisplay::display, frame.plate,
991                         frame.mwm_border_w);
992   XMoveResizeWindow(otk::OBDisplay::display, frame.plate,
993                     frame.margin.left - frame.mwm_border_w - frame.border_w,
994                     frame.margin.top - frame.mwm_border_w - frame.border_w,
995                     client.rect.width(), client.rect.height());
996   XMoveResizeWindow(otk::OBDisplay::display, client.window,
997                     0, 0, client.rect.width(), client.rect.height());
998   // ensure client.rect contains the real location
999   client.rect.setPos(frame.rect.left() + frame.margin.left,
1000                      frame.rect.top() + frame.margin.top);
1001
1002   if (decorations & Decor_Titlebar) {
1003     if (frame.title == None) createTitlebar();
1004
1005     XSetWindowBorderWidth(otk::OBDisplay::display, frame.title,
1006                           frame.border_w);
1007     XMoveResizeWindow(otk::OBDisplay::display, frame.title, -frame.border_w,
1008                       -frame.border_w, frame.inside_w, frame.title_h);
1009
1010     positionButtons();
1011     XMapSubwindows(otk::OBDisplay::display, frame.title);
1012     XMapWindow(otk::OBDisplay::display, frame.title);
1013   } else if (frame.title) {
1014     destroyTitlebar();
1015   }
1016   if (decorations & Decor_Handle) {
1017     if (frame.handle == None) createHandle();
1018     XSetWindowBorderWidth(otk::OBDisplay::display, frame.handle,
1019                           frame.border_w);
1020     XSetWindowBorderWidth(otk::OBDisplay::display, frame.left_grip,
1021                           frame.border_w);
1022     XSetWindowBorderWidth(otk::OBDisplay::display, frame.right_grip,
1023                           frame.border_w);
1024
1025     // use client.rect here so the value is correct even if shaded
1026     XMoveResizeWindow(otk::OBDisplay::display, frame.handle,
1027                       -frame.border_w,
1028                       client.rect.height() + frame.margin.top +
1029                       frame.mwm_border_w - frame.border_w,
1030                       frame.inside_w, frame.handle_h);
1031     XMoveResizeWindow(otk::OBDisplay::display, frame.left_grip,
1032                       -frame.border_w, -frame.border_w,
1033                       frame.grip_w, frame.handle_h);
1034     XMoveResizeWindow(otk::OBDisplay::display, frame.right_grip,
1035                       frame.inside_w - frame.grip_w - frame.border_w,
1036                       -frame.border_w, frame.grip_w, frame.handle_h);
1037
1038     XMapSubwindows(otk::OBDisplay::display, frame.handle);
1039     XMapWindow(otk::OBDisplay::display, frame.handle);
1040   } else if (frame.handle) {
1041     destroyHandle();
1042   }
1043   XSync(otk::OBDisplay::display, False);
1044 }
1045
1046
1047 void BlackboxWindow::updateStrut(void) {
1048   unsigned long num = 4;
1049   unsigned long *data;
1050   if (! xatom->getValue(client.window, XAtom::net_wm_strut, XAtom::cardinal,
1051                         num, &data))
1052     return;
1053  
1054   if (num == 4) {
1055     client.strut.left = data[0];
1056     client.strut.right = data[1];
1057     client.strut.top = data[2];
1058     client.strut.bottom = data[3];
1059
1060     screen->updateAvailableArea();
1061   }
1062
1063   delete [] data;
1064 }
1065
1066
1067 bool BlackboxWindow::getWindowType(void) {
1068   window_type = (WindowType) -1;
1069
1070   unsigned long *val;
1071   unsigned long num = (unsigned) -1;
1072   if (xatom->getValue(client.window, XAtom::net_wm_window_type, XAtom::atom,
1073                         num, &val)) {
1074     for (unsigned long i = 0; i < num; ++i) {
1075       if (val[i] == xatom->getAtom(XAtom::net_wm_window_type_desktop))
1076         window_type = Type_Desktop;
1077       else if (val[i] == xatom->getAtom(XAtom::net_wm_window_type_dock))
1078         window_type = Type_Dock;
1079       else if (val[i] == xatom->getAtom(XAtom::net_wm_window_type_toolbar))
1080         window_type = Type_Toolbar;
1081       else if (val[i] == xatom->getAtom(XAtom::net_wm_window_type_menu))
1082         window_type = Type_Menu;
1083       else if (val[i] == xatom->getAtom(XAtom::net_wm_window_type_utility))
1084         window_type = Type_Utility;
1085       else if (val[i] == xatom->getAtom(XAtom::net_wm_window_type_splash))
1086         window_type = Type_Splash;
1087       else if (val[i] == xatom->getAtom(XAtom::net_wm_window_type_dialog))
1088         window_type = Type_Dialog;
1089       else if (val[i] == xatom->getAtom(XAtom::net_wm_window_type_normal))
1090         window_type = Type_Normal;
1091       else if (val[i] ==
1092                xatom->getAtom(XAtom::kde_net_wm_window_type_override))
1093         mwm_decorations = 0; // prevent this window from getting any decor
1094     }
1095     delete val;
1096   }
1097     
1098   if (window_type == (WindowType) -1) {
1099     /*
1100      * the window type hint was not set, which means we either classify ourself
1101      * as a normal window or a dialog, depending on if we are a transient.
1102      */
1103     if (isTransient())
1104       window_type = Type_Dialog;
1105     else
1106       window_type = Type_Normal;
1107
1108     return False;
1109   }
1110
1111   return True;
1112 }
1113
1114
1115 void BlackboxWindow::getWMName(void) {
1116   if (xatom->getValue(client.window, XAtom::net_wm_name,
1117                       XAtom::utf8, client.title) &&
1118       !client.title.empty()) {
1119     xatom->eraseValue(client.window, XAtom::net_wm_visible_name);
1120     return;
1121   }
1122   //fall through to using WM_NAME
1123   if (xatom->getValue(client.window, XAtom::wm_name, XAtom::ansi, client.title)
1124       && !client.title.empty()) {
1125     xatom->eraseValue(client.window, XAtom::net_wm_visible_name);
1126     return;
1127   }
1128   // fall back to an internal default
1129   client.title = "Unnamed";
1130   xatom->setValue(client.window, XAtom::net_wm_visible_name, XAtom::utf8,
1131                   client.title);
1132
1133 #ifdef DEBUG_WITH_ID
1134   // the 16 is the 8 chars of the debug text plus the number
1135   char *tmp = new char[client.title.length() + 16];
1136   sprintf(tmp, "%s; id: 0x%lx", client.title.c_str(), client.window);
1137   client.title = tmp;
1138   delete tmp;
1139 #endif
1140 }
1141
1142
1143 void BlackboxWindow::getWMIconName(void) {
1144   if (xatom->getValue(client.window, XAtom::net_wm_icon_name,
1145                       XAtom::utf8, client.icon_title) && 
1146       !client.icon_title.empty()) {
1147     xatom->eraseValue(client.window, XAtom::net_wm_visible_icon_name);
1148     return;
1149   }
1150   //fall through to using WM_ICON_NAME
1151   if (xatom->getValue(client.window, XAtom::wm_icon_name, XAtom::ansi,
1152                       client.icon_title) && 
1153       !client.icon_title.empty()) {
1154     xatom->eraseValue(client.window, XAtom::net_wm_visible_icon_name);
1155     return;
1156   }
1157   // fall back to using the main name
1158   client.icon_title = client.title;
1159   xatom->setValue(client.window, XAtom::net_wm_visible_icon_name, XAtom::utf8,
1160                   client.icon_title);
1161 }
1162
1163
1164 /*
1165  * Retrieve which WM Protocols are supported by the client window.
1166  * If the WM_DELETE_WINDOW protocol is supported, add the close button to the
1167  * window's decorations and allow the close behavior.
1168  * If the WM_TAKE_FOCUS protocol is supported, save a value that indicates
1169  * this.
1170  */
1171 void BlackboxWindow::getWMProtocols(void) {
1172   Atom *proto;
1173   int num_return = 0;
1174
1175   if (XGetWMProtocols(otk::OBDisplay::display, client.window,
1176                       &proto, &num_return)) {
1177     for (int i = 0; i < num_return; ++i) {
1178       if (proto[i] == xatom->getAtom(XAtom::wm_delete_window)) {
1179         decorations |= Decor_Close;
1180         functions |= Func_Close;
1181       } else if (proto[i] == xatom->getAtom(XAtom::wm_take_focus))
1182         flags.send_focus_message = True;
1183     }
1184
1185     XFree(proto);
1186   }
1187 }
1188
1189
1190 /*
1191  * Gets the value of the WM_HINTS property.
1192  * If the property is not set, then use a set of default values.
1193  */
1194 void BlackboxWindow::getWMHints(void) {
1195   focus_mode = F_Passive;
1196
1197   // remove from current window group
1198   if (client.window_group) {
1199     BWindowGroup *group = blackbox->searchGroup(client.window_group);
1200     if (group) group->removeWindow(this);
1201   }
1202   client.window_group = None;
1203
1204   XWMHints *wmhint = XGetWMHints(otk::OBDisplay::display, client.window);
1205   if (! wmhint) {
1206     return;
1207   }
1208
1209   if (wmhint->flags & InputHint) {
1210     if (wmhint->input == True) {
1211       if (flags.send_focus_message)
1212         focus_mode = F_LocallyActive;
1213     } else {
1214       if (flags.send_focus_message)
1215         focus_mode = F_GloballyActive;
1216       else
1217         focus_mode = F_NoInput;
1218     }
1219   }
1220
1221   if (wmhint->flags & StateHint)
1222     current_state = wmhint->initial_state;
1223
1224   if (wmhint->flags & WindowGroupHint) {
1225     client.window_group = wmhint->window_group;
1226
1227     // add window to the appropriate group
1228     BWindowGroup *group = blackbox->searchGroup(client.window_group);
1229     if (! group) { // no group found, create it!
1230       new BWindowGroup(blackbox, client.window_group);
1231       group = blackbox->searchGroup(client.window_group);
1232     }
1233     if (group)
1234       group->addWindow(this);
1235   }
1236
1237   XFree(wmhint);
1238 }
1239
1240
1241 /*
1242  * Gets the value of the WM_NORMAL_HINTS property.
1243  * If the property is not set, then use a set of default values.
1244  */
1245 void BlackboxWindow::getWMNormalHints(void) {
1246   long icccm_mask;
1247   XSizeHints sizehint;
1248
1249   client.min_width = client.min_height =
1250     client.width_inc = client.height_inc = 1;
1251   client.base_width = client.base_height = 0;
1252   client.win_gravity = NorthWestGravity;
1253 #if 0
1254   client.min_aspect_x = client.min_aspect_y =
1255     client.max_aspect_x = client.max_aspect_y = 1;
1256 #endif
1257
1258   // don't limit the size of a window, the default max width is the biggest
1259   // possible
1260   client.max_width = (unsigned) -1;
1261   client.max_height = (unsigned) -1;
1262
1263
1264   if (! XGetWMNormalHints(otk::OBDisplay::display, client.window,
1265                           &sizehint, &icccm_mask))
1266     return;
1267
1268   client.normal_hint_flags = sizehint.flags;
1269
1270   if (sizehint.flags & PMinSize) {
1271     if (sizehint.min_width >= 0)
1272       client.min_width = sizehint.min_width;
1273     if (sizehint.min_height >= 0)
1274       client.min_height = sizehint.min_height;
1275   }
1276
1277   if (sizehint.flags & PMaxSize) {
1278     if (sizehint.max_width > static_cast<signed>(client.min_width))
1279       client.max_width = sizehint.max_width;
1280     else
1281       client.max_width = client.min_width;
1282
1283     if (sizehint.max_height > static_cast<signed>(client.min_height))
1284       client.max_height = sizehint.max_height;
1285     else
1286       client.max_height = client.min_height;
1287   }
1288
1289   if (sizehint.flags & PResizeInc) {
1290     client.width_inc = sizehint.width_inc;
1291     client.height_inc = sizehint.height_inc;
1292   }
1293
1294 #if 0 // we do not support this at the moment
1295   if (sizehint.flags & PAspect) {
1296     client.min_aspect_x = sizehint.min_aspect.x;
1297     client.min_aspect_y = sizehint.min_aspect.y;
1298     client.max_aspect_x = sizehint.max_aspect.x;
1299     client.max_aspect_y = sizehint.max_aspect.y;
1300   }
1301 #endif
1302
1303   if (sizehint.flags & PBaseSize) {
1304     client.base_width = sizehint.base_width;
1305     client.base_height = sizehint.base_height;
1306   }
1307
1308   if (sizehint.flags & PWinGravity)
1309     client.win_gravity = sizehint.win_gravity;
1310 }
1311
1312
1313 /*
1314  * Gets the NETWM hints for the class' contained window.
1315  */
1316 void BlackboxWindow::getNetWMHints(void) {
1317   unsigned long workspace;
1318
1319   if (xatom->getValue(client.window, XAtom::net_wm_desktop, XAtom::cardinal,
1320                       workspace)) {
1321     if (workspace == 0xffffffff)
1322       flags.stuck = True;
1323     else
1324       blackbox_attrib.workspace = workspace;
1325   }
1326
1327   unsigned long *state;
1328   unsigned long num = (unsigned) -1;
1329   if (xatom->getValue(client.window, XAtom::net_wm_state, XAtom::atom,
1330                       num, &state)) {
1331     bool vert = False,
1332          horz = False;
1333     for (unsigned long i = 0; i < num; ++i) {
1334       if (state[i] == xatom->getAtom(XAtom::net_wm_state_modal))
1335         flags.modal = True;
1336       else if (state[i] == xatom->getAtom(XAtom::net_wm_state_shaded))
1337         flags.shaded = True;
1338       else if (state[i] == xatom->getAtom(XAtom::net_wm_state_skip_taskbar))
1339         flags.skip_taskbar = True;
1340       else if (state[i] == xatom->getAtom(XAtom::net_wm_state_skip_pager))
1341         flags.skip_pager = True;
1342       else if (state[i] == xatom->getAtom(XAtom::net_wm_state_fullscreen))
1343         flags.fullscreen = True;
1344       else if (state[i] == xatom->getAtom(XAtom::net_wm_state_hidden))
1345         setState(IconicState);
1346       else if (state[i] == xatom->getAtom(XAtom::net_wm_state_maximized_vert))
1347         vert = True;
1348       else if (state[i] == xatom->getAtom(XAtom::net_wm_state_maximized_horz))
1349         horz = True;
1350     }
1351     if (vert && horz)
1352       flags.maximized = 1;
1353     else if (vert)
1354       flags.maximized = 2;
1355     else if (horz)
1356       flags.maximized = 3;
1357
1358     delete [] state;
1359   }
1360 }
1361
1362
1363 /*
1364  * Gets the MWM hints for the class' contained window.
1365  * This is used while initializing the window to its first state, and not
1366  * thereafter.
1367  * Returns: true if the MWM hints are successfully retreived and applied;
1368  * false if they are not.
1369  */
1370 void BlackboxWindow::getMWMHints(void) {
1371   unsigned long num;
1372   MwmHints *mwm_hint;
1373
1374   num = PropMwmHintsElements;
1375   if (! xatom->getValue(client.window, XAtom::motif_wm_hints,
1376                         XAtom::motif_wm_hints, num,
1377                         (unsigned long **)&mwm_hint))
1378     return;
1379   if (num < PropMwmHintsElements) {
1380     delete [] mwm_hint;
1381     return;
1382   }
1383
1384   if (mwm_hint->flags & MwmHintsDecorations) {
1385     if (mwm_hint->decorations & MwmDecorAll) {
1386       mwm_decorations = Decor_Titlebar | Decor_Handle | Decor_Border |
1387                         Decor_Iconify | Decor_Maximize;
1388     } else {
1389       mwm_decorations = 0;
1390
1391       if (mwm_hint->decorations & MwmDecorBorder)
1392         mwm_decorations |= Decor_Border;
1393       if (mwm_hint->decorations & MwmDecorHandle)
1394         mwm_decorations |= Decor_Handle;
1395       if (mwm_hint->decorations & MwmDecorTitle)
1396         mwm_decorations |= Decor_Titlebar;
1397       if (mwm_hint->decorations & MwmDecorIconify)
1398         mwm_decorations |= Decor_Iconify;
1399       if (mwm_hint->decorations & MwmDecorMaximize)
1400         mwm_decorations |= Decor_Maximize;
1401     }
1402   }
1403
1404   if (mwm_hint->flags & MwmHintsFunctions) {
1405     if (mwm_hint->functions & MwmFuncAll) {
1406       functions = Func_Resize | Func_Move | Func_Iconify | Func_Maximize |
1407                   Func_Close;
1408     } else {
1409       functions = 0;
1410
1411       if (mwm_hint->functions & MwmFuncResize)
1412         functions |= Func_Resize;
1413       if (mwm_hint->functions & MwmFuncMove)
1414         functions |= Func_Move;
1415       if (mwm_hint->functions & MwmFuncIconify)
1416         functions |= Func_Iconify;
1417       if (mwm_hint->functions & MwmFuncMaximize)
1418         functions |= Func_Maximize;
1419       if (mwm_hint->functions & MwmFuncClose)
1420         functions |= Func_Close;
1421     }
1422   }
1423   delete [] mwm_hint;
1424 }
1425
1426
1427 /*
1428  * Gets the blackbox hints from the class' contained window.
1429  * This is used while initializing the window to its first state, and not
1430  * thereafter.
1431  * Returns: true if the hints are successfully retreived and applied; false if
1432  * they are not.
1433  */
1434 bool BlackboxWindow::getBlackboxHints(void) {
1435   unsigned long num;
1436   BlackboxHints *blackbox_hint;
1437
1438   num = PropBlackboxHintsElements;
1439   if (! xatom->getValue(client.window, XAtom::blackbox_hints,
1440                         XAtom::blackbox_hints, num,
1441                         (unsigned long **)&blackbox_hint))
1442     return False;
1443   if (num < PropBlackboxHintsElements) {
1444     delete [] blackbox_hint;
1445     return False;
1446   }
1447
1448   if (blackbox_hint->flags & AttribShaded)
1449     flags.shaded = (blackbox_hint->attrib & AttribShaded);
1450
1451   if ((blackbox_hint->flags & AttribMaxHoriz) &&
1452       (blackbox_hint->flags & AttribMaxVert))
1453     flags.maximized = (blackbox_hint->attrib &
1454                        (AttribMaxHoriz | AttribMaxVert)) ? 1 : 0;
1455   else if (blackbox_hint->flags & AttribMaxVert)
1456     flags.maximized = (blackbox_hint->attrib & AttribMaxVert) ? 2 : 0;
1457   else if (blackbox_hint->flags & AttribMaxHoriz)
1458     flags.maximized = (blackbox_hint->attrib & AttribMaxHoriz) ? 3 : 0;
1459
1460   if (blackbox_hint->flags & AttribOmnipresent)
1461     flags.stuck = (blackbox_hint->attrib & AttribOmnipresent);
1462
1463   if (blackbox_hint->flags & AttribWorkspace)
1464     blackbox_attrib.workspace = blackbox_hint->workspace;
1465
1466   // if (blackbox_hint->flags & AttribStack)
1467   //   don't yet have always on top/bottom for blackbox yet... working
1468   //   on that
1469
1470   if (blackbox_hint->flags & AttribDecoration) {
1471     switch (blackbox_hint->decoration) {
1472     case DecorNone:
1473       blackbox_attrib.decoration = DecorNone;
1474       break;
1475
1476     case DecorTiny:
1477     case DecorTool:
1478     case DecorNormal:
1479     default:
1480       // blackbox_attrib.decoration defaults to DecorNormal
1481       break;
1482     }
1483   }
1484   
1485   delete [] blackbox_hint;
1486
1487   return True;
1488 }
1489
1490
1491 void BlackboxWindow::getTransientInfo(void) {
1492   if (client.transient_for &&
1493       client.transient_for != (BlackboxWindow *) ~0ul) {
1494     // reset transient_for in preparation of looking for a new owner
1495     client.transient_for->client.transientList.remove(this);
1496   }
1497
1498   // we have no transient_for until we find a new one
1499   client.transient_for = (BlackboxWindow *) 0;
1500
1501   Window trans_for;
1502   if (! XGetTransientForHint(otk::OBDisplay::display, client.window,
1503                              &trans_for)) {
1504     // transient_for hint not set
1505     return;
1506   }
1507
1508   if (trans_for == client.window) {
1509     // wierd client... treat this window as a normal window
1510     return;
1511   }
1512
1513   if (trans_for == None || trans_for == screen->getRootWindow()) {
1514     // this is an undocumented interpretation of the ICCCM. a transient
1515     // associated with None/Root/itself is assumed to be a modal root
1516     // transient.  we don't support the concept of a global transient,
1517     // so we just associate this transient with nothing, and perhaps
1518     // we will add support later for global modality.
1519     client.transient_for = (BlackboxWindow *) ~0ul;
1520     flags.modal = True;
1521     return;
1522   }
1523
1524   client.transient_for = blackbox->searchWindow(trans_for);
1525   if (! client.transient_for &&
1526       client.window_group && trans_for == client.window_group) {
1527     // no direct transient_for, perhaps this is a group transient?
1528     BWindowGroup *group = blackbox->searchGroup(client.window_group);
1529     if (group) client.transient_for = group->find(screen);
1530   }
1531
1532   if (! client.transient_for || client.transient_for == this) {
1533     // no transient_for found, or we have a wierd client that wants to be
1534     // a transient for itself, so we treat this window as a normal window
1535     client.transient_for = (BlackboxWindow*) 0;
1536     return;
1537   }
1538
1539   // Check for a circular transient state: this can lock up Blackbox
1540   // when it tries to find the non-transient window for a transient.
1541   BlackboxWindow *w = this;
1542   while(w->client.transient_for &&
1543         w->client.transient_for != (BlackboxWindow *) ~0ul) {
1544     if(w->client.transient_for == this) {
1545       client.transient_for = (BlackboxWindow*) 0;
1546       break;
1547     }
1548     w = w->client.transient_for;
1549   }
1550
1551   if (client.transient_for &&
1552       client.transient_for != (BlackboxWindow *) ~0ul) {
1553     // register ourselves with our new transient_for
1554     client.transient_for->client.transientList.push_back(this);
1555     flags.stuck = client.transient_for->flags.stuck;
1556   }
1557 }
1558
1559
1560 BlackboxWindow *BlackboxWindow::getTransientFor(void) const {
1561   if (client.transient_for &&
1562       client.transient_for != (BlackboxWindow*) ~0ul)
1563     return client.transient_for;
1564   return 0;
1565 }
1566
1567
1568 /*
1569  * This function is responsible for updating both the client and the frame
1570  * rectangles.
1571  * According to the ICCCM a client message is not sent for a resize, only a
1572  * move.
1573  */
1574 void BlackboxWindow::configure(int dx, int dy,
1575                                unsigned int dw, unsigned int dh) {
1576   bool send_event = ((frame.rect.x() != dx || frame.rect.y() != dy) &&
1577                      ! flags.moving);
1578
1579   if (dw != frame.rect.width() || dh != frame.rect.height()) {
1580     frame.rect.setRect(dx, dy, dw, dh);
1581     frame.inside_w = frame.rect.width() - (frame.border_w * 2);
1582     frame.inside_h = frame.rect.height() - (frame.border_w * 2);
1583
1584     if (frame.rect.right() <= 0 || frame.rect.bottom() <= 0)
1585       frame.rect.setPos(0, 0);
1586
1587     client.rect.setCoords(frame.rect.left() + frame.margin.left,
1588                           frame.rect.top() + frame.margin.top,
1589                           frame.rect.right() - frame.margin.right,
1590                           frame.rect.bottom() - frame.margin.bottom);
1591
1592 #ifdef    SHAPE
1593     if (blackbox->hasShapeExtensions() && flags.shaped) {
1594       configureShape();
1595     }
1596 #endif // SHAPE
1597
1598     positionWindows();
1599     decorate();
1600     redrawWindowFrame();
1601   } else {
1602     frame.rect.setPos(dx, dy);
1603
1604     XMoveWindow(otk::OBDisplay::display, frame.window,
1605                 frame.rect.x(), frame.rect.y());
1606     /*
1607       we may have been called just after an opaque window move, so even though
1608       the old coords match the new ones no ConfigureNotify has been sent yet.
1609       There are likely other times when this will be relevant as well.
1610     */
1611     if (! flags.moving) send_event = True;
1612   }
1613
1614   if (send_event) {
1615     // if moving, the update and event will occur when the move finishes
1616     client.rect.setPos(frame.rect.left() + frame.margin.left,
1617                        frame.rect.top() + frame.margin.top);
1618
1619     XEvent event;
1620     event.type = ConfigureNotify;
1621
1622     event.xconfigure.display = otk::OBDisplay::display;
1623     event.xconfigure.event = client.window;
1624     event.xconfigure.window = client.window;
1625     event.xconfigure.x = client.rect.x();
1626     event.xconfigure.y = client.rect.y();
1627     event.xconfigure.width = client.rect.width();
1628     event.xconfigure.height = client.rect.height();
1629     event.xconfigure.border_width = client.old_bw;
1630     event.xconfigure.above = frame.window;
1631     event.xconfigure.override_redirect = False;
1632
1633     XSendEvent(otk::OBDisplay::display, client.window, False,
1634                StructureNotifyMask, &event);
1635     XFlush(otk::OBDisplay::display);
1636   }
1637 }
1638
1639
1640 #ifdef SHAPE
1641 void BlackboxWindow::configureShape(void) {
1642   XShapeCombineShape(otk::OBDisplay::display, frame.window, ShapeBounding,
1643                      frame.margin.left - frame.border_w,
1644                      frame.margin.top - frame.border_w,
1645                      client.window, ShapeBounding, ShapeSet);
1646
1647   int num = 0;
1648   XRectangle xrect[2];
1649
1650   if (decorations & Decor_Titlebar) {
1651     xrect[0].x = xrect[0].y = -frame.border_w;
1652     xrect[0].width = frame.rect.width();
1653     xrect[0].height = frame.title_h + (frame.border_w * 2);
1654     ++num;
1655   }
1656
1657   if (decorations & Decor_Handle) {
1658     xrect[1].x = -frame.border_w;
1659     xrect[1].y = frame.rect.height() - frame.margin.bottom +
1660                  frame.mwm_border_w - frame.border_w;
1661     xrect[1].width = frame.rect.width();
1662     xrect[1].height = frame.handle_h + (frame.border_w * 2);
1663     ++num;
1664   }
1665
1666   XShapeCombineRectangles(otk::OBDisplay::display, frame.window,
1667                           ShapeBounding, 0, 0, xrect, num,
1668                           ShapeUnion, Unsorted);
1669 }
1670
1671
1672 void BlackboxWindow::clearShape(void) {
1673   XShapeCombineMask(otk::OBDisplay::display, frame.window, ShapeBounding,
1674                     frame.margin.left - frame.border_w,
1675                     frame.margin.top - frame.border_w,
1676                     None, ShapeSet);
1677 }
1678 #endif // SHAPE
1679
1680
1681 bool BlackboxWindow::setInputFocus(void) {
1682   if (flags.focused) return True;
1683
1684   assert(flags.stuck ||  // window must be on the current workspace or sticky
1685          blackbox_attrib.workspace == screen->getCurrentWorkspaceID());
1686
1687   /*
1688      We only do this check for normal windows and dialogs because other windows
1689      do this on purpose, such as kde's kicker, and we don't want to go moving
1690      it.
1691   */
1692   if (window_type == Type_Normal || window_type == Type_Dialog)
1693     if (! frame.rect.intersects(screen->getRect())) {
1694       // client is outside the screen, move it to the center
1695       configure((screen->getWidth() - frame.rect.width()) / 2,
1696                 (screen->getHeight() - frame.rect.height()) / 2,
1697                 frame.rect.width(), frame.rect.height());
1698     }
1699
1700   if (client.transientList.size() > 0) {
1701     // transfer focus to any modal transients
1702     BlackboxWindowList::iterator it, end = client.transientList.end();
1703     for (it = client.transientList.begin(); it != end; ++it)
1704       if ((*it)->flags.modal) return (*it)->setInputFocus();
1705   }
1706
1707   bool ret = True;
1708   if (focus_mode == F_LocallyActive || focus_mode == F_Passive) {
1709     XSetInputFocus(otk::OBDisplay::display, client.window,
1710                    RevertToPointerRoot, CurrentTime);
1711   } else {
1712     /* we could set the focus to none, since the window doesn't accept focus,
1713      * but we shouldn't set focus to nothing since this would surely make
1714      * someone angry
1715      */
1716     ret = False;
1717   }
1718
1719   if (flags.send_focus_message) {
1720     XEvent ce;
1721     ce.xclient.type = ClientMessage;
1722     ce.xclient.message_type = xatom->getAtom(XAtom::wm_protocols);
1723     ce.xclient.display = otk::OBDisplay::display;
1724     ce.xclient.window = client.window;
1725     ce.xclient.format = 32;
1726     ce.xclient.data.l[0] = xatom->getAtom(XAtom::wm_take_focus);
1727     ce.xclient.data.l[1] = blackbox->getLastTime();
1728     ce.xclient.data.l[2] = 0l;
1729     ce.xclient.data.l[3] = 0l;
1730     ce.xclient.data.l[4] = 0l;
1731     XSendEvent(otk::OBDisplay::display, client.window, False,
1732                NoEventMask, &ce);
1733     XFlush(otk::OBDisplay::display);
1734   }
1735
1736   return ret;
1737 }
1738
1739
1740 void BlackboxWindow::iconify(void) {
1741   if (flags.iconic || ! (functions & Func_Iconify)) return;
1742
1743   // We don't need to worry about resizing because resizing always grabs the X
1744   // server. This should only ever happen if using opaque moving.
1745   if (flags.moving)
1746     endMove();
1747     
1748   /*
1749    * we don't want this XUnmapWindow call to generate an UnmapNotify event, so
1750    * we need to clear the event mask on client.window for a split second.
1751    * HOWEVER, since X11 is asynchronous, the window could be destroyed in that
1752    * split second, leaving us with a ghost window... so, we need to do this
1753    * while the X server is grabbed
1754    */
1755   unsigned long event_mask = PropertyChangeMask | FocusChangeMask |
1756                              StructureNotifyMask;
1757   XGrabServer(otk::OBDisplay::display);
1758   XSelectInput(otk::OBDisplay::display, client.window,
1759                event_mask & ~StructureNotifyMask);
1760   XUnmapWindow(otk::OBDisplay::display, client.window);
1761   XSelectInput(otk::OBDisplay::display, client.window, event_mask);
1762   XUngrabServer(otk::OBDisplay::display);
1763
1764   XUnmapWindow(otk::OBDisplay::display, frame.window);
1765   flags.visible = False;
1766   flags.iconic = True;
1767
1768   setState(IconicState);
1769
1770   screen->getWorkspace(blackbox_attrib.workspace)->removeWindow(this);
1771   if (flags.stuck) {
1772     for (unsigned int i = 0; i < screen->getNumberOfWorkspaces(); ++i)
1773       if (i != blackbox_attrib.workspace)
1774         screen->getWorkspace(i)->removeWindow(this, True);
1775   }
1776
1777   if (isTransient()) {
1778     if (client.transient_for != (BlackboxWindow *) ~0ul &&
1779         ! client.transient_for->flags.iconic) {
1780       // iconify our transient_for
1781       client.transient_for->iconify();
1782     }
1783   }
1784
1785   screen->addIcon(this);
1786
1787   if (client.transientList.size() > 0) {
1788     // iconify all transients
1789     BlackboxWindowList::iterator it, end = client.transientList.end();
1790     for (it = client.transientList.begin(); it != end; ++it) {
1791       if (! (*it)->flags.iconic) (*it)->iconify();
1792     }
1793   }
1794   screen->updateStackingList();
1795 }
1796
1797
1798 void BlackboxWindow::show(void) {
1799   flags.visible = True;
1800   flags.iconic = False;
1801
1802   current_state = (flags.shaded) ? IconicState : NormalState;
1803   setState(current_state);
1804
1805   XMapWindow(otk::OBDisplay::display, client.window);
1806   XMapSubwindows(otk::OBDisplay::display, frame.window);
1807   XMapWindow(otk::OBDisplay::display, frame.window);
1808
1809 #if 0
1810   int real_x, real_y;
1811   Window child;
1812   XTranslateCoordinates(otk::OBDisplay::display, client.window,
1813                         screen->getRootWindow(),
1814                         0, 0, &real_x, &real_y, &child);
1815   fprintf(stderr, "%s -- assumed: (%d, %d), real: (%d, %d)\n", getTitle(),
1816           client.rect.left(), client.rect.top(), real_x, real_y);
1817   assert(client.rect.left() == real_x && client.rect.top() == real_y);
1818 #endif
1819 }
1820
1821
1822 void BlackboxWindow::deiconify(bool reassoc, bool raise) {
1823   if (flags.iconic || reassoc)
1824     screen->reassociateWindow(this, BSENTINEL, False);
1825   else if (blackbox_attrib.workspace != screen->getCurrentWorkspaceID())
1826     return;
1827
1828   show();
1829
1830   // reassociate and deiconify all transients
1831   if (reassoc && client.transientList.size() > 0) {
1832     BlackboxWindowList::iterator it, end = client.transientList.end();
1833     for (it = client.transientList.begin(); it != end; ++it)
1834       (*it)->deiconify(True, False);
1835   }
1836
1837   if (raise)
1838     screen->getWorkspace(blackbox_attrib.workspace)->raiseWindow(this);
1839 }
1840
1841
1842 void BlackboxWindow::close(void) {
1843   if (! (functions & Func_Close)) return;
1844
1845   XEvent ce;
1846   ce.xclient.type = ClientMessage;
1847   ce.xclient.message_type =  xatom->getAtom(XAtom::wm_protocols);
1848   ce.xclient.display = otk::OBDisplay::display;
1849   ce.xclient.window = client.window;
1850   ce.xclient.format = 32;
1851   ce.xclient.data.l[0] = xatom->getAtom(XAtom::wm_delete_window);
1852   ce.xclient.data.l[1] = CurrentTime;
1853   ce.xclient.data.l[2] = 0l;
1854   ce.xclient.data.l[3] = 0l;
1855   ce.xclient.data.l[4] = 0l;
1856   XSendEvent(otk::OBDisplay::display, client.window, False, NoEventMask, &ce);
1857   XFlush(otk::OBDisplay::display);
1858 }
1859
1860
1861 void BlackboxWindow::withdraw(void) {
1862   // We don't need to worry about resizing because resizing always grabs the X
1863   // server. This should only ever happen if using opaque moving.
1864   if (flags.moving)
1865     endMove();
1866     
1867   flags.visible = False;
1868   flags.iconic = False;
1869
1870   setState(current_state);
1871
1872   XUnmapWindow(otk::OBDisplay::display, frame.window);
1873
1874   XGrabServer(otk::OBDisplay::display);
1875
1876   unsigned long event_mask = PropertyChangeMask | FocusChangeMask |
1877                              StructureNotifyMask;
1878   XSelectInput(otk::OBDisplay::display, client.window,
1879                event_mask & ~StructureNotifyMask);
1880   XUnmapWindow(otk::OBDisplay::display, client.window);
1881   XSelectInput(otk::OBDisplay::display, client.window, event_mask);
1882
1883   XUngrabServer(otk::OBDisplay::display);
1884 }
1885
1886
1887 void BlackboxWindow::maximize(unsigned int button) {
1888   if (! (functions & Func_Maximize)) return;
1889
1890   // We don't need to worry about resizing because resizing always grabs the X
1891   // server. This should only ever happen if using opaque moving.
1892   if (flags.moving)
1893     endMove();
1894
1895   if (flags.maximized) {
1896     flags.maximized = 0;
1897
1898     blackbox_attrib.flags &= ! (AttribMaxHoriz | AttribMaxVert);
1899     blackbox_attrib.attrib &= ! (AttribMaxHoriz | AttribMaxVert);
1900
1901     /*
1902       when a resize finishes, maximize(0) is called to clear any maximization
1903       flags currently set.  Otherwise it still thinks it is maximized.
1904       so we do not need to call configure() because resizing will handle it
1905     */
1906     if (! flags.resizing)
1907       configure(blackbox_attrib.premax_x, blackbox_attrib.premax_y,
1908                 blackbox_attrib.premax_w, blackbox_attrib.premax_h);
1909
1910     blackbox_attrib.premax_x = blackbox_attrib.premax_y = 0;
1911     blackbox_attrib.premax_w = blackbox_attrib.premax_h = 0;
1912
1913     redrawAllButtons(); // in case it is not called in configure()
1914     setState(current_state);
1915     return;
1916   }
1917
1918   blackbox_attrib.premax_x = frame.rect.x();
1919   blackbox_attrib.premax_y = frame.rect.y();
1920   blackbox_attrib.premax_w = frame.rect.width();
1921   // use client.rect so that clients can be restored even if shaded
1922   blackbox_attrib.premax_h =
1923     client.rect.height() + frame.margin.top + frame.margin.bottom;
1924
1925 #ifdef    XINERAMA
1926   if (screen->isXineramaActive() && blackbox->doXineramaMaximizing()) {
1927     // find the area to use
1928     RectList availableAreas = screen->allAvailableAreas();
1929     RectList::iterator it, end = availableAreas.end();
1930
1931     for (it = availableAreas.begin(); it != end; ++it)
1932       if (it->intersects(frame.rect)) break;
1933     if (it == end) // the window isn't inside an area
1934       it = availableAreas.begin(); // so just default to the first one
1935
1936     frame.changing = *it;
1937   } else
1938 #endif // XINERAMA
1939   frame.changing = screen->availableArea();
1940
1941   switch(button) {
1942   case 1:
1943     blackbox_attrib.flags |= AttribMaxHoriz | AttribMaxVert;
1944     blackbox_attrib.attrib |= AttribMaxHoriz | AttribMaxVert;
1945     break;
1946
1947   case 2:
1948     blackbox_attrib.flags |= AttribMaxVert;
1949     blackbox_attrib.attrib |= AttribMaxVert;
1950
1951     frame.changing.setX(frame.rect.x());
1952     frame.changing.setWidth(frame.rect.width());
1953     break;
1954
1955   case 3:
1956     blackbox_attrib.flags |= AttribMaxHoriz;
1957     blackbox_attrib.attrib |= AttribMaxHoriz;
1958
1959     frame.changing.setY(frame.rect.y());
1960     frame.changing.setHeight(frame.rect.height());
1961     break;
1962   }
1963
1964   constrain(TopLeft);
1965
1966   if (flags.shaded) {
1967     blackbox_attrib.flags ^= AttribShaded;
1968     blackbox_attrib.attrib ^= AttribShaded;
1969     flags.shaded = False;
1970   }
1971
1972   flags.maximized = button;
1973
1974   configure(frame.changing.x(), frame.changing.y(),
1975             frame.changing.width(), frame.changing.height());
1976   if (flags.focused)
1977     screen->getWorkspace(blackbox_attrib.workspace)->raiseWindow(this);
1978   redrawAllButtons(); // in case it is not called in configure()
1979   setState(current_state);
1980 }
1981
1982
1983 // re-maximizes the window to take into account availableArea changes
1984 void BlackboxWindow::remaximize(void) {
1985   if (flags.shaded) {
1986     // we only update the window's attributes otherwise we lose the shade bit
1987     switch(flags.maximized) {
1988     case 1:
1989       blackbox_attrib.flags |= AttribMaxHoriz | AttribMaxVert;
1990       blackbox_attrib.attrib |= AttribMaxHoriz | AttribMaxVert;
1991       break;
1992
1993     case 2:
1994       blackbox_attrib.flags |= AttribMaxVert;
1995       blackbox_attrib.attrib |= AttribMaxVert;
1996       break;
1997
1998     case 3:
1999       blackbox_attrib.flags |= AttribMaxHoriz;
2000       blackbox_attrib.attrib |= AttribMaxHoriz;
2001       break;
2002     }
2003     return;
2004   }
2005
2006   // save the original dimensions because maximize will wipe them out
2007   int premax_x = blackbox_attrib.premax_x,
2008     premax_y = blackbox_attrib.premax_y,
2009     premax_w = blackbox_attrib.premax_w,
2010     premax_h = blackbox_attrib.premax_h;
2011
2012   unsigned int button = flags.maximized;
2013   flags.maximized = 0; // trick maximize() into working
2014   maximize(button);
2015
2016   // restore saved values
2017   blackbox_attrib.premax_x = premax_x;
2018   blackbox_attrib.premax_y = premax_y;
2019   blackbox_attrib.premax_w = premax_w;
2020   blackbox_attrib.premax_h = premax_h;
2021 }
2022
2023
2024 void BlackboxWindow::setWorkspace(unsigned int n) {
2025   blackbox_attrib.flags |= AttribWorkspace;
2026   blackbox_attrib.workspace = n;
2027   if (n == BSENTINEL) { // iconified window
2028     /*
2029        we set the workspace to 'all workspaces' so that taskbars will show the
2030        window. otherwise, it made uniconifying a window imposible without the
2031        blackbox workspace menu
2032     */
2033     n = 0xffffffff;
2034   }
2035   xatom->setValue(client.window, XAtom::net_wm_desktop, XAtom::cardinal, n);
2036 }
2037
2038
2039 void BlackboxWindow::shade(void) {
2040   if (flags.shaded) {
2041     XResizeWindow(otk::OBDisplay::display, frame.window,
2042                   frame.inside_w, frame.inside_h);
2043     flags.shaded = False;
2044     blackbox_attrib.flags ^= AttribShaded;
2045     blackbox_attrib.attrib ^= AttribShaded;
2046
2047     setState(NormalState);
2048
2049     // set the frame rect to the normal size
2050     frame.rect.setHeight(client.rect.height() + frame.margin.top +
2051                          frame.margin.bottom);
2052   } else {
2053     if (! (decorations & Decor_Titlebar))
2054       return; // can't shade it without a titlebar!
2055
2056     XResizeWindow(otk::OBDisplay::display, frame.window,
2057                   frame.inside_w, frame.title_h);
2058     flags.shaded = True;
2059     blackbox_attrib.flags |= AttribShaded;
2060     blackbox_attrib.attrib |= AttribShaded;
2061
2062     setState(IconicState);
2063
2064     // set the frame rect to the shaded size
2065     frame.rect.setHeight(frame.title_h + (frame.border_w * 2));
2066   }
2067 }
2068
2069
2070 /*
2071  * (Un)Sticks a window and its relatives.
2072  */
2073 void BlackboxWindow::stick(void) {
2074   if (flags.stuck) {
2075     blackbox_attrib.flags ^= AttribOmnipresent;
2076     blackbox_attrib.attrib ^= AttribOmnipresent;
2077
2078     flags.stuck = False;
2079     
2080     for (unsigned int i = 0; i < screen->getNumberOfWorkspaces(); ++i)
2081       if (i != blackbox_attrib.workspace)
2082         screen->getWorkspace(i)->removeWindow(this, True);
2083
2084     if (! flags.iconic)
2085       screen->reassociateWindow(this, BSENTINEL, True);
2086     // temporary fix since sticky windows suck. set the hint to what we
2087     // actually hold in our data.
2088     xatom->setValue(client.window, XAtom::net_wm_desktop, XAtom::cardinal,
2089                     blackbox_attrib.workspace);
2090
2091     setState(current_state);
2092   } else {
2093     flags.stuck = True;
2094
2095     blackbox_attrib.flags |= AttribOmnipresent;
2096     blackbox_attrib.attrib |= AttribOmnipresent;
2097
2098     // temporary fix since sticky windows suck. set the hint to a different
2099     // value than that contained in the class' data.
2100     xatom->setValue(client.window, XAtom::net_wm_desktop, XAtom::cardinal,
2101                     0xffffffff);
2102     
2103     for (unsigned int i = 0; i < screen->getNumberOfWorkspaces(); ++i)
2104       if (i != blackbox_attrib.workspace)
2105         screen->getWorkspace(i)->addWindow(this, False, True);
2106
2107     setState(current_state);
2108   }
2109
2110   redrawAllButtons();
2111   
2112   // go up the chain
2113   if (isTransient() && client.transient_for != (BlackboxWindow *) ~0ul &&
2114       client.transient_for->isStuck() != flags.stuck)
2115     client.transient_for->stick();
2116   // go down the chain
2117   BlackboxWindowList::iterator it;
2118   const BlackboxWindowList::iterator end = client.transientList.end();
2119   for (it = client.transientList.begin(); it != end; ++it)
2120     if ((*it)->isStuck() != flags.stuck)
2121       (*it)->stick();
2122 }
2123
2124
2125 void BlackboxWindow::redrawWindowFrame(void) const {
2126   if (decorations & Decor_Titlebar) {
2127     if (flags.focused) {
2128       if (frame.ftitle)
2129         XSetWindowBackgroundPixmap(otk::OBDisplay::display,
2130                                    frame.title, frame.ftitle);
2131       else
2132         XSetWindowBackground(otk::OBDisplay::display,
2133                              frame.title, frame.ftitle_pixel);
2134     } else {
2135       if (frame.utitle)
2136         XSetWindowBackgroundPixmap(otk::OBDisplay::display,
2137                                    frame.title, frame.utitle);
2138       else
2139         XSetWindowBackground(otk::OBDisplay::display,
2140                              frame.title, frame.utitle_pixel);
2141     }
2142     XClearWindow(otk::OBDisplay::display, frame.title);
2143
2144     redrawLabel();
2145     redrawAllButtons();
2146   }
2147
2148   if (decorations & Decor_Handle) {
2149     if (flags.focused) {
2150       if (frame.fhandle)
2151         XSetWindowBackgroundPixmap(otk::OBDisplay::display,
2152                                    frame.handle, frame.fhandle);
2153       else
2154         XSetWindowBackground(otk::OBDisplay::display,
2155                              frame.handle, frame.fhandle_pixel);
2156
2157       if (frame.fgrip) {
2158         XSetWindowBackgroundPixmap(otk::OBDisplay::display,
2159                                    frame.left_grip, frame.fgrip);
2160         XSetWindowBackgroundPixmap(otk::OBDisplay::display,
2161                                    frame.right_grip, frame.fgrip);
2162       } else {
2163         XSetWindowBackground(otk::OBDisplay::display,
2164                              frame.left_grip, frame.fgrip_pixel);
2165         XSetWindowBackground(otk::OBDisplay::display,
2166                              frame.right_grip, frame.fgrip_pixel);
2167       }
2168     } else {
2169       if (frame.uhandle)
2170         XSetWindowBackgroundPixmap(otk::OBDisplay::display,
2171                                    frame.handle, frame.uhandle);
2172       else
2173         XSetWindowBackground(otk::OBDisplay::display,
2174                              frame.handle, frame.uhandle_pixel);
2175
2176       if (frame.ugrip) {
2177         XSetWindowBackgroundPixmap(otk::OBDisplay::display,
2178                                    frame.left_grip, frame.ugrip);
2179         XSetWindowBackgroundPixmap(otk::OBDisplay::display,
2180                                    frame.right_grip, frame.ugrip);
2181       } else {
2182         XSetWindowBackground(otk::OBDisplay::display,
2183                              frame.left_grip, frame.ugrip_pixel);
2184         XSetWindowBackground(otk::OBDisplay::display,
2185                              frame.right_grip, frame.ugrip_pixel);
2186       }
2187     }
2188     XClearWindow(otk::OBDisplay::display, frame.handle);
2189     XClearWindow(otk::OBDisplay::display, frame.left_grip);
2190     XClearWindow(otk::OBDisplay::display, frame.right_grip);
2191   }
2192
2193   if (decorations & Decor_Border) {
2194     if (flags.focused)
2195       XSetWindowBorder(otk::OBDisplay::display,
2196                        frame.plate, frame.fborder_pixel);
2197     else
2198       XSetWindowBorder(otk::OBDisplay::display,
2199                        frame.plate, frame.uborder_pixel);
2200   }
2201 }
2202
2203
2204 void BlackboxWindow::setFocusFlag(bool focus) {
2205   // only focus a window if it is visible
2206   if (focus && ! flags.visible)
2207     return;
2208
2209   flags.focused = focus;
2210
2211   redrawWindowFrame();
2212
2213   if (flags.focused)
2214     blackbox->setFocusedWindow(this);
2215 }
2216
2217
2218 void BlackboxWindow::installColormap(bool install) {
2219   int i = 0, ncmap = 0;
2220   Colormap *cmaps = XListInstalledColormaps(otk::OBDisplay::display,
2221                                             client.window, &ncmap);
2222   if (cmaps) {
2223     XWindowAttributes wattrib;
2224     if (XGetWindowAttributes(otk::OBDisplay::display,
2225                              client.window, &wattrib)) {
2226       if (install) {
2227         // install the window's colormap
2228         for (i = 0; i < ncmap; i++) {
2229           if (*(cmaps + i) == wattrib.colormap)
2230             // this window is using an installed color map... do not install
2231             install = False;
2232         }
2233         // otherwise, install the window's colormap
2234         if (install)
2235           XInstallColormap(otk::OBDisplay::display, wattrib.colormap);
2236       } else {
2237         // uninstall the window's colormap
2238         for (i = 0; i < ncmap; i++) {
2239           if (*(cmaps + i) == wattrib.colormap)
2240             // we found the colormap to uninstall
2241             XUninstallColormap(otk::OBDisplay::display, wattrib.colormap);
2242         }
2243       }
2244     }
2245
2246     XFree(cmaps);
2247   }
2248 }
2249
2250
2251 void BlackboxWindow::setAllowedActions(void) {
2252   Atom actions[7];
2253   int num = 0;
2254   
2255   actions[num++] = xatom->getAtom(XAtom::net_wm_action_shade);
2256   actions[num++] = xatom->getAtom(XAtom::net_wm_action_change_desktop);
2257   actions[num++] = xatom->getAtom(XAtom::net_wm_action_close);
2258
2259   if (functions & Func_Move)
2260     actions[num++] = xatom->getAtom(XAtom::net_wm_action_move);
2261   if (functions & Func_Resize)
2262     actions[num++] = xatom->getAtom(XAtom::net_wm_action_resize);
2263   if (functions & Func_Maximize) {
2264     actions[num++] = xatom->getAtom(XAtom::net_wm_action_maximize_horz);
2265     actions[num++] = xatom->getAtom(XAtom::net_wm_action_maximize_vert);
2266   }
2267
2268   xatom->setValue(client.window, XAtom::net_wm_allowed_actions, XAtom::atom,
2269                   actions, num);
2270 }
2271
2272
2273 void BlackboxWindow::setState(unsigned long new_state) {
2274   current_state = new_state;
2275
2276   unsigned long state[2];
2277   state[0] = current_state;
2278   state[1] = None;
2279   xatom->setValue(client.window, XAtom::wm_state, XAtom::wm_state, state, 2);
2280  
2281   xatom->setValue(client.window, XAtom::blackbox_attributes,
2282                   XAtom::blackbox_attributes, (unsigned long *)&blackbox_attrib,
2283                   PropBlackboxAttributesElements);
2284
2285   Atom netstate[8];
2286   int num = 0;
2287   if (flags.modal)
2288     netstate[num++] = xatom->getAtom(XAtom::net_wm_state_modal);
2289   if (flags.shaded)
2290     netstate[num++] = xatom->getAtom(XAtom::net_wm_state_shaded);
2291   if (flags.iconic)
2292     netstate[num++] = xatom->getAtom(XAtom::net_wm_state_hidden);
2293   if (flags.skip_taskbar)
2294     netstate[num++] = xatom->getAtom(XAtom::net_wm_state_skip_taskbar);
2295   if (flags.skip_pager)
2296     netstate[num++] = xatom->getAtom(XAtom::net_wm_state_skip_pager);
2297   if (flags.fullscreen)
2298     netstate[num++] = xatom->getAtom(XAtom::net_wm_state_fullscreen);
2299   if (flags.maximized == 1 || flags.maximized == 2)
2300     netstate[num++] = xatom->getAtom(XAtom::net_wm_state_maximized_vert);
2301   if (flags.maximized == 1 || flags.maximized == 3)
2302     netstate[num++] = xatom->getAtom(XAtom::net_wm_state_maximized_horz);
2303   xatom->setValue(client.window, XAtom::net_wm_state, XAtom::atom,
2304                   netstate, num);
2305 }
2306
2307
2308 bool BlackboxWindow::getState(void) {
2309   bool ret = xatom->getValue(client.window, XAtom::wm_state, XAtom::wm_state,
2310                              current_state);
2311   if (! ret) current_state = 0;
2312   return ret;
2313 }
2314
2315
2316 void BlackboxWindow::restoreAttributes(void) {
2317   unsigned long num = PropBlackboxAttributesElements;
2318   BlackboxAttributes *net;
2319   if (! xatom->getValue(client.window, XAtom::blackbox_attributes,
2320                         XAtom::blackbox_attributes, num,
2321                         (unsigned long **)&net))
2322     return;
2323   if (num < PropBlackboxAttributesElements) {
2324     delete [] net;
2325     return;
2326   }
2327
2328   if (net->flags & AttribShaded && net->attrib & AttribShaded) {
2329     flags.shaded = False;
2330     unsigned long orig_state = current_state;
2331     shade();
2332
2333     /*
2334       At this point in the life of a window, current_state should only be set
2335       to IconicState if the window was an *icon*, not if it was shaded.
2336     */
2337     if (orig_state != IconicState)
2338       current_state = WithdrawnState;
2339  }
2340
2341   if (net->workspace != screen->getCurrentWorkspaceID() &&
2342       net->workspace < screen->getWorkspaceCount())
2343     screen->reassociateWindow(this, net->workspace, True);
2344
2345   if ((blackbox_attrib.workspace != screen->getCurrentWorkspaceID()) &&
2346       (blackbox_attrib.workspace < screen->getWorkspaceCount())) {
2347     // set to WithdrawnState so it will be mapped on the new workspace
2348     if (current_state == NormalState) current_state = WithdrawnState;
2349   } else if (current_state == WithdrawnState) {
2350     // the window is on this workspace and is Withdrawn, so it is waiting to
2351     // be mapped
2352     current_state = NormalState;
2353   }
2354
2355   if (net->flags & AttribOmnipresent && net->attrib & AttribOmnipresent &&
2356       ! flags.stuck) {
2357     stick();
2358
2359     // if the window was on another workspace, it was going to be hidden. this
2360     // specifies that the window should be mapped since it is sticky.
2361     if (current_state == WithdrawnState) current_state = NormalState;
2362   }
2363
2364   if (net->flags & AttribMaxHoriz || net->flags & AttribMaxVert) {
2365     int x = net->premax_x, y = net->premax_y;
2366     unsigned int w = net->premax_w, h = net->premax_h;
2367     flags.maximized = 0;
2368
2369     unsigned int m = 0;
2370     if ((net->flags & AttribMaxHoriz) &&
2371         (net->flags & AttribMaxVert))
2372       m = (net->attrib & (AttribMaxHoriz | AttribMaxVert)) ? 1 : 0;
2373     else if (net->flags & AttribMaxVert)
2374       m = (net->attrib & AttribMaxVert) ? 2 : 0;
2375     else if (net->flags & AttribMaxHoriz)
2376       m = (net->attrib & AttribMaxHoriz) ? 3 : 0;
2377
2378     if (m) maximize(m);
2379
2380     blackbox_attrib.premax_x = x;
2381     blackbox_attrib.premax_y = y;
2382     blackbox_attrib.premax_w = w;
2383     blackbox_attrib.premax_h = h;
2384   }
2385
2386   if (net->flags & AttribDecoration) {
2387     switch (net->decoration) {
2388     case DecorNone:
2389       enableDecor(False);
2390       break;
2391
2392     /* since tools only let you toggle this anyways, we'll just make that all
2393        it supports for now.
2394      */
2395     default:
2396     case DecorNormal:
2397     case DecorTiny:
2398     case DecorTool:
2399       enableDecor(True);
2400       break;
2401     }
2402   }
2403
2404   // with the state set it will then be the map event's job to read the
2405   // window's state and behave accordingly
2406
2407   delete [] net;
2408 }
2409
2410
2411 /*
2412  * Positions the Rect r according the the client window position and
2413  * window gravity.
2414  */
2415 void BlackboxWindow::applyGravity(otk::Rect &r) {
2416   // apply horizontal window gravity
2417   switch (client.win_gravity) {
2418   default:
2419   case NorthWestGravity:
2420   case SouthWestGravity:
2421   case WestGravity:
2422     r.setX(client.rect.x());
2423     break;
2424
2425   case NorthGravity:
2426   case SouthGravity:
2427   case CenterGravity:
2428     r.setX(client.rect.x() - (frame.margin.left + frame.margin.right) / 2);
2429     break;
2430
2431   case NorthEastGravity:
2432   case SouthEastGravity:
2433   case EastGravity:
2434     r.setX(client.rect.x() - frame.margin.left - frame.margin.right + 2);
2435     break;
2436
2437   case ForgetGravity:
2438   case StaticGravity:
2439     r.setX(client.rect.x() - frame.margin.left);
2440     break;
2441   }
2442
2443   // apply vertical window gravity
2444   switch (client.win_gravity) {
2445   default:
2446   case NorthWestGravity:
2447   case NorthEastGravity:
2448   case NorthGravity:
2449     r.setY(client.rect.y());
2450     break;
2451
2452   case CenterGravity:
2453   case EastGravity:
2454   case WestGravity:
2455     r.setY(client.rect.y() - (frame.margin.top + frame.margin.bottom) / 2);
2456     break;
2457
2458   case SouthWestGravity:
2459   case SouthEastGravity:
2460   case SouthGravity:
2461     r.setY(client.rect.y() - frame.margin.top - frame.margin.bottom + 2);
2462     break;
2463
2464   case ForgetGravity:
2465   case StaticGravity:
2466     r.setY(client.rect.y() - frame.margin.top);
2467     break;
2468   }
2469 }
2470
2471
2472 /*
2473  * The reverse of the applyGravity function.
2474  *
2475  * Positions the Rect r according to the frame window position and
2476  * window gravity.
2477  */
2478 void BlackboxWindow::restoreGravity(otk::Rect &r) {
2479   // restore horizontal window gravity
2480   switch (client.win_gravity) {
2481   default:
2482   case NorthWestGravity:
2483   case SouthWestGravity:
2484   case WestGravity:
2485     r.setX(frame.rect.x());
2486     break;
2487
2488   case NorthGravity:
2489   case SouthGravity:
2490   case CenterGravity:
2491     r.setX(frame.rect.x() + (frame.margin.left + frame.margin.right) / 2);
2492     break;
2493
2494   case NorthEastGravity:
2495   case SouthEastGravity:
2496   case EastGravity:
2497     r.setX(frame.rect.x() + frame.margin.left + frame.margin.right - 2);
2498     break;
2499
2500   case ForgetGravity:
2501   case StaticGravity:
2502     r.setX(frame.rect.x() + frame.margin.left);
2503     break;
2504   }
2505
2506   // restore vertical window gravity
2507   switch (client.win_gravity) {
2508   default:
2509   case NorthWestGravity:
2510   case NorthEastGravity:
2511   case NorthGravity:
2512     r.setY(frame.rect.y());
2513     break;
2514
2515   case CenterGravity:
2516   case EastGravity:
2517   case WestGravity:
2518     r.setY(frame.rect.y() + (frame.margin.top + frame.margin.bottom) / 2);
2519     break;
2520
2521   case SouthWestGravity:
2522   case SouthEastGravity:
2523   case SouthGravity:
2524     r.setY(frame.rect.y() + frame.margin.top + frame.margin.bottom - 2);
2525     break;
2526
2527   case ForgetGravity:
2528   case StaticGravity:
2529     r.setY(frame.rect.y() + frame.margin.top);
2530     break;
2531   }
2532 }
2533
2534
2535 void BlackboxWindow::redrawLabel(void) const {
2536   if (flags.focused) {
2537     if (frame.flabel)
2538       XSetWindowBackgroundPixmap(otk::OBDisplay::display,
2539                                  frame.label, frame.flabel);
2540     else
2541       XSetWindowBackground(otk::OBDisplay::display,
2542                            frame.label, frame.flabel_pixel);
2543   } else {
2544     if (frame.ulabel)
2545       XSetWindowBackgroundPixmap(otk::OBDisplay::display,
2546                                  frame.label, frame.ulabel);
2547     else
2548       XSetWindowBackground(otk::OBDisplay::display,
2549                            frame.label, frame.ulabel_pixel);
2550   }
2551   XClearWindow(otk::OBDisplay::display, frame.label);
2552
2553   WindowStyle *style = screen->getWindowStyle();
2554
2555   int pos = frame.bevel_w * 2;
2556   style->doJustify(client.title.c_str(), pos, frame.label_w, frame.bevel_w * 4);
2557   style->font->drawString(frame.label, pos, 1,
2558                           (flags.focused ? style->l_text_focus :
2559                            style->l_text_unfocus),
2560                           client.title);
2561 }
2562
2563
2564 void BlackboxWindow::redrawAllButtons(void) const {
2565   if (frame.iconify_button) redrawIconifyButton(False);
2566   if (frame.maximize_button) redrawMaximizeButton(flags.maximized);
2567   if (frame.close_button) redrawCloseButton(False);
2568   if (frame.stick_button) redrawStickyButton(flags.stuck);
2569 }
2570
2571
2572 void BlackboxWindow::redrawButton(bool pressed, Window win,
2573                                   Pixmap fppix, unsigned long fppixel,
2574                                   Pixmap uppix, unsigned long uppixel,
2575                                   Pixmap fpix, unsigned long fpixel,
2576                                   Pixmap upix, unsigned long upixel) const {
2577   Pixmap p;
2578   unsigned long pix;
2579   
2580   if (pressed) {
2581     if (flags.focused) {
2582       p = fppix;
2583       pix = fppixel;
2584     } else {
2585       p = uppix;
2586       pix = uppixel;
2587     }
2588   } else {
2589     if (flags.focused) {
2590       p = fpix;
2591       pix = fpixel;
2592     } else {
2593       p = upix;
2594       pix = upixel;
2595     }
2596   }
2597   
2598   if (p)
2599     XSetWindowBackgroundPixmap(otk::OBDisplay::display, win, p);
2600   else
2601     XSetWindowBackground(otk::OBDisplay::display, win, pix);
2602
2603 }
2604
2605 void BlackboxWindow::redrawIconifyButton(bool pressed) const {
2606   redrawButton(pressed, frame.iconify_button, 
2607                frame.pfbutton, frame.pfbutton_pixel,
2608                frame.pubutton, frame.pubutton_pixel,
2609                frame.fbutton, frame.fbutton_pixel,
2610                frame.ubutton, frame.ubutton_pixel);
2611
2612   XClearWindow(otk::OBDisplay::display, frame.iconify_button);
2613   otk::BPen pen((flags.focused) ? screen->getWindowStyle()->b_pic_focus :
2614                 screen->getWindowStyle()->b_pic_unfocus);
2615
2616   PixmapMask pm = screen->getWindowStyle()->icon_button;
2617   
2618   if (screen->getWindowStyle()->icon_button.mask != None) {
2619     XSetClipMask(otk::OBDisplay::display, pen.gc(), pm.mask);
2620     XSetClipOrigin(otk::OBDisplay::display, pen.gc(),
2621                    (frame.button_w - pm.w)/2, (frame.button_w - pm.h)/2);
2622
2623     XFillRectangle(otk::OBDisplay::display, frame.iconify_button, pen.gc(),
2624                    (frame.button_w - pm.w)/2, (frame.button_w - pm.h)/2,
2625                    (frame.button_w + pm.w)/2, (frame.button_w + pm.h)/2);
2626
2627     XSetClipMask(otk::OBDisplay::display, pen.gc(), None);
2628     XSetClipOrigin(otk::OBDisplay::display, pen.gc(), 0, 0);
2629   } else {
2630     XDrawRectangle(otk::OBDisplay::display, frame.iconify_button, pen.gc(),
2631                    2, (frame.button_w - 5), (frame.button_w - 5), 2);
2632   }
2633 }
2634
2635
2636 void BlackboxWindow::redrawMaximizeButton(bool pressed) const {
2637   redrawButton(pressed, frame.maximize_button, 
2638                frame.pfbutton, frame.pfbutton_pixel,
2639                frame.pubutton, frame.pubutton_pixel,
2640                frame.fbutton, frame.fbutton_pixel,
2641                frame.ubutton, frame.ubutton_pixel);
2642
2643   XClearWindow(otk::OBDisplay::display, frame.maximize_button);
2644
2645   otk::BPen pen((flags.focused) ? screen->getWindowStyle()->b_pic_focus :
2646                 screen->getWindowStyle()->b_pic_unfocus);
2647   
2648   PixmapMask pm = screen->getWindowStyle()->max_button;
2649     
2650   if (pm.mask != None) {
2651     XSetClipMask(otk::OBDisplay::display, pen.gc(), pm.mask);
2652     XSetClipOrigin(otk::OBDisplay::display, pen.gc(),
2653                    (frame.button_w - pm.w)/2, (frame.button_w - pm.h)/2);
2654
2655     XFillRectangle(otk::OBDisplay::display, frame.maximize_button, pen.gc(),
2656                    (frame.button_w - pm.w)/2, (frame.button_w - pm.h)/2,
2657                    (frame.button_w + pm.w)/2, (frame.button_w + pm.h)/2);
2658     
2659     XSetClipOrigin(otk::OBDisplay::display, pen.gc(), 0, 0 );
2660     XSetClipMask( otk::OBDisplay::display, pen.gc(), None );
2661   } else {
2662     XDrawRectangle(otk::OBDisplay::display, frame.maximize_button, pen.gc(),
2663                    2, 2, (frame.button_w - 5), (frame.button_w - 5));
2664     XDrawLine(otk::OBDisplay::display, frame.maximize_button, pen.gc(),
2665               2, 3, (frame.button_w - 3), 3);
2666   }
2667 }
2668
2669
2670 void BlackboxWindow::redrawCloseButton(bool pressed) const {
2671   redrawButton(pressed, frame.close_button, 
2672                frame.pfbutton, frame.pfbutton_pixel,
2673                frame.pubutton, frame.pubutton_pixel,
2674                frame.fbutton, frame.fbutton_pixel,
2675                frame.ubutton, frame.ubutton_pixel);
2676
2677   XClearWindow(otk::OBDisplay::display, frame.close_button);
2678
2679   otk::BPen pen((flags.focused) ? screen->getWindowStyle()->b_pic_focus :
2680                 screen->getWindowStyle()->b_pic_unfocus);
2681   
2682   PixmapMask pm = screen->getWindowStyle()->close_button;
2683
2684   if (pm.mask != None) {
2685     XSetClipMask(otk::OBDisplay::display, pen.gc(), pm.mask);
2686     XSetClipOrigin(otk::OBDisplay::display, pen.gc(),
2687                    (frame.button_w - pm.w)/2, (frame.button_w - pm.h)/2);
2688     
2689     XFillRectangle(otk::OBDisplay::display, frame.close_button, pen.gc(),
2690                    (frame.button_w - pm.w)/2, (frame.button_w - pm.h)/2,
2691                    (frame.button_w + pm.w)/2, (frame.button_w + pm.h)/2);
2692
2693   
2694     XSetClipOrigin(otk::OBDisplay::display, pen.gc(), 0, 0 );
2695     XSetClipMask( otk::OBDisplay::display, pen.gc(), None );
2696   } else {
2697     XDrawLine(otk::OBDisplay::display, frame.close_button, pen.gc(),
2698               2, 2, (frame.button_w - 3), (frame.button_w - 3));
2699     XDrawLine(otk::OBDisplay::display, frame.close_button, pen.gc(),
2700               2, (frame.button_w - 3), (frame.button_w - 3), 2);
2701   }
2702 }
2703
2704 void BlackboxWindow::redrawStickyButton(bool pressed) const {
2705   redrawButton(pressed, frame.stick_button, 
2706                frame.pfbutton, frame.pfbutton_pixel,
2707                frame.pubutton, frame.pubutton_pixel,
2708                frame.fbutton, frame.fbutton_pixel,
2709                frame.ubutton, frame.ubutton_pixel);
2710
2711   XClearWindow(otk::OBDisplay::display, frame.stick_button);
2712
2713   otk::BPen pen((flags.focused) ? screen->getWindowStyle()->b_pic_focus :
2714                 screen->getWindowStyle()->b_pic_unfocus);
2715   
2716   PixmapMask pm = screen->getWindowStyle()->stick_button;
2717
2718   if (pm.mask != None) {
2719     XSetClipMask(otk::OBDisplay::display, pen.gc(), pm.mask);
2720     XSetClipOrigin(otk::OBDisplay::display, pen.gc(),
2721                    (frame.button_w - pm.w)/2, (frame.button_w - pm.h)/2);
2722     
2723     XFillRectangle(otk::OBDisplay::display, frame.stick_button, pen.gc(),
2724                    (frame.button_w - pm.w)/2, (frame.button_w - pm.h)/2,
2725                    (frame.button_w + pm.w)/2, (frame.button_w + pm.h)/2);
2726
2727   
2728     XSetClipOrigin(otk::OBDisplay::display, pen.gc(), 0, 0 );
2729     XSetClipMask( otk::OBDisplay::display, pen.gc(), None );
2730   } else {
2731     XFillRectangle(otk::OBDisplay::display, frame.stick_button, pen.gc(),
2732                    frame.button_w/2 - 1, frame.button_w/2 -1, 2, 2 );
2733   }
2734 }
2735
2736 void BlackboxWindow::mapRequestEvent(const XMapRequestEvent *re) {
2737   if (re->window != client.window)
2738     return;
2739
2740 #ifdef    DEBUG
2741   fprintf(stderr, "BlackboxWindow::mapRequestEvent() for 0x%lx\n",
2742           client.window);
2743 #endif // DEBUG
2744
2745   /*
2746      Even though the window wants to be shown, if it is not on the current
2747      workspace, then it isn't going to be shown right now.
2748   */
2749   if (! flags.stuck &&
2750       blackbox_attrib.workspace != screen->getCurrentWorkspaceID() &&
2751       blackbox_attrib.workspace < screen->getWorkspaceCount())
2752     if (current_state == NormalState) current_state = WithdrawnState;
2753
2754   switch (current_state) {
2755   case IconicState:
2756     iconify();
2757     break;
2758
2759   case WithdrawnState:
2760     withdraw();
2761     break;
2762
2763   case NormalState:
2764   case InactiveState:
2765   case ZoomState:
2766   default:
2767     show();
2768     screen->getWorkspace(blackbox_attrib.workspace)->raiseWindow(this);
2769     if (isNormal()) {
2770       if (blackbox->state() != Openbox::State_Starting) {
2771         XSync(otk::OBDisplay::display, False); // make sure the frame is mapped
2772         if (screen->doFocusNew() || (isTransient() && getTransientFor() &&
2773                                      getTransientFor()->isFocused())) {
2774           setInputFocus();
2775         }
2776         if (screen->getPlacementPolicy() == BScreen::ClickMousePlacement) {
2777           int x, y, rx, ry;
2778           Window c, r;
2779           unsigned int m;
2780           XQueryPointer(otk::OBDisplay::display, screen->getRootWindow(),
2781                         &r, &c, &rx, &ry, &x, &y, &m);
2782           beginMove(rx, ry);
2783         }
2784       }
2785     }
2786     break;
2787   }
2788 }
2789
2790
2791 void BlackboxWindow::unmapNotifyEvent(const XUnmapEvent *ue) {
2792   if (ue->window != client.window)
2793     return;
2794
2795 #ifdef    DEBUG
2796   fprintf(stderr, "BlackboxWindow::unmapNotifyEvent() for 0x%lx\n",
2797           client.window);
2798 #endif // DEBUG
2799
2800   screen->unmanageWindow(this, False);
2801 }
2802
2803
2804 void BlackboxWindow::destroyNotifyEvent(const XDestroyWindowEvent *de) {
2805   if (de->window != client.window)
2806     return;
2807
2808 #ifdef    DEBUG
2809   fprintf(stderr, "BlackboxWindow::destroyNotifyEvent() for 0x%lx\n",
2810           client.window);
2811 #endif // DEBUG
2812
2813   screen->unmanageWindow(this, False);
2814 }
2815
2816
2817 void BlackboxWindow::reparentNotifyEvent(const XReparentEvent *re) {
2818   if (re->window != client.window || re->parent == frame.plate)
2819     return;
2820
2821 #ifdef    DEBUG
2822   fprintf(stderr, "BlackboxWindow::reparentNotifyEvent(): reparent 0x%lx to "
2823           "0x%lx.\n", client.window, re->parent);
2824 #endif // DEBUG
2825
2826   XEvent ev;
2827   ev.xreparent = *re;
2828   XPutBackEvent(otk::OBDisplay::display, &ev);
2829   screen->unmanageWindow(this, True);
2830 }
2831
2832
2833 void BlackboxWindow::propertyNotifyEvent(const XPropertyEvent *pe) {
2834   if (pe->state == PropertyDelete || ! validateClient())
2835     return;
2836
2837 #if 0
2838   fprintf(stderr, "BlackboxWindow::propertyNotifyEvent(): for 0x%lx\n",
2839           client.window);
2840 #endif
2841
2842   switch(pe->atom) {
2843   case XA_WM_CLASS:
2844   case XA_WM_CLIENT_MACHINE:
2845   case XA_WM_COMMAND:
2846     break;
2847
2848   case XA_WM_TRANSIENT_FOR: {
2849     bool s = flags.stuck;
2850     
2851     // determine if this is a transient window
2852     getTransientInfo();
2853
2854     if (flags.stuck != s) stick();
2855
2856     // adjust the window decorations based on transience
2857     if (isTransient()) {
2858       functions &= ~Func_Maximize;
2859       setAllowedActions();
2860       setupDecor();
2861     }
2862
2863     reconfigure();
2864   }
2865     break;
2866
2867   case XA_WM_HINTS:
2868     getWMHints();
2869     break;
2870
2871   case XA_WM_ICON_NAME:
2872     getWMIconName();
2873     if (flags.iconic) screen->propagateWindowName(this);
2874     break;
2875
2876   case XAtom::net_wm_name:
2877   case XA_WM_NAME:
2878     getWMName();
2879
2880     if (decorations & Decor_Titlebar)
2881       redrawLabel();
2882
2883     screen->propagateWindowName(this);
2884     break;
2885
2886   case XA_WM_NORMAL_HINTS: {
2887     getWMNormalHints();
2888
2889     if ((client.normal_hint_flags & PMinSize) &&
2890         (client.normal_hint_flags & PMaxSize)) {
2891       // the window now can/can't resize itself, so the buttons need to be
2892       // regrabbed.
2893       ungrabButtons();
2894       if (client.max_width <= client.min_width &&
2895           client.max_height <= client.min_height) {
2896         functions &= ~(Func_Resize | Func_Maximize);
2897       } else {
2898         if (! isTransient())
2899           functions |= Func_Maximize;
2900         functions |= Func_Resize;
2901       }
2902       grabButtons();
2903       setAllowedActions();
2904       setupDecor();
2905     }
2906
2907     otk::Rect old_rect = frame.rect;
2908
2909     upsize();
2910
2911     if (old_rect != frame.rect)
2912       reconfigure();
2913
2914     break;
2915   }
2916
2917   default:
2918     if (pe->atom == xatom->getAtom(XAtom::wm_protocols)) {
2919       getWMProtocols();
2920
2921       if ((decorations & Decor_Close) && (! frame.close_button)) {
2922         createCloseButton();
2923         if (decorations & Decor_Titlebar) {
2924           positionButtons(True);
2925           XMapSubwindows(otk::OBDisplay::display, frame.title);
2926         }
2927       }
2928     } else if (pe->atom == xatom->getAtom(XAtom::net_wm_strut)) {
2929       updateStrut();
2930     }
2931
2932     break;
2933   }
2934 }
2935
2936
2937 void BlackboxWindow::exposeEvent(const XExposeEvent *ee) {
2938 #if 0
2939   fprintf(stderr, "BlackboxWindow::exposeEvent() for 0x%lx\n", client.window);
2940 #endif
2941
2942   if (frame.label == ee->window && (decorations & Decor_Titlebar))
2943     redrawLabel();
2944   else if (frame.close_button == ee->window)
2945     redrawCloseButton(False);
2946   else if (frame.maximize_button == ee->window)
2947     redrawMaximizeButton(flags.maximized);
2948   else if (frame.iconify_button == ee->window)
2949     redrawIconifyButton(False);
2950   else if (frame.stick_button == ee->window)
2951     redrawStickyButton(flags.stuck);
2952 }
2953
2954
2955 void BlackboxWindow::configureRequestEvent(const XConfigureRequestEvent *cr) {
2956   if (cr->window != client.window || flags.iconic)
2957     return;
2958
2959   if (cr->value_mask & CWBorderWidth)
2960     client.old_bw = cr->border_width;
2961
2962   if (cr->value_mask & (CWX | CWY | CWWidth | CWHeight)) {
2963     frame.changing = frame.rect;
2964
2965     if (cr->value_mask & (CWX | CWY)) {
2966       if (cr->value_mask & CWX)
2967         client.rect.setX(cr->x);
2968       if (cr->value_mask & CWY)
2969         client.rect.setY(cr->y);
2970
2971       applyGravity(frame.changing);
2972     }
2973
2974     if (cr->value_mask & (CWWidth | CWHeight)) {
2975       if (cr->value_mask & CWWidth)
2976         frame.changing.setWidth(cr->width +
2977                                 frame.margin.left + frame.margin.right);
2978
2979       if (cr->value_mask & CWHeight)
2980         frame.changing.setHeight(cr->height +
2981                                  frame.margin.top + frame.margin.bottom);
2982
2983       /*
2984         if a position change has been specified, then that position will be
2985         used instead of determining a position based on the window's gravity.
2986       */
2987       if (! (cr->value_mask & (CWX | CWY))) {
2988         Corner corner;
2989         switch (client.win_gravity) {
2990         case NorthEastGravity:
2991         case EastGravity:
2992           corner = TopRight;
2993           break;
2994         case SouthWestGravity:
2995         case SouthGravity:
2996           corner = BottomLeft;
2997           break;
2998         case SouthEastGravity:
2999           corner = BottomRight;
3000           break;
3001         default:     // NorthWest, Static, etc
3002           corner = TopLeft;
3003         }
3004         constrain(corner);
3005       }
3006     }
3007
3008     configure(frame.changing.x(), frame.changing.y(),
3009               frame.changing.width(), frame.changing.height());
3010   }
3011
3012   if (cr->value_mask & CWStackMode && !isDesktop()) {
3013     switch (cr->detail) {
3014     case Below:
3015     case BottomIf:
3016       screen->getWorkspace(blackbox_attrib.workspace)->lowerWindow(this);
3017       break;
3018
3019     case Above:
3020     case TopIf:
3021     default:
3022       screen->getWorkspace(blackbox_attrib.workspace)->raiseWindow(this);
3023       break;
3024     }
3025   }
3026 }
3027
3028
3029 void BlackboxWindow::buttonPressEvent(const XButtonEvent *be) {
3030 #ifdef DEBUG
3031   fprintf(stderr, "BlackboxWindow::buttonPressEvent() for 0x%lx\n",
3032           client.window);
3033 #endif
3034
3035   if (frame.maximize_button == be->window && be->button <= 3) {
3036     redrawMaximizeButton(True);
3037   } else if (be->button == 1 || (be->button == 3 && be->state == mod_mask)) {
3038     if (! flags.focused)
3039       setInputFocus();
3040
3041     if (frame.iconify_button == be->window) {
3042       redrawIconifyButton(True);
3043     } else if (frame.close_button == be->window) {
3044       redrawCloseButton(True);
3045     } else if (frame.stick_button == be->window) {
3046       redrawStickyButton(True);
3047     } else if (frame.plate == be->window) {
3048       screen->getWorkspace(blackbox_attrib.workspace)->raiseWindow(this);
3049
3050       XAllowEvents(otk::OBDisplay::display, ReplayPointer, be->time);
3051     } else {
3052       if (frame.title == be->window || frame.label == be->window) {
3053         if (((be->time - lastButtonPressTime) <=
3054              blackbox->getDoubleClickInterval()) ||
3055             (be->state == ControlMask)) {
3056           lastButtonPressTime = 0;
3057           shade();
3058         } else {
3059           lastButtonPressTime = be->time;
3060         }
3061       }
3062
3063       screen->getWorkspace(blackbox_attrib.workspace)->raiseWindow(this);
3064     }
3065   } else if (be->button == 2 && (be->window != frame.iconify_button) &&
3066              (be->window != frame.close_button) &&
3067              (be->window != frame.stick_button)) {
3068     screen->getWorkspace(blackbox_attrib.workspace)->lowerWindow(this);
3069   // mouse wheel up
3070   } else if (be->button == 4) {
3071     if ((be->window == frame.label ||
3072          be->window == frame.title ||
3073          be->window == frame.maximize_button ||
3074          be->window == frame.iconify_button ||
3075          be->window == frame.close_button ||
3076          be->window == frame.stick_button) &&
3077         ! flags.shaded)
3078       shade();
3079   // mouse wheel down
3080   } else if (be->button == 5) {
3081     if ((be->window == frame.label ||
3082          be->window == frame.title ||
3083          be->window == frame.maximize_button ||
3084          be->window == frame.iconify_button ||
3085          be->window == frame.close_button ||
3086          be->window == frame.stick_button) &&
3087         flags.shaded)
3088       shade();
3089   }
3090 }
3091
3092
3093 void BlackboxWindow::buttonReleaseEvent(const XButtonEvent *re) {
3094 #ifdef DEBUG
3095   fprintf(stderr, "BlackboxWindow::buttonReleaseEvent() for 0x%lx\n",
3096           client.window);
3097 #endif
3098
3099   if (re->window == frame.maximize_button &&
3100       re->button >= 1 && re->button <= 3) {
3101     if ((re->x >= 0 && re->x <= static_cast<signed>(frame.button_w)) &&
3102         (re->y >= 0 && re->y <= static_cast<signed>(frame.button_w))) {
3103       maximize(re->button);
3104     } else {
3105       redrawMaximizeButton(flags.maximized);
3106     }
3107   } else if (re->window == frame.iconify_button && re->button == 1) {
3108     if ((re->x >= 0 && re->x <= static_cast<signed>(frame.button_w)) &&
3109         (re->y >= 0 && re->y <= static_cast<signed>(frame.button_w))) {
3110       iconify();
3111     } else {
3112       redrawIconifyButton(False);
3113     }
3114   } else if (re->window == frame.stick_button && re->button == 1) {
3115     if ((re->x >= 0 && re->x <= static_cast<signed>(frame.button_w)) &&
3116         (re->y >= 0 && re->y <= static_cast<signed>(frame.button_w))) {
3117       stick();
3118     } else {
3119       redrawStickyButton(False);
3120     }
3121   } else if (re->window == frame.close_button & re->button == 1) {
3122     if ((re->x >= 0 && re->x <= static_cast<signed>(frame.button_w)) &&
3123         (re->y >= 0 && re->y <= static_cast<signed>(frame.button_w)))
3124       close();
3125     redrawCloseButton(False);
3126   } else if (flags.moving) {
3127     endMove();
3128   } else if (flags.resizing) {
3129     endResize();
3130   } else if (re->window == frame.window) {
3131     if (re->button == 2 && re->state == mod_mask)
3132       XUngrabPointer(otk::OBDisplay::display, CurrentTime);
3133   }
3134 }
3135
3136
3137
3138 void BlackboxWindow::beginMove(int x_root, int y_root) {
3139   if (! (functions & Func_Move)) return;
3140
3141   assert(! (flags.resizing || flags.moving));
3142
3143   /*
3144     Only one window can be moved/resized at a time. If another window is already
3145     being moved or resized, then stop it before whating to work with this one.
3146   */
3147   BlackboxWindow *changing = blackbox->getChangingWindow();
3148   if (changing && changing != this) {
3149     if (changing->flags.moving)
3150       changing->endMove();
3151     else // if (changing->flags.resizing)
3152       changing->endResize();
3153   }
3154   
3155   XGrabPointer(otk::OBDisplay::display, frame.window, False,
3156                PointerMotionMask | ButtonReleaseMask,
3157                GrabModeAsync, GrabModeAsync,
3158                None, blackbox->getMoveCursor(), CurrentTime);
3159
3160   flags.moving = True;
3161   blackbox->setChangingWindow(this);
3162
3163   if (! screen->doOpaqueMove()) {
3164     XGrabServer(otk::OBDisplay::display);
3165
3166     frame.changing = frame.rect;
3167     screen->showPosition(frame.changing.x(), frame.changing.y());
3168
3169     XDrawRectangle(otk::OBDisplay::display, screen->getRootWindow(),
3170                    screen->getOpGC(),
3171                    frame.changing.x(),
3172                    frame.changing.y(),
3173                    frame.changing.width() - 1,
3174                    frame.changing.height() - 1);
3175   }
3176
3177   frame.grab_x = x_root - frame.rect.x() - frame.border_w;
3178   frame.grab_y = y_root - frame.rect.y() - frame.border_w;
3179 }
3180
3181
3182 void BlackboxWindow::doMove(int x_root, int y_root) {
3183   assert(flags.moving);
3184   assert(blackbox->getChangingWindow() == this);
3185
3186   int dx = x_root - frame.grab_x, dy = y_root - frame.grab_y;
3187   dx -= frame.border_w;
3188   dy -= frame.border_w;
3189
3190   doWindowSnapping(dx, dy);
3191
3192   if (screen->doOpaqueMove()) {
3193     if (screen->doWorkspaceWarping())
3194       doWorkspaceWarping(x_root, y_root, dx);
3195
3196     configure(dx, dy, frame.rect.width(), frame.rect.height());
3197   } else {
3198     XDrawRectangle(otk::OBDisplay::display, screen->getRootWindow(),
3199                    screen->getOpGC(),
3200                    frame.changing.x(),
3201                    frame.changing.y(),
3202                    frame.changing.width() - 1,
3203                    frame.changing.height() - 1);
3204
3205     if (screen->doWorkspaceWarping())
3206       doWorkspaceWarping(x_root, y_root, dx);
3207
3208     frame.changing.setPos(dx, dy);
3209
3210     XDrawRectangle(otk::OBDisplay::display, screen->getRootWindow(),
3211                    screen->getOpGC(),
3212                    frame.changing.x(),
3213                    frame.changing.y(),
3214                    frame.changing.width() - 1,
3215                    frame.changing.height() - 1);
3216   }
3217
3218   screen->showPosition(dx, dy);
3219 }
3220
3221
3222 void BlackboxWindow::doWorkspaceWarping(int x_root, int y_root, int &dx) {
3223   // workspace warping
3224   bool warp = False;
3225   unsigned int dest = screen->getCurrentWorkspaceID();
3226   if (x_root <= 0) {
3227     warp = True;
3228
3229     if (dest > 0) dest--;
3230     else dest = screen->getNumberOfWorkspaces() - 1;
3231
3232   } else if (x_root >= screen->getRect().right()) {
3233     warp = True;
3234
3235     if (dest < screen->getNumberOfWorkspaces() - 1) dest++;
3236     else dest = 0;
3237   }
3238   if (! warp)
3239     return;
3240
3241   bool focus = flags.focused; // had focus while moving?
3242
3243   int dest_x = x_root;
3244   if (x_root <= 0) {
3245     dest_x += screen->getRect().width() - 1;
3246     dx += screen->getRect().width() - 1;
3247   } else {
3248     dest_x -= screen->getRect().width() - 1;
3249     dx -= screen->getRect().width() - 1;
3250   }
3251
3252   if (! flags.stuck)
3253     screen->reassociateWindow(this, dest, False);
3254   screen->changeWorkspaceID(dest);
3255
3256   if (screen->doOpaqueMove())
3257     XGrabServer(otk::OBDisplay::display);
3258
3259   XUngrabPointer(otk::OBDisplay::display, CurrentTime);
3260   XWarpPointer(otk::OBDisplay::display, None, 
3261                screen->getRootWindow(), 0, 0, 0, 0,
3262                dest_x, y_root);
3263   XGrabPointer(otk::OBDisplay::display, frame.window, False,
3264                PointerMotionMask | ButtonReleaseMask,
3265                GrabModeAsync, GrabModeAsync,
3266                None, blackbox->getMoveCursor(), CurrentTime);
3267
3268   if (screen->doOpaqueMove())
3269     XUngrabServer(otk::OBDisplay::display);
3270
3271   if (focus)
3272     setInputFocus();
3273
3274 }
3275
3276
3277 void BlackboxWindow::doWindowSnapping(int &dx, int &dy) {
3278   // how much resistance to edges to provide
3279   const int resistance_size = screen->getResistanceSize();
3280
3281   // how far away to snap
3282   const int snap_distance = screen->getSnapThreshold();
3283
3284   // how to snap windows
3285   const int snap_to_windows = screen->getWindowToWindowSnap();
3286   const int snap_to_edges = screen->getWindowToEdgeSnap();
3287   // the amount of space away from the edge to provide resistance/snap
3288   const int snap_offset = screen->getSnapOffset();
3289
3290   // find the geomeetery where the moving window currently is
3291   const otk::Rect &moving =
3292     screen->doOpaqueMove() ? frame.rect : frame.changing;
3293
3294   // window corners
3295   const int wleft = dx,
3296            wright = dx + frame.rect.width() - 1,
3297              wtop = dy,
3298           wbottom = dy + frame.rect.height() - 1;
3299
3300   if (snap_to_windows) {
3301     otk::RectList rectlist;
3302
3303     Workspace *w = screen->getWorkspace(getWorkspaceNumber());
3304     assert(w);
3305
3306     // add windows on the workspace to the rect list
3307     const BlackboxWindowList& stack_list = w->getStackingList();
3308     BlackboxWindowList::const_iterator st_it, st_end = stack_list.end();
3309     for (st_it = stack_list.begin(); st_it != st_end; ++st_it)
3310       if (*st_it != this) // don't snap to ourself
3311         rectlist.push_back( (*st_it)->frameRect() );
3312
3313     otk::RectList::const_iterator it, end = rectlist.end();
3314     for (it = rectlist.begin(); it != end; ++it) {
3315       bool snapped = False;
3316       const otk::Rect &winrect = *it;
3317       otk::Rect offsetrect;
3318       offsetrect.setCoords(winrect.left() - snap_offset,
3319                            winrect.top() - snap_offset,
3320                            winrect.right() + snap_offset,
3321                            winrect.bottom() + snap_offset);
3322
3323       if (snap_to_windows == BScreen::WindowResistance)
3324         // if the window is already over top of this snap target, then
3325         // resistance is futile, so just ignore it
3326         if (winrect.intersects(moving))
3327           continue;
3328
3329       int dleft, dright, dtop, dbottom;
3330
3331       // if the windows are in the same plane vertically
3332       if (wtop >= (signed)(winrect.y() - frame.rect.height() + 1) &&
3333           wtop < (signed)(winrect.y() + winrect.height() - 1)) {
3334
3335         if (snap_to_windows == BScreen::WindowResistance) {
3336           dleft = wright - offsetrect.left();
3337           dright = offsetrect.right() - wleft;
3338
3339           // snap left of other window?
3340           if (dleft >= 0 && dleft < resistance_size &&
3341               dleft < (wright - wleft)) {
3342             dx = offsetrect.left() - frame.rect.width();
3343             snapped = True;
3344           }
3345           // snap right of other window?
3346           else if (dright >= 0 && dright < resistance_size &&
3347                    dright < (wright - wleft)) {
3348             dx = offsetrect.right() + 1;
3349             snapped = True;
3350           }
3351         } else { // BScreen::WindowSnap
3352           dleft = abs(wright - offsetrect.left());
3353           dright = abs(wleft - offsetrect.right());
3354
3355           // snap left of other window?
3356           if (dleft < snap_distance && dleft <= dright) {
3357             dx = offsetrect.left() - frame.rect.width();
3358             snapped = True;
3359           }
3360           // snap right of other window?
3361           else if (dright < snap_distance) {
3362             dx = offsetrect.right() + 1;
3363             snapped = True;
3364           }            
3365         }
3366
3367         if (snapped) {
3368           if (screen->getWindowCornerSnap()) {
3369             // try corner-snap to its other sides
3370             if (snap_to_windows == BScreen::WindowResistance) {
3371               dtop = winrect.top() - wtop;
3372               dbottom = wbottom - winrect.bottom();
3373               if (dtop > 0 && dtop < resistance_size) {
3374                 // if we're already past the top edge, then don't provide
3375                 // resistance
3376                 if (moving.top() >= winrect.top())
3377                   dy = winrect.top();
3378               } else if (dbottom > 0 && dbottom < resistance_size) {
3379                 // if we're already past the bottom edge, then don't provide
3380                 // resistance
3381                 if (moving.bottom() <= winrect.bottom())
3382                   dy = winrect.bottom() - frame.rect.height() + 1;
3383               }
3384             } else { // BScreen::WindowSnap
3385               dtop = abs(wtop - winrect.top());
3386               dbottom = abs(wbottom - winrect.bottom());
3387               if (dtop < snap_distance && dtop <= dbottom)
3388                 dy = winrect.top();
3389               else if (dbottom < snap_distance)
3390                 dy = winrect.bottom() - frame.rect.height() + 1;
3391             }
3392           }
3393
3394           continue;
3395         }
3396       }
3397
3398       // if the windows are on the same plane horizontally
3399       if (wleft >= (signed)(winrect.x() - frame.rect.width() + 1) &&
3400           wleft < (signed)(winrect.x() + winrect.width() - 1)) {
3401
3402         if (snap_to_windows == BScreen::WindowResistance) {
3403           dtop = wbottom - offsetrect.top();
3404           dbottom = offsetrect.bottom() - wtop;
3405
3406           // snap top of other window?
3407           if (dtop >= 0 && dtop < resistance_size && dtop < (wbottom - wtop)) {
3408             dy = offsetrect.top() - frame.rect.height();
3409             snapped = True;
3410           }
3411           // snap bottom of other window?
3412           else if (dbottom >= 0 && dbottom < resistance_size &&
3413                    dbottom < (wbottom - wtop)) {
3414             dy = offsetrect.bottom() + 1;
3415             snapped = True;
3416           }
3417         } else { // BScreen::WindowSnap
3418           dtop = abs(wbottom - offsetrect.top());
3419           dbottom = abs(wtop - offsetrect.bottom());
3420
3421           // snap top of other window?
3422           if (dtop < snap_distance && dtop <= dbottom) {
3423             dy = offsetrect.top() - frame.rect.height();
3424             snapped = True;
3425           }
3426           // snap bottom of other window?
3427           else if (dbottom < snap_distance) {
3428             dy = offsetrect.bottom() + 1;
3429             snapped = True;
3430           }
3431
3432         }
3433
3434         if (snapped) {
3435           if (screen->getWindowCornerSnap()) {
3436             // try corner-snap to its other sides
3437             if (snap_to_windows == BScreen::WindowResistance) {
3438               dleft = winrect.left() - wleft;
3439               dright = wright - winrect.right();
3440               if (dleft > 0 && dleft < resistance_size) {
3441                 // if we're already past the left edge, then don't provide
3442                 // resistance
3443                 if (moving.left() >= winrect.left())
3444                   dx = winrect.left();
3445               } else if (dright > 0 && dright < resistance_size) {
3446                 // if we're already past the right edge, then don't provide
3447                 // resistance
3448                 if (moving.right() <= winrect.right())
3449                   dx = winrect.right() - frame.rect.width() + 1;
3450               }
3451             } else { // BScreen::WindowSnap
3452               dleft = abs(wleft - winrect.left());
3453               dright = abs(wright - winrect.right());
3454               if (dleft < snap_distance && dleft <= dright)
3455                 dx = winrect.left();
3456               else if (dright < snap_distance)
3457                 dx = winrect.right() - frame.rect.width() + 1;
3458             }
3459           }
3460
3461           continue;
3462         }
3463       }
3464     }
3465   }
3466
3467   if (snap_to_edges) {
3468     otk::RectList rectlist;
3469
3470     // snap to the screen edges (and screen boundaries for xinerama)
3471 #ifdef    XINERAMA
3472     if (screen->isXineramaActive() && blackbox->doXineramaSnapping()) {
3473       rectlist.insert(rectlist.begin(),
3474                       screen->getXineramaAreas().begin(),
3475                       screen->getXineramaAreas().end());
3476     } else
3477 #endif // XINERAMA
3478       rectlist.push_back(screen->getRect());
3479
3480     otk::RectList::const_iterator it, end = rectlist.end();
3481     for (it = rectlist.begin(); it != end; ++it) {
3482       const otk::Rect &srect = *it;
3483       otk::Rect offsetrect;
3484       offsetrect.setCoords(srect.left() + snap_offset,
3485                            srect.top() + snap_offset,
3486                            srect.right() - snap_offset,
3487                            srect.bottom() - snap_offset);
3488
3489       if (snap_to_edges == BScreen::WindowResistance) {
3490         // if we're not in the rectangle then don't snap to it.
3491         if (! srect.contains(moving))
3492           continue;
3493       } else { // BScreen::WindowSnap
3494         // if we're not in the rectangle then don't snap to it.
3495         if (! srect.intersects(otk::Rect(wleft, wtop, frame.rect.width(),
3496                                          frame.rect.height())))
3497           continue;
3498       }
3499
3500       if (snap_to_edges == BScreen::WindowResistance) {
3501       int dleft = offsetrect.left() - wleft,
3502          dright = wright - offsetrect.right(),
3503            dtop = offsetrect.top() - wtop,
3504         dbottom = wbottom - offsetrect.bottom();
3505
3506         // snap left?
3507         if (dleft > 0 && dleft < resistance_size)
3508           dx = offsetrect.left();
3509         // snap right?
3510         else if (dright > 0 && dright < resistance_size)
3511           dx = offsetrect.right() - frame.rect.width() + 1;
3512
3513         // snap top?
3514         if (dtop > 0 && dtop < resistance_size)
3515           dy = offsetrect.top();
3516         // snap bottom?
3517         else if (dbottom > 0 && dbottom < resistance_size)
3518           dy = offsetrect.bottom() - frame.rect.height() + 1;
3519       } else { // BScreen::WindowSnap
3520         int dleft = abs(wleft - offsetrect.left()),
3521            dright = abs(wright - offsetrect.right()),
3522              dtop = abs(wtop - offsetrect.top()),
3523           dbottom = abs(wbottom - offsetrect.bottom());
3524
3525         // snap left?
3526         if (dleft < snap_distance && dleft <= dright)
3527           dx = offsetrect.left();
3528         // snap right?
3529         else if (dright < snap_distance)
3530           dx = offsetrect.right() - frame.rect.width() + 1;
3531
3532         // snap top?
3533         if (dtop < snap_distance && dtop <= dbottom)
3534           dy = offsetrect.top();
3535         // snap bottom?
3536         else if (dbottom < snap_distance)
3537           dy = offsetrect.bottom() - frame.rect.height() + 1;
3538       }
3539     }
3540   }
3541 }
3542
3543
3544 void BlackboxWindow::endMove(void) {
3545   assert(flags.moving);
3546   assert(blackbox->getChangingWindow() == this);
3547
3548   flags.moving = False;
3549   blackbox->setChangingWindow(0);
3550
3551   if (! screen->doOpaqueMove()) {
3552     /* when drawing the rubber band, we need to make sure we only draw inside
3553      * the frame... frame.changing_* contain the new coords for the window,
3554      * so we need to subtract 1 from changing_w/changing_h every where we
3555      * draw the rubber band (for both moving and resizing)
3556      */
3557     XDrawRectangle(otk::OBDisplay::display, screen->getRootWindow(),
3558                    screen->getOpGC(), frame.changing.x(), frame.changing.y(),
3559                    frame.changing.width() - 1, frame.changing.height() - 1);
3560       XUngrabServer(otk::OBDisplay::display);
3561   
3562       configure(frame.changing.x(), frame.changing.y(),
3563                 frame.changing.width(), frame.changing.height());
3564   } else {
3565     configure(frame.rect.x(), frame.rect.y(),
3566               frame.rect.width(), frame.rect.height());
3567   }
3568   screen->hideGeometry();
3569
3570   XUngrabPointer(otk::OBDisplay::display, CurrentTime);
3571
3572   // if there are any left over motions from the move, drop them now
3573   XSync(otk::OBDisplay::display, false); // make sure we don't miss any
3574   XEvent e;
3575   while (XCheckTypedWindowEvent(otk::OBDisplay::display, frame.window,
3576                                 MotionNotify, &e));
3577 }
3578
3579
3580 void BlackboxWindow::beginResize(int x_root, int y_root, Corner dir) {
3581   if (! (functions & Func_Resize)) return;
3582
3583   assert(! (flags.resizing || flags.moving));
3584
3585   /*
3586     Only one window can be moved/resized at a time. If another window is
3587     already being moved or resized, then stop it before whating to work with
3588     this one.
3589   */
3590   BlackboxWindow *changing = blackbox->getChangingWindow();
3591   if (changing && changing != this) {
3592     if (changing->flags.moving)
3593       changing->endMove();
3594     else // if (changing->flags.resizing)
3595       changing->endResize();
3596   }
3597
3598   resize_dir = dir;
3599
3600   Cursor cursor;
3601   Corner anchor;
3602   
3603   switch (resize_dir) {
3604   case BottomLeft:
3605     anchor = TopRight;
3606     cursor = blackbox->getLowerLeftAngleCursor();
3607     break;
3608
3609   case BottomRight:
3610     anchor = TopLeft;
3611     cursor = blackbox->getLowerRightAngleCursor();
3612     break;
3613
3614   case TopLeft:
3615     anchor = BottomRight;
3616     cursor = blackbox->getUpperLeftAngleCursor();
3617     break;
3618
3619   case TopRight:
3620     anchor = BottomLeft;
3621     cursor = blackbox->getUpperRightAngleCursor();
3622     break;
3623
3624   default:
3625     assert(false); // unhandled Corner
3626     return;        // unreachable, for the compiler
3627   }
3628   
3629   XGrabServer(otk::OBDisplay::display);
3630   XGrabPointer(otk::OBDisplay::display, frame.window, False,
3631                PointerMotionMask | ButtonReleaseMask,
3632                GrabModeAsync, GrabModeAsync, None, cursor, CurrentTime);
3633
3634   flags.resizing = True;
3635   blackbox->setChangingWindow(this);
3636
3637   unsigned int gw, gh;
3638   frame.changing = frame.rect;
3639
3640   constrain(anchor,  &gw, &gh);
3641
3642   XDrawRectangle(otk::OBDisplay::display, screen->getRootWindow(),
3643                  screen->getOpGC(), frame.changing.x(), frame.changing.y(),
3644                  frame.changing.width() - 1, frame.changing.height() - 1);
3645
3646   screen->showGeometry(gw, gh);
3647   
3648   frame.grab_x = x_root;
3649   frame.grab_y = y_root;
3650 }
3651
3652
3653 void BlackboxWindow::doResize(int x_root, int y_root) {
3654   assert(flags.resizing);
3655   assert(blackbox->getChangingWindow() == this);
3656
3657   XDrawRectangle(otk::OBDisplay::display, screen->getRootWindow(),
3658                  screen->getOpGC(), frame.changing.x(), frame.changing.y(),
3659                  frame.changing.width() - 1, frame.changing.height() - 1);
3660
3661   unsigned int gw, gh;
3662   Corner anchor;
3663   int dx, dy; // the amount of change in the size of the window
3664
3665   switch (resize_dir) {
3666   case BottomLeft:
3667     anchor = TopRight;
3668     dx = - (x_root - frame.grab_x);
3669     dy = + (y_root - frame.grab_y);
3670     break;
3671   case BottomRight:
3672     anchor = TopLeft;
3673     dx = + (x_root - frame.grab_x);
3674     dy = + (y_root - frame.grab_y);
3675     break;
3676   case TopLeft:
3677     anchor = BottomRight;
3678     dx = - (x_root - frame.grab_x);
3679     dy = - (y_root - frame.grab_y);
3680     break;
3681   case TopRight:
3682     anchor = BottomLeft;
3683     dx = + (x_root - frame.grab_x);
3684     dy = - (y_root - frame.grab_y);
3685     break;
3686
3687   default:
3688     assert(false); // unhandled Corner
3689     return;        // unreachable, for the compiler
3690   }
3691
3692   // make sure the user cant resize the window smaller than 0, which makes it
3693   // wrap around and become huge
3694   if (dx < -(signed)client.rect.width()) dx = -(signed)client.rect.width();
3695   if (dy < -(signed)client.rect.height()) dy = -(signed)client.rect.height();
3696
3697   frame.changing.setSize(frame.rect.width() + dx, frame.rect.height() + dy);
3698
3699   constrain(anchor, &gw, &gh);
3700
3701   XDrawRectangle(otk::OBDisplay::display, screen->getRootWindow(),
3702                  screen->getOpGC(), frame.changing.x(), frame.changing.y(),
3703                  frame.changing.width() - 1, frame.changing.height() - 1);
3704
3705   screen->showGeometry(gw, gh);
3706 }
3707
3708
3709 void BlackboxWindow::endResize(void) {
3710   assert(flags.resizing);
3711   assert(blackbox->getChangingWindow() == this);
3712
3713   XDrawRectangle(otk::OBDisplay::display, screen->getRootWindow(),
3714                  screen->getOpGC(), frame.changing.x(), frame.changing.y(),
3715                  frame.changing.width() - 1, frame.changing.height() - 1);
3716   XUngrabServer(otk::OBDisplay::display);
3717
3718   // unset maximized state after resized when fully maximized
3719   if (flags.maximized == 1)
3720     maximize(0);
3721   
3722   flags.resizing = False;
3723   blackbox->setChangingWindow(0);
3724
3725   configure(frame.changing.x(), frame.changing.y(),
3726             frame.changing.width(), frame.changing.height());
3727   screen->hideGeometry();
3728
3729   XUngrabPointer(otk::OBDisplay::display, CurrentTime);
3730   
3731   // if there are any left over motions from the resize, drop them now
3732   XSync(otk::OBDisplay::display, false); // make sure we don't miss any
3733   XEvent e;
3734   while (XCheckTypedWindowEvent(otk::OBDisplay::display, frame.window,
3735                                 MotionNotify, &e));
3736 }
3737
3738
3739 void BlackboxWindow::motionNotifyEvent(const XMotionEvent *me) {
3740 #if 0
3741   fprintf(stderr, "BlackboxWindow::motionNotifyEvent() for 0x%lx\n",
3742           client.window);
3743 #endif
3744
3745   if (flags.moving) {
3746     doMove(me->x_root, me->y_root);
3747   } else if (flags.resizing) {
3748     doResize(me->x_root, me->y_root);
3749   } else {
3750     if ((functions & Func_Move) &&
3751        (me->state & Button1Mask) &&
3752         (frame.title == me->window || frame.label == me->window ||
3753          frame.handle == me->window || frame.window == me->window)) {
3754       beginMove(me->x_root, me->y_root);
3755     } else if ((functions & Func_Resize) &&
3756                ((me->state & Button1Mask) &&
3757                 (me->window == frame.right_grip ||
3758                  me->window == frame.left_grip)) ||
3759                ((me->state & Button3Mask) && (me->state & mod_mask) &&
3760                 (frame.title == me->window || frame.label == me->window ||
3761                  frame.handle == me->window || frame.window == me->window ||
3762                  frame.right_grip == me->window ||
3763                  frame.left_grip == me->window))) {
3764       unsigned int zones = screen->getResizeZones();
3765       Corner corner;
3766       
3767       if (me->window == frame.left_grip) {
3768         corner = BottomLeft;
3769       } else if (me->window == frame.right_grip || zones == 1) {
3770         corner = BottomRight;
3771       } else {
3772         bool top;
3773         bool left = (me->x_root - frame.rect.x() <=
3774                      static_cast<signed>(frame.rect.width() / 2));
3775         if (zones == 2)
3776           top = False;
3777         else // (zones == 4)
3778           top = (me->y_root - frame.rect.y() <=
3779                  static_cast<signed>(frame.rect.height() / 2));
3780         corner = (top ? (left ? TopLeft : TopRight) :
3781                         (left ? BottomLeft : BottomRight));
3782       }
3783
3784       beginResize(me->x_root, me->y_root, corner);
3785     }
3786   }
3787 }
3788
3789
3790 void BlackboxWindow::enterNotifyEvent(const XCrossingEvent* ce) {
3791   if (! (screen->isSloppyFocus() && isVisible() && isNormal()))
3792     return;
3793
3794   XEvent e;
3795   bool leave = False, inferior = False;
3796
3797   while (XCheckTypedWindowEvent(otk::OBDisplay::display, ce->window,
3798                                 LeaveNotify, &e)) {
3799     if (e.type == LeaveNotify && e.xcrossing.mode == NotifyNormal) {
3800       leave = True;
3801       inferior = (e.xcrossing.detail == NotifyInferior);
3802     }
3803   }
3804
3805   if (! leave || inferior) {
3806     if (! isFocused()) {
3807       bool success = setInputFocus();
3808       if (success)    // if focus succeeded install the colormap
3809         installColormap(True); // XXX: shouldnt we honour no install?
3810
3811       /*
3812         We only auto-raise when the window wasn't focused because otherwise
3813         we run into problems with gtk+ drop-down lists. The window ends up
3814         raising over the list.
3815       */
3816       if (screen->doAutoRaise())
3817         timer->start();
3818     }
3819   }
3820 }
3821
3822
3823 void BlackboxWindow::leaveNotifyEvent(const XCrossingEvent*) {
3824   if (! (screen->isSloppyFocus() && screen->doAutoRaise() && isNormal()))
3825     return;
3826
3827   installColormap(False);
3828
3829   if (timer->isTiming())
3830     timer->stop();
3831 }
3832
3833
3834 #ifdef    SHAPE
3835 void BlackboxWindow::shapeEvent(XShapeEvent *e) {
3836   if (blackbox->hasShapeExtensions()) {
3837     if (! e->shaped && flags.shaped) {
3838       clearShape();
3839       flags.shaped = False;
3840     } else if (e->shaped) {
3841       configureShape();
3842       flags.shaped = True;
3843     }
3844   }
3845 }