Revision: 745
Author: allain.lalonde
Date: Mon Oct 19 10:43:18 2009
Log: Fixing some checkstyle bugs and fixing an infinite recursion bug  
introduced by r727 by me :(
http://code.google.com/p/piccolo2d/source/detail?r=745

Modified:
  /piccolo2d.java/trunk/core/src/main/java/edu/umd/cs/piccolo/PNode.java
   
/piccolo2d.java/trunk/swt/src/main/java/edu/umd/cs/piccolox/swt/PSWTPath.java
   
/piccolo2d.java/trunk/swt/src/main/java/edu/umd/cs/piccolox/swt/SWTGraphics2D.java

=======================================
--- /piccolo2d.java/trunk/core/src/main/java/edu/umd/cs/piccolo/PNode.java      
 
Wed Oct 14 13:39:44 2009
+++ /piccolo2d.java/trunk/core/src/main/java/edu/umd/cs/piccolo/PNode.java      
 
Mon Oct 19 10:43:18 2009
@@ -1454,11 +1454,11 @@
      }

      /**
-     * Set the bounds of this node to the given value. These bounds are  
stored
+     * Set the bounds of this node to the given position and size. These  
bounds are stored
       * in the local coordinate system of this node.
       *
       * If the width or height is less then or equal to zero then the  
bound's
-     * emtpy bit will be set to true.
+     * empty bit will be set to true.
       *
       * Subclasses must call the super.setBounds() method.
       *
=======================================
---  
/piccolo2d.java/trunk/swt/src/main/java/edu/umd/cs/piccolox/swt/PSWTPath.java   
 
Thu Oct 15 06:40:46 2009
+++  
/piccolo2d.java/trunk/swt/src/main/java/edu/umd/cs/piccolox/swt/PSWTPath.java   
 
Mon Oct 19 10:43:18 2009
@@ -69,10 +69,6 @@
   * @author Jesse Grosjean
   */
  public class PSWTPath extends PNode {
-
-    /**
-     *
-     */
      private static final long serialVersionUID = 1L;

      /**
@@ -92,15 +88,24 @@

      private Paint strokePaint;

-    boolean updatingBoundsFromPath;
-    Shape origShape;
-    Shape shape;
-
-    PAffineTransform internalXForm;
-    AffineTransform inverseXForm;
-
-    double[] shapePts;
-
+    private boolean updatingBoundsFromPath;
+    private Shape origShape;
+    private Shape shape;
+
+    private PAffineTransform internalXForm;
+    private AffineTransform inverseXForm;
+
+    private double[] shapePts;
+
+    /**
+     * Creates a path representing the rectangle provided.
+     *
+     * @param x left of rectangle
+     * @param y top of rectangle
+     * @param width width of rectangle
+     * @param height height of rectangle
+     * @return created rectangle
+     */
      public static PSWTPath createRectangle(final float x, final float y,  
final float width, final float height) {
          TEMP_RECTANGLE.setFrame(x, y, width, height);
          final PSWTPath result = new PSWTPath(TEMP_RECTANGLE);
@@ -108,6 +113,17 @@
          return result;
      }

+    /**
+     * Creates a path representing the rounded rectangle provided.
+     *
+     * @param x left of rectangle
+     * @param y top of rectangle
+     * @param width width of rectangle
+     * @param height height of rectangle
+     * @param arcWidth width of the arc at the corners
+     * @param arcHeight height of arc at the corners
+     * @return created rounded rectangle
+     */
      public static PSWTPath createRoundRectangle(final float x, final float  
y, final float width, final float height,
              final float arcWidth, final float arcHeight) {
          TEMP_ROUNDRECTANGLE.setRoundRect(x, y, width, height, arcWidth,  
arcHeight);
@@ -116,6 +132,16 @@
          return result;
      }

+    /**
+     * Creates a path representing an ellipse that covers the rectangle
+     * provided.
+     *
+     * @param x left of rectangle
+     * @param y top of rectangle
+     * @param width width of rectangle
+     * @param height height of rectangle
+     * @return created ellipse
+     */
      public static PSWTPath createEllipse(final float x, final float y,  
final float width, final float height) {
          TEMP_ELLIPSE.setFrame(x, y, width, height);
          final PSWTPath result = new PSWTPath(TEMP_ELLIPSE);
@@ -137,6 +163,9 @@
          return result;
      }

+    /**
+     * Creates an empty PSWTPath.
+     */
      public PSWTPath() {
          strokePaint = DEFAULT_STROKE_PAINT;
      }
@@ -149,14 +178,23 @@
      // ****************************************************************
      // Stroke
      // ****************************************************************
-
+    /**
+     * Returns the paint to use when drawing the stroke of the shape.
+     *
+     * @return path's stroke paint
+     */
      public Paint getStrokePaint() {
          return strokePaint;
      }

-    public void setStrokeColor(final Paint aPaint) {
+    /**
+     * Sets the paint to use when drawing the stroke of the shape.
+     *
+     * @param strokeColor new stroke color
+     */
+    public void setStrokeColor(final Paint strokeColor) {
          final Paint old = strokePaint;
-        strokePaint = aPaint;
+        strokePaint = strokeColor;
          invalidatePaint();
          firePropertyChange(PPath.PROPERTY_CODE_STROKE_PAINT,  
PPath.PROPERTY_STROKE_PAINT, old, strokePaint);
      }
@@ -201,6 +239,11 @@
          }
      }

+    /**
+     * Returns true if this shape intersects the bounds provided.
+     *
+     *
+     */
      public boolean intersects(Rectangle2D aBounds) {
          if (super.intersects(aBounds)) {

@@ -219,6 +262,9 @@
          return false;
      }

+    /**
+     * Recalculates the path's bounds by examining it's associated shape.
+     */
      public void updateBoundsFromPath() {
          updatingBoundsFromPath = true;

@@ -243,7 +289,11 @@
      // ****************************************************************
      // Painting
      // ****************************************************************
-
+    /**
+     * Paints the path on the context provided.
+     *
+     * @param paintContext the context onto which the path will be painted
+     */
      protected void paint(final PPaintContext paintContext) {
          final Paint p = getPaint();
          final SWTGraphics2D g2 = (SWTGraphics2D)  
paintContext.getGraphics();
@@ -254,52 +304,12 @@

          if (p != null) {
              g2.setBackground((Color) p);
-
-            final double lineWidth = g2.getTransformedLineWidth();
-            if (shape instanceof Rectangle2D) {
-                g2.fillRect(shapePts[0] + lineWidth / 2, shapePts[1] +  
lineWidth / 2, shapePts[2] - lineWidth,
-                        shapePts[3] - lineWidth);
-            }
-            else if (shape instanceof Ellipse2D) {
-                g2.fillOval(shapePts[0] + lineWidth / 2, shapePts[1] +  
lineWidth / 2, shapePts[2] - lineWidth,
-                        shapePts[3] - lineWidth);
-            }
-            else if (shape instanceof Arc2D) {
-                g2.fillArc(shapePts[0] + lineWidth / 2, shapePts[1] +  
lineWidth / 2, shapePts[2] - lineWidth,
-                        shapePts[3] - lineWidth, shapePts[4], shapePts[5]);
-            }
-            else if (shape instanceof RoundRectangle2D) {
-                g2.fillRoundRect(shapePts[0] + lineWidth / 2, shapePts[1]  
+ lineWidth / 2, shapePts[2] - lineWidth,
-                        shapePts[3] - lineWidth, shapePts[4], shapePts[5]);
-            }
-            else {
-                g2.fill(shape);
-            }
+            fillShape(g2);
          }

          if (strokePaint != null) {
              g2.setColor((Color) strokePaint);
-
-            final double lineWidth = g2.getTransformedLineWidth();
-            if (shape instanceof Rectangle2D) {
-                g2.drawRect(shapePts[0] + lineWidth / 2, shapePts[1] +  
lineWidth / 2, shapePts[2] - lineWidth,
-                        shapePts[3] - lineWidth);
-            }
-            else if (shape instanceof Ellipse2D) {
-                g2.drawOval(shapePts[0] + lineWidth / 2, shapePts[1] +  
lineWidth / 2, shapePts[2] - lineWidth,
-                        shapePts[3] - lineWidth);
-            }
-            else if (shape instanceof Arc2D) {
-                g2.drawArc(shapePts[0] + lineWidth / 2, shapePts[1] +  
lineWidth / 2, shapePts[2] - lineWidth,
-                        shapePts[3] - lineWidth, shapePts[4], shapePts[5]);
-            }
-            else if (shape instanceof RoundRectangle2D) {
-                g2.drawRoundRect(shapePts[0] + lineWidth / 2, shapePts[1]  
+ lineWidth / 2, shapePts[2] - lineWidth,
-                        shapePts[3] - lineWidth, shapePts[4], shapePts[5]);
-            }
-            else {
-                g2.draw(shape);
-            }
+            drawShape(g2);
          }

          if (inverseXForm != null) {
@@ -307,10 +317,61 @@
          }
      }

-    public void setShape(final Shape aShape) {
-        shape = cloneShape(aShape);
+    private void drawShape(final SWTGraphics2D g2) {
+        final double lineWidth = g2.getTransformedLineWidth();
+        if (shape instanceof Rectangle2D) {
+            g2.drawRect(shapePts[0] + lineWidth / 2, shapePts[1] +  
lineWidth / 2, shapePts[2] - lineWidth, shapePts[3]
+                    - lineWidth);
+        }
+        else if (shape instanceof Ellipse2D) {
+            g2.drawOval(shapePts[0] + lineWidth / 2, shapePts[1] +  
lineWidth / 2, shapePts[2] - lineWidth, shapePts[3]
+                    - lineWidth);
+        }
+        else if (shape instanceof Arc2D) {
+            g2.drawArc(shapePts[0] + lineWidth / 2, shapePts[1] +  
lineWidth / 2, shapePts[2] - lineWidth, shapePts[3]
+                    - lineWidth, shapePts[4], shapePts[5]);
+        }
+        else if (shape instanceof RoundRectangle2D) {
+            g2.drawRoundRect(shapePts[0] + lineWidth / 2, shapePts[1] +  
lineWidth / 2, shapePts[2] - lineWidth,
+                    shapePts[3] - lineWidth, shapePts[4], shapePts[5]);
+        }
+        else {
+            g2.draw(shape);
+        }
+    }
+
+    private void fillShape(final SWTGraphics2D g2) {
+        final double lineWidth = g2.getTransformedLineWidth();
+        if (shape instanceof Rectangle2D) {
+            g2.fillRect(shapePts[0] + lineWidth / 2, shapePts[1] +  
lineWidth / 2, shapePts[2] - lineWidth, shapePts[3]
+                    - lineWidth);
+        }
+        else if (shape instanceof Ellipse2D) {
+            g2.fillOval(shapePts[0] + lineWidth / 2, shapePts[1] +  
lineWidth / 2, shapePts[2] - lineWidth, shapePts[3]
+                    - lineWidth);
+        }
+        else if (shape instanceof Arc2D) {
+            g2.fillArc(shapePts[0] + lineWidth / 2, shapePts[1] +  
lineWidth / 2, shapePts[2] - lineWidth, shapePts[3]
+                    - lineWidth, shapePts[4], shapePts[5]);
+        }
+        else if (shape instanceof RoundRectangle2D) {
+            g2.fillRoundRect(shapePts[0] + lineWidth / 2, shapePts[1] +  
lineWidth / 2, shapePts[2] - lineWidth,
+                    shapePts[3] - lineWidth, shapePts[4], shapePts[5]);
+        }
+        else {
+            g2.fill(shape);
+        }
+    }
+
+    /**
+     * Changes the underlying shape of this PSWTPath.
+     *
+     * @param newShape new associated shape of this PSWTPath
+     */
+    public void setShape(final Shape newShape) {
+        shape = cloneShape(newShape);
          origShape = shape;
-        updateShapePoints(aShape);
+        updateShapePoints(newShape);

          firePropertyChange(PPath.PROPERTY_CODE_PATH, PPath.PROPERTY_PATH,  
null, shape);
          updateBoundsFromPath();
@@ -389,7 +450,7 @@
              final Line2D l2 = (Line2D) aShape;
              return new Line2D.Double(l2.getP1(), l2.getP2());
          }
-        else {
+        else {
              final GeneralPath aPath = new GeneralPath();
              aPath.append(aShape, false);
              return aPath;
=======================================
---  
/piccolo2d.java/trunk/swt/src/main/java/edu/umd/cs/piccolox/swt/SWTGraphics2D.java
       
Thu Oct 15 06:40:46 2009
+++  
/piccolo2d.java/trunk/swt/src/main/java/edu/umd/cs/piccolox/swt/SWTGraphics2D.java
       
Mon Oct 19 10:43:18 2009
@@ -83,24 +83,37 @@
   * @author Lance Good
   */
  public class SWTGraphics2D extends Graphics2D {
-
      private static final boolean DEFAULT_STRING_TRANSPARENCY = true;
+
+    /**
+     * The number of Graphics Contexts active as determined by called to
+     * incrementGCCount and decrementGCCount.
+     */
      protected static int CACHE_COUNT = 0;
+    /** Map from font names to Fonts. */
      protected static HashMap FONT_CACHE = new HashMap();
+    /** Map from awt colors to swt colors. */
      protected static HashMap COLOR_CACHE = new HashMap();
+    /** Map from awt shapess to swt Paths. */
      protected static HashMap SHAPE_CACHE = new HashMap();
+    /** Buffer used to extract the graphics device. */
      protected static BufferedImage BUFFER = new BufferedImage(1, 1,  
BufferedImage.TYPE_INT_ARGB);

-    private static Point PT = new Point();
-    private static Rectangle2D RECT = new Rectangle2D.Double();
-    private static Rectangle2D LINE_RECT = new Rectangle2D.Double();
+    private static Point TEMP_POINT = new Point();
+    private static Rectangle2D TEMP_RECT = new Rectangle2D.Double();
+    private static Rectangle2D TEMP_LINE_RECT = new Rectangle2D.Double();
      private static org.eclipse.swt.graphics.Rectangle SWT_RECT = new  
org.eclipse.swt.graphics.Rectangle(0, 0, 0, 0);

+    /** The Underlying GraphicsContext provided by swt. */
      protected GC gc;
+    /** Device onto which all graphics operations will ultimately take  
place. */
      protected Device device;
+    /** The current transform to apply to drawing operations. */
      protected AffineTransform transform = new AffineTransform();
-    private Transform swtTransform;
+    private final Transform swtTransform;
+    /** The current font to use when drawing text. */
      protected org.eclipse.swt.graphics.Font curFont;
+    /** The current stroke width to use when drawing lines. */
      protected double lineWidth = 1.0;

      /**
@@ -123,9 +136,7 @@
      // GET CLIP
      // //////////////////

-    /**
-     * @see java.awt.Graphics#getClipBounds()
-     */
+    /** {...@inheritdoc} */
      public Rectangle getClipBounds() {
          final org.eclipse.swt.graphics.Rectangle rect = gc.getClipping();
          final Rectangle aRect = new Rectangle(rect.x, rect.y, rect.width,  
rect.height);
@@ -138,10 +149,11 @@
          return aRect;
      }

+    /** {...@inheritdoc} */
      public void clipRect(final int x, final int y, final int width, final  
int height) {
-        RECT.setRect(x, y, width, height);
-        SWTShapeManager.transform(RECT, transform);
-        SWTShapeManager.awtToSWT(RECT, SWT_RECT);
+        TEMP_RECT.setRect(x, y, width, height);
+        SWTShapeManager.transform(TEMP_RECT, transform);
+        SWTShapeManager.awtToSWT(TEMP_RECT, SWT_RECT);

          org.eclipse.swt.graphics.Rectangle clip = gc.getClipping();
          clip = clip.intersection(SWT_RECT);
@@ -149,10 +161,11 @@
          gc.setClipping(clip);
      }

+    /** {...@inheritdoc} */
      public void setClip(final int x, final int y, final int width, final  
int height) {
-        RECT.setRect(x, y, width, height);
-        SWTShapeManager.transform(RECT, transform);
-        SWTShapeManager.awtToSWT(RECT, SWT_RECT);
+        TEMP_RECT.setRect(x, y, width, height);
+        SWTShapeManager.transform(TEMP_RECT, transform);
+        SWTShapeManager.awtToSWT(TEMP_RECT, SWT_RECT);

          gc.setClipping(SWT_RECT);
      }
@@ -174,7 +187,7 @@
      }

      /**
-     * This method isn't really supported by SWT - so will use the shape  
bounds
+     * This method isn't really supported by SWT - so will use the shape  
bounds.
       *
       * @param clip the desired clipping region's shape, will be simplified  
to
       *            its bounds
@@ -192,6 +205,7 @@
          }
      }

+    /** {...@inheritdoc} */
      public Shape getClip() {
          final org.eclipse.swt.graphics.Rectangle rect = gc.getClipping();
          final Rectangle2D aRect = new Rectangle2D.Double(rect.x, rect.y,  
rect.width, rect.height);
@@ -204,10 +218,11 @@
          return aRect;
      }

-    // ///////////////////
-    // DEVICE SPECIFIC
-    // ///////////////////
-
+    /**
+     * Returns a dummy device configuration.
+     *
+     * @return a dummy device configuration
+     */
      public GraphicsConfiguration getDeviceConfiguration() {
          return ((Graphics2D)  
BUFFER.getGraphics()).getDeviceConfiguration();
      }
@@ -216,22 +231,26 @@
      // COLOR METHODS
      // //////////////

+    /** {...@inheritdoc} */
      public Paint getPaint() {
          return getColor();
      }

+    /** {...@inheritdoc} */
      public void setPaint(final Paint paint) {
          if (paint instanceof Color) {
              setColor((Color) paint);
          }
      }

+    /** {...@inheritdoc} */
      public Color getColor() {
          final org.eclipse.swt.graphics.Color color = gc.getForeground();
          final Color awtColor = new Color(color.getRed(), color.getGreen(),  
color.getBlue());
          return awtColor;
      }

+    /** {...@inheritdoc} */
      public void setColor(final Color c) {
          org.eclipse.swt.graphics.Color cachedColor =  
(org.eclipse.swt.graphics.Color) COLOR_CACHE.get(c);
          if (cachedColor == null) {
@@ -241,10 +260,16 @@
          gc.setForeground(cachedColor);
      }

-    public void setColor(final org.eclipse.swt.graphics.Color c) {
-        gc.setForeground(c);
+    /**
+     * Sets the foreground color to the provided swt color.
+     *
+     * @param foregroundColor new foreground color
+     */
+    public void setColor(final org.eclipse.swt.graphics.Color  
foregroundColor) {
+        gc.setForeground(foregroundColor);
      }

+    /** {...@inheritdoc} */
      public void setBackground(final Color c) {
          org.eclipse.swt.graphics.Color cachedColor =  
(org.eclipse.swt.graphics.Color) COLOR_CACHE.get(c);
          if (cachedColor == null) {
@@ -254,10 +279,16 @@
          gc.setBackground(cachedColor);
      }

-    public void setBackground(final org.eclipse.swt.graphics.Color c) {
-        gc.setBackground(c);
+    /**
+     * Sets the background color to the provided swt color.
+     *
+     * @param backgroundColor new background color
+     */
+    public void setBackground(final org.eclipse.swt.graphics.Color  
backgroundColor) {
+        gc.setBackground(backgroundColor);
      }

+    /** {...@inheritdoc} */
      public Color getBackground() {
          final org.eclipse.swt.graphics.Color color = gc.getBackground();
          final Color awtColor = new Color(color.getRed(), color.getGreen(),  
color.getBlue());
@@ -268,15 +299,26 @@
      // FONT METHODS
      // //////////////

+    /**
+     * Returns the current swt font to use when drawing.
+     *
+     * @return current swt font
+     */
      public org.eclipse.swt.graphics.Font getSWTFont() {
          return curFont;
      }

+    /**
+     * Returns the font metrics of the current SWT font.
+     *
+     * @return font metrics of the current SWT font
+     */
      public org.eclipse.swt.graphics.FontMetrics getSWTFontMetrics() {
          gc.setFont(curFont);
          return gc.getFontMetrics();
      }

+    /** {...@inheritdoc} */
      public Font getFont() {
          if (curFont != null) {
              int style = Font.PLAIN;
@@ -299,6 +341,7 @@
          }
      }

+    /** {...@inheritdoc} */
      public void setFont(final Font font) {
          final String fontString = "name=" + font.getFamily() + ";bold=" +  
font.isBold() + ";italic=" + font.isItalic()
                  + ";size=" + font.getSize();
@@ -306,10 +349,17 @@
          curFont = getFont(fontString);
      }

+    /** {...@inheritdoc} */
      public void setFont(final org.eclipse.swt.graphics.Font font) {
          curFont = font;
      }

+    /**
+     * Returns the SWT font matching the given font string.
+     *
+     * @param fontString description of the font desired
+     * @return matching font, or null if not found
+     */
      public org.eclipse.swt.graphics.Font getFont(final String fontString) {
          org.eclipse.swt.graphics.Font cachedFont =  
(org.eclipse.swt.graphics.Font) FONT_CACHE.get(fontString);
          if (cachedFont == null) {
@@ -339,15 +389,18 @@
      }

      /**
+     * Deprecated since SWT now handles this.
+     *
       * @deprecated
+     * @return font that's been transformed by the current transform
       */
      protected org.eclipse.swt.graphics.Font getTransformedFont() {
          if (curFont != null) {
              final FontData fontData = curFont.getFontData()[0];
              int height = fontData.getHeight();
-            RECT.setRect(0, 0, height, height);
-            SWTShapeManager.transform(RECT, transform);
-            height = (int) (RECT.getHeight() + 0.5);
+            TEMP_RECT.setRect(0, 0, height, height);
+            SWTShapeManager.transform(TEMP_RECT, transform);
+            height = (int) (TEMP_RECT.getHeight() + 0.5);

              final String fontString = "name=" + fontData.getName()  
+ ";bold=" + ((fontData.getStyle() & SWT.BOLD) != 0)
                      + ";italic=" + ((fontData.getStyle() & SWT.ITALIC) !=  
0) + ";size=" + height;
@@ -360,46 +413,55 @@
      // AFFINE TRANSFORM METHODS
      // /////////////////////////

+    /** {...@inheritdoc} */
      public void translate(final int x, final int y) {
          transform.translate(x, y);
          updateSWTTransform();
      }

+    /** {...@inheritdoc} */
      public void translate(final double tx, final double ty) {
          transform.translate(tx, ty);
          updateSWTTransform();
      }

+    /** {...@inheritdoc} */
      public void rotate(final double theta) {
          transform.rotate(theta);
          updateSWTTransform();
      }

+    /** {...@inheritdoc} */
      public void rotate(final double theta, final double x, final double y)  
{
          transform.rotate(theta, x, y);
          updateSWTTransform();
      }

+    /** {...@inheritdoc} */
      public void scale(final double sx, final double sy) {
          transform.scale(sx, sy);
          updateSWTTransform();
      }

+    /** {...@inheritdoc} */
      public void shear(final double shx, final double shy) {
          transform.shear(shx, shy);
          updateSWTTransform();
      }

+    /** {...@inheritdoc} */
      public void transform(final AffineTransform Tx) {
          transform.concatenate(Tx);
          updateSWTTransform();
      }

+    /** {...@inheritdoc} */
      public void setTransform(final AffineTransform Tx) {
          transform = (AffineTransform) Tx.clone();
          updateSWTTransform();
      }

+    /** {...@inheritdoc} */
      public AffineTransform getTransform() {
          return (AffineTransform) transform.clone();
      }
@@ -411,7 +473,7 @@
       * Updates the SWT transform instance such that it matches AWTs  
counterpart.
       */
      private void updateSWTTransform() {
-        double[] m = new double[6];
+        final double[] m = new double[6];
          transform.getMatrix(m);
          swtTransform.setElements((float) m[0], (float) m[1], (float) m[2],  
(float) m[3], (float) m[4], (float) m[5]);
      }
@@ -423,14 +485,13 @@
       * @return the corresponding path object. Must be disposed() when no  
longer
       *         used.
       */
-
-    private Path pathIterator2Path(PathIterator iter) {
-        float[] coords = new float[6];
-
-        Path path = new Path(device);
+    private Path pathIterator2Path(final PathIterator iter) {
+        final float[] coords = new float[6];
+
+        final Path path = new Path(device);

          while (!iter.isDone()) {
-            int type = iter.currentSegment(coords);
+            final int type = iter.currentSegment(coords);

              switch (type) {
                  case PathIterator.SEG_MOVETO:
@@ -452,6 +513,8 @@
                  case PathIterator.SEG_CUBICTO:
                      path.cubicTo(coords[0], coords[1], coords[2],  
coords[3], coords[4], coords[5]);
                      break;
+                default:
+                    // log this?
              }

              iter.next();
@@ -459,15 +522,12 @@
          return path;
      }

-    // /////////////////////////////
-    // /////////////////////////////
-    // DRAWING AND FILLING METHODS
-    // /////////////////////////////
-
+    /** {...@inheritdoc} */
      public void clearRect(final int x, final int y, final int width, final  
int height) {
          fillRect(x, y, width, height);
      }

+    /** {...@inheritdoc} */
      public void draw(final Shape s) {
          if (s instanceof Rectangle2D) {
              final Rectangle2D r2 = (Rectangle2D) s;
@@ -495,6 +555,7 @@
          }
      }

+    /** {...@inheritdoc} */
      public void fill(final Shape s) {
          if (s instanceof Rectangle2D) {
              final Rectangle2D r2 = (Rectangle2D) s;
@@ -522,11 +583,12 @@
          }
      }

+    /** {...@inheritdoc} */
      public void drawPolyline(final int[] xPoints, final int[] yPoints,  
final int nPoints) {
          final int[] ptArray = new int[2 * nPoints];
          for (int i = 0; i < nPoints; i++) {
-            PT.setLocation(xPoints[i], yPoints[i]);
-            transform.transform(PT, PT);
+            TEMP_POINT.setLocation(xPoints[i], yPoints[i]);
+            transform.transform(TEMP_POINT, TEMP_POINT);
              ptArray[2 * i] = xPoints[i];
              ptArray[2 * i + 1] = yPoints[i];
          }
@@ -535,16 +597,18 @@
          gc.drawPolyline(ptArray);
      }

+    /** {...@inheritdoc} */
      public void drawPolyline(final double[] pts) {
          final int[] intPts = SWTShapeManager.transform(pts, transform);
          gc.drawPolyline(intPts);
      }

+    /** {...@inheritdoc} */
      public void drawPolygon(final int[] xPoints, final int[] yPoints,  
final int nPoints) {
          final int[] ptArray = new int[2 * nPoints];
          for (int i = 0; i < nPoints; i++) {
-            PT.setLocation(xPoints[i], yPoints[i]);
-            transform.transform(PT, PT);
+            TEMP_POINT.setLocation(xPoints[i], yPoints[i]);
+            transform.transform(TEMP_POINT, TEMP_POINT);
              ptArray[2 * i] = xPoints[i];
              ptArray[2 * i + 1] = yPoints[i];
          }
@@ -552,16 +616,18 @@
          gc.drawPolygon(ptArray);
      }

+    /** {...@inheritdoc} */
      public void fillPolygon(final double[] pts) {
          final int[] intPts = SWTShapeManager.transform(pts, transform);
          gc.fillPolygon(intPts);
      }

+    /** {...@inheritdoc} */
      public void fillPolygon(final int[] xPoints, final int[] yPoints,  
final int nPoints) {
          final int[] ptArray = new int[2 * nPoints];
          for (int i = 0; i < nPoints; i++) {
-            PT.setLocation(xPoints[i], yPoints[i]);
-            transform.transform(PT, PT);
+            TEMP_POINT.setLocation(xPoints[i], yPoints[i]);
+            transform.transform(TEMP_POINT, TEMP_POINT);
              ptArray[2 * i] = xPoints[i];
              ptArray[2 * i + 1] = yPoints[i];
          }
@@ -569,22 +635,33 @@
          gc.fillPolygon(ptArray);
      }

+    /** {...@inheritdoc} */
      public void drawLine(final int x1, final int y1, final int x2, final  
int y2) {
          drawLine((double) x1, (double) y1, (double) x2, (double) y2);
      }

-    public void drawLine(double x1, double y1, double x2, double y2) {
-        PT.setLocation(x1, y1);
-        transform.transform(PT, PT);
-        x1 = (int) PT.getX();
-        y1 = (int) PT.getY();
-        PT.setLocation(x2, y2);
-        transform.transform(PT, PT);
-        x2 = (int) PT.getX();
-        y2 = (int) PT.getY();
+    /**
+     * Draws a line, using the current color, between the points (x1, y1)  
and
+     * (x2, y2) in this graphics context's coordinate system.
+     *
+     * @param x1 the first point's x coordinate.
+     * @param y1 the first point's y coordinate.
+     * @param x2 the second point's x coordinate.
+     * @param y2 the second point's y coordinate.
+     */
+    public void drawLine(final double x1, final double y1, final double  
x2, final double y2) {
+        TEMP_POINT.setLocation(x1, y1);
+        transform.transform(TEMP_POINT, TEMP_POINT);
+        final double transformedX1 = (int) TEMP_POINT.getX();
+        final double transformedY1 = (int) TEMP_POINT.getY();
+        TEMP_POINT.setLocation(x2, y2);
+        transform.transform(TEMP_POINT, TEMP_POINT);
+        final double transformedX2 = (int) TEMP_POINT.getX();
+        final double transformedY2 = (int) TEMP_POINT.getY();

          gc.setLineWidth(getTransformedLineWidth());
-        gc.drawLine((int) (x1 + 0.5), (int) (y1 + 0.5), (int) (x2 + 0.5),  
(int) (y2 + 0.5));
+        gc.drawLine((int) (transformedX1 + 0.5), (int) (transformedY1 +  
0.5), (int) (transformedX2 + 0.5),
+                (int) (transformedY2 + 0.5));
      }

      //  
**************************************************************************
@@ -593,240 +670,538 @@
      //  
**************************************************************************
      // *

+    /**
+     * Copies the image to the specified position.
+     *
+     * @param img swt image to be copied
+     * @param x x component of position
+     * @param y y component of position
+     */
      public void copyArea(final org.eclipse.swt.graphics.Image img, final  
double x, final double y) {
-        PT.setLocation(x, y);
-        transform.transform(PT, PT);
-
-        gc.copyArea(img, (int) (PT.getX() + 0.5), (int) (PT.getY() + 0.5));
+        TEMP_POINT.setLocation(x, y);
+        transform.transform(TEMP_POINT, TEMP_POINT);
+
+        gc.copyArea(img, (int) (TEMP_POINT.getX() + 0.5), (int)  
(TEMP_POINT.getY() + 0.5));
      }

+    /** {...@inheritdoc} */
      public void copyArea(final int x, final int y, final int width, final  
int height, final int dx, final int dy) {
-        RECT.setRect(x, y, width, height);
-        SWTShapeManager.transform(RECT, transform);
-
-        PT.setLocation(dx, dy);
-        transform.transform(PT, PT);
-        gc.copyArea((int) RECT.getX(), (int) RECT.getY(), (int)  
RECT.getWidth(), (int) RECT.getHeight(), (int) PT
-                .getX(), (int) PT.getY());
+        TEMP_RECT.setRect(x, y, width, height);
+        SWTShapeManager.transform(TEMP_RECT, transform);
+
+        TEMP_POINT.setLocation(dx, dy);
+        transform.transform(TEMP_POINT, TEMP_POINT);
+        gc.copyArea((int) TEMP_RECT.getX(), (int) TEMP_RECT.getY(), (int)  
TEMP_RECT.getWidth(), (int) TEMP_RECT
+                .getHeight(), (int) TEMP_POINT.getX(), (int)  
TEMP_POINT.getY());
      }

-    public void drawString(String str, int x, int y, boolean  
isTransparent) {
+    /**
+     * Renders the text of the specified String, using the current text
+     * attribute state in the Graphics2D context. The baseline of the first
+     * character is at position (x, y) in the User Space. The rendering
+     * attributes applied include the Clip, Transform, Paint, Font and  
Composite
+     * attributes. For characters in script systems such as Hebrew and  
Arabic,
+     * the glyphs can be rendered from right to left, in which case the
+     * coordinate supplied is the location of the leftmost character on the
+     * baseline.
+     *
+     * @param str the string to be rendered
+     * @param x the x coordinate of the location where the String should be
+     *            rendered
+     * @param y the y coordinate of the location where the String should be
+     *            rendered
+     * @param isTransparent whether a background should be painted behind  
the
+     *            text
+     */
+    public void drawString(final String str, final int x, final int y,  
final boolean isTransparent) {
          gc.setTransform(swtTransform);
          gc.drawString(str, x, y, isTransparent);
          gc.setTransform(null);
      }

+    /** {...@inheritdoc} */
      public void drawString(final String str, final int x, final int y) {
          drawString(str, x, y, DEFAULT_STRING_TRANSPARENCY);
      }

-    public void drawString(String str, double x, double y) {
+    /**
+     * Renders the text of the specified String, using the current text
+     * attribute state in the Graphics2D context. The baseline of the first
+     * character is at position (x, y) in the User Space. The rendering
+     * attributes applied include the Clip, Transform, Paint, Font and  
Composite
+     * attributes. For characters in script systems such as Hebrew and  
Arabic,
+     * the glyphs can be rendered from right to left, in which case the
+     * coordinate supplied is the location of the leftmost character on the
+     * baseline.
+     *
+     * @param str the string to be rendered
+     * @param x the x coordinate of the location where the String should be
+     *            rendered
+     * @param y the y coordinate of the location where the String should be
+     *            rendered
+     */
+    public void drawString(final String str, final double x, final double  
y) {
          drawString(str, (int) (x + 0.5), (int) (y + 0.5));
      }

-    public void drawString(String str, double x, double y, boolean  
isTransparent) {
+    /**
+     * Renders the text of the specified String, using the current text
+     * attribute state in the Graphics2D context. The baseline of the first
+     * character is at position (x, y) in the User Space. The rendering
+     * attributes applied include the Clip, Transform, Paint, Font and  
Composite
+     * attributes. For characters in script systems such as Hebrew and  
Arabic,
+     * the glyphs can be rendered from right to left, in which case the
+     * coordinate supplied is the location of the leftmost character on the
+     * baseline.
+     *
+     * @param str the string to be rendered
+     * @param x the x coordinate of the location where the String should be
+     *            rendered
+     * @param y the y coordinate of the location where the String should be
+     *            rendered
+     * @param isTransparent whether a background should be painted behind  
the
+     *            text
+     */
+    public void drawString(final String str, final double x, final double  
y, final boolean isTransparent) {
          drawString(str, (int) (x + 0.5), (int) (y + 0.5), isTransparent);
      }

+    /** {...@inheritdoc} */
      public void drawString(final String str, final float x, final float y)  
{
          drawString(str, (int) (x + 0.5), (int) (y + 0.5));
      }

-    public void drawText(final String s, final double x, final double y) {
-        drawString(s, (int) (x + 0.5), (int) (y + 0.5));
+    /**
+     * Renders the text of the specified String, using the current text
+     * attribute state in the Graphics2D context. The baseline of the first
+     * character is at position (x, y) in the User Space. The rendering
+     * attributes applied include the Clip, Transform, Paint, Font and  
Composite
+     * attributes. For characters in script systems such as Hebrew and  
Arabic,
+     * the glyphs can be rendered from right to left, in which case the
+     * coordinate supplied is the location of the leftmost character on the
+     * baseline.
+     *
+     * @param str the string to be rendered
+     * @param x the x coordinate of the location where the String should be
+     *            rendered
+     * @param y the y coordinate of the location where the String should be
+     *            rendered
+     */
+    public void drawText(final String str, final double x, final double y)  
{
+        drawString(str, (int) (x + 0.5), (int) (y + 0.5));
      }

-    public void drawText(final String s, final double x, final double y,  
final int flags) {
-        drawText(s, (int) (x + 0.5), (int) (y + 0.5), flags);
+    /**
+     * Renders the text of the specified String, using the current text
+     * attribute state in the Graphics2D context. The baseline of the first
+     * character is at position (x, y) in the User Space. The rendering
+     * attributes applied include the Clip, Transform, Paint, Font and  
Composite
+     * attributes. For characters in script systems such as Hebrew and  
Arabic,
+     * the glyphs can be rendered from right to left, in which case the
+     * coordinate supplied is the location of the leftmost character on the
+     * baseline.
+     *
+     * @param str the string to be rendered
+     * @param x the x coordinate of the location where the String should be
+     *            rendered
+     * @param y the y coordinate of the location where the String should be
+     *            rendered
+     * @param flags flags to apply to the string as defined by SWT
+     */
+    public void drawText(final String str, final double x, final double y,  
final int flags) {
+        drawText(str, (int) (x + 0.5), (int) (y + 0.5), flags);
      }

+    /**
+     * Renders the text of the specified String, using the current text
+     * attribute state in the Graphics2D context. The baseline of the first
+     * character is at position (x, y) in the User Space. The rendering
+     * attributes applied include the Clip, Transform, Paint, Font and  
Composite
+     * attributes. For characters in script systems such as Hebrew and  
Arabic,
+     * the glyphs can be rendered from right to left, in which case the
+     * coordinate supplied is the location of the leftmost character on the
+     * baseline.
+     *
+     * @param str the string to be rendered
+     * @param x the x coordinate of the location where the String should be
+     *            rendered
+     * @param y the y coordinate of the location where the String should be
+     *            rendered
+     * @param flags flags to apply to the string as defined by SWT
+     */
+    public void drawText(final String str, final int x, final int y, final  
int flags) {
+        gc.setTransform(swtTransform);
+        gc.drawText(str, x, y, flags);
+        gc.setTransform(null);
+    }
+
+    /** {...@inheritdoc} */
      public void drawRect(final int x, final int y, final int width, final  
int height) {
          drawRect((double) x, (double) y, (double) width, (double) height);
      }

+    /**
+     * Draws the outline of the specified rectangle. The left and right  
edges of
+     * the rectangle are at x and x + width. The top and bottom edges are  
at y
+     * and y + height. The rectangle is drawn using the graphics context's
+     * current color.
+     *
+     * @param x the x coordinate of the rectangle to be drawn.
+     * @param y the y coordinate of the rectangle to be drawn.
+     * @param width the width of the rectangle to be drawn.
+     * @param height the height of the rectangle to be drawn.
+     */
      public void drawRect(final double x, final double y, final double  
width, final double height) {
-        RECT.setRect(x, y, width, height);
-        SWTShapeManager.transform(RECT, transform);
-        SWTShapeManager.awtToSWT(RECT, SWT_RECT);
+        TEMP_RECT.setRect(x, y, width, height);
+        SWTShapeManager.transform(TEMP_RECT, transform);
+        SWTShapeManager.awtToSWT(TEMP_RECT, SWT_RECT);

          gc.setLineWidth(getTransformedLineWidth());
          gc.drawRectangle(SWT_RECT);
      }

+    /** {...@inheritdoc} */
      public void fillRect(final int x, final int y, final int width, final  
int height) {
          fillRect((double) x, (double) y, (double) width, (double) height);
      }

+    /**
+     * Fills the specified rectangle. The left and right edges of the  
rectangle
+     * are at x and x + width - 1. The top and bottom edges are at y and y  
+
+     * height - 1. The resulting rectangle covers an area width pixels  
wide by
+     * height pixels tall. The rectangle is filled using the graphics  
context's
+     * current color.
+     *
+     * @param x the x coordinate of the rectangle to be filled.
+     * @param y the y coordinate of the rectangle to be filled.
+     * @param width the width of the rectangle to be filled.
+     * @param height the height of the rectangle to be filled.
+     */
      public void fillRect(final double x, final double y, final double  
width, final double height) {
-        RECT.setRect(x, y, width, height);
-        SWTShapeManager.transform(RECT, transform);
-        SWTShapeManager.awtToSWT(RECT, SWT_RECT);
+        TEMP_RECT.setRect(x, y, width, height);
+        SWTShapeManager.transform(TEMP_RECT, transform);
+        SWTShapeManager.awtToSWT(TEMP_RECT, SWT_RECT);

          gc.fillRectangle(SWT_RECT);
      }

+    /** {...@inheritdoc} */
      public void drawRoundRect(final int x, final int y, final int width,  
final int height, final int arcWidth,
              final int arcHeight) {
          drawRoundRect((double) x, (double) y, (double) width, (double)  
height, (double) arcWidth, (double) arcHeight);
      }

-    public void drawRoundRect(double x, double y, double width, double  
height, double arcWidth, double arcHeight) {
-        RECT.setRect(x, y, width, height);
-        SWTShapeManager.transform(RECT, transform);
-        x = RECT.getX();
-        y = RECT.getY();
-        width = RECT.getWidth();
-        height = RECT.getHeight();
-
-        RECT.setRect(0, 0, arcWidth, arcHeight);
-        SWTShapeManager.transform(RECT, transform);
-        arcWidth = RECT.getWidth();
-        arcHeight = RECT.getHeight();
+    /**
+     * Draws an outlined round-cornered rectangle using this graphics  
context's
+     * current color. The left and right edges of the rectangle are at x  
and x +
+     * width, respectively. The top and bottom edges of the rectangle are  
at y
+     * and y + height.
+     *
+     * @param x the x coordinate of the rectangle to be drawn.
+     * @param y the y coordinate of the rectangle to be drawn.
+     * @param width the width of the rectangle to be drawn.
+     * @param height the height of the rectangle to be drawn.
+     * @param arcWidth the horizontal diameter of the arc at the four  
corners.
+     * @param arcHeight the vertical diameter of the arc at the four  
corners.
+     */
+    public void drawRoundRect(final double x, final double y, final double  
width, final double height,
+            final double arcWidth, final double arcHeight) {
+        TEMP_RECT.setRect(x, y, width, height);
+        SWTShapeManager.transform(TEMP_RECT, transform);
+        final double tx = TEMP_RECT.getX();
+        final double ty = TEMP_RECT.getY();
+        final double twidth = TEMP_RECT.getWidth();
+        final double theight = TEMP_RECT.getHeight();
+
+        TEMP_RECT.setRect(0, 0, arcWidth, arcHeight);
+        SWTShapeManager.transform(TEMP_RECT, transform);
+        final double tarcWidth = TEMP_RECT.getWidth();
+        final double tarcHeight = TEMP_RECT.getHeight();

          gc.setLineWidth(getTransformedLineWidth());
-        gc.drawRoundRectangle((int) (x + 0.5), (int) (y + 0.5), (int)  
(width + 0.5), (int) (height + 0.5),
-                (int) (arcWidth + 0.5), (int) (arcHeight + 0.5));
+        gc.drawRoundRectangle((int) (tx + 0.5), (int) (ty + 0.5), (int)  
(twidth + 0.5), (int) (theight + 0.5),
+                (int) (tarcWidth + 0.5), (int) (tarcHeight + 0.5));
      }

+    /** {...@inheritdoc} */
      public void fillRoundRect(final int x, final int y, final int width,  
final int height, final int arcWidth,
              final int arcHeight) {
          fillRoundRect((double) x, (double) y, (double) width, (double)  
height, (double) arcWidth, (double) arcHeight);
      }

-    public void fillRoundRect(double x, double y, double width, double  
height, double arcWidth, double arcHeight) {
-        RECT.setRect(x, y, width, height);
-        SWTShapeManager.transform(RECT, transform);
-        x = RECT.getX();
-        y = RECT.getY();
-        width = RECT.getWidth();
-        height = RECT.getHeight();
-
-        RECT.setRect(0, 0, arcWidth, arcHeight);
-        SWTShapeManager.transform(RECT, transform);
-        arcWidth = RECT.getWidth();
-        arcHeight = RECT.getHeight();
+    /**
+     * Fills the specified rounded corner rectangle with the current  
color. The
+     * left and right edges of the rectangle are at x and x + width - 1,
+     * respectively. The top and bottom edges of the rectangle are at y  
and y +
+     * height - 1.
+     *
+     *...@param x the x coordinate of the rectangle to be filled.
+     *...@param y the y coordinate of the rectangle to be filled.
+     *...@param width the width of the rectangle to be filled.
+     *...@param height the height of the rectangle to be filled.
+     *...@param arcWidth the horizontal diameter of the arc at the four  
corners.
+     *...@param arcHeight the vertical diameter of the arc at the four  
corners.
+     */
+    public void fillRoundRect(final double x, final double y, final double  
width, final double height,
+            final double arcWidth, final double arcHeight) {
+        TEMP_RECT.setRect(x, y, width, height);
+        SWTShapeManager.transform(TEMP_RECT, transform);
+        final double tx = TEMP_RECT.getX();
+        final double ty = TEMP_RECT.getY();
+        final double twidth = TEMP_RECT.getWidth();
+        final double theight = TEMP_RECT.getHeight();
+
+        TEMP_RECT.setRect(0, 0, arcWidth, arcHeight);
+        SWTShapeManager.transform(TEMP_RECT, transform);
+        final double tarcWidth = TEMP_RECT.getWidth();
+        final double tarcHeight = TEMP_RECT.getHeight();

          gc.setLineWidth(getTransformedLineWidth());
-        gc.fillRoundRectangle((int) (x + 0.5), (int) (y + 0.5), (int)  
(width + 0.5), (int) (height + 0.5),
-                (int) (arcWidth + 0.5), (int) (arcHeight + 0.5));
+        gc.fillRoundRectangle((int) (tx + 0.5), (int) (ty + 0.5), (int)  
(twidth + 0.5), (int) (theight + 0.5),
+                (int) (tarcWidth + 0.5), (int) (tarcHeight + 0.5));
      }

+    /** {...@inheritdoc} */
      public void drawOval(final int x, final int y, final int width, final  
int height) {
          drawOval((double) x, (double) y, (double) width, (double) height);
      }

+    /**
+     * Draws the outline of an oval. The result is a circle or ellipse  
that fits
+     * within the rectangle specified by the x, y, width, and height  
arguments.
+     * The oval covers an area that is width + 1 pixels wide and height + 1
+     * pixels tall.
+     *
+     * @param x the x coordinate of the upper left corner of the oval to be
+     *            drawn.
+     * @param y the y coordinate of the upper left corner of the oval to be
+     *            drawn.
+     * @param width the width of the oval to be drawn.
+     * @param height the height of the oval to be drawn.
+     */
      public void drawOval(final double x, final double y, final double  
width, final double height) {
-        RECT.setRect(x, y, width, height);
-        SWTShapeManager.transform(RECT, transform);
+        TEMP_RECT.setRect(x, y, width, height);
+        SWTShapeManager.transform(TEMP_RECT, transform);

          gc.setLineWidth(getTransformedLineWidth());
-        gc.drawOval((int) (RECT.getX() + 0.5), (int) (RECT.getY() + 0.5),  
(int) (RECT.getWidth() + 0.5), (int) (RECT
-                .getHeight() + 0.5));
+        gc.drawOval((int) (TEMP_RECT.getX() + 0.5), (int)  
(TEMP_RECT.getY() + 0.5), (int) (TEMP_RECT.getWidth() + 0.5),
+                (int) (TEMP_RECT.getHeight() + 0.5));
      }

+    /** {...@inheritdoc} */
      public void fillOval(final int x, final int y, final int width, final  
int height) {
          fillOval((double) x, (double) y, (double) width, (double) height);
      }

+    /**
+     * Fills an oval bounded by the specified rectangle with the current  
color.
+     *
+     * @param x the x coordinate of the upper left corner of the oval to be
+     *            filled.
+     * @param y the y coordinate of the upper left corner of the oval to be
+     *            filled.
+     * @param width the width of the oval to be filled.
+     * @param height the height of the oval to be filled.
+     */
      public void fillOval(final double x, final double y, final double  
width, final double height) {
-        RECT.setRect(x, y, width, height);
-        SWTShapeManager.transform(RECT, transform);
-
-        gc.fillOval((int) (RECT.getX() + 0.5), (int) (RECT.getY() + 0.5),  
(int) (RECT.getWidth() + 0.5), (int) (RECT
-                .getHeight() + 0.5));
+        TEMP_RECT.setRect(x, y, width, height);
+        SWTShapeManager.transform(TEMP_RECT, transform);
+
+        gc.fillOval((int) (TEMP_RECT.getX() + 0.5), (int)  
(TEMP_RECT.getY() + 0.5), (int) (TEMP_RECT.getWidth() + 0.5),
+                (int) (TEMP_RECT.getHeight() + 0.5));
      }

+    /** {...@inheritdoc} */
      public void drawArc(final int x, final int y, final int width, final  
int height, final int startAngle,
              final int extent) {
          drawArc((double) x, (double) y, (double) width, (double) height,  
(double) startAngle, (double) extent);
      }

+    /**
+     * Draws the outline of a circular or elliptical arc covering the  
specified
+     * rectangle.
+     *
+     * The resulting arc begins at startAngle and extends for arcAngle  
degrees,
+     * using the current color. Angles are interpreted such that 0 degrees  
is at
+     * the 3 o'clock position. A positive value indicates a  
counter-clockwise
+     * rotation while a negative value indicates a clockwise rotation.
+     *
+     * The center of the arc is the center of the rectangle whose origin  
is (x,
+     * y) and whose size is specified by the width and height arguments.
+     *
+     * The resulting arc covers an area width + 1 pixels wide by height + 1
+     * pixels tall.
+     *
+     * The angles are specified relative to the non-square extents of the
+     * bounding rectangle such that 45 degrees always falls on the line  
from the
+     * center of the ellipse to the upper right corner of the bounding
+     * rectangle. As a result, if the bounding rectangle is noticeably  
longer in
+     * one axis than the other, the angles to the start and end of the arc
+     * segment will be skewed farther along the longer axis of the bounds.
+     *
+     * @param x the x coordinate of the upper-left corner of the arc to be
+     *            drawn.
+     * @param y the y coordinate of the upper-left corner of the arc to be
+     *            drawn.
+     * @param width the width of the arc to be drawn.
+     * @param height the height of the arc to be drawn.
+     * @param startAngle the beginning angle.
+     * @param extent the angular extent of the arc, relative to the start  
angle.
+     */
      public void drawArc(final double x, final double y, final double  
width, final double height,
              final double startAngle, final double extent) {
-        RECT.setRect(x, y, width, height);
-        SWTShapeManager.transform(RECT, transform);
+        TEMP_RECT.setRect(x, y, width, height);
+        SWTShapeManager.transform(TEMP_RECT, transform);

          gc.setLineWidth(getTransformedLineWidth());
-        gc.drawArc((int) (RECT.getX() + 0.5), (int) (RECT.getY() + 0.5),  
(int) (RECT.getWidth() + 0.5), (int) (RECT
-                .getHeight() + 0.5), (int) (startAngle + 0.5), (int)  
(startAngle + extent + 0.5));
+        gc.drawArc((int) (TEMP_RECT.getX() + 0.5), (int) (TEMP_RECT.getY()  
+ 0.5), (int) (TEMP_RECT.getWidth() + 0.5),
+                (int) (TEMP_RECT.getHeight() + 0.5), (int) (startAngle +  
0.5), (int) (startAngle + extent + 0.5));
      }

+    /** {...@inheritdoc} */
      public void fillArc(final int x, final int y, final int width, final  
int height, final int startAngle,
              final int extent) {
          drawArc((double) x, (double) y, (double) width, (double) height,  
(double) startAngle, (double) extent);
      }

+    /**
+     * Draws a filledArc with the options provided.
+     *
+     * @param x the x coordinate of the upper-left corner of the arc to be
+     *            filled.
+     * @param y the y coordinate of the upper-left corner of the arc to be
+     *            filled.
+     * @param width the width of the arc to be filled.
+     * @param height the height of the arc to be filled.
+     * @param startAngle the beginning angle.
+     * @param extent the angular extent of the arc, relative to the start  
angle.
+     */
      public void fillArc(final double x, final double y, final double  
width, final double height,
              final double startAngle, final double extent) {
-        RECT.setRect(x, y, width, height);
-        SWTShapeManager.transform(RECT, transform);
-
-        gc.drawArc((int) (RECT.getX() + 0.5), (int) (RECT.getY() + 0.5),  
(int) (RECT.getWidth() + 0.5), (int) (RECT
-                .getHeight() + 0.5), (int) (startAngle + 0.5), (int)  
(startAngle + extent + 0.5));
+        TEMP_RECT.setRect(x, y, width, height);
+        SWTShapeManager.transform(TEMP_RECT, transform);
+
+        gc.drawArc((int) (TEMP_RECT.getX() + 0.5), (int) (TEMP_RECT.getY()  
+ 0.5), (int) (TEMP_RECT.getWidth() + 0.5),
+                (int) (TEMP_RECT.getHeight() + 0.5), (int) (startAngle +  
0.5), (int) (startAngle + extent + 0.5));
      }

-    public void drawPath(Path p) {
+    /**
+     * Draws the provided path.
+     *
+     * @param p path to draw
+     */
+    public void drawPath(final Path p) {
          gc.setTransform(swtTransform);
          gc.drawPath(p);
          gc.setTransform(null);
      }

-    public void fillPath(Path p) {
+    /**
+     * Draws a filled version of the provided path.
+     *
+     * @param p path to draw filled
+     */
+    public void fillPath(final Path p) {
          gc.setTransform(swtTransform);
          gc.fillPath(p);
          gc.setTransform(null);
      }

-    // ////////////////////////
-    // SWT IMAGE METHODS
-    // ////////////////////////
-
+    /**
+     * Draws the provided image at the position specified.
+     *
+     * @param image image to draw
***The diff for this file has been truncated for email.***

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

Reply via email to