/*

 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

 * All rights reserved.

 * This component and the accompanying materials are made available

 * under the terms of "Eclipse Public License v1.0"

 * which accompanies this distribution, and is available

 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

 *

 * Initial Contributors:

 * Nokia Corporation - initial contribution.

 *

 * Contributors:

 *

 * Description: camificonengine.cpp

 *

 */

#include <QPainter>

#include <QPixmap>

#include <QFileInfo>

#include <QDebug>

#include <AknIconUtils.h> // avkon

#include <apgicnfl.h> // fbsbitmap

#include "camificonengine.h"

const int cacheSize = 4;

inline QString CaMifIconEngine::pmcKey(const QSize &size)

{ 

    return QString::number((size.width()<<11)|size.height(), 16);

}

CaMifIconEngine::CaMifIconEngine()

    : QIconEngineV2(),

      mMifFilename(),

      mCache(cacheSize),

      mBitmapCached(0),

      mMaskBitmapCached(0)

{

}

CaMifIconEngine::CaMifIconEngine(const CaMifIconEngine &other) :

    QIconEngineV2(other),

    mMifFilename(other.mMifFilename),

    mCache(cacheSize),

    mBitmapCached(0),

    mMaskBitmapCached(0)

{

}

CaMifIconEngine::~CaMifIconEngine()

{

    mCache.clear();

    delete mBitmapCached;

    delete mMaskBitmapCached;

}

void CaMifIconEngine::cacheBitmapL()

{

    CFbsBitmap *bitmap(0);

    CFbsBitmap *maskBitmap(0);

    TInt bitmapIndex = 0;

    TInt maskIndex = 1;

    TPtrC16 filename(

        reinterpret_cast<const TUint16*>(mMifFilename.utf16()));

    // it will change bitmap ids if it is mif (checking inside)

    AknIconUtils::ValidateLogicalAppIconId( filename,

        bitmapIndex, maskIndex );

    AknIconUtils::CreateIconLC( bitmap, maskBitmap, filename,

        bitmapIndex, maskIndex );

    mBitmapCached = bitmap;

    mMaskBitmapCached = maskBitmap;

    // bitmap and icon, AknsUtils::CreateIconLC doesn't specify the order

    CleanupStack::Pop(2);

}

void CaMifIconEngine::getPixmapFromBitmap(const QSize &size, QPixmap& pixmap)

{

    if (!mBitmapCached || !mMaskBitmapCached) {

        TRAP_IGNORE(cacheBitmapL());

    }

    if (mBitmapCached && mMaskBitmapCached) {

        CFbsBitmap *bitmap = mBitmapCached;

        CFbsBitmap *maskBitmap = mMaskBitmapCached;

        AknIconUtils::SetSize(bitmap, TSize(size.width(), size.height()),

                        EAspectRatioPreservedAndUnusedSpaceRemoved);

        pixmap = pixmap.fromSymbianCFbsBitmap(bitmap);

        QPixmap mask;

        mask = mask.fromSymbianCFbsBitmap(maskBitmap);

        pixmap.setAlphaChannel(mask);

    }

}

QSize CaMifIconEngine::actualSize(const QSize &size,

    QIcon::Mode mode,

    QIcon::State state)

{

    Q_UNUSED(mode);

    Q_UNUSED(state);

    QString key(pmcKey(size));

    qDebug() << "pmckey: " << key;

    QSize realSize;

    if (mCache.contains(key)) {

        realSize = size;

    } else {

        QPixmap pixmap;

        TPtrC16 filename(

            reinterpret_cast<const TUint16*>(mMifFilename.utf16()));

        getPixmapFromBitmap(size, pixmap);

        if (!pixmap.isNull()) {

            QPixmap *cachedPixmap = new QPixmap(pixmap);

            if (mCache.insert(key, cachedPixmap)) {

                realSize = size;

                // mCache has taken ownership of cachedPixmap. 

                qDebug() << "pmckey INSERT";

            }

        }

    }

    return realSize;

}

QPixmap CaMifIconEngine::pixmap(const QSize &size,

    QIcon::Mode mode,

    QIcon::State state)

{

    Q_UNUSED(mode);

    Q_UNUSED(state);

    QPixmap pixmap;

    actualSize(size, mode, state);

    QString key = pmcKey(size);

    if (mCache.contains(key)) {

        pixmap = *mCache[key];

    }

    return pixmap;

}

void CaMifIconEngine::addPixmap(const QPixmap &pixmap,

    QIcon::Mode mode,

    QIcon::State state)

{

    Q_UNUSED(pixmap);

    Q_UNUSED(mode);

    Q_UNUSED(state);

}

void CaMifIconEngine::addFile(const QString &fileName,

    const QSize &size,

    QIcon::Mode mode,

    QIcon::State state)

{

    Q_UNUSED(size);

    Q_UNUSED(mode);

    Q_UNUSED(state);

    // Mif file name is recorded only the first time "addFile" function

    // is invoked (from QIcon constructor).

    if (mMifFilename.isEmpty() && !fileName.isEmpty()) {

        QString abs = fileName;

        if (fileName.at(0) != QLatin1Char(':')) {

            abs = QFileInfo(fileName).absoluteFilePath();

        }

        if (abs.endsWith(QLatin1String(".mif"), Qt::CaseInsensitive))

        {

            mMifFilename = abs;

            mMifFilename.replace('/', '\\');

            TRAP_IGNORE(cacheBitmapL());

        } 

    }

}

void CaMifIconEngine::paint(QPainter *painter, const QRect &rect,

                           QIcon::Mode mode, QIcon::State state)

{

    painter->drawPixmap(rect, pixmap(rect.size(), mode, state));

}

QString CaMifIconEngine::key() const

{

    return QLatin1String("mif");

}

QIconEngineV2 *CaMifIconEngine::clone() const

{

    return new CaMifIconEngine(*this);

}