import edu.umd.cs.piccolo.util.PBounds; //导入依赖的package包/类
private void updateElectronPosition() {
    
    ElectronNode electronNode = getElectronNode();
    PBounds electronBounds = electronNode.getFullBounds();
    Rectangle2D drawingArea = getDrawingArea();

    final double x = drawingArea.getX() + ( electronBounds.getWidth() / 2 ) + X_MARGIN;
    
    double y = Double.MAX_VALUE; // off the chart
    final double r = _atom.getElectronDistanceFromCenter();
    final double minEnergy = -1 / ( MIN_RADIUS * MIN_RADIUS );
    if ( r > 0 ) {
        final double energy = -1 / ( r * r );
        if ( energy >= minEnergy ) {
            double h = drawingArea.getHeight() - Y_MARGIN; // height of energy axis
            double d = h * energy / minEnergy; // how far down the energy axis is this energy value?
            y = drawingArea.getY() + Y_MARGIN + d;
        }
    }

    electronNode.setOffset( x, y );
}
 

import edu.umd.cs.piccolo.util.PBounds; //导入依赖的package包/类
private void updateLayout() {
    //Find the size (width or height) of the biggest child node so far
    final PNode biggestNode = max( getChildren(), new Comparator<PNode>() {
        public int compare( PNode o1, PNode o2 ) {
            return Double.compare( getMaxDimension.apply( o1.getFullBounds() ), getMaxDimension.apply( o2.getFullBounds() ) );
        }
    } );
    final double maxSize = getMaxDimension.apply( biggestNode.getFullBounds() );

    //Position each child, adding space between it and the previous child.
    double position = 0; //X or Y coordinate, depending on implementation of getNodeDimension
    for ( PNode child : getChildren() ) {
        final PBounds bounds = child.getFullBounds();

        //Subtract out any local translation in the node
        double childOriginX = bounds.getX() - child.getOffset().getX();
        double childOriginY = bounds.getY() - child.getOffset().getY();

        //Determine where to put the node and do so
        Point2D relativePosition = positionStrategy.getRelativePosition( child, maxSize, position );
        child.setOffset( relativePosition.getX() - childOriginX, relativePosition.getY() - childOriginY );

        //Move the position accumulator to the next space for the next node
        position += getNodeDimension.apply( bounds ) + spacing;
    }
}
 

import edu.umd.cs.piccolo.util.PBounds; //导入依赖的package包/类
public Rectangle2D transformBoundsToStage( Rectangle2D localBounds ) {
        // TODO: verify this code!
        // get the translation of the control panel
        float offsetX = (float) position.get().getX();
        float offsetY = (float) position.get().getY();

        // convert these to stage-offset from the lower-left, since the control panel itself is translated
        double localLeft = localBounds.getMinX() + offsetX;
        double localRight = localBounds.getMaxX() + offsetX;
//        double localTop = getComponentHeight() - localBounds.getMinY() + offsetY; // remember, Y is flipped here
//        double localBottom = getComponentHeight() - localBounds.getMaxY() + offsetY; // remember, Y is flipped here
        double localTop = localBounds.getMaxY() + offsetY; // remember, Y is flipped here
        double localBottom = localBounds.getMinY() + offsetY; // remember, Y is flipped here

        return new PBounds( localLeft, localBottom, localRight - localLeft, localTop - localBottom );
    }
 

import edu.umd.cs.piccolo.util.PBounds; //导入依赖的package包/类
private void addRandomNode() {

        // choose a random motion delta
        int delta = (int) Math.max( 1, Math.random() * motionDelta );

        // choose a random image
        int index = (int) ( Math.random() * imagePool.size() );
        MovingImageNode imageNode = new MovingImageNode( imagePool.get( index ), delta );
        addChild( imageNode );

        // set a random location within the bounds
        PBounds bounds = getBoundsReference();
        Point2D location = getRandomPoint( bounds );
        double x = location.getX() - ( imageNode.getFullBoundsReference().getWidth() / 2 );
        double y = location.getY() - ( imageNode.getFullBoundsReference().getHeight() / 2 );
        imageNode.setOffset( x, y );
    }
 

import edu.umd.cs.piccolo.util.PBounds; //导入依赖的package包/类
/**
 * Construct the necessary layout. If wide is true, the collectionAreaModelWidth is ignored
 */
public LayoutBounds() {
    double availableWidth = MODEL_SIZE.getWidth() - 2 * ChemicalReactionsConstants.MODEL_PADDING; // minus padding
    double halfWidth = availableWidth / 2;

    double kitTop = MODEL_SIZE.getHeight() / 2 - MODEL_PADDING; // Y is up, so this is the top (max y) value for the rectangle
    double kitHeight = 550;
    double kitBottom = kitTop - kitHeight;

    availableKitBounds = new PBounds( -halfWidth, kitBottom, availableWidth, kitHeight );

    availablePlayAreaBounds = new PBounds(
            -MODEL_SIZE.getWidth() / 2 + MODEL_PADDING + LEFT_EXTRA_PADDING, // far left part of model
            -MODEL_SIZE.getHeight() / 2 + MODEL_PADDING + BOTTOM_PADDING, // top of kit
            availableKitBounds.width - LEFT_EXTRA_PADDING - RIGHT_EXTRA_PADDING, // add in padding, since there is padding in-between the kit and collection area
            kitBottom + MODEL_SIZE.getHeight() / 2 - MODEL_PADDING * 2 - BOTTOM_PADDING );
}
 

import edu.umd.cs.piccolo.util.PBounds; //导入依赖的package包/类
public ControlPanelNode( final PNode content, Color backgroundColor, BasicStroke borderStroke, Color borderColor, final int inset, final int arc, boolean transparifySwing ) {
    //Make sure the background resizes when the content resizes
    background = new PhetPPath( backgroundColor, borderStroke, borderColor ) {{
        final PropertyChangeListener updateSize = new PropertyChangeListener() {
            public void propertyChange( PropertyChangeEvent evt ) {
                final PBounds layoutSize = getControlPanelBounds( content );
                //Set the size of the border, subtracting out any local offset of the content node
                setPathTo( new RoundRectangle2D.Double( 0, 0, layoutSize.width + inset * 2, layoutSize.height + inset * 2, arc, arc ) );
            }
        };
        content.addPropertyChangeListener( PROPERTY_FULL_BOUNDS, updateSize );
        updateSize.propertyChange( null );
    }};
    // Create a node that puts the contents at the inset location
    // regardless of its initial offset.
    PNode insetContentNode = new ZeroOffsetNode( content ) {{
        setOffset( inset, inset );
    }};
    addChild( background );
    background.addChild( insetContentNode );
    if ( transparifySwing ) {
        transparifySwing( this );
    }
}
 

import edu.umd.cs.piccolo.util.PBounds; //导入依赖的package包/类
/**
 * When the "Return Bead" button is clicked,
 * move the bead to the button's position and hide the button.
 */
private void handleReturnBeadButton() {

    // Determine the button's coordinates
    PBounds b = _returnBeadButtonWrapper.getFullBoundsReference();
    double x = b.getX() + ( b.getWidth() / 2 );
    double y = b.getY() + ( b.getHeight() / 2 );
    OTModelViewTransform modelViewTransform = _model.getModelViewTransform();
    Point2D p = modelViewTransform.viewToModel( x, y );

    // Move the bead to the button's position
    Bead bead = _model.getBead();
    bead.setMotionEnabled( false );
    bead.setPosition( p );
    bead.setMotionEnabled( true );

    // Hide the button
    _returnBeadButtonWrapper.setVisible( false );
    _returnBeadButtonWrapper.setPickable( false );
    _returnBeadButtonWrapper.setChildrenPickable( false );
}
 

import edu.umd.cs.piccolo.util.PBounds; //导入依赖的package包/类
public Shaker( Vector2D location, double orientation, PBounds dragBounds, Property<Solute> solute, double maxDispensingRate ) {
    super( location, dragBounds );
    assert ( dragBounds.contains( location.toPoint2D() ) );

    this.orientation = orientation;
    this.solute = solute;
    this.visible = new Property<Boolean>( true );
    this.empty = new Property<Boolean>( false );
    this.maxDispensingRate = maxDispensingRate;
    this.dispensingRate = new Property<Double>( 0d );
    this.previousLocation = location;

    // set the dispensing rate to zero when the shaker becomes empty or invisible
    RichSimpleObserver rateObserver = new RichSimpleObserver() {
        public void update() {
            if ( empty.get() || !visible.get() ) {
                dispensingRate.set( 0d );
            }
        }
    };
    rateObserver.observe( empty, visible );
}
 

import edu.umd.cs.piccolo.util.PBounds; //导入依赖的package包/类
public void testCreateRectangleReturnsValidPPath() {
    final PPath path = PPath.createRectangle(0, 0, 100, 50);
    assertNotNull(path);

    // Seems like rounding is affecting the bounds greatly
    PiccoloAsserts.assertEquals(new PBounds(0, 0, 100, 50), path.getBounds(), 2.0d);
}
 

import edu.umd.cs.piccolo.util.PBounds; //导入依赖的package包/类
/**
 * Flags the bounds provided as needing to be redrawn.
 * 
 * @param bounds the bounds that should be repainted
 */
public void repaint(final PBounds bounds) {
    bounds.expandNearestIntegerDimensions();
    bounds.inset(-1, -1);

    redraw((int) bounds.x, (int) bounds.y, (int) bounds.width, (int) bounds.height, true);
}
 

import edu.umd.cs.piccolo.util.PBounds; //导入依赖的package包/类
public void testAnimateViewToPanToBoundsIsImmediateWhenDurationIsZero() {
    camera.setViewBounds(new PBounds(0, 0, 10, 10));
    final PActivity activity = camera.animateViewToPanToBounds(new PBounds(10, 10, 10, 10), 0);

    assertNull(activity);
    assertEquals(AffineTransform.getTranslateInstance(-15, -15), camera.getViewTransform());
}
 

import edu.umd.cs.piccolo.util.PBounds; //导入依赖的package包/类
/**
 * Should the ScrollPane be revalidated. This occurs when either the scroll
 * bars are showing and should be remove or are not showing and should be
 * added.
 * 
 * @return Whether the scroll pane should be revalidated
 */
public boolean shouldRevalidateScrollPane() {
    if (camera != null) {
        if (scrollPane.getHorizontalScrollBarPolicy() != ScrollPaneConstants.HORIZONTAL_SCROLLBAR_AS_NEEDED
                && scrollPane.getVerticalScrollBarPolicy() != ScrollPaneConstants.VERTICAL_SCROLLBAR_AS_NEEDED) {
            return false;
        }

        // Get the union of all the layers' bounds
        final PBounds layerBounds = new PBounds();
        final List layers = camera.getLayersReference();
        for (final Iterator i = layers.iterator(); i.hasNext();) {
            final PLayer layer = (PLayer) i.next();
            layerBounds.add(layer.getFullBoundsReference());
        }

        // Put into camera coordinates
        camera.viewToLocal(layerBounds);

        // And union with the camera bounds
        final PBounds cameraBounds = camera.getBoundsReference();
        layerBounds.add(cameraBounds);

        // Truncate these to ints before comparing since
        // that's what the ScrollPane uses
        final int layerWidth = (int) (layerBounds.getWidth() + 0.5);
        final int layerHeight = (int) (layerBounds.getHeight() + 0.5);
        final int cameraWidth = (int) (cameraBounds.getWidth() + 0.5);
        final int cameraHeight = (int) (cameraBounds.getHeight() + 0.5);

        if (scrollPane.getHorizontalScrollBar().isShowing() && layerWidth <= cameraWidth
                || !scrollPane.getHorizontalScrollBar().isShowing() && layerWidth > cameraWidth
                || scrollPane.getVerticalScrollBar().isShowing() && layerHeight <= cameraHeight
                || !scrollPane.getVerticalScrollBar().isShowing() && layerHeight > cameraHeight) {
            return true;
        }
    }
    return false;
}
 

import edu.umd.cs.piccolo.util.PBounds; //导入依赖的package包/类
protected void centerNode( PNode node ) {
    if ( node != null ) {
        Dimension2D worldSize = getWorldSize();
        PBounds b = node.getFullBoundsReference();
        double xOffset = ( worldSize.getWidth() - b.getWidth() - PNodeLayoutUtils.getOriginXOffset( node ) ) / 2;
        double yOffset = ( worldSize.getHeight() - b.getHeight() - PNodeLayoutUtils.getOriginYOffset( node ) ) / 2;
        node.setOffset( xOffset, yOffset );
    }
}
 

import edu.umd.cs.piccolo.util.PBounds; //导入依赖的package包/类
/**
 * Force this handle to relocate itself using its locator.
 */
public void relocateHandle() {
    if (locator == null) {
        return;
    }

    final PBounds b = getBoundsReference();
    final Point2D aPoint = locator.locatePoint(null);

    if (locator instanceof PNodeLocator) {
        final PNode located = ((PNodeLocator) locator).getNode();
        final PNode parent = getParent();

        located.localToGlobal(aPoint);
        globalToLocal(aPoint);

        if (parent != located && parent instanceof PCamera) {
            ((PCamera) parent).viewToLocal(aPoint);
        }
    }

    final double newCenterX = aPoint.getX();
    final double newCenterY = aPoint.getY();

    if (newCenterX != b.getCenterX() || newCenterY != b.getCenterY()) {

        centerBoundsOnPoint(newCenterX, newCenterY);
    }

}
 

import edu.umd.cs.piccolo.util.PBounds; //导入依赖的package包/类
/** {@inheritDoc} */
protected PBounds getMarqueeBounds() {
    if (marquee != null) {
        return marquee.getBounds();
    }
    return new PBounds();
}
 

import edu.umd.cs.piccolo.util.PBounds; //导入依赖的package包/类
private void updateRtpLayout()
{
    Rectangle2D probabilityDensityPlotBounds = _chartNode.localToGlobal( _chartNode.getProbabilityDensityPlotBounds() );
    PBounds pdZoomControlBounds = _probabilityDensityZoomControl.getFullBounds();
    
    Direction direction = _planeWave.getDirection();
    
    AbstractProbabilityNode leftNode = null;
    AbstractProbabilityNode rightNode = null;
    if ( direction == Direction.LEFT_TO_RIGHT ) {
        leftNode = _reflectionProbabilityNode;
        rightNode = _transmissionProbabilityNode;
    }
    else {
        leftNode = _transmissionProbabilityNode; 
        rightNode = _reflectionProbabilityNode;
    }
    
    double x, y;
    final double xmargin = 15;
    final double ymargin = 15;
    final double xFudge = 60;
    
    x = pdZoomControlBounds.getMaxX() + xmargin;
    y = probabilityDensityPlotBounds.getY() + ymargin;
    leftNode.setOffset( x, y );
    
    x = probabilityDensityPlotBounds.getX() + probabilityDensityPlotBounds.getWidth() - xFudge - xmargin;
    rightNode.setOffset( x, y );
}
 

import edu.umd.cs.piccolo.util.PBounds; //导入依赖的package包/类
private static PNode createTick( double value, String units, boolean labelOnLeft ) {
    
    PComposite tickNode = new PComposite();
    
    // horizontal line
    GeneralPath path = new GeneralPath();
    path.moveTo( 0f, 0f );
    if ( labelOnLeft ) {
        path.lineTo( (float) -TICK_LENGTH, 0f ); 
    }
    else {
        path.lineTo( (float) TICK_LENGTH, 0f );
    }
    PPath lineNode = new PPath( path );
    lineNode.setPaint( null );
    lineNode.setStroke( TICK_STROKE );
    lineNode.setStrokePaint( TICK_COLOR );
    tickNode.addChild( lineNode );
    
    // label
    String s = TICK_LABEL_FORMAT.format( value ) + units;
    PText labelNode = new PText( s );
    labelNode.setFont( TICK_LABEL_FONT );
    labelNode.setTextPaint( TICK_LABEL_COLOR );
    tickNode.addChild( labelNode );
    
    // position label on left or right of tick, vertically align centers
    lineNode.setOffset( 0, 0 );
    PBounds bLine = lineNode.getFullBoundsReference();
    PBounds bLabel = labelNode.getFullBoundsReference();
    if ( labelOnLeft ) {
        labelNode.setOffset( bLine.getMinX() - bLabel.getWidth() - TICK_LABEL_SPACING, bLine.getCenterY() - bLabel.getHeight() / 2 );
    }
    else {
        labelNode.setOffset( bLine.getMaxX() + TICK_LABEL_SPACING, bLine.getCenterY() - bLabel.getHeight() / 2 );
    }
    
    return tickNode;
}
 

import edu.umd.cs.piccolo.util.PBounds; //导入依赖的package包/类
/**
 * @return Molecule area. Excludes the area in the black box where the 3D button needs to go
 */
private PBounds getMoleculeAreaInBlackBox() {
    PBounds blackBoxFullBounds = blackBox.getFullBounds();
    return new PBounds(
            blackBoxFullBounds.getX(),
            blackBoxFullBounds.getY(),
            blackBoxFullBounds.getWidth() - BLACK_BOX_PADDING_FOR_3D - button3dWidth, // leave room for 3d button on RHS
            blackBoxFullBounds.getHeight()
    );
}
 

import edu.umd.cs.piccolo.util.PBounds; //导入依赖的package包/类
private void centerMoleculesInBlackBox() {
    PBounds moleculeArea = getMoleculeAreaInBlackBox();

    // for now, we scale the molecules up and down depending on their size
    moleculeLayer.setScale( 1 );
    double xScale = ( moleculeArea.getWidth() - 25 ) / moleculeLayer.getFullBounds().getWidth();
    double yScale = ( moleculeArea.getHeight() - 25 ) / moleculeLayer.getFullBounds().getHeight();
    moleculeLayer.setScale( Math.min( xScale, yScale ) );

    moleculeLayer.centerFullBoundsOnPoint(
            moleculeArea.getCenterX() - moleculeArea.getX(),
            moleculeArea.getCenterY() - moleculeArea.getY() );
}
 

import edu.umd.cs.piccolo.util.PBounds; //导入依赖的package包/类
public void testCreatePolyLinePoint2DReturnsValidPPath() {
    final PPath path = PPath.createPolyline(new Point2D[] { new Point2D.Double(0, 0), new Point2D.Double(100, 50),
            new Point2D.Double(100, 0) });
    assertNotNull(path);

    // Seems like rounding is affecting the bounds greatly
    PiccoloAsserts.assertEquals(new PBounds(0, 0, 100, 50), path.getBounds(), 2.0d);
}