KWin::Effect Class

void MyEffect::postPaintScreen()
{
    // Do your own processing here
    ...
    // Call corresponding EffectsHandler method
    effects->postPaintScreen();
}

Member Function Documentation

Effect::Effect(QObject *parent = nullptr)

Constructs new Effect object.

In OpenGL based compositing, the frameworks ensures that the context is current when the Effect is constructed.

[override virtual noexcept] Effect::~Effect()

Destructs the Effect object.

In OpenGL based compositing, the frameworks ensures that the context is current when the Effect is destroyed.

[static] double Effect::animationTime(const KConfigGroup &cfg, const QString &key, std::chrono::milliseconds defaultTime)

Read animation time from the configuration and possibly adjust using animationTimeFactor().

The configuration value in the effect should also have special value 'default' (set using QSpinBox::setSpecialValueText()) with the value 0. This special value is adjusted using the global animation speed, otherwise the exact time configured is returned.

cfg configuration group to read value from

key configuration key to read value from

defaultTime default animation time in milliseconds

[static] double Effect::animationTime(std::chrono::milliseconds defaultTime)

in the effect itself.

template <typename T> int Effect::animationTime(std::chrono::milliseconds defaultDuration)

having a property called "duration".

[virtual] bool Effect::blocksDirectScanout() const

overwrite this method to return false if your effect does not need to be drawn over opaque fullscreen windows

[virtual slot] bool Effect::borderActivated(KWin::ElectricBorder border)

This function gets called when a reserved screen edge for border gets called.

[static] QPointF Effect::cursorPos()

Returns the current pointer position.

[virtual] QString Effect::debug(const QString &parameter) const

Reimplement this method to provide online debugging.

This could be as trivial as printing specific detail information about the effect state but could also be used to move the effect in and out of a special debug modes, clear bogus data, etc.

Notice that the functions is const by intent! Whenever you alter the state of the object due to random user input, you should do so with greatest care, hence const_cast<> your object - signalling "let me alone, i know what i'm doing"

parameter A freeform string user input for your effect to interpret.

[virtual] void Effect::drawWindow(const KWin::RenderTarget &renderTarget, const KWin::RenderViewport &viewport, KWin::EffectWindow *w, int mask, const KWin::Region &deviceRegion, KWin::WindowPaintData &data)

Can be called to draw multiple copies (e.g. thumbnails) of a window.

You can change window's opacity/brightness/etc here, but you can't do any transformations.

In OpenGL based compositing, the frameworks ensures that the context is current when this method is invoked.

[virtual] void Effect::grabbedKeyboardEvent(QKeyEvent *e)

This function can be overriden to handle grabbed keyboard input.

[static] double Effect::interpolate(double x, double y, double a)

Linearly interpolates between x and y.

Returns x when a = 0; returns y when a = 1.

[virtual] bool Effect::isActive() const

Overwrite this method to indicate whether your effect will be doing something in the next frame to be rendered.

If the method returns false the effect will be excluded from the chained methods in the next rendered frame.

This method is called always directly before the paint loop begins. So it is totally fine to e.g. react on a window event, issue a repaint to trigger an animation and change a flag to indicate that this method returns true.

As the method is called each frame, you should not perform complex calculations. Best use just a boolean flag.

The default implementation of this method returns true.

[virtual] void Effect::paintScreen(const KWin::RenderTarget &renderTarget, const KWin::RenderViewport &viewport, int mask, const KWin::Region &deviceRegion, KWin::LogicalOutput *screen)

In this method you can:

• paint something on top of the windows (by painting after calling effects->paintScreen())
• paint multiple desktops and/or multiple copies of the same desktop by calling effects->paintScreen() multiple times

In OpenGL based compositing, the frameworks ensures that the context is current when this method is invoked.

[virtual] void Effect::paintWindow(const KWin::RenderTarget &renderTarget, const KWin::RenderViewport &viewport, KWin::EffectWindow *w, int mask, const KWin::Region &deviceRegion, KWin::WindowPaintData &data)

This is the main method for painting windows.

In this method you can:

• do various transformations
• change opacity of the window
• change brightness and/or saturation, if it's supported

In OpenGL based compositing, the frameworks ensures that the context is current when this method is invoked.

[virtual] bool Effect::perform(KWin::Effect::Feature feature, const QVariantList &arguments)

Performs the feature with the arguments.

This allows to have specific protocols between KWin core and an Effect.

The method is supposed to return true if it performed the features, false otherwise.

The default implementation returns false.

[virtual, since 6.7] void Effect::pointerAxis(KWin::PointerAxisEvent *event)

A pointer axis was scrolled

event The PointerAxisEvent for the event

This function was introduced in 6.7.

[virtual, since 6.7] void Effect::pointerButton(KWin::PointerButtonEvent *event)

A pointer button was moved

event The PointerButtonEvent for the event

This function was introduced in 6.7.

[virtual, since 6.7] void Effect::pointerMotion(KWin::PointerMotionEvent *event)

A pointer was moved

event The PointerMotionEvent for the event

This function was introduced in 6.7.

[virtual] void Effect::postPaintScreen()

Called after all the painting has been finished.

In this method you can:

• schedule next repaint in case of animations

You shouldn't paint anything here.

In OpenGL based compositing, the frameworks ensures that the context is current when this method is invoked.

[virtual] void Effect::prePaintScreen(KWin::ScreenPrePaintData &data)

Called before starting to paint the screen. In this method you can:

• set whether the windows or the entire screen will be transformed
• change the region of the screen that will be painted
• do various housekeeping tasks such as initing your effect's variables for the upcoming paint pass or updating animation's progress

[virtual] void Effect::prePaintWindow(KWin::RenderView *view, KWin::EffectWindow *w, KWin::WindowPrePaintData &data)

Called for every window before the actual paint pass

In this method you can:

• enable or disable painting of the window (e.g. enable painting of minimized window)
• set window to be painted with translucency
• set window to be transformed
• request the window to be divided into multiple parts

In OpenGL based compositing, the frameworks ensures that the context is current when this method is invoked.

[virtual] bool Effect::provides(KWin::Effect::Feature)

Called on Transparent resizes.

return true if your effect substitutes questioned feature

[virtual] void Effect::reconfigure(KWin::Effect::ReconfigureFlags flags)

Called when configuration changes (either the effect's or KWin's global).

In OpenGL based compositing, the frameworks ensures that the context is current when the Effect is reconfigured. If this method is called from within the Effect it is required to ensure that the context is current if the implementation does OpenGL calls.

[virtual] int Effect::requestedEffectChainPosition() const

Reimplement this method to indicate where in the Effect chain the Effect should be placed.

A low number indicates early chain position, thus before other Effects got called, a high number indicates a late position. The returned number should be in the interval [0, 100]. The default value is 0.

In KWin4 this information was provided in the Effect's desktop file as property X-KDE-Ordering. In the case of Scripted Effects this property is still used.

[static] void Effect::setPositionTransformations(KWin::WindowPaintData &data, KWin::Rect &logicalRegion, KWin::EffectWindow *w, const KWin::Rect &r, Qt::AspectRatioMode aspect)

Helper to set WindowPaintData and Region to necessary transformations so that a following drawWindow() would put the window at the requested geometry (useful for thumbnails)

[virtual] bool Effect::tabletPadButtonEvent(uint button, bool pressed, void *device)

There has been an event from a button on a drawing tablet pad

button which button

pressed true if pressed, false when released

device the identifier of the tool id

[virtual, since 6.4] bool Effect::tabletPadDialEvent(int number, double delta, void *device)

There has been an event from a input dial on a drawing tablet pad

number which dial

delta the delta value

device the identifier of the tool id

This function was introduced in 6.4.

[virtual] bool Effect::tabletPadRingEvent(int number, qreal position, bool isFinger, void *device)

There has been an event from a input ring on a drawing tablet pad

number which ring

position the value within the ring that was selected

isFinger if it was activated with a finger

device the identifier of the tool id

[virtual] bool Effect::tabletPadStripEvent(int number, qreal position, bool isFinger, void *device)

There has been an event from a input strip on a drawing tablet pad

number which strip

position the value within the strip that was selected

isFinger if it was activated with a finger

device the identifier of the tool id

[virtual] bool Effect::tabletToolAxis(KWin::TabletToolAxisEvent *event)

There has been an axis tablet tool event.

[virtual] bool Effect::tabletToolButtonEvent(uint button, bool pressed, quint64 toolId)

There has been an event from a button on a drawing tablet tool

button which button

pressed true if pressed, false when released

toolId the identifier of the tool id

[virtual] bool Effect::tabletToolProximity(KWin::TabletToolProximityEvent *event)

There has been a proximity tablet tool event.

[virtual] bool Effect::tabletToolTip(KWin::TabletToolTipEvent *event)

There has been a tip tablet tool event.

[virtual, since 6.3] void Effect::touchCancel()

All touch points were canceled

This function was introduced in 6.3.

[virtual] bool Effect::touchDown(qint32 id, const QPointF &pos, std::chrono::microseconds time)

A touch point was pressed.

If the effect wants to exclusively use the touch event it should return true. If false is returned the touch event is passed to further effects.

In general an Effect should only return true if it is the exclusive effect getting input events. E.g. has grabbed mouse events.

Default implementation returns false.

id The unique id of the touch point

pos The position of the touch point in global coordinates

time Timestamp

See also touchMotion and touchUp.

[virtual] bool Effect::touchMotion(qint32 id, const QPointF &pos, std::chrono::microseconds time)

A touch point moved.

If the effect wants to exclusively use the touch event it should return true. If false is returned the touch event is passed to further effects.

In general an Effect should only return true if it is the exclusive effect getting input events. E.g. has grabbed mouse events.

Default implementation returns false.

id The unique id of the touch point

pos The position of the touch point in global coordinates

time Timestamp

See also touchDown and touchUp.

[virtual] bool Effect::touchUp(qint32 id, std::chrono::microseconds time)

A touch point was released.

If the effect wants to exclusively use the touch event it should return true. If false is returned the touch event is passed to further effects.

In general an Effect should only return true if it is the exclusive effect getting input events. E.g. has grabbed mouse events.

Default implementation returns false.

id The unique id of the touch point

time Timestamp

See also touchDown and touchMotion.