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;
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);
focus_order_add_new(self);
/* focus the new window? */
- if (ob_state != OB_STATE_STARTING && config_focus_new &&
- (self->type == Type_Normal || self->type == Type_Dialog)) {
+ if (ob_state() != OB_STATE_STARTING && config_focus_new &&
+ (self->type == OB_CLIENT_TYPE_NORMAL || self->type == OB_CLIENT_TYPE_DIALOG)) {
gboolean group_foc = FALSE;
if (self->group) {
/* 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);
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 != OB_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);
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;
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 */
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 *c = NULL;
if (XGetTransientForHint(ob_display, self->window, &t)) {
self->transient = TRUE;
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 */
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);
+ !((ObClient*)it->data)->transient_for)
+ ((ObClient*)it->data)->transients =
+ g_slist_remove(((ObClient*)it->data)->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 */
+ 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);
+ !((ObClient*)it->data)->transient_for)
+ ((ObClient*)it->data)->transients =
+ g_slist_append(((ObClient*)it->data)->transients, self);
/* remove all transients which are in the group, that causes
circlular pointer hell of doom */
}
}
-static void client_get_mwm_hints(Client *self)
+static void client_get_mwm_hints(ObClient *self)
{
guint num;
guint32 *hints;
}
}
-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.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;
decor and functionality */
if (self->mwmhints.flags & OB_MWM_FLAG_DECORATIONS) {
if (! (self->mwmhints.decorations & OB_MWM_DECOR_ALL)) {
- if (! (self->mwmhints.decorations & OB_MWM_DECOR_BORDER))
- self->decorations &= ~Decor_Border;
- if (! (self->mwmhints.decorations & OB_MWM_DECOR_HANDLE))
- self->decorations &= ~Decor_Handle;
- if (! (self->mwmhints.decorations & OB_MWM_DECOR_TITLE))
- self->decorations &= ~Decor_Titlebar;
- if (! (self->mwmhints.decorations & OB_MWM_DECOR_ICONIFY))
- self->decorations &= ~Decor_Iconify;
- if (! (self->mwmhints.decorations & OB_MWM_DECOR_MAXIMIZE))
- self->decorations &= ~Decor_Maximize;
+ 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 & 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;
+ /* dont let mwm hints kill any buttons
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; */
+ 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) {
+ 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;
}
}
-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
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 != OB_STATE_STARTING && self->frame == NULL)
+ if (ob_state() != OB_STATE_STARTING && self->frame == NULL)
if (hints->flags & StateHint)
self->iconic = hints->initial_state == IconicState;
set up */
for (it = self->group->members; it; it = it->next)
if (it->data != self &&
- ((Client*)it->data)->transient_for == TRAN_GROUP)
+ ((ObClient*)it->data)->transient_for == OB_TRAN_GROUP)
self->transients = g_slist_append(self->transients,
it->data);
}
}
}
-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;
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 client_calc_layer_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;
}
}
-void client_calc_layer(Client *self)
+void client_calc_layer(ObClient *self)
{
- StackLayer l;
- Client *orig;
+ ObStackingLayer l;
+ ObClient *orig;
orig = self;
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, ObCorner anchor,
+void client_configure(ObClient *self, ObCorner anchor,
int x, int y, int w, int h,
gboolean user, gboolean final)
{
/* 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;
}
}
}
-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,
client_focus(self);
}
-static void client_iconify_recursive(Client *self,
+static void client_iconify_recursive(ObClient *self,
gboolean iconic, gboolean curdesk)
{
GSList *it;
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
iconic, curdesk);
}
-void client_iconify(Client *self, gboolean iconic, gboolean 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);
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) {
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_recursive(Client *self,
+void client_set_desktop_recursive(ObClient *self,
guint target, gboolean donthide)
{
guint old;
target, donthide);
}
-void client_set_desktop(Client *self, guint target, gboolean donthide)
+void client_set_desktop(ObClient *self, guint target, gboolean donthide)
{
client_set_desktop_recursive(client_search_top_transient(self),
target, donthide);
}
-Client *client_search_modal_child(Client *self)
+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);
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);
#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, ObDirection 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)
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_change_state(self); /* reflect this in the state hints */
}
-guint client_monitor(Client *self)
+guint client_monitor(ObClient *self)
{
guint i;
return i;
}
-Client *client_search_top_transient(Client *self)
+ObClient *client_search_top_transient(ObClient *self)
{
/* 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;
for (it = self->group->members; it; it = it->next) {
- Client *c = it->data;
+ ObClient *c = it->data;
/* checking transient_for prevents infinate loops! */
if (c != self && !c->transient_for)