/*

* Copyright (c) 2007-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: This file implements classes CESMRNcsAifEntry, CESMRNcsAifEditor.

*

*/

#include "emailtrace.h"

#include "cesmrncsaifeditor.h"

#include <AknsDrawUtils.h>

#include <s32mem.h>

#include <txtrich.h>

#include <baclipb.h>

#include <PtiDefs.h>

#include <StringLoader.h>

#include <eikedwin.h>

#ifndef FF_CMAIL_INTEGRATION

#include <txtclipboard.h>

#endif // FF_CMAIL_INTEGRATION

#include "cesmrncsemailaddressobject.h"

#include "cesmrcontacthandler.h"

#include "esmrfieldbuilderdef.h"

// ======== MEMBER FUNCTIONS ========

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

// CESMRNcsAifEntry::NewL

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

//

CESMRNcsAifEntry* CESMRNcsAifEntry::NewL(

    const CESMRNcsEmailAddressObject& addr,

    TBool aDisplayFull )

    {

    FUNC_LOG;

    CESMRNcsAifEntry* self = new (ELeave) CESMRNcsAifEntry( aDisplayFull );

    CleanupStack::PushL(self);

    self->ConstructL( addr );

    CleanupStack::Pop(self);

    return self;

    }

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

// CESMRNcsAifEntry::NewL

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

//

CESMRNcsAifEntry* CESMRNcsAifEntry::NewL(

    const TDesC& aDn,

    const TDesC& aEml,

    TBool aDisplayFull )

    {

    FUNC_LOG;

    CESMRNcsAifEntry* self = new ( ELeave ) CESMRNcsAifEntry( aDisplayFull );

    CleanupStack::PushL(self);

    self->ConstructL( aDn, aEml);

    CleanupStack::Pop( self );

    return self;

    }

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

// CESMRNcsAifEntry::~CESMRNcsAifEntry

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

//

CESMRNcsAifEntry::~CESMRNcsAifEntry()

    {

    FUNC_LOG;

    delete iAddress;

    delete iDisplayString;

    }

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

// CESMRNcsAifEntry::CESMRNcsAifEntry

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

//

CESMRNcsAifEntry::CESMRNcsAifEntry( TBool aDisplayFull ) :

    iDisplayFull( aDisplayFull )

    {

    FUNC_LOG;

    //do nothing

    }

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

// CESMRNcsAifEntry::ConstructL

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

//

void CESMRNcsAifEntry::ConstructL( const TDesC& aDn, const TDesC& aEml )

    {

    FUNC_LOG;

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

    ConstructL();

    }

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

// CESMRNcsAifEntry::ConstructL

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

//

void CESMRNcsAifEntry::ConstructL( const CESMRNcsEmailAddressObject& aAddress )

    {

    FUNC_LOG;

    iAddress = CESMRNcsEmailAddressObject::NewL( aAddress );

    ConstructL();

    }

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

// CESMRNcsAifEntry::ConstructL

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

//

void CESMRNcsAifEntry::ConstructL()

    {

    FUNC_LOG;

    SetDisplayStringL();

    }

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

// CESMRNcsAifEntry::SetDisplayStringL

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

//

void CESMRNcsAifEntry::SetDisplayStringL()

    {

    FUNC_LOG;

    if ( iDisplayString )

        {

        delete iDisplayString;

        iDisplayString = NULL;

        }

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

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

    TInt dnameLength = dname.Length();

    TInt emailLength = email.Length();

    TInt length;

    if ( !iIsDup && !iDisplayFull )

        {

        length = dnameLength > 0 ? dnameLength : emailLength;

        length += 1; // ';'

        iDisplayString = HBufC::NewL( length );

        TPtr ptr = iDisplayString->Des();

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

        ptr.Append( KAddressDelimeterSemiColon );

        }

    else

        {

        // Display, Name <display.name(at)dn.com>;

        length = dnameLength + emailLength + 4;

        iDisplayString = HBufC::NewL( length );

        TPtr ptr = iDisplayString->Des();

        ptr.Append( dname );

        _LIT(KLeft, " <");

        ptr.Append( KLeft );

        ptr.Append( email );

        _LIT(KRight, ">");

        ptr.Append( KRight );

        ptr.Append( KAddressDelimeterSemiColon );

        }

    }

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

// constructor/destructor

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

//

CESMRNcsAifEditor::CESMRNcsAifEditor( CESMRContactHandler& aContactHandler, HBufC* aDefaultText ) :

    CESMRNcsEditor( aDefaultText ), iContactHandler( aContactHandler )

    {

    FUNC_LOG;

    SetEdwinObserver( this );

    }

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

// constructor/destructor

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

//

CESMRNcsAifEditor::~CESMRNcsAifEditor()

    {

    FUNC_LOG;

    iArray.ResetAndDestroy();

    iAddressArray.Reset();

    }

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

// CESMRNcsAifEditor::CursorLineNumber() const

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

//

TInt CESMRNcsAifEditor::CursorLineNumber() const

    {

    FUNC_LOG;

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

    ret++;

    if( ret > KMaxAddressFieldLines )

        {

        ret = KMaxAddressFieldLines;

        }

    return ret;

    }

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

// CESMRNcsAifEditor::LineCount() const

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

//

TInt CESMRNcsAifEditor::LineCount() const

    {

    FUNC_LOG;

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

    lineCount++;

    if( lineCount > KMaxAddressFieldLines )

        {

        lineCount = KMaxAddressFieldLines;

        }

    return lineCount;

    }

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

// CESMRNcsAifEditor::OfferKeyEventL()

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

//

TKeyResponse CESMRNcsAifEditor::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

    // We must do this before select sincey 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 );

        }

    if ( ret == EKeyWasNotConsumed )

        {

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

        }

    return ret;

    }

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

// CESMRNcsAifEditor::HandleEdwinEventL()

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

// Otherwise the character entry is added through OfferKeyEvent

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

//

void CESMRNcsAifEditor::HandleEdwinEventL( CEikEdwin* /*aEdwin*/, TEdwinEvent aEventType )

    {

    FUNC_LOG;

    if ( aEventType == MEikEdwinObserver::EEventTextUpdate )

        {

        HandleContactDeletionL();

        HandleTextUpdateL();

        }

    else if ( aEventType == MEikEdwinObserver::EEventNavigation )

        {

        HandleNavigationEventL();

        }

    }

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

// CESMRNcsAifEditor::SetEditorSelectionL()

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

//

TKeyResponse CESMRNcsAifEditor::SetEditorSelectionL( const TKeyEvent& aKeyEvent, TEventCode aType )

    {

    FUNC_LOG;

    TKeyResponse response = EKeyWasNotConsumed;

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

        {

        response = CESMRNcsEditor::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;

                }

            }

        }

    // Close the address popup if we handled the event

    if ( response == EKeyWasConsumed )

        {

        iAddressPopupList->ClosePopupContactListL();

        }

    return response;

    }

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

// CESMRNcsAifEditor::HandleContactDeletionL()

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

//

TKeyResponse CESMRNcsAifEditor::HandleContactDeletionL(

        const TKeyEvent& aKeyEvent,

        TEventCode aType)

    {

    FUNC_LOG;

    TKeyResponse response  = EKeyWasNotConsumed;

    if ( SelectionLength() && aType == EEventKey

        && !IsNavigationKey( 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.

            UpdateDuplicateEntryMarkings();

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

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

                }

            }

        }

    return response;

    }

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

// CESMRNcsAifEditor::DoCharChangeL

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

//

void CESMRNcsAifEditor::DoCharChangeL()

    {

    FUNC_LOG;

    RecalculateEntryPositions();

    TChar previousChar = CharAtPos( CursorPos() - 1 );

    TBool sentinel = ( previousChar == KSemiColon ||

        previousChar == KComma );

    if ( sentinel )

        {

        // if comma was pressed we replace it with semicolon

        if ( previousChar == KComma )

            {

            CPlainText* text = Text();

            text->DeleteL( CursorPos() - 1, 1 );

            text->InsertL( CursorPos() - 1, KSemiColon );

            }

        TBool check = ParseNewAddressL();

        }

    UpdateAddressAutoCompletionL();

    }

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

// CESMRNcsAifEditor::CharAtPos

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

//

TChar CESMRNcsAifEditor::CharAtPos( TInt aPos ) const

    {

    FUNC_LOG;

    if ( aPos >= 0 && aPos < TextLength() )

        {

        TBuf<1> buf;

        Text()->Extract( buf, aPos, 1 );

        return buf[0];

        }

    else

        {

        return 0;

        }

    }

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

// CESMRNcsAifEditor::SetAddressesL()

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

//

void CESMRNcsAifEditor::SetAddressesL( const RPointerArray<CESMRNcsEmailAddressObject>& aAddresses )

    {

    FUNC_LOG;

    iArray.ResetAndDestroy();

    AppendAddressesL( aAddresses );

    }

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

// CESMRNcsAifEditor::AppendAddressesL()

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

//

void CESMRNcsAifEditor::AppendAddressesL( const RPointerArray<CESMRNcsEmailAddressObject>& aAddresses )

    {

    FUNC_LOG;

    iArray.ReserveL( iArray.Count() + aAddresses.Count() );

    CESMRNcsAifEntry* entry = NULL;

    for (int i=0;i<aAddresses.Count();i++)

        {

        CESMRNcsEmailAddressObject* address = aAddresses[i];

        entry = CESMRNcsAifEntry::NewL( *address, address->DisplayFull() );

        int idx;

        // Check for duplicate display names

        for ( idx=0; idx<iArray.Count(); idx++ )

            {

            if ( iArray[idx]->IsSameDN( *entry ) )

                {

                iArray[idx]->SetDup();

                entry->SetDup();

                }

            }

        CleanupStack::PushL( entry );

        iArray.AppendL( entry );

        CleanupStack::Pop( entry );

        }

    RepositionEntriesL( entry );

    }

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

// CESMRNcsAifEditor::GetAddressesL()

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

//

const RPointerArray<CESMRNcsEmailAddressObject>& CESMRNcsAifEditor::GetAddressesL()

    {

    // Clear the existing array since it may be out of sync

    iAddressArray.Reset();

    for (int i=0;i<iArray.Count();i++)

        {

        iAddressArray.AppendL(&iArray[i]->Address());

        }

    return iAddressArray;

    }

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