/*******************************************************************************
* Copyright (c) 2000, 2012 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
*******************************************************************************/
package org.eclipse.swt.graphics;
import org.eclipse.swt.SWTError;
import org.eclipse.swt.SWTException;
/**
* 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>
* The result of drawing on an image that was created with an indexed palette
* using a color that is not in the palette is platform specific. Some platforms
* will match to the nearest color while other will draw the color itself. This
* happens because the allocated image might use a direct palette on platforms
* that do not support indexed palette.
* </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
* @see <a href="http://www.eclipse.org/swt/snippets/#gc">GC snippets</a>
* @see <a href="http://www.eclipse.org/swt/examples.php">SWT Examples:
* GraphicsExample, PaintExample</a>
* @see <a href="http://www.eclipse.org/swt/">Sample code and further
* information</a>
*/
public final class GC extends Resource {
/**
* 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) {
}
/**
* 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>
*
* @since 2.1.2
*/
public GC(Drawable drawable, int style) {
// TODO
}
/**
* 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) {
// TODO
}
/**
* 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) {
// TODO
}
/**
* 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) {
// TODO
}
@Override
void destroy() {
// TODO
}
/**
* 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) {
// TODO
}
/**
* 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) {
// TODO
}
/**
* 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) {
// TODO
}
/**
* 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
* <ul>
* <li>ERROR_NO_HANDLES - if no handles are available to
* perform the operation</li>
* </ul>
*/
public void drawImage(Image image, int srcX, int srcY, int srcWidth,
int srcHeight, int destX, int destY, int destWidth, int destHeight) {
// TODO
}
/**
* Draws a line, using the foreground color, between the points (
* <code>x1</code>, <code>y1</code>) and (<code>x2</code>, <code>y2</code>).
*
* @param x1
* the first point's x coordinate
* @param y1
* the first point's y coordinate
* @param x2
* the second point's x coordinate
* @param y2
* the second point's y coordinate
*
* @exception SWTException
* <ul>
* <li>ERROR_GRAPHIC_DISPOSED - if the receiver has been
* disposed</li>
* </ul>
*/
public void drawLine(int x1, int y1, int x2, int y2) {
// TODO
}
/**
* Draws the outline of an oval, using the foreground color, within the
* specified rectangular area.
* <p>
* The result is a circle or ellipse that fits within the rectangle
* specified by the <code>x</code>, <code>y</code>, <code>width</code>, and
* <code>height</code> arguments.
* </p>
* <p>
* The oval covers an area that is <code>width + 1</code> pixels wide and
* <code>height + 1</code> pixels tall.
* </p>
*
* @param x
* the x coordinate of the upper left corner of the oval to be
* drawn
* @param y
* the y coordinate of the upper left corner of the oval to be
* drawn
* @param width
* the width of the oval to be drawn
* @param height
* the height of the oval to be drawn
*
* @exception SWTException
* <ul>
* <li>ERROR_GRAPHIC_DISPOSED - if the receiver has been
* disposed</li>
* </ul>
*/
public void drawOval(int x, int y, int width, int height) {
// TODO
}
/**
* Draws the path described by the parameter.
* <p>
* This operation requires the operating system's advanced graphics
* subsystem which may not be available on some platforms.
* </p>
*
* @param path
* the path to draw
*
* @exception IllegalArgumentException
* <ul>
* <li>ERROR_NULL_ARGUMENT - if the parameter is null</li>
* <li>ERROR_INVALID_ARGUMENT - if the parameter has been
* disposed</li>
* </ul>
* @exception SWTException
* <ul>
* <li>ERROR_GRAPHIC_DISPOSED - if the receiver has been
* disposed</li>
* <li>ERROR_NO_GRAPHICS_LIBRARY - if advanced graphics are
* not available</li>
* </ul>
*
* @see Path
*
* @since 3.1
*/
public void drawPath(Path path) {
// TODO
}
/**
* Draws a pixel, using the foreground color, at the specified point (
* <code>x</code>, <code>y</code>).
* <p>
* Note that the receiver's line attributes do not affect this operation.
* </p>
*
* @param x
* the point's x coordinate
* @param y
* the point's y coordinate
*
* @exception SWTException
* <ul>
* <li>ERROR_GRAPHIC_DISPOSED - if the receiver has been
* disposed</li>
* </ul>
*
* @since 3.0
*/
public void drawPoint(int x, int y) {
// TODO
}
/**
* Draws the closed polygon which is defined by the specified array of
* integer coordinates, using the receiver's foreground color. The array
* contains alternating x and y values which are considered to represent
* points which are the vertices of the polygon. Lines are drawn between
* each consecutive pair, and between the first pair and last pair in the
* array.
*
* @param pointArray
* an array of alternating x and y values which are the vertices
* of the polygon
*
* @exception IllegalArgumentException
* <ul>
* <li>ERROR_NULL_ARGUMENT if pointArray is null</li>
* </ul>
* @exception SWTException
* <ul>
* <li>ERROR_GRAPHIC_DISPOSED - if the receiver has been
* disposed</li>
* </ul>
*/
public void drawPolygon(int[] pointArray) {
// TODO
}
/**
* Draws the polyline which is defined by the specified array of integer
* coordinates, using the receiver's foreground color. The array contains
* alternating x and y values which are considered to represent points which
* are the corners of the polyline. Lines are drawn between each consecutive
* pair, but not between the first pair and last pair in the array.
*
* @param pointArray
* an array of alternating x and y values which are the corners
* of the polyline
*
* @exception IllegalArgumentException
* <ul>
* <li>ERROR_NULL_ARGUMENT - if the point array is null</li>
* </ul>
* @exception SWTException
* <ul>
* <li>ERROR_GRAPHIC_DISPOSED - if the receiver has been
* disposed</li>
* </ul>
*/
public void drawPolyline(int[] pointArray) {
// TODO
}
/**
* Draws the outline of the rectangle specified by the arguments, using the
* receiver's foreground color. The left and right edges of the rectangle
* are at <code>x</code> and <code>x + width</code>. The top and bottom
* edges are at <code>y</code> and <code>y + height</code>.
*
* @param x
* the x coordinate of the rectangle to be drawn
* @param y
* the y coordinate of the rectangle to be drawn
* @param width
* the width of the rectangle to be drawn
* @param height
* the height of the rectangle to be drawn
*
* @exception SWTException
* <ul>
* <li>ERROR_GRAPHIC_DISPOSED - if the receiver has been
* disposed</li>
* </ul>
*/
public void drawRectangle(int x, int y, int width, int height) {
// TODO
}
/**
* Draws the outline of the specified rectangle, using the receiver's
* foreground color. The left and right edges of the rectangle are at
* <code>rect.x</code> and <code>rect.x + rect.width</code>. The top and
* bottom edges are at <code>rect.y</code> and
* <code>rect.y + rect.height</code>.
*
* @param rect
* the rectangle to draw
*
* @exception IllegalArgumentException
* <ul>
* <li>ERROR_NULL_ARGUMENT - if the rectangle is null</li>
* </ul>
* @exception SWTException
* <ul>
* <li>ERROR_GRAPHIC_DISPOSED - if the receiver has been
* disposed</li>
* </ul>
*/
public void drawRectangle(Rectangle rect) {
// TODO
}
/**
* Draws the outline of the round-cornered rectangle specified by the
* arguments, using the receiver's foreground color. The left and right
* edges of the rectangle are at <code>x</code> and <code>x + width</code>.
* The top and bottom edges are at <code>y</code> and
* <code>y + height</code>. The <em>roundness</em> of the corners is
* specified by the <code>arcWidth</code> and <code>arcHeight</code>
* arguments, which are respectively the width and height of the ellipse
* used to draw the corners.
*
* @param x
* the x coordinate of the rectangle to be drawn
* @param y
* the y coordinate of the rectangle to be drawn
* @param width
* the width of the rectangle to be drawn
* @param height
* the height of the rectangle to be drawn
* @param arcWidth
* the width of the arc
* @param arcHeight
* the height of the arc
*
* @exception SWTException
* <ul>
* <li>ERROR_GRAPHIC_DISPOSED - if the receiver has been
* disposed</li>
* </ul>
*/
public void drawRoundRectangle(int x, int y, int width, int height,
int arcWidth, int arcHeight) {
// TODO
}
/**
* Draws the given string, using the receiver's current font and foreground
* color. No tab expansion or carriage return processing will be performed.
* The background of the rectangular area where the string is being drawn
* will be filled with the receiver's background color.
*
* @param string
* the string to be drawn
* @param x
* the x coordinate of the top left corner of the rectangular
* area where the string is to be drawn
* @param y
* the y coordinate of the top left corner of the rectangular
* area where the string is to be drawn
*
* @exception IllegalArgumentException
* <ul>
* <li>ERROR_NULL_ARGUMENT - if the string is null</li>
* </ul>
* @exception SWTException
* <ul>
* <li>ERROR_GRAPHIC_DISPOSED - if the receiver has been
* disposed</li>
* </ul>
*/
public void drawString(String string, int x, int y) {
// TODO
}
/**
* Draws the given string, using the receiver's current font and foreground
* color. No tab expansion or carriage return processing will be performed.
* If <code>isTransparent</code> is <code>true</code>, then the background
* of the rectangular area where the string is being drawn will not be
* modified, otherwise it will be filled with the receiver's background
* color.
*
* @param string
* the string to be drawn
* @param x
* the x coordinate of the top left corner of the rectangular
* area where the string is to be drawn
* @param y
* the y coordinate of the top left corner of the rectangular
* area where the string is to be drawn
* @param isTransparent
* if <code>true</code> the background will be transparent,
* otherwise it will be opaque
*
* @exception IllegalArgumentException
* <ul>
* <li>ERROR_NULL_ARGUMENT - if the string is null</li>
* </ul>
* @exception SWTException
* <ul>
* <li>ERROR_GRAPHIC_DISPOSED - if the receiver has been
* disposed</li>
* </ul>
*/
public void drawString(String string, int x, int y, boolean isTransparent) {
// TODO
}
/**
* Draws the given string, using the receiver's current font and foreground
* color. Tab expansion and carriage return processing are performed. The
* background of the rectangular area where the text is being drawn will be
* filled with the receiver's background color.
*
* @param string
* the string to be drawn
* @param x
* the x coordinate of the top left corner of the rectangular
* area where the text is to be drawn
* @param y
* the y coordinate of the top left corner of the rectangular
* area where the text is to be drawn
*
* @exception IllegalArgumentException
* <ul>
* <li>ERROR_NULL_ARGUMENT - if the string is null</li>
* </ul>
* @exception SWTException
* <ul>
* <li>ERROR_GRAPHIC_DISPOSED - if the receiver has been
* disposed</li>
* </ul>
*/
public void drawText(String string, int x, int y) {
// TODO
}
/**
* Draws the given string, using the receiver's current font and foreground
* color. Tab expansion and carriage return processing are performed. If
* <code>isTransparent</code> is <code>true</code>, then the background of
* the rectangular area where the text is being drawn will not be modified,
* otherwise it will be filled with the receiver's background color.
*
* @param string
* the string to be drawn
* @param x
* the x coordinate of the top left corner of the rectangular
* area where the text is to be drawn
* @param y
* the y coordinate of the top left corner of the rectangular
* area where the text is to be drawn
* @param isTransparent
* if <code>true</code> the background will be transparent,
* otherwise it will be opaque
*
* @exception IllegalArgumentException
* <ul>
* <li>ERROR_NULL_ARGUMENT - if the string is null</li>
* </ul>
* @exception SWTException
* <ul>
* <li>ERROR_GRAPHIC_DISPOSED - if the receiver has been
* disposed</li>
* </ul>
*/
public void drawText(String string, int x, int y, boolean isTransparent) {
// TODO
}
/**
* Draws the given string, using the receiver's current font and foreground
* color. Tab expansion, line delimiter and mnemonic processing are
* performed according to the specified flags. If <code>flags</code>
* includes <code>DRAW_TRANSPARENT</code>, then the background of the
* rectangular area where the text is being drawn will not be modified,
* otherwise it will be filled with the receiver's background color.
* <p>
* The parameter <code>flags</code> may be a combination of:
* <dl>
* <dt><b>DRAW_DELIMITER</b></dt>
* <dd>draw multiple lines</dd>
* <dt><b>DRAW_TAB</b></dt>
* <dd>expand tabs</dd>
* <dt><b>DRAW_MNEMONIC</b></dt>
* <dd>underline the mnemonic character</dd>
* <dt><b>DRAW_TRANSPARENT</b></dt>
* <dd>transparent background</dd>
* </dl>
* </p>
*
* @param string
* the string to be drawn
* @param x
* the x coordinate of the top left corner of the rectangular
* area where the text is to be drawn
* @param y
* the y coordinate of the top left corner of the rectangular
* area where the text is to be drawn
* @param flags
* the flags specifying how to process the text
*
* @exception IllegalArgumentException
* <ul>
* <li>ERROR_NULL_ARGUMENT - if the string is null</li>
* </ul>
* @exception SWTException
* <ul>
* <li>ERROR_GRAPHIC_DISPOSED - if the receiver has been
* disposed</li>
* </ul>
*/
public void drawText(String string, int x, int y, int flags) {
// TODO
}
/**
* Fills the interior of a circular or elliptical arc within the specified
* rectangular area, with the receiver's background color.
* <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
* filled
* @param y
* the y coordinate of the upper-left corner of the arc to be
* filled
* @param width
* the width of the arc to be filled
* @param height
* the height of the arc to be filled
* @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>
*
* @see #drawArc
*/
public void fillArc(int x, int y, int width, int height, int startAngle,
int arcAngle) {
// TODO
}
/**
* Fills the interior of the specified rectangle with a gradient sweeping
* from left to right or top to bottom progressing from the receiver's
* foreground color to its background color.
*
* @param x
* the x coordinate of the rectangle to be filled
* @param y
* the y coordinate of the rectangle to be filled
* @param width
* the width of the rectangle to be filled, may be negative
* (inverts direction of gradient if horizontal)
* @param height
* the height of the rectangle to be filled, may be negative
* (inverts direction of gradient if vertical)
* @param vertical
* if true sweeps from top to bottom, else sweeps from left to
* right
*
* @exception SWTException
* <ul>
* <li>ERROR_GRAPHIC_DISPOSED - if the receiver has been
* disposed</li>
* </ul>
*
* @see #drawRectangle(int, int, int, int)
*/
public void fillGradientRectangle(int x, int y, int width, int height,
boolean vertical) {
// TODO
}
/**
* Fills the interior of an oval, within the specified rectangular area,
* with the receiver's background color.
*
* @param x
* the x coordinate of the upper left corner of the oval to be
* filled
* @param y
* the y coordinate of the upper left corner of the oval to be
* filled
* @param width
* the width of the oval to be filled
* @param height
* the height of the oval to be filled
*
* @exception SWTException
* <ul>
* <li>ERROR_GRAPHIC_DISPOSED - if the receiver has been
* disposed</li>
* </ul>
*
* @see #drawOval
*/
public void fillOval(int x, int y, int width, int height) {
// TODO
}
/**
* Fills the path described by the parameter.
* <p>
* This operation requires the operating system's advanced graphics
* subsystem which may not be available on some platforms.
* </p>
*
* @param path
* the path to fill
*
* @exception IllegalArgumentException
* <ul>
* <li>ERROR_NULL_ARGUMENT - if the parameter is null</li>
* <li>ERROR_INVALID_ARGUMENT - if the parameter has been
* disposed</li>
* </ul>
* @exception SWTException
* <ul>
* <li>ERROR_GRAPHIC_DISPOSED - if the receiver has been
* disposed</li>
* <li>ERROR_NO_GRAPHICS_LIBRARY - if advanced graphics are
* not available</li>
* </ul>
*
* @see Path
*
* @since 3.1
*/
public void fillPath(Path path) {
// TODO
}
/**
* Fills the interior of the closed polygon which is defined by the
* specified array of integer coordinates, using the receiver's background
* color. The array contains alternating x and y values which are considered
* to represent points which are the vertices of the polygon. Lines are
* drawn between each consecutive pair, and between the first pair and last
* pair in the array.
*
* @param pointArray
* an array of alternating x and y values which are the vertices
* of the polygon
*
* @exception IllegalArgumentException
* <ul>
* <li>ERROR_NULL_ARGUMENT if pointArray is null</li>
* </ul>
* @exception SWTException
* <ul>
* <li>ERROR_GRAPHIC_DISPOSED - if the receiver has been
* disposed</li>
* </ul>
*
* @see #drawPolygon
*/
public void fillPolygon(int[] pointArray) {
// TODO
}
/**
* Fills the interior of the rectangle specified by the arguments, using the
* receiver's background color.
*
* @param x
* the x coordinate of the rectangle to be filled
* @param y
* the y coordinate of the rectangle to be filled
* @param width
* the width of the rectangle to be filled
* @param height
* the height of the rectangle to be filled
*
* @exception SWTException
* <ul>
* <li>ERROR_GRAPHIC_DISPOSED - if the receiver has been
* disposed</li>
* </ul>
*
* @see #drawRectangle(int, int, int, int)
*/
public void fillRectangle(int x, int y, int width, int height) {
// TODO
}
/**
* Fills the interior of the specified rectangle, using the receiver's
* background color.
*
* @param rect
* the rectangle to be filled
*
* @exception IllegalArgumentException
* <ul>
* <li>ERROR_NULL_ARGUMENT - if the rectangle is null</li>
* </ul>
* @exception SWTException
* <ul>
* <li>ERROR_GRAPHIC_DISPOSED - if the receiver has been
* disposed</li>
* </ul>
*
* @see #drawRectangle(int, int, int, int)
*/
public void fillRectangle(Rectangle rect) {
// TODO
}
/**
* Fills the interior of the round-cornered rectangle specified by the
* arguments, using the receiver's background color.
*
* @param x
* the x coordinate of the rectangle to be filled
* @param y
* the y coordinate of the rectangle to be filled
* @param width
* the width of the rectangle to be filled
* @param height
* the height of the rectangle to be filled
* @param arcWidth
* the width of the arc
* @param arcHeight
* the height of the arc
*
* @exception SWTException
* <ul>
* <li>ERROR_GRAPHIC_DISPOSED - if the receiver has been
* disposed</li>
* </ul>
*
* @see #drawRoundRectangle
*/
public void fillRoundRectangle(int x, int y, int width, int height,
int arcWidth, int arcHeight) {
// TODO
}
/**
* Returns the <em>advance width</em> of the specified character in the font
* which is currently selected into the receiver.
* <p>
* The advance width is defined as the horizontal distance the cursor should
* move after printing the character in the selected font.
* </p>
*
* @param ch
* the character to measure
* @return the distance in the x direction to move past the character before
* painting the next
*
* @exception SWTException
* <ul>
* <li>ERROR_GRAPHIC_DISPOSED - if the receiver has been
* disposed</li>
* </ul>
*/
public int getAdvanceWidth(char ch) {
// TODO
return 0;
}
/**
* Returns <code>true</code> if receiver is using the operating system's
* advanced graphics subsystem. Otherwise, <code>false</code> is returned to
* indicate that normal graphics are in use.
* <p>
* Advanced graphics may not be installed for the operating system. In this
* case, <code>false</code> is always returned. Some operating system have
* only one graphics subsystem. If this subsystem supports advanced
* graphics, then <code>true</code> is always returned. If any graphics
* operation such as alpha, antialias, patterns, interpolation, paths,
* clipping or transformation has caused the receiver to switch from regular
* to advanced graphics mode, <code>true</code> is returned. If the receiver
* has been explicitly switched to advanced mode and this mode is supported,
* <code>true</code> is returned.
* </p>
*
* @return the advanced value
*
* @exception SWTException
* <ul>
* <li>ERROR_GRAPHIC_DISPOSED - if the receiver has been
* disposed</li>
* </ul>
*
* @see #setAdvanced
*
* @since 3.1
*/
public boolean getAdvanced() {
// TODO
return false;
}
/**
* Returns the receiver's alpha value. The alpha value is between 0
* (transparent) and 255 (opaque).
*
* @return the alpha value
*
* @exception SWTException
* <ul>
* <li>ERROR_GRAPHIC_DISPOSED - if the receiver has been
* disposed</li>
* </ul>
*
* @since 3.1
*/
public int getAlpha() {
// TODO
return 0;
}
/**
* Returns the receiver's 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 drawing</em>
* operations.
*
* @return the anti-aliasing setting
*
* @exception SWTException
* <ul>
* <li>ERROR_GRAPHIC_DISPOSED - if the receiver has been
* disposed</li>
* </ul>
*
* @see #getTextAntialias
*
* @since 3.1
*/
public int getAntialias() {
// TODO
return 0;
}
/**
* Returns the background color.
*
* @return the receiver's background color
*
* @exception SWTException
* <ul>
* <li>ERROR_GRAPHIC_DISPOSED - if the receiver has been
* disposed</li>
* </ul>
*/
public Color getBackground() {
// TODO
return null;
}
/**
* Returns the background pattern. The default value is <code>null</code>.
*
* @return the receiver's background pattern
*
* @exception SWTException
* <ul>
* <li>ERROR_GRAPHIC_DISPOSED - if the receiver has been
* disposed</li>
* </ul>
*
* @see Pattern
*
* @since 3.1
*/
public Pattern getBackgroundPattern() {
// TODO
return null;
}
/**
* Returns the width of the specified character in the font selected into
* the receiver.
* <p>
* The width is defined as the space taken up by the actual character, not
* including the leading and tailing whitespace or overhang.
* </p>
*
* @param ch
* the character to measure
* @return the width of the character
*
* @exception SWTException
* <ul>
* <li>ERROR_GRAPHIC_DISPOSED - if the receiver has been
* disposed</li>
* </ul>
*/
public int getCharWidth(char ch) {
// TODO
return 0;
}
/**
* Returns the bounding rectangle of the receiver's clipping region. If no
* clipping region is set, the return value will be a rectangle which covers
* the entire bounds of the object the receiver is drawing on.
*
* @return the bounding rectangle of the clipping region
*
* @exception SWTException
* <ul>
* <li>ERROR_GRAPHIC_DISPOSED - if the receiver has been
* disposed</li>
* </ul>
*/
public Rectangle getClipping() {
// TODO
return null;
}
/**
* Sets the region managed by the argument to the current clipping region of
* the receiver.
*
* @param region
* the region to fill with the clipping region
*
* @exception IllegalArgumentException
* <ul>
* <li>ERROR_NULL_ARGUMENT - if the region is null</li>
* <li>ERROR_INVALID_ARGUMENT - if the region is disposed</li>
* </ul>
* @exception SWTException
* <ul>
* <li>ERROR_GRAPHIC_DISPOSED - if the receiver has been
* disposed</li>
* </ul>
*/
public void getClipping(Region region) {
// TODO
}
/**
* Returns the receiver's fill rule, which will be one of
* <code>SWT.FILL_EVEN_ODD</code> or <code>SWT.FILL_WINDING</code>.
*
* @return the receiver's fill rule
*
* @exception SWTException
* <ul>
* <li>ERROR_GRAPHIC_DISPOSED - if the receiver has been
* disposed</li>
* </ul>
*
* @since 3.1
*/
public int getFillRule() {
// TODO
return 0;
}
/**
* Returns the font currently being used by the receiver to draw and measure
* text.
*
* @return the receiver's font
*
* @exception SWTException
* <ul>
* <li>ERROR_GRAPHIC_DISPOSED - if the receiver has been
* disposed</li>
* </ul>
*/
public Font getFont() {
// TODO
return null;
}
/**
* Returns a FontMetrics which contains information about the font currently
* being used by the receiver to draw and measure text.
*
* @return font metrics for the receiver's font
*
* @exception SWTException
* <ul>
* <li>ERROR_GRAPHIC_DISPOSED - if the receiver has been
* disposed</li>
* </ul>
*/
public FontMetrics getFontMetrics() {
// TODO
return null;
}
/**
* Returns the receiver's foreground color.
*
* @return the color used for drawing foreground things
*
* @exception SWTException
* <ul>
* <li>ERROR_GRAPHIC_DISPOSED - if the receiver has been
* disposed</li>
* </ul>
*/
public Color getForeground() {
// TODO
return null;
}
/**
* Returns the foreground pattern. The default value is <code>null</code>.
*
* @return the receiver's foreground pattern
*
* @exception SWTException
* <ul>
* <li>ERROR_GRAPHIC_DISPOSED - if the receiver has been
* disposed</li>
* </ul>
*
* @see Pattern
*
* @since 3.1
*/
public Pattern getForegroundPattern() {
// TODO
return null;
}
/**
* Returns the GCData.
* <p>
* <b>IMPORTANT:</b> This method is <em>not</em> part of the public API for
* <code>GC</code>. It is marked public only so that it can be shared within
* the packages provided by SWT. It is not available on all platforms, and
* should never be called from application code.
* </p>
*
* @return the receiver's GCData
*
* @exception SWTException
* <ul>
* <li>ERROR_GRAPHIC_DISPOSED - if the receiver has been
* disposed</li>
* </ul>
*
* @see GCData
*
* @noreference This method is not intended to be referenced by clients.
*
* @since 3.2
*/
public GCData getGCData() {
// TODO
return null;
}
/**
* Returns the receiver's 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 receiver's interpolation setting
*
* @exception SWTException
* <ul>
* <li>ERROR_GRAPHIC_DISPOSED - if the receiver has been
* disposed</li>
* </ul>
*
* @since 3.1
*/
public int getInterpolation() {
// TODO
return 0;
}
/**
* Returns the receiver's line attributes.
*
* @return the line attributes used for drawing lines
*
* @exception SWTException
* <ul>
* <li>ERROR_GRAPHIC_DISPOSED - if the receiver has been
* disposed</li>
* </ul>
*
* @since 3.3
*/
public LineAttributes getLineAttributes() {
// TODO
return null;
}
/**
* Returns the receiver's 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
*
* @exception SWTException
* <ul>
* <li>ERROR_GRAPHIC_DISPOSED - if the receiver has been
* disposed</li>
* </ul>
*
* @since 3.1
*/
public int getLineCap() {
// TODO
return 0;
}
/**
* Returns the receiver's line dash style. The default value is
* <code>null</code>.
*
* @return the line dash style used for drawing lines
*
* @exception SWTException
* <ul>
* <li>ERROR_GRAPHIC_DISPOSED - if the receiver has been
* disposed</li>
* </ul>
*
* @since 3.1
*/
public int[] getLineDash() {
// TODO
return null;
}
/**
* Returns the receiver's 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>.
*
* @return the join style used for drawing lines
*
* @exception SWTException
* <ul>
* <li>ERROR_GRAPHIC_DISPOSED - if the receiver has been
* disposed</li>
* </ul>
*
* @since 3.1
*/
public int getLineJoin() {
// TODO
return 0;
}
/**
* Returns the receiver's line style, which will 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>.
*
* @return the style used for drawing lines
*
* @exception SWTException
* <ul>
* <li>ERROR_GRAPHIC_DISPOSED - if the receiver has been
* disposed</li>
* </ul>
*/
public int getLineStyle() {
// TODO
return 0;
}
/**
* Returns the width that will be used when drawing lines for all of the
* figure drawing operations (that is, <code>drawLine</code>,
* <code>drawRectangle</code>, <code>drawPolyline</code>, and so forth.
*
* @return the receiver's line width
*
* @exception SWTException
* <ul>
* <li>ERROR_GRAPHIC_DISPOSED - if the receiver has been
* disposed</li>
* </ul>
*/
public int getLineWidth() {
// TODO
return 0;
}
/**
* Returns the receiver's style information.
* <p>
* Note that the value which is returned by this method <em>may
* not match</em> the value which was provided to the constructor when the
* receiver was created. This can occur when the underlying operating system
* does not support a particular combination of requested styles.
* </p>
*
* @return the style bits
*
* @exception SWTException
* <ul>
* <li>ERROR_GRAPHIC_DISPOSED - if the receiver has been
* disposed</li>
* </ul>
*
* @since 2.1.2
*/
public int getStyle() {
// TODO
return 0;
}
/**
* Returns the receiver's text drawing 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.
*
* @return the anti-aliasing setting
*
* @exception SWTException
* <ul>
* <li>ERROR_GRAPHIC_DISPOSED - if the receiver has been
* disposed</li>
* </ul>
*
* @see #getAntialias
*
* @since 3.1
*/
public int getTextAntialias() {
// TODO
return 0;
}
/**
* Sets the parameter to the transform that is currently being used by the
* receiver.
*
* @param transform
* the destination to copy the transform into
*
* @exception IllegalArgumentException
* <ul>
* <li>ERROR_NULL_ARGUMENT - if the parameter is null</li>
* <li>ERROR_INVALID_ARGUMENT - if the parameter has been
* disposed</li>
* </ul>
* @exception SWTException
* <ul>
* <li>ERROR_GRAPHIC_DISPOSED - if the receiver has been
* disposed</li>
* </ul>
*
* @see Transform
*
* @since 3.1
*/
public void getTransform(Transform transform) {
// TODO
}
/**
* Returns <code>true</code> if this GC is drawing in the mode where the
* resulting color in the destination is the <em>exclusive or</em> of the
* color values in the source and the destination, and <code>false</code> if
* it is drawing in the mode where the destination color is being replaced
* with the source color value.
*
* @return <code>true</code> true if the receiver is in XOR mode, and false
* otherwise
*
* @exception SWTException
* <ul>
* <li>ERROR_GRAPHIC_DISPOSED - if the receiver has been
* disposed</li>
* </ul>
*/
public boolean getXORMode() {
// TODO
return false;
}
/**
* Returns <code>true</code> if the receiver has a clipping region set into
* it, and <code>false</code> otherwise. If this method returns false, the
* receiver will draw on all available space in the destination. If it
* returns true, it will draw only in the area that is covered by the region
* that can be accessed with <code>getClipping(region)</code>.
*
* @return <code>true</code> if the GC has a clipping region, and
* <code>false</code> otherwise
*
* @exception SWTException
* <ul>
* <li>ERROR_GRAPHIC_DISPOSED - if the receiver has been
* disposed</li>
* </ul>
*/
public boolean isClipped() {
// TODO
return false;
}
/**
* Returns <code>true</code> if the GC has been disposed, and
* <code>false</code> otherwise.
* <p>
* This method gets the dispose state for the GC. When a GC has been
* disposed, it is an error to invoke any other method (except
* {@link #dispose()}) using the GC.
*
* @return <code>true</code> when the GC is disposed and <code>false</code>
* otherwise
*/
@Override
public boolean isDisposed() {
// TODO
return false;
}
/**
* Sets the receiver to always use the operating system's advanced graphics
* subsystem for all graphics operations if the argument is
* <code>true</code>. If the argument is <code>false</code>, the advanced
* graphics subsystem is no longer used, advanced graphics state is cleared
* and the normal graphics subsystem is used from now on.
* <p>
* Normally, the advanced graphics subsystem is invoked automatically when
* any one of the alpha, antialias, patterns, interpolation, paths, clipping
* or transformation operations in the receiver is requested. When the
* receiver is switched into advanced mode, the advanced graphics subsystem
* performs both advanced and normal graphics operations. Because the two
* subsystems are different, their output may differ. Switching to advanced
* graphics before any graphics operations are performed ensures that the
* output is consistent.
* </p>
* <p>
* Advanced graphics may not be installed for the operating system. In this
* case, this operation does nothing. Some operating system have only one
* graphics subsystem, so switching from normal to advanced graphics does
* nothing. However, switching from advanced to normal graphics will always
* clear the advanced graphics state, even for operating systems that have
* only one graphics subsystem.
* </p>
*
* @param advanced
* the new advanced graphics state
*
* @exception SWTException
* <ul>
* <li>ERROR_GRAPHIC_DISPOSED - if the receiver has been
* disposed</li>
* </ul>
*
* @see #setAlpha
* @see #setAntialias
* @see #setBackgroundPattern
* @see #setClipping(Path)
* @see #setForegroundPattern
* @see #setLineAttributes
* @see #setInterpolation
* @see #setTextAntialias
* @see #setTransform
* @see #getAdvanced
*
* @since 3.1
*/
public void setAdvanced(boolean advanced) {
// TODO
}
/**
* Sets the receiver's alpha value which must be between 0 (transparent) and
* 255 (opaque).
* <p>
* This operation requires the operating system's advanced graphics
* subsystem which may not be available on some platforms.
* </p>
*
* @param alpha
* the alpha value
*
* @exception SWTException
* <ul>
* <li>ERROR_GRAPHIC_DISPOSED - if the receiver has been
* disposed</li>
* <li>ERROR_NO_GRAPHICS_LIBRARY - if advanced graphics are
* not available</li>
* </ul>
*
* @see #getAdvanced
* @see #setAdvanced
*
* @since 3.1
*/
public void setAlpha(int alpha) {
// TODO
}
/**
* Sets the receiver's 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.
* <p>
* This operation requires the operating system's advanced graphics
* subsystem which may not be available on some platforms.
* </p>
*
* @param antialias
* the anti-aliasing setting
*
* @exception IllegalArgumentException
* <ul>
* <li>ERROR_INVALID_ARGUMENT - if the parameter is not one
* of <code>SWT.DEFAULT</code>, <code>SWT.OFF</code> or
* <code>SWT.ON</code></li>
* </ul>
* @exception SWTException
* <ul>
* <li>ERROR_GRAPHIC_DISPOSED - if the receiver has been
* disposed</li>
* <li>ERROR_NO_GRAPHICS_LIBRARY - if advanced graphics are
* not available</li>
* </ul>
*
* @see #getAdvanced
* @see #setAdvanced
* @see #setTextAntialias
*
* @since 3.1
*/
public void setAntialias(int antialias) {
// TODO
}
/**
* Sets the background color. The background color is used for fill
* operations and as the background color when text is drawn.
*
* @param color
* the new background color for the receiver
*
* @exception IllegalArgumentException
* <ul>
* <li>ERROR_NULL_ARGUMENT - if the color is null</li>
* <li>ERROR_INVALID_ARGUMENT - if the color has been
* disposed</li>
* </ul>
* @exception SWTException
* <ul>
* <li>ERROR_GRAPHIC_DISPOSED - if the receiver has been
* disposed</li>
* </ul>
*/
public void setBackground(Color color) {
// TODO
}
/**
* Sets the background pattern. The default value is <code>null</code>.
* <p>
* This operation requires the operating system's advanced graphics
* subsystem which may not be available on some platforms.
* </p>
*
* @param pattern
* the new background pattern
*
* @exception IllegalArgumentException
* <ul>
* <li>ERROR_INVALID_ARGUMENT - if the parameter has been
* disposed</li>
* </ul>
* @exception SWTException
* <ul>
* <li>ERROR_GRAPHIC_DISPOSED - if the receiver has been
* disposed</li>
* <li>ERROR_NO_GRAPHICS_LIBRARY - if advanced graphics are
* not available</li>
* </ul>
*
* @see Pattern
* @see #getAdvanced
* @see #setAdvanced
*
* @since 3.1
*/
public void setBackgroundPattern(Pattern pattern) {
// TODO
}
/**
* Sets the area of the receiver which can be changed by drawing operations
* to the rectangular area specified by the arguments.
*
* @param x
* the x coordinate of the clipping rectangle
* @param y
* the y coordinate of the clipping rectangle
* @param width
* the width of the clipping rectangle
* @param height
* the height of the clipping rectangle
*
* @exception SWTException
* <ul>
* <li>ERROR_GRAPHIC_DISPOSED - if the receiver has been
* disposed</li>
* </ul>
*/
public void setClipping(int x, int y, int width, int height) {
// TODO
}
/**
* Sets the area of the receiver which can be changed by drawing operations
* to the path specified by the argument.
* <p>
* This operation requires the operating system's advanced graphics
* subsystem which may not be available on some platforms.
* </p>
*
* @param path
* the clipping path.
*
* @exception IllegalArgumentException
* <ul>
* <li>ERROR_INVALID_ARGUMENT - if the path has been disposed
* </li>
* </ul>
* @exception SWTException
* <ul>
* <li>ERROR_GRAPHIC_DISPOSED - if the receiver has been
* disposed</li>
* <li>ERROR_NO_GRAPHICS_LIBRARY - if advanced graphics are
* not available</li>
* </ul>
*
* @see Path
* @see #getAdvanced
* @see #setAdvanced
*
* @since 3.1
*/
public void setClipping(Path path) {
// TODO
}
/**
* Sets the area of the receiver which can be changed by drawing operations
* to the rectangular area specified by the argument. Specifying
* <code>null</code> for the rectangle reverts the receiver's clipping area
* to its original value.
*
* @param rect
* the clipping rectangle or <code>null</code>
*
* @exception SWTException
* <ul>
* <li>ERROR_GRAPHIC_DISPOSED - if the receiver has been
* disposed</li>
* </ul>
*/
public void setClipping(Rectangle rect) {
// TODO
}
/**
* Sets the area of the receiver which can be changed by drawing operations
* to the region specified by the argument. Specifying <code>null</code> for
* the region reverts the receiver's clipping area to its original value.
*
* @param region
* the clipping region or <code>null</code>
*
* @exception IllegalArgumentException
* <ul>
* <li>ERROR_INVALID_ARGUMENT - if the region has been
* disposed</li>
* </ul>
* @exception SWTException
* <ul>
* <li>ERROR_GRAPHIC_DISPOSED - if the receiver has been
* disposed</li>
* </ul>
*/
public void setClipping(Region region) {
// TODO
}
/**
* Sets the font which will be used by the receiver to draw and measure text
* to the argument. If the argument is null, then a default font appropriate
* for the platform will be used instead.
*
* @param font
* the new font for the receiver, or null to indicate a default
* font
*
* @exception IllegalArgumentException
* <ul>
* <li>ERROR_INVALID_ARGUMENT - if the font has been disposed
* </li>
* </ul>
* @exception SWTException
* <ul>
* <li>ERROR_GRAPHIC_DISPOSED - if the receiver has been
* disposed</li>
* </ul>
*/
public void setFont(Font font) {
// TODO
}
/**
* Sets the receiver's fill rule to the parameter, which must be one of
* <code>SWT.FILL_EVEN_ODD</code> or <code>SWT.FILL_WINDING</code>.
*
* @param rule
* the new fill rule
*
* @exception IllegalArgumentException
* <ul>
* <li>ERROR_INVALID_ARGUMENT - if the rule is not one of
* <code>SWT.FILL_EVEN_ODD</code> or
* <code>SWT.FILL_WINDING</code></li>
* </ul>
* @exception SWTException
* <ul>
* <li>ERROR_GRAPHIC_DISPOSED - if the receiver has been
* disposed</li>
* </ul>
*
* @since 3.1
*/
public void setFillRule(int rule) {
// TODO
}
/**
* Sets the foreground color. The foreground color is used for drawing
* operations including when text is drawn.
*
* @param color
* the new foreground color for the receiver
*
* @exception IllegalArgumentException
* <ul>
* <li>ERROR_NULL_ARGUMENT - if the color is null</li>
* <li>ERROR_INVALID_ARGUMENT - if the color has been
* disposed</li>
* </ul>
* @exception SWTException
* <ul>
* <li>ERROR_GRAPHIC_DISPOSED - if the receiver has been
* disposed</li>
* </ul>
*/
public void setForeground(Color color) {
// TODO
}
/**
* Sets the foreground pattern. The default value is <code>null</code>.
* <p>
* This operation requires the operating system's advanced graphics
* subsystem which may not be available on some platforms.
* </p>
*
* @param pattern
* the new foreground pattern
*
* @exception IllegalArgumentException
* <ul>
* <li>ERROR_INVALID_ARGUMENT - if the parameter has been
* disposed</li>
* </ul>
* @exception SWTException
* <ul>
* <li>ERROR_GRAPHIC_DISPOSED - if the receiver has been
* disposed</li>
* <li>ERROR_NO_GRAPHICS_LIBRARY - if advanced graphics are
* not available</li>
* </ul>
*
* @see Pattern
* @see #getAdvanced
* @see #setAdvanced
*
* @since 3.1
*/
public void setForegroundPattern(Pattern pattern) {
// TODO
}
/**
* Sets the receiver's interpolation setting to the parameter, which must be
* one of <code>SWT.DEFAULT</code>, <code>SWT.NONE</code>,
* <code>SWT.LOW</code> or <code>SWT.HIGH</code>.
* <p>
* This operation requires the operating system's advanced graphics
* subsystem which may not be available on some platforms.
* </p>
*
* @param interpolation
* the new interpolation setting
*
* @exception IllegalArgumentException
* <ul>
* <li>ERROR_INVALID_ARGUMENT - if the rule is not one of
* <code>SWT.DEFAULT</code>, <code>SWT.NONE</code>,
* <code>SWT.LOW</code> or <code>SWT.HIGH</code>
* </ul>
* @exception SWTException
* <ul>
* <li>ERROR_GRAPHIC_DISPOSED - if the receiver has been
* disposed</li>
* <li>ERROR_NO_GRAPHICS_LIBRARY - if advanced graphics are
* not available</li>
* </ul>
*
* @see #getAdvanced
* @see #setAdvanced
*
* @since 3.1
*/
public void setInterpolation(int interpolation) {
// TODO
}
/**
* Sets the receiver's line attributes.
* <p>
* This operation requires the operating system's advanced graphics
* subsystem which may not be available on some platforms.
* </p>
*
* @param attributes
* the line attributes
*
* @exception IllegalArgumentException
* <ul>
* <li>ERROR_NULL_ARGUMENT - if the attributes is null</li>
* <li>ERROR_INVALID_ARGUMENT - if any of the line attributes
* is not valid</li>
* </ul>
* @exception SWTException
* <ul>
* <li>ERROR_GRAPHIC_DISPOSED - if the receiver has been
* disposed</li>
* <li>ERROR_NO_GRAPHICS_LIBRARY - if advanced graphics are
* not available</li>
* </ul>
*
* @see LineAttributes
* @see #getAdvanced
* @see #setAdvanced
*
* @since 3.3
*/
public void setLineAttributes(LineAttributes attributes) {
// TODO
}
/**
* Sets the receiver's 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 cap style to be used for drawing lines
*
* @exception IllegalArgumentException
* <ul>
* <li>ERROR_INVALID_ARGUMENT - if the style is not valid</li>
* </ul>
* @exception SWTException
* <ul>
* <li>ERROR_GRAPHIC_DISPOSED - if the receiver has been
* disposed</li>
* </ul>
*
* @since 3.1
*/
public void setLineCap(int cap) {
// TODO
}
/**
* Sets the receiver's line dash style to the argument. The default value is
* <code>null</code>. If the argument is not <code>null</code>, the
* receiver's line style is set to <code>SWT.LINE_CUSTOM</code>, otherwise
* it is set to <code>SWT.LINE_SOLID</code>.
*
* @param dashes
* the dash style to be used for drawing lines
*
* @exception IllegalArgumentException
* <ul>
* <li>ERROR_INVALID_ARGUMENT - if any of the values in the
* array is less than or equal 0</li>
* </ul>
* @exception SWTException
* <ul>
* <li>ERROR_GRAPHIC_DISPOSED - if the receiver has been
* disposed</li>
* </ul>
*
* @since 3.1
*/
public void setLineDash(int[] dashes) {
// TODO
}
/**
* Sets the receiver's 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 style to be used for drawing lines
*
* @exception IllegalArgumentException
* <ul>
* <li>ERROR_INVALID_ARGUMENT - if the style is not valid</li>
* </ul>
* @exception SWTException
* <ul>
* <li>ERROR_GRAPHIC_DISPOSED - if the receiver has been
* disposed</li>
* </ul>
*
* @since 3.1
*/
public void setLineJoin(int join) {
// TODO
}
/**
* Sets the receiver's 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 lineStyle
* the style to be used for drawing lines
*
* @exception IllegalArgumentException
* <ul>
* <li>ERROR_INVALID_ARGUMENT - if the style is not valid</li>
* </ul>
* @exception SWTException
* <ul>
* <li>ERROR_GRAPHIC_DISPOSED - if the receiver has been
* disposed</li>
* </ul>
*/
public void setLineStyle(int lineStyle) {
// TODO
}
/**
* Sets the width that will be used when drawing lines for all of the figure
* drawing operations (that is, <code>drawLine</code>,
* <code>drawRectangle</code>, <code>drawPolyline</code>, and so forth.
* <p>
* Note that line width of zero is used as a hint to indicate that the
* fastest possible line drawing algorithms should be used. This means that
* the output may be different from line width one.
* </p>
*
* @param lineWidth
* the width of a line
*
* @exception SWTException
* <ul>
* <li>ERROR_GRAPHIC_DISPOSED - if the receiver has been
* disposed</li>
* </ul>
*/
public void setLineWidth(int lineWidth) {
// TODO
}
/**
* Sets the receiver's text 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.
* <p>
* This operation requires the operating system's advanced graphics
* subsystem which may not be available on some platforms.
* </p>
*
* @param antialias
* the anti-aliasing setting
*
* @exception IllegalArgumentException
* <ul>
* <li>ERROR_INVALID_ARGUMENT - if the parameter is not one
* of <code>SWT.DEFAULT</code>, <code>SWT.OFF</code> or
* <code>SWT.ON</code></li>
* </ul>
* @exception SWTException
* <ul>
* <li>ERROR_GRAPHIC_DISPOSED - if the receiver has been
* disposed</li>
* <li>ERROR_NO_GRAPHICS_LIBRARY - if advanced graphics are
* not available</li>
* </ul>
*
* @see #getAdvanced
* @see #setAdvanced
* @see #setAntialias
*
* @since 3.1
*/
public void setTextAntialias(int antialias) {
// TODO
}
/**
* Sets the transform that is currently being used by the receiver. If the
* argument is <code>null</code>, the current transform is set to the
* identity transform.
* <p>
* This operation requires the operating system's advanced graphics
* subsystem which may not be available on some platforms.
* </p>
*
* @param transform
* the transform to set
*
* @exception IllegalArgumentException
* <ul>
* <li>ERROR_INVALID_ARGUMENT - if the parameter has been
* disposed</li>
* </ul>
* @exception SWTException
* <ul>
* <li>ERROR_GRAPHIC_DISPOSED - if the receiver has been
* disposed</li>
* <li>ERROR_NO_GRAPHICS_LIBRARY - if advanced graphics are
* not available</li>
* </ul>
*
* @see Transform
* @see #getAdvanced
* @see #setAdvanced
*
* @since 3.1
*/
public void setTransform(Transform transform) {
// TODO
}
/**
* If the argument is <code>true</code>, puts the receiver in a drawing mode
* where the resulting color in the destination is the <em>exclusive or</em>
* of the color values in the source and the destination, and if the
* argument is <code>false</code>, puts the receiver in a drawing mode where
* the destination color is replaced with the source color value.
* <p>
* Note that this mode in fundamentally unsupportable on certain platforms,
* notably Carbon (Mac OS X). Clients that want their code to run on all
* platforms need to avoid this method.
* </p>
*
* @param xor
* if <code>true</code>, then <em>xor</em> mode is used,
* otherwise <em>source copy</em> mode is used
*
* @exception SWTException
* <ul>
* <li>ERROR_GRAPHIC_DISPOSED - if the receiver has been
* disposed</li>
* </ul>
*
* @deprecated this functionality is not supported on some platforms
*/
@Deprecated
public void setXORMode(boolean xor) {
// TODO or not
}
/**
* Returns the extent of the given string. No tab expansion or carriage
* return processing will be performed.
* <p>
* The <em>extent</em> of a string is the width and height of the
* rectangular area it would cover if drawn in a particular font (in this
* case, the current font in the receiver).
* </p>
*
* @param string
* the string to measure
* @return a point containing the extent of the string
*
* @exception IllegalArgumentException
* <ul>
* <li>ERROR_NULL_ARGUMENT - if the string is null</li>
* </ul>
* @exception SWTException
* <ul>
* <li>ERROR_GRAPHIC_DISPOSED - if the receiver has been
* disposed</li>
* </ul>
*/
public Point stringExtent(String string) {
// TODO
return null;
}
/**
* Returns the extent of the given string. Tab expansion and carriage return
* processing are performed.
* <p>
* The <em>extent</em> of a string is the width and height of the
* rectangular area it would cover if drawn in a particular font (in this
* case, the current font in the receiver).
* </p>
*
* @param string
* the string to measure
* @return a point containing the extent of the string
*
* @exception IllegalArgumentException
* <ul>
* <li>ERROR_NULL_ARGUMENT - if the string is null</li>
* </ul>
* @exception SWTException
* <ul>
* <li>ERROR_GRAPHIC_DISPOSED - if the receiver has been
* disposed</li>
* </ul>
*/
public Point textExtent(String string) {
// TODO
return null;
}
/**
* Returns the extent of the given string. Tab expansion, line delimiter and
* mnemonic processing are performed according to the specified flags, which
* can be a combination of:
* <dl>
* <dt><b>DRAW_DELIMITER</b></dt>
* <dd>draw multiple lines</dd>
* <dt><b>DRAW_TAB</b></dt>
* <dd>expand tabs</dd>
* <dt><b>DRAW_MNEMONIC</b></dt>
* <dd>underline the mnemonic character</dd>
* <dt><b>DRAW_TRANSPARENT</b></dt>
* <dd>transparent background</dd>
* </dl>
* <p>
* The <em>extent</em> of a string is the width and height of the
* rectangular area it would cover if drawn in a particular font (in this
* case, the current font in the receiver).
* </p>
*
* @param string
* the string to measure
* @param flags
* the flags specifying how to process the text
* @return a point containing the extent of the string
*
* @exception IllegalArgumentException
* <ul>
* <li>ERROR_NULL_ARGUMENT - if the string is null</li>
* </ul>
* @exception SWTException
* <ul>
* <li>ERROR_GRAPHIC_DISPOSED - if the receiver has been
* disposed</li>
* </ul>
*/
public Point textExtent(String string, int flags) {
// TODO
return null;
}
}