src/Window.cc

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