Personal tools
You are here: Home Development Documents gvSIG desktop 1.0 / 1.1 FMap MapControl Behavior
Document Actions

Behavior

by Pablo Piqueras last modified 2010-06-01 22:46

Cada uno de los "comportamientos básicos" predefinidos, que en combinación permiten simular el comportamiento de MapControl. Vía una ToolListener, se podrá simular una herramienta con la que el usuario pueda interactuar con un objeto de tipo MapControl.

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/

View source document


Powered by Plone CMS, the Open Source Content Management System

This site conforms to the following standards: