shapepanel.java

一个J2SE的简单入门

/*
 * Created on 2005-9-1
 *
 * TODO To change the template for this generated file go to
 * Window - Preferences - Java - Code Style - Code Templates
 */

/**
 * @author gerally
 *
 * TODO To change the template for this generated type comment go to
 * Window - Preferences - Java - Code Style - Code Templates
 */
import java.awt.*;
import java.awt.event.*;
import java.awt.geom.*;
import java.util.*;
import javax.swing.*;
public class ShapePanel extends JPanel {
	
	public ShapePanel()
	   {  
	      addMouseListener(new
	         MouseAdapter()
	         {
	            public void mousePressed(MouseEvent event)
	            {  
	               Point p = event.getPoint();
	               for (int i = 0; i < points.length; i++)
	               {  
	                  double x = points[i].getX() - SIZE / 2;
	                  double y = points[i].getY() - SIZE / 2;
	                  Rectangle2D r 
	                     = new Rectangle2D.Double(x, y, SIZE, SIZE);
	                  if (r.contains(p))
	                  {  
	                     current = i;
	                     return;
	                  }
	               }
	            }

	            public void mouseReleased(MouseEvent event)
	            {  
	               current = -1;
	            }
	         });
	      addMouseMotionListener(new 
	         MouseMotionAdapter()
	         {
	            public void mouseDragged(MouseEvent event)
	            {  
	               if (current == -1) return;
	               points[current] = event.getPoint();
	               repaint();
	            }
	         });
	      current = -1;
	   }

	   /**
	      Set a shape maker and initialize it with a random 
	      point set.
	      @param aShapeMaker a shape maker that defines a shape
	      from a point set
	   */      
	   public void setShapeMaker(ShapeMaker aShapeMaker)
	   {  
	   	  shapeMaker = aShapeMaker;
	      int n = shapeMaker.getPointCount();
	      points = new Point2D[n];
	      for (int i = 0; i < n; i++)
	      {  
	         double x = generator.nextDouble() * getWidth();
	         double y = generator.nextDouble() * getHeight();
	         points[i] = new Point2D.Double(x, y);
	      }
	      repaint();
	   }

	   public void paintComponent(Graphics g)
	   {  
	      super.paintComponent(g);
	      if (points == null) return;
	      Graphics2D g2 = (Graphics2D)g;
	      for (int i = 0; i < points.length; i++)
	      {  double x = points[i].getX() - SIZE / 2;
	         double y = points[i].getY() - SIZE / 2;
	         g2.fill(new Rectangle2D.Double(x, y, SIZE, SIZE));
	      }

	      g2.draw(shapeMaker.makeShape(points));
	   }

	   private Point2D[] points;
	   private static Random generator = new Random();
	   private static int SIZE = 10;
	   private int current;
	   private ShapeMaker shapeMaker;
	}


abstract class ShapeMaker
{  
   /**
      Constructs a shape maker.
      @param aPointCount the number of points needed to define
      this shape.
   */
   public ShapeMaker(int aPointCount)
   {  
      pointCount = aPointCount;
   }

   /**
      Gets the number of points needed to define this shape.
      @return the point count
   */
   public int getPointCount()
   {  
      return pointCount;
   }

   /**
      Makes a shape out of the given point set.
      @param p the points that define the shape
      @return the shape defined by the points
   */
   public abstract Shape makeShape(Point2D[] p);

   public String toString()
   {  
      return getClass().getName();
   }

   private int pointCount;
}
class RoundRectangleMaker extends ShapeMaker
{  
   public RoundRectangleMaker() 
   { 
	   super(2); 
   }

   public Shape makeShape(Point2D[] p)
   {  
      RoundRectangle2D s
         = new RoundRectangle2D.Double(0, 0, 0, 0, 20, 20);
      s.setFrameFromDiagonal(p[0], p[1]);
      return s;
   }
}
class LineMaker extends ShapeMaker
{  
   public LineMaker() { super(2); }

   public Shape makeShape(Point2D[] p)
   {  
      return new Line2D.Double(p[0], p[1]);
   }
}

/**
   Makes a line that joins two given corner points.
*/
class RectangleMaker extends ShapeMaker
{  
   public RectangleMaker() { super(2); }

   public Shape makeShape(Point2D[] p)
   {  
      Rectangle2D s = new Rectangle2D.Double();
      s.setFrameFromDiagonal(p[0], p[1]);
      return s;
   }
}

/**
   Makes a round rectangle that joins two given corner points.
*/
/*class RoundRectangleMaker extends ShapeMaker
{  
   public RoundRectangleMaker() { super(2); }

   public Shape makeShape(Point2D[] p)
   {  
      RoundRectangle2D s
         = new RoundRectangle2D.Double(0, 0, 0, 0, 20, 20);
      s.setFrameFromDiagonal(p[0], p[1]);
      return s;
   }
}*/

/**
   Makes an ellipse contained in a bounding box with two given 
   corner points.
*/
class EllipseMaker extends ShapeMaker
{  
   public EllipseMaker() { super(2); }

   public Shape makeShape(Point2D[] p)
   {  
      Ellipse2D s = new Ellipse2D.Double();
      s.setFrameFromDiagonal(p[0], p[1]);
      return s;
   }
}

/**
   Makes an arc contained in a bounding box with two given 
   corner points, and with starting and ending angles given
   by lines emanating from the center of the bounding box and
   ending in two given points. To show the correctness of 
   the angle computation, the returned shape contains the arc,
   the bounding box, and the lines.
*/
class ArcMaker extends ShapeMaker
{  
   public ArcMaker() { super(4); }

   public Shape makeShape(Point2D[] p)
   {  
      double centerX = (p[0].getX() + p[1].getX()) / 2;
      double centerY = (p[0].getY() + p[1].getY()) / 2;
      double width = Math.abs(p[1].getX() - p[0].getX());
      double height = Math.abs(p[1].getY() - p[0].getY());

      double distortedStartAngle
         = Math.toDegrees(Math.atan2(-(p[2].getY() - centerY)
            * width, (p[2].getX() - centerX) * height));
      double distortedEndAngle
         = Math.toDegrees(Math.atan2(-(p[3].getY() - centerY)
            * width, (p[3].getX() - centerX) * height));
      double distortedAngleDifference
         = distortedEndAngle - distortedStartAngle;
      if (distortedStartAngle < 0)
         distortedStartAngle += 360;
      if (distortedAngleDifference < 0)
         distortedAngleDifference += 360;

      Arc2D s = new Arc2D.Double(0, 0, 0, 0,
         distortedStartAngle, distortedAngleDifference,
         Arc2D.OPEN);
      s.setFrameFromDiagonal(p[0], p[1]);

      GeneralPath g = new GeneralPath();
      g.append(s, false);
      Rectangle2D r = new Rectangle2D.Double();
      r.setFrameFromDiagonal(p[0], p[1]);
      g.append(r, false);
      Point2D center = new Point2D.Double(centerX, centerY);
      g.append(new Line2D.Double(center, p[2]), false );
      g.append(new Line2D.Double(center, p[3]), false );
      return g;
   }
}

/**
   Makes a polygon defined by six corner points.
*/
class PolygonMaker extends ShapeMaker
{  
   public PolygonMaker() { super(6); }

   public Shape makeShape(Point2D[] p)
   {  
      GeneralPath s = new GeneralPath();
      s.moveTo((float)p[0].getX(), (float)p[0].getY());
      for (int i = 1; i < p.length; i++)
         s.lineTo((float)p[i].getX(), (float)p[i].getY());
      s.closePath();
      return s;
   }
}

/**
   Makes a quad curve defined by two end points and a control 
   point.
*/
class QuadCurveMaker extends ShapeMaker
{  
   public QuadCurveMaker() { super(3); }

   public Shape makeShape(Point2D[] p)
   {  
      return new QuadCurve2D.Double(p[0].getX(), p[0].getY(),
         p[1].getX(), p[1].getY(), p[2].getX(), p[2].getY());
   }
}

/**
   Makes a cubic curve defined by two end points and two control
   points.
*/
class CubicCurveMaker extends ShapeMaker
{  
   public CubicCurveMaker() { super(4); }

   public Shape makeShape(Point2D[] p)
   {  
      return new CubicCurve2D.Double(p[0].getX(), p[0].getY(),
         p[1].getX(), p[1].getY(), p[2].getX(), p[2].getY(),
         p[3].getX(), p[3].getY());
   }
}