svn-gvsig-desktop / trunk / applications / appgvSIG / src / com / iver / cit / gvsig / project / documents / layout / fframes / FFrameGraphics.java @ 28368
History | View | Annotate | Download (22.8 KB)
1 | 9392 | caballero | /*
|
---|---|---|---|
2 | * Created on 22-jun-2004
|
||
3 | *
|
||
4 | */
|
||
5 | /* gvSIG. Sistema de Informaci?n Geogr?fica de la Generalitat Valenciana
|
||
6 | *
|
||
7 | * Copyright (C) 2004 IVER T.I. and Generalitat Valenciana.
|
||
8 | *
|
||
9 | * This program is free software; you can redistribute it and/or
|
||
10 | * modify it under the terms of the GNU General Public License
|
||
11 | * as published by the Free Software Foundation; either version 2
|
||
12 | * of the License, or (at your option) any later version.
|
||
13 | *
|
||
14 | * This program is distributed in the hope that it will be useful,
|
||
15 | * but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
16 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||
17 | * GNU General Public License for more details.
|
||
18 | *
|
||
19 | * You should have received a copy of the GNU General Public License
|
||
20 | * along with this program; if not, write to the Free Software
|
||
21 | * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,USA.
|
||
22 | *
|
||
23 | * For more information, contact:
|
||
24 | *
|
||
25 | * Generalitat Valenciana
|
||
26 | * Conselleria d'Infraestructures i Transport
|
||
27 | * Av. Blasco Ib??ez, 50
|
||
28 | * 46010 VALENCIA
|
||
29 | * SPAIN
|
||
30 | *
|
||
31 | * +34 963862235
|
||
32 | * gvsig@gva.es
|
||
33 | * www.gvsig.gva.es
|
||
34 | *
|
||
35 | * or
|
||
36 | *
|
||
37 | * IVER T.I. S.A
|
||
38 | * Salamanca 50
|
||
39 | * 46005 Valencia
|
||
40 | * Spain
|
||
41 | *
|
||
42 | * +34 963163400
|
||
43 | * dac@iver.es
|
||
44 | */
|
||
45 | package com.iver.cit.gvsig.project.documents.layout.fframes; |
||
46 | |||
47 | import java.awt.Color; |
||
48 | import java.awt.Graphics2D; |
||
49 | import java.awt.geom.AffineTransform; |
||
50 | import java.awt.geom.Point2D; |
||
51 | import java.awt.geom.Rectangle2D; |
||
52 | import java.awt.image.BufferedImage; |
||
53 | import java.util.BitSet; |
||
54 | |||
55 | 10911 | jaume | import javax.print.attribute.PrintRequestAttributeSet; |
56 | |||
57 | 9392 | caballero | import com.iver.andami.PluginServices; |
58 | 9593 | caballero | import com.iver.cit.gvsig.fmap.core.FShape; |
59 | 10825 | jaume | import com.iver.cit.gvsig.fmap.core.SymbologyFactory; |
60 | 9392 | caballero | import com.iver.cit.gvsig.fmap.core.adapter.CircleAdapter; |
61 | import com.iver.cit.gvsig.fmap.core.adapter.GeometryAdapter; |
||
62 | import com.iver.cit.gvsig.fmap.core.adapter.PointAdapter; |
||
63 | import com.iver.cit.gvsig.fmap.core.adapter.PolyLineAdapter; |
||
64 | import com.iver.cit.gvsig.fmap.core.adapter.PolygonAdapter; |
||
65 | import com.iver.cit.gvsig.fmap.core.adapter.RectangleAdapter; |
||
66 | 10849 | jaume | import com.iver.cit.gvsig.fmap.core.symbols.IMarkerSymbol; |
67 | 9640 | jaume | import com.iver.cit.gvsig.fmap.core.symbols.ISymbol; |
68 | 23074 | vcaballero | import com.iver.cit.gvsig.fmap.core.symbols.SimpleFillSymbol; |
69 | 9392 | caballero | import com.iver.cit.gvsig.project.documents.exceptions.SaveException; |
70 | 9593 | caballero | import com.iver.cit.gvsig.project.documents.layout.fframes.gui.dialogs.FFrameGraphicsDialog; |
71 | 9392 | caballero | import com.iver.cit.gvsig.project.documents.layout.fframes.gui.dialogs.IFFrameDialog; |
72 | import com.iver.cit.gvsig.project.documents.layout.gui.Layout; |
||
73 | import com.iver.utiles.XMLEntity; |
||
74 | |||
75 | |||
76 | /**
|
||
77 | * FFrame para contener un gr?fico.
|
||
78 | *
|
||
79 | * @author Vicente Caballero Navarro
|
||
80 | */
|
||
81 | public class FFrameGraphics extends FFrame implements IFFrameEditableVertex { |
||
82 | private static double TOL = 0.2; |
||
83 | public static final int POINT = 21; |
||
84 | public static final int LINE = 22; |
||
85 | public static final int POLYLINE = 23; |
||
86 | public static final int RECTANGLE = 24; |
||
87 | public static final int CIRCLE = 25; |
||
88 | public static final int POLYGON = 26; |
||
89 | public static final int RECTANGLEGROUP = 16; |
||
90 | public static final int RECTANGLESYMBOL = 17; |
||
91 | private int m_type = POINT; |
||
92 | private ISymbol m_symbol = null; |
||
93 | private Color m_color = null; |
||
94 | private GeometryAdapter geometry;
|
||
95 | private GeometryAdapter geometryEdit;
|
||
96 | private boolean editing = false; |
||
97 | private double size = 0.5; |
||
98 | private BitSet index = new BitSet(); |
||
99 | |||
100 | /**
|
||
101 | * Crea un nuevo FFrameGraphics.
|
||
102 | */
|
||
103 | public FFrameGraphics() {
|
||
104 | } |
||
105 | |||
106 | /**
|
||
107 | * DOCUMENT ME!
|
||
108 | *
|
||
109 | * @param geom DOCUMENT ME!
|
||
110 | */
|
||
111 | public void setGeometryAdapter(GeometryAdapter geom) { |
||
112 | geometry = geom; |
||
113 | } |
||
114 | |||
115 | /**
|
||
116 | * Rellena el color que se utlizar? para dibujar el s?mbolo.
|
||
117 | *
|
||
118 | * @param color
|
||
119 | */
|
||
120 | public void setColor(Color color) { |
||
121 | m_color = color; |
||
122 | } |
||
123 | |||
124 | /**
|
||
125 | * Actualiza el Fsymbol a partir del tipo de Gr?fico que se pase como
|
||
126 | * par?metro.
|
||
127 | *
|
||
128 | * @param type tipo de gr?fico.
|
||
129 | * @param at Transformada.
|
||
130 | */
|
||
131 | public void update(int type, AffineTransform at) { |
||
132 | m_type = type; |
||
133 | |||
134 | //aT = at;
|
||
135 | if (m_color == null) { |
||
136 | m_color = Color.black;
|
||
137 | } |
||
138 | 10849 | jaume | int shapeType = -1; |
139 | 10825 | jaume | /*
|
140 | * (jaume) moved to ISymbol
|
||
141 | * switch (m_type) {
|
||
142 | 9392 | caballero | case (POINT):
|
143 | |||
144 | FSymbol symbolPoint= new FSymbol(FConstant.SHAPE_TYPE_POINT, m_color);
|
||
145 | symbolPoint.setSize((int) FLayoutUtilities.fromSheetDistance(
|
||
146 | size, at));
|
||
147 | m_symbol=symbolPoint;
|
||
148 | break;
|
||
149 | |||
150 | case (RECTANGLE):
|
||
151 | FSymbol symbolRectangle= new FSymbol(FConstant.SYMBOL_TYPE_FILL, m_color);
|
||
152 | symbolRectangle.setColor(null);
|
||
153 | m_symbol=symbolRectangle;
|
||
154 | break;
|
||
155 | |||
156 | case (LINE):
|
||
157 | FSymbol symbolLine= new FSymbol(FConstant.SYMBOL_TYPE_LINE, m_color);
|
||
158 | m_symbol=symbolLine;
|
||
159 | break;
|
||
160 | |||
161 | case (POLYLINE):
|
||
162 | FSymbol symbolPolyline= new FSymbol(FConstant.SYMBOL_TYPE_LINE, m_color);
|
||
163 | m_symbol=symbolPolyline;
|
||
164 | break;
|
||
165 | |||
166 | case (POLYGON):
|
||
167 | FSymbol symbolPolygon= new FSymbol(FConstant.SYMBOL_TYPE_FILL, m_color);
|
||
168 | symbolPolygon.setStyle(FConstant.SYMBOL_STYLE_FILL_SOLID);
|
||
169 | symbolPolygon.setOutlined(true);
|
||
170 | symbolPolygon.setOutlineColor(m_color);
|
||
171 | symbolPolygon.setColor(null);
|
||
172 | m_symbol=symbolPolygon;
|
||
173 | break;
|
||
174 | |||
175 | case (CIRCLE):
|
||
176 | FSymbol symbolCircle= new FSymbol(FConstant.SYMBOL_TYPE_FILL, m_color);
|
||
177 | symbolCircle.setStyle(FConstant.SYMBOL_STYLE_FILL_SOLID);
|
||
178 | symbolCircle.setOutlined(true);
|
||
179 | symbolCircle.setOutlineColor(m_color);
|
||
180 | symbolCircle.setColor(null);
|
||
181 | m_symbol=symbolCircle;
|
||
182 | break;
|
||
183 | }
|
||
184 | 10825 | jaume | */
|
185 | 10849 | jaume | switch (m_type) {
|
186 | case (POINT):
|
||
187 | shapeType = FShape.POINT; |
||
188 | break;
|
||
189 | |||
190 | case (RECTANGLE):
|
||
191 | case (POLYGON):
|
||
192 | case (CIRCLE):
|
||
193 | shapeType = FShape.POLYGON; |
||
194 | break;
|
||
195 | |||
196 | case (LINE):
|
||
197 | case (POLYLINE):
|
||
198 | shapeType = FShape.LINE; |
||
199 | break;
|
||
200 | } |
||
201 | m_symbol = SymbologyFactory.createDefaultSymbolByShapeType(shapeType); |
||
202 | 23074 | vcaballero | if (shapeType==FShape.POLYGON){
|
203 | ((SimpleFillSymbol)m_symbol).setFillColor(null);
|
||
204 | } |
||
205 | 9392 | caballero | } |
206 | |||
207 | /**
|
||
208 | * Devuelve el FSymbol que se representa.
|
||
209 | *
|
||
210 | * @return DOCUMENT ME!
|
||
211 | */
|
||
212 | public ISymbol getFSymbol() {
|
||
213 | return m_symbol;
|
||
214 | } |
||
215 | |||
216 | /**
|
||
217 | * Rellena el FSymbol que se representara al dibujar.
|
||
218 | *
|
||
219 | * @param fs2d
|
||
220 | */
|
||
221 | public void setFSymbol(ISymbol symbol) { |
||
222 | m_symbol = symbol; |
||
223 | } |
||
224 | |||
225 | /**
|
||
226 | * M?todo que dibuja sobre el graphics que se le pasa como par?metro, seg?n
|
||
227 | * la transformada afin que se debe de aplicar y el rect?ngulo que se debe
|
||
228 | * de dibujar.
|
||
229 | *
|
||
230 | * @param g Graphics
|
||
231 | * @param at Transformada afin.
|
||
232 | * @param rv rect?ngulo sobre el que hacer un clip.
|
||
233 | * @param imgBase DOCUMENT ME!
|
||
234 | */
|
||
235 | public void draw(Graphics2D g, AffineTransform at, Rectangle2D rv, |
||
236 | 28368 | vcaballero | BufferedImage imgBase) {
|
237 | 9392 | caballero | Rectangle2D.Double rect = getBoundingBox(at);
|
238 | g.rotate(Math.toRadians(getRotation()), rect.x + (rect.width / 2), |
||
239 | rect.y + (rect.height / 2));
|
||
240 | if (intersects(rv, rect)) {
|
||
241 | g.setColor(Color.black);
|
||
242 | |||
243 | if (m_type == POINT) {
|
||
244 | 10849 | jaume | ((IMarkerSymbol)m_symbol).setSize((int) (rect.getWidth() * 0.7)); |
245 | 9392 | caballero | } |
246 | 9593 | caballero | // float stroke=0;
|
247 | // if (((FSymbol)m_symbol).getStroke() != null) {
|
||
248 | // stroke=((BasicStroke)((FSymbol)m_symbol).getStroke()).getLineWidth();
|
||
249 | // BasicStroke basicStroke = new BasicStroke((float)FLayoutUtilities.fromSheetDistance(stroke,at)/100);
|
||
250 | // ((FSymbol)m_symbol).setStroke(basicStroke);
|
||
251 | // }
|
||
252 | 9392 | caballero | geometry.draw(g, at, m_symbol); |
253 | |||
254 | 9593 | caballero | // if (((FSymbol)m_symbol).getStroke() != null) {
|
255 | // BasicStroke basicStroke = new BasicStroke(stroke);
|
||
256 | // ((FSymbol)m_symbol).setStroke(basicStroke);
|
||
257 | // }
|
||
258 | 9392 | caballero | |
259 | if (editing) {
|
||
260 | g.setColor(Color.red);
|
||
261 | geometry.drawVertex(g, at); |
||
262 | } |
||
263 | } |
||
264 | |||
265 | g.rotate(Math.toRadians(-getRotation()), rect.x + (rect.width / 2), |
||
266 | rect.y + (rect.height / 2));
|
||
267 | } |
||
268 | |||
269 | /**
|
||
270 | * @see com.iver.cit.gvsig.project.documents.layout.fframes.IFFrame#getXMLEntity()
|
||
271 | */
|
||
272 | public XMLEntity getXMLEntity() throws SaveException { |
||
273 | XMLEntity xml = super.getXMLEntity();
|
||
274 | |||
275 | try {
|
||
276 | // xml.putProperty("type", Layout.GRAPHICS);
|
||
277 | xml.putProperty("m_type", m_type);
|
||
278 | xml.addChild(m_symbol.getXMLEntity()); |
||
279 | if (geometry!=null) { |
||
280 | xml.addChild(geometry.getXMLEntity()); |
||
281 | } |
||
282 | // xml.addChild(geometryEdit.getXMLEntity());
|
||
283 | } catch (Exception e) { |
||
284 | throw new SaveException(e, this.getClass().getName()); |
||
285 | } |
||
286 | |||
287 | return xml;
|
||
288 | } |
||
289 | |||
290 | /**
|
||
291 | * @see com.iver.cit.gvsig.project.documents.layout.fframes.IFFrame#updateNum()
|
||
292 | */
|
||
293 | public void updateNum() { |
||
294 | } |
||
295 | |||
296 | /**
|
||
297 | * @see com.iver.cit.gvsig.project.documents.layout.fframes.IFFrame#getNum()
|
||
298 | */
|
||
299 | public int getNum() { |
||
300 | return 0; |
||
301 | } |
||
302 | |||
303 | /**
|
||
304 | * @see com.iver.cit.gvsig.project.documents.layout.fframes.IFFrame#setXMLEntity(com.iver.utiles.XMLEntity,
|
||
305 | * com.iver.cit.gvsig.project.Project)
|
||
306 | */
|
||
307 | public void setXMLEntity(XMLEntity xml) { |
||
308 | m_Selected = xml.getIntProperty("m_Selected");
|
||
309 | |||
310 | setRotation(xml.getDoubleProperty("m_rotation"));
|
||
311 | 10850 | jaume | // jaume; m_symbol = FSymbol.createFromXML(xml.getChild(0));
|
312 | m_symbol = SymbologyFactory.createSymbolFromXML(xml.getChild(0), null); |
||
313 | 9392 | caballero | if (xml.contains("m_type")) { |
314 | m_type = xml.getIntProperty("m_type");
|
||
315 | // return;
|
||
316 | } |
||
317 | if (m_type==RECTANGLESYMBOL)
|
||
318 | return;
|
||
319 | if (xml.getChildrenCount() ==1) { |
||
320 | Rectangle2D r = (Rectangle2D) getBoundBox().clone(); |
||
321 | |||
322 | if (m_type == LINE) {
|
||
323 | geometry = new PolyLineAdapter();
|
||
324 | } else if (m_type == RECTANGLE || |
||
325 | m_type == RECTANGLEGROUP) { |
||
326 | geometry = new RectangleAdapter();
|
||
327 | geometry.addPoint(new Point2D.Double(r.getX(), r.getY())); |
||
328 | geometry.addPoint(new Point2D.Double(r.getMaxX(), r.getMaxY())); |
||
329 | } else if (m_type == POLYLINE) { |
||
330 | geometry = new PolyLineAdapter();
|
||
331 | } else if (m_type == POLYGON) { |
||
332 | geometry = new PolygonAdapter();
|
||
333 | } else if (m_type == CIRCLE) { |
||
334 | geometry = new CircleAdapter();
|
||
335 | geometry.addPoint(new Point2D.Double(r.getCenterX(), |
||
336 | r.getCenterY())); |
||
337 | |||
338 | if (r.getWidth() < r.getHeight()) {
|
||
339 | geometry.addPoint(new Point2D.Double(r.getMaxX(), |
||
340 | r.getCenterY())); |
||
341 | } else {
|
||
342 | geometry.addPoint(new Point2D.Double(r.getCenterX(), |
||
343 | r.getY())); |
||
344 | } |
||
345 | } else if (m_type == POINT) { |
||
346 | geometry = new PointAdapter();
|
||
347 | geometry.addPoint(new Point2D.Double(r.getCenterX(), |
||
348 | r.getCenterY())); |
||
349 | } |
||
350 | |||
351 | geometry.end(); |
||
352 | } else {
|
||
353 | geometry = GeometryAdapter.createFromXML(xml.getChild(1));
|
||
354 | // geometryEdit = GeometryAdapter.createFromXML(xml.getChild(2));
|
||
355 | } |
||
356 | } |
||
357 | |||
358 | /**
|
||
359 | * @see com.iver.cit.gvsig.project.documents.layout.fframes.IFFrame#setXMLEntity(com.iver.utiles.XMLEntity,
|
||
360 | * com.iver.cit.gvsig.project.Project)
|
||
361 | */
|
||
362 | public void setXMLEntity03(XMLEntity xml, Layout p) { |
||
363 | m_Selected = xml.getIntProperty("m_Selected");
|
||
364 | m_type = xml.getIntProperty("m_type");
|
||
365 | 10850 | jaume | // jaume; m_symbol = FSymbol.createFromXML(xml.getChild(0));
|
366 | m_symbol = SymbologyFactory.createSymbolFromXML(xml.getChild(0), null); |
||
367 | 9392 | caballero | |
368 | Rectangle2D r = (Rectangle2D) getBoundBox().clone(); |
||
369 | |||
370 | if (m_type == LINE) {
|
||
371 | geometry = new PolyLineAdapter();
|
||
372 | } else if (m_type == RECTANGLE) { |
||
373 | geometry = new RectangleAdapter();
|
||
374 | geometry.addPoint(new Point2D.Double(r.getX(), r.getY())); |
||
375 | geometry.addPoint(new Point2D.Double(r.getMaxX(), r.getMaxY())); |
||
376 | } else if (m_type == POLYLINE) { |
||
377 | geometry = new PolyLineAdapter();
|
||
378 | } else if (m_type == POLYGON) { |
||
379 | geometry = new PolygonAdapter();
|
||
380 | } else if (m_type == CIRCLE) { |
||
381 | geometry = new CircleAdapter();
|
||
382 | geometry.addPoint(new Point2D.Double(r.getCenterX(), r.getCenterY())); |
||
383 | |||
384 | if (r.getWidth() < r.getHeight()) {
|
||
385 | geometry.addPoint(new Point2D.Double(r.getMaxX(), r.getCenterY())); |
||
386 | } else {
|
||
387 | geometry.addPoint(new Point2D.Double(r.getCenterX(), r.getY())); |
||
388 | } |
||
389 | } else if (m_type == POINT) { |
||
390 | geometry = new PointAdapter();
|
||
391 | geometry.addPoint(new Point2D.Double(r.getCenterX(), r.getCenterY())); |
||
392 | } |
||
393 | |||
394 | geometry.end(); |
||
395 | } |
||
396 | |||
397 | /**
|
||
398 | * @see com.iver.cit.gvsig.project.documents.layout.fframes.IFFrame#getNameFFrame()
|
||
399 | */
|
||
400 | public String getNameFFrame() { |
||
401 | return PluginServices.getText(this, "Graficos")+ num; |
||
402 | } |
||
403 | |||
404 | /**
|
||
405 | * Inserta el tama?o del punto.
|
||
406 | *
|
||
407 | * @param size entero que representa el tama?o del punto.
|
||
408 | */
|
||
409 | public void setSize(double size) { |
||
410 | this.size = size;
|
||
411 | if (m_type==RECTANGLESYMBOL) {
|
||
412 | return;
|
||
413 | } |
||
414 | Rectangle2D r = geometry.getBounds2D();
|
||
415 | super.setBoundBox(new Rectangle2D.Double(r.getX() - size, |
||
416 | r.getY() - size, size * 2, size * 2)); |
||
417 | } |
||
418 | |||
419 | /**
|
||
420 | * Devuelve el tipo de gr?fico que contiene el fframe.
|
||
421 | *
|
||
422 | * @return tipo de
|
||
423 | */
|
||
424 | public int getType() { |
||
425 | return m_type;
|
||
426 | } |
||
427 | public void setType(int type) { |
||
428 | m_type = type; |
||
429 | } |
||
430 | /**
|
||
431 | * DOCUMENT ME!
|
||
432 | *
|
||
433 | * @param r DOCUMENT ME!
|
||
434 | */
|
||
435 | public void setBoundBox(Rectangle2D r) { |
||
436 | if (m_type==RECTANGLESYMBOL) {
|
||
437 | super.setBoundBox(r);
|
||
438 | return;
|
||
439 | } |
||
440 | AffineTransform aT = new AffineTransform(); |
||
441 | |||
442 | if (getBoundBox().getWidth() != 0) { |
||
443 | double w = r.getWidth() / getBoundBox().getWidth();
|
||
444 | double h = r.getHeight() / getBoundBox().getHeight();
|
||
445 | |||
446 | AffineTransform trans2 = AffineTransform.getTranslateInstance(r.getX(), |
||
447 | r.getY()); |
||
448 | aT.concatenate(trans2); |
||
449 | |||
450 | AffineTransform scale1 = AffineTransform.getScaleInstance(w, h); |
||
451 | aT.concatenate(scale1); |
||
452 | |||
453 | AffineTransform trans1 = AffineTransform.getTranslateInstance(-getBoundBox() |
||
454 | .getX(), |
||
455 | -getBoundBox().getY()); |
||
456 | aT.concatenate(trans1); |
||
457 | geometry.applyTransform(aT); |
||
458 | |||
459 | size = aT.getScaleX() * size; |
||
460 | } |
||
461 | |||
462 | super.setBoundBox(r);
|
||
463 | } |
||
464 | |||
465 | /**
|
||
466 | * DOCUMENT ME!
|
||
467 | */
|
||
468 | public void startEditing() { |
||
469 | editing = true;
|
||
470 | } |
||
471 | |||
472 | /**
|
||
473 | * DOCUMENT ME!
|
||
474 | */
|
||
475 | public void stopEditing() { |
||
476 | editing = false;
|
||
477 | } |
||
478 | |||
479 | /**
|
||
480 | * DOCUMENT ME!
|
||
481 | *
|
||
482 | * @return DOCUMENT ME!
|
||
483 | */
|
||
484 | public boolean isEditing() { |
||
485 | return editing;
|
||
486 | } |
||
487 | |||
488 | /**
|
||
489 | * DOCUMENT ME!
|
||
490 | *
|
||
491 | * @param point DOCUMENT ME!
|
||
492 | * @param geom DOCUMENT ME!
|
||
493 | */
|
||
494 | public void pointReleased(Point2D point, GeometryAdapter geom) { |
||
495 | index.clear(); |
||
496 | geometry = geom; |
||
497 | |||
498 | Rectangle2D r = geometry.getBounds2D();
|
||
499 | super.setBoundBox(r);
|
||
500 | } |
||
501 | |||
502 | /**
|
||
503 | * DOCUMENT ME!
|
||
504 | *
|
||
505 | * @param point DOCUMENT ME!
|
||
506 | */
|
||
507 | public void pointPressed(Point2D point) { |
||
508 | Rectangle2D.Double rect = getBoundBox();
|
||
509 | Point2D[] points = geometry.getPoints(); |
||
510 | geometryEdit = geometry.cloneAdapter();//GeometryAdapter.createFromXML(geometry.getXMLEntity());
|
||
511 | |||
512 | Point2D pAux1 = new Point2D.Double(); |
||
513 | index.clear(); |
||
514 | for (int i = 0; i < points.length; i++) { |
||
515 | if (getRotation() != 0) { |
||
516 | AffineTransform af = AffineTransform.getRotateInstance(Math.toRadians( |
||
517 | -getRotation()), rect.x + (rect.width / 2),
|
||
518 | rect.y + (rect.height / 2));
|
||
519 | af.transform(point, pAux1); |
||
520 | |||
521 | if (points[i].distance(pAux1) <= TOL) {
|
||
522 | index.set(i); |
||
523 | } |
||
524 | } else {
|
||
525 | if (points[i].distance(point) <= TOL) {
|
||
526 | index.set(i); |
||
527 | } |
||
528 | } |
||
529 | } |
||
530 | } |
||
531 | |||
532 | /**
|
||
533 | * DOCUMENT ME!
|
||
534 | *
|
||
535 | * @param point DOCUMENT ME!
|
||
536 | */
|
||
537 | public void pointDragged(Point2D point) { |
||
538 | //Point2D[] points = geometry.getPoints();
|
||
539 | |||
540 | for (int j = index.nextSetBit(0); j >= 0; |
||
541 | j = index.nextSetBit(j + 1)) {
|
||
542 | if (getRotation() != 0) { |
||
543 | Rectangle2D.Double rect = getBoundBox();
|
||
544 | AffineTransform af = AffineTransform.getRotateInstance(Math.toRadians( |
||
545 | -getRotation()), rect.x + (rect.width / 2),
|
||
546 | rect.y + (rect.height / 2));
|
||
547 | af.transform(point, point); |
||
548 | } |
||
549 | |||
550 | //points[j] = new Point2D.Double(point.getX(), point.getY());
|
||
551 | geometryEdit.changePoint(j,point); |
||
552 | } |
||
553 | //geometryEdit.setPoints(points);
|
||
554 | geometryEdit.end(); |
||
555 | } |
||
556 | |||
557 | /**
|
||
558 | * DOCUMENT ME!
|
||
559 | *
|
||
560 | * @param g DOCUMENT ME!
|
||
561 | * @param at DOCUMENT ME!
|
||
562 | */
|
||
563 | public void paint(Graphics2D g, AffineTransform at) { |
||
564 | if (geometryEdit != null) { |
||
565 | Rectangle2D.Double rect = getBoundingBox(at);
|
||
566 | if (getRotation()!=0){ |
||
567 | g.rotate(Math.toRadians(getRotation()), rect.x + (rect.width / 2), |
||
568 | rect.y + (rect.height / 2));
|
||
569 | geometryEdit.paint(g,at,false);
|
||
570 | /* FShape m_shape = null;
|
||
571 | GeneralPathX polyLine = new GeneralPathX(geometryEdit.getShape());
|
||
572 | polyLine.transform(at);
|
||
573 | m_shape = new FPolyline2D(polyLine);
|
||
574 | FGraphicUtilities.DrawShape(g, mT, m_shape, m_symbol);
|
||
575 | */
|
||
576 | g.rotate(Math.toRadians(-getRotation()), rect.x + (rect.width / 2), |
||
577 | rect.y + (rect.height / 2));
|
||
578 | }else{
|
||
579 | geometryEdit.paint(g,at,false);
|
||
580 | } |
||
581 | } |
||
582 | } |
||
583 | |||
584 | /**
|
||
585 | * DOCUMENT ME!
|
||
586 | *
|
||
587 | * @return DOCUMENT ME!
|
||
588 | */
|
||
589 | public GeometryAdapter getGeometry() {
|
||
590 | return geometryEdit;
|
||
591 | } |
||
592 | |||
593 | public void initialize() { |
||
594 | // TODO Auto-generated method stub
|
||
595 | |||
596 | } |
||
597 | /**
|
||
598 | * Devuelve un entero que representa donde esta contenido el punto que se
|
||
599 | * pasa como par?metro.
|
||
600 | *
|
||
601 | * @param p punto a comparar.
|
||
602 | *
|
||
603 | * @return entero que representa como esta contenido el punto.
|
||
604 | */
|
||
605 | public int getContains(Point2D p) { |
||
606 | if (geometry instanceof CircleAdapter) { |
||
607 | if (ne.contains(p.getX(), p.getY())) {
|
||
608 | return NE;
|
||
609 | } else if (se.contains(p.getX(), p.getY())) { |
||
610 | return SE;
|
||
611 | } else if (so.contains(p.getX(), p.getY())) { |
||
612 | return SO;
|
||
613 | } else if (no.contains(p.getX(), p.getY())) { |
||
614 | return NO;
|
||
615 | } else if (getBoundingBox(null).contains(p.getX(), p.getY())) { |
||
616 | return RECT;
|
||
617 | } |
||
618 | return NOSELECT;
|
||
619 | } |
||
620 | return super.getContains(p); |
||
621 | } |
||
622 | |||
623 | /**
|
||
624 | * Dibuja los handlers sobre el boundingBox en el graphics que se pasa como
|
||
625 | * par?metro.
|
||
626 | *
|
||
627 | * @param g
|
||
628 | * Graphics sobre el que dibujar.
|
||
629 | */
|
||
630 | public void drawHandlers(Graphics2D g) { |
||
631 | if (geometry instanceof CircleAdapter) { |
||
632 | int size = 10; |
||
633 | Rectangle2D r = getBoundingBox(null); |
||
634 | Point2D p = new Point2D.Double(); |
||
635 | g.rotate(Math.toRadians(getRotation()), r.getX()
|
||
636 | + (r.getWidth() / 2), r.getY() + (r.getHeight() / 2)); |
||
637 | |||
638 | AffineTransform atRotate = new AffineTransform(); |
||
639 | atRotate.rotate(Math.toRadians(getRotation()), r.getX()
|
||
640 | + (r.getWidth() / 2), r.getY() + (r.getHeight() / 2)); |
||
641 | |||
642 | g.fillRect((int) r.getX() - size, (int) r.getY() - size, |
||
643 | size, size); |
||
644 | atRotate.transform(new Point2D.Double(r.getX() - size, r.getY() |
||
645 | - size), p); |
||
646 | no.setRect((int) p.getX(), (int) p.getY(), size, size); |
||
647 | |||
648 | g.fillRect((int) r.getMaxX(), (int) r.getY() - size, size, size); |
||
649 | atRotate.transform( |
||
650 | new Point2D.Double(r.getMaxX(), r.getY() - size), p); |
||
651 | ne.setRect((int) p.getX(), (int) p.getY(), size, size); |
||
652 | |||
653 | g.fillRect((int) r.getX() - size, (int) r.getMaxY(), size, size); |
||
654 | atRotate.transform( |
||
655 | new Point2D.Double(r.getX() - size, r.getMaxY()), p); |
||
656 | so.setRect((int) p.getX(), (int) p.getY(), size, size); |
||
657 | |||
658 | g.fillRect((int) r.getMaxX(), (int) r.getMaxY(), size, size); |
||
659 | atRotate.transform(new Point2D.Double(r.getMaxX(), r.getMaxY()), p); |
||
660 | se.setRect((int) p.getX(), (int) p.getY(), size, size); |
||
661 | |||
662 | g.rotate(Math.toRadians(-getRotation()), r.getX()
|
||
663 | + (r.getWidth() / 2), r.getY() + (r.getHeight() / 2)); |
||
664 | } |
||
665 | else
|
||
666 | super.drawHandlers(g);
|
||
667 | } |
||
668 | |||
669 | public void cloneActions(IFFrame frame) { |
||
670 | // TODO Auto-generated method stub
|
||
671 | |||
672 | } |
||
673 | |||
674 | public IFFrameDialog getPropertyDialog() {
|
||
675 | return new FFrameGraphicsDialog(getLayout(),this); |
||
676 | } |
||
677 | 23074 | vcaballero | public int getShapeType(){ |
678 | int shapeType=0; |
||
679 | switch (m_type) {
|
||
680 | case (POINT):
|
||
681 | shapeType = FShape.POINT; |
||
682 | break;
|
||
683 | 9392 | caballero | |
684 | 23074 | vcaballero | case (RECTANGLE):
|
685 | case (POLYGON):
|
||
686 | case (CIRCLE):
|
||
687 | shapeType = FShape.POLYGON; |
||
688 | break;
|
||
689 | |||
690 | case (LINE):
|
||
691 | case (POLYLINE):
|
||
692 | shapeType = FShape.LINE; |
||
693 | break;
|
||
694 | } |
||
695 | return shapeType;
|
||
696 | } |
||
697 | 28368 | vcaballero | public void print(Graphics2D g, AffineTransform at, FShape shape, PrintRequestAttributeSet printingProperties) { |
698 | 9593 | caballero | Rectangle2D.Double rect = getBoundingBox(at);
|
699 | g.rotate(Math.toRadians(getRotation()), rect.x + (rect.width / 2), |
||
700 | rect.y + (rect.height / 2));
|
||
701 | g.setColor(Color.black);
|
||
702 | |||
703 | if (m_type == POINT) {
|
||
704 | 10849 | jaume | ((IMarkerSymbol)m_symbol).setSize((int) (rect.getWidth() * 0.7)); |
705 | 9593 | caballero | } |
706 | 10911 | jaume | m_symbol.print(g,at,geometry.getShape(at),printingProperties); |
707 | //geometry.print(g, at, m_symbol, printingProperties);
|
||
708 | 9593 | caballero | g.rotate(Math.toRadians(-getRotation()), rect.x + (rect.width / 2), |
709 | rect.y + (rect.height / 2));
|
||
710 | } |
||
711 | |||
712 | |||
713 | 9392 | caballero | } |