src/workspace.cc

   1 // -*- mode: C++; indent-tabs-mode: nil; c-basic-offset: 2; -*-
   2 // Workspace.cc for Blackbox - an X11 Window manager
   3 // Copyright (c) 2001 - 2002 Sean 'Shaleh' Perry <shaleh@debian.org>
   4 // Copyright (c) 1997 - 2000 Brad Hughes (bhughes@tcac.net)
   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/Xlib.h>
  30 #include <X11/Xatom.h>
  31
  32 #ifdef    HAVE_STDIO_H
  33 #  include <stdio.h>
  34 #endif // HAVE_STDIO_H
  35
  36 #ifdef HAVE_STRING_H
  37 #  include <string.h>
  38 #endif // HAVE_STRING_H
  39 }
  40
  41 #include <assert.h>
  42
  43 #include <functional>
  44 #include <string>
  45
  46 using std::string;
  47
  48 #include "blackbox.hh"
  49 #include "font.hh"
  50 #include "screen.hh"
  51 #include "util.hh"
  52 #include "window.hh"
  53 #include "workspace.hh"
  54 #include "xatom.hh"
  55
  56
  57 Workspace::Workspace(BScreen *scrn, unsigned int i) {
  58   screen = scrn;
  59   xatom = screen->getBlackbox()->getXAtom();
  60
  61   cascade_x = cascade_y = 0;
  62 #ifdef    XINERAMA
  63   cascade_region = 0;
  64 #endif // XINERAMA
  65
  66   id = i;
  67
  68   lastfocus = (BlackboxWindow *) 0;
  69
  70   readName();
  71 }
  72
  73
  74 void Workspace::addWindow(BlackboxWindow *w, bool place, bool sticky) {
  75   assert(w != 0);
  76
  77   if (place) placeWindow(w);
  78
  79   stackingList.push_front(w);
  80
  81   if (! sticky)
  82     w->setWorkspace(id);
  83
  84   if (! w->isNormal()) {
  85     if (! sticky) {
  86       // just give it some number, else bad things happen as it is assumed to
  87       // not be on a workspace
  88       w->setWindowNumber(0);
  89     }
  90   } else {
  91     if (! sticky)
  92       w->setWindowNumber(windowList.size());
  93
  94     windowList.push_back(w);
  95
  96     if (screen->doFocusNew() || (w->isTransient() && w->getTransientFor() &&
  97                                  w->getTransientFor()->isFocused())) {
  98       if (id != screen->getCurrentWorkspaceID()) {
  99         /*
 100            not on the focused workspace, so the window is not going to get focus
 101            but if the user wants new windows focused, then it should get focus
 102            when this workspace does become focused.
 103         */
 104         lastfocus = w;
 105       }
 106     }
 107   }
 108
 109   if (! w->isDesktop())
 110     raiseWindow(w);
 111   else
 112     lowerWindow(w);
 113 }
 114
 115
 116 void Workspace::removeWindow(BlackboxWindow *w, bool sticky) {
 117   assert(w != 0);
 118
 119   stackingList.remove(w);
 120
 121   // pass focus to the next appropriate window
 122   if ((w->isFocused() || w == lastfocus) &&
 123       ! screen->getBlackbox()->doShutdown()) {
 124     focusFallback(w);
 125   }
 126
 127   if (! w->isNormal()) return;
 128
 129   BlackboxWindowList::iterator it, end = windowList.end();
 130   int i;
 131   for (i = 0, it = windowList.begin(); it != end; ++it, ++i)
 132     if (*it == w)
 133       break;
 134   assert(it != end);
 135
 136   windowList.erase(it);
 137   if (! sticky) {
 138     BlackboxWindowList::iterator it = windowList.begin();
 139     const BlackboxWindowList::iterator end = windowList.end();
 140     unsigned int i = 0;
 141     for (; it != end; ++it, ++i)
 142       (*it)->setWindowNumber(i);
 143   }
 144
 145   if (i == 0) {
 146     cascade_x = cascade_y = 0;
 147 #ifdef    XINERAMA
 148     cascade_region = 0;
 149 #endif // XINERAMA
 150   }
 151 }
 152
 153
 154 void Workspace::focusFallback(const BlackboxWindow *old_window) {
 155   BlackboxWindow *newfocus = 0;
 156
 157   if (id == screen->getCurrentWorkspaceID()) {
 158     // The window is on the visible workspace.
 159
 160     // if it's a transient, then try to focus its parent
 161     if (old_window && old_window->isTransient()) {
 162       newfocus = old_window->getTransientFor();
 163
 164       if (! newfocus ||
 165           newfocus->isIconic() ||                  // do not focus icons
 166           newfocus->getWorkspaceNumber() != id ||  // or other workspaces
 167           ! newfocus->setInputFocus())
 168         newfocus = 0;
 169     }
 170
 171     if (! newfocus) {
 172       BlackboxWindowList::iterator it = stackingList.begin(),
 173                                   end = stackingList.end();
 174       for (; it != end; ++it) {
 175         BlackboxWindow *tmp = *it;
 176         if (tmp && tmp->isNormal() && tmp->setInputFocus()) {
 177           // we found our new focus target
 178           newfocus = tmp;
 179           break;
 180         }
 181       }
 182     }
 183
 184     screen->getBlackbox()->setFocusedWindow(newfocus);
 185   } else {
 186     // The window is not on the visible workspace.
 187
 188     if (old_window && lastfocus == old_window) {
 189       // The window was the last-focus target, so we need to replace it.
 190       BlackboxWindow *win = (BlackboxWindow*) 0;
 191       if (! stackingList.empty())
 192         win = stackingList.front();
 193       setLastFocusedWindow(win);
 194     }
 195   }
 196 }
 197
 198
 199 void Workspace::removeAll(void) {
 200   while (! windowList.empty())
 201     windowList.front()->iconify();
 202 }
 203
 204 void Workspace::showAll(void) {
 205   BlackboxWindowList::iterator it = stackingList.begin();
 206   const BlackboxWindowList::iterator end = stackingList.end();
 207   for (; it != end; ++it) {
 208     BlackboxWindow *bw = *it;
 209     // sticky windows arent unmapped on a workspace change so we don't have ot
 210     // map them, but sometimes on a restart, another app can unmap our sticky
 211     // windows, so we map on startup always
 212     if (! bw->isStuck() || screen->getBlackbox()->isStartup())
 213       bw->show();
 214   }
 215 }
 216
 217
 218 void Workspace::hideAll(void) {
 219   // withdraw in reverse order to minimize the number of Expose events
 220
 221   BlackboxWindowList lst(stackingList.rbegin(), stackingList.rend());
 222
 223   BlackboxWindowList::iterator it = lst.begin();
 224   const BlackboxWindowList::iterator end = lst.end();
 225   for (; it != end; ++it) {
 226     BlackboxWindow *bw = *it;
 227     // don't hide sticky windows, or they'll end up flickering on a workspace
 228     // change
 229     if (! bw->isStuck())
 230       bw->withdraw();
 231   }
 232 }
 233
 234
 235
 236 /*
 237  * returns the number of transients for win, plus the number of transients
 238  * associated with each transient of win
 239  */
 240 static unsigned int countTransients(const BlackboxWindow * const win) {
 241   BlackboxWindowList transients = win->getTransients();
 242   if (transients.empty()) return 0;
 243
 244   unsigned int ret = transients.size();
 245   BlackboxWindowList::const_iterator it = transients.begin(),
 246     end = transients.end();
 247   for (; it != end; ++it)
 248     ret += countTransients(*it);
 249
 250   return ret;
 251 }
 252
 253
 254 /*
 255  * puts the transients of win into the stack. windows are stacked above
 256  * the window before it in the stackvector being iterated, meaning
 257  * stack[0] is on bottom, stack[1] is above stack[0], stack[2] is above
 258  * stack[1], etc...
 259  */
 260 void Workspace::raiseTransients(const BlackboxWindow * const win,
 261                                 StackVector::iterator &stack) {
 262   if (win->getTransients().empty()) return; // nothing to do
 263
 264   // put win's transients in the stack
 265   BlackboxWindowList::const_iterator it, end = win->getTransients().end();
 266   for (it = win->getTransients().begin(); it != end; ++it) {
 267     BlackboxWindow *w = *it;
 268     *stack++ = w->getFrameWindow();
 269
 270     if (! w->isIconic()) {
 271       Workspace *wkspc = screen->getWorkspace(w->getWorkspaceNumber());
 272       wkspc->stackingList.remove(w);
 273       wkspc->stackingList.push_front(w);
 274     }
 275   }
 276
 277   // put transients of win's transients in the stack
 278   for (it = win->getTransients().begin(); it != end; ++it)
 279     raiseTransients(*it, stack);
 280 }
 281
 282
 283 void Workspace::lowerTransients(const BlackboxWindow * const win,
 284                                 StackVector::iterator &stack) {
 285   if (win->getTransients().empty()) return; // nothing to do
 286
 287   // put transients of win's transients in the stack
 288   BlackboxWindowList::const_reverse_iterator it,
 289     end = win->getTransients().rend();
 290   for (it = win->getTransients().rbegin(); it != end; ++it)
 291     lowerTransients(*it, stack);
 292
 293   // put win's transients in the stack
 294   for (it = win->getTransients().rbegin(); it != end; ++it) {
 295     BlackboxWindow *w = *it;
 296     *stack++ = w->getFrameWindow();
 297
 298     if (! w->isIconic()) {
 299       Workspace *wkspc = screen->getWorkspace(w->getWorkspaceNumber());
 300       wkspc->stackingList.remove(w);
 301       wkspc->stackingList.push_back(w);
 302     }
 303   }
 304 }
 305
 306
 307 void Workspace::raiseWindow(BlackboxWindow *w) {
 308   BlackboxWindow *win = w;
 309
 310   if (win->isDesktop()) return;
 311
 312   // walk up the transient_for's to the window that is not a transient
 313   while (win->isTransient() && win->getTransientFor())
 314     win = win->getTransientFor();
 315
 316   // get the total window count (win and all transients)
 317   unsigned int i = 1 + countTransients(win);
 318
 319   // stack the window with all transients above
 320   StackVector stack_vector(i);
 321   StackVector::iterator stack = stack_vector.begin();
 322
 323   *(stack++) = win->getFrameWindow();
 324   if (! (win->isIconic() || win->isDesktop())) {
 325     Workspace *wkspc = screen->getWorkspace(win->getWorkspaceNumber());
 326     wkspc->stackingList.remove(win);
 327     wkspc->stackingList.push_front(win);
 328   }
 329
 330   raiseTransients(win, stack);
 331
 332   screen->raiseWindows(&stack_vector[0], stack_vector.size());
 333 }
 334
 335
 336 void Workspace::lowerWindow(BlackboxWindow *w) {
 337   BlackboxWindow *win = w;
 338
 339   // walk up the transient_for's to the window that is not a transient
 340   while (win->isTransient() && win->getTransientFor())
 341     win = win->getTransientFor();
 342
 343   // get the total window count (win and all transients)
 344   unsigned int i = 1 + countTransients(win);
 345
 346   // stack the window with all transients above
 347   StackVector stack_vector(i);
 348   StackVector::iterator stack = stack_vector.begin();
 349
 350   lowerTransients(win, stack);
 351
 352   *(stack++) = win->getFrameWindow();
 353   if (! (win->isIconic() || win->isDesktop())) {
 354     Workspace *wkspc = screen->getWorkspace(win->getWorkspaceNumber());
 355     wkspc->stackingList.remove(win);
 356     wkspc->stackingList.push_back(win);
 357   }
 358
 359   screen->lowerWindows(&stack_vector[0], stack_vector.size());
 360 }
 361
 362
 363 void Workspace::reconfigure(void) {
 364   std::for_each(windowList.begin(), windowList.end(),
 365                 std::mem_fun(&BlackboxWindow::reconfigure));
 366 }
 367
 368
 369 BlackboxWindow *Workspace::getWindow(unsigned int index) {
 370   if (index < windowList.size()) {
 371     BlackboxWindowList::iterator it = windowList.begin();
 372     while (index-- > 0) // increment to index
 373       ++it;
 374     return *it;
 375   }
 376
 377   return 0;
 378 }
 379
 380
 381 BlackboxWindow*
 382 Workspace::getNextWindowInList(BlackboxWindow *w) {
 383   BlackboxWindowList::iterator it = std::find(windowList.begin(),
 384                                               windowList.end(),
 385                                               w);
 386   assert(it != windowList.end());   // window must be in list
 387   ++it;                             // next window
 388   if (it == windowList.end())
 389     return windowList.front();      // if we walked off the end, wrap around
 390
 391   return *it;
 392 }
 393
 394
 395 BlackboxWindow* Workspace::getPrevWindowInList(BlackboxWindow *w) {
 396   BlackboxWindowList::iterator it = std::find(windowList.begin(),
 397                                               windowList.end(),
 398                                               w);
 399   assert(it != windowList.end()); // window must be in list
 400   if (it == windowList.begin())
 401     return windowList.back();     // if we walked of the front, wrap around
 402
 403   return *(--it);
 404 }
 405
 406
 407 BlackboxWindow* Workspace::getTopWindowOnStack(void) const {
 408   assert(! stackingList.empty());
 409   return stackingList.front();
 410 }
 411
 412
 413 unsigned int Workspace::getCount(void) const {
 414   return windowList.size();
 415 }
 416
 417
 418 void Workspace::appendStackOrder(BlackboxWindowList &stack_order) const {
 419   BlackboxWindowList::const_reverse_iterator it = stackingList.rbegin();
 420   const BlackboxWindowList::const_reverse_iterator end = stackingList.rend();
 421   for (; it != end; ++it)
 422     // don't add desktop wnidows, or sticky windows more than once
 423     if (! ( (*it)->isDesktop() ||
 424             ((*it)->isStuck() && id != screen->getCurrentWorkspaceID())))
 425       stack_order.push_back(*it);
 426 }
 427
 428
 429 bool Workspace::isCurrent(void) const {
 430   return (id == screen->getCurrentWorkspaceID());
 431 }
 432
 433
 434 bool Workspace::isLastWindow(const BlackboxWindow* const w) const {
 435   return (w == windowList.back());
 436 }
 437
 438
 439 void Workspace::setCurrent(void) {
 440   screen->changeWorkspaceID(id);
 441 }
 442
 443
 444 void Workspace::readName(void) {
 445   XAtom::StringVect namesList;
 446   unsigned long numnames = id + 1;
 447
 448   // attempt to get from the _NET_WM_DESKTOP_NAMES property
 449   if (xatom->getValue(screen->getRootWindow(), XAtom::net_desktop_names,
 450                       XAtom::utf8, numnames, namesList) &&
 451       namesList.size() > id) {
 452     name = namesList[id];
 453
 454   } else {
 455     /*
 456        Use a default name. This doesn't actually change the class. That will
 457        happen after the setName changes the root property, and that change
 458        makes its way back to this function.
 459     */
 460     string tmp = "Workspace %d";
 461     assert(tmp.length() < 32);
 462     char default_name[32];
 463     sprintf(default_name, tmp.c_str(), id + 1);
 464
 465     setName(default_name);  // save this into the _NET_WM_DESKTOP_NAMES property
 466   }
 467 }
 468
 469
 470 void Workspace::setName(const string& new_name) {
 471   // set the _NET_WM_DESKTOP_NAMES property with the new name
 472   XAtom::StringVect namesList;
 473   unsigned long numnames = (unsigned) -1;
 474   if (xatom->getValue(screen->getRootWindow(), XAtom::net_desktop_names,
 475                       XAtom::utf8, numnames, namesList) &&
 476       namesList.size() > id)
 477     namesList[id] = new_name;
 478   else
 479     namesList.push_back(new_name);
 480
 481   xatom->setValue(screen->getRootWindow(), XAtom::net_desktop_names,
 482                   XAtom::utf8, namesList);
 483 }
 484
 485
 486 /*
 487  * Calculate free space available for window placement.
 488  */
 489 Workspace::rectList Workspace::calcSpace(const Rect &win,
 490                                          const rectList &spaces) const {
 491   Rect isect, extra;
 492   rectList result;
 493   rectList::const_iterator siter, end = spaces.end();
 494   for (siter = spaces.begin(); siter != end; ++siter) {
 495     const Rect &curr = *siter;
 496
 497     if(! win.intersects(curr)) {
 498       result.push_back(curr);
 499       continue;
 500     }
 501
 502     /* Use an intersection of win and curr to determine the space around
 503      * curr that we can use.
 504      *
 505      * NOTE: the spaces calculated can overlap.
 506      */
 507     isect = curr & win;
 508
 509     // left
 510     extra.setCoords(curr.left(), curr.top(),
 511                     isect.left() - screen->getSnapOffset(), curr.bottom());
 512     if (extra.valid()) result.push_back(extra);
 513
 514     // top
 515     extra.setCoords(curr.left(), curr.top(),
 516                     curr.right(), isect.top() - screen->getSnapOffset());
 517     if (extra.valid()) result.push_back(extra);
 518
 519     // right
 520     extra.setCoords(isect.right() + screen->getSnapOffset(), curr.top(),
 521                     curr.right(), curr.bottom());
 522     if (extra.valid()) result.push_back(extra);
 523
 524     // bottom
 525     extra.setCoords(curr.left(), isect.bottom() + screen->getSnapOffset(),
 526                     curr.right(), curr.bottom());
 527     if (extra.valid()) result.push_back(extra);
 528   }
 529   return result;
 530 }
 531
 532
 533 static bool rowRLBT(const Rect &first, const Rect &second) {
 534   if (first.bottom() == second.bottom())
 535     return first.right() > second.right();
 536   return first.bottom() > second.bottom();
 537 }
 538
 539 static bool rowRLTB(const Rect &first, const Rect &second) {
 540   if (first.y() == second.y())
 541     return first.right() > second.right();
 542   return first.y() < second.y();
 543 }
 544
 545 static bool rowLRBT(const Rect &first, const Rect &second) {
 546   if (first.bottom() == second.bottom())
 547     return first.x() < second.x();
 548   return first.bottom() > second.bottom();
 549 }
 550
 551 static bool rowLRTB(const Rect &first, const Rect &second) {
 552   if (first.y() == second.y())
 553     return first.x() < second.x();
 554   return first.y() < second.y();
 555 }
 556
 557 static bool colLRTB(const Rect &first, const Rect &second) {
 558   if (first.x() == second.x())
 559     return first.y() < second.y();
 560   return first.x() < second.x();
 561 }
 562
 563 static bool colLRBT(const Rect &first, const Rect &second) {
 564   if (first.x() == second.x())
 565     return first.bottom() > second.bottom();
 566   return first.x() < second.x();
 567 }
 568
 569 static bool colRLTB(const Rect &first, const Rect &second) {
 570   if (first.right() == second.right())
 571     return first.y() < second.y();
 572   return first.right() > second.right();
 573 }
 574
 575 static bool colRLBT(const Rect &first, const Rect &second) {
 576   if (first.right() == second.right())
 577     return first.bottom() > second.bottom();
 578   return first.right() > second.right();
 579 }
 580
 581
 582 bool Workspace::smartPlacement(Rect& win) {
 583   rectList spaces;
 584
 585   //initially the entire screen is free
 586 #ifdef    XINERAMA
 587   if (screen->isXineramaActive() &&
 588       screen->getBlackbox()->doXineramaPlacement()) {
 589     RectList availableAreas = screen->allAvailableAreas();
 590     RectList::iterator it, end = availableAreas.end();
 591
 592     for (it = availableAreas.begin(); it != end; ++it) {
 593       Rect r = *it;
 594       r.setRect(r.x() + screen->getSnapOffset(),
 595                 r.y() + screen->getSnapOffset(),
 596                 r.width() - screen->getSnapOffset(),
 597                 r.height() - screen->getSnapOffset());
 598       spaces.push_back(*it);
 599     }
 600   } else
 601 #endif // XINERAMA
 602   {
 603     Rect r = screen->availableArea();
 604     r.setRect(r.x() + screen->getSnapOffset(),
 605               r.y() + screen->getSnapOffset(),
 606               r.width() - screen->getSnapOffset(),
 607               r.height() - screen->getSnapOffset());
 608     spaces.push_back(r);
 609   }
 610
 611   //Find Free Spaces
 612   BlackboxWindowList::const_iterator wit = windowList.begin(),
 613     end = windowList.end();
 614   Rect tmp;
 615   for (; wit != end; ++wit) {
 616     const BlackboxWindow* const curr = *wit;
 617
 618     // watch for shaded windows and full-maxed windows
 619     if (curr->isShaded()) {
 620       if (screen->getPlaceIgnoreShaded()) continue;
 621     } else if (curr->isMaximizedFull()) {
 622       if (screen->getPlaceIgnoreMaximized()) continue;
 623     }
 624
 625     tmp.setRect(curr->frameRect().x(), curr->frameRect().y(),
 626                 curr->frameRect().width() + screen->getBorderWidth(),
 627                 curr->frameRect().height() + screen->getBorderWidth());
 628
 629     spaces = calcSpace(tmp, spaces);
 630   }
 631
 632   if (screen->getPlacementPolicy() == BScreen::RowSmartPlacement) {
 633     if(screen->getRowPlacementDirection() == BScreen::LeftRight) {
 634       if(screen->getColPlacementDirection() == BScreen::TopBottom)
 635         std::sort(spaces.begin(), spaces.end(), rowLRTB);
 636       else
 637         std::sort(spaces.begin(), spaces.end(), rowLRBT);
 638     } else {
 639       if(screen->getColPlacementDirection() == BScreen::TopBottom)
 640         std::sort(spaces.begin(), spaces.end(), rowRLTB);
 641       else
 642         std::sort(spaces.begin(), spaces.end(), rowRLBT);
 643     }
 644   } else {
 645     if(screen->getColPlacementDirection() == BScreen::TopBottom) {
 646       if(screen->getRowPlacementDirection() == BScreen::LeftRight)
 647         std::sort(spaces.begin(), spaces.end(), colLRTB);
 648       else
 649         std::sort(spaces.begin(), spaces.end(), colRLTB);
 650     } else {
 651       if(screen->getRowPlacementDirection() == BScreen::LeftRight)
 652         std::sort(spaces.begin(), spaces.end(), colLRBT);
 653       else
 654         std::sort(spaces.begin(), spaces.end(), colRLBT);
 655     }
 656   }
 657
 658   rectList::const_iterator sit = spaces.begin(), spaces_end = spaces.end();
 659   for(; sit != spaces_end; ++sit) {
 660     if (sit->width() >= win.width() && sit->height() >= win.height())
 661       break;
 662   }
 663
 664   if (sit == spaces_end)
 665     return False;
 666
 667   //set new position based on the empty space found
 668   const Rect& where = *sit;
 669   win.setX(where.x());
 670   win.setY(where.y());
 671
 672   // adjust the location() based on left/right and top/bottom placement
 673   if (screen->getPlacementPolicy() == BScreen::RowSmartPlacement) {
 674     if (screen->getRowPlacementDirection() == BScreen::RightLeft)
 675       win.setX(where.right() - win.width());
 676     if (screen->getColPlacementDirection() == BScreen::BottomTop)
 677       win.setY(where.bottom() - win.height());
 678   } else {
 679     if (screen->getColPlacementDirection() == BScreen::BottomTop)
 680       win.setY(win.y() + where.height() - win.height());
 681     if (screen->getRowPlacementDirection() == BScreen::RightLeft)
 682       win.setX(win.x() + where.width() - win.width());
 683   }
 684   return True;
 685 }
 686
 687
 688 bool Workspace::underMousePlacement(Rect &win) {
 689   int x, y, rx, ry;
 690   Window c, r;
 691   unsigned int m;
 692   XQueryPointer(screen->getBlackbox()->getXDisplay(), screen->getRootWindow(),
 693                 &r, &c, &rx, &ry, &x, &y, &m);
 694
 695   Rect area;
 696 #ifdef    XINERAMA
 697   if (screen->isXineramaActive() &&
 698       screen->getBlackbox()->doXineramaPlacement()) {
 699     RectList availableAreas = screen->allAvailableAreas();
 700     RectList::iterator it, end = availableAreas.end();
 701
 702     for (it = availableAreas.begin(); it != end; ++it)
 703       if (it->contains(rx, ry)) break;
 704     assert(it != end);  // the mouse isn't inside an area?
 705     area = *it;
 706   } else
 707 #endif // XINERAMA
 708     area = screen->availableArea();
 709
 710   x = rx - win.width() / 2;
 711   y = ry - win.height() / 2;
 712
 713   if (x < area.x())
 714     x = area.x();
 715   if (y < area.y())
 716     y = area.y();
 717   if (x + win.width() > area.x() + area.width())
 718     x = area.x() + area.width() - win.width();
 719   if (y + win.height() > area.y() + area.height())
 720     y = area.y() + area.height() - win.height();
 721
 722   win.setX(x);
 723   win.setY(y);
 724
 725   return True;
 726 }
 727
 728
 729 bool Workspace::cascadePlacement(Rect &win, const int offset) {
 730   Rect area;
 731
 732 #ifdef    XINERAMA
 733   if (screen->isXineramaActive() &&
 734       screen->getBlackbox()->doXineramaPlacement()) {
 735     area = screen->allAvailableAreas()[cascade_region];
 736   } else
 737 #endif // XINERAMA
 738     area = screen->availableArea();
 739
 740   if ((static_cast<signed>(cascade_x + win.width()) > area.right() + 1) ||
 741       (static_cast<signed>(cascade_y + win.height()) > area.bottom() + 1)) {
 742     cascade_x = cascade_y = 0;
 743 #ifdef    XINERAMA
 744     if (screen->isXineramaActive() &&
 745         screen->getBlackbox()->doXineramaPlacement()) {
 746       // go to the next xinerama region, and use its area
 747       if (++cascade_region >= screen->allAvailableAreas().size())
 748         cascade_region = 0;
 749       area = screen->allAvailableAreas()[cascade_region];
 750     }
 751 #endif // XINERAMA
 752   }
 753
 754   if (cascade_x == 0) {
 755     cascade_x = area.x() + offset;
 756     cascade_y = area.y() + offset;
 757   }
 758
 759   win.setPos(cascade_x, cascade_y);
 760
 761   cascade_x += offset;
 762   cascade_y += offset;
 763
 764   return True;
 765 }
 766
 767
 768 void Workspace::placeWindow(BlackboxWindow *win) {
 769   Rect new_win(0, 0, win->frameRect().width(), win->frameRect().height());
 770   bool placed = False;
 771
 772   switch (screen->getPlacementPolicy()) {
 773   case BScreen::RowSmartPlacement:
 774   case BScreen::ColSmartPlacement:
 775     placed = smartPlacement(new_win);
 776     break;
 777   case BScreen::UnderMousePlacement:
 778   case BScreen::ClickMousePlacement:
 779     placed = underMousePlacement(new_win);
 780   default:
 781     break; // handled below
 782   } // switch
 783
 784   if (placed == False)
 785     cascadePlacement(new_win, (win->getTitleHeight() +
 786                                screen->getBorderWidth() * 2));
 787
 788   if (new_win.right() > screen->availableArea().right())
 789     new_win.setX(screen->availableArea().left());
 790   if (new_win.bottom() > screen->availableArea().bottom())
 791     new_win.setY(screen->availableArea().top());
 792
 793   win->configure(new_win.x(), new_win.y(), new_win.width(), new_win.height());
 794 }