// -*- mode: C++; indent-tabs-mode: nil; c-basic-offset: 2; -*-
+#ifdef HAVE_CONFIG_H
+# include "../config.h"
+#endif
+
#include "client.hh"
-#include "screen.hh"
+#include "frame.hh"
+#include "bbscreen.hh"
#include "openbox.hh"
#include "otk/display.hh"
#include "otk/property.hh"
namespace ob {
-OBClient::OBClient(Window window)
- : _window(window)
+OBClient::OBClient(int screen, Window window)
+ : otk::OtkEventHandler(),
+ _screen(screen), _window(window)
{
+ assert(screen >= 0);
assert(window);
- // initialize vars to false/invalid values
- _group = 0;
- _gravity = _base_x = _base_y = _inc_x = _inc_y = _max_x = _max_y = _min_x =
- _min_y = -1;
- _state = -1;
- _type = Type_Normal;
- _desktop = 0xffffffff - 1;
- _can_focus = _urgent = _focus_notify = _shaped = _modal = _shaded =
- _max_horz = _max_vert = _fullscreen = _floating = false;
-
+ Openbox::instance->registerHandler(_window, this);
+
+ ignore_unmaps = 0;
// update EVERYTHING the first time!!
+
+ // the state is kinda assumed to be normal. is this right? XXX
+ _wmstate = NormalState;
+ // no default decors or functions, each has to be enabled
+ _decorations = _functions = 0;
+
+ getArea();
+ getDesktop();
+ getType();
+
+ // set the decorations and functions
+ switch (_type) {
+ case Type_Normal:
+ // normal windows retain all of the possible decorations and
+ // functionality
+ _decorations = Decor_Titlebar | Decor_Handle | Decor_Border |
+ Decor_Iconify | Decor_Maximize;
+ _functions = Func_Resize | Func_Move | Func_Iconify | Func_Maximize;
+
+ case Type_Dialog:
+ // dialogs cannot be maximized
+ _decorations &= ~Decor_Maximize;
+ _functions &= ~Func_Maximize;
+ break;
+
+ case Type_Menu:
+ case Type_Toolbar:
+ case Type_Utility:
+ // these windows get less functionality
+ _decorations &= ~(Decor_Iconify | Decor_Handle);
+ _functions &= ~(Func_Iconify | Func_Resize);
+ break;
+
+ case Type_Desktop:
+ case Type_Dock:
+ case Type_Splash:
+ // none of these windows are manipulated by the window manager
+ _decorations = 0;
+ _functions = 0;
+ break;
+ }
+
+ getMwmHints(); // this fucks (in good ways) with the decors and functions
+ getState();
+ getShaped();
+
+ updateProtocols();
+ updateNormalHints();
+ updateWMHints();
+ // XXX: updateTransientFor();
+ updateTitle();
+ updateIconTitle();
+ updateClass();
+
+/*
+#ifdef DEBUG
+ printf("Mapped window: 0x%lx\n"
+ " title: \t%s\t icon title: \t%s\n"
+ " app name: \t%s\t\t class: \t%s\n"
+ " position: \t%d, %d\t\t size: \t%d, %d\n"
+ " desktop: \t%lu\t\t group: \t0x%lx\n"
+ " type: \t%d\t\t min size \t%d, %d\n"
+ " base size \t%d, %d\t\t max size \t%d, %d\n"
+ " size incr \t%d, %d\t\t gravity \t%d\n"
+ " wm state \t%ld\t\t can be focused:\t%s\n"
+ " notify focus: \t%s\t\t urgent: \t%s\n"
+ " shaped: \t%s\t\t modal: \t%s\n"
+ " shaded: \t%s\t\t iconic: \t%s\n"
+ " vert maximized:\t%s\t\t horz maximized:\t%s\n"
+ " fullscreen: \t%s\t\t floating: \t%s\n"
+ " requested pos: \t%s\n",
+ _window,
+ _title.c_str(),
+ _icon_title.c_str(),
+ _app_name.c_str(),
+ _app_class.c_str(),
+ _area.x(), _area.y(),
+ _area.width(), _area.height(),
+ _desktop,
+ _group,
+ _type,
+ _min_x, _min_y,
+ _base_x, _base_y,
+ _max_x, _max_y,
+ _inc_x, _inc_y,
+ _gravity,
+ _wmstate,
+ _can_focus ? "yes" : "no",
+ _focus_notify ? "yes" : "no",
+ _urgent ? "yes" : "no",
+ _shaped ? "yes" : "no",
+ _modal ? "yes" : "no",
+ _shaded ? "yes" : "no",
+ _iconic ? "yes" : "no",
+ _max_vert ? "yes" : "no",
+ _max_horz ? "yes" : "no",
+ _fullscreen ? "yes" : "no",
+ _floating ? "yes" : "no",
+ _positioned ? "yes" : "no");
+#endif
+*/
}
+
OBClient::~OBClient()
{
+ const otk::OBProperty *property = Openbox::instance->property();
+
+ // these values should not be persisted across a window unmapping/mapping
+ property->erase(_window, otk::OBProperty::net_wm_desktop);
+ property->erase(_window, otk::OBProperty::net_wm_state);
+}
+
+
+void OBClient::getDesktop()
+{
+ const otk::OBProperty *property = Openbox::instance->property();
+
+ // defaults to the current desktop
+ _desktop = 0; // XXX: change this to the current desktop!
+
+ property->get(_window, otk::OBProperty::net_wm_desktop,
+ otk::OBProperty::Atom_Cardinal,
+ &_desktop);
+}
+
+
+void OBClient::getType()
+{
+ const otk::OBProperty *property = Openbox::instance->property();
+
+ _type = (WindowType) -1;
+
+ unsigned long *val;
+ unsigned long num = (unsigned) -1;
+ if (property->get(_window, otk::OBProperty::net_wm_window_type,
+ otk::OBProperty::Atom_Atom,
+ &num, &val)) {
+ // use the first value that we know about in the array
+ for (unsigned long i = 0; i < num; ++i) {
+ if (val[i] ==
+ property->atom(otk::OBProperty::net_wm_window_type_desktop))
+ _type = Type_Desktop;
+ else if (val[i] ==
+ property->atom(otk::OBProperty::net_wm_window_type_dock))
+ _type = Type_Dock;
+ else if (val[i] ==
+ property->atom(otk::OBProperty::net_wm_window_type_toolbar))
+ _type = Type_Toolbar;
+ else if (val[i] ==
+ property->atom(otk::OBProperty::net_wm_window_type_menu))
+ _type = Type_Menu;
+ else if (val[i] ==
+ property->atom(otk::OBProperty::net_wm_window_type_utility))
+ _type = Type_Utility;
+ else if (val[i] ==
+ property->atom(otk::OBProperty::net_wm_window_type_splash))
+ _type = Type_Splash;
+ else if (val[i] ==
+ property->atom(otk::OBProperty::net_wm_window_type_dialog))
+ _type = Type_Dialog;
+ else if (val[i] ==
+ property->atom(otk::OBProperty::net_wm_window_type_normal))
+ _type = Type_Normal;
+// else if (val[i] ==
+// property->atom(otk::OBProperty::kde_net_wm_window_type_override))
+// mwm_decorations = 0; // prevent this window from getting any decor
+ // XXX: make this work again
+ }
+ delete val;
+ }
+
+ if (_type == (WindowType) -1) {
+ /*
+ * the window type hint was not set, which means we either classify ourself
+ * as a normal window or a dialog, depending on if we are a transient.
+ */
+ // XXX: make this code work!
+ //if (isTransient())
+ // _type = Type_Dialog;
+ //else
+ _type = Type_Normal;
+ }
+}
+
+
+void OBClient::getMwmHints()
+{
+ const otk::OBProperty *property = Openbox::instance->property();
+
+ unsigned long num;
+ MwmHints *hints;
+
+ num = MwmHints::elements;
+ if (!property->get(_window, otk::OBProperty::motif_wm_hints,
+ otk::OBProperty::motif_wm_hints, &num,
+ (unsigned long **)&hints))
+ return;
+
+ if (num < MwmHints::elements) {
+ delete [] hints;
+ return;
+ }
+
+ // retrieved the hints
+ // Mwm Hints are applied subtractively to what has already been chosen for
+ // decor and functionality
+
+ if (hints->flags & MwmFlag_Decorations) {
+ if (! (hints->decorations & MwmDecor_All)) {
+ if (! (hints->decorations & MwmDecor_Border))
+ _decorations &= ~Decor_Border;
+ if (! (hints->decorations & MwmDecor_Handle))
+ _decorations &= ~Decor_Handle;
+ if (! (hints->decorations & MwmDecor_Title))
+ _decorations &= ~Decor_Titlebar;
+ if (! (hints->decorations & MwmDecor_Iconify))
+ _decorations &= ~Decor_Iconify;
+ if (! (hints->decorations & MwmDecor_Maximize))
+ _decorations &= ~Decor_Maximize;
+ }
+ }
+
+ if (hints->flags & MwmFlag_Functions) {
+ if (! (hints->functions & MwmFunc_All)) {
+ if (! (hints->functions & MwmFunc_Resize))
+ _functions &= ~Func_Resize;
+ if (! (hints->functions & MwmFunc_Move))
+ _functions &= ~Func_Move;
+ if (! (hints->functions & MwmFunc_Iconify))
+ _functions &= ~Func_Iconify;
+ if (! (hints->functions & MwmFunc_Maximize))
+ _functions &= ~Func_Maximize;
+ //if (! (hints->functions & MwmFunc_Close))
+ // _functions &= ~Func_Close;
+ }
+ }
+ delete [] hints;
+}
+
+
+void OBClient::getArea()
+{
+ XWindowAttributes wattrib;
+ Status ret;
+
+ ret = XGetWindowAttributes(otk::OBDisplay::display, _window, &wattrib);
+ assert(ret != BadWindow);
+
+ _area.setRect(wattrib.x, wattrib.y, wattrib.width, wattrib.height);
+ _border_width = wattrib.border_width;
+}
+
+
+void OBClient::getState()
+{
+ const otk::OBProperty *property = Openbox::instance->property();
+
+ _modal = _shaded = _max_horz = _max_vert = _fullscreen = _floating = false;
+
+ unsigned long *state;
+ unsigned long num = (unsigned) -1;
+
+ if (property->get(_window, otk::OBProperty::net_wm_state,
+ otk::OBProperty::Atom_Atom, &num, &state)) {
+ for (unsigned long i = 0; i < num; ++i) {
+ if (state[i] == property->atom(otk::OBProperty::net_wm_state_modal))
+ _modal = true;
+ else if (state[i] ==
+ property->atom(otk::OBProperty::net_wm_state_shaded))
+ _shaded = true;
+ else if (state[i] ==
+ property->atom(otk::OBProperty::net_wm_state_fullscreen))
+ _fullscreen = true;
+ else if (state[i] ==
+ property->atom(otk::OBProperty::net_wm_state_maximized_vert))
+ _max_vert = true;
+ else if (state[i] ==
+ property->atom(otk::OBProperty::net_wm_state_maximized_horz))
+ _max_horz = true;
+ }
+
+ delete [] state;
+ }
+}
+
+
+void OBClient::getShaped()
+{
+ _shaped = false;
+#ifdef SHAPE
+ if (otk::OBDisplay::shape()) {
+ int foo;
+ unsigned int ufoo;
+ int s;
+
+ XShapeSelectInput(otk::OBDisplay::display, _window, ShapeNotifyMask);
+
+ XShapeQueryExtents(otk::OBDisplay::display, _window, &s, &foo,
+ &foo, &ufoo, &ufoo, &foo, &foo, &foo, &ufoo, &ufoo);
+ _shaped = (s != 0);
+ }
+#endif // SHAPE
+}
+
+
+void OBClient::updateProtocols()
+{
+ const otk::OBProperty *property = Openbox::instance->property();
+
+ Atom *proto;
+ int num_return = 0;
+
+ _focus_notify = false;
+ _decorations &= ~Decor_Close;
+ _functions &= ~Func_Close;
+
+ if (XGetWMProtocols(otk::OBDisplay::display, _window, &proto, &num_return)) {
+ for (int i = 0; i < num_return; ++i) {
+ if (proto[i] == property->atom(otk::OBProperty::wm_delete_window)) {
+ _decorations |= Decor_Close;
+ _functions |= Func_Close;
+ // XXX: update the decor?
+ } else if (proto[i] == property->atom(otk::OBProperty::wm_take_focus))
+ // if this protocol is requested, then the window will be notified
+ // by the window manager whenever it receives focus
+ _focus_notify = true;
+ }
+ XFree(proto);
+ }
}
// defaults
_gravity = NorthWestGravity;
- _inc_x = _inc_y = 1;
- _base_x = _base_y = 0;
+ _size_inc.setPoint(1, 1);
+ _base_size.setPoint(0, 0);
+ _min_size.setPoint(0, 0);
+ _max_size.setPoint(INT_MAX, INT_MAX);
+
+ // XXX: might want to cancel any interactive resizing of the window at this
+ // point..
// get the hints from the window
if (XGetWMNormalHints(otk::OBDisplay::display, _window, &size, &ret)) {
+ _positioned = (size.flags & (PPosition|USPosition));
+
if (size.flags & PWinGravity)
_gravity = size.win_gravity;
- if (size.flags & PBaseSize) {
- _base_x = size.base_width;
- _base_y = size.base_height;
- }
- if (size.flags & PResizeInc) {
- _inc_x = size.width_inc;
- _inc_y = size.height_inc;
- }
+
+ if (size.flags & PMinSize)
+ _min_size.setPoint(size.min_width, size.min_height);
+
+ if (size.flags & PMaxSize)
+ _max_size.setPoint(size.max_width, size.max_height);
+
+ if (size.flags & PBaseSize)
+ _base_size.setPoint(size.base_width, size.base_height);
+
+ if (size.flags & PResizeInc)
+ _size_inc.setPoint(size.width_inc, size.height_inc);
}
}
if ((hints = XGetWMHints(otk::OBDisplay::display, _window)) != NULL) {
if (hints->flags & InputHint)
_can_focus = hints->input;
+
if (hints->flags & XUrgencyHint)
_urgent = true;
- if (hints->flags & WindowGroupHint)
+
+ if (hints->flags & WindowGroupHint) {
if (hints->window_group != _group) {
// XXX: remove from the old group if there was one
_group = hints->window_group;
// XXX: do stuff with the group
}
+ } else // no group!
+ _group = None;
+
XFree(hints);
}
}
}
+void OBClient::updateIconTitle()
+{
+ const otk::OBProperty *property = Openbox::instance->property();
+
+ _icon_title = "";
+
+ // try netwm
+ if (! property->get(_window, otk::OBProperty::net_wm_icon_name,
+ otk::OBProperty::utf8, &_icon_title)) {
+ // try old x stuff
+ property->get(_window, otk::OBProperty::wm_icon_name,
+ otk::OBProperty::ascii, &_icon_title);
+ }
+
+ if (_title.empty())
+ _icon_title = _("Unnamed Window");
+}
+
+
void OBClient::updateClass()
{
const otk::OBProperty *property = Openbox::instance->property();
}
-void OBClient::update(const XPropertyEvent &e)
+void OBClient::propertyHandler(const XPropertyEvent &e)
{
+ otk::OtkEventHandler::propertyHandler(e);
+
const otk::OBProperty *property = Openbox::instance->property();
+ // compress changes to a single property into a single change
+ XEvent ce;
+ while (XCheckTypedEvent(otk::OBDisplay::display, e.type, &ce)) {
+ // XXX: it would be nice to compress ALL changes to a property, not just
+ // changes in a row without other props between.
+ if (ce.xproperty.atom != e.atom) {
+ XPutBackEvent(otk::OBDisplay::display, &ce);
+ break;
+ }
+ }
+
if (e.atom == XA_WM_NORMAL_HINTS)
updateNormalHints();
else if (e.atom == XA_WM_HINTS)
updateWMHints();
else if (e.atom == property->atom(otk::OBProperty::net_wm_name) ||
- e.atom == property->atom(otk::OBProperty::wm_name) ||
- e.atom == property->atom(otk::OBProperty::net_wm_icon_name) ||
- e.atom == property->atom(otk::OBProperty::wm_icon_name))
+ e.atom == property->atom(otk::OBProperty::wm_name))
updateTitle();
+ else if (e.atom == property->atom(otk::OBProperty::net_wm_icon_name) ||
+ e.atom == property->atom(otk::OBProperty::wm_icon_name))
+ updateIconTitle();
else if (e.atom == property->atom(otk::OBProperty::wm_class))
updateClass();
+ else if (e.atom == property->atom(otk::OBProperty::wm_protocols))
+ updateProtocols();
+ // XXX: transient for hint
+ // XXX: strut hint
}
void OBClient::setWMState(long state)
{
- if (state == _state) return; // no change
+ if (state == _wmstate) return; // no change
switch (state) {
case IconicState:
// XXX: cause it to uniconify
break;
}
- _state = state;
+ _wmstate = state;
}
}
-void OBClient::update(const XClientMessageEvent &e)
+void OBClient::clientMessageHandler(const XClientMessageEvent &e)
{
+ otk::OtkEventHandler::clientMessageHandler(e);
+
if (e.format != 32) return;
const otk::OBProperty *property = Openbox::instance->property();
- if (e.message_type == property->atom(otk::OBProperty::wm_change_state))
- setWMState(e.data.l[0]);
- else if (e.message_type ==
- property->atom(otk::OBProperty::net_wm_desktop))
- setDesktop(e.data.l[0]);
+ if (e.message_type == property->atom(otk::OBProperty::wm_change_state)) {
+ // compress changes into a single change
+ bool compress = false;
+ XEvent ce;
+ while (XCheckTypedEvent(otk::OBDisplay::display, e.type, &ce)) {
+ // XXX: it would be nice to compress ALL messages of a type, not just
+ // messages in a row without other message types between.
+ if (ce.xclient.message_type != e.message_type) {
+ XPutBackEvent(otk::OBDisplay::display, &ce);
+ break;
+ }
+ compress = true;
+ }
+ if (compress)
+ setWMState(ce.xclient.data.l[0]); // use the found event
+ else
+ setWMState(e.data.l[0]); // use the original event
+ } else if (e.message_type ==
+ property->atom(otk::OBProperty::net_wm_desktop)) {
+ // compress changes into a single change
+ bool compress = false;
+ XEvent ce;
+ while (XCheckTypedEvent(otk::OBDisplay::display, e.type, &ce)) {
+ // XXX: it would be nice to compress ALL messages of a type, not just
+ // messages in a row without other message types between.
+ if (ce.xclient.message_type != e.message_type) {
+ XPutBackEvent(otk::OBDisplay::display, &ce);
+ break;
+ }
+ compress = true;
+ }
+ if (compress)
+ setDesktop(e.data.l[0]); // use the found event
+ else
+ setDesktop(e.data.l[0]); // use the original event
+ }
else if (e.message_type == property->atom(otk::OBProperty::net_wm_state))
+ // can't compress these
setState((StateAction)e.data.l[0], e.data.l[1], e.data.l[2]);
}
+
+#if defined(SHAPE) || defined(DOXYGEN_IGNORE)
+void OBClient::shapeHandler(const XShapeEvent &e)
+{
+ otk::OtkEventHandler::shapeHandler(e);
+
+ _shaped = e.shaped;
+}
+#endif
+
+
+void OBClient::resize(Corner anchor, int w, int h)
+{
+ w -= _base_size.x();
+ h -= _base_size.y();
+
+ // 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()) {
+ // 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();
+ }
+
+ // keep to the increments
+ w /= _size_inc.x();
+ h /= _size_inc.y();
+
+ // store the logical size
+ _logical_size.setPoint(w, h);
+
+ w *= _size_inc.x();
+ h *= _size_inc.y();
+
+ w += _base_size.x();
+ h += _base_size.y();
+
+ switch (anchor) {
+ case TopLeft:
+ break;
+ case TopRight:
+ _area.setX(_area.x() - _area.width() - w);
+ break;
+ case BottomLeft:
+ _area.setY(_area.y() - _area.height() - h);
+ break;
+ case BottomRight:
+ _area.setX(_area.x() - _area.width() - w);
+ _area.setY(_area.y() - _area.height() - h);
+ break;
+ }
+
+ _area.setSize(w, h);
+
+ // resize the frame to match
+ frame->adjust();
+}
+
+
+void OBClient::move(int x, int y)
+{
+ _area.setPos(x, y);
+ // move the frame to be in the requested position
+ frame->applyGravity();
+}
+
+
+void OBClient::configureRequestHandler(const XConfigureRequestEvent &e)
+{
+ // XXX: if we are iconic (or shaded? (fvwm does that)) ignore the event
+
+ if (e.value_mask & CWBorderWidth)
+ _border_width = e.border_width;
+
+ // resize, then move, as specified in the EWMH section 7.7
+ if (e.value_mask & (CWWidth | CWHeight)) {
+ int w = (e.value_mask & CWWidth) ? e.width : _area.width();
+ int h = (e.value_mask & CWHeight) ? e.height : _area.height();
+
+ Corner corner;
+ switch (_gravity) {
+ case NorthEastGravity:
+ case EastGravity:
+ corner = TopRight;
+ break;
+ case SouthWestGravity:
+ case SouthGravity:
+ corner = BottomLeft;
+ break;
+ case SouthEastGravity:
+ corner = BottomRight;
+ break;
+ default: // NorthWest, Static, etc
+ corner = TopLeft;
+ }
+
+ resize(corner, w, h);
+ }
+
+ 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();
+ move(x, y);
+ }
+
+ if (e.value_mask & CWStackMode) {
+ switch (e.detail) {
+ case Below:
+ case BottomIf:
+ // XXX: lower the window
+ break;
+
+ case Above:
+ case TopIf:
+ default:
+ // XXX: raise the window
+ break;
+ }
+ }
+}
+
+
}