X-Git-Url: https://git.dogcows.com/gitweb?a=blobdiff_plain;f=src%2Fclient.cc;h=e55f681f58a7edaba152905dd4f23d8908f3fe30;hb=a7ccc544500fe84e707f6e511261276b819d8906;hp=4f6fe4a21e3006a115528b5e92a04e4761c315d3;hpb=7b9d92b2e75cab137ca3bfaf48ce40b5cbbaacf4;p=chaz%2Fopenbox diff --git a/src/client.cc b/src/client.cc index 4f6fe4a2..e55f681f 100644 --- a/src/client.cc +++ b/src/client.cc @@ -8,6 +8,7 @@ #include "frame.hh" #include "screen.hh" #include "openbox.hh" +#include "bindings.hh" #include "otk/display.hh" #include "otk/property.hh" @@ -22,6 +23,8 @@ extern "C" { #define _(str) gettext(str) } +#include + namespace ob { Client::Client(int screen, Window window) @@ -36,16 +39,20 @@ Client::Client(int screen, Window window) // update EVERYTHING the first time!! - // the state is kinda assumed to be normal. is this right? XXX - _wmstate = NormalState; _iconic = false; - // no default decors or functions, each has to be enabled - _decorations = _functions = 0; + // we default to NormalState, visible + _wmstate = NormalState; // start unfocused _focused = false; // not a transient by default of course _transient_for = 0; // pick a layer to start from _layer = Layer_Normal; + // default to not urgent + _urgent = false; + // not positioned unless specified + _positioned = false; + // nothing is disabled unless specified + _disabled_decorations = 0; getArea(); getDesktop(); @@ -54,20 +61,35 @@ Client::Client(int screen, Window window) getType(); getMwmHints(); - setupDecorAndFunctions(); - getState(); getShaped(); updateProtocols(); - getGravity(); // get the attribute gravity + + // got the type, the mwmhints, and the protocols, so we're ready to set up + // the decorations/functions + setupDecorAndFunctions(); + + getGravity(); // get the attribute gravity updateNormalHints(); // this may override the attribute gravity - updateWMHints(); + // also get the initial_state and set _iconic if we aren't "starting" + // when we're "starting" that means we should use whatever state was already + // on the window over the initial map state, because it was already mapped + updateWMHints(openbox->state() != Openbox::State_Starting); updateTitle(); updateIconTitle(); updateClass(); updateStrut(); + // this makes sure that these windows appear on all desktops + if (/*_type == Type_Dock ||*/ _type == Type_Desktop) + _desktop = 0xffffffff; + + // set the desktop hint, to make sure that it always exists, and to reflect + // any changes we've made here + otk::Property::set(_window, otk::Property::atoms.net_wm_desktop, + otk::Property::atoms.cardinal, (unsigned)_desktop); + changeState(); } @@ -88,7 +110,27 @@ Client::~Client() // these values should not be persisted across a window unmapping/mapping otk::Property::erase(_window, otk::Property::atoms.net_wm_desktop); otk::Property::erase(_window, otk::Property::atoms.net_wm_state); + } else { + // if we're left in an iconic state, the client wont be mapped. this is + // bad, since we will no longer be managing the window on restart + if (_iconic) + XMapWindow(**otk::display, _window); + } +} + + +bool Client::validate() const +{ + XSync(**otk::display, false); // get all events on the server + + XEvent e; + if (XCheckTypedWindowEvent(**otk::display, _window, DestroyNotify, &e) || + XCheckTypedWindowEvent(**otk::display, _window, UnmapNotify, &e)) { + XPutBackEvent(**otk::display, &e); + return false; } + + return true; } @@ -108,12 +150,12 @@ void Client::getDesktop() // defaults to the current desktop _desktop = openbox->screen(_screen)->desktop(); - if (!otk::Property::get(_window, otk::Property::atoms.net_wm_desktop, - otk::Property::atoms.cardinal, - (long unsigned*)&_desktop)) { - // make sure the hint exists - otk::Property::set(_window, otk::Property::atoms.net_wm_desktop, - otk::Property::atoms.cardinal, (unsigned)_desktop); + if (otk::Property::get(_window, otk::Property::atoms.net_wm_desktop, + otk::Property::atoms.cardinal, + (long unsigned*)&_desktop)) { +#ifdef DEBUG +// printf("Window requested desktop: %ld\n", _desktop); +#endif } } @@ -169,10 +211,19 @@ void Client::getType() void Client::setupDecorAndFunctions() { // start with everything (cept fullscreen) - _decorations = Decor_Titlebar | Decor_Handle | Decor_Border | Decor_Sticky | - Decor_Iconify | Decor_Maximize; + _decorations = Decor_Titlebar | Decor_Handle | Decor_Border | + Decor_AllDesktops | Decor_Iconify | Decor_Maximize; _functions = Func_Resize | Func_Move | Func_Iconify | Func_Maximize | Func_Shade; + if (_delete_window) { + _decorations |= Decor_Close; + _functions |= Func_Close; + } + + if (!(_min_size.x() < _max_size.x() || _min_size.y() < _max_size.y())) { + _decorations &= ~(Decor_Maximize | Decor_Handle); + _functions &= ~(Func_Resize | Func_Maximize); + } switch (_type) { case Type_Normal: @@ -239,7 +290,30 @@ void Client::setupDecorAndFunctions() } } + // finally, user specified disabled decorations are applied to subtract + // decorations + if (_disabled_decorations & Decor_Titlebar) + _decorations &= ~Decor_Titlebar; + if (_disabled_decorations & Decor_Handle) + _decorations &= ~Decor_Handle; + if (_disabled_decorations & Decor_Border) + _decorations &= ~Decor_Border; + if (_disabled_decorations & Decor_Iconify) + _decorations &= ~Decor_Iconify; + if (_disabled_decorations & Decor_Maximize) + _decorations &= ~Decor_Maximize; + if (_disabled_decorations & Decor_AllDesktops) + _decorations &= ~Decor_AllDesktops; + if (_disabled_decorations & Decor_Close) + _decorations &= ~Decor_Close; + changeAllowedActions(); + + if (frame) { + frame->adjustSize(); // change the decors on the frame + frame->adjustPosition(); // with more/less decorations, we may need to be + // moved + } } @@ -282,7 +356,7 @@ void Client::getArea() void Client::getState() { _modal = _shaded = _max_horz = _max_vert = _fullscreen = _above = _below = - _skip_taskbar = _skip_pager = false; + _iconic = _skip_taskbar = _skip_pager = false; unsigned long *state; unsigned long num = (unsigned) -1; @@ -294,6 +368,8 @@ void Client::getState() _modal = true; else if (state[i] == otk::Property::atoms.net_wm_state_shaded) _shaded = true; + else if (state[i] == otk::Property::atoms.net_wm_state_hidden) + _iconic = true; else if (state[i] == otk::Property::atoms.net_wm_state_skip_taskbar) _skip_taskbar = true; else if (state[i] == otk::Property::atoms.net_wm_state_skip_pager) @@ -367,16 +443,13 @@ void Client::updateProtocols() int num_return = 0; _focus_notify = false; - _decorations &= ~Decor_Close; - _functions &= ~Func_Close; + _delete_window = false; if (XGetWMProtocols(**otk::display, _window, &proto, &num_return)) { for (int i = 0; i < num_return; ++i) { if (proto[i] == otk::Property::atoms.wm_delete_window) { - _decorations |= Decor_Close; - _functions |= Func_Close; - if (frame) - frame->adjustSize(); // update the decorations + // this means we can request the window to close + _delete_window = true; } else if (proto[i] == otk::Property::atoms.wm_take_focus) // if this protocol is requested, then the window will be notified // by the window manager whenever it receives focus @@ -394,6 +467,8 @@ void Client::updateNormalHints() int oldgravity = _gravity; // defaults + _min_ratio = 0.0; + _max_ratio = 0.0; _size_inc.setPoint(1, 1); _base_size.setPoint(0, 0); _min_size.setPoint(0, 0); @@ -419,6 +494,11 @@ void Client::updateNormalHints() } } + if (size.flags & PAspect) { + if (size.min_aspect.y) _min_ratio = size.min_aspect.x/size.min_aspect.y; + if (size.max_aspect.y) _max_ratio = size.max_aspect.x/size.max_aspect.y; + } + if (size.flags & PMinSize) _min_size.setPoint(size.min_width, size.min_height); @@ -434,20 +514,24 @@ void Client::updateNormalHints() } -void Client::updateWMHints() +void Client::updateWMHints(bool initstate) { XWMHints *hints; // assume a window takes input if it doesnt specify _can_focus = true; - _urgent = false; + bool ur = false; if ((hints = XGetWMHints(**otk::display, _window)) != NULL) { if (hints->flags & InputHint) _can_focus = hints->input; + // only do this when initstate is true! + if (initstate && (hints->flags & StateHint)) + _iconic = hints->initial_state == IconicState; + if (hints->flags & XUrgencyHint) - _urgent = true; + ur = true; if (hints->flags & WindowGroupHint) { if (hints->window_group != _group) { @@ -460,6 +544,18 @@ void Client::updateWMHints() XFree(hints); } + + if (ur != _urgent) { + _urgent = ur; +#ifdef DEBUG + printf("DEBUG: Urgent Hint for 0x%lx: %s\n", + (long)_window, _urgent ? "ON" : "OFF"); +#endif + // fire the urgent callback if we're mapped, otherwise, wait until after + // we're mapped + if (frame) + fireUrgent(); + } } @@ -535,9 +631,12 @@ void Client::updateStrut() _strut.left = data[0]; _strut.right = data[1]; _strut.top = data[2]; - _strut.bottom = data[3]; - - openbox->screen(_screen)->updateStrut(); + _strut.bottom = data[3]; + + // updating here is pointless while we're being mapped cuz we're not in + // the screen's client list yet + if (frame) + openbox->screen(_screen)->updateStrut(); } delete [] data; @@ -582,6 +681,9 @@ void Client::updateTransientFor() void Client::propertyHandler(const XPropertyEvent &e) { otk::EventHandler::propertyHandler(e); + + // validate cuz we query stuff off the client here + if (!validate()) return; // compress changes to a single property into a single change XEvent ce; @@ -594,16 +696,16 @@ void Client::propertyHandler(const XPropertyEvent &e) } } - if (e.atom == XA_WM_NORMAL_HINTS) + if (e.atom == XA_WM_NORMAL_HINTS) { updateNormalHints(); - else if (e.atom == XA_WM_HINTS) + setupDecorAndFunctions(); // normal hints can make a window non-resizable + } else if (e.atom == XA_WM_HINTS) updateWMHints(); else if (e.atom == XA_WM_TRANSIENT_FOR) { updateTransientFor(); getType(); calcLayer(); // type may have changed, so update the layer setupDecorAndFunctions(); - frame->adjustSize(); // this updates the frame for any new decor settings } else if (e.atom == otk::Property::atoms.net_wm_name || e.atom == otk::Property::atoms.wm_name) @@ -613,8 +715,10 @@ void Client::propertyHandler(const XPropertyEvent &e) updateIconTitle(); else if (e.atom == otk::Property::atoms.wm_class) updateClass(); - else if (e.atom == otk::Property::atoms.wm_protocols) + else if (e.atom == otk::Property::atoms.wm_protocols) { updateProtocols(); + setupDecorAndFunctions(); + } else if (e.atom == otk::Property::atoms.net_wm_strut) updateStrut(); } @@ -624,13 +728,12 @@ void Client::setWMState(long state) { if (state == _wmstate) return; // no change - _wmstate = state; - switch (_wmstate) { + switch (state) { case IconicState: - // XXX: cause it to iconify + setDesktop(ICONIC_DESKTOP); break; case NormalState: - // XXX: cause it to uniconify + setDesktop(openbox->screen(_screen)->desktop()); break; } } @@ -642,12 +745,16 @@ void Client::setDesktop(long target) printf("Setting desktop %ld\n", target); - if (!(target >= 0 || target == (signed)0xffffffff)) return; + if (!(target >= 0 || target == (signed)0xffffffff || + target == ICONIC_DESKTOP)) + return; _desktop = target; - otk::Property::set(_window, otk::Property::atoms.net_wm_desktop, - otk::Property::atoms.cardinal, (unsigned)_desktop); + // set the desktop hint, but not if we're iconifying + if (_desktop != ICONIC_DESKTOP) + otk::Property::set(_window, otk::Property::atoms.net_wm_desktop, + otk::Property::atoms.cardinal, (unsigned)_desktop); // 'move' the window to the new desktop if (_desktop == openbox->screen(_screen)->desktop() || @@ -655,6 +762,27 @@ void Client::setDesktop(long target) frame->show(); else frame->hide(); + + // Handle Iconic state. Iconic state is maintained by the client being a + // member of the ICONIC_DESKTOP, so this is where we make iconifying and + // uniconifying happen. + bool i = _desktop == ICONIC_DESKTOP; + if (i != _iconic) { // has the state changed? + _iconic = i; + if (_iconic) { + _wmstate = IconicState; + ignore_unmaps++; + // we unmap the client itself so that we can get MapRequest events, and + // because the ICCCM tells us to! + XUnmapWindow(**otk::display, _window); + } else { + _wmstate = NormalState; + XMapWindow(**otk::display, _window); + } + changeState(); + } + + frame->adjustState(); } @@ -828,6 +956,9 @@ void Client::clientMessageHandler(const XClientMessageEvent &e) { otk::EventHandler::clientMessageHandler(e); + // validate cuz we query stuff off the client here + if (!validate()) return; + if (e.format != 32) return; if (e.message_type == otk::Property::atoms.wm_change_state) { @@ -882,6 +1013,8 @@ void Client::clientMessageHandler(const XClientMessageEvent &e) #ifdef DEBUG printf("net_active_window for 0x%lx\n", _window); #endif + if (_iconic) + setDesktop(openbox->screen(_screen)->desktop()); if (_shaded) shade(false); // XXX: deiconify @@ -911,7 +1044,8 @@ void Client::resize(Corner anchor, int w, int h) } -void Client::internal_resize(Corner anchor, int w, int h, int x, int y) +void Client::internal_resize(Corner anchor, int w, int h, bool user, + int x, int y) { w -= _base_size.x(); h -= _base_size.y(); @@ -921,14 +1055,21 @@ void Client::internal_resize(Corner anchor, int w, int h, int x, int y) w += _size_inc.x() / 2; h += _size_inc.y() / 2; - // is the window resizable? if it is not, then don't check its sizes, the - // client can do what it wants and the user can't change it anyhow - if (_min_size.x() <= _max_size.x() && _min_size.y() <= _max_size.y()) { + if (user) { + // if this is a user-requested resize, then check against min/max sizes + // and aspect ratios + // smaller than min size or bigger than max size? if (w < _min_size.x()) w = _min_size.x(); else if (w > _max_size.x()) w = _max_size.x(); if (h < _min_size.y()) h = _min_size.y(); else if (h > _max_size.y()) h = _max_size.y(); + + // adjust the height ot match the width for the aspect ratios + if (_min_ratio) + if (h * _min_ratio > w) h = static_cast(w / _min_ratio); + if (_max_ratio) + if (h * _max_ratio < w) h = static_cast(w / _max_ratio); } // keep to the increments @@ -1072,6 +1213,9 @@ void Client::changeState() otk::Property::atoms.atom, netstate, num); calcLayer(); + + if (frame) + frame->adjustState(); } @@ -1107,7 +1251,11 @@ void Client::changeAllowedActions(void) void Client::applyStartupState() { // these are in a carefully crafted order.. - + + if (_iconic) { + _iconic = false; + setDesktop(ICONIC_DESKTOP); + } if (_fullscreen) { _fullscreen = false; fullscreen(true); @@ -1116,6 +1264,8 @@ void Client::applyStartupState() _shaded = false; shade(true); } + if (_urgent) + fireUrgent(); if (_max_vert); // XXX: incomplete if (_max_horz); // XXX: incomplete @@ -1128,12 +1278,22 @@ void Client::applyStartupState() } +void Client::fireUrgent() +{ + // call the python UrgentWindow callbacks + EventData data(_screen, this, EventAction::UrgentWindow, 0); + openbox->bindings()->fireEvent(&data); +} + + void Client::shade(bool shade) { if (!(_functions & Func_Shade) || // can't _shaded == shade) return; // already done - _wmstate = shade ? IconicState : NormalState; + // when we're iconic, don't change the wmstate + if (!_iconic) + _wmstate = shade ? IconicState : NormalState; _shaded = shade; changeState(); frame->adjustSize(); @@ -1188,7 +1348,14 @@ void Client::fullscreen(bool fs) } -bool Client::focus() const +void Client::disableDecorations(DecorationFlags flags) +{ + _disabled_decorations = flags; + setupDecorAndFunctions(); +} + + +bool Client::focus() { // won't try focus if the client doesn't want it, or if the window isn't // visible on the screen @@ -1197,12 +1364,21 @@ bool Client::focus() const if (_focused) return true; // do a check to see if the window has already been unmapped or destroyed + // do this intelligently while watching out for unmaps we've generated + // (ignore_unmaps > 0) XEvent ev; - if (XCheckTypedWindowEvent(**otk::display, _window, UnmapNotify, &ev) || - XCheckTypedWindowEvent(**otk::display, _window, DestroyNotify, &ev)) { + if (XCheckTypedWindowEvent(**otk::display, _window, DestroyNotify, &ev)) { XPutBackEvent(**otk::display, &ev); return false; } + while (XCheckTypedWindowEvent(**otk::display, _window, UnmapNotify, &ev)) { + if (ignore_unmaps) { + unmapHandler(ev.xunmap); + } else { + XPutBackEvent(**otk::display, &ev); + return false; + } + } if (_can_focus) XSetInputFocus(**otk::display, _window, @@ -1223,6 +1399,7 @@ bool Client::focus() const XSendEvent(**otk::display, _window, False, NoEventMask, &ce); } + XSync(**otk::display, False); return true; } @@ -1275,7 +1452,8 @@ void Client::configureRequestHandler(const XConfigureRequestEvent &e) otk::EventHandler::configureRequestHandler(e); - // XXX: if we are iconic (or shaded? (fvwm does that)) ignore the event + // if we are iconic (or shaded (fvwm does this)) ignore the event + if (_iconic || _shaded) return; if (e.value_mask & CWBorderWidth) _border_width = e.border_width; @@ -1306,9 +1484,9 @@ void Client::configureRequestHandler(const XConfigureRequestEvent &e) if (e.value_mask & (CWX | CWY)) { int x = (e.value_mask & CWX) ? e.x : _area.x(); int y = (e.value_mask & CWY) ? e.y : _area.y(); - internal_resize(corner, w, h, x, y); + internal_resize(corner, w, h, false, x, y); } else // if JUST resizing... - internal_resize(corner, w, h); + internal_resize(corner, w, h, false); } else if (e.value_mask & (CWX | CWY)) { // if JUST moving... int x = (e.value_mask & CWX) ? e.x : _area.x(); int y = (e.value_mask & CWY) ? e.y : _area.y(); @@ -1336,7 +1514,7 @@ void Client::unmapHandler(const XUnmapEvent &e) { if (ignore_unmaps) { #ifdef DEBUG - printf("Ignored UnmapNotify for 0x%lx (event 0x%lx)\n", e.window, e.event); +// printf("Ignored UnmapNotify for 0x%lx (event 0x%lx)\n", e.window, e.event); #endif // DEBUG ignore_unmaps--; return; @@ -1394,4 +1572,17 @@ void Client::reparentHandler(const XReparentEvent &e) openbox->screen(_screen)->unmanageWindow(this); } +void Client::mapRequestHandler(const XMapRequestEvent &e) +{ +#ifdef DEBUG + printf("MapRequest for already managed 0x%lx\n", e.window); +#endif // DEBUG + + assert(_iconic); // we shouldn't be able to get this unless we're iconic + + // move to the current desktop (uniconify) + setDesktop(openbox->screen(_screen)->desktop()); + // XXX: should we focus/raise the window? (basically a net_wm_active_window) +} + }