/* function: queryextensions_x11display
* Initializes extension variables of <x11display_t>.
* It is expected that memory of all extension variables is set to zero
* before you call this function. */
static int queryextensions_x11display(x11display_t * x11disp)
{
int major ;
int minor ;
int dummy ;
Bool isSupported ;
isSupported = XQueryExtension(x11disp->sys_display, "DOUBLE-BUFFER", &dummy, &x11disp->xdbe.eventbase, &x11disp->xdbe.errorbase) ;
if (isSupported) {
isSupported = XdbeQueryExtension(x11disp->sys_display, &major, &minor) ;
if (isSupported) {
x11disp->xdbe.isSupported = true ;
x11disp->xdbe.version_major = (uint16_t) major ;
x11disp->xdbe.version_minor = (uint16_t) minor ;
}
}
isSupported = XQueryExtension(x11disp->sys_display, "RANDR", &dummy, &x11disp->xrandr.eventbase, &x11disp->xrandr.errorbase) ;
if (isSupported) {
isSupported = XRRQueryVersion(x11disp->sys_display, &major, &minor) ;
if (isSupported) {
x11disp->xrandr.isSupported = true ;
x11disp->xrandr.version_major = (uint16_t) major ;
x11disp->xrandr.version_minor = (uint16_t) minor ;
// prepare receiving events
for (int i = ScreenCount(x11disp->sys_display); (--i) >= 0 ;) {
XRRSelectInput(x11disp->sys_display, RootWindow(x11disp->sys_display,i), RRScreenChangeNotifyMask) ;
}
}
}
isSupported = XQueryExtension(x11disp->sys_display, "RENDER", &dummy, &x11disp->xrender.eventbase, &x11disp->xrender.errorbase) ;
if (isSupported) {
isSupported = XRenderQueryVersion(x11disp->sys_display, &major, &minor) ;
if (isSupported) {
x11disp->xrender.isSupported = true ;
x11disp->xrender.version_major = (uint16_t) major ;
x11disp->xrender.version_minor = (uint16_t) minor ;
}
}
return 0 ;
}
gboolean
init_composite (void)
{
Display *display;
display = gdk_x11_get_default_xdisplay ();
// First, check the Composite extension, then the Render extension.
int error_base;
int event_base;
int version_major;
int version_minor;
if (!XCompositeQueryExtension (display, &event_base, &error_base)) {
return FALSE;
}
// We need at least version 0.2, for XCompositeNameWindowPixmap.
XCompositeQueryVersion (display, &version_major, &version_minor);
if (version_major <= 0 && version_minor < 2) {
return FALSE;
}
if (!XRenderQueryExtension (display, &event_base, &error_base)) {
return FALSE;
}
// We need at least version 0.6, for XRenderSetPictureTransform.
XRenderQueryVersion (display, &version_major, &version_minor);
if (version_major <= 0 && version_minor < 6) {
return FALSE;
}
XCompositeRedirectSubwindows (display,
GDK_WINDOW_XWINDOW (gdk_get_default_root_window ()),
CompositeRedirectAutomatic);
return TRUE;
}
void
xsg_xrender_init(Display *dpy)
{
static bool ok = FALSE;
void *librender, *libcomposite;
int opcode = 0, event = 0, error = 0;
int major, minor;
if (ok) {
return;
} else {
ok = TRUE;
}
if ((librender = dlopen("libXrender.so", RTLD_LAZY | RTLD_LOCAL)) == NULL) {
xsg_error("Cannot open libXrender.so: %s", dlerror());
}
if ((libcomposite = dlopen("libXcomposite.so", RTLD_LAZY | RTLD_LOCAL)) == NULL) {
xsg_error("Cannot open libXcomposite.so: %s", dlerror());
}
if ((XRenderQueryExtension = (Bool (*)(Display *, int *, int *)) (intptr_t) dlsym(librender, "XRenderQueryExtension")) == NULL) {
xsg_error("Cannot find symbol XRenderQueryExtension: %s", dlerror());
}
if ((XRenderQueryVersion = (Status (*)(Display *, int *, int *)) (intptr_t) dlsym(librender, "XRenderQueryVersion")) == NULL) {
xsg_error("Cannot find symbol XRenderQueryVersion: %s", dlerror());
}
if ((XCompositeQueryExtension = (Bool (*)(Display *, int *, int *)) (intptr_t) dlsym(libcomposite, "XCompositeQueryExtension")) == NULL) {
xsg_error("Cannot find symbol XCompositeQueryExtension: %s", dlerror());
}
if ((XCompositeQueryVersion = (Status (*)(Display *, int *, int *)) (intptr_t) dlsym(libcomposite, "XCompositeQueryVersion")) == NULL) {
xsg_error("Cannot find symbol XCompositeQueryVersion: %s", dlerror());
}
if ((XRenderFindVisualFormat = (XRenderPictFormat *(*)(Display *, _Xconst Visual *)) (intptr_t) dlsym(librender, "XRenderFindVisualFormat")) == NULL) {
xsg_error("Cannot find symbol XRenderFindVisualFormat: %s", dlerror());
}
if ((XCompositeRedirectSubwindows = (void (*)(Display *, Window, int)) (intptr_t) dlsym(libcomposite, "XCompositeRedirectSubwindows")) == NULL) {
xsg_error("Cannot find symbol XCompositeRedirectSubwindows: %s", dlerror());
}
if ((XRenderFindStandardFormat = (XRenderPictFormat *(*)(Display *, int)) (intptr_t) dlsym(librender, "XRenderFindStandardFormat")) == NULL) {
xsg_error("Cannot find symbol XRenderFindStandardFormat: %s", dlerror());
}
if ((XRenderCreatePicture = (Picture (*)(Display *, Drawable, _Xconst XRenderPictFormat *, unsigned long, _Xconst XRenderPictureAttributes *)) (intptr_t) dlsym(librender, "XRenderCreatePicture")) == NULL) {
xsg_error("Cannot find symbol XRenderCreatePicture: %s", dlerror());
}
if ((XRenderComposite = (void (*)(Display *, int, Picture, Picture, Picture, int, int, int, int, int, int, unsigned int, unsigned int)) (intptr_t) dlsym(librender, "XRenderComposite")) == NULL) {
xsg_error("Cannot find symbol XRenderComposite: %s", dlerror());
}
if ((XRenderFreePicture = (void (*)(Display *, Picture)) (intptr_t) dlsym(librender, "XRenderFreePicture")) == NULL) {
xsg_error("Cannot find symbol XRenderFreePicture: %s", dlerror());
}
display = dpy;
if (!XQueryExtension(display, "RENDER", &opcode, &event, &error)) {
xsg_error("XQueryExtension RENDER failed: opcode=%d, event=%d, error=%d", opcode, event, error);
}
if (!XRenderQueryExtension(display, &event, &error)) {
xsg_error("XRenderQueryExtension failed: event=%d, error=%d", event, error);
}
XRenderQueryVersion(display, &major, &minor);
xsg_message("XRenderQueryVersion: %d.%d", major, minor);
if (!XQueryExtension(display, "Composite", &opcode, &event, &error)) {
xsg_error("XQueryExtension COMPOSITE failed: opcode=%d, event=%d, error=%d", opcode, event, error);
}
if (!XCompositeQueryExtension(display, &event, &error)) {
xsg_error("XCompositeQueryExtension failed: event=%d, error=%d", event, error);
}
XCompositeQueryVersion(display, &major, &minor);
xsg_message("XCompositeQueryVersion: %d.%d", major, minor);
}
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;
}
static void InitXLib()
{
for(sInt i=0;i<MAX_CLIPS;i++)
ClipStack[i] = XCreateRegion();
EmptyRegion = XCreateRegion();
UpdateRegion = XCreateRegion();
static const int shapeInd[] =
{
0,
XC_left_ptr,
XC_watch,
XC_crosshair,
XC_hand2,
XC_xterm,
XC_X_cursor,
XC_fleur,
XC_sb_v_double_arrow,
XC_sb_h_double_arrow,
XC_bottom_right_corner, // poor match!
XC_bottom_left_corner, // poor match!
};
Cursors[0] = 0;
for(sInt i=1;i<sMP_MAX;i++)
Cursors[i] = XCreateFontCursor(sXDisplay(),shapeInd[i]);
if(sGetSystemFlags() & sISF_2D)
{
XRenderColor rc;
XftColor blackColor;
sClear(rc);
rc.alpha = 0xffff;
XftColorAllocValue(sXDisplay(),sXVisual,sXColMap,&rc,&blackColor);
for(sInt i=0;i<MAX_COLORS;i++)
{
Color[i][0] = Color[i][1] = 0;
ColorXFT[i] = blackColor;
}
XDraw = XftDrawCreate(sXDisplay(),sXWnd,DefaultVisual(sXDisplay(),sXScreen),sXColMap);
if(!XDraw)
sFatal(L"XftDrawCreate failed!");
// initialize x render extension
int major,minor;
XRenderQueryVersion(sXDisplay(),&major,&minor);
sLogF(L"xlib",L"XRender %d.%d found\n",major,minor);
XRenderPictFormat *fmt = XRenderFindVisualFormat(sXDisplay(),sXVisual);
if(!fmt)
sFatal(L"XRenderFindVisualFormat failed on default visual!");
XRenderPictureAttributes attr;
attr.graphics_exposures = False;
XPict = XRenderCreatePicture(sXDisplay(),sXWnd,fmt,CPGraphicsExposure,&attr);
if(!XPict)
sFatal(L"XRenderCreatePicture for main picture failed!");
XFmtARGB = XRenderFindStandardFormat(sXDisplay(),PictStandardARGB32);
if(!XFmtARGB)
sFatal(L"XRenderFindStandardFormat failed on display!");
}
ForegroundCol = -1;
}
// Look for and initialize supported X11 extensions
//
static GLFWbool initExtensions(void)
{
_glfw.x11.vidmode.handle = _glfw_dlopen("libXxf86vm.so.1");
if (_glfw.x11.vidmode.handle)
{
_glfw.x11.vidmode.QueryExtension = (PFN_XF86VidModeQueryExtension)
_glfw_dlsym(_glfw.x11.vidmode.handle, "XF86VidModeQueryExtension");
_glfw.x11.vidmode.GetGammaRamp = (PFN_XF86VidModeGetGammaRamp)
_glfw_dlsym(_glfw.x11.vidmode.handle, "XF86VidModeGetGammaRamp");
_glfw.x11.vidmode.SetGammaRamp = (PFN_XF86VidModeSetGammaRamp)
_glfw_dlsym(_glfw.x11.vidmode.handle, "XF86VidModeSetGammaRamp");
_glfw.x11.vidmode.GetGammaRampSize = (PFN_XF86VidModeGetGammaRampSize)
_glfw_dlsym(_glfw.x11.vidmode.handle, "XF86VidModeGetGammaRampSize");
_glfw.x11.vidmode.available =
XF86VidModeQueryExtension(_glfw.x11.display,
&_glfw.x11.vidmode.eventBase,
&_glfw.x11.vidmode.errorBase);
}
#if defined(__CYGWIN__)
_glfw.x11.xi.handle = _glfw_dlopen("libXi-6.so");
#else
_glfw.x11.xi.handle = _glfw_dlopen("libXi.so.6");
#endif
if (_glfw.x11.xi.handle)
{
_glfw.x11.xi.QueryVersion = (PFN_XIQueryVersion)
_glfw_dlsym(_glfw.x11.xi.handle, "XIQueryVersion");
_glfw.x11.xi.SelectEvents = (PFN_XISelectEvents)
_glfw_dlsym(_glfw.x11.xi.handle, "XISelectEvents");
if (XQueryExtension(_glfw.x11.display,
"XInputExtension",
&_glfw.x11.xi.majorOpcode,
&_glfw.x11.xi.eventBase,
&_glfw.x11.xi.errorBase))
{
_glfw.x11.xi.major = 2;
_glfw.x11.xi.minor = 0;
if (XIQueryVersion(_glfw.x11.display,
&_glfw.x11.xi.major,
&_glfw.x11.xi.minor) == Success)
{
_glfw.x11.xi.available = GLFW_TRUE;
}
}
}
#if defined(__CYGWIN__)
_glfw.x11.randr.handle = _glfw_dlopen("libXrandr-2.so");
#else
_glfw.x11.randr.handle = _glfw_dlopen("libXrandr.so.2");
#endif
if (_glfw.x11.randr.handle)
{
_glfw.x11.randr.AllocGamma = (PFN_XRRAllocGamma)
_glfw_dlsym(_glfw.x11.randr.handle, "XRRAllocGamma");
_glfw.x11.randr.FreeGamma = (PFN_XRRFreeGamma)
_glfw_dlsym(_glfw.x11.randr.handle, "XRRFreeGamma");
_glfw.x11.randr.FreeCrtcInfo = (PFN_XRRFreeCrtcInfo)
_glfw_dlsym(_glfw.x11.randr.handle, "XRRFreeCrtcInfo");
_glfw.x11.randr.FreeGamma = (PFN_XRRFreeGamma)
_glfw_dlsym(_glfw.x11.randr.handle, "XRRFreeGamma");
_glfw.x11.randr.FreeOutputInfo = (PFN_XRRFreeOutputInfo)
_glfw_dlsym(_glfw.x11.randr.handle, "XRRFreeOutputInfo");
_glfw.x11.randr.FreeScreenResources = (PFN_XRRFreeScreenResources)
_glfw_dlsym(_glfw.x11.randr.handle, "XRRFreeScreenResources");
_glfw.x11.randr.GetCrtcGamma = (PFN_XRRGetCrtcGamma)
_glfw_dlsym(_glfw.x11.randr.handle, "XRRGetCrtcGamma");
_glfw.x11.randr.GetCrtcGammaSize = (PFN_XRRGetCrtcGammaSize)
_glfw_dlsym(_glfw.x11.randr.handle, "XRRGetCrtcGammaSize");
_glfw.x11.randr.GetCrtcInfo = (PFN_XRRGetCrtcInfo)
_glfw_dlsym(_glfw.x11.randr.handle, "XRRGetCrtcInfo");
_glfw.x11.randr.GetOutputInfo = (PFN_XRRGetOutputInfo)
_glfw_dlsym(_glfw.x11.randr.handle, "XRRGetOutputInfo");
_glfw.x11.randr.GetOutputPrimary = (PFN_XRRGetOutputPrimary)
_glfw_dlsym(_glfw.x11.randr.handle, "XRRGetOutputPrimary");
_glfw.x11.randr.GetScreenResourcesCurrent = (PFN_XRRGetScreenResourcesCurrent)
_glfw_dlsym(_glfw.x11.randr.handle, "XRRGetScreenResourcesCurrent");
_glfw.x11.randr.QueryExtension = (PFN_XRRQueryExtension)
_glfw_dlsym(_glfw.x11.randr.handle, "XRRQueryExtension");
_glfw.x11.randr.QueryVersion = (PFN_XRRQueryVersion)
_glfw_dlsym(_glfw.x11.randr.handle, "XRRQueryVersion");
_glfw.x11.randr.SelectInput = (PFN_XRRSelectInput)
_glfw_dlsym(_glfw.x11.randr.handle, "XRRSelectInput");
_glfw.x11.randr.SetCrtcConfig = (PFN_XRRSetCrtcConfig)
_glfw_dlsym(_glfw.x11.randr.handle, "XRRSetCrtcConfig");
_glfw.x11.randr.SetCrtcGamma = (PFN_XRRSetCrtcGamma)
_glfw_dlsym(_glfw.x11.randr.handle, "XRRSetCrtcGamma");
_glfw.x11.randr.UpdateConfiguration = (PFN_XRRUpdateConfiguration)
_glfw_dlsym(_glfw.x11.randr.handle, "XRRUpdateConfiguration");
if (XRRQueryExtension(_glfw.x11.display,
&_glfw.x11.randr.eventBase,
&_glfw.x11.randr.errorBase))
{
if (XRRQueryVersion(_glfw.x11.display,
&_glfw.x11.randr.major,
&_glfw.x11.randr.minor))
{
// The GLFW RandR path requires at least version 1.3
if (_glfw.x11.randr.major > 1 || _glfw.x11.randr.minor >= 3)
_glfw.x11.randr.available = GLFW_TRUE;
}
else
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"X11: Failed to query RandR version");
}
}
}
if (_glfw.x11.randr.available)
{
XRRScreenResources* sr = XRRGetScreenResourcesCurrent(_glfw.x11.display,
_glfw.x11.root);
if (!sr->ncrtc || !XRRGetCrtcGammaSize(_glfw.x11.display, sr->crtcs[0]))
{
// This is likely an older Nvidia driver with broken gamma support
// Flag it as useless and fall back to xf86vm gamma, if available
_glfw.x11.randr.gammaBroken = GLFW_TRUE;
}
if (!sr->ncrtc)
{
// A system without CRTCs is likely a system with broken RandR
// Disable the RandR monitor path and fall back to core functions
_glfw.x11.randr.monitorBroken = GLFW_TRUE;
}
XRRFreeScreenResources(sr);
}
if (_glfw.x11.randr.available && !_glfw.x11.randr.monitorBroken)
{
XRRSelectInput(_glfw.x11.display, _glfw.x11.root,
RROutputChangeNotifyMask);
}
#if defined(__CYGWIN__)
_glfw.x11.xcursor.handle = _glfw_dlopen("libXcursor-1.so");
#else
_glfw.x11.xcursor.handle = _glfw_dlopen("libXcursor.so.1");
#endif
if (_glfw.x11.xcursor.handle)
{
_glfw.x11.xcursor.ImageCreate = (PFN_XcursorImageCreate)
_glfw_dlsym(_glfw.x11.xcursor.handle, "XcursorImageCreate");
_glfw.x11.xcursor.ImageDestroy = (PFN_XcursorImageDestroy)
_glfw_dlsym(_glfw.x11.xcursor.handle, "XcursorImageDestroy");
_glfw.x11.xcursor.ImageLoadCursor = (PFN_XcursorImageLoadCursor)
_glfw_dlsym(_glfw.x11.xcursor.handle, "XcursorImageLoadCursor");
}
#if defined(__CYGWIN__)
_glfw.x11.xinerama.handle = _glfw_dlopen("libXinerama-1.so");
#else
_glfw.x11.xinerama.handle = _glfw_dlopen("libXinerama.so.1");
#endif
if (_glfw.x11.xinerama.handle)
{
_glfw.x11.xinerama.IsActive = (PFN_XineramaIsActive)
_glfw_dlsym(_glfw.x11.xinerama.handle, "XineramaIsActive");
_glfw.x11.xinerama.QueryExtension = (PFN_XineramaQueryExtension)
_glfw_dlsym(_glfw.x11.xinerama.handle, "XineramaQueryExtension");
_glfw.x11.xinerama.QueryScreens = (PFN_XineramaQueryScreens)
_glfw_dlsym(_glfw.x11.xinerama.handle, "XineramaQueryScreens");
if (XineramaQueryExtension(_glfw.x11.display,
&_glfw.x11.xinerama.major,
&_glfw.x11.xinerama.minor))
{
if (XineramaIsActive(_glfw.x11.display))
_glfw.x11.xinerama.available = GLFW_TRUE;
}
}
_glfw.x11.xkb.major = 1;
_glfw.x11.xkb.minor = 0;
_glfw.x11.xkb.available =
XkbQueryExtension(_glfw.x11.display,
&_glfw.x11.xkb.majorOpcode,
&_glfw.x11.xkb.eventBase,
&_glfw.x11.xkb.errorBase,
&_glfw.x11.xkb.major,
&_glfw.x11.xkb.minor);
if (_glfw.x11.xkb.available)
{
Bool supported;
if (XkbSetDetectableAutoRepeat(_glfw.x11.display, True, &supported))
{
if (supported)
_glfw.x11.xkb.detectable = GLFW_TRUE;
}
}
#if defined(__CYGWIN__)
_glfw.x11.x11xcb.handle = _glfw_dlopen("libX11-xcb-1.so");
#else
_glfw.x11.x11xcb.handle = _glfw_dlopen("libX11-xcb.so.1");
#endif
if (_glfw.x11.x11xcb.handle)
{
_glfw.x11.x11xcb.GetXCBConnection = (PFN_XGetXCBConnection)
_glfw_dlsym(_glfw.x11.x11xcb.handle, "XGetXCBConnection");
}
#if defined(__CYGWIN__)
_glfw.x11.xrender.handle = _glfw_dlopen("libXrender-1.so");
#else
_glfw.x11.xrender.handle = _glfw_dlopen("libXrender.so.1");
#endif
if (_glfw.x11.xrender.handle)
{
_glfw.x11.xrender.QueryExtension = (PFN_XRenderQueryExtension)
_glfw_dlsym(_glfw.x11.xrender.handle, "XRenderQueryExtension");
_glfw.x11.xrender.QueryVersion = (PFN_XRenderQueryVersion)
_glfw_dlsym(_glfw.x11.xrender.handle, "XRenderQueryVersion");
_glfw.x11.xrender.FindVisualFormat = (PFN_XRenderFindVisualFormat)
_glfw_dlsym(_glfw.x11.xrender.handle, "XRenderFindVisualFormat");
if (XRenderQueryExtension(_glfw.x11.display,
&_glfw.x11.xrender.errorBase,
&_glfw.x11.xrender.eventBase))
{
if (XRenderQueryVersion(_glfw.x11.display,
&_glfw.x11.xrender.major,
&_glfw.x11.xrender.minor))
{
_glfw.x11.xrender.available = GLFW_TRUE;
}
}
}
// Update the key code LUT
// FIXME: We should listen to XkbMapNotify events to track changes to
// the keyboard mapping.
createKeyTables();
// Detect whether an EWMH-conformant window manager is running
detectEWMH();
// String format atoms
_glfw.x11.NULL_ = XInternAtom(_glfw.x11.display, "NULL", False);
_glfw.x11.UTF8_STRING = XInternAtom(_glfw.x11.display, "UTF8_STRING", False);
_glfw.x11.ATOM_PAIR = XInternAtom(_glfw.x11.display, "ATOM_PAIR", False);
// Custom selection property atom
_glfw.x11.GLFW_SELECTION =
XInternAtom(_glfw.x11.display, "GLFW_SELECTION", False);
// ICCCM standard clipboard atoms
_glfw.x11.TARGETS = XInternAtom(_glfw.x11.display, "TARGETS", False);
_glfw.x11.MULTIPLE = XInternAtom(_glfw.x11.display, "MULTIPLE", False);
_glfw.x11.PRIMARY = XInternAtom(_glfw.x11.display, "PRIMARY", False);
_glfw.x11.INCR = XInternAtom(_glfw.x11.display, "INCR", False);
_glfw.x11.CLIPBOARD = XInternAtom(_glfw.x11.display, "CLIPBOARD", False);
// Clipboard manager atoms
_glfw.x11.CLIPBOARD_MANAGER =
XInternAtom(_glfw.x11.display, "CLIPBOARD_MANAGER", False);
_glfw.x11.SAVE_TARGETS =
XInternAtom(_glfw.x11.display, "SAVE_TARGETS", False);
// Xdnd (drag and drop) atoms
_glfw.x11.XdndAware = XInternAtom(_glfw.x11.display, "XdndAware", False);
_glfw.x11.XdndEnter = XInternAtom(_glfw.x11.display, "XdndEnter", False);
_glfw.x11.XdndPosition = XInternAtom(_glfw.x11.display, "XdndPosition", False);
_glfw.x11.XdndStatus = XInternAtom(_glfw.x11.display, "XdndStatus", False);
_glfw.x11.XdndActionCopy = XInternAtom(_glfw.x11.display, "XdndActionCopy", False);
_glfw.x11.XdndDrop = XInternAtom(_glfw.x11.display, "XdndDrop", False);
_glfw.x11.XdndFinished = XInternAtom(_glfw.x11.display, "XdndFinished", False);
_glfw.x11.XdndSelection = XInternAtom(_glfw.x11.display, "XdndSelection", False);
_glfw.x11.XdndTypeList = XInternAtom(_glfw.x11.display, "XdndTypeList", False);
_glfw.x11.text_uri_list = XInternAtom(_glfw.x11.display, "text/uri-list", False);
// ICCCM, EWMH and Motif window property atoms
// These can be set safely even without WM support
// The EWMH atoms that require WM support are handled in detectEWMH
_glfw.x11.WM_PROTOCOLS =
XInternAtom(_glfw.x11.display, "WM_PROTOCOLS", False);
_glfw.x11.WM_STATE =
XInternAtom(_glfw.x11.display, "WM_STATE", False);
_glfw.x11.WM_DELETE_WINDOW =
XInternAtom(_glfw.x11.display, "WM_DELETE_WINDOW", False);
_glfw.x11.NET_WM_ICON =
XInternAtom(_glfw.x11.display, "_NET_WM_ICON", False);
_glfw.x11.NET_WM_PING =
XInternAtom(_glfw.x11.display, "_NET_WM_PING", False);
_glfw.x11.NET_WM_PID =
XInternAtom(_glfw.x11.display, "_NET_WM_PID", False);
_glfw.x11.NET_WM_NAME =
XInternAtom(_glfw.x11.display, "_NET_WM_NAME", False);
_glfw.x11.NET_WM_ICON_NAME =
XInternAtom(_glfw.x11.display, "_NET_WM_ICON_NAME", False);
_glfw.x11.NET_WM_BYPASS_COMPOSITOR =
XInternAtom(_glfw.x11.display, "_NET_WM_BYPASS_COMPOSITOR", False);
_glfw.x11.NET_WM_WINDOW_OPACITY =
XInternAtom(_glfw.x11.display, "_NET_WM_WINDOW_OPACITY", False);
_glfw.x11.MOTIF_WM_HINTS =
XInternAtom(_glfw.x11.display, "_MOTIF_WM_HINTS", False);
// The compositing manager selection name contains the screen number
{
char name[32];
snprintf(name, sizeof(name), "_NET_WM_CM_S%u", _glfw.x11.screen);
_glfw.x11.NET_WM_CM_Sx = XInternAtom(_glfw.x11.display, name, False);
}
return GLFW_TRUE;
}
_X_HIDDEN XftDisplayInfo *
_XftDisplayInfoGet (Display *dpy, FcBool createIfNecessary)
{
XftDisplayInfo *info, **prev;
XRenderPictFormat pf;
int i;
int event_base, error_base;
for (prev = &_XftDisplayInfo; (info = *prev); prev = &(*prev)->next)
{
if (info->display == dpy)
{
/*
* MRU the list
*/
if (prev != &_XftDisplayInfo)
{
*prev = info->next;
info->next = _XftDisplayInfo;
_XftDisplayInfo = info;
}
return info;
}
}
if (!createIfNecessary)
return NULL;
info = (XftDisplayInfo *) malloc (sizeof (XftDisplayInfo));
if (!info)
goto bail0;
info->codes = XAddExtension (dpy);
if (!info->codes)
goto bail1;
(void) XESetCloseDisplay (dpy, info->codes->extension, _XftCloseDisplay);
info->display = dpy;
info->defaults = NULL;
info->solidFormat = NULL;
info->hasRender = (XRenderQueryExtension (dpy, &event_base, &error_base) &&
(XRenderFindVisualFormat (dpy, DefaultVisual (dpy, DefaultScreen (dpy))) != NULL));
info->use_free_glyphs = FcTrue;
if (info->hasRender)
{
int major, minor;
XRenderQueryVersion (dpy, &major, &minor);
if (major < 0 || (major == 0 && minor <= 2))
info->use_free_glyphs = FcFalse;
pf.type = PictTypeDirect;
pf.depth = 32;
pf.direct.redMask = 0xff;
pf.direct.greenMask = 0xff;
pf.direct.blueMask = 0xff;
pf.direct.alphaMask = 0xff;
info->solidFormat = XRenderFindFormat (dpy,
(PictFormatType|
PictFormatDepth|
PictFormatRedMask|
PictFormatGreenMask|
PictFormatBlueMask|
PictFormatAlphaMask),
&pf,
0);
}
if (XftDebug () & XFT_DBG_RENDER)
{
Visual *visual = DefaultVisual (dpy, DefaultScreen (dpy));
XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
printf ("XftDisplayInfoGet Default visual 0x%x ",
(int) visual->visualid);
if (format)
{
if (format->type == PictTypeDirect)
{
printf ("format %d,%d,%d,%d\n",
format->direct.alpha,
format->direct.red,
format->direct.green,
format->direct.blue);
}
else
{
printf ("format indexed\n");
}
}
else
printf ("No Render format for default visual\n");
printf ("XftDisplayInfoGet initialized, hasRender set to \"%s\"\n",
info->hasRender ? "True" : "False");
}
for (i = 0; i < XFT_NUM_SOLID_COLOR; i++)
{
info->colors[i].screen = -1;
info->colors[i].pict = 0;
}
info->fonts = NULL;
info->next = _XftDisplayInfo;
_XftDisplayInfo = info;
info->glyph_memory = 0;
info->max_glyph_memory = XftDefaultGetInteger (dpy,
XFT_MAX_GLYPH_MEMORY, 0,
XFT_DPY_MAX_GLYPH_MEMORY);
if (XftDebug () & XFT_DBG_CACHE)
printf ("global max cache memory %ld\n", info->max_glyph_memory);
info->num_unref_fonts = 0;
info->max_unref_fonts = XftDefaultGetInteger (dpy,
XFT_MAX_UNREF_FONTS, 0,
XFT_DPY_MAX_UNREF_FONTS);
if (XftDebug() & XFT_DBG_CACHE)
printf ("global max unref fonts %d\n", info->max_unref_fonts);
memset (info->fontHash, '\0', sizeof (XftFont *) * XFT_NUM_FONT_HASH);
return info;
bail1:
free (info);
bail0:
if (XftDebug () & XFT_DBG_RENDER)
{
printf ("XftDisplayInfoGet failed to initialize, Xft unhappy\n");
}
return NULL;
}
cairo_xlib_display_t *
_cairo_xlib_display_get (Display *dpy)
{
cairo_xlib_display_t *display;
cairo_xlib_display_t **prev;
XExtCodes *codes;
int major_unused, minor_unused;
/* There is an apparent deadlock between this mutex and the
* mutex for the display, but it's actually safe. For the
* app to call XCloseDisplay() while any other thread is
* inside this function would be an error in the logic
* app, and the CloseDisplay hook is the only other place we
* acquire this mutex.
*/
CAIRO_MUTEX_LOCK (_cairo_xlib_display_mutex);
for (prev = &_cairo_xlib_display_list; (display = *prev); prev = &(*prev)->next)
{
if (display->display == dpy) {
/*
* MRU the list
*/
if (prev != &_cairo_xlib_display_list) {
*prev = display->next;
display->next = _cairo_xlib_display_list;
_cairo_xlib_display_list = display;
}
break;
}
}
if (display != NULL) {
display = _cairo_xlib_display_reference (display);
goto UNLOCK;
}
display = malloc (sizeof (cairo_xlib_display_t));
if (display == NULL) {
_cairo_error_throw (CAIRO_STATUS_NO_MEMORY);
goto UNLOCK;
}
/* Xlib calls out to the extension close_display hooks in LIFO
* order. So we have to ensure that all extensions that we depend
* on in our close_display hook are properly initialized before we
* add our hook. For now, that means Render, so we call into its
* QueryVersion function to ensure it gets initialized.
*/
XRenderQueryVersion (dpy, &major_unused, &minor_unused);
codes = XAddExtension (dpy);
if (codes == NULL) {
_cairo_error_throw (CAIRO_STATUS_NO_MEMORY);
free (display);
display = NULL;
goto UNLOCK;
}
XESetCloseDisplay (dpy, codes->extension, _cairo_xlib_close_display);
_cairo_freelist_init (&display->wq_freelist, sizeof (cairo_xlib_job_t));
_cairo_freelist_init (&display->hook_freelist, sizeof (cairo_xlib_hook_t));
CAIRO_REFERENCE_COUNT_INIT (&display->ref_count, 2); /* add one for the CloseDisplay */
CAIRO_MUTEX_INIT (display->mutex);
display->display = dpy;
display->screens = NULL;
display->workqueue = NULL;
display->close_display_hooks = NULL;
display->closed = FALSE;
display->buggy_repeat = FALSE;
if (strstr (ServerVendor (dpy), "X.Org") != NULL) {
/* When modularized, the X.Org server VendorRelease was
* bogusly reset to a very small number, without any change in
* the ServerVendor string. We avoid considering the new
* servers with the small number as buggy by restricting the
* test to known bad releases. But there could be a problem
* again in the future if X.Org server versions ever climb
* back up to 6.7 or 6.8. */
if (VendorRelease (dpy) >= 60700000 && VendorRelease (dpy) <= 60802000)
display->buggy_repeat = TRUE;
/* But even the new modular server has bugs, (bad enough to
* crash the X server), that it so happens we can avoid with
* the exact same buggy_repeat workaround. We've verified that
* this bug exists as least as late as version 1.3.0.0, (which
* is in Fedora 8), and is gone again in version 1.4.99.901
* (from a Fedora 9 Beta). Versions between those are still
* unknown, but until we learn more, we'll assume that any 1.3
* version is buggy. */
if (VendorRelease (dpy) < 10400000)
display->buggy_repeat = TRUE;
} else if (strstr (ServerVendor (dpy), "XFree86") != NULL) {
if (VendorRelease (dpy) <= 40500000)
display->buggy_repeat = TRUE;
}
display->next = _cairo_xlib_display_list;
_cairo_xlib_display_list = display;
UNLOCK:
CAIRO_MUTEX_UNLOCK (_cairo_xlib_display_mutex);
return display;
}
