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

**

** Copyright (C) 2008-2010 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (developer.feedback@nokia.com)

**

** This file is part of the HbCore module of the UI Extensions for Mobile.

**

** GNU Lesser General Public License Usage

** 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 developer.feedback@nokia.com.

**

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

#include "hbiconengine_p.h"

#include "hbicon.h"

#include "hbiconloader_p.h"

#include "hbtheme.h"

#include "hbtheme_p.h"

#include "hblayoutdirectionnotifier_p.h"

#include "hbiconanimation_p.h"

#include "hbimagetraces_p.h"

#include "hbiconimpl_p.h"

#include "hbpixmapiconimpl_p.h"

#include "hbbadgeicon_p.h"

#include <hbinstance.h>

#include <hbiconanimator.h>

#include <hbiconanimator_p.h>

#include <QObject>

#include <QMetaMethod>

#include <QPainter>

#include <QDebug>

#define DEFAULT_OPTIONS (HbIconLoader::ReturnUnknownIcon | HbIconLoader::BitmapIcons | HbIconLoader::VectorIcons)

class HbIconEnginePrivate

{

public:

    HbIconEnginePrivate(const QString &iconName);

    HbIconEnginePrivate(const HbIconEnginePrivate &other);

    HbIconEnginePrivate(QDataStream &stream);

    ~HbIconEnginePrivate();

    void clear();

    bool isMirrored();

    HbIconLoader::IconLoaderOptions iconLoaderOptions();

    QString iconName(QIcon::Mode mode, QIcon::State state) const;

    void setIconName(const QString &iconName, QIcon::Mode mode, QIcon::State state);

    void externalize(QDataStream &stream);

    void appendLoadFail(QIcon::Mode mode, QIcon::State state);

    void removeLoadFail(QIcon::Mode mode, QIcon::State state);

    void unLoadIcon(bool unloadedByServer = false);

    void addBadge(Qt::Alignment alignment,

                  const HbIcon &badge,

                  int z,

                  const QSizeF &sizeFactor,

                  Qt::AspectRatioMode aspectRatio);

    bool removeBadge(const HbIcon &badge);

    void removeAllBadges();

    const QList<HbBadgeIconInfo> badges() const;

    bool isBadged() const;

    QColor colorToUse(const QString &iconName) const;

public:

    HbIconEngine *q;

    QSizeF size;

    struct IconName {

        QIcon::Mode mode;

        QIcon::State state;

        QString name;

    };

    // Logical icon names specified for different states and modes of the icon

    // The default one is with mode = QIcon::Normal and state = QIcon::Off.

    QList<IconName> iconNames;

    QPixmap pixmap; // last accessed pixmap is stored here for fast re-use, it has the size as defined by d->size.

    Qt::AspectRatioMode aspectRatioMode; // aspect ratio mode of the last accessed pixmap

    QIcon::Mode mode; // icon mode of the last accessed pixmap

    QIcon::State state; // icon state of last accessed pixmap

    QSizeF defaultSize; // default icon size returned by the loader

    bool defaultSizeFailed;

    // List of those mode and state combinations which have failed in loading the icon.

    // This list should be empty normally but in case there is a failure in loading an icon,

    // it allows quick check for not trying to reload it again.

    // Mode and state are stored in integer as (mode | state << 16)

    QVector<int> loadFailed;

    HbIcon::Flags flags;

    HbIcon::MirroringMode mirroringMode;

    enum DefaultMirroring {

        Unknown = 0,

        Enabled = 1,

        Disabled = 2

    };

    DefaultMirroring defaultMirroring;

    // Pointer to the icon animator interface that is using this HbIcon instance.

    // If this pointer is 0, animations are not used.

    HbIconAnimator *animator;

    // Variables introduced for handling colorizable icons

    QColor color;

    // The color coming from the color group associated with a widget in its css.

    QColor themedColor;

    //Icon Implementation interface which provides abstraction for the type of icon ( Pixmap, NVG, SgImage etc).

    // Each class derived from HbIconImpl will have to implement the paint(), pixmap() and defaultSize() API

    HbIconImpl *icon;

    // Icons decorating this engine

    HbBadgeIcon *badgeInfo;

    bool signalConnectionsSet;

    // Icon FormatType

    HbIconFormatType iconType;

    bool async;

    bool asyncOngoing;

    HbIconEngine::AsyncCallback asyncCallback;

    void *asyncCallbackParam;

    int loadFinishedSlotIndex;

    QIcon::Mode curIconMode;

    QIcon::State curIconState;

};

// Class HbIconEnginePrivate

HbIconEnginePrivate::HbIconEnginePrivate(const QString &iconName) :

    aspectRatioMode(Qt::KeepAspectRatio),

    mode(QIcon::Normal),

    state(QIcon::Off),

    defaultSizeFailed(false),

    loadFailed(0),

    flags(0),

    mirroringMode(HbIcon::Default),

    defaultMirroring(Unknown),

    animator(0),

    icon(0),

    badgeInfo(0),

    signalConnectionsSet(false),

    iconType(INVALID_FORMAT),

    async(false),

    asyncOngoing(false),

    asyncCallback(0),

    asyncCallbackParam(0),

    loadFinishedSlotIndex(-1)

{

    if (!iconName.isEmpty()) {

        HbIconEnginePrivate::IconName newName = {QIcon::Normal, QIcon::Off, iconName};

        iconNames.append(newName);

    }

}

HbIconEnginePrivate::HbIconEnginePrivate(const HbIconEnginePrivate &other) :

    size(other.size),

    iconNames(other.iconNames),

    pixmap(other.animator ? QPixmap() : other.pixmap), // Pixmap is cleared if other object uses animation.

    aspectRatioMode(other.aspectRatioMode),

    mode(other.mode),

    state(other.state),

    defaultSize(other.defaultSize),

    defaultSizeFailed(other.defaultSizeFailed),

    loadFailed(other.loadFailed),

    flags(other.flags),

    mirroringMode(other.mirroringMode),

    defaultMirroring(other.defaultMirroring),

    animator(0), // Animator is instance specific and not copied.

    color(other.color), // No copy for themedColor, that one is an internal, instance-specific setting.

    icon(0),  // HbIconImpl is instance specific, it is recreated when icon is painted.

    badgeInfo(0),

    signalConnectionsSet(false),

    iconType(INVALID_FORMAT),

    async(false), // similarly to themedColor, this is not copied, it needs to be set explicitly by the clients after copying

    asyncOngoing(false),

    asyncCallback(0),

    asyncCallbackParam(0),

    loadFinishedSlotIndex(-1)

{

    if (other.badgeInfo) {

        badgeInfo = new HbBadgeIcon();

        *badgeInfo = *other.badgeInfo;

    }

}

HbIconEnginePrivate::HbIconEnginePrivate(QDataStream &stream) :

    aspectRatioMode(Qt::KeepAspectRatio),

    mode(QIcon::Normal),

    state(QIcon::Off),

    defaultSizeFailed(false),

    loadFailed(0),

    flags(0),

    mirroringMode(HbIcon::Default),

    defaultMirroring(Unknown),

    animator(0),

    icon(0),

    badgeInfo(new HbBadgeIcon),

    signalConnectionsSet(false),

    iconType(INVALID_FORMAT),

    async(false),

    asyncOngoing(false),

    asyncCallback(0),

    asyncCallbackParam(0),

    loadFinishedSlotIndex(-1)

{

    // Internalize the icon from the stream

    stream >> size;

    int count;

    stream >> count;

    qint32 temp; // workaround for compiler problem

    for (int i = 0; i < count; i++) {

        IconName name;

        stream >> temp;

        name.mode = (QIcon::Mode)temp;

        stream >> temp;

        name.state = (QIcon::State)temp;

        stream >> name.name;

        iconNames.append(name);

    }

    stream >> temp;

    flags = (HbIcon::Flags)temp;

    stream >> temp;

    mirroringMode = (HbIcon::MirroringMode)temp;

    stream >> temp;

    defaultMirroring = (HbIconEnginePrivate::DefaultMirroring)temp;

    stream >> color;

    // Do not store themedColor, see the copy ctor.

    badgeInfo->internalize(stream);

}

void HbIconEnginePrivate::externalize(QDataStream &stream)

{

    // Externalize parameters that are needed to reconstruct the icon

    stream << size;

    stream << iconNames.count();

    Q_FOREACH(const IconName & name, iconNames) {

        stream << (qint32)(name.mode);

        stream << (qint32)(name.state);

        stream << name.name;

    }

    stream << (qint32)flags;

    stream << (qint32)mirroringMode;

    stream << (qint32)defaultMirroring;

    stream << (QColor)color;

    if (!badgeInfo) {

        badgeInfo = new HbBadgeIcon();

    }

    badgeInfo->externalize(stream);

}

void HbIconEnginePrivate::appendLoadFail(QIcon::Mode mode, QIcon::State state)

{

    int modeAndState = mode | (state << 16);

    int index = loadFailed.indexOf(modeAndState);

    if (index < 0) {

        loadFailed.append(modeAndState);

    }

}

void HbIconEnginePrivate::removeLoadFail(QIcon::Mode mode, QIcon::State state)

{

    int index = loadFailed.indexOf(mode | (state << 16));

    if (index >= 0) {

        loadFailed.remove(index);

    }

}

HbIconEnginePrivate::~HbIconEnginePrivate()

{

    unLoadIcon();

    delete badgeInfo;

}

/*!

  \internal

  Initiates an IPC call to the ThemeServer to unload ( decrement ref count )

  the icon if created on server side.

 */

void HbIconEnginePrivate::unLoadIcon(bool unloadedByServer)

{

    HbIconLoader *loader = HbIconLoader::global();

    // Ignore the result of any outstanding loadIcon request. The

    // parameters here must match callback and callbackParam passed to

    // HbIconLoader::loadIcon in paintHelper().

    if (loader) {

        loader->cancelLoadIcon(HbIconEngine::asyncLoadCallback, q);

    }

    if (icon) {

        if (loader) {

            loader->unLoadIcon(icon, unloadedByServer);

        }

        icon->dispose();

        icon = 0;

    }

}

void HbIconEnginePrivate::clear()

{

    size = QSizeF();

    iconNames.clear();

    pixmap = QPixmap();

    aspectRatioMode = Qt::KeepAspectRatio;

    mode = QIcon::Normal;

    state = QIcon::Off;

    defaultSize = QSizeF();

    defaultSizeFailed = false;

    loadFailed.clear();

    flags = 0;

    mirroringMode = HbIcon::Default;

    defaultMirroring = Unknown;

    animator = 0;

    color = QColor();

    themedColor = QColor();

    unLoadIcon();

    if (badgeInfo) {

        badgeInfo->removeAllBadges();

    }

}

bool HbIconEnginePrivate::isMirrored()

{

    // If mirroring mode is default, check automatic mirroring from loader.

    if (mirroringMode == HbIcon::Default && defaultMirroring == Unknown) {

        HbIconLoader *loader = HbIconLoader::global();

        defaultMirroring = loader->isAutomaticallyMirrored(

                               iconName(QIcon::Normal, QIcon::Off)) ? Enabled : Disabled;

    }

    bool basedOnLayoutDir = false;

    // Handle the different mirroring modes

    // Default

    if (mirroringMode == HbIcon::Default) {

        if (defaultMirroring == Enabled) {

            basedOnLayoutDir = true;

        } else if (defaultMirroring == Disabled) {

            return false;

        }

        // Forced

    } else if (mirroringMode == HbIcon::Forced) {

        return true;

        // Prevented

    } else if (mirroringMode == HbIcon::Prevented) {

        return false;

        // LayoutDirection

    } else if (mirroringMode == HbIcon::LayoutDirection) {

        basedOnLayoutDir = true;

    }

    if (basedOnLayoutDir) {

        // e.g. some unit tests do not have primary window at this point so need to do NULL checks here.

        if (hbInstance) {

            QList<HbMainWindow *> allWindows = hbInstance->allMainWindows();

            if (!allWindows.isEmpty() &&

                    allWindows.value(0) &&

                    allWindows.value(0)->layoutDirection() == Qt::RightToLeft) {

                return true;

            }

            return false;

        }

    }

#ifdef HB_ICON_TRACES

    qDebug() << "HbIconEnginePrivate, invalid mirroring mode";

#endif

    return false;

}

HbIconLoader::IconLoaderOptions HbIconEnginePrivate::iconLoaderOptions()

{

    HbIconLoader::IconLoaderOptions options = DEFAULT_OPTIONS;

    if (flags.testFlag(HbIcon::DoNotCache)) {

        options |= HbIconLoader::DoNotCache;

    }

    if (isMirrored()) {

        options |= HbIconLoader::HorizontallyMirrored;

    }

    if (flags.testFlag(HbIcon::ResolutionCorrected)) {

        options |= HbIconLoader::ResolutionCorrected;

    }

    if (flags.testFlag(HbIcon::NoAutoStartAnimation)) {

        options |= HbIconLoader::NoAutoStartAnimation;

    }

    return options;

}

QString HbIconEnginePrivate::iconName(QIcon::Mode mode, QIcon::State state) const

{

    QString ret;

    Q_FOREACH(const HbIconEnginePrivate::IconName & name, iconNames) {

        if (name.mode == mode && name.state == state) {

            ret = name.name;

            break;

        }

    }

    return ret;

}

void HbIconEnginePrivate::setIconName(const QString &iconName, QIcon::Mode mode, QIcon::State state)

{

    int count = iconNames.count();

    for (int i = 0; i < count; i++) {

        HbIconEnginePrivate::IconName &name = iconNames[i];

        if (name.mode == mode && name.state == state) {

            // If given icon name is empty, remove the corresponding definition

            if (iconName.isEmpty()) {

                iconNames.removeAt(i);

            } else { // Otherwise, update the icon name

                name.name = iconName;

                // Icon name changed so remove information of failed loading

                removeLoadFail(mode, state);

            }

            return;

        }

    }

    // Not found, insert new item, if the given icon name was not empty

    if (!iconName.isEmpty()) {

        HbIconEnginePrivate::IconName newName = {mode, state, iconName};

        iconNames.append(newName);

    }

}

inline bool isMonoIcon(const QString &name)

{

    // Even when the Colorized flag is not set certain icons from the theme must be

    // colorized. These mono icons are recognized from their name. The check should not be

    // done for normal files, only for logical theme graphics names.

    return name.startsWith(QLatin1String("qtg_mono_")) && !name.contains('.');

}

QColor HbIconEnginePrivate::colorToUse(const QString &iconName) const

{

    if (flags.testFlag(HbIcon::Colorized) || isMonoIcon(iconName)) {

        return color.isValid() ? color : themedColor;

    } else {

        return QColor();

    }

}

void HbIconEnginePrivate::addBadge(Qt::Alignment align,

                                   const HbIcon &icon,

                                   int z,

                                   const QSizeF &sizeFactor,

                                   Qt::AspectRatioMode aspectRatio)

{

    if (!badgeInfo) {

        badgeInfo = new HbBadgeIcon();

    }

    badgeInfo->addBadge(align, icon, z, sizeFactor, aspectRatio);

}

bool HbIconEnginePrivate::removeBadge(const HbIcon &badge)

{

    return badgeInfo ? badgeInfo->removeBadge(badge) : false;

}

void HbIconEnginePrivate::removeAllBadges()

{

    if (badgeInfo) {

        badgeInfo->removeAllBadges();

    }

}

const QList<HbBadgeIconInfo> HbIconEnginePrivate::badges() const

{

    return badgeInfo ? badgeInfo->badges() : QList<HbBadgeIconInfo>();

}

bool HbIconEnginePrivate::isBadged() const

{

    return badgeInfo ? badgeInfo->isBadged() : false;

}

// Class HbIconEngine

HbIconEngine::HbIconEngine() :