Java PPickPath.pushTransform方法代码示例

import org.piccolo2d.util.PPickPath; //导入方法依赖的package包/类
/**
 * Try to pick this node and all of its descendants if they are visible in
 * the clipping region.
 * 
 * @param pickPath the pick path to add the node to if its picked
 * @return true if this node or one of its descendants was picked.
 */
public boolean fullPick(final PPickPath pickPath) {
    if (getPickable() && fullIntersects(pickPath.getPickBounds())) {
        pickPath.pushNode(this);
        pickPath.pushTransform(getTransformReference(false));

        if (pick(pickPath)) {
            return true;
        }

        if (getChildrenPickable() && getPathReference().intersects(pickPath.getPickBounds())) {
            final int count = getChildrenCount();
            for (int i = count - 1; i >= 0; i--) {
                final PNode each = getChild(i);
                if (each.fullPick(pickPath)) {
                    return true;
                }
            }
        }

        if (pickAfterChildren(pickPath)) {
            return true;
        }

        pickPath.popTransform(getTransformReference(false));
        pickPath.popNode(this);
    }

    return false;
}
 

import org.piccolo2d.util.PPickPath; //导入方法依赖的package包/类
/**
 * Traverse the pick path determining which parent nodes are occluded by
 * their children nodes. Note that this is only detecting a subset of
 * occlusions (parent, child), others such as overlapping siblings or
 * cousins are not detected.
 * 
 * @param node node from which to detect occlusions
 * @param pickPath Pick Path to traverse
 */
public void detectOcclusions(final PNode node, final PPickPath pickPath) {
    if (!node.fullIntersects(pickPath.getPickBounds())) {
        return;
    }

    pickPath.pushTransform(node.getTransformReference(false));

    final int count = node.getChildrenCount();
    for (int i = count - 1; i >= 0; i--) {
        final PNode each = node.getChild(i);
        if (node.getOccluded()) {
            // if n has been occluded by a previous descendant then
            // this child must also be occluded
            each.setOccluded(true);
        }
        else {
            // see if child each occludes n
            detectOcclusions(each, pickPath);
        }
    }

    if (nodeOccludesParents(node, pickPath)) {
        final PNode parent = node.getParent();
        while (parent != null && !parent.getOccluded()) {
            parent.setOccluded(true);
        }
    }

    pickPath.popTransform(node.getTransformReference(false));
}
 

import org.piccolo2d.util.PPickPath; //导入方法依赖的package包/类
/**
 * Generate and return a PPickPath for the point x,y specified in the local
 * coord system of this camera. Picking is done with a rectangle, halo
 * specifies how large that rectangle will be.
 * 
 * @param x the x coordinate of the pick path given in local coordinates
 * @param y the y coordinate of the pick path given in local coordinates
 * @param halo the distance from the x,y coordinate that is considered for
 *            inclusion in the pick path
 * 
 * @return the picked path
 */
public PPickPath pick(final double x, final double y, final double halo) {
    final PBounds b = new PBounds(new Point2D.Double(x, y), -halo, -halo);
    final PPickPath result = new PPickPath(this, b);

    fullPick(result);

    // make sure this camera is pushed.
    if (result.getNodeStackReference().size() == 0) {
        result.pushNode(this);
        result.pushTransform(getTransformReference(false));
    }

    return result;
}
 

import org.piccolo2d.util.PPickPath; //导入方法依赖的package包/类
/**
 * {@inheritDoc}
 * 
 * <p>
 * After the direct children of this camera have been given a chance to be
 * picked all of the layers in the list of layers viewed by this camera are
 * given a chance to be picked.
 * </p>
 * 
 * @return true if any of the layers in the list of layers viewed by this
 *    camera were picked
 */
protected boolean pickAfterChildren(final PPickPath pickPath) {
    if (intersects(pickPath.getPickBounds())) {
        pickPath.pushTransform(viewTransform);

        if (pickCameraView(pickPath)) {
            return true;
        }

        pickPath.popTransform(viewTransform);
        return true;
    }
    return false;
}
 

import org.piccolo2d.util.PPickPath; //导入方法依赖的package包/类
/**
 * Try to pick this node and all of its descendants. Most subclasses should
 * not need to override this method. Instead they should override
 * <code>pick</code> or <code>pickAfterChildren</code>.
 * 
 * @param pickPath the pick path to add the node to if its picked
 * @return true if this node or one of its descendants was picked.
 */
public boolean fullPick(final PPickPath pickPath) {
    if (getVisible() && (getPickable() || getChildrenPickable()) && fullIntersects(pickPath.getPickBounds())) {
        pickPath.pushNode(this);
        pickPath.pushTransform(transform);

        final boolean thisPickable = getPickable() && pickPath.acceptsNode(this);

        if (thisPickable && pick(pickPath)) {
            return true;
        }

        if (getChildrenPickable()) {
            final int count = getChildrenCount();
            for (int i = count - 1; i >= 0; i--) {
                final PNode each = (PNode) children.get(i);
                if (each.fullPick(pickPath)) {
                    return true;
                }
            }
        }

        if (thisPickable && pickAfterChildren(pickPath)) {
            return true;
        }

        pickPath.popTransform(transform);
        pickPath.popNode(this);
    }

    return false;
}