Category

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

2D Graphic

Development Platform:

Java

Stars3D.java：Code Content
  1. /*
  2.  * @(#)Stars3D.java 1.17 99/04/23
  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.  */
  31. package demos.Mix;
  33. import java.awt.*;
  34. import java.awt.event.*;
  35. import java.awt.geom.*;
  36. import java.awt.font.FontRenderContext;
  37. import javax.swing.*;
  38. import DemoSurface;
  39. import DemoPanel;
  40. import CustomControls;
  43. /**
  44.  * Generate a 3D text shape with GeneralPath, render a number of small
  45.  * multi-colored rectangles and then render the 3D text shape.
  46.  */
  47. public class Stars3D extends DemoSurface implements CustomControls {
  49.     private static Color colors[] = { Color.red, Color.green, Color.white };
  50.     private static AffineTransform at = AffineTransform.getTranslateInstance(-5, -5);
  51.     private Shape shape, tshape;
  52.     private Shape ribbon;
  53.     protected int fontSize = 72;
  54.     protected String text = "J2D";
  55.     protected int numStars = 300;
  56.     private DemoControls controls;
  59.     public Stars3D() {
  60.         setBackground(Color.black);
  61.         controls = new DemoControls(this);
  62.     }
  65.     public String[] getCustomControlsConstraints() {
  66.         return new String[] { BorderLayout.NORTH };
  67.     }
  70.     public Component[] getCustomControls() {
  71.         return new Component[] { (Component) controls };
  72.     }
  75.     public void customControlsThread(int state) {
  76.         if (state == CustomControls.START) {
  77.             controls.start();
  78.         } else if (state == CustomControls.STOP) {
  79.             controls.stop();
  80.         }
  81.     }
  84.     public void drawDemo(int w, int h, Graphics2D g2) {
  86.         Rectangle2D rect = new Rectangle2D.Double();
  87.         for (int i = 0; i < numStars; i++) {
  88.             g2.setColor(colors[i%3]);
  89.             g2.setComposite(AlphaComposite.getInstance(
  90.                          AlphaComposite.SRC_OVER, (float) Math.random()));
  91.             rect.setRect(w*Math.random(), h*Math.random(),2,2);
  92.             g2.fill(rect);
  93.         }
  95.         FontRenderContext frc = g2.getFontRenderContext();
  96.         Font font = new Font("serif.bolditalic", Font.PLAIN, fontSize);
  97.         shape = font.createGlyphVector(frc, text).getOutline();
  98.         tshape = at.createTransformedShape(shape);
  99.         PathIterator pi = shape.getPathIterator(null);
  100.         
  101.         float seg[] = new float[6];
  102.         float tseg[] = new float[6];
  103.         
  104.         GeneralPath working = new GeneralPath(GeneralPath.WIND_NON_ZERO);
  105.         float x=0, y=0; // Current point on the path
  106.         float tx=0, ty=0; // Transformed path point
  107.         float cx=0, cy=0; // Last moveTo point, for SEG_CLOSE
  108.         float tcx=0, tcy=0; // Transformed last moveTo point
  109.         
  110.         //
  111.         // Iterate through the Shape and build the ribbon
  112.         // by adding general path objects.
  113.         //
  114.         while(!pi.isDone()) {
  115.             int segType = pi.currentSegment(seg);
  116.             switch(segType) {
  117.                 case PathIterator.SEG_MOVETO:
  118.                         at.transform(seg, 0, tseg, 0, 1);
  119.                         x = seg[0];
  120.                         y = seg[1];
  121.                         tx = tseg[0];
  122.                         ty = tseg[1];
  123.                         cx = x;
  124.                         cy = y;
  125.                         tcx = tx;
  126.                         tcy = ty;
  127.                         break;
  128.                 case PathIterator.SEG_LINETO:
  129.                         at.transform(seg, 0, tseg, 0, 1);
  130.                         if (Line2D.relativeCCW(x, y, tx, ty,
  131.                                                seg[0], seg[1]) < 0) {
  132.                             working.moveTo(x, y);
  133.                             working.lineTo(seg[0], seg[1]);
  134.                             working.lineTo(tseg[0], tseg[1]);
  135.                             working.lineTo(tx, ty);
  136.                             working.lineTo(x, y);
  137.                         } else {
  138.                             working.moveTo(x, y);
  139.                             working.lineTo(tx, ty);
  140.                             working.lineTo(tseg[0], tseg[1]);
  141.                             working.lineTo(seg[0], seg[1]);
  142.                             working.lineTo(x, y);
  143.                         }
  144.                         
  145.                         x = seg[0];
  146.                         y = seg[1];
  147.                         tx = tseg[0];
  148.                         ty = tseg[1];
  149.                         break;
  150.                         
  151.                 case PathIterator.SEG_QUADTO:
  152.                         at.transform(seg, 0, tseg, 0, 2);
  153.                         if (Line2D.relativeCCW(x, y, tx, ty,
  154.                                                seg[2], seg[3]) < 0) {
  155.                             working.moveTo(x, y);
  156.                             working.quadTo(seg[0], seg[1],
  157.                                            seg[2], seg[3]);
  158.                             working.lineTo(tseg[2], tseg[3]);
  159.                             working.quadTo(tseg[0], tseg[1],
  160.                                            tx, ty);
  161.                             working.lineTo(x, y);
  162.                         } else {
  163.                             working.moveTo(x, y);
  164.                             working.lineTo(tx, ty);
  165.                             working.quadTo(tseg[0], tseg[1],
  166.                                            tseg[2], tseg[3]);
  167.                             working.lineTo(seg[2], seg[3]);
  168.                             working.quadTo(seg[0], seg[1],
  169.                                            x, y);
  170.                         }
  171.                 
  172.                         x = seg[2];
  173.                         y = seg[3];
  174.                         tx = tseg[2];
  175.                         ty = tseg[3];
  176.                         break;
  177.         
  178.                 case PathIterator.SEG_CUBICTO:
  179.                         at.transform(seg, 0, tseg, 0, 3);
  180.                         if (Line2D.relativeCCW(x, y, tx, ty,
  181.                                                seg[4], seg[5]) < 0) {
  182.                             working.moveTo(x, y);
  183.                             working.curveTo(seg[0], seg[1],
  184.                                             seg[2], seg[3],
  185.                                             seg[4], seg[5]);
  186.                             working.lineTo(tseg[4], tseg[5]);
  187.                             working.curveTo(tseg[2], tseg[3],
  188.                                             tseg[0], tseg[1],
  189.                                             tx, ty);
  190.                             working.lineTo(x, y);
  191.                         } else {
  192.                             working.moveTo(x, y);
  193.                             working.lineTo(tx, ty);
  194.                             working.curveTo(tseg[0], tseg[1],
  195.                                             tseg[2], tseg[3],
  196.                                             tseg[4], tseg[5]);
  197.                             working.lineTo(seg[4], seg[5]);
  198.                             working.curveTo(seg[2], seg[3],
  199.                                             seg[0], seg[1],
  200.                                             x, y);
  201.                         }
  202.                 
  203.                         x = seg[4];
  204.                         y = seg[5];
  205.                         tx = tseg[4];
  206.                         ty = tseg[5];
  207.                         break;
  208.         
  209.                 case PathIterator.SEG_CLOSE:
  210.                         if (Line2D.relativeCCW(x, y, tx, ty,
  211.                                                cx, cy) < 0) {
  212.                             working.moveTo(x, y);
  213.                             working.lineTo(cx, cy);
  214.                             working.lineTo(tcx, tcy);
  215.                             working.lineTo(tx, ty);
  216.                             working.lineTo(x, y);
  217.                         } else {
  218.                             working.moveTo(x, y);
  219.                             working.lineTo(tx, ty);
  220.                             working.lineTo(tcx, tcy);
  221.                             working.lineTo(cx, cy);
  222.                             working.lineTo(x, y);
  223.                         }
  224.                         x = cx; 
  225.                         y = cy;
  226.                         tx = tcx;
  227.                         ty = tcy;
  228.             }
  229.             pi.next();
  230.         } // while
  231.         ribbon = working;
  233.         g2.setComposite(AlphaComposite.SrcOver);
  234.         Rectangle r = shape.getBounds();
  235.         g2.translate(w*.5-r.width*.5,h*.5+r.height*.5);
  237.         g2.setColor(Color.blue);
  238.         g2.fill(tshape);
  239.         g2.setColor(new Color(255, 255, 255, 200));
  240.         g2.fill(ribbon);
  242.         g2.setColor(Color.white);
  243.         g2.fill(shape);
  245.         g2.setColor(Color.blue);
  246.         g2.draw(shape);
  247.     }
  250.     public static void main(String argv[]) {
  251.         Frame f = new Frame("Java2D Demo - Stars3D");
  252.         f.addWindowListener(new WindowAdapter() {
  253.             public void windowClosing(WindowEvent e) {System.exit(0);}
  254.         });
  255.         f.add("Center", new DemoPanel(new Stars3D()));
  256.         f.pack();
  257.         f.setSize(new Dimension(400,300));
  258.         f.show();
  259.     }
  262.     static class DemoControls extends JPanel implements ActionListener, Runnable {
  264.         Stars3D demo;
  265.         JTextField tf1, tf2;
  266.         Thread thread;
  268.         public DemoControls(Stars3D demo) {
  269.             this.demo = demo;
  270.             setBackground(Color.gray);
  271.             JLabel l = new JLabel("  Text:");
  272.             l.setForeground(Color.black);
  273.             add(l);
  274.             add(tf1 = new JTextField(demo.text));
  275.             tf1.setPreferredSize(new Dimension(60,20));
  276.             tf1.addActionListener(this);
  277.             l = new JLabel("  Size:");
  278.             l.setForeground(Color.black);
  279.             add(l);
  280.             add(tf2 = new JTextField(String.valueOf(demo.fontSize)));
  281.             tf2.setPreferredSize(new Dimension(30,20));
  282.             tf2.addActionListener(this);
  283.             addMouseListener(new MouseAdapter() {
  284.                 public void mouseClicked(MouseEvent e) {
  285.                     if (thread == null) start(); else stop();
  286.                 }
  287.             });
  288.         }
  290.         public void actionPerformed(ActionEvent e) {
  291.             try { 
  292.                 if (e.getSource().equals(tf1)) {
  293.                     demo.text = tf1.getText().trim();
  294.                 } else if (e.getSource().equals(tf2)) {
  295.                     demo.fontSize = Integer.parseInt(tf2.getText().trim());
  296.                     if (demo.fontSize < 10) {
  297.                         demo.fontSize = 10;
  298.                     }
  299.                 }
  300.                 demo.repaint();
  301.             } catch (Exception ex) {}
  302.         }
  304.         public Dimension getPreferredSize() {
  305.             return new Dimension(200,32);
  306.         }
  309.         public void start() {
  310.             if (thread != null) {
  311.                 return;
  312.             }
  313.             thread = new Thread(this);
  314.             thread.setPriority(Thread.MIN_PRIORITY);
  315.             thread.setName("Mix.Stars3D DemoControls Thread");
  316.             thread.start();
  317.         }
  320.         public synchronized void stop() {
  321.             if (thread != null) {
  322.                 thread.interrupt();
  323.             }
  324.             thread = null;
  325.             notifyAll();
  326.         }
  329.         public void run() {
  330.             Thread me = Thread.currentThread();
  331.             try { thread.sleep(999); } catch (Exception e) { return; }
  332.             int width = getSize().width;
  333.             int size[] = { (int)(width*.25), (int)(width*.35)};
  334.             String str[] = { "JAVA", "J2D" };
  335.             while (thread == me) {
  336.                 for (int i = 0; i < 2; i++) {
  337.                     demo.fontSize = size[i];
  338.                     tf2.setText(String.valueOf(demo.fontSize));
  339.                     tf1.setText(demo.text = str[i]);
  340.                     demo.repaint();
  341.                     try {
  342.                         thread.sleep(5555);
  343.                     } catch (InterruptedException e) { return; }
  344.                 }
  345.             }
  346.             thread = null;
  347.         }
  348.     } // End DemoControls
  349. } // End Stars3D