/*
* gdkscreen-x11.c
- *
- * Copyright 2001 Sun Microsystems Inc.
+ *
+ * Copyright 2001 Sun Microsystems Inc.
*
* Erwann Chenede <erwann.chenede@sun.com>
*
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
- * License along with this library; if not, write to the
- * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
- * Boston, MA 02111-1307, USA.
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
*/
#include "config.h"
#include <X11/extensions/Xfixes.h>
#endif
-#include "gdksettings.c"
-
-static void gdk_screen_x11_dispose (GObject *object);
-static void gdk_screen_x11_finalize (GObject *object);
+static void gdk_x11_screen_dispose (GObject *object);
+static void gdk_x11_screen_finalize (GObject *object);
static void init_randr_support (GdkScreen *screen);
static void deinit_multihead (GdkScreen *screen);
static guint signals[LAST_SIGNAL] = { 0 };
-G_DEFINE_TYPE (GdkScreenX11, _gdk_screen_x11, GDK_TYPE_SCREEN)
+G_DEFINE_TYPE (GdkX11Screen, gdk_x11_screen, GDK_TYPE_SCREEN)
typedef struct _NetWmSupportedAtoms NetWmSupportedAtoms;
static void
-_gdk_screen_x11_init (GdkScreenX11 *screen)
+gdk_x11_screen_init (GdkX11Screen *screen)
{
}
static GdkDisplay *
-gdk_screen_x11_get_display (GdkScreen *screen)
+gdk_x11_screen_get_display (GdkScreen *screen)
{
- g_return_val_if_fail (GDK_IS_SCREEN (screen), NULL);
-
- return GDK_SCREEN_X11 (screen)->display;
+ return GDK_X11_SCREEN (screen)->display;
}
static gint
-gdk_screen_x11_get_width (GdkScreen *screen)
+gdk_x11_screen_get_width (GdkScreen *screen)
{
- g_return_val_if_fail (GDK_IS_SCREEN (screen), 0);
-
- return WidthOfScreen (GDK_SCREEN_X11 (screen)->xscreen);
+ return WidthOfScreen (GDK_X11_SCREEN (screen)->xscreen);
}
static gint
-gdk_screen_x11_get_height (GdkScreen *screen)
+gdk_x11_screen_get_height (GdkScreen *screen)
{
- g_return_val_if_fail (GDK_IS_SCREEN (screen), 0);
-
- return HeightOfScreen (GDK_SCREEN_X11 (screen)->xscreen);
+ return HeightOfScreen (GDK_X11_SCREEN (screen)->xscreen);
}
static gint
-gdk_screen_x11_get_width_mm (GdkScreen *screen)
+gdk_x11_screen_get_width_mm (GdkScreen *screen)
{
- g_return_val_if_fail (GDK_IS_SCREEN (screen), 0);
-
- return WidthMMOfScreen (GDK_SCREEN_X11 (screen)->xscreen);
+ return WidthMMOfScreen (GDK_X11_SCREEN (screen)->xscreen);
}
static gint
-gdk_screen_x11_get_height_mm (GdkScreen *screen)
+gdk_x11_screen_get_height_mm (GdkScreen *screen)
{
- g_return_val_if_fail (GDK_IS_SCREEN (screen), 0);
-
- return HeightMMOfScreen (GDK_SCREEN_X11 (screen)->xscreen);
+ return HeightMMOfScreen (GDK_X11_SCREEN (screen)->xscreen);
}
static gint
-gdk_screen_x11_get_number (GdkScreen *screen)
+gdk_x11_screen_get_number (GdkScreen *screen)
{
- g_return_val_if_fail (GDK_IS_SCREEN (screen), 0);
-
- return GDK_SCREEN_X11 (screen)->screen_num;
+ return GDK_X11_SCREEN (screen)->screen_num;
}
static GdkWindow *
-gdk_screen_x11_get_root_window (GdkScreen *screen)
+gdk_x11_screen_get_root_window (GdkScreen *screen)
{
- g_return_val_if_fail (GDK_IS_SCREEN (screen), NULL);
-
- return GDK_SCREEN_X11 (screen)->root_window;
+ return GDK_X11_SCREEN (screen)->root_window;
}
static void
-_gdk_screen_x11_events_uninit (GdkScreen *screen)
+_gdk_x11_screen_events_uninit (GdkScreen *screen)
{
- GdkScreenX11 *screen_x11 = GDK_SCREEN_X11 (screen);
+ GdkX11Screen *x11_screen = GDK_X11_SCREEN (screen);
- if (screen_x11->xsettings_client)
+ if (x11_screen->xsettings_client)
{
- xsettings_client_destroy (screen_x11->xsettings_client);
- screen_x11->xsettings_client = NULL;
+ _gdk_x11_xsettings_client_destroy (x11_screen->xsettings_client);
+ x11_screen->xsettings_client = NULL;
}
}
static void
-gdk_screen_x11_dispose (GObject *object)
+gdk_x11_screen_dispose (GObject *object)
{
- GdkScreenX11 *screen_x11 = GDK_SCREEN_X11 (object);
+ GdkX11Screen *x11_screen = GDK_X11_SCREEN (object);
int i;
for (i = 0; i < 32; ++i)
{
- if (screen_x11->subwindow_gcs[i])
+ if (x11_screen->subwindow_gcs[i])
{
- XFreeGC (screen_x11->xdisplay, screen_x11->subwindow_gcs[i]);
- screen_x11->subwindow_gcs[i] = 0;
+ XFreeGC (x11_screen->xdisplay, x11_screen->subwindow_gcs[i]);
+ x11_screen->subwindow_gcs[i] = 0;
}
}
- _gdk_screen_x11_events_uninit (GDK_SCREEN (object));
+ _gdk_x11_screen_events_uninit (GDK_SCREEN (object));
- if (screen_x11->root_window)
- _gdk_window_destroy (screen_x11->root_window, TRUE);
+ if (x11_screen->root_window)
+ _gdk_window_destroy (x11_screen->root_window, TRUE);
- G_OBJECT_CLASS (_gdk_screen_x11_parent_class)->dispose (object);
+ G_OBJECT_CLASS (gdk_x11_screen_parent_class)->dispose (object);
- screen_x11->xdisplay = NULL;
- screen_x11->xscreen = NULL;
- screen_x11->screen_num = -1;
- screen_x11->xroot_window = None;
- screen_x11->wmspec_check_window = None;
+ x11_screen->xdisplay = NULL;
+ x11_screen->xscreen = NULL;
+ x11_screen->screen_num = -1;
+ x11_screen->xroot_window = None;
+ x11_screen->wmspec_check_window = None;
}
static void
-gdk_screen_x11_finalize (GObject *object)
+gdk_x11_screen_finalize (GObject *object)
{
- GdkScreenX11 *screen_x11 = GDK_SCREEN_X11 (object);
+ GdkX11Screen *x11_screen = GDK_X11_SCREEN (object);
gint i;
- if (screen_x11->root_window)
- g_object_unref (screen_x11->root_window);
+ if (x11_screen->root_window)
+ g_object_unref (x11_screen->root_window);
/* Visual Part */
- for (i = 0; i < screen_x11->nvisuals; i++)
- g_object_unref (screen_x11->visuals[i]);
- g_free (screen_x11->visuals);
- g_hash_table_destroy (screen_x11->visual_hash);
+ for (i = 0; i < x11_screen->nvisuals; i++)
+ g_object_unref (x11_screen->visuals[i]);
+ g_free (x11_screen->visuals);
+ g_hash_table_destroy (x11_screen->visual_hash);
- g_free (screen_x11->window_manager_name);
+ g_free (x11_screen->window_manager_name);
deinit_multihead (GDK_SCREEN (object));
- G_OBJECT_CLASS (_gdk_screen_x11_parent_class)->finalize (object);
+ G_OBJECT_CLASS (gdk_x11_screen_parent_class)->finalize (object);
}
static gint
-gdk_screen_x11_get_n_monitors (GdkScreen *screen)
+gdk_x11_screen_get_n_monitors (GdkScreen *screen)
{
- g_return_val_if_fail (GDK_IS_SCREEN (screen), 0);
-
- return GDK_SCREEN_X11 (screen)->n_monitors;
+ return GDK_X11_SCREEN (screen)->n_monitors;
}
static gint
-gdk_screen_x11_get_primary_monitor (GdkScreen *screen)
+gdk_x11_screen_get_primary_monitor (GdkScreen *screen)
{
- g_return_val_if_fail (GDK_IS_SCREEN (screen), 0);
-
- return GDK_SCREEN_X11 (screen)->primary_monitor;
+ return GDK_X11_SCREEN (screen)->primary_monitor;
}
static gint
-gdk_screen_x11_get_monitor_width_mm (GdkScreen *screen,
- gint monitor_num)
+gdk_x11_screen_get_monitor_width_mm (GdkScreen *screen,
+ gint monitor_num)
{
- GdkScreenX11 *screen_x11 = GDK_SCREEN_X11 (screen);
-
- g_return_val_if_fail (GDK_IS_SCREEN (screen), -1);
- g_return_val_if_fail (monitor_num >= 0, -1);
- g_return_val_if_fail (monitor_num < screen_x11->n_monitors, -1);
+ GdkX11Screen *x11_screen = GDK_X11_SCREEN (screen);
- return screen_x11->monitors[monitor_num].width_mm;
+ return x11_screen->monitors[monitor_num].width_mm;
}
static gint
-gdk_screen_x11_get_monitor_height_mm (GdkScreen *screen,
+gdk_x11_screen_get_monitor_height_mm (GdkScreen *screen,
gint monitor_num)
{
- GdkScreenX11 *screen_x11 = GDK_SCREEN_X11 (screen);
-
- g_return_val_if_fail (GDK_IS_SCREEN (screen), -1);
- g_return_val_if_fail (monitor_num >= 0, -1);
- g_return_val_if_fail (monitor_num < screen_x11->n_monitors, -1);
+ GdkX11Screen *x11_screen = GDK_X11_SCREEN (screen);
- return screen_x11->monitors[monitor_num].height_mm;
+ return x11_screen->monitors[monitor_num].height_mm;
}
static gchar *
-gdk_screen_x11_get_monitor_plug_name (GdkScreen *screen,
+gdk_x11_screen_get_monitor_plug_name (GdkScreen *screen,
gint monitor_num)
{
- GdkScreenX11 *screen_x11 = GDK_SCREEN_X11 (screen);
+ GdkX11Screen *x11_screen = GDK_X11_SCREEN (screen);
- g_return_val_if_fail (GDK_IS_SCREEN (screen), NULL);
- g_return_val_if_fail (monitor_num >= 0, NULL);
- g_return_val_if_fail (monitor_num < screen_x11->n_monitors, NULL);
-
- return g_strdup (screen_x11->monitors[monitor_num].output_name);
+ return g_strdup (x11_screen->monitors[monitor_num].output_name);
}
/**
* gdk_x11_screen_get_monitor_output:
- * @screen: a #GdkScreen
+ * @screen: (type GdkX11Screen): a #GdkScreen
* @monitor_num: number of the monitor, between 0 and gdk_screen_get_n_monitors (screen)
*
* Gets the XID of the specified output/monitor.
gdk_x11_screen_get_monitor_output (GdkScreen *screen,
gint monitor_num)
{
- GdkScreenX11 *screen_x11 = GDK_SCREEN_X11 (screen);
+ GdkX11Screen *x11_screen = GDK_X11_SCREEN (screen);
g_return_val_if_fail (GDK_IS_SCREEN (screen), None);
g_return_val_if_fail (monitor_num >= 0, None);
- g_return_val_if_fail (monitor_num < screen_x11->n_monitors, None);
+ g_return_val_if_fail (monitor_num < x11_screen->n_monitors, None);
- return screen_x11->monitors[monitor_num].output;
+ return x11_screen->monitors[monitor_num].output;
}
static void
-gdk_screen_x11_get_monitor_geometry (GdkScreen *screen,
+gdk_x11_screen_get_monitor_geometry (GdkScreen *screen,
gint monitor_num,
GdkRectangle *dest)
{
- GdkScreenX11 *screen_x11 = GDK_SCREEN_X11 (screen);
-
- g_return_if_fail (GDK_IS_SCREEN (screen));
- g_return_if_fail (monitor_num >= 0);
- g_return_if_fail (monitor_num < screen_x11->n_monitors);
+ GdkX11Screen *x11_screen = GDK_X11_SCREEN (screen);
if (dest)
- *dest = screen_x11->monitors[monitor_num].geometry;
+ *dest = x11_screen->monitors[monitor_num].geometry;
}
-static GdkVisual *
-gdk_screen_x11_get_rgba_visual (GdkScreen *screen)
+static int
+get_current_desktop (GdkScreen *screen)
{
- GdkScreenX11 *screen_x11;
+ Display *display;
+ Window win;
+ Atom current_desktop, type;
+ int format;
+ unsigned long n_items, bytes_after;
+ unsigned char *data_return = NULL;
+ int workspace = 0;
- g_return_val_if_fail (GDK_IS_SCREEN (screen), NULL);
+ if (!gdk_x11_screen_supports_net_wm_hint (screen,
+ gdk_atom_intern_static_string ("_NET_CURRENT_DESKTOP")))
+ return workspace;
- screen_x11 = GDK_SCREEN_X11 (screen);
+ display = GDK_DISPLAY_XDISPLAY (gdk_screen_get_display (screen));
+ win = XRootWindow (display, GDK_SCREEN_XNUMBER (screen));
- return screen_x11->rgba_visual;
+ current_desktop = XInternAtom (display, "_NET_CURRENT_DESKTOP", True);
+
+ XGetWindowProperty (display,
+ win,
+ current_desktop,
+ 0, G_MAXLONG,
+ False, XA_CARDINAL,
+ &type, &format, &n_items, &bytes_after,
+ &data_return);
+
+ if (type == XA_CARDINAL && format == 32 && n_items > 0)
+ workspace = (int) data_return[0];
+
+ if (data_return)
+ XFree (data_return);
+
+ return workspace;
+}
+
+static void
+get_work_area (GdkScreen *screen,
+ GdkRectangle *area)
+{
+ Atom workarea;
+ Atom type;
+ Window win;
+ int format;
+ gulong num;
+ gulong leftovers;
+ gulong max_len = 4 * 32;
+ guchar *ret_workarea;
+ long *workareas;
+ int result;
+ int disp_screen;
+ int desktop;
+ Display *display;
+
+ display = GDK_DISPLAY_XDISPLAY (gdk_screen_get_display (screen));
+ disp_screen = GDK_SCREEN_XNUMBER (screen);
+ workarea = XInternAtom (display, "_NET_WORKAREA", True);
+
+ /* Defaults in case of error */
+ area->x = 0;
+ area->y = 0;
+ area->width = gdk_screen_get_width (screen);
+ area->height = gdk_screen_get_height (screen);
+
+ if (!gdk_x11_screen_supports_net_wm_hint (screen,
+ gdk_atom_intern_static_string ("_NET_WORKAREA")))
+ return;
+
+ if (workarea == None)
+ return;
+
+ win = XRootWindow (display, disp_screen);
+ result = XGetWindowProperty (display,
+ win,
+ workarea,
+ 0,
+ max_len,
+ False,
+ AnyPropertyType,
+ &type,
+ &format,
+ &num,
+ &leftovers,
+ &ret_workarea);
+ if (result != Success ||
+ type == None ||
+ format == 0 ||
+ leftovers ||
+ num % 4 != 0)
+ return;
+
+ desktop = get_current_desktop (screen);
+
+ workareas = (long *) ret_workarea;
+ area->x = workareas[desktop * 4];
+ area->y = workareas[desktop * 4 + 1];
+ area->width = workareas[desktop * 4 + 2];
+ area->height = workareas[desktop * 4 + 3];
+
+ XFree (ret_workarea);
+}
+
+static void
+gdk_x11_screen_get_monitor_workarea (GdkScreen *screen,
+ gint monitor_num,
+ GdkRectangle *dest)
+{
+ GdkRectangle workarea;
+
+ gdk_x11_screen_get_monitor_geometry (screen, monitor_num, dest);
+
+ /* The EWMH constrains workarea to be a rectangle, so it
+ * can't adequately deal with L-shaped monitor arrangements.
+ * As a workaround, we ignore the workarea for anything
+ * but the primary monitor. Since that is where the 'desktop
+ * chrome' usually lives, this works ok in practice.
+ */
+ if (monitor_num == GDK_X11_SCREEN (screen)->primary_monitor)
+ {
+ get_work_area (screen, &workarea);
+ if (gdk_rectangle_intersect (dest, &workarea, &workarea))
+ *dest = workarea;
+ }
+}
+
+static GdkVisual *
+gdk_x11_screen_get_rgba_visual (GdkScreen *screen)
+{
+ GdkX11Screen *x11_screen = GDK_X11_SCREEN (screen);
+
+ return x11_screen->rgba_visual;
}
/**
* gdk_x11_screen_get_xscreen:
- * @screen: a #GdkScreen.
- * @returns: (transfer none): an Xlib <type>Screen*</type>
+ * @screen: (type GdkX11Screen): a #GdkScreen
*
* Returns the screen of a #GdkScreen.
*
+ * Returns: (transfer none): an Xlib <type>Screen*</type>
+ *
* Since: 2.2
*/
Screen *
gdk_x11_screen_get_xscreen (GdkScreen *screen)
{
- return GDK_SCREEN_X11 (screen)->xscreen;
+ return GDK_X11_SCREEN (screen)->xscreen;
}
/**
* gdk_x11_screen_get_screen_number:
- * @screen: a #GdkScreen.
- * @returns: the position of @screen among the screens of
- * its display.
+ * @screen: (type GdkX11Screen): a #GdkScreen
*
* Returns the index of a #GdkScreen.
*
+ * Returns: the position of @screen among the screens
+ * of its display
+ *
* Since: 2.2
*/
int
gdk_x11_screen_get_screen_number (GdkScreen *screen)
{
- return GDK_SCREEN_X11 (screen)->screen_num;
+ return GDK_X11_SCREEN (screen)->screen_num;
+}
+
+static Atom
+get_cm_atom (GdkX11Screen *x11_screen)
+{
+ return _gdk_x11_get_xatom_for_display_printf (x11_screen->display, "_NET_WM_CM_S%d", x11_screen->screen_num);
}
static gboolean
check_is_composited (GdkDisplay *display,
- GdkScreenX11 *screen_x11)
+ GdkX11Screen *x11_screen)
{
- Atom xselection = gdk_x11_atom_to_xatom_for_display (display, screen_x11->cm_selection_atom);
Window xwindow;
- xwindow = XGetSelectionOwner (GDK_DISPLAY_XDISPLAY (display), xselection);
+ xwindow = XGetSelectionOwner (GDK_DISPLAY_XDISPLAY (display), get_cm_atom (x11_screen));
return xwindow != None;
}
-static GdkAtom
-make_cm_atom (int screen_number)
-{
- gchar *name = g_strdup_printf ("_NET_WM_CM_S%d", screen_number);
- GdkAtom atom = gdk_atom_intern (name, FALSE);
- g_free (name);
- return atom;
-}
-
static void
init_monitor_geometry (GdkX11Monitor *monitor,
int x, int y, int width, int height)
init_fake_xinerama (GdkScreen *screen)
{
#ifdef G_ENABLE_DEBUG
- GdkScreenX11 *screen_x11 = GDK_SCREEN_X11 (screen);
+ GdkX11Screen *x11_screen = GDK_X11_SCREEN (screen);
XSetWindowAttributes atts;
Window win;
gint w, h;
/* Fake Xinerama mode by splitting the screen into 4 monitors.
* Also draw a little cross to make the monitor boundaries visible.
*/
- w = WidthOfScreen (screen_x11->xscreen);
- h = HeightOfScreen (screen_x11->xscreen);
-
- screen_x11->n_monitors = 4;
- screen_x11->monitors = g_new0 (GdkX11Monitor, 4);
- init_monitor_geometry (&screen_x11->monitors[0], 0, 0, w / 2, h / 2);
- init_monitor_geometry (&screen_x11->monitors[1], w / 2, 0, w / 2, h / 2);
- init_monitor_geometry (&screen_x11->monitors[2], 0, h / 2, w / 2, h / 2);
- init_monitor_geometry (&screen_x11->monitors[3], w / 2, h / 2, w / 2, h / 2);
+ w = WidthOfScreen (x11_screen->xscreen);
+ h = HeightOfScreen (x11_screen->xscreen);
+
+ x11_screen->n_monitors = 4;
+ x11_screen->monitors = g_new0 (GdkX11Monitor, 4);
+ init_monitor_geometry (&x11_screen->monitors[0], 0, 0, w / 2, h / 2);
+ init_monitor_geometry (&x11_screen->monitors[1], w / 2, 0, w / 2, h / 2);
+ init_monitor_geometry (&x11_screen->monitors[2], 0, h / 2, w / 2, h / 2);
+ init_monitor_geometry (&x11_screen->monitors[3], w / 2, h / 2, w / 2, h / 2);
atts.override_redirect = 1;
atts.background_pixel = WhitePixel(GDK_SCREEN_XDISPLAY (screen),
- screen_x11->screen_num);
+ x11_screen->screen_num);
win = XCreateWindow(GDK_SCREEN_XDISPLAY (screen),
- screen_x11->xroot_window, 0, h / 2, w, 1, 0,
+ x11_screen->xroot_window, 0, h / 2, w, 1, 0,
DefaultDepth(GDK_SCREEN_XDISPLAY (screen),
- screen_x11->screen_num),
+ x11_screen->screen_num),
InputOutput,
DefaultVisual(GDK_SCREEN_XDISPLAY (screen),
- screen_x11->screen_num),
+ x11_screen->screen_num),
CWOverrideRedirect|CWBackPixel,
&atts);
XMapRaised(GDK_SCREEN_XDISPLAY (screen), win);
win = XCreateWindow(GDK_SCREEN_XDISPLAY (screen),
- screen_x11->xroot_window, w/2 , 0, 1, h, 0,
+ x11_screen->xroot_window, w/2 , 0, 1, h, 0,
DefaultDepth(GDK_SCREEN_XDISPLAY (screen),
- screen_x11->screen_num),
+ x11_screen->screen_num),
InputOutput,
DefaultVisual(GDK_SCREEN_XDISPLAY (screen),
- screen_x11->screen_num),
+ x11_screen->screen_num),
CWOverrideRedirect|CWBackPixel,
&atts);
XMapRaised(GDK_SCREEN_XDISPLAY (screen), win);
{
#ifdef HAVE_RANDR
GdkDisplay *display = gdk_screen_get_display (screen);
- GdkX11Display *display_x11 = GDK_DISPLAY_X11 (display);
- GdkScreenX11 *screen_x11 = GDK_SCREEN_X11 (screen);
+ GdkX11Display *display_x11 = GDK_X11_DISPLAY (display);
+ GdkX11Screen *x11_screen = GDK_X11_SCREEN (screen);
Display *dpy = GDK_SCREEN_XDISPLAY (screen);
XRRScreenResources *resources;
RROutput primary_output;
if (!display_x11->have_randr13)
return FALSE;
- resources = XRRGetScreenResourcesCurrent (screen_x11->xdisplay,
- screen_x11->xroot_window);
+ resources = XRRGetScreenResourcesCurrent (x11_screen->xdisplay,
+ x11_screen->xroot_window);
if (!resources)
return FALSE;
g_array_sort (monitors,
(GCompareFunc) monitor_compare_function);
- screen_x11->n_monitors = monitors->len;
- screen_x11->monitors = (GdkX11Monitor *)g_array_free (monitors, FALSE);
+ x11_screen->n_monitors = monitors->len;
+ x11_screen->monitors = (GdkX11Monitor *)g_array_free (monitors, FALSE);
- screen_x11->primary_monitor = 0;
+ x11_screen->primary_monitor = 0;
- primary_output = XRRGetOutputPrimary (screen_x11->xdisplay,
- screen_x11->xroot_window);
+ primary_output = XRRGetOutputPrimary (x11_screen->xdisplay,
+ x11_screen->xroot_window);
- for (i = 0; i < screen_x11->n_monitors; ++i)
+ for (i = 0; i < x11_screen->n_monitors; ++i)
{
- if (screen_x11->monitors[i].output == primary_output)
+ if (x11_screen->monitors[i].output == primary_output)
{
- screen_x11->primary_monitor = i;
+ x11_screen->primary_monitor = i;
break;
}
/* No RandR1.3+ available or no primary set, fall back to prefer LVDS as primary if present */
if (primary_output == None &&
- g_ascii_strncasecmp (screen_x11->monitors[i].output_name, "LVDS", 4) == 0)
+ g_ascii_strncasecmp (x11_screen->monitors[i].output_name, "LVDS", 4) == 0)
{
- screen_x11->primary_monitor = i;
+ x11_screen->primary_monitor = i;
break;
}
/* No primary specified and no LVDS found */
- if (screen_x11->monitors[i].output == first_output)
- screen_x11->primary_monitor = i;
+ if (x11_screen->monitors[i].output == first_output)
+ x11_screen->primary_monitor = i;
}
- return screen_x11->n_monitors > 0;
+ return x11_screen->n_monitors > 0;
#endif
return FALSE;
#ifdef HAVE_SOLARIS_XINERAMA
Display *dpy = GDK_SCREEN_XDISPLAY (screen);
int screen_no = gdk_screen_get_number (screen);
- GdkScreenX11 *screen_x11 = GDK_SCREEN_X11 (screen);
+ GdkX11Screen *x11_screen = GDK_X11_SCREEN (screen);
XRectangle monitors[MAXFRAMEBUFFERS];
unsigned char hints[16];
gint result;
return FALSE;
}
- screen_x11->monitors = g_new0 (GdkX11Monitor, n_monitors);
- screen_x11->n_monitors = n_monitors;
+ x11_screen->monitors = g_new0 (GdkX11Monitor, n_monitors);
+ x11_screen->n_monitors = n_monitors;
for (i = 0; i < n_monitors; i++)
{
- init_monitor_geometry (&screen_x11->monitors[i],
+ init_monitor_geometry (&x11_screen->monitors[i],
monitors[i].x, monitors[i].y,
monitors[i].width, monitors[i].height);
}
- screen_x11->primary_monitor = 0;
+ x11_screen->primary_monitor = 0;
return TRUE;
#endif /* HAVE_SOLARIS_XINERAMA */
{
#ifdef HAVE_XFREE_XINERAMA
Display *dpy = GDK_SCREEN_XDISPLAY (screen);
- GdkScreenX11 *screen_x11 = GDK_SCREEN_X11 (screen);
+ GdkX11Screen *x11_screen = GDK_X11_SCREEN (screen);
XineramaScreenInfo *monitors;
int i, n_monitors;
return FALSE;
}
- screen_x11->n_monitors = n_monitors;
- screen_x11->monitors = g_new0 (GdkX11Monitor, n_monitors);
+ x11_screen->n_monitors = n_monitors;
+ x11_screen->monitors = g_new0 (GdkX11Monitor, n_monitors);
for (i = 0; i < n_monitors; ++i)
{
- init_monitor_geometry (&screen_x11->monitors[i],
+ init_monitor_geometry (&x11_screen->monitors[i],
monitors[i].x_org, monitors[i].y_org,
monitors[i].width, monitors[i].height);
}
XFree (monitors);
- screen_x11->primary_monitor = 0;
+ x11_screen->primary_monitor = 0;
return TRUE;
#endif /* HAVE_XFREE_XINERAMA */
return FALSE;
}
+static gboolean
+init_solaris_xinerama_indices (GdkX11Screen *x11_screen)
+{
+#ifdef HAVE_SOLARIS_XINERAMA
+ XRectangle x_monitors[MAXFRAMEBUFFERS];
+ unsigned char hints[16];
+ gint result;
+ gint monitor_num;
+ gint x_n_monitors;
+ gint i;
+
+ if (!XineramaGetState (x11_screen->xdisplay, x11_screen->screen_num))
+ return FALSE;
+
+ result = XineramaGetInfo (x11_screen->xdisplay, x11_screen->screen_num,
+ x_monitors, hints, &x_n_monitors);
+
+ if (result == 0)
+ return FALSE;
+
+
+ for (monitor_num = 0; monitor_num < x11_screen->n_monitors; ++monitor_num)
+ {
+ for (i = 0; i < x_n_monitors; ++i)
+ {
+ if (x11_screen->monitors[monitor_num].geometry.x == x_monitors[i].x &&
+ x11_screen->monitors[monitor_num].geometry.y == x_monitors[i].y &&
+ x11_screen->monitors[monitor_num].geometry.width == x_monitors[i].width &&
+ x11_screen->monitors[monitor_num].geometry.height == x_monitors[i].height)
+ {
+ g_hash_table_insert (x11_screen->xinerama_matches,
+ GINT_TO_POINTER (monitor_num),
+ GINT_TO_POINTER (i));
+ }
+ }
+ }
+ return TRUE;
+#endif /* HAVE_SOLARIS_XINERAMA */
+
+ return FALSE;
+}
+
+static gboolean
+init_xfree_xinerama_indices (GdkX11Screen *x11_screen)
+{
+#ifdef HAVE_XFREE_XINERAMA
+ XineramaScreenInfo *x_monitors;
+ gint monitor_num;
+ gint x_n_monitors;
+ gint i;
+
+ if (!XineramaIsActive (x11_screen->xdisplay))
+ return FALSE;
+
+ x_monitors = XineramaQueryScreens (x11_screen->xdisplay, &x_n_monitors);
+ if (x_n_monitors <= 0 || x_monitors == NULL)
+ {
+ if (x_monitors)
+ XFree (x_monitors);
+
+ return FALSE;
+ }
+
+ for (monitor_num = 0; monitor_num < x11_screen->n_monitors; ++monitor_num)
+ {
+ for (i = 0; i < x_n_monitors; ++i)
+ {
+ if (x11_screen->monitors[monitor_num].geometry.x == x_monitors[i].x_org &&
+ x11_screen->monitors[monitor_num].geometry.y == x_monitors[i].y_org &&
+ x11_screen->monitors[monitor_num].geometry.width == x_monitors[i].width &&
+ x11_screen->monitors[monitor_num].geometry.height == x_monitors[i].height)
+ {
+ g_hash_table_insert (x11_screen->xinerama_matches,
+ GINT_TO_POINTER (monitor_num),
+ GINT_TO_POINTER (i));
+ }
+ }
+ }
+ XFree (x_monitors);
+ return TRUE;
+#endif /* HAVE_XFREE_XINERAMA */
+
+ return FALSE;
+}
+
+static void
+init_xinerama_indices (GdkX11Screen *x11_screen)
+{
+ int opcode, firstevent, firsterror;
+
+ x11_screen->xinerama_matches = g_hash_table_new (g_direct_hash, g_direct_equal);
+ if (XQueryExtension (x11_screen->xdisplay, "XINERAMA",
+ &opcode, &firstevent, &firsterror))
+ {
+ x11_screen->xinerama_matches = g_hash_table_new (g_direct_hash, g_direct_equal);
+
+ /* Solaris Xinerama first, then XFree/Xorg Xinerama
+ * to match the order in init_multihead()
+ */
+ if (init_solaris_xinerama_indices (x11_screen) == FALSE)
+ init_xfree_xinerama_indices (x11_screen);
+ }
+}
+
+gint
+_gdk_x11_screen_get_xinerama_index (GdkScreen *screen,
+ gint monitor_num)
+{
+ GdkX11Screen *x11_screen = GDK_X11_SCREEN (screen);
+ gpointer val;
+
+ g_return_val_if_fail (monitor_num < x11_screen->n_monitors, -1);
+
+ if (x11_screen->xinerama_matches == NULL)
+ init_xinerama_indices (x11_screen);
+
+ if (g_hash_table_lookup_extended (x11_screen->xinerama_matches, GINT_TO_POINTER (monitor_num), NULL, &val))
+ return (GPOINTER_TO_INT(val));
+
+ return -1;
+}
+
+void
+_gdk_x11_screen_get_edge_monitors (GdkScreen *screen,
+ gint *top,
+ gint *bottom,
+ gint *left,
+ gint *right)
+{
+ GdkX11Screen *x11_screen = GDK_X11_SCREEN (screen);
+ gint top_most_pos = HeightOfScreen (GDK_X11_SCREEN (screen)->xscreen);
+ gint left_most_pos = WidthOfScreen (GDK_X11_SCREEN (screen)->xscreen);
+ gint bottom_most_pos = 0;
+ gint right_most_pos = 0;
+ gint monitor_num;
+
+ for (monitor_num = 0; monitor_num < x11_screen->n_monitors; monitor_num++)
+ {
+ gint monitor_x = x11_screen->monitors[monitor_num].geometry.x;
+ gint monitor_y = x11_screen->monitors[monitor_num].geometry.y;
+ gint monitor_max_x = monitor_x + x11_screen->monitors[monitor_num].geometry.width;
+ gint monitor_max_y = monitor_y + x11_screen->monitors[monitor_num].geometry.height;
+
+ if (left && left_most_pos > monitor_x)
+ {
+ left_most_pos = monitor_x;
+ *left = monitor_num;
+ }
+ if (right && right_most_pos < monitor_max_x)
+ {
+ right_most_pos = monitor_max_x;
+ *right = monitor_num;
+ }
+ if (top && top_most_pos > monitor_y)
+ {
+ top_most_pos = monitor_y;
+ *top = monitor_num;
+ }
+ if (bottom && bottom_most_pos < monitor_max_y)
+ {
+ bottom_most_pos = monitor_max_y;
+ *bottom = monitor_num;
+ }
+ }
+}
+
static void
deinit_multihead (GdkScreen *screen)
{
- GdkScreenX11 *screen_x11 = GDK_SCREEN_X11 (screen);
+ GdkX11Screen *x11_screen = GDK_X11_SCREEN (screen);
- free_monitors (screen_x11->monitors, screen_x11->n_monitors);
+ free_monitors (x11_screen->monitors, x11_screen->n_monitors);
+ g_clear_pointer (&x11_screen->xinerama_matches, g_hash_table_destroy);
- screen_x11->n_monitors = 0;
- screen_x11->monitors = NULL;
+ x11_screen->n_monitors = 0;
+ x11_screen->monitors = NULL;
}
static gboolean
static void
init_multihead (GdkScreen *screen)
{
- GdkScreenX11 *screen_x11 = GDK_SCREEN_X11 (screen);
+ GdkX11Screen *x11_screen = GDK_X11_SCREEN (screen);
int opcode, firstevent, firsterror;
/* There are four different implementations of multihead support:
}
/* No multihead support of any kind for this screen */
- screen_x11->n_monitors = 1;
- screen_x11->monitors = g_new0 (GdkX11Monitor, 1);
- screen_x11->primary_monitor = 0;
+ x11_screen->n_monitors = 1;
+ x11_screen->monitors = g_new0 (GdkX11Monitor, 1);
+ x11_screen->primary_monitor = 0;
- init_monitor_geometry (screen_x11->monitors, 0, 0,
- WidthOfScreen (screen_x11->xscreen),
- HeightOfScreen (screen_x11->xscreen));
+ init_monitor_geometry (x11_screen->monitors, 0, 0,
+ WidthOfScreen (x11_screen->xscreen),
+ HeightOfScreen (x11_screen->xscreen));
}
GdkScreen *
gint screen_number)
{
GdkScreen *screen;
- GdkScreenX11 *screen_x11;
- GdkX11Display *display_x11 = GDK_DISPLAY_X11 (display);
-
- screen = g_object_new (GDK_TYPE_SCREEN_X11, NULL);
-
- screen_x11 = GDK_SCREEN_X11 (screen);
- screen_x11->display = display;
- screen_x11->xdisplay = display_x11->xdisplay;
- screen_x11->xscreen = ScreenOfDisplay (display_x11->xdisplay, screen_number);
- screen_x11->screen_num = screen_number;
- screen_x11->xroot_window = RootWindow (display_x11->xdisplay,screen_number);
- screen_x11->wmspec_check_window = None;
+ GdkX11Screen *x11_screen;
+ GdkX11Display *display_x11 = GDK_X11_DISPLAY (display);
+
+ screen = g_object_new (GDK_TYPE_X11_SCREEN, NULL);
+
+ x11_screen = GDK_X11_SCREEN (screen);
+ x11_screen->display = display;
+ x11_screen->xdisplay = display_x11->xdisplay;
+ x11_screen->xscreen = ScreenOfDisplay (display_x11->xdisplay, screen_number);
+ x11_screen->screen_num = screen_number;
+ x11_screen->xroot_window = RootWindow (display_x11->xdisplay,screen_number);
+ x11_screen->wmspec_check_window = None;
/* we want this to be always non-null */
- screen_x11->window_manager_name = g_strdup ("unknown");
+ x11_screen->window_manager_name = g_strdup ("unknown");
init_multihead (screen);
init_randr_support (screen);
void
_gdk_x11_screen_setup (GdkScreen *screen)
{
- GdkScreenX11 *screen_x11 = GDK_SCREEN_X11 (screen);
+ GdkX11Screen *x11_screen = GDK_X11_SCREEN (screen);
- screen_x11->cm_selection_atom = make_cm_atom (screen_x11->screen_num);
- gdk_display_request_selection_notification (screen_x11->display,
- screen_x11->cm_selection_atom);
- screen_x11->is_composited = check_is_composited (screen_x11->display, screen_x11);
+ gdk_display_request_selection_notification (x11_screen->display,
+ gdk_x11_xatom_to_atom_for_display (x11_screen->display, get_cm_atom (x11_screen)));
+ x11_screen->is_composited = check_is_composited (x11_screen->display, x11_screen);
}
static gboolean
-gdk_screen_x11_is_composited (GdkScreen *screen)
+gdk_x11_screen_is_composited (GdkScreen *screen)
{
- GdkScreenX11 *screen_x11;
+ GdkX11Screen *x11_screen = GDK_X11_SCREEN (screen);
- g_return_val_if_fail (GDK_IS_SCREEN (screen), FALSE);
-
- screen_x11 = GDK_SCREEN_X11 (screen);
-
- return screen_x11->is_composited;
+ return x11_screen->is_composited;
}
static void
-init_randr_support (GdkScreen * screen)
+init_randr_support (GdkScreen *screen)
{
- GdkScreenX11 *screen_x11 = GDK_SCREEN_X11 (screen);
-
+ GdkX11Screen *x11_screen = GDK_X11_SCREEN (screen);
+
+ /* NB: This is also needed for XSettings, so don't remove. */
XSelectInput (GDK_SCREEN_XDISPLAY (screen),
- screen_x11->xroot_window,
- StructureNotifyMask);
+ x11_screen->xroot_window,
+ StructureNotifyMask);
#ifdef HAVE_RANDR
+ if (!GDK_X11_DISPLAY (gdk_screen_get_display (screen))->have_randr12)
+ return;
+
XRRSelectInput (GDK_SCREEN_XDISPLAY (screen),
- screen_x11->xroot_window,
- RRScreenChangeNotifyMask |
- RRCrtcChangeNotifyMask |
- RROutputPropertyNotifyMask);
+ x11_screen->xroot_window,
+ RRScreenChangeNotifyMask
+ | RRCrtcChangeNotifyMask
+ | RROutputPropertyNotifyMask);
#endif
}
static void
process_monitors_change (GdkScreen *screen)
{
- GdkScreenX11 *screen_x11 = GDK_SCREEN_X11 (screen);
+ GdkX11Screen *x11_screen = GDK_X11_SCREEN (screen);
gint n_monitors;
+ gint primary_monitor;
GdkX11Monitor *monitors;
gboolean changed;
- n_monitors = screen_x11->n_monitors;
- monitors = screen_x11->monitors;
+ primary_monitor = x11_screen->primary_monitor;
+ n_monitors = x11_screen->n_monitors;
+ monitors = x11_screen->monitors;
- screen_x11->n_monitors = 0;
- screen_x11->monitors = NULL;
+ x11_screen->n_monitors = 0;
+ x11_screen->monitors = NULL;
init_multihead (screen);
- changed = !compare_monitors (monitors, n_monitors,
- screen_x11->monitors, screen_x11->n_monitors);
+ changed =
+ !compare_monitors (monitors, n_monitors,
+ x11_screen->monitors, x11_screen->n_monitors) ||
+ x11_screen->primary_monitor != primary_monitor;
+
free_monitors (monitors, n_monitors);
height = gdk_screen_get_height (screen);
#ifdef HAVE_RANDR
- display_x11 = GDK_DISPLAY_X11 (gdk_screen_get_display (screen));
+ display_x11 = GDK_X11_DISPLAY (gdk_screen_get_display (screen));
if (display_x11->have_randr13 && event->type == ConfigureNotify)
- {
- g_signal_emit_by_name (screen, "monitors-changed");
- return;
- }
+ return;
XRRUpdateConfiguration (event);
#else
{
#ifdef HAVE_XFIXES
XFixesSelectionNotifyEvent *selection_event = (XFixesSelectionNotifyEvent *)event;
- GdkScreenX11 *screen_x11 = GDK_SCREEN_X11 (screen);
- Atom xcm_selection_atom = gdk_x11_atom_to_xatom_for_display (screen_x11->display,
- screen_x11->cm_selection_atom);
+ GdkX11Screen *x11_screen = GDK_X11_SCREEN (screen);
- if (selection_event->selection == xcm_selection_atom)
+ if (selection_event->selection == get_cm_atom (x11_screen))
{
gboolean composited = selection_event->owner != None;
- if (composited != screen_x11->is_composited)
+ if (composited != x11_screen->is_composited)
{
- screen_x11->is_composited = composited;
+ x11_screen->is_composited = composited;
g_signal_emit_by_name (screen, "composited-changed");
}
}
static gchar *
-gdk_screen_x11_make_display_name (GdkScreen *screen)
+gdk_x11_screen_make_display_name (GdkScreen *screen)
{
const gchar *old_display;
- g_return_val_if_fail (GDK_IS_SCREEN (screen), NULL);
-
old_display = gdk_display_get_name (gdk_screen_get_display (screen));
return substitute_screen_number (old_display,
}
static GdkWindow *
-gdk_screen_x11_get_active_window (GdkScreen *screen)
+gdk_x11_screen_get_active_window (GdkScreen *screen)
{
- GdkScreenX11 *screen_x11;
+ GdkX11Screen *x11_screen = GDK_X11_SCREEN (screen);
GdkWindow *ret = NULL;
Atom type_return;
gint format_return;
gulong bytes_after_return;
guchar *data = NULL;
- g_return_val_if_fail (GDK_IS_SCREEN (screen), NULL);
-
if (!gdk_x11_screen_supports_net_wm_hint (screen,
gdk_atom_intern_static_string ("_NET_ACTIVE_WINDOW")))
return NULL;
- screen_x11 = GDK_SCREEN_X11 (screen);
-
- if (XGetWindowProperty (screen_x11->xdisplay, screen_x11->xroot_window,
- gdk_x11_get_xatom_by_name_for_display (screen_x11->display,
+ if (XGetWindowProperty (x11_screen->xdisplay, x11_screen->xroot_window,
+ gdk_x11_get_xatom_by_name_for_display (x11_screen->display,
"_NET_ACTIVE_WINDOW"),
0, 1, False, XA_WINDOW, &type_return,
&format_return, &nitems_return,
{
if ((type_return == XA_WINDOW) && (format_return == 32) && (data))
{
- GdkNativeWindow window = *(GdkNativeWindow *) data;
+ Window window = *(Window *) data;
if (window != None)
{
- ret = gdk_x11_window_foreign_new_for_display (screen_x11->display,
- *(Window *) data);
+ ret = gdk_x11_window_foreign_new_for_display (x11_screen->display,
+ window);
}
}
}
}
static GList *
-gdk_screen_x11_get_window_stack (GdkScreen *screen)
+gdk_x11_screen_get_window_stack (GdkScreen *screen)
{
- GdkScreenX11 *screen_x11;
+ GdkX11Screen *x11_screen = GDK_X11_SCREEN (screen);
GList *ret = NULL;
Atom type_return;
gint format_return;
gulong bytes_after_return;
guchar *data = NULL;
- g_return_val_if_fail (GDK_IS_SCREEN (screen), NULL);
-
if (!gdk_x11_screen_supports_net_wm_hint (screen,
gdk_atom_intern_static_string ("_NET_CLIENT_LIST_STACKING")))
return NULL;
- screen_x11 = GDK_SCREEN_X11 (screen);
-
- if (XGetWindowProperty (screen_x11->xdisplay, screen_x11->xroot_window,
- gdk_x11_get_xatom_by_name_for_display (screen_x11->display,
+ if (XGetWindowProperty (x11_screen->xdisplay, x11_screen->xroot_window,
+ gdk_x11_get_xatom_by_name_for_display (x11_screen->display,
"_NET_CLIENT_LIST_STACKING"),
0, G_MAXLONG, False, XA_WINDOW, &type_return,
&format_return, &nitems_return,
for (i = 0; i < nitems_return; i++)
{
- win = gdk_x11_window_foreign_new_for_display (screen_x11->display,
+ win = gdk_x11_window_foreign_new_for_display (x11_screen->display,
(Window)stack[i]);
if (win != NULL)
return ret;
}
-/* Sends a ClientMessage to all toplevel client windows */
-static gboolean
-gdk_event_send_client_message_to_all_recurse (GdkDisplay *display,
- XEvent *xev,
- guint32 xid,
- guint level)
-{
- Atom type = None;
- int format;
- unsigned long nitems, after;
- unsigned char *data;
- Window *ret_children, ret_root, ret_parent;
- unsigned int ret_nchildren;
- gboolean send = FALSE;
- gboolean found = FALSE;
- gboolean result = FALSE;
- int i;
-
- gdk_x11_display_error_trap_push (display);
-
- if (XGetWindowProperty (GDK_DISPLAY_XDISPLAY (display), xid,
- gdk_x11_get_xatom_by_name_for_display (display, "WM_STATE"),
- 0, 0, False, AnyPropertyType,
- &type, &format, &nitems, &after, &data) != Success)
- goto out;
-
- if (type)
- {
- send = TRUE;
- XFree (data);
- }
- else
- {
- /* OK, we're all set, now let's find some windows to send this to */
- if (!XQueryTree (GDK_DISPLAY_XDISPLAY (display), xid,
- &ret_root, &ret_parent,
- &ret_children, &ret_nchildren))
- goto out;
-
- for(i = 0; i < ret_nchildren; i++)
- if (gdk_event_send_client_message_to_all_recurse (display, xev, ret_children[i], level + 1))
- found = TRUE;
-
- XFree (ret_children);
- }
-
- if (send || (!found && (level == 1)))
- {
- xev->xclient.window = xid;
- _gdk_x11_display_send_xevent (display, xid, False, NoEventMask, xev);
- }
-
- result = send || found;
-
- out:
- gdk_x11_display_error_trap_pop_ignored (display);
-
- return result;
-}
-
-static void
-gdk_screen_x11_broadcast_client_message (GdkScreen *screen,
- GdkEvent *event)
-{
- XEvent sev;
- GdkWindow *root_window;
-
- g_return_if_fail (event != NULL);
-
- root_window = gdk_screen_get_root_window (screen);
-
- /* Set up our event to send, with the exception of its target window */
- sev.xclient.type = ClientMessage;
- sev.xclient.display = GDK_WINDOW_XDISPLAY (root_window);
- sev.xclient.format = event->client.data_format;
- memcpy(&sev.xclient.data, &event->client.data, sizeof (sev.xclient.data));
- sev.xclient.message_type =
- gdk_x11_atom_to_xatom_for_display (GDK_WINDOW_DISPLAY (root_window),
- event->client.message_type);
-
- gdk_event_send_client_message_to_all_recurse (gdk_screen_get_display (screen),
- &sev,
- GDK_WINDOW_XID (root_window),
- 0);
-}
-
static gboolean
-check_transform (const gchar *xsettings_name,
- GType src_type,
- GType dest_type)
-{
- if (!g_value_type_transformable (src_type, dest_type))
- {
- g_warning ("Cannot transform xsetting %s of type %s to type %s\n",
- xsettings_name,
- g_type_name (src_type),
- g_type_name (dest_type));
- return FALSE;
- }
- else
- return TRUE;
-}
-
-static gboolean
-gdk_screen_x11_get_setting (GdkScreen *screen,
+gdk_x11_screen_get_setting (GdkScreen *screen,
const gchar *name,
GValue *value)
{
+ GdkX11Screen *x11_screen = GDK_X11_SCREEN (screen);
+ const GValue *setting;
- const char *xsettings_name = NULL;
- XSettingsResult result;
- XSettingsSetting *setting = NULL;
- GdkScreenX11 *screen_x11;
- gboolean success = FALSE;
- gint i;
- GValue tmp_val = { 0, };
-
- g_return_val_if_fail (GDK_IS_SCREEN (screen), FALSE);
-
- screen_x11 = GDK_SCREEN_X11 (screen);
-
- for (i = 0; i < GDK_SETTINGS_N_ELEMENTS(); i++)
- if (strcmp (GDK_SETTINGS_GDK_NAME (i), name) == 0)
- {
- xsettings_name = GDK_SETTINGS_X_NAME (i);
- break;
- }
-
- if (!xsettings_name)
+ setting = _gdk_x11_xsettings_client_get_setting (x11_screen->xsettings_client, name);
+ if (setting == NULL)
goto out;
- result = xsettings_client_get_setting (screen_x11->xsettings_client,
- xsettings_name, &setting);
- if (result != XSETTINGS_SUCCESS)
- goto out;
-
- switch (setting->type)
+ if (!g_value_type_transformable (G_VALUE_TYPE (setting), G_VALUE_TYPE (value)))
{
- case XSETTINGS_TYPE_INT:
- if (check_transform (xsettings_name, G_TYPE_INT, G_VALUE_TYPE (value)))
- {
- g_value_init (&tmp_val, G_TYPE_INT);
- g_value_set_int (&tmp_val, setting->data.v_int);
- g_value_transform (&tmp_val, value);
-
- success = TRUE;
- }
- break;
- case XSETTINGS_TYPE_STRING:
- if (check_transform (xsettings_name, G_TYPE_STRING, G_VALUE_TYPE (value)))
- {
- g_value_init (&tmp_val, G_TYPE_STRING);
- g_value_set_string (&tmp_val, setting->data.v_string);
- g_value_transform (&tmp_val, value);
-
- success = TRUE;
- }
- break;
- case XSETTINGS_TYPE_COLOR:
- if (!check_transform (xsettings_name, GDK_TYPE_COLOR, G_VALUE_TYPE (value)))
- {
- GdkColor color;
-
- g_value_init (&tmp_val, GDK_TYPE_COLOR);
-
- color.pixel = 0;
- color.red = setting->data.v_color.red;
- color.green = setting->data.v_color.green;
- color.blue = setting->data.v_color.blue;
-
- g_value_set_boxed (&tmp_val, &color);
-
- g_value_transform (&tmp_val, value);
-
- success = TRUE;
- }
- break;
+ g_warning ("Cannot transform xsetting %s of type %s to type %s\n",
+ name,
+ g_type_name (G_VALUE_TYPE (setting)),
+ g_type_name (G_VALUE_TYPE (value)));
+ goto out;
}
- g_value_unset (&tmp_val);
+ g_value_transform (setting, value);
- out:
- if (setting)
- xsettings_setting_free (setting);
+ return TRUE;
- if (success)
- return TRUE;
- else
- return _gdk_x11_get_xft_setting (screen, name, value);
+ out:
+ return _gdk_x11_get_xft_setting (screen, name, value);
}
static void
g_free (supported_atoms);
}
-static void
-fetch_net_wm_check_window (GdkScreen *screen)
+static Window
+get_net_supporting_wm_check (GdkX11Screen *screen,
+ Window window)
{
- GdkScreenX11 *screen_x11;
GdkDisplay *display;
Atom type;
gint format;
gulong n_items;
gulong bytes_after;
guchar *data;
- Window *xwindow;
+ Window value;
+
+ display = screen->display;
+ type = None;
+ data = NULL;
+ value = None;
+
+ gdk_x11_display_error_trap_push (display);
+ XGetWindowProperty (screen->xdisplay, window,
+ gdk_x11_get_xatom_by_name_for_display (display, "_NET_SUPPORTING_WM_CHECK"),
+ 0, G_MAXLONG, False, XA_WINDOW, &type, &format,
+ &n_items, &bytes_after, &data);
+ gdk_x11_display_error_trap_pop_ignored (display);
+
+ if (type == XA_WINDOW)
+ value = *(Window *)data;
+
+ if (data)
+ XFree (data);
+
+ return value;
+}
+
+static void
+fetch_net_wm_check_window (GdkScreen *screen)
+{
+ GdkX11Screen *x11_screen;
+ GdkDisplay *display;
+ Window window;
GTimeVal tv;
gint error;
- screen_x11 = GDK_SCREEN_X11 (screen);
- display = screen_x11->display;
+ x11_screen = GDK_X11_SCREEN (screen);
+ display = x11_screen->display;
- g_return_if_fail (GDK_DISPLAY_X11 (display)->trusted_client);
-
- g_get_current_time (&tv);
+ g_return_if_fail (GDK_X11_DISPLAY (display)->trusted_client);
- if (ABS (tv.tv_sec - screen_x11->last_wmspec_check_time) < 15)
- return; /* we've checked recently */
+ if (x11_screen->wmspec_check_window != None)
+ return; /* already have it */
- screen_x11->last_wmspec_check_time = tv.tv_sec;
+ g_get_current_time (&tv);
- data = NULL;
- XGetWindowProperty (screen_x11->xdisplay, screen_x11->xroot_window,
- gdk_x11_get_xatom_by_name_for_display (display, "_NET_SUPPORTING_WM_CHECK"),
- 0, G_MAXLONG, False, XA_WINDOW, &type, &format,
- &n_items, &bytes_after, &data);
-
- if (type != XA_WINDOW)
- {
- if (data)
- XFree (data);
- return;
- }
+ if (ABS (tv.tv_sec - x11_screen->last_wmspec_check_time) < 15)
+ return; /* we've checked recently */
- xwindow = (Window *)data;
+ window = get_net_supporting_wm_check (x11_screen, x11_screen->xroot_window);
+ if (window == None)
+ return;
- if (screen_x11->wmspec_check_window == *xwindow)
- {
- XFree (xwindow);
- return;
- }
+ if (window != get_net_supporting_wm_check (x11_screen, window))
+ return;
gdk_x11_display_error_trap_push (display);
/* Find out if this WM goes away, so we can reset everything. */
- XSelectInput (screen_x11->xdisplay, *xwindow, StructureNotifyMask);
+ XSelectInput (x11_screen->xdisplay, window, StructureNotifyMask);
error = gdk_x11_display_error_trap_pop (display);
if (!error)
{
- screen_x11->wmspec_check_window = *xwindow;
- screen_x11->need_refetch_net_supported = TRUE;
- screen_x11->need_refetch_wm_name = TRUE;
+ /* We check the window property again because after XGetWindowProperty()
+ * and before XSelectInput() the window may have been recycled in such a
+ * way that XSelectInput() doesn't fail but the window is no longer what
+ * we want.
+ */
+ if (window != get_net_supporting_wm_check (x11_screen, window))
+ return;
+
+ x11_screen->wmspec_check_window = window;
+ x11_screen->last_wmspec_check_time = tv.tv_sec;
+ x11_screen->need_refetch_net_supported = TRUE;
+ x11_screen->need_refetch_wm_name = TRUE;
/* Careful, reentrancy */
- _gdk_x11_screen_window_manager_changed (GDK_SCREEN (screen_x11));
- }
- else if (error == BadWindow)
- {
- /* Leftover property, try again immediately, new wm may be starting up */
- screen_x11->last_wmspec_check_time = 0;
+ _gdk_x11_screen_window_manager_changed (screen);
}
-
- XFree (xwindow);
}
/**
* gdk_x11_screen_supports_net_wm_hint:
- * @screen: the relevant #GdkScreen.
+ * @screen: (type GdkX11Screen): the relevant #GdkScreen.
* @property: a property atom.
*
* This function is specific to the X11 backend of GDK, and indicates
GdkAtom property)
{
gulong i;
- GdkScreenX11 *screen_x11;
+ GdkX11Screen *x11_screen;
NetWmSupportedAtoms *supported_atoms;
GdkDisplay *display;
g_return_val_if_fail (GDK_IS_SCREEN (screen), FALSE);
- screen_x11 = GDK_SCREEN_X11 (screen);
- display = screen_x11->display;
+ x11_screen = GDK_X11_SCREEN (screen);
+ display = x11_screen->display;
- if (!G_LIKELY (GDK_DISPLAY_X11 (display)->trusted_client))
+ if (!G_LIKELY (GDK_X11_DISPLAY (display)->trusted_client))
return FALSE;
supported_atoms = g_object_get_data (G_OBJECT (screen), "gdk-net-wm-supported-atoms");
fetch_net_wm_check_window (screen);
- if (screen_x11->wmspec_check_window == None)
+ if (x11_screen->wmspec_check_window == None)
return FALSE;
- if (screen_x11->need_refetch_net_supported)
+ if (x11_screen->need_refetch_net_supported)
{
/* WM has changed since we last got the supported list,
* refetch it.
gint format;
gulong bytes_after;
- screen_x11->need_refetch_net_supported = FALSE;
+ x11_screen->need_refetch_net_supported = FALSE;
if (supported_atoms->atoms)
XFree (supported_atoms->atoms);
supported_atoms->atoms = NULL;
supported_atoms->n_atoms = 0;
- XGetWindowProperty (GDK_DISPLAY_XDISPLAY (display), screen_x11->xroot_window,
+ XGetWindowProperty (GDK_DISPLAY_XDISPLAY (display), x11_screen->xroot_window,
gdk_x11_get_xatom_by_name_for_display (display, "_NET_SUPPORTED"),
0, G_MAXLONG, False, XA_ATOM, &type, &format,
&supported_atoms->n_atoms, &bytes_after,
return FALSE;
}
-static void
-refcounted_grab_server (Display *xdisplay)
-{
- GdkDisplay *display = gdk_x11_lookup_xdisplay (xdisplay);
-
- gdk_x11_display_grab (display);
-}
-
-static void
-refcounted_ungrab_server (Display *xdisplay)
-{
- GdkDisplay *display = gdk_x11_lookup_xdisplay (xdisplay);
-
- gdk_x11_display_ungrab (display);
-}
-
-static GdkFilterReturn
-gdk_xsettings_client_event_filter (GdkXEvent *xevent,
- GdkEvent *event,
- gpointer data)
-{
- GdkScreenX11 *screen = data;
-
- if (xsettings_client_process_event (screen->xsettings_client, (XEvent *)xevent))
- return GDK_FILTER_REMOVE;
- else
- return GDK_FILTER_CONTINUE;
-}
-
-static Bool
-gdk_xsettings_watch_cb (Window window,
- Bool is_start,
- long mask,
- void *cb_data)
-{
- GdkWindow *gdkwin;
- GdkScreen *screen = cb_data;
-
- gdkwin = gdk_x11_window_lookup_for_display (gdk_screen_get_display (screen), window);
-
- if (is_start)
- {
- if (gdkwin)
- g_object_ref (gdkwin);
- else
- {
- gdkwin = gdk_x11_window_foreign_new_for_display (gdk_screen_get_display (screen), window);
-
- /* gdk_window_foreign_new_for_display() can fail and return NULL if the
- * window has already been destroyed.
- */
- if (!gdkwin)
- return False;
- }
-
- gdk_window_add_filter (gdkwin, gdk_xsettings_client_event_filter, screen);
- }
- else
- {
- if (!gdkwin)
- {
- /* gdkwin should not be NULL here, since if starting the watch succeeded
- * we have a reference on the window. It might mean that the caller didn't
- * remove the watch when it got a DestroyNotify event. Or maybe the
- * caller ignored the return value when starting the watch failed.
- */
- g_warning ("gdk_xsettings_watch_cb(): Couldn't find window to unwatch");
- return False;
- }
-
- gdk_window_remove_filter (gdkwin, gdk_xsettings_client_event_filter, screen);
- g_object_unref (gdkwin);
- }
-
- return True;
-}
-
-static void
-gdk_xsettings_notify_cb (const char *name,
- XSettingsAction action,
- XSettingsSetting *setting,
- void *data)
-{
- GdkEvent new_event;
- GdkScreen *screen = data;
- GdkScreenX11 *screen_x11 = data;
- int i;
-
- if (screen_x11->xsettings_in_init)
- return;
-
- new_event.type = GDK_SETTING;
- new_event.setting.window = gdk_screen_get_root_window (screen);
- new_event.setting.send_event = FALSE;
- new_event.setting.name = NULL;
-
- for (i = 0; i < GDK_SETTINGS_N_ELEMENTS() ; i++)
- if (strcmp (GDK_SETTINGS_X_NAME (i), name) == 0)
- {
- new_event.setting.name = (char*) GDK_SETTINGS_GDK_NAME (i);
- break;
- }
-
- if (!new_event.setting.name)
- return;
-
- switch (action)
- {
- case XSETTINGS_ACTION_NEW:
- new_event.setting.action = GDK_SETTING_ACTION_NEW;
- break;
- case XSETTINGS_ACTION_CHANGED:
- new_event.setting.action = GDK_SETTING_ACTION_CHANGED;
- break;
- case XSETTINGS_ACTION_DELETED:
- new_event.setting.action = GDK_SETTING_ACTION_DELETED;
- break;
- }
-
- gdk_event_put (&new_event);
-}
-
void
_gdk_x11_screen_init_events (GdkScreen *screen)
{
- GdkScreenX11 *screen_x11 = GDK_SCREEN_X11 (screen);
+ GdkX11Screen *x11_screen = GDK_X11_SCREEN (screen);
- /* Keep a flag to avoid extra notifies that we don't need
- */
- screen_x11->xsettings_in_init = TRUE;
- screen_x11->xsettings_client = xsettings_client_new_with_grab_funcs (screen_x11->xdisplay,
- screen_x11->screen_num,
- gdk_xsettings_notify_cb,
- gdk_xsettings_watch_cb,
- screen,
- refcounted_grab_server,
- refcounted_ungrab_server);
- screen_x11->xsettings_in_init = FALSE;
+ x11_screen->xsettings_client = _gdk_x11_xsettings_client_new (screen);
}
/**
* gdk_x11_screen_get_window_manager_name:
- * @screen: a #GdkScreen
+ * @screen: (type GdkX11Screen): a #GdkScreen
*
* Returns the name of the window manager for @screen.
*
const char*
gdk_x11_screen_get_window_manager_name (GdkScreen *screen)
{
- GdkScreenX11 *screen_x11;
+ GdkX11Screen *x11_screen;
GdkDisplay *display;
- screen_x11 = GDK_SCREEN_X11 (screen);
- display = screen_x11->display;
+ x11_screen = GDK_X11_SCREEN (screen);
+ display = x11_screen->display;
- if (!G_LIKELY (GDK_DISPLAY_X11 (display)->trusted_client))
- return screen_x11->window_manager_name;
+ if (!G_LIKELY (GDK_X11_DISPLAY (display)->trusted_client))
+ return x11_screen->window_manager_name;
fetch_net_wm_check_window (screen);
- if (screen_x11->need_refetch_wm_name)
+ if (x11_screen->need_refetch_wm_name)
{
/* Get the name of the window manager */
- screen_x11->need_refetch_wm_name = FALSE;
+ x11_screen->need_refetch_wm_name = FALSE;
- g_free (screen_x11->window_manager_name);
- screen_x11->window_manager_name = g_strdup ("unknown");
+ g_free (x11_screen->window_manager_name);
+ x11_screen->window_manager_name = g_strdup ("unknown");
- if (screen_x11->wmspec_check_window != None)
+ if (x11_screen->wmspec_check_window != None)
{
Atom type;
gint format;
gdk_x11_display_error_trap_push (display);
XGetWindowProperty (GDK_DISPLAY_XDISPLAY (display),
- screen_x11->wmspec_check_window,
+ x11_screen->wmspec_check_window,
gdk_x11_get_xatom_by_name_for_display (display,
"_NET_WM_NAME"),
0, G_MAXLONG, False,
if (name != NULL)
{
- g_free (screen_x11->window_manager_name);
- screen_x11->window_manager_name = g_strdup (name);
+ g_free (x11_screen->window_manager_name);
+ x11_screen->window_manager_name = g_strdup (name);
XFree (name);
}
}
}
- return GDK_SCREEN_X11 (screen)->window_manager_name;
+ return GDK_X11_SCREEN (screen)->window_manager_name;
}
static void
-_gdk_screen_x11_class_init (GdkScreenX11Class *klass)
+gdk_x11_screen_class_init (GdkX11ScreenClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
GdkScreenClass *screen_class = GDK_SCREEN_CLASS (klass);
- object_class->dispose = gdk_screen_x11_dispose;
- object_class->finalize = gdk_screen_x11_finalize;
-
- screen_class->get_display = gdk_screen_x11_get_display;
- screen_class->get_width = gdk_screen_x11_get_width;
- screen_class->get_height = gdk_screen_x11_get_height;
- screen_class->get_width_mm = gdk_screen_x11_get_width_mm;
- screen_class->get_height_mm = gdk_screen_x11_get_height_mm;
- screen_class->get_number = gdk_screen_x11_get_number;
- screen_class->get_root_window = gdk_screen_x11_get_root_window;
- screen_class->get_n_monitors = gdk_screen_x11_get_n_monitors;
- screen_class->get_primary_monitor = gdk_screen_x11_get_primary_monitor;
- screen_class->get_monitor_width_mm = gdk_screen_x11_get_monitor_width_mm;
- screen_class->get_monitor_height_mm = gdk_screen_x11_get_monitor_height_mm;
- screen_class->get_monitor_plug_name = gdk_screen_x11_get_monitor_plug_name;
- screen_class->get_monitor_geometry = gdk_screen_x11_get_monitor_geometry;
- screen_class->get_system_visual = _gdk_screen_x11_get_system_visual;
- screen_class->get_rgba_visual = gdk_screen_x11_get_rgba_visual;
- screen_class->is_composited = gdk_screen_x11_is_composited;
- screen_class->make_display_name = gdk_screen_x11_make_display_name;
- screen_class->get_active_window = gdk_screen_x11_get_active_window;
- screen_class->get_window_stack = gdk_screen_x11_get_window_stack;
- screen_class->broadcast_client_message = gdk_screen_x11_broadcast_client_message;
- screen_class->get_setting = gdk_screen_x11_get_setting;
- screen_class->visual_get_best_depth = _gdk_screen_x11_visual_get_best_depth;
- screen_class->visual_get_best_type = _gdk_screen_x11_visual_get_best_type;
- screen_class->visual_get_best = _gdk_screen_x11_visual_get_best;
- screen_class->visual_get_best_with_depth = _gdk_screen_x11_visual_get_best_with_depth;
- screen_class->visual_get_best_with_type = _gdk_screen_x11_visual_get_best_with_type;
- screen_class->visual_get_best_with_both = _gdk_screen_x11_visual_get_best_with_both;
- screen_class->query_depths = _gdk_screen_x11_query_depths;
- screen_class->query_visual_types = _gdk_screen_x11_query_visual_types;
- screen_class->list_visuals = _gdk_screen_x11_list_visuals;
+ object_class->dispose = gdk_x11_screen_dispose;
+ object_class->finalize = gdk_x11_screen_finalize;
+
+ screen_class->get_display = gdk_x11_screen_get_display;
+ screen_class->get_width = gdk_x11_screen_get_width;
+ screen_class->get_height = gdk_x11_screen_get_height;
+ screen_class->get_width_mm = gdk_x11_screen_get_width_mm;
+ screen_class->get_height_mm = gdk_x11_screen_get_height_mm;
+ screen_class->get_number = gdk_x11_screen_get_number;
+ screen_class->get_root_window = gdk_x11_screen_get_root_window;
+ screen_class->get_n_monitors = gdk_x11_screen_get_n_monitors;
+ screen_class->get_primary_monitor = gdk_x11_screen_get_primary_monitor;
+ screen_class->get_monitor_width_mm = gdk_x11_screen_get_monitor_width_mm;
+ screen_class->get_monitor_height_mm = gdk_x11_screen_get_monitor_height_mm;
+ screen_class->get_monitor_plug_name = gdk_x11_screen_get_monitor_plug_name;
+ screen_class->get_monitor_geometry = gdk_x11_screen_get_monitor_geometry;
+ screen_class->get_monitor_workarea = gdk_x11_screen_get_monitor_workarea;
+ screen_class->get_system_visual = _gdk_x11_screen_get_system_visual;
+ screen_class->get_rgba_visual = gdk_x11_screen_get_rgba_visual;
+ screen_class->is_composited = gdk_x11_screen_is_composited;
+ screen_class->make_display_name = gdk_x11_screen_make_display_name;
+ screen_class->get_active_window = gdk_x11_screen_get_active_window;
+ screen_class->get_window_stack = gdk_x11_screen_get_window_stack;
+ screen_class->get_setting = gdk_x11_screen_get_setting;
+ screen_class->visual_get_best_depth = _gdk_x11_screen_visual_get_best_depth;
+ screen_class->visual_get_best_type = _gdk_x11_screen_visual_get_best_type;
+ screen_class->visual_get_best = _gdk_x11_screen_visual_get_best;
+ screen_class->visual_get_best_with_depth = _gdk_x11_screen_visual_get_best_with_depth;
+ screen_class->visual_get_best_with_type = _gdk_x11_screen_visual_get_best_with_type;
+ screen_class->visual_get_best_with_both = _gdk_x11_screen_visual_get_best_with_both;
+ screen_class->query_depths = _gdk_x11_screen_query_depths;
+ screen_class->query_visual_types = _gdk_x11_screen_query_visual_types;
+ screen_class->list_visuals = _gdk_x11_screen_list_visuals;
signals[WINDOW_MANAGER_CHANGED] =
- g_signal_new (g_intern_static_string ("window_manager_changed"),
+ g_signal_new (g_intern_static_string ("window-manager-changed"),
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_LAST,
- G_STRUCT_OFFSET (GdkScreenX11Class, window_manager_changed),
+ G_STRUCT_OFFSET (GdkX11ScreenClass, window_manager_changed),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE,