screenshot.cpp 11.7 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 129 130 131 132 133 134 135 136
            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);
            }
            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 138
            if (m_type & INCLUDE_CURSOR) {
                grabPointerImage(img, m_scheduledScreenshot->x() + left, m_scheduledScreenshot->y() + top);
Martin Flöser's avatar
Martin Flöser committed
139
            }
140

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

158
void ScreenShotEffect::screenshotWindowUnderCursor(int mask)
159
{
160 161
    m_type = (ScreenShotType)mask;
    const QPoint cursor = effects->cursorPos();
162 163 164 165 166 167 168 169 170
    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;
171 172
    }
    if (m_scheduledScreenshot) {
173
        m_scheduledScreenshot->addRepaintFull();
Martin Flöser's avatar
Martin Flöser committed
174
    }
175
}
176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195

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)
196
    kDebug(1212) << "Framebuffer Blit not supported";
197 198
    return QString();
#else
199 200 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
    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();
    }

228 229 230 231 232 233 234 235 236 237 238
    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
239

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

    //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.
250
    QVarLengthArray< quint32 > pixels(xcursorimg->width * xcursorimg->height);
251 252 253 254
    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,
255
                      QImage::Format_ARGB32_Premultiplied);
256 257 258 259 260 261 262

    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
263 264 265 266 267 268 269 270
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();
271
        uint *end = p + w * h;
Martin Flöser's avatar
Martin Flöser committed
272 273 274 275 276 277 278 279 280
        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);
281
            for (int x = 0; x < w; ++x) {
Martin Flöser's avatar
Martin Flöser committed
282 283
                const uint pixel = *q;
                *q = ((pixel << 16) & 0xff0000) | ((pixel >> 16) & 0xff)
284
                     | (pixel & 0xff00ff00);
Martin Flöser's avatar
Martin Flöser committed
285 286 287 288 289 290 291 292 293

                q++;
            }
        }

    }
    img = img.mirrored();
}

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

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

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