package graph;

import java.awt.*;
import java.util.*;
import java.lang.*;
import java.io.StreamTokenizer;
import java.io.InputStream;
import java.io.IOException;
import java.net.URL;


/*
**************************************************************************
**
**                      Class  graph.Marker
**
**************************************************************************
**    Copyright (C) 1996 Leigh Brookshaw
**
**    This program is free software; you can redistribute it and/or modify
**    it under the terms of the GNU General Public License as published by
**    the Free Software Foundation; either version 2 of the License, or
**    (at your option) any later version.
**
**    This program is distributed in the hope that it will be useful,
**    but WITHOUT ANY WARRANTY; without even the implied warranty of
**    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
**    GNU General Public License for more details.
**
**    You should have received a copy of the GNU General Public License
**    along with this program; if not, write to the Free Software
**    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
**************************************************************************
**
** class Marker extends Object 
**        This class is designed to help install and manipulate
** markers
**
*************************************************************************/


/**
 * This class installs, manipulates and draws markers.
 * Markers are stroked using the line drawing method of the class Graph.
 * This means that any stroked figure can become a marker.
 *
 * @version $Revision: 1.8 $, $Date: 1996/09/20 00:02:57 $
 * @author  Leigh Brookshaw
 */

public class Markers extends Object {

/*
**********************
**
** Protected Variables
**
*********************/

/**
 *    index of the last marker loaded
 */
      protected int last;
/**
 *    maximum number of markers allowed
 */
      protected int max  = 10;
/**
 *    An array of vectors. Each element in the array contains the vertex
 *    vectors for a marker. Marker 1 is at element vert[0].
 */
      protected Vector vert[];

/*
*******************
**
** Constructors
**
******************/
/**
 *  The class contructor
 */
      public Markers() {
          last = 0;
          vert = new Vector[max];
      }

/**
 * Instantiate the Marker class and load marker definitions from the parsed URL.
 * The format of the file is easily worked out from the 
 * default marker file <a href="marker.txt">marker.txt</a>.
 *
 * @param file    The URL of the data file to read
 * @exception  IOException if there is an error with the IO stream.
*/
      public Markers(URL file) throws IOException {

          this();

          LoadMarkers(file);
      }

/**
 * Add the definition of a new marker. The arrays contain the vertex
 * points of the marker. The boolean array is used to define a relative draw 
 * or move to the vertex.
 * The first vertex should always be a move (The boolean array is "true" 
 * for a relative draw.
 *
 * @param m The index of the marker. The first marker has index 1.
 * @param n The number of vertices required to stroke the marker.
 * @param draw Boolean array containing relative move/draw instructions. 
 *   "true" is a draw.
 * @param x Integer array containing the pixel x position of the vertices. 
 *          All positions are relative to the center of the marker.
 * @param y Integer array containing the pixel y postions of the vertices. 
 */
      public void AddMarker( int m, int n, boolean draw[], int x[], int y[]) {
          MarkerVertex v;
          int i;
          
          if(m < 1 || m > max ) return;
          if( n <= 0 ) return;
          
          m--;
          last = m;
          vert[m] = new Vector();
          
          for(i=0; i<n; i++) {
               v = new MarkerVertex();

               v.draw = draw[i];
               v.x    = x[i];
               v.y    = y[i];
               
               vert[m].addElement(v);
          }

      }
/**
 * Add the definition of a new marker. The new marker is appended onto 
 * the marker list. The center of the marker is assumed to be at (0,0).
 * @param n number of move/draw commands
 * @param draw <i>true</i> if the point is to drawn to, <i>false</i> if
 * the point is to be moved to.
 * @param x X pixel to move/draw to.
 * @param x Y pixel to move/draw to.
 */
      public void AddMarker(int n, boolean draw[], int x[], int y[]) {
         AddMarker(last+1,n,draw,x,y);
      }

/**
 *  Delete the marker with the given index. the first marker has index 1.
 * @param n The index of the marker to delete. Markers start at index 1. 
 */
     public void DeleteMarker( int n ) {

        if(n<1 || n>max) return;
        vert[n-1] = null;
     
     }
  /**
   * Clear All markers.
   */
     public void ClearMarkers() {
        int i;
        
        if(last == 0) return;
        for(i=0; i<max; i++) {
           vert[i] = null;
        }
        
        last = 0;
        
     }
  /**
   * This method reads the marker file and loads the marker definitions.
   * The format of the file is simple. The following are the keywords.
   * <dl>
   *   <dt><b>start</b>
   *   <dd> starts a new marker definition.
   *   <dt><b>end</b>
   *   <dd> ends a marker definition.
   *   <dt><b>m x y</b>
   *   <dd> move to position x,y
   *   <dt><b>l x y</b>
   *   <dd> line to position x,y
   * </dl>
   * All line drawing is relative to the previous position. The center 
   * of the marker is assumed to be at (0,0).
   * As always blank lines are ignored and comments begin with a # character.
   *
   * @param file URL of file to load
   * @exception IOException If there is an IO error
   */
     public void LoadMarkers(URL file) throws IOException {
         InputStream is;
         StreamTokenizer st;
         MarkerVertex v;

         is = file.openStream();

         st = new StreamTokenizer(is);
         st.eolIsSignificant(true);
         st.commentChar('#');

scan:
        while (true) {
            switch (st.nextToken()) {
              default:
                break scan;
              case StreamTokenizer.TT_EOL:
                break;
              case StreamTokenizer.TT_WORD:

                   if ("start".equals(st.sval)) {
                        vert[last] = new Vector();
                   } else
                   if ("end".equals(st.sval)) {
                        last++;
                   } else
                   if ("m".equals(st.sval)) {
                        v = new MarkerVertex();
                        v.draw = false;
                        if (st.nextToken() == StreamTokenizer.TT_NUMBER) {
                           v.x = (int)st.nval;
                           if (st.nextToken() == StreamTokenizer.TT_NUMBER) {
                               v.y = (int)st.nval;
                               vert[last].addElement(v);
                           }
                        }
                   } else
                   if ("l".equals(st.sval)) {
                        v = new MarkerVertex();
                        v.draw = true;
                        if (st.nextToken() == StreamTokenizer.TT_NUMBER) {
                           v.x = (int)st.nval;
                           if (st.nextToken() == StreamTokenizer.TT_NUMBER) {
                               v.y = (int)st.nval;
                               vert[last].addElement(v);
                           }
                        }
                    }
                 break;
             }


        }

        is.close();

}

  /**
   * draw the marker
   * @param g Graphics context
   * @param m Index of the marker to draw
   * @param scale scale factor. All coordinates are multiplied by this factor.
   * @param x Coordinate where to draw the marker
   * @param y Coordinate where to draw the marker
   */
      public void draw(Graphics g, int m, double scale, int x, int y) {
          int i;
          MarkerVertex mv;
          int x0 = x, x1 = x, y0 = y, y1 = y;
          Vector v;
          
          
          if(m < 1 || m > max ) return;
          if(scale <= 0) return;
          
          v = vert[m-1];
          if( v == null) return;

          for (i=0; i<v.size(); i++) {
             mv = (MarkerVertex)v.elementAt(i);

             if( mv.draw ) {
                 x1 = x + (int)(mv.x*scale);
                 y1 = y + (int)(mv.y*scale);

                 g.drawLine(x0,y0,x1,y1);

                 x0 = x1;
                 y0 = y1;
             } else {
                 x0 = x + (int)(mv.x*scale);
                 y0 = y + (int)(mv.y*scale);

             }

          }

     }
}


/**
 * This class is a structure class. It defines one vertex of the marker.
 */

class MarkerVertex extends Object {
      boolean draw;
      int     x;
      int     y;
}