SWT Graphics Example
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.Combo;
import org.eclipse.swt.widgets.Composite;
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.computeSize(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.computeTrim(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.computeSize(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);
}
}
Related examples in the same category
