omgeometrylist.java

openmap java写的开源数字地图程序. 用applet实现,可以像google map 那样放大缩小地图.

            } else {
                iterator = targets.listIterator();
                while (iterator.hasNext()) {
                    geometry = (OMGeometry) iterator.next();

                    if (geometry.isVisible()) {
                        renderGeometry(geometry, gr);
                    }
                }
            }
        }
    }

    protected void renderGeometry(OMGeometry geometry, Graphics gr) {
        if (matted) {
            if (gr instanceof Graphics2D && stroke instanceof BasicStroke) {
                ((Graphics2D) gr).setStroke(new BasicStroke(((BasicStroke) stroke).getLineWidth() + 2f));
                setGraphicsColor(gr, mattingPaint);
                geometry.draw(gr);
            }
        }

        setGraphicsForFill(gr);
        geometry.fill(gr);
        setGraphicsForEdge(gr);
        geometry.draw(gr);
    }

    /**
     * Renders all the objects in the list a geometry's context, in
     * their 'selected' mode. This is the same as <code>paint()</code>
     * for AWT components. The geometries are rendered in the order of
     * traverseMode. Any geometries where <code>isVisible()</code>
     * returns false are not rendered. All of the geometries on the
     * list are returned to their deselected state.
     * 
     * @param gr the AWT Graphics context
     */
    public void renderAllAsSelected(Graphics gr) {
        if (shape != null) {

            setGraphicsForFill(gr);
            ((Graphics2D) gr).fill(shape);
            select();
            setGraphicsForEdge(gr);
            ((Graphics2D) gr).draw(shape);
            deselect();

        }
    }

    /**
     * Prepare the geometries for rendering. This must be done before
     * calling <code>render()</code>! This recursively calls
     * generate() on the OMGeometries on the list.
     * 
     * @param p a <code>Projection</code>
     * @param forceProjectAll if true, all the geometries on the list
     *        are generated with the new projection. If false they are
     *        only generated if getNeedToRegenerate() returns true
     * @see OMGeometry#generate
     * @see OMGeometry#regenerate
     */
    public synchronized void generate(Projection p, boolean forceProjectAll) {

        // Important! Resets the shape.
        shape = null;

        // Create a shape object out of all of the shape objects.
        ListIterator iterator;

        if (traverseMode == FIRST_ADDED_ON_TOP) {
            iterator = graphics.listIterator(graphics.size());
            while (iterator.hasPrevious()) {
                updateShape((OMGeometry) iterator.previous(),
                        p,
                        forceProjectAll);
            }
        } else {
            iterator = graphics.listIterator();
            while (iterator.hasNext()) {
                updateShape((OMGeometry) iterator.next(), p, forceProjectAll);
            }
        }
        setNeedToRegenerate(false);
    }

    /**
     * Given a OMGeometry, it calls generate/regenerate on it, and
     * then adds the GeneralPath shape within it to the OMGeometryList
     * shape object.
     */
    protected void updateShape(OMGeometry geometry, Projection p,
                               boolean forceProject) {

        if (forceProject) {
            geometry.generate(p);
        } else {
            geometry.regenerate(p);
        }

        if (geometry.isVisible()) {
            GeneralPath gp = (GeneralPath) geometry.getShape();

            if (gp == null) {
                return;
            }

            if (shape == null) {
                shape = gp;
            } else {
                ((GeneralPath) shape).append(gp, connectParts);
            }
        }
    }

    /**
     * Return the shortest distance from the graphic to an XY-point.
     * Checks to see of the point is contained within the OMGraphic,
     * which may, or may not be the right thing for clear OMGraphics
     * or lines.
     * <p>
     * 
     * _distance was added so subclasses could make this call if their
     * geometries/attributes require this action (when fill color
     * doesn't matter).
     * 
     * @param x X coordinate of the point.
     * @param y Y coordinate of the point.
     * @return float distance, in pixels, from graphic to the point.
     *         Returns Float.POSITIVE_INFINITY if the graphic isn't
     *         ready (ungenerated).
     */
    protected float _distance(int x, int y) {
        float distance = Float.POSITIVE_INFINITY;

        if (isVague()) {

            if (getNeedToRegenerate() || shape == null) {
                return distance;
            }

            if (shape.contains((double) x, (double) y)) {
                //          if (Debug.debugging("omgraphicdetail")) {
                //              Debug.output(" contains " + x + ", " + y);
                //          }
                distance = 0f;
            } else {
                distance = distanceToEdge(x, y);
            }
        } else {
            distance = super._distance(x, y);
        }

        return distance;
    }

    protected synchronized OMDist _findClosest(int x, int y, float limit,
                                               boolean resetSelect) {

        if (shape != null) {
            float currentDistance = _distance(x, y);
            OMDist omd = new OMDist();

            if (currentDistance < limit) {
                omd.omg = this;
                omd.d = currentDistance;
            }
            return omd;
        } else {
            return super._findClosest(x, y, limit, resetSelect);
        }
    }

    /**
     * Finds the object located the closest to the point, if the
     * object distance away is within the limit. The search is always
     * conducted from the topmost geometry to the bottommost,
     * depending on the traverseMode. Any geometries where
     * <code>isVisible()</code> returns false are not considered.
     * 
     * @param x the x coordinate on the component the geometries are
     *        displayed on.
     * @param y the y coordinate on the component the geometries are
     *        displayed on.
     * @param limit the max distance that a geometry has to be within
     *        to be returned, in pixels.
     * @return OMGeometry the closest on the list within the limit, or
     *         null if not found.
     */
    public OMGeometry findClosestGeometry(int x, int y, float limit) {
        return _findClosest(x, y, limit).omg;
    }

    /**
     * This method returns an OMGraphic if the thing that is found
     * closest to the coordinates is an OMGraphic. It mose likely is
     * an OMGeometry, so it can return null if it found something
     * close to the coordinates that isn't an OMGraphic.
     */
    public OMGraphic findClosest(int x, int y, float limit) {
        return objectToOMGraphic(_findClosest(x, y, limit).omg);
    }

    /**
     * This method returns an OMGraphic if the thing that is found
     * closest to the coordinates is an OMGraphic. It mose likely is
     * an OMGeometry, so it can return null if it found something
     * close to the coordinates that isn't an OMGraphic. It will tell
     * anything it finds to be selected, however, whether it is an
     * OMGraphic or OMGeometry.
     */
    public OMGraphic selectClosest(int x, int y, float limit) {
        return objectToOMGraphic(_selectClosest(x, y, limit));
    }

    /**
     * Finds the object located the closest to the point, regardless
     * of how far away it is. This method returns null if the list is
     * not valid. The search starts at the first-added geometry. <br>
     * This is the same as calling
     * <code>findClosest(x, y, Float.MAX_VALUE)</code>.
     * 
     * @param x the horizontal pixel position of the window, from the
     *        left of the window.
     * @param y the vertical pixel position of the window, from the
     *        top of the window.
     * @return the closest geometry to the xy window point.
     * @see #findClosest(int, int, float)
     */
    public OMGeometry findClosestGeometry(int x, int y) {
        return _findClosest(x, y, Float.MAX_VALUE).omg;
    }

    /**
     * Finds the object located the closest to the coordinates,
     * regardless of how far away it is. Sets the select paint of that
     * object, and resets the paint of all the other objects. The
     * search starts at the first-added graphic.
     * 
     * @param x the x coordinate on the component the graphics are
     *        displayed on.
     * @param y the y coordinate on the component the graphics are
     *        displayed on.
     * @return the closest OMGraphic on the list.
     */
    public OMGeometry selectClosestGeometry(int x, int y) {
        return _selectClosest(x, y, Float.MAX_VALUE);
    }

    /**
     * Finds the object located the closest to the point, if the
     * object distance away is within the limit, and sets the paint of
     * that geometry to its select paint. It sets the paints to all
     * the other objects to the regular paint. The search starts at
     * the first-added geometry. Any geometries where
     * <code>isVisible()</code> returns false are not considered.
     * 
     * @param x the horizontal pixel position of the window, from the
     *        left of the window.
     * @param y the vertical pixel position of the window, from the
     *        top of the window.
     * @param limit the max distance that a geometry has to be within
     *        to be returned, in pixels.
     * @return the closest OMGeometry on the list, within the limit or
     *         null if none found.
     */
    public OMGeometry selectClosestGeometry(int x, int y, float limit) {
        return _selectClosest(x, y, limit);
    }

    /**
     * Finds the first OMGeometry (the one on top) that is under this
     * pixel. This method will return the particular OMGeometry that
     * may fall around the pixel location. If you want to know if the
     * pixel touches any part of this list, call contains(x, y)
     * instead.
     * 
     * @param x the horizontal pixel position of the window, from the
     *        left of the window.
     * @param y the vertical pixel position of the window, from the
     *        top of the window.
     * @return the geometry that contains the pixel, NONE (null) if
     *         none are found.
     */
    public OMGeometry getContains(int x, int y) {
        if (shape != null && isVague() && shape.contains(x, y)) {
            return this;
        } else {
            return _getContains(x, y);
        }
    }

    /**
     * Returns this list if x, y is inside the bounds of the contents
     * of this list.
     */
    public OMGraphic getOMGraphicThatContains(int x, int y) {
        return objectToOMGraphic(getContains(x, y));
    }

    /**
     * Perform an action on the provided geometry. If the geometry is
     * not currently on the list, it is added (if the action doesn't
     * say to delete it). If the geometry is null, the list checks for
     * an action to take on the list (deselectAll).
     */
    public void doAction(OMGeometry geometry, OMAction action) {
        _doAction(geometry, action);
    }

    /**
     * Read a cache of OMGeometries, given a ObjectInputStream.
     * 
     * @param objstream ObjectInputStream of geometry list.
     */
    public void readGraphics(ObjectInputStream objstream) throws IOException {

        Debug.message("omgraphics", "OMGeometryList: Reading cached geometries");

        try {
            while (true) {
                try {
                    OMGeometry omg = (OMGeometry) objstream.readObject();
                    this.add(omg);
                } catch (ClassNotFoundException e) {
                    e.printStackTrace();
                } catch (OptionalDataException ode) {
                    ode.printStackTrace();
                }
            }
        } catch (EOFException e) {
        }
    }

    /**
     * Set whether the OMGeometries on the list should be connected to
     * make a one-part shape object (if true), or a multi-part shape
     * object (if false).
     */
    public void setConnectParts(boolean value) {
        connectParts = value;
    }

    /**
     * Get whether the OMGeometries on the list should be connected to
     * make a one-part shape object (if true), or a multi-part shape
     * object (if false).
     */
    public boolean getConnectParts() {
        return connectParts;
    }

}