gboolean xdk_display_has_composite_extension(XdkDisplay * self)
{
g_return_val_if_fail(self, FALSE);
int event_base, error_base;
return XCompositeQueryExtension(self->priv->peer, & event_base, & error_base);
}
static gboolean
_has_composite (Display *display)
{
int dummy1, dummy2;
return XCompositeQueryExtension (display, &dummy1, &dummy2);
}
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;
}
/*! 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);
}
}
}
Bool
composite_check_ext_and_mgr(Display* dsp, int scr)
{
int event_base, error_base;
Atom comp_manager_atom;
char comp_manager_hint[32];
if (!XCompositeQueryExtension(dsp, &event_base, &error_base))
return False;
snprintf(comp_manager_hint, 32, "_NET_WM_CM_S%d", scr);
comp_manager_atom = XInternAtom(dsp, comp_manager_hint, False);
return (XGetSelectionOwner(dsp, comp_manager_atom) != None);
}
QT_BEGIN_NAMESPACE
XCompositeHandler::XCompositeHandler(QWaylandCompositor *compositor, Display *display)
: QtWaylandServer::qt_xcomposite(compositor->display(), 1)
{
mFakeRootWindow = new QWindow();
mFakeRootWindow->setGeometry(QRect(-1,-1,1,1));
mFakeRootWindow->create();
mFakeRootWindow->show();
int composite_event_base, composite_error_base;
if (!XCompositeQueryExtension(display, &composite_event_base, &composite_error_base))
qFatal("XComposite required");
mDisplayString = QString::fromLocal8Bit(XDisplayString(display));
}
static DFBResult
x11InitPool( CoreDFB *core,
CoreSurfacePool *pool,
void *pool_data,
void *pool_local,
void *system_data,
CoreSurfacePoolDescription *ret_desc )
{
DFBResult ret;
x11PoolLocalData *local = pool_local;
DFBX11 *x11 = system_data;
D_DEBUG_AT( X11_Surfaces, "%s()\n", __FUNCTION__ );
D_MAGIC_ASSERT( pool, CoreSurfacePool );
D_ASSERT( ret_desc != NULL );
local->x11 = x11;
ret_desc->caps = CSPCAPS_NONE;
ret_desc->types = CSTF_LAYER | CSTF_WINDOW | CSTF_SHARED | CSTF_EXTERNAL;
ret_desc->priority = CSPP_ULTIMATE;
/* For showing our X11 window */
ret_desc->access[CSAID_LAYER0] = CSAF_READ;
ret_desc->access[CSAID_LAYER1] = CSAF_READ;
ret_desc->access[CSAID_LAYER2] = CSAF_READ;
snprintf( ret_desc->name, DFB_SURFACE_POOL_DESC_NAME_LENGTH, "X11 Windows" );
ret = direct_hash_create( 7, &local->hash );
if (ret) {
D_DERROR( ret, "X11/Surfaces: Could not create local hash table!\n" );
return ret;
}
pthread_mutex_init( &local->lock, NULL );
int event_base_return, error_base_return;
XLockDisplay( x11->display );
XCompositeQueryExtension( x11->display, &event_base_return, &error_base_return );
x11->Sync( x11 );
XUnlockDisplay( x11->display );
return DFB_OK;
}
static gboolean
ccm_display_init_composite (CCMDisplay * self)
{
g_return_val_if_fail (self != NULL, FALSE);
if (XCompositeQueryExtension (self->priv->xdisplay,
&self->priv->composite.event_base,
&self->priv->composite.error_base))
{
self->priv->composite.available = TRUE;
ccm_debug ("COMPOSITE EVENT BASE: %i", self->priv->composite.event_base);
ccm_debug ("COMPOSITE ERROR BASE: %i",
self->priv->composite.error_base);
return TRUE;
}
return FALSE;
}
static void
constructed(GObject *base)
{
struct Private *priv = GET_PRIVATE(base);
JoyScreen *self = JOY_SCREEN(base);
Display *display = joy_x11_screen_get_display(self);
if (G_UNLIKELY(!display)) {
goto exit;
}
priv->composite = FALSE;
#ifdef HAVE_XCOMPOSITE
gint ignore;
if (XCompositeQueryExtension(display, &ignore, &ignore)) {
priv->composite = TRUE;
}
#endif
// search for the best Visual
XVisualInfo template;
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;
}
FdoSelectionManagerPrivate(FdoSelectionManager *q)
: q(q),
notificationsEngine(0),
haveComposite(false)
{
display = QX11Info::display();
selectionAtom = XInternAtom(display, "_NET_SYSTEM_TRAY_S" + QByteArray::number(QX11Info::appScreen()), false);
opcodeAtom = XInternAtom(display, "_NET_SYSTEM_TRAY_OPCODE", false);
messageAtom = XInternAtom(display, "_NET_SYSTEM_TRAY_MESSAGE_DATA", false);
visualAtom = XInternAtom(display, "_NET_SYSTEM_TRAY_VISUAL", false);
#if defined(HAVE_XFIXES) && defined(HAVE_XDAMAGE) && defined(HAVE_XCOMPOSITE)
int eventBase, errorBase;
bool haveXfixes = XFixesQueryExtension(display, &eventBase, &errorBase);
bool haveXdamage = XDamageQueryExtension(display, &damageEventBase, &errorBase);
bool haveXComposite = XCompositeQueryExtension(display, &eventBase, &errorBase);
if (haveXfixes && haveXdamage && haveXComposite) {
haveComposite = true;
oldEventFilter = QCoreApplication::instance()->setEventFilter(x11EventFilter);
}
#endif
}
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;
}
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";
}
}
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);
}
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;
}
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 TrayIcon::isXCompositeAvailable()
{
int eventBase, errorBase;
return XCompositeQueryExtension(QX11Info::display(), &eventBase, &errorBase );
}
QFwhm::QFwhm()
{
//
// checking if we have a composite window manager
//
#ifdef _X11_NEEDED_
// are extensions present ?
int base, error;
if(!XCompositeQueryExtension(QX11Info::display(),&base,&error)) {
QMessageBox::critical(this, tr("astrofocuser"),tr("Your window manager can't compose\nLeaving..."));
exit(1);
} else {
// is the atom defined
_NET_WM_CM_S0 = XInternAtom(QX11Info::display(), "_NET_WM_CM_S0", True);
if( _NET_WM_CM_S0 == None ) {
QMessageBox::critical(this, tr("astrofocuser"),tr("Your window manager can't compose\nLeaving..."));
exit(1);
}
// is a composite window manager running on the first display
if(XGetSelectionOwner(QX11Info::display(), _NET_WM_CM_S0) == None ){
QMessageBox::critical(this, tr("astrofocuser"),tr("Your window manager can't compose\nLeaving..."));
exit(1);
}
}
#endif
//
// init
//
// fwhm default value
fwhm_value=0.0;
// main window
setWindowTitle(QString::fromUtf8("FWHM"));
setAttribute(Qt::WA_TranslucentBackground);
setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
setFixedSize(FWHM_WIDTH,FWHM_HEIGHT+FWHM_LABEL_HEIGHT);
// picture hole for grabbing
hole=new QWidget();
hole->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
hole->setFixedSize(FWHM_WIDTH,FWHM_HEIGHT);
// FWHM value
value=new QLabel();
value->setStyleSheet("QLabel { background-color : black; color : yellow; font-size: 22px;}");
value->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
value->setFixedSize(FWHM_WIDTH,FWHM_LABEL_HEIGHT);
value->setAlignment(Qt::AlignRight);
// setting label text
fwhm_text.setNum(fwhm_value,'f',2);
value->setText(fwhm_text);
// Widget placement
grid=new QVBoxLayout();
grid->addWidget(hole,Qt::AlignTop);
grid->addWidget(value,Qt::AlignBottom);
grid->setContentsMargins (0,0,0,0);
setLayout(grid);
// display widget
show();
// timer loop
timer=new QTimer();
connect(timer, SIGNAL(timeout()), this, SLOT(compute()));
timer->start(200);
}
