Application: gvSIG desktop » gvSIG Document Layout

 * no MapControl is used in current implementation, but a similar behavior

 * is simulated by the FFrameView. The original MapContext is cloned when

 * assigned to the FFrameView, which is then used for drawing.

 * The FFrameView and the associated View can be synchronized, depending

 * on the values of {@link #getTypeScale()} and {@link #getLinked()}.

 * {@link OwnMapContextListener} and {@link ViewDocListener}. The first one

 * listens for events on the FFrameView and synchronizes the View accordingly.

 * The second one listens for events on the View and synchronizes the FFrameView

 * accordingly. There synchronization process is flagged using

 * {@link #b_updating} and {@link #b_updating}, in order

 * @author Vicente Caballero Navarro

 * @author Cesar Martinez Izquierdo

 */

    private static final String LAYER_SYNC_FIELD = "layerSync";

    private static final String EXTENT_SYNC_FIELD = "extentSync";

    private static final String SCALE_TYPE_FIELD = "scaleType";

    private static final String EXTENSION_FIELD = "extension";

    private static final String BLINKED_FIELD = "bLinked";

    private static final String MODE_FIELD = "mode";

	/**

	 * When we load a FFrameview from project, it will receive a wrong

	 * extentChanged event the first time the View is painted, so we must

	 */

	private boolean b_frameInitialized = true;

        num++;

        createListeners();

    }

    protected void createListeners() {

    	viewDocListener = new ViewDocListener();

    	ownMapContextListener = new OwnMapContextListener();

    /**

     * Returns a description of the FFrame

     * @return Description.

     */

    public String toString() {

    /**

     * Sets the scale of the MapContext contained in this FFrameView

     * @param d Scale to be set

     */

    public void setScale(double d) {

    /**

     * Sets a new Envelope on the MapContext contained in

     * this FFrameView

     * @param r Envelope to be set

     */

    public void setNewEnvelope(Envelope r) {

    	getMapContext().getViewPort().setEnvelope(r);

    	updateScaleCtrl();

    }

    /**

     * Calculates the resolution (measured on dots per inch, DPI) to be

     * considered to draw the FFrameView on screen. It is calculated by

    	if (getLayoutContext()!=null) {

    		at = getLayoutContext().getAT();

    	}

    }

    /**

     * usually a clone of the associated View. This MapContext

     * may be synchronized with the View one, depending on the

     * scale type that has been set (see {{@link #getTypeScale()}.

     * @return The mapContext object

     */

    public MapContext getMapContext() {

     * Valid values include {@link #DRAFT} and {@link #PRESENTATION}.

     * Draft will disable the frame normal drawing, which will be

     * replaced by an empty rectangle only showing the name of the

     * @param q Integer representing the quality.

     */

    public void setQuality(int q) {

     * Valid values include {@link #DRAFT} and {@link #PRESENTATION}.

     * Draft will disable the frame normal drawing, which will be

     * replaced by an empty rectangle only showing the name of the

     * @param q The selected quality

     */

    public int getQuality() {

    /**

     * Sets the MapContext associated with this FFrameView, which will

     * be used to clone the layers and synchronize the FFrameView with

     * @param viewMapContext

     */

    public void setViewMapContext(MapContext viewMapContext) {

     * Sets the View associated with this FFrameView, which will

     * be used to clone the MapContext and the layers. It will

     * also used to synchronize the FFrameView with

     * @param viewMapContext

     */

    public void setView(ViewDocument dvd) {

    /**

     * Gets the associated View

     * @return The associated view

     * @see {@link #setView(ViewDocument)}

     */

    /**

     * Draws the FFrameView on the provided Graphics, according to the

     * provided affine transform and the visible rectangle.

     * @param g Graphics2D

     * @param at Affine transform to translate sheet coordinates (in cm)

     * 				to screen coordinates (in pixels)

        		} else {

        			drawDraft(g);

        	}

        }

            grid.draw(g, at, visibleLayoutDocRect, imgBase);

    }

    private void drawMessage(Graphics2D g, String msg) {

        Rectangle2D r = getBoundingBox(null);

        g.setColor(Color.lightGray);

        g.fillRect((int) r.getX(), (int) r.getY(), (int) r.getWidth(),

    /**

     * Gets the visible envelope, in map coordinates

     * @param fframeViewRect Rectangle defining the bounding box of the

     * FFrameView, in screen coordinates

     * @param visiblefframeViewRect Rectangle defining the bounding box

    	Envelope oldEnv = getMapContext().getViewPort().getAdjustedEnvelope();

    	double widthFactor = ((int)visiblefframeViewRect.width) / fframeViewRect.width;

    	double heightFactor = ((int)visiblefframeViewRect.height) / fframeViewRect.height;

    	double newWidth = oldEnv.getLength(0)*widthFactor;

    	double newHeight = oldEnv.getLength(1)*heightFactor;

        double translateX = visiblefframeViewRect.x - fframeViewRect.x;

        double translateY = visiblefframeViewRect.y - fframeViewRect.y;

        double translateFactorX = translateX / fframeViewRect.width;

        double translateFactorY = translateY / fframeViewRect.height;

        double newX = oldEnv.getMinimum(0) + translateFactorX*oldEnv.getLength(0);

        double newMaxY =  oldEnv.getMaximum(1) - translateFactorY*oldEnv.getLength(1);

        double newMaxX = newX + newWidth;

			logger.error("Error calculating visible extent", e);

		}

        return newEnv;

    }

    protected void drawPresentation(

        Graphics2D g,

        AffineTransform affineTransform,

        Rectangle2D.Double fframeViewRect,

        Rectangle2D.Double visibleRect,

        BufferedImage imgBase) throws Exception {

    	b_drawing = true;

    	int drawWidth = (int)visibleRect.width;

    	int drawHeight = (int)visibleRect.height;

        	getMapContext().getViewPort().setImageSize(new Dimension(drawWidth, drawHeight));

        	getMapContext().getViewPort().refreshExtent();

        }

        // map origin should be calculated using the full fframeview, as the visible position will be relative

        Point mapOrigin = new Point((int)fframeViewRect.getMinX(), (int)fframeViewRect.getMaxY());

        //Draw the created image

        drawImage(g, m_image, visibleRect);

        if (oldEnvelope!=null) {

        	// restore real envelope and image size

        	getMapContext().getViewPort().setImageSize(new Dimension((int)fframeViewRect.width, (int) fframeViewRect.height));

        	getMapContext().getViewPort().setEnvelope(oldEnvelope);

        }

        scaleAnt = affineTransform.getScaleX();

        origin = mapOrigin;

        b_drawing = false;

    }

    protected void createImage(AffineTransform affineTransform,

    		int width, int height, Point mapOrigin) throws ReadException, MapContextException {

    	ViewPort viewPort = this.getMapContext().getViewPort();

    			!origin.equals(mapOrigin) ||

    			affineTransform.getScaleX() != scaleAnt ||

    			m_image == null ||

    		viewPort.setDPI(getDrawPaperDPI());

            m_image =

                    new BufferedImage(

                    		width,

            getMapContext().draw(m_image, gimg, getScale());

            gimg.dispose();

            b_validCache = true;

    }

    protected void drawImage(Graphics2D g, BufferedImage image,

    		Rectangle2D.Double visibleRectangle) {

            		(int)visibleRectangle.width,

            		(int)visibleRectangle.height);

        }

        		(int) visibleRectangle.x,

        		(int) visibleRectangle.y,

    }

    protected void preDraw(Graphics2D g, Rectangle2D.Double fframeViewRect, Rectangle2D.Double visibleRect){

    	originalGraphicsAT = (AffineTransform) g.getTransform().clone();

        if (g.getClipBounds() != null) {

            originalClip = (Rectangle) g.getClipBounds().clone();

        }

        g.setClip((int) visibleRect.getMinX(), (int) visibleRect.getMinY(),

            (int) visibleRect.getWidth(), (int) visibleRect.getHeight());

    }

    protected void postDraw(Graphics2D g, Rectangle2D.Double fframeViewRect, AffineTransform at){

    	g.setTransform(originalGraphicsAT);

        if (getMapContext() != null) {

        }

        if (originalClip != null) {

            g.setClip(originalClip.x, originalClip.y, originalClip.width, originalClip.height);

    }

    /**

     * @deprecated Use {@link #postDraw(Graphics2D, java.awt.geom.Rectangle2D.Double, AffineTransform)} instead.

     */

    @Deprecated

    protected void postDraw(Graphics2D g, Rectangle2D.Double rectangleLayout, Rectangle2D rectangleView, BufferedImage imgBase, Rectangle originalClip, AffineTransform at) {

    	postDraw(g, rectangleLayout, at);

    }

    /**

     * @deprecated Use {@link #preDraw(Graphics2D, java.awt.geom.Rectangle2D.Double, java.awt.geom.Rectangle2D.Double) instead

     */

    public void print(Graphics2D g, AffineTransform at, Geometry geom,

        PrintAttributes printAttributes) {

        preDraw(g, rectangleLayout, rectangleLayout);

        print(g, at, printAttributes);

        postDraw(g, rectangleLayout, at);

        if (showGrid && grid != null) {

            grid.print(g, at, geom, printAttributes);

    }

    protected void print(Graphics2D g, AffineTransform at, PrintAttributes printAttributes) {

        Rectangle2D.Double layoutRectangle = getBoundingBox(at);

        // FIXME: should we clone the mapcontext and viewport before printing ??

        // otherwise we will probably have unexpected results if the user modifies

        // the layout while printing (answer: not an issue at the moment as printing is

        // a blocking operation)

        ViewPort viewPort = this.getMapContext().getViewPort();

        Point2D old_offset = viewPort.getOffset();

        Dimension old_imgsize = viewPort.getImageSize();

        double oldDpi = viewPort.getDPI();

        viewPort.setOffset(new Point2D.Double(layoutRectangle.x, layoutRectangle.y));

        viewPort.setImageSize(new Dimension((int) layoutRectangle.width, (int) layoutRectangle.height));

        double dpi = PrintAttributes.PRINT_QUALITY_DPI[printAttributes.getPrintQuality()];

            g.fillRect((int) layoutRectangle.x, (int) layoutRectangle.y, viewPort

                    .getImageWidth(), viewPort

                    .getImageHeight());

        //Print the map

        try {

            this.getMapContext().print(g, getScale(), printAttributes);

            NotificationManager.addError(e.getMessage(), e);

        } catch (MapContextException e) {

            NotificationManager.addError(e.getMessage(), e);

        // Restore offset, imgsize

        viewPort.setOffset(old_offset);

        viewPort.setImageSize(old_imgsize);

    /**

     * Rellena la unidad de medida en la que est? la vista.

     * @param i

     *            entero que representa la unidad de medida de la vista.

     */

    /**

     * Obtiene la unidad de medida en la que est? la vista.

     * @return Unidad de medida.

     */

    public int getMapUnits() {

    /**

     * Devuelve la escala seg?n el tipo de escala que se haya seleccionado al

     * a?adida la vista.

     * @return escala.

     */

    public long getScale() {

    /**

     * Inserta la imagen para repintar el FFrameView.

     * @param bi

     *            Imagen para repintar.

     */

    /**

     * Devuelve la imagen para repintar.

     * @return Imagen para repintar.

     */

    public BufferedImage getBufferedImage() {

    /**

     * Devuelve la MAtriz de transformaci?n utilizada por la FFrameView.

     * @return MAtriz de transformaci?n.

     */

    public AffineTransform getATMap() {

    /**

     * Inserta la matriz de transformaci?n.

     * @param transform

     *            Matriz de transformaci?n.

     */

    /**

     * Inserta el proyecto.

     * @param p

     *            Proyecto.

     */

    /**

     * DOCUMENT ME!

     * @param arg0

     *            DOCUMENT ME!

     * @return DOCUMENT ME!

     */

    public boolean compare(Object arg0) {

        }

        return true;

    }

    public void updateScaleCtrl() {

    	NewStatusBar statusbar = PluginServices.getMainFrame().getStatusBar();

    	MapContext mapContext = this.getMapContext();

    	}

    	statusbar.setMessage("units",

    			PluginServices.getText(this, mapContext.getDistanceName()));

    	if (fixedScale!=null && getScaleType()==SCALE_TYPE.FIXED_SCALE) {

    		// prefer fixedScale as getScaleView() may offer slight differences

    		// because the influence of the adjusted envelope

    public static void registerPersistent() {

        PersistenceManager manager = ToolsLocator.getPersistenceManager();

            DynStruct definition =

                manager.addDefinition(FFrameView.class,

                    PERSISTENCE_DEFINITION_NAME,

        	syncLayers = true;

        }

        Double layoutScale = null;

        	layoutScale = state.getDouble(SCALE_FIELD);

        }

        if (state.hasValue(SCALE_TYPE_FIELD)) {

        	int value = state.getInt(SCALE_TYPE_FIELD);

        if (state.hasValue(HAS_TOC_FIELD)) {

        	this.b_hasToc = state.getBoolean(HAS_TOC_FIELD);

        }

        // When copying and pasting layout documents (in project manager), the view

        // is first persisted (copy action) and then re-created from persistence (paste action).

        // This is a problem, as the re-created view is not the same view as the original one

        	if (layoutScale!=null) {

        		getMapContext().setScaleView(layoutScale.longValue());

        	}

        	if (this.getLayoutContext()!=null) {

        		this.getLayoutContext().setTocModel(getMapContext());

        	}

        		state.set(SCALE_FIELD, (double)fixedScale);

        	}

        	else {

        	}

        	if (scaleType == SCALE_TYPE.FIXED_EXTENT) {

        		if (fixedExtent==null) {

        	}

        	else {

        		state.set(ENVELOPE_FIELD, getMapContext().getViewPort()

        	}

        }

        state.set(SHOWGRID_FIELD, showGrid);

        state.set(GRID_FIELD, grid);

    }

    @Override

    public void setBoundBox(Rectangle2D r) {

    	super.setBoundBox(r);

    		updateScaleCtrl();

    		refresh();

    	}

    /**

     * Gets the rotation of the frame

     * @return Rotation in degrees

     */

    public double getMapRotation() {

        return 0;

    }

	protected void invalidateLayout() {

		b_validCache = false;

		if (getLayoutContext()!=null) {

			getLayoutContext().notifAllObservers();

		}

                new DefaultLayoutNotification(LayoutNotification.LAYOUT_REFRESH));

	}

	protected void invalidateToc() {

		if (getLayoutContext()!=null) {

			getLayoutContext().notifyTocUpdated(TocModelChangedNotification.Type.ITEM_UPDATED);

		}

	}

	protected void refreshToc() {

		if (getLayoutContext()!=null) {

			getLayoutContext().notifyTocUpdated(TocModelChangedNotification.Type.MODEL_CHANGED);

	}

	public void refresh() {

		b_validCache = false;

	}

    protected void resetListeners() {

		if (this.getMapContext()!=null) {

			clearOwnListeners(this.getMapContext());

		}

    	setListeners();

    }

    protected void setListeners() {

    	if (getView()!=null) {

    		if (syncLayers) {

    	mapContext.getLayers().removeLayerCollectionListener(viewDocListener);

    	mapContext.removeAtomicEventListener(viewDocListener);

    }

    /*

     * (non-Javadoc)

     * @see org.gvsig.tools.dispose.Disposable#dispose()

		setTocModel();

		updateScaleCtrl();

	}

	public void setHasToc(boolean hasToc) {

		this.b_hasToc = hasToc;

		setTocModel();

	}

	protected void setTocModel() {

		if (getLayoutContext()!=null) {

			if (b_hasToc && getMapContext()!=null) {

			}

		}

	}

	@Override

	protected void doSetSelected(int selectedStatus) {

		boolean oldSelectedStatus = isSelected();

			updateScaleCtrl();

		}

	}

	public boolean getLayerSynced() {

		return syncLayers;

	}

		syncExtents = synced;

        resetListeners();

	}

	/**

	 * Returns true if the newEnvelope represents a pan operation on oldEnvelope,

	 * (both extents have the same height and width)

		if (oldEnvelope!=null && newEnvelope!=null) {

			double toleranceX = 0.00000001*Math.min(oldEnvelope.getLength(0), newEnvelope.getLength(0));

			double toleranceY = 0.00000001*Math.min(oldEnvelope.getLength(1), newEnvelope.getLength(1));

			// (we use tolerance to avoid direct comparison of double values)

			if ( ((oldEnvelope.getLength(0)-newEnvelope.getLength(0))<toleranceX)

					&& ((oldEnvelope.getLength(1)-newEnvelope.getLength(1))<toleranceY) ) {

		}

		return false;

	}

	/**

	 * Calculates the new extent for the FFrame. It is necessary to avoid

	 * scale changes when a pan is triggered from the view, as the different

	 * size factors from View/FFrameView introduces scale changes even for

	 * pans

	 * @param newEnvelope

	 * @return

	 */

		Envelope oldViewEnvelope = null;

		try {

			if (getView().getMapContext().getViewPort().getEnvelopes().hasPrevious()) {

				oldViewEnvelope = GeometryLocator.getGeometryManager().createEnvelope(r.getMinX(), r.getMinY(), r.getMaxX(), r.getMaxY(), SUBTYPES.GEOM2D);

			}

			if (isPan(oldViewEnvelope, newEnvelope)) {

					else {

						getMapContext().getViewPort().setEnvelope(calculateNewExtent());

						if (scaleType==SCALE_TYPE.FIXED_SCALE) {

							getView().getMapContext().getViewPort().setEnvelope(getMapContext().getViewPort().getAdjustedEnvelope());

						}

						updateScaleCtrl();

					}

				}

				b_updating = false;

		}

		public void backColorChanged(ColorEvent e) {

				invalidateLayout();

				// the view should also receive the event and update automatically

				b_updating = false;

		}

		public void legendChanged(LegendChangedEvent e) {

				updateScaleCtrl();

				invalidateLayout();

				b_updating = false;

		}

		public void backColorChanged(ColorEvent e) {

				try {

					b_updating = true;

					fullExtent();

				} catch (ReadException e1) {

				} finally {

					b_updating = false;

	public void setScaleType(SCALE_TYPE scaleType) {

		this.scaleType = scaleType;

	}

	public void setScaleType(SCALE_TYPE scaleType, double fixedScale) {

		if (scaleType == SCALE_TYPE.FIXED_SCALE) {

			this.scaleType = scaleType;

			setScale(fixedScale);

		}

	}

	public void setScaleType(SCALE_TYPE scaleType, Envelope fixedExtent) {

		if (scaleType == SCALE_TYPE.FIXED_EXTENT) {

			this.scaleType = scaleType;

			// as the control instance is shared for all the windows

			updateScaleCtrl();

		}

	}

	public void windowClosed() {