home *** CD-ROM | disk | FTP | other *** search
/ The Net: Ultimate Internet Guide / WWLCD1.ISO / pc / java / prmjatgt / viewdraw.java < prev    next >
Encoding:
Java Source  |  1996-08-14  |  16.7 KB  |  716 lines
  1. import java.awt.*;
  2. import java.applet.*;
  3. import java.util.*;
  4. import java.io.*;
  5. import java.net.*;
  6.  
  7. import objTank;
  8.  
  9. /**
  10.  * A applet that shows drawing
  11.  *
  12.  * @version     1.0 03/24/96
  13.  * @author         Kang, Dae Woong (namu@star.elim.net)
  14.  */
  15. public class ViewDraw extends Applet 
  16. {
  17.     Dimension dimension = new Dimension(0, 0);
  18.     String comment = new String();
  19.     Vector drawVector = new Vector();
  20.     Vector objVector = new Vector();
  21.  
  22.     Image offImage; // for double buffering
  23.     Graphics offGraphics;
  24.  
  25.     static final int CHART_ID = 0x3140;
  26.     static final int CHART_VERSION = 0x0100;
  27.  
  28.     static Applet me;
  29.  
  30.     /**
  31.      * Load Draw File
  32.      */
  33.     public void init() // load draw file
  34.     {
  35.         String fileName = getParameter("draw");
  36.  
  37.         if (fileName == null)
  38.             return;
  39.         showStatus("Loading : " + fileName);
  40.         me = this;
  41.  
  42.         URL  url = null;
  43.         try
  44.         {
  45.             url =  new URL(getDocumentBase(), fileName);
  46.         }
  47.         catch (MalformedURLException e)
  48.         {
  49.             System.err.println(fileName + " document not found" + e);
  50.             return;
  51.         }
  52.  
  53.         try
  54.         {
  55.             DataInputStream dis= new DataInputStream(url.openStream());
  56.  
  57.             int count;
  58.             int str_len; // string len
  59.             byte[] str_byte; // string buf
  60.  
  61.             if (CHART_ID !=  dis.readShort())
  62.                 throw (new IOException("This is not draw file"));
  63.  
  64.             if (CHART_VERSION !=  dis.readShort())
  65.                 throw (new IOException("This is invalid version draw file"));
  66.  
  67.             str_len = dis.readByte();
  68.             str_byte = new byte[str_len];
  69.             dis.readFully(str_byte);
  70.             comment = new String(str_byte, 0);
  71.  
  72.             dimension.width = dis.readShort();
  73.             dimension.height = dis.readShort();
  74.         
  75.             count = dis.readShort();
  76.             for (int i = 0 ; i < count; i++)
  77.             {
  78.                 ObjTank obj = new ObjTank();
  79.                 obj.read(dis, this);
  80.                 objVector.addElement(obj);
  81.             }
  82.             
  83.             count = dis.readShort();
  84.             for (int i = 0 ; i < count; i++)
  85.             {
  86.                 MiniDraw dd = new MiniDraw();
  87.                 dd.read(dis, objVector);
  88.                 drawVector.addElement(dd);
  89.             }
  90.         }
  91.         catch (IOException ioeRead)
  92.         {
  93.             System.out.println(ioeRead);
  94.             return;
  95.         }
  96.         showStatus(comment + "(" + dimension.width + "x" + dimension.height + ")");
  97.     }
  98.  
  99.     public void paint(Graphics g)
  100.     {
  101.         update(g);
  102.     }
  103.  
  104.     public void update(Graphics g)
  105.     {
  106.         Rectangle clipRect = g.getClipRect();
  107.         offGraphics.setColor(getBackground());
  108.         offGraphics.fillRect(clipRect.x, clipRect.y, clipRect.width, clipRect.height);
  109.  
  110.         Enumeration enum = drawVector.elements();
  111.         while (enum.hasMoreElements())
  112.             ((MiniDraw) enum.nextElement()).draw(offGraphics);
  113.         g.drawImage(offImage, 0, 0, null);
  114.     }
  115.  
  116.     public boolean mouseDown(Event e, int x, int y)
  117.     {
  118.         Enumeration enum = drawVector.elements();
  119.         MiniDraw dd;
  120.         while (enum.hasMoreElements())
  121.         {
  122.             dd = (MiniDraw) enum.nextElement();
  123.             if (dd.inside(x, y) && dd.hasURL())
  124.             {
  125.                 URL url= null;
  126.                 try 
  127.                     url = new URL(dd.urlName);
  128.                 catch (MalformedURLException mue1)
  129.                 {
  130.                     try 
  131.                         url = new URL(getDocumentBase(), dd.urlName);
  132.                     catch (MalformedURLException mue2)
  133.                         ;
  134.                 }
  135.                     
  136.                 if (url != null)
  137.                     getAppletContext().showDocument(url);
  138.                 return true;
  139.             }
  140.         }
  141.         showStatus(comment + "(" + dimension.width + "x" + dimension.height + ")");
  142.         return true;
  143.     }
  144.  
  145.     public boolean mouseMove(Event e, int x, int y)
  146.     {
  147.         Enumeration enum = drawVector.elements();
  148.         MiniDraw dd;
  149.         while (enum.hasMoreElements())
  150.         {
  151.             dd = (MiniDraw) enum.nextElement();
  152.             if (dd.inside(x, y) && dd.hasURL())
  153.             {
  154.                 showStatus(dd.urlName);
  155.                 return true;
  156.             }
  157.         }
  158.         
  159.         return true;
  160.     }
  161.  
  162.     public void layout()
  163.     {
  164.         Dimension dm = size();
  165.  
  166.         if (dm.width != 0 && dm.height != 0)
  167.         {        
  168.             offImage = createImage(dm.width, dm.height); 
  169.             offGraphics = offImage.getGraphics();
  170.         }
  171.     }
  172.  
  173.     public String[][] getParameterInfo()
  174.     {
  175.          String pinfo[][] = 
  176.          {
  177.            {"draw",  "String",    "draw file to show"},
  178.          };
  179.          return pinfo;
  180.     }
  181.  
  182.     public String getAppletInfo()
  183.     {
  184.         return new String("Web Draw 1.0  Author:Kang, Daewoong");
  185.     }
  186. }
  187.  
  188.  
  189. /**
  190.  * subset of Draw For viewonly
  191.  * @see : Draw
  192.  */
  193. class MiniDraw extends Rectangle
  194. {
  195.     int method;
  196.     int content;
  197.     int shape;
  198.     Color color = new Color(0);
  199.     Vector intParams = null;
  200.  
  201.     double lineAngle = 0;
  202.  
  203.     int fontStyle;
  204.     String fontName = null;
  205.     String text = null;
  206.  
  207.     String urlName = null;
  208.  
  209.     // used OBJECT Drawing
  210.     ObjTank objTank;
  211.     //draw method ======================
  212.     static final int LINE = 0;
  213.     static final int RECT = 1;
  214.     static final int ROUND_RECT = 2;
  215.     static final int POLYGON = 3;
  216.     static final int OVAL = 4;
  217.     static final int PIE = 5;
  218.     static final int ARC = 6;
  219.     static final int STRING = 7;
  220.     static final int IMAGE = 8;
  221.     static final int CHART = 9;
  222.     static final int SELECT = 10;
  223.     static final int ANCHOR = 11;
  224.     //draw content ======================
  225.     static final int CONTENT_FILL = 0;
  226.     static final int CONTENT_UNFILL = 1;
  227.     //draw shape =========================
  228.     static final int SHAPE_PLAIN = 0;
  229.     static final int SHAPE_UP =    1;
  230.     static final int SHAPE_DOWN =  2;
  231.  
  232.     static final int INVALID_PARAM = 0x7FFFFFFF;
  233.  
  234.     public MiniDraw()
  235.     {
  236.     }
  237.  
  238.     public void read(DataInputStream dis, Vector obj) throws IOException
  239.     {
  240.         
  241.         try 
  242.         {
  243.             x = dis.readShort();
  244.             y = dis.readShort();
  245.             width = dis.readShort();
  246.             height = dis.readShort();
  247.  
  248.             method = dis.readByte();
  249.             shape = dis.readByte();
  250.             content = dis.readByte();
  251.             color = new Color(dis.readInt());
  252.  
  253.             int count = dis.readShort();
  254.             for (int i = 0; i < count; i++)
  255.                 addParam(dis.readShort() );
  256.  
  257.             if (method == STRING)
  258.             {
  259.                 int len;
  260.                 byte[] buf;
  261.  
  262.                 fontStyle = dis.readInt();                
  263.                 
  264.                 len = dis.readByte();
  265.                 buf = new byte[len];                
  266.                 dis.readFully(buf);
  267.                 fontName = new String(buf, 0);
  268.                             
  269.                 len = dis.readByte();
  270.                 buf = new byte[len];                
  271.                 dis.readFully(buf);
  272.                 text = new String(buf, 0);
  273.             }
  274.  
  275.             if (method == IMAGE || method == CHART)
  276.             {
  277.                 int index = dis.readShort();
  278.                 if (obj != null)
  279.                 {
  280.                     objTank = (ObjTank) obj.elementAt(index);
  281.                 }
  282.             }
  283.  
  284.             int len;
  285.             len = dis.readByte();
  286.             if (len > 0)
  287.             {
  288.                 byte[] buf = new byte[len];                
  289.                 dis.readFully(buf);
  290.                 urlName = new String(buf, 0);
  291.             }
  292.  
  293.             if (method == LINE)
  294.                 setLineAngle();
  295.  
  296.         }
  297.         catch (IOException ioe)
  298.             throw ioe;
  299.     }
  300.  
  301.     public int getPointsCount()
  302.     {
  303.         switch (method)
  304.         {
  305.         case LINE:
  306.         case POLYGON:
  307.             return getParaCount()/2;
  308.         case ROUND_RECT: return 1;
  309.         case PIE:
  310.         case ARC:
  311.             return 2;
  312.         default: return 0;
  313.         }
  314.     }
  315.  
  316.         
  317.     public int getFontSize()
  318.     {
  319.         return height*4/5;
  320.     }
  321.  
  322.     public void addParam(int p)
  323.     {
  324.         if (intParams == null)
  325.             intParams = new Vector();
  326.         intParams.addElement(new Integer(p));
  327.     }
  328.     public boolean isYNearAngle(int i) // is it near y line?
  329.     {
  330.         double angle = (getParam(i + 2) == getParam(i)) ? Math.PI/2 : Math.atan((double)(getParam(i + 3) - getParam(i + 1))/(getParam(i + 2) - getParam(i)));
  331.         return angle > Math.PI/4  || angle < -Math.PI/4;
  332.     }
  333.  
  334.     public boolean isTopLeftAngle(int angle)
  335.     {
  336.         angle %= 360;
  337.         return angle >= 45 && angle < 225;
  338.     }
  339.  
  340.     public int bottom() { return y + height; }
  341.     public int right()  { return x + width; }
  342.     public Point getCenterPoint() {    return new Point(x + width/2, y + height/2); }
  343.     public boolean hasText()
  344.     {
  345.         return text != null && text.length() > 0;
  346.     }
  347.  
  348.     public boolean hasURL()
  349.     {
  350.         return urlName != null && urlName.length() > 0;
  351.     }
  352.  
  353.     public int getParaCount()
  354.     {
  355.         return intParams.size();
  356.     }
  357.  
  358.     public void drawAngleLine(Graphics g, int angle)
  359.     {
  360.         Point pt = getCenterPoint();
  361.         double a = angle / 180.0 * Math.PI;
  362.         
  363.         g.drawLine(pt.x, pt.y, pt.x + (int)(width/2*Math.cos(a)), pt.y - (int)(height/2*Math.sin(a)));
  364.     }
  365.  
  366.     public Polygon getPolygon()
  367.     {
  368.         Polygon plg = new Polygon();
  369.         
  370.         Enumeration e = intParams.elements();
  371.         while (e.hasMoreElements())
  372.             plg.addPoint(((Integer) e.nextElement()).intValue(), ((Integer) e.nextElement()).intValue());
  373.  
  374.         return plg;
  375.     }
  376.  
  377.     public void setLineAngle()
  378.     {
  379.         lineAngle = (getParam(2) == getParam(0)) ? Math.PI/2 : Math.atan((double)(getParam(3) - getParam(1))/(getParam(2) - getParam(0)));
  380.     }
  381.     public boolean is3D()
  382.     {
  383.         return shape != SHAPE_PLAIN;
  384.     }
  385.  
  386.     public boolean isFill()
  387.     {
  388.         return content == CONTENT_FILL;
  389.     }
  390.  
  391.     /** 
  392.     * index of param
  393.     * if error return INVALID_PARAM
  394.     */
  395.     public int getParam(int i)
  396.     {
  397.         try
  398.         {
  399.             return ((Integer) intParams.elementAt(i)).intValue();
  400.         }
  401.         catch (ArrayIndexOutOfBoundsException e)
  402.         {
  403.             System.err.println("Draw.getParam invalide index :" + i);
  404.             return INVALID_PARAM;
  405.         } 
  406.     }
  407.     public void draw(Graphics g)
  408.     {
  409.         Color clrTopLeft = null, clrBottomRight = null;
  410.         if (shape == SHAPE_UP)
  411.         {
  412.             clrTopLeft = color.brighter();
  413.             clrBottomRight = color.darker();
  414.         }
  415.         else if (shape == SHAPE_DOWN)
  416.         {
  417.             clrTopLeft = color.darker();
  418.             clrBottomRight = color.brighter();
  419.         }
  420.  
  421.         switch (method)
  422.         {
  423.         case LINE:
  424.             g.setColor(color);
  425.             g.drawLine(getParam(0), getParam(1), getParam(2), getParam(3));
  426.             if (is3D())
  427.             {
  428.                 if (lineAngle > Math.PI / 4 || lineAngle < -Math.PI / 4)
  429.                 {
  430.                     g.setColor(clrTopLeft);
  431.                     g.drawLine(getParam(0) - 1, getParam(1), getParam(2) - 1, getParam(3));
  432.                     g.setColor(clrBottomRight);
  433.                     g.drawLine(getParam(0) + 1, getParam(1), getParam(2) + 1, getParam(3));
  434.                 }
  435.                 else
  436.                 {
  437.                     g.setColor(clrTopLeft);
  438.                     g.drawLine(getParam(0), getParam(1) - 1, getParam(2), getParam(3) - 1);
  439.                     g.setColor(clrBottomRight);
  440.                     g.drawLine(getParam(0), getParam(1) + 1, getParam(2), getParam(3) + 1);
  441.                 }
  442.             }
  443.             break;
  444.         case RECT:
  445.             g.setColor(color);
  446.             if (isFill())
  447.             {
  448.                 g.fillRect(x, y, width, height);
  449.             }
  450.             switch (shape)
  451.             {
  452.             case SHAPE_PLAIN:
  453.                 if (!isFill())
  454.                     g.drawRect(x, y, width, height);
  455.                 break;
  456.             case SHAPE_UP:
  457.                 g.draw3DRect(x, y, width, height, true);
  458.                 break;
  459.             case SHAPE_DOWN:
  460.                 g.draw3DRect(x, y, width, height, false);
  461.                 break;
  462.             }
  463.             break;
  464.         case ROUND_RECT:
  465.             if (isFill())
  466.             {
  467.                 g.setColor(color);
  468.                 g.fillRoundRect(x, y, width, height, getParam(0), getParam(1));
  469.             }
  470.  
  471.             if (is3D())
  472.             {
  473.                 Rectangle rcCorner = new Rectangle(x, y + height - getParam(1), getParam(0), getParam(1));
  474.                                      // bottom left corner
  475.                 int wid = rcCorner.width/2;
  476.                 int hgt = rcCorner.height/2;
  477.                 
  478.                 g.setColor(clrBottomRight);
  479.                 g.drawArc(rcCorner.x, rcCorner.y, rcCorner.width, rcCorner.height, 225, 45);
  480.                 g.setColor(clrTopLeft);
  481.                 g.drawArc(rcCorner.x, rcCorner.y, rcCorner.width, rcCorner.height, 180, 45); 
  482.  
  483.                 g.drawLine(x, bottom() - hgt, x, y + hgt); // left line
  484.                 
  485.                 g.drawArc(x, y, rcCorner.width, rcCorner.height, 90, 90); // top left corner
  486.                 
  487.                 // top right corner
  488.                 rcCorner.move(right() - rcCorner.width, y); 
  489.                 g.drawLine(x + wid, y, right() - wid, y); // top line
  490.                 g.drawArc(rcCorner.x, rcCorner.y, rcCorner.width, rcCorner.height, 45, 45); 
  491.                 g.setColor(clrBottomRight);
  492.                 g.drawArc(rcCorner.x, rcCorner.y, rcCorner.width, rcCorner.height,  0, 45); 
  493.                 
  494.                 // bottom right corner 
  495.                 g.drawLine(right(), y + hgt, right(), bottom() - hgt); // right line
  496.                 g.drawArc(right() - rcCorner.width, bottom() - rcCorner.height, rcCorner.width, rcCorner.height, 270, 90); // bottom right corner
  497.  
  498.                 g.drawLine(right() - rcCorner.width/2, bottom(), x + rcCorner.width/2, bottom()); // bottom line
  499.             }
  500.             else
  501.             {
  502.                 if (!isFill())
  503.                 {
  504.                     g.setColor(color);
  505.                     g.drawRoundRect(x, y, width, height, getParam(0), getParam(1));
  506.                 }
  507.             }
  508.             break;
  509.         case POLYGON:
  510.             if (isFill())
  511.             {
  512.                 g.setColor(color);
  513.                 if (getPointsCount() > 2)
  514.                     g.fillPolygon(getPolygon());
  515.                 else
  516.                     g.drawPolygon(getPolygon());
  517.                 if (is3D())
  518.                 {
  519.                     int count = getParaCount() - 2;
  520.                     int i = 0;
  521.                     while (i < count)
  522.                     {
  523.                         g.setColor
  524.                         (
  525.                           (  
  526.                               (getParam(i + 3) >  getParam(i + 1)) ||
  527.                             ( (getParam(i + 3) == getParam(i + 1)) && (getParam(i + 2) < getParam(i)) )
  528.                           )    ? clrBottomRight : clrTopLeft
  529.                         );
  530.                         g.drawLine(getParam(i), getParam(i + 1), getParam(i + 2), getParam(i + 3));
  531.                         i += 2;
  532.                     }
  533.                     //close line
  534.                     g.setColor
  535.                     (
  536.                       (  
  537.                           (getParam(1) >  getParam(i + 1)) ||
  538.                         ( (getParam(1) == getParam(i + 1)) && (getParam(0) < getParam(i)) )
  539.                       )    ? clrBottomRight : clrTopLeft
  540.                     );
  541.                     g.drawLine(getParam(i), getParam(i + 1), getParam(0), getParam(1));
  542.                 }
  543.             }
  544.             else
  545.             {
  546.                 if (is3D())
  547.                 {
  548.                     int count = getParaCount() - 2;
  549.                     int i = 0;
  550.                     while (i < count)
  551.                     {
  552.                         if (isYNearAngle(i))
  553.                         {
  554.                             g.setColor(clrTopLeft);
  555.                             g.drawLine(getParam(i) - 1, getParam(i + 1), getParam(i + 2) - 1, getParam(i + 3));
  556.                             g.setColor(clrBottomRight);
  557.                             g.drawLine(getParam(i) + 1, getParam(i + 1), getParam(i + 2) + 1, getParam(i + 3));
  558.                         }
  559.                         else
  560.                         {
  561.                             g.setColor(clrTopLeft);
  562.                             g.drawLine(getParam(i), getParam(i + 1) - 1, getParam(i + 2), getParam(i + 3) - 1);
  563.                             g.setColor(clrBottomRight);
  564.                             g.drawLine(getParam(i), getParam(i + 1) + 1, getParam(i + 2), getParam(i + 3) + 1);
  565.                         }
  566.                         i += 2;
  567.                     }
  568.                 }
  569.                 g.setColor(color);
  570.                 g.drawPolygon(getPolygon());
  571.             }
  572.             break;
  573.         case OVAL:
  574.             if (isFill())
  575.             {
  576.                 g.setColor(color);
  577.                 g.fillOval(x, y, width, height);
  578.             }
  579.  
  580.             if (is3D())
  581.             {
  582.                 g.setColor(clrTopLeft);
  583.                 g.drawArc(x, y, width, height, 45, 180);
  584.                 g.setColor(clrBottomRight);
  585.                 g.drawArc(x, y, width, height, 225, 180);
  586.             }
  587.             else
  588.             {
  589.                 if (!isFill())
  590.                 {
  591.                     g.setColor(color);
  592.                     g.drawOval(x, y, width, height);
  593.                 }
  594.             }
  595.             break;
  596.         case PIE:
  597.             if (isFill())
  598.             {
  599.                 g.setColor(color);
  600.                 g.fillArc(x, y, width, height, getParam(0), getParam(1));
  601.             }
  602.             if (is3D())
  603.             {
  604.                 int[] angleSep = { 45, 225, 405, 585, 765};
  605.                 int angleCur = getParam(0);
  606.                 int angleEnd = angleCur + getParam(1);
  607.                 int angleSize = 0;
  608.                 int i = (angleCur + 135) / 180;
  609.  
  610.                 // start line
  611.                 g.setColor( isTopLeftAngle(angleCur + 90) ? clrBottomRight : clrTopLeft);
  612.                 drawAngleLine(g, getParam(0));
  613.  
  614.                 while (angleCur < angleEnd)
  615.                 {
  616.                     angleSize = ((angleSep[i] >= angleEnd) ? angleEnd : angleSep[i]) - angleCur;
  617.  
  618.                     g.setColor( isTopLeftAngle(angleCur) ? clrTopLeft : clrBottomRight);
  619.                     g.drawArc(x, y, width, height, angleCur, angleSize);
  620.  
  621.                     angleCur = angleSep[i++];
  622.                 }
  623.  
  624.                 // end line
  625.                 g.setColor( isTopLeftAngle(getParam(0) + getParam(1) + 90) ? clrTopLeft : clrBottomRight);
  626.                 drawAngleLine(g, getParam(0) + getParam(1));
  627.  
  628.             }
  629.             else
  630.             {
  631.                 if (!isFill())
  632.                 {
  633.                     g.setColor(color);
  634.                     g.drawArc(x, y, width, height, getParam(0), getParam(1));
  635.                     drawAngleLine(g, getParam(0));
  636.                     drawAngleLine(g, getParam(0) + getParam(1));
  637.                 }
  638.             }
  639.  
  640.             break;
  641.         case ARC:
  642.             g.setColor(color);
  643.             g.drawArc(x, y, width, height, getParam(0), getParam(1));
  644.             if (is3D())
  645.             {
  646.                 int[] angleSep = { 45, 225, 405, 585, 765};
  647.                 int angleCur = getParam(0);
  648.                 int angleEnd = angleCur + getParam(1);
  649.                 int angleSize = 0;
  650.                 int i = (angleCur + 135) / 180;
  651.  
  652.                 while (angleCur < angleEnd)
  653.                 {
  654.                     angleSize = ((angleSep[i] >= angleEnd) ? angleEnd : angleSep[i]) - angleCur;
  655.  
  656.                     if ((angleCur % 360) >= 45 && (angleCur % 360) <  225)
  657.                     {
  658.                         g.setColor(clrTopLeft);
  659.                         g.drawArc(x - 1, y - 1, width + 2, height + 2, angleCur, angleSize);
  660.                         g.setColor(clrBottomRight);
  661.                         g.drawArc(x + 1, y + 1, width - 2, height - 2, angleCur, angleSize);
  662.                     }
  663.                     else
  664.                     {
  665.                         g.setColor(clrBottomRight);
  666.                         g.drawArc(x - 1, y - 1, width + 2, height + 2, angleCur, angleSize);
  667.                         g.setColor(clrTopLeft);
  668.                         g.drawArc(x + 1, y + 1, width - 2, height - 2, angleCur, angleSize);
  669.                     }
  670.                     
  671.                     angleCur = angleSep[i++];
  672.                 }
  673.             }
  674.             break;
  675.         case STRING:
  676.             if (hasText())
  677.             {
  678.                 g.setFont( new Font(fontName, fontStyle, getFontSize()) );
  679.                 if (is3D())
  680.                 {
  681.                     g.setColor(clrTopLeft);
  682.                     g.drawString(text, x - 1, y + getFontSize() - 1);
  683.                     g.setColor(clrBottomRight);
  684.                     g.drawString(text, x + 1, y + getFontSize() + 1);
  685.                 }
  686.                 g.setColor(color);
  687.                 g.drawString(text, x, y + getFontSize());
  688.  
  689.             }
  690.             break;
  691.         case IMAGE:
  692.             if (objTank.image != null)
  693.                 g.drawImage(objTank.image, x, y, ViewDraw.me);
  694.             break;
  695.         case CHART:
  696.             if (objTank.obj != null)
  697.             {
  698.                 Enumeration enum = objTank.obj.elements();
  699.  
  700.                 while (enum.hasMoreElements())
  701.                 {
  702.                     Draw dd = (Draw) enum.nextElement();
  703.                     Draw clone = new Draw(dd);
  704.                     clone.multiply((double)width/objTank.dim.width, (double)height/objTank.dim.height);
  705.                     clone.transelate(x, y);
  706.                     clone.draw(g);
  707.                 }
  708.             }
  709.             break;
  710.  
  711.         default:
  712.             System.out.println("invalid draw method");
  713.         }
  714.     }
  715. }
  716.