ac1dbac8b1
For the functions from GL_FOO_robustness we want to resolve it by ourselves in order to add a custom implementation if it's not available. Unfortunately once epoxy.h is included this breaks as epoxy defines the names and so through the preprocessor epoxy always wins. So we need different names: all functions from robustness get a "kwin" prefix and the usage is changed everywhere in kwin source code. REVIEW: 125883
335 lines
13 KiB
C++
335 lines
13 KiB
C++
/********************************************************************
|
|
KWin - the KDE window manager
|
|
This file is part of the KDE project.
|
|
|
|
Copyright (C) 2010 Martin Gräßlin <mgraesslin@kde.org>
|
|
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 <kwinglplatform.h>
|
|
#include <kwinglutils.h>
|
|
#include <kwinxrenderutils.h>
|
|
#include <QtCore/QTemporaryFile>
|
|
#include <QtCore/QDir>
|
|
#include <QtDBus/QDBusConnection>
|
|
#include <QVarLengthArray>
|
|
#include <QtGui/QPainter>
|
|
#include <QMatrix4x4>
|
|
#include <xcb/xcb_image.h>
|
|
|
|
namespace KWin
|
|
{
|
|
|
|
bool ScreenShotEffect::supported()
|
|
{
|
|
return effects->compositingType() == XRenderCompositing ||
|
|
(effects->isOpenGLCompositing() && GLRenderTarget::supported());
|
|
}
|
|
|
|
ScreenShotEffect::ScreenShotEffect()
|
|
: m_scheduledScreenshot(0)
|
|
{
|
|
connect ( effects, SIGNAL(windowClosed(KWin::EffectWindow*)), SLOT(windowClosed(KWin::EffectWindow*)) );
|
|
QDBusConnection::sessionBus().registerObject(QStringLiteral("/Screenshot"), this, QDBusConnection::ExportScriptableContents);
|
|
QDBusConnection::sessionBus().registerService(QStringLiteral("org.kde.kwin.Screenshot"));
|
|
}
|
|
|
|
ScreenShotEffect::~ScreenShotEffect()
|
|
{
|
|
QDBusConnection::sessionBus().unregisterObject(QStringLiteral("/Screenshot"));
|
|
QDBusConnection::sessionBus().unregisterService(QStringLiteral("org.kde.kwin.Screenshot"));
|
|
}
|
|
|
|
#ifdef KWIN_HAVE_XRENDER_COMPOSITING
|
|
static QImage xPictureToImage(xcb_render_picture_t srcPic, const QRect &geometry, xcb_image_t **xImage)
|
|
{
|
|
xcb_connection_t *c = effects->xcbConnection();
|
|
xcb_pixmap_t xpix = xcb_generate_id(c);
|
|
xcb_create_pixmap(c, 32, xpix, effects->x11RootWindow(), geometry.width(), geometry.height());
|
|
XRenderPicture pic(xpix, 32);
|
|
xcb_render_composite(c, XCB_RENDER_PICT_OP_SRC, srcPic, XCB_RENDER_PICTURE_NONE, pic,
|
|
geometry.x(), geometry.y(), 0, 0, 0, 0, geometry.width(), geometry.height());
|
|
xcb_flush(c);
|
|
*xImage = xcb_image_get(c, xpix, 0, 0, geometry.width(), geometry.height(), ~0, XCB_IMAGE_FORMAT_Z_PIXMAP);
|
|
QImage img((*xImage)->data, (*xImage)->width, (*xImage)->height, (*xImage)->stride, QImage::Format_ARGB32_Premultiplied);
|
|
// TODO: byte order might need swapping
|
|
xcb_free_pixmap(c, xpix);
|
|
return img;
|
|
}
|
|
#endif
|
|
|
|
void ScreenShotEffect::postPaintScreen()
|
|
{
|
|
effects->postPaintScreen();
|
|
if (m_scheduledScreenshot) {
|
|
WindowPaintData d(m_scheduledScreenshot);
|
|
double left = 0;
|
|
double top = 0;
|
|
double right = m_scheduledScreenshot->width();
|
|
double bottom = m_scheduledScreenshot->height();
|
|
if (m_scheduledScreenshot->hasDecoration() && m_type & INCLUDE_DECORATION) {
|
|
foreach (const WindowQuad & quad, d.quads) {
|
|
// 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());
|
|
}
|
|
} else if (m_scheduledScreenshot->hasDecoration()) {
|
|
WindowQuadList newQuads;
|
|
left = m_scheduledScreenshot->width();
|
|
top = m_scheduledScreenshot->height();
|
|
right = 0;
|
|
bottom = 0;
|
|
foreach (const WindowQuad & quad, d.quads) {
|
|
if (quad.type() == WindowQuadContents) {
|
|
newQuads << quad;
|
|
left = qMin(left, quad.left());
|
|
top = qMin(top, quad.top());
|
|
right = qMax(right, quad.right());
|
|
bottom = qMax(bottom, quad.bottom());
|
|
}
|
|
}
|
|
d.quads = newQuads;
|
|
}
|
|
const int width = right - left;
|
|
const int height = bottom - top;
|
|
bool validTarget = true;
|
|
QScopedPointer<GLTexture> offscreenTexture;
|
|
QScopedPointer<GLRenderTarget> target;
|
|
if (effects->isOpenGLCompositing()) {
|
|
offscreenTexture.reset(new GLTexture(GL_RGBA8, width, height));
|
|
offscreenTexture->setFilter(GL_LINEAR);
|
|
offscreenTexture->setWrapMode(GL_CLAMP_TO_EDGE);
|
|
target.reset(new GLRenderTarget(*offscreenTexture));
|
|
validTarget = target->valid();
|
|
}
|
|
if (validTarget) {
|
|
d.setXTranslation(-m_scheduledScreenshot->x() - left);
|
|
d.setYTranslation(-m_scheduledScreenshot->y() - top);
|
|
|
|
// render window into offscreen texture
|
|
int mask = PAINT_WINDOW_TRANSFORMED | PAINT_WINDOW_TRANSLUCENT;
|
|
QImage img;
|
|
if (effects->isOpenGLCompositing()) {
|
|
GLRenderTarget::pushRenderTarget(target.data());
|
|
glClearColor(0.0, 0.0, 0.0, 0.0);
|
|
glClear(GL_COLOR_BUFFER_BIT);
|
|
glClearColor(0.0, 0.0, 0.0, 1.0);
|
|
|
|
QMatrix4x4 projection;
|
|
projection.ortho(QRect(0, 0, offscreenTexture->width(), offscreenTexture->height()));
|
|
d.setProjectionMatrix(projection);
|
|
|
|
effects->drawWindow(m_scheduledScreenshot, mask, infiniteRegion(), d);
|
|
|
|
// copy content from framebuffer into image
|
|
img = QImage(QSize(width, height), QImage::Format_ARGB32);
|
|
kwinGlReadnPixels(0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, img.byteCount(), (GLvoid*)img.bits());
|
|
GLRenderTarget::popRenderTarget();
|
|
ScreenShotEffect::convertFromGLImage(img, width, height);
|
|
}
|
|
#ifdef KWIN_HAVE_XRENDER_COMPOSITING
|
|
xcb_image_t *xImage = NULL;
|
|
if (effects->compositingType() == XRenderCompositing) {
|
|
setXRenderOffscreen(true);
|
|
effects->drawWindow(m_scheduledScreenshot, mask, QRegion(0, 0, width, height), d);
|
|
if (xRenderOffscreenTarget()) {
|
|
img = xPictureToImage(xRenderOffscreenTarget(), QRect(0, 0, width, height), &xImage);
|
|
}
|
|
setXRenderOffscreen(false);
|
|
}
|
|
#endif
|
|
|
|
if (m_type & INCLUDE_CURSOR) {
|
|
grabPointerImage(img, m_scheduledScreenshot->x() + left, m_scheduledScreenshot->y() + top);
|
|
}
|
|
|
|
const int depth = img.depth();
|
|
xcb_pixmap_t xpix = xcb_generate_id(xcbConnection());
|
|
xcb_create_pixmap(xcbConnection(), depth, xpix, x11RootWindow(), img.width(), img.height());
|
|
|
|
xcb_gcontext_t cid = xcb_generate_id(xcbConnection());
|
|
xcb_create_gc(xcbConnection(), cid, xpix, 0, NULL);
|
|
xcb_put_image(xcbConnection(), XCB_IMAGE_FORMAT_Z_PIXMAP, xpix, cid, img.width(), img.height(),
|
|
0, 0, 0, depth, img.byteCount(), img.constBits());
|
|
xcb_free_gc(xcbConnection(), cid);
|
|
xcb_flush(xcbConnection());
|
|
emit screenshotCreated(xpix);
|
|
#ifdef KWIN_HAVE_XRENDER_COMPOSITING
|
|
if (xImage) {
|
|
xcb_image_destroy(xImage);
|
|
}
|
|
#endif
|
|
}
|
|
m_scheduledScreenshot = NULL;
|
|
}
|
|
}
|
|
|
|
void ScreenShotEffect::screenshotWindowUnderCursor(int mask)
|
|
{
|
|
m_type = (ScreenShotType)mask;
|
|
const QPoint cursor = effects->cursorPos();
|
|
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;
|
|
}
|
|
if (m_scheduledScreenshot) {
|
|
m_scheduledScreenshot->addRepaintFull();
|
|
}
|
|
}
|
|
|
|
void ScreenShotEffect::screenshotForWindow(qulonglong winid, int mask)
|
|
{
|
|
m_type = (ScreenShotType) mask;
|
|
EffectWindow* w = effects->findWindow(winid);
|
|
if(w && !w->isMinimized() && !w->isDeleted()) {
|
|
m_scheduledScreenshot = w;
|
|
m_scheduledScreenshot->addRepaintFull();
|
|
}
|
|
}
|
|
|
|
QString ScreenShotEffect::screenshotFullscreen()
|
|
{
|
|
return blitScreenshot(effects->virtualScreenGeometry());
|
|
}
|
|
|
|
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)
|
|
{
|
|
QImage img;
|
|
if (effects->isOpenGLCompositing())
|
|
{
|
|
if (!GLRenderTarget::blitSupported()) {
|
|
qCDebug(KWINEFFECTS) << "Framebuffer Blit not supported";
|
|
return QString();
|
|
}
|
|
GLTexture tex(GL_RGBA8, 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);
|
|
if (GLPlatform::instance()->isGLES()) {
|
|
glReadPixels(0, 0, img.width(), img.height(), GL_RGBA, GL_UNSIGNED_BYTE, (GLvoid*)img.bits());
|
|
} else {
|
|
glGetTexImage(GL_TEXTURE_2D, 0, GL_RGBA, GL_UNSIGNED_BYTE, (GLvoid*)img.bits());
|
|
}
|
|
tex.unbind();
|
|
ScreenShotEffect::convertFromGLImage(img, geometry.width(), geometry.height());
|
|
}
|
|
|
|
#ifdef KWIN_HAVE_XRENDER_COMPOSITING
|
|
xcb_image_t *xImage = NULL;
|
|
#endif
|
|
if (effects->compositingType() == XRenderCompositing) {
|
|
#ifdef KWIN_HAVE_XRENDER_COMPOSITING
|
|
img = xPictureToImage(effects->xrenderBufferPicture(), geometry, &xImage);
|
|
#endif
|
|
}
|
|
|
|
QTemporaryFile temp(QDir::tempPath() + QDir::separator() + QLatin1String("kwin_screenshot_XXXXXX.png"));
|
|
temp.setAutoRemove(false);
|
|
if (!temp.open()) {
|
|
return QString();
|
|
}
|
|
img.save(&temp);
|
|
#ifdef KWIN_HAVE_XRENDER_COMPOSITING
|
|
if (xImage) {
|
|
xcb_image_destroy(xImage);
|
|
}
|
|
#endif
|
|
temp.close();
|
|
return temp.fileName();
|
|
}
|
|
|
|
void ScreenShotEffect::grabPointerImage(QImage& snapshot, int offsetx, int offsety)
|
|
// Uses the X11_EXTENSIONS_XFIXES_H extension to grab the pointer image, and overlays it onto the snapshot.
|
|
{
|
|
QScopedPointer<xcb_xfixes_get_cursor_image_reply_t, QScopedPointerPodDeleter> cursor(
|
|
xcb_xfixes_get_cursor_image_reply(xcbConnection(),
|
|
xcb_xfixes_get_cursor_image_unchecked(xcbConnection()),
|
|
NULL));
|
|
if (cursor.isNull())
|
|
return;
|
|
|
|
QImage qcursorimg((uchar *) xcb_xfixes_get_cursor_image_cursor_image(cursor.data()), cursor->width, cursor->height,
|
|
QImage::Format_ARGB32_Premultiplied);
|
|
|
|
QPainter painter(&snapshot);
|
|
painter.drawImage(QPointF(cursor->x - cursor->xhot - offsetx, cursor->y - cursor ->yhot - offsety), qcursorimg);
|
|
}
|
|
|
|
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();
|
|
uint *end = p + w * h;
|
|
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);
|
|
for (int x = 0; x < w; ++x) {
|
|
const uint pixel = *q;
|
|
*q = ((pixel << 16) & 0xff0000) | ((pixel >> 16) & 0xff)
|
|
| (pixel & 0xff00ff00);
|
|
|
|
q++;
|
|
}
|
|
}
|
|
|
|
}
|
|
img = img.mirrored();
|
|
}
|
|
|
|
bool ScreenShotEffect::isActive() const
|
|
{
|
|
return m_scheduledScreenshot != NULL && !effects->isScreenLocked();
|
|
}
|
|
|
|
void ScreenShotEffect::windowClosed( EffectWindow* w )
|
|
{
|
|
if (w == m_scheduledScreenshot) {
|
|
m_scheduledScreenshot = NULL;
|
|
screenshotWindowUnderCursor(m_type);
|
|
}
|
|
}
|
|
|
|
} // namespace
|