/*

* 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    "cimcvapprichtextcontainer.h"

#include    "cimcvappmessagewrapper.h"

#include    "mimcvapptextview.h"

#include    "cimcvappui.h"

#include    "mimcvenginemessage.h"

#include    "cimcvappmessageextensionshandler.h"

#include    <AknIconUtils.h>

#include    <txtrich.h>     // CRichtText

#include    <AknSettingCache.h>

#include    <aknenv.h>

#include    <aknconsts.h>

#include    <finditemengine.h>

#include    <barsread.h> // resourcereader

#include    <StringLoader.h>

#include    <AknsDrawUtils.h>

#include    <AknsUtils.h>

#include    <AknUtils.h>

#include 	"imcvlogger.h"

#include	"cimcvapppicture.h"

#include 	<imcvuiapp.mbg>

#include	"cimcvappsmileiconutility.h"

#include    <imcvuiapp.rsg>

// CONSTANTS

const TInt KIMCVHighlightColor = 244;

const TInt KTimeStampMaxLength = 15;     // max length of timestamp text

const TInt KUnicodeRLM         = 0x200F; // Right-to-Left Mark

const TInt KUnicodeLRM         = 0x200E; // Left-to-Right Mark

//Received message maximum length is 400 character,

//this must always be in sync with imconnectionprovider KReceiveMsgMaxLength

const TInt KReceiveMsgMaxLength = 400; 

const TInt KMsgMaxLength = 450; //Received message maximum length is 400 character + truncation message 

_LIT( KSeparator, ": " );

_LIT(KSpace, " ");

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

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

// CIMCVAppRichTextContainer::CIMCVAppRichTextContainer

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CIMCVAppRichTextContainer::CIMCVAppRichTextContainer(MIMCVAppUi* aAppUi,

        MIMCVAppTextView* aTextView, 

        CIMCVAppMessageExtensionsHandler* aExtensionsHandler,

        CGulIcon* aFromMe,

        CGulIcon* aToMe,

        MGraphicsDeviceMap* aMap, 

        TInt aServiceId,

        TBool aScrollOver /*= ETrue*/):

    iAppUi(aAppUi),

    iTextView( aTextView ), 

    iItemHighlight( ETrue ), 

    iHighlightState( ENoHighlight ),

    iExtensionsHandler( aExtensionsHandler ),

    iScrollOver( aScrollOver ),

    iFromMe( aFromMe ), 

    iToMe( aToMe ),

    iMap(aMap),

    iServiceId( aServiceId )

	    {

	    }

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

// CIMCVAppRichTextContainer::Initialize

// Initializes iTextView

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

//

void CIMCVAppRichTextContainer::Initialize( MIMCVAppUi* aAppUi,

        MIMCVAppTextView* aTextView, 

        CIMCVAppMessageExtensionsHandler* aExtensionsHandler,

        CGulIcon* aFromMe,

        CGulIcon* aToMe,

        MGraphicsDeviceMap* aMap,                              

        TBool aScrollOver /*= ETrue*/ )

    {

    iAppUi = aAppUi;

    iTextView = aTextView;   

    iExtensionsHandler = aExtensionsHandler;

    iFromMe = aFromMe;

    iToMe = aToMe;

    iMap = aMap;

    iScrollOver = aScrollOver;

    }

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

// CIMCVAppRichTextContainer::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CIMCVAppRichTextContainer::ConstructL(const TDesC& aPrimaryKey)

    {

    iPrimaryKey = aPrimaryKey.AllocL();

    iAppUi->AddLayoutChangeObserver( this );

    iAppUi->AddResourceChangeObserver( this );

       // setup layout

    TAknLayoutId layoutId;

    CAknEnv::Static()->GetCurrentLayoutId( layoutId );

    iPrimaryFont = AknLayoutUtils::FontFromId( EAknLogicalFontPrimaryFont, 

    	NULL );

    iSecondaryFont = AknLayoutUtils::FontFromId( EAknLogicalFontPrimarySmallFont, 

    	NULL );

    CParaFormat paraFormat;

    TParaFormatMask paraFormatMask;

	paraFormat.iLanguage = CAknEnv::Static()->SettingCache().InputLanguage();

	paraFormatMask.SetAttrib( EAttParaLanguage );

    paraFormat.iFillColor = KRgbWhite;

    paraFormatMask.SetAttrib( EAttFillColor );

    paraFormat.iLeftMarginInTwips = 100;

    paraFormat.iIndentInTwips = -100;

    paraFormatMask.SetAttrib( EAttLeftMargin );    

    paraFormatMask.SetAttrib( EAttIndent );    

    TCharFormat charFormat;

    TCharFormatMask charFormatMask;

    charFormat.iFontSpec = iSecondaryFont->FontSpecInTwips();

    charFormatMask.SetAttrib( EAttFontTypeface );

    charFormatMask.SetAttrib( EAttFontHeight );

    // Text color

    TRgb defaultSkinTextColor( KRgbBlack );

    AknsUtils::GetCachedColor( AknsUtils::SkinInstance(), 

                               defaultSkinTextColor,

                               KAknsIIDQsnTextColors,

                               EAknsCIQsnTextColorsCG6 );

    charFormat.iFontPresentation.iTextColor = defaultSkinTextColor;

    charFormatMask.SetAttrib( EAttColor );

   	charFormat.iFontPresentation.iPictureAlignment = 

   	    TFontPresentation::EAlignTop;

   	charFormatMask.SetAttrib( EAttFontPictureAlignment );

    charFormat.iFontSpec.iFontStyle.SetStrokeWeight( EStrokeWeightNormal );

    charFormatMask.SetAttrib( EAttFontStrokeWeight );

    iParaFormatLayer = CParaFormatLayer::NewL( &paraFormat, paraFormatMask );

    iCharFormatLayer = CCharFormatLayer::NewL( charFormat, charFormatMask );

    iRichText = CRichText::NewL( iParaFormatLayer, iCharFormatLayer );    

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

    }

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

// CIMCVAppRichTextContainer::NewL

// Two-phased constructor.

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

//

CIMCVAppRichTextContainer* CIMCVAppRichTextContainer::NewL( MIMCVAppUi* aAppUi,

                              MIMCVAppTextView* aTextView, 

                              CIMCVAppMessageExtensionsHandler* aExtensionsHandler,

                              CGulIcon* aFromMe,

                              CGulIcon* aToMe,

							  MGraphicsDeviceMap* aMap,                              

                              const TDesC& aPrimaryKey,

                              TInt aServiceId,

                              TBool aScrollOver /*= ETrue*/)

    {    

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

    CIMCVAppRichTextContainer* self = new( ELeave ) CIMCVAppRichTextContainer(aAppUi,

                                        aTextView, 

									    aExtensionsHandler, aFromMe, aToMe, aMap,aServiceId,

									    aScrollOver );

    CleanupStack::PushL( self );

    self->ConstructL(aPrimaryKey);

    CleanupStack::Pop( self );

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

    return self;

    }

// Destructor

CIMCVAppRichTextContainer::~CIMCVAppRichTextContainer()

    {

    if(iPrimaryKey)

        {

        delete iPrimaryKey;

        iPrimaryKey = NULL;

        }

    delete iParaFormatLayer;

    delete iCharFormatLayer;

    delete iRichText;

    iMessages.ResetAndDestroy();

    if(iAppUi)

        {

        iAppUi->RemoveLayoutChangeObserver( this );  

        iAppUi->RemoveResourceChangeObserver( this );  

        }

    }

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

// CIMCVAppRichTextContainer::SelectedItem

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

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

//

HBufC* CIMCVAppRichTextContainer::SelectedItemL()

    {

    IM_CV_LOGS(TXT("CIMCVAppRichTextContainer::SelectedItemL()	start" ));

    if( iHighlightState == EItemSelected )

        {

        TCursorSelection curSel( iMessages[iSelected]->Selection() );

        // calculate item highlight position        

        TCursorSelection itemSel( 

        					iMessages[iSelected]->Highlights()[iSelectedItem] );

        TInt messageStart( curSel.LowerPos() );

        curSel.iAnchorPos = itemSel.iAnchorPos + messageStart;

        curSel.iCursorPos = itemSel.iCursorPos + messageStart;

        HBufC* text = HBufC::NewMaxL( curSel.Length() );

        TPtr ptr( text->Des() );

        iRichText->Extract(	ptr, curSel.LowerPos(), curSel.Length() );

	    IM_CV_LOGS(TXT("CIMCVAppRichTextContainer::SelectedItemL()	end" ));

        return text;

        }

    else

        {

	    IM_CV_LOGS(TXT("CIMCVAppRichTextContainer::SelectedItemL()	end" ));

        return KNullDesC().AllocL();

        }

    }

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

// CIMCVAppRichTextContainer::SelectedItemType

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

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

//

TInt CIMCVAppRichTextContainer::SelectedItemType()

    {

    IM_CV_LOGS(TXT("CIMCVAppRichTextContainer::SelectedItemType()	start" ));

    if( (iHighlightState == EItemSelected) && ( iMessages.Count() >0  )

    	&& (iSelected >= 0  ) )

        {

	    IM_CV_LOGS(TXT("CIMCVAppRichTextContainer::SelectedItemType()	end" ));

        return iMessages[iSelected]->HighlightTypes()[iSelectedItem];

        }

    else

        {

    	IM_CV_LOGS(TXT("CIMCVAppRichTextContainer::SelectedItemType()	end" ));

        return KErrNotFound;

        }

    }

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

// CIMCVAppRichTextContainer::RichText

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

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

//

MLayDoc* CIMCVAppRichTextContainer::TextLayout()

    {

    return iRichText;

    }

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

// CIMCVAppRichTextContainer::RichText

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

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

//

TInt CIMCVAppRichTextContainer::ServiceId() const

    {

    return iServiceId;

    }

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

// CIMCVAppRichTextContainer::SetItemHighlight

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

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

//

void CIMCVAppRichTextContainer::SetItemHighlight( TBool aItemHighlight )

    {

    iItemHighlight = aItemHighlight;

	TInt richTextDocumentLength = iRichText->DocumentLength();

	if (!richTextDocumentLength)

		return;

	if (aItemHighlight)

	{

		HBufC* text = HBufC::NewMaxLC( richTextDocumentLength );

		TPtr txt( text->Des() );

		iRichText->Extract( txt);

		CFindItemEngine* findItem = CFindItemEngine::NewL( txt, 

									CFindItemEngine::TFindItemSearchCase(

									CFindItemEngine::EFindItemSearchPhoneNumberBin |

									CFindItemEngine::EFindItemSearchMailAddressBin |

									CFindItemEngine::EFindItemSearchURLBin/* |

									CFindItemEngine::EFindItemSearchScheme*/ )

									);									   

		CleanupStack::PushL( findItem );

		const CArrayFixFlat<CFindItemEngine::SFoundItem>* items = findItem->ItemArray();

		TInt count( items->Count() );

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

			{

			const CFindItemEngine::SFoundItem item = items->At(i);

			// selection in rich text

			TCursorSelection realSel( item.iStartPos + item.iLength, item.iStartPos );

			HighLightItemL( realSel );

			}

		CleanupStack::PopAndDestroy( findItem );

		CleanupStack::PopAndDestroy( text);

	}

	else

    {

    	TCharFormat charFormat;

		TCharFormatMask charFormatMask;

		charFormatMask.SetAttrib( EAttFontUnderline );

		charFormat.iFontPresentation.iUnderline = EUnderlineOff;

		iRichText->ApplyCharFormatL ( charFormat, charFormatMask, 0, richTextDocumentLength);

	}

    }

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

// CIMCVAppRichTextContainer::MoveHighlightL

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

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

//

TInt CIMCVAppRichTextContainer::MoveHighlightL( THighlightMovement aDirection )

    {

    IM_CV_LOGS(TXT("CIMCVAppRichTextContainer::MoveHighlightL()	start" ));

    TBool up( aDirection == EPrevious );

    TInt messageCount( iMessages.Count() );    

    if( messageCount == 0 )

        {

        // no messages, nothing to highlight

        //but make highlight state as EMessageBottom 

        //so that tabs can be switched when there is no conversation in text container.

        if(iHighlightState == EMessageBottom)

            {

            iHighlightState = ENoHighlight;            

            }

        else

            {

            iHighlightState = EMessageBottom;   

            }

        return KErrNone;

        }

    TInt highlightCount( iMessages[iSelected]->Highlights().Count() );

    if( !iItemHighlight )

        {

        // if item highlighting is not on, clear the item count

        highlightCount = 0;

        }    

    // if message is highlighted, but it doesn't fit to screen

    // scroll it line by line

    if( iHighlightState == EMessageTop || iHighlightState == EMessageBottom )

        {

        TCursorSelection& sel = iMessages[iSelected]->Selection();

        if( up )

            {

            // up

            if( !iTextView->IsVisible( sel.LowerPos() ) )

                {

                // we're scrolling up and top line is not shown, 

                // so scroll messages down by one line

                iTextView->ScrollLinesL( 1 );

                return KErrNone;

                }

            }

        else if( !iTextView->IsVisible( sel.HigherPos() ) )

            {

            // we're scrolling down and bottom line is not shown,

            // so scroll messages up by one line

            iTextView->ScrollLinesL( -1 );

            return KErrNone;

            }        

        }

    // update highlight position    

    switch( iHighlightState )

        {

        case ENoHighlight:  // no highlight, select last  or first message

            {

            if( up )

                {

                iSelected = messageCount - 1;

                // Get highlight count of prev message

                // if item highlighting is on

                if ( iItemHighlight )                

                    {

                    highlightCount = iMessages[iSelected]->Highlights().Count();

                    }                

                if ( highlightCount > 0 )

                    {

                    // highlight items inside last message (if any)

                    iHighlightState = EItemSelected;

                    iSelectedItem = highlightCount - 1;

                    }

                else

                    {

                    // bottom of last message

                    iHighlightState = EMessageBottom;

                    }

                }

            else

                {

                // top of first message

                iHighlightState = EMessageTop;

                iSelected = 0;

                }            

            break;

            }

        case EItemSelected: // highlighting items            

            {

            if( up )

                {

                // up, previous item

                --iSelectedItem;

                if( iSelectedItem < 0 )

                    {

                    // end of highlights, focus message

                    iHighlightState = EMessageTop;

                    }

                }

            else

                {

                // down, next item

                ++iSelectedItem;

                if( iSelectedItem >= highlightCount )

                    {

                    // end of highlights

                    if ( iSelected < messageCount - 1 )

                        {

                        // focus next message

                        ++iSelected;

                        iHighlightState = EMessageTop;

                        }

                    else if ( iScrollOver )

                        {

                        // going down from last message,

                        // disable highlight so editor can take the focus

                        DisableHighlightL();

                        return KErrNone;

                        }

                    else

                        {

                        // Loop back to beginning

                        iSelected = 0;

                        iSelectedItem = 0;

                        iHighlightState = EMessageTop;

                        }

                    }

                }

            break;

            }

        case EMessageTop:   // highlighting message ("top" of it)

            {

            if( up )

                {

                // up, highlighting previous message

                if( iSelected > 0 )

                    {

                    // prev

                    --iSelected;

                    // get highlight count of prev message

                    // if item highlighting is on                

                    if ( iItemHighlight )                

                        {

                        highlightCount = iMessages[iSelected]->Highlights().Count();

                        }

                    if ( highlightCount > 0 )

                        {

                        // highlight items inside prev message (if any)

                        iHighlightState = EItemSelected;

                        iSelectedItem = highlightCount - 1;

                        }

                    else

                        {

                        // highlight whole prev message

                        iHighlightState = EMessageBottom;

                        }    

                    }

                else if ( iScrollOver )

                    {

                    // going up from first message,

                    // disable highlight, so editor can take the focus

                    DisableHighlightL();