1 /*

     2 * Copyright (c) 2009 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:

    15 *

    16 */

    17 

    18 // INCLUDE FILES

    19 

    20 #include <xcfwtree.h>

    21 #include <xcfwengine.h>

    22 #include <pathinfo.h>

    23 #include <f32file.h>

    24 #include <sysutil.h>

    25 #include "menueng.h"

    26 #include "menuengobjectfactoryproxy.h"

    27 #include "menuengobject.h"

    28 #include "menuengobserver.h"

    29 #include "menuengoperation.h"

    30 #include "menuengfilter.h"

    31 #include "menuengvisitor.h"

    32 #include "menuengitemlister.h"

    33 #include "menuengdeletionchecker.h"

    34 #include "menuengidmanagerinit.h"

    35 #include "menuengidsetter.h"

    36 #include "menuengidmanager.h"

    37 #include "menuengidcollector.h"

    38 #include "menuengflags.h"

    39 #include "mcsmenuitem.h" // for flags

    40 

    41 // CONSTANTS

    42 

    43 LOCAL_D const TInt KDriveAndColon = 2; //drive letter and colon, e.g. "c:"

    44 _LIT( KMenuTypeIdSeed, "menu:id_seed" );

    45 _LIT( KMenuAttrIdSeed, "seed" );

    46 _LIT( KMenuContentDirName, "content\\" );

    47 _LIT( KMenuContentExtension, ".xml" );

    48 _LIT( KMenuTempExtension, ".$$$" );

    49 

    50 // ================= LOCAL FUNCTIONS =======================

    51 

    52 /**

    53 * Insert string into other string, checking vaailable space.

    54 * Leaves with KErrOverflow if aSoure cannot be inserted to aTarget.

    55 * @param aTarget Target descriptor.

    56 * @param aPos Insertion point.

    57 * @param aSource Source descriptor.

    58 */

    59 LOCAL_C void InsertL( TDes& aTarget, TInt aPos, const TDesC& aSource )

    60     {

    61     if ( aTarget.MaxLength() < aTarget.Length() + aSource.Length() )

    62         {

    63         User::Leave( KErrOverflow );

    64         }

    65     aTarget.Insert( aPos, aSource );

    66     }

    67 

    68 /**

    69 * Append string to the end of other string, checking available space.

    70 * Leaves with KErrOverflow if aSource cannot be appended to aTarget.

    71 * @param aTarget Target descriptor.

    72 * @param aSource Source descriptor.

    73 */

    74 LOCAL_C void AppendL( TDes& aTarget, const TDesC& aSource )

    75     {

    76     if ( aTarget.MaxLength() < aTarget.Length() + aSource.Length() )

    77         {

    78         User::Leave( KErrOverflow );

    79         }

    80     aTarget.Append( aSource );

    81     }

    82 

    83 // ================= MEMBER FUNCTIONS =======================

    84 

    85 // ---------------------------------------------------------

    86 // CMenuEng::Object

    87 // ---------------------------------------------------------

    88 //

    89 CMenuEngObject& CMenuEng::Object( MXCFWNode& aNode ) const

    90     {

    91     return (CMenuEngObject&)(*aNode.Data());

    92     }

    93 

    94 // ---------------------------------------------------------

    95 // CMenuEng::~CMenuEng

    96 // ---------------------------------------------------------

    97 //

    98 EXPORT_C CMenuEng::~CMenuEng()

    99     {

   100     Cancel();

   101     CancelAllOperations();

   102     iOperations.Close();

   103     iNotifyQueue.Close();

   104     delete iEngine;

   105     delete iTree;

   106     delete iObjectFactory;

   107     delete iIdManager;

   108     iFs.Close();

   109     iName.Close();

   110     iTempFileName.Close();

   111     iRamFileName.Close();

   112     delete iActiveWait;

   113     }

   114 

   115 // ---------------------------------------------------------

   116 // CMenuEng::NewL

   117 // ---------------------------------------------------------

   118 //

   119 EXPORT_C CMenuEng* CMenuEng::NewL

   120 ( const TDesC& aName, MMenuEngObserver& aObserver )

   121     {

   122     CMenuEng* eng = new (ELeave) CMenuEng( aObserver );

   123     CleanupStack::PushL( eng );

   124     eng->ConstructL( aName );

   125     CleanupStack::Pop( eng );

   126     return eng;

   127     }

   128 

   129 // ---------------------------------------------------------

   130 // CMenuEng::CMenuEng

   131 // ---------------------------------------------------------

   132 //

   133 CMenuEng::CMenuEng( MMenuEngObserver& aObserver )

   134 : CActive( CActive::EPriorityStandard ), iObserver( aObserver )

   135     {

   136     CActiveScheduler::Add( this );

   137     iLegacyFormat = EFalse;

   138     }

   139 

   140 // ---------------------------------------------------------

   141 // CMenuEng::ConstructL

   142 // ---------------------------------------------------------

   143 //

   144 void CMenuEng::ConstructL( const TDesC& aName )

   145     {

   146     ValidateNameL( aName );

   147     iName.CreateL( aName );

   148     User::LeaveIfError( iFs.Connect() );

   149     // Keep temp file and the RAM file name as members -

   150     // we use these all the time.

   151     TFileName fname;

   152     GetFileNameL( fname, ETempFile );

   153     iTempFileName.CreateL( fname );

   154     GetFileNameL( fname, ERamFile );

   155     iRamFileName.CreateL( fname );

   156     iObjectFactory = CMenuEngObjectFactoryProxy::NewL( *this );

   157     iEngine = CXCFWEngine::NewL( this );

   158     iEngine->RegisterObjectFactoryL( iObjectFactory );

   159     SelfComplete( KErrNone ); 	// Start processing asynchronously.

   160     ActiveWaitForFileLoadL();	//we need to wait until parsing is complete

   161     }

   162 

   163 // ---------------------------------------------------------

   164 // CMenuEng::QueueOperationL

   165 // ---------------------------------------------------------

   166 //

   167 EXPORT_C void CMenuEng::QueueOperationL( MMenuEngOperation& aOperation )

   168     {

   169     __ASSERT_DEBUG( KErrNotFound == iOperations.Find( &aOperation ), \

   170                     User::Invariant() );

   171     iOperations.AppendL( &aOperation );

   172     // If idle, kick back into life.

   173     if ( EReady == iState )

   174         {

   175         iState = EExecuteOp;

   176         SelfComplete( KErrNone );

   177         }

   178     }

   179 

   180 // ---------------------------------------------------------

   181 // CMenuEng::DequeueOperation

   182 // ---------------------------------------------------------

   183 //

   184 EXPORT_C void CMenuEng::DequeueOperation( MMenuEngOperation& aOperation )

   185     {

   186     if ( iCurrentOperation == &aOperation )

   187         {

   188         iCurrentOperation = NULL;

   189         }

   190     TInt i = iOperations.Find( &aOperation );

   191     if ( KErrNotFound != i )

   192         {

   193         iOperations.Remove( i );

   194         }

   195     }

   196 

   197 // ---------------------------------------------------------

   198 // CMenuEng::TraverseFolderL

   199 // ---------------------------------------------------------

   200 //

   201 EXPORT_C void CMenuEng::TraverseFolderL

   202 ( TInt aFolder, MMenuEngVisitor& aVisitor ) const

   203     {

   204     if ( !iTree )

   205         {

   206         User::Leave( KErrNotReady );

   207         }

   208     TraverseNodeL( FolderNodeL( aFolder ), aVisitor );

   209     }

   210 

   211 // ---------------------------------------------------------

   212 // CMenuEng::NewObjectL

   213 // ---------------------------------------------------------

   214 //

   215 EXPORT_C CMenuEngObject* CMenuEng::NewObjectL( const TDesC& aType )

   216     {

   217     if ( !iIdManager )

   218         {

   219         User::Leave( KErrNotReady );

   220         }

   221     CMenuEngObject* object = CMenuEngObject::NewL( *this, aType );

   222     CleanupStack::PushL( object );

   223     TInt id;

   224     iIdManager->AllocL( id );

   225     object->SetId( id );

   226     CleanupStack::Pop( object );

   227     return object;

   228     }

   229 

   230 // ---------------------------------------------------------

   231 // CMenuEng::RootFolderL

   232 // ---------------------------------------------------------

   233 //

   234 EXPORT_C void CMenuEng::RootFolderL( TInt& aId ) const

   235     {

   236     if ( !iTree )

   237         {

   238         User::Leave( KErrNotReady );

   239         }

   240     aId = iRoot;

   241     }

   242 

   243 // ---------------------------------------------------------

   244 // CMenuEng::ParentFolderL

   245 // ---------------------------------------------------------

   246 //

   247 EXPORT_C void CMenuEng::ParentFolderL( TInt aId, TInt& aParentId ) const

   248     {

   249     if ( !iTree )

   250         {

   251         User::Leave( KErrNotReady );

   252         }

   253     TInt parentId = 0;

   254     if ( aId != iRoot )

   255         {

   256         // We may have nodes above the root, but do not allow access to those.

   257         // Say 0 to the root's parent.

   258         MXCFWNode* parentNode = NodeL( aId ).Parent();

   259         if ( parentNode )

   260             {

   261             parentId = Object( *parentNode ).Id();

   262             }

   263         }

   264     aParentId = parentId;

   265     }

   266 

   267 // ---------------------------------------------------------

   268 // CMenuEng::GetItemL

   269 // ---------------------------------------------------------

   270 //

   271 EXPORT_C void CMenuEng::GetItemL( TInt aId, TMenuItem& aItem ) const

   272     {

   273     if ( !iTree )

   274         {

   275         User::Leave( KErrNotReady );

   276         }

   277     const CMenuEngObject& object = ObjectL( aId );

   278     aItem.SetId( object.Id() );

   279     aItem.SetFlags( object.Flags() );

   280     aItem.SetType( object.Type() );

   281     TInt parent;

   282     ParentFolderL( aId, parent );

   283     aItem.SetParent( parent );

   284     }

   285 

   286 // ---------------------------------------------------------

   287 // CMenuEng::GetItemsL

   288 // ---------------------------------------------------------

   289 //

   290 EXPORT_C void CMenuEng::GetItemsL(

   291         RArray<TMenuItem>& aItemArray,

   292         TInt aFolder,

   293         const MMenuEngFilter* aFilter,

   294         TBool aRecursive ) const

   295     {

   296     if ( !iTree )

   297         {

   298         User::Leave( KErrNotReady );

   299         }

   300     TMenuEngItemLister lister

   301         ( *this, aItemArray, aFolder, aFilter, aRecursive );

   302     TraverseFolderL( aFolder, lister );

   303     }

   304 

   305 // ---------------------------------------------------------

   306 // CMenuEng::ObjectL

   307 // ---------------------------------------------------------

   308 //

   309 EXPORT_C const CMenuEngObject& CMenuEng::ObjectL( TInt aId ) const

   310     {

   311     if ( !iTree )

   312         {

   313         User::Leave( KErrNotReady );

   314         }

   315     return Object( NodeL( aId ) );

   316     }

   317 

   318 // ---------------------------------------------------------

   319 // CMenuEng::GetLegacyFormat

   320 // ---------------------------------------------------------

   321 //

   322 EXPORT_C TBool CMenuEng::GetOnceLegacyFormat()

   323     {

   324     TBool format = iLegacyFormat;

   325     iLegacyFormat = EFalse;

   326     return format;

   327     }

   328 

   329 // ---------------------------------------------------------

   330 // CMenuEng::RemoveL

   331 // ---------------------------------------------------------

   332 //

   333 EXPORT_C void CMenuEng::RemoveL( TInt aId )

   334     {

   335 	if ( SysUtil::DiskSpaceBelowCriticalLevelL( &iFs, 0, EDriveC) )

   336 		{

   337 		User::Leave( KErrDiskFull );

   338 		}

   339     if ( iState != EExecuteOp )

   340         {

   341         User::Leave( KErrLocked );

   342         }

   343     // Check if aId exists.

   344     MXCFWNode& node = NodeL( aId );

   345     // Can't delete the root.

   346     if ( aId == iRoot )

   347         {

   348         User::Leave( KErrAccessDenied );

   349         }

   350     // Can't delete read-only items, or folders containing any read-only items.

   351     TMenuEngDeletionChecker checker;

   352     TraverseNodeL( node, checker );

   353     // Get the IDs of items to be deleted.

   354     RArray<TInt> deletedIds;

   355     CleanupClosePushL( deletedIds );

   356     TMenuEngIdCollector idCollector( deletedIds );

   357     TraverseNodeL( node, idCollector );

   358     // Add notification event.

   359     MXCFWNode* parent = node.Parent();

   360     __ASSERT_DEBUG( parent, User::Invariant() );

   361     AppendNotifyL( Object( *parent ).Id(),

   362                    RMenuNotifier::EItemsAddedRemoved );

   363     // Delete node.

   364     iTree->RemoveNodeL( &node );

   365     iChanged = ETrue;

   366     // Deletion successful, remove the IDs.

   367     for ( TInt i = 0; i < deletedIds.Count(); i++ )

   368         {

   369         iIdManager->Remove( deletedIds[i] );

   370         }

   371     CleanupStack::PopAndDestroy( &deletedIds );

   372     }

   373 

   374 // ---------------------------------------------------------

   375 // CMenuEng::MoveToFolderL

   376 // ---------------------------------------------------------

   377 //

   378 EXPORT_C void CMenuEng::MoveToFolderL

   379 ( RArray<TInt>& aItems, TInt aFolder, TInt aMoveBefore )

   380     {

   381 	if ( SysUtil::DiskSpaceBelowCriticalLevelL( &iFs, 0, EDriveC) )

   382 		{

   383 		User::Leave( KErrDiskFull );

   384 		}

   385     if ( iState != EExecuteOp )

   386         {

   387         User::Leave( KErrLocked );

   388         }

   389     TInt i;

   390     TInt id;

   391     MXCFWNode* fromFolder = NULL;

   392     // Check that toFolder exists.

   393     MXCFWNode& toFolder = FolderNodeL( aFolder );

   394     CMenuEngObject& toFolderObj = Object( toFolder );

   395     // Check that we can move items into target toFolder.

   396     if ( toFolderObj.Flags() & TMenuItem::ELockMoveInto )

   397         {

   398         User::Leave( KErrAccessDenied );

   399         }

   400     // Check that all items exist and they are not locked against moving.

   401     // Also check that and they are in the same toFolder.

   402     if ( aItems.Count() )

   403         {

   404         fromFolder = NodeL( aItems[0] ).Parent();

   405         for ( i = 0; i< aItems.Count(); i++ )

   406             {

   407             id = aItems[i];

   408             if ( id == iRoot )

   409                 {

   410                 User::Leave( KErrAccessDenied ); // Can't move the root.

   411                 }

   412             MXCFWNode& node = NodeL( id );

   413             if ( Object( node ).Flags() & TMenuItem::ELockItem )

   414                 {

   415                 User::Leave( KErrAccessDenied ); // lock_item

   416                 }

   417             if ( node.Parent() != fromFolder )

   418                 {

   419                 User::Leave( KErrArgument ); // Items from different folders.

   420                 }

   421             }

   422         // Add notification events. Presume that there will be no recursion.

   423         // If there is recursion, then we make an unnecessary notify, that is

   424         // better than missing one.

   425         __ASSERT_DEBUG( fromFolder, User::Invariant() );

   426         AppendNotifyL( Object( *fromFolder ).Id(),

   427                        RMenuNotifier::EItemsAddedRemoved );

   428         AppendNotifyL( toFolderObj.Id(),

   429                        RMenuNotifier::EItemsAddedRemoved );

   430         // Do move the items.

   431         // Recursion check is done by the XML tree (->KErrArgument).

   432         MXCFWNode* moveBefore = Child( toFolder, aMoveBefore );

   433         for ( i = 0; i < aItems.Count(); i++ )

   434             {

   435             iTree->MoveNodeL( &NodeL( aItems[i] ), &toFolder, moveBefore );

   436             }

   437         iChanged = ETrue;

   438         }

   439     }

   440 

   441 // ---------------------------------------------------------

   442 // CMenuEng::ReorderL

   443 // ---------------------------------------------------------

   444 //

   445 EXPORT_C void CMenuEng::ReorderL( TInt aId, TInt aMoveBefore )

   446     {

   447 	if ( SysUtil::DiskSpaceBelowCriticalLevelL( &iFs, 0, EDriveC) )

   448 		{

   449 		User::Leave( KErrDiskFull );

   450 		}

   451     if ( iState != EExecuteOp )

   452         {

   453         User::Leave( KErrLocked );

   454         }

   455     // Can't reorder the root.

   456     if ( aId == iRoot )

   457         {

   458         User::Leave( KErrArgument );

   459         }

   460     // Check if aId exists.

   461     MXCFWNode& node = NodeL( aId );

   462     // Check if item can be reordered.

   463     if ( Object( node ).Flags() & TMenuItem::ELockItem )

   464         {

   465         User::Leave( KErrAccessDenied ); // lock_item

   466         }

   467     MXCFWNode* parent = node.Parent();

   468     __ASSERT_DEBUG( parent, User::Invariant() );

   469     if ( parent )

   470         {

   471         // Add notification event.

   472         AppendNotifyL( Object( *parent ).Id(),

   473                        RMenuNotifier::EItemsReordered );

   474         // Move it.

   475         MXCFWNode* moveBefore = Child( *parent, aMoveBefore );

   476         iTree->MoveNodeL( &node, parent, moveBefore );

   477         iChanged = ETrue;

   478         }

   479     }

   480 

   481 // ---------------------------------------------------------

   482 // CMenuEng::AddL

   483 // ---------------------------------------------------------

   484 //

   485 EXPORT_C void CMenuEng::AddL

   486 ( CMenuEngObject& aObject, TInt aFolder, TInt aInsertBefore )

   487     {

   488 	if ( SysUtil::DiskSpaceBelowCriticalLevelL( &iFs, 0, EDriveC) )

   489 		{

   490 		User::Leave( KErrDiskFull );

   491 		}

   492     if ( &aObject.Engine() != this )

   493         {

   494         // ID integrity requires that objects are bound to engines.

   495         User::Leave( KErrArgument );

   496         }

   497     if ( iState != EExecuteOp )

   498         {

   499         User::Leave( KErrLocked );

   500         }

   501     if ( KMenuTypeData() == aObject.Type() )

   502         {

   503         // Internal type, disallow.

   504         User::Leave( KErrArgument );

   505         }

   506     // Check if aFolder exists.

   507     MXCFWNode& folder = FolderNodeL( aFolder );

   508     // Check if folder is locked.

   509     if ( Object( folder ).Flags() & TMenuItem::ELockMoveInto )

   510         {

   511         User::Leave( KErrAccessDenied ); // lock_moveinto

   512         }

   513     // Add notification event.

   514     AppendNotifyL( aFolder, RMenuNotifier::EItemsAddedRemoved );

   515     // Add the node.

   516     MXCFWNode* insertBefore = Child( folder, aInsertBefore );

   517     if ( insertBefore )

   518         {

   519         iTree->AddNodeL( &aObject, &folder, insertBefore );

   520         // No leaving after this point - ownership of aObject taken by the

   521         // tree. (Well, almost -- CXCFWTree is buggy, but hopefully it will

   522         // be fixed.)

   523         }

   524     else

   525         {

   526         // CXCFWTree API design flaw:

   527         // AddNodeL( &aObject, &folder, NULL ) leaves with KErrArgument!

   528         iTree->AddNodeL( &aObject, &folder );

   529         // No leaving after this point - ownership of aObject taken by the

   530         // tree. (Well, almost -- CXCFWTree is buggy, but hopefully it will

   531         // be fixed.)

   532         }

   533     iChanged = ETrue;

   534     }

   535 

   536 // ---------------------------------------------------------

   537 // CMenuEng::ModifiableObjectL

   538 // ---------------------------------------------------------

   539 //

   540 EXPORT_C CMenuEngObject& CMenuEng::ModifiableObjectL( TInt aId , TInt aEvent)

   541     {

   542     if ( !iTree )

   543         {

   544         User::Leave( KErrNotReady );

   545         }

   546     if ( iState != EExecuteOp )

   547         {

   548         User::Leave( KErrLocked );

   549         }

   550     MXCFWNode& node = NodeL( aId );

   551     CMenuEngObject& object = Object( node );

   552     // Add notification event.

   553     MXCFWNode* parent = node.Parent();

   554     __ASSERT_DEBUG( parent, User::Invariant() );

   555     if( aEvent != RMenuNotifier::EItemsNone )

   556     	{

   557     	AppendNotifyL( Object( *parent ).Id(), aEvent );

   558     	}

   559     iChanged = ETrue; // Might not be true, but how could we know?

   560     // Note1: We must presume that this object will actually be changed

   561     // because we haven't any information what is being done to it!

   562     // If the object had a back-pointer to the engine, this could

   563     // be solved, but that would be a BAD THING to do.

   564     // Note2: other possible solution is to drop this method and invent

   565     // something else to allow item data update.

   566     return object;

   567     }

   568 

   569 

   570 	

   571 // ---------------------------------------------------------

   572 // CMenuEng::AppendNotifyL

   573 // ---------------------------------------------------------

   574 //

   575 EXPORT_C void CMenuEng::AppendNotifyL( TInt aFolder, TInt aEvents )

   576     {

   577     for ( TInt i = 0; i < iNotifyQueue.Count(); i++ )

   578         {

   579         if ( iNotifyQueue[i].iFolder == aFolder )

   580             {

   581             iNotifyQueue[i].iEvents |= aEvents;

   582             return;

   583             }

   584         }

   585     iNotifyQueue.AppendL( TMenuEngNotify( aFolder, aEvents ) );

   586     }

   587 

   588 // ---------------------------------------------------------

   589 // CMenuEng::NodeL

   590 // ---------------------------------------------------------

   591 //

   592 EXPORT_C TBool CMenuEng::Exist( TInt aId ) const

   593     {

   594     MXCFWNode* node = NULL;

   595     const RNodeArray& nodes = iTree->Nodes();

   596     for ( TInt i = 0; i < nodes.Count(); i++ )

   597         {

   598         node = nodes[i];

   599         if ( aId == Object( *node ).Id() )

   600             {

   601             return ETrue;

   602             }

   603         }

   604     return EFalse;

   605     }

   606 // ---------------------------------------------------------

   607 // CMenuEng::RunL

   608 // ---------------------------------------------------------

   609 //

   610 void CMenuEng::RunL()

   611     {

   612     switch( iState )

   613         {

   614         case ENull:

   615             {

   616             // Self-completion in ConstructL(). Load RAM tree.

   617             __ASSERT_DEBUG( !iStatus.Int(), User::Invariant() );

   618             iState = ELoadRamFile;

   619             LoadRamFileL();

   620             break;

   621             }

   622 

   623         case ELoadRamFile:

   624             {

   625             if ( iStatus.Int() )

   626                 {

   627                 // Error loading RAM tree -> Try ROM tree.

   628                 iObserver.EngineTreeReloaded();

   629                 iState = ELoadRomFile;

   630                 LoadRomFileL();

   631                 }

   632             else

   633                 {

   634                 // Tree loaded OK. Start processing operations.

   635                 iState = EExecuteOp;

   636                 ExecuteOperationL();

   637                 }

   638             break;

   639             }

   640 

   641         case ELoadRomFile:

   642             {

   643             // Error loading ROM tree is fatal. Nothing we can do.

   644             User::LeaveIfError( iStatus.Int() );

   645             iState = ESaveFile;

   646             SaveTempFileL();

   647             break;

   648             }

   649 

   650         case ESaveFile:

   651             {

   652             // Error saving tree is fatal. Nothing we can do.

   653             User::LeaveIfError( iStatus.Int() );

   654             // Tree saved to temp file OK. Replace content file with temp file.

   655             ReplaceRamFileL();

   656             // Saving completed succesfully.

   657             iChanged = EFalse;

   658             // If there is a current operation, this is the final result.

   659             CompleteCurrentOperation( iStatus.Int() );

   660             // Start next operation.

   661             iState = EExecuteOp;

   662             ExecuteOperationL();

   663             break;

   664             }

   665 

   666         case EExecuteOp:

   667             {

   668             // Start next operation.

   669             __ASSERT_DEBUG( !iStatus.Int(), User::Invariant() );

   670             ExecuteOperationL();

   671             break;

   672             }

   673 

   674         case EReady:

   675         case EDead:

   676         default:

   677             {

   678             User::Invariant();

   679             }

   680         }

   681     }

   682 

   683 // ---------------------------------------------------------

   684 // CMenuEng::DoCancel

   685 // ---------------------------------------------------------

   686 //

   687 void CMenuEng::DoCancel()

   688     {

   689     // We don't have real requests, only self-completion; which is already

   690     // completed.

   691     }

   692 

   693 // ---------------------------------------------------------

   694 // CMenuEng::RunError

   695 // ---------------------------------------------------------

   696 //

   697 TInt CMenuEng::RunError( TInt aError )

   698     {

   699     switch( iState )

   700         {

   701         case ENull:

   702             {

   703             User::Invariant(); // Self-completion cannot fail.

   704             break;

   705             }

   706 

   707         case ELoadRamFile:

   708             {

   709             // Error loading RAM tree -> keep going (try ROM tree).

   710             SelfComplete( aError );

   711             break;

   712             }

   713 

   714         case ELoadRomFile:

   715             {

   716             // Error loading ROM tree is fatal. Nothing we can do.

   717             // stop nested active scheduler loop if error in parsing

   718             if ( iActiveWait->IsStarted() )

   719                 {

   720                 iActiveWait->AsyncStop();

   721                 }  

   722                 

   723             iState = EDead;

   724             iObserver.EngineError( aError );

   725             // Can't delete the tree now, XCFW Engine keeps a pointer to it

   726             // and still uses it even after reporting the error. :(

   727          

   728             break;

   729             }

   730 

   731         case ESaveFile:

   732             {

   733             // File is too big and cannot be saved, delete it

   734             // and try reading from rom

   735             if (iStatus.Int() == KErrNoMemory)

   736             	{

   737             	iState = ELoadRamFile;

   738             	SelfComplete( aError );

   739             	}

   740             else {

   741 				// Error saving tree is fatal. Nothing we can do.

   742 				// If there is a current operation, this is the final result.

   743 				CompleteCurrentOperation( aError );

   744 				iState = EDead;

   745 				iObserver.EngineError( aError );

   746             }

   747             // Can't delete the tree now, XCFW Engine keeps a pointer to it

   748             // and still uses it even after reporting the error. :(

   749             break;

   750             }

   751 

   752         case EExecuteOp:

   753             {

   754             // Current operation failed.

   755             CompleteCurrentOperation( aError );

   756             // Continue with next operation.

   757             SelfComplete( KErrNone );

   758             break;

   759             }

   760 

   761         case EReady:

   762         case EDead:

   763         default:

   764             {

   765             User::Invariant();

   766             }

   767         }

   768     return KErrNone;

   769     }

   770 

   771 // ---------------------------------------------------------

   772 // CMenuEng::HandleEngineEventL

   773 // ---------------------------------------------------------

   774 //

   775 void CMenuEng::HandleEngineEventL( TXCFWEngineEvent aEvent )

   776     {

   777     switch ( aEvent )

   778         {

   779         case EEvtParsingComplete:

   780             {

   781             __ASSERT_DEBUG( iTree, User::Invariant() );

   782 

   783             // parsing operation complete

   784             // we can stop nested active scheduler loop

   785             if ( iActiveWait->IsStarted() )

   786                 {

   787                 iActiveWait->AsyncStop();

   788                 }         

   789             

   790             TBool legacyFormat = iObjectFactory->IsLegacyFormat();                        

   791             // Reset object factory in all cases.

   792             iObjectFactory->Reset();

   793             // Tree is up (maybe unsaved yet).

   794             // Check the structure and get the root folder node.

   795             MXCFWNode& rootNode = CheckTreeL( *iTree );

   796             // Init ID manager, check and fix ID-s.

   797             InitIdManagerL( rootNode );

   798             // Now we have ID for all (including the root).

   799             iRoot = Object( rootNode ).Id();

   800             // This is the earliest point to do an ID sanity check.

   801             __ASSERT_DEBUG( DebugSanityCheck( *iTree ), User::Invariant() );

   802             // Send a "wildcard" notification so everybody reloads.

   803             iObserver.EngineEvents( 0, RMenuNotifier::EItemsAddedRemoved );

   804             iLegacyFormat = legacyFormat;

   805             SelfComplete( KErrNone ); // Go to RunL().

   806             break;

   807             }

   808 

   809         case EEvtSavingComplete:

   810             {

   811             //iLegacyFormat = EFalse;

   812             SelfComplete( KErrNone ); // Go to RunL().

   813             break;

   814             }

   815 

   816         case EEvtParsingCanceled:

   817         case EEvtSavingCanceled:

   818             {

   819             // Reset object factory in all cases.

   820             iObjectFactory->Reset();

   821             SelfComplete( KErrCancel ); // Go to RunL().

   822             break;

   823             }

   824 

   825         case EEvtParsingStarted:

   826         case EEvtSavingStarted:

   827         case EEvtNull:

   828         default:

   829             {

   830             break;

   831             }

   832         }

   833     }

   834 

   835 // ---------------------------------------------------------

   836 // CMenuEng::HandleEngineErrorL

   837 // ---------------------------------------------------------

   838 //

   839 void CMenuEng::HandleEngineErrorL( TInt aErrorCode )

   840     {

   841     // Reset object factory in all cases.

   842     iObjectFactory->Reset();

   843 

   844     SelfComplete( aErrorCode ); // Go to RunL().

   845     }

   846 

   847 // ---------------------------------------------------------

   848 // CMenuEng::CheckTreeL

   849 // ---------------------------------------------------------

   850 //

   851 MXCFWNode& CMenuEng::CheckTreeL( MXCFWTree& aTree ) const

   852     {

   853     MXCFWNode* rootFolder = NULL;

   854     MXCFWNode* treeRoot = aTree.Root();

   855     if ( treeRoot )

   856         {

   857         // The tree has nodes.

   858         if ( KMenuTypeData() == Object( *treeRoot ).Type() )

   859             {

   860             // Root node is "menu:data"

   861             RNodeArray nodes;

   862             CleanupClosePushL( nodes );

   863             aTree.GetNodesOfTypeL( KMenuTypeFolder(), nodes,

   864                                     treeRoot, EFalse );

   865             if ( 1 == nodes.Count() )

   866                 {

   867                 // Exactly 1 "menu:folder" in the root.

   868                 // This is the root folder.

   869                 rootFolder = nodes[0];

   870                 }

   871             CleanupStack::PopAndDestroy( &nodes );

   872             }

   873         }

   874     if ( !rootFolder )

   875         {

   876         User::Leave( KErrCorrupt );

   877         }

   878     return *rootFolder;

   879     }

   880 

   881 // ---------------------------------------------------------

   882 // CMenuEng::DebugSanityCheck

   883 // ---------------------------------------------------------

   884 //

   885 TBool CMenuEng::DebugSanityCheck( MXCFWTree& aTree ) const

   886     {

   887     const RNodeArray& nodes = aTree.Nodes();

   888     for ( TInt i = 0; i < nodes.Count(); i++ )

   889         {

   890         if ( !DebugSanityCheck( *nodes[i] ) )

   891             {

   892             return EFalse;

   893             }

   894         }

   895     return ETrue;

   896     }

   897 

   898 // ---------------------------------------------------------

   899 // CMenuEng::ActiveWaitForLoadFileL

   900 // ---------------------------------------------------------

   901 //

   902 void CMenuEng::ActiveWaitForFileLoadL()

   903     {

   904     iActiveWait = new( ELeave ) CActiveSchedulerWait();

   905     if ( !iActiveWait->IsStarted() )

   906         {

   907         iActiveWait->Start();

   908         }

   909     //now we check if file was properly loaded

   910     TInt root(0);

   911     RootFolderL( root );

   912     if( !root && ( iState != EDead ) )

   913     	{

   914     	//there was problem with Ram file(probably file was empty), lets load Rom file

   915     	iState = ELoadRamFile;

   916         if ( !iActiveWait->IsStarted() )

   917             {

   918             iActiveWait->Start();

   919             }

   920     	}

   921     }

   922 

   923 // ---------------------------------------------------------

   924 // CMenuEng::DebugSanityCheck

   925 // ---------------------------------------------------------

   926 //

   927 TBool CMenuEng::DebugSanityCheck( MXCFWNode& aNode ) const

   928     {

   929     __ASSERT_DEBUG( iRoot, User::Invariant() );

   930     // Sanity check, for node location and ID.

   931     // - Nodes under the root folder (==items) should have non-0 ID.

   932     // - Nodes not under the root folder (==other stuff like id_seed) should

   933     //   always have 0 id.

   934     // This is crucial for the ID space integrity. XCFW node lookup uses

   935     // a flat list of nodes; the only way we can differentiate items from

   936     // non-items is the ID.

   937     MXCFWNode* node;

   938     for ( node = &aNode; node; node = node->Parent() )

   939         {

   940         if ( Object( *node ).Id() == iRoot )

   941             {

   942             // The node is, or descendant of, the root folder. Must have an ID.

   943             return 0 != Object( aNode ).Id();

   944             }

   945         }

   946     // Node is not under the root folder. Must not have an ID.

   947     return 0 == Object( aNode ).Id();

   948     }

   949 

   950 // ---------------------------------------------------------

   951 // CMenuEng::NodeL

   952 // ---------------------------------------------------------

   953 //

   954 MXCFWNode& CMenuEng::NodeL( TInt aId ) const

   955     {

   956     __ASSERT_DEBUG( iTree, User::Invariant() );

   957     if ( !aId )

   958         {

   959         // We can actually have 0 id node (outside the item tree), but

   960         // those are not items.

   961         User::Leave( KErrNotFound );

   962         }

   963     MXCFWNode* node = NULL;

   964     const RNodeArray& nodes = iTree->Nodes();

   965     for ( TInt i = 0; i < nodes.Count(); i++ )

   966         {

   967         node = nodes[i];

   968         if ( aId == Object( *node ).Id() )

   969             {

   970             __ASSERT_DEBUG( DebugSanityCheck( *node ), User::Invariant() );

   971             return *node;

   972             }

   973         }

   974     User::Leave( KErrNotFound );

   975     /* NOTREACHED */

   976     return *node;

   977     }

   978 

   979 // ---------------------------------------------------------

   980 // CMenuEng::FolderNodeL

   981 // ---------------------------------------------------------

   982 //

   983 MXCFWNode& CMenuEng::FolderNodeL( TInt aId ) const

   984     {

   985     __ASSERT_DEBUG( iTree, User::Invariant() );

   986     MXCFWNode& node = NodeL( aId );

   987     if ( KMenuTypeFolder() == Object( node ).Type() )

   988         {

   989         return node;

   990         }

   991     User::Leave( KErrNotFound );

   992     /* NOTREACHED */

   993     return node;

   994     }

   995 

   996 // ---------------------------------------------------------

   997 // CMenuEng::Child

   998 // ---------------------------------------------------------

   999 //

  1000 

  1001 MXCFWNode* CMenuEng::Child( MXCFWNode& aParent, TInt aId )

  1002     {

  1003     MXCFWNode* node;

  1004     for ( node = aParent.FirstChild(); node; node = node->NextSibling() )

  1005         {

  1006         if ( Object( *node ).Id() == aId )

  1007             {

  1008             break;

  1009             }

  1010         }

  1011     return node;

  1012     }

  1013 

  1014 // ---------------------------------------------------------

  1015 // CMenuEng::CancelAllOperations

  1016 // ---------------------------------------------------------

  1017 //

  1018 void CMenuEng::CancelAllOperations()

  1019     {

  1020     // For safety, we remove pointers before completion.

  1021     // (OperationCompleted might want to remove operation too, avoid

  1022     // conflict.)

  1023     MMenuEngOperation* operation;

  1024     if ( iCurrentOperation )

  1025         {

  1026         operation = iCurrentOperation;

  1027         iCurrentOperation = NULL;

  1028         operation->CompletedMenuEngOperation( KErrCancel );

  1029         }

  1030     while ( iOperations.Count() )

  1031         {

  1032         operation = iOperations[0];

  1033         iOperations.Remove( 0 );

  1034         operation->CompletedMenuEngOperation( KErrCancel );

  1035         }

  1036     }

  1037 

  1038 // ---------------------------------------------------------

  1039 // CMenuEng::ValidateNameL

  1040 // ---------------------------------------------------------

  1041 //

  1042 void CMenuEng::ValidateNameL( const TDesC& aName )

  1043     {

  1044     // We only accept alphanumeric characters and underscore as content

  1045     // file name. This is stricter than the (current) file system

  1046     // restriction, for future-proofing reasons.

  1047     if ( !aName.Length() )

  1048         {

  1049         User::Leave( KErrArgument );

  1050         }

  1051     for ( TInt i = 0; i < aName.Length(); i++ )

  1052         {

  1053         TChar c =  aName[i];

  1054         if ( !c.IsAlphaDigit() && '_' != c )

  1055             {

  1056             User::Leave( KErrArgument );

  1057             }

  1058         }

  1059     }

  1060 

  1061 // ---------------------------------------------------------

  1062 // CMenuEng::GetFileNameL

  1063 // ---------------------------------------------------------

  1064 //

  1065 void CMenuEng::GetFileNameL( TFileName& aFname, TFile aSelector )

  1066     {

  1067     User::LeaveIfError( iFs.PrivatePath( aFname ) );

  1068     if ( ERomFile == aSelector )

  1069         {

  1070         InsertL(

  1071             aFname,

  1072             0,

  1073             PathInfo::RomRootPath().Left( KDriveAndColon ) );

  1074         }

  1075     else

  1076         {

  1077         InsertL(

  1078             aFname,

  1079             0,

  1080             PathInfo::PhoneMemoryRootPath().Left( KDriveAndColon ) );

  1081         }

  1082     AppendL( aFname, KMenuContentDirName );

  1083     AppendL( aFname, iName );

  1084     AppendL( aFname, ETempFile == aSelector ?

  1085         KMenuTempExtension : KMenuContentExtension );

  1086     }

  1087 

  1088 // ---------------------------------------------------------

  1089 // CMenuEng::TraverseNodeL

  1090 // ---------------------------------------------------------

  1091 //

  1092 TBool CMenuEng::TraverseNodeL

  1093 ( MXCFWNode& aNode, MMenuEngVisitor& aVisitor ) const

  1094     {

  1095     CMenuEngObject& object = Object( aNode );

  1096     if ( KMenuTypeFolder() == object.Type() )

  1097         {

  1098         if ( aVisitor.VisitEnterL( object ) )

  1099             {

  1100             // Recursion is used - menu data tree is not very deep.

  1101             MXCFWNode* node = aNode.FirstChild();

  1102             while( node && TraverseNodeL( *node, aVisitor ) )

  1103                 {

  1104                 node = node->NextSibling();

  1105                 }

  1106             }

  1107         // countChildren( object );

  1108         return aVisitor.VisitLeaveL( object );

  1109         }

  1110     else

  1111         {

  1112         return aVisitor.VisitL( object );

  1113         }

  1114     }

  1115 

  1116 // ---------------------------------------------------------

  1117 // CMenuEng::InitIdManagerL

  1118 // ---------------------------------------------------------

  1119 //

  1120 void CMenuEng::InitIdManagerL( MXCFWNode& aRootNode )

  1121     {

  1122     __ASSERT_DEBUG( !iIdManager, User::Invariant() );

  1123     __ASSERT_DEBUG( iTree, User::Invariant() );

  1124     iIdManager = new (ELeave) CMenuEngIdManager();

  1125     TInt idSeed;

  1126     GetIdSeedL( idSeed );

  1127     iIdManager->SetSeed( idSeed );

  1128     // Read ID-s to ID manager.

  1129     TMenuEngIdManagerInit idManagerInit( *iIdManager );

  1130     TraverseNodeL( aRootNode, idManagerInit );

  1131     // Make sure all nodes have ID.

  1132     TMenuEngIdSetter idSetter( *iIdManager );

  1133     TraverseNodeL( aRootNode, idSetter ); 

  1134     }