X-Git-Url: https://git.dogcows.com/gitweb?a=blobdiff_plain;f=openbox%2Fclient.c;h=68e1e09886d4d6d09aa1de0a047c5af8c9355669;hb=f278ec41e4c310da218563e7d443df32783e26e4;hp=dfc7034838dd9ec4b485522c0d804a28a7b55f0a;hpb=648c55b829e09c66222a9bbf08d10434622feae2;p=chaz%2Fopenbox diff --git a/openbox/client.c b/openbox/client.c index dfc70348..68e1e098 100644 --- a/openbox/client.c +++ b/openbox/client.c @@ -9,6 +9,7 @@ #include "focus.h" #include "stacking.h" #include "dispatch.h" +#include "group.h" #include #include @@ -20,9 +21,12 @@ #define CLIENT_NOPROPAGATEMASK (ButtonPressMask | ButtonReleaseMask | \ ButtonMotionMask) -GSList *client_list = NULL; +GList *client_list = NULL; GHashTable *client_map = NULL; +static Window *client_startup_stack_order = NULL; +static gulong client_startup_stack_size = 0; + static void client_get_all(Client *self); static void client_toggle_border(Client *self, gboolean show); static void client_get_area(Client *self); @@ -34,17 +38,23 @@ 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_move_onscreen(Client *self); static Client *search_focus_tree(Client *node, Client *skip); static void client_apply_startup_state(Client *self); static Client *search_modal_tree(Client *node, Client *skip); -static guint map_hash(Window w) { return w; } -static gboolean map_key_comp(Window w1, Window w2) { return w1 == w2; } +static guint map_hash(Window *w) { return *w; } +static gboolean map_key_comp(Window *w1, Window *w2) { return *w1 == *w2; } void client_startup() { client_map = g_hash_table_new((GHashFunc)map_hash, (GEqualFunc)map_key_comp); + + /* save the stacking order on startup! */ + PROP_GET32U(ob_root, net_client_list_stacking, window, + client_startup_stack_order, client_startup_stack_size); + client_set_list(); } @@ -56,8 +66,8 @@ void client_shutdown() void client_set_list() { Window *windows, *win_it; - GSList *it; - guint size = g_slist_length(client_list); + GList *it; + guint size = g_list_length(client_list); /* create an array of the window ids */ if (size > 0) { @@ -112,15 +122,34 @@ void client_manage_all() } } XFree(children); + + /* stack them as they were on startup! + why with stacking_lower? Why, because then windows who aren't in the + stacking list are on the top where you can see them instead of buried + at the bottom! */ + for (i = client_startup_stack_size; i > 0; --i) { + Client *c; + + w = client_startup_stack_order[i-1]; + c = g_hash_table_lookup(client_map, &w); + if (c) stacking_lower(c); + } + g_free(client_startup_stack_order); + client_startup_stack_order = NULL; + client_startup_stack_size = 0; + + if (focus_new) + focus_fallback(FALSE); } void client_manage(Window window) { - Client *client; + Client *self; XEvent e; XWindowAttributes attrib; XSetWindowAttributes attrib_set; /* XWMHints *wmhint; */ + guint i; grab_server(TRUE); @@ -129,7 +158,7 @@ void client_manage(Window window) if (XCheckTypedWindowEvent(ob_display, window, DestroyNotify, &e) || XCheckTypedWindowEvent(ob_display, window, UnmapNotify, &e)) { XPutBackEvent(ob_display, &e); - + grab_server(FALSE); return; /* don't manage it */ } @@ -153,6 +182,7 @@ void client_manage(Window window) XFree(wmhint); } */ + g_message("Managing window: %lx", window); /* choose the events we want to receive on the CLIENT window */ attrib_set.event_mask = CLIENT_EVENTMASK; @@ -163,46 +193,59 @@ void client_manage(Window window) /* create the Client struct, and populate it from the hints on the window */ - client = g_new(Client, 1); - client->window = window; - client_get_all(client); + self = g_new(Client, 1); + self->window = window; + client_get_all(self); /* remove the client's border (and adjust re gravity) */ - client_toggle_border(client, FALSE); + client_toggle_border(self, FALSE); /* specify that if we exit, the window should not be destroyed and should be reparented back to root automatically */ XChangeSaveSet(ob_display, window, SetModeInsert); /* create the decoration frame for the client window */ - client->frame = engine_frame_new(); + self->frame = engine_frame_new(); - engine_frame_grab_client(client->frame, client); + engine_frame_grab_client(self->frame, self); - client_apply_startup_state(client); + client_apply_startup_state(self); grab_server(FALSE); - client_list = g_slist_append(client_list, client); - stacking_list = g_list_append(stacking_list, client); - g_hash_table_insert(client_map, (gpointer)window, client); + client_list = g_list_append(client_list, self); + stacking_list = g_list_append(stacking_list, self); + g_assert(!g_hash_table_lookup(client_map, &self->window)); + g_hash_table_insert(client_map, &self->window, self); + + /* update the focus lists */ + if (self->desktop == DESKTOP_ALL) { + for (i = 0; i < screen_num_desktops; ++i) + focus_order[i] = g_list_append(focus_order[i], self); + } else { + i = self->desktop; + focus_order[i] = g_list_append(focus_order[i], self); + } - stacking_raise(client); + stacking_raise(self); screen_update_struts(); - dispatch_client(Event_Client_New, client, 0, 0); + dispatch_client(Event_Client_New, self, 0, 0); - client_showhide(client); + client_showhide(self); - dispatch_client(Event_Client_Mapped, client, 0, 0); + dispatch_client(Event_Client_Mapped, self, 0, 0); - /* grab all mouse bindings */ - /*pointer_grab_all(client, TRUE);XXX*/ + if (ob_state != State_Starting && focus_new) + client_focus(self); /* update the list hints */ client_set_list(); + /* make sure the window is visible */ + client_move_onscreen(self); + g_message("Managed window 0x%lx", window); } @@ -212,95 +255,135 @@ void client_unmanage_all() client_unmanage(client_list->data); } -void client_unmanage(Client *client) +void client_unmanage(Client *self) { guint i; int j; GSList *it; - g_message("Unmanaging window: %lx", client->window); + g_message("Unmanaging window: %lx", self->window); - dispatch_client(Event_Client_Destroy, client, 0, 0); + dispatch_client(Event_Client_Destroy, self, 0, 0); + g_assert(self != NULL); /* remove the window from our save set */ - XChangeSaveSet(ob_display, client->window, SetModeDelete); + XChangeSaveSet(ob_display, self->window, SetModeDelete); /* we dont want events no more */ - XSelectInput(ob_display, client->window, NoEventMask); - - /* ungrab any mouse bindings */ - /*pointer_grab_all(client, FALSE);XXX*/ - - engine_frame_hide(client->frame); + XSelectInput(ob_display, self->window, NoEventMask); - /* give the client its border back */ - client_toggle_border(client, TRUE); + engine_frame_hide(self->frame); - /* reparent the window out of the frame, and free the frame */ - engine_frame_release_client(client->frame, client); - - client_list = g_slist_remove(client_list, client); - stacking_list = g_list_remove(stacking_list, client); - g_hash_table_remove(client_map, (gpointer)client->window); + client_list = g_list_remove(client_list, self); + stacking_list = g_list_remove(stacking_list, self); + g_hash_table_remove(client_map, &self->window); /* update the focus lists */ - if (client->desktop == DESKTOP_ALL) { + if (self->desktop == DESKTOP_ALL) { for (i = 0; i < screen_num_desktops; ++i) - focus_order[i] = g_list_remove(focus_order[i], client); + focus_order[i] = g_list_remove(focus_order[i], self); } else { - i = client->desktop; - focus_order[i] = g_list_remove(focus_order[i], client); + i = self->desktop; + focus_order[i] = g_list_remove(focus_order[i], self); } /* once the client is out of the list, update the struts to remove it's influence */ screen_update_struts(); - /* tell our parent that we're gone */ - if (client->transient_for != NULL) - client->transient_for->transients = - g_slist_remove(client->transient_for->transients, client); + /* tell our parent(s) that we're gone */ + if (self->transient_for == 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); + } 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 = client->transients; it != NULL; it = it->next) { - ((Client*)it->data)->transient_for = NULL; - client_calc_layer(it->data); + for (it = self->transients; it != NULL; it = it->next) { + if (((Client*)it->data)->transient_for != TRAN_GROUP) { + ((Client*)it->data)->transient_for = NULL; + client_calc_layer(it->data); + } } - /* unfocus the client (dispatchs the focus event) (we're out of the - transient lists already, so being modal doesn't matter) */ - if (client->focused) - client_unfocus(client); - + focus_fallback(FALSE); + + /* remove from its group */ + if (self->group) { + group_remove(self->group, self); + self->group = NULL; + } + + /* dispatch the unmapped event */ + dispatch_client(Event_Client_Unmapped, self, 0, 0); + g_assert(self != NULL); + + /* give the client its border back */ + client_toggle_border(self, TRUE); + + /* reparent the window out of the frame, and free the frame */ + engine_frame_release_client(self->frame, self); + self->frame = NULL; + if (ob_state != State_Exiting) { /* these values should not be persisted across a window unmapping/mapping */ - prop_erase(client->window, prop_atoms.net_wm_desktop); - prop_erase(client->window, prop_atoms.net_wm_state); + prop_erase(self->window, prop_atoms.net_wm_desktop); + prop_erase(self->window, prop_atoms.net_wm_state); } else { /* if we're left in an iconic state, the client wont be mapped. this is bad, since we will no longer be managing the window on restart */ - if (client->iconic) - XMapWindow(ob_display, client->window); + if (self->iconic) + XMapWindow(ob_display, self->window); } + g_message("Unmanaged window 0x%lx", self->window); + /* free all data allocated in the client struct */ - g_slist_free(client->transients); - for (j = 0; j < client->nicons; ++j) - g_free(client->icons[j].data); - if (client->nicons > 0) - g_free(client->icons); - g_free(client->title); - g_free(client->icon_title); - g_free(client->res_name); - g_free(client->res_class); - g_free(client->role); - g_free(client); + g_slist_free(self->transients); + for (j = 0; j < self->nicons; ++j) + g_free(self->icons[j].data); + if (self->nicons > 0) + g_free(self->icons); + g_free(self->title); + g_free(self->icon_title); + g_free(self->name); + g_free(self->class); + g_free(self->role); + g_free(self); /* update the list hints */ client_set_list(); } +static void client_move_onscreen(Client *self) +{ + Rect *a; + int x = self->frame->area.x, y = self->frame->area.y; + + a = screen_area(self->desktop); + if (x >= a->x + a->width - 1) + x = a->x + a->width - self->frame->area.width; + if (y >= a->y + a->height - 1) + y = a->y + a->height - self->frame->area.height; + if (x + self->frame->area.width - 1 < a->x) + x = a->x; + if (y + self->frame->area.height - 1< a->y) + y = a->y; + + frame_frame_gravity(self->frame, &x, &y); /* get where the client + should be */ + client_configure(self , Corner_TopLeft, x, y, + self->area.width, self->area.height, + TRUE, TRUE); +} + static void client_toggle_border(Client *self, gboolean show) { /* adjust our idea of where the client is, based on its border. When the @@ -376,9 +459,8 @@ static void client_get_all(Client *self) /* defaults */ self->frame = NULL; self->title = self->icon_title = NULL; - self->res_name = self->res_class = self->role = NULL; + self->name = self->class = self->role = NULL; self->wmstate = NormalState; - self->focused = FALSE; self->transient = FALSE; self->transients = NULL; self->transient_for = NULL; @@ -386,7 +468,7 @@ static void client_get_all(Client *self) self->urgent = FALSE; self->positioned = FALSE; self->disabled_decorations = 0; - self->group = None; + self->group = NULL; self->nicons = 0; client_get_area(self); @@ -518,18 +600,17 @@ void client_update_transient_for(Client *self) if (XGetTransientForHint(ob_display, self->window, &t) && t != self->window) { /* cant be transient to itself! */ self->transient = TRUE; - c = g_hash_table_lookup(client_map, (gpointer)t); + c = g_hash_table_lookup(client_map, &t); g_assert(c != self);/* if this happens then we need to check for it*/ - if (!c /*XXX: && _group*/) { + if (!c && self->group) { /* not transient to a client, see if it is transient for a group */ - if (/*t == _group->leader() || */ + if (t == self->group->leader || t == None || t == ob_root) { /* window is a transient for its group! */ - /* XXX: for now this is treated as non-transient. - this needs to be fixed! */ + c = TRAN_GROUP; } } } else @@ -537,13 +618,33 @@ void client_update_transient_for(Client *self) /* if anything has changed... */ if (c != self->transient_for) { - if (self->transient_for) + if (self->transient_for == 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)->transients = + g_slist_remove(((Client*)it->data)->transients, self); + } else if (self->transient_for != NULL) { /* transient of window */ /* remove from old parent */ - g_slist_remove(self->transient_for->transients, self); + self->transient_for->transients = + g_slist_remove(self->transient_for->transients, self); + } self->transient_for = c; - if (self->transient_for) + if (self->transient_for == 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)->transients = + g_slist_append(((Client*)it->data)->transients, self); + } else if (self->transient_for != NULL) { /* transient of window */ /* add to new parent */ - g_slist_append(self->transient_for->transients, self); + self->transient_for->transients = + g_slist_append(self->transient_for->transients, self); + } } } @@ -662,7 +763,7 @@ void client_update_normal_hints(Client *self) /* get the hints from the window */ if (XGetWMNormalHints(ob_display, self->window, &size, &ret)) { - self->positioned = (size.flags & (PPosition|USPosition)); + self->positioned = !!(size.flags & (PPosition|USPosition)); if (size.flags & PWinGravity) { self->gravity = size.win_gravity; @@ -703,7 +804,8 @@ void client_setup_decor_and_functions(Client *self) { /* start with everything (cept fullscreen) */ self->decorations = Decor_Titlebar | Decor_Handle | Decor_Border | - Decor_Icon | Decor_AllDesktops | Decor_Iconify | Decor_Maximize; + Decor_Icon | Decor_AllDesktops | Decor_Iconify | Decor_Maximize | + Decor_Shade; self->functions = Func_Resize | Func_Move | Func_Iconify | Func_Maximize | Func_Shade; if (self->delete_window) { @@ -782,7 +884,7 @@ void client_setup_decor_and_functions(Client *self) /* can't maximize without moving/resizing */ if (!((self->functions & Func_Move) && (self->functions & Func_Resize))) - self->functions &= ~Func_Maximize; + self->functions &= ~(Func_Maximize | Func_Fullscreen); /* finally, user specified disabled decorations are applied to subtract decorations */ @@ -798,6 +900,8 @@ void client_setup_decor_and_functions(Client *self) 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; @@ -808,10 +912,9 @@ void client_setup_decor_and_functions(Client *self) client_change_allowed_actions(self); if (self->frame) { - /* change the decors on the frame */ - engine_frame_adjust_size(self->frame); - /* with more/less decorations, we may need to be repositioned */ - engine_frame_adjust_position(self->frame); + /* change the decors on the frame, and with more/less decorations, + we may also need to be repositioned */ + engine_frame_adjust_area(self->frame, TRUE, TRUE); /* with new decor, the window's maximized size may change */ client_remaximize(self); } @@ -850,6 +953,7 @@ static void client_change_allowed_actions(Client *self) else self->shaded = FALSE; } if (!(self->functions & Func_Iconify) && self->iconic) { + g_message("UNSETTING ICONIC"); if (self->frame) client_iconify(self, FALSE, TRUE); else self->iconic = FALSE; } @@ -891,21 +995,31 @@ void client_update_wmhints(Client *self) if (hints->flags & InputHint) self->can_focus = hints->input; - /* only do this when starting! */ - if (ob_state == State_Starting && (hints->flags & StateHint)) - self->iconic = hints->initial_state == IconicState; + /* only do this when first managing the window *AND* when we aren't + starting up! */ + if (ob_state != State_Starting && self->frame == NULL) + if (hints->flags & StateHint) + self->iconic = hints->initial_state == IconicState; if (hints->flags & XUrgencyHint) ur = TRUE; - if (hints->flags & WindowGroupHint) { - if (hints->window_group != self->group) { - /* XXX: remove from the old group if there was one */ - self->group = hints->window_group; - /* XXX: do stuff with the group */ - } - } else /* no group! */ - self->group = None; + if (!(hints->flags & WindowGroupHint)) + hints->window_group = None; /* no group */ + /* did the group state change? */ + if (hints->window_group != (self->group ? self->group->leader : None)){ + /* remove from the old group if there was one */ + if (self->group != NULL) + group_remove(self->group, self); + if (hints->window_group != None) + self->group = group_add(hints->window_group, self); + + /* because the self->transient flag wont change from this call, + we don't need to update the window's type and such, only its + transient_for, and the transients lists of other windows in the + group may be affected */ + client_update_transient_for(self); + } if (hints->flags & IconPixmapHint) { client_update_kwm_icon(self); @@ -927,7 +1041,7 @@ void client_update_wmhints(Client *self) if (ur != self->urgent) { self->urgent = ur; - g_message("Urgent Hint for 0x%lx: %s\n", self->window, + g_message("Urgent Hint for 0x%lx: %s", self->window, ur ? "ON" : "OFF"); /* fire the urgent callback if we're mapped, otherwise, wait until after we're mapped */ @@ -940,8 +1054,7 @@ void client_update_title(Client *self) { gchar *data = NULL; - if (self->title != NULL) - g_free(self->title); + g_free(self->title); /* try netwm */ if (!PROP_GETS(self->window, net_wm_name, utf8, data)) { @@ -975,8 +1088,7 @@ void client_update_icon_title(Client *self) { gchar *data = NULL; - if (self->icon_title != NULL) - g_free(self->icon_title); + g_free(self->icon_title); /* try netwm */ if (!PROP_GETS(self->window, net_wm_icon_name, utf8, data)) { @@ -1009,19 +1121,19 @@ void client_update_class(Client *self) gchar *s; guint i; - if (self->res_name) g_free(self->res_name); - if (self->res_class) g_free(self->res_class); + if (self->name) g_free(self->name); + if (self->class) g_free(self->class); if (self->role) g_free(self->role); - self->res_name = self->res_class = self->role = NULL; + self->name = self->class = self->role = NULL; data = g_ptr_array_new(); if (PROP_GETSA(self->window, wm_class, string, data)) { if (data->len > 0) - self->res_name = g_strdup(g_ptr_array_index(data, 0)); + self->name = g_strdup(g_ptr_array_index(data, 0)); if (data->len > 1) - self->res_class = g_strdup(g_ptr_array_index(data, 1)); + self->class = g_strdup(g_ptr_array_index(data, 1)); } for (i = 0; i < data->len; ++i) @@ -1031,8 +1143,8 @@ void client_update_class(Client *self) if (PROP_GETS(self->window, wm_window_role, string, s)) self->role = g_strdup(s); - if (self->res_name == NULL) self->res_name = g_strdup(""); - if (self->res_class == NULL) self->res_class = g_strdup(""); + if (self->name == NULL) self->name = g_strdup(""); + if (self->class == NULL) self->class = g_strdup(""); if (self->role == NULL) self->role = g_strdup(""); } @@ -1041,7 +1153,7 @@ void client_update_strut(Client *self) gulong *data; if (PROP_GET32A(self->window, net_wm_strut, cardinal, data, 4)) { - STRUT_SET(self->strut, data[0], data[1], data[2], data[3]); + STRUT_SET(self->strut, data[0], data[2], data[1], data[3]); g_free(data); } else STRUT_SET(self->strut, 0, 0, 0, 0); @@ -1081,8 +1193,8 @@ void client_update_icons(Client *self) /* store the icons */ i = 0; for (j = 0; j < self->nicons; ++j) { - w = self->icons[j].w = data[i++]; - h = self->icons[j].h = data[i++]; + w = self->icons[j].width = data[i++]; + h = self->icons[j].height = data[i++]; self->icons[j].data = g_memdup(&data[i], w * h * sizeof(gulong)); i += w * h; @@ -1092,11 +1204,6 @@ void client_update_icons(Client *self) g_free(data); } - if (self->nicons <= 0) { - self->nicons = 1; - self->icons = g_new0(Icon, 1); - } - if (self->frame) engine_frame_adjust_icon(self->frame); } @@ -1160,11 +1267,11 @@ static Client *search_focus_tree(Client *node, Client *skip) GSList *it; Client *ret; - for (it = node->transients; it != NULL; it = g_slist_next(it)) { + for (it = node->transients; it != NULL; it = it->next) { Client *c = it->data; if (c == skip) continue; /* circular? */ if ((ret = search_focus_tree(c, skip))) return ret; - if (c->focused) return c; + if (client_focused(c)) return c; } return NULL; } @@ -1178,7 +1285,7 @@ void client_calc_layer(Client *self) /* are we fullscreen, or do we have a fullscreen transient parent? */ c = self; fs = FALSE; - while (c) { + while (c && c != TRAN_GROUP) { /* XXX do smthng with the TRAN_GROUP case?*/ if (c->fullscreen) { fs = TRUE; break; @@ -1277,59 +1384,100 @@ void client_configure(Client *self, Corner anchor, int x, int y, int w, int h, { gboolean moved = FALSE, resized = FALSE; - w -= self->base_size.width; - h -= self->base_size.height; - - if (user) { - /* for interactive resizing. have to move half an increment in each - direction. */ - - /* how far we are towards the next size inc */ - int mw = w % self->size_inc.width; - int mh = h % self->size_inc.height; - /* amount to add */ - int aw = self->size_inc.width / 2; - int ah = self->size_inc.height / 2; - /* don't let us move into a new size increment */ - if (mw + aw >= self->size_inc.width) - aw = self->size_inc.width - mw - 1; - if (mh + ah >= self->size_inc.height) - ah = self->size_inc.height - mh - 1; - w += aw; - h += ah; - - /* if this is a user-requested resize, then check against min/max - sizes and aspect ratios */ + /* gets the frame's position */ + frame_client_gravity(self->frame, &x, &y); - /* smaller than min size or bigger than max size? */ - if (w > self->max_size.width) w = self->max_size.width; - if (w < self->min_size.width) w = self->min_size.width; - if (h > self->max_size.height) h = self->max_size.height; - if (h < self->min_size.height) h = self->min_size.height; + /* these positions are frame positions, not client positions */ - /* adjust the height ot match the width for the aspect ratios */ - if (self->min_ratio) - if (h * self->min_ratio > w) h = (int)(w / self->min_ratio); - if (self->max_ratio) - if (h * self->max_ratio < w) h = (int)(w / self->max_ratio); - } - - /* keep to the increments */ - w /= self->size_inc.width; - h /= self->size_inc.height; + /* set the size and position if fullscreen */ + if (self->fullscreen) { + x = 0; + y = 0; + w = screen_physical_size.width; + h = screen_physical_size.height; + } else { + /* 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; + } + if (self->max_vert) { + y = screen_area(self->desktop)->y; + h = screen_area(self->desktop)->height - + self->frame->size.top - self->frame->size.bottom; + } + } + + /* gets the client's position */ + frame_frame_gravity(self->frame, &x, &y); - /* you cannot resize to nothing */ - if (w < 1) w = 1; - if (h < 1) h = 1; + /* these override the above states! if you cant move you can't move! */ + if (user) { + if (!(self->functions & Func_Move)) { + x = self->area.x; + y = self->area.y; + } + if (!(self->functions & Func_Resize)) { + w = self->area.width; + h = self->area.height; + } + } + + if (!(w == self->area.width && h == self->area.height)) { + w -= self->base_size.width; + h -= self->base_size.height; + + if (user) { + /* for interactive resizing. have to move half an increment in each + direction. */ + + /* how far we are towards the next size inc */ + int mw = w % self->size_inc.width; + int mh = h % self->size_inc.height; + /* amount to add */ + int aw = self->size_inc.width / 2; + int ah = self->size_inc.height / 2; + /* don't let us move into a new size increment */ + if (mw + aw >= self->size_inc.width) + aw = self->size_inc.width - mw - 1; + if (mh + ah >= self->size_inc.height) + ah = self->size_inc.height - mh - 1; + w += aw; + h += ah; + + /* if this is a user-requested resize, then check against min/max + sizes and aspect ratios */ + + /* smaller than min size or bigger than max size? */ + if (w > self->max_size.width) w = self->max_size.width; + if (w < self->min_size.width) w = self->min_size.width; + if (h > self->max_size.height) h = self->max_size.height; + if (h < self->min_size.height) h = self->min_size.height; + + /* adjust the height ot match the width for the aspect ratios */ + if (self->min_ratio) + if (h * self->min_ratio > w) h = (int)(w / self->min_ratio); + if (self->max_ratio) + if (h * self->max_ratio < w) h = (int)(w / self->max_ratio); + } + + /* keep to the increments */ + w /= self->size_inc.width; + h /= self->size_inc.height; + + /* you cannot resize to nothing */ + if (w < 1) w = 1; + if (h < 1) h = 1; - /* store the logical size */ - SIZE_SET(self->logical_size, w, h); + /* store the logical size */ + SIZE_SET(self->logical_size, w, h); - w *= self->size_inc.width; - h *= self->size_inc.height; + w *= self->size_inc.width; + h *= self->size_inc.height; - w += self->base_size.width; - h += self->base_size.height; + w += self->base_size.width; + h += self->base_size.height; + } switch (anchor) { case Corner_TopLeft: @@ -1356,40 +1504,35 @@ void client_configure(Client *self, Corner anchor, int x, int y, int w, int h, /* move/resize the frame to match the request */ if (self->frame) { - /* Adjust the size and then the position, as required by the EWMH */ - if (resized) - engine_frame_adjust_size(self->frame); - if (moved) { - engine_frame_adjust_position(self->frame); - - if (!user || final) { - XEvent event; - event.type = ConfigureNotify; - event.xconfigure.display = ob_display; - event.xconfigure.event = self->window; - event.xconfigure.window = self->window; + if (moved || resized) + engine_frame_adjust_area(self->frame, moved, resized); + + if (!user || final) { + XEvent event; + event.type = ConfigureNotify; + event.xconfigure.display = ob_display; + event.xconfigure.event = self->window; + event.xconfigure.window = self->window; - /* root window coords with border in mind */ - event.xconfigure.x = x - self->border_width + - self->frame->size.left; - event.xconfigure.y = y - self->border_width + - self->frame->size.top; + /* root window coords with border in mind */ + event.xconfigure.x = x - self->border_width + + self->frame->size.left; + event.xconfigure.y = y - self->border_width + + self->frame->size.top; - event.xconfigure.width = self->area.width; - event.xconfigure.height = self->area.height; - event.xconfigure.border_width = self->border_width; - event.xconfigure.above = self->frame->plate; - event.xconfigure.override_redirect = FALSE; - XSendEvent(event.xconfigure.display, event.xconfigure.window, - FALSE, StructureNotifyMask, &event); - } + event.xconfigure.width = self->area.width; + event.xconfigure.height = self->area.height; + event.xconfigure.border_width = self->border_width; + event.xconfigure.above = self->frame->plate; + event.xconfigure.override_redirect = FALSE; + XSendEvent(event.xconfigure.display, event.xconfigure.window, + FALSE, StructureNotifyMask, &event); } } } void client_fullscreen(Client *self, gboolean fs, gboolean savearea) { - static int saved_func, saved_decor; int x, y, w, h; if (!(self->functions & Func_Fullscreen) || /* can't */ @@ -1400,11 +1543,11 @@ void client_fullscreen(Client *self, gboolean fs, gboolean savearea) if (fs) { /* save the functions and remove them */ - saved_func = self->functions; + self->pre_fs_func = self->functions; self->functions &= (Func_Close | Func_Fullscreen | Func_Iconify); /* save the decorations and remove them */ - saved_decor = self->decorations; + self->pre_fs_decor = self->decorations; self->decorations = 0; if (savearea) { long dimensions[4]; @@ -1416,15 +1559,15 @@ void client_fullscreen(Client *self, gboolean fs, gboolean savearea) PROP_SET32A(self->window, openbox_premax, cardinal, dimensions, 4); } - x = 0; - y = 0; - w = screen_physical_size.width; - h = screen_physical_size.height; + + /* these are not actually used cuz client_configure will set them + as appropriate when the window is fullscreened */ + x = y = w = h = 0; } else { long *dimensions; - self->functions = saved_func; - self->decorations = saved_decor; + self->functions = self->pre_fs_func; + self->decorations = self->pre_fs_decor; if (PROP_GET32A(self->window, openbox_premax, cardinal, dimensions, 4)) { @@ -1461,7 +1604,7 @@ void client_iconify(Client *self, gboolean iconic, gboolean curdesk) { if (self->iconic == iconic) return; /* nothing to do */ - g_message("%sconifying window: 0x%lx\n", (iconic ? "I" : "Uni"), + g_message("%sconifying window: 0x%lx", (iconic ? "I" : "Uni"), self->window); self->iconic = iconic; @@ -1474,13 +1617,24 @@ void client_iconify(Client *self, gboolean iconic, gboolean curdesk) XUnmapWindow(ob_display, self->window); } else { if (curdesk) - client_set_desktop(self, screen_desktop); + client_set_desktop(self, screen_desktop, FALSE); self->wmstate = self->shaded ? IconicState : NormalState; XMapWindow(ob_display, self->window); } 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 */ + if (self->transients) { + GSList *it; + + for (it = self->transients; it != NULL; it = it->next) + if (it->data != self) client_iconify(it->data, iconic, curdesk); + } } void client_maximize(Client *self, gboolean max, int dir, gboolean savearea) @@ -1535,17 +1689,6 @@ void client_maximize(Client *self, gboolean max, int dir, gboolean savearea) PROP_SET32A(self->window, openbox_premax, cardinal, dimensions, 4); } - if (dir == 0 || dir == 1) { /* horz */ - x = screen_area(self->desktop)->x - self->frame->size.left; - w = screen_area(self->desktop)->x + - screen_area(self->desktop)->width; - } - if (dir == 0 || dir == 2) { /* vert */ - y = screen_area(self->desktop)->y; - h = screen_area(self->desktop)->y + - screen_area(self->desktop)->height - - self->frame->size.top - self->frame->size.bottom; - } } else { long *dimensions; @@ -1592,7 +1735,7 @@ void client_maximize(Client *self, gboolean max, int dir, gboolean savearea) void client_shade(Client *self, gboolean shade) { - if (!(self->functions & Func_Shade) || /* can't */ + if ((!(self->functions & Func_Shade) && shade) || /* can't shade */ self->shaded == shade) return; /* already done */ /* when we're iconic, don't change the wmstate */ @@ -1600,7 +1743,8 @@ void client_shade(Client *self, gboolean shade) self->wmstate = shade ? IconicState : NormalState; self->shaded = shade; client_change_state(self); - engine_frame_adjust_size(self->frame); + /* resize the frame to just the titlebar */ + engine_frame_adjust_area(self->frame, FALSE, FALSE); } void client_close(Client *self) @@ -1623,20 +1767,25 @@ void client_close(Client *self) ce.xclient.window = self->window; ce.xclient.format = 32; ce.xclient.data.l[0] = prop_atoms.wm_delete_window; - ce.xclient.data.l[1] = CurrentTime; + ce.xclient.data.l[1] = event_lasttime; ce.xclient.data.l[2] = 0l; ce.xclient.data.l[3] = 0l; ce.xclient.data.l[4] = 0l; XSendEvent(ob_display, self->window, FALSE, NoEventMask, &ce); } -void client_set_desktop(Client *self, guint target) +void client_kill(Client *self) +{ + XKillClient(ob_display, self->window); +} + +void client_set_desktop(Client *self, guint target, gboolean donthide) { guint old, i; if (target == self->desktop) return; - g_message("Setting desktop %u\n", target); + g_message("Setting desktop %u", target); g_assert(target < screen_num_desktops || target == DESKTOP_ALL); @@ -1646,21 +1795,31 @@ void client_set_desktop(Client *self, guint target) /* the frame can display the current desktop state */ engine_frame_adjust_state(self->frame); /* 'move' the window to the new desktop */ - client_showhide(self); + if (!donthide) + client_showhide(self); + /* raise if it was not already on the desktop */ + if (old != DESKTOP_ALL) + stacking_raise(self); screen_update_struts(); /* update the focus lists */ if (old == DESKTOP_ALL) { for (i = 0; i < screen_num_desktops; ++i) focus_order[i] = g_list_remove(focus_order[i], self); - } else { + } else focus_order[old] = g_list_remove(focus_order[old], self); - } if (target == DESKTOP_ALL) { - for (i = 0; i < screen_num_desktops; ++i) - focus_order[i] = g_list_prepend(focus_order[i], self); + for (i = 0; i < screen_num_desktops; ++i) { + if (focus_new) + focus_order[i] = g_list_prepend(focus_order[i], self); + else + focus_order[i] = g_list_append(focus_order[i], self); + } } else { - focus_order[target] = g_list_prepend(focus_order[target], self); + if (focus_new) + focus_order[target] = g_list_prepend(focus_order[target], self); + else + focus_order[target] = g_list_append(focus_order[target], self); } dispatch_client(Event_Client_Desktop, self, target, old); @@ -1838,20 +1997,32 @@ void client_set_state(Client *self, Atom action, long data1, long data2) client_change_state(self); /* change the hint to relect these changes */ } -gboolean client_focus(Client *self) +Client *client_focus_target(Client *self) { - XEvent ev; Client *child; /* if we have a modal child, then focus it, not us */ child = client_find_modal_child(self); - if (child) - return client_focus(child); + if (child) return child; + return self; +} +gboolean client_focusable(Client *self) +{ /* won't try focus if the client doesn't want it, or if the window isn't visible on the screen */ - if (!(self->frame->visible && - (self->can_focus || self->focus_notify))) + return self->frame->visible && + (self->can_focus || self->focus_notify); +} + +gboolean client_focus(Client *self) +{ + XEvent ev; + + /* choose the correct target */ + self = client_focus_target(self); + + if (!client_focusable(self)) return FALSE; /* do a check to see if the window has already been unmapped or destroyed @@ -1871,9 +2042,13 @@ gboolean client_focus(Client *self) return FALSE; } } - + if (self->can_focus) - XSetInputFocus(ob_display, self->window, RevertToNone, CurrentTime); + /* RevertToPointerRoot causes much more headache than TevertToNone, so + I choose to use it always, hopefully to find errors quicker, if any + are left. (I hate X. I hate focus events.) */ + XSetInputFocus(ob_display, self->window, RevertToPointerRoot, + event_lasttime); if (self->focus_notify) { XEvent ce; @@ -1890,12 +2065,50 @@ gboolean client_focus(Client *self) XSendEvent(ob_display, self->window, FALSE, NoEventMask, &ce); } - /*XSync(ob_display, FALSE); XXX Why sync? */ +#ifdef DEBUG_FOCUS + g_message("focusing %lx", self->window); +#endif + + /* Cause the FocusIn to come back to us. Important for desktop switches, + since otherwise we'll have no FocusIn on the queue and send it off to + the focus_backup. */ + XSync(ob_display, FALSE); return TRUE; } void client_unfocus(Client *self) { g_assert(focus_client == self); - focus_set_client(NULL); + g_message("client_unfocus"); + focus_fallback(FALSE); +} + +gboolean client_focused(Client *self) +{ + return self == focus_client; +} + +Icon *client_icon(Client *self, int w, int h) +{ + int i; + /* si is the smallest image >= req */ + /* li is the largest image < req */ + unsigned long size, smallest = 0xffffffff, largest = 0, si = 0, li = 0; + + if (!self->nicons) return NULL; + + for (i = 0; i < self->nicons; ++i) { + size = self->icons[i].width * self->icons[i].height; + if (size < smallest && size >= (unsigned)(w * h)) { + smallest = size; + si = i; + } + if (size > largest && size <= (unsigned)(w * h)) { + largest = size; + li = i; + } + } + if (largest == 0) /* didnt find one smaller than the requested size */ + return &self->icons[si]; + return &self->icons[li]; }