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

**

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

#include "hbthemeindex_p.h"

#include "hbthemecommon_p.h"

#include "hbiconimplcreator_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>

#ifdef HB_NVG_CS_ICON

#include "hbeglstate_p.h"

#endif

#define HB_ICONIMPL_CACHE

/*

 * Client side caching of sgimage icon required,

 * as  sgimage lite cannot be opened multiple times

 */

#ifdef HB_SGIMAGE_ICON

#ifndef HB_ICONIMPL_CACHE

#define HB_ICONIMPL_CACHE

#endif

#endif

// Just an experimental implementation.. Disable if necessary.

#define ENABLE_EXPERIMENTAL_RESIZE_BOOST__

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

#undef HB_SVG_ANIMATION

static const char *s_unknown = "unknown";

// Icon name without extension

/*!

    \class HbIconLoader

    \brief HbIconLoader loads icons according to the Freedesktop Icon Theme Specification

    \internal

*/

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

// Deleting it later causes segmentation fault.

static HbIconLoader *theLoader = 0;

#ifdef HB_ICONIMPL_CACHE

static QHash<QByteArray, HbIconImpl *> iconImplCache;

#endif

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);

#ifdef HB_ICONIMPL_CACHE

    QByteArray createCacheKeyFrom(const QString &iconName,

                                  const QSizeF &size,

                                  Qt::AspectRatioMode aspectRatioMode,

                                  QIcon::Mode mode,

                                  bool mirrored,

                                  const QColor &color,

                                  HbRenderingMode renderMode);

#endif

public:

    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;

private:

    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;

};

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)

{

}

HbIconLoaderPrivate::~HbIconLoaderPrivate()

{

    delete lastIconSource;

}

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

    }

*/

bool HbIconLoaderPrivate::isAutomaticallyMirrored(const QString &iconName)

{

    // only place to get mirroring information is from themeindex

    // Try to get themed icon information from theme index

    HbThemeIndexResource resource(iconName);

    if (resource.isValid()) {

        return resource.isAutomaticallyMirrored();

    }

    return false;

}

bool HbIconLoaderPrivate::isLayoutMirrored()

{

    if (layoutMirrored == Unknown) {

        // The layout directionality is defined by asking it from the main window.

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

        HbMainWindow *primaryWindow = allWindows.value(0);

        if (primaryWindow) {

            layoutMirrored = primaryWindow->layoutDirection() == Qt::LeftToRight ? NotMirrored : Mirrored;

        } else {

            // Do not know mirroring state yet, return not mirrored.

            return NotMirrored;

        }

    }

    return layoutMirrored == Mirrored;

}

void HbIconLoaderPrivate::setLayoutMirrored(bool mirrored)

{

    layoutMirrored = mirrored ? Mirrored : NotMirrored;

}

#ifdef HB_ICONIMPL_CACHE

QByteArray HbIconLoaderPrivate::createCacheKeyFrom(const QString &iconName,

        const QSizeF &size,

        Qt::AspectRatioMode aspectRatioMode,

        QIcon::Mode mode,

        bool mirrored,

        const QColor &color,

        HbRenderingMode renderMode)

{

    static const int paramArraySize = 8;

    // This uses QByteArray to improve performance compared to QString.

    // It allows appending stuff with less heap allocations and conversions compared to using QString.

    QByteArray cacheKey;

    int nameSize = iconName.size();

    // Preallocate memory for the array so appending stuff in it does not cause new memory allocations

    cacheKey.reserve(sizeof(int)*paramArraySize + nameSize * sizeof(QChar) + 1);

    int temp[paramArraySize];

    // Store size of icon name first because its often different with different icons, so comparing

    // different cacheKeys is fast.

    temp[0] = nameSize;

    temp[1] = static_cast<int>(size.width());

    temp[2] = static_cast<int>(size.height());

    temp[3] = aspectRatioMode;

    temp[4] = mode;

    if (color.isValid()) {

        temp[5] = 1; // flag, color is valid

        temp[6] = color.rgba();

    } else {

        temp[5] = 0; // flag, color is invalid

        temp[6] = 0;

    }

    // Append render mode when creating cache key

    temp[7] = renderMode;

    cacheKey.append((char *)&(temp[0]), sizeof(int)*paramArraySize);

    const QChar *iconNamePtr = iconName.constData();

    cacheKey.append((char *)iconNamePtr, nameSize * sizeof(QChar));

    if (mirrored) {

        cacheKey.append('M');

    }

    return cacheKey;

}

#endif

HbIconLoader::HbIconLoader(const QString &appName, QObject *parent)

    : QObject(parent)

{

    setObjectName(appName);

    d = new HbIconLoaderPrivate();

    // Set default rendering mode to EHWRendering

    renderMode = EHWRendering;

    // Delete the icon loader when the application is destroyed.

    connect(QCoreApplication::instance(), SIGNAL(aboutToQuit()), this, SLOT(destroy()));

    connect(HbLayoutDirectionNotifier::instance(), SIGNAL(layoutDirectionChangeStarted()),

            this, SLOT(updateLayoutDirection()));

#ifdef HB_TOOL_INTERFACE

    // This enables partial theme updates.

    connect(&hbInstance->theme()->d_ptr->iconTheme, SIGNAL(iconsUpdated(QStringList)), this, SLOT(themeChange(QStringList)));

#endif

}