Dogcows Code - chaz/openbox/blob - src/frame.cc

   1 // -*- mode: C++; indent-tabs-mode: nil; c-basic-offset: 2; -*-
   2
   3 #ifdef HAVE_CONFIG_H
   4 # include "../config.h"
   5 #endif
   6
   7 extern "C" {
   8 #ifdef    SHAPE
   9 #include <X11/extensions/shape.h>
  10 #endif // SHAPE
  11 }
  12
  13 #include "openbox.hh"
  14 #include "frame.hh"
  15 #include "client.hh"
  16 #include "python.hh"
  17 #include "bindings.hh"
  18 #include "otk/display.hh"
  19
  20 #include <string>
  21
  22 namespace ob {
  23
  24 const long Frame::event_mask;
  25
  26 Frame::Frame(Client *client, otk::RenderStyle *style)
  27   : otk::Widget(openbox, style, Horizontal, 0, 1, true),
  28     WidgetBase(WidgetBase::Type_Frame),
  29     _client(client),
  30     _screen(otk::display->screenInfo(client->screen())),
  31     _plate(this, WidgetBase::Type_Plate),
  32     _titlebar(this, WidgetBase::Type_Titlebar),
  33     _button_close(&_titlebar, WidgetBase::Type_CloseButton, client),
  34     _button_iconify(&_titlebar, WidgetBase::Type_IconifyButton, client),
  35     _button_max(&_titlebar, WidgetBase::Type_MaximizeButton, client),
  36     _button_stick(&_titlebar, WidgetBase::Type_StickyButton, client),
  37     _label(&_titlebar, WidgetBase::Type_Label),
  38     _handle(this, WidgetBase::Type_Handle),
  39     _grip_left(&_handle, WidgetBase::Type_LeftGrip, client),
  40     _grip_right(&_handle, WidgetBase::Type_RightGrip, client),
  41     _decorations(client->decorations())
  42 {
  43   assert(client);
  44   assert(style);
  45
  46   XSelectInput(**otk::display, _window, Frame::event_mask);
  47
  48   _grip_left.setCursor(openbox->cursors().ll_angle);
  49   _grip_right.setCursor(openbox->cursors().lr_angle);
  50
  51   _label.setText(_client->title());
  52
  53   _style = 0;
  54   setStyle(style);
  55
  56   otk::Widget::unfocus(); // stuff starts out appearing focused in otk
  57
  58   _plate.show(); // the other stuff is shown based on decor settings
  59 }
  60
  61
  62 Frame::~Frame()
  63 {
  64 }
  65
  66
  67 void Frame::setTitle(const otk::ustring &text)
  68 {
  69   _label.setText(text);
  70   _label.update();
  71 }
  72
  73
  74 void Frame::setStyle(otk::RenderStyle *style)
  75 {
  76   assert(style);
  77
  78   // if a style was previously set, then 'replace' is true, cause we're
  79   // replacing a style
  80   bool replace = (_style);
  81
  82   otk::Widget::setStyle(style);
  83
  84   if (replace) {
  85     // XXX: do shit here whatever
  86   }
  87
  88   _style = style;
  89
  90   setBorderColor(_style->frameBorderColor());
  91
  92   // if !replace, then adjust() will get called after the client is grabbed!
  93   if (replace) {
  94     // size/position everything
  95     adjustSize();
  96     adjustPosition();
  97   }
  98 }
  99
 100
 101 void Frame::focus()
 102 {
 103   otk::Widget::focus();
 104   update();
 105 }
 106
 107
 108 void Frame::unfocus()
 109 {
 110   otk::Widget::unfocus();
 111   update();
 112 }
 113
 114
 115 void Frame::adjust()
 116 {
 117   // the party all happens in adjustSize
 118 }
 119
 120
 121 void Frame::adjustSize()
 122 {
 123   // XXX: only if not overridden or something!!! MORE LOGIC HERE!!
 124   _decorations = _client->decorations();
 125
 126   // true/false for whether to show each element of the titlebar
 127   bool tit_i = false, tit_m = false, tit_s = false, tit_c = false;
 128   int width;   // the width of the client and its border
 129   int bwidth;  // width to make borders
 130   int cbwidth; // width of the inner client border
 131   int butsize=0; // width and height of the titlebar buttons
 132   const int bevel = _style->bevelWidth();
 133
 134   if (_decorations & Client::Decor_Border) {
 135     bwidth = _style->frameBorderWidth();
 136     cbwidth = _style->clientBorderWidth();
 137   } else
 138     bwidth = cbwidth = 0;
 139   _innersize.left = _innersize.top = _innersize.bottom = _innersize.right =
 140     cbwidth;
 141   width = _client->area().width() + cbwidth * 2;
 142
 143   _plate.setBorderWidth(cbwidth);
 144
 145   setBorderWidth(bwidth);
 146   _titlebar.setBorderWidth(bwidth);
 147   _grip_left.setBorderWidth(bwidth);
 148   _grip_right.setBorderWidth(bwidth);
 149   _handle.setBorderWidth(bwidth);
 150
 151   if (_decorations & Client::Decor_Titlebar) {
 152     // set the titlebar size
 153     _titlebar.setGeometry(-bwidth,
 154                           -bwidth,
 155                           width,
 156                           _style->labelFont()->height() + (bevel * 2));
 157     _innersize.top += _titlebar.height() + bwidth;
 158
 159     // set the label size
 160     _label.setGeometry(0, bevel, width, _style->labelFont()->height());
 161     // set the buttons sizes
 162     butsize = _label.height() - 2;
 163     if (_decorations & Client::Decor_Iconify)
 164       _button_iconify.setGeometry(0, bevel + 1, butsize, butsize);
 165     if (_decorations & Client::Decor_Maximize)
 166       _button_max.setGeometry(0, bevel + 1, butsize, butsize);
 167     if (_decorations & Client::Decor_Sticky)
 168       _button_stick.setGeometry(0, bevel + 1, butsize, butsize);
 169     if (_decorations & Client::Decor_Close)
 170       _button_close.setGeometry(0, bevel + 1, butsize, butsize);
 171
 172     // separation between titlebar elements
 173     const int sep = bevel + 1;
 174
 175     otk::ustring layout;
 176     if (!python_get_string("titlebar_layout", &layout))
 177       layout = "ILMC";
 178
 179     // this code ensures that the string only has one of each possible
 180     // letter, all of the letters are valid, and L exists somewhere in the
 181     // string!
 182     bool tit_l = false;
 183
 184     for (std::string::size_type i = 0; i < layout.size(); ++i) {
 185       switch (layout[i]) {
 186       case 'i':
 187       case 'I':
 188         if (!tit_i && (_decorations & Client::Decor_Iconify)) {
 189           tit_i = true;
 190           continue;
 191         }
 192         break;
 193       case 'l':
 194       case 'L':
 195         if (!tit_l) {
 196           tit_l = true;
 197           continue;
 198         }
 199         break;
 200       case 'm':
 201       case 'M':
 202         if (!tit_m && (_decorations & Client::Decor_Maximize)) {
 203           tit_m = true;
 204           continue;
 205         }
 206         break;
 207       case 's':
 208       case 'S':
 209         if (!tit_s && (_decorations & Client::Decor_Sticky)) {
 210           tit_s = true;
 211           continue;
 212         }
 213         break;
 214       case 'c':
 215       case 'C':
 216         if (!tit_c && (_decorations & Client::Decor_Close)) {
 217           tit_c = true;
 218           continue;
 219         }
 220         break;
 221       }
 222       // if we get here then we don't want the letter, kill it
 223       layout.erase(i--, 1);
 224     }
 225     if (!tit_l)
 226       layout += "L";
 227
 228     // the size of the label. this ASSUMES the layout has only buttons other
 229     // that the ONE LABEL!!
 230     // adds an extra sep so that there's a space on either side of the
 231     // titlebar.. note: x = sep, below.
 232     int lwidth = width - sep * 2 -
 233       (butsize + sep) * (layout.size() - 1);
 234     // quick sanity check for really small windows. if this is needed, its
 235     // obviously not going to be displayed right...
 236     // XXX: maybe we should make this look better somehow? constraints?
 237     if (lwidth <= 0) lwidth = 1;
 238     _label.setWidth(lwidth);
 239
 240     int x = sep;
 241     for (std::string::size_type i = 0, len = layout.size(); i < len; ++i) {
 242       switch (layout[i]) {
 243       case 'i':
 244       case 'I':
 245         _button_iconify.move(x, _button_iconify.rect().y());
 246         x += _button_iconify.width();
 247         break;
 248       case 'l':
 249       case 'L':
 250         _label.move(x, _label.rect().y());
 251         x += _label.width();
 252         break;
 253       case 'm':
 254       case 'M':
 255         _button_max.move(x, _button_max.rect().y());
 256         x += _button_max.width();
 257         break;
 258       case 's':
 259       case 'S':
 260         _button_stick.move(x, _button_stick.rect().y());
 261         x += _button_stick.width();
 262         break;
 263       case 'c':
 264       case 'C':
 265         _button_close.move(x, _button_close.rect().y());
 266         x += _button_close.width();
 267         break;
 268       default:
 269         assert(false); // the layout string is invalid!
 270       }
 271       x += sep;
 272     }
 273   }
 274
 275   if (_decorations & Client::Decor_Handle) {
 276     _handle.setGeometry(-bwidth,
 277                         _innersize.top + _client->area().height() + cbwidth,
 278                         width, _style->handleWidth());
 279     _grip_left.setGeometry(-bwidth,
 280                            -bwidth,
 281                            // XXX: get a Point class in otk and use that for
 282                            // the 'buttons size' since theyre all the same
 283                            butsize * 2,
 284                            _handle.height());
 285     _grip_right.setGeometry(((_handle.rect().right() + 1) -
 286                              butsize * 2),
 287                             -bwidth,
 288                             // XXX: get a Point class in otk and use that for
 289                             // the 'buttons size' since theyre all the same
 290                             butsize * 2,
 291                             _handle.height());
 292     _innersize.bottom += _handle.height() + bwidth;
 293   }
 294
 295
 296   // position/size all the windows
 297
 298   if (_client->shaded())
 299     resize(_innersize.left + _innersize.right + _client->area().width(),
 300            _titlebar.height());
 301   else
 302     resize(_innersize.left + _innersize.right + _client->area().width(),
 303            _innersize.top + _innersize.bottom + _client->area().height());
 304
 305   _plate.setGeometry(_innersize.left - cbwidth, _innersize.top - cbwidth,
 306                      _client->area().width(), _client->area().height());
 307
 308   // map/unmap all the windows
 309   if (_decorations & Client::Decor_Titlebar) {
 310     _label.show();
 311     if (tit_i)
 312       _button_iconify.show();
 313     else
 314       _button_iconify.hide();
 315     if (tit_m)
 316       _button_max.show();
 317     else
 318       _button_max.hide();
 319     if (tit_s)
 320       _button_stick.show();
 321     else
 322       _button_stick.hide();
 323     if (tit_c)
 324       _button_close.show();
 325     else
 326       _button_close.hide();
 327     _titlebar.show();
 328   } else {
 329     _titlebar.hide(true);
 330   }
 331
 332   if (_decorations & Client::Decor_Handle)
 333     _handle.show(true);
 334   else
 335     _handle.hide(true);
 336
 337   _size.left   = _innersize.left + bwidth;
 338   _size.right  = _innersize.right + bwidth;
 339   _size.top    = _innersize.top + bwidth;
 340   _size.bottom = _innersize.bottom + bwidth;
 341
 342   adjustShape();
 343
 344   update();
 345 }
 346
 347
 348 void Frame::adjustPosition()
 349 {
 350   int x, y;
 351   clientGravity(x, y);
 352   move(x, y);
 353 }
 354
 355
 356 void Frame::adjustShape()
 357 {
 358 #ifdef SHAPE
 359   int bwidth = (_decorations & Client::Decor_Border) ?
 360     _style->frameBorderWidth() : 0;
 361
 362   if (!_client->shaped()) {
 363     // clear the shape on the frame window
 364     XShapeCombineMask(**otk::display, _window, ShapeBounding,
 365                       _innersize.left,
 366                       _innersize.top,
 367                       None, ShapeSet);
 368   } else {
 369     // make the frame's shape match the clients
 370     XShapeCombineShape(**otk::display, _window, ShapeBounding,
 371                        _innersize.left,
 372                        _innersize.top,
 373                        _client->window(), ShapeBounding, ShapeSet);
 374
 375     int num = 0;
 376     XRectangle xrect[2];
 377
 378     if (_decorations & Client::Decor_Titlebar) {
 379       xrect[0].x = _titlebar.rect().x();
 380       xrect[0].y = _titlebar.rect().y();
 381       xrect[0].width = _titlebar.width() + bwidth * 2; // XXX: this is useless once the widget handles borders!
 382       xrect[0].height = _titlebar.height() + bwidth * 2;
 383       ++num;
 384     }
 385
 386     if (_decorations & Client::Decor_Handle) {
 387       xrect[1].x = _handle.rect().x();
 388       xrect[1].y = _handle.rect().y();
 389       xrect[1].width = _handle.width() + bwidth * 2; // XXX: this is useless once the widget handles borders!
 390       xrect[1].height = _handle.height() + bwidth * 2;
 391       ++num;
 392     }
 393
 394     XShapeCombineRectangles(**otk::display, window(),
 395                             ShapeBounding, 0, 0, xrect, num,
 396                             ShapeUnion, Unsorted);
 397   }
 398 #endif // SHAPE
 399 }
 400
 401
 402 void Frame::adjustState()
 403 {
 404   _button_stick.update();
 405   _button_max.update();
 406 }
 407
 408
 409 void Frame::grabClient()
 410 {
 411   // reparent the client to the frame
 412   XReparentWindow(**otk::display, _client->window(),
 413                   _plate.window(), 0, 0);
 414   /*
 415     When reparenting the client window, it is usually not mapped yet, since
 416     this occurs from a MapRequest. However, in the case where Openbox is
 417     starting up, the window is already mapped, so we'll see unmap events for
 418     it. There are 2 unmap events generated that we see, one with the 'event'
 419     member set the root window, and one set to the client, but both get handled
 420     and need to be ignored.
 421   */
 422   if (openbox->state() == Openbox::State_Starting)
 423     _client->ignore_unmaps += 2;
 424
 425   // select the event mask on the client's parent (to receive config req's)
 426   XSelectInput(**otk::display, _plate.window(),
 427                SubstructureRedirectMask);
 428
 429   // map the client so it maps when the frame does
 430   XMapWindow(**otk::display, _client->window());
 431
 432   adjustSize();
 433   adjustPosition();
 434 }
 435
 436
 437 void Frame::releaseClient()
 438 {
 439   XEvent ev;
 440
 441   // check if the app has already reparented its window away
 442   if (XCheckTypedWindowEvent(**otk::display, _client->window(),
 443                              ReparentNotify, &ev)) {
 444     XPutBackEvent(**otk::display, &ev);
 445     // re-map the window since the unmanaging process unmaps it
 446     XMapWindow(**otk::display, _client->window());
 447   } else {
 448     // according to the ICCCM - if the client doesn't reparent itself, then we
 449     // will reparent the window to root for them
 450     XReparentWindow(**otk::display, _client->window(),
 451                     _screen->rootWindow(),
 452                     _client->area().x(), _client->area().y());
 453   }
 454 }
 455
 456
 457 void Frame::clientGravity(int &x, int &y)
 458 {
 459   x = _client->area().x();
 460   y = _client->area().y();
 461
 462   // horizontal
 463   switch (_client->gravity()) {
 464   default:
 465   case NorthWestGravity:
 466   case SouthWestGravity:
 467   case WestGravity:
 468     break;
 469
 470   case NorthGravity:
 471   case SouthGravity:
 472   case CenterGravity:
 473     x -= (_size.left + _size.right) / 2;
 474     break;
 475
 476   case NorthEastGravity:
 477   case SouthEastGravity:
 478   case EastGravity:
 479     x -= _size.left + _size.right;
 480     break;
 481
 482   case ForgetGravity:
 483   case StaticGravity:
 484     x -= _size.left;
 485     break;
 486   }
 487
 488   // vertical
 489   switch (_client->gravity()) {
 490   default:
 491   case NorthWestGravity:
 492   case NorthEastGravity:
 493   case NorthGravity:
 494     break;
 495
 496   case CenterGravity:
 497   case EastGravity:
 498   case WestGravity:
 499     y -= (_size.top + _size.bottom) / 2;
 500     break;
 501
 502   case SouthWestGravity:
 503   case SouthEastGravity:
 504   case SouthGravity:
 505     y -= _size.top + _size.bottom;
 506     break;
 507
 508   case ForgetGravity:
 509   case StaticGravity:
 510     y -= _size.top;
 511     break;
 512   }
 513 }
 514
 515
 516 void Frame::frameGravity(int &x, int &y)
 517 {
 518   x = rect().x();
 519   y = rect().y();
 520
 521   // horizontal
 522   switch (_client->gravity()) {
 523   default:
 524   case NorthWestGravity:
 525   case WestGravity:
 526   case SouthWestGravity:
 527     break;
 528   case NorthGravity:
 529   case CenterGravity:
 530   case SouthGravity:
 531     x += (_size.left + _size.right) / 2;
 532     break;
 533   case NorthEastGravity:
 534   case EastGravity:
 535   case SouthEastGravity:
 536     x += _size.left + _size.right;
 537     break;
 538   case StaticGravity:
 539   case ForgetGravity:
 540     x += _size.left;
 541     break;
 542   }
 543
 544   // vertical
 545   switch (_client->gravity()) {
 546   default:
 547   case NorthWestGravity:
 548   case WestGravity:
 549   case SouthWestGravity:
 550     break;
 551   case NorthGravity:
 552   case CenterGravity:
 553   case SouthGravity:
 554     y += (_size.top + _size.bottom) / 2;
 555     break;
 556   case NorthEastGravity:
 557   case EastGravity:
 558   case SouthEastGravity:
 559     y += _size.top + _size.bottom;
 560     break;
 561   case StaticGravity:
 562   case ForgetGravity:
 563     y += _size.top;
 564     break;
 565   }
 566 }
 567
 568
 569 }