#include "screen.h"
#include "prop.h"
#include "extensions.h"
+#include "config.h"
#include "frame.h"
#include "engine.h"
#include "event.h"
+#include "grab.h"
#include "focus.h"
#include "stacking.h"
#include "dispatch.h"
GSList *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);
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();
}
void client_manage_all()
{
+ ConfigValue focus_new;
unsigned int i, j, nchild;
Window w, *children;
XWMHints *wmhints;
}
}
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);
+ g_message("0x%lx %d", c->window, c->iconic);
+ if (c) stacking_lower(c);
+ }
+ g_free(client_startup_stack_order);
+ client_startup_stack_order = NULL;
+ client_startup_stack_size = 0;
+
+ if (!config_get("focusNew", Config_Bool, &focus_new))
+ g_assert_not_reached();
+ if (focus_new.bool)
+ focus_fallback(FALSE);
}
void client_manage(Window window)
XWindowAttributes attrib;
XSetWindowAttributes attrib_set;
/* XWMHints *wmhint; */
-
- XGrabServer(ob_display);
- XSync(ob_display, FALSE);
+ guint i;
+ ConfigValue focus_new;
+
+ grab_server(TRUE);
/* check if it has already been unmapped by the time we started mapping
the grab does a sync so we don't have to here */
if (XCheckTypedWindowEvent(ob_display, window, DestroyNotify, &e) ||
XCheckTypedWindowEvent(ob_display, window, UnmapNotify, &e)) {
XPutBackEvent(ob_display, &e);
-
- XUngrabServer(ob_display);
- XFlush(ob_display);
+
+ grab_server(FALSE);
return; /* don't manage it */
}
/* make sure it isn't an override-redirect window */
if (!XGetWindowAttributes(ob_display, window, &attrib) ||
attrib.override_redirect) {
- XUngrabServer(ob_display);
- XFlush(ob_display);
+ grab_server(FALSE);
return; /* don't manage it */
}
if ((wmhint->flags & StateHint) &&
wmhint->initial_state == WithdrawnState) {
/\* XXX: make dock apps work! *\/
- XUngrabServer(ob_display);
- XFlush(ob_display);
+ grab_server(FALSE);
XFree(wmhint);
return;
}
client_apply_startup_state(client);
- XUngrabServer(ob_display);
- XFlush(ob_display);
+ 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);
+ g_assert(!g_hash_table_lookup(client_map, &client->window));
+ g_hash_table_insert(client_map, &client->window, client);
+
+ /* update the focus lists */
+ if (client->desktop == DESKTOP_ALL) {
+ for (i = 0; i < screen_num_desktops; ++i)
+ focus_order[i] = g_list_append(focus_order[i], client);
+ } else {
+ i = client->desktop;
+ focus_order[i] = g_list_append(focus_order[i], client);
+ }
stacking_raise(client);
dispatch_client(Event_Client_Mapped, client, 0, 0);
- /* grab all mouse bindings */
- /*pointer_grab_all(client, TRUE);XXX*/
+ if (!config_get("focusNew", Config_Bool, &focus_new))
+ g_assert_not_reached();
+ if (ob_state != State_Starting && focus_new.bool)
+ client_focus(client);
/* update the list hints */
client_set_list();
- g_message("Managed window 0x%lx", window);
+/* g_message("Managed window 0x%lx", window);*/
}
void client_unmanage_all()
void client_unmanage(Client *client)
{
+ guint i;
int j;
GSList *it;
- g_message("Unmanaging window: %lx", client->window);
+/* g_message("Unmanaging window: %lx", client->window);*/
dispatch_client(Event_Client_Destroy, client, 0, 0);
+ g_assert(client != NULL);
/* remove the window from our save set */
XChangeSaveSet(ob_display, client->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);
- /* give the client its border back */
- client_toggle_border(client, TRUE);
-
- /* 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);
+ g_hash_table_remove(client_map, &client->window);
+
+ /* update the focus lists */
+ if (client->desktop == DESKTOP_ALL) {
+ for (i = 0; i < screen_num_desktops; ++i)
+ focus_order[i] = g_list_remove(focus_order[i], client);
+ } else {
+ i = client->desktop;
+ focus_order[i] = g_list_remove(focus_order[i], client);
+ }
/* once the client is out of the list, update the struts to remove it's
influence */
client_calc_layer(it->data);
}
- /* unfocus the client (calls the focus callbacks) (we're out of the
+ /* dispatch the unmapped event */
+ dispatch_client(Event_Client_Unmapped, client, 0, 0);
+ g_assert(client != NULL);
+
+ /* unfocus the client (dispatchs the focus event) (we're out of the
transient lists already, so being modal doesn't matter) */
- if (client->focused)
+ if (client_focused(client))
client_unfocus(client);
-
+
+ /* give the client its border back */
+ client_toggle_border(client, TRUE);
+
+ /* reparent the window out of the frame, and free the frame */
+ engine_frame_release_client(client->frame, client);
+ client->frame = NULL;
+
if (ob_state != State_Exiting) {
/* these values should not be persisted across a window
unmapping/mapping */
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->name);
+ g_free(client->class);
g_free(client->role);
g_free(client);
/* 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;
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->transient_for) {
if (self->transient_for)
/* 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)
/* add to new parent */
- g_slist_append(self->transient_for->transients, self);
+ self->transient_for->transients =
+ g_slist_append(self->transient_for->transients, 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 */
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);
}
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 */
{
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)) {
{
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)) {
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)
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("");
}
/* 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;
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);
}
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;
}
{
gboolean moved = FALSE, resized = FALSE;
- w -= self->base_size.width;
- h -= self->base_size.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)->x +
+ screen_area(self->desktop)->width;
+ }
+ if (self->max_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;
+ }
+ }
+ /* these override the above states! if you cant move you can't move! */
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);
+ 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;
+ }
}
- /* 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;
+ 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:
/* 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 */
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];
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)) {
{
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;
client_change_state(self);
client_showhide(self);
screen_update_struts();
+
+ dispatch_client(iconic ? Event_Client_Unmapped : Event_Client_Mapped,
+ self, 0, 0);
}
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;
- }
+
+ /* pass the client's current position info. the client_configure
+ will move/size stuff as appropriate for a maximized window */
+ x = self->area.x;
+ y = self->area.y;
+ w = self->area.width;
+ h = self->area.height;
} else {
long *dimensions;
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)
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_kill(Client *self)
+{
+ XKillClient(ob_display, self->window);
+}
+
void client_set_desktop(Client *self, guint target)
{
- guint old;
+ guint old, i;
if (target == self->desktop) return;
g_message("Setting desktop %u\n", target);
- if (!(target < screen_num_desktops ||
- target == DESKTOP_ALL))
- return;
+ g_assert(target < screen_num_desktops || target == DESKTOP_ALL);
old = self->desktop;
self->desktop = target;
client_showhide(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);
+ focus_order[target] = g_list_prepend(focus_order[target], self);
+ } 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);
+ }
+
dispatch_client(Event_Client_Desktop, self, target, old);
}
return FALSE;
}
}
-
+
if (self->can_focus)
- XSetInputFocus(ob_display, self->window, RevertToNone, CurrentTime);
+ XSetInputFocus(ob_display, self->window, RevertToPointerRoot,
+ event_lasttime);
if (self->focus_notify) {
XEvent ce;
XSendEvent(ob_display, self->window, FALSE, NoEventMask, &ce);
}
- /*XSync(ob_display, FALSE); XXX Why sync? */
+ g_message("focusing %lx", self->window);
+
+ /* 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);
+ 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];
}
projects / chaz / openbox / blobdiff