Category

Development Platform
Home > SourceCode/Document > Graph program > 2D Graphic > View Code
Intro.java
Package: Java2D.rar　[view]
Upload User: cdlibang
Upload Date: 2016-07-17
Package Size: 774k
Code Size: 58k
Category:

2D Graphic

Development Platform:

Java

Intro.java：Code Content
  1. /*
  2.  * @(#)Intro.java 1.6 99/08/16
  3.  *
  4.  * Copyright (c) 1998, 1999 by Sun Microsystems, Inc. All Rights Reserved.
  5.  * 
  6.  * Sun grants you ("Licensee") a non-exclusive, royalty free, license to use,
  7.  * modify and redistribute this software in source and binary code form,
  8.  * provided that i) this copyright notice and license appear on all copies of
  9.  * the software; and ii) Licensee does not utilize the software in a manner
  10.  * which is disparaging to Sun.
  11.  * 
  12.  * This software is provided "AS IS," without a warranty of any kind. ALL
  13.  * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES, INCLUDING ANY
  14.  * IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR
  15.  * NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN AND ITS LICENSORS SHALL NOT BE
  16.  * LIABLE FOR ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING
  17.  * OR DISTRIBUTING THE SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR ITS
  18.  * LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR DIRECT,
  19.  * INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE DAMAGES, HOWEVER
  20.  * CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY, ARISING OUT OF THE USE OF
  21.  * OR INABILITY TO USE SOFTWARE, EVEN IF SUN HAS BEEN ADVISED OF THE
  22.  * POSSIBILITY OF SUCH DAMAGES.
  23.  * 
  24.  * This software is not designed or intended for use in on-line control of
  25.  * aircraft, air traffic, aircraft navigation or aircraft communications; or in
  26.  * the design, construction, operation or maintenance of any nuclear
  27.  * facility. Licensee represents and warrants that it will not use or
  28.  * redistribute the Software for such purposes.
  29.  */
  32. import java.awt.*;
  33. import java.awt.event.*;
  34. import java.awt.geom.*;
  35. import java.awt.image.BufferedImage;
  36. import java.awt.image.DataBuffer;
  37. import java.awt.font.*;
  38. import javax.swing.*;
  39. import javax.swing.border.*;
  40. import javax.swing.table.*;
  41. import javax.swing.event.*;
  42. import java.util.Vector;
  43. import java.util.List;
  44. import java.util.Arrays;
  48. /**
  49.  * Introduction to the Java2Demo.  
  50.  *
  51.  * @version @(#)Intro.java 1.6 99/08/16
  52.  * @author Brian Lichtenwalter
  53.  */
  54. public class Intro extends JPanel {
  56.     static Color black = new Color(20, 20, 20); 
  57.     static Color white = new Color(240, 240, 255); 
  58.     static Color red = new Color(149, 43, 42);
  59.     static Color blue = new Color(94, 105, 176); 
  60.     static Color yellow = new Color(255, 255, 140);
  62.     static Surface surface;
  63.     private ScenesTable scenesTable;
  64.     private boolean doTable;
  67.     public Intro() {
  68.         EmptyBorder eb = new EmptyBorder(80,110,80,110);
  69.         BevelBorder bb = new BevelBorder(BevelBorder.LOWERED);
  70.         setBorder(new CompoundBorder(eb,bb));
  71.         setLayout(new BorderLayout());
  72.         setBackground(Color.gray);
  73.         setToolTipText("click for scene table");
  74.         add(surface = new Surface());
  75.         addMouseListener(new MouseAdapter() {
  76.             public void mouseClicked(MouseEvent e) {
  77.                removeAll();
  78.                if ((doTable = !doTable)) {
  79.                    setToolTipText("click for animation");
  80.                    surface.stop();
  81.                    if (scenesTable == null) {
  82.                        scenesTable = new ScenesTable();
  83.                    }
  84.                    add(scenesTable);
  85.                } else {
  86.                    setToolTipText("click for scene table");
  87.                    surface.start();
  88.                    add(surface);
  89.                }
  90.                revalidate();
  91.                repaint();
  92.             }
  93.         });
  94.     }
  97.     public void start() {
  98.         if (!doTable) {
  99.             surface.start();
  100.         }
  101.     }
  104.     public void stop() {
  105.         if (!doTable) {
  106.            surface.stop();
  107.         }
  108.     }
  111.     public static void main(String argv[]) {
  112.         final Intro intro = new Intro();
  113.         WindowListener l = new WindowAdapter() {
  114.             public void windowClosing(WindowEvent e) {System.exit(0);}
  115.             public void windowDeiconified(WindowEvent e) { intro.start(); }
  116.             public void windowIconified(WindowEvent e) { intro.stop(); }
  117.         };
  118.         JFrame f = new JFrame("Java2D Demo - Intro");
  119.         f.addWindowListener(l);
  120.         f.getContentPane().add("Center", intro);
  121.         f.pack();
  122.         Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
  123.         int w = 720;
  124.         int h = 510;
  125.         f.setLocation(screenSize.width/2 - w/2, screenSize.height/2 - h/2);
  126.         f.setSize(w, h);
  127.         f.show();
  128.         intro.start();
  129.     }
  132.     /**
  133.      * ScenesTable is the list of scenes known to the Director.
  134.      * Scene participation, scene name and scene pause amount columns.
  135.      * Global animation delay for scene's steps.
  136.      */
  137.     static class ScenesTable extends JPanel implements ActionListener, ChangeListener {
  139.         private JTable table;
  140.         private TableModel dataModel;
  142.         public ScenesTable() {
  143.             setBackground(Color.white);
  144.             setLayout(new BorderLayout());
  145.             final String[] names = { "", "Scenes", "Pause" };
  146.     
  147.             dataModel = new AbstractTableModel() {
  148.                 public int getColumnCount() { return names.length; }
  149.                 public int getRowCount() { return surface.director.size();}
  150.                 public Object getValueAt(int row, int col) { 
  151.                     Surface.Scene scene = (Surface.Scene) surface.director.get(row); 
  152.                     if (col == 0) {
  153.                         return scene.participate;
  154.                     } else if (col == 1) {
  155.                         return scene.name;
  156.                     } else { 
  157.                         return scene.pauseAmt;
  158.                    }
  159.                 }
  160.                 public String getColumnName(int col) {return names[col]; }
  161.                 public Class getColumnClass(int c) {
  162.                     return getValueAt(0, c).getClass();
  163.                 }
  164.                 public boolean isCellEditable(int row, int col) {
  165.                     return col != 1 ? true : false;
  166.                 }
  167.                 public void setValueAt(Object aValue, int row, int col) {
  168.                     Surface.Scene scene = (Surface.Scene) surface.director.get(row); 
  169.                     if (col == 0) {
  170.                         scene.participate = aValue;
  171.                     } else if (col == 1) {
  172.                         scene.name = aValue;
  173.                     } else { 
  174.                         scene.pauseAmt = aValue;
  175.                     }
  176.                 }
  177.             };
  178.     
  179.             table = new JTable(dataModel);
  180.             TableColumn col = table.getColumn("");
  181.             col.setWidth(16);
  182.             col.setMinWidth(16);
  183.             col.setMaxWidth(20);
  184.             col = table.getColumn("Pause");
  185.             col.setWidth(60);
  186.             col.setMinWidth(60);
  187.             col.setMaxWidth(60);
  188.             table.sizeColumnsToFit(0);
  189.         
  190.             JScrollPane scrollpane = new JScrollPane(table);
  191.             add(scrollpane);
  192.  
  193.             JPanel panel = new JPanel(new BorderLayout());
  194.             JButton b = new JButton("Unselect All");
  195.             b.setHorizontalAlignment(JButton.LEFT);
  196.             Font font = new Font("serif", Font.PLAIN, 10);
  197.             b.setFont(font);
  198.             b.addActionListener(this);
  199.             panel.add("West", b);
  201.             JSlider slider = new JSlider(JSlider.HORIZONTAL, 0, 200, (int) surface.sleepAmt);
  202.             slider.addChangeListener(this);
  203.             TitledBorder tb = new TitledBorder(new EtchedBorder());
  204.             tb.setTitleFont(font);
  205.             tb.setTitle("Anim delay = " + String.valueOf(surface.sleepAmt) + " ms");
  206.             slider.setBorder(tb);
  207.             slider.setPreferredSize(new Dimension(140,40));
  208.             slider.setMinimumSize(new Dimension(100,40));
  209.             slider.setMaximumSize(new Dimension(180,40));
  210.             panel.add("East", slider);
  212.             add("South", panel);
  213.         }
  216.         public void actionPerformed(ActionEvent e) {
  217.             JButton b = (JButton) e.getSource();
  218.             b.setSelected(!b.isSelected());
  219.             b.setText(b.isSelected() ? "Select All" : "Unselect All");
  220.             for (int i = 0; i < surface.director.size(); i++) {
  221.                 Surface.Scene scene = (Surface.Scene) surface.director.get(i); 
  222.                 scene.participate = new Boolean(!b.isSelected());
  223.             }
  224.     table.tableChanged(new TableModelEvent(dataModel));
  225.         }
  228.         public void stateChanged(ChangeEvent e) {
  229.             JSlider slider = (JSlider) e.getSource();
  230.             int value = slider.getValue();
  231.             TitledBorder tb = (TitledBorder) slider.getBorder();
  232.             tb.setTitle("Anim delay = " + String.valueOf(value) + " ms");
  233.             surface.sleepAmt = (long) value;
  234.             slider.repaint();
  235.         }
  236.     }  // End ScenesTable class
  240.     /**
  241.      * Surface is the stage where the Director plays its scenes.
  242.      */
  243.     static class Surface extends JPanel implements Runnable {
  245.         static Surface surf;
  246.         static Image cupanim, java_logo;
  247.         static BufferedImage bimg;
  248.         static List list;                  // a cache for DdE part 
  249.         public Director director;
  250.         public int index;
  251.         public long sleepAmt = 30;
  252.         private Thread thread;
  255.         public Surface() {
  256.             surf = this;
  257.             setBackground(black);
  258.             setLayout(new BorderLayout());
  259.             addMouseListener(new MouseAdapter() {
  260.                 public void mouseClicked(MouseEvent e) {
  261.                     if (thread == null) start(); else stop();
  262.                 }
  263.             });
  264.             cupanim = DemoImages.getImage("cupanim.gif", this);
  265.             java_logo = DemoImages.getImage("java_logo.gif", this);
  266.             director = new Director();
  267.         }
  270.         static FontMetrics getMetrics(Font font) {
  271.             return surf.getFontMetrics(font);
  272.         }
  275.         public void paint(Graphics g) {
  276.             Dimension d = getSize();
  277.             if (bimg == null || bimg.getWidth() != d.width || bimg.getHeight() != d.height) {
  278.                 bimg = (BufferedImage) createImage(d.width, d.height);  
  279.                 // reset future scenes
  280.                 for (int i = index+1; i < director.size(); i++) {
  281.                     ((Scene) director.get(i)).reset(d.width, d.height);
  282.                 }
  283.                 createShuffledList();
  284.             }
  286.             Scene scene = (Scene) director.get(index);
  287.             if (scene.index <= scene.length) {
  288.                 if (thread != null) {
  289.                     scene.step(d.width, d.height);
  290.                 }
  292.                 Graphics2D g2 = bimg.createGraphics();
  293.                 g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, 
  294.                                     RenderingHints.VALUE_ANTIALIAS_ON);
  295.                 g2.setBackground(getBackground());
  296.                 g2.clearRect(0, 0, d.width, d.height);
  297.     
  298.                 scene.render(d.width, d.height, g2);
  300.                 if (thread != null) {
  301.                     // increment scene.index after scene.render
  302.                     scene.index++;      
  303.                 }
  304.                 g2.dispose();
  305.             }
  306.             g.drawImage(bimg, 0, 0, this);
  307.         }
  311.         public void start() {
  312.             if (thread == null) {
  313.                 thread = new Thread(this);
  314.                 thread.setPriority(Thread.MIN_PRIORITY);
  315.                 thread.setName("Intro");
  316.                 thread.start();
  317.             }
  318.         }
  319.     
  321.         public synchronized void stop() {
  322.             if (thread != null) {
  323.                 thread.interrupt();
  324.             }
  325.             thread = null;
  326.             notifyAll();
  327.         }
  330.         public void reset() {
  331.             index = 0;
  332.             Dimension d = getSize();
  333.             for (int i = 0; i < director.size(); i++) {
  334.                 ((Scene) director.get(i)).reset(d.width, d.height);
  335.             }
  336.         }
  337.       
  339.         /**
  340.          * create a shuffled list for the DdE part - Dither Dissolve Effect
  341.          */
  342.         private void createShuffledList() {
  343.             int size = bimg.getRaster().getDataBuffer().getSize();
  344.             Integer array[] = new Integer[size];
  345.             for (int j = 0; j < array.length; j++) {
  346.                  array[j] = new Integer(j);
  347.             }
  348.             java.util.Collections.shuffle(list = Arrays.asList(array));
  349.         }
  351.     
  352.         public void run() {
  354.             Thread me = Thread.currentThread();
  356.             while (thread == me && !isShowing() || getSize().width <= 0) {
  357.                 try {
  358.                     thread.sleep(500);
  359.                 } catch (InterruptedException e) { return; }
  360.             }
  362.             if (index == 0) {
  363.                 reset();
  364.             }
  366.             while (thread == me) {
  367.                 Scene scene = (Scene) director.get(index);
  368.                 if (((Boolean) scene.participate).booleanValue()) {
  369.                     repaint();
  370.                     try {
  371.                         thread.sleep(sleepAmt);
  372.                     } catch (InterruptedException e) { break; }
  373.                     if (scene.index > scene.length) {
  374.                         scene.pause(thread);
  375.                         if (++index >= director.size()) {
  376.                             reset();
  377.                         }
  378.                     }
  379.                 } else {
  380.                    if (++index >= director.size()) {
  381.                         reset();
  382.                    }
  383.                 }
  384.             }
  385.             thread = null;
  386.         }
  390.         /**
  391.          * Part is a piece of the scene.  Classes must implement Part
  392.          * inorder to participate in a scene.
  393.          */
  394.         interface Part {
  395.             public void reset(int newwidth, int newheight);
  396.             public void step(int w, int h);
  397.             public void render(int w, int h, Graphics2D g2);
  398.             public int getBegin();
  399.             public int getEnd();
  400.         }
  404.         /**
  405.          * Director is the holder of the scenes, their names & pause amounts
  406.          * between scenes.
  407.          */
  408.         static class Director extends Vector {
  410.             GradientPaint gp = new GradientPaint(0,40,blue,38,2,black);
  411.             Font f1 = new Font("serif", Font.PLAIN, 200);
  412.             Font f2 = new Font("serif", Font.PLAIN, 120);
  413.             Font f3 = new Font("serif", Font.PLAIN, 72);
  414.             Object parts[][][] = {
  415.                { { "J  -  scale text on gradient", "0" },
  416.                  { new GpE(GpE.BURI, black, blue, 0, 20),
  417.                    new TxE("J", f1, TxE.SCI, yellow, 2, 20) } },
  418.                { { "2  -  scale & rotate text on gradient" , "0" },
  419.                  { new GpE(GpE.BURI, blue, black, 0, 22),
  420.                    new TxE("2", f1, TxE.RI | TxE.SCI, yellow, 2, 22) } },
  421.                { { "D  -  scale text on gradient", "0" },
  422.                  { new GpE(GpE.BURI, black, blue, 0, 20),
  423.                    new TxE("D", f1, TxE.SCI, yellow, 2, 20) } },
  424.                { { "Java2D  -  scale & rotate text on gradient", "1000" },
  425.                  { new GpE(GpE.SIH, blue, black, 0, 40),
  426.                    new TxE("Java2D", f2, TxE.RI | TxE.SCI, yellow, 0, 40) }},
  427.                { { "Previous scene dither dissolve out", "0"},
  428.                  { new DdE(0, 20) }},
  429.                { { "Graphics Features", "999" },
  430.                  { new Temp(Temp.RECT, null, 0, 15),
  431.                    new Temp(Temp.IMG, java_logo, 2, 15),
  432.                    new Temp(Temp.RNA | Temp.INA, java_logo, 16, 130),
  433.                    new Features(Features.GRAPHICS, 16, 130) }},
  434.                { { "Java2D  -  texture text on gradient", "1000"},
  435.                  { new GpE(GpE.WI, blue, black, 0, 20),
  436.                    new GpE(GpE.WD, blue, black, 21, 40),
  437.                    new TpE(TpE.OI | TpE.NF, black, yellow, 4, 0, 10),
  438.                    new TpE(TpE.OD | TpE.NF, black, yellow, 4, 11, 20),
  439.                    new TpE(TpE.OI | TpE.NF | TpE.HAF, black, yellow,5,21,40),
  440.                    new TxE("Java2D", f2, 0, null, 0, 40) }},
  441.                { { "Previous scene random close out", "0"},
  442.                  { new CoE(CoE.RAND, 0, 20) } },
  443.                { { "Text Features", "999" },
  444.                  { new Temp(Temp.RECT, null, 0, 15),
  445.                    new Temp(Temp.IMG, java_logo, 2, 15),
  446.                    new Temp(Temp.RNA | Temp.INA, java_logo, 16, 130),
  447.                    new Features(Features.TEXT, 16, 130) }},
  448.                { { "Java2D  -  composite text on texture", "1000"},
  449.                  { new TpE(TpE.RI, black, gp, 40, 0, 20),
  450.                    new TpE(TpE.RD, black, gp, 40, 21, 40),
  451.                    new TpE(TpE.RI, black, gp, 40, 41, 60),
  452.                    new TxE("Java2D", f2, TxE.AC, yellow, 0, 60) }},
  453.                { { "Previous scene dither dissolve out", "0"},
  454.                  { new DdE(0, 20) }},
  455.                { { "Imaging Features", "999" },
  456.                  { new Temp(Temp.RECT, null, 0, 15),
  457.                    new Temp(Temp.IMG, java_logo, 2, 15),
  458.                    new Temp(Temp.RNA | Temp.INA, java_logo, 16, 130),
  459.                    new Features(Features.IMAGES, 16, 130) }},
  460.                { { "Java2D  -  text on gradient", "1000" },
  461.                  { new GpE(GpE.SDH, blue, black, 0, 20),
  462.                    new GpE(GpE.SIH, blue, black, 21, 40),
  463.                    new GpE(GpE.SDH, blue, black, 41, 50),
  464.                    new GpE(GpE.INC | GpE.NF, red, yellow, 0, 50),
  465.                    new TxE("Java2D", f2, TxE.NOP, null, 0, 50) }},
  466.                { { "Previous scene ellipse close out", "0"},
  467.                  { new CoE(CoE.OVAL, 0, 20) } },
  468.                { { "Color Features", "999" },
  469.                  { new Temp(Temp.RECT, null, 0, 15),
  470.                    new Temp(Temp.IMG, java_logo, 2, 15),
  471.                    new Temp(Temp.RNA | Temp.INA, java_logo, 16, 99),
  472.                    new Features(Features.COLOR, 16, 99) }},
  473.                { { "Java2D  -  composite and rotate text on paints", "2000" },
  474.                  { new GpE(GpE.BURI, black, blue, 0, 20),
  475.                    new GpE(GpE.BURD, black, blue, 21, 30),
  476.                    new TpE(TpE.OI | TpE.HAF, black, blue, 10, 31, 40),
  477.                    new TxE("Java2D", f2, TxE.AC | TxE.RI, yellow, 0, 40) }},
  478.                { { "Previous scene subimage transform out", "0" },
  479.                  { new SiE(60, 60, 0, 40) }},
  480.                { { "CREDITS  -  transform in", "1000" },
  481.                  { new LnE(LnE.ACI | LnE.ZOOMI | LnE.RI, 0, 60),
  482.                    new TxE("CREDITS", f3, TxE.AC | TxE.SCI, Color.red,20,30),
  483.                    new TxE("CREDITS", f3, TxE.SCXD, Color.red, 31, 38),
  484.                    new TxE("CREDITS", f3, TxE.SCXI, Color.red, 39, 48),
  485.                    new TxE("CREDITS", f3, TxE.SCXD, Color.red, 49, 54),
  486.                    new TxE("CREDITS", f3, TxE.SCXI, Color.red, 55, 60) }},
  487.                { { "CREDITS  -  transform out", "0" },
  488.                  { new LnE(LnE.ACD | LnE.ZOOMD | LnE.RD, 0, 45),
  489.                    new TxE("CREDITS", f3, 0, Color.red, 0, 9),
  490.                    new TxE("CREDITS", f3, TxE.SCD | TxE.RD, Color.red,10,30)}},
  491.                { { "Contributors", "1000" },
  492.                  { new Temp(Temp.RECT, null, 0, 30),
  493.                    new Temp(Temp.IMG, cupanim, 4, 30),
  494.                    new Temp(Temp.RNA | Temp.INA, cupanim, 31, 200),
  495.                    new Contributors(34, 200) } },
  496.             };
  499.             public Director() {
  500.                 for (int i = 0; i < parts.length; i++) {
  501.                     Vector v = new Vector();
  502.                     for (int j = 0; j < parts[i][1].length; j++) {
  503.                         v.addElement(parts[i][1][j]);
  504.                     }
  505.                     addElement(new Scene(v, parts[i][0][0], parts[i][0][1]));
  506.                 }
  507.             }
  508.         }
  509.         
  512.         /**
  513.          * Scene is the manager of the parts.
  514.          */
  515.         static class Scene extends Object {
  516.             public Object name;
  517.             public Object participate = new Boolean(true);
  518.             public Object pauseAmt;
  519.             public Vector parts;
  520.             public int index;
  521.             public int length;
  523.             public Scene(Vector parts, Object name, Object pauseAmt) {
  524.                 this.name = name;
  525.                 this.parts = parts;
  526.                 this.pauseAmt = pauseAmt;
  527.                 for (int i = 0; i < parts.size(); i++) {
  528.                     if (((Part) parts.get(i)).getEnd() > length) {
  529.                         length = ((Part) parts.get(i)).getEnd();
  530.                     }
  531.                 }
  532.             }
  534.             public void reset(int w, int h) {
  535.                 index = 0;
  536.                 for (int i = 0; i < parts.size(); i++) {
  537.                     ((Part) parts.get(i)).reset(w, h);
  538.                 }
  539.             }
  541.             public void step(int w, int h) {
  542.                 for (int i = 0; i < parts.size(); i++) {
  543.                     Part part = (Part) parts.get(i);
  544.                     if (index >= part.getBegin() && index <= part.getEnd()) {
  545.                         part.step(w, h);
  546.                     }
  547.                 }
  548.             }
  550.             public void render(int w, int h, Graphics2D g2) {
  551.                 for (int i = 0; i < parts.size(); i++) {
  552.                     Part part = (Part) parts.get(i);
  553.                     if (index >= part.getBegin() && index <= part.getEnd()) {
  554.                         part.render(w, h, g2);
  555.                     }
  556.                 }
  557.             }
  559.             public void pause(Thread thread) {
  560.                 try {
  561.                     thread.sleep(Long.parseLong((String) pauseAmt));
  562.                 } catch (Exception e) { }
  563.                 System.gc();
  564.             }
  565.         } // End Scene class
  569.         /**
  570.          * Text Effect.  Transformation of characters.  Clip or fill.
  571.          */
  572.         static class TxE implements Part {
  574.             static final int INC  = 1;
  575.             static final int DEC  = 2;
  576.             static final int R    = 4;            // rotate
  577.             static final int RI   = R | INC;
  578.             static final int RD   = R | DEC;
  579.             static final int SC   = 8;            // scale
  580.             static final int SCI  = SC | INC;
  581.             static final int SCD  = SC | DEC;    
  582.             static final int SCX  = 16;           // scale invert x
  583.             static final int SCXI = SCX | SC | INC;
  584.             static final int SCXD = SCX | SC | DEC; 
  585.             static final int SCY  = 32;           // scale invert y
  586.             static final int SCYI = SCY | SC | INC;
  587.             static final int SCYD = SCY | SC | DEC; 
  588.             static final int AC   = 64;           // AlphaComposite
  589.             static final int CLIP = 128;          // Clipping
  590.             static final int NOP  = 512;          // No Paint 
  591.             private int beginning, ending;
  592.             private int type;
  593.             private double rIncr, sIncr;
  594.             private double sx, sy, rotate;
  595.             private Shape shapes[], txShapes[];
  596.             private int sw;
  597.             private int numRev;
  598.             private Paint paint;
  601.             public TxE(String text, 
  602.                            Font font, 
  603.                            int type, 
  604.                            Paint paint,
  605.                            int beg, 
  606.                            int end) {
  607.                 this.type = type;
  608.                 this.paint = paint;
  609.                 this.beginning = beg;
  610.                 this.ending = end;
  612.                 setIncrements(2);
  613.                 
  614.                 char[] chars = text.toCharArray();
  615.                 shapes = new Shape[chars.length];
  616.                 txShapes = new Shape[chars.length];
  617.                 FontRenderContext frc = new FontRenderContext(null,true,true);
  618.                 TextLayout tl = new TextLayout(text, font, frc);
  619.                 sw = (int) tl.getOutline(null).getBounds().getWidth();
  620.                 for (int j = 0; j < chars.length; j++) {
  621.                     String s = String.valueOf(chars[j]);
  622.                     shapes[j] = new TextLayout(s, font, frc).getOutline(null);
  623.                 }
  624.             }
  627.             public void setIncrements(double numRevolutions) {
  628.                 this.numRev = (int) numRevolutions;
  629.                 rIncr = 360.0 / ((ending - beginning) / numRevolutions);
  630.                 sIncr = 1.0 / (ending - beginning);
  631.                 if ((type & SCX) != 0 || (type & SCY) != 0) {
  632.                     sIncr *= 2;
  633.                 }
  634.                 if ((type & DEC) != 0) {
  635.                     rIncr = -rIncr;
  636.                     sIncr = -sIncr;
  637.                 }
  638.             }
  641.             public void reset(int w, int h) {
  642.                 if (type == SCXI) {
  643.                     sx = -1.0;  sy = 1.0;
  644.                 } else if (type == SCYI) {
  645.                     sx = 1.0;  sy = -1.0;
  646.                 } else {
  647.                     sx = sy = (type & DEC) != 0 ? 1.0 : 0.0;  
  648.                 }
  649.                 rotate = 0;
  650.             }
  652.        
  653.             public void step(int w, int h) {
  654.         
  655.                 float charWidth = w/2-sw/2;
  656.         
  657.                 for (int i = 0; i < shapes.length; i++) {
  658.                     AffineTransform at = new AffineTransform();
  659.                     Rectangle2D maxBounds = shapes[i].getBounds();
  660.                     at.translate(charWidth, h/2+maxBounds.getHeight()/2);
  661.                     charWidth += (float) maxBounds.getWidth() + 1;
  662.                     Shape shape = at.createTransformedShape(shapes[i]);
  663.                     Rectangle2D b1 = shape.getBounds2D();
  664.         
  665.                     if ((type & R) != 0) {
  666.                         at.rotate(Math.toRadians(rotate)); 
  667.                     }
  668.                     if ((type & SC) != 0) {
  669.                         at.scale(sx, sy);
  670.                     }
  671.                     shape = at.createTransformedShape(shapes[i]);
  672.                     Rectangle2D b2 = shape.getBounds2D();
  673.       
  674.                     double xx = (b1.getX()+b1.getWidth()/2)
  675.                                 - (b2.getX()+b2.getWidth()/2);
  676.                     double yy = (b1.getY()+b1.getHeight()/2)
  677.                                 - (b2.getY()+b2.getHeight()/2);
  678.                     AffineTransform toCenterAT = new AffineTransform();
  679.                     toCenterAT.translate(xx, yy);
  680.                     toCenterAT.concatenate(at);
  681.                     txShapes[i] = toCenterAT.createTransformedShape(shapes[i]);
  682.                 }
  683.                 // avoid over rotation
  684.                 if (Math.abs(rotate) <= numRev * 360) {
  685.                     rotate += rIncr;
  686.                     if ((type & SCX) != 0) {
  687.                         sx += sIncr;
  688.                     } else if ((type & SCY) != 0) {
  689.                         sy += sIncr;
  690.                     } else {
  691.                         sx += sIncr; sy += sIncr;
  692.                     }
  693.                 }
  694.             }
  697.             public void render(int w, int h, Graphics2D g2) {
  698.                 Composite saveAC = null;
  699.                 if ((type & AC) != 0 && sx > 0 && sx < 1) {
  700.                     saveAC = g2.getComposite();
  701.                     g2.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, (float) sx));
  702.                 }
  703.                 GeneralPath path = null;
  704.                 if ((type & CLIP) != 0) {
  705.                     path = new GeneralPath();
  706.                 }
  707.                 if (paint != null) {
  708.                     g2.setPaint(paint);
  709.                 }
  710.                 for (int i = 0; i < txShapes.length; i++) {
  711.                     if ((type & CLIP) != 0) {
  712.                        path.append(txShapes[i], false);
  713.                     } else {
  714.                        g2.fill(txShapes[i]);
  715.                     }
  716.                 }
  717.                 if ((type & CLIP) != 0) {
  718.                     g2.clip(path);
  719.                 }
  720.                 if (saveAC != null) {
  721.                    g2.setComposite(saveAC);
  722.                 }
  723.             }
  726.             public int getBegin() {
  727.                 return beginning;
  728.             }
  730.             public int getEnd() {
  731.                 return ending;
  732.             }
  733.         } // End TxE class
  738.         /**
  739.          * GradientPaint Effect.  Burst, split, horizontal and 
  740.          * vertical gradient fill effects.
  741.          */
  742.         static class GpE implements Part {
  744.             static final int INC = 1;             // increasing
  745.             static final int DEC = 2;             // decreasing
  746.             static final int CNT = 4;             // center
  747.             static final int WID = 8;             // width 
  748.             static final int WI  = WID | INC;             
  749.             static final int WD  = WID | DEC;            
  750.             static final int HEI = 16;            // height
  751.             static final int HI  = HEI | INC;            
  752.             static final int HD  = HEI | DEC;            
  753.             static final int SPL = 32 | CNT;      // split 
  754.             static final int SIW = SPL | INC | WID;
  755.             static final int SDW = SPL | DEC | WID;
  756.             static final int SIH = SPL | INC | HEI;
  757.             static final int SDH = SPL | DEC | HEI;
  758.             static final int BUR = 64 | CNT;     // burst 
  759.             static final int BURI = BUR | INC;    
  760.             static final int BURD = BUR | DEC;   
  761.             static final int NF = 128;           // no fill
  762.             private Color c1, c2;
  763.             private int beginning, ending;
  764.             private float incr, index;
  765.             private Vector rect = new Vector();
  766.             private Vector grad = new Vector();
  767.             private int type;
  770.             public GpE(int type, Color c1, Color c2, int beg, int end) {
  771.                 this.type = type;
  772.                 this.c1 = c1;
  773.                 this.c2 = c2;
  774.                 this.beginning = beg;
  775.                 this.ending = end;
  776.             }
  779.             public void reset(int w, int h) {
  780.                 incr = 1.0f / (ending - beginning);
  781.                 if ((type & CNT) != 0) {
  782.                     incr /= 2.3f;
  783.                 }
  784.                 if ((type & CNT) != 0 && (type & INC) != 0) {
  785.                     index = 0.5f;
  786.                 } else if ((type & DEC) != 0) {
  787.                     index = 1.0f;
  788.                     incr = -incr;
  789.                 } else {
  790.                     index = 0.0f;
  791.                 }
  792.                 index += incr;
  793.             }
  795.        
  796.             public void step(int w, int h) {
  797.                 rect.clear();
  798.                 grad.clear();
  800.                 if ((type & WID) != 0) {
  801.                     float w2 = 0, x1 = 0, x2 = 0;
  802.                     if ((type & SPL) != 0) {
  803.                         w2 = w * 0.5f;
  804.                         x1 = w * (1.0f - index);
  805.                         x2 = w * index;
  806.                     } else {
  807.                         w2 = w * index;
  808.                         x1 = x2 = w2;
  809.                     }
  810.                     rect.addElement(new Rectangle2D.Float(0, 0, w2, h));
  811.                     rect.addElement(new Rectangle2D.Float(w2, 0, w-w2, h));
  812.                     grad.addElement(new GradientPaint(0,0,c1,x1,0,c2));
  813.                     grad.addElement(new GradientPaint(x2,0,c2,w,0,c1));
  814.                 } else if ((type & HEI) != 0) {
  815.                     float h2 = 0, y1 = 0, y2 = 0;
  816.                     if ((type & SPL) != 0) {
  817.                         h2 = h * 0.5f;
  818.                         y1 = h * (1.0f - index);
  819.                         y2 = h * index;
  820.                     } else {
  821.                         h2 = h * index;
  822.                         y1 = y2 = h2;
  823.                     }
  824.                     rect.addElement(new Rectangle2D.Float(0, 0, w, h2));
  825.                     rect.addElement(new Rectangle2D.Float(0, h2, w, h-h2));
  826.                     grad.addElement(new GradientPaint(0,0,c1,0,y1,c2));
  827.                     grad.addElement(new GradientPaint(0,y2,c2,0,h,c1));
  828.                 } else if ((type & BUR) != 0) {
  830.                     float w2 = w/2;
  831.                     float h2 = h/2;
  833.                     rect.addElement(new Rectangle2D.Float(0, 0, w2, h2));
  834.                     rect.addElement(new Rectangle2D.Float(w2, 0, w2, h2));
  835.                     rect.addElement(new Rectangle2D.Float(0, h2, w2, h2));
  836.                     rect.addElement(new Rectangle2D.Float(w2, h2, w2, h2));
  838.                     float x1 = w * (1.0f - index);
  839.                     float x2 = w * index;
  840.                     float y1 = h * (1.0f - index);
  841.                     float y2 = h * index;
  843.                     grad.addElement(new GradientPaint(0,0,c1,x1,y1,c2));
  844.                     grad.addElement(new GradientPaint(w,0,c1,x2,y1,c2));
  845.                     grad.addElement(new GradientPaint(0,h,c1,x1,y2,c2));
  846.                     grad.addElement(new GradientPaint(w,h,c1,x2,y2,c2));
  847.                 } else if ((type & NF) != 0) {
  848.                     float x = w * index;
  849.                     float y = h * index;
  850.                     grad.addElement(new GradientPaint(0,0,c1,0,y,c2));
  851.                 }
  853.                 if ((type & INC) != 0 || (type & DEC) != 0) {
  854.                     index += incr;
  855.                 }
  856.             }
  859.             public void render(int w, int h, Graphics2D g2) {
  860.                 g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, 
  861.                                 RenderingHints.VALUE_ANTIALIAS_OFF);
  862.                 for (int i = 0; i < grad.size(); i++) {
  863.                     g2.setPaint((GradientPaint) grad.get(i));
  864.                     if ((type & NF) == 0) {
  865.                         g2.fill((Rectangle2D) rect.get(i));
  866.                     }
  867.                 }
  868.                 g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, 
  869.                                 RenderingHints.VALUE_ANTIALIAS_ON);
  870.             }
  872.             public int getBegin() {
  873.                 return beginning;
  874.             }
  876.             public int getEnd() {
  877.                 return ending;
  878.             }
  879.         } // End GpE class
  883.         /**
  884.          * TexturePaint Effect.  Expand and collapse a texture. 
  885.          */
  886.         static class TpE implements Part {
  888.             static final int INC = 1;             // increasing
  889.             static final int DEC = 2;             // decreasing
  890.             static final int OVAL = 4;            // oval
  891.             static final int RECT = 8;            // rectangle 
  892.             static final int HAF = 16;            // half oval or rect size
  893.             static final int OI = OVAL | INC; 
  894.             static final int OD = OVAL | DEC;
  895.             static final int RI = RECT | INC;
  896.             static final int RD = RECT | DEC;
  897.             static final int NF = 32;             // no fill 
  898.             private Paint p1, p2;
  899.             private int beginning, ending;
  900.             private float incr, index;
  901.             private TexturePaint texture;
  902.             private int type;
  903.             private int size;
  904.             private BufferedImage bimg;
  905.             private Rectangle rect;
  908.             public TpE(int type, Paint p1, Paint p2, int size,
  909.                                    int beg, int end) {
  910.                 this.type = type;
  911.                 this.p1 = p1;
  912.                 this.p2 = p2;
  913.                 this.beginning = beg;
  914.                 this.ending = end;
  915.                 setTextureSize(size);
  916.             }
  919.             public void setTextureSize(int size) {
  920.                 this.size = size;
  921.                 bimg = new BufferedImage(size,size,BufferedImage.TYPE_INT_RGB);
  922.                 rect = new Rectangle(0,0,size,size);
  923.             }
  926.             public void reset(int w, int h) {
  927.                 incr = (float) (size) / (float) (ending - beginning);
  928.                 if ((type & HAF) != 0) {
  929.                    incr /= 2;
  930.                 }
  931.                 if ((type & DEC) != 0) {
  932.                     index = size;
  933.                     if ((type & HAF) != 0) {
  934.                        index /= 2;
  935.                     }
  936.                     incr = -incr;
  937.                 } else {
  938.                     index = 0.0f;
  939.                 }
  940.                 index += incr;
  941.             }
  943.        
  944.             public void step(int w, int h) {
  945.                 Graphics2D g2 = bimg.createGraphics();
  946.                 g2.setPaint(p1);
  947.                 g2.fillRect(0,0,size,size);
  948.                 g2.setPaint(p2);
  949.                 if ((type & OVAL) != 0) {
  950.                     g2.fill(new Ellipse2D.Float(0,0,index,index));
  951.                 } else if ((type & RECT) != 0) {
  952.                     g2.fill(new Rectangle2D.Float(0,0,index,index));
  953.                 }
  954.                 texture = new TexturePaint(bimg, rect);
  955.                 g2.dispose();
  956.                 index += incr;
  957.             }
  960.             public void render(int w, int h, Graphics2D g2) {
  961.                 g2.setPaint(texture);
  962.                 if ((type & NF) == 0) {
  963.                     g2.fillRect(0, 0, w, h);
  964.                 }
  965.             }
  967.             public int getBegin() {
  968.                 return beginning;
  969.             }
  971.             public int getEnd() {
  972.                 return ending;
  973.             }
  974.         } // End TpE class
  978.         /**
  979.          * Close out effect.  Close out the buffered image with different 
  980.          * geometry shapes.
  981.          */
  982.         static class CoE implements Part {
  984.             static final int WID  = 1;            
  985.             static final int HEI  = 2;           
  986.             static final int OVAL = 4;            
  987.             static final int RECT = 8;           
  988.             static final int RAND = 16;           
  989.             static final int ARC  = 32;           
  990.             private int type;
  991.             private int beginning, ending;
  992.             private BufferedImage bimg;
  993.             private Shape shape;
  994.             private double zoom, extent;
  995.             private double zIncr, eIncr;
  996.             private boolean doRandom;
  999.             public CoE(int type, int beg, int end) {
  1000.                 this.type = type;
  1001.                 this.beginning = beg;
  1002.                 this.ending = end;
  1003.                 zIncr = -(2.0 / (ending - beginning));
  1004.                 eIncr = 360.0 / (ending - beginning);
  1005.                 doRandom = (type & RAND) != 0;
  1006.             }
  1009.             public void reset(int w, int h) {
  1010.                 if (doRandom) {
  1011.                     int num = (int) (Math.random() * 5.0);
  1012.                     switch (num) {
  1013.                         case 0 : type = OVAL; break;
  1014.                         case 1 : type = RECT; break;
  1015.                         case 2 : type = RECT | WID; break;
  1016.                         case 3 : type = RECT | HEI; break;
  1017.                         case 4 : type = ARC; break;
  1018.                         default : type = OVAL; 
  1019.                     }
  1020.                 }
  1021.                 shape = null;
  1022.                 bimg = null;
  1023.                 extent = 360.0;
  1024.                 zoom = 2.0;
  1025.             }
  1028.             public void step(int w, int h) {
  1029.                 if (bimg == null) {
  1030.                     int biw = Surface.bimg.getWidth();
  1031.                     int bih = Surface.bimg.getHeight();
  1032.                     bimg = new BufferedImage(biw, bih, BufferedImage.TYPE_INT_RGB);
  1033.                     Graphics2D big = bimg.createGraphics();
  1034.                     big.drawImage(Surface.bimg, 0, 0, null);
  1035.                 }
  1036.                 double z = Math.min(w, h) * zoom;
  1037.                 if ((type & OVAL) != 0) {
  1038.                     shape = new Ellipse2D.Double(w/2-z/2,h/2-z/2,z,z);
  1039.                 } else if ((type & ARC) != 0) {
  1040.                     shape = new Arc2D.Double(-100,-100,w+200,h+200,90,extent,Arc2D.PIE);
  1041.                     extent -= eIncr;
  1042.                 } else if ((type & RECT) != 0) {
  1043.                     if ((type & WID) != 0) {
  1044.                         shape = new Rectangle2D.Double(w/2-z/2,0,z,h);
  1045.                     } else if ((type & HEI) != 0) {
  1046.                         shape = new Rectangle2D.Double(0,h/2-z/2,w,z);
  1047.                     } else {
  1048.                         shape = new Rectangle2D.Double(w/2-z/2,h/2-z/2,z,z);
  1049.                     }
  1050.                 }
  1051.                 zoom += zIncr;
  1052.             }
  1055.             public void render(int w, int h, Graphics2D g2) {
  1056.                 g2.clip(shape);
  1057.                 g2.draw(shape);
  1058.                 g2.drawImage(bimg, 0, 0, null);
  1059.             }
  1061.             public int getBegin() {
  1062.                 return beginning;
  1063.             }
  1065.             public int getEnd() {
  1066.                 return ending;
  1067.             }
  1068.         } // End CoE class
  1072.         /**
  1073.          * Dither Dissolve Effect.  Render a shuffled list of pixels black
  1074.          * from the buffered image.
  1075.          *
  1076.          * The shuffled list is created in the Surface class 
  1077.          * createShuffledList() method.  
  1078.          */
  1079.         static class DdE implements Part {
  1081.             private int beginning, ending;
  1082.             private BufferedImage bimg;
  1083.             private DataBuffer db;
  1084.             private int eNum;   // element number
  1085.             private int cSize;  // chunk size
  1088.             public DdE(int beg, int end) {
  1089.                 this.beginning = beg;
  1090.                 this.ending = end;
  1091.             }
  1094.             public void reset(int w, int h) {
  1095.                 bimg = null;
  1096.             }
  1099.             public void step(int w, int h) {
  1100.                 if (bimg == null) {
  1101.                     int biw = Surface.bimg.getWidth();
  1102.                     int bih = Surface.bimg.getHeight();
  1103.                     bimg = new BufferedImage(biw, bih, BufferedImage.TYPE_INT_RGB);
  1104.                     Graphics2D big = bimg.createGraphics();
  1105.                     big.drawImage(Surface.bimg, 0, 0, null);
  1106.                     db = bimg.getRaster().getDataBuffer();
  1107.                     cSize = list.size() / (ending - beginning);
  1108.                     eNum = -cSize;
  1109.                 }
  1110.                 eNum += cSize;
  1111.             }
  1114.             public void render(int w, int h, Graphics2D g2) {
  1115.                 int black = 20 << 16 | 20 << 8 | 20;
  1116.                 for (int j = eNum; j < eNum+cSize && j < list.size();j++) {
  1117.                     int val = ((Integer) list.get(j)).intValue();
  1118.                     db.setElem(val, black);
  1119.                 }
  1120.                 g2.drawImage(bimg, 0, 0, null);
  1121.             }
  1123.             public int getBegin() {
  1124.                 return beginning;
  1125.             }
  1127.             public int getEnd() {
  1128.                 return ending;
  1129.             }
  1130.         } // End DdE class
  1134.         /**
  1135.          * Subimage effect.  Subimage the scene's buffered
  1136.          * image then rotate and scale down the subimages.
  1137.          */
  1138.         static class SiE implements Part {
  1140.             private int beginning, ending;
  1141.             private BufferedImage bimg;
  1142.             private double rIncr, sIncr;
  1143.             private double scale, rotate;
  1144.             private int siw, sih;
  1145.             private Vector subs = new Vector(20);
  1146.             private Vector pts = new Vector(20);
  1149.             public SiE(int siw, int sih, int beg, int end) {
  1150.                 this.siw = siw;
  1151.                 this.sih = sih;
  1152.                 this.beginning = beg;
  1153.                 this.ending = end;
  1154.                 rIncr = 360.0 / (ending - beginning);
  1155.                 sIncr = 1.0 / (ending - beginning);
  1156.             }
  1159.             public void reset(int w, int h) {
  1160.                 scale = 1.0;  
  1161.                 rotate = 0.0;
  1162.                 bimg = null;
  1163.                 subs.clear();
  1164.                 pts.clear();
  1165.             }
  1168.             public void step(int w, int h) {
  1169.                 if (bimg == null) {
  1170.                     int biw = Surface.bimg.getWidth();
  1171.                     int bih = Surface.bimg.getHeight();
  1172.                     bimg = new BufferedImage(biw, bih, BufferedImage.TYPE_INT_RGB);
  1173.                     Graphics2D big = bimg.createGraphics();
  1174.                     big.drawImage(Surface.bimg, 0, 0, null);
  1175.                     for (int x = 0; x < w && scale > 0.0; x+=siw) {
  1176.                         int ww = x+siw < w ? siw : w-x;
  1177.                         for (int y = 0; y < h; y+=sih) {
  1178.                             int hh = y+sih < h ? sih : h-y;
  1179.                             subs.addElement(bimg.getSubimage(x,y,ww,hh));    
  1180.                             pts.addElement(new Point(x, y));
  1181.                         }
  1182.                     }
  1183.                 }
  1184.                 
  1185.                 rotate += rIncr;
  1186.                 scale -= sIncr;
  1187.             }
  1190.             public void render(int w, int h, Graphics2D g2) {
  1191.                 AffineTransform saveTx = g2.getTransform();
  1192.                 g2.setColor(blue);
  1193.                 for (int i = 0; i < subs.size() && scale > 0.0; i++) {
  1194.                     BufferedImage bi = (BufferedImage) subs.get(i);
  1195.                     Point p = (Point) pts.get(i);
  1196.                     int ww = bi.getWidth();
  1197.                     int hh = bi.getHeight();
  1198.                     AffineTransform at = new AffineTransform();
  1199.                     at.rotate(Math.toRadians(rotate), p.x+ww/2, p.y+hh/2); 
  1200.                     at.translate(p.x, p.y);
  1201.                     at.scale(scale, scale);
  1203.                     Rectangle b1 = new Rectangle(0, 0, ww, hh);
  1204.                     Shape shape = at.createTransformedShape(b1);
  1205.                     Rectangle2D b2 = shape.getBounds2D();
  1206.                     double xx = (p.x+ww/2) - (b2.getX()+b2.getWidth()/2);
  1207.                     double yy = (p.y+hh/2) - (b2.getY()+b2.getHeight()/2);
  1208.                     AffineTransform toCenterAT = new AffineTransform();
  1209.                     toCenterAT.translate(xx, yy);
  1210.                     toCenterAT.concatenate(at);
  1212.                     g2.setTransform(toCenterAT);
  1213.                     g2.drawImage(bi, 0, 0, null);
  1214.                     g2.draw(b1);
  1215.                 }
  1216.                 g2.setTransform(saveTx);
  1217.             }
  1219.             public int getBegin() {
  1220.                 return beginning;
  1221.             }
  1223.             public int getEnd() {
  1224.                 return ending;
  1225.             }
  1226.         } // End SiE class
  1231.         /**
  1232.          * Line Effect.  Flattened ellipse with lines from the center 
  1233.          * to the edge.  Expand or collapse the ellipse.  Fade in or out 
  1234.          * the lines.
  1235.          */
  1236.         static class LnE implements Part {
  1238.             static final int INC  = 1;
  1239.             static final int DEC  = 2;
  1240.             static final int R    = 4;              // rotate
  1241.             static final int RI   = R | INC;
  1242.             static final int RD   = R | DEC;
  1243.             static final int ZOOM   = 8;            // zoom
  1244.             static final int ZOOMI  = ZOOM | INC;
  1245.             static final int ZOOMD  = ZOOM | DEC;    
  1246.             static final int AC   = 32;             // AlphaComposite
  1247.             static final int ACI   = 32 | INC;
  1248.             static final int ACD   = 32 | DEC; 
  1249.             private int beginning, ending;
  1250.             private double rIncr, rotate;
  1251.             private double zIncr, zoom;
  1252.             private Vector pts = new Vector();
  1253.             private float alpha, aIncr;
  1254.             private int type;
  1257.             public LnE(int type, int beg, int end) {
  1258.                 this.type = type;
  1259.                 this.beginning = beg;
  1260.                 this.ending = end;
  1261.                 rIncr = 360.0 / (ending - beginning);
  1262.                 aIncr = 0.9f / (ending - beginning);
  1263.                 zIncr = 2.0 / (ending - beginning);
  1264.                 if ((type & DEC) != 0) {
  1265.                     rIncr = -rIncr;
  1266.                     aIncr = -aIncr;
  1267.                     zIncr = -zIncr;
  1268.                 }
  1269.             }
  1272.             public void generatePts(int w, int h, double sizeF) {
  1273.                 pts.clear();
  1274.                 double size = Math.min(w, h) * sizeF;
  1275.                 Ellipse2D ellipse = new Ellipse2D.Double(w/2-size/2,h/2-size/2,size,size);
  1276.                 PathIterator pi = ellipse.getPathIterator(null, 0.8);
  1277.                 while ( !pi.isDone() ) {
  1278.                     double[] pt = new double[6];
  1279.                     switch ( pi.currentSegment(pt) ) {
  1280.                         case FlatteningPathIterator.SEG_MOVETO:
  1281.                         case FlatteningPathIterator.SEG_LINETO:
  1282.                             pts.addElement(new Point2D.Double(pt[0], pt[1]));
  1283.                     }
  1284.                     pi.next();
  1285.                 }
  1286.             }
  1289.             public void reset(int w, int h) {
  1290.                 if ((type & DEC) != 0) {
  1291.                     rotate = 360;
  1292.                     alpha = 1.0f;
  1293.                     zoom = 2.0;
  1294.                 } else {
  1295.                     rotate = alpha = 0;
  1296.                     zoom = 0;
  1297.                 }
  1298.                 if ((type & ZOOM) == 0) {
  1299.                     generatePts(w, h, 0.5);
  1300.                 }
  1301.             }
  1304.             public void step(int w, int h) {
  1305.                 if ((type & ZOOM) != 0) {
  1306.                     generatePts(w, h, zoom += zIncr);
  1307.                 }
  1308.                 if ((type & RI) != 0 || (type & RI) != 0) {
  1309.                    rotate += rIncr;
  1310.                 }
  1311.                 if ((type & ACI) != 0 || (type & ACD) != 0) {
  1312.                    alpha += aIncr;
  1313.                 }
  1314.             }
  1317.             public void render(int w, int h, Graphics2D g2) {
  1318.                 Composite saveAC = null;
  1319.                 if ((type & AC) != 0 && alpha >= 0 && alpha <= 1) {
  1320.                     saveAC = g2.getComposite();
  1321.                     g2.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, alpha));
  1322.                 }
  1323.                 AffineTransform saveTx = null;
  1324.                 if ((type & R) != 0) {
  1325.                     saveTx = g2.getTransform();
  1326.                     AffineTransform at = new AffineTransform();
  1327.                     at.rotate(Math.toRadians(rotate), w/2, h/2); 
  1328.                     g2.setTransform(at);
  1329.                 }
  1330.                 Point2D p1 = new Point2D.Double(w/2, h/2);
  1331.                 g2.setColor(Color.yellow);
  1332.                 for (int i = 0; i < pts.size()-1; i++) {
  1333.                     g2.draw(new Line2D.Float(p1, (Point2D) pts.get(i)));
  1334.                 }
  1335.                 if (saveTx != null) {
  1336.                    g2.setTransform(saveTx);
  1337.                 }
  1338.                 if (saveAC != null) {
  1339.                    g2.setComposite(saveAC);
  1340.                 }
  1341.             }
  1343.             public int getBegin() {
  1344.                 return beginning;
  1345.             }
  1347.             public int getEnd() {
  1348.                 return ending;
  1349.             }
  1350.         } // End LnE class
  1354.         /**
  1355.          * Template for Features & Contributors consisting of translating
  1356.          * blue and red rectangles and an image going from transparent to
  1357.          * opaque.
  1358.          */
  1359.         static class Temp implements Part {
  1360.             static final int NOANIM = 1;
  1361.             static final int RECT   = 2;
  1362.             static final int RNA    = RECT | NOANIM;
  1363.             static final int IMG    = 4;
  1364.             static final int INA    = IMG | NOANIM;
  1365.             private int beginning, ending;
  1366.             private float alpha, aIncr;
  1367.             private int type;
  1368.             private Rectangle rect1, rect2;
  1369.             private int x, y, xIncr, yIncr;
  1370.             private Image img;
  1373.             public Temp(int type, Image img, int beg, int end) {
  1374.                 this.type = type;
  1375.                 this.img = img;
  1376.                 this.beginning = beg;
  1377.                 this.ending = end;
  1378.                 aIncr = 0.9f / (ending - beginning);
  1379.                 if ((type & NOANIM) != 0) {
  1380.                     alpha = 1.0f;
  1381.                 } 
  1382.             }
  1386.             public void reset(int w, int h) {
  1387.                 rect1 = new Rectangle(8, 20, w-20, 30);
  1388.                 rect2 = new Rectangle(20, 8, 30, h-20);
  1389.                 if ((type & NOANIM) == 0) {
  1390.                     alpha = 0.0f;
  1391.                     xIncr = w / (ending - beginning);
  1392.                     yIncr = h / (ending - beginning);
  1393.                     x = w+(int)(xIncr*1.4);
  1394.                     y = h+(int)(yIncr*1.4);
  1395.                 }
  1396.             }
  1399.             public void step(int w, int h) {
  1400.                 if ((type & NOANIM) != 0) {
  1401.                    return;
  1402.                 }
  1403.                 if ((type & RECT) != 0) {
  1404.                     rect1.setLocation(x-=xIncr, 20);
  1405.                     rect2.setLocation(20, y-=yIncr);
  1406.                 }
  1407.                 if ((type & IMG) != 0) {
  1408.                     alpha += aIncr;
  1409.                 }
  1410.             }
  1413.             public void render(int w, int h, Graphics2D g2) {
  1414.                 if ((type & RECT) != 0) {
  1415.                     g2.setColor(blue);
  1416.                     g2.fill(rect1);
  1417.                     g2.setColor(red);
  1418.                     g2.fill(rect2);
  1419.                 }
  1420.                 if ((type & IMG) != 0) {
  1421.                     Composite saveAC = g2.getComposite();
  1422.                     if (alpha >= 0 && alpha <= 1) {
  1423.                         g2.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, alpha));
  1424.                     }
  1425.                     g2.drawImage(img, 30, 30, null);
  1426.                     g2.setComposite(saveAC);
  1427.                 }
  1428.             }
  1430.             public int getBegin() {
  1431.                 return beginning;
  1432.             }
  1434.             public int getEnd() {
  1435.                 return ending;
  1436.             }
  1437.         } // End Temp class
  1441.         /**
  1442.          * Features of Java2D.  Single character advancement effect.
  1443.          */
  1444.         static class Features implements Part {
  1446.             static final int GRAPHICS = 0;
  1447.             static final int TEXT = 1;
  1448.             static final int IMAGES = 2;
  1449.             static final int COLOR = 3;
  1450.             static Font font1 = new Font("serif", Font.BOLD, 38);
  1451.             static Font font2 = new Font("serif", Font.PLAIN, 24);
  1452.             static FontMetrics fm1 = Surface.getMetrics(font1);
  1453.             static FontMetrics fm2 = Surface.getMetrics(font2);
  1454.             static String table[][] = 
  1455.                 {{ "Graphics", "Antialiased rendering", "Bezier paths", 
  1456.                     "Transforms", "Compositing", "Stroking parameters" },
  1457.                  { "Text", "Extended font support", 
  1458.                    "Advanced text layout",  
  1459.                    "AttributeSets for font customization" },
  1460.                  { "Images", "Flexible image layouts",
  1461.                     "Extended imaging operations", 
  1462.                     "   Convolutions, Lookup Tables",
  1463.                     "RenderableImage interface"},
  1464.                  { "Color", "ICC profile support", "Color conversion", 
  1465.                    "Arbitrary color spaces"} };
  1466.             private String list[];
  1467.             private int beginning, ending;
  1468.             private int strH;
  1469.             private int endIndex, listIndex;
  1470.             private Vector v = new Vector();
  1471.            
  1473.             public Features(int type, int beg, int end) {
  1474.                 list = table[type];
  1475.                 this.beginning = beg;
  1476.                 this.ending = end;
  1477.             }
  1480.             public void reset(int w, int h) {
  1481.                 strH = (int) (fm2.getAscent()+fm2.getDescent());
  1482.                 endIndex = 1;
  1483.                 listIndex = 0;
  1484.                 v.clear();
  1485.                 v.addElement(list[listIndex].substring(0,endIndex));
  1486.             }
  1489.             public void step(int w, int h) {
  1490.                 if (listIndex < list.length) {
  1491.                     if (++endIndex > list[listIndex].length()) {
  1492.                         if (++listIndex < list.length) {
  1493.                             endIndex = 1;
  1494.                             v.addElement(list[listIndex].substring(0,endIndex));
  1495.                         }
  1496.                     } else {
  1497.                         v.set(listIndex, list[listIndex].substring(0,endIndex));
  1498.                     }
  1499.                 }
  1500.             }
  1503.             public void render(int w, int h, Graphics2D g2) {
  1504.                 g2.setColor(white);
  1505.                 g2.setFont(font1);
  1506.                 g2.drawString((String) v.get(0), 90, 85);
  1507.                 g2.setFont(font2);
  1508.                 for (int i = 1, y = 90; i < v.size(); i++) {
  1509.                     g2.drawString((String) v.get(i), 120, y += strH);
  1510.                 }
  1511.             }
  1513.             public int getBegin() {
  1514.                 return beginning;
  1515.             }
  1517.             public int getEnd() {
  1518.                 return ending;
  1519.             }
  1520.         } // End Features class
  1524.         /**
  1525.          * Scrolling text of Java2D contributors.
  1526.          */
  1527.         static class Contributors implements Part {
  1529.             static String members[] = 
  1530.             { 
  1531.                 "Brian Lichtenwalter", "Jeannette Hung", 
  1532.                 "Thanh Nguyen", "Jim Graham", "Jerry Evans", 
  1533.                 "John Raley", "Michael Peirce", "Robert Kim", 
  1534.                 "Jennifer Ball", "Deborah Adair", "Paul Charlton", 
  1535.                 "Dmitry Feld", "Gregory Stone", "Richard Blanchard", 
  1536.                 "Link Perry", "Phil Race", "Vincent Hardy", 
  1537.                 "Parry Kejriwal", "Doug Felt", "Rekha Rangarajan", 
  1538.                 "Paula Patel", "Michael Bundschuh", "Joe Warzecha", 
  1539.                 "Joey Beheler", "Aastha Bhardwaj", "Daniel Rice"
  1540.             };
  1541.             static Font font = new Font("serif", Font.PLAIN, 26);
  1542.             static FontMetrics fm = Surface.getMetrics(font);
  1543.             private int beginning, ending;
  1544.             private int nStrs, strH, index, yh, height;
  1545.             private Vector v = new Vector();
  1546.             private Vector cast = new Vector(members.length+3);
  1547.             private int counter, cntMod;
  1548.             private GradientPaint gp;
  1551.             public Contributors(int beg, int end) {
  1552.                 this.beginning = beg;
  1553.                 this.ending = end;
  1554.                 java.util.Arrays.sort(members);
  1555.                 cast.addElement("CONTRIBUTORS");
  1556.                 cast.addElement(" ");
  1557.                 for (int i = 0; i < members.length; i++) {
  1558.                     cast.addElement(members[i]);
  1559.                 }
  1560.                 cast.addElement(" "); cast.addElement(" ");
  1561.                 cntMod = (ending - beginning) / cast.size() - 1;
  1562.             }
  1565.             public void reset(int w, int h) {
  1566.                 v.clear();
  1567.                 strH = (int) (fm.getAscent()+fm.getDescent());
  1568.                 nStrs = (h-40)/strH + 1;
  1569.                 height = strH * (nStrs-1) + 48;
  1570.                 index = 0;
  1571.                 gp = new GradientPaint(0,h/2,Color.white,0,h+20,Color.black);
  1572.                 counter = 0;
  1573.             }
  1576.             public void step(int w, int h) {
  1577.                 if (counter++%cntMod == 0) {
  1578.                     if (index < cast.size()) {
  1579.                         v.addElement(cast.get(index));
  1580.                     }
  1581.                     if ((v.size() == nStrs || index >= cast.size()) && v.size() != 0) {
  1582.                         v.removeElementAt(0);
  1583.                     }
  1584.                     ++index;
  1585.                 }
  1586.             }
  1589.             public void render(int w, int h, Graphics2D g2) {
  1590.                 g2.setPaint(gp);
  1591.                 g2.setFont(font);
  1592.                 double remainder = counter%cntMod;
  1593.                 double incr = 1.0-remainder/cntMod;
  1594.                 incr = incr == 1.0 ? 0 : incr;
  1595.                 int y = (int) (incr * strH);
  1597.                 if (index >= cast.size()) {
  1598.                     y = yh + y; 
  1599.                 } else {
  1600.                     y = yh = height - v.size() * strH + y;
  1601.                 }
  1602.                 for (int i = 0; i < v.size(); i++) {
  1603.                     String s = (String) v.get(i);
  1604.                     g2.drawString(s, w/2-fm.stringWidth(s)/2, y += strH);
  1605.                 }
  1606.             }
  1608.             public int getBegin() {
  1609.                 return beginning;
  1610.             }
  1612.             public int getEnd() {
  1613.                 return ending;
  1614.             }
  1615.         } // End Contributors class
  1617.     } // End Surface class
  1618. } // End Intro class