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

 * Copyright (c) 2008, 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 - initial API and implementation

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

#include <QBrush>

#include <QGradient>

#include <QImage>

#include <QLine>

#include <QLinearGradient>

#include <QPainterPath>

#include <QPolygon>

#include <QColor>

#include <QFont>

#include <QStyleOptionFocusRect>

#include <QApplication>

#include <QFrame>

#include <QPaintEngine>

//#ifdef __SYMBIAN32__

//#include <QtGui/private/qpixmapdata_p.h>

//#endif

#include <memory>

#include "graphicscontextimpl.h"

#include "gfxlog.h"

#include "autorelease.h"

#include "swtbufferflushevent.h"

#include "iostream"

using namespace std;

namespace Java { namespace GFX {

GraphicsContextImpl::GraphicsContextImpl()

: mPainter(NULL),

  mPen(NULL),

  mBackground(Qt::white),

  mForeground(Qt::black)

{

    GFX_LOG_FUNC_CALL();

}

GraphicsContextImpl::~GraphicsContextImpl()

{

    GFX_LOG_FUNC_CALL();

    // Disconnect observer in case it is active

    if(mObserver.isObserving())

    {

        mObserver.disconnectTarget();

    }

    doCleanup();

}

WindowSurface* GraphicsContextImpl::getWindowSurface()

{

    GFX_LOG_FUNC_CALL();

    QPaintEngine* engine = mPainter->paintEngine();

    QPaintDevice* device = engine->paintDevice();

    switch (device->devType())

    {

        case QInternal::Image:

        {

            return GraphicsFactory::createWindowSurface(device, WsTypeQtImage);

        }

        case QInternal::Pixmap:

        {

            // this is a quick fix for linux build break

//#ifdef __SYMBIAN32__

//            QPixmapData* data = mSurface.getPixmap()->pixmapData();

//            return GraphicsFactory::createWindowSurface(static_cast<QPaintDevice*>(data->buffer()), QtImage);

//#else

            return NULL;

//#endif

        }

        default:

        {

            return 0;

        }

    }

}

void GraphicsContextImpl::bindTarget(int aTarget, TTargetType aType, const int& aBufferFlushTargetHandle)

{

    GFX_LOG_FUNC_CALL();

    // If not created yet, create fresh painter & pen

    if (mPainter == NULL || mPen == NULL ) {

        mPainter = new(std::nothrow) QPainter();

        mPen     = new(std::nothrow) QPen();

    }

    // Validate allocations

    if (mPainter == NULL || mPen == NULL )

    {

        doCleanup();

        throw GfxException(EGfxErrorNoMemory, "mPainter or mPen - alloc failed");

    }

    // color are clean at this point

    mBgColorDirty = false;

    mFgColorDirty = false;

    // Reset local color

    mForeground = mPen->color();

    // Set target for surface

    mSurface.setTarget(aTarget, aType);

    if(aType == ETypeBuffer)

        {

        mSurface.setBufferFlushTarget(reinterpret_cast<QPaintDevice*>(aBufferFlushTargetHandle));

        }

    QPaintDevice* paintDevice = mSurface.getBindable();

    if(paintDevice->paintingActive())

    {

        doCleanup();

        throw GfxException(EGfxErrorIllegalState, "Target already bound by other gc instance");

    }

    // Start painter on target and check success of begin()

    // This might fail if there's already painter associated with

    // current target, the target is null or if target is widget and

    // paintevent hasn't been sent by window server before trying to paint

    if (!(mPainter->begin(paintDevice)))

    {

        doCleanup();

        throw GfxException(EGfxErrorIllegalArgument, "Painter->begin() - failed");

    }

    // If target is type of Widget or MainWindow, set observer to monitor

    // rendering targets state, i.e. when it's destroyed.

    // Is target is deleted before releaseTarget is called, the observer gets notification

    // of that and automatically calls releaseTarget of this GC.

    if(mSurface.getType() == ETypeWidget)

    {

        mObserver.connectTarget((GraphicsContext*)this, mSurface.getWidget());

    }

    // set default pen width to 1 isntead of Qt default 0 (cosmetic pen)

    mPen->setWidth(1);

    mPainter->setPen(*mPen);

}

void GraphicsContextImpl::render(Buffer* aBuffer)

{

    GFX_LOG_FUNC_CALL();

    mPainter->drawPicture(0,0, *aBuffer->getPicture());

}

void GraphicsContextImpl::releaseTarget()

{

    GFX_LOG_FUNC_CALL();

    // End painting, i.e. flush if painter is active,

    // otherwise end should not be called.

    // mPainter might be null at this point if binding failed,

    // so check that before checking state.

    if(mPainter != NULL) {

        if(mPainter->isActive())

        {

            mPainter->end();

        }

    }

    // Disconnect observer in case it is active

    if(mObserver.isObserving())

    {

        mObserver.disconnectTarget();

    }

    // Do cleanup

    mSurface.clearTarget();

    // saveSettings/restoreSettings need mPainter, so do not do cleanup for now

    // doCleanup();

}

/*

 *  Copy area from currently bound target to given image target

 *  NOTE: This covers currently only Images

 */

void GraphicsContextImpl::copyArea(Image* aImage, int aX, int aY)

    GFX_LOG_FUNC_CALL();

    switch (mSurface.getType()) {

        case ETypeWidget:

        case ETypeBuffer:

        {

            QWidget* widget = 0;

            if (mSurface.getType() == ETypeWidget)

                widget = mSurface.getWidget();

            else // ETypeBuffer

                widget = static_cast<QWidget*>(reinterpret_cast<QObject*>(mSurface.getBufferFlushTarget()));

            if (widget)

                // Determine the smallest area needed to grab, don't grab anything we don't need

                const int widgetGrabWidth = widget->width() - aX;

                const int widgetGrabHeight = widget->height() - aY;

                const int imageGrabWidth = aImage->getWidth();

                const int imageGrabHeight = aImage->getHeight();

                const int minGrabWidth = widgetGrabWidth < imageGrabWidth ? widgetGrabWidth : imageGrabWidth;

                const int minGrabHeight = widgetGrabHeight < imageGrabHeight ? widgetGrabHeight : imageGrabHeight;

                // Source coordinates need to be adjusted by the widget's

                // location in the parent that owns the window.

                QPoint offset = widgetOffsetInWindow(widget);

                QRect source(aX+offset.x(), aY+offset.y(), minGrabWidth, minGrabHeight);

                QRect target(0, 0, minGrabWidth, minGrabHeight);

                // Get the paint device that the widget is using

                int devType = QInternal::UnknownDevice;

                QPaintEngine* engine = mPainter->paintEngine();

                QPaintDevice* device = NULL;

                if(engine)

                    {

                    device = engine->paintDevice();

                    if(device)

                        {

                        devType = device->devType();

                        }

                    }

                switch(devType)

                    {

                    case QInternal::Image:

                        {

                        QImage& pixels = static_cast<QImage&>(*device);

                        QPainter p(aImage->getBindable());

                        drawImageCheckOverlap(p, *aImage->getBindable(), target, pixels, source);

                        }

                        break;

                    case QInternal::Pixmap:

                        {

                        QPixmap& pixmap = static_cast<QPixmap&>(*device);

                        QPainter p(aImage->getBindable());

                        drawPixmapCheckOverlap(p, *aImage->getBindable(), target, pixmap, source);

                        }

                        break;

                    case QInternal::Picture:

                        {

                        // Grab area from the window and draw it to the Image.

                        // Don't grab from outside of the window but grab a smaller area

                        // if necessary and adjust target coordinates accordingly.

                        QRect widgetRect(offset, widget->size());

                        QRect grabRect = source.intersected(widgetRect);

                        QPixmap winGrab = QPixmap::grabWindow(widget->window()->winId(),

                                grabRect.x(), grabRect.y(), grabRect.width(), grabRect.height());

                        QPainter p(aImage->getBindable());

                        p.drawPixmap(target.x() + grabRect.x() - source.x(),

                                target.y() + grabRect.y() - source.y(), winGrab);

                        }

                        break;

                    default: // QInternal::UnknownDevice or something else

                        {

                        // Grab area from the window and draw it to the widget.

                        QRect grabRect = source.intersected(QRect(QPoint(0, 0), widget->size()));

                        QPixmap winGrab = QPixmap::grabWindow(widget->window()->winId(),

                                grabRect.x(), grabRect.y(), grabRect.width(), grabRect.height());

                        QPainter p(aImage->getBindable());

                        p.drawPixmap(target.x() + grabRect.x() - source.x(),

                                target.y() + grabRect.y() - source.y(), winGrab);

                        }

                        break;

                    }

            }

            break;

        }

        case ETypeImage:

            TImageType type = mSurface.getImageType();

            if (type == EPixmap)

                QPixmap* source = mSurface.getPixmap();

                QRect sourceRect(aX, aY, target->width(), target->height());

                QRect targetRect(0, 0, target->width(), target->height());

                // If copying on itself then don't try to create two QPainters

                // for the same paint device

                if(target == source)

                    drawPixmapCheckOverlap(*mPainter, *target, targetRect, *source, sourceRect);

                else

                    QPainter painter(target);

                    drawPixmapCheckOverlap(painter, *target, targetRect, *source, sourceRect);

                }

            else

                Q_ASSERT_X(false, "Graphics", "CopyArea image type not recognized");

            }

        default:

            Q_ASSERT_X(false, "Graphics", "Surface type not recognized");

            break;

    }

}

/*

 *  Copy a rectangular area within the currently bound target

 */

void GraphicsContextImpl::copyArea(int aSrcX, int aSrcY, int aWidth, int aHeight, int aDestX, int aDestY, bool aPaint)

{

    GFX_LOG_FUNC_CALL();

    TTargetType painterTarget = mSurface.getType();

    switch(painterTarget)

    {

        case ETypeWidget:

        case ETypeBuffer:

        {

            QWidget* widget = 0;

            if (painterTarget == ETypeWidget)

            {

                widget = mSurface.getWidget();

            }

            else // ETypeBuffer

            {

                widget = static_cast<QWidget*>(reinterpret_cast<QObject*>(mSurface.getBufferFlushTarget()));

            }

            if (widget)

            {

                // Source coordinates need to be adjusted by the widget's

                // location in the parent that owns the window. Target

                // coordinates are already correctly in the widget's coordinate

                // system.

                QPoint offset = widgetOffsetInWindow(widget);

                QRect target(aDestX, aDestY, aWidth, aHeight);

                QRect source(aSrcX+offset.x(), aSrcY+offset.y(), aWidth, aHeight);

                // Get the paint device that the widget is using

                int devType = QInternal::UnknownDevice;

                QPaintEngine* engine = mPainter->paintEngine();

                QPaintDevice* device = NULL;

                if(engine)

                    {

                    device = engine->paintDevice();

                    if(device)

                        {

                        devType = device->devType();

                        }

                    }

                switch(devType)

                    {

                    case QInternal::Image:

                        {

                        QImage& pixels = static_cast<QImage&>(*device);

                        drawImageCheckOverlap(*mPainter, pixels, target, pixels, source);

                        }

                        break;

                    case QInternal::Pixmap:

                        {

                        QPixmap& pixmap = static_cast<QPixmap&>(*device);

                        drawPixmapCheckOverlap(*mPainter, pixmap, target, pixmap, source);

                        }

                        break;

                    case QInternal::Picture:

                        {

                        // Grab area from the window and draw it to the QPicture buffer.

                        // Don't grab from outside of the window but grab a smaller area

                        // if necessary and adjust target coordinates accordingly.

                        QRect widgetRect(offset, widget->size());

                        QRect grabRect = source.intersected(widgetRect);

                        QPixmap winGrab = QPixmap::grabWindow(widget->window()->winId(),

                                grabRect.x(), grabRect.y(), grabRect.width(), grabRect.height());

                        mPainter->drawPixmap(target.x() + grabRect.x() - source.x(),

                                target.y() + grabRect.y() - source.y(), winGrab);

                        // The copied area needs to be painted now. In the end

                        // result it needs to appear on top so the area needs

                        // to be first painted to the widget then a paint event

                        // is sent to the application where the area is

                        // clipped. All commands that have been collected

                        // outside of the paint listener are flushed here. If

                        // there are more commands outside the paint listener

                        // after this flush then it might cause flicker.

                        flushBufferToSwtWidget(widget, target);

                        }

                        break;

                    default: // QInternal::UnknownDevice or something else

                        {

                        // Grab area from the window and draw it to the widget.

                        QRect grabRect = source.intersected(QRect(QPoint(0, 0), widget->size()));

                        QPixmap winGrab = QPixmap::grabWindow(widget->window()->winId(),

                                grabRect.x(), grabRect.y(), grabRect.width(), grabRect.height());

                        mPainter->drawPixmap(target.x() + grabRect.x() - source.x(),

                                target.y() + grabRect.y() - source.y(), winGrab);

                        }

                        break;

                    }

                if(aPaint)

                    {

                    // Calculate region to invalidate

                    QRegion sourceArea(aSrcX, aSrcY, aWidth, aHeight);

                    QRegion targetArea(aDestX, aDestY, aWidth, aHeight);

                    QRegion clientArea(0, 0, widget->size().width(), widget->size().height());

                    QRegion sourceAreaInsideWidget = clientArea.intersected(sourceArea);

                    // Start with the whole source area

                    QRegion invalidArea(sourceArea);

                    // Remove possibly overlapping target area

                    invalidArea = invalidArea.subtracted(targetArea);

                    // Add the areas that were scrolled in from outside of the widget

                    invalidArea = invalidArea.united(targetArea);

                    sourceAreaInsideWidget.translate(aDestX-aSrcX, aDestY-aSrcY);

                    invalidArea = invalidArea.subtracted(sourceAreaInsideWidget);

                    widget->update(invalidArea);

                    }

            }

            break;

        }

        case ETypeImage:

        {

            // first obtain native image type of current target (QPixmap/QImage)

            TImageType type = mSurface.getImageType();

            if (type == EPixmap)

            {

                drawPixmapCheckOverlap(*mPainter, *mSurface.getBindable(), targetRect, *mSurface.getPixmap(), sourceRect);

            }

            else

            {

                Q_ASSERT_X(false, "Graphics", "CopyArea image type not recognized");

            }

            break;

        }

        default:

        {

            Q_ASSERT_X(false, "Graphics", "Surface type not recognized");

        }

    }

}

void GraphicsContextImpl::drawArc(int aX, int aY, int aWidth, int aHeight, int aStartAngle, int aArcAngle)

{

    GFX_LOG_FUNC_CALL();

    checkFgColor();

    QRect arcRect(aX, aY, aWidth, aHeight);

    mPainter->drawArc(arcRect, aStartAngle*16, aArcAngle*16);

}

void GraphicsContextImpl::drawEllipse(int aX, int aY, int aWidth, int aHeight)

{

    GFX_LOG_FUNC_CALL();

    checkFgColor();

    mPainter->drawEllipse(aX, aY, aWidth, aHeight);

}

void GraphicsContextImpl::drawFocus(int aX, int aY, int aWidth, int aHeight)

{

    GFX_LOG_FUNC_CALL();

    QStyleOptionFocusRect option;

    option.rect.setRect(aX, aY, aWidth, aHeight);

    QApplication::style()->drawPrimitive(QStyle::PE_FrameFocusRect, &option, mPainter);

}

void GraphicsContextImpl::drawImage(Image* aImage, int x, int y)

{

    TImageType type = aImage->type();

    switch (type)

    {

        case EPixmap:

            break;