kwin/lib/kwinglobals.cpp

/********************************************************************
 KWin - the KDE window manager
 This file is part of the KDE project.

Copyright (C) 2006 Lubos Lunak <l.lunak@kde.org>

This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*********************************************************************/

#include "kwinglobals.h"

#include <config-workspace.h>
#include <config-X11.h>

#include <assert.h>

#include <kdebug.h>

#include <X11/Xlib.h>
#include <X11/extensions/shape.h>

#ifdef HAVE_XRENDER
#include <X11/extensions/Xrender.h>
#endif
#ifdef HAVE_XFIXES
#include <X11/extensions/Xfixes.h>
#endif
#ifdef HAVE_XDAMAGE
#include <X11/extensions/Xdamage.h>
#endif
#ifdef HAVE_XRANDR
#include <X11/extensions/Xrandr.h>
#endif
#ifdef HAVE_XCOMPOSITE
#include <X11/extensions/Xcomposite.h>
#endif
#ifdef HAVE_OPENGL
#include <GL/glx.h>
#endif
#ifdef HAVE_XSYNC
#include <X11/extensions/sync.h>
#endif

namespace KWin
{

int Extensions::shape_version = 0;
int Extensions::shape_event_base = 0;
bool Extensions::has_randr = false;
int Extensions::randr_event_base = 0;
bool Extensions::has_damage = false;
int Extensions::damage_event_base = 0;
int Extensions::composite_version = 0;
int Extensions::fixes_version = 0;
int Extensions::render_version = 0;
bool Extensions::has_glx = false;
bool Extensions::has_sync = false;
int Extensions::sync_event_base = 0;
// for fillExtensionsData()
const char* Extensions::data_extensions[ 32 ];
int Extensions::data_nextensions;
int Extensions::data_opcodes[ 32 ];
int Extensions::data_error_bases[ 32 ];

void Extensions::addData(const char* name)
{
    assert(data_nextensions < 32);
    int opcode, event_base, error_base;
    XQueryExtension(display(), name, &opcode, &event_base, &error_base);
    data_extensions[ data_nextensions ] = name;
    data_opcodes[ data_nextensions ] = opcode;
    data_error_bases[ data_nextensions ] = error_base;
    ++data_nextensions;
}

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
#ifndef KWIN_HAVE_OPENGLES
    has_glx = glXQueryExtension(display(), &event_base, &error_base);
    if (has_glx)
        addData("GLX");
#endif
#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;
}

void Extensions::fillExtensionsData(const char**& extensions, int& nextensions, int*&opcodes, int*& error_bases)
{
    extensions = data_extensions;
    nextensions = data_nextensions;
    opcodes = data_opcodes;
    error_bases = data_error_bases;
}

int Extensions::shapeNotifyEvent()
{
    return shape_event_base + ShapeNotify;
}

// does the window w need a shape combine mask around it?
bool Extensions::hasShape(Window w)
{
    int xws, yws, xbs, ybs;
    unsigned int wws, hws, wbs, hbs;
    int boundingShaped = 0, clipShaped = 0;
    if (!shapeAvailable())
        return false;
    XShapeQueryExtents(display(), w,
                       &boundingShaped, &xws, &yws, &wws, &hws,
                       &clipShaped, &xbs, &ybs, &wbs, &hbs);
    return boundingShaped != 0;
}

bool Extensions::shapeInputAvailable()
{
    return shape_version >= 0x11; // 1.1
}

int Extensions::randrNotifyEvent()
{
#ifdef HAVE_XRANDR
    return randr_event_base + RRScreenChangeNotify;
#else
    return 0;
#endif
}

int Extensions::damageNotifyEvent()
{
#ifdef HAVE_XDAMAGE
    return damage_event_base + XDamageNotify;
#else
    return 0;
#endif
}

bool Extensions::compositeOverlayAvailable()
{
    return composite_version >= 0x03; // 0.3
}

bool Extensions::fixesRegionAvailable()
{
    return fixes_version >= 0x30; // 3
}

int Extensions::syncAlarmNotifyEvent()
{
#ifdef HAVE_XSYNC
    return sync_event_base + XSyncAlarmNotify;
#else
    return 0;
#endif
}

} // namespace