/* -*- 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)
guint screen_num_desktops;
guint screen_num_monitors;
Size screen_physical_size;
gboolean screen_showing_desktop;
DesktopLayout screen_desktop_layout;
-char **screen_desktop_names;
+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;
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;
}
-gboolean screen_annex()
+gboolean screen_annex(const gchar *program_name)
{
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;
}
net_supporting_wm_check, window, screen_support_win);
/* set properties on the supporting window */
- PROP_SETS(screen_support_win, net_wm_name, "Openbox");
+ PROP_SETS(screen_support_win, net_wm_name, program_name);
PROP_SET32(screen_support_win, net_supporting_wm_check,
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_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.ob_wm_state_undecorated;
+ 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.openbox_wm_state_undecorated;
+ supported[i++] = prop_atoms.openbox_pid;
+ supported[i++] = prop_atoms.openbox_config;
+ supported[i++] = prop_atoms.openbox_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);
void screen_startup(gboolean reconfig)
{
+ guint i, numnames;
+ gchar **names;
GSList *it;
- guint i;
+ guint32 d;
desktop_cycle_popup = pager_popup_new(FALSE);
+ pager_popup_height(desktop_cycle_popup, POPUP_HEIGHT);
- 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;
+ if (reconfig)
+ return;
+
+ /* get the initial size */
+ screen_resize();
+
+ /* get the desktop names */
+ numnames = g_slist_length(config_desktops_names);
+ names = g_new(gchar*, numnames + 1);
+ names[numnames] = NULL;
+ for (i = 0, it = config_desktops_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);
- if (!reconfig)
- screen_num_desktops = 0;
+ g_strfreev(names);
+
+ /* set the number of desktops */
+ screen_num_desktops = 0;
screen_set_num_desktops(config_desktops_num);
- if (!reconfig) {
- screen_set_desktop(0);
- /* 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);
+ /* 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_update_layout();
- }
+ /* 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);
+
+ 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;
+
+ XSelectInput(ob_display, RootWindow(ob_display, ob_screen),
+ NoEventMask);
- /* 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);
+ /* 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);
- }
+ 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;
for (it = stacking_list; it; it = g_list_next(it)) {
if (WINDOW_IS_CLIENT(it->data)) {
ObClient *c = it->data;
- if (client_should_show(c))
- frame_show(c->frame);
+ client_show(c);
+ }
+ }
+
+ /* have to try focus here because when you leave an empty desktop
+ there is no focus out to watch for
+
+ do this before hiding the windows so if helper windows are coming
+ with us, they don't get hidden
+ */
+ if (dofocus && (c = focus_fallback_target(TRUE, focus_client))) {
+ /* 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) {
+ /* 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);
+ /* reduce flicker by hiliting now rather than waiting for the
+ server FocusIn event */
+ frame_adjust_focus(c->frame, TRUE);
}
+ client_focus(c);
}
/* hide windows from bottom to top */
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();
- focus_hilite = focus_fallback_target(OB_FOCUS_FALLBACK_NOFOCUS);
- if (focus_hilite) {
- frame_adjust_focus(focus_hilite->frame, TRUE);
-
- /*!
- When this focus_client check is not used, you can end up with races,
- as demonstrated with gnome-panel, sometmies the window you click on
- another desktop ends up losing focus cuz of the focus change here.
- */
- /*if (!focus_client)*/
- client_focus(focus_hilite);
- }
+ if (event_curtime != CurrentTime)
+ screen_desktop_user_time = event_curtime;
}
static void get_row_col(guint d, guint *r, guint *c)
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;
- 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;
get_row_col(d, &r, &c);
- if (lin) {
+ if (linear) {
switch (dir) {
case OB_DIRECTION_EAST:
if (d < screen_num_desktops - 1)
}
show_cycle_dialog:
- if (dialog) {
+ if (dialog && !cancel && !done) {
screen_desktop_popup(d, TRUE);
- return d;
- }
-
-done_cycle:
- first = TRUE;
+ } else
+ screen_desktop_popup(0, FALSE);
+ ret = d;
- screen_desktop_popup(0, FALSE);
+ if (!dialog || cancel || done)
+ d = (guint)-1;
- return d;
+ return ret;
}
void screen_update_layout()
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) {
+ 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");
+ screen_desktop_names[i] = g_strdup_printf("desktop %i", i + 1);
}
+
+ /* 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, gboolean restore_focus)
{
GList *it;
if (show) {
/* 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 *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) {
+ 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);
+ client_showhide(client);
}
}
}
if (show) {
/* focus desktop */
- for (it = focus_order[screen_desktop]; it; it = it->next)
- if (((ObClient*)it->data)->type == OB_CLIENT_TYPE_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 (restore_focus) {
+ ObClient *c;
+
+ /* use NULL for the "old" argument because the desktop was focused
+ and we don't want to fallback to the desktop by default */
+ if ((c = focus_fallback_target(TRUE, NULL)))
+ client_focus(c);
}
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));
} 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) {
+ if (client->colormap != None)
+ 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);
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;
}