From: Dana Jansens Date: Sat, 2 Feb 2008 16:36:17 +0000 (-0500) Subject: Merge branch 'backport' into work X-Git-Url: https://git.dogcows.com/gitweb?a=commitdiff_plain;h=0dc7eca4cdfff6425e19a0bace0f9ae8834d04e8;p=chaz%2Fopenbox Merge branch 'backport' into work Conflicts: openbox/client.c openbox/event.c openbox/mouse.c openbox/openbox.c openbox/prop.c openbox/prop.h openbox/screen.c parser/parse.c parser/parse.h --- 0dc7eca4cdfff6425e19a0bace0f9ae8834d04e8 diff --cc obt/prop.c index 6eedce5d,00000000..89d3950d mode 100644,000000..100644 --- a/obt/prop.c +++ b/obt/prop.c @@@ -1,494 -1,0 +1,495 @@@ +/* -*- indent-tabs-mode: nil; tab-width: 4; c-basic-offset: 4; -*- + + obt/prop.c for the Openbox window manager + Copyright (c) 2006 Mikael Magnusson + Copyright (c) 2003-2007 Dana Jansens + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + See the COPYING file for a copy of the GNU General Public License. +*/ + +#include "obt/prop.h" +#include "obt/display.h" + +#include +#ifdef HAVE_STRING_H +# include +#endif + +Atom prop_atoms[OBT_PROP_NUM_ATOMS]; +gboolean prop_started = FALSE; + +#define CREATE_NAME(var, name) (prop_atoms[OBT_PROP_##var] = \ + XInternAtom((obt_display), (name), FALSE)) +#define CREATE(var) CREATE_NAME(var, #var) +#define CREATE_(var) CREATE_NAME(var, "_" #var) + +void obt_prop_startup() +{ + if (prop_started) return; + prop_started = TRUE; + + g_assert(obt_display); + + CREATE(CARDINAL); + CREATE(WINDOW); + CREATE(PIXMAP); + CREATE(ATOM); + CREATE(STRING); + CREATE_NAME(UTF8, "UTF8_STRING"); + + CREATE(MANAGER); + + CREATE(WM_COLORMAP_WINDOWS); + CREATE(WM_PROTOCOLS); + CREATE(WM_STATE); + CREATE(WM_CHANGE_STATE); + CREATE(WM_DELETE_WINDOW); + CREATE(WM_TAKE_FOCUS); + CREATE(WM_NAME); + CREATE(WM_ICON_NAME); + CREATE(WM_CLASS); + CREATE(WM_WINDOW_ROLE); + CREATE(WM_CLIENT_MACHINE); + CREATE(WM_COMMAND); + CREATE(WM_CLIENT_LEADER); + CREATE_(MOTIF_WM_HINTS); + + CREATE(SM_CLIENT_ID); + + CREATE_(NET_WM_FULL_PLACEMENT); + + CREATE_(NET_SUPPORTED); + CREATE_(NET_CLIENT_LIST); + CREATE_(NET_CLIENT_LIST_STACKING); + CREATE_(NET_NUMBER_OF_DESKTOPS); + CREATE_(NET_DESKTOP_GEOMETRY); + CREATE_(NET_DESKTOP_VIEWPORT); + CREATE_(NET_CURRENT_DESKTOP); + CREATE_(NET_DESKTOP_NAMES); + CREATE_(NET_ACTIVE_WINDOW); +/* CREATE_(NET_RESTACK_WINDOW);*/ + CREATE_(NET_WORKAREA); + CREATE_(NET_SUPPORTING_WM_CHECK); + CREATE_(NET_DESKTOP_LAYOUT); + CREATE_(NET_SHOWING_DESKTOP); + + CREATE_(NET_CLOSE_WINDOW); + CREATE_(NET_WM_MOVERESIZE); + CREATE_(NET_MOVERESIZE_WINDOW); + CREATE_(NET_REQUEST_FRAME_EXTENTS); + CREATE_(NET_RESTACK_WINDOW); + + CREATE_(NET_STARTUP_ID); + + CREATE_(NET_WM_NAME); + CREATE_(NET_WM_VISIBLE_NAME); + CREATE_(NET_WM_ICON_NAME); + CREATE_(NET_WM_VISIBLE_ICON_NAME); + CREATE_(NET_WM_DESKTOP); + CREATE_(NET_WM_WINDOW_TYPE); + CREATE_(NET_WM_STATE); + CREATE_(NET_WM_STRUT); + CREATE_(NET_WM_STRUT_PARTIAL); + CREATE_(NET_WM_ICON); + CREATE_(NET_WM_ICON_GEOMETRY); + CREATE_(NET_WM_PID); + CREATE_(NET_WM_ALLOWED_ACTIONS); + CREATE_(NET_WM_USER_TIME); +/* CREATE_(NET_WM_USER_TIME_WINDOW); */ + CREATE_(KDE_NET_WM_FRAME_STRUT); + CREATE_(NET_FRAME_EXTENTS); + + CREATE_(NET_WM_PING); +#ifdef SYNC + CREATE_(NET_WM_SYNC_REQUEST); + CREATE_(NET_WM_SYNC_REQUEST_COUNTER); +#endif + + CREATE_(NET_WM_WINDOW_TYPE_DESKTOP); + CREATE_(NET_WM_WINDOW_TYPE_DOCK); + CREATE_(NET_WM_WINDOW_TYPE_TOOLBAR); + CREATE_(NET_WM_WINDOW_TYPE_MENU); + CREATE_(NET_WM_WINDOW_TYPE_UTILITY); + CREATE_(NET_WM_WINDOW_TYPE_SPLASH); + CREATE_(NET_WM_WINDOW_TYPE_DIALOG); + CREATE_(NET_WM_WINDOW_TYPE_NORMAL); + + prop_atoms[OBT_PROP_NET_WM_MOVERESIZE_SIZE_TOPLEFT] = 0; + prop_atoms[OBT_PROP_NET_WM_MOVERESIZE_SIZE_TOP] = 1; + prop_atoms[OBT_PROP_NET_WM_MOVERESIZE_SIZE_TOPRIGHT] = 2; + prop_atoms[OBT_PROP_NET_WM_MOVERESIZE_SIZE_RIGHT] = 3; + prop_atoms[OBT_PROP_NET_WM_MOVERESIZE_SIZE_BOTTOMRIGHT] = 4; + prop_atoms[OBT_PROP_NET_WM_MOVERESIZE_SIZE_BOTTOM] = 5; + prop_atoms[OBT_PROP_NET_WM_MOVERESIZE_SIZE_BOTTOMLEFT] = 6; + prop_atoms[OBT_PROP_NET_WM_MOVERESIZE_SIZE_LEFT] = 7; + prop_atoms[OBT_PROP_NET_WM_MOVERESIZE_MOVE] = 8; + prop_atoms[OBT_PROP_NET_WM_MOVERESIZE_SIZE_KEYBOARD] = 9; + prop_atoms[OBT_PROP_NET_WM_MOVERESIZE_MOVE_KEYBOARD] = 10; + prop_atoms[OBT_PROP_NET_WM_MOVERESIZE_CANCEL] = 11; + + CREATE_(NET_WM_ACTION_MOVE); + CREATE_(NET_WM_ACTION_RESIZE); + CREATE_(NET_WM_ACTION_MINIMIZE); + CREATE_(NET_WM_ACTION_SHADE); + CREATE_(NET_WM_ACTION_MAXIMIZE_HORZ); + CREATE_(NET_WM_ACTION_MAXIMIZE_VERT); + CREATE_(NET_WM_ACTION_FULLSCREEN); + CREATE_(NET_WM_ACTION_CHANGE_DESKTOP); + CREATE_(NET_WM_ACTION_CLOSE); + CREATE_(NET_WM_ACTION_ABOVE); + CREATE_(NET_WM_ACTION_BELOW); + + CREATE_(NET_WM_STATE_MODAL); +/* CREATE_(NET_WM_STATE_STICKY);*/ + CREATE_(NET_WM_STATE_MAXIMIZED_VERT); + CREATE_(NET_WM_STATE_MAXIMIZED_HORZ); + CREATE_(NET_WM_STATE_SHADED); + CREATE_(NET_WM_STATE_SKIP_TASKBAR); + CREATE_(NET_WM_STATE_SKIP_PAGER); + CREATE_(NET_WM_STATE_HIDDEN); + CREATE_(NET_WM_STATE_FULLSCREEN); + CREATE_(NET_WM_STATE_ABOVE); + CREATE_(NET_WM_STATE_BELOW); + CREATE_(NET_WM_STATE_DEMANDS_ATTENTION); + + prop_atoms[OBT_PROP_NET_WM_STATE_ADD] = 1; + prop_atoms[OBT_PROP_NET_WM_STATE_REMOVE] = 0; + prop_atoms[OBT_PROP_NET_WM_STATE_TOGGLE] = 2; + + prop_atoms[OBT_PROP_NET_WM_ORIENTATION_HORZ] = 0; + prop_atoms[OBT_PROP_NET_WM_ORIENTATION_VERT] = 1; + prop_atoms[OBT_PROP_NET_WM_TOPLEFT] = 0; + prop_atoms[OBT_PROP_NET_WM_TOPRIGHT] = 1; + prop_atoms[OBT_PROP_NET_WM_BOTTOMRIGHT] = 2; + prop_atoms[OBT_PROP_NET_WM_BOTTOMLEFT] = 3; + + CREATE_(KDE_WM_CHANGE_STATE); + CREATE_(KDE_NET_WM_WINDOW_TYPE_OVERRIDE); + +/* + CREATE_NAME(ROOTPMAPId, "_XROOTPMAP_ID"); + CREATE_NAME(ESETROOTId, "ESETROOT_PMAP_ID"); +*/ + + CREATE_(OPENBOX_PID); + CREATE_(OB_THEME); ++ CREATE_(OB_CONFIG_FILE); + CREATE_(OB_WM_ACTION_UNDECORATE); + CREATE_(OB_WM_STATE_UNDECORATED); + CREATE_(OB_CONTROL); +} + +Atom obt_prop_atom(ObtPropAtom a) +{ + g_assert(prop_started); + g_assert(a < OBT_PROP_NUM_ATOMS); + return prop_atoms[a]; +} + +static gboolean get_prealloc(Window win, Atom prop, Atom type, gint size, + guchar *data, gulong num) +{ + gboolean ret = FALSE; + gint res; + guchar *xdata = NULL; + Atom ret_type; + gint ret_size; + gulong ret_items, bytes_left; + glong num32 = 32 / size * num; /* num in 32-bit elements */ + + res = XGetWindowProperty(obt_display, win, prop, 0l, num32, + FALSE, type, &ret_type, &ret_size, + &ret_items, &bytes_left, &xdata); + if (res == Success && ret_items && xdata) { + if (ret_size == size && ret_items >= num) { + guint i; + for (i = 0; i < num; ++i) + switch (size) { + case 8: + data[i] = xdata[i]; + break; + case 16: + ((guint16*)data)[i] = ((gushort*)xdata)[i]; + break; + case 32: + ((guint32*)data)[i] = ((gulong*)xdata)[i]; + break; + default: + g_assert_not_reached(); /* unhandled size */ + } + ret = TRUE; + } + XFree(xdata); + } + return ret; +} + +static gboolean get_all(Window win, Atom prop, Atom type, gint size, + guchar **data, guint *num) +{ + gboolean ret = FALSE; + gint res; + guchar *xdata = NULL; + Atom ret_type; + gint ret_size; + gulong ret_items, bytes_left; + + res = XGetWindowProperty(obt_display, win, prop, 0l, G_MAXLONG, + FALSE, type, &ret_type, &ret_size, + &ret_items, &bytes_left, &xdata); + if (res == Success) { + if (ret_size == size && ret_items > 0) { + guint i; + + *data = g_malloc(ret_items * (size / 8)); + for (i = 0; i < ret_items; ++i) + switch (size) { + case 8: + (*data)[i] = xdata[i]; + break; + case 16: + ((guint16*)*data)[i] = ((gushort*)xdata)[i]; + break; + case 32: + ((guint32*)*data)[i] = ((gulong*)xdata)[i]; + break; + default: + g_assert_not_reached(); /* unhandled size */ + } + *num = ret_items; + ret = TRUE; + } + XFree(xdata); + } + return ret; +} + +static gboolean get_stringlist(Window win, Atom prop, gchar ***list, gint *nstr) +{ + XTextProperty tprop; + gboolean ret = FALSE; + + if (XGetTextProperty(obt_display, win, &tprop, prop) && tprop.nitems) { + if (XTextPropertyToStringList(&tprop, list, nstr)) + ret = TRUE; + XFree(tprop.value); + } + return ret; +} + +gboolean obt_prop_get32(Window win, Atom prop, Atom type, guint32 *ret) +{ + return get_prealloc(win, prop, type, 32, (guchar*)ret, 1); +} + +gboolean obt_prop_get_array32(Window win, Atom prop, Atom type, guint32 **ret, + guint *nret) +{ + return get_all(win, prop, type, 32, (guchar**)ret, nret); +} + +gboolean obt_prop_get_string_locale(Window win, Atom prop, gchar **ret) +{ + gchar **list; + gint nstr; + gchar *s; + + if (get_stringlist(win, prop, &list, &nstr) && nstr) { + s = g_locale_to_utf8(list[0], -1, NULL, NULL, NULL); + XFreeStringList(list); + if (s) { + *ret = s; + return TRUE; + } + } + return FALSE; +} + +gboolean obt_prop_get_strings_locale(Window win, Atom prop, gchar ***ret) +{ + GSList *strs = NULL, *it; + gchar *raw, *p; + guint num, i, count = 0; + + if (get_all(win, prop, OBT_PROP_ATOM(STRING), 8, + (guchar**)&raw, &num)) + { + p = raw; + while (p < raw + num) { + ++count; + strs = g_slist_append(strs, p); + p += strlen(p) + 1; /* next string */ + } + + *ret = g_new0(gchar*, count + 1); + (*ret)[count] = NULL; /* null terminated list */ + + for (i = 0, it = strs; it; ++i, it = g_slist_next(it)) { + (*ret)[i] = g_locale_to_utf8(it->data, -1, NULL, NULL, NULL); + /* make sure translation did not fail */ + if (!(*ret)[i]) + (*ret)[i] = g_strdup(""); + } + g_free(raw); + g_slist_free(strs); + return TRUE; + } + return FALSE; +} + +gboolean obt_prop_get_string_utf8(Window win, Atom prop, gchar **ret) +{ + gchar *raw; + gchar *str; + guint num; + + if (get_all(win, prop, OBT_PROP_ATOM(UTF8), 8, + (guchar**)&raw, &num)) + { + str = g_strndup(raw, num); /* grab the first string from the list */ + g_free(raw); + if (g_utf8_validate(str, -1, NULL)) { + *ret = str; + return TRUE; + } + g_free(str); + } + return FALSE; +} + +gboolean obt_prop_get_strings_utf8(Window win, Atom prop, gchar ***ret) +{ + GSList *strs = NULL, *it; + gchar *raw, *p; + guint num, i, count = 0; + + if (get_all(win, prop, OBT_PROP_ATOM(UTF8), 8, + (guchar**)&raw, &num)) + { + p = raw; + while (p < raw + num) { + ++count; + strs = g_slist_append(strs, p); + p += strlen(p) + 1; /* next string */ + } + + *ret = g_new0(gchar*, count + 1); + + for (i = 0, it = strs; it; ++i, it = g_slist_next(it)) { + if (g_utf8_validate(it->data, -1, NULL)) + (*ret)[i] = g_strdup(it->data); + else + (*ret)[i] = g_strdup(""); + } + g_free(raw); + g_slist_free(strs); + return TRUE; + } + return FALSE; +} + +void obt_prop_set32(Window win, Atom prop, Atom type, gulong val) +{ + XChangeProperty(obt_display, win, prop, type, 32, PropModeReplace, + (guchar*)&val, 1); +} + +void obt_prop_set_array32(Window win, Atom prop, Atom type, gulong *val, + guint num) +{ + XChangeProperty(obt_display, win, prop, type, 32, PropModeReplace, + (guchar*)val, num); +} + +void obt_prop_set_string_locale(Window win, Atom prop, const gchar *val) +{ + gchar const *s[2] = { val, NULL }; + obt_prop_set_strings_locale(win, prop, s); +} + +void obt_prop_set_strings_locale(Window win, Atom prop, const gchar **strs) +{ + gint i, count; + gchar **lstrs; + XTextProperty tprop; + + /* count the strings in strs, and convert them to the locale format */ + for (count = 0; strs[count]; ++count); + lstrs = g_new0(char*, count); + for (i = 0; i < count; ++i) { + lstrs[i] = g_locale_from_utf8(strs[i], -1, NULL, NULL, NULL); + if (!lstrs[i]) { + lstrs[i] = g_strdup(""); /* make it an empty string */ + g_warning("Unable to translate string '%s' from UTF8 to locale " + "format", strs[i]); + } + } + + + XStringListToTextProperty(lstrs, count, &tprop); + XSetTextProperty(obt_display, win, &tprop, prop); + XFree(tprop.value); +} + +void obt_prop_set_string_utf8(Window win, Atom prop, const gchar *val) +{ + XChangeProperty(obt_display, win, prop, OBT_PROP_ATOM(UTF8), 8, + PropModeReplace, (const guchar*)val, strlen(val)); +} + +void obt_prop_set_strings_utf8(Window win, Atom prop, const gchar **strs) +{ + GString *str; + gchar const **s; + + str = g_string_sized_new(0); + for (s = strs; *s; ++s) { + str = g_string_append(str, *s); + str = g_string_append_c(str, '\0'); + } + XChangeProperty(obt_display, win, prop, obt_prop_atom(OBT_PROP_UTF8), 8, + PropModeReplace, (guchar*)str->str, str->len); + g_string_free(str, TRUE); +} + +void obt_prop_erase(Window win, Atom prop) +{ + XDeleteProperty(obt_display, win, prop); +} + +void obt_prop_message(gint screen, Window about, Atom messagetype, + glong data0, glong data1, glong data2, glong data3, + glong data4, glong mask) +{ + obt_prop_message_to(obt_root(screen), about, messagetype, + data0, data1, data2, data3, data4, mask); +} + +void obt_prop_message_to(Window to, Window about, + Atom messagetype, + glong data0, glong data1, glong data2, glong data3, + glong data4, glong mask) +{ + XEvent ce; + ce.xclient.type = ClientMessage; + ce.xclient.message_type = messagetype; + ce.xclient.display = obt_display; + ce.xclient.window = about; + ce.xclient.format = 32; + ce.xclient.data.l[0] = data0; + ce.xclient.data.l[1] = data1; + ce.xclient.data.l[2] = data2; + ce.xclient.data.l[3] = data3; + ce.xclient.data.l[4] = data4; + XSendEvent(obt_display, to, FALSE, mask, &ce); +} diff --cc obt/prop.h index 4de3111d,00000000..e1236116 mode 100644,000000..100644 --- a/obt/prop.h +++ b/obt/prop.h @@@ -1,277 -1,0 +1,278 @@@ +/* -*- indent-tabs-mode: nil; tab-width: 4; c-basic-offset: 4; -*- + + obt/prop.h for the Openbox window manager + Copyright (c) 2006 Mikael Magnusson + Copyright (c) 2003-2007 Dana Jansens + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + See the COPYING file for a copy of the GNU General Public License. +*/ + +#ifndef __obt_prop_h +#define __obt_prop_h + +#include +#include + +G_BEGIN_DECLS + +typedef enum { + /* types */ + OBT_PROP_CARDINAL, /*!< The atom which represents the Cardinal data type */ + OBT_PROP_WINDOW, /*!< The atom which represents window ids */ + OBT_PROP_PIXMAP, /*!< The atom which represents pixmap ids */ + OBT_PROP_ATOM, /*!< The atom which represents atom values */ + OBT_PROP_STRING, /*!< The atom which represents ascii strings */ + OBT_PROP_UTF8, /*!< The atom which represents utf8-encoded strings */ + + /* selection stuff */ + OBT_PROP_MANAGER, + + /* window hints */ + OBT_PROP_WM_COLORMAP_WINDOWS, + OBT_PROP_WM_PROTOCOLS, + OBT_PROP_WM_STATE, + OBT_PROP_WM_DELETE_WINDOW, + OBT_PROP_WM_TAKE_FOCUS, + OBT_PROP_WM_CHANGE_STATE, + OBT_PROP_WM_NAME, + OBT_PROP_WM_ICON_NAME, + OBT_PROP_WM_CLASS, + OBT_PROP_WM_WINDOW_ROLE, + OBT_PROP_WM_CLIENT_MACHINE, + OBT_PROP_WM_COMMAND, + OBT_PROP_WM_CLIENT_LEADER, + OBT_PROP_MOTIF_WM_HINTS, + + /* SM atoms */ + OBT_PROP_SM_CLIENT_ID, + + /* NETWM atoms */ + + /* Atoms that are used inside messages - these don't go in net_supported */ + + OBT_PROP_NET_WM_MOVERESIZE_SIZE_TOPLEFT, + OBT_PROP_NET_WM_MOVERESIZE_SIZE_TOP, + OBT_PROP_NET_WM_MOVERESIZE_SIZE_TOPRIGHT, + OBT_PROP_NET_WM_MOVERESIZE_SIZE_RIGHT, + OBT_PROP_NET_WM_MOVERESIZE_SIZE_BOTTOMRIGHT, + OBT_PROP_NET_WM_MOVERESIZE_SIZE_BOTTOM, + OBT_PROP_NET_WM_MOVERESIZE_SIZE_BOTTOMLEFT, + OBT_PROP_NET_WM_MOVERESIZE_SIZE_LEFT, + OBT_PROP_NET_WM_MOVERESIZE_MOVE, + OBT_PROP_NET_WM_MOVERESIZE_SIZE_KEYBOARD, + OBT_PROP_NET_WM_MOVERESIZE_MOVE_KEYBOARD, + OBT_PROP_NET_WM_MOVERESIZE_CANCEL, + + OBT_PROP_NET_WM_STATE_ADD, + OBT_PROP_NET_WM_STATE_REMOVE, + OBT_PROP_NET_WM_STATE_TOGGLE, + + OBT_PROP_NET_WM_ORIENTATION_HORZ, + OBT_PROP_NET_WM_ORIENTATION_VERT, + OBT_PROP_NET_WM_TOPLEFT, + OBT_PROP_NET_WM_TOPRIGHT, + OBT_PROP_NET_WM_BOTTOMRIGHT, + OBT_PROP_NET_WM_BOTTOMLEFT, + + OBT_PROP_PRIVATE_PADDING1, + OBT_PROP_PRIVATE_PADDING2, + OBT_PROP_PRIVATE_PADDING3, + OBT_PROP_PRIVATE_PADDING4, + OBT_PROP_PRIVATE_PADDING5, + OBT_PROP_PRIVATE_PADDING6, + OBT_PROP_PRIVATE_PADDING7, + OBT_PROP_PRIVATE_PADDING8, + OBT_PROP_PRIVATE_PADDING9, + OBT_PROP_PRIVATE_PADDING10, + OBT_PROP_PRIVATE_PADDING11, + OBT_PROP_PRIVATE_PADDING12, + + /* Everything below here must go in net_supported on the root window */ + + /* root window properties */ + OBT_PROP_NET_SUPPORTED, + OBT_PROP_NET_CLIENT_LIST, + OBT_PROP_NET_CLIENT_LIST_STACKING, + OBT_PROP_NET_NUMBER_OF_DESKTOPS, + OBT_PROP_NET_DESKTOP_GEOMETRY, + OBT_PROP_NET_DESKTOP_VIEWPORT, + OBT_PROP_NET_CURRENT_DESKTOP, + OBT_PROP_NET_DESKTOP_NAMES, + OBT_PROP_NET_ACTIVE_WINDOW, +/* Atom net_restack_window;*/ + OBT_PROP_NET_WORKAREA, + OBT_PROP_NET_SUPPORTING_WM_CHECK, + OBT_PROP_NET_DESKTOP_LAYOUT, + OBT_PROP_NET_SHOWING_DESKTOP, + + /* root window messages */ + OBT_PROP_NET_CLOSE_WINDOW, + OBT_PROP_NET_WM_MOVERESIZE, + OBT_PROP_NET_MOVERESIZE_WINDOW, + OBT_PROP_NET_REQUEST_FRAME_EXTENTS, + OBT_PROP_NET_RESTACK_WINDOW, + + /* helpful hints to apps that aren't used for anything */ + OBT_PROP_NET_WM_FULL_PLACEMENT, + + /* startup-notification extension */ + OBT_PROP_NET_STARTUP_ID, + + /* application window properties */ + OBT_PROP_NET_WM_NAME, + OBT_PROP_NET_WM_VISIBLE_NAME, + OBT_PROP_NET_WM_ICON_NAME, + OBT_PROP_NET_WM_VISIBLE_ICON_NAME, + OBT_PROP_NET_WM_DESKTOP, + OBT_PROP_NET_WM_WINDOW_TYPE, + OBT_PROP_NET_WM_STATE, + OBT_PROP_NET_WM_STRUT, + OBT_PROP_NET_WM_STRUT_PARTIAL, + OBT_PROP_NET_WM_ICON, + OBT_PROP_NET_WM_ICON_GEOMETRY, + OBT_PROP_NET_WM_PID, + OBT_PROP_NET_WM_ALLOWED_ACTIONS, + OBT_PROP_NET_WM_USER_TIME, +/* OBT_PROP_NET_WM_USER_TIME_WINDOW, */ + OBT_PROP_NET_FRAME_EXTENTS, + + /* application protocols */ + OBT_PROP_NET_WM_PING, +#ifdef SYNC + OBT_PROP_NET_WM_SYNC_REQUEST, + OBT_PROP_NET_WM_SYNC_REQUEST_COUNTER, +#endif + + OBT_PROP_NET_WM_WINDOW_TYPE_DESKTOP, + OBT_PROP_NET_WM_WINDOW_TYPE_DOCK, + OBT_PROP_NET_WM_WINDOW_TYPE_TOOLBAR, + OBT_PROP_NET_WM_WINDOW_TYPE_MENU, + OBT_PROP_NET_WM_WINDOW_TYPE_UTILITY, + OBT_PROP_NET_WM_WINDOW_TYPE_SPLASH, + OBT_PROP_NET_WM_WINDOW_TYPE_DIALOG, + OBT_PROP_NET_WM_WINDOW_TYPE_NORMAL, + + OBT_PROP_NET_WM_ACTION_MOVE, + OBT_PROP_NET_WM_ACTION_RESIZE, + OBT_PROP_NET_WM_ACTION_MINIMIZE, + OBT_PROP_NET_WM_ACTION_SHADE, +/* OBT_PROP_NET_WM_ACTION_STICK,*/ + OBT_PROP_NET_WM_ACTION_MAXIMIZE_HORZ, + OBT_PROP_NET_WM_ACTION_MAXIMIZE_VERT, + OBT_PROP_NET_WM_ACTION_FULLSCREEN, + OBT_PROP_NET_WM_ACTION_CHANGE_DESKTOP, + OBT_PROP_NET_WM_ACTION_CLOSE, + OBT_PROP_NET_WM_ACTION_ABOVE, + OBT_PROP_NET_WM_ACTION_BELOW, + + OBT_PROP_NET_WM_STATE_MODAL, +/* OBT_PROP_NET_WM_STATE_STICKY,*/ + OBT_PROP_NET_WM_STATE_MAXIMIZED_VERT, + OBT_PROP_NET_WM_STATE_MAXIMIZED_HORZ, + OBT_PROP_NET_WM_STATE_SHADED, + OBT_PROP_NET_WM_STATE_SKIP_TASKBAR, + OBT_PROP_NET_WM_STATE_SKIP_PAGER, + OBT_PROP_NET_WM_STATE_HIDDEN, + OBT_PROP_NET_WM_STATE_FULLSCREEN, + OBT_PROP_NET_WM_STATE_ABOVE, + OBT_PROP_NET_WM_STATE_BELOW, + OBT_PROP_NET_WM_STATE_DEMANDS_ATTENTION, + + /* KDE atoms */ + + OBT_PROP_KDE_WM_CHANGE_STATE, + OBT_PROP_KDE_NET_WM_FRAME_STRUT, + OBT_PROP_KDE_NET_WM_WINDOW_TYPE_OVERRIDE, + +/* + OBT_PROP_ROOTPMAPID, + OBT_PROP_ESETROOTID, +*/ + + /* Openbox specific atoms */ + + OBT_PROP_OB_WM_ACTION_UNDECORATE, + OBT_PROP_OB_WM_STATE_UNDECORATED, + OBT_PROP_OPENBOX_PID, /* this is depreecated in favour of ob_control */ + OBT_PROP_OB_THEME, ++ OBT_PROP_OB_CONFIG_FILE, + OBT_PROP_OB_CONTROL, + + OBT_PROP_NUM_ATOMS +} ObtPropAtom; + +Atom obt_prop_atom(ObtPropAtom a); + +gboolean obt_prop_get32(Window win, Atom prop, Atom type, guint32 *ret); +gboolean obt_prop_get_array32(Window win, Atom prop, Atom type, guint32 **ret, + guint *nret); +gboolean obt_prop_get_string_locale(Window win, Atom prop, gchar **ret); +gboolean obt_prop_get_string_utf8(Window win, Atom prop, gchar **ret); +gboolean obt_prop_get_strings_locale(Window win, Atom prop, gchar ***ret); +gboolean obt_prop_get_strings_utf8(Window win, Atom prop, gchar ***ret); + +void obt_prop_set32(Window win, Atom prop, Atom type, gulong val); +void obt_prop_set_array32(Window win, Atom prop, Atom type, gulong *val, + guint num); +void obt_prop_set_string_locale(Window win, Atom prop, const gchar *val); +void obt_prop_set_string_utf8(Window win, Atom prop, const gchar *val); +void obt_prop_set_strings_locale(Window win, Atom prop, const gchar **strs); +void obt_prop_set_strings_utf8(Window win, Atom prop, const gchar **strs); + +void obt_prop_erase(Window win, Atom prop); + +void obt_prop_message(gint screen, Window about, Atom messagetype, + glong data0, glong data1, glong data2, glong data3, + glong data4, glong mask); +void obt_prop_message_to(Window to, Window about, Atom messagetype, + glong data0, glong data1, glong data2, glong data3, + glong data4, glong mask); + +#define OBT_PROP_ATOM(prop) obt_prop_atom(OBT_PROP_##prop) + +#define OBT_PROP_GET32(win, prop, type, ret) \ + (obt_prop_get32(win, OBT_PROP_ATOM(prop), OBT_PROP_ATOM(type), ret)) +#define OBT_PROP_GETA32(win, prop, type, ret, nret) \ + (obt_prop_get_array32(win, OBT_PROP_ATOM(prop), OBT_PROP_ATOM(type), \ + ret, nret)) +#define OBT_PROP_GETS(win, prop, type, ret) \ + (obt_prop_get_string_##type(win, OBT_PROP_ATOM(prop), ret)) +#define OBT_PROP_GETSS(win, prop, type, ret) \ + (obt_prop_get_strings_##type(win, OBT_PROP_ATOM(prop), ret)) + +#define OBT_PROP_SET32(win, prop, type, val) \ + (obt_prop_set32(win, OBT_PROP_ATOM(prop), OBT_PROP_ATOM(type), val)) +#define OBT_PROP_SETA32(win, prop, type, val, num) \ + (obt_prop_set_array32(win, OBT_PROP_ATOM(prop), OBT_PROP_ATOM(type), \ + val, num)) +#define OBT_PROP_SETS(win, prop, type, val) \ + (obt_prop_set_string_##type(win, OBT_PROP_ATOM(prop), val)) +#define OBT_PROP_SETSS(win, prop, type, strs) \ + (obt_prop_set_strings_##type(win, OBT_PROP_ATOM(prop), strs)) + +#define OBT_PROP_ERASE(win, prop) (obt_prop_erase(win, OBT_PROP_ATOM(prop))) + +#define OBT_PROP_MSG(screen, about, msgtype, data0, data1, data2, data3, \ + data4) \ + (obt_prop_message(screen, about, OBT_PROP_ATOM(msgtype), \ + data0, data1, data2, data3, data4, \ + SubstructureNotifyMask | SubstructureRedirectMask)) + +#define OBT_PROP_MSG_TO(to, about, msgtype, data0, data1, data2, data3, \ + data4, mask) \ + (obt_prop_message_to(to, about, OBT_PROP_ATOM(msgtype), \ + data0, data1, data2, data3, data4, mask)) + +G_END_DECLS + +#endif /* __obt_prop_h */ diff --cc openbox/actions.c index 10bf929a,b7ba5b44..6068f19c --- a/openbox/actions.c +++ b/openbox/actions.c @@@ -332,8 -346,14 +344,14 @@@ gboolean actions_interactive_input_even void actions_client_move(ObActionsData *data, gboolean start) { static gulong ignore_start = 0; - if (start) + if (start) { ignore_start = event_start_ignore_all_enters(); + if (replay_pointer) { + /* replay the pointer event before any windows move */ - XAllowEvents(ob_display, ReplayPointer, event_curtime); ++ XAllowEvents(obt_display, ReplayPointer, event_curtime); + replay_pointer = FALSE; + } + } else if (config_focus_follow && data->context != OB_FRAME_CONTEXT_CLIENT) { diff --cc openbox/client.c index b1b5e8a3,e7290ca5..6534e1b3 --- a/openbox/client.c +++ b/openbox/client.c @@@ -2978,7 -3097,15 +3019,15 @@@ void client_configure(ObClient *self, g self->frame->size.left, self->frame->size.top, w, h); } - XFlush(ob_display); + XFlush(obt_display); + + /* if it moved between monitors, then this can affect the stacking + layer of this window or others - for fullscreen windows */ + if (screen_find_monitor(&self->frame->area) != + screen_find_monitor(&oldframe)) + { + client_calc_layer(self); + } } void client_fullscreen(ObClient *self, gboolean fs) diff --cc openbox/event.c index 5207e093,caf6f5af..bce1de12 --- a/openbox/event.c +++ b/openbox/event.c @@@ -708,8 -701,8 +706,8 @@@ static void event_process(const XEvent if (e->type == ButtonPress || e->type == ButtonRelease) { /* If the button press was on some non-root window, or was physically - on the root window, the process it */ + on the root window, then process it */ - if (window != RootWindow(ob_display, ob_screen) || + if (window != obt_root(ob_screen) || e->xbutton.subwindow == None) { event_handle_user_input(client, e); diff --cc openbox/mouse.c index dca6e6ba,711317ec..b2893cee --- a/openbox/mouse.c +++ b/openbox/mouse.c @@@ -234,11 -246,14 +245,14 @@@ void mouse_event(ObClient *client, XEve if (grab_on_pointer()) button = 0; - if (CLIENT_CONTEXT(context, client)) { - /* Replay the event, so it goes to the client*/ + /* replay the pointer event if it hasn't been replayed yet (i.e. no + windows were moved) */ + if (actions_get_need_pointer_replay_before_move()) - XAllowEvents(ob_display, ReplayPointer, event_curtime); + XAllowEvents(obt_display, ReplayPointer, event_curtime); - /* Fall through to the release case! */ - } else + + /* in the client context, we won't get a button release because of the + way it is grabbed, so just fake one */ + if (!CLIENT_CONTEXT(context, client)) break; case ButtonRelease: diff --cc openbox/openbox.c index 95a58198,7d7e0d0d..80f81594 --- a/openbox/openbox.c +++ b/openbox/openbox.c @@@ -222,21 -247,29 +223,32 @@@ gint main(gint argc, gchar **argv config_startup(i); /* parse/load user options */ - if (obt_parse_load_config_file(i, "openbox", "rc.xml", - if (parse_load_rc(config_file, &doc, &node)) { - parse_tree(i, doc, node->xmlChildrenNode); - parse_close(doc); ++ if ((config_file && ++ obt_parse_load_file(i, config_file, "openbox_config")) || ++ obt_parse_load_config_file(i, "openbox", "rc.xml", + "openbox_config")) + { + obt_parse_tree_from_root(i); + obt_parse_close(i); - } else + } + else { g_message(_("Unable to find a valid config file, using some simple defaults")); + config_file = NULL; + } - /* - if (config_type != NULL) - PROP_SETS(obt_root(ob_screen), ob_config, config_type); - */ + if (config_file) { + gchar *p = g_filename_to_utf8(config_file, -1, + NULL, NULL, NULL); + if (p) - PROP_SETS(RootWindow(ob_display, ob_screen), - ob_config_file, p); ++ OBT_PROP_SETS(obt_root(ob_screen), OB_CONFIG_FILE, ++ utf8, p); + g_free(p); + } + else - PROP_ERASE(RootWindow(ob_display, ob_screen), - ob_config_file); ++ OBT_PROP_ERASE(obt_root(ob_screen), OB_CONFIG_FILE); /* we're done with parsing now, kill it */ - parse_shutdown(i); + obt_parse_instance_unref(i); } /* load the theme specified in the rc file */ diff --cc openbox/screen.c index de3203e3,73429bc9..fcd0de8c --- a/openbox/screen.c +++ b/openbox/screen.c @@@ -205,96 -212,100 +205,97 @@@ gboolean screen_annex(void /* set the _NET_SUPPORTED_ATOMS hint */ - /* this is all the atoms after net_supported in the prop_atoms struct */ - prop_atoms_start = (Atom*)&prop_atoms; - wm_supported_pos = (Atom*)&(prop_atoms.net_supported); - num_support = sizeof(prop_atoms) / sizeof(Atom) - - (wm_supported_pos - prop_atoms_start) - 1; + /* this is all the atoms after NET_SUPPORTED in the ObtPropAtoms enum */ + num_support = OBT_PROP_NUM_ATOMS - OBT_PROP_NET_SUPPORTED - 1; i = 0; supported = g_new(gulong, num_support); - supported[i++] = prop_atoms.net_supporting_wm_check; - supported[i++] = prop_atoms.net_wm_full_placement; - supported[i++] = prop_atoms.net_current_desktop; - supported[i++] = prop_atoms.net_number_of_desktops; - supported[i++] = prop_atoms.net_desktop_geometry; - supported[i++] = prop_atoms.net_desktop_viewport; - supported[i++] = prop_atoms.net_active_window; - supported[i++] = prop_atoms.net_workarea; - supported[i++] = prop_atoms.net_client_list; - supported[i++] = prop_atoms.net_client_list_stacking; - supported[i++] = prop_atoms.net_desktop_names; - supported[i++] = prop_atoms.net_close_window; - supported[i++] = prop_atoms.net_desktop_layout; - supported[i++] = prop_atoms.net_showing_desktop; - supported[i++] = prop_atoms.net_wm_name; - supported[i++] = prop_atoms.net_wm_visible_name; - supported[i++] = prop_atoms.net_wm_icon_name; - supported[i++] = prop_atoms.net_wm_visible_icon_name; - supported[i++] = prop_atoms.net_wm_desktop; - supported[i++] = prop_atoms.net_wm_strut; - supported[i++] = prop_atoms.net_wm_strut_partial; - supported[i++] = prop_atoms.net_wm_icon; - supported[i++] = prop_atoms.net_wm_icon_geometry; - supported[i++] = prop_atoms.net_wm_window_type; - supported[i++] = prop_atoms.net_wm_window_type_desktop; - supported[i++] = prop_atoms.net_wm_window_type_dock; - supported[i++] = prop_atoms.net_wm_window_type_toolbar; - supported[i++] = prop_atoms.net_wm_window_type_menu; - supported[i++] = prop_atoms.net_wm_window_type_utility; - supported[i++] = prop_atoms.net_wm_window_type_splash; - supported[i++] = prop_atoms.net_wm_window_type_dialog; - supported[i++] = prop_atoms.net_wm_window_type_normal; - supported[i++] = prop_atoms.net_wm_allowed_actions; - supported[i++] = prop_atoms.net_wm_action_move; - supported[i++] = prop_atoms.net_wm_action_resize; - supported[i++] = prop_atoms.net_wm_action_minimize; - supported[i++] = prop_atoms.net_wm_action_shade; - supported[i++] = prop_atoms.net_wm_action_maximize_horz; - supported[i++] = prop_atoms.net_wm_action_maximize_vert; - supported[i++] = prop_atoms.net_wm_action_fullscreen; - supported[i++] = prop_atoms.net_wm_action_change_desktop; - supported[i++] = prop_atoms.net_wm_action_close; - supported[i++] = prop_atoms.net_wm_action_above; - supported[i++] = prop_atoms.net_wm_action_below; - supported[i++] = prop_atoms.net_wm_state; - supported[i++] = prop_atoms.net_wm_state_modal; - supported[i++] = prop_atoms.net_wm_state_maximized_vert; - supported[i++] = prop_atoms.net_wm_state_maximized_horz; - supported[i++] = prop_atoms.net_wm_state_shaded; - supported[i++] = prop_atoms.net_wm_state_skip_taskbar; - supported[i++] = prop_atoms.net_wm_state_skip_pager; - supported[i++] = prop_atoms.net_wm_state_hidden; - supported[i++] = prop_atoms.net_wm_state_fullscreen; - supported[i++] = prop_atoms.net_wm_state_above; - supported[i++] = prop_atoms.net_wm_state_below; - supported[i++] = prop_atoms.net_wm_state_demands_attention; - supported[i++] = prop_atoms.net_moveresize_window; - supported[i++] = prop_atoms.net_wm_moveresize; - supported[i++] = prop_atoms.net_wm_user_time; + supported[i++] = OBT_PROP_ATOM(NET_SUPPORTING_WM_CHECK); + supported[i++] = OBT_PROP_ATOM(NET_WM_FULL_PLACEMENT); + supported[i++] = OBT_PROP_ATOM(NET_CURRENT_DESKTOP); + supported[i++] = OBT_PROP_ATOM(NET_NUMBER_OF_DESKTOPS); + supported[i++] = OBT_PROP_ATOM(NET_DESKTOP_GEOMETRY); + supported[i++] = OBT_PROP_ATOM(NET_DESKTOP_VIEWPORT); + supported[i++] = OBT_PROP_ATOM(NET_ACTIVE_WINDOW); + supported[i++] = OBT_PROP_ATOM(NET_WORKAREA); + supported[i++] = OBT_PROP_ATOM(NET_CLIENT_LIST); + supported[i++] = OBT_PROP_ATOM(NET_CLIENT_LIST_STACKING); + supported[i++] = OBT_PROP_ATOM(NET_DESKTOP_NAMES); + supported[i++] = OBT_PROP_ATOM(NET_CLOSE_WINDOW); + supported[i++] = OBT_PROP_ATOM(NET_DESKTOP_LAYOUT); + supported[i++] = OBT_PROP_ATOM(NET_SHOWING_DESKTOP); + supported[i++] = OBT_PROP_ATOM(NET_WM_NAME); + supported[i++] = OBT_PROP_ATOM(NET_WM_VISIBLE_NAME); + supported[i++] = OBT_PROP_ATOM(NET_WM_ICON_NAME); + supported[i++] = OBT_PROP_ATOM(NET_WM_VISIBLE_ICON_NAME); + supported[i++] = OBT_PROP_ATOM(NET_WM_DESKTOP); + supported[i++] = OBT_PROP_ATOM(NET_WM_STRUT); + supported[i++] = OBT_PROP_ATOM(NET_WM_STRUT_PARTIAL); + supported[i++] = OBT_PROP_ATOM(NET_WM_ICON); + supported[i++] = OBT_PROP_ATOM(NET_WM_ICON_GEOMETRY); + supported[i++] = OBT_PROP_ATOM(NET_WM_WINDOW_TYPE); + supported[i++] = OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_DESKTOP); + supported[i++] = OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_DOCK); + supported[i++] = OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_TOOLBAR); + supported[i++] = OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_MENU); + supported[i++] = OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_UTILITY); + supported[i++] = OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_SPLASH); + supported[i++] = OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_DIALOG); + supported[i++] = OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_NORMAL); + supported[i++] = OBT_PROP_ATOM(NET_WM_ALLOWED_ACTIONS); + supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_MOVE); + supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_RESIZE); + supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_MINIMIZE); + supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_SHADE); + supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_MAXIMIZE_HORZ); + supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_MAXIMIZE_VERT); + supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_FULLSCREEN); + supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_CHANGE_DESKTOP); + supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_CLOSE); + supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_ABOVE); + supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_BELOW); + supported[i++] = OBT_PROP_ATOM(NET_WM_STATE); + supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_MODAL); + supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_MAXIMIZED_VERT); + supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_MAXIMIZED_HORZ); + supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_SHADED); + supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_SKIP_TASKBAR); + supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_SKIP_PAGER); + supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_HIDDEN); + supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_FULLSCREEN); + supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_ABOVE); + supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_BELOW); + supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_DEMANDS_ATTENTION); + supported[i++] = OBT_PROP_ATOM(NET_MOVERESIZE_WINDOW); + supported[i++] = OBT_PROP_ATOM(NET_WM_MOVERESIZE); + supported[i++] = OBT_PROP_ATOM(NET_WM_USER_TIME); /* - supported[i++] = prop_atoms.net_wm_user_time_window; + supported[i++] = OBT_PROP_ATOM(NET_WM_USER_TIME_WINDOW); */ - supported[i++] = prop_atoms.net_frame_extents; - supported[i++] = prop_atoms.net_request_frame_extents; - supported[i++] = prop_atoms.net_restack_window; - supported[i++] = prop_atoms.net_startup_id; + supported[i++] = OBT_PROP_ATOM(NET_FRAME_EXTENTS); + supported[i++] = OBT_PROP_ATOM(NET_REQUEST_FRAME_EXTENTS); + supported[i++] = OBT_PROP_ATOM(NET_RESTACK_WINDOW); + supported[i++] = OBT_PROP_ATOM(NET_STARTUP_ID); #ifdef SYNC - supported[i++] = prop_atoms.net_wm_sync_request; - supported[i++] = prop_atoms.net_wm_sync_request_counter; + supported[i++] = OBT_PROP_ATOM(NET_WM_SYNC_REQUEST); + supported[i++] = OBT_PROP_ATOM(NET_WM_SYNC_REQUEST_COUNTER); #endif - supported[i++] = prop_atoms.net_wm_pid; - supported[i++] = prop_atoms.net_wm_ping; - - supported[i++] = prop_atoms.kde_wm_change_state; - supported[i++] = prop_atoms.kde_net_wm_frame_strut; - supported[i++] = prop_atoms.kde_net_wm_window_type_override; - - supported[i++] = prop_atoms.ob_wm_action_undecorate; - supported[i++] = prop_atoms.ob_wm_state_undecorated; - supported[i++] = prop_atoms.openbox_pid; - supported[i++] = prop_atoms.ob_theme; - supported[i++] = prop_atoms.ob_config_file; - supported[i++] = prop_atoms.ob_control; + supported[i++] = OBT_PROP_ATOM(NET_WM_PID); + supported[i++] = OBT_PROP_ATOM(NET_WM_PING); + + supported[i++] = OBT_PROP_ATOM(KDE_WM_CHANGE_STATE); + supported[i++] = OBT_PROP_ATOM(KDE_NET_WM_FRAME_STRUT); + supported[i++] = OBT_PROP_ATOM(KDE_NET_WM_WINDOW_TYPE_OVERRIDE); + + supported[i++] = OBT_PROP_ATOM(OB_WM_ACTION_UNDECORATE); + supported[i++] = OBT_PROP_ATOM(OB_WM_STATE_UNDECORATED); + supported[i++] = OBT_PROP_ATOM(OPENBOX_PID); + supported[i++] = OBT_PROP_ATOM(OB_THEME); ++ supported[i++] = OBT_PROP_ATOM(OB_CONFIG_FILE); + supported[i++] = OBT_PROP_ATOM(OB_CONTROL); g_assert(i == num_support); - PROP_SETA32(RootWindow(ob_display, ob_screen), - net_supported, atom, supported, num_support); + OBT_PROP_SETA32(obt_root(ob_screen), + NET_SUPPORTED, ATOM, supported, num_support); g_free(supported); screen_tell_ksplash();