/*

* Copyright (c) 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:  Field container for UI fields

*

*/

#include "cmrfieldcontainer.h"

#include "mesmrfieldstorage.h"

#include "mmrfieldcontainerobserver.h"

#include "cesmrfield.h"

//DEBUG

#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 ----

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

// CMRFieldContainer::CMRFieldContainer

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

//

CMRFieldContainer::CMRFieldContainer( MESMRFieldStorage& aFactory )

    : iFactory( aFactory )

    {

    FUNC_LOG;

    }

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

// CMRFieldContainer::~CMRFieldContainer

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

//

CMRFieldContainer::~CMRFieldContainer()

    {

    FUNC_LOG;

    // No implementation

    }

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

// CMRFieldContainer::NewL

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

//

CMRFieldContainer* CMRFieldContainer::NewL( 

        MESMRFieldStorage& aFactory, 

        const CCoeControl& aParent )

    {

    FUNC_LOG;

    CMRFieldContainer* self = new( ELeave )CMRFieldContainer( aFactory );

    CleanupStack::PushL( self );

    self->ConstructL( aParent );

    CleanupStack::Pop( self );

    return self;

    }

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

// CMRFieldContainer::ConstructL

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

//

void CMRFieldContainer::ConstructL( const CCoeControl& aParent )

    {

    FUNC_LOG;

    CCoeControl::SetComponentsToInheritVisibility( ETrue );

    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;

            iFocusedFieldIndex = i;

            }

        }

    for ( TInt i = 0; i < count; i++ )

        {

        CESMRField* field = iFactory.Field( i );

        field->SetListObserver( this );

        }

    }

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

// CMRFieldContainer::FocusedItem

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

//

CESMRField* CMRFieldContainer::FocusedField() const

    {

    FUNC_LOG;

    /*

     * Returns currently focused field

     */

    CESMRField* field = NULL;

    if ( iFactory.Count() > 0 )

        {

        field = iFactory.Field( iFocusedFieldIndex );

        }

    return field;

    }

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

// CMRFieldContainer::MoveFocusUpL

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

//

TKeyResponse CMRFieldContainer::MoveFocusUpL( TBool aHiddenFocus )

    {

    FUNC_LOG;

    /*

     * Moves focus up after key event. If aHiddenFocus, moves focus 

     * to the first visible field in the bottom of the viewable area.

     */

    if( aHiddenFocus )

        {

        return MoveFocusVisibleL();

        }

    else

        {

        TInt ind( iFocusedFieldIndex );

        // search next visible focus item

        while ( ind > 0 )

            {

            CESMRField* field = iFactory.Field( --ind );

            if ( !field->IsNonFocusing() )

                {

                field = iFactory.Field( ind );

                CESMRField* focusedField = iFactory.Field( iFocusedFieldIndex );

                if ( field->IsVisible() )

                    {

                    TBool canLoseFocus(

                            focusedField->OkToLoseFocusL( field->FieldId() ) );

                    if ( canLoseFocus )

                        {

                        field->SetPreItemIndex( iFocusedFieldIndex );

                        iFocusedFieldIndex = ind;

                        field->SetCurrentItemIndex( iFocusedFieldIndex );

                        // Remove focus from previous position 

                        focusedField->SetOutlineFocusL( EFalse );

                        focusedField->SetFocus( EFalse );

                        // Set focus to new position

                        field->SetOutlineFocusL( ETrue );

                        field->SetFocus( ETrue );

                        // Scrollbar and physics update is done here

                        ScrollControlVisible( iFocusedFieldIndex );

                        DrawDeferred();

                        }

                    return EKeyWasConsumed;

                    }

                }

            }

        return EKeyWasNotConsumed;

        }

    }

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

// CMRFieldContainer::MoveFocusDownL

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

//

TKeyResponse CMRFieldContainer::MoveFocusDownL( TBool aHiddenFocus )

    {

    FUNC_LOG;

    /*

     * Moves focus down after key event. If aHiddenFocus, moves focus 

     * to the first visible field in the top of the viewable area.

     */

    if( aHiddenFocus )

        {

        return MoveFocusVisibleL();

        }

    else

        {

        TInt ind( iFocusedFieldIndex );

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

                TBool canLoseFocus(

                        focusedField->OkToLoseFocusL( field->FieldId() ) );

                // check it its ok for the old focus item to lose focus

                if ( canLoseFocus )

                    {

                    field->SetPreItemIndex( iFocusedFieldIndex );

                    iFocusedFieldIndex = ind;

                    field->SetCurrentItemIndex( iFocusedFieldIndex );

                    // Remove focus from previous position 

                    focusedField->SetOutlineFocusL( EFalse );

                    focusedField->SetFocus( EFalse );

                    // Set focus to new position

                    field->SetOutlineFocusL( ETrue );

                    field->SetFocus( ETrue );

                    // Scrollbar and physics update is done here

                    ScrollControlVisible( iFocusedFieldIndex );

                    DrawDeferred();

                    }

                return EKeyWasConsumed;

                }

            }

        return EKeyWasNotConsumed;

        }

    }

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

// CMRFieldContainer::MoveFocusVisibleL

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

//

TKeyResponse CMRFieldContainer::MoveFocusVisibleL()

    {

    FUNC_LOG;

    /*

     * Move focus to first completely visible field in the view, 

     * if focus was in a field that was not visible in the view.

     * Use case: After pointer scroll focus is hidden. User presses

     * arrow keys -> Focus appears to the first visible field on the upper

     * or bottom part of the viewable area.

     */

    TKeyResponse response( EKeyWasNotConsumed );

    CESMRField* focusedField = FocusedField();

    CESMRField* visibleField = NULL;

    TRect view( Parent()->Rect() );

    // Focus is above the visible view area

    if ( focusedField->Rect().iBr.iY <= view.iTl.iY )

        {

        // Move focus to next visible field

        TInt lastIndex = iFactory.Count() - 1;

        TInt ind( iFocusedFieldIndex );

        while ( ind < lastIndex && !visibleField )

            {

            visibleField = iFactory.Field( ++ind );

            TRect fieldRect = visibleField->Rect();

            if ( visibleField->IsVisible()

                 && !visibleField->IsNonFocusing()

                 && fieldRect.iTl.iY >= view.iTl.iY )

                {

                // Update previous and current field indexes

                visibleField->SetPreItemIndex( iFocusedFieldIndex );

                iFocusedFieldIndex = ind;

                visibleField->SetCurrentItemIndex( iFocusedFieldIndex );

                }

            else

                {

                visibleField = NULL;

                }

            }

        }

    // Focus is below the visible view area

    else

        {

        // Move focus to previous visible field

        TInt ind( iFocusedFieldIndex );

        while ( ind > 0 && !visibleField )

            {

            visibleField = iFactory.Field( --ind );

            TRect fieldRect = visibleField->Rect();

            if ( visibleField->IsVisible()

                 && !visibleField->IsNonFocusing()

                 && fieldRect.iBr.iY <= view.iBr.iY )

                {

                // Update previous and current field indexes

                visibleField->SetPreItemIndex( iFocusedFieldIndex );

                iFocusedFieldIndex = ind;

                visibleField->SetCurrentItemIndex( iFocusedFieldIndex );

                }

            else

                {

                visibleField = NULL;

                }

            }

        }

    if ( visibleField )

        {

        // Remove existing focus

        focusedField->SetOutlineFocusL( EFalse );

        focusedField->SetFocus( EFalse );

        // Set focus to new field

        visibleField->SetOutlineFocusL( ETrue );

        visibleField->SetFocus( ETrue );

        response = EKeyWasConsumed;

        DrawDeferred();

        }

    return response;

    }

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

// CMRFieldContainer::SetFieldContainerObserver

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

//

void CMRFieldContainer::SetFieldContainerObserver( 

        MMRFieldContainerObserver* aObserver )

    {

    FUNC_LOG;

    iObserver = aObserver;

    }

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

// CMRFieldContainer::CountComponentControls

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

//

TInt CMRFieldContainer::CountComponentControls() const

    {

    FUNC_LOG;

    return iFactory.Count();

    }

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

// CMRFieldContainer::ComponentControl

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

//

CCoeControl* CMRFieldContainer::ComponentControl( TInt aIndex ) const

    {

    FUNC_LOG;

    return iFactory.Field( aIndex );

    }

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

// CMRFieldContainer::MinimumSize

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

//

TSize CMRFieldContainer::MinimumSize()

    {

    FUNC_LOG;

    /*

     * Returns the minimum size required by the field container

     */

    TSize containerSize;

    const TInt count( iFactory.Count() );

    for ( TInt i(0); i < count; ++i )

        {

        CESMRField* field = iFactory.Field( i );

        if ( field->IsVisible() )

            {

            TRect rect( field->Rect() );

            containerSize.iHeight += rect.Height();

            }

        }

    containerSize.iWidth = Parent()->Rect().Width();

    return containerSize;

    }

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

// CMRFieldContainer::SizeChanged

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

//

void CMRFieldContainer::SizeChanged()

    {

    FUNC_LOG;

    // TEST CODE:

    TRect fieldcontainerRect = Rect();

    TRect parentRect = Parent()->Rect();

    // For example when orientation changes, we might need to scroll 

    // the currently focused control visible again. This handles also

    // scrollbar and physics updates.

    ScrollControlVisible( KErrNotFound ); 

    TPoint tl( Position() );

    const TInt count( iFactory.Count() );

    // Loop all the visible fields and set size and position in the list

    for ( TInt i = 0; i < count; i++ )

        {

        CESMRField* field = iFactory.Field( i );

        if ( field->IsVisible() )

            {

            LayoutField( *field, tl );

            TInt height = field->Size().iHeight;

            tl.iY += height;

            }

        }

    }

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

// CMRFieldContainer::ControlSizeChanged

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

//

void CMRFieldContainer::ControlSizeChanged( CESMRField* aField )

    {

    FUNC_LOG;

    /*

     * Called whenever a fields size has changed. Requires always 

     * relayouting. 

     */

    if ( !aField )

        {

        SizeChanged();

        }

    else

        {

        // Relayout field if size has changed

        TSize old( aField->Size() );

        TSize size( aField->MinimumSize() );

        if( size != old )

            {

            aField->SetSize( size );

            TPoint tl( aField->Position() );

            TInt index = IndexByFieldId( iFactory, aField->FieldId() );

            // Move fields below this particular field

            tl.iY += size.iHeight;

            MoveFields( index + 1, tl );

            // Fields have been re-layouted / moved. This requires resetting

            // the size of this field container.

            SetSize( MinimumSize() );

            // Update also scrollbar and physics

            iObserver->UpdateScrollBarAndPhysics();

            if( index == iFocusedFieldIndex )

                {

                // Scroll this field completely visible, if required.

                // This updates also scrollbar and physics if scrolling 

                // is done.

                ScrollControlVisible( iFocusedFieldIndex );

                }

            DrawDeferred();

            }

        }

    }

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

// CMRFieldContainer::ShowControl

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

//

void CMRFieldContainer::ShowControl( TESMREntryFieldId aFieldId )

    {

    FUNC_LOG;

    /*