/*
* Copyright (c) 2009-2009 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:  List pane component for UI fields
*
*/
#include "cmrlistpane.h"

#include <eikscrlb.h>
#include <AknUtils.h>
#include <touchfeedback.h>

#include "mesmrfieldstorage.h"
#include "cesmrfield.h"

#include "emailtrace.h"

namespace // codescanner::namespace
    {
    /**
     * Vertical scroll margin
     */
    const TInt KVerticalScrollMargin = 3;

    // ---------------------------------------------------------------------------
    // IndexByFieldId
    // ---------------------------------------------------------------------------
    //
    TInt IndexByFieldId( const MESMRFieldStorage& aFactory,
                         TESMREntryFieldId aFieldId )
        {
        TInt index( KErrNotFound );
        TInt count( aFactory.Count() );
        
        for ( TInt i = 0; i < count; ++i )
            {
            if ( aFactory.Field( i )->FieldId() == aFieldId )
                {
                index = i;
                break;
                }
            }
        
        return index;
        }
    }

//----- MEMBER FUNCTIONS ----

// ---------------------------------------------------------------------------
// CMRListPane::NewL
// ---------------------------------------------------------------------------
//
CMRListPane* CMRListPane::NewL( const CCoeControl& aParent,
                                MESMRFieldStorage& aFactory,
                                TAknDoubleSpanScrollBarModel& aScrollModel )
    {
    CMRListPane* self = new (ELeave) CMRListPane( aFactory, aScrollModel );
    CleanupStack::PushL( self );
    self->ConstructL( aParent );
    CleanupStack::Pop( self );
    return self;
    }

// ---------------------------------------------------------------------------
// CMRListPane::~CMRListPane
// ---------------------------------------------------------------------------
//
CMRListPane::~CMRListPane()
    {
    }

// ---------------------------------------------------------------------------
// CMRListPane::CMRListPane
// ---------------------------------------------------------------------------
//
CMRListPane::CMRListPane( MESMRFieldStorage& aFactory,
                          TAknDoubleSpanScrollBarModel& aScrollModel )
    : iFactory( aFactory ),
      iScrollModel( aScrollModel )
    {
    }

// ---------------------------------------------------------------------------
// CMRListPane::ConstructL
// ---------------------------------------------------------------------------
//
void CMRListPane::ConstructL( const CCoeControl& aParent )
    {
    SetContainerWindowL( aParent );
    TBool focusSet = EFalse;
    const TInt count( iFactory.Count() );
    for ( TInt i = 0; i < count; i++ )
        {
        iFactory.Field(i)->SetContainerWindowL( *this );
        }

    for ( TInt i = 0; i < count; i++ )
        {
        CESMRField* field = iFactory.Field( i );
        
        // Initialize field
        field->InitializeL();
        User::LeaveIfError( field->SetParent( this ) );

        if ( !focusSet
             && field->IsVisible()
             && !field->IsNonFocusing())
            {
            field->SetOutlineFocusL( ETrue );
            focusSet = ETrue;
            iFocus = i;
            }
        }    
    }

// ---------------------------------------------------------------------------
// CMRListPane::FocusedItem
// ---------------------------------------------------------------------------
//
CESMRField* CMRListPane::FocusedItem() const
    {
    FUNC_LOG;
    CESMRField* field = NULL;
    if ( iFactory.Count() > 0 )
        {
        field = iFactory.Field( iFocus );
        }
    return field;
    }
        
// ---------------------------------------------------------------------------
// CMRListPane::CountComponentControls
// ---------------------------------------------------------------------------
//
TInt CMRListPane::CountComponentControls() const
    {
    return iFactory.Count();
    }

// ---------------------------------------------------------------------------
// CMRListPane::ComponentControl
// ---------------------------------------------------------------------------
//
CCoeControl* CMRListPane::ComponentControl( TInt aIndex ) const
    {
    return iFactory.Field( aIndex );
    }

// ---------------------------------------------------------------------------
// CMRListPane::SizeChanged
// ---------------------------------------------------------------------------
//
void CMRListPane::SizeChanged()
    {
    TPoint tl( Position() );
    TInt scrollSpan = 0;
    // Loop all the visible fields and set size and position in the list
    TBool topVisibleFound( EFalse );
    
    const TInt count( iFactory.Count() );
    for ( TInt i = 0; i < count; i++ )
        {
        CESMRField* field = iFactory.Field( i );

        if ( field->IsVisible() )
            {
            LayoutField( *field, tl );
            
            if ( !topVisibleFound )
                {
                iTopVisibleIndex = i;
                topVisibleFound = ETrue;
                }

            TInt height = field->Size().iHeight;
            tl.iY += height;
            scrollSpan += height;
            }
        }
    
    iScrollModel.SetScrollSpan( scrollSpan );
    iScrollModel.SetWindowSize( iSize.iHeight );
    UpdateFocusPosition();
    }

// ---------------------------------------------------------------------------
// CMRListPane::OfferKeyEventL
// ---------------------------------------------------------------------------
//
TKeyResponse CMRListPane::OfferKeyEventL( const TKeyEvent &aKeyEvent,
                                          TEventCode aType )
    {
    TKeyResponse response( EKeyWasNotConsumed );
    
    // If we have at least one item in the list
    if ( iFocus < iFactory.Count() )
        {
        CESMRField* field = iFactory.Field( iFocus );
        // First check if the focused item needs the key event
        response = field->OfferKeyEventL( aKeyEvent, aType );

        if ( aType == EEventKey
             && response == EKeyWasNotConsumed )
            {
            // Check if the focus should be changed
            switch ( aKeyEvent.iScanCode )
                {
                case EStdKeyUpArrow:
                    {
                    response = MoveFocusUpL();
                    break;
                    }
                case EStdKeyDownArrow:
                    {
                    response = MoveFocusDownL();
                    break;
                    }
                default:
                    {
                    break;
                    }
                }
            }
        }
    return response;
    }

// ---------------------------------------------------------------------------
// CMRListPane::ControlSizeChanged
// ---------------------------------------------------------------------------
//
void CMRListPane::ControlSizeChanged( CESMRField* aCtrl )
    {
    if ( !aCtrl )
        {
        SizeChanged();
        }
    else
        {
        TPoint tl( aCtrl->Position() );
        TInt index = IndexByFieldId( iFactory, aCtrl->FieldId() );
        
        // Relayout aCtrl
        TSize old( aCtrl->Size() );
        TSize size( aCtrl->MinimumSize() );
        if ( aCtrl->IsExpandable() )
            {
            size.iHeight = aCtrl->ExpandedHeight();
            }
        aCtrl->SetSize( size );
        iScrollModel.SetScrollSpan( iScrollModel.ScrollSpan()
                                    + size.iHeight - old.iHeight );
        
        // Move other fields
        ++index;
        tl.iY += size.iHeight;
        MoveFields( index, tl );
        UpdateFocusPosition();
        }
    }

// ---------------------------------------------------------------------------
// CMRListPane::InsertControl
// ---------------------------------------------------------------------------
//
void CMRListPane::InsertControl( TESMREntryFieldId aField )
    {
    CESMRField* field = iFactory.FieldById( aField );
    
    if ( field && !field->IsVisible() )
        {
        // Make field visible 
        field->MakeVisible( ETrue );
        TInt index = IndexByFieldId( iFactory, aField );
        if ( index < iTopVisibleIndex )
            {
            iTopVisibleIndex = index;
            }
        
        TPoint tl( Rect().iTl );
        TInt prevIndex = index - 1;
        
        // Get previous visible field position
        if ( prevIndex >= 0 )
            {
            CESMRField* previous = NULL;
            do
                {
                previous = iFactory.Field( prevIndex-- );
                }
            while ( prevIndex >= 0 && !previous->IsVisible() );
            
            tl.iY = previous->Rect().iBr.iY;
            }
        
        // Layout field
        LayoutField( *field, tl );
        iScrollModel.SetScrollSpan( iScrollModel.ScrollSpan()
                                    + field->Size().iHeight );
        
        // Move following fields
        tl.iY += field->Size().iHeight;
        MoveFields( ++index, tl );
        UpdateFocusPosition();
        }
    }

// ---------------------------------------------------------------------------
// CMRListPane::InsertControl
// ---------------------------------------------------------------------------
//
void CMRListPane::RemoveControl( TESMREntryFieldId aField )
    {
    CESMRField* field = iFactory.FieldById( aField );
        
    if ( field && field->IsVisible() )
        {
        field->MakeVisible( EFalse );
        iScrollModel.SetScrollSpan( iScrollModel.ScrollSpan() - field->Size().iHeight );
        TInt index = IndexByFieldId( iFactory, aField );
        TBool focused = ( index == iFocus )? ETrue : EFalse;
        
        if ( index == iTopVisibleIndex )
            {
            // Find next
            TInt count( iFactory.Count() );
            while ( index < count )
                {
                if ( iFactory.Field( ++index )->IsVisible() )
                    {
                    iTopVisibleIndex = index;
                    break;
                    }
                }
            }
        else
            {
            ++index;
            }
        TPoint pos( field->Position() );
        MoveFields( index, pos );
        if ( focused && !field->IsNonFocusing() )
            {
            TRAP_IGNORE( DoSetFocusL( index ) )
            }
        UpdateFocusPosition();
        }
    }

// ---------------------------------------------------------------------------
// CMRListPane::IsControlVisible
// ---------------------------------------------------------------------------
//
TBool CMRListPane::IsControlVisible( TESMREntryFieldId aField )
    {
    TBool visible( EFalse );
    CESMRField* field = iFactory.FieldById( aField );
    
    if ( field )
        {
        visible = field->IsVisible();
        }
    
    return visible;
    }

// ---------------------------------------------------------------------------
// CMRListPane::SetControlFocusedL
// ---------------------------------------------------------------------------
//
void CMRListPane::SetControlFocusedL( TESMREntryFieldId aField )
    {
    TInt count = iFactory.Count();
    for ( TInt i(0); i < count; i++ )
        {
        CESMRField* field = iFactory.Field(i);
        
        if ( field->FieldId() == aField )
            {
            if( field->IsVisible() && !field->IsNonFocusing() )
                {
                // Remove current focus before setting new one
                CESMRField* focusedField = FocusedItem();
                ASSERT( focusedField );
                focusedField->SetOutlineFocusL( EFalse );

                // Set new focus
                field->SetOutlineFocusL( ETrue );
                iFocus = i;
                break;
                }
            else
                {
                // Not possible to set focus to non-visible control
                User::Leave( KErrGeneral );
                }
            }
        }
    }

// SCROLLING_MOD: These two methods are for CESMRRichTextViewer to 
// be able to control view area
// ---------------------------------------------------------------------------
// CMRListPane::MoveListAreaDownL
// ---------------------------------------------------------------------------
//
void CMRListPane::MoveListAreaDownL( TInt aAmount )
    {
    FUNC_LOG;
    // Method for CESMRRichTextViewer for moving view area down if the text in
    // text field does not fit on the screen.

    // Fetch the position info about the first visible field in field set:
    CESMRField* field;
    if( iTopVisibleIndex != KErrNotFound )
        {
        field = iFactory.Field( iTopVisibleIndex );
        }
    else
        {
        field = iFactory.Field( iFactory.Count() - 1 );
        }
    TRect rect( field->Rect() );

    // check whether the first field is visible, if not, let's
    // check should we scroll less than needed to get the first
    // field shown.
    if ( rect.iTl.iY + aAmount > Rect().iTl.iY )
        {
        aAmount = Rect().iTl.iY - rect.iTl.iY + KVerticalScrollMargin;
        }
    else if ( rect.iTl.iY == Rect().iTl.iY )
        {
        // field already visible, do not scroll.
        aAmount = 0;
        }

    // Do the view scrolling if needed:
    if ( aAmount )
        {
        ScrollItemsDown( aAmount );
        UpdateFocusPosition();
        //UpdateScrollBar();
        DrawDeferred();
        }
    }

// ---------------------------------------------------------------------------
// CMRListPane::MoveListAreaUpL
// ---------------------------------------------------------------------------
//
void CMRListPane::MoveListAreaUpL( TInt aAmount )
    {
    FUNC_LOG;
    // Fetch the position information about currently focused field:
    CESMRField* field = iFactory.Field( iFocus );
    TRect rect( field->Rect() );

    // check whether the scroll pixels should be less than normal
    // scroll sequence to let the field bottom to be placed at
    // the bottom of view rect.
    if ( rect.iBr.iY - aAmount < Rect().iBr.iY )
        {
        aAmount = rect.iBr.iY - Rect().iBr.iY + KVerticalScrollMargin;
        }
    else if ( rect.iBr.iY + aAmount == Rect().iBr.iY )
        {
        // field already visible, do not scroll.
        aAmount = 0;
        }

    // do the scrolling if needed:
    if ( aAmount > 0 )
        {
        // if the focus is on last
        ScrollItemsUp( aAmount );
        UpdateFocusPosition();
        //UpdateScrollBar();
        DrawDeferred();
        }
    }

// ---------------------------------------------------------------------------
// CMRListPane::ListHeight
// ---------------------------------------------------------------------------
//
TInt CMRListPane::ListHeight()
    {
    FUNC_LOG;
    return iSize.iHeight;
    }

// ---------------------------------------------------------------------------
// CMRListPane::IsFieldBottomVisible
// ---------------------------------------------------------------------------
//
TBool CMRListPane::IsFieldBottomVisible()
    {
    // Fetch the position information about currently focused field:
    CESMRField* field = iFactory.Field( iFocus );
    TBool ret( EFalse );
    if ( field->Rect().iBr.iY <= Rect().iBr.iY )
       {
       ret = ETrue;
       }

    return ret;
    }

// ---------------------------------------------------------------------------
// CMRListPane::MoveFocusUpL
// ---------------------------------------------------------------------------
//
TKeyResponse CMRListPane::MoveFocusUpL()
    {
    TInt ind( iFocus );
    
    // search next visible focus item
    while ( ind > 0 )
        {
        CESMRField* field = iFactory.Field( --ind );

        if ( !field->IsNonFocusing() )
            {
            field = iFactory.Field( ind );

            CESMRField* focusedField = iFactory.Field( iFocus );
            if ( field->IsVisible() )
                {
                TBool canLoseFocus( 
                        focusedField->OkToLoseFocusL( field->FieldId() ) );

                if ( canLoseFocus )
                    {
                    iFocus = ind;
                                        
                    // update focus index and scroll the item visible
                    focusedField->SetOutlineFocusL( EFalse );
                    // This call changes the text color of previously 
                    // focused field
                    focusedField->SetFocus( EFalse );
                    field->SetOutlineFocusL( ETrue );
                    // This call changes the text color of focused field
                    field->SetFocus( ETrue );

                    ScrollItemVisible( iFocus );
                    }
                return EKeyWasConsumed;
                }
            }
        }
    return EKeyWasNotConsumed;
    }

// ---------------------------------------------------------------------------
// CMRListPane::MoveFocusDownL
// ---------------------------------------------------------------------------
//
TKeyResponse CMRListPane::MoveFocusDownL()
    {
    TInt ind( iFocus );

    // start searching next possible focus item
    TInt maxItemIndex = iFactory.Count() - 1;
    
    while ( ind < maxItemIndex )
        {
        // only visible and focusable items can be focused
        CESMRField* field = iFactory.Field( ++ind );

        if ( field->IsVisible() && !field->IsNonFocusing() )
            {
            CESMRField* focusedField = iFactory.Field( iFocus );
                    
            TBool canLoseFocus( 
                    focusedField->OkToLoseFocusL( field->FieldId() ) );

            // check it its ok for the old focus item to lose focus
            if ( canLoseFocus )
                {
                iFocus = ind;
                                
                // update focus index and scroll the item visible
                focusedField->SetOutlineFocusL( EFalse );
                // This call changes the text color of previously 
                // focused field
                focusedField->SetFocus( EFalse );
                field->SetOutlineFocusL( ETrue );
                // This call changes the text color of focused field
                field->SetFocus( ETrue );

                ScrollItemVisible( iFocus );
                }
            return EKeyWasConsumed;
            }
        }
    return EKeyWasNotConsumed;
    }

// ---------------------------------------------------------------------------
// CMRListPane::MoveFocusL
// ---------------------------------------------------------------------------
//
TBool CMRListPane::MoveFocusL(TInt aNextFieldIndex)
    {
    // start searching next possible focus item
    TInt maxItemIndex = iFactory.Count() - 1;

    CESMRField* focusedField = iFactory.Field( iFocus );
    
    // only visible and focusable items can be focused
    CESMRField* field = iFactory.Field( aNextFieldIndex );

    if ( field->IsVisible() && !field->IsNonFocusing() )
        {
        TBool canLoseFocus( 
                focusedField->OkToLoseFocusL( field->FieldId() ) );

        // check it its ok for the old focus item to lose focus
        if ( canLoseFocus )
            {
            // tactile feedback if touch 
            if ( AknLayoutUtils::PenEnabled() )
                {
                MTouchFeedback* feedback = MTouchFeedback::Instance();
                if ( feedback )
                    {
                    feedback->InstantFeedback( this, ETouchFeedbackBasic );
                    }
                }
            
            iFocus = aNextFieldIndex;
                            
            // update focus index and scroll the item visible
            focusedField->SetOutlineFocusL( EFalse );
            // This call changes the text color of previously 
            // focused field
            focusedField->SetFocus( EFalse );
            field->SetOutlineFocusL( ETrue );
            // This call changes the text color of focused field
            field->SetFocus( ETrue );
            DrawDeferred();
            }
        return ETrue; // operation succeed
        }
    return EFalse;
    }

// ---------------------------------------------------------------------------
// CMRListPane::LayoutField
// ---------------------------------------------------------------------------
//
void CMRListPane::LayoutField( CESMRField& aField,
                               const TPoint& aTl )
    {
    TSize size( aField.MinimumSize() );
    if ( aField.IsExpandable() )
        {
        size.iHeight = aField.ExpandedHeight();
        }
    aField.SetPosition( aTl );
    aField.SetSize( size );
    }

// ---------------------------------------------------------------------------
// CMRListPane::MoveFields
// ---------------------------------------------------------------------------
//
void CMRListPane::MoveFields( TInt aIndex,
                              TPoint& aTl )
    {
    const TInt count( iFactory.Count() );
    
    for ( TInt i = aIndex; i < count; ++i )
        {
        CESMRField* field = iFactory.Field( i );

        if ( field->IsVisible() )
            {
            field->SetPosition( aTl );
            
            aTl.iY += field->Size().iHeight;
            }
        }
    }

// ---------------------------------------------------------------------------
// CMRListPane::DoSetFocusL
// ---------------------------------------------------------------------------
//
void CMRListPane::DoSetFocusL( TInt aFocus )
    {
    TInt count( iFactory.Count() );
    aFocus = Max( 0, Min( aFocus, count - 1 ) );
    
    if ( aFocus != iFocus )
        {
        // Get current focused field
        CESMRField* old = iFactory.Field( iFocus );
        
        // Get next focused field
        CESMRField* field = iFactory.Field( aFocus );
        while ( aFocus < count && !field->IsVisible() )
            {
            field = iFactory.Field( aFocus++ );
            }
        
        if ( !field->IsVisible() )
            {
            aFocus = iFocus - 1;
            while ( aFocus > 0 && !field->IsVisible() )
                {
                field = iFactory.Field( aFocus-- );
                }
            }
        
        ASSERT( field->IsVisible() );
        
        // Remove focus from old
        iFocus = aFocus;
        // update focus index and scroll the item visible
        old->SetOutlineFocusL( EFalse );
        // Change the text color of previously focused field
        old->SetFocus( EFalse );
        field->SetOutlineFocusL( ETrue );
        // This call changes the text color of focused field
        field->SetFocus( ETrue );
        }
    }

// ---------------------------------------------------------------------------
// CMRListPane::ScrollItemVisible
// ---------------------------------------------------------------------------
//
void CMRListPane::ScrollItemVisible( TInt aInd )
    {
    FUNC_LOG;
    CESMRField* field = NULL;
    if ( aInd == KErrNotFound )
        {
        field = FocusedItem();
        }
    else
        {
        field = iFactory.Field( aInd );
        }

    ASSERT( field );

    TRect rect( field->Rect() );

    // move all items upwards
    TInt bottomRightY = Rect().iBr.iY;


    TInt fieldUpper(0);
    TInt fieldLower(0);
    field->GetMinimumVisibleVerticalArea( fieldUpper, fieldLower );

    // desired position below view rect:
    if ( rect.iTl.iY + fieldLower > Rect().iBr.iY )
        {
        // field rect Y position related to view rect:
        TInt fieldRelYPos = rect.iTl.iY - Size().iHeight;
        TInt px = fieldRelYPos + fieldLower;

        // if focus on first or last field: add margin height to
        // scroll amount.
        if ( iFocus == 0 || iFocus == iFactory.Count()-1 )
            {
            px += 2 * KVerticalScrollMargin;
            }

        ScrollItemsUp( px );
        }

    // move all items downwards.
    TInt topLeftY = Rect().iTl.iY;

    if ( rect.iBr.iY - (rect.Height() - fieldUpper ) < topLeftY )
        {
        TInt fieldRelYPos = topLeftY - rect.iBr.iY;
        TInt px = fieldRelYPos + ( rect.Height() - fieldUpper);

        // if focus on first or last field: add margin height to
        // scroll amount.
        if ( iFocus == 0 ||  iFocus == iFactory.Count()-1 )
            {
            px += KVerticalScrollMargin;
            }

        ScrollItemsDown( px );
        }

    UpdateFocusPosition();//UpdateScrollBar();
    DrawDeferred();
    }

// ---------------------------------------------------------------------------
// CMRListPane::UpdateScrollBar
// ---------------------------------------------------------------------------
//
void CMRListPane::UpdateScrollBar()
    {
    FUNC_LOG;
    // Scroll span is the size of the scrolled list,
    // including the items that doesn't fit in the screen
    TInt spanSize( 0 );
    TInt hidden( 0 );
    const TInt count(iFactory.Count());
    for ( TInt i(0); i < count; i++ )
        {
        CESMRField* field = iFactory.Field( i );
        if ( field->IsVisible() )
            {
            TRect rect( field->Rect() );
            spanSize += rect.Height();
            // Check if the field's top Y-position is hidden.
            if ( rect.iTl.iY  < 0 )
                {
                // whole field is hidden
                if ( rect.iBr.iY < 0 )
                    {
                    hidden += rect.Height();
                    }
                // partly hidden:
                else
                    {
                    hidden += Abs( rect.iTl.iY );
                    }
                }
            }
        }

    iScrollModel.SetScrollSpan( spanSize );
    iScrollModel.SetWindowSize( iSize.iHeight );
    iScrollModel.SetFocusPosition( hidden );

    }

// ---------------------------------------------------------------------------
// CMRListPane::ScrollItemsUp
// ---------------------------------------------------------------------------
//
void CMRListPane::ScrollItemsUp( TInt aPx )
    {
    FUNC_LOG;
    TInt count( iFactory.Count() );
    for ( TInt i = 0; i < count; ++i )
        {
        CESMRField* field = iFactory.Field(i);
        if ( field->IsVisible() )
            {
            TPoint pos( field->Position() );
            pos.iY -= aPx;
            if ( i == iTopVisibleIndex && pos.iY < 0 )
                {
                iTopVisibleIndex = KErrNotFound;
                }
            else if ( iTopVisibleIndex == KErrNotFound && pos.iY >= 0 )
                {
                iTopVisibleIndex = i;
                }
            field->SetPosition( pos );
            }
        }
    }

// ---------------------------------------------------------------------------
// CMRListPane::ScrollItemsDown
// ---------------------------------------------------------------------------
//
void CMRListPane::ScrollItemsDown( TInt aPx )
    {
    FUNC_LOG;
    TInt count( iFactory.Count() );
    for ( TInt i = 0; i < count; ++i )
        {
        CESMRField* field = iFactory.Field( i );
        if ( field->IsVisible() )
            {
            TPoint pos( field->Position() );
            pos.iY += aPx;
            if ( pos.iY >= 0 && ( i < iTopVisibleIndex || iTopVisibleIndex == KErrNotFound ) )
                {
                iTopVisibleIndex = i;
                }
            field->SetPosition( pos );
            }
        }
    }

// ---------------------------------------------------------------------------
// CMRListPane::ScrollView
// ---------------------------------------------------------------------------
//
void CMRListPane::ScrollView( TInt aAmount )
    {
    FUNC_LOG;
    
    if ( aAmount > 0 )
        {
        // move list up
        ScrollItemsUp( aAmount );
        UpdateFocusPosition();
        DrawDeferred();
        }
    else if ( aAmount < 0 )
        {
        // move list down
        ScrollItemsDown( -aAmount );
        UpdateFocusPosition();
        DrawDeferred();
        }
    }


// ---------------------------------------------------------------------------
// CMRListPane::UpdateFocusPosition
// ---------------------------------------------------------------------------
//
void CMRListPane::UpdateFocusPosition()
    {
    TInt focusPos = 0;
    TInt count = iFactory.Count();
    for ( TInt i = 0; i < count; ++i )
        {
        CESMRField* field = iFactory.Field( i );
        if ( field->IsVisible() )
            {
            TRect rect( field->Rect() );
            // Check if the field's top is above scroll area origo.
            if ( rect.iTl.iY  < 0 )
                {
                // Whole field is above origo
                if ( rect.iBr.iY < 0 )
                    {
                    focusPos += rect.Height();
                    }
                // Part of the field is above origo
                else
                    {
                    focusPos += Abs( rect.iTl.iY );
                    }
                }
            else
                {
                // Rest of the fields are below scroll area origo
                break;
                }
            }
        }
    
    iScrollModel.SetFocusPosition( focusPos );
    }


// -----------------------------------------------------------------------------
// CMRListPane::GetViewCenterPosition
// -----------------------------------------------------------------------------
//
TPoint CMRListPane::GetViewCenterPosition() const
    {
    const TInt count( iFactory.Count() );
    TInt topFieldYPos( 0 );
    for ( TInt i = 0; i < count; i++ )
        {
        CESMRField* field = iFactory.Field( i );

        if ( field->IsVisible() )
            {
            topFieldYPos = field->Position().iY;    
            break;
            }
        }
    TInt centerX = iSize.iWidth / 2;
    TInt visibleHeight = iSize.iHeight;

    TInt centerY = visibleHeight / 2 - topFieldYPos;
    
    
    return TPoint( centerX, centerY );
    }


// -----------------------------------------------------------------------------
// CMRListPane::HandlePointerEventL
// -----------------------------------------------------------------------------
//
void CMRListPane::HandlePointerEventL( const TPointerEvent& aPointerEvent )
    {
    if ( aPointerEvent.iType == TPointerEvent::EButton1Down )
        {
        TInt count = iFactory.Count();
        for ( TInt i = 0; i < count; ++i )
            {
            CESMRField* field = static_cast<CESMRField*>(iFactory.Field( i ) );
            TRect r = field->Rect();
            TBool tapped = field->Rect().Contains( aPointerEvent.iPosition );
            if (tapped && field->IsVisible() && !field->IsFocused() )
                {
                MoveFocusL( i );
                break;
                }
            }
        }
    // here some fields can further adjust their state (for example, CESMRResponseField has sub-fields) 
    CCoeControl::HandlePointerEventL(aPointerEvent);
    }
// End of file