1 /*

     2 * Copyright (c) 2006-2007 Nokia Corporation and/or its subsidiary(-ies). 

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:   Implementation of CHuiTextureManager, texture objects loading 

    15 *                and management.

    16 *

    17 */

    18 

    19 

    20 

    21 #include <eikenv.h>

    22 #include <eikappui.h>

    23 #include <eikapp.h>

    24 

    25 #include "uiacceltk/HuiTextureManager.h"  // Class definition

    26 #include "uiacceltk/HuiTextureProcessor.h"

    27 #include "HuiRenderPlugin.h"

    28 #include "uiacceltk/HuiEnv.h"

    29 #include "uiacceltk/HuiTexture.h"

    30 #include "uiacceltk/HuiFont.h"

    31 #include "uiacceltk/HuiUtil.h"

    32 #include "uiacceltk/HuiPanic.h"

    33 #include "uiacceltk/HuiDisplay.h"

    34 #include "huitextureanimationstate.h"

    35 

    36 /**

    37  * Granularity of CHuiTextureManager::iAnimations and 

    38  * CHuiTextureManager::iAnimatedTextureGroupItems arrays.

    39  */

    40 const TInt KHuiAnimationsGranularity = 4;

    41 

    42 EXPORT_C MHuiBitmapProvider::~MHuiBitmapProvider()

    43     {

    44     }

    45 

    46 EXPORT_C CHuiTextureManager::CHuiTextureManager(CHuiEnv& aEnv)

    47         : CActive(EPriorityHigh),

    48         iEnv(aEnv), iState(EIdle), iReleaseState(ENormal), iFS(CHuiStatic::FsSession()),

    49         iAnimatedTextureGroupItems( KHuiAnimationsGranularity ),

    50         iAnimations( KHuiAnimationsGranularity ),

    51         iEnableTexMemCalculation( EFalse )  //Texture memory calculation is disabled by default

    52     {}

    53 

    54 

    55 EXPORT_C void CHuiTextureManager::BaseConstructL()

    56     {

    57     iEnv.SetTextureManager(*this);

    58 

    59     SetImagePathL(_L(""));

    60 

    61     // Create a small initial bitmaps for decoder output.

    62     iBitmap = new (ELeave) CFbsBitmap();

    63     User::LeaveIfError( iBitmap->Create(TSize(4, 4), EColor64K) );

    64     iMaskBitmap = new (ELeave) CFbsBitmap();

    65     User::LeaveIfError( iMaskBitmap->Create(TSize(4, 4), EGray256) );

    66 

    67     // Create blank texture

    68     iBlankTexture = CHuiStatic::Renderer().CreateTextureL();

    69     iBlankTexture->SetImageFileNameL(_L("blank"));

    70 

    71     CActiveScheduler::Add(this);

    72     

    73     // Enabling logging will cause diagnostics and debugging messages to be

    74     // printed to a file.

    75     CHuiStatic::EnableLogging(EFalse);

    76     }

    77 

    78 

    79 EXPORT_C CHuiTextureManager::~CHuiTextureManager()

    80     {

    81     Cancel();

    82 

    83     delete iAnimationWithoutGroup;

    84     iAnimatedTextureGroupItems.Close();

    85     iAnimations.ResetAndDestroy();

    86     iAnimations.Close();

    87 

    88     // Delete the texture processor.

    89     delete iProcessor;

    90 

    91     // Clear any remaining entries in the load queue.

    92     for(TInt i = 0; i < iLoadQueue.Count(); ++i)

    93         {

    94         delete iLoadQueue[i].iDecoder;

    95         iLoadQueue[i].iDecoder = 0;

    96         }

    97     iLoadQueue.Reset();

    98 

    99     delete iBlankTexture;

   100 

   101     // Remove all texture entries (from last to first -order)

   102     /*while (iTextures.Count()>0)*/

   103     for(TInt i = iTextures.Count()-1; i >= 0; --i)

   104         {

   105         CTextureEntry * te = iTextures[i];

   106         

   107         if (te->iTexture)

   108             {

   109             delete te->iTexture;

   110             }

   111         else

   112             {

   113             // This texture was defined but never loaded.

   114             HUI_DEBUG2(_L("CHuiTextureManager::~CHuiTextureManager() - Notice, texture id %i (\"%S\") was never loaded!"), te->iId, te->iFileName);

   115             }

   116         }

   117         

   118     iTextures.ResetAndDestroy();

   119     iStateObservers.Close();

   120     iLoadObservers.Close();

   121     iAnimatedTextures.Close();

   122     iTextureAutoSizeObservers.Close();

   123 

   124     delete iBitmap;

   125     delete iMaskBitmap;

   126     delete iImagePath;

   127     }

   128 

   129 

   130 EXPORT_C CHuiEnv& CHuiTextureManager::Env()

   131     {

   132     return iEnv;

   133     }

   134 

   135 

   136 EXPORT_C CHuiTexture* CHuiTextureManager::Texture(TInt aId)

   137     {

   138     TInt index = CheckTexture(aId);

   139     if(index == -1)

   140         {

   141         HUI_DEBUG1(_L("CHuiTextureManager::Texture() - Texture id %i not found! Returning blank."), aId);

   142         // NOTE: there is a danger of editing the blank texture

   143         // instead of the real texture..

   144         return &BlankTexture();

   145         }

   146     CHuiTexture * texture = iTextures[index]->iTexture;

   147     if(texture)

   148         {

   149         return texture;

   150         }

   151     else

   152         {

   153         HUI_ASSERT(EFalse); // texture exists but is not loaded! (defined but not loaded)

   154         return &BlankTexture();

   155         }

   156     }

   157 

   158 

   159 EXPORT_C const CHuiTexture* CHuiTextureManager::Texture(TInt aId) const

   160     {

   161     TInt id = CheckTexture(aId);

   162     if(id == -1)

   163         {

   164         return &BlankTexture();

   165         }

   166     const CHuiTexture * texture = iTextures[id]->iTexture;

   167     if(texture)

   168         {

   169         return texture;

   170         }

   171     else

   172         {

   173         HUI_ASSERT(EFalse); // texture exists but is not loaded! (defined but not loaded)

   174         return &BlankTexture();

   175         }

   176     }

   177 

   178 

   179 EXPORT_C CHuiTexture* CHuiTextureManager::TextureL(TInt aId)

   180     {

   181     // try to get the index for the texture id

   182     TInt index = CheckTexture(aId);

   183     if(index != -1)

   184         {

   185         // If the texture has content and a filename, we can do a load-on-demand.       

   186         if(!iTextures[index]->iTexture->HasContent() && iTextures[index]->iFileName)

   187             {

   188             // we don't want to return textures without content

   189             // so load-on-demand      

   190                     

   191             // texture has an entry but the

   192             // actual texture object has not been loaded yet

   193 

   194             // we can load the texture if there's a filename

   195             // available for this id

   196             return &LoadTextureL(aId);

   197             }

   198             

   199         // texture found  

   200         return iTextures[index]->iTexture;

   201         }

   202 

   203     User::Leave(KErrNotFound);

   204     return NULL; // never

   205     }

   206 

   207 

   208 EXPORT_C void CHuiTextureManager::SetImagePathL(const TDesC& aPath)

   209     {

   210     delete iImagePath;

   211     iImagePath = NULL;

   212 

   213     TParsePtrC parse(aPath);

   214     CEikonEnv* coe = CEikonEnv::Static();

   215     if (aPath.Length() && !parse.DrivePresent() && coe && coe->EikAppUi() && coe->EikAppUi()->Application())

   216         {

   217         iImagePath = HBufC::NewL(aPath.Size()+2); // two extra characters for drive

   218         TPtr ptr = iImagePath->Des();

   219         ptr.Append(coe->EikAppUi()->Application()->AppFullName().Left(2));

   220         ptr.Append(aPath);

   221         }

   222     else

   223         {

   224         iImagePath = aPath.AllocL();        

   225         }

   226     }

   227 

   228 EXPORT_C const TDesC& CHuiTextureManager::ImagePath() const

   229     {

   230     return *iImagePath;

   231     }

   232 

   233 

   234 EXPORT_C const CHuiTexture& CHuiTextureManager::BlankTexture() const

   235     {

   236     HUI_ASSERT(iBlankTexture!=NULL); // this MUST have a valid pointer otherwise access violation will follow..

   237     return *iBlankTexture;

   238     }

   239 

   240 

   241 EXPORT_C CHuiTexture& CHuiTextureManager::BlankTexture()

   242     {

   243     HUI_ASSERT(iBlankTexture!=NULL); // this MUST have a valid pointer otherwise access violation will follow..

   244     return *iBlankTexture;

   245     }

   246 

   247 

   248 EXPORT_C TBool CHuiTextureManager::SetTextureId(CHuiTexture* aTexture, TInt aId)

   249     {

   250     

   251     if(!aTexture)

   252         {

   253         // Cannot set texture ID for null texture.

   254         return EFalse;

   255         }

   256     

   257     // Iterate through all the managed textures to find the one we

   258     // are interested in, and then set its texture ID.

   259     for(TInt i = 0; i < iTextures.Count(); ++i)

   260         {

   261         if(iTextures[i]->iTexture == aTexture)

   262             {

   263             // Texture was found in the list, so set the new identifier.

   264             iTextures[i]->iId = aId;

   265             return ETrue;

   266             }

   267         }

   268 

   269     // Texture was not found in the manager's list.

   270     return EFalse;

   271     }

   272 

   273 EXPORT_C TBool CHuiTextureManager::IsLoaded(const CHuiTexture * texture) const

   274     {

   275     if(texture != NULL && texture->HasContent() && !IsInLoadQueue(texture))

   276         {

   277         return ETrue;

   278         }

   279     return EFalse;

   280     }

   281 

   282 

   283 EXPORT_C TBool CHuiTextureManager::IsLoaded(const TDesC& aImageName, const TInt aFrameNumber) const

   284     {

   285     TFileName fileName = *iImagePath;

   286     fileName.Append(aImageName);

   287     TInt index = CheckTexture(fileName, aFrameNumber);

   288     if(index < 0)

   289         {

   290         HUI_DEBUG1(_L("CHuiTextureManager::IsLoaded() - Texture \"%S\" was not found. Assuming not loaded."), &aImageName);

   291         return EFalse;

   292         }

   293     return IsLoaded(iTextures[index]->iTexture);

   294     }

   295 

   296 

   297 EXPORT_C TBool CHuiTextureManager::IsLoaded(TInt aId) const

   298     {

   299     HUI_ASSERT(aId!=0);

   300     TInt index = CheckTexture(aId);

   301     if(index < 0)

   302         {

   303         HUI_DEBUG1(_L("CHuiTextureManager::IsLoaded() - Texture having id %i was not found. Assuming not loaded."), aId);

   304         return EFalse;

   305         }

   306     return IsLoaded(iTextures[index]->iTexture);

   307     }

   308 

   309 

   310 EXPORT_C void CHuiTextureManager::AppendTextureL(CHuiTexture* aTexture, TInt aId)

   311     {

   312     // Panic if the manager is currently restoring or releasing textures.

   313     if(iReleaseState == EReleasing)

   314         {

   315         THuiPanic::Panic(THuiPanic::ETextureManagerTextureDestroyedDuringRelease);

   316         }

   317     else if(iReleaseState == ERestoring)

   318         {

   319         THuiPanic::Panic(THuiPanic::ETextureManagerTextureConstructedDuringRestore);

   320         }

   321     else

   322         {

   323         // for PC lint

   324         }

   325 

   326     HUI_ASSERT(aTexture != NULL);

   327 

   328 #ifdef _DEBUG

   329     // Look for an existing entry for this.

   330     // There must not be any duplicates present!

   331     for(TInt i = 0; i < iTextures.Count(); ++i)

   332         {

   333         if(iTextures[i]->iTexture == aTexture)

   334             {

   335             User::Leave(KErrAlreadyExists);

   336             }

   337         }

   338 #endif

   339 

   340     // Create a new texture entry

   341     CTextureEntry * te = new (ELeave) CTextureEntry(aId, aTexture);

   342     CleanupStack::PushL(te);

   343     // Add the new entry to the list of new textures

   344     User::LeaveIfError( iTextures.Append(te) );

   345     CleanupStack::Pop(); // pop the texture entry

   346 

   347     HUI_DEBUG1(_L("CHuiTextureManager::AppendTextureL() - Registered texture 0x%x."), aTexture);

   348     }

   349 

   350 

   351 EXPORT_C void CHuiTextureManager::RemoveTexture(CHuiTexture& aTexture)

   352     {

   353     // Panic if the manager is currently restoring or releasing textures.

   354     if(iReleaseState == EReleasing)

   355         {

   356         THuiPanic::Panic(THuiPanic::ETextureManagerTextureDestroyedDuringRelease);

   357         }

   358     else if(iReleaseState == ERestoring)

   359         {

   360         THuiPanic::Panic(THuiPanic::ETextureManagerTextureDestroyedDuringRestore);

   361         }

   362     else

   363         {

   364         // for PC lint

   365         }

   366     

   367     // Cancel loading of the texture to be removed.

   368     CancelLoadingOfTexture(aTexture);

   369 

   370     // Manual sequential search.

   371     for(TInt index = iTextures.Count() - 1; index >= 0; --index)

   372         {

   373         if(iTextures[index]->iTexture == &aTexture)

   374             {

   375             CTextureEntry * entry = iTextures[index];

   376             if ( entry->iFileName )

   377                 {

   378                 HUI_DEBUG4(_L("CHuiTextureManager::RemoveTexture() - Removing texture 0x%x  (Name: \"%S\", Id: %i). Number of textures after deleting: %i."),

   379                               &aTexture, &(aTexture.ImageFileName()), entry->iId, iTextures.Count()-1);                     

   380                 }

   381             else

   382                 {

   383                 HUI_DEBUG3(_L("CHuiTextureManager::RemoveTexture() - Removing unnamed texture 0x%x  ( Id: %i). Number of textures after deleting: %i."),

   384                               &aTexture, entry->iId, iTextures.Count()-1);                     

   385                 }

   386 

   387             iTextures.Remove(index);

   388             delete entry;

   389             return;

   390             }

   391         }

   392 

   393     HUI_DEBUG2(_L("CHuiTextureManager::RemoveTexture() - Error! Failed to remove texture 0x%x \"%S\". Texture not found."), &aTexture, &aTexture.ImageFileName());

   394     // this is a programming error.. texturemanager is aware of all textures in the toolkit!!

   395     #ifdef _DEBUG

   396     HUI_PANIC(THuiPanic::ETextureNotValid)

   397     #endif

   398     }

   399 

   400 

   401 EXPORT_C CHuiTexture& CHuiTextureManager::LoadTextureL(

   402     const TDesC& aImageName,

   403     THuiTextureUploadFlags aFlags,

   404     TInt aId,

   405     TInt aFrameNumber)

   406     {

   407     return LoadTextureL(aImageName, TSize(0, 0), aFlags, aId, aFrameNumber);

   408     }

   409 

   410 

   411 EXPORT_C CHuiTexture& CHuiTextureManager::LoadTextureL(const TInt aId,

   412                                        const TSize& aTextureMaxSize,

   413                                        THuiTextureUploadFlags aFlags)

   414     {

   415     return LoadTextureL(KNullDesC(), aTextureMaxSize, aFlags, aId);

   416     }

   417 

   418 

   419 EXPORT_C CHuiTexture& CHuiTextureManager::LoadTextureL(const TDesC& aImageName,

   420         const TSize& aTextureMaxSize,

   421         THuiTextureUploadFlags aFlags,

   422         TInt aId,

   423         TInt aFrameNumber)

   424     {

   425     // Ignore EHuiTextureFlagAllowDirectBitmapUsage flag

   426    	aFlags = (THuiTextureUploadFlags)(aFlags & ~EHuiTextureFlagAllowDirectBitmapUsage);		

   427     

   428     TFileName fileName;

   429 

   430     CTextureEntry * entry = NULL;  

   431 

   432     // If the name is invalid, and there was no filename available

   433     // based on id, return a dummy texture.

   434     if((aImageName.Length() == 0) && (aId == 0))

   435         {

   436         HUI_DEBUG(_L("CHuiTextureManager::LoadTextureL() - No filename or id provided for texture. Returning blank."));

   437         return BlankTexture();

   438         }

   439 

   440     // add path to filename if filename has been passed

   441     if(aImageName.Length() > 0)

   442         {

   443         // assume relative pathname and prepend the image path to get full filename

   444         fileName = aImageName;

   445         PrependImagePath(fileName);

   446         }

   447 

   448     // if no name has been passed as a parameter but

   449     // a nonzero id has been passed, we

   450     // can assume that there's a predefined name available

   451     if((aImageName.Length() == 0) && (aId != 0))

   452        {

   453         // search for a texture filename based on the id.

   454         TInt index = CheckTexture(aId);

   455         if(index >=0)

   456             {

   457             entry = iTextures[index];

   458             HUI_ASSERT(entry->iFileName);

   459             fileName = *(entry->iFileName);

   460             }

   461         else

   462             {

   463             HUI_DEBUG1(_L("CHuiTextureManager::LoadTextureL() - Unable to load texture without filename or pre-defined id (filename definition for id %i not found)."), aId);

   464             User::Leave(KErrNotFound);

   465             }

   466        }

   467 

   468     // a guarantee that there's a filename available

   469     HUI_ASSERT(	fileName.Length()>0 );

   470 

   471     // Reuse pre-existing entries:

   472     // try first finding an entry based on id

   473     if(entry == NULL && aId != 0)

   474         {

   475         TInt previouslyLoadedIndex = CheckTexture(aId);

   476         if (previouslyLoadedIndex >= 0)

   477             {

   478             entry = iTextures[previouslyLoadedIndex];

   479             }

   480         }

   481 

   482     // We are not allowed to change required texture id so we can't 

   483     // try again with the filename unless user does not care about id

   484     if(aId == 0 && entry == NULL)

   485         {

   486         TInt previouslyLoadedIndex = CheckTexture(fileName, aFrameNumber);

   487         if (previouslyLoadedIndex >= 0)

   488             {

   489             entry = iTextures[previouslyLoadedIndex];

   490             }

   491         }

   492 

   493     // create new texture entry if there's not one

   494     // available at this point

   495     if(entry == NULL)

   496         {

   497         HUI_DEBUG(_L("CHuiTextureManager::LoadTextureL() - Creating new texture."));

   498 

   499         // in the case that a previously loaded slot was not found,

   500         // create a new texture, which automatically registers a new

   501         // texture entry in the iTextures list.

   502         CHuiTexture::NewL();

   503 

   504         // we assume that the newest entry was added the last

   505         entry = iTextures[iTextures.Count()-1];

   506 

   507         entry->iId = aId;

   508         }

   509     else

   510         {

   511         // We have a valid texture name and ID.

   512         HUI_ASSERT(entry->iTexture);

   513       

   514         // we have a pre-existing texture,

   515         // but check that the texture is loaded ok, we can also

   516         // return unloaded textures that are in the load queue

   517         if (entry->iTexture->HasContent() || IsInLoadQueue(entry->iTexture))

   518             {

   519             // a previous texture exists!

   520             HUI_ASSERT(entry->iTexture!=NULL);            

   521             

   522             HUI_DEBUG3(_L("CHuiTextureManager::LoadTextureL() - Reusing texture 0x%x (\"%S\", id: %i) No need to load."),

   523                       entry->iTexture, &entry->iTexture->ImageFileName(), entry->iId);

   524             return *(entry->iTexture);

   525             }

   526         }

   527 

   528     HUI_ASSERT(entry!=NULL);

   529     HUI_ASSERT(entry->iTexture!=NULL);

   530        

   531     // replace filename

   532     // File names are relative to the image path.

   533     entry->SetFileName(fileName);

   534     entry->iTexture->SetImageFileNameL(fileName);

   535     entry->iTexture->EnableShadow((aFlags & EHuiTextureUploadFlagGenerateShadow) != 0);

   536     entry->iFrameNumber = aFrameNumber;

   537 

   538     // add a content observer so that we can reload the texture

   539     // during restoring

   540     if (entry->iTexture->iContentObservers.Count()==0)

   541         {

   542         HUI_DEBUG2(_L("CHuiTextureManager::LoadTextureL() - Adding content observer 0x%x for texture 0x%x."),  entry, entry->iTexture);

   543         entry->iTexture->iContentObservers.AppendL(*entry);

   544         }

   545 

   546     HUI_DEBUG3(_L("CHuiTextureManager::LoadTextureL() - Enqueuing texture 0x%x (Name: \"%S\", Id: %i)."),

   547                entry->iTexture, &entry->iTexture->ImageFileName(), entry->iId);

   548 

   549     // Prepare for loading by creating a load queue entry.

   550     SLoadQueueEntry loadqentry;

   551     Mem::FillZ(&loadqentry, sizeof(loadqentry));

   552     loadqentry.iLoading = entry;

   553     entry->iMaxTextureSize = aTextureMaxSize;

   554     entry->iFlags = aFlags;

   555 

   556     // Textures are loaded one at a time, in the order they were requested.

   557     User::LeaveIfError( iLoadQueue.Append(loadqentry) );

   558 

   559     // Start loading images.

   560     if(iState == EIdle)

   561         {

   562         StartLoading();

   563         

   564         if(iState == ELoading)

   565             {

   566             // Notify observers that loading has started.

   567             NotifyStateChange();

   568             }

   569         }

   570 

   571     return *entry->iTexture;

   572     }

   573 

   574 EXPORT_C CHuiTexture&

   575 CHuiTextureManager::CreateTextureL(TInt aId,

   576                                    MHuiBitmapProvider* aBitmapProvider,

   577                                    THuiTextureUploadFlags aFlags)

   578     {

   579     CHuiTexture* tex;

   580     

   581     // can't create texture without id (or filename)

   582     if (aId==0)

   583         {

   584         HUI_DEBUG(_L("CHuiTextureManager::CreateTextureL() - ERROR! Can't create texture without valid id. Please use nonzero ids."));

   585         User::Leave(KErrArgument);

   586         }

   587 

   588     // Provide an already created texture if such exists.

   589     CHuiTexture* texture = NULL;

   590     TRAPD(err, texture = TextureL(aId));

   591     if(err == KErrNone)

   592         {

   593         ASSERT( texture );

   594 

   595         // Update flags here because there is no other way to change flags. 

   596         CTextureEntry* entry = TextureEntry(CheckTexture(aId));

   597         if (entry)

   598             {

   599             entry->iFlags = aFlags;        

   600             }

   601         

   602         return *texture;

   603         }

   604 

   605     // Assert that the bitmap provider object exists.

   606     HUI_ASSERT(aBitmapProvider != NULL);

   607 

   608     HUI_DEBUG1(_L("CHuiTextureManager::CreateTextureL() - Requesting bitmap content from provider 0x%x .."), aBitmapProvider);

   609 

   610     // Initialize bitmap and mask bitmap pointers to zero.

   611     CFbsBitmap* bitmap = NULL;

   612     CFbsBitmap* maskBitmap = NULL;

   613 

   614     // Call the bitmapProvider method to load the bitmaps.

   615     ASSERT( aBitmapProvider );

   616     aBitmapProvider->ProvideBitmapL(aId, bitmap, maskBitmap);

   617 

   618     // Error if main bitmap could not be loaded

   619     User::LeaveIfNull(bitmap);

   620     CleanupStack::PushL(bitmap);

   621     

   622     UpdateFlags(*bitmap, maskBitmap, aFlags);

   623     

   624     if (maskBitmap)

   625         {

   626         // A mask was provided, so pass this to texture creation.

   627         CleanupStack::PushL(maskBitmap);

   628         // create textures right away for these bitmaps

   629         tex = &CreateTextureL(*bitmap, maskBitmap, aFlags, aId);

   630         // get rid of bitmap and mask

   631         CleanupStack::PopAndDestroy(maskBitmap);

   632         }

   633     else

   634         {

   635         // No mask, so create texture without one.

   636         // create textures right away for these bitmaps

   637         tex = &CreateTextureL(*bitmap, NULL, aFlags, aId);            

   638         }

   639         

   640     CleanupStack::PopAndDestroy(bitmap);        

   641 

   642     // store the provider with the texture for Restore operations

   643     HUI_ASSERT(CheckTexture(aId)>=0);

   644     CTextureEntry * entry = TextureEntry(CheckTexture(aId));

   645     entry->iBitmapProvider = aBitmapProvider;

   646     entry->iFlags = aFlags;

   647 

   648     HUI_ASSERT(entry->iTexture);

   649 

   650     // add a content observer so that we can reload the texture

   651     // during restoring

   652     if (entry->iTexture->iContentObservers.Count()==0)

   653         {

   654         HUI_DEBUG2(_L("CHuiTextureManager::CreateTextureL() - Adding content observer 0x%x for texture 0x%x."),  entry, entry->iTexture);

   655         entry->iTexture->iContentObservers.AppendL(*entry);

   656         }

   657 

   658     return *tex;

   659     }

   660 

   661 EXPORT_C CHuiTexture& CHuiTextureManager::CreateTextureL(CFbsBitmap& aBitmap,

   662                                    const CFbsBitmap* aMask,

   663                                    THuiTextureUploadFlags aFlags,

   664                                    TInt aId)

   665     {

   666     TBool hasAlpha = (aMask != NULL);

   667     TSize bitmapSize = aBitmap.SizeInPixels();

   668 

   669     CHuiStatic::Tic(2);

   670 

   671     // Verify that the bitmap size is same as the mask size.

   672     if(hasAlpha && (bitmapSize != aMask->SizeInPixels()))

   673         {

   674         HUI_DEBUG(_L("CHuiTextureManager::CreateTextureL() - Bitmap size is not compatible with the mask bitmap!"));

   675         User::Leave(KErrArgument);

   676         }

   677 

   678     // Leave if the name and the id are empty.

   679     if(aId==0)

   680         {

   681         HUI_DEBUG(_L("CHuiTextureManager::CreateTextureL() - ERROR! Can't create texture without valid id or name."));

   682         User::Leave(KErrArgument);

   683         }

   684 

   685     // If the texture has already been loaded, just return a reference.

   686     TInt previouslyLoadedIndex = CheckTexture(aId);

   687 

   688     if((previouslyLoadedIndex != -1) && IsLoaded(aId))

   689         {

   690         CHuiTexture * tex = iTextures[previouslyLoadedIndex]->iTexture;

   691         HUI_ASSERT(tex);

   692         HUI_DEBUG3(_L("CHuiTextureManager::CreateTextureL() - Reusing previously loaded texture (0x%x, \"%S\", id: %i)."),

   693                      tex, &tex->ImageFileName(), iTextures[previouslyLoadedIndex]->iId);

   694         return *tex;

   695         }

   696 

   697     // create and append to the textures list (automatic)

   698     CHuiTexture* texture = CHuiTexture::NewL();

   699     // Set texture name

   700     texture->SetImageFileNameL(_L(""));

   701     // Set the texture id.

   702     HUI_ASSERT(TextureEntryCount()>0);

   703     CTextureEntry * te = TextureEntry(TextureEntryCount()-1);

   704     te->iId = aId;

   705 

   706     HUI_DEBUG3(_L("CHuiTextureManager::CreateTextureL() - Created new texture 0x%x (\"%S\", id: %i)."),

   707                      texture, &texture->ImageFileName(), aId);

   708 

   709     // Let the texture know its size as soon as possible.

   710     texture->SetSize(bitmapSize);

   711 

   712     HUI_DEBUG6(_L("CHuiTextureManager::CreateTextureL() - Image for texture 0x%x is \"%S\": w=%i, h=%i, dm=%i, mdm=%i"),

   713                texture,

   714                &texture->ImageFileName(),

   715                bitmapSize.iWidth,

   716                bitmapSize.iHeight,

   717                aBitmap.DisplayMode(),

   718                (aMask != NULL ? aMask->DisplayMode() : ENone));

   719 

   720     // Enable texture shadow.

   721     texture->EnableShadow((aFlags & EHuiTextureUploadFlagGenerateShadow) != 0);

   722 

   723 	if (bitmapSize.iWidth != 0 && bitmapSize.iHeight != 0)

   724 	    {

   725     	if (aFlags & EHuiTextureFlagAllowDirectBitmapUsage) 

   726     		{

   727        		texture->UploadDirectL(aBitmap, aMask, aFlags);		

   728     		}

   729     	else 

   730     		{

   731        		texture->UploadL(aBitmap, aMask, aFlags);		

   732     		}

   733 

   734 	    }

   735 

   736     HUI_DEBUG1(_L("CHuiTextureManager::CreateTextureL() - Upload for texture 0x%x done, notifying possible observers.."), texture);

   737 

   738     // Store bits per pixel info to calculate texture memory usage

   739     te->iBitDepth = TDisplayModeUtils::NumDisplayModeBitsPerPixel( aBitmap.DisplayMode() );

   740     if( aMask )

   741     	{

   742     	 te->iBitDepth =  te->iBitDepth + TDisplayModeUtils::NumDisplayModeBitsPerPixel( aMask->DisplayMode() );

   743     	}

   744 

   745     // Notify the observers

   746     NotifyTextureLoaded(*texture, aId, KErrNone);

   747 

   748     HUI_DEBUG2(_L("CHuiTextureManager::CreateTextureL() - Finished with texture 0x%x, toc: %f seconds"), texture, CHuiStatic::Toc(2));

   749     return *texture;

   750     }

   751 

   752 

   753 EXPORT_C void CHuiTextureManager::UpdateTextureFromBitmapL(TInt aId, MHuiBitmapProvider* aBitmapProvider)

   754     {

   755     TInt previouslyLoadedIndex = CheckTexture(aId);

   756     if (previouslyLoadedIndex == KErrNotFound)

   757     	{

   758     	User::Leave(KErrNotFound);

   759     	}

   760 

   761 	// Unload

   762 	

   763     UnloadTexture(aId);      

   764 

   765 	// Upload with the new content

   766 	

   767 	CTextureEntry* entry = iTextures[previouslyLoadedIndex];

   768     

   769     HUI_DEBUG1(_L("CHuiTextureManager::UpdateTextureFromBitmapL() - Requesting bitmap content from provider 0x%x .."), aBitmapProvider);

   770 

   771     // Initialize bitmap and mask bitmap pointers to zero.

   772     CFbsBitmap* bitmap = NULL;

   773     CFbsBitmap* maskBitmap = NULL;

   774 

   775     // Call the bitmapProvider method to load the bitmaps.

   776     if (!aBitmapProvider)

   777     	{

   778     	aBitmapProvider = entry->iBitmapProvider;

   779     	}

   780     if (aBitmapProvider)

   781     	{

   782    	    aBitmapProvider->ProvideBitmapL(aId, bitmap, maskBitmap);

   783     	}

   784 

   785     // Error if main bitmap could not be loaded

   786     if (!bitmap)

   787     	{

   788     	User::Leave(KErrNotFound);

   789     	}

   790     CleanupStack::PushL(bitmap);

   791     

   792     if (maskBitmap)

   793         {

   794         CleanupStack::PushL(maskBitmap);

   795         }

   796 

   797     TBool hasAlpha = (maskBitmap != NULL);

   798     TSize bitmapSize = bitmap->SizeInPixels();

   799 

   800     CHuiStatic::Tic(2);

   801 

   802     // Verify that the bitmap size is same as the mask size.

   803     if(hasAlpha && (bitmapSize != maskBitmap->SizeInPixels()))

   804         {

   805         HUI_DEBUG(_L("CHuiTextureManager::UpdateTextureFromBitmapL() - Bitmap size is not compatible with the mask bitmap!"));

   806         User::Leave(KErrArgument);

   807         }

   808 

   809     CHuiTexture* texture = entry->iTexture;

   810     // Set texture name

   811     texture->SetImageFileNameL(_L(""));

   812 

   813     HUI_DEBUG6(_L("CHuiTextureManager::UpdateTextureFromBitmapL() - Image for texture 0x%x is \"%S\": w=%i, h=%i, dm=%i, mdm=%i"),

   814                texture,

   815                &texture->ImageFileName(),

   816                bitmapSize.iWidth,

   817                bitmapSize.iHeight,

   818                bitmap->DisplayMode(),

   819                (maskBitmap != NULL ? maskBitmap->DisplayMode() : ENone));

   820 

   821     UpdateFlags(*bitmap, maskBitmap, entry->iFlags);

   822     

   823 	if (bitmapSize.iWidth != 0 && bitmapSize.iHeight != 0)

   824 	    {

   825     	if (entry->iFlags & EHuiTextureFlagAllowDirectBitmapUsage) 

   826     		{

   827        		texture->UploadDirectL(*bitmap, maskBitmap, entry->iFlags);		

   828     		}

   829     	else 

   830     		{

   831        		texture->UploadL(*bitmap, maskBitmap, entry->iFlags);		

   832     		}

   833 	    }

   834     HUI_DEBUG2(_L("CHuiTextureManager::UpdateTextureFromBitmapL() - Finished with texture 0x%x, toc: %f seconds"), texture, CHuiStatic::Toc(2));

   835      

   836     // Store bits per pixel info to calculate texture memory usage

   837     entry->iBitDepth = TDisplayModeUtils::NumDisplayModeBitsPerPixel( bitmap->DisplayMode() );

   838     if (maskBitmap)

   839     	{

   840     	entry->iBitDepth = entry->iBitDepth + TDisplayModeUtils::NumDisplayModeBitsPerPixel( maskBitmap->DisplayMode() );

   841     	}

   842     

   843     if (maskBitmap)    

   844     	{

   845     	CleanupStack::PopAndDestroy(maskBitmap);   	

   846     	}

   847     	

   848     CleanupStack::PopAndDestroy(bitmap);        

   849     

   850     // Store provider in case it has changed

   851     if (aBitmapProvider)

   852     	{

   853     	entry->iBitmapProvider = aBitmapProvider;

   854     	}

   855    }

   856     

   857  

   858 void CHuiTextureManager::UpdateFlags(const CFbsBitmap& aBitmap, const CFbsBitmap* aMaskBitmap, 

   859 	                                 THuiTextureUploadFlags& aFlags)

   860 	{

   861 	// Update EHuiTextureFlagUseBitmapDirectly flag if needed

   862 	

   863 	if (aFlags & EHuiTextureFlagAllowDirectBitmapUsage)

   864 		{

   865 		TBool isDirectBitmapOk = !aBitmap.IsCompressedInRAM() && 

   866 		                     (!aMaskBitmap || !aMaskBitmap->IsCompressedInRAM());

   867 		// Check texture formats from the display

   868 		// Note: if there is no display the check cannot be done

   869 		if (isDirectBitmapOk)

   870 			{

   871 			isDirectBitmapOk = EFalse;		

   872 			if (CHuiStatic::Env().DisplayCount() > 0)

   873 				{

   874 				RPointerArray<CHuiDisplay::CTextureBitmapFormat> formatArray;

   875     			TInt err = CHuiStatic::Env().PrimaryDisplay().GetPreferredTextureFormats(formatArray);

   876     			if (!err)

   877     				{

   878     				for (TInt i = 0; i < formatArray.Count(); i++)

   879     					{

   880    			   			if ((aBitmap.DisplayMode() == formatArray[i]->iImage) &&

   881    			   				((!aMaskBitmap) || (aMaskBitmap->DisplayMode() == formatArray[i]->iMask)))

   882    			   				{

   883    			   				isDirectBitmapOk = ETrue;

   884    			   				}

   885     					}

   886 					}

   887 				formatArray.ResetAndDestroy();

   888 				}

   889 			}

   890 		// Update	

   891 		if (!isDirectBitmapOk)

   892 			{

   893    			aFlags = (THuiTextureUploadFlags)(aFlags & ~EHuiTextureFlagAllowDirectBitmapUsage);		

   894 			}

   895 		}

   896 	}

   897 

   898     

   899 RFs& CHuiTextureManager::FsSession() const

   900     {

   901     return iFS;

   902     }

   903 

   904 

   905 EXPORT_C void CHuiTextureManager::PrependImagePath(TDes& aFileName) const

   906     {

   907     TFileName buf;

   908 

   909     //allow app to load textures from different drive with complete path

   910     TParse p1;

   911     p1.Set(aFileName,0,0);

   912 

   913     if (p1.DrivePresent())

   914         {

   915         return;

   916         }

   917 

   918     if(aFileName.Find(*iImagePath) == KErrNotFound)

   919         {

   920         buf = *iImagePath;

   921         buf.Append(aFileName);

   922         aFileName = buf;

   923         }

   924     }

   925 

   926 

   927 EXPORT_C void CHuiTextureManager::UnloadTexture(const TDesC& aImageName, const TInt aFrameNumber)

   928     {

   929     TFileName fileName = aImageName;

   930     PrependImagePath(fileName);

   931     TInt index = CheckTexture(fileName, aFrameNumber);

   932     if (index >= 0)

   933         {

   934         HUI_DEBUG2(_L("CHuiTextureManager::UnloadTexture() - Unloading texture 0x%x (id: %i)."),

   935                    iTextures[index]->iTexture,

   936                    iTextures[index]->iId);

   937         DoUnload(index);

   938         return;

   939         }

   940     HUI_DEBUG1(_L("CHuiTextureManager::UnloadTexture() - Warning! Unable to unload \"%S\" - No such texture(s) found. Already unloaded?"), &fileName);

   941     }

   942 

   943 

   944 EXPORT_C void CHuiTextureManager::UnloadTexture(TInt aId)

   945     {

   946     TInt index = CheckTexture(aId);

   947     if (index >= 0)

   948         {

   949         HUI_DEBUG2(_L("CHuiTextureManager::UnloadTexture() - Unloading texture 0x%x (id: %i)."),

   950                    iTextures[index]->iTexture,

   951                    iTextures[index]->iId);

   952         DoUnload(index);

   953         return;

   954         }

   955     HUI_DEBUG1(_L("CHuiTextureManager::UnloadTexture() - Warning! Unable to unload id %i. No texture with such id. Already unloaded?"), aId);

   956     }

   957 

   958 

   959 EXPORT_C void CHuiTextureManager::DefineFileNameL(TInt aId,

   960                                                   const TDesC& aImageName)

   961     {

   962     if (aId==0)

   963         {

   964         HUI_DEBUG(_L("CHuiTextureManager::DefineFileNameL() - ERROR! Defining filename for texture id 0 is not allowed. Please use nonzero ids."));

   965         User::Leave(KErrArgument); // can't specify filename for "no id"

   966         }

   967 

   968     // Look for an existing entry for the id.

   969     for(TInt i = 0; i < iTextures.Count(); ++i)

   970         {

   971         if(iTextures[i]->iId == aId)

   972             {

   973             // Just set the new image name.

   974             iTextures[i]->SetFileName(aImageName);

   975             return;

   976             }

   977         }

   978 

   979     // create a new texture, which automatically registers a new

   980     // texture entry in the iTextures list.

   981     CHuiTexture::NewL();

   982     // we assume that the newest entry was added last

   983     CTextureEntry* entry = iTextures[iTextures.Count()-1];

   984     entry->iId = aId;

   985     entry->SetFileName(aImageName);

   986     }

   987 

   988 

   989 EXPORT_C TInt CHuiTextureManager::CheckTexture(const TDesC& aImageName, TInt aFrameNumber) const

   990     {

   991     if(aImageName.Length()==0)

   992         {

   993         // name empty, can't check

   994         return -1;

   995         }

   996     for(TInt i = 0; i < iTextures.Count(); ++i)

   997         {

   998         CTextureEntry * te = iTextures[i];

   999         // compare against texture manager entry filename (iFileName)

  1000         if((te->iFileName != NULL)

  1001             && (aImageName.Compare(*(te->iFileName)) == 0)

  1002             && te->iFrameNumber == aFrameNumber)

  1003             {

  1004             return i;

  1005             }

  1006 

  1007         // compare against texture object imagefilename

  1008         if( te->iTexture 

  1009             && te->iTexture->ImageFileName().Compare(aImageName) == 0

  1010             && te->iTexture->iFrameNumber == aFrameNumber)

  1011             {

  1012             return i;

  1013             }

  1014         }

  1015     // not found

  1016     return -1;

  1017     }

  1018 

  1019 

  1020 EXPORT_C TInt CHuiTextureManager::CheckTexture(TInt aId) const

  1021     {

  1022     if(aId == 0)

  1023         {

  1024         // id not defined, can't search

  1025         return -1;

  1026         }

  1027     for(TInt i = 0; i < iTextures.Count(); ++i)

  1028         {

  1029         if(iTextures[i]->iId == aId)

  1030             {

  1031             return i;

  1032             }

  1033         }

  1034     // not found:

  1035     return -1;

  1036     }

  1037 

  1038 

  1039 TBool CHuiTextureManager::IsInLoadQueue(const CHuiTexture * texture) const

  1040     {

  1041 

  1042     if (texture == NULL)

  1043         {

  1044         return EFalse;

  1045         }

  1046 

  1047     // textures in the load queue are not loaded yet,

  1048     // the others are assumed to be loaded..

  1049     for(TInt i = 0; i < iLoadQueue.Count(); ++i)

  1050         {

  1051         CTextureEntry* textureEntry = iLoadQueue[i].iLoading;

  1052         if(textureEntry->iTexture == texture)

  1053             {

  1054             // Still in the queue.

  1055             return ETrue;

  1056             }

  1057         }

  1058     return EFalse;

  1059     }

  1060 

  1061 TBool CHuiTextureManager::IsInLoadQueue(TInt id) const

  1062     {

  1063     // textures in the load queue are not loaded yet,

  1064     // the others are assumed to be loaded..

  1065     for(TInt i = 0; i < iLoadQueue.Count(); ++i)

  1066         {

  1067         if(iLoadQueue[i].iLoading->iId == id)

  1068             {

  1069             // Still in the queue.

  1070             return ETrue;

  1071             }

  1072         }

  1073     return EFalse;

  1074     }

  1075 

  1076 

  1077 void CHuiTextureManager::StartLoading()

  1078     {

  1079     // Start the texture load active object if we're not loading

  1080     if(iState == EIdle)

  1081         {

  1082         HUI_DEBUG(_L("CHuiTextureManager::StartLoading() - Starting load queue."));

  1083 

  1084         // loop that finds next entry to load

  1085         while (1)

  1086             {            

  1087             HUI_DEBUG(_L("CHuiTextureManager::StartLoading() - Find next to be loaded."));

  1088             

  1089             // try to schedule next image for loading..

  1090             TRAPD(err, DoLoadNextL());

  1091             // ok?

  1092                 

  1093             if(err != KErrNone)

  1094                 {

  1095                 HUI_DEBUG(_L("CHuiTextureManager::StartLoading() - Found an error."));

  1096                 

  1097                 HUI_ASSERT(iLoadQueue.Count()>0);

  1098                 // remove the entry from the queue

  1099                 SLoadQueueEntry entry = PopLoadedQueueEntry();

  1100                 switch (err)

  1101                     {

  1102                     case KErrNoMemory:

  1103                         {

  1104                         HUI_DEBUG3( _L("CHuiTextureManager::StartLoading() - Unable to start loading \"%S\" (id %i): Out of memory. Trying to continue with %i items in the queue.."), &(entry.iLoading->iTexture->ImageFileName()), entry.iLoading->iId, iLoadQueue.Count());

  1105                         break;

  1106                         }

  1107                     default:

  1108                         {

  1109                         HUI_DEBUG4( _L("CHuiTextureManager::StartLoading() - Unable to start loading \"%S\" (id %i): Leave error code %i. Trying to continue with %i items in the queue.."), &(entry.iLoading->iTexture->ImageFileName()), entry.iLoading->iId, err, iLoadQueue.Count());

  1110                         break;

  1111                         }

  1112                     }

  1113                 // Notify observers about the image loading error

  1114                 NotifyTextureLoaded(*entry.iLoading->iTexture, entry.iLoading->iId, err);

  1115                 // Image loading has been completed.

  1116                 iState = EIdle;

  1117                 continue;

  1118                 }

  1119             else

  1120                 {

  1121                 HUI_DEBUG(_L("CHuiTextureManager::StartLoading() - Found next texture to load."));

  1122                 if(iLoadQueue.Count() == 0 && iLoadQueueHadValidTexture)

  1123                     {

  1124                     // During the load loop that has passed we have succesfully started to load

  1125                     // at least one texture. So the state has been changed to ELoading, thus

  1126                     // it is now changed back to EIdle.

  1127                     NotifyStateChange();

  1128                     iLoadQueueHadValidTexture = EFalse;

  1129                     }

  1130                 }

  1131                 

  1132             // leave the loop if we had no trouble scheduling the next

  1133             // image decode

  1134             break;