/*

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

* All rights reserved.

* This component and the accompanying materials are made available

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

* which accompanies this distribution, and is available

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

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:  compose view container

*

*/

// INCLUDE FILES

#include "emailtrace.h"

#include <s32mem.h>

#include <txtrich.h>

#include <AknIconUtils.h>

#include <StringLoader.h>

#include <avkon.hrh>

#include <AknsDrawUtils.h>

#include <aknview.h>

#include <AknUtils.h>

#include <FreestyleEmailUi.rsg>

#include <eikclbd.h>

#include <aknViewAppUi.h>

#include <aknnotewrappers.h> //CAknInformationNote

#include <txtetext.h>

#include <aknphysics.h>

#include "ncscomposeviewcontainer.h"

#include "ncsheadercontainer.h"

#include "ncsaddressinputfield.h"

#include "ncssubjectfield.h"

#include "ncsconstants.h"

#include "ncseditor.h"

#include "ncspopuplistbox.h"

#include "ncscomposeview.h"

#include "ncsutility.h"

#include "ncsemailaddressobject.h"

#include "FreestyleEmailUiUtilities.h"

#include "FreestyleEmailUiConstants.h"

#include "FreestyleEmailUiSendAttachmentsListControl.h"

#include "FreestyleEmailUiSendAttachmentsListVisualiser.h"

#include "FreestyleEmailUiSendAttachmentsListModel.h"

#include "FreestyleEmailUi.hrh"

#include "FSAutoSaver.h"

#include "FreestyleEmailUiCLSItem.h"

#include "FSAsyncTextFormatter.h"

const TInt KHeaderVisibilityThreshold = -100;

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

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

// constructor

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

//

CNcsComposeViewContainer::CNcsComposeViewContainer(

    CNcsComposeView& aView,

    CFsAutoSaver& aAutoSaver,

	CFSMailBox& aMailBox ):

	iView( aView ), iAmountMesFieldMovedUp( 0 ),

	iAutoSaver( aAutoSaver ), iMailBox( aMailBox )

    {

    FUNC_LOG;

    }

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

// CNcsComposeViewContainer::NewL()

// Two-phased constructor.

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

//

CNcsComposeViewContainer* CNcsComposeViewContainer::NewL( 

    CNcsComposeView& aView, const TRect& aRect, CFSMailBox& aMailBox, 

    CFsAutoSaver& aAutoSaver, TInt aFlags )

    {

    FUNC_LOG;

    CNcsComposeViewContainer* self = new ( ELeave ) CNcsComposeViewContainer(

        aView, aAutoSaver, aMailBox );

    CleanupStack::PushL( self );

    self->ConstructL( aRect, aFlags );

    CleanupStack::Pop( self );

    return self;

    }

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

// CNcsComposeViewContainer::ConstructL()

// Symbian 2nd phase constructor can leave.

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

//

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

    {

    FUNC_LOG;

    SetMopParent( &iView );

    CreateWindowL();

    if ( CAknPhysics::FeatureEnabled() )

        {

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

        }

    // Setup the control array

    InitComponentArrayL();

    CCoeControlArray& controls = Components();

    controls.SetControlsOwnedExternally( ETrue );

    // Create the header field

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

    controls.AppendLC( iHeader );

    CleanupStack::Pop( iHeader );

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

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

    iMessageField->SetContainerWindowL( *this );

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

    iMessageField->SetAlignment( EAknEditorAlignBidi );

    iMessageField->SetAknEditorInputMode( EAknEditorTextInputMode );

    iMessageField->EnableKineticScrollingL( iPhysics );

    controls.AppendLC( iMessageField );

    CleanupStack::Pop( iMessageField );

    iMessageField->SetNcsFontType( NcsUtility::ENcsBodytextFont );

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

    iMessageField->AddEdwinObserverL( this );

    iMessageField->SetEdwinSizeObserver( this );

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

    // protocol doesn't allow editing the original message

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

    iReadOnlyQuoteField->SetContainerWindowL( *this );

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

    iReadOnlyQuoteField->SetAlignment( EAknEditorAlignBidi );

    iReadOnlyQuoteField->SetReadOnly( ETrue );

    controls.AppendLC( iReadOnlyQuoteField );

    CleanupStack::Pop( iReadOnlyQuoteField );

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

    iReadOnlyQuoteField->AddEdwinObserverL( this );

    iReadOnlyQuoteField->SetEdwinSizeObserver( this );

   iReadOnlyQuoteField->EnableKineticScrollingL( iPhysics );

    // Create the scroll bar

    iScrollBar = new( ELeave ) CAknDoubleSpanScrollBar( this );

    iScrollBar->ConstructL( ETrue, this, this, CEikScrollBar::EVertical,

        aRect.Height() );

    iScrollBar->MakeVisible( EFalse );

    iScrollBar->SetModelL( &iScrollBarModel );

    controls.AppendLC( iScrollBar );

    CleanupStack::Pop( iScrollBar );

    iMessageField->SetupEditorL();

    iReadOnlyQuoteField->SetupEditorL();

    iBgContext = CAknsBasicBackgroundControlContext::NewL(

        KAknsIIDQsnBgAreaMain, Rect(), EFalse );

    SetRect( aRect );

    iLongTapDetector = CAknLongTapDetector::NewL( this );

    // activate auto save functionality

    iAutoSaver.Enable( ETrue );

    }

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

// CNcsComposeViewContainer::StopAsyncTextFormatter

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

//

void CNcsComposeViewContainer::StopAsyncTextFormatter()

    {

    if ( iAsyncTextFormatter )

        {

        iAsyncTextFormatter->Cancel();

        }

    }

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

// CNcsComposeViewContainer::~CNcsComposeViewContainer

// Destructor

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

//

CNcsComposeViewContainer::~CNcsComposeViewContainer()

    {

    FUNC_LOG;

    if ( iAsyncTextFormatter )

        {

        iAsyncTextFormatter->Cancel();

        delete iAsyncTextFormatter;

        }

    if ( iContactHandler )

        {

        iContactHandler->ClearObservers();

        }

	delete iHeader;

    delete iScrollBar;

    delete iMessageField;

    delete iBgContext;

	delete iLongTapDetector;

    delete iReadOnlyQuoteField;

    delete iReadOnlyQuote;

    delete iPhysics;

    iPhysics = NULL;

    }

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

// CNcsComposeViewContainer::FocusChanged

//

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

//

void CNcsComposeViewContainer::FocusChanged( TDrawNow aDrawNow )

    {

    FUNC_LOG;

	if ( iFocused != iHeader &&

	     iFocused != iMessageField &&

	     iFocused != iReadOnlyQuoteField )

        {

		iFocused = iHeader;

        }

    if ( iFocused == iHeader )

        {

        iHeader->ShowCursor( IsFocused() );

        iFocused->SetFocus( ETrue, aDrawNow );

        }

    else if ( iFocused == iMessageField )

        {

        iFocused->SetFocus( IsFocused(), aDrawNow );

        }

    else 

        {

        iFocused->SetFocus( ETrue, aDrawNow );

        }

    iView.HandleContainerChangeRequiringToolbarRefresh();

	if ( aDrawNow )

	    {

		DrawNow();

	    }

    }

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

// CNcsComposeViewContainer::SetMskL()

//

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

//

void CNcsComposeViewContainer::SetMskL()

    {

    FUNC_LOG;

    iHeader->SetMskL();

    }

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

// CNcsComposeViewContainer::HandlePointerEventL()

//

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

//

void CNcsComposeViewContainer::HandlePointerEventL( 

        const TPointerEvent& aPointerEvent )

    {

    FUNC_LOG;

	TBool clearSelection(EFalse);

    if ( aPointerEvent.iType != TPointerEvent::EButton1Down &&

         iHeader->NeedsLongTapL( aPointerEvent.iPosition ) )

        {

    	iLongTapDetector->PointerEventL( aPointerEvent );

        }

    switch( aPointerEvent.iType )

    	{

    	case TPointerEvent::EButton1Down:

    		{

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

            // drag/scrolling calculations

            iPreviousPosition = iOriginalPosition = 

                aPointerEvent.iPosition;

            iIsDragging = EFalse;

            iIsFlicking = EFalse;

            if( iPhysics )

                {

                iPhysics->StopPhysics();

                iPhysics->ResetFriction();

                iStartTime.HomeTime();

                UpdatePhysicsL();

                }            

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

                {

                if ( iFocused == iMessageField )

                    {

					if( iMessageField->SelectionLength() )

						{

						iMessageField->ClearSelectionL();

						}

                    iMessageField->SetFocus( EFalse, ENoDrawNow );

                    iFocused = iHeader;

                    iHeader->SetFocus( ETrue,ENoDrawNow );

                    }

                else if ( iFocused == iReadOnlyQuoteField )

                    {

                    iReadOnlyQuoteField->SetFocus( EFalse, ENoDrawNow );

                    iFocused = iHeader;

                    iHeader->SetFocus( ETrue, ENoDrawNow );

                    }

                }

            else if ( iReadOnlyQuoteField->Rect().Contains( 

                        aPointerEvent.iPosition ) )

                {

                if ( iFocused == iMessageField )

                    {

                    iMessageField->SetFocus( EFalse, ENoDrawNow );

                    iFocused = iReadOnlyQuoteField;

                    iReadOnlyQuoteField->SetFocus( ETrue, ENoDrawNow );

                    iReadOnlyQuoteField->SetCursorPosL( 0, EFalse );

                    }

                else if ( iFocused == iHeader )

                    {

                    iHeader->SetFocus( EFalse, ENoDrawNow );

                    iFocused = iReadOnlyQuoteField;

                    iReadOnlyQuoteField->SetFocus( ETrue, ENoDrawNow );

                    iReadOnlyQuoteField->SetCursorPosL( 0, EFalse );

                    }

                }

            else 

                {

                if ( iFocused == iHeader )

                    {

                    iHeader->SetFocus( EFalse, ENoDrawNow );

                    iFocused = iMessageField;

                    iMessageField->SetFocus( ETrue, ENoDrawNow );

                    }

                else if ( iFocused == iReadOnlyQuoteField )

                    {

                    iReadOnlyQuoteField->SetFocus( EFalse, ENoDrawNow );

                    iFocused = iMessageField;

                    iMessageField->SetFocus( ETrue, ENoDrawNow );

                    }

                else

                    {

				    // Changes made in predictive input mode can be approved

					// only if ClearSelection is called AFTER

					// CCoeControl::HandlePointerEventL,

					// so iMessageField->ClearSelection() has been moved

					clearSelection = ETrue;

                    }

                }

			break;

    		}

    	case TPointerEvent::EButton1Up:    		

    		{

            if( iIsDragging && iPhysics )

                {

                TPoint drag( iOriginalPosition - aPointerEvent.iPosition );

                iPhysics->StartPhysics( drag, iStartTime );

                iIsFlicking = ETrue;

                iIsDragging = EFalse;

                }

    		break;

    		}

    	case TPointerEvent::EDrag:

    		{

            if ( !iIsDragging )

                {

                TInt drag( iOriginalPosition.iY - aPointerEvent.iPosition.iY );

                if ( Abs( drag ) > iPhysics->DragThreshold() )

                    {

					// If user started dragging, cancel hotspot actions

					iIsDragging = ETrue;

					iMessageField->SetPhysicsEmulationOngoing( ETrue );

					iReadOnlyQuoteField->SetPhysicsEmulationOngoing( ETrue );

					iHeader->SetPhysicsEmulationOngoing( ETrue );

                    }

                }

            // Get current pointer position

            TPoint position = aPointerEvent.iPosition;

           if( iPhysics )

               {

			   if ( iIsDragging )

				   {

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

                    if ( !iMessageField->SelectionLength() )

                    		iPhysics->RegisterPanningPosition( delta );

				   }

                }

            else

                {

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

    			TInt totalHeight( ContentTotalHeight() );

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

    			TInt scrollOffset( 0 );

				if( totalHeight > areaHeight )

					{

					// Calculate new scroll offset based on current and

					// previous Y-positions

					scrollOffset = topPosition + 

                        ( iPreviousPosition.iY - position.iY );

					// Ensure that thumb position is in correct range

					scrollOffset = Max( scrollOffset, 0 );

					scrollOffset = Min( scrollOffset, 

                                        totalHeight - areaHeight );

					}

				Scroll( scrollOffset );

				}

			// Save current position as previous pos for future calculations

			iPreviousPosition = position;  

			break;

    		}

    	default:

    		{

    		// unknown event, ignored

    		break;

    		}

    	}

    if ( aPointerEvent.iType == TPointerEvent::EButton1Down &&

         iHeader->NeedsLongTapL( aPointerEvent.iPosition ) )

        {

        iLongTapDetector->PointerEventL( aPointerEvent );

        }

    CCoeControl::HandlePointerEventL( aPointerEvent );

	if (clearSelection)

		{

		iMessageField->ClearSelectionL();

		}

    }

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

// CNcsComposeViewContainer::OfferKeyEventL()

// Handles key events

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

//

TKeyResponse CNcsComposeViewContainer::OfferKeyEventL( 

        const TKeyEvent& aKeyEvent, TEventCode aType )

    {

    FUNC_LOG;

    if( iPhysics )

        {

        iPhysics->StopPhysics();

        iPhysics->ResetFriction();

        }

    TKeyResponse ret( EKeyWasNotConsumed );

    //we are allowing to change MSK label 

    SwitchChangeMskOff( EFalse );

    if ( aKeyEvent.iCode == EKeyYes )

        {

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

        if ( !iHeader->AreAddressFieldsEmpty() )

            {

            iView.HandleCommandL( ENcsCmdSend );

            }

        else

            {

            AppendAddressesL();

            }

        ret = EKeyWasConsumed;

        }

    else if ( aKeyEvent.iCode == EKeyOK )

    	{

        if ( iHeader->IsPopupActive() )

            {

            DoPopupSelectL();

            ret = EKeyWasConsumed;

            }

        else if ( AppendAddressesL() )

            {

            ret = EKeyWasConsumed;

            }

        }

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

              aKeyEvent.iModifiers & EModifierCtrl &&

              aType == EEventKey )

        {

        iView.HandleCommandL( ENcsCmdSaveDraft );

        ret = EKeyWasConsumed;

        }

    else if ( aKeyEvent.iCode == EKeyUpArrow || 

              aKeyEvent.iCode == EKeyDownArrow )

        {

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

        if ( ret == EKeyWasNotConsumed )

            {

            ret = ChangeFocusL( aKeyEvent );

            }

        if ( ret != EKeyWasConsumed )

            {

            DrawDeferred();

            }

        }

    if ( ret == EKeyWasNotConsumed )

        {

        if ( iFocused )