/*

* Copyright (c) 2008 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

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

* which accompanies this distribution, and is available

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

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:  Xuikon view adapter source file

*

*/

// System includes

#include <aknViewAppUi.h>

#include <eikbtgpc.h>

#include <avkon.rsg>

// User includes

#include "xnappuiadapter.h"

#include "xnviewmanager.h"

#include "xnviewdata.h"

#include "xnuiengine.h"

#include "xnkeyeventdispatcher.h"

#include "xncontroladapter.h"

#include "xndomdocument.h"

#include "xndomnode.h"

#include "xndomlist.h"

#include "xnodt.h"

#include "xnproperty.h"

#include "xnnodeimpl.h"

#include "xnnode.h"

#include "xntype.h"

#include "xnfocuscontrol.h"

#include "xneditor.h"

#include "xnbackgroundmanager.h"

#include "xneffectmanager.h"

#include "xnwallpaperview.h"

#include "xnviewadapter.h"

#include "xnmenu.h"

#include "xneditmode.h"

#include "xnrootdata.h"

#include "debug.h"

// Constants

const TUid KXmlViewUid = { 1 };

_LIT8( KActivateDefaultView, "activatedefault" );

_LIT8( KSetWallpaper, "setwallpaper" );

_LIT8( KMenuBar, "menubar" );

// Data types

enum 

    {

    EIsActivated,    

    EIsInCall,

    EIsLightsOn,

    EIsForeground,    

    EIsControlsAwake,    

    EIsDestructionRunning

    };

enum TAction

    {

    ENoAction = 0,

    EActivateDefault,

    ESetWallpaper

    };

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

// -----------------------------------------------------------------------------

// CleanupEffect

// -----------------------------------------------------------------------------

//

static void CleanupEffect( TAny* aAny )

    {

    static_cast< CXnEffectManager* >( aAny )->CleanupControlEffect();

    }

// -----------------------------------------------------------------------------

// DetermineStatusPaneLayout

// -----------------------------------------------------------------------------

//

static TInt DetermineStatusPaneLayout( CXnProperty* aProperty )

    {

    TInt spane( KErrNotFound );

    if ( aProperty )

        {

        const TDesC8& value( aProperty->StringValue() );

        // Currently supported status pane layout

        if ( value == XnPropertyNames::view::statuspanelayout::KNone )

            {

            spane = R_AVKON_STATUS_PANE_LAYOUT_EMPTY;

            }

        if ( value == XnPropertyNames::view::statuspanelayout::KBasic )

            {

            spane = R_AVKON_STATUS_PANE_LAYOUT_IDLE;

            }

        else if ( value == XnPropertyNames::view::statuspanelayout::KBasicFlat )

            {

            spane = R_AVKON_STATUS_PANE_LAYOUT_IDLE_FLAT;

            }

        else if ( value ==

                  XnPropertyNames::view::statuspanelayout::KWideScreen )

            {

            spane = R_AVKON_WIDESCREEN_PANE_LAYOUT_IDLE;

            }

        else if ( value ==

                  XnPropertyNames::view::statuspanelayout::KWideScreenFlat )

            {

            spane = R_AVKON_WIDESCREEN_PANE_LAYOUT_IDLE_FLAT;

            }

        else if ( value ==

                  XnPropertyNames::view::statuspanelayout::

                  KWideScreenFlat3Softkeys )

            {

            spane = R_AVKON_WIDESCREEN_PANE_LAYOUT_IDLE_FLAT_NO_SOFTKEYS;

            }

        }

    return spane;

    }

// -----------------------------------------------------------------------------

// BuildTriggerL

// -----------------------------------------------------------------------------

//

static CXnNode* BuildTriggerL(

    CXnUiEngine& aUiEngine,

    const TDesC8& aTriggerName )

    {

    CXnNode* node = CXnNode::NewL();

    CleanupStack::PushL( node );

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

    CleanupStack::PushL( type );

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

    CleanupStack::Pop( type );

    node->SetImpl( impl );

    node->SetUiEngine( aUiEngine );

    CXnDomPropertyValue* nameValue = CXnDomPropertyValue::NewL(

        aUiEngine.ODT()->DomDocument().StringPool() );

    CleanupStack::PushL( nameValue );

    nameValue->SetStringValueL( CXnDomPropertyValue::EString, aTriggerName );

    CXnProperty* name = CXnProperty::NewL(

        XnPropertyNames::action::trigger::KName,

        nameValue,

        *aUiEngine.ODT()->DomDocument().StringPool() );

    CleanupStack::Pop( nameValue );

    CleanupStack::PushL( name );

    node->SetPropertyL( name );

    CleanupStack::Pop( 2, node ); // name 

    return node;

    }

// -----------------------------------------------------------------------------

// BuildActivateTriggerL

// -----------------------------------------------------------------------------

//

static CXnNode* BuildActivateTriggerL( CXnUiEngine& aUiEngine )

    {

    return BuildTriggerL(

        aUiEngine, XnPropertyNames::action::trigger::name::KViewActivate );

    }

// -----------------------------------------------------------------------------

// BuildDeactivateTriggerL

// -----------------------------------------------------------------------------

//

static CXnNode* BuildDeactivateTriggerL( CXnUiEngine& aUiEngine )

    {

    return BuildTriggerL(

        aUiEngine, XnPropertyNames::action::trigger::name::KViewDeactivate );

    }

// -----------------------------------------------------------------------------

// BuildEditStateTriggerL

// -----------------------------------------------------------------------------

//

static CXnNode* BuildEditStateTriggerL( CXnUiEngine& aUiEngine )

    {

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

    CXnProperty* value = CXnProperty::NewL(

        XnPropertyNames::action::KValue,

        KNullDesC8, CXnDomPropertyValue::EString, *sp );

    CleanupStack::PushL( value );

    CXnNode* trigger( BuildTriggerL(

        aUiEngine, XnPropertyNames::action::trigger::name::KEditMode ) );    

    CleanupStack::PushL( trigger );

    trigger->SetPropertyL( value );

    CleanupStack::Pop( 2, value ); // trigger

    return trigger;

    }

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

// -----------------------------------------------------------------------------

// CXnViewAdapter::CXnViewAdapter

// C++ default constructor can NOT contain any code, that

// might leave.

// -----------------------------------------------------------------------------

//

CXnViewAdapter::CXnViewAdapter( CXnAppUiAdapter& aAdapter )

    : iAppUiAdapter( aAdapter )

    {

    }

// -----------------------------------------------------------------------------

// CXnViewAdapter::~CXnViewAdapter

// Destructor.

// -----------------------------------------------------------------------------

//

CXnViewAdapter::~CXnViewAdapter()

    {

    delete iTimer;

    delete iActivate;

    delete iDeactivate;

    delete iEditState;    

    delete iBgManager;

    delete iFocusControl;

    }

// -----------------------------------------------------------------------------

// CXnViewAdapter::NewL

// 2nd phase construction.

// -----------------------------------------------------------------------------

//

CXnViewAdapter* CXnViewAdapter::NewL( CXnAppUiAdapter& aAdapter )

    {

    CXnViewAdapter* self = new ( ELeave ) CXnViewAdapter( aAdapter );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

// -----------------------------------------------------------------------------

// CXnViewAdapter::ConstructL

// 2nd phase construction.

// -----------------------------------------------------------------------------

//

void CXnViewAdapter::ConstructL()

    {

    BaseConstructL();

    iTimer = CPeriodic::NewL( CActive::EPriorityIdle );

    // Base class CAknViewAppUi takes ownership of iViewAdapter

    iAppUiAdapter.AddViewL( this );    

    iAppUiAdapter.SetDefaultViewL( *this );

    iBgManager = CXnBackgroundManager::NewL( iAppUiAdapter.ViewManager(),

        iAppUiAdapter.ViewManager().Editor().HspsWrapper() );

    iFocusControl = CXnFocusControl::NewL( iAppUiAdapter );   

    iEventDispatcher = 

        CXnKeyEventDispatcher::NewL( iAppUiAdapter.UiEngine() );

    iAppUiAdapter.UiEngine().SetEventDispatcher( iEventDispatcher );

    iAppUiAdapter.UiStateListener().AddObserver( *this );

    }

// -----------------------------------------------------------------------------

// CXnViewAdapter::ReloadUiL

// Called when application UI is reloaded

// -----------------------------------------------------------------------------

//

void CXnViewAdapter::ReloadUiL()

    {

    iTimer->Cancel();

    iAction = ENoAction;

    DeactivateContainerL();

    iAppUiAdapter.RemoveFromStack( iEventDispatcher );

    delete iEventDispatcher;

    iEventDispatcher = NULL;

    delete iActivate;

    iActivate = NULL;

    delete iDeactivate;

    iDeactivate = NULL;

    delete iEditState;

    iEditState = NULL;

    iEventDispatcher = CXnKeyEventDispatcher::NewL( iAppUiAdapter.UiEngine() );

    iAppUiAdapter.UiEngine().SetEventDispatcher( iEventDispatcher );

    if ( iFlags.IsSet( EIsActivated ) )

        {

        iAppUiAdapter.AddToStackL( *this, iEventDispatcher );

        }

    }

// -----------------------------------------------------------------------------

// CXnViewAdapter::PrepareToExit

// Sets view to be destroyed

// -----------------------------------------------------------------------------

//

void CXnViewAdapter::PrepareToExit()

    {                

    iAppUiAdapter.RemoveFromStack( iEventDispatcher );

    delete iEventDispatcher;

    iEventDispatcher = NULL;

    iAppUiAdapter.UiEngine().SetEventDispatcher( NULL );

    iContainer = NULL;

    iFlags.Set( EIsDestructionRunning );    

    }

// -----------------------------------------------------------------------------

// CXnViewAdapter::EventDispatcher

// Get event dispatcher

// -----------------------------------------------------------------------------

//

CXnKeyEventDispatcher* CXnViewAdapter::EventDispatcher() const

    {

    return iEventDispatcher;

    }

// -----------------------------------------------------------------------------

// CXnViewAdapter::BgManager

// Returns background manager.

// -----------------------------------------------------------------------------

//

CXnBackgroundManager& CXnViewAdapter::BgManager() const

    {

    return *iBgManager;

    }

// -----------------------------------------------------------------------------

// CXnViewAdapter::FocusControl

// Returns focus control.

// -----------------------------------------------------------------------------

//

CXnFocusControl& CXnViewAdapter::FocusControl() const

    {

    return *iFocusControl;

    }

// -----------------------------------------------------------------------------

// CXnViewAdapter::Id

// Returns view uid.

// -----------------------------------------------------------------------------

//

TUid CXnViewAdapter::Id() const

    {

    return KXmlViewUid;

    }

// -----------------------------------------------------------------------------

// CXnViewAdapter::DoActivateL

// Activates view.

// -----------------------------------------------------------------------------

//

void CXnViewAdapter::DoActivateL( const TVwsViewId& /*aPrevViewId*/,    

    TUid /*aCustomMessageId*/,

    const TDesC8& aCustomMessage )

    {

    if ( iFlags.IsSet( EIsDestructionRunning ) )

        {

        return;

        }

    __TICK( "CXnViewAdapter::DoActivateL" );

    __TIME_MARK( time );

    iFlags.Set( EIsActivated );

    // State must be cleared before adding to stack

    iEventDispatcher->ClearStateL();

    iAppUiAdapter.AddToStackL( *this, iEventDispatcher );

    // enable statuspane transparancy 

    CEikStatusPane* sp( iAppUiAdapter.StatusPane() );

    CEikButtonGroupContainer* bgc( iAppUiAdapter.Cba() );

    if ( bgc )

        {

        // EventDispatcher will handle sotkey keyevents 

        CEikCba* cba( 

            static_cast< CEikCba* >( bgc->ButtonGroup() ) );

        iAppUiAdapter.RemoveFromStack( cba );        

        }

    iBgManager->MakeVisible( ETrue );

    // Set status pane layout

    CXnViewData& viewData( iAppUiAdapter.ViewManager().ActiveViewData() );

    CXnProperty* prop( viewData.Node()->LayoutNode()->GetPropertyL( 

        XnPropertyNames::view::KStatusPaneLayout ) );

    // Is there status pane declaration available

    TInt spane( DetermineStatusPaneLayout( prop ) );

    if ( spane != KErrNotFound )

        {

        if ( sp && sp->CurrentLayoutResId() != spane )

            {

            sp->SwitchLayoutL( spane );

            sp->ApplyCurrentSettingsL();

            }

        }    

    if ( sp && !sp->IsTransparent() ) 

        { 

        sp->EnableTransparent( ETrue );

        sp->DrawNow();

        }

    if ( aCustomMessage == KSetWallpaper )

        {

        iAction = ESetWallpaper;

        iTimer->Cancel();

        iTimer->Start( 1000, 1000, TCallBack( TimerCallback, this ) );        

        }

    // Set the active container

    if ( aCustomMessage == KActivateDefaultView )

        {

        __PRINTS( "*** CXnViewAdapter::DoActivateL - activating default container" );

        ActivateDefaultContainerL();

        iAction = EActivateDefault;

        iTimer->Cancel();

        iTimer->Start( 1000, 1000, TCallBack( TimerCallback, this ) );

        }

    else

        {

        __PRINTS( "*** CXnViewAdapter::DoActivateL - activating container" );

        ActivateContainerL( viewData );

        }

    __TIME_ENDMARK( "CXnViewAdapter::DoActivateL, done", time );

    __TICK( "CXnViewAdapter::DoActivateL - HS UI Ready" );

    }

// -----------------------------------------------------------------------------

// CXnViewAdapter::TimerCallback

// 

// -----------------------------------------------------------------------------

//

TInt CXnViewAdapter::TimerCallback( TAny *aPtr )

    {

    __PRINTS( "*** CXnViewAdapter::TimerCallback" );

    CXnViewAdapter* self = reinterpret_cast< CXnViewAdapter* >( aPtr );

    self->iTimer->Cancel();

    if ( self->iAction == EActivateDefault )

        {

        self->iCoeEnv->WsSession().SetWindowGroupOrdinalPosition(

                self->iCoeEnv->RootWin().Identifier(), 0 );    

        }

    else if ( self->iAction == ESetWallpaper )

        {

        CAknViewAppUi& appui = static_cast< CAknViewAppUi& >( self->iAppUiAdapter );

        CXnWallpaperView* view = 

            static_cast< CXnWallpaperView* >( appui.View( KWallpaperViewUid ) );

        if ( view )

            {

            TFileName filename( KNullDesC );

            // Get selected wallpaper

            view->SelectedWallpaper( filename );

            if ( filename != KNullDesC )

                {

                if ( self->BgManager().SetWallpaper( filename ) )

                    {

                    self->iAppUiAdapter.EffectManager()->BgAppearEffect( 

                        self->iBgManager, ETrue );                     

                    }                                              

                }                        

            }        

        }