+#include "debug.h"
#include "client.h"
#include "dock.h"
#include "xerror.h"
GList *client_list = NULL;
-static void client_get_all(Client *self);
-static void client_toggle_border(Client *self, gboolean show);
-static void client_get_area(Client *self);
-static void client_get_desktop(Client *self);
-static void client_get_state(Client *self);
-static void client_get_shaped(Client *self);
-static void client_get_mwm_hints(Client *self);
-static void client_get_gravity(Client *self);
-static void client_showhide(Client *self);
-static void client_change_allowed_actions(Client *self);
-static void client_change_state(Client *self);
-static void client_apply_startup_state(Client *self);
+static void client_get_all(ObClient *self);
+static void client_toggle_border(ObClient *self, gboolean show);
+static void client_get_area(ObClient *self);
+static void client_get_desktop(ObClient *self);
+static void client_get_state(ObClient *self);
+static void client_get_shaped(ObClient *self);
+static void client_get_mwm_hints(ObClient *self);
+static void client_get_gravity(ObClient *self);
+static void client_showhide(ObClient *self);
+static void client_change_allowed_actions(ObClient *self);
+static void client_change_state(ObClient *self);
+static void client_apply_startup_state(ObClient *self);
void client_startup()
{
windows = g_new(Window, size);
win_it = windows;
for (it = client_list; it != NULL; it = it->next, ++win_it)
- *win_it = ((Client*)it->data)->window;
+ *win_it = ((ObClient*)it->data)->window;
} else
windows = NULL;
- PROP_SETA32(ob_root, net_client_list, window, (guint32*)windows, size);
+ PROP_SETA32(RootWindow(ob_display, ob_screen),
+ net_client_list, window, (guint32*)windows, size);
if (windows)
g_free(windows);
}
/*
-void client_foreach_transient(Client *self, ClientForeachFunc func, void *data)
+void client_foreach_transient(ObClient *self, ObClientForeachFunc func, void *data)
{
GSList *it;
}
}
-void client_foreach_ancestor(Client *self, ClientForeachFunc func, void *data)
+void client_foreach_ancestor(ObClient *self, ObClientForeachFunc func, void *data)
{
if (self->transient_for) {
- if (self->transient_for != TRAN_GROUP) {
+ if (self->transient_for != OB_TRAN_GROUP) {
if (!func(self->transient_for, data)) return;
client_foreach_ancestor(self->transient_for, func, data);
} else {
for (it = self->group->members; it; it = it->next)
if (it->data != self &&
- !((Client*)it->data)->transient_for) {
+ !((ObClient*)it->data)->transient_for) {
if (!func(it->data, data)) return;
client_foreach_ancestor(it->data, func, data);
}
XWMHints *wmhints;
XWindowAttributes attrib;
- XQueryTree(ob_display, ob_root, &w, &w, &children, &nchild);
+ XQueryTree(ob_display, RootWindow(ob_display, ob_screen),
+ &w, &w, &children, &nchild);
/* remove all icon windows from the list */
for (i = 0; i < nchild; i++) {
if (active) {
g_assert(WINDOW_IS_CLIENT(active));
if (!client_focus(WINDOW_AS_CLIENT(active)))
- focus_fallback(Fallback_NoFocus);
+ focus_fallback(OB_FOCUS_FALLBACK_NOFOCUS);
} else
- focus_fallback(Fallback_NoFocus);
+ focus_fallback(OB_FOCUS_FALLBACK_NOFOCUS);
}
}
void client_manage(Window window)
{
- Client *self;
+ ObClient *self;
XEvent e;
XWindowAttributes attrib;
XSetWindowAttributes attrib_set;
XFree(wmhint);
}
- g_message("Managing window: %lx", window);
+ ob_debug("Managing window: %lx\n", window);
/* choose the events we want to receive on the CLIENT window */
attrib_set.event_mask = CLIENT_EVENTMASK;
CWEventMask|CWDontPropagate, &attrib_set);
- /* create the Client struct, and populate it from the hints on the
+ /* create the ObClient struct, and populate it from the hints on the
window */
- self = g_new(Client, 1);
+ self = g_new(ObClient, 1);
self->obwin.type = Window_Client;
self->window = window;
client_get_all(self);
/* update the focus lists */
focus_order_add_new(self);
- /* focus the new window? */
- if (ob_state != State_Starting && config_focus_new &&
- (self->type == Type_Normal || self->type == Type_Dialog)) {
- gboolean group_foc = FALSE;
-
- if (self->group) {
- GSList *it;
+ stacking_add(CLIENT_AS_WINDOW(self));
- for (it = self->group->members; it; it = it->next) {
- if (client_focused(it->data)) {
- group_foc = TRUE;
- break;
- }
- }
- }
+ /* focus the new window? */
+ if (ob_state() != OB_STATE_STARTING && config_focus_new &&
/* note the check against Type_Normal/Dialog, not client_normal(self),
which would also include other types. in this case we want more
strict rules for focus */
- if ((group_foc ||
- (!self->transient_for && (!self->group ||
- !self->group->members->next))) ||
- client_search_focus_tree_full(self) ||
- !focus_client ||
- !client_normal(focus_client)) {
+ (self->type == OB_CLIENT_TYPE_NORMAL ||
+ self->type == OB_CLIENT_TYPE_DIALOG))
+ {
+ if (self->desktop != screen_desktop) {
/* activate the window */
- stacking_add(CLIENT_AS_WINDOW(self));
activate = TRUE;
} else {
- /* try to not get in the way */
- stacking_add_nonintrusive(CLIENT_AS_WINDOW(self));
+ gboolean group_foc = FALSE;
+
+ if (self->group) {
+ GSList *it;
+
+ for (it = self->group->members; it; it = it->next)
+ {
+ if (client_focused(it->data))
+ {
+ group_foc = TRUE;
+ break;
+ }
+ }
+ }
+ if ((group_foc ||
+ (!self->transient_for && (!self->group ||
+ !self->group->members->next))) ||
+ client_search_focus_tree_full(self) ||
+ !focus_client ||
+ !client_normal(focus_client))
+ {
+ /* activate the window */
+ activate = TRUE;
+ }
}
- } else {
- stacking_add(CLIENT_AS_WINDOW(self));
}
- screen_update_struts();
-
dispatch_client(Event_Client_New, self, 0, 0);
/* make sure the window is visible */
client_move_onscreen(self);
+ screen_update_areas();
+
client_showhide(self);
- if (activate) client_activate(self);
+ /* use client_focus instead of client_activate cuz client_activate does
+ stuff like switch desktops etc and I'm not interested in all that when
+ a window maps since its not based on an action from the user like
+ clicking a window to activate is. so keep the new window out of the way
+ but do focus it. */
+ if (activate) client_focus(self);
+
+ /* client_activate does this but we aret using it so we have to do it
+ here as well */
+ if (screen_showing_desktop)
+ screen_show_desktop(FALSE);
/* update the list hints */
client_set_list();
dispatch_client(Event_Client_Mapped, self, 0, 0);
- g_message("Managed window 0x%lx (%s)", window, self->class);
+ ob_debug("Managed window 0x%lx (%s)\n", window, self->class);
}
void client_unmanage_all()
/* called by client_unmanage() to close any menus referencing this client */
void client_close_menus(gpointer key, gpointer value, gpointer self)
{
- if (((Menu *)value)->client == (Client *)self)
- menu_hide((Menu *)value);
+ if (((ObMenu *)value)->client == (ObClient *)self)
+ menu_hide((ObMenu *)value);
}
-void client_unmanage(Client *self)
+void client_unmanage(ObClient *self)
{
- int j;
+ guint j;
GSList *it;
- g_message("Unmanaging window: %lx (%s)", self->window, self->class);
+ ob_debug("Unmanaging window: %lx (%s)\n", self->window, self->class);
dispatch_client(Event_Client_Destroy, self, 0, 0);
g_assert(self != NULL);
/* once the client is out of the list, update the struts to remove it's
influence */
- screen_update_struts();
+ screen_update_areas();
/* tell our parent(s) that we're gone */
- if (self->transient_for == TRAN_GROUP) { /* transient of group */
+ if (self->transient_for == OB_TRAN_GROUP) { /* transient of group */
GSList *it;
for (it = self->group->members; it; it = it->next)
if (it->data != self)
- ((Client*)it->data)->transients =
- g_slist_remove(((Client*)it->data)->transients, self);
+ ((ObClient*)it->data)->transients =
+ g_slist_remove(((ObClient*)it->data)->transients, self);
} else if (self->transient_for) { /* transient of window */
self->transient_for->transients =
g_slist_remove(self->transient_for->transients, self);
/* tell our transients that we're gone */
for (it = self->transients; it != NULL; it = it->next) {
- if (((Client*)it->data)->transient_for != TRAN_GROUP) {
- ((Client*)it->data)->transient_for = NULL;
+ if (((ObClient*)it->data)->transient_for != OB_TRAN_GROUP) {
+ ((ObClient*)it->data)->transient_for = NULL;
client_calc_layer(it->data);
}
}
frame_release_client(self->frame, self);
self->frame = NULL;
- if (ob_state != State_Exiting) {
+ if (ob_state() != OB_STATE_EXITING) {
/* these values should not be persisted across a window
unmapping/mapping */
prop_erase(self->window, prop_atoms.net_wm_desktop);
}
- g_message("Unmanaged window 0x%lx", self->window);
+ ob_debug("Unmanaged window 0x%lx\n", self->window);
/* free all data allocated in the client struct */
g_slist_free(self->transients);
client_set_list();
}
-void client_move_onscreen(Client *self)
+void client_move_onscreen(ObClient *self)
{
Rect *a;
int x = self->frame->area.x, y = self->frame->area.y;
+ /* XXX watch for xinerama dead areas */
a = screen_area(self->desktop);
if (x >= a->x + a->width - 1)
x = a->x + a->width - self->frame->area.width;
frame_frame_gravity(self->frame, &x, &y); /* get where the client
should be */
- client_configure(self , Corner_TopLeft, x, y,
+ client_configure(self, OB_CORNER_TOPLEFT, x, y,
self->area.width, self->area.height,
TRUE, TRUE);
}
-static void client_toggle_border(Client *self, gboolean show)
+static void client_toggle_border(ObClient *self, gboolean show)
{
/* adjust our idea of where the client is, based on its border. When the
border is removed, the client should now be considered to be in a
}
-static void client_get_all(Client *self)
+static void client_get_all(ObClient *self)
{
/* update EVERYTHING!! */
self->layer = -1;
self->urgent = FALSE;
self->positioned = FALSE;
- self->disabled_decorations = 0;
+ self->decorate = TRUE;
self->group = NULL;
self->nicons = 0;
client_change_state(self);
}
-static void client_get_area(Client *self)
+static void client_get_area(ObClient *self)
{
XWindowAttributes wattrib;
Status ret;
self->border_width = wattrib.border_width;
}
-static void client_get_desktop(Client *self)
+static void client_get_desktop(ObClient *self)
{
guint32 d = screen_num_desktops; /* an always-invalid value */
self->desktop = screen_num_desktops - 1;
else
self->desktop = d;
- } else {
+ } else {
gboolean trdesk = FALSE;
if (self->transient_for) {
- if (self->transient_for != TRAN_GROUP) {
+ if (self->transient_for != OB_TRAN_GROUP) {
self->desktop = self->transient_for->desktop;
trdesk = TRUE;
} else {
for (it = self->group->members; it; it = it->next)
if (it->data != self &&
- !((Client*)it->data)->transient_for) {
- self->desktop = ((Client*)it->data)->desktop;
+ !((ObClient*)it->data)->transient_for) {
+ self->desktop = ((ObClient*)it->data)->desktop;
trdesk = TRUE;
break;
}
}
}
-static void client_get_state(Client *self)
+static void client_get_state(ObClient *self)
{
guint32 *state;
guint num;
}
}
-static void client_get_shaped(Client *self)
+static void client_get_shaped(ObClient *self)
{
self->shaped = FALSE;
#ifdef SHAPE
#endif
}
-void client_update_transient_for(Client *self)
+void client_update_transient_for(ObClient *self)
{
Window t = None;
- Client *c = NULL;
+ ObClient *target = NULL;
if (XGetTransientForHint(ob_display, self->window, &t)) {
self->transient = TRUE;
if (t != self->window) { /* cant be transient to itself! */
- c = g_hash_table_lookup(window_map, &t);
+ target = g_hash_table_lookup(window_map, &t);
/* if this happens then we need to check for it*/
- g_assert(c != self);
- g_assert(!c || WINDOW_IS_CLIENT(c));
+ g_assert(target != self);
+ g_assert(!target || WINDOW_IS_CLIENT(target));
- if (!c && self->group) {
+ if (!target && self->group) {
/* not transient to a client, see if it is transient for a
group */
if (t == self->group->leader ||
t == None ||
- t == ob_root) {
+ t == RootWindow(ob_display, ob_screen)) {
/* window is a transient for its group! */
- c = TRAN_GROUP;
+ target = OB_TRAN_GROUP;
}
}
}
self->transient = FALSE;
/* if anything has changed... */
- if (c != self->transient_for) {
- if (self->transient_for == TRAN_GROUP) { /* transient of group */
+ if (target != self->transient_for) {
+ if (self->transient_for == OB_TRAN_GROUP) { /* transient of group */
GSList *it;
/* remove from old parents */
- for (it = self->group->members; it; it = it->next)
- if (it->data != self &&
- !((Client*)it->data)->transient_for)
- ((Client*)it->data)->transients =
- g_slist_remove(((Client*)it->data)->transients, self);
+ for (it = self->group->members; it; it = g_slist_next(it)) {
+ ObClient *c = it->data;
+ if (c != self && !c->transient_for)
+ c->transients = g_slist_remove(c->transients, self);
+ }
} else if (self->transient_for != NULL) { /* transient of window */
/* remove from old parent */
self->transient_for->transients =
g_slist_remove(self->transient_for->transients, self);
}
- self->transient_for = c;
- if (self->transient_for == TRAN_GROUP) { /* transient of group */
+ self->transient_for = target;
+ if (self->transient_for == OB_TRAN_GROUP) { /* transient of group */
GSList *it;
/* add to new parents */
- for (it = self->group->members; it; it = it->next)
- if (it->data != self &&
- !((Client*)it->data)->transient_for)
- ((Client*)it->data)->transients =
- g_slist_append(((Client*)it->data)->transients, self);
+ for (it = self->group->members; it; it = g_slist_next(it)) {
+ ObClient *c = it->data;
+ if (c != self && !c->transient_for)
+ c->transients = g_slist_append(c->transients, self);
+ }
/* remove all transients which are in the group, that causes
circlular pointer hell of doom */
- for (it = self->group->members; it; it = it->next) {
+ for (it = self->group->members; it; it = g_slist_next(it)) {
GSList *sit, *next;
for (sit = self->transients; sit; sit = next) {
- next = sit->next;
+ next = g_slist_next(sit);
if (sit->data == it->data)
- self->transients = g_slist_remove(self->transients,
- sit->data);
+ self->transients =
+ g_slist_delete_link(self->transients, sit);
}
}
} else if (self->transient_for != NULL) { /* transient of window */
}
}
-static void client_get_mwm_hints(Client *self)
+static void client_get_mwm_hints(ObClient *self)
{
guint num;
guint32 *hints;
if (PROP_GETA32(self->window, motif_wm_hints, motif_wm_hints,
&hints, &num)) {
- if (num >= MWM_ELEMENTS) {
+ if (num >= OB_MWM_ELEMENTS) {
self->mwmhints.flags = hints[0];
self->mwmhints.functions = hints[1];
self->mwmhints.decorations = hints[2];
}
}
-void client_get_type(Client *self)
+void client_get_type(ObClient *self)
{
guint num, i;
guint32 *val;
/* use the first value that we know about in the array */
for (i = 0; i < num; ++i) {
if (val[i] == prop_atoms.net_wm_window_type_desktop)
- self->type = Type_Desktop;
+ self->type = OB_CLIENT_TYPE_DESKTOP;
else if (val[i] == prop_atoms.net_wm_window_type_dock)
- self->type = Type_Dock;
+ self->type = OB_CLIENT_TYPE_DOCK;
else if (val[i] == prop_atoms.net_wm_window_type_toolbar)
- self->type = Type_Toolbar;
+ self->type = OB_CLIENT_TYPE_TOOLBAR;
else if (val[i] == prop_atoms.net_wm_window_type_menu)
- self->type = Type_Menu;
+ self->type = OB_CLIENT_TYPE_MENU;
else if (val[i] == prop_atoms.net_wm_window_type_utility)
- self->type = Type_Utility;
+ self->type = OB_CLIENT_TYPE_UTILITY;
else if (val[i] == prop_atoms.net_wm_window_type_splash)
- self->type = Type_Splash;
+ self->type = OB_CLIENT_TYPE_SPLASH;
else if (val[i] == prop_atoms.net_wm_window_type_dialog)
- self->type = Type_Dialog;
+ self->type = OB_CLIENT_TYPE_DIALOG;
else if (val[i] == prop_atoms.net_wm_window_type_normal)
- self->type = Type_Normal;
+ self->type = OB_CLIENT_TYPE_NORMAL;
else if (val[i] == prop_atoms.kde_net_wm_window_type_override) {
/* prevent this window from getting any decor or
functionality */
- self->mwmhints.flags &= (MwmFlag_Functions |
- MwmFlag_Decorations);
+ self->mwmhints.flags &= (OB_MWM_FLAG_FUNCTIONS |
+ OB_MWM_FLAG_DECORATIONS);
self->mwmhints.decorations = 0;
self->mwmhints.functions = 0;
}
- if (self->type != (WindowType) -1)
+ if (self->type != (ObClientType) -1)
break; /* grab the first legit type */
}
g_free(val);
}
- if (self->type == (WindowType) -1) {
+ if (self->type == (ObClientType) -1) {
/*the window type hint was not set, which means we either classify
ourself as a normal window or a dialog, depending on if we are a
transient. */
if (self->transient)
- self->type = Type_Dialog;
+ self->type = OB_CLIENT_TYPE_DIALOG;
else
- self->type = Type_Normal;
+ self->type = OB_CLIENT_TYPE_NORMAL;
}
}
-void client_update_protocols(Client *self)
+void client_update_protocols(ObClient *self)
{
guint32 *proto;
guint num_return, i;
}
}
-static void client_get_gravity(Client *self)
+static void client_get_gravity(ObClient *self)
{
XWindowAttributes wattrib;
Status ret;
self->gravity = wattrib.win_gravity;
}
-void client_update_normal_hints(Client *self)
+void client_update_normal_hints(ObClient *self)
{
XSizeHints size;
long ret;
}
}
-void client_setup_decor_and_functions(Client *self)
+void client_setup_decor_and_functions(ObClient *self)
{
/* start with everything (cept fullscreen) */
- self->decorations = Decor_Titlebar | Decor_Handle | Decor_Border |
- Decor_Icon | Decor_AllDesktops | Decor_Iconify | Decor_Maximize |
- Decor_Shade;
- self->functions = Func_Resize | Func_Move | Func_Iconify | Func_Maximize |
- Func_Shade;
+ self->decorations = (OB_FRAME_DECOR_TITLEBAR |
+ OB_FRAME_DECOR_HANDLE |
+ OB_FRAME_DECOR_GRIPS |
+ OB_FRAME_DECOR_BORDER |
+ OB_FRAME_DECOR_ICON |
+ OB_FRAME_DECOR_ALLDESKTOPS |
+ OB_FRAME_DECOR_ICONIFY |
+ OB_FRAME_DECOR_MAXIMIZE |
+ OB_FRAME_DECOR_SHADE);
+ self->functions = (OB_CLIENT_FUNC_RESIZE |
+ OB_CLIENT_FUNC_MOVE |
+ OB_CLIENT_FUNC_ICONIFY |
+ OB_CLIENT_FUNC_MAXIMIZE |
+ OB_CLIENT_FUNC_SHADE);
if (self->delete_window) {
- self->decorations |= Decor_Close;
- self->functions |= Func_Close;
+ self->functions |= OB_CLIENT_FUNC_CLOSE;
+ self->decorations |= OB_FRAME_DECOR_CLOSE;
}
if (!(self->min_size.width < self->max_size.width ||
- self->min_size.height < self->max_size.height)) {
- self->decorations &= ~(Decor_Maximize | Decor_Handle);
- self->functions &= ~(Func_Resize | Func_Maximize);
- }
+ self->min_size.height < self->max_size.height))
+ self->functions &= ~OB_CLIENT_FUNC_RESIZE;
switch (self->type) {
- case Type_Normal:
+ case OB_CLIENT_TYPE_NORMAL:
/* normal windows retain all of the possible decorations and
functionality, and are the only windows that you can fullscreen */
- self->functions |= Func_Fullscreen;
+ self->functions |= OB_CLIENT_FUNC_FULLSCREEN;
break;
- case Type_Dialog:
- case Type_Utility:
+ case OB_CLIENT_TYPE_DIALOG:
+ case OB_CLIENT_TYPE_UTILITY:
/* these windows cannot be maximized */
- self->decorations &= ~Decor_Maximize;
- self->functions &= ~Func_Maximize;
+ self->functions &= ~OB_CLIENT_FUNC_MAXIMIZE;
break;
- case Type_Menu:
- case Type_Toolbar:
+ case OB_CLIENT_TYPE_MENU:
+ case OB_CLIENT_TYPE_TOOLBAR:
/* these windows get less functionality */
- self->decorations &= ~(Decor_Iconify | Decor_Handle);
- self->functions &= ~(Func_Iconify | Func_Resize);
+ self->functions &= ~(OB_CLIENT_FUNC_ICONIFY | OB_CLIENT_FUNC_RESIZE);
break;
- case Type_Desktop:
- case Type_Dock:
- case Type_Splash:
+ case OB_CLIENT_TYPE_DESKTOP:
+ case OB_CLIENT_TYPE_DOCK:
+ case OB_CLIENT_TYPE_SPLASH:
/* none of these windows are manipulated by the window manager */
self->decorations = 0;
self->functions = 0;
/* Mwm Hints are applied subtractively to what has already been chosen for
decor and functionality */
- if (self->mwmhints.flags & MwmFlag_Decorations) {
- if (! (self->mwmhints.decorations & MwmDecor_All)) {
- if (! (self->mwmhints.decorations & MwmDecor_Border))
- self->decorations &= ~Decor_Border;
- if (! (self->mwmhints.decorations & MwmDecor_Handle))
- self->decorations &= ~Decor_Handle;
- if (! (self->mwmhints.decorations & MwmDecor_Title))
- self->decorations &= ~Decor_Titlebar;
- if (! (self->mwmhints.decorations & MwmDecor_Iconify))
- self->decorations &= ~Decor_Iconify;
- if (! (self->mwmhints.decorations & MwmDecor_Maximize))
- self->decorations &= ~Decor_Maximize;
+ if (self->mwmhints.flags & OB_MWM_FLAG_DECORATIONS) {
+ if (! (self->mwmhints.decorations & OB_MWM_DECOR_ALL)) {
+ if (! ((self->mwmhints.decorations & OB_MWM_DECOR_HANDLE) ||
+ (self->mwmhints.decorations & OB_MWM_DECOR_TITLE)))
+ /* if the mwm hints request no handle or title, then all
+ decorations are disabled */
+ self->decorations = 0;
}
}
- if (self->mwmhints.flags & MwmFlag_Functions) {
- if (! (self->mwmhints.functions & MwmFunc_All)) {
- if (! (self->mwmhints.functions & MwmFunc_Resize))
- self->functions &= ~Func_Resize;
- if (! (self->mwmhints.functions & MwmFunc_Move))
- self->functions &= ~Func_Move;
- if (! (self->mwmhints.functions & MwmFunc_Iconify))
- self->functions &= ~Func_Iconify;
- if (! (self->mwmhints.functions & MwmFunc_Maximize))
- self->functions &= ~Func_Maximize;
+ if (self->mwmhints.flags & OB_MWM_FLAG_FUNCTIONS) {
+ if (! (self->mwmhints.functions & OB_MWM_FUNC_ALL)) {
+ if (! (self->mwmhints.functions & OB_MWM_FUNC_RESIZE))
+ self->functions &= ~OB_CLIENT_FUNC_RESIZE;
+ if (! (self->mwmhints.functions & OB_MWM_FUNC_MOVE))
+ self->functions &= ~OB_CLIENT_FUNC_MOVE;
+ /* dont let mwm hints kill any buttons
+ if (! (self->mwmhints.functions & OB_MWM_FUNC_ICONIFY))
+ self->functions &= ~OB_CLIENT_FUNC_ICONIFY;
+ if (! (self->mwmhints.functions & OB_MWM_FUNC_MAXIMIZE))
+ self->functions &= ~OB_CLIENT_FUNC_MAXIMIZE;
+ */
/* dont let mwm hints kill the close button
if (! (self->mwmhints.functions & MwmFunc_Close))
- self->functions &= ~Func_Close; */
+ self->functions &= ~OB_CLIENT_FUNC_CLOSE; */
}
}
+ if (!(self->functions & OB_CLIENT_FUNC_SHADE))
+ self->decorations &= ~OB_FRAME_DECOR_SHADE;
+ if (!(self->functions & OB_CLIENT_FUNC_ICONIFY))
+ self->decorations &= ~OB_FRAME_DECOR_ICONIFY;
+ if (!(self->functions & OB_CLIENT_FUNC_RESIZE))
+ self->decorations &= ~OB_FRAME_DECOR_GRIPS;
+
/* can't maximize without moving/resizing */
- if (!((self->functions & Func_Move) && (self->functions & Func_Resize)))
- self->functions &= ~(Func_Maximize | Func_Fullscreen);
-
- /* finally, user specified disabled decorations are applied to subtract
- decorations */
- if (self->disabled_decorations & Decor_Titlebar)
- self->decorations &= ~Decor_Titlebar;
- if (self->disabled_decorations & Decor_Handle)
- self->decorations &= ~Decor_Handle;
- if (self->disabled_decorations & Decor_Border)
- self->decorations &= ~Decor_Border;
- if (self->disabled_decorations & Decor_Iconify)
- self->decorations &= ~Decor_Iconify;
- if (self->disabled_decorations & Decor_Maximize)
- self->decorations &= ~Decor_Maximize;
- if (self->disabled_decorations & Decor_AllDesktops)
- self->decorations &= ~Decor_AllDesktops;
- if (self->disabled_decorations & Decor_Shade)
- self->decorations &= ~Decor_Shade;
- if (self->disabled_decorations & Decor_Close)
- self->decorations &= ~Decor_Close;
+ if (!((self->functions & OB_CLIENT_FUNC_MAXIMIZE) &&
+ (self->functions & OB_CLIENT_FUNC_MOVE) &&
+ (self->functions & OB_CLIENT_FUNC_RESIZE))) {
+ self->functions &= ~OB_CLIENT_FUNC_MAXIMIZE;
+ self->decorations &= ~OB_FRAME_DECOR_MAXIMIZE;
+ }
+
+ /* finally, the user can have requested no decorations, which overrides
+ everything */
+ if (!self->decorate)
+ self->decorations = 0;
/* if we don't have a titlebar, then we cannot shade! */
- if (!(self->decorations & Decor_Titlebar))
- self->functions &= ~Func_Shade;
+ if (!(self->decorations & OB_FRAME_DECOR_TITLEBAR))
+ self->functions &= ~OB_CLIENT_FUNC_SHADE;
/* now we need to check against rules for the client's current state */
if (self->fullscreen) {
- self->functions &= (Func_Close | Func_Fullscreen | Func_Iconify);
+ self->functions &= (OB_CLIENT_FUNC_CLOSE |
+ OB_CLIENT_FUNC_FULLSCREEN |
+ OB_CLIENT_FUNC_ICONIFY);
self->decorations = 0;
}
if (self->frame) {
/* this makes sure that these windows appear on all desktops */
- if (self->type == Type_Desktop && self->desktop != DESKTOP_ALL)
+ if (self->type == OB_CLIENT_TYPE_DESKTOP &&
+ self->desktop != DESKTOP_ALL)
client_set_desktop(self, DESKTOP_ALL, FALSE);
/* adjust the client's decorations, etc. */
client_reconfigure(self);
} else {
/* this makes sure that these windows appear on all desktops */
- if (self->type == Type_Desktop && self->desktop != DESKTOP_ALL)
+ if (self->type == OB_CLIENT_TYPE_DESKTOP &&
+ self->desktop != DESKTOP_ALL)
+ {
self->desktop = DESKTOP_ALL;
+ }
}
}
-static void client_change_allowed_actions(Client *self)
+static void client_change_allowed_actions(ObClient *self)
{
guint32 actions[9];
int num = 0;
/* desktop windows are kept on all desktops */
- if (self->type != Type_Desktop)
+ if (self->type != OB_CLIENT_TYPE_DESKTOP)
actions[num++] = prop_atoms.net_wm_action_change_desktop;
- if (self->functions & Func_Shade)
+ if (self->functions & OB_CLIENT_FUNC_SHADE)
actions[num++] = prop_atoms.net_wm_action_shade;
- if (self->functions & Func_Close)
+ if (self->functions & OB_CLIENT_FUNC_CLOSE)
actions[num++] = prop_atoms.net_wm_action_close;
- if (self->functions & Func_Move)
+ if (self->functions & OB_CLIENT_FUNC_MOVE)
actions[num++] = prop_atoms.net_wm_action_move;
- if (self->functions & Func_Iconify)
+ if (self->functions & OB_CLIENT_FUNC_ICONIFY)
actions[num++] = prop_atoms.net_wm_action_minimize;
- if (self->functions & Func_Resize)
+ if (self->functions & OB_CLIENT_FUNC_RESIZE)
actions[num++] = prop_atoms.net_wm_action_resize;
- if (self->functions & Func_Fullscreen)
+ if (self->functions & OB_CLIENT_FUNC_FULLSCREEN)
actions[num++] = prop_atoms.net_wm_action_fullscreen;
- if (self->functions & Func_Maximize) {
+ if (self->functions & OB_CLIENT_FUNC_MAXIMIZE) {
actions[num++] = prop_atoms.net_wm_action_maximize_horz;
actions[num++] = prop_atoms.net_wm_action_maximize_vert;
}
/* make sure the window isn't breaking any rules now */
- if (!(self->functions & Func_Shade) && self->shaded) {
+ if (!(self->functions & OB_CLIENT_FUNC_SHADE) && self->shaded) {
if (self->frame) client_shade(self, FALSE);
else self->shaded = FALSE;
}
- if (!(self->functions & Func_Iconify) && self->iconic) {
- g_message("UNSETTING ICONIC");
+ if (!(self->functions & OB_CLIENT_FUNC_ICONIFY) && self->iconic) {
if (self->frame) client_iconify(self, FALSE, TRUE);
else self->iconic = FALSE;
}
- if (!(self->functions & Func_Fullscreen) && self->fullscreen) {
+ if (!(self->functions & OB_CLIENT_FUNC_FULLSCREEN) && self->fullscreen) {
if (self->frame) client_fullscreen(self, FALSE, TRUE);
else self->fullscreen = FALSE;
}
- if (!(self->functions & Func_Maximize) && (self->max_horz ||
- self->max_vert)) {
+ if (!(self->functions & OB_CLIENT_FUNC_MAXIMIZE) && (self->max_horz ||
+ self->max_vert)) {
if (self->frame) client_maximize(self, FALSE, 0, TRUE);
else self->max_vert = self->max_horz = FALSE;
}
}
-void client_reconfigure(Client *self)
+void client_reconfigure(ObClient *self)
{
/* by making this pass FALSE for user, we avoid the emacs event storm where
every configurenotify causes an update in its normal hints, i think this
is generally what we want anyways... */
- client_configure(self, Corner_TopLeft, self->area.x, self->area.y,
+ client_configure(self, OB_CORNER_TOPLEFT, self->area.x, self->area.y,
self->area.width, self->area.height, FALSE, TRUE);
}
-void client_update_wmhints(Client *self)
+void client_update_wmhints(ObClient *self)
{
XWMHints *hints;
gboolean ur = FALSE;
/* only do this when first managing the window *AND* when we aren't
starting up! */
- if (ob_state != State_Starting && self->frame == NULL)
+ if (ob_state() != OB_STATE_STARTING && self->frame == NULL)
if (hints->flags & StateHint)
self->iconic = hints->initial_state == IconicState;
if (!self->transient_for) {
/* add other transients of the group that are already
set up */
- for (it = self->group->members; it; it = it->next)
- if (it->data != self &&
- ((Client*)it->data)->transient_for == TRAN_GROUP)
- self->transients = g_slist_append(self->transients,
- it->data);
+ for (it = self->group->members; it; it = it->next) {
+ ObClient *c = it->data;
+ if (c != self && c->transient_for == OB_TRAN_GROUP)
+ self->transients =
+ g_slist_append(self->transients, c);
+ }
}
}
if (ur != self->urgent) {
self->urgent = ur;
- g_message("Urgent Hint for 0x%lx: %s", self->window,
- ur ? "ON" : "OFF");
+ ob_debug("Urgent Hint for 0x%lx: %s\n", self->window,
+ ur ? "ON" : "OFF");
/* fire the urgent callback if we're mapped, otherwise, wait until
after we're mapped */
if (self->frame)
}
}
-void client_update_title(Client *self)
+void client_update_title(ObClient *self)
{
GList *it;
guint32 nums;
nums = 0;
for (it = client_list; it; it = it->next)
if (it->data != self) {
- Client *c = it->data;
+ ObClient *c = it->data;
if (0 == strncmp(c->title, data, strlen(data)))
nums |= 1 << c->title_count;
}
self->icon_title = data;
}
-void client_update_class(Client *self)
+void client_update_class(ObClient *self)
{
char **data;
char *s;
if (self->role == NULL) self->role = g_strdup("");
}
-void client_update_strut(Client *self)
+void client_update_strut(ObClient *self)
{
guint num;
guint32 *data;
/* updating here is pointless while we're being mapped cuz we're not in
the client list yet */
if (self->frame)
- screen_update_struts();
+ screen_update_areas();
}
-void client_update_icons(Client *self)
+void client_update_icons(ObClient *self)
{
guint num;
guint32 *data;
- guint w, h, i;
- int j;
+ guint w, h, i, j;
- for (j = 0; j < self->nicons; ++j)
- g_free(self->icons[j].data);
+ for (i = 0; i < self->nicons; ++i)
+ g_free(self->icons[i].data);
if (self->nicons > 0)
g_free(self->icons);
self->nicons = 0;
++self->nicons;
}
- self->icons = g_new(Icon, self->nicons);
+ self->icons = g_new(ObClientIcon, self->nicons);
/* store the icons */
i = 0;
kwm_win_icon, &data, &num)) {
if (num == 2) {
self->nicons++;
- self->icons = g_new(Icon, self->nicons);
+ self->icons = g_new(ObClientIcon, self->nicons);
xerror_set_ignore(TRUE);
if (!RrPixmapToRGBA(ob_rr_inst,
data[0], data[1],
if ((hints = XGetWMHints(ob_display, self->window))) {
if (hints->flags & IconPixmapHint) {
self->nicons++;
- self->icons = g_new(Icon, self->nicons);
+ self->icons = g_new(ObClientIcon, self->nicons);
xerror_set_ignore(TRUE);
if (!RrPixmapToRGBA(ob_rr_inst,
hints->icon_pixmap,
frame_adjust_icon(self->frame);
}
-static void client_change_state(Client *self)
+static void client_change_state(ObClient *self)
{
guint32 state[2];
guint32 netstate[10];
frame_adjust_state(self->frame);
}
-Client *client_search_focus_tree(Client *self)
+ObClient *client_search_focus_tree(ObClient *self)
{
GSList *it;
- Client *ret;
+ ObClient *ret;
for (it = self->transients; it != NULL; it = it->next) {
if (client_focused(it->data)) return it->data;
return NULL;
}
-Client *client_search_focus_tree_full(Client *self)
+ObClient *client_search_focus_tree_full(ObClient *self)
{
if (self->transient_for) {
- if (self->transient_for != TRAN_GROUP) {
+ if (self->transient_for != OB_TRAN_GROUP) {
return client_search_focus_tree_full(self->transient_for);
} else {
GSList *it;
gboolean recursed = FALSE;
for (it = self->group->members; it; it = it->next)
- if (!((Client*)it->data)->transient_for) {
- Client *c;
+ if (!((ObClient*)it->data)->transient_for) {
+ ObClient *c;
if ((c = client_search_focus_tree_full(it->data)))
return c;
recursed = TRUE;
return client_search_focus_tree(self);
}
-static StackLayer calc_layer(Client *self)
+static ObStackingLayer calc_layer(ObClient *self)
{
- StackLayer l;
+ ObStackingLayer l;
- if (self->fullscreen) l = Layer_Fullscreen;
- else if (self->type == Type_Desktop) l = Layer_Desktop;
- else if (self->type == Type_Dock) {
- if (!self->below) l = Layer_Top;
- else l = Layer_Normal;
+ if (self->fullscreen) l = OB_STACKING_LAYER_FULLSCREEN;
+ else if (self->type == OB_CLIENT_TYPE_DESKTOP)
+ l = OB_STACKING_LAYER_DESKTOP;
+ else if (self->type == OB_CLIENT_TYPE_DOCK) {
+ if (!self->below) l = OB_STACKING_LAYER_TOP;
+ else l = OB_STACKING_LAYER_NORMAL;
}
- else if (self->above) l = Layer_Above;
- else if (self->below) l = Layer_Below;
- else l = Layer_Normal;
+ else if (self->above) l = OB_STACKING_LAYER_ABOVE;
+ else if (self->below) l = OB_STACKING_LAYER_BELOW;
+ else l = OB_STACKING_LAYER_NORMAL;
return l;
}
-static void calc_recursive(Client *self, Client *orig, StackLayer l,
- gboolean raised)
+static void client_calc_layer_recursive(ObClient *self, ObClient *orig,
+ ObStackingLayer l, gboolean raised)
{
- StackLayer old, own;
+ ObStackingLayer old, own;
GSList *it;
old = self->layer;
self->layer = l > own ? l : own;
for (it = self->transients; it; it = it->next)
- calc_recursive(it->data, orig, l, raised ? raised : l != old);
+ client_calc_layer_recursive(it->data, orig,
+ l, raised ? raised : l != old);
if (!raised && l != old)
if (orig->frame) { /* only restack if the original window is managed */
}
}
-void client_calc_layer(Client *self)
+void client_calc_layer(ObClient *self)
{
- StackLayer l;
- Client *orig;
+ ObStackingLayer l;
+ ObClient *orig;
orig = self;
/* transients take on the layer of their parents */
- if (self->transient_for) {
- if (self->transient_for != TRAN_GROUP) {
- self = self->transient_for;
- } else {
- GSList *it;
-
- for (it = self->group->members; it; it = it->next)
- if (it->data != self &&
- !((Client*)it->data)->transient_for) {
- self = it->data;
- break;
- }
- }
- }
+ self = client_search_top_transient(self);
l = calc_layer(self);
- calc_recursive(self, orig, l, FALSE);
+ client_calc_layer_recursive(self, orig, l, FALSE);
}
-gboolean client_should_show(Client *self)
+gboolean client_should_show(ObClient *self)
{
if (self->iconic) return FALSE;
else if (!(self->desktop == screen_desktop ||
return TRUE;
}
-static void client_showhide(Client *self)
+static void client_showhide(ObClient *self)
{
if (client_should_show(self))
frame_hide(self->frame);
}
-gboolean client_normal(Client *self) {
- return ! (self->type == Type_Desktop || self->type == Type_Dock ||
- self->type == Type_Splash);
+gboolean client_normal(ObClient *self) {
+ return ! (self->type == OB_CLIENT_TYPE_DESKTOP ||
+ self->type == OB_CLIENT_TYPE_DOCK ||
+ self->type == OB_CLIENT_TYPE_SPLASH);
}
-static void client_apply_startup_state(Client *self)
+static void client_apply_startup_state(ObClient *self)
{
/* these are in a carefully crafted order.. */
*/
}
-void client_configure(Client *self, Corner anchor, int x, int y, int w, int h,
+void client_configure(ObClient *self, ObCorner anchor,
+ int x, int y, int w, int h,
gboolean user, gboolean final)
{
gboolean moved = FALSE, resized = FALSE;
#ifdef VIDMODE
int dot;
XF86VidModeModeLine mode;
+#endif
+ Rect *a;
+ guint i;
+
+ i = client_monitor(self);
+ a = screen_physical_area_monitor(i);
- if (XF86VidModeGetModeLine(ob_display, ob_screen, &dot, &mode)) {
+#ifdef VIDMODE
+ if (i == 0 && /* primary head */
+ extensions_vidmode &&
+ XF86VidModeGetViewPort(ob_display, ob_screen, &x, &y) &&
+ /* get the mode last so the mode.privsize isnt freed incorrectly */
+ XF86VidModeGetModeLine(ob_display, ob_screen, &dot, &mode)) {
+ x += a->x;
+ y += a->y;
w = mode.hdisplay;
h = mode.vdisplay;
if (mode.privsize) XFree(mode.private);
- } else {
-#else
- w = screen_physical_size.width;
- h = screen_physical_size.height;
-#endif
-#ifdef VIDMODE
- }
- if (!XF86VidModeGetViewPort(ob_display, ob_screen, &x, &y)) {
- x = y = 0;
+ } else
#endif
+ {
+ x = a->x;
+ y = a->y;
+ w = a->width;
+ h = a->height;
}
+
user = FALSE; /* ignore that increment etc shit when in fullscreen */
} else {
+ Rect *a;
+
+ a = screen_area_monitor(self->desktop, client_monitor(self));
+
/* set the size and position if maximized */
if (self->max_horz) {
- x = screen_area(self->desktop)->x - self->frame->size.left;
- w = screen_area(self->desktop)->width;
+ x = a->x - self->frame->size.left;
+ w = a->width;
}
if (self->max_vert) {
- y = screen_area(self->desktop)->y;
- h = screen_area(self->desktop)->height -
- self->frame->size.top - self->frame->size.bottom;
+ y = a->y;
+ h = a->height - self->frame->size.top - self->frame->size.bottom;
}
}
/* these override the above states! if you cant move you can't move! */
if (user) {
- if (!(self->functions & Func_Move)) {
+ if (!(self->functions & OB_CLIENT_FUNC_MOVE)) {
x = self->area.x;
y = self->area.y;
}
- if (!(self->functions & Func_Resize)) {
+ if (!(self->functions & OB_CLIENT_FUNC_RESIZE)) {
w = self->area.width;
h = self->area.height;
}
}
switch (anchor) {
- case Corner_TopLeft:
+ case OB_CORNER_TOPLEFT:
break;
- case Corner_TopRight:
+ case OB_CORNER_TOPRIGHT:
x -= w - self->area.width;
break;
- case Corner_BottomLeft:
+ case OB_CORNER_BOTTOMLEFT:
y -= h - self->area.height;
break;
- case Corner_BottomRight:
+ case OB_CORNER_BOTTOMRIGHT:
x -= w - self->area.width;
y -= h - self->area.height;
break;
}
}
-void client_fullscreen(Client *self, gboolean fs, gboolean savearea)
+void client_fullscreen(ObClient *self, gboolean fs, gboolean savearea)
{
int x, y, w, h;
- if (!(self->functions & Func_Fullscreen) || /* can't */
- self->fullscreen == fs) return; /* already done */
+ if (!(self->functions & OB_CLIENT_FUNC_FULLSCREEN) || /* can't */
+ self->fullscreen == fs) return; /* already done */
self->fullscreen = fs;
client_change_state(self); /* change the state hints on the client,
} else {
guint num;
gint32 *dimensions;
+ Rect *a;
/* pick some fallbacks... */
- x = screen_area(self->desktop)->x +
- screen_area(self->desktop)->width / 4;
- y = screen_area(self->desktop)->y +
- screen_area(self->desktop)->height / 4;
- w = screen_area(self->desktop)->width / 2;
- h = screen_area(self->desktop)->height / 2;
+ a = screen_area_monitor(self->desktop, 0);
+ x = a->x + a->width / 4;
+ y = a->y + a->height / 4;
+ w = a->width / 2;
+ h = a->height / 2;
if (PROP_GETA32(self->window, openbox_premax, cardinal,
(guint32**)&dimensions, &num)) {
client_setup_decor_and_functions(self);
- client_configure(self, Corner_TopLeft, x, y, w, h, TRUE, TRUE);
+ client_configure(self, OB_CORNER_TOPLEFT, x, y, w, h, TRUE, TRUE);
/* try focus us when we go into fullscreen mode */
client_focus(self);
}
-void client_iconify(Client *self, gboolean iconic, gboolean curdesk)
+static void client_iconify_recursive(ObClient *self,
+ gboolean iconic, gboolean curdesk)
{
GSList *it;
+ gboolean changed = FALSE;
- /* move up the transient chain as far as possible first */
- if (self->transient_for) {
- if (self->transient_for != TRAN_GROUP) {
- if (self->transient_for->iconic != iconic) {
- client_iconify(self->transient_for, iconic, curdesk);
- return;
- }
- } else {
- GSList *it;
-
- for (it = self->group->members; it; it = it->next) {
- Client *c = it->data;
- if (c != self && c->iconic != iconic &&
- !c->transient_for) {
- client_iconify(it->data, iconic, curdesk);
- break;
- }
- }
- if (it != NULL) return;
- }
- }
- if (self->iconic == iconic) return; /* nothing to do */
+ if (self->iconic != iconic) {
+ ob_debug("%sconifying window: 0x%lx\n", (iconic ? "I" : "Uni"),
+ self->window);
- g_message("%sconifying window: 0x%lx", (iconic ? "I" : "Uni"),
- self->window);
+ self->iconic = iconic;
- self->iconic = iconic;
+ if (iconic) {
+ if (self->functions & OB_CLIENT_FUNC_ICONIFY) {
+ self->wmstate = IconicState;
+ self->ignore_unmaps++;
+ /* we unmap the client itself so that we can get MapRequest
+ events, and because the ICCCM tells us to! */
+ XUnmapWindow(ob_display, self->window);
- if (iconic) {
- self->wmstate = IconicState;
- self->ignore_unmaps++;
- /* we unmap the client itself so that we can get MapRequest events,
- and because the ICCCM tells us to! */
- XUnmapWindow(ob_display, self->window);
+ /* update the focus lists.. iconic windows go to the bottom of
+ the list, put the new iconic window at the 'top of the
+ bottom'. */
+ focus_order_to_top(self);
- /* update the focus lists.. iconic windows go to the bottom of the
- list, put the new iconic window at the 'top of the bottom'. */
- focus_order_to_top(self);
- } else {
- if (curdesk)
- client_set_desktop(self, screen_desktop, FALSE);
- self->wmstate = self->shaded ? IconicState : NormalState;
- XMapWindow(ob_display, self->window);
+ changed = TRUE;
+ }
+ } else {
+ if (curdesk)
+ client_set_desktop(self, screen_desktop, FALSE);
+ self->wmstate = self->shaded ? IconicState : NormalState;
+ XMapWindow(ob_display, self->window);
+
+ /* this puts it after the current focused window */
+ focus_order_remove(self);
+ focus_order_add_new(self);
+
+ /* this is here cuz with the VIDMODE extension, the viewport can
+ change while a fullscreen window is iconic, and when it
+ uniconifies, it would be nice if it did so to the new position
+ of the viewport */
+ client_reconfigure(self);
+
+ changed = TRUE;
+ }
+ }
- /* this puts it after the current focused window */
- focus_order_remove(self);
- focus_order_add_new(self);
+ if (changed) {
+ client_change_state(self);
+ client_showhide(self);
+ screen_update_areas();
- /* this is here cuz with the VIDMODE extension, the viewport can change
- while a fullscreen window is iconic, and when it uniconifies, it
- would be nice if it did so to the new position of the viewport */
- client_reconfigure(self);
+ dispatch_client(iconic ? Event_Client_Unmapped : Event_Client_Mapped,
+ self, 0, 0);
}
- client_change_state(self);
- client_showhide(self);
- screen_update_struts();
-
- dispatch_client(iconic ? Event_Client_Unmapped : Event_Client_Mapped,
- self, 0, 0);
/* iconify all transients */
for (it = self->transients; it != NULL; it = it->next)
- if (it->data != self) client_iconify(it->data, iconic, curdesk);
+ if (it->data != self) client_iconify_recursive(it->data,
+ iconic, curdesk);
+}
+
+void client_iconify(ObClient *self, gboolean iconic, gboolean curdesk)
+{
+ /* move up the transient chain as far as possible first */
+ self = client_search_top_transient(self);
+
+ client_iconify_recursive(client_search_top_transient(self),
+ iconic, curdesk);
}
-void client_maximize(Client *self, gboolean max, int dir, gboolean savearea)
+void client_maximize(ObClient *self, gboolean max, int dir, gboolean savearea)
{
int x, y, w, h;
g_assert(dir == 0 || dir == 1 || dir == 2);
- if (!(self->functions & Func_Maximize)) return; /* can't */
+ if (!(self->functions & OB_CLIENT_FUNC_MAXIMIZE)) return; /* can't */
/* check if already done */
if (max) {
} else {
guint num;
gint32 *dimensions;
+ Rect *a;
/* pick some fallbacks... */
+ a = screen_area_monitor(self->desktop, 0);
if (dir == 0 || dir == 1) { /* horz */
- x = screen_area(self->desktop)->x +
- screen_area(self->desktop)->width / 4;
- w = screen_area(self->desktop)->width / 2;
+ x = a->x + a->width / 4;
+ w = a->width / 2;
}
if (dir == 0 || dir == 2) { /* vert */
- y = screen_area(self->desktop)->y +
- screen_area(self->desktop)->height / 4;
- h = screen_area(self->desktop)->height / 2;
+ y = a->y + a->height / 4;
+ h = a->height / 2;
}
if (PROP_GETA32(self->window, openbox_premax, cardinal,
/* figure out where the client should be going */
frame_frame_gravity(self->frame, &x, &y);
- client_configure(self, Corner_TopLeft, x, y, w, h, TRUE, TRUE);
+ client_configure(self, OB_CORNER_TOPLEFT, x, y, w, h, TRUE, TRUE);
}
-void client_shade(Client *self, gboolean shade)
+void client_shade(ObClient *self, gboolean shade)
{
- if ((!(self->functions & Func_Shade) && shade) || /* can't shade */
+ if ((!(self->functions & OB_CLIENT_FUNC_SHADE) &&
+ shade) || /* can't shade */
self->shaded == shade) return; /* already done */
/* when we're iconic, don't change the wmstate */
frame_adjust_area(self->frame, FALSE, FALSE);
}
-void client_close(Client *self)
+void client_close(ObClient *self)
{
XEvent ce;
- if (!(self->functions & Func_Close)) return;
+ if (!(self->functions & OB_CLIENT_FUNC_CLOSE)) return;
/*
XXX: itd be cool to do timeouts and shit here for killing the client's
XSendEvent(ob_display, self->window, FALSE, NoEventMask, &ce);
}
-void client_kill(Client *self)
+void client_kill(ObClient *self)
{
XKillClient(ob_display, self->window);
}
-void client_set_desktop(Client *self, guint target, gboolean donthide)
+void client_set_desktop_recursive(ObClient *self,
+ guint target, gboolean donthide)
{
guint old;
+ GSList *it;
- if (target == self->desktop) return;
-
- g_message("Setting desktop %u", target+1);
+ if (target != self->desktop) {
- g_assert(target < screen_num_desktops || target == DESKTOP_ALL);
+ ob_debug("Setting desktop %u\n", target+1);
- /* remove from the old desktop(s) */
- focus_order_remove(self);
+ g_assert(target < screen_num_desktops || target == DESKTOP_ALL);
- old = self->desktop;
- self->desktop = target;
- PROP_SET32(self->window, net_wm_desktop, cardinal, target);
- /* the frame can display the current desktop state */
- frame_adjust_state(self->frame);
- /* 'move' the window to the new desktop */
- if (!donthide)
- client_showhide(self);
- /* raise if it was not already on the desktop */
- if (old != DESKTOP_ALL)
- stacking_raise(CLIENT_AS_WINDOW(self));
- screen_update_struts();
-
- /* add to the new desktop(s) */
- if (config_focus_new)
- focus_order_to_top(self);
- else
- focus_order_to_bottom(self);
+ /* remove from the old desktop(s) */
+ focus_order_remove(self);
- dispatch_client(Event_Client_Desktop, self, target, old);
+ old = self->desktop;
+ self->desktop = target;
+ PROP_SET32(self->window, net_wm_desktop, cardinal, target);
+ /* the frame can display the current desktop state */
+ frame_adjust_state(self->frame);
+ /* 'move' the window to the new desktop */
+ if (!donthide)
+ client_showhide(self);
+ /* raise if it was not already on the desktop */
+ if (old != DESKTOP_ALL)
+ stacking_raise(CLIENT_AS_WINDOW(self));
+ screen_update_areas();
+
+ /* add to the new desktop(s) */
+ if (config_focus_new)
+ focus_order_to_top(self);
+ else
+ focus_order_to_bottom(self);
+
+ dispatch_client(Event_Client_Desktop, self, target, old);
+ }
+
+ /* move all transients */
+ for (it = self->transients; it != NULL; it = it->next)
+ if (it->data != self) client_set_desktop_recursive(it->data,
+ target, donthide);
}
-Client *client_search_modal_child(Client *self)
+void client_set_desktop(ObClient *self, guint target, gboolean donthide)
+{
+ client_set_desktop_recursive(client_search_top_transient(self),
+ target, donthide);
+}
+
+ObClient *client_search_modal_child(ObClient *self)
{
GSList *it;
- Client *ret;
+ ObClient *ret;
for (it = self->transients; it != NULL; it = it->next) {
- Client *c = it->data;
+ ObClient *c = it->data;
if ((ret = client_search_modal_child(c))) return ret;
if (c->modal) return c;
}
return NULL;
}
-gboolean client_validate(Client *self)
+gboolean client_validate(ObClient *self)
{
XEvent e;
return TRUE;
}
-void client_set_wm_state(Client *self, long state)
+void client_set_wm_state(ObClient *self, long state)
{
if (state == self->wmstate) return; /* no change */
}
}
-void client_set_state(Client *self, Atom action, long data1, long data2)
+void client_set_state(ObClient *self, Atom action, long data1, long data2)
{
gboolean shaded = self->shaded;
gboolean fullscreen = self->fullscreen;
client_change_state(self); /* change the hint to reflect these changes */
}
-Client *client_focus_target(Client *self)
+ObClient *client_focus_target(ObClient *self)
{
- Client *child;
+ ObClient *child;
/* if we have a modal child, then focus it, not us */
child = client_search_modal_child(self);
return self;
}
-gboolean client_can_focus(Client *self)
+gboolean client_can_focus(ObClient *self)
{
XEvent ev;
return TRUE;
}
-gboolean client_focus(Client *self)
+gboolean client_focus(ObClient *self)
{
/* choose the correct target */
self = client_focus_target(self);
}
#ifdef DEBUG_FOCUS
- g_message("%sively focusing %lx at %d", (self->can_focus ? "act" : "pass"),
- self->window, (int)
- event_lasttime);
+ ob_debug("%sively focusing %lx at %d\n",
+ (self->can_focus ? "act" : "pass"),
+ self->window, (int) event_lasttime);
#endif
/* Cause the FocusIn to come back to us. Important for desktop switches,
return TRUE;
}
-void client_unfocus(Client *self)
+void client_unfocus(ObClient *self)
{
g_assert(focus_client == self);
#ifdef DEBUG_FOCUS
- g_message("client_unfocus for %lx", self->window);
+ ob_debug("client_unfocus for %lx\n", self->window);
#endif
- focus_fallback(Fallback_Unfocusing);
+ focus_fallback(OB_FOCUS_FALLBACK_UNFOCUSING);
}
-void client_activate(Client *self)
+void client_activate(ObClient *self)
{
if (client_normal(self) && screen_showing_desktop)
screen_show_desktop(FALSE);
if (self->iconic)
- client_iconify(self, FALSE, TRUE);
+ client_iconify(self, FALSE, FALSE);
+ if (self->desktop != DESKTOP_ALL &&
+ self->desktop != screen_desktop)
+ screen_set_desktop(self->desktop);
else if (!self->frame->visible)
/* if its not visible for other reasons, then don't mess
with it */
stacking_raise(CLIENT_AS_WINDOW(self));
}
-gboolean client_focused(Client *self)
+gboolean client_focused(ObClient *self)
{
return self == focus_client;
}
-Icon *client_icon(Client *self, int w, int h)
+ObClientIcon *client_icon(ObClient *self, int w, int h)
{
- int i;
+ guint i;
/* si is the smallest image >= req */
/* li is the largest image < req */
unsigned long size, smallest = 0xffffffff, largest = 0, si = 0, li = 0;
}
/* this be mostly ripped from fvwm */
-Client *client_find_directional(Client *c, Direction dir)
+ObClient *client_find_directional(ObClient *c, ObDirection dir)
{
int my_cx, my_cy, his_cx, his_cy;
int offset = 0;
int distance = 0;
int score, best_score;
- Client *best_client, *cur;
+ ObClient *best_client, *cur;
GList *it;
if(!client_list)
}
switch(dir) {
- case Direction_North :
- case Direction_South :
- case Direction_NorthEast :
- case Direction_SouthWest :
+ case OB_DIRECTION_NORTH:
+ case OB_DIRECTION_SOUTH:
+ case OB_DIRECTION_NORTHEAST:
+ case OB_DIRECTION_SOUTHWEST:
offset = (his_cx < 0) ? -his_cx : his_cx;
- distance = (dir == Direction_North || dir == Direction_NorthEast) ?
- -his_cy : his_cy;
+ distance = ((dir == OB_DIRECTION_NORTH ||
+ dir == OB_DIRECTION_NORTHEAST) ?
+ -his_cy : his_cy);
break;
- case Direction_East :
- case Direction_West :
- case Direction_SouthEast :
- case Direction_NorthWest :
+ case OB_DIRECTION_EAST:
+ case OB_DIRECTION_WEST:
+ case OB_DIRECTION_SOUTHEAST:
+ case OB_DIRECTION_NORTHWEST:
offset = (his_cy < 0) ? -his_cy : his_cy;
- distance = (dir == Direction_West || dir == Direction_NorthWest) ?
- -his_cx : his_cx;
+ distance = ((dir == OB_DIRECTION_WEST ||
+ dir == OB_DIRECTION_NORTHWEST) ?
+ -his_cx : his_cx);
break;
}
return best_client;
}
-void client_set_layer(Client *self, int layer)
+void client_set_layer(ObClient *self, int layer)
{
if (layer < 0) {
self->below = TRUE;
client_calc_layer(self);
client_change_state(self); /* reflect this in the state hints */
}
+
+guint client_monitor(ObClient *self)
+{
+ guint i;
+
+ for (i = 0; i < screen_num_monitors; ++i) {
+ Rect *area = screen_physical_area_monitor(i);
+ if (RECT_INTERSECTS_RECT(*area, self->frame->area))
+ break;
+ }
+ if (i == screen_num_monitors) i = 0;
+ g_assert(i < screen_num_monitors);
+ return i;
+}
+
+ObClient *client_search_top_transient(ObClient *self)
+{
+ /* move up the transient chain as far as possible */
+ if (self->transient_for) {
+ if (self->transient_for != OB_TRAN_GROUP) {
+ return client_search_top_transient(self->transient_for);
+ } else {
+ GSList *it;
+
+ for (it = self->group->members; it; it = it->next) {
+ ObClient *c = it->data;
+
+ /* checking transient_for prevents infinate loops! */
+ if (c != self && !c->transient_for)
+ break;
+ }
+ if (it)
+ return it->data;
+ }
+ }
+
+ return self;
+}
projects / chaz / openbox / blobdiff