FCL/sf/mw/hb: comparison src/hbcore/image/hbicon.cpp

equal deleted inserted replaced

--1:000000000000
+:16d8024aca5e
+/****************************************************************************
+**
+** 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 "hbicon.h"
+#include "hbicon_p.h"
+#include "hbiconanimator.h"
+#include "hbbadgeicon_p.h"
+#include "hbiconloader_p.h"
+#include <QObject>
+#include <QPainter>
+#include <QVariant>
+/*!
+@stable
+@hbcore
+\class HbIcon
+\brief HbIcon is a paintable instance of an icon. The term icon means any piece of
+graphics that can be drawn. This class is not intended to be derived from.
+For more information on image and icon classes and general notes about
+graphics memory usage see \ref graph_mem_usage "this page".
+This class implements copy-on-write semantics, so copy constructor and assignment operator
+only perform shallow copy and are fast. A deep copy is done if the icon state is changed.
+Supported formats and file extensions are the following.
+- SVG-T (.svg)
+- Externalized QPicture (.qpic)
+- PNG (.png)
+- XPM (.xpm)
+- JPG (.jpg)
+- Frame animations (.axml)
+An icon is defined by its name. The filename should be same as the logical name of the icon,
+accompanied with the file extension.
+E.g. logical name of the icon is "frame". Assuming the icon file is in SVG-T format,
+the filename should be "frame.svg".
+If the given icon name is a logical icon name and not an absolute filename,
+it is searched in the icon locations of the theming framework.
+An absolute icon filename can point e.g. in application's resource file.
+The icon can be resized with method HbIcon::setSize.
+When resizing, by default the aspect ratio of the icon is preserved.
+To change this, define the aspect ratio mode parameter in the method HbIcon::paint().
+An icon itself can be a combination of existing icons; in this case the main icon is
+"badged" with smaller icons to form a distinct icon. You can badge icons in this way
+with the HbIcon::addBadge method, specifying the location where the badge should be drawn
+and a second HbIcon to draw at the indicated location. To prevent possible recursion ,
+you can't badge an icon with a badge icon that is itself badged, however.
+Scaled instances of the icons are shared by the framework
+to decrease memory consumption.
+A brief example of how to create an icon and use it.
+\snippet{clock/clockworldview.cpp,1}
+This class provides built-in support for icon animations.
+Supported formats are the following.
+- GIF (.gif)
+- MNG (.mng)
+The formats mentioned above contain all the animation information inside a single file.
+They are pixel formats, so the quality of resizing the animations is not good.
+Icon animations can also be constructed from separate frame icons.
+The frames are defined in separate files, which can be in any format supported by HbIcon.
+The animation frame information for the icon is defined using class HbIconAnimationManager.
+The animated icon can be then constructed normally with its name.
+As default the icon animation is started automatically when the icon is painted for the first time.
+This can be disabled with flag HbIcon::NoAutoStartAnimation.
+An example of how to define a frame-by-frame animation and construct an icon using it.
+\dontinclude ultimatecodesnippet/ultimatecodesnippet.cpp
+\skip frame-by-frame
+\until }
+*/
+/*!
+\enum HbIcon::Flag
+\b DoNotCache \b (0x01) Icon pixmap is not cached in the system wide icon pixmap cache.
+Setting this flag improves cache performance for other icons, if this icon does
+not need to be cached for being able to load it faster next time.
+\b ResolutionCorrected \b (0x02) This flag is useful for making icon sizes automatically
+adapt to different screen resolutions (DPI values) and zoom factors used in the user
+interface. The current display resolution (DPI value) and zoom factor are taken
+in consideration when defining the default size of the icon. This affects on what default
+size is reported for the icon and also in which size the icon is rendered if its size is
+not set explicitly. The default DPI value is 144 and the default zoom factor 1.0.
+When this flag is set, the corrected default size of icon is defined as:
+Corrected default size = original default size * current DPI value / default DPI
+value * current zoom factor
+\note Currently this flag has an effect on vector icons only.
+\note If the icon size is set explicitly this flag has no effect.
+\b NoAutoStartAnimation \b (0x04) This flag disables automatic starting of the icon animation
+when the icon is painted for the first time. The client can then control the animation with
+startAnimation() and stopAnimation() methods in class HbIconAnimator.
+If the icon is not animated this flag has no effect.
+\b Colorized \b (0x08) This flag enables the usage of the color that is set via
+setColor(). If this flag is not set then the color that is set with setColor() is
+ignored, unless the icon refers some theme graphics. For icons coming from the
+theme this flag can be left unset because they will still be colorized properly
+if the logical icon name indicates that the icon is a mono icon. Therefore this
+flag is only relevant for icons loaded from regular files.
+*/
+/*!
+\enum HbIcon::MirroringMode
+\b Default This is the default mirroring mode. The icon is mirrored in right-to-left
+layout if its name is listed in the icon framework's configuration list of mirrored icons.
+\b Forced Forces horizontal mirroring of the icon. As default, the system
+automatically mirrors the icon pixmap based on a predefined configuration,
+when required for the purpose of a mirrored layout.
+This mirroring mode explicitly forces the icon pixmap to be mirrored,
+regardless of the layout direction.
+\b Prevented Prevents horizontal mirroring of the icon. As default, the system
+automatically mirrors the icon pixmap based on a predefined configuration,
+when required for the purpose of a mirrored layout.
+This mirroring mode explicitly prevents the icon pixmap from being mirrored,
+regardless of the layout direction.
+\b LayoutDirection This mirroring mode automatically mirrors the icon pixmap
+in a right-to-left layout.
+*/
+// Must be initialized dynamically because QIcon cannot be constructed
+// when static variables are constructed.
+static HbIconPrivate *shared_null = 0;
+static const int iconMetaType = qRegisterMetaType<HbIcon>();
+/*!
+This constructor is used for shared_null instance only
+\internal
+*/
+HbIconPrivate::HbIconPrivate() :
+engine( new HbIconEngine(QString()) ),
+qicon(engine),
+badgeInfo(0)
+{
+ref.ref(); // Need to do extra ref so the shared null does not get destructed
+}
+/*!
+\internal
+*/
+HbIconPrivate::HbIconPrivate( const QIcon &qicon ) :
+engine(0),
+qicon(qicon),
+badgeInfo(0)
+{
+}
+/*!
+\internal
+*/
+HbIconPrivate::HbIconPrivate( const QString &iconName ) :
+engine( new HbIconEngine(iconName) ),
+qicon(engine),
+badgeInfo(0)
+{
+}
+/*!
+\internal
+*/
+HbIconPrivate::HbIconPrivate( const HbIconPrivate &other ) :
+QSharedData( other ),
+size( other.size ),
+engine(0),
+qicon(),
+badgeInfo(0)
+{
+if ( other.engine ) {
+engine = new HbIconEngine( *other.engine );
+// Have to instantiate a temporary QIcon because
+// QIcon's copy constructor shares the engine.
+QIcon temp(engine);
+qicon = temp;
+} else {
+// Copy constructed from qicon - so just copy the qicon.
+qicon = other.qicon;
+if ( other.badgeInfo ) {
+badgeInfo = new HbBadgeIcon(*other.badgeInfo);
+}
+}
+}
+/*!
+\internal
+*/
+HbIconPrivate::~HbIconPrivate()
+{
+delete badgeInfo;
+if (engine) {
+engine->setAnimator(0);
+}
+// engine is deleted by QIcon destructor.
+}
+/*!
+\internal
+*/
+void HbIconPrivate::clear()
+{
+if (badgeInfo) {
+badgeInfo->removeAllBadges();
+}
+if (engine) {
+engine->clear();
+size = QSizeF();
+} else {
+qicon = QIcon();
+}
+}
+/*!
+\internal
+*/
+void HbIconPrivate::removeAllBadges()
+{
+if ( engine ) {
+engine->removeAllBadges();
+} else if ( badgeInfo ) {
+badgeInfo->removeAllBadges();
+}
+}
+/*!
+\internal
+*/
+bool HbIconPrivate::isBadged() const
+{
+if ( engine ) {
+return engine->isBadged();
+} else if ( badgeInfo ) {
+return badgeInfo->isBadged();
+}
+return false;
+}
+/*!
+\internal
+*/
+QDataStream &operator>>(QDataStream &stream, HbIconPrivate &icon)
+{
+stream >> icon.size;
+int enginePtr = 0;
+stream >> enginePtr;
+if (enginePtr) {
+icon.engine = new HbIconEngine(stream);
+} else {
+stream >> icon.qicon;
+}
+return stream;
+}
+/*!
+\internal
+*/
+QDataStream &operator<<(QDataStream &stream, const HbIconPrivate &icon)
+{
+stream << icon.size;
+// Put the engine pointer in stream to see if it exists
+stream << (qptrdiff)(icon.engine);
+// If the icon has engine, externalize it in the stream
+if (icon.engine) {
+icon.engine->externalize(stream);
+} else {
+stream << icon.qicon;
+}
+return stream;
+}
+/*!
+\internal
+*/
+bool HbIconPrivate::addBadge(Qt::Alignment align,
+const HbIcon& icon,
+int z)
+{
+if ( icon.isBadged() ) {
+return false;
+} else if ( engine ) {
+engine->addBadge(align, icon, z);
+} else {
+if ( !badgeInfo ) {
+badgeInfo = new HbBadgeIcon();
+}
+badgeInfo->addBadge(align, icon, z);
+}
+return true;
+}
+/*!
+\internal
+*/
+bool HbIconPrivate::removeBadge(const HbIcon& badge)
+{
+bool result = false;
+if ( engine ) {
+result = engine->removeBadge(badge);
+} else if ( badgeInfo ) {
+result = badgeInfo->removeBadge(badge);
+}
+return result;
+}
+/*! Default constructor. If this constructor is used, the icon name needs to be set
+* by calling HbIcon::setIconName.
+*/
+HbIcon::HbIcon()
+{
+// Construct shared_null if not done yet.
+if ( !shared_null ) {
+shared_null = new HbIconPrivate;
+}
+d = shared_null;
+}
+/*! Constructs a new icon with the icon name \a iconName.
+*/
+HbIcon::HbIcon( const QString &iconName )
+{
+d = new HbIconPrivate(iconName);
+}
+/*! Constructs a new icon to be a copy of the given QIcon.
+* Due to the limitations listed below, this constructor should be used only for
+* compatibility reasons if a QIcon instance needs to be passed as a parameter
+* to a method taking a HbIcon parameter.
+* \note If this constructor is used, there are the following limitations in the HbIcon methods.
+* - HbIcon::defaultSize() always returns QSizeF().
+* - HbIcon::paint() ignores the parameter aspectRatioMode and converts the given QRectF to QRect.
+* This method should only be used if absolute necessary, as this is not ideal for hardware accelerated environment.
+*/
+HbIcon::HbIcon( const QIcon &icon )
+{
+d = new HbIconPrivate(icon);
+}
+/*!
+* Copy constructs a new icon using the \a other icon.
+* Copy-on-write semantics is used, so this only does a shallow copy.
+*/
+HbIcon::HbIcon( const HbIcon &other ) :
+d( other.d )
+{
+}
+/*!
+* Assigns the \a other icon to this icon and returns a reference to
+* this icon. Copy-on-write semantics is used, so this only does a shallow copy.
+*/
+HbIcon &HbIcon::operator=( const HbIcon &other )
+{
+if ( &other != this ) {
+d = other.d;
+}
+return *this;
+}
+/*!
+* Destroys the icon.
+*/
+HbIcon::~HbIcon()
+{
+}
+/*!
+* Returns true if either
+* - Icon was not copy constructed from QIcon and it does not have the any icon names set.
+* - Icon was copy constructed from QIcon and QIcon::isNull returns true.
+* \note Even a non-null icon might not be able to create valid pixmaps,
+* e.g. if the file does not exist or cannot be read.
+*/
+bool HbIcon::isNull() const
+{
+if (d->engine) {
+return d->engine->isNull();
+} else {
+return d->qicon.isNull();
+}
+}
+/*!
+* Clears the icon. After this it is same as a default constructed HbIcon.
+* Calling this method is faster than assigning a default constructed HbIcon to this icon.
+*/
+void HbIcon::clear()
+{
+// A NULL icon is always cleared - save some time not detaching from it
+if ( d.constData() != shared_null ) {
+d.detach();
+d->clear();
+}
+}
+/*!
+* Indicates whether or not the icon is badged.
+* returns true if this icon is bearing a badge.
+*/
+bool HbIcon::isBadged() const
+{
+return d->isBadged();
+}
+/*!
+* Returns the the default icon pixmap in state QIcon::Normal and mode QIcon::Off.
+*
+* \note This method should be used only if it is necessary to get hold of the pixel data
+* of the pixmap. It slows down hardware accelerated rendering. In normal use cases, this
+* method is not needed. HbIcon::size() can be used to retrieve the size of the icon
+* and HbIcon::paint() to paint the icon.
+*/
+QPixmap HbIcon::pixmap()
+{
+if (d->engine) {
+return d->engine->pixmap( d->size.toSize(), QIcon::Normal, QIcon::Off );
+}
+return QPixmap();
+}
+/*!
+* Sets the new color that is used to colorize mono icons.
+*
+* \param  color to be set
+*
+* This setting will be ignored for regular files when the HbIcon::Colorized flag
+* is not set.  This does not apply to theme elements, for them the color is
+* always taken into account when the logical graphics name indicates that it is
+* a mono icon.
+*
+* Note that if a widget css defines a color for an icon primitive then the style will take
+* care of calling setColor() with the correct color from the theme whenever the theme
+* changes. Typical examples of such widgets are the itemviews (e.g. list, grid). Therefore
+* mono icons shown in such widgets will automatically be colorized with a theme-specific
+* color if the icon is either a mono icon coming from the theme or the icon has the
+* HbIcon::Colorized flag set.
+*
+* \warning Currently this method makes use of pixmap() routine in case of NVG icons.
+* pixmap() slows down the hardware accelerated rendering.
+*
+* \sa HbIcon::color(), HbIcon::Colorized
+*/
+void HbIcon::setColor(const QColor &color)
+{
+if (d->engine) {
+if (color != d->engine->color()) {
+d.detach();
+d->engine->setColor(color);
+}
+}
+}
+/*!
+* brief  Returns the color of the Icon.
+* \sa HbIcon::setColor()
+*/
+QColor HbIcon::color() const
+{
+if (d->engine) {
+return d->engine->color();
+} else {
+return QColor();
+}
+}
+/*!
+* Returns the name of the icon.
+* This icon name is used if there is no name set separately for the specified icon mode and state.
+* \sa HbIcon::setIconName()
+*/
+QString HbIcon::iconName() const
+{
+if (d->engine) {
+return d->engine->iconName();
+} else {
+return QString();
+}
+}
+/*!
+* Sets the name of the icon.
+* This icon name is used if there is no name set separately for the specified icon mode and state.
+* \sa HbIcon::iconName()
+*/
+void HbIcon::setIconName( const QString &iconName )
+{
+if (d->engine && d->engine->iconName() != iconName) {
+d.detach();
+d->engine->setIconName(iconName);
+} else {
+// Icon was earlier copy constructed from QIcon, but now its name is set,
+// so it becomes a 'real' HbIcon.
+d.detach();
+d->engine = new HbIconEngine(iconName);
+d->engine->setSize(d->size);
+// Have to instantiate a temporary QIcon because
+// QIcon's assignment operator shares the engine.
+QIcon temp(d->engine);
+d->qicon = temp;
+}
+}
+/*!
+* Returns the name of the icon in the specified \a mode and \a state.
+* If there is no icon name set for the specified \a mode and \a state,
+* the icon name set without these parameters is returned.
+* \sa HbIcon::setIconName()
+*/
+QString HbIcon::iconName( QIcon::Mode mode, QIcon::State state ) const
+{
+QString ret;
+if (d->engine) {
+ret = d->engine->iconName( mode, state );
+if ( ret.isEmpty() ) {
+ret = d->engine->iconName();
+}
+}
+return ret;
+}
+/*!
+* Sets the name of the icon in the specified \a mode and \a state.
+* \note Passing an empty \a iconName removes the icon name definition specific to
+* the given mode and state.
+* \sa HbIcon::iconName()
+*/
+void HbIcon::setIconName( const QString &iconName, QIcon::Mode mode, QIcon::State state )
+{
+if ( d->engine && d->engine->iconName(mode, state) != iconName) {
+d.detach();
+d->engine->setIconName(iconName, mode, state);
+}
+}
+/*! Paints the icon in the given \a painter with the specified drawing parameters.
+* \note If the constructor HbIcon::HbIcon(const QIcon &icon) is used, the parameter
+* \a aspectRatioMode is ignored and Qt::KeepAspectRatio is used. Also in that case the icon
+* is not scaled exactly to the given size but the best size match returned by the QIcon
+* instance is used.
+*/
+void HbIcon::paint( QPainter *painter,
+const QRectF &rect,
+Qt::AspectRatioMode aspectRatioMode,
+Qt::Alignment alignment,
+QIcon::Mode mode,
+QIcon::State state) const
+{
+if ( !rect.isEmpty() && d.constData() != shared_null ) {
+if ( d->engine ) {
+d->engine->paint( painter, rect, aspectRatioMode, alignment, mode, state );
+} else {
+// This HbIcon was copy constructed from QIcon and
+// we cannot use HbIconEngine for painting.
+QSizeF size = this->size();
+if ( !size.isValid() ) {
+// If size is not set, have to use rect size because QIcon
+// does not provide defaultSize information.
+size = rect.size();
+}
+QPixmap pixmap = d->qicon.pixmap( size.toSize(), mode, state );
+QSizeF pixmapSize = pixmap.size();
+// Adjust the alignment
+QPointF topLeft = rect.topLeft();
+if ( alignment & Qt::AlignRight ) {
+topLeft.setX( rect.right() - pixmapSize.width() );
+} else if ( alignment & Qt::AlignHCenter ) {
+topLeft.setX( topLeft.x() + (rect.width() - pixmapSize.width()) / 2 );
+}
+if ( alignment & Qt::AlignBottom ) {
+topLeft.setY( rect.bottom() - pixmapSize.height() );
+} else if ( alignment & Qt::AlignVCenter ) {
+topLeft.setY( topLeft.y() + (rect.height() - pixmapSize.height()) / 2 );
+}
+painter->drawPixmap( topLeft, pixmap, pixmap.rect() );
+// Draw the badges on this icon
+if ( d->badgeInfo ) {
+d->badgeInfo->paint(painter, rect, mode, state, false);
+}
+}
+}
+}
+/*! Returns the current size of the icon.
+* \sa HbIcon::setSize(), HbIcon::defaultSize()
+*/
+QSizeF HbIcon::size() const
+{
+if ((static_cast<int>(flags()) & HbIcon::ResolutionCorrected)) {
+if (d->size.isValid()) {
+return d->size;
+} else {
+QSizeF defSize(defaultSize());
+HbIconLoader::global()->applyResolutionCorrection(defSize);
+return defSize;
+}
+} else if (d->size.isValid()) {
+return d->size;
+}
+return defaultSize();
+}
+/*! Returns the default size of the icon.
+*/
+QSizeF HbIcon::defaultSize() const
+{
+// Default constructed icon?
+if ( d.constData() == shared_null ) {
+return QSizeF();
+}
+// Do not cache default size in this class,
+// because it may change when icon definitions change.
+else if (d->engine) {
+return d->engine->defaultSize();
+}
+// Constructed from QIcon
+else {
+QList<QSize> sizes = d->qicon.availableSizes();
+if (sizes.count()) {
+return QSizeF(sizes.at(0));
+} else {
+return QSizeF();
+}
+}
+}
+/*! Sets the \a height of the icon. Its width is computed using the aspect ratio of the icon.
+*/
+void HbIcon::setHeight( qreal height )
+{
+QSizeF size = defaultSize();
+if ( size.height() > 0 ) {
+qreal ar = size.width() / size.height();
+setSize( QSizeF( ar * height , height) );
+}
+}
+/*! Sets the \a width of the icon. Its height is computed using the aspect ratio of the icon.
+*/
+void HbIcon::setWidth( qreal width )
+{
+QSizeF size = defaultSize();
+if ( size.width() > 0 ) {
+qreal ar = size.height() / size.width();
+setSize( QSizeF( width, ar * width ) );
+}
+}
+/*! Returns the width of the icon.
+*/
+qreal HbIcon::width() const
+{
+return size().width();
+}
+/*! Returns the height of the icon.
+*/
+qreal HbIcon::height() const
+{
+return size().height();
+}
+/*! Returns the mirroring mode set for the icon.
+* \sa HbIcon::setMirroringMode()
+*/
+HbIcon::MirroringMode HbIcon::mirroringMode() const
+{
+if (d->engine) {
+return d->engine->mirroringMode();
+} else {
+return HbIcon::Default;
+}
+}
+/*! Sets the mirroring \a mode for the icon.
+* \sa HbIcon::mirroringMode()
+*/
+void HbIcon::setMirroringMode( HbIcon::MirroringMode mode )
+{
+if (d->engine) {
+if ( mode != d->engine->mirroringMode() ) {
+d.detach();
+d->engine->setMirroringMode(mode);
+}
+}
+}
+/*! Returns the flags set for the icon.
+*/
+HbIcon::Flags HbIcon::flags() const
+{
+if (d->engine) {
+return d->engine->flags();
+} else {
+return ( HbIcon::Flags )0;
+}
+}
+/*! Sets the flags for the icon.
+*/
+void HbIcon::setFlags(HbIcon::Flags flags)
+{
+if (d->engine) {
+if (flags != d->engine->flags()) {
+d.detach();
+d->engine->setFlags(flags);
+}
+}
+}
+/*! Sets the size for the icon. Without calling this method, the icon uses its default size.
+* \sa HbIcon::size(), HbIcon::defaultSize()
+*/
+void HbIcon::setSize( const QSizeF &size )
+{
+if ( size != d->size ) {
+d.detach();
+d->size = size;
+if (d->engine) {
+d->engine->setSize(size);
+}
+}
+}
+/*!
+* Returns the icon as a QVariant.
+*/
+HbIcon::operator QVariant() const
+{
+return QVariant::fromValue(*this);
+}
+/*!
+* Returns a reference to a QIcon instance representing this icon.
+* \note The returned reference is valid only for the life time of this HbIcon instance.
+*/
+QIcon & HbIcon::qicon() const
+{
+return d->qicon;
+}
+/*!
+* Equality operator. It compares the icon names for all the state and mode combinations.
+* The sizes set for the icons are not used for the comparison.
+*/
+bool HbIcon::operator==( const HbIcon &other ) const
+{
+return !( *this != other );
+}
+/*!
+* Inequality operator. It compares the icon names for all the state and mode combinations.
+* The sizes set for the icons are not used for the comparison.
+*/
+bool HbIcon::operator!=( const HbIcon &other ) const
+{
+// NULL icons are equal
+if ( isNull() && other.isNull() ) {
+if ( d->badgeInfo && other.d->badgeInfo ) {
+if ( d->badgeInfo->badges() != other.d->badgeInfo->badges() ) {
+return true;
+}
+}
+return false;
+}
+const HbIconEngine *engine1 = d->engine;
+const HbIconEngine *engine2 = other.d->engine;
+// If both icons do not have engines, they are unequal.
+// An icon does not have an engine if it is constructed with a QIcon.
+if ( !engine1 || !engine2 ) {
+return true;
+}
+if ( engine1->iconName() != engine2->iconName() ||
+engine1->iconName( QIcon::Normal, QIcon::Off )    != engine2->iconName( QIcon::Normal, QIcon::Off ) ||
+engine1->iconName( QIcon::Normal, QIcon::On )     != engine2->iconName( QIcon::Normal, QIcon::On ) ||
+engine1->iconName( QIcon::Disabled, QIcon::Off )  != engine2->iconName( QIcon::Disabled, QIcon::Off ) ||
+engine1->iconName( QIcon::Disabled, QIcon::On )   != engine2->iconName( QIcon::Disabled, QIcon::On ) ||
+engine1->iconName( QIcon::Active, QIcon::Off )    != engine2->iconName( QIcon::Active, QIcon::Off ) ||
+engine1->iconName( QIcon::Active, QIcon::On )     != engine2->iconName( QIcon::Active, QIcon::On ) ||
+engine1->iconName( QIcon::Selected, QIcon::Off )  != engine2->iconName( QIcon::Selected, QIcon::Off ) ||
+engine1->iconName( QIcon::Selected, QIcon::On )   != engine2->iconName( QIcon::Selected, QIcon::On ) ) {
+return true;
+}
+// If they have different badges, they are unequal
+if ( engine1->badges() != engine2->badges() ) {
+return true;
+}
+if ( engine1->color() != engine2->color() )
+return true;
+else
+return false;
+}
+/*!
+* Adds a badge icon to the existing icon. The badge icons
+* are drawn relative to the alignment you specify with the
+* z-order you provide.
+*/
+bool HbIcon::addBadge( Qt::Alignment alignment,
+const HbIcon& badge,
+int z )
+{
+d.detach();
+return d->addBadge(alignment, badge, z);
+}
+/*!
+* Removes badge icon(s) from the icon.
+*/
+bool HbIcon::removeBadge( const HbIcon& badge )
+{
+d.detach();
+return d->removeBadge( badge );
+}
+/*!
+Remove all badge icons from this icon
+*/
+void HbIcon::removeAllBadges()
+{
+d.detach();
+d->removeAllBadges();
+}
+/*!
+* Externalizes the \a icon information in a data \a stream. It can be transferred to other process and
+* the icon can be reconstructed from the stream there.
+*/
+QDataStream &operator<<(QDataStream &stream, const HbIcon &icon)
+{
+return stream << *icon.d.data();
+}
+/*!
+* Internalizes the \a icon information from a data \a stream and reconstructs the icon.
+* The streamed icon data can be transferred to another process and used from there.
+*/
+QDataStream &operator>>(QDataStream &stream, HbIcon &icon)
+{
+icon.d.detach();
+return stream >> *icon.d.data();
+}
+/*!
+Clears the icon data (e.g. QPixmaps that are stored internally) but does not
+touch the settings, e.g. the size, state, flags, unlike clear().
+The call is simply forwarded to the underlying HbIconEngine. This function
+has no effect when the icon was constructed from a QIcon.
+\internal
+*/
+void HbIconPrivate::clearStoredIconContent()
+{
+if (engine) {
+engine->clearStoredIconContent();
+}
+}

changeset 0	16d8024aca5e
child 1	f7ac710697a9