Introducción
-------------

Los distintos modos en que un usuario puede interactuar con un objeto de tipo *MapControl* son lo que se denomina *behavior*.

Así, en un momento dado, puede ser necesario tener que trabajar seleccionando una polilínea, o un punto, o un rectángulo, o arrastrando el ratón sobre un MapControl_, o, porqué no, combinando varios de estos comportamientos individuales (por ej. seleccionando un punto del objeto de tipo *MapControl* y arrastrando *(drag & drop)* el ratón) ... Cada uno de estos comportamientos posibles con los que trabajar con MapControl_ es lo que, en la terminología de *libFMap* se denomina *behavior*. De hecho, es común utilizar varios de estos comportamientos básicos combinados para definir la interacción con *MapControl* vía una herramienta determinada.

Ninguno de los *behavior* se encargará de tratar la información seleccionada por el usuario sobre MapControl_, para esto están las ToolListeners_. *Behavior* se encarga de procesar los eventos que se producen en MapControl, preparando eventos_ genéricos que enviará a la ToolListener actual, con la información necesaria.

De este modo, se consigue simular distintas herramientas con las que un usuario podrá trabajar con un objeto de tipo *MapControl*, y a la vez facilitar al desarrollador el incorporar nuevas herramientas, basándonos en el principio de *divide y vencerás* y una variante del patrón software "*Chain-of-responsibility pattern*".

Actualmente, todos los eventos que puede recibir cualquier tipo de *behavior* son producidos por el manejo del ratón sobre el objeto *MapControl*, y estos pueden ser de tipo *MouseEvent*, o de tipo *MouseWheelEvent*, según su naturaleza, atenderá a uno u otro tipo de evento. Por otro lado, cualquiera de las excepciones que puede lanzar son de tipo *BehaviorException*.


Diagramas
----------

El *diagrama 1* muestra cómo se integra en MapControl, y la relación con los tipos de eventos que puede recibir, o excepciones que puede lanzar.

.. figure:: images/mapcontrol/dcbehavior.png
   :height: 284
   :width: 578
   :align: center

   *Diagrama 1: Diagrama de clases centrado en Behavior.*


Tipos de behavior en libFMap
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

El *diagrama 2* muestra los tipos de comportamientos básicos implementados en la librería *libFMap*.

.. figure:: images/mapcontrol/dcbehaviortypes.png
   :height: 381
   :width: 860
   :align: center

   *Diagrama 2: Tipos de comportamiento implementados en libFMap.*



+---------------------------+--------------+---------------------------------------------------------------------------+--------------------+---------------------+
| **Tipo**                  | **Proyecto** | **Modo de interacción**                                                   | **Eventos hacia**  | **Herramienta**     |
|                           |              |                                                                           | **la herramienta** | **asociada**        |
+===========================+==============+===========================================================================+====================+=====================+
| **CADToolAdapter**        | *extCAD*     | *Por Ratón:*                                                              | *MouseEvent*,      | 1 o más             |
|                           |              |                                                                           | *InputEvent*       | *CADTool*           |
|                           |              | Haciendo click con el botón derecho del ratón solicita a la herramienta   |                    |                     |
|                           |              | actual que muestre un *popup* con las opciones de edición actualmente     |                    |                     |
|                           |              | disponibles. Si es con el botón izquierdo agrega un punto en              |                    |                     |
|                           |              | dicha posición. Soltando cualquier botón solicita a *MapControl* que se   |                    |                     |
|                           |              | repinte. Mientras que, moviéndolo además actualiza las coordenadas en la  |                    |                     |
|                           |              | barra de estado. En caso que esté habilitado el *snap*, actualizará el    |                    |                     |
|                           |              | icono del cursor conforme el punto de control más cercano en una pequeña  |                    |                     |
|                           |              | área de tolerancia bajo.                                                  |                    |                     |
|                           |              |                                                                           |                    |                     |
|                           |              | *Por Teclado:*                                                            |                    |                     |
|                           |              |                                                                           |                    |                     |
|                           |              | En caso de escribir un comando por teclado, cambia a una herramienta en   |                    |                     |
|                           |              | modo selección, y según el tipo de comando escrito y el estado actual de  |                    |                     |
|                           |              | la herramienta, puede tomar la información como un nuevo punto, una opción|                    |                     |
|                           |              | o el valor de una opción. Aplicará cambios, o notificará que el           |                    |                     |
|                           |              | comando no es válido, en la misma consola de edición.                     |                    |                     |
+---------------------------+--------------+---------------------------------------------------------------------------+--------------------+---------------------+
| **CircleBehavior**        | *libFMap*    | Pulsando el botón izquierdo del ratón, permite definir un área circular:  | *MeasureEvent*     | *CircleListener*    |
|                           |              | primero se indica centro, y luego un punto de la circunferencia, mediante |                    |                     |
|                           |              | el botón izquierdo del ratón.                                             |                    |                     |
+---------------------------+--------------+---------------------------------------------------------------------------+--------------------+---------------------+
| **CompoundBehavior**      | *libFMap*    | Funciona como una combinación de *Behavior* de *libFMap*. El modo de      | *MouseEvent*,      | 1 o más             |
|                           |              | interacción dependerá de los *Behavior* que lo componen.                  | *MouseWheelEvent*  | *ToolListener*      |
+---------------------------+--------------+---------------------------------------------------------------------------+--------------------+---------------------+
| **DraggerBehavior**       | *libFMap*    | Arrastrando el ratón y manteniendo pulsado cualquiera de sus botones. Irá | *MoveEvent*        | *PanListener*       |
|                           |              | actualizando *MapControl* teniendo en cuenta la variación del punto actual|                    |                     |
|                           |              | respecto al inicial. Una vez soltado el ratón, el cambio será permanente. |                    |                     |
+---------------------------+--------------+---------------------------------------------------------------------------+--------------------+---------------------+
| **MouseMovementBehavior** | *libFMap*    | Notifica eventos de movimiento, o arrastre *(mantener pulsado un botón del| *PointEvent*       | *PointListener*     |
|                           |              | ratón y a la vez moverlo)* del ratón sobre *MapControl*.                  |                    |                     |
+---------------------------+--------------+---------------------------------------------------------------------------+--------------------+---------------------+
| **MoveBehavior**          | *libFMap*    | Igual que *DraggedBehavior* pero manteniendo pulsado el botón izquierdo   | *MoveEvent*        | *PanListener*       |
|                           |              | del ratón.                                                                |                    |                     |
+---------------------------+--------------+---------------------------------------------------------------------------+--------------------+---------------------+
| **PointBehavior**         | *libFMap*    | Selección de un punto con un click por medio de cualquier botón del ratón.| *PointEvent*       | *PointListener*     |
|                           |              |                                                                           |                    |                     |
|                           |              | Pulsando una vez, solicita la cancelación del dibujado actual de          |                    |                     |
|                           |              | *MapControl*.                                                             |                    |                     |
|                           |              |                                                                           |                    |                     |
|                           |              | Siempre notifica el que un botón haya dejado de estar pulsado, y en caso  |                    |                     |
|                           |              | que se hubiese hecho un click doble, notifica el evento al soltar el      |                    |                     |
|                           |              | botón.                                                                    |                    |                     |
+---------------------------+--------------+---------------------------------------------------------------------------+--------------------+---------------------+
| **PolylineBehavior**      | *libFMap*    | Con un click de cualquier botón del ratón, notifica y almacena el punto,  | *MeasureEvent*     | *PolylineListener*  |
|                           |              | iniciándose así el modo de dibujado de polilínea. Todos los eventos de    |                    |                     |
|                           |              | movimiento o arrastre del ratón posteriores son tambien notificados,      |                    |                     |
|                           |              | hasta que con 2 clicks se finaliza el modo, enviando todos los vértices   |                    |                     |
|                           |              | seleccionados por el usuario a la *ToolListener* asociada.                |                    |                     |
+---------------------------+--------------+---------------------------------------------------------------------------+--------------------+---------------------+
| **PolygonBehavior**       | *libFMap*    | Igual a *PolylineBehavior*, pero ahora el primer punto será también el    | *MeasureEvent*     | *PolylineListener*  |
|                           |              | último de la polilínea, y cada nuevo en agregarse será el penúltimo.      |                    |                     |
+---------------------------+--------------+---------------------------------------------------------------------------+--------------------+---------------------+
| **RectangleBehavior**     | *libFMap*    | Notifica el punto donde se hizo click con el botón izquierdo del ratón,   | *RectangleEvent*   | *RectangleListener* |
|                           |              | a partir de ese momento según se arrastre el ratón se mostrará un         |                    |                     |
|                           |              | rectángulo tomando como segundo vértice en diagonal la posición actual del|                    |                     |
|                           |              | cursor. Una vez se suelte el botón, quedará definida el área rectangular. |                    |                     |
|                           |              | Así pues, durante el arrastre y al soltar el botón, se generarán eventos  |                    |                     |
|                           |              | que notifiquen la posición actual del ratón.                              |                    |                     |
|                           |              |                                                                           |                    |                     |
|                           |              | Via los puntos inicial y el final se definirá un rectángulo con los lados |                    |                     |
|                           |              | paralelos a los ejes X e Y de coordenadas.                                |                    |                     |
+---------------------------+--------------+---------------------------------------------------------------------------+--------------------+---------------------+



Enlaces de interés
-------------------
`Chain of responsibility Pattern`_: información acerca de este patrón software, con código fuente de ejemplo.

`ToolListeners`_: herramientas que combinadas con algún comportamiento *Behavior* permiten trabajar con *MapControl*.

`ToolListener events`_: eventos que utiliza un *Behavior* para notificar información a su/s *ToolListener* asociada.

.. _`Chain of responsibility Pattern`: http://en.wikipedia.org/wiki/Chain-of-responsibility_pattern
.. _gvSIG: http://www.gvsig.gva.es/
.. _ToolListeners: ./toollistener
.. _MapControl: ./mapcontrol
.. _`ToolListener events`: ./toollistenersevents
.. _eventos: ./toollistenersevents/