highlightwindow.cpp 12.2 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
/********************************************************************
 KWin - the KDE window manager
 This file is part of the KDE project.

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

#include "highlightwindow.h"

namespace KWin
{

HighlightWindowEffect::HighlightWindowEffect()
27
    : m_finishing(false)
28
    , m_fadeDuration(float(animationTime(150)))
29 30
    , m_monitorWindow(NULL)
{
31
    m_atom = effects->announceSupportProperty("_KDE_WINDOW_HIGHLIGHT", this);
32 33 34 35
    connect(effects, SIGNAL(windowAdded(KWin::EffectWindow*)), this, SLOT(slotWindowAdded(KWin::EffectWindow*)));
    connect(effects, SIGNAL(windowClosed(KWin::EffectWindow*)), this, SLOT(slotWindowClosed(KWin::EffectWindow*)));
    connect(effects, SIGNAL(windowDeleted(KWin::EffectWindow*)), this, SLOT(slotWindowDeleted(KWin::EffectWindow*)));
    connect(effects, SIGNAL(propertyNotify(KWin::EffectWindow*,long)), this, SLOT(slotPropertyNotify(KWin::EffectWindow*,long)));
36 37 38 39 40
    connect(effects, &EffectsHandler::xcbConnectionChanged, this,
        [this] {
            m_atom = effects->announceSupportProperty("_KDE_WINDOW_HIGHLIGHT", this);
        }
    );
41
}
42 43

HighlightWindowEffect::~HighlightWindowEffect()
44 45
{
}
46

47 48 49
static bool isInitiallyHidden(EffectWindow* w)
{
    // Is the window initially hidden until it is highlighted?
Thomas Lübking's avatar
Thomas Lübking committed
50
    return w->isMinimized() || !w->isCurrentTab() || !w->isOnCurrentDesktop();
51
}
52

53 54
void HighlightWindowEffect::prePaintWindow(EffectWindow* w, WindowPrePaintData& data, int time)
{
55
    // Calculate window opacities
56
    QHash<EffectWindow*, float>::iterator opacity = m_windowOpacity.find(w);
57 58
    if (!m_highlightedWindows.isEmpty()) {
        // Initial fade out and changing highlight animation
59 60 61
        if (opacity == m_windowOpacity.end())
            opacity = m_windowOpacity.insertMulti(w, 0.0f);
        float oldOpacity = *opacity;
62
        if (m_highlightedWindows.contains(w))
63
            *opacity = qMin(1.0f, oldOpacity + time / m_fadeDuration);
64
        else if (w->isNormalWindow() || w->isDialog())   // Only fade out windows
65
            *opacity = qMax(isInitiallyHidden(w) ? 0.0f : 0.15f, oldOpacity - time / m_fadeDuration);
66

67
        if (*opacity < 0.98f)
68
            data.setTranslucent();
69
        if (oldOpacity != *opacity)
70
            effects->addRepaint(w->expandedGeometry());
71 72
    } else if (m_finishing && m_windowOpacity.contains(w)) {
        // Final fading back in animation
73 74 75
        if (opacity == m_windowOpacity.end())
            opacity = m_windowOpacity.insert(w, 0.0f);
        float oldOpacity = *opacity;
76
        if (isInitiallyHidden(w))
77
            *opacity = qMax(0.0f, oldOpacity - time / m_fadeDuration);
78
        else
79
            *opacity = qMin(1.0f, oldOpacity + time / m_fadeDuration);
80

81
        if (*opacity < 0.98f)
82
            data.setTranslucent();
83
        if (oldOpacity != *opacity)
84
            effects->addRepaint(w->expandedGeometry());
85

86
        if (*opacity > 0.98f || *opacity < 0.02f) {
87
            m_windowOpacity.remove(w);   // We default to 1.0
88 89
            opacity = m_windowOpacity.end();
        }
90
    }
91

92
    // Show tabbed windows and windows on other desktops if highlighted
93 94 95
    if (opacity != m_windowOpacity.end() && *opacity > 0.01) {
        if (w->isMinimized())
            w->enablePainting(EffectWindow::PAINT_DISABLED_BY_MINIMIZE);
Thomas Lübking's avatar
Thomas Lübking committed
96 97
        if (!w->isCurrentTab())
            w->enablePainting(EffectWindow::PAINT_DISABLED_BY_TAB_GROUP);
98 99
        if (!w->isOnCurrentDesktop())
            w->enablePainting(EffectWindow::PAINT_DISABLED_BY_DESKTOP);
100 101
    }

102 103 104 105 106
    effects->prePaintWindow(w, data, time);
}

void HighlightWindowEffect::paintWindow(EffectWindow* w, int mask, QRegion region, WindowPaintData& data)
{
107
    data.multiplyOpacity(m_windowOpacity.value(w, 1.0f));
108 109
    effects->paintWindow(w, mask, region, data);
}
110

111
void HighlightWindowEffect::slotWindowAdded(EffectWindow* w)
112 113 114
{
    if (!m_highlightedWindows.isEmpty()) {
        // The effect is activated thus we need to add it to the opacity hash
115 116 117 118 119 120 121
        foreach (const WId id, m_highlightedIds) {
            if (w == effects->findWindow(id)) {
                m_windowOpacity[w] = 1.0; // this window was demanded to be highlighted before it appeared
                return;
            }
        }
        m_windowOpacity[w] = 0.15; // this window is not currently highlighted
122
    }
123
    slotPropertyNotify(w, m_atom, w);   // Check initial value
124
}
125

126
void HighlightWindowEffect::slotWindowClosed(EffectWindow* w)
127 128
{
    if (m_monitorWindow == w)   // The monitoring window was destroyed
129
        finishHighlighting();
130
}
131

132
void HighlightWindowEffect::slotWindowDeleted(EffectWindow* w)
133 134 135
{
    m_windowOpacity.remove(w);
}
136

137
void HighlightWindowEffect::slotPropertyNotify(EffectWindow* w, long a, EffectWindow *addedWindow)
138
{
139
    if (a != m_atom || m_atom == XCB_ATOM_NONE)
140 141
        return; // Not our atom

142
    // if the window is null, the property was set on the root window - see events.cpp
143 144 145 146
    QByteArray byteData = w ? w->readProperty(m_atom, m_atom, 32) :
                          effects->readRootProperty(m_atom, m_atom, 32);
    if (byteData.length() < 1) {
        // Property was removed, clearing highlight
147 148
        if (!addedWindow || w != addedWindow)
            finishHighlighting();
149
        return;
150
    }
151
    auto* data = reinterpret_cast<uint32_t*>(byteData.data());
152

153 154
    if (!data[0]) {
        // Purposely clearing highlight by issuing a NULL target
155
        finishHighlighting();
156
        return;
157
    }
158
    m_monitorWindow = w;
159
    bool found = false;
160 161
    int length = byteData.length() / sizeof(data[0]);
    //foreach ( EffectWindow* e, m_highlightedWindows )
162
    //    effects->setElevatedWindow( e, false );
163
    m_highlightedWindows.clear();
164
    m_highlightedIds.clear();
165
    for (int i = 0; i < length; i++) {
166
        m_highlightedIds << data[i];
167 168
        EffectWindow* foundWin = effects->findWindow(data[i]);
        if (!foundWin) {
169
            qCDebug(KWINEFFECTS) << "Invalid window targetted for highlight. Requested:" << data[i];
170
            continue; // might come in later.
171
        }
172 173 174 175
        m_highlightedWindows.append(foundWin);
        // TODO: We cannot just simply elevate the window as this will elevate it over
        // Plasma tooltips and other such windows as well
        //effects->setElevatedWindow( foundWin, true );
176 177 178
        found = true;
    }
    if (!found) {
179
        finishHighlighting();
180
        return;
181
    }
182
    prepareHighlighting();
183
    if (w)
184
        m_windowOpacity[w] = 1.0; // Because it's not in stackingOrder() yet
185 186

    /* TODO: Finish thumbnails of offscreen windows, not sure if it's worth it though
187
    if ( !m_highlightedWindow->isOnCurrentDesktop() )
188 189 190 191 192 193 194 195 196 197 198 199
        { // Window is offscreen, determine thumbnail position
        QRect screenArea = effects->clientArea( MaximizeArea ); // Workable area of the active screen
        QRect outerArea = outerArea.adjusted( outerArea.width() / 10, outerArea.height() / 10,
            -outerArea.width() / 10, -outerArea.height() / 10 ); // Add 10% margin around the edge
        QRect innerArea = outerArea.adjusted( outerArea.width() / 40, outerArea.height() / 40,
            -outerArea.width() / 40, -outerArea.height() / 40 ); // Outer edge of the thumbnail border (2.5%)
        QRect thumbArea = outerArea.adjusted( 20, 20, -20, -20 ); // Outer edge of the thumbnail (20px)

        // Determine the maximum size that we can make the thumbnail within the innerArea
        double areaAspect = double( thumbArea.width() ) / double( thumbArea.height() );
        double windowAspect = aspectRatio( m_highlightedWindow );
        QRect thumbRect; // Position doesn't matter right now, but it will later
200
        if ( windowAspect > areaAspect )
201 202 203 204
            // Top/bottom will touch first
            thumbRect = QRect( 0, 0, widthForHeight( thumbArea.height() ), thumbArea.height() );
        else // Left/right will touch first
            thumbRect = QRect( 0, 0, thumbArea.width(), heightForWidth( thumbArea.width() ));
205
        if ( thumbRect.width() >= m_highlightedWindow->width() )
206 207 208 209
            // Area is larger than the window, just use the window's size
            thumbRect = m_highlightedWindow->geometry();

        // Determine position of desktop relative to the current one
210 211
        QPoint direction = effects->desktopGridCoords( m_highlightedWindow->desktop() ) -
            effects->desktopGridCoords( effects->currentDesktop() );
212 213 214 215 216 217 218 219 220 221

        // Draw a line from the center of the current desktop to the center of the target desktop.
        QPointF desktopLine( 0, 0, direction.x() * screenArea.width(), direction.y() * screenArea.height() );
        desktopLeft.translate( screenArea.width() / 2, screenArea.height() / 2 ); // Move to the screen center

        // Take the point where the line crosses the outerArea, this will be the tip of our arrow
        QPointF arrowTip;
        QLineF testLine( // Top
            outerArea.x(), outerArea.y(),
            outerArea.x() + outerArea.width(), outerArea.y() );
222
        if ( desktopLine.intersect( testLine, &arrowTip ) != QLineF::BoundedIntersection )
223 224 225 226
            {
            testLine = QLineF( // Right
                outerArea.x() + outerArea.width(), outerArea.y(),
                outerArea.x() + outerArea.width(), outerArea.y() + outerArea.height() );
227
            if ( desktopLine.intersect( testLine, &arrowTip ) != QLineF::BoundedIntersection )
228 229 230 231
                {
                testLine = QLineF( // Bottom
                    outerArea.x() + outerArea.width(), outerArea.y() + outerArea.height(),
                    outerArea.x(), outerArea.y() + outerArea.height() );
232
                if ( desktopLine.intersect( testLine, &arrowTip ) != QLineF::BoundedIntersection )
233 234 235 236 237 238 239 240 241 242
                    {
                    testLine = QLineF( // Left
                        outerArea.x(), outerArea.y() + outerArea.height(),
                        outerArea.x(), outerArea.y() );
                    desktopLine.intersect( testLine, &arrowTip ); // Should never fail
                    }
                }
            }
        m_arrowTip = arrowTip.toPoint();
        } */
243
}
244 245

void HighlightWindowEffect::prepareHighlighting()
246
{
247 248
    // Create window data for every window. Just calling [w] creates it.
    m_finishing = false;
249 250 251 252 253 254
    foreach (EffectWindow * w, effects->stackingOrder()) {
        if (!m_windowOpacity.contains(w))    // Just in case we are still finishing from last time
            m_windowOpacity.insertMulti(w, isInitiallyHidden(w) ? 0.0 : 1.0);
        if (!m_highlightedWindows.isEmpty())
            m_highlightedWindows.at(0)->addRepaintFull();
    }
255
}
256 257

void HighlightWindowEffect::finishHighlighting()
258
{
259 260
    m_finishing = true;
    m_monitorWindow = NULL;
261
    m_highlightedWindows.clear();
262 263
    if (!m_windowOpacity.isEmpty())
        m_windowOpacity.constBegin().key()->addRepaintFull();
264
}
265

266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281
void HighlightWindowEffect::highlightWindows(const QVector<KWin::EffectWindow *> &windows)
{
    if (windows.isEmpty()) {
        finishHighlighting();
        return;
    }

    m_monitorWindow = nullptr;
    m_highlightedWindows.clear();
    m_highlightedIds.clear();
    for (auto w : windows) {
        m_highlightedWindows << w;
    }
    prepareHighlighting();
}

282 283
bool HighlightWindowEffect::isActive() const
{
284
    return !(m_windowOpacity.isEmpty() || effects->isScreenLocked());
285 286
}

287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308
bool HighlightWindowEffect::provides(Feature feature)
{
    switch (feature) {
    case HighlightWindows:
        return true;
    default:
        return false;
    }
}

bool HighlightWindowEffect::perform(Feature feature, const QVariantList &arguments)
{
    if (feature != HighlightWindows) {
        return false;
    }
    if (arguments.size() != 1) {
        return false;
    }
    highlightWindows(arguments.first().value<QVector<EffectWindow*>>());
    return true;
}

309
} // namespace