/*

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

  {

  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::ModelItemsCount()

    {

    return iModel->NumberOfItems();

    }

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

//

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

//

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;

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

        {

        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 + NumberOfItemsThatFitInRect( ViewRect() ) );

        if ( !itemDrawer->IsEditMode() )

            {

            itemDrawer->DrawBackground( ViewRect() );

            itemDrawer->SetRedrawItemBackground( EFalse );

            itemDrawer->SetDrawSeparatorLines( ETrue );

            while (i < lastPotentialItemIndex)

                {

                DrawItem(i++);

                }

            itemDrawer->SetRedrawItemBackground( ETrue );

            itemDrawer->SetDrawSeparatorLines( EFalse );

            }

        else

            {

            while (i < lastPotentialItemIndex)

                {

                DrawItem(i++);

                }

        // this redraws background in the view portion not covered by items

            RedrawBackground();

            }

        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 )

        {

        itemDrawer->SetDrawSeparatorLines( ETrue );

        DrawSingleItem ( aItemIndex );

        itemDrawer->SetDrawSeparatorLines( EFalse );

        }

    }

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

//

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

//

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 )

        {

        const TInt viewHeight = ViewRect().Height();

        newTopItemIndex = aItemIndex;

        for ( ;; )

            {

            TInt totalHeight = GetTotalHeight( newTopItemIndex, aItemIndex );

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

                {

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

                        viewHeight - totalHeight );

                break;

                }

            --newTopItemIndex;

            }

        }

  return newTopItemIndex;

  }

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

//

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

//

void CMmListBoxView::RedrawBackground (TRect aUsedPortionOfViewRect,

        TRect aSmallerViewRect) const

    {

#ifdef RD_UI_TRANSITION_EFFECTS_LIST

    MAknListBoxTfxInternal* transApi = CAknListLoader::TfxApiInternal(iGc);

    if (transApi)

        {

        transApi->StartDrawing(MAknListBoxTfxInternal::EListView);

        }

#endif

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

    MAknsSkinInstance *skin = AknsUtils::SkinInstance();

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

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

    if (control)

        {

        AknsDrawUtils::BackgroundBetweenRects( skin, cc, control, *iGc,

                aSmallerViewRect, aUsedPortionOfViewRect);

        }

    else

        {

        iGc->SetBrushColor(BackColor());

        DrawUtils::ClearBetweenRects(*iGc, aSmallerViewRect,

                aUsedPortionOfViewRect);

        }

#ifdef RD_UI_TRANSITION_EFFECTS_LIST

    if( transApi )

        {

        transApi->StopDrawing();

        }

#endif

  }

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

//