| gvSIG desktop 1

import com.hardcode.gdbms.engine.values.Value;

import com.iver.cit.gvsig.fmap.MapControl;

import com.iver.cit.gvsig.fmap.core.CartographicSupport;

import com.iver.cit.gvsig.fmap.core.FShape;

import com.iver.cit.gvsig.fmap.core.IFeature;

import com.iver.cit.gvsig.fmap.core.symbols.IMultiLayerSymbol;

import com.iver.cit.gvsig.fmap.core.v02.FSymbol;

import com.iver.cit.gvsig.fmap.drivers.IFeatureIterator;

import com.iver.cit.gvsig.fmap.layers.ISpatialDB;

import com.iver.cit.gvsig.fmap.layers.SpatialCache;

import com.iver.cit.gvsig.fmap.rendering.IClassifiedVectorLegend;

import com.iver.cit.gvsig.fmap.rendering.SingleSymbolLegend;

import com.iver.cit.gvsig.fmap.rendering.ZSort;

     * Draws using IFeatureIterator. This method will replace the old draw(...) one.

     * @autor jaume dominguez faus - jaume.dominguez@iver.es

     * @param image

     * @param g

     * @param viewPort

     * @param cancel

     * @param scale

     * @throws ReadDriverException

    private void _draw(BufferedImage image, Graphics2D g, ViewPort viewPort,

    		Cancellable cancel, double scale) throws ReadDriverException {

        IGeometry geom, clongeom;

        arcimsStatus.setExtent(bBox);

        arcimsStatus.setHeight(viewPort.getImageHeight());

        arcimsStatus.setWidth(viewPort.getImageWidth());

        // one-item vector:

        arcimsStatus.setLayerIds(Utilities.createVector(layerQuery, ","));

        arcimsStatus.setServer(host.toString());

        arcimsStatus.setService(service);

        arcimsStatus.setSrs(this.getProjection().getAbrev());

        arcimsStatus.setTransparency(this.arcImsTransparency);

        FMapFeatureArcImsDriver drv =

        	(FMapFeatureArcImsDriver) getSource().getDriver();

        IVectorLegend lgnd = (IVectorLegend) getLegend();

        // get needed fields

		String[] legflds = null;

		String[] savedFieldNames = arcimsStatus.getSubfields();

		if (lgnd instanceof IClassifiedVectorLegend) {

			legflds = ((IClassifiedVectorLegend) lgnd).getClassifyingFieldNames();

			if (legflds!=null) {

				String[] appended = appendAtringArrays(savedFieldNames, legflds);

				arcimsStatus.setSubfields(appended);

			}

		}

        try {

            // ********************************************

            // first item in query must contain ID or #ALL#

            // ********************************************

            geometries = (ArrayList) drv.getMap(arcimsStatus);

        } catch (Exception e) {

        	// restore dubfields

        	arcimsStatus.setSubfields(savedFieldNames);

        	ReadDriverException de =

        		new ReadDriverException("While getting map (ArrayList of geometries) ", e);

            throw de;

        }

    	// restore dubfields

        arcimsStatus.setSubfields(savedFieldNames);

    	boolean bDrawShapes = true;

    	if (lgnd instanceof SingleSymbolLegend) {

    		bDrawShapes = lgnd.getDefaultSymbol().isShapeVisible();

    	}

    	Point2D offset = viewPort.getOffset();

    	double dpi = MapContext.getScreenDPI();

    	if (bDrawShapes) {

    		try {

    			// Get the iterator over the visible features

    			IFeatureIterator it = new AvoidGeometryAndIdFeatureIterator(geometries, savedFieldNames.length);

    			ZSort zSort = ((IVectorLegend) getLegend()).getZSort();

    			boolean bSymbolLevelError = false;

    			// if layer has map levels it will use a ZSort

    			boolean useZSort = zSort != null && zSort.isUsingZSort();

    			// -- visual FX stuff

    			long time = System.currentTimeMillis();

    			BufferedImage virtualBim;

    			Graphics2D virtualGraphics;

    			// render temporary map each screenRefreshRate milliseconds;

    			int screenRefreshDelay = (int) ((1D/MapControl.getDrawFrameRate())*3*1000);

    			BufferedImage[] imageLevels = null;

    			Graphics2D[] graphics = null;

    			if (useZSort) {

    				imageLevels = new BufferedImage[zSort.getLevelCount()];

    				graphics = new Graphics2D[imageLevels.length];

    				for (int i = 0; !cancel.isCanceled() && i < imageLevels.length; i++) {

    					imageLevels[i] = new BufferedImage(image.getWidth(), image.getHeight(), image.getType());

    					graphics[i] = imageLevels[i].createGraphics();

    					graphics[i].setTransform(g.getTransform());

    					graphics[i].setRenderingHints(g.getRenderingHints());

    				}

    			}

    			// -- end visual FX stuff

    			int featindex = -1;

    			// Iteration over each feature

    			while ( !cancel.isCanceled() && it.hasNext()) {

    				featindex++;

    				IFeature feat = it.next();

    				geom = feat.getGeometry();

    				clongeom = geom.cloneGeometry();

    				geom = clongeom; 

    		        if ((layerTransf != null) && (isNotSame(layerTransf))) {

    		        	geom.reProject(layerTransf);

    		        }

    				// retrieve the symbol associated to such feature

    				ISymbol sym = lgnd.getSymbolByFeature(feat);

    				if (sym == null) continue;

    				//C?digo para poder acceder a los ?ndices para ver si est? seleccionado un Feature

    				ReadableVectorial rv=getSource();

    				int selectionIndex=-1;

    				FMapFeatureArcImsDriver imsdrv = (FMapFeatureArcImsDriver) getSource().getDriver();

    				selectionIndex = imsdrv.getOverallIndex(featindex);

    				if (selectionIndex!=-1) {

    					if (getSelectionSupport().isSelected(selectionIndex)) {

    						sym = sym.getSymbolForSelection();

    					}

    				}

    				// Check if this symbol is sized with CartographicSupport

    				CartographicSupport csSym = null;

    				int symbolType = sym.getSymbolType();

    				boolean bDrawCartographicSupport = false;

    				if (   symbolType == FShape.POINT

    						|| symbolType == FShape.LINE

    						|| sym instanceof CartographicSupport) {

    					// patch

    					if (!sym.getClass().equals(FSymbol.class)) {

    						csSym = (CartographicSupport) sym;

    						bDrawCartographicSupport = (csSym.getUnit() != -1);

    					}

    				}

    				int x = -1;

    				int y = -1;

    				int[] xyCoords = new int[2];

    				// Check if size is a pixel

    				boolean onePoint = bDrawCartographicSupport ?

    						isOnePoint(g.getTransform(), viewPort, MapContext.getScreenDPI(), csSym, geom, xyCoords) :

    							isOnePoint(g.getTransform(), viewPort, geom, xyCoords);

    						// Avoid out of bounds exceptions

    						if (onePoint) {

    							x = xyCoords[0];

    							y = xyCoords[1];

    							if (x<0 || y<0 || x>= viewPort.getImageWidth() || y>=viewPort.getImageHeight()) continue;

    						}

    						if (useZSort) {

    							// Check if this symbol is a multilayer

								int[] symLevels = zSort.getLevels(sym);

    							if (sym instanceof IMultiLayerSymbol) {

    								// if so, treat each of its layers as a single symbol

    								// in its corresponding map level

    								IMultiLayerSymbol mlSym = (IMultiLayerSymbol) sym;

    								for (int i = 0; !cancel.isCanceled() && i < mlSym.getLayerCount(); i++) {

    									ISymbol mySym = mlSym.getLayer(i);

        								int symbolLevel = 0;

        								if (symLevels != null) {

        									symbolLevel = symLevels[i];

        								} else {

    										/* an error occured when managing symbol levels.

    										 * some of the legend changed events regarding the

    										 * symbols did not finish satisfactory and the legend

    										 * is now inconsistent. For this drawing, it will finish

    										 * as it was at the bottom (level 0) but, when done, the

    										 * ZSort will be reset to avoid app crashes. This is

    										 * a bug that has to be fixed.

    										 */

    										bSymbolLevelError = true;

    									}

    									if (onePoint) {

    										if (x<0 || y<0 || x>= imageLevels[symbolLevel].getWidth() || y>=imageLevels[symbolLevel].getHeight()) continue;

    										imageLevels[symbolLevel].setRGB(x, y, mySym.getOnePointRgb());

    									} else {

    										if (!bDrawCartographicSupport) {

    											geom.drawInts(graphics[symbolLevel], viewPort, mySym, cancel);

    										} else {

    											geom.drawInts(graphics[symbolLevel], viewPort, dpi, (CartographicSupport) mySym, cancel);

    										}

    									}

    								}

    							} else {

    								// else, just draw the symbol in its level

    								int symbolLevel = 0;

    								if (symLevels != null) {

    									symbolLevel=symLevels[0];

    								} else {

    									/* If symLevels == null

    									 * an error occured when managing symbol levels.

    									 * some of the legend changed events regarding the

    									 * symbols did not finish satisfactory and the legend

    									 * is now inconsistent. For this drawing, it will finish

    									 * as it was at the bottom (level 0). This is

    									 * a bug that has to be fixed.

    									 */

//    									bSymbolLevelError = true;

    								}

    								if (!bDrawCartographicSupport) {

    									geom.drawInts(graphics[symbolLevel], viewPort, sym, cancel);

    								} else {

    									geom.drawInts(graphics[symbolLevel], viewPort, dpi, (CartographicSupport) csSym, cancel);

    								}

    							}

    							// -- visual FX stuff

    							// Cuando el offset!=0 se est? dibujando sobre el Layout y por tanto no tiene que ejecutar el siguiente c?digo.

    							if (offset.getX()==0 && offset.getY()==0)

    								if ((System.currentTimeMillis() - time) > screenRefreshDelay) {

    									virtualBim = new BufferedImage(image.getWidth(),image.getHeight(),BufferedImage.TYPE_INT_ARGB);

    									virtualGraphics = virtualBim.createGraphics();

    									virtualGraphics.drawImage(image,0,0, null);

    									for (int i = 0; !cancel.isCanceled() && i < imageLevels.length; i++) {

    										virtualGraphics.drawImage(imageLevels[i],0,0, null);

    									}

    									g.clearRect(0, 0, image.getWidth(), image.getHeight());

    									g.drawImage(virtualBim, 0, 0, null);

    									time = System.currentTimeMillis();

    								}

    							// -- end visual FX stuff

    						} else {

    							// no ZSort, so there is only a map level, symbols are

    							// just drawn.

    							if (onePoint) {

    								if (x<0 || y<0 || x>= image.getWidth() || y>=image.getHeight()) continue;

    								image.setRGB(x, y, sym.getOnePointRgb());

    							} else {

    								if (!bDrawCartographicSupport) {

    									geom.drawInts(g, viewPort, sym, cancel);

    								} else {

    									geom.drawInts(g, viewPort, dpi, csSym, cancel);

    								}

    							}

    						}

    			}

    			if (useZSort) {

    				g.drawImage(image, 0, 0, null);

    				g.translate(offset.getX(), offset.getY());

    				for (int i = 0; !cancel.isCanceled() && i < imageLevels.length; i++) {

    					g.drawImage(imageLevels[i],0,0, null);

    					imageLevels[i] = null;

    					graphics[i] = null;

    				}

    				g.translate(-offset.getX(), -offset.getY());

    				imageLevels = null;

    				graphics = null;

    			}

    			it.closeIterator();

    			if (bSymbolLevelError) {

    				((IVectorLegend) getLegend()).setZSort(null);

    			}

    		} catch (ReadDriverException e) {

    			this.setVisible(false);

    			this.setActive(false);

    			throw e;

    		}

    	}

	private boolean isNotSame(ICoordTrans trans) {

    	String from_abb = trans.getPOrig().getAbrev(); 

    	String to_abb = trans.getPDest().getAbrev();

    	return (from_abb.compareTo(to_abb) != 0);

	}

	private String[] appendAtringArrays(String[] arr1, String[] arr2) {

    	int len = arr1.length + arr2.length;

    	String[] resp = new String[len];

    	int i = 0;

    	for (i=0; i<arr1.length; i++) resp[i] = arr1[i];

    	for (i=0; i<arr2.length; i++) resp[arr1.length+i] = arr2[i];

		return resp;

	}

	/**

     *

     */

    public void draw(BufferedImage image, Graphics2D g, ViewPort viewPort,

        Cancellable cancel, double scale) throws ReadDriverException {

    	_draw(image, g, viewPort, cancel, scale);

    }

    private class AvoidGeometryAndIdFeatureIterator implements IFeatureIterator {

    	private ArrayList featArray;

    	private int index = 0;

    	private int size = 0;

    	private int noToAvoid = 0;

    	public AvoidGeometryAndIdFeatureIterator(ArrayList arr, int navoided) {

    		featArray = arr;

    		size = arr.size();

    		index = 0;

    		noToAvoid = navoided;

    	}

		public void closeIterator() throws ReadDriverException {

    		index = 0;

		}

		public boolean hasNext() throws ReadDriverException {

			return (index < size);

		}

		public IFeature next() throws ReadDriverException {

			index++;

			if (index > size) {

				logger.error("Out of index in AuxFeatureIterator: " + (index-1));

				return null;

			} else {

				IFeature resp = (IFeature) featArray.get(index-1);

				Value[] oldatts = resp.getAttributes();

				Value[] newatts = new Value[oldatts.length - noToAvoid];

				for (int i=0; i<newatts.length; i++) newatts[i] = oldatts[i + noToAvoid];

				resp.setAttributes(newatts);

				return resp;

			}

		}

    }