/*

* 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 <AknsDrawUtils.h>

#include <layoutmetadata.cdl.h>

#include "mmgrid.h"

#include "mmgridmodel.h"

#include "mmlistboxitemdrawer.h"

#include "mmgridview.h"

#include "mmtemplatelibrary.h"

#include "mmlistboxmodel.h"

#include "mmmarqueeadapter.h"

#include "mmwidgetsconstants.h"

#include "mmwidgetcontainer.h"

#include "hnsuitemodel.h"

#include "mmdraweranimator.h"

#ifdef RD_UI_TRANSITION_EFFECTS_LIST

#include <aknlistloadertfx.h>

#include <aknlistboxtfxinternal.h>

#endif

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

//

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

//

CMmGrid::CMmGrid()

    {

    // No implementation required

    }

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

//

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

//

CMmGrid::~CMmGrid()

    {

    delete iRedrawTimer;

    }

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

//

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

//

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

        CMmTemplateLibrary* aTemplateLibrary)

    {

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

    CleanupStack::PushL(self);

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

    return self;

    }

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

//

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

//

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

        CMmTemplateLibrary* aTemplateLibrary )

    {

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

    CleanupStack::Pop( self );

    return self;

    }

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

// If a parent to the supplied control has its Gc set, this function will find

// it and return it. (Copied from EIKLBX.CPP, needed by CMmGrid::Draw)

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

//

LOCAL_C CWindowGc* ReplaceGcWithCustomGc( const CEikListBox* aListBox )

    {

    const CCoeControl* parent = aListBox;

    CWindowGc* customGc;

    while(parent)

        {

        customGc = parent->GetGc();

        if ( customGc )

            {

            CListItemDrawer* itemDrawer = aListBox->View()->ItemDrawer();

            CWindowGc* originalGc = itemDrawer->Gc();

            if ( customGc == originalGc )

                return NULL;

                }

            else

                {

                itemDrawer->SetGc( customGc );

                return originalGc;

                }

            }

        parent = parent->Parent();

        }

    return NULL;

    }

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

//

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

//

void CMmGrid::Draw(const TRect& aRect) const

    {

    if ( View()->RedrawDisabled () || !IsVisible () )

        {

        return;

        }

    iMmDrawer->SetNumberOfColsInView(

            static_cast<CMmGridView*>(iView)->NumberOfColsInView() );

    // If a parent has a custom gc, draw listbox using that gc

    CWindowGc* replacedGc = ReplaceGcWithCustomGc( this );

    CWindowGc* gc = iItemDrawer->Gc();

    TGulBorder::TColors borderColors;

    iBorder.Draw(*gc, Rect(), borderColors);

#ifdef RD_UI_TRANSITION_EFFECTS_LIST

    MAknListBoxTfxInternal* transApi = CAknListLoader::TfxApiInternal(

            static_cast<CMmGridView*>(iView)->Gc() );

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

    if ( effects )

        {

        // ViewRect might have been moved to the right to prevent grid items

        // from overlapping the scrollbar in mirrored layout.

        // However, we still have to draw scrollbar background, thus the

        // rectangle object passed to MAknListBoxTfxInternal::BeginRedraw must

        // be placed at (0, 0) so that it covers the area where scrollbar is

        // drawn.

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

        transApi->BeginRedraw( MAknListBoxTfxInternal::EListView, r );

        transApi->StartDrawing( MAknListBoxTfxInternal::EListView );

        }

#endif // RD_UI_TRANSITION_EFFECTS_LIST

    ClearMargins();

    RedrawScrollbarBackground();

#ifdef RD_UI_TRANSITION_EFFECTS_LIST

    if ( effects )

        {

        transApi->StopDrawing();

        }

#endif // RD_UI_TRANSITION_EFFECTS_LIST

    iView->Draw(&aRect);

#ifdef RD_UI_TRANSITION_EFFECTS_LIST

    if ( effects )

        {

        transApi->EndViewRedraw( aRect );

        }

#endif // RD_UI_TRANSITION_EFFECTS_LIST

    if ( replacedGc )

        {

        // Stop using the custom gc

        iItemDrawer->SetGc( replacedGc );

        }

    }

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

//

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

//

void CMmGrid::DrawView()

    {

    iDisableChildComponentDrawing = ETrue;

    DrawNow(Rect());

    iDisableChildComponentDrawing = EFalse;

    }

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

//

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

//

void CMmGrid::CreateItemDrawerL()

    {

    iItemDrawer = iMmDrawer;

    }

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

//

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

//

void CMmGrid::CreateItemDrawerL( CMmTemplateLibrary* aTemplateLibrary )

    {

    CFormattedCellListBoxData* data=CFormattedCellGridData::NewL();

    CleanupStack::PushL(data);

    iMmDrawer = CMmListBoxItemDrawer::NewL(

        MmModel()->MmListBoxModel(), iEikonEnv->NormalFont(), data, EGrid,

        aTemplateLibrary );

    iItemDrawer = iMmDrawer;

    data->SetControl( this );

    CleanupStack::Pop( data );

    }

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

//

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

//

void CMmGrid::HandleScrollEventL( CEikScrollBar* aScrollBar,

        TEikScrollEvent aEventType )

    {

    if ( aEventType == EEikScrollThumbDragVert && !iScrollbarThumbIsBeingDragged )

        {

        iScrollbarThumbIsBeingDragged = ETrue;

        static_cast<CMmListBoxItemDrawer*>(

                View()->ItemDrawer() )->EnableCachedDataUse( ETrue );

        iRedrawTimer->Start( KScrollingRedrawInterval, KScrollingRedrawInterval,

                TCallBack( &CMmGrid::RedrawTimerCallback, static_cast<TAny*>( this ) ) );

        }

    else if ( aEventType == EEikScrollThumbReleaseVert )

        {

        iScrollbarThumbIsBeingDragged = EFalse;

        static_cast<CMmListBoxItemDrawer*>(

                View()->ItemDrawer() )->EnableCachedDataUse( EFalse );

        // The view will be redrawn with cache disabled when ProcessScrollEventL

        // calls the base class's HandleScrollEventL method -- no need to

        // explicitly redraw the view.

        iRedrawTimer->Cancel();

        }

    if ( !iScrollbarThumbIsBeingDragged )

        {

        ProcessScrollEventL( aScrollBar, aEventType );

        }

    else

        {

        __ASSERT_DEBUG( aEventType == EEikScrollThumbDragVert, User::Invariant() );

        ++iSkippedScrollbarEventsCount;

        }

    }

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

// 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 CMmGrid::HandlePointerEventInEditModeL( const TPointerEvent& aPointerEvent )

    {

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

        {

        iButton1DownPos = aPointerEvent.iPosition;

        }

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

        {

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

        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 )

        {

        CAknGrid::HandlePointerEventL( aPointerEvent );

        }

    else if ( View()->XYPosToItemIndex(

            aPointerEvent.iPosition, itemUnderPointerIndex ) )

        {

        if ( CurrentItemIndex() != itemUnderPointerIndex )

            {

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

    		if ( parent->IsNoItemDragged() )

    			{

    			if ( ItemDrawer()->Flags() & CListItemDrawer::EPressedDownState )

    				{

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

    				iView->DrawItem( CurrentItemIndex() );

    				}

    			}

    		else

    			{

    			iView->SetCurrentItemIndex( itemUnderPointerIndex );

				iView->DrawItem(itemUnderPointerIndex);

    			}

            }

        }

    HandleScrollingInEditMode( aPointerEvent );

    }

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

//

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

//

void CMmGrid::HandlePointerEventInNormalModeL( const TPointerEvent& aPointerEvent )

    {

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

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

		{

        const TInt KIgnoreRectSize = 40;

        TRect ignoreDragRect(aPointerEvent.iPosition,

                TSize(KIgnoreRectSize, KIgnoreRectSize));

        ignoreDragRect.Move( - KIgnoreRectSize / 2, - KIgnoreRectSize / 2 );

        Window().RequestPointerRepeatEvent( 50000, ignoreDragRect );

		}

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

        {

        HandleButtonRepeatEventInNormalModeL( aPointerEvent );

        }

	CAknGrid::HandlePointerEventL(aPointerEvent);

    }

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

//

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

//

void CMmGrid::HandleButtonRepeatEventInNormalModeL(

        const TPointerEvent& aPointerEvent )

    {

    TInt itemUnderPointerIndex = KErrNotFound;

    TBool itemFound = View()->XYPosToItemIndex(

            aPointerEvent.iPosition, itemUnderPointerIndex );

    if ( !itemFound )

        {

        return;

        }

    View()->ItemDrawer()->SetFlags( CListItemDrawer::EPressedDownState );

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

    TBool highlightWasVisible = parent->IsHighlightVisible();

    if( itemUnderPointerIndex == View()->CurrentItemIndex() )

        {

#ifdef RD_UI_TRANSITION_EFFECTS_LIST

        MAknListBoxTfxInternal *transApi = CAknListLoader::TfxApiInternal(

                iMmDrawer->Gc() );

         if ( transApi )

             {

             transApi->Remove( MAknListBoxTfxInternal::EListHighlight );

             View()->DrawItem( itemUnderPointerIndex );

             TRect itemUnderPointerIndexRect (

                     View()->ItemPos(itemUnderPointerIndex),

                     View()->ItemSize(itemUnderPointerIndex));

             transApi->Draw( itemUnderPointerIndexRect );

             }

         else

        	 {

        	 View()->DrawItem( itemUnderPointerIndex );

        	 }

#else

         View()->DrawItem( itemUnderPointerIndex );

#endif

        }

     else

        {

        TInt previouslyHighlightedItemIndex = View()->CurrentItemIndex();

        parent->SetManualHighlightL( itemUnderPointerIndex , EFalse );

        if ( highlightWasVisible )

            {

            View()->DrawItem( previouslyHighlightedItemIndex );

            }

        }

    }

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

//

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

//

void CMmGrid::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 CMmGrid::IsPointerInTopScrollingThreshold(

            const TPointerEvent& aPointerEvent ) const

    {

    TInt topScrollingTreshold = Rect().iTl.iY

        + ( MmEffects::KFocusScrollingThreshold

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

    return ( aPointerEvent.iPosition.iY < topScrollingTreshold );

    }

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

//

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

//

TBool CMmGrid::IsPointerInBottomScrollingThreshold(

            const TPointerEvent& aPointerEvent ) const

    {

    TInt bottomScrollingTreshold = Rect().iBr.iY

        - ( MmEffects::KFocusScrollingThreshold

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

    return ( aPointerEvent.iPosition.iY > bottomScrollingTreshold );

    }

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

//

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

//

void CMmGrid::ScrollWithoutRedraw( TInt distanceInPixels )

    {

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

    const TInt rowHeight = ItemHeight();

    const TInt numOfCols = view->NumberOfColsInView();

    const TInt itemCount = iModel->NumberOfItems();

    TInt totalNumberOfRows = itemCount / numOfCols;

    if ( itemCount % numOfCols )

        {

        ++totalNumberOfRows;

        }

    const TInt topItemRowIndex = TopItemIndex() / numOfCols;

    // desired view position relative to the first item in grid (always positive)

    TInt desiredViewPosition = rowHeight * topItemRowIndex - VerticalItemOffset();

    desiredViewPosition += distanceInPixels;

    const TInt viewPositionMin = 0;

    const TInt viewPositionMax = 

		Max( 0, ( totalNumberOfRows * rowHeight ) - view->ViewRect().Height() );

    desiredViewPosition = Min( desiredViewPosition, viewPositionMax );

    desiredViewPosition = Max( desiredViewPosition, viewPositionMin );

    ASSERT( desiredViewPosition >= 0 );

    TInt newTopItemIndex = ( desiredViewPosition / rowHeight ) * numOfCols;

    TInt newVerticalOffset = -( desiredViewPosition % rowHeight ); 

    SetTopItemIndex( newTopItemIndex );

    SetVerticalItemOffset( newVerticalOffset );

    }

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

//

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

//

TInt CMmGrid::ScrollIfNeeded( const TPointerEvent& aPointerEvent )

    {

    CAknGridView* view = static_cast<CAknGridView*>( View() );

    TInt nextScrollDelay = 0;

    TBool readyForScrolling = iMmDrawer->GetAnimator()->IsReadyForNewAnimation()

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

	if ( IsPointerInTopScrollingThreshold( aPointerEvent ) )

		{

		// scroll up by one row

		TInt newCurrentItemIndex = CurrentItemIndex() - view->NumberOfColsInView();

        if ( newCurrentItemIndex < 0 )

            {

            newCurrentItemIndex = CurrentItemIndex();

            }

       nextScrollDelay = MmEffects::KEditModeScrollingDelayFactor *

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

		if ( readyForScrolling )

			{

			ScrollWithoutRedraw( -iItemHeight );

			View()->SetCurrentItemIndex( newCurrentItemIndex );

			}

		}

	else if ( IsPointerInBottomScrollingThreshold( aPointerEvent) )

		{

		TInt newCurrentItemIndex = CurrentItemIndex() + view->NumberOfColsInView();

		if ( newCurrentItemIndex > iModel->NumberOfItems() - 1 )

			{

			newCurrentItemIndex = CurrentItemIndex();

			}

		nextScrollDelay = MmEffects::KEditModeScrollingDelayFactor *

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

		if ( readyForScrolling )

			{

			ScrollWithoutRedraw( iItemHeight );

			View()->SetCurrentItemIndex( newCurrentItemIndex );

			}

		}

    return nextScrollDelay;

    }