/*

* Copyright (c) 2002-2004 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:  Implementation for Avkon AppUi adapter

*

*/

// System includes

#include <aknview.h>

#include <akntoolbar.h>

#include <avkon.rsg>

// User includes

#include <hspublisherinfo.h>

#include "xnappuiadapter.h"

#include "xnappuiadapterimpl.h"

#include "xnviewadapter.h"

#include "xnuiengineappif.h"

#include "xnfocuscontrol.h"

#include "hscontentcontrolfactory.h"

#include "xnviewadapter.h"

#include "xnnode.h"

#include "xuikon_builds_cfg.hrh"

#include "debug.h"

_LIT8( KActivateDefaultView, "activatedefault" );

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

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

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

// CXnAppUiAdapter::CXnAppUiAdapter

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

// might leave.

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

//

EXPORT_C CXnAppUiAdapter::CXnAppUiAdapter( TUid aApplicationUid )

    : iExitingApp( EFalse ), iApplicationUid( aApplicationUid )

    {    

    }

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

// CXnAppUiAdapter::ConstructL

// Second-phase constructor

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

//

EXPORT_C void CXnAppUiAdapter::ConstructL()

    {

    __TICK( "CXnAppUiAdapter::ConstructL" );    

    __TIME_MARK( time );

    __PRINTS( "*** CXnAppUiAdapter::ConstructL - BaseConstructL" );

    __TIME_MARK( time2 );

    EnableLocalScreenClearer( EFalse );

    CAknViewAppUi::BaseConstructL( EAknEnableSkin | EAknEnableMSK | EAknSingleClickCompatible );

    CAknToolbar* toolbar( CurrentFixedToolbar() );

    if ( toolbar )

        {

        toolbar->SetToolbarVisibility( EFalse );

        toolbar->DisableToolbarL( ETrue );

        }

    CEikStatusPane* sp( StatusPane() );

    if ( sp )

        {

        sp->EnableTransparent( ETrue );

        }

    __TIME_ENDMARK( "CXnAppUiAdapter::ConstructL - BaseConstructL, done", time2 );

    iImpl = CXnAppUiAdapterImpl::NewL( iApplicationUid, *this );

    iImpl->ConstructL();

    __TIME_ENDMARK( "CXnAppUiAdapter::ConstructL, done", time );

    }

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

// Destructor

//

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

//

EXPORT_C CXnAppUiAdapter::~CXnAppUiAdapter()

    {       

    delete iUiEngineAppIf;

    delete iImpl;    

    }

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

// CXnAppUiAdapter::HandleResourceChangeL

// Handles resource changes

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

//

EXPORT_C void CXnAppUiAdapter::HandleResourceChangeL( TInt aType )

    {

    __PRINTS( "*** CXnAppUiAdapter::HandleResourceChangeL" );

    __TIME_MARK( time );

    CAknViewAppUi::HandleResourceChangeL( aType );

    if ( iImpl )

        {

        iImpl->HandleResourceChangeL( aType );

        }

    __TIME_ENDMARK( "CXnAppUiAdapter::HandleResourceChangeL, done", time );

    }

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

// CXnAppUiAdapter::UiEngine

// Get UI engine proxy

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

//

EXPORT_C TXnUiEngineAppIf* CXnAppUiAdapter::UiEngineL()

    {

    if ( !iUiEngineAppIf )

        {

        iUiEngineAppIf = new ( ELeave ) TXnUiEngineAppIf( UiEngine() );

        }

    return iUiEngineAppIf;

    }

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

// CXnAppUiAdapter::HandleXuikonEventL

// Handle callbacks from the engine

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

//

EXPORT_C void CXnAppUiAdapter::HandleXuikonEventL(

    CXnNodeAppIf& /*aOrigin*/,

    CXnNodeAppIf& /*aTrigger*/,

    CXnDomNode& /*aTriggerDefinition*/,

    CXnDomNode& /*aEvent*/ )

    {

    // Default empty implementation

    }

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

// CXnAppUiAdapter::LoadPublisher

//

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

//

EXPORT_C void CXnAppUiAdapter::LoadPublisher( 

    const TAiFwPublisherInfo& /*aPublisher*/ )     

    {

    // Default empty implementation    

    }

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

// CXnAppUiAdapter::DestroyPublisher

//

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

//

EXPORT_C void CXnAppUiAdapter::DestroyPublisher( 

    const TAiFwPublisherInfo& /*aPublisher*/ )     

    {

    // Default empty implementation    

    }

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

// CXnAppUiAdapter::DynInitMenuItemL

//

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

//

EXPORT_C TBool CXnAppUiAdapter::DynInitMenuItemL( const TDesC& /*aItemType*/,          

    RPointerArray< CXnNodeAppIf >* /*aList*/ )

    {

    // Default empty implementation

    return EFalse;

    }

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

// CXnAppUiAdapter::View

//

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

//    

EXPORT_C CAknView& CXnAppUiAdapter::View() const

    {

    return iImpl->ViewAdapter();

    }

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

// CXnAppUiAdapter::HandleEnterEditModeL

//

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

//

EXPORT_C void CXnAppUiAdapter::HandleEnterEditModeL( TBool /*aEnter*/ )

    {

    // Default empty implementation

    }

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

// CXnAppUiAdapter::HandleEventL

//

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

//

EXPORT_C void CXnAppUiAdapter::HandleEventL( const TDesC& /*aEvent*/,

    CXnNodeAppIf& /*aDestination*/ )

    {

    // Default empty implementation

    }

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

// CXnAppUiAdapter::PublisherInfo

//

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

//

EXPORT_C TInt CXnAppUiAdapter::PublisherInfo( CXnNodeAppIf& /*aNode*/, 

    THsPublisherInfo& /*aInfo*/ )

    {

    // Default empty implementation    

    return KErrNotSupported;

    }

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

// CXnAppUiAdapter::PublisherInfo

//

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

//

TInt CXnAppUiAdapter::PublisherInfo( CXnNode& aNode, 

    THsPublisherInfo& aInfo )

    {

    CXnNodeAppIf* node( NULL );

    TRAPD( err, node = &aNode.AppIfL() );

    if ( node )

        {

        err = PublisherInfo( *node, aInfo );    

        }

    return err;

    }

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

// CXnAppUiAdapter::RemoveViewL

//

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

//

EXPORT_C void CXnAppUiAdapter::RemoveViewL( CAknView& aView )

    {

	if ( iExitingApp ) return; // framework will destroy view

    TVwsViewId activeViewId(KNullUid,KNullUid);

    TBool activateDefaultView( EFalse );

    if ( GetActiveViewId( activeViewId ) == KErrNone &&

        activeViewId.iViewUid == aView.Id() )

        {

        // currently active, deactivate        

        activateDefaultView = ETrue;

        DeactivateActiveViewIfOwnerMatchL();

        }

    if ( iView == &aView ) { iView = NULL; }

    CCoeAppUi::DeregisterView( aView );

    const TInt count( iViews->Count() );       

    for ( TInt i = 0; i < count; ++i )

        {

        CAknView* view( iViews->At( i ) );       

        if ( view == &aView && 

            view->Id() == aView.Id() )

            {

            iViews->Delete( i );           

            delete view;

            view = NULL;

            break;

            }

        }

    if ( activateDefaultView )

        {

        // check which view is active now.

        activeViewId = TVwsViewId(KNullUid,KNullUid);

        GetActiveViewId( activeViewId );

        TVwsViewId defaultViewId( KNullUid,KNullUid );    

        // activate default if needed

        if ( GetDefaultViewId( defaultViewId ) == KErrNone && 

            activeViewId != defaultViewId )

            {

            ActivateViewL( defaultViewId );

            }

        }

    }

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

// CXnAppUiAdapter::PrepareToExit

//

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

//

EXPORT_C void CXnAppUiAdapter::PrepareToExit()

    {

    iExitingApp = ETrue;

    if ( iImpl )

        {

        iImpl->UiStateListener().PrepareToExit();

        iImpl->ViewAdapter().PrepareToExit();

        iImpl->HsContentControlFactory()->PrepareToExit();

        }

    CAknViewAppUi::PrepareToExit();

    }

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

// CXnAppUiAdapter::HandleUiReadyEventL

//

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

//

EXPORT_C void CXnAppUiAdapter::HandleUiReadyEventL()

    {

    // Default empty implementation

    }

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

// CXnAppUiAdapter::ProcessMessageL

//

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

//

EXPORT_C void CXnAppUiAdapter::ProcessMessageL( TUid aUid,

    const TDesC8& /*aParams*/ )

    {

    if ( aUid.iUid == KUidApaMessageSwitchOpenFileValue )

        {

        // activate default homescreen view.

        // customcontrol is set so that window group order is not changed

        SetCustomControl( 1 );

        TRAP_IGNORE( ActivateLocalViewL(

                View().Id(), TUid::Null(), KActivateDefaultView() ) );

        SetCustomControl( 0 );

        }

    }

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

// CXnAppUiAdapter::ReloadUiL

//

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

//

void CXnAppUiAdapter::ReloadUiL()

    {    

    iImpl->ReloadUiL();

    }

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

// CXnAppUiAdapter::UiEngine

// 

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

//

CXnUiEngine& CXnAppUiAdapter::UiEngine() const

    {

    return iImpl->UiEngine();

    }

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

// CXnAppUiAdapter::ViewManager

// 

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

//

CXnViewManager& CXnAppUiAdapter::ViewManager() const

    {

    return iImpl->ViewManager();

    }

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

// CXnAppUiAdapter::ViewAdapter

// 

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

//

CXnViewAdapter& CXnAppUiAdapter::ViewAdapter() const

    {

    return iImpl->ViewAdapter();

    }

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

// CXnAppUiAdapter::UiStateListener

// 

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

//

CXnUiStateListener& CXnAppUiAdapter::UiStateListener() const

    {

    return iImpl->UiStateListener();

    }

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

// CXnAppUiAdapter::HsContentController

//

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

//

MHsContentControlUi* CXnAppUiAdapter::HsContentController( 

    const TDesC8& aType ) const

    {

    return iImpl->HsContentController( aType );

    }

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

// CXnAppUiAdapter::EffectManager

//

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

//

CXnEffectManager* CXnAppUiAdapter::EffectManager() const

    {

    return iImpl->EffectManager();

    }

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

// CXnAppUiAdapter::HsContentControlSrv

//

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

//

MHsContentControl* CXnAppUiAdapter::HsContentControlSrv() const

    {

    return iImpl->HsContentControlSrv();

    }

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

// CXnAppUiAdapter::ItemActivator

// 

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

//

CXnItemActivator& CXnAppUiAdapter::ItemActivator() const

    {

    return iImpl->ItemActivator();

    }

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

// CXnAppUiAdapter::FocusShown

//

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

//

TBool CXnAppUiAdapter::FocusShown() const

    {

    return iImpl->ViewAdapter().FocusControl().IsVisible();

    }

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

// CXnAppUiAdapter::HideFocus

//

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

//

void CXnAppUiAdapter::HideFocus() 

    {

    return iImpl->ViewAdapter().FocusControl().MakeVisible( EFalse );

    }

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

// CXnAppUiAdapter::ShowFocus

//

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

//

void CXnAppUiAdapter::ShowFocus()

    {

    return iImpl->ViewAdapter().FocusControl().MakeVisible( ETrue );

    }

// End of file