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

equal deleted inserted replaced

-:11d3954df52a
+:627c4a0fd0e7
 #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 = 0);
-bool removeBadge(const HbIcon& badge);
+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;
 }
 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) {
 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();
 {
 // 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 QColor();
 }
 }
 void HbIconEnginePrivate::addBadge(Qt::Alignment align,
-const HbIcon& icon,
+const HbIcon &icon,
 int z)
 {
 if (!badgeInfo) {
 badgeInfo = new HbBadgeIcon();
 }
 badgeInfo->addBadge(align, icon, z);
 }
-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->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->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;
 }
 }
 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());
 }
 // Size changed, invalidate pixmap stored in this object.
 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 = 0;
+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) {
 icon->paint(painter, rect, Qt::AlignCenter);
 HbIconLoader::global()->unLoadIcon(icon);
 icon->dispose();
 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->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::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(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();
 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)
 {
 d->addBadge(align, icon, z);
 }
-bool HbIconEngine::removeBadge(const HbIcon& badge)
+bool HbIconEngine::removeBadge(const HbIcon &badge)
 {
 return d->removeBadge(badge);
 }
 void HbIconEngine::removeAllBadges()

changeset 5	627c4a0fd0e7
parent 3	11d3954df52a
child 7	923ff622b8b9