if (cit == c) break;
if (client_normal(cit) == client_normal(c) &&
- cit->layer == c->layer &&
- frame_visible(cit->frame) &&
- !client_search_transient(c, cit))
+ cit->layer == c->layer &&
+ cit->frame->visible &&
+ !client_search_transient(c, cit))
{
if (RECT_INTERSECTS_RECT(cit->frame->area, c->frame->area)) {
raise = TRUE;
self->below = TRUE;
else if (state[i] == prop_atoms.net_wm_state_demands_attention)
self->demands_attention = TRUE;
- else if (state[i] == prop_atoms.ob_wm_state_undecorated)
+ else if (state[i] == prop_atoms.openbox_wm_state_undecorated)
self->undecorated = TRUE;
}
c = it->data;
if (c != self && (!c->transient_for ||
c->transient_for != OB_TRAN_GROUP))
- c->transients = g_slist_append(c->transients, self);
+ c->transients = g_slist_prepend(c->transients, self);
}
}
/* If we are now transient for a single window which we weren't before,
newparent != oldparent &&
/* don't make ourself its child if it is already our child */
!client_is_direct_child(self, newparent))
- newparent->transients = g_slist_append(newparent->transients, self);
+ newparent->transients = g_slist_prepend(newparent->transients, self);
/* If the group changed then we need to add any new group transient
windows to our children. But if we're transient for the group, then
/* Don't make it our child if it is already our parent */
!client_is_direct_child(c, self))
{
- self->transients = g_slist_append(self->transients, c);
+ self->transients = g_slist_prepend(self->transients, c);
}
}
}
old = self->wmstate;
- if (self->shaded || self->iconic || !frame_visible(self->frame))
+ if (self->shaded || !self->frame->visible)
self->wmstate = IconicState;
else
self->wmstate = NormalState;
if (self->demands_attention)
netstate[num++] = prop_atoms.net_wm_state_demands_attention;
if (self->undecorated)
- netstate[num++] = prop_atoms.ob_wm_state_undecorated;
+ netstate[num++] = prop_atoms.openbox_wm_state_undecorated;
PROP_SETA32(self->window, net_wm_state, atom, netstate, num);
if (self->frame)
if (changed) {
client_change_state(self);
- if (iconic) {
- if (ob_state() != OB_STATE_STARTING && config_animate_iconify) {
- /* delay the showhide until the window is done the animation */
- frame_begin_iconify_animation
- (self->frame, iconic,
- (ObFrameIconifyAnimateFunc)client_showhide, self);
- /* but focus a new window now please */
- focus_fallback(FALSE);
- } else
- client_showhide(self);
- } else {
- if (config_animate_iconify)
- /* the animation will show the window when it is hidden,
- but the window state needs to be adjusted after the
- animation finishes, so call showhide when it's done to make
- sure everything is updated appropriately
- */
- frame_begin_iconify_animation
- (self->frame, iconic,
- (ObFrameIconifyAnimateFunc)client_showhide, self);
- }
+ if (ob_state() != OB_STATE_STARTING && config_animate_iconify)
+ frame_begin_iconify_animation(self->frame, iconic);
+ /* do this after starting the animation so it doesn't flash */
+ client_showhide(self);
}
/* iconify all direct transients, and deiconify all transients
action = self->demands_attention ?
prop_atoms.net_wm_state_remove :
prop_atoms.net_wm_state_add;
- else if (state == prop_atoms.ob_wm_state_undecorated)
+ else if (state == prop_atoms.openbox_wm_state_undecorated)
action = undecorated ? prop_atoms.net_wm_state_remove :
prop_atoms.net_wm_state_add;
}
self->below = TRUE;
} else if (state == prop_atoms.net_wm_state_demands_attention) {
demands_attention = TRUE;
- } else if (state == prop_atoms.ob_wm_state_undecorated) {
+ } else if (state == prop_atoms.openbox_wm_state_undecorated) {
undecorated = TRUE;
}
self->below = FALSE;
} else if (state == prop_atoms.net_wm_state_demands_attention) {
demands_attention = FALSE;
- } else if (state == prop_atoms.ob_wm_state_undecorated) {
+ } else if (state == prop_atoms.openbox_wm_state_undecorated) {
undecorated = FALSE;
}
}
/* choose the correct target */
self = client_focus_target(self);
- if (!frame_visible(self->frame))
+ if (!self->frame->visible)
return FALSE;
if (!(self->can_focus || self->focus_notify))
self = client_focus_target(self);
if (!client_can_focus(self)) {
- if (!frame_visible(self->frame)) {
+ if (!self->frame->visible) {
/* update the focus lists */
focus_order_to_top(self);
}
client_set_desktop(self, screen_desktop, FALSE);
else
screen_set_desktop(self->desktop);
- } else if (!frame_visible(self->frame))
+ } else if (!self->frame->visible)
/* if its not visible for other reasons, then don't mess
with it */
return;
for (it = stacking_list; it; it = g_list_next(it)) {
if (WINDOW_IS_CLIENT(it->data)) {
ObClient *c = WINDOW_AS_CLIENT(it->data);
- if (frame_visible(c->frame) &&
+ if (c->frame->visible &&
/* ignore all animating windows */
!frame_iconify_animating(c->frame) &&
RECT_CONTAINS(c->frame->area, x, y))
va_list vl;
if (show) {
+ fprintf(stderr, "DEBUG: ");
va_start(vl, a);
vfprintf(stderr, a, vl);
va_end(vl);
g_assert(type < OB_DEBUG_TYPE_NUM);
if (show && enabled_types[type]) {
+ switch (type) {
+ case OB_DEBUG_FOCUS:
+ fprintf(stderr, "FOCUS: ");
+ break;
+ case OB_DEBUG_APP_BUGS:
+ fprintf(stderr, "APPLICATION BUG: ");
+ break;
+ default:
+ g_assert_not_reached();
+ }
+
va_start(vl, a);
vfprintf(stderr, a, vl);
va_end(vl);
typedef enum {
OB_DEBUG_FOCUS,
+ OB_DEBUG_APP_BUGS,
OB_DEBUG_TYPE_NUM
} ObDebugType;
/* This means focus moved from one client to another */
if (detail == NotifyNonlinearVirtual)
return TRUE;
+ /* This means focus moved to the frame window */
+ if (detail == NotifyInferior)
+ return TRUE;
/* Otherwise.. */
return FALSE;
guint d = e->xclient.data.l[0];
if (d < screen_num_desktops) {
event_curtime = e->xclient.data.l[1];
- ob_debug("SWITCH DESKTOP TIME: %d\n", event_curtime);
+ if (event_curtime == 0)
+ ob_debug_type(OB_DEBUG_APP_BUGS,
+ "_NET_CURRENT_DESKTOP message is missing "
+ "a timestamp\n");
screen_set_desktop(d);
}
} else if (msgtype == prop_atoms.net_number_of_desktops) {
screen_set_num_desktops(d);
} else if (msgtype == prop_atoms.net_showing_desktop) {
screen_show_desktop(e->xclient.data.l[0] != 0, TRUE);
- } else if (msgtype == prop_atoms.ob_control) {
+ } else if (msgtype == prop_atoms.openbox_control) {
if (e->xclient.data.l[0] == 1)
ob_reconfigure();
else if (e->xclient.data.l[0] == 2)
{
XEvent ce;
Atom msgtype;
- gint i=0;
ObFrameContext con;
switch (e->type) {
break;
}
case ConfigureRequest:
- /* compress these */
- while (XCheckTypedWindowEvent(ob_display, client->window,
- ConfigureRequest, &ce)) {
- ++i;
- /* XXX if this causes bad things.. we can compress config req's
- with the same mask. */
- e->xconfigurerequest.value_mask |=
- ce.xconfigurerequest.value_mask;
- if (ce.xconfigurerequest.value_mask & CWX)
- e->xconfigurerequest.x = ce.xconfigurerequest.x;
- if (ce.xconfigurerequest.value_mask & CWY)
- e->xconfigurerequest.y = ce.xconfigurerequest.y;
- if (ce.xconfigurerequest.value_mask & CWWidth)
- e->xconfigurerequest.width = ce.xconfigurerequest.width;
- if (ce.xconfigurerequest.value_mask & CWHeight)
- e->xconfigurerequest.height = ce.xconfigurerequest.height;
- if (ce.xconfigurerequest.value_mask & CWBorderWidth)
- e->xconfigurerequest.border_width =
- ce.xconfigurerequest.border_width;
- if (ce.xconfigurerequest.value_mask & CWStackMode)
- e->xconfigurerequest.detail = ce.xconfigurerequest.detail;
- }
+ /* dont compress these unless you're going to watch for property
+ notifies in between (these can change what the configure would
+ do to the window).
+ also you can't compress stacking events
+ */
+
+ ob_debug("ConfigureRequest desktop %d wmstate %d vis %d\n",
+ screen_desktop, client->wmstate, client->frame->visible);
- /* if we are iconic (or shaded (fvwm does this)) ignore the event */
- if (client->iconic || client->shaded) return;
+ /* don't allow clients to move shaded windows (fvwm does this) */
+ if (client->shaded) {
+ e->xconfigurerequest.value_mask &= ~CWX;
+ e->xconfigurerequest.value_mask &= ~CWY;
+ }
/* resize, then move, as specified in the EWMH section 7.7 */
if (e->xconfigurerequest.value_mask & (CWWidth | CWHeight |
e->xconfigurerequest.value_mask & CWX, x,
e->xconfigurerequest.value_mask & CWY, y);
+ /* check for broken apps moving to their root position
+
+ XXX remove this some day...that would be nice. right now all
+ kde apps do this when they try activate themselves on another
+ desktop. eg. open amarok window on desktop 1, switch to desktop
+ 2, click amarok tray icon. it will move by its decoration size.
+ */
+ if (x != client->area.x &&
+ x == (client->frame->area.x + client->frame->size.left -
+ (gint)client->border_width) &&
+ y != client->area.y &&
+ y == (client->frame->area.y + client->frame->size.top -
+ (gint)client->border_width))
+ {
+ ob_debug_type(OB_DEBUG_APP_BUGS,
+ "Application %s is trying to move via "
+ "ConfigureRequest to it's root window position "
+ "but it is not using StaticGravity\n",
+ client->title);
+ /* don't move it */
+ x = client->area.x;
+ y = client->area.y;
+ }
+
client_find_onscreen(client, &x, &y, w, h, FALSE);
client_configure_full(client, x, y, w, h, FALSE, TRUE, TRUE);
}
(e->xclient.data.l[0] == 0 ? "unknown" :
(e->xclient.data.l[0] == 1 ? "application" :
(e->xclient.data.l[0] == 2 ? "user" : "INVALID"))));
- /* XXX make use of data.l[2] ! */
+ /* XXX make use of data.l[2] !? */
event_curtime = e->xclient.data.l[1];
+ ob_debug_type(OB_DEBUG_APP_BUGS,
+ "_NET_ACTIVE_WINDOW message for window %s is "
+ "missing a timestamp\n", client->title);
client_activate(client, FALSE,
(e->xclient.data.l[0] == 0 ||
e->xclient.data.l[0] == 2));
{
/* the frame may not be "visible" but they can still click on it
in the case where it is animating before disappearing */
- if (client && frame_visible(client->frame))
+ if (!client || !frame_iconify_animating(client->frame))
mouse_event(client, e);
} else if (e->type == KeyPress) {
keyboard_event((focus_cycle_target ? focus_cycle_target :
{
if (self->visible) {
self->visible = FALSE;
- self->client->ignore_unmaps += 1;
+ if (!frame_iconify_animating(self))
+ XUnmapWindow(ob_display, self->window);
/* we unmap the client itself so that we can get MapRequest
events, and because the ICCCM tells us to! */
- XUnmapWindow(ob_display, self->window);
XUnmapWindow(ob_display, self->client->window);
+ self->client->ignore_unmaps += 1;
}
}
vals[3] = self->size.bottom;
PROP_SETA32(self->client->window, net_frame_extents,
cardinal, vals, 4);
+ PROP_SETA32(self->client->window, kde_net_wm_frame_strut,
+ cardinal, vals, 4);
}
/* if this occurs while we are focus cycling, the indicator needs to
/* see if there is an animation going */
if (self->iconify_animation_going == 0) return;
- /* call the callback when it's done */
- if (self->iconify_animation_cb)
- self->iconify_animation_cb(self->iconify_animation_data);
+ if (!self->visible)
+ XUnmapWindow(ob_display, self->window);
+
/* we're not animating any more ! */
self->iconify_animation_going = 0;
- /* move after the callback for the animation ending */
XMoveResizeWindow(ob_display, self->window,
self->area.x, self->area.y,
self->area.width - self->bwidth * 2,
XFlush(ob_display);
}
-void frame_begin_iconify_animation(ObFrame *self, gboolean iconifying,
- ObFrameIconifyAnimateFunc callback,
- gpointer data)
+void frame_begin_iconify_animation(ObFrame *self, gboolean iconifying)
{
gulong time;
gboolean new_anim = FALSE;
/* if there is no titlebar, just don't animate for now
XXX it would be nice tho.. */
- if (!(self->decorations & OB_FRAME_DECOR_TITLEBAR)) {
- if (callback) callback(data);
+ if (!(self->decorations & OB_FRAME_DECOR_TITLEBAR))
return;
- }
/* get the current time */
g_get_current_time(&now);
new_anim = TRUE;
self->iconify_animation_going = iconifying ? 1 : -1;
- self->iconify_animation_cb = callback;
- self->iconify_animation_data = data;
-
/* set the ending time */
if (set_end) {
self->iconify_animation_end.tv_sec = now.tv_sec;
/* do the first step */
frame_animate_iconify(self);
+ /* show it during the animation even if it is not "visible" */
if (!self->visible)
- frame_show(self);
+ XMapWindow(ob_display, self->window);
}
}
-
-gboolean frame_visible(ObFrame *self)
-{
- /* if it is animating back from iconic state then it is considered
- visible. but if it is iconifying then it is not visible. */
- return self->visible && self->iconify_animation_going <= 0;
-}
Strut size;
Rect area;
- /*! Is the frame visible? Don't read this directly ! Use frame_visible()
- instead, because that takes into account if the frame is visible but
- animating to the iconic (invisible) state. */
gboolean visible;
guint decorations;
*/
gint iconify_animation_going;
GTimeVal iconify_animation_end;
- ObFrameIconifyAnimateFunc iconify_animation_cb;
- gpointer iconify_animation_data;
};
ObFrame *frame_new(struct _ObClient *c);
/*! Start an animation for iconifying or restoring a frame. The callback
will be called when the animation finishes. But if another animation is
started in the meantime, the callback will never get called. */
-void frame_begin_iconify_animation(ObFrame *self, gboolean iconifying,
- ObFrameIconifyAnimateFunc callback,
- gpointer data);
+void frame_begin_iconify_animation(ObFrame *self, gboolean iconifying);
void frame_end_iconify_animation(ObFrame *self);
-/* Returns true if the frame is visible (but false if it is only visible
- because it is animating */
-gboolean frame_visible(ObFrame *self);
-
#define frame_iconify_animating(f) (f->iconify_animation_going != 0)
#endif
moving = (cnr == prop_atoms.net_wm_moveresize_move ||
cnr == prop_atoms.net_wm_moveresize_move_keyboard);
- if (moveresize_in_progress || !frame_visible(c->frame) ||
+ if (moveresize_in_progress || !c->frame->visible ||
!(moving ?
(c->functions & OB_CLIENT_FUNC_MOVE) :
(c->functions & OB_CLIENT_FUNC_RESIZE)))
* remote_control = 1 -> reconfigure
* remote_control = 2 -> restart */
PROP_MSG(RootWindow(ob_display, ob_screen),
- ob_control, remote_control, 0, 0, 0);
+ openbox_control, remote_control, 0, 0, 0);
XCloseDisplay(ob_display);
exit(EXIT_SUCCESS);
}
xsync = TRUE;
} else if (!strcmp(argv[i], "--debug")) {
ob_debug_show_output(TRUE);
+ ob_debug_enable(OB_DEBUG_APP_BUGS, TRUE);
} else if (!strcmp(argv[i], "--debug-focus")) {
ob_debug_show_output(TRUE);
+ ob_debug_enable(OB_DEBUG_APP_BUGS, TRUE);
ob_debug_enable(OB_DEBUG_FOCUS, TRUE);
} else if (!strcmp(argv[i], "--reconfigure")) {
remote_control = 1;
} ObSmartType;
#define SMART_IGNORE(placer, c) \
- (placer == c || c->shaded || !client_normal(c) || \
- !frame_visible(c->frame) || \
+ (placer == c || c->shaded || !client_normal(c) || !c->frame->visible || \
(c->desktop != DESKTOP_ALL && \
c->desktop != (placer->desktop == DESKTOP_ALL ? \
screen_desktop : placer->desktop)))
CREATE(net_current_desktop, "_NET_CURRENT_DESKTOP");
CREATE(net_desktop_names, "_NET_DESKTOP_NAMES");
CREATE(net_active_window, "_NET_ACTIVE_WINDOW");
+/* CREATE(net_restack_window, "_NET_RESTACK_WINDOW");*/
CREATE(net_workarea, "_NET_WORKAREA");
CREATE(net_supporting_wm_check, "_NET_SUPPORTING_WM_CHECK");
CREATE(net_desktop_layout, "_NET_DESKTOP_LAYOUT");
/* CREATE(net_wm_pid, "_NET_WM_PID"); */
CREATE(net_wm_allowed_actions, "_NET_WM_ALLOWED_ACTIONS");
CREATE(net_wm_user_time, "_NET_WM_USER_TIME");
+ CREATE(kde_net_wm_frame_strut, "_KDE_NET_WM_FRAME_STRUT");
CREATE(net_frame_extents, "_NET_FRAME_EXTENTS");
/* CREATE(net_wm_ping, "_NET_WM_PING"); */
CREATE(net_wm_action_change_desktop, "_NET_WM_ACTION_CHANGE_DESKTOP");
CREATE(net_wm_action_close, "_NET_WM_ACTION_CLOSE");
CREATE(net_wm_state_modal, "_NET_WM_STATE_MODAL");
- CREATE(net_wm_state_sticky, "_NET_WM_STATE_STICKY");
+/* CREATE(net_wm_state_sticky, "_NET_WM_STATE_STICKY");*/
CREATE(net_wm_state_maximized_vert, "_NET_WM_STATE_MAXIMIZED_VERT");
CREATE(net_wm_state_maximized_horz, "_NET_WM_STATE_MAXIMIZED_HORZ");
CREATE(net_wm_state_shaded, "_NET_WM_STATE_SHADED");
CREATE(kde_wm_change_state, "_KDE_WM_CHANGE_STATE");
CREATE(kde_net_wm_window_type_override,"_KDE_NET_WM_WINDOW_TYPE_OVERRIDE");
+/*
CREATE(rootpmapid, "_XROOTPMAP_ID");
CREATE(esetrootid, "ESETROOT_PMAP_ID");
+*/
CREATE(openbox_pid, "_OPENBOX_PID");
CREATE(openbox_rc, "_OPENBOX_RC");
- CREATE(ob_wm_state_undecorated, "_OB_WM_STATE_UNDECORATED");
- CREATE(ob_control, "_OB_CONTROL");
+ CREATE(openbox_wm_state_undecorated, "_OB_WM_STATE_UNDECORATED");
+ CREATE(openbox_control, "_OB_CONTROL");
}
#include <X11/Xutil.h>
/* NETWM atoms */
- Atom net_wm_full_placement;
+ /* Atoms that are used inside messages - these don't go in net_supported */
+
+ Atom net_wm_moveresize_size_topleft;
+ Atom net_wm_moveresize_size_top;
+ Atom net_wm_moveresize_size_topright;
+ Atom net_wm_moveresize_size_right;
+ Atom net_wm_moveresize_size_bottomright;
+ Atom net_wm_moveresize_size_bottom;
+ Atom net_wm_moveresize_size_bottomleft;
+ Atom net_wm_moveresize_size_left;
+ Atom net_wm_moveresize_move;
+ Atom net_wm_moveresize_size_keyboard;
+ Atom net_wm_moveresize_move_keyboard;
+ Atom net_wm_moveresize_cancel;
+
+ Atom net_wm_state_add;
+ Atom net_wm_state_remove;
+ Atom net_wm_state_toggle;
+
+ Atom net_wm_orientation_horz;
+ Atom net_wm_orientation_vert;
+ Atom net_wm_topleft;
+ Atom net_wm_topright;
+ Atom net_wm_bottomright;
+ Atom net_wm_bottomleft;
+
+ /* Everything below here must go in net_supported on the root window */
/* root window properties */
Atom net_supported;
Atom net_current_desktop;
Atom net_desktop_names;
Atom net_active_window;
+/* Atom net_restack_window;*/
Atom net_workarea;
Atom net_supporting_wm_check;
Atom net_desktop_layout;
Atom net_showing_desktop;
+
/* root window messages */
Atom net_close_window;
Atom net_wm_moveresize;
Atom net_moveresize_window;
+ /* helpful hints to apps that aren't used for anything */
+ Atom net_wm_full_placement;
+
/* startup-notification extension */
Atom net_startup_id;
Atom net_wm_window_type_dialog;
Atom net_wm_window_type_normal;
- Atom net_wm_moveresize_size_topleft;
- Atom net_wm_moveresize_size_top;
- Atom net_wm_moveresize_size_topright;
- Atom net_wm_moveresize_size_right;
- Atom net_wm_moveresize_size_bottomright;
- Atom net_wm_moveresize_size_bottom;
- Atom net_wm_moveresize_size_bottomleft;
- Atom net_wm_moveresize_size_left;
- Atom net_wm_moveresize_move;
- Atom net_wm_moveresize_size_keyboard;
- Atom net_wm_moveresize_move_keyboard;
- Atom net_wm_moveresize_cancel;
-
Atom net_wm_action_move;
Atom net_wm_action_resize;
Atom net_wm_action_minimize;
Atom net_wm_action_close;
Atom net_wm_state_modal;
- Atom net_wm_state_sticky;
+/* Atom net_wm_state_sticky;*/
Atom net_wm_state_maximized_vert;
Atom net_wm_state_maximized_horz;
Atom net_wm_state_shaded;
Atom net_wm_state_below;
Atom net_wm_state_demands_attention;
- Atom net_wm_state_add;
- Atom net_wm_state_remove;
- Atom net_wm_state_toggle;
-
- Atom net_wm_orientation_horz;
- Atom net_wm_orientation_vert;
- Atom net_wm_topleft;
- Atom net_wm_topright;
- Atom net_wm_bottomright;
- Atom net_wm_bottomleft;
-
- /* Extra atoms */
+ /* KDE atoms */
Atom kde_wm_change_state;
+ Atom kde_net_wm_frame_strut;
Atom kde_net_wm_window_type_override;
+/*
Atom rootpmapid;
Atom esetrootid;
+*/
/* Openbox specific atoms */
+ Atom openbox_wm_state_undecorated;
Atom openbox_pid;
Atom openbox_rc;
- Atom ob_wm_state_undecorated;
- Atom ob_control;
+ Atom openbox_control;
} Atoms;
Atoms prop_atoms;
target = it->data;
/* don't snap to self or non-visibles */
- if (!frame_visible(target->frame) || target == c) continue;
+ if (!target->frame->visible || target == c) continue;
/* don't snap to windows in layers beneath */
if(target->layer < c->layer && !config_resist_layers_below)
target = it->data;
/* don't snap to invisibles or ourself */
- if (!frame_visible(target->frame) || target == c) continue;
+ if (!target->frame->visible || target == c) continue;
/* don't snap to windows in layers beneath */
if(target->layer < c->layer && !config_resist_layers_below)
XSetWindowAttributes attrib;
pid_t pid;
gint i, num_support;
+ Atom *prop_atoms_start, *wm_supported_pos;
gulong *supported;
/* create the netwm support window */
window, screen_support_win);
/* set the _NET_SUPPORTED_ATOMS hint */
- num_support = 55;
-#ifdef SYNC
- num_support += 2;
-#endif
+
+ /* 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;
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_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_moveresize;
supported[i++] = prop_atoms.net_wm_user_time;
supported[i++] = prop_atoms.net_frame_extents;
+ supported[i++] = prop_atoms.net_startup_id;
#ifdef SYNC
supported[i++] = prop_atoms.net_wm_sync_request;
supported[i++] = prop_atoms.net_wm_sync_request_counter;
#endif
- supported[i++] = prop_atoms.ob_wm_state_undecorated;
+
+ 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.openbox_wm_state_undecorated;
+ supported[i++] = prop_atoms.openbox_pid;
+ supported[i++] = prop_atoms.openbox_rc;
+ supported[i++] = prop_atoms.openbox_control;
g_assert(i == num_support);
PROP_SETA32(RootWindow(ob_display, ob_screen),
projects / dana / openbox.git / commitdiff