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

**

** 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 <exception>

#include <w32std.h>

#include <fbs.h>

#include <private/qapplication_p.h>

#include <private/qgraphicssystem_p.h>

#include <private/qt_s60_p.h>

#include <private/qpaintengine_s60_p.h>

#include "qpixmap.h"

#include "qpixmap_raster_p.h"

#include <qwidget.h>

#include "qpixmap_s60_p.h"

#include "qnativeimage_p.h"

#include "qbitmap.h"

#include "qimage.h"

#include "qimage_p.h"

#include <fbs.h>

QT_BEGIN_NAMESPACE

const uchar qt_pixmap_bit_mask[] = { 0x01, 0x02, 0x04, 0x08,

                                     0x10, 0x20, 0x40, 0x80 };

/*

    \class QSymbianFbsClient

    \since 4.6

    \internal

    Symbian Font And Bitmap server client that is

    used to lock the global bitmap heap. Only used in

    S60 v3.1 and S60 v3.2.

*/

_LIT(KFBSERVLargeBitmapAccessName,"FbsLargeBitmapAccess");

class QSymbianFbsClient

{

public:

    QSymbianFbsClient() : heapLocked(false)

    {

        heapLock.OpenGlobal(KFBSERVLargeBitmapAccessName);

    }

    ~QSymbianFbsClient()

    {

        heapLock.Close();

    }

    bool lockHeap()

    {

        bool wasLocked = heapLocked;

        if (heapLock.Handle() && !heapLocked) {

            heapLock.Wait();

            heapLocked = true;

        }

        return wasLocked;

    }

    bool unlockHeap()

    {

        bool wasLocked = heapLocked;

        if (heapLock.Handle() && heapLocked) {

            heapLock.Signal();

            heapLocked = false;

        }

        return wasLocked;

    }

private:

    RMutex heapLock;

    bool heapLocked;

};

Q_GLOBAL_STATIC(QSymbianFbsClient, qt_symbianFbsClient);

// QSymbianFbsHeapLock

QSymbianFbsHeapLock::QSymbianFbsHeapLock(LockAction a)

: action(a), wasLocked(false)

{

    QSysInfo::SymbianVersion symbianVersion = QSysInfo::symbianVersion();

    if (symbianVersion == QSysInfo::SV_9_2 || symbianVersion == QSysInfo::SV_9_3)

        wasLocked = qt_symbianFbsClient()->unlockHeap();

}

QSymbianFbsHeapLock::~QSymbianFbsHeapLock()

{

    // Do nothing

}

void QSymbianFbsHeapLock::relock()

{

    QSysInfo::SymbianVersion symbianVersion = QSysInfo::symbianVersion();

    if (wasLocked && (symbianVersion == QSysInfo::SV_9_2 || symbianVersion == QSysInfo::SV_9_3))

        qt_symbianFbsClient()->lockHeap();

}

/*

    \class QSymbianBitmapDataAccess

    \since 4.6

    \internal

    Data access class that is used to locks/unlocks pixel data

    when drawing or modifying CFbsBitmap pixel data.

*/

class QSymbianBitmapDataAccess

{

public:

    bool heapWasLocked;

    QSysInfo::SymbianVersion symbianVersion;

    explicit QSymbianBitmapDataAccess() : heapWasLocked(false)

    {

        symbianVersion = QSysInfo::symbianVersion();

    };

    ~QSymbianBitmapDataAccess() {};

    inline void beginDataAccess(CFbsBitmap *bitmap)

    {

        if (symbianVersion == QSysInfo::SV_9_2)

            heapWasLocked = qt_symbianFbsClient()->lockHeap();

        else

            bitmap->LockHeap(ETrue);

    }

    inline void endDataAccess(CFbsBitmap *bitmap)

    {

        if (symbianVersion == QSysInfo::SV_9_2) {

            if (!heapWasLocked)

                qt_symbianFbsClient()->unlockHeap();

        } else {

            bitmap->UnlockHeap(ETrue);

        }

    }

};

#define UPDATE_BUFFER()     \

    {                       \

    beginDataAccess();      \

    endDataAccess();        \

}

static CFbsBitmap* createSymbianCFbsBitmap(const TSize& size, TDisplayMode mode)

{

    QSymbianFbsHeapLock lock(QSymbianFbsHeapLock::Unlock);

    CFbsBitmap* bitmap = 0;

    QT_TRAP_THROWING(bitmap = new (ELeave) CFbsBitmap);

    if (bitmap->Create(size, mode) != KErrNone) {

        delete bitmap;

        bitmap = 0;

    }

    lock.relock();

    return bitmap;

}

static CFbsBitmap* uncompress(CFbsBitmap* bitmap)

{

    if(bitmap->IsCompressedInRAM()) {

        QSymbianFbsHeapLock lock(QSymbianFbsHeapLock::Unlock);

        CFbsBitmap *uncompressed = 0;

        QT_TRAP_THROWING(uncompressed = new (ELeave) CFbsBitmap);

        if (uncompressed->Create(bitmap->SizeInPixels(), bitmap->DisplayMode()) != KErrNone) {

            delete bitmap;

            bitmap = 0;

            lock.relock();

            return bitmap;

        }

        lock.relock();

        CFbsBitmapDevice* bitmapDevice = 0;

        CFbsBitGc *bitmapGc = 0;

        QT_TRAP_THROWING(bitmapDevice = CFbsBitmapDevice::NewL(uncompressed));

        QT_TRAP_THROWING(bitmapGc = CFbsBitGc::NewL());

        bitmapGc->Activate(bitmapDevice);

        bitmapGc->BitBlt(TPoint(), bitmap);

        delete bitmapGc;

        delete bitmapDevice;

        return uncompressed;

    } else {

        return bitmap;

    }

}

QPixmap QPixmap::grabWindow(WId winId, int x, int y, int w, int h)

{

    CWsScreenDevice* screenDevice = S60->screenDevice();

    TSize screenSize = screenDevice->SizeInPixels();

    TSize srcSize;

    // Find out if this is one of our windows.

    QSymbianControl *sControl;

    sControl = winId->MopGetObject(sControl);

    if (sControl && sControl->widget()->windowType() == Qt::Desktop) {

        // Grabbing desktop widget

        srcSize = screenSize;

    } else {

        TPoint relativePos = winId->PositionRelativeToScreen();

        x += relativePos.iX;

        y += relativePos.iY;

        srcSize = winId->Size();

    }

    TRect srcRect(TPoint(x, y), srcSize);

    // Clip to the screen

    srcRect.Intersection(TRect(screenSize));

    if (w > 0 && h > 0) {

        TRect subRect(TPoint(x, y), TSize(w, h));

        // Clip to the subRect

        srcRect.Intersection(subRect);

    }

    if (srcRect.IsEmpty())

        return QPixmap();

    CFbsBitmap* temporary = createSymbianCFbsBitmap(srcRect.Size(), screenDevice->DisplayMode());

    QPixmap pix;

    if (temporary && screenDevice->CopyScreenToBitmap(temporary, srcRect) == KErrNone) {

        pix = QPixmap::fromSymbianCFbsBitmap(temporary);

    }

    delete temporary;

    return pix;

}

/*!

    \fn CFbsBitmap *QPixmap::toSymbianCFbsBitmap() const

    \since 4.6

    Creates a \c CFbsBitmap that is equivalent to the QPixmap. Internally this

    function will try to duplicate the handle instead of copying the data,

    however in scenarios where this is not possible the data will be copied.

    If the creation fails or the pixmap is null, then this function returns 0.

    It is the caller's responsibility to release the \c CFbsBitmap data

    after use either by deleting the bitmap or calling \c Reset().

    \warning On S60 3.1 and S60 3.2, semi-transparent pixmaps are always copied

             and not duplicated.

    \warning This function is only available on Symbian OS.

    \sa fromSymbianCFbsBitmap()

*/

CFbsBitmap *QPixmap::toSymbianCFbsBitmap() const

{

    QPixmapData *data = pixmapData();

    if (!data || data->isNull())

        return 0;

    return reinterpret_cast<CFbsBitmap*>(data->toNativeType(QPixmapData::FbsBitmap));

}

/*!

    \fn QPixmap QPixmap::fromSymbianCFbsBitmap(CFbsBitmap *bitmap)

    \since 4.6

    Creates a QPixmap from a \c CFbsBitmap \a bitmap. Internally this function

    will try to duplicate the bitmap handle instead of copying the data, however

    in scenarios where this is not possible the data will be copied.

    To be sure that QPixmap does not modify your original instance, you should

    make a copy of your \c CFbsBitmap before calling this function.

    If the CFbsBitmap is not valid this function will return a null QPixmap.

    \warning This function is only available on Symbian OS.

    \sa toSymbianCFbsBitmap(), {QPixmap#Pixmap Conversion}{Pixmap Conversion}

*/

QPixmap QPixmap::fromSymbianCFbsBitmap(CFbsBitmap *bitmap)

{

    if (!bitmap)

        return QPixmap();

    data->fromNativeType(reinterpret_cast<void*>(bitmap), QPixmapData::FbsBitmap);

    QPixmap pixmap(data.take());

    return pixmap;

}

QS60PixmapData::QS60PixmapData(PixelType type) : QRasterPixmapData(type),

    symbianBitmapDataAccess(new QSymbianBitmapDataAccess),

    cfbsBitmap(0),

    pengine(0),

    bytes(0),

    formatLocked(false)

{

}

QS60PixmapData::~QS60PixmapData()

{

    release();

    delete symbianBitmapDataAccess;

}

void QS60PixmapData::resize(int width, int height)

{

    if (width <= 0 || height <= 0) {

        w = width;

        h = height;

        is_null = true;

        release();

        return;

    } else if (!cfbsBitmap) {

        TDisplayMode mode;

        if (pixelType() == BitmapType)

            mode = EGray2;

        else

            mode = EColor16MU;

        CFbsBitmap* bitmap = createSymbianCFbsBitmap(TSize(width, height), mode);

        fromSymbianBitmap(bitmap);

    } else {

        TSize newSize(width, height);

        if(cfbsBitmap->SizeInPixels() != newSize) {

            cfbsBitmap->Resize(TSize(width, height));

            if(pengine) {

                delete pengine;

                pengine = 0;

            }

        }

        UPDATE_BUFFER();

    }

}

void QS60PixmapData::release()

{

    if (cfbsBitmap) {

        QSymbianFbsHeapLock lock(QSymbianFbsHeapLock::Unlock);

        delete cfbsBitmap;

        lock.relock();

    }

    delete pengine;

    image = QImage();

    cfbsBitmap = 0;

    pengine = 0;

    bytes = 0;

}

/*!

 * Takes ownership of bitmap. Used by window surface

 */

void QS60PixmapData::fromSymbianBitmap(CFbsBitmap* bitmap, bool lockFormat)

{

    Q_ASSERT(bitmap);

    release();

    cfbsBitmap = bitmap;

    formatLocked = lockFormat;

    setSerialNumber(cfbsBitmap->Handle());

    UPDATE_BUFFER();

    // Create default palette if needed

    if (cfbsBitmap->DisplayMode() == EGray2) {

        image.setColorCount(2);

        image.setColor(0, QColor(Qt::color0).rgba());

        image.setColor(1, QColor(Qt::color1).rgba());

        //Symbian thinks set pixels are white/transparent, Qt thinks they are foreground/solid

        //So invert mono bitmaps so that masks work correctly.

        image.invertPixels();

    } else if (cfbsBitmap->DisplayMode() == EGray256) {

        for (int i=0; i < 256; ++i)

            image.setColor(i, qRgb(i, i, i));

    } else if (cfbsBitmap->DisplayMode() == EColor256) {

        const TColor256Util *palette = TColor256Util::Default();

        for (int i=0; i < 256; ++i)

            image.setColor(i, (QRgb)(palette->Color256(i).Value()));

    }

}

QImage QS60PixmapData::toImage(const QRect &r) const

{

    QS60PixmapData *that = const_cast<QS60PixmapData*>(this);

    that->beginDataAccess();

    QImage copy = that->image.copy(r);

    that->endDataAccess();

    return copy;

}

void QS60PixmapData::fromImage(const QImage &img, Qt::ImageConversionFlags flags)

{

    release();

    QImage sourceImage;

    if (pixelType() == BitmapType) {

        sourceImage = img.convertToFormat(QImage::Format_MonoLSB);

    } else {

        if (img.depth() == 1) {

            sourceImage = img.hasAlphaChannel()

                        ? img.convertToFormat(QImage::Format_ARGB32_Premultiplied)

                        : img.convertToFormat(QImage::Format_RGB32);

        } else {

            QImage::Format opaqueFormat = QNativeImage::systemFormat();

            QImage::Format alphaFormat = QImage::Format_ARGB32_Premultiplied;

            if (!img.hasAlphaChannel()

                || ((flags & Qt::NoOpaqueDetection) == 0

                    && !const_cast<QImage &>(img).data_ptr()->checkForAlphaPixels())) {

                sourceImage = img.convertToFormat(opaqueFormat);

            } else {

                sourceImage = img.convertToFormat(alphaFormat);

            }

        }

    }

    QImage::Format destFormat = sourceImage.format();

    TDisplayMode mode;

    switch (destFormat) {

    case QImage::Format_MonoLSB:

        mode = EGray2;

        break;

    case QImage::Format_RGB32:

        mode = EColor16MU;

        break;

    case QImage::Format_ARGB32_Premultiplied:

        if (S60->supportsPremultipliedAlpha) {

            mode = Q_SYMBIAN_ECOLOR16MAP;

            break;

        } else {

            destFormat = QImage::Format_ARGB32;

        }

        // Fall through intended

    case QImage::Format_ARGB32:

        mode = EColor16MA;

        break;

    case QImage::Format_Invalid:

        return;

    default:

        qWarning("Image format not supported: %d", image.format());

        return;

    }

    cfbsBitmap = createSymbianCFbsBitmap(TSize(sourceImage.width(), sourceImage.height()), mode);

    if (!cfbsBitmap) {

        qWarning("Could not create CFbsBitmap");

        release();

        return;

    }

    setSerialNumber(cfbsBitmap->Handle());

    const uchar *sptr = const_cast<const QImage &>(sourceImage).bits();