Pintado
--------

gvSIG pinta usando el patrón *"SingleWorketThread"*.

Las peticiones de dibujado se encolan y se envían a un único thread que lanza el dibujado con un objeto de tipo *Cancellable* para permitir interrumpir ese dibujado.

El thread de pintado va recibiendo comandos de pintado e inmediatamente se pone a pintar en segundo plano sobre una imagen en memoria. Frecuentemente, y para observar el progreso (porque puede llegar a tardar varios segundos en terminarlo) MapContext_ renderiza esa imagen y se muestra en pantalla. Esto es cada 400 milisegundos (y a partir de v1.2 será configurable de manera que se puede ver el progreso en tiempo real) y en el momento en que el thread ha terminado de pintar.

El dibujado de las capas lo hace MapContext_. MapContext_ puede pintar sobre un *Graphics2D* que provenga de una imagen (caso de las peticiones del MapControl_) o sobre un *Graphics2D* que venga de otro sitio (por ejemplo al imprimir). MapContext_ tiene una colección FLayers_, y cada capa tiene un método *draw*. Para terminar, existe un *"StrategyManager"* que, en función del tipo de capa, escoge una estrategia de pintado u otra (patrón *"Strategy"*). Las estrategias de pintado están en el paquete *"operations"*, dentro de libFMap_, y las más interesantes son *ShpStrategy* y *DBStrategy*.

Por otra parte, si se observa el interfaz de las capas (FLayers_) se verá que el método draw (que dibuja cada capa) tiene un argumento Cancellable que tiene un método *isCanceled()*. Cuando se ha cancelado el pintado (sea por un zoom, un *pan* o cualquier otro evento que comporte que lo que hay actualmente ya no es válido y debe de recalcularse) entonces *isCanceled()* devuelve *true*. En cualquier otro caso devuelve *false*.

La agilización de la cancelación se realiza dentro de cada una de las iteraciones que se hace en el método *draw* y posteriores llamadas internas, comprobando que *isCanceled()* es *true*, y si lo es, se aborta todo el proceso y entonces se sale del método del *draw*, si no lo es, se continua con el renderizando. Si se cancela el pintado de todas las capas de manera encadenada, la petición de *draw* del MapContext_ se termina, haciendo que se atienda a la siguiente (la que ha provocado que Mapcontext_ se invalide y que *cancel.isCanceled()* devuelva *true*).

Que el cancelado sea inmediato o no, depende del tipo de capas y de la implementación del método *draw* de ellas. La mayor parte de las capas tienen en cuenta el *Cancelable*, pero hay algunas que no lo pueden comprobar e inevitablemente ejecutan su método *draw* íntegro aunque el resultado no se llegue a mostrar en pantalla. 




Escritura de una capa
----------------------

El método *isWritable()* de una capa devuelve *true* si el driver en el que se apoya la capa devuelve *true*:

- **Para el caso vectorial**:

.. code-block:: java

  public boolean isWritable() {
    VectorialDriver drv = getSource().getDriver();

    if (!drv.isWritable())
      return false;

    // VectorialEditableAdapter vea = (VectorialEditableAdapter) lyrVect
    // .getSource();
    if (drv instanceof IWriteable)
    {
      IWriter writer = ((IWriteable)drv).getWriter();
      if (writer != null)
      {
        if (writer instanceof ISpatialWriter)
          return true;
      }
    }
    return false;
  }


- **Para el caso de los shape**: devuelve *true* si el fichero tiene permiso de escritura. El resto (instanceof *IWriteable*) es por si tenemos solo capas con driver de lectura. Si el driver implementa la escritura, se podrá editar y guardar la capa en ese formato. Si no, la capa se puede poner en edición, pero no se puede salvar a ese formato, solo se puede *guardar como* .



Enlaces relacionados
---------------------
* Strategy_ : explicación detallada en inglés acerca de este patrón sofware.
* WorkerThreadPattern_ : código Java con un ejemplo donde se implementa este patrón software.
* `Painting in AWT and Swing`_ : descripción detallada en inglés de los mecanismos y *filosofía* de pintado de la biblioteca *Swing* y el kit de herramientas *AWT* en Java.
* `Pintando en AWT`_ : descripción detallada en castellano de los mecanismos y *filosofía* de pintado en Java con la biblioteca *AWT*.
* `Pintando en Swing`_ : descripción detallada en castellano de los mecanismos y *filosofía* de pintado en Java con la biblioteca *Swing*.


.. _Strategy: http://en.wikipedia.org/wiki/Strategy_pattern
.. _WorkerThreadPattern: http://www.java2s.com/Code/Java/Design-Pattern/WorkerThreadPatterninJava.htm
.. _libFMap: ../introduccion/introduccion
.. _FLayers: ../dirlayers/layers
.. _MapContext: ../dirmapcontext/mapcontext
.. _MapControl: ../dirmapcontrol/mapcontrol
.. _gvSIG: http://www.gvsig.gva.es
.. _`Painting in AWT and Swing`: http://java.sun.com/docs/books/tutorial/uiswing/painting/index.html
.. _`Pintando en AWT`: http://www.itapizaco.edu.mx/paginas/JavaTut/froufe/parte15/cap15-2.html
.. _`Pintando en Swing`: http://www.itapizaco.edu.mx/paginas/JavaTut/froufe/parte15/cap15-3.html