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

Documents