openbox_LDADD=../otk/libotk.a @LIBINTL@
openbox_SOURCES= configuration.cc screen.cc openbox.cc \
- util.cc bbwindow.cc workspace.cc xatom.cc blackbox.cc \
+ util.cc bbwindow.cc workspace.cc atom.cc blackbox.cc \
main.cc xeventhandler.cc
MAINTAINERCLEANFILES= Makefile.in
#include <assert.h>
}
-#include "xatom.hh"
+#include "atom.hh"
#include "screen.hh"
#include "util.hh"
+#include "otk/display.hh"
namespace ob {
-XAtom::XAtom(Display *d) {
- _display = d;
-
+OBAtom::OBAtom() {
// make sure asserts fire if there is a problem
memset(_atoms, 0, sizeof(_atoms));
/*
* clean up the class' members
*/
-XAtom::~XAtom() {
+OBAtom::~OBAtom() {
while (!_support_windows.empty()) {
// make sure we aren't fucking with this somewhere
assert(_support_windows.back() != None);
- XDestroyWindow(_display, _support_windows.back());
+ XDestroyWindow(otk::OBDisplay::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);
+Atom OBAtom::create(const char *name) const {
+ return XInternAtom(otk::OBDisplay::display, name, False);
}
/*
* Sets which atoms are supported for NETWM, by Openbox, on the root window.
*/
-void XAtom::setSupported(const otk::ScreenInfo *screen) {
+void OBAtom::setSupported(const otk::ScreenInfo *screen) {
Window root = screen->getRootWindow();
// create the netwm support window
- Window w = XCreateSimpleWindow(_display, root, 0, 0, 1, 1, 0, 0, 0);
+ Window w = XCreateSimpleWindow(otk::OBDisplay::display, root, 0, 0, 1, 1, 0, 0, 0);
assert(w != None);
_support_windows.push_back(w);
* Sets a window property on a window, optionally appending to the existing
* value.
*/
-void XAtom::setValue(Window win, Atom atom, Atom type,
+void OBAtom::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(nelements == 0 || (nelements > 0 && data != (unsigned char *) 0));
assert(size == 8 || size == 16 || size == 32);
- XChangeProperty(_display, win, atom, type, size,
+ XChangeProperty(otk::OBDisplay::display, win, atom, type, size,
(append ? PropModeAppend : PropModeReplace),
data, nelements);
}
/*
* Set a 32-bit property value on a window.
*/
-void XAtom::setValue(Window win, Atoms atom, Atoms type,
+void OBAtom::setValue(Window win, Atoms atom, Atoms type,
unsigned long value) const {
assert(atom >= 0 && atom < NUM_ATOMS);
assert(type >= 0 && type < NUM_ATOMS);
/*
* Set an array of 32-bit properties value on a window.
*/
-void XAtom::setValue(Window win, Atoms atom, Atoms type,
+void OBAtom::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);
/*
* Set an string property value on a window.
*/
-void XAtom::setValue(Window win, Atoms atom, StringType type,
+void OBAtom::setValue(Window win, Atoms atom, StringType type,
const std::string &value) const {
assert(atom >= 0 && atom < NUM_ATOMS);
assert(type >= 0 && type < NUM_STRING_TYPE);
/*
* Set an array of string property values on a window.
*/
-void XAtom::setValue(Window win, Atoms atom, StringType type,
+void OBAtom::setValue(Window win, Atoms atom, StringType type,
const StringVect &strings) const {
assert(atom >= 0 && atom < NUM_ATOMS);
assert(type >= 0 && type < NUM_STRING_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, Atom atom, Atom type,
+bool OBAtom::getValue(Window win, Atom atom, Atom type,
unsigned long &nelements, unsigned char **value,
int size) const {
assert(win != None); assert(atom != None); assert(type != None);
bool ret = False;
// try get the first element
- result = XGetWindowProperty(_display, win, atom, 0l, 1l, False,
+ result = XGetWindowProperty(otk::OBDisplay::display, win, atom, 0l, 1l, False,
AnyPropertyType, &ret_type, &ret_size,
&nelements, &ret_bytes, &c_val);
ret = (result == Success && ret_type == type && ret_size == size &&
int remain = (ret_bytes - 1)/sizeof(long) + 1 + 1;
if (remain > size/8 * (signed)maxread) // dont get more than the max
remain = size/8 * (signed)maxread;
- result = XGetWindowProperty(_display, win, atom, 0l, remain, False, type,
+ result = XGetWindowProperty(otk::OBDisplay::display, win, atom, 0l, remain, False, type,
&ret_type, &ret_size, &nelements, &ret_bytes,
&c_val);
ret = (result == Success && ret_type == type && ret_size == size &&
/*
* Gets a 32-bit property's value from a window.
*/
-bool XAtom::getValue(Window win, Atoms atom, Atoms type,
+bool OBAtom::getValue(Window win, Atoms atom, Atoms type,
unsigned long &nelements,
unsigned long **value) const {
assert(atom >= 0 && atom < NUM_ATOMS);
/*
* Gets a single 32-bit property's value from a window.
*/
-bool XAtom::getValue(Window win, Atoms atom, Atoms type,
+bool OBAtom::getValue(Window win, Atoms atom, Atoms type,
unsigned long &value) const {
assert(atom >= 0 && atom < NUM_ATOMS);
assert(type >= 0 && type < NUM_ATOMS);
/*
* Gets an string property's value from a window.
*/
-bool XAtom::getValue(Window win, Atoms atom, StringType type,
+bool OBAtom::getValue(Window win, Atoms atom, StringType type,
std::string &value) const {
unsigned long n = 1;
StringVect s;
}
-bool XAtom::getValue(Window win, Atoms atom, StringType type,
+bool OBAtom::getValue(Window win, Atoms atom, StringType type,
unsigned long &nelements, StringVect &strings) const {
assert(atom >= 0 && atom < NUM_ATOMS);
assert(type >= 0 && type < NUM_STRING_TYPE);
/*
* Removes a property entirely from a window.
*/
-void XAtom::eraseValue(Window win, Atoms atom) const {
+void OBAtom::eraseValue(Window win, Atoms atom) const {
assert(atom >= 0 && atom < NUM_ATOMS);
- XDeleteProperty(_display, win, _atoms[atom]);
+ XDeleteProperty(otk::OBDisplay::display, win, _atoms[atom]);
}
-void XAtom::sendClientMessage(Window target, Atoms type, Window about,
+void OBAtom::sendClientMessage(Window target, Atoms type, Window about,
long data, long data1, long data2,
long data3, long data4) const {
assert(atom >= 0 && atom < NUM_ATOMS);
e.xclient.data.l[3] = data3;
e.xclient.data.l[4] = data4;
- XSendEvent(_display, target, False,
+ XSendEvent(otk::OBDisplay::display, target, False,
SubstructureRedirectMask | SubstructureNotifyMask,
&e);
}
-// XAtom.h for Openbox
-#ifndef __XAtom_h
-#define __XAtom_h
+// OBAtom.h for Openbox
+#ifndef __atom_hh
+#define __atom_hh
/*! @file xatom.hh
@brief Provides access to atoms on the display
namespace ob {
-class XAtom {
+class OBAtom {
public:
enum Atoms {
// types
private:
typedef std::vector<Window> SupportWindows;
- Display *_display;
// windows used to specify support for NETWM
SupportWindows _support_windows;
Atom _atoms[NUM_ATOMS];
int size) const;
// no copying!!
- XAtom(const XAtom &);
- XAtom& operator=(const XAtom&);
+ OBAtom(const OBAtom &);
+ OBAtom& operator=(const OBAtom&);
public:
typedef std::vector<std::string> StringVect;
- XAtom(Display *d);
- virtual ~XAtom();
+ OBAtom();
+ virtual ~OBAtom();
// setup support on a screen, each screen should call this once in its
// constructor.
}
-#endif // __XAtom_h
+#endif // __atom_hh
void BlackboxWindow::updateStrut(void) {
unsigned long num = 4;
unsigned long *data;
- if (! xatom->getValue(client.window, XAtom::net_wm_strut, XAtom::cardinal,
+ if (! xatom->getValue(client.window, OBAtom::net_wm_strut, OBAtom::cardinal,
num, &data))
return;
unsigned long *val;
unsigned long num = (unsigned) -1;
- if (xatom->getValue(client.window, XAtom::net_wm_window_type, XAtom::atom,
+ if (xatom->getValue(client.window, OBAtom::net_wm_window_type, OBAtom::atom,
num, &val)) {
for (unsigned long i = 0; i < num; ++i) {
- if (val[i] == xatom->getAtom(XAtom::net_wm_window_type_desktop))
+ if (val[i] == xatom->getAtom(OBAtom::net_wm_window_type_desktop))
window_type = Type_Desktop;
- else if (val[i] == xatom->getAtom(XAtom::net_wm_window_type_dock))
+ else if (val[i] == xatom->getAtom(OBAtom::net_wm_window_type_dock))
window_type = Type_Dock;
- else if (val[i] == xatom->getAtom(XAtom::net_wm_window_type_toolbar))
+ else if (val[i] == xatom->getAtom(OBAtom::net_wm_window_type_toolbar))
window_type = Type_Toolbar;
- else if (val[i] == xatom->getAtom(XAtom::net_wm_window_type_menu))
+ else if (val[i] == xatom->getAtom(OBAtom::net_wm_window_type_menu))
window_type = Type_Menu;
- else if (val[i] == xatom->getAtom(XAtom::net_wm_window_type_utility))
+ else if (val[i] == xatom->getAtom(OBAtom::net_wm_window_type_utility))
window_type = Type_Utility;
- else if (val[i] == xatom->getAtom(XAtom::net_wm_window_type_splash))
+ else if (val[i] == xatom->getAtom(OBAtom::net_wm_window_type_splash))
window_type = Type_Splash;
- else if (val[i] == xatom->getAtom(XAtom::net_wm_window_type_dialog))
+ else if (val[i] == xatom->getAtom(OBAtom::net_wm_window_type_dialog))
window_type = Type_Dialog;
- else if (val[i] == xatom->getAtom(XAtom::net_wm_window_type_normal))
+ else if (val[i] == xatom->getAtom(OBAtom::net_wm_window_type_normal))
window_type = Type_Normal;
else if (val[i] ==
- xatom->getAtom(XAtom::kde_net_wm_window_type_override))
+ xatom->getAtom(OBAtom::kde_net_wm_window_type_override))
mwm_decorations = 0; // prevent this window from getting any decor
}
delete val;
void BlackboxWindow::getWMName(void) {
- if (xatom->getValue(client.window, XAtom::net_wm_name,
- XAtom::utf8, client.title) &&
+ if (xatom->getValue(client.window, OBAtom::net_wm_name,
+ OBAtom::utf8, client.title) &&
!client.title.empty()) {
- xatom->eraseValue(client.window, XAtom::net_wm_visible_name);
+ xatom->eraseValue(client.window, OBAtom::net_wm_visible_name);
return;
}
//fall through to using WM_NAME
- if (xatom->getValue(client.window, XAtom::wm_name, XAtom::ansi, client.title)
+ if (xatom->getValue(client.window, OBAtom::wm_name, OBAtom::ansi, client.title)
&& !client.title.empty()) {
- xatom->eraseValue(client.window, XAtom::net_wm_visible_name);
+ xatom->eraseValue(client.window, OBAtom::net_wm_visible_name);
return;
}
// fall back to an internal default
client.title = "Unnamed";
- xatom->setValue(client.window, XAtom::net_wm_visible_name, XAtom::utf8,
+ xatom->setValue(client.window, OBAtom::net_wm_visible_name, OBAtom::utf8,
client.title);
#ifdef DEBUG_WITH_ID
void BlackboxWindow::getWMIconName(void) {
- if (xatom->getValue(client.window, XAtom::net_wm_icon_name,
- XAtom::utf8, client.icon_title) &&
+ if (xatom->getValue(client.window, OBAtom::net_wm_icon_name,
+ OBAtom::utf8, client.icon_title) &&
!client.icon_title.empty()) {
- xatom->eraseValue(client.window, XAtom::net_wm_visible_icon_name);
+ xatom->eraseValue(client.window, OBAtom::net_wm_visible_icon_name);
return;
}
//fall through to using WM_ICON_NAME
- if (xatom->getValue(client.window, XAtom::wm_icon_name, XAtom::ansi,
+ if (xatom->getValue(client.window, OBAtom::wm_icon_name, OBAtom::ansi,
client.icon_title) &&
!client.icon_title.empty()) {
- xatom->eraseValue(client.window, XAtom::net_wm_visible_icon_name);
+ xatom->eraseValue(client.window, OBAtom::net_wm_visible_icon_name);
return;
}
// fall back to using the main name
client.icon_title = client.title;
- xatom->setValue(client.window, XAtom::net_wm_visible_icon_name, XAtom::utf8,
+ xatom->setValue(client.window, OBAtom::net_wm_visible_icon_name, OBAtom::utf8,
client.icon_title);
}
if (XGetWMProtocols(otk::OBDisplay::display, client.window,
&proto, &num_return)) {
for (int i = 0; i < num_return; ++i) {
- if (proto[i] == xatom->getAtom(XAtom::wm_delete_window)) {
+ if (proto[i] == xatom->getAtom(OBAtom::wm_delete_window)) {
decorations |= Decor_Close;
functions |= Func_Close;
- } else if (proto[i] == xatom->getAtom(XAtom::wm_take_focus))
+ } else if (proto[i] == xatom->getAtom(OBAtom::wm_take_focus))
flags.send_focus_message = True;
}
void BlackboxWindow::getNetWMHints(void) {
unsigned long workspace;
- if (xatom->getValue(client.window, XAtom::net_wm_desktop, XAtom::cardinal,
+ if (xatom->getValue(client.window, OBAtom::net_wm_desktop, OBAtom::cardinal,
workspace)) {
if (workspace == 0xffffffff)
flags.stuck = True;
unsigned long *state;
unsigned long num = (unsigned) -1;
- if (xatom->getValue(client.window, XAtom::net_wm_state, XAtom::atom,
+ if (xatom->getValue(client.window, OBAtom::net_wm_state, OBAtom::atom,
num, &state)) {
bool vert = False,
horz = False;
for (unsigned long i = 0; i < num; ++i) {
- if (state[i] == xatom->getAtom(XAtom::net_wm_state_modal))
+ if (state[i] == xatom->getAtom(OBAtom::net_wm_state_modal))
flags.modal = True;
- else if (state[i] == xatom->getAtom(XAtom::net_wm_state_shaded))
+ else if (state[i] == xatom->getAtom(OBAtom::net_wm_state_shaded))
flags.shaded = True;
- else if (state[i] == xatom->getAtom(XAtom::net_wm_state_skip_taskbar))
+ else if (state[i] == xatom->getAtom(OBAtom::net_wm_state_skip_taskbar))
flags.skip_taskbar = True;
- else if (state[i] == xatom->getAtom(XAtom::net_wm_state_skip_pager))
+ else if (state[i] == xatom->getAtom(OBAtom::net_wm_state_skip_pager))
flags.skip_pager = True;
- else if (state[i] == xatom->getAtom(XAtom::net_wm_state_fullscreen))
+ else if (state[i] == xatom->getAtom(OBAtom::net_wm_state_fullscreen))
flags.fullscreen = True;
- else if (state[i] == xatom->getAtom(XAtom::net_wm_state_hidden))
+ else if (state[i] == xatom->getAtom(OBAtom::net_wm_state_hidden))
setState(IconicState);
- else if (state[i] == xatom->getAtom(XAtom::net_wm_state_maximized_vert))
+ else if (state[i] == xatom->getAtom(OBAtom::net_wm_state_maximized_vert))
vert = True;
- else if (state[i] == xatom->getAtom(XAtom::net_wm_state_maximized_horz))
+ else if (state[i] == xatom->getAtom(OBAtom::net_wm_state_maximized_horz))
horz = True;
}
if (vert && horz)
MwmHints *mwm_hint;
num = PropMwmHintsElements;
- if (! xatom->getValue(client.window, XAtom::motif_wm_hints,
- XAtom::motif_wm_hints, num,
+ if (! xatom->getValue(client.window, OBAtom::motif_wm_hints,
+ OBAtom::motif_wm_hints, num,
(unsigned long **)&mwm_hint))
return;
if (num < PropMwmHintsElements) {
BlackboxHints *blackbox_hint;
num = PropBlackboxHintsElements;
- if (! xatom->getValue(client.window, XAtom::blackbox_hints,
- XAtom::blackbox_hints, num,
+ if (! xatom->getValue(client.window, OBAtom::blackbox_hints,
+ OBAtom::blackbox_hints, num,
(unsigned long **)&blackbox_hint))
return False;
if (num < PropBlackboxHintsElements) {
if (flags.send_focus_message) {
XEvent ce;
ce.xclient.type = ClientMessage;
- ce.xclient.message_type = xatom->getAtom(XAtom::wm_protocols);
+ ce.xclient.message_type = xatom->getAtom(OBAtom::wm_protocols);
ce.xclient.display = otk::OBDisplay::display;
ce.xclient.window = client.window;
ce.xclient.format = 32;
- ce.xclient.data.l[0] = xatom->getAtom(XAtom::wm_take_focus);
+ ce.xclient.data.l[0] = xatom->getAtom(OBAtom::wm_take_focus);
ce.xclient.data.l[1] = blackbox->getLastTime();
ce.xclient.data.l[2] = 0l;
ce.xclient.data.l[3] = 0l;
XEvent ce;
ce.xclient.type = ClientMessage;
- ce.xclient.message_type = xatom->getAtom(XAtom::wm_protocols);
+ ce.xclient.message_type = xatom->getAtom(OBAtom::wm_protocols);
ce.xclient.display = otk::OBDisplay::display;
ce.xclient.window = client.window;
ce.xclient.format = 32;
- ce.xclient.data.l[0] = xatom->getAtom(XAtom::wm_delete_window);
+ ce.xclient.data.l[0] = xatom->getAtom(OBAtom::wm_delete_window);
ce.xclient.data.l[1] = CurrentTime;
ce.xclient.data.l[2] = 0l;
ce.xclient.data.l[3] = 0l;
*/
n = 0xffffffff;
}
- xatom->setValue(client.window, XAtom::net_wm_desktop, XAtom::cardinal, n);
+ xatom->setValue(client.window, OBAtom::net_wm_desktop, OBAtom::cardinal, n);
}
screen->reassociateWindow(this, BSENTINEL, True);
// temporary fix since sticky windows suck. set the hint to what we
// actually hold in our data.
- xatom->setValue(client.window, XAtom::net_wm_desktop, XAtom::cardinal,
+ xatom->setValue(client.window, OBAtom::net_wm_desktop, OBAtom::cardinal,
blackbox_attrib.workspace);
setState(current_state);
// temporary fix since sticky windows suck. set the hint to a different
// value than that contained in the class' data.
- xatom->setValue(client.window, XAtom::net_wm_desktop, XAtom::cardinal,
+ xatom->setValue(client.window, OBAtom::net_wm_desktop, OBAtom::cardinal,
0xffffffff);
for (unsigned int i = 0; i < screen->getNumberOfWorkspaces(); ++i)
Atom actions[7];
int num = 0;
- actions[num++] = xatom->getAtom(XAtom::net_wm_action_shade);
- actions[num++] = xatom->getAtom(XAtom::net_wm_action_change_desktop);
- actions[num++] = xatom->getAtom(XAtom::net_wm_action_close);
+ actions[num++] = xatom->getAtom(OBAtom::net_wm_action_shade);
+ actions[num++] = xatom->getAtom(OBAtom::net_wm_action_change_desktop);
+ actions[num++] = xatom->getAtom(OBAtom::net_wm_action_close);
if (functions & Func_Move)
- actions[num++] = xatom->getAtom(XAtom::net_wm_action_move);
+ actions[num++] = xatom->getAtom(OBAtom::net_wm_action_move);
if (functions & Func_Resize)
- actions[num++] = xatom->getAtom(XAtom::net_wm_action_resize);
+ actions[num++] = xatom->getAtom(OBAtom::net_wm_action_resize);
if (functions & Func_Maximize) {
- actions[num++] = xatom->getAtom(XAtom::net_wm_action_maximize_horz);
- actions[num++] = xatom->getAtom(XAtom::net_wm_action_maximize_vert);
+ actions[num++] = xatom->getAtom(OBAtom::net_wm_action_maximize_horz);
+ actions[num++] = xatom->getAtom(OBAtom::net_wm_action_maximize_vert);
}
- xatom->setValue(client.window, XAtom::net_wm_allowed_actions, XAtom::atom,
+ xatom->setValue(client.window, OBAtom::net_wm_allowed_actions, OBAtom::atom,
actions, num);
}
unsigned long state[2];
state[0] = current_state;
state[1] = None;
- xatom->setValue(client.window, XAtom::wm_state, XAtom::wm_state, state, 2);
+ xatom->setValue(client.window, OBAtom::wm_state, OBAtom::wm_state, state, 2);
- xatom->setValue(client.window, XAtom::blackbox_attributes,
- XAtom::blackbox_attributes, (unsigned long *)&blackbox_attrib,
+ xatom->setValue(client.window, OBAtom::blackbox_attributes,
+ OBAtom::blackbox_attributes, (unsigned long *)&blackbox_attrib,
PropBlackboxAttributesElements);
Atom netstate[8];
int num = 0;
if (flags.modal)
- netstate[num++] = xatom->getAtom(XAtom::net_wm_state_modal);
+ netstate[num++] = xatom->getAtom(OBAtom::net_wm_state_modal);
if (flags.shaded)
- netstate[num++] = xatom->getAtom(XAtom::net_wm_state_shaded);
+ netstate[num++] = xatom->getAtom(OBAtom::net_wm_state_shaded);
if (flags.iconic)
- netstate[num++] = xatom->getAtom(XAtom::net_wm_state_hidden);
+ netstate[num++] = xatom->getAtom(OBAtom::net_wm_state_hidden);
if (flags.skip_taskbar)
- netstate[num++] = xatom->getAtom(XAtom::net_wm_state_skip_taskbar);
+ netstate[num++] = xatom->getAtom(OBAtom::net_wm_state_skip_taskbar);
if (flags.skip_pager)
- netstate[num++] = xatom->getAtom(XAtom::net_wm_state_skip_pager);
+ netstate[num++] = xatom->getAtom(OBAtom::net_wm_state_skip_pager);
if (flags.fullscreen)
- netstate[num++] = xatom->getAtom(XAtom::net_wm_state_fullscreen);
+ netstate[num++] = xatom->getAtom(OBAtom::net_wm_state_fullscreen);
if (flags.maximized == 1 || flags.maximized == 2)
- netstate[num++] = xatom->getAtom(XAtom::net_wm_state_maximized_vert);
+ netstate[num++] = xatom->getAtom(OBAtom::net_wm_state_maximized_vert);
if (flags.maximized == 1 || flags.maximized == 3)
- netstate[num++] = xatom->getAtom(XAtom::net_wm_state_maximized_horz);
- xatom->setValue(client.window, XAtom::net_wm_state, XAtom::atom,
+ netstate[num++] = xatom->getAtom(OBAtom::net_wm_state_maximized_horz);
+ xatom->setValue(client.window, OBAtom::net_wm_state, OBAtom::atom,
netstate, num);
}
bool BlackboxWindow::getState(void) {
- bool ret = xatom->getValue(client.window, XAtom::wm_state, XAtom::wm_state,
+ bool ret = xatom->getValue(client.window, OBAtom::wm_state, OBAtom::wm_state,
current_state);
if (! ret) current_state = 0;
return ret;
void BlackboxWindow::restoreAttributes(void) {
unsigned long num = PropBlackboxAttributesElements;
BlackboxAttributes *net;
- if (! xatom->getValue(client.window, XAtom::blackbox_attributes,
- XAtom::blackbox_attributes, num,
+ if (! xatom->getValue(client.window, OBAtom::blackbox_attributes,
+ OBAtom::blackbox_attributes, num,
(unsigned long **)&net))
return;
if (num < PropBlackboxAttributesElements) {
if (flags.iconic) screen->propagateWindowName(this);
break;
- case XAtom::net_wm_name:
+ case OBAtom::net_wm_name:
case XA_WM_NAME:
getWMName();
}
default:
- if (pe->atom == xatom->getAtom(XAtom::wm_protocols)) {
+ if (pe->atom == xatom->getAtom(OBAtom::wm_protocols)) {
getWMProtocols();
if ((decorations & Decor_Close) && (! frame.close_button)) {
XMapSubwindows(otk::OBDisplay::display, frame.title);
}
}
- } else if (pe->atom == xatom->getAtom(XAtom::net_wm_strut)) {
+ } else if (pe->atom == xatom->getAtom(OBAtom::net_wm_strut)) {
updateStrut();
}
// erase the netwm stuff that we read when a window maps, so that it
// doesn't persist between mappings.
// (these are the ones read in getNetWMFlags().)
- xatom->eraseValue(client.window, XAtom::net_wm_desktop);
- xatom->eraseValue(client.window, XAtom::net_wm_state);
+ xatom->eraseValue(client.window, OBAtom::net_wm_desktop);
+ xatom->eraseValue(client.window, OBAtom::net_wm_state);
restoreGravity(client.rect);
private:
Blackbox *blackbox;
BScreen *screen;
- XAtom *xatom;
+ OBAtom *xatom;
otk::OBTimer *timer;
BlackboxAttributes blackbox_attrib;
#include "util.hh"
#include "bbwindow.hh"
#include "workspace.hh"
-#include "xatom.hh"
+#include "atom.hh"
namespace ob {
load_rc();
- xatom = new XAtom(otk::OBDisplay::display);
+ xatom = new OBAtom();
cursor.session = XCreateFontCursor(otk::OBDisplay::display, XC_left_ptr);
cursor.move = XCreateFontCursor(otk::OBDisplay::display, XC_fleur);
case ClientMessage: {
if (e->xclient.format == 32) {
- if (e->xclient.message_type == xatom->getAtom(XAtom::wm_change_state)) {
+ if (e->xclient.message_type == xatom->getAtom(OBAtom::wm_change_state)) {
// WM_CHANGE_STATE message
BlackboxWindow *win = searchWindow(e->xclient.window);
if (! win || ! win->validateClient()) return;
if (e->xclient.data.l[0] == NormalState)
win->deiconify();
} else if (e->xclient.message_type ==
- xatom->getAtom(XAtom::blackbox_change_workspace) ||
+ xatom->getAtom(OBAtom::blackbox_change_workspace) ||
e->xclient.message_type ==
- xatom->getAtom(XAtom::net_current_desktop)) {
+ xatom->getAtom(OBAtom::net_current_desktop)) {
// NET_CURRENT_DESKTOP message
BScreen *screen = searchScreen(e->xclient.window);
if (screen && workspace < screen->getWorkspaceCount())
screen->changeWorkspaceID(workspace);
} else if (e->xclient.message_type ==
- xatom->getAtom(XAtom::blackbox_change_window_focus)) {
+ xatom->getAtom(OBAtom::blackbox_change_window_focus)) {
// TEMP HACK TO KEEP BBKEYS WORKING
BlackboxWindow *win = searchWindow(e->xclient.window);
if (win && win->isVisible() && win->setInputFocus())
win->installColormap(True);
} else if (e->xclient.message_type ==
- xatom->getAtom(XAtom::net_active_window)) {
+ xatom->getAtom(OBAtom::net_active_window)) {
// NET_ACTIVE_WINDOW
BlackboxWindow *win = searchWindow(e->xclient.window);
}
}
} else if (e->xclient.message_type ==
- xatom->getAtom(XAtom::blackbox_cycle_window_focus)) {
+ xatom->getAtom(OBAtom::blackbox_cycle_window_focus)) {
// BLACKBOX_CYCLE_WINDOW_FOCUS
BScreen *screen = searchScreen(e->xclient.window);
screen->nextFocus();
}
} else if (e->xclient.message_type ==
- xatom->getAtom(XAtom::net_wm_desktop)) {
+ xatom->getAtom(OBAtom::net_wm_desktop)) {
// NET_WM_DESKTOP
BlackboxWindow *win = searchWindow(e->xclient.window);
}
}
} else if (e->xclient.message_type ==
- xatom->getAtom(XAtom::blackbox_change_attributes)) {
+ xatom->getAtom(OBAtom::blackbox_change_attributes)) {
// BLACKBOX_CHANGE_ATTRIBUTES
BlackboxWindow *win = searchWindow(e->xclient.window);
win->changeBlackboxHints(&net);
}
} else if (e->xclient.message_type ==
- xatom->getAtom(XAtom::net_number_of_desktops)) {
+ xatom->getAtom(OBAtom::net_number_of_desktops)) {
// NET_NUMBER_OF_DESKTOPS
BScreen *screen = searchScreen(e->xclient.window);
if (e->xclient.data.l[0] > 0)
screen->changeWorkspaceCount((unsigned) e->xclient.data.l[0]);
} else if (e->xclient.message_type ==
- xatom->getAtom(XAtom::net_close_window)) {
+ xatom->getAtom(OBAtom::net_close_window)) {
// NET_CLOSE_WINDOW
BlackboxWindow *win = searchWindow(e->xclient.window);
if (win && win->validateClient())
win->close(); // could this be smarter?
} else if (e->xclient.message_type ==
- xatom->getAtom(XAtom::net_wm_moveresize)) {
+ xatom->getAtom(OBAtom::net_wm_moveresize)) {
// NET_WM_MOVERESIZE
BlackboxWindow *win = searchWindow(e->xclient.window);
if (win && win->validateClient()) {
int x_root = e->xclient.data.l[0],
y_root = e->xclient.data.l[1];
if ((Atom) e->xclient.data.l[2] ==
- xatom->getAtom(XAtom::net_wm_moveresize_move)) {
+ xatom->getAtom(OBAtom::net_wm_moveresize_move)) {
win->beginMove(x_root, y_root);
} else {
if ((Atom) e->xclient.data.l[2] ==
- xatom->getAtom(XAtom::net_wm_moveresize_size_topleft))
+ xatom->getAtom(OBAtom::net_wm_moveresize_size_topleft))
win->beginResize(x_root, y_root, BlackboxWindow::TopLeft);
else if ((Atom) e->xclient.data.l[2] ==
- xatom->getAtom(XAtom::net_wm_moveresize_size_topright))
+ xatom->getAtom(OBAtom::net_wm_moveresize_size_topright))
win->beginResize(x_root, y_root, BlackboxWindow::TopRight);
else if ((Atom) e->xclient.data.l[2] ==
- xatom->getAtom(XAtom::net_wm_moveresize_size_bottomleft))
+ xatom->getAtom(OBAtom::net_wm_moveresize_size_bottomleft))
win->beginResize(x_root, y_root, BlackboxWindow::BottomLeft);
else if ((Atom) e->xclient.data.l[2] ==
- xatom->getAtom(XAtom::net_wm_moveresize_size_bottomright))
+ xatom->getAtom(OBAtom::net_wm_moveresize_size_bottomright))
win->beginResize(x_root, y_root, BlackboxWindow::BottomRight);
}
}
} else if (e->xclient.message_type ==
- xatom->getAtom(XAtom::net_wm_state)) {
+ xatom->getAtom(OBAtom::net_wm_state)) {
// NET_WM_STATE
BlackboxWindow *win = searchWindow(e->xclient.window);
if (win && win->validateClient()) {
if ((Atom) e->xclient.data.l[0] == 1) {
// ADD
- if (state[i] == xatom->getAtom(XAtom::net_wm_state_modal)) {
+ if (state[i] == xatom->getAtom(OBAtom::net_wm_state_modal)) {
win->setModal(True);
} else if (state[i] ==
- xatom->getAtom(XAtom::net_wm_state_maximized_vert)) {
+ xatom->getAtom(OBAtom::net_wm_state_maximized_vert)) {
if (win->isMaximizedHoriz()) {
win->maximize(0); // unmaximize
win->maximize(1); // full
win->maximize(2); // vert
}
} else if (state[i] ==
- xatom->getAtom(XAtom::net_wm_state_maximized_horz)) {
+ xatom->getAtom(OBAtom::net_wm_state_maximized_horz)) {
if (win->isMaximizedVert()) {
win->maximize(0); // unmaximize
win->maximize(1); // full
win->maximize(3); // horiz
}
} else if (state[i] ==
- xatom->getAtom(XAtom::net_wm_state_shaded)) {
+ xatom->getAtom(OBAtom::net_wm_state_shaded)) {
if (! win->isShaded())
win->shade();
} else if (state[i] ==
- xatom->getAtom(XAtom::net_wm_state_skip_taskbar)) {
+ xatom->getAtom(OBAtom::net_wm_state_skip_taskbar)) {
win->setSkipTaskbar(True);
} else if (state[i] ==
- xatom->getAtom(XAtom::net_wm_state_skip_pager)) {
+ xatom->getAtom(OBAtom::net_wm_state_skip_pager)) {
win->setSkipPager(True);
} else if (state[i] ==
- xatom->getAtom(XAtom::net_wm_state_fullscreen)) {
+ xatom->getAtom(OBAtom::net_wm_state_fullscreen)) {
win->setFullscreen(True);
}
} else if (action == 0) {
// REMOVE
- if (state[i] == xatom->getAtom(XAtom::net_wm_state_modal)) {
+ if (state[i] == xatom->getAtom(OBAtom::net_wm_state_modal)) {
win->setModal(False);
} else if (state[i] ==
- xatom->getAtom(XAtom::net_wm_state_maximized_vert)) {
+ xatom->getAtom(OBAtom::net_wm_state_maximized_vert)) {
if (win->isMaximizedFull()) {
win->maximize(0); // unmaximize
win->maximize(3); // horiz
win->maximize(0); // unmaximize
}
} else if (state[i] ==
- xatom->getAtom(XAtom::net_wm_state_maximized_horz)) {
+ xatom->getAtom(OBAtom::net_wm_state_maximized_horz)) {
if (win->isMaximizedFull()) {
win->maximize(0); // unmaximize
win->maximize(2); // vert
win->maximize(0); // unmaximize
}
} else if (state[i] ==
- xatom->getAtom(XAtom::net_wm_state_shaded)) {
+ xatom->getAtom(OBAtom::net_wm_state_shaded)) {
if (win->isShaded())
win->shade();
} else if (state[i] ==
- xatom->getAtom(XAtom::net_wm_state_skip_taskbar)) {
+ xatom->getAtom(OBAtom::net_wm_state_skip_taskbar)) {
win->setSkipTaskbar(False);
} else if (state[i] ==
- xatom->getAtom(XAtom::net_wm_state_skip_pager)) {
+ xatom->getAtom(OBAtom::net_wm_state_skip_pager)) {
win->setSkipPager(False);
} else if (state[i] ==
- xatom->getAtom(XAtom::net_wm_state_fullscreen)) {
+ xatom->getAtom(OBAtom::net_wm_state_fullscreen)) {
win->setFullscreen(False);
}
} else if (action == 2) {
// TOGGLE
- if (state[i] == xatom->getAtom(XAtom::net_wm_state_modal)) {
+ if (state[i] == xatom->getAtom(OBAtom::net_wm_state_modal)) {
win->setModal(! win->isModal());
} else if (state[i] ==
- xatom->getAtom(XAtom::net_wm_state_maximized_vert)) {
+ xatom->getAtom(OBAtom::net_wm_state_maximized_vert)) {
if (win->isMaximizedFull()) {
win->maximize(0); // unmaximize
win->maximize(3); // horiz
win->maximize(2); // vert
}
} else if (state[i] ==
- xatom->getAtom(XAtom::net_wm_state_maximized_horz)) {
+ xatom->getAtom(OBAtom::net_wm_state_maximized_horz)) {
if (win->isMaximizedFull()) {
win->maximize(0); // unmaximize
win->maximize(2); // vert
win->maximize(3); // horiz
}
} else if (state[i] ==
- xatom->getAtom(XAtom::net_wm_state_shaded)) {
+ xatom->getAtom(OBAtom::net_wm_state_shaded)) {
win->shade();
} else if (state[i] ==
- xatom->getAtom(XAtom::net_wm_state_skip_taskbar)) {
+ xatom->getAtom(OBAtom::net_wm_state_skip_taskbar)) {
win->setSkipTaskbar(! win->skipTaskbar());
} else if (state[i] ==
- xatom->getAtom(XAtom::net_wm_state_skip_pager)) {
+ xatom->getAtom(OBAtom::net_wm_state_skip_pager)) {
win->setSkipPager(! win->skipPager());
} else if (state[i] ==
- xatom->getAtom(XAtom::net_wm_state_fullscreen)) {
+ xatom->getAtom(OBAtom::net_wm_state_fullscreen)) {
win->setFullscreen(! win->isFullscreen());
}
}
#include "openbox.hh"
#include "configuration.hh"
#include "timer.hh"
-#include "xatom.hh"
+#include "atom.hh"
#define AttribShaded (1l << 0)
#define AttribMaxHoriz (1l << 1)
BlackboxWindow *focused_window, *changing_window;
otk::OBTimer *timer;
Configuration config;
- XAtom *xatom;
+ OBAtom *xatom;
bool no_focus, reconfigure_wait;
Time last_time;
void removeWindowSearch(Window window);
void removeGroupSearch(Window window);
- inline XAtom *getXAtom(void) { return xatom; }
+ inline OBAtom *getXAtom(void) { return xatom; }
inline BlackboxWindow *getFocusedWindow(void) { return focused_window; }
inline BlackboxWindow *getChangingWindow(void) { return changing_window; }
#include "otk/screeninfo.hh"
#include "otk/timerqueuemanager.hh"
#include "xeventhandler.hh"
+#include "atom.hh"
namespace ob {
//! The main function of the Openbox class
/*!
This function should be called after instantiating the Openbox class.
- Loops indefinately while handling all events in the application.
+ It loops indefinately while handling all events for the application.
The Openbox::shutdown method will cause this function to exit.
*/
void eventLoop();
#include "bbwindow.hh"
#include "workspace.hh"
#include "util.hh"
-#include "xatom.hh"
+#include "atom.hh"
#ifndef FONT_ELEMENT_SIZE
#define FONT_ELEMENT_SIZE 50
#endif // HAVE_GETPID
unsigned long geometry[] = { getWidth(),
getHeight()};
- xatom->setValue(getRootWindow(), XAtom::net_desktop_geometry,
- XAtom::cardinal, geometry, 2);
+ xatom->setValue(getRootWindow(), OBAtom::net_desktop_geometry,
+ OBAtom::cardinal, geometry, 2);
unsigned long viewport[] = {0,0};
- xatom->setValue(getRootWindow(), XAtom::net_desktop_viewport,
- XAtom::cardinal, viewport, 2);
+ xatom->setValue(getRootWindow(), OBAtom::net_desktop_viewport,
+ OBAtom::cardinal, viewport, 2);
XDefineCursor(otk::OBDisplay::display, getRootWindow(),
current_workspace = workspacesList.front();
- xatom->setValue(getRootWindow(), XAtom::net_current_desktop,
- XAtom::cardinal, 0); //first workspace
+ xatom->setValue(getRootWindow(), OBAtom::net_current_desktop,
+ OBAtom::cardinal, 0); //first workspace
raiseWindows(0, 0); // this also initializes the empty stacking list
resource.col_direction = TopBottom;
if (config->getValue(screenstr + "workspaceNames", s)) {
- XAtom::StringVect workspaceNames;
+ OBAtom::StringVect workspaceNames;
string::const_iterator it = s.begin(), end = s.end();
while(1) {
++it;
}
- xatom->setValue(getRootWindow(), XAtom::net_desktop_names, XAtom::utf8,
+ xatom->setValue(getRootWindow(), OBAtom::net_desktop_names, OBAtom::utf8,
workspaceNames);
}
current_workspace = getWorkspace(id);
- xatom->setValue(getRootWindow(), XAtom::net_current_desktop,
- XAtom::cardinal, id);
+ xatom->setValue(getRootWindow(), OBAtom::net_current_desktop,
+ OBAtom::cardinal, id);
current_workspace->showAll();
const BlackboxWindowList::iterator end = windowList.end();
for (; it != end; ++it, ++win_it)
*win_it = (*it)->getClientWindow();
- xatom->setValue(getRootWindow(), XAtom::net_client_list, XAtom::window,
+ xatom->setValue(getRootWindow(), OBAtom::net_client_list, OBAtom::window,
windows, windowList.size());
delete [] windows;
} else
- xatom->setValue(getRootWindow(), XAtom::net_client_list, XAtom::window,
+ xatom->setValue(getRootWindow(), OBAtom::net_client_list, OBAtom::window,
0, 0);
updateStackingList();
end = stack_order.end();
for (; it != end; ++it, ++win_it)
*win_it = (*it)->getClientWindow();
- xatom->setValue(getRootWindow(), XAtom::net_client_list_stacking,
- XAtom::window, windows, stack_order.size());
+ xatom->setValue(getRootWindow(), OBAtom::net_client_list_stacking,
+ OBAtom::window, windows, stack_order.size());
delete [] windows;
} else
- xatom->setValue(getRootWindow(), XAtom::net_client_list_stacking,
- XAtom::window, 0, 0);
+ xatom->setValue(getRootWindow(), OBAtom::net_client_list_stacking,
+ OBAtom::window, 0, 0);
}
XSelectInput(otk::OBDisplay::display, window, StructureNotifyMask);
systrayWindowList.push_back(window);
- xatom->setValue(getRootWindow(), XAtom::kde_net_system_tray_windows,
- XAtom::window,
+ xatom->setValue(getRootWindow(), OBAtom::kde_net_system_tray_windows,
+ OBAtom::window,
&systrayWindowList[0], systrayWindowList.size());
blackbox->saveSystrayWindowSearch(window, this);
for (; it != end; ++it)
if (*it == window) {
systrayWindowList.erase(it);
- xatom->setValue(getRootWindow(), XAtom::kde_net_system_tray_windows,
- XAtom::window,
+ xatom->setValue(getRootWindow(), OBAtom::kde_net_system_tray_windows,
+ OBAtom::window,
&systrayWindowList[0], systrayWindowList.size());
blackbox->removeSystrayWindowSearch(window);
XSelectInput(otk::OBDisplay::display, window, NoEventMask);
void BScreen::manageWindow(Window w) {
// is the window a KDE systray window?
Window systray;
- if (xatom->getValue(w, XAtom::kde_net_wm_system_tray_window_for,
- XAtom::window, systray) && systray != None) {
+ if (xatom->getValue(w, OBAtom::kde_net_wm_system_tray_window_for,
+ OBAtom::window, systray) && systray != None) {
addSystrayWindow(w);
return;
}
// is the window a KDE systray window?
Window systray;
if (xatom->getValue(w->getClientWindow(),
- XAtom::kde_net_wm_system_tray_window_for,
- XAtom::window, systray) && systray != None) {
+ OBAtom::kde_net_wm_system_tray_window_for,
+ OBAtom::window, systray) && systray != None) {
removeSystrayWindow(w->getClientWindow());
return;
}
dims[(i * 4) + 2] = area.width();
dims[(i * 4) + 3] = area.height();
}
- xatom->setValue(getRootWindow(), XAtom::net_workarea, XAtom::cardinal,
+ xatom->setValue(getRootWindow(), OBAtom::net_workarea, OBAtom::cardinal,
dims, 4 * workspacesList.size());
delete [] dims;
} else
- xatom->setValue(getRootWindow(), XAtom::net_workarea, XAtom::cardinal,
+ xatom->setValue(getRootWindow(), OBAtom::net_workarea, OBAtom::cardinal,
0, 0);
}
void BScreen::updateNetizenWorkspaceCount(void) {
- xatom->setValue(getRootWindow(), XAtom::net_number_of_desktops,
- XAtom::cardinal, workspacesList.size());
+ xatom->setValue(getRootWindow(), OBAtom::net_number_of_desktops,
+ OBAtom::cardinal, workspacesList.size());
updateWorkArea();
}
Window f = ((blackbox->getFocusedWindow()) ?
blackbox->getFocusedWindow()->getClientWindow() : None);
- xatom->setValue(getRootWindow(), XAtom::net_active_window,
- XAtom::window, f);
+ xatom->setValue(getRootWindow(), OBAtom::net_active_window,
+ OBAtom::window, f);
}
void BScreen::propertyNotifyEvent(const XPropertyEvent *pe) {
- if (pe->atom == xatom->getAtom(XAtom::net_desktop_names)) {
+ if (pe->atom == xatom->getAtom(OBAtom::net_desktop_names)) {
// _NET_WM_DESKTOP_NAMES
WorkspaceList::iterator it = workspacesList.begin();
const WorkspaceList::iterator end = workspacesList.end();
namespace ob {
-class XAtom;
+class OBAtom;
struct Strut;
enum TextJustify { LeftJustify = 1, RightJustify, CenterJustify };
Blackbox *blackbox;
otk::BImageControl *image_control;
Configuration *config;
- XAtom *xatom;
+ OBAtom *xatom;
BlackboxWindowList iconList, windowList;
#include "util.hh"
#include "bbwindow.hh"
#include "workspace.hh"
-#include "xatom.hh"
+#include "atom.hh"
namespace ob {
void Workspace::readName(void) {
- XAtom::StringVect namesList;
+ OBAtom::StringVect namesList;
unsigned long numnames = id + 1;
// attempt to get from the _NET_WM_DESKTOP_NAMES property
- if (xatom->getValue(screen->getRootWindow(), XAtom::net_desktop_names,
- XAtom::utf8, numnames, namesList) &&
+ if (xatom->getValue(screen->getRootWindow(), OBAtom::net_desktop_names,
+ OBAtom::utf8, numnames, namesList) &&
namesList.size() > id) {
name = namesList[id];
void Workspace::setName(const string& new_name) {
// set the _NET_WM_DESKTOP_NAMES property with the new name
- XAtom::StringVect namesList;
+ OBAtom::StringVect namesList;
unsigned long numnames = (unsigned) -1;
- if (xatom->getValue(screen->getRootWindow(), XAtom::net_desktop_names,
- XAtom::utf8, numnames, namesList) &&
+ if (xatom->getValue(screen->getRootWindow(), OBAtom::net_desktop_names,
+ OBAtom::utf8, numnames, namesList) &&
namesList.size() > id)
namesList[id] = new_name;
else
namesList.push_back(new_name);
- xatom->setValue(screen->getRootWindow(), XAtom::net_desktop_names,
- XAtom::utf8, namesList);
+ xatom->setValue(screen->getRootWindow(), OBAtom::net_desktop_names,
+ OBAtom::utf8, namesList);
}
#include <string>
#include <vector>
-#include "xatom.hh"
+#include "atom.hh"
namespace ob {
private:
BScreen *screen;
BlackboxWindow *lastfocus;
- XAtom *xatom;
+ OBAtom *xatom;
BlackboxWindowList stackingList, windowList;