idlehomescreen/xmluirendering/uiengine/src/xnviewadapter.cpp
branchRCL_3
changeset 34 5456b4e8b3a8
child 35 3321d3e205b6
equal deleted inserted replaced
33:5f0182e07bfb 34:5456b4e8b3a8
       
     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:  Xuikon view adapter source file
       
    15 *
       
    16 */
       
    17 
       
    18 // System includes
       
    19 #include <aknViewAppUi.h>
       
    20 #include <eikbtgpc.h>
       
    21 #include <avkon.rsg>
       
    22 
       
    23 // User includes
       
    24 #include "xnappuiadapter.h"
       
    25 #include "xnviewmanager.h"
       
    26 #include "xnviewdata.h"
       
    27 #include "xnuiengine.h"
       
    28 
       
    29 #include "xnkeyeventdispatcher.h"
       
    30 #include "xncontroladapter.h"
       
    31 
       
    32 #include "xndomdocument.h"
       
    33 #include "xndomnode.h"
       
    34 #include "xndomlist.h"
       
    35 #include "xnodt.h"
       
    36 #include "xnproperty.h"
       
    37 #include "xnnodeimpl.h"
       
    38 #include "xnnode.h"
       
    39 #include "xntype.h"
       
    40 #include "xnfocuscontrol.h"
       
    41 #include "xneditor.h"
       
    42 #include "xnbackgroundmanager.h"
       
    43 #include "xneffectmanager.h"
       
    44 #include "xnwallpaperview.h"
       
    45 
       
    46 #include "xnviewadapter.h"
       
    47 #include "xnmenu.h"
       
    48 #include "xneditmode.h"
       
    49 #include "xnrootdata.h"
       
    50 
       
    51 #include "debug.h"
       
    52 
       
    53 // Constants
       
    54 const TUid KXmlViewUid = { 1 };
       
    55 
       
    56 _LIT8( KActivateDefaultView, "activatedefault" );
       
    57 _LIT8( KSetWallpaper, "setwallpaper" );
       
    58 
       
    59 _LIT8( KMenuBar, "menubar" );
       
    60 
       
    61 // Data types
       
    62 enum 
       
    63     {
       
    64     EIsActivated,    
       
    65     EIsInCall,
       
    66     EIsLightsOn,
       
    67     EIsForeground,    
       
    68     EIsControlsAwake,    
       
    69     EIsDestructionRunning
       
    70     };
       
    71 
       
    72 enum TAction
       
    73     {
       
    74     ENoAction = 0,
       
    75     EActivateDefault,
       
    76     ESetWallpaper
       
    77     };
       
    78 
       
    79 // ============================= LOCAL FUNCTIONS ===============================
       
    80 // -----------------------------------------------------------------------------
       
    81 // CleanupEffect
       
    82 // -----------------------------------------------------------------------------
       
    83 //
       
    84 static void CleanupEffect( TAny* aAny )
       
    85     {
       
    86     static_cast< CXnEffectManager* >( aAny )->CleanupControlEffect();
       
    87     }
       
    88 
       
    89 // -----------------------------------------------------------------------------
       
    90 // DetermineStatusPaneLayout
       
    91 // -----------------------------------------------------------------------------
       
    92 //
       
    93 static TInt DetermineStatusPaneLayout( CXnProperty* aProperty )
       
    94     {
       
    95     TInt spane( KErrNotFound );
       
    96 
       
    97     if ( aProperty )
       
    98         {
       
    99         const TDesC8& value( aProperty->StringValue() );
       
   100 
       
   101         // Currently supported status pane layout
       
   102         if ( value == XnPropertyNames::view::statuspanelayout::KNone )
       
   103             {
       
   104             spane = R_AVKON_STATUS_PANE_LAYOUT_EMPTY;
       
   105             }
       
   106         if ( value == XnPropertyNames::view::statuspanelayout::KBasic )
       
   107             {
       
   108             spane = R_AVKON_STATUS_PANE_LAYOUT_IDLE;
       
   109             }
       
   110         else if ( value == XnPropertyNames::view::statuspanelayout::KBasicFlat )
       
   111             {
       
   112             spane = R_AVKON_STATUS_PANE_LAYOUT_IDLE_FLAT;
       
   113             }
       
   114         else if ( value ==
       
   115                   XnPropertyNames::view::statuspanelayout::KWideScreen )
       
   116             {
       
   117             spane = R_AVKON_WIDESCREEN_PANE_LAYOUT_IDLE;
       
   118             }
       
   119         else if ( value ==
       
   120                   XnPropertyNames::view::statuspanelayout::KWideScreenFlat )
       
   121             {
       
   122             spane = R_AVKON_WIDESCREEN_PANE_LAYOUT_IDLE_FLAT;
       
   123             }
       
   124         else if ( value ==
       
   125                   XnPropertyNames::view::statuspanelayout::
       
   126                   KWideScreenFlat3Softkeys )
       
   127             {
       
   128             spane = R_AVKON_WIDESCREEN_PANE_LAYOUT_IDLE_FLAT_NO_SOFTKEYS;
       
   129             }
       
   130         }
       
   131 
       
   132     return spane;
       
   133     }
       
   134 
       
   135 // -----------------------------------------------------------------------------
       
   136 // BuildTriggerL
       
   137 // -----------------------------------------------------------------------------
       
   138 //
       
   139 static CXnNode* BuildTriggerL(
       
   140     CXnUiEngine& aUiEngine,
       
   141     const TDesC8& aTriggerName )
       
   142     {
       
   143     CXnNode* node = CXnNode::NewL();
       
   144     CleanupStack::PushL( node );
       
   145     CXnType* type = CXnType::NewL( XnPropertyNames::action::KTrigger );
       
   146     CleanupStack::PushL( type );
       
   147     CXnNodeImpl* impl = CXnNodeImpl::NewL( type );
       
   148     CleanupStack::Pop( type );
       
   149     node->SetImpl( impl );
       
   150     node->SetUiEngine( aUiEngine );
       
   151     
       
   152     CXnDomPropertyValue* nameValue = CXnDomPropertyValue::NewL(
       
   153         aUiEngine.ODT()->DomDocument().StringPool() );
       
   154     CleanupStack::PushL( nameValue );
       
   155     nameValue->SetStringValueL( CXnDomPropertyValue::EString, aTriggerName );
       
   156     CXnProperty* name = CXnProperty::NewL(
       
   157         XnPropertyNames::action::trigger::KName,
       
   158         nameValue,
       
   159         *aUiEngine.ODT()->DomDocument().StringPool() );
       
   160     CleanupStack::Pop( nameValue );
       
   161     CleanupStack::PushL( name );
       
   162     node->SetPropertyL( name );
       
   163     CleanupStack::Pop( 2, node ); // name 
       
   164     
       
   165     return node;
       
   166     }
       
   167 
       
   168 // -----------------------------------------------------------------------------
       
   169 // BuildActivateTriggerL
       
   170 // -----------------------------------------------------------------------------
       
   171 //
       
   172 static CXnNode* BuildActivateTriggerL( CXnUiEngine& aUiEngine )
       
   173     {
       
   174     return BuildTriggerL(
       
   175         aUiEngine, XnPropertyNames::action::trigger::name::KViewActivate );
       
   176     }
       
   177 
       
   178 // -----------------------------------------------------------------------------
       
   179 // BuildDeactivateTriggerL
       
   180 // -----------------------------------------------------------------------------
       
   181 //
       
   182 static CXnNode* BuildDeactivateTriggerL( CXnUiEngine& aUiEngine )
       
   183     {
       
   184     return BuildTriggerL(
       
   185         aUiEngine, XnPropertyNames::action::trigger::name::KViewDeactivate );
       
   186     }
       
   187 
       
   188 // -----------------------------------------------------------------------------
       
   189 // BuildEditStateTriggerL
       
   190 // -----------------------------------------------------------------------------
       
   191 //
       
   192 static CXnNode* BuildEditStateTriggerL( CXnUiEngine& aUiEngine )
       
   193     {
       
   194     CXnDomStringPool* sp( aUiEngine.ODT()->DomDocument().StringPool() );
       
   195     
       
   196     CXnProperty* value = CXnProperty::NewL(
       
   197         XnPropertyNames::action::KValue,
       
   198         KNullDesC8, CXnDomPropertyValue::EString, *sp );
       
   199     CleanupStack::PushL( value );
       
   200     
       
   201     CXnNode* trigger( BuildTriggerL(
       
   202         aUiEngine, XnPropertyNames::action::trigger::name::KEditMode ) );    
       
   203     CleanupStack::PushL( trigger );
       
   204     
       
   205     trigger->SetPropertyL( value );
       
   206     CleanupStack::Pop( 2, value ); // trigger
       
   207     
       
   208     return trigger;
       
   209     }
       
   210 
       
   211 // ============================ MEMBER FUNCTIONS ===============================
       
   212 
       
   213 // -----------------------------------------------------------------------------
       
   214 // CXnViewAdapter::CXnViewAdapter
       
   215 // C++ default constructor can NOT contain any code, that
       
   216 // might leave.
       
   217 // -----------------------------------------------------------------------------
       
   218 //
       
   219 CXnViewAdapter::CXnViewAdapter( CXnAppUiAdapter& aAdapter )
       
   220     : iAppUiAdapter( aAdapter )
       
   221     {
       
   222     }
       
   223 
       
   224 // -----------------------------------------------------------------------------
       
   225 // CXnViewAdapter::~CXnViewAdapter
       
   226 // Destructor.
       
   227 // -----------------------------------------------------------------------------
       
   228 //
       
   229 CXnViewAdapter::~CXnViewAdapter()
       
   230     {
       
   231     delete iTimer;
       
   232     delete iActivate;
       
   233     delete iDeactivate;
       
   234     delete iEditState;    
       
   235     delete iBgManager;
       
   236     delete iFocusControl;
       
   237     }
       
   238 
       
   239 // -----------------------------------------------------------------------------
       
   240 // CXnViewAdapter::NewL
       
   241 // 2nd phase construction.
       
   242 // -----------------------------------------------------------------------------
       
   243 //
       
   244 CXnViewAdapter* CXnViewAdapter::NewL( CXnAppUiAdapter& aAdapter )
       
   245     {
       
   246     CXnViewAdapter* self = new ( ELeave ) CXnViewAdapter( aAdapter );
       
   247     CleanupStack::PushL( self );
       
   248     self->ConstructL();
       
   249     CleanupStack::Pop( self );
       
   250     return self;
       
   251     }
       
   252 
       
   253 // -----------------------------------------------------------------------------
       
   254 // CXnViewAdapter::ConstructL
       
   255 // 2nd phase construction.
       
   256 // -----------------------------------------------------------------------------
       
   257 //
       
   258 void CXnViewAdapter::ConstructL()
       
   259     {
       
   260     BaseConstructL();
       
   261     
       
   262     iTimer = CPeriodic::NewL( CActive::EPriorityIdle );
       
   263             
       
   264     // Base class CAknViewAppUi takes ownership of iViewAdapter
       
   265     iAppUiAdapter.AddViewL( this );    
       
   266     iAppUiAdapter.SetDefaultViewL( *this );
       
   267 
       
   268     iBgManager = CXnBackgroundManager::NewL( iAppUiAdapter.ViewManager(),
       
   269         iAppUiAdapter.ViewManager().Editor().HspsWrapper() );
       
   270 
       
   271     iFocusControl = CXnFocusControl::NewL( iAppUiAdapter );   
       
   272     
       
   273     iEventDispatcher = 
       
   274         CXnKeyEventDispatcher::NewL( iAppUiAdapter.UiEngine() );
       
   275     
       
   276     iAppUiAdapter.UiEngine().SetEventDispatcher( iEventDispatcher );
       
   277     
       
   278     iAppUiAdapter.UiStateListener().AddObserver( *this );
       
   279     }
       
   280 
       
   281 // -----------------------------------------------------------------------------
       
   282 // CXnViewAdapter::ReloadUiL
       
   283 // Called when application UI is reloaded
       
   284 // -----------------------------------------------------------------------------
       
   285 //
       
   286 void CXnViewAdapter::ReloadUiL()
       
   287     {
       
   288     iTimer->Cancel();
       
   289     iAction = ENoAction;
       
   290     
       
   291     DeactivateContainerL();
       
   292     
       
   293     iAppUiAdapter.RemoveFromStack( iEventDispatcher );
       
   294     
       
   295     delete iEventDispatcher;
       
   296     iEventDispatcher = NULL;
       
   297     
       
   298     delete iActivate;
       
   299     iActivate = NULL;
       
   300     
       
   301     delete iDeactivate;
       
   302     iDeactivate = NULL;
       
   303     
       
   304     delete iEditState;
       
   305     iEditState = NULL;
       
   306         
       
   307     iEventDispatcher = CXnKeyEventDispatcher::NewL( iAppUiAdapter.UiEngine() );
       
   308     
       
   309     iAppUiAdapter.UiEngine().SetEventDispatcher( iEventDispatcher );
       
   310     
       
   311     if ( iFlags.IsSet( EIsActivated ) )
       
   312         {
       
   313         iAppUiAdapter.AddToStackL( *this, iEventDispatcher );
       
   314         }
       
   315     }
       
   316 
       
   317 // -----------------------------------------------------------------------------
       
   318 // CXnViewAdapter::PrepareToExit
       
   319 // Sets view to be destroyed
       
   320 // -----------------------------------------------------------------------------
       
   321 //
       
   322 void CXnViewAdapter::PrepareToExit()
       
   323     {                
       
   324     iAppUiAdapter.RemoveFromStack( iEventDispatcher );
       
   325     
       
   326     delete iEventDispatcher;
       
   327     iEventDispatcher = NULL;
       
   328     
       
   329     iAppUiAdapter.UiEngine().SetEventDispatcher( NULL );
       
   330     
       
   331     iContainer = NULL;
       
   332     
       
   333     iFlags.Set( EIsDestructionRunning );    
       
   334     }
       
   335 
       
   336 // -----------------------------------------------------------------------------
       
   337 // CXnViewAdapter::EventDispatcher
       
   338 // Get event dispatcher
       
   339 // -----------------------------------------------------------------------------
       
   340 //
       
   341 CXnKeyEventDispatcher* CXnViewAdapter::EventDispatcher() const
       
   342     {
       
   343     return iEventDispatcher;
       
   344     }
       
   345 
       
   346 // -----------------------------------------------------------------------------
       
   347 // CXnViewAdapter::BgManager
       
   348 // Returns background manager.
       
   349 // -----------------------------------------------------------------------------
       
   350 //
       
   351 CXnBackgroundManager& CXnViewAdapter::BgManager() const
       
   352     {
       
   353     return *iBgManager;
       
   354     }
       
   355 
       
   356 // -----------------------------------------------------------------------------
       
   357 // CXnViewAdapter::FocusControl
       
   358 // Returns focus control.
       
   359 // -----------------------------------------------------------------------------
       
   360 //
       
   361 CXnFocusControl& CXnViewAdapter::FocusControl() const
       
   362     {
       
   363     return *iFocusControl;
       
   364     }
       
   365 
       
   366 // -----------------------------------------------------------------------------
       
   367 // CXnViewAdapter::Id
       
   368 // Returns view uid.
       
   369 // -----------------------------------------------------------------------------
       
   370 //
       
   371 TUid CXnViewAdapter::Id() const
       
   372     {
       
   373     return KXmlViewUid;
       
   374     }
       
   375 
       
   376 // -----------------------------------------------------------------------------
       
   377 // CXnViewAdapter::DoActivateL
       
   378 // Activates view.
       
   379 // -----------------------------------------------------------------------------
       
   380 //
       
   381 void CXnViewAdapter::DoActivateL( const TVwsViewId& /*aPrevViewId*/,    
       
   382     TUid /*aCustomMessageId*/,
       
   383     const TDesC8& aCustomMessage )
       
   384     {
       
   385     if ( iFlags.IsSet( EIsDestructionRunning ) )
       
   386         {
       
   387         return;
       
   388         }
       
   389 
       
   390     __TICK( "CXnViewAdapter::DoActivateL" );
       
   391     __TIME_MARK( time );
       
   392 
       
   393     TBool wasActive( iFlags.IsSet( EIsActivated ) );
       
   394     
       
   395     iFlags.Set( EIsActivated );
       
   396     
       
   397     iEventDispatcher->ClearStateL();
       
   398            
       
   399     iAppUiAdapter.RemoveFromStack( iEventDispatcher );
       
   400     iAppUiAdapter.AddToStackL( *this, iEventDispatcher );
       
   401 
       
   402     CEikButtonGroupContainer* bgc( iAppUiAdapter.Cba() );
       
   403     
       
   404     if ( bgc )
       
   405         {
       
   406         // EventDispatcher will handle sotkey keyevents 
       
   407         CEikCba* cba( 
       
   408             static_cast< CEikCba* >( bgc->ButtonGroup() ) );
       
   409 
       
   410         iAppUiAdapter.RemoveFromStack( cba );        
       
   411         }
       
   412        
       
   413     iBgManager->MakeVisible( ETrue );
       
   414         
       
   415     CXnViewData& viewData( iAppUiAdapter.ViewManager().ActiveViewData() );
       
   416     
       
   417     if ( !wasActive )
       
   418         {
       
   419         // Set status pane layout        
       
   420         CXnProperty* prop( viewData.Node()->LayoutNode()->GetPropertyL( 
       
   421             XnPropertyNames::view::KStatusPaneLayout ) );
       
   422     
       
   423         CEikStatusPane* sp( iAppUiAdapter.StatusPane() );
       
   424         
       
   425         // Is there status pane declaration available
       
   426         TInt spane( DetermineStatusPaneLayout( prop ) );
       
   427     
       
   428         if ( spane != KErrNotFound )
       
   429             {
       
   430             if ( sp && sp->CurrentLayoutResId() != spane )
       
   431                 {
       
   432                 sp->SwitchLayoutL( spane );
       
   433                 sp->ApplyCurrentSettingsL();
       
   434                 }
       
   435             }    
       
   436         
       
   437         // enable statuspane transparancy        
       
   438         if ( sp && !sp->IsTransparent() ) 
       
   439             { 
       
   440             sp->EnableTransparent( ETrue );
       
   441             sp->DrawNow();
       
   442             }    
       
   443         }
       
   444 
       
   445     if ( aCustomMessage == KSetWallpaper )
       
   446         {
       
   447         iAction = ESetWallpaper;
       
   448         
       
   449         iTimer->Cancel();
       
   450         iTimer->Start( 1000, 1000, TCallBack( TimerCallback, this ) );        
       
   451         }
       
   452     
       
   453     // Set the active container
       
   454     if ( aCustomMessage == KActivateDefaultView )
       
   455         {
       
   456         __PRINTS( "*** CXnViewAdapter::DoActivateL - activating default container" );
       
   457     
       
   458         ActivateDefaultContainerL();
       
   459     
       
   460         iAction = EActivateDefault;
       
   461         
       
   462         iTimer->Cancel();
       
   463         iTimer->Start( 1000, 1000, TCallBack( TimerCallback, this ) );
       
   464         }
       
   465     else
       
   466         {
       
   467         __PRINTS( "*** CXnViewAdapter::DoActivateL - activating container" );
       
   468     
       
   469         ActivateContainerL( viewData );
       
   470         }
       
   471 			  
       
   472     __TIME_ENDMARK( "CXnViewAdapter::DoActivateL, done", time );
       
   473     
       
   474     __TICK( "CXnViewAdapter::DoActivateL - HS UI Ready" );
       
   475     }
       
   476 
       
   477 // -----------------------------------------------------------------------------
       
   478 // CXnViewAdapter::TimerCallback
       
   479 // 
       
   480 // -----------------------------------------------------------------------------
       
   481 //
       
   482 TInt CXnViewAdapter::TimerCallback( TAny *aPtr )
       
   483     {
       
   484     __PRINTS( "*** CXnViewAdapter::TimerCallback" );
       
   485     
       
   486     CXnViewAdapter* self = reinterpret_cast< CXnViewAdapter* >( aPtr );
       
   487     self->iTimer->Cancel();
       
   488     
       
   489     if ( self->iAction == EActivateDefault )
       
   490         {
       
   491         self->iCoeEnv->WsSession().SetWindowGroupOrdinalPosition(
       
   492                 self->iCoeEnv->RootWin().Identifier(), 0 );    
       
   493         }
       
   494     else if ( self->iAction == ESetWallpaper )
       
   495         {
       
   496         CAknViewAppUi& appui = static_cast< CAknViewAppUi& >( self->iAppUiAdapter );
       
   497         
       
   498         CXnWallpaperView* view = 
       
   499             static_cast< CXnWallpaperView* >( appui.View( KWallpaperViewUid ) );
       
   500         
       
   501         if ( view )
       
   502             {
       
   503             TFileName filename( KNullDesC );
       
   504             
       
   505             // Get selected wallpaper
       
   506             view->SelectedWallpaper( filename );
       
   507             
       
   508             if ( filename != KNullDesC )
       
   509                 {
       
   510                 if ( self->BgManager().SetWallpaper( filename ) )
       
   511                     {
       
   512                     self->iAppUiAdapter.EffectManager()->BgAppearEffect( 
       
   513                         self->iBgManager, ETrue );                     
       
   514                     }                                              
       
   515                 }                        
       
   516             }        
       
   517         }
       
   518     
       
   519     self->iAction = ENoAction;
       
   520 
       
   521     __PRINTS( "*** CXnViewAdapter::TimerCallback, done" );
       
   522     
       
   523     return KErrNone;
       
   524     }
       
   525 
       
   526 // -----------------------------------------------------------------------------
       
   527 // CXnViewAdapter::DoDeactivate
       
   528 // Deactivates view.
       
   529 // -----------------------------------------------------------------------------
       
   530 //
       
   531 void CXnViewAdapter::DoDeactivate()
       
   532     {        
       
   533     if ( iFlags.IsSet( EIsDestructionRunning ) )
       
   534         {
       
   535         return;
       
   536         }
       
   537     
       
   538     __PRINTS( "*** CXnViewAdapter::DoDeactivate" );
       
   539     __TIME_MARK( time );
       
   540     
       
   541     iAppUiAdapter.RemoveFromStack( iEventDispatcher );
       
   542 
       
   543     TRAP_IGNORE( DeactivateContainerL() );
       
   544     
       
   545     iBgManager->MakeVisible( EFalse );
       
   546     
       
   547     iFocusControl->MakeVisible( EFalse );
       
   548     
       
   549     iFlags.Clear( EIsActivated );
       
   550     
       
   551     __TIME_ENDMARK( "CXnViewAdapter::DoDeactivate, done", time );
       
   552     }
       
   553 
       
   554 // -----------------------------------------------------------------------------
       
   555 // CXnViewAdapter::ActivateContainerL
       
   556 // Activates container
       
   557 // -----------------------------------------------------------------------------
       
   558 //
       
   559 void CXnViewAdapter::ActivateContainerL( CXnViewData& aContainer, 
       
   560     TBool aEnterEditState, TUid aEffect )
       
   561     {
       
   562     // Returns if the container remains the same and activation is not forced
       
   563     // Otherwise the old container is deactivated and the new is activated
       
   564     if ( iFlags.IsSet( EIsDestructionRunning ) || iContainer == &aContainer )        
       
   565         {
       
   566         return;
       
   567         }
       
   568     
       
   569     if ( iFlags.IsClear( EIsActivated ) )
       
   570         {
       
   571         // Some other view than this in this appui is currently active,
       
   572         // postpone container activation
       
   573         return;
       
   574         }
       
   575  
       
   576     const CXnViewData& active( iAppUiAdapter.ViewManager().ActiveViewData() );
       
   577     
       
   578     CXnEffectManager* mgr( iAppUiAdapter.EffectManager() );
       
   579     
       
   580     CleanupStack::PushL( TCleanupItem( CleanupEffect, mgr ) );
       
   581     
       
   582     TBool started(
       
   583         mgr->BeginActivateViewEffect( active, aContainer, aEffect ) );
       
   584     
       
   585     DeactivateContainerL( EFalse );
       
   586         
       
   587     // Update  
       
   588     iContainer = &aContainer;
       
   589     
       
   590     // Disable layout and redraw until container activation is done
       
   591     iAppUiAdapter.UiEngine().DisableRenderUiLC();
       
   592 
       
   593     // Try exit controls from powersave mode
       
   594     ChangeControlsStateL( ETrue );
       
   595     
       
   596     if ( !iActivate )
       
   597         {
       
   598         iActivate = BuildActivateTriggerL( iAppUiAdapter.UiEngine() );
       
   599         }
       
   600 
       
   601     CXnNode* node( aContainer.Node()->LayoutNode() );
       
   602     
       
   603     CXnDomStringPool* sp( node->DomNode()->StringPool() );
       
   604     
       
   605     CXnProperty* prop = CXnProperty::NewL(
       
   606         XnPropertyNames::style::common::KDisplay, 
       
   607         XnPropertyNames::style::common::display::KBlock,
       
   608         CXnDomPropertyValue::EString, *sp );
       
   609     CleanupStack::PushL( prop );    
       
   610     
       
   611     node->SetPropertyWithoutNotificationL( prop );
       
   612     CleanupStack::Pop( prop );
       
   613     
       
   614     node->ReportXuikonEventL( *iActivate );
       
   615                            
       
   616     if ( iFlags.IsSet( EIsInCall ) )
       
   617         {
       
   618         iFlags.Clear( EIsInCall );
       
   619         
       
   620         // This container is in-call state
       
   621         NotifyInCallStateChaged( ETrue );        
       
   622         }
       
   623        
       
   624     if ( aEnterEditState || iAppUiAdapter.UiEngine().IsEditMode() )
       
   625         {
       
   626         EnterEditStateL( aContainer, ETrue );                        
       
   627         }
       
   628     else
       
   629         {
       
   630         EnterEditStateL( aContainer, EFalse );                                
       
   631         }
       
   632     
       
   633     CXnControlAdapter* adapter( node->Control() );
       
   634     adapter->MakeVisible( ETrue );
       
   635            
       
   636     iAppUiAdapter.ViewManager().NotifyContainerChangedL( aContainer );
       
   637     
       
   638     iBgManager->ChangeWallpaper( active, aContainer, !started );
       
   639     
       
   640     iAppUiAdapter.UiEngine().RenderUIL();
       
   641     
       
   642     CleanupStack::PopAndDestroy(); // DisableRenderUiLC
       
   643     
       
   644     mgr->EndActivateViewEffect( active, aContainer, aEffect );
       
   645     
       
   646     CleanupStack::PopAndDestroy(); // cleanupitem
       
   647     
       
   648     iAppUiAdapter.ViewManager().UpdatePageManagementInformationL();
       
   649             
       
   650     if ( iEventDispatcher )
       
   651         {        
       
   652         iEventDispatcher->SetMenuNodeL( 
       
   653             iAppUiAdapter.UiEngine().MenuBarNode() );            
       
   654         }    
       
   655     }
       
   656 
       
   657 // -----------------------------------------------------------------------------
       
   658 // CXnViewAdapter::ActivateDefaultContainerL
       
   659 // Activates default container
       
   660 // -----------------------------------------------------------------------------
       
   661 //
       
   662 void CXnViewAdapter::ActivateDefaultContainerL( TBool aEnterEditState )
       
   663     {
       
   664     CXnRootData& rootData( iAppUiAdapter.ViewManager().ActiveAppData() );
       
   665     
       
   666     RPointerArray< CXnPluginData >& views( rootData.PluginData() );
       
   667     
       
   668     if ( !views.Count() )
       
   669         {
       
   670         return;
       
   671         }    
       
   672     
       
   673     // first view is default
       
   674     CXnViewData* viewData = static_cast<CXnViewData*>( views[0] );
       
   675     
       
   676     if ( viewData )
       
   677         {
       
   678         EnterEditStateL( *viewData, aEnterEditState );
       
   679         // Deactivate container even though it hasn't changed to close all 
       
   680         // popups and other windows
       
   681         ActivateContainerL( *viewData, aEnterEditState );
       
   682         }
       
   683     }
       
   684 
       
   685 // -----------------------------------------------------------------------------
       
   686 // CXnViewAdapter::EnterEditStateL
       
   687 // Sets edit state property
       
   688 // -----------------------------------------------------------------------------
       
   689 //
       
   690 void CXnViewAdapter::EnterEditStateL( CXnViewData& aView, TBool aEnter )
       
   691     {
       
   692     if ( !iEditState )
       
   693         {
       
   694         iEditState = BuildEditStateTriggerL( iAppUiAdapter.UiEngine() ); 
       
   695         }
       
   696     
       
   697     CXnProperty* prop( iEditState->GetPropertyL( 
       
   698         XnPropertyNames::action::KValue ) );
       
   699     
       
   700     if ( !prop )
       
   701         {
       
   702         return;
       
   703         }
       
   704     
       
   705     if ( aEnter )
       
   706         {
       
   707         static_cast< CXnDomPropertyValue* >(
       
   708             prop->Property()->PropertyValueList().Item( 0 ) )
       
   709             ->SetStringValueL( CXnDomPropertyValue::EString,
       
   710             XnPropertyNames::action::trigger::name::editmode::KEnter() );
       
   711         }
       
   712     else
       
   713         {
       
   714         static_cast< CXnDomPropertyValue* >(
       
   715             prop->Property()->PropertyValueList().Item( 0 ) )
       
   716             ->SetStringValueL( CXnDomPropertyValue::EString,
       
   717             XnPropertyNames::action::trigger::name::editmode::KExit() );
       
   718         }
       
   719     
       
   720     if ( aView.Node() && aView.Node()->LayoutNode() )
       
   721         {
       
   722         aView.Node()->LayoutNode()->ReportXuikonEventL( *iEditState );
       
   723         }
       
   724     }
       
   725 
       
   726 // -----------------------------------------------------------------------------
       
   727 // CXnViewAdapter::DeactivateContainerL
       
   728 // Deactivates current container
       
   729 // -----------------------------------------------------------------------------
       
   730 //
       
   731 void CXnViewAdapter::DeactivateContainerL( TBool aHide )
       
   732     {
       
   733     if ( !iContainer || iFlags.IsSet( EIsDestructionRunning ) )    
       
   734         {
       
   735         return;
       
   736         }
       
   737     
       
   738     CloseAllPopupsL();
       
   739     
       
   740     // Run controls to powersave mode
       
   741     ChangeControlsStateL( EFalse );
       
   742 
       
   743     CXnNode* node( iContainer->Node()->LayoutNode() );
       
   744     
       
   745     CXnDomStringPool* sp( node->DomNode()->StringPool() );
       
   746     
       
   747     CXnProperty* prop = CXnProperty::NewL(
       
   748         XnPropertyNames::style::common::KDisplay, 
       
   749         XnPropertyNames::style::common::display::KNone,
       
   750         CXnDomPropertyValue::EString, *sp );
       
   751     CleanupStack::PushL( prop );    
       
   752     
       
   753     node->SetPropertyWithoutNotificationL( prop );
       
   754     CleanupStack::Pop( prop );
       
   755     
       
   756     if ( !iDeactivate )
       
   757         {
       
   758         iDeactivate = BuildDeactivateTriggerL( iAppUiAdapter.UiEngine() );
       
   759         }
       
   760                   
       
   761     node->ReportXuikonEventL( *iDeactivate );
       
   762        
       
   763     if ( aHide )
       
   764         {
       
   765         node->Control()->MakeVisible( EFalse );
       
   766         }
       
   767         
       
   768     iContainer = NULL;
       
   769     }
       
   770 
       
   771 // -----------------------------------------------------------------------------
       
   772 // CXnViewAdapter::NotifyForegroundChanged
       
   773 // 
       
   774 // -----------------------------------------------------------------------------
       
   775 //
       
   776 void CXnViewAdapter::NotifyForegroundChanged( 
       
   777     MXnUiStateObserver::TForegroundStatus aStatus ) 
       
   778     {     
       
   779     if ( aStatus == MXnUiStateObserver::EPartialForeground || 
       
   780          aStatus == MXnUiStateObserver::EBackground )
       
   781         {
       
   782         iFlags.Clear( EIsForeground );
       
   783 
       
   784         CXnEditMode* editMode = iAppUiAdapter.UiEngine().EditMode();
       
   785         if( editMode )
       
   786             {
       
   787             TRAP_IGNORE( editMode->StopDraggingL() );
       
   788             }
       
   789 
       
   790         iFocusControl->MakeVisible( EFalse );
       
   791         
       
   792         TRAP_IGNORE( ChangeControlsStateL( EFalse ) );
       
   793         }
       
   794     else
       
   795         {
       
   796         iFlags.Set( EIsForeground );
       
   797         
       
   798         TRAP_IGNORE( ChangeControlsStateL( ETrue ) );               
       
   799         }
       
   800     }
       
   801 
       
   802 // -----------------------------------------------------------------------------
       
   803 // CXnViewAdapter::NotifyLightStatusChanged
       
   804 // 
       
   805 // -----------------------------------------------------------------------------
       
   806 //
       
   807 void CXnViewAdapter::NotifyLightStatusChanged( TBool aLightsOn )
       
   808     {       
       
   809     if ( aLightsOn )
       
   810         {
       
   811         iFlags.Set( EIsLightsOn );
       
   812         
       
   813         TRAP_IGNORE( ChangeControlsStateL( ETrue ) );        
       
   814         }
       
   815     else 
       
   816         {
       
   817         iFlags.Clear( EIsLightsOn );
       
   818         
       
   819         TRAP_IGNORE( ChangeControlsStateL( EFalse ) );        
       
   820         }        
       
   821     }
       
   822 
       
   823 // -----------------------------------------------------------------------------
       
   824 // CXnViewAdapter::NotifyInCallStateChaged
       
   825 // 
       
   826 // -----------------------------------------------------------------------------
       
   827 //
       
   828 void CXnViewAdapter::NotifyInCallStateChaged( TBool aInCall )
       
   829     {       
       
   830     if ( !iContainer )
       
   831         {
       
   832         return;
       
   833         }
       
   834 
       
   835     TBool incallNow( iFlags.IsSet( EIsInCall ) ? ETrue : EFalse );
       
   836 
       
   837     if ( incallNow == aInCall )
       
   838         {
       
   839         return;
       
   840         }
       
   841 
       
   842     if ( aInCall )
       
   843         {
       
   844         iFlags.Set( EIsInCall );
       
   845         }
       
   846     else
       
   847         {
       
   848         iFlags.Clear( EIsInCall );
       
   849         }
       
   850 
       
   851     CXnViewData& view( iAppUiAdapter.ViewManager().ActiveViewData() );
       
   852     
       
   853     TRAP_IGNORE( UpdateRskByUiStateL( view ) );
       
   854     }
       
   855 
       
   856 // -----------------------------------------------------------------------------
       
   857 // CXnViewAdapter::ChangeControlsStateL
       
   858 // 
       
   859 // -----------------------------------------------------------------------------
       
   860 //
       
   861 void CXnViewAdapter::ChangeControlsStateL( TBool aAwake )
       
   862     {
       
   863     if ( !iContainer )
       
   864         {
       
   865         return;
       
   866         }
       
   867 
       
   868     TBool awakeNow( iFlags.IsSet( EIsControlsAwake ) ? ETrue : EFalse );
       
   869     
       
   870     if ( aAwake == awakeNow )
       
   871         {
       
   872         // No change in the state
       
   873         return;
       
   874         }
       
   875 
       
   876     TBool changeState( EFalse );
       
   877     
       
   878     if ( aAwake )
       
   879         {
       
   880         if ( iFlags.IsSet( EIsForeground ) && iFlags.IsSet( EIsLightsOn ) )
       
   881             {
       
   882             iFlags.Set( EIsControlsAwake );
       
   883             changeState = ETrue;
       
   884             }       
       
   885         }
       
   886     else
       
   887         {
       
   888         iFlags.Clear( EIsControlsAwake );
       
   889         changeState = ETrue;
       
   890         }
       
   891     
       
   892     if( changeState )
       
   893         {
       
   894         RPointerArray< CXnControlAdapter > controls;
       
   895         CleanupClosePushL( controls );
       
   896         
       
   897         iContainer->ControlsL( controls );
       
   898         
       
   899         for ( TInt i = 0; i < controls.Count(); i++ )
       
   900             {
       
   901             if ( aAwake )
       
   902                 {
       
   903                 controls[i]->ExitPowerSaveModeL();
       
   904                 }
       
   905             else
       
   906                 {
       
   907                 controls[i]->EnterPowerSaveModeL();
       
   908                 if ( controls[i]->LongTapDetector() && 
       
   909                         controls[i]->LongTapDetector()->IsActive() )
       
   910                     {
       
   911                     controls[i]->LongTapDetector()->Cancel();
       
   912                     }
       
   913                 }               
       
   914             }
       
   915             
       
   916         CleanupStack::PopAndDestroy( &controls );            
       
   917         }           
       
   918     }
       
   919 
       
   920 // -----------------------------------------------------------------------------
       
   921 // CXnViewAdapter::UpdateRskByUiStateL()
       
   922 // 
       
   923 // -----------------------------------------------------------------------------
       
   924 //
       
   925 void CXnViewAdapter::UpdateRskByUiStateL( const CXnViewData& aViewData )
       
   926     {
       
   927     CXnNode* menubar( NULL );
       
   928     
       
   929     CXnDomNode* view( aViewData.Node() );
       
   930     
       
   931     if ( view && view->LayoutNode() )
       
   932         {
       
   933         RPointerArray< CXnNode >& children( view->LayoutNode()->Children() );
       
   934         
       
   935         for ( TInt count = children.Count() - 1; count >= 0 ; --count )
       
   936             {
       
   937             CXnNode* node( children[count] );
       
   938 
       
   939             // Check that the given type of a control is parent
       
   940             // (or ancestor) of this control
       
   941             const TDesC8& type( node->Type()->Type() );
       
   942             
       
   943             if ( type == KMenuBar )
       
   944                 {
       
   945                 menubar = node;
       
   946                 break;
       
   947                 }
       
   948             }        
       
   949         }
       
   950     
       
   951     if( menubar )
       
   952         {
       
   953         const TDesC8* state( NULL );
       
   954         
       
   955         if( iAppUiAdapter.UiEngine().IsEditMode() )
       
   956             {
       
   957             state = &XnPropertyNames::softkey::mode::KModeEdit;
       
   958             }     
       
   959         else if( iFlags.IsSet( EIsInCall ) )
       
   960             {
       
   961             state = &XnPropertyNames::softkey::mode::KModeCallActive;
       
   962             }
       
   963         else
       
   964             {
       
   965             state = &XnPropertyNames::softkey::mode::KModeCallInactive;
       
   966             }
       
   967         
       
   968         XnMenuInterface::MXnMenuInterface* menuIf( NULL );
       
   969         XnComponentInterface::MakeInterfaceL( menuIf, menubar->AppIfL() );
       
   970                
       
   971         RPointerArray<CXnNode>& childrens( menubar->Children() );
       
   972         
       
   973         for( TInt i=0; i < childrens.Count(); i++ )
       
   974             {
       
   975             CXnNode* node = childrens[i];
       
   976             
       
   977             if( node && node->Type()->Type() == XnPropertyNames::softkey::KNodeName )
       
   978                 {                  
       
   979                 CXnProperty* mode = node->GetPropertyL( XnPropertyNames::softkey::KModeAttribute );
       
   980                 CXnProperty* type = node->GetPropertyL( XnPropertyNames::softkey::KTypeAttribute );
       
   981                 
       
   982                 if( ( mode && *state == mode->StringValue() ) &&
       
   983                         ( type && type->StringValue().Compare( XnPropertyNames::softkey::type::KRight ) == 0 ) )
       
   984                     {
       
   985                     menuIf->SetSoftKeyL( &node->PluginIfL() , XnMenuInterface::MXnMenuInterface::ERight );
       
   986                     node->SetDirtyL( XnDirtyLevel::ERender );
       
   987                                        
       
   988                     TRAP_IGNORE( iAppUiAdapter.UiEngine().RefreshMenuL() );                   
       
   989                     } 
       
   990                 }
       
   991             }
       
   992         }
       
   993     }
       
   994 
       
   995 // -----------------------------------------------------------------------------
       
   996 // CXnViewAdapter::CloseAllPopupsL()
       
   997 // 
       
   998 // -----------------------------------------------------------------------------
       
   999 //
       
  1000 void CXnViewAdapter::CloseAllPopupsL()
       
  1001     {
       
  1002     if ( !iContainer )
       
  1003         {
       
  1004         return;
       
  1005         }
       
  1006     
       
  1007     RPointerArray< CXnNode > popups;
       
  1008     CleanupClosePushL( popups );
       
  1009     
       
  1010     iContainer->PopupNodesL( popups );
       
  1011     
       
  1012     for ( TInt i = 0; i < popups.Count(); i++ )
       
  1013         {
       
  1014         CXnProperty* display = CXnProperty::NewL(
       
  1015             XnPropertyNames::style::common::KDisplay,
       
  1016             XnPropertyNames::style::common::display::KNone,
       
  1017             CXnDomPropertyValue::EString,
       
  1018             *iAppUiAdapter.UiEngine().ODT()->DomDocument().StringPool() );
       
  1019         
       
  1020         CleanupStack::PushL( display );         
       
  1021         popups[i]->SetPropertyL(display);             
       
  1022         CleanupStack::Pop( display );
       
  1023         }
       
  1024         
       
  1025     CleanupStack::PopAndDestroy( &popups );
       
  1026     }
       
  1027 
       
  1028 
       
  1029 // End of file