/*

* Copyright (c) 2002 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:    LandmarksUi Content File -

*

*/

// INCLUDE FILES

#include <featmgr.h>

#include <sendnorm.rsg> // R_SENDUI_MENU

#include <aknsfld.h>

#include <StringLoader.h>

#include <lmkui.rsg>

#include <lmkerrors.h>

#include "CLmkMultiSelectorDialog.h"

#include "MLmkDlgMenuObserver.h"

#include "MLmkNavigationObserver.h"

#include "LmkConsts.h"

#include "landmarks.hrh"

#include "CLmkSender.h"

// CONSTANTS

/// Unnamed namespace for local definitions

namespace {

#if defined(_DEBUG)

_LIT( KPanicMsg, "CLmkMultiSelectorDialog" );

void Panic( TPanicCode aReason )

    {

    User::Panic( KPanicMsg, aReason );

    }

#endif

}  // namespace

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

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

// CLmkMultiSelectorDialog::CLmkMultiSelectorDialog

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

// might leave.

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

//

CLmkMultiSelectorDialog::CLmkMultiSelectorDialog(

    TInt& aOpenedItemIndex,

    CArrayFix<TInt>* aSelectionIndexArray,

    MDesCArray* aLbModel,

    TInt aMenuBarResourceId,

    TInt aOkOptionsMenuResourceId,

    MEikCommandObserver* aCmdObserver,

    MLmkDlgMenuObserver* aMenuObserver,

    MLmkListMemento* aMemento )

    : CLmkSelectorDialog( aOpenedItemIndex, aLbModel, aCmdObserver,aMemento ),

      iMenuBarResourceId( aMenuBarResourceId ),

      iOkOptionsMenuResourceId( aOkOptionsMenuResourceId ),

      iSendUiMenuPaneResourceId( KZeroResourceId ),

      iSelectionIndexArray( aSelectionIndexArray ),

      iMenuObserver( aMenuObserver )

    {

    iExited = EFalse;

    iIsToClearSelection = EFalse;

    }

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

// CLmkMultiSelectorDialog::NewL

// Two-phased constructor.

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

//

CLmkMultiSelectorDialog* CLmkMultiSelectorDialog::NewL(

    TInt& aOpenedItemIndex,

    CArrayFix<TInt>* aSelectionIndexArray,

    MDesCArray* aLbModel,

    TInt aMenuBarResourceId,

    TInt aOkOptionsMenuResourceId,

    MEikCommandObserver* aCmdObserver,

    MLmkDlgMenuObserver* aMenuObserver,

    MLmkListMemento* aMemento )

    {

    CLmkMultiSelectorDialog* self =

        new( ELeave ) CLmkMultiSelectorDialog( aOpenedItemIndex,

                                               aSelectionIndexArray,

                                               aLbModel,

                                               aMenuBarResourceId,

                                               aOkOptionsMenuResourceId,

                                               aCmdObserver,

                                               aMenuObserver,

                                               aMemento );

    CleanupStack::PushL( self );

    self->ConstructL( aMenuBarResourceId );

    CleanupStack::Pop();

    return self;

    }

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

// CLmkMultiSelectorDialog::ConstructL

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

//

void CLmkMultiSelectorDialog::ConstructL(TInt aMenuBarResourceId)

	{

	CAknSelectionListDialog::ConstructL( aMenuBarResourceId );

	}

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

// CLmkMultiSelectorDialog::~CLmkMultiSelectorDialog

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

//

CLmkMultiSelectorDialog::~CLmkMultiSelectorDialog()

    {

    }

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

// CLmkMultiSelectorDialog::SetupSendMenu

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

//

void CLmkMultiSelectorDialog::SetupSendMenu(

    CLmkSender& aSender,

    TInt aSendUiMenuPaneResource,

    TInt aMenuTextResource )

    {

    iLmkSender = &aSender;

    iSendUiMenuPaneResourceId = aSendUiMenuPaneResource;

    iMenuTextResourceId = aMenuTextResource;

    }

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

// CLmkMultiSelectorDialog::HandleListBoxEventL

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

//

void CLmkMultiSelectorDialog::HandleListBoxEventL(

    CEikListBox* /*aListBox*/,

    TListBoxEvent aEventType )

    {

    switch( aEventType )

        {

        case EEventEnterKeyPressed:

        case EEventItemDoubleClicked:

            {

	        // Do nothing -- offerkeyevent handles this

            }

            break;

    #ifdef RD_SCALABLE_UI_V2

        case EEventItemClicked:

        	{

        	UpdateMskL();

        	break;

        	}

    #endif//RD_SCALABLE_UI_V2

        default:

            {

            break;

            }

        };

    }

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

// CLmkMultiSelectorDialog::SelectionListProcessCommandL

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

//

void CLmkMultiSelectorDialog::SelectionListProcessCommandL( TInt aCommand )

    {

    AknSelectionService::HandleMarkableListProcessCommandL( aCommand,

                                                            ListBox() );

    }

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

// CLmkMultiSelectorDialog::OfferKeyEventL

// ?implementation_description

// (other items were commented in a header).

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

//

TKeyResponse CLmkMultiSelectorDialog::OfferKeyEventL(

                                     const TKeyEvent& aKeyEvent,

                                     TEventCode aType )

	{

	// Do not process navigation handling till UI gets from engine

	if (!ListBox())

		{

		return EKeyWasConsumed;

		}

    if (aType == EEventKey &&

        	(aKeyEvent.iCode == EKeyOK || aKeyEvent.iCode == EKeyEnter || aKeyEvent.iScanCode == EStdKeyEnter) )

		{

		ListBox()->View()->ToggleItemL(ListBox()->CurrentItemIndex());

		return EKeyWasConsumed;

		}

	if (aKeyEvent.iRepeats == 0)

        {

        if (KeyEventForNavigationL(aKeyEvent, aType) == EKeyWasConsumed)

            {

            iIsToClearSelection = ETrue;

            TryExitL(EAknSoftkeyOk);

            return EKeyWasConsumed;

            }

        CAknSearchField* findBox = FindBox();

        if	(findBox && !(findBox->IsVisible()))

            {

            return 	EKeyWasConsumed;

            }

        }

	TKeyResponse keyResponce;

	keyResponce = CAknSelectionListDialog::OfferKeyEventL(aKeyEvent, aType);

	//CEikButtonGroupContainer &buttonContainer = *(CEikButtonGroupContainer::Current());//ButtonGroupContainer();

	if(!iExited)

		{

		UpdateMskL();

		}

	return keyResponce;

	}

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

// CLmkMultiSelectorDialog::PreLayoutDynInitL

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

//

void CLmkMultiSelectorDialog::PreLayoutDynInitL()

    {

    CLmkSelectorDialog::PreLayoutDynInitL();

    __ASSERT_DEBUG( iSelectionIndexArray, Panic( KLmkPanicNullMember ) );

    ListBox()->SetSelectionIndexesL( iSelectionIndexArray );

    }

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

// CLmkMultiSelectorDialog::PostLayoutDynInitL

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

void CLmkMultiSelectorDialog::PostLayoutDynInitL()

	{

	CLmkSelectorDialog::PostLayoutDynInitL();

	UpdateMskL();

	}

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

// CLmkMultiSelectorDialog::OkToExitL

// ?implementation_description

// (other items were commented in a header).

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

//

TBool CLmkMultiSelectorDialog::OkToExitL( TInt aButtonId )

    {

    TBool b = CAknSelectionListDialog::OkToExitL( aButtonId );

    if ( iSelectionIndexArray )

	    {

	    const CArrayFix<TInt>* array = ListBox()->SelectionIndexes();

	    if ( FindBox() )

	        {

            CAknFilteredTextListBoxModel* model =

	         static_cast<CAknFilteredTextListBoxModel*>( ListBox()->Model() );

            model->Filter()->UpdateSelectionIndexesL();

	        array = model->Filter()->SelectionIndexes();

	        }

	    TInt numberOfItems( array->Count() );

	    iSelectionIndexArray->Reset();

	    for ( TInt i( 0 ); i < numberOfItems; ++i )

            {

	        iSelectionIndexArray->AppendL( array->At( i ) );

            }

	    }

    if(iIsToClearSelection && iSelectionIndexArray)

        {

        iSelectionIndexArray->Reset();

        }

    if ( b && iNavigationObserver )

        {

        iNavigationObserver->HandleClosingEventL();

        }

    iExited = b;

    return b;

    }

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

// CLmkMultiSelectorDialog::DynInitMenuPaneL

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

//

void CLmkMultiSelectorDialog::DynInitMenuPaneL(

    TInt aResourceId,

    CEikMenuPane* aMenuPane )

    {

    AknSelectionService::HandleMarkableListDynInitMenuPane( aResourceId,

                                                    aMenuPane, ListBox() );

    if ( iMenuObserver )

        {

        iMenuObserver->DynInitDlgMenuPaneL( aResourceId, aMenuPane );

        }

    TInt visibleCount = ListBox()->Model()->NumberOfItems();

    if ( aResourceId == iSendUiMenuPaneResourceId )

        {

        if ( iLmkSender )

            {

            // Send menu is handled by iLmkSender:

            if ( FeatureManager::FeatureSupported( KFeatureIdLandmarksConverter ) )

				{

				aMenuPane->SetItemDimmed(ELmkCmdSendDummy, EFalse);

				}

			else

				{

				aMenuPane->SetItemDimmed(ELmkCmdSendDummy, ETrue);

				}

            }

        }

    else if ( aResourceId == R_SENDUI_MENU )

        { // Dynamically created send ui menu

        // Sender always exists if R_SENDUI_MENU exists:

        __ASSERT_DEBUG( iLmkSender, Panic( KLmkPanicSenderNotExist ) );

        if ( FeatureManager::FeatureSupported( KFeatureIdLandmarksConverter ) )

	        {

	        iLmkSender->DisplaySendCascadeMenuL( *aMenuPane );

	        }

        }

    CAknSelectionListDialog::DynInitMenuPaneL( aResourceId, aMenuPane );

    }

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

// CLmkMultiSelectorDialog::UpdateMskL

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

//

 void CLmkMultiSelectorDialog::UpdateMskL()

	 {

 	CEikButtonGroupContainer* cba = CEikButtonGroupContainer::Current();

 	HBufC* mskTxt = NULL;

 	if (ListBox()->Model()->NumberOfItems() > 0)

 		{

 		cba->MakeCommandVisibleByPosition(CEikButtonGroupContainer::EMiddleSoftkeyPosition,ETrue);

 		cba->MakeCommandVisible(EAknSoftkeyDone, ETrue);

		cba->MakeCommandVisible(EAknSoftkeyOk, ETrue);

 		if(IsCurrentItemMarked())

			{

			mskTxt = StringLoader::LoadLC( R_LM_MSK_UNMARK, iEikonEnv );

			cba->AddCommandToStackL(KMskCommandPos,EAknSoftkeyUnmark,mskTxt->Des());

			CleanupStack::PopAndDestroy(mskTxt);

			}

		else

			{

			mskTxt = StringLoader::LoadLC( R_LM_MSK_MARK, iEikonEnv );

			cba->AddCommandToStackL(KMskCommandPos,EAknSoftkeyMark,mskTxt->Des());

			CleanupStack::PopAndDestroy(mskTxt);

			}

 		}

 	else

 		{

 		cba->MakeCommandVisible(EAknSoftkeyDone, EFalse);

		cba->MakeCommandVisible(EAknSoftkeyOk, EFalse);

 		cba->MakeCommandVisibleByPosition(CEikButtonGroupContainer::EMiddleSoftkeyPosition,EFalse);

 		}

 	 cba->DrawDeferred();

	 }

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

// CLmkMultiSelectorDialog::IsCurrentItemMarked

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

//

TBool CLmkMultiSelectorDialog::IsCurrentItemMarked()

	{

	TBool ret(EFalse);

	TInt itemIndex = ListBox()->View()->CurrentItemIndex();

	if (itemIndex != KErrNotFound)

		{

		 ret = ListBox()->View()->ItemIsSelected(itemIndex);

		}

	return ret;

	}

//  End of File