assertGrabPoints();        OMPoint point = (OMPoint) graphic;        boolean ntr = point.getNeedToRegenerate();        int renderType = point.getRenderType();        LatLonPoint llp;        int latoffset = 0;        int lonoffset = 0;        boolean doStraight = true;        if (ntr == false) {            if (renderType == OMGraphic.RENDERTYPE_LATLON                    || renderType == OMGraphic.RENDERTYPE_OFFSET) {                if (projection != null) {                    float lon = point.getLon();                    float lat = point.getLat();                    llp = new LatLonPoint(lat, lon);                    java.awt.Point p = projection.forward(llp);                    if (renderType == OMGraphic.RENDERTYPE_LATLON) {                        doStraight = false;                        gpc.set((int) p.getX(), (int) p.getY());                    } else {                        latoffset = (int) p.getY();                        lonoffset = (int) p.getX();                        gpo.set(lonoffset, latoffset);                    }                }            }            if (doStraight) {                gpc.set(lonoffset + point.getX(), latoffset + point.getY());            }            if (renderType == OMGraphic.RENDERTYPE_OFFSET) {                gpo.updateOffsets();            }        } else {            Debug.message("eomg",                    "EditableOMPoint.setGrabPoints: graphic needs to be regenerated");        }    }    /**     * Take the current location of the GrabPoints, and modify the     * location parameters of the OMPoint with them. Called when you     * want the graphic to change according to the grab points.     */    public void setGrabPoints() {        int renderType = point.getRenderType();        LatLonPoint llp1;        Debug.message("eomg", "EditableOMPoint.setGrabPoints()");        // Do center point for lat/lon or offset points        if (renderType == OMGraphic.RENDERTYPE_LATLON) {            if (projection != null) {                //movingPoint == gpc                llp1 = projection.inverse(gpc.getX(), gpc.getY());                point.set(llp1.getLatitude(), llp1.getLongitude());                // point.setNeedToRegenerate set            }        }        boolean settingOffset = getStateMachine().getState() instanceof GraphicSetOffsetState                && movingPoint == gpo;        // If the center point is moving, the offset distance changes        if (renderType == OMGraphic.RENDERTYPE_OFFSET) {            llp1 = projection.inverse(gpo.getX(), gpo.getY());            point.setLat(llp1.getLatitude());            point.setLon(llp1.getLongitude());            if (settingOffset || movingPoint == gpc) {                // Don't call point.setLocation because we only want                // to                // setNeedToRegenerate if !settingOffset.                point.setX(gpc.getX() - gpo.getX());                point.setY(gpc.getY() - gpo.getY());            }            if (!settingOffset) {                Debug.message("eomg", "EditableOMPoint: updating offset point");                point.set(gpc.getX() - gpo.getX(), gpc.getY() - gpo.getY());            }            // Set Location has reset the rendertype, but provides            // the convenience of setting the max and min values            // for us.            point.setRenderType(OMGraphic.RENDERTYPE_OFFSET);        }        // Do the point height and width for XY and OFFSET render        // types.        if (renderType == OMGraphic.RENDERTYPE_XY) {            Debug.message("eomg", "EditableOMPoint: updating x/y point");            if (movingPoint == gpc) {                point.set(gpc.getX(), gpc.getY());            }        }        if (projection != null) {            regenerate(projection);        }    }    /**     * Get whether a graphic can be manipulated by its edges, rather     * than just by its grab points.     */    public boolean getCanGrabGraphic() {        return false;    }    /**     * Called to set the OffsetGrabPoint to the current mouse     * location, and update the OffsetGrabPoint with all the other     * GrabPoint locations, so everything can shift smoothly. Should     * also set the OffsetGrabPoint to the movingPoint. Should be     * called only once at the beginning of the general movement, in     * order to set the movingPoint. After that, redraw(e) should just     * be called, and the movingPoint will make the adjustments to the     * graphic that are needed.     */    public void move(java.awt.event.MouseEvent e) {}    /**     * Use the current projection to place the graphics on the screen.     * Has to be called to at least assure the graphics that they are     * ready for rendering. Called when the graphic position changes.     *      * @param proj com.bbn.openmap.proj.Projection     * @return true     */    public boolean generate(Projection proj) {        Debug.message("eomgdetail", "EditableOMPoint.generate()");        if (point != null)            point.regenerate(proj);        for (int i = 0; i < gPoints.length; i++) {            GrabPoint gp = gPoints[i];            if (gp != null) {                gp.generate(proj);            }        }        return true;    }    /**     * Given a new projection, the grab points may need to be     * repositioned off the current position of the graphic. Called     * when the projection changes.     */    public void regenerate(Projection proj) {        Debug.message("eomg", "EditableOMPoint.regenerate()");        if (point != null)            point.regenerate(proj);        setGrabPoints(point);        generate(proj);    }    /**     * Draw the EditableOMPoint parts into the java.awt.Graphics     * object. The grab points are only rendered if the point machine     * state is PointSelectedState.POINT_SELECTED.     *      * @param graphics java.awt.Graphics.     */    public void render(java.awt.Graphics graphics) {        Debug.message("eomgdetail", "EditableOMPoint.render()");        State state = getStateMachine().getState();        if (!(state instanceof GraphicUndefinedState)) {            if (point != null) {                point.setVisible(true);                point.render(graphics);                point.setVisible(false);            } else {                Debug.message("eomg", "EditableOMPoint.render: null point.");            }            int renderType = point.getRenderType();            if (state instanceof GraphicSelectedState                    || state instanceof GraphicEditState) {                for (int i = 0; i < gPoints.length; i++) {                    GrabPoint gp = gPoints[i];                    if (gp != null) {                        if ((i == OFFSET_POINT_INDEX                                && renderType == OMGraphic.RENDERTYPE_OFFSET && movingPoint == gpo)                                ||                                (state instanceof GraphicSelectedState && ((i != OFFSET_POINT_INDEX && renderType != OMGraphic.RENDERTYPE_OFFSET) || (renderType == OMGraphic.RENDERTYPE_OFFSET)))                        ) {                            gp.setVisible(true);                            gp.render(graphics);                            gp.setVisible(false);                        }                    }                }            }        }    }    /**     * Modifies the gui to not include line type adjustments, and adds     * widgets to control point settings.     *      * @param graphicAttributes the GraphicAttributes to use to get     *        the GUI widget from to control those parameters for this     *        EOMG.     * @return java.awt.Component to use to control parameters for     *         this EOMG.     */    public Component getGUI(GraphicAttributes graphicAttributes) {        Debug.message("eomg", "EditableOMPoint.getGUI");        if (graphicAttributes != null) {            JPanel panel = graphicAttributes.getColorAndLineGUI();            panel.add(getPointGUI());            return panel;        } else {            return getPointGUI();        }    }    protected JToolBar pToolBar = null;    protected JToolBar getPointGUI() {        if (pToolBar == null) {            pToolBar = new GridBagToolBar();            // Add buttons to toggle oval/rect, radius of point.        }        return pToolBar;    }}