} 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_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 {
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);
}
}
/* focus the new window? */
if (ob_state != OB_STATE_STARTING && config_focus_new &&
- (self->type == Type_Normal || self->type == Type_Dialog)) {
+ (self->type == OB_CLIENT_TYPE_NORMAL || self->type == OB_CLIENT_TYPE_DIALOG)) {
gboolean group_foc = FALSE;
if (self->group) {
void client_unmanage(ObClient *self)
{
- int j;
+ guint j;
GSList *it;
g_message("Unmanaging window: %lx (%s)", self->window, self->class);
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)
/* tell our transients that we're gone */
for (it = self->transients; it != NULL; it = it->next) {
- if (((ObClient*)it->data)->transient_for != TRAN_GROUP) {
+ if (((ObClient*)it->data)->transient_for != OB_TRAN_GROUP) {
((ObClient*)it->data)->transient_for = NULL;
client_calc_layer(it->data);
}
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 {
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;
+ c = OB_TRAN_GROUP;
}
}
}
/* if anything has changed... */
if (c != self->transient_for) {
- if (self->transient_for == TRAN_GROUP) { /* transient of group */
+ if (self->transient_for == OB_TRAN_GROUP) { /* transient of group */
GSList *it;
/* remove from old parents */
g_slist_remove(self->transient_for->transients, self);
}
self->transient_for = c;
- if (self->transient_for == TRAN_GROUP) { /* transient of group */
+ if (self->transient_for == OB_TRAN_GROUP) { /* transient of group */
GSList *it;
/* add to new parents */
/* 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.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;
}
}
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->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;
}
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->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;
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 &= ~Func_Resize;
+ self->functions &= ~OB_CLIENT_FUNC_RESIZE;
if (! (self->mwmhints.functions & OB_MWM_FUNC_MOVE))
- self->functions &= ~Func_Move;
+ self->functions &= ~OB_CLIENT_FUNC_MOVE;
if (! (self->mwmhints.functions & OB_MWM_FUNC_ICONIFY))
- self->functions &= ~Func_Iconify;
+ self->functions &= ~OB_CLIENT_FUNC_ICONIFY;
if (! (self->mwmhints.functions & OB_MWM_FUNC_MAXIMIZE))
- self->functions &= ~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; */
}
/* can't maximize without moving/resizing */
- if (!((self->functions & Func_Move) && (self->functions & Func_Resize)))
- self->functions &= ~(Func_Maximize | Func_Fullscreen);
+ if (!((self->functions & OB_CLIENT_FUNC_MOVE) &&
+ (self->functions & OB_CLIENT_FUNC_RESIZE)))
+ self->functions &= ~(OB_CLIENT_FUNC_MAXIMIZE |
+ OB_CLIENT_FUNC_FULLSCREEN);
/* finally, user specified disabled decorations are applied to subtract
decorations */
/* if we don't have a titlebar, then we cannot shade! */
if (!(self->decorations & Decor_Titlebar))
- self->functions &= ~Func_Shade;
+ 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;
+ }
}
}
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) {
+ if (!(self->functions & OB_CLIENT_FUNC_ICONIFY) && self->iconic) {
g_message("UNSETTING 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;
}
set up */
for (it = self->group->members; it; it = it->next)
if (it->data != self &&
- ((ObClient*)it->data)->transient_for == TRAN_GROUP)
+ ((ObClient*)it->data)->transient_for == OB_TRAN_GROUP)
self->transients = g_slist_append(self->transients,
it->data);
}
{
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;
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;
return client_search_focus_tree(self);
}
-static StackLayer calc_layer(ObClient *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 client_calc_layer_recursive(ObClient *self, ObClient *orig,
- StackLayer l, gboolean raised)
+ ObStackingLayer l, gboolean raised)
{
- StackLayer old, own;
+ ObStackingLayer old, own;
GSList *it;
old = self->layer;
void client_calc_layer(ObClient *self)
{
- StackLayer l;
+ ObStackingLayer l;
ObClient *orig;
orig = self;
}
gboolean client_normal(ObClient *self) {
- return ! (self->type == Type_Desktop || self->type == Type_Dock ||
- self->type == Type_Splash);
+ 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(ObClient *self)
/* 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;
}
{
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,
self->iconic = iconic;
if (iconic) {
- if (self->functions & Func_Iconify) {
+ if (self->functions & OB_CLIENT_FUNC_ICONIFY) {
self->wmstate = IconicState;
self->ignore_unmaps++;
/* we unmap the client itself so that we can get MapRequest
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) {
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 */
{
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
#ifdef DEBUG_FOCUS
g_message("client_unfocus for %lx", self->window);
#endif
- focus_fallback(Fallback_Unfocusing);
+ focus_fallback(OB_FOCUS_FALLBACK_UNFOCUSING);
}
void client_activate(ObClient *self)
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;
{
/* move up the transient chain as far as possible */
if (self->transient_for) {
- if (self->transient_for != TRAN_GROUP) {
+ if (self->transient_for != OB_TRAN_GROUP) {
return client_search_top_transient(self->transient_for);
} else {
GSList *it;
projects / chaz / openbox / blobdiff