grabber.cpp

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2005 by Bojan D.                                        *
 *   bojan_d@users.sourceforge.net                                         *
 *                                                                         *
 *   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, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/

#include <ksavefile.h>
#include <kimageio.h>
#include <klocale.h>
#include <kurl.h>
#include <kapplication.h>

#include <qbitmap.h>
#include <qimage.h>
#include <qregexp.h>
#include <qpainter.h>
#include <qpaintdevicemetrics.h>
#include <qfile.h>
#include <qregion.h>

#include <stdlib.h>

#ifdef HAVE_X11_EXTENSIONS_SHAPE_H
#include <X11/extensions/shape.h>
#endif

#include "grabber.h"

Grabber::Grabber(QObject *parent, const char *name)
 : QObject(parent, name),
 m_snapshot()
{
}

Grabber::~Grabber()
{
}

QPixmap Grabber::capture()
{
        emit startCapture();
        emit message(i18n("Taking snapshot..."));
        // make sure the UI is updated.
        kapp->processEvents();
        
        XGrabServer( qt_xdisplay());
        if ( Config().Capture.CaptureMode == Configuration::WindowUnderCursor ) 
        {
                Window root;
                Window child;
                uint mask;
                int rootX, rootY, winX, winY;
                XQueryPointer(  qt_xdisplay(), qt_xrootwin(), &root, &child,
                                        &rootX, &rootY, &winX, &winY,
                                        &mask);
        if( child == None )
            child = qt_xrootwin();
                if( !Config().Capture.IncludeWD) 
                {
                        Window real_child = findRealWindow( child );
                        if( real_child != None ) // test just in case
                                child = real_child;
                }
                
                int x, y;
                unsigned int w, h;
                unsigned int border;
                unsigned int depth;
                XGetGeometry( qt_xdisplay(), child, &root, &x, &y, &w, &h, &border, &depth );
        w += 2 * border;
        h += 2 * border;

                Window parent;
                Window* children;
                unsigned int nchildren;
                if( XQueryTree( qt_xdisplay(), child, &root, &parent, &children, &nchildren ) != 0 ) 
                {
                if( children != NULL )
                                XFree( children );
            
                        int newx, newy;
                Window dummy;
                if( XTranslateCoordinates( qt_xdisplay(), parent, qt_xrootwin(),
                        x, y, &newx, &newy, &dummy )) 
                        {
                                x = newx;
                                y = newy;
                        }
                }

                m_snapshot = QPixmap::grabWindow( qt_xrootwin(), x, y, w, h );

#ifdef HAVE_X11_EXTENSIONS_SHAPE_H
                //No XShape - no work.
                if (haveXShape) 
                {
                QBitmap mask(w, h);
                //As the first step, get the mask from XShape.
                int count, order;
                XRectangle* rects = XShapeGetRectangles(qt_xdisplay(), child,
                                                        ShapeBounding, &count, &order);
                //The ShapeBounding region is the outermost shape of the window;
                //ShapeBounding - ShapeClipping is defined to be the border.
                //Since the border area is part of the window, we use bounding
                // to limit our work region
                if (rects) 
                        {
                                //Create a QRegion from the rectangles describing the bounding mask.
                                QRegion contents;
                                for (int pos = 0; pos < count; pos++)
                        contents += QRegion(rects[pos].x, rects[pos].y,
                                                rects[pos].width, rects[pos].height);
                                XFree(rects);

                                //Create the bounding box.
                                QRegion bbox(0, 0, snapshot.width(), snapshot.height());

                if( border > 0 ) 
                                {
                    contents.translate( border, border );
                    contents += QRegion( 0, 0, border, h );
                    contents += QRegion( 0, 0, w, border );
                    contents += QRegion( 0, h - border, w, border );
                    contents += QRegion( w - border, 0, border, h );
                }

                                //Get the masked away area.
                                QRegion maskedAway = bbox - contents;
                                QMemArray<QRect> maskedAwayRects = maskedAway.rects();

                                //Construct a bitmap mask from the rectangles
                                QPainter p(&mask);
                                p.fillRect(0, 0, w, h, Qt::color1);
                                for (uint pos = 0; pos < maskedAwayRects.count(); pos++)
                        p.fillRect(maskedAwayRects[pos], Qt::color0);
                                p.end();

                                m_snapshot.setMask(mask);
                }
                }
#endif
    }
    else 
        {
                m_snapshot = QPixmap::grabWindow( qt_xrootwin() );
    }
    XUngrabServer( qt_xdisplay());
        
        emit message(i18n("Snapshot taken."));
        emit finishCapture();
        
        return m_snapshot;
}

void Grabber::saveFiles()
{
        emit startSave();
        emit message(i18n("Saving images..."));
        
        // make sure the UI is updated.
        kapp->processEvents();
        
        QString fileNameMain = Config().File.PathMain;
        saveMain(fileNameMain);
        
        if(Config().Ftp.UseThumb)
        {
                QString fileNameThumb = Config().File.PathThumb;
                saveThumb(fileNameThumb);
        }
        
        emit message(i18n("Images saved."));
        emit finishSave();
}
        

Window Grabber::findRealWindow( Window w, int depth)
{
        if( depth > 5 )
                return None;
    
        static Atom wm_state = XInternAtom( qt_xdisplay(), "WM_STATE", False );
    Atom type;
    int format;
    unsigned long nitems, after;
    unsigned char* prop;
    
        if( XGetWindowProperty( qt_xdisplay(), w, wm_state, 0, 0, False, AnyPropertyType,
        &type, &format, &nitems, &after, &prop ) == Success ) 
        {
                if( prop != NULL )
                XFree( prop );
                if( type != None )
                return w;
    }
    
        Window root, parent;
    Window* children;
    unsigned int nchildren;
    Window ret = None;
    if( XQueryTree( qt_xdisplay(), w, &root, &parent, &children, &nchildren ) != 0 ) 
        {
                for( unsigned int i = 0; i < nchildren && ret == None; ++i )
                ret = findRealWindow( children[ i ], depth + 1 );
                if( children != NULL )
                XFree( children );
    }
    return ret;
}

void Grabber::saveMain( const QString & fileName )
{
        QImage temp = m_snapshot.convertToImage();

        if(Config().Capture.ScaleMode == Configuration::ScalePercent)
        {
                int scale = Config().Capture.ScaleMain;
                if(scale != 100)
                {
                        int neww = (int)((double)m_snapshot.width() * ((double)scale / 100.0));
                        int newh = (int)((double)m_snapshot.height() * ((double)scale / 100.0));
                        temp = temp.scale(neww, newh, QImage::ScaleMin);
                }
        }
        else if(Config().Capture.ScaleMode == Configuration::ScalePixel)
        {
                int neww = Config().Capture.ScaleMain;
                if(neww != m_snapshot.width())
                {
                        double scale = (double)neww / (double) m_snapshot.width();
                        int newh = (int)((double)m_snapshot.height() *((double)scale));
                        temp = temp.scale(neww, newh, QImage::ScaleMin);
                }
        }

        if(Config().Caption.UseCaption)
        {
                QImage temp2 = drawCaption(temp);

                if(!temp2.isNull())
                {
                        temp = temp2;
                }
                else
                {
                        emit message(i18n("Could not draw caption on main image."), Configuration::Debug);              
                }
        }

        saveImage(fileName, temp);
}

void Grabber::saveThumb( const QString & fileName )
{
        QImage temp = m_snapshot.convertToImage();

        if(Config().Caption.UseCaption)
        {
                QImage temp2 = drawCaption(temp);

                if(!temp2.isNull())
                {
                        temp = temp2;
                }
                else
                {
                        emit message(i18n("Could not draw caption on thumbnail image."), Configuration::Debug);
                }
        }
        
        if(Config().Capture.ScaleMode == Configuration::ScalePercent)
        {
                int scale = Config().Capture.ScaleThumb;
                if(scale != 100)
                {
                        int neww = (int)((double)m_snapshot.width() * ((double)scale / 100.0));
                        int newh = (int)((double)m_snapshot.height() * ((double)scale / 100.0));
                        temp = temp.scale(neww, newh, QImage::ScaleMin);
                }
        }
        else if(Config().Capture.ScaleMode == Configuration::ScalePixel)
        {
                int neww = Config().Capture.ScaleThumb;
                if(neww != m_snapshot.width())
                {
                        double scale = (double)neww / (double) m_snapshot.width();
                        int newh = (int)((double)m_snapshot.height() *((double)scale));
                        temp = temp.scale(neww, newh, QImage::ScaleMin);
                }
        }       
        
        saveImage(fileName, temp);
}

void Grabber::saveImage(const QString& fileName, const QImage& image)
{
        KURL url(fileName);
        
        if ( !url.isValid() )
        {
                
        return;
        }

    QString type( KImageIO::type(url.path()) );
        if ( type.isNull() )
                type = "PNG";
                
        bool ok = false;
        
        KSaveFile saveFile( url.path() );
        if ( saveFile.status() == 0 ) 
        {
            if ( image.save( saveFile.file(), type.latin1(), Config().Capture.PictureQuality ) )
                        ok = saveFile.close();
        }
        
        if ( !ok ) 
                emit message(i18n("Unable to save the image."), Configuration::Debug);
}

QImage Grabber::drawCaption(const QImage& image)
{
        QString text = Config().Caption.Text;

        QPixmap pic(image);
        QPainter paint;
        paint.begin(&pic);
        paint.setFont(Config().Caption.Font);
        paint.setPen(Config().Caption.Color);

        if(Config().Caption.CustomPos)
        {
                paint.drawText(Config().Caption.PositionX, Config().Caption.PositionY,  text);
        }
        else
        {
                paint.drawText(pic.rect(),  Config().Caption.Position | Qt::WordBreak, text);
        }

        paint.end();
        return pic.convertToImage();
}

#include "grabber.moc"

---