Capitulo 1 GUI Threads

Capitulo 1 GUI Threads
1. Is Event Dispatcher Thread

import java.awt.Color;
import java.awt.Component;
import java.awt.Dimension;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Random;
import javax.swing.AbstractAction;
import javax.swing.ButtonGroup;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JRadioButton;
import javax.swing.JTable;
import javax.swing.SwingUtilities;
import javax.swing.table.AbstractTableModel;
import javax.swing.table.TableCellRenderer;
public class IsEDTExample extends JPanel {

private boolean keepRunning;
private static int RED = 0;
private static int BLUE = 1;
private static int GREEN = 2;
private static int VARIABLE = 3;
private static int SIZE = 3;
private int threadShade;
private ColorTableModel tableModel= new ColorTableModel();
private Thread colorShadeThread;
public IsEDTExample() {
JTable table = new JTable(tableModel);
table.setRowHeight(100);
table.setDefaultRenderer(Object.class, new ColorRenderer());
add(table);
add(new JLabel("Thread Color Shade:"));

ButtonGroup group = new ButtonGroup();
JRadioButton redOption = new JRadioButton("Red");
group.add(redOption);
redOption.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
threadShade = RED;
}
});
JRadioButton blueOption = new JRadioButton("Blue");

group.add(blueOption);
blueOption.addActionListener(new ActionListener() {
threadShade = BLUE;
}
});
JRadioButton greenOption = new JRadioButton("Green");

group.add(greenOption);
greenOption.addActionListener(new ActionListener() {
threadShade = GREEN;
}
});
redOption.setSelected(true);
this.threadShade = RED;
add(redOption);
add(greenOption);
add(blueOption);
add(new JButton(new RandomColorAction()));
this.keepRunning = true;
this.colorShadeThread = new Thread(new RandomColorShadeRunnable());
this.colorShadeThread.start();
}
private class RandomColorAction extends AbstractAction {

public RandomColorAction() {
super("Create Random Color");
}

IsEDTExample.this.tableModel.generateRandomColor(VARIABLE);
}
}
private class ColorTableModel extends AbstractTableModel {

private Color[][] colors = new Color[3][3];
public ColorTableModel() {
for (int i = 0; i < SIZE; i++) {
for (int x = 0; x < SIZE; x++) {
colors[i][x] = Color.white;
}
}
}
public int getRowCount() {

return SIZE;
}
public int getColumnCount() {

return SIZE;
}
public Object getValueAt(int rowIndex, int columnIndex) {

return colors[rowIndex][columnIndex];
}
public void generateRandomColor(int type) {

Random random = new Random(System.currentTimeMillis());
final int row = random.nextInt(SIZE);

final int column = random.nextInt(SIZE);
final Color color;
if (type == RED) {
color = new Color(random.nextInt(256), 0, 0);
} else if (type == BLUE) {
color = new Color(0, 0, random.nextInt(256));
} else if (type == GREEN) {
color = new Color(0, random.nextInt(256), 0);
} else {
color = new Color(random.nextInt(256), random.nextInt(256),
random.nextInt(256));
}
if (SwingUtilities.isEventDispatchThread()) {
colors[row][column] = color;
fireTableCellUpdated(row, column);
} else {
SwingUtilities.invokeLater(new Runnable() {
public void run() {
colors[row][column] = color;
fireTableCellUpdated(row, column);
}
});
}
}
}
private class ColorRenderer implements TableCellRenderer {

private JLabel label;
public ColorRenderer() {
label = new JLabel();
label.setOpaque(true);
label.setPreferredSize(new Dimension(100, 100));
}
public Component getTableCellRendererComponent(JTable table, Object value,

boolean isSelected,
boolean hasFocus, int row, int column) {
label.setBackground((Color) value);
return label;
}
}
private class RandomColorShadeRunnable implements Runnable {

public void run() {
while (keepRunning) {
tableModel.generateRandomColor(threadShade);
try {
Thread.sleep(500);
} catch (InterruptedException e) {
}
}
}
}
public static void main(String[] a) {

JFrame f = new JFrame("Is Event Dispatch Thread Example");
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
f.add(new IsEDTExample());
f.pack();
f.setVisible(true);
}
}
2. GUI clock
import java.applet.Applet;
import java.awt.Graphics;
import java.text.DateFormat;
import java.util.Calendar;
import java.util.Date;
public class GUIClock extends Applet implements Sleeper {
private AlarmClock clock;
public void init() {

clock = new AlarmClock();
}
public void start() {

clock.letMeSleepFor(this, ONE_SECOND);
}
public void paint(Graphics g) {

Calendar cal = Calendar.getInstance();
Date date = cal.getTime();
DateFormat dateFormatter = DateFormat.getTimeInstance();
g.drawString(dateFormatter.format(date), 5, 10);
}
public void wakeUp() {

repaint();
clock.letMeSleepFor(this, ONE_SECOND);
}
}
interface Sleeper {
public void wakeUp();
public long ONE_SECOND = 1000; // in milliseconds

}
class AlarmClock {
private static final int MAX_CAPACITY = 10;
private static final int UNUSED = -1;
private static final int NOROOM = -1;
private Sleeper[] sleepers = new Sleeper[MAX_CAPACITY];
private long[] sleepFor = new long[MAX_CAPACITY];
public AlarmClock() {
for (int i = 0; i < MAX_CAPACITY; i++)
sleepFor[i] = UNUSED;
public synchronized boolean letMeSleepFor(Sleeper s, long time) {

int index = findNextSlot();
if (index == NOROOM) {
return false;
} else {
sleepers[index] = s;
sleepFor[index] = time;
new AlarmThread(index).start();
return true;
}
}
private synchronized int findNextSlot() {

for (int i = 0; i < MAX_CAPACITY; i++) {
if (sleepFor[i] == UNUSED)
return i;
}
return NOROOM;
}
private synchronized void wakeUpSleeper(int sleeperIndex) {

sleepers[sleeperIndex].wakeUp();
sleepers[sleeperIndex] = null;
sleepFor[sleeperIndex] = UNUSED;
}
private class AlarmThread extends Thread {

int mySleeper;
AlarmThread(int sleeperIndex) {
super();
mySleeper = sleeperIndex;
}
public void run() {

try {
sleep(sleepFor[mySleeper]);
}
wakeUpSleeper(mySleeper);
}
}
}
3. Race Conditions using Swing Components

import java.awt.BorderLayout;
import java.awt.Container;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import javax.swing.JTextField;
public class EventThreadFrame extends JFrame {

private JTextField statusField = new JTextField("Initial Value");
public EventThreadFrame() {
Container cp = getContentPane();
cp.add(statusField, BorderLayout.NORTH);
addWindowListener(new WindowAdapter() {
public void windowOpened(WindowEvent e) {
try { // Simulate initialization overhead
Thread.sleep(2000);
} catch (InterruptedException ex) {
throw new RuntimeException(ex);
}
statusField.setText("Initialization complete");
}
});
}
public static void main(String[] args) {

EventThreadFrame etf = new EventThreadFrame();
run(etf, 150, 60);
etf.statusField.setText("Application ready");
System.out.println("Done");
}
public static void run(JFrame frame, int width, int height) {

frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setSize(width, height);
frame.setVisible(true);
}
} ///:~
4. Using the Runnable interface
import java.awt.GridLayout;
import java.util.Random;
import javax.swing.JApplet;
class CBox extends JPanel implements Runnable {

private Thread t;
private int pause;
private static final Color[] colors = { Color.BLACK, Color.BLUE,

Color.CYAN, Color.DARK_GRAY, Color.GRAY, Color.GREEN,
Color.LIGHT_GRAY, Color.MAGENTA, Color.ORANGE, Color.PINK,
Color.RED, Color.WHITE, Color.YELLOW };
private static Random rand = new Random();
private static final Color newColor() {

return colors[rand.nextInt(colors.length)];
}
private Color cColor = newColor();
public void paintComponent(Graphics g) {
super.paintComponent(g);
g.setColor(cColor);
Dimension s = getSize();
g.fillRect(0, 0, s.width, s.height);
}
public CBox(int pause) {

this.pause = pause;
t = new Thread(this);
t.start();
}
public void run() {

while (true) {
cColor = newColor();
repaint();
try {
t.sleep(pause);
throw new RuntimeException(e);
}
}
}
}
public class ColorBoxes extends JApplet {

private boolean isApplet = true;
private int grid = 12;
private int pause = 50;
public void init() {

// Get parameters from Web page:
if (isApplet) {
String gsize = getParameter("grid");
if (gsize != null)
grid = Integer.parseInt(gsize);
String pse = getParameter("pause");
if (pse != null)
pause = Integer.parseInt(pse);
}
Container cp = getContentPane();
cp.setLayout(new GridLayout(grid, grid));
for (int i = 0; i < grid * grid; i++)
cp.add(new CBox(pause));
}

ColorBoxes applet = new ColorBoxes();
applet.isApplet = false;
if (args.length > 0)
applet.grid = Integer.parseInt(args[0]);
if (args.length > 1)
applet.pause = Integer.parseInt(args[1]);
run(applet, 500, 400);
}
public static void run(JApplet applet, int width, int height) {

JFrame frame = new JFrame();
frame.getContentPane().add(applet);
applet.init();
applet.start();
}
} ///:~
5. Write your Beans this way so they can run in a multithreaded environment
import java.awt.Font;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.event.MouseMotionAdapter;
import java.io.Serializable;
import java.util.ArrayList;
public class BangBean2 extends JPanel implements Serializable {

private int xm, ym;
private int cSize = 20; // Circle size
private String text = "Bang!";
private int fontSize = 48;
private Color tColor = Color.RED;
private ArrayList actionListeners = new ArrayList();
public BangBean2() {
addMouseListener(new ML());
addMouseMotionListener(new MM());
}
public synchronized int getCircleSize() {

return cSize;
}
public synchronized void setCircleSize(int newSize) {

cSize = newSize;
}
public synchronized String getBangText() {

return text;
}
public synchronized void setBangText(String newText) {

text = newText;
}
public synchronized int getFontSize() {
return fontSize;
}
public synchronized void setFontSize(int newSize) {

fontSize = newSize;
}
public synchronized Color getTextColor() {

return tColor;
}
public synchronized void setTextColor(Color newColor) {

tColor = newColor;
}
public void paintComponent(Graphics g) {

super.paintComponent(g);
g.setColor(Color.BLACK);
g.drawOval(xm - cSize / 2, ym - cSize / 2, cSize, cSize);
}
// This is a multicast listener, which is more typically

// used than the unicast approach taken in BangBean.java:
public synchronized void addActionListener(ActionListener l) {
actionListeners.add(l);
}
public synchronized void removeActionListener(ActionListener l) {

actionListeners.remove(l);
}
// Notice this isn't synchronized:

public void notifyListeners() {
ActionEvent a = new ActionEvent(BangBean2.this,
ActionEvent.ACTION_PERFORMED, null);
ArrayList lv = null;
// Make a shallow copy of the List in case
// someone adds a listener while we're
// calling listeners:
synchronized (this) {
lv = (ArrayList) actionListeners.clone();
}
// Call all the listener methods:
for (int i = 0; i < lv.size(); i++)
((ActionListener) lv.get(i)).actionPerformed(a);
}
class ML extends MouseAdapter {

public void mousePressed(MouseEvent e) {
Graphics g = getGraphics();
g.setColor(tColor);
g.setFont(new Font("TimesRoman", Font.BOLD, fontSize));
int width = g.getFontMetrics().stringWidth(text);
g.drawString(text, (getSize().width - width) / 2,
getSize().height / 2);
g.dispose();
notifyListeners();
}
}
class MM extends MouseMotionAdapter {

public void mouseMoved(MouseEvent e) {
xm = e.getX();
ym = e.getY();
repaint();
}
}

BangBean2 bb = new BangBean2();
bb.addActionListener(new ActionListener() {
System.out.println("ActionEvent" + e);
}
});
System.out.println("BangBean2 action");
}
});
System.out.println("More action");
}
});
run(bb, 300, 300);
}
public static void run(JPanel panel, int width, int height) {

JFrame frame = new JFrame();
frame.getContentPane().add(panel);
}
} ///:~
6. User interface responsiveness

import java.awt.FlowLayout;
public class InvokeExample {

private static JButton good = new JButton("Good");
private static JButton bad = new JButton("Bad");
private static JButton bad2 = new JButton("Bad2");
private static JLabel resultLabel = new JLabel("Ready", JLabel.CENTER);

JFrame f = new JFrame();
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
// Layout . . .
JPanel p = new JPanel();
p.setOpaque(true);
p.setLayout(new FlowLayout());
p.add(good);
p.add(bad);
p.add(bad2);
Container c = f.getContentPane();
c.setLayout(new BorderLayout());
c.add(p, BorderLayout.CENTER);
c.add(resultLabel, BorderLayout.SOUTH);
// Listeners
good.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent ev) {
resultLabel.setText("Working . . .");
setEnabled(false);
// We're going to do something that takes a long time, so we

// spin off a thread and update the display when we're done.
Thread worker = new Thread() {
public void run() {
// Something that takes a long time . . . in real life,
// this
// might be a DB query, remote method invocation, etc.
try {
Thread.sleep(5000);
}
// Report the result using invokeLater().

public void run() {
resultLabel.setText("Ready");
setEnabled(true);
}
});
}
};
worker.start(); // So we don't hold up the dispatch thread.

}
});
bad.addActionListener(new ActionListener() {
resultLabel.setText("Working . . .");
setEnabled(false);
// We're going to do the same thing, but not in a separate

// thread.
try {
Thread.sleep(5000); // Dispatch thread is starving!
}
// Report the result.

setEnabled(true);
}
});
bad2.addActionListener(new ActionListener() {
resultLabel.setText("Working . . . ");
setEnabled(false);
// The wrong way to use invokeLater(). The runnable() shouldn't

// starve the dispatch thread.
public void run() {
try {
Thread.sleep(5000); // Dispatch thread is starving!
}
setEnabled(true);
}
});
}
});
f.setSize(300, 100);
f.setVisible(true);
// Allows us to turn the buttons on or off while we work.

static void setEnabled(boolean b) {
good.setEnabled(b);
bad.setEnabled(b);
bad2.setEnabled(b);
}
}
7. Counter: Swing and thread
import java.text.DecimalFormat;
import javax.swing.JComponent;
import javax.swing.border.EmptyBorder;
public class SecondCounterDemo extends JPanel {

private SecondCounterRunnable sc = new SecondCounterRunnable();
private JButton startB = new JButton("Start");
private JButton stopB = new JButton("Stop");
public SecondCounterDemo() {
stopB.setEnabled(false); // begin with this disabled
startB.addActionListener(new ActionListener() {
startB.setEnabled(false);
Thread counterThread = new Thread(sc, "Counter");

counterThread.start();
stopB.setEnabled(true);
stopB.requestFocus();
}
});
stopB.addActionListener(new ActionListener() {
stopB.setEnabled(false);
sc.stopClock();
startB.setEnabled(true);
startB.requestFocus();
}
});
JPanel innerButtonP = new JPanel();

innerButtonP.setLayout(new GridLayout(0, 1, 0, 3));
innerButtonP.add(startB);
innerButtonP.add(stopB);
JPanel buttonP = new JPanel();

buttonP.setLayout(new BorderLayout());
buttonP.add(innerButtonP, BorderLayout.NORTH);
this.setLayout(new BorderLayout(10, 10));

this.setBorder(new EmptyBorder(20, 20, 20, 20));
this.add(buttonP, BorderLayout.WEST);
this.add(sc, BorderLayout.CENTER);
}

SecondCounterDemo scm = new SecondCounterDemo();

f.setContentPane(scm);
f.setVisible(true);
f.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
System.exit(0);
}
});
}
class SecondCounterRunnable extends JComponent implements Runnable {

private volatile boolean keepRunning;
private Font paintFont = new Font("SansSerif", Font.BOLD, 14);
private volatile String timeMsg = "never started";
private volatile int arcLen = 0;
public SecondCounterRunnable() {
}
public void run() {

runClock();
}
public void runClock() {

DecimalFormat fmt = new DecimalFormat("0.000");
long normalSleepTime = 100;
int counter = 0;
keepRunning = true;
try {
Thread.sleep(normalSleepTime);
} catch (InterruptedException x) {
// ignore
}
counter++;
double counterSecs = counter / 10.0;
timeMsg = fmt.format(counterSecs);
arcLen = (((int) counterSecs) % 60) * 360 / 60;
repaint();
}
}
public void stopClock() {

keepRunning = false;
}

g.setColor(Color.black);
g.setFont(paintFont);
g.drawString(timeMsg, 0, 15);
g.fillOval(0, 20, 100, 100);
g.setColor(Color.white);
g.fillOval(3, 23, 94, 94);
g.setColor(Color.red);
g.fillArc(2, 22, 96, 96, 90, -arcLen);
}
}
}
8. Thread accuracy: Swing and threads
import java.text.DecimalFormat;
import javax.swing.border.EmptyBorder;
public class SecondCounterMain extends JPanel {

private SecondCounter sc = new SecondCounter();
private JButton startB = new JButton("Start");
private JButton stopB = new JButton("Stop");
public SecondCounterMain() {
startB.addActionListener(new ActionListener() {
startB.setEnabled(false);
Thread counterThread = new Thread(sc, "Counter");

counterThread.start();
stopB.setEnabled(true);
stopB.requestFocus();
}
});
stopB.addActionListener(new ActionListener() {
sc.stopClock();
startB.setEnabled(true);
startB.requestFocus();
}
});
JPanel innerButtonP = new JPanel();

innerButtonP.setLayout(new GridLayout(0, 1, 0, 3));
innerButtonP.add(startB);
innerButtonP.add(stopB);
JPanel buttonP = new JPanel();

buttonP.setLayout(new BorderLayout());
buttonP.add(innerButtonP, BorderLayout.NORTH);
this.setLayout(new BorderLayout(10, 10));

this.setBorder(new EmptyBorder(20, 20, 20, 20));
this.add(buttonP, BorderLayout.WEST);
this.add(sc, BorderLayout.CENTER);
}

SecondCounterMain scm = new SecondCounterMain();
JFrame f = new JFrame("Second Counter");

f.setContentPane(scm);
f.setVisible(true);
System.exit(0);
}
});
}
class SecondCounter extends JComponent implements Runnable {

private volatile boolean keepRunning;
private Font paintFont = new Font("SansSerif", Font.BOLD, 14);
private volatile String timeMsg = "never started";
private volatile int arcLen = 0;
public SecondCounter() {
}
public void run() {

runClock();
}
public void runClock() {

DecimalFormat fmt = new DecimalFormat("0.000");
long normalSleepTime = 100;
long nextSleepTime = normalSleepTime;
int counter = 0;
long startTime = System.currentTimeMillis();
keepRunning = true;
try {
Thread.sleep(nextSleepTime);
// ignore
}
counter++;
double counterSecs = counter / 10.0;
double elapsedSecs = (System.currentTimeMillis() - startTime) / 1000.0;
double diffSecs = counterSecs - elapsedSecs;
nextSleepTime = normalSleepTime + ((long) (diffSecs * 1000.0));
if (nextSleepTime < 0) {
nextSleepTime = 0;
}
timeMsg = fmt.format(counterSecs) + " - "

+ fmt.format(elapsedSecs) + " = "
+ fmt.format(diffSecs);
arcLen = (((int) counterSecs) % 60) * 360 / 60;
repaint();
}
}
public void stopClock() {

keepRunning = false;
}

g.setFont(paintFont);
g.drawString(timeMsg, 0, 15);
g.fillOval(0, 20, 100, 100); // black border
g.setColor(Color.white);
g.fillOval(3, 23, 94, 94); // white for unused portion
g.setColor(Color.blue); // blue for used portion

g.fillArc(2, 22, 96, 96, 90, -arcLen);
}
}
}
9. Swing and thread: invoke and wait
import java.lang.reflect.InvocationTargetException;
public class InvokeAndWaitDemo extends Object {

private static void print(String msg) {
String name = Thread.currentThread().getName();
System.out.println(name + ": " + msg);
}

final JLabel label = new JLabel("--------");
JPanel panel = new JPanel(new FlowLayout());

panel.add(label);
JFrame f = new JFrame("InvokeAndWaitDemo");

f.setContentPane(panel);
f.setVisible(true);
try {
print("sleeping for 3 seconds");
Thread.sleep(3000);
print("creating code block for event thread");

Runnable setTextRun = new Runnable() {
public void run() {
print("about to do setText()");
label.setText("New text!");
}
};
print("about to invokeAndWait()");
SwingUtilities.invokeAndWait(setTextRun);
print("back from invokeAndWait()");
} catch (InterruptedException ix) {
print("interrupted while waiting on invokeAndWait()");
} catch (InvocationTargetException x) {
print("exception thrown from run()");
}
}
}
10. Swing and threads: invoke later
public class InvokeLaterDemo extends Object {

private static void print(String msg) {
String name = Thread.currentThread().getName();
System.out.println(name + ": " + msg);
}

final JLabel label = new JLabel("--------");
JPanel panel = new JPanel(new FlowLayout());

panel.add(label);

f.setContentPane(panel);
f.setVisible(true);
try {
print("sleeping for 3 seconds");
Thread.sleep(3000);
} catch (InterruptedException ix) {
print("interrupted while sleeping");
}
print("creating code block for event thread");

Runnable setTextRun = new Runnable() {
public void run() {
try {
Thread.sleep(500);
print("about to do setText()");
label.setText("New text!");
} catch (Exception x) {
x.printStackTrace();
}
}
};
print("call invokeLater()");
SwingUtilities.invokeLater(setTextRun);
print("return from invokeLater()");
}
}
11. Swing and threads: slide

import java.awt.Graphics2D;
import java.awt.RenderingHints;
import java.awt.image.BufferedImage;
public class SlideShow extends JComponent {

private BufferedImage[] slide;
private Dimension slideSize;
private volatile int currSlide;
private Thread internalThread;
private volatile boolean noStopRequested;
public SlideShow() {
currSlide = 0;
slideSize = new Dimension(50, 50);
buildSlides();
setMinimumSize(slideSize);
setPreferredSize(slideSize);
setMaximumSize(slideSize);
setSize(slideSize);
noStopRequested = true;
Runnable r = new Runnable() {
public void run() {
try {
runWork();
}
}
};
internalThread = new Thread(r, "SlideShow");

internalThread.start();
}
private void buildSlides() {

RenderingHints renderHints = new RenderingHints(
RenderingHints.KEY_ANTIALIASING,
RenderingHints.VALUE_ANTIALIAS_ON);
renderHints.put(RenderingHints.KEY_RENDERING,
RenderingHints.VALUE_RENDER_QUALITY);
slide = new BufferedImage[20];
Color rectColor = Color.BLUE;
Color circleColor = Color.YELLOW;
for (int i = 0; i < slide.length; i++) {

slide[i] = new BufferedImage(slideSize.width, slideSize.height,
BufferedImage.TYPE_INT_RGB);
Graphics2D g2 = slide[i].createGraphics();
g2.setRenderingHints(renderHints);
g2.setColor(rectColor);
g2.fillRect(0, 0, slideSize.width, slideSize.height);
g2.setColor(circleColor);
int diameter = 0;
if (i < (slide.length / 2)) {
diameter = 5 + (8 * i);
} else {
diameter = 5 + (8 * (slide.length - i));
}
int inset = (slideSize.width - diameter) / 2;

g2.fillOval(inset, inset, diameter, diameter);
g2.setColor(Color.black);
g2.drawRect(0, 0, slideSize.width - 1, slideSize.height - 1);
g2.dispose();
}
}

g.drawImage(slide[currSlide], 0, 0, this);
}
private void runWork() {

while (noStopRequested) {
try {
Thread.sleep(100); // 10 frames per second
currSlide = (currSlide + 1) % slide.length;
repaint();
Thread.currentThread().interrupt();
}
}
}
public void stopRequest() {

noStopRequested = false;
internalThread.interrupt();
}
public boolean isAlive() {

return internalThread.isAlive();
}

SlideShow ss = new SlideShow();
JPanel p = new JPanel(new FlowLayout());
p.add(ss);
JFrame f = new JFrame("SlideShow");

f.setContentPane(p);
f.setVisible(true);
}
}
12. Swing and threads: scroll text
import java.awt.RenderingHints;
import java.awt.font.FontRenderContext;
import java.awt.font.TextLayout;
import java.awt.geom.Rectangle2D;
public class ScrollText extends JComponent {

private BufferedImage image;
private Dimension imageSize;
private volatile int currOffset;
public ScrollText(String text) {

currOffset = 0;
buildImage(text);
setMinimumSize(imageSize);
setPreferredSize(imageSize);
setMaximumSize(imageSize);
setSize(imageSize);
public void run() {
try {
runWork();
}
}
};
internalThread = new Thread(r, "ScrollText");

}
private void buildImage(String text) {

RenderingHints renderHints = new RenderingHints(
RenderingHints.KEY_ANTIALIASING,
RenderingHints.VALUE_ANTIALIAS_ON);
renderHints.put(RenderingHints.KEY_RENDERING,
RenderingHints.VALUE_RENDER_QUALITY);
BufferedImage scratchImage = new BufferedImage(1, 1,

Graphics2D scratchG2 = scratchImage.createGraphics();

scratchG2.setRenderingHints(renderHints);
Font font = new Font("Serif", Font.BOLD | Font.ITALIC, 24);
FontRenderContext frc = scratchG2.getFontRenderContext();

TextLayout tl = new TextLayout(text, font, frc);
Rectangle2D textBounds = tl.getBounds();
int textWidth = (int) Math.ceil(textBounds.getWidth());
int textHeight = (int) Math.ceil(textBounds.getHeight());
int horizontalPad = 10;

int verticalPad = 6;
imageSize = new Dimension(textWidth + horizontalPad, textHeight

+ verticalPad);
image = new BufferedImage(imageSize.width, imageSize.height,

Graphics2D g2 = image.createGraphics();
g2.setRenderingHints(renderHints);
int baselineOffset = (verticalPad / 2) - ((int) textBounds.getY());
g2.setColor(Color.white);
g2.fillRect(0, 0, imageSize.width, imageSize.height);
g2.setColor(Color.blue);
tl.draw(g2, 0, baselineOffset);
// Free-up resources right away, but keep "image" for

// animation.
scratchG2.dispose();
scratchImage.flush();
g2.dispose();
}

// Make sure to clip the edges, regardless of curr size
g.setClip(0, 0, imageSize.width, imageSize.height);
int localOffset = currOffset; // in case it changes

g.drawImage(image, -localOffset, 0, this);
g.drawImage(image, imageSize.width - localOffset, 0, this);
// draw outline
g.drawRect(0, 0, imageSize.width - 1, imageSize.height - 1);

try {
Thread.sleep(100); // 10 frames per second
// adjust the scroll position

currOffset = (currOffset + 1) % imageSize.width;
// signal the event thread to call paint()

repaint();
}
}
}

}

}

ScrollText st = new ScrollText("Java can do animation!");
JPanel p = new JPanel(new FlowLayout());

p.add(st);
JFrame f = new JFrame("ScrollText Demo");

f.setContentPane(p);
f.setVisible(true);
}
}
13. Animation: Swing and thread
import java.awt.Image;
import java.awt.geom.Ellipse2D;
import java.awt.geom.Rectangle2D;
public class SwingWithThread extends JComponent {

private Image[] frameList;
private long msPerFrame;
private volatile int currFrame;
public SwingWithThread(int width, int height, long msPerCycle, int framesPerSec,

Color fgColor) {
setPreferredSize(new Dimension(width, height));
int framesPerCycle = (int) ((framesPerSec * msPerCycle) / 1000);

msPerFrame = 1000L / framesPerSec;
frameList = buildImages(width, height, fgColor, framesPerCycle);

currFrame = 0;
public void run() {
try {
runWork();
// in case ANY exception slips through
}
}
};
internalThread = new Thread(r);
}
private Image[] buildImages(int width, int height, Color color, int count) {
BufferedImage[] im = new BufferedImage[count];
for (int i = 0; i < count; i++) {

im[i] = new BufferedImage(width, height,
BufferedImage.TYPE_INT_ARGB);
double xShape = 0.0;

double yShape = ((double) (i * height)) / (double) count;
double wShape = width;

double hShape = 2.0 * (height - yShape);
Rectangle2D shape = new Rectangle2D.Double(xShape, yShape, wShape,
hShape);
Graphics2D g2 = im[i].createGraphics();
g2.setColor(color);
g2.fill(shape);
g2.dispose();
}
return im;
}

currFrame = (currFrame + 1) % frameList.length;

repaint();
try {
Thread.sleep(msPerFrame);
}
}
}

}

}

g.drawImage(frameList[currFrame], 0, 0, this);
}

SwingWithThread redSquish = new SwingWithThread(250, 200, 2500L, 10,
Color.red);
f.setLayout(new FlowLayout());
f.add(redSquish);
f.setVisible(true);
System.exit(0);
}
});
}
}

Capitulo 1 GUI Threads

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Capitulo 1 GUI Threads

Uploaded by

Copyright:

Available Formats

Capitulo 1 GUI Threads

1. Is Event Dispatcher Thread

public class IsEDTExample extends JPanel {

private static int RED = 0;

private static int BLUE = 1;

private static int GREEN = 2;

private static int VARIABLE = 3;

private static int SIZE = 3;

private int threadShade;

private ColorTableModel tableModel= new ColorTableModel();

private Thread colorShadeThread;

add(new JLabel("Thread Color Shade:"));

JRadioButton blueOption = new JRadioButton("Blue");

JRadioButton greenOption = new JRadioButton("Green");

add(new JButton(new RandomColorAction()));

private class RandomColorAction extends AbstractAction {

public void actionPerformed(ActionEvent e) {

private class ColorTableModel extends AbstractTableModel {

public int getRowCount() {

public int getColumnCount() {

public Object getValueAt(int rowIndex, int columnIndex) {

public void generateRandomColor(int type) {

final int row = random.nextInt(SIZE);

private class ColorRenderer implements TableCellRenderer {

public Component getTableCellRendererComponent(JTable table, Object value,

private class RandomColorShadeRunnable implements Runnable {

public static void main(String[] a) {

public class GUIClock extends Applet implements Sleeper {

private AlarmClock clock;

public void init() {

public void start() {

public void paint(Graphics g) {

public void wakeUp() {

public long ONE_SECOND = 1000; // in milliseconds

private static final int MAX_CAPACITY = 10;

private static final int UNUSED = -1;

private static final int NOROOM = -1;

private Sleeper[] sleepers = new Sleeper[MAX_CAPACITY];

private long[] sleepFor = new long[MAX_CAPACITY];

public synchronized boolean letMeSleepFor(Sleeper s, long time) {

private synchronized int findNextSlot() {

private synchronized void wakeUpSleeper(int sleeperIndex) {

private class AlarmThread extends Thread {

public void run() {

3. Race Conditions using Swing Components

public class EventThreadFrame extends JFrame {

public static void main(String[] args) {

public static void run(JFrame frame, int width, int height) {

4. Using the Runnable interface

class CBox extends JPanel implements Runnable {

private int pause;

private static final Color[] colors = { Color.BLACK, Color.BLUE,

private static Random rand = new Random();

private static final Color newColor() {

private Color cColor = newColor();

public void paintComponent(Graphics g) {

public CBox(int pause) {

public void run() {

public class ColorBoxes extends JApplet {

private int grid = 12;

private int pause = 50;

public void init() {

public static void main(String[] args) {

public static void run(JApplet applet, int width, int height) {