• Skip to content
• Skip to link menu

KDE 4.5 API Reference

• KDE API Reference
• API Reference

• Sitemap
• Contact Us

 

KWinLibraries

kwineffects.h

Go to the documentation of this file.

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

Copyright (C) 2006 Lubos Lunak <l.lunak@kde.org>
Copyright (C) 2009 Lucas Murray <lmurray@undefinedfire.com>

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 KWINEFFECTS_H
#define KWINEFFECTS_H

#include <kwinconfig.h>
#include <kwinglobals.h>
#include "kdecoration.h"

#include <QtCore/QPair>
#include <QtCore/QRect>
#include <QtGui/QRegion>
#include <QtGui/QFont>

#include <QtCore/QVector>
#include <QtCore/QList>
#include <QtCore/QHash>
#include <QtCore/QStack>
#include <QtCore/QTimeLine>

#include <KDE/KPluginFactory>
#include <KDE/KShortcutsEditor>

#include <KDE/Plasma/FrameSvg>
#include <KDE/Plasma/Theme>

#include <assert.h>
#include <limits.h>

class KLibrary;
class KConfigGroup;
class KActionCollection;
class QKeyEvent;

namespace KWin
{


class EffectWindow;
class EffectWindowGroup;
class Effect;
class WindowQuad;
class GLRenderTarget;
class GLShader;
class GLTexture;
class XRenderPicture;
class RotationData;
class WindowQuadList;
class WindowPrePaintData;
class WindowPaintData;
class ScreenPrePaintData;
class ScreenPaintData;

typedef QPair< QString, Effect* > EffectPair;
typedef QPair< Effect*, Window > InputWindowPair;
typedef QList< EffectWindow* > EffectWindowList;


#define KWIN_EFFECT_API_MAKE_VERSION( major, minor ) (( major ) << 8 | ( minor ))
#define KWIN_EFFECT_API_VERSION_MAJOR 0
#define KWIN_EFFECT_API_VERSION_MINOR 131
#define KWIN_EFFECT_API_VERSION KWIN_EFFECT_API_MAKE_VERSION( \
    KWIN_EFFECT_API_VERSION_MAJOR, KWIN_EFFECT_API_VERSION_MINOR )

enum WindowQuadType
    {
    WindowQuadError, // for the stupid default ctor
    WindowQuadContents,
    WindowQuadDecoration,
    EFFECT_QUAD_TYPE_START = 100 
    };

enum DataRole
    {
    // Grab roles are used to force all other animations to ignore the window.
    // The value of the data is set to the Effect's `this` value.
    WindowAddedGrabRole = 1,
    WindowClosedGrabRole,
    WindowMinimizedGrabRole,
    WindowUnminimizedGrabRole
    };

KWIN_EXPORT inline
QRect infiniteRegion()
    { // INT_MIN / 2 because width/height is used (INT_MIN+INT_MAX==-1)
    return QRect( INT_MIN / 2, INT_MIN / 2, INT_MAX, INT_MAX );
    }

class KWIN_EXPORT Effect
    {
    public:
        // TODO: is that ok here?
        enum
        {
            PAINT_WINDOW_OPAQUE         = 1 << 0,
            PAINT_WINDOW_TRANSLUCENT    = 1 << 1,
            PAINT_WINDOW_TRANSFORMED    = 1 << 2,
            PAINT_SCREEN_REGION         = 1 << 3,
            PAINT_SCREEN_TRANSFORMED    = 1 << 4,
            PAINT_SCREEN_WITH_TRANSFORMED_WINDOWS = 1 << 5,
            PAINT_SCREEN_BACKGROUND_FIRST = 1 << 6,
            PAINT_DECORATION_ONLY = 1 << 7
        };

        Effect();
        virtual ~Effect();

        enum ReconfigureFlag
            {
            ReconfigureAll = 1 << 0 
            };
        Q_DECLARE_FLAGS( ReconfigureFlags, ReconfigureFlag )

        
        virtual void reconfigure( ReconfigureFlags flags );

        virtual void* proxy();

        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 drawWindow( EffectWindow* w, int mask, QRegion region, WindowPaintData& data );

        virtual void buildQuads( EffectWindow* w, WindowQuadList& quadList );

        virtual QRect transformWindowDamage( EffectWindow* w, const QRect& r );

        virtual void windowUserMovedResized( EffectWindow* c, bool first, bool last );
        virtual void windowMoveResizeGeometryUpdate( EffectWindow* c, const QRect& geometry );
        virtual void windowOpacityChanged( EffectWindow* c, double old_opacity );
        virtual void windowAdded( EffectWindow* c );
        virtual void windowClosed( EffectWindow* c );
        virtual void windowDeleted( EffectWindow* c );
        virtual void windowActivated( EffectWindow* c );
        virtual void windowMinimized( EffectWindow* c );
        virtual void windowUnminimized( EffectWindow* c );
        virtual void clientGroupItemSwitched( EffectWindow* from, EffectWindow* to );
        virtual void clientGroupItemAdded( EffectWindow* from, EffectWindow* to ); // from merged with to
        virtual void clientGroupItemRemoved( EffectWindow* c, EffectWindow* group ); // c removed from group
        virtual void windowInputMouseEvent( Window w, QEvent* e );
        virtual void desktopChanged( int old );
        virtual void windowDamaged( EffectWindow* w, const QRect& r );
        virtual void windowGeometryShapeChanged( EffectWindow* w, const QRect& old );
        virtual void mouseChanged( const QPoint& pos, const QPoint& oldpos,
            Qt::MouseButtons buttons, Qt::MouseButtons oldbuttons,
            Qt::KeyboardModifiers modifiers, Qt::KeyboardModifiers oldmodifiers );
        virtual void grabbedKeyboardEvent( QKeyEvent* e );
        virtual void propertyNotify( EffectWindow* w, long atom );

        virtual void tabBoxAdded( int mode );
        virtual void tabBoxClosed();
        virtual void tabBoxUpdated();
        virtual void tabBoxKeyEvent( QKeyEvent* event );
        virtual bool borderActivated( ElectricBorder border );

        static int displayWidth();
        static int displayHeight();
        static QPoint cursorPos();

        // return type is intentionally double so that one can divide using it without losing data
        static double animationTime( const KConfigGroup& cfg, const QString& key, int defaultTime );
        static double animationTime( int defaultTime );
        static double interpolate(double x, double y, double a)
            {
            return x * (1 - a) + y * a;
            }
        static void setPositionTransformations( WindowPaintData& data, QRect& region, EffectWindow* w,
            const QRect& r, Qt::AspectRatioMode aspect );
    };


#define KWIN_EFFECT( name, classname ) \
    extern "C" { \
        KWIN_EXPORT Effect* effect_create_kwin4_effect_##name() { return new classname; } \
        KWIN_EXPORT int effect_version_kwin4_effect_##name() { return KWIN_EFFECT_API_VERSION; } \
    }

#define KWIN_EFFECT_SUPPORTED( name, function ) \
    extern "C" { \
        KWIN_EXPORT bool effect_supported_kwin4_effect_##name() { return function; } \
    }

#define KWIN_EFFECT_CONFIG( name, classname ) \
    K_PLUGIN_FACTORY(EffectFactory, registerPlugin<classname>(#name);) \
    K_EXPORT_PLUGIN(EffectFactory("kcm_kwin4_effect_" #name))

#define KWIN_EFFECT_CONFIG_MULTIPLE( name, singles ) \
    K_PLUGIN_FACTORY(EffectFactory, singles) \
    K_EXPORT_PLUGIN(EffectFactory("kcm_kwin4_effect_" #name))

#define KWIN_EFFECT_CONFIG_SINGLE( name, classname ) \
    registerPlugin<classname>(#name);

#define KWIN_EFFECT_CONFIG_FACTORY K_PLUGIN_FACTORY_DECLARATION(EffectFactory)


class KWIN_EXPORT EffectsHandler
    {
    friend class Effect;
    public:
        EffectsHandler(CompositingType type);
        virtual ~EffectsHandler();
        // for use by effects
        virtual void prePaintScreen( ScreenPrePaintData& data, int time ) = 0;
        virtual void paintScreen( int mask, QRegion region, ScreenPaintData& data ) = 0;
        virtual void postPaintScreen() = 0;
        virtual void prePaintWindow( EffectWindow* w, WindowPrePaintData& data, int time ) = 0;
        virtual void paintWindow( EffectWindow* w, int mask, QRegion region, WindowPaintData& data ) = 0;
        virtual void postPaintWindow( EffectWindow* w ) = 0;
        virtual void drawWindow( EffectWindow* w, int mask, QRegion region, WindowPaintData& data ) = 0;
        virtual void buildQuads( EffectWindow* w, WindowQuadList& quadList ) = 0;
        virtual QRect transformWindowDamage( EffectWindow* w, const QRect& r );
        // Functions for handling input - e.g. when an Expose-like effect is shown, an input window
        // covering the whole screen is created and all mouse events will be intercepted by it.
        // The effect's windowInputMouseEvent() will get called with such events.
        virtual Window createInputWindow( Effect* e, int x, int y, int w, int h, const QCursor& cursor ) = 0;
        Window createInputWindow( Effect* e, const QRect& r, const QCursor& cursor );
        virtual Window createFullScreenInputWindow( Effect* e, const QCursor& cursor );
        virtual void destroyInputWindow( Window w ) = 0;
        virtual QPoint cursorPos() const = 0;
        virtual bool grabKeyboard( Effect* effect ) = 0;
        virtual void ungrabKeyboard() = 0;

        virtual void* getProxy( QString name ) = 0;

        // Mouse polling
        virtual void startMousePolling() = 0;
        virtual void stopMousePolling() = 0;

        virtual void checkElectricBorder(const QPoint &pos, Time time) = 0;
        virtual void reserveElectricBorder( ElectricBorder border ) = 0;
        virtual void unreserveElectricBorder( ElectricBorder border ) = 0;
        virtual void reserveElectricBorderSwitching( bool reserve ) = 0;

        // functions that allow controlling windows/desktop
        virtual void activateWindow( EffectWindow* c ) = 0;
        virtual EffectWindow* activeWindow() const = 0 ;
        virtual void moveWindow( EffectWindow* w, const QPoint& pos, bool snap = false, double snapAdjust = 1.0 ) = 0;
        virtual void windowToDesktop( EffectWindow* w, int desktop ) = 0;
        virtual void windowToScreen( EffectWindow* w, int screen ) = 0;
        virtual void setShowingDesktop( bool showing ) = 0;

        // Desktops
        virtual int currentDesktop() const = 0;
        virtual int numberOfDesktops() const = 0;
        virtual void setCurrentDesktop( int desktop ) = 0;
        virtual QSize desktopGridSize() const = 0;
        virtual int desktopGridWidth() const = 0;
        virtual int desktopGridHeight() const = 0;
        virtual int workspaceWidth() const = 0;
        virtual int workspaceHeight() const = 0;
        virtual int desktopAtCoords( QPoint coords ) const = 0;
        virtual QPoint desktopGridCoords( int id ) const = 0;
        virtual QPoint desktopCoords( int id ) const = 0;
        virtual int desktopAbove( int desktop = 0, bool wrap = true ) const = 0;
        virtual int desktopToRight( int desktop = 0, bool wrap = true ) const = 0;
        virtual int desktopBelow( int desktop = 0, bool wrap = true ) const = 0;
        virtual int desktopToLeft( int desktop = 0, bool wrap = true ) const = 0;
        virtual bool isDesktopLayoutDynamic() const = 0;
        virtual int addDesktop( QPoint coords ) = 0;
        virtual void deleteDesktop( int id ) = 0;
        virtual QString desktopName( int desktop ) const = 0;
        virtual bool optionRollOverDesktops() const = 0;

        virtual int activeScreen() const = 0; // Xinerama
        virtual int numScreens() const = 0; // Xinerama
        virtual int screenNumber( const QPoint& pos ) const = 0; // Xinerama
        virtual QRect clientArea( clientAreaOption, int screen, int desktop ) const = 0;
        virtual QRect clientArea( clientAreaOption, const EffectWindow* c ) const = 0;
        virtual QRect clientArea( clientAreaOption, const QPoint& p, int desktop ) const = 0;
        virtual double animationTimeFactor() const = 0;
        virtual WindowQuadType newWindowQuadType() = 0;

        virtual EffectWindow* findWindow( WId id ) const = 0;
        virtual EffectWindowList stackingOrder() const = 0;
        // window will be temporarily painted as if being at the top of the stack
        virtual void setElevatedWindow( EffectWindow* w, bool set ) = 0;

        virtual void setTabBoxWindow(EffectWindow*) = 0;
        virtual void setTabBoxDesktop(int) = 0;
        virtual EffectWindowList currentTabBoxWindowList() const = 0;
        virtual void refTabBox() = 0;
        virtual void unrefTabBox() = 0;
        virtual void closeTabBox() = 0;
        virtual QList< int > currentTabBoxDesktopList() const = 0;
        virtual int currentTabBoxDesktop() const = 0;
        virtual EffectWindow* currentTabBoxWindow() const = 0;

        virtual void setActiveFullScreenEffect( Effect* e ) = 0;
        virtual Effect* activeFullScreenEffect() const = 0;

        virtual void pushRenderTarget(GLRenderTarget* target) = 0;
        virtual GLRenderTarget* popRenderTarget() = 0;

        virtual void addRepaintFull() = 0;
        virtual void addRepaint( const QRect& r ) = 0;
        virtual void addRepaint( const QRegion& r ) = 0;
        virtual void addRepaint( int x, int y, int w, int h ) = 0;

        CompositingType compositingType() const;
        virtual unsigned long xrenderBufferPicture() = 0;
        bool saturationSupported() const;
        virtual void reconfigure() = 0;

        virtual void registerPropertyType( long atom, bool reg ) = 0;
        virtual QByteArray readRootProperty( long atom, long type, int format ) const = 0;
        virtual void deleteRootProperty( long atom ) const = 0;

        virtual bool hasDecorationShadows() const = 0;

        virtual bool decorationsHaveAlpha() const = 0;

        bool paintText( const QString& text, const QPoint& center, int maxwidth,
                        const QColor& color, const QFont& font = QFont() );
        bool paintText( const QString& text, const QRect& rect, const QColor& color,
                        const QFont& font = QFont(), const Qt::Alignment& alignment = Qt::AlignCenter );
        bool paintTextWithBackground( const QString& text, const QPoint& center, int maxwidth,
                                      const QColor& color, const QColor& bgcolor,
                                      const QFont& font = QFont() );
        bool paintTextWithBackground( const QString& text, const QRect& rect, const QColor& color,
                                      const QColor& bgcolor, const QFont& font = QFont(),
                                      const Qt::Alignment& alignment = Qt::AlignCenter );


        static void sendReloadMessage( const QString& effectname );
        static KConfigGroup effectConfig( const QString& effectname );


    protected:
        QVector< EffectPair > loaded_effects;
        QHash< QString, KLibrary* > effect_libraries;
        QList< InputWindowPair > input_windows;
        //QHash< QString, EffectFactory* > effect_factories;
        int current_paint_screen;
        int current_paint_window;
        int current_draw_window;
        int current_build_quads;
        int current_transform;
        CompositingType compositing_type;
    };


class KWIN_EXPORT EffectWindow
    {
    public:
        enum
        {
            PAINT_DISABLED                 = 1 << 0,
            PAINT_DISABLED_BY_DELETE       = 1 << 1,
            PAINT_DISABLED_BY_DESKTOP      = 1 << 2,
            PAINT_DISABLED_BY_MINIMIZE     = 1 << 3,
            PAINT_DISABLED_BY_CLIENT_GROUP = 1 << 4
        };

        EffectWindow();
        virtual ~EffectWindow();

        virtual void enablePainting( int reason ) = 0;
        virtual void disablePainting( int reason ) = 0;
        virtual bool isPaintingEnabled() = 0;
        virtual void addRepaint( const QRect& r ) = 0;
        virtual void addRepaint( int x, int y, int w, int h ) = 0;
        virtual void addRepaintFull() = 0;

        virtual void refWindow() = 0;
        virtual void unrefWindow() = 0;
        virtual bool isDeleted() const = 0;

        virtual bool isMinimized() const = 0;
        virtual double opacity() const = 0;
        virtual bool hasAlpha() const = 0;

        virtual bool isOnDesktop( int d ) const;
        virtual bool isOnCurrentDesktop() const;
        virtual bool isOnAllDesktops() const = 0;
        virtual int desktop() const = 0; // prefer isOnXXX()

        virtual int x() const = 0;
        virtual int y() const = 0;
        virtual int width() const = 0;
        virtual int height() const = 0;
        virtual QRect geometry() const = 0;
        virtual QRegion shape() const = 0;
        virtual int screen() const = 0;
        virtual bool hasOwnShape() const = 0; // only for shadow effect, for now
        virtual QPoint pos() const = 0;
        virtual QSize size() const = 0;
        virtual QRect rect() const = 0;
        virtual bool isMovable() const = 0;
        virtual bool isMovableAcrossScreens() const = 0;
        virtual bool isUserMove() const = 0;
        virtual bool isUserResize() const = 0;
        virtual QRect iconGeometry() const = 0;
        virtual QRect contentsRect() const = 0;
        virtual QRect decorationInnerRect() const = 0;
        bool hasDecoration() const;
        virtual QByteArray readProperty( long atom, long type, int format ) const = 0;
        virtual void deleteProperty( long atom ) const = 0;

        virtual QString caption() const = 0;
        virtual QPixmap icon() const = 0;
        virtual QString windowClass() const = 0;
        virtual QString windowRole() const = 0;
        virtual const EffectWindowGroup* group() const = 0;

        virtual bool isDesktop() const = 0;
        virtual bool isDock() const = 0;
        virtual bool isToolbar() const = 0;
        virtual bool isTopMenu() const = 0;
        virtual bool isMenu() const = 0;
        virtual bool isNormalWindow() const = 0; // normal as in 'NET::Normal or NET::Unknown non-transient'
        virtual bool isSpecialWindow() const = 0;
        virtual bool isDialog() const = 0;
        virtual bool isSplash() const = 0;
        virtual bool isUtility() const = 0;
        virtual bool isDropdownMenu() const = 0;
        virtual bool isPopupMenu() const = 0; // a context popup, not dropdown, not torn-off
        virtual bool isTooltip() const = 0;
        virtual bool isNotification() const = 0;
        virtual bool isComboBox() const = 0;
        virtual bool isDNDIcon() const = 0;
        virtual bool isManaged() const = 0; // whether it's managed or override-redirect
        virtual bool acceptsFocus() const = 0;
        virtual bool keepAbove() const = 0;

        virtual bool isModal() const = 0;
        virtual EffectWindow* findModal() = 0;
        virtual EffectWindowList mainWindows() const = 0;

        virtual WindowQuadList buildQuads( bool force = false ) const = 0;

        virtual void minimize() const = 0;
        virtual void unminimize() const = 0;
        virtual void closeWindow() const = 0;

        virtual bool visibleInClientGroup() const = 0;

        virtual void setData( int role, const QVariant &data ) = 0;
        virtual QVariant data( int role ) const = 0;
    };

class KWIN_EXPORT EffectWindowGroup
    {
    public:
        virtual ~EffectWindowGroup();
        virtual EffectWindowList members() const = 0;
    };

class KWIN_EXPORT GlobalShortcutsEditor : public KShortcutsEditor
    {
    public:
        GlobalShortcutsEditor( QWidget *parent );
    };

class KWIN_EXPORT WindowVertex
    {
    public:
        double x() const;
        double y() const;
        void move( double x, double y );
        void setX( double x );
        void setY( double y );
        double originalX() const;
        double originalY() const;
        double textureX() const;
        double textureY() const;
        WindowVertex();
        WindowVertex( double x, double y, double tx, double ty );
    private:
        friend class WindowQuad;
        friend class WindowQuadList;
        double px, py; // position
        double ox, oy; // origional position
        double tx, ty; // texture coords
    };

// NOTE: This class expects the (original) vertices to be in the clockwise order starting from topleft.
class KWIN_EXPORT WindowQuad
    {
    public:
        explicit WindowQuad( WindowQuadType type, int id = -1 );
        WindowQuad makeSubQuad( double x1, double y1, double x2, double y2 ) const;
        WindowVertex& operator[]( int index );
        const WindowVertex& operator[]( int index ) const;
        WindowQuadType type() const;
        int id() const;
        bool decoration() const;
        bool effect() const;
        double left() const;
        double right() const;
        double top() const;
        double bottom() const;
        double originalLeft() const;
        double originalRight() const;
        double originalTop() const;
        double originalBottom() const;
        bool smoothNeeded() const;
        bool isTransformed() const;
    private:
        friend class WindowQuadList;
        WindowVertex verts[ 4 ];
        WindowQuadType quadType; // 0 - contents, 1 - decoration
        int quadID;
    };

class KWIN_EXPORT WindowQuadList
    : public QList< WindowQuad >
    {
    public:
        WindowQuadList splitAtX( double x ) const;
        WindowQuadList splitAtY( double y ) const;
        WindowQuadList makeGrid( int maxquadsize ) const;
        WindowQuadList makeRegularGrid( int xSubdivisions, int ySubdivisions ) const;
        WindowQuadList select( WindowQuadType type ) const;
        WindowQuadList filterOut( WindowQuadType type ) const;
        bool smoothNeeded() const;
        void makeArrays( float** vertices, float** texcoords ) const;
        bool isTransformed() const;
    };

class KWIN_EXPORT WindowPrePaintData
    {
    public:
        int mask;
        QRegion paint;
        QRegion clip;
        WindowQuadList quads;
        void setTranslucent();
        void setTransformed();
    };

class KWIN_EXPORT WindowPaintData
    {
    public:
        WindowPaintData( EffectWindow* w );
        double opacity;
        double contents_opacity;
        double decoration_opacity;
        double xScale;
        double yScale;
        double zScale;
        int xTranslate;
        int yTranslate;
        double zTranslate;
        double saturation;
        double brightness;
        WindowQuadList quads;
        GLShader* shader;
        RotationData* rotation;
    };

class KWIN_EXPORT ScreenPaintData
    {
    public:
        ScreenPaintData();
        double xScale;
        double yScale;
        double zScale;
        int xTranslate;
        int yTranslate;
        double zTranslate;
        RotationData* rotation;
    };

class KWIN_EXPORT ScreenPrePaintData
    {
    public:
        int mask;
        QRegion paint;
    };

class KWIN_EXPORT RotationData
    {
    public:
        RotationData();
        enum RotationAxis
            {
            XAxis,
            YAxis,
            ZAxis
            };
        RotationAxis axis;
        float angle;
        float xRotationPoint;
        float yRotationPoint;
        float zRotationPoint;
    };

class KWIN_EXPORT PaintClipper
    {
    public:
        PaintClipper( const QRegion& allowed_area );
        ~PaintClipper();
        static void push( const QRegion& allowed_area );
        static void pop( const QRegion& allowed_area );
        static bool clip();
        static QRegion paintArea();
        class KWIN_EXPORT Iterator
            {
            public:
                Iterator();
                ~Iterator();
                bool isDone();
                void next();
                QRect boundingRect() const;
            private:
                struct Data;
                Data* data;
            };
    private:
        QRegion area;
        static QStack< QRegion >* areas;
    };


class KWIN_EXPORT TimeLine
    {

    //Q_ENUMS( CurveShape ) // Requires Q_OBJECT

    public:
        enum CurveShape
        {
            EaseInCurve = 0,
            EaseOutCurve,
            EaseInOutCurve,
            LinearCurve,
            SineCurve
        };

        explicit TimeLine(const int duration = 0);

        TimeLine(const TimeLine &other);
        ~TimeLine();
        int duration() const;
        void setDuration(const int msec);
        double value() const;
        double valueForTime(const int msec) const;
        int time() const;
        double progress() const;
        void addProgress(const double progress);
        void addTime(const int msec);
        void removeTime(const int msec);
        void setProgress(const double progress);
        void setCurveShape(CurveShape curveShape);
        //void setCurveShape(CurveShape curveShape);

    private:
        QTimeLine* m_TimeLine;
        int m_Time;
        double m_Progress;
        int m_Duration;
        CurveShape m_CurveShape;
        //Q_DISABLE_COPY(TimeLine)
    };

template <typename T>
class KWIN_EXPORT Motion
    {
    public:
        explicit Motion( T initial, double strength, double smoothness );
        Motion( const Motion<T> &other );
        ~Motion();

        inline T value() const { return m_value; }
        inline void setValue( const T value ) { m_value = value; }
        inline T target() const { return m_target; }
        inline void setTarget( const T target ) { m_target = target; }
        inline T velocity() const { return m_velocity; }
        inline void setVelocity( const T velocity ) { m_velocity = velocity; }

        inline double strength() const { return m_strength; }
        inline void setStrength( const double strength ) { m_strength = strength; }
        inline double smoothness() const { return m_smoothness; }
        inline void setSmoothness( const double smoothness ) { m_smoothness = smoothness; }

        inline T distance() const { return m_target - m_value; }

        void calculate( const int msec );
        void finish();

    private:
        T m_value;

        T m_target;
        T m_velocity;
        double m_strength;
        double m_smoothness;
    };

class KWIN_EXPORT Motion1D : public Motion<double>
    {
    public:
        explicit Motion1D( double initial = 0.0, double strength = 0.08, double smoothness = 4.0 );
        Motion1D( const Motion1D &other );
        ~Motion1D();
    };

class KWIN_EXPORT Motion2D : public Motion<QPointF>
    {
    public:
        explicit Motion2D( QPointF initial = QPointF(), double strength = 0.08, double smoothness = 4.0 );
        Motion2D( const Motion2D &other );
        ~Motion2D();
    };

class KWIN_EXPORT WindowMotionManager
    {
    public:
        explicit WindowMotionManager( bool useGlobalAnimationModifier = true );
        ~WindowMotionManager();

        void manage( EffectWindow *w );
        inline void manage( EffectWindowList list )
            {
            for( int i = 0; i < list.size(); i++ )
                manage( list.at( i ));
            }
        void unmanage( EffectWindow *w );
        void unmanageAll();
        void calculate( int time );
        void apply( EffectWindow *w, WindowPaintData &data );
        void reset();
        void reset( EffectWindow *w );

        void moveWindow( EffectWindow *w, QPoint target, double scale = 1.0, double yScale = 0.0 );
        inline void moveWindow( EffectWindow *w, QRect target )
            {
            // TODO: Scale might be slightly different in the comparison due to rounding
            moveWindow( w, target.topLeft(),
                target.width() / double( w->width() ), target.height() / double( w->height() ));
            }

        QRectF transformedGeometry( EffectWindow *w ) const;
        QRectF targetGeometry( EffectWindow *w ) const;
        EffectWindow* windowAtPoint( QPoint point, bool useStackingOrder = true ) const;

        inline EffectWindowList managedWindows() const { return m_managedWindows.keys(); }
        inline bool isManaging( EffectWindow *w ) { return m_managedWindows.contains( w ); }
        inline bool managingWindows() { return !m_managedWindows.empty(); }
        inline bool areWindowsMoving() { return !m_movingWindowsSet.isEmpty(); }

    private:
        bool m_useGlobalAnimationModifier;
        struct WindowMotion
            { // TODO: Rotation, etc?
            Motion2D translation; // Absolute position
            Motion2D scale; // xScale and yScale
            };
        QHash<EffectWindow*, WindowMotion> m_managedWindows;
        QSet<EffectWindow*> m_movingWindowsSet;
    };

class KWIN_EXPORT EffectFrame : public QObject
    {
    Q_OBJECT

    public:
        enum Style
            {
            None, 
            Unstyled, 
            Styled 
            };

        explicit EffectFrame( Style style, bool staticSize = true, QPoint position = QPoint( -1, -1 ),
            Qt::Alignment alignment = Qt::AlignCenter );
        ~EffectFrame();

        void free();

        void render( QRegion region = infiniteRegion(), double opacity = 1.0, double frameOpacity = 1.0 );

        void setPosition( const QPoint& point );
        inline void setAlignment( Qt::Alignment alignment )
            { m_alignment = alignment; }; // Doesn't change geometry
        void setGeometry( const QRect& geometry, bool force = false );
        inline QRect geometry() const // Inner/contents geometry
            { return m_geometry; };

        void setText( const QString& text );
        inline QString text() const
            { return m_text; };
        void setFont( const QFont& font );
        inline QFont font() const
            { return m_font; };
        void setIcon( const QPixmap& icon );
        inline QPixmap icon() const
            { return m_icon; };
        void setIconSize( const QSize& size );
        inline QSize iconSize() const
            { return m_iconSize; };

        static QColor styledTextColor();

        static void cleanup();

    private Q_SLOTS:
        void plasmaThemeChanged();

    private:
        Q_DISABLE_COPY( EffectFrame ) // As we need to use Qt slots we cannot copy this class

        void autoResize(); // Auto-resize if not a static size
        void updateTexture(); // Update OpenGL styled frame texture
        void updateTextTexture(); // Update OpenGL text texture
        void updatePicture(); // Update XRender styled frame picture
        void updateTextPicture(); // Update XRender text picture

        Style m_style;
        Plasma::FrameSvg m_frame;
        GLTexture* m_texture;
        GLTexture* m_textTexture;
        XRenderPicture* m_picture;
        XRenderPicture* m_textPicture;

        // 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;

        static GLTexture* m_unstyledTexture;
        static void updateUnstyledTexture(); // Update OpenGL unstyled frame texture
    };

extern KWIN_EXPORT EffectsHandler* effects;

/***************************************************************
 EffectsHandler
***************************************************************/

inline
bool EffectsHandler::paintText( const QString& text, const QPoint& center, int maxwidth,
        const QColor& color, const QFont& font )
{
    return paintText( text, QRect( center.x() - maxwidth / 2, center.y() - 5000, maxwidth, 10000 ),
        color, font, Qt::AlignCenter );
}

inline
bool EffectsHandler::paintTextWithBackground( const QString& text, const QPoint& center, int maxwidth,
        const QColor& color, const QColor& bgcolor, const QFont& font )
{
    return paintTextWithBackground( text,
        QRect( center.x() - maxwidth / 2, center.y() - 5000, maxwidth, 10000 ),
        color, bgcolor, font, Qt::AlignCenter );
}

/***************************************************************
 WindowVertex
***************************************************************/

inline
WindowVertex::WindowVertex()
    : px( 0 ), py( 0 ), tx( 0 ), ty( 0 )
    {
    }

inline
WindowVertex::WindowVertex( double _x, double _y, double _tx, double _ty )
    : px( _x ), py( _y ), ox( _x ), oy( _y ), tx( _tx ), ty( _ty )
    {
    }

inline
double WindowVertex::x() const
    {
    return px;
    }

inline
double WindowVertex::y() const
    {
    return py;
    }

inline
double WindowVertex::originalX() const
    {
    return ox;
    }

inline
double WindowVertex::originalY() const
    {
    return oy;
    }

inline
double WindowVertex::textureX() const
    {
    return tx;
    }

inline
double WindowVertex::textureY() const
    {
    return ty;
    }

inline
void WindowVertex::move( double x, double y )
    {
    px = x;
    py = y;
    }

inline
void WindowVertex::setX( double x )
    {
    px = x;
    }

inline
void WindowVertex::setY( double y )
    {
    py = y;
    }

/***************************************************************
 WindowQuad
***************************************************************/

inline
WindowQuad::WindowQuad( WindowQuadType t, int id )
    : quadType( t )
    , quadID( id )
    {
    }

inline
WindowVertex& WindowQuad::operator[]( int index )
    {
    assert( index >= 0 && index < 4 );
    return verts[ index ];
    }

inline
const WindowVertex& WindowQuad::operator[]( int index ) const
    {
    assert( index >= 0 && index < 4 );
    return verts[ index ];
    }

inline
WindowQuadType WindowQuad::type() const
    {
    assert( quadType != WindowQuadError );
    return quadType;
    }

inline
int WindowQuad::id() const
    {
    return quadID;
    }

inline
bool WindowQuad::decoration() const
    {
    assert( quadType != WindowQuadError );
    return quadType == WindowQuadDecoration;
    }

inline
bool WindowQuad::effect() const
    {
    assert( quadType != WindowQuadError );
    return quadType >= EFFECT_QUAD_TYPE_START;
    }

inline
bool WindowQuad::isTransformed() const
    {
    return !( verts[ 0 ].px == verts[ 0 ].ox && verts[ 0 ].py == verts[ 0 ].oy
        && verts[ 1 ].px == verts[ 1 ].ox && verts[ 1 ].py == verts[ 1 ].oy
        && verts[ 2 ].px == verts[ 2 ].ox && verts[ 2 ].py == verts[ 2 ].oy
        && verts[ 3 ].px == verts[ 3 ].ox && verts[ 3 ].py == verts[ 3 ].oy );
    }

inline
double WindowQuad::left() const
    {
    return qMin( verts[ 0 ].px, qMin( verts[ 1 ].px, qMin( verts[ 2 ].px, verts[ 3 ].px )));
    }

inline
double WindowQuad::right() const
    {
    return qMax( verts[ 0 ].px, qMax( verts[ 1 ].px, qMax( verts[ 2 ].px, verts[ 3 ].px )));
    }

inline
double WindowQuad::top() const
    {
    return qMin( verts[ 0 ].py, qMin( verts[ 1 ].py, qMin( verts[ 2 ].py, verts[ 3 ].py )));
    }

inline
double WindowQuad::bottom() const
    {
    return qMax( verts[ 0 ].py, qMax( verts[ 1 ].py, qMax( verts[ 2 ].py, verts[ 3 ].py )));
    }

inline
double WindowQuad::originalLeft() const
    {
    return verts[ 0 ].ox;
    }

inline
double WindowQuad::originalRight() const
    {
    return verts[ 2 ].ox;
    }

inline
double WindowQuad::originalTop() const
    {
    return verts[ 0 ].oy;
    }

inline
double WindowQuad::originalBottom() const
    {
    return verts[ 2 ].oy;
    }

/***************************************************************
 Motion
***************************************************************/

template <typename T>
Motion<T>::Motion( T initial, double strength, double smoothness )
    :   m_value( initial )
    ,   m_target( initial )
    ,   m_velocity()
    ,   m_strength( strength )
    ,   m_smoothness( smoothness )
    {
    }

template <typename T>
Motion<T>::Motion( const Motion &other )
    :   m_value( other.value() )
    ,   m_target( other.target() )
    ,   m_velocity( other.velocity() )
    ,   m_strength( other.strength() )
    ,   m_smoothness( other.smoothness() )
    {
    }

template <typename T>
Motion<T>::~Motion()
    {
    }

template <typename T>
void Motion<T>::calculate( const int msec )
    {
    if( m_value == m_target && m_velocity == T() ) // At target and not moving
        return;

    // Poor man's time independent calculation
    int steps = qMax( 1, msec / 5 );
    for( int i = 0; i < steps; i++ )
        {
        T diff = m_target - m_value;
        T strength = diff * m_strength;
        m_velocity = ( m_smoothness * m_velocity + strength ) / ( m_smoothness + 1.0 );
        m_value += m_velocity;
        }
    }

template <typename T>
void Motion<T>::finish()
    {
    m_value = m_target;
    m_velocity = T();
    }

} // namespace

#endif // KWINEFFECTS_H

KWinLibraries

Skip menu "KWinLibraries"

• Main Page
• Modules
• Namespace List
• Class Hierarchy
• Alphabetical List
• Class List
• File List
• Namespace Members
• Class Members
• Related Pages

API Reference

Skip menu "API Reference"

• KStyles
• KWin
•   KWin Libraries
• Libraries
•   libkworkspace
•   libsolidcontrol
•   libtaskmanager
• Plasma
•     Animators
•     Applets
•     Engines
• Solid Modules
• System Settings
•   SystemSettingsView

Generated for API Reference by doxygen 1.5.9-20090814
This website is maintained by Adriaan de Groot and Allen Winter.
KDE^® and the K Desktop Environment^® logo are registered trademarks of KDE e.V. | Legal