1 /*

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

    15 *

    16 */

    17 

    18 // System includes

    19 #include <AknUtils.h>

    20 #include <AknsWallpaperUtils.h>

    21 #include <AknSkinsInternalCRKeys.h>

    22 #include <StringLoader.h>

    23 #include <xnuiengine.rsg>

    24 #include <aknnotewrappers.h>

    25 

    26 #if 0 // MSK icon change

    27 #include <AknsConstants.h>

    28 #include <avkon.mbg>

    29 #endif // MSK icon change

    30 

    31 // User includes

    32 #include "xnapplication.h"

    33 #include "xnuiengine.h"

    34 #include "xnproperty.h"

    35 #include "xndomnode.h"

    36 #include "xndomlist.h"

    37 #include "xnnode.h"

    38 #include "xncomposer.h"

    39 #include "xneditor.h"

    40 #include "xnrootdata.h"

    41 #include "xnviewdata.h"

    42 #include "xnappuiadapter.h"

    43 #include "xncontroladapter.h"

    44 #include "xnviewnodeimpl.h"

    45 #include "xnviewadapter.h"

    46 #include "xnodt.h"

    47 #include "xndomdocument.h"

    48 #include "xntype.h"

    49 #include "xntext.h"

    50 #include "xnpanic.h"

    51 #include "xnmenu.h"

    52 #include "xnmenuadapter.h"

    53 #include "xncomponentnodeimpl.h"

    54 #include "xnnodepluginif.h"

    55 #include "xnoomsyshandler.h"

    56 

    57 // Constants

    58 _LIT8( KEmptyWidgetUid, "0x2001f47f" );

    59 _LIT8( KViewSwitcherText, "switcher_text" );

    60 _LIT8( KStateError, "Error" );

    61 _LIT8( KMax, "max" );

    62 

    63 _LIT8( KTemplateViewUID, "0x20026f50" );

    64 

    65 enum

    66     {

    67     EFirstPassDrawComplete,

    68     EDataPluginsComplete,

    69     EViewIsValid,       

    70     };

    71 

    72 const TInt KMinPages = 1;

    73 

    74 

    75 #if 0 // MSK icon change

    76 

    77 const TInt KIconIds[] = {

    78         EMbmAvkonQgnQgn_home_page_11,

    79         EMbmAvkonQgnQgn_home_page_21,

    80         EMbmAvkonQgnQgn_home_page_22,

    81         EMbmAvkonQgnQgn_home_page_31,

    82         EMbmAvkonQgnQgn_home_page_32,

    83         EMbmAvkonQgnQgn_home_page_33,

    84         EMbmAvkonQgnQgn_home_page_41,

    85         EMbmAvkonQgnQgn_home_page_42,

    86         EMbmAvkonQgnQgn_home_page_43,

    87         EMbmAvkonQgnQgn_home_page_44,

    88         EMbmAvkonQgnQgn_home_page_51,

    89         EMbmAvkonQgnQgn_home_page_52,

    90         EMbmAvkonQgnQgn_home_page_53,

    91         EMbmAvkonQgnQgn_home_page_54,

    92         EMbmAvkonQgnQgn_home_page_55,

    93         EMbmAvkonQgnQgn_home_page_61,

    94         EMbmAvkonQgnQgn_home_page_62,

    95         EMbmAvkonQgnQgn_home_page_63,

    96         EMbmAvkonQgnQgn_home_page_64,

    97         EMbmAvkonQgnQgn_home_page_65,

    98         EMbmAvkonQgnQgn_home_page_66

    99         };

   100 

   101 const TInt KMaskIds[] = {

   102         EMbmAvkonQgnQgn_home_page_11_mask,

   103         EMbmAvkonQgnQgn_home_page_21_mask,

   104         EMbmAvkonQgnQgn_home_page_22_mask,

   105         EMbmAvkonQgnQgn_home_page_31_mask,

   106         EMbmAvkonQgnQgn_home_page_32_mask,

   107         EMbmAvkonQgnQgn_home_page_33_mask,

   108         EMbmAvkonQgnQgn_home_page_41_mask,

   109         EMbmAvkonQgnQgn_home_page_42_mask,

   110         EMbmAvkonQgnQgn_home_page_43_mask,

   111         EMbmAvkonQgnQgn_home_page_44_mask,

   112         EMbmAvkonQgnQgn_home_page_51_mask,

   113         EMbmAvkonQgnQgn_home_page_52_mask,

   114         EMbmAvkonQgnQgn_home_page_53_mask,

   115         EMbmAvkonQgnQgn_home_page_54_mask,

   116         EMbmAvkonQgnQgn_home_page_55_mask,

   117         EMbmAvkonQgnQgn_home_page_61_mask,

   118         EMbmAvkonQgnQgn_home_page_62_mask,

   119         EMbmAvkonQgnQgn_home_page_63_mask,

   120         EMbmAvkonQgnQgn_home_page_64_mask,

   121         EMbmAvkonQgnQgn_home_page_65_mask,

   122         EMbmAvkonQgnQgn_home_page_66_mask

   123         };

   124 

   125 const TAknsItemID KSkinIds[] = {            

   126         KAknsIIDQgnHomePage11,

   127         KAknsIIDQgnHomePage21,

   128         KAknsIIDQgnHomePage22,

   129         KAknsIIDQgnHomePage31,

   130         KAknsIIDQgnHomePage32,

   131         KAknsIIDQgnHomePage33,

   132         KAknsIIDQgnHomePage41,

   133         KAknsIIDQgnHomePage42,

   134         KAknsIIDQgnHomePage43,

   135         KAknsIIDQgnHomePage44,

   136         KAknsIIDQgnHomePage51,

   137         KAknsIIDQgnHomePage52,

   138         KAknsIIDQgnHomePage53,

   139         KAknsIIDQgnHomePage54,

   140         KAknsIIDQgnHomePage55,

   141         KAknsIIDQgnHomePage61,

   142         KAknsIIDQgnHomePage62,

   143         KAknsIIDQgnHomePage63,

   144         KAknsIIDQgnHomePage64,

   145         KAknsIIDQgnHomePage65,

   146         KAknsIIDQgnHomePage66

   147         };

   148 

   149 #endif // MSK icon change

   150 

   151 

   152 // ============================ LOCAL FUNCTIONS ===============================

   153 

   154 

   155 // -----------------------------------------------------------------------------

   156 // BuildTriggerL

   157 // Builds a trigger node

   158 // -----------------------------------------------------------------------------

   159 //

   160 static CXnNode* BuildTriggerL( CXnUiEngine& aUiEngine,

   161     const TDesC8& aStringValue )

   162     {

   163     CXnNode* node = CXnNode::NewL();

   164     CleanupStack::PushL( node );

   165 

   166     CXnType* type = CXnType::NewL( XnPropertyNames::action::KTrigger );

   167     CleanupStack::PushL( type );

   168 

   169     CXnNodeImpl* impl = CXnNodeImpl::NewL( type );

   170     CleanupStack::Pop( type );

   171 

   172     node->SetImpl( impl );

   173     node->SetUiEngine( aUiEngine );

   174 

   175     CXnDomStringPool& sp( aUiEngine.ODT()->DomDocument().StringPool() );

   176 

   177     CXnProperty* name = CXnProperty::NewL(

   178         XnPropertyNames::action::trigger::KName, aStringValue,

   179         CXnDomPropertyValue::EString, sp );

   180 

   181     CleanupStack::PushL( name );

   182     node->SetPropertyL( name );

   183     CleanupStack::Pop( name );

   184 

   185     CXnProperty* value = CXnProperty::NewL(

   186         XnPropertyNames::action::KValue,

   187         KNullDesC8, CXnDomPropertyValue::EString, sp );

   188 

   189     CleanupStack::PushL( value );

   190     node->SetPropertyL( value );

   191     CleanupStack::Pop( value );

   192 

   193     CleanupStack::Pop( node ); 

   194 

   195     return node;

   196     }

   197 

   198 // -----------------------------------------------------------------------------

   199 // SetOnlineStateL

   200 // 

   201 // -----------------------------------------------------------------------------

   202 //

   203 static void SetOnlineStateL( CXnAppUiAdapter& aAdapter, 

   204     CXnViewData& aViewData )

   205     {

   206     if( !aViewData.Active() )

   207         {

   208         // Only active view can change online/offline state

   209         return;

   210         }

   211     

   212     RPointerArray< CXnNode > nodes;

   213     CleanupClosePushL( nodes );

   214 

   215     RPointerArray< CXnNodeAppIf > list;

   216     CleanupClosePushL( list );

   217 

   218     aViewData.ContentSourceNodesL( nodes );

   219 

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

   221         {

   222         list.AppendL( &nodes[i]->AppIfL() );

   223         }

   224 

   225     aAdapter.SetOnlineStateL( list );

   226 

   227     CleanupStack::PopAndDestroy( 2, &nodes ); // &list                                                 

   228     }

   229 

   230 // ============================ MEMBER FUNCTIONS ===============================

   231 

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

   233 // CXnViewManager::NewL()

   234 // Two-phased constructor.

   235 // -----------------------------------------------------------------------------

   236 //

   237 CXnViewManager* CXnViewManager::NewL( CXnAppUiAdapter& aAdapter )    

   238     {

   239     CXnViewManager* self = CXnViewManager::NewLC( aAdapter );

   240     CleanupStack::Pop( self );

   241     return self;

   242     }

   243 

   244 // -----------------------------------------------------------------------------

   245 // CXnViewManager::NewLC()

   246 // Two-phased constructor.

   247 // -----------------------------------------------------------------------------

   248 //

   249 CXnViewManager* CXnViewManager::NewLC( CXnAppUiAdapter& aAdapter )

   250     {

   251     CXnViewManager* self = new( ELeave ) CXnViewManager( aAdapter );

   252     CleanupStack::PushL( self );

   253     self->ConstructL();

   254     return self;

   255     }

   256 

   257 // -----------------------------------------------------------------------------

   258 // CXnViewManager::CXnViewManager()

   259 // C++ default constructor

   260 // -----------------------------------------------------------------------------

   261 //

   262 CXnViewManager::CXnViewManager( CXnAppUiAdapter& aAdapter ) 

   263     : iAppUiAdapter( aAdapter ), 

   264       iApplicationUid( iAppUiAdapter.Application()->AppDllUid() )

   265     {

   266     }

   267 

   268 // -----------------------------------------------------------------------------

   269 // CXnViewManager::~CXnViewManager()

   270 // C++ default destructor.

   271 // -----------------------------------------------------------------------------

   272 //

   273 CXnViewManager::~CXnViewManager()

   274     {

   275     iObservers.Reset();

   276     

   277     delete iRootData;

   278     

   279     delete iWidgetAmountTrigger;       

   280 

   281     if ( iResources )

   282         {

   283         iResources->Reset();

   284         }

   285     

   286     delete iResources;

   287 

   288     iControls.Reset();

   289     iAppearanceNodes.Reset();

   290        

   291     iFailedPlugins.Reset();

   292     

   293     delete iComposer;

   294     delete iEditor;

   295     delete iOomSysHandler;

   296     }

   297 

   298 // -----------------------------------------------------------------------------

   299 // CXnViewManager::ConstructL()

   300 // 2nd phase constructor

   301 // -----------------------------------------------------------------------------

   302 //

   303 void CXnViewManager::ConstructL()

   304     {

   305     iOomSysHandler = CXnOomSysHandler::NewL();

   306     

   307     // Create resource list

   308     iResources = new ( ELeave ) CArrayPtrSeg< CXnResource > ( 16 );

   309        

   310     const TInt KMaxUidLength( 10 );

   311     _LIT8( KUint, "%u" );

   312 

   313     TBuf8< KMaxUidLength > uid;

   314     uid.Format( KUint, iApplicationUid.iUid );

   315     

   316     iEditor = CXnEditor::NewL( *this, uid );

   317 

   318     iHspsWrapper = &iEditor->HspsWrapper();

   319     

   320     iComposer = CXnComposer::NewL( *iHspsWrapper );

   321     }

   322 

   323 // -----------------------------------------------------------------------------

   324 // CXnViewManager::LoadUiL()

   325 // Loads the application UI and initial view

   326 // -----------------------------------------------------------------------------

   327 //

   328 void CXnViewManager::LoadUiL()

   329     {

   330     iUiEngine->DisableRenderUiLC();

   331     

   332     // Load application root configuration

   333     iRootData = CXnRootData::NewL( *this, iApplicationUid );

   334            

   335     // Load root configuration and initial view.

   336     iRootData->LoadL();

   337     

   338     CleanupStack::PopAndDestroy(); // DisableRenderUiLC();

   339     }

   340 

   341 // -----------------------------------------------------------------------------

   342 // CXnViewManager::ReloadUiL()

   343 // Reloads the application UI and initial ivew

   344 // -----------------------------------------------------------------------------

   345 void CXnViewManager::ReloadUiL()  

   346     {

   347 #ifdef _XN_PERFORMANCE_TEST_

   348     RDebug::Print( _L( "CXnViewManager::ReloadUiL() - start" ) );

   349 #endif //_XN_PERFORMANCE_TEST_

   350     

   351     NotifyViewDeactivatedL( ActiveViewData() );

   352     

   353     delete iWidgetAmountTrigger;

   354     iWidgetAmountTrigger = NULL;

   355           

   356     // Destroy active view data

   357     ActiveViewData().Destroy();

   358          

   359     // Schedule application configuration destroyal

   360     iRootData->Destroy();

   361     iRootData = NULL;

   362     

   363     iFlags.ClearAll();

   364     

   365     User::Heap().Compress();

   366     

   367     LoadUiL();

   368     

   369     // Activate first view from the new configuration

   370     iAppUiAdapter.ViewAdapter().ActivateContainerL( ActiveViewData() );    

   371    

   372 #ifdef _XN_PERFORMANCE_TEST_

   373     RDebug::Print( _L( "CXnViewManager::ReloadUiL() - end" ) );

   374 #endif //_XN_PERFORMANCE_TEST_

   375     }

   376 

   377 // -----------------------------------------------------------------------------

   378 // CXnViewManager::LoadWidgetToPluginL()

   379 // -----------------------------------------------------------------------------

   380 //

   381 TInt CXnViewManager::LoadWidgetToPluginL( CHsContentInfo& aContentInfo,

   382     CXnPluginData& aPluginData )

   383     {

   384     // Plugin must not have widget when about to add

   385     if ( aPluginData.Occupied() )

   386         {

   387         return KErrAlreadyExists;

   388         }

   389 

   390     CXnViewData& viewData( 

   391         static_cast< CXnViewData& >( *aPluginData.Parent() ) );

   392 

   393     TBool emptyInUse( viewData.UseEmptyWidget() );

   394             

   395     // By default widget is added to active view configuration

   396     const TDesC8& configurationId( viewData.ConfigurationId() );

   397 

   398     TInt retval( KErrGeneral );

   399               

   400     if ( emptyInUse && aPluginData.Empty() )

   401         {

   402         retval = iHspsWrapper->ReplacePluginL( 

   403             aPluginData.PluginId(), aContentInfo.Uid() );   

   404         

   405         if( retval == KErrDiskFull )

   406             {

   407             ShowDiskFullMessageL();

   408             }

   409         }

   410     else

   411         {

   412         TInt index( viewData.PluginData().Find( &aPluginData ) );

   413         

   414         CAddPluginResult* result = iHspsWrapper->AddPluginL( 

   415             configurationId, aContentInfo.Uid(), index );

   416     

   417         CleanupStack::PushL( result );

   418         

   419         retval = result->Status();        

   420         if ( retval == KErrNone )

   421             {

   422             aPluginData.SetPluginIdL( result->PluginId() );

   423             }

   424         else if( retval == KErrDiskFull )

   425             {

   426             ShowDiskFullMessageL();

   427             }        

   428         

   429         CleanupStack::PopAndDestroy( result ); 

   430         }

   431              

   432     if ( retval == KErrNone )

   433         {              

   434         iUiEngine->DisableRenderUiLC();

   435                                      

   436         NotifyConfigureWidgetL( aContentInfo, aPluginData );

   437     

   438         aPluginData.LoadL();

   439                    

   440         UpdateCachesL();

   441     

   442         NotifyWidgetAdditionL( aPluginData );

   443 

   444         // Report widget amount in the view

   445         ReportWidgetAmountL( viewData );

   446         

   447         CleanupStack::PopAndDestroy(); // DisableRenderUiLC

   448         }

   449            

   450     return retval;

   451     }

   452 

   453 // -----------------------------------------------------------------------------

   454 // CXnViewManager::UnloadWidgetFromPluginL()

   455 // -----------------------------------------------------------------------------

   456 //

   457 TInt CXnViewManager::UnloadWidgetFromPluginL( CXnPluginData& aPluginData )    

   458     {          

   459     TBool error( aPluginData.PluginState().CompareF( KStateError ) == 0 );

   460     

   461     // Plugins in error state are always removed

   462     if ( !error && !aPluginData.Occupied() )

   463         {

   464         // Plugin must have widget when about to remove

   465         return KErrNotFound;            

   466         }

   467     

   468     CXnViewData& viewData( 

   469         static_cast< CXnViewData& >( *aPluginData.Parent() ) );

   470     

   471     TBool emptyInUse( viewData.UseEmptyWidget() );

   472     

   473     TInt retval( KErrGeneral );

   474     

   475     // Save temporary

   476     TBuf8< 32 > id( aPluginData.PluginId() );

   477            

   478     if ( emptyInUse )

   479         {

   480         retval = iHspsWrapper->ReplacePluginL( 

   481             aPluginData.PluginId(), KEmptyWidgetUid );                       

   482         }

   483     else 

   484         {        

   485         retval = iHspsWrapper->RemovePluginL( aPluginData.PluginId() );

   486         }

   487        

   488     if ( retval == KErrNone )

   489         {

   490         TBool active( aPluginData.Active() );

   491         

   492         iUiEngine->DisableRenderUiLC();

   493         

   494         NotifyWidgetRemovalL( aPluginData );

   495                  

   496         aPluginData.Destroy();

   497         

   498         if ( emptyInUse )

   499             {

   500             // Write id back for for later usage

   501             aPluginData.SetEmptyL( id );

   502             }

   503         else

   504             {

   505             // Reorder plugindata array

   506             RPointerArray< CXnPluginData >& plugins( viewData.PluginData() ); 

   507                 

   508             TInt index( plugins.Find( &aPluginData ) );

   509 

   510             plugins.Remove( index );

   511             plugins.Insert( &aPluginData, plugins.Count() - 1 );                                           

   512             }

   513                                                            

   514         UpdateCachesL();

   515 

   516         // Report widget amount in the view 

   517         ReportWidgetAmountL( viewData );

   518         

   519         if ( active )

   520             {            

   521             iUiEngine->RenderUIL();

   522             SetOnlineStateL( iAppUiAdapter, ActiveViewData() );

   523             }

   524                

   525         CleanupStack::PopAndDestroy(); // DisableRenderUiLC               

   526         }

   527 

   528     return retval;

   529     }

   530 

   531 // -----------------------------------------------------------------------------

   532 // CXnViewManager::ReplaceWidgetToPluginL

   533 // -----------------------------------------------------------------------------

   534 //

   535 TInt CXnViewManager::ReplaceWidgetToPluginL( CHsContentInfo& aContentInfo,

   536     CXnPluginData& aPluginData, TBool aUseHsps )

   537     {

   538     TInt ret = KErrNone;

   539     

   540     // if aUseHsps is false, the plugin was already replaced by

   541     // another process

   542     if( aUseHsps )

   543         {

   544         ret = iHspsWrapper->ReplacePluginL( aPluginData.PluginId(),

   545                                            aContentInfo.Uid() );

   546         }

   547 

   548     if ( ret == KErrNone )

   549         {

   550         iUiEngine->DisableRenderUiLC();

   551         

   552         NotifyWidgetRemovalL( aPluginData );

   553 

   554         TBuf8< 32 > id( aPluginData.PluginId() );

   555         TBuf8< 32 > uid( aContentInfo.Uid() );

   556         

   557         aPluginData.Destroy();

   558                         

   559         UpdateCachesL();

   560         aPluginData.SetPluginIdL( id );

   561         

   562         NotifyConfigureWidgetL( aContentInfo, aPluginData );

   563         

   564         aPluginData.LoadL();

   565                                                                   

   566         UpdateCachesL();

   567         

   568         // notify addition if not replaced with empty widget

   569         // NotifyWidgetAdditionL will call RenderUIL()

   570         if( uid != KEmptyWidgetUid )

   571             {

   572             NotifyWidgetAdditionL( aPluginData );

   573             }

   574         else

   575             {

   576             if( aPluginData.Active() )

   577                 {

   578                 iUiEngine->RenderUIL();

   579                 }

   580             }

   581         

   582         CleanupStack::PopAndDestroy(); // DisableRenderUiLC

   583         }

   584     

   585     return ret;

   586     }

   587 

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

   589 // CXnViewManager::ODT()

   590 // Get the ODT

   591 // -----------------------------------------------------------------------------

   592 //

   593 CXnODT* CXnViewManager::ODT() const

   594     {

   595     return iRootData->ODT();

   596     }

   597 

   598 // -----------------------------------------------------------------------------

   599 // CXnViewManager::RootNode()

   600 // Finds the root node 

   601 // -----------------------------------------------------------------------------

   602 //

   603 CXnNode* CXnViewManager::RootNode() const

   604     {

   605     return iRootData->RootNode();

   606     }

   607 

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

   609 // CXnViewManager::ViewNode()

   610 // Finds the view node from active view data

   611 // -----------------------------------------------------------------------------

   612 //

   613 CXnNode* CXnViewManager::ViewNode() const

   614     {

   615     return ActiveViewData().ViewNode();

   616     }

   617 

   618 // -----------------------------------------------------------------------------

   619 // CXnViewManager::Parser()

   620 // Gets ODT parser

   621 // -----------------------------------------------------------------------------

   622 //

   623 CXnODTParser& CXnViewManager::Parser() const

   624     {

   625     return iRootData->Parser();

   626     }

   627 

   628 // -----------------------------------------------------------------------------

   629 // CXnViewManager::EcomHandler()

   630 // Gets Ecom handler

   631 // -----------------------------------------------------------------------------

   632 //

   633 CXnEcomHandler& CXnViewManager::EcomHandler() const

   634     {

   635     return iRootData->EcomHandler();

   636     }

   637 

   638 // -----------------------------------------------------------------------------

   639 // CXnViewManager::Controls()

   640 // Finds the controls from active view data

   641 // -----------------------------------------------------------------------------

   642 //

   643 const RPointerArray< CXnControlAdapter >& CXnViewManager::Controls() const

   644     {

   645     return iControls;

   646     }

   647 

   648 // -----------------------------------------------------------------------------

   649 // CXnViewManager::PluginNodes()

   650 // Finds the plugin nodes from active view data

   651 // -----------------------------------------------------------------------------

   652 //

   653 RPointerArray< CXnNode >& CXnViewManager::PluginNodes() const

   654     {

   655     // These must be fetched from layout tree to get correct order of plugins

   656     CXnViewData& activeViewData( ActiveViewData() );

   657 

   658     // Get first plugin data

   659     CXnPluginData* pluginData( activeViewData.PluginData()[0] );

   660     CXnNode* parent( pluginData->Owner()->LayoutNode()->Parent() );

   661 

   662     // This assumes that the parent has only "plugin" nodes as its children

   663     RPointerArray< CXnNode >& children( parent->Children() );

   664 

   665     return children;

   666     }

   667 

   668 // -----------------------------------------------------------------------------

   669 // CXnViewManager::PluginDataL()

   670 // 

   671 // -----------------------------------------------------------------------------

   672 //

   673 void CXnViewManager::PluginDataL( RPointerArray< CXnPluginData >& aList, 

   674     TBool aGlobal ) const

   675     {

   676     if ( aGlobal )

   677         {

   678         RPointerArray< CXnPluginData >& views( iRootData->PluginData() );

   679         

   680         for ( TInt i = 0; i < views.Count(); i++ )

   681             {

   682             RPointerArray< CXnPluginData >& plugins( views[i]->PluginData() );

   683             

   684             for ( TInt j = 0; j < plugins.Count(); j++ )

   685                 {

   686                 aList.AppendL( plugins[ j ] );

   687                 }

   688             }            

   689         }

   690     else

   691         {

   692         RPointerArray< CXnPluginData >& 

   693             plugins( ActiveViewData().PluginData() ); 

   694 

   695         for ( TInt j = 0; j < plugins.Count(); j++ )

   696             {

   697             aList.AppendL( plugins[ j ] );

   698             }        

   699         }

   700     }

   701 

   702 // -----------------------------------------------------------------------------

   703 // CXnViewManager::Resources()

   704 // Finds the resources from the active view data

   705 // -----------------------------------------------------------------------------

   706 //

   707 CArrayPtrSeg< CXnResource >& CXnViewManager::Resources() const

   708     {

   709     return *iResources;

   710     }

   711 

   712 // -----------------------------------------------------------------------------

   713 // CXnViewManager::AppearanceNodes()

   714 // -----------------------------------------------------------------------------

   715 //

   716 RPointerArray< CXnNode >& CXnViewManager::AppearanceNodes() const

   717     {

   718     return iAppearanceNodes;

   719     }

   720 

   721 // -----------------------------------------------------------------------------

   722 // CXnViewManager::ViewData()

   723 // Finds a view data based on a view node

   724 // -----------------------------------------------------------------------------

   725 //

   726 CXnViewData* CXnViewManager::ViewData( CXnNode& aNode ) const

   727     {    

   728     if ( !aNode.ViewNodeImpl() )

   729         {

   730         return NULL;

   731         }

   732 

   733     RPointerArray< CXnPluginData >& views( iRootData->PluginData() );

   734     

   735     for ( TInt i = 0; i < views.Count(); i++ )

   736         {

   737         if ( views[i]->Occupied() )

   738             {

   739             if ( views[i]->Node()->LayoutNode() == &aNode )

   740                 {

   741                 return static_cast< CXnViewData* >( views[ i ] );                

   742                 }

   743             }

   744         }

   745 

   746     return NULL;

   747     }

   748 

   749 // -----------------------------------------------------------------------------

   750 // CXnViewManager::ActiveAppData()

   751 // Gets the active app data

   752 // -----------------------------------------------------------------------------

   753 //

   754 CXnRootData& CXnViewManager::ActiveAppData() const

   755     {

   756     return *iRootData;

   757     }

   758 

   759 // -----------------------------------------------------------------------------

   760 // CXnViewManager::ActiveViewData()

   761 // Gets the active view data

   762 // -----------------------------------------------------------------------------

   763 //

   764 CXnViewData& CXnViewManager::ActiveViewData() const

   765     {

   766     return iRootData->ActiveViewData();

   767     }

   768 

   769 // -----------------------------------------------------------------------------

   770 // CXnViewManager::PreviousViewData()

   771 // Gets the previous view data 

   772 // -----------------------------------------------------------------------------

   773 //

   774 CXnViewData& CXnViewManager::PreviousViewData() const

   775     {

   776     return iRootData->PreviousViewData();

   777     }

   778 

   779 // -----------------------------------------------------------------------------

   780 // CXnViewManager::NextViewData()

   781 // Gets the next view data 

   782 // -----------------------------------------------------------------------------

   783 //

   784 CXnViewData& CXnViewManager::NextViewData() const

   785     {

   786     return iRootData->NextViewData();

   787     }

   788 

   789 // -----------------------------------------------------------------------------

   790 // CXnViewManager::ActivateNextViewL()

   791 // Activates the next view

   792 // -----------------------------------------------------------------------------

   793 //

   794 void CXnViewManager::ActivateNextViewL()

   795     {

   796     CXnViewData& current( ActiveViewData() );

   797     CXnViewData& next( NextViewData() );

   798 

   799     if ( !next.Occupied() )

   800         {

   801         next.LoadL();

   802         }

   803         

   804     // Activate view

   805     if ( next.Occupied() )

   806         {            

   807         iAppUiAdapter.ViewAdapter().ActivateContainerL( next );                

   808         }

   809     }

   810 

   811 // -----------------------------------------------------------------------------

   812 // CXnViewManager::ActivatePreviousViewL()

   813 // Activates the previous view

   814 // -----------------------------------------------------------------------------

   815 //

   816 void CXnViewManager::ActivatePreviousViewL()

   817     {

   818     CXnViewData& current( ActiveViewData() );

   819     CXnViewData& prev( PreviousViewData() );

   820 

   821     if ( !prev.Occupied() )

   822         {

   823         prev.LoadL();

   824         }

   825         

   826     // Activate view

   827     if ( prev.Occupied() )

   828         {   

   829         iAppUiAdapter.ViewAdapter().ActivateContainerL( prev );

   830         }

   831     }

   832 

   833 // -----------------------------------------------------------------------------

   834 // CXnViewManager::AddViewL()

   835 // Adds a new view based on info

   836 // -----------------------------------------------------------------------------

   837 //

   838 TInt CXnViewManager::AddViewL( CHsContentInfo& aInfo )

   839     {    

   840     if ( iRootData->PluginData().Count() >= iRootData->MaxPages() )

   841         {

   842         return KErrGeneral;

   843         }

   844 

   845     // Add new view (template view) to hsps

   846     CAddPluginResult* result = iHspsWrapper->AddPluginL( 

   847         iRootData->ConfigurationId(), aInfo.Uid(),

   848         ViewIndex() + 1 ); 

   849     CleanupStack::PushL( result );

   850 

   851     TInt retval( result->Status() );

   852     

   853     if( retval == KErrDiskFull )

   854         {

   855         ShowDiskFullMessageL();

   856         }        

   857     else if ( retval == KErrNone )

   858         {                             

   859         // Create new view        

   860         CXnViewData* newView = CXnViewData::NewLC( *iRootData );    

   861         

   862         newView->SetPluginIdL( result->PluginId() );

   863         

   864         newView->SetOwner( iRootData->Node() );

   865         

   866         newView->LoadL();

   867                 

   868         if ( newView->Occupied() )

   869             {

   870             // Load succeed, add the new view behind the current view               

   871             RPointerArray< CXnPluginData >& views( iRootData->PluginData() );

   872             

   873             TInt index( views.Find( &ActiveViewData() ) );

   874             

   875             views.InsertL( newView, index + 1 );

   876             

   877             // Root data owns the new view now

   878             CleanupStack::Pop( newView );            

   879 

   880             // Inform observers about added view

   881             NotifyViewAdditionL( *newView );

   882             

   883             UpdatePageManagementInformationL();

   884             

   885             iUiEngine->RenderUIL();

   886             }

   887         else

   888             {                                  

   889             // creation failed, remove it from hsps

   890             iHspsWrapper->RemovePluginL( result->PluginId() );

   891             

   892             // ... and destroy it

   893             CleanupStack::PopAndDestroy( newView );            

   894             

   895             retval = KErrGeneral;

   896 

   897             }

   898         }

   899 

   900     CleanupStack::PopAndDestroy( result );   

   901     

   902     return retval;

   903     }

   904 

   905 // -----------------------------------------------------------------------------

   906 // CXnViewManager::AddViewL()

   907 // Adds a new view

   908 // -----------------------------------------------------------------------------

   909 //

   910 void CXnViewManager::AddViewL()

   911     {

   912     if ( iRootData->PluginData().Count() >= iRootData->MaxPages() ) 

   913         { 

   914         HBufC* msg( StringLoader::LoadLC( 

   915             R_QTN_HS_MAX_AMOUNT_OF_PAGES_NOTE ) ); 

   916 

   917         CAknErrorNote* note = new ( ELeave ) CAknErrorNote; 

   918         CleanupStack::PushL( note ); 

   919                

   920         note->ExecuteLD( *msg ); 

   921                

   922         CleanupStack::Pop( note ); 

   923         CleanupStack::PopAndDestroy( msg ); 

   924 

   925         return; 

   926         }

   927 

   928     // Add new view (template view) to hsps

   929     CAddPluginResult* result = iHspsWrapper->AddPluginL( 

   930         iRootData->ConfigurationId(), KTemplateViewUID,

   931         ViewIndex() + 1 ); 

   932     CleanupStack::PushL( result );

   933         

   934     TInt status( result->Status() );

   935     

   936     if( status == KErrDiskFull )

   937         {

   938         ShowDiskFullMessageL();

   939         }            

   940     else if ( status == KErrNone )

   941         {                             

   942         // Create new view        

   943         CXnViewData* newView = CXnViewData::NewLC( *iRootData );    

   944         

   945         newView->SetPluginIdL( result->PluginId() );

   946         

   947         newView->SetOwner( iRootData->Node() );

   948         

   949         newView->LoadL();

   950                 

   951         if ( newView->Occupied() )

   952             {

   953             // Load succeed, add the new view behind the current view               

   954             RPointerArray< CXnPluginData >& views( iRootData->PluginData() );

   955             

   956             TInt index( views.Find( &ActiveViewData() ) );

   957             

   958             views.InsertL( newView, index + 1 );

   959             

   960             // Root data owns the new view now

   961             CleanupStack::Pop( newView );

   962             

   963             // Activate view

   964             iAppUiAdapter.ViewAdapter().ActivateContainerL( *newView, ETrue );

   965             

   966             // Inform observers about added view

   967             NotifyViewAdditionL( *newView );

   968             }

   969         else

   970             {                      

   971             // creation failed, remove it from hsps

   972             iHspsWrapper->RemovePluginL( result->PluginId() );

   973             

   974             // ... and destroy it

   975             CleanupStack::PopAndDestroy( newView );            

   976             }

   977         }

   978 

   979     CleanupStack::PopAndDestroy( result );       

   980     }

   981 

   982 // -----------------------------------------------------------------------------

   983 // CXnViewManager::RemoveViewL()

   984 // Removes view based info

   985 // -----------------------------------------------------------------------------

   986 //

   987 TInt CXnViewManager::RemoveViewL( const CHsContentInfo& aInfo )

   988     {

   989     TInt retval( KErrGeneral );

   990     

   991     if ( iRootData->PluginData().Count() <= 1 )

   992         {

   993         // Only one page left, not allowed to remove

   994         return retval;        

   995         }

   996     

   997     RPointerArray< CXnPluginData >& views( iRootData->PluginData() );

   998 

   999     for ( TInt i = 0; i < views.Count(); i++ )

  1000         {

  1001         CXnViewData* view( static_cast< CXnViewData* >( views[i] ) );

  1002         

  1003         if ( view->PluginId() == aInfo.PluginId() )

  1004             {

  1005             if ( !view->Removable() )

  1006                 {

  1007                 return retval;

  1008                 }

  1009             

  1010             if ( view->Active() )

  1011                 {

  1012                 // Activate the next view, or first if in the last view 

  1013                 CXnViewData& next( NextViewData() );

  1014                 iAppUiAdapter.ViewAdapter().ActivateContainerL( next );

  1015                 }

  1016 

  1017             retval = iHspsWrapper->RemovePluginL( view->PluginId() );

  1018             

  1019             // Notify observers of view list change

  1020             NotifyViewRemovalL( *view );

  1021 

  1022             iRootData->DestroyViewData( view );

  1023                                                                    

  1024             // Need to update after view is removed

  1025             UpdatePageManagementInformationL();                

  1026                                    

  1027             break;

  1028             }

  1029         }

  1030     

  1031     return retval;

  1032     }

  1033 

  1034 // -----------------------------------------------------------------------------

  1035 // CXnViewManager::RemoveViewL()

  1036 // Removes active view if more than one view.

  1037 // -----------------------------------------------------------------------------

  1038 //

  1039 void CXnViewManager::RemoveViewL()

  1040     {   

  1041     if ( iRootData->PluginData().Count() <= 1 || 

  1042         !ActiveViewData().Removable() )

  1043         {

  1044         // Only one page left, this should not happen,  

  1045         // or active view is not removable

  1046         return;        

  1047         }

  1048           

  1049     RPointerArray< CXnPluginData >& views( iRootData->PluginData() );

  1050     

  1051     TInt index( views.Find( &ActiveViewData() ) );

  1052            

  1053     CAknQueryDialog* query = CAknQueryDialog::NewL(); 

  1054     query->PrepareLC( R_YES_NO_HS_REMOVE_VIEW );

  1055     

  1056     HBufC* queryText( StringLoader::LoadLC( R_QTN_HS_DELETE_PAGE ) ); 

  1057     

  1058     query->SetPromptL( queryText->Des() );

  1059     

  1060     CleanupStack::PopAndDestroy( queryText );

  1061 

  1062     if ( query->RunLD() )

  1063         { 

  1064         // Activate the next view, or first if in the last view 

  1065         CXnViewData& next( NextViewData() );

  1066 

  1067         iAppUiAdapter.ViewAdapter().ActivateContainerL( next );

  1068                 

  1069         CXnViewData* view( static_cast< CXnViewData* >( views[ index ] ) );

  1070 

  1071         // Remove plugin from HSPS

  1072         iHspsWrapper->RemovePluginL( view->PluginId() );

  1073         

  1074         // Notify observers of view list change

  1075         NotifyViewRemovalL( *view );

  1076 

  1077         iRootData->DestroyViewData( view );

  1078         

  1079         // Need to update after view is removed

  1080         UpdatePageManagementInformationL();        

  1081         }       

  1082     }

  1083 

  1084 // -----------------------------------------------------------------------------

  1085 // CXnViewManager::AddObserver()

  1086 // -----------------------------------------------------------------------------

  1087 //

  1088 void CXnViewManager::AddObserver( const MXnViewObserver& aObserver )

  1089     {

  1090     TInt index( iObservers.Find( &aObserver ) );

  1091 

  1092     if ( index == KErrNotFound )

  1093         {

  1094         iObservers.Append( &aObserver );

  1095         }

  1096     }

  1097 

  1098 // -----------------------------------------------------------------------------

  1099 // CXnViewManager::RemoveObserver()

  1100 // -----------------------------------------------------------------------------

  1101 //

  1102 void CXnViewManager::RemoveObserver( const MXnViewObserver& aObserver )

  1103     {

  1104     TInt index( iObservers.Find( &aObserver ) );

  1105 

  1106     if ( index != KErrNotFound )

  1107         {

  1108         iObservers.Remove( index );

  1109         }

  1110     }

  1111 

  1112 // -----------------------------------------------------------------------------

  1113 // CXnViewManager::ActivateAppL()

  1114 // Activates application configuration

  1115 // -----------------------------------------------------------------------------

  1116 TInt CXnViewManager::ActivateAppL( const TDesC8& aPluginUid )

  1117     {

  1118     if ( aPluginUid == KNullDesC8 )

  1119         {

  1120         return KErrArgument;

  1121         }

  1122 

  1123     if ( iRootData->PluginUid().Compare( aPluginUid ) == 0 )

  1124         {

  1125         // Nothing to do

  1126         return KErrNone;

  1127         }

  1128     

  1129     return iHspsWrapper->SetAppConfigurationL( aPluginUid );

  1130     }

  1131 

  1132 // -----------------------------------------------------------------------------

  1133 // CXnViewManager::ActivateViewL()

  1134 // Activates view