+ } else if (e.message_type == otk::Property::atoms.net_close_window) {
+#ifdef DEBUG
+ printf("net_close_window for 0x%lx\n", _window);
+#endif
+ close();
+ } else if (e.message_type == otk::Property::atoms.net_active_window) {
+#ifdef DEBUG
+ printf("net_active_window for 0x%lx\n", _window);
+#endif
+ if (openbox->screen(_screen)->showingDesktop())
+ openbox->screen(_screen)->showDesktop(false);
+ if (_iconic)
+ iconify(false);
+ else if (!frame->visible()) // if its not visible for other reasons, then
+ return; // don't mess with it
+ if (_shaded)
+ shade(false);
+ focus();
+ openbox->screen(_screen)->raiseWindow(this);
+ } else if (e.message_type == otk::Property::atoms.openbox_active_window) {
+ if (openbox->screen(_screen)->showingDesktop())
+ openbox->screen(_screen)->showDesktop(false);
+ if (_iconic)
+ iconify(false);
+ else if (!frame->visible()) // if its not visible for other reasons, then
+ return; // don't mess with it
+ if (e.data.l[0] && _shaded)
+ shade(false);
+ focus();
+ if (e.data.l[1])
+ openbox->screen(_screen)->raiseWindow(this);
+ }
+}
+
+#if defined(SHAPE)
+void Client::shapeHandler(const XShapeEvent &e)
+{
+ otk::EventHandler::shapeHandler(e);
+
+ if (e.kind == ShapeBounding) {
+ _shaped = e.shaped;
+ frame->adjustShape();
+ }
+}
+#endif
+
+void Client::resize(Corner anchor, int w, int h)
+{
+ if (!(_functions & Func_Resize)) return;
+ internal_resize(anchor, w, h);
+}
+
+void Client::internal_resize(Corner anchor, int w, int h,
+ bool user, int x, int y)
+{
+ w -= _base_size.width();
+ h -= _base_size.height();
+
+ if (user) {
+ // for interactive resizing. have to move half an increment in each
+ // direction.
+ int mw = w % _size_inc.width(); // how far we are towards the next size inc
+ int mh = h % _size_inc.height();
+ int aw = _size_inc.width() / 2; // amount to add
+ int ah = _size_inc.height() / 2;
+ // don't let us move into a new size increment
+ if (mw + aw >= _size_inc.width()) aw = _size_inc.width() - mw - 1;
+ if (mh + ah >= _size_inc.height()) ah = _size_inc.height() - mh - 1;
+ w += aw;
+ h += ah;
+
+ // 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 > _max_size.width()) w = _max_size.width();
+ if (w < _min_size.width()) w = _min_size.width();
+ if (h > _max_size.height()) h = _max_size.height();
+ if (h < _min_size.height()) h = _min_size.height();
+
+ // adjust the height ot match the width for the aspect ratios
+ if (_min_ratio)
+ if (h * _min_ratio > w) h = static_cast<int>(w / _min_ratio);
+ if (_max_ratio)
+ if (h * _max_ratio < w) h = static_cast<int>(w / _max_ratio);
+ }
+
+ // keep to the increments
+ w /= _size_inc.width();
+ h /= _size_inc.height();
+
+ // you cannot resize to nothing
+ if (w < 1) w = 1;
+ if (h < 1) h = 1;
+
+ // store the logical size
+ _logical_size = otk::Size(w, h);
+
+ w *= _size_inc.width();
+ h *= _size_inc.height();
+
+ w += _base_size.width();
+ h += _base_size.height();
+
+ if (x == INT_MIN || y == INT_MIN) {
+ 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 = otk::Rect(_area.position(), otk::Size(w, h));
+
+ XResizeWindow(**otk::display, _window, w, h);
+
+ // resize the frame to match the request
+ frame->adjustSize();
+ internal_move(x, y);
+}
+
+const Icon *Client::icon(const otk::Size &s) const
+{
+ unsigned long req = s.width() * s.height();
+ // si is the smallest image >= req
+ // li is the largest image < req
+ unsigned long smallest = 0xffffffff, largest = 0, si = 0, li = 0;
+
+ assert(_nicons > 0); // there should always be a default..
+ for (int i = 0; i < _nicons; ++i) {
+ unsigned long size = _icons[i].w * _icons[i].h;
+ if (size < smallest && size >= req) {
+ smallest = size;
+ si = i;
+ }
+ if (size > largest && size <= req) {
+ largest = size;
+ li = i;
+ }
+ }
+ if (largest == 0) // didnt find one smaller than the requested size
+ return &_icons[si];
+ return &_icons[li];
+}
+
+void Client::move(int x, int y)
+{
+ if (!(_functions & Func_Move)) return;
+ frame->frameGravity(x, y); // get the client's position based on x,y for the
+ // frame
+ internal_move(x, y);
+}
+
+void Client::internal_move(int x, int y)
+{
+ _area = otk::Rect(otk::Point(x, y), _area.size());
+
+ // move the frame to be in the requested position
+ if (frame) { // this can be called while mapping, before frame exists
+ frame->adjustPosition();
+
+ // send synthetic configure notify (we don't need to if we aren't mapped
+ // yet)
+ XEvent event;
+ event.type = ConfigureNotify;
+ event.xconfigure.display = **otk::display;
+ event.xconfigure.event = _window;
+ event.xconfigure.window = _window;
+
+ // root window coords with border in mind
+ event.xconfigure.x = x - _border_width + frame->size().left;
+ event.xconfigure.y = y - _border_width + frame->size().top;
+
+ event.xconfigure.width = _area.width();
+ event.xconfigure.height = _area.height();
+ event.xconfigure.border_width = _border_width;
+ event.xconfigure.above = frame->plate();
+ event.xconfigure.override_redirect = False;
+ XSendEvent(event.xconfigure.display, event.xconfigure.window, False,
+ StructureNotifyMask, &event);
+#if 0//def DEBUG
+ printf("Sent synthetic ConfigureNotify %d,%d %d,%d to 0x%lx\n",
+ event.xconfigure.x, event.xconfigure.y, event.xconfigure.width,
+ event.xconfigure.height, event.xconfigure.window);
+#endif
+ }
+}
+
+void Client::close()
+{
+ XEvent ce;
+
+ if (!(_functions & Func_Close)) return;
+
+ // XXX: itd be cool to do timeouts and shit here for killing the client's
+ // process off
+ // like... if the window is around after 5 seconds, then the close button
+ // turns a nice red, and if this function is called again, the client is
+ // explicitly killed.
+
+ ce.xclient.type = ClientMessage;
+ ce.xclient.message_type = otk::Property::atoms.wm_protocols;
+ ce.xclient.display = **otk::display;
+ ce.xclient.window = _window;
+ ce.xclient.format = 32;
+ ce.xclient.data.l[0] = otk::Property::atoms.wm_delete_window;
+ ce.xclient.data.l[1] = CurrentTime;
+ ce.xclient.data.l[2] = 0l;
+ ce.xclient.data.l[3] = 0l;
+ ce.xclient.data.l[4] = 0l;
+ XSendEvent(**otk::display, _window, false, NoEventMask, &ce);
+}
+
+void Client::changeState()
+{
+ unsigned long state[2];
+ state[0] = _wmstate;
+ state[1] = None;
+ otk::Property::set(_window, otk::Property::atoms.wm_state,
+ otk::Property::atoms.wm_state, state, 2);
+
+ Atom netstate[10];
+ int num = 0;
+ if (_modal)
+ netstate[num++] = otk::Property::atoms.net_wm_state_modal;
+ if (_shaded)
+ netstate[num++] = otk::Property::atoms.net_wm_state_shaded;
+ if (_iconic)
+ netstate[num++] = otk::Property::atoms.net_wm_state_hidden;
+ if (_skip_taskbar)
+ netstate[num++] = otk::Property::atoms.net_wm_state_skip_taskbar;
+ if (_skip_pager)
+ netstate[num++] = otk::Property::atoms.net_wm_state_skip_pager;
+ if (_fullscreen)
+ netstate[num++] = otk::Property::atoms.net_wm_state_fullscreen;
+ if (_max_vert)
+ netstate[num++] = otk::Property::atoms.net_wm_state_maximized_vert;
+ if (_max_horz)
+ netstate[num++] = otk::Property::atoms.net_wm_state_maximized_horz;
+ if (_above)
+ netstate[num++] = otk::Property::atoms.net_wm_state_above;
+ if (_below)
+ netstate[num++] = otk::Property::atoms.net_wm_state_below;
+ otk::Property::set(_window, otk::Property::atoms.net_wm_state,
+ otk::Property::atoms.atom, netstate, num);
+
+ calcLayer();
+
+ if (frame)
+ frame->adjustState();
+}
+
+void Client::changeAllowedActions(void)
+{
+ Atom actions[9];
+ int num = 0;
+
+ actions[num++] = otk::Property::atoms.net_wm_action_change_desktop;
+
+ if (_functions & Func_Shade)
+ actions[num++] = otk::Property::atoms.net_wm_action_shade;
+ if (_functions & Func_Close)
+ actions[num++] = otk::Property::atoms.net_wm_action_close;
+ if (_functions & Func_Move)
+ actions[num++] = otk::Property::atoms.net_wm_action_move;
+ if (_functions & Func_Iconify)
+ actions[num++] = otk::Property::atoms.net_wm_action_minimize;
+ if (_functions & Func_Resize)
+ actions[num++] = otk::Property::atoms.net_wm_action_resize;
+ if (_functions & Func_Fullscreen)
+ actions[num++] = otk::Property::atoms.net_wm_action_fullscreen;
+ if (_functions & Func_Maximize) {
+ actions[num++] = otk::Property::atoms.net_wm_action_maximize_horz;
+ actions[num++] = otk::Property::atoms.net_wm_action_maximize_vert;
+ }
+
+ otk::Property::set(_window, otk::Property::atoms.net_wm_allowed_actions,
+ otk::Property::atoms.atom, actions, num);
+
+ // make sure the window isn't breaking any rules now
+
+ if (!(_functions & Func_Shade) && _shaded)
+ if (frame) shade(false);
+ else _shaded = false;
+ if (!(_functions & Func_Iconify) && _iconic)
+ if (frame) setDesktop(openbox->screen(_screen)->desktop());
+ else _iconic = false;
+ if (!(_functions & Func_Fullscreen) && _fullscreen)
+ if (frame) fullscreen(false);
+ else _fullscreen = false;
+ if (!(_functions & Func_Maximize) && (_max_horz || _max_vert))
+ if (frame) maximize(false, 0);
+ else _max_vert = _max_horz = false;