Java PBounds.setRect方法代码示例

import edu.umd.cs.piccolo.util.PBounds; //导入方法依赖的package包/类
/**
 * Change the full bounds computation to take into account that we are
 * expanding the children's bounds Do this instead of overriding
 * getBoundsReference() since the node is not volatile
 */
public PBounds computeFullBounds(final PBounds dstBounds) {
    final PBounds result = getUnionOfChildrenBounds(dstBounds);

    cachedChildBounds.setRect(result);
    result.setRect(result.getX() - INDENT, result.getY() - INDENT, result.getWidth() + 2 * INDENT, result
            .getHeight()
            + 2 * INDENT);
    localToParent(result);
    return result;
}
 

import edu.umd.cs.piccolo.util.PBounds; //导入方法依赖的package包/类
/**
 * Since our bounds are volatile, we can override this method to indicate
 * that we are expanding our bounds beyond our children
 */
public PBounds getBoundsReference() {
    final PBounds bds = super.getBoundsReference();
    getUnionOfChildrenBounds(bds);

    cachedChildBounds.setRect(bds);
    final double scaledIndent = INDENT / renderCamera.getViewScale();
    bds.setRect(bds.getX() - scaledIndent, bds.getY() - scaledIndent, bds.getWidth() + 2 * scaledIndent, bds
            .getHeight()
            + 2 * scaledIndent);

    return bds;
}
 

import edu.umd.cs.piccolo.util.PBounds; //导入方法依赖的package包/类
/** {@inheritDoc} */
public PBounds getBoundsReference() {
    final PBounds targetBounds = target.getFullBounds();
    camera.viewToLocal(targetBounds);
    camera.globalToLocal(targetBounds);
    final PBounds bounds = super.getBoundsReference();
    bounds.setRect(targetBounds);
    return super.getBoundsReference();
}
 

import edu.umd.cs.piccolo.util.PBounds; //导入方法依赖的package包/类
/**
 * The sticky handle manager's bounds as computed by examining its target
 * through its camera.
 * 
 * @return the sticky handle manager's bounds as computed by examining its
 *         target through its camera
 */
public PBounds getBoundsReference() {
    final PBounds targetBounds = target.getFullBounds();
    camera.viewToLocal(targetBounds);
    camera.globalToLocal(targetBounds);
    final PBounds bounds = super.getBoundsReference();
    bounds.setRect(targetBounds);
    return super.getBoundsReference();
}
 

import edu.umd.cs.piccolo.util.PBounds; //导入方法依赖的package包/类
/**
 * Transforms the view so that it conforms to the given constraint.
 */
protected void applyViewConstraints() {
    if (VIEW_CONSTRAINT_NONE == viewConstraint) {
        return;
    }
    final PBounds viewBounds = getViewBounds();
    final PBounds layerBounds = (PBounds) globalToLocal(getUnionOfLayerFullBounds());

    if (VIEW_CONSTRAINT_CENTER == viewConstraint) {
        layerBounds.setRect(layerBounds.getCenterX(), layerBounds.getCenterY(), 0, 0);            
    }
    PDimension constraintDelta = viewBounds.deltaRequiredToContain(layerBounds);
    viewTransform.translate(-constraintDelta.width, -constraintDelta.height);
}
 

import edu.umd.cs.piccolo.util.PBounds; //导入方法依赖的package包/类
/**
 * Is invoked when the handle is being dragged.
 * 
 * @param aLocalDimension dimension representing the magnitude of the handle
 *            drag
 * @param aEvent event responsible for the call
 */
public void dragHandle(final PDimension aLocalDimension, final PInputEvent aEvent) {
    final PBoundsLocator l = (PBoundsLocator) getLocator();

    final PNode n = l.getNode();
    final PBounds b = n.getBounds();

    final PNode parent = getParent();
    if (parent != n && parent instanceof PCamera) {
        ((PCamera) parent).localToView(aLocalDimension);
    }

    localToGlobal(aLocalDimension);
    n.globalToLocal(aLocalDimension);

    final double dx = aLocalDimension.getWidth();
    final double dy = aLocalDimension.getHeight();

    switch (l.getSide()) {
        case SwingConstants.NORTH:
            b.setRect(b.x, b.y + dy, b.width, b.height - dy);
            break;

        case SwingConstants.SOUTH:
            b.setRect(b.x, b.y, b.width, b.height + dy);
            break;

        case SwingConstants.EAST:
            b.setRect(b.x, b.y, b.width + dx, b.height);
            break;

        case SwingConstants.WEST:
            b.setRect(b.x + dx, b.y, b.width - dx, b.height);
            break;

        case SwingConstants.NORTH_WEST:
            b.setRect(b.x + dx, b.y + dy, b.width - dx, b.height - dy);
            break;

        case SwingConstants.SOUTH_WEST:
            b.setRect(b.x + dx, b.y, b.width - dx, b.height + dy);
            break;

        case SwingConstants.NORTH_EAST:
            b.setRect(b.x, b.y + dy, b.width + dx, b.height - dy);
            break;

        case SwingConstants.SOUTH_EAST:
            b.setRect(b.x, b.y, b.width + dx, b.height + dy);
            break;
        default:
            throw new RuntimeException("Invalid side returned from PBoundsLocator");
    }

    boolean flipX = false;
    boolean flipY = false;

    if (b.width < 0) {
        flipX = true;
        b.width = -b.width;
        b.x -= b.width;
    }

    if (b.height < 0) {
        flipY = true;
        b.height = -b.height;
        b.y -= b.height;
    }

    if (flipX || flipY) {
        flipSiblingBoundsHandles(flipX, flipY);
    }

    n.setBounds(b);
}