/*

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

* All rights reserved.

* This component and the accompanying materials are made available

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

* which accompanies this distribution, and is available

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

*

* Initial Contributors:

* Nokia Corporation - Initial contribution

* 

* Contributors:

* 

* 

* Description:

* Export help related files.

*

*/

// INCLUDE FILES

#include	"cimcvappviewcontainer.h"

#include    "cimcvengine.h"

#include 	"mimcvenginemessagesreadinterface.h"

#include 	"mimcvenginemessageswriteinterface.h"

#include    "cimcvappviewcontrol.h"

#include 	"cimcvenginemessagecreator.h"

#include    "mimcvenginemessage.h"

#include	"cimcvappui.h"

#include 	"imcvuiappnotemapper.h"

#include 	"mimcvapplayoutinfo.h"

#include 	"imcvlogger.h"

#include 	"cimcvappbitmapmapping.h"

#include 	"mimcvuiappskinvariant.h"

#include 	"imcvuiapputils.h"

#include 	"cimcvappmessageextensionshandler.h"

#include 	"mimcvenginemessagecontainerinfo.h"

#include 	"mimcvenginemessagehandler.h"

#include 	"mimcvrecipientobserver.h"

#include    "imcvuiapp.hrh"

//consts

#include 	"imcvuiliterals.h"

#include    "imcvuiapp.h"

#include    <StringLoader.h>

#include 	<txtrich.h>

#include    <aknlayout.cdl.h> //cdl 

#include    <applayout.cdl.h> //cdl 

#include    <AknsUtils.h>

#include    <aknlayoutscalable_apps.cdl.h>

#include    <aknnotewrappers.h>

#include    <AknFepGlobalEnums.h> // for EAknFepSoftkeySpell

#include    <AknIconUtils.h>

#include 	<imcvuiapp.rsg>

#include 	<imerrors.hrh>

#include "conversations.h"

#include "cimcvapplogineventlistener.h"

#include "cimcvappwaitnote.h"

#include <aknEditStateIndicator.h>

#include <AknIndicatorContainer.h>

#include "mimcvenginecchhandler.h"

#include "mimcvenginemessageswriteinterface.h"

#include "mimcvenginechatinterface.h"

#include <finditemengine.h>

#include <e32property.h>

#include "cimcvappview.h"

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

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

// CIMCVAppViewContainer::NewL

// Symbian constructor can leave.

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

//

CIMCVAppViewContainer* CIMCVAppViewContainer::NewL( 

            const TRect& aRect,

            CIMCVEngine* aEngine,

            MIMCVEngineMessageReadInterface* aReadInterface,

		    MIMCVEngineMessageWriteInterface* aWriteInterface,

		    CIMCVAppView* aParent,

            CIMCVAppMessageExtensionsHandler& aMessageHandler,

			CEikButtonGroupContainer* aCba,

			const TDesC& aRecipientId,			

			MIMCVRecipientObserver* aRecipientObserver,

            CIMCVAppRichTextContainerCache* aRTContainerCache,

            CGulIcon* aFromMe, CGulIcon* aToMe)

	{

	IM_CV_LOGS(TXT("CIMCVAppViewContainer::NewL()  start") );

	CIMCVAppViewContainer* self = new ( ELeave )

			 CIMCVAppViewContainer(aEngine,aReadInterface,aWriteInterface,

			aMessageHandler, aCba, aRecipientObserver,*aParent, aRTContainerCache );

	CleanupStack::PushL( self );

	self->ConstructL( aRect, aParent, aFromMe, aToMe,aRecipientId);

	CleanupStack::Pop( self );

	IM_CV_LOGS(TXT("CIMCVAppViewContainer::NewL()  end") );

	return self;

	}

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

// CIMCVAppViewContainer::CIMCVAppViewContainer

// Default constructor must not leave

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

//

CIMCVAppViewContainer::CIMCVAppViewContainer(CIMCVEngine* aEngine,

			MIMCVEngineMessageReadInterface* aReadInterface,

		    MIMCVEngineMessageWriteInterface* aWriteInterface, 

            CIMCVAppMessageExtensionsHandler& aMessageHandler,

			CEikButtonGroupContainer* aCba,

			MIMCVRecipientObserver* aRecipientObserver,

			CIMCVAppView& aAppView,

            CIMCVAppRichTextContainerCache* aRTContainerCache):

            iActiveEngine(aEngine),

  iReadInterface(aReadInterface),

  iWriteInterface(aWriteInterface),

  iMessageExtensionsHandler( aMessageHandler ),

  iCba( aCba ),

  iRecipientObserver( aRecipientObserver ),  

  iAppView(aAppView),

  iRTContainerCache(aRTContainerCache)

    {

    IM_CV_LOGS(TXT("CIMCVAppViewContainer::CIMCVAppViewContainer() start") );

    // take virtual ownership of interfaces, so that they are not deleted

    IM_CV_LOGS(TXT("CIMCVAppViewContainer::CIMCVAppViewContainer() end") );

   	}

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

// CIMCVAppViewContainer::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CIMCVAppViewContainer::ConstructL( const TRect& aRect, 

                                            MObjectProvider* aParent,                                            

                                            CGulIcon* aFromMe, CGulIcon* aToMe,

                                            const TDesC& aRecipientId )

	{	

	IM_CV_LOGS(TXT("CIMCVAppViewContainer::ConstructL() start") );

	// for getting mbm path from CIMCVAPPAppUi

	iRecipientId = aRecipientId.AllocL();

	iAppUi = static_cast<CIMCVAppUi*>( CEikonEnv::Static()->AppUi() );

	iAppUi->AddLayoutChangeObserver( this );

	// This must be done first.

	SetMopParent( aParent );

	CreateWindowL();

	iSkinVaiant = iAppUi->SkinVariantL();

	iFromMe = aFromMe;

	iToMe = aToMe;

	//Load from-me and to-me icons

	if(!iFromMe)

	    {

	    iFromMe = LoadBitmapL(KEMbmImcvuiappQgnpropimfrom,EMbmImcvuiappQgn_prop_im_from,EMbmImcvuiappQgn_prop_im_from_mask);

	    }

	if(!iToMe)

	    {

	    iToMe = LoadBitmapL(KEMbmImcvuiappQgnpropimtome,EMbmImcvuiappQgn_prop_im_tome,EMbmImcvuiappQgn_prop_im_tome_mask );

	    }

	iMsgEditor = CIMCVAppMessageEditor::NewL(this, iAppUi->MbmFullPath(), iAppView,

	        iMessageExtensionsHandler );

	iMsgEditor->SetMessageEditorObserver(this);

	//Sets the previously typed message in the editor

	iMsgEditor->SetTextL( iReadInterface->GetEditerMessage() );

	iChatView = CIMCVAppViewControl::NewL( aRect,

                            	        *this,

                            	        *iReadInterface,

                            	        iMessageExtensionsHandler,

                            	        iFromMe, 

                            	        iToMe,

                            	        *iRTContainerCache,

                            	        *iActiveEngine );

	iChatView->SetObserver( this );

	iMsgEditor->SetObserver( this );

	iAppUi->LayoutInfo()->SetLayoutID( TChatListBoxLayout::EWithEditor );

	iAppUi->LayoutInfo()->SetEditorVisibility( ETrue );

	SetRect( aRect );

	iMsgEditor->Editor().SetCursorPosL(0, EFalse);

	iChatView->SetFocus( EFalse );

	iMsgEditor->SetFocus(EFalse);

	ActivateL();

	iChatView->SetTapObserver( this, EMessageList );

	iMsgEditor->SetTapObserver( this, EMessageEditor );

	IM_CV_LOGS(TXT("CIMCVAppViewContainer::ConstructL() end") );

	}

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

// CIMCVAppViewContainer::~CIMCVAppViewContainer()

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

//

CIMCVAppViewContainer::~CIMCVAppViewContainer()

    {

	IM_CV_LOGS(TXT("CIMCVAppViewContainer::DESTRUCTING() DESTRUCTER GETTING CALLED end") );    

    if(iChatView)

        {

        delete iChatView;

        }

    if(iEditorMessage)

        {

        delete iEditorMessage;

        }

    delete iMsgEditor;

    if( iAppUi )

        {

        if( !iAppUi->IsUnderDestruction() )

            {

            iAppUi->LayoutInfo()->SetEditorVisibility( EFalse );

            iAppUi->RemoveLayoutChangeObserver( this );

            }

        }	

    }

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

// CIMCVAppViewContainer::SetServiceParametersL()

// This method is called when scrolling is started again

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

//          

void CIMCVAppViewContainer::SetServiceParametersL( 

                                CIMCVEngine* aNewEngine )

    {

    iActiveEngine = aNewEngine;

    }

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

// CIMCVAppViewContainer::StartScrollingL()

// This method is called when scrolling is started again

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

//

void CIMCVAppViewContainer::StartScrollingL()

	{

	IM_CV_LOGS(TXT("CIMCVAppViewContainer::StartScrollingL() start") );

	// disable highlight and set focus to editor

    if( iChatView->Highlighted() )

        {

        iChatView->DisableHighlightL();

        }       

    iMsgEditor->SetFocus( ETrue, EDrawNow );

    iMsgEditor->DrawDeferred();

    UpdateCbaL();

    iAppView.UpdateToolbarButtonsStateL();

    IM_CV_LOGS(TXT("CIMCVAppViewContainer::StartScrollingL() end") );

	}

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

// CIMCVAppViewContainer::StopScrollingL()

// (other items were commented in a header).

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

//

void CIMCVAppViewContainer::StopScrollingL()

	{

	IM_CV_LOGS(TXT("CIMCVAppViewContainer::StopScrollingL() start") );

	// unfocus editor (highlighting is enabled 

	// automatically in OfferKeyEvent of ChatView)

	iMsgEditor->SetFocus( EFalse, EDrawNow );

	iMsgEditor->DrawDeferred();

    // Set editor cursor pos to end of text

	iMsgEditor->Editor().SetCursorPosL( iMsgEditor->TextLength(), EFalse );

    UpdateCbaL();

    iAppView.UpdateToolbarButtonsStateL();

    IM_CV_LOGS(TXT("CIMCVAppViewContainer::StopScrollingL() end") );

	}

void CIMCVAppViewContainer :: SmileyDialogLaunched (TBool aLaunched)

    {

    iChatView->SmileyDialogLaunched (aLaunched);

    }

void CIMCVAppViewContainer :: UpdateChatViewL ()

    {

    iChatView->UpdateChatViewL ();

    }

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

// CIMCVAppViewContainer::UpdateCbaL()

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

//

void CIMCVAppViewContainer::UpdateCbaL()

    {

    IM_CV_LOGS(TXT("CIMCVAppViewContainer::UpdateCbaL() start") );

    if( iChatView->Highlighted() )

        {

        // focus on chatview

        HBufC* item = iChatView->SelectedItemL();

        CleanupStack::PushL( item );

        if( item && item->Length() > 0 )

            {

            // automatic find item selected

            TInt cbaRes = R_CV_SOFTKEYS_OPTIONS_BACK__CONTEXTOPTIONS;

            iCba->SetCommandSetL( cbaRes );

            iCba->DrawNow();

            }

        CleanupStack::PopAndDestroy( item );        

        }

    IM_CV_LOGS(TXT("CIMCVAppViewContainer::UpdateCbaL() end") );    

    }

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

// CIMCVAppViewContainer::HandleMessageEditorEventL()

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

//

void CIMCVAppViewContainer::HandleMessageEditorEventL( TEditorEvent aEvent )

	{

	IM_CV_LOGS(TXT("CIMCVAppViewContainer::HandleMessageEditorEventL() start") );

	switch( aEvent )

        {

	    case EEditorContentCleared: 

	        {	        

	        // Call StartScrollingL to update CBA if needed

	        StartScrollingL();

	        break;	

	        }

	    case EEditorContentChanged:

	        {            

	        // Call StartScrollingL to update CBA if needed

	        if(!iMsgEditor->IsFocused())//!iEditor->IsFocused())

	            {

	            StartScrollingL();	

	            }

	        break;

	        }

	    default:

	        {

	        break;

	        }

        }    

    // need to implements	

	IM_CV_LOGS(TXT("CIMCVAppViewContainer::HandleMessageEditorEventL() end") );	

	}

void CIMCVAppViewContainer::StartConversationL()

	{

	IM_CV_LOGS(TXT("CIMCVAppViewContainer::StartConversationL() start") );

	// start a conversation with selected user id,

	// exist cache info fetch that

	iActiveEngine->MessageHandler().StartNewConversationL( *iRecipientId );

	IM_CV_LOGS(TXT("CIMCVAppViewContainer::StartConversationL() end") );

	}

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

// CIMCVAppViewContainer::CloseConversationL()

// This method handles message sending to engine

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

//

TInt CIMCVAppViewContainer::CloseConversationL(const TDesC& aBuddyId )

	{

	IM_CV_LOGS(TXT("CIMCVAppViewContainer::CloseConversationL()") );

	// close the conversation with selected user id,

	// exist cache info fetch that

	iRTContainerCache->DeleteContainer(iReadInterface->Name() ,iActiveEngine->GetServiceId()  );

	return iActiveEngine->MessageHandler().CloseConversationL( aBuddyId );

	}

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

// CIMCVAppViewContainer::DeactivateConversationL()

// This method handles message sending to engine

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

//

TInt CIMCVAppViewContainer::DeactivateConversationL()

	{

	IM_CV_LOGS(TXT("CIMCVAppViewContainer::DeactivateConversationL()") );

	// start a conversation with selected user id,

	// exist cache info fetch that

	return iActiveEngine->MessageHandler().DeactivateConversationL();

	}	

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

// CIMCVAppViewContainer::SendMessageL()

// This method handles message sending to engine

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

//

void CIMCVAppViewContainer::SendMessageL()

	{

	IM_CV_LOGS(TXT("CIMCVAppViewContainer::SendMessageL() start") );

	TBool loggedIn = IsLoggedIn();

	if( !loggedIn )

		{

		// load the promp from lOC file + server name

		HBufC* prompt = StringLoader::LoadLC( R_SERVTAB_CONNECTION_NEEDED_TO, 

		        iActiveEngine->ServiceName() );

	    TInt ret = IMCVUiAppNoteMapper::DisplayQueryDialogL( R_GENERIC_YES_NO_CONFIRMATION_QUERY,

	    												 *prompt );

	    CleanupStack::PopAndDestroy( prompt );

    	if( ( ret == EAknSoftkeyOk ) || ( ret == EAknSoftkeyYes ) )

	    	{

			// load the promp from lOC file + server name

			HBufC* prompt = StringLoader::LoadLC( R_SERVTAB_LOGIN_ONGOING, 

			        iActiveEngine->ServiceName() );

			CIMCVAppWaitNote* waitDialog = CIMCVAppWaitNote::ShowWaitNoteL( 

			        *prompt, 

			        ETrue );         

			CleanupStack::PushL(waitDialog);

			// start capturing the events

			iAppUi->CaptureEventsL();

			IM_CV_LOGS(TXT("CIMCVAppViewContainer::SendMessageL() BEFORE CALLING LOGIN") );

			TRAPD(error, iActiveEngine->LoginL());

			IM_CV_LOGS(TXT("CIMCVAppViewContainer::SendMessageL() AFTER CALLING LOGIN") );					

			// stop capturing the events

    		iAppUi->ReleaseCapturingL(); 

			IM_CV_LOGS(TXT("CIMCVAppViewContainer::SendMessageL() start") );

			loggedIn = IsLoggedIn();

			if (KErrNone != error)

				{

				IMCVUiAppNoteMapper::ShowNoteL( KImErrServiceGeneralError , KNullDesC );				

				}

			else

			    {

			    // subscribe for presence notification

			    iActiveEngine->MessageHandler().SubscribePresenceL( *iRecipientId );

			    }

			CleanupStack::PopAndDestroy(); //waitDialog

			CleanupStack::PopAndDestroy(); //prompt

	    	}		    	

		}

	if( loggedIn )

		{

		if(iEditorMessage)

			{

			delete iEditorMessage;

			iEditorMessage = NULL;	

			}

		iEditorMessage = iMessageExtensionsHandler.ProcessMessageLC( iMsgEditor->Editor(),

		        iActiveEngine->GetServiceId() );

	    TPtr msgPtr( iEditorMessage->Des() );

	    CleanupStack::Pop();//iEditorMessage   

		if( msgPtr.Length() == 0 )

			{

			return;	

			}

		TPtrC ownUserId = iActiveEngine->GetLoggedInUserId() ;

		MIMCVEngineMessageCreator::SMessageData data =

											{

											KMessageDataVersion,

											ownUserId,

											*iRecipientId, // Recipient

											msgPtr,

											MIMCVEngineMessage::EContentText,

											MIMCVEngineMessage::EMessageSent            

											};

	    MIMCVEngineMessage* message = iActiveEngine->MessageHandler().MessageCreator().CreateMessageL( data );

	    iWriteInterface->AppendL(message );

	    iActiveEngine->MessageHandler().SendMessageL( *message );

		ResetAfterSendL();

		StopScrollingL();

		}

	IM_CV_LOGS(TXT("CIMCVAppViewContainer::SendMessageL() end") );

	}

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

// CIMCVAppViewContainer::InsertStatusChangedMessageL()

// This method handles message sending to engine

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

//

void CIMCVAppViewContainer::InsertStatusChangedMessageL(CIMCVEngine& aEngine ,

                                                        TInt aServiceId, 

                                                        const TDesC& aBuddyId )

	{

	IM_CV_LOGS(TXT("CIMCVAppViewContainer::InsertStatusChangedMessageL() start") );

	TIMCVOnlineStatus status = 	aEngine.MessageHandler().GetPresenceStatus();

	TInt resourceId(0);

	switch( status ) 

		{

		case EOnline:

			{

			resourceId = R_SERVTAB_STATUS_CHANGE_ONLINE;

			break;	

			}

		case EInvisible:

			{

			resourceId = R_SERVTAB_STATUS_CHANGE_ONTHEPHONE;

			break;	

			}

		case EAway:

			{

			resourceId = R_SERVTAB_STATUS_CHANGE_AWAY;	

			break;	

			}

		case EBusy:

			{

			resourceId = R_SERVTAB_STATUS_CHANGE_DND;

			break;	

			}

		case EOnPhone:

			{

			resourceId = R_SERVTAB_STATUS_CHANGE_ONTHEPHONE;

			break;	

			}

		case EDoNotDisturb:

			{

			resourceId = R_SERVTAB_STATUS_CHANGE_DND;