/*

* 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:

*

*/

// INCLUDE FILES

#include "aknselectionlist.h"

#include <aknsfld.h>

#include <eikfrlbd.h>

#include <eikclb.h>

#include <eikclbd.h>

#include <AknPanic.h>

#include <eikcapc.h>

#include <AknUtils.h>

#include <AknIconArray.h>

#include <aknappui.h>

#include <avkon.mbg>

#include "AknDebug.h"

#include "akntrace.h"

// LOCAL FUNCTION PROTOTYPES

// ==================== EXTENSION CLASS ====================

NONSHARABLE_CLASS(CAknSelectionListDialogExtension) : public CBase

    {

    public:        

        CAknSelectionListDialogExtension();

        ~CAknSelectionListDialogExtension();    

    public:

        CIdle *iIdle;

    };

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

// CAknSelectionListDialogExtension::CAknSelectionListDialogExtension()

// 

// Constructor

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

//  

CAknSelectionListDialogExtension::CAknSelectionListDialogExtension()

    {

    iIdle = NULL;

    }

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

// CAknSelectionListDialogExtension::~CAknSelectionListDialogExtension()

// 

// Destructor

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

// 

CAknSelectionListDialogExtension::~CAknSelectionListDialogExtension()

    {

    delete iIdle;

    }

// ==================== EXTENSION CLASS ====================

NONSHARABLE_CLASS(CAknMarkableListDialogExtension) : public CBase

    {

    public:        

        CAknMarkableListDialogExtension();

        ~CAknMarkableListDialogExtension();    

    public:

        CIdle *iIdle;

    };

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

// CAknMarkableListDialogExtension::CAknMarkableListDialogExtension()

// 

// Constructor

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

//  

CAknMarkableListDialogExtension::CAknMarkableListDialogExtension()

    {

    iIdle = NULL;

    }

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

// CAknMarkableListDialogExtension::~CAknMarkableListDialogExtension()

// 

// Destructor

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

// 

CAknMarkableListDialogExtension::~CAknMarkableListDialogExtension()

    {

    delete iIdle;

    }

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

class CFindControl : public CCoeControl 

    {

public:

    CAknSearchField *iFind;

    ~CFindControl() { delete iFind; }

    void Draw(const TRect &) const

    {

    // this removes flicker from CEikDialog's Draw().

    }

    void SizeChanged()

        {

        _AKNTRACE_FUNC_ENTER;

        TRect mainPane;

        AknLayoutUtils::LayoutMetricsRect( AknLayoutUtils::EMainPane, mainPane );

        TAknLayoutRect listRect;

        listRect.LayoutRect( mainPane, AknLayout::list_gen_pane(0) );

        TRect r( listRect.Rect() );

        iPosition = TPoint( r.iTl );

        iSize.SetSize( r.Width(), r.Height() );

        _AKNTRACE( "[%s][%s] size: w = %d, h = %d.",

                "CFindControl", __FUNCTION__, iSize.iWidth, iSize.iHeight );

        _AKNTRACE_FUNC_EXIT;

        }

    TSize MinimumSize()

        {

        if ( iFind )

            {

            if ( iFind->Size() != TSize( 0, 0 ) )

                {

                return iFind->Size();

                }

            }

        return iSize;

        }

    };

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

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

// might leave.

//

EXPORT_C CAknSelectionListDialog* CAknSelectionListDialog::NewL(TInt &aValue, MDesCArray *aArray, TInt aMenuBarResourceId, MEikCommandObserver *aCommand)

    {

    _AKNTRACE( "[%s][%s] aValue = %d, aMenuBarResourceId = %d.",

            "CAknSelectionListDialog", __FUNCTION__, aValue, aMenuBarResourceId );

    CAknSelectionListDialog *dialog = NewLC(aValue, aArray, aMenuBarResourceId, aCommand);

    CleanupStack::Pop();

    return dialog;

    }

EXPORT_C CAknMarkableListDialog* CAknMarkableListDialog::NewL(TInt &aValue, CArrayFix<TInt> *aSelectedItems, MDesCArray *aArray, TInt aMenuBarResourceId, TInt aOkMenuBarId, MEikCommandObserver *aCommand)

    {

    _AKNTRACE( "[%s][%s] aValue = %d, aMenuBarResourceId = %d, aOkMenuBarId = %d.",

            "CAknMarkableListDialog", __FUNCTION__, aValue, aMenuBarResourceId, aOkMenuBarId );

    CAknMarkableListDialog *dialog = NewLC(aValue, aSelectedItems, aArray, aMenuBarResourceId, aOkMenuBarId, aCommand);

    CleanupStack::Pop();

    return dialog;

    }

EXPORT_C CAknSelectionListDialog *CAknSelectionListDialog::NewLC(TInt &aValue, MDesCArray *aArray, TInt aMenuBarResourceId, MEikCommandObserver *aCommand)

    {

    _AKNTRACE( "[%s][%s] aValue = %d, aMenuBarResourceId = %d.",

            "CAknSelectionListDialog", __FUNCTION__, aValue, aMenuBarResourceId );

    CAknSelectionListDialog *dialog = new(ELeave)CAknSelectionListDialog(aValue,aArray, aCommand);

    CleanupStack::PushL(dialog);

    dialog->ConstructL(aMenuBarResourceId); 

    return dialog;

    }

EXPORT_C CAknMarkableListDialog *CAknMarkableListDialog::NewLC(TInt &aValue, CArrayFix<TInt> *aSelectedItems, MDesCArray *aArray, TInt aMenuBarResourceId, TInt aOkMenuBarId, MEikCommandObserver *aCommand)

    {

    _AKNTRACE( "[%s][%s] aValue = %d, aMenuBarResourceId = %d, aOkMenuBarId = %d.",

            "CAknMarkableListDialog", __FUNCTION__, aValue, aMenuBarResourceId, aOkMenuBarId );

    CAknMarkableListDialog *dialog = new(ELeave)CAknMarkableListDialog(aValue,aSelectedItems, aArray, aMenuBarResourceId, aOkMenuBarId, aCommand);

    CleanupStack::PushL(dialog);

    dialog->ConstructL(aMenuBarResourceId);

    return dialog;

    }

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

//  CAknSelectionListDialog::ConstructL()

// 

// Constructs extension class

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

// 

EXPORT_C void CAknSelectionListDialog::ConstructL(TInt aMenuTitleResourceId)

    {

    _AKNTRACE( "[%s][%s] aMenuTitleResourceId = %d.",

            "CAknSelectionListDialog", __FUNCTION__, aMenuTitleResourceId );

    CAknDialog::ConstructL(aMenuTitleResourceId);

    iExtension = new (ELeave) CAknSelectionListDialogExtension;     

    }

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

//  CAknMarkableListDialog::ConstructL()

// 

// Constructs extension class

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

// 

EXPORT_C void CAknMarkableListDialog::ConstructL(TInt aMenuTitleResourceId)

    {

    _AKNTRACE( "[%s][%s] aMenuTitleResourceId = %d.",

            "CAknMarkableListDialog", __FUNCTION__, aMenuTitleResourceId );

    CAknDialog::ConstructL(aMenuTitleResourceId);

    iMarkableExtension = new (ELeave) CAknMarkableListDialogExtension;     

    }

EXPORT_C CAknSelectionListDialog::CAknSelectionListDialog(TInt &aIndex, MDesCArray *aArray, MEikCommandObserver *aCommand)

    : iEnterKeyPressed(EFalse),

      iSelectedItem(&aIndex),

      iArray(aArray),

      iCmdObserver(aCommand)

    {       

    }

EXPORT_C CAknMarkableListDialog::CAknMarkableListDialog(TInt &aIndex, CArrayFix<TInt> * aSelectedItems, MDesCArray *aArray, TInt aMenuBarResourceId, TInt aOkMenuBarResourceId, MEikCommandObserver *aCommand)

    : CAknSelectionListDialog(aIndex,aArray, aCommand),

      iSelectionIndexArray(aSelectedItems),

      iMenuBarResourceId(aMenuBarResourceId),

      iOkMenuBarResourceId(aOkMenuBarResourceId)

    {

    }

EXPORT_C CAknSelectionListDialog::~CAknSelectionListDialog()

    {

    if (iAvkonAppUi)

    iAvkonAppUi->RemoveFromStack( this );        

    delete iExtension;

    }

EXPORT_C CAknMarkableListDialog::~CAknMarkableListDialog()

    {

    delete iMarkableExtension;

    }

EXPORT_C CCoeControl* CAknSelectionListDialog::ComponentControl(TInt aIndex) const

    {

    if (aIndex == CAknDialog::CountComponentControls() )

    {

    return FindBox();

    }

    return CAknDialog::ComponentControl(aIndex);

    }

EXPORT_C TInt CAknSelectionListDialog::CountComponentControls() const

    {

    TInt newitems = 0;

    if (FindBox()) newitems++;

    return CAknDialog::CountComponentControls() + newitems;

    }

EXPORT_C TBool CAknSelectionListDialog::OkToExitL(TInt aButtonId)

    {

    TBool b = CAknDialog::OkToExitL(aButtonId);

    *iSelectedItem = ListBox()->CurrentItemIndex();

    if (FindBox())

    {

    if (*iSelectedItem != -1)

        *iSelectedItem = STATIC_CAST(CAknFilteredTextListBoxModel*,ListBox()->Model())->Filter()->FilteredItemIndex(*iSelectedItem);

    }

    _AKNTRACE( "[%s][%s] return value = %d.",

            "CAknSelectionListDialog", __FUNCTION__, b );

    return b;

    }

EXPORT_C void CAknSelectionListDialog::Draw(const TRect &) const

    {

    // this removes flicker from CEikDialog's Draw().

    }

EXPORT_C void CAknSelectionListDialog::ProcessCommandL(TInt aCommand)

    {

    _AKNTRACE( "[%s][%s] aCommand = %d.",

            "CAknSelectionListDialog", __FUNCTION__, aCommand );

    CAknDialog::ProcessCommandL(aCommand);

    if (FindBox() && iFindType == EPopupFind) 

        {

        AknFind::HandleFindPopupProcessCommandL(aCommand, ListBox(), FindBox(), this);

        DrawNow();

        }

    if (iCmdObserver) iCmdObserver->ProcessCommandL(aCommand);

    switch(aCommand)

    {

    case EAknCmdOpen:

        iEnterKeyPressed = ETrue;

        break;

    default:

        SelectionListProcessCommandL(aCommand);

        break;

    };

    }

EXPORT_C void CAknSelectionListDialog::SelectionListProcessCommandL(TInt aCommand)

    {

    _AKNTRACE( "[%s][%s] aCommand = %d.",

            "CAknSelectionListDialog", __FUNCTION__, aCommand );

    AknSelectionService::HandleSelectionListProcessCommandL(aCommand, ListBox());

    }

EXPORT_C void CAknSelectionListDialog::HandleListBoxEventL( CEikListBox* /*aListBox*/, TListBoxEvent aEventType )

    {

    _AKNTRACE( "[%s][%s] aEventType = %d.",

            "CAknSelectionListDialog", __FUNCTION__, aEventType );

    switch(aEventType)

        {

        case EEventItemDoubleClicked:

        case EEventItemSingleClicked:

            {

            if ( AknLayoutUtils::PenEnabled() )

                {

                delete iExtension->iIdle;

                iExtension->iIdle = NULL;

                iExtension->iIdle = CIdle::NewL(CActive::EPriorityIdle);

                if (iExtension->iIdle)

                    {                                  

                    iExtension->iIdle->Start(TCallBack(ExitViaIdle,this)); 

                    }

                }

            else

                {

                ProcessCommandL(EAknCmdOpen);

                // Should do nothing after this - the dialog might be deleted..

                }

            }

            break;

        case EEventEnterKeyPressed:

            {

            ProcessCommandL(EAknCmdOpen);

            // Should do nothing after this - the dialog might be deleted..

            }

            break;

        default:

            break;

        };

    }

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

// CAknSelectionListDialog::ExitViaIdle()

// 

// Callback function to exit dialog after selecting something with tapping it. 

// This prevents dialog to be destroyed before dialog page's handlepointereventl

// is fully completed.

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

// 

TInt CAknSelectionListDialog::ExitViaIdle(TAny* aSelectionList )

    {  

    _AKNTRACE( "[%s][%s] aSelectionList = 0x%x.",

            "CAknSelectionListDialog", __FUNCTION__, aSelectionList );

    CAknSelectionListDialog *selectionListDlg = (CAknSelectionListDialog*) aSelectionList; 

    TRAP_IGNORE(selectionListDlg->TryExitL(EAknSoftkeyOk));

    return EFalse;

    }  

EXPORT_C TKeyResponse CAknSelectionListDialog::OfferKeyEventL(const TKeyEvent& aKeyEvent,

                                  TEventCode aType)

    {

    _AKNTRACE( "[%s][%s] aKeyEvent(iCode = %d, iScanCode = %d, iModifiers = %d, iRepeats = %d) aType = %d.",

            "CAknSelectionListDialog", __FUNCTION__, aKeyEvent.iCode, aKeyEvent.iScanCode, aKeyEvent.iModifiers, aKeyEvent.iRepeats, aType );

    // must pass escape event to dialog - findbox and listbox "eat" escape events

    TKeyResponse res = EKeyWasNotConsumed;

    if ( aType == EEventKey && aKeyEvent.iCode == EKeyEscape )

        {

        res = CAknDialog::OfferKeyEventL(aKeyEvent, aType);

        }

    if ( res == EKeyWasConsumed ) 

        return res;

    TBool needRefresh = EFalse;

    res = AknFind::HandleFindOfferKeyEventL(aKeyEvent, aType, this, ListBox(), FindBox(), iFindType==EPopupFind, needRefresh);

    if (needRefresh && FindBox())

    {

    if (iFindType == EPopupFind)

        {

//      AknFind::HandlePopupFindSizeChanged(Control(EFindControl), ListBox(), FindBox());

        AknFind::HandlePopupFindSizeChanged(this, ListBox(), FindBox());

        }

    else if ( iFindType == EFixedFind || iFindType == EAdaptiveFind )

        {

//      AknFind::HandleFixedFindSizeChanged(Control(EFindControl),(CAknColumnListBox*)ListBox(), FindBox());

        AknFind::HandleFixedFindSizeChanged(this,(CAknColumnListBox*)ListBox(), FindBox());

        }

    DrawNow();

    }

    if ( res == EKeyWasConsumed ) 

    return res;

    // Give the events to listbox first! This is because otherwise all events do not go to the controls!

    // Dialogs filter out KeyUp/KeyDown events. If we do not do this, marking is broken; Sometimes it does

    // not mark list items correctly.

    if (aKeyEvent.iCode == EKeyLeftArrow || aKeyEvent.iCode == EKeyRightArrow)

    {

    // Multipage dialogs need the left/right keys

    res = CAknDialog::OfferKeyEventL(aKeyEvent, aType);

    }

    else

    res = ListBox()->OfferKeyEventL(aKeyEvent, aType);

    if ( res == EKeyWasNotConsumed )

    {

    res = CAknDialog::OfferKeyEventL(aKeyEvent, aType);

    }

    else 

    {

    }

    if (iEnterKeyPressed)

    TryExitL(EAknSoftkeyOk);

    // should do nothing after this.

    return res;

    }

EXPORT_C CEikListBox *CAknSelectionListDialog::ListBox() const

    {

    return (CEikListBox*)Control(ESelectionListControl);

    }

EXPORT_C CAknSearchField *CAknSelectionListDialog::FindBox() const

    {

    CFindControl *control = (CFindControl*)ControlOrNull(EFindControl);

    if (control) { return control->iFind; }

    return NULL;

    }

EXPORT_C void CAknSelectionListDialog::SetupFind(TFindType aType)

    {

    _AKNTRACE( "[%s][%s] aType = %d.",

            "CAknSelectionListDialog", __FUNCTION__, aType );

    iFindType = aType;

    }

EXPORT_C TBool CAknSelectionListDialog::IsAcceptableListBoxType(TInt /*aControlType*/, TBool &/*aIsFormattedCellListBox*/) const

    {

    return EFalse;

    }

EXPORT_C TBool CAknSelectionListDialog::IsFormattedCellListBox() const

    {

    CEikCaptionedControl *line = Line(ESelectionListControl);

    TInt controlType = line->iControlType;

    TBool result = EFalse;

    if (IsAcceptableListBoxType(controlType, result))

    return result;

    switch(controlType)

    {

    case EAknCtSingleListBox:

    case EAknCtSingleNumberListBox:

    case EAknCtSingleHeadingListBox:

    case EAknCtSingleGraphicListBox:

    case EAknCtSingleGraphicHeadingListBox:

    case EAknCtSingleNumberHeadingListBox:

    case EAknCtSingleLargeListBox:

        return EFalse;

    case EAknCtDoubleListBox:

    case EAknCtDoubleNumberListBox:

    case EAknCtDoubleTimeListBox:

    case EAknCtDoubleLargeListBox:

    case EAknCtDoubleGraphicListBox:

    case EAknCtSettingListBox:

    case EAknCtSettingNumberListBox:

        return ETrue;

    default:

        // If you hit this assert, you should derive from this dialog and

        // implement IsAcceptableListBoxType() method.

        __ASSERT_DEBUG(0, Panic(EAknPanicNotSupported));

        return ETrue;

    }

    }

EXPORT_C CArrayPtr<CGulIcon>* CAknSelectionListDialog::IconArray() const

    {

    if (IsFormattedCellListBox())

    {

    return ((CEikFormattedCellListBox*)ListBox())->ItemDrawer()->FormattedCellData()->IconArray();  

    }

    else

    {

    return ((CEikColumnListBox*)ListBox())->ItemDrawer()->ColumnData()->IconArray();

    }

    }

EXPORT_C void CAknSelectionListDialog::SetIconArrayL(CArrayPtr<CGulIcon>* aIcons)

    {

    CArrayPtr<CGulIcon>* oldicons = IconArray();

    if (oldicons)

        {

        oldicons->ResetAndDestroy();

        delete oldicons;

        }

    if (IsFormattedCellListBox())

    {

    ((CEikFormattedCellListBox*)ListBox())->ItemDrawer()->FormattedCellData()->SetIconArray(aIcons);    

    }

    else

    {

    ((CEikColumnListBox*)ListBox())->ItemDrawer()->ColumnData()->SetIconArray(aIcons);      

    }

    }

EXPORT_C SEikControlInfo CAknSelectionListDialog::CreateCustomControlL(TInt aControlType)

    {

    _AKNTRACE( "[%s][%s] aControlType = %d.",

            "CAknSelectionListDialog", __FUNCTION__, aControlType );

    CFindControl *control1= NULL;

    TBool findControl = EFalse;

    if (aControlType == EAknCtSelectionListFixedFind)

        {

        iFindType = EFixedFind;

        findControl = ETrue;

        }

    if (aControlType == EAknCtSelectionListPopupFind)

        {

        iFindType = EPopupFind;

        findControl = ETrue;

        }

    if (aControlType == EAknCtSelectionListAdaptiveFind)

        {