## com.bbn.openmap.omGraphics
Class EditableOMCircle

    java.lang.Object
      com.bbn.openmap.event.MapMouseAdapter
          com.bbn.openmap.omGraphics.EditableOMGraphic
              com.bbn.openmap.omGraphics.EditableOMCircle

All Implemented Interfaces:
  MapMouseListener

Direct Known Subclasses:
  EditableOMRangeRings

public class EditableOMCircle
extends EditableOMGraphic

The EditableOMCircle encompasses an OMCircle, providing methods for modifying or creating it. This class only modifies circles in lat/lon space (RENDERTYPE_LATLON) - and ellipses in screen space (RENDERTYPE_XY or RENDERTYPE_OFFSET). When you grab at the circle, you change the radius of the entire circle. Grabbing the center point moves the circle. If there is an offset point, moving the center point changes the circle's position in relation to the offset point. Moving the offset point moves the circle, keeping the distance to the center point constant.

Field Summary
`static int` `CENTER_POINT_INDEX`
`protected OMCircle` `circle`
`static int` `E_POINT_INDEX`
`protected OffsetGrabPoint` `gpc`
`protected HorizontalGrabPoint` `gpe`
`protected OffsetGrabPoint` `gpm`
`protected VerticalGrabPoint` `gpn`
`protected GrabPoint` `gpne`
`protected GrabPoint` `gpnw`
`protected OffsetGrabPoint` `gpo`
`protected GrabPoint` `gpr`
`protected VerticalGrabPoint` `gps`
`protected GrabPoint` `gpse`
`protected GrabPoint` `gpsw`
`protected HorizontalGrabPoint` `gpw`
`protected int` `lastRenderType`
`static int` `N_POINT_INDEX`
`static int` `NE_POINT_INDEX`
`static int` `NW_POINT_INDEX`
`static int` `OFFSET_POINT_INDEX`
`static int` `RADIUS_POINT_INDEX`
`static int` `S_POINT_INDEX`
`static int` `SE_POINT_INDEX`
`static int` `SW_POINT_INDEX`
`static int` `W_POINT_INDEX`

Fields inherited from class com.bbn.openmap.omGraphics.EditableOMGraphic
`actionMask, canGrabGraphic, DEBUG, DEBUG_DETAIL, gPoints, holder, lastMouseEvent, listeners, mouseModeServiceList, movingPoint, projection, showGUI, stateMachine`

Constructor Summary
`EditableOMCircle()` Create the EditableOMCircle, setting the state machine to create the circle off of the gestures.
`EditableOMCircle(GraphicAttributes ga)` Create an EditableOMCircle with the circleType and renderType parameters in the GraphicAttributes object.
`EditableOMCircle(OMCircle omc)` Create the EditableOMCircle with an OMCircle already defined, ready for editing.

Method Summary
`void` `assertGrabPoints()` Check to make sure the grab points are not null.
`void` `attachToMovingGrabPoint(OffsetGrabPoint gp)` Attach to the Moving OffsetGrabPoint so if it moves, it will move this EditableOMGraphic with it.
`protected void` `clearGrabPoints()`
`void` `createGraphic(GraphicAttributes ga)` Create and set the graphic within the state machine.
`void` `detachFromMovingGrabPoint(OffsetGrabPoint gp)` Detach from a Moving OffsetGrabPoint.
`boolean` `generate(Projection proj)` Use the current projection to place the graphics on the screen.
`boolean` `getCanGrabGraphic()` Get whether a graphic can be manipulated by its edges, rather than just by its grab points.
`OMGraphic` `getGraphic()` Get the OMGraphic being created/modified by the EditableOMCircle.
`java.awt.Component` `getGUI(GraphicAttributes graphicAttributes)` If this EditableOMGraphic has parameters that can be manipulated that are independent of other EditableOMGraphic types, then you can provide the widgets to control those parameters here.
`GrabPoint` `getMovingPoint(java.awt.event.MouseEvent e)` Given a MouseEvent, find a GrabPoint that it is touching, and set the moving point to that GrabPoint.
`void` `init()` Create and initialize the state machine that interprets the modifying gestures/commands, as well as ititialize the grab points.
`void` `move(java.awt.event.MouseEvent e)` 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.
`void` `regenerate(Projection proj)` Given a new projection, the grab points may need to be repositioned off the current position of the graphic.
`void` `render(java.awt.Graphics graphics)` Draw the EditableOMCircle parts into the java.awt.Graphics object.
`void` `setGrabPoints()` Take the current location of the GrabPoints, and modify the location parameters of the OMCircle with them.
`void` `setGrabPoints(OMGraphic graphic)` Set the grab points for the graphic provided, setting them on the extents of the graphic.
`void` `setGraphic(OMGraphic graphic)` Set the graphic within the state machine.
`void` `setMovingPoint(GrabPoint gp)` Set the GrabPoint that is in the middle of being modified, as a result of a mouseDragged event, or other selection process.
`protected void` `setRadius(float radius)` To be overloaded if needed when setting circle's radius.

Methods inherited from class com.bbn.openmap.omGraphics.EditableOMGraphic

`_getMovingPoint, addEOMGListener, cleanMap, finalize, fireEvent, fireEvent, fireEvent, fireEvent, getActionMask, getGrabPoint, getGrabPoints, getGUI, getMouseModeServiceList, getMovingPoint, getProjection, getShowGUI, getStateMachine, handleInitialMouseEvent, modifyOMGraphicForEditRender, mouseClicked, mouseDragged, mouseEntered, mouseExited, mouseMoved, mouseMoved, mousePressed, mouseReleased, redraw, redraw, redraw, removeEOMGListener, repaint, repaintRender, reset, resetOMGraphicAfterEditRender, setActionMask, setCanGrabGraphic, setGrabPoint, setGrabPoints, setMouseModeServiceList, setProjection, setShowGUI, setStateMachine`

Methods inherited from class java.lang.Object
`clone, equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Field Detail

### gpn

    protected VerticalGrabPoint gpn

### gpw

    protected HorizontalGrabPoint gpw

### gps

    protected VerticalGrabPoint gps

### gpe

    protected HorizontalGrabPoint gpe

### gpnw

    protected GrabPoint gpnw

### gpne

    protected GrabPoint gpne

### gpsw

    protected GrabPoint gpsw

### gpse

    protected GrabPoint gpse

### gpc

    protected OffsetGrabPoint gpc

### gpr

    protected GrabPoint gpr

### gpo

    protected OffsetGrabPoint gpo

### gpm

    protected OffsetGrabPoint gpm

### circle

    protected OMCircle circle

### CENTER_POINT_INDEX

    public static final int CENTER_POINT_INDEX

See Also:
  Constant Field Values

### NW_POINT_INDEX

    public static final int NW_POINT_INDEX

See Also:
  Constant Field Values

### N_POINT_INDEX

    public static final int N_POINT_INDEX

See Also:
  Constant Field Values

### NE_POINT_INDEX

    public static final int NE_POINT_INDEX

See Also:
  Constant Field Values

### W_POINT_INDEX

    public static final int W_POINT_INDEX

See Also:
  Constant Field Values

### E_POINT_INDEX

    public static final int E_POINT_INDEX

See Also:
  Constant Field Values

### SW_POINT_INDEX

    public static final int SW_POINT_INDEX

See Also:
  Constant Field Values

### S_POINT_INDEX

    public static final int S_POINT_INDEX

See Also:
  Constant Field Values

### SE_POINT_INDEX

    public static final int SE_POINT_INDEX

See Also:
  Constant Field Values

### RADIUS_POINT_INDEX

    public static final int RADIUS_POINT_INDEX

See Also:
  Constant Field Values

### OFFSET_POINT_INDEX

    public static final int OFFSET_POINT_INDEX

See Also:
  Constant Field Values

### lastRenderType

    protected int lastRenderType

Constructor Detail

### EditableOMCircle

    public EditableOMCircle()

  Create the EditableOMCircle, setting the state machine to create the circle off of the gestures.

### EditableOMCircle

    public EditableOMCircle(GraphicAttributes ga)

  Create an EditableOMCircle with the circleType and renderType parameters in the GraphicAttributes object.

### EditableOMCircle

    public EditableOMCircle(OMCircle omc)

  Create the EditableOMCircle with an OMCircle already defined, ready for editing.

Parameters:
  `omc` - OMCircle that should be edited.

Method Detail

### init

    public void init()

  Create and initialize the state machine that interprets the modifying gestures/commands, as well as ititialize the grab points. Also allocates the grab point array needed by the EditableOMCircle.

### setGraphic

    public void setGraphic(OMGraphic graphic)

  Set the graphic within the state machine. If the graphic is null, then one shall be created, and located off screen until the gestures driving the state machine place it on the map.

  Specified by:
    `setGraphic` in class `EditableOMGraphic`
  Parameters:
    `graphic` - OMGraphic.

### createGraphic

    public void createGraphic(GraphicAttributes ga)

  Create and set the graphic within the state machine. The GraphicAttributes describe the type of circle to create.

  Specified by:
    `createGraphic` in class `EditableOMGraphic`
  Parameters:
    `ga` - GraphicAttributes, describing the graphic to be created.

### getCanGrabGraphic

    public boolean getCanGrabGraphic()

  Get whether a graphic can be manipulated by its edges, rather than just by its grab points.

  Overrides:
    `getCanGrabGraphic` in class `EditableOMGraphic`

### getGraphic

    public OMGraphic getGraphic()

  Get the OMGraphic being created/modified by the EditableOMCircle.

  Specified by:
    `getGraphic` in class `EditableOMGraphic`

### attachToMovingGrabPoint

    public void attachToMovingGrabPoint(OffsetGrabPoint gp)

  Attach to the Moving OffsetGrabPoint so if it moves, it will move this EditableOMGraphic with it. EditableOMGraphic version doesn't do anything, each subclass has to decide which of its OffsetGrabPoints should be attached to it.

  Overrides:
    `attachToMovingGrabPoint` in class `EditableOMGraphic`

### detachFromMovingGrabPoint

    public void detachFromMovingGrabPoint(OffsetGrabPoint gp)

  Detach from a Moving OffsetGrabPoint. The EditableOMGraphic version doesn't do anything, each subclass should remove whatever GrabPoint it would have attached to an OffsetGrabPoint.

  Overrides:
    `detachFromMovingGrabPoint` in class `EditableOMGraphic`

### setMovingPoint

    public void setMovingPoint(GrabPoint gp)

  Set the GrabPoint that is in the middle of being modified, as a result of a mouseDragged event, or other selection process.

  Overrides:
    `setMovingPoint` in class `EditableOMGraphic`

### getMovingPoint

    public GrabPoint getMovingPoint(java.awt.event.MouseEvent e)

  Given a MouseEvent, find a GrabPoint that it is touching, and set the moving point to that GrabPoint.

  Overrides:
    `getMovingPoint` in class `EditableOMGraphic`
  Parameters:
    `e` - MouseEvent
  Returns:
    GrabPoint that is touched by the MouseEvent, null if none are.

### assertGrabPoints

    public void assertGrabPoints()

  Check to make sure the grab points are not null. If they are, allocate them, and them assign them to the array.

### clearGrabPoints

    protected void clearGrabPoints()

### setGrabPoints

    public void setGrabPoints(OMGraphic graphic)

  Set the grab points for the graphic provided, setting them on the extents of the graphic. Called when you want to set the grab points off the location of the graphic.

### setGrabPoints

    public void setGrabPoints()

  Take the current location of the GrabPoints, and modify the location parameters of the OMCircle with them. Called when you want the graphic to change according to the grab points.

  Specified by:
    `setGrabPoints` in class `EditableOMGraphic`

### setRadius

    protected void setRadius(float radius)

  To be overloaded if needed when setting circle's radius.

  Parameters:
    `radius` - in DECIMAL_DEGREES

### move

    public void move(java.awt.event.MouseEvent e)

  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.

  Specified by:
    `move` in class `EditableOMGraphic`

### generate

    public boolean generate(Projection proj)

  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.

  Specified by:
    `generate` in class `EditableOMGraphic`
  Parameters:
    `proj` - com.bbn.openmap.proj.Projection
  Returns:
    true

### regenerate

    public void regenerate(Projection proj)

  Given a new projection, the grab points may need to be repositioned off the current position of the graphic. Called when the projection changes.

  Specified by:
    `regenerate` in class `EditableOMGraphic`

### render

    public void render(java.awt.Graphics graphics)

  Draw the EditableOMCircle parts into the java.awt.Graphics object. The grab points are only rendered if the circle machine state is CircleSelectedState.CIRCLE_SELECTED.

  Specified by:
    `render` in class `EditableOMGraphic`
  Parameters:
    `graphics` - java.awt.Graphics.

### getGUI

    public java.awt.Component getGUI(GraphicAttributes graphicAttributes)

  If this EditableOMGraphic has parameters that can be manipulated that are independent of other EditableOMGraphic types, then you can provide the widgets to control those parameters here. By default, returns the GraphicAttributes GUI widgets. If you don't want a GUI to appear when a widget is being created/edited, then don't call this method from the EditableOMGraphic implementation, and return a null Component from getGUI.

  Overrides:
    `getGUI` in class `EditableOMGraphic`
  Parameters:
    `graphicAttributes` - the GraphicAttributes to use to get the GUI widget from to control those parameters for this EOMG.
  Returns:
    java.awt.Component to use to control parameters for this EOMG.

Copyright (C) BBNT Solutions LLC; See http://openmap.bbn.com/ for details