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

**

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

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

#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 findIconHelper(const QString &iconName,

                                  bool mirrored,

                                  bool& mirroredIconFound,

                                  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

private:

    void createMirroredList();

public: // data

    QString storedTheme;

    /*

    * List of icons that should be mirrored automatically in a mirrored layout.

    * This is initially read from a config file "mirrored.txt".

    */

    QStringList mirroredList;

    bool mirroredListCreated;

    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: // data

    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(HbIconTheme::global()->currentTheme()),

        mirroredListCreated(false),

        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(".svg")

        || loweredIconName.endsWith(".png")

        || loweredIconName.endsWith(".mng")

        || loweredIconName.endsWith(".gif")

        || loweredIconName.endsWith(".xpm")

        || loweredIconName.endsWith(".jpg")

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

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

    }

    if (loweredIconName.endsWith(".svgz")

        || loweredIconName.endsWith(".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::findIconHelper(const QString &iconName, bool mirrored, bool& mirroredIconFound, bool useThemeIndex)

{

    Q_UNUSED(useThemeIndex)

    mirroredIconFound = false;

    QString iconPath;

    if (QDir::isRelativePath(iconName)) {

        bool themeIndexUsed = false;

#ifdef Q_OS_SYMBIAN

        // Try to get themed icon information from theme index

        ThemeIndexTables &themeIndex = hbInstance->theme()->d_ptr->themeIndex;

        // Check if there is a valid theme index

        if (useThemeIndex && themeIndex.isValid()) {

            themeIndexUsed = true;

            int tableIndex;

            const HbThemeIndexItem *item = themeIndex.getItem(iconName, tableIndex);

            if (item) {

                const char *baseAddress = reinterpret_cast<const char *>(themeIndex.tables[tableIndex]);

                QString fullfilename;

                // Add drive letter of the used theme if the path does not point to a QT resource

                if (*(baseAddress + item->folderOffset) != ':') {

                    fullfilename.append(themeIndex.drives[tableIndex]);

                    fullfilename.append(':');

                }

                // Add folder

                fullfilename.append(baseAddress + item->folderOffset);

                if (mirrored) {

                    if (item->mirroredExtOffset >= 0) {

                        mirroredIconFound = true;

                        fullfilename.append("mirrored\\");

                        fullfilename.append(iconName);

                        fullfilename.append(baseAddress + item->mirroredExtOffset);

                        #ifdef THEME_INDEX_TRACES

                        qDebug() << "ThemeIndex: Resolved icon filename:" << fullfilename.toUtf8();

                        #endif

                        return fullfilename;

                    } 

                }

                fullfilename.append(iconName);

                fullfilename.append(baseAddress + item->extOffset);

                #ifdef THEME_INDEX_TRACES

                qDebug() << "ThemeIndex: Resolved icon filename:" << fullfilename.toUtf8();

                #endif

                return fullfilename;

            }

        }

#endif // Q_OS_SYMBIAN

        // If there was no theme index, search the icon in theme icon dirs (slow)

        if (!themeIndexUsed) {

        foreach( const QString &dir, HbIconTheme::global()->dirList() ) {

                if (mirrored) {

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

                    iconPath =  HbStandardDirs::findResource( dir + "mirrored" + '/' + iconName, Hb::IconResource );

                    if( !iconPath.isEmpty() ) {

                        mirroredIconFound = true;

                        break;

                    }

                }

            iconPath =  HbStandardDirs::findResource( dir + iconName, Hb::IconResource );

                // If the file was found in this dir, return the filename.

            if ( !iconPath.isEmpty() ) {

                    break;

                }

            }

        }

    } else {

        // Absolute path. Do not scan through different theme directories.

        QString iconNameCopy(iconName);

        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 = iconName.lastIndexOf('/');

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

            int index = index1 > index2 ? index1 : index2;

            QString iconNameCopy(iconName);

            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(iconName, 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)

{

    if (!mirroredListCreated) {

        // Read the list of the mirrored icons from a file.

        createMirroredList();

        mirroredListCreated = true;

    }

    // Check if the given icon name is found in the list of mirrored icons

    QList<QString>::const_iterator j = qBinaryFind(mirroredList, iconName);

    return (j != mirroredList.constEnd());

}

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;

}

void HbIconLoaderPrivate::createMirroredList()

{

    // Find mirrored.txt file

    QString filename = HbStandardDirs::findResource("themes/themes/mirrored.txt", Hb::ThemeResource);

    if (filename.endsWith("mirrored.txt")) {

        // Try to read file

        QFile file(filename);

        if (file.open(QIODevice::ReadOnly)) {

            QString line;

            while(!file.atEnd()) {        

                QByteArray dirtyLine = file.readLine();

                line = QString(dirtyLine).trimmed();

                // Skip empty lines and comment lines

                if (line.isEmpty() || line.at(0) == '#') {

                    continue; 

                }

                mirroredList.append(line);

            }