/*

* Copyright (c) 2006 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:   Text visual

*

*/

#include <s32mem.h>

#include "alf/alftextvisual.h"

#include "alf/alfcontrol.h"

#include "alf/alfenv.h"

#include "alfclient.h"

#include "alf/alfconstants.h"

#include "alf/alfgencomponent.h"

#include "alflogger.h"

#include "alf/alflayoutmetrics.h"

#include "alf/alftextstyle.h"

#include "alf/alfdropshadow.h"

#include <uiacceltk/HuiFont.h>

#include <AknsConstants.h>

#include <AknBidiTextUtils.h>

#include <utf.h>

#include <aknnotewrappers.h>

#ifdef ALF_RASTER_TEXT

/** Granularity of line wrapping array. */

const TInt KLineArrayGranularity = 4;

NONSHARABLE_CLASS(CAlfRasterizedTextMesh): public CBase

    {

    struct SRasterizedLine

        {

        SRasterizedLine()

            {

            iTexture = NULL;

            iGap = 0;

            }

        /** Texture that holds the rasterized version of a text line. The

            size of the texture determines the extents of the line. */

        CAlfTexture* iTexture;

        /** Extra gap to the next line in pixels. Not applied to the last

            line. */

        TInt iGap;

        };

    public:

    static CAlfRasterizedTextMesh* NewL(CAlfTextVisual* aVisual)

        {

        CAlfRasterizedTextMesh* self = new (ELeave) CAlfRasterizedTextMesh(aVisual);

        return self;

        }

    CAlfRasterizedTextMesh(CAlfTextVisual* aVisual)

        :iVisual(aVisual){}

    ~CAlfRasterizedTextMesh()

        {

        ResetLines(ETrue);

        iLines.Close();

        ReleaseTextures(ETrue);

        iObsoleteTextures.Close();

        delete iBuf;

        }

    void PrepareForRasterize()

        {

        // resolve max width 

        iMaxWidth = KMaxTInt;

        if(iVisual->Wrapping() != CAlfTextVisual::ELineWrapManual)

            {

            TAlfRealRect content = iVisual->DisplayRectTarget();

            content.Shrink(iVisual->PaddingInPixels());

            iMaxWidth = TInt(content.Width()+0.5f);

            }        

        }

    TInt Lines()

        {

        return iLines.Count();

        }

    void ResetLines(TBool aDeleteTexture = EFalse)

        {

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

            {

            if ( aDeleteTexture )

                {

                delete iLines[i].iTexture;

                }

            else 

                {

                MarkTextureForRemovalL(iLines[i].iTexture);

                }

            iLines[i].iTexture = NULL;

            }

        iLines.Reset();

        }

    void RasterizeLineL(const TDesC& aTextLine, SRasterizedLine & aLineOut, CAlfTextStyle* aTextStyle)

        {

        // Calculate line extents and assign it to texture size.

        TSize textureSize = aTextStyle->LineExtentsL(aTextLine);

        if(textureSize.iWidth == 0)

            {

            // This is an empty string. We will not rasterize it.

            // Just add a gap to rows.

            aLineOut.iTexture = NULL;

            aLineOut.iGap = textureSize.iHeight; // @todo: refacture/rename iGap? iGap is used as a size of an empty line?

            return;

            }

        // Rasterize string using the defined text style.

        aTextStyle->RasterizeLineL(aTextLine, &aLineOut.iTexture);

        }

    void DoBuildL(CAlfTextStyle* aTextStyle)

        {

        ResetLines();

        TSize extents(0, 0);

        const TDesC& text = iVisual->Text();

        // Retrieve the CFont object used when rasterizing this text mesh.

        CFont* font = aTextStyle->Font()->NearestFontL(1.0);

        // In wrapping mode, let the mesh know how much space there is

        // for drawing into.

        TInt maxWidth = iMaxWidth; //KMaxTInt;

        TInt lineCount = 0;

        // awkward, just to avoid warning

        CArrayFixFlat<TPtrC>* linePtrs = 0;

        HBufC* buf = 0;

        switch(iVisual->Wrapping())

            {

            case CAlfTextVisual::ELineWrapManual:

                {

                lineCount = 1;

                for (TInt i = text.Length()-2;i>=0;i--) // linebreak as last character is ignored

                    {

                    if (text[i]=='\n') // not elegant but keeps the compatibility

                        lineCount++;

                    }

                if (lineCount > 1)

                    {

                    TInt lineStart = 0;

                    TInt breakpos = 0;

                    TInt remaining = text.Length();                    

                    while(lineCount)

                        {

                        for (TInt i = lineStart; i<remaining ;i++)

                            {

                            if (text[i]=='\n') // not elegant but keeps the compatibility

                                {

                                breakpos = i;

                                break;

                                }

                            }

                            if (breakpos < lineStart) // not found

                                {

                                breakpos = remaining-1;

                                }

                            HBufC* buf = text.Mid(lineStart,breakpos-lineStart).AllocLC(); // todo.. is extra space required for bidi

                            lineStart = breakpos+1;

                            TPtr ptr = buf->Des();

                            // truncate line

                            AknBidiTextUtils::ConvertToVisualAndClipL(ptr, *font, maxWidth, maxWidth);

                            // create the line entry if not already existing

                            SRasterizedLine line;

                            line.iTexture = NULL;

                            line.iGap = 0;

                            iLines.AppendL(line);

                            TInt index = iLines.Count()-1;

                            // rasterize a single line (updates texture in iLines[0].iTexture)

                            RasterizeLineL(ptr, iLines[index], aTextStyle);                     

                            // Get extents from the texture we just created

                            CAlfTexture* tex = iLines[index].iTexture;

                            extents.iHeight += iLines[index].iGap;

                            if(tex)

                                {

                                extents.iWidth = Max(extents.iWidth, tex->Size().iWidth);

                                extents.iHeight += tex->Size().iHeight;

                                }                   

                            CleanupStack::PopAndDestroy(buf);

                            lineCount--;

                            }

                        break;

                        }

                    } // fall through with single line

            case CAlfTextVisual::ELineWrapTruncate:

                {

                lineCount = 1; // there's always one line created per logical line

                HBufC* buf = text.AllocLC(); // todo.. is extra space required for bidi

                TPtr ptr = buf->Des();

                // truncate line

                AknBidiTextUtils::ConvertToVisualAndClipL(ptr, *font, maxWidth, maxWidth);

                // create the line entry if not already existing

                SRasterizedLine line;

                line.iTexture = NULL;

                line.iGap = 0;

                iLines.AppendL(line);

 	            // rasterize a single line (updates texture in iLines[0].iTexture)

        	    RasterizeLineL(ptr, iLines[0], aTextStyle);	                    

   	            // Get extents from the texture we just created

                CAlfTexture* tex = iLines[0].iTexture;

                extents.iHeight += iLines[0].iGap;

                if(tex)

                    {

                    extents.iWidth = Max(extents.iWidth, tex->Size().iWidth);

                    extents.iHeight += tex->Size().iHeight;

                    }	                

        	    CleanupStack::PopAndDestroy(buf);

                break;

                }

            case CAlfTextVisual::ELineWrapBreak:

                {

                // wrap lines to array

                linePtrs = new (ELeave) CArrayFixFlat<TPtrC>(KLineArrayGranularity);

                CleanupStack::PushL(linePtrs);

                buf = AknBidiTextUtils::ConvertToVisualAndWrapToArrayL(

                    text, maxWidth, *font, *linePtrs);

                CleanupStack::PushL(buf);

              	// Do rasterisation

                for(TInt i = 0; i < linePtrs->Count();i++)

                    {

                    SRasterizedLine line;

                    line.iTexture = NULL;

                    line.iGap = 0;

                    iLines.AppendL(line);

                    // rasterize a single line (updates texture in iLines[i].iTexture)

                    RasterizeLineL(linePtrs->At(i), iLines[i], aTextStyle);

                    CAlfTexture* tex = iLines[i].iTexture;

                    extents.iHeight += iLines[i].iGap;

                    if(tex)

                        {

                        extents.iWidth = Max(extents.iWidth, tex->Size().iWidth);

                        extents.iHeight += tex->Size().iHeight;

                        }    

                    if (i == iVisual->MaxLineCount()-1)

          	            {

       	                // Maximum number of lines reached.

       	                break;

       	                }

                    }

                CleanupStack::PopAndDestroy(buf);

                CleanupStack::PopAndDestroy(linePtrs);

                break;

                }

            default:

                break;

            }

        // Extents needs to be updated in order to make alignment 

        // work properly.

        iExtents = extents;

        UpdateDescriptorL();

        }

    void UpdateDescriptorL()

        {

        delete iBuf;

        iBuf = 0;

        iBuf = HBufC8::NewL((iLines.Count()+1)*8 + 2*4);

        RDesWriteStream stream;

        TPtr8 ptr = iBuf->Des();

        stream.Open(ptr);

        CleanupClosePushL(stream);

        stream.WriteInt32L(iLines.Count());

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

            {

            if (iLines[i].iTexture)

                stream.WriteInt32L(iLines[i].iTexture->ServerHandle());

            else

                stream.WriteInt32L(0);                

            stream.WriteInt32L(iLines[i].iGap);

            }

        stream.WriteInt32L(iExtents.iWidth);

        stream.WriteInt32L(iExtents.iHeight);

        stream.CommitL();

        CleanupStack::PopAndDestroy(); // close stream

        }

    HBufC8* Buffer()

        {

        return iBuf;    

        }

    void MarkTextureForRemovalL(CAlfTexture* aTexture)

        {    

        if (iObsoleteTextures.Find(aTexture)==KErrNotFound)

            {

            iObsoleteTextures.AppendL(aTexture);

            }

        }

    void ReleaseTextures(TBool aObsoleteOnly)

        {

        if (!aObsoleteOnly)

            {        

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

                {

                delete iLines[i].iTexture;

                iLines.Remove(0);

                }

            }        

        iObsoleteTextures.ResetAndDestroy();

        }

    CAlfTextVisual* iVisual;

    RArray<SRasterizedLine> iLines;

    RPointerArray<CAlfTexture> iObsoleteTextures;

    HBufC8* iBuf;

    TSize iExtents;

    TInt iMaxWidth;

    };

#endif // #ifdef ALF_RASTER_TEXT

struct CAlfTextVisual::TTextVisualPrivateData

    {

    HBufC* iText; // own

    TInt iTextStyleId;

    CAlfTextStyle* iTextStyle;

#ifdef ALF_RASTER_TEXT

    CAlfRasterizedTextMesh* iMesh;

    TInt iWrappingMode;

    TInt iMaxLineCount;

    TInt iLineSpacingUnit;

    TInt iLineSpacing;

    TBool iMeshUptoDate;   

#endif // #ifdef ALF_RASTER_TEXT

    };

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

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

// Constructor

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

//

EXPORT_C CAlfTextVisual::CAlfTextVisual()

    {

    }

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

// ConstructL

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

//

EXPORT_C void CAlfTextVisual::ConstructL(CAlfControl& aOwner)

    {

    CAlfVisual::ConstructL(aOwner);

    iTextVisualData = new (ELeave) TTextVisualPrivateData;

    iTextVisualData->iText = NULL;

    iTextVisualData->iTextStyleId = 0;

#ifdef ALF_RASTER_TEXT

    iTextVisualData->iTextStyle = 0;

    iTextVisualData->iMesh = 0;

    iTextVisualData->iWrappingMode=0;

    iTextVisualData->iMaxLineCount=256;

    iTextVisualData->iLineSpacing=0;

    iTextVisualData->iLineSpacingUnit=0;

    iTextVisualData->iMesh = CAlfRasterizedTextMesh::NewL(this);

    iTextVisualData->iMeshUptoDate = EFalse;

#endif //#ifdef ALF_RASTER_TEXT

    // If alflayoutmetrcis is in automatic mode, mark this visual.

    if (aOwner.Env().LayoutMetricsUtility()->AutoMarking() )

        {

        aOwner.Env().LayoutMetricsUtility()->MarkVisual(NULL, this);    

        }

    }

void CAlfTextVisual::PrepareForUpdateMesh()

    {

#ifdef ALF_RASTER_TEXT

    if(!iTextVisualData->iMeshUptoDate)

        {

        iTextVisualData->iMesh->PrepareForRasterize();

        }

#endif // ALF_RASTER_TEXT    

    }

void CAlfTextVisual::UpdateMesh(TBool aSynch)

    {

 #ifdef ALF_RASTER_TEXT

    // update textures

    CAlfTextStyle* style = iTextVisualData->iTextStyle;

    if (!style)

        { // default

        iTextVisualData->iTextStyle = Env().TextStyleManager().SwitchTextStyle(0,this);//register for updates 

        style = Env().TextStyleManager().TextStyle(0);

        }

    if (aSynch)

        {

        if(!iTextVisualData->iMeshUptoDate)

            {

            TRAPD(err, iTextVisualData->iMesh->DoBuildL(style))

            // Inform server

            if (!err)

                {

                TPtr8 ptr = iTextVisualData->iMesh->Buffer()->Des();

                Comms()->DoCmdNoReply(EAlfTextVisualSetRasterizedMesh, ptr);    

                }    

            iTextVisualData->iMesh->ReleaseTextures(ETrue);

            iTextVisualData->iMeshUptoDate = ETrue;

            }

        }

     else

        {

        iTextVisualData->iMeshUptoDate = EFalse;

        style->ReportChanged();

        }

 #endif

    }

void CAlfTextVisual::ReleaseMesh()

    {

#ifdef ALF_RASTER_TEXT

    iTextVisualData->iMesh->ResetLines(ETrue);

    iTextVisualData->iMeshUptoDate = EFalse;

#endif

    }

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

// Destructor

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

//

EXPORT_C CAlfTextVisual::~CAlfTextVisual()

    {

    if ( iTextVisualData )

        {

        delete iTextVisualData->iText;

#ifdef ALF_RASTER_TEXT

        Env().TextStyleManager().Unregister(this);

        delete iTextVisualData->iMesh;

#endif

        }

    delete iTextVisualData;

    Env().LayoutMetricsUtility()->UnmarkVisual(this);

    }

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

// Creates new CAlfTextVisual

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

//

EXPORT_C CAlfTextVisual* CAlfTextVisual::AddNewL(

    CAlfControl& aOwnerControl,

    CAlfLayout* aParentLayout)

    {

    CAlfTextVisual* text = STATIC_CAST(CAlfTextVisual*,

        aOwnerControl.AppendVisualL(EAlfVisualTypeText, aParentLayout));

    return text;

    }

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

// Sets text.

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

//

EXPORT_C void CAlfTextVisual::SetTextL(const TDesC& aText)

    {

#ifdef ALF_RASTER_TEXT

    if (!iTextVisualData->iText || aText.Compare(*iTextVisualData->iText))

        {

		// Store the text into a temp buffer.

        HBufC* newBuffer = aText.AllocL();

        delete iTextVisualData->iText;

        iTextVisualData->iText = newBuffer;

        UpdateMesh();

        }

#else

    // Store the text into a temp buffer.

    HBufC* newBuffer = aText.AllocLC();

    TPtrC8 ptr(reinterpret_cast<const TUint8 *>(aText.Ptr()), aText.Length()*2);

    TBuf8<1> dum;

    TInt err = Comms()->DoSynchronousCmd(EAlfTextVisualSetText, ptr, dum);

    if ( err )

        {

        __ALFLOGSTRING1( "CAlfTextVisual::SetTextL leave error %d", err )

        User::Leave( err );