FCL/sf/app/photos: comparison photosgallery/viewframework/texturemanager/src/glxtexturemanagerimpl.cpp

equal deleted inserted replaced

-:4e91876724a2
+:9ba538e329bd
 // trap create texture
 TRAPD(err, texture = &iAlfTextureManager.CreateTextureL(
 icon.iTextureId,
 this,
 EAlfTextureFlagDefault));
 if(err)
 {
 // if error delete entry and leave
 iIconList.Remove(iIconList.Count() - 1);
 User::Leave(err);
 // if no error add texture to entry
 iIconList[iIconList.Count() - 1].iTexture = texture;
 }
 }
-User::LeaveIfNull(texture); //should not be possible
+if (NULL == texture)
+{
+User::Leave(KErrNotFound);
+}
 return *texture;
 }
 // If the current thumbnail matches what is required then return the current texture otherwise
 // create a new one.
 if (!GetThumbnailAttributeAndIndexL(aSize, aMedia, aIdSpaceId, thumbnailIndex, thumbNailAttribute))
 {
+// only texture is missing.
+if ( (NULL != iThumbnailList[thumbnailIndex].iBitmap) && (NULL == iThumbnailList[thumbnailIndex].iTexture))
+{
+CAlfTexture* newTexture = &iAlfTextureManager.CreateTextureL(
+iThumbnailList[thumbnailIndex].iTextureId,
+this,
+EAlfTextureFlagDefault);
+iThumbnailList[thumbnailIndex].iTexture = newTexture ;
+}
 return *iThumbnailList[thumbnailIndex].iTexture;
 }
 // We have 2 scenarios here.
 // 1) We do not have a thumbnail
 if(!aAllTexture)
 break;
 }
 }
 }
+// -----------------------------------------------------------------------------
+// FlushTextures Removes All Textures
+// -----------------------------------------------------------------------------
+//
+void CGlxTextureManagerImpl::FlushTextures()
+{
+TRACER("CGlxTextureManagerImpl::FlushTextures");
+TInt textureID ;
+TInt i = iThumbnailList.Count();
+while(i > 0)
+{
+--i;
+textureID = iThumbnailList[i].iTextureId;
+iAlfTextureManager.UnloadTexture(textureID );
+iThumbnailList[i].iTexture = NULL;
+}
+i = iIconList.Count();
+while(i > 0)
+{
+--i;
+textureID = iIconList[i].iTextureId;
+iAlfTextureManager.UnloadTexture(textureID );
+iIconList[i].iTexture = NULL;
+}
+i = iZoomedList.Count();
+while(i > 0)
+{
+--i;
+textureID = iZoomedList[i].iTextureId;
+iAlfTextureManager.UnloadTexture(textureID );
+iZoomedList[i].iTexture = NULL;
+}
+}
 // -----------------------------------------------------------------------------
 // GetThumbnailAttributeAndIndexL
 // -----------------------------------------------------------------------------
 //
 TBool CGlxTextureManagerImpl::GetThumbnailAttributeAndIndexL( TSize aSize,
 // No need to do anything
 return EFalse;
 }
 }
 }
 return ETrue;
 }
+// -----------------------------------------------------------------------------
+// CreateNewTextureL
+// -----------------------------------------------------------------------------
+CAlfTexture* CGlxTextureManagerImpl::CreateZoomedTextureL()
+{
+TRACER("CGlxTextureManagerImpl::CreateZoomedTextureL");
+TInt count = iZoomedList.Count();
+TInt index = 0 ;
+for (index = count-1; index >=0  ; index--)
+{
+if (NULL == iZoomedList[index].iTexture)
+{
+if (NULL != iZoomedList[index].iBitmap)
+{
+// If we got this far we need to create a new texture
+iZoomedList[index].iTextureId = NextTextureId();
+iZoomedList[index].iTexture = &iAlfTextureManager.CreateTextureL(
+iZoomedList[index].iTextureId,
+this,
+EAlfTextureFlagDefault);
+return iZoomedList[index].iTexture ;
+}
+}
+}
+return NULL;
+}
 // -----------------------------------------------------------------------------
 // CreateNewTextureL
 // -----------------------------------------------------------------------------
 CAlfTexture& CGlxTextureManagerImpl::CreateNewTextureL( TSize aSize,
 const TGlxMedia& aMedia, const TGlxIdSpaceId& aIdSpaceId,
 if( aIsThumbnailTexture )
 	    {
 	     //Add to the thumbnail list
 GLX_LOG_INFO("CGlxTextureManagerImpl::CreateNewTextureL iThumbnailList.Append ");
 	    iThumbnailList.Append(aThumbData);
 	    }
 else
 	   {
 GLX_LOG_INFO1("CGlxTextureManagerImpl::CreateNewTextureL,count=%d",iZoomedList.Count());
 	   iZoomedList.Append(aThumbData);
 	   }
 GLX_LOG_INFO("CGlxTextureManagerImpl::CreateNewTextureL aIsThumbnailTexture ");
 	    TInt index = iThumbnailList.Count()-1;
 	    iThumbnailList[index].iTexture = newTexture;
 	    iThumbnailList[index].iRequiredSize = aSize;
 	    }
 	else
 	    {
 GLX_LOG_INFO("CGlxTextureManagerImpl::CreateNewTextureL else aIsThumbnailTexture ");
 	    TInt index = iZoomedList.Count()-1;
 	    iZoomedList[index].iTexture = newTexture;
 }
 return *newTexture;
 }
 // -----------------------------------------------------------------------------
 // CreateZoomedTextureL
 // -----------------------------------------------------------------------------
 //
 CAlfTexture& CGlxTextureManagerImpl::CreateZoomedTextureL(
 const TGlxMedia& aMedia, const TMPXAttribute& aAttribute,
 TGlxIdSpaceId aIdSpaceId, MGlxTextureObserver* aObserver)
 {
 TRACER("CGlxTextureManagerImpl::CreateZoomedTextureL");
 if(!iZoomDecoder)
-		{
+{
-		 GLX_LOG_INFO("CGlxTextureManagerImpl:: CreateZoomedTextureL,iZoomDecoder == NULL");
+GLX_LOG_INFO("CGlxTextureManagerImpl:: CreateZoomedTextureL,iZoomDecoder == NULL");
-		 iZoomDecoder = CGlxBitmapDecoderWrapper::NewL(this);
+iZoomDecoder = CGlxBitmapDecoderWrapper::NewL(this);
-		}
+}
 TGlxThumbnailIcon aThumbData;
 aThumbData.iTextureId = NextTextureId();
 aThumbData.iTexture = NULL;
 aThumbData.iAttribId = aAttribute;
 aThumbData.iMediaId = aMedia.Id();
 aThumbData.iIdSpaceId = aIdSpaceId;
 	iZoomedList[index].iBitmap=NULL;
 	iZoomedList[index].iObserver = aObserver ;
 	iZoomDecoder->DoDecodeImageL(aMedia.Uri(), iZoomedList.Count()-1);
 	return *(iZoomedList[index].iTexture);
 }
 // -----------------------------------------------------------------------------
 // CreateAnimatedGifTextureL
 bitmapId,
 maskId );
 }
 // Leave if bitmap or mask is NULL.
-User::LeaveIfNull( aBitmap );
+if (NULL == aBitmap)
+{
+User::Leave(KErrNotFound);
+}
 // set size
 // In preference use requested size if there is one
 TInt height =TInt(iResUtil->PossToPixels(icon.iHeightInPoss));
 TInt width =TInt(iResUtil->PossToPixels(icon.iWidthInPoss));
 TRACER("CGlxTextureManagerImpl::HandleBitmapDecodedL");
 CAlfTexture* newTexture = NULL;
 TBool textureCreated = ETrue;
 TInt textureID = -1;
 TInt textureToBeUnloaded = -1;
 //check if the image is decoded
 if(aBitmap != NULL)
-		    {
+{
-		    iZoomedList[aThumbnailIndex].iBitmap = aBitmap;
+iZoomedList[aThumbnailIndex].iBitmap = aBitmap;
-			//if we already have a texture then dont unload the texture before creating
+//if we already have a texture then dont unload the texture before creating
-			//the next one. It might happen that because of low memory we might not be able
+//the next one. It might happen that because of low memory we might not be able
-			//to create a new texture.
+//to create a new texture.
-			  if(iZoomedList[aThumbnailIndex].iTexture)
+if(iZoomedList[aThumbnailIndex].iTexture)
-			    {
+{
-			    textureID = NextTextureId();
+textureID = NextTextureId();
-			    textureToBeUnloaded = iZoomedList[aThumbnailIndex].iTextureId  ;
+textureToBeUnloaded = iZoomedList[aThumbnailIndex].iTextureId  ;
-			    iZoomedList[aThumbnailIndex].iTextureId = textureID  ;
+iZoomedList[aThumbnailIndex].iTextureId = textureID  ;
-			  	}
+}
-			  else
+else
-				  {
+{
-				  textureID = iZoomedList[aThumbnailIndex].iTextureId;
+textureID = iZoomedList[aThumbnailIndex].iTextureId;
-				  }
+}
-		    TRAPD(err, newTexture = &iAlfTextureManager.CreateTextureL(
-		    												 textureID, this, EAlfTextureFlagDefault));
-		    if ( KErrNone != err && KErrNoMemory == err )
-		        {
-		        GLX_LOG_INFO("CGlxTextureManagerImpl::HandleBitmapDecoded ReleaseRam : START RAM  RELEASE");
-		        iCache->ReleaseRAML(ETrue);
-		        TRAPD(err, newTexture = &iAlfTextureManager.CreateTextureL(textureID, this, EAlfTextureFlagDefault));
-		        if ( KErrNone != err && KErrNoMemory == err )
-		            {
-		            GLX_LOG_INFO("CGlxTextureManagerImpl::HandleBitmapDecoded CreateTextureL : LOW MEMORY CONDITION");
-		            textureCreated = EFalse;
-		            }
-		        }
-		    }
-		    else
-		    {
-		     textureCreated = EFalse;
-		    }
-if(iZoomedList[aThumbnailIndex].iBitmap)
-{
-GLX_LOG_INFO("CGlxTextureManagerImpl::HandleBitmapDecoded delete iBitmap");
-		delete iZoomedList[aThumbnailIndex].iBitmap;
-		iZoomedList[aThumbnailIndex].iBitmap = NULL;
-}
+TRAPD(err, newTexture = &iAlfTextureManager.CreateTextureL(
+textureID, this, EAlfTextureFlagDefault));
+if ( KErrNone != err && KErrNoMemory == err )
+{
+GLX_LOG_INFO("CGlxTextureManagerImpl::HandleBitmapDecoded ReleaseRam : START RAM  RELEASE");
+iCache->ReleaseRAML(ETrue);
+TRAPD(err, newTexture = &iAlfTextureManager.CreateTextureL(textureID, this, EAlfTextureFlagDefault));
+if ( KErrNone != err && KErrNoMemory == err )
+{
+GLX_LOG_INFO("CGlxTextureManagerImpl::HandleBitmapDecoded CreateTextureL : LOW MEMORY CONDITION");
+textureCreated = EFalse;
+}
+}
+}
+else
+{
+textureCreated = EFalse;
+}
 if (textureCreated && (NULL != newTexture))
 {
 GLX_LOG_INFO("CGlxTextureManagerImpl::HandleBitmapDecoded textureCreated && newTexture");
 //If the new texture is created then unload the old texture and store the new texture and textureID.
 if(iZoomedList[aThumbnailIndex].iTexture)
-				    {
+{
-				    GLX_LOG_INFO("CGlxTextureManagerImpl::HandleBitmapDecoded Unloading Old Texture");
+GLX_LOG_INFO("CGlxTextureManagerImpl::HandleBitmapDecoded Unloading Old Texture");
-				    iAlfTextureManager.UnloadTexture(textureToBeUnloaded );
+iAlfTextureManager.UnloadTexture(textureToBeUnloaded );
-				  	}
+}
-				iZoomedList[aThumbnailIndex].iTextureId = textureID;
+iZoomedList[aThumbnailIndex].iTextureId = textureID;
 iZoomedList[aThumbnailIndex].iTexture = newTexture;
 }
 if (iZoomedList[aThumbnailIndex].iObserver)
 {
 GLX_LOG_INFO("CGlxTextureManagerImpl::HandleBitmapDecoded TextureContentChangedL");
 iZoomedList[aThumbnailIndex].iObserver->TextureContentChangedL( textureCreated ,iZoomedList[aThumbnailIndex].iTexture);
 }

changeset 1	9ba538e329bd
parent 0	4e91876724a2
child 9	6b87b143d312