/* 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; }