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

**

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

#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,

#endif

    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;

};

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

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

    }

        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;

        // 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 {

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

            }

            iconPath = HbStandardDirs::findResource(iconNameCopy, Hb::IconResource);

            if( !iconPath.isEmpty() ) {

                mirroredIconFound = true;

                return iconPath;

            }

        }

        iconPath = HbStandardDirs::findResource(resourceName, Hb::IconResource);

    }

    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

    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

{

    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

}

HbIconLoader::~HbIconLoader()

{

    delete d;

}

HbIconLoader *HbIconLoader::global()