X-Git-Url: https://git.dogcows.com/gitweb?a=blobdiff_plain;f=openbox%2Fscreen.c;h=3962fd2a746b0e183c1ac94595a0a361b9e2cfdd;hb=44bc0dab886c924b6aac1d3f1eaf4cc0164950c9;hp=7e2d8645ce3fd3602f7c1d37615f90246cbfec7e;hpb=03d1c08dfe8f0c37b269c10ec922d4cb52d130fe;p=chaz%2Fopenbox diff --git a/openbox/screen.c b/openbox/screen.c index 7e2d8645..3962fd2a 100644 --- a/openbox/screen.c +++ b/openbox/screen.c @@ -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; @@ -436,8 +441,6 @@ void screen_startup(gboolean reconfig) void screen_shutdown(gboolean reconfig) { - Rect **r; - pager_popup_free(desktop_cycle_popup); if (reconfig) @@ -457,11 +460,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() @@ -733,7 +731,7 @@ void screen_desktop_popup(guint d, gboolean show) if (!show) { pager_popup_hide(desktop_cycle_popup); } else { - a = screen_physical_area_monitor_active(); + 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, @@ -1086,249 +1084,306 @@ 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); + dims = g_new(gulong, 4 * screen_num_desktops * screen_num_monitors); + + RESET_STRUT_LIST(struts_left); + RESET_STRUT_LIST(struts_top); + RESET_STRUT_LIST(struts_right); + RESET_STRUT_LIST(struts_bottom); + + /* 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; + } - 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); + /* 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; - for (i = 0; i < screen_num_desktops + 1; ++i) { - Strut *struts; - gint l, r, t, b; + /* only add the strut to the area if it touches the monitor */ - 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); + 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); } - } - 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]); + 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); } - screen_area_add_strut_left(&dock_strut, - &monitor_area[x], - o + dock_strut.left - area[i][x].x, - &struts[x]); - - area[i][x].x += struts[x].left; - area[i][x].width -= struts[x].left; - } - - /* 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]); + 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_top(&dock_strut, - &monitor_area[x], - o + dock_strut.top - area[i][x].y, - &struts[x]); - area[i][x].y += struts[x].top; - area[i][x].height -= struts[x].top; + /* 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; } - /* 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]); - } - 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; - } + PROP_SETA32(RootWindow(ob_display, ob_screen), net_workarea, cardinal, + dims, 4 * screen_num_desktops * screen_num_monitors); - /* 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]); - } - 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; - } + /* the area has changed, adjust all the windows if they need it */ + for (it = client_list; it; it = g_list_next(it)) { + gint x, y, w, h, lw, lh; + ObClient *client = it->data; - 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])); - } - 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; - } + RECT_TO_DIMS(client->area, x, y, w, h); + client_try_configure(client, &x, &y, &w, &h, &lw, &lh, FALSE); + if (!RECT_EQUAL_DIMS(client->area, x, y, w, h)) { + gulong ignore_start; - g_free(struts); + ignore_start = event_start_ignore_all_enters(); + client_configure(client, x, y, w, h, FALSE, TRUE); + event_end_ignore_all_enters(ignore_start); + } } - PROP_SETA32(RootWindow(ob_display, ob_screen), net_workarea, cardinal, - dims, 4 * screen_num_desktops); - 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) @@ -1351,23 +1406,34 @@ 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) +Rect* screen_physical_area_monitor(guint 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) { - if (head > screen_num_monitors) - return NULL; - return &monitor_area[head]; + g_assert(head <= screen_num_monitors); + g_assert(search); + return RECT_INTERSECTS_RECT(monitor_area[head], *search); } -Rect *screen_physical_area_monitor_active() +Rect* screen_physical_area_active() { Rect *a; gint x, y;