You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
428 lines
14 KiB
428 lines
14 KiB
/******************************************************************** |
|
KWin - the KDE window manager |
|
This file is part of the KDE project. |
|
|
|
Copyright (C) 2006 Lubos Lunak <l.lunak@kde.org> |
|
Copyright (C) 2010, 2011 Martin Gräßlin <mgraesslin@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/>. |
|
*********************************************************************/ |
|
|
|
#ifndef KWIN_EFFECTSIMPL_H |
|
#define KWIN_EFFECTSIMPL_H |
|
|
|
#include "kwineffects.h" |
|
|
|
#include "scene.h" |
|
|
|
#include <QStack> |
|
#include <QHash> |
|
#include <Plasma/FrameSvg> |
|
|
|
|
|
class KService; |
|
|
|
|
|
namespace KWin |
|
{ |
|
|
|
class ThumbnailItem; |
|
|
|
class Client; |
|
class Compositor; |
|
class Deleted; |
|
class Unmanaged; |
|
|
|
class EffectsHandlerImpl : public EffectsHandler |
|
{ |
|
Q_OBJECT |
|
Q_CLASSINFO("D-Bus Interface", "org.kde.kwin.Effects") |
|
Q_PROPERTY(QStringList activeEffects READ activeEffects) |
|
Q_PROPERTY(QStringList loadedEffects READ loadedEffects) |
|
Q_PROPERTY(QStringList listOfEffects READ listOfEffects) |
|
public: |
|
EffectsHandlerImpl(Compositor *compositor, Scene *scene); |
|
virtual ~EffectsHandlerImpl(); |
|
virtual void prePaintScreen(ScreenPrePaintData& data, int time); |
|
virtual void paintScreen(int mask, QRegion region, ScreenPaintData& data); |
|
virtual void postPaintScreen(); |
|
virtual void prePaintWindow(EffectWindow* w, WindowPrePaintData& data, int time); |
|
virtual void paintWindow(EffectWindow* w, int mask, QRegion region, WindowPaintData& data); |
|
virtual void postPaintWindow(EffectWindow* w); |
|
virtual void paintEffectFrame(EffectFrame* frame, QRegion region, double opacity, double frameOpacity); |
|
|
|
Effect *provides(Effect::Feature ef); |
|
|
|
virtual void drawWindow(EffectWindow* w, int mask, QRegion region, WindowPaintData& data); |
|
|
|
virtual void buildQuads(EffectWindow* w, WindowQuadList& quadList); |
|
|
|
virtual void activateWindow(EffectWindow* c); |
|
virtual EffectWindow* activeWindow() const; |
|
virtual void moveWindow(EffectWindow* w, const QPoint& pos, bool snap = false, double snapAdjust = 1.0); |
|
virtual void windowToDesktop(EffectWindow* w, int desktop); |
|
virtual void windowToScreen(EffectWindow* w, int screen); |
|
virtual void setShowingDesktop(bool showing); |
|
|
|
virtual QString currentActivity() const; |
|
virtual int currentDesktop() const; |
|
virtual int numberOfDesktops() const; |
|
virtual void setCurrentDesktop(int desktop); |
|
virtual void setNumberOfDesktops(int desktops); |
|
virtual QSize desktopGridSize() const; |
|
virtual int desktopGridWidth() const; |
|
virtual int desktopGridHeight() const; |
|
virtual int workspaceWidth() const; |
|
virtual int workspaceHeight() const; |
|
virtual int desktopAtCoords(QPoint coords) const; |
|
virtual QPoint desktopGridCoords(int id) const; |
|
virtual QPoint desktopCoords(int id) const; |
|
virtual int desktopAbove(int desktop = 0, bool wrap = true) const; |
|
virtual int desktopToRight(int desktop = 0, bool wrap = true) const; |
|
virtual int desktopBelow(int desktop = 0, bool wrap = true) const; |
|
virtual int desktopToLeft(int desktop = 0, bool wrap = true) const; |
|
virtual QString desktopName(int desktop) const; |
|
virtual bool optionRollOverDesktops() const; |
|
|
|
virtual int displayWidth() const; |
|
virtual int displayHeight() const; |
|
virtual QPoint cursorPos() const; |
|
virtual bool grabKeyboard(Effect* effect); |
|
virtual void ungrabKeyboard(); |
|
virtual void* getProxy(QString name); |
|
virtual void startMousePolling(); |
|
virtual void stopMousePolling(); |
|
virtual EffectWindow* findWindow(WId id) const; |
|
virtual EffectWindowList stackingOrder() const; |
|
virtual void setElevatedWindow(EffectWindow* w, bool set); |
|
|
|
virtual void setTabBoxWindow(EffectWindow*); |
|
virtual void setTabBoxDesktop(int); |
|
virtual EffectWindowList currentTabBoxWindowList() const; |
|
virtual void refTabBox(); |
|
virtual void unrefTabBox(); |
|
virtual void closeTabBox(); |
|
virtual QList< int > currentTabBoxDesktopList() const; |
|
virtual int currentTabBoxDesktop() const; |
|
virtual EffectWindow* currentTabBoxWindow() const; |
|
|
|
virtual void setActiveFullScreenEffect(Effect* e); |
|
virtual Effect* activeFullScreenEffect() const; |
|
|
|
virtual void addRepaintFull(); |
|
virtual void addRepaint(const QRect& r); |
|
virtual void addRepaint(const QRegion& r); |
|
virtual void addRepaint(int x, int y, int w, int h); |
|
virtual int activeScreen() const; |
|
virtual int numScreens() const; |
|
virtual int screenNumber(const QPoint& pos) const; |
|
virtual QRect clientArea(clientAreaOption, int screen, int desktop) const; |
|
virtual QRect clientArea(clientAreaOption, const EffectWindow* c) const; |
|
virtual QRect clientArea(clientAreaOption, const QPoint& p, int desktop) const; |
|
virtual double animationTimeFactor() const; |
|
virtual WindowQuadType newWindowQuadType(); |
|
|
|
virtual Window createInputWindow(Effect* e, int x, int y, int w, int h, const QCursor& cursor); |
|
using EffectsHandler::createInputWindow; |
|
virtual void destroyInputWindow(Window w); |
|
virtual bool checkInputWindowEvent(XEvent* e); |
|
virtual void checkInputWindowStacking(); |
|
|
|
virtual void checkElectricBorder(const QPoint &pos, Time time); |
|
virtual void reserveElectricBorder(ElectricBorder border); |
|
virtual void unreserveElectricBorder(ElectricBorder border); |
|
virtual void reserveElectricBorderSwitching(bool reserve, Qt::Orientations o); |
|
|
|
virtual unsigned long xrenderBufferPicture(); |
|
virtual void reconfigure(); |
|
virtual void registerPropertyType(long atom, bool reg); |
|
virtual QByteArray readRootProperty(long atom, long type, int format) const; |
|
virtual void deleteRootProperty(long atom) const; |
|
|
|
virtual bool hasDecorationShadows() const; |
|
|
|
virtual bool decorationsHaveAlpha() const; |
|
|
|
virtual bool decorationSupportsBlurBehind() const; |
|
|
|
virtual EffectFrame* effectFrame(EffectFrameStyle style, bool staticSize, const QPoint& position, Qt::Alignment alignment) const; |
|
|
|
virtual QVariant kwinOption(KWinOption kwopt); |
|
|
|
// internal (used by kwin core or compositing code) |
|
void startPaint(); |
|
bool borderActivated(ElectricBorder border); |
|
void grabbedKeyboardEvent(QKeyEvent* e); |
|
bool hasKeyboardGrab() const; |
|
void desktopResized(const QSize &size); |
|
|
|
virtual void reloadEffect(Effect *effect); |
|
QStringList loadedEffects() const; |
|
QStringList listOfEffects() const; |
|
|
|
QList<EffectWindow*> elevatedWindows() const; |
|
QStringList activeEffects() const; |
|
|
|
public Q_SLOTS: |
|
void slotCurrentTabAboutToChange(EffectWindow* from, EffectWindow* to); |
|
void slotTabAdded(EffectWindow* from, EffectWindow* to); |
|
void slotTabRemoved(EffectWindow* c, EffectWindow* newActiveWindow); |
|
void slotShowOutline(const QRect &geometry); |
|
void slotHideOutline(); |
|
|
|
// slots for D-Bus interface |
|
Q_SCRIPTABLE void reconfigureEffect(const QString& name); |
|
Q_SCRIPTABLE bool loadEffect(const QString& name, bool checkDefault = false); |
|
Q_SCRIPTABLE void toggleEffect(const QString& name); |
|
Q_SCRIPTABLE void unloadEffect(const QString& name); |
|
Q_SCRIPTABLE bool isEffectLoaded(const QString& name) const; |
|
Q_SCRIPTABLE QString supportInformation(const QString& name) const; |
|
|
|
protected Q_SLOTS: |
|
void slotDesktopChanged(int old, KWin::Client *withClient); |
|
void slotClientAdded(KWin::Client *c); |
|
void slotClientShown(KWin::Toplevel*); |
|
void slotUnmanagedAdded(KWin::Unmanaged *u); |
|
void slotWindowClosed(KWin::Toplevel *c); |
|
void slotClientActivated(KWin::Client *c); |
|
void slotDeletedRemoved(KWin::Deleted *d); |
|
void slotClientMaximized(KWin::Client *c, KDecorationDefines::MaximizeMode maxMode); |
|
void slotClientStartUserMovedResized(KWin::Client *c); |
|
void slotClientStepUserMovedResized(KWin::Client *c, const QRect &geometry); |
|
void slotClientFinishUserMovedResized(KWin::Client *c); |
|
void slotOpacityChanged(KWin::Toplevel *t, qreal oldOpacity); |
|
void slotClientMinimized(KWin::Client *c, bool animate); |
|
void slotClientUnminimized(KWin::Client *c, bool animate); |
|
void slotGeometryShapeChanged(KWin::Toplevel *t, const QRect &old); |
|
void slotPaddingChanged(KWin::Toplevel *t, const QRect &old); |
|
void slotWindowDamaged(KWin::Toplevel *t, const QRect& r); |
|
void slotPropertyNotify(KWin::Toplevel *t, long atom); |
|
void slotPropertyNotify(long atom); |
|
|
|
protected: |
|
bool loadScriptedEffect(const QString &name, KService *service); |
|
KLibrary* findEffectLibrary(KService* service); |
|
void effectsChanged(); |
|
void setupClientConnections(KWin::Client *c); |
|
void setupUnmanagedConnections(KWin::Unmanaged *u); |
|
|
|
Effect* keyboard_grab_effect; |
|
Effect* fullscreen_effect; |
|
QList<EffectWindow*> elevated_windows; |
|
QMultiMap< int, EffectPair > effect_order; |
|
QHash< long, int > registered_atoms; |
|
int next_window_quad_type; |
|
int mouse_poll_ref_count; |
|
|
|
private Q_SLOTS: |
|
void slotEffectsQueried(); |
|
|
|
private: |
|
QList< Effect* > m_activeEffects; |
|
QList< Effect* >::iterator m_currentDrawWindowIterator; |
|
QList< Effect* >::iterator m_currentPaintWindowIterator; |
|
QList< Effect* >::iterator m_currentPaintEffectFrameIterator; |
|
QList< Effect* >::iterator m_currentPaintScreenIterator; |
|
QList< Effect* >::iterator m_currentBuildQuadsIterator; |
|
Compositor *m_compositor; |
|
Scene *m_scene; |
|
}; |
|
|
|
class EffectWindowImpl : public EffectWindow |
|
{ |
|
Q_OBJECT |
|
public: |
|
EffectWindowImpl(Toplevel *toplevel); |
|
virtual ~EffectWindowImpl(); |
|
|
|
virtual void enablePainting(int reason); |
|
virtual void disablePainting(int reason); |
|
virtual bool isPaintingEnabled(); |
|
|
|
virtual void refWindow(); |
|
virtual void unrefWindow(); |
|
|
|
virtual const EffectWindowGroup* group() const; |
|
|
|
virtual QRegion shape() const; |
|
virtual QRect decorationInnerRect() const; |
|
virtual QByteArray readProperty(long atom, long type, int format) const; |
|
virtual void deleteProperty(long atom) const; |
|
|
|
virtual EffectWindow* findModal(); |
|
virtual EffectWindowList mainWindows() const; |
|
|
|
virtual WindowQuadList buildQuads(bool force = false) const; |
|
|
|
const Toplevel* window() const; |
|
Toplevel* window(); |
|
|
|
void setWindow(Toplevel* w); // internal |
|
void setSceneWindow(Scene::Window* w); // internal |
|
const Scene::Window* sceneWindow() const; // internal |
|
Scene::Window* sceneWindow(); // internal |
|
|
|
void setData(int role, const QVariant &data); |
|
QVariant data(int role) const; |
|
|
|
void registerThumbnail(ThumbnailItem *item); |
|
QHash<ThumbnailItem*, QWeakPointer<EffectWindowImpl> > const &thumbnails() const { |
|
return m_thumbnails; |
|
} |
|
private Q_SLOTS: |
|
void thumbnailDestroyed(QObject *object); |
|
void thumbnailTargetChanged(); |
|
private: |
|
void insertThumbnail(ThumbnailItem *item); |
|
Toplevel* toplevel; |
|
Scene::Window* sw; // This one is used only during paint pass. |
|
QHash<int, QVariant> dataMap; |
|
QHash<ThumbnailItem*, QWeakPointer<EffectWindowImpl> > m_thumbnails; |
|
}; |
|
|
|
class EffectWindowGroupImpl |
|
: public EffectWindowGroup |
|
{ |
|
public: |
|
EffectWindowGroupImpl(Group* g); |
|
virtual EffectWindowList members() const; |
|
private: |
|
Group* group; |
|
}; |
|
|
|
class EffectFrameImpl |
|
: public QObject, public EffectFrame |
|
{ |
|
Q_OBJECT |
|
public: |
|
explicit EffectFrameImpl(EffectFrameStyle style, bool staticSize = true, QPoint position = QPoint(-1, -1), |
|
Qt::Alignment alignment = Qt::AlignCenter); |
|
virtual ~EffectFrameImpl(); |
|
|
|
virtual void free(); |
|
virtual void render(QRegion region = infiniteRegion(), double opacity = 1.0, double frameOpacity = 1.0); |
|
virtual Qt::Alignment alignment() const; |
|
virtual void setAlignment(Qt::Alignment alignment); |
|
virtual const QFont& font() const; |
|
virtual void setFont(const QFont& font); |
|
virtual const QRect& geometry() const; |
|
virtual void setGeometry(const QRect& geometry, bool force = false); |
|
virtual const QPixmap& icon() const; |
|
virtual void setIcon(const QPixmap& icon); |
|
virtual const QSize& iconSize() const; |
|
virtual void setIconSize(const QSize& size); |
|
virtual void setPosition(const QPoint& point); |
|
virtual const QString& text() const; |
|
virtual void setText(const QString& text); |
|
virtual EffectFrameStyle style() const { |
|
return m_style; |
|
}; |
|
Plasma::FrameSvg& frame() { |
|
return m_frame; |
|
} |
|
bool isStatic() const { |
|
return m_static; |
|
}; |
|
void finalRender(QRegion region, double opacity, double frameOpacity) const; |
|
virtual void setShader(GLShader* shader) { |
|
m_shader = shader; |
|
} |
|
virtual GLShader* shader() const { |
|
return m_shader; |
|
} |
|
virtual void setSelection(const QRect& selection); |
|
const QRect& selection() const { |
|
return m_selectionGeometry; |
|
} |
|
Plasma::FrameSvg& selectionFrame() { |
|
return m_selection; |
|
} |
|
/** |
|
* The foreground text color as specified by the default Plasma theme. |
|
*/ |
|
static QColor styledTextColor(); |
|
|
|
private Q_SLOTS: |
|
void plasmaThemeChanged(); |
|
|
|
private: |
|
Q_DISABLE_COPY(EffectFrameImpl) // As we need to use Qt slots we cannot copy this class |
|
void align(QRect &geometry); // positions geometry around m_point respecting m_alignment |
|
void autoResize(); // Auto-resize if not a static size |
|
|
|
EffectFrameStyle m_style; |
|
Plasma::FrameSvg m_frame; // TODO: share between all EffectFrames |
|
Plasma::FrameSvg m_selection; |
|
|
|
// Position |
|
bool m_static; |
|
QPoint m_point; |
|
Qt::Alignment m_alignment; |
|
QRect m_geometry; |
|
|
|
// Contents |
|
QString m_text; |
|
QFont m_font; |
|
QPixmap m_icon; |
|
QSize m_iconSize; |
|
QRect m_selectionGeometry; |
|
|
|
Scene::EffectFrame* m_sceneFrame; |
|
GLShader* m_shader; |
|
}; |
|
|
|
inline |
|
QList<EffectWindow*> EffectsHandlerImpl::elevatedWindows() const |
|
{ |
|
return elevated_windows; |
|
} |
|
|
|
|
|
inline |
|
EffectWindowGroupImpl::EffectWindowGroupImpl(Group* g) |
|
: group(g) |
|
{ |
|
} |
|
|
|
EffectWindow* effectWindow(Toplevel* w); |
|
EffectWindow* effectWindow(Scene::Window* w); |
|
|
|
inline |
|
const Scene::Window* EffectWindowImpl::sceneWindow() const |
|
{ |
|
return sw; |
|
} |
|
|
|
inline |
|
Scene::Window* EffectWindowImpl::sceneWindow() |
|
{ |
|
return sw; |
|
} |
|
|
|
inline |
|
const Toplevel* EffectWindowImpl::window() const |
|
{ |
|
return toplevel; |
|
} |
|
|
|
inline |
|
Toplevel* EffectWindowImpl::window() |
|
{ |
|
return toplevel; |
|
} |
|
|
|
|
|
} // namespace |
|
|
|
#endif
|
|
|