--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/org.eclipse.draw2d/src/org/eclipse/draw2d/Graphics.d	Sat Mar 14 18:23:29 2009 +0100
@@ -0,0 +1,934 @@
+/*******************************************************************************
+ * Copyright (c) 2000, 2005 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 org.eclipse.draw2d.Graphics;
+
+import java.lang.all;
+
+
+
+import org.eclipse.swt.SWT;
+import org.eclipse.swt.graphics.Color;
+import org.eclipse.swt.graphics.Font;
+import org.eclipse.swt.graphics.FontMetrics;
+import org.eclipse.swt.graphics.GC;
+import org.eclipse.swt.graphics.Image;
+import org.eclipse.swt.graphics.Path;
+import org.eclipse.swt.graphics.Pattern;
+import org.eclipse.swt.graphics.TextLayout;
+import org.eclipse.draw2d.geometry.Point;
+import org.eclipse.draw2d.geometry.PointList;
+import org.eclipse.draw2d.geometry.Rectangle;
+
+/**
+ * The Graphics class allows you to draw to a surface.  The drawXxx() methods that pertain
+ * to shapes draw an outline of the shape, whereas the fillXxx() methods fill in the shape.
+ * Also provides for drawing text, lines and images.
+ */
+public abstract class Graphics {
+
+/**
+ * @see SWT#LINE_CUSTOM
+ */
+public static final int LINE_CUSTOM = SWT.LINE_CUSTOM;
+
+/**
+ * @see SWT#LINE_DASH
+ */
+public static final int LINE_DASH = SWT.LINE_DASH;
+
+/**
+ * @see SWT#LINE_DASHDOT
+ */
+public static final int LINE_DASHDOT = SWT.LINE_DASHDOT;
+
+/**
+ * @see SWT#LINE_DASHDOTDOT
+ */
+public static final int LINE_DASHDOTDOT = SWT.LINE_DASHDOTDOT;
+
+/**
+ * @see SWT#LINE_DOT
+ */
+public static final int LINE_DOT = SWT.LINE_DOT;
+
+/**
+ * @see SWT#LINE_SOLID
+ */
+public static final int LINE_SOLID = SWT.LINE_SOLID;
+
+/**
+ * Sets the clip region to the given rectangle.  Anything outside this rectangle will not
+ * be drawn.
+ * @param r the clip rectangle
+ */
+public abstract void clipRect(Rectangle r);
+
+/**
+ * Disposes this object, releasing any resources.
+ */
+public abstract void dispose();
+
+/**
+ * Draws the outline of an arc located at (x,y) with width <i>w</i> and height <i>h</i>.
+ * The starting angle of the arc (specified in degrees) is <i>offset</i> and <i>length</i>
+ * is the arc's angle (specified in degrees).
+ *
+ * @param x the x coordinate
+ * @param y the y coordinate
+ * @param w the width
+ * @param h the height
+ * @param offset the start angle
+ * @param length the length of the arc
+ */
+public abstract void drawArc(int x, int y, int w, int h, int offset, int length);
+
+/**
+ * @see #drawArc(int, int, int, int, int, int)
+ */
+public final void drawArc(Rectangle r, int offset, int length) {
+    drawArc(r.x, r.y, r.width, r.height, offset, length);
+}
+
+/**
+ * Draws a focus rectangle.
+ *
+ * @param x the x coordinate
+ * @param y the y coordinate
+ * @param w the width
+ * @param h the height
+ */
+public abstract void drawFocus(int x, int y, int w, int h);
+
+/**
+ * @see #drawFocus(int, int, int, int)
+ */
+public final void drawFocus(Rectangle r) {
+    drawFocus(r.x, r.y, r.width, r.height);
+}
+
+/**
+ * Draws the given Image at the location (x,y).
+ * @param srcImage the Image
+ * @param x the x coordinate
+ * @param y the y coordinate
+ */
+public abstract void drawImage(Image srcImage, int x, int y);
+
+/**
+ * Draws a rectangular section of the given Image to the specified rectangular reagion on
+ * the canvas.  The section of the image bounded by the rectangle (x1,y1,w1,h1) is copied
+ * to the section of the canvas bounded by the rectangle (x2,y2,w2,h2).  If these two
+ * sizes are different, scaling will occur.
+ *
+ * @param srcImage the image
+ * @param x1 the x coordinate of the source
+ * @param y1 the y coordinate of the source
+ * @param w1 the width of the source
+ * @param h1 the height of the source
+ * @param x2 the x coordinate of the destination
+ * @param y2 the y coordinate of the destination
+ * @param w2 the width of the destination
+ * @param h2 the height of the destination
+ */
+public abstract void drawImage(Image srcImage, int x1, int y1, int w1, int h1,
+                                                    int x2, int y2, int w2, int h2);
+
+/**
+ * Draws the given image at a point.
+ * @param image the image to draw
+ * @param p where to draw the image
+ * @see #drawImage(Image, int, int)
+ */
+public final void drawImage(Image image, Point p) {
+    drawImage(image, p.x, p.y);
+}
+
+/**
+ * @see #drawImage(Image, int, int, int, int, int, int, int, int)
+ */
+public final void drawImage(Image srcImage, Rectangle src, Rectangle dest) {
+    drawImage(srcImage, src.x, src.y, src.width, src.height,
+                        dest.x, dest.y, dest.width, dest.height);
+}
+
+/**
+ * Draws a line between the points <code>(x1,y1)</code> and <code>(x2,y2)</code> using the
+ * foreground color.
+ * @param x1 the x coordinate for the first point
+ * @param y1 the y coordinate for the first point
+ * @param x2 the x coordinate for the second point
+ * @param y2 the y coordinate for the second point
+ */
+public abstract void drawLine(int x1, int y1, int x2, int y2);
+
+/**
+ * @see #drawLine(int, int, int, int)
+ */
+public final void drawLine(Point p1, Point p2) {
+    drawLine(p1.x, p1.y, p2.x, p2.y);
+}
+
+/**
+ * Draws the outline of an ellipse that fits inside the rectangle with the given
+ * properties using the foreground color.
+ *
+ * @param x the x coordinate
+ * @param y the y coordinate
+ * @param w the width
+ * @param h the height
+ */
+public abstract void drawOval(int x, int y, int w, int h);
+
+/**
+ * Draws an oval inside the given rectangle using the current foreground color.
+ * @param r the rectangle circumscribing the oval to be drawn
+ * @see #drawOval(int, int, int, int)
+ */
+public final void drawOval(Rectangle r) {
+    drawOval(r.x, r.y, r.width, r.height);
+}
+
+/**
+ * Draws the given path.
+ * @param path the path to draw
+ * @since 3.1
+ */
+public void drawPath(Path path) {
+    subclassFunctionMission();
+}
+
+/**
+ * Draws a pixel, using the foreground color, at the specified point (<code>x</code>,
+ * <code>y</code>).
+ * <p>
+ * Note that the current line attributes do not affect this
+ * operation.
+ * </p>
+ *
+ * @param x the point's x coordinate
+ * @param y the point's y coordinate
+ *
+ */
+public void drawPoint(int x, int y) {
+    drawLine(x, y, x, y);
+}
+
+/**
+ * Draws a closed polygon defined by the given Integer array containing the vertices in
+ * x,y order.  The first and last points in the list will be connected.
+ * @param points the vertices
+ */
+public void drawPolygon(int[] points) {
+    drawPolygon(getPointList(points));
+}
+
+/**
+ * Draws a closed polygon defined by the given <code>PointList</code> containing the
+ * vertices.  The first and last points in the list will be connected.
+ * @param points the vertices
+ */
+public abstract void drawPolygon(PointList points);
+
+/**
+ * Draws a polyline defined by the given Integer array containing the vertices in x,y
+ * order. The first and last points in the list will <b>not</b> be connected.
+ * @param points the vertices
+ */
+public void drawPolyline(int[] points) {
+    drawPolyline(getPointList(points));
+}
+
+/**
+ * Draws a polyline defined by the given <code>PointList</code> containing the vertices.
+ * The first and last points in the list will <b>not</b> be connected.
+ * @param points the vertices
+ */
+public abstract void drawPolyline(PointList points);
+
+/**
+ * Draws a rectangle whose top-left corner is located at the point (x,y) with the given
+ * width and height.
+ *
+ * @param x the x coordinate
+ * @param y the y coordinate
+ * @param width the width
+ * @param height the height
+ */
+public abstract void drawRectangle(int x, int y, int width, int height);
+
+/**
+ * Draws the given rectangle using the current foreground color.
+ * @param r the rectangle to draw
+ * @see #drawRectangle(int, int, int, int)
+ */
+public final void drawRectangle(Rectangle r) {
+    drawRectangle(r.x, r.y, r.width, r.height);
+}
+
+/**
+ * Draws a rectangle with rounded corners using the foreground color.  <i>arcWidth</i> and
+ * <i>arcHeight</i> represent the horizontal and vertical diameter of the corners.
+ *
+ * @param r the rectangle
+ * @param arcWidth the arc width
+ * @param arcHeight the arc height
+ */
+public abstract void drawRoundRectangle(Rectangle r, int arcWidth, int arcHeight);
+
+/**
+ * Draws the given string using the current font and foreground color. No tab expansion or
+ * carriage return processing will be performed. The background of the string will be
+ * transparent.
+ *
+ * @param s the string
+ * @param x the x coordinate
+ * @param y the y coordinate
+ */
+public abstract void drawString(String s, int x, int y);
+
+/**
+ * @see #drawString(String, int, int)
+ */
+public final void drawString(String s, Point p) {
+    drawString(s, p.x, p.y);
+}
+
+
+/**
+ * Draws the given string using the current font and foreground color. Tab expansion and
+ * carriage return processing are performed. The background of the text will be
+ * transparent.
+ *
+ * @param s the text
+ * @param x the x coordinate
+ * @param y the y coordinate
+ */
+public abstract void drawText(String s, int x, int y);
+
+/**
+ * Draws a string using the specified styles. The styles are defined by {@link
+ * GC#drawText(String, int, int, int)}.
+ * @param s the String to draw
+ * @param x the x location
+ * @param y the y location
+ * @param style the styles used to render the string
+ * @since 3.0
+ */
+public void drawText(String s, int x, int y, int style) {
+    subclassFunctionMission();
+}
+
+/**
+ * @see #drawText(String, int, int)
+ */
+public final void drawText(String s, Point p) {
+    drawText(s, p.x, p.y);
+}
+
+/**
+ * Draws a string using the specified styles. The styles are defined by {@link
+ * GC#drawText(String, int, int, int)}.
+ * @param s the String to draw
+ * @param p the point at which to draw the string
+ * @param style the styles used to render the string
+ * @since 3.0
+ */
+public final void drawText(String s, Point p, int style) {
+    drawText(s, p.x, p.y, style);
+}
+
+/**
+ * Renders the specified TextLayout to this Graphics.
+ * @since 3.0
+ * @param layout the TextLayout
+ * @param x the x coordinate
+ * @param y the y coordinate
+ */
+public final void drawTextLayout(TextLayout layout, int x, int y) {
+    drawTextLayout(layout, x, y, -1, -1, null, null);
+}
+
+/**
+ * @param x the x location
+ * @param y the y location
+ * @param layout the TextLayout being rendered
+ * @param selectionStart the start of selection
+ * @param selectionEnd the end of selection
+ * @param selectionForeground the foreground selection color
+ * @param selectionBackground the background selection color
+ * @see Graphics#drawTextLayout(TextLayout, int, int)
+ */
+public void drawTextLayout(TextLayout layout, int x, int y, int selectionStart,
+        int selectionEnd, Color selectionForeground, Color selectionBackground) {
+    subclassFunctionMission();
+}
+
+/**
+ * Fills the interior of an arc located at (<i>x</i>,<i>y</i>) with width <i>w</i> and
+ * height <i>h</i>. The starting angle of the arc (specified in degrees) is <i>offset</i>
+ * and <i>length</i> is the arc's angle (specified in degrees).
+ *
+ * @param x the x coordinate
+ * @param y the y coordinate
+ * @param w the width
+ * @param h the height
+ * @param offset the start angle
+ * @param length the length of the arc
+ */
+public abstract void fillArc(int x, int y, int w, int h, int offset, int length);
+
+/**
+ * @see #fillArc(int, int, int, int, int, int)
+ */
+public final void fillArc(Rectangle r, int offset, int length) {
+    fillArc(r.x, r.y, r.width, r.height, offset, length);
+}
+
+/**
+ * Fills the the given rectangle with a gradient from the foreground color to the
+ * background color. If <i>vertical</i> is <code>true</code>, the gradient will go from
+ * top to bottom.  Otherwise, it will go from left to right.
+ * background color.
+ *
+ * @param x the x coordinate
+ * @param y the y coordinate
+ * @param w the width
+ * @param h the height
+ * @param vertical whether the gradient should be vertical
+ */
+public abstract void fillGradient(int x, int y, int w, int h, bool vertical);
+
+/**
+ * @see #fillGradient(int, int, int, int, bool)
+ */
+public final void fillGradient(Rectangle r, bool vertical) {
+    fillGradient(r.x, r.y, r.width, r.height, vertical);
+}
+
+/**
+ * Fills an ellipse that fits inside the rectangle with the given properties using the
+ * background color.
+ *
+ * @param x the x coordinate
+ * @param y the y coordinate
+ * @param w the width
+ * @param h the height
+ */
+public abstract void fillOval(int x, int y, int w, int h);
+
+/**
+ * @see #fillOval(int, int, int, int)
+ */
+public final void fillOval(Rectangle r) {
+    fillOval(r.x, r.y, r.width, r.height);
+}
+
+/**
+ * Fills the given path.
+ * @param path the path to fill
+ * @since 3.1
+ */
+public void fillPath(Path path) {
+    subclassFunctionMission();
+}
+
+/**
+ * Fills a closed polygon defined by the given Integer array containing the
+ * vertices in x,y order.  The first and last points in the list will be connected.
+ * @param points the vertices
+ */
+public void fillPolygon(int[] points) {
+    fillPolygon(getPointList(points));
+}
+
+/**
+ * Fills a closed polygon defined by the given <code>PointList</code> containing the
+ * vertices.  The first and last points in the list will be connected.
+ * @param points the vertices
+ */
+public abstract void fillPolygon(PointList points);
+
+/**
+ * Fills a rectangle whose top-left corner is located at the point (x,y) with the given
+ * width and height.
+ *
+ * @param x the x coordinate
+ * @param y the y coordinate
+ * @param width the width
+ * @param height the height
+ */
+public abstract void fillRectangle(int x, int y, int width, int height);
+
+/**
+ * Fills the given rectangle using the current background color.
+ * @param r the rectangle to fill
+ * @see #fillRectangle(int, int, int, int)
+ */
+public final void fillRectangle(Rectangle r) {
+    fillRectangle(r.x, r.y, r.width, r.height);
+}
+
+/**
+ * Fills a rectangle with rounded corners using the background color.  <i>arcWidth</i> and
+ * <i>arcHeight</i> represent the horizontal and vertical diameter of the corners.
+ *
+ * @param r the rectangle
+ * @param arcWidth the arc width
+ * @param arcHeight the arc height
+ */
+public abstract void fillRoundRectangle(Rectangle r, int arcWidth, int arcHeight);
+
+/**
+ * Draws the given string using the current font and foreground color. No tab expansion or
+ * carriage return processing will be performed. The background of the string will be
+ * filled with the current background color.
+ *
+ * @param s the string
+ * @param x the x coordinate
+ * @param y the y coordinate
+ */
+public abstract void fillString(String s, int x, int y);
+
+/**
+ * @see #fillString(String, int, int)
+ */
+public final void fillString(String s, Point p) {
+    fillString(s, p.x, p.y);
+}
+
+/**
+ * Draws the given string using the current font and foreground color. Tab expansion and
+ * carriage return processing are performed. The background of the text will be filled
+ * with the current background color.
+ *
+ * @param s the text
+ * @param x the x coordinate
+ * @param y the y coordinate
+ */
+public abstract void fillText(String s, int x, int y);
+
+/**
+ * @see #fillText(String, int, int)
+ */
+public final void fillText(String s, Point p) {
+    fillText(s, p.x, p.y);
+}
+
+/**
+ * Returns the current absolute scaling which will be applied to the underlying Device
+ * when painting to this Graphics.  The default value is 1.0.
+ * @since 3.0
+ * @return the effective absolute scaling factor
+ */
+public double getAbsoluteScale() {
+    return 1.0;
+}
+
+/**
+ * Returns the current alpha value of the graphics.
+ * @return the alpha value
+ * @since 3.1
+ */
+public int getAlpha() {
+    subclassFunctionMission();
+    return 255;
+}
+
+/**
+ * Returns the anti-aliasing setting value, which will be one of <code>SWT.DEFAULT</code>,
+ * <code>SWT.OFF</code> or <code>SWT.ON</code>. Note that this controls anti-aliasing for
+ * all <em>non-text</em> drawing operations.
+ * @see #getTextAntialias()
+ * @return the anti-alias setting
+ * @since 3.1
+ */
+public int getAntialias() {
+    subclassFunctionMission();
+    return SWT.DEFAULT;
+}
+
+/**
+ * Returns the background color used for filling.
+ * @return the background color
+ */
+public abstract Color getBackgroundColor();
+
+/**
+ * Modifies the given rectangle to match the clip region and returns that rectangle.
+ * @param rect the rectangle to hold the clip region
+ * @return the clip rectangle
+ */
+public abstract Rectangle getClip(Rectangle rect);
+
+/**
+ * Returns the fill rule, which will be one of <code>SWT.FILL_EVEN_ODD</code> or
+ * <code>SWT.FILL_WINDING</code>.
+ * @return the fill rule
+ * @since 3.1
+ */
+public int getFillRule() {
+    subclassFunctionMission();
+    return 0;
+}
+
+/**
+ * Returns the font used to draw and fill text.
+ * @return the font
+ */
+public abstract Font getFont();
+
+/**
+ * Returns the font metrics for the current font.
+ * @return the font metrics
+ */
+public abstract FontMetrics getFontMetrics();
+
+/**
+ * Returns the foreground color used to draw lines and text.
+ * @return the foreground color
+ */
+public abstract Color getForegroundColor();
+
+/**
+ * Returns the interpolation setting, which will be one of <code>SWT.DEFAULT</code>,
+ * <code>SWT.NONE</code>, <code>SWT.LOW</code> or <code>SWT.HIGH</code>.
+ * @return the interpolation setting
+ * @since 3.1
+ */
+public int getInterpolation() {
+    subclassFunctionMission();
+    return 0;
+}
+
+/**
+ * Returns the current line cap style, which will be one of the constants
+ * <code>SWT.CAP_FLAT</code>, <code>SWT.CAP_ROUND</code>, or <code>SWT.CAP_SQUARE</code>.
+ *
+ * @return the cap style used for drawing lines
+ * @since 3.1
+ */
+public int getLineCap() {
+    subclassFunctionMission();
+    return SWT.CAP_FLAT;
+}
+
+
+/**
+ * Returns the line join style, which will be one of the constants
+ * <code>SWT.JOIN_MITER</code>, <code>SWT.JOIN_ROUND</code>, or
+ * <code>SWT.JOIN_BEVEL</code>.
+ *
+ * @since 3.1
+ * @return the join style used for drawing lines
+ */
+public int getLineJoin() {
+    subclassFunctionMission();
+    return SWT.JOIN_MITER;
+}
+
+/**
+ * Returns the line style.
+ * @return the line style
+ */
+public abstract int getLineStyle();
+/**
+ * Returns the current line width.
+ * @return the line width
+ */
+public abstract int getLineWidth();
+
+/**
+ * Returns a pointlist containing all the points from the integer array.
+ * @param points an integer array of x,y points
+ * @return the corresponding pointlist
+ */
+private PointList getPointList(int[] points) {
+    PointList pointList = new PointList(points.length / 2);
+    for (int i = 0; (i + 1) < points.length; i += 2)
+        pointList.addPoint(points[i], points[i + 1]);
+    return pointList;
+}
+
+/**
+ * Returns the textual anti-aliasing setting value, which will be one of
+ * <code>SWT.DEFAULT</code>, <code>SWT.OFF</code> or <code>SWT.ON</code>. Note that this
+ * controls anti-aliasing <em>only</em> for text drawing operations.
+ *
+ * @see #getAntialias()
+ * @return the anti-aliasing setting
+ * @since 3.1
+ */
+public int getTextAntialias() {
+    subclassFunctionMission();
+    return SWT.DEFAULT;
+}
+
+/**
+ * Returns <code>true</code> if this graphics object should use XOR mode with painting.
+ * @return whether XOR mode is turned on
+ */
+public abstract bool getXORMode();
+
+/**
+ * Pops the previous state of this graphics object off the stack (if {@link #pushState()}
+ * has previously been called) and restores the current state to that popped state.
+ */
+public abstract void popState();
+
+/**
+ * Pushes the current state of this graphics object onto a stack.
+ */
+public abstract void pushState();
+
+/**
+ * Restores the previous state of this graphics object.
+ */
+public abstract void restoreState();
+
+/**
+ * Rotates the coordinates by the given counter-clockwise angle. All subsequent painting
+ * will be performed in the resulting coordinates. Some functions are illegal when a
+ * rotated coordinates system is in use.  To restore access to those functions, it is
+ * necessary to call restore or pop to return to a non rotated state.
+ * @param degrees the degrees to rotate
+ * @since 3.1
+ */
+public void rotate(float degrees) {
+    subclassFunctionMission();
+}
+
+/**
+ * Scales this graphics object by the given amount.
+ * @param amount the scale factor
+ */
+public abstract void scale(double amount);
+
+/**
+ * Scales the graphics by the given horizontal and vertical components.
+ * @param horizontal the horizontal scaling factor
+ * @param vertical the vertical scaling factor
+ * @since 3.1
+ */
+public void scale(float horizontal, float vertical) {
+    subclassFunctionMission();
+}
+
+/**
+ * Sets the alpha to the given value.  Values may range from 0 to 255.  A value
+ * of 0 is completely transparent.
+ *
+ * @param alpha an alpha value (0-255)
+ * @since 3.1
+ */
+public void setAlpha(int alpha) {
+    subclassFunctionMission();
+}
+
+/**
+ * Sets the anti-aliasing value to the parameter, which must be one of
+ * <code>SWT.DEFAULT</code>, <code>SWT.OFF</code> or <code>SWT.ON</code>. Note that this
+ * controls anti-aliasing for all <em>non-text drawing</em> operations.
+ *
+ * @param value the anti-alias value
+ */
+public void setAntialias(int value) {
+    subclassFunctionMission();
+}
+
+/**
+ * Sets the background color.
+ * @param rgb the new background color
+ */
+public abstract void setBackgroundColor(Color rgb);
+
+/**
+ * Sets the pattern used for fill-type graphics operations. The pattern must not be
+ * disposed while it is being used by the graphics.
+ * @param pattern the background pattern
+ * @since 3.1
+ */
+public void setBackgroundPattern(Pattern pattern) {
+    subclassFunctionMission();
+}
+
+/**
+ * Sets the area which can be affected by drawing operations to the specified
+ * <code>Path</code>.
+
+ * @param path the clipping path
+ * @since 3.1
+ */
+public void setClip(Path path) {
+    subclassFunctionMission();
+}
+
+/**
+ * Sets the clip rectangle. Painting will <b>not</b> occur outside this area.
+ * @param r the new clip rectangle
+ */
+public abstract void setClip(Rectangle r);
+
+/**
+ * Sets the fill rule to the given value, which must be one of
+ * <code>SWT.FILL_EVEN_ODD</code> or <code>SWT.FILL_WINDING</code>.
+ * @param rule the fill rule
+ * @since 3.1
+ */
+public void setFillRule(int rule) {
+    subclassFunctionMission();
+}
+
+/**
+ * Sets the font.
+ * @param f the new font
+ */
+public abstract void setFont(Font f);
+
+/**
+ * Sets the foreground color.
+ * @param rgb the new foreground color
+ */
+public abstract void setForegroundColor(Color rgb);
+
+/**
+ * Sets the foreground pattern for draw and text operations. The pattern must not be
+ * disposed while it is being referenced by the graphics.
+ * @param pattern the foreground pattern
+ * @since 3.1
+ */
+public void setForegroundPattern(Pattern pattern) {
+    subclassFunctionMission();
+}
+
+/**
+ * Sets the interpolation setting to the given value, which must be one of
+ * <code>SWT.DEFAULT</code>, <code>SWT.NONE</code>,  <code>SWT.LOW</code> or
+ * <code>SWT.HIGH</code>. This setting is relevant when working with Images.
+ * @param interpolation the interpolation
+ * @since 3.1
+ */
+public void setInterpolation(int interpolation) {
+    subclassFunctionMission();
+}
+
+/**
+ * Sets the line cap style to the argument, which must be one of the constants
+ * <code>SWT.CAP_FLAT</code>, <code>SWT.CAP_ROUND</code>, or <code>SWT.CAP_SQUARE</code>.
+ * @param cap the line cap
+ * @since 3.1
+ */
+public void setLineCap(int cap) {
+    subclassFunctionMission();
+}
+
+/**
+ * Sets the dash pattern when the custom line style is in use. Because this
+ * feature is rarely used, the dash pattern may not be preserved when calling
+ * {@link #pushState()} and {@link #popState()}.
+ * @param dash the pixel pattern
+ * @since 3.1
+ */
+public void setLineDash(int dash[]) {
+    subclassFunctionMission();
+}
+
+/**
+ * Sets the line join style to the argument, which must be one of the constants
+ * <code>SWT.JOIN_MITER</code>, <code>SWT.JOIN_ROUND</code>, or
+ * <code>SWT.JOIN_BEVEL</code>.
+ * @param join the join type
+ * @since 3.1
+ */
+public void setLineJoin(int join) {
+    subclassFunctionMission();
+}
+
+/**
+ * Sets the line style to the argument, which must be one of the constants
+ * <code>SWT.LINE_SOLID</code>, <code>SWT.LINE_DASH</code>, <code>SWT.LINE_DOT</code>,
+ * <code>SWT.LINE_DASHDOT</code> or <code>SWT.LINE_DASHDOTDOT</code>.
+ * @param style the new style
+ */
+public abstract void setLineStyle(int style);
+
+/**
+ * Sets the line width.
+ *
+ * @param width the new width
+ */
+public abstract void setLineWidth(int width);
+
+/**
+ * Sets the textual anti-aliasing value to the parameter, which must be one of
+ * <code>SWT.DEFAULT</code>, <code>SWT.OFF</code> or <code>SWT.ON</code>. Note that this
+ * controls anti-aliasing only for all <em>text drawing</em> operations.
+ *
+ * @param value the textual anti-alias setting
+ * @since 3.1
+ */
+public void setTextAntialias(int value) {
+    subclassFunctionMission();
+}
+
+/**
+ * Modifies the current transformation by shearing the graphics in the specified
+ * horizontal and vertical amounts. Shearing can be used to produce effects like Italic
+ * fonts.
+ * @param horz the horizontal shearing amount
+ * @param vert the vertical shearming amount
+ * @since 3.1
+ */
+public void shear(float horz, float vert) {
+    subclassFunctionMission();
+}
+
+/**
+ * Sets the XOR mode.
+ * @param b the new XOR mode
+ */
+public abstract void setXORMode(bool b);
+
+private void subclassFunctionMission() {
+    throw new RuntimeException( "The class: " ~ this.classinfo.name //$NON-NLS-1$
+            ~ " has not implemented this new graphics function"); //$NON-NLS-1$
+}
+
+/**
+ * Translates the receiver's coordinates by the specified x and y amounts. All
+ * subsequent painting will be performed in the resulting coordinate system. Integer
+ * translation used by itself does not require or start the use of the advanced
+ * graphics system in SWT. It is emulated until advanced graphics are triggered.
+ * @param dx the horizontal offset
+ * @param dy the vertical offset
+ */
+public abstract void translate(int dx, int dy);
+
+
+/**
+ * Modifies the current transform by translating the given x and y amounts. All
+ * subsequent painting will be performed in the resulting coordinate system.
+ * @param dx the horizontal offset
+ * @param dy the vertical offset
+ */
+public void translate(float dx, float dy) {
+    subclassFunctionMission();
+}
+
+/**
+ * @see #translate(int, int)
+ */
+public final void translate(Point pt) {
+    translate(pt.x, pt.y);
+}
+
+}