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

equal deleted inserted replaced

-:730c025d4b77
+:f378acbc9cfb
 #include "hblayoutdirectionnotifier_p.h"
 #include "hbiconanimation_p.h"
 #include "hbimagetraces_p.h"
 #include "hbiconimpl_p.h"
 #include "hbpixmapiconimpl_p.h"
+#include "hbbadgeicon_p.h"
 #include <hbinstance.h>
 #include <hbiconanimator.h>
 #include <hbiconanimator_p.h>
-#include "hbbadgeicon_p.h"
 #include <QObject>
 #include <QPainter>
 #include <QDebug>
 void appendLoadFail(QIcon::Mode mode, QIcon::State state);
 void removeLoadFail(QIcon::Mode mode, QIcon::State state);
 void unLoadIcon(bool unloadedByServer = false);
 void addBadge(Qt::Alignment alignment,
-const HbIcon& badge,
+const HbIcon &badge,
-int z=0);
+int z,
-bool removeBadge(const HbIcon& badge);
+const QSizeF &sizeFactor,
+Qt::AspectRatioMode aspectRatio);
+bool removeBadge(const HbIcon &badge);
 void removeAllBadges();
 const QList<HbBadgeIconInfo> badges() const;
 bool isBadged() const;
+QColor colorToUse(const QString &iconName) const;
 public:
 QSizeF size;
-struct IconName
+struct IconName {
-{
 QIcon::Mode mode;
 QIcon::State state;
 QString name;
 };
 QVector<int> loadFailed;
 HbIcon::Flags flags;
 HbIcon::MirroringMode mirroringMode;
-enum DefaultMirroring
+enum DefaultMirroring {
-{
 Unknown = 0,
 Enabled = 1,
 Disabled = 2
 };
 DefaultMirroring defaultMirroring;
 // If this pointer is 0, animations are not used.
 HbIconAnimator *animator;
 // Variables introduced for handling colorizable icons
 QColor color;
+// The color coming from the color group associated with a widget in its css.
+QColor themedColor;
 //Icon Implementation interface which provides abstraction for the type of icon ( Pixmap, NVG, SgImage etc).
 // Each class derived from HbIconImpl will have to implement the paint(), pixmap() and defaultSize() API
 HbIconImpl *icon;
 // Icons decorating this engine
 };
 // Class HbIconEnginePrivate
 HbIconEnginePrivate::HbIconEnginePrivate(const QString &iconName) :
-size(),
-iconNames(),
-pixmap(),
 aspectRatioMode(Qt::KeepAspectRatio),
 mode(QIcon::Normal),
 state(QIcon::Off),
-defaultSize(),
 defaultSizeFailed(false),
 loadFailed(0),
 flags(0),
 mirroringMode(HbIcon::Default),
 defaultMirroring(Unknown),
 animator(0),
-color(QColor()),
 icon(0),
 badgeInfo(0),
 signalConnectionsSet(false),
 iconType(INVALID_FORMAT)
 {
 }
 HbIconEnginePrivate::HbIconEnginePrivate(const HbIconEnginePrivate &other) :
 size(other.size),
 iconNames(other.iconNames),
-// Pixmap is cleared if other object uses animation
+pixmap(other.animator ? QPixmap() : other.pixmap), // Pixmap is cleared if other object uses animation.
-pixmap(other.animator ? QPixmap() : other.pixmap),
 aspectRatioMode(other.aspectRatioMode),
 mode(other.mode),
 state(other.state),
 defaultSize(other.defaultSize),
 defaultSizeFailed(other.defaultSizeFailed),
 loadFailed(other.loadFailed),
 flags(other.flags),
 mirroringMode(other.mirroringMode),
 defaultMirroring(other.defaultMirroring),
-// Animator is instance specific and not copied
+animator(0), // Animator is instance specific and not copied.
-animator(0),
+color(other.color), // No copy for themedColor, that one is an internal, instance-specific setting.
-color(other.color),
+icon(0),  // HbIconImpl is instance specific, it is recreated when icon is painted.
-// HbIconImpl is instance specific, it is recreated when icon is painted
-icon(0),
 badgeInfo(0),
 signalConnectionsSet(false),
 iconType(INVALID_FORMAT)
 {
 if (other.badgeInfo) {
 *badgeInfo = *other.badgeInfo;
 }
 }
 HbIconEnginePrivate::HbIconEnginePrivate(QDataStream &stream) :
-size(),
-iconNames(),
-pixmap(),
 aspectRatioMode(Qt::KeepAspectRatio),
 mode(QIcon::Normal),
 state(QIcon::Off),
-defaultSize(),
 defaultSizeFailed(false),
 loadFailed(0),
 flags(0),
 mirroringMode(HbIcon::Default),
 defaultMirroring(Unknown),
 animator(0),
-color(QColor()),
 icon(0),
 badgeInfo(new HbBadgeIcon),
 signalConnectionsSet(false),
 iconType(INVALID_FORMAT)
 {
 stream >> temp;
 mirroringMode = (HbIcon::MirroringMode)temp;
 stream >> temp;
 defaultMirroring = (HbIconEnginePrivate::DefaultMirroring)temp;
 stream >> color;
+// Do not store themedColor, see the copy ctor.
 badgeInfo->internalize(stream);
 }
 void HbIconEnginePrivate::externalize(QDataStream &stream)
 {
 // Externalize parameters that are needed to reconstruct the icon
 stream << size;
 stream << iconNames.count();
-Q_FOREACH(const IconName &name, iconNames) {
+Q_FOREACH(const IconName & name, iconNames) {
 stream << (qint32)(name.mode);
 stream << (qint32)(name.state);
 stream << name.name;
 }
 stream << (qint32)flags;
 delete badgeInfo;
 }
 /*!
 \internal
 Initiates an IPC call to the ThemeServer to unload ( decrement ref count )
 the icon if created on server side.
 */
 void HbIconEnginePrivate::unLoadIcon(bool unloadedByServer)
 {
 if (icon) {
 HbIconLoader *loader = HbIconLoader::global();
 flags = 0;
 mirroringMode = HbIcon::Default;
 defaultMirroring = Unknown;
 animator = 0;
 color = QColor();
+themedColor = QColor();
 unLoadIcon();
 if (badgeInfo) {
 badgeInfo->removeAllBadges();
 }
 }
 {
 // If mirroring mode is default, check automatic mirroring from loader.
 if (mirroringMode == HbIcon::Default && defaultMirroring == Unknown) {
 HbIconLoader *loader = HbIconLoader::global();
 defaultMirroring = loader->isAutomaticallyMirrored(
 iconName(QIcon::Normal, QIcon::Off)) ? Enabled : Disabled;
 }
 bool basedOnLayoutDir = false;
 // Handle the different mirroring modes
 if (defaultMirroring == Enabled) {
 basedOnLayoutDir = true;
 } else if (defaultMirroring == Disabled) {
 return false;
 }
 // Forced
 } else if (mirroringMode == HbIcon::Forced) {
 return true;
 // Prevented
 } else if (mirroringMode == HbIcon::Prevented) {
 return false;
 // LayoutDirection
 } else if (mirroringMode == HbIcon::LayoutDirection) {
 basedOnLayoutDir = true;
 }
 if (basedOnLayoutDir) {
 // e.g. some unit tests do not have primary window at this point so need to do NULL checks here.
 if (hbInstance) {
-QList<HbMainWindow*> allWindows = hbInstance->allMainWindows();
+QList<HbMainWindow *> allWindows = hbInstance->allMainWindows();
-if ( !allWindows.isEmpty() &&
+if (!allWindows.isEmpty() &&
 allWindows.value(0) &&
 allWindows.value(0)->layoutDirection() == Qt::RightToLeft) {
 return true;
 }
 return false;
 }
 }
 QString HbIconEnginePrivate::iconName(QIcon::Mode mode, QIcon::State state) const
 {
 QString ret;
-Q_FOREACH(const HbIconEnginePrivate::IconName &name, iconNames) {
+Q_FOREACH(const HbIconEnginePrivate::IconName & name, iconNames) {
 if (name.mode == mode && name.state == state) {
 ret = name.name;
 break;
 }
 }
 inline bool isMonoIcon(const QString &name)
 {
 // Even when the Colorized flag is not set certain icons from the theme must be
 // colorized. These mono icons are recognized from their name. The check should not be
 // done for normal files, only for logical theme graphics names.
-return name.startsWith("qtg_mono_") && !name.contains('.');
+return name.startsWith(QLatin1String("qtg_mono_")) && !name.contains('.');
+}
+QColor HbIconEnginePrivate::colorToUse(const QString &iconName) const
+{
+if (flags.testFlag(HbIcon::Colorized) || isMonoIcon(iconName)) {
+return color.isValid() ? color : themedColor;
+} else {
+return QColor();
+}
 }
 void HbIconEnginePrivate::addBadge(Qt::Alignment align,
-const HbIcon& icon,
+const HbIcon &icon,
-int z)
+int z,
+const QSizeF &sizeFactor,
+Qt::AspectRatioMode aspectRatio)
 {
 if (!badgeInfo) {
 badgeInfo = new HbBadgeIcon();
 }
-badgeInfo->addBadge(align, icon, z);
+badgeInfo->addBadge(align, icon, z, sizeFactor, aspectRatio);
 }
-bool HbIconEnginePrivate::removeBadge(const HbIcon& badge)
+bool HbIconEnginePrivate::removeBadge(const HbIcon &badge)
 {
 return badgeInfo ? badgeInfo->removeBadge(badge) : false;
 }
 void HbIconEnginePrivate::removeAllBadges()
 QIconEngineV2(),
 d(new HbIconEnginePrivate(QString()))
 {
 // Register the HbIconEngine Instance to HbIconLoader
 HbIconLoader *loader = HbIconLoader::global();
 loader->storeIconEngineInfo(this);
 }
 HbIconEngine::HbIconEngine(const QString &iconName) :
 QObject(),
 QIconEngineV2(),
 d(new HbIconEnginePrivate(iconName))
 {
 // Register the HbIconEngine Instance to HbIconLoader
 HbIconLoader *loader = HbIconLoader::global();
 loader->storeIconEngineInfo(this);
 }
 HbIconEngine::HbIconEngine(const HbIconEngine &other) :
 QObject(),
 {
 if (d->mirroringMode != mode) {
 // Mirroring changed, clear stored icon content
 clearStoredIconContent();
 }
 d->mirroringMode = mode;
 }
 QSize HbIconEngine::actualSize(const QSize &size, QIcon::Mode mode, QIcon::State state)
 {
 }
 // If size has not been defined, use icon's default size.
 if (!s.isValid()) {
 // With size (0,0), loader uses the icon's default size.
-s = QSize(0,0);
+s = QSize(0, 0);
 }
 QIcon::Mode modeForLoader = mode;
 QString name = iconName(mode, state);
 if (!name.isEmpty()) {
 HbIconLoader *loader = HbIconLoader::global();
 // If requested size is not the same as set in the engine, get a new pixmap from loader
 if (pixelSize != size().toSize()) {
 // Clear the old icon first
 d->unLoadIcon();
 d->icon = loader->loadIcon(
 name,
 HbIconLoader::AnyType,
 HbIconLoader::AnyPurpose,
 s,
 Qt::KeepAspectRatio,
 modeForLoader,
 d->iconLoaderOptions(),
 0,
-(d->flags.testFlag(HbIcon::Colorized) || isMonoIcon(name)) ? d->color : QColor());
+d->colorToUse(name));
-if (d->icon){
+if (d->icon) {
 // Draw badges on this pixmap
 QPainter painter(&d->pixmap);
 if (d->badgeInfo) {
 d->badgeInfo->paint(&painter, QRectF(QPointF(0, 0), pixelSize), mode, state, d->isMirrored());
 }
 d->pixmap = d->icon->pixmap();
 return d->pixmap;
 }
 }
 // Requested size was same as set in engine, use the pixmap stored in engine
 else {
 if (!d->icon || Qt::KeepAspectRatio != d->aspectRatioMode || mode != d->mode || state != d->state) {
 d->aspectRatioMode = Qt::KeepAspectRatio;
 d->mode = mode;
 d->state = state;
 // Clear the old icon first
 d->unLoadIcon();
 d->icon  = loader->loadIcon(
 name,
 HbIconLoader::AnyType,
 HbIconLoader::AnyPurpose,
 s,
 Qt::KeepAspectRatio,
 modeForLoader,
 d->iconLoaderOptions(),
 0,
-(d->flags.testFlag(HbIcon::Colorized) || isMonoIcon(name)) ? d->color : QColor());
+d->colorToUse(name));
 // If loading failed, store information so it is not retried.
 if (!d->icon) {
 d->appendLoadFail(mode, state);
 }
 }
 if (d->icon) {
 d->pixmap = d->icon->pixmap();
 // Draw badges on this pixmap
 QPainter painter(&d->pixmap);
-if (d->badgeInfo){
+if (d->badgeInfo) {
 d->badgeInfo->paint(&painter, QRectF(QPointF(0, 0), pixelSize), mode, state, d->isMirrored());
 }
 return d->pixmap;
 }
 }
 QColor HbIconEngine::color() const
 {
 return d->color;
 }
+void HbIconEngine::setThemedColor(const QColor &color)
+{
+if (d->themedColor != color) {
+clearStoredIconContent();
+d->themedColor = color;
+}
+}
+QColor HbIconEngine::themedColor() const
+{
+return d->themedColor;
+}
 QSizeF HbIconEngine::defaultSize() const
 {
 QString name = iconName();
 if (!d->defaultSizeFailed && !d->defaultSize.isValid() && !name.isEmpty()) {
-if (d->icon){
+if (d->icon) {
 d->defaultSize = d->icon->defaultSize();
 } else {
 HbIconLoader *loader = HbIconLoader::global();
 d->defaultSize = loader->defaultSize(name, QString(), d->iconLoaderOptions());
+if (d->flags & HbIcon::ResolutionCorrected) {
+HbIconLoader::global()->applyResolutionCorrection(d->defaultSize);
+}
 }
 // If default size could not get retrieved,
 // store information about that so it does not need to be checked again.
 if (!d->defaultSize.isValid()) {
 d->defaultSizeFailed = true;
 void HbIconEngine::setSize(const QSizeF &size)
 {
 if (size != d->size) {
 d->size = size;
+// Update default size if size is set before painting
+// to obtain the actual default size of the image
+if (!d->icon && !d->defaultSize.isValid()) {
+defaultSize();
+}
 // Size changed, invalidate pixmap stored in this object.
-clearStoredIconContent();
+clearStoredIconContent(KeepDefaultSize);
 }
 }
-void HbIconEngine::paint( QPainter *painter,
+void HbIconEngine::paint(QPainter *painter,
 const QRect &rect,
 QIcon::Mode mode,
-QIcon::State state )
+QIcon::State state)
 {
 // This method is called by QIcon and it should paint the icon with the size defined by 'rect'.
-HbIconImpl* icon =  NULL;
+HbIconImpl *icon = 0;
 // update the rendering mode
-HbIconLoader::global()->updateRenderingMode(painter->paintEngine()->type());
+QPaintEngine *paintEngine = painter->paintEngine();
+if (paintEngine) {
+HbIconLoader::global()->updateRenderingMode(paintEngine->type());
+}
 icon = paintHelper(rect.size(), Qt::KeepAspectRatio, mode, state);
-if (icon){
+if (icon) {
 icon->paint(painter, rect, Qt::AlignCenter);
 HbIconLoader::global()->unLoadIcon(icon);
 icon->dispose();
-}
+// Now paint any necessary badges.
-// Now paint any necessary badges.
+if (d->badgeInfo) {
-if (d->badgeInfo) {
+d->badgeInfo->paint(painter, rect, mode, state, icon->isMirrored());
-d->badgeInfo->paint(painter, rect, mode, state, icon->isMirrored());
+}
 }
 }
-void HbIconEngine::paint( QPainter *painter,
+void HbIconEngine::paint(QPainter *painter,
 const QRectF &rect,
 Qt::AspectRatioMode aspectRatioMode,
 Qt::Alignment alignment,
 QIcon::Mode mode,
 QIcon::State state)
 {
 // If loading the pixmap has failed, do not retry forever
 if (loadFailed(mode, state)) {
 return;
 }
 }
 // FrameSet animations need to be reloaded if size related parameters have changed,
 // so delete the current animation in that case.
 HbIconAnimation *anim = animation();
 if (anim && anim->type() == HbIconAnimation::FrameSet) {
-if ( ( (!s.isEmpty() || !anim->size().isEmpty()) && s != anim->size() ) ||
+if (((!s.isEmpty() || !anim->size().isEmpty()) && s != anim->size()) ||
 aspectRatioMode != anim->aspectRatioMode()) {
 #ifdef HB_ICON_TRACES
 qDebug("HbIconEngine: deleting anim");
 #endif
 delete anim;
 d->animator->d->animation = 0;
 }
 // If size has not been defined, use icon's default size.
 if (!s.isValid()) {
 // With size (0,0), loader uses the icon's default size.
-s = QSizeF(0,0);
+s = QSizeF(0, 0);
 }
 // If pixmap has not been loaded yet or parameters affecting to pixmap have changed,
 // load the pixmap using paintHelper.
 if ((!d->icon) || aspectRatioMode != d->aspectRatioMode || mode != d->mode || state != d->state) {
 d->mode = mode;
 d->state = state;
 // If icon parameters changed unload the icon first, and get the new icon
 d->unLoadIcon();
 // Update the rendering mode
-HbIconLoader::global()->updateRenderingMode(painter->paintEngine()->type());
+QPaintEngine *paintEngine = painter->paintEngine();
+if (paintEngine) {
+HbIconLoader::global()->updateRenderingMode(paintEngine->type());
+}
 d->icon = paintHelper(s, aspectRatioMode, mode, state);
-if ( d->icon && d->icon->isCreatedOnServer() ) {
+if (d->icon && d->icon->isCreatedOnServer()) {
 d->iconType = d->icon->iconData().type;
 }
 }
 // Adjust the alignment and draw the icon.
 }
 void HbIconEngine::setAnimator(HbIconAnimator *animator)
 {
 d->animator = animator;
 // Reconnect animation signals
 HbIconAnimation *anim = animation();
 if (anim) {
 disconnect(anim); // To make sure we don't get multiple signals
 connect(anim, SIGNAL(animationUpdated()), this, SLOT(handleAnimationUpdated()));
 connect(anim, SIGNAL(animationStopped()), this, SLOT(handleAnimationStopped()));
 connect(anim, SIGNAL(animationFinished()), this, SLOT(handleAnimationFinished()));
 }
 }
-HbIconImpl* HbIconEngine::paintHelper(
+HbIconImpl *HbIconEngine::paintHelper(
 const QSizeF &size,
 Qt::AspectRatioMode aspectRatioMode,
 QIcon::Mode mode,
 QIcon::State state)
 {
 // set afterwards (after construction but before the first paint).
 ensureSignalConnections();
 QString name = iconName(mode, state);
 QIcon::Mode modeForLoader = mode;
-HbIconImpl *icon = NULL;
+HbIconImpl *icon = 0;
 if (name.isEmpty()) {
 // Icon name not defined for this mode and state, use default icon name
 name = iconName(QIcon::Normal, QIcon::Off);
 } else {
 // Icon name was defined for this mode and state, do not apply mode in loader
 else {
 if (!name.isEmpty()) {
 HbIconLoader *loader = HbIconLoader::global();
 icon = loader->loadIcon(
 name,
 HbIconLoader::AnyType,
 HbIconLoader::AnyPurpose,
 size,
 aspectRatioMode,
 modeForLoader,
 d->iconLoaderOptions(),
 d->animator,
-(d->flags.testFlag(HbIcon::Colorized) || isMonoIcon(name)) ? d->color : QColor());
+d->colorToUse(name));
 // If loading failed, store information so it is not retried in every repaint.
 if (!icon) {
 d->appendLoadFail(mode, state);
 }
 but does not touch the settings, e.g. the size, state, flags, unlike clear().
 This function is called when some parameters change so that the content has
 to be reloaded, and in low-graphics-memory situations to get rid of all
 cached image data for the icon.
 The goal in the OOGM case is to destroy all unnecessary QPixmaps which will in turn
 lead to freeing graphics memory (in case we are running on the OpenVG paint engine).
 The data will be reloaded (well, at least tried to be reloaded) when the icon is
 painted the next time.
 */
-void HbIconEngine::clearStoredIconContent(bool resetIconSize, bool unloadedByServer)
+void HbIconEngine::clearStoredIconContent(ClearingFlags flags)
 {
 #ifdef HB_ICON_TRACES
 qDebug("HbIconEngine %x: clearStoredIconContent", (int) this);
 #endif
 d->pixmap = QPixmap();
-d->unLoadIcon(unloadedByServer);
+d->unLoadIcon(flags.testFlag(UnloadedByServer));
-d->defaultSize = QSizeF();
+if (!(flags.testFlag(KeepDefaultSize))) {
-if (resetIconSize) {
+d->defaultSize = QSizeF();
+}
+if (flags.testFlag(ResetIconSize)) {
 d->size = QSizeF();
 }
 d->defaultSizeFailed = false;
 d->loadFailed.clear();
 void HbIconEngine::themeChange(const QStringList &updatedFiles)
 {
 // Theme has changed, clear stored icon content
 // Server side icon cache is already cleared when theme is changed
-if (updatedFiles.count() == 0 || (d->icon && updatedFiles.contains(d->icon->iconFileName())) ) {
+if (updatedFiles.count() == 0 || (d->icon && updatedFiles.contains(d->icon->iconFileName()))) {
-clearStoredIconContent(false, true);
+clearStoredIconContent(UnloadedByServer);
 }
 }
 void HbIconEngine::handleLayoutDirectionChanged()
 {
 if ((d->mirroringMode == HbIcon::Default && d->defaultMirroring == HbIconEnginePrivate::Enabled) ||
 d->mirroringMode == HbIcon::LayoutDirection) {
 // This icon is automatically mirrored based on layout direction.
 // Clear the stored icon content and its default size because the layout direction just changed.
 // Lazy loading is used, new pixmap will be rasterized when it's required by paint method.
 clearStoredIconContent();
 void HbIconEngine::handleDefaultSizeAdjustmentChanged()
 {
 if (d->flags.testFlag(HbIcon::ResolutionCorrected)) {
 // Icon content not valid any more - clear it.
-clearStoredIconContent(true);
+clearStoredIconContent(ResetIconSize);
 }
 }
 void HbIconEngine::handleAnimationUpdated()
 {
 if (anim) {
 // Update parameters in animation
 anim->setSize(size());
 anim->setAspectRatioMode(d->aspectRatioMode);
 anim->setMode(d->mode);
 // Get the current frame as pixmap from the animation
 return anim->currentFrame();
 } else {
 return QPixmap();
 }
 }
 /*!
 * Removes the item in the cache if the ref. count is 0 and does delete on
 * HbIconImpl and Resets the IconImpl.
 */
 void HbIconEngine::resetIconImpl() const
 {
 #if defined(HB_SGIMAGE_ICON) || defined(HB_NVG_CS_ICON)
-if ( (d->iconType == SGIMAGE) || (d->iconType == NVG) ) {
+if ((d->iconType == SGIMAGE) || (d->iconType == NVG)) {
-if ( d->icon ) {
+if (d->icon) {
 d->icon->decrementRefCount();
-if ( d->icon->refCount() == 0 && d->icon->isCreatedOnServer() ) {
+if (d->icon->refCount() == 0 && d->icon->isCreatedOnServer()) {
 HbIconLoader *loader = HbIconLoader::global();
 loader->removeItemInCache(d->icon);
 d->icon->dispose();
 }
 d->icon = 0;
 }
 }
 #endif
 }
 void HbIconEngine::addBadge(Qt::Alignment align,
-const HbIcon& icon,
+const HbIcon &icon,
-int z)
+int z,
-{
+const QSizeF &sizeFactor,
-d->addBadge(align, icon, z);
+Qt::AspectRatioMode aspectRatio)
-}
+{
+d->addBadge(align, icon, z, sizeFactor, aspectRatio);
-bool HbIconEngine::removeBadge(const HbIcon& badge)
+}
+bool HbIconEngine::removeBadge(const HbIcon &badge)
 {
 return d->removeBadge(badge);
 }
 void HbIconEngine::removeAllBadges()

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