Java 类java.awt.geom.Area 实例源码

/**
 * Costructor of the life
 * @param allPoints All the point of the graph
 * @param sd3 The sector of saturation
 */
public EngineConvex2D(Vector<Point2D> allPoints, Vector<Object> sd3) {
    this.allPoints = (Vector<Point2D>) allPoints.clone();
    allConvex = new Vector<Point2D>();
    allImperant = (Vector<Point2D>) allPoints.clone();
    allDominates = new Vector<Point2D>();

    filtDominants = new Vector<Point2D>();
    filtDominates = new Vector<Point2D>();
    filtPoints = new Vector<DPoint>();
    filtConvex = new Vector<Point2D>();

    filtArea = new Area();

    separator();
    //calcConvex();
    calcConvex(sd3);

    dominates = (Vector<Point2D>) allDominates.clone();
    imperant = (Vector<Point2D>) allImperant.clone();
    convex = (Vector<Point2D>) allConvex.clone();
    points = (Vector<Point2D>) this.allPoints.clone();
}

/**
 * Costructor of the life
 * @param allPoints All the point of the graph
 * @param sd3 The sector of saturation
 */
public EngineConvex2D(Vector<Point2D> allPoints, Vector<Object> sd3) {
    this.allPoints = (Vector<Point2D>) allPoints.clone();
    allConvex = new Vector<Point2D>();
    allImperant = (Vector<Point2D>) allPoints.clone();
    allDominates = new Vector<Point2D>();

    filtDominants = new Vector<Point2D>();
    filtDominates = new Vector<Point2D>();
    filtPoints = new Vector<DPoint>();
    filtConvex = new Vector<Point2D>();

    filtArea = new Area();

    separator();
    //calcConvex();
    calcConvex(sd3);

    dominates = (Vector<Point2D>) allDominates.clone();
    imperant = (Vector<Point2D>) allImperant.clone();
    convex = (Vector<Point2D>) allConvex.clone();
    points = (Vector<Point2D>) this.allPoints.clone();
}

@Override
public void updateVisionShape() {
  final Path2D path = new Path2D.Float();
  final Path2D renderPath = new Path2D.Float();
  path.append(this.getMapVisionCircle(this.combatEntity), false);
  renderPath.append(this.getRenderVisionArc(this.combatEntity), false);

  for (final ICombatEntity entity : this.environment.getCombatEntities()) {
    if (entity.isFriendly(this.combatEntity) && !entity.equals(this.combatEntity)) {
      path.append(this.getMapVisionCircle(entity), false);
      renderPath.append(this.getRenderVisionArc(entity), false);
    }
  }

  this.renderVisionShape = renderPath;

  final float width = (float) this.environment.getMap().getSizeInPixels().getWidth();
  final float height = (float) this.environment.getMap().getSizeInPixels().getHeight();
  final Rectangle2D rect = new Rectangle2D.Float(0, 0, width, height);
  final Area rectangleArea = new Area(rect);
  rectangleArea.subtract(new Area(path));

  this.fogOfWar = rectangleArea;
}

private static final void paintTopLine(Graphics g,
                                       WinXPEditorTabCellRenderer ren,
                                       TabPainter p) {
    Polygon poly = p.getInteriorPolygon(ren);
    ((Graphics2D) g).setPaint(getHighlightColor());
    g.setColor(getHighlightColor());
    Shape clip = g.getClip();
    Insets ins = p.getBorderInsets(ren);
    try {
        if (clip != null) {
            Area a = new Area(clip);
            a.intersect(new Area(poly));
            g.setClip(a);
        } else {
            g.setClip(poly);
        }
        g.fillRect(0, ins.top, ren.getWidth(), 3);
    } finally {
        g.setClip(clip);
    }
}

/**
 * Get a shape appropriate for drawing on the window's glass pane to
 * indicate where a component should appear in the tab order if it is
 * dropped here.
 *
 * @param dragged An object being dragged, or null. The object may be an
 * instance of
 * <code>TabData</code> or
 * <code>Component</code>, in which case a check will be done of whether the
 * dragged object is already in the data model, so that attempts to drop the
 * object over the place it already is in the model will always return the
 * exact indication of that tab's position.
 *
 * @param location A point
 * @return Drop indication drawing
 */
public Shape getDropIndication( Object dragged, Point location ) {
    int over = dropIndexOfPoint( location );
    Rectangle component = getSelectedComponent().getBounds();
    Area selectedComponent = new Area( component );

    Rectangle firstTab = null, secondTab = null;
    if( over > 0 && over < getTabCount() )
        firstTab = getBoundsAt( over-1 );
    if( over < getTabCount() )
        secondTab = getBoundsAt( over );
    if( over >= getTabCount() ) {
        firstTab = getBoundsAt( getTabCount()-1 );
        secondTab = null;
    }
    Rectangle joined = joinTabAreas( firstTab, secondTab );
    Area t = new Area( joined );
    selectedComponent.add( t );
    return selectedComponent;
}

private void drawUtilizationMulti(double U, Color startC, Color border, boolean gradientFill, Graphics2D g2d, int cpu) {

        double x = getProcessorXY().x, y = getProcessorXY().y;
        try {
            occupiedRect = new Rectangle2D.Double(x + PROC_RAD / 2 + ELEMS_GAP / 2, y + cpu * (PROC_RAD - ELEMS_GAP) + ELEMS_GAP * cpu * 3
                    - ELEMS_GAP / 2, PROC_RAD - ELEMS_GAP, (PROC_RAD - ELEMS_GAP) * (1 - U / nCpu));
        } catch (Exception e) {
            occupiedRect = new Rectangle2D.Double(x + PROC_RAD / 2 + ELEMS_GAP / 2, y + cpu * (PROC_RAD - ELEMS_GAP) + ELEMS_GAP * cpu * 3
                    - ELEMS_GAP / 2, PROC_RAD - ELEMS_GAP, 0);
        }
        occupiedEll = new Ellipse2D.Double(x + PROC_RAD / 2 + ELEMS_GAP / 2, y + cpu * (PROC_RAD - ELEMS_GAP) + ELEMS_GAP * cpu * 3 - ELEMS_GAP / 2,
                PROC_RAD - ELEMS_GAP, PROC_RAD - ELEMS_GAP);
        if (gradientFill) {
            GradientPaint gp = new GradientPaint((float) x, (float) y, startC.brighter(), (float) x, (float) (y + 2 * PROC_RAD), startC.darker(),
                    false);
            g2d.setPaint(gp);
        } else {
            g2d.setPaint(startC);
        }
        occupiedArea = new Area(occupiedEll);
        occupiedArea.subtract(new Area(occupiedRect));
        g2d.fill(occupiedArea);
        g2d.setPaint(Color.BLACK);
        g2d.draw(occupiedArea);

    }

/**
 * Draw a semi-trasparent area that is the filtered area
 * @param g The graphic object
 * @param filteredArea The filtered area
 */
public void drawFiltArea(Graphics2D g, Area filtArea) {
    AffineTransform t = new AffineTransform();
    t.scale(scale / 100, scale / 100);
    AffineTransform t2 = new AffineTransform();
    t2.translate(tran_x, tran_y);

    filtArea.transform(t);
    filtArea.transform(t2);

    Stroke oldStro = g.getStroke();
    Stroke stroke = new BasicStroke(2.0f, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND);
    g.setStroke(stroke);

    g.setColor(Color.GRAY);
    Composite oldComp = g.getComposite();
    Composite alphaComp = AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 0.3f);
    g.setComposite(alphaComp);

    g.fill(filtArea);
    g.setComposite(oldComp);
    g.setStroke(oldStro);
}

public Area getShape() {
    Area maskArea = new Area();
    Rectangle rect = new Rectangle(0, 0, reader.getWidth(), reader.getHeight());
    GeometryFactory gf = new GeometryFactory();
    Coordinate[] coords = new Coordinate[]{
        new Coordinate((int) rect.getMinX(), (int) rect.getMinY()),
        new Coordinate((int) rect.getMaxX(), (int) rect.getMinY()),
        new Coordinate((int) rect.getMaxX(), (int) rect.getMaxY()),
        new Coordinate((int) rect.getMinX(), (int) rect.getMaxY()),
        new Coordinate((int) rect.getMinX(), (int) rect.getMinY()),
    };
    Polygon geom = gf.createPolygon(gf.createLinearRing(coords), null);
    for (Geometry p : glayer.getGeometries()) {
        if (p.intersects(geom)) {
            int[] xPoints = new int[p.getNumPoints()];
            int[] yPoints = new int[p.getNumPoints()];
            int i = 0;
            for (Coordinate c : p.getCoordinates()) {
                xPoints[i] = (int) (c.x);
                yPoints[i++] = (int) (c.y);
            }
            maskArea.add(new Area(new java.awt.Polygon(xPoints, yPoints, p.getNumPoints())));
        }
    }
    return maskArea;
}

public Area getArea(MapShader shader) {
  Area a = null;
  final MapShader.ShadedPiece shaded = (MapShader.ShadedPiece) Decorator.getDecorator(piece,MapShader.ShadedPiece.class);
  if (shaded != null) {
    a = shaded.getArea(shader);
  }
  if (alwaysActive || active) {
    if (shader.getConfigureName().equals(mapShaderName)) {
      Area myArea = getArea();
      if (a == null) {
        a = myArea;
      }
      else {
        a.add(myArea);
      }
    }
  }
  return a;
}

protected void checkPiece(Area area, GamePiece piece) {
  if (piece instanceof Stack) {
    Stack s = (Stack) piece;
    for (int i = 0; i < s.getPieceCount(); i++) {
      checkPiece(area, s.getPieceAt(i));
    }
  }
  else {
    ShadedPiece shaded = (ShadedPiece) Decorator.getDecorator(piece,ShadedPiece.class);
    if (shaded != null) {
      Area shape = shaded.getArea(this);
      if (shape != null) {
        if (type.equals(FG_TYPE)) {
          area.add(shape);
        }
        else {
          area.subtract(shape);
        }
      }
    }
  }
}

public void draw(Graphics g, Rectangle bounds, Rectangle visibleRect, double scale, boolean reversed) {
  if ((getGrid() != null && getGrid().isVisible()) || highlighter != null) {
    final Graphics2D g2d = (Graphics2D) g;
    final Shape oldClip = g2d.getClip();
    final Area newClip = new Area(visibleRect);
    final Shape s = getCachedShape(myPolygon, bounds.x, bounds.y, scale);
    newClip.intersect(new Area(s));
    g2d.setClip(newClip);
    if (getGrid() != null && getGrid().isVisible()) {
      getGrid().draw(g, bounds, visibleRect, scale, reversed);
    }
    if (highlighter != null) {
      highlighter.draw(g2d, s, scale);
    }
    g2d.setClip(oldClip);
  }
}

private void drawUtilizationMulti(double U, Color startC, Color border, boolean gradientFill, Graphics2D g2d, int cpu) {

        double x = getProcessorXY().x, y = getProcessorXY().y;
        try {
            occupiedRect = new Rectangle2D.Double(x + PROC_RAD / 2 + ELEMS_GAP / 2, y + cpu * (PROC_RAD - ELEMS_GAP) + ELEMS_GAP * cpu * 3
                    - ELEMS_GAP / 2, PROC_RAD - ELEMS_GAP, (PROC_RAD - ELEMS_GAP) * (1 - U / nCpu));
        } catch (Exception e) {
            occupiedRect = new Rectangle2D.Double(x + PROC_RAD / 2 + ELEMS_GAP / 2, y + cpu * (PROC_RAD - ELEMS_GAP) + ELEMS_GAP * cpu * 3
                    - ELEMS_GAP / 2, PROC_RAD - ELEMS_GAP, 0);
        }
        occupiedEll = new Ellipse2D.Double(x + PROC_RAD / 2 + ELEMS_GAP / 2, y + cpu * (PROC_RAD - ELEMS_GAP) + ELEMS_GAP * cpu * 3 - ELEMS_GAP / 2,
                PROC_RAD - ELEMS_GAP, PROC_RAD - ELEMS_GAP);
        if (gradientFill) {
            GradientPaint gp = new GradientPaint((float) x, (float) y, startC.brighter(), (float) x, (float) (y + 2 * PROC_RAD), startC.darker(),
                    false);
            g2d.setPaint(gp);
        } else {
            g2d.setPaint(startC);
        }
        occupiedArea = new Area(occupiedEll);
        occupiedArea.subtract(new Area(occupiedRect));
        g2d.fill(occupiedArea);
        g2d.setPaint(Color.BLACK);
        g2d.draw(occupiedArea);

    }

/**
 * Draw a semi-trasparent area that is the filtered area
 * @param g The graphic object
 * @param filteredArea The filtered area
 */
public void drawFiltArea(Graphics2D g, Area filtArea) {
    AffineTransform t = new AffineTransform();
    t.scale(scale / 100, scale / 100);
    AffineTransform t2 = new AffineTransform();
    t2.translate(tran_x, tran_y);

    filtArea.transform(t);
    filtArea.transform(t2);

    Stroke oldStro = g.getStroke();
    Stroke stroke = new BasicStroke(2.0f, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND);
    g.setStroke(stroke);

    g.setColor(Color.gray);
    Composite oldComp = g.getComposite();
    Composite alphaComp = AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 0.3f);
    g.setComposite(alphaComp);

    g.fill(filtArea);
    g.setComposite(oldComp);
    g.setStroke(oldStro);
}

private void registerMultipleServices() {
    area = new Area();
    rectangle = new Rectangle();
    polygon = new Polygon();

    Dictionary polygonProp = new Properties();
    polygonProp.put(Constants.SERVICE_RANKING, new Integer(1));
    // first register polygon
    polygonReg = bundleContext.registerService(Shape.class.getName(), polygon, polygonProp);

    // then rectangle
    Dictionary rectangleProp = new Properties();
    rectangleProp.put(Constants.SERVICE_RANKING, new Integer(10));
    rectangleReg = bundleContext.registerService(Shape.class.getName(), rectangle, rectangleProp);

    // then area
    Dictionary areaProp = new Properties();
    areaProp.put(Constants.SERVICE_RANKING, new Integer(100));
    areaReg = bundleContext.registerService(Shape.class.getName(), area, areaProp);

}

public void testBehaviour() throws Exception {
    String bundleId = "org.eclipse.gemini.blueprint.iandt, async-nowait-bundle,"
            + getSpringDMVersion();

    // start it
    Bundle bundle = installBundle(bundleId);
    bundle.start();

    // wait for the bundle to start and fail
    Thread.sleep(3000);

    // put service up
    registration = bundleContext.registerService(Shape.class.getName(), new Area(), null);

    assertTrue("bundle " + bundle + "hasn't been fully started", OsgiBundleUtils.isBundleActive(bundle));

    // check that the appCtx is *not* published 
    // TODO: this fails sometimes on the build server - find out why
    // assertContextServiceIs(bundle, false, 1000);
}

public void testBehaviour() throws Exception {

        String bundleId = "org.eclipse.gemini.blueprint.iandt, async-wait-bundle,"
                + getSpringDMVersion();

        // start it
        Bundle bundle = installBundle(bundleId);
        bundle.start();

        assertTrue("bundle " + bundle + "hasn't been fully started", OsgiBundleUtils.isBundleActive(bundle));

        // make sure the appCtx is not up
        // check that the appCtx is *not* published (it waits for the service to
        // appear)
        assertContextServiceIs(bundle, false, 500);

        // put service up
        registration = bundleContext.registerService(Shape.class.getName(), new Area(), null);

        // do wait a bit to let the appCtx to fully start
        // check the appCtx again (should be published)
        assertContextServiceIs(bundle, true, 4000);

    }

protected void paintComponent(Graphics g1D) {
    if (theImage == null || theRectangle == null)
        return;
    Graphics2D g = (Graphics2D) g1D;
    Insets insets = getInsets();
    int xOffset = insets.left;
    int yOffset = insets.top;
    int availableWidth = getWidth() - insets.left - insets.right;
    int availableHeight = getHeight() - insets.top - insets.bottom;
    g.drawImage(theImage, xOffset, yOffset, null);
    Color tmpColor = g.getColor();
    Area area = new Area(new Rectangle(xOffset, yOffset, availableWidth,
            availableHeight));
    area.subtract(new Area(theRectangle));
    g.setColor(new Color(200, 200, 200, 128));
    g.fill(area);
    g.setColor(Color.BLACK);
    g.draw(theRectangle);
    g.setColor(tmpColor);
}

private void drawFrame(GraphicsDecorator g, Shape shape, Color color, Point2D.Float pos) {
    Shape old_clip = g.getClip();
    AffineTransform old = g.getTransform();
    AffineTransform t = g.getTransform();
    t.concatenate(AffineTransform.getTranslateInstance(pos.x, pos.y));
    g.setTransform(t);
    g.setColor(color);
    Stroke old_stroke = g.getStroke();
    g.setStroke(new BasicStroke(10.0f, BasicStroke.CAP_BUTT, BasicStroke.JOIN_ROUND));
    Area a = new Area(g.getClip());
    a.subtract(new Area(shape));
    g.setClip(a);
    g.draw(shape);
    g.setTransform(old);
    g.setStroke(old_stroke);
    g.setClip(old_clip);
}

private void drawFrame(GraphicsDecorator g, Shape shape, Color color, Point2D.Float pos) {
    Shape old_clip = g.getClip();
    AffineTransform old = g.getTransform();
    AffineTransform t = g.getTransform();
    t.concatenate(AffineTransform.getTranslateInstance(pos.x, pos.y));
    g.setTransform(t);
    g.setColor(color);
    Stroke old_stroke = g.getStroke();
    g.setStroke(new BasicStroke(10.0f, BasicStroke.CAP_BUTT, BasicStroke.JOIN_ROUND));
    Area a = new Area(g.getClip());
    a.subtract(new Area(shape));
    g.setClip(a);
    g.draw(shape);
    g.setTransform(old);
    g.setStroke(old_stroke);
    g.setClip(old_clip);
}

@Override
public void paintIcon(Component c, Graphics g, int x, int y) {
    Graphics2D g2d = (Graphics2D) g.create();
    g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
            RenderingHints.VALUE_ANTIALIAS_ON);
    g2d.translate(x, y);

    Area clip = new Area(new Rectangle(0, 0, this.width, this.height));     
    if (g2d.getClip() != null) clip.intersect(new Area(g2d.getClip()));     
    g2d.setClip(clip);

    double coef1 = (double) this.width / (double) getOrigWidth();
    double coef2 = (double) this.height / (double) getOrigHeight();
    double coef = Math.min(coef1, coef2);
    g2d.scale(coef, coef);
    paint(g2d);
    g2d.dispose();
}

@Override
public void paintIcon(Component c, Graphics g, int x, int y) {
    Graphics2D g2d = (Graphics2D) g.create();
    g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
            RenderingHints.VALUE_ANTIALIAS_ON);
    g2d.translate(x, y);

    Area clip = new Area(new Rectangle(0, 0, this.width, this.height));     
    if (g2d.getClip() != null) clip.intersect(new Area(g2d.getClip()));     
    g2d.setClip(clip);

    double coef1 = (double) this.width / (double) getOrigWidth();
    double coef2 = (double) this.height / (double) getOrigHeight();
    double coef = Math.min(coef1, coef2);
    g2d.scale(coef, coef);
    paint(g2d);
    g2d.dispose();
}

/**
 * Draws the needle.
 *
 * @param g2  the graphics device.
 * @param plotArea  the plot area.
 * @param rotate  the rotation point.
 * @param angle  the angle.
 */
protected void drawNeedle(Graphics2D g2, Rectangle2D plotArea, Point2D rotate, double angle) {

    Arc2D shape = new Arc2D.Double(Arc2D.PIE);
    double radius = plotArea.getHeight();
    double halfX = plotArea.getWidth() / 2;
    double diameter = 2 * radius;

    shape.setFrame(plotArea.getMinX() + halfX - radius ,
                   plotArea.getMinY() - radius,
                   diameter, diameter);
    radius = Math.toDegrees(Math.asin(halfX / radius));
    shape.setAngleStart(270 - radius);
    shape.setAngleExtent(2 * radius);

    Area s = new Area(shape);

    if ((rotate != null) && (angle != 0)) {
        /// we have rotation houston, please spin me
        getTransform().setToRotation(angle, rotate.getX(), rotate.getY());
        s.transform(getTransform());
    }

    defaultDisplay(g2, s);
}

/**
 * Draws the frame.
 * 
 * @param g2  the graphics target.
 * @param plot  the plot.
 * @param frame  the dial's reference frame.
 * @param view  the dial's view rectangle.
 */
public void draw(Graphics2D g2, DialPlot plot, Rectangle2D frame, 
        Rectangle2D view) {

    Shape window = getWindow(frame);
    Shape outerWindow = getOuterWindow(frame);

    Area area1 = new Area(outerWindow);
    Area area2 = new Area(window);
    area1.subtract(area2);
    g2.setPaint(Color.lightGray);
    g2.fill(area1);

    g2.setStroke(this.stroke);
    g2.setPaint(this.foregroundPaint);
    g2.draw(window);
    g2.draw(outerWindow);


}

/**
 * Draws the frame.  This method is called by the {@link DialPlot} class,
 * you shouldn't need to call it directly.
 *
 * @param g2  the graphics target (<code>null</code> not permitted).
 * @param plot  the plot (<code>null</code> not permitted).
 * @param frame  the frame (<code>null</code> not permitted).
 * @param view  the view (<code>null</code> not permitted).
 */
public void draw(Graphics2D g2, DialPlot plot, Rectangle2D frame, 
        Rectangle2D view) {

    Shape window = getWindow(frame);

    Rectangle2D f = DialPlot.rectangleByRadius(frame, this.radius + 0.02, 
            this.radius + 0.02);
    Ellipse2D e = new Ellipse2D.Double(f.getX(), f.getY(), f.getWidth(), 
            f.getHeight());

    Area area = new Area(e);
    Area area2 = new Area(window);
    area.subtract(area2);
    g2.setPaint(this.backgroundPaint);
    g2.fill(area);

    g2.setStroke(this.stroke);
    g2.setPaint(this.foregroundPaint);
    g2.draw(window);
    g2.draw(e);
}

/**
 * Draws the needle.
 *
 * @param g2  the graphics device.
 * @param plotArea  the plot area.
 * @param rotate  the rotation point.
 * @param angle  the angle.
 */
protected void drawNeedle(Graphics2D g2, Rectangle2D plotArea, 
                          Point2D rotate, double angle) {

    Arc2D shape = new Arc2D.Double(Arc2D.PIE);
    double radius = plotArea.getHeight();
    double halfX = plotArea.getWidth() / 2;
    double diameter = 2 * radius;

    shape.setFrame(plotArea.getMinX() + halfX - radius ,
                   plotArea.getMinY() - radius,
                   diameter, diameter);
    radius = Math.toDegrees(Math.asin(halfX / radius));
    shape.setAngleStart(270 - radius);
    shape.setAngleExtent(2 * radius);

    Area s = new Area(shape);

    if ((rotate != null) && (angle != 0)) {
        /// we have rotation houston, please spin me
        getTransform().setToRotation(angle, rotate.getX(), rotate.getY());
        s.transform(getTransform());
    }

    defaultDisplay(g2, s);
}

private static void createUI() throws Exception {
    SwingUtilities.invokeAndWait(new Runnable() {
        @Override
        public void run() {
            background = new Frame();
            background.setUndecorated(true);
            background.setBackground(Color.blue);
            background.setSize(300, 300);
            background.setLocation(100, 100);
            background.setVisible(true);
            window = new Window(background);
            window.setBackground(Color.red);
            window.add(new Panel(), BorderLayout.CENTER);
            window.setLocation(200, 200);
            window.setSize(100, 100);
            Area a = new Area();
            a.add(new Area(new Rectangle2D.Double(0, 0, 100, 100)));
            window.setShape(a);
            window.setVisible(true);
            window.toFront();
        }
    });
}

public TrapezoidPool() {
    this.waterShape = new CompositeProperty<Shape>( new Function0<Shape>() {
        public Shape apply() {
            final Shape containerShape = getContainerShape();
            double height = getWaterHeight();
            Rectangle2D whole = containerShape.getBounds2D();

            //just keep the bottom part that is occupied by water
            final Rectangle2D part = new Rectangle2D.Double( whole.getX(), whole.getY(), whole.getWidth(), height );
            return new Area( containerShape ) {{
                intersect( new Area( part ) );
            }};
        }
    }, waterVolume );
    inputFaucetEnabled = new CompositeBooleanProperty( new Function0<Boolean>() {
        public Boolean apply() {
            return getWaterHeight() < height;
        }
    }, waterVolume );
    drainFaucetEnabled = new CompositeBooleanProperty( new Function0<Boolean>() {
        public Boolean apply() {
            return waterVolume.get() > 0.0;
        }
    }, waterVolume );
}

@Override
public void applyShape() {
    Area shape = new Area(new Rectangle2D.Float(0, 0, 200, 200));
    GeneralPath gp;
    gp = new GeneralPath();
    gp.moveTo(190, 0);
    gp.lineTo(200, 0);
    gp.lineTo(200, 10);
    gp.lineTo(10, 200);
    gp.lineTo(0, 200);
    gp.lineTo(0, 190);
    gp.closePath();
    shape.subtract(new Area(gp));

    window.setShape(shape);
}

@Override
public Shape getClip() {
    if(clipping==null)
        return null;

    try {
        Area area = new Area(clipping);
        area.transform(transform.createInverse());
        if(area.isRectangular())
            return area.getBounds2D();
        return area;
    } catch(NoninvertibleTransformException t) {
        RuntimeException e2 = new RuntimeException();
        e2.initCause(t);
        throw e2;
    }
}

private void updateNode() {
    final double y = 0;
    if ( dipole.get().magnitude() == 0 ) {
        setPathTo( new Rectangle2D.Double() ); // because Arrow doesn't handle zero-length arrows
    }
    else {
        // arrow, in angle=0 orientation (pointing right), so we can easily add cross
        Arrow arrow = new Arrow( new Point2D.Double( 0, 0 ), new Point2D.Double( getDipoleViewLength(), y ),
                                 HEAD_SIZE.height, HEAD_SIZE.width, TAIL_WIDTH, FRACTIONAL_HEAD_HEIGHT, true /* scaleTailToo */ );
        // cross
        Shape cross = createCross( arrow );

        // Combine arrow and cross using constructive area geometry.
        Area area = new Area( arrow.getShape() );
        area.add( new Area( cross ) );
        setPathTo( area );

        // rotate into dipole orientation
        setRotation( dipole.get().getAngle() );
    }
}

/**
 * Lookup the sig collection of interpretations for those which contain the provided
 * point.
 *
 * @param point provided point
 * @return the containing interpretations
 */
public List<Inter> containingInters (Point point)
{
    List<Inter> found = new ArrayList<Inter>();

    for (Inter inter : vertexSet()) {
        Rectangle bounds = inter.getBounds();

        if ((bounds != null) && bounds.contains(point)) {
            // More precise test if we know inter area
            Area area = inter.getArea();

            if ((area == null) || area.contains(point)) {
                found.add(inter);
            }
        }
    }

    return found;
}

public TipNode() {
    super();

    // rounded corners at top
    Shape roundRect = new RoundRectangle2D.Float( 0f, 0f, 1f, 1.5f, 0.4f, 0.4f );

    // mask out rounded corners at bottom
    Shape rect = new Rectangle2D.Float( 0f, 0.5f, 1f, 1f );

    // point at the bottom
    GeneralPath triangle = new GeneralPath();
    triangle.moveTo( 0f, 1.5f );
    triangle.lineTo( 0.5f, 2.5f );
    triangle.lineTo( 1f, 1.5f );
    triangle.closePath();

    // constructive area geometry
    Area area = new Area( roundRect );
    area.add( new Area( rect ) );
    area.add( new Area( triangle ) );

    setPathTo( area );
    setPaint( TIP_COLOR );
    setStroke( null );
}

public void update() {
    if( pressureReadingSource == box ) {
        pressure = box.getPressure();
    }
    else {
        pressure = pressureSlice.getPressure();
    }
    temperature = pressureSlice.getTemperature();

    // Clear the drawing area and rebuild it
    drawingArea.exclusiveOr( drawingArea );
    drawingArea.add( new Area( boundingRect ) );
    drawingArea.add( new Area( new Rectangle( (int)readoutRectangle.getX() - 2, (int)readoutRectangle.getY() - 2,
                                              (int)readoutRectangle.getWidth() + 4, (int)readoutRectangle.getHeight() + 4 ) ) );
    setBoundsDirty();
    repaint();
}

private Area computeArea ()
{
    final GeoPath path;

    if (p2.x > p1.x) {
        path = new GeoPath(new Line2D.Double(p1.x + 1, p1.y - MARGIN, p2.x, p2.y - MARGIN));
        path.append(new Line2D.Double(p2.x, p2.y + MARGIN, p1.x + 1, p1.y + MARGIN), true);
    } else {
        path = new GeoPath(new Line2D.Double(p1.x, p1.y - MARGIN, p2.x + 1, p2.y - MARGIN));
        path.append(new Line2D.Double(p2.x + 1, p2.y + MARGIN, p1.x, p1.y + MARGIN), true);
    }

    path.closePath();

    return new Area(path);
}

/** Calculating the scaling ratio for the shape to fit the dimensions provided. */
protected float calculateMultiplier(Dimension size) {
    Shape shape = getShape();
    Area base = new Area(shape);
    AffineTransform transform = new AffineTransform();
    Rectangle2D r = ShapeBounds.getBounds(base);
    transform.translate(size.width/2f-r.getCenterX(),size.height/2f-r.getCenterY());
    base.transform(transform);
    r = ShapeBounds.getBounds(base,r);
    float min = 0;
    float max = 1;
    Rectangle2D boundsRect = new Rectangle2D.Float(0,0,size.width,size.height);
    while(isOK(base,r,boundsRect,max)==false) {
        min = max;
        max*=1.2;
    }
    float f = calculateMultiplier(base,r,boundsRect,min,max);
    isOK(base,r,boundsRect,f);
    return f;
}

/**
 * Adds to <code>nodePath</code> the quadrilateral joining vertices at 
 * vertexIndex1, vertexIndex2, vertexIndex3, vertexIndex4 indices, 
 * only if the quadrilateral has a positive orientation. 
 */
private void addQuadrilateralToPath(GeometryArray geometryArray, int vertexIndex1, int vertexIndex2,
        int vertexIndex3, int vertexIndex4, float[] vertices, GeneralPath geometryPath, int quadrilateralIndex,
        Area nodeArea)
{
    float xVertex1 = vertices[2 * vertexIndex1];
    float yVertex1 = vertices[2 * vertexIndex1 + 1];
    float xVertex2 = vertices[2 * vertexIndex2];
    float yVertex2 = vertices[2 * vertexIndex2 + 1];
    float xVertex3 = vertices[2 * vertexIndex3];
    float yVertex3 = vertices[2 * vertexIndex3 + 1];
    if ((xVertex2 - xVertex1) * (yVertex3 - yVertex2) - (yVertex2 - yVertex1) * (xVertex3 - xVertex2) > 0)
    {
        if (quadrilateralIndex > 0 && quadrilateralIndex % 1000 == 0)
        {
            // Add now current path to area otherwise area gets too slow
            nodeArea.add(new Area(geometryPath));
            geometryPath.reset();
        }
        geometryPath.moveTo(xVertex1, yVertex1);
        geometryPath.lineTo(xVertex2, yVertex2);
        geometryPath.lineTo(xVertex3, yVertex3);
        geometryPath.lineTo(vertices[2 * vertexIndex4], vertices[2 * vertexIndex4 + 1]);
        geometryPath.closePath();
    }
}

/**
 * Returns the list of closed paths that may define rooms from 
 * the current set of home walls.
 */
private List<GeneralPath> getRoomPathsFromWalls()
{
    if (this.roomPathsCache == null)
    {
        // Iterate over all the paths the walls area contains
        Area wallsArea = getWallsArea(false);
        List<GeneralPath> roomPaths = getAreaPaths(wallsArea);
        Area insideWallsArea = new Area(wallsArea);
        for (GeneralPath roomPath : roomPaths)
        {
            insideWallsArea.add(new Area(roomPath));
        }

        this.roomPathsCache = roomPaths;
        this.insideWallsAreaCache = insideWallsArea;
    }
    return this.roomPathsCache;
}

/**
 * Clips to the intersection of the current clipping region and the
 * specified shape. 
 * 
 * According to the Oracle API specification, this method will accept a 
 * {@code null} argument, but there is an open bug report (since 2004) 
 * that suggests this is wrong:
 * <p>
 * <a href="http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=6206189">
 * http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=6206189</a>
 * 
 * In this implementation, a {@code null} argument is not permitted.
 * 
 * @param s  the clip shape ({@code null} not permitted). 
 */
@Override
public void clip(Shape s) {
    if (this.clip == null) {
        setClip(s);
        return;
    }
    Shape ts = this.transform.createTransformedShape(s);
    Shape clipNew;
    if (!ts.intersects(this.clip.getBounds2D())) {
        clipNew = new Rectangle2D.Double();
    } else {
        Area a1 = new Area(ts);
        Area a2 = new Area(this.clip);
        a1.intersect(a2);
        clipNew = new Path2D.Double(a1);
    }
    this.clip = clipNew;
    if (!this.clippingDisabled) {
        this.gc.save();
        this.saveCount++;
        shapeToPath(this.clip);
        this.gc.clip();
    }
}

public Area getBeltArea (Area coreArea,
                         int dx,
                         int topDy,
                         int bottomDy)
{
    final double shiftY = (bottomDy - topDy) / 2;
    final double beltHeight = height + topDy + bottomDy;

    Point2D p1 = LineUtil.intersectionAtX(median, median.getX1() - dx);
    p1.setLocation(p1.getX(), p1.getY() + shiftY);

    Point2D p2 = LineUtil.intersectionAtX(median, median.getX2() + dx);
    p2.setLocation(p2.getX(), p2.getY() + shiftY);

    Area beltArea = AreaUtil.horizontalParallelogram(p1, p2, beltHeight);
    beltArea.subtract(coreArea);

    return beltArea;
}

@SuppressWarnings("unused")
public void paintBorder(Component c, Graphics g0, int x, int y,
        int width, int height) {
    Graphics2D g = (Graphics2D)g0;
    Area area = new Area(new Rectangle(x, y, width, height));
    area.subtract(new Area(new Rectangle(
            x+insets.left, y+insets.top,
            width-insets.left-insets.right,
            height-insets.top-insets.bottom
    )));
    if(c.isOpaque()) {
        Color bkgnd = c.getBackground();
        g.setColor(bkgnd);
        g.fill(area);
    }
    if(false) {
        g.setColor(debugColor);
        g.fill(area);
    }
}