/*

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

    {

    }

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

//

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

//

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 )

    {

    CAknGrid::HandleScrollEventL(aScrollBar, aEventType);

    iCurrentTopItemIndex = TopItemIndex();

    // setting default highligh in order not to overwrite the top item index

    // set before in the SetLayout method

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

    if (!parent->IsHighlightVisible())

         {

         parent->SetDefaultHighlightL( EFalse );

#ifdef RD_UI_TRANSITION_EFFECTS_LIST

         MAknListBoxTfxInternal* transApi = CAknListLoader::TfxApiInternal(

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

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

         if ( effects && aEventType == EEikScrollPageUp ||

                 aEventType == EEikScrollPageDown )

             {

             DrawNow();

             }

#endif

         }

    }

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

//

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

//

void CMmGrid::HandlePointerEventInEditModeL( const TPointerEvent& aPointerEvent )

    {

    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;

    }

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

//

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

//

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

        {

        HandlePointerEventInNormalModeL( aPointerEvent );

        }

    if ( iMmDrawer->GetFloatingItemCount() > 0 &&