static void
panel_multiscreen_init_randr (GdkDisplay *display)
{
#ifdef HAVE_RANDR
Display *xdisplay;
int event_base, error_base;
#endif
have_randr = FALSE;
have_randr_1_3 = FALSE;
#ifdef HAVE_RANDR
xdisplay = GDK_DISPLAY_XDISPLAY (display);
/* We don't remember the event/error bases, as we expect to get "screen
* changed" events from GdkScreen instead.
*/
if (XRRQueryExtension (xdisplay, &event_base, &error_base)) {
int major, minor;
XRRQueryVersion (xdisplay, &major, &minor);
if ((major == 1 && minor >= 2) || major > 1)
have_randr = TRUE;
if ((major == 1 && minor >= 3) || major > 1)
have_randr_1_3 = TRUE;
}
#endif
}
static gboolean
gst_vaapi_display_x11_open_display(GstVaapiDisplay *display)
{
GstVaapiDisplayX11Private * const priv =
GST_VAAPI_DISPLAY_X11(display)->priv;
if (priv->create_display) {
priv->x11_display = XOpenDisplay(get_display_name(display));
if (!priv->x11_display)
return FALSE;
priv->x11_screen = DefaultScreen(priv->x11_display);
}
if (!priv->x11_display)
return FALSE;
if (priv->synchronous)
XSynchronize(priv->x11_display, True);
#ifdef HAVE_XRANDR
{
int evt_base, err_base;
priv->use_xrandr = XRRQueryExtension(
priv->x11_display, &evt_base, &err_base);
}
#endif
return TRUE;
}
int runDaemon ( const char * display_name )
{
Display * display;
Window root;
int rr_event_base = 0, rr_error_base = 0;
XcmeContext_s * c = XcmeContext_New( );
XcmeContext_Setup2( c, display_name, 0 );
display = XcmeContext_DisplayGet( c );
if(!display)
return 1;
root = RootWindow( display, DefaultScreen( display ) );
#ifdef HAVE_XRANDR
XRRQueryExtension( display, &rr_event_base, &rr_error_base );
XRRSelectInput( display, root, RRScreenChangeNotifyMask | RRCrtcChangeNotifyMask | RROutputChangeNotifyMask | RROutputPropertyNotifyMask);
#endif
for(;;)
{
XEvent event;
XNextEvent( display, &event);
/* we rely on any color server doing X11 setup by its own */
if(XcmColorServerCapabilities( display ) & XCM_COLOR_SERVER_MANAGEMENT)
continue;
#ifdef HAVE_XRANDR
if(event.type == rr_event_base + RRNotify)
{
XRRNotifyEvent *rrn = (XRRNotifyEvent *) &event;
if(rrn->subtype == RRNotify_OutputChange ||
rrn->subtype == RR_Rotate_0)
{
fprintf( stderr,"detected RRNotify_OutputChange event -> update\n");
updateOutputConfiguration( display );
}
}
#else
{
Atom net_desktop_geometry = XInternAtom( display,
"_NET_DESKTOP_GEOMETRY", False );
if( event.type == PropertyNotify &&
event.xproperty.atom == net_desktop_geometry)
{
fprintf( stderr,"detected _NET_DESKTOP_GEOMETRY event -> update\n");
updateOutputConfiguration( display );
}
}
#endif
}
XcmeContext_Release( &c );
return 0;
}
void psb_xrandr_thread(void* arg)
{
VADriverContextP ctx = (VADriverContextP)arg;
INIT_DRIVER_DATA;
int event_base, error_base;
XEvent event;
XRRQueryExtension(psb_xrandr_info->dpy, &event_base, &error_base);
XRRSelectInput(psb_xrandr_info->dpy, psb_xrandr_info->root, RRScreenChangeNotifyMask | RRCrtcChangeNotifyMask | RROutputChangeNotifyMask | RROutputPropertyNotifyMask);
drv_debug_msg(VIDEO_DEBUG_GENERAL, "Xrandr: psb xrandr thread start\n");
while (1) {
if (XCheckIfEvent(psb_xrandr_info->dpy, (XEvent *)&event, outputChangePredicate, NULL)) {
if (event.type == ClientMessage) {
drv_debug_msg(VIDEO_DEBUG_GENERAL, "Xrandr: receive ClientMessage event, thread should exit\n");
XClientMessageEvent *evt;
evt = (XClientMessageEvent*) & event;
if (evt->message_type == psb_xrandr_info->psb_exit_atom) {
drv_debug_msg(VIDEO_DEBUG_GENERAL, "Xrandr: xrandr thread exit safely\n");
pthread_exit(NULL);
}
}
switch (event.type - event_base) {
case RRNotify_OutputChange:
XRRUpdateConfiguration(&event);
drv_debug_msg(VIDEO_DEBUG_GENERAL, "Xrandr: receive RRNotify_OutputChange event, refresh output/crtc info\n");
driver_data->xrandr_update = 1;
psb_xrandr_refresh(ctx);
break;
default:
break;
}
}
usleep(200000);
}
}
static XRRScreenConfiguration *GetScreenConfig(MythXDisplay*& display)
{
display = OpenMythXDisplay();
if (!display)
{
LOG(VB_GENERAL, LOG_ERR, "DisplaResX: MythXOpenDisplay call failed");
return NULL;
}
Window root = RootWindow(display->GetDisplay(), display->GetScreen());
XRRScreenConfiguration *cfg = NULL;
int event_basep = 0, error_basep = 0;
if (XRRQueryExtension(display->GetDisplay(), &event_basep, &error_basep))
cfg = XRRGetScreenInfo(display->GetDisplay(), root);
if (!cfg)
{
delete display;
display = NULL;
LOG(VB_GENERAL, LOG_ERR, "DisplaResX: Unable to XRRgetScreenInfo");
}
return cfg;
}
static XRRScreenConfiguration *GetScreenConfig(Display*& display)
{
display = MythXOpenDisplay();
if (!display)
{
cerr<<"DisplaResX: MythXOpenDisplay call failed"<<endl;
return NULL;
}
X11L;
Window root = RootWindow(display, DefaultScreen(display));
XRRScreenConfiguration *cfg = NULL;
int event_basep = 0, error_basep = 0;
if (XRRQueryExtension(display, &event_basep, &error_basep))
cfg = XRRGetScreenInfo(display, root);
if (!cfg)
{
if (display)
{
XCloseDisplay(display);
display = NULL;
}
cerr<<"DisplaResX: Unable to XRRgetScreenInfo"<<endl;
}
X11U;
return cfg;
}
static int _glfwInitDisplay( void )
{
// Open display
_glfwLibrary.Dpy = XOpenDisplay( 0 );
if( !_glfwLibrary.Dpy )
{
return GL_FALSE;
}
// Check screens
_glfwLibrary.NumScreens = ScreenCount( _glfwLibrary.Dpy );
_glfwLibrary.DefaultScreen = DefaultScreen( _glfwLibrary.Dpy );
// Check for XF86VidMode extension
#ifdef _GLFW_HAS_XF86VIDMODE
_glfwLibrary.XF86VidMode.Available =
XF86VidModeQueryExtension( _glfwLibrary.Dpy,
&_glfwLibrary.XF86VidMode.EventBase,
&_glfwLibrary.XF86VidMode.ErrorBase);
#else
_glfwLibrary.XF86VidMode.Available = 0;
#endif
// Check for XRandR extension
#ifdef _GLFW_HAS_XRANDR
_glfwLibrary.XRandR.Available =
XRRQueryExtension( _glfwLibrary.Dpy,
&_glfwLibrary.XRandR.EventBase,
&_glfwLibrary.XRandR.ErrorBase );
#else
_glfwLibrary.XRandR.Available = 0;
#endif
return GL_TRUE;
}
QSize native_res_for_monitior()
{
Display* dpy = QX11Info::display();
int major_version_return;
int minor_version_return;
XRRQueryVersion(dpy, &major_version_return, &minor_version_return);
int event_base_return;
int error_base_return;
if (!XRRQueryExtension(dpy, &event_base_return, &error_base_return))
{
return QSize();
}
qDebug() << "XRandR extension supported";
int nscreen_sizes = 0;
XRRScreenSize * screen_sizes;
screen_sizes = XRRSizes(dpy, QX11Info::appScreen(), &nscreen_sizes);
for ( int i = 0 ; i < nscreen_sizes; i++ )
{
XRRScreenSize ss = screen_sizes[i];
QSize qss(ss.width, ss.height);
return qss;
}
return QSize();
}
KDE_EXPORT bool test_randr()
{
int eventBase, errorBase;
if( XRRQueryExtension(qt_xdisplay(), &eventBase, &errorBase ) )
return true;
return false;
}
bool C4AbstractApp::Init(int argc, char * argv[])
{
// Set locale
setlocale(LC_ALL,"");
gtk_init(&argc, &argv);
GdkPixbuf* icon = gdk_pixbuf_new_from_resource("/org/openclonk/engine/oc.ico", NULL);
gtk_window_set_default_icon(icon);
g_object_unref(icon);
// Try to figure out the location of the executable
Priv->argc=argc; Priv->argv=argv;
#ifdef GDK_WINDOWING_X11
Display * const dpy = gdk_x11_display_get_xdisplay(gdk_display_get_default());
int xrandr_error_base;
if (!XRRQueryExtension(dpy, &Priv->xrandr_event, &xrandr_error_base)
|| !XRRQueryVersion(dpy, &Priv->xrandr_major_version, &Priv->xrandr_minor_version))
{
Priv->xrandr_major_version = -1;
Priv->xrandr_minor_version = 0;
}
if (Priv->xrandr_major_version >= 0)
{
XRRSelectInput(dpy, DefaultRootWindow(dpy), RRScreenChangeNotifyMask);
}
else
Log("The Xrandr extension is missing. Resolution switching will not work.");
#endif
// Custom initialization
return DoInit (argc, argv);
}
JNIEXPORT jobject JNICALL
Java_gnu_java_awt_peer_gtk_GdkScreenGraphicsDevice_nativeGetFixedDisplayMode
(JNIEnv *env, jobject obj, jobject gdkGraphicsEnv __attribute__((unused)))
{
jclass displayMode_class;
jmethodID displayMode_ctor;
GdkScreen *screen;
jobject fixedDisplayMode = NULL;
#ifdef HAVE_XRANDR
int temp1, temp2;
GdkDisplay *display;
display = (GdkDisplay *) NSA_GET_DISPLAY_PTR(env, gdkGraphicsEnv);
gdk_threads_enter();
if (!XRRQueryExtension(GDK_DISPLAY_XDISPLAY(display), &temp1, &temp2))
{
displayMode_class = (*env)->FindClass(env, "java/awt/DisplayMode");
displayMode_ctor = (*env)->GetMethodID(env,
displayMode_class,
"<init>",
"(IIII)V");
screen = (GdkScreen *) NSA_GET_SCREEN_PTR(env, obj);
fixedDisplayMode = (*env)->NewObject(env,
displayMode_class,
displayMode_ctor,
gdk_screen_get_width(screen),
gdk_screen_get_height(screen),
-1,
0);
}
gdk_threads_leave();
#else
displayMode_class = (*env)->FindClass(env, "java/awt/DisplayMode");
displayMode_ctor = (*env)->GetMethodID(env,
displayMode_class,
"<init>",
"(IIII)V");
screen = (GdkScreen *) NSA_GET_SCREEN_PTR(env, obj);
fixedDisplayMode = (*env)->NewObject(env,
displayMode_class,
displayMode_ctor,
gdk_screen_get_width(screen),
gdk_screen_get_height(screen),
-1,
0);
#endif
return fixedDisplayMode;
}
EXTERN_C_ENTER
JNIEXPORT jint JNICALL Java_org_lwjgl_system_linux_Xrandr_nXRRQueryExtension(JNIEnv *__env, jclass clazz, jlong displayAddress, jlong event_base_returnAddress, jlong error_base_returnAddress) {
Display *display = (Display *)(intptr_t)displayAddress;
int *event_base_return = (int *)(intptr_t)event_base_returnAddress;
int *error_base_return = (int *)(intptr_t)error_base_returnAddress;
UNUSED_PARAMS(__env, clazz)
return (jint)XRRQueryExtension(display, event_base_return, error_base_return);
}
bool XRandRToggler::isUsable() {
int unused = 0;
int major = 1;
int minor = 1;
return XRRQueryExtension(QX11Info::display(), &unused, &unused) &&
XRRQueryVersion(QX11Info::display(), &major, &minor) &&
major == 1 && minor >= 1;
}
static Bool
outputChangePredicate(Display *display, XEvent *event, char *args)
{
int event_base, error_base;
XRRQueryExtension(psb_xrandr_info->dpy, &event_base, &error_base);
return ((event->type == event_base + RRNotify_OutputChange) ||
((event->type == ClientMessage) &&
(((XClientMessageEvent*)event)->message_type == psb_xrandr_info->psb_exit_atom)));
}
gboolean
_cogl_xlib_renderer_connect (CoglRenderer *renderer, CoglError **error)
{
CoglXlibRenderer *xlib_renderer =
_cogl_xlib_renderer_get_data (renderer);
CoglX11Renderer *x11_renderer =
(CoglX11Renderer *) xlib_renderer;
int damage_error;
int randr_error;
if (!assert_xlib_display (renderer, error))
return FALSE;
if (getenv ("COGL_X11_SYNC"))
XSynchronize (xlib_renderer->xdpy, TRUE);
/* Check whether damage events are supported on this display */
if (!XDamageQueryExtension (xlib_renderer->xdpy,
&x11_renderer->damage_base,
&damage_error))
x11_renderer->damage_base = -1;
/* Check whether randr is supported on this display */
if (!XRRQueryExtension (xlib_renderer->xdpy,
&x11_renderer->randr_base,
&randr_error))
x11_renderer->randr_base = -1;
xlib_renderer->trap_state = NULL;
if (renderer->xlib_enable_event_retrieval)
{
_cogl_poll_renderer_add_fd (renderer,
ConnectionNumber (xlib_renderer->xdpy),
COGL_POLL_FD_EVENT_IN,
prepare_xlib_events_timeout,
dispatch_xlib_events,
renderer);
}
XRRSelectInput(xlib_renderer->xdpy,
DefaultRootWindow (xlib_renderer->xdpy),
RRScreenChangeNotifyMask
| RRCrtcChangeNotifyMask
| RROutputPropertyNotifyMask);
update_outputs (renderer, FALSE);
register_xlib_renderer (renderer);
cogl_xlib_renderer_add_filter (renderer,
randr_filter,
renderer);
return TRUE;
}
static void *settings_thread_proc(void *arg) {
Display *settings_disp = XOpenDisplay(XDisplayName(NULL));;
if (settings_disp != NULL) {
logger(LOG_LEVEL_DEBUG, "%s [%u]: %s\n",
__FUNCTION__, __LINE__, "XOpenDisplay success.");
pthread_cleanup_push(settings_cleanup_proc, settings_disp);
int event_base = 0;
int error_base = 0;
if (XRRQueryExtension(settings_disp, &event_base, &error_base)) {
Window root = XDefaultRootWindow(settings_disp);
unsigned long event_mask = RRScreenChangeNotifyMask;
XRRSelectInput(settings_disp, root, event_mask);
XEvent ev;
while(settings_disp != NULL) {
XNextEvent(settings_disp, &ev);
if (ev.type == event_base + RRScreenChangeNotifyMask) {
logger(LOG_LEVEL_DEBUG, "%s [%u]: Received XRRScreenChangeNotifyEvent.\n",
__FUNCTION__, __LINE__);
pthread_mutex_lock(&xrandr_mutex);
if (xrandr_resources != NULL) {
XRRFreeScreenResources(xrandr_resources);
}
xrandr_resources = XRRGetScreenResources(settings_disp, root);
if (xrandr_resources == NULL) {
logger(LOG_LEVEL_WARN, "%s [%u]: XRandR could not get screen resources!\n",
__FUNCTION__, __LINE__);
}
pthread_mutex_unlock(&xrandr_mutex);
}
else {
logger(LOG_LEVEL_WARN, "%s [%u]: XRandR is not currently available!\n",
__FUNCTION__, __LINE__);
}
}
}
// Execute the thread cleanup handler.
pthread_cleanup_pop(1);
}
else {
logger(LOG_LEVEL_ERROR, "%s [%u]: XOpenDisplay failure!\n",
__FUNCTION__, __LINE__);
}
return NULL;
}
/* Check for display server extensions */
static void
check_extensions (GstMfxDisplay * display)
{
GstMfxDisplayX11Private *const priv = GST_MFX_DISPLAY_X11_PRIVATE (display);
Display *const dpy = GST_MFX_DISPLAY_HANDLE (display);
int evt_base, err_base;
#ifdef HAVE_XRANDR
priv->use_xrandr = XRRQueryExtension (dpy,
&evt_base, &err_base);
#endif
}
/* Check for display server extensions */
static void
check_extensions (GstVaapiDisplayX11 * display)
{
GstVaapiDisplayX11Private *const priv = display->priv;
int evt_base, err_base;
#if HAVE_XRANDR
priv->use_xrandr = XRRQueryExtension (priv->x11_display,
&evt_base, &err_base);
#endif
#if HAVE_XRENDER
priv->has_xrender = XRenderQueryExtension (priv->x11_display,
&evt_base, &err_base);
#endif
}
/** Init screen geo
*/
void
screen_init_geo(void)
{
int i;
int s = screen_count();
sgeo = xcalloc(s, sizeof(XRectangle));
spgeo = xcalloc(s, sizeof(XRectangle));
for(i = 0; i < s; ++i)
sgeo[i] = screen_get_geo(i);
spgeo[0].x = 0;
spgeo[0].y = 0;
spgeo[0].width = MAXW;
spgeo[0].height = MAXH;
#ifdef HAVE_XINERAMA
XineramaScreenInfo *xsi;
int n;
if(XineramaIsActive(dpy))
{
xsi = XineramaQueryScreens(dpy, &n);
for(i = 0; i < n; ++i)
{
spgeo[i].x = xsi[i].x_org;
spgeo[i].y = xsi[i].y_org;
spgeo[i].width = xsi[i].width;
spgeo[i].height = xsi[i].height;
}
XFree(xsi);
}
#endif /* HAVE_XINERAMA */
#ifdef HAVE_XRANDR
/* Init xrandr stuff */
int d;
XRRSelectInput(dpy, ROOT, 1);
XRRQueryExtension(dpy, &xrandr_event, &d);
#endif /* HAVE_XRANDR */
ewmh_set_desktop_geometry();
return;
}
bool
_cg_xlib_renderer_connect(cg_renderer_t *renderer, cg_error_t **error)
{
cg_xlib_renderer_t *xlib_renderer = _cg_xlib_renderer_get_data(renderer);
cg_x11_renderer_t *x11_renderer = (cg_x11_renderer_t *)xlib_renderer;
int damage_error;
int randr_error;
if (!assert_xlib_display(renderer, error))
return false;
if (getenv("CG_X11_SYNC"))
XSynchronize(xlib_renderer->xdpy, true);
/* Check whether damage events are supported on this display */
if (!XDamageQueryExtension(
xlib_renderer->xdpy, &x11_renderer->damage_base, &damage_error))
x11_renderer->damage_base = -1;
/* Check whether randr is supported on this display */
if (!XRRQueryExtension(
xlib_renderer->xdpy, &x11_renderer->randr_base, &randr_error))
x11_renderer->randr_base = -1;
xlib_renderer->trap_state = NULL;
if (renderer->xlib_enable_event_retrieval) {
_cg_loop_add_fd(renderer,
ConnectionNumber(xlib_renderer->xdpy),
CG_POLL_FD_EVENT_IN,
prepare_xlib_events_timeout,
dispatch_xlib_events,
renderer);
}
XRRSelectInput(xlib_renderer->xdpy,
DefaultRootWindow(xlib_renderer->xdpy),
RRScreenChangeNotifyMask | RRCrtcChangeNotifyMask |
RROutputPropertyNotifyMask);
update_outputs(renderer, false);
register_xlib_renderer(renderer);
cg_xlib_renderer_add_filter(renderer, randr_filter, renderer);
return true;
}
static gboolean
ccm_display_init_randr(CCMDisplay *self)
{
g_return_val_if_fail(self != NULL, FALSE);
if (XRRQueryExtension (self->priv->xdisplay,
&self->priv->randr.event_base,
&self->priv->randr.error_base))
{
self->priv->randr.available = TRUE;
ccm_debug ("RANDR EVENT BASE: %i", self->priv->randr.event_base);
ccm_debug ("RANDR ERROR BASE: %i", self->priv->randr.error_base);
return TRUE;
}
return FALSE;
}
void eventNotifier::run()
{
int rr_event_base;
int rr_error_base;
XRRQueryExtension (m_pDpy, &rr_event_base, &rr_error_base);
XRRSelectInput( m_pDpy, m_screen, RRCrtcChangeNotifyMask |
RROutputChangeNotifyMask |
RROutputPropertyNotifyMask );
while (!m_bStop){
XEvent event;
XNextEvent (m_pDpy, &event);
if (event.type == rr_event_base + RRNotify){
prologue (&event, "RRScreenChangeNotify");
do_RRNotify(&event);
}
}
}
bool Display::Initialize()
{
if (X11Display == NULL)
{
X11Display = XOpenDisplay(NULL);
}
if (X11Display == NULL)
{
OVR::LogError("[Linux Display] Unable to open X display!");
return false;
}
if (!XRRQueryExtension(X11Display, &BaseRREvent, &BaseRRError))
{
OVR::LogError("[Linux Display] Unable to query XRandR extension!");
return false;
}
return true;
}
/*
* r_desktop_init:
*
*/
void
r_desktop_init()
{
gint event_base;
gint error_base;
gint version_major;
gint version_minor;
gint sizes_count;
XRRScreenSize* sizes;
XRRScreenConfiguration *sc;
if(!XRRQueryExtension(
game->display,
&event_base,
&error_base
)
|| !XRRQueryVersion(
game->display,
&version_major,
&version_minor
))
{
g_error("XRandr not supported");
}
sc = XRRGetScreenInfo(game->display, DefaultRootWindow(game->display));
self.size = XRRConfigCurrentConfiguration(sc, &self.rotation);
self.rate = XRRConfigCurrentRate(sc);
XRRFreeScreenConfigInfo(sc);
sizes = XRRSizes(game->display, DefaultScreen(game->display), &sizes_count);
self.default_width = sizes[self.size].width;
self.default_height = sizes[self.size].height;
self.default_rate = self.rate;
self.current_width = self.default_width;
self.current_height = self.default_height;
self.current_rate = self.default_rate;
_desktop_print_info();
}
static void
x_init(const char *dpyname)
{
int i;
if ((X_Dpy = XOpenDisplay(dpyname)) == NULL)
errx(1, "unable to open display \"%s\"", XDisplayName(dpyname));
XSetErrorHandler(x_wmerrorhandler);
XSelectInput(X_Dpy, DefaultRootWindow(X_Dpy), SubstructureRedirectMask);
XSync(X_Dpy, False);
XSetErrorHandler(x_errorhandler);
HasRandr = XRRQueryExtension(X_Dpy, &Randr_ev, &i);
conf_atoms();
conf_cursor(&Conf);
for (i = 0; i < ScreenCount(X_Dpy); i++)
screen_init(i);
}
static int initDisplay(Display *pDisplay)
{
int rc = VINF_SUCCESS;
uint32_t fMouseFeatures = 0;
LogRelFlowFunc(("testing dynamic resizing\n"));
int iDummy;
if (!XRRQueryExtension(pDisplay, &iDummy, &iDummy))
rc = VERR_NOT_SUPPORTED;
if (RT_SUCCESS(rc))
rc = VbglR3CtlFilterMask(VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST, 0);
else
VbglR3CtlFilterMask(0, VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST);
/* Log and ignore the return value, as there is not much we can do with
* it. */
LogRelFlowFunc(("dynamic resizing: result %Rrc\n", rc));
/* Enable support for switching between hardware and software cursors */
LogRelFlowFunc(("enabling relative mouse re-capturing support\n"));
rc = VbglR3GetMouseStatus(&fMouseFeatures, NULL, NULL);
if (RT_SUCCESS(rc))
{
rc = VbglR3CtlFilterMask(VMMDEV_EVENT_MOUSE_CAPABILITIES_CHANGED,
0);
if (RT_SUCCESS(rc))
rc = VbglR3SetMouseStatus
( fMouseFeatures
& ~VMMDEV_MOUSE_GUEST_NEEDS_HOST_CURSOR);
}
if (RT_FAILURE(rc))
{
VbglR3CtlFilterMask(0, VMMDEV_EVENT_MOUSE_CAPABILITIES_CHANGED);
VbglR3SetMouseStatus( fMouseFeatures
| VMMDEV_MOUSE_GUEST_NEEDS_HOST_CURSOR);
}
LogRelFlowFunc(("mouse re-capturing support: result %Rrc\n", rc));
return VINF_SUCCESS;
}
// Initialize X11 display and look for supported X11 extensions
//
static GLFWbool initExtensions(void)
{
// Find or create window manager atoms
_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.MOTIF_WM_HINTS = XInternAtom(_glfw.x11.display,
"_MOTIF_WM_HINTS",
False);
#if defined(_GLFW_HAS_XF86VM)
// Check for XF86VidMode extension
_glfw.x11.vidmode.available =
XF86VidModeQueryExtension(_glfw.x11.display,
&_glfw.x11.vidmode.eventBase,
&_glfw.x11.vidmode.errorBase);
#endif /*_GLFW_HAS_XF86VM*/
// Check for RandR extension
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 = XRRGetScreenResources(_glfw.x11.display,
_glfw.x11.root);
if (!sr->ncrtc || !XRRGetCrtcGammaSize(_glfw.x11.display, sr->crtcs[0]))
{
// This is either a headless system or an older Nvidia binary driver
// with broken gamma support
// Flag it as useless and fall back to Xf86VidMode gamma, if
// available
_glfwInputError(GLFW_PLATFORM_ERROR,
"X11: RandR gamma ramp support seems broken");
_glfw.x11.randr.gammaBroken = GLFW_TRUE;
}
XRRFreeScreenResources(sr);
XRRSelectInput(_glfw.x11.display, _glfw.x11.root,
RROutputChangeNotifyMask);
}
if (XineramaQueryExtension(_glfw.x11.display,
&_glfw.x11.xinerama.major,
&_glfw.x11.xinerama.minor))
{
if (XineramaIsActive(_glfw.x11.display))
_glfw.x11.xinerama.available = GLFW_TRUE;
}
#if defined(_GLFW_HAS_XINPUT)
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) != BadRequest)
{
_glfw.x11.xi.available = GLFW_TRUE;
}
}
#endif /*_GLFW_HAS_XINPUT*/
// Check if Xkb is supported on this display
_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;
}
}
// 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();
// Find or create 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.COMPOUND_STRING =
XInternAtom(_glfw.x11.display, "COMPOUND_STRING", False);
_glfw.x11.ATOM_PAIR = XInternAtom(_glfw.x11.display, "ATOM_PAIR", False);
// Find or create selection property atom
_glfw.x11.GLFW_SELECTION =
XInternAtom(_glfw.x11.display, "GLFW_SELECTION", False);
// Find or create standard clipboard atoms
_glfw.x11.TARGETS = XInternAtom(_glfw.x11.display, "TARGETS", False);
_glfw.x11.MULTIPLE = XInternAtom(_glfw.x11.display, "MULTIPLE", False);
_glfw.x11.CLIPBOARD = XInternAtom(_glfw.x11.display, "CLIPBOARD", False);
// Find or create 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);
// Find Xdnd (drag and drop) atoms, if available
_glfw.x11.XdndAware = XInternAtom(_glfw.x11.display, "XdndAware", True);
_glfw.x11.XdndEnter = XInternAtom(_glfw.x11.display, "XdndEnter", True);
_glfw.x11.XdndPosition = XInternAtom(_glfw.x11.display, "XdndPosition", True);
_glfw.x11.XdndStatus = XInternAtom(_glfw.x11.display, "XdndStatus", True);
_glfw.x11.XdndActionCopy = XInternAtom(_glfw.x11.display, "XdndActionCopy", True);
_glfw.x11.XdndDrop = XInternAtom(_glfw.x11.display, "XdndDrop", True);
_glfw.x11.XdndLeave = XInternAtom(_glfw.x11.display, "XdndLeave", True);
_glfw.x11.XdndFinished = XInternAtom(_glfw.x11.display, "XdndFinished", True);
_glfw.x11.XdndSelection = XInternAtom(_glfw.x11.display, "XdndSelection", True);
return GLFW_TRUE;
}
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;
}
int
main(int argc, char *argv[], char *env[])
{
char *display_name = NULL;
char *device_name = NULL;
char *output_name = NULL;
XSetWindowAttributes xswa;
int i = 0;
double a, a1, a2, b, b1, b2, xerr, yerr;
int xi_opcode, event, error;
XExtensionVersion *version;
XDeviceInfo *info;
XDevice *device;
long calib_data[4];
unsigned long mask;
unsigned char swap;
int keep_cursor = 0, ch;
/* Crosshair placement */
int cpx[] = { 0, 0, 1, 1, 1 };
int cpy[] = { 0, 1, 0, 0, 1 };
while ((ch = getopt(argc, argv, "cD:d:o:v")) != -1) {
switch (ch) {
case 'c':
keep_cursor++;
break;
case 'D':
display_name = optarg;
break;
case 'd':
device_name = optarg;
break;
case 'o':
output_name = optarg;
break;
case 'v':
verbose = True;
break;
default:
usage();
/* NOTREACHED */
}
}
argc -= optind;
argv += optind;
if (argc != 0)
usage();
/* connect to X server */
if ((display = XOpenDisplay(display_name)) == NULL) {
fprintf(stderr, "%s: cannot connect to X server %s\n",
__progname, XDisplayName(display_name));
exit(1);
}
screen = DefaultScreen(display);
root = RootWindow(display, screen);
/* get screen size from display structure macro */
xpos = 0;
ypos = 0;
width = DisplayWidth(display, screen);
height = DisplayHeight(display, screen);
if (XRRQueryExtension(display, &event, &error)) {
int major, minor;
if (XRRQueryVersion(display, &major, &minor) != True) {
fprintf(stderr, "Error querying XRandR version");
} else {
printf("XRandR extension version %d.%d present\n",
major, minor);
has_xrandr = True;
if (major > 1 || (major == 1 && minor >=2))
has_xrandr_1_2 = True;
if (major > 1 || (major == 1 && minor >=3))
has_xrandr_1_3 = True;
}
}
if (output_name != NULL) {
if (has_xrandr_1_2) {
get_xrandr_config(display, root, output_name,
&xpos, &ypos, &width, &height);
} else {
fprintf(stderr, "%s: can not specify an output "
"whithout XRandr 1.2 or later", __progname);
exit(2);
}
}
if (!XQueryExtension(display, INAME, &xi_opcode,
&event, &error)) {
fprintf(stderr, "%s: X Input extension not available.\n",
__progname);
exit(1);
}
version = XGetExtensionVersion(display, INAME);
if (version == NULL ||
version == (XExtensionVersion *)NoSuchExtension) {
fprintf(stderr, "Cannot query X Input version.\n");
exit(1);
}
XFree(version);
prop_calibration = XInternAtom(display, WS_PROP_CALIBRATION, True);
if (prop_calibration == None) {
fprintf(stderr, "Unable to find the \"%s\" device property.\n"
"There are probably no calibrable devices "
"on this system.\n", WS_PROP_CALIBRATION);
exit(1);
}
prop_swap = XInternAtom(display, WS_PROP_SWAP_AXES, True);
if (prop_swap == None) {
fprintf(stderr, "Unable to find the \"%s\" device property\n",
WS_PROP_SWAP_AXES);
exit(1);
}
info = find_device_info(device_name);
if (info == NULL) {
fprintf(stderr, "Unable to find the %s device\n",
device_name ? device_name : "default");
exit(1);
}
/* setup window attributes */
xswa.override_redirect = True;
xswa.background_pixel = BlackPixel(display, screen);
xswa.event_mask = ExposureMask | KeyPressMask;
mask = CWOverrideRedirect | CWBackPixel | CWEventMask;
if (!keep_cursor) {
xswa.cursor = create_empty_cursor();
mask |= CWCursor;
}
win = XCreateWindow(display, RootWindow(display, screen),
xpos, ypos, width, height, 0,
CopyFromParent, InputOutput, CopyFromParent,
mask, &xswa);
render_init();
XMapWindow(display, win);
XGrabKeyboard(display, win, False, GrabModeAsync, GrabModeAsync,
CurrentTime);
XGrabServer(display);
XClearWindow(display, win);
if (verbose)
printf("Calibrating %s\n", info->name);
device = XOpenDevice(display, info->id);
if (!device) {
fprintf(stderr, "Unable to open the X input device \"%s\"\n",
info->name);
return 0;
}
if (!register_events(info, device, 0))
exit(1);
uncalibrate(device);
calib:
XftDrawRect(draw, &bg, 0, 0, width, height);
for (i = 0; i < 5; i++) {
draw_graphics(cpx[i], cpy[i], i);
XFlush(display);
if (!get_events(i))
break;
XftDrawRect(draw, &bg, 0, 0, width, height);
}
if (interrupted)
cleanup_exit(device);
/* Check if X and Y should be swapped */
if (fabs(x[0] - x[1]) > fabs(y[0] - y[1])) {
calib.swapxy = 1;
for (i = 0; i < 5; i++) {
int t = x[i];
x[i] = y[i];
y[i] = t;
}
}
/* get touch pad resolution to screen resolution ratio */
a1 = (double) (x[4] - x[0]) / (double) (cx[4] - cx[0]);
a2 = (double) (x[3] - x[1]) / (double) (cx[3] - cx[1]);
/* get the minimum pad position on the X-axis */
b1 = x[0] - a1 * cx[0];
b2 = x[1] - a2 * cx[1];
/* use the average ratio and average minimum position */
a = (a1 + a2) / 2.0;
b = (b1 + b2) / 2.0;
xerr = a * width / 2 + b - x[2];
if (fabs(xerr) > fabs(a * width * .01)) {
fprintf(stderr, "Calibration problem: X axis error (%.2f) too high, try again\n",
fabs(xerr));
goto err;
}
calib.minx = (int) (b + 0.5);
calib.maxx = (int) (a * width + b + 0.5);
/* get touch pad resolution to screen resolution ratio */
a1 = (double) (y[4] - y[0]) / (double) (cy[4] - cy[0]);
a2 = (double) (y[3] - y[1]) / (double) (cy[3] - cy[1]);
/* get the minimum pad position on the Y-axis */
b1 = y[0] - a1 * cy[0];
b2 = y[1] - a2 * cy[1];
/* use the average ratio and average minimum position */
a = (a1 + a2) / 2.0;
b = (b1 + b2) / 2.0;
yerr = a * height / 2 + b - y[2];
if (fabs(yerr) > fabs(a * height * 0.01)) {
fprintf(stderr, "Calibration problem: Y axis error (%.2f) too high, try again\n",
fabs(yerr));
goto err;
}
calib.miny = (int) (b + 0.5);
calib.maxy = (int) (a * height + b + 0.5);
XFlush(display);
calib.resx = width;
calib.resy = height;
/* Send new values to the X server */
calib_data[0] = calib.minx;
calib_data[1] = calib.maxx;
calib_data[2] = calib.miny;
calib_data[3] = calib.maxy;
XChangeDeviceProperty(display, device, prop_calibration,
XA_INTEGER, 32, PropModeReplace, (unsigned char *)calib_data, 4);
swap = calib.swapxy;
XChangeDeviceProperty(display, device, prop_swap,
XA_INTEGER, 8, PropModeReplace, (unsigned char *)&swap, 1);
XCloseDevice(display, device);
XCloseDisplay(display);
/* And print them for storage in wsconsctl.conf */
printf("mouse.scale=%d,%d,%d,%d,%d,%d,%d\n",
calib.minx, calib.maxx,
calib.miny, calib.maxy,
calib.swapxy,
calib.resx, calib.resy);
return 0;
err:
draw_text(error_message, &errorColor);
XFlush(display);
sleep(2);
goto calib;
}
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;
}
