/*

* Copyright (c) 2005-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:

*

*/

#include <fbs.h>

#include <biditext.h>

#include <bitdev.h>

#include <gdi.h>

#include <e32math.h>

#include "LcdGraphics.h"

#include "LcdImage.h"

#include <lcdgdrv.h>

#include "LcdBitmapSurface.h"

#include "DebugArg.h"

#include "LcdWindowSurface.h"

TPoint AnchorPoint(const TPoint& aPoint, TInt aAnchor, const TSize& aSize);

void   ArcVectors(TPoint& aStart, TPoint& aEnd, const TRect& aRect, TInt aStartAngle, TInt aArcAngle);

TPoint Vector(const TReal& aAngle, const TSize& aSize);

#ifdef _DEBUG

class MyBitmapLockCountHack

{

public:

    TInt iCount;

};

#define CHECK_BITMAP_LOCK() ASSERT( ((MyBitmapLockCountHack*)(&iCount))->iCount == 0 )

#else

#define CHECK_BITMAP_LOCK()

#endif

const TUint32 KARGBBlack = 0xff000000;

/**

 * Map lcdui stroke style to GDI pen style.

 */

inline CGraphicsContext::TPenStyle PenStyle(TStrokeStyle aStrokeStyle)

{

    return (aStrokeStyle == EStrokeDotted ? CGraphicsContext::EDottedPen : CGraphicsContext::ESolidPen);

}

//

// CLcdGraphics inline methods

//

inline void CLcdGraphics::SetPenOn()

{

    if (0 == (iState & EPenOn))

    {

        iContext->SetPenStyle(PenStyle(iStrokeStyle));

        iState |= EPenOn;

    }

    if (0 == (iState & EPenColor))

    {

        iContext->SetPenColor(TRgb::Color16MA(iColor));

        iState |= EPenColor;

    }

}

inline void CLcdGraphics::SetPenOff()

{

    if (iState & EPenOn)

    {

        iContext->SetPenStyle(CGraphicsContext::ENullPen);

        iState ^= EPenOn;

    }

}

inline void CLcdGraphics::SetBrushOn()

{

    if (0 == (iState & EBrushOn))

    {

        iContext->SetBrushStyle(CGraphicsContext::ESolidBrush);

        iState |= EBrushOn;

    }

    if (0 == (iState & EBrushColor))

    {

        iContext->SetBrushColor(TRgb::Color16MA(iColor));

        iState |= EBrushColor;

    }

}

inline void CLcdGraphics::SetBrushOff()

{

    if (iState & EBrushOn)

    {

        iContext->SetBrushStyle(CGraphicsContext::ENullBrush);

        iState ^= EBrushOn;

    }

}

inline void CLcdGraphics::LineMode()

{

    SetPenOn();

}

inline void CLcdGraphics::FillMode()

{

    SetPenOff();

    SetBrushOn();

}

inline void CLcdGraphics::OutlineMode()

{

    SetPenOn();

    SetBrushOff();

}

CLcdGraphics* CLcdGraphics::NewL(CLcdGraphicsDriver& aDriver, CCoeControl& aWindow, MDirectContainer& aContainer, TBool aUpdate)

{

    return CLcdGraphics::NewL(aDriver, CLcdWindowSurface::NewL(aWindow, aContainer, aUpdate));

}

CLcdGraphics* CLcdGraphics::NewL(CLcdGraphicsDriver& aDriver, const CFbsBitmap* aBitmap)

{

    return CLcdGraphics::NewL(aDriver, CLcdBitmapSurface::NewL(aBitmap));

}

//

// aSurface is NOT on cleanup stack.

//

CLcdGraphics* CLcdGraphics::NewL(CLcdGraphicsDriver& aDriver, CLcdSurface* aSurface)

{

    CleanupStack::PushL(aSurface);

    CLcdGraphics* graphics = new(ELeave) CLcdGraphics(aDriver, aSurface);

    CleanupStack::Pop(aSurface);

    CleanupStack::PushL(graphics);

    graphics->ConstructL();

    CleanupStack::Pop(graphics);

    return graphics;

}

//

//

//

CLcdGraphics::CLcdGraphics(CLcdGraphicsDriver& aDriver, CLcdSurface* aSurface)

        : iLcdDriver(aDriver)

        , iSurface(aSurface)

        , iIsCanvasGraphicsItemTarget(EFalse)

{

    iStrokeStyle = EStrokeSolid;

    iColor    = KARGBBlack;

    iFont     = NULL;

    iState    = EPenOn|EPenColor;   // Initial state of context

}

void CLcdGraphics::ConstructL()

{

    //

    // We require a CLcdGraphicsDevice for transforming bitblts which are

    // not supported by BITGDI. If the driver cannot create a device for

    // this surface type we will fail here. A line buffer could be used to

    // implement a slow version of the transforming blitters to avoid this

    // failure mode.

    //

    iLcdDevice = iLcdDriver.CreateDeviceL(iSurface->ImageType());

    iLcdDrawCaps = iLcdDevice->DrawingCaps();

    iDeviceBounds = iSurface->Bounds();

    iDeviceOrigin = iDeviceBounds.iTl;

    iDeviceClipRect = iDeviceBounds;

    iOrigin   = TPoint();

    iClipRect = TRect(iDeviceBounds.Size());

#ifdef __SERIES60_

    iMIDPictograph  = CMIDPictograph::NewL();

#endif

}

CLcdGraphics::~CLcdGraphics()

{

    delete iLcdDevice;

    delete iSurface;

#ifdef __SERIES60_

    delete iMIDPictograph;

#endif

}

void CLcdGraphics::Begin()

{

    CHECK_BITMAP_LOCK();

    TRect bounds = iSurface->Bounds();

    if (bounds != iDeviceBounds)

    {

        iDeviceBounds = bounds;

        iDeviceOrigin = iDeviceBounds.iTl + iOrigin;

        iDeviceClipRect = iClipRect;

        iDeviceClipRect.Move(iDeviceOrigin);

        iDeviceClipRect.Intersection(bounds);

    }

    CBitmapContext* context = iSurface->Context();

    if (context != iContext)

    {

        iContext = context;

        ASSERT(iContext);

        iState = 0;

        iContext->SetPenStyle(CGraphicsContext::ENullPen);

        iContext->SetBrushStyle(CGraphicsContext::ENullBrush);

        iContext->SetOrigin(iOrigin);

        iContext->SetClippingRect(iClipRect);

        if (iFont)

        {

            iContext->UseFont(iFont);

            iContext->SetUnderlineStyle(iUnderline);

        }

    }

}

void CLcdGraphics::End()

{

    //

    // This may not be required if we have CLcdGraphics::Flush(rect)

    //

    //iSurface->Update();

    CHECK_BITMAP_LOCK();

}

/**

Maps a color provided as 32bit rgb triple to the closest color representable

in the target devices display mode. returns the result as a 32bit rgb triple.

*/

TUint32 CLcdGraphics::QuantizeColor(TUint32 aRGB32)

{

    if (iLcdDevice)

    {

        return iLcdDevice->Quantize(aRGB32);

    }

    return aRGB32; // iLcdDriver.Quantize( iFbsBitmap->DisplayMode(), aRGB32 );

}

CLcdSurface* CLcdGraphics::Surface()

{

    return iSurface;

}

void CLcdGraphics::SetColor(TUint32 aColor)

{

    if (iColor != aColor)

    {

        iColor = aColor;

        iState &= ~(EPenColor|EBrushColor);

    }

}

TUint32 CLcdGraphics::Color() const

{

    return iColor;

}

void CLcdGraphics::SetClipRect(const TPoint& aPosition, const TSize& aSize)

{

    //

    // We keep a copy of the clipping rectangle for the

    // blitters. Clip rect is supplied in translated

    // coordinates, we map to device coords.

    //

    iClipRect = TRect(aPosition, aSize);

    iContext->SetClippingRect(iClipRect);

    iDeviceClipRect = iClipRect;

    iDeviceClipRect.Move(iDeviceOrigin);

    iDeviceClipRect.Intersection(iDeviceBounds);

}

const TRect& CLcdGraphics::ClipRect() const

{

    return iClipRect;

}

void CLcdGraphics::Translate(const TPoint& aPoint)

{

    //

    // Context stores clip rect in translated coords so there

    // is no need to update the clipping rect.

    //

    iContext->SetOrigin(aPoint);

    iClipRect.Move(iOrigin - aPoint);

    iOrigin = aPoint;

    iDeviceOrigin = aPoint + iDeviceBounds.iTl;

}

const TPoint& CLcdGraphics::Origin() const

{

    return iOrigin;

}

void CLcdGraphics::SetStrokeStyle(TStrokeStyle aStyle)

{

    if (iStrokeStyle != aStyle)

    {

        iStrokeStyle = aStyle;

        if (iState & EPenOn)

        {

            iContext->SetPenStyle(PenStyle(iStrokeStyle));

        }

    }

}

TStrokeStyle CLcdGraphics::StrokeStyle() const

{

    return iStrokeStyle;

}

void CLcdGraphics::SetFont(TUint32 aFontID)

{

    MMIDFont* font = reinterpret_cast<MMIDFont*>(aFontID << 2);

    iFont = font->Font();

    iUnderline = font->IsUnderlined()  ? EUnderlineOn : EUnderlineOff;

    iHeight = font->Height();

    iContext->UseFont(iFont);

    iContext->SetUnderlineStyle(iUnderline);

}

void CLcdGraphics::Reset(const TSize& aSize)

{

    TRect deviceBounds(iDeviceBounds.iTl, aSize);

    iDeviceBounds = deviceBounds;

    iState = 0;

    iColor = KARGBBlack;

    iStrokeStyle = EStrokeSolid;

    iOrigin = TPoint(0,0);

    iClipRect = TRect(iDeviceBounds.Size());

    iDeviceClipRect = iDeviceBounds;

    iDeviceOrigin = iDeviceBounds.iTl;

    iContext->SetPenStyle(CGraphicsContext::ENullPen);

    iContext->SetBrushStyle(CGraphicsContext::ENullBrush);

    iContext->SetOrigin(iOrigin);

    iContext->SetClippingRect(iClipRect);

}

void CLcdGraphics::DrawLine(const TPoint& aPoint1, const TPoint& aPoint2)

{

    TInt caps = CLcdGraphicsDevice::ECapDrawLine;

    if (iStrokeStyle == EStrokeDotted)

    {

        caps |= CLcdGraphicsDevice::ECapStrokeDotted;

    }

    if ((iLcdDrawCaps & caps) == caps)

    {

        ASSERT(iLcdDevice);

        TPoint p1(aPoint1);

        TPoint p2(aPoint2);

        p1 += iDeviceOrigin;

        p2 += iDeviceOrigin;

        CHECK_BITMAP_LOCK();

        iSurface->Begin(iBitmap, iCount);

        RRegion* visibleRegion = iSurface->VisibleRegion();

        if (iBitmap.iAddress && visibleRegion)

        {

            const TRect* rects = visibleRegion->RectangleList();

            const TInt   count = visibleRegion->Count();

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

            {

                TRect clip(iDeviceClipRect);

                clip.Intersection(rects[i]);

                iLcdDevice->DrawLine(&iBitmap, p1, p2, iColor, (TStrokeStyle)iStrokeStyle, clip);

            }

        }

        iSurface->End(iCount);

        CHECK_BITMAP_LOCK();

    }

    else

    {

        LineMode();

        const TPoint& p1 = aPoint1;

        TPoint p2 = aPoint2;

        if (p1.iY == p2.iY)

        {

            /**

            Horizontal special case - adjust coords to include endpoint

            */

            if (p2.iX > p1.iX)

            {

                ++ p2.iX;

            }

            else

            {

                -- p2.iX;

            }

            iContext->DrawLine(p1,p2);

        }

        else if (p1.iX == p2.iX)

        {

            /**

            Vertical special case - adjust coords to include endpoint

            */

            if (p2.iY > p1.iY)

            {

                ++ p2.iY;

            }

            else

            {

                -- p2.iY;

            }

            iContext->DrawLine(p1, p2);

        }

        else

        {

            /**

            General slope - have to plot last point since SymbianOS GDI does

            not draw the last point on a line.

            */

            iContext->DrawLine(p1, p2);

            iContext->Plot(p2);

        }

    }

}

void CLcdGraphics::DrawRect(const TPoint& aPosition, const TSize& aSize)

{

    //

    // adjust coords for stroked primitives

    //

    TRect rect(aPosition, aSize);

    rect.iBr.iX++;

    rect.iBr.iY++;

    TInt caps = CLcdGraphicsDevice::ECapDrawRect;

    if (iStrokeStyle == EStrokeDotted)

    {

        caps |= CLcdGraphicsDevice::ECapStrokeDotted;

    }

    if ((iLcdDrawCaps & caps) == caps)

    {

        ASSERT(iLcdDevice);

        rect.Move(iDeviceOrigin);

        CHECK_BITMAP_LOCK();

        iSurface->Begin(iBitmap, iCount);

        RRegion* visibleRegion = iSurface->VisibleRegion();

        if (iBitmap.iAddress && visibleRegion)

        {

            const TRect* rects = visibleRegion->RectangleList();

            const TInt   count = visibleRegion->Count();

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

            {

                TRect clip(iDeviceClipRect);

                clip.Intersection(rects[i]);

                iLcdDevice->DrawRect(&iBitmap, rect, iColor, (TStrokeStyle)iStrokeStyle, clip);

            }

        }

        iSurface->End(iCount);

        CHECK_BITMAP_LOCK();

    }

    else

    {

        OutlineMode();

        iContext->DrawRect(rect);

    }

}

void CLcdGraphics::FillRect(const TPoint& aPosition, const TSize& aSize)

{

    TRect rect(aPosition, aSize);

    if (iLcdDrawCaps & CLcdGraphicsDevice::ECapFillRect)

    {

        ASSERT(iLcdDevice);

        rect.Move(iDeviceOrigin);

        CHECK_BITMAP_LOCK();

        iSurface->Begin(iBitmap, iCount);

        RRegion* visibleRegion = iSurface->VisibleRegion();

        if (iBitmap.iAddress && visibleRegion)

        {

            const TRect* rects = visibleRegion->RectangleList();

            const TInt   count = visibleRegion->Count();

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

            {

                TRect clip(iDeviceClipRect);

                clip.Intersection(rects[i]);

                iLcdDevice->FillRect(&iBitmap, rect, iColor, clip);

            }

        }

        iSurface->End(iCount);

        CHECK_BITMAP_LOCK();

    }

    else

    {

        FillMode();

        iContext->DrawRect(rect);

    }

}

void CLcdGraphics::DrawArc(const TPoint& aPosition, const TSize& aSize, TInt aStartAngle, TInt aArcAngle)

{

    if (!aArcAngle)

    {

        return;

    }

    TRect rect(aPosition, aSize);

    rect.iBr.iX++;

    rect.iBr.iY++;