用java swt实现的一个2d效果,很漂亮!
代码如下:
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
)
;
}
}