/*
Copyright 2000 by Ralph Hartley
This software is licenced under the terms of the
Gnu Public Licence
*/
import java.awt.*;
import java.awt.geom.*;
import java.util.*;


public abstract class TickedStroke extends SavableStroke {
  static double tol  = 0.5;

  static int PENDOWN = 1;
  static int PENUP = 2;
  static int LEFT = 4;
  static int RIGHT = 8;

  public double thickness;
  public double ticklength;
  int flip = 1;

  double[] lengths;
  int[] actions;
  int partcnt;

  public TickedStroke(double thickness) {
    super(thickness);
  }

  Vector heads = new Vector();
  Vector tails = new Vector();

  public void setFlip(boolean val) {
    if (val) flip = -1;
    else flip = 1;
  }

  public Shape createStrokedShape(Shape p) {
      //System.out.println("shape = "+p);
    PathIterator path = p.getPathIterator(new AffineTransform(),tol);
    GeneralPath res = new GeneralPath();

    //System.out.println("res = "+res+" path = "+path);

    double[] points;// = null;
    double[] current = null;
    int type;
    double[] start = null;

    heads.clear();
    tails.clear();

    double dist;

    double[] anchor;
    double[] end;

    int curpart = 0;
    double phase = lengths[0];
    boolean pendown = true;

    //System.out.println("path "+path);
    for (;!path.isDone();path.next()) {
        //System.out.println("done= "+path.isDone());
      points = new double[2];
      type = path.currentSegment(points);
      //System.out.println("Segment "+type);
      switch (type) {
      case PathIterator.SEG_MOVETO:
          res.moveTo((float)points[0],(float)points[1]);
          start = points;
          current = points;
          break;
      case PathIterator.SEG_CLOSE:
          points = start;
      case PathIterator.SEG_LINETO:
          dist = Math.sqrt((points[0]-current[0])*(points[0]-current[0]) +
                          (points[1]-current[1])*(points[1]-current[1]));
          while (phase < dist) {
            anchor = new double[2];
            anchor[0] = current[0] + phase*(points[0]-current[0])/dist;
            anchor[1] = current[1] + phase*(points[1]-current[1])/dist;

            if (pendown)
              res.lineTo((float)anchor[0],(float)anchor[1]);
            else if ((actions[curpart]&PENDOWN) !=0)
              res.moveTo((float)anchor[0],(float)anchor[1]);
            if ((actions[curpart]&PENDOWN) !=0) pendown = true;
            if ((actions[curpart]&PENUP) !=0) pendown = false;

            if ((actions[curpart]&(LEFT|RIGHT)) !=0) {
              if((actions[curpart]&LEFT) !=0) {
                end = new double[2];
                end[0] = anchor[0] - flip*ticklength*(points[1]-current[1])/dist;
                end[1] = anchor[1] + flip*ticklength*(points[0]-current[0])/dist;
        	heads.add(end);
              } else heads.add(anchor);
              if((actions[curpart]&RIGHT) !=0) {
                end = new double[2];
                end[0] = anchor[0] + flip*ticklength*(points[1]-current[1])/dist;
                end[1] = anchor[1] - flip*ticklength*(points[0]-current[0])/dist;
        	tails.add(end);
              } else tails.add(anchor);
            }

                  dist -= phase;
            curpart = (curpart+1)%partcnt;
            phase = lengths[curpart];
            current = anchor;
          }
          //System.out.println("backbone done");

          if (dist>0) {
              //if (type==PathIterator.SEG_CLOSE) res.closePath();
            // else
            if (pendown)
              res.lineTo((float)points[0],(float)points[1]);
            //	    else
            //  res.moveTo((float)points[0],(float)points[1]);
            phase -= dist;
            current = points;
                }
      }
    }
    
    for (int i=0;i<heads.size();i++) {
      res.moveTo((float)((double[])heads.elementAt(i))[0],(float)((double[])heads.elementAt(i))[1]);
      res.lineTo((float)((double[])tails.elementAt(i))[0],(float)((double[])tails.elementAt(i))[1]);
    }

    return(linestroke.createStrokedShape(res));
  }
}