--- /dev/null 2018-05-11 11:35:00.000000000 -0700 +++ new/src/demo/share/jfc/J2Ddemo/java2d/Intro.java 2018-05-11 11:34:59.000000000 -0700 @@ -0,0 +1,1784 @@ +/* + * + * Copyright (c) 2007, 2011, Oracle and/or its affiliates. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * - Neither the name of Oracle nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS + * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, + * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +package java2d; + + +import static java.awt.Color.BLACK; +import static java.awt.Color.GRAY; +import static java.awt.Color.RED; +import static java.awt.Color.WHITE; +import static java.awt.Color.YELLOW; +import java.awt.AlphaComposite; +import java.awt.BorderLayout; +import java.awt.Color; +import java.awt.Composite; +import java.awt.Dimension; +import java.awt.Font; +import java.awt.FontMetrics; +import java.awt.GradientPaint; +import java.awt.Graphics; +import java.awt.Graphics2D; +import java.awt.Image; +import java.awt.Paint; +import java.awt.Point; +import java.awt.Rectangle; +import java.awt.RenderingHints; +import java.awt.Shape; +import java.awt.TexturePaint; +import java.awt.Toolkit; +import java.awt.event.ActionEvent; +import java.awt.event.ActionListener; +import java.awt.event.MouseAdapter; +import java.awt.event.MouseEvent; +import java.awt.event.WindowAdapter; +import java.awt.event.WindowEvent; +import java.awt.event.WindowListener; +import java.awt.font.FontRenderContext; +import java.awt.font.TextLayout; +import java.awt.geom.AffineTransform; +import java.awt.geom.Arc2D; +import java.awt.geom.Ellipse2D; +import java.awt.geom.FlatteningPathIterator; +import java.awt.geom.GeneralPath; +import java.awt.geom.Line2D; +import java.awt.geom.PathIterator; +import java.awt.geom.Point2D; +import java.awt.geom.Rectangle2D; +import java.awt.image.BufferedImage; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import javax.swing.JButton; +import javax.swing.JFrame; +import javax.swing.JPanel; +import javax.swing.JScrollPane; +import javax.swing.JSlider; +import javax.swing.JTable; +import javax.swing.border.BevelBorder; +import javax.swing.border.CompoundBorder; +import javax.swing.border.EmptyBorder; +import javax.swing.border.EtchedBorder; +import javax.swing.border.TitledBorder; +import javax.swing.event.ChangeEvent; +import javax.swing.event.ChangeListener; +import javax.swing.event.TableModelEvent; +import javax.swing.table.AbstractTableModel; +import javax.swing.table.TableColumn; +import javax.swing.table.TableModel; + + +/** + * Introduction to the J2Ddemo. + * + * @author Brian Lichtenwalter + * @author Alexander Kouznetsov + */ +@SuppressWarnings("serial") +public class Intro extends JPanel { + + private static final Color myBlack = new Color(20, 20, 20); + private static final Color myWhite = new Color(240, 240, 255); + private static final Color myRed = new Color(149, 43, 42); + private static final Color myBlue = new Color(94, 105, 176); + private static final Color myYellow = new Color(255, 255, 140); + private ScenesTable scenesTable; + private boolean doTable; + private final Surface surface; + + public Intro() { + EmptyBorder eb = new EmptyBorder(80, 110, 80, 110); + BevelBorder bb = new BevelBorder(BevelBorder.LOWERED); + setBorder(new CompoundBorder(eb, bb)); + setLayout(new BorderLayout()); + setBackground(GRAY); + setToolTipText("click for scene table"); + add(surface = new Surface()); + addMouseListener(new MouseAdapter() { + + @Override + public void mouseClicked(MouseEvent e) { + removeAll(); + if ((doTable = !doTable)) { + setToolTipText("click for animation"); + surface.stop(); + if (scenesTable == null) { + scenesTable = new ScenesTable(Intro.this); + } + add(scenesTable); + } else { + setToolTipText("click for scene table"); + surface.start(); + add(surface); + } + revalidate(); + repaint(); + } + }); + } + + public void start() { + if (!doTable) { + surface.start(); + } + } + + public void stop() { + if (!doTable) { + surface.stop(); + } + } + + public static void main(String argv[]) { + final Intro intro = new Intro(); + WindowListener l = new WindowAdapter() { + + @Override + public void windowClosing(WindowEvent e) { + System.exit(0); + } + + @Override + public void windowDeiconified(WindowEvent e) { + intro.start(); + } + + @Override + public void windowIconified(WindowEvent e) { + intro.stop(); + } + }; + JFrame f = new JFrame("Java2D(TM) Demo - Intro"); + f.addWindowListener(l); + f.getContentPane().add("Center", intro); + f.pack(); + Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize(); + int w = 720; + int h = 510; + f.setLocation(screenSize.width / 2 - w / 2, screenSize.height / 2 - h + / 2); + f.setSize(w, h); + f.setVisible(true); + intro.start(); + } + + + /** + * ScenesTable is the list of scenes known to the Director. + * Scene participation, scene name and scene pause amount columns. + * Global animation delay for scene's steps. + */ + static class ScenesTable extends JPanel implements ActionListener, + ChangeListener { + private final Intro intro; + private JTable table; + private TableModel dataModel; + + @SuppressWarnings("LeakingThisInConstructor") + public ScenesTable(final Intro intro) { + this.intro = intro; + + setBackground(WHITE); + setLayout(new BorderLayout()); + final String[] names = { "", "Scenes", "Pause" }; + + dataModel = new AbstractTableModel() { + + @Override + public int getColumnCount() { + return names.length; + } + + @Override + public int getRowCount() { + return intro.surface.director.size(); + } + + @Override + public Object getValueAt(int row, int col) { + Surface.Scene scene = intro.surface.director.get(row); + if (col == 0) { + return scene.participate; + } else if (col == 1) { + return scene.name; + } else { + return scene.pauseAmt; + } + } + + @Override + public String getColumnName(int col) { + return names[col]; + } + + @Override + public Class getColumnClass(int c) { + return getValueAt(0, c).getClass(); + } + + @Override + public boolean isCellEditable(int row, int col) { + return col != 1 ? true : false; + } + + @Override + public void setValueAt(Object aValue, int row, int col) { + Surface.Scene scene = intro.surface.director.get(row); + if (col == 0) { + scene.participate = aValue; + } else if (col == 1) { + scene.name = aValue; + } else { + scene.pauseAmt = aValue; + } + } + }; + + table = new JTable(dataModel); + TableColumn col = table.getColumn(""); + col.setWidth(16); + col.setMinWidth(16); + col.setMaxWidth(20); + col = table.getColumn("Pause"); + col.setWidth(60); + col.setMinWidth(60); + col.setMaxWidth(60); + table.sizeColumnsToFit(0); + + JScrollPane scrollpane = new JScrollPane(table); + add(scrollpane); + + JPanel panel = new JPanel(new BorderLayout()); + JButton b = new JButton("Unselect All"); + b.setHorizontalAlignment(JButton.LEFT); + Font font = new Font(Font.SERIF, Font.PLAIN, 10); + b.setFont(font); + b.addActionListener(this); + panel.add("West", b); + + JSlider slider = new JSlider(JSlider.HORIZONTAL, 0, 200, + (int) intro.surface.sleepAmt); + slider.addChangeListener(this); + TitledBorder tb = new TitledBorder(new EtchedBorder()); + tb.setTitleFont(font); + tb.setTitle("Anim delay = " + String.valueOf(intro.surface.sleepAmt) + + " ms"); + slider.setBorder(tb); + slider.setPreferredSize(new Dimension(140, 40)); + slider.setMinimumSize(new Dimension(100, 40)); + slider.setMaximumSize(new Dimension(180, 40)); + panel.add("East", slider); + + add("South", panel); + } + + @Override + public void actionPerformed(ActionEvent e) { + JButton b = (JButton) e.getSource(); + b.setSelected(!b.isSelected()); + b.setText(b.isSelected() ? "Select All" : "Unselect All"); + for (int i = 0; i < intro.surface.director.size(); i++) { + Surface.Scene scene = intro.surface.director.get(i); + scene.participate = Boolean.valueOf(!b.isSelected()); + } + table.tableChanged(new TableModelEvent(dataModel)); + } + + @Override + public void stateChanged(ChangeEvent e) { + JSlider slider = (JSlider) e.getSource(); + int value = slider.getValue(); + TitledBorder tb = (TitledBorder) slider.getBorder(); + tb.setTitle("Anim delay = " + String.valueOf(value) + " ms"); + intro.surface.sleepAmt = (long) value; + slider.repaint(); + } + } // End ScenesTable class + + + /** + * Surface is the stage where the Director plays its scenes. + */ + static class Surface extends JPanel implements Runnable { + + private final Image dukeanim, duke; + private BufferedImage bimg; + public Director director; + public int index; + public long sleepAmt = 30; + private Thread thread; + + @SuppressWarnings("LeakingThisInConstructor") + public Surface() { + setBackground(myBlack); + setLayout(new BorderLayout()); + addMouseListener(new MouseAdapter() { + + @Override + public void mouseClicked(MouseEvent e) { + if (thread == null) { + start(); + } else { + stop(); + } + } + }); + dukeanim = DemoImages.getImage("duke.running.gif", this); + duke = DemoImages.getImage("duke.png", this); + director = new Director(this); + } + + public FontMetrics getMetrics(Font font) { + return getFontMetrics(font); + } + + @Override + public void paint(Graphics g) { + Dimension d = getSize(); + if (d.width <= 0 || d.height <= 0) { + return; + } + if (bimg == null || bimg.getWidth() != d.width || bimg.getHeight() + != d.height) { + bimg = getGraphicsConfiguration().createCompatibleImage(d.width, + d.height); + // reset future scenes + for (int i = index + 1; i < director.size(); i++) { + (director.get(i)).reset(d.width, d.height); + } + } + + Scene scene = director.get(index); + if (scene.index <= scene.length) { + if (thread != null) { + scene.step(d.width, d.height); + } + + Graphics2D g2 = bimg.createGraphics(); + g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, + RenderingHints.VALUE_ANTIALIAS_ON); + g2.setBackground(getBackground()); + g2.clearRect(0, 0, d.width, d.height); + + scene.render(d.width, d.height, g2); + + if (thread != null) { + // increment scene.index after scene.render + scene.index++; + } + g2.dispose(); + } + g.drawImage(bimg, 0, 0, this); + } + + public void start() { + if (thread == null) { + thread = new Thread(this); + thread.setPriority(Thread.MIN_PRIORITY); + thread.setName("Intro"); + thread.start(); + } + } + + public synchronized void stop() { + if (thread != null) { + thread.interrupt(); + } + thread = null; + notifyAll(); + } + + public void reset() { + index = 0; + Dimension d = getSize(); + for (Scene scene : director) { + scene.reset(d.width, d.height); + } + } + + @Override + @SuppressWarnings("SleepWhileHoldingLock") + public void run() { + + Thread me = Thread.currentThread(); + + while (thread == me && !isShowing() || getSize().width <= 0) { + try { + Thread.sleep(500); + } catch (InterruptedException e) { + return; + } + } + + if (index == 0) { + reset(); + } + + while (thread == me) { + Scene scene = director.get(index); + if (((Boolean) scene.participate).booleanValue()) { + repaint(); + try { + Thread.sleep(sleepAmt); + } catch (InterruptedException e) { + break; + } + if (scene.index > scene.length) { + scene.pause(); + if (++index >= director.size()) { + reset(); + } + } + } else { + if (++index >= director.size()) { + reset(); + } + } + } + thread = null; + } + + + /** + * Part is a piece of the scene. Classes must implement Part + * in order to participate in a scene. + */ + interface Part { + + public void reset(int newwidth, int newheight); + + public void step(int w, int h); + + public void render(int w, int h, Graphics2D g2); + + public int getBegin(); + + public int getEnd(); + } + + + /** + * Director is the holder of the scenes, their names & pause amounts + * between scenes. + */ + static class Director extends ArrayList { + + GradientPaint gp = new GradientPaint(0, 40, myBlue, 38, 2, myBlack); + Font f1 = new Font(Font.SERIF, Font.PLAIN, 200); + Font f2 = new Font(Font.SERIF, Font.PLAIN, 120); + Font f3 = new Font(Font.SERIF, Font.PLAIN, 72); + + public Director(Surface surf) { + Object partsInfo[][][] = { + { { "J - scale text on gradient", "0" }, + { new GpE(GpE.BURI, myBlack, myBlue, 0, 20), + new TxE("J", f1, TxE.SCI, myYellow, 2, 20) } }, + { { "2 - scale & rotate text on gradient", "0" }, + { new GpE(GpE.BURI, myBlue, myBlack, 0, 22), + new TxE("2", f1, TxE.RI | TxE.SCI, myYellow, 2, 22) } }, + { { "D - scale text on gradient", "0" }, + { new GpE(GpE.BURI, myBlack, myBlue, 0, 20), + new TxE("D", f1, TxE.SCI, myYellow, 2, 20) } }, + { { "J2D demo - scale & rotate text on gradient", "1000" }, + { new GpE(GpE.SIH, myBlue, myBlack, 0, 40), + new TxE("J2D demo", f2, TxE.RI | TxE.SCI, myYellow, 0, 40) } }, + { { "Previous scene dither dissolve out", "0" }, + { new DdE(0, 20, 1, surf) } }, + { { "Graphics Features", "999" }, + { new Temp(Temp.RECT, null, 0, 15), + new Temp(Temp.IMG, surf.duke, 2, 15), + new Temp(Temp.RNA | Temp.INA, surf.duke, 16, 130), + new Features(Features.GRAPHICS, 16, 130, surf) } }, + { { "J2D demo - texture text on gradient", "1000" }, + { new GpE(GpE.WI, myBlue, myBlack, 0, 20), + new GpE(GpE.WD, myBlue, myBlack, 21, 40), + new TpE(TpE.OI | TpE.NF, myBlack, myYellow, 4, 0, 10), + new TpE(TpE.OD | TpE.NF, myBlack, myYellow, 4, 11, 20), + new TpE(TpE.OI | TpE.NF | TpE.HAF, myBlack, myYellow, 5, + 21, 40), + new TxE("J2D demo", f2, 0, null, 0, 40) } }, + { { "Previous scene random close out", "0" }, + { new CoE(CoE.RAND, 0, 20, surf) } }, + { { "Text Features", "999" }, + { new Temp(Temp.RECT, null, 0, 15), + new Temp(Temp.IMG, surf.duke, 2, 15), + new Temp(Temp.RNA | Temp.INA, surf.duke, 16, 130), + new Features(Features.TEXT, 16, 130, surf) } }, + { { "J2D demo - composite text on texture", "1000" }, + { new TpE(TpE.RI, myBlack, gp, 40, 0, 20), + new TpE(TpE.RD, myBlack, gp, 40, 21, 40), + new TpE(TpE.RI, myBlack, gp, 40, 41, 60), + new TxE("J2D demo", f2, TxE.AC, myYellow, 0, 60) } }, + { { "Previous scene dither dissolve out", "0" }, + { new DdE(0, 20, 4, surf) } }, + { { "Imaging Features", "999" }, + { new Temp(Temp.RECT, null, 0, 15), + new Temp(Temp.IMG, surf.duke, 2, 15), + new Temp(Temp.RNA | Temp.INA, surf.duke, 16, 130), + new Features(Features.IMAGES, 16, 130, surf) } }, + { { "J2D demo - text on gradient", "1000" }, + { new GpE(GpE.SDH, myBlue, myBlack, 0, 20), + new GpE(GpE.SIH, myBlue, myBlack, 21, 40), + new GpE(GpE.SDH, myBlue, myBlack, 41, 50), + new GpE(GpE.INC | GpE.NF, myRed, myYellow, 0, 50), + new TxE("J2D demo", f2, TxE.NOP, null, 0, 50) } }, + { { "Previous scene ellipse close out", "0" }, + { new CoE(CoE.OVAL, 0, 20, surf) } }, + { { "Color Features", "999" }, + { new Temp(Temp.RECT, null, 0, 15), + new Temp(Temp.IMG, surf.duke, 2, 15), + new Temp(Temp.RNA | Temp.INA, surf.duke, 16, 99), + new Features(Features.COLOR, 16, 99, surf) } }, + { { "J2D demo - composite and rotate text on paints", "2000" }, + { new GpE(GpE.BURI, myBlack, myBlue, 0, 20), + new GpE(GpE.BURD, myBlack, myBlue, 21, 30), + new TpE(TpE.OI | TpE.HAF, myBlack, myBlue, 10, 31, 40), + new TxE("J2D demo", f2, TxE.AC | TxE.RI, myYellow, 0, 40) } }, + { { "Previous scene subimage transform out", "0" }, + { new SiE(60, 60, 0, 40, surf) } }, + { { "CREDITS - transform in", "1000" }, + { new LnE(LnE.ACI | LnE.ZOOMI | LnE.RI, 0, 60), + new TxE("CREDITS", f3, TxE.AC | TxE.SCI, RED, 20, 30), + new TxE("CREDITS", f3, TxE.SCXD, RED, 31, 38), + new TxE("CREDITS", f3, TxE.SCXI, RED, 39, 48), + new TxE("CREDITS", f3, TxE.SCXD, RED, 49, 54), + new TxE("CREDITS", f3, TxE.SCXI, RED, 55, 60) } }, + { { "CREDITS - transform out", "0" }, + { new LnE(LnE.ACD | LnE.ZOOMD | LnE.RD, 0, 45), + new TxE("CREDITS", f3, 0, RED, 0, 9), + new TxE("CREDITS", f3, TxE.SCD | TxE.RD, RED, 10, 30) } }, + { { "Contributors", "1000" }, + { new Temp(Temp.RECT, null, 0, 30), + new Temp(Temp.IMG, surf.dukeanim, 4, 30), + new Temp(Temp.RNA | Temp.INA, surf.dukeanim, 31, 200), + new Contributors(34, 200, surf) } }, }; + + for (Object[][] partInfo : partsInfo) { + List parts = new ArrayList(); + for (Object part : partInfo[1]) { + parts.add((Part) part); + } + add(new Scene(parts, partInfo[0][0], partInfo[0][1])); + } + } + } + + + /** + * Scene is the manager of the parts. + */ + static class Scene extends Object { + + public Object name; + public Object participate = Boolean.TRUE; + public Object pauseAmt; + public List parts; + public int index; + public int length; + + public Scene(List parts, Object name, Object pauseAmt) { + this.name = name; + this.parts = parts; + this.pauseAmt = pauseAmt; + for (Part part : parts) { + int partLength = part.getEnd(); + if (partLength > length) { + length = partLength; + } + } + } + + public void reset(int w, int h) { + index = 0; + for (int i = 0; i < parts.size(); i++) { + (parts.get(i)).reset(w, h); + } + } + + public void step(int w, int h) { + for (int i = 0; i < parts.size(); i++) { + Part part = parts.get(i); + if (index >= part.getBegin() && index <= part.getEnd()) { + part.step(w, h); + } + } + } + + public void render(int w, int h, Graphics2D g2) { + for (int i = 0; i < parts.size(); i++) { + Part part = parts.get(i); + if (index >= part.getBegin() && index <= part.getEnd()) { + part.render(w, h, g2); + } + } + } + + public void pause() { + try { + Thread.sleep(Long.parseLong((String) pauseAmt)); + } catch (Exception ignored) { + } + System.gc(); + } + } // End Scene class + + + /** + * Text Effect. Transformation of characters. Clip or fill. + */ + static final class TxE implements Part { + + static final int INC = 1; + static final int DEC = 2; + static final int R = 4; // rotate + static final int RI = R | INC; + static final int RD = R | DEC; + static final int SC = 8; // scale + static final int SCI = SC | INC; + static final int SCD = SC | DEC; + static final int SCX = 16; // scale invert x + static final int SCXI = SCX | SC | INC; + static final int SCXD = SCX | SC | DEC; + static final int SCY = 32; // scale invert y + static final int SCYI = SCY | SC | INC; + static final int SCYD = SCY | SC | DEC; + static final int AC = 64; // AlphaComposite + static final int CLIP = 128; // Clipping + static final int NOP = 512; // No Paint + private int beginning, ending; + private int type; + private double rIncr, sIncr; + private double sx, sy, rotate; + private Shape shapes[], txShapes[]; + private int sw; + private int numRev; + private Paint paint; + + public TxE(String text, + Font font, + int type, + Paint paint, + int beg, + int end) { + this.type = type; + this.paint = paint; + this.beginning = beg; + this.ending = end; + + setIncrements(2); + + char[] chars = text.toCharArray(); + shapes = new Shape[chars.length]; + txShapes = new Shape[chars.length]; + FontRenderContext frc = new FontRenderContext(null, true, true); + TextLayout tl = new TextLayout(text, font, frc); + sw = (int) tl.getOutline(null).getBounds().getWidth(); + for (int j = 0; j < chars.length; j++) { + String s = String.valueOf(chars[j]); + shapes[j] = new TextLayout(s, font, frc).getOutline(null); + } + } + + public void setIncrements(double numRevolutions) { + this.numRev = (int) numRevolutions; + rIncr = 360.0 / ((ending - beginning) / numRevolutions); + sIncr = 1.0 / (ending - beginning); + if ((type & SCX) != 0 || (type & SCY) != 0) { + sIncr *= 2; + } + if ((type & DEC) != 0) { + rIncr = -rIncr; + sIncr = -sIncr; + } + } + + @Override + public void reset(int w, int h) { + if (type == SCXI) { + sx = -1.0; + sy = 1.0; + } else if (type == SCYI) { + sx = 1.0; + sy = -1.0; + } else { + sx = sy = (type & DEC) != 0 ? 1.0 : 0.0; + } + rotate = 0; + } + + @Override + public void step(int w, int h) { + + float charWidth = w / 2 - sw / 2; + + for (int i = 0; i < shapes.length; i++) { + AffineTransform at = new AffineTransform(); + Rectangle2D maxBounds = shapes[i].getBounds(); + at.translate(charWidth, h / 2 + maxBounds.getHeight() / 2); + charWidth += (float) maxBounds.getWidth() + 1; + Shape shape = at.createTransformedShape(shapes[i]); + Rectangle2D b1 = shape.getBounds2D(); + + if ((type & R) != 0) { + at.rotate(Math.toRadians(rotate)); + } + if ((type & SC) != 0) { + at.scale(sx, sy); + } + shape = at.createTransformedShape(shapes[i]); + Rectangle2D b2 = shape.getBounds2D(); + + double xx = (b1.getX() + b1.getWidth() / 2) + - (b2.getX() + b2.getWidth() / 2); + double yy = (b1.getY() + b1.getHeight() / 2) + - (b2.getY() + b2.getHeight() / 2); + AffineTransform toCenterAT = new AffineTransform(); + toCenterAT.translate(xx, yy); + toCenterAT.concatenate(at); + txShapes[i] = toCenterAT.createTransformedShape(shapes[i]); + } + // avoid over rotation + if (Math.abs(rotate) <= numRev * 360) { + rotate += rIncr; + if ((type & SCX) != 0) { + sx += sIncr; + } else if ((type & SCY) != 0) { + sy += sIncr; + } else { + sx += sIncr; + sy += sIncr; + } + } + } + + @Override + public void render(int w, int h, Graphics2D g2) { + Composite saveAC = null; + if ((type & AC) != 0 && sx > 0 && sx < 1) { + saveAC = g2.getComposite(); + g2.setComposite(AlphaComposite.getInstance( + AlphaComposite.SRC_OVER, (float) sx)); + } + GeneralPath path = null; + if ((type & CLIP) != 0) { + path = new GeneralPath(); + } + if (paint != null) { + g2.setPaint(paint); + } + for (int i = 0; i < txShapes.length; i++) { + if ((type & CLIP) != 0) { + path.append(txShapes[i], false); + } else { + g2.fill(txShapes[i]); + } + } + if ((type & CLIP) != 0) { + g2.clip(path); + } + if (saveAC != null) { + g2.setComposite(saveAC); + } + } + + @Override + public int getBegin() { + return beginning; + } + + @Override + public int getEnd() { + return ending; + } + } // End TxE class + + + /** + * GradientPaint Effect. Burst, split, horizontal and + * vertical gradient fill effects. + */ + static class GpE implements Part { + + static final int INC = 1; // increasing + static final int DEC = 2; // decreasing + static final int CNT = 4; // center + static final int WID = 8; // width + static final int WI = WID | INC; + static final int WD = WID | DEC; + static final int HEI = 16; // height + static final int HI = HEI | INC; + static final int HD = HEI | DEC; + static final int SPL = 32 | CNT; // split + static final int SIW = SPL | INC | WID; + static final int SDW = SPL | DEC | WID; + static final int SIH = SPL | INC | HEI; + static final int SDH = SPL | DEC | HEI; + static final int BUR = 64 | CNT; // burst + static final int BURI = BUR | INC; + static final int BURD = BUR | DEC; + static final int NF = 128; // no fill + private Color c1, c2; + private int beginning, ending; + private float incr, index; + private List rect = new ArrayList(); + private List grad = new ArrayList(); + private int type; + + public GpE(int type, Color c1, Color c2, int beg, int end) { + this.type = type; + this.c1 = c1; + this.c2 = c2; + this.beginning = beg; + this.ending = end; + } + + @Override + public void reset(int w, int h) { + incr = 1.0f / (ending - beginning); + if ((type & CNT) != 0) { + incr /= 2.3f; + } + if ((type & CNT) != 0 && (type & INC) != 0) { + index = 0.5f; + } else if ((type & DEC) != 0) { + index = 1.0f; + incr = -incr; + } else { + index = 0.0f; + } + index += incr; + } + + @Override + public void step(int w, int h) { + rect.clear(); + grad.clear(); + + if ((type & WID) != 0) { + float w2 = 0, x1 = 0, x2 = 0; + if ((type & SPL) != 0) { + w2 = w * 0.5f; + x1 = w * (1.0f - index); + x2 = w * index; + } else { + w2 = w * index; + x1 = x2 = w2; + } + rect.add(new Rectangle2D.Float(0, 0, w2, h)); + rect.add(new Rectangle2D.Float(w2, 0, w - w2, h)); + grad.add(new GradientPaint(0, 0, c1, x1, 0, c2)); + grad.add(new GradientPaint(x2, 0, c2, w, 0, c1)); + } else if ((type & HEI) != 0) { + float h2 = 0, y1 = 0, y2 = 0; + if ((type & SPL) != 0) { + h2 = h * 0.5f; + y1 = h * (1.0f - index); + y2 = h * index; + } else { + h2 = h * index; + y1 = y2 = h2; + } + rect.add(new Rectangle2D.Float(0, 0, w, h2)); + rect.add(new Rectangle2D.Float(0, h2, w, h - h2)); + grad.add(new GradientPaint(0, 0, c1, 0, y1, c2)); + grad.add(new GradientPaint(0, y2, c2, 0, h, c1)); + } else if ((type & BUR) != 0) { + + float w2 = w / 2; + float h2 = h / 2; + + rect.add(new Rectangle2D.Float(0, 0, w2, h2)); + rect.add(new Rectangle2D.Float(w2, 0, w2, h2)); + rect.add(new Rectangle2D.Float(0, h2, w2, h2)); + rect.add(new Rectangle2D.Float(w2, h2, w2, h2)); + + float x1 = w * (1.0f - index); + float x2 = w * index; + float y1 = h * (1.0f - index); + float y2 = h * index; + + grad.add(new GradientPaint(0, 0, c1, x1, y1, c2)); + grad.add(new GradientPaint(w, 0, c1, x2, y1, c2)); + grad.add(new GradientPaint(0, h, c1, x1, y2, c2)); + grad.add(new GradientPaint(w, h, c1, x2, y2, c2)); + } else if ((type & NF) != 0) { + float y = h * index; + grad.add(new GradientPaint(0, 0, c1, 0, y, c2)); + } + + if ((type & INC) != 0 || (type & DEC) != 0) { + index += incr; + } + } + + @Override + public void render(int w, int h, Graphics2D g2) { + g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, + RenderingHints.VALUE_ANTIALIAS_OFF); + for (int i = 0; i < grad.size(); i++) { + g2.setPaint(grad.get(i)); + if ((type & NF) == 0) { + g2.fill(rect.get(i)); + } + } + g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, + RenderingHints.VALUE_ANTIALIAS_ON); + } + + @Override + public int getBegin() { + return beginning; + } + + @Override + public int getEnd() { + return ending; + } + } // End GpE class + + + /** + * TexturePaint Effect. Expand and collapse a texture. + */ + static final class TpE implements Part { + + static final int INC = 1; // increasing + static final int DEC = 2; // decreasing + static final int OVAL = 4; // oval + static final int RECT = 8; // rectangle + static final int HAF = 16; // half oval or rect size + static final int NF = 32; // no fill + static final int OI = OVAL | INC; + static final int OD = OVAL | DEC; + static final int RI = RECT | INC; + static final int RD = RECT | DEC; + private Paint p1, p2; + private int beginning, ending; + private float incr, index; + private TexturePaint texture; + private int type; + private int size; + private BufferedImage bimg; + private Rectangle rect; + + public TpE(int type, Paint p1, Paint p2, int size, + int beg, int end) { + this.type = type; + this.p1 = p1; + this.p2 = p2; + this.beginning = beg; + this.ending = end; + setTextureSize(size); + } + + public void setTextureSize(int size) { + this.size = size; + bimg = new BufferedImage(size, size, BufferedImage.TYPE_INT_RGB); + rect = new Rectangle(0, 0, size, size); + } + + @Override + public void reset(int w, int h) { + incr = (float) (size) / (float) (ending - beginning); + if ((type & HAF) != 0) { + incr /= 2; + } + if ((type & DEC) != 0) { + index = size; + if ((type & HAF) != 0) { + index /= 2; + } + incr = -incr; + } else { + index = 0.0f; + } + index += incr; + } + + @Override + public void step(int w, int h) { + Graphics2D g2 = bimg.createGraphics(); + g2.setPaint(p1); + g2.fillRect(0, 0, size, size); + g2.setPaint(p2); + if ((type & OVAL) != 0) { + g2.fill(new Ellipse2D.Float(0, 0, index, index)); + } else if ((type & RECT) != 0) { + g2.fill(new Rectangle2D.Float(0, 0, index, index)); + } + texture = new TexturePaint(bimg, rect); + g2.dispose(); + index += incr; + } + + @Override + public void render(int w, int h, Graphics2D g2) { + g2.setPaint(texture); + if ((type & NF) == 0) { + g2.fillRect(0, 0, w, h); + } + } + + @Override + public int getBegin() { + return beginning; + } + + @Override + public int getEnd() { + return ending; + } + } // End TpE class + + + /** + * Close out effect. Close out the buffered image with different + * geometry shapes. + */ + static class CoE implements Part { + private final Surface surf; + static final int WID = 1; + static final int HEI = 2; + static final int OVAL = 4; + static final int RECT = 8; + static final int RAND = 16; + static final int ARC = 32; + private int type; + private int beginning, ending; + private BufferedImage bimg; + private Shape shape; + private double zoom, extent; + private double zIncr, eIncr; + private boolean doRandom; + + public CoE(int type, int beg, int end, Surface surf) { + this.type = type; + this.beginning = beg; + this.ending = end; + this.surf = surf; + zIncr = -(2.0 / (ending - beginning)); + eIncr = 360.0 / (ending - beginning); + doRandom = (type & RAND) != 0; + } + + @Override + public void reset(int w, int h) { + if (doRandom) { + int num = (int) (Math.random() * 5.0); + switch (num) { + case 0: + type = OVAL; + break; + case 1: + type = RECT; + break; + case 2: + type = RECT | WID; + break; + case 3: + type = RECT | HEI; + break; + case 4: + type = ARC; + break; + default: + type = OVAL; + } + } + shape = null; + bimg = null; + extent = 360.0; + zoom = 2.0; + } + + @Override + public void step(int w, int h) { + if (bimg == null) { + int biw = surf.bimg.getWidth(); + int bih = surf.bimg.getHeight(); + bimg = new BufferedImage(biw, bih, + BufferedImage.TYPE_INT_RGB); + Graphics2D big = bimg.createGraphics(); + big.drawImage(surf.bimg, 0, 0, null); + } + double z = Math.min(w, h) * zoom; + if ((type & OVAL) != 0) { + shape = new Ellipse2D.Double(w / 2 - z / 2, h / 2 - z / 2, z, + z); + } else if ((type & ARC) != 0) { + shape = new Arc2D.Double(-100, -100, w + 200, h + 200, 90, + extent, Arc2D.PIE); + extent -= eIncr; + } else if ((type & RECT) != 0) { + if ((type & WID) != 0) { + shape = new Rectangle2D.Double(w / 2 - z / 2, 0, z, h); + } else if ((type & HEI) != 0) { + shape = new Rectangle2D.Double(0, h / 2 - z / 2, w, z); + } else { + shape = new Rectangle2D.Double(w / 2 - z / 2, h / 2 - z + / 2, z, z); + } + } + zoom += zIncr; + } + + @Override + public void render(int w, int h, Graphics2D g2) { + g2.clip(shape); + g2.drawImage(bimg, 0, 0, null); + } + + @Override + public int getBegin() { + return beginning; + } + + @Override + public int getEnd() { + return ending; + } + } // End CoE class + + + /** + * Dither Dissolve Effect. For each successive step in the animation, + * a pseudo-random starting horizontal position is chosen using list, + * and then the corresponding points created from xlist and ylist are + * blacked out for the current "chunk". The x and y chunk starting + * positions are each incremented by the associated chunk size, and + * this process is repeated for the number of "steps" in the + * animation, causing an equal number of pseudo-randomly picked + * "blocks" to be blacked out during each step of the animation. + */ + static class DdE implements Part { + private final Surface surf; + private int beginning, ending; + private BufferedImage bimg; + private Graphics2D big; + private List list, xlist, ylist; + private int xeNum, yeNum; // element number + private int xcSize, ycSize; // chunk size + private int inc; + private int blocksize; + + public DdE(int beg, int end, int blocksize, Surface surf) { + this.beginning = beg; + this.ending = end; + this.blocksize = blocksize; + this.surf = surf; + } + + private void createShuffledLists() { + int width = bimg.getWidth(); + int height = bimg.getHeight(); + xlist = new ArrayList(width); + ylist = new ArrayList(height); + list = new ArrayList(ending - beginning + 1); + for (int i = 0; i < width; i++) { + xlist.add(i, i); + } + for (int i = 0; i < height; i++) { + ylist.add(i, i); + } + for (int i = 0; i < (ending - beginning + 1); i++) { + list.add(i, i); + } + java.util.Collections.shuffle(xlist); + java.util.Collections.shuffle(ylist); + java.util.Collections.shuffle(list); + } + + @Override + public void reset(int w, int h) { + bimg = null; + } + + @Override + public void step(int w, int h) { + if (inc > ending) { + bimg = null; + } + if (bimg == null) { + int biw = surf.bimg.getWidth(); + int bih = surf.bimg.getHeight(); + bimg = new BufferedImage(biw, bih, + BufferedImage.TYPE_INT_RGB); + createShuffledLists(); + big = bimg.createGraphics(); + big.drawImage(surf.bimg, 0, 0, null); + xcSize = (xlist.size() / (ending - beginning)) + 1; + ycSize = (ylist.size() / (ending - beginning)) + 1; + xeNum = 0; + inc = 0; + } + xeNum = xcSize * (list.get(inc)).intValue(); + yeNum = -ycSize; + inc++; + } + + @Override + public void render(int w, int h, Graphics2D g2) { + big.setColor(myBlack); + + for (int k = 0; k <= (ending - beginning); k++) { + if ((xeNum + xcSize) > xlist.size()) { + xeNum = 0; + } else { + xeNum += xcSize; + } + yeNum += ycSize; + + for (int i = xeNum; i < xeNum + xcSize && i < xlist.size(); + i++) { + for (int j = yeNum; j < yeNum + ycSize && j + < ylist.size(); j++) { + int xval = (xlist.get(i)).intValue(); + int yval = (ylist.get(j)).intValue(); + if (((xval % blocksize) == 0) && ((yval % blocksize) + == 0)) { + big.fillRect(xval, yval, blocksize, blocksize); + } + } + } + } + + g2.drawImage(bimg, 0, 0, null); + } + + @Override + public int getBegin() { + return beginning; + } + + @Override + public int getEnd() { + return ending; + } + } // End DdE class + + + /** + * Subimage effect. Subimage the scene's buffered + * image then rotate and scale down the subimages. + */ + static class SiE implements Part { + private final Surface surf; + private int beginning, ending; + private BufferedImage bimg; + private double rIncr, sIncr; + private double scale, rotate; + private int siw, sih; + private List subs = new ArrayList(20); + private List pts = new ArrayList(20); + + public SiE(int siw, int sih, int beg, int end, Surface surf) { + this.siw = siw; + this.sih = sih; + this.beginning = beg; + this.ending = end; + this.surf = surf; + rIncr = 360.0 / (ending - beginning); + sIncr = 1.0 / (ending - beginning); + } + + @Override + public void reset(int w, int h) { + scale = 1.0; + rotate = 0.0; + bimg = null; + subs.clear(); + pts.clear(); + } + + @Override + public void step(int w, int h) { + if (bimg == null) { + int biw = surf.bimg.getWidth(); + int bih = surf.bimg.getHeight(); + bimg = new BufferedImage(biw, bih, + BufferedImage.TYPE_INT_RGB); + Graphics2D big = bimg.createGraphics(); + big.drawImage(surf.bimg, 0, 0, null); + for (int x = 0; x < w && scale > 0.0; x += siw) { + int ww = x + siw < w ? siw : w - x; + for (int y = 0; y < h; y += sih) { + int hh = y + sih < h ? sih : h - y; + subs.add(bimg.getSubimage(x, y, ww, hh)); + pts.add(new Point(x, y)); + } + } + } + + rotate += rIncr; + scale -= sIncr; + } + + @Override + public void render(int w, int h, Graphics2D g2) { + AffineTransform saveTx = g2.getTransform(); + g2.setColor(myBlue); + for (int i = 0; i < subs.size() && scale > 0.0; i++) { + BufferedImage bi = subs.get(i); + Point p = pts.get(i); + int ww = bi.getWidth(); + int hh = bi.getHeight(); + AffineTransform at = new AffineTransform(); + at.rotate(Math.toRadians(rotate), p.x + ww / 2, p.y + hh / 2); + at.translate(p.x, p.y); + at.scale(scale, scale); + + Rectangle b1 = new Rectangle(0, 0, ww, hh); + Shape shape = at.createTransformedShape(b1); + Rectangle2D b2 = shape.getBounds2D(); + double xx = (p.x + ww / 2) - (b2.getX() + b2.getWidth() / 2); + double yy = (p.y + hh / 2) + - (b2.getY() + b2.getHeight() / 2); + AffineTransform toCenterAT = new AffineTransform(); + toCenterAT.translate(xx, yy); + toCenterAT.concatenate(at); + + g2.setTransform(toCenterAT); + g2.drawImage(bi, 0, 0, null); + g2.draw(b1); + } + g2.setTransform(saveTx); + } + + @Override + public int getBegin() { + return beginning; + } + + @Override + public int getEnd() { + return ending; + } + } // End SiE class + + + /** + * Line Effect. Flattened ellipse with lines from the center + * to the edge. Expand or collapse the ellipse. Fade in or out + * the lines. + */ + static class LnE implements Part { + + static final int INC = 1; + static final int DEC = 2; + static final int R = 4; // rotate + static final int ZOOM = 8; // zoom + static final int AC = 32; // AlphaComposite + static final int RI = R | INC; + static final int RD = R | DEC; + static final int ZOOMI = ZOOM | INC; + static final int ZOOMD = ZOOM | DEC; + static final int ACI = AC | INC; + static final int ACD = AC | DEC; + private int beginning, ending; + private double rIncr, rotate; + private double zIncr, zoom; + private List pts = new ArrayList(); + private float alpha, aIncr; + private int type; + + public LnE(int type, int beg, int end) { + this.type = type; + this.beginning = beg; + this.ending = end; + float range = ending - beginning; + rIncr = 360.0f / range; + aIncr = 0.9f / range; + zIncr = 2.0f / range; + if ((type & DEC) != 0) { + rIncr = -rIncr; + aIncr = -aIncr; + zIncr = -zIncr; + } + } + + public void generatePts(int w, int h, double sizeF) { + pts.clear(); + double size = Math.min(w, h) * sizeF; + Ellipse2D ellipse = new Ellipse2D.Double(w / 2 - size / 2, h / 2 - size + / 2, size, size); + PathIterator pi = ellipse.getPathIterator(null, 0.8); + while (!pi.isDone()) { + double[] pt = new double[6]; + switch (pi.currentSegment(pt)) { + case FlatteningPathIterator.SEG_MOVETO: + case FlatteningPathIterator.SEG_LINETO: + pts.add(new Point2D.Double(pt[0], pt[1])); + } + pi.next(); + } + } + + @Override + public void reset(int w, int h) { + if ((type & DEC) != 0) { + rotate = 360; + alpha = 1.0f; + zoom = 2.0; + } else { + rotate = alpha = 0; + zoom = 0; + } + if ((type & ZOOM) == 0) { + generatePts(w, h, 0.5); + } + } + + @Override + public void step(int w, int h) { + if ((type & ZOOM) != 0) { + generatePts(w, h, zoom += zIncr); + } + if ((type & RI) != 0 || (type & RI) != 0) { + rotate += rIncr; + } + if ((type & ACI) != 0 || (type & ACD) != 0) { + alpha += aIncr; + } + } + + @Override + public void render(int w, int h, Graphics2D g2) { + Composite saveAC = null; + if ((type & AC) != 0 && alpha >= 0 && alpha <= 1) { + saveAC = g2.getComposite(); + g2.setComposite(AlphaComposite.getInstance( + AlphaComposite.SRC_OVER, alpha)); + } + AffineTransform saveTx = null; + if ((type & R) != 0) { + saveTx = g2.getTransform(); + AffineTransform at = new AffineTransform(); + at.rotate(Math.toRadians(rotate), w / 2, h / 2); + g2.setTransform(at); + } + Point2D p1 = new Point2D.Double(w / 2, h / 2); + g2.setColor(YELLOW); + for (Point2D pt : pts) { + g2.draw(new Line2D.Float(p1, pt)); + } + if (saveTx != null) { + g2.setTransform(saveTx); + } + if (saveAC != null) { + g2.setComposite(saveAC); + } + } + + @Override + public int getBegin() { + return beginning; + } + + @Override + public int getEnd() { + return ending; + } + } // End LnE class + + + /** + * Template for Features & Contributors consisting of translating + * blue and red rectangles and an image going from transparent to + * opaque. + */ + static class Temp implements Part { + + static final int NOANIM = 1; + static final int RECT = 2; + static final int IMG = 4; + static final int RNA = RECT | NOANIM; + static final int INA = IMG | NOANIM; + private int beginning, ending; + private float alpha, aIncr; + private int type; + private Rectangle rect1, rect2; + private int x, y, xIncr, yIncr; + private Image img; + + public Temp(int type, Image img, int beg, int end) { + this.type = type; + this.img = img; + this.beginning = beg; + this.ending = end; + aIncr = 0.9f / (ending - beginning); + if ((type & NOANIM) != 0) { + alpha = 1.0f; + } + } + + @Override + public void reset(int w, int h) { + rect1 = new Rectangle(8, 20, w - 20, 30); + rect2 = new Rectangle(20, 8, 30, h - 20); + if ((type & NOANIM) == 0) { + alpha = 0.0f; + xIncr = w / (ending - beginning); + yIncr = h / (ending - beginning); + x = w + (int) (xIncr * 1.4); + y = h + (int) (yIncr * 1.4); + } + } + + @Override + public void step(int w, int h) { + if ((type & NOANIM) != 0) { + return; + } + if ((type & RECT) != 0) { + rect1.setLocation(x -= xIncr, 20); + rect2.setLocation(20, y -= yIncr); + } + if ((type & IMG) != 0) { + alpha += aIncr; + } + } + + @Override + public void render(int w, int h, Graphics2D g2) { + if ((type & RECT) != 0) { + g2.setColor(myBlue); + g2.fill(rect1); + g2.setColor(myRed); + g2.fill(rect2); + } + if ((type & IMG) != 0) { + Composite saveAC = g2.getComposite(); + if (alpha >= 0 && alpha <= 1) { + g2.setComposite(AlphaComposite.getInstance( + AlphaComposite.SRC_OVER, alpha)); + } + g2.drawImage(img, 30, 30, null); + g2.setComposite(saveAC); + } + } + + @Override + public int getBegin() { + return beginning; + } + + @Override + public int getEnd() { + return ending; + } + } // End Temp class + + + /** + * Features of Java2D(TM). Single character advancement effect. + */ + static class Features implements Part { + + static final int GRAPHICS = 0; + static final int TEXT = 1; + static final int IMAGES = 2; + static final int COLOR = 3; + static final Font font1 = new Font(Font.SERIF, Font.BOLD, 38); + static final Font font2 = new Font(Font.SERIF, Font.PLAIN, 24); + private final FontMetrics fm1; + private final FontMetrics fm2; + private static final String table[][] = { { "Graphics", "Antialiased rendering", + "Bezier paths", + "Transforms", "Compositing", "Stroking parameters" }, + { "Text", "Extended font support", + "Advanced text layout", "Dynamic font loading", + "AttributeSets for font customization" }, + { "Images", "Flexible image layouts", + "Extended imaging operations", + " Convolutions, Lookup Tables", + "RenderableImage interface" }, + { "Color", "ICC profile support", "Color conversion", + "Arbitrary color spaces" } }; + private String list[]; + private int beginning, ending; + private int strH; + private int endIndex, listIndex; + private List v = new ArrayList(); + + public Features(int type, int beg, int end, Surface surf) { + list = table[type]; + this.beginning = beg; + this.ending = end; + fm1 = surf.getMetrics(font1); + fm2 = surf.getMetrics(font2); + } + + @Override + public void reset(int w, int h) { + strH = (fm2.getAscent() + fm2.getDescent()); + endIndex = 1; + listIndex = 0; + v.clear(); + v.add(list[listIndex].substring(0, endIndex)); + } + + @Override + public void step(int w, int h) { + if (listIndex < list.length) { + if (++endIndex > list[listIndex].length()) { + if (++listIndex < list.length) { + endIndex = 1; + v.add(list[listIndex].substring(0, endIndex)); + } + } else { + v.set(listIndex, list[listIndex].substring(0, endIndex)); + } + } + } + + @Override + public void render(int w, int h, Graphics2D g2) { + g2.setColor(myWhite); + g2.setFont(font1); + g2.drawString(v.get(0), 90, 85); + g2.setFont(font2); + for (int i = 1, y = 90; i < v.size(); i++) { + g2.drawString(v.get(i), 120, y += strH); + } + } + + @Override + public int getBegin() { + return beginning; + } + + @Override + public int getEnd() { + return ending; + } + } // End Features class + + + /** + * Scrolling text of Java2D(TM) contributors. + */ + static class Contributors implements Part { + + private static final String members[] = { + "Brian Lichtenwalter", "Jeannette Hung", + "Thanh Nguyen", "Jim Graham", "Jerry Evans", + "John Raley", "Michael Peirce", "Robert Kim", + "Jennifer Ball", "Deborah Adair", "Paul Charlton", + "Dmitry Feld", "Gregory Stone", "Richard Blanchard", + "Link Perry", "Phil Race", "Vincent Hardy", + "Parry Kejriwal", "Doug Felt", "Rekha Rangarajan", + "Paula Patel", "Michael Bundschuh", "Joe Warzecha", + "Joey Beheler", "Aastha Bhardwaj", "Daniel Rice", + "Chris Campbell", "Shinsuke Fukuda", "Dmitri Trembovetski", + "Chet Haase", "Jennifer Godinez", "Nicholas Talian", + "Raul Vera", "Ankit Patel", "Ilya Bagrak", + "Praveen Mohan", "Rakesh Menon" + }; + private static final Font font = new Font(Font.SERIF, Font.PLAIN, 26); + private final FontMetrics fm; + private int beginning, ending; + private int nStrs, strH, index, yh, height; + private List v = new ArrayList(); + private List cast = + new ArrayList(members.length + 3); + private int counter, cntMod; + private GradientPaint gp; + + public Contributors(int beg, int end, Surface surf) { + this.beginning = beg; + this.ending = end; + fm = surf.getMetrics(font); + java.util.Arrays.sort(members); + cast.add("CONTRIBUTORS"); + cast.add(" "); + cast.addAll(Arrays.asList(members)); + cast.add(" "); + cast.add(" "); + cntMod = (ending - beginning) / cast.size() - 1; + } + + @Override + public void reset(int w, int h) { + v.clear(); + strH = (fm.getAscent() + fm.getDescent()); + nStrs = (h - 40) / strH + 1; + height = strH * (nStrs - 1) + 48; + index = 0; + gp = new GradientPaint(0, h / 2, WHITE, 0, h + 20, BLACK); + counter = 0; + } + + @Override + public void step(int w, int h) { + if (counter++ % cntMod == 0) { + if (index < cast.size()) { + v.add(cast.get(index)); + } + if ((v.size() == nStrs || index >= cast.size()) && !v. + isEmpty()) { + v.remove(0); + } + ++index; + } + } + + @Override + public void render(int w, int h, Graphics2D g2) { + g2.setPaint(gp); + g2.setFont(font); + double remainder = counter % cntMod; + double incr = 1.0 - remainder / cntMod; + incr = incr == 1.0 ? 0 : incr; + int y = (int) (incr * strH); + + if (index >= cast.size()) { + y = yh + y; + } else { + y = yh = height - v.size() * strH + y; + } + for (String s : v) { + g2.drawString(s, w / 2 - fm.stringWidth(s) / 2, y += strH); + } + } + + @Override + public int getBegin() { + return beginning; + } + + @Override + public int getEnd() { + return ending; + } + } // End Contributors class + } // End Surface class +} // End Intro class +