screenshot.cpp 11.8 KB
Newer Older
Martin Flöser's avatar
Martin Flöser committed
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22
/********************************************************************
 KWin - the KDE window manager
 This file is part of the KDE project.

 Copyright (C) 2010 Martin Gräßlin <kde@martin-graesslin.com>
 Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies)

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 "screenshot.h"
#include <kwinglutils.h>
23
#include <kwinxrenderutils.h>
24
#include <KDE/KDebug>
25
#include <KDE/KTemporaryFile>
26 27 28 29 30 31
#include <QtDBus/QDBusConnection>
#include <QtCore/QVarLengthArray>
#include <QtGui/QPainter>

#include <X11/extensions/Xfixes.h>
#include <QX11Info>
Martin Flöser's avatar
Martin Flöser committed
32 33 34 35

namespace KWin
{

36 37
KWIN_EFFECT(screenshot, ScreenShotEffect)
KWIN_EFFECT_SUPPORTED(screenshot, ScreenShotEffect::supported())
Martin Flöser's avatar
Martin Flöser committed
38 39

bool ScreenShotEffect::supported()
40
{
41 42
    return  effects->compositingType() == XRenderCompositing ||
            (effects->compositingType() == KWin::OpenGLCompositing && GLRenderTarget::supported());
43
}
Martin Flöser's avatar
Martin Flöser committed
44 45

ScreenShotEffect::ScreenShotEffect()
46 47
    : m_scheduledScreenshot(0)
{
48
    connect ( effects, SIGNAL(windowClosed(KWin::EffectWindow*)), SLOT(windowClosed(KWin::EffectWindow*)) );
49 50 51
    QDBusConnection::sessionBus().registerObject("/Screenshot", this, QDBusConnection::ExportScriptableContents);
    QDBusConnection::sessionBus().registerService("org.kde.kwin.Screenshot");
}
Martin Flöser's avatar
Martin Flöser committed
52 53

ScreenShotEffect::~ScreenShotEffect()
54 55 56 57
{
    QDBusConnection::sessionBus().unregisterObject("/Screenshot");
    QDBusConnection::sessionBus().unregisterService("org.kde.kwin.Screenshot");
}
Martin Flöser's avatar
Martin Flöser committed
58
void ScreenShotEffect::postPaintScreen()
59
{
Martin Flöser's avatar
Martin Flöser committed
60
    effects->postPaintScreen();
61
    if (m_scheduledScreenshot) {
Martin Flöser's avatar
Martin Flöser committed
62 63
        int w = displayWidth();
        int h = displayHeight();
64 65 66 67 68 69 70 71 72 73 74 75 76
        bool validTarget = true;
        GLTexture* offscreenTexture = 0;
        GLRenderTarget* target = 0;
        if (effects->compositingType() == KWin::OpenGLCompositing) {
            if (!GLTexture::NPOTTextureSupported()) {
                w = nearestPowerOfTwo(w);
                h = nearestPowerOfTwo(h);
            }
            offscreenTexture = new GLTexture(w, h);
            offscreenTexture->setFilter(GL_LINEAR);
            offscreenTexture->setWrapMode(GL_CLAMP_TO_EDGE);
            target = new GLRenderTarget(*offscreenTexture);
            validTarget = target->valid();
77
        }
78
        if (validTarget) {
79
            WindowPaintData d(m_scheduledScreenshot);
Martin Flöser's avatar
Martin Flöser committed
80 81 82 83
            double left = 0;
            double top = 0;
            double right = m_scheduledScreenshot->width();
            double bottom = m_scheduledScreenshot->height();
84 85
            if (m_scheduledScreenshot->hasDecoration() && m_type & INCLUDE_DECORATION) {
                foreach (const WindowQuad & quad, d.quads) {
86 87 88 89 90 91
                    // we need this loop to include the decoration padding
                    left   = qMin(left, quad.left());
                    top    = qMin(top, quad.top());
                    right  = qMax(right, quad.right());
                    bottom = qMax(bottom, quad.bottom());
                }
92
            } else if (m_scheduledScreenshot->hasDecoration()) {
93 94 95 96 97
                WindowQuadList newQuads;
                left = m_scheduledScreenshot->width();
                top = m_scheduledScreenshot->height();
                right = 0;
                bottom = 0;
98 99
                foreach (const WindowQuad & quad, d.quads) {
                    if (quad.type() == WindowQuadContents) {
100 101 102 103 104 105
                        newQuads << quad;
                        left   = qMin(left, quad.left());
                        top    = qMin(top, quad.top());
                        right  = qMax(right, quad.right());
                        bottom = qMax(bottom, quad.bottom());
                    }
Martin Flöser's avatar
Martin Flöser committed
106
                }
107 108
                d.quads = newQuads;
            }
Martin Flöser's avatar
Martin Flöser committed
109 110 111 112
            int width = right - left;
            int height = bottom - top;
            d.xTranslate = -m_scheduledScreenshot->x() - left;
            d.yTranslate = -m_scheduledScreenshot->y() - top;
113

Martin Flöser's avatar
Martin Flöser committed
114 115
            // render window into offscreen texture
            int mask = PAINT_WINDOW_TRANSFORMED | PAINT_WINDOW_TRANSLUCENT;
116 117 118 119 120 121 122 123 124 125 126 127 128
            QImage img;
            if (effects->compositingType() == KWin::OpenGLCompositing) {
                GLRenderTarget::pushRenderTarget(target);
                glClearColor(0.0, 0.0, 0.0, 0.0);
                glClear(GL_COLOR_BUFFER_BIT);
                glClearColor(0.0, 0.0, 0.0, 1.0);
                effects->drawWindow(m_scheduledScreenshot, mask, QRegion(0, 0, width, height), d);
                // copy content from framebuffer into image
                img = QImage(QSize(width, height), QImage::Format_ARGB32);
                glReadPixels(0, offscreenTexture->height() - height, width, height, GL_RGBA, GL_UNSIGNED_BYTE, (GLvoid*)img.bits());
                GLRenderTarget::popRenderTarget();
                ScreenShotEffect::convertFromGLImage(img, width, height);
            }
129
#ifdef KWIN_HAVE_XRENDER_COMPOSITING
130 131 132 133 134 135 136
            if (effects->compositingType() == XRenderCompositing) {
                setXRenderOffscreen(true);
                effects->drawWindow(m_scheduledScreenshot, mask, QRegion(0, 0, width, height), d);
                if (xRenderOffscreenTarget())
                    img = xRenderOffscreenTarget()->toImage().copy(0, 0, width, height);
                setXRenderOffscreen(false);
            }
137
#endif
138

139 140
            if (m_type & INCLUDE_CURSOR) {
                grabPointerImage(img, m_scheduledScreenshot->x() + left, m_scheduledScreenshot->y() + top);
Martin Flöser's avatar
Martin Flöser committed
141
            }
142

143
            m_lastScreenshot = QPixmap::fromImage(img);
144 145
            if (m_lastScreenshot.handle() == 0) {
                Pixmap xpix = XCreatePixmap(display(), rootWindow(), m_lastScreenshot.width(),
146
                                            m_lastScreenshot.height(), 32);
147 148
                m_lastScreenshot = QPixmap::fromX11Pixmap(xpix, QPixmap::ExplicitlyShared);
                QPainter p(&m_lastScreenshot);
149
                p.setCompositionMode(QPainter::CompositionMode_Source);
150 151
                p.drawImage(QPoint(0, 0), img);
            }
152 153
            emit screenshotCreated(m_lastScreenshot.handle());
        }
Martin Flöser's avatar
Martin Flöser committed
154 155 156 157
        delete offscreenTexture;
        delete target;
        m_scheduledScreenshot = NULL;
    }
158
}
Martin Flöser's avatar
Martin Flöser committed
159

160
void ScreenShotEffect::screenshotWindowUnderCursor(int mask)
161
{
162 163
    m_type = (ScreenShotType)mask;
    const QPoint cursor = effects->cursorPos();
164 165 166 167 168 169 170 171 172
    EffectWindowList order = effects->stackingOrder();
    EffectWindowList::const_iterator it = order.constEnd(), first = order.constBegin();
    while( it != first ) {
        m_scheduledScreenshot = *(--it);
        if (m_scheduledScreenshot->isOnCurrentDesktop() &&
            !m_scheduledScreenshot->isMinimized() && !m_scheduledScreenshot->isDeleted() &&
            m_scheduledScreenshot->geometry().contains(cursor))
            break;
        m_scheduledScreenshot = 0;
173 174
    }
    if (m_scheduledScreenshot) {
175
        m_scheduledScreenshot->addRepaintFull();
Martin Flöser's avatar
Martin Flöser committed
176
    }
177
}
178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197

QString ScreenShotEffect::screenshotFullscreen()
{
    return blitScreenshot(QRect(0, 0, displayWidth(), displayHeight()));
}

QString ScreenShotEffect::screenshotScreen(int screen)
{
    return blitScreenshot(effects->clientArea(FullScreenArea, screen, 0));
}

QString ScreenShotEffect::screenshotArea(int x, int y, int width, int height)
{
    return blitScreenshot(QRect(x, y, width, height));
}

QString ScreenShotEffect::blitScreenshot(const QRect &geometry)
{
#ifdef KWIN_HAVE_OPENGLES
    Q_UNUSED(geometry)
198
    kDebug(1212) << "Framebuffer Blit not supported";
199 200
    return QString();
#else
201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229
    QImage img;
    if (effects->compositingType() == KWin::OpenGLCompositing)
    {
        if (!GLRenderTarget::blitSupported()) {
            kDebug(1212) << "Framebuffer Blit not supported";
            return QString();
        }
        GLTexture tex(geometry.width(), geometry.height());
        GLRenderTarget target(tex);
        target.blitFromFramebuffer(geometry);
        // copy content from framebuffer into image
        tex.bind();
        img = QImage(geometry.size(), QImage::Format_ARGB32);
        glGetTexImage(GL_TEXTURE_2D, 0, GL_RGBA, GL_UNSIGNED_BYTE, (GLvoid*)img.bits());
        tex.unbind();
        ScreenShotEffect::convertFromGLImage(img, geometry.width(), geometry.height());
    }

    if (effects->compositingType() == XRenderCompositing) {
        QPixmap buffer(geometry.size());
        if (buffer.handle() == 0) {
            Pixmap xpix = XCreatePixmap(display(), rootWindow(), geometry.width(), geometry.height(), 32);
            buffer = QPixmap::fromX11Pixmap(xpix, QPixmap::ExplicitlyShared);
        }
        XRenderComposite(display(), PictOpSrc, effects->xrenderBufferPicture(), None, buffer.x11PictureHandle(),
                                    0, 0, 0, 0, geometry.x(), geometry.y(), geometry.width(), geometry.height());
        img = buffer.toImage();
    }

230 231 232 233 234 235 236 237 238 239 240
    KTemporaryFile temp;
    temp.setSuffix(".png");
    temp.setAutoRemove(false);
    if (!temp.open()) {
        return QString();
    }
    img.save(&temp);
    temp.close();
    return temp.fileName();
#endif
}
Martin Flöser's avatar
Martin Flöser committed
241

242
void ScreenShotEffect::grabPointerImage(QImage& snapshot, int offsetx, int offsety)
243 244
// Uses the X11_EXTENSIONS_XFIXES_H extension to grab the pointer image, and overlays it onto the snapshot.
{
245 246 247
    XFixesCursorImage *xcursorimg = XFixesGetCursorImage(QX11Info::display());
    if (!xcursorimg)
        return;
248 249 250 251

    //Annoyingly, xfixes specifies the data to be 32bit, but places it in an unsigned long *
    //which can be 64 bit.  So we need to iterate over a 64bit structure to put it in a 32bit
    //structure.
252
    QVarLengthArray< quint32 > pixels(xcursorimg->width * xcursorimg->height);
253 254 255 256
    for (int i = 0; i < xcursorimg->width * xcursorimg->height; ++i)
        pixels[i] = xcursorimg->pixels[i] & 0xffffffff;

    QImage qcursorimg((uchar *) pixels.data(), xcursorimg->width, xcursorimg->height,
257
                      QImage::Format_ARGB32_Premultiplied);
258 259 260 261 262 263 264

    QPainter painter(&snapshot);
    painter.drawImage(QPointF(xcursorimg->x - xcursorimg->xhot - offsetx, xcursorimg->y - xcursorimg ->yhot - offsety), qcursorimg);

    XFree(xcursorimg);
}

Martin Flöser's avatar
Martin Flöser committed
265 266 267 268 269 270 271 272
void ScreenShotEffect::convertFromGLImage(QImage &img, int w, int h)
{
    // from QtOpenGL/qgl.cpp
    // Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies)
    // see http://qt.gitorious.org/qt/qt/blobs/master/src/opengl/qgl.cpp
    if (QSysInfo::ByteOrder == QSysInfo::BigEndian) {
        // OpenGL gives RGBA; Qt wants ARGB
        uint *p = (uint*)img.bits();
273
        uint *end = p + w * h;
Martin Flöser's avatar
Martin Flöser committed
274 275 276 277 278 279 280 281 282
        while (p < end) {
            uint a = *p << 24;
            *p = (*p >> 8) | a;
            p++;
        }
    } else {
        // OpenGL gives ABGR (i.e. RGBA backwards); Qt wants ARGB
        for (int y = 0; y < h; y++) {
            uint *q = (uint*)img.scanLine(y);
283
            for (int x = 0; x < w; ++x) {
Martin Flöser's avatar
Martin Flöser committed
284 285
                const uint pixel = *q;
                *q = ((pixel << 16) & 0xff0000) | ((pixel >> 16) & 0xff)
286
                     | (pixel & 0xff00ff00);
Martin Flöser's avatar
Martin Flöser committed
287 288 289 290 291 292 293 294 295

                q++;
            }
        }

    }
    img = img.mirrored();
}

296 297 298 299 300
bool ScreenShotEffect::isActive() const
{
    return m_scheduledScreenshot != NULL;
}

301 302 303 304 305 306 307 308
void ScreenShotEffect::windowClosed( EffectWindow* w )
{
    if (w == m_scheduledScreenshot) {
        m_scheduledScreenshot = NULL;
        screenshotWindowUnderCursor(m_type);
    }
}

Martin Flöser's avatar
Martin Flöser committed
309
} // namespace