/ - Diff - gvSIG Document Layout - gvSIG

Revision 141

             double wcm,
             double wpixels) {
             double dpi = wpixels / wcm * 2.54;
             double dpi = (2.54*wpixels) / wcm;
             IProjection proj = viewPort.getProjection();
             if (viewPort.getAdjustedEnvelope() == null) {

         public void setLayoutContext(LayoutContext lc) {
             layoutContext = lc;
             layoutContext.addObserver(this);
             fullRect();
+        }
         /**
-...
                 Graphics gimgRuler = imgRuler.getGraphics();
                 clipVisibleRect((Graphics2D) gimag);
                 if (initial) {
                     fullRect();
                     initial = false;
+                }
                 // moved to initialize()
     //            if (initial) {
     //                fullRect();
     //                initial = false;
     //            }
                 try {
                     layoutDraw.drawLayout((Graphics2D) gimag, img);

         private static final String TYPESCALE_FIELD = "typeScale";
         private static final String EXTENSION_FIELD = "extension";
         private static final String QUALITY_FIELD = "quality";
         private static final String VIEWING_FIELD = "viewing";
         private static final String BLINKED_FIELD = "bLinked";
         private static final String MAPUNITS_FIELD = "mapUnits";
         private static final String SCALE_FIELD = "scale";
-...
         protected int typeScale = AUTOMATICO;
         protected int extension = 0;
         protected int quality = PRESENTATION;
         protected int viewing = 0;
         protected boolean linked = true;
         protected ViewDocument viewDocument = null;
         protected MapContext mapContext = null;
-...
             refresh = true;
             mapScale =
                 FLayoutUtilities.getScaleView(getMapContext().getViewPort(),
                     getBoundBox().width, getBoundingBox(null).width
                         / getBoundBox().width);
                     getBoundBox().width, getBoundingBox(null).width);
             updateScaleCtrl();
+        }
         /**
          * Calculates the resolution (measured on dots per inch, DPI) to be
          * considered to draw the FFrameView on screen. It is calculated by
          * dividing the width (in pixels) of the FFrame divided by the width
          * in inches of the paper.
          */
         protected double getDrawPaperDPI() {
         	return (2.54*getBoundingBox(null).width)/getBoundBox().width;
+        }
         /**
          * Devuelve el FMap de la vista o una clonaci?n de este si se utiliza una
-...
+        }
         /**
          * Devuelve un entero que representa la forma en que se actualiza la vista.
+         *
          * @return forma que se actualiza la vista.
          */
         public int getViewing() {
             return viewing;
+        }
         /**
          * Rellena la forma de actualizar la vista(cuando activo o siempre). De
          * momento esta opci?n esta deshabilitada.
+         *
          * @param v
          *            entero que representa la forma de actualizar la vista.
          */
         public void setViewing(int v) {
             viewing = v;
+        }
         /**
          * Inserta el ProjectView de donde obtener las propiedades de la vista a
          * mostrar.
+         *
-...
+        }
         /**
          * M?todo que dibuja sobre el graphics que se le pasa como par?metro, seg?n
          * la transformada afin que se debe de aplicar y el rect?ngulo que se debe
          * de dibujar.
          * Draws the FFrameView on the provided Graphics, according to the
          * provided affine transform and the visible rectangle.
+         *
          * @param g
          *            Graphics2D
          * @param at
          *            Transformada af?n.
          * @param rectangleView
          *            rect?ngulo sobre el que hacer un clip.
          * @param imgBase
          *            Imagen para acelerar el dibujado.
          * @param g Graphics2D
          * @param at Affine transform to translate sheet coordinates (in cm)
          * 				to screen coordinates (in pixels)
          * @param visibleLayoutDocRect visible rectangle
          * @param imgBase Image used to speed up the drawing process
          */
         public void draw(Graphics2D g, AffineTransform at, Rectangle2D rectangleView, BufferedImage imgBase) {
             Rectangle2D.Double rectangleLayout = getBoundingBox(at);
             Rectangle originalClip = preDraw(g, rectangleLayout);
             if (intersects(rectangleView, rectangleLayout)) {
         public void draw(Graphics2D g, AffineTransform at, Rectangle2D visibleLayoutDocRect, BufferedImage imgBase) {
             Rectangle2D.Double fframeViewRect = getBoundingBox(at);
             Rectangle originalClip = preDraw(g, fframeViewRect);
             if (intersects(visibleLayoutDocRect, fframeViewRect)) {
                 if (getMapContext() == null) {
                     drawEmpty(g);
                 } else {
-...
                     } else {
                         if (getQuality() == PRESENTATION) {
                             try {
                                 drawPresentation(g, at, rectangleLayout, rectangleView, imgBase);
                                 drawPresentation(g, at, fframeViewRect, visibleLayoutDocRect, imgBase);
                             } catch (Exception exc) {
                                 drawMessage(g, FLayoutFunctions.getLastMessage(exc));
+                            }
-...
+                    }
+                }
+            }
             postDraw(g, rectangleLayout, rectangleView, imgBase, originalClip, at);
             postDraw(g, fframeViewRect, visibleLayoutDocRect, imgBase, originalClip, at);
             if (showGrid && grid != null) {
                 grid.draw(g, at, rectangleView, imgBase);
                 grid.draw(g, at, visibleLayoutDocRect, imgBase);
+            }
+        }
-...
         protected void drawPresentation(
             Graphics2D g,
             AffineTransform affineTransform,
             Rectangle2D.Double rectangleLayout,
             Rectangle2D rectangleView,
             Rectangle2D.Double fframeViewRect,
             Rectangle2D visibleLayoutDocRect,
             BufferedImage imgBase) throws Exception {
             Point mapOrigin = new Point((int)rectangleView.getMinX(), (int)rectangleView.getMaxY());
             Point mapOrigin = new Point((int)visibleLayoutDocRect.getMinX(), (int)visibleLayoutDocRect.getMaxY());
             ViewPort viewPort = this.getMapContext().getViewPort();
             Color theBackColor = viewPort.getBackColor();
         	int drawWidth = (int)fframeViewRect.width;
         	int drawHeight = (int)fframeViewRect.height;
             //If the image has to be created...
             if (!(origin != null
-...
                 && affineTransform.getScaleX() == scaleAnt
                 && m_image != null
                 && !refresh
                 && !(rectangleLayout.getWidth() > rectangleView.getWidth() || rectangleLayout.getHeight() > rectangleView.getHeight()))) {
                 && !(fframeViewRect.getWidth() > visibleLayoutDocRect.getWidth() || fframeViewRect.getHeight() > visibleLayoutDocRect.getHeight()))) {
                 double scale1_1 = viewPort.getDPI() / 2.54;
                 /*
                  * This is the ratio between the size assumed by the
                  * mapcontext drawer and the true size on screen
                  */
                 double visible_factor = affineTransform.getScaleX() / scale1_1;
                 int draw_w = (int) (1d * rectangleLayout.width / visible_factor);
                 int draw_h = (int) (1d * rectangleLayout.height / visible_factor);
                 viewPort.setImageSize(new Dimension(draw_w, draw_h));
                 viewPort.refreshExtent();
                 /*
                 viewPort.setOffset(new Point2D.Double(rectangleLayout.x, rectangleLayout.y));
                 */
             	viewPort.setImageSize(new Dimension(drawWidth, drawHeight));
             	viewPort.refreshExtent(); // comprobar si es necesario; el setImageSize ya calcula la nueva AT, pero no lanza el evento extentChanged
                 viewPort.setDPI(getDrawPaperDPI());
                 m_image =
                     new BufferedImage(
                         draw_w, //(int) rectangleLayout.getWidth(),
                         draw_h, //(int) rectangleLayout.getHeight(),
                         BufferedImage.TYPE_INT_ARGB);
                         new BufferedImage(
                         		drawWidth,
                         		drawHeight,
                         		BufferedImage.TYPE_INT_ARGB);
                 Graphics2D gimg = (Graphics2D) m_image.createGraphics();
                 /*
                 gimg.translate(-((int) rectangleLayout.getX()),
                     -((int) rectangleLayout.getY()));
                 */
                     Graphics2D gimg = (Graphics2D) m_image.createGraphics();
                 getMapContext().draw(m_image, gimg, getScale());
                 gimg.dispose();
                 /*
                 gimg.translate(((int) rectangleLayout.getX()),
                     ((int) rectangleLayout.getY()));
                     */
                     getMapContext().draw(m_image, gimg, getScale());
                     gimg.dispose();
                 refresh = false;
+            }
             //Draw the created image
             if (theBackColor != null) {
                 g.setColor(theBackColor);
                 g.fillRect((int) rectangleLayout.x, (int) rectangleLayout.y,
                     viewPort.getImageWidth(),
                     viewPort.getImageHeight());
                 g.fillRect((int) fframeViewRect.x, (int) fframeViewRect.y,
                 		(int)fframeViewRect.width,
                 		(int)fframeViewRect.height);
+            }
             g.drawImage(m_image,
             		(int) fframeViewRect.x,
             		(int) fframeViewRect.y,
             		null);
             m_image = copyForcingImageSize(
                 m_image,
                 (int) rectangleLayout.getWidth(),
                 (int) rectangleLayout.getHeight());
             g.drawImage(m_image,
                 (int) rectangleLayout.getX(),
                 (int) rectangleLayout.getY(), null);
             scaleAnt = affineTransform.getScaleX();
             origin = mapOrigin;
+        }
         /**
          * @param m_image2
          * @param width
          * @param height
          * @return
          */
         protected BufferedImage copyForcingImageSize(
             BufferedImage disp_img, int w, int h) {
             Graphics rg = null;
             try {
                 if (disp_img == null || w < 1 || h < 1) {
                     return new BufferedImage(1, 1, BufferedImage.TYPE_INT_ARGB);
+                }
                 int from_w = disp_img.getWidth(null);
                 int from_h = disp_img.getHeight(null);
                 if (from_w < 1 || from_h < 1) {
                     return new BufferedImage(1, 1, BufferedImage.TYPE_INT_ARGB);
+                }
                 BufferedImage resp =
                     new BufferedImage(w, h, BufferedImage.TYPE_INT_ARGB);
                 rg = resp.createGraphics();
                 double rat_w = (1d*w) / (1d*from_w);
                 double rat_h = (1d*h) / (1d*from_h);
                 int offset_w = 0;
                 int offset_h = 0;
                 Image aux = null;
                 if (rat_w <= rat_h) {
                     // apply resize of width
                     int target_h = Math.max(1, (int) (from_h * rat_w));
                     // w, target_h
                     offset_w = 0;
                     offset_h = (h - target_h) / 2;
                     aux = disp_img.getScaledInstance(w, target_h, Image.SCALE_FAST);
                     rg.drawImage(aux, offset_w, offset_h, null);
                 } else {
                     // apply resize from height
                     int target_w = Math.max(1, (int) (from_w * rat_h));
                     // target_w, h
                     offset_w = (w - target_w) / 2;
                     offset_h = 0;
                     aux = disp_img.getScaledInstance(target_w, h, Image.SCALE_FAST);
                     rg.drawImage(aux, offset_w, offset_h, null);
+                }
                 aux = null;
                 resp.flush();
                 rg.dispose();
                 return resp;
             } catch (Throwable th) {
                 logger.info("While resizing image.", th);
                 if (rg != null) {
                     rg.dispose();
+                }
                 return null;
+            }
+        }
         protected Rectangle preDraw(Graphics2D g, Rectangle2D.Double rectangleLayout){
         protected Rectangle preDraw(Graphics2D g, Rectangle2D.Double fframeViewRect){
             Rectangle originalClip = null;
             if (g.getClipBounds() != null) {
                 originalClip = (Rectangle) g.getClipBounds().clone();
+            }
             if (getRotation() != 0) {
                 g.rotate(Math.toRadians(getRotation()), rectangleLayout.getCenterX(), rectangleLayout.getCenterY()
                     + (rectangleLayout.height / 2));
                 g.rotate(Math.toRadians(getRotation()), fframeViewRect.getCenterX(), fframeViewRect.getCenterY()
                     + (fframeViewRect.height / 2));
+            }
             g.clipRect((int) rectangleLayout.getMinX(), (int) rectangleLayout.getMinY(),
                 (int) rectangleLayout.getWidth(), (int) rectangleLayout.getHeight());
             g.clipRect((int) fframeViewRect.getMinX(), (int) fframeViewRect.getMinY(),
                 (int) fframeViewRect.getWidth(), (int) fframeViewRect.getHeight());
             return originalClip;
+        }
         protected void postDraw(Graphics2D g, Rectangle2D.Double rectangleLayout, Rectangle2D rectangleView, BufferedImage imgBase,
         protected void postDraw(Graphics2D g, Rectangle2D.Double fframeViewRect, Rectangle2D visibleLayoutDocRect, BufferedImage imgBase,
             Rectangle originalClip, AffineTransform at){
             if (getRotation() != 0) {
                 g.rotate(Math.toRadians(-getRotation()), rectangleLayout.getCenterX(), rectangleLayout.getCenterY());
                 g.rotate(Math.toRadians(-getRotation()), fframeViewRect.getCenterX(), fframeViewRect.getCenterY());
+            }
             if (getMapContext() != null) {
                 setATMap(getMapContext().getViewPort().getAffineTransform());
-...
             if (linked){
                 if (getTypeScale() == AUTOMATICO) {
                     mapContext.getViewPort().setEnvelope(e.getNewExtent());
     //                observers.notifyObservers(this,
     //                    new DefaultLayoutNotification(LayoutNotification.LAYOUT_INVALIDATED));
                     observers.notifyObservers(this,
                         new DefaultLayoutNotification(LayoutNotification.LAYOUT_INVALIDATED));
                             new DefaultLayoutNotification(LayoutNotification.LAYOUT_REFRESH));
                 } else
                     if (getTypeScale() == MANUAL) {
                         Envelope oldExtent = mapContext.getViewPort().getEnvelope();
-...
+                    }
                 refresh = true;
+            }
             updateScaleCtrl();
+        }
         /**
-...
         	statusbar.setMessage("units",
         			PluginServices.getText(this, mapContext.getDistanceName()));
         	statusbar.setControlValue("layout-view-change-scale",
         			String.valueOf(mapContext.getScaleView()));
         			String.valueOf(getScale()));
         	IProjection proj = mapContext.getViewPort().getProjection();
         	if (proj != null) {
         		statusbar.setMessage("projection", proj.getAbrev());
-...
                 definition.addDynFieldInt(TYPESCALE_FIELD).setMandatory(true);
                 definition.addDynFieldInt(EXTENSION_FIELD).setMandatory(true);
                 definition.addDynFieldInt(QUALITY_FIELD).setMandatory(true);
                 definition.addDynFieldInt(VIEWING_FIELD).setMandatory(true);
                 definition.addDynFieldBoolean(BLINKED_FIELD).setMandatory(true);
                 definition.addDynFieldInt(MAPUNITS_FIELD).setMandatory(true);
                 definition.addDynFieldDouble(SCALE_FIELD).setMandatory(true);
-...
             typeScale = state.getInt(TYPESCALE_FIELD);
             extension = state.getInt(EXTENSION_FIELD);
             quality = state.getInt(QUALITY_FIELD);
             viewing = state.getInt(VIEWING_FIELD);
             linked = state.getBoolean(BLINKED_FIELD);
             mapUnits = state.getInt(MAPUNITS_FIELD);
             mapScale = state.getDouble(SCALE_FIELD);
-...
             state.set(TYPESCALE_FIELD, typeScale);
             state.set(EXTENSION_FIELD, extension);
             state.set(QUALITY_FIELD, quality);
             state.set(VIEWING_FIELD, viewing);
             state.set(BLINKED_FIELD, linked);
             state.set(MAPUNITS_FIELD, mapUnits);
             state.set(SCALE_FIELD, mapScale);

                 jContentPane.add(getTEscalaNumerica(), null);
                 jContentPane.add(getLExtension(), null);
                 jContentPane.add(getCbExtension(), null);
                 jContentPane.add(getLVisualizacion(), null);
                 jContentPane.add(getCbVisualizacion(), null);
                 jContentPane.add(getLCalidad(), null);
                 jContentPane.add(getCbCalidad(), null);
                 jContentPane.add(getbAceptar(), null);
-...
+        }
         /**
          * This method initializes jLabel4
+         *
          * @return javax.swing.JLabel
          */
         private javax.swing.JLabel getLVisualizacion() {
             if (lVisualizacion == null) {
                 lVisualizacion = new javax.swing.JLabel();
                 lVisualizacion.setSize(86, 16);
                 lVisualizacion.setText(PluginServices
                     .getText(this, "visualizacion"));
                 lVisualizacion.setLocation(10, 180);
                 lVisualizacion.setVisible(false);
+            }
             return lVisualizacion;
+        }
         /**
          * This method initializes cbVisualizacion
+         *
          * @return javax.swing.JComboBox
          */
         private javax.swing.JComboBox getCbVisualizacion() {
             if (cbVisualizacion == null) {
                 // String[] s={"Cuando activo","Siempre"};
                 cbVisualizacion = new javax.swing.JComboBox();
                 cbVisualizacion.setSize(220, 20);
                 cbVisualizacion.addItem(PluginServices.getText(this,
                     "cuando_activo"));
                 cbVisualizacion.addItem(PluginServices.getText(this, "siempre"));
                 cbVisualizacion.setSelectedIndex(fframeview.getViewing());
                 cbVisualizacion.setPreferredSize(new java.awt.Dimension(200, 20));
                 cbVisualizacion.setLocation(100, 180);
                 cbVisualizacion.setEnabled(false);
                 cbVisualizacion.setVisible(false);
+            }
             return cbVisualizacion;
+        }
         /**
          * This method initializes jButton
+         *
          * @return javax.swing.JButton
-...
                                 // fframeview.setFMap(m_projectView.getMapContext());
                                 newFFrameView.setExtension(getCbExtension()
                                     .getSelectedIndex());
                                 newFFrameView.setViewing(getCbVisualizacion()
                                     .getSelectedIndex());
                                 newFFrameView.setQuality(getCbCalidad()
                                     .getSelectedIndex());
                                 if (fframeview.getGrid() != null) {

             BufferedImage imgBase);
         /**
          * Devuelve el boundingBox del fframe en funci�n de la transformada af�n
          * que se pasa como par�metro. Si se pasa como par�metro null, devuelve
          * el
          * �ltimo boundingbox que se calcul�.
          * Returns the bounding box (in pixels) of this FFrame, based on the provided
          * AffineTransform. If the AffineTransform is null, it returns the last
          * calculated bounding box.
+         *
          * @param at
          *            Transformada af�n
+         *
          * @return Rect�ngulo que representa el BoundingBox del fframe.
          * @param at Affine transform to apply to the sheet coordinates to get the
          *  		bounding box in pixels.
          * @return Rectangle representing the bounding box (in pixels) of this
          * FFrame
          */
         public Rectangle2D.Double getBoundingBox(AffineTransform at) {
             if (at != null) {
-...
+        }
         /**
          * Devuelve el rect�ngulo que representa el fframe en cent�metros.
          * Returns the bounding box in centimeters of this FFrame
          * Returns the rectangle that represents the FFrame in centimeters.
+         *
          * @return Rect�ngulo en centimetros.
          * @return The bounding box of this FFrame, measured in centimeters.
          */
         public Rectangle2D.Double getBoundBox() {
             return m_BoundBox;
-...
+        }
         /**
          * Dibuja sobre el graphics el rect�ngulo del fframe pero vacio, mostrando
          * el nombre del fframe y vacio.
          * Draws the FFrame rectangle on the provided Graphics2D, only showing the
          * FFrame name on an empty rectangle.
+         *
          * @param g
          *            Graphics sobre el que dibujar.
          * @param g The graphics to draw on
          */
         public void drawEmpty(Graphics2D g) {
             Rectangle2D r = getBoundingBox(null);

Also available in: Unified diff

Application: gvSIG desktop » gvSIG Document Layout

Revision 141