/*

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