| gvSIG desktop 1

					double visible__factor = at.getScaleX() / scale1_1;

							ViewPort viewPort = this.getMapContext()

							.getViewPort();

										mapContext.draw(m_image, gimg, getScale(),

												MapContext.getScreenDPI() * visible__factor);

	public static double getCartographicLength(CartographicSupport cartographicElement, double length, ViewPort viewPort, double dpi) {

				lengthInPixel = lengthInInches*dpi;

			double scale=dpi/72;

	 * <p>Draws this map if its {@link ViewPort ViewPort} has an extent defined:<br>

	 * <ol>

	 * <li>Selects only the layers that have to be drawn: {@linkplain #prepareDrawing(BufferedImage, Graphics2D, double)}.

	 * <li>Sets quality: antialiasing by text and images, and quality rendering.

	 * <li>Draws the layers.

	 * <li>Fires a <code>LayerDrawEvent.GRAPHICLAYER_BEFORE_DRAW</code>.

	 * <li>Draws the graphic layer.

	 * <li>Fires a <code>LayerDrawEvent.GRAPHICLAYER_AFTER_DRAW</code>.

	 * <li>Invokes the garbage collector and memory clean.

	 * </ol></p>

	 *

	 * @param image buffer used sometimes instead <code>g</code> to accelerate the draw. For example, if two points are as closed that can't be distinguished, draws only one.

	 * @param g for rendering 2-dimensional shapes, text and images on the Java(tm) platform

	 * @param cancel shared object that determines if this layer can continue being drawn

	 * @param scale the scale of the view. Must be between {@linkplain FLayer#getMinScale()} and {@linkplain FLayer#getMaxScale()}.

	 * @throws ReadDriverException if fails reading with the driver.

	 */

	public void draw(BufferedImage image, Graphics2D g, Cancellable cancel,

			double scale, double _dpi) throws ReadDriverException {

		if (viewPort.getExtent() == null) {

			// System.err.println("viewPort.getExtent() = null");

			return;

		}

		System.out.println("Viewport despues: " + viewPort.toString());

		/*

		 * if ((viewPort.getImageWidth() <=0) || (viewPort.getImageHeight() <=

		 * 0)) { return; }

		 */

//		prepareDrawing(image, g, scale);

		// M�s c�lidad al texto

		RenderingHints renderHints = new RenderingHints(

				RenderingHints.KEY_ANTIALIASING,

				RenderingHints.VALUE_ANTIALIAS_ON);

		renderHints.put(RenderingHints.KEY_RENDERING,

				RenderingHints.VALUE_RENDER_QUALITY);

		renderHints.put(RenderingHints.KEY_TEXT_ANTIALIASING,

				RenderingHints.VALUE_TEXT_ANTIALIAS_ON);

		g.setRenderingHints(renderHints);

		long t1 = System.currentTimeMillis();

//		layers.draw(image, g, viewPort, cancel, scale);

		this.getMapContextDrawer().draw(this.layers, image, g, cancel, scale, _dpi);

		LayerDrawEvent beforeTracLayerEvent = new LayerDrawEvent(tracLayer,

				g, viewPort, LayerDrawEvent.GRAPHICLAYER_BEFORE_DRAW);

		fireLayerDrawingEvent(beforeTracLayerEvent);

		tracLayer.draw(image, g, viewPort, cancel, scale);

		LayerDrawEvent afterTracLayerEvent = new LayerDrawEvent(tracLayer,

				g, viewPort, LayerDrawEvent.GRAPHICLAYER_AFTER_DRAW);

		fireLayerDrawingEvent(afterTracLayerEvent);

		//layers.setDirty(false);

		long t2 = System.currentTimeMillis();

		System.err.println("Tiempo de dibujado:" + (t2 - t1) +

				" mseg. Memoria libre:" + Runtime.getRuntime().freeMemory() / 1024  + " KB");

		/*

		 * g.setColor(Color.BLUE); GeneralPath shpR = new

		 * GeneralPath(viewPort.getExtent());

		 * shpR.transform(viewPort.getAffineTransform()); g.draw(shpR);

		 */

		System.gc();

	}

	/**

	/**

	 * <p>Like {@linkplain MapContext#draw(BufferedImage, Graphics2D, Cancellable, double)}, but creating

	 *  the task as cancellable.</p>

	 *

	 * @param image buffer used sometimes instead <code>g</code> to accelerate the draw. For example, if two points are as closed that can't be distinguished, draws only one.

	 * @param g for rendering 2-dimensional shapes, text and images on the Java(tm) platform

	 * @param scale the scale of the view. Must be between {@linkplain FLayer#getMinScale()} and {@linkplain FLayer#getMaxScale()}.

	 *

	 * @throws ReadDriverException if the driver fails reading.

	 *

	 * @see #draw(BufferedImage, Graphics2D, Cancellable, double)

	 */

	public void draw(BufferedImage image, Graphics2D g, double scale, double _dpi)

			throws ReadDriverException {

//		layers.setDirty(true);

		draw(image, g, new Cancellable() {

			/**

			 * @see com.iver.utiles.swing.threads.Cancellable#isCanceled()

			 */

			public boolean isCanceled() {

				return false;

			}

			public void setCanceled(boolean canceled) {

				// TODO Auto-generated method stub

			}

		}, scale, _dpi);

	}

	/**

	 * Alternative draw method, used when DPI in real world is different,

	 * for example, when you create a map and zoom in or out in it.

	 * The method takes in consideration the "physical_dpi" especailly

	 * to draw fonts in correct size.

	 * 

	 * @param root

	 * @param image

	 * @param g

	 * @param cancel

	 * @param scale

	 * @param physical_dpi

	 * @throws ReadDriverException

	 */

	public void draw(FLayers root, BufferedImage image, Graphics2D g, Cancellable cancel,

			double scale, double physical_dpi) throws ReadDriverException;

	public void draw(FLayers root, BufferedImage image, Graphics2D g, Cancellable cancel,

			double scale, double _dpi) throws ReadDriverException {

		this.checkIntilalized();

		boolean needToPaintAll = false;

		DrawList drawList = this.createDrawList(root, cancel,scale);

		if (cancel.isCanceled()){

			return;

		}

		if (cachedImage == null){

			needToPaintAll=true;

		} else if (!cachedImage.isValid(mapContext, viewPort, drawList.getFirstLayerToDraw())){

				needToPaintAll=true;

			}

		int firstLayer= 0;

		if (!needToPaintAll){

			firstLayer = cachedImage.getListPosition()+1;

//			System.out.println("=======Pintando a partir de la pos "+ firstLayer+"============");

			g.drawImage(cachedImage.getImage(), 0, 0, null);

//			System.out.println("=======Pintando imagen ============");

		} else{

			this.cachedImage = null;

//			System.out.println("=======Pintando todo============");

		}

		boolean cached=false;

		ComposedLayer composed = null;

		int pos;

		int layerPos= -1;

		FLayer layer;

		Object obj;

		LayersGroupEvent event;

		for (pos=0; pos < drawList.size(); pos++){

			if (cancel.isCanceled()){

				return;

			}

			obj = drawList.get(pos);

			// *** Gestion de eventos de pintado de grupos ***

			if (obj instanceof LayersGroupEvent){

				event = (LayersGroupEvent) obj;

				if (event.type == LayersGroupEvent.IN_Event){

//					System.out.println("=======Empiza a pintar grupo de capas "+ ((FLayers)event.group).getName() +"============");

					event.group.beginDraw(g, viewPort);

				} else{

					event.group.endDraw(g, viewPort);

//					System.out.println("=======Fin a pintar grupo de capas "+ ((FLayers)event.group).getName() +"============");

				}

				continue;

			}

			layerPos++;

			if (layerPos < firstLayer){

				continue;

			}

			layer = (FLayer) obj;

			if (cancel.isCanceled()){

				return;

			}

			// *** Gestion de cache ***

			if ((!cached) && this.isLayerCacheable(layer)){

				if (layerPos > 0){ //La primera capa es la activa, no cacheamos

					if (cachedImage==null || cachedImage.getListPosition() < layerPos-1){

						if (composed != null){

							//si tenemos una composicion de capas, necesitamos pintarlas

							//antes de guardarnos la imagen

//							System.out.println("=======Pintando composicion de pintado "+ (layerPos-1)+" (antes de cache)============");

							this.draw(composed, image, g, cancel, scale, _dpi);

//							composed.draw(image, g, viewPort, cancel, scale);

							composed = null;

						}

						CachedImage  newCached = new CachedImage();

						newCached.setImage(image, mapContext, viewPort, layerPos-1);

						this.cachedImage = newCached;

//						System.out.println("=======Guardando imagen de la pos "+ (layerPos-1)+" ("+ newCached.getListPosition() +")============");

					}

				}

				cached = true;

			}

			if (cancel.isCanceled()){

				return;

			}

			if (composed == null){

				composed = layer.newComposedLayer();

				if (composed != null){

					try {

//						System.out.println("=== a?adiendo a composicion de pintado "+ layerPos+ " "+layer.getName());

						composed.add(layer);

						continue;

					} catch (Exception e) {

						throw new ReadDriverException("DefaultMapContexDrawer exception",e);

					}

				}

			}else{

				if (composed.canAdd(layer)){

					try {

//						System.out.println("=== a?adiendo a composicion de pintado "+ layerPos+ " "+layer.getName());

						composed.add(layer);

						continue;

					} catch (Exception e) {

						throw new ReadDriverException("DefaultMapContexDrawer exception",e);

					}

				} else {

//					System.out.println("=======Pintando composicion de pintado "+ (layerPos-1)+" (cambio composicion)============");

					this.draw(composed, image, g, cancel, scale, _dpi);

//					composed.draw(image, g, viewPort, cancel, scale);

					composed = layer.newComposedLayer();

					if (composed != null){

						try {

//							System.out.println("=== a?adiendo a composicion de pintado "+ layerPos+ " "+layer.getName());

							composed.add(layer);

							continue;

						} catch (Exception e) {

							throw new ReadDriverException("DefaultMapContexDrawer exception",e);

						}					}

				}

			}

//			System.out.println("=== pintando "+ layerPos+ " "+layer.getName());

			this.draw(layer, image, g, cancel, scale, _dpi);

//			layer.draw(image, g, viewPort, cancel, scale);

		}

		if (composed != null){

			// si la composicion no se ha pintado la pintamos

//			System.out.println("=======Pintando composicion de pintado "+ (layerPos-1)+" (ultimo)============");

			this.draw(composed, image, g, cancel, scale, _dpi);

//			composed.draw(image, g, viewPort, cancel, scale);

		}

		if (cancel.isCanceled()){

			return;

		}

		this.previousDrawList = drawList;

	}