/*

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

*

*/

#include <aknlists.h>

#include <eikspmod.h>

#include <eikclb.h>

#include <eikfrlb.h>

#include <eikslb.h>

#include <AknUtils.h>

#include <aknlayoutscalable_avkon.cdl.h>

#include <aknlayoutscalable_apps.cdl.h>

#include <layoutmetadata.cdl.h>

#ifdef RD_UI_TRANSITION_EFFECTS_LIST

#include <aknlistboxtfxinternal.h>

#include <akntransitionutils.h>

#include <aknlistloadertfx.h>

#endif

#include "mmlistboxmodel.h"

#include "mmlistbox.h"

#include "mmlistboxview.h"

#include "mmlistboxitemdrawer.h"

#include "mmmarqueeadapter.h"

#include "mmwidgetcontainer.h"

#include "mmwidgetsconstants.h"

#include "mmdraweranimator.h"

#include "mmtemplatelibrary.h"

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

//

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

//

CMmListBox::CMmListBox() : AKNDOUBLELISTBOXNAME(R_LIST_PANE_LINES_AB_COLUMN)

	{

	// No implementation required

	}

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

//

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

//

CMmListBox::~CMmListBox()

	{

	delete iRedrawTimer;

	}

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

//

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

//

CMmListBox* CMmListBox::NewLC( const CCoeControl* aParent, TInt aFlags,

    CMmTemplateLibrary* aTemplateLibrary )

	{

	CMmListBox* self = new (ELeave)CMmListBox();

	CleanupStack::PushL(self);

	self->ConstructL( aParent, aFlags, aTemplateLibrary );

	return self;

	}

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

//

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

//

void CMmListBox::SetListFlag( TInt aFlag )

	{

	iListBoxFlags = iListBoxFlags | aFlag;

	}

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

//

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

//

void CMmListBox::ClearListFlag( TInt aFlag )

	{

	iListBoxFlags = iListBoxFlags & !aFlag;

	}

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

//

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

//

CMmListBox* CMmListBox::NewL( const CCoeControl* aParent, TInt aFlags,

    CMmTemplateLibrary* aTemplateLibrary )

	{

	CMmListBox* self = CMmListBox::NewLC( aParent, aFlags, aTemplateLibrary );

	CleanupStack::Pop( self );

	return self;

	}

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

//

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

//

void CMmListBox::ConstructL( const CCoeControl* aParent, TInt aFlags,

    CMmTemplateLibrary* aTemplateLibrary )

	{

	iDisableChildComponentDrawing = EFalse;

	iModel = iMmModel = CMmListBoxModel::NewL();

    CreateItemDrawerL( aTemplateLibrary );

    EnableExtendedDrawingL();

    iItemDrawer->SetDrawMark(EFalse);

    CEikListBox::ConstructL(aParent,aFlags);

    iMmDrawer->SetView( this );

    iRedrawTimer = CPeriodic::NewL( EPriorityRealTime );

	}

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

// Clearing ELeftDownInViewRect flag before invoking the base class

// HandlePointerEventL method effectively prevents that method from doing most

// of the things it would normally do in response to EButton1Down event.

// This flag is explicitly cleared to achieve two things:

// 1. Prevent kinetic scrolling (flick) in edit mode.

// 2. Prevent highlight removal when popup menu is displayed.

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

//

void CMmListBox::HandlePointerEventInEditModeL(

        const TPointerEvent& aPointerEvent )

    {

    CMmWidgetContainer* parent = static_cast<CMmWidgetContainer*>( Parent() );

    if ( aPointerEvent.iType == TPointerEvent::EButton1Down )

        {

        iButton1DownPos = aPointerEvent.iPosition;

        }

    else if ( aPointerEvent.iType == TPointerEvent::EButton1Up )

        {

        TPoint dragDelta = iButton1DownPos - aPointerEvent.iPosition;

        if ( Abs( dragDelta.iY ) > KDragTreshold || parent->LongTapInProgress() )

            {

            iListBoxFlags &= ~ELeftDownInViewRect;

            }

        }

    TInt itemUnderPointerIndex = KErrNotFound;

    if ( aPointerEvent.iType == TPointerEvent::EButton1Up ||

            aPointerEvent.iType == TPointerEvent::EButton1Down )

        {

        TBool highlightWasVisible = parent->IsHighlightVisible();

        CEikFormattedCellListBoxTypedef::HandlePointerEventL( aPointerEvent );

        // Tricky: Do not allow the base class implementation of HandlePointerEventL 

        //         to remove the highlight on EButton1Up event when context menu

        //         is displayed for an item

        if ( aPointerEvent.iType == TPointerEvent::EButton1Up &&

                highlightWasVisible && parent->LongTapInProgress()

                && !parent->IsHighlightVisible() )

            {

            ItemDrawer()->ClearFlags( CListItemDrawer::ESingleClickDisabledHighlight );

            }

        }

    else if ( View()->XYPosToItemIndex(

            aPointerEvent.iPosition, itemUnderPointerIndex ) )

        {

        TInt currentItemIndex = CurrentItemIndex();

        if ( currentItemIndex != itemUnderPointerIndex )

            {

            View()->SetCurrentItemIndex( itemUnderPointerIndex );

            // remove hightlight from the previously highlighted item

            }

        }

    HandleScrollingInEditMode( aPointerEvent );

    }

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

//

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

//

void CMmListBox::HandleScrollingInEditMode( const TPointerEvent& aPointerEvent )

    {

    if ( aPointerEvent.iType == TPointerEvent::EDrag

            || aPointerEvent.iType == TPointerEvent::EButtonRepeat )

        {

        TInt nextScrollDelay = ScrollIfNeeded( aPointerEvent );

        if ( nextScrollDelay )

            {

            TRect ignoreDragRect(

                TPoint(aPointerEvent.iParentPosition.iX - MmEffects::KDragIgnoreRectValue,

                    aPointerEvent.iParentPosition.iY - MmEffects::KDragIgnoreRectValue),

                TPoint(aPointerEvent.iParentPosition.iX + MmEffects::KDragIgnoreRectValue,

                    aPointerEvent.iParentPosition.iY + MmEffects::KDragIgnoreRectValue));

            Window().CancelPointerRepeatEventRequest();

            Window().RequestPointerRepeatEvent( nextScrollDelay, ignoreDragRect );

            }

        }

    }

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

//

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

//

TBool CMmListBox::IsPointerInTopScrollingThreshold(

            const TPointerEvent& aPointerEvent ) const

    {

    TInt topScrollingTreshold = Rect().iTl.iY

        + ( MmListBox::KFocusScrollingThreshold

            * TReal( View()->ItemSize().iHeight ) );

    return ( aPointerEvent.iPosition.iY < topScrollingTreshold );

    }

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

//

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

//

TBool CMmListBox::IsPointerInBottomScrollingThreshold(

            const TPointerEvent& aPointerEvent ) const

    {

    TInt bottomScrollingTreshold = Rect().iBr.iY

        - ( MmListBox::KFocusScrollingThreshold

            * TReal( View()->ItemSize().iHeight ) );

    return ( aPointerEvent.iPosition.iY > bottomScrollingTreshold );

    }

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

//

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

//

TInt CMmListBox::ScrollIfNeeded( const TPointerEvent& aPointerEvent )

    {

    TInt nextScrollDelay = 0;

	TBool readyForScrolling =

			iMmDrawer->GetAnimator()->IsReadyForNewAnimation()

					&& iMmDrawer->GetFloatingItemCount() != 0;

	if ( IsPointerInTopScrollingThreshold( aPointerEvent ) )

		{

		// scroll up by one row

		TInt newCurrentItemIndex = CurrentItemIndex() - 1;

		if ( newCurrentItemIndex >= 0 )

			{

			nextScrollDelay = MmEffects::KEditModeScrollingDelayFactor *

				Max( 1, aPointerEvent.iPosition.iY - Rect().iTl.iY );

			if (readyForScrolling)

				{

				View()->VScrollTo( View()->CalcNewTopItemIndexSoItemIsVisible(

                        newCurrentItemIndex ) );

                View()->SetCurrentItemIndex( newCurrentItemIndex );

                UpdateScrollBarThumbs();

				}

			}

		}

	else if ( IsPointerInBottomScrollingThreshold( aPointerEvent) )

		{

		// scroll down by one row

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

		TInt newCurrentItemIndex = CurrentItemIndex() + 1;

		if ( newCurrentItemIndex <= lastItemIndex )

			{

			nextScrollDelay = MmEffects::KEditModeScrollingDelayFactor *

				Max( 1, Rect().iBr.iY - aPointerEvent.iPosition.iY );

			if (readyForScrolling)

				{

				View()->VScrollTo( View()->CalcNewTopItemIndexSoItemIsVisible(

						newCurrentItemIndex ) );

				View()->SetCurrentItemIndex( newCurrentItemIndex );

                UpdateScrollBarThumbs();

				}

			}

		}

    return nextScrollDelay;

    }

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

//

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

//

void CMmListBox::HandlePointerEventL(const TPointerEvent& aPointerEvent)

    {

//    if ( aPointerEvent.iType == TPointerEvent::EButton1Down &&

//            iMmDrawer->CachedDataUseIsEnabled() )

//        {

//        // Touching the screen stops flick but avkon does not send us

//        // MEikListBoxObserver::EEventFlickStopped event in such case.

//        // Thus this little hack:

//        iMmDrawer->EnableCachedDataUse( EFalse );

//        DrawView();

//        }

    CMmWidgetContainer* parent = static_cast<CMmWidgetContainer*>( Parent() );

    if ( parent->IsEditMode() )

        {

        HandlePointerEventInEditModeL( aPointerEvent );

        }

    else

    	{

        CEikFormattedCellListBoxTypedef::HandlePointerEventL( aPointerEvent );

    	}

    if ( iMmDrawer->GetAnimator()->IsActive() )

    	{

    	iMmDrawer->GetAnimator()->CancelNextRedrawL();

    	}

    }

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

//

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

//

void CMmListBox::FixViewForMirroredLayout()

    {

    TInt scrollbarWidth =

            ScrollBarFrame()->VerticalScrollBar()->Rect().Width();

    TRect r( View()->ViewRect() );

    TInt currentShift = r.iTl.iX;

    TBool scrollbarVisible = ScrollBarFrame()->VerticalScrollBar()->IsVisible();

    TBool layoutMirrored = AknLayoutUtils::LayoutMirrored();

    if ( layoutMirrored && scrollbarVisible && currentShift != scrollbarWidth )

        {

        // shift view rect to the right

        r.Move( scrollbarWidth - currentShift, 0 );

        View()->SetViewRect( r );

        }

    else if ( ( !layoutMirrored || !scrollbarVisible ) && currentShift != 0 )

        {

        // restore view rect to its normal position

        r.Move( -currentShift, 0 );

        View()->SetViewRect( r );

        }

    }

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

//

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

//

void CMmListBox::RedrawScrollbarBackground() const

    {

    TRect viewRect( View()->ViewRect() );

    if ( viewRect.iTl.iX > 0 )

        {

        TRect scrollbarRect( TPoint( 0, 0 ),

                TSize( viewRect.iTl.iX, viewRect.Height() ) );

        CWindowGc* gc = iItemDrawer->Gc();

        CMmListBoxItemDrawer* itemDrawer =

                static_cast<CMmListBoxItemDrawer*>( iItemDrawer );

        MAknsSkinInstance *skin = AknsUtils::SkinInstance();

        CCoeControl* control = itemDrawer->FormattedCellData()->Control();

        MAknsControlContext *cc = AknsDrawUtils::ControlContext( control );

        if( gc )

            {

            if ( control )

                {

                AknsDrawUtils::Background( skin, cc, control, *gc, scrollbarRect );

                }

            else

                {

                gc->SetBrushColor( BackColor() );

                gc->Clear( scrollbarRect );

                }

            }

        }

    }

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

//

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

//

void CMmListBox::ProcessScrollEventL( CEikScrollBar* aScrollBar, 

            TEikScrollEvent aEventType )

    {

    CEikFormattedCellListBoxTypedef::HandleScrollEventL(

            aScrollBar, aEventType );

    }

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

//

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

//

void CMmListBox::HandleRedrawTimerEventL()

    {

    if ( iSkippedScrollbarEventsCount )

        {

        ProcessScrollEventL( ScrollBarFrame()->VerticalScrollBar(),

                EEikScrollThumbDragVert );

        }

    iSkippedScrollbarEventsCount = 0;

    }

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

//

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

//

TInt CMmListBox::RedrawTimerCallback( TAny* aPtr )

    {

    CMmListBox* self = static_cast<CMmListBox*>( aPtr );

    TRAP_IGNORE( self->HandleRedrawTimerEventL() );

    // Do not bother returning a meaningful error code, CPeriodic will ignore it

    // anyway.

    return 0;

    }

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

//

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

//

TKeyResponse CMmListBox::OfferKeyEventL(

        const TKeyEvent& aKeyEvent,TEventCode aType )

    {

    TInt itemIndex = CurrentItemIndex();

    TInt previousItemIndex = CurrentItemIndex();

    TKeyResponse ret = CEikFormattedCellListBoxTypedef::OfferKeyEventL(

        aKeyEvent, aType );

    TInt currentItemIndex = CurrentItemIndex();

    TInt itemY = View()->ItemPos( currentItemIndex ).iY

               + View()->ItemSize( currentItemIndex ).iHeight;

    if ( currentItemIndex == BottomItemIndex()

    		&& currentItemIndex != previousItemIndex

    		&& itemY > View()->ViewRect().iBr.iY )

    	{

    	if( aType == EEventKey )

    		{

#ifdef RD_UI_TRANSITION_EFFECTS_LIST

    		MAknListBoxTfxInternal* transApi = CAknListLoader::TfxApiInternal(

    		    View()->ItemDrawer()->Gc() );

    		TBool effects = transApi && !transApi->EffectsDisabled();

    		if ( effects )

    			{

    			transApi->SetMoveType( MAknListBoxTfxInternal::EListScrollDown );

    			}

#endif

			iView->VScrollTo(

				iView->CalcNewTopItemIndexSoItemIsVisible( currentItemIndex ) );

#ifdef RD_UI_TRANSITION_EFFECTS_LIST

			if ( effects )

				{

				transApi->Draw( Rect() );

				}

#endif

			}

    	SetCurrentItemIndex( currentItemIndex );

    	}

    RedrawIfNecessary( itemIndex, CurrentItemIndex());

    return ret;

    }

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

//

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

//

TBool CMmListBox::RedrawIfNecessary( TInt aPreviousCurrent, TInt aCurrent )

    {

    TBool redrawConsumed( EFalse );

    if( aCurrent == KErrNotFound )

        {

        return redrawConsumed;

        }

    CMmListBoxView * view = static_cast<CMmListBoxView *>(iView);

    TInt differenceIndex = Abs( aPreviousCurrent - aCurrent );

    if ( aPreviousCurrent == KErrNotFound  || differenceIndex == 0 )

        {

        //TODO: It should be checked if this is really necessary

        view->RedrawBackground();

        return redrawConsumed;

        }

    TInt sizePrevBefore = iMmDrawer->GetItemHeight(aPreviousCurrent, ETrue);

    TInt sizeCurBefore = iMmDrawer->GetItemHeight(aCurrent, EFalse);

    TInt sizePrevAfter = iMmDrawer->GetItemHeight(aPreviousCurrent, EFalse);

    TInt sizeCurAfter = iMmDrawer->GetItemHeight(aCurrent, ETrue);

    if ( ( sizePrevBefore == sizePrevAfter ) && (sizeCurBefore == sizeCurAfter) )

        {

        return redrawConsumed;

        }

     else

        {

        TInt sizeAllBefore = sizePrevBefore + sizePrevAfter;

        TInt sizeAllAfter = sizeCurBefore + sizeCurAfter;

        TInt lastPotentialItemIndex = Min( iModel->NumberOfItems(),

                iView->TopItemIndex() + iView->NumberOfItemsThatFitInRect(

                        iView->ViewRect() ) );

        TInt redrawIndex = lastPotentialItemIndex;

        if ( differenceIndex == 1 )

            {

            if( sizeAllBefore != sizeAllAfter )

            	{

                redrawIndex = Min( aPreviousCurrent, aCurrent );

            	}

            else

            	{

            	return redrawConsumed;

            	}

            }

        else if ( differenceIndex > 1 && sizeAllBefore == sizeAllAfter  )

            {

            redrawIndex = Min( aPreviousCurrent, aCurrent );

            lastPotentialItemIndex = Max( aPreviousCurrent, aCurrent );