--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/demo/share/jfc/J2Ddemo/java2d/Intro.java Mon May 14 08:58:32 2018 -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<Scene> {
+
+ 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<Part> parts = new ArrayList<Part>();
+ 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<Part> parts;
+ public int index;
+ public int length;
+
+ public Scene(List<Part> 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<Rectangle2D> rect = new ArrayList<Rectangle2D>();
+ private List<GradientPaint> grad = new ArrayList<GradientPaint>();
+ 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<Integer> 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<Integer>(width);
+ ylist = new ArrayList<Integer>(height);
+ list = new ArrayList<Integer>(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<BufferedImage> subs = new ArrayList<BufferedImage>(20);
+ private List<Point> pts = new ArrayList<Point>(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<Point2D.Double> pts = new ArrayList<Point2D.Double>();
+ 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<String> v = new ArrayList<String>();
+
+ 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<String> v = new ArrayList<String>();
+ private List<String> cast =
+ new ArrayList<String>(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
+