/*******************************************************************************

 * Copyright (c) 2005, 2010 Nokia Corporation and/or its subsidiary(-ies).

 * All rights reserved. This program and the accompanying materials

 * are made available under the terms of the Eclipse Public License v1.0

 * which accompanies this distribution, and is available at

 * http://www.eclipse.org/legal/epl-v10.html

 *

 * Contributors:

 *     Nokia Corporation - S60 implementation

 *******************************************************************************/

#include <e32math.h>

#include <e32des16.h>

#include <frmtview.h>

#include <txtglobl.h>

#include <txtfmlyr.h>

#include <AknBidiTextUtils.h>

#include "swtgcbase.h"

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <graphics/openfontconstants.h>

#endif

#ifdef RD_JAVA_UI_ALFDRAWER_ENABLED

#include <alf/alfdrawer.h>

#endif // RD_JAVA_UI_ALFDRAWER_ENABLED

/*

 * This method is used only for M2G support purposes

 */

void CFbsBitmapESWT::SetHandles(TInt aHandle, TInt aServerHandle)

{

    iHandle = aHandle;

    iServerHandle = aServerHandle;

};

/*

 * Warning: unlike what happens on most platforms, SWT drawing primitives are

 *          inclusive of both their extremities. This means line primitives

 *          must draw the last pixel and fillable shapes must include their

 *          bottom and right edges.

 */

static const TInt KDefaultPenWidth = 1;

static const TInt KThinPenWidth    = 1;

static const TUint16 KCarriageReturn = 0x000d;

static const TUint16 KLineFeed = 0x000a;

static const TUint16 KTabulation = 0x0009;

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

/**

 * Constructor

 *

 * The GC passed in is set as follows:

 *  - The drawing mode is <code>TDrawMode::EDrawModePen</code>

 *  - There is no clipping rectangle

 *  - The pen settings are: solid, single pixel size

 *  - The brush style is null

 *  - No text font is selected

 *  - Pen & brush colours are set to the specified values

 *

 * @param aDrawable     The drawable that created <code>aGc</code>.

 * @param aGc           The native GC to use, ownership is tranferred.

 * @param aDestructor   The function that will take care of destroying <code>iGc</code>.

 * @param aPenCol       The pen's colour.

 * @param aBrushCol     The brush's colour.

 * @param aFont         The font to use

 * @param aBoundaryRect The rectangle drawing is restricted to, in GC coordinates.

 * @param aSize         The GC's size

 */

CSwtGcBase::CSwtGcBase(MSwtDrawable& aDrawable, CBitmapContext* aGc, TDestructor aDestructor,

                       const TRgb& aPenCol, const TRgb& aBrushCol, const MSwtFont& aFont,

                       const TRect& aBoundaryRect, const TSize& aSize)

        : iDrawable(aDrawable)

        , iGc(aGc)

        , iDestructor(aDestructor)

        , iCurrentPenStyle(CGraphicsContext::ESolidPen)

        , iUserPenStyle(CGraphicsContext::ESolidPen)

        , iLineStyle(ESwtLineSolid)

        , iCurrentPenWidth(KDefaultPenWidth)

        , iUserPenWidth(KDefaultPenWidth)

        , iPenColor(aPenCol)

        , iCurrentBrushStyle(CGraphicsContext::ENullBrush)

        , iUserBrushStyle(CGraphicsContext::ESolidBrush)

        , iBrushColor(aBrushCol)

        , iDrawMode(CGraphicsContext::EDrawModePEN)

        , iDefaultFont(aFont)

        , iFont(&aFont)

        , iBoundaryRect(aBoundaryRect)

        , iSize(aSize)

        , iClippingRect(aSize)

        , iAlpha(0xff)

{

    ASSERT(iGc!=NULL);

    iDefaultFont.AddRef();

    iFont->AddRef();

    iGc->SetPenColor(iPenColor);

    iGc->SetBrushColor(iBrushColor);

    iGc->SetClippingRect(iBoundaryRect);

    iGc->UseFont(&iFont->Font());

}

CSwtGcBase::~CSwtGcBase()

{

    iDestructor(iGc);

    iDefaultFont.RemoveRef();

    if (iFont)

    {

        iFont->RemoveRef();

    }

#ifdef _lint

    //lint -esym(1740, CSwtGcBase::iDestructor)

    iGc   = NULL;

    iFont = NULL;

#endif

}

/**

 * Sets the current pen style to null

 */

void CSwtGcBase::UseNullPen()

{

    if (iCurrentPenStyle != CGraphicsContext::ENullPen)

    {

        iCurrentPenStyle = CGraphicsContext::ENullPen;

        iGc->SetPenStyle(CGraphicsContext::ENullPen);

    }

}

/**

 * Sets the current pen style to null

 */

void CSwtGcBase::UseSolidPen()

{

    if (iCurrentPenStyle != CGraphicsContext::ESolidPen)

    {

        iCurrentPenStyle = CGraphicsContext::ESolidPen;

        iGc->SetPenStyle(CGraphicsContext::ESolidPen);

    }

}

/**

 * Restores the pen to its user-asked value

 */

void CSwtGcBase::RestorePen()

{

    if (iCurrentPenStyle != iUserPenStyle)

    {

        iCurrentPenStyle = iUserPenStyle;

        iGc->SetPenStyle(iUserPenStyle);

    }

}

/**

 * Sets the current pen width to 1

 */

void CSwtGcBase::UseThinPen()

{

    if (iCurrentPenWidth != KThinPenWidth)

    {

        iCurrentPenWidth = KThinPenWidth;

        iGc->SetPenSize(TSize(KThinPenWidth,KThinPenWidth));

    }

}

/**

 * Restores the pen width to its user-asked value

 */

void CSwtGcBase::RestorePenWidth()

{

    if (iCurrentPenWidth != iUserPenWidth)

    {

        iCurrentPenWidth = iUserPenWidth;

        TInt width = (iCurrentPenWidth==0) ? 1 : iCurrentPenWidth;

        iGc->SetPenSize(TSize(width,width));

    }

}

/**

 * Sets the current brush style to null

 */

void CSwtGcBase::UseNullBrush()

{

    if (iCurrentBrushStyle != CGraphicsContext::ENullBrush)

    {

        iCurrentBrushStyle = CGraphicsContext::ENullBrush;

        iGc->SetBrushStyle(CGraphicsContext::ENullBrush);

    }

}

/**

 * Restores the brush to its user-asked value

 */

void CSwtGcBase::RestoreBrush()

{

    if (iCurrentBrushStyle != iUserBrushStyle)

    {

        iCurrentBrushStyle = iUserBrushStyle;

        iGc->SetBrushStyle(iUserBrushStyle);

    }

}

/**

 * Restores the clipping

 */

void CSwtGcBase::RestoreClipping()

{

    TRect clipRect(iClippingRect);

    clipRect.Intersection(iBoundaryRect); // We can never go outside the boundary rect

    iGc->SetClippingRect(clipRect);

}

/**

 * Converts a degree angle to a (x,y) position.

 */

TPoint CSwtGcBase::AngleToPosition(TInt aAngle, const TSize& aSize)

{

    ASSERT(aSize.iWidth>0 && aSize.iHeight>0);

    TReal radAngle = aAngle * KDegToRad;

    TReal cos;

    TReal sin;

    Math::Cos(cos, radAngle);

    Math::Sin(sin, radAngle);

    return TPoint(static_cast<TInt>(cos*aSize.iWidth),

                  -static_cast<TInt>(sin*aSize.iHeight));

}

/**

 * Computes the parameters of an elliptical arc.

 */

void CSwtGcBase::ComputeArc(const TRect& aRect,

                            TInt aStartAngle, TInt aArcAngle, TPoint& aStart, TPoint& aEnd)

{

    const TPoint center(aRect.Center());

    if (aRect.IsEmpty())

    {

        aStart = aEnd = center;

        return;

    }

    TRect rect(aRect);

    rect.Normalize();

    if (aArcAngle>=360 || aArcAngle<=-360) // Full ellipse

    {

        aStart.iX = aEnd.iX = rect.iBr.iX;

        aStart.iY = aEnd.iY = center.iY;

    }

    else                                   // Arc

    {

        TInt angle1 = aStartAngle;

        TInt angle2 = aStartAngle + aArcAngle;

        if (aArcAngle < 0)

        {

            TInt tmp = angle1;

            angle1 = angle2;

            angle2 = tmp;

        }

        const TSize size(rect.Size());

        aStart  = center;

        aStart += AngleToPosition(angle1, size);

        aEnd    = center;

        aEnd   += AngleToPosition(angle2, size);

    }

}

/**

 * Workaround for issue in the rectangle drawing code.

 * When the line style is other than solid and the pen is wider than 1 pixel,

 * the outline is drawn as solid.

 */

void CSwtGcBase::DrawRectangleWorkaround(const TRect& aRect)

{

    if (iUserPenWidth==1 || iUserPenStyle==CGraphicsContext::ESolidPen)

        iGc->DrawRect(InclusiveRect(aRect));

    else

    {

        TPoint points[4];

        points[0] = aRect.iTl;

        points[1] = TPoint(aRect.iBr.iX, aRect.iTl.iY);

        points[2] = aRect.iBr;

        points[3] = TPoint(aRect.iTl.iX, aRect.iBr.iY);

        iGc->DrawPolygon(points, 4);

    }

}

/**

 * Extracts a portion of a bitmap and scales it to a given size

 * The returned bitmap is a newly created one, it is left on the cleanup stack.

 */

CFbsBitmap* CSwtGcBase::ScaleBitmapPortionLC(

    const CFbsBitmap& aBitmap, const TRect& aRect, const TSize& aNewSize)

{

    // Create the bitmap

    CFbsBitmap* resizedBitmap = new(ELeave) CFbsBitmap;

    CleanupStack::PushL(resizedBitmap);

    User::LeaveIfError(resizedBitmap->Create(aNewSize, aBitmap.DisplayMode()));

    // Create the device

    CFbsBitmapDevice* bitmapDevice = CFbsBitmapDevice::NewL(resizedBitmap);

    CleanupStack::PushL(bitmapDevice);

    // Create the context

    CBitmapContext* bitmapContext;

    User::LeaveIfError(bitmapDevice->CreateBitmapContext(bitmapContext));

    // Scaled copy

    bitmapContext->DrawBitmap(TRect(aNewSize), &aBitmap, aRect);

    delete bitmapContext;

    CleanupStack::PopAndDestroy(bitmapDevice);

    return resizedBitmap;

}

/**

 * Scales a size by multiplying and dividing it.

 */

TSize CSwtGcBase::ScaleSize(const TSize& aSize,

                            const TSize& aMultiplier, const TSize& aDivider)

{

    ASSERT(aDivider.iWidth!=0 && aDivider.iHeight!=0);

    TInt scaledWidth  = (aSize.iWidth *aMultiplier.iWidth) / aDivider.iWidth;

    TInt scaledHeight = (aSize.iHeight*aMultiplier.iHeight) / aDivider.iHeight;

    return TSize(scaledWidth, scaledHeight);

}

/**

 * Draws a resized image with an alpha mask

 */

void CSwtGcBase::DrawResizedAlphaImageL(const CFbsBitmap& aBitmap,

                                        const CFbsBitmap& aMask, const TRect& aSrceRect, const TRect& aDestRect)

{

    const TSize bmpSize(aBitmap.SizeInPixels());

    const TSize mskSize(aMask.SizeInPixels());

    const TSize srceSize(aSrceRect.Size());

    const TSize destSize(aDestRect.Size());

    CFbsBitmap* resizedBitmap;

    CFbsBitmap* resizedMask;

    TPoint      scaledSrceOrig(TPoint::EUninitialized);

    // The mask is large enough for the bitmap --> resize only portions

    if (mskSize.iWidth>=bmpSize.iWidth && mskSize.iHeight>=bmpSize.iHeight)

    {

        scaledSrceOrig = TPoint(0,0);

        resizedBitmap  = ScaleBitmapPortionLC(aBitmap, aSrceRect, destSize);

        resizedMask    = ScaleBitmapPortionLC(aMask,   aSrceRect, destSize);

    }

    // The mask is too small for the bitmap, it will be tiled --> resize the whole bitmaps

    else

    {

        TSize newBmpSize(ScaleSize(bmpSize, destSize, srceSize));

        TSize newMskSize(ScaleSize(mskSize, destSize, srceSize));

        scaledSrceOrig = ScaleSize(aSrceRect.iTl.AsSize(), destSize, srceSize).AsPoint();

        resizedBitmap  = ScaleBitmapPortionLC(aBitmap, TRect(bmpSize), newBmpSize);

        resizedMask    = ScaleBitmapPortionLC(aMask,   TRect(mskSize), newMskSize);

    }

    iGc->BitBltMasked(aDestRect.iTl, resizedBitmap,

                      TRect(scaledSrceOrig,destSize), resizedMask, EFalse);

    CleanupStack::PopAndDestroy(resizedMask);

    CleanupStack::PopAndDestroy(resizedBitmap);

}

/**

 * Creates a <code>CTextLayout</code> object from a descriptor and its

 *        drawing flags, for display or text extent computaion. The new

 *        <code>CTextLayout</code> object will be pushed on the cleanup stack.

 *

 * The descriptor will be modified to respect the values of the flags.

 * The global text set in parameters will then contain a copy of the updated

 * descriptor, and will be used by the new text layout.

 *

 * @param aText            The descriptor.

 * @param aFlags           Drawing flags of the descriptor.

 * @param aBaseLineSpace   Baseline space.

 *                         new text layout. This global text will contain the

 *                         descriptor with delimiters and tab

 * @param aMinimumViewSize In return, width and height of the bounding box of

 *                          the text.

 *

 * @return Pointer to the bdiitext. Should be released when no more needed.

 */

TBidiText* CSwtGcBase::CreateTextLayoutLC(TDes& aText, TInt aFlags,

        TInt& aSpaceBetweenBaseLines, TSize& aMinimumViewSize) const

{

    ASSERT(iFont!=NULL);

    TBool drawDelimiter(aFlags & KSwtDrawDelimiter);

    TBool drawTab(aFlags & KSwtDrawTab);

    // Delimiters management

    TUint16 delimiter = static_cast<TUint16>(drawDelimiter ?

                        CEditableText::ELineBreak : KReplacementCharacter);

    TUint16 tabchar = static_cast<TUint16>(KSwtDrawTab ?

                                           CEditableText::ETabCharacter : KReplacementCharacter);

    // Scan all text in order to get

    // 1. the number of lines

    // 2. the text length

    // 3. replace delimiter if draw delimiter flag is not set

    TInt descLength(aText.Length());

    TInt numberOfLines(0);

    TInt numberOfTabs(0);

    TInt ind(0);

    for (ind = 0; ind < descLength; ind++)

    {

        switch (aText[ind])

        {

        case KCarriageReturn:

        case KLineFeed:

            aText[ind] = delimiter;

            if (drawDelimiter)

            {

                numberOfLines++;

            }

            break;

        case KTabulation:

            aText[ind] = tabchar;

            if (drawTab)

            {

                numberOfTabs++;

            }

            break;

        default:

            break;

        }

    }

    numberOfLines++;

    // Create text buffer and copy the text to the text buffer

    const TInt KTabLength(4);

    _LIT(KExtraTabSpaces, "   ");   // 3 spaces

    HBufC* textBuffer = HBufC::NewLC(descLength

                                     + numberOfLines * KAknBidiExtraSpacePerLine  + numberOfTabs * (KTabLength -1));

    TPtr ptr = textBuffer->Des();

    ptr = aText.Mid(0);

    // Replace tabchar with two space

    TInt tabPos(KErrNotFound);

    ptr = textBuffer->Des();

    while ((tabPos = ptr.Locate(CEditableText::ETabCharacter)) != KErrNotFound)

    {

        // tab is replaced by 4 spaces

        ptr[ tabPos ] = ' ';

        ptr.Insert(tabPos + 1, KExtraTabSpaces);

    }

    AknBidiTextUtils::PrepareRunInfoArray(textBuffer->Des());

    // Get width of text

    ptr = textBuffer->Des();

    descLength = textBuffer->Length();

    TInt lineWidth(0);

    TInt maxLineWidth(0);

    TInt lineStartPos(0);

    const CFont& font = iFont->Font();

    for (ind = 0; ind < descLength; ind++)

    {

        if (ptr[ ind ] == CEditableText::ELineBreak)

        {

            lineWidth =

                iFont->TextWidthInPixels(ptr.MidTPtr(lineStartPos, ind  - lineStartPos  + 1));

            if (lineWidth > maxLineWidth)

            {

                maxLineWidth = lineWidth;

            }

            lineStartPos = ind + 1;

        }

    }

    lineWidth = font.TextWidthInPixels(ptr.MidTPtr(lineStartPos, descLength - lineStartPos));

    if (lineWidth > maxLineWidth)

    {

        maxLineWidth = lineWidth;

    }

    // Create ad prepare biditext

    TBidiText* bidiText = TBidiText::NewL(textBuffer->Des(), numberOfLines);

    CleanupStack::PushL(bidiText);

    bidiText->WrapText(maxLineWidth, font);

    // Get the minimum size and the baseline spacing

    // WARNING! This must be kept similar to the way Label sets the gap!

    // See CSwtLabel::DoSetFontL

    TInt padding = Max(font.FontLineGap() - font.FontMaxHeight(), KSwtMinLinePadding);

    aMinimumViewSize = bidiText->MinimumSize(maxLineWidth, font, padding, numberOfLines);

    aSpaceBetweenBaseLines = (aMinimumViewSize.iHeight + padding) / numberOfLines;

    if (numberOfLines <= 1)

    {

        aSpaceBetweenBaseLines = 0;

    }

    CleanupStack::Pop(bidiText);

    CleanupStack::PopAndDestroy(textBuffer);

    CleanupStack::PushL(bidiText);

    return bidiText;

}

/**

 * This method removes the '&' characters from a string as mnemonics are not supported in Symbian.

 * @param aText The text from which the mnemonics are to be removed.

 */

void CSwtGcBase::RemoveMnemonics(TDes& aText)

{

    TInt pos = aText.LocateReverse('&');

    while (pos != KErrNotFound)