]> Dogcows Code - chaz/openbox/blobdiff - openbox/client.c
handle focus in the kernel, no more plugin
[chaz/openbox] / openbox / client.c
index b717b914f561323ee9fd2f5ebe12b161a3ec8757..5d897f1c00faf01f78d3956f133ea98815b91b8a 100644 (file)
@@ -2,6 +2,7 @@
 #include "screen.h"
 #include "prop.h"
 #include "extensions.h"
+#include "config.h"
 #include "frame.h"
 #include "engine.h"
 #include "event.h"
@@ -23,6 +24,9 @@
 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);
@@ -38,13 +42,18 @@ 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();
 }
 
@@ -78,6 +87,7 @@ void client_set_list()
 
 void client_manage_all()
 {
+    ConfigValue focus_new;
     unsigned int i, j, nchild;
     Window w, *children;
     XWMHints *wmhints;
@@ -112,6 +122,27 @@ 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);
+        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)
@@ -122,6 +153,7 @@ void client_manage(Window window)
     XSetWindowAttributes attrib_set;
 /*    XWMHints *wmhint; */
     guint i;
+    ConfigValue focus_new;
 
     grab_server(TRUE);
 
@@ -186,8 +218,8 @@ void client_manage(Window window)
      
     client_list = g_slist_append(client_list, client);
     stacking_list = g_list_append(stacking_list, client);
-    g_assert(!g_hash_table_lookup(client_map, (gpointer)client->window));
-    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) {
@@ -208,10 +240,15 @@ void client_manage(Window window)
 
     dispatch_client(Event_Client_Mapped, client, 0, 0);
 
+    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()
@@ -226,7 +263,7 @@ void client_unmanage(Client *client)
     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);
@@ -241,7 +278,7 @@ void client_unmanage(Client *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) {
@@ -528,7 +565,7 @@ 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*/) {
@@ -794,7 +831,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 */
@@ -1090,8 +1127,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;
@@ -1101,11 +1138,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);
 }
@@ -1307,63 +1339,73 @@ void client_configure(Client *self, Corner anchor, int x, int y, int w, int h,
         }
     }
 
-    if (x == self->area.x && y == self->area.y && w == self->area.width &&
-        h == self->area.height)
-        return; /* no change */
-
-    w -= self->base_size.width;
-    h -= self->base_size.height;
-
+    /* 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;
+    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;
+        /* 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:
@@ -1390,30 +1432,29 @@ 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) {
-        engine_frame_adjust_area(self->frame, moved, resized);
-
-       if (moved) {
-           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);
        }
     }
 }
@@ -1906,8 +1947,8 @@ gboolean client_focus(Client *self)
     }
 
     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;
@@ -1917,21 +1958,26 @@ gboolean client_focus(Client *self)
        ce.xclient.window = self->window;
        ce.xclient.format = 32;
        ce.xclient.data.l[0] = prop_atoms.wm_take_focus;
-       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);
     }
 
-    /* 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);
-    client_set_focused(self, FALSE);
+    focus_fallback(FALSE);
 }
 
 gboolean client_focused(Client *self)
@@ -1939,18 +1985,27 @@ gboolean client_focused(Client *self)
     return self == focus_client;
 }
 
-void client_set_focused(Client *self, gboolean focused)
+Icon *client_icon(Client *self, int w, int h)
 {
-    if (focused) {
-        if (focus_client != self)
-            focus_set_client(self);
-    } else {
-       if (focus_client == self)
-           focus_set_client(NULL);
-    }
+    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;
 
-    /* focus state can affect the stacking layer */
-    client_calc_layer(self);
+    if (!self->nicons) return NULL;
 
-    engine_frame_adjust_focus(self->frame);
+    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];
 }
This page took 0.033345 seconds and 4 git commands to generate.