static gboolean screen_validate_layout(ObDesktopLayout *l);
static gboolean replace_wm();
+static void screen_tell_ksplash();
guint screen_num_desktops;
guint screen_num_monitors;
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;
+static GSList *struts_top;
+static GSList *struts_left;
+static GSList *struts_right;
+static GSList *struts_bottom;
static ObPagerPopup *desktop_cycle_popup;
supported[i++] = prop_atoms.ob_wm_action_undecorate;
supported[i++] = prop_atoms.ob_wm_state_undecorated;
supported[i++] = prop_atoms.openbox_pid;
- supported[i++] = prop_atoms.ob_config;
+ supported[i++] = prop_atoms.ob_theme;
supported[i++] = prop_atoms.ob_control;
g_assert(i == num_support);
net_supported, atom, supported, num_support);
g_free(supported);
+ screen_tell_ksplash();
+
return TRUE;
}
+static void screen_tell_ksplash()
+{
+ XEvent e;
+ char **argv;
+
+ argv = g_new(gchar*, 6);
+ argv[0] = g_strdup("dcop");
+ argv[1] = g_strdup("ksplash");
+ argv[2] = g_strdup("ksplash");
+ argv[3] = g_strdup("upAndRunning(QString)");
+ argv[4] = g_strdup("wm started");
+ argv[5] = NULL;
+
+ /* tell ksplash through the dcop server command line interface */
+ g_spawn_async(NULL, argv, NULL,
+ G_SPAWN_SEARCH_PATH | G_SPAWN_DO_NOT_REAP_CHILD |
+ G_SPAWN_STDERR_TO_DEV_NULL | G_SPAWN_STDOUT_TO_DEV_NULL,
+ NULL, NULL, NULL, NULL);
+ g_strfreev(argv);
+
+ /* i'm not sure why we do this, kwin does it, but ksplash doesn't seem to
+ hear it anyways. perhaps it is for old ksplash. or new ksplash. or
+ something. oh well. */
+ e.xclient.type = ClientMessage;
+ e.xclient.display = ob_display;
+ e.xclient.window = RootWindow(ob_display, ob_screen);
+ e.xclient.message_type =
+ XInternAtom(ob_display, "_KDE_SPLASH_PROGRESS", False );
+ e.xclient.format = 8;
+ strcpy(e.xclient.data.b, "wm started");
+ XSendEvent(ob_display, RootWindow(ob_display, ob_screen),
+ False, SubstructureNotifyMask, &e );
+}
+
void screen_startup(gboolean reconfig)
{
gchar **names = NULL;
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()
ObClient *c;
GList *it;
guint old;
+ gulong ignore_start;
+ gboolean allow_omni;
g_assert(num < screen_num_desktops);
ob_debug("Moving to desktop %d\n", num+1);
+ /* ignore enter events caused by the move */
+ ignore_start = event_start_ignore_all_enters();
+
if (moveresize_client)
client_set_desktop(moveresize_client, num, TRUE);
}
}
- 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
+ there is no focus out to watch for. also, we have different rules
+ here. we always allow it to look under the mouse pointer if
+ config_focus_last is FALSE
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)))
+ 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
}
}
- event_ignore_all_queued_enters();
+ event_end_ignore_all_enters(ignore_start);
if (event_curtime != CurrentTime)
screen_desktop_user_time = event_curtime;
if (!show) {
pager_popup_hide(desktop_cycle_popup);
} else {
- a = screen_physical_area_monitor(0);
+ a = screen_physical_area_monitor_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,
else if (!show_only) {
ObClient *c;
- if ((c = focus_fallback(TRUE))) {
+ if ((c = focus_fallback(TRUE, FALSE, TRUE))) {
/* only do the flicker reducing stuff ahead of time if we are going
to call xsetinputfocus on the window ourselves. otherwise there
is no guarantee the window will actually take focus.. */
void screen_install_colormap(ObClient *client, gboolean install)
{
- if (client == NULL) {
+ if (client == NULL || client->colormap == None) {
if (install)
XInstallColormap(RrDisplay(ob_rr_inst), RrColormap(ob_rr_inst));
else
XUninstallColormap(RrDisplay(ob_rr_inst), RrColormap(ob_rr_inst));
} else {
xerror_set_ignore(TRUE);
- if (install) {
- if (client->colormap != None)
- XInstallColormap(RrDisplay(ob_rr_inst), client->colormap);
- } else
+ if (install)
+ XInstallColormap(RrDisplay(ob_rr_inst), client->colormap);
+ else
XUninstallColormap(RrDisplay(ob_rr_inst), client->colormap);
xerror_set_ignore(FALSE);
}
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);
- 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);
+ g_slist_free(struts_left); struts_left = NULL;
+ g_slist_free(struts_top); struts_top = NULL;
+ g_slist_free(struts_right); struts_right = NULL;
+ g_slist_free(struts_bottom); struts_bottom = NULL;
- for (i = 0; i < screen_num_desktops + 1; ++i) {
- Strut *struts;
- gint l, r, t, b;
+ /* collect the struts */
+ for (it = client_list; it; it = g_list_next(it)) {
+ ObClient *c = it->data;
+ if (c->strut.left)
+ struts_left = g_slist_prepend(struts_left, &c->strut);
+ if (c->strut.top)
+ struts_top = g_slist_prepend(struts_top, &c->strut);
+ if (c->strut.right)
+ struts_right = g_slist_prepend(struts_right, &c->strut);
+ if (c->strut.bottom)
+ struts_bottom = g_slist_prepend(struts_bottom, &c->strut);
+ }
- 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);
- }
+ /* 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 * j + 0] = monitor_area[i].x;
+ dims[i * j + 1] = monitor_area[i].y;
+ dims[i * j + 2] = monitor_area[i].width;
+ dims[i * j + 3] = monitor_area[i].height;
}
- 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]);
- area[i][x].x += struts[x].left;
- area[i][x].width -= struts[x].left;
- }
+ /* 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;
- /* 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]);
+ /* only add the strut to the area if it touches the monitor */
+
+ for (sit = struts_left; sit; sit = g_slist_next(sit)) {
+ StrutPartial *s = sit->data;
+ if (RANGE_INTERSECT
+ (s->left_start, s->left_end - s->left_start + 1,
+ monitor_area[i].y, monitor_area[i].height))
+ l = MAX(l, s->left);
+ }
+ for (sit = struts_top; sit; sit = g_slist_next(sit)) {
+ StrutPartial *s = sit->data;
+ if (RANGE_INTERSECT
+ (s->top_start, s->top_end - s->top_start + 1,
+ monitor_area[i].x, monitor_area[i].width))
+ t = MAX(t, s->top);
+ }
+ for (sit = struts_right; sit; sit = g_slist_next(sit)) {
+ StrutPartial *s = sit->data;
+ if (RANGE_INTERSECT
+ (s->right_start, s->right_end - s->right_start + 1,
+ monitor_area[i].y, monitor_area[i].height))
+ r = MAX(r, s->right);
+ }
+ for (sit = struts_bottom; sit; sit = g_slist_next(sit)) {
+ StrutPartial *s = sit->data;
+ if (RANGE_INTERSECT
+ (s->bottom_start, s->bottom_end - s->bottom_start + 1,
+ monitor_area[i].x, monitor_area[i].width))
+ 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 * j + 0] += l;
+ dims[i * j + 1] += t;
+ dims[i * j + 2] -= l + r;
+ dims[i * j + 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)
+Rect* screen_area(guint desktop, Rect *search)
{
- return screen_area_monitor(desktop, screen_num_monitors);
+ guint i;
+ Rect *a;
+
+ a = screen_area_monitor(desktop, 0, search);
+
+ /* combine all the monitors together */
+ for (i = 0; i < screen_num_monitors; ++i) {
+ Rect *m = screen_area_monitor(desktop, i, search);
+ 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;
}
-Rect *screen_area_monitor(guint desktop, guint head)
+Rect* screen_area_monitor(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;
+
+ g_assert(head < screen_num_monitors);
+
+ /* get the base area for the monitor */
+ a = g_new(Rect, 1);
+ *a = monitor_area[head];
+
+ /* remove any struts which will be affecting the search area */
+ l = t = r = b = 0;
+ for (it = struts_left; it; it = g_slist_next(it)) {
+ StrutPartial *s = it->data;
+ if (!search ||
+ RANGE_INTERSECT(search->y, search->height,
+ s->left_start, s->left_end - s->left_start + 1))
+ l = MAX(l, s->left);
}
- return &area[desktop][head];
+ for (it = struts_right; it; it = g_slist_next(it)) {
+ StrutPartial *s = it->data;
+ if (!search == 0 ||
+ RANGE_INTERSECT(search->y, search->height,
+ s->right_start, s->right_end - s->right_start + 1))
+ r = MAX(r, s->right);
+ }
+ for (it = struts_top; it; it = g_slist_next(it)) {
+ StrutPartial *s = it->data;
+ if (!search == 0 ||
+ RANGE_INTERSECT(search->x, search->width,
+ s->top_start, s->top_end - s->top_start + 1))
+ t = MAX(t, s->top);
+ }
+ for (it = struts_bottom; it; it = g_slist_next(it)) {
+ StrutPartial *s = it->data;
+ if (search->width == 0 ||
+ RANGE_INTERSECT(search->x, search->width,
+ s->bottom_start,
+ s->bottom_end - s->bottom_start + 1))
+ b = MAX(b, s->bottom);
+ }
+
+ a->x += l;
+ a->y += t;
+ a->width -= l + r;
+ a->height -= t + b;
+ return a;
}
guint screen_find_monitor(Rect *search)
most = i;
}
}
+ g_free(area);
}
return most;
}
-Rect *screen_physical_area()
+Rect* screen_physical_area()
{
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;
+}
+
+Rect* screen_physical_area_monitor_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