[Bprocessor-commit] gl/src/net/sourceforge/bprocessor/gl/tool TapeMeasure.java, NONE, 1.1 ToolFactory.java, 1.65, 1.66 AbstractPencil.java, 1.71, 1.72

[Michael L. <he...@us...>]

Update of /cvsroot/bprocessor/gl/src/net/sourceforge/bprocessor/gl/tool
In directory sc8-pr-cvs3.sourceforge.net:/tmp/cvs-serv29896/src/net/sourceforge/bprocessor/gl/tool

Modified Files:
	ToolFactory.java AbstractPencil.java 
Added Files:
	TapeMeasure.java 
Log Message:
New implementation of TapeMeasureTool:

   - A constructionline can be created just be specifying two points (with starting
      on an edge.
   - A constructionline can be created by clicking at an existing line
   - The constructionline are not restricted to an adjacant surface

Index: ToolFactory.java
===================================================================
RCS file: /cvsroot/bprocessor/gl/src/net/sourceforge/bprocessor/gl/tool/ToolFactory.java,v
retrieving revision 1.65
retrieving revision 1.66
diff -C2 -d -r1.65 -r1.66
*** ToolFactory.java	13 Nov 2006 12:22:30 -0000	1.65
--- ToolFactory.java	14 Nov 2006 15:10:05 -0000	1.66
***************
*** 89,93 ****
    
    /** Tape measure tool  */
!   private TapeMeasureTool tapeMeasure;
    
    /** Constructor tool */
--- 89,93 ----
    
    /** Tape measure tool  */
!   private AbstractPencil tapeMeasure;
    
    /** Constructor tool */
***************
*** 179,183 ****
      extrude = new ExtrusionTool(glv, pencilcursor);
      clipplane = new ClipplaneTool(glv, pencilcursor);
!     tapeMeasure = new TapeMeasureTool(glv, pencilcursor);
      camera = new CameraTool(glv, rotationCursor);
      fly = new CameraFlyTool(glv, flyCursor);
--- 179,183 ----
      extrude = new ExtrusionTool(glv, pencilcursor);
      clipplane = new ClipplaneTool(glv, pencilcursor);
!     tapeMeasure = new TapeMeasure(glv, pencilcursor);
      camera = new CameraTool(glv, rotationCursor);
      fly = new CameraFlyTool(glv, flyCursor);

Index: AbstractPencil.java
===================================================================
RCS file: /cvsroot/bprocessor/gl/src/net/sourceforge/bprocessor/gl/tool/AbstractPencil.java,v
retrieving revision 1.71
retrieving revision 1.72
diff -C2 -d -r1.71 -r1.72
*** AbstractPencil.java	22 Oct 2006 14:32:55 -0000	1.71
--- AbstractPencil.java	14 Nov 2006 15:10:05 -0000	1.72
***************
*** 467,471 ****
        setLength(edge.getLength());
      } else {
!       setLength(0);
      }
    }
--- 467,471 ----
        setLength(edge.getLength());
      } else {
!       glv.setLengthValue("");
      }
    }

--- NEW FILE: TapeMeasure.java ---
//---------------------------------------------------------------------------------
// $Id: TapeMeasure.java,v 1.1 2006/11/14 15:10:05 henryml Exp $
//
// Copyright (c) 2005      The BProcessor Team (http://bprocessor.sourceforge.net) 
// Released under the Lesser GNU Public License v2.1
//---------------------------------------------------------------------------------

package net.sourceforge.bprocessor.gl.tool;

import java.awt.Cursor;
import java.awt.event.MouseEvent;
import java.util.LinkedList;
import java.util.List;

import net.sourceforge.bprocessor.gl.GLView;
import net.sourceforge.bprocessor.model.Edge;
import net.sourceforge.bprocessor.model.Geometry;
import net.sourceforge.bprocessor.model.Line;
import net.sourceforge.bprocessor.model.Vertex;

/**
 * TapeMeasure
 */
public class TapeMeasure extends AbstractPencil {
  
  /**
   * Original edge
   */
  private Edge originalEdge;
  
  /**
   * Length edge
   */
  private Edge lengthEdge;
  
  /**
   * Constructor
   * @param glv GLView
   * @param cursor Cursor
   */
  public TapeMeasure(GLView glv, Cursor cursor) {
    super(glv, cursor);
  }
  
  /**
   * 
   * Update feedback
   */
  public void updateFeedback() {
    if (start != null) {
      List edges = new LinkedList();
      if (originalEdge != null) {
        Line line = new Line(current.vertex(), originalEdge.getDirection(), true, false);
        edges.add(line);
        Vertex normal = originalEdge.getDirection();
        normal.normalize();
        Vertex origin = start.vertex().copy();
        Vertex projected = current.vertex().minus(origin);
        double t = normal.dot(projected);
        normal.scale(t);
        projected = projected.minus(normal);
        Edge ortho = new Edge(origin, origin.add(projected));
        ortho.setStrippled(true);
        edges.add(ortho);
        lengthEdge = ortho;
      } else {
        Edge edge = new Edge(start.vertex(), current.vertex());
        edge.setStrippled(true);
        edges.add(edge);
        lengthEdge = edge;
      }
      feedback(edges);
    } else {
      lengthEdge = null;
      constructors(new LinkedList());
      feedback(new LinkedList());
    }
    makeTarget(current);
    updateConstructors();
  }
  
  /**
   * @param e MouseEvent
   */
  protected void moved(MouseEvent e) {
    current = findIntersection(e);
    if (current != null) {
      updateFeedback();
    }
  }
  /**
   * @param e MouseEvent
   */
  protected void pressed(MouseEvent e) {
    current = findIntersection(e);
    if (current != null) {
      onVertex();
    }
  }
  
  /**
   * 
   */
  public void onVertex() {
    if (start == null) {
      start = current;
      if (current.object() instanceof Edge) {
        originalEdge = (Edge) current.object();
      }
    } else {
      if (originalEdge != null) {
        Line line = new Line(current.vertex(), originalEdge.getDirection(), true, false);
        Geometry.insertConstructor(line);
      } else {
        if (lengthEdge != null) {
          Line line = new Line(start.vertex(), lengthEdge.getDirection(), true, false);
          Geometry.insertConstructor(line);
        }
      }
      cleanUp();
    }
    updateFeedback();
  }
  
  /**
   * Update length
   */
  protected void updateLength() {
    if (lengthEdge != null) {
      setLength(lengthEdge.getLength());
    } else {
      super.updateLength();
    }
  }
  
  /**
   * @param value Length
   */
  public void apply(double value) {
    if (lengthEdge != null) {
      if (originalEdge != null) {
        Vertex direction = lengthEdge.getDirection();
        direction.normalize();
        direction.scale(value);
        Vertex origin = start.vertex().add(direction);
        Line line = new Line(origin, originalEdge.getDirection(), true, false);
        Geometry.insertConstructor(line);
      } else {
        Line line = new Line(start.vertex(), lengthEdge.getDirection(), true, false);
        Geometry.insertConstructor(line);
      }
      cleanUp();
    } else {
      super.apply(value);
    }
  }
  
  /**
   * Cleanup
   */
  public void cleanUp() {
    originalEdge = null;
    lengthEdge = null;
    super.cleanUp();
  }
}