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

equal deleted inserted replaced

-:730c025d4b77
+:f378acbc9cfb
 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,
+The icon name can be either a logical icon name that is fetched from the theme
-it is searched in the icon locations of the theming framework.
+or an absolute filename. Logical icon names should not include a filename extension.
-An absolute icon filename can point e.g. in application's resource file.
+An absolute icon filename must include full path and filename extension.
 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.
 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 }
 */
 \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 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()) ),
+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 ) :
+HbIconPrivate::HbIconPrivate(const QIcon &qicon) :
 engine(0),
 qicon(qicon),
 badgeInfo(0)
 {
 }
 /*!
 \internal
 */
-HbIconPrivate::HbIconPrivate( const QString &iconName ) :
+HbIconPrivate::HbIconPrivate(const QString &iconName) :
-engine( new HbIconEngine(iconName) ),
+engine(new HbIconEngine(iconName)),
 qicon(engine),
 badgeInfo(0)
 {
 }
 /*!
 \internal
 */
-HbIconPrivate::HbIconPrivate( const HbIconPrivate &other ) :
+HbIconPrivate::HbIconPrivate(const HbIconPrivate &other) :
-QSharedData( other ),
+QSharedData(other),
-size( other.size ),
+size(other.size),
 engine(0),
 qicon(),
 badgeInfo(0)
 {
-if ( other.engine ) {
+if (other.engine) {
-engine = new HbIconEngine( *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 ) {
+if (other.badgeInfo) {
 badgeInfo = new HbBadgeIcon(*other.badgeInfo);
 }
 }
 }
 /*!
 \internal
 /*!
 \internal
 */
 void HbIconPrivate::removeAllBadges()
 {
-if ( engine ) {
+if (engine) {
 engine->removeAllBadges();
-} else if ( badgeInfo ) {
+} else if (badgeInfo) {
 badgeInfo->removeAllBadges();
 }
 }
 /*!
 \internal
 */
 bool HbIconPrivate::isBadged() const
 {
-if ( engine ) {
+if (engine) {
 return engine->isBadged();
-} else if ( badgeInfo ) {
+} else if (badgeInfo) {
 return badgeInfo->isBadged();
 }
 return false;
+}
+/*!
+\internal
+*/
+void HbIconPrivate::setThemedColor(const QColor &color)
+{
+if (engine && color != engine->themedColor()) {
+engine->setThemedColor(color);
+}
+}
+/*!
+\internal
+*/
+QColor HbIconPrivate::themedColor() const
+{
+return engine ? engine->themedColor() : QColor();
 }
 /*!
 \internal
 */
 /*!
 \internal
 */
 bool HbIconPrivate::addBadge(Qt::Alignment align,
-const HbIcon& icon,
+const HbIcon &icon,
-int z)
+int z,
-{
+const QSizeF &sizeFactor,
-if ( icon.isBadged() ) {
+Qt::AspectRatioMode aspectRatio)
+{
+if (icon.isBadged()) {
 return false;
-} else if ( engine ) {
+} else if (engine) {
-engine->addBadge(align, icon, z);
+engine->addBadge(align, icon, z, sizeFactor, aspectRatio);
 } else {
-if ( !badgeInfo ) {
+if (!badgeInfo) {
 badgeInfo = new HbBadgeIcon();
 }
-badgeInfo->addBadge(align, icon, z);
+badgeInfo->addBadge(align, icon, z, sizeFactor, aspectRatio);
 }
 return true;
 }
 /*!
 \internal
 */
-bool HbIconPrivate::removeBadge(const HbIcon& badge)
+bool HbIconPrivate::removeBadge(const HbIcon &badge)
 {
 bool result = false;
-if ( engine ) {
+if (engine) {
 result = engine->removeBadge(badge);
-} else if ( badgeInfo ) {
+} else if (badgeInfo) {
 result = badgeInfo->removeBadge(badge);
 }
 return result;
 }
 * by calling HbIcon::setIconName.
 */
 HbIcon::HbIcon()
 {
 // Construct shared_null if not done yet.
-if ( !shared_null ) {
+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 )
+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::defaultSize() may return QSizeF().
 * - HbIcon::paint() ignores the parameter aspectRatioMode and converts the given QRectF to QRect.
 * - HbIcon::iconName() returns empty string by default.
 * - HbIcon::pixmap() returns null pixmap.
 * - Colorization and mirroring support are not available.
-* This method should only be used if absolute necessary, as this is not ideal for hardware accelerated environment.
+* This method should only be used if absolute necessary, as this is not ideal for hardware accelerated environment
-*/
+* and there may be huge differences in painting performance when compared to a native HbIcon.
-HbIcon::HbIcon( const QIcon &icon )
+*/
+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 ) :
+HbIcon::HbIcon(const HbIcon &other) :
-d( other.d )
+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 )
+HbIcon &HbIcon::operator=(const HbIcon &other)
 {
-if ( &other != this ) {
+if (&other != this) {
 d = other.d;
 }
 return *this;
 }
 * 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 ) {
+if (d.constData() != shared_null) {
 d.detach();
 d->clear();
 }
 }
 * 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 d->engine->pixmap(d->size.toSize(), QIcon::Normal, QIcon::Off);
 }
 return QPixmap();
 }
 *
 * 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
+* Note that if a widget defines a color for its icon primitive (as most standard
-* care of calling setColor() with the correct color from the theme whenever the theme
+* widgets do) then the style will take care of colorizing with the correct color
-* changes. Typical examples of such widgets are the itemviews (e.g. list, grid). Therefore
+* from the theme whenever the theme changes. Therefore mono icons shown in such
-* mono icons shown in such widgets will automatically be colorized with a theme-specific
+* widgets will automatically be colorized with a theme-specific color if the
-* color if the icon is either a mono icon coming from the theme or the icon has 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.
+* However it is possible to override this theme-specific color with a custom one
-* pixmap() slows down the hardware accelerated rendering.
+* by calling this function.
 *
+* \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) {
 return QString();
 }
 }
 /*!
-* Sets the name of the icon.
+* Sets the name of the icon. It can be either a logical icon name that is fetched from the theme
+* or an absolute filename. Logical icon names should not include a filename extension.
 * 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 )
+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 HbIcon::iconName(QIcon::Mode mode, QIcon::State state) const
 {
 QString ret;
 if (d->engine) {
-ret = d->engine->iconName( mode, state );
+ret = d->engine->iconName(mode, state);
-if ( ret.isEmpty() ) {
+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 )
+void HbIcon::setIconName(const QString &iconName, QIcon::Mode mode, QIcon::State state)
 {
-if ( d->engine && d->engine->iconName(mode, state) != iconName) {
+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,
+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 (!rect.isEmpty() && d.constData() != shared_null) {
-if ( d->engine ) {
+if (d->engine) {
-d->engine->paint( painter, rect, aspectRatioMode, alignment, mode, state );
+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.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 );
+QPixmap pixmap = d->qicon.pixmap(size.toSize(), mode, state);
 QSizeF pixmapSize = pixmap.size();
+// QIcon::pixmap() will not do upscaling.
+if (pixmapSize.width() < size.width() || pixmapSize.height() < size.height()) {
+// Native HbIcons are scaled using SmoothTransformation so use the same.
+pixmap = pixmap.scaled(size.toSize(), aspectRatioMode, Qt::SmoothTransformation);
+pixmapSize = pixmap.size();
+}
 // Adjust the alignment
 QPointF topLeft = rect.topLeft();
-if ( alignment & Qt::AlignRight ) {
+if (alignment & Qt::AlignRight) {
-topLeft.setX( rect.right() - pixmapSize.width() );
+topLeft.setX(rect.right() - pixmapSize.width());
-} else if ( alignment & Qt::AlignHCenter ) {
+} else if (alignment & Qt::AlignHCenter) {
-topLeft.setX( topLeft.x() + (rect.width() - pixmapSize.width()) / 2 );
+topLeft.setX(topLeft.x() + (rect.width() - pixmapSize.width()) / 2);
 }
-if ( alignment & Qt::AlignBottom ) {
+if (alignment & Qt::AlignBottom) {
-topLeft.setY( rect.bottom() - pixmapSize.height() );
+topLeft.setY(rect.bottom() - pixmapSize.height());
-} else if ( alignment & Qt::AlignVCenter ) {
+} else if (alignment & Qt::AlignVCenter) {
-topLeft.setY( topLeft.y() + (rect.height() - pixmapSize.height()) / 2 );
+topLeft.setY(topLeft.y() + (rect.height() - pixmapSize.height()) / 2);
 }
-painter->drawPixmap( topLeft, pixmap, pixmap.rect() );
+painter->drawPixmap(topLeft, pixmap, pixmap.rect());
 // Draw the badges on this icon
-if ( d->badgeInfo ) {
+if (d->badgeInfo) {
 d->badgeInfo->paint(painter, rect, mode, state, false);
 }
 }
 }
 }
 * \sa HbIcon::setSize(), HbIcon::defaultSize()
 */
 QSizeF HbIcon::size() const
 {
 if ((static_cast<int>(flags()) & HbIcon::ResolutionCorrected)) {
+if (d->engine) {
+d->size = d->engine->size();
+}
 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 ) {
+if (d.constData() == shared_null) {
 return QSizeF();
 }
 // Do not cache default size in this class,
 // because it may change when icon definitions change.
 }
 }
 /*! Sets the \a height of the icon. Its width is computed using the aspect ratio of the icon.
 */
-void HbIcon::setHeight( qreal height )
+void HbIcon::setHeight(qreal height)
 {
 QSizeF size = defaultSize();
-if ( size.height() > 0 ) {
+if (size.height() > 0) {
 qreal ar = size.width() / size.height();
-setSize( QSizeF( ar * height , 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 )
+void HbIcon::setWidth(qreal width)
 {
 QSizeF size = defaultSize();
-if ( size.width() > 0 ) {
+if (size.width() > 0) {
 qreal ar = size.height() / size.width();
-setSize( QSizeF( width, ar * 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.
 }
 /*! Sets the mirroring \a mode for the icon.
 * \sa HbIcon::mirroringMode()
 */
-void HbIcon::setMirroringMode( HbIcon::MirroringMode mode )
+void HbIcon::setMirroringMode(HbIcon::MirroringMode mode)
 {
 if (d->engine) {
-if ( mode != d->engine->mirroringMode() ) {
+if (mode != d->engine->mirroringMode()) {
 d.detach();
 d->engine->setMirroringMode(mode);
 }
 }
 }
 HbIcon::Flags HbIcon::flags() const
 {
 if (d->engine) {
 return d->engine->flags();
 } else {
-return ( HbIcon::Flags )0;
+return (HbIcon::Flags)0;
 }
 }
 /*! Sets the flags for the icon.
 */
 }
 /*! 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 )
+void HbIcon::setSize(const QSizeF &size)
 {
-if ( size != d->size ) {
+if (size != d->size) {
 d.detach();
 d->size = size;
 if (d->engine) {
 d->engine->setSize(size);
 /*!
 * 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
+QIcon &HbIcon::qicon() const
 {
 return d->qicon;
 }
 /*!
 * Equality operator. It compares the icon names for all the state and mode combinations.
 * It also compares the badges, the color and the mirroring mode of the icon. The sizes
 * set for the icons are not used for the comparison.
 */
-bool HbIcon::operator==( const HbIcon &other ) const
+bool HbIcon::operator==(const HbIcon &other) const
 {
-return !( *this != other );
+return !(*this != other);
 }
 /*!
 * Inequality operator. It compares the icon names for all the state and mode combinations.
 * It also compares the badges, the color and the mirroring mode of the icon. The sizes
 * set for the icons are not used for the comparison.
 */
-bool HbIcon::operator!=( const HbIcon &other ) const
+bool HbIcon::operator!=(const HbIcon &other) const
 {
 // NULL icons are equal
-if ( isNull() && other.isNull() ) {
+if (isNull() && other.isNull()) {
-if ( d->badgeInfo && other.d->badgeInfo ) {
+if (d->badgeInfo && other.d->badgeInfo) {
-if ( d->badgeInfo->badges() != other.d->badgeInfo->badges() ) {
+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 ) {
+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 (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() ) {
+if (engine1->badges() != engine2->badges()) {
 return true;
 }
-if ( engine1->color() != engine2->color() ){
+if (engine1->color() != engine2->color()) {
 return true;
 }
 // two icons are considered different if their mirroring modes are different
-if ( engine1->mirroringMode() != engine2->mirroringMode() ){
+if (engine1->mirroringMode() != engine2->mirroringMode()) {
 return true;
 }
 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.
+*
+* By default the badge icon will use its default size.  If this is
+* not suitable (which is typical in case of vector graphics) then
+* call setSize() explicitly on \a badge before passing it to this
+* function.
+*
+* The aspect ratio for the badge is kept by default, but this can be
+* changed in the \a aspectRatio argument.
+*
+* \sa addProportionalBadge()
 */
-bool HbIcon::addBadge( Qt::Alignment alignment,
+bool HbIcon::addBadge(Qt::Alignment alignment,
-const HbIcon& badge,
+const HbIcon &badge,
-int z )
+int z,
+Qt::AspectRatioMode aspectRatio)
 {
 d.detach();
-return d->addBadge(alignment, badge, z);
+return d->addBadge(alignment, badge, z, QSizeF(), aspectRatio);
+}
+/*!
+* 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.
+*
+* With this function the size of the badge icon will be proportional
+* to the size of the badged icon.  If the size needs to be explicitly
+* specified then use addBadge() instead.
+*
+* \a sizeFactor's x and y values must be between 0 and 1. They
+* specify how much space the badge takes. For example (0.25, 0.25)
+* causes both the width and height to be 1/4 of the full icon width
+* and height.
+*
+* The aspect ratio for the badge is kept by default, but this can be
+* changed in the \a aspectRatio argument.
+*
+* \sa addBadge()
+*/
+bool HbIcon::addProportionalBadge(Qt::Alignment alignment,
+const HbIcon &badge,
+const QSizeF &sizeFactor,
+int z,
+Qt::AspectRatioMode aspectRatio)
+{
+d.detach();
+return d->addBadge(alignment, badge, z, sizeFactor, aspectRatio);
 }
 /*!
 * Removes badge icon(s) from the icon.
 */
-bool HbIcon::removeBadge( const HbIcon& badge )
+bool HbIcon::removeBadge(const HbIcon &badge)
 {
 d.detach();
-return d->removeBadge( badge );
+return d->removeBadge(badge);
 }
 /*!
 Remove all badge icons from this icon
 */

branch	GCC_SURGE
changeset 15	f378acbc9cfb
parent 7	923ff622b8b9
child 21	4633027730f5
child 34	ed14f46c0e55