Java/SWT JFace Eclipse/2D
Содержание
- 1 Alpha Fade In
- 2 Animations Example
- 3 Class Analyzer
- 4 Demonstrates animation
- 5 Demonstrates animation. It uses double buffering.
- 6 Demonstrates drawing an Arc
- 7 Demonstrates drawing lines
- 8 Demonstrates drawing ovals
- 9 Demonstrates drawing points. It draws a sine wave
- 10 Demonstrates drawing polygons
- 11 Demonstrates how to draw text
- 12 Demonstrates how to draw text in colors
- 13 Demonstrates how to draw vertical text
- 14 Demonstrates the effects of the flags on the constructor
- 15 Displays information about the display device
- 16 Draw2D Sample
- 17 Drawings
- 18 Drawing with transformations, paths and alpha blending
- 19 Draw lines and polygons with different cap and join styles
- 20 Draw Round Rectangle
- 21 Draw Text Demo
- 22 GC Creation
- 23 GC example: draw a thick line
- 24 GC: implement a simple scribble program
- 25 GC: measure a string
- 26 How to draw directly on an SWT Control
- 27 Palettes
- 28 SWT 2D Chart: Flowchart
- 29 SWT 2D Simple Demo
- 30 SWT 2D Unicode
- 31 SWT Draw 2D
- 32 SWT Draw2D Example
- 33 SWT Graphics Example
- 34 SWT OpenGL snippet: draw a square
- 35 SWT Paint Example
- 36 SWT useful utilities
- 37 Transparency
- 38 Use of Java2D on SWT or Draw2D graphical context
- 39 Utility methods for drawing graphics
- 40 XOR
Alpha Fade In
<source lang="java">
/******************************************************************************
* All Right Reserved. * Copyright (c) 1998, 2004 Jackwind Li Guojie * * Created on 2004-4-21 22:36:43 by JACK * $Id$ * *****************************************************************************/
import org.eclipse.swt.SWT; import org.eclipse.swt.events.PaintEvent; import org.eclipse.swt.events.PaintListener; import org.eclipse.swt.graphics.Image; import org.eclipse.swt.graphics.ImageData; import org.eclipse.swt.layout.FillLayout; import org.eclipse.swt.widgets.Canvas; import org.eclipse.swt.widgets.Display; import org.eclipse.swt.widgets.Shell; public class AlphaFadeIn {
Display display = new Display();
Shell shell = new Shell(display);
public AlphaFadeIn() {
shell.setLayout(new FillLayout());
final Canvas canvas = new Canvas(shell, SWT.NULL);
ImageData imageData = new ImageData("jexp.gif");
ImageData imageData2 = imageData.scaledTo(100, 100);
Image image2 = new Image(display, imageData2);
byte[] alphaValues = new byte[imageData.height * imageData.width];
for(int j=0; j<imageData.height; j++) {
for(int i=0; i<imageData.width; i++) {
alphaValues[j*imageData.width + i] = (byte) (255 - 255 * i / imageData.width);
}
}
imageData.alphaData = alphaValues;
final Image image = new Image(display, imageData);
canvas.addPaintListener(new PaintListener() {
public void paintControl(PaintEvent e) {
e.gc.drawImage(image, 10, 10);
}
});
shell.setSize(200, 100);
shell.open();
//textUser.forceFocus();
// Set up the event loop.
while (!shell.isDisposed()) {
if (!display.readAndDispatch()) {
// If no more entries in event queue
display.sleep();
}
}
display.dispose();
}
private void init() {
}
public static void main(String[] args) {
new AlphaFadeIn();
}
}
</source>
Animations Example
<source lang="java">
/*******************************************************************************
* All Right Reserved. Copyright (c) 1998, 2004 Jackwind Li Guojie * * Created on 2004-4-22 11:06:42 by JACK $Id$ * ******************************************************************************/
import org.eclipse.swt.SWT; import org.eclipse.swt.events.PaintEvent; import org.eclipse.swt.events.PaintListener; import org.eclipse.swt.events.ShellAdapter; import org.eclipse.swt.events.ShellEvent; import org.eclipse.swt.events.ShellListener; import org.eclipse.swt.graphics.GC; import org.eclipse.swt.graphics.Image; import org.eclipse.swt.graphics.ImageData; import org.eclipse.swt.graphics.ImageLoader; import org.eclipse.swt.layout.FillLayout; import org.eclipse.swt.widgets.Canvas; import org.eclipse.swt.widgets.Display; import org.eclipse.swt.widgets.Shell; public class Animations {
Display display = new Display();
Shell shell = new Shell(display);
public Animations() {
shell.setLayout(new FillLayout());
ImageLoader imageLoader = new ImageLoader();
final ImageData[] imageDatas = imageLoader.load("jexp.gif");
final Image image = new Image(display, imageDatas[0].width, imageDatas[0].height);
final Canvas canvas = new Canvas(shell, SWT.NULL);
canvas.addPaintListener(new PaintListener() {
public void paintControl(PaintEvent e) {
e.gc.drawImage(image, 0, 0);
}
});
final GC gc = new GC(image);
final Thread thread = new Thread() {
int frameIndex = 0;
public void run() {
while (!isInterrupted()) {
frameIndex %= imageDatas.length;
final ImageData frameData = imageDatas[frameIndex];
display.asyncExec(new Runnable() {
public void run() {
Image frame =
new Image(display, frameData);
gc.drawImage(frame, frameData.x, frameData.y);
frame.dispose();
canvas.redraw();
}
});
try {
// delay
Thread.sleep(imageDatas[frameIndex].delayTime * 10);
} catch (InterruptedException e) {
return;
}
frameIndex += 1;
}
}
};
shell.addShellListener(new ShellAdapter() {
public void shellClosed(ShellEvent e) {
thread.interrupt();
}
});
shell.setSize(400, 200);
shell.open();
thread.start();
// Set up the event loop.
while (!shell.isDisposed()) {
if (!display.readAndDispatch()) {
// If no more entries in event queue
display.sleep();
}
}
display.dispose();
}
private void init() {
}
public static void main(String[] args) {
new Animations();
}
}
</source>
Class Analyzer
<source lang="java">
/*******************************************************************************
* All Right Reserved. Copyright (c) 1998, 2004 Jackwind Li Guojie * * Created on 2004-7-4 19:32:27 by JACK $Id$ * ******************************************************************************/
import java.lang.reflect.Field; import java.lang.reflect.Method; import java.lang.reflect.Modifier; import org.eclipse.draw2d.AbstractBorder; import org.eclipse.draw2d.ChopboxAnchor; import org.eclipse.draw2d.ColorConstants; import org.eclipse.draw2d.Figure; import org.eclipse.draw2d.Graphics; import org.eclipse.draw2d.IFigure; import org.eclipse.draw2d.Label; import org.eclipse.draw2d.LightweightSystem; import org.eclipse.draw2d.LineBorder; import org.eclipse.draw2d.MouseListener; import org.eclipse.draw2d.PolygonDecoration; import org.eclipse.draw2d.PolylineConnection; import org.eclipse.draw2d.ToolbarLayout; import org.eclipse.draw2d.XYLayout; import org.eclipse.draw2d.geometry.Insets; import org.eclipse.draw2d.geometry.PointList; import org.eclipse.draw2d.geometry.Rectangle; import org.eclipse.jface.action.Action; import org.eclipse.jface.dialogs.Dialog; import org.eclipse.jface.dialogs.InputDialog; import org.eclipse.jface.resource.ImageDescriptor; import org.eclipse.jface.resource.ImageRegistry; import org.eclipse.jface.window.ApplicationWindow; import org.eclipse.swt.SWT; import org.eclipse.swt.graphics.Image; import org.eclipse.swt.layout.FillLayout; import org.eclipse.swt.widgets.Canvas; import org.eclipse.swt.widgets.ruposite; import org.eclipse.swt.widgets.Control; import org.eclipse.swt.widgets.Display; import org.eclipse.swt.widgets.Shell; import org.eclipse.swt.widgets.Text; class ClassFigure extends Figure {
ImageRegistry registry = new ImageRegistry();
// image keys.
String KEY_CLASS = "class";
String KEY_METHOD_PUBLIC = "method_public";
String KEY_METHOD_DEFAULT = "method_default";
String KEY_METHOD_PROTECTED = "method_protected";
String KEY_METHOD_PRIVATE = "method_private";
String KEY_FIELD_PUBLIC = "field_public";
String KEY_FIELD_DEFAULT = "field_default";
String KEY_FIELD_PROTECTED = "field_protected";
String KEY_FIELD_PRIVATE = "field_private";
String[] keys =
{
KEY_CLASS,
KEY_METHOD_PUBLIC,
KEY_METHOD_DEFAULT,
KEY_METHOD_PROTECTED,
KEY_METHOD_PRIVATE,
KEY_FIELD_PUBLIC,
KEY_FIELD_DEFAULT,
KEY_FIELD_PROTECTED,
KEY_FIELD_PRIVATE };
public Box fieldBox = new Box();
public Box methodBox = new Box();
public ClassFigure(Class cls) {
setLayoutManager(new ToolbarLayout());
setBorder(new LineBorder(ColorConstants.black));
setBackgroundColor(ColorConstants.yellow);
setOpaque(true);
for (int i = 0; i < keys.length; i++)
registry.put(
keys[i],
ImageDescriptor.createFromFile(
null,
"icons/java/" + keys[i] + ".gif"));
Label title = new Label(cls.getName(), registry.get(KEY_CLASS));
add(title);
add(fieldBox);
add(methodBox);
// fields.
Field[] fields = cls.getDeclaredFields();
for (int i = 0; i < fields.length; i++) {
Field field = fields[i];
Image image = null;
if (Modifier.isPublic(field.getModifiers())) {
image = registry.get(KEY_FIELD_PUBLIC);
} else if (Modifier.isProtected(field.getModifiers())) {
image = registry.get(KEY_FIELD_PROTECTED);
} else if (Modifier.isPrivate(field.getModifiers())) {
image = registry.get(KEY_FIELD_PRIVATE);
} else {
image = registry.get(KEY_FIELD_DEFAULT);
}
fieldBox.add(new Label(fields[i].getName(), image));
}
// fields.
Method[] methods = cls.getDeclaredMethods();
for (int i = 0; i < methods.length; i++) {
Method method = methods[i];
Image image = null;
if (Modifier.isPublic(method.getModifiers())) {
image = registry.get(KEY_METHOD_PUBLIC);
} else if (Modifier.isProtected(method.getModifiers())) {
image = registry.get(KEY_METHOD_PROTECTED);
} else if (Modifier.isPrivate(method.getModifiers())) {
image = registry.get(KEY_METHOD_PRIVATE);
} else {
image = registry.get(KEY_METHOD_DEFAULT);
}
methodBox.add(new Label(methods[i].getName(), image));
}
}
} class Box extends Figure {
public Box() {
setBorder(new BoxBorder());
ToolbarLayout toolbarLayout = new ToolbarLayout();
toolbarLayout.setStretchMinorAxis(false);
setLayoutManager(toolbarLayout);
}
private class BoxBorder extends AbstractBorder {
/*
* (non-Javadoc)
*
* @see org.eclipse.draw2d.Border#getInsets(org.eclipse.draw2d.IFigure)
*/
public Insets getInsets(IFigure figure) {
return new Insets(1, 0, 0, 0);
}
/*
* (non-Javadoc)
*
* @see org.eclipse.draw2d.Border#paint(org.eclipse.draw2d.IFigure,
* org.eclipse.draw2d.Graphics,
* org.eclipse.draw2d.geometry.Insets)
*/
public void paint(IFigure figure, Graphics graphics, Insets insets) {
Rectangle rect = getPaintRectangle(figure, insets);
graphics.drawLine(rect.getTopLeft(), rect.getTopRight());
}
}
} /**
* */
public class ClassAnalyzer extends ApplicationWindow {
Text className;
Canvas canvas;
Figure contents;
XYLayout xyLayout;
/**
* @param parentShell
*/
public ClassAnalyzer(Shell parentShell) {
super(parentShell);
addToolBar(SWT.NULL);
}
private void showClass(Class cls) {
if (cls == null)
return;
// removes all existing items.
contents.removeAll();
// draws super class.
Label sup = null;
if (cls.getSuperclass() != null) {
final Class superClass = cls.getSuperclass();
sup = new Label(superClass.getName());
sup.setBorder(new LineBorder());
sup.setBackgroundColor(ColorConstants.lightGreen);
sup.setOpaque(true);
sup.addMouseListener(new MouseListener() {
public void mousePressed(org.eclipse.draw2d.MouseEvent me) {
}
public void mouseReleased(org.eclipse.draw2d.MouseEvent me) {
}
public void mouseDoubleClicked(
org.eclipse.draw2d.MouseEvent me) {
showClass(superClass);
}
});
}
if (sup != null) {
contents.add(sup);
xyLayout.setConstraint(sup, new Rectangle(20, 20, -1, -1));
}
ClassFigure classFigure = new ClassFigure(cls);
contents.add(classFigure);
if (sup == null)
xyLayout.setConstraint(classFigure, new Rectangle(20, 20, -1, -1));
else
xyLayout.setConstraint(
classFigure,
new Rectangle(20, sup.getBounds().height + 40, -1, -1));
// adds connection.
if (sup != null) {
PolylineConnection connection = new PolylineConnection();
ChopboxAnchor source = new ChopboxAnchor(classFigure);
ChopboxAnchor target = new ChopboxAnchor(sup);
connection.setSourceAnchor(source);
connection.setTargetAnchor(target);
PolygonDecoration decoration = new PolygonDecoration();
PointList list = new PointList();
list.addPoint(-2, -2);
list.addPoint(0, 0);
list.addPoint(-2, 2);
decoration.setTemplate(list);
connection.setTargetDecoration(decoration);
contents.add(connection);
}
// resizes the shell.
getShell().setSize(
contents.getPreferredSize().width + 30,
contents.getPreferredSize().height + 80);
}
/*
* (non-Javadoc)
*
* @see org.eclipse.jface.window.Window#createContents(org.eclipse.swt.widgets.ruposite)
*/
protected Control createContents(Composite parent) {
Composite composite = new Composite(parent, SWT.NULL);
composite.setLayout(new FillLayout());
canvas = new Canvas(composite, SWT.NULL);
canvas.setBackground(getShell().getDisplay().getSystemColor(SWT.COLOR_WHITE));
LightweightSystem lws = new LightweightSystem(canvas);
contents = new Figure();
xyLayout = new XYLayout();
contents.setLayoutManager(xyLayout);
lws.setContents(contents);
showClass(this.getClass());
// Creates tool bar items.
getToolBarManager().add(new Action("Set class ...") {
public void run() {
InputDialog dialog =
new InputDialog(
getShell(),
"",
"Please enter the class name",
"",
null);
if (dialog.open() != Dialog.OK)
return;
contents.removeAll();
Class cls = null;
try {
cls = Class.forName(dialog.getValue());
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
if (cls != null) {
showClass(cls);
}
}
});
getToolBarManager().update(true);
return composite;
}
public static void main(String[] args) {
ClassAnalyzer window = new ClassAnalyzer(null);
window.setBlockOnOpen(true);
window.open();
Display.getCurrent().dispose();
}
}
</source>
Demonstrates animation
<source lang="java">
//Send questions, comments, bug reports, etc. to the authors: //Rob Warner (rwarner@interspatial.ru) //Robert Harris (rbrt_harris@yahoo.ru) import org.eclipse.swt.SWT; import org.eclipse.swt.events.*; import org.eclipse.swt.graphics.*; import org.eclipse.swt.layout.*; import org.eclipse.swt.widgets.*; /**
* This class demonstrates animation. */
public class Animator {
// The width (and height) of the image
private static final int IMAGE_WIDTH = 100;
// The timer interval in milliseconds
private static final int TIMER_INTERVAL = 10;
// The location of the "ball"
private int x = 0;
private int y = 0;
// The direction the "ball" is moving
private int directionX = 1;
private int directionY = 1;
// We draw everything on this canvas
private Canvas canvas;
/**
* Runs the application
*/
public void run() {
final Display display = new Display();
Shell shell = new Shell(display);
shell.setText("Animator");
createContents(shell);
shell.open();
// Set up the timer for the animation
Runnable runnable = new Runnable() {
public void run() {
animate();
display.timerExec(TIMER_INTERVAL, this);
}
};
// Launch the timer
display.timerExec(TIMER_INTERVAL, runnable);
while (!shell.isDisposed()) {
if (!display.readAndDispatch()) {
display.sleep();
}
}
// Kill the timer
display.timerExec(-1, runnable);
display.dispose();
}
/**
* Creates the main window"s contents
*
* @param shell the main window
*/
private void createContents(final Shell shell) {
shell.setLayout(new FillLayout());
// Create the canvas for drawing
canvas = new Canvas(shell, SWT.NO_BACKGROUND);
canvas.addPaintListener(new PaintListener() {
public void paintControl(PaintEvent event) {
// Draw the background
event.gc.fillRectangle(canvas.getBounds());
// Set the color of the ball
event.gc.setBackground(shell.getDisplay().getSystemColor(SWT.COLOR_RED));
// Draw the ball
event.gc.fillOval(x, y, IMAGE_WIDTH, IMAGE_WIDTH);
}
});
}
/**
* Animates the next frame
*/
public void animate() {
// Determine the ball"s location
x += directionX;
y += directionY;
// Determine out of bounds
Rectangle rect = canvas.getClientArea();
if (x < 0) {
x = 0;
directionX = 1;
} else if (x > rect.width - IMAGE_WIDTH) {
x = rect.width - IMAGE_WIDTH;
directionX = -1;
}
if (y < 0) {
y = 0;
directionY = 1;
} else if (y > rect.height - IMAGE_WIDTH) {
y = rect.height - IMAGE_WIDTH;
directionY = -1;
}
// Force a redraw
canvas.redraw();
}
/**
* The application entry point
*
* @param args the command line arguments
*/
public static void main(String[] args) {
new Animator().run();
}
}
</source>
Demonstrates animation. It uses double buffering.
<source lang="java">
//Send questions, comments, bug reports, etc. to the authors: //Rob Warner (rwarner@interspatial.ru) //Robert Harris (rbrt_harris@yahoo.ru) import org.eclipse.swt.SWT; import org.eclipse.swt.events.*; import org.eclipse.swt.graphics.*; import org.eclipse.swt.layout.*; import org.eclipse.swt.widgets.*; /**
* This class demonstrates animation. It uses double buffering */
public class AnimatorDoubleBuffer {
// The width (and height) of the image
private static final int IMAGE_WIDTH = 100;
// The timer interval in milliseconds
private static final int TIMER_INTERVAL = 10;
// The location of the "ball"
private int x = 0;
private int y = 0;
// The direction the "ball" is moving
private int directionX = 1;
private int directionY = 1;
// We draw everything on this canvas
private Canvas canvas;
/**
* Runs the application
*/
public void run() {
final Display display = new Display();
Shell shell = new Shell(display);
shell.setText("Animator Double Buffer");
createContents(shell);
shell.open();
// Set up the timer for the animation
Runnable runnable = new Runnable() {
public void run() {
animate();
display.timerExec(TIMER_INTERVAL, this);
}
};
// Launch the timer
display.timerExec(TIMER_INTERVAL, runnable);
while (!shell.isDisposed()) {
if (!display.readAndDispatch()) {
display.sleep();
}
}
// Kill the timer
display.timerExec(-1, runnable);
display.dispose();
}
/**
* Creates the main window"s contents
*
* @param shell the main window
*/
private void createContents(final Shell shell) {
shell.setLayout(new FillLayout());
// Create the canvas for drawing
canvas = new Canvas(shell, SWT.NO_BACKGROUND);
canvas.addPaintListener(new PaintListener() {
public void paintControl(PaintEvent event) {
// Create the image to fill the canvas
Image image = new Image(shell.getDisplay(), canvas.getBounds());
// Set up the offscreen gc
GC gcImage = new GC(image);
// Draw the background
gcImage.setBackground(event.gc.getBackground());
gcImage.fillRectangle(image.getBounds());
// Set the color of the ball
gcImage.setBackground(shell.getDisplay().getSystemColor(SWT.COLOR_RED));
// Draw the ball
gcImage.fillOval(x, y, IMAGE_WIDTH, IMAGE_WIDTH);
// Draw the offscreen buffer to the screen
event.gc.drawImage(image, 0, 0);
// Clean up
image.dispose();
gcImage.dispose();
}
});
}
/**
* Animates the next frame
*/
public void animate() {
// Determine the ball"s location
x += directionX;
y += directionY;
// Determine out of bounds
Rectangle rect = canvas.getClientArea();
if (x < 0) {
x = 0;
directionX = 1;
} else if (x > rect.width - IMAGE_WIDTH) {
x = rect.width - IMAGE_WIDTH;
directionX = -1;
}
if (y < 0) {
y = 0;
directionY = 1;
} else if (y > rect.height - IMAGE_WIDTH) {
y = rect.height - IMAGE_WIDTH;
directionY = -1;
}
// Force a redraw
canvas.redraw();
}
/**
* The application entry point
*
* @param args the command line arguments
*/
public static void main(String[] args) {
new AnimatorDoubleBuffer().run();
}
}
</source>
Demonstrates drawing an Arc
<source lang="java">
//Send questions, comments, bug reports, etc. to the authors: //Rob Warner (rwarner@interspatial.ru) //Robert Harris (rbrt_harris@yahoo.ru) import org.eclipse.swt.SWT; import org.eclipse.swt.events.*; import org.eclipse.swt.layout.*; import org.eclipse.swt.widgets.*; /**
* This class demonstrates drawing an Arc */
public class ArcExample {
private Text txtWidth = null;
private Text txtHeight = null;
private Text txtBeginAngle = null;
private Text txtAngle = null;
/**
* Runs the application
*/
public void run() {
Display display = new Display();
Shell shell = new Shell(display);
shell.setText("Arc Example");
createContents(shell);
shell.open();
while (!shell.isDisposed()) {
if (!display.readAndDispatch()) {
display.sleep();
}
}
display.dispose();
}
/**
* Creates the main window"s contents
*
* @param shell the main window
*/
private void createContents(Shell shell) {
shell.setLayout(new FillLayout(SWT.VERTICAL));
// Create the composite that holds the input fields
Composite widgetComposite = new Composite(shell, SWT.NONE);
widgetComposite.setLayout(new GridLayout(2, false));
// Create the input fields
new Label(widgetComposite, SWT.NONE).setText("Width:");
txtWidth = new Text(widgetComposite, SWT.BORDER);
new Label(widgetComposite, SWT.NONE).setText("Height");
txtHeight = new Text(widgetComposite, SWT.BORDER);
new Label(widgetComposite, SWT.NONE).setText("Begin Angle:");
txtBeginAngle = new Text(widgetComposite, SWT.BORDER);
new Label(widgetComposite, SWT.NONE).setText("Angle:");
txtAngle = new Text(widgetComposite, SWT.BORDER);
// Create the button that launches the redraw
Button button = new Button(widgetComposite, SWT.PUSH);
button.setText("Redraw");
shell.setDefaultButton(button);
// Create the canvas to draw the arc on
final Canvas drawingCanvas = new Canvas(shell, SWT.NONE);
drawingCanvas.addPaintListener(new ArcExamplePaintListener());
// Add a handler to redraw the arc when pressed
button.addSelectionListener(new SelectionAdapter() {
public void widgetSelected(SelectionEvent e) {
drawingCanvas.redraw();
}
});
}
/**
* This class gets the user input and draws the requested arc
*/
private class ArcExamplePaintListener implements PaintListener {
public void paintControl(PaintEvent e) {
// Get the canvas for drawing and its dimensions
Canvas canvas = (Canvas) e.widget;
int x = canvas.getBounds().width;
int y = canvas.getBounds().height;
// Determine user input, defaulting everything to zero.
// Any blank fields are converted to zero
int width = 0;
int height = 0;
int begin = 0;
int angle = 0;
try {
width = txtWidth.getText().length() == 0 ? 0 : Integer.parseInt(txtWidth
.getText());
height = txtHeight.getText().length() == 0 ? 0 : Integer
.parseInt(txtHeight.getText());
begin = txtBeginAngle.getText().length() == 0 ? 0 : Integer
.parseInt(txtBeginAngle.getText());
angle = txtAngle.getText().length() == 0 ? 0 : Integer.parseInt(txtAngle
.getText());
} catch (NumberFormatException ex) {
// Any problems, reset them all to zero
width = 0;
height = 0;
begin = 0;
angle = 0;
}
// Set the drawing color to black
e.gc.setBackground(e.display.getSystemColor(SWT.COLOR_BLACK));
// Draw the arc, centered on the canvas
e.gc
.fillArc((x - width) / 2, (y - height) / 2, width, height, begin, angle);
}
}
/**
* The application entry point
*
* @param args the command line arguments
*/
public static void main(String[] args) {
new ArcExample().run();
}
}
</source>
Demonstrates drawing lines
<source lang="java">
//Send questions, comments, bug reports, etc. to the authors: //Rob Warner (rwarner@interspatial.ru) //Robert Harris (rbrt_harris@yahoo.ru) import org.eclipse.swt.*; import org.eclipse.swt.events.*; import org.eclipse.swt.widgets.*; import org.eclipse.swt.layout.*; /**
* This class demonstrates drawing lines */
public class LineExample {
/**
* Runs the application
*/
public void run() {
Display display = new Display();
Shell shell = new Shell(display);
shell.setText("Line Example");
createContents(shell);
shell.open();
while (!shell.isDisposed()) {
if (!display.readAndDispatch()) {
display.sleep();
}
}
display.dispose();
}
/**
* Creates the main window"s contents
*
* @param shell the main window
*/
private void createContents(Shell shell) {
shell.setLayout(new FillLayout());
// Create a canvas to draw on
Canvas canvas = new Canvas(shell, SWT.NONE);
// Add a handler to do the drawing
canvas.addPaintListener(new PaintListener() {
public void paintControl(PaintEvent e) {
// Get the canvas and its size
Canvas canvas = (Canvas) e.widget;
int maxX = canvas.getSize().x;
int maxY = canvas.getSize().y;
// Calculate the middle
int halfX = (int) maxX / 2;
int halfY = (int) maxY / 2;
// Set the drawing color to blue
e.gc.setForeground(e.display.getSystemColor(SWT.COLOR_BLUE));
// Set the width of the lines to draw
e.gc.setLineWidth(10);
// Draw a vertical line halfway across the canvas
e.gc.drawLine(halfX, 0, halfX, maxY);
// Draw a horizontal line halfway down the canvas
e.gc.drawLine(0, halfY, maxX, halfY);
}
});
}
/**
* The application entry point
*
* @param args the command line arguments
*/
public static void main(String[] args) {
new LineExample().run();
}
}
</source>
Demonstrates drawing ovals
<source lang="java">
//Send questions, comments, bug reports, etc. to the authors: //Rob Warner (rwarner@interspatial.ru) //Robert Harris (rbrt_harris@yahoo.ru) import org.eclipse.swt.SWT; import org.eclipse.swt.events.*; import org.eclipse.swt.layout.*; import org.eclipse.swt.widgets.*; /**
* This class demonstrates drawing ovals */
public class OvalExample {
private Text txtWidth = null;
private Text txtHeight = null;
/**
* Runs the application
*/
public void run() {
Display display = new Display();
Shell shell = new Shell(display);
shell.setText("Oval Example");
createContents(shell);
shell.open();
while (!shell.isDisposed()) {
if (!display.readAndDispatch()) {
display.sleep();
}
}
display.dispose();
}
/**
* Creates the main window"s contents
*
* @param shell the main window
*/
private void createContents(Shell shell) {
shell.setLayout(new FillLayout(SWT.VERTICAL));
// Create the composite that holds the input fields
Composite widgetComposite = new Composite(shell, SWT.NONE);
widgetComposite.setLayout(new GridLayout(2, false));
// Create the input fields
new Label(widgetComposite, SWT.NONE).setText("Width:");
txtWidth = new Text(widgetComposite, SWT.BORDER);
new Label(widgetComposite, SWT.NONE).setText("Height");
txtHeight = new Text(widgetComposite, SWT.BORDER);
// Create the button that launches the redraw
Button button = new Button(widgetComposite, SWT.PUSH);
button.setText("Redraw");
shell.setDefaultButton(button);
// Create the canvas to draw the oval on
final Canvas drawingCanvas = new Canvas(shell, SWT.NONE);
drawingCanvas.addPaintListener(new OvalExamplePaintListener());
// Add a handler to redraw the oval when pressed
button.addSelectionListener(new SelectionAdapter() {
public void widgetSelected(SelectionEvent e) {
drawingCanvas.redraw();
}
});
}
/**
* This class gets the user input and draws the requested oval
*/
private class OvalExamplePaintListener implements PaintListener {
public void paintControl(PaintEvent e) {
// Get the canvas for drawing and its width and height
Canvas canvas = (Canvas) e.widget;
int x = canvas.getBounds().width;
int y = canvas.getBounds().height;
// Determine user input, defaulting everything to zero.
// Any blank fields are converted to zero
int width = 0;
int height = 0;
try {
width = txtWidth.getText().length() == 0 ? 0 : Integer.parseInt(txtWidth
.getText());
height = txtHeight.getText().length() == 0 ? 0 : Integer
.parseInt(txtHeight.getText());
} catch (NumberFormatException ex) {
// Any problems, set them both to zero
width = 0;
height = 0;
}
// Set the drawing width for the oval
e.gc.setLineWidth(4);
// Draw the requested oval
e.gc.drawOval((x - width) / 2, (y - height) / 2, width, height);
}
}
/**
* The application entry point
*
* @param args the command line arguments
*/
public static void main(String[] args) {
new OvalExample().run();
}
}
</source>
Demonstrates drawing points. It draws a sine wave
<source lang="java">
//Send questions, comments, bug reports, etc. to the authors: //Rob Warner (rwarner@interspatial.ru) //Robert Harris (rbrt_harris@yahoo.ru) import org.eclipse.swt.SWT; import org.eclipse.swt.events.*; import org.eclipse.swt.layout.FillLayout; import org.eclipse.swt.widgets.*; /**
* This class demonstrates drawing points. It draws a sine wave. */
public class PointExample {
/**
* Runs the application
*/
public void run() {
Display display = new Display();
Shell shell = new Shell(display);
shell.setText("Point Example");
createContents(shell);
shell.open();
while (!shell.isDisposed()) {
if (!display.readAndDispatch()) {
display.sleep();
}
}
display.dispose();
}
/**
* Creates the main window"s contents
*
* @param shell the main window
*/
private void createContents(Shell shell) {
shell.setLayout(new FillLayout());
// Create the canvas for drawing on
Canvas canvas = new Canvas(shell, SWT.NONE);
// Add the paint handler to draw the sine wave
canvas.addPaintListener(new PointExamplePaintListener());
// Use a white background
canvas.setBackground(shell.getDisplay().getSystemColor(SWT.COLOR_WHITE));
}
/**
* This class draws a sine wave using points
*/
private class PointExamplePaintListener implements PaintListener {
public void paintControl(PaintEvent e) {
// Get the canvas and its dimensions
Canvas canvas = (Canvas) e.widget;
int maxX = canvas.getSize().x;
int maxY = canvas.getSize().y;
// Calculate the middle
int halfX = (int) maxX / 2;
int halfY = (int) maxY / 2;
// Set the line color and draw a horizontal axis
e.gc.setForeground(e.display.getSystemColor(SWT.COLOR_BLACK));
e.gc.drawLine(0, halfY, maxX, halfY);
// Draw the sine wave
for (int i = 0; i < maxX; i++) {
e.gc.drawPoint(i, getNormalizedSine(i, halfY, maxX));
}
}
/**
* Calculates the sine value
*
* @param x the value along the x-axis
* @param halfY the value of the y-axis
* @param maxX the width of the x-axis
* @return int
*/
int getNormalizedSine(int x, int halfY, int maxX) {
double piDouble = 2 * Math.PI;
double factor = piDouble / maxX;
return (int) (Math.sin(x * factor) * halfY + halfY);
}
}
/**
* The application entry point
*
* @param args the command line arguments
*/
public static void main(String[] args) {
new PointExample().run();
}
}
</source>
Demonstrates drawing polygons
<source lang="java">
//Send questions, comments, bug reports, etc. to the authors: //Rob Warner (rwarner@interspatial.ru) //Robert Harris (rbrt_harris@yahoo.ru) import org.eclipse.swt.SWT; import org.eclipse.swt.events.*; import org.eclipse.swt.layout.*; import org.eclipse.swt.widgets.*; /**
* This class demonstrates drawing polygons */
public class PolygonExample {
private Text txtWidth = null;
private Text txtHeight = null;
/**
* Runs the application
*/
public void run() {
Display display = new Display();
Shell shell = new Shell(display);
shell.setText("Polygon Example");
createContents(shell);
shell.open();
while (!shell.isDisposed()) {
if (!display.readAndDispatch()) {
display.sleep();
}
}
display.dispose();
}
/**
* Creates the main window"s contents
*
* @param shell the main window
*/
private void createContents(Shell shell) {
shell.setLayout(new FillLayout(SWT.VERTICAL));
// Create the canvas to draw the polygons on
Canvas drawingCanvas = new Canvas(shell, SWT.NONE);
drawingCanvas.addPaintListener(new PolygonExamplePaintListener());
}
/**
* This class gets the user input and draws the requested oval
*/
private class PolygonExamplePaintListener implements PaintListener {
public void paintControl(PaintEvent e) {
// Get the canvas for drawing and its dimensions
Canvas canvas = (Canvas) e.widget;
int x = canvas.getBounds().width;
int y = canvas.getBounds().height;
// Set the drawing color
e.gc.setBackground(e.display.getSystemColor(SWT.COLOR_BLACK));
// Create the points for drawing a triangle in the upper left
int[] upper_left = { 0, 0, 200, 0, 0, 200};
// Create the points for drawing a triangle in the lower right
int[] lower_right = { x, y, x, y - 200, x - 200, y};
// Draw the triangles
e.gc.fillPolygon(upper_left);
e.gc.fillPolygon(lower_right);
}
}
/**
* The application entry point
*
* @param args the command line arguments
*/
public static void main(String[] args) {
new PolygonExample().run();
}
}
</source>
Demonstrates how to draw text
<source lang="java">
//Send questions, comments, bug reports, etc. to the authors: //Rob Warner (rwarner@interspatial.ru) //Robert Harris (rbrt_harris@yahoo.ru) import org.eclipse.swt.SWT; import org.eclipse.swt.events.*; import org.eclipse.swt.graphics.*; import org.eclipse.swt.widgets.*; /**
* This class demonstrates how to draw text */
public class DrawText {
// The string to draw
private static final String HELLO = "Hello,\n&World!\tFrom SWT";
/**
* Runs the application
*/
public void run() {
Display display = new Display();
final Shell shell = new Shell(display);
// Load an image to use as the background
final Image image = new Image(display, this.getClass().getResourceAsStream(
"jexp.gif"));
shell.addPaintListener(new PaintListener() {
public void paintControl(PaintEvent event) {
/* Stretch the image to fill the window*/
Rectangle rect = shell.getClientArea();
event.gc.drawImage(image, 0, 0, image.getImageData().width, image
.getImageData().height, 0, 0, rect.width, rect.height);
// This will draw the string on one line, with non-printing characters
// for \n and \t, with an ampersand, and with an opaque background
event.gc.drawString(HELLO, 5, 0);
// This will draw the string on one line, with non-printing characters
// for \n and \t, with an ampersand, and with a transparent background
event.gc.drawString(HELLO, 5, 40, true);
// This will draw the string on two lines, with a tab between World! and
// From, with an ampersand, and with an opaque background
event.gc.drawText(HELLO, 5, 80);
// This will draw the string on two lines, with a tab between World! and
// From, with an ampersand, and with a transparent background
event.gc.drawText(HELLO, 5, 120, true);
// This will draw the string on two lines, with a tab between World! and
// From, with the W underlined, and with a transparent background
event.gc.drawText(HELLO, 5, 160, SWT.DRAW_MNEMONIC | SWT.DRAW_DELIMITER
| SWT.DRAW_TAB | SWT.DRAW_TRANSPARENT);
}
});
shell.setText("Draw Text");
shell.open();
while (!shell.isDisposed()) {
if (!display.readAndDispatch()) {
display.sleep();
}
}
image.dispose();
display.dispose();
}
/**
* The application entry point
*
* @param args the command line arguments
*/
public static void main(String[] args) {
new DrawText().run();
}
}
</source>
Demonstrates how to draw text in colors
<source lang="java">
//Send questions, comments, bug reports, etc. to the authors: //Rob Warner (rwarner@interspatial.ru) //Robert Harris (rbrt_harris@yahoo.ru) import org.eclipse.swt.SWT; import org.eclipse.swt.events.*; import org.eclipse.swt.widgets.*; /**
* This class demonstrates how to draw text in colors */
public class ColorFont {
// The color indices to use for the text
private static final int[] COLOR_INDICES = { SWT.COLOR_BLUE, SWT.COLOR_GREEN,
SWT.COLOR_RED, SWT.COLOR_GRAY};
/**
* Runs the application
*/
public void run() {
Display display = new Display();
final Shell shell = new Shell(display);
// Handler to do the drawing
shell.addPaintListener(new PaintListener() {
public void paintControl(PaintEvent event) {
// Loop through the colors, moving down the screen each iteration
for (int i = 0, n = COLOR_INDICES.length, y = 0, height = event.gc
.getFontMetrics().getHeight(); i < n; i++, y += height) {
event.gc.setForeground(shell.getDisplay().getSystemColor(
COLOR_INDICES[i]));
event.gc.drawText("Hooray for Color!", 0, y);
}
}
});
shell.setText("Color Font");
shell.open();
while (!shell.isDisposed()) {
if (!display.readAndDispatch()) {
display.sleep();
}
}
display.dispose();
}
/**
* The application entry point
*
* @param args the command line arguments
*/
public static void main(String[] args) {
new ColorFont().run();
}
}
</source>
Demonstrates how to draw vertical text
<source lang="java">
//Send questions, comments, bug reports, etc. to the authors: //Rob Warner (rwarner@interspatial.ru) //Robert Harris (rbrt_harris@yahoo.ru) import org.eclipse.swt.SWT; import org.eclipse.swt.events.*; import org.eclipse.swt.graphics.*; import org.eclipse.swt.widgets.*; /**
* This class demonstrates how to draw vertical text */
public class VerticalTextSpanish {
/**
* Runs the application
*/
public void run() {
Display display = new Display();
final Shell shell = new Shell(display);
final Font font = new Font(display, "Arial", 36, SWT.ITALIC);
// Create "Hello" image
final Image hello = GraphicsUtils.createRotatedText("Hola", font, shell
.getForeground(), shell.getBackground(), SWT.UP);
// Create "Good Bye" image
final Image goodBye = GraphicsUtils.createRotatedText("Chao Pescado", font,
shell.getForeground(), shell.getBackground(), SWT.DOWN);
shell.addPaintListener(new PaintListener() {
public void paintControl(PaintEvent event) {
// Set the font
event.gc.setFont(font);
// Draw hello in the upper left
event.gc.drawImage(hello, 0, 0);
// Draw good bye in the lower right
// Note how we calculate the origin
Rectangle rcImage = goodBye.getBounds();
Rectangle rect = shell.getClientArea();
event.gc.drawImage(goodBye, rect.width - rcImage.width, rect.height
- rcImage.height);
}
});
shell.setText("Vertical Text Spanish");
shell.open();
while (!shell.isDisposed()) {
if (!display.readAndDispatch()) {
display.sleep();
}
}
goodBye.dispose();
hello.dispose();
font.dispose();
display.dispose();
}
/**
* The application entry point
*
* @param args the command line arguments
*/
public static void main(String[] args) {
new VerticalTextSpanish().run();
}
}
</source>
Demonstrates the effects of the flags on the constructor
<source lang="java">
//Send questions, comments, bug reports, etc. to the authors: //Rob Warner (rwarner@interspatial.ru) //Robert Harris (rbrt_harris@yahoo.ru) import org.eclipse.swt.*; import org.eclipse.swt.graphics.*; import org.eclipse.swt.layout.*; import org.eclipse.swt.widgets.*; /**
* This class demonstrates the effects of the flags on the constructor:
*
* Image(Device device, Image srcImage, int flag)
*/
public class ShowImageFlags {
// Members to hold the images
private Image image;
private Image copy;
private Image disable;
private Image gray;
/**
* Runs the program
*/
public void run() {
Display display = new Display();
Shell shell = new Shell(display);
shell.setText("Show Image Flags");
// Load the image
image = new Image(display, this.getClass().getResourceAsStream(
"jexp.gif"));
// Create the duplicate image
copy = new Image(display, image, SWT.IMAGE_COPY);
// Create the disabled image
disable = new Image(display, image, SWT.IMAGE_DISABLE);
// Create the gray image
gray = new Image(display, image, SWT.IMAGE_GRAY);
createContents(shell);
shell.pack();
shell.open();
while (!shell.isDisposed()) {
if (!display.readAndDispatch()) {
display.sleep();
}
}
// Dispose the images
image.dispose();
copy.dispose();
disable.dispose();
gray.dispose();
display.dispose();
}
/**
* Creates the main window"s contents
*
* @param shell the main window
*/
private void createContents(Shell shell) {
shell.setLayout(new FillLayout());
// Create labels to hold each image
new Label(shell, SWT.NONE).setImage(image);
new Label(shell, SWT.NONE).setImage(copy);
new Label(shell, SWT.NONE).setImage(disable);
new Label(shell, SWT.NONE).setImage(gray);
}
/**
* The application entry point
*
* @param args the command line arguments
*/
public static void main(String[] args) {
new ShowImageFlags().run();
}
}
</source>
Displays information about the display device
<source lang="java">
//Send questions, comments, bug reports, etc. to the authors: //Rob Warner (rwarner@interspatial.ru) //Robert Harris (rbrt_harris@yahoo.ru) import org.eclipse.swt.SWT; import org.eclipse.swt.graphics.*; import org.eclipse.swt.layout.*; import org.eclipse.swt.widgets.*; /**
* This class displays information about the display device. */
public class ShowDevice {
/**
* Runs the application
*/
public void run() {
Display display = new Display();
Shell shell = new Shell(display);
shell.setText("Display Device");
createContents(shell);
shell.pack();
shell.open();
while (!shell.isDisposed()) {
if (!display.readAndDispatch()) {
display.sleep();
}
}
display.dispose();
}
/**
* Creates the main window"s contents
*
* @param shell the main window
*/
private void createContents(Shell shell) {
shell.setLayout(new FillLayout());
// Create a text box to hold the data
Text text = new Text(shell, SWT.MULTI | SWT.H_SCROLL | SWT.V_SCROLL);
// Get the display device
Device device = shell.getDisplay();
// Put its data into a buffer
StringBuffer buf = new StringBuffer();
buf.append("getBounds(): ").append(device.getBounds()).append("\n");
buf.append("getClientArea(): ").append(device.getClientArea()).append("\n");
buf.append("getDepth(): ").append(device.getDepth()).append("\n");
buf.append("getDPI(): ").append(device.getDPI()).append("\n");
// By setting warnings to true and then getting warnings, we know if the
// current platform supports it
device.setWarnings(true);
buf.append("Warnings supported: ").append(device.getWarnings()).append("\n");
// Put the collected information into the text box
text.setText(buf.toString());
}
/**
* The application entry point
*
* @param args the command line arguments
*/
public static void main(String[] args) {
new ShowDevice().run();
}
}
</source>
Draw2D Sample
<source lang="java">
/******************************************************************************
* All Right Reserved. * Copyright (c) 1998, 2004 Jackwind Li Guojie * * Created on 2004-7-3 17:22:26 by JACK * $Id$ * *****************************************************************************/
import org.eclipse.draw2d.Button; import org.eclipse.draw2d.LightweightSystem; import org.eclipse.jface.window.ApplicationWindow; import org.eclipse.swt.SWT; import org.eclipse.swt.graphics.Image; import org.eclipse.swt.layout.FillLayout; import org.eclipse.swt.widgets.Canvas; import org.eclipse.swt.widgets.ruposite; import org.eclipse.swt.widgets.Control; import org.eclipse.swt.widgets.Shell; public class Draw2DSample extends ApplicationWindow {
/* (non-Javadoc)
* @see org.eclipse.jface.window.ApplicationWindow#addToolBar(int)
*/
protected void addToolBar(int style) {
super.addToolBar(style);
}
/* (non-Javadoc)
* @see org.eclipse.jface.window.Window#createContents(org.eclipse.swt.widgets.ruposite)
*/
protected Control createContents(Composite parent) {
Composite composite = new Composite(parent, SWT.NULL);
composite.setLayout(new FillLayout());
Canvas canvas = new Canvas(composite, SWT.NULL);
LightweightSystem lws = new LightweightSystem(canvas);
Button button = new Button("Button", new Image(getShell().getDisplay(), "jexp.gif"));
lws.setContents(button);
return composite;
}
/**
* @param parentShell
*/
public Draw2DSample(Shell parentShell) {
super(parentShell);
}
public static void main(String[] args) {
Draw2DSample window = new Draw2DSample(null);
window.setBlockOnOpen(true);
window.open();
}
}
</source>
Drawings
<source lang="java">
/******************************************************************************
* All Right Reserved. * Copyright (c) 1998, 2004 Jackwind Li Guojie * * Created on 2004-4-18 18:33:36 by JACK * $Id$ * *****************************************************************************/
import org.eclipse.swt.SWT; import org.eclipse.swt.events.PaintEvent; import org.eclipse.swt.events.PaintListener; import org.eclipse.swt.layout.FillLayout; import org.eclipse.swt.widgets.Canvas; import org.eclipse.swt.widgets.Display; import org.eclipse.swt.widgets.Shell; public class Drawings {
Display display = new Display();
Shell shell = new Shell(display);
public Drawings() {
shell.setLayout(new FillLayout());
Canvas canvas = new Canvas(shell, SWT.BORDER);
canvas.setBackground(display.getSystemColor(SWT.COLOR_WHITE));
canvas.addPaintListener(new PaintListener() {
public void paintControl(PaintEvent e) {
// e.gc.drawString("SWT.LINE_SOLID (default)", 10, 10); // e.gc.drawString("SWT.LINE_DASH", 10, 30); // e.gc.drawString("SWT.LINE_DOT", 10, 50); // e.gc.drawString("SWT.LINE_DASHDOT", 10, 70); // e.gc.drawString("SWT.LINE_DASHDOTDOT", 10, 90); // e.gc.drawString("Line width = 1 (default)", 10, 120); // e.gc.drawString("Line width = 3", 10, 140); // // int start = 150; // e.gc.setLineWidth(1); // e.gc.setLineStyle(SWT.LINE_SOLID); // e.gc.drawLine(start, 15, start + 200, 15); // e.gc.setLineStyle(SWT.LINE_DASH); // e.gc.drawLine(start, 35, start + 200, 35); // e.gc.setLineStyle(SWT.LINE_DOT); // e.gc.drawLine(start, 55, start + 200, 55); // e.gc.setLineStyle(SWT.LINE_DASHDOT); // e.gc.drawLine(start, 75, start + 200, 75); // e.gc.setLineStyle(SWT.LINE_DASHDOTDOT); // e.gc.drawLine(start, 95, start + 200, 95); // // e.gc.setLineStyle(SWT.LINE_SOLID); // e.gc.drawLine(start, 125, start + 200, 125); // e.gc.setLineWidth(3); // e.gc.drawLine(start, 145, start + 200, 145);
// int[] points = new int[3 * 2];
// points[0] = 10; // The point at the top.
// points[1] = 10;
//
// points[2] = 10; // The point at the left bottom.
// points[3] = 100;
//
// points[4] = 100; // the point at the right bottom
// points[5] = 100;
//
// //e.gc.drawPolyline(points);
e.gc.setLineStyle(SWT.LINE_SOLID);
e.gc.setBackground(display.getSystemColor(SWT.COLOR_DARK_GREEN));
e.gc.fillArc(10, 10, 200, 100, 0, -90);
e.gc.setLineStyle(SWT.LINE_DOT);
e.gc.drawLine(0, 60, 220, 60);
e.gc.drawLine(110, 0, 110, 120);
}
});
shell.pack();
shell.open();
//textUser.forceFocus();
// Set up the event loop.
while (!shell.isDisposed()) {
if (!display.readAndDispatch()) {
// If no more entries in event queue
display.sleep();
}
}
display.dispose();
}
private void init() {
}
public static void main(String[] args) {
new Drawings();
}
}
</source>
Drawing with transformations, paths and alpha blending
<source lang="java">
/*
* Drawing with transformations, paths and alpha blending * * For a list of all SWT example snippets see * http://dev.eclipse.org/viewcvs/index.cgi/%7Echeckout%7E/platform-swt-home/dev.html#snippets */
import org.eclipse.swt.SWT; import org.eclipse.swt.graphics.Font; import org.eclipse.swt.graphics.FontData; import org.eclipse.swt.graphics.GC; import org.eclipse.swt.graphics.Image; import org.eclipse.swt.graphics.Path; import org.eclipse.swt.graphics.Rectangle; import org.eclipse.swt.graphics.Transform; import org.eclipse.swt.widgets.Display; import org.eclipse.swt.widgets.Event; import org.eclipse.swt.widgets.Listener; import org.eclipse.swt.widgets.Shell; public class Snippet10 {
public static void main(String[] args) {
final Display display = new Display();
final Shell shell = new Shell(display);
shell.setText("Advanced Graphics");
FontData fd = shell.getFont().getFontData()[0];
final Font font = new Font(display, fd.getName(), 60, SWT.BOLD
| SWT.ITALIC);
final Image image = new Image(display, 640, 480);
final Rectangle rect = image.getBounds();
GC gc = new GC(image);
gc.setBackground(display.getSystemColor(SWT.COLOR_RED));
gc.fillOval(rect.x, rect.y, rect.width, rect.height);
gc.dispose();
shell.addListener(SWT.Paint, new Listener() {
public void handleEvent(Event event) {
GC gc = event.gc;
Transform tr = new Transform(display);
tr.translate(50, 120);
tr.rotate(-30);
gc.drawImage(image, 0, 0, rect.width, rect.height, 0, 0,
rect.width / 2, rect.height / 2);
gc.setAlpha(100);
gc.setTransform(tr);
Path path = new Path(display);
path.addString("SWT", 0, 0, font);
gc.setBackground(display.getSystemColor(SWT.COLOR_GREEN));
gc.setForeground(display.getSystemColor(SWT.COLOR_BLUE));
gc.fillPath(path);
gc.drawPath(path);
tr.dispose();
path.dispose();
}
});
shell.setSize(shell.ruputeSize(rect.width / 2, rect.height / 2));
shell.open();
while (!shell.isDisposed()) {
if (!display.readAndDispatch())
display.sleep();
}
image.dispose();
font.dispose();
display.dispose();
}
}
</source>
Draw lines and polygons with different cap and join styles
<source lang="java">
/*
* Draw lines and polygons with different cap and join styles * * For a list of all SWT example snippets see * http://dev.eclipse.org/viewcvs/index.cgi/%7Echeckout%7E/platform-swt-home/dev.html#snippets */
import org.eclipse.swt.SWT; import org.eclipse.swt.graphics.GC; import org.eclipse.swt.widgets.Display; import org.eclipse.swt.widgets.Event; import org.eclipse.swt.widgets.Listener; import org.eclipse.swt.widgets.Shell; public class Snippet168 {
public static void main(String[] args) {
final Display display = new Display();
Shell shell = new Shell(display);
shell.addListener(SWT.Paint, new Listener() {
public void handleEvent(Event event) {
int x = 20, y = 20, w = 120, h = 60;
GC gc = event.gc;
gc.setForeground(display.getSystemColor(SWT.COLOR_BLUE));
gc.setLineWidth(10);
int[] caps = { SWT.CAP_FLAT, SWT.CAP_ROUND, SWT.CAP_SQUARE };
for (int i = 0; i < caps.length; i++) {
gc.setLineCap(caps[i]);
gc.drawLine(x, y, x + w, y);
y += 20;
}
int[] joins = { SWT.JOIN_BEVEL, SWT.JOIN_MITER, SWT.JOIN_ROUND };
for (int i = 0; i < joins.length; i++) {
gc.setLineJoin(joins[i]);
gc
.drawPolygon(new int[] { x, y, x + w / 2, y + h,
x + w, y });
y += h + 20;
}
}
});
shell.open();
while (!shell.isDisposed()) {
if (!display.readAndDispatch())
display.sleep();
}
}
}
</source>
Draw Round Rectangle
<source lang="java">
//Send questions, comments, bug reports, etc. to the authors: //Rob Warner (rwarner@interspatial.ru) //Robert Harris (rbrt_harris@yahoo.ru) import org.eclipse.swt.SWT; import org.eclipse.swt.events.*; import org.eclipse.swt.layout.*; import org.eclipse.swt.widgets.*; public class RoundRectangleExample {
private Text txtArcWidth = null;
private Text txtArcHeight = null;
/**
* Runs the application
*/
public void run() {
Display display = new Display();
Shell shell = new Shell(display);
shell.setText("RoundRectangle Example");
createContents(shell);
shell.open();
while (!shell.isDisposed()) {
if (!display.readAndDispatch()) {
display.sleep();
}
}
display.dispose();
}
/**
* Creates the main window"s contents
*
* @param shell the main window
*/
private void createContents(Shell shell) {
shell.setLayout(new FillLayout(SWT.VERTICAL));
// Create the composite that holds the input fields
Composite widgetComposite = new Composite(shell, SWT.NONE);
widgetComposite.setLayout(new GridLayout(2, false));
// Create the input fields
new Label(widgetComposite, SWT.NONE).setText("Arc Width:");
txtArcWidth = new Text(widgetComposite, SWT.BORDER);
new Label(widgetComposite, SWT.NONE).setText("Arc Height");
txtArcHeight = new Text(widgetComposite, SWT.BORDER);
// Create the button that launches the redraw
Button button = new Button(widgetComposite, SWT.PUSH);
button.setText("Redraw");
shell.setDefaultButton(button);
// Create the canvas to draw the round rectangle on
final Canvas drawingCanvas = new Canvas(shell, SWT.NONE);
drawingCanvas.addPaintListener(new RoundRectangleExamplePaintListener());
// Add a handler to redraw the round rectangle when pressed
button.addSelectionListener(new SelectionAdapter() {
public void widgetSelected(SelectionEvent e) {
drawingCanvas.redraw();
}
});
}
/**
* This class gets the user input and draws the requested round rectangle
*/
private class RoundRectangleExamplePaintListener implements PaintListener {
public void paintControl(PaintEvent e) {
// Get the canvas for drawing and its width and height
Canvas canvas = (Canvas) e.widget;
int x = canvas.getBounds().width;
int y = canvas.getBounds().height;
// Determine user input, defaulting everything to zero.
// Any blank fields are converted to zero
int arcWidth = 0;
int arcHeight = 0;
try {
arcWidth = txtArcWidth.getText().length() == 0 ? 0 : Integer
.parseInt(txtArcWidth.getText());
arcHeight = txtArcWidth.getText().length() == 0 ? 0 : Integer
.parseInt(txtArcHeight.getText());
} catch (NumberFormatException ex) {
// Any problems, set them both to zero
arcWidth = 0;
arcHeight = 0;
}
// Set the line width
e.gc.setLineWidth(4);
// Draw the round rectangle
e.gc.drawRoundRectangle(10, 10, x - 20, y - 20, arcWidth, arcHeight);
}
}
/**
* The application entry point
*
* @param args the command line arguments
*/
public static void main(String[] args) {
new RoundRectangleExample().run();
}
}
</source>
Draw Text Demo
<source lang="java">
/******************************************************************************
* All Right Reserved. * Copyright (c) 1998, 2004 Jackwind Li Guojie * * Created on 2004-4-19 13:48:04 by JACK * $Id$ * *****************************************************************************/
import org.eclipse.swt.SWT; import org.eclipse.swt.events.PaintEvent; import org.eclipse.swt.events.PaintListener; import org.eclipse.swt.graphics.Font; import org.eclipse.swt.graphics.Image; import org.eclipse.swt.graphics.Point; import org.eclipse.swt.graphics.Rectangle; import org.eclipse.swt.layout.FillLayout; import org.eclipse.swt.widgets.Canvas; import org.eclipse.swt.widgets.Display; import org.eclipse.swt.widgets.Shell; public class DrawTextDemo {
Display display = new Display();
Shell shell = new Shell(display);
public DrawTextDemo() {
shell.setLayout(new FillLayout());
final Canvas canvas = new Canvas(shell, SWT.NO_BACKGROUND);
final Image image = new Image(display, "jexp.gif");
canvas.addPaintListener(new PaintListener() {
public void paintControl(PaintEvent e) {
Rectangle size = image.getBounds();
// Draws the background image.
e.gc.drawImage(image, 0, 0, size.width, size.height, 0, 0, canvas.getSize().x, canvas.getSize().y);
Font font = new Font(display, "Tahoma", 18, SWT.BOLD);
e.gc.setFont(font);
e.gc.setForeground(display.getSystemColor(SWT.COLOR_WHITE));
e.gc.setBackground(display.getSystemColor(SWT.COLOR_BLUE));
String english = "SWT rocks!";
String chinese = "\u4e2d\u6587\u6c49\u5b57\u6d4b\u8bd5";
e.gc.drawString(english, 10, 10);
e.gc.drawString(chinese, 10, 80, true);
String text = "Text to be drawn in the center";
Point textSize = e.gc.textExtent(text);
e.gc.drawText(text, (canvas.getSize().x - textSize.x)/2, (canvas.getSize().y - textSize.y)/2);
font.dispose();
}
});
shell.setSize(300, 150);
shell.open();
//textUser.forceFocus();
// Set up the event loop.
while (!shell.isDisposed()) {
if (!display.readAndDispatch()) {
// If no more entries in event queue
display.sleep();
}
}
display.dispose();
}
private void init() {
}
public static void main(String[] args) {
new DrawTextDemo();
}
}
</source>
GC Creation
<source lang="java">
/******************************************************************************
* All Right Reserved. * Copyright (c) 1998, 2004 Jackwind Li Guojie * * Created on 2004-4-18 15:03:44 by JACK * $Id$ * *****************************************************************************/
import org.eclipse.swt.SWT; import org.eclipse.swt.custom.CLabel; import org.eclipse.swt.graphics.GC; import org.eclipse.swt.graphics.Image; import org.eclipse.swt.widgets.Display; import org.eclipse.swt.widgets.Shell; /**
* */
public class GCCreation {
Display display = new Display();
Shell shell = new Shell(display);
public GCCreation() {
Image image = new Image(display, "jexp.gif");
// Clones the image.
Image image2 = new Image(display, image.getImageData());
// Draws an oval
GC gc = new GC(image2);
gc.setForeground(display.getSystemColor(SWT.COLOR_WHITE));
gc.drawOval(10, 10, 90, 40);
gc.dispose();
CLabel label = new CLabel(shell, SWT.NULL);
label.setImage(image);
label.setBounds(10, 10, 130, 130);
CLabel label2 = new CLabel(shell, SWT.NULL);
label2.setImage(image2);
label2.setBounds(150, 10, 130, 130);
shell.pack();
shell.open();
//textUser.forceFocus();
// Set up the event loop.
while (!shell.isDisposed()) {
if (!display.readAndDispatch()) {
// If no more entries in event queue
display.sleep();
}
}
display.dispose();
}
public static void main(String[] args) {
new GCCreation();
}
}
</source>
GC example: draw a thick line
<source lang="java">
/*
* GC example snippet: draw a thick line * * For a list of all SWT example snippets see * http://dev.eclipse.org/viewcvs/index.cgi/%7Echeckout%7E/platform-swt-home/dev.html#snippets */
import org.eclipse.swt.graphics.GC; import org.eclipse.swt.widgets.Display; import org.eclipse.swt.widgets.Shell; public class Snippet13 {
public static void main(String[] args) {
Display display = new Display();
Shell shell = new Shell(display);
shell.open();
GC gc = new GC(shell);
gc.setLineWidth(4);
gc.drawRectangle(20, 20, 100, 100);
gc.dispose();
while (!shell.isDisposed()) {
if (!display.readAndDispatch())
display.sleep();
}
display.dispose();
}
}
</source>
GC: implement a simple scribble program
<source lang="java">
/*
* GC example snippet: implement a simple scribble program * * For a list of all SWT example snippets see * http://dev.eclipse.org/viewcvs/index.cgi/%7Echeckout%7E/platform-swt-home/dev.html#snippets */
import org.eclipse.swt.SWT; import org.eclipse.swt.graphics.GC; import org.eclipse.swt.widgets.Display; import org.eclipse.swt.widgets.Event; import org.eclipse.swt.widgets.Listener; import org.eclipse.swt.widgets.Shell; public class Snippet66 {
public static void main(String[] args) {
Display display = new Display();
final Shell shell = new Shell(display);
Listener listener = new Listener() {
int lastX = 0, lastY = 0;
public void handleEvent(Event event) {
switch (event.type) {
case SWT.MouseMove:
if ((event.stateMask & SWT.BUTTON1) == 0)
break;
GC gc = new GC(shell);
gc.drawLine(lastX, lastY, event.x, event.y);
gc.dispose();
// FALL THROUGH
case SWT.MouseDown:
lastX = event.x;
lastY = event.y;
break;
}
}
};
shell.addListener(SWT.MouseDown, listener);
shell.addListener(SWT.MouseMove, listener);
shell.open();
while (!shell.isDisposed()) {
if (!display.readAndDispatch())
display.sleep();
}
display.dispose();
}
}
</source>
GC: measure a string
<source lang="java">
/*
* GC example snippet: measure a string * * For a list of all SWT example snippets see * http://dev.eclipse.org/viewcvs/index.cgi/%7Echeckout%7E/platform-swt-home/dev.html#snippets */
import org.eclipse.swt.SWT; import org.eclipse.swt.graphics.GC; import org.eclipse.swt.graphics.Point; import org.eclipse.swt.layout.RowLayout; import org.eclipse.swt.widgets.Display; import org.eclipse.swt.widgets.Label; import org.eclipse.swt.widgets.Shell; public class Snippet93 {
public static void main(String[] args) {
Display display = new Display();
Shell shell = new Shell(display);
shell.setLayout(new RowLayout());
Label label = new Label(shell, SWT.NONE);
GC gc = new GC(label);
Point size = gc.textExtent("Hello");
gc.dispose();
label.setText("Hello -> " + size);
shell.pack();
shell.open();
while (!shell.isDisposed()) {
if (!display.readAndDispatch())
display.sleep();
}
display.dispose();
}
}
</source>
How to draw directly on an SWT Control
<source lang="java">
import java.util.ResourceBundle; import org.eclipse.swt.events.DisposeEvent; import org.eclipse.swt.events.DisposeListener; import org.eclipse.swt.events.PaintEvent; import org.eclipse.swt.events.PaintListener; import org.eclipse.swt.graphics.Color; import org.eclipse.swt.graphics.GC; import org.eclipse.swt.graphics.Rectangle; import org.eclipse.swt.widgets.Display; import org.eclipse.swt.widgets.Shell; /*
* This example builds on HelloWorld1 and demonstrates how to draw directly * on an SWT Control. */
public class HelloWorld5 {
public static void main(String[] args) {
Display display = new Display();
Shell shell = new HelloWorld5().open(display);
while (!shell.isDisposed()) {
if (!display.readAndDispatch())
display.sleep();
}
display.dispose();
}
public Shell open(Display display) {
final Color red = new Color(display, 0xFF, 0, 0);
final Shell shell = new Shell(display);
shell.addPaintListener(new PaintListener() {
public void paintControl(PaintEvent event) {
GC gc = event.gc;
gc.setForeground(red);
Rectangle rect = shell.getClientArea();
gc.drawRectangle(rect.x + 10, rect.y + 10, rect.width - 20,
rect.height - 20);
gc.drawString("Hello_world", rect.x + 20,
rect.y + 20);
}
});
shell.addDisposeListener(new DisposeListener() {
public void widgetDisposed(DisposeEvent e) {
red.dispose();
}
});
shell.open();
return shell;
}
}
</source>
Palettes
<source lang="java">
/*******************************************************************************
* All Right Reserved. Copyright (c) 1998, 2004 Jackwind Li Guojie * * Created on 2004-4-21 20:12:55 by JACK $Id$ * ******************************************************************************/
import org.eclipse.swt.SWT; import org.eclipse.swt.events.PaintEvent; import org.eclipse.swt.events.PaintListener; import org.eclipse.swt.graphics.Image; import org.eclipse.swt.graphics.ImageData; import org.eclipse.swt.graphics.PaletteData; import org.eclipse.swt.graphics.RGB; import org.eclipse.swt.layout.FillLayout; import org.eclipse.swt.widgets.Canvas; import org.eclipse.swt.widgets.Display; import org.eclipse.swt.widgets.Shell; public class Palettes {
Display display = new Display();
Shell shell = new Shell(display);
public Palettes() {
shell.setLayout(new FillLayout());
PaletteData paletteData = new PaletteData(0xFF0000, 0x00FF00, 0x0000FF);
ImageData imageData = new ImageData(100, 100, 24, paletteData);
for (int i = 0; i < 100; i++) { // each column.
for (int j = 0; j < 100; j++) { // each row.
if (j < 30 || (i > 35 && i < 65))
imageData.setPixel(i, j, 0xFF);
else
imageData.setPixel(i, j, 0xFFFF00);
}
}
// int pixelValue = imageData.getPixel(50, 50);
// int redComponent = pixelValue & imageData.palette.redMask;
// int greenComponent = pixelValue & imageData.palette.greenMask;
// int blueComponent = pixelValue & imageData.palette.blueMask;
PaletteData paletteData2 =
new PaletteData(new RGB[] { new RGB(0, 0, 255), // blue
new RGB(255, 255, 0) // yellow
});
ImageData imageData2 = new ImageData(100, 100, 1, paletteData2);
for (int i = 0; i < 100; i++) { // each column.
for (int j = 0; j < 100; j++) { // each row.
if (j < 30 || (i > 35 && i < 65))
imageData2.setPixel(i, j, 0);
else
imageData2.setPixel(i, j, 1);
}
}
System.out.println(imageData.palette.getRGB(imageData.getPixel(50, 50)));
final Image image2 = new Image(display, imageData2);
final Image image = new Image(display, imageData);
final Canvas canvas = new Canvas(shell, SWT.NULL);
canvas.setBackground(display.getSystemColor(SWT.COLOR_WHITE));
canvas.addPaintListener(new PaintListener() {
public void paintControl(PaintEvent e) {
e.gc.drawImage(image2, 0, 0);
}
});
shell.pack();
shell.open();
//textUser.forceFocus();
// Set up the event loop.
while (!shell.isDisposed()) {
if (!display.readAndDispatch()) {
// If no more entries in event queue
display.sleep();
}
}
display.dispose();
}
private void init() {
}
public static void main(String[] args) {
new Palettes();
}
}
</source>
SWT 2D Chart: Flowchart
<source lang="java">
/* SWT/JFace in Action GUI Design with Eclipse 3.0 Matthew Scarpino, Stephen Holder, Stanford Ng, and Laurent Mihalkovic ISBN: 1932394273 Publisher: Manning
- /
import java.util.Enumeration; import java.util.Hashtable; import org.eclipse.draw2d.AbstractConnectionAnchor; import org.eclipse.draw2d.ColorConstants; import org.eclipse.draw2d.ConnectionAnchor; import org.eclipse.draw2d.Figure; import org.eclipse.draw2d.FreeformLayeredPane; import org.eclipse.draw2d.FreeformLayout; import org.eclipse.draw2d.Graphics; import org.eclipse.draw2d.IFigure; import org.eclipse.draw2d.LightweightSystem; import org.eclipse.draw2d.ManhattanConnectionRouter; import org.eclipse.draw2d.MarginBorder; import org.eclipse.draw2d.MouseEvent; import org.eclipse.draw2d.MouseListener; import org.eclipse.draw2d.MouseMotionListener; import org.eclipse.draw2d.PolylineConnection; import org.eclipse.draw2d.PolylineDecoration; import org.eclipse.draw2d.geometry.Dimension; import org.eclipse.draw2d.geometry.Point; import org.eclipse.draw2d.geometry.PointList; import org.eclipse.draw2d.geometry.PrecisionPoint; import org.eclipse.draw2d.geometry.Rectangle; import org.eclipse.swt.widgets.Display; import org.eclipse.swt.widgets.Shell; public class Flowchart {
public static void main(String args[]) {
Shell shell = new Shell();
shell.setSize(200, 300);
shell.open();
shell.setText("Flowchart");
LightweightSystem lws = new LightweightSystem(shell);
ChartFigure flowchart = new ChartFigure();
lws.setContents(flowchart);
TerminatorFigure start = new TerminatorFigure();
start.setName("Start");
start.setBounds(new Rectangle(40, 20, 80, 20));
DecisionFigure dec = new DecisionFigure();
dec.setName("Should I?");
dec.setBounds(new Rectangle(30, 60, 100, 60));
ProcessFigure proc = new ProcessFigure();
proc.setName("Do it!");
proc.setBounds(new Rectangle(40, 140, 80, 40));
TerminatorFigure stop = new TerminatorFigure();
stop.setName("End");
stop.setBounds(new Rectangle(40, 200, 80, 20));
PathFigure path1 = new PathFigure();
path1.setSourceAnchor(start.outAnchor);
path1.setTargetAnchor(dec.inAnchor);
PathFigure path2 = new PathFigure();
path2.setSourceAnchor(dec.yesAnchor);
path2.setTargetAnchor(proc.inAnchor);
PathFigure path3 = new PathFigure();
path3.setSourceAnchor(dec.noAnchor);
path3.setTargetAnchor(stop.inAnchor);
PathFigure path4 = new PathFigure();
path4.setSourceAnchor(proc.outAnchor);
path4.setTargetAnchor(stop.inAnchor);
flowchart.add(start);
flowchart.add(dec);
flowchart.add(proc);
flowchart.add(stop);
flowchart.add(path1);
flowchart.add(path2);
flowchart.add(path3);
flowchart.add(path4);
new Dnd(start);
new Dnd(proc);
new Dnd(dec);
new Dnd(stop);
Display display = Display.getDefault();
while (!shell.isDisposed()) {
if (!display.readAndDispatch())
display.sleep();
}
}
} class ChartFigure extends FreeformLayeredPane {
public ChartFigure() {
setLayoutManager(new FreeformLayout());
setBorder(new MarginBorder(5));
setBackgroundColor(ColorConstants.white);
setOpaque(true);
}
} class Dnd extends MouseMotionListener.Stub implements MouseListener {
public Dnd(IFigure figure) {
figure.addMouseMotionListener(this);
figure.addMouseListener(this);
}
Point start;
public void mouseReleased(MouseEvent e) {
}
public void mouseClicked(MouseEvent e) {
}
public void mouseDoubleClicked(MouseEvent e) {
}
public void mousePressed(MouseEvent e) {
start = e.getLocation();
}
public void mouseDragged(MouseEvent e) {
Point p = e.getLocation();
Dimension d = p.getDifference(start);
start = p;
Figure f = ((Figure) e.getSource());
f.setBounds(f.getBounds().getTranslated(d.width, d.height));
}
} class TerminatorFigure extends ActivityFigure {
FixedAnchor inAnchor, outAnchor;
public TerminatorFigure() {
inAnchor = new FixedAnchor(this);
inAnchor.place = new Point(1, 0);
targetAnchors.put("in_term", inAnchor);
outAnchor = new FixedAnchor(this);
outAnchor.place = new Point(1, 2);
sourceAnchors.put("out_term", outAnchor);
}
public void paintFigure(Graphics g) {
Rectangle r = bounds;
g.drawArc(r.x + r.width / 8, r.y, r.width / 4, r.height - 1, 90, 180);
g.drawLine(r.x + r.width / 4, r.y, r.x + 3 * r.width / 4, r.y);
g.drawLine(r.x + r.width / 4, r.y + r.height - 1,
r.x + 3 * r.width / 4, r.y + r.height - 1);
g.drawArc(r.x + 5 * r.width / 8, r.y, r.width / 4, r.height - 1, 270,
180);
g.drawText(message, r.x + 3 * r.width / 8, r.y + r.height / 8);
}
} class FixedAnchor extends AbstractConnectionAnchor {
Point place;
public FixedAnchor(IFigure owner) {
super(owner);
}
public Point getLocation(Point loc) {
Rectangle r = getOwner().getBounds();
int x = r.x + place.x * r.width / 2;
int y = r.y + place.y * r.height / 2;
Point p = new PrecisionPoint(x, y);
getOwner().translateToAbsolute(p);
return p;
}
} class DecisionFigure extends ActivityFigure {
FixedAnchor inAnchor, yesAnchor, noAnchor;
public DecisionFigure() {
inAnchor = new FixedAnchor(this);
inAnchor.place = new Point(1, 0);
targetAnchors.put("in_dec", inAnchor);
noAnchor = new FixedAnchor(this);
noAnchor.place = new Point(2, 1);
sourceAnchors.put("no", noAnchor);
yesAnchor = new FixedAnchor(this);
yesAnchor.place = new Point(1, 2);
sourceAnchors.put("yes", yesAnchor);
}
public void paintFigure(Graphics g) {
Rectangle r = bounds;
PointList pl = new PointList(4);
pl.addPoint(r.x + r.width / 2, r.y);
pl.addPoint(r.x, r.y + r.height / 2);
pl.addPoint(r.x + r.width / 2, r.y + r.height - 1);
pl.addPoint(r.x + r.width, r.y + r.height / 2);
g.drawPolygon(pl);
g.drawText(message, r.x + r.width / 4 + 5, r.y + 3 * r.height / 8);
g.drawText("N", r.x + 7 * r.width / 8, r.y + 3 * r.height / 8);
g.drawText("Y", r.x + r.width / 2 - 2, r.y + 3 * r.height / 4);
}
} class PathFigure extends PolylineConnection {
public PathFigure() {
setTargetDecoration(new PolylineDecoration());
setConnectionRouter(new ManhattanConnectionRouter());
}
} class ProcessFigure extends ActivityFigure {
FixedAnchor inAnchor, outAnchor;
public ProcessFigure() {
inAnchor = new FixedAnchor(this);
inAnchor.place = new Point(1, 0);
targetAnchors.put("in_proc", inAnchor);
outAnchor = new FixedAnchor(this);
outAnchor.place = new Point(1, 2);
sourceAnchors.put("out_proc", outAnchor);
}
public void paintFigure(Graphics g) {
Rectangle r = bounds;
g.drawText(message, r.x + r.width / 4, r.y + r.height / 4);
g.drawRectangle(r.x, r.y, r.width - 1, r.height - 1);
}
} abstract class ActivityFigure extends Figure {
Rectangle r = new Rectangle();
Hashtable targetAnchors = new Hashtable();
Hashtable sourceAnchors = new Hashtable();
String message = new String();
public void setName(String msg) {
message = msg;
repaint();
}
public ConnectionAnchor ConnectionAnchorAt(Point p) {
ConnectionAnchor closest = null;
long min = Long.MAX_VALUE;
Hashtable conn = getSourceConnectionAnchors();
conn.putAll(getTargetConnectionAnchors());
Enumeration e = conn.elements();
while (e.hasMoreElements()) {
ConnectionAnchor c = (ConnectionAnchor) e.nextElement();
Point p2 = c.getLocation(null);
long d = p.getDistance2(p2);
if (d < min) {
min = d;
closest = c;
}
}
return closest;
}
public ConnectionAnchor getSourceConnectionAnchor(String name) {
return (ConnectionAnchor) sourceAnchors.get(name);
}
public ConnectionAnchor getTargetConnectionAnchor(String name) {
return (ConnectionAnchor) targetAnchors.get(name);
}
public String getSourceAnchorName(ConnectionAnchor c) {
Enumeration e = sourceAnchors.keys();
String name;
while (e.hasMoreElements()) {
name = (String) e.nextElement();
if (sourceAnchors.get(name).equals(c))
return name;
}
return null;
}
public String getTargetAnchorName(ConnectionAnchor c) {
Enumeration e = targetAnchors.keys();
String name;
while (e.hasMoreElements()) {
name = (String) e.nextElement();
if (targetAnchors.get(name).equals(c))
return name;
}
return null;
}
public ConnectionAnchor getSourceConnectionAnchorAt(Point p) {
ConnectionAnchor closest = null;
long min = Long.MAX_VALUE;
Enumeration e = getSourceConnectionAnchors().elements();
while (e.hasMoreElements()) {
ConnectionAnchor c = (ConnectionAnchor) e.nextElement();
Point p2 = c.getLocation(null);
long d = p.getDistance2(p2);
if (d < min) {
min = d;
closest = c;
}
}
return closest;
}
public Hashtable getSourceConnectionAnchors() {
return sourceAnchors;
}
public ConnectionAnchor getTargetConnectionAnchorAt(Point p) {
ConnectionAnchor closest = null;
long min = Long.MAX_VALUE;
Enumeration e = getTargetConnectionAnchors().elements();
while (e.hasMoreElements()) {
ConnectionAnchor c = (ConnectionAnchor) e.nextElement();
Point p2 = c.getLocation(null);
long d = p.getDistance2(p2);
if (d < min) {
min = d;
closest = c;
}
}
return closest;
}
public Hashtable getTargetConnectionAnchors() {
return targetAnchors;
}
} class FigureFactory {
public static IFigure createTerminatorFigure() {
return new TerminatorFigure();
}
public static IFigure createDecisionFigure() {
return new DecisionFigure();
}
public static IFigure createProcessFigure() {
return new ProcessFigure();
}
public static PathFigure createPathFigure() {
return new PathFigure();
}
public static ChartFigure createChartFigure() {
return new ChartFigure();
}
}
</source>
SWT 2D Simple Demo
<source lang="java">
/*******************************************************************************
* Copyright (c) 2004 Berthold Daum. All rights reserved. This program and the * accompanying materials are made available under the terms of the Common * Public License v1.0 which accompanies this distribution, and is available at * http://www.eclipse.org/legal/cpl-v10.html * * Contributors: Berthold Daum ******************************************************************************/
import java.awt.RenderingHints; import java.util.ArrayList; import java.util.Iterator; import org.eclipse.swt.SWT; import org.eclipse.swt.awt.SWT_AWT; import org.eclipse.swt.events.PaintEvent; import org.eclipse.swt.events.PaintListener; import org.eclipse.swt.events.SelectionAdapter; import org.eclipse.swt.events.SelectionEvent; import org.eclipse.swt.graphics.Point; import org.eclipse.swt.layout.FillLayout; import org.eclipse.swt.layout.GridData; import org.eclipse.swt.layout.GridLayout; import org.eclipse.swt.widgets.Button; import org.eclipse.swt.widgets.ruposite; import org.eclipse.swt.widgets.Display; import org.eclipse.swt.widgets.Shell; import org.eclipse.swt.widgets.Text; public class SWT2D {
// Shell fur Popup-Editor
Shell eShell = null;
// Text-Widget fur Editor
Text eText = null;
// Liste eingegebener Zeichenketten
ArrayList wordList = new ArrayList(12);
public static void main(String[] args) {
SWT2D swtawt = new SWT2D();
swtawt.run();
}
private void run() {
// Create top level shell
final Display display = new Display();
final Shell shell = new Shell(display);
shell.setText("Java 2D Example");
// GridLayout for canvas and button
shell.setLayout(new GridLayout());
// Create container for AWT canvas
final Composite canvasComp = new Composite(shell, SWT.EMBEDDED);
// Set preferred size
GridData data = new GridData();
data.widthHint = 600;
data.heightHint = 500;
canvasComp.setLayoutData(data);
// Create AWT Frame for Canvas
java.awt.Frame canvasFrame = SWT_AWT.new_Frame(canvasComp);
// Create Canvas and add it to the Frame
final java.awt.Canvas canvas = new java.awt.Canvas();
canvasFrame.add(canvas);
// Get graphical context and cast to Java2D
final java.awt.Graphics2D g2d = (java.awt.Graphics2D) canvas
.getGraphics();
// Enable antialiasing
g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
RenderingHints.VALUE_ANTIALIAS_ON);
// Remember initial transform
final java.awt.geom.AffineTransform origTransform = g2d.getTransform();
// Create Clear button and position it
Button clearButton = new Button(shell, SWT.PUSH);
clearButton.setText("Clear");
data = new GridData();
data.horizontalAlignment = GridData.CENTER;
clearButton.setLayoutData(data);
// Event processing for Clear button
clearButton.addSelectionListener(new SelectionAdapter() {
public void widgetSelected(SelectionEvent e) {
// Delete word list and redraw canvas
wordList.clear();
canvasComp.redraw();
}
});
// Process canvas mouse clicks
canvas.addMouseListener(new java.awt.event.MouseListener() {
public void mouseClicked(java.awt.event.MouseEvent e) {
}
public void mouseEntered(java.awt.event.MouseEvent e) {
}
public void mouseExited(java.awt.event.MouseEvent e) {
}
public void mousePressed(java.awt.event.MouseEvent e) {
// Manage pop-up editor
display.syncExec(new Runnable() {
public void run() {
if (eShell == null) {
// Create new Shell: non-modal!
eShell = new Shell(shell, SWT.NO_TRIM
| SWT.MODELESS);
eShell.setLayout(new FillLayout());
// Text input field
eText = new Text(eShell, SWT.BORDER);
eText.setText("Text rotation in the SWT?");
eShell.pack();
// Set position (Display coordinates)
java.awt.Rectangle bounds = canvas.getBounds();
org.eclipse.swt.graphics.Point pos = canvasComp
.toDisplay(bounds.width / 2,
bounds.height / 2);
Point size = eShell.getSize();
eShell.setBounds(pos.x, pos.y, size.x, size.y);
// Open Shell
eShell.open();
} else if (!eShell.isVisible()) {
// Editor versteckt, sichtbar machen
eShell.setVisible(true);
} else {
// Editor is visible - get text
String t = eText.getText();
// set editor invisible
eShell.setVisible(false);
// Add text to list and redraw canvas
wordList.add(t);
canvasComp.redraw();
}
}
});
}
public void mouseReleased(java.awt.event.MouseEvent e) {
}
});
// Redraw the canvas
canvasComp.addPaintListener(new PaintListener() {
public void paintControl(PaintEvent e) {
// Pass the redraw task to AWT event queue
java.awt.EventQueue.invokeLater(new Runnable() {
public void run() {
// Compute canvas center
java.awt.Rectangle bounds = canvas.getBounds();
int originX = bounds.width / 2;
int originY = bounds.height / 2;
// Reset canvas
g2d.setTransform(origTransform);
g2d.setColor(java.awt.Color.WHITE);
g2d.fillRect(0, 0, bounds.width, bounds.height);
// Set font
g2d.setFont(new java.awt.Font("Myriad",
java.awt.Font.PLAIN, 32));
double angle = 0d;
// Prepare star shape
double increment = Math.toRadians(30);
Iterator iter = wordList.iterator();
while (iter.hasNext()) {
// Determine text colors in RGB color cycle
float red = (float) (0.5 + 0.5 * Math.sin(angle));
float green = (float) (0.5 + 0.5 * Math.sin(angle
+ Math.toRadians(120)));
float blue = (float) (0.5 + 0.5 * Math.sin(angle
+ Math.toRadians(240)));
g2d.setColor(new java.awt.Color(red, green, blue));
// Redraw text
String text = (String) iter.next();
g2d.drawString(text, originX + 50, originY);
// Rotate for next text output
g2d.rotate(increment, originX, originY);
angle += increment;
}
}
});
}
});
// Finish shell and open it
shell.pack();
shell.open();
// SWT event processing
while (!shell.isDisposed()) {
if (!display.readAndDispatch())
display.sleep();
}
display.dispose();
}
}
</source>
SWT 2D Unicode
<source lang="java">
/*
* -----------------------------------------------------------------------------
* (c) Copyright IBM Corp. 2004 All rights reserved.
*
* The sample program(s) is/are owned by International Business Machines
* Corporation or one of its subsidiaries ("IBM") and is/are copyrighted and
* licensed, not sold.
*
* You may copy, modify, and distribute this/these sample program(s) in any form
* without payment to IBM, for any purpose including developing, using,
* marketing or distributing programs that include or are derivative works of
* the sample program(s).
*
* The sample program(s) is/are provided to you on an "AS IS" basis, without
* warranty of any kind. IBM HEREBY EXPRESSLY DISCLAIMS ALL WARRANTIES, EITHER
* EXPRESS OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. Some jurisdictions do
* not allow for the exclusion or limitation of implied warranties, so the above
* limitations or exclusions may not apply to you. IBM shall not be liable for
* any damages you suffer as a result of using, modifying or distributing the
* sample program(s) or its/their derivatives.
*
* Each copy of any portion of this/these sample program(s) or any derivative
* work, must include the above copyright notice and disclaimer of warranty.
*
* -----------------------------------------------------------------------------
*/
import java.awt.GradientPaint; import java.awt.Graphics2D; import java.awt.RenderingHints; import java.awt.image.BufferedImage; import org.eclipse.draw2d.Figure; import org.eclipse.draw2d.IFigure; import org.eclipse.draw2d.LightweightSystem; import org.eclipse.draw2d.geometry.Dimension; import org.eclipse.swt.graphics.GC; import org.eclipse.swt.graphics.Image; import org.eclipse.swt.graphics.ImageData; import org.eclipse.swt.graphics.PaletteData; import org.eclipse.swt.widgets.Display; import org.eclipse.swt.widgets.Shell; public class Draw2DTest {
public static void main(String[] args) {
final Graphics2DRenderer renderer = new Graphics2DRenderer();
Shell shell = new Shell();
shell.setSize(350, 350);
shell.open();
shell.setText("Draw2d Hello World");
LightweightSystem lws = new LightweightSystem(shell);
IFigure figure = new Figure() {
protected void paintClientArea(org.eclipse.draw2d.Graphics graphics) {
Dimension controlSize = getSize();
renderer.prepareRendering(graphics);
// prepares the Graphics2D renderer
// gets the Graphics2D context and switch on the antialiasing
Graphics2D g2d = renderer.getGraphics2D();
g2d.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING,
RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
// paints the background with a color gradient
g2d.setPaint(new GradientPaint(0.0f, 0.0f,
java.awt.Color.yellow, (float) controlSize.width,
(float) controlSize.width, java.awt.Color.white));
g2d.fillRect(0, 0, controlSize.width, controlSize.width);
// draws rotated text
g2d.setFont(new java.awt.Font("SansSerif", java.awt.Font.BOLD,
16));
g2d.setColor(java.awt.Color.blue);
g2d.translate(controlSize.width / 2, controlSize.width / 2);
int nbOfSlices = 18;
for (int i = 0; i < nbOfSlices; i++) {
g2d.drawString("Angle = " + (i * 360 / nbOfSlices)
+ "\u00B0", 30, 0);
g2d.rotate(-2 * Math.PI / nbOfSlices);
}
// now that we are done with Java2D, renders Graphics2D
// operation
// on the SWT graphics context
renderer.render(graphics);
// now we can continue with pure SWT paint operations
graphics.drawOval(0, 0, controlSize.width, controlSize.width);
}
};
lws.setContents(figure);
Display display = Display.getDefault();
while (!shell.isDisposed()) {
if (!display.readAndDispatch())
display.sleep();
}
renderer.dispose();
}
} /*
* -----------------------------------------------------------------------------
* (c) Copyright IBM Corp. 2004 All rights reserved.
*
* The sample program(s) is/are owned by International Business Machines
* Corporation or one of its subsidiaries ("IBM") and is/are copyrighted and
* licensed, not sold.
*
* You may copy, modify, and distribute this/these sample program(s) in any form
* without payment to IBM, for any purpose including developing, using,
* marketing or distributing programs that include or are derivative works of
* the sample program(s).
*
* The sample program(s) is/are provided to you on an "AS IS" basis, without
* warranty of any kind. IBM HEREBY EXPRESSLY DISCLAIMS ALL WARRANTIES, EITHER
* EXPRESS OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. Some jurisdictions do
* not allow for the exclusion or limitation of implied warranties, so the above
* limitations or exclusions may not apply to you. IBM shall not be liable for
* any damages you suffer as a result of using, modifying or distributing the
* sample program(s) or its/their derivatives.
*
* Each copy of any portion of this/these sample program(s) or any derivative
* work, must include the above copyright notice and disclaimer of warranty.
*
* -----------------------------------------------------------------------------
*/
/**
* Helper class allowing the use of Java2D on SWT or Draw2D graphical context. * * @author Yannick Saillet */
class Graphics2DRenderer {
private static final PaletteData PALETTE_DATA = new PaletteData(0xFF0000,
0xFF00, 0xFF);
private BufferedImage awtImage;
private Image swtImage;
private ImageData swtImageData;
private int[] awtPixels;
/** RGB value to use as transparent color */
private static final int TRANSPARENT_COLOR = 0x123456;
/**
* Prepare to render on a SWT graphics context.
*/
public void prepareRendering(GC gc) {
org.eclipse.swt.graphics.Rectangle clip = gc.getClipping();
prepareRendering(clip.x, clip.y, clip.width, clip.height);
}
/**
* Prepare to render on a Draw2D graphics context.
*/
public void prepareRendering(org.eclipse.draw2d.Graphics graphics) {
org.eclipse.draw2d.geometry.Rectangle clip = graphics
.getClip(new org.eclipse.draw2d.geometry.Rectangle());
prepareRendering(clip.x, clip.y, clip.width, clip.height);
}
/**
* Prepare the AWT offscreen image for the rendering of the rectangular
* region given as parameter.
*/
private void prepareRendering(int clipX, int clipY, int clipW, int clipH) {
// check that the offscreen images are initialized and large enough
checkOffScreenImages(clipW, clipH);
// fill the region in the AWT image with the transparent color
java.awt.Graphics awtGraphics = awtImage.getGraphics();
awtGraphics.setColor(new java.awt.Color(TRANSPARENT_COLOR));
awtGraphics.fillRect(clipX, clipY, clipW, clipH);
}
/**
* Returns the Graphics2D context to use.
*/
public Graphics2D getGraphics2D() {
if (awtImage == null)
return null;
return (Graphics2D) awtImage.getGraphics();
}
/**
* Complete the rendering by flushing the 2D renderer on a SWT graphical
* context.
*/
public void render(GC gc) {
if (awtImage == null)
return;
org.eclipse.swt.graphics.Rectangle clip = gc.getClipping();
transferPixels(clip.x, clip.y, clip.width, clip.height);
gc.drawImage(swtImage, clip.x, clip.y, clip.width, clip.height, clip.x,
clip.y, clip.width, clip.height);
}
/**
* Complete the rendering by flushing the 2D renderer on a Draw2D graphical
* context.
*/
public void render(org.eclipse.draw2d.Graphics graphics) {
if (awtImage == null)
return;
org.eclipse.draw2d.geometry.Rectangle clip = graphics
.getClip(new org.eclipse.draw2d.geometry.Rectangle());
transferPixels(clip.x, clip.y, clip.width, clip.height);
graphics.drawImage(swtImage, clip.x, clip.y, clip.width, clip.height,
clip.x, clip.y, clip.width, clip.height);
}
/**
* Transfer a rectangular region from the AWT image to the SWT image.
*/
private void transferPixels(int clipX, int clipY, int clipW, int clipH) {
int step = swtImageData.depth / 8;
byte[] data = swtImageData.data;
awtImage.getRGB(clipX, clipY, clipW, clipH, awtPixels, 0, clipW);
for (int i = 0; i < clipH; i++) {
int idx = (clipY + i) * swtImageData.bytesPerLine + clipX * step;
for (int j = 0; j < clipW; j++) {
int rgb = awtPixels[j + i * clipW];
for (int k = swtImageData.depth - 8; k >= 0; k -= 8) {
data[idx++] = (byte) ((rgb >> k) & 0xFF);
}
}
}
if (swtImage != null)
swtImage.dispose();
swtImage = new Image(Display.getDefault(), swtImageData);
}
/**
* Dispose the resources attached to this 2D renderer.
*/
public void dispose() {
if (awtImage != null)
awtImage.flush();
if (swtImage != null)
swtImage.dispose();
awtImage = null;
swtImageData = null;
awtPixels = null;
}
/**
* Ensure that the offscreen images are initialized and are at least as
* large as the size given as parameter.
*/
private void checkOffScreenImages(int width, int height) {
int currentImageWidth = 0;
int currentImageHeight = 0;
if (swtImage != null) {
currentImageWidth = swtImage.getImageData().width;
currentImageHeight = swtImage.getImageData().height;
}
// if the offscreen images are too small, recreate them
if (width > currentImageWidth || height > currentImageHeight) {
dispose();
width = Math.max(width, currentImageWidth);
height = Math.max(height, currentImageHeight);
awtImage = new BufferedImage(width, height,
BufferedImage.TYPE_INT_ARGB);
swtImageData = new ImageData(width, height, 24, PALETTE_DATA);
swtImageData.transparentPixel = TRANSPARENT_COLOR;
awtPixels = new int[width * height];
}
}
}
</source>
SWT Draw 2D
<source lang="java">
/* SWT/JFace in Action GUI Design with Eclipse 3.0 Matthew Scarpino, Stephen Holder, Stanford Ng, and Laurent Mihalkovic ISBN: 1932394273 Publisher: Manning
- /
import org.eclipse.swt.SWT; import org.eclipse.swt.graphics.GC; import org.eclipse.swt.widgets.Canvas; import org.eclipse.swt.widgets.Display; import org.eclipse.swt.widgets.Shell; public class DrawExample {
public static void main(String[] args) {
Display display = new Display();
Shell shell = new Shell(display);
shell.setText("Drawing Example");
Canvas canvas = new Canvas(shell, SWT.NONE);
canvas.setSize(150, 150);
canvas.setLocation(20, 20);
shell.open();
shell.setSize(200, 220);
GC gc = new GC(canvas);
gc.drawRectangle(10, 10, 40, 45);
gc.drawOval(65, 10, 30, 35);
gc.drawLine(130, 10, 90, 80);
gc.drawPolygon(new int[] { 20, 70, 45, 90, 70, 70 });
gc.drawPolyline(new int[] { 10, 120, 70, 100, 100, 130, 130, 75 });
gc.dispose();
while (!shell.isDisposed()) {
if (!display.readAndDispatch())
display.sleep();
}
display.dispose();
}
}
</source>
SWT Draw2D Example
<source lang="java">
/* SWT/JFace in Action GUI Design with Eclipse 3.0 Matthew Scarpino, Stephen Holder, Stanford Ng, and Laurent Mihalkovic ISBN: 1932394273 Publisher: Manning
- /
import org.eclipse.draw2d.ButtonGroup; import org.eclipse.draw2d.ButtonModel; import org.eclipse.draw2d.ChangeEvent; import org.eclipse.draw2d.ChangeListener; import org.eclipse.draw2d.CheckBox; import org.eclipse.draw2d.Clickable; import org.eclipse.draw2d.Figure; import org.eclipse.draw2d.Label; import org.eclipse.draw2d.LightweightSystem; import org.eclipse.draw2d.ToggleModel; import org.eclipse.draw2d.XYLayout; import org.eclipse.draw2d.geometry.Rectangle; import org.eclipse.swt.widgets.Display; import org.eclipse.swt.widgets.Shell; public class Draw2D_Example {
public static void main(String args[]) {
final Label label = new Label("Press a button!");
Shell shell = new Shell();
LightweightSystem lws = new LightweightSystem(shell);
Figure parent = new Figure();
parent.setLayoutManager(new XYLayout());
lws.setContents(parent);
Clickable above = new CheckBox("I"m above!");
parent.add(above, new Rectangle(10, 10, 80, 20));
ButtonModel aModel = new ToggleModel();
aModel.addChangeListener(new ChangeListener() {
public void handleStateChanged(ChangeEvent e) {
label.setText("Above");
}
});
above.setModel(aModel);
Clickable below = new CheckBox("I"m below!");
parent.add(below, new Rectangle(10, 40, 80, 20));
ButtonModel bModel = new ToggleModel();
bModel.addChangeListener(new ChangeListener() {
public void handleStateChanged(ChangeEvent e) {
label.setText("Below");
}
});
below.setModel(bModel);
ButtonGroup bGroup = new ButtonGroup();
bGroup.add(aModel);
bGroup.add(bModel);
bGroup.setDefault(bModel);
parent.add(label, new Rectangle(10, 70, 80, 20));
shell.setSize(130, 120);
shell.open();
shell.setText("Example");
Display display = Display.getDefault();
while (!shell.isDisposed()) {
if (!display.readAndDispatch())
display.sleep();
}
}
}
</source>
SWT Graphics Example
<source lang="java">
import java.io.IOException; import java.io.InputStream; import java.util.HashSet; import java.util.Iterator; import java.util.MissingResourceException; import java.util.Random; import java.util.ResourceBundle; import java.util.Vector; import org.eclipse.swt.SWT; import org.eclipse.swt.SWTException; import org.eclipse.swt.graphics.Color; import org.eclipse.swt.graphics.Font; import org.eclipse.swt.graphics.FontData; import org.eclipse.swt.graphics.GC; import org.eclipse.swt.graphics.Image; import org.eclipse.swt.graphics.Path; import org.eclipse.swt.graphics.Point; import org.eclipse.swt.graphics.RGB; import org.eclipse.swt.graphics.Rectangle; import org.eclipse.swt.layout.GridData; import org.eclipse.swt.layout.GridLayout; import org.eclipse.swt.layout.RowLayout; import org.eclipse.swt.widgets.Canvas; import org.eclipse.swt.widgets.ColorDialog; import org.eclipse.swt.widgets.rubo; import org.eclipse.swt.widgets.ruposite; import org.eclipse.swt.widgets.Control; import org.eclipse.swt.widgets.Display; import org.eclipse.swt.widgets.Event; import org.eclipse.swt.widgets.Group; import org.eclipse.swt.widgets.Label; import org.eclipse.swt.widgets.Listener; import org.eclipse.swt.widgets.Menu; import org.eclipse.swt.widgets.MenuItem; import org.eclipse.swt.widgets.MessageBox; import org.eclipse.swt.widgets.Sash; import org.eclipse.swt.widgets.Shell; import org.eclipse.swt.widgets.Spinner; import org.eclipse.swt.widgets.ToolBar; import org.eclipse.swt.widgets.ToolItem; import org.eclipse.swt.widgets.Tree; import org.eclipse.swt.widgets.TreeItem; public class GraphicsExample {
Composite parent;
GraphicsTab[] tabs;
GraphicsTab tab;
Object[] tabBackground;
boolean animate;
Listener redrawListener;
ToolBar toolBar;
Tree tabList;
Canvas canvas;
Composite controlPanel, tabPanel;
ToolItem playItem, pauseItem, backItem, dbItem;
Spinner timerSpinner;
Menu backMenu;
MenuItem customMI;
Image customImage;
Color customColor;
Vector images;
static boolean advanceGraphics, advanceGraphicsInit;
static final int TIMER = 30;
public GraphicsExample(final Composite parent) {
this.parent = parent;
redrawListener = new Listener() {
public void handleEvent(Event e) {
redraw();
}
};
GridData data;
GridLayout layout = new GridLayout(3, false);
layout.horizontalSpacing = 1;
parent.setLayout(layout);
tabs = createTabs();
images = new Vector();
createToolBar(parent);
createTabList(parent);
final Sash sash = new Sash(parent, SWT.VERTICAL);
createTabPanel(parent);
data = new GridData(SWT.FILL, SWT.CENTER, true, false);
data.horizontalSpan = 3;
toolBar.setLayoutData(data);
data = new GridData(SWT.CENTER, SWT.FILL, false, true);
data.widthHint = tabList.ruputeSize(SWT.DEFAULT, SWT.DEFAULT).x + 50;
tabList.setLayoutData(data);
data = new GridData(SWT.CENTER, SWT.FILL, false, true);
sash.setLayoutData(data);
data = new GridData(SWT.FILL, SWT.FILL, true, true);
tabPanel.setLayoutData(data);
sash.addListener(SWT.Selection, new Listener() {
public void handleEvent(Event event) {
if (event.detail != SWT.DRAG) {
GridData data = (GridData) tabList.getLayoutData();
data.widthHint = event.x
- tabList.ruputeTrim(0, 0, 0, 0).width;
parent.layout(true);
animate = pauseItem.getEnabled();
} else {
animate = false;
}
}
});
setTab(tab);
startAnimationTimer();
}
boolean checkAdvancedGraphics() {
if (advanceGraphicsInit)
return advanceGraphics;
advanceGraphicsInit = true;
Display display = Display.getCurrent();
try {
Path path = new Path(display);
path.dispose();
} catch (SWTException e) {
Shell shell = display.getActiveShell(), newShell = null;
if (shell == null)
shell = newShell = new Shell(display);
MessageBox dialog = new MessageBox(shell, SWT.ICON_WARNING | SWT.OK);
dialog.setText("Warning"); //$NON-NLS-1$
dialog.setMessage("LibNotFound"); //$NON-NLS-1$
dialog.open();
if (newShell != null)
newShell.dispose();
return false;
}
return advanceGraphics = true;
}
void createCanvas(Composite parent) {
canvas = new Canvas(parent, SWT.NO_BACKGROUND);
canvas.addListener(SWT.Paint, new Listener() {
public void handleEvent(Event event) {
GC gc;
Rectangle rect = canvas.getClientArea();
Image buffer = null;
if (dbItem.getSelection()) {
buffer = new Image(canvas.getDisplay(), rect);
gc = new GC(buffer);
} else {
gc = event.gc;
}
paintBackground(gc, rect);
GraphicsTab tab = getTab();
if (tab != null)
tab.paint(gc, rect.width, rect.height);
if (gc != event.gc)
gc.dispose();
if (buffer != null) {
event.gc.drawImage(buffer, 0, 0);
buffer.dispose();
}
}
});
}
void createControlPanel(Composite parent) {
Group group;
controlPanel = group = new Group(parent, SWT.NONE);
group.setText(getResourceString("Settings")); //$NON-NLS-1$
controlPanel.setLayout(new RowLayout());
}
void createTabPanel(Composite parent) {
tabPanel = new Composite(parent, SWT.NONE);
GridData data;
GridLayout layout = new GridLayout(1, false);
layout.marginHeight = layout.marginWidth = 0;
tabPanel.setLayout(layout);
createCanvas(tabPanel);
createControlPanel(tabPanel);
data = new GridData(SWT.FILL, SWT.FILL, true, true);
canvas.setLayoutData(data);
data = new GridData(SWT.FILL, SWT.CENTER, true, false);
controlPanel.setLayoutData(data);
}
void createToolBar(final Composite parent) {
final Display display = parent.getDisplay();
toolBar = new ToolBar(parent, SWT.FLAT);
Listener toolBarListener = new Listener() {
public void handleEvent(Event event) {
switch (event.type) {
case SWT.Selection: {
if (event.widget == playItem) {
animate = true;
playItem.setEnabled(!animate);
pauseItem.setEnabled(animate);
} else if (event.widget == pauseItem) {
animate = false;
playItem.setEnabled(!animate);
pauseItem.setEnabled(animate);
} else if (event.widget == backItem) {
final ToolItem toolItem = (ToolItem) event.widget;
final ToolBar toolBar = toolItem.getParent();
Rectangle toolItemBounds = toolItem.getBounds();
Point point = toolBar.toDisplay(new Point(
toolItemBounds.x, toolItemBounds.y));
backMenu.setLocation(point.x, point.y
+ toolItemBounds.height);
backMenu.setVisible(true);
}
}
break;
}
}
};
playItem = new ToolItem(toolBar, SWT.PUSH);
playItem.setText(getResourceString("Play")); //$NON-NLS-1$
playItem.setImage(loadImage(display, "play.gif")); //$NON-NLS-1$
playItem.addListener(SWT.Selection, toolBarListener);
pauseItem = new ToolItem(toolBar, SWT.PUSH);
pauseItem.setText(getResourceString("Pause")); //$NON-NLS-1$
pauseItem.setImage(loadImage(display, "pause.gif")); //$NON-NLS-1$
pauseItem.addListener(SWT.Selection, toolBarListener);
backItem = new ToolItem(toolBar, SWT.PUSH);
backItem.setText(getResourceString("Background")); //$NON-NLS-1$
backItem.addListener(SWT.Selection, toolBarListener);
String[] names = new String[] { getResourceString("White"), //$NON-NLS-1$
getResourceString("Black"), //$NON-NLS-1$
getResourceString("Red"), //$NON-NLS-1$
getResourceString("Green"), //$NON-NLS-1$
getResourceString("Blue"), //$NON-NLS-1$
getResourceString("CustomColor"), //$NON-NLS-1$
};
Color[] colors = new Color[] { display.getSystemColor(SWT.COLOR_WHITE),
display.getSystemColor(SWT.COLOR_BLACK),
display.getSystemColor(SWT.COLOR_RED),
display.getSystemColor(SWT.COLOR_GREEN),
display.getSystemColor(SWT.COLOR_BLUE), null, };
backMenu = new Menu(parent);
Listener listener = new Listener() {
public void handleEvent(Event event) {
MenuItem item = (MenuItem) event.widget;
if (customMI == item) {
ColorDialog dialog = new ColorDialog(parent.getShell());
RGB rgb = dialog.open();
if (rgb == null)
return;
if (customColor != null)
customColor.dispose();
customColor = new Color(display, rgb);
if (customImage != null)
customImage.dispose();
customImage = createImage(display, customColor);
item.setData(new Object[] { customColor, customImage });
item.setImage(customImage);
}
tabBackground = (Object[]) item.getData();
backItem.setImage((Image) tabBackground[1]);
canvas.redraw();
}
};
for (int i = 0; i < names.length; i++) {
MenuItem item = new MenuItem(backMenu, SWT.NONE);
item.setText(names[i]);
item.addListener(SWT.Selection, listener);
Image image = null;
if (colors[i] != null) {
image = createImage(display, colors[i]);
images.addElement(image);
item.setImage(image);
} else {
// custom menu item
customMI = item;
}
item.setData(new Object[] { colors[i], image });
if (tabBackground == null) {
tabBackground = (Object[]) item.getData();
backItem.setImage((Image) tabBackground[1]);
}
}
dbItem = new ToolItem(toolBar, SWT.CHECK);
dbItem.setText(getResourceString("DoubleBuffer")); //$NON-NLS-1$
dbItem.setImage(loadImage(display, "db.gif")); //$NON-NLS-1$
ToolItem separator = new ToolItem(toolBar, SWT.SEPARATOR);
Composite comp = new Composite(toolBar, SWT.NONE);
GridData data;
GridLayout layout = new GridLayout(1, false);
layout.verticalSpacing = 0;
layout.marginWidth = layout.marginHeight = 3;
comp.setLayout(layout);
timerSpinner = new Spinner(comp, SWT.BORDER | SWT.WRAP);
data = new GridData(SWT.CENTER, SWT.CENTER, false, false);
timerSpinner.setLayoutData(data);
Label label = new Label(comp, SWT.NONE);
label.setText(getResourceString("Animation")); //$NON-NLS-1$
data = new GridData(SWT.CENTER, SWT.CENTER, false, false);
label.setLayoutData(data);
timerSpinner.setMaximum(1000);
timerSpinner.setSelection(TIMER);
timerSpinner.setSelection(TIMER);
separator.setControl(comp);
separator.setWidth(comp.ruputeSize(SWT.DEFAULT, SWT.DEFAULT).x);
}
Image createImage(Display display, Color color) {
Image image = new Image(display, 16, 16);
GC gc = new GC(image);
gc.setBackground(color);
Rectangle rect = image.getBounds();
gc.fillRectangle(rect);
if (color.equals(display.getSystemColor(SWT.COLOR_BLACK))) {
gc.setForeground(display.getSystemColor(SWT.COLOR_WHITE));
}
gc.drawRectangle(rect.x, rect.y, rect.width - 1, rect.height - 1);
gc.dispose();
return image;
}
void createTabList(Composite parent) {
tabList = new Tree(parent, SWT.SINGLE | SWT.H_SCROLL | SWT.V_SCROLL
| SWT.BORDER);
HashSet set = new HashSet();
for (int i = 0; i < tabs.length; i++) {
GraphicsTab tab = tabs[i];
set.add(tab.getCategory());
}
for (Iterator iter = set.iterator(); iter.hasNext();) {
String text = (String) iter.next();
TreeItem item = new TreeItem(tabList, SWT.NONE);
item.setText(text);
}
TreeItem[] items = tabList.getItems();
for (int i = 0; i < items.length; i++) {
TreeItem item = items[i];
for (int j = 0; j < tabs.length; j++) {
GraphicsTab tab = tabs[j];
if (item.getText().equals(tab.getCategory())) {
TreeItem item1 = new TreeItem(item, SWT.NONE);
item1.setText(tab.getText());
item1.setData(tab);
}
}
}
tabList.addListener(SWT.Selection, new Listener() {
public void handleEvent(Event event) {
TreeItem item = (TreeItem) event.item;
if (item != null) {
setTab((GraphicsTab) item.getData());
}
}
});
}
GraphicsTab[] createTabs() {
return new GraphicsTab[] { new LineTab(this), new StarPolyTab(this),
tab = new IntroTab(this), new BlackHoleTab(this), };
}
/**
* Disposes all resources created by the receiver.
*/
public void dispose() {
if (tabs != null) {
for (int i = 0; i < tabs.length; i++) {
GraphicsTab tab = tabs[i];
tab.dispose();
}
}
tabs = null;
if (images != null) {
for (int i = 0; i < images.size(); i++) {
((Image) images.elementAt(i)).dispose();
}
}
images = null;
if (customColor != null)
customColor.dispose();
customColor = null;
if (customImage != null)
customImage.dispose();
customImage = null;
}
TreeItem findItemByData(TreeItem[] items, Object data) {
for (int i = 0; i < items.length; i++) {
TreeItem item = items[i];
if (item.getData() == data)
return item;
item = findItemByData(item.getItems(), data);
if (item != null)
return item;
}
return null;
}
/**
* Gets the current tab.
*/
public GraphicsTab getTab() {
return tab;
}
Listener getRedrawListener() {
return redrawListener;
}
/**
* Gets a string from the resource bundle. We don"t want to crash because of
* a missing String. Returns the key if not found.
*/
static String getResourceString(String key) {
return "key";
}
static Image loadImage(Display display, Class clazz, String string) {
InputStream stream = clazz.getResourceAsStream(string);
if (stream == null)
return null;
Image image = null;
try {
image = new Image(display, stream);
} catch (SWTException ex) {
} finally {
try {
stream.close();
} catch (IOException ex) {
}
}
return image;
}
Image loadImage(Display display, String name) {
Image image = loadImage(display, GraphicsExample.class, name);
if (image != null)
images.addElement(image);
return image;
}
void paintBackground(GC gc, Rectangle rect) {
gc.setBackground((Color) tabBackground[0]);
gc.fillRectangle(rect);
}
/**
* Redraws the current tab.
*/
public void redraw() {
canvas.redraw();
}
/**
* Grabs input focus.
*/
public void setFocus() {
tabList.setFocus();
}
/**
* Sets the current tab.
*/
public void setTab(GraphicsTab tab) {
this.tab = tab;
Control[] children = controlPanel.getChildren();
for (int i = 0; i < children.length; i++) {
Control control = children[i];
control.dispose();
}
if (tab != null) {
tab.createControlPanel(controlPanel);
animate = tab.isAnimated();
}
playItem.setEnabled(!animate);
pauseItem.setEnabled(animate);
GridData data = (GridData) controlPanel.getLayoutData();
children = controlPanel.getChildren();
data.exclude = children.length == 0;
controlPanel.setVisible(!data.exclude);
if (data.exclude) {
tabPanel.layout();
} else {
tabPanel.layout(children);
}
if (tab != null) {
TreeItem[] selection = tabList.getSelection();
if (selection.length == 0 || selection[0].getData() != tab) {
TreeItem item = findItemByData(tabList.getItems(), tab);
if (item != null)
tabList.setSelection(new TreeItem[] { item });
}
}
canvas.redraw();
}
void startAnimationTimer() {
final Display display = Display.getCurrent();
display.timerExec(timerSpinner.getSelection(), new Runnable() {
public void run() {
if (canvas.isDisposed())
return;
if (animate) {
GraphicsTab tab = getTab();
if (tab != null && tab.isAnimated()) {
Rectangle rect = canvas.getClientArea();
tab.next(rect.width, rect.height);
canvas.redraw();
canvas.update();
}
}
display.timerExec(timerSpinner.getSelection(), this);
}
});
}
public static void main(String[] args) {
Display display = new Display();
Shell shell = new Shell(display);
shell.setText(getResourceString("SWTGraphics")); //$NON-NLS-1$
final GraphicsExample example = new GraphicsExample(shell);
shell.addListener(SWT.Close, new Listener() {
public void handleEvent(Event event) {
example.dispose();
}
});
shell.open();
while (!shell.isDisposed()) {
if (!display.readAndDispatch())
display.sleep();
}
}
} /*******************************************************************************
* 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 ******************************************************************************/
abstract class GraphicsTab {
GraphicsExample example;
public GraphicsTab(GraphicsExample example) {
this.example = example;
}
/**
* Creates the widgets used to control the drawing.
*/
public void createControlPanel(Composite parent) {
}
/**
* Disposes resources created by the receiver.
*/
public void dispose() {
}
/**
* Answer the receiver"s name.
*/
public abstract String getText();
/**
* Answer the receiver"s category.
*/
public String getCategory() {
return GraphicsExample.getResourceString("Misc"); //$NON-NLS-1$
}
/**
* Answer whether the receiver is animated or not.
*/
public boolean isAnimated() {
return false;
}
/**
* Advance the animation.
*/
public void next(int width, int height) {
}
/**
* Paint the receiver into the specified GC.
*/
public void paint(GC gc, int width, int height) {
}
} /*******************************************************************************
* 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 ******************************************************************************/
class LineTab extends GraphicsTab {
public LineTab(GraphicsExample example) {
super(example);
}
public String getText() {
return GraphicsExample.getResourceString("Line"); //$NON-NLS-1$
}
public void paint(GC gc, int width, int height) {
gc.drawLine(0, 0, width, height);
gc.drawLine(width, 0, 0, height);
}
} /*******************************************************************************
* 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 ******************************************************************************/
class StarPolyTab extends GraphicsTab {
int[] radial;
static final int POINTS = 11;
Combo fillRuleCb;
public StarPolyTab(GraphicsExample example) {
super(example);
radial = new int[POINTS * 2];
}
public void createControlPanel(Composite parent) {
new Label(parent, SWT.NONE).setText(GraphicsExample
.getResourceString("FillRule")); //$NON-NLS-1$
fillRuleCb = new Combo(parent, SWT.DROP_DOWN);
fillRuleCb.add("FILL_EVEN_ODD");
fillRuleCb.add("FILL_WINDING");
fillRuleCb.select(0);
fillRuleCb.addListener(SWT.Selection, example.getRedrawListener());
}
public String getCategory() {
return GraphicsExample.getResourceString("Polygons"); //$NON-NLS-1$
}
public String getText() {
return GraphicsExample.getResourceString("StarPolygon"); //$NON-NLS-1$
}
public void paint(GC gc, int width, int height) {
int centerX = width / 2;
int centerY = height / 2;
int pos = 0;
for (int i = 0; i < POINTS; ++i) {
double r = Math.PI * 2 * pos / POINTS;
radial[i * 2] = (int) ((1 + Math.cos(r)) * centerX);
radial[i * 2 + 1] = (int) ((1 + Math.sin(r)) * centerY);
pos = (pos + POINTS / 2) % POINTS;
}
Display display = Display.getCurrent();
gc.setFillRule(fillRuleCb.getSelectionIndex() != 0 ? SWT.FILL_WINDING
: SWT.FILL_EVEN_ODD);
gc.setBackground(display.getSystemColor(SWT.COLOR_WHITE));
gc.fillPolygon(radial);
gc.drawPolygon(radial);
}
} /*******************************************************************************
* 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 ******************************************************************************/
class BlackHoleTab extends GraphicsTab {
int size = 1;
public BlackHoleTab(GraphicsExample example) {
super(example);
}
public String getText() {
return GraphicsExample.getResourceString("BlackHole"); //$NON-NLS-1$
}
public boolean isAnimated() {
return true;
}
public void next(int width, int height) {
if (size > width * 3 / 2)
size = 0;
else
size += 10;
}
public void paint(GC gc, int width, int height) {
Display display = Display.getCurrent();
gc.setBackground(display.getSystemColor(SWT.COLOR_BLACK));
gc.fillOval((width - size) / 2, (height - size) / 2, size, size);
}
} /*******************************************************************************
* 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 ******************************************************************************/
class IntroTab extends GraphicsTab {
Font font;
Image image;
Random random = new Random();
float x, y;
float incX = 10.0f;
float incY = 5.0f;
int textWidth, textHeight;
String text = "SWT";
public IntroTab(GraphicsExample example) {
super(example);
}
public void dispose() {
if (image != null)
image.dispose();
image = null;
if (font != null)
font.dispose();
font = null;
}
public String getCategory() {
return GraphicsExample.getResourceString("Introduction"); //$NON-NLS-1$
}
public String getText() {
return GraphicsExample.getResourceString("SWT"); //$NON-NLS-1$
}
public boolean isAnimated() {
return true;
}
public void next(int width, int height) {
x += incX;
y += incY;
float random = (float) Math.random();
if (x + textWidth > width) {
x = width - textWidth;
incX = random * -width / 16 - 1;
}
if (x < 0) {
x = 0;
incX = random * width / 16 + 1;
}
if (y + textHeight > height) {
y = (height - textHeight) - 2;
incY = random * -height / 16 - 1;
}
if (y < 0) {
y = 0;
incY = random * height / 16 + 1;
}
}
public void paint(GC gc, int width, int height) {
if (!example.checkAdvancedGraphics())
return;
Display display = Display.getCurrent();
if (image == null) {
image = example.loadImage(Display.getCurrent(), "irmaos.jpg");
Rectangle rect = image.getBounds();
FontData fd = display.getSystemFont().getFontData()[0];
font = new Font(display, fd.getName(), rect.height / 4, SWT.BOLD);
gc.setFont(font);
Point size = gc.stringExtent(text);
textWidth = size.x;
textHeight = size.y;
}
Path path = new Path(display);
path.addString(text, x, y, font);
gc.setClipping(path);
Rectangle rect = image.getBounds();
gc.drawImage(image, 0, 0, rect.width, rect.height, 0, 0, width, height);
gc.setClipping((Rectangle) null);
gc.setForeground(display.getSystemColor(SWT.COLOR_BLUE));
gc.drawPath(path);
}
}
</source>
SWT OpenGL snippet: draw a square
<source lang="java">
/*******************************************************************************
* 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: * Sebastian Davids - initial implementation * IBM Corporation *******************************************************************************/
package org.eclipse.swt.snippets; /*
* SWT OpenGL snippet: draw a square * * This snippet requires the experimental org.eclipse.swt.opengl plugin, which * is not included in swt by default. For information on this plugin see * http://dev.eclipse.org/viewcvs/index.cgi/%7Echeckout%7E/platform-swt-home/opengl/opengl.html * * For a list of all SWT example snippets see * http://dev.eclipse.org/viewcvs/index.cgi/%7Echeckout%7E/platform-swt-home/dev.html#snippets */
import org.eclipse.swt.SWT; import org.eclipse.swt.events.*; import org.eclipse.swt.graphics.*; import org.eclipse.swt.layout.*; import org.eclipse.swt.opengl.*; import org.eclipse.swt.widgets.*; public class Snippet174 {
public static void main(String[] args) {
Display display = new Display();
Shell shell = new Shell(display);
shell.setText("OpenGL in SWT");
shell.setLayout(new FillLayout());
final Canvas canvas = new Canvas(shell, SWT.NO_BACKGROUND);
canvas.addControlListener(new ControlAdapter() {
public void controlResized(ControlEvent e) {
resize(canvas);
}
});
final GLContext context = init(canvas);
shell.addDisposeListener(new DisposeListener() {
public void widgetDisposed(DisposeEvent e) {
context.dispose();
}
});
new Runnable() {
public void run() {
if (canvas.isDisposed())
return;
render();
context.swapBuffers();
canvas.getDisplay().timerExec(50, this);
}
}.run();
shell.open();
while (!shell.isDisposed()) {
if (!display.readAndDispatch())
display.sleep();
}
display.dispose();
}
static GLContext init(Canvas canvas) {
GLContext context = new GLContext(canvas);
context.setCurrent();
resize(canvas);
GL.glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
GL.glColor3f(0.0f, 0.0f, 0.0f);
GL.glClearDepth(1.0f);
GL.glEnable(GL.GL_DEPTH_TEST);
GL.glHint(GL.GL_PERSPECTIVE_CORRECTION_HINT, GL.GL_NICEST);
return context;
}
static void render() {
GL.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT);
GL.glLoadIdentity();
GL.glTranslatef(0.0f, 0.0f, -6.0f);
GL.glBegin(GL.GL_QUADS);
GL.glVertex3f(-1.0f, 1.0f, 0.0f);
GL.glVertex3f(1.0f, 1.0f, 0.0f);
GL.glVertex3f(1.0f, -1.0f, 0.0f);
GL.glVertex3f(-1.0f, -1.0f, 0.0f);
GL.glEnd();
}
static void resize(Canvas canvas) {
Rectangle rect = canvas.getClientArea();
int width = rect.width;
int height = Math.max(rect.height, 1);
GL.glViewport(0, 0, width, height);
GL.glMatrixMode(GL.GL_PROJECTION);
GL.glLoadIdentity();
float aspect = (float) width / (float) height;
GLU.gluPerspective(45.0f, aspect, 0.5f, 400.0f);
GL.glMatrixMode(GL.GL_MODELVIEW);
GL.glLoadIdentity();
}
}
</source>
SWT Paint Example
<source lang="java">
import org.eclipse.swt.*; import org.eclipse.swt.graphics.*; import org.eclipse.swt.widgets.*; import org.eclipse.swt.events.*; import org.eclipse.swt.layout.*; import org.eclipse.swt.accessibility.*; import java.io.*; import java.text.*; import java.util.*; public class PaintExample {
private Composite mainComposite;
private Canvas activeForegroundColorCanvas;
private Canvas activeBackgroundColorCanvas;
private Color paintColorBlack, paintColorWhite; // alias for paintColors[0] and [1]
private Color[] paintColors;
private Font paintDefaultFont; // do not free
private static final int numPaletteRows = 3;
private static final int numPaletteCols = 50;
private ToolSettings toolSettings; // current active settings
private PaintSurface paintSurface; // paint surface for drawing
static final int Pencil_tool = 0;
static final int Airbrush_tool = 1;
static final int Line_tool = 2;
static final int PolyLine_tool = 3;
static final int Rectangle_tool = 4;
static final int RoundedRectangle_tool = 5;
static final int Ellipse_tool = 6;
static final int Text_tool = 7;
static final int None_fill = 8;
static final int Outline_fill = 9;
static final int Solid_fill = 10;
static final int Solid_linestyle = 11;
static final int Dash_linestyle = 12;
static final int Dot_linestyle = 13;
static final int DashDot_linestyle = 14;
static final int Font_options = 15;
static final int Default_tool = Pencil_tool;
static final int Default_fill = None_fill;
static final int Default_linestyle = Solid_linestyle;
public static final Tool[] tools = {
new Tool(Pencil_tool, "Pencil", "tool", SWT.RADIO),
new Tool(Airbrush_tool, "Airbrush", "tool", SWT.RADIO),
new Tool(Line_tool, "Line", "tool", SWT.RADIO),
new Tool(PolyLine_tool, "PolyLine", "tool", SWT.RADIO),
new Tool(Rectangle_tool, "Rectangle", "tool", SWT.RADIO),
new Tool(RoundedRectangle_tool, "RoundedRectangle", "tool", SWT.RADIO),
new Tool(Ellipse_tool, "Ellipse", "tool", SWT.RADIO),
new Tool(Text_tool, "Text", "tool", SWT.RADIO),
new Tool(None_fill, "None", "fill", SWT.RADIO, new Integer(ToolSettings.ftNone)),
new Tool(Outline_fill, "Outline", "fill", SWT.RADIO, new Integer(ToolSettings.ftOutline)),
new Tool(Solid_fill, "Solid", "fill", SWT.RADIO, new Integer(ToolSettings.ftSolid)),
new Tool(Solid_linestyle, "Solid", "linestyle", SWT.RADIO, new Integer(SWT.LINE_SOLID)),
new Tool(Dash_linestyle, "Dash", "linestyle", SWT.RADIO, new Integer(SWT.LINE_DASH)),
new Tool(Dot_linestyle, "Dot", "linestyle", SWT.RADIO, new Integer(SWT.LINE_DOT)),
new Tool(DashDot_linestyle, "DashDot", "linestyle", SWT.RADIO, new Integer(SWT.LINE_DASHDOT)),
new Tool(Font_options, "Font", "options", SWT.PUSH)
};
/**
* Creates an instance of a PaintExample embedded inside
* the supplied parent Composite.
*
* @param parent the container of the example
*/
public PaintExample(Composite parent) {
mainComposite = parent;
initResources();
initActions();
init();
}
/**
* Invokes as a standalone program.
*/
public static void main(String[] args) {
Display display = new Display();
Shell shell = new Shell(display);
shell.setText(getResourceString("window.title"));
shell.setLayout(new GridLayout());
PaintExample instance = new PaintExample(shell);
instance.createToolBar(shell);
Composite composite = new Composite(shell, SWT.NONE);
composite.setLayout(new FillLayout());
composite.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));
instance.createGUI(composite);
instance.setDefaults();
setShellSize(display, shell);
shell.open();
while (! shell.isDisposed()) {
if (! display.readAndDispatch()) display.sleep();
}
instance.dispose();
}
/**
* Creates the toolbar.
* Note: Only called by standalone.
*/
private void createToolBar(Composite parent) {
ToolBar toolbar = new ToolBar (parent, SWT.NONE);
String group = null;
for (int i = 0; i < tools.length; i++) {
Tool tool = tools[i];
if (group != null && !tool.group.equals(group)) {
new ToolItem (toolbar, SWT.SEPARATOR);
}
group = tool.group;
ToolItem item = addToolItem(toolbar, tool);
if (i == Default_tool || i == Default_fill || i == Default_linestyle) item.setSelection(true);
}
}
/**
* Adds a tool item to the toolbar.
* Note: Only called by standalone.
*/
private ToolItem addToolItem(final ToolBar toolbar, final Tool tool) {
final String id = tool.group + "." + tool.name;
ToolItem item = new ToolItem (toolbar, tool.type);
item.setText (getResourceString(id + ".label"));
item.setToolTipText(getResourceString(id + ".tooltip"));
item.setImage(tool.image);
item.addSelectionListener(new SelectionAdapter() {
public void widgetSelected(SelectionEvent e) {
tool.action.run();
}
});
final int childID = toolbar.indexOf(item);
toolbar.getAccessible().addAccessibleListener(new AccessibleAdapter() {
public void getName(org.eclipse.swt.accessibility.AccessibleEvent e) {
if (e.childID == childID) {
e.result = getResourceString(id + ".description");
}
}
});
return item;
}
/**
* Sets the default tool item states.
*/
public void setDefaults() {
setPaintTool(Default_tool);
setFillType(Default_fill);
setLineStyle(Default_linestyle);
setForegroundColor(paintColorBlack);
setBackgroundColor(paintColorWhite);
}
/**
* Creates the GUI.
*/
public void createGUI(Composite parent) {
GridLayout gridLayout;
GridData gridData;
/*** Create principal GUI layout elements ***/
Composite displayArea = new Composite(parent, SWT.NONE);
gridLayout = new GridLayout();
gridLayout.numColumns = 1;
displayArea.setLayout(gridLayout);
// Creating these elements here avoids the need to instantiate the GUI elements
// in strict layout order. The natural layout ordering is an artifact of using
// SWT layouts, but unfortunately it is not the same order as that required to
// instantiate all of the non-GUI application elements to satisfy referential
// dependencies. It is possible to reorder the initialization to some extent, but
// this can be very tedious.
// paint canvas
final Canvas paintCanvas = new Canvas(displayArea, SWT.BORDER | SWT.V_SCROLL | SWT.H_SCROLL |
SWT.NO_REDRAW_RESIZE | SWT.NO_BACKGROUND);
gridData = new GridData(GridData.FILL_HORIZONTAL | GridData.FILL_VERTICAL);
paintCanvas.setLayoutData(gridData);
paintCanvas.setBackground(paintColorWhite);
// color selector frame
final Composite colorFrame = new Composite(displayArea, SWT.NONE);
gridData = new GridData(GridData.FILL_HORIZONTAL | GridData.VERTICAL_ALIGN_FILL);
colorFrame.setLayoutData(gridData);
// tool settings frame
final Composite toolSettingsFrame = new Composite(displayArea, SWT.NONE);
gridData = new GridData(GridData.FILL_HORIZONTAL | GridData.VERTICAL_ALIGN_FILL);
toolSettingsFrame.setLayoutData(gridData);
// status text
final Text statusText = new Text(displayArea, SWT.BORDER | SWT.SINGLE | SWT.READ_ONLY);
gridData = new GridData(GridData.FILL_HORIZONTAL | GridData.VERTICAL_ALIGN_FILL);
statusText.setLayoutData(gridData);
/*** Create the remaining application elements inside the principal GUI layout elements ***/
// paintSurface
paintSurface = new PaintSurface(paintCanvas, statusText, paintColorWhite);
// finish initializing the tool data
tools[Pencil_tool].data = new PencilTool(toolSettings, paintSurface);
tools[Airbrush_tool].data = new AirbrushTool(toolSettings, paintSurface);
tools[Line_tool].data = new LineTool(toolSettings, paintSurface);
tools[PolyLine_tool].data = new PolyLineTool(toolSettings, paintSurface);
tools[Rectangle_tool].data = new RectangleTool(toolSettings, paintSurface);
tools[RoundedRectangle_tool].data = new RoundedRectangleTool(toolSettings, paintSurface);
tools[Ellipse_tool].data = new EllipseTool(toolSettings, paintSurface);
tools[Text_tool].data = new TextTool(toolSettings, paintSurface);
// colorFrame
gridLayout = new GridLayout();
gridLayout.numColumns = 3;
gridLayout.marginHeight = 0;
gridLayout.marginWidth = 0;
colorFrame.setLayout(gridLayout);
// activeForegroundColorCanvas, activeBackgroundColorCanvas
activeForegroundColorCanvas = new Canvas(colorFrame, SWT.BORDER);
gridData = new GridData(GridData.HORIZONTAL_ALIGN_FILL);
gridData.heightHint = 24;
gridData.widthHint = 24;
activeForegroundColorCanvas.setLayoutData(gridData);
activeBackgroundColorCanvas = new Canvas(colorFrame, SWT.BORDER);
gridData = new GridData(GridData.HORIZONTAL_ALIGN_FILL);
gridData.heightHint = 24;
gridData.widthHint = 24;
activeBackgroundColorCanvas.setLayoutData(gridData);
// paletteCanvas
final Canvas paletteCanvas = new Canvas(colorFrame, SWT.BORDER | SWT.NO_BACKGROUND);
gridData = new GridData(GridData.FILL_HORIZONTAL);
gridData.heightHint = 24;
paletteCanvas.setLayoutData(gridData);
paletteCanvas.addListener(SWT.MouseDown, new Listener() {
public void handleEvent(Event e) {
Rectangle bounds = paletteCanvas.getClientArea();
Color color = getColorAt(bounds, e.x, e.y);
if (e.button == 1) setForegroundColor(color);
else setBackgroundColor(color);
}
private Color getColorAt(Rectangle bounds, int x, int y) {
if (bounds.height <= 1 && bounds.width <= 1) return paintColorWhite;
final int row = (y - bounds.y) * numPaletteRows / bounds.height;
final int col = (x - bounds.x) * numPaletteCols / bounds.width;
return paintColors[Math.min(Math.max(row * numPaletteCols + col, 0), paintColors.length - 1)];
}
});
Listener refreshListener = new Listener() {
public void handleEvent(Event e) {
if (e.gc == null) return;
Rectangle bounds = paletteCanvas.getClientArea();
for (int row = 0; row < numPaletteRows; ++row) {
for (int col = 0; col < numPaletteCols; ++col) {
final int x = bounds.width * col / numPaletteCols;
final int y = bounds.height * row / numPaletteRows;
final int width = Math.max(bounds.width * (col + 1) / numPaletteCols - x, 1);
final int height = Math.max(bounds.height * (row + 1) / numPaletteRows - y, 1);
e.gc.setBackground(paintColors[row * numPaletteCols + col]);
e.gc.fillRectangle(bounds.x + x, bounds.y + y, width, height);
}
}
}
};
paletteCanvas.addListener(SWT.Resize, refreshListener);
paletteCanvas.addListener(SWT.Paint, refreshListener);
//paletteCanvas.redraw();
// toolSettingsFrame
gridLayout = new GridLayout();
gridLayout.numColumns = 4;
gridLayout.marginHeight = 0;
gridLayout.marginWidth = 0;
toolSettingsFrame.setLayout(gridLayout);
Label label = new Label(toolSettingsFrame, SWT.NONE);
label.setText(getResourceString("settings.AirbrushRadius.text"));
final Scale airbrushRadiusScale = new Scale(toolSettingsFrame, SWT.HORIZONTAL);
airbrushRadiusScale.setMinimum(5);
airbrushRadiusScale.setMaximum(50);
airbrushRadiusScale.setSelection(toolSettings.airbrushRadius);
airbrushRadiusScale.setLayoutData(new GridData(GridData.FILL_HORIZONTAL | GridData.VERTICAL_ALIGN_FILL));
airbrushRadiusScale.addSelectionListener(new SelectionAdapter() {
public void widgetSelected(SelectionEvent e) {
toolSettings.airbrushRadius = airbrushRadiusScale.getSelection();
updateToolSettings();
}
});
label = new Label(toolSettingsFrame, SWT.NONE);
label.setText(getResourceString("settings.AirbrushIntensity.text"));
final Scale airbrushIntensityScale = new Scale(toolSettingsFrame, SWT.HORIZONTAL);
airbrushIntensityScale.setMinimum(1);
airbrushIntensityScale.setMaximum(100);
airbrushIntensityScale.setSelection(toolSettings.airbrushIntensity);
airbrushIntensityScale.setLayoutData(new GridData(GridData.FILL_HORIZONTAL | GridData.VERTICAL_ALIGN_FILL));
airbrushIntensityScale.addSelectionListener(new SelectionAdapter() {
public void widgetSelected(SelectionEvent e) {
toolSettings.airbrushIntensity = airbrushIntensityScale.getSelection();
updateToolSettings();
}
});
}
/**
* Disposes of all resources associated with a particular
* instance of the PaintExample.
*/
public void dispose() {
if (paintSurface != null) paintSurface.dispose();
if (paintColors != null) {
for (int i = 0; i < paintColors.length; ++i) {
final Color color = paintColors[i];
if (color != null) color.dispose();
}
}
paintDefaultFont = null;
paintColors = null;
paintSurface = null;
freeResources();
}
/**
* Frees the resource bundle resources.
*/
public void freeResources() {
for (int i = 0; i < tools.length; ++i) {
Tool tool = tools[i];
final Image image = tool.image;
if (image != null) image.dispose();
tool.image = null;
}
}
/**
* Returns the Display.
*
* @return the display we"re using
*/
public Display getDisplay() {
return mainComposite.getDisplay();
}
/**
* Gets a string from the resource bundle.
* We don"t want to crash because of a missing String.
* Returns the key if not found.
*/
public static String getResourceString(String key) {
return key;
}
/**
* Gets a string from the resource bundle and binds it
* with the given arguments. If the key is not found,
* return the key.
*/
public static String getResourceString(String key, Object[] args) {
try {
return MessageFormat.format(getResourceString(key), args);
} catch (MissingResourceException e) {
return key;
} catch (NullPointerException e) {
return "!" + key + "!";
}
}
/**
* Initialize colors, fonts, and tool settings.
*/
private void init() {
Display display = mainComposite.getDisplay();
paintColorWhite = new Color(display, 255, 255, 255);
paintColorBlack = new Color(display, 0, 0, 0);
paintDefaultFont = display.getSystemFont();
paintColors = new Color[numPaletteCols * numPaletteRows];
paintColors[0] = paintColorBlack;
paintColors[1] = paintColorWhite;
for (int i = 2; i < paintColors.length; i++) {
paintColors[i] = new Color(display,
((i*7)%255),((i*23)%255), ((i*51)%255));
}
toolSettings = new ToolSettings();
toolSettings.rumonForegroundColor = paintColorBlack;
toolSettings.rumonBackgroundColor = paintColorWhite;
toolSettings.rumonFont = paintDefaultFont;
}
/**
* Sets the action field of the tools
*/
private void initActions() {
for (int i = 0; i < tools.length; ++i) {
final Tool tool = tools[i];
String group = tool.group;
if (group.equals("tool")) {
tool.action = new Runnable() {
public void run() {
setPaintTool(tool.id);
}
};
} else if (group.equals("fill")) {
tool.action = new Runnable() {
public void run() {
setFillType(tool.id);
}
};
} else if (group.equals("linestyle")) {
tool.action = new Runnable() {
public void run() {
setLineStyle(tool.id);
}
};
} else if (group.equals("options")) {
tool.action = new Runnable() {
public void run() {
FontDialog fontDialog = new FontDialog(paintSurface.getShell(), SWT.PRIMARY_MODAL);
FontData[] fontDatum = toolSettings.rumonFont.getFontData();
if (fontDatum != null && fontDatum.length > 0) {
fontDialog.setFontList(fontDatum);
}
fontDialog.setText(getResourceString("options.Font.dialog.title"));
paintSurface.hideRubberband();
FontData fontData = fontDialog.open();
paintSurface.showRubberband();
if (fontData != null) {
try {
Font font = new Font(mainComposite.getDisplay(), fontData);
toolSettings.rumonFont = font;
updateToolSettings();
} catch (SWTException ex) {
}
}
}
};
}
}
}
/**
* Loads the image resources.
*/
public void initResources() {
final Class clazz = PaintExample.class;
try {
for (int i = 0; i < tools.length; ++i) {
Tool tool = tools[i];
String id = tool.group + "." + tool.name;
InputStream sourceStream = clazz.getResourceAsStream(getResourceString(id + ".image"));
ImageData source = new ImageData(sourceStream);
ImageData mask = source.getTransparencyMask();
tool.image = new Image(null, source, mask);
try {
sourceStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
return;
} catch (Throwable t) {
}
String error = "Unable to load resources";
freeResources();
throw new RuntimeException(error);
}
/**
* Grabs input focus.
*/
public void setFocus() {
mainComposite.setFocus();
}
/**
* Sets the tool foreground color.
*
* @param color the new color to use
*/
public void setForegroundColor(Color color) {
if (activeForegroundColorCanvas != null)
activeForegroundColorCanvas.setBackground(color);
toolSettings.rumonForegroundColor = color;
updateToolSettings();
}
/**
* Set the tool background color.
*
* @param color the new color to use
*/
public void setBackgroundColor(Color color) {
if (activeBackgroundColorCanvas != null)
activeBackgroundColorCanvas.setBackground(color);
toolSettings.rumonBackgroundColor = color;
updateToolSettings();
}
/**
* Selects a tool given its ID.
*/
public void setPaintTool(int id) {
PaintTool paintTool = (PaintTool) tools[id].data;
paintSurface.setPaintSession(paintTool);
updateToolSettings();
}
/**
* Selects a filltype given its ID.
*/
public void setFillType(int id) {
Integer fillType = (Integer) tools[id].data;
toolSettings.rumonFillType = fillType.intValue();
updateToolSettings();
}
/**
* Selects line type given its ID.
*/
public void setLineStyle(int id) {
Integer lineType = (Integer) tools[id].data;
toolSettings.rumonLineStyle = lineType.intValue();
updateToolSettings();
}
/**
* Sets the size of the shell to it"s "packed" size,
* unless that makes it bigger than the display,
* in which case set it to 9/10 of display size.
*/
private static void setShellSize (Display display, Shell shell) {
Rectangle bounds = display.getBounds();
Point size = shell.ruputeSize (SWT.DEFAULT, SWT.DEFAULT);
if (size.x > bounds.width) size.x = bounds.width * 9 / 10;
if (size.y > bounds.height) size.y = bounds.height * 9 / 10;
shell.setSize (size);
}
/**
* Notifies the tool that its settings have changed.
*/
private void updateToolSettings() {
final PaintTool activePaintTool = paintSurface.getPaintTool();
if (activePaintTool == null) return;
activePaintTool.endSession();
activePaintTool.set(toolSettings);
activePaintTool.beginSession();
}
}
/*******************************************************************************
* 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 *******************************************************************************/
/**
* Tool Settings objects group tool-related configuration information. */
class ToolSettings {
public static final int ftNone = 0, ftOutline = 1, ftSolid = 2; /** * commonForegroundColor: current tool foreground colour */ public Color commonForegroundColor; /** * commonBackgroundColor: current tool background colour */ public Color commonBackgroundColor; /** * commonFont: current font */ public Font commonFont; /** * commonFillType: current fill type*
One of ftNone, ftOutline, ftSolid.
*/ public int commonFillType = ftNone; /** * commonLineStyle: current line type */ public int commonLineStyle = SWT.LINE_SOLID; /** * airbrushRadius: coverage radius in pixels */ public int airbrushRadius = 10; /** * airbrushIntensity: average surface area coverage in region defined by radius per "jot" */ public int airbrushIntensity = 30; /** * roundedRectangleCornerDiameter: the diameter of curvature of corners in a rounded rectangle */ public int roundedRectangleCornerDiameter = 16;
}
/*******************************************************************************
* 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 *******************************************************************************/
class Tool {
public int id;
public String name;
public String group;
public int type;
public Runnable action;
public Image image = null;
public Object data;
public Tool(int id, String name, String group, int type) {
super();
this.id = id;
this.name = name;
this.group = group;
this.type = type;
}
public Tool(int id, String name, String group, int type, Object data) {
this(id, name, group, type);
this.data = data;
}
}
/*******************************************************************************
* 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 *******************************************************************************/
/**
* A text drawing tool. */
class TextTool extends BasicPaintSession implements PaintTool {
private ToolSettings settings;
private String drawText = PaintExample.getResourceString("tool.Text.settings.defaulttext");
/**
* Constructs a PaintTool.
*
* @param toolSettings the new tool settings
* @param paintSurface the PaintSurface we will render on.
*/
public TextTool(ToolSettings toolSettings, PaintSurface paintSurface) {
super(paintSurface);
set(toolSettings);
}
/**
* Sets the tool"s settings.
*
* @param toolSettings the new tool settings
*/
public void set(ToolSettings toolSettings) {
settings = toolSettings;
}
/**
* Returns name associated with this tool.
*
* @return the localized name of this tool
*/
public String getDisplayName() {
return PaintExample.getResourceString("tool.Text.label");
}
/**
* Activates the tool.
*/
public void beginSession() {
getPaintSurface().setStatusMessage(PaintExample.getResourceString(
"session.Text.message"));
}
/**
* Deactivates the tool.
*/
public void endSession() {
getPaintSurface().clearRubberbandSelection();
}
/**
* Aborts the current operation.
*/
public void resetSession() {
getPaintSurface().clearRubberbandSelection();
}
/**
* Handles a mouseDown event.
*
* @param event the mouse event detail information
*/
public void mouseDown(MouseEvent event) {
if (event.button == 1) {
// draw with left mouse button
getPaintSurface().rumitRubberbandSelection();
} else {
// set text with right mouse button
getPaintSurface().clearRubberbandSelection();
Shell shell = getPaintSurface().getShell();
final Shell dialog = new Shell(shell, SWT.DIALOG_TRIM | SWT.APPLICATION_MODAL);
dialog.setText(PaintExample.getResourceString("tool.Text.dialog.title"));
dialog.setLayout(new GridLayout());
Label label = new Label(dialog, SWT.NONE);
label.setText(PaintExample.getResourceString("tool.Text.dialog.message"));
label.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, false, false));
final Text field = new Text(dialog, SWT.SINGLE | SWT.BORDER);
field.setText(drawText);
field.selectAll();
field.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, true, false));
Composite buttons = new Composite(dialog, SWT.NONE);
GridLayout layout = new GridLayout(2, true);
layout.marginWidth = 0;
buttons.setLayout(layout);
buttons.setLayoutData(new GridData(SWT.END, SWT.CENTER, false, false));
Button ok = new Button(buttons, SWT.PUSH);
ok.setText(PaintExample.getResourceString("OK"));
ok.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, false, false));
ok.addSelectionListener(new SelectionAdapter() {
public void widgetSelected(SelectionEvent e) {
drawText = field.getText();
dialog.dispose();
}
});
Button cancel = new Button(buttons, SWT.PUSH);
cancel.setText(PaintExample.getResourceString("Cancel"));
cancel.addSelectionListener(new SelectionAdapter() {
public void widgetSelected(SelectionEvent e) {
dialog.dispose();
}
});
dialog.setDefaultButton(ok);
dialog.pack();
dialog.open();
Display display = dialog.getDisplay();
while (! shell.isDisposed() && ! dialog.isDisposed()) {
if (! display.readAndDispatch()) display.sleep();
}
}
}
/**
* Handles a mouseDoubleClick event.
*
* @param event the mouse event detail information
*/
public void mouseDoubleClick(MouseEvent event) {
}
/**
* Handles a mouseUp event.
*
* @param event the mouse event detail information
*/
public void mouseUp(MouseEvent event) {
}
/**
* Handles a mouseMove event.
*
* @param event the mouse event detail information
*/
public void mouseMove(MouseEvent event) {
final PaintSurface ps = getPaintSurface();
ps.setStatusCoord(ps.getCurrentPosition());
ps.clearRubberbandSelection();
ps.addRubberbandSelection(
new TextFigure(settings.rumonForegroundColor, settings.rumonFont,
drawText, event.x, event.y));
}
}
/*******************************************************************************
* 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 *******************************************************************************/
/**
* 2D Rectangle object */
class TextFigure extends Figure {
private Color color;
private Font font;
private String text;
private int x, y;
/**
* Constructs a TextFigure
*
* @param color the color for this object
* @param font the font for this object
* @param text the text to draw, tab and new-line expansion is performed
* @param x the virtual X coordinate of the top-left corner of the text bounding box
* @param y the virtual Y coordinate of the top-left corner of the text bounding box
*/
public TextFigure(Color color, Font font, String text, int x, int y) {
this.color = color; this.font = font; this.text = text; this.x = x; this.y = y;
}
public void draw(FigureDrawContext fdc) {
Point p = fdc.toClientPoint(x, y);
fdc.gc.setFont(font);
fdc.gc.setForeground(color);
fdc.gc.drawText(text, p.x, p.y, true);
}
public void addDamagedRegion(FigureDrawContext fdc, Region region) {
Font oldFont = fdc.gc.getFont();
fdc.gc.setFont(font);
Point textExtent = fdc.gc.textExtent(text);
fdc.gc.setFont(oldFont);
region.add(fdc.toClientRectangle(x, y, x + textExtent.x, y + textExtent.y));
}
}
/*******************************************************************************
* 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 *******************************************************************************/
/**
* 2D SolidRectangle object */
class SolidRoundedRectangleFigure extends Figure {
private Color color;
private int x1, y1, x2, y2, diameter;
/**
* Constructs a SolidRectangle
* These objects are defined by any two diametrically opposing corners.
*
* @param color the color for this object
* @param x1 the virtual X coordinate of the first corner
* @param y1 the virtual Y coordinate of the first corner
* @param x2 the virtual X coordinate of the second corner
* @param y2 the virtual Y coordinate of the second corner
* @param diameter the diameter of curvature of all four corners
*/
public SolidRoundedRectangleFigure(Color color, int x1, int y1, int x2, int y2, int diameter) {
this.color = color; this.x1 = x1; this.y1 = y1; this.x2 = x2; this.y2 = y2;
this.diameter = diameter;
}
public void draw(FigureDrawContext fdc) {
Rectangle r = fdc.toClientRectangle(x1, y1, x2, y2);
fdc.gc.setBackground(color);
fdc.gc.fillRoundRectangle(r.x, r.y, r.width, r.height, diameter, diameter);
}
public void addDamagedRegion(FigureDrawContext fdc, Region region) {
region.add(fdc.toClientRectangle(x1, y1, x2, y2));
}
}
/*******************************************************************************
* 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 *******************************************************************************/
/**
* 2D SolidRectangle object */
class SolidRectangleFigure extends Figure {
private Color color;
private int x1, y1, x2, y2;
/**
* Constructs a SolidRectangle
* These objects are defined by any two diametrically opposing corners.
*
* @param color the color for this object
* @param x1 the virtual X coordinate of the first corner
* @param y1 the virtual Y coordinate of the first corner
* @param x2 the virtual X coordinate of the second corner
* @param y2 the virtual Y coordinate of the second corner
*/
public SolidRectangleFigure(Color color, int x1, int y1, int x2, int y2) {
this.color = color; this.x1 = x1; this.y1 = y1; this.x2 = x2; this.y2 = y2;
}
public void draw(FigureDrawContext fdc) {
Rectangle r = fdc.toClientRectangle(x1, y1, x2, y2);
fdc.gc.setBackground(color);
fdc.gc.fillRectangle(r.x, r.y, r.width, r.height);
}
public void addDamagedRegion(FigureDrawContext fdc, Region region) {
region.add(fdc.toClientRectangle(x1, y1, x2, y2));
}
}
/*******************************************************************************
* 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 *******************************************************************************/
/**
* 2D Line object */
class SolidPolygonFigure extends Figure {
private Color color;
private int[] points;
/**
* Constructs a SolidPolygon
* These objects are defined by a sequence of vertices.
*
* @param color the color for this object
* @param vertices the array of vertices making up the polygon
* @param numPoint the number of valid points in the array (n >= 3)
*/
public SolidPolygonFigure(Color color, Point[] vertices, int numPoints) {
this.color = color;
this.points = new int[numPoints * 2];
for (int i = 0; i < numPoints; ++i) {
points[i * 2] = vertices[i].x;
points[i * 2 + 1] = vertices[i].y;
}
}
public void draw(FigureDrawContext fdc) {
int[] drawPoints = new int[points.length];
for (int i = 0; i < points.length; i += 2) {
drawPoints[i] = points[i] * fdc.xScale - fdc.xOffset;
drawPoints[i + 1] = points[i + 1] * fdc.yScale - fdc.yOffset;
}
fdc.gc.setBackground(color);
fdc.gc.fillPolygon(drawPoints);
}
public void addDamagedRegion(FigureDrawContext fdc, Region region) {
int xmin = Integer.MAX_VALUE, ymin = Integer.MAX_VALUE;
int xmax = Integer.MIN_VALUE, ymax = Integer.MIN_VALUE;
for (int i = 0; i < points.length; i += 2) {
if (points[i] < xmin) xmin = points[i];
if (points[i] > xmax) xmax = points[i];
if (points[i+1] < ymin) ymin = points[i+1];
if (points[i+1] > ymax) ymax = points[i+1];
}
region.add(fdc.toClientRectangle(xmin, ymin, xmax, ymax));
}
}
/*******************************************************************************
* 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 *******************************************************************************/
/**
* 2D Solid Ellipse object */
class SolidEllipseFigure extends Figure {
private Color color;
private int x1, y1, x2, y2;
/**
* Constructs a SolidEllipse
* These objects are defined by any two diametrically opposing corners of a box
* bounding the ellipse.
*
* @param color the color for this object
* @param x1 the virtual X coordinate of the first corner
* @param y1 the virtual Y coordinate of the first corner
* @param x2 the virtual X coordinate of the second corner
* @param y2 the virtual Y coordinate of the second corner
*/
public SolidEllipseFigure(Color color, int x1, int y1, int x2, int y2) {
this.color = color; this.x1 = x1; this.y1 = y1; this.x2 = x2; this.y2 = y2;
}
public void draw(FigureDrawContext fdc) {
Rectangle r = fdc.toClientRectangle(x1, y1, x2, y2);
fdc.gc.setBackground(color);
fdc.gc.fillOval(r.x, r.y, r.width, r.height);
}
public void addDamagedRegion(FigureDrawContext fdc, Region region) {
region.add(fdc.toClientRectangle(x1, y1, x2, y2));
}
}
/*******************************************************************************
* 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 *******************************************************************************/
/**
* The superclass for paint tools that contruct objects from individually * picked segments. */
abstract class SegmentedPaintSession extends BasicPaintSession {
/**
* The set of control points making up the segmented selection
*/
private Vector /* of Point */ controlPoints = new Vector();
/**
* The previous figure (so that we can abort with right-button)
*/
private Figure previousFigure = null;
/**
* The current figure (so that we can abort with right-button)
*/
private Figure currentFigure = null;
/**
* Constructs a PaintSession.
*
* @param paintSurface the drawing surface to use
*/
protected SegmentedPaintSession(PaintSurface paintSurface) {
super(paintSurface);
}
/**
* Activates the tool.
*/
public void beginSession() {
getPaintSurface().setStatusMessage(PaintExample.getResourceString(
"session.SegmentedInteractivePaint.message.anchorMode"));
previousFigure = null;
currentFigure = null;
controlPoints.clear();
}
/**
* Deactivates the tool.
*/
public void endSession() {
getPaintSurface().clearRubberbandSelection();
if (previousFigure != null) getPaintSurface().drawFigure(previousFigure);
}
/**
* Resets the tool.
* Aborts any operation in progress.
*/
public void resetSession() {
getPaintSurface().clearRubberbandSelection();
if (previousFigure != null) getPaintSurface().drawFigure(previousFigure);
getPaintSurface().setStatusMessage(PaintExample.getResourceString(
"session.SegmentedInteractivePaint.message.anchorMode"));
previousFigure = null;
currentFigure = null;
controlPoints.clear();
}
/**
* Handles a mouseDown event.
*
* @param event the mouse event detail information
*/
public void mouseDown(MouseEvent event) {
if (event.button != 1) return;
getPaintSurface().setStatusMessage(PaintExample.getResourceString(
"session.SegmentedInteractivePaint.message.interactiveMode"));
previousFigure = currentFigure;
if (controlPoints.size() > 0) {
final Point lastPoint = (Point) controlPoints.elementAt(controlPoints.size() - 1);
if (lastPoint.x == event.x || lastPoint.y == event.y) return; // spurious event
}
controlPoints.add(new Point(event.x, event.y));
}
/**
* Handles a mouseDoubleClick event.
*
* @param event the mouse event detail information
*/
public void mouseDoubleClick(MouseEvent event) {
if (event.button != 1) return;
if (controlPoints.size() >= 2) {
getPaintSurface().clearRubberbandSelection();
previousFigure = createFigure(
(Point[]) controlPoints.toArray(new Point[controlPoints.size()]),
controlPoints.size(), true);
}
resetSession();
}
/**
* Handles a mouseUp event.
*
* @param event the mouse event detail information
*/
public void mouseUp(MouseEvent event) {
if (event.button != 1) {
resetSession(); // abort if right or middle mouse button pressed
return;
}
}
/**
* Handles a mouseMove event.
*
* @param event the mouse event detail information
*/
public void mouseMove(MouseEvent event) {
final PaintSurface ps = getPaintSurface();
if (controlPoints.size() == 0) {
ps.setStatusCoord(ps.getCurrentPosition());
return; // spurious event
} else {
ps.setStatusCoordRange((Point) controlPoints.elementAt(controlPoints.size() - 1),
ps.getCurrentPosition());
}
ps.clearRubberbandSelection();
Point[] points = (Point[]) controlPoints.toArray(new Point[controlPoints.size() + 1]);
points[controlPoints.size()] = ps.getCurrentPosition();
currentFigure = createFigure(points, points.length, false);
ps.addRubberbandSelection(currentFigure);
}
/**
* Template Method: Creates a Figure for drawing rubberband entities and the final product
*
* @param points the array of control points
* @param numPoints the number of valid points in the array (n >= 2)
* @param closed true if the user double-clicked on the final control point
*/
protected abstract Figure createFigure(Point[] points, int numPoints, boolean closed);
}
/*******************************************************************************
* 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 *******************************************************************************/
/**
* A drawing tool. */
class RoundedRectangleTool extends DragPaintSession implements PaintTool {
private ToolSettings settings;
/**
* Constructs a RoundedRectangleTool.
*
* @param toolSettings the new tool settings
* @param paintSurface the PaintSurface we will render on.
*/
public RoundedRectangleTool(ToolSettings toolSettings, PaintSurface paintSurface) {
super(paintSurface);
set(toolSettings);
}
/**
* Sets the tool"s settings.
*
* @param toolSettings the new tool settings
*/
public void set(ToolSettings toolSettings) {
settings = toolSettings;
}
/**
* Returns name associated with this tool.
*
* @return the localized name of this tool
*/
public String getDisplayName() {
return PaintExample.getResourceString("tool.RoundedRectangle.label");
}
/*
* Template methods for drawing
*/
protected Figure createFigure(Point a, Point b) {
ContainerFigure container = new ContainerFigure();
if (settings.rumonFillType != ToolSettings.ftNone)
container.add(new SolidRoundedRectangleFigure(settings.rumonBackgroundColor,
a.x, a.y, b.x, b.y, settings.roundedRectangleCornerDiameter));
if (settings.rumonFillType != ToolSettings.ftSolid)
container.add(new RoundedRectangleFigure(settings.rumonForegroundColor, settings.rumonBackgroundColor,
settings.rumonLineStyle, a.x, a.y, b.x, b.y, settings.roundedRectangleCornerDiameter));
return container;
}
}
/*******************************************************************************
* 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 *******************************************************************************/
/**
* 2D Rectangle object */
class RoundedRectangleFigure extends Figure {
private Color foregroundColor, backgroundColor;
private int lineStyle, x1, y1, x2, y2, diameter;
/**
* Constructs a Rectangle
* These objects are defined by any two diametrically opposing corners.
*
* @param color the color for this object
* @param lineStyle the line style for this object
* @param x1 the virtual X coordinate of the first corner
* @param y1 the virtual Y coordinate of the first corner
* @param x2 the virtual X coordinate of the second corner
* @param y2 the virtual Y coordinate of the second corner
* @param diameter the diameter of curvature of all four corners
*/
public RoundedRectangleFigure(Color foregroundColor, Color backgroundColor, int lineStyle, int x1, int y1, int x2, int y2, int diameter) {
this.foregroundColor = foregroundColor;
this.backgroundColor = backgroundColor;
this.lineStyle = lineStyle;
this.x1 = x1; this.y1 = y1; this.x2 = x2; this.y2 = y2;
this.diameter = diameter;
}
public void draw(FigureDrawContext fdc) {
Rectangle r = fdc.toClientRectangle(x1, y1, x2, y2);
fdc.gc.setForeground(foregroundColor);
fdc.gc.setBackground(backgroundColor);
fdc.gc.setLineStyle(lineStyle);
fdc.gc.drawRoundRectangle(r.x, r.y, r.width - 1, r.height - 1, diameter, diameter);
fdc.gc.setLineStyle(SWT.LINE_SOLID);
}
public void addDamagedRegion(FigureDrawContext fdc, Region region) {
region.add(fdc.toClientRectangle(x1, y1, x2, y2));
}
}
/*******************************************************************************
* 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 *******************************************************************************/
/**
* A drawing tool. */
class RectangleTool extends DragPaintSession implements PaintTool {
private ToolSettings settings;
/**
* Constructs a RectangleTool.
*
* @param toolSettings the new tool settings
* @param paintSurface the PaintSurface we will render on.
*/
public RectangleTool(ToolSettings toolSettings, PaintSurface paintSurface) {
super(paintSurface);
set(toolSettings);
}
/**
* Sets the tool"s settings.
*
* @param toolSettings the new tool settings
*/
public void set(ToolSettings toolSettings) {
settings = toolSettings;
}
/**
* Returns name associated with this tool.
*
* @return the localized name of this tool
*/
public String getDisplayName() {
return PaintExample.getResourceString("tool.Rectangle.label");
}
/*
* Template method for drawing
*/
protected Figure createFigure(Point a, Point b) {
switch (settings.rumonFillType) {
default:
case ToolSettings.ftNone:
return new RectangleFigure(settings.rumonForegroundColor, settings.rumonBackgroundColor, settings.rumonLineStyle,
a.x, a.y, b.x, b.y);
case ToolSettings.ftSolid:
return new SolidRectangleFigure(settings.rumonBackgroundColor, a.x, a.y, b.x, b.y);
case ToolSettings.ftOutline: {
ContainerFigure container = new ContainerFigure();
container.add(new SolidRectangleFigure(settings.rumonBackgroundColor, a.x, a.y, b.x, b.y));
container.add(new RectangleFigure(settings.rumonForegroundColor, settings.rumonBackgroundColor, settings.rumonLineStyle,
a.x, a.y, b.x, b.y));
return container;
}
}
}
}
/*******************************************************************************
* 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 *******************************************************************************/
/**
* 2D Rectangle object */
class RectangleFigure extends Figure {
private Color foregroundColor, backgroundColor;
private int lineStyle, x1, y1, x2, y2;
/**
* Constructs a Rectangle
* These objects are defined by any two diametrically opposing corners.
*
* @param color the color for this object
* @param lineStyle the line style for this object
* @param x1 the virtual X coordinate of the first corner
* @param y1 the virtual Y coordinate of the first corner
* @param x2 the virtual X coordinate of the second corner
* @param y2 the virtual Y coordinate of the second corner
*/
public RectangleFigure(Color foregroundColor, Color backgroundColor, int lineStyle, int x1, int y1, int x2, int y2) {
this.foregroundColor = foregroundColor;
this.backgroundColor = backgroundColor;
this.lineStyle = lineStyle;
this.x1 = x1; this.y1 = y1; this.x2 = x2; this.y2 = y2;
}
public void draw(FigureDrawContext fdc) {
Rectangle r = fdc.toClientRectangle(x1, y1, x2, y2);
fdc.gc.setForeground(foregroundColor);
fdc.gc.setBackground(backgroundColor);
fdc.gc.setLineStyle(lineStyle);
fdc.gc.drawRectangle(r.x, r.y, r.width - 1, r.height - 1);
fdc.gc.setLineStyle(SWT.LINE_SOLID);
}
public void addDamagedRegion(FigureDrawContext fdc, Region region) {
region.add(fdc.toClientRectangle(x1, y1, x2, y2));
}
}
/*******************************************************************************
* 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 *******************************************************************************/
/**
* A polyline drawing tool. */
class PolyLineTool extends SegmentedPaintSession implements PaintTool {
private ToolSettings settings;
/**
* Constructs a PolyLineTool.
*
* @param toolSettings the new tool settings
* @param paintSurface the PaintSurface we will render on.
*/
public PolyLineTool(ToolSettings toolSettings, PaintSurface paintSurface) {
super(paintSurface);
set(toolSettings);
}
/**
* Sets the tool"s settings.
*
* @param toolSettings the new tool settings
*/
public void set(ToolSettings toolSettings) {
settings = toolSettings;
}
/**
* Returns the name associated with this tool.
*
* @return the localized name of this tool
*/
public String getDisplayName() {
return PaintExample.getResourceString("tool.PolyLine.label");
}
/*
* Template methods for drawing
*/
protected Figure createFigure(Point[] points, int numPoints, boolean closed) {
ContainerFigure container = new ContainerFigure();
if (closed && settings.rumonFillType != ToolSettings.ftNone && numPoints >= 3) {
container.add(new SolidPolygonFigure(settings.rumonBackgroundColor, points, numPoints));
}
if (! closed || settings.rumonFillType != ToolSettings.ftSolid || numPoints < 3) {
for (int i = 0; i < numPoints - 1; ++i) {
final Point a = points[i];
final Point b = points[i + 1];
container.add(new LineFigure(settings.rumonForegroundColor, settings.rumonBackgroundColor, settings.rumonLineStyle,
a.x, a.y, b.x, b.y));
}
if (closed) {
final Point a = points[points.length - 1];
final Point b = points[0];
container.add(new LineFigure(settings.rumonForegroundColor, settings.rumonBackgroundColor, settings.rumonLineStyle,
a.x, a.y, b.x, b.y));
}
}
return container;
}
}
/*******************************************************************************
* 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 *******************************************************************************/
/**
* 2D Point object */
class PointFigure extends Figure {
private Color color;
private int x, y;
/**
* Constructs a Point
*
* @param color the color for this object
* @param x the virtual X coordinate of the first end-point
* @param y the virtual Y coordinate of the first end-point
*/
public PointFigure(Color color, int x, int y) {
this.color = color; this.x = x; this.y = y;
}
public void draw(FigureDrawContext fdc) {
Point p = fdc.toClientPoint(x, y);
fdc.gc.setBackground(color);
fdc.gc.fillRectangle(p.x, p.y, 1, 1);
}
public void addDamagedRegion(FigureDrawContext fdc, Region region) {
region.add(fdc.toClientRectangle(x, y, x, y));
}
}
/*******************************************************************************
* 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 *******************************************************************************/
/**
* A pencil tool. */
class PencilTool extends ContinuousPaintSession implements PaintTool {
private ToolSettings settings;
/**
* Constructs a pencil tool.
*
* @param toolSettings the new tool settings
* @param getPaintSurface() the PaintSurface we will render on.
*/
public PencilTool(ToolSettings toolSettings, PaintSurface paintSurface) {
super(paintSurface);
set(toolSettings);
}
/**
* Sets the tool"s settings.
*
* @param toolSettings the new tool settings
*/
public void set(ToolSettings toolSettings) {
settings = toolSettings;
}
/**
* Returns the name associated with this tool.
*
* @return the localized name of this tool
*/
public String getDisplayName() {
return PaintExample.getResourceString("tool.Pencil.label");
}
/*
* Template method for drawing
*/
public void render(final Point point) {
final PaintSurface ps = getPaintSurface();
ps.drawFigure(new PointFigure(settings.rumonForegroundColor, point.x, point.y));
}
}
/*******************************************************************************
* 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 *******************************************************************************/
interface PaintTool extends PaintSession {
/** * Sets the tool"s settings. * * @param toolSettings the new tool settings */ public void set(ToolSettings toolSettings);
}
/*******************************************************************************
* 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 *******************************************************************************/
/**
* Manages a simple drawing surface. */
class PaintSurface {
private Point currentPosition = new Point(0, 0); private Canvas paintCanvas; private PaintSession paintSession; private Image image; private Image paintImage; // buffer for refresh blits private int imageWidth, imageHeight; private int visibleWidth, visibleHeight; private FigureDrawContext displayFDC = new FigureDrawContext(); private FigureDrawContext imageFDC = new FigureDrawContext(); private FigureDrawContext paintFDC = new FigureDrawContext(); /* Rubberband */ private ContainerFigure rubberband = new ContainerFigure(); // the active rubberband selection private int rubberbandHiddenNestingCount = 0; // always >= 0, if > 0 rubberband has been hidden /* Status */ private Text statusText; private String statusActionInfo, statusMessageInfo, statusCoordInfo; /** * Constructs a PaintSurface.*
* paintCanvas must have SWT.NO_REDRAW_RESIZE and SWT.NO_BACKGROUND styles, * and may have SWT.V_SCROLL and/or SWT.H_SCROLL. *
* @param paintCanvas the Canvas object in which to render
* @param paintStatus the PaintStatus object to use for providing user feedback
* @param fillColor the color to fill the canvas with initially
*/
public PaintSurface(Canvas paintCanvas, Text statusText, Color fillColor) {
this.paintCanvas = paintCanvas;
this.statusText = statusText;
clearStatus();
/* Set up the drawing surface */
Rectangle displayRect = paintCanvas.getDisplay().getClientArea();
imageWidth = displayRect.width;
imageHeight = displayRect.height;
image = new Image(paintCanvas.getDisplay(), imageWidth, imageHeight);
imageFDC.gc = new GC(image);
imageFDC.gc.setBackground(fillColor);
imageFDC.gc.fillRectangle(0, 0, imageWidth, imageHeight);
displayFDC.gc = new GC(paintCanvas);
/* Initialize the session */
setPaintSession(null);
/* Add our listeners */
paintCanvas.addDisposeListener(new DisposeListener() {
public void widgetDisposed(DisposeEvent e) {
displayFDC.gc.dispose();
}
});
paintCanvas.addMouseListener(new MouseAdapter() {
public void mouseDown(MouseEvent event) {
processMouseEventCoordinates(event);
if (paintSession != null) paintSession.mouseDown(event);
}
public void mouseUp(MouseEvent event) {
processMouseEventCoordinates(event);
if (paintSession != null) paintSession.mouseUp(event);
}
public void mouseDoubleClick(MouseEvent event) {
processMouseEventCoordinates(event);
if (paintSession != null) paintSession.mouseDoubleClick(event);
}
});
paintCanvas.addMouseMoveListener(new MouseMoveListener() {
public void mouseMove(MouseEvent event) {
processMouseEventCoordinates(event);
if (paintSession != null) paintSession.mouseMove(event);
}
});
paintCanvas.addPaintListener(new PaintListener() {
public void paintControl(PaintEvent event) {
if (rubberband.isEmpty()) {
// Nothing to merge, so we just refresh
event.gc.drawImage(image,
displayFDC.xOffset + event.x, displayFDC.yOffset + event.y, event.width, event.height,
event.x, event.y, event.width, event.height);
} else {
/*
* Avoid flicker when merging overlayed objects by constructing the image on
* a backbuffer first, then blitting it to the screen.
*/
// Check that the backbuffer is large enough
if (paintImage != null) {
Rectangle rect = paintImage.getBounds();
if ((event.width + event.x > rect.width) ||
(event.height + event.y > rect.height)) {
paintFDC.gc.dispose();
paintImage.dispose();
paintImage = null;
}
}
if (paintImage == null) {
Display display = getDisplay();
Rectangle rect = display.getClientArea();
paintImage = new Image(display,
Math.max(rect.width, event.width + event.x),
Math.max(rect.height, event.height + event.y));
paintFDC.gc = new GC(paintImage);
}
// Setup clipping and the FDC
Region clipRegion = new Region();
event.gc.getClipping(clipRegion);
paintFDC.gc.setClipping(clipRegion);
clipRegion.dispose();
paintFDC.xOffset = displayFDC.xOffset;
paintFDC.yOffset = displayFDC.yOffset;
paintFDC.xScale = displayFDC.xScale;
paintFDC.yScale = displayFDC.yScale;
// Merge the overlayed objects into the image, then blit
paintFDC.gc.drawImage(image,
displayFDC.xOffset + event.x, displayFDC.yOffset + event.y, event.width, event.height,
event.x, event.y, event.width, event.height);
rubberband.draw(paintFDC);
event.gc.drawImage(paintImage,
event.x, event.y, event.width, event.height,
event.x, event.y, event.width, event.height);
}
}
});
paintCanvas.addControlListener(new ControlAdapter() {
public void controlResized(ControlEvent event) {
handleResize();
}
});
/* Set up the paint canvas scroll bars */
ScrollBar horizontal = paintCanvas.getHorizontalBar();
horizontal.setVisible(true);
horizontal.addSelectionListener(new SelectionAdapter() {
public void widgetSelected(SelectionEvent event) {
scrollHorizontally((ScrollBar)event.widget);
}
});
ScrollBar vertical = paintCanvas.getVerticalBar();
vertical.setVisible(true);
vertical.addSelectionListener(new SelectionAdapter() {
public void widgetSelected(SelectionEvent event) {
scrollVertically((ScrollBar)event.widget);
}
});
handleResize();
}
/**
* Disposes of the PaintSurface"s resources.
*/
public void dispose() {
imageFDC.gc.dispose();
image.dispose();
if (paintImage != null) {
paintImage.dispose();
paintFDC.gc.dispose();
}
currentPosition = null;
paintCanvas = null;
paintSession = null;
image = null;
paintImage = null;
displayFDC = null;
imageFDC = null;
paintFDC = null;
rubberband = null;
statusText = null;
statusActionInfo = null;
statusMessageInfo = null;
statusCoordInfo = null;
}
/**
* Called when we must grab focus.
*/
public void setFocus() {
paintCanvas.setFocus();
}
/**
* Returns the Display on which the PaintSurface resides.
* @return the Display
*/
public Display getDisplay() {
return paintCanvas.getDisplay();
}
/**
* Returns the Shell in which the PaintSurface resides.
* @return the Shell
*/
public Shell getShell() {
return paintCanvas.getShell();
}
/**
* Sets the current paint session.
* * If oldPaintSession != paintSession calls oldPaintSession.end() * and paintSession.begin() *
*
* @param paintSession the paint session to activate; null to disable all sessions
*/
public void setPaintSession(PaintSession paintSession) {
if (this.paintSession != null) {
if (this.paintSession == paintSession) return;
this.paintSession.endSession();
}
this.paintSession = paintSession;
clearStatus();
if (paintSession != null) {
setStatusAction(paintSession.getDisplayName());
paintSession.beginSession();
} else {
setStatusAction(PaintExample.getResourceString("tool.Null.label"));
setStatusMessage(PaintExample.getResourceString("session.Null.message"));
}
}
/**
* Returns the current paint session.
*
* @return the current paint session, null if none is active
*/
public PaintSession getPaintSession() {
return paintSession;
}
/**
* Returns the current paint tool.
*
* @return the current paint tool, null if none is active (though some other session
* might be)
*/
public PaintTool getPaintTool() {
return (paintSession != null && paintSession instanceof PaintTool) ?
(PaintTool)paintSession : null;
}
/**
* Returns the current position in an interactive operation.
*
* @return the last known position of the pointer
*/
public Point getCurrentPosition() {
return currentPosition;
}
/**
* Draws a Figure object to the screen and to the backing store permanently.
*
* @param object the object to draw onscreen
*/
public void drawFigure(Figure object) {
object.draw(imageFDC);
object.draw(displayFDC);
}
/**
* Adds a Figure object to the active rubberband selection.
* * This object will be drawn to the screen as a preview and refreshed appropriately * until the selection is either cleared or committed. *
*
* @param object the object to add to the selection
*/
public void addRubberbandSelection(Figure object) {
rubberband.add(object);
if (! isRubberbandHidden()) object.draw(displayFDC);
}
/**
* Clears the active rubberband selection.
* * Erases any rubberband objects on the screen then clears the selection. *
*/
public void clearRubberbandSelection() {
if (! isRubberbandHidden()) {
Region region = new Region();
rubberband.addDamagedRegion(displayFDC, region);
Rectangle r = region.getBounds();
paintCanvas.redraw(r.x, r.y, r.width, r.height, true);
region.dispose();
}
rubberband.clear();
}
/**
* Commits the active rubberband selection.
* * Redraws any rubberband objects on the screen as permanent objects then clears the selection. *
*/
public void commitRubberbandSelection() {
rubberband.draw(imageFDC);
if (isRubberbandHidden()) rubberband.draw(displayFDC);
rubberband.clear();
}
/**
* Hides the rubberband (but does not eliminate it).
* * Increments by one the rubberband "hide" nesting count. The rubberband * is hidden from view (but remains active) if it wasn"t already hidden. *
*/
public void hideRubberband() {
if (rubberbandHiddenNestingCount++ <= 0) {
Region region = new Region();
rubberband.addDamagedRegion(displayFDC, region);
Rectangle r = region.getBounds();
paintCanvas.redraw(r.x, r.y, r.width, r.height, true);
region.dispose();
}
}
/**
* Shows (un-hides) the rubberband.
* * Decrements by one the rubberband "hide" nesting count. The rubberband * is only made visible when showRubberband() has been called once for each * previous hideRubberband(). It is not permitted to call showRubberband() if * the rubber band is not presently hidden. *
*/
public void showRubberband() {
if (rubberbandHiddenNestingCount <= 0)
throw new IllegalStateException("rubberbandHiddenNestingCount > 0");
if (--rubberbandHiddenNestingCount == 0) {
rubberband.draw(displayFDC);
}
}
/**
* Determines if the rubberband is hidden.
*
* @return true iff the rubber is hidden
*/
public boolean isRubberbandHidden() {
return rubberbandHiddenNestingCount > 0;
}
/**
* Handles a horizontal scroll event
*
* @param scrollbar the horizontal scroll bar that posted this event
*/
public void scrollHorizontally(ScrollBar scrollBar) {
if (image == null) return;
if (imageWidth > visibleWidth) {
final int oldOffset = displayFDC.xOffset;
final int newOffset = Math.min(scrollBar.getSelection(), imageWidth - visibleWidth);
if (oldOffset != newOffset) {
paintCanvas.update();
displayFDC.xOffset = newOffset;
paintCanvas.scroll(Math.max(oldOffset - newOffset, 0), 0, Math.max(newOffset - oldOffset, 0), 0,
visibleWidth, visibleHeight, false);
}
}
}
/**
* Handles a vertical scroll event
*
* @param scrollbar the vertical scroll bar that posted this event
*/
public void scrollVertically(ScrollBar scrollBar) {
if (image == null) return;
if (imageHeight > visibleHeight) {
final int oldOffset = displayFDC.yOffset;
final int newOffset = Math.min(scrollBar.getSelection(), imageHeight - visibleHeight);
if (oldOffset != newOffset) {
paintCanvas.update();
displayFDC.yOffset = newOffset;
paintCanvas.scroll(0, Math.max(oldOffset - newOffset, 0), 0, Math.max(newOffset - oldOffset, 0),
visibleWidth, visibleHeight, false);
}
}
}
/**
* Handles resize events
*/
private void handleResize() {
paintCanvas.update();
Rectangle visibleRect = paintCanvas.getClientArea();
visibleWidth = visibleRect.width;
visibleHeight = visibleRect.height;
ScrollBar horizontal = paintCanvas.getHorizontalBar();
if (horizontal != null) {
displayFDC.xOffset = Math.min(horizontal.getSelection(), imageWidth - visibleWidth);
if (imageWidth <= visibleWidth) {
horizontal.setEnabled(false);
horizontal.setSelection(0);
} else {
horizontal.setEnabled(true);
horizontal.setValues(displayFDC.xOffset, 0, imageWidth, visibleWidth,
8, visibleWidth);
}
}
ScrollBar vertical = paintCanvas.getVerticalBar();
if (vertical != null) {
displayFDC.yOffset = Math.min(vertical.getSelection(), imageHeight - visibleHeight);
if (imageHeight <= visibleHeight) {
vertical.setEnabled(false);
vertical.setSelection(0);
} else {
vertical.setEnabled(true);
vertical.setValues(displayFDC.yOffset, 0, imageHeight, visibleHeight,
8, visibleHeight);
}
}
}
/**
* Virtualizes MouseEvent coordinates and stores the current position.
*/
private void processMouseEventCoordinates(MouseEvent event) {
currentPosition.x = event.x =
Math.min(Math.max(event.x, 0), visibleWidth - 1) + displayFDC.xOffset;
currentPosition.y = event.y =
Math.min(Math.max(event.y, 0), visibleHeight - 1) + displayFDC.yOffset;
}
/**
* Clears the status bar.
*/
public void clearStatus() {
statusActionInfo = "";
statusMessageInfo = "";
statusCoordInfo = "";
updateStatus();
}
/**
* Sets the status bar action text.
*
* @param action the action in progress, null to clear
*/
public void setStatusAction(String action) {
statusActionInfo = (action != null) ? action : "";
updateStatus();
}
/**
* Sets the status bar message text.
*
* @param message the message to display, null to clear
*/
public void setStatusMessage(String message) {
statusMessageInfo = (message != null) ? message : "";
updateStatus();
}
/**
* Sets the coordinates in the status bar.
*
* @param coord the coordinates to display, null to clear
*/
public void setStatusCoord(Point coord) {
statusCoordInfo = (coord != null) ? PaintExample.getResourceString("status.Coord.format", new Object[]
{ new Integer(coord.x), new Integer(coord.y)}) : "";
updateStatus();
}
/**
* Sets the coordinate range in the status bar.
*
* @param a the "from" coordinate, must not be null
* @param b the "to" coordinate, must not be null
*/
public void setStatusCoordRange(Point a, Point b) {
statusCoordInfo = PaintExample.getResourceString("status.CoordRange.format", new Object[]
{ new Integer(a.x), new Integer(a.y), new Integer(b.x), new Integer(b.y)});
updateStatus();
}
/**
* Updates the display.
*/
private void updateStatus() {
statusText.setText(
PaintExample.getResourceString("status.Bar.format", new Object[]
{ statusActionInfo, statusMessageInfo, statusCoordInfo }));
}
}
/*******************************************************************************
* 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 *******************************************************************************/
/**
* Manages an interactive paint session. * Note that the coordinates received via the listener interfaces are virtualized to zero-origin * relative to the painting surface. */
interface PaintSession extends MouseListener, MouseMoveListener {
/**
* Returns the paint surface associated with this paint session
*
* @return the associated PaintSurface
*/
public PaintSurface getPaintSurface();
/**
* Activates the session.
*
* Note: When overriding this method, call super.beginSession() at method start.
*/
public abstract void beginSession();
/**
* Deactivates the session.
*
* Note: When overriding this method, call super.endSession() at method exit.
*/
public abstract void endSession();
/**
* Resets the session.
* Aborts any operation in progress.
*
* Note: When overriding this method, call super.resetSession() at method exit.
*/
public abstract void resetSession();
/**
* Returns the name associated with this tool.
*
* @return the localized name of this tool
*/
public String getDisplayName();
}
/*******************************************************************************
* 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 *******************************************************************************/
/**
* A line drawing tool */
class LineTool extends DragPaintSession implements PaintTool {
private ToolSettings settings;
/**
* Constructs a LineTool.
*
* @param toolSettings the new tool settings
* @param paintSurface the PaintSurface we will render on.
*/
public LineTool(ToolSettings toolSettings, PaintSurface paintSurface) {
super(paintSurface);
set(toolSettings);
}
/**
* Sets the tool"s settings.
*
* @param toolSettings the new tool settings
*/
public void set(ToolSettings toolSettings) {
settings = toolSettings;
}
/**
* Returns name associated with this tool.
*
* @return the localized name of this tool
*/
public String getDisplayName() {
return PaintExample.getResourceString("tool.Line.label");
}
/*
* Template methods for drawing
*/
protected Figure createFigure(Point a, Point b) {
return new LineFigure(settings.rumonForegroundColor, settings.rumonBackgroundColor, settings.rumonLineStyle,
a.x, a.y, b.x, b.y);
}
}
/*******************************************************************************
* 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 *******************************************************************************/
/**
* 2D Line object */
class LineFigure extends Figure {
private Color foregroundColor, backgroundColor;
private int lineStyle, x1, y1, x2, y2;
/**
* Constructs a Line
* These objects are defined by their two end-points.
*
* @param color the color for this object
* @param lineStyle the line style for this object
* @param x1 the virtual X coordinate of the first end-point
* @param y1 the virtual Y coordinate of the first end-point
* @param x2 the virtual X coordinate of the second end-point
* @param y2 the virtual Y coordinate of the second end-point
*/
public LineFigure(Color foregroundColor, Color backgroundColor, int lineStyle, int x1, int y1, int x2, int y2) {
this.foregroundColor = foregroundColor;
this.backgroundColor = backgroundColor;
this.lineStyle = lineStyle;
this.x1 = x1; this.y1 = y1; this.x2 = x2; this.y2 = y2;
}
public void draw(FigureDrawContext fdc) {
Point p1 = fdc.toClientPoint(x1, y1);
Point p2 = fdc.toClientPoint(x2, y2);
fdc.gc.setForeground(foregroundColor);
fdc.gc.setBackground(backgroundColor);
fdc.gc.setLineStyle(lineStyle);
fdc.gc.drawLine(p1.x, p1.y, p2.x, p2.y);
fdc.gc.setLineStyle(SWT.LINE_SOLID);
}
public void addDamagedRegion(FigureDrawContext fdc, Region region) {
region.add(fdc.toClientRectangle(x1, y1, x2, y2));
}
}
/*******************************************************************************
* 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 *******************************************************************************/
class FigureDrawContext {
/**
* The GC must be set up as follows * (it will be returned to this state upon completion of drawing operations) *
-
*
- setXORMode(false) *
*/
public GC gc = null;
public int xOffset = 0, yOffset = 0; // substract to get GC coords
public int xScale = 1, yScale = 1;
public Rectangle toClientRectangle(int x1, int y1, int x2, int y2) {
return new Rectangle(
Math.min(x1, x2) * xScale - xOffset,
Math.min(y1, y2) * yScale - yOffset,
(Math.abs(x2 - x1) + 1) * xScale,
(Math.abs(y2 - y1) + 1) * yScale);
}
public Point toClientPoint(int x, int y) {
return new Point(x * xScale - xOffset, y * yScale - yOffset);
}
}
/*******************************************************************************
* 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 *******************************************************************************/
/**
* Superinterface for all drawing objects. * All drawing objects know how to render themselved to the screen and can draw a * temporary version of themselves for previewing the general appearance of the * object onscreen before it gets committed. */
abstract class Figure {
/** * Draws this object. * * @param fdc a parameter block specifying drawing-related information */ public abstract void draw(FigureDrawContext fdc); /** * Computes the damaged screen region caused by drawing this object (imprecise), then * appends it to the supplied region. * * @param fdc a parameter block specifying drawing-related information * @param region a region to which additional damage areas will be added */ public abstract void addDamagedRegion(FigureDrawContext fdc, Region region);
}
/*******************************************************************************
* 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 *******************************************************************************/
/**
* A drawing tool. */
class EllipseTool extends DragPaintSession implements PaintTool {
private ToolSettings settings;
/**
* Constructs a EllipseTool.
*
* @param toolSettings the new tool settings
* @param paintSurface the PaintSurface we will render on.
*/
public EllipseTool(ToolSettings toolSettings, PaintSurface paintSurface) {
super(paintSurface);
set(toolSettings);
}
/**
* Sets the tool"s settings.
*
* @param toolSettings the new tool settings
*/
public void set(ToolSettings toolSettings) {
settings = toolSettings;
}
/**
* Returns name associated with this tool.
*
* @return the localized name of this tool
*/
public String getDisplayName() {
return PaintExample.getResourceString("tool.Ellipse.label");
}
/*
* Template methods for drawing
*/
protected Figure createFigure(Point a, Point b) {
ContainerFigure container = new ContainerFigure();
if (settings.rumonFillType != ToolSettings.ftNone)
container.add(new SolidEllipseFigure(settings.rumonBackgroundColor, a.x, a.y, b.x, b.y));
if (settings.rumonFillType != ToolSettings.ftSolid)
container.add(new EllipseFigure(settings.rumonForegroundColor, settings.rumonBackgroundColor, settings.rumonLineStyle,
a.x, a.y, b.x, b.y));
return container;
}
}
/*******************************************************************************
* 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 *******************************************************************************/
/**
* 2D Ellipse object */
class EllipseFigure extends Figure {
private Color foregroundColor, backgroundColor;
private int lineStyle, x1, y1, x2, y2;
/**
* Constructs an Ellipse
* These objects are defined by any two diametrically opposing corners of a box
* bounding the ellipse.
*
* @param color the color for this object
* @param lineStyle the line style for this object
* @param x1 the virtual X coordinate of the first corner
* @param y1 the virtual Y coordinate of the first corner
* @param x2 the virtual X coordinate of the second corner
* @param y2 the virtual Y coordinate of the second corner
*/
public EllipseFigure(Color foregroundColor, Color backgroundColor, int lineStyle, int x1, int y1, int x2, int y2) {
this.foregroundColor = foregroundColor;
this.backgroundColor = backgroundColor;
this.lineStyle = lineStyle;
this.x1 = x1; this.y1 = y1; this.x2 = x2; this.y2 = y2;
}
public void draw(FigureDrawContext fdc) {
Rectangle r = fdc.toClientRectangle(x1, y1, x2, y2);
fdc.gc.setForeground(foregroundColor);
fdc.gc.setBackground(backgroundColor);
fdc.gc.setLineStyle(lineStyle);
fdc.gc.drawOval(r.x, r.y, r.width - 1, r.height - 1);
fdc.gc.setLineStyle(SWT.LINE_SOLID);
}
public void addDamagedRegion(FigureDrawContext fdc, Region region) {
region.add(fdc.toClientRectangle(x1, y1, x2, y2));
}
}
/*******************************************************************************
* 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 *******************************************************************************/
/**
* The superclass for paint tools that use click-drag-release motions to * draw objects. */
abstract class DragPaintSession extends BasicPaintSession {
/**
* True if a click-drag is in progress
*/
private boolean dragInProgress = false;
/**
* The position of the first click in a click-drag
*/
private Point anchorPosition = new Point(-1, -1);
/**
* A temporary point
*/
private Point tempPosition = new Point(-1, -1);
/**
* Constructs a PaintSession.
*
* @param getPaintSurface() the drawing surface to use
*/
protected DragPaintSession(PaintSurface paintSurface) {
super(paintSurface);
}
/**
* Activates the tool.
*/
public void beginSession() {
getPaintSurface().
setStatusMessage(PaintExample.getResourceString("session.DragInteractivePaint.message"));
anchorPosition.x = -1;
dragInProgress = false;
}
/**
* Deactivates the tool.
*/
public void endSession() {
}
/**
* Resets the tool.
* Aborts any operation in progress.
*/
public void resetSession() {
getPaintSurface().clearRubberbandSelection();
anchorPosition.x = -1;
dragInProgress = false;
}
/**
* Handles a mouseDown event.
*
* @param event the mouse event detail information
*/
public void mouseDown(MouseEvent event) {
if (event.button != 1) return;
if (dragInProgress) return; // spurious event
dragInProgress = true;
anchorPosition.x = event.x;
anchorPosition.y = event.y;
}
/**
* Handles a mouseDoubleClick event.
*
* @param event the mouse event detail information
*/
public void mouseDoubleClick(MouseEvent event) {
}
/**
* Handles a mouseUp event.
*
* @param event the mouse event detail information
*/
public void mouseUp(MouseEvent event) {
if (event.button != 1) {
resetSession(); // abort if right or middle mouse button pressed
return;
}
if (! dragInProgress) return; // spurious event
dragInProgress = false;
if (anchorPosition.x == -1) return; // spurious event
getPaintSurface().rumitRubberbandSelection();
}
/**
* Handles a mouseMove event.
*
* @param event the mouse event detail information
*/
public void mouseMove(MouseEvent event) {
final PaintSurface ps = getPaintSurface();
if (! dragInProgress) {
ps.setStatusCoord(ps.getCurrentPosition());
return;
}
ps.setStatusCoordRange(anchorPosition, ps.getCurrentPosition());
ps.clearRubberbandSelection();
tempPosition.x = event.x;
tempPosition.y = event.y;
ps.addRubberbandSelection(createFigure(anchorPosition, tempPosition));
}
/**
* Template Method: Creates a Figure for drawing rubberband entities and the final product
*
* @param anchor the anchor point
* @param cursor the point marking the current pointer location
*/
protected abstract Figure createFigure(Point anchor, Point cursor);
}
/*******************************************************************************
* 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 *******************************************************************************/
/**
* The superclass for paint tools that draw continuously along the path * traced by the mouse"s movement while the button is depressed */
abstract class ContinuousPaintSession extends BasicPaintSession {
/**
* True if a click-drag is in progress.
*/
private boolean dragInProgress = false;
/**
* A cached Point array for drawing.
*/
private Point[] points = new Point[] { new Point(-1, -1), new Point(-1, -1) };
/**
* The time to wait between retriggers in milliseconds.
*/
private int retriggerInterval = 0;
/**
* The currently valid RetriggerHandler
*/
protected Runnable retriggerHandler = null;
/**
* Constructs a ContinuousPaintSession.
*
* @param paintSurface the drawing surface to use
*/
protected ContinuousPaintSession(PaintSurface paintSurface) {
super(paintSurface);
}
/**
* Sets the retrigger timer.
* * After the timer elapses, if the mouse is still hovering over the same point with the * drag button pressed, a new render order is issued and the timer is restarted. *
* @param interval the time in milliseconds to wait between retriggers, 0 to disable
*/
public void setRetriggerTimer(int interval) {
retriggerInterval = interval;
}
/**
* Activates the tool.
*/
public void beginSession() {
getPaintSurface().
setStatusMessage(PaintExample.getResourceString("session.ContinuousPaint.message"));
dragInProgress = false;
}
/**
* Deactivates the tool.
*/
public void endSession() {
abortRetrigger();
}
/**
* Aborts the current operation.
*/
public void resetSession() {
abortRetrigger();
}
/**
* Handles a mouseDown event.
*
* @param event the mouse event detail information
*/
public final void mouseDown(MouseEvent event) {
if (event.button != 1) return;
if (dragInProgress) return; // spurious event
dragInProgress = true;
points[0].x = event.x;
points[0].y = event.y;
render(points[0]);
prepareRetrigger();
}
/**
* Handles a mouseDoubleClick event.
*
* @param event the mouse event detail information
*/
public final void mouseDoubleClick(MouseEvent event) {
}
/**
* Handles a mouseUp event.
*
* @param event the mouse event detail information
*/
public final void mouseUp(MouseEvent event) {
if (event.button != 1) return;
if (! dragInProgress) return; // spurious event
abortRetrigger();
mouseSegmentFinished(event);
dragInProgress = false;
}
/**
* Handles a mouseMove event.
*
* @param event the mouse event detail information
*/
public final void mouseMove(MouseEvent event) {
final PaintSurface ps = getPaintSurface();
ps.setStatusCoord(ps.getCurrentPosition());
if (! dragInProgress) return;
mouseSegmentFinished(event);
prepareRetrigger();
}
/**
* Handle a rendering segment
*
* @param event the mouse event detail information
*/
private final void mouseSegmentFinished(MouseEvent event) {
if (points[0].x == -1) return; // spurious event
if (points[0].x != event.x || points[0].y != event.y) {
// draw new segment
points[1].x = event.x;
points[1].y = event.y;
renderContinuousSegment();
}
}
/**
* Draws a continuous segment from points[0] to points[1].
* Assumes points[0] has been drawn already.
*
* @post points[0] will refer to the same point as points[1]
*/
protected void renderContinuousSegment() {
/* A lazy but effective line drawing algorithm */
final int dX = points[1].x - points[0].x;
final int dY = points[1].y - points[0].y;
int absdX = Math.abs(dX);
int absdY = Math.abs(dY);
if ((dX == 0) && (dY == 0)) return;
if (absdY > absdX) {
final int incfpX = (dX << 16) / absdY;
final int incY = (dY > 0) ? 1 : -1;
int fpX = points[0].x << 16; // X in fixedpoint format
while (--absdY >= 0) {
points[0].y += incY;
points[0].x = (fpX += incfpX) >> 16;
render(points[0]);
}
if (points[0].x == points[1].x) return;
points[0].x = points[1].x;
} else {
final int incfpY = (dY << 16) / absdX;
final int incX = (dX > 0) ? 1 : -1;
int fpY = points[0].y << 16; // Y in fixedpoint format
while (--absdX >= 0) {
points[0].x += incX;
points[0].y = (fpY += incfpY) >> 16;
render(points[0]);
}
if (points[0].y == points[1].y) return;
points[0].y = points[1].y;
}
render(points[0]);
}
/**
* Prepare the retrigger timer
*/
private final void prepareRetrigger() {
if (retriggerInterval > 0) {
/*
* timerExec() provides a lightweight mechanism for running code at intervals from within
* the event loop when timing accuracy is not important.
*
* Since it is not possible to cancel a timerExec(), we remember the Runnable that is
* active in order to distinguish the valid one from the stale ones. In practice,
* if the interval is 1/100th of a second, then creating a few hundred new RetriggerHandlers
* each second will not cause a significant performance hit.
*/
Display display = getPaintSurface().getDisplay();
retriggerHandler = new Runnable() {
public void run() {
if (retriggerHandler == this) {
render(points[0]);
prepareRetrigger();
}
}
};
display.timerExec(retriggerInterval, retriggerHandler);
}
}
/**
* Aborts the retrigger timer
*/
private final void abortRetrigger() {
retriggerHandler = null;
}
/**
* Template method: Renders a point.
* @param point, the point to render
*/
protected abstract void render(Point point);
}
/*******************************************************************************
* 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 *******************************************************************************/
/**
* Container for Figure objects with stacking preview mechanism. */
class ContainerFigure extends Figure {
private static final int INITIAL_ARRAY_SIZE = 16;
Figure[] objectStack = null;
int nextIndex = 0;
/**
* Constructs an empty Container
*/
public ContainerFigure() {
}
/**
* Adds an object to the container for later drawing.
*
* @param object the object to add to the drawing list
*/
public void add(Figure object) {
if (objectStack == null) {
objectStack = new Figure[INITIAL_ARRAY_SIZE];
} else if (objectStack.length <= nextIndex) {
Figure[] newObjectStack = new Figure[objectStack.length * 2];
System.arraycopy(objectStack, 0, newObjectStack, 0, objectStack.length);
objectStack = newObjectStack;
}
objectStack[nextIndex] = object;
++nextIndex;
}
/**
* Determines if the container is empty.
* @return true if the container is empty
*/
public boolean isEmpty() {
return nextIndex == 0;
}
/**
* Adds an object to the container and draws its preview then updates the supplied preview state.
*
* @param object the object to add to the drawing list
* @param gc the GC to draw on
* @param offset the offset to add to virtual coordinates to get display coordinates
* @param rememberedState the state returned by a previous drawPreview() or addAndPreview()
* using this Container, may be null if there was no such previous call
* @return object state that must be passed to erasePreview() later to erase this object
*/
// public Object addAndPreview(Figure object, GC gc, Point offset, Object rememberedState) { // Object[] stateStack = (Object[]) rememberedState; // if (stateStack == null) { // stateStack = new Object[INITIAL_ARRAY_SIZE]; // } else if (stateStack.length <= nextIndex) { // Object[] newStateStack = new Object[stateStack.length * 2]; // System.arraycopy(stateStack, 0, newStateStack, 0, stateStack.length); // stateStack = newStateStack; // } // add(object); // stateStack[nextIndex - 1] = object.drawPreview(gc, offset); // return stateStack; // }
/** * Clears the container.*
* Note that erasePreview() cannot be called after this point to erase any previous * drawPreview()"s. *
*/
public void clear() {
while (--nextIndex > 0) objectStack[nextIndex] = null;
nextIndex = 0;
}
public void draw(FigureDrawContext fdc) {
for (int i = 0; i < nextIndex; ++i) objectStack[i].draw(fdc);
}
public void addDamagedRegion(FigureDrawContext fdc, Region region) {
for (int i = 0; i < nextIndex; ++i) objectStack[i].addDamagedRegion(fdc, region);
}
}
/*******************************************************************************
* 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 *******************************************************************************/
abstract class BasicPaintSession implements PaintSession {
/**
* The paint surface
*/
private PaintSurface paintSurface;
/**
* Constructs a PaintSession.
*
* @param paintSurface the drawing surface to use
*/
protected BasicPaintSession(PaintSurface paintSurface) {
this.paintSurface = paintSurface;
}
/**
* Returns the paint surface associated with this paint session.
*
* @return the associated PaintSurface
*/
public PaintSurface getPaintSurface() {
return paintSurface;
}
}
/*******************************************************************************
* 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 *******************************************************************************/
/**
* An airbrush tool. */
class AirbrushTool extends ContinuousPaintSession implements PaintTool {
private ToolSettings settings;
private Random random;
private int cachedRadiusSquared;
private int cachedNumPoints;
/**
* Constructs a Tool.
*
* @param toolSettings the new tool settings
* @param paintSurface the PaintSurface we will render on.
*/
public AirbrushTool(ToolSettings toolSettings, PaintSurface paintSurface) {
super(paintSurface);
random = new Random();
setRetriggerTimer(10);
set(toolSettings);
}
/**
* Sets the tool"s settings.
*
* @param toolSettings the new tool settings
*/
public void set(ToolSettings toolSettings) {
// compute things we need to know for drawing
settings = toolSettings;
cachedRadiusSquared = settings.airbrushRadius * settings.airbrushRadius;
cachedNumPoints = 314 * settings.airbrushIntensity * cachedRadiusSquared / 250000;
if (cachedNumPoints == 0 && settings.airbrushIntensity != 0)
cachedNumPoints = 1;
}
/**
* Returns the name associated with this tool.
*
* @return the localized name of this tool
*/
public String getDisplayName() {
return PaintExample.getResourceString("tool.Airbrush.label");
}
/*
* Template method for drawing
*/
protected void render(Point point) {
// Draws a bunch (cachedNumPoints) of random pixels within a specified circle (cachedRadiusSquared).
ContainerFigure cfig = new ContainerFigure();
for (int i = 0; i < cachedNumPoints; ++i) {
int randX, randY;
do {
randX = (int) ((random.nextDouble() - 0.5) * settings.airbrushRadius * 2.0);
randY = (int) ((random.nextDouble() - 0.5) * settings.airbrushRadius * 2.0);
} while (randX * randX + randY * randY > cachedRadiusSquared);
cfig.add(new PointFigure(settings.rumonForegroundColor, point.x + randX, point.y + randY));
}
getPaintSurface().drawFigure(cfig);
}
}
</source>
SWT useful utilities
<source lang="java">
/*
* (c) Copyright 2004 by Heng Yuan * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * ITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * DEALINGS IN THE SOFTWARE. */
package cookxml.cookswt.util; import java.util.HashMap; import org.eclipse.swt.SWT; import org.eclipse.swt.graphics.*; import org.eclipse.swt.widgets.*; /**
* SWT useful utilities. * * @since CookSwt 1.0 * @author Heng Yuan */
public class SwtUtils {
/**
* automatically dispose Color resource
*/
public static boolean autoDisposeColor = true;
/**
* automatically dispose Font resource
*/
public static boolean autoDisposeFont = true;
/**
* automatically dispose Image resource
*/
public static boolean autoDisposeImage = true;
/**
* automatically dispose Image resource
*/
public static boolean autoDisposeCursor = true;
/**
* This is a table of system colors that cannot be disposed.
*/
private static HashMap s_systemColorTable;
/**
* This is a table of system cursors that cannot be disposed.
*/
private static HashMap s_systemCursorTable;
/**
* This is a table of system images that cannot be disposed.
*/
private static HashMap s_systemImageTable;
/**
* Setup the system color table for the given device.
*
* @param device the display device.
*/
private static void setupSystemColorTable (Device device)
{
HashMap colorTable = new HashMap ();
for (int i = 0; i <= 35; ++i)
{
Color c = device.getSystemColor (i);
colorTable.put (c, c);
}
s_systemColorTable = colorTable;
}
/**
* Setup the system cursor table for the given device.
*
* @param display the display device.
*/
private static void setupSystemCursorTable (Display display)
{
HashMap cursorTable = new HashMap ();
for (int i = 0; i <= 21; ++i)
{
Cursor c = display.getSystemCursor (i);
cursorTable.put (c, c);
}
s_systemCursorTable = cursorTable;
}
/**
* Setup the system cursor table for the given device.
*
* @param display the display device.
*/
private static void setupSystemImageTable (Display display)
{
HashMap imageTable = new HashMap ();
Image image;
image = display.getSystemImage (SWT.ICON_ERROR);
imageTable.put (image, image);
image = display.getSystemImage (SWT.ICON_INFORMATION);
imageTable.put (image, image);
image = display.getSystemImage (SWT.ICON_QUESTION);
imageTable.put (image, image);
image = display.getSystemImage (SWT.ICON_WARNING);
imageTable.put (image, image);
image = display.getSystemImage (SWT.ICON_WORKING);
imageTable.put (image, image);
s_systemImageTable = imageTable;
}
/**
* Check if a color is a system color. A system color cannot be disposed.
*
* @param color The color to be disposed.
* @param device The device that contains the color.
*/
public static boolean isSystemColor (Color color, Device device)
{
if (s_systemColorTable == null)
setupSystemColorTable (device);
return s_systemColorTable.get (color) == color;
}
/**
* Check if a color is a system color. A system color cannot be disposed.
*
* @param cursor The cursor to be disposed.
* @param display The display device.
*/
public static boolean isSystemCursor (Cursor cursor, Display display)
{
if (s_systemCursorTable == null)
setupSystemCursorTable (display);
return s_systemCursorTable.get (cursor) == cursor;
}
/**
* Check if a color is a system color. A system color cannot be disposed.
*
* @param image The image to be disposed.
* @param display The display device.
*/
public static boolean isSystemImage (Image image, Display display)
{
if (s_systemImageTable == null)
setupSystemImageTable (display);
return s_systemImageTable.get (image) == image;
}
/**
* Check if a color is a system color. A system color cannot be disposed.
*
* @param font The font to be disposed.
* @param device The display device.
*/
public static boolean isSystemFont (Font font, Device device)
{
return device.getSystemFont () == font;
}
/**
* Dispose a color if it is not a system color.
*
* @param color The color to be disposed.
* @param device The device that contains the color.
*/
public static void disposeColor (Color color, Device device)
{
if (color.isDisposed ())
return;
if (!isSystemColor (color, device))
{
assert disposeDebug ("Dispose color: " + color);
color.dispose ();
}
}
/**
* Dispose a color if it is not a system color.
*
* @param image The image to be disposed.
* @param device The device that contains the color.
*/
public static void disposeImage (Image image, Display device)
{
if (image.isDisposed ())
return;
if (!isSystemImage (image, device))
{
assert disposeDebug ("Dispose image: " + image);
image.dispose ();
}
}
/**
* Attach a DisposeListener that dispose the resource when the widget
* object is disposed.
*
* @param widget the widget to listen to.
* @param color the resource to be disposed.
*/
public static void attachColorDisposeListener (Widget widget, Color color)
{
if (autoDisposeColor &&
!isSystemColor (color, widget.getDisplay ()))
widget.addDisposeListener (new ColorDisposeListener (color));
}
/**
* Attach a DisposeListener that dispose the resource when the widget
* object is disposed.
*
* @param widget the widget to listen to.
* @param cursor the resource to be disposed.
*/
public static void attachCursorDisposeListener (Widget widget, Cursor cursor)
{
if (autoDisposeCursor &&
!isSystemCursor (cursor, widget.getDisplay ()))
widget.addDisposeListener (new CursorDisposeListener (cursor));
}
/**
* Attach a DisposeListener that dispose the resource when the widget
* object is disposed.
*
* @param widget the widget to listen to.
* @param font the resource to be disposed.
*/
public static void attachFontDisposeListener (Widget widget, Font font)
{
if (autoDisposeFont &&
!isSystemFont (font, widget.getDisplay ()))
widget.addDisposeListener (new FontDisposeListener (font));
}
/**
* Attach a DisposeListener that dispose the resource when the widget
* object is disposed.
*
* @param widget the widget to listen to.
* @param image the resource to be disposed.
*/
public static void attachImageDisposeListener (Widget widget, Image image)
{
if (autoDisposeImage &&
!isSystemImage (image, widget.getDisplay ()))
widget.addDisposeListener (new ImageDisposeListener (image));
}
/**
* Attach a dropdown menu to a drop down ToolItem. The drop down menu will be
* automatically positioned and displayed at under the ToolItem.
*
* @param item the drop down tool item
* @param menu the drop down menu
*/
public static void attachToolItemDropDownMenu (ToolItem item, Menu menu)
{
item.addSelectionListener (new DropDownListener (menu));
}
/**
* Open all the shells inside the Display object and dispose the Display
* after all shells are disposed.
*
* @param display the Display object.
*/
public static void showDisplay (Display display)
{
// open shells for display
Shell[] shells = display.getShells ();
for (int i = 0; i < shells.length; ++i)
{
if (!shells[i].isDisposed () && !shells[i].isVisible ())
shells[i].open ();
}
// exit after all shells are disposed
while (!display.isDisposed ())
{
shells = display.getShells ();
boolean canExit = true;
for (int i = 0; i < shells.length; ++i)
{
if (!shells[i].isDisposed ())
{
canExit = false;
break;
}
}
if (canExit)
break;
if (!display.readAndDispatch ())
display.sleep ();
}
if (!display.isDisposed ())
display.dispose ();
}
/**
* This function is supposed to work in conjunction with assert to generate
* a debug message but does not really throw an Exception
*
* @param msg the message to be printed.
* @return true
*/
public static boolean disposeDebug (String msg)
{
System.out.println (msg);
return true;
}
}
</source>
Transparency
<source lang="java">
/******************************************************************************
* All Right Reserved. * Copyright (c) 1998, 2004 Jackwind Li Guojie * * Created on 2004-4-21 21:49:01 by JACK * $Id$ * *****************************************************************************/
import org.eclipse.swt.SWT; import org.eclipse.swt.events.PaintEvent; import org.eclipse.swt.events.PaintListener; import org.eclipse.swt.graphics.Image; import org.eclipse.swt.graphics.ImageData; import org.eclipse.swt.graphics.RGB; import org.eclipse.swt.layout.FillLayout; import org.eclipse.swt.widgets.Canvas; import org.eclipse.swt.widgets.Display; import org.eclipse.swt.widgets.Shell; public class Transparency {
Display display = new Display();
Shell shell = new Shell(display);
public Transparency() {
shell.setLayout(new FillLayout());
ImageData imageData = new ImageData("jexp.gif");
final Image image = new Image(display, imageData);
RGB white = new RGB(255, 255, 255);
for(int i=0; i<imageData.width; i++) {
for(int j=0; j<imageData.height; j++) {
RGB rgb = imageData.palette.getRGB(imageData.getPixel(i, j));
int threshold = 220;
if(rgb.red > threshold && rgb.green > threshold && rgb.blue > threshold)
imageData.setPixel(i, j, imageData.palette.getPixel(white));
}
}
imageData.transparentPixel = imageData.palette.getPixel(new RGB(255, 255, 255));
final Image image2 = new Image(display, imageData);
final Canvas canvas = new Canvas(shell, SWT.NULL);
canvas.addPaintListener(new PaintListener() {
public void paintControl(PaintEvent e) {
e.gc.drawImage(image, 10, 20);
e.gc.drawImage(image2, 200, 20);
}
});
shell.setSize(400, 140);
shell.open();
//textUser.forceFocus();
// Set up the event loop.
while (!shell.isDisposed()) {
if (!display.readAndDispatch()) {
// If no more entries in event queue
display.sleep();
}
}
display.dispose();
}
private void init() {
}
public static void main(String[] args) {
new Transparency();
}
}
</source>
Use of Java2D on SWT or Draw2D graphical context
<source lang="java">
/*
* -----------------------------------------------------------------------------
* (c) Copyright IBM Corp. 2004 All rights reserved.
*
* The sample program(s) is/are owned by International Business Machines
* Corporation or one of its subsidiaries ("IBM") and is/are copyrighted and
* licensed, not sold.
*
* You may copy, modify, and distribute this/these sample program(s) in any form
* without payment to IBM, for any purpose including developing, using,
* marketing or distributing programs that include or are derivative works of
* the sample program(s).
*
* The sample program(s) is/are provided to you on an "AS IS" basis, without
* warranty of any kind. IBM HEREBY EXPRESSLY DISCLAIMS ALL WARRANTIES, EITHER
* EXPRESS OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. Some jurisdictions do
* not allow for the exclusion or limitation of implied warranties, so the above
* limitations or exclusions may not apply to you. IBM shall not be liable for
* any damages you suffer as a result of using, modifying or distributing the
* sample program(s) or its/their derivatives.
*
* Each copy of any portion of this/these sample program(s) or any derivative
* work, must include the above copyright notice and disclaimer of warranty.
*
* -----------------------------------------------------------------------------
*/
import java.awt.GradientPaint; import java.awt.Graphics2D; import java.awt.RenderingHints; import java.awt.image.BufferedImage; import org.eclipse.swt.SWT; import org.eclipse.swt.events.PaintEvent; import org.eclipse.swt.events.PaintListener; import org.eclipse.swt.graphics.GC; import org.eclipse.swt.graphics.Image; import org.eclipse.swt.graphics.ImageData; import org.eclipse.swt.graphics.PaletteData; import org.eclipse.swt.graphics.Point; import org.eclipse.swt.layout.GridData; import org.eclipse.swt.layout.GridLayout; import org.eclipse.swt.widgets.Canvas; import org.eclipse.swt.widgets.Control; import org.eclipse.swt.widgets.Display; import org.eclipse.swt.widgets.Shell; public class SWTTest {
public static void main(String[] args) {
Display display = new Display();
Shell shell = new Shell(display);
shell.setSize(350, 350);
shell.setLayout(new GridLayout());
Canvas canvas = new Canvas(shell, SWT.NO_BACKGROUND);
GridData data = new GridData(GridData.FILL_BOTH);
canvas.setLayoutData(data);
final Graphics2DRenderer renderer = new Graphics2DRenderer();
canvas.addPaintListener(new PaintListener() {
public void paintControl(PaintEvent e) {
Point controlSize = ((Control) e.getSource()).getSize();
GC gc = e.gc; // gets the SWT graphics context from the event
renderer.prepareRendering(gc); // prepares the Graphics2D
// renderer
// gets the Graphics2D context and switch on the antialiasing
Graphics2D g2d = renderer.getGraphics2D();
g2d.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING,
RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
// paints the background with a color gradient
g2d.setPaint(new GradientPaint(0.0f, 0.0f,
java.awt.Color.yellow, (float) controlSize.x,
(float) controlSize.y, java.awt.Color.white));
g2d.fillRect(0, 0, controlSize.x, controlSize.y);
// draws rotated text
g2d.setFont(new java.awt.Font("SansSerif", java.awt.Font.BOLD,
16));
g2d.setColor(java.awt.Color.blue);
g2d.translate(controlSize.x / 2, controlSize.y / 2);
int nbOfSlices = 18;
for (int i = 0; i < nbOfSlices; i++) {
g2d.drawString("Angle = " + (i * 360 / nbOfSlices)
+ "\u00B0", 30, 0);
g2d.rotate(-2 * Math.PI / nbOfSlices);
}
// now that we are done with Java2D, renders Graphics2D
// operation
// on the SWT graphics context
renderer.render(gc);
// now we can continue with pure SWT paint operations
gc.drawOval(0, 0, controlSize.x, controlSize.y);
}
});
shell.open();
while (!shell.isDisposed()) {
if (!display.readAndDispatch())
display.sleep();
}
display.dispose();
renderer.dispose();
System.exit(0);
}
} /*
* -----------------------------------------------------------------------------
* (c) Copyright IBM Corp. 2004 All rights reserved.
*
* The sample program(s) is/are owned by International Business Machines
* Corporation or one of its subsidiaries ("IBM") and is/are copyrighted and
* licensed, not sold.
*
* You may copy, modify, and distribute this/these sample program(s) in any form
* without payment to IBM, for any purpose including developing, using,
* marketing or distributing programs that include or are derivative works of
* the sample program(s).
*
* The sample program(s) is/are provided to you on an "AS IS" basis, without
* warranty of any kind. IBM HEREBY EXPRESSLY DISCLAIMS ALL WARRANTIES, EITHER
* EXPRESS OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. Some jurisdictions do
* not allow for the exclusion or limitation of implied warranties, so the above
* limitations or exclusions may not apply to you. IBM shall not be liable for
* any damages you suffer as a result of using, modifying or distributing the
* sample program(s) or its/their derivatives.
*
* Each copy of any portion of this/these sample program(s) or any derivative
* work, must include the above copyright notice and disclaimer of warranty.
*
* -----------------------------------------------------------------------------
*/
/**
* Helper class allowing the use of Java2D on SWT or Draw2D graphical context. * * @author Yannick Saillet */
class Graphics2DRenderer {
private static final PaletteData PALETTE_DATA = new PaletteData(0xFF0000,
0xFF00, 0xFF);
private BufferedImage awtImage;
private Image swtImage;
private ImageData swtImageData;
private int[] awtPixels;
/** RGB value to use as transparent color */
private static final int TRANSPARENT_COLOR = 0x123456;
/**
* Prepare to render on a SWT graphics context.
*/
public void prepareRendering(GC gc) {
org.eclipse.swt.graphics.Rectangle clip = gc.getClipping();
prepareRendering(clip.x, clip.y, clip.width, clip.height);
}
/**
* Prepare to render on a Draw2D graphics context.
*/
public void prepareRendering(org.eclipse.draw2d.Graphics graphics) {
org.eclipse.draw2d.geometry.Rectangle clip = graphics
.getClip(new org.eclipse.draw2d.geometry.Rectangle());
prepareRendering(clip.x, clip.y, clip.width, clip.height);
}
/**
* Prepare the AWT offscreen image for the rendering of the rectangular
* region given as parameter.
*/
private void prepareRendering(int clipX, int clipY, int clipW, int clipH) {
// check that the offscreen images are initialized and large enough
checkOffScreenImages(clipW, clipH);
// fill the region in the AWT image with the transparent color
java.awt.Graphics awtGraphics = awtImage.getGraphics();
awtGraphics.setColor(new java.awt.Color(TRANSPARENT_COLOR));
awtGraphics.fillRect(clipX, clipY, clipW, clipH);
}
/**
* Returns the Graphics2D context to use.
*/
public Graphics2D getGraphics2D() {
if (awtImage == null)
return null;
return (Graphics2D) awtImage.getGraphics();
}
/**
* Complete the rendering by flushing the 2D renderer on a SWT graphical
* context.
*/
public void render(GC gc) {
if (awtImage == null)
return;
org.eclipse.swt.graphics.Rectangle clip = gc.getClipping();
transferPixels(clip.x, clip.y, clip.width, clip.height);
gc.drawImage(swtImage, clip.x, clip.y, clip.width, clip.height, clip.x,
clip.y, clip.width, clip.height);
}
/**
* Complete the rendering by flushing the 2D renderer on a Draw2D graphical
* context.
*/
public void render(org.eclipse.draw2d.Graphics graphics) {
if (awtImage == null)
return;
org.eclipse.draw2d.geometry.Rectangle clip = graphics
.getClip(new org.eclipse.draw2d.geometry.Rectangle());
transferPixels(clip.x, clip.y, clip.width, clip.height);
graphics.drawImage(swtImage, clip.x, clip.y, clip.width, clip.height,
clip.x, clip.y, clip.width, clip.height);
}
/**
* Transfer a rectangular region from the AWT image to the SWT image.
*/
private void transferPixels(int clipX, int clipY, int clipW, int clipH) {
int step = swtImageData.depth / 8;
byte[] data = swtImageData.data;
awtImage.getRGB(clipX, clipY, clipW, clipH, awtPixels, 0, clipW);
for (int i = 0; i < clipH; i++) {
int idx = (clipY + i) * swtImageData.bytesPerLine + clipX * step;
for (int j = 0; j < clipW; j++) {
int rgb = awtPixels[j + i * clipW];
for (int k = swtImageData.depth - 8; k >= 0; k -= 8) {
data[idx++] = (byte) ((rgb >> k) & 0xFF);
}
}
}
if (swtImage != null)
swtImage.dispose();
swtImage = new Image(Display.getDefault(), swtImageData);
}
/**
* Dispose the resources attached to this 2D renderer.
*/
public void dispose() {
if (awtImage != null)
awtImage.flush();
if (swtImage != null)
swtImage.dispose();
awtImage = null;
swtImageData = null;
awtPixels = null;
}
/**
* Ensure that the offscreen images are initialized and are at least as
* large as the size given as parameter.
*/
private void checkOffScreenImages(int width, int height) {
int currentImageWidth = 0;
int currentImageHeight = 0;
if (swtImage != null) {
currentImageWidth = swtImage.getImageData().width;
currentImageHeight = swtImage.getImageData().height;
}
// if the offscreen images are too small, recreate them
if (width > currentImageWidth || height > currentImageHeight) {
dispose();
width = Math.max(width, currentImageWidth);
height = Math.max(height, currentImageHeight);
awtImage = new BufferedImage(width, height,
BufferedImage.TYPE_INT_ARGB);
swtImageData = new ImageData(width, height, 24, PALETTE_DATA);
swtImageData.transparentPixel = TRANSPARENT_COLOR;
awtPixels = new int[width * height];
}
}
}
</source>
Utility methods for drawing graphics
<source lang="java">
//Send questions, comments, bug reports, etc. to the authors: //Rob Warner (rwarner@interspatial.ru) //Robert Harris (rbrt_harris@yahoo.ru) import org.eclipse.swt.*; import org.eclipse.swt.graphics.*; import org.eclipse.swt.widgets.Display; /**
* This class contains utility methods for drawing graphics */
public class GraphicsUtils {
/** * Draws text vertically (rotates plus or minus 90 degrees). Uses the current * font, color, and background.*
-
*
- Styles: *
- UP, DOWN *
* * @param string the text to draw * @param x the x coordinate of the top left corner of the drawing rectangle * @param y the y coordinate of the top left corner of the drawing rectangle * @param gc the GC on which to draw the text * @param style the style (SWT.UP or SWT.DOWN)*
* Note: Only one of the style UP or DOWN may be specified. *
*/
public static void drawVerticalText(String string, int x, int y, GC gc,
int style) {
// Get the current display
Display display = Display.getCurrent();
if (display == null) SWT.error(SWT.ERROR_THREAD_INVALID_ACCESS);
// Determine string"s dimensions
FontMetrics fm = gc.getFontMetrics();
Point pt = gc.textExtent(string);
// Create an image the same size as the string
Image stringImage = new Image(display, pt.x, pt.y);
// Create a GC so we can draw the image
GC stringGc = new GC(stringImage);
// Set attributes from the original GC to the new GC
stringGc.setForeground(gc.getForeground());
stringGc.setBackground(gc.getBackground());
stringGc.setFont(gc.getFont());
// Draw the text onto the image
stringGc.drawText(string, 0, 0);
// Draw the image vertically onto the original GC
drawVerticalImage(stringImage, x, y, gc, style);
// Dispose the new GC
stringGc.dispose();
// Dispose the image
stringImage.dispose();
}
/**
* Draws an image vertically (rotates plus or minus 90 degrees)
* -
*
- Styles: *
- UP, DOWN *
* * @param image the image to draw * @param x the x coordinate of the top left corner of the drawing rectangle * @param y the y coordinate of the top left corner of the drawing rectangle * @param gc the GC on which to draw the image * @param style the style (SWT.UP or SWT.DOWN)*
* Note: Only one of the style UP or DOWN may be specified. *
*/
public static void drawVerticalImage(Image image, int x, int y, GC gc, int style) {
// Get the current display
Display display = Display.getCurrent();
if (display == null) SWT.error(SWT.ERROR_THREAD_INVALID_ACCESS);
// Use the image"s data to create a rotated image"s data
ImageData sd = image.getImageData();
ImageData dd = new ImageData(sd.height, sd.width, sd.depth, sd.palette);
// Determine which way to rotate, depending on up or down
boolean up = (style & SWT.UP) == SWT.UP;
// Run through the horizontal pixels
for (int sx = 0; sx < sd.width; sx++) {
// Run through the vertical pixels
for (int sy = 0; sy < sd.height; sy++) {
// Determine where to move pixel to in destination image data
int dx = up ? sy : sd.height - sy - 1;
int dy = up ? sd.width - sx - 1 : sx;
// Swap the x, y source data to y, x in the destination
dd.setPixel(dx, dy, sd.getPixel(sx, sy));
}
}
// Create the vertical image
Image vertical = new Image(display, dd);
// Draw the vertical image onto the original GC
gc.drawImage(vertical, x, y);
// Dispose the vertical image
vertical.dispose();
}
/**
* Creates an image containing the specified text, rotated either plus or minus
* 90 degrees.
* -
*
- Styles: *
- UP, DOWN *
* * @param text the text to rotate * @param font the font to use * @param foreground the color for the text * @param background the background color * @param style direction to rotate (up or down) * @return Image*
* Note: Only one of the style UP or DOWN may be specified. *
*/
public static Image createRotatedText(String text, Font font, Color foreground,
Color background, int style) {
// Get the current display
Display display = Display.getCurrent();
if (display == null) SWT.error(SWT.ERROR_THREAD_INVALID_ACCESS);
// Create a GC to calculate font"s dimensions
GC gc = new GC(display);
gc.setFont(font);
// Determine string"s dimensions
FontMetrics fm = gc.getFontMetrics();
Point pt = gc.textExtent(text);
// Dispose that gc
gc.dispose();
// Create an image the same size as the string
Image stringImage = new Image(display, pt.x, pt.y);
// Create a gc for the image
gc = new GC(stringImage);
gc.setFont(font);
gc.setForeground(foreground);
gc.setBackground(background);
// Draw the text onto the image
gc.drawText(text, 0, 0);
// Draw the image vertically onto the original GC
Image image = createRotatedImage(stringImage, style);
// Dispose the new GC
gc.dispose();
// Dispose the horizontal image
stringImage.dispose();
// Return the rotated image
return image;
}
/**
* Creates a rotated image (plus or minus 90 degrees)
* -
*
- Styles: *
- UP, DOWN *
* * @param image the image to rotate * @param style direction to rotate (up or down) * @return Image*
* Note: Only one of the style UP or DOWN may be specified. *
*/
public static Image createRotatedImage(Image image, int style) {
// Get the current display
Display display = Display.getCurrent();
if (display == null) SWT.error(SWT.ERROR_THREAD_INVALID_ACCESS);
// Use the image"s data to create a rotated image"s data
ImageData sd = image.getImageData();
ImageData dd = new ImageData(sd.height, sd.width, sd.depth, sd.palette);
// Determine which way to rotate, depending on up or down
boolean up = (style & SWT.UP) == SWT.UP;
// Run through the horizontal pixels
for (int sx = 0; sx < sd.width; sx++) {
// Run through the vertical pixels
for (int sy = 0; sy < sd.height; sy++) {
// Determine where to move pixel to in destination image data
int dx = up ? sy : sd.height - sy - 1;
int dy = up ? sd.width - sx - 1 : sx;
// Swap the x, y source data to y, x in the destination
dd.setPixel(dx, dy, sd.getPixel(sx, sy));
}
}
// Create the vertical image
return new Image(display, dd);
}
}
</source>
XOR
<source lang="java">
/******************************************************************************
* All Right Reserved. * Copyright (c) 1998, 2004 Jackwind Li Guojie * * Created on 2004-4-19 15:31:18 by JACK * $Id$ * *****************************************************************************/
import org.eclipse.swt.SWT; import org.eclipse.swt.events.PaintEvent; import org.eclipse.swt.events.PaintListener; import org.eclipse.swt.layout.FillLayout; import org.eclipse.swt.widgets.Canvas; import org.eclipse.swt.widgets.Display; import org.eclipse.swt.widgets.Shell; public class XOR {
Display display = new Display();
Shell shell = new Shell(display);
public XOR() {
shell.setLayout(new FillLayout());
final Canvas canvas = new Canvas(shell, SWT.NULL);
canvas.setBackground(display.getSystemColor(SWT.COLOR_WHITE));
canvas.addPaintListener(new PaintListener() {
public void paintControl(PaintEvent e) {
e.gc.setXORMode(true);
e.gc.setBackground(display.getSystemColor(SWT.COLOR_GREEN));
e.gc.fillOval(60, 10, 100, 100); // Top
e.gc.setBackground(display.getSystemColor(SWT.COLOR_RED));
e.gc.fillOval(10, 60, 120, 120); // left bottom
e.gc.setBackground(display.getSystemColor(SWT.COLOR_BLUE));
e.gc.fillOval(110, 60, 100, 100); // right bottom
}
});
shell.setSize(300, 220);
shell.open();
//textUser.forceFocus();
// Set up the event loop.
while (!shell.isDisposed()) {
if (!display.readAndDispatch()) {
// If no more entries in event queue
display.sleep();
}
}
display.dispose();
}
private void init() {
}
public static void main(String[] args) {
new XOR();
}
}
</source>
