composite.h

Go to the documentation of this file.

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

Copyright (C) 2011 Arthur Arlt <[email protected]>
Copyright (C) 2012 Martin Gräßlin <[email protected]>

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/>.
*********************************************************************/

#ifndef KWIN_COMPOSITE_H
#define KWIN_COMPOSITE_H
// KWin
#include <kwinglobals.h>
// KDE
#include <KSelectionOwner>
// Qt
#include <QObject>
#include <QElapsedTimer>
#include <QTimer>
#include <QBasicTimer>
#include <QRegion>

namespace KWin {

class Client;
class Scene;

class CompositorSelectionOwner : public KSelectionOwner
{
    Q_OBJECT
public:
    CompositorSelectionOwner(const char *selection);
private:
    friend class Compositor;
    bool owning;
private Q_SLOTS:
    void looseOwnership();
};

class Compositor : public QObject {
    Q_OBJECT
    Q_CLASSINFO("D-Bus Interface", "org.kde.kwin.Compositing")
    Q_PROPERTY(bool active READ isActive)
    Q_PROPERTY(bool compositingPossible READ isCompositingPossible)
    Q_PROPERTY(QString compositingNotPossibleReason READ compositingNotPossibleReason)
    Q_PROPERTY(bool openGLIsBroken READ isOpenGLBroken)
    Q_PROPERTY(QString compositingType READ compositingType)
public:
    enum SuspendReason { NoReasonSuspend = 0, UserSuspend = 1<<0, BlockRuleSuspend = 1<<1, ScriptSuspend = 1<<2, AllReasonSuspend = 0xff };
    Q_DECLARE_FLAGS(SuspendReasons, SuspendReason)
    ~Compositor();
    // when adding repaints caused by a window, you probably want to use
    // either Toplevel::addRepaint() or Toplevel::addWorkspaceRepaint()
    void addRepaint(const QRect& r);
    void addRepaint(const QRegion& r);
    void addRepaint(int x, int y, int w, int h);
    bool isActive();
    int xrrRefreshRate() const {
        return m_xrrRefreshRate;
    }
    void setCompositeResetTimer(int msecs);

    bool hasScene() const {
        return m_scene != NULL;
    }

    bool checkForOverlayWindow(WId w) const;
    WId overlayWindow() const;
    bool isOverlayWindowVisible() const;
    void setOverlayWindowVisibility(bool visible);
    void lastFrameRendered();

    Scene *scene() {
        return m_scene;
    }

    static bool isCreated() {
        return s_compositor != NULL;
    }
    static bool compositing() {
        return s_compositor != NULL && s_compositor->isActive();
    }

    // for delayed supportproperty management of effects
    void keepSupportProperty(xcb_atom_t atom);
    void removeSupportProperty(xcb_atom_t atom);

    // D-Bus: getters for Properties, see documentation on the property
    bool isCompositingPossible() const;
    QString compositingNotPossibleReason() const;
    bool isOpenGLBroken() const;
    QString compositingType() const;

public Q_SLOTS:
    void addRepaintFull();
    Q_SCRIPTABLE void toggleCompositing();
    Q_SCRIPTABLE inline void suspend() { suspend(ScriptSuspend); }
    void suspend(Compositor::SuspendReason reason);
    Q_SCRIPTABLE inline void resume() { resume(ScriptSuspend); }
    void resume(Compositor::SuspendReason reason);
    // NOTICE this is atm. for script usage *ONLY* and needs to be extended like resume / suspend are
    // if intended to be used from within KWin code!
    Q_SCRIPTABLE void setCompositing(bool active);
    void slotToggleCompositing();
    void slotReinitialize();
    void scheduleRepaint();
    void checkUnredirect();
    void checkUnredirect(bool force);
    void updateCompositeBlocking();
    void updateCompositeBlocking(KWin::Client* c);

    // For the D-Bus interface

Q_SIGNALS:
    Q_SCRIPTABLE void compositingToggled(bool active);

protected:
    void timerEvent(QTimerEvent *te);

private Q_SLOTS:
    void setup();
    void slotCompositingOptionsInitialized();
    void finish();
    void restart();
    void fallbackToXRenderCompositing();
    void performCompositing();
    void delayedCheckUnredirect();
    void slotConfigChanged();
    void releaseCompositorSelection();
    void deleteUnusedSupportProperties();

private:
    void setCompositeTimer();
    bool windowRepaintsPending() const;

    SuspendReasons m_suspended;

    QBasicTimer compositeTimer;
    CompositorSelectionOwner* cm_selection;
    QTimer m_releaseSelectionTimer;
    QList<xcb_atom_t> m_unusedSupportProperties;
    QTimer m_unusedSupportPropertyTimer;
    qint64 vBlankInterval, fpsInterval;
    int m_xrrRefreshRate;
    QElapsedTimer nextPaintReference;
    QRegion repaints_region;

    QTimer unredirectTimer;
    bool forceUnredirectCheck;
    QTimer compositeResetTimer; // for compressing composite resets
    bool m_finishing; // finish() sets this variable while shutting down
    bool m_starting; // start() sets this variable while starting
    qint64 m_timeSinceLastVBlank;
    Scene *m_scene;
    bool m_waitingForFrameRendered;

    KWIN_SINGLETON_VARIABLE(Compositor, s_compositor)
};
}

# endif // KWIN_COMPOSITE_H