root/dwt/graphics/GC.d

/*******************************************************************************
 * Copyright (c) 2000, 2008 IBM Corporation and others.
 * 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
 * Port to the D programming language:
 *     Frank Benoit <benoit@tionex.de>
 *******************************************************************************/
module dwt.graphics.GC;

import dwt.DWT;
import dwt.DWTError;
import dwt.DWTException;
import dwt.internal.Compatibility;
import dwt.internal.gdip.Gdip;
import dwt.internal.win32.OS;

import dwt.graphics.Color;
import dwt.graphics.Drawable;
import dwt.graphics.Resource;
import dwt.graphics.Device;
import dwt.graphics.Font;
import dwt.graphics.FontMetrics;
import dwt.graphics.GCData;
import dwt.graphics.Image;
import dwt.graphics.ImageData;
import dwt.graphics.Path;
import dwt.graphics.Pattern;
import dwt.graphics.Point;
import dwt.graphics.RGB;
import dwt.graphics.Rectangle;
import dwt.graphics.Region;
import dwt.graphics.Resource;
import dwt.graphics.Transform;
import dwt.graphics.LineAttributes;

import dwt.dwthelper.utils;
import tango.text.convert.Format;

/**
 * Class <code>GC</code> is where all of the drawing capabilities that are
 * supported by DWT 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 DWT 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 dwt.events.PaintEvent
 * @see <a href="http://www.eclipse.org/swt/snippets/#gc">GC snippets</a>
 * @see <a href="http://www.eclipse.org/swt/examples.php">DWT Examples: GraphicsExample, PaintExample</a>
 * @see <a href="http://www.eclipse.org/swt/">Sample code and further information</a>
 */

public final class GC : Resource {

    alias Resource.init_ init_;

    /**
     * the handle to the OS device context
     * (Warning: This field is platform dependent)
     * <p>
     * <b>IMPORTANT:</b> This field is <em>not</em> part of the DWT
     * public API. It is marked public only so that it can be shared
     * within the packages provided by DWT. It is not available on all
     * platforms and should never be accessed from application code.
     * </p>
     */
    public HDC handle;

    Drawable drawable;
    GCData data;

    static const int FOREGROUND = 1 << 0;
    static const int BACKGROUND = 1 << 1;
    static const int FONT = 1 << 2;
    static const int LINE_STYLE = 1 << 3;
    static const int LINE_WIDTH = 1 << 4;
    static const int LINE_CAP = 1 << 5;
    static const int LINE_JOIN = 1 << 6;
    static const int LINE_MITERLIMIT = 1 << 7;
    static const int FOREGROUND_TEXT = 1 << 8;
    static const int BACKGROUND_TEXT = 1 << 9;
    static const int BRUSH = 1 << 10;
    static const int PEN = 1 << 11;
    static const int NULL_BRUSH = 1 << 12;
    static const int NULL_PEN = 1 << 13;
    static const int DRAW_OFFSET = 1 << 14;

    static const int DRAW = FOREGROUND | LINE_STYLE | LINE_WIDTH | LINE_CAP | LINE_JOIN | LINE_MITERLIMIT | PEN | NULL_BRUSH | DRAW_OFFSET;
    static const int FILL = BACKGROUND | BRUSH | NULL_PEN;

    static const float[] LINE_DOT_ZERO = [3, 3];
    static const float[] LINE_DASH_ZERO = [18, 6];
    static const float[] LINE_DASHDOT_ZERO = [9, 6, 3, 6];
    static const float[] LINE_DASHDOTDOT_ZERO = [9, 3, 3, 3, 3, 3];

/**
 * Prevents uninitialized instances from being created outside the package.
 */
this() {
}

/**
 * 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 DWTError <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 this(Drawable drawable) {
    this(drawable, DWT.NONE);
}

/**
 * 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 DWTError <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>
 *
 * @since 2.1.2
 */
public this(Drawable drawable, int style) {
    if (drawable is null) DWT.error(DWT.ERROR_NULL_ARGUMENT);
    GCData data = new GCData ();
    data.style = checkStyle(style);
    auto hDC = drawable.internal_new_GC(data);
    Device device = data.device;
    if (device is null) device = Device.getDevice();
    if (device is null) DWT.error(DWT.ERROR_NULL_ARGUMENT);
    this.device = data.device = device;
    init_ (drawable, data, hDC);
    init_();
}

static int checkStyle(int style) {
    if ((style & DWT.LEFT_TO_RIGHT) !is 0) style &= ~DWT.RIGHT_TO_LEFT;
    return style & (DWT.LEFT_TO_RIGHT | DWT.RIGHT_TO_LEFT);
}

void checkGC(int mask) {
    int state = data.state;
    if ((state & mask) is mask) return;
    state = (state ^ mask) & mask;
    data.state |= mask;
    auto gdipGraphics = data.gdipGraphics;
    if (gdipGraphics !is null) {
        auto pen = data.gdipPen;
        float width = data.lineWidth;
        if ((state & FOREGROUND) !is 0 || (pen is null && (state & (LINE_WIDTH | LINE_STYLE | LINE_MITERLIMIT | LINE_JOIN | LINE_CAP)) !is 0)) {
            if (data.gdipFgBrush !is null) Gdip.SolidBrush_delete(data.gdipFgBrush);
            data.gdipFgBrush = null;
            Gdip.Brush brush;
            Pattern pattern = data.foregroundPattern;
            if (pattern !is null) {
                brush = pattern.handle;
                if ((data.style & DWT.MIRRORED) !is 0) {
                    switch (Gdip.Brush_GetType(brush)) {
                        case Gdip.BrushTypeTextureFill:
                            brush = Gdip.Brush_Clone(brush);
                            if (brush is null) DWT.error(DWT.ERROR_NO_HANDLES);
                            Gdip.TextureBrush_ScaleTransform( cast(Gdip.TextureBrush) brush, -1, 1, Gdip.MatrixOrderPrepend);
                            data.gdipFgBrush = cast(Gdip.SolidBrush)brush;
                        default:
                    }
                }
            } else {
                auto foreground = data.foreground;
                int rgb = ((foreground >> 16) & 0xFF) | (foreground & 0xFF00) | ((foreground & 0xFF) << 16);
                auto color = Gdip.Color_new(data.alpha << 24 | rgb);
                if (color is 0) DWT.error(DWT.ERROR_NO_HANDLES);
                brush = cast(Gdip.Brush) Gdip.SolidBrush_new(color);
                if (brush is null) DWT.error(DWT.ERROR_NO_HANDLES);
                Gdip.Color_delete(color);
                data.gdipFgBrush = cast(Gdip.SolidBrush)brush;
            }
            if (pen !is null) {
                Gdip.Pen_SetBrush(pen, brush);
            } else {
                pen = data.gdipPen = Gdip.Pen_new(brush, width);
            }
        }
        if ((state & LINE_WIDTH) !is 0) {
            Gdip.Pen_SetWidth(pen, width);
            switch (data.lineStyle) {
                case DWT.LINE_CUSTOM:
                    state |= LINE_STYLE;
                default:
            }
        }
        if ((state & LINE_STYLE) !is 0) {
            float[] dashes = null;
            float dashOffset = 0;
            int dashStyle = Gdip.DashStyleSolid;
            switch (data.lineStyle) {
                case DWT.LINE_SOLID: break;
                case DWT.LINE_DOT: dashStyle = Gdip.DashStyleDot; if (width is 0) dashes = LINE_DOT_ZERO; break;
                case DWT.LINE_DASH: dashStyle = Gdip.DashStyleDash; if (width is 0) dashes = LINE_DASH_ZERO; break;
                case DWT.LINE_DASHDOT: dashStyle = Gdip.DashStyleDashDot; if (width is 0) dashes = LINE_DASHDOT_ZERO; break;
                case DWT.LINE_DASHDOTDOT: dashStyle = Gdip.DashStyleDashDotDot; if (width is 0) dashes = LINE_DASHDOTDOT_ZERO; break;
                case DWT.LINE_CUSTOM: {
                    if (data.lineDashes !is null) {
                        dashOffset = data.lineDashesOffset / Math.max (1, width);
                        dashes = new float[data.lineDashes.length * 2];
                        for (int i = 0; i < data.lineDashes.length; i++) {
                            float dash = data.lineDashes[i] / Math.max (1, width);
                            dashes[i] = dash;
                            dashes[i + data.lineDashes.length] = dash;
                        }
                    }
                }
                default:
            }
            if (dashes !is null) {
                Gdip.Pen_SetDashPattern(pen, dashes.ptr, dashes.length);
                Gdip.Pen_SetDashStyle(pen, Gdip.DashStyleCustom);
                Gdip.Pen_SetDashOffset(pen, dashOffset);
            } else {
                Gdip.Pen_SetDashStyle(pen, dashStyle);
            }
        }
        if ((state & LINE_MITERLIMIT) !is 0) {
            Gdip.Pen_SetMiterLimit(pen, data.lineMiterLimit);
        }
        if ((state & LINE_JOIN) !is 0) {
            int joinStyle = 0;
            switch (data.lineJoin) {
                case DWT.JOIN_MITER: joinStyle = Gdip.LineJoinMiter; break;
                case DWT.JOIN_BEVEL: joinStyle = Gdip.LineJoinBevel; break;
                case DWT.JOIN_ROUND: joinStyle = Gdip.LineJoinRound; break;
                default:
            }
            Gdip.Pen_SetLineJoin(pen, joinStyle);
        }
        if ((state & LINE_CAP) !is 0) {
            int dashCap = Gdip.DashCapFlat, capStyle = 0;
            switch (data.lineCap) {
                case DWT.CAP_FLAT: capStyle = Gdip.LineCapFlat; break;
                case DWT.CAP_ROUND: capStyle = Gdip.LineCapRound; dashCap = Gdip.DashCapRound; break;
                case DWT.CAP_SQUARE: capStyle = Gdip.LineCapSquare; break;
                default:
            }
            Gdip.Pen_SetLineCap(pen, capStyle, capStyle, dashCap);
        }
        if ((state & BACKGROUND) !is 0) {
            if (data.gdipBgBrush !is null) Gdip.SolidBrush_delete(data.gdipBgBrush);
            data.gdipBgBrush = null;
            Pattern pattern = data.backgroundPattern;
            if (pattern !is null) {
                data.gdipBrush = pattern.handle;
                if ((data.style & DWT.MIRRORED) !is 0) {
                    switch (Gdip.Brush_GetType(data.gdipBrush)) {
                        case Gdip.BrushTypeTextureFill:
                            auto brush = Gdip.Brush_Clone(data.gdipBrush);
                            if (brush is null) DWT.error(DWT.ERROR_NO_HANDLES);
                            Gdip.TextureBrush_ScaleTransform( cast(Gdip.TextureBrush)brush, -1, 1, Gdip.MatrixOrderPrepend);
                            data.gdipBrush = brush;
                            data.gdipBgBrush = cast(Gdip.SolidBrush) brush;
                        default:
                    }
                }
            } else {
                auto background = data.background;
                int rgb = ((background >> 16) & 0xFF) | (background & 0xFF00) | ((background & 0xFF) << 16);
                auto color = Gdip.Color_new(data.alpha << 24 | rgb);
                // if (color is null) DWT.error(DWT.ERROR_NO_HANDLES);
                auto brush = Gdip.SolidBrush_new(color);
                if (brush is null) DWT.error(DWT.ERROR_NO_HANDLES);
                Gdip.Color_delete(color);
                data.gdipBrush = cast(Gdip.Brush)brush;
                data.gdipBgBrush = brush;
            }
        }
        if ((state & FONT) !is 0) {
            Font font = data.font;
            OS.SelectObject(handle, font.handle);
            auto gdipFont = createGdipFont(handle, font.handle);
            if (data.gdipFont !is null) Gdip.Font_delete(data.gdipFont);
            data.gdipFont = gdipFont;
        }
        if ((state & DRAW_OFFSET) !is 0) {
            data.gdipXOffset = data.gdipYOffset = 0;
            auto matrix = Gdip.Matrix_new(1, 0, 0, 1, 0, 0);
            float[2] point; point[0]=1.0; point[1]=1.0;
            Gdip.Graphics_GetTransform(gdipGraphics, matrix);
            Gdip.Matrix_TransformPoints(matrix, cast(Gdip.PointF*)point.ptr, 1);
            Gdip.Matrix_delete(matrix);
            float scaling = point[0];
            if (scaling < 0) scaling = -scaling;
            float penWidth = data.lineWidth * scaling;
            if (penWidth is 0 || (cast(int)penWidth % 2) is 1) {
                data.gdipXOffset = 0.5f / scaling;
            }
            scaling = point[1];
            if (scaling < 0) scaling = -scaling;
            penWidth = data.lineWidth * scaling;
            if (penWidth is 0 || (cast(int)penWidth % 2) is 1) {
                data.gdipYOffset = 0.5f / scaling;
            }
        }
        return;
    }
    if ((state & (FOREGROUND | LINE_CAP | LINE_JOIN | LINE_STYLE | LINE_WIDTH)) !is 0) {
        int color = data.foreground;
        int width = cast(int)data.lineWidth;
        uint[] dashes = null;
        int lineStyle = OS.PS_SOLID;
        switch (data.lineStyle) {
            case DWT.LINE_SOLID: break;
            case DWT.LINE_DASH: lineStyle = OS.PS_DASH; break;
            case DWT.LINE_DOT: lineStyle = OS.PS_DOT; break;
            case DWT.LINE_DASHDOT: lineStyle = OS.PS_DASHDOT; break;
            case DWT.LINE_DASHDOTDOT: lineStyle = OS.PS_DASHDOTDOT; break;
            case DWT.LINE_CUSTOM: {
                if (data.lineDashes !is null) {
                    lineStyle = OS.PS_USERSTYLE;
                    dashes = new uint[data.lineDashes.length];
                    for (int i = 0; i < dashes.length; i++) {
                        dashes[i] = cast(int)data.lineDashes[i];
                    }
                }
                break;
            }
            default:
        }
        if ((state & LINE_STYLE) !is 0) {
            OS.SetBkMode(handle, data.lineStyle is DWT.LINE_SOLID ? OS.OPAQUE : OS.TRANSPARENT);
        }
        int joinStyle = 0;
        switch (data.lineJoin) {
            case DWT.JOIN_MITER: joinStyle = OS.PS_JOIN_MITER; break;
            case DWT.JOIN_ROUND: joinStyle = OS.PS_JOIN_ROUND; break;
            case DWT.JOIN_BEVEL: joinStyle = OS.PS_JOIN_BEVEL; break;
            default:
        }
        int capStyle = 0;
        switch (data.lineCap) {
            case DWT.CAP_ROUND: capStyle = OS.PS_ENDCAP_ROUND; break;
            case DWT.CAP_FLAT: capStyle = OS.PS_ENDCAP_FLAT; break;
            case DWT.CAP_SQUARE: capStyle = OS.PS_ENDCAP_SQUARE;break;
            default:
        }
        int style = lineStyle | joinStyle | capStyle;
        /*
        * Feature in Windows.  Windows does not honour line styles other then
        * PS_SOLID for pens wider than 1 pixel created with CreatePen().  The fix
        * is to use ExtCreatePen() instead.
        */
        HPEN newPen;
        if (OS.IsWinCE || (width is 0 && lineStyle !is OS.PS_USERSTYLE) || style is 0) {
            newPen = OS.CreatePen(style & OS.PS_STYLE_MASK, width, color);
        } else {
            LOGBRUSH logBrush;
            logBrush.lbStyle = OS.BS_SOLID;
            logBrush.lbColor = color;
            /* Feature in Windows. PS_GEOMETRIC pens cannot have zero width. */
            newPen = OS.ExtCreatePen (style | OS.PS_GEOMETRIC, Math.max(1, width), &logBrush, dashes !is null ? dashes.length : 0, dashes.ptr);
        }
        OS.SelectObject(handle, newPen);
        data.state |= PEN;
        data.state &= ~NULL_PEN;
        if (data.hPen !is null) OS.DeleteObject(data.hPen);
        data.hPen = data.hOldPen = newPen;
    } else if ((state & PEN) !is 0) {
        OS.SelectObject(handle, data.hOldPen);
        data.state &= ~NULL_PEN;
    } else if ((state & NULL_PEN) !is 0) {
        data.hOldPen = OS.SelectObject(handle, OS.GetStockObject(OS.NULL_PEN));
        data.state &= ~PEN;
    }
    if ((state & BACKGROUND) !is 0) {
        auto newBrush = OS.CreateSolidBrush(data.background);
        OS.SelectObject(handle, newBrush);
        data.state |= BRUSH;
        data.state &= ~NULL_BRUSH;
        if (data.hBrush !is null) OS.DeleteObject(data.hBrush);
        data.hOldBrush = data.hBrush = newBrush;
    } else if ((state & BRUSH) !is 0) {
        OS.SelectObject(handle, data.hOldBrush);
        data.state &= ~NULL_BRUSH;
    } else if ((state & NULL_BRUSH) !is 0) {
        data.hOldBrush = OS.SelectObject(handle, OS.GetStockObject(OS.NULL_BRUSH));
        data.state &= ~BRUSH;
    }
    if ((state & BACKGROUND_TEXT) !is 0) {
        OS.SetBkColor(handle, data.background);
    }
    if ((state & FOREGROUND_TEXT) !is 0) {
        OS.SetTextColor(handle, data.foreground);
    }
    if ((state & FONT) !is 0) {
        Font font = data.font;
        OS.SelectObject(handle, font.handle);
    }
}

/**
 * Copies a rectangular area of the receiver at the specified
 * position into the image, which must be of type <code>DWT.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>