Java PNode.getFullBounds方法代码示例

import edu.umd.cs.piccolo.PNode; //导入方法依赖的package包/类
/**
 * Maps the location (upper-left corner) of a PNode on a specified PCanvas to
 * the coordinate system of the parent help pane.
 *
 * @param node
 * @param canvas
 * @return
 */
public Point2D mapLocation( PNode node, PCanvas canvas ) {
    // Determine the node's location in canvas coordinates...
    int x = 0;
    int y = 0;
    {
        // Get the node's full bounds (union of its bounds and all children) in parent node's local coordinates
        Rectangle2D fullBounds = node.getFullBounds();
        // Get the node's global bounds - above the root node's transform, but below the canvas's view transform.
        Rectangle2D globalFullBounds = node.getParent().localToGlobal( fullBounds );

        //TODO: perhaps this code should transform this.globalToLocal(globalFullBounds) to identify the correct location.
        // Apply the canvas' view transform to get bounds in the canvas' coordinate system.
        PCamera camera = canvas.getCamera();
        PAffineTransform transform = camera.getViewTransformReference();
        Rectangle2D bounds = transform.transform( globalFullBounds, null );
        x = (int) bounds.getX();
        y = (int) bounds.getY();
    }

    // Convert the canvas location to a location in the help pane.
    Point2D helpPanePoint = SwingUtilities.convertPoint( canvas, x, y, _helpPane );
    return helpPanePoint;
}
 

import edu.umd.cs.piccolo.PNode; //导入方法依赖的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.PNode; //导入方法依赖的package包/类
public BackgroundNode( PNode node ) {
    super();
    setPickable( false );
    final double m = BACKGROUND_MARGIN;
    final double r = BACKGROUND_CORNER_RADIUS;
    PBounds b = node.getFullBounds();
    setPathTo( new RoundRectangle2D.Double( b.getX() - m, b.getY() - m, b.getWidth() + ( 2 * m ), b.getHeight() + ( 2 * m ), r, r ) );
    setStroke( BACKGROUND_STROKE );
    setStrokePaint( BACKGROUND_STROKE_COLOR );
    setPaint( BACKGROUND_COLOR );
}
 

import edu.umd.cs.piccolo.PNode; //导入方法依赖的package包/类
public PNodeFacade( PNode target ) {
    addChild( target );
    target.setPickable( false );
    target.setChildrenPickable( false );
    PBounds bounds = target.getFullBounds();
    addChild( new PhetPPath( bounds, new Color( 0, 0, 0, 0 ) ) );
}
 

import edu.umd.cs.piccolo.PNode; //导入方法依赖的package包/类
/**
 * Maps to a point that allows us to point to the center of
 * one of the node's edges, instead of its upper-left corner.
 * Which edge is dependent on the arrow position.
 *
 * @param node
 * @param canvas
 */
public Point2D mapLocation( PNode node, PCanvas canvas ) {

    // Map the node's location (upper-left corner) to help pane coordinates...
    Point2D p = super.mapLocation( node, canvas );

    // Determine the node's dimensions, in help pane coordinates...
    Rectangle2D fullBounds = node.getFullBounds(); // in parent's local coordinates
    Rectangle2D globalFullBounds = node.getParent().localToGlobal( fullBounds );
    PCamera camera = canvas.getCamera();
    PAffineTransform transform = camera.getViewTransformReference();
    Rectangle2D bounds = transform.transform( globalFullBounds, null );
    double width = bounds.getWidth();
    double height = bounds.getHeight();

    // Translate the help pane coordinates, using the node's dimensions and arrow position...
    if ( isArrowOnTop() ) {
        p.setLocation( p.getX() + ( width / 2 ), p.getY() + height );
    }
    else if ( isArrowOnBottom() ) {
        p.setLocation( p.getX() + ( width / 2 ), p.getY() );
    }
    else if ( isArrowOnRight() ) {
        p.setLocation( p.getX(), p.getY() + ( height / 2 ) );
    }
    else {
        p.setLocation( p.getX() + width, p.getY() + ( height / 2 ) );
    }

    return p;
}
 

import edu.umd.cs.piccolo.PNode; //导入方法依赖的package包/类
public Rectangle2D apply( PNode pNode ) {
    return pNode.getFullBounds();
}
 

import edu.umd.cs.piccolo.PNode; //导入方法依赖的package包/类
@Override protected PBounds getControlPanelBounds( PNode content ) {
    if ( contentBounds == null ) {
        contentBounds = content.getFullBounds();
    }
    return contentBounds;
}
 

import edu.umd.cs.piccolo.PNode; //导入方法依赖的package包/类
public InjectorNode( double rotationAngle, final SimpleObserver inject ) {
    this.inject = inject;

    // Create the root node to which the various constituent parts can be
    // added.
    injectorNode = new PNode();

    // Load the graphic images for this device.  These are offset in order
    // to make the center of rotation be the center of the bulb.
    BufferedImage injectorBodyImage = RESOURCES.getImage( "squeezer_background.png" );
    PNode injectorBodyImageNode = new PImage( injectorBodyImage );
    Rectangle2D originalBodyBounds = injectorBodyImageNode.getFullBounds();
    injectorBodyImageNode.setOffset( -originalBodyBounds.getWidth() / 2, -originalBodyBounds.getHeight() / 2 );
    injectorNode.addChild( injectorBodyImageNode );

    pressedButtonImage = RESOURCES.getImage( "button_pressed.png" );
    unpressedButtonImage = RESOURCES.getImage( "button_unpressed.png" );
    buttonImageNode = new PImage( unpressedButtonImage );
    buttonImageNode.setOffset( BUTTON_OFFSET );
    injectorNode.addChild( buttonImageNode );

    // Rotate and scale the image node as a whole.
    double scale = INJECTOR_HEIGHT / injectorBodyImageNode.getFullBoundsReference().height;
    injectorNode.rotate( -rotationAngle );
    injectorNode.scale( scale );

    // Add the injector image node.  Note that the position has to be
    // tweaked in order to account for the rotation of the node image,
    // since the rotation of the square image enlarges the bounds.
    injectorNode.setOffset( -Math.abs( Math.sin( rotationAngle * 2 ) ) * 30, 0 );
    addChild( injectorNode );

    // Set up the injection point offset. This makes some assumptions
    // about the nature of the image, and will need to be updated if the
    // image is changed.
    distanceCenterToTip = 0.7 * INJECTOR_HEIGHT;
    final double centerOffsetX = 0.4 * INJECTOR_HEIGHT;
    Dimension2D injectionPointOffset = new PDimension();
    injectionPointOffset.setSize( distanceCenterToTip * Math.cos( rotationAngle ) + centerOffsetX,
                                  distanceCenterToTip * Math.sin( -rotationAngle ) );

    // Set up the button handling.
    injectorBodyImageNode.setPickable( false );
    buttonImageNode.setPickable( true );
}
 

import edu.umd.cs.piccolo.PNode; //导入方法依赖的package包/类
/**
 * Utility method for calculating the scale factor needed to make a PNode
 * fit within the specified size.
 */
private double calculateScaleForTargetSize( PNode node, Dimension2D desiredSize ) {

    PBounds bounds = node.getFullBounds();

    double xDimensionScale = desiredSize.getWidth() / bounds.width;
    double yDimensionScale = desiredSize.getHeight() / bounds.height;

    return Math.min( xDimensionScale, yDimensionScale );
}
 

import edu.umd.cs.piccolo.PNode; //导入方法依赖的package包/类
/**
 * Determine the bounds of the control panel.  This implementation uses the bounds of the content.
 * This may be overridden if subclasses don't want control panel size to change when the contents
 * change.
 *
 * @param content the content PNode in this ControlPanelNode
 * @return the PBounds which the ControlPanelNode should occupy
 */
protected PBounds getControlPanelBounds( PNode content ) {
    return content.getFullBounds();
}