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

 * Copyright (c) 2008 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 implementation

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

package org.eclipse.swt.internal.qt.graphics;

import java.util.Vector;

import org.eclipse.swt.widgets.Internal_PackageSupport;

import org.eclipse.swt.widgets.Widget;

public final class GraphicsContext {

    // These must be in sync with graphics.h

    // Rectangle index

    /**

     * Rectangle data array's <code>x</code> index

     * @see #getClip

     * @see #getTextBoundingBox

     */

    public final static int RECT_X = 0;

    /**

     * Rectangle data array's <code>y</code> index

     * @see #getClip

     * @see #getTextBoundingBox

     */

    public final static int RECT_Y = 1;

    /**

     * Rectangle data array's <code>width</code> index

     * @see #getClip

     * @see #getTextBoundingBox

     */

    public final static int RECT_WIDTH = 2;

    /**

     * Rectangle data array's <code>height</code> index

     * @see #getClip

     * @see #getTextBoundingBox

     */

    public final static int RECT_HEIGHT = 3;

    // Blending modes

    /**

     * Constant for Source blending mode. The destination's color and

     * alpha values are replaced with those of source.

     */

    public static final int BLENDING_MODE_SRC = 10;

    /**

     * Constant for Source over blending mode. The source is composed over destination.

     */

    public static final int BLENDING_MODE_SRC_OVER = 11;

    /**

     * Constant for XOR blending mode. The resulting color in the destination is

     * the exclusive or of the color values in the source and the destination.

     */

    public static final int BLENDING_MODE_XOR = 12;

    // Stroke styles

    /**

     * Stroke style is not set.

     */

    public static final int STROKE_NO = 0;

    /**

     * Solid stroke.

     */

    public static final int STROKE_SOLID = 1;

    /**

     * Dotted stroke

     */

    public static final int STROKE_DOT = 2;

    /**

     * Dash stroke

     */

    public static final int STROKE_DASH = 3;

    /**

     * Dash-dot stroke

     */

    public static final int STROKE_DASH_DOT = 4;

    /**

     * Dash-dot-dot stroke

     */

    public static final int STROKE_DASH_DOT_DOT = 5;

    // Text flags

    /**

     * One line. Whitespaces are threated as spaces.

     * NOTE: TEXT_SINGLE_LINE and TEXT_WORD_WRAP cannot be combined.

     * @see TEXT_WORD_WRAP

     */

    public static final int TEXT_SINGLE_LINE = 0x0100;

    /**

     * Prints outside of the given bounds if needed

     */

    public static final int TEXT_DONT_CLIP = 0x0200;

    /**

     * Expand tabs

     */

    public static final int TEXT_EXPAND_TABS = 0x0400;

    /**

     * Underline the mnemonic character

     */

    public static final int TEXT_SHOW_MNEMONIC = 0x0800;

    /**

     * Breaks lines at appropriate points

     * NOTE: TEXT_SINGLE_LINE and TEXT_WORD_WRAP cannot be combined.

     * @see TEXT_SINGLE_LINE

     */

    public static final int TEXT_WORD_WRAP = 0x1000;

    /**

     * Breaks lines anywhere, even within words.

     */

    public static final int TEXT_WRAP_ANYWHERE = 0x2000;

    /**

     * Same as OS_TEXT_SHOW_MNEMONIC but no underlines.

     * @see OS_TEXT_SHOW_MNEMONIC

     */

    public static final int TEXT_HIDE_MNEMONIC = 0x8000;

    /**

     * Behaves like a "hidden" text - not printed.

     */

    public static final int TEXT_DONT_PRINT = 0x4000;

    /**

     * Trailing whitespace not deleted automatically.

     */

    public static final int TEXT_INCLUDE_TRAILING_SPACES = 0x08000000;

    /**

     * Ensures that text lines are justified.

     */

    public static final int TEXT_JUSTIFICATIONFORCED = 0x10000;

    // Alignment flags

    /**

     * Aligns with the left edge.

     */

    public static final int ALIGNMENT_LEFT = 0x0001;

    /**

     * Aligns with the right edge.

     */

    public static final int ALIGNMENT_RIGHT = 0x0002;

    /**

     * Centers horizontally in the available space.

     */

    public static final int ALIGNMENT_HCENTER = 0x0004;

    /**

     * Justifies the text in the available space.

     */

    public static final int ALIGNMENT_JUSTIFY = 0x0008;

    /**

     * Aligns with the top.

     */

    public static final int ALIGNMENT_TOP = 0x0020;

    /**

     * Aligns with the bottom.

     */

    public static final int ALIGNMENT_BOTTOM =    0x0040;

    /**

     * Centers vertically in the available space.

     */

    public static final int ALIGNMENT_VCENTER = 0x0080;

    // package constants

    /**

     * Specifies no target

     */

    static final int TARGET_NONE = 0;

    /**

     * Specifies native target type QWidget.

     */

    static final int TARGET_WIDGET = 1;

    /**

     * Specifies native target type Image.

     */

    static final int TARGET_IMAGE = 2;

    /**

     * Specifies native target type Buffer.

     */

    static final int TARGET_NATIVE_COMMAND_BUFFER = 3;

    /**

     * Specifies Java command buffer target

     */

    static final int TARGET_WINDOWSURFACE = 4;

    /**

     * Specifies Java command buffer target, not valid in native target types

     */

   static final int TARGET_JAVA_COMMAND_BUFFER = 5;

    /**

     * Native peer handle

     */

    int handle = -1;

    /**

     * private members

     */

    private boolean disposed;

    private RenderingTarget targetData = null;

    /**

     * Constructor

     */

    public GraphicsContext() {

        Utils.validateUiThread();

        handle = OS.graphicsContext_init();

        targetData = new RenderingTarget();

        disposed = false;

    }

    /**

     * Gets the windowsurface of currently bound target.

     * Windowsurface is the surface where external graphics APIs can render, e.g m2g and m3g.

     * @return windowSurface if currently bound target has one, otherwise null

     */

    public WindowSurface getWindowSurface() {

        checkState();

        // buffers don't have a window surface

        if ((targetData.type == TARGET_NATIVE_COMMAND_BUFFER) ||(targetData.type == TARGET_JAVA_COMMAND_BUFFER) ) {

            return null;

        }

        // Get the current target that is bound

        Object target = targetData.target;

        // Only shells have window surface so figure out if target is shell,

        // and if not get the shell of child widget

        if (targetData.type == TARGET_WIDGET) {

            if (!(target instanceof org.eclipse.swt.widgets.Shell)) {

                target = ((org.eclipse.swt.widgets.Control)target).getShell();

            }

        }

        SurfaceCache cache = SurfaceCache.getInstance();

        // check surface cache for existing windowsurface for current target

        WindowSurface surface = cache.getSurface(target);

        // If not found in cache we need to create new one

        // and store that to cache for future use

        if (surface == null) {

            surface = new WindowSurface(OS.graphicsContext_get_windowsurface(handle));

            if (targetData.type == TARGET_WIDGET) {

                // Add to cache and let it add dispose listener for automatic cleanup

                cache.addSurface(surface, target, true);

            } else {

                // Image associated entry's are deleted when Image dispose is called 

                cache.addSurface(surface, target, false);

            }

            return surface;

        } else {

            return surface;

        }

    }

    void bindTarget(java.lang.Object target, int type, int handle, int bufferFlushTargetHandle) {

        Utils.validateUiThread();

        // validate state

        if(disposed) {

            throw new IllegalStateException("GraphicsContext already disposed");

        }

        if (isActive()) {

            throw new IllegalStateException("Already bound to target: " + targetData.target);

        }

        // Reset iTarget before setting new target

        targetData.reset();

        // call for actual bind, this may throw an exception

        // especially when trying to bind a target which has been bound already

        // this is skipped if target is java command buffer

        if (type != TARGET_JAVA_COMMAND_BUFFER) {

            doBind(handle, type, target, bufferFlushTargetHandle);

        } else {

            if(((JavaCommandBuffer)target).isBound()) {

                throw new IllegalStateException("Target already bound by other gc instance");

            }

            targetData.commandBuffer = (JavaCommandBuffer)target;

            targetData.isJavaCommandBuffer = true;

        }

        // store target

        targetData.handle = handle;

        targetData.type = type;

        targetData.target = target;

        // If target is Image, inform that it is being bound.

        // this is needed in case image is disposed before

        // releaseTarget() is called

        if(type == TARGET_IMAGE) {

            ((org.eclipse.swt.internal.qt.graphics.Image)target).notifyBind(this);

        }

    }

    /**

     * Binds given SWT Control as the rendering target of this GraphicsContext.

     *

     * @param target SWT Control

     *

     * @throws java.lang.IllegalStateException if this GraphicsContext already has a rendering target

     * @throws java.lang.IllegalStateException if given target is already bound by some other GC instance

     * @throws java.lang.IllegalStateException if GraphicsContext has already been disposed

     * @throws java.lang.NullPointerException if given target is null

     * @throws java.lang.IllegalArgumentException if given target cannot be bound

     * @throws java.lang.IllegalArgumentException if given target is already disposed

     */

    public void bindTarget(org.eclipse.swt.widgets.Control target) {

        if(target == null) {

        }

        if(target.isDisposed())

            throw new IllegalArgumentException("Target already disposed");

        bindTarget(target, TARGET_WIDGET, handle(target), 0);

    }

    /**

     * Binds given SWT Display as the rendering target of this GraphicsContext.

     *

     * @param target SWT Display

     *

     * @throws java.lang.IllegalStateException if this GraphicsContext already has a rendering target

     * @throws java.lang.IllegalStateException if given target is already bound by some other GC instance

     * @throws java.lang.IllegalStateException if GraphicsContext has already been disposed

     * @throws java.lang.NullPointerException if given target is null

     * @throws java.lang.IllegalArgumentException if given target cannot be bound

     * @throws java.lang.IllegalArgumentException if given target is already disposed

     */

    public void bindTarget(org.eclipse.swt.widgets.Display target) {

        if(target == null) {

        }

        if(target.isDisposed())

            throw new IllegalArgumentException("Target already disposed");

        int handle = org.eclipse.swt.internal.qt.OS.QApplication_desktop();

        bindTarget(target, TARGET_WIDGET, handle, 0);

    }

    /**

     * Binds given org.eclipse.swt.internal.qt.graphics.Image as the rendering target of this GraphicsContext.

     *

     * @param target The image

     *

     * @throws java.lang.IllegalStateException if this GraphicsContext already has a rendering target

     * @throws java.lang.IllegalStateException if given target is already bound by some other GC instance

     * @throws java.lang.IllegalStateException if GraphicsContext has already been disposed

     * @throws java.lang.NullPointerException if given target is null

     * @throws java.lang.IllegalArgumentException if given target cannot be bound

     * @throws java.lang.IllegalArgumentException if given target is already disposed

     */

    public void bindTarget(org.eclipse.swt.internal.qt.graphics.Image target) {

        if(target == null) {

        }

        if(target.isDisposed())

            throw new IllegalArgumentException("Target already disposed");

        bindTarget(target, TARGET_IMAGE, target.handle, 0);

    }

    /**

     * Binds given org.eclipse.swt.internal.qt.graphics.Buffer as the rendering target of this GraphicsContext.

     *

     * @param target The buffer

     * @param flushTargetHandle The actual target where the buffer will be flushed to

     *

     * @throws java.lang.IllegalStateException if this GraphicsContext already has a rendering target

     * @throws java.lang.IllegalStateException if given target is already bound by some other GC instance

     * @throws java.lang.IllegalStateException if CraphicsContext has already been disposed

     * @throws java.lang.NullPointerException if given target is null

     * @throws java.lang.NullPointerException if given flushTarget is null

     * @throws java.lang.IllegalArgumentException if given target cannot be bound

     * @throws java.lang.IllegalArgumentException if given target is already disposed

     */

    public void bindTarget(org.eclipse.swt.internal.qt.graphics.NativeCommandBuffer target, org.eclipse.swt.widgets.Control flushTarget) {

        if(target == null) {

        }

        if(flushTarget == null) {

        }

        if(target.isDisposed())

            throw new IllegalArgumentException("Target already disposed");

        if(flushTarget.isDisposed())

            throw new IllegalArgumentException("Buffer flush target already disposed");

        bindTarget(target, TARGET_NATIVE_COMMAND_BUFFER, target.handle, handle(flushTarget));

    }

    /**

     * Binds given org.eclipse.swt.internal.qt.graphics.CommandBuffer as the rendering target of this GraphicsContext.

     * When JavaCommandBuffer is set as rendering target only one way methods, i.e. draw and setters are supported.

     * See JavaCommanduffer implementation for details of what operations are supported.

     *

     * @param target The buffer where commands are recorded

     * @throws java.lang.IllegalStateException if this GraphicsContext already has a rendering target

     * @throws java.lang.IllegalStateException if given target is already bound by some other GC instance

     * @throws java.lang.IllegalStateException if CraphicsContext has already been disposed

     * @throws java.lang.NullPointerException if given target is null

     */

    public void bindTarget(org.eclipse.swt.internal.qt.graphics.JavaCommandBuffer target) {

        if(target == null)

          throw new NullPointerException("target is null");

        bindTarget(target, TARGET_JAVA_COMMAND_BUFFER, 0, 0);

    }

    /**

     * Don't use. This is here only for testing purposes. 

     * @deprecated Buffer flush target must be given be given when binding to a buffer. 

     * @see bindTarget(org.eclipse.swt.internal.qt.graphics.Buffer target, org.eclipse.swt.widgets.Control flushTarget)

     */

    public void bindTarget(org.eclipse.swt.internal.qt.graphics.NativeCommandBuffer target) {

        if(target == null) {

        }

        if(target.isDisposed()) {

            throw new IllegalArgumentException("target already disposed");

        }

        bindTarget(target, TARGET_NATIVE_COMMAND_BUFFER, target.handle, 0);

    }

    /**

     * Binds given org.eclipse.swt.internal.qt.graphics.WindowSurface as the rendering target of this GraphicsContext.

     *

     * @param target The WindowSurface instance to be bound

     * @throws java.lang.IllegalStateException if this GraphicsContext already has a rendering target

     * @throws java.lang.IllegalStateException if given target is already bound by some other GC instance

     * @throws java.lang.IllegalStateException if CraphicsContext has already been disposed

     * @throws java.lang.NullPointerException if given target is null

     * @throws java.lang.IllegalArgumentException if given target is already disposed

     */

    public void bindTarget(org.eclipse.swt.internal.qt.graphics.WindowSurface target) {

        if(target == null) {

        }

            throw new IllegalArgumentException("target already disposed");

        }

    }

    /**

     * Get target to which current GraphicsContext is bound to

     *

     * @return Object to which GraphicsContext is bound to or null if there is no target

     */

    public Object getBoundTarget() {

        checkState();

        return targetData.target;

    }

    /**

     * Flushes all pending draw operations and releases current rending target.

     * If no target is bound, request is silently ingored.

     */

    public void releaseTarget() {

        Utils.validateUiThread();

        if (disposed) {

            throw new IllegalStateException("GraphicsContext already disposed");

        }

        if (targetData.target != null) {

            // In case of java command buffer no native calls needed

            if (targetData.type == TARGET_JAVA_COMMAND_BUFFER) {

                targetData.commandBuffer.release();

                targetData.reset();

                return;

            }

            // call native release

            OS.graphicsContext_releaseTarget(handle);

            // if target is Image notify about release

            if(targetData.type == TARGET_IMAGE) {

                ((org.eclipse.swt.internal.qt.graphics.Image)targetData.target).notifyRelease();

            }

            // reset target data

            targetData.reset();

        } else {

            //ignore, i.e. no need to throw an exception

        }

    }

    /**

     * Checks if target is already bound by some other gc instance and does

     * native bind operation.

     *

     * @param gc The GraphicsContext doing the binding

     * @throws IllegalStateException if target is found in the list before adding it,

     * i.e. it is already being painted by some other gc.

     */

    private void doBind(int targetHandle, int targetType, java.lang.Object target, int bufferFlushTargetHandle) {

        // call native bind. In case this fails the native peer throws an exception

        // and resets state automatically, i.e. there no need to rewind from here

        OS.graphicsContext_bindTarget(handle, targetHandle, targetType, bufferFlushTargetHandle);