/****************************************************************************

**

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the QtGui module of the Qt Toolkit.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

#include <qglobal.h>

#include "qpixmap.h"

#include "qpixmapdata_p.h"

#include "qimagepixmapcleanuphooks_p.h"

#include "qbitmap.h"

#include "qcolormap.h"

#include "qimage.h"

#include "qwidget.h"

#include "qpainter.h"

#include "qdatastream.h"

#include "qbuffer.h"

#include "qapplication.h"

#include <private/qapplication_p.h>

#include <private/qgraphicssystem_p.h>

#include <private/qwidget_p.h>

#include "qevent.h"

#include "qfile.h"

#include "qfileinfo.h"

#include "qpixmapcache.h"

#include "qdatetime.h"

#include "qimagereader.h"

#include "qimagewriter.h"

#include "qpaintengine.h"

#include "qthread.h"

#ifdef Q_WS_MAC

# include "private/qt_mac_p.h"

# include "private/qpixmap_mac_p.h"

#endif

#if defined(Q_WS_X11)

# include "qx11info_x11.h"

# include <private/qt_x11_p.h>

# include <private/qpixmap_x11_p.h>

#endif

#if defined(Q_OS_SYMBIAN)

# include <private/qt_s60_p.h>

#endif

#include "qpixmap_raster_p.h"

QT_BEGIN_NAMESPACE

// ### Qt 5: remove

Q_GUI_EXPORT qint64 qt_pixmap_id(const QPixmap &pixmap)

{

    return pixmap.cacheKey();

}

static bool qt_pixmap_thread_test()

{

    if (!qApp) {

        qFatal("QPixmap: Must construct a QApplication before a QPaintDevice");

        return false;

    }

#ifndef Q_WS_WIN

    if (qApp->thread() != QThread::currentThread()) {

        qWarning("QPixmap: It is not safe to use pixmaps outside the GUI thread");

        return false;

    }

#endif

    return true;

}

void QPixmap::init(int w, int h, Type type)

{

    init(w, h, int(type));

}

void QPixmap::init(int w, int h, int type)

{

    if ((w > 0 && h > 0) || type == QPixmapData::BitmapType)

        data = QPixmapData::create(w, h, (QPixmapData::PixelType) type);

    else

        data = 0;

}

/*!

    \enum QPixmap::ColorMode

    \compat

    This enum type defines the color modes that exist for converting

    QImage objects to QPixmap.  It is provided here for compatibility

    with earlier versions of Qt.

    Use Qt::ImageConversionFlags instead.

    \value Auto  Select \c Color or \c Mono on a case-by-case basis.

    \value Color Always create colored pixmaps.

    \value Mono  Always create bitmaps.

*/

/*!

    Constructs a null pixmap.

    \sa isNull()

*/

QPixmap::QPixmap()

    : QPaintDevice()

{

    (void) qt_pixmap_thread_test();

    init(0, 0, QPixmapData::PixmapType);

}

/*!

    \fn QPixmap::QPixmap(int width, int height)

    Constructs a pixmap with the given \a width and \a height. If

    either \a width or \a height is zero, a null pixmap is

    constructed.

    \warning This will create a QPixmap with uninitialized data. Call

    fill() to fill the pixmap with an appropriate color before drawing

    onto it with QPainter.

    \sa isNull()

*/

QPixmap::QPixmap(int w, int h)

    : QPaintDevice()

{

    if (!qt_pixmap_thread_test())

        init(0, 0, QPixmapData::PixmapType);

    else

        init(w, h, QPixmapData::PixmapType);

}

/*!

    \overload

    Constructs a pixmap of the given \a size.

    \warning This will create a QPixmap with uninitialized data. Call

    fill() to fill the pixmap with an appropriate color before drawing

    onto it with QPainter.

*/

QPixmap::QPixmap(const QSize &size)

    : QPaintDevice()

{

    if (!qt_pixmap_thread_test())

        init(0, 0, QPixmapData::PixmapType);

    else

        init(size.width(), size.height(), QPixmapData::PixmapType);

}

/*!

  \internal

*/

QPixmap::QPixmap(const QSize &s, Type type)

{

    if (!qt_pixmap_thread_test())

        init(0, 0, type);

    else

        init(s.width(), s.height(), type);

}

/*!

  \internal

*/

QPixmap::QPixmap(const QSize &s, int type)

{

    if (!qt_pixmap_thread_test())

        init(0, 0, static_cast<QPixmapData::PixelType>(type));

    else

        init(s.width(), s.height(), static_cast<QPixmapData::PixelType>(type));

}

/*!

    \internal

*/

QPixmap::QPixmap(QPixmapData *d)

    : QPaintDevice(), data(d)

{

}

/*!

    Constructs a pixmap from the file with the given \a fileName. If the

    file does not exist or is of an unknown format, the pixmap becomes a

    null pixmap.

    The loader attempts to read the pixmap using the specified \a

    format. If the \a format is not specified (which is the default),

    the loader probes the file for a header to guess the file format.

    The file name can either refer to an actual file on disk or to

    one of the application's embedded resources. See the

    \l{resources.html}{Resource System} overview for details on how

    to embed images and other resource files in the application's

    executable.

    If the image needs to be modified to fit in a lower-resolution

    result (e.g. converting from 32-bit to 8-bit), use the \a

    flags to control the conversion.

    The \a fileName, \a format and \a flags parameters are

    passed on to load(). This means that the data in \a fileName is

    not compiled into the binary. If \a fileName contains a relative

    path (e.g. the filename only) the relevant file must be found

    relative to the runtime working directory.

    \sa {QPixmap#Reading and Writing Image Files}{Reading and Writing

    Image Files}

*/

QPixmap::QPixmap(const QString& fileName, const char *format, Qt::ImageConversionFlags flags)

    : QPaintDevice()

{

    init(0, 0, QPixmapData::PixmapType);

    if (!qt_pixmap_thread_test())

        return;

    load(fileName, format, flags);

}

/*!

    Constructs a pixmap that is a copy of the given \a pixmap.

    \sa copy()

*/

QPixmap::QPixmap(const QPixmap &pixmap)

    : QPaintDevice()

{

    if (!qt_pixmap_thread_test()) {

        init(0, 0, QPixmapData::PixmapType);

        return;

    }

    if (pixmap.paintingActive()) {                // make a deep copy

        operator=(pixmap.copy());

    } else {

        data = pixmap.data;

    }

}

/*!

    Constructs a pixmap from the given \a xpm data, which must be a

    valid XPM image.

    Errors are silently ignored.

    Note that it's possible to squeeze the XPM variable a little bit

    by using an unusual declaration:

    \snippet doc/src/snippets/code/src_gui_image_qpixmap.cpp 0

    The extra \c const makes the entire definition read-only, which is

    slightly more efficient (for example, when the code is in a shared

    library) and ROMable when the application is to be stored in ROM.

*/

#ifndef QT_NO_IMAGEFORMAT_XPM

QPixmap::QPixmap(const char * const xpm[])

    : QPaintDevice()

{

    init(0, 0, QPixmapData::PixmapType);

    if (!xpm)

        return;

    QImage image(xpm);

    if (!image.isNull()) {

        if (data && data->pixelType() == QPixmapData::BitmapType)

            *this = QBitmap::fromImage(image);

        else

            *this = fromImage(image);

    }

}

#endif

/*!

    Destroys the pixmap.

*/

QPixmap::~QPixmap()

{

    Q_ASSERT(!data || data->ref >= 1); // Catch if ref-counting changes again

}

/*!

  \internal

*/

int QPixmap::devType() const

{

    return QInternal::Pixmap;

}

/*!

    \fn QPixmap QPixmap::copy(int x, int y, int width, int height) const

    \overload

    Returns a deep copy of the subset of the pixmap that is specified

    by the rectangle QRect( \a x, \a y, \a width, \a height).

*/

/*!

    \fn QPixmap QPixmap::copy(const QRect &rectangle) const

    Returns a deep copy of the subset of the pixmap that is specified

    by the given \a rectangle. For more information on deep copies,

    see the \l {Implicit Data Sharing} documentation.

    If the given \a rectangle is empty, the whole image is copied.

    \sa operator=(), QPixmap(), {QPixmap#Pixmap

    Transformations}{Pixmap Transformations}

*/

QPixmap QPixmap::copy(const QRect &rect) const

{

    if (isNull())

        return QPixmap();

    QPixmapData *d = data->createCompatiblePixmapData();

    d->copy(data.data(), r);

    return QPixmap(d);

}

/*!

    \fn QPixmap::scroll(int dx, int dy, int x, int y, int width, int height, QRegion *exposed)

    \since 4.6

    This convenience function is equivalent to calling QPixmap::scroll(\a dx,

    \a dy, QRect(\a x, \a y, \a width, \a height), \a exposed).

    \sa QWidget::scroll(), QGraphicsItem::scroll()

*/

/*!

    \since 4.6

    Scrolls the area \a rect of this pixmap by (\a dx, \a dy). The exposed

    region is left unchanged. You can optionally pass a pointer to an empty

    QRegion to get the region that is \a exposed by the scroll operation.

    \snippet doc/src/snippets/code/src_gui_image_qpixmap.cpp 2

    You cannot scroll while there is an active painter on the pixmap.

    \sa QWidget::scroll(), QGraphicsItem::scroll()

*/

void QPixmap::scroll(int dx, int dy, const QRect &rect, QRegion *exposed)

{

    if (isNull() || (dx == 0 && dy == 0))

        return;

    QRect dest = rect & this->rect();

    QRect src = dest.translated(-dx, -dy) & dest;

    if (src.isEmpty()) {

        if (exposed)

            *exposed += dest;

        return;

    }

    detach();

    if (!data->scroll(dx, dy, src)) {

        // Fallback

        QPixmap pix = *this;

        QPainter painter(&pix);

        painter.setCompositionMode(QPainter::CompositionMode_Source);

        painter.drawPixmap(src.translated(dx, dy), *this, src);

        painter.end();

        *this = pix;

    }

    if (exposed) {

        *exposed += dest;

        *exposed -= src.translated(dx, dy);

    }

}

/*!

    Assigns the given \a pixmap to this pixmap and returns a reference

    to this pixmap.

    \sa copy(), QPixmap()

*/

QPixmap &QPixmap::operator=(const QPixmap &pixmap)

{

    if (paintingActive()) {

        qWarning("QPixmap::operator=: Cannot assign to pixmap during painting");

        return *this;

    }

    if (pixmap.paintingActive()) {                // make a deep copy

        *this = pixmap.copy();

    } else {

        data = pixmap.data;

    }

    return *this;

}

/*!

   Returns the pixmap as a QVariant.

*/

QPixmap::operator QVariant() const

{

    return QVariant(QVariant::Pixmap, this);

}

/*!

    \fn bool QPixmap::operator!() const

    Returns true if this is a null pixmap; otherwise returns false.

    \sa isNull()

*/

/*!

    \fn QPixmap::operator QImage() const

    Returns the pixmap as a QImage.

    Use the toImage() function instead.

*/

/*!

    Converts the pixmap to a QImage. Returns a null image if the

    conversion fails.

    If the pixmap has 1-bit depth, the returned image will also be 1

    bit deep. Images with more bits will be returned in a format

    closely represents the underlying system. Usually this will be

    QImage::Format_ARGB32_Premultiplied for pixmaps with an alpha and

    QImage::Format_RGB32 or QImage::Format_RGB16 for pixmaps without

    alpha.

    Note that for the moment, alpha masks on monochrome images are

    ignored.

    \sa fromImage(), {QImage#Image Formats}{Image Formats}

*/

QImage QPixmap::toImage() const

{

    if (isNull())

        return QImage();

    return data->toImage();

}

/*!

    \fn QMatrix QPixmap::trueMatrix(const QTransform &matrix, int width, int height)

    Returns the actual matrix used for transforming a pixmap with the

    given \a width, \a height and \a matrix.

    When transforming a pixmap using the transformed() function, the

    transformation matrix is internally adjusted to compensate for

    unwanted translation, i.e. transformed() returns the smallest

    pixmap containing all transformed points of the original

    pixmap. This function returns the modified matrix, which maps

    points correctly from the original pixmap into the new pixmap.

    \sa transformed(), {QPixmap#Pixmap Transformations}{Pixmap

    Transformations}

*/

QTransform QPixmap::trueMatrix(const QTransform &m, int w, int h)

{

    return QImage::trueMatrix(m, w, h);

}

/*!

  \overload

  This convenience function loads the matrix \a m into a

  QTransform and calls the overloaded function with the

  QTransform and the width \a w and the height \a h.

 */

QMatrix QPixmap::trueMatrix(const QMatrix &m, int w, int h)

{

    return trueMatrix(QTransform(m), w, h).toAffine();

}

/*!

    \fn bool QPixmap::isQBitmap() const

    Returns true if this is a QBitmap; otherwise returns false.

*/