/*

* Copyright (c) 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

*

*/

#include <e32base.h>

#include <e32cmn.h>

#include <avkon.hrh>

#include <avkon.rsg>

#include <akntitle.h>

#include <eikmenub.h>

#include <akntoolbar.h>

#include <aknbutton.h>

#include <e32hashtab.h>

#include <layoutmetadata.cdl.h>

#include <gulicon.h>

#include <fbs.h>

#include <eikcmbut.h>

#include <hlplch.h>

#include <aknlists.h>

#include <StringLoader.h>

#include <activeidle2domainpskeys.h>

#include <UikonInternalPSKeys.h>

#include <e32property.h>

#include <AknTaskList.h>

#include <AknSgcc.h>                           // for transition effects

#include <featmgr.h>

#include <matrixmenu.rsg>

#include <akntabgrp.h>

#include <apgcli.h>

#include <AknDef.hrh>

#include <AknDlgShut.h>

#include <mmenuinternalPSkeys.h>

#include <aknstyluspopupmenu.h> //stylus popup for long tap event

#include "mmgui.hrh"

#include "mmguiconstants.h"

#include "mmappui.h"

#include "menudebug.h"

#include "hnengine.h"

#include "hnglobals.h"

#include "hnsuitemodelcontainer.h"

#include "hnmenuitemmodel.h"

#include "hntoolbarmodel.h"

#include "hnbuttonmodel.h"

#include "hnitemmodel.h"

#include "hnconvutils.h"

#include "hnsuitemodel.h"

#include "hnmdbasekey.h"

#include "hnmdkeyfactory.h"

#include "mmwidgetcontainer.h"

#include "mmtemplatelibrary.h"

#include "mmextensionmanager.h"

#include "hnitemsorder.h"

#include "mmnomemory.h"

#include "mmappkeyhandler.h"

enum TMenuTransEffectContext

    {

    EMenuOpenFolderEffect = 1001,

    EMenuCloseFolderEffect = 1002

    };

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

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

//

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

//

void CMmAppUi::ConstructL()

    {

    DEBUG(("_Mm_:CMmAppUi::ConstructL IN"));

    MMPERF(("Test Logger speed..."));

    MMPERF(("Test Logger speed - DONE"));

    MMPERF(("GO!"));

    //set matrix to be system app

    iEikonEnv->SetSystem( ETrue );

    TInt appUiFlags = AknLayoutUtils::PenEnabled() ?

    	EAknEnableSkin | EAknSingleClickCompatible :

        EAknEnableSkin | EAknEnableMSK;

    BaseConstructL( appUiFlags );

    iAppUiFactory = CEikonEnv::Static()->AppUiFactory( *this );

    ASSERT( iAppUiFactory );

    FeatureManager::InitializeLibL();

    iIsKastorEffectStarted = EFalse;

    StartLayoutSwitchFullScreen( AknTransEffect::EApplicationStart );

    RefreshUiPanesL( ETrue );

    Cba()->MakeVisible( EFalse );

    StatusPane()->SwitchLayoutL( R_AVKON_STATUS_PANE_LAYOUT_USUAL );

    iDummyTemplateLib = CMmTemplateLibrary::NewL();

    iDummyContainer = CMmWidgetContainer::NewGridContainerL( ClientRect(),

            this, iDummyTemplateLib );

    iDummyContainer->SetEmptyTextL( KNullDesC );

    AddToStackL( iDummyContainer, ECoeStackPriorityDefault,

            ECoeStackFlagRefusesFocus | ECoeStackFlagRefusesAllKeys );

    iDummyContainer->MakeVisible( ETrue );

    iDummyContainer->DrawNow();

    iHNInterface = CHnEngine::NewL( *this );

    iTemplateLibrary = CMmTemplateLibrary::NewL();

    InitializeL();

    iMmExtManager = CMMExtensionManager::NewL( *this );

    iScreenOn = ETrue;

    iSkinChangeNeeded = EFalse;

    iSkinChangeInProgress = EFalse;

    iHasFocus = ETrue;

    iSkinSrvSession.Connect(this);

    iAppkeyHandler = CMmAppkeyHandler::NewL();

    iOptionsMenuIsOpen = EFalse;

    RProperty::Define( KMMenuPSCat, KMMenuLastViewKey, RProperty::EText );

    MMPERF(("CMmAppUi::ConstructL - HN ready"));

    DEBUG(("_Mm_:CMmAppUi::ConstructL OUT"));

    }

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

//

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

//

TBool CMmAppUi::IsRootdisplayedL()

    {

    TBool ret( EFalse );

    if( iHNInterface && iHNInterface->GetSuiteModelsCountL() == KModelCountForRoot )

        {

        ret = ETrue;

        }

    return ret;

    }

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

//

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

//

CMmAppUi::CMmAppUi()

    {

    // No implementation required

    }

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

//

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

//

CMmAppUi::~CMmAppUi()

    {

    DEBUG(("_Mm_:CMmAppUi::~CMmAppUi IN"));

    delete iOutOfMemoryHandler;

    if (iCurrentSuiteModel)

        {

        iCurrentSuiteModel->UnregisterSuiteObserver( this );

        }

    delete iToolbar;

    iCascadeMenuMap.Close();

    RemoveFromStack( iCurrentContainer );

    RemoveFromStack( iDummyContainer );

    iDummyContainer->MakeVisible( EFalse );

    delete iDummyContainer;

    ResetContainerMap();

    iGarbage.ResetAndDestroy();

    delete iHNInterface;

    FeatureManager::UnInitializeLib();

    delete iMmExtManager;

    delete iTemplateLibrary;

    delete iDummyTemplateLib;

    delete iAppkeyHandler;

    delete iPopupMenu;

    iSkinSrvSession.Close();

    MMPERF(("Matrix closed"));

    DEBUG(("_Mm_:CMmAppUi::~CMmAppUi OUT"));

    }

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

//

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

//

void CMmAppUi::HandleResourceChangeL( TInt aType )

    {

    CAknAppUi::HandleResourceChangeL( aType );

    //we're interested in layout change events

    //only if container is available

    if ( aType == KEikDynamicLayoutVariantSwitch &&

            iCurrentContainer && iCurrentSuiteModel )

        {

        MMPERF(("Layout change START"));

        // Do not call StartLayoutSwitchFullScreen(),

        // layout switch effect is started automatically

        iIsKastorEffectStarted = ETrue;

        TInt lastItemIndex = iCurrentContainer->NumberOfItems() - 1;

        TBool makeLastItemVisible = lastItemIndex >= 0 &&

			iCurrentContainer->ItemIsFullyVisible( lastItemIndex );

        iCurrentContainer->SetRect( ClientRect() );

        iDummyContainer->SetRect( ClientRect() );

        // This fixes a problem (view scrolled one row up) that occurs when

        // switching from portrait to landscape orientation with scrollbar

        // in bottom position.

        if ( makeLastItemVisible )

        	{

        	iCurrentContainer->Widget()->View()->SetTopItemIndex(

        		iCurrentContainer->Widget()->View()->

					CalcNewTopItemIndexSoItemIsVisible(	lastItemIndex ) );

        	}

        THashMapIter< TInt, CMmWidgetContainer* > iterator( iContainerMap );

        while( iterator.NextKey() )

            {

            CMmWidgetContainer* container = *iterator.CurrentValue();

            if ( container != iCurrentContainer )

                {

                container->SetRect( ClientRect() );

                container->HandleResourceChange( aType );

                }

            }

        ShowSuiteL();

        EndFullScreen();

        MMPERF(("Layout change END"));

        }

    if ( aType == KEikMessageFadeAllWindows && iCurrentContainer )

        {

        iCurrentContainer->SetIsFaded( ETrue );

        }

    else if ( aType == KEikMessageUnfadeWindows && iCurrentContainer )

        {

        iCurrentContainer->SetIsFaded( EFalse );

        }

    }

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

//

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

//

TBool CMmAppUi::ProcessCommandParametersL( TApaCommand aCommand,

                                                TFileName& aDocumentName,

                                                const TDesC8& aTail )

    {

    DEBUG(("_Mm_:CMmAppUi::ProcessCommandParametersL IN"));

    DEBUG8(("\t_Mm_:tail: %S", &aTail));

    if ( aTail.Length() )

        {

        DEBUG(("\t_Mm_:call HandleMessageL"));

        HandleMessageL( aTail );

        }

    TBool result = CEikAppUi::ProcessCommandParametersL( aCommand,

                                                    aDocumentName,

                                                    aTail );

    MMPERF(("Matrix started and ready!"));

    DEBUG(("_Mm_:CMmAppUi::ProcessCommandParametersL OUT"));

    return result;

    }

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

//

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

//

void CMmAppUi::ProcessCommandL(TInt aCommand)

    {

    TBool ignoreCommand = EFalse;

    // ignore options click in edit mode and intermediate states for non-touch

    if ( aCommand == EAknSoftkeyOptions && iEditModeStatus != ENoEditMode &&

            !AknLayoutUtils::PenEnabled() )

        {

        ignoreCommand = ETrue;

        }

    // ignore keyselect for non-touch while in edit mode or stopping edit mode

    if ( aCommand == KKeyIdSelect && !AknLayoutUtils::PenEnabled() &&

            ( iEditModeStatus == ETransitionFromEditMode || IsEditMode() ) )

        {

        ignoreCommand = ETrue;

        }

    if ( !ignoreCommand )

        {

        CAknAppUi::ProcessCommandL( aCommand );

        }

    	{

    	}

    }

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

//

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

//

void CMmAppUi::ProcessMessageL( TUid /*aUid*/, const TDesC8& aParams )

    {

    DEBUG(("_Mm_:CMmAppUi::ProcessMessageL IN"));

    DEBUG8(("\t_Mm_:params: %S", &aParams));

    MMPERF(("APA Message Recieved"));

    // fix for the CR 417-35490

    // Handle empty message sends by AVKON after app key press or switch

    // to Menu via task swapper.

    if( !aParams.Compare( KNullDesC8 ) )

        {

        if ( !iAppkeyHandler->IsActive() )

        	{

            CleanupForExitL( EExitKeyApplication );

			User::LeaveIfError( iCoeEnv->WsSession().SetWindowGroupOrdinalPosition(

						CEikonEnv::Static()->RootWin().Identifier(), 0 ) );

			iAppkeyHandler->StartL();

        	}

        }

    // first refresh model, show afterwords

    if ( aParams.Length() )

        {

        DEBUG(("\t_Mm_:call HandleMessageL"));

        HandleMessageL( aParams );

        }

    MMPERF(("APA Message Processed"));

    DEBUG(("_Mm_:CMmAppUi::ProcessMessageL OUT"));

    }

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

//

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

//

MCoeMessageObserver::TMessageResponse CMmAppUi::HandleMessageL(

         TUint32 aClientHandleOfTargetWindowGroup,

         TUid aMessageUid,

         const TDesC8& aMessageParameters )

    {

    if ( aMessageUid.iUid == KUidApaMessageSwitchOpenFileValue )

        {

        ProcessMessageL( aMessageUid, aMessageParameters );

        return EMessageHandled;

        }

    else

        {

        return CAknAppUi::HandleMessageL(

                aClientHandleOfTargetWindowGroup,

                aMessageUid,

                aMessageParameters );

        }

    }

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

//

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

//

void CMmAppUi::HandleCommandL( TInt aCommand )

    {

    DEBUG(("_Mm_:CMmAppUi::HandleCommandL IN"));

    DEBUG(("\t_Mm_:aCommand: %d",aCommand));

    // in case something has gone wrong

    ClearTransitionFromEditModeFlag();

    switch( aCommand )

        {

        case EEikCmdExit:

            {

            DEBUG(("\t_Mm_:EEikCmdExit"));

            // Simply exit

            Exit();

            }

            break;

        case EMmOptionsExit:

            {

            MMPERF(("Options->Exit pressed"));

            DEBUG(("\t_Mm_:EMmOptionsExit"));

            //Check if it is a folder suite.If Yes really exit.

            //Otherwise behave like LSK.

            if( iCurrentSuiteModel &&

                iCurrentSuiteModel->SuiteName().Compare( KFolderSuite) )

                {

                if( iCurrentSuiteModel->ExitMode() == EExitModeHide )

                    {

                    // hide and reset menu

                    TApaTaskList taskList( iCoeEnv->WsSession() );

                    TApaTask me = taskList.FindApp( KUidMatrixMenuApp );

                    me.SendToBackground();

                    CleanupForExitL( EExitKeyApplication );

                    }

                else

                    {

                    StartLayoutSwitchFullScreen( EMenuCloseFolderEffect );

                    HandleBackCommandL();

                    }

                }

            else

                {

                ExitMatrix( EExitReally );

                }

            }

            break;

        case EAknSoftkeyExit:

            {

            MMPERF(("SoftkeyExit pressed"));

            DEBUG(("\t_Mm_:EAknSoftkeyExit"));

            ExitMatrix( EExitToPhone );

            }

            break;

        case EAknSoftkeyBack:

            {

            StartLayoutSwitchFullScreen( EMenuCloseFolderEffect );

            if( iCurrentSuiteModel && iCurrentSuiteModel->ExitMode() == EExitModeHide )

                {

                // hide and reset menu

                TApaTaskList taskList( iCoeEnv->WsSession() );

                TApaTask me = taskList.FindApp( KUidMatrixMenuApp );

                me.SendToBackground();

                if ( iCurrentContainer )

                    {

                    iCurrentContainer->MakeVisible( EFalse );

                    }

                iDummyContainer->MakeVisible( ETrue );

                RefreshCbaL();

                iDummyContainer->DrawNow();

                CleanupForExitL( EExitKeyApplication );

                }

            else if( iCurrentSuiteModel )

                {

                HandleBackCommandL();

                }

            }

            break;

        case EAknSoftkeyOk:

        case EAknSoftkeyDone:

            {

            ASSERT( IsEditMode() );

            SetEditModeL( EFalse );

            }

            break;

        default:

            {

            ForwardEventToHNL( aCommand );

            }

            break;

        }

    DEBUG(("_Mm_:CMmAppUi::HandleCommandL OUT"));

    }

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

//

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

//

void CMmAppUi::HandleBackCommandL()

    {

    DEBUG(("_Mm_:CMmAppUi::HandleBackCommandL IN"));

    MMPERF(("CMmAppUi::HandleBackCommandL - START"));

    DEBUG16(("\t_Mm_:current genre: %S",&iCurrentSuiteModel->SuiteName()));

    iDummyContainer->MakeVisible( ETrue );

    RefreshUiPanesL( ETrue );

    iCurrentContainer->MakeVisible( EFalse );

    iDummyContainer->DrawNow();

    iHNInterface->HandleBackEventL( iCurrentSuiteModel->SuiteName() );

    MMPERF(("CMmAppUi::HandleBackCommandL - DONE"));

    DEBUG(("_Mm_:CMmAppUi::HandleBackCommandL OUT"));

    }

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

//

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

//

CMmWidgetContainer* CMmAppUi::GetAppropriateContainerToLoadL()

    {

    CMmWidgetContainer* retContainer = NULL;

    if ( iCurrentSuiteModel )

        {

        TInt currentSuiteId = iCurrentSuiteModel->GetItemsOrder()->GetSuiteId();

        CMmWidgetContainer** ret = iContainerMap.Find( currentSuiteId );

        retContainer = (ret) ? *ret : NULL;

        if ( ret && (*ret)->WidgetType() != iCurrentSuiteModel->WidgetType() )

            {

            iMakeHightlightedItemFullyVisible = ETrue;

            iGarbage.AppendL( *ret );

            iContainerMap.Remove(

                    iCurrentSuiteModel->GetItemsOrder()->GetSuiteId() );

            retContainer = NULL;

            }

        }

    return retContainer;

    }

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

//

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

//