/*

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

*

*/

package javax.microedition.lcdui;

import org.eclipse.swt.widgets.Control;

import org.eclipse.swt.widgets.Widget;

import org.eclipse.swt.graphics.Point;

import org.eclipse.swt.graphics.Rectangle;

import org.eclipse.swt.internal.qt.OS;

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

{

    // Default values for Graphics 

    final static Font defaultFont = Font.getDefaultFont();

    final static int defaultColor = 0xff000000;

    final static int defaultStrokeStyle = Graphics.SOLID;

    final static int defaultTranslateX = 0;

    final static int defaultTranslateY = 0;

    // 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

    // FORCE_SETTINGS Forces settings to validated also in case

    // there's only one Graphics instance as client, normally 

    // settings are not checked in such case

    final static int NONE            = 0;

    final static int COLOR           = 1;

    final static int CLIP            = 2;

    final static int FONT            = 4;

    final static int STROKESTYLE     = 8;

    final static int COORDS_TRANSLATION = 16; 

    final static int FORCE_SETTINGS    = 32; 

    // 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 boolean isInitialized;

    private int clientCount;

    private boolean isSurfaceSessionOpen;

    /**

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

    }

    /**

     * Creates Buffer instance based on the type of given host object 

     * and the platform (symbian/linux) currently running on.

     * 

     * @param host The host target where pixels are drawn. Given object must be Canvas, CustomItem or Image.

     * @param control The eSWT control associated with the target, or null if the host is Image

     * @return New buffer instance

     */

    static Buffer createInstance(Object host, Control control)

    {

        if(host instanceof Canvas) 

        {

            if(OS.windowServer == OS.WS_SYMBIAN_S60)

            {   

                return new CanvasBufferSymbian((Canvas) host, control);

            }

            else if(OS.windowServer == OS.WS_X11)

            {

                return new CanvasBufferLinux((Canvas) host, control);

            }

            return null;

        } 

        else if(host instanceof CustomItem)

        {

            if(OS.windowServer == OS.WS_SYMBIAN_S60)

            {   

                return new CustomItemBufferSymbian((CustomItem) host, control);

            }

            else if(OS.windowServer == OS.WS_X11)

            {

                return new CustomItemBufferLinux((CustomItem) host, control);

            }

            return null;

        } 

        else if(host instanceof Image) 

        {

            return new ImageBuffer((Image) host);   

        }

        return null;

    }

    /**

     * Initializes data, called once

     */

    protected void init()

    {

        clientCount = 0;

        gc = new GraphicsContext();

        commandBuffer = new JavaCommandBuffer();

        gc.bindTarget(commandBuffer);

        writeControlBoundsToBuffer(false);

        isInitialized = true;

    }

    /**

     * Defines the bounds of the host.

     * Bounds are used for restricting the rendering in

     * the area of the control that is being updated. 

     *

     * @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)

    {

        // This implementation is based on the fact that

        // the QWindowSurface has the size of the shell active area

        // not the whole display, thus Shell clientArea equals QWindowSurface.

        // This might change in future if/when Qt starts

        // rendering e.g. the status pane i.e. the whole display

        // to window surface

        Point controlLoc = control.toDisplay(0,0);

        Point shellLoc = control.getShell().toDisplay(0,0);

        hostBounds.x = controlLoc.x - shellLoc.x;

        hostBounds.y = controlLoc.y - shellLoc.y;

        hostBounds.width = control.getBounds().width;

        hostBounds.height = control.getBounds().height;

    }

    /**

     * Defines the bounds of the host.

     *

     * @param crtl The Control of the host

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

     */

    void setImageBounds(int width, int height)

    {

        hostBounds.x = 0;

        hostBounds.y = 0;

        hostBounds.width = width;

        hostBounds.height = height;

    }

    /**

     * Prepares surface for a new frame and starts paint session. 

     * Must be called in UI thread (sync calls this automatically)

     * and at the start of new frame. The rectangle provided as 

     * arguments are in control coordinates.

     * 

     * @param x The x-coordinate of the area to be painted

     * @param y The y-coordinate of the area to be painted

     * @param w The width of the area to be painted

     * @param h The height of the area to be painted

     */

    void startFrame(int x, int y, int w, int h)

    {

        if(!isSurfaceSessionOpen)

        {

            beginPaint(x, y, w, h);

            isSurfaceSessionOpen = true;

        }

    }

    /**

     * Ends frame painting session. Must be called in UI thread and

     * at the end of the frame. BlitToDisplay calls this automatically.

     */

    void endFrame()

    {

        if(isSurfaceSessionOpen)

        {

            endPaint();

            isSurfaceSessionOpen = false;

        }

    }

    /**

     * Transfers the result of rendering to display.

     * @param gc The graphics context used for blit, may be null in some cases

     * @param widget The widget that is the target 

     */

    void blitToDisplay(GraphicsContext gc, Widget widget)

    {

        endFrame();

        blit(gc, widget);

    }

    /** 

     * Prepares surface for painting, implemented by

     * child implementation.

     * @param x The x-coordinate of the area to be painted

     * @param y The y-coordinate of the area to be painted

     * @param w The width of the area to be painted

     * @param h The height of the area to be painted

     */

    abstract void beginPaint(int x, int y, int w, int h);

    /**

     * Ends frame painting session. Must be called in UI thread and

     * at the end of the frame. Implemented by

     * child implementation.

     */

    abstract void endPaint();

    /**

     * Performs binding to target in host specific way. Implemented by

     * child implementation.

     */

    abstract void bindToHost(GraphicsContext gc);

    /** 

     * Performs the actual blit operation in child class implementation.

     * @param gc The graphics context used for blit, may be null in some cases

     * @param widget The widget that is the target 

     */

    abstract void blit(GraphicsContext gc, Widget widget);

    /**

     * Getter for the host of the buffer, implemented by

     * child implementation.

     * @return The host

     */

    abstract Object getHost();

    /**

     * Getter for the host type,implemented by

     * child implementation.

     * @return One of host types defined in this class

     */

    abstract int getHostType();

    /**

     * Status checker that indicates if this instance has requested a synchronous paint event, 

     * implemented by child implementation.

     * @return True if this instance has requested a redraw paint event, otherwise false

     */

    abstract boolean isPaintingActive(); 

    /**

     * Creates and returns new Graphics instance

     * @return new Graphics instance

     */

    Graphics getGraphics()

    {

        if(!isInitialized)

        {

            init();

        }

        clientCount++;

        // In case this is the first Graphics instance

        // write the default values to the buffer

        if(clientCount == 1) 

        {

            writeDefaultValuesToBuffer();   

        }

        return new Graphics(this, hostBounds );

    }

    /**

     * Synchronizes this buffer with the actual target

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

     * are created, sync has no effect. This variant always closes 

     * the surface session unconditionally

     */

    void sync() 

    {

        sync(true);

    }

    /**

     * Synchronizes this buffer with the actual target

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

     * are created, sync has no effect

     * 

     * @param closeSurfaceSession If true the endFrame is called after sync has been 

     *                            performed closing the surface session, otherwise

     *                            endFrame is performed and surface session is left open

     */

    void sync(boolean closeSurfaceSession)

    {

        if(!isInitialized)

        {

            return;

        }

        if(!commandBuffer.containsDrawnPrimitives())

        {

            return;

        }

        // Start surface session if not started yet

        startFrame(hostBounds.x, hostBounds.y , hostBounds.width , hostBounds.height);

        doRelease();

        bindToHost(gc);

        gc.render(commandBuffer);

        doRelease();

        // Close surface session

        if(closeSurfaceSession)

        {

            endFrame();

        }

        // 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()

    {

        if(gc != null) 

        {

            doRelease();

            gc.dispose();

            gc = null;

        }

        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|COORDS_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|COORDS_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|COORDS_TRANSLATION), client);

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

    }

    void fillTriangle(int[] points, Graphics client)

    {

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

        gc.fillPolygon(points);

    }

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

    {

        validateAndApplySettings(COORDS_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 = clipToWindowCoords(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 setGraphicsDefaults(Graphics client)

    {

    	validateAndApplySettings((FONT|COLOR|STROKESTYLE|COORDS_TRANSLATION|FORCE_SETTINGS), client);

    }

    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;

    }