#include "Configuration.hh"
#include "Util.hh"
+#include <algorithm>
+
#ifdef HAVE_STDLIB_H
# include <stdlib.h>
#endif // HAVE_STDLIB_H
bin_PROGRAMS= openbox
-openbox_SOURCES= BaseDisplay.cc Basemenu.cc Clientmenu.cc Color.cc Configmenu.cc Configuration.cc GCCache.cc Iconmenu.cc Image.cc ImageControl.cc Netizen.cc Rootmenu.cc Screen.cc Slit.cc Texture.cc Timer.cc Toolbar.cc Util.cc Window.cc Windowmenu.cc Workspace.cc Workspacemenu.cc blackbox.cc i18n.cc main.cc
+openbox_SOURCES= BaseDisplay.cc Basemenu.cc Clientmenu.cc Color.cc Configmenu.cc Configuration.cc GCCache.cc Iconmenu.cc Image.cc ImageControl.cc Netizen.cc Rootmenu.cc Screen.cc Slit.cc Texture.cc Timer.cc Toolbar.cc Util.cc Window.cc Windowmenu.cc Workspace.cc Workspacemenu.cc XAtom.cc blackbox.cc i18n.cc main.cc
MAINTAINERCLEANFILES= Makefile.in
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
// DEALINGS IN THE SOFTWARE.
-#ifdef HAVE_CONFIG_H
-# include "../config.h"
-#endif // HAVE_CONFIG_H
+#include "../config.h"
extern "C" {
#include <X11/Xatom.h>
#include "Window.hh"
#include "Workspace.hh"
#include "Workspacemenu.hh"
+#include "XAtom.hh"
#ifndef FONT_ELEMENT_SIZE
#define FONT_ELEMENT_SIZE 50
blackbox = bb;
screenstr = (string)"session.screen" + itostring(scrn) + '.';
config = blackbox->getConfig();
+ xatom = blackbox->getXAtom();
event_mask = ColormapChangeMask | EnterWindowMask | PropertyChangeMask |
SubstructureRedirectMask | ButtonPressMask | ButtonReleaseMask;
resource.mstyle.t_font = resource.mstyle.f_font = resource.tstyle.font =
resource.wstyle.font = (XFontStruct *) 0;
+ xatom->setSupported(this); // set-up netwm support
#ifdef HAVE_GETPID
- pid_t bpid = getpid();
-
- XChangeProperty(blackbox->getXDisplay(), getRootWindow(),
- blackbox->getBlackboxPidAtom(), XA_CARDINAL,
- sizeof(pid_t) * 8, PropModeReplace,
- (unsigned char *) &bpid, 1);
+ xatom->setValue(getRootWindow(), XAtom::blackbox_pid, XAtom::Type_Cardinal,
+ (unsigned long) getpid());
#endif // HAVE_GETPID
XDefineCursor(blackbox->getXDisplay(), getRootWindow(),
#include "Workspacemenu.hh"
#include "blackbox.hh"
class Slit; // forward reference
+class XAtom;
enum TextJustify { LeftJustify = 1, RightJustify, CenterJustify };
Iconmenu *iconmenu;
Rootmenu *rootmenu;
Configuration *config;
+ XAtom *xatom;
typedef std::list<Rootmenu*> RootmenuList;
RootmenuList rootmenuList;
--- /dev/null
+// XAtom.cc for Openbox
+// Copyright (c) 2002 - 2002 Ben Jansens (xor at orodu.net)
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the "Software"),
+// to deal in the Software without restriction, including without limitation
+// the rights to use, copy, modify, merge, publish, distribute, sublicense,
+// and/or sell copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+// DEALINGS IN THE SOFTWARE.
+
+#include "../config.h"
+
+#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
+ _atoms[blackbox_pid] = create("_BLACKBOX_PID");
+#endif // HAVE_GETPID
+
+ _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");
+
+ _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");
+}
+
+
+/*
+ * clean up the class' members
+ */
+XAtom::~XAtom() {
+ while (!_support_windows.empty()) {
+ // make sure we aren't fucking with this somewhere
+ assert(_support_windows.back() != None);
+ XDestroyWindow(_display, _support_windows.back());
+ _support_windows.pop_back();
+ }
+}
+
+
+/*
+ * Returns an atom from the Xserver, creating it if necessary.
+ */
+Atom XAtom::create(const char *name) const {
+ return XInternAtom(_display, name, False);
+}
+
+
+/*
+ * 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, 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]);
+}
+
+
+/*
+ * Internal setValue used by all typed setValue functions.
+ * Sets a window property on a window, optionally appending to the existing
+ * value.
+ */
+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 property value on a window.
+ */
+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<unsigned char*>(&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<unsigned char*>
+ (reinterpret_cast<const unsigned char*>(value.c_str())),
+ 8, value.size(), false);
+}
+
+
+/*
+ * Add elements to a 32-bit property 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<unsigned char*>(&value), 32, 1, true);
+}
+
+
+/*
+ * Add characters to a string property value on a window.
+ */
+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<unsigned char*>
+ (reinterpret_cast<const unsigned char *>
+ (value.c_str())),
+ 8, value.size(), true);
+}
+
+
+/*
+ * Internal getValue function used by all of the typed getValue functions.
+ * Gets an property's value from a window.
+ * Returns true if the property was successfully retrieved; false if the
+ * 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,
+ 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, _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;
+ if (ret_type != type || ret_size != size) {
+ // wrong data in property
+ XFree(c_val);
+ return false;
+ }
+ // 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);
+ XFree(c_val);
+ return true;
+ }
+ // get the entire property since it is larger than one long
+ free(c_val);
+ // 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);
+ assert(ret_bytes == 0);
+ *value = new unsigned char[*nelements * size/8 + 1];
+ memcpy(*value, c_val, *nelements * size/8 + 1);
+ XFree(c_val);
+ return true;
+}
+
+
+/*
+ * Gets a 32-bit property's value from a window.
+ */
+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<unsigned char **>(value), 32);
+}
+
+
+/*
+ * Gets an string property's value from a window.
+ */
+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 = getValue(win, atom, t, &nelements, &data, 8);
+ if (ret)
+ value = reinterpret_cast<char*>(data);
+ return ret;
+}
+
+
+/*
+ * Removes a property entirely from a window.
+ */
+void XAtom::eraseValue(Window win, AvailableAtoms atom) const {
+ XDeleteProperty(_display, win, _atoms[atom]);
+}
--- /dev/null
+// XAtom.h for Openbox
+// Copyright (c) 2002 - 2002 Ben Janens (ben at orodu.net)
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the "Software"),
+// to deal in the Software without restriction, including without limitation
+// the rights to use, copy, modify, merge, publish, distribute, sublicense,
+// and/or sell copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+// DEALINGS IN THE SOFTWARE.
+
+#ifndef __XAtom_h
+#define __XAtom_h
+
+#include <X11/Xlib.h>
+#include <X11/Xatom.h>
+#include <vector>
+#include <string>
+
+class Blackbox;
+class ScreenInfo;
+
+class XAtom {
+public:
+ enum AvailableAtoms {
+ // string type
+ utf8_string,
+
+#ifdef HAVE_GETPID
+ blackbox_pid,
+#endif // HAVE_GETPID
+
+ // window hints
+ wm_colormap_windows,
+ wm_protocols,
+ wm_state,
+ wm_delete_window,
+ wm_take_focus,
+ wm_change_state,
+ motif_wm_hints,
+ blackbox_attributes,
+ blackbox_change_attributes,
+ blackbox_hints,
+
+ // blackbox-protocol atoms (wm -> client)
+ blackbox_structure_messages,
+ blackbox_notify_startup,
+ blackbox_notify_window_add,
+ blackbox_notify_window_del,
+ blackbox_notify_window_focus,
+ blackbox_notify_current_workspace,
+ blackbox_notify_workspace_count,
+ blackbox_notify_window_raise,
+ blackbox_notify_window_lower,
+ // blackbox-protocol atoms (client -> wm)
+ blackbox_change_workspace,
+ blackbox_change_window_focus,
+ blackbox_cycle_window_focus,
+
+ // NETWM atoms
+ // root window properties
+ net_supported,
+ net_client_list,
+ net_client_list_stacking,
+ net_number_of_desktops,
+ net_desktop_geometry,
+ net_desktop_viewport,
+ net_current_desktop,
+ net_desktop_names,
+ net_active_window,
+ net_workarea,
+ net_supporting_wm_check,
+ net_virtual_roots,
+ // root window messages
+ net_close_window,
+ net_wm_moveresize,
+ // application window properties
+ net_properties,
+ net_wm_name,
+ net_wm_desktop,
+ net_wm_window_type,
+ net_wm_state,
+ net_wm_strut,
+ net_wm_icon_geometry,
+ net_wm_icon,
+ net_wm_pid,
+ net_wm_handled_icons,
+ // application protocols
+ net_wm_ping,
+
+ // constant for how many atoms exist in the enumerator
+ NUM_ATOMS
+ };
+
+ enum AtomType {
+ Type_Cardinal,
+ Type_Atom,
+ Type_Window,
+ Type_Pixmap
+ };
+
+ enum StringType {
+ Type_String,
+ Type_Utf8,
+ };
+
+private:
+ typedef std::vector<Window> SupportWindows;
+
+ Display *_display;
+ // windows used to specify support for NETWM
+ SupportWindows _support_windows;
+ Atom _atoms[NUM_ATOMS];
+
+ Atom create(const char *name) const;
+
+ void setValue(Window win, AvailableAtoms 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,
+ int size) const;
+
+ // no copying!!
+ XAtom(const XAtom &);
+ XAtom& operator=(const XAtom&);
+
+public:
+ XAtom(Blackbox *bb);
+ virtual ~XAtom();
+
+ // setup support on a screen, each screen should call this once in its
+ // 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,
+ 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,
+ std::string &value) const;
+
+ void eraseValue(Window win, AvailableAtoms atom) const;
+
+ // temporary function!! remove when not used in blackbox.hh anymore!!
+ inline Atom getAtom(AvailableAtoms a)
+ { Atom ret = _atoms[a]; assert(ret != 0); return ret; }
+};
+
+#endif // __XAtom_h
#include "Window.hh"
#include "Workspace.hh"
#include "Workspacemenu.hh"
-
+#include "XAtom.hh"
// X event scanner for enter/leave notifies - adapted from twm
struct scanargs {
XrmInitialize();
load_rc();
- init_icccm();
+ xatom = new XAtom(this);
cursor.session = XCreateFontCursor(getXDisplay(), XC_left_ptr);
cursor.move = XCreateFontCursor(getXDisplay(), XC_fleur);
std::for_each(menuTimestamps.begin(), menuTimestamps.end(),
PointerAssassin());
+ delete xatom;
+
delete timer;
}
}
-void Blackbox::init_icccm(void) {
- xa_wm_colormap_windows =
- XInternAtom(getXDisplay(), "WM_COLORMAP_WINDOWS", False);
- xa_wm_protocols = XInternAtom(getXDisplay(), "WM_PROTOCOLS", False);
- xa_wm_state = XInternAtom(getXDisplay(), "WM_STATE", False);
- xa_wm_change_state = XInternAtom(getXDisplay(), "WM_CHANGE_STATE", False);
- xa_wm_delete_window = XInternAtom(getXDisplay(), "WM_DELETE_WINDOW", False);
- xa_wm_take_focus = XInternAtom(getXDisplay(), "WM_TAKE_FOCUS", False);
- motif_wm_hints = XInternAtom(getXDisplay(), "_MOTIF_WM_HINTS", False);
-
- blackbox_hints = XInternAtom(getXDisplay(), "_BLACKBOX_HINTS", False);
- blackbox_attributes =
- XInternAtom(getXDisplay(), "_BLACKBOX_ATTRIBUTES", False);
- blackbox_change_attributes =
- XInternAtom(getXDisplay(), "_BLACKBOX_CHANGE_ATTRIBUTES", False);
- blackbox_structure_messages =
- XInternAtom(getXDisplay(), "_BLACKBOX_STRUCTURE_MESSAGES", False);
- blackbox_notify_startup =
- XInternAtom(getXDisplay(), "_BLACKBOX_NOTIFY_STARTUP", False);
- blackbox_notify_window_add =
- XInternAtom(getXDisplay(), "_BLACKBOX_NOTIFY_WINDOW_ADD", False);
- blackbox_notify_window_del =
- XInternAtom(getXDisplay(), "_BLACKBOX_NOTIFY_WINDOW_DEL", False);
- blackbox_notify_current_workspace =
- XInternAtom(getXDisplay(), "_BLACKBOX_NOTIFY_CURRENT_WORKSPACE", False);
- blackbox_notify_workspace_count =
- XInternAtom(getXDisplay(), "_BLACKBOX_NOTIFY_WORKSPACE_COUNT", False);
- blackbox_notify_window_focus =
- XInternAtom(getXDisplay(), "_BLACKBOX_NOTIFY_WINDOW_FOCUS", False);
- blackbox_notify_window_raise =
- XInternAtom(getXDisplay(), "_BLACKBOX_NOTIFY_WINDOW_RAISE", False);
- blackbox_notify_window_lower =
- XInternAtom(getXDisplay(), "_BLACKBOX_NOTIFY_WINDOW_LOWER", False);
- blackbox_change_workspace =
- XInternAtom(getXDisplay(), "_BLACKBOX_CHANGE_WORKSPACE", False);
- blackbox_change_window_focus =
- XInternAtom(getXDisplay(), "_BLACKBOX_CHANGE_WINDOW_FOCUS", False);
- blackbox_cycle_window_focus =
- XInternAtom(getXDisplay(), "_BLACKBOX_CYCLE_WINDOW_FOCUS", False);
-
-#ifdef NEWWMSPEC
- net_supported = XInternAtom(getXDisplay(), "_NET_SUPPORTED", False);
- net_client_list = XInternAtom(getXDisplay(), "_NET_CLIENT_LIST", False);
- net_client_list_stacking =
- XInternAtom(getXDisplay(), "_NET_CLIENT_LIST_STACKING", False);
- net_number_of_desktops =
- XInternAtom(getXDisplay(), "_NET_NUMBER_OF_DESKTOPS", False);
- net_desktop_geometry =
- XInternAtom(getXDisplay(), "_NET_DESKTOP_GEOMETRY", False);
- net_desktop_viewport =
- XInternAtom(getXDisplay(), "_NET_DESKTOP_VIEWPORT", False);
- net_current_desktop =
- XInternAtom(getXDisplay(), "_NET_CURRENT_DESKTOP", False);
- net_desktop_names = XInternAtom(getXDisplay(), "_NET_DESKTOP_NAMES", False);
- net_active_window = XInternAtom(getXDisplay(), "_NET_ACTIVE_WINDOW", False);
- net_workarea = XInternAtom(getXDisplay(), "_NET_WORKAREA", False);
- net_supporting_wm_check =
- XInternAtom(getXDisplay(), "_NET_SUPPORTING_WM_CHECK", False);
- net_virtual_roots = XInternAtom(getXDisplay(), "_NET_VIRTUAL_ROOTS", False);
- net_close_window = XInternAtom(getXDisplay(), "_NET_CLOSE_WINDOW", False);
- net_wm_moveresize = XInternAtom(getXDisplay(), "_NET_WM_MOVERESIZE", False);
- net_properties = XInternAtom(getXDisplay(), "_NET_PROPERTIES", False);
- net_wm_name = XInternAtom(getXDisplay(), "_NET_WM_NAME", False);
- net_wm_desktop = XInternAtom(getXDisplay(), "_NET_WM_DESKTOP", False);
- net_wm_window_type =
- XInternAtom(getXDisplay(), "_NET_WM_WINDOW_TYPE", False);
- net_wm_state = XInternAtom(getXDisplay(), "_NET_WM_STATE", False);
- net_wm_strut = XInternAtom(getXDisplay(), "_NET_WM_STRUT", False);
- net_wm_icon_geometry =
- XInternAtom(getXDisplay(), "_NET_WM_ICON_GEOMETRY", False);
- net_wm_icon = XInternAtom(getXDisplay(), "_NET_WM_ICON", False);
- net_wm_pid = XInternAtom(getXDisplay(), "_NET_WM_PID", False);
- net_wm_handled_icons =
- XInternAtom(getXDisplay(), "_NET_WM_HANDLED_ICONS", False);
- net_wm_ping = XInternAtom(getXDisplay(), "_NET_WM_PING", False);
-#endif // NEWWMSPEC
-
-#ifdef HAVE_GETPID
- blackbox_pid = XInternAtom(getXDisplay(), "_BLACKBOX_PID", False);
-#endif // HAVE_GETPID
-}
-
-
bool Blackbox::validateWindow(Window window) {
XEvent event;
if (XCheckTypedWindowEvent(getXDisplay(), window, DestroyNotify, &event)) {
#include "BaseDisplay.hh"
#include "Configuration.hh"
#include "Timer.hh"
+#include "XAtom.hh"
#define AttribShaded (1l << 0)
#define AttribMaxHoriz (1l << 1)
BlackboxWindow *focused_window;
BTimer *timer;
Configuration config;
+ XAtom *xatom;
bool no_focus, reconfigure_wait, reread_menu_wait;
Time last_time;
char **argv;
std::string menu_file, rc_file;
- Atom xa_wm_colormap_windows, xa_wm_protocols, xa_wm_state,
- xa_wm_delete_window, xa_wm_take_focus, xa_wm_change_state,
- motif_wm_hints;
-
- // NETAttributes
- Atom blackbox_attributes, blackbox_change_attributes, blackbox_hints;
-#ifdef HAVE_GETPID
- Atom blackbox_pid;
-#endif // HAVE_GETPID
-
- // NETStructureMessages
- Atom blackbox_structure_messages, blackbox_notify_startup,
- blackbox_notify_window_add, blackbox_notify_window_del,
- blackbox_notify_window_focus, blackbox_notify_current_workspace,
- blackbox_notify_workspace_count, blackbox_notify_window_raise,
- blackbox_notify_window_lower;
-
- // message_types for client -> wm messages
- Atom blackbox_change_workspace, blackbox_change_window_focus,
- blackbox_cycle_window_focus;
-
-#ifdef NEWWMSPEC
- // root window properties
- Atom net_supported, net_client_list, net_client_list_stacking,
- net_number_of_desktops, net_desktop_geometry, net_desktop_viewport,
- net_current_desktop, net_desktop_names, net_active_window, net_workarea,
- net_supporting_wm_check, net_virtual_roots;
-
- // root window messages
- Atom net_close_window, net_wm_moveresize;
-
- // application window properties
- Atom net_properties, net_wm_name, net_wm_desktop, net_wm_window_type,
- net_wm_state, net_wm_strut, net_wm_icon_geometry, net_wm_icon, net_wm_pid,
- net_wm_handled_icons;
-
- // application protocols
- Atom net_wm_ping;
-#endif // NEWWMSPEC
-
Blackbox(const Blackbox&);
Blackbox& operator=(const Blackbox&);
void real_rereadMenu(void);
void real_reconfigure(void);
- void init_icccm(void);
-
virtual void process_event(XEvent *);
void removeToolbarSearch(Window window);
void removeSlitSearch(Window window);
+ inline XAtom *getXAtom(void) { return xatom; }
+
inline BlackboxWindow *getFocusedWindow(void) { return focused_window; }
inline Configuration *getConfig() { return &config; }
enum { B_AmericanDate = 1, B_EuropeanDate };
#endif // HAVE_STRFTIME
-#ifdef HAVE_GETPID
- inline Atom getBlackboxPidAtom(void) const { return blackbox_pid; }
-#endif // HAVE_GETPID
-
inline Atom getWMChangeStateAtom(void) const
- { return xa_wm_change_state; }
+ { return xatom->getAtom(XAtom::wm_change_state); }
inline Atom getWMStateAtom(void) const
- { return xa_wm_state; }
+ { return xatom->getAtom(XAtom::wm_state); }
inline Atom getWMDeleteAtom(void) const
- { return xa_wm_delete_window; }
+ { return xatom->getAtom(XAtom::wm_delete_window); }
inline Atom getWMProtocolsAtom(void) const
- { return xa_wm_protocols; }
+ { return xatom->getAtom(XAtom::wm_protocols); }
inline Atom getWMTakeFocusAtom(void) const
- { return xa_wm_take_focus; }
+ { return xatom->getAtom(XAtom::wm_take_focus); }
inline Atom getWMColormapAtom(void) const
- { return xa_wm_colormap_windows; }
+ { return xatom->getAtom(XAtom::wm_colormap_windows); }
inline Atom getMotifWMHintsAtom(void) const
- { return motif_wm_hints; }
+ { return xatom->getAtom(XAtom::motif_wm_hints); }
// this atom is for normal app->WM hints about decorations, stacking,
// starting workspace etc...
inline Atom getBlackboxHintsAtom(void) const
- { return blackbox_hints;}
+ { return xatom->getAtom(XAtom::blackbox_hints); }
// these atoms are for normal app->WM interaction beyond the scope of the
// ICCCM...
inline Atom getBlackboxAttributesAtom(void) const
- { return blackbox_attributes; }
+ { return xatom->getAtom(XAtom::blackbox_attributes); }
inline Atom getBlackboxChangeAttributesAtom(void) const
- { return blackbox_change_attributes; }
+ { return xatom->getAtom(XAtom::blackbox_change_attributes); }
// these atoms are for window->WM interaction, with more control and
// information on window "structure"... common examples are
// notifying apps when windows are raised/lowered... when the user changes
// workspaces... i.e. "pager talk"
inline Atom getBlackboxStructureMessagesAtom(void) const
- { return blackbox_structure_messages; }
+ { return xatom->getAtom(XAtom::blackbox_structure_messages); }
// *Notify* portions of the NETStructureMessages protocol
inline Atom getBlackboxNotifyStartupAtom(void) const
- { return blackbox_notify_startup; }
+ { return xatom->getAtom(XAtom::blackbox_notify_startup); }
inline Atom getBlackboxNotifyWindowAddAtom(void) const
- { return blackbox_notify_window_add; }
+ { return xatom->getAtom(XAtom::blackbox_notify_window_add); }
inline Atom getBlackboxNotifyWindowDelAtom(void) const
- { return blackbox_notify_window_del; }
+ { return xatom->getAtom(XAtom::blackbox_notify_window_del); }
inline Atom getBlackboxNotifyWindowFocusAtom(void) const
- { return blackbox_notify_window_focus; }
+ { return xatom->getAtom(XAtom::blackbox_notify_window_focus); }
inline Atom getBlackboxNotifyCurrentWorkspaceAtom(void) const
- { return blackbox_notify_current_workspace; }
+ { return xatom->getAtom(XAtom::blackbox_notify_current_workspace); }
inline Atom getBlackboxNotifyWorkspaceCountAtom(void) const
- { return blackbox_notify_workspace_count; }
+ { return xatom->getAtom(XAtom::blackbox_notify_workspace_count); }
inline Atom getBlackboxNotifyWindowRaiseAtom(void) const
- { return blackbox_notify_window_raise; }
+ { return xatom->getAtom(XAtom::blackbox_notify_window_raise); }
inline Atom getBlackboxNotifyWindowLowerAtom(void) const
- { return blackbox_notify_window_lower; }
+ { return xatom->getAtom(XAtom::blackbox_notify_window_lower); }
// atoms to change that request changes to the desktop environment during
// runtime... these messages can be sent by any client... as the sending
// client window id is not included in the ClientMessage event...
inline Atom getBlackboxChangeWorkspaceAtom(void) const
- { return blackbox_change_workspace; }
+ { return xatom->getAtom(XAtom::blackbox_change_workspace); }
inline Atom getBlackboxChangeWindowFocusAtom(void) const
- { return blackbox_change_window_focus; }
+ { return xatom->getAtom(XAtom::blackbox_change_window_focus); }
inline Atom getBlackboxCycleWindowFocusAtom(void) const
- { return blackbox_cycle_window_focus; }
-
-#ifdef NEWWMSPEC
- // root window properties
- inline Atom getNETSupportedAtom(void) const
- { return net_supported; }
- inline Atom getNETClientListAtom(void) const
- { return net_client_list; }
- inline Atom getNETClientListStackingAtom(void) const
- { return net_client_list_stacking; }
- inline Atom getNETNumberOfDesktopsAtom(void) const
- { return net_number_of_desktops; }
- inline Atom getNETDesktopGeometryAtom(void) const
- { return net_desktop_geometry; }
- inline Atom getNETDesktopViewportAtom(void) const
- { return net_desktop_viewport; }
- inline Atom getNETCurrentDesktopAtom(void) const
- { return net_current_desktop; }
- inline Atom getNETDesktopNamesAtom(void) const
- { return net_desktop_names; }
- inline Atom getNETActiveWindowAtom(void) const
- { return net_active_window; }
- inline Atom getNETWorkareaAtom(void) const
- { return net_workarea; }
- inline Atom getNETSupportingWMCheckAtom(void) const
- { return net_supporting_wm_check; }
- inline Atom getNETVirtualRootsAtom(void) const
- { return net_virtual_roots; }
-
- // root window messages
- inline Atom getNETCloseWindowAtom(void) const
- { return net_close_window; }
- inline Atom getNETWMMoveResizeAtom(void) const
- { return net_wm_moveresize; }
-
- // application window properties
- inline Atom getNETPropertiesAtom(void) const
- { return net_properties; }
- inline Atom getNETWMNameAtom(void) const
- { return net_wm_name; }
- inline Atom getNETWMDesktopAtom(void) const
- { return net_wm_desktop; }
- inline Atom getNETWMWindowTypeAtom(void) const
- { return net_wm_window_type; }
- inline Atom getNETWMStateAtom(void) const
- { return net_wm_state; }
- inline Atom getNETWMStrutAtom(void) const
- { return net_wm_strut; }
- inline Atom getNETWMIconGeometryAtom(void) const
- { return net_wm_icon_geometry; }
- inline Atom getNETWMIconAtom(void) const
- { return net_wm_icon; }
- inline Atom getNETWMPidAtom(void) const
- { return net_wm_pid; }
- inline Atom getNETWMHandledIconsAtom(void) const
- { return net_wm_handled_icons; }
-
- // application protocols
- inline Atom getNETWMPingAtom(void) const
- { return net_wm_ping; }
-#endif // NEWWMSPEC
+ { return xatom->getAtom(XAtom::blackbox_cycle_window_focus); }
};
projects / chaz / openbox / commitdiff
