]> Dogcows Code - chaz/openbox/blobdiff - openbox/screen.c
check for damage and render extensions if going to use composite. require them for...
[chaz/openbox] / openbox / screen.c
index 9cfc1850250455c33f928d52224196d888f06792..1ef080752dbfdb50a885b10e27f83d7b3a39a23a 100644 (file)
@@ -65,8 +65,13 @@ gchar  **screen_desktop_names;
 Window   screen_support_win;
 Time     screen_desktop_user_time = CurrentTime;
 
-static Rect  **area; /* array of desktop holding array of xinerama areas */
-static Rect  *monitor_area;
+/*! An array of desktops, holding array of areas per monitor */
+static Rect  *monitor_area = NULL;
+/*! An array of desktops, holding an array of struts */
+static GSList *struts_top = NULL;
+static GSList *struts_left = NULL;
+static GSList *struts_right = NULL;
+static GSList *struts_bottom = NULL;
 
 static ObPagerPopup *desktop_cycle_popup;
 
@@ -359,6 +364,15 @@ void screen_startup(gboolean reconfig)
         return;
     }
 
+#ifdef USE_XCOMPOSITE
+    if (extensions_comp) {
+        /* Redirect window contents to offscreen pixmaps */
+        XCompositeRedirectSubwindows(ob_display,
+                                     RootWindow(ob_display, ob_screen),
+                                     CompositeRedirectAutomatic);
+    }
+#endif
+
     /* get the initial size */
     screen_resize();
 
@@ -436,8 +450,6 @@ void screen_startup(gboolean reconfig)
 
 void screen_shutdown(gboolean reconfig)
 {
-    Rect **r;
-
     pager_popup_free(desktop_cycle_popup);
 
     if (reconfig)
@@ -457,11 +469,6 @@ void screen_shutdown(gboolean reconfig)
 
     g_strfreev(screen_desktop_names);
     screen_desktop_names = NULL;
-
-    for (r = area; *r; ++r)
-        g_free(*r);
-    g_free(area);
-    area = NULL;
 }
 
 void screen_resize()
@@ -498,7 +505,7 @@ void screen_set_num_desktops(guint num)
 {
     guint old;
     gulong *viewport;
-    GList *it;
+    GList *it, *stacking_copy;
 
     g_assert(num > 0);
 
@@ -518,11 +525,21 @@ void screen_set_num_desktops(guint num)
     /* the number of rows/columns will differ */
     screen_update_layout();
 
-    /* move windows on desktops that will no longer exist! */
-    for (it = client_list; it; it = g_list_next(it)) {
-        ObClient *c = it->data;
-        if (c->desktop >= num && c->desktop != DESKTOP_ALL)
-            client_set_desktop(c, num - 1, FALSE);
+    /* move windows on desktops that will no longer exist!
+       make a copy of the list cuz we're changing it */
+    stacking_copy = g_list_copy(stacking_list);
+    for (it = g_list_last(stacking_copy); it; it = g_list_previous(it)) {
+        if (WINDOW_IS_CLIENT(it->data)) {
+            ObClient *c = it->data;
+            if (c->desktop != DESKTOP_ALL && c->desktop >= num)
+                client_set_desktop(c, num - 1, FALSE, TRUE);
+            /* raise all the windows that are on the current desktop which
+               is being merged */
+            else if (screen_desktop == num - 1 &&
+                     (c->desktop == DESKTOP_ALL ||
+                      c->desktop == screen_desktop))
+                stacking_raise(WINDOW_AS_CLIENT(c));
+        }
     }
  
     /* change our struts/area to match (after moving windows) */
@@ -543,6 +560,7 @@ void screen_set_desktop(guint num, gboolean dofocus)
     GList *it;
     guint old;
     gulong ignore_start;
+    gboolean allow_omni;
      
     g_assert(num < screen_num_desktops);
 
@@ -562,7 +580,7 @@ void screen_set_desktop(guint num, gboolean dofocus)
     ignore_start = event_start_ignore_all_enters();
 
     if (moveresize_client)
-        client_set_desktop(moveresize_client, num, TRUE);
+        client_set_desktop(moveresize_client, num, TRUE, FALSE);
 
     /* show windows before hiding the rest to lessen the enter/leave events */
 
@@ -574,9 +592,15 @@ void screen_set_desktop(guint num, gboolean dofocus)
         }
     }
 
-    if (focus_client && ((client_normal(focus_client) &&
-                          focus_client->desktop == DESKTOP_ALL) ||
-                         focus_client->desktop == screen_desktop))
+    /* only allow omnipresent windows to get focus on desktop change if
+       an omnipresent window is already focused (it'll keep focus probably, but
+       maybe not depending on mouse-focus options) */
+    allow_omni = focus_client && (client_normal(focus_client) &&
+                                  focus_client->desktop == DESKTOP_ALL);
+
+    /* the client moved there already so don't move focus. prevent flicker
+       on sendtodesktop + follow */
+    if (focus_client && focus_client->desktop == screen_desktop)
         dofocus = FALSE;
 
     /* have to try focus here because when you leave an empty desktop
@@ -587,7 +611,7 @@ void screen_set_desktop(guint num, gboolean dofocus)
        do this before hiding the windows so if helper windows are coming
        with us, they don't get hidden
     */
-    if (dofocus && (c = focus_fallback(TRUE, !config_focus_last, FALSE)))
+    if (dofocus && (c = focus_fallback(TRUE, !config_focus_last, allow_omni)))
     {
         /* only do the flicker reducing stuff ahead of time if we are going
            to call xsetinputfocus on the window ourselves. otherwise there is
@@ -731,7 +755,7 @@ void screen_desktop_popup(guint d, gboolean show)
     if (!show) {
         pager_popup_hide(desktop_cycle_popup);
     } else {
-        a = screen_physical_area_monitor(0);
+        a = screen_physical_area_active();
         pager_popup_position(desktop_cycle_popup, CenterGravity,
                              a->x + a->width / 2, a->y + a->height / 2);
         pager_popup_icon_size_multiplier(desktop_cycle_popup,
@@ -1084,249 +1108,294 @@ void screen_install_colormap(ObClient *client, gboolean install)
     }
 }
 
-static inline void
-screen_area_add_strut_left(const StrutPartial *s, const Rect *monitor_area,
-                           gint edge, Strut *ret)
-{
-    if (s->left &&
-        ((s->left_end <= s->left_start) ||
-         (RECT_TOP(*monitor_area) < s->left_end &&
-          RECT_BOTTOM(*monitor_area) > s->left_start)))
-        ret->left = MAX(ret->left, edge);
-}
-
-static inline void
-screen_area_add_strut_top(const StrutPartial *s, const Rect *monitor_area,
-                          gint edge, Strut *ret)
-{
-    if (s->top &&
-        ((s->top_end <= s->top_start) ||
-         (RECT_LEFT(*monitor_area) < s->top_end &&
-          RECT_RIGHT(*monitor_area) > s->top_start)))
-        ret->top = MAX(ret->top, edge);
-}
-
-static inline void
-screen_area_add_strut_right(const StrutPartial *s, const Rect *monitor_area,
-                            gint edge, Strut *ret)
-{
-    if (s->right &&
-        ((s->right_end <= s->right_start) ||
-         (RECT_TOP(*monitor_area) < s->right_end &&
-          RECT_BOTTOM(*monitor_area) > s->right_start)))
-        ret->right = MAX(ret->right, edge);
-}
-
-static inline void
-screen_area_add_strut_bottom(const StrutPartial *s, const Rect *monitor_area,
-                             gint edge, Strut *ret)
-{
-    if (s->bottom &&
-        ((s->bottom_end <= s->bottom_start) ||
-         (RECT_LEFT(*monitor_area) < s->bottom_end &&
-          RECT_RIGHT(*monitor_area) > s->bottom_start)))
-        ret->bottom = MAX(ret->bottom, edge);
+#define STRUT_LEFT_ON_MONITOR(s, i) \
+    (RANGES_INTERSECT(s->left_start, s->left_end - s->left_start + 1, \
+                      monitor_area[i].y, monitor_area[i].height))
+#define STRUT_RIGHT_ON_MONITOR(s, i) \
+    (RANGES_INTERSECT(s->right_start, s->right_end - s->right_start + 1, \
+                      monitor_area[i].y, monitor_area[i].height))
+#define STRUT_TOP_ON_MONITOR(s, i) \
+    (RANGES_INTERSECT(s->top_start, s->top_end - s->top_start + 1, \
+                      monitor_area[i].x, monitor_area[i].width))
+#define STRUT_BOTTOM_ON_MONITOR(s, i) \
+    (RANGES_INTERSECT(s->bottom_start, s->bottom_end - s->bottom_start + 1, \
+                      monitor_area[i].x, monitor_area[i].width))
+
+typedef struct {
+    guint desktop;
+    StrutPartial *strut;
+} ObScreenStrut;
+
+#define RESET_STRUT_LIST(sl) \
+    (g_slist_free(sl), sl = NULL)
+
+#define ADD_STRUT_TO_LIST(sl, d, s) \
+{ \
+    ObScreenStrut *ss = g_new(ObScreenStrut, 1); \
+    ss->desktop = d; \
+    ss->strut = s;  \
+    sl = g_slist_prepend(sl, ss); \
 }
 
 void screen_update_areas()
 {
-    guint i, x;
+    guint i, j;
     gulong *dims;
     GList *it;
-    gint o;
+    GSList *sit;
+
+    ob_debug("updating screen areas\n");
 
     g_free(monitor_area);
     extensions_xinerama_screens(&monitor_area, &screen_num_monitors);
 
-    if (area) {
-        for (i = 0; area[i]; ++i)
-            g_free(area[i]);
-        g_free(area);
-    }
-
-    area = g_new(Rect*, screen_num_desktops + 2);
-    for (i = 0; i < screen_num_desktops + 1; ++i)
-        area[i] = g_new0(Rect, screen_num_monitors + 1);
-    area[i] = NULL;
-     
-    dims = g_new(gulong, 4 * screen_num_desktops);
-
-    for (i = 0; i < screen_num_desktops + 1; ++i) {
-        Strut *struts;
-        gint l, r, t, b;
+    dims = g_new(gulong, 4 * screen_num_desktops * screen_num_monitors);
 
-        struts = g_new0(Strut, screen_num_monitors);
-
-        /* calc the xinerama areas */
-        for (x = 0; x < screen_num_monitors; ++x) {
-            area[i][x] = monitor_area[x];
-            if (x == 0) {
-                l = monitor_area[x].x;
-                t = monitor_area[x].y;
-                r = monitor_area[x].x + monitor_area[x].width - 1;
-                b = monitor_area[x].y + monitor_area[x].height - 1;
-            } else {
-                l = MIN(l, monitor_area[x].x);
-                t = MIN(t, monitor_area[x].y);
-                r = MAX(r, monitor_area[x].x + monitor_area[x].width - 1);
-                b = MAX(b, monitor_area[x].y + monitor_area[x].height - 1);
-            }
-        }
-        RECT_SET(area[i][x], l, t, r - l + 1, b - t + 1);
-
-        /* apply the struts */
-
-        /* find the left-most xin heads, i do this in 2 loops :| */
-        o = area[i][0].x;
-        for (x = 1; x < screen_num_monitors; ++x)
-            o = MIN(o, area[i][x].x);
-
-        for (x = 0; x < screen_num_monitors; ++x) {
-            for (it = client_list; it; it = g_list_next(it)) {
-                ObClient *c = it->data;
-                screen_area_add_strut_left(&c->strut,
-                                           &monitor_area[x],
-                                           o + c->strut.left - area[i][x].x,
-                                           &struts[x]);
-            }
-            screen_area_add_strut_left(&dock_strut,
-                                       &monitor_area[x],
-                                       o + dock_strut.left - area[i][x].x,
-                                       &struts[x]);
+    RESET_STRUT_LIST(struts_left);
+    RESET_STRUT_LIST(struts_top);
+    RESET_STRUT_LIST(struts_right);
+    RESET_STRUT_LIST(struts_bottom);
 
-            area[i][x].x += struts[x].left;
-            area[i][x].width -= struts[x].left;
+    /* collect the struts */
+    for (it = client_list; it; it = g_list_next(it)) {
+        ObClient *c = it->data;
+        if (c->strut.left)
+            ADD_STRUT_TO_LIST(struts_left, c->desktop, &c->strut);
+        if (c->strut.top)
+            ADD_STRUT_TO_LIST(struts_top, c->desktop, &c->strut);
+        if (c->strut.right)
+            ADD_STRUT_TO_LIST(struts_right, c->desktop, &c->strut);
+        if (c->strut.bottom)
+            ADD_STRUT_TO_LIST(struts_bottom, c->desktop, &c->strut);
+    }
+    if (dock_strut.left)
+        ADD_STRUT_TO_LIST(struts_left, DESKTOP_ALL, &dock_strut);
+    if (dock_strut.top)
+        ADD_STRUT_TO_LIST(struts_top, DESKTOP_ALL, &dock_strut);
+    if (dock_strut.right)
+        ADD_STRUT_TO_LIST(struts_right, DESKTOP_ALL, &dock_strut);
+    if (dock_strut.bottom)
+        ADD_STRUT_TO_LIST(struts_bottom, DESKTOP_ALL, &dock_strut);
+
+    /* set up the work areas to be full screen */
+    for (i = 0; i < screen_num_monitors; ++i)
+        for (j = 0; j < screen_num_desktops; ++j) {
+            dims[(i * screen_num_desktops + j) * 4+0] = monitor_area[i].x;
+            dims[(i * screen_num_desktops + j) * 4+1] = monitor_area[i].y;
+            dims[(i * screen_num_desktops + j) * 4+2] = monitor_area[i].width;
+            dims[(i * screen_num_desktops + j) * 4+3] = monitor_area[i].height;
         }
 
-        /* find the top-most xin heads, i do this in 2 loops :| */
-        o = area[i][0].y;
-        for (x = 1; x < screen_num_monitors; ++x)
-            o = MIN(o, area[i][x].y);
-
-        for (x = 0; x < screen_num_monitors; ++x) {
-            for (it = client_list; it; it = g_list_next(it)) {
-                ObClient *c = it->data;
-                screen_area_add_strut_top(&c->strut,
-                                           &monitor_area[x],
-                                           o + c->strut.top - area[i][x].y,
-                                           &struts[x]);
-            }
-            screen_area_add_strut_top(&dock_strut,
-                                      &monitor_area[x],
-                                      o + dock_strut.top - area[i][x].y,
-                                      &struts[x]);
+    /* calculate the work areas from the struts */
+    for (i = 0; i < screen_num_monitors; ++i)
+        for (j = 0; j < screen_num_desktops; ++j) {
+            gint l = 0, r = 0, t = 0, b = 0;
 
-            area[i][x].y += struts[x].top;
-            area[i][x].height -= struts[x].top;
-        }
+            /* only add the strut to the area if it touches the monitor */
 
-        /* find the right-most xin heads, i do this in 2 loops :| */
-        o = area[i][0].x + area[i][0].width - 1;
-        for (x = 1; x < screen_num_monitors; ++x)
-            o = MAX(o, area[i][x].x + area[i][x].width - 1);
-
-        for (x = 0; x < screen_num_monitors; ++x) {
-            for (it = client_list; it; it = g_list_next(it)) {
-                ObClient *c = it->data;
-                screen_area_add_strut_right(&c->strut,
-                                           &monitor_area[x],
-                                           (area[i][x].x +
-                                            area[i][x].width - 1) -
-                                            (o - c->strut.right),
-                                            &struts[x]);
+            for (sit = struts_left; sit; sit = g_slist_next(sit)) {
+                ObScreenStrut *s = sit->data;
+                if ((s->desktop == j || s->desktop == DESKTOP_ALL) &&
+                    STRUT_LEFT_ON_MONITOR(s->strut, i))
+                    l = MAX(l, s->strut->left);
             }
-            screen_area_add_strut_right(&dock_strut,
-                                        &monitor_area[x],
-                                        (area[i][x].x +
-                                         area[i][x].width - 1) -
-                                        (o - dock_strut.right),
-                                        &struts[x]);
-
-            area[i][x].width -= struts[x].right;
-        }
-
-        /* find the bottom-most xin heads, i do this in 2 loops :| */
-        o = area[i][0].y + area[i][0].height - 1;
-        for (x = 1; x < screen_num_monitors; ++x)
-            o = MAX(o, area[i][x].y + area[i][x].height - 1);
-
-        for (x = 0; x < screen_num_monitors; ++x) {
-            for (it = client_list; it; it = g_list_next(it)) {
-                ObClient *c = it->data;
-                screen_area_add_strut_bottom(&c->strut,
-                                             &monitor_area[x],
-                                             (area[i][x].y +
-                                              area[i][x].height - 1) - \
-                                             (o - c->strut.bottom),
-                                             &struts[x]);
+            for (sit = struts_top; sit; sit = g_slist_next(sit)) {
+                ObScreenStrut *s = sit->data;
+                if ((s->desktop == j || s->desktop == DESKTOP_ALL) &&
+                    STRUT_TOP_ON_MONITOR(s->strut, i))
+                    t = MAX(t, s->strut->top);
+            }
+            for (sit = struts_right; sit; sit = g_slist_next(sit)) {
+                ObScreenStrut *s = sit->data;
+                if ((s->desktop == j || s->desktop == DESKTOP_ALL) &&
+                    STRUT_RIGHT_ON_MONITOR(s->strut, i))
+                    r = MAX(r, s->strut->right);
+            }
+            for (sit = struts_bottom; sit; sit = g_slist_next(sit)) {
+                ObScreenStrut *s = sit->data;
+                if ((s->desktop == j || s->desktop == DESKTOP_ALL) &&
+                    STRUT_BOTTOM_ON_MONITOR(s->strut, i))
+                    b = MAX(b, s->strut->bottom);
             }
-            screen_area_add_strut_bottom(&dock_strut,
-                                         &monitor_area[x],
-                                         (area[i][x].y +
-                                          area[i][x].height - 1) - \
-                                         (o - dock_strut.bottom),
-                                         &struts[x]);
-
-            area[i][x].height -= struts[x].bottom;
-        }
 
-        l = RECT_LEFT(area[i][0]);
-        t = RECT_TOP(area[i][0]);
-        r = RECT_RIGHT(area[i][0]);
-        b = RECT_BOTTOM(area[i][0]);
-        for (x = 1; x < screen_num_monitors; ++x) {
-            l = MIN(l, RECT_LEFT(area[i][x]));
-            t = MIN(l, RECT_TOP(area[i][x]));
-            r = MAX(r, RECT_RIGHT(area[i][x]));
-            b = MAX(b, RECT_BOTTOM(area[i][x]));
+            /* based on these margins, set the work area for the
+               monitor/desktop */
+            dims[(i * screen_num_desktops + j) * 4 + 0] += l;
+            dims[(i * screen_num_desktops + j) * 4 + 1] += t;
+            dims[(i * screen_num_desktops + j) * 4 + 2] -= l + r;
+            dims[(i * screen_num_desktops + j) * 4 + 3] -= t + b;
         }
-        RECT_SET(area[i][screen_num_monitors], l, t,
-                 r - l + 1, b - t + 1);
-
-        /* XXX optimize when this is run? */
-
-        /* the area has changed, adjust all the maximized 
-           windows */
-        for (it = client_list; it; it = g_list_next(it)) {
-            ObClient *c = it->data; 
-            if (i < screen_num_desktops) {
-                if (c->desktop == i)
-                    client_reconfigure(c);
-            } else if (c->desktop == DESKTOP_ALL)
-                client_reconfigure(c);
-        }
-        if (i < screen_num_desktops) {
-            /* don't set these for the 'all desktops' area */
-            dims[(i * 4) + 0] = area[i][screen_num_monitors].x;
-            dims[(i * 4) + 1] = area[i][screen_num_monitors].y;
-            dims[(i * 4) + 2] = area[i][screen_num_monitors].width;
-            dims[(i * 4) + 3] = area[i][screen_num_monitors].height;
-        }
-
-        g_free(struts);
-    }
 
     PROP_SETA32(RootWindow(ob_display, ob_screen), net_workarea, cardinal,
-                dims, 4 * screen_num_desktops);
+                dims, 4 * screen_num_desktops * screen_num_monitors);
+
+    /* the area has changed, adjust all the windows if they need it */
+    for (it = client_list; it; it = g_list_next(it))
+        client_reconfigure(it->data, FALSE);
 
     g_free(dims);
 }
 
-Rect *screen_area(guint desktop)
+#if 0
+Rect* screen_area_all_monitors(guint desktop)
 {
-    return screen_area_monitor(desktop, screen_num_monitors);
+    guint i;
+    Rect *a;
+
+    a = screen_area_monitor(desktop, 0);
+
+    /* combine all the monitors together */
+    for (i = 1; i < screen_num_monitors; ++i) {
+        Rect *m = screen_area_monitor(desktop, i);
+        gint l, r, t, b;
+
+        l = MIN(RECT_LEFT(*a), RECT_LEFT(*m));
+        t = MIN(RECT_TOP(*a), RECT_TOP(*m));
+        r = MAX(RECT_RIGHT(*a), RECT_RIGHT(*m));
+        b = MAX(RECT_BOTTOM(*a), RECT_BOTTOM(*m));
+
+        RECT_SET(*a, l, t, r - l + 1, b - t + 1);
+
+        g_free(m);
+    }
+        
+    return a;
 }
+#endif
 
-Rect *screen_area_monitor(guint desktop, guint head)
+#define STRUT_LEFT_IN_SEARCH(s, search) \
+    (RANGES_INTERSECT(search->y, search->height, \
+                      s->left_start, s->left_end - s->left_start + 1))
+#define STRUT_RIGHT_IN_SEARCH(s, search) \
+    (RANGES_INTERSECT(search->y, search->height, \
+                      s->right_start, s->right_end - s->right_start + 1))
+#define STRUT_TOP_IN_SEARCH(s, search) \
+    (RANGES_INTERSECT(search->x, search->width, \
+                      s->top_start, s->top_end - s->top_start + 1))
+#define STRUT_BOTTOM_IN_SEARCH(s, search) \
+    (RANGES_INTERSECT(search->x, search->width, \
+                      s->bottom_start, s->bottom_end - s->bottom_start + 1))
+
+#define STRUT_LEFT_IGNORE(s, us, search) \
+    (head == SCREEN_AREA_ALL_MONITORS && us && \
+     RECT_LEFT(monitor_area[i]) + s->left > RECT_LEFT(*search))
+#define STRUT_RIGHT_IGNORE(s, us, search) \
+    (head == SCREEN_AREA_ALL_MONITORS && us && \
+     RECT_RIGHT(monitor_area[i]) - s->right < RECT_RIGHT(*search))
+#define STRUT_TOP_IGNORE(s, us, search) \
+    (head == SCREEN_AREA_ALL_MONITORS && us && \
+     RECT_TOP(monitor_area[i]) + s->top > RECT_TOP(*search))
+#define STRUT_BOTTOM_IGNORE(s, us, search) \
+    (head == SCREEN_AREA_ALL_MONITORS && us && \
+     RECT_BOTTOM(monitor_area[i]) - s->bottom < RECT_BOTTOM(*search))
+
+Rect* screen_area(guint desktop, guint head, Rect *search)
 {
-    if (head > screen_num_monitors)
-        return NULL;
-    if (desktop >= screen_num_desktops) {
-        if (desktop == DESKTOP_ALL)
-            return &area[screen_num_desktops][head];
-        return NULL;
+    Rect *a;
+    GSList *it;
+    gint l, r, t, b, al, ar, at, ab;
+    guint i, d;
+    gboolean us = search != NULL; /* user provided search */
+
+    g_assert(desktop < screen_num_desktops || desktop == DESKTOP_ALL);
+    g_assert(head < screen_num_monitors || head == SCREEN_AREA_ONE_MONITOR ||
+             head == SCREEN_AREA_ALL_MONITORS);
+    g_assert(!(head == SCREEN_AREA_ONE_MONITOR && search == NULL));
+
+    /* find any struts for this monitor
+       which will be affecting the search area.
+    */
+
+    /* search everything if search is null */
+    if (!search) {
+        if (head < screen_num_monitors) search = &monitor_area[head];
+        else search = &monitor_area[screen_num_monitors];
+    }
+    if (head == SCREEN_AREA_ONE_MONITOR) head = screen_find_monitor(search);
+
+    /* al is "all left" meaning the furthest left you can get, l is our
+       "working left" meaning our current strut edge which we're calculating
+    */
+
+    /* only include monitors which the search area lines up with */
+    if (RECT_INTERSECTS_RECT(monitor_area[screen_num_monitors], *search)) {
+        al = l = RECT_RIGHT(monitor_area[screen_num_monitors]);
+        at = t = RECT_BOTTOM(monitor_area[screen_num_monitors]);
+        ar = r = RECT_LEFT(monitor_area[screen_num_monitors]);
+        ab = b = RECT_TOP(monitor_area[screen_num_monitors]);
+        for (i = 0; i < screen_num_monitors; ++i) {
+            /* add the monitor if applicable */
+            if (RANGES_INTERSECT(search->x, search->width,
+                                 monitor_area[i].x, monitor_area[i].width))
+            {
+                at = t = MIN(t, RECT_TOP(monitor_area[i]));
+                ab = b = MAX(b, RECT_BOTTOM(monitor_area[i]));
+            }
+            if (RANGES_INTERSECT(search->y, search->height,
+                                 monitor_area[i].y, monitor_area[i].height))
+            {
+                al = l = MIN(l, RECT_LEFT(monitor_area[i]));
+                ar = r = MAX(r, RECT_RIGHT(monitor_area[i]));
+            }
+        }
+    } else {
+        al = l = RECT_LEFT(monitor_area[screen_num_monitors]);
+        at = t = RECT_TOP(monitor_area[screen_num_monitors]);
+        ar = r = RECT_RIGHT(monitor_area[screen_num_monitors]);
+        ab = b = RECT_BOTTOM(monitor_area[screen_num_monitors]);
     }
-    return &area[desktop][head];
+
+    for (d = 0; d < screen_num_desktops; ++d) {
+        if (d != desktop && desktop != DESKTOP_ALL) continue;
+
+        for (i = 0; i < screen_num_monitors; ++i) {
+            if (head != SCREEN_AREA_ALL_MONITORS && head != i) continue;
+
+            for (it = struts_left; it; it = g_slist_next(it)) {
+                ObScreenStrut *s = it->data;
+                if ((s->desktop == d || s->desktop == DESKTOP_ALL) &&
+                    STRUT_LEFT_IN_SEARCH(s->strut, search) &&
+                    !STRUT_LEFT_IGNORE(s->strut, us, search))
+                    l = MAX(l, al + s->strut->left);
+            }
+            for (it = struts_top; it; it = g_slist_next(it)) {
+                ObScreenStrut *s = it->data;
+                if ((s->desktop == d || s->desktop == DESKTOP_ALL) &&
+                    STRUT_TOP_IN_SEARCH(s->strut, search) &&
+                    !STRUT_TOP_IGNORE(s->strut, us, search))
+                    t = MAX(t, at + s->strut->top);
+            }
+            for (it = struts_right; it; it = g_slist_next(it)) {
+                ObScreenStrut *s = it->data;
+                if ((s->desktop == d || s->desktop == DESKTOP_ALL) &&
+                    STRUT_RIGHT_IN_SEARCH(s->strut, search) &&
+                    !STRUT_RIGHT_IGNORE(s->strut, us, search))
+                    r = MIN(r, ar - s->strut->right);
+            }
+            for (it = struts_bottom; it; it = g_slist_next(it)) {
+                ObScreenStrut *s = it->data;
+                if ((s->desktop == d || s->desktop == DESKTOP_ALL) &&
+                    STRUT_BOTTOM_IN_SEARCH(s->strut, search) &&
+                    !STRUT_BOTTOM_IGNORE(s->strut, us, search))
+                    b = MIN(b, ab - s->strut->bottom);
+            }
+
+            /* limit to this monitor */
+            if (head == i) {
+                l = MAX(l, RECT_LEFT(monitor_area[i]));
+                t = MAX(t, RECT_TOP(monitor_area[i]));
+                r = MIN(r, RECT_RIGHT(monitor_area[i]));
+                b = MIN(b, RECT_BOTTOM(monitor_area[i]));
+            }
+        }
+    }
+
+    a = g_new(Rect, 1);
+    a->x = l;
+    a->y = t;
+    a->width = r - l + 1;
+    a->height = b - t + 1;
+    return a;
 }
 
 guint screen_find_monitor(Rect *search)
@@ -1349,20 +1418,49 @@ guint screen_find_monitor(Rect *search)
                 most = i;
             }
         }
+        g_free(area);
     }
     return most;
 }
 
-Rect *screen_physical_area()
+Rect* screen_physical_area_all_monitors()
 {
     return screen_physical_area_monitor(screen_num_monitors);
 }
 
-Rect *screen_physical_area_monitor(guint head)
+Rectscreen_physical_area_monitor(guint head)
 {
-    if (head > screen_num_monitors)
-        return NULL;
-    return &monitor_area[head];
+    Rect *a;
+    g_assert(head <= screen_num_monitors);
+
+    a = g_new(Rect, 1);
+    *a = monitor_area[head];
+    return a;
+}
+
+gboolean screen_physical_area_monitor_contains(guint head, Rect *search)
+{
+    g_assert(head <= screen_num_monitors);
+    g_assert(search);
+    return RECT_INTERSECTS_RECT(monitor_area[head], *search);
+}
+
+Rect* screen_physical_area_active()
+{
+    Rect *a;
+    gint x, y;
+
+    if (focus_client)
+        a = screen_physical_area_monitor(client_monitor(focus_client));
+    else {
+        Rect mon;
+        if (screen_pointer_pos(&x, &y))
+            RECT_SET(mon, x, y, 1, 1);
+        else
+            RECT_SET(mon, 0, 0, 1, 1);
+        a = screen_physical_area_monitor(screen_find_monitor(&mon));
+    }
+    return a;
 }
 
 void screen_set_root_cursor()
This page took 0.034082 seconds and 4 git commands to generate.