Window screen_support_win;
Time screen_desktop_user_time = CurrentTime;
-static Rect **area; /* array of desktop holding array of xinerama areas */
+/*! An array of desktops, holding array of areas per monitor */
static Rect *monitor_area;
+/*! An array of desktops, holding an array of struts */
+static GSList **struts_top;
+static GSList **struts_left;
+static GSList **struts_right;
+static GSList **struts_bottom;
static ObPagerPopup *desktop_cycle_popup;
void screen_shutdown(gboolean reconfig)
{
- Rect **r;
-
pager_popup_free(desktop_cycle_popup);
if (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()
GList *it;
guint old;
gulong ignore_start;
+ gboolean allow_omni;
g_assert(num < screen_num_desktops);
}
}
- if (focus_client && ((client_normal(focus_client) &&
- focus_client->desktop == DESKTOP_ALL) ||
- focus_client->desktop == screen_desktop))
- dofocus = FALSE;
+ /* 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);
/* have to try focus here because when you leave an empty desktop
there is no focus out to watch for. also, we have different rules
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
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,
}
}
-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))
+
+#define RESET_STRUT_LIST(sl) \
+ {for (i = 0; sl[i]; ++i) \
+ g_slist_free(sl[i]); \
+ sl = g_renew(GSList*, sl, screen_num_desktops + 1); \
+ sl[screen_num_desktops] = NULL;} /* null terminated */
+
+#define ADD_STRUT_TO_LIST(sl, d, s) \
+ {for (i = 0; i < screen_num_desktops; ++i) \
+ if (i == d || d == DESKTOP_ALL) \
+ sl[i] = g_slist_prepend(sl[i], s);}
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[j]; sit; sit = g_slist_next(sit)) {
+ StrutPartial *s = sit->data;
+ if (STRUT_LEFT_ON_MONITOR(s, i))
+ l = MAX(l, s->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[j]; sit; sit = g_slist_next(sit)) {
+ StrutPartial *s = sit->data;
+ if (STRUT_TOP_ON_MONITOR(s, i))
+ t = MAX(t, s->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[j]; sit; sit = g_slist_next(sit)) {
+ StrutPartial *s = sit->data;
+ if (STRUT_RIGHT_ON_MONITOR(s, i))
+ r = MAX(r, s->right);
+ }
+ for (sit = struts_bottom[j]; sit; sit = g_slist_next(sit)) {
+ StrutPartial *s = sit->data;
+ if (STRUT_BOTTOM_ON_MONITOR(s, i))
+ b = MAX(b, s->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) {
+ if (RANGES_INTERSECT(search->x, search->width,
+ monitor_area[i].x, monitor_area[i].width) ||
+ RANGES_INTERSECT(search->y, search->height,
+ monitor_area[i].y, monitor_area[i].height))
+ {
+ /* add the monitor */
+ al = l = MIN(l, RECT_LEFT(monitor_area[i]));
+ at = t = MIN(t, RECT_TOP(monitor_area[i]));
+ ar = r = MAX(r, RECT_RIGHT(monitor_area[i]));
+ ab = b = MAX(b, RECT_BOTTOM(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]);
+ }
+
+ 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[d]; it; it = g_slist_next(it)) {
+ StrutPartial *s = it->data;
+ if (STRUT_LEFT_IN_SEARCH(s, search) &&
+ !STRUT_LEFT_IGNORE(s, us, search))
+ l = MAX(l, al + s->left);
+ }
+ for (it = struts_top[d]; it; it = g_slist_next(it)) {
+ StrutPartial *s = it->data;
+ if (STRUT_TOP_IN_SEARCH(s, search) &&
+ !STRUT_TOP_IGNORE(s, us, search))
+ t = MAX(t, al + s->top);
+ }
+ for (it = struts_right[d]; it; it = g_slist_next(it)) {
+ StrutPartial *s = it->data;
+ if (STRUT_RIGHT_IN_SEARCH(s, search) &&
+ !STRUT_RIGHT_IGNORE(s, us, search))
+ r = MIN(r, ar - s->right);
+ }
+ for (it = struts_bottom[d]; it; it = g_slist_next(it)) {
+ StrutPartial *s = it->data;
+ if (STRUT_BOTTOM_IN_SEARCH(s, search) &&
+ !STRUT_BOTTOM_IGNORE(s, us, search))
+ r = MIN(r, ar - s->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]));
+ }
+ }
}
- return &area[desktop][head];
+
+ 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)
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)
{
- 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()
projects / chaz / openbox / blobdiff