/*

* 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:

*

*/

package javax.microedition.lcdui;

import org.eclipse.swt.widgets.Control;

import org.eclipse.swt.graphics.Point;

import org.eclipse.swt.graphics.Rectangle;

import org.eclipse.swt.internal.qt.graphics.GraphicsContext;

import org.eclipse.swt.internal.qt.graphics.JavaCommandBuffer;

import org.eclipse.swt.internal.qt.graphics.WindowSurface;

/**

 * This class works a proxy between instances of Graphics class and common graphics

 * (command buffer and GraphicsContext). The relation of this class to Graphics is one-to-many, i.e.

 * one GraphicsBuffer instance handles multiple Graphics instances.

 *

 * Each LCDUI API class instance providing access to Graphics (Image, Canvas, GameCanvas, CustomItem),

 * must instantiate one GraphicsBuffer and use it for creating instances of Graphics class.

 *

 * The implementation is not thread safe, thus all serialization must be implemented in

 * callers, for instance the Graphics implementation serializes all calls to this class.

 * Furthermore this class does not take care of switching to UI thread, it must be done by

 * caller object.

 */

abstract class Buffer

{

    // Constants for buffer host types

    final static int HOST_TYPE_IMAGE = 1;

    final static int HOST_TYPE_CANVAS = 2;

    final static int HOST_TYPE_CUSTOMITEM = 3;

    // Flags for raising settings validation

    private final static int NONE            = 0;

    private final static int COLOR           = 1;

    private final static int CLIP            = 2;

    private final static int FONT            = 4;

    private final static int STROKESTYLE     = 8;

    private final static int COORS_TRANSLATION = 16;

    // Graphics settings active in buffer

    // all values are comparable to those

    // in Graphics except font which is stored

    // as handle instead of LCDUI Font

    private int bufferFontHandle;

    private int bufferColor;

    private int bufferStrokeStyle;

    private int bufferTranslateX;

    private int bufferTranslateY;

    private Rectangle bufferClip;

    private GraphicsContext gc;

    private JavaCommandBuffer commandBuffer;

    private Rectangle hostBounds;

    private Graphics currentClient;

    private int clientCount;

    /**

     * Constructor

     */

    protected Buffer()

    {

        hostBounds = new Rectangle(0,0,0,0);

        bufferClip = new Rectangle(0,0,0,0);

        bufferFontHandle = 0;

        bufferColor = 0xff000000;

        bufferStrokeStyle = Graphics.SOLID;

        bufferTranslateX = 0;

        bufferTranslateY = 0;

    }

    /**

     * Initializes data, called once

     */

    {

        clientCount = 0;

        gc = new GraphicsContext();

        commandBuffer = new JavaCommandBuffer();

        gc.bindTarget(commandBuffer);

        writeControlBoundsToBuffer(false);

    }

    /**

     * Defines the bounds of the host.

     * Bounds are used for restricting the rendering in

     * the area of the control that is being updated. With Images

     * the bounds are not used.

     *

     * @param crtl The Control of the host

     * @param clienArea The area of the control which can be drawn by Graphics

     */

    void setControlBounds(final Control control)

    {

    }

    /**

     */

    abstract void bindToHost(GraphicsContext gc);

    /**

     * @return The host

     */

    abstract Object getHost();

    /**

     * @return One of host types defined in this class

     */

    abstract int getHostType();

    /**

     */

    /**

     * Creates and returns new Graphics instance

     * @return new Graphics instance

     */

    Graphics getGraphics()

    {

        {

            init();

        }

        clientCount++;

    }

    /**

     * Synchronizes this buffer with the actual target

     * must be called in UI thread. If no Graphics instances

     */

    {

        {

            return;

        }

        // if there's nothing to flush return

        if(!commandBuffer.containsDrawnPrimitives())

        {

            return;

        }

        doRelease();

        bindToHost(gc);

        gc.render(commandBuffer);

        doRelease();

        // Reset commands

        commandBuffer.reset();

        // Write last settings to buffer

        // as they are reset in bind

        gc.bindTarget(commandBuffer);

        gc.setFont(bufferFontHandle);

        gc.setBackgroundColor(bufferColor, true);

        gc.setForegroundColor(bufferColor, true);

        writeControlBoundsToBuffer(true);

    }

    /**

     * Decreases the client reference count,

     * should be called by Graphics instances when

     * they are about to be disposed

     */

    void removeRef()

    {

        clientCount--;

    }

    /**

     * Disposes this instance

     */

    void dispose()

    {

        commandBuffer = null;

    }

    void copyArea(int x1, int y1, int width, int height, int x2, int y2, Graphics client)

    {

        gc.copyArea(x1, y1, width, height, x2, y2);

    }

    void fillRect(int x, int y, int w, int h, Graphics client)

    {

        validateAndApplySettings((COLOR|CLIP|COORS_TRANSLATION), client);

        gc.fillRect(x, y, w, h);

    }

    void fillRoundRect(int x, int y, int w, int h, int arcW, int arcH, Graphics client)

    {

        validateAndApplySettings((COLOR|CLIP|COORS_TRANSLATION), client);

        gc.fillRoundRect(x, y, w, h, arcW, arcH);

    }

    void fillArc(int x, int y, int w, int h, int startAngle, int arcAngle, Graphics client)

    {

        validateAndApplySettings((COLOR|CLIP|COORS_TRANSLATION), client);

        gc.fillArc(x, y, w, h, startAngle, arcAngle);

    }

    void fillTriangle(int[] points, Graphics client)

    {

        validateAndApplySettings((COLOR|CLIP|COORS_TRANSLATION), client);

        gc.fillPolygon(points);

    }

    void setClip(int x, int y, int w, int h, Graphics client)

    {

        validateAndApplySettings(COORS_TRANSLATION, client);

        // check if given clip is already active in buffer

        if((bufferClip.x == x) && (bufferClip.y == y) &&

                (bufferClip.width == w) && (bufferClip.height== h))

        {

            return;

        }

        // Images do not need special handling

        if(getHostType() == HOST_TYPE_IMAGE)

        {

            gc.setClip(x, y, w, h, false);

            return;

        }

        // translate clip to display coordinates and apply

        Rectangle rect = clipToDisplayCoords(x, y, w, h);

        if(rect.isEmpty())

        {

            // check is buffer clip is already up to date

            if(bufferClip.isEmpty())

            {

                return;

            }

            else

            {

                // This is a special case, where the clip defines

                // an area outside control bounds and due to that the clip

                // is set to zero size, in order t prevent drawing on top of other controls.

                // In all other cases the buffer clip is always set

                // to the same values as the client, i.e. Graphics has.

                // So by setting the bufferClip here to zero means that the clip

                // in Graphics and the buffer are not in sync and not comparable,

                // however they will be back in sync when client sets clip

                // with an area partly or completely inside the host control.

                bufferClip = rect;

            }

        }

        else

        {

            bufferClip.x = x;

            bufferClip.y = y;

            bufferClip.width = w;

            bufferClip.height = h;

        }

        gc.setClip(rect.x, rect.y, rect.width, rect.height, false);

    }

    void setColor(int r, int g, int b, Graphics client)

    {

        // check if given color is already active in buffer

        if(bufferColor == (Graphics.OPAQUE_ALPHA | (r << 16) | (g << 8) | b))

        {

            return;

        }

        gc.setForegroundColor(r, g, b);

        gc.setBackgroundColor(r, g, b);

        // Cache active color

        bufferColor = (Graphics.OPAQUE_ALPHA | (r << 16) | (g << 8) | b);

    }

    void setFont(int fontHandle, Graphics client)

    {

        // check if given font is already active in buffer

        if(bufferFontHandle == fontHandle)

        {

            return;

        }

        gc.setFont(fontHandle);

        // Cache active setting

        bufferFontHandle = fontHandle;

    }

    void setStrokeStyle(int cgfxStyle, int graphicsStyle, Graphics client)

    {

        if(bufferStrokeStyle == graphicsStyle)

        {

            return;

        }

        gc.setStrokeStyle(cgfxStyle);

        // Cache active setting

        bufferStrokeStyle = graphicsStyle;

    }

    void translate(int xDelta, int yDelta, Graphics client)

    {

        if((xDelta == 0) && (yDelta == 0))

        {

            return;

        }

        gc.translate(xDelta, yDelta);

        // Cache active settings

        bufferTranslateX += xDelta;

        bufferTranslateY += yDelta;

    }

    void drawLine(int xStart, int yStart, int xEnd, int yEnd, Graphics client)

    {

        validateAndApplySettings((COLOR|CLIP|COORS_TRANSLATION|STROKESTYLE), client);

        gc.drawLine(xStart, yStart, xEnd, yEnd);

    }

    void drawRect(int x, int y, int w, int h, Graphics client)

    {

        validateAndApplySettings((COLOR|CLIP|COORS_TRANSLATION|STROKESTYLE), client);