Application: gvSIG desktop

import javax.print.attribute.PrintRequestAttributeSet;

import javax.print.attribute.standard.PrintQuality;

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

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

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

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

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

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

	}

		double originalSize = getSize();

		double size=originalSize;

		// scale it to size

		return mask;

	}

	}

	public final void setMask(IMask mask) {

import javax.print.attribute.PrintRequestAttributeSet;

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

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

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

	}

	public void drawInsideRectangle(Graphics2D g,

		double myWidth =  (r.getWidth()/3);

		Rectangle rect = new Rectangle(0, r.y, (int) myWidth, r.height);

		if (marker != null) {

			g.translate(r.x, r.y);

			g.translate(-(r.x), -(r.y));

		}

		if (line != null) {

			g.translate(r.x+myWidth, r.y);

			g.translate(-(r.x+myWidth), -(r.y));

		}

		if (fill != null) {

			g.translate(r.x+myWidth+myWidth, r.y);

			g.translate(-(r.x+myWidth+myWidth), -(r.y));

		}

		return getClass().getName();

	}

		switch (shape.getShapeType()) {

		case FShape.POINT: //Tipo punto

        case FShape.POINT + FShape.Z:

import javax.print.attribute.PrintRequestAttributeSet;

import javax.print.attribute.standard.PrintQuality;

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

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

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

		color = new Color(color.getRed(), color.getGreen(), color.getBlue(), outlineAlpha);

	}

		final int hGap = (int) (r.getWidth() * 0.1); // the left and right margins

		final int vPos = 1; 						 // the top and bottom margins

		final int splitCount = 3; 					 // number of lines

		}

		try {

		} catch (Exception e) {

			throw new SymbolDrawingException(SymbolDrawingException.UNSUPPORTED_SET_OF_SETTINGS);

		}

	public void print(Graphics2D g,

			  AffineTransform at,

			  FShape shape,

		double originalSize = getLineWidth();

		double size=originalSize;

		// scale it to size

import java.awt.Rectangle;

import java.awt.geom.AffineTransform;

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

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

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

	 * rectangles. For example, think about rendering a Label with size

	 * in meters => You will need to specify a size in pixels.

	 * Of course, you can also to choose to render a prepared image, etc.

	 * @param scaleInstance

	 * @param r

	 * @throws SymbolDrawingException TODO

	 */

}

import javax.print.attribute.PrintRequestAttributeSet;

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

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

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

		g.rotate(-rotation, p.getX(), p.getY());

	}

		g.rotate(rotation, r.getCenterX(), r.getCenterY());

		for (int i = 0; i < layers.length; i++) {

		}

		g.rotate(-rotation, r.getCenterX(), r.getCenterY());

	}

	}

		for (int i = 0; i < layers.length; i++) {

			layers[i].print(g, at, shape, properties);

		}

import javax.print.attribute.PrintRequestAttributeSet;

import javax.print.attribute.standard.PrintQuality;

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

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

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

	private boolean autoresize;

	private Rectangle bounds = null;

	private FShape horizontalTextWrappingShape = null;

	public void draw(Graphics2D g, AffineTransform affineTransform, FShape shp, Cancellable cancel) {

		if (!isShapeVisible()) return;

		g.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);

		g.setColor(textColor);

		g.setFont(font);

		g.translate(((FPoint2D) shp).getX(), ((FPoint2D) shp).getY());

		// Alineamos el texto de manera que la parte superior

		// izquierda de la primera letra est? en (0,0).

		g.drawString(getText(), 0, (int)-bounds.getY());

		g.rotate(-rotation);

		g.translate(-((FPoint2D) shp).getX(), -((FPoint2D) shp).getY());

	}

	public void drawInsideRectangle(Graphics2D g,

		int s = getFont().getSize();

		if (autoresize) {

		//Only for debugging purpose

//		g.drawRect((int)r.getX(), (int)r.getY(), (int)r.getWidth(), (int)r.getHeight());

	}

	public int getOnePointRgb() {

		return getClass().getName();

	}

	}

import javax.print.attribute.PrintRequestAttributeSet;

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

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

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

	}

	public void drawInsideRectangle(Graphics2D g,

		for (int i = 0; i < layers.length; i++) {

		}

	}

		}

	}

		for (int i = 0; i < layers.length; i++) {

			layers[i].print(g, at, shape, properties);

		}

import javax.print.attribute.PrintRequestAttributeSet;

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

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

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

		}

	}

		for (int i = 0; i < layers.length; i++) {

		}

	}

		}

	}

		for (int i = 0; i < layers.length; i++) {

			layers[i].print(g, at, shape, properties);

		}

import javax.print.attribute.PrintRequestAttributeSet;

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

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

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

	}

	public void drawInsideRectangle(Graphics2D g,

		Rectangle rect = new Rectangle(r.x, r.y, r.width, r.height);

		rect.setFrame(((int) rect.getMinX())+1, ((int) rect.getMinY())+1, ((int) rect.getWidth())-2, ((int) rect.getHeight())-2);

		FShape shp = new FPolygon2D(new GeneralPathX(rect));

		}

		if (getOutline() != null && hasOutline())

	}

	public String getClassName() {

			setHasOutline(xml.getBooleanProperty("hasOutline"));

	}

		Color c = getFillColor();

		if (c!=null && hasFill()) {

			g.setColor(c);

	}

	public void drawInsideRectangle(Graphics2D g,

		g.setColor(getColor());

		g.setStroke(getLineStyle().getStroke());

	}

	public String getClassName() {

import javax.print.attribute.PrintRequestAttributeSet;

public interface IPrintable {

	public void print(Graphics2D g,

					  AffineTransform at,

					  FShape shape,

}

        point.transform(at);

        FShape shapeAux = new FPoint2D(point.getCurrentPoint());

        // FGraphicUtilities.DrawShape(g, at, shapeAux, symbol);

    }

    }

    public void print(Graphics2D g, AffineTransform at, ISymbol symbol,PrintRequestAttributeSet properties) {

    	FShape shapeAux =getShape(at);

    }

    /**

     * DOCUMENT ME!

	public void print(Graphics2D g, AffineTransform at, ISymbol symbol, PrintRequestAttributeSet properties) {

		FShape shapeAux=getShape(at);

	}

}

import java.awt.geom.Ellipse2D;

import java.io.File;

import javax.swing.JFrame;

import javax.swing.JPanel;

			return new MultiShapeSymbol();

		} else if (shapeType == FShape.NULL){

			return null;

		throw new Error("shape type not yet supported");

	}

					super.paintComponent(g);

					Graphics2D g2 = (Graphics2D)g;

					try {

					} catch (SymbolDrawingException e) {

						// TODO Auto-generated catch block

						e.printStackTrace();

		public void draw(Graphics2D g, AffineTransform affineTransform,

				FShape shp, Cancellable cancel) {

			try {

			} catch (SymbolDrawingException e) {

				// IMPOSSIBLE

			}

		}

		public void drawInsideRectangle(Graphics2D g,

				throws SymbolDrawingException {

			g.setClip(r);

			if (message == null) {

					(int) lineHeight);

			for (int i =0; i < messageLines.length; i++) {

				text.setText(messageLines[i]);

				textRect.setLocation((int) r.getX(), (int) (r.getY()+r.getHeight()));

			}

		}

		return true;

	}

		FGraphicUtilities.DrawSymbol(g2, scaleInstance, r, this);

	}

	 * @throws IOException

	 * @throws DriverIOException

	 */

			int previousExpansionFileIndex, int sourceType) throws EditionCommandException  {

		if (previousExpansionFileIndex == -1) {

				throw new EditionCommandException(writer.getName(),e);

			}

			if (cancel)

			// Se elimina de las relaciones y del fichero de expansi?n

			relations.remove(new Integer(geometryIndex));

			expansionFile.deleteLastRow();

				throw new EditionCommandException(writer.getName(),e);

			}

			if (cancel)

			// Se actualiza la relaci?n de ?ndices

			relations.put(new Integer(geometryIndex), new Integer(

					previousExpansionFileIndex));

		}

		//fireAfterModifyRow(geometryIndex, sourceType);

	}

	/**

		} else {

			// Obtenemos el ?ndice en el fichero de expansi?n

			int num = ((Integer) relations.get(integer)).intValue();

			// Obtenemos la geometr?a para actualiza el ?ndice

			// espacialposteriormente

				this.fmapSpatialIndex.delete(rAnt, new Integer(calculatedIndex));

				this.fmapSpatialIndex.insert(r, new Integer(calculatedIndex));

			}

		}

		isFullExtentDirty = true;

		fireAfterModifyRow(calculatedIndex, sourceType);

	 * @throws IOException

	 * @throws DriverIOException

	 */

			int previousExpansionFileIndex, int sourceType) throws EditionCommandException{

		try {

			// Llega el CalculatedIndex

				boolean cancel = fireBeforeModifyRow(df, calculatedIndex,

						sourceType);

				if (cancel)

				IGeometry g = df.getGeometry();

				// IGeometry g = ova.getShape(calculatedIndex);

				Rectangle2D r = g.getBounds2D();

				boolean cancel = fireBeforeModifyRow(df, calculatedIndex,

						sourceType);

				if (cancel)

				if (sourceType == EditionEvent.GRAPHIC) {

					g = df.getGeometry();

					System.out.println("Actual: " + g.toString());

				}

				// Se actualiza la relaci?n de ?ndices

				// Integer integer = new Integer(geometryIndex);

				relations.put(new Integer(calculatedIndex), new Integer(

						previousExpansionFileIndex));

			}

		} catch (ReadDriverException e) {

			throw new EditionCommandException(writer.getName(),e);

		}

		//fireAfterModifyRow(calculatedIndex, sourceType);

	}

	/**

    void startComplexRow();

    void endComplexRow(String description);

    public IRow doRemoveRow(int index, int sourceType) throws ReadDriverException, ExpansionFileReadException;

    public int doModifyRow(int index, IRow feat, int sourceType) throws ExpansionFileWriteException, ReadDriverException, ExpansionFileReadException;

    public int doAddRow(IRow feat, int sourceType) throws ReadDriverException, ExpansionFileWriteException;

		fireAfterRemoveRow(calculatedIndex, sourceType);

	}

		try {

		if (previousExpansionFileIndex == -1) {

	            //Se obtiene la geometr?a para actualizar el ?ndice

				IGeometry gAnt = dfAnt.getGeometry();

	            boolean cancel = fireBeforeModifyRow(dfAnt,calculatedIndex, sourceType);

	    		if (cancel)

	            Rectangle2D rAnt = gAnt.getBounds2D();

	            this.fmapSpatialIndex.delete(r, new Integer(calculatedIndex));

	            this.fmapSpatialIndex.insert(rAnt, new Integer(calculatedIndex));

	            g = df.getGeometry();

	            Rectangle2D r = g.getBounds2D();

	            this.fmapSpatialIndex.delete(r, new Integer(calculatedIndex));

	            //Se actualiza la relaci?n de ?ndices

	            relations.put(new Integer(calculatedIndex),

	                new Integer(previousExpansionFileIndex));

	            df=(DefaultFeature)getRow(inverse).getLinkedRow();

	            boolean cancel = fireBeforeModifyRow(df,calculatedIndex, sourceType);

	    		if (cancel)

	            g = df.getGeometry();

	            r = g.getBounds2D();

	            this.fmapSpatialIndex.insert(r, new Integer(calculatedIndex));

	    		if (mapping.getColumnRotate()==mapping.getColumnText()){

	    			label.setRotation(((NumericValue)value).doubleValue());

	    		}

	        }

		}  catch (ReadDriverException e) {

			throw new EditionCommandException(writer.getName(),e);

		}

		fireAfterModifyRow(calculatedIndex, sourceType);

	}

	public void undoRemoveRow(int index, int sourceType) throws EditionCommandException {

	 * @see com.iver.cit.gvsig.fmap.edition.Command#undo()

	 */

	public void undo() throws EditionCommandException {

	}

	/**

	 * @throws DriverIOException

	 */

	public void redo() throws EditionCommandException {

		try {

		} catch (ExpansionFileWriteException e) {

			throw new EditionCommandException(efs.getWriter().getName(),e);

		} catch (ReadDriverException e) {

					Rectangle textRect = new Rectangle(x, y, width, height);

					Shape oldClip = graphics.getClip();

					graphics.setClip(textRect);

					graphics.setClip(oldClip);

				}

			}

			if (texts != null && texts.length>0)

				getTextSymbol().setText(texts[0]);

		}

	}

	private boolean useFixedSize;

	private boolean useFixedColor;

	private int referenceSystem;

	private double  printDPI;

	private Font font;

	private Color colorFont;

	private String rotationFieldName;

	private String heightFieldName;

	private String colorFieldName;

	public ILabelingMethod getLabelingMethod() {

		return this.method;

					for (int j = 0; j < aux.length; j++) {

						FPoint2D p = new FPoint2D(aux[j].getOrig());

						p.transform(viewPort.getAffineTransform());

					}

	}

	public void print(Graphics2D g, ViewPort viewPort, Cancellable cancel, PrintRequestAttributeSet properties) throws ReadDriverException {

		draw(null, g, viewPort, cancel, printDPI);

	}

	public void setUsesFixedSize(boolean b) {

		   this.sourceProjection != null &&

		   this.targetProjection.getAbrev() != this.sourceProjection.getAbrev()){

			ICoordTrans trans = targetProjection.getCT(sourceProjection);

		}

		this.rect = rect;

	}

	 */

	public String getStringFieldValue(int rowIndex, int fieldId)

			throws UnsupportedEncodingException {

		int fieldOffset = myHeader.getFieldDescription(fieldId).myFieldDataAddress;

		byte[] data = new byte[myHeader.getFieldLength(fieldId)];

		if (rowIndex != posActual) {

		cachedRecord.get(data);

		return new String(data, chars.name());

	}