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:  compose view container

    15 *

    16 */

    17 

    18 

    19 

    20 // INCLUDE FILES

    21 #include "emailtrace.h"

    22 #include <s32mem.h>

    23 #include <txtrich.h>

    24 #include <AknIconUtils.h>

    25 #include <StringLoader.h>

    26 #include <avkon.hrh>

    27 #include <AknsDrawUtils.h>

    28 #include <aknview.h>

    29 #include <AknUtils.h>

    30 #include <FreestyleEmailUi.rsg>

    31 #include <eikclbd.h>

    32 #include <aknViewAppUi.h>

    33 #include <aknnotewrappers.h> //CAknInformationNote

    34 #include <txtetext.h>

    35 #include <aknphysics.h>

    36 

    37 #include "ncscomposeviewcontainer.h"

    38 #include "ncsheadercontainer.h"

    39 #include "ncsaddressinputfield.h"

    40 #include "ncssubjectfield.h"

    41 #include "ncsconstants.h"

    42 #include "ncseditor.h"

    43 #include "ncspopuplistbox.h"

    44 #include "ncscomposeview.h"

    45 #include "ncsutility.h"

    46 #include "ncsemailaddressobject.h"

    47 #include "FreestyleEmailUiUtilities.h"

    48 #include "FreestyleEmailUiConstants.h"

    49 #include "FreestyleEmailUiSendAttachmentsListControl.h"

    50 #include "FreestyleEmailUiSendAttachmentsListVisualiser.h"

    51 #include "FreestyleEmailUiSendAttachmentsListModel.h"

    52 #include "FreestyleEmailUi.hrh"

    53 #include "FSAutoSaver.h"

    54 #include "FreestyleEmailUiCLSItem.h"

    55 

    56 

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

    58 

    59 // ---------------------------------------------------------------------------

    60 // constructor

    61 // ---------------------------------------------------------------------------

    62 //

    63 CNcsComposeViewContainer::CNcsComposeViewContainer(

    64     CNcsComposeView& aView,

    65     CFsAutoSaver& aAutoSaver,

    66 	CFSMailBox& aMailBox ):

    67 	iView( aView ), iAmountMesFieldMovedUp( 0 ),

    68 	iAutoSaver( aAutoSaver ), iMailBox( aMailBox )

    69     {

    70     FUNC_LOG;

    71     }

    72 

    73 // -----------------------------------------------------------------------------

    74 // CNcsComposeViewContainer::NewL()

    75 // Two-phased constructor.

    76 // -----------------------------------------------------------------------------

    77 //

    78 CNcsComposeViewContainer* CNcsComposeViewContainer::NewL( CNcsComposeView& aView,

    79     const TRect& aRect, CFSMailBox& aMailBox, CFsAutoSaver& aAutoSaver,

    80     TInt aFlags )

    81     {

    82     FUNC_LOG;

    83 

    84     CNcsComposeViewContainer* self = new ( ELeave ) CNcsComposeViewContainer(

    85         aView, aAutoSaver, aMailBox );

    86     CleanupStack::PushL( self );

    87     self->ConstructL( aRect, aFlags );

    88     CleanupStack::Pop( self );

    89 

    90     return self;

    91     }

    92 

    93 // -----------------------------------------------------------------------------

    94 // CNcsComposeViewContainer::ConstructL()

    95 // Symbian 2nd phase constructor can leave.

    96 // -----------------------------------------------------------------------------

    97 //

    98 void CNcsComposeViewContainer::ConstructL( const TRect& aRect, TInt aFlags )

    99     {

   100     FUNC_LOG;

   101 

   102     SetMopParent( &iView );

   103     CreateWindowL();

   104 	// <cmail>

   105     // iApplicationRect = aRect;

   106 	// </cmail>

   107 

   108     // Setup the control array

   109     InitComponentArrayL();

   110     CCoeControlArray& controls = Components();

   111     controls.SetControlsOwnedExternally( ETrue );

   112 

   113     // Create the header field

   114     iHeader = CNcsHeaderContainer::NewL( *this, iMailBox, aFlags );

   115     controls.AppendLC( iHeader );

   116     CleanupStack::Pop( iHeader );

   117 

   118     // Create 'message body' field, default text is empty for that field

   119     iMessageField = new ( ELeave ) CNcsEditor( this, EFalse, ENcsEditorBody );

   120     iMessageField->SetContainerWindowL( *this );

   121     iMessageField->ConstructL( this, 0, 0 );

   122     iMessageField->SetAlignment( EAknEditorAlignBidi );

   123     iMessageField->SetAknEditorInputMode( EAknEditorTextInputMode );

   124     controls.AppendLC( iMessageField );

   125     CleanupStack::Pop( iMessageField );

   126 

   127     // <cmail> Platform layout change

   128     iMessageField->SetNcsFontType( NcsUtility::ENcsBodytextFont );

   129     // </cmail>

   130 

   131     // Listen edwin events and size events from message body field

   132     iMessageField->AddEdwinObserverL( this );

   133     iMessageField->SetEdwinSizeObserver( this );

   134 

   135     // Create read-only field to be used for original message quote when

   136     // protocol doesn't allow editing the original message

   137     iReadOnlyQuoteField = new( ELeave ) CNcsEditor( this, EFalse );

   138     iReadOnlyQuoteField->SetContainerWindowL( *this );

   139     iReadOnlyQuoteField->ConstructL( this, 0, 0 );

   140     iReadOnlyQuoteField->SetAlignment( EAknEditorAlignBidi );

   141     iReadOnlyQuoteField->SetReadOnly( ETrue );

   142     controls.AppendLC( iReadOnlyQuoteField );

   143     CleanupStack::Pop( iReadOnlyQuoteField );

   144 

   145     // Listen edwin events and size events from smart quote field

   146     iReadOnlyQuoteField->AddEdwinObserverL( this );

   147     iReadOnlyQuoteField->SetEdwinSizeObserver( this );

   148 

   149     // Create the scroll bar

   150     iScrollBar = new( ELeave ) CAknDoubleSpanScrollBar( this );

   151     iScrollBar->ConstructL( this, this, CEikScrollBar::EVertical, aRect.Height() );

   152     iScrollBar->MakeVisible( ETrue );

   153     iScrollBar->SetModelL( &iScrollBarModel );

   154 

   155     iMessageField->SetupEditorL();

   156     iReadOnlyQuoteField->SetupEditorL();

   157 

   158     SetRect( aRect );

   159 

   160     //<cmail> S60 skin support

   161     iBgContext = CAknsBasicBackgroundControlContext::NewL(

   162         KAknsIIDQsnBgAreaMain, Rect(), EFalse );

   163     // <cmail>

   164 	//iMessageField->SetSkinBackgroundControlContextL( iBgContext );

   165 	// </cmail>

   166     iLongTapDetector = CAknLongTapDetector::NewL( this );

   167     //</cmail>

   168 

   169     UpdateScrollBarL();

   170 

   171     ActivateL();

   172 

   173     // activate auto save functionality

   174     iAutoSaver.Enable( ETrue );

   175 

   176     if ( CAknPhysics::FeatureEnabled() )

   177         {

   178         iPhysics = CAknPhysics::NewL( *this, this );

   179         }

   180     }

   181 

   182 // ---------------------------------------------------------------------------

   183 // CNcsComposeViewContainer::~CNcsComposeViewContainer

   184 // Destructor

   185 // ---------------------------------------------------------------------------

   186 //

   187 CNcsComposeViewContainer::~CNcsComposeViewContainer()

   188     {

   189     FUNC_LOG;

   190     if ( iContactHandler )

   191         {

   192         iContactHandler->ClearObservers();

   193         }

   194 	delete iHeader;

   195     delete iScrollBar;

   196     delete iMessageField;

   197     // <cmail>

   198     delete iBgContext;

   199 	delete iLongTapDetector;

   200     // </cmail>

   201     delete iReadOnlyQuoteField;

   202     delete iReadOnlyQuote;

   203 

   204     delete iPhysics;

   205     iPhysics = NULL;

   206     }

   207 

   208 

   209 // -----------------------------------------------------------------------------

   210 // CNcsComposeViewContainer::FocusChanged

   211 //

   212 // -----------------------------------------------------------------------------

   213 //

   214 void CNcsComposeViewContainer::FocusChanged(TDrawNow aDrawNow)

   215     {

   216     FUNC_LOG;

   217 

   218 	if ( iFocused != iHeader &&

   219 	     iFocused != iMessageField &&

   220 	     iFocused != iReadOnlyQuoteField )

   221         {

   222 		iFocused = iHeader;

   223         }

   224 	iFocused->SetFocus( ETrue, aDrawNow );

   225 	// <cmail>

   226 	iView.HandleContainerChangeRequiringToolbarRefresh();

   227 	// </cmail>

   228 	if ( aDrawNow )

   229 	    {

   230 		DrawNow();

   231 	    }

   232 

   233     }

   234 // -----------------------------------------------------------------------------

   235 // CNcsComposeViewContainer::SetMskL()

   236 //

   237 // -----------------------------------------------------------------------------

   238 //

   239 void CNcsComposeViewContainer::SetMskL()

   240     {

   241     FUNC_LOG;

   242     iHeader->SetMskL();

   243     }

   244 

   245 //<cmail>

   246 

   247 // -----------------------------------------------------------------------------

   248 // CNcsComposeViewContainer::HandlePointerEventL()

   249 //

   250 // -----------------------------------------------------------------------------

   251 //

   252 void CNcsComposeViewContainer::HandlePointerEventL( const TPointerEvent& aPointerEvent )

   253     {

   254 	FUNC_LOG;

   255 

   256     CCoeControl::HandlePointerEventL( aPointerEvent );

   257 

   258     if ( iHeader->NeedsLongTapL( aPointerEvent.iPosition ) )

   259         {

   260     	iLongTapDetector->PointerEventL( aPointerEvent );

   261         }

   262 	   

   263     switch( aPointerEvent.iType )

   264     	{

   265     	case TPointerEvent::EButton1Down:

   266     		{

   267             // Save current and original position so that those can be used in

   268             // drag/scrolling calculations

   269             iPreviousPosition = iOriginalPosition = aPointerEvent.iParentPosition;

   270             iIsDragging = EFalse;

   271             iIsFlicking = EFalse;

   272 

   273             if( iPhysics )

   274                 {

   275                 iPhysics->StopPhysics();

   276                 iPhysics->ResetFriction();

   277                 iStartTime.HomeTime();

   278                 UpdatePhysicsL();

   279                 }            

   280 

   281             

   282 			//Closes the attachment action menu, if it is open.

   283 			//Otherwise does nothing

   284 			iView.DismissAttachmentActionMenuL();

   285 

   286             if ( iHeader->Rect().Contains(aPointerEvent.iPosition) )

   287                 {

   288                 if (iFocused == iMessageField)

   289                     {

   290                     iFocused = iHeader;

   291                     iHeader->SetFocus( ETrue,EDrawNow );

   292                     iMessageField->SetFocus( EFalse, EDrawNow );

   293                     iHeader->MakeVisible( ETrue );

   294                     CommitL(EBodyField);

   295                     iView.HandleContainerChangeRequiringToolbarRefresh();

   296                     }

   297                 else if (iFocused == iReadOnlyQuoteField)

   298                     {

   299                     iFocused = iMessageField;

   300                     iReadOnlyQuoteField->SetFocus( EFalse, EDrawNow );

   301                     iHeader->SetFocus( ETrue, EDrawNow );

   302                     iView.HandleContainerChangeRequiringToolbarRefresh();

   303                     }

   304                 }

   305             else if (iReadOnlyQuoteField->Rect().Contains(aPointerEvent.iPosition))

   306                 {

   307                 if (iFocused == iMessageField)

   308                     {

   309                     iFocused = iReadOnlyQuoteField;

   310                     iReadOnlyQuoteField->SetFocus( ETrue, EDrawNow );

   311                     iMessageField->SetFocus( EFalse, EDrawNow );

   312                     iReadOnlyQuoteField->SetCursorPosL( 0, EFalse );

   313                     iView.HandleContainerChangeRequiringToolbarRefresh();

   314                     }

   315                 else if (iFocused == iHeader)

   316                     {

   317                     iFocused = iReadOnlyQuoteField;

   318                     iReadOnlyQuoteField->SetFocus( ETrue, EDrawNow );

   319                     iHeader->SetFocus( EFalse, EDrawNow );

   320                     iReadOnlyQuoteField->SetCursorPosL( 0, EFalse );

   321                     iView.HandleContainerChangeRequiringToolbarRefresh();

   322                     }

   323                 }

   324             else 

   325                 {

   326                 if (iFocused == iHeader)

   327                     {

   328                     iFocused = iMessageField;

   329                     iHeader->SetFocus( EFalse, EDrawNow );

   330                     iMessageField->SetFocus( ETrue, EDrawNow );

   331                     //iMessageField->SetCursorPosL( iMessageField->TextLength(), EFalse );

   332                     iView.HandleContainerChangeRequiringToolbarRefresh();

   333                     }

   334                 else if (iFocused == iReadOnlyQuoteField)

   335                     {

   336                     iFocused = iMessageField;

   337                     iReadOnlyQuoteField->SetFocus( EFalse, EDrawNow );

   338                     iMessageField->SetFocus( ETrue, EDrawNow );

   339                     iView.HandleContainerChangeRequiringToolbarRefresh();

   340                     }

   341                 else 

   342                     {

   343                     //iMessageField->SetCursorPosL( iMessageField->TextLength(), EFalse );

   344                     const TRect messageFieldRect(iMessageField->Rect());

   345                     if (!messageFieldRect.Contains(aPointerEvent.iPosition) && 

   346                             aPointerEvent.iPosition.iY >= messageFieldRect.iTl.iY ) 

   347                         {

   348                         iMessageField->OpenVirtualKeyBoardL();

   349                         }

   350                     }

   351                 }

   352 

   353 			break;

   354     		}

   355     	

   356     	case TPointerEvent::EButton1Up:    		

   357     		{

   358             if( iIsDragging && iPhysics )

   359                 {

   360                 TPoint drag(iOriginalPosition - aPointerEvent.iParentPosition);

   361                 iPhysics->StartPhysics(drag, iStartTime);

   362                 iIsFlicking = ETrue;

   363                 iIsDragging = EFalse;

   364                 }

   365     		break;

   366     		}

   367     	

   368     	case TPointerEvent::EDrag:

   369     		{

   370     		// Get current pointer position

   371     		TPoint position = aPointerEvent.iParentPosition;

   372 

   373     		// If user started dragging, cancel hotspot actions

   374             iIsDragging = ETrue;

   375 

   376            if( iPhysics )

   377                 {

   378                 TPoint delta( 0, iPreviousPosition.iY - position.iY );

   379                 iPhysics->RegisterPanningPosition( delta );

   380                 }

   381             else

   382                 {

   383     			TInt topPosition( -iHeader->Position().iY );

   384     						

   385     			TInt totalHeight( ContentTotalHeight() );

   386 

   387     			TInt areaHeight( Rect().Size().iHeight );

   388     			TInt scrollOffset( 0 );

   389     			

   390 				if( totalHeight > areaHeight )

   391 					{

   392 					// Calculate new scroll offset based on current and previous Y-positions

   393 					scrollOffset = topPosition + ( iPreviousPosition.iY - position.iY );

   394 					// Ensure that thumb position is in correct range

   395 					scrollOffset = Max( scrollOffset, 0 );

   396 					scrollOffset = Min( scrollOffset, totalHeight - areaHeight );

   397 					}

   398 

   399 				ScrollL( scrollOffset );

   400 				}

   401            

   402 			// Save current position as previous pos for future calculations

   403 			iPreviousPosition = position;  

   404 			

   405 			break;

   406     		}

   407     		

   408     	default:

   409     		{

   410     		// unknown event, ignored

   411     		break;

   412     		}

   413     	}

   414     

   415     }

   416 

   417 //</cmail>

   418 

   419 // -----------------------------------------------------------------------------

   420 // CNcsComposeViewContainer::OfferKeyEventL()

   421 // Handles key events

   422 // -----------------------------------------------------------------------------

   423 //

   424 TKeyResponse CNcsComposeViewContainer::OfferKeyEventL( const TKeyEvent& aKeyEvent, TEventCode aType )

   425     {

   426     FUNC_LOG;

   427 

   428     if( iPhysics )

   429         {

   430         iPhysics->StopPhysics();

   431         iPhysics->ResetFriction();

   432         }

   433 

   434     TKeyResponse ret( EKeyWasNotConsumed );

   435 

   436     //<cmail>

   437     //we are allowing to change MSK label 

   438     SwitchChangeMskOff(EFalse);

   439     //</cmail>

   440     

   441     if ( aKeyEvent.iCode == EKeyYes )

   442         {

   443         // check that at least one of the address fields has an address

   444         if ( !iHeader->AreAddressFieldsEmpty() )

   445             {

   446             iView.HandleCommandL( ENcsCmdSend );

   447             }

   448         else

   449             {

   450             AppendAddressesL();

   451             }

   452         ret = EKeyWasConsumed;

   453         }

   454     else if ( aKeyEvent.iCode == EKeyOK )

   455     	{

   456         if ( iHeader->IsPopupActive() )

   457             {

   458             DoPopupSelectL();

   459             ret = EKeyWasConsumed;

   460             }

   461         else if ( AppendAddressesL() )

   462             {

   463             ret = EKeyWasConsumed;

   464             }

   465         }

   466     else if ( aKeyEvent.iScanCode == 'S' &&

   467               aKeyEvent.iModifiers & EModifierCtrl &&

   468               aType == EEventKey )

   469         {

   470         iView.HandleCommandL( ENcsCmdSaveDraft );

   471         ret = EKeyWasConsumed;

   472         }

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

   474         {

   475         ret = iFocused->OfferKeyEventL( aKeyEvent, aType );

   476 

   477         if ( ret == EKeyWasNotConsumed )

   478             {

   479             ret = ChangeFocusL( aKeyEvent );

   480             }

   481 

   482         if ( ret != EKeyWasConsumed )

   483             {

   484         	DrawNow();

   485             }

   486         }

   487 

   488     if ( ret == EKeyWasNotConsumed )

   489         {

   490         ret = iFocused->OfferKeyEventL( aKeyEvent, aType );

   491 

   492         // Report user activity to auto saver if editor field handled the

   493         // event. In case of message field (body text), EKeyWasConsumed

   494         // condition does not come true because AknFep consumes EKeyEvent

   495         // and calls HandleEdwinEventL. This OfferKeyEventL gets only

   496         // EEventKeyUp and EEventKeyDown events. Thus, when typing body text,

   497         // autosaver is notified in HandleEdwinEventL()

   498         if ( ( ret == EKeyWasConsumed ) && ( iFocused != iMessageField ) )

   499             {

   500             iView.HandleContainerChangeRequiringToolbarRefresh();

   501             iAutoSaver.ReportActivity();

   502             }

   503         }

   504 

   505     return ret;

   506     }

   507 

   508 // -----------------------------------------------------------------------------

   509 // CNcsComposeViewContainer::UpdateScreenPositionL()

   510 // If the user scrolled down in the message field

   511 // we want to scroll up the header and grow the message field.

   512 // -----------------------------------------------------------------------------

   513 //

   514 void CNcsComposeViewContainer::UpdateScreenPositionL( const TUint& /*aKeyCode*/ )

   515     {

   516     FUNC_LOG;

   517 

   518     // get screen rectangle

   519     const TRect screenRect( Rect() );

   520 

   521     TPoint msgPos( iMessageField->Position() );

   522     TPoint quotePos( iReadOnlyQuoteField->Position() );

   523 

   524     // find out cursor position in absolute coordinates

   525     TRect lineRect;

   526     if ( iFocused == iMessageField )

   527         {

   528         iMessageField->GetLineRectL( lineRect );

   529         lineRect.Move( msgPos );

   530         }

   531     else if ( iFocused == iReadOnlyQuoteField )

   532         {

   533         iReadOnlyQuoteField->GetLineRectL( lineRect );

   534         lineRect.Move( quotePos );

   535         }

   536     else

   537         {

   538         // This function should be used only when focus is in body or read-only quote

   539         return;

   540         }

   541     TPoint linePos = lineRect.iTl;

   542 

   543     TInt minTargetY = lineRect.Height();

   544     TInt maxTargetY = screenRect.Height() - lineRect.Height() * 2;

   545 

   546     TInt moveY = 0;

   547     // if cursor goes out of screen then move the controls

   548     if ( linePos.iY > maxTargetY )

   549         {

   550         moveY = maxTargetY - linePos.iY;

   551         }

   552     else if ( linePos.iY < minTargetY )

   553         {

   554         moveY = minTargetY - linePos.iY;

   555         }

   556 

   557     // Check we don't scroll too low

   558     if ( quotePos.iY + moveY + iReadOnlyQuoteField->Size().iHeight < screenRect.Height() )

   559         {

   560         moveY = screenRect.Height() - quotePos.iY - iReadOnlyQuoteField->Size().iHeight;

   561         }

   562 

   563     // Check we don't scroll too high

   564     TPoint headerPos = iHeader->Position();

   565     if ( headerPos.iY + moveY > 0 )

   566         {

   567         moveY = -headerPos.iY;

   568         }

   569 

   570     if ( moveY )

   571         {

   572         headerPos.iY += moveY;

   573         iHeader->SetPosition( headerPos );

   574 

   575         msgPos.iY += moveY;

   576         iMessageField->SetPosition( msgPos );

   577 

   578         quotePos.iY += moveY;

   579         iReadOnlyQuoteField->SetPosition( quotePos );

   580 

   581         iSeparatorLineYPos += moveY;

   582         UpdateScrollBarL();

   583 

   584         //DrawDeferred();

   585         }

   586     }

   587 

   588 // -----------------------------------------------------------------------------

   589 // CNcsComposeViewContainer::UpdateFieldPosition

   590 //

   591 // -----------------------------------------------------------------------------

   592 //

   593 void CNcsComposeViewContainer::UpdateFieldPosition(CCoeControl* aAnchor)

   594     {

   595     FUNC_LOG;

   596 

   597 	// We may not be completely constructed

   598 	if ( iHeader && iMessageField && iReadOnlyQuoteField )

   599 	    {

   600 	    // First, move all the controls in the header

   601 	    iHeader->UpdateFieldPosition(aAnchor);

   602 

   603 	    // Then, move the body field below the header

   604 	    TRect headerRect = iHeader->Rect();

   605 	            

   606 		const TSize separatorSize( NcsUtility::SeparatorSizeInThisResolution() );

   607 		iSeparatorLineYPos = headerRect.iBr.iY;

   608 			

   609 		TPoint bodyPos( iMessageField->Position() );

   610 		bodyPos.iY = iSeparatorLineYPos + separatorSize.iHeight;

   611 		iMessageField->SetPosition( bodyPos );

   612 		

   613 		TPoint quotePos( iReadOnlyQuoteField->Position() );

   614 		quotePos.iY = iMessageField->Rect().iBr.iY;

   615 		iReadOnlyQuoteField->SetPosition( quotePos );

   616 

   617 	    TRAP_IGNORE(UpdateScrollBarL());

   618 

   619 	    DrawDeferred();

   620 	    }

   621 

   622     }

   623 

   624 // -----------------------------------------------------------------------------

   625 // CNcsComposeViewContainer::ChangeFocusL()

   626 // Handles key events

   627 // -----------------------------------------------------------------------------

   628 //

   629 

   630 TKeyResponse CNcsComposeViewContainer::ChangeFocusL( const TKeyEvent& aKeyEvent )

   631     {

   632     FUNC_LOG;

   633 

   634     TKeyResponse ret( EKeyWasNotConsumed );

   635 

   636     if ( iFocused == iReadOnlyQuoteField && aKeyEvent.iCode == EKeyUpArrow )

   637         {

   638         iFocused = iMessageField;

   639         iReadOnlyQuoteField->SetFocus( EFalse, EDrawNow );

   640         iMessageField->SetFocus( ETrue, EDrawNow );

   641         ret = EKeyWasConsumed;

   642         }

   643     else if ( iFocused == iMessageField )

   644 	    {

   645 	    if ( aKeyEvent.iCode == EKeyUpArrow )

   646 	        {

   647             iFocused = iHeader;

   648     		iHeader->SetFocus( ETrue,EDrawNow );

   649     		iMessageField->SetFocus( EFalse, EDrawNow );

   650     		iHeader->MakeVisible( ETrue );

   651             CommitL(EBodyField);

   652             ret = EKeyWasConsumed;

   653 	        }

   654 	    else if ( aKeyEvent.iCode == EKeyDownArrow && iReadOnlyQuoteField->TextLength() )

   655 	        {

   656 	        // Focus move to read-only quote only if there is some text in it.

   657 	        iFocused = iReadOnlyQuoteField;

   658 	        iReadOnlyQuoteField->SetFocus( ETrue, EDrawNow );

   659 	        iMessageField->SetFocus( EFalse, EDrawNow );

   660 	        iReadOnlyQuoteField->SetCursorPosL( 0, EFalse );

   661 	        ret = EKeyWasConsumed;

   662 	        }

   663         }

   664 	else if ( iFocused == iHeader && aKeyEvent.iCode == EKeyDownArrow )

   665         {

   666 		iFocused = iMessageField;

   667 		iHeader->SetFocus( EFalse, EDrawNow );

   668 		iMessageField->SetFocus( ETrue, EDrawNow );

   669         iMessageField->SetCursorPosL( 0, EFalse );

   670         ret = EKeyWasConsumed;

   671         }

   672 

   673     if ( ret == EKeyWasConsumed )

   674         {

   675         UpdateScreenPositionL( aKeyEvent.iCode );

   676         }

   677 

   678     return ret;

   679     }

   680 

   681 // -----------------------------------------------------------------------------

   682 // CNcsComposeViewContainer::UpdateFieldSizeL()

   683 // This is called through MNcsFieldSizeObserver when the rects have changed

   684 // -----------------------------------------------------------------------------

   685 //

   686 TBool CNcsComposeViewContainer::UpdateFieldSizeL()

   687     {

   688     FUNC_LOG;

   689 

   690 	// We may not have finished construction

   691 	if ( iHeader && iMessageField && iReadOnlyQuoteField )

   692 	    {

   693 	    SizeChanged();

   694 	    DrawDeferred();

   695 	    }

   696 

   697 	return EFalse;

   698     }

   699 

   700 // <cmail> Platform layout changes

   701 // -----------------------------------------------------------------------------

   702 // CNcsComposeViewContainer::SizeChanged()

   703 // set size

   704 // -----------------------------------------------------------------------------

   705 //

   706 void CNcsComposeViewContainer::SizeChanged()

   707     {

   708     FUNC_LOG;

   709 

   710     const TRect rect( Rect() );

   711     iScrollBar->SetRect( NcsUtility::ListCmailScrollbarRect( rect ) );

   712     TRect cmailPaneRect( NcsUtility::ListCmailPaneRect( rect ) );

   713 

   714     const TInt headerLineCount( iHeader->LayoutLineCount() );

   715     const TPoint headerPos( NcsUtility::HeaderControlPosition( cmailPaneRect, 0 ) );

   716     cmailPaneRect.Move( 0, iHeader->Position().iY - headerPos.iY );

   717 

   718     NcsUtility::LayoutHeaderControl( iHeader, cmailPaneRect, 0, headerLineCount );

   719 

   720     // do not used stored headerLineCount, because relayout above may grow or

   721     // shrink edit fields

   722     TRAP_IGNORE( iMessageField->FormatAllTextNowL() );

   723     NcsUtility::LayoutBodyEdwin( iMessageField, cmailPaneRect, iHeader->LayoutLineCount(), iMessageField->LineCount(),

   724             iSeparatorLineYPos );

   725 

   726     iMessageField->UpdateFontSize();

   727 

   728     TInt readOnlyQuoteFieldHeight( 0 );

   729     if ( iReadOnlyQuoteField->TextLength() )

   730         {

   731         TInt dummySeparatorPos;

   732         NcsUtility::LayoutBodyEdwin( iReadOnlyQuoteField, cmailPaneRect, headerLineCount + iMessageField->LineCount(), iReadOnlyQuoteField->LineCount(), 

   733         		dummySeparatorPos );

   734         iReadOnlyQuoteField->UpdateFontSize();

   735         readOnlyQuoteFieldHeight = iReadOnlyQuoteField->Rect().Height();

   736         }

   737 

   738     if ( iBgContext )

   739         {

   740         iBgContext->SetRect( Rect() );

   741         }  

   742     iMessageField->SetRealRect( Rect() );

   743     iReadOnlyQuoteField->SetRealRect( Rect() );

   744     

   745     TInt messageLineHeigth = NcsUtility::HeaderCaptionPaneRect( cmailPaneRect ).Height();

   746     iMessageEditorMinHeigth = cmailPaneRect.Height() - iHeader->Size().iHeight -

   747                               NcsUtility::SeparatorSizeInThisResolution().iHeight -

   748                               readOnlyQuoteFieldHeight;

   749     

   750     iMessageEditorMinHeigth -= iMessageEditorMinHeigth % messageLineHeigth;

   751     if ( iMessageEditorMinHeigth > messageLineHeigth )

   752         {

   753         TSize newSize( iMessageField->Size().iWidth,

   754                        Max( iMessageField->Size().iHeight, iMessageEditorMinHeigth ));

   755             

   756         iMessageField->SetSize( newSize );

   757         }

   758     else

   759         {

   760         iMessageEditorMinHeigth = messageLineHeigth;

   761         }

   762 

   763     TRAP_IGNORE( UpdateScrollBarL() );

   764     DrawNow();

   765     

   766     }

   767 // </cmail> Platform layout changes

   768 

   769 // -----------------------------------------------------------------------------

   770 // CNcsComposeViewContainer::Draw() const

   771 // Draws the display

   772 // -----------------------------------------------------------------------------

   773 //

   774 void CNcsComposeViewContainer::Draw( const TRect& /*aRect*/ ) const

   775     {

   776     FUNC_LOG;

   777 	// <cmail> S60 skin support

   778 	if ( iBgContext )

   779 	    {

   780     	CWindowGc& gc = SystemGc();

   781 

   782     	MAknsSkinInstance* skin = AknsUtils::SkinInstance();

   783 

   784     	if ( skin )

   785     		{

   786     		AknsDrawUtils::Background( skin, iBgContext, this, gc, Rect() );

   787     		}

   788 	    }

   789     }

   790 

   791 

   792 // -----------------------------------------------------------------------------

   793 // CNcsComposeViewContainer::SetBodyContentL()

   794 // -----------------------------------------------------------------------------

   795 //

   796 void CNcsComposeViewContainer::SetBodyContentL( const TDesC& aMessage,

   797     const TDesC& aReadOnlyQuote )

   798     {

   799     FUNC_LOG;

   800     delete iReadOnlyQuote;

   801     iReadOnlyQuote = NULL;

   802     if ( aReadOnlyQuote.Length() )

   803         {

   804         iReadOnlyQuote = aReadOnlyQuote.AllocL();

   805         }

   806 

   807     RMemReadStream inputStream( aMessage.Ptr(), aMessage.Size() );

   808     CleanupClosePushL( inputStream );

   809     iMessageField->RichText()->ImportTextL( 0, inputStream,

   810         CPlainText::EOrganiseByParagraph );

   811     CleanupStack::PopAndDestroy( &inputStream );

   812 

   813     // Activating the field will set the control to the end of the text

   814     iMessageField->ActivateL();

   815     iMessageField->SetCursorPosL(0,EFalse);

   816 

   817     inputStream.Open( aReadOnlyQuote.Ptr(), aReadOnlyQuote.Size() );

   818     CleanupClosePushL( inputStream );

   819     iReadOnlyQuoteField->RichText()->ImportTextL( 0, inputStream,

   820         CPlainText::EOrganiseByParagraph );

   821     CleanupStack::PopAndDestroy( &inputStream );

   822 

   823     // Activating the field will set the control to the end of the text

   824     iReadOnlyQuoteField->ActivateL();

   825     iReadOnlyQuoteField->SetCursorPosL(0,EFalse);

   826 

   827     // Recalculate the size of the body field

   828     SizeChanged();

   829     }

   830 

   831 // -----------------------------------------------------------------------------

   832 // CNcsComposeViewContainer::GetBodyContentLC()

   833 // -----------------------------------------------------------------------------

   834 //

   835 HBufC* CNcsComposeViewContainer::GetBodyContentLC()

   836     {

   837     FUNC_LOG;

   838     HBufC* body = NULL;

   839 

   840     TInt messageLength = iMessageField->TextLength();

   841     HBufC* message = HBufC::NewLC( messageLength );

   842     TPtr messagePtr = message->Des();

   843     iMessageField->GetText( messagePtr );

   844     NcsUtility::ConvertLineEndingsL( message );

   845     CleanupStack::Pop();

   846     CleanupStack::PushL( message );

   847     messageLength = message->Length();

   848 

   849     // Append read-only quote if present

   850     if ( iReadOnlyQuote )

   851         {

   852         TInt quoteLength = iReadOnlyQuote->Length();

   853         TInt length = messageLength + KIMSLineFeed().Length() + quoteLength;

   854         body = message->ReAllocL( length );

   855         CleanupStack::Pop( message );

   856         CleanupStack::PushL( body );

   857 

   858         TPtr bodyPtr = body->Des();

   859         bodyPtr.Append( KIMSLineFeed() );

   860         bodyPtr.Append( *iReadOnlyQuote );

   861         }

   862     else

   863         {

   864         body = message;

   865         }

   866 

   867     return body;

   868     }

   869 

   870 // -----------------------------------------------------------------------------

   871 // CNcsComposeViewContainer::BodyText()

   872 // -----------------------------------------------------------------------------

   873 //

   874 CRichText& CNcsComposeViewContainer::BodyText()

   875     {

   876     FUNC_LOG;

   877     return *iMessageField->RichText();

   878     }

   879 

   880 // -----------------------------------------------------------------------------

   881 // CNcsComposeViewContainer::HandleScrollEventL()

   882 // -----------------------------------------------------------------------------

   883 //

   884 void CNcsComposeViewContainer::HandleScrollEventL( CEikScrollBar* aScrollBar, TEikScrollEvent /*aEventType*/ )

   885     {

   886     // <cmail> Platform layout change

   887     FUNC_LOG;

   888     

   889     if( iPhysics )

   890         {

   891         iPhysics->StopPhysics();

   892         iPhysics->ResetFriction();

   893         }

   894 

   895     ScrollL( aScrollBar->ThumbPosition() );

   896     }

   897 

   898 // -----------------------------------------------------------------------------

   899 // CNcsComposeViewContainer::OperationCompleteL

   900 // -----------------------------------------------------------------------------

   901 //

   902 void CNcsComposeViewContainer::OperationCompleteL( TContactHandlerCmd /*aCmd*/,

   903     const RPointerArray<CFSEmailUiClsItem>& aContacts )

   904 	{

   905     FUNC_LOG;

   906 	if ( aContacts.Count() )

   907 		{

   908 		RPointerArray<CNcsEmailAddressObject> ncsObjects;

   909 		CleanupResetAndDestroyClosePushL( ncsObjects );

   910 

   911 		for ( TInt i = 0 ; i < aContacts.Count() ; i++ )

   912 			{

   913 			CNcsEmailAddressObject* object = CNcsEmailAddressObject::NewL( aContacts[i]->DisplayName(),

   914 					aContacts[i]->EmailAddress() );

   915 			if ( aContacts[i]->MultipleEmails() )

   916 				{

   917 

   918 				object->SetDisplayFull( ETrue );

   919 				}

   920 			CleanupStack::PushL( object );

   921 			ncsObjects.AppendL( object );

   922 			CleanupStack::Pop( object );

   923 			}

   924 

   925 		if ( iAppendAddresses == EAppendTo )

   926 			{

   927 			AppendToFieldAddressesL( ncsObjects );

   928 			}

   929 		// if Cc field is focused insert addresses in there

   930 		else if ( iAppendAddresses == EAppendCc )

   931 			{

   932 			AppendCcFieldAddressesL( ncsObjects );

   933 			}

   934 		// if Bcc field is focused insert addresses in there

   935 		else if ( iAppendAddresses == EAppendBcc )

   936 			{

   937 			AppendBccFieldAddressesL( ncsObjects );

   938 			}

   939 

   940 		CleanupStack::PopAndDestroy( &ncsObjects );

   941 		}

   942 	iView.HandleContainerChangeRequiringToolbarRefresh();

   943 	}

   944 

   945 void CNcsComposeViewContainer::OperationErrorL( TContactHandlerCmd, TInt /*aError*/ )

   946 	{

   947     FUNC_LOG;

   948 	//Nothing to do

   949 	}

   950 

   951 // -----------------------------------------------------------------------------

   952 // CNcsComposeViewContainer::HandleEdwinEventL

   953 // -----------------------------------------------------------------------------

   954 //

   955 void CNcsComposeViewContainer::HandleEdwinEventL( CEikEdwin* aEdwin,

   956     TEdwinEvent aEventType )

   957     {

   958     FUNC_LOG;

   959     if ( aEdwin == iMessageField || aEdwin == iReadOnlyQuoteField )

   960         {

   961         if ( aEventType == MEikEdwinObserver::EEventTextUpdate ||

   962              aEventType == MEikEdwinObserver::EEventNavigation )

   963             {

   964             iAutoSaver.ReportActivity();

   965 

   966             // Update screen position and scroll bar when text changed or cursor moved

   967             UpdateScreenPositionL();

   968             UpdateScrollBarL();

   969             DrawDeferred();

   970             }

   971         }

   972     }

   973 

   974 // -----------------------------------------------------------------------------

   975 // CNcsComposeViewContainer::HandleEdwinSizeEventL

   976 // -----------------------------------------------------------------------------

   977 //

   978 TBool CNcsComposeViewContainer::HandleEdwinSizeEventL( CEikEdwin* aEdwin,

   979         TEdwinSizeEvent /*aEventType*/, TSize aDesirableEdwinSize )

   980     {

   981     FUNC_LOG;

   982     TBool ret = ETrue;

   983     

   984     const TRect rect( Rect() );

   985     TRect cmailPaneRect( NcsUtility::ListCmailPaneRect( rect ) );

   986 

   987     if ( aDesirableEdwinSize.iHeight < iPrevDesiredHeigth )

   988         {

   989         if ( aDesirableEdwinSize.iHeight < iMessageEditorMinHeigth )

   990             {

   991             ScrollL( 0 );

   992             }

   993         }

   994 

   995     if ( aEdwin == iMessageField ) 

   996         {

   997         if ( aDesirableEdwinSize.iHeight >= iMessageEditorMinHeigth )

   998             {

   999             aEdwin->SetSize( aDesirableEdwinSize );

  1000             }        

  1001         }

  1002     else

  1003         {

  1004         aEdwin->SetSize( aDesirableEdwinSize );

  1005         }

  1006     if ( aEdwin == iMessageField )

  1007         {

  1008         // move the quote field below the body field

  1009         TPoint quotePos = iMessageField->Position();

  1010         quotePos.iY += iMessageField->Size().iHeight;

  1011         iReadOnlyQuoteField->SetPosition( quotePos );

  1012 		UpdateScreenPositionL(); 

  1013         }

  1014 

  1015     iPrevDesiredHeigth = aDesirableEdwinSize.iHeight;

  1016 

  1017     return ret;

  1018     }

  1019 

  1020 // -----------------------------------------------------------------------------

  1021 // CNcsComposeViewContainer::MopSupplyObject

  1022 // From CCoeControl.

  1023 // -----------------------------------------------------------------------------

  1024 //

  1025 TTypeUid::Ptr CNcsComposeViewContainer::MopSupplyObject( TTypeUid aId )

  1026     {

  1027     FUNC_LOG;

  1028     return CCoeControl::MopSupplyObject( aId );

  1029     }

  1030 

  1031 // -----------------------------------------------------------------------------

  1032 // CNcsComposeViewContainer::UpdateScrollBarL()

  1033 // -----------------------------------------------------------------------------

  1034 //

  1035 void CNcsComposeViewContainer::UpdateScrollBarL()

  1036 	{

  1037     FUNC_LOG;

  1038 

  1039     TRect headerRect = iHeader->Rect();

  1040     TRect bodyRect = iMessageField->Rect();

  1041     TRect quoteRect = iReadOnlyQuoteField->Rect();

  1042     const TSize separatorSize( NcsUtility::SeparatorSizeInThisResolution() );

  1043 

  1044     TInt totalComposerHeight = headerRect.Height() + separatorSize.iHeight*2 + 

  1045 							   bodyRect.Height() + quoteRect.Height();

  1046     

  1047     TInt visibleAreaHeight = Rect().Height();

  1048     TInt visiblePosition = -headerRect.iTl.iY;

  1049 

  1050     iScrollBarModel.SetScrollSpan( totalComposerHeight );

  1051     iScrollBarModel.SetWindowSize( visibleAreaHeight );

  1052     iScrollBarModel.SetFocusPosition( visiblePosition );

  1053 

  1054     iScrollBar->SetModelL( &iScrollBarModel );

  1055     iScrollBar->DrawNow();

  1056 	}

  1057 

  1058 // -----------------------------------------------------------------------------

  1059 // CNcsComposeViewContainer::SetApplicationRect()

  1060 // -----------------------------------------------------------------------------

  1061 //

  1062 // <cmail>

  1063 /*

  1064 void CNcsComposeViewContainer::SetApplicationRect( TRect aRect )

  1065 	{

  1066     FUNC_LOG;

  1067 

  1068 	iApplicationRect = aRect;

  1069 

  1070 	}

  1071 */

  1072 // </cmail>

  1073 

  1074 

  1075 // -----------------------------------------------------------------------------

  1076 // CNcsComposeViewContainer::SetFocusToMessageFieldL()

  1077 // -----------------------------------------------------------------------------

  1078 //

  1079 void CNcsComposeViewContainer::SetFocusToMessageFieldL()

  1080     {

  1081     FUNC_LOG;

  1082 

  1083     if( iFocused != iMessageField )

  1084         {

  1085         iHeader->SetFocus( EFalse, ENoDrawNow );

  1086         iMessageField->SetCursorPosL( 0, EFalse );

  1087         iMessageField->SetFocus( ETrue, EDrawNow );

  1088         iFocused = iMessageField;

  1089         UpdateScreenPositionL();

  1090         DrawDeferred();

  1091         }

  1092 

  1093     }

  1094 

  1095 // -----------------------------------------------------------------------------

  1096 // CNcsComposeViewContainer::AddQuickTextL()

  1097 // -----------------------------------------------------------------------------

  1098 //

  1099 void CNcsComposeViewContainer::AddQuickTextL( const TDesC& aText )

  1100     {

  1101     FUNC_LOG;

  1102 

  1103 	TInt pos = iMessageField->CursorPos();

  1104 	TCursorSelection selIns( pos, pos );

  1105 	iMessageField->InsertDeleteCharsL( pos, aText, selIns );

  1106 	DrawDeferred();

  1107 

  1108     }

  1109 

  1110 // -----------------------------------------------------------------------------

  1111 // CNcsComposeViewContainer::SelectAllToFieldTextL

  1112 //

  1113 // -----------------------------------------------------------------------------

  1114 //

  1115 void CNcsComposeViewContainer::SelectAllToFieldTextL()

  1116 	{

  1117     FUNC_LOG;

  1118 

  1119 	iHeader->SelectAllToFieldTextL();

  1120 

  1121 	}

  1122 

  1123 // -----------------------------------------------------------------------------

  1124 // CNcsComposeViewContainer::SelectAllCcFieldTextL

  1125 //

  1126 // -----------------------------------------------------------------------------

  1127 //

  1128 void CNcsComposeViewContainer::SelectAllCcFieldTextL()

  1129 	{

  1130     FUNC_LOG;

  1131 

  1132 	iHeader->SelectAllCcFieldTextL();

  1133 

  1134 	}