highlightwindow.cpp 10.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 27
/********************************************************************
 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"

#include <kdebug.h>

namespace KWin
{

28
KWIN_EFFECT(highlightwindow, HighlightWindowEffect)
29 30

HighlightWindowEffect::HighlightWindowEffect()
31 32 33 34 35 36
    : m_finishing(false)
    , m_fadeDuration(double(animationTime(150)))
    , m_monitorWindow(NULL)
{
    m_atom = XInternAtom(display(), "_KDE_WINDOW_HIGHLIGHT", False);
    effects->registerPropertyType(m_atom, true);
37 38 39

    // Announce support by creating a dummy version on the root window
    unsigned char dummy = 0;
40 41
    XChangeProperty(display(), rootWindow(), m_atom, m_atom, 8, PropModeReplace, &dummy, 1);
}
42 43

HighlightWindowEffect::~HighlightWindowEffect()
44 45 46 47
{
    XDeleteProperty(display(), rootWindow(), m_atom);
    effects->registerPropertyType(m_atom, false);
}
48

49 50 51
static bool isInitiallyHidden(EffectWindow* w)
{
    // Is the window initially hidden until it is highlighted?
52
    return !w->visibleInClientGroup() || !w->isOnCurrentDesktop();
53
}
54

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

67
        if (m_windowOpacity[w] != 1.0)
68
            data.setTranslucent();
69
        if (oldOpacity != m_windowOpacity[w])
70
            w->addRepaintFull();
71 72
    } else if (m_finishing && m_windowOpacity.contains(w)) {
        // Final fading back in animation
73
        double oldOpacity = m_windowOpacity[w];
74 75
        if (isInitiallyHidden(w))
            m_windowOpacity[w] = qMax(0.0, m_windowOpacity[w] - time / m_fadeDuration);
76
        else
77
            m_windowOpacity[w] = qMin(1.0, m_windowOpacity[w] + time / m_fadeDuration);
78

79
        if (m_windowOpacity[w] != 1.0)
80
            data.setTranslucent();
81
        if (oldOpacity != m_windowOpacity[w])
82 83
            w->addRepaintFull();

84 85 86
        if (m_windowOpacity[w] == 1.0 || m_windowOpacity[w] == 0.0)
            m_windowOpacity.remove(w);   // We default to 1.0
    }
87

88
    // Show tabbed windows and windows on other desktops if highlighted
89 90 91 92 93
    if (m_windowOpacity.contains(w) && m_windowOpacity[w] != 0.0) {
        if (!w->visibleInClientGroup())
            w->enablePainting(EffectWindow::PAINT_DISABLED_BY_CLIENT_GROUP);
        if (!w->isOnCurrentDesktop())
            w->enablePainting(EffectWindow::PAINT_DISABLED_BY_DESKTOP);
94 95
    }

96 97 98 99 100 101
    effects->prePaintWindow(w, data, time);
}

void HighlightWindowEffect::paintWindow(EffectWindow* w, int mask, QRegion region, WindowPaintData& data)
{
    if (m_windowOpacity.contains(w))
102
        data.opacity *= m_windowOpacity[w];
103 104
    effects->paintWindow(w, mask, region, data);
}
105

106 107 108 109 110 111
void HighlightWindowEffect::windowAdded(EffectWindow* w)
{
    if (!m_highlightedWindows.isEmpty()) {
        // The effect is activated thus we need to add it to the opacity hash
        if (w->isNormalWindow() || w->isDialog())   // Only fade out windows
            m_windowOpacity[w] = isInitiallyHidden(w) ? 0.0 : 0.15;
112 113
        else
            m_windowOpacity[w] = 1.0;
114
    }
115 116
    propertyNotify(w, m_atom);   // Check initial value
}
117

118 119 120
void HighlightWindowEffect::windowClosed(EffectWindow* w)
{
    if (m_monitorWindow == w)   // The monitoring window was destroyed
121
        finishHighlighting();
122
}
123

124 125 126 127
void HighlightWindowEffect::windowDeleted(EffectWindow* w)
{
    m_windowOpacity.remove(w);
}
128

129 130 131
void HighlightWindowEffect::propertyNotify(EffectWindow* w, long a)
{
    if (a != m_atom)
132 133
        return; // Not our atom

134
    // if the window is null, the property was set on the root window - see events.cpp
135 136 137 138
    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
139 140
        finishHighlighting();
        return;
141 142
    }
    long* data = reinterpret_cast<long*>(byteData.data());
143

144 145
    if (!data[0]) {
        // Purposely clearing highlight by issuing a NULL target
146
        finishHighlighting();
147
        return;
148
    }
149
    m_monitorWindow = w;
150
    bool found = false;
151 152
    int length = byteData.length() / sizeof(data[0]);
    //foreach ( EffectWindow* e, m_highlightedWindows )
153
    //    effects->setElevatedWindow( e, false );
154
    m_highlightedWindows.clear();
155 156 157
    for (int i = 0; i < length; i++) {
        EffectWindow* foundWin = effects->findWindow(data[i]);
        if (!foundWin) {
158 159
            kDebug(1212) << "Invalid window targetted for highlight. Requested:" << data[i];
            continue;
160 161 162
        }
        if (!foundWin->isMinimized()) {
            m_highlightedWindows.append(foundWin);
163 164 165
            // 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 );
166
        }
167 168 169
        found = true;
    }
    if (!found) {
170
        finishHighlighting();
171
        return;
172
    }
173
    prepareHighlighting();
174
    if (w)
175
        m_windowOpacity[w] = 1.0; // Because it's not in stackingOrder() yet
176 177

    /* TODO: Finish thumbnails of offscreen windows, not sure if it's worth it though
178
    if ( !m_highlightedWindow->isOnCurrentDesktop() )
179 180 181 182 183 184 185 186 187 188 189 190
        { // 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
191
        if ( windowAspect > areaAspect )
192 193 194 195
            // 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() ));
196
        if ( thumbRect.width() >= m_highlightedWindow->width() )
197 198 199 200
            // 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
201 202
        QPoint direction = effects->desktopGridCoords( m_highlightedWindow->desktop() ) -
            effects->desktopGridCoords( effects->currentDesktop() );
203 204 205 206 207 208 209 210 211 212

        // 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() );
213
        if ( desktopLine.intersect( testLine, &arrowTip ) != QLineF::BoundedIntersection )
214 215 216 217
            {
            testLine = QLineF( // Right
                outerArea.x() + outerArea.width(), outerArea.y(),
                outerArea.x() + outerArea.width(), outerArea.y() + outerArea.height() );
218
            if ( desktopLine.intersect( testLine, &arrowTip ) != QLineF::BoundedIntersection )
219 220 221 222
                {
                testLine = QLineF( // Bottom
                    outerArea.x() + outerArea.width(), outerArea.y() + outerArea.height(),
                    outerArea.x(), outerArea.y() + outerArea.height() );
223
                if ( desktopLine.intersect( testLine, &arrowTip ) != QLineF::BoundedIntersection )
224 225 226 227 228 229 230 231 232 233
                    {
                    testLine = QLineF( // Left
                        outerArea.x(), outerArea.y() + outerArea.height(),
                        outerArea.x(), outerArea.y() );
                    desktopLine.intersect( testLine, &arrowTip ); // Should never fail
                    }
                }
            }
        m_arrowTip = arrowTip.toPoint();
        } */
234
}
235 236

void HighlightWindowEffect::prepareHighlighting()
237
{
238 239
    // Create window data for every window. Just calling [w] creates it.
    m_finishing = false;
240 241 242 243
    foreach (EffectWindow * w, effects->stackingOrder())
    if (!m_windowOpacity.contains(w))    // Just in case we are still finishing from last time
        m_windowOpacity[w] = isInitiallyHidden(w) ? 0.0 : 1.0;
}
244 245

void HighlightWindowEffect::finishHighlighting()
246
{
247 248
    m_finishing = true;
    m_monitorWindow = NULL;
249
    m_highlightedWindows.clear();
250
}
251 252

} // namespace