/*

* Copyright (c) 2005 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:  CAknChoiceList - Choice list for S60 

*

*/

#include <AknControl.h>

#include <aknlists.h>

#include <aknbutton.h>

#include <avkon.hrh> // AknButton flags

#include <barsread.h> // TResourceReader

#include <AknInfoPopupNoteController.h> // Tooltip

#include "aknchoicelist.h"

#include <AknLayout2ScalableDef.h>

#include <aknlayoutscalable_avkon.cdl.h>

#include <AknsFrameBackgroundControlContext.h> 

#include <AknsConstants.h>

#include <avkon.mbg>

#include <aknglobalpopupprioritycontroller.h>

#include <touchfeedback.h>

#include <AknTasHook.h>

#include <akntranseffect.h>

#ifdef RD_UI_TRANSITION_EFFECTS_POPUPS

#include <akntransitionutils.h>

#endif

#include "akntrace.h"

// CONSTANTS

const TInt KTimeoutBeforeTooltipNote = 150; // in milliseconds

const TInt KTimeoutInViewTooltipNote = 3000; // in milliseconds

// CLASS DECLARATION

/**

* CAknChoiceListPopupList

* This is a List to be used in side of CAknChoiceListPopup. 

* We had to create a own list for this because currently AvKon 

* lists are not parent relative but main pane relative.

* @internal This should not be used anywhere else!

*/

NONSHARABLE_CLASS(CAknChoiceListPopupList): public CEikFormattedCellListBox

    {

public: // Functions from base classes

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

    // CAknChoiceListPopupList::SizeChanged()

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

    //

    void SizeChanged()

        {   

        CEikFormattedCellListBox::SizeChanged(); 

        TRAP_IGNORE( SizeChangedL() );

        TAknLayoutRect cellRect;

        cellRect.LayoutRect( Rect(), 

            AknLayoutScalable_Avkon::list_single_choice_list_pane(0) );

        CFormattedCellListBoxItemDrawer *itemDrawer( ItemDrawer() );

        itemDrawer->SetItemCellSize( cellRect.Rect().Size() );

        }

    TSize MinimumSize()

        {    

        return Size();

        }

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

    // CAknChoiceListPopupList::CreateItemDrawerL

    // Item drawer construction

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

    //

    void CreateItemDrawerL()

    {

        CFormattedCellListBoxData* data=CFormattedCellListBoxData::NewL();

        CleanupStack::PushL( data );   

        TAknLayoutText itemText;

        itemText.LayoutText( Rect(), AknLayoutScalable_Avkon::list_single_choice_list_pane_t1(0) );

        const CFont* font = itemText.Font();

        iItemDrawer=new (ELeave) CFormattedCellListBoxItemDrawer( 

            Model(), 

            font, 

            data

            ); //takes ownership

        // Let the choice list background context control the grid skinning

        ItemDrawer()->FormattedCellData()->SetSkinEnabledL( EFalse );

        // Marquee can be requested.. ;) 

        ItemDrawer()->FormattedCellData()->EnableMarqueeL( EFalse );

        CleanupStack::Pop();

    }

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

    // CAknChoiceListPopupList::UpdateTextColors

    // Skin items

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

    //    

    void UpdateTextColors()

    {

        TRgb color( KRgbBlack );  // sane default for nonskinned case

        if ( AknsUtils::AvkonSkinEnabled() )

            {

            AknsUtils::GetCachedColor( AknsUtils::SkinInstance(),

                                   color, KAknsIIDQsnTextColors, EAknsCIQsnTextColorsCG8 );

            }

        ItemDrawer()->SetTextColor( color );

        ItemDrawer()->SetBackColor( AKN_LAF_COLOR( 0 ) );

        if ( AknsUtils::AvkonSkinEnabled() )

            {

            AknsUtils::GetCachedColor( AknsUtils::SkinInstance(),

                                   color, KAknsIIDQsnTextColors, EAknsCIQsnTextColorsCG8 );

            }

        ItemDrawer()->SetHighlightedTextColor( color );

        ItemDrawer()->SetHighlightedBackColor( AKN_LAF_COLOR( 0 ) );    

    }

private:

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

    // CAknChoiceListPopupList::SizeChangedL

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

    //

    void SizeChangedL()

        {

        CFormattedCellListBoxItemDrawer* itemDrawer = ItemDrawer();

        CFormattedCellListBoxData* d = itemDrawer->FormattedCellData();        

        TAknLayoutRect cellRect;

        cellRect.LayoutRect( Rect(), 

            AknLayoutScalable_Avkon::list_single_choice_list_pane(0) );

        TRect cell( cellRect.Rect() );

        SetItemHeightL( cell.Height() );

        d->SetTextSubCellL( 0, AknLayoutScalable_Avkon::list_single_choice_list_pane_t1(0) );    

        }       

    };    

// CLASS DECLARATION

/**

*  Control container for choice list

*/

NONSHARABLE_CLASS( CAknChoiceListPopup ) : public CCoeControl,

                  public MEikListBoxObserver,                  

    {

public:      

    CAknChoiceListPopup() : iIndex( -1 ), iCancelled( EFalse )

        {

        AKNTASHOOK_ADD( this, "CAknChoiceListPopup" );

        }

    // Symbian OS default constructor can leave.

    void ConstructL()

        {

        CreateWindowL();

        if( CAknEnv::Static()->TransparencyEnabled() )

        {

            Window().SetRequiredDisplayMode( EColor16MA );

            TInt err = Window().SetTransparencyAlphaChannel();

            if ( err == KErrNone )

                {

                Window().SetBackgroundColor(~0);

                }

        }

        SetComponentsToInheritVisibility();    

        CreateChoiceListL();

        Window().SetShadowDisabled( ETrue );

        Window().SetPointerGrab( ETrue );

        SetGloballyCapturing( ETrue );

        MakeVisible( EFalse );

        TRect nullRect( 0, 0, 0, 0 );

        iBgContext = CAknsFrameBackgroundControlContext::NewL(

                KAknsIIDQsnFrPopupSub, nullRect, nullRect, EFalse );        

        if ( AknLayoutUtils::PenEnabled() )

            {

            SetGloballyCapturing( ETrue );

            SetPointerCapture( ETrue );

            }

        iList->UpdateTextColors();

        }

    // Destructor

    ~CAknChoiceListPopup()

        {  

        AKNTASHOOK_REMOVE();

        AknGlobalPopupPriorityController::RemovePopupPriority(*this);

        delete iCba;

        delete iList;

        delete iBgContext;

        }

// New functions

public: 

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

    // CAknChoiceListPopup::CloseChoiceList

    // Dismisses CAknChoiceListPopup

    // from the screen and removes it from the control stack

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

    //

    void CloseChoiceList()

        {

        if ( iIsDisplayed )

            {

            MakeVisible( EFalse );    

            if (iCba)

                AknGlobalPopupPriorityController::RemovePopupPriority(*iCba->ButtonGroup()->AsControl());

            delete iCba;

            iCba = NULL;

            SetFocus( EFalse );            

            iAvkonAppUi->RemoveFromStack( this );

            iEikonEnv->BringForwards( EFalse );

            AknGlobalPopupPriorityController::ShowPopup(*this, EFalse);

            if ( AknLayoutUtils::PenEnabled() )

                {

                SetPointerCapture( EFalse );

                }

            if( iCancelled )

                {

                TRAP_IGNORE( Observer()->HandleControlEventL( this, MCoeControlObserver::EEventRequestCancel ) );

                }

            else

                {

                TRAP_IGNORE( Observer()->HandleControlEventL( this, MCoeControlObserver::EEventStateChanged ) );  

                }

            DrawNow();

            }

        iIsDisplayed = EFalse;    

        }

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

    // CAknChoiceListPopup::UpdateControlContext

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

    //

    void UpdateControlContext()

        {

        TRect rectParent( Rect() );

        TAknLayoutRect layoutRect;

        TInt variety = 0;

        // check if scrollbar-layout should be selected

        if ( iList->Model()->ItemTextArray()->MdcaCount() > 6 )

            {

            variety = 1;

            TRAP_IGNORE( iList->ScrollBarFrame()->SetScrollBarVisibilityL(

                CEikScrollBarFrame::EOff, CEikScrollBarFrame::EOn) );            

            AknLayoutUtils::LayoutVerticalScrollBar( iList->ScrollBarFrame(), 

                rectParent, 

                AknLayoutScalable_Avkon::scroll_pane_cp23().LayoutLine()

            );                    

            }

        else

            {

            TRAP_IGNORE( iList->ScrollBarFrame()->SetScrollBarVisibilityL(

                CEikScrollBarFrame::EOff, CEikScrollBarFrame::EOff) );

            // Enable scrolling

            iList->DisableScrolling( EFalse );   

            }

        layoutRect.LayoutRect( rectParent, 

            AknLayoutScalable_Avkon::list_choice_list_pane( variety ).LayoutLine() );        

        iList->SetRect( layoutRect.Rect() );

        TAknLayoutRect innerRect;

        innerRect.LayoutRect( 

            rectParent, 

            AknLayoutScalable_Avkon::list_choice_list_pane(0).LayoutLine() 

            );

        iBgContext->SetFrameRects(rectParent, innerRect.Rect());        

        }

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

    // CAknChoiceListPopup::SetItemsL

    // set content array

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

    //      

    void SetItemsL( CDesCArray& aArray )

        {              

        // Set list items.

        CTextListBoxModel* model = iList->Model();    

        model->SetItemTextArray( &aArray );        

        iList->HandleItemAdditionL();

        // We don't want to transfer ownership

        model->SetOwnershipType( ELbmDoesNotOwnItemArray );        

        }

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

    // CAknChoiceListPopup::SelectedItem()

    // Ask selected item from the choice list

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

    //

    TInt SelectedItem() const

        {

        return iIndex;

        }

    void SetSelectedItem( const TInt aIndex )

        {        

        if ( aIndex >= 0 )

            {

            iIndex = aIndex;                        

            if ( iIsDisplayed && aIndex < iList->Model()->ItemTextArray()->MdcaCount() )

                {                

                iList->SetCurrentItemIndexAndDraw( aIndex );

                }

            }       

        else

            {

            iIndex = -1;            

            }        

        }

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

    // CAknChoiceListPopup::SetPopupSizeAndLocation

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

    //

    void SetPopupSizeAndLocation( const TRect& aRect )

        {        

        if ( iIsDisplayed ) 

            {            

            Window().Invalidate();

            }

        SetRect( aRect );        

        TAknLayoutRect listRect;

        TInt variety = 0;

        if ( iList->Model()->ItemTextArray()->MdcaCount() > 6 )

            {            

            variety = 1;

            }

        listRect.LayoutRect( aRect, AknLayoutScalable_Avkon::list_choice_list_pane( variety ) );        

        iList->SetSize( listRect.Rect().Size() );        

        }

    void OpenChoiceListL()

        {    

        if ( iIsDisplayed || iList->Model()->ItemTextArray()->MdcaCount() == 0 )

            {            

            return;

            }

        if ( AknLayoutUtils::PenEnabled() )

            {

            SetPointerCapture( ETrue );

            }

        iIsDisplayed = ETrue;

        AknGlobalPopupPriorityController::AddPopupToControlStackL( *this );

        iEikonEnv->BringForwards( ETrue );

        DrawableWindow()->SetOrdinalPosition( 0 );    

        AknGlobalPopupPriorityController::ShowPopup(*this, ETrue);

        // this will fix possibly corrupted index        

        if ( iIndex < iList->Model()->ItemTextArray()->MdcaCount() && iIndex >= 0 )

            {

            iList->SetCurrentItemIndex( iIndex );

            }

        else if ( iList->Model()->ItemTextArray()->MdcaCount() > 0 )

            {

            iList->SetCurrentItemIndex( 0 );

            }

        CreateCbaL();

        ActivateL();

        MakeVisible( ETrue );

        SetFocus( ETrue );

        iList->SetFocus( ETrue );      

        iCancelled = EFalse;

        UpdateControlContext(); 

        DrawNow();  

        }

// Functions from base classes

public: 

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

    // CAknChoiceListPopup::Draw

    // Symbian OS framework drawing function. Draws the window shadows and

    // outline frame.

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

    //

    void Draw(const TRect& aRect) const

        {                

        CWindowGc& gc = SystemGc();

        MAknsSkinInstance* skin = AknsUtils::SkinInstance();

        if ( !AknsDrawUtils::Background( skin, iBgContext, gc, aRect ) )

            {

            SystemGc().Clear( aRect );

            }

        }

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

    // CAknChoiceListPopup::SizeChanged

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

    //

    void SizeChanged()

        {        

        CCoeControl::SizeChanged();        

        UpdateControlContext();

        }

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

    // CAknChoiceListPopup::HandleResourceChange

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

    //

    void HandleResourceChange(TInt aType)

        {

        CCoeControl::HandleResourceChange(aType);

        if ( iCba )

            {

            iCba->HandleResourceChange(aType);

            }

        if( aType == KEikDynamicLayoutVariantSwitch )

            {

            MakeVisible( ETrue );

            }

        if ( aType == KAknsMessageSkinChange )

            {

            iList->UpdateTextColors();

            }

        }

    TKeyResponse OfferKeyEventL(const TKeyEvent& aKeyEvent,TEventCode aType)

        { 

        if ( aType == EEventKey )

            {            

            if ( aKeyEvent.iScanCode == EStdKeyUpArrow || 

                 aKeyEvent.iScanCode == EStdKeyDownArrow || 

                 aKeyEvent.iScanCode == EStdKeyEnter ||

                 aKeyEvent.iScanCode == EStdKeyDevice3 )

                {            

                return iList->OfferKeyEventL(aKeyEvent, aType);    

                }

            else

                {

                CloseChoiceList();

                return EKeyWasConsumed;                

                }            

            }

        return EKeyWasNotConsumed;          

        }

private:

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

    // CAknChoiceListPopup::CountComponentControls

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

    //

    TInt CountComponentControls() const

        {

        return 1;

        }

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

    // CAknChoiceListPopup::ComponentControl

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

    //

    CCoeControl* ComponentControl(TInt aIndex) const

        {

        if ( aIndex == 0 )

            {            

            return iList;

            }

        return NULL;    

        }

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

    // CAknChoiceListPopup::HandlePointerEventL

    // Decides what to do when pen is used and choice list is active

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