X-Git-Url: https://git.dogcows.com/gitweb?a=blobdiff_plain;f=src%2Fclient.cc;h=4a99b0bc58eecbb27ca21870ae57c743c0a79f80;hb=b0149ef3fd8eeafc6a7fc008468d36c3b86b9008;hp=7a3754a669c581f110c67acf25dff926b0667678;hpb=d017db67e4d77fd7af3f070803a773df0a5768eb;p=chaz%2Fopenbox diff --git a/src/client.cc b/src/client.cc index 7a3754a6..4a99b0bc 100644 --- a/src/client.cc +++ b/src/client.cc @@ -18,28 +18,333 @@ extern "C" { namespace ob { -OBClient::OBClient(BScreen *screen, Window window) - : _screen(screen), _window(window) +OBClient::OBClient(Window window) + : _window(window) { - assert(_screen); 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; + // 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; + } - // update EVERYTHING the first time!! + 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; + assert(XGetWindowAttributes(otk::OBDisplay::display, _window, &wattrib)); + + _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; + + XShapeQueryExtents(otk::OBDisplay::display, client.window, &_shaped, &foo, + &foo, &ufoo, &ufoo, &foo, &foo, &foo, &ufoo, &ufoo); + } +#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); + } } @@ -52,15 +357,34 @@ void OBClient::updateNormalHints() _gravity = NorthWestGravity; _inc_x = _inc_y = 1; _base_x = _base_y = 0; + _min_x = _min_y = 0; + _max_x = _max_y = 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 & PMinSize) { + _min_x = size.min_width; + _min_y = size.min_height; + } + + if (size.flags & PMaxSize) { + _max_x = size.max_width; + _max_y = size.max_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; @@ -80,14 +404,19 @@ void OBClient::updateWMHints() 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); } } @@ -112,6 +441,25 @@ void OBClient::updateTitle() } +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(); @@ -140,18 +488,23 @@ void OBClient::update(const XPropertyEvent &e) 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: @@ -161,7 +514,7 @@ void OBClient::setWMState(long state) // XXX: cause it to uniconify break; } - _state = state; + _wmstate = state; } @@ -289,4 +642,10 @@ void OBClient::update(const XClientMessageEvent &e) setState((StateAction)e.data.l[0], e.data.l[1], e.data.l[2]); } + +void OBClient::setArea(const otk::Rect &area) +{ + _area = area; +} + }