/*

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

    {

        {

        static_cast<CMmListBoxItemDrawer*>(

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

        }

    else if ( aEventType == EEikScrollThumbReleaseVert )

        {

        static_cast<CMmListBoxItemDrawer*>(

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

        }

        ProcessScrollEventL( aScrollBar, aEventType );

        }

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

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

    {

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

        CAknGrid::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 ) )

        {

        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 )

    {

    CAknGrid::HandlePointerEventL(aPointerEvent);

    }

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

//

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

//

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

        + ( MmGrid::KFocusScrollingThreshold

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

    return ( aPointerEvent.iPosition.iY < topScrollingTreshold );

    }

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

//

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

//

TBool CMmGrid::IsPointerInBottomScrollingThreshold(

            const TPointerEvent& aPointerEvent ) const

    {

    TInt bottomScrollingTreshold = Rect().iBr.iY

        - ( MmGrid::KFocusScrollingThreshold

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

    return ( aPointerEvent.iPosition.iY > bottomScrollingTreshold );

    }

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

//

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

//

void CMmGrid::ScrollWithoutRedraw( TInt distanceInPixels )

    {

    const TInt rowHeight = ItemHeight();

    const TInt numOfCols = view->NumberOfColsInView();

    const TInt itemCount = iModel->NumberOfItems();

    TInt totalNumberOfRows = 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;

    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 )

    {

    TInt nextScrollDelay = 0;

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

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

        }

    }

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

//

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

//

void CMmGrid::HandleOverridenHighlightDrawing( const TPointerEvent& aPointerEvent,

        TInt aIndexBefore, TInt aIndexAfter )

    {

    // In grid our behaviour is a little different than defalt avkon.

    // It is required to clean the highlight after the finger has been raised,

    // and simulate the tap effect, when an item that has an invisible

    // highlight is tapped again.

    TBool effects (EFalse);

#ifdef RD_UI_TRANSITION_EFFECTS_LIST

        MAknListBoxTfxInternal *transApi = CAknListLoader::TfxApiInternal(

                iMmDrawer->Gc() );

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

#endif

    if (effects)

        {

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

        if ( aIndexBefore == aIndexAfter

                && !parent->IsEditMode()

                && aPointerEvent.iType == TPointerEvent::EButton1Down )

            {

            DrawItem( aIndexAfter );

#ifdef RD_UI_TRANSITION_EFFECTS_LIST

            MAknListBoxTfxInternal *transApi = CAknListLoader::TfxApiInternal(

                    iMmDrawer->Gc() );

             if ( transApi )

                 {

                 transApi->SetMoveType( MAknListBoxTfxInternal::EListTap);

                 transApi->Draw( Rect() );

                 }

#endif

            }

        else if ( aIndexBefore == aIndexAfter

                && aPointerEvent.iType == TPointerEvent::EButton1Up

                && !parent->IsHighlightVisible())

            {

#ifdef RD_UI_TRANSITION_EFFECTS_LIST

            MAknListBoxTfxInternal *transApi = CAknListLoader::TfxApiInternal(

                    iMmDrawer->Gc() );

             if ( transApi )

                 {

                 transApi->Draw( Rect() );

                 }

#endif

            }

        }

    }

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

//