MapControl

java.lang.Object
- java.awt.Component
- - java.awt.Container
  - - javax.swing.JComponent
    - - org.gvsig.fmap.mapcontrol.MapControl

All Implemented Interfaces:

ComponentListener, ImageObserver, MenuContainer, Serializable, EventListener, Disposable, Observer

Direct Known Subclasses:

MapOverview
```
public class MapControl
extends JComponent
implements ComponentListener, Observer, Disposable
```
A component that includes a MapContext with support for use it as a particular Behavior.

A developer can register a set of Behavior, but only one (that can be a composition of several) of them can be active. The active one defines the way to work and access with its MapContext's layers. The active behavior, in combination with the appropriate ToolListener will allow user work with a particular tool.

All mouse events produced on this component will be delegated to the current active behavior, the currentMapTool.

Drawing process:

Uses a double buffer for the drawing process of MapContext's information.

If the double buffer wasn't created, creates a new one.

Paints the component according the following algorithm:
If status is UPDATED:
If there is a double buffer:
If there is a behavior for managing the MapControl instance, delegates the drawing process to that behavior, calling: behavior_instance.paintComponent(g).
Else, repaints the current graphical information quickly calling: g.drawImage(image,0,0,null).
Else, (status is OUTDATED, or ONLY_GRAPHICS): executes a quickly repaint of the previous information calling g.drawImage(image,0,0,null), and creates a painting request to delegate the heavy drawing process to the Drawer2's worker thread, according the SingleWorketThread pattern, starting a timer to update (invoking repaint()) the view every delay of 1000 / drawFrameRate ms. during that heavy drawing process, and if its enabled drawAnimationEnabled. The painting request once is being attended, invokes MapContext to draw the layers: mapContext.draw(image, g, cancel,mapContext.getScaleView());

Some notes:
- The painting process can be cancelled calling #cancelDrawing().
- At last resort, the particular implementation of each layer in a MapControl's MapContrext will be that one which will draw the graphical information, and, if supports, which could cancel its drawing subprocess.
- It's possible to force repaint all layers, calling #drawMap(boolean).
- It's possible repaint only the dirty layers, calling #rePaintDirtyLayers().
- It's possible repaint only the GraphicLayer, calling #drawGraphics().
Tools:

A developer can:
- Register each tool as:
  - A single behavior: #addMapTool(String, Behavior).
  - Or, a compound behavior: #addMapTool(String, Behavior).
- Get the current active tool: #getCurrentMapTool().
- Get the current active tool name: #getCurrentTool().
- Get a registered tool: #getMapTool(String).
- Get the name of all tools registered: #getMapToolsKeySet().
- Get all tools registered, including the name they were registered: #getNamesMapTools().
- Determine if has a tool registered: #hasTool(String).
- Set as an active tool, one of the registered: #setTool(String).
- Set as active tool, the previous used: #setPrevTool().
- Set the current tool: #setCurrentMapTool(Behavior).
- Change the draw frame rate: #setDrawFrameRate(int) and #applyFrameRate().
- Get the draw frame rate: #getDrawFrameRate().
- Determine if will repaint this component each time timer finishes: #isDrawAnimationEnabled().
- Change if will repaint this component each time timer finishes: #setDrawAnimationEnabled(boolean).
- Get the shared object that determines if a drawing process must be cancelled or can continue: #getCanceldraw().
- Get the combined tool: #getCombinedTool().
- Set a combined tool: #setCombinedTool(Behavior).
- Remove the combined tool: #removeCombinedTool().
Exception listener:

Adding an ExceptionListener, can get notification about any exception produced:
- Attending a painting request.
- Working with the active tool.
- Applying a zoom in or zoom out operation.
Other:

Other useful capabilities of MapControl:
- Cancel the current drawing process (notifying it also to the inner MapContext instance and its layers): #cancelDrawing().
- Applying a zoom in operation centered at mouse position (without a ToolListener): #zoomIn().
- Applying a zoom out operation centered at mouse position (without a ToolListener): #zoomOut().
See Also:
MapControl.CancelDraw, MapControl.Drawer, MapControl.MapContextListener, MapControl.MapToolListener, Serialized Form

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`class`	`MapControl.CancelDraw` An instance of `CancelDraw` will be shared by all this `MapControl`'s `MapContext` layers, allowing receive a notification that, when they're been drawn, to be cancelled.
`class`	`MapControl.Drawer` An instance of `Drawer2` could manage all `MapControl` painting requests.
`class`	`MapControl.MapContextListener` MapContextListener listens all events produced in a `MapControl`'s `MapContext` object during an atomic period of time, and sets it to dirty, executing `drawMap(false)`, if any of the following conditions is accomplished: Any of the `LayerEvent` in the `AtomicEvent` parameter notifies a visibility change.
`class`	`MapControl.MapToolListener` Listens all kind of mouse events produced in `MapControl`, and invokes its current map tool ( `MapControl#getCurrentMapTool()` to simulate a behavior.

Nested classes/interfaces inherited from class javax.swing.JComponent
JComponent.AccessibleJComponent

Nested classes/interfaces inherited from class java.awt.Container
Container.AccessibleAWTContainer

Nested classes/interfaces inherited from class java.awt.Component
Component.AccessibleAWTComponent, Component.BaselineResizeBehavior, Component.BltBufferStrategy, Component.FlipBufferStrategy

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`ACTUALIZADO` One of the possible status of `MapControl`.
`protected Point2D`	`adjustedPoint` Represents the cursor's point selected in screen coordinates.
`protected Behavior`	`currentMapTool` Active `Behavior` that will generate events according a criterion, and then, with a `ToolListener` associated, will simulate to user that works with this component as a particular tool.
`protected String`	`currentTool` Name of the tool used currently to interact with this component.
`static int`	`DESACTUALIZADO` One of the possible status of `MapControl`.
`protected static GeometryManager`	`geomManager`
`protected Point2D`	`mapAdjustedPoint` Represents the cursor's point selected in map coordinates.
`protected static MapControlManager`	`mapControlManager`
`protected MapControl.MapToolListener`	`mapToolListener` Listener of all kind of mouse events produced in this component.
`protected Map<String,Behavior>`	`namesMapTools` All registered `Behavior` that can define a way to work with this `MapControl`.
`protected String`	`prevTool` Name of the previous tool used.
`protected ViewPort`	`vp` Reference to the `ViewPort` of the `MapContext` of this component.

Fields inherited from class javax.swing.JComponent
accessibleContext, listenerList, TOOL_TIP_TEXT_KEY, ui, UNDEFINED_CONDITION, WHEN_ANCESTOR_OF_FOCUSED_COMPONENT, WHEN_FOCUSED, WHEN_IN_FOCUSED_WINDOW

Fields inherited from class java.awt.Component
BOTTOM_ALIGNMENT, CENTER_ALIGNMENT, LEFT_ALIGNMENT, RIGHT_ALIGNMENT, TOP_ALIGNMENT

Fields inherited from interface java.awt.image.ImageObserver
ABORT, ALLBITS, ERROR, FRAMEBITS, HEIGHT, PROPERTIES, SOMEBITS, WIDTH

Constructor Summary

Constructors
Constructor and Description

MapControl()
Creates a new MapControl instance with the following characteristics: Name: MapControl .

MapControl(MapContext theMapContext)

Constructors
Constructor and Description
`MapControl()` Creates a new `MapControl` instance with the following characteristics: Name: MapControl .
`MapControl(MapContext theMapContext)`

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`addBehavior(String name, Behavior tool)` Registers a new behavior to this component.
`void`	`addBehavior(String name, Behavior[] tools)` Registers a new behavior to this component as a `CompoundBehavior` made up of `tools`.
`void`	`addCombinedBehavior(Behavior tool)` Adds a new tool as combined tool.
`void`	`addExceptionListener(ExceptionListener o)`
`void`	`applyFrameRate()` Sets the delay to the timer that refreshes this `MapControl` instance.
`void`	`calculateSnapPoint(Point point)` Tries to find the nearest geometry or grid control point by the position of the current snap tool.
`void`	`cancelDrawing()` Determines that current drawing process of `MapControl`'s `MapContext`'s data must be canceled.
`void`	`commandRefresh()`
`void`	`commandRepaint()`
`void`	`componentHidden(ComponentEvent e)`
`void`	`componentMoved(ComponentEvent e)`
`void`	`componentResized(ComponentEvent e)`
`void`	`componentShown(ComponentEvent e)`
`void`	`dispose()` Disposes the current object, to allow it to close and dispose any used resources.
`void`	`drawGraphics()` Deprecated. use `drawMap(boolean)` instead, or even better `getMapContext()`.invalidate().
`void`	`drawMap(boolean doClear)` Forces repaint all visible graphical information in this component.
`Point2D`	`getAdjustedPoint()`
`MapControl.CancelDraw`	`getCanceldraw()` Gets the shared object that determines if a drawing process must be cancelled or can continue.
`Behavior`	`getCombinedTool()` Gets the tool used in combination with the current tool of this `MapControl`.
`Behavior`	`getCurrentMapTool()` Gets as current active `Behavior` associated to this component, that one which is registered and identified by `toolName`.
`String`	`getCurrentTool()` Returns the name of the current selected tool on this MapControl
`Grid`	`getGrid()`
`BufferedImage`	`getImage()` Gets the `BufferedImage` used to accelerate the draw of new ''frames'' with changes, or new graphical items in this component.
`Point2D`	`getMapAdjustedPoint()`
`MapContext`	`getMapContext()` Gets this component's `MapContext`, with the model, and most of the view, and control logic of the layers of this component, including a `ViewPort` to adapt the information to the projection, and display it in the available area.
`MapControlDrawer`	`getMapControlDrawer()`
`Behavior`	`getMapTool(String name)` Gets the `Behavior` registered in this component, identified by `name`.
`MapControl.MapToolListener`	`getMapToolListener()` Returns the listener used to catch all mouse events produced in this `MapControl` instance and that redirects the calls to the current map tool.
`Set`	`getMapToolsKeySet()` Returns a set view of the keys that identified the tools registered.
`HashMap`	`getNamesMapTools()` Returns all registered `Behavior` that can define a way to work with this `MapControl`.
`Point2D`	`getPoint()` Gets the selected point.
`IProjection`	`getProjection()` Gets this component's `MapContext` projection.
`ViewPort`	`getViewPort()` Gets the `ViewPort` of this component's `MapContext` .
`boolean`	`hasTool(String toolName)` Returns `true` if this component contains a tool identified by `toolName`.
`void`	`initializeGrid()` Updates the grid on the `ViewPort` of the associated `MapControl` object according the values in the `com.iver.cit.gvsig.gui.cad.CADToolAdapter.prefs.Preferences`.
`static boolean`	`isDrawAnimationEnabled()` Determines if its enabled the repaint that invokes the timer according to `#getDrawFrameRate()`.
`boolean`	`isRefentEnabled()` Determines if snap tools are enabled or disabled.
`protected void`	`paintComponent(Graphics g)` Paints the graphical information of this component using a double buffer.
`void`	`removeCombinedTool(Behavior tool)` Removes the tool `tool` used in combination with the current tool of this `MapControl`.
`boolean`	`removeExceptionListener(ExceptionListener o)`
`void`	`rePaintDirtyLayers()` Cancels any current drawing process, changing the status to `OUTDATED`, and forcing repaint only the layers dirty.
`void`	`setAdjustGrid(boolean adjustGrid)`
`void`	`setCombinedTool(Behavior combinedTool)` Sets a tool to be used in combination with the current tool of this `MapControl`.
`void`	`setCurrentMapTool(Behavior mapTool)` Sets `mapTool` as this `MapControl`'s current map tool.
`static void`	`setDrawAnimationEnabled(boolean drawAnimationEnabled)` Sets if its enabled the repaint that invokes the timer according to `#getDrawFrameRate()`.
`void`	`setGridVisibility(boolean showGrid)`
`void`	`setMapContext(MapContext model)` Sets a `MapContext` to this component.
`void`	`setMapControlDrawer(MapControlDrawer mapControlDrawer)`
`void`	`setPrevTool()` Equivalent operation to undo.
`void`	`setProjection(IProjection proj)` Sets the projection to this component's `MapContext`.
`void`	`setRefentEnabled(boolean activated)` Sets the snap tools enabled or disabled.
`void`	`setTool(String toolName)` Sets as current active `Behavior` associated to this component, that one which is registered and identified by `toolName`.
`protected void`	`throwException(Throwable t)`
`void`	`update(Observable observable, Object notification)` Called whenever a `Observable` object is changed and this `Observer` has registered on it to receive notifications.
`void`	`zoomIn()` Executes a zoom in operation centered at the center of the extent.
`void`	`zoomOut()` Executes a zoom out operation centered at the center of the extent.

Methods inherited from class javax.swing.JComponent
addAncestorListener, addNotify, addVetoableChangeListener, computeVisibleRect, contains, createToolTip, disable, enable, firePropertyChange, firePropertyChange, firePropertyChange, fireVetoableChange, getAccessibleContext, getActionForKeyStroke, getActionMap, getAlignmentX, getAlignmentY, getAncestorListeners, getAutoscrolls, getBaseline, getBaselineResizeBehavior, getBorder, getBounds, getClientProperty, getComponentGraphics, getComponentPopupMenu, getConditionForKeyStroke, getDebugGraphicsOptions, getDefaultLocale, getFontMetrics, getGraphics, getHeight, getInheritsPopupMenu, getInputMap, getInputMap, getInputVerifier, getInsets, getInsets, getListeners, getLocation, getMaximumSize, getMinimumSize, getNextFocusableComponent, getPopupLocation, getPreferredSize, getRegisteredKeyStrokes, getRootPane, getSize, getToolTipLocation, getToolTipText, getToolTipText, getTopLevelAncestor, getTransferHandler, getUIClassID, getVerifyInputWhenFocusTarget, getVetoableChangeListeners, getVisibleRect, getWidth, getX, getY, grabFocus, hide, isDoubleBuffered, isLightweightComponent, isManagingFocus, isOpaque, isOptimizedDrawingEnabled, isPaintingForPrint, isPaintingOrigin, isPaintingTile, isRequestFocusEnabled, isValidateRoot, paint, paintBorder, paintChildren, paintImmediately, paintImmediately, paramString, print, printAll, printBorder, printChildren, printComponent, processComponentKeyEvent, processKeyBinding, processKeyEvent, processMouseEvent, processMouseMotionEvent, putClientProperty, registerKeyboardAction, registerKeyboardAction, removeAncestorListener, removeNotify, removeVetoableChangeListener, repaint, repaint, requestDefaultFocus, requestFocus, requestFocus, requestFocusInWindow, requestFocusInWindow, resetKeyboardActions, reshape, revalidate, scrollRectToVisible, setActionMap, setAlignmentX, setAlignmentY, setAutoscrolls, setBackground, setBorder, setComponentPopupMenu, setDebugGraphicsOptions, setDefaultLocale, setDoubleBuffered, setEnabled, setFocusTraversalKeys, setFont, setForeground, setInheritsPopupMenu, setInputMap, setInputVerifier, setMaximumSize, setMinimumSize, setNextFocusableComponent, setOpaque, setPreferredSize, setRequestFocusEnabled, setToolTipText, setTransferHandler, setUI, setVerifyInputWhenFocusTarget, setVisible, unregisterKeyboardAction, update, updateUI

Methods inherited from class java.awt.Container
add, add, add, add, add, addContainerListener, addImpl, addPropertyChangeListener, addPropertyChangeListener, applyComponentOrientation, areFocusTraversalKeysSet, countComponents, deliverEvent, doLayout, findComponentAt, findComponentAt, getComponent, getComponentAt, getComponentAt, getComponentCount, getComponents, getComponentZOrder, getContainerListeners, getFocusTraversalKeys, getFocusTraversalPolicy, getLayout, getMousePosition, insets, invalidate, isAncestorOf, isFocusCycleRoot, isFocusCycleRoot, isFocusTraversalPolicyProvider, isFocusTraversalPolicySet, layout, list, list, locate, minimumSize, paintComponents, preferredSize, printComponents, processContainerEvent, processEvent, remove, remove, removeAll, removeContainerListener, setComponentZOrder, setFocusCycleRoot, setFocusTraversalPolicy, setFocusTraversalPolicyProvider, setLayout, transferFocusDownCycle, validate, validateTree

Methods inherited from class java.awt.Component
action, add, addComponentListener, addFocusListener, addHierarchyBoundsListener, addHierarchyListener, addInputMethodListener, addKeyListener, addMouseListener, addMouseMotionListener, addMouseWheelListener, bounds, checkImage, checkImage, coalesceEvents, contains, createImage, createImage, createVolatileImage, createVolatileImage, disableEvents, dispatchEvent, enable, enableEvents, enableInputMethods, firePropertyChange, firePropertyChange, firePropertyChange, firePropertyChange, firePropertyChange, firePropertyChange, getBackground, getBounds, getColorModel, getComponentListeners, getComponentOrientation, getCursor, getDropTarget, getFocusCycleRootAncestor, getFocusListeners, getFocusTraversalKeysEnabled, getFont, getForeground, getGraphicsConfiguration, getHierarchyBoundsListeners, getHierarchyListeners, getIgnoreRepaint, getInputContext, getInputMethodListeners, getInputMethodRequests, getKeyListeners, getLocale, getLocation, getLocationOnScreen, getMouseListeners, getMouseMotionListeners, getMousePosition, getMouseWheelListeners, getName, getParent, getPeer, getPropertyChangeListeners, getPropertyChangeListeners, getSize, getToolkit, getTreeLock, gotFocus, handleEvent, hasFocus, imageUpdate, inside, isBackgroundSet, isCursorSet, isDisplayable, isEnabled, isFocusable, isFocusOwner, isFocusTraversable, isFontSet, isForegroundSet, isLightweight, isMaximumSizeSet, isMinimumSizeSet, isPreferredSizeSet, isShowing, isValid, isVisible, keyDown, keyUp, list, list, list, location, lostFocus, mouseDown, mouseDrag, mouseEnter, mouseExit, mouseMove, mouseUp, move, nextFocus, paintAll, postEvent, prepareImage, prepareImage, processComponentEvent, processFocusEvent, processHierarchyBoundsEvent, processHierarchyEvent, processInputMethodEvent, processMouseWheelEvent, remove, removeComponentListener, removeFocusListener, removeHierarchyBoundsListener, removeHierarchyListener, removeInputMethodListener, removeKeyListener, removeMouseListener, removeMouseMotionListener, removeMouseWheelListener, removePropertyChangeListener, removePropertyChangeListener, repaint, repaint, repaint, resize, resize, setBounds, setBounds, setComponentOrientation, setCursor, setDropTarget, setFocusable, setFocusTraversalKeysEnabled, setIgnoreRepaint, setLocale, setLocation, setLocation, setName, setSize, setSize, show, show, size, toString, transferFocus, transferFocusBackward, transferFocusUpCycle

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

- Field Detail
  - geomManager
```
protected static final GeometryManager geomManager
```
  - ACTUALIZADO
```
public static final int ACTUALIZADO
```
    One of the possible status of MapControl. Determines that all visible information has been drawn and its updated.
    
    See Also:
    Constant Field Values
  - DESACTUALIZADO
```
public static final int DESACTUALIZADO
```
    One of the possible status of MapControl. Determines that not all visible information has been drawn or isn't updated.
    
    See Also:
    Constant Field Values
  - namesMapTools
```
protected Map<String,Behavior> namesMapTools
```
    All registered Behavior that can define a way to work with this MapControl.
    
    Only one of them can be active at a given moment.
    
    See Also:
    addBehavior(String, Behavior), addBehavior(String, Behavior[]), getMapTool(String), getMapToolsKeySet(), getNamesMapTools()
  - currentMapTool
```
protected Behavior currentMapTool
```
    Active Behavior that will generate events according a criterion, and then, with a ToolListener associated, will simulate to user that works with this component as a particular tool.
    
    See Also:
    getCurrentMapTool(), getCurrentTool(), setTool(String)
  - currentTool
```
protected String currentTool
```
    Name of the tool used currently to interact with this component.
    
    See Also:
    getCurrentTool(), setTool(String)
  - vp
```
protected ViewPort vp
```
    Reference to the ViewPort of the MapContext of this component.
    
    After, the view port will change adapting itself according the current projection and the extent.
    
    See Also:
    getViewPort(), ViewPort
  - mapToolListener
```
protected MapControl.MapToolListener mapToolListener
```
    Listener of all kind of mouse events produced in this component.
    
    Delegates each mouse event to the current map tool.
    
    See Also:
    addBehavior(String, Behavior), addBehavior(String, Behavior[]), getMapTool(String), getMapToolsKeySet(), getNamesMapTools(), setTool(String)
  - prevTool
```
protected String prevTool
```
    Name of the previous tool used.
  - adjustedPoint
```
protected Point2D adjustedPoint
```
    Represents the cursor's point selected in screen coordinates.
    
    See Also:
    ViewPort.fromMapPoint(Point2D)
  - mapControlManager
```
protected static MapControlManager mapControlManager
```
  - mapAdjustedPoint
```
protected Point2D mapAdjustedPoint
```
    Represents the cursor's point selected in map coordinates.
    
    See Also:
    MapControl#toMapPoint
- Constructor Detail
  - MapControl
```
public MapControl()
```
    Creates a new MapControl instance with the following characteristics:
    - Name: MapControl .
    - Disables the double buffer of JComponent .
    - Sets opaque (see JComponent.setOpaque(boolean) ).
    - Sets its status to OUTDATED .
    - Creates a new CancelDraw object to notify MapContext's layers if can continue processing the drawn or must cancel it.
    - Creates a new MapContext with a new ViewPort in the default projection.
    - Creates a new CommandListener for edition operations.
    - Creates a new MapToolListener, and associates it as a listener of whatever kind of mouse events produced in this component.
    - Creates a new Drawer2 for managing the painting requests.
    - Creates a new timer that will invoke refresh this component drawFrameRate per second, when is running a drawing process, and its enabled drawAnimationEnabled.
  - MapControl
```
public MapControl(MapContext theMapContext)
```
- Method Detail
  - setMapContext
```
public void setMapContext(MapContext model)
```
    Sets a MapContext to this component.
    
    The MapContext has the model, and most of the view, and control logic of the layers of this component, including a ViewPort to adapt the information to the projection, and to display it in the available area.
    
    If model hadn't a ViewPort, assigns the current one to it, otherwise, use its ViewPort.
    
    After assigning the MapContext and ViewPort, sets the same MapContextListener that was using, and changes the status to OUTDATED.
    
    Parameters:
    model - this component's MapContext, that includes the ViewPort.
    See Also:
    MapContext, getMapContext()
  - getMapControlDrawer
```
public MapControlDrawer getMapControlDrawer()
```
    Returns:
    the mapControlDrawer
  - setMapControlDrawer
```
public void setMapControlDrawer(MapControlDrawer mapControlDrawer)
```
    Parameters:
    mapControlDrawer - the mapControlDrawer to set
  - getProjection
```
public IProjection getProjection()
```
    Gets this component's MapContext projection.
    
    Returns:
    this component's MapContext projection
    See Also:
    MapContext.getProjection(), setProjection(IProjection)
  - setProjection
```
public void setProjection(IProjection proj)
```
    Sets the projection to this component's MapContext.
    
    Parameters:
    proj - the kind of projection to this component's MapContext
    See Also:
    MapContext.setProjection(IProjection), getProjection()
  - getMapContext
```
public MapContext getMapContext()
```
    Gets this component's MapContext, with the model, and most of the view, and control logic of the layers of this component, including a ViewPort to adapt the information to the projection, and display it in the available area.
    
    Returns:
    this component's MapContext, that includes the ViewPort used to project the graphical information, and display it in the available area
    See Also:
    MapContext, setMapContext(MapContext)
  - addBehavior
```
public void addBehavior(String name,
               Behavior tool)
```
    Registers a new behavior to this component.
    
    According the nature of the Behavior, different events will be generated. Those events can be caught by a particular ToolListener, allowing user to interact with this MapControl object as a tool.
    
    Parameters:
    name - name to identify the behavior to add
    tool - the behavior to add
    See Also:
    addBehavior(String, Behavior[]), getNamesMapTools(), getMapToolsKeySet(), hasTool(String)
  - addBehavior
```
public void addBehavior(String name,
               Behavior[] tools)
```
    Registers a new behavior to this component as a CompoundBehavior made up of tools.
    
    According the nature of the behaviors registered, different events will be generated. Those events can be caught by a particular ToolListener, allowing user to interact with this MapControl object as a tool.
    
    Parameters:
    name - name to identify the compound behavior to add
    tools - the compound behavior to add
    See Also:
    addBehavior(String, Behavior), getNamesMapTools(), getMapToolsKeySet(), hasTool(String)
  - getMapTool
```
public Behavior getMapTool(String name)
```
    Gets the Behavior registered in this component, identified by name.
    
    Parameters:
    name - name of a registered behavior
    
    Returns:
    tool the registered behavior in this component as name, or null if no one has that identifier
    See Also:
    addBehavior(String, Behavior), addBehavior(String, Behavior[]), hasTool(String)
  - getMapToolsKeySet
```
public Set getMapToolsKeySet()
```
    Returns a set view of the keys that identified the tools registered.
    
    Returns:
    a set view of the keys that identified the tools registered
    See Also:
    HashMap.keySet(), getNamesMapTools(), addBehavior(String, Behavior), addBehavior(String, Behavior[])
  - hasTool
```
public boolean hasTool(String toolName)
```
    Returns true if this component contains a tool identified by toolName.
    
    Parameters:
    toolName - identifier of the tool
    
    Returns:
    true if this component contains a tool identified by toolName; otherwise false
    See Also:
    addBehavior(String, Behavior), addBehavior(String, Behavior[])
  - setTool
```
public void setTool(String toolName)
```
    Sets as current active Behavior associated to this component, that one which is registered and identified by toolName.
    
    Changing the current active behavior for this MapControl, implies also updating the previous behavior tool, and the current cursor.
    
    Parameters:
    toolName - name of a registered behavior
    See Also:
    getCurrentMapTool(), getCurrentTool()
  - getCurrentMapTool
```
public Behavior getCurrentMapTool()
```
    Gets as current active Behavior associated to this component, that one which is registered and identified by toolName.
    
    Changing the current active behavior for this MapControl, implies also updating the previous behavior tool, and the current cursor.
    
    Parameters:
    toolName - name of a registered behavior
    See Also:
    getCurrentTool(), setTool(String)
  - getCurrentTool
```
public String getCurrentTool()
```
    Returns the name of the current selected tool on this MapControl
    
    Returns:
    the name of the current's behavior tool associated to this component
    See Also:
    getCurrentMapTool(), setTool(String)
  - cancelDrawing
```
public void cancelDrawing()
```
    Determines that current drawing process of MapControl's MapContext's data must be canceled.
    
    It has no effects if now isn't drawing that graphical information.
    
    At last resort, the particular implementation of each layer in this MapControl's MapContrext will be that one which will draw the graphical information, and, if supports, which could cancel its drawing subprocess.
  - paintComponent
```
protected void paintComponent(Graphics g)
```
    Paints the graphical information of this component using a double buffer.
    
    If the double buffer wasn't created, creates a new one.
    
    Paints the component according the following algorithm:
    If status is UPDATED:
    If there is no double buffer:
    If there is a behavior for managing the MapControl instance, delegates the drawing process to that behavior, calling: behavior_instance.paintComponent(g) .
    Else, repaints the current graphical information quickly calling: g.drawImage(image,0,0,null) .
    Else, (status is OUTDATED, or ONLY_GRAPHICS): executes a quickly repaint of the previous information calling g.drawImage(image,0,0,null), and creates a painting request to delegate the heavy drawing process to the Drawer2's worker thread, according the SingleWorketThread pattern, starting a timer to update (invoking repaint() that comprises invoke this method) the view every delay of 360 ms. during the the process drawing.
    
    Overrides:
    
    paintComponent in class JComponent
    
    See Also:
    JComponent.paintComponent(java.awt.Graphics), Drawer2
  - getImage
```
public BufferedImage getImage()
```
    Gets the BufferedImage used to accelerate the draw of new ''frames'' with changes, or new graphical items in this component.
    
    Returns:
    double buffered image used by this component to accelerate the draw of its graphical information, or null if isn't already created
    See Also:
    BufferedImage
  - drawMap
```
public void drawMap(boolean doClear)
```
    Forces repaint all visible graphical information in this component.
    
    If doClear == true, before repainting, clears the background color, with the inner viewport's background color.
    
    Parameters:
    doClear - true if needs clearing the background color before drawing the map
    See Also:
    cancelDrawing(), FLayers#setDirty(boolean)
  - rePaintDirtyLayers
```
public void rePaintDirtyLayers()
```
    Cancels any current drawing process, changing the status to OUTDATED, and forcing repaint only the layers dirty.
    
    See Also:
    cancelDrawing()
  - drawGraphics
```
public void drawGraphics()
```
    Deprecated. use drawMap(boolean) instead, or even better getMapContext().invalidate().
  - componentHidden
```
public void componentHidden(ComponentEvent e)
```
    Specified by:
    
    componentHidden in interface ComponentListener
    
    See Also:
    ComponentListener.componentHidden(java.awt.event.ComponentEvent)
  - componentMoved
```
public void componentMoved(ComponentEvent e)
```
    Specified by:
    
    componentMoved in interface ComponentListener
    
    See Also:
    ComponentListener.componentMoved(java.awt.event.ComponentEvent)
  - componentResized
```
public void componentResized(ComponentEvent e)
```
    Specified by:
    
    componentResized in interface ComponentListener
    
    See Also:
    ComponentListener.componentResized(java.awt.event.ComponentEvent)
  - componentShown
```
public void componentShown(ComponentEvent e)
```
    Specified by:
    
    componentShown in interface ComponentListener
    
    See Also:
    ComponentListener.componentShown(java.awt.event.ComponentEvent)
  - addExceptionListener
```
public void addExceptionListener(ExceptionListener o)
```
    See Also:
    ExceptionHandlingSupport.addExceptionListener(ExceptionListener)
  - removeExceptionListener
```
public boolean removeExceptionListener(ExceptionListener o)
```
    See Also:
    ExceptionHandlingSupport.removeExceptionListener(ExceptionListener)
  - throwException
```
protected void throwException(Throwable t)
```
    See Also:
    ExceptionHandlingSupport.throwException(Throwable)
  - getViewPort
```
public ViewPort getViewPort()
```
    Gets the ViewPort of this component's MapContext .
    
    See Also:
    MapContext.getViewPort()
  - getNamesMapTools
```
public HashMap getNamesMapTools()
```
    Returns all registered Behavior that can define a way to work with this MapControl.
    
    Returns:
    registered Behavior to this MapControl
    See Also:
    addBehavior(String, Behavior), addBehavior(String, Behavior[]), getMapToolsKeySet(), hasTool(String)
  - commandRepaint
```
public void commandRepaint()
```
  - commandRefresh
```
public void commandRefresh()
```
  - setPrevTool
```
public void setPrevTool()
```
    Equivalent operation to undo.
    
    Exchanges the previous tool with the current one.
    
    See Also:
    addBehavior(String, Behavior), addBehavior(String, Behavior[]), setTool(String)
  - zoomIn
```
public void zoomIn()
```
    Executes a zoom in operation centered at the center of the extent.
    
    This implementation is designed for being invoked outside a Behavior, for example by an action of pressing a button; and simulates that the event has been produced by releasing the button 1 of the mouse using the registered Behavior in this MapControl object that's responsible for the zoom in operation.
    
    See Also:
    zoomOut()
  - zoomOut
```
public void zoomOut()
```
    Executes a zoom out operation centered at the center of the extent.
    
    This implementation is thought for being invoked outside a Behavior, for example by an action of pressing a button, and simulates that the event has been produced by releasing the button 1 of the mouse using the registered Behavior in this MapControl object that's responsible for the zoom out operation.
    
    See Also:
    zoomIn()
  - getMapToolListener
```
public MapControl.MapToolListener getMapToolListener()
```
    Returns the listener used to catch all mouse events produced in this MapControl instance and that redirects the calls to the current map tool.
    
    Returns:
    the map tool listener used
  - setCurrentMapTool
```
public void setCurrentMapTool(Behavior mapTool)
```
    Sets mapTool as this MapControl's current map tool.
    
    Parameters:
    mapTool - a map tool, or null to disable the interaction with the user
    See Also:
    getCurrentMapTool(), getCurrentTool(), setTool(String), setPrevTool(), addBehavior(String, Behavior), addBehavior(String, Behavior[])
  - applyFrameRate
```
public void applyFrameRate()
```
    Sets the delay to the timer that refreshes this MapControl instance.
    
    Delay (in ms) = 1000 / getDrawFrameRate()
    
    See Also:
    #getDrawFrameRate(), #setDrawFrameRate(int)
  - isDrawAnimationEnabled
```
public static boolean isDrawAnimationEnabled()
```
    Determines if its enabled the repaint that invokes the timer according to #getDrawFrameRate().
    
    Returns:
    true if its enabled; otherwise false
  - setDrawAnimationEnabled
```
public static void setDrawAnimationEnabled(boolean drawAnimationEnabled)
```
    Sets if its enabled the repaint that invokes the timer according to #getDrawFrameRate().
    
    Parameters:
    drawAnimationEnabled - true to enable the mode; otherwise false
  - getCanceldraw
```
public MapControl.CancelDraw getCanceldraw()
```
    Gets the shared object that determines if a drawing process must be cancelled or can continue.
    
    Returns:
    the shared object that determines if a drawing process must be cancelled or can continue
  - getCombinedTool
```
public Behavior getCombinedTool()
```
    Gets the tool used in combination with the current tool of this MapControl.
    
    Returns:
    the tool used in combination with the currentMapTool ; null if there is no combined tool
  - setCombinedTool
```
public void setCombinedTool(Behavior combinedTool)
```
    Sets a tool to be used in combination with the current tool of this MapControl.
    
    Parameters:
    combinedTool - a tool to be used in combination with the current tool of MapControl
  - addCombinedBehavior
```
public void addCombinedBehavior(Behavior tool)
```
    Adds a new tool as combined tool.
    
    The new tool will be stored with the previous combined tools, and will be combined with the current tool.
    
    If tool was already stored as a combined tool, doesn't adds it.
    
    Parameters:
    tool - a new tool to be used combined with the current tool
  - removeCombinedTool
```
public void removeCombinedTool(Behavior tool)
```
    Removes the tool tool used in combination with the current tool of this MapControl.
  - initializeGrid
```
public void initializeGrid()
```
    Updates the grid on the ViewPort of the associated MapControl object according the values in the com.iver.cit.gvsig.gui.cad.CADToolAdapter.prefs.Preferences.
    
    The preferences are:
    - Show/hide the grid.
    - Adjust or not the grid.
    - Horizontal ( X ) line separation.
    - Vertical ( Y ) line separation.
  - setAdjustGrid
```
public void setAdjustGrid(boolean adjustGrid)
```
  - setGridVisibility
```
public void setGridVisibility(boolean showGrid)
```
  - isRefentEnabled
```
public boolean isRefentEnabled()
```
    Determines if snap tools are enabled or disabled.
    
    Returns:
    true to enable the snap tools; false to disable them
    See Also:
    setRefentEnabled(boolean)
  - calculateSnapPoint
```
public void calculateSnapPoint(Point point)
```
    Tries to find the nearest geometry or grid control point by the position of the current snap tool.
    
    Prioritizes the grid control points than the geometries ones.
    
    If finds any near, stores the map and pixel coordinates for the snap, and enables the bForceCoord attribute for the next draw of the mouse's cursor.
    
    Parameters:
    point - current mouse 2D position
  - setRefentEnabled
```
public void setRefentEnabled(boolean activated)
```
    Sets the snap tools enabled or disabled.
    
    Parameters:
    activated - true to enable the snap tools; false to disable them
    See Also:
    isRefentEnabled()
  - getGrid
```
public Grid getGrid()
```
  - update
```
public void update(Observable observable,
          Object notification)
```
    Description copied from interface: Observer
    
    Called whenever a Observable object is changed and this Observer has registered on it to receive notifications.
    Implementations of this method will be called for each simple notification or, if a complex notification is created, for each of the child notifications.
    
    In the latter case, don't assume any ordering in the notification between this Observer and other Observers listening to the same Observable.
    
    In a complex notification scenario, if you want to receive only the complex notification and not each of the child notifications, just implement the ComplexObserver and prepare this method implementation to handle receiving DefaultComplexNotification instances as well as direct notification objects.
    
    Specified by:
    
    update in interface Observer
    
    Parameters:
    observable - the observable object.
    notification - the notification data.
  - getAdjustedPoint
```
public Point2D getAdjustedPoint()
```
    Returns:
    the adjustedPoint
  - getMapAdjustedPoint
```
public Point2D getMapAdjustedPoint()
```
    Returns:
    the mapAdjustedPoint
  - getPoint
```
public Point2D getPoint()
```
    Gets the selected point. If the snapping is enabled it returns the selected point.
    
    Returns:
    The selected point
  - dispose
```
public void dispose()
```
    Description copied from interface: Disposable
    
    Disposes the current object, to allow it to close and dispose any used resources.
    NOTE:After calling this method, the object may not be usable anymore.
    
    Specified by:
    
    dispose in interface Disposable

Class MapControl

Nested Class Summary

Nested classes/interfaces inherited from class javax.swing.JComponent

Nested classes/interfaces inherited from class java.awt.Container

Nested classes/interfaces inherited from class java.awt.Component

Field Summary

Fields inherited from class javax.swing.JComponent

Fields inherited from class java.awt.Component

Fields inherited from interface java.awt.image.ImageObserver

Constructor Summary

Method Summary

Methods inherited from class javax.swing.JComponent

Methods inherited from class java.awt.Container

Methods inherited from class java.awt.Component

Methods inherited from class java.lang.Object

Field Detail

geomManager

ACTUALIZADO

DESACTUALIZADO

namesMapTools

currentMapTool

currentTool

vp

mapToolListener

prevTool

adjustedPoint

mapControlManager

mapAdjustedPoint

Constructor Detail

MapControl

MapControl

Method Detail

setMapContext

getMapControlDrawer

setMapControlDrawer

getProjection

setProjection

getMapContext

addBehavior

addBehavior

getMapTool

getMapToolsKeySet

hasTool

setTool

getCurrentMapTool

getCurrentTool

cancelDrawing

paintComponent

getImage

drawMap

rePaintDirtyLayers

drawGraphics

componentHidden

componentMoved

componentResized

componentShown

addExceptionListener

removeExceptionListener

throwException

getViewPort

getNamesMapTools

commandRepaint

commandRefresh

setPrevTool

zoomIn

zoomOut

getMapToolListener

setCurrentMapTool

applyFrameRate

isDrawAnimationEnabled

setDrawAnimationEnabled

getCanceldraw

getCombinedTool

setCombinedTool

addCombinedBehavior

removeCombinedTool

initializeGrid

setAdjustGrid

setGridVisibility

isRefentEnabled