/*

* 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 "mmlistboxview.h"

#include "mmlistbox.h"

#include "mmlistboxitemdrawer.h"

#include "mmlistboxmodel.h"

#include "hnsuitemodel.h"

#include "hnitemsorder.h"

#include <eikfrlb.h>

#include <AknUtils.h>

#include <eikfrlbd.h>

#include <eikspmod.h>

#include <aknlayoutscalable_avkon.cdl.h>

#include <AknsDrawUtils.h>

#ifdef RD_UI_TRANSITION_EFFECTS_LIST

#include <aknlistboxtfx.h>

#include <aknlistboxtfxinternal.h>

#include <akntransitionutils.h>

#include <aknlistloadertfx.h>

#endif

CMmListBoxView::CMmListBoxView ()

	{

	// No implementation required

	}

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

//

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

//

CMmListBoxView::~CMmListBoxView ()

	{

	}

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

//

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

//

CMmListBoxView* CMmListBoxView::NewLC ()

	{

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

	CleanupStack::PushL (self);

	self->ConstructL ();

	return self;

	}

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

//

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

//

CMmListBoxView* CMmListBoxView::NewL ()

	{

	CMmListBoxView* self=CMmListBoxView::NewLC ();

	CleanupStack::Pop( self );

	return self;

	}

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

//

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

//

void CMmListBoxView::ConstructL ()

	{

	iScrollbarIsVisible = ETrue;

	iPreviouslyDrawnCurrentItemIndex = KErrNotFound;

	}

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

//

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

//

void CMmListBoxView::UpdateAverageItemHeight ()

	{

	TInt count( iModel->NumberOfItems() );

	if ( !count )

	    {

	    SetItemHeight( 2 );

	    }

	else

	    {

	    TInt totalHeight = GetTotalHeight( 0, count - 1 );

	    TInt averageItemHeight = totalHeight / count;

	    if ( totalHeight % count )

	        {

	        ++averageItemHeight;

	        // this ensures that it is always possible to

	        // scroll to the very bottom of the view by

	        // using scrollbar.

	        }

	    SetItemHeight( averageItemHeight );

	    }

	}

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

//

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

//

TInt CMmListBoxView::GetTotalHeight (const TInt aStartIndex, TInt aEndIndex) const

	{

	TInt totalHeight = 0;

	if ( aEndIndex >= 0)

		{

		TInt itemCount = iModel->NumberOfItems ();

		aEndIndex = (aEndIndex >= itemCount ) ? itemCount-1 : aEndIndex;

		CMmListBoxItemDrawer* drawer= STATIC_CAST( CMmListBoxItemDrawer*, iItemDrawer);

		for (TInt i(aStartIndex); i <= aEndIndex; i++)

			{

			totalHeight += drawer->GetItemHeight (i, CurrentItemIndex () == i);

			}

		}

	return totalHeight;

	}

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

//

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

//

TInt CMmListBoxView::GetLastIndexInHeight (const TInt aStartIndex, TInt aHeight) const

	{

	TInt i = aStartIndex;

	TInt totalHeight = 0;

	TInt itemCount(iModel->NumberOfItems () );

	CMmListBoxItemDrawer* drawer= STATIC_CAST( CMmListBoxItemDrawer*, iItemDrawer);

	for (; (i > -1) && (i < itemCount); i++)

		{

		totalHeight += drawer->GetItemHeight (i, CurrentItemIndex () == i);

		if ( totalHeight > aHeight)

			break;

		}

	TInt ret(i - aStartIndex);

	if ( !AknLayoutUtils::PenEnabled() && totalHeight > aHeight )

		{

		ret--; // exclude partial item

		}

	return ret;

	}

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

//

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

//

TInt CMmListBoxView::NumberOfItemsThatFitInRect(const TRect& aRect) const

	{

	return GetNumberOfItemsThatFitInRect( aRect, EFalse );

	}

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

//

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

//

TInt CMmListBoxView::GetNumberOfItemsThatFitInRect (const TRect& aRect,

		TBool aIncludePartialItem ) const

	{

	TInt i = iTopItemIndex;

	TInt totalHeight = iVerticalOffset;

	TInt itemCount( iModel->NumberOfItems () );

	CMmListBoxItemDrawer* drawer= STATIC_CAST( CMmListBoxItemDrawer*, iItemDrawer);

	while (totalHeight < aRect.Height ())

		{

		totalHeight += ((i > -1) && (i < itemCount )) ? drawer->GetItemHeight (

				i, CurrentItemIndex () == i) : iItemHeight;

		++i;

		}

	TInt ret(i - iTopItemIndex);

	if ( !AknLayoutUtils::PenEnabled() && !aIncludePartialItem && totalHeight > aRect.Height() )

		{

		ret--; // exclude partial item

		}

	return ret;

	}

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

//

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

//

void CMmListBoxView::CalcBottomItemIndex ()

	{

	TInt numberOfVisibleItems = NumberOfItemsThatFitInRect( iViewRect );

	iBottomItemIndex = Min( iTopItemIndex + numberOfVisibleItems - 1,

	        iModel->NumberOfItems() );

	// The next piece of code removes filtering from find box when

	// new list items are added.

	if ( Flags () & CListBoxView::EItemCountModified)

		{

		CAknFilteredTextListBoxModel *model= STATIC_CAST(CAknFilteredTextListBoxModel*,iModel);

		CAknListBoxFilterItems *filter = model ? model->Filter () : 0;

		if ( filter)

			{

			TRAP_IGNORE(filter->ResetFilteringL());

			}

		}

	}

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

//

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

//

void CMmListBoxView::Draw (const TRect* aClipRect) const

	{

    TBool drawingInitiated(EFalse);

    if ( CAknEnv::Static()->TransparencyEnabled() &&

    		iWin && iWin->GetDrawRect() == TRect::EUninitialized )

    	{

    	TRect a(ViewRect());

    	if (!aClipRect || *aClipRect == TRect(0,0,0,0) )

    		{

    		aClipRect = &a;

    		}

    	drawingInitiated=ETrue;

		iWin->Invalidate( *aClipRect );

		iWin->BeginRedraw( *aClipRect );

    	}

	DoDraw(aClipRect);

	CMmListBoxItemDrawer* itemDrawer =

			static_cast<CMmListBoxItemDrawer*>(iItemDrawer );

    if (aClipRect)

        {

        TRect rect(*aClipRect);

        rect.iTl.iY = ItemPos( BottomItemIndex() ).iY + ItemSize( BottomItemIndex() ).iHeight;

//      iGc->SetClippingRect( rect );

//		removed to prevent non-redraw drawing. Was present to prevent out of view drawing when effects are on.

//      could be removed because effects were disabled at some point in edit mode to enhance performance.

        itemDrawer->DrawFloatingItems( rect );

//      iGc->CancelClippingRect();

        }

    if ( CAknEnv::Static()->TransparencyEnabled() &&

    		iWin && drawingInitiated )

    	{

    	drawingInitiated = EFalse;

    	iWin->EndRedraw( );

    	}

	}

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

//

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

//

void CMmListBoxView::DoDraw(const TRect* aClipRect) const

	{

	CMmListBoxView* view= CONST_CAST( CMmListBoxView*, this );

	view->UpdateAverageItemHeight ();

	CMmListBoxModel* model = static_cast< CMmListBoxModel* > ( iModel );

	if ( model && model->GetSuiteModel()

			&& !model->GetSuiteModel()->GetItemsOrder()->IsSuiteReadyToShow() )

		{

		return;

		}

	if ( RedrawDisabled () || !IsVisible () )

		{

		return;

		}

	TInt i = iTopItemIndex;

	CMmListBoxItemDrawer* itemDrawer =

			static_cast<CMmListBoxItemDrawer*>(iItemDrawer );

	MAknsSkinInstance *skin = AknsUtils::SkinInstance ();

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

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

	if ( !cc)

		{

		cc = itemDrawer->FormattedCellData()->SkinBackgroundContext ();

		}

	itemDrawer->SetTopItemIndex (iTopItemIndex);

	if ( iModel->NumberOfItems () > 0)

		{

		TBool drawingInitiated = ETrue;

		if ( CAknEnv::Static()->TransparencyEnabled () )

			{

			if ( iWin && iWin->GetDrawRect () == TRect::EUninitialized)

				{

#ifdef RD_UI_TRANSITION_EFFECTS_LIST

								MAknListBoxTfxInternal* transApi =

									CAknListLoader::TfxApiInternal( iGc );

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

#else

				drawingInitiated = EFalse;

#endif

				}

			if ( !drawingInitiated)

				{

				iWin->Invalidate ( *aClipRect);

				iWin->BeginRedraw ( *aClipRect);

				}

			}

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

				iTopItemIndex + GetNumberOfItemsThatFitInRect( ViewRect (), ETrue ) );

		if ( CAknEnv::Static()->TransparencyEnabled () && !drawingInitiated)

			{

			iWin->EndRedraw ();

			}

		}

	}

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

//

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

//

void CMmListBoxView::DrawItem (TInt aItemIndex) const

	{

	CMmListBoxItemDrawer* itemDrawer= STATIC_CAST( CMmListBoxItemDrawer*, iItemDrawer );

	TBool currentChanged( CurrentItemIndex() != iPreviouslyDrawnCurrentItemIndex );

	TBool redrawConsumed(EFalse);

	if ( currentChanged )

		{

		CMmListBoxView* view= CONST_CAST( CMmListBoxView*, this );

		redrawConsumed =

			static_cast<CMmListBox*> (itemDrawer->Widget())->RedrawIfNecessary(

								iPreviouslyDrawnCurrentItemIndex,

								CurrentItemIndex());

		view->SetPreviouslyDrawnCurrentItemIndex( CurrentItemIndex() );

		}

	if ( !redrawConsumed )

		{

		DrawSingleItem ( aItemIndex );

		}

	}

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

//

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

//

TSize CMmListBoxView::ItemSize (TInt aItemIndex) const

	{

	CMmListBoxView* view= CONST_CAST( CMmListBoxView*, this );

	view->UpdateAverageItemHeight ();

    CMmListBoxItemDrawer* itemDrawer= STATIC_CAST( CMmListBoxItemDrawer*, iItemDrawer );

    TSize size(CFormattedCellListBoxView::ItemSize(aItemIndex).iWidth, itemDrawer->GetItemHeight (aItemIndex,

            CurrentItemIndex () == aItemIndex) );

    if ( size.iHeight < 2)

        size.iHeight = 2;

    return size;

	}

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

//

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

//

TPoint CMmListBoxView::ItemPos (TInt aItemIndex) const

	{

	TInt vRealPos = CFormattedCellListBoxView::ItemPos(TopItemIndex()).iY;

	TInt totalHeight = 0;

	if ( aItemIndex > iTopItemIndex )

	    {

	    totalHeight = GetTotalHeight( iTopItemIndex, aItemIndex - 1 );

	    }

	else if ( aItemIndex < iTopItemIndex )

	    {

	    totalHeight = -GetTotalHeight( aItemIndex, iTopItemIndex - 1 );

	    }

	return TPoint (-iHScrollOffset + iViewRect.iTl.iX, iViewRect.iTl.iY

			+ totalHeight + vRealPos);

	}

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

//

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

//

TBool CMmListBoxView::XYPosToItemIndex (TPoint aPosition, TInt& aItemIndex) const

	{

	// returns ETrue and sets aItemIndex to the index of the item whose bounding box contains aPosition

	// returns EFalse if no such item exists

	TBool itemFound = EFalse;

	if ( iViewRect.Contains (aPosition))

		{

		TInt vRealPos = CFormattedCellListBoxView::ItemPos(TopItemIndex()).iY;

		// aPosition is inside the display area

		TInt numberOfVisibleItems = GetLastIndexInHeight (iTopItemIndex,

				aPosition.iY - iViewRect.iTl.iY - vRealPos );

		TInt itemAtSpecifiedPos = iTopItemIndex + numberOfVisibleItems;

		aItemIndex = itemAtSpecifiedPos;

		itemFound = ( GetTotalHeight( iTopItemIndex, iBottomItemIndex )

            >= aPosition.iY ) && ( iModel->NumberOfItems() > itemAtSpecifiedPos );

//        if ( itemFound )

//            {

//            // aPosition is inside the display area

//            TInt numberOfVisibleItems = GetLastIndexInHeight (iTopItemIndex,

//                    aPosition.iY - iViewRect.iTl.iY);

//            TInt itemAtSpecifiedPos = iTopItemIndex + numberOfVisibleItems;

//            aItemIndex = itemAtSpecifiedPos;

//            }

		}

	return itemFound;

	}

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

//

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

//

void CMmListBoxView::SetItemHeight (TInt aItemHeight)

	{

	//	we need to update the iItemHeight member in widget also (there are two different item height value holders - in widget and here in widget view)

	iItemHeight = aItemHeight;

	CMmListBoxItemDrawer* itemDrawer =

			STATIC_CAST( CMmListBoxItemDrawer*, ItemDrawer() );

	static_cast<CMmListBox*>(itemDrawer->Widget())->SetItemHeight( aItemHeight );

	}

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

//

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

//

TInt CMmListBoxView::CalcNewTopItemIndexSoItemIsVisible (TInt aItemIndex) const

	{

	CMmListBoxItemDrawer* itemDrawer =

            static_cast<CMmListBoxItemDrawer*>( iItemDrawer );

	TInt newTopItemIndex = iTopItemIndex;

	TInt itemHeight = itemDrawer->

		GetItemHeight( aItemIndex, aItemIndex == CurrentItemIndex() );

	// ItemIsPartiallyVisible uses fixed iItemHeight, but we have to support

	// variable item height in lists, unfortunately ItemIsPartiallyVisible

	// is not virtual

    TPoint itemPosition( ItemPos( aItemIndex ) );

    TBool itemPartiallyVisible =

        ( itemPosition.iY < iViewRect.iTl.iY &&

          itemPosition.iY + itemHeight >= iViewRect.iTl.iY ) ||

        ( itemPosition.iY <= iViewRect.iBr.iY &&

          itemPosition.iY + itemHeight > iViewRect.iBr.iY );

	TBool itemIsFullyVisible = ItemIsVisible( aItemIndex ) &&

            !itemPartiallyVisible;

	TBool itemIsAboveVisibleArea = !itemIsFullyVisible &&

            ItemPos( aItemIndex ).iY < ViewRect().iTl.iY;

	TBool itemIsBeneathVisibleArea = !itemIsFullyVisible &&

            !itemIsAboveVisibleArea && ItemPos( aItemIndex ).iY + itemDrawer->

            GetItemHeight( aItemIndex, aItemIndex == CurrentItemIndex() ) >

            ViewRect().iBr.iY;

	if ( itemIsAboveVisibleArea )

	    {

	    newTopItemIndex = aItemIndex;

	    const_cast<CMmListBoxView*>( this )->SetItemOffsetInPixels( 0 );

	    }

	if ( itemIsBeneathVisibleArea )

        {

        newTopItemIndex = aItemIndex;

        for ( ;; )

            {

            TInt totalHeight = GetTotalHeight( newTopItemIndex, aItemIndex );

            if ( totalHeight >= viewHeight || newTopItemIndex == 0 )

                {

                const_cast<CMmListBoxView*>( this )->SetItemOffsetInPixels(

                        viewHeight - totalHeight );

                break;

                }

            --newTopItemIndex;