callisto-debian/gtk2
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add RandR 1.2 support

Browse Source 
Thu Dec 13 13:14:50 2007  Søren Sandmann  <sandmann@redhat.com>

        * Add RandR 1.2 support

        - New monitors_changed signal - New API to get width/height of
          monitors, and the name of the plug



svn path=/trunk/; revision=19173
This commit is contained in:
Søren Sandmann
2007-12-13 18:27:05 +00:00
committed by Søren Sandmann Pedersen
parent 935d9a6574
commit 053cbe6daf
11 changed files with 500 additions and 205 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
ChangeLog
View File

@ -1,3 +1,10 @@
Thu Dec 13 13:14:50 2007 Søren Sandmann <sandmann@redhat.com>
* Add RandR 1.2 support
- New monitors_changed signal - New API to get width/height of
monitors, and the name of the plug
2007-12-13 Kristian Rietveld <kris@imendio.com> 2007-12-13 Kristian Rietveld <kris@imendio.com>
* gtk/tests/liststore.c: * gtk/tests/liststore.c:

13
configure.in
View File

@ -1325,19 +1325,10 @@ if test "x$gdktarget" = "xx11"; then
AM_CONDITIONAL(XINPUT_XFREE, test x$with_xinput = xxfree || test x$with_xinput = xyes) AM_CONDITIONAL(XINPUT_XFREE, test x$with_xinput = xxfree || test x$with_xinput = xyes)
# Check for the RANDR extension # Check for the RANDR extension
if $PKG_CONFIG --exists "xrandr >= 1.2" ; then
AC_DEFINE(HAVE_RANDR, 1, Have the Xrandr extension library)
have_randr=false
if $PKG_CONFIG --exists xrandr ; then
have_randr=true
X_PACKAGES="$X_PACKAGES xrandr" X_PACKAGES="$X_PACKAGES xrandr"
else
AC_CHECK_LIB(Xrandr, XRRUpdateConfiguration,
[AC_CHECK_HEADER(X11/extensions/Xrandr.h,
# RANDR requires RENDER
[have_randr=true
GTK_ADD_LIB(x_extra_libs, Xrender)
GTK_ADD_LIB(x_extra_libs, Xrandr)],
:, [#include <X11/Xlib.h>])])
fi fi
if $have_randr ; then if $have_randr ; then

4
gdk/gdk.symbols
View File

@ -1056,6 +1056,9 @@ gdk_screen_get_default_colormap
gdk_screen_set_default_colormap gdk_screen_set_default_colormap
gdk_screen_get_n_monitors gdk_screen_get_n_monitors
gdk_screen_get_monitor_geometry gdk_screen_get_monitor_geometry
gdk_screen_get_monitor_width_mm
gdk_screen_get_monitor_height_mm
gdk_screen_get_monitor_plug_name
gdk_screen_get_rgba_colormap gdk_screen_get_rgba_colormap
gdk_screen_get_rgba_visual gdk_screen_get_rgba_visual
gdk_screen_get_active_window gdk_screen_get_active_window
@ -1234,6 +1237,7 @@ gdk_x11_image_get_ximage
#if IN_FILE(__GDK_SCREEN_X11_C__) #if IN_FILE(__GDK_SCREEN_X11_C__)
gdk_x11_screen_get_screen_number gdk_x11_screen_get_screen_number
gdk_x11_screen_get_xscreen gdk_x11_screen_get_xscreen
gdk_x11_screen_get_monitor_output
#endif #endif
#if IN_FILE(__GDK_VISUAL_X11_C__) #if IN_FILE(__GDK_VISUAL_X11_C__)

23
gdk/gdkscreen.c
View File

@ -51,6 +51,7 @@ enum
{ {
SIZE_CHANGED, SIZE_CHANGED,
COMPOSITED_CHANGED, COMPOSITED_CHANGED,
MONITORS_CHANGED,
LAST_SIGNAL LAST_SIGNAL
}; };
@ -124,6 +125,28 @@ gdk_screen_class_init (GdkScreenClass *klass)
g_cclosure_marshal_VOID__VOID, g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, G_TYPE_NONE,
0); 0);
/**
* GdkScreen::monitors-changed:
* @screen: the object on which the signal is emitted
*
* The ::monitors_changed signal is emitted when the number, size
* or position of the monitors attached to the screen change.
*
* Only for X for now. Future implementations for Win32 and
* OS X may be a possibility.
*
* Since: 2.14
*/
signals[MONITORS_CHANGED] =
g_signal_new (g_intern_static_string ("monitors_changed"),
G_OBJECT_CLASS_TYPE (klass),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GdkScreenClass, monitors_changed),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE,
0);
} }
static void static void

7
gdk/gdkscreen.h
View File

@ -58,6 +58,7 @@ struct _GdkScreenClass
void (*size_changed) (GdkScreen *screen); void (*size_changed) (GdkScreen *screen);
void (*composited_changed) (GdkScreen *screen); void (*composited_changed) (GdkScreen *screen);
void (*monitors_changed) (GdkScreen *screen);
}; };
GType gdk_screen_get_type (void) G_GNUC_CONST; GType gdk_screen_get_type (void) G_GNUC_CONST;
@ -93,6 +94,12 @@ gint gdk_screen_get_monitor_at_point (GdkScreen *screen,
gint y); gint y);
gint gdk_screen_get_monitor_at_window (GdkScreen *screen, gint gdk_screen_get_monitor_at_window (GdkScreen *screen,
GdkWindow *window); GdkWindow *window);
gint gdk_screen_get_monitor_width_mm (GdkScreen *screen,
gint monitor_num);
gint gdk_screen_get_monitor_height_mm (GdkScreen *screen,
gint monitor_num);
gchar * gdk_screen_get_monitor_plug_name (GdkScreen *screen,
gint monitor_num);
void gdk_screen_broadcast_client_message (GdkScreen *screen, void gdk_screen_broadcast_client_message (GdkScreen *screen,
GdkEvent *event); GdkEvent *event);

19
gdk/x11/gdkdisplay-x11.c
View File

@ -62,6 +62,10 @@
#include <X11/extensions/Xdamage.h> #include <X11/extensions/Xdamage.h>
#endif #endif
#ifdef HAVE_RANDR
#include <X11/extensions/Xrandr.h>
#endif
static void gdk_display_x11_dispose (GObject *object); static void gdk_display_x11_dispose (GObject *object);
static void gdk_display_x11_finalize (GObject *object); static void gdk_display_x11_finalize (GObject *object);
@ -165,6 +169,21 @@ gdk_display_open (const gchar *display_name)
XAddConnectionWatch (xdisplay, gdk_internal_connection_watch, NULL); XAddConnectionWatch (xdisplay, gdk_internal_connection_watch, NULL);
#endif /* HAVE_X11R6 */ #endif /* HAVE_X11R6 */
/* RandR must be initialized before we initialize the screens */
display_x11->have_randr12 = FALSE;
#ifdef HAVE_RANDR
if (XRRQueryExtension (display_x11->xdisplay,
&display_x11->xrandr_event_base, &ignore))
{
int major, minor;
XRRQueryVersion (display_x11->xdisplay, &major, &minor);
if ((major == 1 && minor >= 2) || major > 1)
display_x11->have_randr12 = TRUE;
}
#endif
/* initialize the display's screens */ /* initialize the display's screens */
display_x11->screens = g_new (GdkScreen *, ScreenCount (display_x11->xdisplay)); display_x11->screens = g_new (GdkScreen *, ScreenCount (display_x11->xdisplay));
for (i = 0; i < ScreenCount (display_x11->xdisplay); i++) for (i = 0; i < ScreenCount (display_x11->xdisplay); i++)

3
gdk/x11/gdkdisplay-x11.h
View File

@ -85,6 +85,9 @@ struct _GdkDisplayX11
gboolean have_xdamage; gboolean have_xdamage;
gint xdamage_event_base; gint xdamage_event_base;
gboolean have_randr12;
gint xrandr_event_base;
/* If the SECURITY extension is in place, whether this client holds /* If the SECURITY extension is in place, whether this client holds
* a trusted authorization and so is allowed to make various requests * a trusted authorization and so is allowed to make various requests
* (grabs, properties etc.) Otherwise always TRUE. */ * (grabs, properties etc.) Otherwise always TRUE. */

14
gdk/x11/gdkevents-x11.c
View File

@ -58,6 +58,10 @@
#include <X11/extensions/Xfixes.h> #include <X11/extensions/Xfixes.h>
#endif #endif
#ifdef HAVE_RANDR
#include <X11/extensions/Xrandr.h>
#endif
#include <X11/Xatom.h> #include <X11/Xatom.h>
typedef struct _GdkIOClosure GdkIOClosure; typedef struct _GdkIOClosure GdkIOClosure;
@ -2102,6 +2106,16 @@ gdk_event_translate (GdkDisplay *display,
} }
else else
#endif #endif
#ifdef HAVE_RANDR
if (xevent->type - display_x11->xrandr_event_base == RRNotify)
{
XRRNotifyEvent *notify = (XRRNotifyEvent *)xevent;
if (screen)
_gdk_x11_screen_process_monitors_change (screen);
}
else
#endif
#if defined(HAVE_XCOMPOSITE) && defined (HAVE_XDAMAGE) && defined (HAVE_XFIXES) #if defined(HAVE_XCOMPOSITE) && defined (HAVE_XDAMAGE) && defined (HAVE_XFIXES)
if (display_x11->have_xdamage && window_private && window_private->composited && if (display_x11->have_xdamage && window_private && window_private->composited &&
xevent->type == display_x11->xdamage_event_base + XDamageNotify && xevent->type == display_x11->xdamage_event_base + XDamageNotify &&

599
gdk/x11/gdkscreen-x11.c
View File

@ -53,8 +53,8 @@
static void gdk_screen_x11_dispose (GObject *object); static void gdk_screen_x11_dispose (GObject *object);
static void gdk_screen_x11_finalize (GObject *object); static void gdk_screen_x11_finalize (GObject *object);
static void init_xinerama_support (GdkScreen *screen);
static void init_randr_support (GdkScreen *screen); static void init_randr_support (GdkScreen *screen);
static void deinit_multihead (GdkScreen *screen);
enum enum
{ {
@ -66,6 +66,16 @@ static guint signals[LAST_SIGNAL] = { 0 };
G_DEFINE_TYPE (GdkScreenX11, _gdk_screen_x11, GDK_TYPE_SCREEN) G_DEFINE_TYPE (GdkScreenX11, _gdk_screen_x11, GDK_TYPE_SCREEN)
struct _GdkX11Monitor
{
GdkRectangle geometry;
XID output;
int width_mm;
int height_mm;
char * output_name;
char * manufacturer;
};
static void static void
_gdk_screen_x11_class_init (GdkScreenX11Class *klass) _gdk_screen_x11_class_init (GdkScreenX11Class *klass)
{ {
@ -321,7 +331,7 @@ gdk_screen_x11_finalize (GObject *object)
g_hash_table_destroy (screen_x11->colormap_hash); g_hash_table_destroy (screen_x11->colormap_hash);
g_free (screen_x11->monitors); deinit_multihead (GDK_SCREEN (object));
G_OBJECT_CLASS (_gdk_screen_x11_parent_class)->finalize (object); G_OBJECT_CLASS (_gdk_screen_x11_parent_class)->finalize (object);
} }
@ -341,7 +351,100 @@ gdk_screen_get_n_monitors (GdkScreen *screen)
{ {
g_return_val_if_fail (GDK_IS_SCREEN (screen), 0); g_return_val_if_fail (GDK_IS_SCREEN (screen), 0);
return GDK_SCREEN_X11 (screen)->num_monitors; return GDK_SCREEN_X11 (screen)->n_monitors;
}
static GdkX11Monitor *
get_monitor (GdkScreen *screen,
int monitor_num)
{
GdkScreenX11 *screen_x11;
g_return_val_if_fail (GDK_IS_SCREEN (screen), NULL);
screen_x11 = GDK_SCREEN_X11 (screen);
g_return_val_if_fail (monitor_num < screen_x11->n_monitors, NULL);
g_return_val_if_fail (monitor_num >= 0, NULL);
return &(screen_x11->monitors[monitor_num]);
}
/**
* gdk_screen_get_monitor_width_mm:
* @screen: a #GdkScreen
* @monitor_num: number of the monitor
*
* Gets the width in millimeters of the specified monitor, if available.
*
* Returns the width of the monitor, or -1 if not available;
*
* Since: 2.14
*/
gint
gdk_screen_get_monitor_width_mm (GdkScreen *screen,
gint monitor_num)
{
return get_monitor (screen, monitor_num)->width_mm;
}
/**
* gdk_screen_get_monitor_height_mm:
* @screen: a #GdkScreen
* @monitor_num: number of the monitor
*
* Gets the height in millimeters of the specified monitor.
*
* Returns: the height of the monitor
*
* Since: 2.14
*/
gint
gdk_screen_get_monitor_height_mm (GdkScreen *screen,
gint monitor_num)
{
return get_monitor (screen, monitor_num)->height_mm;
}
/**
* gdk_screen_get_monitor_plug_name:
* @screen: a #GdkScreen
* @monitor_num: number of the monitor
*
* Returns the output name of the specified monitor.
* Usually something like VGA, DVI, or TV, not the actual
* product name of the display device.
*
* Returns: a newly-allocated string containing the name of the monitor,
* or %NULL if the name cannot be determined
*
* Since: 2.14
*/
gchar *
gdk_screen_get_monitor_plug_name (GdkScreen *screen,
gint monitor_num)
{
return g_strdup (get_monitor (screen, monitor_num)->output_name);
}
/**
* gdk_x11_screen_get_monitor_output:
* @screen: a #GdkScreen
* @monitor_num: number of the monitor
*
* Gets the XID of the specified output/monitor.
* If the X server does not support version 1.2 of the RANDR
* extension, 0 is returned.
*
* Returns: the XID of the monitor
*
* Since: 2.14
*/
XID
gdk_x11_screen_get_monitor_output (GdkScreen *screen,
gint monitor_num)
{
return get_monitor (screen, monitor_num)->output;
} }
/** /**
@ -363,11 +466,12 @@ gdk_screen_get_monitor_geometry (GdkScreen *screen,
gint monitor_num, gint monitor_num,
GdkRectangle *dest) GdkRectangle *dest)
{ {
g_return_if_fail (GDK_IS_SCREEN (screen)); if (dest)
g_return_if_fail (monitor_num < GDK_SCREEN_X11 (screen)->num_monitors); {
g_return_if_fail (monitor_num >= 0); GdkX11Monitor *monitor = get_monitor (screen, monitor_num);
*dest = GDK_SCREEN_X11 (screen)->monitors[monitor_num]; *dest = monitor->geometry;
}
} }
/** /**
@ -452,7 +556,6 @@ gdk_x11_screen_get_xscreen (GdkScreen *screen)
return GDK_SCREEN_X11 (screen)->xscreen; return GDK_SCREEN_X11 (screen)->xscreen;
} }
/** /**
* gdk_x11_screen_get_screen_number: * gdk_x11_screen_get_screen_number:
* @screen: a #GdkScreen. * @screen: a #GdkScreen.
@ -490,6 +593,287 @@ make_cm_atom (int screen_number)
return atom; return atom;
} }
static void
init_monitor_geometry (GdkX11Monitor *monitor,
int x, int y, int width, int height)
{
monitor->geometry.x = x;
monitor->geometry.y = y;
monitor->geometry.width = width;
monitor->geometry.height = height;
monitor->output = None;
monitor->width_mm = -1;
monitor->height_mm = -1;
monitor->output_name = NULL;
monitor->manufacturer = NULL;
}
static gboolean
init_fake_xinerama (GdkScreen *screen)
{
#ifdef G_ENABLE_DEBUG
GdkScreenX11 *screen_x11 = GDK_SCREEN_X11 (screen);
XSetWindowAttributes atts;
Window win;
gint w, h;
if (!(_gdk_debug_flags & GDK_DEBUG_XINERAMA))
return FALSE;
/* 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);
atts.override_redirect = 1;
atts.background_pixel = WhitePixel(GDK_SCREEN_XDISPLAY (screen),
screen_x11->screen_num);
win = XCreateWindow(GDK_SCREEN_XDISPLAY (screen),
screen_x11->xroot_window, 0, h / 2, w, 1, 0,
DefaultDepth(GDK_SCREEN_XDISPLAY (screen),
screen_x11->screen_num),
InputOutput,
DefaultVisual(GDK_SCREEN_XDISPLAY (screen),
screen_x11->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,
DefaultDepth(GDK_SCREEN_XDISPLAY (screen),
screen_x11->screen_num),
InputOutput,
DefaultVisual(GDK_SCREEN_XDISPLAY (screen),
screen_x11->screen_num),
CWOverrideRedirect|CWBackPixel,
&atts);
XMapRaised(GDK_SCREEN_XDISPLAY (screen), win);
return TRUE;
#endif
return FALSE;
}
static gboolean
init_randr12 (GdkScreen *screen)
{
#ifdef HAVE_RANDR
GdkDisplay *display = gdk_screen_get_display (screen);
GdkDisplayX11 *display_x11 = GDK_DISPLAY_X11 (display);
GdkScreenX11 *screen_x11 = GDK_SCREEN_X11 (screen);
Display *dpy = GDK_SCREEN_XDISPLAY (screen);
XRRScreenResources *resources;
int i;
GArray *monitors;
if (!display_x11->have_randr12)
return FALSE;
monitors = g_array_new (TRUE, TRUE, sizeof (GdkX11Monitor));
resources = XRRGetScreenResources (screen_x11->xdisplay,
screen_x11->xroot_window);
/* FIXME: can GetScreenResources return NULL except when it's out of memory? */
for (i = 0; i < resources->noutput; ++i)
{
XRROutputInfo *output =
XRRGetOutputInfo (dpy, resources, resources->outputs[i]);
if (output->crtc)
{
GdkX11Monitor monitor;
XRRCrtcInfo *crtc = XRRGetCrtcInfo (dpy, resources, output->crtc);
monitor.geometry.x = crtc->x;
monitor.geometry.y = crtc->y;
monitor.geometry.width = crtc->width;
monitor.geometry.height = crtc->height;
/* FIXME: fill this out properly - need EDID parser */
monitor.output = resources->outputs[i];
monitor.width_mm = -1;
monitor.height_mm = -1;
monitor.output_name = NULL;
monitor.manufacturer = NULL;
g_array_append_val (monitors, monitor);
}
XRRFreeOutputInfo (output);
}
screen_x11->n_monitors = monitors->len;
screen_x11->monitors = (GdkX11Monitor *)g_array_free (monitors, FALSE);
return TRUE;
#endif
return FALSE;
}
static gboolean
init_solaris_xinerama (GdkScreen *screen)
{
#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);
XRectangle monitors[MAXFRAMEBUFFERS];
unsigned char hints[16];
gint result;
int n_monitors;
int i;
if (!XineramaGetState (dpy, screen_no))
return FALSE;
result = XineramaGetInfo (dpy, screen_no, monitors, hints, &n_monitors);
/* Yes I know it should be Success but the current implementation
* returns the num of monitor
*/
if (result == 0)
{
/* FIXME: We need to trap errors, since
* XINERAMA isn't always XINERAMA.
*/
g_error ("error while retrieving Xinerama information");
}
screen_x11->monitors = g_new0 (GdkX11Monitor, n_rects);
screen_x11->n_monitors = n_rects;
for (i = 0; i < n_rects; i++)
{
init_monitor_geometry (&screen_x11->monitors[i],
rects[i].x, rects[i].y,
rects[i].width, rects[i].height);
}
return TRUE;
#endif /* HAVE_SOLARIS_XINERAMA */
return FALSE;
}
static gboolean
init_xfree_xinerama (GdkScreen *screen)
{
#ifdef HAVE_XFREE_XINERAMA
Display *dpy = GDK_SCREEN_XDISPLAY (screen);
GdkScreenX11 *screen_x11 = GDK_SCREEN_X11 (screen);
XineramaScreenInfo *monitors;
int i, n_monitors;
if (!XineramaIsActive (dpy))
return FALSE;
monitors = XineramaQueryScreens (dpy, &n_monitors);
if (n_monitors <= 0 || monitors == NULL)
{
/* If Xinerama doesn't think we have any monitors, try acting as
* though we had no Xinerama. If the "no monitors" condition
* is because XRandR 1.2 is currently switching between CRTCs,
* we'll be notified again when we have our monitor back,
* and can go back into Xinerama-ish mode at that point.
*/
if (monitors)
XFree (monitors);
return FALSE;
}
screen_x11->n_monitors = n_monitors;
screen_x11->monitors = g_new0 (GdkX11Monitor, n_monitors);
for (i = 0; i < n_monitors; ++i)
{
init_monitor_geometry (&screen_x11->monitors[i],
monitors[i].x_org, monitors[i].y_org,
monitors[i].width, monitors[i].height);
}
XFree (monitors);
return TRUE;
#endif /* HAVE_XFREE_XINERAMA */
return FALSE;
}
static void
deinit_multihead (GdkScreen *screen)
{
GdkScreenX11 *screen_x11 = GDK_SCREEN_X11 (screen);
int i;
for (i = 0; i < screen_x11->n_monitors; ++i)
{
GdkX11Monitor *monitor = get_monitor (screen, i);
g_free (monitor->output_name);
g_free (monitor->manufacturer);
}
g_free (screen_x11->monitors);
screen_x11->n_monitors = 0;
screen_x11->monitors = NULL;
}
static void
init_multihead (GdkScreen *screen)
{
GdkScreenX11 *screen_x11 = GDK_SCREEN_X11 (screen);
int opcode, firstevent, firsterror;
deinit_multihead (screen);
/* There are four different implementations of multihead support:
*
* 1. Fake Xinerama for debugging purposes
* 2. RandR 1.2
* 3. Solaris Xinerama
* 4. XFree86/Xorg Xinerama
*
* We use them in that order.
*/
if (init_fake_xinerama (screen))
return;
if (init_randr12 (screen))
return;
if (XQueryExtension (GDK_SCREEN_XDISPLAY (screen), "XINERAMA",
&opcode, &firstevent, &firsterror))
{
if (init_solaris_xinerama (screen))
return;
if (init_xfree_xinerama (screen))
return;
}
/* No multihead support of any kind for this screen */
screen_x11->n_monitors = 1;
screen_x11->monitors = g_new0 (GdkX11Monitor, 1);
init_monitor_geometry (screen_x11->monitors, 0, 0,
WidthOfScreen (screen_x11->xscreen),
HeightOfScreen (screen_x11->xscreen));
}
GdkScreen * GdkScreen *
_gdk_x11_screen_new (GdkDisplay *display, _gdk_x11_screen_new (GdkDisplay *display,
gint screen_number) gint screen_number)
@ -512,7 +896,7 @@ _gdk_x11_screen_new (GdkDisplay *display,
screen_x11->cm_selection_atom = make_cm_atom (screen_number); screen_x11->cm_selection_atom = make_cm_atom (screen_number);
screen_x11->is_composited = check_is_composited (display, screen_x11); screen_x11->is_composited = check_is_composited (display, screen_x11);
init_xinerama_support (screen); init_multihead (screen);
init_randr_support (screen); init_randr_support (screen);
_gdk_visual_init (screen); _gdk_visual_init (screen);
@ -549,185 +933,6 @@ gdk_screen_is_composited (GdkScreen *screen)
return screen_x11->is_composited; return screen_x11->is_composited;
} }
#ifdef HAVE_XINERAMA
static gboolean
check_solaris_xinerama (GdkScreen *screen)
{
#ifdef HAVE_SOLARIS_XINERAMA
if (XineramaGetState (GDK_SCREEN_XDISPLAY (screen),
gdk_screen_get_number (screen)))
{
XRectangle monitors[MAXFRAMEBUFFERS];
unsigned char hints[16];
gint result;
GdkScreenX11 *screen_x11 = GDK_SCREEN_X11 (screen);
result = XineramaGetInfo (GDK_SCREEN_XDISPLAY (screen),
gdk_screen_get_number (screen),
monitors, hints,
&screen_x11->num_monitors);
/* Yes I know it should be Success but the current implementation
returns the num of monitor*/
if (result == 0)
{
/* FIXME: We need to trap errors, since XINERAMA isn't always XINERAMA.
*/
g_error ("error while retrieving Xinerama information");
}
else
{
int i;
screen_x11->monitors = g_new0 (GdkRectangle, screen_x11->num_monitors);
for (i = 0; i < screen_x11->num_monitors; i++)
{
screen_x11->monitors[i].x = monitors[i].x;
screen_x11->monitors[i].y = monitors[i].y;
screen_x11->monitors[i].width = monitors[i].width;
screen_x11->monitors[i].height = monitors[i].height;
}
return TRUE;
}
}
#endif /* HAVE_SOLARIS_XINERAMA */
return FALSE;
}
static gboolean
check_xfree_xinerama (GdkScreen *screen)
{
#ifdef HAVE_XFREE_XINERAMA
if (XineramaIsActive (GDK_SCREEN_XDISPLAY (screen)))
{
GdkScreenX11 *screen_x11 = GDK_SCREEN_X11 (screen);
XineramaScreenInfo *monitors = XineramaQueryScreens (GDK_SCREEN_XDISPLAY (screen),
&screen_x11->num_monitors);
if (screen_x11->num_monitors <= 0 || monitors == NULL)
{
/* If Xinerama doesn't think we have any monitors, try acting as
* though we had no Xinerama. If the "no monitors" condition
* is because XRandR 1.2 is currently switching between CRTCs,
* we'll be notified again when we have our monitor back,
* and can go back into Xinerama-ish mode at that point. */
if (monitors)
XFree (monitors);
return FALSE;
}
else
{
int i;
screen_x11->monitors = g_new0 (GdkRectangle, screen_x11->num_monitors);
for (i = 0; i < screen_x11->num_monitors; i++)
{
screen_x11->monitors[i].x = monitors[i].x_org;
screen_x11->monitors[i].y = monitors[i].y_org;
screen_x11->monitors[i].width = monitors[i].width;
screen_x11->monitors[i].height = monitors[i].height;
}
XFree (monitors);
return TRUE;
}
}
#endif /* HAVE_XFREE_XINERAMA */
return FALSE;
}
#endif /* HAVE_XINERAMA */
static void
init_xinerama_support (GdkScreen * screen)
{
GdkScreenX11 *screen_x11 = GDK_SCREEN_X11 (screen);
#ifdef HAVE_XINERAMA
int opcode, firstevent, firsterror;
#endif
g_free (screen_x11->monitors);
#ifdef HAVE_XINERAMA
if (XQueryExtension (GDK_SCREEN_XDISPLAY (screen), "XINERAMA",
&opcode, &firstevent, &firsterror))
{
if (check_solaris_xinerama (screen) ||
check_xfree_xinerama (screen))
return;
}
#endif /* HAVE_XINERAMA */
/* No Xinerama
*/
#ifdef G_ENABLE_DEBUG
if (_gdk_debug_flags & GDK_DEBUG_XINERAMA)
{
/* Fake Xinerama mode by splitting the screen into 4 monitors.
* Also draw a little cross to make the monitor boundaries visible.
*/
XSetWindowAttributes atts;
Window win;
gint w, h;
w = WidthOfScreen (screen_x11->xscreen);
h = HeightOfScreen (screen_x11->xscreen);
screen_x11->num_monitors = 4;
screen_x11->monitors = g_new0 (GdkRectangle, 4);
screen_x11->monitors[0].x = 0;
screen_x11->monitors[0].y = 0;
screen_x11->monitors[0].width = w / 2;
screen_x11->monitors[0].height = h / 2;
screen_x11->monitors[1].x = w / 2;
screen_x11->monitors[1].y = 0;
screen_x11->monitors[1].width = w / 2;
screen_x11->monitors[1].height = h / 2;
screen_x11->monitors[2].x = 0;
screen_x11->monitors[2].y = h / 2;
screen_x11->monitors[2].width = w / 2;
screen_x11->monitors[2].height = h / 2;
screen_x11->monitors[3].x = w / 2;
screen_x11->monitors[3].y = h / 2;
screen_x11->monitors[3].width = w / 2;
screen_x11->monitors[3].height = h / 2;
atts.override_redirect = 1;
atts.background_pixel = WhitePixel(GDK_SCREEN_XDISPLAY (screen),
screen_x11->screen_num);
win = XCreateWindow(GDK_SCREEN_XDISPLAY (screen),
screen_x11->xroot_window, 0, h / 2, w, 1, 0,
DefaultDepth(GDK_SCREEN_XDISPLAY (screen),
screen_x11->screen_num),
InputOutput,
DefaultVisual(GDK_SCREEN_XDISPLAY (screen),
screen_x11->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,
DefaultDepth(GDK_SCREEN_XDISPLAY (screen),
screen_x11->screen_num),
InputOutput,
DefaultVisual(GDK_SCREEN_XDISPLAY (screen),
screen_x11->screen_num),
CWOverrideRedirect|CWBackPixel,
&atts);
XMapRaised(GDK_SCREEN_XDISPLAY (screen), win);
}
else
#endif
{
screen_x11->num_monitors = 1;
screen_x11->monitors = g_new0 (GdkRectangle, 1);
screen_x11->monitors[0].x = 0;
screen_x11->monitors[0].y = 0;
screen_x11->monitors[0].width = WidthOfScreen (screen_x11->xscreen);
screen_x11->monitors[0].height = HeightOfScreen (screen_x11->xscreen);
}
}
static void static void
init_randr_support (GdkScreen * screen) init_randr_support (GdkScreen * screen)
{ {
@ -736,6 +941,14 @@ init_randr_support (GdkScreen * screen)
XSelectInput (GDK_SCREEN_XDISPLAY (screen), XSelectInput (GDK_SCREEN_XDISPLAY (screen),
screen_x11->xroot_window, screen_x11->xroot_window,
StructureNotifyMask); StructureNotifyMask);
#ifdef HAVE_RANDR
XRRSelectInput (GDK_SCREEN_XDISPLAY (screen),
screen_x11->xroot_window,
RRScreenChangeNotifyMask |
RRCrtcChangeNotifyMask |
RROutputPropertyNotifyMask);
#endif
} }
void void
@ -758,10 +971,18 @@ _gdk_x11_screen_size_changed (GdkScreen *screen,
return; return;
#endif #endif
init_xinerama_support (screen); init_multihead (screen);
g_signal_emit_by_name (screen, "size_changed"); g_signal_emit_by_name (screen, "size_changed");
} }
void
_gdk_x11_screen_process_monitors_change (GdkScreen *screen)
{
init_multihead (screen);
g_signal_emit_by_name (screen, "monitors_changed");
}
void void
_gdk_x11_screen_window_manager_changed (GdkScreen *screen) _gdk_x11_screen_window_manager_changed (GdkScreen *screen)
{ {

9
gdk/x11/gdkscreen-x11.h
View File

@ -43,6 +43,8 @@ typedef struct _GdkScreenX11Class GdkScreenX11Class;
#define GDK_IS_SCREEN_X11_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_SCREEN_X11)) #define GDK_IS_SCREEN_X11_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_SCREEN_X11))
#define GDK_SCREEN_X11_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_SCREEN_X11, GdkScreenX11Class)) #define GDK_SCREEN_X11_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_SCREEN_X11, GdkScreenX11Class))
typedef struct _GdkX11Monitor GdkX11Monitor;
struct _GdkScreenX11 struct _GdkScreenX11
{ {
GdkScreen parent_instance; GdkScreen parent_instance;
@ -87,9 +89,9 @@ struct _GdkScreenX11
XSettingsClient *xsettings_client; XSettingsClient *xsettings_client;
guint xsettings_in_init : 1; guint xsettings_in_init : 1;
/* Xinerama */ /* Xinerama/RandR 1.2 */
gint num_monitors; gint n_monitors;
GdkRectangle *monitors; GdkX11Monitor *monitors;
/* Pango renderer object singleton */ /* Pango renderer object singleton */
PangoRenderer *renderer; PangoRenderer *renderer;
@ -124,6 +126,7 @@ void _gdk_x11_screen_size_changed (GdkScreen *screen,
XEvent *event); XEvent *event);
void _gdk_x11_screen_process_owner_change (GdkScreen *screen, void _gdk_x11_screen_process_owner_change (GdkScreen *screen,
XEvent *event); XEvent *event);
void _gdk_x11_screen_process_monitors_change (GdkScreen *screen);
G_END_DECLS G_END_DECLS

3
gdk/x11/gdkx.h
View File

@ -156,6 +156,9 @@ void gdk_x11_display_broadcast_startup_message (GdkDisplay *display,
gboolean gdk_x11_screen_supports_net_wm_hint (GdkScreen *screen, gboolean gdk_x11_screen_supports_net_wm_hint (GdkScreen *screen,
GdkAtom property); GdkAtom property);
XID gdk_x11_screen_get_monitor_output (GdkScreen *screen,
gint monitor_num);
#ifndef GDK_MULTIHEAD_SAFE #ifndef GDK_MULTIHEAD_SAFE
gpointer gdk_xid_table_lookup (XID xid); gpointer gdk_xid_table_lookup (XID xid);
gboolean gdk_net_wm_supports (GdkAtom property); gboolean gdk_net_wm_supports (GdkAtom property);