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

 * Copyright (c) 2000, 2007 IBM Corporation and others.

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

 *     IBM Corporation - initial API and implementation

 *     Nokia Corporation - Qt implementation

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

package org.eclipse.swt.graphics;

import org.eclipse.swt.SWT;

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

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

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

import org.eclipse.swt.widgets.Control;

import org.eclipse.swt.widgets.Display;

/**

 * Class <code>GC</code> is where all of the drawing capabilities that are

 * supported by SWT are located. Instances are used to draw on either an

 * <code>Image</code>, a <code>Control</code>, or directly on a

 * <code>Display</code>.

 * <dl>

 * <dt><b>Styles:</b></dt>

 * <dd>LEFT_TO_RIGHT, RIGHT_TO_LEFT</dd>

 * </dl>

 * 

 * <p>

 * The SWT drawing coordinate system is the two-dimensional space with the

 * origin (0,0) at the top left corner of the drawing area and with (x,y) values

 * increasing to the right and downward respectively.

 * </p>

 * 

 * <p>

 * Application code must explicitly invoke the <code>GC.dispose()</code> method

 * to release the operating system resources managed by each instance when those

 * instances are no longer required. This is <em>particularly</em> important on

 * Windows95 and Windows98 where the operating system has a limited number of

 * device contexts available.

 * </p>

 * 

 * <p>

 * Note: Only one of LEFT_TO_RIGHT and RIGHT_TO_LEFT may be specified.

 * </p>

 * 

 * @see org.eclipse.swt.events.PaintEvent

 */

public final class GC {

// FontMetrics

private final static int FM_ASCENT = 0;

private final static int FM_AVERAGE_CHAR_WIDTH = 1;

private final static int FM_DESCENT = 2;

private final static int FM_HEIGHT = 3;

private final static int FM_LEADING = 4;

private final static int FM_DATA_COUNT = 5;

// Configuration flags

final static int FOREGROUND = 1 << 0;

final static int BACKGROUND = 1 << 1;

final static int FONT = 1 << 2;

final static int LINE_STYLE = 1 << 3;

final static int LINE_CAP = 1 << 4;

final static int LINE_JOIN = 1 << 5;

final static int LINE_WIDTH = 1 << 6;

final static int LINE_MITERLIMIT = 1 << 7;

final static int BACKGROUND_BG = 1 << 8;

final static int DRAW_OFFSET = 1 << 9;

final static int DRAW = FOREGROUND | LINE_WIDTH | LINE_STYLE | LINE_CAP

        | LINE_JOIN | LINE_MITERLIMIT | DRAW_OFFSET;

final static int FILL = BACKGROUND;

static int checkStyle(int style) {

    if ((style & SWT.LEFT_TO_RIGHT) != 0) {

        style &= ~SWT.RIGHT_TO_LEFT;

    }

    return style & (SWT.LEFT_TO_RIGHT | SWT.RIGHT_TO_LEFT);

}

int handle;

GCData data;

Color customForeground;

Color customBackground;

Drawable drawable;

/**

 * Prevents uninitialized instances from being created outside the package.

 */

GC() {

}

/**

 * Constructs a new instance of this class which has been configured to draw on

 * the specified drawable. Sets the foreground color, background color and font

 * in the GC to match those in the drawable.

 * <p>

 * You must dispose the graphics context when it is no longer required.

 * </p>

 * 

 * @param drawable

 *            the drawable to draw on

 * @exception IllegalArgumentException

 *                <ul>

 *                <li>ERROR_NULL_ARGUMENT - if the drawable is null</li>

 *                <li>ERROR_NULL_ARGUMENT - if there is no current device</li>

 *                <li>ERROR_INVALID_ARGUMENT - if the drawable is an image that

 *                is not a bitmap or an icon - if the drawable is an image or

 *                printer that is already selected into another graphics context

 *                </li>

 *                </ul>

 * @exception SWTError

 *                <ul>

 *                <li>ERROR_NO_HANDLES if a handle could not be obtained for GC

 *                creation</li>

 *                <li>ERROR_THREAD_INVALID_ACCESS if not called from the thread

 *                that created the drawable</li>

 *                </ul>

 */

public GC(Drawable drawable) {

    this(drawable, 0);

}

/**

 * Constructs a new instance of this class which has been configured to draw on

 * the specified drawable. Sets the foreground color, background color and font

 * in the GC to match those in the drawable.

 * <p>

 * You must dispose the graphics context when it is no longer required.

 * </p>

 * 

 * @param drawable

 *            the drawable to draw on

 * @param style

 *            the style of GC to construct

 * 

 * @exception IllegalArgumentException

 *                <ul>

 *                <li>ERROR_NULL_ARGUMENT - if the drawable is null</li>

 *                <li>ERROR_NULL_ARGUMENT - if there is no current device</li>

 *                <li>ERROR_INVALID_ARGUMENT - if the drawable is an image that

 *                is not a bitmap or an icon - if the drawable is an image or

 *                printer that is already selected into another graphics context

 *                </li>

 *                </ul>

 * @exception SWTError

 *                <ul>

 *                <li>ERROR_NO_HANDLES if a handle could not be obtained for GC

 *                creation</li>

 *                <li>ERROR_THREAD_INVALID_ACCESS if not called from the thread

 *                that created the drawable</li>

 *                </ul>

 * 

 */

public GC(Drawable drawable, int style) {

    if (drawable == null) {

        SWT.error(SWT.ERROR_NULL_ARGUMENT);

    }

    GCData data = new GCData();

    data.style = checkStyle(style);

    int gcHandle = drawable.internal_new_GC(data);

    try {

        init(drawable, data, gcHandle);

    } catch (Error e) {

        drawable.internal_dispose_GC(data);

        throw e;

    }

}

/*

 * Here it's checked based on the data.state flags which gc attributes need to

 * be configured. State flags are set when configuration is up-to-date and

 * cleared when configuration is invalidated.

 */

void checkGC(int mask) {

    int state = data.state;

    if ((state & mask) == mask)

        return;

    state = (state ^ mask) & mask; // take out bits not in mask

    data.state |= mask;

    if((data.state & FOREGROUND) != 0) {

        if ((data.style & SWT.MIRRORED) != 0) {

            int width = OS.QPaintDevice_width(data.drawable);

            data.internalGc.resetTransform();

            data.internalGc.translate(width - 1, 0);

            data.internalGc.scale(-1, 1);

        }

    }

}

/**

 * Copies a rectangular area of the receiver at the specified position into the

 * image, which must be of type <code>SWT.BITMAP</code>.

 * 

 * @param image

 *            the image to copy into

 * @param x

 *            the x coordinate in the receiver of the area to be copied

 * @param y

 *            the y coordinate in the receiver of the area to be copied

 * 

 * @exception IllegalArgumentException

 *                <ul>

 *                <li>ERROR_NULL_ARGUMENT - if the image is null</li>

 *                <li>ERROR_INVALID_ARGUMENT - if the image is not a bitmap or

 *                has been disposed</li>

 *                </ul>

 * @exception SWTException

 *                <ul>

 *                <li>ERROR_GRAPHIC_DISPOSED - if the receiver has been disposed

 *                </li>

 *                </ul>

 */

public void copyArea(Image image, int x, int y) {

    if (handle == 0) {

        SWT.error(SWT.ERROR_GRAPHIC_DISPOSED);

    }

    if (image == null) {

        SWT.error(SWT.ERROR_NULL_ARGUMENT);

    }

    if (image.type != SWT.BITMAP || image.isDisposed()) {

        SWT.error(SWT.ERROR_INVALID_ARGUMENT);

    }

    // Reset all mirroring transformation and calculate the mirrored coordinates

    // manually.

    if ((data.style & SWT.MIRRORED) != 0) {

        data.internalGc.resetTransform();

        data.state = ~FOREGROUND;

        int clientWidth = OS.QPaintDevice_width(data.drawable);

        x = clientWidth - x - image.getBounds().width;

    }

    data.internalGc.copyArea(image.getImage(), x, y);

}

/**

 * Copies a rectangular area of the receiver at the source position onto the

 * receiver at the destination position.

 * 

 * @param srcX

 *            the x coordinate in the receiver of the area to be copied

 * @param srcY

 *            the y coordinate in the receiver of the area to be copied

 * @param width

 *            the width of the area to copy

 * @param height

 *            the height of the area to copy

 * @param destX

 *            the x coordinate in the receiver of the area to copy to

 * @param destY

 *            the y coordinate in the receiver of the area to copy to

 * 

 * @exception SWTException

 *                <ul>

 *                <li>ERROR_GRAPHIC_DISPOSED - if the receiver has been disposed

 *                </li>

 *                </ul>

 */

public void copyArea(int srcX, int srcY, int width, int height, int destX,

        int destY) {

    copyArea(srcX, srcY, width, height, destX, destY, true);

}

/**

 * Copies a rectangular area of the receiver at the source

 * position onto the receiver at the destination position.

 *

 * @param srcX the x coordinate in the receiver of the area to be copied

 * @param srcY the y coordinate in the receiver of the area to be copied

 * @param width the width of the area to copy

 * @param height the height of the area to copy

 * @param destX the x coordinate in the receiver of the area to copy to

 * @param destY the y coordinate in the receiver of the area to copy to

 * @param paint if <code>true</code> paint events will be generated for old and obscured areas

 *

 * @exception SWTException <ul>

 *    <li>ERROR_GRAPHIC_DISPOSED - if the receiver has been disposed</li>

 * </ul>

 * 

 * @since 3.1 

 */

public void copyArea(int srcX, int srcY, int width, int height, int destX, int destY, boolean paint) {

    if (handle == 0) {

        SWT.error(SWT.ERROR_GRAPHIC_DISPOSED);

    }

    if (width <= 0 || height <= 0) {

        return;

    }

    int deltaX = destX - srcX;

    int deltaY = destY - srcY;

    if (deltaX == 0 && deltaY == 0) {

        return;

    }

    // Reset all mirroring transformation and calculate the mirrored coordinates

    // manually.

    if ((data.style & SWT.MIRRORED) != 0) {

        data.internalGc.resetTransform();

        data.state = ~FOREGROUND;

        int clientWidth = OS.QPaintDevice_width(data.drawable);

        srcX = clientWidth - srcX - width;

        destX = clientWidth - destX - width;

    }

    data.internalGc.copyArea(srcX, srcY, width, height, destX, destY, paint);

}

/**

 * Disposes of the operating system resources associated with the graphics

 * context. Applications must dispose of all the GCs which they allocate.

 * 

 * @exception SWTError

 *                <ul>

 *                <li>ERROR_THREAD_INVALID_ACCESS if not called from the thread

 *                that created the drawable</li>

 */

public void dispose() {

	final Display display = (Display)data.device; 

	if(display.getThread() != Thread.currentThread()) {

		SWT.error(SWT.ERROR_THREAD_INVALID_ACCESS);

	}

    if (drawable != null && handle != 0) {

        if (data.buffered && (drawable instanceof Control)) {

            display.syncExec(new Runnable() {

                public void run() {

                    ((Control) drawable).redraw();

                    while (display.readAndDispatch())

                        ;

                }

            });

        }

        drawable.internal_dispose_GC(data);

    }

    data.destroy();

    handle = SWT.NULL;

    customForeground = null;

    customBackground = null;

    drawable = null;

}

/**

 * Draws the outline of a circular or elliptical arc within the specified

 * rectangular area.

 * <p>

 * The resulting arc begins at <code>startAngle</code> and extends for <code>

 * arcAngle</code> degrees, using the current color. Angles are interpreted such

 * that 0 degrees is at the 3 o'clock position. A positive value indicates a

 * counter-clockwise rotation while a negative value indicates a clockwise

 * rotation.

 * </p>

 * <p>

 * The center of the arc is the center of the rectangle whose origin is (<code>x

 * </code>, <code>y</code>) and whose size is specified by the <code>width

 * </code> and <code>height</code> arguments.

 * </p>

 * <p>

 * The resulting arc covers an area <code>width + 1</code> pixels wide by <code>

 * height + 1</code> pixels tall.

 * </p>

 * 

 * @param x

 *            the x coordinate of the upper-left corner of the arc to be drawn

 * @param y

 *            the y coordinate of the upper-left corner of the arc to be drawn

 * @param width

 *            the width of the arc to be drawn

 * @param height

 *            the height of the arc to be drawn

 * @param startAngle

 *            the beginning angle

 * @param arcAngle

 *            the angular extent of the arc, relative to the start angle

 * 

 * @exception SWTException

 *                <ul>

 *                <li>ERROR_GRAPHIC_DISPOSED - if the receiver has been disposed

 *                </li>

 *                </ul>

 */

public void drawArc(int x, int y, int width, int height, int startAngle,

        int arcAngle) {

    if (handle == 0) {

        SWT.error(SWT.ERROR_GRAPHIC_DISPOSED);

    }

    if (width < 0) {

        x = x + width;

        width = -width;

    }

    if (height < 0) {

        y = y + height;

        height = -height;

    }

    if (width == 0 || height == 0 || arcAngle == 0) {

        return;

    }

    checkGC(FOREGROUND);

    data.internalGc.drawArc(x, y, width, height, startAngle, arcAngle);

}

/**

 * Draws a rectangle, based on the specified arguments, which has the appearance

 * of the platform's <em>focus rectangle</em> if the platform supports such a

 * notion, and otherwise draws a simple rectangle in the receiver's foreground

 * color.

 * 

 * @param x

 *            the x coordinate of the rectangle

 * @param y

 *            the y coordinate of the rectangle

 * @param width

 *            the width of the rectangle

 * @param height

 *            the height of the rectangle

 * 

 * @exception SWTException

 *                <ul>

 *                <li>ERROR_GRAPHIC_DISPOSED - if the receiver has been disposed

 *                </li>

 *                </ul>

 * 

 * @see #drawRectangle(int, int, int, int)

 */

public void drawFocus(int x, int y, int width, int height) {

    if (handle == 0) {

        SWT.error(SWT.ERROR_GRAPHIC_DISPOSED);

    }

    checkGC(FOREGROUND);

    data.internalGc.drawFocus(x, y, width, height);

}

/**

 * Draws the given image in the receiver at the specified coordinates.

 * 

 * @param image

 *            the image to draw

 * @param x

 *            the x coordinate of where to draw

 * @param y

 *            the y coordinate of where to draw

 * 

 * @exception IllegalArgumentException

 *                <ul>

 *                <li>ERROR_NULL_ARGUMENT - if the image is null</li>

 *                <li>ERROR_INVALID_ARGUMENT - if the image has been disposed</li>

 *                <li>ERROR_INVALID_ARGUMENT - if the given coordinates are

 *                outside the bounds of the image</li>

 * @exception SWTException

 *                <ul>

 *                <li>ERROR_GRAPHIC_DISPOSED - if the receiver has been disposed

 *                </li>

 *                </ul>

 * @exception SWTError

 *                <ul>

 *                <li>ERROR_NO_HANDLES - if no handles are available to perform

 *                the operation</li>

 *                </ul>

 */

public void drawImage(Image image, int x, int y) {

    if (handle == 0) {

        SWT.error(SWT.ERROR_GRAPHIC_DISPOSED);

    }

    if (image == null) {

        SWT.error(SWT.ERROR_NULL_ARGUMENT);

    }

    if (image.isDisposed()) {

        SWT.error(SWT.ERROR_INVALID_ARGUMENT);

    }

    // Reset all mirroring transformation and calculate the mirrored coordinates

    // manually.

    if ((data.style & SWT.MIRRORED) != 0) {

        data.internalGc.resetTransform();

        data.state = ~FOREGROUND;

        int clientWidth = OS.QPaintDevice_width(data.drawable);

        x = clientWidth - x - image.getBounds().width;

    }

    data.internalGc.drawImage(image.getImage(), x, y);

}

/**

 * Copies a rectangular area from the source image into a (potentially different

 * sized) rectangular area in the receiver. If the source and destination areas

 * are of differing sizes, then the source area will be stretched or shrunk to

 * fit the destination area as it is copied. The copy fails if any part of the

 * source rectangle lies outside the bounds of the source image, or if any of

 * the width or height arguments are negative.

 * 

 * @param image

 *            the source image

 * @param srcX

 *            the x coordinate in the source image to copy from

 * @param srcY

 *            the y coordinate in the source image to copy from

 * @param srcWidth

 *            the width in pixels to copy from the source

 * @param srcHeight

 *            the height in pixels to copy from the source

 * @param destX

 *            the x coordinate in the destination to copy to

 * @param destY

 *            the y coordinate in the destination to copy to

 * @param destWidth

 *            the width in pixels of the destination rectangle

 * @param destHeight

 *            the height in pixels of the destination rectangle

 * 

 * @exception IllegalArgumentException

 *                <ul>

 *                <li>ERROR_NULL_ARGUMENT - if the image is null</li>

 *                <li>ERROR_INVALID_ARGUMENT - if the image has been disposed</li>

 *                <li>ERROR_INVALID_ARGUMENT - if any of the width or height

 *                arguments are negative.

 *                <li>ERROR_INVALID_ARGUMENT - if the source rectangle is not

 *                contained within the bounds of the source image</li>

 *                </ul>

 * @exception SWTException

 *                <ul>

 *                <li>ERROR_GRAPHIC_DISPOSED - if the receiver has been disposed

 *                </li>

 *                </ul>

 * @exception SWTError