#endif
#include "client.hh"
+#include "frame.hh"
#include "screen.hh"
+#include "bbscreen.hh"
#include "openbox.hh"
#include "otk/display.hh"
#include "otk/property.hh"
namespace ob {
OBClient::OBClient(int screen, Window window)
- : _screen(screen), _window(window)
+ : otk::OtkEventHandler(),
+ OBWidget(OBWidget::Type_Client),
+ frame(0), _screen(screen), _window(window)
{
+ assert(screen >= 0);
assert(window);
+ ignore_unmaps = 0;
+
// update EVERYTHING the first time!!
// the state is kinda assumed to be normal. is this right? XXX
void OBClient::getArea()
{
XWindowAttributes wattrib;
- assert(XGetWindowAttributes(otk::OBDisplay::display, _window, &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;
if (otk::OBDisplay::shape()) {
int foo;
unsigned int ufoo;
+ int s;
+
+ XShapeSelectInput(otk::OBDisplay::display, _window, ShapeNotifyMask);
- XShapeQueryExtents(otk::OBDisplay::display, client.window, &_shaped, &foo,
+ XShapeQueryExtents(otk::OBDisplay::display, _window, &s, &foo,
&foo, &ufoo, &ufoo, &foo, &foo, &foo, &ufoo, &ufoo);
+ _shaped = (s != 0);
}
#endif // SHAPE
}
{
XSizeHints size;
long ret;
+ int oldgravity = _gravity;
// defaults
_gravity = NorthWestGravity;
- _inc_x = _inc_y = 1;
- _base_x = _base_y = 0;
- _min_x = _min_y = 0;
- _max_x = _max_y = INT_MAX;
+ _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..
if (size.flags & PWinGravity)
_gravity = size.win_gravity;
+
+ if (size.flags & PMinSize)
+ _min_size.setPoint(size.min_width, size.min_height);
- if (size.flags & PMinSize) {
- _min_x = size.min_width;
- _min_y = size.min_height;
- }
+ if (size.flags & PMaxSize)
+ _max_size.setPoint(size.max_width, size.max_height);
- if (size.flags & PMaxSize) {
- _max_x = size.max_width;
- _max_y = size.max_height;
- }
+ if (size.flags & PBaseSize)
+ _base_size.setPoint(size.base_width, size.base_height);
- 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 & PResizeInc)
+ _size_inc.setPoint(size.width_inc, size.height_inc);
+ }
+
+ // if the client has a frame, i.e. has already been mapped and is
+ // changing its gravity
+ if (frame && _gravity != oldgravity) {
+ // move our idea of the client's position based on its new gravity
+ int x, y;
+ frame->frameGravity(x, y);
+ _area.setPos(x, y);
}
}
}
-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)
}
-void OBClient::update(const XClientMessageEvent &e)
+void OBClient::toggleClientBorder(bool addborder)
{
+ // adjust our idea of where the client is, based on its border. When the
+ // border is removed, the client should now be considered to be in a
+ // different position.
+ // when re-adding the border to the client, the same operation needs to be
+ // reversed.
+ int x = _area.x(), y = _area.y();
+ switch(_gravity) {
+ case NorthWestGravity:
+ case WestGravity:
+ case SouthWestGravity:
+ break;
+ case NorthEastGravity:
+ case EastGravity:
+ case SouthEastGravity:
+ if (addborder) x -= _border_width * 2;
+ else x += _border_width * 2;
+ break;
+ }
+ switch(_gravity) {
+ case NorthWestGravity:
+ case NorthGravity:
+ case NorthEastGravity:
+ break;
+ case SouthWestGravity:
+ case SouthGravity:
+ case SouthEastGravity:
+ if (addborder) y -= _border_width * 2;
+ else y += _border_width * 2;
+ break;
+ default:
+ // no change for StaticGravity etc.
+ break;
+ }
+ _area.setPos(x, y);
+
+ if (addborder) {
+ XSetWindowBorderWidth(otk::OBDisplay::display, _window, _border_width);
+
+ // move the client so it is back it the right spot _with_ its border!
+ XMoveWindow(otk::OBDisplay::display, _window, x, y);
+ } else
+ XSetWindowBorderWidth(otk::OBDisplay::display, _window, 0);
+}
+
+
+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]);
}
-void OBClient::setArea(const otk::Rect &area)
+#if defined(SHAPE) || defined(DOXYGEN_IGNORE)
+void OBClient::shapeHandler(const XShapeEvent &e)
{
- _area = area;
+ 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();
+
+ // for interactive resizing. have to move half an increment in each
+ // direction.
+ 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()) {
+ // 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();
+
+ int x = _area.x(), y = _area.y();
+ switch (anchor) {
+ case TopLeft:
+ break;
+ case TopRight:
+ x -= w - _area.width();
+ break;
+ case BottomLeft:
+ y -= h - _area.height();
+ break;
+ case BottomRight:
+ x -= w - _area.width();
+ y -= h - _area.height();
+ break;
+ }
+
+ _area.setSize(w, h);
+ XResizeWindow(otk::OBDisplay::display, _window, w, h);
+
+ // resize the frame to match the request
+ frame->adjustSize();
+ move(x, y);
+}
+
+
+void OBClient::move(int x, int y)
+{
+ _area.setPos(x, y);
+ // move the frame to be in the requested position
+ frame->adjustPosition();
+}
+
+
+void OBClient::configureRequestHandler(const XConfigureRequestEvent &e)
+{
+ OtkEventHandler::configureRequestHandler(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;
+ }
+ }
+}
+
+
+void OBClient::unmapHandler(const XUnmapEvent &e)
+{
+#ifdef DEBUG
+ printf("UnmapNotify for 0x%lx\n", e.window);
+#endif // DEBUG
+
+ if (ignore_unmaps) {
+ ignore_unmaps--;
+ return;
+ }
+
+ OtkEventHandler::unmapHandler(e);
+
+ // this deletes us etc
+ Openbox::instance->screen(_screen)->unmanageWindow(this);
+}
+
+
+void OBClient::destroyHandler(const XDestroyWindowEvent &e)
+{
+#ifdef DEBUG
+ printf("DestroyNotify for 0x%lx\n", e.window);
+#endif // DEBUG
+
+ OtkEventHandler::destroyHandler(e);
+
+ // this deletes us etc
+ Openbox::instance->screen(_screen)->unmanageWindow(this);
+}
+
}