emailuis/emailui/src/ncsheadercontainer.cpp
author Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
Wed, 13 Oct 2010 14:11:15 +0300
branchRCL_3
changeset 80 726fba06891a
parent 73 c8382f7b54ef
permissions -rw-r--r--
Revision: 201039 Kit: 201041

/*
* 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 : email header container
*
*/



#include "emailtrace.h"
#include <StringLoader.h>
#include <aknViewAppUi.h>
#include <aknnotewrappers.h> //CAknInformationNote
#include <FreestyleEmailUi.rsg>
#include <aknphysics.h>

#include "cfsmailbox.h"
#include <FreestyleEmailUi.rsg>

#include "FSEmailBuildFlags.h"
#include "ncsheadercontainer.h"
#include "ncscomposeviewcontainer.h"
#include "ncsemailaddressobject.h"
#include "ncsutility.h"
#include "FreestyleEmailUiUtilities.h"
#include "FreestyleEmailUiAppui.h"
#include "FSEmail.pan"
#include "ncsattachmentfield.h"
#include "ncssubjectfield.h"
#include "ncspopuplistbox.h"

_LIT( KAddressDelimeterSemiColon, ";" );


// ---------------------------------------------------------------------------
// ToNcsControl
// ---------------------------------------------------------------------------
//
static MNcsControl* ToNcsControl( CCoeControlArray::TCursor cur )
	{
    FUNC_LOG;
	CCoeControl* coe = cur.Control<CCoeControl>();
	return dynamic_cast<MNcsControl*>(coe);
	}

// ---------------------------------------------------------------------------
// CNcsHeaderContainer::NewL
// ---------------------------------------------------------------------------
//
CNcsHeaderContainer* CNcsHeaderContainer::NewL( CCoeControl& aParent, 
    CFSMailBox& aMailBox, TInt aFlags, CAknPhysics* aPhysics )
    {
    FUNC_LOG;
    CNcsHeaderContainer* self = 
        new ( ELeave ) CNcsHeaderContainer( aParent, aMailBox, aPhysics );
    CleanupStack::PushL( self );
    self->ConstructL( aFlags );
    CleanupStack::Pop( self );
    return self;
    }

// ---------------------------------------------------------------------------
// CNcsHeaderContainer::CNcsHeaderContainer
// ---------------------------------------------------------------------------
//
CNcsHeaderContainer::CNcsHeaderContainer(
	CCoeControl& aParent, 
	CFSMailBox& aMailBox,
	CAknPhysics* aPhysics ): 
	iParent( aParent ),
	iFieldSizeObserver( static_cast< CNcsComposeViewContainer& >( aParent ) ),
	iMailBox( aMailBox ),
	iLongTapEventConsumed( EFalse ),
    iPhysics( aPhysics )
	{
    FUNC_LOG;
	}

// ---------------------------------------------------------------------------
// CNcsHeaderContainer::ConstructL
// ---------------------------------------------------------------------------
//
void CNcsHeaderContainer::ConstructL( TInt aFlags )
	{
    FUNC_LOG;
    
	SetContainerWindowL( iParent );
    
	CFreestyleEmailUiAppUi* fsAppUi = 
        static_cast<CFreestyleEmailUiAppUi*>( ControlEnv()->AppUi() );

	// Create 'To' field
	iToField = CNcsAddressInputField::NewL( 
		R_NCS_TO_FIELD_TEXT,
		CNcsAddressInputField::EInputFieldTo,
		&iFieldSizeObserver, 
		this, this );

	// Create 'Cc' field
	iCcField = CNcsAddressInputField::NewL( 
		R_NCS_CC_FIELD_TEXT,
		CNcsAddressInputField::EInputFieldCc,
		&iFieldSizeObserver, 
		this, this );
	iCcField->MakeVisible( aFlags&ECcFieldVisible );

	// Create 'Bcc' field
	iBccField = CNcsAddressInputField::NewL( 
		R_NCS_BCC_FIELD_TEXT,
		CNcsAddressInputField::EInputFieldBcc,
		&iFieldSizeObserver, 
		this, this );
	iBccField->MakeVisible( aFlags&EBccFieldVisible );

	// Create 'subject' field
	iSubjectField = CNcsSubjectField::NewL( R_FSE_EDITOR_HEADER_SUBJECT, 
	        &iFieldSizeObserver, this );
    
    iAttachmentField = CNcsAttachmentField::NewL( R_NCS_ATTACHMENT_LABEL_TEXT, 
            &iFieldSizeObserver, this, this );

    // Setup the control array
    // Add all of them now so the container and parent is set correctly
    InitComponentArrayL();
    CCoeControlArray& controls = Components();
    controls.SetControlsOwnedExternally( ETrue );
    
    controls.AppendLC( iToField );
    CleanupStack::Pop( iToField );
    controls.AppendLC( iCcField );
    CleanupStack::Pop( iCcField );
    controls.AppendLC( iBccField );
    CleanupStack::Pop( iBccField );
    controls.AppendLC( iSubjectField );
    CleanupStack::Pop( iSubjectField );
    controls.AppendLC( iAttachmentField );
    CleanupStack::Pop( iAttachmentField );

    iToField->SetFocus( ETrue );

    if ( !(aFlags&ECcFieldVisible) )
        {
        controls.Remove( iCcField );
        }

    if ( !(aFlags&EBccFieldVisible) )
        {
        controls.Remove( iBccField );
        }

    // initially attachments field is hidden
	iAttachmentField->MakeVisible( EFalse );
	controls.Remove( iAttachmentField );

	// test whether mailbox supports remote lookup
	TBool remoteLookupSupported = 
        TFsEmailUiUtility::IsRemoteLookupSupported( iMailBox );
	
	iAacListBox = CNcsPopupListBox::NewL( 
	        this, iMailBox, *this, remoteLookupSupported );
	iAacListBox->MakeVisible( EFalse );

    iRALInProgress = EFalse;

    iToField->EnableKineticScrollingL( iPhysics );
    iCcField->EnableKineticScrollingL( iPhysics );
    iBccField->EnableKineticScrollingL( iPhysics );
    iSubjectField->EnableKineticScrollingL( iPhysics );
	}

// ---------------------------------------------------------------------------
// CNcsHeaderContainer::~CNcsHeaderContainer
// ---------------------------------------------------------------------------
CNcsHeaderContainer::~CNcsHeaderContainer()
	{
    FUNC_LOG;
	delete iToField;
	delete iCcField;
	delete iBccField;
	delete iSubjectField;
    delete iAttachmentField;
	delete iAacListBox;
	delete iLongTapDetector;
	}

// ---------------------------------------------------------------------------
// CNcsHeaderContainer::FocusChanged
// ---------------------------------------------------------------------------
//
void CNcsHeaderContainer::FocusChanged( TDrawNow aDrawNow )
    {
    FUNC_LOG;

    CCoeControl* focused = iFocused;

    if ( !focused )
        {
        focused = FindFocused();
        iFocused = focused;
        }

    if ( !IsFocused() )
        {
        if ( focused )
            {
            // We're loosing focus (probably going to message body)
            // Commit changes and make sure no controls are focused.
            if ( iParent.IsFocused() )
                {
                TRAP_IGNORE( CommitFieldL( focused ) );
                }
            focused->SetFocus( EFalse, aDrawNow );
            }

        // Remove MSK label when header loses focus
        TRAP_IGNORE( SetMskL() );
        }
    else
        {
        if ( !focused )
            {
            // We're gaining focus from the message body
            // Set the focus to the last control in the control array
            // (either attachment line or subject field)
            CCoeControlArray::TCursor cur = Components().End();
            cur.Prev();
            iFocused = cur.Control<CCoeControl>();
            }
        iFocused->SetFocus( ETrue, aDrawNow );
        }
    }

// ---------------------------------------------------------------------------
// CNcsHeaderContainer::ShowCursor
// ---------------------------------------------------------------------------
//
void CNcsHeaderContainer::ShowCursor( TBool aShow, TDrawNow aDrawNow )
    {
    CCoeControl* focused = FindFocused();
    if ( focused )
        {
        iFocused = focused;
        }
    if ( iFocused ) 
        {
        iFocused->SetFocus( aShow, aDrawNow );
        }
    }

// -----------------------------------------------------------------------------
// CNcsHeaderContainer::Draw() const
// Draws the display
// -----------------------------------------------------------------------------
void CNcsHeaderContainer::Draw( const TRect& /*aRect*/ ) const
	{
    FUNC_LOG;
	}

// -----------------------------------------------------------------------------
// CNcsHeaderContainer::HandleControlArrayEventL()
// Handles removal or additons of controls to the header.
// -----------------------------------------------------------------------------
void CNcsHeaderContainer::HandleControlArrayEventL(
	CCoeControlArray::TEvent aEvent,
	const CCoeControlArray* /*aArray*/,
	CCoeControl* aControl,
	TInt /*aControlId*/ )
	{
    FUNC_LOG;
	if ( aEvent == CCoeControlArray::EControlAdded ) 
		{
		aControl->SetContainerWindowL( iParent );
		aControl->MakeVisible( ETrue );
		aControl->ActivateL();
		}
	else if ( aEvent == CCoeControlArray::EControlRemoved )
		{
		aControl->MakeVisible( EFalse );
		}
	// Tell the parent to recalculate everything
	iFieldSizeObserver.UpdateFieldPosition( NULL );
	}

void CNcsHeaderContainer::SetMskL()
    {
    FUNC_LOG;

    // msk change disabled - probably some dialog/popup is visible
    if( iSwitchChangeMskOff )
        {
        return;
        }

    CCoeControl* focused = FindFocused();
    if ( focused == iToField || focused == iCcField || focused == iBccField )
        {
        ChangeMskCommandL( R_FSE_QTN_MSK_ADD );
        }
    else if ( focused == iAttachmentField ) 
        {
        if ( GetAttachmentCount() > 1 )
            {
            ChangeMskCommandL( R_FSE_QTN_MSK_VIEWATTACHMENTS );
            }
        else if ( !HasRemoteAttachments() )
            {
            ChangeMskCommandL( R_FSE_QTN_MSK_VIEWATTACHMENT );
            }
        else // message has single remote attachment => no MSK function
            {
            ChangeMskCommandL( R_FSE_QTN_MSK_EMPTY );
            }
        }
    else if ( focused == iSubjectField )
        {
        ChangeMskCommandL( R_FSE_QTN_MSK_EMPTY );
        }
    else 
        {
        ChangeMskCommandL( R_FSE_QTN_MSK_BODY_MENU );
        }
    }  

// -----------------------------------------------------------------------------
// CNcsHeaderContainer::HandlePointerEventL()
// 
// -----------------------------------------------------------------------------
void CNcsHeaderContainer::HandlePointerEventL( 
        const TPointerEvent& aPointerEvent )
    {
    FUNC_LOG;
    if ( aPointerEvent.iType == TPointerEvent::EButton1Up )
        {
        CCoeControl* clicked = 0;
        for ( TInt i=0; i < Components().Count(); ++i )
            {
            TRect rc = Components().At( i ).iControl->Rect();
            if ( rc.Contains( aPointerEvent.iPosition ) )
                {
                clicked = Components().At( i ).iControl;
                }
            }

        if ( clicked )
            {
            CCoeControl* pOldCtrl = FindFocused();
            CCoeControl* pNewCtrl= clicked;

            if ( pOldCtrl != pNewCtrl )
                {
                // Unfocus the control
                if ( pOldCtrl )
                    {
                    pOldCtrl->SetFocus( EFalse, ENoDrawNow );
                    }
                pNewCtrl->SetFocus( ETrue, ENoDrawNow );
                iFocused = pNewCtrl;
                // Commit changes to previously focused field.
                if ( pOldCtrl )
                    {
                    CommitFieldL( pOldCtrl );
                    }

                CNcsComposeViewContainer* container = 
                    static_cast<CNcsComposeViewContainer*>( &iParent );
                container->UpdateScrollBar();
                }

            if ( iLongTapEventConsumed )
                {
                iLongTapEventConsumed = EFalse;
                return;
                }

            TBool physicsActionOngoing( EFalse );
            if ( iPhysics && iPhysics->OngoingPhysicsAction() != CAknPhysics::EAknPhysicsActionNone )
                {
                physicsActionOngoing = ETrue;
            }

            if( pNewCtrl == iAttachmentField && !physicsActionOngoing )
                {
                CNcsComposeViewContainer& parent = 
                    static_cast<CNcsComposeViewContainer&>( iParent );
                parent.HandleAttachmentOpenCommandL();
                }
            }
        }

    CCoeControl::HandlePointerEventL( aPointerEvent );
    }

// -----------------------------------------------------------------------------
// CNcsHeaderContainer::HandleLongTapL()
// 
// -----------------------------------------------------------------------------
void CNcsHeaderContainer::HandleLongTap( const TPoint& aPenEventLocation, 
										  const TPoint& aPenEventScreenLocation )
    {
	FUNC_LOG;
	iLongTapEventConsumed = EFalse;
	
    CCoeControl* control = FindFocused();
    TRect rect = iAttachmentField->Rect();
    	if( iAttachmentField->IsVisible() && 
    	    rect.Contains( aPenEventLocation ) )
        {
        iLongTapEventConsumed = ETrue;
        
        CNcsComposeViewContainer& parent = 
            static_cast<CNcsComposeViewContainer&>( iParent );
        parent.LaunchStylusPopupMenu( aPenEventScreenLocation );
        }
    }

// -----------------------------------------------------------------------------
// CNcsHeaderContainer::NeedsLongTapL()
// Whether long tap detection is needed or not (depends on whether touch 
// location is within attachment field or not)
// -----------------------------------------------------------------------------
TBool CNcsHeaderContainer::NeedsLongTapL( const TPoint& aPenEventLocation )
    {
	FUNC_LOG;

    TRect rect = iAttachmentField->Rect();
    TBool result( EFalse );
	if( iAttachmentField->IsVisible() && rect.Contains( aPenEventLocation ) &&
	    KNoAttachmentLabelFocused !=
            iAttachmentField->FocusedAttachmentLabelIndex() )
        {
        result = ETrue;
        }
    return result;    
    }

// -----------------------------------------------------------------------------
// CNcsHeaderContainer::OfferKeyEventL()
// Handles key events
// -----------------------------------------------------------------------------
TKeyResponse CNcsHeaderContainer::OfferKeyEventL( 
        const TKeyEvent& aKeyEvent, TEventCode aType )
    {
    FUNC_LOG;
    TKeyResponse ret( EKeyWasNotConsumed );
    TBool doScroll( EFalse );
    CCoeControl* focused = FindFocused();

    if ( aKeyEvent.iCode == EKeyUpArrow || 
         aKeyEvent.iCode == EKeyDownArrow )
        {
        if ( iAacListBox && iAacListBox->IsVisible() && 
             !iAacListBox->IsPopupEmpty() )
            {
           	return iAacListBox->OfferKeyEventL( aKeyEvent, aType );
            }
        else if ( focused )
            {
            ret = focused->OfferKeyEventL( aKeyEvent, aType );
            doScroll = ( ret == EKeyWasConsumed ); 
            }

        if ( ret == EKeyWasNotConsumed ) 
            {
            ret = ChangeFocusL( aKeyEvent );
            DrawDeferred();
            }
        }
    else
        {
        if ( IsPopupActive() && aType == EEventKey )
            {
            // select current
            if( aKeyEvent.iCode == EKeyEnter || 
                aKeyEvent.iCode == EKeyDevice4 || 
                aKeyEvent.iCode == EKeyOK )
                {
                DoPopupSelectL();
                ret = EKeyWasConsumed;
                }
            }
        else
            {
            // Don't allow line feeds in header fields.
            // Could be nice if enter committed the field and moved the focus
            // to next one
            if ( aType == EEventKey && 
                 ( aKeyEvent.iCode == EKeyEnter || 
                   aKeyEvent.iScanCode == EStdKeyEnter) )
                {
                focused->OfferKeyEventL( aKeyEvent, aType );
                ret = EKeyWasConsumed;
                }
            }
        }
    if ( ret == EKeyWasNotConsumed )
        {
        if ( focused )
            {
            ret = focused->OfferKeyEventL( aKeyEvent, aType );

            if(aType==EEventKeyDown)
                {
                doScroll = ETrue; 
                }
            else 
                {
                doScroll = (ret == EKeyWasConsumed); 
                }
            }
        }

    if ( doScroll )
        {
        DoScroll();
        }

    return ret;
    }

// ---------------------------------------------------------------------------
// CNcsHeaderContainer::FindFocused
// ---------------------------------------------------------------------------
//
CCoeControl* CNcsHeaderContainer::FindFocused() const
    {
    FUNC_LOG;
    CCoeControlArray::TCursor cur = Components().Begin();
    do 
        {
        if ( cur.Control<CCoeControl>()->IsFocused() )
            {
            return cur.Control<CCoeControl>();
            }
        } 
    while ( cur.Next() );
    return NULL;
    }

// -----------------------------------------------------------------------------
// CNcsHeaderContainer::ChangeFocusL()
// Handles key events
// -----------------------------------------------------------------------------
TKeyResponse CNcsHeaderContainer::ChangeFocusL( const TKeyEvent& aKeyEvent )
    {
    FUNC_LOG;
    ASSERT( aKeyEvent.iCode == EKeyDownArrow || 
            aKeyEvent.iCode == EKeyUpArrow );
    TKeyResponse ret( EKeyWasNotConsumed );

    CCoeControl* pOldCtrl = FindFocused();

    // If nothing is focused we return
    if ( !pOldCtrl ) return ret;
    
    //If this is the first control in the list, don't change focus
    CCoeControlArray::TCursor cur = Components().Find(pOldCtrl);
    if ( aKeyEvent.iCode == EKeyUpArrow && cur == Components().Begin() )
        {
        return ret;
        }

    // Unfocus the control
    pOldCtrl->SetFocus( EFalse, ENoDrawNow );

    CCoeControl* pNewCtrl = NULL;
    if ( aKeyEvent.iCode == EKeyDownArrow && cur.Next() ) 
        {
        pNewCtrl = cur.Control<CCoeControl>();
        if ( pNewCtrl == iAttachmentField )
            {
            iAttachmentField->SetFocusedAttachmentLabelIndex( 0 );
            }
        pNewCtrl->SetFocus( ETrue, ENoDrawNow );
        iFocused = pNewCtrl;
        ret = EKeyWasConsumed;
        }
    else if ( aKeyEvent.iCode == EKeyUpArrow && cur.Prev() )
        {
        pNewCtrl = cur.Control<CCoeControl>();
        pNewCtrl->SetFocus( ETrue, ENoDrawNow );
        iFocused = pNewCtrl;
        ret = EKeyWasConsumed;
        }

    CNcsComposeViewContainer* container = 
        static_cast<CNcsComposeViewContainer*>( &iParent );
    if ( pOldCtrl == iToField )
        {
        container->CommitL( EToField );
        }
    else if ( pOldCtrl == iCcField) 
        {
        container->CommitL( ECcField );
        }
    else if ( pOldCtrl == iBccField)
        {
        container->CommitL( EBccField );
        }
    else if ( pOldCtrl == iSubjectField)
        {
        container->CommitL( ESubjectField );
        }

    // if focus was changed, update scroll bar
    if ( ret == EKeyWasConsumed )
        {
        container->UpdateScrollBar();
        DoScroll();
        }

    // NOTE: If we're leaving the header (down was pushed on last control)
    //       then we return EKeyWasNotConsumed to make sure the
    //		 parent moves the focus to the control below this container
    return ret;
	}

// -----------------------------------------------------------------------------
// CNcsHeaderContainer::UpdateFieldPosition()
// One of the controls want me to readjust myself to a new position,'
// anchoring arround the given control
// -----------------------------------------------------------------------------
void CNcsHeaderContainer::UpdateFieldPosition( CCoeControl* aAnchor )
	{
    FUNC_LOG;
	// if the anchor is NULL just call SizeChanged
	if ( !aAnchor )
		{
		SizeChanged();
		return;
		}
	
	CCoeControlArray::TCursor cur = Components().Find( aAnchor );
	// figure out the new top position of the container
	TInt top = aAnchor->Rect().iTl.iY;
        if( cur.IsValid() )
		{
	    while ( cur.Prev() )
	    	{
		    CCoeControl* ctrl = cur.Control<CCoeControl>();
		    top -= ctrl->Rect().Height();
		    }
		}
	// Then check we didn't move too much and composer still fills the whole
	// visible area on the screen (i.e. don't scroll below the bottom of the
	// body field)
	CNcsComposeViewContainer& parent = 
        static_cast<CNcsComposeViewContainer&>( iParent );
	TInt composerHeight = parent.ContentTotalHeight();
    TInt screenHeight = parent.Rect().Height();
    if ( composerHeight <= screenHeight )
        { // no scrolling is needed at all since everything fits on screen
        top = 0;
        }
    else
        {
        top = Max( top, screenHeight - composerHeight );
        }

    // The top edge of the header should never be lower than on the top edge
    // of the screen. For some reason, the calculation above leads to such
    // situation if recipient and subject fields are scrollable. If that 
    // happens, increase the top value to 0 to prevent empty space showing up
    // above the header area.
	top = Min( top, 0 );
	
	// set the new position of the container
	SetExtent( TPoint( Rect().iTl.iX, top ), Size() );
	}

// -----------------------------------------------------------------------------
// CNcsHeaderContainer::SizeChanged()
// set size
// -----------------------------------------------------------------------------
void CNcsHeaderContainer::SizeChanged()
	{
    FUNC_LOG;

    const TRect rect( Rect() );

    TInt currentLine( 0 );
    CCoeControlArray::TCursor cur = Components().Begin();
    do
        {
        const TInt lineCount( ToNcsControl( cur )->LayoutLineCount() );
        if ( lineCount > 0 )
            {
            NcsUtility::LayoutHeaderControl( cur.Control<CCoeControl>(), 
                    rect, currentLine, lineCount );
            // Do not use stored value lineCount because count may change
            // during layout (e.g. when orientation is changed => edit field
            // length may change => it grows or shrinks)
            currentLine += ToNcsControl( cur )->LayoutLineCount();
            }
        } while ( cur.Next() );
        
	if( iAacListBox->IsVisible() && !iAacListBox->IsPopupEmpty() )
		{
		iAacListBox->SetPopupMaxRect( CalculatePopupRect() );
		}
	}

// -----------------------------------------------------------------------------
// CNcsHeaderContainer::PositionChanged()
// set size
// -----------------------------------------------------------------------------
void CNcsHeaderContainer::PositionChanged()
    {
    FUNC_LOG;
    }

// -----------------------------------------------------------------------------
// CNcsHeaderContainer::ChangePositions()
// set positions
// -----------------------------------------------------------------------------
//
void CNcsHeaderContainer::ChangePositions()
	{
    FUNC_LOG;
	TPoint nextPoint( Rect().iTl );

	CCoeControl* ctrl;
	CCoeControlArray::TCursor cur = Components().Begin();
	do 
		{
		ctrl = cur.Control<CCoeControl>();
		ctrl->SetPosition( nextPoint );
		nextPoint.iY += ctrl->Size().iHeight;
		} 
    while ( cur.Next() );
	}


// ---------------------------------------------------------------------------
// CNcsHeaderContainer::NeedsAifMenu
// ---------------------------------------------------------------------------
//
TBool CNcsHeaderContainer::NeedsAifMenu() const
	{
    FUNC_LOG;

	CCoeControl* focused = FindFocused();

	// Has to be an AIF field
	TBool ret = EFalse;
	
    if ( IsAddressInputField( focused ) )
        {
        CNcsAddressInputField* aifFocused = NULL;
        aifFocused = static_cast<CNcsAddressInputField*>( focused );
        ret = ( aifFocused->TextEditor()->SelectionLength() > 1 );
        }
	
	return ret;
	}

// ---------------------------------------------------------------------------
// CNcsHeaderContainer::GetToLineHeight
// ---------------------------------------------------------------------------
//
TInt CNcsHeaderContainer::GetToLineHeight() const
	{
	FUNC_LOG;
	TInt lineHeight = 0;
	
	if(iToField)
		{
	    TRect lineRect;
	    TRAPD(err, iToField->GetLineRectL(lineRect) );
	   	if(err == KErrNone)
	        {
	        lineHeight = lineRect.iBr.iY - lineRect.iTl.iY;
	        }
		}
	return lineHeight;
	}
      
// ---------------------------------------------------------------------------
// CNcsHeaderContainer::GetTotalHeight
// ---------------------------------------------------------------------------
//
TInt CNcsHeaderContainer::GetTotalHeight() const
	{
    FUNC_LOG;
	TInt ret = 0;
	CCoeControlArray::TCursor cur = Components().Begin();
	do
		{
		CCoeControl* ctrl = cur.Control<CCoeControl>();
		ret += ctrl->Size().iHeight;
		} 
	while ( cur.Next() );
	return ret;
	}

// -----------------------------------------------------------------------------
// CNcsHeaderContainer::SetAttachmentLabelTextsLD
//
// -----------------------------------------------------------------------------
//
void CNcsHeaderContainer::SetAttachmentLabelTextsLD( 
    CDesCArray* aAttachmentNames, CDesCArray* aAttachmentSizes )
    {
    FUNC_LOG;   
    iAttachmentField->SetTextsLD( aAttachmentNames, aAttachmentSizes );
    if( aAttachmentNames )
        {
        ShowAttachmentLabelL();
        }
    }

// -----------------------------------------------------------------------------
// CNcsHeaderContainer::FocusedAttachmentLabelIndex
//
// -----------------------------------------------------------------------------
//
TInt CNcsHeaderContainer::FocusedAttachmentLabelIndex() const
    {
    FUNC_LOG;
    return iAttachmentField->FocusedAttachmentLabelIndex();
    }

// -----------------------------------------------------------------------------
// CNcsHeaderContainer::ShowAttachmentLabel()
// -----------------------------------------------------------------------------
//
void CNcsHeaderContainer::ShowAttachmentLabelL()
    {
    FUNC_LOG;
    if ( !iAttachmentField->IsVisible() )
        {
        CCoeControlArray::TCursor cur = Components().End();
        Components().InsertLC( cur, iAttachmentField );
        CleanupStack::Pop( iAttachmentField );

        TRAP_IGNORE( iFieldSizeObserver.UpdateFieldSizeL() );

        CCoeControl* pOldCtrl = FindFocused();
        if ( pOldCtrl )
            {
            pOldCtrl->SetFocus( EFalse, ENoDrawNow );
            }

        iAttachmentField->SetFocus( ETrue, ENoDrawNow );
        iFieldSizeObserver.UpdateFieldPosition( iAttachmentField );
        }
    }

// -----------------------------------------------------------------------------
// CNcsHeaderContainer::HideAttachmentLabel()
// -----------------------------------------------------------------------------
//
void CNcsHeaderContainer::HideAttachmentLabel()
    {
    FUNC_LOG;
    // check if we are focused and in that case
    // unfocus attachment filed and focus previous control
    CCoeControl* pOldCtrl = FindFocused();
    CCoeControl* pNewCtrl = NULL;

    if ( iFocused == iAttachmentField )
        {
        iFocused = NULL;
        }

    if ( pOldCtrl == iAttachmentField )
        {
        CCoeControlArray::TCursor cur = Components().Find( pOldCtrl );
        pOldCtrl->SetFocus( EFalse, ENoDrawNow );

        if ( cur.Prev() )
            {
            pNewCtrl = cur.Control<CCoeControl>();
            pNewCtrl->SetFocus( ETrue, ENoDrawNow );
            }
        }
    else
        {
        pNewCtrl = pOldCtrl; // no need to move focus
        }

    iAttachmentField->MakeVisible( EFalse );
    Components().Remove( iAttachmentField );
    TRAP_IGNORE( iFieldSizeObserver.UpdateFieldSizeL() );

    // Scroll to currently focused field
    if ( pNewCtrl )
        {
        iFieldSizeObserver.UpdateFieldPosition( pNewCtrl );
        }

    }

// -----------------------------------------------------------------------------
// CNcsHeaderContainer::SetBccFieldVisibleL()
// -----------------------------------------------------------------------------
//
void CNcsHeaderContainer::SetBccFieldVisibleL( 
        TBool aVisible, TDrawNow aDrawNow, TBool aFocus ) 
    {
    FUNC_LOG;
	if ( iBccField->IsVisible() == aVisible )
		{
		return;
		}

	if ( aVisible )
		{
		CCoeControlArray::TCursor cur = Components().Find( iSubjectField );
		Components().InsertLC( cur, iBccField );
		CleanupStack::Pop( iBccField );

		if ( aFocus )
			{
			CCoeControl* focused = FindFocused();

			if ( focused )
				{
				focused->SetFocus( EFalse );
				}
			iBccField->SetFocus( ETrue );
            iFocused = iBccField;
			iBccField->SelectAllTextL();
			}
		}
	else
		{
		if ( iBccField->IsFocused() )
			{
			CCoeControlArray::TCursor cur = Components().Find( iBccField );
			ASSERT( cur.IsValid() );
			
			iBccField->SetFocus( EFalse );

			cur.Prev(); // Get the control before this field
			cur.Control<CCoeControl>()->SetFocus( ETrue );
			}
		Components().Remove( iBccField );
        iFocused = iSubjectField;
		}

    TRAP_IGNORE( iFieldSizeObserver.UpdateFieldSizeL() );

	if ( aDrawNow == EDrawNow )
		{
	    DrawDeferred();
		}
	}

// -----------------------------------------------------------------------------
// CNcsHeaderContainer::SetCcFieldVisibleL()
// -----------------------------------------------------------------------------
void CNcsHeaderContainer::SetCcFieldVisibleL( 
        TBool aVisible, TDrawNow aDrawNow, TBool aFocus ) 
	{
    FUNC_LOG;
	if ( iCcField->IsVisible() == aVisible )
		{
		return;
		}

	if ( aVisible )
		{
		Components().InsertAfterLC( Components().Id( *iToField ), iCcField );
		CleanupStack::Pop( iCcField );

		if ( aFocus )
			{
			CCoeControl* focused = FindFocused();
			if ( focused )
				{
				focused->SetFocus( EFalse );
				}
			iCcField->SetFocus( ETrue );
            iFocused = iCcField;
			iCcField->SelectAllTextL();
			}
		}
	else
		{
		if( iCcField->IsFocused() )
			{
			iCcField->SetFocus( EFalse );
			iToField->SetFocus( ETrue );
			}
		Components().Remove( iCcField );
        iFocused = iToField;
		}
    
	TRAP_IGNORE( iFieldSizeObserver.UpdateFieldSizeL() );

    if ( aDrawNow == EDrawNow )
		{
	    DrawDeferred();
		}
    }

// -----------------------------------------------------------------------------
// CNcsHeaderContainer::MopSupplyObject
// From CCoeControl.
// -----------------------------------------------------------------------------
TTypeUid::Ptr CNcsHeaderContainer::MopSupplyObject( TTypeUid aId )
	{
    FUNC_LOG;
    return CCoeControl::MopSupplyObject( aId );
	}

// ---------------------------------------------------------------------------
// CNcsHeaderContainer::LineCount
// ---------------------------------------------------------------------------
//
TInt CNcsHeaderContainer::LineCount() const
	{
    FUNC_LOG;
	TInt cnt = 0;
	CCoeControlArray::TCursor cur = Components().Begin();
	do 
		{
        MNcsControl* ctrl = ToNcsControl( cur );
        cnt += ctrl->LineCount();
        } 
    while ( cur.Next() );
	return cnt;
	}

// ---------------------------------------------------------------------------
// CNcsHeaderContainer::ScrollableLines
// ---------------------------------------------------------------------------
//
TInt CNcsHeaderContainer::ScrollableLines() const
	{
    FUNC_LOG;
	TInt cnt = 0;
	CCoeControlArray::TCursor cur = Components().Begin();
	do 
		{
		MNcsControl* ctrl = ToNcsControl( cur );
		cnt += ctrl->ScrollableLines();
		} 
	while ( cur.Next() );
	return cnt;
	}

// ---------------------------------------------------------------------------
// CNcsHeaderContainer::CursorPosition
// ---------------------------------------------------------------------------
//
TInt CNcsHeaderContainer::CursorPosition() const
	{
    FUNC_LOG;
	CCoeControl* coe = FindFocused();
	if ( !coe )
		{
		return 0;
		}
	
	MNcsControl* ncsCtrl = dynamic_cast<MNcsControl*>( coe );
	// This will give the the position relative to the top of the control
	TInt pos(0); // Coverity error fix ncsCtrl could be NULL
	if(ncsCtrl)
	    {
        pos = ncsCtrl->CursorPosition();
        // add the location of the top of the control relative to the top
        // of the header.
        pos += coe->Rect().iTl.iY - Rect().iTl.iY;
	    }
	return pos;
	}

// ---------------------------------------------------------------------------
// CNcsHeaderContainer::CursorLineNumber
// ---------------------------------------------------------------------------
//
TInt CNcsHeaderContainer::CursorLineNumber() const
    {
    FUNC_LOG;
    TInt cnt = 0;
	CCoeControlArray::TCursor cur = Components().Begin();
	do 
		{
        CCoeControl* coe = cur.Control<CCoeControl>();
        MNcsControl* ctrl = ToNcsControl( cur );
        if ( !coe->IsFocused() )
            {
            cnt += ctrl->LineCount();
            }
        else
            {
            cnt += ctrl->CursorLineNumber();
            break;
            }
        }
    while ( cur.Next() );
	return cnt;
    }

// ---------------------------------------------------------------------------
// CNcsHeaderContainer::GetNumChars
// ---------------------------------------------------------------------------
//
TInt CNcsHeaderContainer::GetNumChars() const
	{
    FUNC_LOG;
	TInt cnt = iToField->GetNumChars() + 
               iCcField->GetNumChars() + 
               iBccField->GetNumChars() + 
               iSubjectField->GetNumChars();

	return cnt;
	}

// -----------------------------------------------------------------------------
// CNcsHeaderContainer::UpdatePopupContactListL()
// -----------------------------------------------------------------------------
//
void CNcsHeaderContainer::UpdatePopupContactListL( 
        const TDesC& aMatchString, TBool /*aListAll*/ )
	{
    FUNC_LOG;

    // do update only for address fields
	CCoeControl* focused = FindFocused();
	
	if ( !IsAddressInputField( focused ) )
	    {
	    return;
	    }
	    
	if ( aMatchString.CompareC( KNullDesC ) == 0 || 
	     aMatchString.Compare( KAddressDelimeterSemiColon ) == 0 )
		{
		ClosePopupContactListL();
		return;
		}
	
	if( !iAacListBox->IsVisible() )
		{
        iAacListBox->SetPopupMaxRect( CalculatePopupRect() );
        iAacListBox->InitAndSearchL( aMatchString, 1 );
        iAacListBox->ActivateL();
		}
	else
		{
		iAacListBox->SetSearchTextL( aMatchString );
		}
	}

// -----------------------------------------------------------------------------
// CNcsHeaderContainer::ClosePopupContactListL()
// -----------------------------------------------------------------------------
//
void CNcsHeaderContainer::ClosePopupContactListL()
	{
    FUNC_LOG;

    if ( iAacListBox->IsVisible() )
        {
        iAacListBox->MakeVisible( EFalse );
        ShowPopupMenuBarL( EFalse );
        
        // The focused address field should be redrawn after the popup is
        // closed to fix the field border.
        if ( iToField->IsFocused() )
            {
            iToField->DrawDeferred();
            }
        else if ( iCcField->IsFocused() )
            {
            iCcField->DrawDeferred();
            }
        else if ( iBccField->IsFocused() )
            {
            iBccField->DrawDeferred();
            }
        }
	}

// ---------------------------------------------------------------------------
// CNcsHeaderContainer::ShowPopupMenuBarL
// ---------------------------------------------------------------------------
//
void CNcsHeaderContainer::ShowPopupMenuBarL( TBool aShow )
	{
    FUNC_LOG;
	if ( iMenuBar ) 
		{
		if( aShow )
			{
			iMenuBar->SetCommandSetL( R_AVKON_SOFTKEYS_CANCEL ); 
			}
		else
			{
			iMenuBar->SetCommandSetL( R_FSE_EDITOR_SOFTKEYS_OPTIONS_CLOSE );
			SetMskL();
			}
        iMenuBar->DrawDeferred();
		}
	}

// ---------------------------------------------------------------------------
// CNcsHeaderContainer::DeleteSelectionL
// ---------------------------------------------------------------------------
//
void CNcsHeaderContainer::DeleteSelectionL()
	{
    FUNC_LOG;

    CCoeControl* focused = FindFocused();

    if ( IsAddressInputField( focused ) )
        {
    	CNcsAddressInputField* field = NULL;
    	field = static_cast<CNcsAddressInputField*>( focused );
    	TKeyEvent event;  // This mimics c -button pressing
    	event.iCode = EKeyBackspace;
    	event.iScanCode = EStdKeyBackspace;
    	event.iModifiers = EModifierAutorepeatable|EModifierNumLock;
    	event.iRepeats = 0;
    	TEventCode code = EEventKey;
    	field->OfferKeyEventL( event, code );
        }
	}

// ---------------------------------------------------------------------------
// CNcsHeaderContainer::SelectAllToFieldTextL
// ---------------------------------------------------------------------------
//
void CNcsHeaderContainer::SelectAllToFieldTextL()
	{
    FUNC_LOG;
	iToField->SelectAllTextL();
	}
		
// ---------------------------------------------------------------------------
// CNcsHeaderContainer::SelectAllCcFieldTextL
// ---------------------------------------------------------------------------
//
void CNcsHeaderContainer::SelectAllCcFieldTextL()
	{
    FUNC_LOG;
	iCcField->SelectAllTextL();
	}
	
// ---------------------------------------------------------------------------
// CNcsHeaderContainer::SelectAllBccFieldTextL
// ---------------------------------------------------------------------------
//
void CNcsHeaderContainer::SelectAllBccFieldTextL()
	{
    FUNC_LOG;
	iBccField->SelectAllTextL();
	}
	
// ---------------------------------------------------------------------------
// CNcsHeaderContainer::SelectAllSubjectFieldTextL
// ---------------------------------------------------------------------------
//
void CNcsHeaderContainer::SelectAllSubjectFieldTextL()
	{
    FUNC_LOG;
	iSubjectField->SelectAllTextL();
	}

// -----------------------------------------------------------------------------
// CNcsHeaderContainer::CalculatePopupRect
// -----------------------------------------------------------------------------
TRect CNcsHeaderContainer::CalculatePopupRect()
    {
    FUNC_LOG;
    // get focused control rect
    TRect popupRect;

    CCoeControl* focused = FindFocused();
    if ( IsAddressInputField( focused ) )
        {
        CNcsAddressInputField* aifEditor =
            static_cast<CNcsAddressInputField*>( focused );

        TPoint editorPos = aifEditor->Editor()->PositionRelativeToScreen();
        TRect editorRect = aifEditor->Editor()->Rect();

        popupRect.iTl = TPoint( editorPos.iX, 
            editorPos.iY + aifEditor->CursorPosition() + 1 );

        popupRect.iBr = TPoint( editorPos.iX + editorRect.Width(),
            iParent.PositionRelativeToScreen().iY + iParent.Rect().Height() );
        }

    return popupRect;
    }

// -----------------------------------------------------------------------------
// CNcsHeaderContainer::DoPopupSelect
// -----------------------------------------------------------------------------
void CNcsHeaderContainer::DoPopupSelectL()
	{
    FUNC_LOG;
    __ASSERT_DEBUG( iAacListBox, Panic( ENcsBasicUi ) );
    __ASSERT_DEBUG( &iMailBox, Panic( ENcsBasicUi ) );

	if( iAacListBox->IsRemoteLookupItemSelected() )
		{
		CCoeControl* focused = FindFocused();
		
		if ( IsAddressInputField( focused ) )
		    {
    		// Launch remote lookup
		    iRALInProgress = ETrue;
    		CNcsAddressInputField* addressField = NULL;
    		addressField = static_cast<CNcsAddressInputField*>( focused );
    		HBufC* lookupText = addressField->GetLookupTextLC();
    		CPbkxRemoteContactLookupServiceUiContext::TResult::TExitReason ex;
            CNcsEmailAddressObject* address = ExecuteRemoteSearchL(
                ex, *lookupText );
            iRALInProgress = EFalse;
            if ( address )
                {
                CleanupStack::PushL( address );
                IncludeAddressL( *address );
                CleanupStack::PopAndDestroy( address );
                }
            CleanupStack::PopAndDestroy( lookupText );
            CNcsComposeViewContainer& parent = 
                static_cast<CNcsComposeViewContainer&>( iParent );
            parent.FocusChanged( EDrawNow );
		    }
		}
	else if( !iAacListBox->IsPopupEmpty() )
		{
		CNcsEmailAddressObject* emailAddress  = 
            iAacListBox->ReturnCurrentEmailAddressLC();
		if( emailAddress )
			{
            if ( emailAddress->EmailAddress().Compare( KNullDesC ) != 0 )
                {
                IncludeAddressL( *emailAddress );
                }
            else
                {           
                // selected contact doesn't have email address, launch remote
                // contact lookup rcl must be usable, since otherwise there 
                // couldn't be any items without email addresses
                iRALInProgress = ETrue; 
                CPbkxRemoteContactLookupServiceUiContext::TResult::TExitReason
                    exitReason;
                CNcsEmailAddressObject* remAddress = ExecuteRemoteSearchL(
                    exitReason,
                    emailAddress->DisplayName() );
                iRALInProgress = EFalse;
                // Refresh the toolbar. It was hidden during the remote search 
                // and now it needs to be shown. FocusChanged () will do it. 
                CNcsComposeViewContainer& parent = 
                    static_cast<CNcsComposeViewContainer&>( iParent );
                parent.FocusChanged( EDrawNow );
                
                if ( remAddress )
                    {
                    CleanupStack::PushL( remAddress );
                    IncludeAddressL( *remAddress );
                    CleanupStack::PopAndDestroy( remAddress );
                    }           
                }
            CleanupStack::PopAndDestroy( emailAddress );
            }
        }
	ClosePopupContactListL();
	}

// -----------------------------------------------------------------------------
// CNcsHeaderContainer::IsPopupActive
// -----------------------------------------------------------------------------
TBool CNcsHeaderContainer::IsPopupActive() const
	{
    FUNC_LOG;
	if ( iAacListBox && iAacListBox->IsVisible() )
		{
		return ETrue;
		}
	else
		{
		return EFalse;
		}
	}

// ---------------------------------------------------------------------------
// CNcsHeaderContainer::IsToFieldEmpty
// ---------------------------------------------------------------------------
//
TBool CNcsHeaderContainer::IsToFieldEmpty() const
	{
    FUNC_LOG;
	return ( GetToFieldLength() < 1 );
	}
	
// ---------------------------------------------------------------------------
// CNcsHeaderContainer::IsCcFieldEmpty
// ---------------------------------------------------------------------------
//
TBool CNcsHeaderContainer::IsCcFieldEmpty() const
	{
    FUNC_LOG;
   	return ( !IsCcFieldVisible() || GetCcFieldLength() < 1 );
	}

// ---------------------------------------------------------------------------
// CNcsHeaderContainer::IsBccFieldEmpty
// ---------------------------------------------------------------------------
//
TBool CNcsHeaderContainer::IsBccFieldEmpty() const
	{
    FUNC_LOG;
	return ( !IsBccFieldVisible() || GetBccFieldLength() < 1 );
	}

// ---------------------------------------------------------------------------
// CNcsHeaderContainer::IsSubjectFieldEmpty
// ---------------------------------------------------------------------------
//
TBool CNcsHeaderContainer::IsSubjectFieldEmpty() const
	{
    FUNC_LOG;
	return ( GetSubjectFieldLength() < 1 );
	}

// ---------------------------------------------------------------------------
// CNcsHeaderContainer::GetToFieldAddressesL
// ---------------------------------------------------------------------------
//
const RPointerArray<CNcsEmailAddressObject>& 
CNcsHeaderContainer::GetToFieldAddressesL( TBool aParseNow )
    {
	return iToField->GetAddressesL( aParseNow );
    }

// ---------------------------------------------------------------------------
// CNcsHeaderContainer::GetCcFieldAddressesL
// ---------------------------------------------------------------------------
//
const RPointerArray<CNcsEmailAddressObject>& 
CNcsHeaderContainer::GetCcFieldAddressesL( TBool aParseNow )
    {
	return iCcField->GetAddressesL( aParseNow );
    }

// ---------------------------------------------------------------------------
// CNcsHeaderContainer::GetBccFieldAddressesL
// ---------------------------------------------------------------------------
//
const RPointerArray<CNcsEmailAddressObject>& 
CNcsHeaderContainer::GetBccFieldAddressesL( TBool aParseNow )
    {
	return iBccField->GetAddressesL( aParseNow );
    }

// ---------------------------------------------------------------------------
// CNcsHeaderContainer::GetSubjectLC
// ---------------------------------------------------------------------------
//
HBufC* CNcsHeaderContainer::GetSubjectLC() const
    {
    FUNC_LOG;
	HBufC* subject = 
        HBufC::NewLC( iSubjectField->Editor()->TextLength() + 2 );
	TPtr des = subject->Des();
	iSubjectField->Editor()->GetText( des );
	return subject;
    }

// ---------------------------------------------------------------------------
// CNcsHeaderContainer::IsBccFieldVisible
// ---------------------------------------------------------------------------
//
TBool CNcsHeaderContainer::IsBccFieldVisible() const
    {
    FUNC_LOG;
	return iBccField->IsVisible(); 
    }

// ---------------------------------------------------------------------------
// CNcsHeaderContainer::IsCcFieldVisible
// ---------------------------------------------------------------------------
//
TBool CNcsHeaderContainer::IsCcFieldVisible() const
    {
    FUNC_LOG;
	return iCcField->IsVisible(); 
    }

// ---------------------------------------------------------------------------
// CNcsHeaderContainer::IsFocusAttachments
// ---------------------------------------------------------------------------
//
TBool CNcsHeaderContainer::IsFocusAttachments() const
    {
    FUNC_LOG;
	return ( FindFocused() == iAttachmentField );
    }

// ---------------------------------------------------------------------------
// CNcsHeaderContainer::IsFocusTo
// ---------------------------------------------------------------------------
//
TBool CNcsHeaderContainer::IsFocusTo() const
    {
    FUNC_LOG;
	return ( FindFocused() == iToField );
    }

// ---------------------------------------------------------------------------
// CNcsHeaderContainer::IsFocusCc
// ---------------------------------------------------------------------------
//
TBool CNcsHeaderContainer::IsFocusCc() const
    {
    FUNC_LOG;
	return ( FindFocused() == iCcField );
    }

// ---------------------------------------------------------------------------
// CNcsHeaderContainer::IsFocusBcc
// ---------------------------------------------------------------------------
//
TBool CNcsHeaderContainer::IsFocusBcc() const
    {
    FUNC_LOG;
	return ( FindFocused() == iBccField );
    }

// ---------------------------------------------------------------------------
// CNcsHeaderContainer::GetCcFieldLength
// ---------------------------------------------------------------------------
//
TInt CNcsHeaderContainer::GetCcFieldLength() const
    {
    FUNC_LOG;
	return iCcField->Editor()->TrimmedTextLength();
    }

// ---------------------------------------------------------------------------
// CNcsHeaderContainer::GetBccFieldLength
// ---------------------------------------------------------------------------
//
TInt CNcsHeaderContainer::GetBccFieldLength() const
    {
    FUNC_LOG;
	return iBccField->Editor()->TrimmedTextLength();
    }

// ---------------------------------------------------------------------------
// CNcsHeaderContainer::GetToFieldLength
// ---------------------------------------------------------------------------
//
TInt CNcsHeaderContainer::GetToFieldLength() const
    {
    FUNC_LOG;
	return iToField->Editor()->TrimmedTextLength();
    }

// ---------------------------------------------------------------------------
// CNcsHeaderContainer::GetSubjectFieldLength
// ---------------------------------------------------------------------------
//
TInt CNcsHeaderContainer::GetSubjectFieldLength() const
    {
    FUNC_LOG;
	return iSubjectField->Editor()->TrimmedTextLength();
    }

// ---------------------------------------------------------------------------
// CNcsHeaderContainer::GetAttachmentCount
// ---------------------------------------------------------------------------
//
TInt CNcsHeaderContainer::GetAttachmentCount() const
    {
    FUNC_LOG;
    CNcsComposeViewContainer& parent = 
        static_cast<CNcsComposeViewContainer&>( iParent );
    return parent.GetAttachmentCount();
    }

// ---------------------------------------------------------------------------
// CNcsHeaderContainer::HasRemoteAttachments
// ---------------------------------------------------------------------------
//
TInt CNcsHeaderContainer::HasRemoteAttachments() const
    {
    FUNC_LOG;
    CNcsComposeViewContainer& parent = 
        static_cast<CNcsComposeViewContainer&>( iParent );
    return parent.HasRemoteAttachments();
    }

// ---------------------------------------------------------------------------
// CNcsHeaderContainer::GetToFieldSelectionLength
// ---------------------------------------------------------------------------
//
TInt CNcsHeaderContainer::GetToFieldSelectionLength() const
    {
    FUNC_LOG;
	return iToField->TextEditor()->SelectionLength();
    }

// ---------------------------------------------------------------------------
// CNcsHeaderContainer::GetCcFieldSelectionLength
// ---------------------------------------------------------------------------
//
TInt CNcsHeaderContainer::GetCcFieldSelectionLength() const
    {
    FUNC_LOG;
	return iCcField->TextEditor()->SelectionLength();
    }

// ---------------------------------------------------------------------------
// CNcsHeaderContainer::GetBccFieldSelectionLength
// ---------------------------------------------------------------------------
//
TInt CNcsHeaderContainer::GetBccFieldSelectionLength()	const
    {
    FUNC_LOG;
	return iBccField->TextEditor()->SelectionLength();
    }

// ---------------------------------------------------------------------------
// CNcsHeaderContainer::GetLookupTextLC
// ---------------------------------------------------------------------------
//
HBufC* CNcsHeaderContainer::GetLookupTextLC() const
    {
    FUNC_LOG;
	CCoeControl* focused = FindFocused();
	if ( !focused ) return NULL;
	
	CNcsAddressInputField* aif = dynamic_cast<CNcsAddressInputField*>(focused);
	if ( !aif ) return NULL;
	return aif->GetLookupTextLC();
    }

// ---------------------------------------------------------------------------
// CNcsHeaderContainer::SetToFieldAddressesL
// ---------------------------------------------------------------------------
//
void CNcsHeaderContainer::SetToFieldAddressesL( 
        const RPointerArray<CNcsEmailAddressObject>& aAddress )
    {
    FUNC_LOG;
	iToField->SetAddressesL( aAddress );
    }

// ---------------------------------------------------------------------------
// CNcsHeaderContainer::SetCcFieldAddressesL
// ---------------------------------------------------------------------------
//
void CNcsHeaderContainer::SetCcFieldAddressesL( 
        const RPointerArray<CNcsEmailAddressObject>& aAddress )
    {
    FUNC_LOG;
	iCcField->SetAddressesL( aAddress );
	if ( !iCcField->IsEmpty() )
		SetCcFieldVisibleL( ETrue, ENoDrawNow );
    }

// ---------------------------------------------------------------------------
// CNcsHeaderContainer::SetBccFieldAddressesL
// ---------------------------------------------------------------------------
//
void CNcsHeaderContainer::SetBccFieldAddressesL( 
        const RPointerArray<CNcsEmailAddressObject>& aAddress )
    {
    FUNC_LOG;
	iBccField->SetAddressesL( aAddress );
	if ( !iBccField->IsEmpty() )
		SetBccFieldVisibleL( ETrue, ENoDrawNow );
    }

// ---------------------------------------------------------------------------
// CNcsHeaderContainer::AppendToFieldAddressesL
// ---------------------------------------------------------------------------
//
void CNcsHeaderContainer::AppendToFieldAddressesL( 
        const RPointerArray<CNcsEmailAddressObject>& aAddresses )
    {
    FUNC_LOG;
	iToField->AppendAddressesL( aAddresses );
    }

// ---------------------------------------------------------------------------
// CNcsHeaderContainer::AppendCcFieldAddressesL
// ---------------------------------------------------------------------------
//
void CNcsHeaderContainer::AppendCcFieldAddressesL( 
        const RPointerArray<CNcsEmailAddressObject>& aAddresses )
    {
    FUNC_LOG;
	iCcField->AppendAddressesL( aAddresses );
    }

// ---------------------------------------------------------------------------
// CNcsHeaderContainer::AppendBccFieldAddressesL
// ---------------------------------------------------------------------------
//
void CNcsHeaderContainer::AppendBccFieldAddressesL( 
        const RPointerArray<CNcsEmailAddressObject>& aAddresses )
    {
    FUNC_LOG;
	iBccField->AppendAddressesL( aAddresses );
    }

// ---------------------------------------------------------------------------
// CNcsHeaderContainer::SetSubjectL
// ---------------------------------------------------------------------------
//
void CNcsHeaderContainer::SetSubjectL( const TDesC& aSubject )
    {
    FUNC_LOG;
	iSubjectField->SetSubjectL( aSubject );
    }

// ---------------------------------------------------------------------------
// CNcsHeaderContainer::SetMenuBar
// ---------------------------------------------------------------------------
//
void CNcsHeaderContainer::SetMenuBar( CEikButtonGroupContainer* aMenuBar )
    {
    FUNC_LOG;
	iMenuBar = aMenuBar;
    }

// ---------------------------------------------------------------------------
// CNcsHeaderContainer::IncludeAddressL
// ---------------------------------------------------------------------------
//
void CNcsHeaderContainer::IncludeAddressL(const CNcsEmailAddressObject& aEml )
    {
    FUNC_LOG;

    CCoeControl* focused = FindFocused();
    if ( IsAddressInputField( focused ) )
        {
        CNcsAddressInputField* aifFocused = NULL;
        aifFocused = static_cast<CNcsAddressInputField*>( focused );
        aifFocused->AddAddressL( aEml );
        }
    DoScroll();
    }

// ---------------------------------------------------------------------------
// CNcsHeaderContainer::IncludeAddressL
// ---------------------------------------------------------------------------
//
void CNcsHeaderContainer::IncludeAddressL()
    {
    FUNC_LOG;
    }

// ---------------------------------------------------------------------------
// CNcsHeaderContainer::FocusToField
// ---------------------------------------------------------------------------
//
void CNcsHeaderContainer::FocusToField()
    {
    FUNC_LOG;
    CCoeControl* oldCtrl = FindFocused();
    if ( oldCtrl )
        {
        oldCtrl->SetFocus( EFalse, ENoDrawNow );
        }

    iToField->SetFocus( ETrue, ENoDrawNow );
    iFocused = iToField;
    }

// ---------------------------------------------------------------------------
// CNcsHeaderContainer::FocusAttachmentField
// ---------------------------------------------------------------------------
//
void CNcsHeaderContainer::FocusAttachmentField()
    {
    FUNC_LOG;
    CCoeControl* oldCtrl = FindFocused();
    if ( oldCtrl )
        {
        oldCtrl->SetFocus( EFalse, ENoDrawNow );
        }

    iAttachmentField->SetFocus( ETrue, ENoDrawNow );
    iFocused = iAttachmentField;
    }

// ---------------------------------------------------------------------------
// Sets focus to the first visible header field from the bottom.
// ---------------------------------------------------------------------------
//
void CNcsHeaderContainer::SetFocusToBottom( TDrawNow aDrawNow )
    {
    FUNC_LOG;
    CCoeControl* oldCtrl = FindFocused();
    if ( oldCtrl )
        {
        oldCtrl->SetFocus( EFalse, aDrawNow );
        }

    CCoeControlArray::TCursor cur = Components().End();
    cur.Prev();
    CCoeControl* newControl = cur.Control<CCoeControl>();
    if ( newControl && newControl == iAttachmentField )
        {
        // set focus to the last attachment
        TInt count = GetAttachmentCount();
        iAttachmentField->SetFocusedAttachmentLabelIndex( count - 1 );
        }
    SetFocus( ETrue, aDrawNow );
    }

// ---------------------------------------------------------------------------
// CNcsHeaderContainer::AreAddressFieldsEmpty
// ---------------------------------------------------------------------------
//
TBool CNcsHeaderContainer::AreAddressFieldsEmpty() const
	{
    FUNC_LOG;
    return ( IsToFieldEmpty() && IsCcFieldEmpty() && IsBccFieldEmpty() ) || 
            iRALInProgress;
	}

// ---------------------------------------------------------------------------
// CNcsHeaderContainer::HandleDynamicVariantSwitchL
// ---------------------------------------------------------------------------
//
void CNcsHeaderContainer::HandleDynamicVariantSwitchL()
    {
    FUNC_LOG;
    }

// ---------------------------------------------------------------------------
// CNcsHeaderContainer::HandleSkinChangeL
// ---------------------------------------------------------------------------
//
void CNcsHeaderContainer::HandleSkinChangeL()
    {
    FUNC_LOG;
    if ( iAacListBox )
        {
        iAacListBox->HandleResourceChange( KAknsMessageSkinChange );
        }
    }

// ---------------------------------------------------------------------------
// CNcsHeaderContainer::LayoutLineCount
// ---------------------------------------------------------------------------
//
TInt CNcsHeaderContainer::LayoutLineCount() const
    {
    FUNC_LOG;
    TInt totalLineCount( 0 );
    CCoeControlArray::TCursor cur = Components().Begin();
    do
        {
        totalLineCount += ToNcsControl( cur )->LayoutLineCount();                       
        } 
    while ( cur.Next() );
    
    return totalLineCount;
    }


// ---------------------------------------------------------------------------
// CNcsHeaderContainer::IsAddressInputField
// ---------------------------------------------------------------------------
//
TBool CNcsHeaderContainer::IsAddressInputField(
        const CCoeControl* aControl ) const
    {
    FUNC_LOG;

    TBool ret = EFalse;

    if ( aControl != NULL && 
            ( aControl == iToField ||
              aControl == iCcField ||
              aControl == iBccField ) )
        {
        ret = ETrue;
        }
    
    return ret;
    }

// ---------------------------------------------------------------------------
// CNcsHeaderContainer::ExecuteRemoteSearchL
// ---------------------------------------------------------------------------
//
CNcsEmailAddressObject* CNcsHeaderContainer::ExecuteRemoteSearchL(
    CPbkxRemoteContactLookupServiceUiContext::TResult::TExitReason& /*aExitReason*/,
    const TDesC& aSearchText )
    {
    FUNC_LOG;
    const TInt KMaxLength = 255;
    RBuf displayname;
    displayname.CreateL( KMaxLength );
    CleanupClosePushL( displayname );

    RBuf emailAddress;
    emailAddress.CreateL( KMaxLength );
    CleanupClosePushL( emailAddress );

    TBool contactSelected = 
        CFsDelayedLoader::InstanceL()->GetContactHandlerL()->
            GetNameAndEmailFromRemoteLookupL( 
                iMailBox, aSearchText, displayname, emailAddress );

    CNcsEmailAddressObject* address = NULL;
    if ( contactSelected )
        {
        if ( !displayname.Length() )
            {
            address = 
                CNcsEmailAddressObject::NewL( emailAddress, emailAddress );
            }
        else
            {
            address = 
                CNcsEmailAddressObject::NewL( displayname, emailAddress );
            }
        }

    CleanupStack::PopAndDestroy( &emailAddress );
    CleanupStack::PopAndDestroy( &displayname );

    return address;
    }
   	
// -----------------------------------------------------------------------------
// CNcsHeaderContainer::ChangeMskCommandL
// Utility function to change the command ID and label on the middle soft key
// -----------------------------------------------------------------------------
void CNcsHeaderContainer::ChangeMskCommandL( TInt aLabelResourceId )
    {
    FUNC_LOG;
    CEikButtonGroupContainer* cba = CEikButtonGroupContainer::Current();
    if ( cba ) 
        {
        cba->SetCommandL( CEikButtonGroupContainer::EMiddleSoftkeyPosition, 
                            aLabelResourceId );
        cba->DrawDeferred();
        }
    }

// -----------------------------------------------------------------------------
// CNcsHeaderContainer::SwitchChangeMskOff
// sets up iSwitchChangeMskOff falg 
// -----------------------------------------------------------------------------
void CNcsHeaderContainer::SwitchChangeMskOff( TBool aTag )
    {
    iSwitchChangeMskOff = aTag;
    }

// -----------------------------------------------------------------------------
// CNcsHeaderContainer::OpenPhonebookL
// 
// -----------------------------------------------------------------------------
void CNcsHeaderContainer::OpenPhonebookL()
    {
    CNcsComposeViewContainer* container = 
        static_cast<CNcsComposeViewContainer*>( &iParent );
    container->AppendAddressesL();
    }

void CNcsHeaderContainer::FixSemicolonInAddressFieldsL()
	{
		iToField->FixSemicolonAtTheEndL();
		iCcField->FixSemicolonAtTheEndL();
		iBccField->FixSemicolonAtTheEndL();
	}

TBool CNcsHeaderContainer::IsRemoteSearchInprogress() const
    {
    return iRALInProgress;
    }

// ---------------------------------------------------------------------------
// Commits changes made to given input field.
// ---------------------------------------------------------------------------
//
void CNcsHeaderContainer::CommitFieldL( CCoeControl* aField )
    {
    FUNC_LOG;
    CNcsComposeViewContainer* container = 
        static_cast<CNcsComposeViewContainer*>( &iParent );
    if ( container && aField )
        {
        if ( aField == iToField )
            {
			if( iToField->TextEditor()->SelectionLength() )
				{
				iToField->TextEditor()->HandleTextChangedL();
				}
            container->CommitL( EToField );
            }
        else if ( aField == iCcField )
            {
			if( iCcField->TextEditor()->SelectionLength() )
				{
				iCcField->TextEditor()->HandleTextChangedL();
				}
            container->CommitL( ECcField );
            }
        else if ( aField == iBccField )
            {
			if( iBccField->TextEditor()->SelectionLength() )
				{
				iBccField->TextEditor()->HandleTextChangedL();
				}
            container->CommitL( EBccField );
            }
        else if ( aField == iSubjectField ) 
            {
			if( iSubjectField->Editor()->SelectionLength() )
				{
				iSubjectField->Editor()->HandleTextChangedL();
				}
            container->CommitL( ESubjectField );
            }
        }
    }

// -----------------------------------------------------------------------------
// CNcsHeaderContainer::DoScroll
// -----------------------------------------------------------------------------
// 
void CNcsHeaderContainer::DoScroll()
    {
    // scroll the screen if the cursor goes beyond the screen
    CNcsComposeViewContainer& parent = static_cast<CNcsComposeViewContainer&>( iParent );
    
    TInt screenPos( -Position().iY );
    TInt cursorPos( CursorPosition() );
    TInt lineHeight( Rect().Height() / LineCount() );
    TInt screenHeight( parent.Rect().Height() );

    if ( cursorPos - lineHeight < screenPos )
        {
        screenPos = cursorPos - lineHeight;             
        }
    else if( cursorPos + lineHeight > screenPos + screenHeight )
        {
        screenPos = cursorPos + lineHeight - screenHeight;
        }

    parent.Scroll( screenPos );
    }

// ---------------------------------------------------------------------------
// CNcsHeaderContainer::SetPhysicsEmulationOngoing
// ---------------------------------------------------------------------------
//
void CNcsHeaderContainer::SetPhysicsEmulationOngoing( TBool aPhysOngoing )
    {
    iToField->SetPhysicsEmulationOngoing( aPhysOngoing );
    iCcField->SetPhysicsEmulationOngoing( aPhysOngoing );
    iBccField->SetPhysicsEmulationOngoing( aPhysOngoing );
    iSubjectField->SetPhysicsEmulationOngoing( aPhysOngoing );
    }

// ---------------------------------------------------------------------------
// CNcsHeaderContainer::AttachmentOpenL
// ---------------------------------------------------------------------------
//
void CNcsHeaderContainer::AttachmentOpenL()
    {
    CNcsComposeViewContainer& parent = 
          static_cast<CNcsComposeViewContainer&>( iParent );

    parent.HandleAttachmentOpenCommandL();
    }

// ---------------------------------------------------------------------------
// CNcsHeaderContainer::AttachmentRemoveL
// ---------------------------------------------------------------------------
//
void CNcsHeaderContainer::AttachmentRemoveL()
    {
    CNcsComposeViewContainer& parent = 
          static_cast<CNcsComposeViewContainer&>( iParent );

    parent.HandleAttachmentRemoveCommandL();
    }