skins/AknSkins/srvinc/AknsSrvChunkMaintainer.h
changeset 0 05e9090e2422
equal deleted inserted replaced
-1:000000000000 0:05e9090e2422
       
     1 /*
       
     2 * Copyright (c) 2002-2008 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:  Chunk maintainer.
       
    15 *
       
    16 */
       
    17 
       
    18 
       
    19 #ifndef AKNSSRVCHUNKMAINTAINER_H
       
    20 #define AKNSSRVCHUNKMAINTAINER_H
       
    21 
       
    22 // INCLUDES
       
    23 
       
    24 #include <e32std.h>
       
    25 #include <e32base.h>
       
    26 
       
    27 #include <AknsSrvClient.h>
       
    28 #include "AknsSrvItemDef.h"
       
    29 #include "AknsSrvExclusion.h"
       
    30 
       
    31 // CONSTANTS
       
    32 
       
    33 // The shared memory chunk name
       
    34 _LIT(KAKNSSRVSHAREDMEMORYCHUNKNAME, "AknsSrvSharedMemoryChunk");
       
    35 // The shared memory chunk protection semaphore
       
    36 _LIT(KAKNSSRVWAITSEMAPHORENAME, "AknsSrvWaitSemaphore");
       
    37 // Rendering mutex
       
    38 _LIT(KAKNSSRVRENDERMUTEXNAME, "AknsSrvRenderSemaphore");
       
    39 
       
    40 static const TInt KAknsSrvMaxFileNameLen = 512;
       
    41 
       
    42 // DATA TYPES
       
    43 
       
    44 /**
       
    45 * Header area offsets.
       
    46 * Valid only for enhanced skins implementation.
       
    47 */
       
    48 enum TAknsSrvHeaderAreaOffsets
       
    49     {
       
    50     EAknsSrvItemDefAreaBaseOffset               = 0,
       
    51     EAknsSrvItemDefAreaAllocatedSizeOffset      = 1,
       
    52     EAknsSrvItemDefAreaCurrentSizeOffset        = 2,
       
    53     EAknsSrvDataAreaBaseOffset                  = 3,
       
    54     EAknsSrvDataAreaAllocatedSizeOffset         = 4,
       
    55     EAknsSrvDataAreaCurrentSizeOffset           = 5,
       
    56     EAknsSrvFilenameAreaBaseOffset              = 6,
       
    57     EAknsSrvFilenameAreaAllocatedSizeOffset     = 7,
       
    58     EAknsSrvFilenameAreaCurrentSizeOffset       = 8,
       
    59     EAknsSrvScalableGfxAreaBaseOffset           = 9,
       
    60     EAknsSrvScalableGfxAreaAllocatedSizeOffset  = 10,
       
    61     EAknsSrvScalableGfxAreaCurrentSizeOffset    = 11,
       
    62     EAknsSrvItemDefHashBaseOffset               = 12,
       
    63     EAknsSrvItemDefHashAllocatedSizeOffset      = 13,
       
    64     EAknsSrvItemDefHashCurrentSizeOffset        = 14
       
    65     };
       
    66 
       
    67 /**
       
    68 * Base area names.
       
    69 * Valid only for enhanced skins implementation.
       
    70 */
       
    71 enum TAknsSrvBaseAreaName
       
    72     {
       
    73     EAknsSrvItemDefArea     = 0,
       
    74     EAknsSrvDataArea        = 1,
       
    75     EAknsSrvFilenameArea    = 2,
       
    76     EAknsSrvScalableGfxArea = 4,
       
    77     EAknsSrvItemDefHash     = 5
       
    78     };
       
    79 
       
    80 /**
       
    81 * Post operation types.
       
    82 * Valid only for enhanced skins implementation.
       
    83 *
       
    84 * @internal
       
    85 */
       
    86 enum TAknsSrvCMPostOpType
       
    87     {
       
    88     EAknsSrvCMPOTTileX          = 0,
       
    89     EAknsSrvCMPOTTileY          = 1,
       
    90     EAknsSrvCMPOTTileToStretch  = 2
       
    91     };
       
    92 
       
    93 /**
       
    94 * Hash Table data structure.
       
    95 */
       
    96 struct TAknsSrvHashTable
       
    97     {
       
    98     TInt iHead;
       
    99     };
       
   100 
       
   101 
       
   102 /**
       
   103 * Post operation data structure.
       
   104 * Valid only for enhanced skins implementation.
       
   105 */
       
   106 struct TAknsSrvCMPostOp
       
   107     {
       
   108     public: // Data
       
   109         TAknsSrvCMPostOpType iType;
       
   110         TAknsItemID iIID;
       
   111 
       
   112     public:
       
   113         static TInt LinearOrder(
       
   114             const TAknsSrvCMPostOp& aFirst,
       
   115             const TAknsSrvCMPostOp& aSecond );
       
   116     };
       
   117 
       
   118 class MAknsSrvMorphingListener
       
   119 {
       
   120     public:
       
   121         virtual void MorhphingEventTimeout() = 0;
       
   122 };
       
   123 
       
   124 class CAknsSrvMorphingTimer : public CActive
       
   125     {
       
   126     public:
       
   127         static CAknsSrvMorphingTimer* NewL(MAknsSrvMorphingListener* aListener, TInt aInterval);
       
   128         void RunL();
       
   129         void DoCancel();
       
   130         void IssueRequest();
       
   131         ~CAknsSrvMorphingTimer();
       
   132 
       
   133     protected:
       
   134         void ConstructL();
       
   135         CAknsSrvMorphingTimer(MAknsSrvMorphingListener* aListener, TInt aInterval);
       
   136     private:
       
   137         MAknsSrvMorphingListener* iListener;
       
   138         TInt iInterval;
       
   139         RTimer iTimer;
       
   140     };
       
   141 
       
   142 // FORWARD DECLARATIONS
       
   143 
       
   144 class CAknsSrvFileBuffer;
       
   145 class CAknsSrvBitmapStore;
       
   146 
       
   147 // CLASS DECLARATIONS
       
   148 
       
   149 /**
       
   150 * Internal class for maintaining the shared memory chunk in the skin server.
       
   151 *
       
   152 * @since 2.0
       
   153 */
       
   154 NONSHARABLE_CLASS(CAknsSrvChunkMaintainer) : public CBase
       
   155     {
       
   156 
       
   157     public: // Construction and destruction
       
   158         /**
       
   159         * Default C++ constructor
       
   160         */
       
   161         CAknsSrvChunkMaintainer(CAknsSrvBitmapStore* aBitmapStore);
       
   162 
       
   163         /**
       
   164         * Destructor.
       
   165         */
       
   166         ~CAknsSrvChunkMaintainer();
       
   167 
       
   168     public: // New methods
       
   169 
       
   170         /**
       
   171         * Reads normal skin (non ROM) definitions to the shared memory chunk.
       
   172         *
       
   173         * @since 2.0
       
   174         *
       
   175         * @param aUid Uid of the skin file to read
       
   176         *
       
   177         * @param aClass Which class should be merged.
       
   178         *
       
   179         * @param aClearChunk A boolean value to specify
       
   180         *        if to discard existing content in the shared
       
   181         *        chunk
       
   182         *
       
   183         * @param aExclQuery Exclusion query object.
       
   184         */
       
   185         void MergeSkinDefinitionsL( const TPtrC& aFilename,
       
   186             const TAknsItemDefClass aClass, const TBool aClearChunk,
       
   187             const TAknsSrvExclusionQuery& aExclQuery,
       
   188             const TBool aAhOverride,
       
   189             const TAknsPkgID& aPID );
       
   190 
       
   191         /**
       
   192         * Set the idle state wallpaper.
       
   193         *
       
   194         * @since 2.0
       
   195         *
       
   196         * @param aIID the item id of the idle wallpaper.
       
   197         * @param aFilename the filename of the wallpaper mbm-file(incl. path)
       
   198         * @param aIndex of the bitmap in the mbm file
       
   199         */
       
   200         void SetWallpaper( const TAknsItemID& aIID,
       
   201             const TDesC& aFilename, TInt aIndex );
       
   202 
       
   203         /**
       
   204         * Blocks read acces to the shared memory chunk
       
   205         * maintained by this class.
       
   206         *
       
   207         * @since 2.0
       
   208         */
       
   209         void BeginWrite();
       
   210 
       
   211         /**
       
   212         * Allows write acces to the shared memory chunk
       
   213         * maintained by this class.
       
   214         *
       
   215         * @since 2.0
       
   216         */
       
   217         void EndWrite();
       
   218 
       
   219         /**
       
   220         *
       
   221         */
       
   222         void ResetLevel();
       
   223 
       
   224         /**
       
   225         *
       
   226         */
       
   227         void NextLevel();
       
   228 
       
   229         /**
       
   230         * Checks whether the given IID should be altered (i.e. is it in
       
   231         * the skin package internal number space or in exclusion list),
       
   232         * and modifies it accordingly.
       
   233         *
       
   234         * @since 2.0
       
   235         *
       
   236         * @param aIID Item ID to be checked and modified, if necessary.
       
   237         *
       
   238         * @param aExclQuery Exclusion query object.
       
   239         */
       
   240         void CheckAndModifyIID( TAknsItemID& aIID,
       
   241             const TAknsSrvExclusionQuery& aExclQuery );
       
   242 
       
   243     private: // New methods
       
   244 
       
   245         /**
       
   246         * The actual merge function for normal (non ROM) skins.
       
   247         *
       
   248         * @since 2.0
       
   249         *
       
   250         * @param aFilename the skin file name
       
   251         * @param aClearChunk A boolean value to specify
       
   252         *        if to discard existing content in the shared
       
   253         *        chunk
       
   254         * @param aExclQuery Exclusion query object.
       
   255         * @param aAhOverride specifies if the data to be merged is
       
   256         *   A&H override.
       
   257         *
       
   258         * @par Exceptions:
       
   259         *    If merge operation fails, leaves with an error code.
       
   260         */
       
   261         void MergeSkinDefinitionsUnprotectedL( const TDesC& aFilename,
       
   262             const TBool aClearChunk, const TAknsSrvExclusionQuery& aExclQuery,
       
   263             const TBool aAhOverride,
       
   264             const TAknsPkgID& aPID );
       
   265 
       
   266         /**
       
   267         * The merge function for (non ROM) skins.
       
   268         * Calls @c MergeSkinDefinitionsUnprotectedL to do the actual merge
       
   269         * to avoid fatal errors.
       
   270         *
       
   271         * @since 2.0
       
   272         *
       
   273         * @param aFile File buffer of the skin file to read from.
       
   274         * @param aOffset The file offset to read from .
       
   275         * @param aClass Which class should be merged.
       
   276         * @param aExclQuery Exclusion query object.
       
   277         * @param aAhOverride Specified if the skin file to be merged is an
       
   278         *   A&H variant.
       
   279         *
       
   280         * @par Exceptions:
       
   281         *    If merge fails, leaves with an error code.
       
   282         */
       
   283         void DoMergeSkinDefinitionsL( CAknsSrvFileBuffer& file,
       
   284             const TUint aOffset, const TAknsItemDefClass aClass,
       
   285             const TAknsSrvExclusionQuery& aExclQuery,
       
   286             const TBool aAhOverride );
       
   287 
       
   288     private: // New methods - Type-specific merging
       
   289 
       
   290         /**
       
   291         * Merge a single bitmap definition.
       
   292         */
       
   293         void DoMergeBitmapDefinitionL( CAknsSrvFileBuffer& aFile,
       
   294             const TUint aOffset, const TAknsItemDefClass aClass,
       
   295             const TAknsSrvExclusionQuery& aExclQuery,
       
   296             const TBool aAhOverride );
       
   297 
       
   298         /**
       
   299         * Merge a single color table definition.
       
   300         */
       
   301         void DoMergeColorTableDefinitionL( CAknsSrvFileBuffer& aFile,
       
   302             const TUint aOffset, const TAknsItemDefClass aClass,
       
   303             const TAknsSrvExclusionQuery& aExclQuery,
       
   304             const TBool aAhOverride );
       
   305 
       
   306         /**
       
   307         * Merge a single image table definition.
       
   308         */
       
   309         void DoMergeImageTableDefinitionL( CAknsSrvFileBuffer& aFile,
       
   310             const TUint aOffset, const TAknsItemDefClass aClass,
       
   311             const TAknsSrvExclusionQuery& aExclQuery,
       
   312             const TBool aAhOverride );
       
   313 
       
   314         /**
       
   315         * Merge a single bitmap animation definition.
       
   316         */
       
   317         void DoMergeBmpAnimDefinitionL( CAknsSrvFileBuffer& aFile,
       
   318             const TUint aOffset, const TAknsItemDefClass aClass,
       
   319             const TAknsSrvExclusionQuery& aExclQuery,
       
   320             const TBool aAhOverride );
       
   321 
       
   322         /**
       
   323         * Merge a single string definition.
       
   324         */
       
   325         void DoMergeStringDefinitionL( CAknsSrvFileBuffer& aFile,
       
   326             const TUint aOffset, const TAknsItemDefClass aClass,
       
   327             const TAknsSrvExclusionQuery& aExclQuery,
       
   328             const TBool aAhOverride );
       
   329 
       
   330     private: // New methods - Chunk content utilities
       
   331 
       
   332         /**
       
   333         * Retrieves the index of an item definition in the table.
       
   334         *
       
   335         * @since 2.0
       
   336         *
       
   337         * @param aIID Item ID to be searched for.
       
   338         *
       
   339         * @return The index of the item definition, or -1 if not found.
       
   340         */
       
   341         TInt FindDefIndex( const TAknsItemID& aIID );
       
   342 
       
   343         /**
       
   344         * Replaces or appends an item definition into the table located
       
   345         *   in the shared chunk. Also updates the data area.
       
   346         *
       
   347         * @since 2.0
       
   348         *
       
   349         * @param aDef Pointer to the item definition to be updated.
       
   350         *   No ownership is claimed.
       
   351         *
       
   352         * @param aData Definition data.
       
   353         *
       
   354         * @param aDataSize The size of the definition data.
       
   355         */
       
   356         void UpdateDef( const TAknsSrvDef* aDef, const TAny* aData,
       
   357             const TInt aDataSize, const TInt aOldDataSize );
       
   358 
       
   359         /**
       
   360         * Replaces or appends data to the data area of the shared chunk.
       
   361         *
       
   362         * @since 2.0
       
   363         *
       
   364         * @param aData Pointer to the new content. No ownership is claimed.
       
   365         *   If @c NULL is given, only space is allocated.
       
   366         *
       
   367         * @param aDataSize Size of the new content.
       
   368         *
       
   369         * @param aOldData Pointer to the old content, or @c NULL.
       
   370         *
       
   371         * @param aOldDataSize Size of the old content.
       
   372         *
       
   373         * @return Offset of the new data location in the shared chunk.
       
   374         */
       
   375         TInt UpdateData( const TAny* aData, const TInt aDataSize,
       
   376             TAny* aOldData = 0, const TInt aOldDataSize = 0 );
       
   377 
       
   378         void UpdateDefHash ( TAknsSrvDef* aDef );
       
   379         
       
   380         /**
       
   381         * Initializes the shared chunk header and clears the allocated memory
       
   382         *
       
   383         * @since 2.8
       
   384         *
       
   385         */
       
   386         void InitializeChunk();
       
   387 
       
   388         /**
       
   389         * Aligns the given value by 4
       
   390         *
       
   391         * @since 2.8
       
   392         *
       
   393         * @param aValue the value to align
       
   394         *
       
   395         * @return the aligned value
       
   396         */
       
   397         TInt AlignToFour(const TInt aValue);
       
   398 
       
   399     public: // New methods - Scalable version
       
   400 
       
   401         /**
       
   402         *
       
   403         * @since 2.8
       
   404         */
       
   405         void StoreScalableGraphicsL( const TAknsItemID& aIID,
       
   406             const TInt aType, const TSize& aLayoutSize,
       
   407             TInt aBmpHandle, TInt aMskHandle, TBool aIsMorphing = EFalse);
       
   408 
       
   409         /**
       
   410         *
       
   411         * @since 2.8
       
   412         */
       
   413         void ClearScalableGraphics(TAknsSrcScreenMode aMode);
       
   414 
       
   415         /**
       
   416         *
       
   417         * @since 3.0
       
   418         */
       
   419         void ClearMorphedGraphics();
       
   420         void RemoveSingleScalableItem(const TAknsItemID& aIID );
       
   421         /**
       
   422         *
       
   423         * @since 3.0
       
   424         */
       
   425         void CreateMorphingTimerL(MAknsSrvMorphingListener* aListener);
       
   426         void UpdateMorphingTime();
       
   427     private: // New methods - Scalable version
       
   428 
       
   429         /**
       
   430         *
       
   431         * @since 2.8
       
   432         */
       
   433         void DoMergeEffectQueueL( CAknsSrvFileBuffer& aFile,
       
   434             const TUint aOffset, const TAknsItemDefClass aClass,
       
   435             const TAknsSrvExclusionQuery& aExclQuery,
       
   436             const TBool aAhOverride);
       
   437 
       
   438         /**
       
   439         * @return The total size of parameters, in bytes.
       
   440         *
       
   441         * @since 3.0
       
   442         */
       
   443         TUint32 DoMergeParamsL( CAknsSrvFileBuffer& aFile,
       
   444                                 const TUint aOffset,
       
   445                                 TUint32& aEqBase,
       
   446                                 RPointerArray<TUint8>& aParamArray,
       
   447                                 const TUint16 aParamCount );
       
   448         /**
       
   449         * @return The total size of param groups, in bytes.
       
   450         *
       
   451         * @since 3.0
       
   452         */
       
   453         TUint32 DoMergeParamGroupsL( CAknsSrvFileBuffer& aFile,
       
   454                                      const TUint aOffset,
       
   455                                      TUint32& aBase,
       
   456                                      RPointerArray<TUint8>& aGroupArray,
       
   457                                      const TUint16 aGroupCount );
       
   458         /**
       
   459         * @return The total size of effect commands, in bytes.
       
   460         *
       
   461         * @since 3.0
       
   462         */
       
   463         TUint32 DoMergeEffectCommandsL( CAknsSrvFileBuffer& aFile,
       
   464                                         const TUint aOffset,
       
   465                                         TUint32& aEqBase,
       
   466                                         RPointerArray<TUint8>& aEffectArray,
       
   467                                         const TUint16 aEffectCount );
       
   468         /**
       
   469         * @since 3.0
       
   470         */
       
   471         void DoMergeAnimationL( CAknsSrvFileBuffer& aFile,
       
   472                                 const TUint aOffset,
       
   473                                 const TAknsItemDefClass aClass,
       
   474                                 const TAknsSrvExclusionQuery& aExclQuery,
       
   475                                 const TBool aAhOverride );
       
   476 
       
   477         /**
       
   478         *
       
   479         * @since 2.8
       
   480         */
       
   481         void UpdateFilename(TInt32 aFilenameID, TUint8* aFilenamePtr,
       
   482             TUint16 aFilenameLen,  const TDesC& aBaseFilename );
       
   483 
       
   484         /**
       
   485         *
       
   486         * @since 2.8
       
   487         */
       
   488         TInt8* GetAreaBasePtr( TAknsSrvBaseAreaName aAreaname);
       
   489 
       
   490         /**
       
   491         *
       
   492         * @since 2.8
       
   493         */
       
   494         TInt GetAreaAllocatedSize( TAknsSrvBaseAreaName aAreaname );
       
   495 
       
   496         /**
       
   497         *
       
   498         * @since 2.8
       
   499         */
       
   500         TInt GetAreaCurrentSize( TAknsSrvBaseAreaName aAreaname );
       
   501 
       
   502         /**
       
   503         *
       
   504         * @since 2.8
       
   505         */
       
   506         void AdjustAreaAllocatedSize(
       
   507             TAknsSrvBaseAreaName aAreaname, TInt aNewSize );
       
   508 
       
   509         /**
       
   510         *
       
   511         * @since 2.8
       
   512         */
       
   513         void SetAreaCurrentSize(
       
   514             TAknsSrvBaseAreaName aAreaname, TInt aNewSize );
       
   515 
       
   516         /**
       
   517         *
       
   518         * @since 2.8
       
   519         */
       
   520         TInt GetFilenameOffsetByID( TInt32 aID );
       
   521 
       
   522         /**
       
   523         *
       
   524         * @since 2.8
       
   525         */
       
   526         TInt ProcessChunksL(CAknsSrvFileBuffer& aFile, TUint32 aFileOffset,
       
   527             TUint32 aChunkCount, const TDesC& aFilename,
       
   528             const TAknsSrvExclusionQuery& aExclQuery, const TBool aMirrored);
       
   529 
       
   530         /**
       
   531         *
       
   532         * @since 2.8
       
   533         */
       
   534         TInt HandleFilenameChunkL(CAknsSrvFileBuffer& aFile,
       
   535             TUint32 aFileOffset, const TDesC& aFilename);
       
   536 
       
   537         /**
       
   538         *
       
   539         * @since 2.8
       
   540         */
       
   541         TInt HandleClassChunkL(CAknsSrvFileBuffer& aFile, TUint32 aFileOffset,
       
   542             const TAknsSrvExclusionQuery& aExclQuery);
       
   543 
       
   544         /**
       
   545         *
       
   546         * @since 2.8
       
   547         */
       
   548         TInt HandleLangOverrideChunkL(CAknsSrvFileBuffer& aFile,
       
   549             TUint32 aFileOffset);
       
   550 
       
   551         /**
       
   552         *
       
   553         * @since 2.8
       
   554         */
       
   555         TInt HandleWallpaperChunkL(CAknsSrvFileBuffer& aFile,
       
   556             TUint32 aFileOffset);
       
   557 
       
   558         /**
       
   559         * Handles 2.6 release restriction chunk.
       
   560         *
       
   561         * @since 2.8
       
   562         */
       
   563         TInt Handle26RelRestrictionChunkL(CAknsSrvFileBuffer& aFile,
       
   564             TUint32 aFileOffset, const TDesC& aFilename,
       
   565             const TAknsSrvExclusionQuery& aExclQuery, const TBool aMirrored);
       
   566 
       
   567         /**
       
   568         * Handles generic release restriction chunk.
       
   569         *
       
   570         * @since 2.8
       
   571         */
       
   572         TInt HandleGenericRelRestrictionChunkL(CAknsSrvFileBuffer& aFile,
       
   573             TUint32 aFileOffset, const TDesC& aFilename,
       
   574             const TAknsSrvExclusionQuery& aExclQuery, const TBool aMirrored);
       
   575 
       
   576         /**
       
   577         *
       
   578         * @since 2.8
       
   579         */
       
   580         TInt HandleLangRestrictionChunkL(CAknsSrvFileBuffer& aFile,
       
   581             TUint32 aFileOffset, const TDesC& aFilename,
       
   582             const TAknsSrvExclusionQuery& aExclQuery, const TBool aMirrored);
       
   583 
       
   584         /**
       
   585         *
       
   586         * @since 3.1
       
   587         */
       
   588         TInt HandleInformationChunkL(CAknsSrvFileBuffer& aFile,
       
   589             TUint32 aFileOffset, const TDesC& aFilename);
       
   590 
       
   591 
       
   592         /**
       
   593         *
       
   594         * @since 2.8
       
   595         */
       
   596         void EnqueuePostOperationL( const TAknsSrvCMPostOpType aType,
       
   597             const TAknsItemID aIID );
       
   598 
       
   599         /**
       
   600         * Executes post operations.
       
   601         *
       
   602         * @since 2.8
       
   603         */
       
   604         void ExecutePostOperations();
       
   605 
       
   606         /**
       
   607         * Utility function for post operation execution.
       
   608         * Changes tiling attribute from generic to X/Y specific.
       
   609         *
       
   610         * @since 2.8
       
   611         */
       
   612         void PostOpTile( TAknsSrvCMPostOp& op, TAknsSrvDef* itemDef );
       
   613 
       
   614         /**
       
   615         * Reads an attribute chunk.
       
   616         *
       
   617         * @since 2.8
       
   618         */
       
   619         void ReadAttributeChunkL( CAknsSrvFileBuffer& aFile,
       
   620             const TUint aOffset, TInt& aAttributes, TInt& aAlignment,
       
   621             TInt& aCoordX, TInt& aCoordY, TInt& aSizeW, TInt& aSizeH );
       
   622 
       
   623     private: // Data
       
   624 
       
   625         RChunk iSharedChunk;
       
   626         RSemaphore iWaitSema;
       
   627         TInt iInternalSemaCount;
       
   628         TInt iMergingLevel;
       
   629 
       
   630     private: // Data - Scalable version
       
   631         RMutex iRenderMutex;
       
   632         TInt iCurrentFilenameID;
       
   633         TInt iFilenameCount;
       
   634         TInt iMorphingMinInterval;
       
   635         CAknsSrvMorphingTimer* iMorphingTimer;
       
   636         CAknsSrvBitmapStore* iBitmapStore;
       
   637         RArray<TAknsSrvCMPostOp> iPostOpArray;
       
   638         HBufC16* iBitmapPath;
       
   639         TUint iPlatformMajor;
       
   640         TUint iPlatformMinor;
       
   641         TBool iMergeS60Skin;
       
   642     };
       
   643 
       
   644 #endif // AKNSSRVCHUNKMAINTAINER_H
       
   645 
       
   646 // End of file.