Revision: 708
Author: allain.lalonde
Date: Wed Oct 14 08:47:49 2009
Log: Further CheckStyle activity on extras module.
http://code.google.com/p/piccolo2d/source/detail?r=708

Modified:
   
/piccolo2d.java/trunk/extras/src/main/java/edu/umd/cs/piccolox/pswing/PSwingEventHandler.java
   
/piccolo2d.java/trunk/extras/src/main/java/edu/umd/cs/piccolox/swing/PScrollPaneLayout.java
   
/piccolo2d.java/trunk/extras/src/main/java/edu/umd/cs/piccolox/swing/PViewport.java
   
/piccolo2d.java/trunk/extras/src/main/java/edu/umd/cs/piccolox/util/LineShape.java
   
/piccolo2d.java/trunk/extras/src/main/java/edu/umd/cs/piccolox/util/MutablePoints.java
   
/piccolo2d.java/trunk/extras/src/main/java/edu/umd/cs/piccolox/util/PBoundsLocator.java
   
/piccolo2d.java/trunk/extras/src/main/java/edu/umd/cs/piccolox/util/PFixedWidthStroke.java
   
/piccolo2d.java/trunk/extras/src/main/java/edu/umd/cs/piccolox/util/PLocator.java
   
/piccolo2d.java/trunk/extras/src/main/java/edu/umd/cs/piccolox/util/PNodeLocator.java
   
/piccolo2d.java/trunk/extras/src/main/java/edu/umd/cs/piccolox/util/POcclusionDetection.java
   
/piccolo2d.java/trunk/extras/src/main/java/edu/umd/cs/piccolox/util/PSemanticStroke.java
   
/piccolo2d.java/trunk/extras/src/main/java/edu/umd/cs/piccolox/util/Points.java
   
/piccolo2d.java/trunk/extras/src/main/java/edu/umd/cs/piccolox/util/ShadowUtils.java
   
/piccolo2d.java/trunk/extras/src/main/java/edu/umd/cs/piccolox/util/XYArray.java

=======================================
---  
/piccolo2d.java/trunk/extras/src/main/java/edu/umd/cs/piccolox/pswing/PSwingEventHandler.java
    
Tue Oct 13 20:14:37 2009
+++  
/piccolo2d.java/trunk/extras/src/main/java/edu/umd/cs/piccolox/pswing/PSwingEventHandler.java
    
Wed Oct 14 08:47:49 2009
@@ -257,20 +257,22 @@
              }
          }
          else if (isPressOrClickOrMove(pSwingMouseEvent) && comp != null) {
-            final MouseEvent e_temp = new MouseEvent(comp,  
pSwingMouseEvent.getID(), mEvent.getWhen(), mEvent
+            final MouseEvent tempEvent = new MouseEvent(comp,  
pSwingMouseEvent.getID(), mEvent.getWhen(), mEvent
                      .getModifiers(), point.x - offset.x, point.y -  
offset.y, mEvent.getClickCount(), mEvent
                      .isPopupTrigger());

-            final PSwingEvent e2 =  
PSwingMouseEvent.createMouseEvent(e_temp.getID(), e_temp, aEvent);
+            final PSwingEvent e2 =  
PSwingMouseEvent.createMouseEvent(tempEvent.getID(), tempEvent, aEvent);
              dispatchEvent(comp, e2);
          }
          else if (isWheelEvent(pSwingMouseEvent) && comp != null) {
              final MouseWheelEvent mWEvent = (MouseWheelEvent) mEvent;
-            final MouseWheelEvent e_temp = new MouseWheelEvent(comp,  
pSwingMouseEvent.getID(), mEvent.getWhen(), mEvent
-                    .getModifiers(), point.x - offset.x, point.y -  
offset.y, mEvent.getClickCount(), mEvent
-                    .isPopupTrigger(), mWEvent.getScrollType(),  
mWEvent.getScrollAmount(), mWEvent.getWheelRotation());
-
-            final PSwingMouseWheelEvent e2 = new  
PSwingMouseWheelEvent(e_temp.getID(), e_temp, aEvent);
+
+            final MouseWheelEvent tempEvent = new MouseWheelEvent(comp,  
pSwingMouseEvent.getID(), mEvent.getWhen(),
+                    mEvent.getModifiers(), point.x - offset.x, point.y -  
offset.y, mEvent.getClickCount(), mEvent
+                            .isPopupTrigger(), mWEvent.getScrollType(),  
mWEvent.getScrollAmount(), mWEvent
+                            .getWheelRotation());
+
+            final PSwingMouseWheelEvent e2 = new  
PSwingMouseWheelEvent(tempEvent.getID(), tempEvent, aEvent);
              dispatchEvent(comp, e2);
          }

@@ -282,9 +284,9 @@

              // This shouldn't happen - since we're only getting node events
              if (comp == null || pSwingMouseEvent.getID() ==  
MouseEvent.MOUSE_EXITED) {
-                final MouseEvent e_temp = createExitEvent(mEvent);
-
-                final PSwingEvent e2 =  
PSwingMouseEvent.createMouseEvent(e_temp.getID(), e_temp, aEvent);
+                final MouseEvent tempEvent = createExitEvent(mEvent);
+
+                final PSwingEvent e2 =  
PSwingMouseEvent.createMouseEvent(tempEvent.getID(), tempEvent, aEvent);

                  dispatchEvent(previousComponent, e2);
                  previousComponent = null;
@@ -292,18 +294,18 @@

              // This means mouseExited prevComponent and mouseEntered comp
              else if (previousComponent != comp) {
-                MouseEvent e_temp = createExitEvent(mEvent);
-                PSwingEvent e2 =  
PSwingMouseEvent.createMouseEvent(e_temp.getID(), e_temp, aEvent);
+                MouseEvent tempEvent = createExitEvent(mEvent);
+                PSwingEvent e2 =  
PSwingMouseEvent.createMouseEvent(tempEvent.getID(), tempEvent, aEvent);
                  dispatchEvent(previousComponent, e2);

-                e_temp = createEnterEvent(comp, mEvent, offset.x,  
offset.y);
-                e2 = PSwingMouseEvent.createMouseEvent(e_temp.getID(),  
e_temp, aEvent);
+                tempEvent = createEnterEvent(comp, mEvent, offset.x,  
offset.y);
+                e2 = PSwingMouseEvent.createMouseEvent(tempEvent.getID(),  
tempEvent, aEvent);
                  comp.dispatchEvent(e2.asMouseEvent());
              }
          }
          else if (comp != null) { // This means mouseEntered
-            final MouseEvent e_temp = createEnterEvent(comp, mEvent,  
offset.x, offset.y);
-            final PSwingEvent e2 =  
PSwingMouseEvent.createMouseEvent(e_temp.getID(), e_temp, aEvent);
+            final MouseEvent tempEvent = createEnterEvent(comp, mEvent,  
offset.x, offset.y);
+            final PSwingEvent e2 =  
PSwingMouseEvent.createMouseEvent(tempEvent.getID(), tempEvent, aEvent);
              dispatchEvent(comp, e2);
          }

@@ -370,7 +372,8 @@
      private void handleButton(final PSwingEvent e1, final PInputEvent  
aEvent, final ButtonData buttonData) {
          final MouseEvent m1 = e1.asMouseEvent();
          if (involvesSceneNode(buttonData)) {
-            // TODO: this probably won't handle viewing through multiple  
cameras.
+            // TODO: this probably won't handle viewing through multiple
+            // cameras.

              final Point2D pt = new Point2D.Double(m1.getX(), m1.getY());
              cameraToLocal(e1.getPath().getTopCamera(), pt,  
buttonData.getPNode());
@@ -459,8 +462,8 @@
      }

      /**
-     * Process a Piccolo2D event and (if active) dispatch the  
corresponding Swing
-     * event.
+     * Process a Piccolo2D event and (if active) dispatch the corresponding
+     * Swing event.
       *
       * @param aEvent Piccolo2D event being testing for dispatch to swing
       * @param type is not used in this method
=======================================
---  
/piccolo2d.java/trunk/extras/src/main/java/edu/umd/cs/piccolox/swing/PScrollPaneLayout.java
      
Thu Jul 30 12:36:17 2009
+++  
/piccolo2d.java/trunk/extras/src/main/java/edu/umd/cs/piccolox/swing/PScrollPaneLayout.java
      
Wed Oct 14 08:47:49 2009
@@ -42,19 +42,15 @@
  /**
   * A subclass of ScrollPaneLayout that looks at the Viewport for sizing
   * information rather than View. Also queries the Viewport for sizing
- * information after each decision about scrollbar visiblity
+ * information after each decision about scrollbar visiblity.
   *
   * @author Lance Good
   */
  public class PScrollPaneLayout extends ScrollPaneLayout {
-
-    /**
-     *
-     */
      private static final long serialVersionUID = 1L;

      /**
-     * MODIFIED FROM javax.swing.ScrollPaneLayout.layoutContainer
+     * MODIFIED FROM javax.swing.ScrollPaneLayout.layoutContainer.
       *
       * This is largely the same as ScrollPaneLayout.layoutContainer but  
obtains
       * the preferred view size from the viewport rather than directly from  
the
@@ -63,9 +59,7 @@
       * @param parent the Container to lay out
       */
      public void layoutContainer(final Container parent) {
-        /*
-         * Sync the (now obsolete) policy fields with the JScrollPane.
-         */
+        // Sync the (now obsolete) policy fields with the JScrollPane.
          if (!(parent instanceof JScrollPane)) {
              throw new IllegalArgumentException("layoutContainer may only  
be applied to JScrollPanes");
          }
@@ -74,7 +68,7 @@
          hsbPolicy = scrollPane.getHorizontalScrollBarPolicy();

          final Rectangle availR = scrollPane.getBounds();
-        availR.x = availR.y = 0;
+        availR.setLocation(0, 0);

          final Insets insets = parent.getInsets();
          availR.x = insets.left;
@@ -82,9 +76,7 @@
          availR.width -= insets.left + insets.right;
          availR.height -= insets.top + insets.bottom;

-        /*
-         * Get the scrollPane's orientation.
-         */
+        // Get the scrollPane's orientation.
          final boolean leftToRight =  
scrollPane.getComponentOrientation().isLeftToRight();

          /*
@@ -153,14 +145,13 @@
           * And we assume that the viewports layout manager will give the  
view
           * it's preferred size.
           */
-        Dimension extentSize = viewport != null ?  
viewport.toViewCoordinates(availR.getSize()) : new Dimension(0, 0);
+        Dimension extentSize = getExtentSize(availR);

          final PBounds cameraBounds = new PBounds(0, 0,  
extentSize.getWidth(), extentSize.getHeight());

          // LEG: Modification to ask the viewport for the view size rather
          // than asking the view directly
-        Dimension viewPrefSize = viewport != null ? ((PViewport)  
viewport).getViewSize(cameraBounds) : new Dimension(0,
-                0);
+        Dimension viewPrefSize = getViewSize(cameraBounds);

          /*
           * If there's a vertical scrollbar and we need one, allocate space  
for
@@ -289,31 +280,83 @@
          }

          if (lowerLeft != null) {
-            lowerLeft.setBounds(leftToRight ? rowHeadR.x : vsbR.x, hsbR.y,  
leftToRight ? rowHeadR.width : vsbR.width,
-                    hsbR.height);
+            if (leftToRight) {
+                lowerLeft.setBounds(rowHeadR.x, hsbR.y, rowHeadR.width,  
hsbR.height);
+            }
+            else {
+                lowerLeft.setBounds(vsbR.x, hsbR.y, vsbR.width,  
hsbR.height);
+            }
          }

          if (lowerRight != null) {
-            lowerRight.setBounds(leftToRight ? vsbR.x : rowHeadR.x,  
hsbR.y, leftToRight ? vsbR.width : rowHeadR.width,
-                    hsbR.height);
+            if (leftToRight) {
+                lowerRight.setBounds(vsbR.x, hsbR.y, vsbR.width,  
hsbR.height);
+            }
+            else {
+                lowerRight.setBounds(rowHeadR.x, hsbR.y, rowHeadR.width,  
hsbR.height);
+            }
          }

          if (upperLeft != null) {
-            upperLeft.setBounds(leftToRight ? rowHeadR.x : vsbR.x,  
colHeadR.y, leftToRight ? rowHeadR.width
-                    : vsbR.width, colHeadR.height);
+            if (leftToRight) {
+                upperLeft.setBounds(rowHeadR.x, colHeadR.y,  
rowHeadR.width, colHeadR.height);
+            }
+            else {
+                upperLeft.setBounds(vsbR.x, colHeadR.y, vsbR.width,  
colHeadR.height);
+            }
          }

          if (upperRight != null) {
-            upperRight.setBounds(leftToRight ? vsbR.x : rowHeadR.x,  
colHeadR.y, leftToRight ? vsbR.width
-                    : rowHeadR.width, colHeadR.height);
+            if (leftToRight) {
+                upperRight.setBounds(vsbR.x, colHeadR.y, vsbR.width,  
colHeadR.height);
+            }
+            else {
+                upperRight.setBounds(rowHeadR.x, colHeadR.y,  
rowHeadR.width, colHeadR.height);
+            }
          }
      }

      /**
-     * Copied FROM javax.swing.ScrollPaneLayout.adjustForVSB
+     * @param cameraBounds
+     * @return
+     */
+    private Dimension getViewSize(final PBounds cameraBounds) {
+        Dimension viewPrefSize;
+        if (viewport != null) {
+            viewPrefSize = ((PViewport)  
viewport).getViewSize(cameraBounds);
+        }
+        else {
+            viewPrefSize = new Dimension(0, 0);
+        }
+        return viewPrefSize;
+    }
+
+    /**
+     * @param availR
+     * @return
+     */
+    private Dimension getExtentSize(final Rectangle availR) {
+        Dimension extentSize;
+        if (viewport != null) {
+            extentSize = viewport.toViewCoordinates(availR.getSize());
+        }
+        else {
+            extentSize = new Dimension(0, 0);
+        }
+        return extentSize;
+    }
+
+    /**
+     * Copied FROM javax.swing.ScrollPaneLayout.adjustForVSB.
       *
       * This method is called from ScrollPaneLayout.layoutContainer and is
       * private in ScrollPaneLayout so it was copied here
+     *
+     * @param wantsVSB whether to account for vertical scrollbar
+     * @param available region to adjust
+     * @param vsbR vertical scroll bar region
+     * @param vpbInsets margin of vertical scroll bars
+     * @param leftToRight orientation of the text LTR or RTL
       */
      protected void adjustForVSB(final boolean wantsVSB, final Rectangle  
available, final Rectangle vsbR,
              final Insets vpbInsets, final boolean leftToRight) {
@@ -336,10 +379,15 @@
      }

      /**
-     * Copied FROM javax.swing.ScrollPaneLayout.adjustForHSB
+     * Copied FROM javax.swing.ScrollPaneLayout.adjustForHSB.
       *
       * This method is called from ScrollPaneLayout.layoutContainer and is
       * private in ScrollPaneLayout so it was copied here
+     *
+     * @param wantsHSB whether to account for horizontal scrollbar
+     * @param available region to adjust
+     * @param hsbR vertical scroll bar region
+     * @param vpbInsets margin of the scroll bars
       */
      protected void adjustForHSB(final boolean wantsHSB, final Rectangle  
available, final Rectangle hsbR,
              final Insets vpbInsets) {
=======================================
---  
/piccolo2d.java/trunk/extras/src/main/java/edu/umd/cs/piccolox/swing/PViewport.java
      
Thu Oct  8 14:47:46 2009
+++  
/piccolo2d.java/trunk/extras/src/main/java/edu/umd/cs/piccolox/swing/PViewport.java
      
Wed Oct 14 08:47:49 2009
@@ -50,14 +50,10 @@
   */
  public class PViewport extends JViewport {
      private static final long serialVersionUID = 1L;
-    /**
-     * Controls what happens when scrolling occurs
-     */
+    /** Controls what happens when scrolling occurs. */
      PScrollDirector scrollDirector;

-    /**
-     * Pass constructor info to super
-     */
+    /** Pass constructor info to super. */
      public PViewport() {
          super();

@@ -79,7 +75,7 @@
       * Subclasses can override this to install a different scroll director  
in
       * the constructor. Returns a new <code>PScrollDirector</code> object.
       *
-     * @return a <code>PScrollDirector
+     * @return a PScrollDirector
       */
      protected PScrollDirector createScrollDirector() {
          return new PDefaultScrollDirector();
@@ -101,14 +97,16 @@
      }

      /**
-     * @return The scroll director on this viewport.
+     * Returns the scroll director on this viewport.
+     *
+     * @return The scroll director on this viewport
       */
      public PScrollDirector getScrollDirector() {
          return scrollDirector;
      }

      /**
-     * Overridden to throw an exception if the view is not a ZCanvas
+     * Overridden to throw an exception if the view is not a PCanvas.
       *
       * @param view The new view - it better be a ZCanvas!
       */
@@ -138,7 +136,7 @@
       * Sets the view coordinates that appear in the upper left hand corner  
of
       * the viewport, does nothing if there's no view.
       *
-     * @param p a <code>Point</code> object giving the upper left  
coordinates
+     * @param p a Point object giving the upper left coordinates
       */
      public void setViewPosition(final Point p) {
          if (getView() == null) {
@@ -154,10 +152,8 @@
              oldY = vp.getY();
          }

-        /**
-         * Send the scroll director the exact view position and let it  
interpret
-         * it as needed
-         */
+        // Send the scroll director the exact view position and let it  
interpret
+        // it as needed
          final double newX = x;
          final double newY = y;

@@ -172,23 +168,22 @@

      /**
       * Gets the view position from the scroll director based on the current
-     * extent size
+     * extent size.
       *
-     * @return The new view position
+     * @return The new view's position
       */
      public Point getViewPosition() {
-        if (scrollDirector != null) {
-            final Dimension extent = getExtentSize();
-            return scrollDirector.getViewPosition(new PBounds(0, 0,  
extent.getWidth(), extent.getHeight()));
-        }
-        else {
+        if (scrollDirector == null) {
              return null;
          }
+
+        final Dimension extent = getExtentSize();
+        return scrollDirector.getViewPosition(new PBounds(0, 0,  
extent.getWidth(), extent.getHeight()));
      }

      /**
       * Gets the view size from the scroll director based on the current  
extent
-     * size
+     * size.
       *
       * @return The new view size
       */
@@ -199,7 +194,7 @@

      /**
       * Gets the view size from the scroll director based on the specified  
extent
-     * size
+     * size.
       *
       * @param r The extent size from which the view is computed
       * @return The new view size
@@ -209,7 +204,7 @@
      }

      /**
-     * A simple layout manager to give the ZCanvas the same size as the  
Viewport
+     * A simple layout manager to give the ZCanvas the same size as the  
Viewport.
       */
      public static class PViewportLayout extends ViewportLayout {
          private static final long serialVersionUID = 1L;
=======================================
---  
/piccolo2d.java/trunk/extras/src/main/java/edu/umd/cs/piccolox/util/LineShape.java
       
Fri Oct  9 09:55:21 2009
+++  
/piccolo2d.java/trunk/extras/src/main/java/edu/umd/cs/piccolox/util/LineShape.java
       
Wed Oct 14 08:47:49 2009
@@ -36,6 +36,9 @@
  import java.awt.geom.Point2D;
  import java.awt.geom.Rectangle2D;

+/**
+ * A shape that can be used to represent hand drawn lines.
+ */
  public class LineShape implements Shape, MutablePoints {
      private MutablePoints points;
      private final Rectangle2D bounds = new Rectangle2D.Double();
@@ -54,11 +57,13 @@
       *
       * @param points new Points to use as this shape's path
       */
-    public void setPoints(MutablePoints points) {
+    public void setPoints(final MutablePoints points) {
          if (points == null) {
-            points = new XYArray();
-        }
-        this.points = points;
+            this.points = new XYArray();
+        }
+        else {
+            this.points = points;
+        }
      }

      /**
@@ -214,8 +219,9 @@
          double dy = y2 - y1;

          // If line is a point then bail out
-        if (dx == 0 && dy == 0)
+        if (dx == 0 && dy == 0) {
              return false;
+        }

          final double dx2 = dx * dx;
          final double dy2 = dy * dy;
@@ -400,8 +406,8 @@
       * @param height height of defined rectangle
       * @return true if rectangle is contained
       */
-    public boolean contains(final double x, final double y, final double  
w, final double h) {
-        return contains(x, y) && contains(x + w, y) && contains(x, y + h)  
&& contains(x + w, y + h);
+    public boolean contains(final double x, final double y, final double  
width, final double height) {
+        return contains(x, y) && contains(x + width, y) && contains(x, y +  
height) && contains(x + width, y + height);
      }

      /**
@@ -420,7 +426,6 @@
       *
       * @param at optional transform to apply to segment before returning  
it. May
       *            be null
-     * @param iterator for iterating over Line Paths
       * @return iterator for iterating segments of this LineShape
       */
      public PathIterator getPathIterator(final AffineTransform at) {
@@ -433,7 +438,6 @@
       *
       * @param at optional transform to apply to segment before returning  
it. May
       *            be null
-     * @param iterator for iterating over Line Paths
       * @param flatness ignored completely
       * @return iterator for iterating segments of this LineShape
       */
@@ -463,7 +467,8 @@
          /**
           * Returns the winding rule being applied when selecting next  
paths.
           *
-         * @return GeneralPath.WIND_EVEN_ODD since that's the only policy  
supported
+         * @return GeneralPath.WIND_EVEN_ODD since that's the only policy
+         *         supported
           */
          public int getWindingRule() {
              return GeneralPath.WIND_EVEN_ODD;
@@ -506,7 +511,12 @@
              currentSegment();
              coords[0] = (float) tempPoint.getX();
              coords[1] = (float) tempPoint.getY();
-            return i == 0 ? PathIterator.SEG_MOVETO :  
PathIterator.SEG_LINETO;
+            if (i == 0) {
+                return PathIterator.SEG_MOVETO;
+            }
+            else {
+                return PathIterator.SEG_LINETO;
+            }
          }

          /**
@@ -521,7 +531,12 @@
              currentSegment();
              coords[0] = tempPoint.getX();
              coords[1] = tempPoint.getY();
-            return i == 0 ? PathIterator.SEG_MOVETO :  
PathIterator.SEG_LINETO;
+            if (i == 0) {
+                return PathIterator.SEG_MOVETO;
+            }
+            else {
+                return PathIterator.SEG_LINETO;
+            }
          }
      }
  }
=======================================
---  
/piccolo2d.java/trunk/extras/src/main/java/edu/umd/cs/piccolox/util/MutablePoints.java
   
Fri Jan 23 12:29:37 2009
+++  
/piccolo2d.java/trunk/extras/src/main/java/edu/umd/cs/piccolox/util/MutablePoints.java
   
Wed Oct 14 08:47:49 2009
@@ -30,12 +30,40 @@

  import java.awt.geom.AffineTransform;

+/**
+ * Minimal interface that a changeable sequence of points must provide.
+ */
  public interface MutablePoints extends Points {
-    public void setPoint(int i, double x, double y);
-
-    public void addPoint(int pos, double x, double y);
-
-    public void removePoints(int pos, int num);
-
-    public void transformPoints(AffineTransform t);
-}
+    /**
+     * Sets the coordinates for the point at the given index.
+     *
+     * @param i index of point
+     * @param x x component of the point's coordinates
+     * @param y y component of the point's coordinates
+     */
+    void setPoint(int i, double x, double y);
+
+    /**
+     * Inserts a point at the specified position.
+     *
+     * @param pos position at which to insert the point
+     * @param x x component of the point's coordinates
+     * @param y y component of the point's coordinates
+     */
+    void addPoint(int pos, double x, double y);
+
+    /**
+     * Removes a subsequence of points.
+     *
+     * @param pos position to start removing points
+     * @param num number of points to remove
+     */
+    void removePoints(int pos, int num);
+
+    /**
+     * Modifies all points by applying the transform to them.
+     *
+     * @param t transformto apply to the points
+     */
+    void transformPoints(AffineTransform t);
+}
=======================================
---  
/piccolo2d.java/trunk/extras/src/main/java/edu/umd/cs/piccolox/util/PBoundsLocator.java
  
Tue Jul 28 12:46:54 2009
+++  
/piccolo2d.java/trunk/extras/src/main/java/edu/umd/cs/piccolox/util/PBoundsLocator.java
  
Wed Oct 14 08:47:49 2009
@@ -43,58 +43,127 @@
   * @author Jesse Grosjean
   */
  public class PBoundsLocator extends PNodeLocator {
+    private static final long serialVersionUID = 1L;
+    private int side;

      /**
+     * Creates a locator for tracking the east side of the provided node.
       *
+     * @param node node to track
+     * @return a new locator
       */
-    private static final long serialVersionUID = 1L;
-    private int side;
-
      public static PBoundsLocator createEastLocator(final PNode node) {
          return new PBoundsLocator(node, SwingConstants.EAST);
      }

+    /**
+     * Creates a locator for tracking the north east corner of the provided
+     * node.
+     *
+     * @param node node to track
+     * @return a new locator
+     */
      public static PBoundsLocator createNorthEastLocator(final PNode node) {
          return new PBoundsLocator(node, SwingConstants.NORTH_EAST);
      }

+    /**
+     * Creates a locator for tracking the north west corner of the provided
+     * node.
+     *
+     * @param node node to track
+     * @return a new locator
+     */
      public static PBoundsLocator createNorthWestLocator(final PNode node) {
          return new PBoundsLocator(node, SwingConstants.NORTH_WEST);
      }

+    /**
+     * Creates a locator for tracking the north side of the provided node.
+     *
+     * @param node node to track
+     * @return a new locator
+     */
      public static PBoundsLocator createNorthLocator(final PNode node) {
          return new PBoundsLocator(node, SwingConstants.NORTH);
      }

+    /**
+     * Creates a locator for tracking the south side of the provided node.
+     *
+     * @param node node to track
+     * @return a new locator
+     */
      public static PBoundsLocator createSouthLocator(final PNode node) {
          return new PBoundsLocator(node, SwingConstants.SOUTH);
      }

+    /**
+     * Creates a locator for tracking the west side of the provided node.
+     *
+     * @param node node to track
+     * @return a new locator
+     */
      public static PBoundsLocator createWestLocator(final PNode node) {
          return new PBoundsLocator(node, SwingConstants.WEST);
      }

+    /**
+     * Creates a locator for tracking the south west corner of the provided
+     * node.
+     *
+     * @param node node to track
+     * @return a new locator
+     */
      public static PBoundsLocator createSouthWestLocator(final PNode node) {
          return new PBoundsLocator(node, SwingConstants.SOUTH_WEST);
      }

+    /**
+     * Creates a locator for tracking the south east corner of the provided
+     * node.
+     *
+     * @param node node to track
+     * @return a new locator
+     */
      public static PBoundsLocator createSouthEastLocator(final PNode node) {
          return new PBoundsLocator(node, SwingConstants.SOUTH_EAST);
      }

+    /**
+     * Constructs a locator for tracking the position on the node provided.
+     *
+     * @param node node to track
+     * @param aSide specified the position on the node to track
+     */
      public PBoundsLocator(final PNode node, final int aSide) {
          super(node);
          side = aSide;
      }

+    /**
+     * Returns the side of the node that's being tracked.
+     *
+     * @return tracked side
+     */
      public int getSide() {
          return side;
      }

+    /**
+     * Sets the side to track on the node.
+     *
+     * @param side new side to track
+     */
      public void setSide(final int side) {
          this.side = side;
      }

+    /**
+     * Maps the locator's side to its x position.
+     *
+     * @return x position on side this locator is tracking
+     */
      public double locateX() {
          final Rectangle2D aBounds = node.getBoundsReference();

@@ -112,10 +181,16 @@
              case SwingConstants.NORTH:
              case SwingConstants.SOUTH:
                  return aBounds.getX() + aBounds.getWidth() / 2;
-        }
-        return -1;
+            default:
+                return -1;
+        }
      }

+    /**
+     * Maps the locator's side to its y position.
+     *
+     * @return y position on side this locator is tracking
+     */
      public double locateY() {
          final Rectangle2D aBounds = node.getBoundsReference();

@@ -133,7 +208,8 @@
              case SwingConstants.NORTH_EAST:
              case SwingConstants.NORTH:
                  return aBounds.getY();
-        }
-        return -1;
+            default:
+                return -1;
+        }
      }
  }
=======================================
---  
/piccolo2d.java/trunk/extras/src/main/java/edu/umd/cs/piccolox/util/PFixedWidthStroke.java
       
Tue Oct 13 14:11:50 2009
+++  
/piccolo2d.java/trunk/extras/src/main/java/edu/umd/cs/piccolox/util/PFixedWidthStroke.java
       
Wed Oct 14 08:47:49 2009
@@ -116,6 +116,11 @@
          this(new BasicStroke(width, cap, join, miterlimit, dash,  
dash_phase));
      }

+    /**
+     * Throws an exception since PFixedWidthStrokes are not serializable.
+     *
+     * @return never returns anything
+     */
      public Object clone() {
          throw new UnsupportedOperationException("Not implemented.");
      }
@@ -160,10 +165,22 @@
          return ((BasicStroke) stroke).getLineWidth();
      }

+    /**
+     * Returns the miter limit of this node.
+     *
+     * @return miter limit of this node
+     */
      public float getMiterLimit() {
          return ((BasicStroke) stroke).getMiterLimit();
      }

+    /**
+     * Returns a stroke equivalent to this one, but scaled by the scale
+     * provided.
+     *
+     * @param activeScale scale to apply to the new stoke
+     * @return scaled stroke
+     */
      protected Stroke newStroke(final float activeScale) {
          if (tmpDash != null) {
              for (int i = dash.length - 1; i >= 0; i--) {
@@ -188,6 +205,7 @@
       *
       * @throws ObjectStreamException doesn't actually throw this at all,  
why's
       *             this here?
+     * @return the resolved stroke
       */
      protected Object readResolve() throws ObjectStreamException {
          return new PFixedWidthStroke((BasicStroke) stroke);
=======================================
---  
/piccolo2d.java/trunk/extras/src/main/java/edu/umd/cs/piccolox/util/PLocator.java
        
Tue Jul 28 12:46:54 2009
+++  
/piccolo2d.java/trunk/extras/src/main/java/edu/umd/cs/piccolox/util/PLocator.java
        
Wed Oct 14 08:47:49 2009
@@ -42,23 +42,45 @@
   */
  public abstract class PLocator implements Serializable {

-    /**
-     *
-     */
      private static final long serialVersionUID = 1L;

+    /**
+     * Default constructor provided for subclasses. Does nothing by itself.
+     */
      public PLocator() {
      }

-    public Point2D locatePoint(Point2D aDstPoint) {
+    /**
+     * Locates the point this locator is responsible for finding, and  
stores it
+     * in dstPoints. Should dstPoints be null, it will create a new point  
and
+     * return it.
+     *
+     * @param aDstPoint output parameter to store the located point
+     * @return the located point
+     */
+    public Point2D locatePoint(final Point2D aDstPoint) {
+        Point2D result;
          if (aDstPoint == null) {
-            aDstPoint = new Point2D.Double();
-        }
-        aDstPoint.setLocation(locateX(), locateY());
-        return aDstPoint;
+            result = new Point2D.Double();
+        }
+        else {
+            result = aDstPoint;
+        }
+        result.setLocation(locateX(), locateY());
+        return result;
      }

+    /**
+     * Locates the X component of the position this locator finds.
+     *
+     * @return x component of located point
+     */
      public abstract double locateX();

+    /**
+     * Locates the Y component of the position this locator finds.
+     *
+     * @return y component of located point
+     */
      public abstract double locateY();
  }
=======================================
---  
/piccolo2d.java/trunk/extras/src/main/java/edu/umd/cs/piccolox/util/PNodeLocator.java
    
Tue Jul 28 12:46:54 2009
+++  
/piccolo2d.java/trunk/extras/src/main/java/edu/umd/cs/piccolox/util/PNodeLocator.java
    
Wed Oct 14 08:47:49 2009
@@ -44,29 +44,52 @@
   * @author Jesse Grosjean
   */
  public class PNodeLocator extends PLocator {
+    private static final long serialVersionUID = 1L;
+
+    /** Node being located by this locator. */
+    protected PNode node;

      /**
+     * Constructs a locator responsible for locating the given node.
       *
+     * @param node node to be located
       */
-    private static final long serialVersionUID = 1L;
-    protected PNode node;
-
      public PNodeLocator(final PNode node) {
          setNode(node);
      }

+    /**
+     * Returns the node being located by this locator.
+     *
+     * @return node being located by this locator
+     */
      public PNode getNode() {
          return node;
      }

+    /**
+     * Changes the node being located by this locator.
+     *
+     * @param node new node to have this locator locate.
+     */
      public void setNode(final PNode node) {
          this.node = node;
      }

+    /**
+     * Locates the left of the target node's bounds.
+     *
+     * @return left of target node's bounds
+     */
      public double locateX() {
          return node.getBoundsReference().getCenterX();
      }

+    /**
+     * Locates the top of the target node's bounds.
+     *
+     * @return top of target node's bounds
+     */
      public double locateY() {
          return node.getBoundsReference().getCenterY();
      }
=======================================
---  
/piccolo2d.java/trunk/extras/src/main/java/edu/umd/cs/piccolox/util/POcclusionDetection.java
     
Thu Jul 30 14:59:39 2009
+++  
/piccolo2d.java/trunk/extras/src/main/java/edu/umd/cs/piccolox/util/POcclusionDetection.java
     
Wed Oct 14 08:47:49 2009
@@ -44,11 +44,23 @@
       * the tree determining which parent nodes are occluded by their  
children
       * nodes. Note that this is only detecting a subset of occlusions  
(parent,
       * child), others such as overlapping siblings or cousins are not  
detected.
+     *
+     * @param n node from which to detect occlusions
+     * @param parentBounds bounds of parent node
       */
      public void detectOccusions(final PNode n, final PBounds parentBounds)  
{
          detectOcclusions(n, new PPickPath(null, parentBounds));
      }

+    /**
+     * Traverse the pick path determining which parent nodes are occluded  
by
+     * their children nodes. Note that this is only detecting a subset of
+     * occlusions (parent, child), others such as overlapping siblings or
+     * cousins are not detected.
+     *
+     * @param node node from which to detect occlusions
+     * @param pickPath Pick Path to traverse
+     */
      public void detectOcclusions(final PNode node, final PPickPath  
pickPath) {
          if (!node.fullIntersects(pickPath.getPickBounds())) {
              return;
@@ -60,8 +72,8 @@
          for (int i = count - 1; i >= 0; i--) {
              final PNode each = node.getChild(i);
              if (node.getOccluded()) {
-                // if n has been occuded by a previous decendent then
-                // this child must also be occuded
+                // if n has been occluded by a previous descendant then
+                // this child must also be occluded
                  each.setOccluded(true);
              }
              else {
@@ -80,6 +92,13 @@
          pickPath.popTransform(node.getTransformReference(false));
      }

+    /**
+     * Calculate whether node occludes its parents.
+     *
+     * @param n node to test
+     * @param pickPath pickpath identifying the parents of the node
+     * @return true if parents are occluded by the node
+     */
      private boolean nodeOccludesParents(final PNode n, final PPickPath  
pickPath) {
          return !n.getOccluded() && n.intersects(pickPath.getPickBounds())  
&& n.isOpaque(pickPath.getPickBounds());
      }
=======================================
---  
/piccolo2d.java/trunk/extras/src/main/java/edu/umd/cs/piccolox/util/PSemanticStroke.java
         
Fri Jan 23 12:29:37 2009
+++  
/piccolo2d.java/trunk/extras/src/main/java/edu/umd/cs/piccolox/util/PSemanticStroke.java
         
Wed Oct 14 08:47:49 2009
@@ -49,22 +49,32 @@
      protected final Stroke stroke;

      protected PSemanticStroke(final Stroke stroke) {
-        this.stroke = recentStroke = stroke;
+        this.stroke = stroke;
+        recentStroke = stroke;
          recentScale = 1.0F;
      }

      /**
       * Ask {...@link #getActiveScale()}, call {...@link #newStroke(float)} if
-     * necessary and delegate to {...@link Stroke#createStrokedShape(Shape)}
+     * necessary and delegate to {...@link Stroke#createStrokedShape(Shape)}.
+     *
+     * @param s
       */
      public Shape createStrokedShape(final Shape s) {
          final float currentScale = getActiveScale();
          if (Math.abs(currentScale - recentScale) > THRESHOLD) {
-            recentStroke = newStroke(recentScale = currentScale);
+            recentScale = currentScale;
+            recentStroke = newStroke(recentScale);
          }
          return recentStroke.createStrokedShape(s);
      }

+    /**
+     * Returns true if this stroke is equivalent to the object provided.
+     *
+     * @param obj Object being tested
+     * @return true if object is equivalent
+     */
      public boolean equals(final Object obj) {
          if (this == obj) {
              return true;
@@ -110,8 +120,12 @@

      public int hashCode() {
          final int prime = 31;
-        int result = 1;
-        result = prime * result + (stroke == null ? 0 : stroke.hashCode());
+        int result = prime;
+
+        if (stroke != null) {
+            result += stroke.hashCode();
+        }
+
          return result;
      }

=======================================
---  
/piccolo2d.java/trunk/extras/src/main/java/edu/umd/cs/piccolox/util/Points.java 
 
Fri Jan 23 12:29:37 2009
+++  
/piccolo2d.java/trunk/extras/src/main/java/edu/umd/cs/piccolox/util/Points.java 
 
Wed Oct 14 08:47:49 2009
@@ -31,14 +31,52 @@
  import java.awt.geom.Point2D;
  import java.awt.geom.Rectangle2D;

+/**
+ * Interface for a sequence of points.
+ */
  public interface Points {
-    public int getPointCount();
-
-    public double getX(int i);
-
-    public double getY(int i);
-
-    public Point2D getPoint(int i, Point2D dst);
-
-    public Rectangle2D getBounds(Rectangle2D dst);
-}
+    /**
+     * Returns the number of points in the sequence.
+     *
+     * @return number of points in the sequence
+     */
+    int getPointCount();
+
+    /**
+     * Returns the x component of the point at the given index.
+     *
+     * @param i index of desired point
+     *
+     * @return x component of point
+     */
+    double getX(int i);
+
+    /**
+     * Returns the y component of the point at the given index.
+     *
+     * @param i index of desired point
+     *
+     * @return y component of point
+     */
+    double getY(int i);
+
+    /**
+     * Returns a point representation of the coordinates at the given  
index.
+     *
+     * @param i index of desired point
+     * @param dst output parameter into which the point's details will be
+     *            populated, if null a new one will be created.
+     *
+     * @return a point representation of the coordinates at the given index
+     */
+    Point2D getPoint(int i, Point2D dst);
+
+    /**
+     * Returns the bounds of all the points taken as a whole.
+     *
+     * @param dst output parameter to store bounds into, if null a new  
rectangle
+     *            will be created
+     * @return rectangle containing the bounds
+     */
+    Rectangle2D getBounds(Rectangle2D dst);
+}
=======================================
---  
/piccolo2d.java/trunk/extras/src/main/java/edu/umd/cs/piccolox/util/ShadowUtils.java
     
Thu Aug 20 13:59:03 2009
+++  
/piccolo2d.java/trunk/extras/src/main/java/edu/umd/cs/piccolox/util/ShadowUtils.java
     
Wed Oct 14 08:47:49 2009
@@ -42,6 +42,8 @@
   */
  public final class ShadowUtils {

+    private static final int BLUR_BOUNDS_AFFORDANCE = 4;
+
      /**
       * Private no-arg constructor.
       */
@@ -71,8 +73,8 @@
          if (blurRadius < 1) {
              throw new IllegalArgumentException("blur radius must be  
greater than zero, was " + blurRadius);
          }
-        int w = src.getWidth(null) + (4 * blurRadius);
-        int h = src.getHeight(null) + (4 * blurRadius);
+        int w = src.getWidth(null) + (BLUR_BOUNDS_AFFORDANCE * blurRadius);
+        int h = src.getHeight(null) + (BLUR_BOUNDS_AFFORDANCE *  
blurRadius);

          // paint src image into mask
          BufferedImage mask = new BufferedImage(w, h,  
BufferedImage.TYPE_INT_ARGB);
@@ -114,7 +116,7 @@
           */
          private static float[] createKernel(final int r) {
              int w = (2 * r) + 1;
-            float kernel[] = new float[w * w];
+            float[] kernel = new float[w * w];
              double m = 2.0d * Math.pow((r / 3.0d), 2);
              double n = Math.PI * m;

=======================================
---  
/piccolo2d.java/trunk/extras/src/main/java/edu/umd/cs/piccolox/util/XYArray.java
         
Fri Oct  9 14:15:05 2009
+++  
/piccolo2d.java/trunk/extras/src/main/java/edu/umd/cs/piccolox/util/XYArray.java
         
Wed Oct 14 08:47:49 2009
@@ -32,11 +32,15 @@
  import java.awt.geom.Point2D;
  import java.awt.geom.Rectangle2D;

+/**
+ * Represents a sequence as points that's internally stored as a single  
array of
+ * point components.
+ */
  public class XYArray implements MutablePoints, Cloneable {
      /** The coordinates of the points, specifically 2x the number of  
points. */
      private double[] points = null;

-    /** the number of valid x, y pairs */
+    /** the number of valid x, y pairs. */
      private int numPoints = 0;

      /**
@@ -51,7 +55,7 @@
      /**
       * Constructs an XYArray of the given size.
       *
-     * @param n numbe rof points XYArray should contain
+     * @param n number of points XYArray should contain
       */
      public XYArray(final int n) {
          initPoints(null, n);
@@ -79,13 +83,17 @@
       * @param i index to be normalized
       * @return normalized index
       */
-
      private int normalize(final int i) {
          if (i >= numPoints) {
              throw new IllegalArgumentException("The point index " + i + "  
is not below " + numPoints);
          }

-        return i < 0 ? numPoints + i : i;
+        if (i < 0) {
+            return numPoints + i;
+        }
+        else {
+            return i;
+        }
      }

      /**
@@ -204,26 +212,36 @@
       *            desired
       * @return initialized points
       */
-    public static double[] initPoints(double[] points, final int n, final  
double[] old) {
+    public static double[] initPoints(final double[] points, final int n,  
final double[] old) {
+        final double[] result;
          if (points == null || n * 2 > points.length) {
-            points = new double[n * 2];
-        }
-        if (old != null && points != old) {
-            System.arraycopy(old, 0, points, 0, Math.min(old.length, n *  
2));
-        }
-        return points;
+            result = new double[n * 2];
+        }
+        else {
+            result = points;
+        }
+        if (old != null && result != old) {
+            System.arraycopy(old, 0, result, 0, Math.min(old.length, n *  
2));
+        }
+
+        return result;
      }

      /**
       * Constructs an array of point coordinates for n points.
       *
-     * @param points array to populate with point values, or null to  
generate a
-     *            new array
+     * @param srcPoints array to populate with point values, or null to  
generate
+     *            a new array
       * @param n number of points
       */
-    private void initPoints(final double[] points, final int n) {
-        this.points = initPoints(points, n, this.points);
-        numPoints = points != null ? points.length / 2 : 0;
+    private void initPoints(final double[] srcPoints, final int n) {
+        this.points = initPoints(srcPoints, n, this.points);
+        if (srcPoints == null) {
+            numPoints = 0;
+        }
+        else {
+            numPoints = srcPoints.length / 2;
+        }
      }

      /**
@@ -234,22 +252,26 @@
       * @param start the start index within newPoints to start extracting  
points
       * @param end the end index within newPoints to finish extracting  
points
       */
-    public void addPoints(final int index, final Points newPoints, int  
start, int end) {
+    public void addPoints(final int index, final Points newPoints, final  
int start, final int end) {
+        final int sanitizedEnd;
          if (end < 0) {
-            end = newPoints.getPointCount() + end + 1;
-        }
-        final int n = numPoints + end - start;
+            sanitizedEnd = newPoints.getPointCount() + end + 1;
+        }
+        else {
+            sanitizedEnd = end;
+        }
+        final int n = numPoints + sanitizedEnd - start;
          points = initPoints(points, n, points);
          final int pos1 = index * 2;
-        final int pos2 = (index + end - start) * 2;
+        final int pos2 = (index + sanitizedEnd - start) * 2;
          final int len = (numPoints - index) * 2;

          System.arraycopy(points, pos1, points, pos2, len);

          numPoints = n;
          if (newPoints != null) {
-            for (int count = 0; start < end; count++, start++) {
-                setPoint(index + count, newPoints.getX(start),  
newPoints.getY(start));
+            for (int count = 0, currentPos = start; currentPos <  
sanitizedEnd; count++, currentPos++) {
+                setPoint(index + count, newPoints.getX(currentPos),  
newPoints.getY(currentPos));
              }
          }
      }
@@ -313,13 +335,12 @@
       * @param pos the position to start removing points
       * @param num the number of points to remove
       */
-    public void removePoints(final int pos, int num) {
-        num = Math.min(num, numPoints - pos);
-        if (num <= 0) {
-            return;
-        }
-        System.arraycopy(points, (pos + num) * 2, points, pos * 2,  
(numPoints - (pos + num)) * 2);
-        numPoints -= num;
+    public void removePoints(final int pos, final int num) {
+        int sanitizedNum = Math.min(num, numPoints - pos);
+        if (sanitizedNum > 0) {
+            System.arraycopy(points, (pos + sanitizedNum) * 2, points, pos  
* 2, (numPoints - (pos + sanitizedNum)) * 2);
+            numPoints -= sanitizedNum;
+        }
      }

      /**
@@ -344,6 +365,7 @@
              ps.numPoints = numPoints;
          }
          catch (final CloneNotSupportedException e) {
+
          }

          return ps;

--~--~---------~--~----~------------~-------~--~----~
Piccolo2D Developers Group: http://groups.google.com/group/piccolo2d-dev?hl=en
-~----------~----~----~----~------~----~------~--~---

Reply via email to