/*

* Copyright (c) 2006-2007 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:  Application UI class for vcommand app

*

*/

// INCLUDE FILES

#include <hlplch.h>

#include <featmgr.h>

#include <akntitle.h>  // CAknTitlePane

#include <barsread.h>  // TResourceReader

#include <StringLoader.h>

#include <AknQueryDialog.h>

#include <aknnotewrappers.h>

#include <e32property.h>        // RProperty

#include <PSVariables.h>        // Property values

#include <ctsydomainpskeys.h>

#include <vcommand.rsg>

#include "vcappui.h"

#include "vcmodelappuiinterface.h"

#include "vcgenericview.h"

#include "vcfolderview.h"

#include "vcsettingsview.h"

#include "vcommandconstants.h"

#include "vcmodel.h"

#include "rubydebug.h"

/**

* This is an application closer class. VCommandhandler needs to finish certain

* operations once they are started. Since the application receives key events

* all the time, including the ones requesting application exit, we ask the

* system to Call() this class a bit later. From its RunL it will gracefully

* close the application

*/

NONSHARABLE_CLASS( CAppCloser ) : public CAsyncOneShot 

	{

	public:

		CAppCloser();

	protected:

	    /** Is called by the system after we asked it to Call() closer

	    */

		virtual void RunL();

	};

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

//  Constructor

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

//

CAppCloser::CAppCloser() :

	CAsyncOneShot( CActive::EPriorityStandard )

	{

	}

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

//  CAppCloser::RunL

//  Will be called by the system and exits the application

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

//

void CAppCloser::RunL() 

	{

	if( iStatus == KErrNone ) 

		{

		static_cast<CVCAppUi*> ( CEikonEnv::Static()->AppUi() )->DoExitProgram();

		}

	else 

		{

		RUBY_ERROR1( "CAppCloser::RunL Unexpected iStatus [%d]", iStatus.Int() );

		}

	}

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

//

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

// CVCAppUi::ConstructL()

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

//

void CVCAppUi::ConstructL()

    {

    BaseConstructL( EAknEnableSkin | EAknEnableMSK | EAknSingleClickCompatible );

    iCloser = new (ELeave) CAppCloser;

    // Sets up TLS, must be done before FeatureManager is used.

    FeatureManager::InitializeLibL();

    iModel = CVCModel::NewL( this );

    iMainView = new (ELeave) CVCGenericView( *iModel );

    iMainView->ConstructL( R_VCOMMAND_MAIN_VIEW );

    AddViewL( iMainView );      // transfer ownership to CAknViewAppUi

    iFolderView = new (ELeave) CVCFolderView( *iModel );

    iFolderView->ConstructL( R_VCOMMAND_FOLDER_VIEW );

    AddViewL( iFolderView );      // transfer ownership to CAknViewAppUi

	CVCSettingsView* settingsView = new (ELeave) CVCSettingsView;

    CleanupStack::PushL( settingsView );

    settingsView->ConstructL();

    AddViewL( settingsView );      // transfer ownership to CAknViewAppUi

    CleanupStack::Pop( settingsView );   

    SetDefaultViewL( *iMainView );

    }

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

// CVCAppUi::~CVCAppUi()

// Destructor

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

//

CVCAppUi::~CVCAppUi() 

    {    

    delete iCloser;

    delete iModel;

    FeatureManager::UnInitializeLib();

    }

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

// CVCAppUi::DynInitMenuPaneL

// This function is called by the EIKON framework just before it displays

// a menu pane.

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

//

void CVCAppUi::DynInitMenuPaneL(

    TInt /*aResourceId*/,CEikMenuPane* /*aMenuPane*/)

    {

    }

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

// CVCAppUi::HandleCommandL

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

//

void CVCAppUi::HandleCommandL(TInt aCommand)

    {

    switch ( aCommand )

        {

        // Both exit commands should do the same thing

        case EEikCmdExit:

        case EAknSoftkeyExit:

            {

            ExitProgram();

            break;

            }

        case EAknCmdHelp:

            {

            HlpLauncher::LaunchHelpApplicationL( iEikonEnv->WsSession(),

                                                 AppHelpContextL() );

            break;

            }

        default:

            {

            CAknViewAppUi::HandleCommandL( aCommand );

            break;              

            }

        }

    }

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

// CVCAppUi::ExitProgram

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

//

void CVCAppUi::ExitProgram() 

    {

    if( iOperationInProgress ) 

        {

        iExitRequested = ETrue;

        }

    else 

        {

        DoExitProgram();

        }

    }

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

// CVCAppUi::DoExitProgram

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

//    

void CVCAppUi::DoExitProgram() 

    {

    Exit();

    }

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

// CVCAppUi::ExitProgramDeferred

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

//

void CVCAppUi::ExitProgramDeferred()

    {

    iCloser->Call();

    }

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

// CVCAppUi::StartAtomicOperationLC

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

//  

void CVCAppUi::StartAtomicOperationLC()

    {

    iOperationInProgress = ETrue;

    TCleanupItem item( CleanupEndAtomicOperation, this );

    CleanupStack::PushL( item );

    }

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

// CVCAppUi::NotifyEndOfAtomicOperationL

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

//   

void CVCAppUi::EndAtomicOperation()

    {

    iOperationInProgress = EFalse;

    if( iExitRequested ) 

        {

        RUBY_DEBUG0( "NotifyEndOfAtomicOperationL exit requested -> DoExit" );

        ExitProgramDeferred();

        // A function with a NotifyStartOfAtomicOperation -

        // NotifyEndOfAtomicOperation pair might be called from a function

        // with the same pair, so we make sure ExitProgramDeferred is called

        // only once in such a situation.

        iExitRequested = EFalse;

        }

    }

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

// CVCAppUi::CleanupEndAtomicOperation

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

//   

void CVCAppUi::CleanupEndAtomicOperation( TAny* aService )

    {

    CVCAppUi* service = static_cast<CVCAppUi*>(aService);

    service->EndAtomicOperation();

    }

void CVCAppUi::CreateAndPushEndAtomicCleanupItemL()

    {

    TCleanupItem item( CleanupEndAtomicOperation, this );

    CleanupStack::PushL( item );

    }

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

// CVCAppUi::SetTitleL

// Set title pane text from a resource.

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

//

void CVCAppUi::SetTitleL( TInt aResourceId )

    {

    CAknTitlePane* title = static_cast<CAknTitlePane*>(

        StatusPane()->ControlL( TUid::Uid( EEikStatusPaneUidTitle ) ) );

    TResourceReader reader;

    iCoeEnv->CreateResourceReaderLC( reader, aResourceId );

    title->SetFromResourceL( reader );

    CleanupStack::PopAndDestroy();  // resource reader

    }

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

// CVCAppUi::InvalidTextNoteL

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

//

void CVCAppUi::ShowErrorNoteL( TInt aResourceId )

    {

    HBufC* text = StringLoader::LoadLC( aResourceId );

    CAknErrorNote* note = new( ELeave ) CAknErrorNote( ETrue );

    note->ExecuteLD( *text );

    CleanupStack::PopAndDestroy( text );

    }

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

// CVCAppUi::NameAlreadyInUseNoteL

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

//

void CVCAppUi::NameAlreadyInUseNoteL( const TDesC& aName )

    {

    if ( aName.Length() > 0 )

        {

        // Not using the version of LoadLC where a parameter is inserted to

        // the returned string because for some reason that causes some weird

        // characters to appear when using localized strings

        TDesC* stringholder = StringLoader::LoadLC( R_QTN_VC_ERROR_IN_USE,

                                                    iEikonEnv );

        TName noteText;

        StringLoader::Format( noteText, *stringholder, -1, aName );

        CleanupStack::PopAndDestroy( stringholder );

        CAknNoteWrapper* note = new ( ELeave ) CAknNoteWrapper();

        note->ExecuteLD( R_VC_ALREADY_IN_USE, noteText );

        }

    }

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

// CVCSindAppUi::ShowWaitNoteL

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

//

void CVCAppUi::ShowWaitNoteL( const TDesC& aText )

    {

    if ( iWaitNote )

        {

        delete iWaitNote;

        iWaitNote = NULL;

        }

    iWaitNote = new(ELeave) CAknWaitDialog(

        ( reinterpret_cast<CEikDialog**>( &iWaitNote ) ), ETrue );

    iWaitNote->PrepareLC( R_VC_WAIT_NOTE );

    iWaitNote->SetTextL( aText );

    iWaitNote->RunLD();

    }

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

// CVCSindAppUi::ShowWaitNoteL

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

//

void CVCAppUi::DeleteWaitNoteL()

    {

    if (iWaitNote)

    	{

    	iWaitNote->ProcessFinishedL(); // deletes the dialog    	

    	}

    delete iWaitNote;

    iWaitNote = NULL;

    }

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

// CVCAppUi::CheckCallStateL

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

//

TInt CVCAppUi::CheckCallStateL()

    {

    TInt callState;

    TInt err = RProperty::Get( KPSUidCtsyCallInformation, KCTsyCallState,

                               callState );

    User::LeaveIfError( err );

    return callState;

    }

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

// CVCAppUi::IsVideoCallL

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

//

TBool CVCAppUi::IsVideoCallL() 

    { 

    TInt callType;

    TInt err =  RProperty::Get( KPSUidCtsyCallInformation, KCTsyCallType,

                                callType );

    User::LeaveIfError( err );

    return callType == EPSCTsyCallTypeH324Multimedia;

    }

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

// CVCAppUi::CallInProgressNoteL

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

//

void CVCAppUi::CallInProgressNoteL()

    {

    HBufC* text = StringLoader::LoadLC( R_TEXT_CALL_IN_PROGRESS );

    CAknInformationNote* note = new( ELeave ) CAknInformationNote( ETrue );

    note->ExecuteLD( *text );

    CleanupStack::PopAndDestroy( text );

    }

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

// CVCAppUi::HandleResourceChangeL

// Handle skin change event.

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

//

void CVCAppUi::HandleResourceChangeL( TInt aType )

    {

    CAknAppUi::HandleResourceChangeL( aType );

    if ( aType == KEikDynamicLayoutVariantSwitch ) 

        {

        CAknView* view = View( KUidVCMainView );        

        if ( view )

            {

        	static_cast< CVCGenericView* >( view )->HandleSizeChange(); 

            }

        view = View( KUidVCFolderView );        

        if ( view )

            {

            static_cast< CVCGenericView* >( view )->HandleSizeChange(); 

            }

        view = View( KUidVCSettingsView );        

        if ( view )

            {

            static_cast< CVCSettingsView* >( view )->HandleClientRectChange();

            }

        }

    }

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

// CVCAppUi::CommandSetChanged

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

//

void CVCAppUi::CommandSetChanged()

    {

    TUid focusedView = FocusedView();

    TRAPD( err,

        // Shouldn't all views be updated?

/*        if( focusedView == KUidVCMainView )

            {

            iMainView->RefreshViewL();

            }

        else

            {

            iFolderView->RefreshViewL();

            }*/

        iMainView->RefreshViewL();

        iFolderView->RefreshViewL();

        );

    if( err != KErrNone )

        {

        RUBY_ERROR1( "RefreshViewL failed with [%d]", err );

        }

    }

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

// CVCAppUi::CommandSetChanged

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

//

TBool CVCAppUi::IsDisplayingMenuOrDialog()

    {

    return EFalse;

    }

// End of File