static void
meta_backend_x11_post_init (MetaBackend *backend)
{
MetaBackendX11 *x11 = META_BACKEND_X11 (backend);
MetaBackendX11Private *priv = meta_backend_x11_get_instance_private (x11);
int major, minor;
priv->xdisplay = clutter_x11_get_default_display ();
priv->source = x_event_source_new (backend);
if (!XSyncQueryExtension (priv->xdisplay, &priv->xsync_event_base, &priv->xsync_error_base) ||
!XSyncInitialize (priv->xdisplay, &major, &minor))
meta_fatal ("Could not initialize XSync");
{
int major = 2, minor = 3;
gboolean has_xi = FALSE;
if (XQueryExtension (priv->xdisplay,
"XInputExtension",
&priv->xinput_opcode,
&priv->xinput_error_base,
&priv->xinput_event_base))
{
if (XIQueryVersion (priv->xdisplay, &major, &minor) == Success)
{
int version = (major * 10) + minor;
if (version >= 22)
has_xi = TRUE;
}
}
if (!has_xi)
meta_fatal ("X server doesn't have the XInput extension, version 2.2 or newer\n");
}
take_touch_grab (backend);
priv->xcb = XGetXCBConnection (priv->xdisplay);
if (!xkb_x11_setup_xkb_extension (priv->xcb,
XKB_X11_MIN_MAJOR_XKB_VERSION,
XKB_X11_MIN_MINOR_XKB_VERSION,
XKB_X11_SETUP_XKB_EXTENSION_NO_FLAGS,
NULL, NULL,
&priv->xkb_event_base,
&priv->xkb_error_base))
meta_fatal ("X server doesn't have the XKB extension, version %d.%d or newer\n",
XKB_X11_MIN_MAJOR_XKB_VERSION, XKB_X11_MIN_MINOR_XKB_VERSION);
g_signal_connect_object (clutter_device_manager_get_default (), "device-added",
G_CALLBACK (on_device_added), backend, 0);
META_BACKEND_CLASS (meta_backend_x11_parent_class)->post_init (backend);
}
gboolean
meta_sync_ring_init (Display *xdisplay)
{
gint major, minor;
guint i;
MetaSyncRing *ring = meta_sync_ring_get ();
if (!ring)
return FALSE;
g_return_val_if_fail (xdisplay != NULL, FALSE);
g_return_val_if_fail (ring->xdisplay == NULL, FALSE);
if (!load_required_symbols ())
return FALSE;
if (!XSyncQueryExtension (xdisplay, &ring->xsync_event_base, &ring->xsync_error_base) ||
!XSyncInitialize (xdisplay, &major, &minor))
return FALSE;
XSyncIntToValue (&SYNC_VALUE_ZERO, 0);
XSyncIntToValue (&SYNC_VALUE_ONE, 1);
ring->xdisplay = xdisplay;
ring->alarm_to_sync = g_hash_table_new (NULL, NULL);
for (i = 0; i < NUM_SYNCS; ++i)
{
MetaSync *sync = meta_sync_new (ring->xdisplay);
ring->syncs_array[i] = sync;
g_hash_table_replace (ring->alarm_to_sync, (gpointer) sync->xalarm, sync);
}
/* Since the connection we create the X fences on isn't the same as
* the one used for the GLX context, we need to XSync() here to
* ensure glImportSync() succeeds. */
XSync (xdisplay, False);
for (i = 0; i < NUM_SYNCS; ++i)
meta_sync_import (ring->syncs_array[i]);
ring->current_sync_idx = 0;
ring->current_sync = ring->syncs_array[0];
ring->warmup_syncs = 0;
return TRUE;
}
static void
init_xsync (void)
{
#ifdef HAVE_XSYNC
{
int major, minor;
xsync->display = GDK_DISPLAY_XDISPLAY (gdk_display_get_default ());
xsync->have_xsync = FALSE;
xsync->sync_error_base = 0;
xsync->sync_event_base = 0;
/* I don't think we really have to fill these in */
major = SYNC_MAJOR_VERSION;
minor = SYNC_MINOR_VERSION;
if (!XSyncQueryExtension (xsync->display,
&xsync->sync_event_base,
&xsync->sync_error_base) ||
!XSyncInitialize (xsync->display,
&major, &minor))
{
xsync->sync_error_base = 0;
xsync->sync_event_base = 0;
}
else
{
xsync->have_xsync = TRUE;
XSyncSetPriority (xsync->display, None, 10);
}
meta_verbose ("Attempted to init Xsync, found version %d.%d error base %d event base %d\n",
major, minor,
xsync->sync_error_base,
xsync->sync_event_base);
}
#else /* HAVE_XSYNC */
meta_verbose ("Not compiled with Xsync support\n");
#endif /* !HAVE_XSYNC */
}
DisplayInfo *
myDisplayInit (GdkDisplay *gdisplay)
{
DisplayInfo *display;
int major, minor;
int dummy;
gchar *hostnametmp;
display = g_new0 (DisplayInfo, 1);
display->gdisplay = gdisplay;
display->dpy = (Display *) gdk_x11_display_get_xdisplay (gdisplay);
display->session = NULL;
display->quit = FALSE;
display->reload = FALSE;
XSetErrorHandler (handleXError);
/* Initialize internal atoms */
if (!myDisplayInitAtoms (display))
{
g_warning ("Some internal atoms were not properly created.");
}
/* Test XShape extension support */
major = 0;
minor = 0;
display->shape_version = 0;
if (XShapeQueryExtension (display->dpy,
&display->shape_event_base,
&dummy))
{
display->have_shape = TRUE;
if (XShapeQueryVersion (display->dpy, &major, &minor))
{
display->shape_version = major * 1000 + minor;
}
}
else
{
g_warning ("The display does not support the XShape extension.");
display->have_shape = FALSE;
display->shape_event_base = 0;
}
#ifdef HAVE_XSYNC
display->have_xsync = FALSE;
display->xsync_error_base = 0;
display->xsync_event_base = 0;
major = SYNC_MAJOR_VERSION;
minor = SYNC_MINOR_VERSION;
if (XSyncQueryExtension (display->dpy,
&display->xsync_event_base,
&display->xsync_error_base)
&& XSyncInitialize (display->dpy,
&major,
&minor))
{
display->have_xsync = TRUE;
}
else
{
g_warning ("The display does not support the XSync extension.");
display->have_xsync = FALSE;
display->xsync_event_base = 0;
display->xsync_error_base = 0;
}
#endif /* HAVE_XSYNC */
#ifdef HAVE_RENDER
if (XRenderQueryExtension (display->dpy,
&display->render_event_base,
&display->render_error_base))
{
display->have_render = TRUE;
}
else
{
g_warning ("The display does not support the XRender extension.");
display->have_render = FALSE;
display->render_event_base = 0;
display->render_error_base = 0;
}
#else /* HAVE_RENDER */
display->have_render = FALSE;
#endif /* HAVE_RENDER */
#ifdef HAVE_RANDR
if (XRRQueryExtension (display->dpy,
&display->xrandr_event_base,
&display->xrandr_error_base))
{
display->have_xrandr = TRUE;
}
else
{
g_warning ("The display does not support the XRandr extension.");
display->have_xrandr = FALSE;
display->xrandr_event_base = 0;
display->xrandr_error_base = 0;
}
#else /* HAVE_RANDR */
display->have_xrandr = FALSE;
#endif /* HAVE_RANDR */
myDisplayCreateCursor (display);
myDisplayCreateTimestampWin (display);
display->xfilter = NULL;
display->screens = NULL;
display->clients = NULL;
display->xgrabcount = 0;
display->double_click_time = 250;
display->double_click_distance = 5;
display->nb_screens = 0;
display->current_time = CurrentTime;
hostnametmp = g_new0 (gchar, (size_t) MAX_HOSTNAME_LENGTH + 1);
if (gethostname ((char *) hostnametmp, MAX_HOSTNAME_LENGTH))
{
g_warning ("The display's hostname could not be determined.");
display->hostname = NULL;
} else {
hostnametmp[MAX_HOSTNAME_LENGTH] = '\0';
display->hostname = g_strdup(hostnametmp);
}
g_free (hostnametmp);
compositorInitDisplay (display);
return display;
}
void Extensions::init()
{
int event_base, error_base;
data_nextensions = 0;
shape_version = 0;
if( XShapeQueryExtension( display(), &shape_event_base, &error_base ))
{
int major, minor;
if( XShapeQueryVersion( display(), &major, &minor ))
{
shape_version = major * 0x10 + minor;
addData( "SHAPE" );
}
}
#ifdef HAVE_XRANDR
has_randr = XRRQueryExtension( display(), &randr_event_base, &error_base );
if( has_randr )
{
int major, minor;
XRRQueryVersion( display(), &major, &minor );
has_randr = ( major > 1 || ( major == 1 && minor >= 1 ) );
addData( "RANDR" );
}
#else
has_randr = false;
#endif
#ifdef HAVE_XDAMAGE
has_damage = XDamageQueryExtension( display(), &damage_event_base, &error_base );
if( has_damage )
addData( "DAMAGE" );
#else
has_damage = false;
#endif
composite_version = 0;
#ifdef HAVE_XCOMPOSITE
if( XCompositeQueryExtension( display(), &event_base, &error_base ))
{
int major = 0, minor = 0;
XCompositeQueryVersion( display(), &major, &minor );
composite_version = major * 0x10 + minor;
addData( "Composite" );
}
#endif
fixes_version = 0;
#ifdef HAVE_XFIXES
if( XFixesQueryExtension( display(), &event_base, &error_base ))
{
int major = 0, minor = 0;
XFixesQueryVersion( display(), &major, &minor );
fixes_version = major * 0x10 + minor;
addData( "XFIXES" );
}
#endif
render_version = 0;
#ifdef HAVE_XRENDER
if( XRenderQueryExtension( display(), &event_base, &error_base ))
{
int major = 0, minor = 0;
XRenderQueryVersion( display(), &major, &minor );
render_version = major * 0x10 + minor;
addData( "RENDER" );
}
#endif
has_glx = false;
#ifdef HAVE_OPENGL
has_glx = glXQueryExtension( display(), &event_base, &error_base );
if( has_glx )
addData( "GLX" );
#endif
#ifdef HAVE_XSYNC
if( XSyncQueryExtension( display(), &sync_event_base, &error_base ))
{
int major = 0, minor = 0;
if( XSyncInitialize( display(), &major, &minor ))
{
has_sync = true;
addData( "SYNC" );
}
}
#endif
kDebug( 1212 ) << "Extensions: shape: 0x" << QString::number( shape_version, 16 )
<< " composite: 0x" << QString::number( composite_version, 16 )
<< " render: 0x" << QString::number( render_version, 16 )
<< " fixes: 0x" << QString::number( fixes_version, 16 ) << endl;
}
