/*! Tries to ask the X Composite extension (if supported) to redirect all
windows on all screens to backing storage. This does not have
any effect if another application already requested the same
thing (typically the window manager does this).
*/
void WindowImageProvider::activateComposite()
{
int event_base;
int error_base;
Display *display = QX11Info::display();
bool compositeSupport = false;
if (XCompositeQueryExtension(display, &event_base, &error_base)) {
int major = 0;
int minor = 2;
XCompositeQueryVersion(display, &major, &minor);
if (major > 0 || minor >= 2) {
compositeSupport = true;
(UQ_DEBUG).nospace() << "Server supports the Composite extension (ver "
<< major << "." << minor << ")";
}
else {
(UQ_DEBUG).nospace() << "Server supports the Composite extension, but "
"version is < 0.2 (ver " << major << "." << minor << ")";
}
} else {
UQ_DEBUG << "Server doesn't support the Composite extension.";
}
if (compositeSupport) {
int screens = ScreenCount(display);
for (int i = 0; i < screens; ++i) {
XCompositeRedirectSubwindows(display, RootWindow(display, i),
CompositeRedirectAutomatic);
}
}
}
static bool supportsXDamageAndXComposite(GdkWindow* window)
{
static bool initialized = false;
static bool hasExtensions = false;
if (initialized)
return hasExtensions;
initialized = true;
Display* display = GDK_DISPLAY_XDISPLAY(gdk_window_get_display(window));
int errorBase;
if (!XDamageQueryExtension(display, &XDamageNotifier::s_damageEventBase, &errorBase))
return false;
int eventBase;
if (!XCompositeQueryExtension(display, &eventBase, &errorBase))
return false;
// We need to support XComposite version 0.2.
int major, minor;
XCompositeQueryVersion(display, &major, &minor);
if (major < 0 || (!major && minor < 2))
return false;
hasExtensions = true;
return true;
}
void check_features(void) {
int event_base, error_base, glxver;
int major = 0, minor = 3;
if(!XCompositeQueryExtension(dpy, &event_base, &error_base))
die(1, "Composite extension not available\n");
if(!XCompositeQueryVersion(dpy, &major, &minor))
die(1, "Composite extension version >=0.3 is required\n");
if(!XShapeQueryExtension(dpy, &event_base, &error_base))
die(1, "Shape extension not available\n");
if(!XDamageQueryExtension(dpy, &event_base, &error_base))
die(1, "Damage extension not available\n");
if(!glXQueryExtension(dpy, &event_base, &error_base))
die(1, "GLX extension not available\n");
glXQueryVersion(dpy, &major, &minor);
glxver = MAKE_GL_VERSION(major, minor, 0);
if(glxver < 0x010300) // GLX 1.3 required
die(1, "GLX version >=1.3 is required\n");
info("All features supported\n");
}
void stubCheckXExtensions(WindowInfo *pWindow)
{
int evb, erb, vmi=0, vma=0;
Display *dpy = stubGetWindowDisplay(pWindow);
stub.bXExtensionsChecked = GL_TRUE;
stub.trackWindowVisibleRgn = 0;
XLOCK(dpy);
if (XCompositeQueryExtension(dpy, &evb, &erb)
&& XCompositeQueryVersion(dpy, &vma, &vmi)
&& (vma>0 || vmi>=4))
{
stub.bHaveXComposite = GL_TRUE;
crDebug("XComposite %i.%i", vma, vmi);
vma=0;
vmi=0;
if (XFixesQueryExtension(dpy, &evb, &erb)
&& XFixesQueryVersion(dpy, &vma, &vmi)
&& vma>=2)
{
crDebug("XFixes %i.%i", vma, vmi);
stub.bHaveXFixes = GL_TRUE;
stub.trackWindowVisibleRgn = 1;
XUNLOCK(dpy);
return;
}
else
{
crWarning("XFixes not found or old version (%i.%i), no VisibilityTracking", vma, vmi);
}
}
else
{
crWarning("XComposite not found or old version (%i.%i), no VisibilityTracking", vma, vmi);
}
XUNLOCK(dpy);
return;
}
/**
* clutter_x11_has_composite_extension:
*
* Retrieves whether Clutter is running on an X11 server with the
* XComposite extension
*
* Return value: %TRUE if the XComposite extension is available
*/
gboolean
clutter_x11_has_composite_extension (void)
{
#if HAVE_XCOMPOSITE
static gboolean have_composite = FALSE, done_check = FALSE;
int error = 0, event = 0;
Display *dpy;
if (done_check)
return have_composite;
if (!_clutter_context_is_initialized ())
{
g_critical ("X11 backend has not been initialised");
return FALSE;
}
dpy = clutter_x11_get_default_display();
if (dpy == NULL)
return FALSE;
if (XCompositeQueryExtension (dpy, &event, &error))
{
int major = 0, minor = 0;
if (XCompositeQueryVersion (dpy, &major, &minor))
{
if (major >= 0 && minor >= 3)
have_composite = TRUE;
}
}
done_check = TRUE;
return have_composite;
#else
return FALSE;
#endif /* HAVE_XCOMPOSITE */
}
Bool
chkCompExt (Display * d)
{
int compositeErrorBase, compositeEventBase, xCompExtVerMin, xCompExtVerMaj;
char buf[1024];
logCtrl ("\tChecking composite extension", LOG_LVL_1, False);
if (XCompositeQueryExtension (d, &compositeEventBase,
&compositeErrorBase) == False)
{
logCtrl ("\t\tNo composite extension found, aborting!", LOG_LVL_NO,
True);
return False;
}
else if (! XCompositeQueryVersion (d, &xCompExtVerMaj, &xCompExtVerMin))
{
logCtrl ("\t\tX Server doesn't support such a version of the X "
"Composite Extension which is compatible with the client "
"library", LOG_LVL_NO, True);
return False;
}
else if ( ( xCompExtVerMaj < 1 ) && ( xCompExtVerMin < 2 ) )
{
logCtrl ("\t\tUnsupported version of X composite extension (<0.2)",
LOG_LVL_NO, True);
return False;
}
else
{
snprintf (buf, sizeof (buf), "\t\tversion %d.%d",
xCompExtVerMaj, xCompExtVerMin);
logCtrl (buf, LOG_LVL_2, True);
}
logCtrl ("\t\tSuccess", LOG_LVL_2, True);
return True;
}
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;
}
bool XCompcapMain::init()
{
if (!xdisp) {
blog(LOG_ERROR, "failed opening display");
return false;
}
int eventBase, errorBase;
if (!XCompositeQueryExtension(xdisp, &eventBase, &errorBase)) {
blog(LOG_ERROR, "Xcomposite extension not supported");
return false;
}
int major = 0, minor = 2;
XCompositeQueryVersion(xdisp, &major, &minor);
if (major == 0 && minor < 2) {
blog(LOG_ERROR, "Xcomposite extension is too old: %d.%d < 0.2",
major, minor);
return false;
}
return true;
}
PyObject *
X11Display_PyObject__composite_supported(X11Display_PyObject * self, PyObject * args)
{
#ifdef HAVE_X11_COMPOSITE
int event_base, error_base;
if ( XCompositeQueryExtension( self->display, &event_base, &error_base ) ) {
// If we get here the server supports the extension
int major = 0, minor = 2; // The highest version we support
XCompositeQueryVersion( self->display, &major, &minor );
// major and minor will now contain the highest version the server supports.
// The protocol specifies that the returned version will never be higher
// then the one requested. Version 0.2 is the first version to have the
// XCompositeNameWindowPixmap() request.
if ( major > 0 || minor >= 2 ) {
Py_INCREF(Py_True);
return Py_True;
}
}
#endif
Py_INCREF(Py_False);
return Py_False;
}
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;
}
Bool
addDisplay (char *name,
char **plugin,
int nPlugin)
{
CompDisplay *d;
Display *dpy;
int i;
d = &compDisplay;
if (displayPrivateLen)
{
d->privates = malloc (displayPrivateLen * sizeof (CompPrivate));
if (!d->privates)
return FALSE;
}
else
d->privates = 0;
d->screenPrivateIndices = 0;
d->screenPrivateLen = 0;
for (i = 0; i < CompModNum; i++)
d->modMask[i] = CompNoMask;
d->plugin.list.type = CompOptionTypeString;
d->plugin.list.nValue = 0;
d->plugin.list.value = 0;
compDisplayInitOptions (d, plugin, nPlugin);
d->textureFilter = GL_LINEAR;
d->display = dpy = XOpenDisplay (name);
if (!d->display)
{
fprintf (stderr, "%s: Couldn't open display %s\n",
programName, XDisplayName (name));
return FALSE;
}
#ifdef DEBUG
XSynchronize (dpy, TRUE);
#endif
XSetErrorHandler (errorHandler);
updateModifierMappings (d);
d->setDisplayOption = setDisplayOption;
d->setDisplayOptionForPlugin = setDisplayOptionForPlugin;
d->initPluginForDisplay = initPluginForDisplay;
d->finiPluginForDisplay = finiPluginForDisplay;
d->handleEvent = handleEvent;
d->winTypeAtom = XInternAtom (dpy, "_NET_WM_WINDOW_TYPE", 0);
d->winDesktopAtom = XInternAtom (dpy, "_NET_WM_WINDOW_TYPE_DESKTOP", 0);
d->winDockAtom = XInternAtom (dpy, "_NET_WM_WINDOW_TYPE_DOCK", 0);
d->winToolbarAtom = XInternAtom (dpy, "_NET_WM_WINDOW_TYPE_TOOLBAR", 0);
d->winMenuAtom = XInternAtom (dpy, "_NET_WM_WINDOW_TYPE_MENU", 0);
d->winUtilAtom = XInternAtom (dpy, "_NET_WM_WINDOW_TYPE_UTILITY", 0);
d->winSplashAtom = XInternAtom (dpy, "_NET_WM_WINDOW_TYPE_SPLASH", 0);
d->winDialogAtom = XInternAtom (dpy, "_NET_WM_WINDOW_TYPE_DIALOG", 0);
d->winNormalAtom = XInternAtom (dpy, "_NET_WM_WINDOW_TYPE_NORMAL", 0);
d->winOpacityAtom = XInternAtom (dpy, "_NET_WM_WINDOW_OPACITY", 0);
d->winActiveAtom = XInternAtom (dpy, "_NET_ACTIVE_WINDOW", 0);
d->wmStateAtom = XInternAtom (dpy, "WM_STATE", 0);
d->wmDeleteWindowAtom = XInternAtom (dpy, "WM_DELETE_WINDOW", 0);
d->xBackgroundAtom[0] = XInternAtom (dpy, "_XSETROOT_ID", 0);
d->xBackgroundAtom[1] = XInternAtom (dpy, "_XROOTPMAP_ID", 0);
if (testMode)
{
d->compositeOpcode = MAXSHORT;
d->compositeEvent = MAXSHORT;
d->compositeError = MAXSHORT;
d->damageEvent = MAXSHORT;
d->damageError = MAXSHORT;
}
else
{
int compositeMajor, compositeMinor;
if (!XQueryExtension (dpy,
COMPOSITE_NAME,
&d->compositeOpcode,
&d->compositeEvent,
&d->compositeError))
{
fprintf (stderr, "%s: No composite extension\n", programName);
return FALSE;
}
XCompositeQueryVersion (dpy, &compositeMajor, &compositeMinor);
if (compositeMajor == 0 && compositeMinor < 2)
{
fprintf (stderr, "%s: Old composite extension\n", programName);
return FALSE;
}
if (!XDamageQueryExtension (dpy, &d->damageEvent, &d->damageError))
{
fprintf (stderr, "%s: No damage extension\n", programName);
return FALSE;
}
}
d->shapeExtension = XShapeQueryExtension (dpy,
&d->shapeEvent,
&d->shapeError);
compDisplays = d;
if (testMode)
{
addScreen (d, 0);
}
else
{
XGrabServer (dpy);
for (i = 0; i < ScreenCount (dpy); i++)
{
redirectFailed = 0;
XCompositeRedirectSubwindows (dpy, XRootWindow (dpy, i),
CompositeRedirectManual);
XSync (dpy, FALSE);
if (redirectFailed)
{
fprintf (stderr, "%s: Another composite manager is already "
"running on screen: %d\n", programName, i);
}
else
{
if (!addScreen (d, i))
{
fprintf (stderr, "%s: Failed to manage screen: %d\n",
programName, i);
}
}
}
XUngrabServer (dpy);
}
if (!d->screens)
{
fprintf (stderr, "%s: No managable screens found on display %s\n",
programName, XDisplayName (name));
return FALSE;
}
return TRUE;
}
bool MImXCompositeExtension::queryVersion(int *major, int *minor) const
{
return XCompositeQueryVersion(QX11Info::display(), major, minor) != 0;
}
int xcomposite_get_widow_contents()
{
int ret = 0;
int ver, rev, eventB, baseB;
int x, y;
Pixmap pxm = 0;
window_struct params;
if(create_window(¶ms, "Test Window"))
{
ret = -1;
goto cleanup;
}
if(!XCompositeQueryExtension(params.display, &eventB, &baseB))
{
BLTS_ERROR("XCompositeQueryExtension failed\n");
ret = -1;
goto cleanup;
}
if(!XCompositeQueryVersion(params.display, &ver, &rev))
{
BLTS_ERROR("XCompositeQueryVersion failed\n");
ret = -1;
goto cleanup;
}
BLTS_DEBUG("XComposite Extension version %i.%i\n", ver, rev);
/* Redirect window to off-screen storage (the window might be already
redirected when using composite window manager) */
XCompositeRedirectWindow(params.display, params.window, 0);
/* Draw rectangle pattern */
for(x = 0; x < params.window_attributes.width; x+=20)
{
for(y = 0; y < params.window_attributes.height; y+=20)
{
XFillRectangle(params.display, params.window, params.gc, x, y,
10, 10);
}
}
XFlush(params.display);
sleep(1);
/* Get pixmap of window contents */
pxm = XCompositeNameWindowPixmap(params.display, params.window);
XCompositeUnredirectWindow(params.display, params.window, 0);
/* Copy the pixmap over the window (you should see white/black stripes
* after this)
*/
for(y = 0; y < params.window_attributes.height; y++)
{
XCopyArea(params.display, pxm, params.window, params.gc, 0, 0,
params.window_attributes.width, params.window_attributes.height,
0, y );
}
XFlush(params.display);
sleep(1);
cleanup:
if(params.display && pxm)
{
XFreePixmap(params.display, pxm);
}
close_window(¶ms);
return ret;
}
WindowsModel::WindowsModel (QObject *parent)
: QAbstractItemModel (parent)
, CurrentDesktop_ (Util::XWrapper::Instance ().GetCurrentDesktop ())
, ImageProvider_ (new TaskbarImageProvider (QIcon::fromTheme ("xorg")))
{
auto& w = Util::XWrapper::Instance ();
auto windows = w.GetWindows ();
for (auto wid : windows)
AddWindow (wid, w);
connect (&w,
SIGNAL (windowListChanged ()),
this,
SLOT (updateWinList ()));
connect (&w,
SIGNAL (activeWindowChanged ()),
this,
SLOT (updateActiveWindow ()));
connect (&w,
SIGNAL (windowNameChanged (ulong)),
this,
SLOT (updateWindowName (ulong)));
connect (&w,
SIGNAL (windowIconChanged (ulong)),
this,
SLOT (updateWindowIcon (ulong)));
connect (&w,
SIGNAL (windowStateChanged (ulong)),
this,
SLOT (updateWindowState (ulong)));
connect (&w,
SIGNAL (windowActionsChanged (ulong)),
this,
SLOT (updateWindowActions (ulong)));
connect (&w,
SIGNAL (windowDesktopChanged (ulong)),
this,
SLOT (updateWindowDesktop (ulong)));
connect (&w,
SIGNAL (desktopChanged ()),
this,
SLOT (updateCurrentDesktop ()));
QHash<int, QByteArray> roleNames;
roleNames [Role::WindowName] = "windowName";
roleNames [Role::WindowID] = "windowID";
roleNames [Role::IconGenID] = "iconGenID";
roleNames [Role::IsCurrentDesktop] = "isCurrentDesktop";
roleNames [Role::IsActiveWindow] = "isActiveWindow";
roleNames [Role::IsMinimizedWindow] = "isMinimizedWindow";
setRoleNames (roleNames);
int eventBase, errorBase;
if (XCompositeQueryExtension (w.GetDisplay (), &eventBase, &errorBase))
{
int major = 0, minor = 2;
XCompositeQueryVersion (w.GetDisplay (), &major, &minor);
if (major > 0 || minor >= 2)
qDebug () << "all good, has NamePixmap";
}
}
