1 /*

     2 * Copyright (c) 2007 Nokia Corporation and/or its subsidiary(-ies). 

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description: This file implements classes CNcsAifEntry, CNcsAifEditor. 

    15 *

    16 */

    17 

    18 

    19 

    20 #include "emailtrace.h"

    21 #include <AknsDrawUtils.h>

    22 #include <s32mem.h>

    23 #include <txtrich.h>

    24 #include <baclipb.h>

    25 #include <PtiDefs.h>

    26 #include <StringLoader.h>

    27 #include <FreestyleEmailUi.rsg>

    28 

    29 #include "ncsaifeditor.h"

    30 #include "ncsconstants.h"

    31 #include "ncsaddressinputfield.h"

    32 #include "ncsutility.h"

    33 #include "FreestyleEmailUiUtilities.h"

    34 #include "ncsemailaddressobject.h"

    35 #include "FreestyleEmailUiLayoutData.h"

    36 #include "FSDelayedLoader.h"

    37 #include "FSEmail.pan"

    38 

    39 const TChar KCharAddressDelimeterSemiColon = ';';

    40 const TChar KCharAddressDelimeterComma = ',';

    41 const TChar KCharSpace = ' ';

    42 const TChar KCharAt = '@';

    43 

    44 // ---------------------------------------------------------------------------

    45 // CNcsAifEntry::NewL

    46 // ---------------------------------------------------------------------------

    47 //

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

    49     {

    50     FUNC_LOG;

    51     CNcsAifEntry* self = new (ELeave) CNcsAifEntry;

    52     CleanupStack::PushL(self);

    53     self->ConstructL( aAddr );

    54     CleanupStack::Pop(self);

    55     return self;

    56     }

    57 

    58 // ---------------------------------------------------------------------------

    59 // CNcsAifEntry::NewL

    60 // ---------------------------------------------------------------------------

    61 //

    62 CNcsAifEntry* CNcsAifEntry::NewL(

    63     const TDesC& aDn, 

    64     const TDesC& aEml,

    65     TBool aDisplayFull )

    66     {

    67     FUNC_LOG;

    68     CNcsAifEntry* self = new ( ELeave ) CNcsAifEntry;

    69     CleanupStack::PushL( self );

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

    71     CleanupStack::Pop( self );

    72     return self;

    73     }

    74 

    75 // ---------------------------------------------------------------------------

    76 // CNcsAifEntry::~CNcsAifEntry

    77 // ---------------------------------------------------------------------------

    78 //

    79 CNcsAifEntry::~CNcsAifEntry()

    80     {

    81     FUNC_LOG;

    82     delete iAddress;

    83     delete iDisplayString;

    84     }

    85 

    86 // ---------------------------------------------------------------------------

    87 // CNcsAifEntry::CNcsAifEntry

    88 // ---------------------------------------------------------------------------

    89 //

    90 CNcsAifEntry::CNcsAifEntry() 

    91     {

    92     FUNC_LOG;

    93     }

    94 

    95 // ---------------------------------------------------------------------------

    96 // CNcsAifEntry::ConstructL

    97 // ---------------------------------------------------------------------------

    98 //

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

   100     {

   101     FUNC_LOG;

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

   103     iAddress->SetDisplayFull( aDisplayFull );

   104     ConstructL();

   105     }

   106 

   107 // ---------------------------------------------------------------------------

   108 // CNcsAifEntry::ConstructL

   109 // ---------------------------------------------------------------------------

   110 //

   111 void CNcsAifEntry::ConstructL( const CNcsEmailAddressObject& aAddress )

   112     {

   113     FUNC_LOG;

   114     iAddress = CNcsEmailAddressObject::NewL( aAddress );

   115     ConstructL();

   116     }

   117 

   118 // ---------------------------------------------------------------------------

   119 // CNcsAifEntry::ConstructL

   120 // ---------------------------------------------------------------------------

   121 //

   122 void CNcsAifEntry::ConstructL() 

   123     {

   124     FUNC_LOG;

   125     SetDisplayStringL();

   126     }

   127 

   128 // ---------------------------------------------------------------------------

   129 // CNcsAifEntry::SetDisplayStringL

   130 // ---------------------------------------------------------------------------

   131 //

   132 void CNcsAifEntry::SetDisplayStringL() 

   133     {

   134     FUNC_LOG;

   135     delete iDisplayString;

   136     iDisplayString = NULL;

   137 

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

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

   140     

   141     TInt dnameLength = dname.Length();

   142     TInt emailLength = email.Length();

   143     

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

   145     

   146     TInt length;

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

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

   149     // or if the display name is empty

   150     if ( !displayFull ||

   151          dname == email ||

   152          !dnameLength )

   153         {

   154         length = dnameLength > 0 ? dnameLength : emailLength;

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

   156         

   157         iDisplayString = HBufC::NewL( length );

   158         TPtr ptr = iDisplayString->Des();

   159         

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

   161         ptr.Append( KEmailAddressSeparator );

   162         }

   163     

   164     // Otherwise, show both display name and email addresss

   165     else 

   166         {

   167         // Display, Name;

   168         length = dnameLength + emailLength + 

   169             KSpace().Length() + 

   170             KEmailAddressDecorationHead().Length() +

   171             KEmailAddressDecorationTail().Length() +

   172             KEmailAddressSeparator().Length();

   173         

   174         iDisplayString = HBufC::NewL( length );

   175         TPtr ptr = iDisplayString->Des();

   176         

   177         ptr.Append( dname );

   178         ptr.Append( KSpace );

   179         ptr.Append( KEmailAddressDecorationHead );

   180         ptr.Append( email );

   181         ptr.Append( KEmailAddressDecorationTail );

   182         ptr.Append( KEmailAddressSeparator );

   183         }

   184     }

   185 

   186 // ---------------------------------------------------------------------------

   187 // CNcsAifEntry::SetDupL

   188 // ---------------------------------------------------------------------------

   189 //

   190 void CNcsAifEntry::SetDupL( TBool aDup ) 

   191     {

   192     FUNC_LOG;

   193     if ( iIsDup != aDup )

   194         {

   195         iIsDup = aDup;

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

   197         // meaningful display name

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

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

   200             {

   201             SetDisplayStringL();

   202             }

   203         }

   204     }

   205 

   206 // ---------------------------------------------------------------------------

   207 // CNcsAifEntry::IsSameDN

   208 // ---------------------------------------------------------------------------

   209 //

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

   211     {

   212     FUNC_LOG;

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

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

   215     return ownDn.Compare( otherDn ) == 0;

   216     }

   217 

   218 // ---------------------------------------------------------------------------

   219 // constructor/destructor

   220 // ---------------------------------------------------------------------------

   221 //

   222 CNcsAifEditor::CNcsAifEditor(

   223     MNcsFieldSizeObserver* aSizeObserver, const TDesC& aCaptionText ) 

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

   225     iAddLeftover( ETrue )

   226     {

   227     FUNC_LOG;

   228 	SetEdwinObserver( this );

   229     }

   230 

   231 // ---------------------------------------------------------------------------

   232 // second phase constructor

   233 // ---------------------------------------------------------------------------

   234 //

   235 void CNcsAifEditor::ConstructL( const CCoeControl* aParent,

   236         TInt aNumberOfLines,

   237         TInt aTextLimit )

   238     {

   239     FUNC_LOG;

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

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

   242     }

   243 

   244 // ---------------------------------------------------------------------------

   245 // destructor

   246 // ---------------------------------------------------------------------------

   247 //

   248 CNcsAifEditor::~CNcsAifEditor()

   249     {

   250     FUNC_LOG;

   251 	iArray.ResetAndDestroy();

   252 	iAddressArray.Reset();

   253 	if ( iAsyncCallBack )

   254 	    {

   255 	    iAsyncCallBack->Cancel();

   256 	    delete iAsyncCallBack;

   257 	    }

   258     }

   259 

   260 

   261 // -----------------------------------------------------------------------------

   262 // CNcsAifEditor::CursorLineNumber() const

   263 // -----------------------------------------------------------------------------

   264 //

   265 TInt CNcsAifEditor::CursorLineNumber() const

   266     {

   267     FUNC_LOG;

   268     

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

   270     ret++;

   271     return ret;    

   272     }

   273     

   274 // -----------------------------------------------------------------------------

   275 // CNcsAifEditor::LineCount() const

   276 // -----------------------------------------------------------------------------

   277 //    

   278 TInt CNcsAifEditor::LineCount() const

   279     {

   280     FUNC_LOG;

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

   282     lineCount++;

   283     return lineCount;

   284     }

   285 

   286 // -----------------------------------------------------------------------------

   287 // CNcsAifEditor::OfferKeyEventL()

   288 // -----------------------------------------------------------------------------

   289 //

   290 TKeyResponse CNcsAifEditor::OfferKeyEventL( const TKeyEvent& aKeyEvent,

   291     TEventCode aType )

   292     {

   293     FUNC_LOG;

   294     TKeyResponse ret = EKeyWasNotConsumed;

   295 

   296     // check if we are copying

   297     if ( ret == EKeyWasNotConsumed )

   298         {

   299         ret = CopyEntriesToClipboardL( aKeyEvent, aType );

   300         }

   301 

   302     // Check if we need to delete a contact

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

   304     if ( ret == EKeyWasNotConsumed )

   305         {

   306         ret = HandleContactDeletionL( aKeyEvent, aType );

   307         }

   308 

   309     // Check if we need to highlight a contact

   310     if ( ret == EKeyWasNotConsumed )

   311         {

   312         ret = SetEditorSelectionL( aKeyEvent, aType );

   313         }

   314     

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

   316     if ( aType == EEventKeyDown )

   317     	{

   318     	iLastTimeCursorPos = CursorPos();

   319     	}

   320 

   321     if ( ret == EKeyWasNotConsumed )

   322         {

   323         // enter completes the address entry

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

   325         	aKeyEvent.iScanCode == EStdKeyEnter) )

   326         	{

   327         	// make sure there is really some text inputted 

   328             TInt cursorPos( CursorPos() );

   329         	

   330             TCursorSelection selection = NonEntryTextAtPos( cursorPos );

   331             

   332             TInt length( selection.Length() );

   333             

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

   335             TPtr ptr = text->Des();

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

   337             ptr.Trim();

   338             

   339             // complete the entry by adding a semicolon, 

   340             // address will be added in HandleTextUpdateL

   341             if( ptr.Length() > 0 )

   342             	{            

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

   344 				HandleTextChangedL();

   345 				SetCursorPosL( cursorPos + 1, EFalse );

   346             	}

   347             

   348             CleanupStack::PopAndDestroy( text );            

   349         	}

   350         iTextSelection = Selection();        

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

   352         }

   353     

   354     return ret;

   355     }

   356 

   357 // -----------------------------------------------------------------------------

   358 // CNcsAifEditor::HandleEdwinEventL()

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

   360 // Otherwise the character entry is added through OfferKeyEvent

   361 // -----------------------------------------------------------------------------

   362 //

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

   364     TEdwinEvent aEventType )

   365     {

   366     FUNC_LOG;

   367     if ( aEventType == MEikEdwinObserver::EEventTextUpdate )

   368         {

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

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

   371         CheckAndRemoveInvalidEntriesL();

   372         

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

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

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

   376         HandleTextUpdateDeferred();

   377         }

   378     else if ( aEventType == MEikEdwinObserver::EEventNavigation )

   379         {

   380         iTextSelection = Selection();

   381         HandleNavigationEventL();

   382         }

   383     }

   384 

   385 // -----------------------------------------------------------------------------

   386 // CNcsAifEditor::SetEditorSelectionL()

   387 // -----------------------------------------------------------------------------

   388 //   

   389 TKeyResponse CNcsAifEditor::SetEditorSelectionL( const TKeyEvent& aKeyEvent,

   390     TEventCode aType )

   391     {

   392     FUNC_LOG;

   393     TKeyResponse response = EKeyWasNotConsumed;

   394     CNcsAifEntry* entry = NULL;

   395     TCursorSelection selection = Selection();

   396     

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

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

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

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

   401         {

   402         CompleteEntryL();

   403 		

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

   405         if ( response == EKeyWasConsumed ) 

   406             {

   407             // We're moving to a new line.

   408             entry = GetEntryAt( CursorPos() );

   409             if ( entry )

   410                 {

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

   412                 }

   413             }

   414         }

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

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

   417         {

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

   419         entry = GetEntryAt( CursorPos(), EDirectionLeft );

   420         if ( entry )

   421             {

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

   423                 {

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

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

   426                 response = EKeyWasConsumed;

   427                 }

   428             else if ( !selection.Length() )

   429                 {

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

   431                 response = EKeyWasConsumed;

   432                 }

   433             }

   434         }

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

   436         {

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

   438         entry = GetEntryAt( CursorPos(), EDirectionRight );

   439         if ( entry )

   440             {

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

   442                 {

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

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

   445                 response = EKeyWasConsumed;

   446                 }

   447             else if ( !selection.Length() )

   448                 {

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

   450                 response = EKeyWasConsumed;

   451                 }

   452             }

   453         }

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

   455     else if ( aKeyEvent.iScanCode == EStdKeyHash ) 

   456         {

   457         iAddressPopupList->ClosePopupContactListL();

   458         }

   459 

   460     // Close the address popup if we handled the event

   461     if ( response == EKeyWasConsumed )

   462         {

   463         iAddressPopupList->ClosePopupContactListL();

   464         }

   465     

   466     return response;

   467     }

   468 

   469 // ---------------------------------------------------------------------------

   470 // CNcsAifEditor::HandleContactDeletionL()

   471 // ---------------------------------------------------------------------------

   472 //

   473 TKeyResponse CNcsAifEditor::HandleContactDeletionL( const TKeyEvent& aKeyEvent,

   474     TEventCode aType )

   475     {

   476     FUNC_LOG;

   477     TKeyResponse response  = EKeyWasNotConsumed;

   478     if ( SelectionLength() && aType == EEventKey 

   479         && IsCharacterKey( aKeyEvent ) )

   480         {

   481         // Delete highlighted entries.

   482         TCursorSelection selection = Selection();

   483         TBool entryDeleted = EFalse;

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

   485             {

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

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

   488                 {

   489                 delete iArray[ii];

   490                 iArray.Remove( ii );

   491                 entryDeleted = ETrue;

   492                 }

   493             }

   494 

   495         if ( entryDeleted )

   496             {

   497             // Check that duplicate entries are correctly marked.

   498             UpdateDuplicateEntryMarkingsL();

   499     

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

   501             CNcsAifEntry* entry = NULL;

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

   503                 {

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

   505                     {

   506                     entry = iArray[ii];

   507                     break;

   508                     }

   509                 }

   510             

   511             ClearSelectionL();

   512             

   513             RepositionEntriesL( entry );

   514 

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

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

   517             if ( aKeyEvent.iCode == EKeyDelete || 

   518                  aKeyEvent.iCode == EKeyBackspace )

   519                 {

   520                 response = EKeyWasConsumed;

   521                 }

   522             }

   523         }

   524     return response;

   525     }

   526 

   527 // ---------------------------------------------------------------------------

   528 // CNcsAifEditor::DoCharChangeL

   529 // ---------------------------------------------------------------------------

   530 //

   531 void CNcsAifEditor::DoCharChangeL()

   532 	{

   533     FUNC_LOG;

   534 	RecalculateEntryPositions();

   535 

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

   537 	TBool sentinel = ( previousChar == KCharAddressDelimeterSemiColon || 

   538 	    previousChar == KCharAddressDelimeterComma );

   539 	if ( sentinel )

   540         {

   541         // if comma was pressed we replace it with semicolon

   542 		if ( previousChar == KCharAddressDelimeterComma )

   543             {

   544 			CPlainText* text = Text();

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

   546 			text->InsertL( CursorPos() - 1, KCharAddressDelimeterSemiColon );

   547             }

   548 		ParseNewAddressL();

   549         }

   550 	UpdateAddressAutoCompletionL();

   551 	}

   552 

   553 // ---------------------------------------------------------------------------

   554 // CNcsAddressInputField::CharAtPos

   555 // ---------------------------------------------------------------------------

   556 //

   557 TChar CNcsAifEditor::CharAtPos( TInt aPos ) const

   558     {

   559     FUNC_LOG;

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

   561         {

   562 		TBuf<1> buf;

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

   564 		return buf[0];

   565         }

   566 	else

   567         {

   568 		return 0;

   569         }

   570     }

   571 

   572 // -----------------------------------------------------------------------------

   573 // CNcsAifEditor::SetAddressesL()

   574 // -----------------------------------------------------------------------------

   575 //

   576 void CNcsAifEditor::SetAddressesL( const RPointerArray<CNcsEmailAddressObject>& aAddresses )

   577     {

   578     FUNC_LOG;

   579     iArray.Reset();

   580     AppendAddressesL( aAddresses );

   581     }

   582 

   583 // -----------------------------------------------------------------------------

   584 // CNcsAifEditor::AppendAddressesL()

   585 // -----------------------------------------------------------------------------

   586 //

   587 void CNcsAifEditor::AppendAddressesL( const RPointerArray<CNcsEmailAddressObject>& aAddresses )

   588     {

   589     FUNC_LOG;

   590     // First, add all the addresses without updating the editor text contents 

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

   592         {

   593         AddAddressL( *aAddresses[i], EFalse );

   594         }

   595     // Update editor text content after all the items have been added

   596     RepositionEntriesL( NULL );

   597     }

   598 

   599 // -----------------------------------------------------------------------------

   600 // CNcsAifEditor::GetAddressesL()

   601 // -----------------------------------------------------------------------------

   602 //   

   603 const RPointerArray<CNcsEmailAddressObject>& CNcsAifEditor::GetAddressesL()

   604     {

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

   606 	iAddressArray.Reset();

   607 

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

   609         {

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

   611         }

   612 

   613 	return iAddressArray;

   614     }

   615     

   616 // -----------------------------------------------------------------------------

   617 // CNcsAifEditor::GetEntryAt()

   618 // -----------------------------------------------------------------------------

   619 //   

   620 CNcsAifEntry* CNcsAifEditor::GetEntryAt( 

   621     TInt aPos, 

   622     TEntryDirection aDirection ) const

   623     {

   624     FUNC_LOG;

   625     const TChar KSpace( ' ' );

   626 

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

   628         {

   629         CNcsAifEntry* entry = iArray[i];

   630         if ( aDirection == EDirectionNone )

   631             {

   632             // no direction, check if cursor is on entry

   633             if ( entry->Includes( aPos ) )

   634                 {

   635                 return entry;

   636                 }

   637             }

   638         else if ( aDirection == EDirectionRight )

   639             {

   640             // direction to the righ. check if cursor is on entry or

   641             // entry is immediately to the right of the cursor

   642             if ( entry->Includes( aPos ) )

   643                 {

   644                 return entry;

   645                 }

   646 

   647             if ( entry->Start() >= aPos && entry->Start() - aPos <= 1 &&

   648                 CharAtPos( aPos ) == KSpace )

   649                 {

   650                 return entry;

   651                 }

   652             }

   653         else if ( aDirection == EDirectionLeft )

   654             {

   655             // direction to the left. decrease cursor by one and check if it

   656             // is on entry or if entry is immediately to the left of the cursor

   657             if ( entry->Includes( aPos - 1 ) )

   658                 {

   659                 return entry;

   660                 }

   661             

   662             if ( aPos >= entry->End() && aPos - entry->End() <= 1 &&

   663                 CharAtPos( aPos - 1 ) == KSpace )

   664                 {

   665                 return entry;

   666                 }

   667             }

   668         }

   669 	return NULL;

   670     }

   671 

   672 // -----------------------------------------------------------------------------

   673 // CNcsAifEditor::GetPreviousEntryFrom()

   674 // -----------------------------------------------------------------------------

   675 //

   676 CNcsAifEntry* CNcsAifEditor::GetPreviousEntryFrom( TInt aPos ) const

   677     {

   678     FUNC_LOG;

   679     CNcsAifEntry* entry = NULL;

   680     

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

   682         {

   683         if ( iArray[i]->End() < aPos )

   684             {

   685             entry = iArray[i];

   686             }

   687         else

   688             {

   689             break;

   690             }

   691         }

   692     

   693     return entry;

   694     }

   695 

   696 // -----------------------------------------------------------------------------

   697 // CNcsAifEditor::CheckAddressWhenFocusLostL()

   698 // -----------------------------------------------------------------------------

   699 //

   700 void CNcsAifEditor::CheckAddressWhenFocusLostL()

   701     {

   702     FUNC_LOG;

   703 	ParseNewAddressL();

   704     }

   705 

   706 // -----------------------------------------------------------------------------

   707 // CNcsAifEditor::ParseNewAddressL()

   708 // -----------------------------------------------------------------------------

   709 //

   710 void CNcsAifEditor::ParseNewAddressL()

   711 	{

   712     FUNC_LOG;

   713 	HBufC* text = GetNonEntryTextLC();

   714 	__ASSERT_ALWAYS( text, Panic(EFSEmailUiNullPointerException) );

   715 

   716 	if ( text->Length() )

   717 		{

   718         // if changing focus leftover text is parsed to email

   719         // object - we don't need to add it anymore

   720         iAddLeftover = EFalse;

   721         // check if there is a name for the email address

   722         HBufC* name = CFsDelayedLoader::InstanceL()->GetContactHandlerL()->GetLastSearchNameL( *text );

   723 	if ( name )

   724 		{

   725             CleanupStack::PushL( name );

   726 		AddAddressL( *name, *text, ETrue );

   727 		CleanupStack::PopAndDestroy( name );

   728 		}

   729 	else

   730 		{

   731 		AddAddressL( KNullDesC, *text );

   732 		}

   733 	    }

   734 	

   735 	CleanupStack::PopAndDestroy(text);

   736 	}

   737 

   738 // -----------------------------------------------------------------------------

   739 // CNcsAifEditor::GetNonEntryTextL()

   740 // This will extract any text that was entered that is not

   741 // part of any existing entries

   742 // -----------------------------------------------------------------------------

   743 //

   744 HBufC* CNcsAifEditor::GetNonEntryTextLC() const

   745     {

   746     FUNC_LOG;

   747     

   748     // "non-entry text" starts after last "entry"

   749     TInt start( 0 );

   750     if ( iArray.Count() > 0 )

   751         {

   752         start = iArray[iArray.Count() - 1]->End();

   753         }

   754     TInt length( TextLength() - start );

   755 

   756     // Allocate space and extract it

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

   758     TPtr ptr = text->Des();

   759     Text()->Extract( ptr, start, length );

   760     

   761     // Wipe out possible delimiter

   762     TInt pos = ptr.Locate( KCharAddressDelimeterSemiColon );

   763     if ( pos != KErrNotFound )

   764         {

   765         ptr.Delete( pos, 1 );

   766         }

   767     

   768     // Remove unnecessary whitespaces

   769     ptr.Trim();

   770     

   771     INFO_1("non-entry text == %S", text);

   772     return text;

   773     }

   774 

   775 // ---------------------------------------------------------------------------

   776 // CNcsAifEditor::CopyEntriesToClipBoardL

   777 // ---------------------------------------------------------------------------

   778 //

   779 TKeyResponse CNcsAifEditor::CopyEntriesToClipboardL(

   780     const TKeyEvent& aKeyEvent,

   781     TEventCode aType )

   782     {

   783     FUNC_LOG;

   784     TKeyResponse ret = EKeyWasNotConsumed;

   785     // check that we are copying

   786     TBool copyKeyEvent = ( aType == EEventKey && aKeyEvent.iCode == 3 &&

   787                            aKeyEvent.iModifiers & EModifierCtrl &&

   788                            aKeyEvent.iScanCode == EPtiKeyQwertyC );

   789     TBool cutKeyEvent = ( aType == EEventKey && aKeyEvent.iCode == 24 &&

   790                           aKeyEvent.iModifiers & EModifierCtrl &&

   791                           aKeyEvent.iScanCode == EPtiKeyQwertyX );

   792     if ( copyKeyEvent || cutKeyEvent ) 

   793         {

   794         RPointerArray<CNcsAifEntry> entries;

   795         CleanupClosePushL( entries );

   796         FindSelectedEntriesL( entries );

   797         if ( entries.Count() > 0 )

   798             {

   799             CancelFepTransaction();

   800             HBufC* formattedText = GetFormattedAddressListLC( entries, EFalse );

   801             TFsEmailUiUtility::CopyToClipboardL( *formattedText );

   802             CleanupStack::PopAndDestroy( formattedText );

   803             

   804             if ( !cutKeyEvent )

   805                 { // cutting needs more handling

   806                 ret = EKeyWasConsumed;

   807                 }

   808             }

   809         CleanupStack::PopAndDestroy( &entries );

   810         }

   811     return ret;

   812     }

   813 

   814 // -----------------------------------------------------------------------------

   815 // CNcsAifEditor::FindSelectedEntriesL( )

   816 // -----------------------------------------------------------------------------

   817 //

   818 void CNcsAifEditor::FindSelectedEntriesL( RPointerArray<CNcsAifEntry>& aEntries )

   819     {

   820     FUNC_LOG;

   821     TCursorSelection selection = Selection();

   822     TInt count = iArray.Count();

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

   824         {

   825         CNcsAifEntry* entry = iArray[i];

   826         if ( entry->Start() >= selection.LowerPos() &&

   827              entry->End() <= selection.HigherPos() )

   828             {

   829             aEntries.AppendL( entry );

   830             }

   831         }

   832     }

   833 

   834 // -----------------------------------------------------------------------------

   835 // CNcsAifEditor::EmailAddressIndexNameBySelection( )

   836 // -----------------------------------------------------------------------------

   837 //

   838 const CNcsEmailAddressObject* CNcsAifEditor::EmailAddressObjectBySelection() const

   839     {

   840     FUNC_LOG;

   841 	// Find the contact the cursor is in

   842 	const CNcsAifEntry* aEntry = GetEntryAt(CursorPos());

   843 	ASSERT(aEntry != NULL);

   844 	return &aEntry->Address();

   845     }

   846 

   847 // -----------------------------------------------------------------------------

   848 // CNcsAifEditor::AddAddressL()

   849 // -----------------------------------------------------------------------------

   850 //

   851 void CNcsAifEditor::AddAddressL( const CNcsEmailAddressObject& aAddress, TBool aUpdateEditorText /*= ETrue*/ )

   852     {

   853     FUNC_LOG;

   854     CNcsAifEntry* entry = CNcsAifEntry::NewL( aAddress );

   855     CleanupStack::PushL( entry );

   856     AddAddressL( entry, aUpdateEditorText );

   857     CleanupStack::Pop( entry );

   858     }

   859 

   860 void CNcsAifEditor::AddAddressL( 

   861     const TDesC& aDisplayName, 

   862     const TDesC& aEmail,

   863     TBool aDisplayFull /*= EFalse*/,

   864     TBool aUpdateEditorText /*= ETrue*/ )

   865     {

   866     FUNC_LOG;

   867     CNcsAifEntry* entry = CNcsAifEntry::NewL( aDisplayName, aEmail, aDisplayFull );

   868     CleanupStack::PushL( entry );

   869 	AddAddressL( entry, aUpdateEditorText );

   870 	CleanupStack::Pop( entry );

   871     }

   872 

   873 void CNcsAifEditor::AddAddressL( CNcsAifEntry* aNewEntry, TBool aUpdateEditorText )

   874     {

   875     FUNC_LOG;

   876 	TInt idx;

   877 	

   878 	// Check for duplicate display names

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

   880         {

   881 		if ( iArray[idx]->IsSameDN(*aNewEntry) ) 

   882             {

   883 			iArray[idx]->SetDupL();

   884 			aNewEntry->SetDupL();

   885             }

   886         }

   887 

   888 	// Find the location where we need to insert the address.

   889 	// Browse from back to forth to make last index as default index. 

   890 	// This ensures items remain in correct order when populating field from

   891 	// existing message.

   892 	TInt cursorPos = CursorPos();

   893     // if we are at the end of editor the address was

   894     // added from MRU list or separator was typed in

   895     if ( cursorPos == Text()->DocumentLength() )

   896         {

   897         iAddLeftover = EFalse;

   898         }

   899 	

   900 	for ( idx = iArray.Count() ; idx > 0 ; idx-- ) 

   901         {

   902 		if ( cursorPos >= iArray[idx-1]->End() ) break;

   903         }

   904 	if ( idx == iArray.Count() ) 

   905         {

   906 		// Tack the address onto the end of the array

   907 		iArray.AppendL( aNewEntry );

   908         }

   909 	else

   910         {

   911 		iArray.InsertL( aNewEntry, idx );

   912         }

   913 	

   914 	if ( aUpdateEditorText )

   915 	    {

   916 	    // Trap because we must not leave after we have taken the ownership of aNewEntry.

   917 	    // Otherwise douple deletion might happen.

   918 	    TRAP_IGNORE( RepositionEntriesL( aNewEntry ) );

   919 	    }

   920     }

   921 

   922 // ---------------------------------------------------------------------------

   923 // CNcsAifEditor::RecalculateEntryPositions()

   924 // The text has changed, so recalculate the positions of the items.

   925 // ---------------------------------------------------------------------------

   926 //	

   927 void CNcsAifEditor::RecalculateEntryPositions()

   928 	{

   929     FUNC_LOG;

   930 	// We only need to worry about items right of the cursor

   931 	TInt pos = CursorPos();

   932 	TInt error = KErrNone;

   933 	

   934 	// Find the first item to the right of the cursor

   935 	TInt idx = 0;

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

   937 		{

   938 		if ( ( iArray[idx]->Includes( iLastTimeCursorPos ) ) 

   939 				 || ( iArray[idx]->Start() >= iLastTimeCursorPos ) )   

   940 			{

   941 			break;

   942 			}

   943 		}	

   944 	

   945    	// If no entry was to the right of the cursor position

   946 	// then the new text was added at the end of the text.

   947 	// Don't do anything

   948 	if ( idx == iArray.Count() )

   949 		{

   950 		return;

   951 		}

   952 	

   953 	// Find the location of the first entry to the right

   954 	// of the cursor using a display string match

   955 	pos = Min( iArray[idx]->Start(), pos );

   956 	TRAP( error, pos = FindTextL( &iArray[idx]->DisplayString(), pos,

   957 	    CEikEdwin::EFindCaseSensitive | CEikEdwin::ENoBusyMessage ) );

   958 	ASSERT( KErrNone == error && KErrNotFound != pos );

   959 

   960 	// Now reposition all entries to the right

   961 	for ( ; idx<iArray.Count(); idx++ ) 

   962 		{

   963 		pos = iArray[idx]->SetPos( pos );

   964 		pos++; // for whitespace

   965 		}

   966 	}

   967 

   968 // ---------------------------------------------------------------------------

   969 // CNcsAifEditor::RepositionEntriesL()

   970 // ---------------------------------------------------------------------------

   971 //

   972 void CNcsAifEditor::RepositionEntriesL( const CNcsAifEntry* aPosEntry )

   973 	{

   974     FUNC_LOG;

   975 	TInt pos = 0;

   976 	CNcsAifEntry* entry;

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

   978 		{

   979 		entry = iArray[i];

   980 		pos = entry->SetPos( pos );

   981 		pos++; // for whitespace

   982 		}

   983 

   984   // Reset the text

   985 	HBufC* text = NULL;

   986 	text = GetFormattedAddressListLC( iArray );

   987 	// fix for dissapearing text PWAN-82DNEJ	

   988 	SetCursorPosL( 0, EFalse ); //In case the cursor pos is invalid

   989 	

   990     if ( iAddLeftover )

   991         {

   992         TInt lengthBefore = Text()->DocumentLength();

   993         HBufC* textBefore = HBufC::NewLC( lengthBefore );

   994         TPtr ptrBefore = textBefore->Des();

   995         Text()->Extract( ptrBefore, 0, lengthBefore );

   996         ptrBefore.Trim();

   997         // find text after last semicolon

   998         TInt colon = ptrBefore.LocateReverseF( 

   999                 KCharAddressDelimeterSemiColon ) + 1;

  1000         TPtrC leftover = ptrBefore.Mid( colon );

  1001         HBufC* newText = HBufC::NewLC( text->Length() + leftover.Length() );

  1002         TPtr newTextPtr = newText->Des();

  1003         // add all email addresses

  1004         newTextPtr.Append( text->Des() );

  1005         // add the text that was after last email object

  1006         newTextPtr.Append( leftover );

  1007     

  1008         SetTextL( newText );

  1009         CleanupStack::PopAndDestroy( newText );

  1010         CleanupStack::PopAndDestroy( textBefore );

  1011         }

  1012     else

  1013         {

  1014         SetTextL( text );

  1015         }

  1016     CleanupStack::PopAndDestroy( text );

  1017     HandleTextChangedL();

  1018     

  1019     // Set the cursor at the end of the given entry 

  1020     if ( !aPosEntry )

  1021     	{

  1022 	    SetCursorPosL( 0, EFalse );

  1023     	}

  1024     else

  1025     	{

  1026     	SetCursorPosL( aPosEntry->End(), EFalse );

  1027     	}

  1028 	}

  1029 

  1030 // ---------------------------------------------------------------------------

  1031 // CNcsAifEditor::CheckAndRemoveInvalidEntriesL()

  1032 // ---------------------------------------------------------------------------

  1033 //

  1034 void CNcsAifEditor::CheckAndRemoveInvalidEntriesL()

  1035     {

  1036     FUNC_LOG;

  1037     TInt currentCursorPos( CursorPos() );

  1038     const TInt KNoEntryRemoved = -1;

  1039     TInt removedEntryIndex( KNoEntryRemoved );

  1040     

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

  1042         {

  1043         TInt matchesInText;

  1044         TInt matchesInArray;

  1045         TInt arrayItemLowPos( iArray[i]->LowerPos() );

  1046         TInt arrayItemHighPos( iArray[i]->HigherPos());

  1047 

  1048         GetMatchingEntryCountsL( iArray[i], matchesInText, matchesInArray );

  1049 

  1050         // Entry is removed if:

  1051         // a) there's no matches for it in the text, or

  1052         // b) there're less matches for it in the text than in array (i.e.,

  1053         //    a duplicate ("foo(at)foo.org; foo(at)foo.org") has just been removed)

  1054         // In b) case the correct duplicate is the one that is in current

  1055         // cursor position (or one off due to possible whitespace).

  1056         if ( 0 == matchesInText ||

  1057              ( matchesInText < matchesInArray ) &&

  1058                ( currentCursorPos >= arrayItemLowPos && 

  1059                  currentCursorPos <= arrayItemHighPos )) 

  1060             {

  1061             delete iArray[i];

  1062             iArray.Remove(i);

  1063             removedEntryIndex = i;

  1064             if ( iTextSelection.iAnchorPos != iTextSelection.iCursorPos &&

  1065                  iTextSelection.HigherPos() < arrayItemHighPos )

  1066                 {

  1067                 iPartialRemove = ETrue;

  1068                 }

  1069             }

  1070         }

  1071     

  1072     if ( KNoEntryRemoved != removedEntryIndex )

  1073         {

  1074         // at least one entry has been removed => udpates duplicate markings

  1075         UpdateDuplicateEntryMarkingsL();

  1076         }

  1077     }

  1078 

  1079 // ---------------------------------------------------------------------------

  1080 // CNcsAifEditor::GetLookupTextLC()

  1081 // ---------------------------------------------------------------------------

  1082 //

  1083 HBufC* CNcsAifEditor::GetLookupTextLC() const

  1084     {

  1085     FUNC_LOG;

  1086 	HBufC* text = GetTextInHBufL();

  1087 	

  1088 	if (text == NULL) return NULL;

  1089 

  1090 	CleanupStack::PushL( text );

  1091 	TPtr ptr( text->Des() );

  1092 	TInt location = ptr.LocateReverse( KCharAddressDelimeterSemiColon );

  1093 	if( location != KErrNotFound )

  1094         {

  1095 		ptr = ptr.RightTPtr( ptr.Length() - location -1 );

  1096 		ptr.TrimLeft();

  1097         }

  1098 	return text;

  1099     }

  1100 

  1101 // ---------------------------------------------------------------------------

  1102 // CNcsAifEditor::GetFormattedAddressListLC()

  1103 // ---------------------------------------------------------------------------

  1104 //

  1105 HBufC* CNcsAifEditor::GetFormattedAddressListLC(

  1106     RPointerArray<CNcsAifEntry>& aEntries,

  1107     TBool aDisplayList ) const

  1108     {

  1109     FUNC_LOG;

  1110 	TInt length = CalculateAddressListLength( aEntries, aDisplayList );

  1111 	if ( length <= 0 )

  1112         {

  1113 		return HBufC::NewLC(0);

  1114         }

  1115     

  1116 	HBufC* buf = HBufC::NewLC( length );

  1117 	TPtr ptr = buf->Des();

  1118     

  1119 	TInt count = aEntries.Count();

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

  1121         {

  1122         if ( aDisplayList )

  1123             {

  1124             ptr.Append( aEntries[i]->DisplayString() );

  1125             }

  1126         else

  1127             {

  1128             ptr.Append( aEntries[i]->Address().EmailAddress() );

  1129             ptr.Append( KEmailAddressSeparator );

  1130             }

  1131         

  1132 		// append whitespace, if not in the last entry

  1133         if ( i < count - 1 )

  1134             {