src/client.cc

   1 // -*- mode: C++; indent-tabs-mode: nil; c-basic-offset: 2; -*-
   2
   3 #include "client.hh"
   4 #include "screen.hh"
   5 #include "openbox.hh"
   6 #include "otk/display.hh"
   7 #include "otk/property.hh"
   8
   9 extern "C" {
  10 #include <X11/Xlib.h>
  11 #include <X11/Xutil.h>
  12
  13 #include <assert.h>
  14
  15 #include "gettext.h"
  16 #define _(str) gettext(str)
  17 }
  18
  19 namespace ob {
  20
  21 OBClient::OBClient(Window window)
  22   : _window(window)
  23 {
  24   assert(window);
  25
  26   // update EVERYTHING the first time!!
  27
  28   // the state is kinda assumed to be normal. is this right? XXX
  29   _wmstate = NormalState;
  30   // no default decors or functions, each has to be enabled
  31   _decorations = _functions = 0;
  32
  33   getArea();
  34   getDesktop();
  35   getType();
  36   getMwmHints();
  37   getState();
  38   getShaped();
  39
  40   updateProtocols();
  41   updateNormalHints();
  42   updateWMHints();
  43   // XXX: updateTransientFor();
  44   updateTitle();
  45   updateClass();
  46
  47 #ifdef DEBUG
  48   printf("Mapped window: 0x%lx\n"
  49          "  title:         \t%s\t  icon title:    \t%s\n"
  50          "  app name:      \t%s\t\t  class:         \t%s\n"
  51          "  position:      \t%d, %d\t\t  size:          \t%d, %d\n"
  52          "  desktop:       \t%lu\t\t  group:         \t0x%lx\n"
  53          "  type:          \t%d\t\t  min size       \t%d, %d\n"
  54          "  base size      \t%d, %d\t\t  max size       \t%d, %d\n"
  55          "  size incr      \t%d, %d\t\t  gravity        \t%d\n"
  56          "  wm state       \t%ld\t\t  can be focused:\t%s\n"
  57          "  notify focus:  \t%s\t\t  urgent:        \t%s\n"
  58          "  shaped:        \t%s\t\t  modal:         \t%s\n"
  59          "  shaded:        \t%s\t\t  iconic:        \t%s\n"
  60          "  vert maximized:\t%s\t\t  horz maximized:\t%s\n"
  61          "  fullscreen:    \t%s\t\t  floating:      \t%s\n"
  62          "  requested pos: \t%s\n",
  63          _window,
  64          _title.c_str(),
  65          _icon_title.c_str(),
  66          _app_name.c_str(),
  67          _app_class.c_str(),
  68          _area.x(), _area.y(),
  69          _area.width(), _area.height(),
  70          _desktop,
  71          _group,
  72          _type,
  73          _min_x, _min_y,
  74          _base_x, _base_y,
  75          _max_x, _max_y,
  76          _inc_x, _inc_y,
  77          _gravity,
  78          _wmstate,
  79          _can_focus ? "yes" : "no",
  80          _focus_notify ? "yes" : "no",
  81          _urgent ? "yes" : "no",
  82          _shaped ? "yes" : "no",
  83          _modal ? "yes" : "no",
  84          _shaded ? "yes" : "no",
  85          _iconic ? "yes" : "no",
  86          _max_vert ? "yes" : "no",
  87          _max_horz ? "yes" : "no",
  88          _fullscreen ? "yes" : "no",
  89          _floating ? "yes" : "no",
  90          _positioned ? "yes" : "no");
  91 #endif
  92 }
  93
  94
  95 OBClient::~OBClient()
  96 {
  97   const otk::OBProperty *property = Openbox::instance->property();
  98
  99   // these values should not be persisted across a window unmapping/mapping
 100   property->erase(_window, otk::OBProperty::net_wm_desktop);
 101   property->erase(_window, otk::OBProperty::net_wm_state);
 102 }
 103
 104
 105 void OBClient::getDesktop()
 106 {
 107   const otk::OBProperty *property = Openbox::instance->property();
 108
 109   // defaults to the current desktop
 110   _desktop = 0; // XXX: change this to the current desktop!
 111
 112   property->get(_window, otk::OBProperty::net_wm_desktop,
 113                 otk::OBProperty::Atom_Cardinal,
 114                 &_desktop);
 115 }
 116
 117
 118 void OBClient::getType()
 119 {
 120   const otk::OBProperty *property = Openbox::instance->property();
 121
 122   _type = (WindowType) -1;
 123
 124   unsigned long *val;
 125   unsigned long num = (unsigned) -1;
 126   if (property->get(_window, otk::OBProperty::net_wm_window_type,
 127                     otk::OBProperty::Atom_Atom,
 128                     &num, &val)) {
 129     // use the first value that we know about in the array
 130     for (unsigned long i = 0; i < num; ++i) {
 131       if (val[i] ==
 132           property->atom(otk::OBProperty::net_wm_window_type_desktop))
 133         _type = Type_Desktop;
 134       else if (val[i] ==
 135                property->atom(otk::OBProperty::net_wm_window_type_dock))
 136         _type = Type_Dock;
 137       else if (val[i] ==
 138                property->atom(otk::OBProperty::net_wm_window_type_toolbar))
 139         _type = Type_Toolbar;
 140       else if (val[i] ==
 141                property->atom(otk::OBProperty::net_wm_window_type_menu))
 142         _type = Type_Menu;
 143       else if (val[i] ==
 144                property->atom(otk::OBProperty::net_wm_window_type_utility))
 145         _type = Type_Utility;
 146       else if (val[i] ==
 147                property->atom(otk::OBProperty::net_wm_window_type_splash))
 148         _type = Type_Splash;
 149       else if (val[i] ==
 150                property->atom(otk::OBProperty::net_wm_window_type_dialog))
 151         _type = Type_Dialog;
 152       else if (val[i] ==
 153                property->atom(otk::OBProperty::net_wm_window_type_normal))
 154         _type = Type_Normal;
 155 //      else if (val[i] ==
 156 //               property->atom(otk::OBProperty::kde_net_wm_window_type_override))
 157 //        mwm_decorations = 0; // prevent this window from getting any decor
 158       // XXX: make this work again
 159     }
 160     delete val;
 161   }
 162
 163   if (_type == (WindowType) -1) {
 164     /*
 165      * the window type hint was not set, which means we either classify ourself
 166      * as a normal window or a dialog, depending on if we are a transient.
 167      */
 168     // XXX: make this code work!
 169     //if (isTransient())
 170     //  _type = Type_Dialog;
 171     //else
 172       _type = Type_Normal;
 173   }
 174
 175   // set the decorations and functions based on the type of the window
 176 }
 177
 178
 179 void OBClient::getMWMHints()
 180 {
 181   const otk::OBProperty *property = Openbox::instance->property();
 182
 183   unsigned long num;
 184   MwmHints *hints;
 185
 186   num = MwmHints::elements;
 187   if (!property->get(_window, otk::OBProperty::motif_wm_hints,
 188                      otk::OBProperty::motif_wm_hints, &num,
 189                      (unsigned long **)&hints))
 190     return;
 191
 192   if (num < MwmHints::elements) {
 193     delete [] hints;
 194     return;
 195   }
 196
 197   // retrieved the hints
 198   // Mwm Hints are applied subtractively to what has already been chosen for
 199   // decor and functionality
 200
 201   if (hints->flags & MwmDecorations) {
 202     if (! (hints->decorations & MwmDecor_All)) {
 203       if (! (hints->decorations & MwmDecor_Border))
 204         _decorations &= ~Decor_Border;
 205       if (! (hints->decorations & MwmDecor_Handle))
 206         _decorations &= ~Decor_Handle;
 207       if (! (hints->decorations & MwmDecor_Title))
 208         _decorations &= ~Decor_Titlebar;
 209       if (! (hints->decorations & MwmDecor_Iconify))
 210         _decorations &= ~Decor_Iconify;
 211       if (! (hints->decorations & MwmDecor_Maximize))
 212         _decorations &= ~Decor_Maximize;
 213     }
 214   }
 215
 216   _mwm_functions = 0xffffffff; // everything!
 217
 218   if (hints->flags & MwmFunctions) {
 219     if (! (hints->functions & MwmFunc_All)) {
 220       _mwm_functions = hints->functions;
 221
 222       if (! (hints->functions & MwmFunc_Resize))
 223         functions &= ~Func_Resize;
 224       if (! (hints->functions & MwmFunc_Move))
 225         functions &= ~Func_Move;
 226       if (! (hints->functions & MwmFunc_Iconify))
 227         functions &= ~Func_Iconify;
 228       if (! (hints->functions & MwmFunc_Maximize))
 229         functions &= ~Func_Maximize;
 230       if (! (hints->functions & MwmFunc_Close))
 231         functions &= ~Func_Close;
 232     }
 233   }
 234   delete [] hints;
 235 }
 236
 237
 238 void OBClient::getArea()
 239 {
 240   XWindowAttributes wattrib;
 241   assert(XGetWindowAttributes(otk::OBDisplay::display, _window, &wattrib));
 242
 243   _area.setRect(wattrib.x, wattrib.y, wattrib.width, wattrib.height);
 244   _border_width = wattrib.border_width;
 245 }
 246
 247
 248 void OBClient::getState()
 249 {
 250   const otk::OBProperty *property = Openbox::instance->property();
 251
 252   _modal = _shaded = _max_horz = _max_vert = _fullscreen = _floating = false;
 253
 254   unsigned long *state;
 255   unsigned long num = (unsigned) -1;
 256
 257   if (property->get(_window, otk::OBProperty::net_wm_state,
 258                     otk::OBProperty::Atom_Atom, &num, &state)) {
 259     for (unsigned long i = 0; i < num; ++i) {
 260       if (state[i] == property->atom(otk::OBProperty::net_wm_state_modal))
 261         _modal = true;
 262       else if (state[i] ==
 263                property->atom(otk::OBProperty::net_wm_state_shaded))
 264         _shaded = true;
 265       else if (state[i] ==
 266                property->atom(otk::OBProperty::net_wm_state_fullscreen))
 267         _fullscreen = true;
 268       else if (state[i] ==
 269                property->atom(otk::OBProperty::net_wm_state_maximized_vert))
 270         _max_vert = true;
 271       else if (state[i] ==
 272                property->atom(otk::OBProperty::net_wm_state_maximized_horz))
 273         _max_horz = true;
 274     }
 275
 276     delete [] state;
 277   }
 278 }
 279
 280
 281 void OBClient::getShaped()
 282 {
 283   _shaped = false;
 284 #ifdef   SHAPE
 285   if (otk::OBDisplay::shape()) {
 286     int foo;
 287     unsigned int ufoo;
 288
 289     XShapeQueryExtents(otk::OBDisplay::display, client.window, &_shaped, &foo,
 290                        &foo, &ufoo, &ufoo, &foo, &foo, &foo, &ufoo, &ufoo);
 291   }
 292 #endif // SHAPE
 293 }
 294
 295
 296 void OBClient::updateProtocols()
 297 {
 298   const otk::OBProperty *property = Openbox::instance->property();
 299
 300   Atom *proto;
 301   int num_return = 0;
 302
 303   _focus_notify = false;
 304
 305   if (XGetWMProtocols(otk::OBDisplay::display, _window, &proto, &num_return)) {
 306     for (int i = 0; i < num_return; ++i) {
 307       if (proto[i] == property->atom(otk::OBProperty::wm_delete_window)) {
 308         // add the close button/functionality only if the mwm hints didnt
 309         // exclude it
 310         if (_mwm_functions & MwmFunc_Close) {
 311           decorations |= Decor_Close;
 312           functions |= Func_Close;
 313           // XXX: update the decor?
 314         }
 315       } else if (proto[i] == property->atom(otk::OBProperty::wm_take_focus))
 316         // if this protocol is requested, then the window will be notified
 317         // by the window manager whenever it receives focus
 318         _focus_notify = true;
 319     }
 320     XFree(proto);
 321   }
 322 }
 323
 324
 325 void OBClient::updateNormalHints()
 326 {
 327   XSizeHints size;
 328   long ret;
 329
 330   // defaults
 331   _gravity = NorthWestGravity;
 332   _inc_x = _inc_y = 1;
 333   _base_x = _base_y = 0;
 334   _min_x = _min_y = 0;
 335   _max_x = _max_y = INT_MAX;
 336
 337   // XXX: might want to cancel any interactive resizing of the window at this
 338   // point..
 339
 340   // get the hints from the window
 341   if (XGetWMNormalHints(otk::OBDisplay::display, _window, &size, &ret)) {
 342     _positioned = (size.flags & (PPosition|USPosition));
 343
 344     if (size.flags & PWinGravity)
 345       _gravity = size.win_gravity;
 346
 347     if (size.flags & PMinSize) {
 348       _min_x = size.min_width;
 349       _min_y = size.min_height;
 350     }
 351
 352     if (size.flags & PMaxSize) {
 353       _max_x = size.max_width;
 354       _max_y = size.max_height;
 355     }
 356
 357     if (size.flags & PBaseSize) {
 358       _base_x = size.base_width;
 359       _base_y = size.base_height;
 360     }
 361
 362     if (size.flags & PResizeInc) {
 363       _inc_x = size.width_inc;
 364       _inc_y = size.height_inc;
 365     }
 366   }
 367 }
 368
 369
 370 void OBClient::updateWMHints()
 371 {
 372   XWMHints *hints;
 373
 374   // assume a window takes input if it doesnt specify
 375   _can_focus = true;
 376   _urgent = false;
 377
 378   if ((hints = XGetWMHints(otk::OBDisplay::display, _window)) != NULL) {
 379     if (hints->flags & InputHint)
 380       _can_focus = hints->input;
 381
 382     if (hints->flags & XUrgencyHint)
 383       _urgent = true;
 384
 385     if (hints->flags & WindowGroupHint) {
 386       if (hints->window_group != _group) {
 387         // XXX: remove from the old group if there was one
 388         _group = hints->window_group;
 389         // XXX: do stuff with the group
 390       }
 391     } else // no group!
 392       _group = None;
 393
 394     XFree(hints);
 395   }
 396 }
 397
 398
 399 void OBClient::updateTitle()
 400 {
 401   const otk::OBProperty *property = Openbox::instance->property();
 402
 403   _title = "";
 404
 405   // try netwm
 406   if (! property->get(_window, otk::OBProperty::net_wm_name,
 407                       otk::OBProperty::utf8, &_title)) {
 408     // try old x stuff
 409     property->get(_window, otk::OBProperty::wm_name,
 410                   otk::OBProperty::ascii, &_title);
 411   }
 412
 413   if (_title.empty())
 414     _title = _("Unnamed Window");
 415 }
 416
 417
 418 void OBClient::updateClass()
 419 {
 420   const otk::OBProperty *property = Openbox::instance->property();
 421
 422   // set the defaults
 423   _app_name = _app_class = "";
 424
 425   otk::OBProperty::StringVect v;
 426   unsigned long num = 2;
 427
 428   if (! property->get(_window, otk::OBProperty::wm_class,
 429                       otk::OBProperty::ascii, &num, &v))
 430     return;
 431
 432   if (num > 0) _app_name = v[0];
 433   if (num > 1) _app_class = v[1];
 434 }
 435
 436
 437 void OBClient::update(const XPropertyEvent &e)
 438 {
 439   const otk::OBProperty *property = Openbox::instance->property();
 440
 441   if (e.atom == XA_WM_NORMAL_HINTS)
 442     updateNormalHints();
 443   else if (e.atom == XA_WM_HINTS)
 444     updateWMHints();
 445   else if (e.atom == property->atom(otk::OBProperty::net_wm_name) ||
 446            e.atom == property->atom(otk::OBProperty::wm_name) ||
 447            e.atom == property->atom(otk::OBProperty::net_wm_icon_name) ||
 448            e.atom == property->atom(otk::OBProperty::wm_icon_name))
 449     updateTitle();
 450   else if (e.atom == property->atom(otk::OBProperty::wm_class))
 451     updateClass();
 452   else if (e.atom == property->atom(otk::OBProperty::wm_protocols))
 453     updateProtocols();
 454   // XXX: transient for hint
 455   // XXX: strut hint
 456 }
 457
 458
 459 void OBClient::setWMState(long state)
 460 {
 461   if (state == _wmstate) return; // no change
 462
 463   switch (state) {
 464   case IconicState:
 465     // XXX: cause it to iconify
 466     break;
 467   case NormalState:
 468     // XXX: cause it to uniconify
 469     break;
 470   }
 471   _wmstate = state;
 472 }
 473
 474
 475 void OBClient::setDesktop(long target)
 476 {
 477   assert(target >= 0);
 478   //assert(target == 0xffffffff || target < MAX);
 479
 480   // XXX: move the window to the new desktop
 481   _desktop = target;
 482 }
 483
 484
 485 void OBClient::setState(StateAction action, long data1, long data2)
 486 {
 487   const otk::OBProperty *property = Openbox::instance->property();
 488
 489   if (!(action == State_Add || action == State_Remove ||
 490         action == State_Toggle))
 491     return; // an invalid action was passed to the client message, ignore it
 492
 493   for (int i = 0; i < 2; ++i) {
 494     Atom state = i == 0 ? data1 : data2;
 495
 496     if (! state) continue;
 497
 498     // if toggling, then pick whether we're adding or removing
 499     if (action == State_Toggle) {
 500       if (state == property->atom(otk::OBProperty::net_wm_state_modal))
 501         action = _modal ? State_Remove : State_Add;
 502       else if (state ==
 503                property->atom(otk::OBProperty::net_wm_state_maximized_vert))
 504         action = _max_vert ? State_Remove : State_Add;
 505       else if (state ==
 506                property->atom(otk::OBProperty::net_wm_state_maximized_horz))
 507         action = _max_horz ? State_Remove : State_Add;
 508       else if (state == property->atom(otk::OBProperty::net_wm_state_shaded))
 509         action = _shaded ? State_Remove : State_Add;
 510       else if (state ==
 511                property->atom(otk::OBProperty::net_wm_state_fullscreen))
 512         action = _fullscreen ? State_Remove : State_Add;
 513       else if (state == property->atom(otk::OBProperty::net_wm_state_floating))
 514         action = _floating ? State_Remove : State_Add;
 515     }
 516
 517     if (action == State_Add) {
 518       if (state == property->atom(otk::OBProperty::net_wm_state_modal)) {
 519         if (_modal) continue;
 520         _modal = true;
 521         // XXX: give it focus if another window has focus that shouldnt now
 522       } else if (state ==
 523                  property->atom(otk::OBProperty::net_wm_state_maximized_vert)){
 524         if (_max_vert) continue;
 525         _max_vert = true;
 526         // XXX: resize the window etc
 527       } else if (state ==
 528                  property->atom(otk::OBProperty::net_wm_state_maximized_horz)){
 529         if (_max_horz) continue;
 530         _max_horz = true;
 531         // XXX: resize the window etc
 532       } else if (state ==
 533                  property->atom(otk::OBProperty::net_wm_state_shaded)) {
 534         if (_shaded) continue;
 535         _shaded = true;
 536         // XXX: hide the client window
 537       } else if (state ==
 538                  property->atom(otk::OBProperty::net_wm_state_fullscreen)) {
 539         if (_fullscreen) continue;
 540         _fullscreen = true;
 541         // XXX: raise the window n shit
 542       } else if (state ==
 543                  property->atom(otk::OBProperty::net_wm_state_floating)) {
 544         if (_floating) continue;
 545         _floating = true;
 546         // XXX: raise the window n shit
 547       }
 548
 549     } else { // action == State_Remove
 550       if (state == property->atom(otk::OBProperty::net_wm_state_modal)) {
 551         if (!_modal) continue;
 552         _modal = false;
 553       } else if (state ==
 554                  property->atom(otk::OBProperty::net_wm_state_maximized_vert)){
 555         if (!_max_vert) continue;
 556         _max_vert = false;
 557         // XXX: resize the window etc
 558       } else if (state ==
 559                  property->atom(otk::OBProperty::net_wm_state_maximized_horz)){
 560         if (!_max_horz) continue;
 561         _max_horz = false;
 562         // XXX: resize the window etc
 563       } else if (state ==
 564                  property->atom(otk::OBProperty::net_wm_state_shaded)) {
 565         if (!_shaded) continue;
 566         _shaded = false;
 567         // XXX: show the client window
 568       } else if (state ==
 569                  property->atom(otk::OBProperty::net_wm_state_fullscreen)) {
 570         if (!_fullscreen) continue;
 571         _fullscreen = false;
 572         // XXX: lower the window to its proper layer
 573       } else if (state ==
 574                  property->atom(otk::OBProperty::net_wm_state_floating)) {
 575         if (!_floating) continue;
 576         _floating = false;
 577         // XXX: lower the window to its proper layer
 578       }
 579     }
 580   }
 581 }
 582
 583
 584 void OBClient::update(const XClientMessageEvent &e)
 585 {
 586   if (e.format != 32) return;
 587
 588   const otk::OBProperty *property = Openbox::instance->property();
 589
 590   if (e.message_type == property->atom(otk::OBProperty::wm_change_state))
 591     setWMState(e.data.l[0]);
 592   else if (e.message_type ==
 593              property->atom(otk::OBProperty::net_wm_desktop))
 594     setDesktop(e.data.l[0]);
 595   else if (e.message_type == property->atom(otk::OBProperty::net_wm_state))
 596     setState((StateAction)e.data.l[0], e.data.l[1], e.data.l[2]);
 597 }
 598
 599
 600 void OBClient::setArea(const otk::Rect &area)
 601 {
 602   _area = area;
 603 }
 604
 605 }