X-Git-Url: https://git.brokenzipper.com/gitweb?a=blobdiff_plain;f=src%2FXAtom.cc;h=8940f2e36db52e5a13b79779a866269ce7659808;hb=23640740ca6659ee4effb9e5c040900e0bbdeb59;hp=9e5901265f0b5953c93e7719a45d5bdeecea3ec6;hpb=18bdbfaad269fe7ab688194739391695b874bbd1;p=chaz%2Fopenbox diff --git a/src/XAtom.cc b/src/XAtom.cc index 9e590126..8940f2e3 100644 --- a/src/XAtom.cc +++ b/src/XAtom.cc @@ -19,75 +19,83 @@ // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER // DEALINGS IN THE SOFTWARE. -#include "XAtom.h" -#include "openbox.h" -#include "Screen.h" -#include "Util.h" +#include "../config.h" -XAtom::XAtom(Openbox &ob) { - _display = ob.getXDisplay(); +#include "XAtom.hh" +#include "blackbox.hh" +#include "Screen.hh" +#include "Util.hh" +XAtom::XAtom(Blackbox *bb) { + _display = bb->getXDisplay(); + + // make sure asserts fire if there is a problem + memset(_atoms, sizeof(_atoms), 0); + + _atoms[utf8_string] = create("UTF8_STRING"); + #ifdef HAVE_GETPID - openbox_pid = getAtom("_BLACKBOX_PID"); + _atoms[blackbox_pid] = create("_BLACKBOX_PID"); #endif // HAVE_GETPID - wm_colormap_windows = getAtom("WM_COLORMAP_WINDOWS"); - wm_protocols = getAtom("WM_PROTOCOLS"); - wm_state = getAtom("WM_STATE"); - wm_change_state = getAtom("WM_CHANGE_STATE"); - wm_delete_window = getAtom("WM_DELETE_WINDOW"); - wm_take_focus = getAtom("WM_TAKE_FOCUS"); - motif_wm_hints = getAtom("_MOTIF_WM_HINTS"); - openbox_hints = getAtom("_BLACKBOX_HINTS"); - openbox_attributes = getAtom("_BLACKBOX_ATTRIBUTES"); - openbox_change_attributes = getAtom("_BLACKBOX_CHANGE_ATTRIBUTES"); - - openbox_structure_messages = getAtom("_BLACKBOX_STRUCTURE_MESSAGES"); - openbox_notify_startup = getAtom("_BLACKBOX_NOTIFY_STARTUP"); - openbox_notify_window_add = getAtom("_BLACKBOX_NOTIFY_WINDOW_ADD"); - openbox_notify_window_del = getAtom("_BLACKBOX_NOTIFY_WINDOW_DEL"); - openbox_notify_current_workspace = - getAtom("_BLACKBOX_NOTIFY_CURRENT_WORKSPACE"); - openbox_notify_workspace_count = getAtom("_BLACKBOX_NOTIFY_WORKSPACE_COUNT"); - openbox_notify_window_focus = getAtom("_BLACKBOX_NOTIFY_WINDOW_FOCUS"); - openbox_notify_window_raise = getAtom("_BLACKBOX_NOTIFY_WINDOW_RAISE"); - openbox_notify_window_lower = getAtom("_BLACKBOX_NOTIFY_WINDOW_LOWER"); + _atoms[wm_colormap_windows] = create("WM_COLORMAP_WINDOWS"); + _atoms[wm_protocols] = create("WM_PROTOCOLS"); + _atoms[wm_state] = create("WM_STATE"); + _atoms[wm_change_state] = create("WM_CHANGE_STATE"); + _atoms[wm_delete_window] = create("WM_DELETE_WINDOW"); + _atoms[wm_take_focus] = create("WM_TAKE_FOCUS"); + _atoms[motif_wm_hints] = create("_MOTIF_WM_HINTS"); + _atoms[blackbox_hints] = create("_BLACKBOX_HINTS"); + _atoms[blackbox_attributes] = create("_BLACKBOX_ATTRIBUTES"); + _atoms[blackbox_change_attributes] = create("_BLACKBOX_CHANGE_ATTRIBUTES"); + _atoms[blackbox_structure_messages] = create("_BLACKBOX_STRUCTURE_MESSAGES"); + _atoms[blackbox_notify_startup] = create("_BLACKBOX_NOTIFY_STARTUP"); + _atoms[blackbox_notify_window_add] = create("_BLACKBOX_NOTIFY_WINDOW_ADD"); + _atoms[blackbox_notify_window_del] = create("_BLACKBOX_NOTIFY_WINDOW_DEL"); + _atoms[blackbox_notify_current_workspace] = + create("_BLACKBOX_NOTIFY_CURRENT_WORKSPACE"); + _atoms[blackbox_notify_workspace_count] = + create("_BLACKBOX_NOTIFY_WORKSPACE_COUNT"); + _atoms[blackbox_notify_window_focus] = + create("_BLACKBOX_NOTIFY_WINDOW_FOCUS"); + _atoms[blackbox_notify_window_raise] = + create("_BLACKBOX_NOTIFY_WINDOW_RAISE"); + _atoms[blackbox_notify_window_lower] = + create("_BLACKBOX_NOTIFY_WINDOW_LOWER"); - openbox_change_workspace = getAtom("_BLACKBOX_CHANGE_WORKSPACE"); - openbox_change_window_focus = getAtom("_BLACKBOX_CHANGE_WINDOW_FOCUS"); - openbox_cycle_window_focus = getAtom("_BLACKBOX_CYCLE_WINDOW_FOCUS"); - - net_supported = getAtom("_NET_SUPPORTED"); - net_client_list = getAtom("_NET_CLIENT_LIST"); - net_client_list_stacking = getAtom("_NET_CLIENT_LIST_STACKING"); - net_number_of_desktops = getAtom("_NET_NUMBER_OF_DESKTOPS"); - net_desktop_geometry = getAtom("_NET_DESKTOP_GEOMETRY"); - net_desktop_viewport = getAtom("_NET_DESKTOP_VIEWPORT"); - net_current_desktop = getAtom("_NET_CURRENT_DESKTOP"); - net_desktop_names = getAtom("_NET_DESKTOP_NAMES"); - net_active_window = getAtom("_NET_ACTIVE_WINDOW"); - net_workarea = getAtom("_NET_WORKAREA"); - net_supporting_wm_check = getAtom("_NET_SUPPORTING_WM_CHECK"); - net_virtual_roots = getAtom("_NET_VIRTUAL_ROOTS"); - - net_close_window = getAtom("_NET_CLOSE_WINDOW"); - net_wm_moveresize = getAtom("_NET_WM_MOVERESIZE"); - - net_properties = getAtom("_NET_PROPERTIES"); - net_wm_name = getAtom("_NET_WM_NAME"); - net_wm_desktop = getAtom("_NET_WM_DESKTOP"); - net_wm_window_type = getAtom("_NET_WM_WINDOW_TYPE"); - net_wm_state = getAtom("_NET_WM_STATE"); - net_wm_strut = getAtom("_NET_WM_STRUT"); - net_wm_icon_geometry = getAtom("_NET_WM_ICON_GEOMETRY"); - net_wm_icon = getAtom("_NET_WM_ICON"); - net_wm_pid = getAtom("_NET_WM_PID"); - net_wm_handled_icons = getAtom("_NET_WM_HANDLED_ICONS"); - - net_wm_ping = getAtom("_NET_WM_PING"); - - for (unsigned int s = 0, c = ob.managedScreenCount(); s < c; ++s) - setSupported( static_cast(ob.getScreen(s)) ); + _atoms[blackbox_change_workspace] = create("_BLACKBOX_CHANGE_WORKSPACE"); + _atoms[blackbox_change_window_focus] = + create("_BLACKBOX_CHANGE_WINDOW_FOCUS"); + _atoms[blackbox_cycle_window_focus] = create("_BLACKBOX_CYCLE_WINDOW_FOCUS"); + + _atoms[net_supported] = create("_NET_SUPPORTED"); + _atoms[net_client_list] = create("_NET_CLIENT_LIST"); + _atoms[net_client_list_stacking] = create("_NET_CLIENT_LIST_STACKING"); + _atoms[net_number_of_desktops] = create("_NET_NUMBER_OF_DESKTOPS"); + _atoms[net_desktop_geometry] = create("_NET_DESKTOP_GEOMETRY"); + _atoms[net_desktop_viewport] = create("_NET_DESKTOP_VIEWPORT"); + _atoms[net_current_desktop] = create("_NET_CURRENT_DESKTOP"); + _atoms[net_desktop_names] = create("_NET_DESKTOP_NAMES"); + _atoms[net_active_window] = create("_NET_ACTIVE_WINDOW"); + _atoms[net_workarea] = create("_NET_WORKAREA"); + _atoms[net_supporting_wm_check] = create("_NET_SUPPORTING_WM_CHECK"); + _atoms[net_virtual_roots] = create("_NET_VIRTUAL_ROOTS"); + + _atoms[net_close_window] = create("_NET_CLOSE_WINDOW"); + _atoms[net_wm_moveresize] = create("_NET_WM_MOVERESIZE"); + + _atoms[net_properties] = create("_NET_PROPERTIES"); + _atoms[net_wm_name] = create("_NET_WM_NAME"); + _atoms[net_wm_desktop] = create("_NET_WM_DESKTOP"); + _atoms[net_wm_window_type] = create("_NET_WM_WINDOW_TYPE"); + _atoms[net_wm_state] = create("_NET_WM_STATE"); + _atoms[net_wm_strut] = create("_NET_WM_STRUT"); + _atoms[net_wm_icon_geometry] = create("_NET_WM_ICON_GEOMETRY"); + _atoms[net_wm_icon] = create("_NET_WM_ICON"); + _atoms[net_wm_pid] = create("_NET_WM_PID"); + _atoms[net_wm_handled_icons] = create("_NET_WM_HANDLED_ICONS"); + + _atoms[net_wm_ping] = create("_NET_WM_PING"); } @@ -97,7 +105,7 @@ XAtom::XAtom(Openbox &ob) { XAtom::~XAtom() { while (!_support_windows.empty()) { // make sure we aren't fucking with this somewhere - ASSERT(_support_windows.back() != None); + assert(_support_windows.back() != None); XDestroyWindow(_display, _support_windows.back()); _support_windows.pop_back(); } @@ -107,7 +115,7 @@ XAtom::~XAtom() { /* * Returns an atom from the Xserver, creating it if necessary. */ -Atom XAtom::getAtom(const char *name) const { +Atom XAtom::create(const char *name) const { return XInternAtom(_display, name, False); } @@ -116,13 +124,31 @@ Atom XAtom::getAtom(const char *name) const { * Sets which atoms are supported for NETWM, by Openbox, on the root window. */ void XAtom::setSupported(const ScreenInfo *screen) { + Window root = screen->getRootWindow(); + // create the netwm support window - Window w = XCreateSimpleWindow(_display, screen->getRootWindow(), - 0, 0, 1, 1, 0, 0, 0); - ASSERT(w != None); + Window w = XCreateSimpleWindow(_display, root, 0, 0, 1, 1, 0, 0, 0); + assert(w != None); _support_windows.push_back(w); + // set supporting window + setValue(root, net_supporting_wm_check, Type_Window, w); + + //set properties on the supporting window + setValue(w, net_wm_name, Type_Utf8, "Openbox"); + setValue(w, net_supporting_wm_check, Type_Window, w); + + // we don't support any yet.. + // yes we do! + + Atom supported[] = { + _atoms[net_supported] // remove me later, cuz i dont think i belong + }; + + eraseValue(root, net_supported); + for (unsigned int i = 0, num = sizeof(supported)/sizeof(Atom); i < num; ++i) + addValue(root, net_supported, Type_Atom, supported[i]); } @@ -131,50 +157,34 @@ void XAtom::setSupported(const ScreenInfo *screen) { * Sets a window property on a window, optionally appending to the existing * value. */ -void XAtom::setValue(Window win, Atom atom, Atom type, unsigned char* data, - int size, int nelements, bool append) const { - ASSERT(win != None); ASSERT(atom != None); ASSERT(type != None); - ASSERT(data != (unsigned char *) 0); - ASSERT(size == 8 || size == 16 || size == 32); - ASSERT(nelements > 0); - XChangeProperty(_display, win, atom, type, size, +void XAtom::setValue(Window win, AvailableAtoms atom, Atom type, + unsigned char* data, int size, int nelements, + bool append) const { + assert(atom >= 0 && atom < NUM_ATOMS); + assert(win != None); assert(type != None); + assert(data != (unsigned char *) 0); + assert(size == 8 || size == 16 || size == 32); + assert(nelements > 0); + XChangeProperty(_display, win, _atoms[atom], type, size, (append ? PropModeAppend : PropModeReplace), data, nelements); } /* - * Set a 32-bit CARDINAL property value on a window. + * Set a 32-bit property value on a window. */ -void XAtom::setCardValue(Window win, Atom atom, long value) const { - setValue(win, atom, XA_CARDINAL, reinterpret_cast(&value), - 32, 1, false); -} - - -/* - * Set an Atom property value on a window. - */ -void XAtom::setAtomValue(Window win, Atom atom, Atom value) const { - setValue(win, atom, XA_ATOM, reinterpret_cast(&value), - 32, 1, false); -} - - -/* - * Set a Window property value on a window. - */ -void XAtom::setWindowValue(Window win, Atom atom, Window value) const { - setValue(win, atom, XA_WINDOW, reinterpret_cast(&value), - 32, 1, false); -} - - -/* - * Set a Pixmap property value on a window. - */ -void XAtom::setPixmapValue(Window win, Atom atom, Pixmap value) const { - setValue(win, atom, XA_PIXMAP, reinterpret_cast(&value), +void XAtom::setValue(Window win, AvailableAtoms atom, AtomType type, + unsigned long value) const { + Atom t; + switch (type) { + case Type_Cardinal: t = XA_CARDINAL; break; + case Type_Atom: t = XA_ATOM; break; + case Type_Window: t = XA_WINDOW; break; + case Type_Pixmap: t = XA_PIXMAP; break; + default: assert(false); // unhandled AtomType + } + setValue(win, atom, t, reinterpret_cast(&value), 32, 1, false); } @@ -182,9 +192,15 @@ void XAtom::setPixmapValue(Window win, Atom atom, Pixmap value) const { /* * Set a string property value on a window. */ -void XAtom::setStringValue(Window win, Atom atom, - const std::string &value) const { - setValue(win, atom, XA_STRING, +void XAtom::setValue(Window win, AvailableAtoms atom, StringType type, + const std::string &value) const { + Atom t; + switch (type) { + case Type_String: t = XA_STRING; break; + case Type_Utf8: t = _atoms[utf8_string]; break; + default: assert(false); // unhandled StringType + } + setValue(win, atom, t, const_cast (reinterpret_cast(value.c_str())), 8, value.size(), false); @@ -192,47 +208,34 @@ void XAtom::setStringValue(Window win, Atom atom, /* - * Add elements to a 32-bit CARDINAL property value on a window. - */ -void XAtom::addCardValue(Window win, Atom atom, long value) const { - setValue(win, atom, XA_CARDINAL, reinterpret_cast(&value), - 32, 1, true); -} - - -/* - * Add elements to an Atom property value on a window. + * Add elements to a 32-bit property value on a window. */ -void XAtom::addAtomValue(Window win, Atom atom, Atom value) const { - setValue(win, atom, XA_ATOM, reinterpret_cast(&value), - 32, 1, true); -} - - -/* - * Add elements to a Window property value on a window. - */ -void XAtom::addWindowValue(Window win, Atom atom, Window value) const { - setValue(win, atom, XA_WINDOW, reinterpret_cast(&value), - 32, 1, true); -} - - -/* - * Add elements to a Pixmap property value on a window. - */ -void XAtom::addPixmapValue(Window win, Atom atom, Pixmap value) const { - setValue(win, atom, XA_PIXMAP, reinterpret_cast(&value), - 32, 1, true); +void XAtom::addValue(Window win, AvailableAtoms atom, AtomType type, + unsigned long value) const { + Atom t; + switch (type) { + case Type_Cardinal: t = XA_CARDINAL; break; + case Type_Atom: t = XA_ATOM; break; + case Type_Window: t = XA_WINDOW; break; + case Type_Pixmap: t = XA_PIXMAP; break; + default: assert(false); // unhandled Atom_Type + } + setValue(win, atom, t, reinterpret_cast(&value), 32, 1, true); } /* * Add characters to a string property value on a window. */ -void XAtom::addStringValue(Window win, Atom atom, - const std::string &value) const { - setValue(win, atom, XA_STRING, +void XAtom::addValue(Window win, AvailableAtoms atom, StringType type, + const std::string &value) const { + Atom t; + switch (type) { + case Type_String: t = XA_STRING; break; + case Type_Utf8: t = _atoms[utf8_string]; break; + default: assert(false); // unhandled StringType + } + setValue(win, atom, t, const_cast (reinterpret_cast (value.c_str())), @@ -247,15 +250,19 @@ void XAtom::addStringValue(Window win, Atom atom, * property did not exist on the window, or has a different type/size format * than the user tried to retrieve. */ -bool XAtom::getValue(Window win, Atom atom, Atom type, unsigned long *nelements, - unsigned char **value, int size) const { +bool XAtom::getValue(Window win, AvailableAtoms atom, Atom type, + unsigned long *nelements, unsigned char **value, + int size) const { + assert(atom >= 0 && atom < NUM_ATOMS); + assert(win != None); assert(type != None); + assert(size == 8 || size == 16 || size == 32); unsigned char *c_val; // value alloc'd with c malloc Atom ret_type; int ret_size; unsigned long ret_bytes; - XGetWindowProperty(_display, win, atom, 0l, 1l, False, AnyPropertyType, - &ret_type, &ret_size, nelements, &ret_bytes, - &c_val); // try get the first element + XGetWindowProperty(_display, win, _atoms[atom], 0l, 1l, False, + AnyPropertyType, &ret_type, &ret_size, nelements, + &ret_bytes, &c_val); // try get the first element if (ret_type == None) // the property does not exist on the window return false; @@ -277,9 +284,9 @@ bool XAtom::getValue(Window win, Atom atom, Atom type, unsigned long *nelements, // the number of longs that need to be retreived to get the property's entire // value. The last + 1 is the first long that we retrieved above. const int remain = (ret_bytes - 1)/sizeof(long) + 1 + 1; - XGetWindowProperty(_display, win, atom, 0l, remain, False, type, &ret_type, - &ret_size, nelements, &ret_bytes, &c_val); - ASSERT(ret_bytes == 0); + XGetWindowProperty(_display, win, _atoms[atom], 0l, remain, False, type, + &ret_type, &ret_size, nelements, &ret_bytes, &c_val); + assert(ret_bytes == 0); *value = new unsigned char[*nelements * size/8 + 1]; memcpy(*value, c_val, *nelements * size/8 + 1); XFree(c_val); @@ -288,41 +295,20 @@ bool XAtom::getValue(Window win, Atom atom, Atom type, unsigned long *nelements, /* - * Gets a 32-bit Cardinal property's value from a window. - */ -bool XAtom::getCardValue(Window win, Atom atom, unsigned long *nelements, - long **value) const { - return XAtom::getValue(win, atom, XA_CARDINAL, nelements, - reinterpret_cast(value), 32); -} - - -/* - * Gets an Atom property's value from a window. - */ -bool XAtom::getAtomValue(Window win, Atom atom, unsigned long *nelements, - Atom **value) const { - return XAtom::getValue(win, atom, XA_ATOM, nelements, - reinterpret_cast(value), 32); -} - - -/* - * Gets an Window property's value from a window. + * Gets a 32-bit property's value from a window. */ -bool XAtom::getWindowValue(Window win, Atom atom, unsigned long *nelements, - Window **value) const { - return XAtom::getValue(win, atom, XA_WINDOW, nelements, - reinterpret_cast(value), 32); -} - - -/* - * Gets an Pixmap property's value from a window. - */ -bool XAtom::getPixmapValue(Window win, Atom atom, unsigned long *nelements, - Pixmap **value) const { - return XAtom::getValue(win, atom, XA_PIXMAP, nelements, +bool XAtom::getValue(Window win, AvailableAtoms atom, AtomType type, + unsigned long *nelements, + unsigned long **value) const { + Atom t; + switch (type) { + case Type_Cardinal: t = XA_CARDINAL; break; + case Type_Atom: t = XA_ATOM; break; + case Type_Window: t = XA_WINDOW; break; + case Type_Pixmap: t = XA_PIXMAP; break; + default: assert(false); // unhandled Atom_Type + } + return getValue(win, atom, XA_CARDINAL, nelements, reinterpret_cast(value), 32); } @@ -330,10 +316,17 @@ bool XAtom::getPixmapValue(Window win, Atom atom, unsigned long *nelements, /* * Gets an string property's value from a window. */ -bool XAtom::getStringValue(Window win, Atom atom, std::string &value) const { +bool XAtom::getValue(Window win, AvailableAtoms atom, StringType type, + std::string &value) const { + Atom t; + switch (type) { + case Type_String: t = XA_STRING; break; + case Type_Utf8: t = _atoms[utf8_string]; break; + default: assert(false); // unhandled StringType + } unsigned char *data; unsigned long nelements; - bool ret = XAtom::getValue(win, atom, XA_STRING, &nelements, &data, 8); + bool ret = getValue(win, atom, t, &nelements, &data, 8); if (ret) value = reinterpret_cast(data); return ret; @@ -343,6 +336,6 @@ bool XAtom::getStringValue(Window win, Atom atom, std::string &value) const { /* * Removes a property entirely from a window. */ -void XAtom::eraseValue(Window win, Atom atom) const { - XDeleteProperty(_display, win, atom); +void XAtom::eraseValue(Window win, AvailableAtoms atom) const { + XDeleteProperty(_display, win, _atoms[atom]); }