FCL/sf/mw/hb: comparison src/hbservers/hbthemeserver/hbthemeserver

equal deleted inserted replaced

-:923ff622b8b9
+:4633027730f5
 #include "hbmemoryutils_p.h"
 #include "hbdeviceprofiledatabase_p.h"
 #include "hbthemesystemeffect_p.h"
 #ifdef HB_SGIMAGE_ICON
 #include "hbsgimagerenderer_p.h"
+#include <sgresource/sgerror.h>
 #endif
 // 5 MB GPU cache size
 #define GPU_CACHE_SIZE 0x500000
 // 5 MB  CPU cache size
 static const TInt KThemeName = 0;
 const QString KOperatorCPath = "C:/resource/hb/prioritytheme/icons/";
 const QString KOperatorZPath = "Z:/resource/hb/prioritytheme/icons/";
+const QString KBaseThemePath = "z:/resource/hb/";
 bool HbThemeServerPrivate::gpuGoodMemoryState = true;
 // This is used as parent theme always regardless of the active theme
 //**********************************
 QDir path(currentTheme);
 iCurrentThemeName = path.dirName();
 iCurrentThemePath = path.absolutePath();
 cache = 0;
-cssCache = 0;
 QT_TRY {
 //Create the Icon cache
 cache = new HbIconDataCache();
-//Create the CSS cache
-cssCache = new HbCache();
 } QT_CATCH(const std::bad_alloc &badalloc) {
 delete cache;
-delete cssCache;
 qt_symbian_exception2LeaveL(badalloc);
 }
 setMaxGpuCacheSize(GPU_CACHE_SIZE);
 setMaxCpuCacheSize(CPU_CACHE_SIZE);
 #if defined(HB_SGIMAGE_ICON) || defined(HB_NVG_CS_ICON)
 Destructor
 */
 HbThemeServerPrivate::~HbThemeServerPrivate()
 {
 delete cache;
-delete cssCache;
 cache = 0;      // so that HbThemeServerSession::~HbThemeServerSession can avoid using these pointers;
-cssCache = 0;   // it may be called inside HbThemeServerPrivate::~HbThemeServerPrivate
 TInt err = RProperty::Delete(KServerUid3, KNewThemeForThemeChanger);
 if(err != KErrNotFound) {
 User::LeaveIfError(err);
 }
 // Delete the listener for Publish/Subscribe
 /**
 Handles theme selection
 */
 void HbThemeServerPrivate::HandleThemeSelection( const QString& themeName)
 {
-QDir path(themeName.trimmed());
+QString cleanThemeName = themeName;
+if (!HbThemeUtils::isThemeValid(cleanThemeName)) {
+// check if the theme name is logical
+cleanThemeName = KBaseThemePath + HbThemeUtils::platformHierarchy + '/' +
+HbThemeUtils::iconsResourceFolder + '/' + cleanThemeName;
+}
+QDir path(cleanThemeName);
 iCurrentThemeName = path.dirName();
 iCurrentThemePath = path.absolutePath();
 #ifdef THEME_INDEX_TRACES
-qDebug() << "ThemeIndex: theme change request, new theme =" << themeName.toUtf8();
+qDebug() << "ThemeIndex: theme change request, new theme =" << cleanThemeName.toUtf8();
 #endif
 // Clear cached icons and session data
 clearIconCache();
 iSessionIter.SetToFirst();
 while(iSessionIter) {
 return (cache->insert(key, item));
 }
 /**
-* HbThemeServerPrivate::insertCssCacheItem
-*
-* Inserts a css-cache item along with its key into the css-cache.
-*/
-bool HbThemeServerPrivate::insertCssCacheItem(const QString& key,  HbCacheItem* item)
-{
-return (cssCache->insert(key, item));
-}
-/**
 * HbThemeServerPrivate::iconCacheItem
 *
 * Retrieves a icon cache-item from the icon cache based on it's key.
 */
 HbIconCacheItem * HbThemeServerPrivate::iconCacheItem(const HbIconKey &key , bool isMultiIconPiece)
 {
 return(cache->getCacheItem(key, renderMode, isMultiIconPiece));
 }
 /**
-* HbThemeServerPrivate::cssCacheItem
-*
-* Retrieves a css-cache item from the css cache based on it's key.
-*/
-HbCacheItem * HbThemeServerPrivate::cssCacheItem(const QString &key)
-{
-return(cssCache->cacheItem(key));
-}
-/**
 * HbThemeServerPrivate::clearIconCache
 *
 * Clears icon cache.
 */
 void HbThemeServerPrivate::clearIconCache()
 {
 cache->clear();
-}
-/**
-* HbThemeServerPrivate::clearCssCache
-*
-* Clears css cache.
-*/
-void HbThemeServerPrivate::clearCssCache()
-{
-cssCache->clear();
 }
 /**
 * HbThemeServerPrivate::CleanupSessionIconItem
 *
 return item->vectorIconData.type;
 }
 }
 /**
-* HbThemeServerPrivate::CleanupSessionCssItem
-*
-* Removes a css cache-item from css-cache based on it's key.
-*/
-void HbThemeServerPrivate::CleanupSessionCssItem(QString key)
-{
-/*
-Don't call any HbCache ( CssCache )  functions if HbThemeServerPrivate has already deleted it,
-which happens when ThemeServer is closed before the client(s).
-*/
-if (cssCache) {
-cssCache->remove(key);
-}
-}
-/**
 HbThemeServerPrivate::setMaxGpuCacheSize
 */
 void HbThemeServerPrivate::setMaxGpuCacheSize(int size)
 {
 cache->setMaxGpuCacheSize(size);
 void HbThemeServerPrivate::FreeGpuRam(int bytes, bool useSwRendering )
 {
 gpuGoodMemoryState = false;
 cache->freeGpuRam(bytes, useSwRendering);
-#ifdef HB_SGIMAGE_ICON
+}
-if (useSwRendering) {
-HbSgImageRenderer::global()->terminate();
+void HbThemeServerPrivate::freeGpuRam()
-}
+{
-#endif
+cache->freeGpuRam();
 }
 /**
 *  HbThemeServerPrivate::freeUnusedGpuResources
 *  This function frees all unused SgImage icons
 *
 */
 HbRenderingMode HbThemeServerPrivate::currentRenderingMode() const
 {
 return renderMode;
 }
+HbRenderingMode HbThemeServerPrivate::expectedRenderingMode(HbRenderingMode requsetedRenderingMode) const
+{
+HbRenderingMode renderingMode = ESWRendering;
+#if defined(HB_SGIMAGE_ICON) || defined(HB_NVG_CS_ICON)
+if((requsetedRenderingMode == EHWRendering) &&
+(currentRenderingMode() == EHWRendering) &&
+HbThemeServerPrivate::gpuMemoryState()) {
+renderingMode = EHWRendering;
+}
+#endif
+return renderingMode;
+}
 /**
 *  HbThemeServerPrivate::setCurrentRenderingMode
 *  This function sets  ThemeServer's current rendering mode
 *
 */
 void HbThemeServerPrivate::setCurrentRenderingMode(HbRenderingMode currentMode)
 {
 renderMode = currentMode;
-}
-//Debug Code for Test Purpose
-#ifdef HB_ICON_CACHE_DEBUG
-int HbThemeServerPrivate ::cacheIconCount() const
-{
-return cache->count();
 }
 unsigned long HbThemeServerPrivate::totalGPUMemory()
 {
 #ifdef HB_SGIMAGE_ICON
 #else
 return 0;
 #endif
 }
+int HbThemeServerPrivate::cachedSgImagesCount() const
+{
+return cache->cachedSgImagesCount();
+}
+int HbThemeServerPrivate::cachedPixmapCount() const
+{
+return cache->cachedPixmapCount();
+}
 unsigned long HbThemeServerPrivate::freeGPUMemory()
 {
 #ifdef HB_SGIMAGE_ICON
+#ifdef HB_ICON_CACHE_DEBUG
 qDebug() << "Inside  HbThemeServerSymbian::freeGPUMemory()  " ;
+#endif
 return HbSgImageRenderer::global()->freeGPUMemory();
 #else
 return 0;
 #endif
 }
+//Debug Code for Test Purpose
+#ifdef HB_ICON_CACHE_DEBUG
+int HbThemeServerPrivate ::cacheIconCount() const
+{
+return cache->count();
+}
 int HbThemeServerPrivate::freeVectorMemory()
 {
 return cache->freeVectorMemory();
 }
 int HbThemeServerPrivate::vectorLruCount()
 {
 return cache->vectorLruCount();
 }
 #endif
 int HbThemeServerPrivate::gpuLRUSize() const
 {
 return cache->gpuLRUSize();
 }
-/**
+//*********************************
-* HbThemeServerPrivate::doCleanup()
-*
-* This function releases shared memory occupied by css-resources whose reference count is zero,
-* so that subsequent css-requests could be fulfilled by the server. Those css-files whose reference
-* count are zero, are already appended to the LRU list maintained by the css-cache. Since these resources
-* are not being referred to by any application, they can be removed from the cache and corresponding
-* shared memory can be freed up.
-*/
-void HbThemeServerPrivate::doCleanup()
-{
-HbThemeServerUtils::cleanupUnusedCss(cssCache);
-}
-//**********************************
 //HbThemeServerSession
 //**********************************
 /**
-This class represents a session with the  server.
+This class represents a session with the server.
 Functions are provided to respond appropriately to client messages.
 */
 /**
 Constructor
 for (QList<HbIconKey>::const_iterator iter = sessionData.constBegin();
 iter != itEnd;
 ++iter) {
 iServer->CleanupSessionIconItem(*iter);
 }
-//clean up css related session-specific info
-QList<QString>::const_iterator iterEnd(sessionCssData.constEnd());
-for (QList<QString>::const_iterator iter = sessionCssData.constBegin();
-iter != iterEnd;
-++iter) {
-iServer->CleanupSessionCssItem(*iter);
-}
 sessionData.clear();
-sessionCssData.clear();
 }
 TIconParams HbThemeServerSession::ReadMessageAndRetrieveParams(const RMessage2& aMessage)
 {
 TInt deslen = aMessage.GetDesLength(0);
 TInt freeVectMem = iServer->freeVectorMemory();
 TPckg<TInt> out(freeVectMem);
 aMessage.WriteL(1, out);
 break;
 }
-case EFreeGPUMem: {
-unsigned long freeMem = iServer->freeGPUMemory();
-TPckg<unsigned long> out(freeMem);
-aMessage.WriteL(1, out);
-break;
-}
-case ETotalGPUMem: {
-unsigned long totalMem = iServer->totalGPUMemory();
-TPckg<unsigned long> out(totalMem);
-aMessage.WriteL(1, out);
-break;
-}
 case ELastAddedItemMem: {
 TInt lAddItemMem = iServer->lastAddedItemMem();
 TPckg<TInt> out(lAddItemMem);
 aMessage.WriteL(1, out);
 break;
 case EServerAllocReset: {
 //TODO
 break;
 }
 #endif
+case EFreeGPUMem: {
+unsigned long freeMem = iServer->freeGPUMemory();
+TPckg<unsigned long> out(freeMem);
+aMessage.WriteL(1, out);
+break;
+}
+case ECachedSgImages: {
+TInt cachedSgImages = iServer->cachedSgImagesCount();
+TPckg<TInt> out(cachedSgImages);
+aMessage.WriteL(1, out);
+break;
+}
+case ECachedPixmapImages: {
+TInt cachedPixImages = iServer->cachedPixmapCount();
+TPckg<TInt> out(cachedPixImages);
+aMessage.WriteL(1, out);
+break;
+}
+case ECurrentRenderingMode: {
+TInt currentRenderingMode = iServer->currentRenderingMode();
+TPckg<TInt> out(currentRenderingMode);
+aMessage.WriteL(1, out);
+break;
+}
+case ETotalGPUMem: {
+unsigned long totalMem = iServer->totalGPUMemory();
+TPckg<unsigned long> out(totalMem);
+aMessage.WriteL(1, out);
+break;
+}
 #ifdef HB_THEME_SERVER_MEMORY_REPORT
 case ECreateMemoryReport: {
 GET_MEMORY_MANAGER(HbMemoryManager::SharedMemory);
 static_cast<HbSharedMemoryManager *>(manager)->createReport();
 break;
 TInt mode = 0;
 TPckg<TInt> paramPckg(mode);
 aMessage.ReadL(0, paramPckg, 0);
 SwitchRenderingMode((HbRenderingMode)mode);
 break;
 }
 case EFreeSharedMem: {
 int freeSharedMem = iServer->freeSharedMemory();
 TPckg<int> out(freeSharedMem);
 aMessage.WriteL(1, out);
 break;
 break;
 }
 case ETypefaceOffset: {
 HandleTypefaceReqL(aMessage);
+break;
+}
+case EMissedHbCssLookup: {
+HandleMissedHbCssLookupL(aMessage);
 break;
 }
 qDebug()<< "HbThemeServerSession::SwitchRenderingMode:GPU Memory After Switching to Software:" << sgImg->freeGPUMemory();
 #endif //HB_ICON_CACHE_DEBUG
 }
 #endif
 }
 /**
 * HandleStyleSheetLookupL
 */
 void HbThemeServerSession::HandleStyleSheetLookupL(const RMessage2& aMessage)
 {
 HbLayeredStyleLoader::LayerPriority layerPriority = (HbLayeredStyleLoader::LayerPriority) priorityValue;
 QString cssFileName((QChar*)fileName.Ptr(), fileName.Length());
 HbSharedStyleSheetInfo offsetInfo;
-HbCacheItem* cssCacheItem = iServer->cssCacheItem(cssFileName);
-bool insertKeyIntoSessionList = false;
+offsetInfo.offset = HbThemeServerUtils::getSharedStylesheet(cssFileName,
-if (cssCacheItem) {
+layerPriority, offsetInfo.fileExists);
-//The item was found in the cache and reference count was incremented
-insertKeyIntoSessionList = true;
-offsetInfo.offset = cssCacheItem->offset;
-} else {
-bool tryAgain = false;
-do {
-offsetInfo.offset = HbThemeServerUtils::getSharedStylesheet(cssFileName, layerPriority);
-if (offsetInfo.offset >= 0) {
-HbCacheItem *cssItem =  new HbCacheItem(offsetInfo.offset, 0, cssFileName);
-insertKeyIntoSessionList = iServer->insertCssCacheItem(cssFileName, cssItem);
-if (layerPriority == HbLayeredStyleLoader::Priority_Core && cssItem->refCount == 1) {
-// This will make sure the requested stylesheet will always remain
-// in the primary and secondary cache.
-cssItem->incrementRefCount();
-}
-break;
-} else if (offsetInfo.offset == OUT_OF_MEMORY_ERROR && tryAgain == false) {
-iServer->doCleanup();
-tryAgain = true;
-} else if (offsetInfo.offset == OUT_OF_MEMORY_ERROR && tryAgain == true) {
-//try only once to free up memory, else offset remains -2
-tryAgain = false;
-}
-} while (tryAgain);
-}
-if (insertKeyIntoSessionList) {
-//The session will only keep track of cssFiles that were either successfully found or were
-//successfully inserted in the cache.
-if (!sessionCssData.contains(cssFileName)) {
-sessionCssData.append(cssFileName);
-}
-}
 TPckg<HbSharedStyleSheetInfo> data(offsetInfo);
 aMessage.WriteL(2, data);
+}
+/**
+* HandleMissedHbCssLookupL
+*/
+void HbThemeServerSession::HandleMissedHbCssLookupL(const RMessage2& aMessage)
+{
+HbSharedMissedHbCssInfo offsetInfo;
+offsetInfo.offset = HbThemeServerUtils::getMissedHbCssFilesOffset();
+TPckg<HbSharedMissedHbCssInfo> data(offsetInfo);
+aMessage.WriteL(0, data);
 }
 static const TInt KMaxLayoutName = 256;
 static const TInt KMaxSectionName = 256;
 QString wmlFileName((QChar*)fileName.Ptr(), fileName.Length());
 QString layout((QChar*)layoutName.Ptr(), layoutName.Length());
 QString section((QChar*)sectionName.Ptr(), sectionName.Length());
 HbSharedWMLInfo offsetInfo;
-offsetInfo.offset = HbThemeServerUtils::getSharedLayoutDefinition(wmlFileName, layout, section);
+offsetInfo.offset = HbThemeServerUtils::getSharedLayoutDefinition(wmlFileName, layout,
+section, offsetInfo.fileExists);
 TPckg<HbSharedWMLInfo> data(offsetInfo);
 aMessage.WriteL(3, data);
 }
 HbIconKey key(filename, QSizeF(params.width, params.height),
 (Qt::AspectRatioMode)params.aspectRatioMode,
 (QIcon::Mode)params.mode, params.mirrored, color,
 (HbRenderingMode)params.renderMode);
-HbIconCacheItem* cacheItem = iServer->iconCacheItem(key);
 bool insertKeyIntoSessionList = false;
+QString format = HbThemeServerUtils::formatFromPath(key.filename);
+HbIconCacheItem* cacheItem = getCachedIcon(key, format);
 if (cacheItem) {
 insertKeyIntoSessionList = true; //The item was found in the cache and ref count was incremented
 if (cacheItem->rasterIconData.type != INVALID_FORMAT) {
 data = cacheItem->rasterIconData;
 } else if (cacheItem->vectorIconData.type != INVALID_FORMAT) {
 } else {
 data.type = INVALID_FORMAT;
 }
 } else {
 QT_TRY {
-QString format = HbThemeServerUtils::formatFromPath(key.filename);
 QScopedPointer <HbIconCacheItem> tempIconCacheItem(
 HbIconCacheItemCreator::createCacheItem(key,
 static_cast<HbIconLoader::IconLoaderOptions>(params.options),
 format, iServer->currentRenderingMode()));
 cacheItem = tempIconCacheItem.data();
 data = cacheItem->blobIconData;
 } else {
 data.type = INVALID_FORMAT;
 }
 if (data.type != INVALID_FORMAT) {
+// set the rendering mode according to the actual rendering mode
+// in which the icon is created
+key.renderMode = cacheItem->renderingMode();
 insertKeyIntoSessionList = iServer->insertIconCacheItem(key, cacheItem);
 if (!insertKeyIntoSessionList) {
 FreeDataFromCacheItem(cacheItem);
 tempIconCacheItem.take();
 delete cacheItem; // do delete the item after gpu/cpu memory is freed
 if (insertKeyIntoSessionList) {
 //The session will only keep track of icons that were either successfully found or were
 //successfully inserted in the cache.
 sessionData.append(key);
 }
+#ifdef HB_SGIMAGE_ICON
+HbSgImageRenderer *sgImg = HbSgImageRenderer::global();
+if (sgImg->lastError() == KErrNoGraphicsMemory ) {
+iServer->freeGpuRam();
+}
+#endif
 // create dshared pixmap info from HbIconCacheItem
 TPckg<HbSharedIconInfo> pixdata(data);
 aMessage.WriteL(1, pixdata);
 #ifdef THEME_SERVER_TRACES
 static_cast<QIcon::Mode>(params.mode),
 params.mirrored,
 color,
 static_cast<HbRenderingMode>(params.renderMode));
-if (!IconInfoFromSingleIcon(finalIconKey, stitchedData)) {
+if (!IconInfoFromSingleIcon(finalIconKey, stitchedData, QString())) {
 HbMultiIconParams frameItemParams;
 int noOfPieces = 1;
 if (iconId.contains("_3PV", Qt::CaseInsensitive) || iconId.contains("_3PH", Qt::CaseInsensitive)) {
 noOfPieces = 3;
 } else if (iconId.contains("_9P", Qt::CaseInsensitive)) {
 // create dshared pixmap info from HbIconCacheItem
 TPckg<HbSharedIconInfo> pixdata(stitchedData);
 aMessage.WriteL(1, pixdata);
 }
+HbIconCacheItem* HbThemeServerSession::getCachedIcon(HbIconKey & key, const QString & format)
+{
+HbIconCacheItem* cacheItem = 0;
+// try to find the icon in other rendering mode,
+// if rendering will take place in another rendering mode
+HbRenderingMode rm = iServer->expectedRenderingMode((HbRenderingMode)key.renderMode);
+if (rm == key.renderMode) {
+cacheItem = iServer->iconCacheItem(key);
+} else if (rm != key.renderMode) {
+HbIconKey newKey(key);
+newKey.renderMode = rm;
+cacheItem = iServer->iconCacheItem(newKey);
+if (cacheItem) {
+key.renderMode = rm;
+}
+}
+if (!cacheItem) {
+// try search for icon in software mode if the icon is not of type nvg
+// currently only nvg type is used to create RSgImage
+if (format != HbIconCacheItemCreator::KNvg) {
+HbIconKey newKey(key);
+newKey.renderMode = ESWRendering;
+cacheItem = iServer->iconCacheItem(newKey);
+if (cacheItem) {
+key.renderMode = ESWRendering;
+}
+}
+}
+return cacheItem;
+}
 /**
 * HbThemeServerPrivate::IconInfoFromSingleIcon
 Checks for the cacheItem for a given key, if found gets the data relevant of the cacheItem.
 */
 bool HbThemeServerSession::IconInfoFromSingleIcon(HbIconKey key,
-HbSharedIconInfo &stitchedData)
+HbSharedIconInfo &stitchedData, const QString & format)
 {
-stitchedData.type = INVALID_FORMAT;
+HbIconCacheItem* cacheItem = 0;
-HbIconCacheItem * cacheItem = iServer->iconCacheItem(key, true);
+// try to find the icon in other rendering mode,
+// if rendering will take place in another rendering mode
+HbRenderingMode rm = iServer->expectedRenderingMode((HbRenderingMode)key.renderMode);
+if (rm == key.renderMode) {
+cacheItem = iServer->iconCacheItem(key, true);
+} else if (rm != key.renderMode) {
+HbIconKey newKey(key);
+newKey.renderMode = rm;
+cacheItem = iServer->iconCacheItem(newKey, true);
+if (cacheItem) {
+key.renderMode = rm;
+}
+}
+if (!cacheItem) {
+if (!format.isEmpty()) {
+// try search for icon in software mode if the icon is not of type nvg
+// currently only nvg type is used to create RSgImage
+if (format != HbIconCacheItemCreator::KNvg) {
+HbIconKey newKey(key);
+key.renderMode = ESWRendering;
+cacheItem = iServer->iconCacheItem(newKey);
+if (cacheItem) {
+key.renderMode = ESWRendering;
+}
+}
+}
+}
 if (cacheItem) {
 GetDataFromCacheItem(cacheItem, stitchedData);
 return true; //The item was found in the cache and ref count was incremented
 }
 return false;
 tempCacheItem.take();
 delete cacheItem; // do delete the item after gpu/cpu memory is freed
 stitchedData.type = INVALID_FORMAT;
 }
 }
+#ifdef HB_SGIMAGE_ICON
+HbSgImageRenderer *sgImg = HbSgImageRenderer::global();
+if (sgImg->lastError() == KErrNoGraphicsMemory ) {
+iServer->freeGpuRam();
+}
+#endif
 if (tempCacheItem.data()) {
 tempCacheItem.take();
 }
 return insertKeyIntoSessionList;
 }
 HbSharedIconInfo data;
 bool iconPieceMirrored = false;
 HbIconKey key(frameItemParams.multiPartIconList.at(i), frameItemParams.multiPartIconData.pixmapSizes[i],
 (Qt::AspectRatioMode)stichedKey.aspectRatioMode, (QIcon::Mode)stichedKey.mode, iconPieceMirrored,
 stichedKey.color,(HbRenderingMode)frameItemParams.renderMode);
-insertKeyIntoSessionList = IconInfoFromSingleIcon(key, data);
+insertKeyIntoSessionList = IconInfoFromSingleIcon(key, data, HbThemeServerUtils::formatFromPath(key.filename));
 if (!insertKeyIntoSessionList) {
 insertKeyIntoSessionList = CreateCacheItemData(key, frameItemParams.options, data, true);
 }
 if ((data.type == INVALID_FORMAT) || (!insertKeyIntoSessionList)) {
 failedToCreateParts = true;
 HbSharedIconInfo data;
 QString pieceName((QChar*)frameItemParams.iconList[i].Ptr(), frameItemParams.iconList[i].Length());
 HbIconKey key(pieceName, frameItemParams.sizeList[i],
 (Qt::AspectRatioMode)frameItemParams.aspectRatioMode, (QIcon::Mode)frameItemParams.mode,
 (bool)frameItemParams.mirrored, color, (HbRenderingMode)frameItemParams.renderMode);
-insertKeyIntoSessionList = IconInfoFromSingleIcon(key, data);
+insertKeyIntoSessionList = IconInfoFromSingleIcon(key, data, HbThemeServerUtils::formatFromPath(key.filename));
 if (!insertKeyIntoSessionList) {
 insertKeyIntoSessionList = CreateCacheItemData(key, 0, data, false);
 }
 if ((data.type != INVALID_FORMAT) || (insertKeyIntoSessionList)) {
 //The session will only keep track of icons that were either successfully found or were

changeset 21	4633027730f5
parent 7	923ff622b8b9
child 23	e6ad4ef83b23