/*

* 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: This file implements classes CNcsAifEntry, CNcsAifEditor. 

*

*/

#include "emailtrace.h"

#include <AknsDrawUtils.h>

#include <s32mem.h>

#include <txtrich.h>

#include <baclipb.h>

#include <PtiDefs.h>

#include <StringLoader.h>

#include <FreestyleEmailUi.rsg>

#include "ncsaifeditor.h"

#include "ncsconstants.h"

#include "ncsaddressinputfield.h"

#include "ncsutility.h"

#include "FreestyleEmailUiUtilities.h"

#include "ncsemailaddressobject.h"

#include "FreestyleEmailUiLayoutData.h"

#include "FSDelayedLoader.h"

#include "FSEmail.pan"

const TChar KCharAddressDelimeterSemiColon = ';';

const TChar KCharAddressDelimeterComma = ',';

const TChar KCharSpace = ' ';

const TChar KCharAt = '@';

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

// CNcsAifEntry::NewL

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

//

CNcsAifEntry* CNcsAifEntry::NewL( const CNcsEmailAddressObject& aAddr )

    {

    FUNC_LOG;

    CNcsAifEntry* self = new (ELeave) CNcsAifEntry;

    CleanupStack::PushL(self);

    self->ConstructL( aAddr );

    CleanupStack::Pop(self);

    return self;

    }

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

// CNcsAifEntry::NewL

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

//

CNcsAifEntry* CNcsAifEntry::NewL(

    const TDesC& aDn, 

    const TDesC& aEml,

    TBool aDisplayFull )

    {

    FUNC_LOG;

    CNcsAifEntry* self = new ( ELeave ) CNcsAifEntry;

    CleanupStack::PushL( self );

    self->ConstructL( aDn, aEml, aDisplayFull );

    CleanupStack::Pop( self );

    return self;

    }

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

// CNcsAifEntry::~CNcsAifEntry

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

//

CNcsAifEntry::~CNcsAifEntry()

    {

    FUNC_LOG;

    delete iAddress;

    delete iDisplayString;

    }

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

// CNcsAifEntry::CNcsAifEntry

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

//

CNcsAifEntry::CNcsAifEntry() 

    {

    FUNC_LOG;

    }

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

// CNcsAifEntry::ConstructL

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

//

void CNcsAifEntry::ConstructL( const TDesC& aDn, const TDesC& aEml, TBool aDisplayFull )

    {

    FUNC_LOG;

    iAddress = CNcsEmailAddressObject::NewL( aDn, aEml );

    iAddress->SetDisplayFull( aDisplayFull );

    ConstructL();

    }

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

// CNcsAifEntry::ConstructL

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

//

void CNcsAifEntry::ConstructL( const CNcsEmailAddressObject& aAddress )

    {

    FUNC_LOG;

    iAddress = CNcsEmailAddressObject::NewL( aAddress );

    ConstructL();

    }

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

// CNcsAifEntry::ConstructL

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

//

void CNcsAifEntry::ConstructL() 

    {

    FUNC_LOG;

    SetDisplayStringL();

    }

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

// CNcsAifEntry::SetDisplayStringL

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

//

void CNcsAifEntry::SetDisplayStringL() 

    {

    FUNC_LOG;

    delete iDisplayString;

    iDisplayString = NULL;

    const TDesC& dname = iAddress->DisplayName();

    const TDesC& email = iAddress->EmailAddress();

    TInt dnameLength = dname.Length();

    TInt emailLength = email.Length();

    TBool displayFull = iAddress->DisplayFull() || iIsDup;

    TInt length;

    // Show only display name OR email address if showing both is not required

    // or if display name doesn't contain anything but the email address

    // or if the display name is empty

    if ( !displayFull ||

         dname == email ||

         !dnameLength )

        {

        length = dnameLength > 0 ? dnameLength : emailLength;

        length += KEmailAddressSeparator().Length(); // ';'

        iDisplayString = HBufC::NewL( length );

        TPtr ptr = iDisplayString->Des();

        ptr.Append( dname.Length() > 0 ? dname : email );

        ptr.Append( KEmailAddressSeparator );

        }

    // Otherwise, show both display name and email addresss

    else 

        {

        // Display, Name;

        length = dnameLength + emailLength + 

            KSpace().Length() + 

            KEmailAddressDecorationHead().Length() +

            KEmailAddressDecorationTail().Length() +

            KEmailAddressSeparator().Length();

        iDisplayString = HBufC::NewL( length );

        TPtr ptr = iDisplayString->Des();

        ptr.Append( dname );

        ptr.Append( KSpace );

        ptr.Append( KEmailAddressDecorationHead );

        ptr.Append( email );

        ptr.Append( KEmailAddressDecorationTail );

        ptr.Append( KEmailAddressSeparator );

        }

    }

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

// CNcsAifEntry::SetDupL

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

//

void CNcsAifEntry::SetDupL( TBool aDup ) 

    {

    FUNC_LOG;

    if ( iIsDup != aDup )

        {

        iIsDup = aDup;

        // Display string needs to be recreated unless there's no

        // meaningful display name

        if ( iAddress->DisplayName().Length() &&

             iAddress->DisplayName() != iAddress->EmailAddress() )

            {

            SetDisplayStringL();

            }

        }

    }

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

// CNcsAifEntry::IsSameDN

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

//

TBool CNcsAifEntry::IsSameDN( const CNcsAifEntry& entry ) const

    {

    FUNC_LOG;

    const TDesC& ownDn = Address().DisplayName();

    const TDesC& otherDn = entry.Address().DisplayName();

    return ownDn.Compare( otherDn ) == 0;

    }

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

// constructor/destructor

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

//

CNcsAifEditor::CNcsAifEditor(

    MNcsFieldSizeObserver* aSizeObserver, const TDesC& aCaptionText ) 

    : CNcsEditor( aSizeObserver, ETrue, ENcsEditorAddress, aCaptionText ), iAddressPopupList( NULL ),

    iAddLeftover( ETrue )

    {

    FUNC_LOG;

	SetEdwinObserver( this );

    }

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

// second phase constructor

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

//

void CNcsAifEditor::ConstructL( const CCoeControl* aParent,

        TInt aNumberOfLines,

        TInt aTextLimit )

    {

    FUNC_LOG;

    CNcsEditor::ConstructL( aParent, aNumberOfLines, aTextLimit );

    iAsyncCallBack = new (ELeave) CAsyncCallBack( CActive::EPriorityStandard );

    }

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

// destructor

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

//

CNcsAifEditor::~CNcsAifEditor()

    {

    FUNC_LOG;

	iArray.ResetAndDestroy();

	iAddressArray.Reset();

	if ( iAsyncCallBack )

	    {

	    iAsyncCallBack->Cancel();

	    delete iAsyncCallBack;

	    }

    }

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

// CNcsAifEditor::CursorLineNumber() const

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

//

TInt CNcsAifEditor::CursorLineNumber() const

    {

    FUNC_LOG;

    TInt ret = iLayout->GetLineNumber( CursorPos() );

    ret++;

    return ret;    

    }

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

// CNcsAifEditor::LineCount() const

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

//    

TInt CNcsAifEditor::LineCount() const

    {

    FUNC_LOG;

    TInt lineCount = iLayout->GetLineNumber( TextLength() );

    lineCount++;

    return lineCount;

    }

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

// CNcsAifEditor::OfferKeyEventL()

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

//

TKeyResponse CNcsAifEditor::OfferKeyEventL( const TKeyEvent& aKeyEvent,

    TEventCode aType )

    {

    FUNC_LOG;

    TKeyResponse ret = EKeyWasNotConsumed;

    // check if we are copying

    if ( ret == EKeyWasNotConsumed )

        {

        ret = CopyEntriesToClipboardL( aKeyEvent, aType );

        }

    // Check if we need to delete a contact

    // This is done before select since they key off of the same key code.

    if ( ret == EKeyWasNotConsumed )

        {

        ret = HandleContactDeletionL( aKeyEvent, aType );

        }

    // Check if we need to highlight a contact

    if ( ret == EKeyWasNotConsumed )

        {

        ret = SetEditorSelectionL( aKeyEvent, aType );

        }

    //when press a key down, record the coursor position

    if ( aType == EEventKeyDown )

    	{

    	iLastTimeCursorPos = CursorPos();

    	}

    if ( ret == EKeyWasNotConsumed )

        {

        // enter completes the address entry

        if( aType == EEventKey && (aKeyEvent.iCode == EKeyEnter || 

        	aKeyEvent.iScanCode == EStdKeyEnter) )

        	{

        	// make sure there is really some text inputted 

            TInt cursorPos( CursorPos() );

            TCursorSelection selection = NonEntryTextAtPos( cursorPos );

            TInt length( selection.Length() );

            HBufC* text = HBufC::NewLC( length );

            TPtr ptr = text->Des();

            Text()->Extract( ptr, selection.LowerPos(), length );

            ptr.Trim();

            // complete the entry by adding a semicolon, 

            // address will be added in HandleTextUpdateL

            if( ptr.Length() > 0 )

            	{            

				Text()->InsertL( cursorPos, KCharAddressDelimeterSemiColon );

				HandleTextChangedL();

				SetCursorPosL( cursorPos + 1, EFalse );

            	}

            CleanupStack::PopAndDestroy( text );            

        	}

        iTextSelection = Selection();        

        ret = CNcsEditor::OfferKeyEventL( aKeyEvent, aType );

        }

    return ret;

    }

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

// CNcsAifEditor::HandleEdwinEventL()

// This function gets called if a character is entered through the FEP.

// Otherwise the character entry is added through OfferKeyEvent

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

//

void CNcsAifEditor::HandleEdwinEventL( CEikEdwin* /*aEdwin*/,

    TEdwinEvent aEventType )

    {

    FUNC_LOG;

    if ( aEventType == MEikEdwinObserver::EEventTextUpdate )

        {

        // Remove any invalid entries. This is needed when entries have been marked

        // and have got replaced with some key event handled by FEP.

        CheckAndRemoveInvalidEntriesL();

        // Make a deferred call to HandleTextUpdateL() because it may result in

        // changing the text field contents, and doing so directly within HandleEdwinEventL

        // causes problems for the FEP in some special cases.

        HandleTextUpdateDeferred();

        }

    else if ( aEventType == MEikEdwinObserver::EEventNavigation )

        {

        iTextSelection = Selection();

        HandleNavigationEventL();

        }

    }

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

// CNcsAifEditor::SetEditorSelectionL()

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

//   

TKeyResponse CNcsAifEditor::SetEditorSelectionL( const TKeyEvent& aKeyEvent,

    TEventCode aType )

    {

    FUNC_LOG;

    TKeyResponse response = EKeyWasNotConsumed;

    CNcsAifEntry* entry = NULL;

    TCursorSelection selection = Selection();

    // Moving to a new line is a special case.

    // We need to offer the key to the editor control first so it can

    // move the cursor for us.  Then we check if it's in an entry.

    if ( aKeyEvent.iCode == EKeyUpArrow || aKeyEvent.iCode == EKeyDownArrow )

        {

        CompleteEntryL();

        response = CNcsEditor::OfferKeyEventL( aKeyEvent,aType );

        if ( response == EKeyWasConsumed ) 

            {

            // We're moving to a new line.

            entry = GetEntryAt( CursorPos() );

            if ( entry )

                {

                SetSelectionL( entry->iCursorPos, entry->iAnchorPos );

                }

            }

        }

    // Check if the cursor is in any of the addresses

    else if( aKeyEvent.iCode == EKeyLeftArrow || aKeyEvent.iCode == EKeyBackspace ) 

        {

        // We're moving left, but haven't yet.

        entry = GetEntryAt( CursorPos(), EDirectionLeft );

        if ( entry )

            {

            if ( selection.Length() && aKeyEvent.iCode == EKeyLeftArrow)

                {

                // Adds or removes the entry from the current selection.

                SetSelectionL( entry->LowerPos(), selection.iAnchorPos );

                response = EKeyWasConsumed;

                }

            else if ( !selection.Length() )

                {

                SetSelectionL( entry->LowerPos(), entry->HigherPos() );

                response = EKeyWasConsumed;

                }

            }

        }

    else if( aKeyEvent.iCode == EKeyRightArrow || aKeyEvent.iCode == EKeyDelete )

        {

        // We're moving right, but haven't yet.

        entry = GetEntryAt( CursorPos(), EDirectionRight );

        if ( entry )

            {

            if ( selection.Length() && aKeyEvent.iCode == EKeyRightArrow  )

                {

                // Adds or removes the entry form the current selection.

                SetSelectionL( entry->HigherPos(), selection.iAnchorPos );

                response = EKeyWasConsumed;

                }

            else if ( !selection.Length() )

                {

                SetSelectionL( entry->HigherPos(), entry->LowerPos() );

                response = EKeyWasConsumed;

                }

            }

        }

    // to fix problems with updating CBA when hash key is pressed and hold

    else if ( aKeyEvent.iScanCode == EStdKeyHash ) 

        {

        iAddressPopupList->ClosePopupContactListL();

        }

    // Close the address popup if we handled the event

    if ( response == EKeyWasConsumed )

        {

        iAddressPopupList->ClosePopupContactListL();

        }

    return response;

    }

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

// CNcsAifEditor::HandleContactDeletionL()

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

//

TKeyResponse CNcsAifEditor::HandleContactDeletionL( const TKeyEvent& aKeyEvent,

    TEventCode aType )

    {

    FUNC_LOG;

    TKeyResponse response  = EKeyWasNotConsumed;

    if ( SelectionLength() && aType == EEventKey 

        && IsCharacterKey( aKeyEvent ) )

        {

        // Delete highlighted entries.

        TCursorSelection selection = Selection();

        TBool entryDeleted = EFalse;

        for ( TInt ii = iArray.Count() - 1; ii >= 0; --ii )

            {

            if ( iArray[ii]->LowerPos() >= selection.LowerPos() &&

                iArray[ii]->HigherPos() <= selection.HigherPos() )

                {

                delete iArray[ii];

                iArray.Remove( ii );

                entryDeleted = ETrue;

                }

            }

        if ( entryDeleted )

            {

            // Check that duplicate entries are correctly marked.

            UpdateDuplicateEntryMarkingsL();

            // Set the cursor after the entry before the ones we just deleted

            CNcsAifEntry* entry = NULL;

            for ( TInt ii = iArray.Count() - 1; ii >= 0; --ii )

                {

                if ( iArray[ii]->HigherPos() <= selection.LowerPos() )

                    {

                    entry = iArray[ii];

                    break;

                    }

                }

            ClearSelectionL();

            RepositionEntriesL( entry );

            // The key event is set consumed only on delete and backpace

            // events, other events need to be forwarded to the editor.

            if ( aKeyEvent.iCode == EKeyDelete || 

                 aKeyEvent.iCode == EKeyBackspace )

                {

                response = EKeyWasConsumed;

                }

            }

        }