/*

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

  {

  }

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

//

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

//

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 );

  }

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

// 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;

        {

        }

        }

    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 );

      }

    }

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

//

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

//

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 );

    }

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

//

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

//

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 );

            }

        else if ( differenceIndex > 1 )

            {

            redrawIndex = Min( aPreviousCurrent, aCurrent );

            }

        if (redrawIndex < iView->TopItemIndex())

            redrawIndex = iView->TopItemIndex();

        if (lastPotentialItemIndex > iView->BottomItemIndex())

            lastPotentialItemIndex = iView->BottomItemIndex();

        if ( aPreviousCurrent < TopItemIndex() )

          {

          lastPotentialItemIndex = BottomItemIndex() ;

          }

        else if ( BottomItemIndex() < aPreviousCurrent )

          {

          lastPotentialItemIndex = BottomItemIndex() + 1;

          }