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

**

** 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 "hbiconloader_p.h"

#include "hbframedrawer_p.h"

#include "hbicontheme_p.h"

#include "hblayoutdirectionnotifier_p.h"

#include "hbinstance.h"

#include "hbinstance_p.h"

#include "hbiconanimation_p.h"

#include "hbiconanimator.h"

#include "hbiconanimator_p.h"

#include "hbtheme.h"

#include "hbtheme_p.h"

#include "hbthemeclient_p.h"

#include "hbthemeutils_p.h"

#include "hbiconanimationmanager.h"

#include "hbiconanimationdefinition.h"

#include "hbimagetraces_p.h"

#include "hbmemoryutils_p.h"

#include "hbpixmapiconimpl_p.h"

#include "hbiconimplcreator_p.h"

#include "hbiconsource_p.h"

#include "hbthemeindex_p.h"

#include "hbthemecommon_p.h"

#include <QDir>

#include <QCoreApplication>

#include <QDebug>

#include <QPicture>

#include <QPainter>

#include <QStyleOption>

#include <QApplication> //krazy:exclude=qclasses

#include <QtAlgorithms>

#include <QTime>

#include <QSvgRenderer>

#include <QImageReader>

#include <QHash>

#include <QThread>

#include <QMutex>

#include <QMutexLocker>

#ifdef HB_NVG_CS_ICON

#include "hbeglstate_p.h"

#include "hbnvgrasterizer_p.h"

#endif

// SVG animation is currently disabled because of bugs in QT's svg engine

#undef HB_SVG_ANIMATION

//#define HB_ICON_CACHE_DEBUG

// Icon name without extension

static const char *s_unknown = "unknown";

/*!

    \class HbIconLoader

    \brief HbIconLoader loads and caches vector and raster icons

    either via the Theme Server or directly from files/resources.

    \internal

*/

// Allocated dynamically so it can be deleted before the application object is destroyed.

static HbIconLoader *theLoader = 0;

static bool loaderDestroyed = false;

// The max consumption for the icons held by the cachekeeper, assuming that each

// icon is 32bpp. Note that the cachekeeper's content is cleared also when

// losing visibility and when switching rendering mode.

const int MAX_KEEPALIVE_CACHE_SIZE_BYTES = 1024 * 1024; // 1 MB

// Icons with size above a certain limit are always ignored by the cachekeeper.

const int MAX_KEEPALIVE_ITEM_SIZE_BYTES = MAX_KEEPALIVE_CACHE_SIZE_BYTES / 2;

class HbLocalLoaderThread : public QThread

{

public:

    void run();

};

class HbIconLoaderPrivate

{

public:

    HbIconLoaderPrivate();

    ~HbIconLoaderPrivate();

    static HbIconLoaderPrivate *global();

    static QString removeIconNameSuffix(const QString &iconName);

    /* This method is supposed to work the same way

       as the FindIconHelper in the Icon Theme Spec: */

    static QString findSharedResourceHelper(const QString &resourceName,

                                            bool mirrored,

                                            bool &mirroredIconFound,

                                            Hb::ResourceType itemType = Hb::IconResource,

                                            bool useThemeIndex = true);

    static QString findEffectHelper(const QString &effectName);

    bool isAutomaticallyMirrored(const QString &iconName);

    bool isLayoutMirrored();

    void setLayoutMirrored(bool mirrored);

    QByteArray createCacheKeyFrom(const QString &iconName,

                                  const QSizeF &size,

                                  Qt::AspectRatioMode aspectRatioMode,

                                  QIcon::Mode mode,

                                  bool mirrored,

                                  const QColor &color);

    QString storedTheme;

    int sourceResolution;

    int resolution;

    qreal zoom;

    // Frame-by-frame animation support -------------------------------------->

    HbIconAnimationManager *animationManager;

    // Flag to prevent animation frames from loading new animations recursively

    bool animationLoading;

    // <-- Frame-by-frame animation support ------------------------------------

    HbIconSource *lastIconSource;

    enum {

        Unknown = 0,

        NotMirrored = 1,

        Mirrored = 2

    };

    /*

    * Information whether the layout is mirrored or not.

    * Flipped icons are used in the mirrored layout.

    */

    int layoutMirrored;

    struct AsyncParams {

        HbIconLoader::HbAsyncIconLoaderCallback mCallback;

        HbIconLoadingParams mLdParams;

        void *mParam;

    };

    QList<AsyncParams *> mActiveAsyncRequests;

    HbLocalLoaderThread mLocalLoaderThread;

    HbLocalIconLoader *mLocalLoader;

    QMutex mLocalLoadMutex;

    QMutex mIconSourceMutex;

    friend class HbLocalLoaderThread;

    /*

     * Client side caching of sgimage icon required, as sgimage lite cannot be

     * opened multiple times

     *

     * It is also beneficial for performance, because it reduces IPC in certain

     * cases.

     *

     * Note that by default this is not a permanent cache, i.e. when an iconimpl's

     * refcount reaches zero it is removed from the cache.  This means that the

     * cache is beneficial for having the same icon rendered by two or more HbIcons

     * at the same time (very typical in some itemview (e.g. list widget) cases),

     * but it would not benefit a load-unload-load scenario because the icon is

     * removed from the cache during the unload when there are no references

     * anymore.

     *

     * However the cachekeeper below will change this behavior, preventing refcounts

     * reaching zero in unLoadIcon(), so this cache may contain also icons that are

     * not really in use and are only referenced by the cachekeeper. This is

     * required for further reduction of IPC calls.

     */

    QHash<QByteArray, HbIconImpl *> iconImplCache;

    // The global cachekeeper instance will hold references to icons that would

    // normally be unloaded (i.e. mIcons will contain icons with refcount 1).

    //

    // Icons get added from unLoadIcon(), meaning that if the cachekeeper decides to

    // hold a reference then the icon is not really unloaded (and thus stays in

    // iconImplCache).

    //

    // When the icon gets referenced due to a cache hit, in loadIcon() and other

    // places, the icon is removed from the cachekeeper.

    class CacheKeeper {

    public:

        CacheKeeper(HbIconLoaderPrivate *p) : mConsumption(0), mIconLoaderPrivate(p) { }

        void ref(HbIconImpl *icon);

        void unref(HbIconImpl *icon);

        void clear();

    private:

        void del(HbIconImpl *icon, bool sendUnloadReq);

        QList<HbIconImpl *> mIcons;

        int mConsumption;

        HbIconLoaderPrivate *mIconLoaderPrivate;

        friend class HbIconLoaderPrivate;

    };

    CacheKeeper cacheKeeper;

};

void HbLocalLoaderThread::run()

{

    setPriority(QThread::LowPriority);

    exec();

    delete HbIconLoaderPrivate::global()->mLocalLoader;

}

HbIconLoaderPrivate::HbIconLoaderPrivate() :

    storedTheme(HbTheme::instance()->name()),

    sourceResolution(144), // This is about the resolution of a Nokia N95 8GB

    resolution(144),

    zoom(1.0),

    animationManager(HbIconAnimationManager::global()),

    animationLoading(false),

    lastIconSource(0),

    layoutMirrored(Unknown),

    mLocalLoadMutex(QMutex::Recursive),

    mIconSourceMutex(QMutex::Recursive),

    cacheKeeper(this)

{

    qRegisterMetaType<HbIconImpl *>();

    qRegisterMetaType<HbIconLoadingParams>();

    qRegisterMetaType<void *>();

    mLocalLoader = new HbLocalIconLoader;

    mLocalLoader->moveToThread(&mLocalLoaderThread);

    mLocalLoaderThread.start();

}

HbIconLoaderPrivate::~HbIconLoaderPrivate()

{

    // quit() cannot be called directly on mLocalLoaderThread because

    // there is a chance that start() has not yet executed.

    QMetaObject::invokeMethod(mLocalLoader, "doQuit", Qt::QueuedConnection);

    mLocalLoaderThread.wait();

    delete lastIconSource;

    qDeleteAll(mActiveAsyncRequests);

    cacheKeeper.clear();

    // There may be icons in iconImplCache at this point and they are not

    // leftovers so they must not be destroyed. In many cases the HbIconLoader

    // is destroyed before the destructors of icon engines or framedrawers are run

    // so it must be left up to them to correctly unref all icons.

    iconImplCache.clear();

}

HbIconLoaderPrivate *HbIconLoaderPrivate::global()

{

    HbIconLoader *loader = HbIconLoader::global();

    return loader->d;

}

QString HbIconLoaderPrivate::removeIconNameSuffix(const QString &iconName)

{

    QString loweredIconName = iconName.toLower();

    if (loweredIconName.endsWith(QLatin1String(".svg"))

            || loweredIconName.endsWith(QLatin1String(".png"))

            || loweredIconName.endsWith(QLatin1String(".mng"))

            || loweredIconName.endsWith(QLatin1String(".gif"))

            || loweredIconName.endsWith(QLatin1String(".xpm"))

            || loweredIconName.endsWith(QLatin1String(".jpg"))

            || loweredIconName.endsWith(QLatin1String(".nvg"))) {

        return iconName.left(iconName.length() - 4);

    }

    if (loweredIconName.endsWith(QLatin1String(".svgz"))

            || loweredIconName.endsWith(QLatin1String(".qpic"))) {

        return iconName.left(iconName.length() - 5);

    }

    return iconName;

}

QString HbIconLoader::formatFromPath(const QString &iconPath)

{

    QString suffix = QFileInfo(iconPath).suffix().toUpper();

    if (suffix == "SVGZ") {

        return "SVG";

    }

    if (suffix == "QPIC") {

        return "PIC";

    }

    if (suffix == "XML" || suffix == "AXML" || suffix == "FXML") {

        return "BLOB";

    }

    return suffix;

}

QString HbIconLoaderPrivate::findSharedResourceHelper(const QString &resourceName, bool mirrored,

                                                      bool &mirroredIconFound, Hb::ResourceType itemType,

                                                      bool useThemeIndex)

{

    Q_UNUSED(useThemeIndex)

    Q_UNUSED(itemType)

    mirroredIconFound = false;

    QString iconPath;

    if (HbThemeUtils::isLogicalName(resourceName)) {

        // Try to get themed icon information from theme index

        HbThemeIndexResource resource(resourceName);

        if (resource.isValid()) {

            if (mirrored) {

                return resource.fullMirroredFileName();

            } else {

                return resource.fullFileName();

            }

        } else {

            // Logical name not found in theme index - return empty string

            return QString();

        }

    } else {

        // Not a logical name. Check from file system.

        if (mirrored) {

            // If icon is mirrored, try to find the icon in a separate "mirrored" folder used for mirrored icons

            // Find the directory part from the full filename

            int index1 = resourceName.lastIndexOf('/');

            int index2 = resourceName.lastIndexOf('\\');

            int index = index1 > index2 ? index1 : index2;

            QString iconNameCopy(resourceName);

            if (index > 0) {

                iconNameCopy.insert(index + 1, QString("mirrored/"));

            }

            if (QFile::exists(iconNameCopy)) {

                iconPath = iconNameCopy;

            }

            if (!iconPath.isEmpty()) {

                mirroredIconFound = true;

                return iconPath;

            }

        }

        if (QFile::exists(resourceName)) {

            iconPath = resourceName;

        }

    }

    return iconPath;

}

/*

From Freedesktop.org:

 The exact algorithm (in pseudocode) for looking up an icon in a theme (if the implementation supports SVG) is:

FindIcon(icon, size) {

  filename = FindIconHelper(icon, size, user selected theme);

  if filename != none

    return filename

  return LookupFallbackIcon(icon)

}

FindIconHelper(icon, size, theme) {

  filename = LookupIcon(icon, size, theme)

  if filename != none

    return filename

  if theme has parents

    parents = theme.parents

  else if theme != hicolor

    parents = [hicolor]

  for parent in parents {

    filename = FindIconHelper(icon, size, parent)

    if filename != none

      return filename

  }

  return none

}

With the following helper functions:

LookupIcon(iconname, size, theme) {

  for each subdir in $(theme subdir list) {

    for each directory in $(basename list) {

      for extension in ("png", "svg", "xpm") {

        if DirectoryMatchesSize(subdir, size) {

          filename = directory/$(themename)/subdir/iconname.extension

          if exist filename

        return filename

        }

      }

    }

  }

  minimal_size = MAXINT

  for each subdir in $(theme subdir list) {

    for each directory in $(basename list) {

      for extension in ("png", "svg", "xpm") {

        filename = directory/$(themename)/subdir/iconname.extension

        if exist filename and DirectorySizeDistance(subdir, size) < minimal_size {

       closest_filename = filename

       minimal_size = DirectorySizeDistance(subdir, size)

        }

      }

    }

  }

  if closest_filename set

     return closest_filename

  return none

}

LookupFallbackIcon(iconname) {

  for each directory in $(basename list) {

    for extension in ("png", "svg", "xpm") {

      if exists directory/iconname.extension

        return directory/iconname.extension

    }

  }

  return none

}

DirectoryMatchesSize(subdir, iconsize) {

  read Type and size data from subdir

  if Type is Fixed

    return Size == iconsize

  if Type is Scaled

    return MinSize <= iconsize <= MaxSize

  if Type is Threshold

    return Size - Threshold <= iconsize <= Size + Threshold

}

DirectorySizeDistance(subdir, size) {

  read Type and size data from subdir

  if Type is Fixed

    return abs(Size - iconsize)

  if Type is Scaled

    if iconsize < MinSize

        return MinSize - iconsize

    if iconsize > MaxSize

        return iconsize - MaxSize

    return 0

  if Type is Threshold

    if iconsize < Size - Threshold

        return MinSize - iconsize

    if iconsize > Size + Threshold

        return iconsize - MaxSize

    return 0

}

In some cases you don't always want to fall back to an icon in an inherited theme. For instance, sometimes you look for a set of icons, prefering any of them before using an icon from an inherited theme. To support such operations implementations can contain a function that finds the first of a list of icon names in the inheritance hierarchy. I.E. It would look something like this:

FindBestIcon(iconList, size) {

  filename = FindBestIconHelper(iconList, size, user selected theme);

  if filename != none

    return filename

  for icon in iconList {

    filename = LookupFallbackIcon(icon)

    if filename != none

      return filename

  }

  return none;

}

FindBestIconHelper(iconList, size, theme) {

  for icon in iconList {

    filename = LookupIcon(icon, size, theme)

    if filename != none

      return filename

  }

  if theme has parents

    parents = theme.parents

  else if theme != hicolor

    parents = [hicolor]

  for parent in parents {

    filename = FindBestIconHelper(iconList, size, parent)

    if filename != none

      return filename

  }

  return none

    }

*/