/* -*- indent-tabs-mode: nil; tab-width: 4; c-basic-offset: 4; -*-
screen.c for the Openbox window manager
- Copyright (c) 2003 Ben Jansens
+ Copyright (c) 2006 Mikael Magnusson
+ Copyright (c) 2003-2007 Dana Jansens
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
#include "config.h"
#include "screen.h"
#include "client.h"
+#include "session.h"
#include "frame.h"
#include "event.h"
#include "focus.h"
#include "popup.h"
#include "extensions.h"
#include "render/render.h"
+#include "gettext.h"
#include <X11/Xlib.h>
#ifdef HAVE_UNISTD_H
/*! The event mask to grab on the root window */
#define ROOT_EVENTMASK (StructureNotifyMask | PropertyChangeMask | \
- EnterWindowMask | LeaveWindowMask | \
- SubstructureNotifyMask | SubstructureRedirectMask | \
- ButtonPressMask | ButtonReleaseMask | ButtonMotionMask)
+ EnterWindowMask | LeaveWindowMask | \
+ SubstructureRedirectMask | FocusChangeMask | \
+ ButtonPressMask | ButtonReleaseMask | ButtonMotionMask)
+
+static gboolean screen_validate_layout(ObDesktopLayout *l);
+static gboolean replace_wm();
+static void screen_tell_ksplash();
guint screen_num_desktops;
guint screen_num_monitors;
guint screen_last_desktop;
Size screen_physical_size;
gboolean screen_showing_desktop;
-DesktopLayout screen_desktop_layout;
-char **screen_desktop_names;
+ObDesktopLayout screen_desktop_layout;
+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;
static gboolean replace_wm()
{
- char *wm_sn;
+ gchar *wm_sn;
Atom wm_sn_atom;
Window current_wm_sn_owner;
Time timestamp;
g_free(wm_sn);
current_wm_sn_owner = XGetSelectionOwner(ob_display, wm_sn_atom);
+ if (current_wm_sn_owner == screen_support_win)
+ current_wm_sn_owner = None;
if (current_wm_sn_owner) {
if (!ob_replace_wm) {
- g_warning("A window manager is already running on screen %d",
+ g_message(_("A window manager is already running on screen %d"),
ob_screen);
return FALSE;
}
timestamp);
if (XGetSelectionOwner(ob_display, wm_sn_atom) != screen_support_win) {
- g_warning("Could not acquire window manager selection on screen %d",
+ g_message(_("Could not acquire window manager selection on screen %d"),
ob_screen);
return FALSE;
}
}
if (wait >= timeout) {
- g_warning("Timeout expired while waiting for the current WM to die "
- "on screen %d", ob_screen);
+ g_message(_("The WM on screen %d is not exiting"), ob_screen);
return FALSE;
}
}
/* Send client message indicating that we are now the WM */
prop_message(RootWindow(ob_display, ob_screen), prop_atoms.manager,
- timestamp, wm_sn_atom, 0, 0, SubstructureNotifyMask);
-
+ timestamp, wm_sn_atom, screen_support_win, 0,
+ SubstructureNotifyMask);
return TRUE;
}
XSetWindowAttributes attrib;
pid_t pid;
gint i, num_support;
- guint32 *supported;
+ Atom *prop_atoms_start, *wm_supported_pos;
+ gulong *supported;
/* create the netwm support window */
attrib.override_redirect = TRUE;
CopyFromParent, InputOutput,
CopyFromParent,
CWOverrideRedirect, &attrib);
- XMapRaised(ob_display, screen_support_win);
+ XMapWindow(ob_display, screen_support_win);
+ XLowerWindow(ob_display, screen_support_win);
if (!replace_wm()) {
XDestroyWindow(ob_display, screen_support_win);
ROOT_EVENTMASK);
xerror_set_ignore(FALSE);
if (xerror_occured) {
- g_warning("A window manager is already running on screen %d",
+ g_message(_("A window manager is already running on screen %d"),
ob_screen);
XDestroyWindow(ob_display, screen_support_win);
- return FALSE;
+ return FALSE;
}
-
screen_set_root_cursor();
/* set the OPENBOX_PID hint */
window, screen_support_win);
/* set the _NET_SUPPORTED_ATOMS hint */
- num_support = 51;
+
+ /* this is all the atoms after net_supported in the prop_atoms struct */
+ prop_atoms_start = (Atom*)&prop_atoms;
+ wm_supported_pos = (Atom*)&(prop_atoms.net_supported);
+ num_support = sizeof(prop_atoms) / sizeof(Atom) -
+ (wm_supported_pos - prop_atoms_start) - 1;
i = 0;
- supported = g_new(guint32, num_support);
+ supported = g_new(gulong, num_support);
+ supported[i++] = prop_atoms.net_supporting_wm_check;
+ supported[i++] = prop_atoms.net_wm_full_placement;
supported[i++] = prop_atoms.net_current_desktop;
supported[i++] = prop_atoms.net_number_of_desktops;
supported[i++] = prop_atoms.net_desktop_geometry;
supported[i++] = prop_atoms.net_wm_visible_icon_name;
supported[i++] = prop_atoms.net_wm_desktop;
supported[i++] = prop_atoms.net_wm_strut;
+ supported[i++] = prop_atoms.net_wm_strut_partial;
+ supported[i++] = prop_atoms.net_wm_icon;
+ supported[i++] = prop_atoms.net_wm_icon_geometry;
supported[i++] = prop_atoms.net_wm_window_type;
supported[i++] = prop_atoms.net_wm_window_type_desktop;
supported[i++] = prop_atoms.net_wm_window_type_dock;
supported[i++] = prop_atoms.net_wm_action_fullscreen;
supported[i++] = prop_atoms.net_wm_action_change_desktop;
supported[i++] = prop_atoms.net_wm_action_close;
+ supported[i++] = prop_atoms.net_wm_action_above;
+ supported[i++] = prop_atoms.net_wm_action_below;
supported[i++] = prop_atoms.net_wm_state;
supported[i++] = prop_atoms.net_wm_state_modal;
supported[i++] = prop_atoms.net_wm_state_maximized_vert;
supported[i++] = prop_atoms.net_wm_state_fullscreen;
supported[i++] = prop_atoms.net_wm_state_above;
supported[i++] = prop_atoms.net_wm_state_below;
+ supported[i++] = prop_atoms.net_wm_state_demands_attention;
supported[i++] = prop_atoms.net_moveresize_window;
supported[i++] = prop_atoms.net_wm_moveresize;
+ supported[i++] = prop_atoms.net_wm_user_time;
+ supported[i++] = prop_atoms.net_wm_user_time_window;
+ supported[i++] = prop_atoms.net_frame_extents;
+ supported[i++] = prop_atoms.net_request_frame_extents;
+ supported[i++] = prop_atoms.net_restack_window;
+ supported[i++] = prop_atoms.net_startup_id;
+#ifdef SYNC
+ supported[i++] = prop_atoms.net_wm_sync_request;
+ supported[i++] = prop_atoms.net_wm_sync_request_counter;
+#endif
+
+ supported[i++] = prop_atoms.kde_wm_change_state;
+ supported[i++] = prop_atoms.kde_net_wm_frame_strut;
+ supported[i++] = prop_atoms.kde_net_wm_window_type_override;
+
+ 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_theme;
+ supported[i++] = prop_atoms.ob_control;
g_assert(i == num_support);
-/*
- supported[] = prop_atoms.net_wm_action_stick;
-*/
PROP_SETA32(RootWindow(ob_display, ob_screen),
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)
{
- GSList *it;
- guint i;
+ gchar **names = NULL;
+ guint32 d;
+ gboolean namesexist = FALSE;
desktop_cycle_popup = pager_popup_new(FALSE);
+ pager_popup_height(desktop_cycle_popup, POPUP_HEIGHT);
+
+ if (reconfig) {
+ /* update the pager popup's width */
+ pager_popup_text_width_to_strings(desktop_cycle_popup,
+ screen_desktop_names,
+ screen_num_desktops);
+ return;
+ }
- if (!reconfig)
- /* get the initial size */
- screen_resize();
-
- /* set the names */
- screen_desktop_names = g_new(char*,
- g_slist_length(config_desktops_names) + 1);
- for (i = 0, it = config_desktops_names; it; ++i, it = it->next)
- screen_desktop_names[i] = it->data; /* dont strdup */
- screen_desktop_names[i] = NULL;
- PROP_SETSS(RootWindow(ob_display, ob_screen),
- net_desktop_names, screen_desktop_names);
- g_free(screen_desktop_names); /* dont free the individual strings */
- screen_desktop_names = NULL;
+ /* get the initial size */
+ screen_resize();
- if (!reconfig)
- screen_num_desktops = 0;
- screen_set_num_desktops(config_desktops_num);
- if (!reconfig) {
- screen_set_desktop(0);
+ /* have names already been set for the desktops? */
+ if (PROP_GETSS(RootWindow(ob_display, ob_screen),
+ net_desktop_names, utf8, &names))
+ {
+ g_strfreev(names);
+ namesexist = TRUE;
+ }
+
+ /* if names don't exist and we have session names, set those.
+ do this stuff BEFORE setting the number of desktops, because that
+ will create default names for them
+ */
+ if (!namesexist && session_desktop_names != NULL) {
+ guint i, numnames;
+ GSList *it;
+
+ /* get the desktop names */
+ numnames = g_slist_length(session_desktop_names);
+ names = g_new(gchar*, numnames + 1);
+ names[numnames] = NULL;
+ for (i = 0, it = session_desktop_names; it; ++i, it = g_slist_next(it))
+ names[i] = g_strdup(it->data);
+
+ /* set the root window property */
+ PROP_SETSS(RootWindow(ob_display, ob_screen), net_desktop_names,names);
+
+ g_strfreev(names);
+ }
- /* don't start in showing-desktop mode */
- screen_showing_desktop = FALSE;
- PROP_SET32(RootWindow(ob_display, ob_screen),
- net_showing_desktop, cardinal, screen_showing_desktop);
+ /* set the number of desktops, if it's not already set.
+
+ this will also set the default names from the config file up for
+ desktops that don't have names yet */
+ screen_num_desktops = 0;
+ if (PROP_GET32(RootWindow(ob_display, ob_screen),
+ net_number_of_desktops, cardinal, &d))
+ screen_set_num_desktops(d);
+ /* restore from session if possible */
+ else if (session_num_desktops)
+ screen_set_num_desktops(session_num_desktops);
+ else
+ screen_set_num_desktops(config_desktops_num);
- screen_update_layout();
+ screen_desktop = screen_num_desktops; /* something invalid */
+ /* start on the current desktop when a wm was already running */
+ if (PROP_GET32(RootWindow(ob_display, ob_screen),
+ net_current_desktop, cardinal, &d) &&
+ d < screen_num_desktops)
+ {
+ screen_set_desktop(d, FALSE);
+ } else if (session_desktop >= 0)
+ screen_set_desktop(MIN((guint)session_desktop,
+ screen_num_desktops), FALSE);
+ else
+ screen_set_desktop(MIN(config_screen_firstdesk,
+ screen_num_desktops) - 1, FALSE);
+ screen_last_desktop = screen_desktop;
+
+ /* don't start in showing-desktop mode */
+ screen_showing_desktop = FALSE;
+ PROP_SET32(RootWindow(ob_display, ob_screen),
+ net_showing_desktop, cardinal, screen_showing_desktop);
+
+ if (session_desktop_layout_present &&
+ screen_validate_layout(&session_desktop_layout))
+ {
+ screen_desktop_layout = session_desktop_layout;
}
+ else
+ screen_update_layout();
}
void screen_shutdown(gboolean reconfig)
pager_popup_free(desktop_cycle_popup);
- if (!reconfig) {
- XSelectInput(ob_display, RootWindow(ob_display, ob_screen),
- NoEventMask);
+ if (reconfig)
+ return;
- /* we're not running here no more! */
- PROP_ERASE(RootWindow(ob_display, ob_screen), openbox_pid);
- /* not without us */
- PROP_ERASE(RootWindow(ob_display, ob_screen), net_supported);
- /* don't keep this mode */
- PROP_ERASE(RootWindow(ob_display, ob_screen), net_showing_desktop);
+ XSelectInput(ob_display, RootWindow(ob_display, ob_screen),
+ NoEventMask);
- XDestroyWindow(ob_display, screen_support_win);
- }
+ /* we're not running here no more! */
+ PROP_ERASE(RootWindow(ob_display, ob_screen), openbox_pid);
+ /* not without us */
+ PROP_ERASE(RootWindow(ob_display, ob_screen), net_supported);
+ /* don't keep this mode */
+ PROP_ERASE(RootWindow(ob_display, ob_screen), net_showing_desktop);
+
+ XDestroyWindow(ob_display, screen_support_win);
g_strfreev(screen_desktop_names);
screen_desktop_names = NULL;
+
for (r = area; *r; ++r)
g_free(*r);
g_free(area);
void screen_resize()
{
- static int oldw = 0, oldh = 0;
- int w, h;
+ static gint oldw = 0, oldh = 0;
+ gint w, h;
GList *it;
- guint32 geometry[2];
+ gulong geometry[2];
w = WidthOfScreen(ScreenOfDisplay(ob_display, ob_screen));
h = HeightOfScreen(ScreenOfDisplay(ob_display, ob_screen));
net_desktop_geometry, cardinal, geometry, 2);
if (ob_state() == OB_STATE_STARTING)
- return;
+ return;
screen_update_areas();
dock_configure();
- for (it = client_list; it; it = it->next)
+ for (it = client_list; it; it = g_list_next(it))
client_move_onscreen(it->data, FALSE);
}
void screen_set_num_desktops(guint num)
{
- guint i, old;
- guint32 *viewport;
+ guint old;
+ gulong *viewport;
GList *it;
g_assert(num > 0);
net_number_of_desktops, cardinal, num);
/* set the viewport hint */
- viewport = g_new0(guint32, num * 2);
+ viewport = g_new0(gulong, num * 2);
PROP_SETA32(RootWindow(ob_display, ob_screen),
net_desktop_viewport, cardinal, viewport, num * 2);
g_free(viewport);
/* the number of rows/columns will differ */
screen_update_layout();
- /* may be some unnamed desktops that we need to fill in with names */
- screen_update_desktop_names();
-
/* move windows on desktops that will no longer exist! */
- for (it = client_list; it != NULL; it = it->next) {
+ 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);
/* change our struts/area to match (after moving windows) */
screen_update_areas();
+ /* may be some unnamed desktops that we need to fill in with names
+ (after updating the areas so the popup can resize) */
+ screen_update_desktop_names();
+
/* change our desktop if we're on one that no longer exists! */
if (screen_desktop >= screen_num_desktops)
- screen_set_desktop(num - 1);
-
- /* update the focus lists */
- /* free our lists for the desktops which have disappeared */
- for (i = num; i < old; ++i)
- g_list_free(focus_order[i]);
- /* realloc the array */
- focus_order = g_renew(GList*, focus_order, num);
- /* set the new lists to be empty */
- for (i = old; i < num; ++i)
- focus_order[i] = NULL;
+ screen_set_desktop(num - 1, TRUE);
}
-void screen_set_desktop(guint num)
+void screen_set_desktop(guint num, gboolean dofocus)
{
+ ObClient *c;
GList *it;
guint old;
old = screen_desktop;
screen_desktop = num;
- PROP_SET32(RootWindow(ob_display, ob_screen),
- net_current_desktop, cardinal, num);
if (old == num) return;
+ PROP_SET32(RootWindow(ob_display, ob_screen),
+ net_current_desktop, cardinal, num);
+
screen_last_desktop = old;
ob_debug("Moving to desktop %d\n", num+1);
/* show windows before hiding the rest to lessen the enter/leave events */
/* show windows from top to bottom */
- for (it = stacking_list; it != NULL; it = it->next) {
+ for (it = stacking_list; it; it = g_list_next(it)) {
if (WINDOW_IS_CLIENT(it->data)) {
ObClient *c = it->data;
- if (!c->frame->visible && client_should_show(c))
- frame_show(c->frame);
+ client_show(c);
+ }
+ }
+
+ if (focus_client && ((client_normal(focus_client) &&
+ focus_client->desktop == DESKTOP_ALL) ||
+ focus_client->desktop == screen_desktop))
+ dofocus = FALSE;
+
+ /* 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
+ 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, !config_focus_last)))
+ {
+ /* 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.. */
+ if (c->can_focus) {
+ /* reduce flicker by hiliting now rather than waiting for the
+ server FocusIn event */
+ frame_adjust_focus(c->frame, TRUE);
+ /* do this here so that if you switch desktops to a window with
+ helper windows then the helper windows won't flash */
+ client_bring_helper_windows(c);
}
}
/* hide windows from bottom to top */
- for (it = g_list_last(stacking_list); it != NULL; it = it->prev) {
+ for (it = g_list_last(stacking_list); it; it = g_list_previous(it)) {
if (WINDOW_IS_CLIENT(it->data)) {
ObClient *c = it->data;
- if (c->frame->visible && !client_should_show(c))
- frame_hide(c->frame);
+ client_hide(c);
}
}
- event_ignore_queued_enters();
+ event_ignore_all_queued_enters();
- focus_fallback(OB_FOCUS_FALLBACK_NOFOCUS);
+ if (event_curtime != CurrentTime)
+ screen_desktop_user_time = event_curtime;
}
static void get_row_col(guint d, guint *r, guint *c)
{
Rect *a;
- if (!show || !config_dialog_desktop) {
+ if (!show) {
pager_popup_hide(desktop_cycle_popup);
} else {
a = screen_physical_area_monitor(0);
pager_popup_position(desktop_cycle_popup, CenterGravity,
a->x + a->width / 2, a->y + a->height / 2);
- /* XXX the size and the font extents need to be related on some level
- */
- pager_popup_size(desktop_cycle_popup, POPUP_WIDTH, POPUP_HEIGHT);
-
- pager_popup_set_text_align(desktop_cycle_popup, RR_JUSTIFY_CENTER);
-
+ pager_popup_icon_size_multiplier(desktop_cycle_popup,
+ (screen_desktop_layout.columns /
+ screen_desktop_layout.rows) / 2,
+ (screen_desktop_layout.rows/
+ screen_desktop_layout.columns) / 2);
+ pager_popup_max_width(desktop_cycle_popup,
+ MAX(a->width/3, POPUP_WIDTH));
pager_popup_show(desktop_cycle_popup, screen_desktop_names[d], d);
}
}
guint screen_cycle_desktop(ObDirection dir, gboolean wrap, gboolean linear,
gboolean dialog, gboolean done, gboolean cancel)
{
- static gboolean first = TRUE;
- static gboolean lin;
- static guint origd, d;
guint r, c;
+ static guint d = (guint)-1;
+ guint ret, oldd;
- if (cancel) {
- d = origd;
- goto done_cycle;
- } else if (done && dialog) {
- goto done_cycle;
- }
- if (first) {
- first = FALSE;
- lin = linear;
- d = origd = screen_desktop;
- }
+ if (d == (guint)-1)
+ d = screen_desktop;
+
+ if ((cancel || done) && dialog)
+ goto show_cycle_dialog;
+ oldd = d;
get_row_col(d, &r, &c);
- if (lin) {
+ if (linear) {
switch (dir) {
case OB_DIRECTION_EAST:
if (d < screen_num_desktops - 1)
case OB_DIRECTION_EAST:
++c;
if (c >= screen_desktop_layout.columns) {
- if (!wrap) return d = screen_desktop;
- c = 0;
+ if (wrap)
+ c = 0;
+ else
+ goto show_cycle_dialog;
}
d = translate_row_col(r, c);
if (d >= screen_num_desktops) {
- if (!wrap) return d = screen_desktop;
- ++c;
+ if (wrap) {
+ ++c;
+ } else {
+ d = oldd;
+ goto show_cycle_dialog;
+ }
}
break;
case OB_DIRECTION_WEST:
--c;
if (c >= screen_desktop_layout.columns) {
- if (!wrap) return d = screen_desktop;
- c = screen_desktop_layout.columns - 1;
+ if (wrap)
+ c = screen_desktop_layout.columns - 1;
+ else
+ goto show_cycle_dialog;
}
d = translate_row_col(r, c);
if (d >= screen_num_desktops) {
- if (!wrap) return d = screen_desktop;
- --c;
+ if (wrap) {
+ --c;
+ } else {
+ d = oldd;
+ goto show_cycle_dialog;
+ }
}
break;
case OB_DIRECTION_SOUTH:
++r;
if (r >= screen_desktop_layout.rows) {
- if (!wrap) return d = screen_desktop;
- r = 0;
+ if (wrap)
+ r = 0;
+ else
+ goto show_cycle_dialog;
}
d = translate_row_col(r, c);
if (d >= screen_num_desktops) {
- if (!wrap) return d = screen_desktop;
- ++r;
+ if (wrap) {
+ ++r;
+ } else {
+ d = oldd;
+ goto show_cycle_dialog;
+ }
}
break;
case OB_DIRECTION_NORTH:
--r;
if (r >= screen_desktop_layout.rows) {
- if (!wrap) return d = screen_desktop;
- r = screen_desktop_layout.rows - 1;
+ if (wrap)
+ r = screen_desktop_layout.rows - 1;
+ else
+ goto show_cycle_dialog;
}
d = translate_row_col(r, c);
if (d >= screen_num_desktops) {
- if (!wrap) return d = screen_desktop;
- --r;
+ if (wrap) {
+ --r;
+ } else {
+ d = oldd;
+ goto show_cycle_dialog;
+ }
}
break;
default:
d = translate_row_col(r, c);
}
- if (dialog) {
+show_cycle_dialog:
+ if (dialog && !cancel && !done) {
screen_desktop_popup(d, TRUE);
- return d;
- }
+ } else
+ screen_desktop_popup(0, FALSE);
+ ret = d;
-done_cycle:
- first = TRUE;
+ if (!dialog || cancel || done)
+ d = (guint)-1;
+
+ return ret;
+}
+
+static gboolean screen_validate_layout(ObDesktopLayout *l)
+{
+ if (l->columns == 0 && l->rows == 0) /* both 0's is bad data.. */
+ return FALSE;
- screen_desktop_popup(0, FALSE);
+ /* fill in a zero rows/columns */
+ if (l->columns == 0) {
+ l->columns = screen_num_desktops / l->rows;
+ if (l->rows * l->columns < screen_num_desktops)
+ l->columns++;
+ if (l->rows * l->columns >= screen_num_desktops + l->columns)
+ l->rows--;
+ } else if (l->rows == 0) {
+ l->rows = screen_num_desktops / l->columns;
+ if (l->columns * l->rows < screen_num_desktops)
+ l->rows++;
+ if (l->columns * l->rows >= screen_num_desktops + l->rows)
+ l->columns--;
+ }
- return d;
+ /* bounds checking */
+ if (l->orientation == OB_ORIENTATION_HORZ) {
+ l->columns = MIN(screen_num_desktops, l->columns);
+ l->rows = MIN(l->rows,
+ (screen_num_desktops + l->columns - 1) / l->columns);
+ l->columns = screen_num_desktops / l->rows +
+ !!(screen_num_desktops % l->rows);
+ } else {
+ l->rows = MIN(screen_num_desktops, l->rows);
+ l->columns = MIN(l->columns,
+ (screen_num_desktops + l->rows - 1) / l->rows);
+ l->rows = screen_num_desktops / l->columns +
+ !!(screen_num_desktops % l->columns);
+ }
+ return TRUE;
}
void screen_update_layout()
+
{
- ObOrientation orient;
- ObCorner corner;
- guint rows;
- guint cols;
+ ObDesktopLayout l;
guint32 *data;
guint num;
- gboolean valid = FALSE;
+
+ screen_desktop_layout.orientation = OB_ORIENTATION_HORZ;
+ screen_desktop_layout.start_corner = OB_CORNER_TOPLEFT;
+ screen_desktop_layout.rows = 1;
+ screen_desktop_layout.columns = screen_num_desktops;
if (PROP_GETA32(RootWindow(ob_display, ob_screen),
net_desktop_layout, cardinal, &data, &num)) {
if (num == 3 || num == 4) {
-
+
if (data[0] == prop_atoms.net_wm_orientation_vert)
- orient = OB_ORIENTATION_VERT;
+ l.orientation = OB_ORIENTATION_VERT;
else if (data[0] == prop_atoms.net_wm_orientation_horz)
- orient = OB_ORIENTATION_HORZ;
+ l.orientation = OB_ORIENTATION_HORZ;
else
- goto screen_update_layout_bail;
+ return;
if (num < 4)
- corner = OB_CORNER_TOPLEFT;
+ l.start_corner = OB_CORNER_TOPLEFT;
else {
if (data[3] == prop_atoms.net_wm_topleft)
- corner = OB_CORNER_TOPLEFT;
+ l.start_corner = OB_CORNER_TOPLEFT;
else if (data[3] == prop_atoms.net_wm_topright)
- corner = OB_CORNER_TOPRIGHT;
+ l.start_corner = OB_CORNER_TOPRIGHT;
else if (data[3] == prop_atoms.net_wm_bottomright)
- corner = OB_CORNER_BOTTOMRIGHT;
+ l.start_corner = OB_CORNER_BOTTOMRIGHT;
else if (data[3] == prop_atoms.net_wm_bottomleft)
- corner = OB_CORNER_BOTTOMLEFT;
+ l.start_corner = OB_CORNER_BOTTOMLEFT;
else
- goto screen_update_layout_bail;
+ return;
}
- cols = data[1];
- rows = data[2];
+ l.columns = data[1];
+ l.rows = data[2];
- /* fill in a zero rows/columns */
- if ((cols == 0 && rows == 0)) { /* both 0's is bad data.. */
- goto screen_update_layout_bail;
- } else {
- if (cols == 0) {
- cols = screen_num_desktops / rows;
- if (rows * cols < screen_num_desktops)
- cols++;
- if (rows * cols >= screen_num_desktops + cols)
- rows--;
- } else if (rows == 0) {
- rows = screen_num_desktops / cols;
- if (cols * rows < screen_num_desktops)
- rows++;
- if (cols * rows >= screen_num_desktops + rows)
- cols--;
- }
- }
-
- /* bounds checking */
- if (orient == OB_ORIENTATION_HORZ) {
- cols = MIN(screen_num_desktops, cols);
- rows = MIN(rows, (screen_num_desktops + cols - 1) / cols);
- cols = screen_num_desktops / rows +
- !!(screen_num_desktops % rows);
- } else {
- rows = MIN(screen_num_desktops, rows);
- cols = MIN(cols, (screen_num_desktops + rows - 1) / rows);
- rows = screen_num_desktops / cols +
- !!(screen_num_desktops % cols);
- }
+ if (screen_validate_layout(&l))
+ screen_desktop_layout = l;
- valid = TRUE;
+ g_free(data);
}
- screen_update_layout_bail:
- g_free(data);
- }
-
- if (!valid) {
- /* defaults */
- orient = OB_ORIENTATION_HORZ;
- corner = OB_CORNER_TOPLEFT;
- rows = 1;
- cols = screen_num_desktops;
}
-
- screen_desktop_layout.orientation = orient;
- screen_desktop_layout.start_corner = corner;
- screen_desktop_layout.rows = rows;
- screen_desktop_layout.columns = cols;
}
void screen_update_desktop_names()
if (PROP_GETSS(RootWindow(ob_display, ob_screen),
net_desktop_names, utf8, &screen_desktop_names))
- for (i = 0; screen_desktop_names[i] && i <= screen_num_desktops; ++i);
+ for (i = 0; screen_desktop_names[i] && i < screen_num_desktops; ++i);
else
i = 0;
- if (i <= screen_num_desktops) {
- screen_desktop_names = g_renew(char*, screen_desktop_names,
+ if (i < screen_num_desktops) {
+ GSList *it;
+
+ screen_desktop_names = g_renew(gchar*, screen_desktop_names,
screen_num_desktops + 1);
screen_desktop_names[screen_num_desktops] = NULL;
- for (; i < screen_num_desktops; ++i)
- screen_desktop_names[i] = g_strdup("Unnamed Desktop");
+
+ it = g_slist_nth(config_desktops_names, i);
+
+ for (; i < screen_num_desktops; ++i) {
+ if (it && ((char*)it->data)[0]) /* not empty */
+ /* use the names from the config file when possible */
+ screen_desktop_names[i] = g_strdup(it->data);
+ else
+ /* make up a nice name if it's not though */
+ screen_desktop_names[i] = g_strdup_printf(_("desktop %i"),
+ i + 1);
+ if (it) it = g_slist_next(it);
+ }
+
+ /* if we changed any names, then set the root property so we can
+ all agree on the names */
+ PROP_SETSS(RootWindow(ob_display, ob_screen), net_desktop_names,
+ screen_desktop_names);
}
+
+ /* resize the pager for these names */
+ pager_popup_text_width_to_strings(desktop_cycle_popup,
+ screen_desktop_names,
+ screen_num_desktops);
}
-void screen_show_desktop(gboolean show)
+void screen_show_desktop(gboolean show, ObClient *show_only)
{
GList *it;
screen_showing_desktop = show;
if (show) {
- /* bottom to top */
- for (it = g_list_last(stacking_list); it != NULL; it = it->prev) {
+ /* hide windows bottom to top */
+ for (it = g_list_last(stacking_list); it; it = g_list_previous(it)) {
if (WINDOW_IS_CLIENT(it->data)) {
ObClient *client = it->data;
- if (client->frame->visible && !client_should_show(client))
- frame_hide(client->frame);
+ client_showhide(client);
}
- }
- } else {
- /* top to bottom */
- for (it = stacking_list; it != NULL; it = it->next) {
+ }
+ }
+ else {
+ /* restore windows top to bottom */
+ for (it = stacking_list; it; it = g_list_next(it)) {
if (WINDOW_IS_CLIENT(it->data)) {
ObClient *client = it->data;
- if (!client->frame->visible && client_should_show(client))
- frame_show(client->frame);
+ if (client_should_show(client)) {
+ if (!show_only || client == show_only)
+ client_show(client);
+ else
+ client_iconify(client, TRUE, FALSE, TRUE);
+ }
}
- }
+ }
}
if (show) {
- /* focus desktop */
- for (it = focus_order[screen_desktop]; it; it = it->next)
- if (((ObClient*)it->data)->type == OB_CLIENT_TYPE_DESKTOP &&
+ /* focus the desktop */
+ for (it = focus_order; it; it = g_list_next(it)) {
+ ObClient *c = it->data;
+ if (c->type == OB_CLIENT_TYPE_DESKTOP &&
+ (c->desktop == screen_desktop || c->desktop == DESKTOP_ALL) &&
client_focus(it->data))
break;
- } else {
- focus_fallback(OB_FOCUS_FALLBACK_NOFOCUS);
+ }
+ }
+ else if (!show_only) {
+ ObClient *c;
+
+ if ((c = focus_fallback(TRUE, FALSE))) {
+ /* 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.. */
+ if (c->can_focus) {
+ /* reduce flicker by hiliting now rather than waiting for the
+ server FocusIn event */
+ frame_adjust_focus(c->frame, TRUE);
+ }
+ }
}
show = !!show; /* make it boolean */
void screen_install_colormap(ObClient *client, gboolean install)
{
- XWindowAttributes wa;
-
- if (client == NULL) {
- if (install)
- XInstallColormap(RrDisplay(ob_rr_inst), RrColormap(ob_rr_inst));
- else
- XUninstallColormap(RrDisplay(ob_rr_inst), RrColormap(ob_rr_inst));
+ 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 {
- if (XGetWindowAttributes(ob_display, client->window, &wa) &&
- wa.colormap != None) {
- xerror_set_ignore(TRUE);
- if (install)
- XInstallColormap(RrDisplay(ob_rr_inst), wa.colormap);
- else
- XUninstallColormap(RrDisplay(ob_rr_inst), wa.colormap);
- xerror_set_ignore(FALSE);
- }
+ xerror_set_ignore(TRUE);
+ 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;
- guint32 *dims;
+ gulong *dims;
GList *it;
gint o;
area[i] = g_new0(Rect, screen_num_monitors + 1);
area[i] = NULL;
- dims = g_new(guint32, 4 * screen_num_desktops);
+ dims = g_new(gulong, 4 * screen_num_desktops);
for (i = 0; i < screen_num_desktops + 1; ++i) {
Strut *struts;
o = MIN(o, area[i][x].x);
for (x = 0; x < screen_num_monitors; ++x) {
- for (it = client_list; it; it = it->next) {
+ 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 = MIN(o, area[i][x].y);
for (x = 0; x < screen_num_monitors; ++x) {
- for (it = client_list; it; it = it->next) {
+ 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 = 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 = it->next) {
+ for (it = client_list; it; it = g_list_next(it)) {
ObClient *c = it->data;
screen_area_add_strut_right(&c->strut,
&monitor_area[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 = it->next) {
+ for (it = client_list; it; it = g_list_next(it)) {
ObClient *c = it->data;
screen_area_add_strut_bottom(&c->strut,
&monitor_area[x],
/* the area has changed, adjust all the maximized
windows */
- for (it = client_list; it; it = it->next) {
+ for (it = client_list; it; it = g_list_next(it)) {
ObClient *c = it->data;
if (i < screen_num_desktops) {
if (c->desktop == i)
if (head > screen_num_monitors)
return NULL;
if (desktop >= screen_num_desktops) {
- if (desktop == DESKTOP_ALL)
- return &area[screen_num_desktops][head];
- return NULL;
+ if (desktop == DESKTOP_ALL)
+ return &area[screen_num_desktops][head];
+ return NULL;
}
return &area[desktop][head];
}
+guint screen_find_monitor(Rect *search)
+{
+ guint i;
+ guint most = 0;
+ guint mostv = 0;
+
+ for (i = 0; i < screen_num_monitors; ++i) {
+ Rect *area = screen_physical_area_monitor(i);
+ if (RECT_INTERSECTS_RECT(*area, *search)) {
+ Rect r;
+ guint v;
+
+ RECT_SET_INTERSECTION(r, *area, *search);
+ v = r.width * r.height;
+
+ if (v > mostv) {
+ mostv = v;
+ most = i;
+ }
+ }
+ }
+ return most;
+}
+
Rect *screen_physical_area()
{
return screen_physical_area_monitor(screen_num_monitors);
{
if (sn_app_starting())
XDefineCursor(ob_display, RootWindow(ob_display, ob_screen),
- ob_cursor(OB_CURSOR_BUSY));
+ ob_cursor(OB_CURSOR_BUSYPOINTER));
else
XDefineCursor(ob_display, RootWindow(ob_display, ob_screen),
ob_cursor(OB_CURSOR_POINTER));
}
-gboolean screen_pointer_pos(int *x, int *y)
+gboolean screen_pointer_pos(gint *x, gint *y)
{
Window w;
- int i;
+ gint i;
guint u;
-
- return !!XQueryPointer(ob_display, RootWindow(ob_display, ob_screen),
- &w, &w, x, y, &i, &i, &u);
+ gboolean ret;
+
+ ret = !!XQueryPointer(ob_display, RootWindow(ob_display, ob_screen),
+ &w, &w, x, y, &i, &i, &u);
+ if (!ret) {
+ for (i = 0; i < ScreenCount(ob_display); ++i)
+ if (i != ob_screen)
+ if (XQueryPointer(ob_display, RootWindow(ob_display, i),
+ &w, &w, x, y, &i, &i, &u))
+ break;
+ }
+ return ret;
}