From 5336c900d07804589600c8af9d838c12dec7ab1c Mon Sep 17 00:00:00 2001 From: Dana Jansens Date: Thu, 30 May 2002 06:51:43 +0000 Subject: [PATCH] merge in netwm branch at tag netwm-merge2 --- src/Screen.cc | 15 +++- src/Window.cc | 38 +++------ src/Window.hh | 1 + src/XAtom.cc | 206 ++++++++++++++++++++++++------------------------ src/XAtom.hh | 49 ++++++------ src/blackbox.cc | 2 +- src/blackbox.hh | 4 - 7 files changed, 152 insertions(+), 163 deletions(-) diff --git a/src/Screen.cc b/src/Screen.cc index 23638ae9..d22999ef 100644 --- a/src/Screen.cc +++ b/src/Screen.cc @@ -137,7 +137,7 @@ BScreen::BScreen(Blackbox *bb, unsigned int scrn) : ScreenInfo(bb, scrn) { xatom->setSupported(this); // set-up netwm support #ifdef HAVE_GETPID - xatom->setValue(getRootWindow(), XAtom::blackbox_pid, XAtom::Type_Cardinal, + xatom->setValue(getRootWindow(), XAtom::blackbox_pid, XAtom::cardinal, (unsigned long) getpid()); #endif // HAVE_GETPID @@ -230,10 +230,16 @@ BScreen::BScreen(Blackbox *bb, unsigned int scrn) : ScreenInfo(bb, scrn) { } saveWorkspaceNames(); + updateNetizenWorkspaceCount(); + workspacemenu->insert(i18n(IconSet, IconIcons, "Icons"), iconmenu); workspacemenu->update(); current_workspace = workspacesList.front(); + + xatom->setValue(getRootWindow(), XAtom::net_current_desktop, + XAtom::cardinal, 0); //first workspace + workspacemenu->setItemSelected(2, True); toolbar = new Toolbar(this); @@ -1020,6 +1026,10 @@ void BScreen::changeWorkspaceID(unsigned int id) { current_workspace = getWorkspace(id); + xatom->setValue(getRootWindow(), XAtom::net_current_desktop, + XAtom::cardinal, id); + printf("%d\n", id); + workspacemenu->setItemSelected(current_workspace->getID() + 2, True); toolbar->redrawWorkspaceLabel(True); @@ -1107,6 +1117,9 @@ void BScreen::removeNetizen(Window w) { } + xatom->setValue(getRootWindow(), XAtom::net_number_of_desktops, + XAtom::cardinal, workspacesList.size()); + void BScreen::updateNetizenCurrentWorkspace(void) { std::for_each(netizenList.begin(), netizenList.end(), std::mem_fun(&Netizen::sendCurrentWorkspace)); diff --git a/src/Window.cc b/src/Window.cc index a90e5183..47809ea9 100644 --- a/src/Window.cc +++ b/src/Window.cc @@ -75,6 +75,7 @@ BlackboxWindow::BlackboxWindow(Blackbox *b, Window w, BScreen *s) { blackbox = b; client.window = w; screen = s; + xatom = blackbox->getXAtom(); if (! validateClient()) { delete this; @@ -1758,14 +1759,10 @@ void BlackboxWindow::setState(unsigned long new_state) { unsigned long state[2]; state[0] = current_state; state[1] = None; - XChangeProperty(blackbox->getXDisplay(), client.window, - blackbox->getWMStateAtom(), blackbox->getWMStateAtom(), 32, - PropModeReplace, (unsigned char *) state, 2); - - XChangeProperty(blackbox->getXDisplay(), client.window, - blackbox->getBlackboxAttributesAtom(), - blackbox->getBlackboxAttributesAtom(), 32, PropModeReplace, - (unsigned char *) &blackbox_attrib, + xatom->setValue(client.window, XAtom::wm_state, XAtom::wm_state, state, 2); + + xatom->setValue(client.window, XAtom::blackbox_attributes, + XAtom::blackbox_attributes, (unsigned long *)&blackbox_attrib, PropBlackboxAttributesElements); } @@ -1775,27 +1772,16 @@ bool BlackboxWindow::getState(void) { Atom atom_return; bool ret = False; - int foo; - unsigned long *state, ulfoo, nitems; - - if ((XGetWindowProperty(blackbox->getXDisplay(), client.window, - blackbox->getWMStateAtom(), - 0l, 2l, False, blackbox->getWMStateAtom(), - &atom_return, &foo, &nitems, &ulfoo, - (unsigned char **) &state) != Success) || - (! state)) { - return False; - } - - if (nitems >= 1) { - current_state = static_cast(state[0]); + unsigned long *state, nitems; - ret = True; - } + if (! xatom->getValue(client.window, XAtom::wm_state, XAtom::wm_state, nitems, + &state)) + return False; - XFree((void *) state); + current_state = static_cast(state[0]); + delete state; - return ret; + return True; } diff --git a/src/Window.hh b/src/Window.hh index 9bed2798..6dda6558 100644 --- a/src/Window.hh +++ b/src/Window.hh @@ -111,6 +111,7 @@ public: private: Blackbox *blackbox; BScreen *screen; + XAtom *xatom; BTimer *timer; BlackboxAttributes blackbox_attrib; diff --git a/src/XAtom.cc b/src/XAtom.cc index 8940f2e3..649f118f 100644 --- a/src/XAtom.cc +++ b/src/XAtom.cc @@ -32,6 +32,11 @@ XAtom::XAtom(Blackbox *bb) { // make sure asserts fire if there is a problem memset(_atoms, sizeof(_atoms), 0); + _atoms[cardinal] = XA_CARDINAL; + _atoms[window] = XA_WINDOW; + _atoms[pixmap] = XA_PIXMAP; + _atoms[atom] = XA_ATOM; + _atoms[string] = XA_STRING; _atoms[utf8_string] = create("UTF8_STRING"); #ifdef HAVE_GETPID @@ -132,40 +137,38 @@ void XAtom::setSupported(const ScreenInfo *screen) { _support_windows.push_back(w); // set supporting window - setValue(root, net_supporting_wm_check, Type_Window, w); + setValue(root, net_supporting_wm_check, 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); - + setValue(w, net_wm_name, utf8, "Openbox"); + setValue(w, net_supporting_wm_check, 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 + _atoms[net_current_desktop], + _atoms[net_number_of_desktops] }; + const int num_supported = sizeof(supported)/sizeof(Atom); - 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]); + setValue(root, net_supported, atom, supported, num_supported); } /* - * Internal setValue used by all typed setValue functions. + * Internal setValue. * Sets a window property on a window, optionally appending to the existing * value. */ -void XAtom::setValue(Window win, AvailableAtoms atom, Atom type, +void XAtom::setValue(Window win, Atom 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(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, _atoms[atom], type, size, + XChangeProperty(_display, win, atom, type, size, (append ? PropModeAppend : PropModeReplace), data, nelements); } @@ -174,73 +177,53 @@ void XAtom::setValue(Window win, AvailableAtoms atom, Atom type, /* * Set a 32-bit property value on a window. */ -void XAtom::setValue(Window win, AvailableAtoms atom, AtomType type, +void XAtom::setValue(Window win, Atoms atom, Atoms 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); -} - - -/* - * Set a string property value on a window. - */ -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); + assert(atom >= 0 && atom < NUM_ATOMS); + assert(type >= 0 && type < NUM_ATOMS); + setValue(win, _atoms[atom], _atoms[type], + reinterpret_cast(&value), 32, 1, false); } /* - * Add elements to a 32-bit property value on a window. + * Set an array of 32-bit properties value on a window. */ -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); +void XAtom::setValue(Window win, Atoms atom, Atoms type, + unsigned long value[], int elements) const { + assert(atom >= 0 && atom < NUM_ATOMS); + assert(type >= 0 && type < NUM_ATOMS); + setValue(win, _atoms[atom], _atoms[type], + reinterpret_cast(value), 32, elements, false); } /* - * Add characters to a string property value on a window. + * Set an string property value on a window. */ -void XAtom::addValue(Window win, AvailableAtoms atom, StringType type, +void XAtom::setValue(Window win, Atoms 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 + assert(atom >= 0 && atom < NUM_ATOMS); + assert(type >= 0 && type < NUM_STRING_TYPE); + assert(win != None); assert(_atoms[atom] != None); + + const char *c = value.c_str(); + XTextProperty textprop; + if (Success != XmbTextListToTextProperty(_display, const_cast(&c), 1, + type == ansi ? XStringStyle : +#ifdef X_HAVE_UTF8_STRING + XUTF8StringStyle, +#else + XCompoundTextStyle, +#endif + &textprop)) { + return; } - setValue(win, atom, t, - const_cast - (reinterpret_cast - (value.c_str())), - 8, value.size(), true); -} + + XSetTextProperty(_display, win, &textprop, _atoms[atom]); + + XFree(textprop.value); +} /* @@ -250,19 +233,18 @@ void XAtom::addValue(Window win, AvailableAtoms atom, StringType type, * 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, AvailableAtoms atom, Atom type, - unsigned long *nelements, unsigned char **value, +bool XAtom::getValue(Window win, Atom 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(win != None); assert(atom != 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, _atoms[atom], 0l, 1l, False, - AnyPropertyType, &ret_type, &ret_size, nelements, - &ret_bytes, &c_val); // try get the first element + // try get the first element + XGetWindowProperty(_display, win, atom, 0l, 1l, False, AnyPropertyType, + &ret_type, &ret_size, &nelements, &ret_bytes, &c_val); if (ret_type == None) // the property does not exist on the window return false; @@ -274,8 +256,8 @@ bool XAtom::getValue(Window win, AvailableAtoms atom, Atom type, // the data is correct, now, is there more than 1 element? if (ret_bytes == 0) { // we got the whole property's value - *value = new unsigned char[*nelements * size/8 + 1]; - memcpy(*value, c_val, *nelements * size/8 + 1); + *value = new unsigned char[nelements * size/8 + 1]; + memcpy(*value, c_val, nelements * size/8 + 1); XFree(c_val); return true; } @@ -284,11 +266,11 @@ bool XAtom::getValue(Window win, AvailableAtoms atom, Atom type, // 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, _atoms[atom], 0l, remain, False, type, - &ret_type, &ret_size, nelements, &ret_bytes, &c_val); + XGetWindowProperty(_display, win, 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); + *value = new unsigned char[nelements * size/8 + 1]; + memcpy(*value, c_val, nelements * size/8 + 1); XFree(c_val); return true; } @@ -297,18 +279,12 @@ bool XAtom::getValue(Window win, AvailableAtoms atom, Atom type, /* * Gets a 32-bit property's value from a window. */ -bool XAtom::getValue(Window win, AvailableAtoms atom, AtomType type, - unsigned long *nelements, +bool XAtom::getValue(Window win, Atoms atom, Atoms 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, + assert(atom >= 0 && atom < NUM_ATOMS); + assert(type >= 0 && type < NUM_ATOMS); + return getValue(win, _atoms[atom], _atoms[type], nelements, reinterpret_cast(value), 32); } @@ -316,26 +292,48 @@ bool XAtom::getValue(Window win, AvailableAtoms atom, AtomType type, /* * Gets an string property's value from a window. */ -bool XAtom::getValue(Window win, AvailableAtoms atom, StringType type, +bool XAtom::getValue(Window win, Atoms 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 + assert(atom >= 0 && atom < NUM_ATOMS); + assert(type >= 0 && type < NUM_STRING_TYPE); + assert(win != None); assert(_atoms[atom] != None); + + XTextProperty textprop; + if (0 == XGetTextProperty(_display, win, &textprop, _atoms[atom])) + return false; + + int ret; + int count; + char **list; + if (type == ansi) { + ret = XmbTextPropertyToTextList(_display, &textprop, &list, &count); + } else { +#ifdef X_HAVE_UTF8_STRING + ret = Xutf8TextPropertyToTextList(_display, &textprop, &list, &count); +#else + ret = XmbTextPropertyToTextList(_display, &textprop, &list, &count); +#endif } - unsigned char *data; - unsigned long nelements; - bool ret = getValue(win, atom, t, &nelements, &data, 8); - if (ret) - value = reinterpret_cast(data); - return ret; + + if (ret != Success || count < 1) { + XFree(textprop.value); + return false; + } + + value = list[0]; + + XFreeStringList(list); + XFree(textprop.value); + return true; } + + /* * Removes a property entirely from a window. */ -void XAtom::eraseValue(Window win, AvailableAtoms atom) const { +void XAtom::eraseValue(Window win, Atoms atom) const { + assert(atom >= 0 && atom < NUM_ATOMS); XDeleteProperty(_display, win, _atoms[atom]); } diff --git a/src/XAtom.hh b/src/XAtom.hh index f73f7558..580b973c 100644 --- a/src/XAtom.hh +++ b/src/XAtom.hh @@ -32,8 +32,13 @@ class ScreenInfo; class XAtom { public: - enum AvailableAtoms { - // string type + enum Atoms { + // types + cardinal, + window, + pixmap, + atom, + string, utf8_string, #ifdef HAVE_GETPID @@ -102,16 +107,10 @@ public: NUM_ATOMS }; - enum AtomType { - Type_Cardinal, - Type_Atom, - Type_Window, - Type_Pixmap - }; - enum StringType { - Type_String, - Type_Utf8, + ansi, + utf8, + NUM_STRING_TYPE }; private: @@ -124,10 +123,10 @@ private: Atom create(const char *name) const; - void setValue(Window win, AvailableAtoms atom, Atom type, unsigned char *data, + void setValue(Window win, Atom atom, Atom type, unsigned char *data, int size, int nelements, bool append) const; - bool getValue(Window win, AvailableAtoms atom, Atom type, - unsigned long *nelements, unsigned char **value, + bool getValue(Window win, Atom atom, Atom type, + unsigned long &nelements, unsigned char **value, int size) const; // no copying!! @@ -142,29 +141,25 @@ public: // constructor. void setSupported(const ScreenInfo *screen); - void setValue(Window win, AvailableAtoms atom, AtomType type, - unsigned long value) const; - void setValue(Window win, AvailableAtoms atom, StringType type, - const std::string &value) const; - - void addValue(Window win, AvailableAtoms atom, AtomType type, - unsigned long value) const; - void addValue(Window win, AvailableAtoms atom, StringType type, + void setValue(Window win, Atoms atom, Atoms type, unsigned long value) const; + void setValue(Window win, Atoms atom, Atoms type, + unsigned long value[], int elements) const; + void setValue(Window win, Atoms atom, StringType type, const std::string &value) const; // the 'value' is allocated inside the function and // delete [] value needs to be called when you are done with it. // the 'value' array returned is null terminated, and has 'nelements' // elements in it plus the null. - bool getValue(Window win, AvailableAtoms atom, AtomType type, - unsigned long *nelements, unsigned long **value) const; - bool getValue(Window win, AvailableAtoms atom, StringType type, + bool getValue(Window win, Atoms atom, Atoms type, + unsigned long &nelements, unsigned long **value) const; + bool getValue(Window win, Atoms atom, StringType type, std::string &value) const; - void eraseValue(Window win, AvailableAtoms atom) const; + void eraseValue(Window win, Atoms atom) const; // temporary function!! remove when not used in blackbox.hh anymore!! - inline Atom getAtom(AvailableAtoms a) + inline Atom getAtom(Atoms a) { Atom ret = _atoms[a]; assert(ret != 0); return ret; } }; diff --git a/src/blackbox.cc b/src/blackbox.cc index 1c543bbe..ce727aff 100644 --- a/src/blackbox.cc +++ b/src/blackbox.cc @@ -653,7 +653,7 @@ void Blackbox::process_event(XEvent *e) { case ClientMessage: { if (e->xclient.format == 32) { - if (e->xclient.message_type == getWMChangeStateAtom()) { + if (e->xclient.message_type == xatom->getAtom(XAtom::wm_change_state)) { BlackboxWindow *win = searchWindow(e->xclient.window); if (! win || ! win->validateClient()) return; diff --git a/src/blackbox.hh b/src/blackbox.hh index 0e39cc2f..cb38dc34 100644 --- a/src/blackbox.hh +++ b/src/blackbox.hh @@ -245,10 +245,6 @@ public: enum { B_AmericanDate = 1, B_EuropeanDate }; #endif // HAVE_STRFTIME - inline Atom getWMChangeStateAtom(void) const - { return xatom->getAtom(XAtom::wm_change_state); } - inline Atom getWMStateAtom(void) const - { return xatom->getAtom(XAtom::wm_state); } inline Atom getWMDeleteAtom(void) const { return xatom->getAtom(XAtom::wm_delete_window); } inline Atom getWMProtocolsAtom(void) const -- 2.45.2