if (renderType == OMGraphic.RENDERTYPE_LATLON) {                        doStraight = false;                        top = (int) p.getY();                        left = (int) p.getX();                        gpnw.set((int) p.getX(), (int) p.getY());                        p = projection.forward(slat, elon);                        gpse.set((int) p.getX(), (int) p.getY());                        p = projection.forward(nlat, elon);                        gpne.set((int) p.getX(), (int) p.getY());                        p = projection.forward(slat, wlon);                        gpsw.set((int) p.getX(), (int) p.getY());                        p = projection.forward(nlat - (nlat - slat) / 2f, wlon                                + (elon - wlon) / 2f);                        gpc.set((int) p.getX(), (int) p.getY());                    } else {                        latoffset = (int) p.getY();                        lonoffset = (int) p.getX();                        gpo.set(lonoffset, latoffset);                    }                }            }            if (doStraight) {                Debug.message("eomg",                        "EditableOMRect: drawing straight line rectangle");                top = rect.getTop() + latoffset;                bottom = rect.getBottom() + latoffset;                right = rect.getRight() + lonoffset;                left = rect.getLeft() + lonoffset;                // We have to do some fancy point wrangling to keep                // from messing up the next setGrabPoints().                if (movingPoint == gpc || movingPoint == gpo                        || movingPoint == null) {                    gpne.set(right, top);                    gpnw.set(left, top);                    gpse.set(right, bottom);                    gpsw.set(left, bottom);                } else if (movingPoint == gpnw) {                    gpne.set(gpse.getX(), gpnw.getY());                    gpsw.set(gpnw.getX(), gpse.getY());                } else if (movingPoint == gpse) {                    gpne.set(gpse.getX(), gpnw.getY());                    gpsw.set(gpnw.getX(), gpse.getY());                } else if (movingPoint == gpsw) {                    gpnw.set(gpsw.getX(), gpne.getY());                    gpse.set(gpne.getX(), gpsw.getY());                } else if (movingPoint == gpne) {                    gpnw.set(gpsw.getX(), gpne.getY());                    gpse.set(gpne.getX(), gpsw.getY());                }                int middlex = (right - left) / 2;                int middley = (bottom - top) / 2;                gpc.set(left + middlex, top + middley);                gpc.updateOffsets();                //              Debug.output("Center setting x: " + gpc.getX() + ",                // y:" + gpc.getY());            }            if (renderType == OMGraphic.RENDERTYPE_OFFSET) {                gpo.updateOffsets();            }        } else {            Debug.message("eomg",                    "EditableOMRect.setGrabPoints: graphic needs to be regenerated");        }    }    /**     * Take the current location of the GrabPoints, and modify the     * location parameters of the OMRect with them. Called when you     * want the graphic to change according to the grab points.     */    public void setGrabPoints() {        int renderType = rect.getRenderType();        LatLonPoint llp1;        Debug.message("eomg", "EditableOMRect.setGrabPoints()");        // Do center point for lat/lon or offset rects        if (renderType == OMGraphic.RENDERTYPE_LATLON) {            if (projection != null) {                // Need to figure out which point was moved, and then                // set the upper left and lower right points                // accordingly.                if (movingPoint == gpne) {                    llp1 = projection.inverse(gpne.getX(), gpne.getY());                    rect.lat1 = llp1.getLatitude();                    rect.lon2 = llp1.getLongitude();                } else if (movingPoint == gpnw) {                    llp1 = projection.inverse(gpnw.getX(), gpnw.getY());                    rect.lat1 = llp1.getLatitude();                    rect.lon1 = llp1.getLongitude();                } else if (movingPoint == gpsw) {                    llp1 = projection.inverse(gpsw.getX(), gpsw.getY());                    rect.lat2 = llp1.getLatitude();                    rect.lon1 = llp1.getLongitude();                } else if (movingPoint == gpse) {                    llp1 = projection.inverse(gpse.getX(), gpse.getY());                    LatLonPoint llp2 = projection.inverse(gpnw.getX(),                            gpnw.getY());                    rect.lat1 = llp2.getLatitude();                    rect.lon1 = llp2.getLongitude();                    rect.lat2 = llp1.getLatitude();                    rect.lon2 = llp1.getLongitude();                } else {                    //movingPoint == gpc                    llp1 = projection.inverse(gpc.getX(), gpc.getY());                    rect.lat1 = llp1.getLatitude() + diffy;                    rect.lon1 = llp1.getLongitude() - diffx;                    rect.lat2 = llp1.getLatitude() - diffy;                    rect.lon2 = llp1.getLongitude() + diffx;                }                rect.setNeedToRegenerate(true);            }        }        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());            rect.lat1 = llp1.getLatitude();            rect.lon1 = llp1.getLongitude();            if (settingOffset || movingPoint == gpc) {                int halfheight = (gpse.getY() - gpnw.getY()) / 2;                int halfwidth = (gpse.getX() - gpnw.getX()) / 2;                // Don't call rect.setLocation because we only want to                // setNeedToRegenerate if !settingOffset.                rect.x1 = gpc.getX() - halfwidth - gpo.getX();                rect.y1 = gpc.getY() - halfheight - gpo.getY();                rect.x2 = gpc.getX() + halfwidth - gpo.getX();                rect.y2 = gpc.getY() + halfheight - gpo.getY();            }            if (!settingOffset) {                Debug.message("eomg", "EditableOMRect: updating offset rect");                if (movingPoint == gpnw || movingPoint == gpse) {                    rect.setLocation(gpnw.getX() - gpo.getX(), gpnw.getY()                            - gpo.getY(), gpse.getX() - gpo.getX(), gpse.getY()                            - gpo.getY());                } else if (movingPoint == gpne || movingPoint == gpsw) {                    rect.setLocation(rect.x1 = gpsw.getX() - gpo.getX(),                            gpne.getY() - gpo.getY(),                            gpne.getX() - gpo.getX(),                            gpsw.getY() - gpo.getY());                }                rect.setNeedToRegenerate(true);            }            // Set Location has reset the rendertype, but provides            // the convenience of setting the max and min values            // for us.            rect.setRenderType(OMGraphic.RENDERTYPE_OFFSET);        }        // Do the rect height and width for XY and OFFSET render        // types.        if (renderType == OMGraphic.RENDERTYPE_XY) {            Debug.message("eomg", "EditableOMRect: updating x/y rect");            if (movingPoint == gpc) {                int halfheight = (gpse.getY() - gpnw.getY()) / 2;                int halfwidth = (gpse.getX() - gpnw.getX()) / 2;                rect.setLocation(gpc.getX() - halfwidth, gpc.getY()                        - halfheight, gpc.getX() + halfwidth, gpc.getY()                        + halfheight);            } else if (movingPoint == gpnw || movingPoint == gpse) {                rect.setLocation(gpnw.getX(),                        gpnw.getY(),                        gpse.getX(),                        gpse.getY());            } else if (movingPoint == gpne || movingPoint == gpsw) {                rect.setLocation(gpsw.getX(),                        gpne.getY(),                        gpne.getX(),                        gpsw.getY());            }        }        if (projection != null) {            regenerate(projection);        }    }    /**     * 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", "EditableOMRect.generate()");        if (rect != null)            rect.generate(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", "EditableOMRect.regenerate()");        if (rect != null)            rect.regenerate(proj);        setGrabPoints(rect);        generate(proj);    }    /**     * Draw the EditableOMRect parts into the java.awt.Graphics     * object. The grab points are only rendered if the rect machine     * state is RectSelectedState.RECT_SELECTED.     *      * @param graphics java.awt.Graphics.     */    public void render(java.awt.Graphics graphics) {        Debug.message("eomgdetail", "EditableOMRect.render()");        State state = getStateMachine().getState();        if (rect != null) {            rect.setVisible(true);            rect.render(graphics);            rect.setVisible(false);        } else {            Debug.message("eomg", "EditableOMRect.render: null rect.");        }        int renderType = rect.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);                    }                }            }        }    }}