]> Dogcows Code - chaz/openbox/blobdiff - openbox/client.c
add decoration state to the frame struct. make client_configure adjust the frame...
[chaz/openbox] / openbox / client.c
index 29a20ad965977bd4da7000deaff9c76a82f86cbd..87cdba96973d61b55cef4f8f76bcff33ea6bbcee 100644 (file)
@@ -1,5 +1,6 @@
 #include "client.h"
-#include "slit.h"
+#include "dock.h"
+#include "xerror.h"
 #include "startup.h"
 #include "screen.h"
 #include "moveresize.h"
@@ -14,6 +15,8 @@
 #include "openbox.h"
 #include "group.h"
 #include "config.h"
+#include "menu.h"
+#include "render/render.h"
 
 #include <glib.h>
 #include <X11/Xutil.h>
@@ -26,7 +29,6 @@
                                ButtonMotionMask)
 
 GList      *client_list      = NULL;
-GHashTable *client_map       = NULL;
 
 static void client_get_all(Client *self);
 static void client_toggle_border(Client *self, gboolean show);
@@ -41,20 +43,13 @@ static void client_change_allowed_actions(Client *self);
 static void client_change_state(Client *self);
 static void client_apply_startup_state(Client *self);
 
-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);
-
     client_set_list();
 }
 
 void client_shutdown()
 {
-    g_hash_table_destroy(client_map);
 }
 
 void client_set_list()
@@ -102,7 +97,7 @@ void client_foreach_ancestor(Client *self, ClientForeachFunc func, void *data)
 
             for (it = self->group->members; it; it = it->next)
                 if (it->data != self &&
-                    ((Client*)it->data)->transient_for != TRAN_GROUP) {
+                    !((Client*)it->data)->transient_for) {
                     if (!func(it->data, data)) return;
                     client_foreach_ancestor(it->data, func, data);
                 }
@@ -117,7 +112,6 @@ void client_manage_all()
     Window w, *children;
     XWMHints *wmhints;
     XWindowAttributes attrib;
-    Client *active;
 
     XQueryTree(ob_display, ob_root, &w, &w, &children, &nchild);
 
@@ -154,19 +148,28 @@ void client_manage_all()
        stacking list are on the top where you can see them instead of buried
        at the bottom! */
     for (i = startup_stack_size; i > 0; --i) {
-        Client *c;
+        ObWindow *obw;
 
         w = startup_stack_order[i-1];
-        c = g_hash_table_lookup(client_map, &w);
-        if (c) stacking_lower(c);
+        obw = g_hash_table_lookup(window_map, &w);
+        if (obw) {
+            g_assert(WINDOW_IS_CLIENT(obw));
+            stacking_lower(CLIENT_AS_WINDOW(obw));
+        }
     }
     g_free(startup_stack_order);
     startup_stack_order = NULL;
     startup_stack_size = 0;
 
     if (config_focus_new) {
-        active = g_hash_table_lookup(client_map, &startup_active);
-        if (!(active && client_focus(active)))
+        ObWindow *active;
+
+        active = g_hash_table_lookup(window_map, &startup_active);
+        if (active) {
+            g_assert(WINDOW_IS_CLIENT(active));
+            if (!client_focus(WINDOW_AS_CLIENT(active)))
+                focus_fallback(Fallback_NoFocus);
+        } else
             focus_fallback(Fallback_NoFocus);
     }
 }
@@ -178,6 +181,7 @@ void client_manage(Window window)
     XWindowAttributes attrib;
     XSetWindowAttributes attrib_set;
     XWMHints *wmhint;
+    gboolean activate = FALSE;
 
     grab_server(TRUE);
 
@@ -202,7 +206,7 @@ void client_manage(Window window)
     if ((wmhint = XGetWMHints(ob_display, window))) {
        if ((wmhint->flags & StateHint) &&
            wmhint->initial_state == WithdrawnState) {
-            slit_add(window, wmhint, &attrib);
+            dock_add(window, wmhint);
             grab_server(FALSE);
            XFree(wmhint);
            return;
@@ -222,6 +226,7 @@ void client_manage(Window window)
     /* create the Client struct, and populate it from the hints on the
        window */
     self = g_new(Client, 1);
+    self->obwin.type = Window_Client;
     self->window = window;
     client_get_all(self);
 
@@ -240,75 +245,66 @@ void client_manage(Window window)
     client_apply_startup_state(self);
 
     grab_server(FALSE);
-     
+
+    /* add to client list/map */
     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);
+    g_hash_table_insert(window_map, &self->window, self);
 
     /* update the focus lists */
     focus_order_add_new(self);
 
-    stacking_raise(self);
-
-    screen_update_struts();
-
-    dispatch_client(Event_Client_New, self, 0, 0);
-
-    client_showhide(self);
-
     /* focus the new window? */
-    if (ob_state != State_Starting) {
-        Client *parent;
+    if (ob_state != State_Starting && config_focus_new &&
+        (self->type == Type_Normal || self->type == Type_Dialog)) {
         gboolean group_foc = FALSE;
         
-        parent = NULL;
-
         if (self->group) {
             GSList *it;
 
-            for (it = self->group->members; it; it = it->next)
+            for (it = self->group->members; it; it = it->next) {
                 if (client_focused(it->data)) {
                     group_foc = TRUE;
                     break;
                 }
-        }
-        if (!group_foc && self->transient_for) {
-            if (self->transient_for != TRAN_GROUP) {/* transient of a window */
-                parent = self->transient_for;
-            } else { /* transient of a group */
-                GSList *it;
-
-                for (it = self->group->members; it; it = it->next)
-                    if (it->data != self &&
-                        ((Client*)it->data)->transient_for != TRAN_GROUP)
-                        parent = it->data;
             }
         }
-        /* note the check against Type_Normal, not client_normal(self), which
-           would also include dialog types. in this case we want more strict
-           rules for focus */
-        if ((config_focus_new &&
-             (self->type == Type_Normal ||
-              (self->type == Type_Dialog &&
-               (group_foc ||
-                (!parent && (!self->group ||
-                             !self->group->members->next)))))) ||
-            (parent && (client_focused(parent) ||
-                        client_search_focus_tree(parent)))) {
-            client_focus(self);
+        /* note the check against Type_Normal/Dialog, not client_normal(self),
+           which would also include other types. in this case we want more
+           strict rules for focus */
+        if ((group_foc ||
+             (!self->transient_for && (!self->group ||
+                                       !self->group->members->next))) ||
+            client_search_focus_tree_full(self) ||
+            !focus_client ||
+            !client_normal(focus_client)) {
+            /* activate the window */
+            stacking_add(CLIENT_AS_WINDOW(self));
+            activate = TRUE;
+        } else {
+            /* try to not get in the way */
+            stacking_add_nonintrusive(CLIENT_AS_WINDOW(self));
         }
+    } else {
+        stacking_add(CLIENT_AS_WINDOW(self));
     }
 
-    /* update the list hints */
-    client_set_list();
+    screen_update_struts();
 
     /* make sure the window is visible */
     client_move_onscreen(self);
 
+    dispatch_client(Event_Client_New, self, 0, 0);
+
+    client_showhide(self);
+
+    if (activate) client_activate(self);
+
+    /* update the list hints */
+    client_set_list();
+
     dispatch_client(Event_Client_Mapped, self, 0, 0);
 
-    g_message("Managed window 0x%lx", window);
+    g_message("Managed window 0x%lx (%s)", window, self->class);
 }
 
 void client_unmanage_all()
@@ -317,12 +313,19 @@ void client_unmanage_all()
        client_unmanage(client_list->data);
 }
 
+/* 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);
+}
+
 void client_unmanage(Client *self)
 {
     int j;
     GSList *it;
 
-    g_message("Unmanaging window: %lx", self->window);
+    g_message("Unmanaging window: %lx (%s)", self->window, self->class);
 
     dispatch_client(Event_Client_Destroy, self, 0, 0);
     g_assert(self != NULL);
@@ -336,8 +339,8 @@ void client_unmanage(Client *self)
     frame_hide(self->frame);
 
     client_list = g_list_remove(client_list, self);
-    stacking_list = g_list_remove(stacking_list, self);
-    g_hash_table_remove(client_map, &self->window);
+    stacking_remove(self);
+    g_hash_table_remove(window_map, &self->window);
 
     /* update the focus lists */
     focus_order_remove(self);
@@ -370,6 +373,10 @@ void client_unmanage(Client *self)
     if (moveresize_client == self)
         moveresize_end(TRUE);
 
+    /* close any windows that are attached to this window */
+    g_hash_table_foreach(menu_hash, client_close_menus, self);
+
+    
     if (focus_client == self) {
         XEvent e;
 
@@ -562,7 +569,6 @@ static void client_get_all(Client *self)
     client_update_class(self);
     client_update_strut(self);
     client_update_icons(self);
-    client_update_kwm_icon(self);
 
     client_change_state(self);
 }
@@ -599,7 +605,7 @@ static void client_get_desktop(Client *self)
 
                 for (it = self->group->members; it; it = it->next)
                     if (it->data != self &&
-                        ((Client*)it->data)->transient_for != TRAN_GROUP) {
+                        !((Client*)it->data)->transient_for) {
                         self->desktop = ((Client*)it->data)->desktop;
                         trdesk = TRUE;
                         break;
@@ -680,9 +686,10 @@ void client_update_transient_for(Client *self)
     if (XGetTransientForHint(ob_display, self->window, &t)) {
        self->transient = TRUE;
         if (t != self->window) { /* cant be transient to itself! */
-            c = g_hash_table_lookup(client_map, &t);
+            c = g_hash_table_lookup(window_map, &t);
             /* if this happens then we need to check for it*/
             g_assert(c != self);
+            g_assert(!c || WINDOW_IS_CLIENT(c));
             
             if (!c && self->group) {
                 /* not transient to a client, see if it is transient for a
@@ -706,7 +713,7 @@ void client_update_transient_for(Client *self)
            /* remove from old parents */
             for (it = self->group->members; it; it = it->next)
                 if (it->data != self &&
-                    (((Client*)it->data)->transient_for != TRAN_GROUP))
+                    !((Client*)it->data)->transient_for)
                     ((Client*)it->data)->transients =
                         g_slist_remove(((Client*)it->data)->transients, self);
         } else if (self->transient_for != NULL) { /* transient of window */
@@ -721,7 +728,7 @@ void client_update_transient_for(Client *self)
            /* add to new parents */
             for (it = self->group->members; it; it = it->next)
                 if (it->data != self &&
-                    (((Client*)it->data)->transient_for != TRAN_GROUP))
+                    !((Client*)it->data)->transient_for)
                     ((Client*)it->data)->transients =
                         g_slist_append(((Client*)it->data)->transients, self);
 
@@ -1020,11 +1027,8 @@ void client_setup_decor_and_functions(Client *self)
         if (self->type == Type_Desktop && self->desktop != DESKTOP_ALL)
             client_set_desktop(self, DESKTOP_ALL, FALSE);
 
-       /* change the decors on the frame, and with more/less decorations,
-           we may also need to be repositioned */
-       frame_adjust_area(self->frame, TRUE, TRUE);
-       /* with new decor, the window's maximized size may change */
-       client_remaximize(self);
+       /* 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)
@@ -1082,19 +1086,13 @@ static void client_change_allowed_actions(Client *self)
     }
 }
 
-void client_remaximize(Client *self)
+void client_reconfigure(Client *self)
 {
-    int dir;
-    if (self->max_horz && self->max_vert)
-       dir = 0;
-    else if (self->max_horz)
-       dir = 1;
-    else if (self->max_vert)
-       dir = 2;
-    else
-       return; /* not maximized */
-    self->max_horz = self->max_vert = FALSE;
-    client_maximize(self, TRUE, dir, FALSE);
+    /* 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
+       is generally what we want anyways... */
+    client_configure(self, Corner_TopLeft, self->area.x, self->area.y,
+                     self->area.width, self->area.height, FALSE, TRUE);
 }
 
 void client_update_wmhints(Client *self)
@@ -1129,26 +1127,30 @@ void client_update_wmhints(Client *self)
             if (self->group != NULL) {
                 /* remove transients of the group */
                 for (it = self->group->members; it; it = it->next)
-                    if (it->data != self &&
-                        ((Client*)it->data)->transient_for == TRAN_GROUP) {
-                        self->transients = g_slist_remove(self->transients,
-                                                          it->data);
-                    }
+                    self->transients = g_slist_remove(self->transients,
+                                                      it->data);
                 group_remove(self->group, self);
                 self->group = NULL;
             }
             if (hints->window_group != None) {
                 self->group = group_add(hints->window_group, self);
 
-                /* add other transients of the group that are already
-                   set up */
-                for (it = self->group->members; it; it = it->next)
-                    if (it->data != self &&
-                        ((Client*)it->data)->transient_for == TRAN_GROUP)
-                        self->transients = g_slist_append(self->transients,
-                                                          it->data);
+                /* i can only have transients from the group if i am not
+                   transient myself */
+                if (!self->transient_for) {
+                    /* add other transients of the group that are already
+                       set up */
+                    for (it = self->group->members; it; it = it->next)
+                        if (it->data != self &&
+                            ((Client*)it->data)->transient_for == TRAN_GROUP)
+                            self->transients = g_slist_append(self->transients,
+                                                              it->data);
+                }
             }
 
+            /* the WM_HINTS can contain an icon */
+            client_update_icons(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
@@ -1156,23 +1158,6 @@ void client_update_wmhints(Client *self)
             client_update_transient_for(self);
         }
 
-        client_update_kwm_icon(self);
-        /* try get the kwm icon first, this is a fallback only */
-        if (self->pixmap_icon == None) {
-            if (hints->flags & IconPixmapHint) {
-                if (self->pixmap_icon == None) {
-                    self->pixmap_icon = hints->icon_pixmap;
-                    if (hints->flags & IconMaskHint)
-                        self->pixmap_icon_mask = hints->icon_mask;
-                    else
-                        self->pixmap_icon_mask = None;
-
-                    if (self->frame)
-                        frame_adjust_icon(self->frame);
-                }
-            }
-       }
-
        XFree(hints);
     }
 
@@ -1332,7 +1317,7 @@ void client_update_icons(Client *self)
            w = data[i++];
            h = data[i++];
            i += w * h;
-           if (i > num) break;
+           if (i > num || w*h == 0) break;
            ++self->nicons;
        }
 
@@ -1341,36 +1326,70 @@ void client_update_icons(Client *self)
        /* store the icons */
        i = 0;
        for (j = 0; j < self->nicons; ++j) {
+            guint x, y, t;
+
            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;
+
+            if (w*h == 0) continue;
+
+           self->icons[j].data = g_new(RrPixel32, w * h);
+            for (x = 0, y = 0, t = 0; t < w * h; ++t, ++x, ++i) {
+                if (x >= w) {
+                    x = 0;
+                    ++y;
+                }
+                self->icons[j].data[t] =
+                    (((data[i] >> 24) & 0xff) << RrDefaultAlphaOffset) +
+                    (((data[i] >> 16) & 0xff) << RrDefaultRedOffset) +
+                    (((data[i] >> 8) & 0xff) << RrDefaultGreenOffset) +
+                    (((data[i] >> 0) & 0xff) << RrDefaultBlueOffset);
+            }
            g_assert(i <= num);
        }
 
        g_free(data);
-    }
-
-    if (self->frame)
-       frame_adjust_icon(self->frame);
-}
-
-void client_update_kwm_icon(Client *self)
-{
-    guint num;
-    guint32 *data;
-
-    if (!PROP_GETA32(self->window, kwm_win_icon, kwm_win_icon, &data, &num)) {
-       self->pixmap_icon = self->pixmap_icon_mask = None;
-    } else {
+    } else if (PROP_GETA32(self->window, kwm_win_icon,
+                           kwm_win_icon, &data, &num)) {
         if (num == 2) {
-            self->pixmap_icon = data[0];
-            self->pixmap_icon_mask = data[1];
-        } else
-            self->pixmap_icon = self->pixmap_icon_mask = None;
-       g_free(data);
+            self->nicons++;
+            self->icons = g_new(Icon, self->nicons);
+            xerror_set_ignore(TRUE);
+            if (!RrPixmapToRGBA(ob_rr_inst,
+                                data[0], data[1],
+                                &self->icons[self->nicons-1].width,
+                                &self->icons[self->nicons-1].height,
+                                &self->icons[self->nicons-1].data)) {
+                g_free(&self->icons[self->nicons-1]);
+                self->nicons--;
+            }
+            xerror_set_ignore(FALSE);
+        }
+        g_free(data);
+    } else {
+        XWMHints *hints;
+
+        if ((hints = XGetWMHints(ob_display, self->window))) {
+            if (hints->flags & IconPixmapHint) {
+                self->nicons++;
+                self->icons = g_new(Icon, self->nicons);
+                xerror_set_ignore(TRUE);
+                if (!RrPixmapToRGBA(ob_rr_inst,
+                                    hints->icon_pixmap,
+                                    (hints->flags & IconMaskHint ?
+                                     hints->icon_mask : None),
+                                    &self->icons[self->nicons-1].width,
+                                    &self->icons[self->nicons-1].height,
+                                    &self->icons[self->nicons-1].data)){
+                    g_free(&self->icons[self->nicons-1]);
+                    self->nicons--;
+                }
+                xerror_set_ignore(FALSE);
+            }
+            XFree(hints);
+        }
     }
+
     if (self->frame)
        frame_adjust_icon(self->frame);
 }
@@ -1433,30 +1452,32 @@ Client *client_search_focus_tree_full(Client *self)
             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 != TRAN_GROUP) {
+                if (!((Client*)it->data)->transient_for) {
                     Client *c;
                     if ((c = client_search_focus_tree_full(it->data)))
                         return c;
+                    recursed = TRUE;
                 }
-            return NULL;
+            if (recursed)
+              return NULL;
         }
-    } else {
-        /* this function checks the whole tree, the client_search_focus_tree
-           does not, so we need to check this window */
-        if (client_focused(self))
-            return self;
-        return client_search_focus_tree(self);
     }
+
+    /* this function checks the whole tree, the client_search_focus_tree~
+       does not, so we need to check this window */
+    if (client_focused(self))
+      return self;
+    return client_search_focus_tree(self);
 }
 
 static StackLayer calc_layer(Client *self)
 {
     StackLayer l;
 
-    if (self->iconic) l = Layer_Icon;
-    else if (self->fullscreen) l = Layer_Fullscreen;
+    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;
@@ -1484,7 +1505,7 @@ static void calc_recursive(Client *self, Client *orig, StackLayer l,
 
     if (!raised && l != old)
        if (orig->frame) /* only restack if the original window is managed */
-           stacking_raise(self);
+           stacking_raise(CLIENT_AS_WINDOW(self));
 }
 
 void client_calc_layer(Client *self)
@@ -1503,7 +1524,7 @@ void client_calc_layer(Client *self)
 
             for (it = self->group->members; it; it = it->next)
                 if (it->data != self &&
-                    ((Client*)it->data)->transient_for != TRAN_GROUP) {
+                    !((Client*)it->data)->transient_for) {
                     self = it->data;
                     break;
                 }
@@ -1590,10 +1611,25 @@ void client_configure(Client *self, Corner anchor, int x, int y, int w, int h,
 
     /* set the size and position if fullscreen */
     if (self->fullscreen) {
-       x = 0;
-       y = 0;
-       w = screen_physical_size.width;
-       h = screen_physical_size.height;
+#ifdef VIDMODE
+        int dot;
+        XF86VidModeModeLine mode;
+
+        if (XF86VidModeGetModeLine(ob_display, ob_screen, &dot, &mode)) {
+            w = mode.hdisplay;
+            h = mode.vdisplay;
+            if (mode.privsize) XFree(mode.private);
+        } else {
+#else
+            w = screen_physical_size.width;
+            h = screen_physical_size.height;
+#endif
+#ifdef VIDMODE
+        }
+        if (!XF86VidModeGetViewPort(ob_display, ob_screen, &x, &y)) {
+            x = y = 0;
+#endif
+        }
         user = FALSE; /* ignore that increment etc shit when in fullscreen */
     } else {
         /* set the size and position if maximized */
@@ -1624,16 +1660,32 @@ void client_configure(Client *self, Corner anchor, int x, int y, int w, int h,
     }
 
     if (!(w == self->area.width && h == self->area.height)) {
-        w -= self->base_size.width;
-        h -= self->base_size.height;
+        int basew, baseh, minw, minh;
+
+        /* base size is substituted with min size if not specified */
+        if (self->base_size.width || self->base_size.height) {
+            basew = self->base_size.width;
+            baseh = self->base_size.height;
+        } else {
+            basew = self->min_size.width;
+            baseh = self->min_size.height;
+        }
+        /* min size is substituted with base size if not specified */
+        if (self->min_size.width || self->min_size.height) {
+            minw = self->min_size.width;
+            minh = self->min_size.height;
+        } else {
+            minw = self->base_size.width;
+            minh = 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;
+            int mw = (w - basew) % self->size_inc.width; 
+            int mh = (h - baseh) % self->size_inc.height;
             /* amount to add */
             int aw = self->size_inc.width / 2;
             int ah = self->size_inc.height / 2;
@@ -1646,21 +1698,18 @@ void client_configure(Client *self, Corner anchor, int x, int y, int w, int h,
             h += ah;
     
             /* if this is a user-requested resize, then check against min/max
-               sizes and aspect ratios */
+               sizes */
 
             /* 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 (w < minw) w = minw;
             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 (h < minh) h = minh;
         }
 
+        w -= basew;
+        h -= baseh;
+
         /* keep to the increments */
         w /= self->size_inc.width;
         h /= self->size_inc.height;
@@ -1675,8 +1724,23 @@ void client_configure(Client *self, Corner anchor, int x, int y, int w, int h,
         w *= self->size_inc.width;
         h *= self->size_inc.height;
 
-        w += self->base_size.width;
-        h += self->base_size.height;
+        w += basew;
+        h += baseh;
+
+        if (user) {
+            /* adjust the height to match the width for the aspect ratios.
+             for this, min size is not substituted for base size ever. */
+            w -= self->base_size.width;
+            h -= self->base_size.height;
+
+            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);
+
+            w += self->base_size.width;
+            h += self->base_size.height;
+        }
     }
 
     switch (anchor) {
@@ -1699,30 +1763,39 @@ void client_configure(Client *self, Corner anchor, int x, int y, int w, int h,
 
     RECT_SET(self->area, x, y, w, h);
 
-    if (resized)
+    /* for app-requested resizes, always resize if 'resized' is true.
+       for user-requested ones, only resize if final is true, or when
+       resizing in opaque mode */
+    if ((!user && resized) ||
+        (user && (final || (resized && config_opaque_resize))))
        XResizeWindow(ob_display, self->window, w, h);
 
     /* move/resize the frame to match the request */
     if (self->frame) {
+        if (self->decorations != self->frame->decorations)
+            moved = resized = TRUE;
+
         if (moved || resized)
             frame_adjust_area(self->frame, moved, resized);
 
-        if (!user || final) {
+        /* If you send this and the client hasn't changed you end up with buggy
+           clients (emacs) freaking out, cuz they send back a configure every
+           time they receive this event, which resends them this event... etc.
+        */
+        if ((!user && moved) || (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 real coords */
+            event.xconfigure.x = self->frame->area.x + self->frame->size.left;
+            event.xconfigure.y = self->frame->area.y + 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.width = w;
+            event.xconfigure.height = h;
+            event.xconfigure.border_width = 0;
             event.xconfigure.above = self->frame->plate;
             event.xconfigure.override_redirect = FALSE;
             XSendEvent(event.xconfigure.display, event.xconfigure.window,
@@ -1803,13 +1876,10 @@ void client_iconify(Client *self, gboolean iconic, gboolean curdesk)
         } else {
             GSList *it;
 
-            /* the check for TRAN_GROUP is to prevent an infinate loop with
-               2 transients of the same group at the head of the group's
-               members list */
             for (it = self->group->members; it; it = it->next) {
                 Client *c = it->data;
                 if (c != self && c->iconic != iconic &&
-                    c->transient_for != TRAN_GROUP) {
+                    !c->transient_for) {
                     client_iconify(it->data, iconic, curdesk);
                     break;
                 }
@@ -1844,6 +1914,11 @@ void client_iconify(Client *self, gboolean iconic, gboolean curdesk)
         /* this puts it after the current focused window */
         focus_order_remove(self);
         focus_order_add_new(self);
+
+        /* this is here cuz with the VIDMODE extension, the viewport can change
+           while a fullscreen window is iconic, and when it uniconifies, it
+           would be nice if it did so to the new position of the viewport */
+        client_reconfigure(self);
     }
     client_change_state(self);
     client_showhide(self);
@@ -2011,7 +2086,7 @@ void client_set_desktop(Client *self, guint target, gboolean donthide)
 
     if (target == self->desktop) return;
   
-    g_message("Setting desktop %u", target);
+    g_message("Setting desktop %u", target+1);
 
     g_assert(target < screen_num_desktops || target == DESKTOP_ALL);
 
@@ -2028,7 +2103,7 @@ void client_set_desktop(Client *self, guint target, gboolean donthide)
         client_showhide(self);
     /* raise if it was not already on the desktop */
     if (old != DESKTOP_ALL)
-        stacking_raise(self);
+        stacking_raise(CLIENT_AS_WINDOW(self));
     screen_update_struts();
 
     /* add to the new desktop(s) */
@@ -2203,7 +2278,7 @@ void client_set_state(Client *self, Atom action, long data1, long data2)
     if (shaded != self->shaded)
        client_shade(self, shaded);
     client_calc_layer(self);
-    client_change_state(self); /* change the hint to relect these changes */
+    client_change_state(self); /* change the hint to reflect these changes */
 }
 
 Client *client_focus_target(Client *self)
@@ -2216,18 +2291,15 @@ Client *client_focus_target(Client *self)
     return self;
 }
 
-gboolean client_focus(Client *self)
+gboolean client_can_focus(Client *self)
 {
     XEvent ev;
 
     /* choose the correct target */
     self = client_focus_target(self);
 
-    if (self->desktop != DESKTOP_ALL && self->desktop != screen_desktop) {
-        /* update the focus lists */
-        focus_order_to_top(self);
+    if (!self->frame->visible)
         return FALSE;
-    }
 
     if (!((self->can_focus || self->focus_notify) &&
           (self->desktop == screen_desktop ||
@@ -2253,6 +2325,22 @@ gboolean client_focus(Client *self)
        }
     }
 
+    return TRUE;
+}
+
+gboolean client_focus(Client *self)
+{
+    /* choose the correct target */
+    self = client_focus_target(self);
+
+    if (!client_can_focus(self)) {
+        if (!self->frame->visible) {
+            /* update the focus lists */
+            focus_order_to_top(self);
+        }
+        return FALSE;
+    }
+
     if (self->can_focus)
         /* RevertToPointerRoot causes much more headache than RevertToNone, so
            I choose to use it always, hopefully to find errors quicker, if any
@@ -2310,7 +2398,7 @@ void client_activate(Client *self)
     if (self->shaded)
         client_shade(self, FALSE);
     client_focus(self);
-    stacking_raise(self);
+    stacking_raise(CLIENT_AS_WINDOW(self));
 }
 
 gboolean client_focused(Client *self)
@@ -2342,3 +2430,113 @@ Icon *client_icon(Client *self, int w, int h)
         return &self->icons[si];
     return &self->icons[li];
 }
+
+/* this be mostly ripped from fvwm */
+Client *client_find_directional(Client *c, Direction dir) 
+{
+    int my_cx, my_cy, his_cx, his_cy;
+    int offset = 0;
+    int distance = 0;
+    int score, best_score;
+    Client *best_client, *cur;
+    GList *it;
+
+    if(!client_list)
+        return NULL;
+
+    /* first, find the centre coords of the currently focused window */
+    my_cx = c->frame->area.x + c->frame->area.width / 2;
+    my_cy = c->frame->area.y + c->frame->area.height / 2;
+
+    best_score = -1;
+    best_client = NULL;
+
+    for(it = g_list_first(client_list); it; it = it->next) {
+        cur = it->data;
+
+        /* the currently selected window isn't interesting */
+        if(cur == c)
+            continue;
+        if (!client_normal(cur))
+            continue;
+        if(c->desktop != cur->desktop && cur->desktop != DESKTOP_ALL)
+            continue;
+        if(cur->iconic)
+            continue;
+       if(client_focus_target(cur) == cur &&
+           !(cur->can_focus || cur->focus_notify))
+            continue;
+
+        /* find the centre coords of this window, from the
+         * currently focused window's point of view */
+        his_cx = (cur->frame->area.x - my_cx)
+            + cur->frame->area.width / 2;
+        his_cy = (cur->frame->area.y - my_cy)
+            + cur->frame->area.height / 2;
+
+        if(dir > 3) { 
+            int tx;
+            /* Rotate the diagonals 45 degrees counterclockwise.
+             * To do this, multiply the matrix /+h +h\ with the
+             * vector (x y).                   \-h +h/
+             * h = sqrt(0.5). We can set h := 1 since absolute
+             * distance doesn't matter here. */
+            tx = his_cx + his_cy;
+            his_cy = -his_cx + his_cy;
+            his_cx = tx;
+        }
+
+        switch(dir) {
+        case Direction_North :
+        case Direction_South :
+        case Direction_NorthEast :
+        case Direction_SouthWest :
+            offset = (his_cx < 0) ? -his_cx : his_cx;
+            distance = (dir == Direction_North || dir == Direction_NorthEast) ?
+                -his_cy : his_cy;
+            break;
+        case Direction_East :
+        case Direction_West :
+        case Direction_SouthEast :
+        case Direction_NorthWest :
+            offset = (his_cy < 0) ? -his_cy : his_cy;
+            distance = (dir == Direction_West || dir == Direction_NorthWest) ?
+                -his_cx : his_cx;
+            break;
+        }
+
+        /* the target must be in the requested direction */
+        if(distance <= 0)
+            continue;
+
+        /* Calculate score for this window.  The smaller the better. */
+        score = distance + offset;
+
+        /* windows more than 45 degrees off the direction are
+         * heavily penalized and will only be chosen if nothing
+         * else within a million pixels */
+        if(offset > distance)
+            score += 1000000;
+
+        if(best_score == -1 || score < best_score)
+            best_client = cur,
+                best_score = score;
+    }
+
+    return best_client;
+}
+
+void client_set_layer(Client *self, int layer)
+{
+    if (layer < 0) {
+        self->below = TRUE;
+        self->above = FALSE;
+    } else if (layer == 0) {
+        self->below = self->above = FALSE;
+    } else {
+        self->below = FALSE;
+        self->above = TRUE;
+    }
+    client_calc_layer(self);
+    client_change_state(self); /* reflect this in the state hints */
+}
This page took 0.048236 seconds and 4 git commands to generate.