|
1
26
27 package org.nightlabs.editor2d.impl;
28
29 import java.awt.Color  ;
30 import java.awt.geom.AffineTransform ;
31 import java.awt.geom.PathIterator ;
32 import java.awt.image.BufferedImage ;
33 import java.io.ByteArrayInputStream ;
34 import java.io.ByteArrayOutputStream ;
35 import java.io.IOException ;
36 import java.util.StringTokenizer ;
37
38 import org.nightlabs.editor2d.DrawComponent;
39 import org.nightlabs.editor2d.DrawComponentContainer;
40 import org.nightlabs.editor2d.Editor2DFactory;
41 import org.nightlabs.editor2d.EditorGuide;
42 import org.nightlabs.editor2d.EditorRuler;
43 import org.nightlabs.editor2d.EllipseDrawComponent;
44 import org.nightlabs.editor2d.ImageDrawComponent;
45 import org.nightlabs.editor2d.Layer;
46 import org.nightlabs.editor2d.LineDrawComponent;
47 import org.nightlabs.editor2d.MultiLayerDrawComponent;
48 import org.nightlabs.editor2d.RectangleDrawComponent;
49 import org.nightlabs.editor2d.ShapeDrawComponent;
50 import org.nightlabs.editor2d.TextDrawComponent;
51 import org.nightlabs.editor2d.j2d.GeneralShape;
52 import com.sun.image.codec.jpeg.ImageFormatException;
53 import com.sun.image.codec.jpeg.JPEGCodec;
54 import com.sun.image.codec.jpeg.JPEGImageDecoder;
55 import com.sun.image.codec.jpeg.JPEGImageEncoder;
56
57
63 public class Editor2DFactoryImpl
64 implements Editor2DFactory
65 {
66
72 public Editor2DFactoryImpl() {
73 super();
74 }
75
76
100
126
131 public DrawComponent createDrawComponent() {
132 DrawComponentImpl drawComponent = new DrawComponentImpl();
133 return drawComponent;
134 }
135
136
141 public ShapeDrawComponent createShapeDrawComponent() {
142 ShapeDrawComponentImpl shapeDrawComponent = new ShapeDrawComponentImpl();
143 return shapeDrawComponent;
144 }
145
146
151 public Layer createLayer() {
152 LayerImpl layer = new LayerImpl();
153 return layer;
154 }
155
156
161 public MultiLayerDrawComponent createMultiLayerDrawComponent() {
162 MultiLayerDrawComponentImpl multiLayerDrawComponent = new MultiLayerDrawComponentImpl();
163 validateMLDC(multiLayerDrawComponent);
164 return multiLayerDrawComponent;
165 }
166
167 public static final int UNIT_PIXELS = 2;
168 public static final int UNIT_CENTIMETER = 1;
169 protected void validateMLDC(MultiLayerDrawComponent mldc)
170 {
171 if (mldc == null)
172 throw new IllegalStateException ("Param mldc must not be null!");
173
174 Editor2DFactory factory = Editor2DFactory.eINSTANCE;
176
177 if (mldc.getCurrentLayer() == null)
179 {
180 Layer l = factory.createLayer();
181 if (l.getParent() == null)
182 l.setParent(mldc);
183
184 mldc.addDrawComponent(l);
185 mldc.setCurrentLayer(l);
186 }
187
188 if (mldc.getLeftRuler() == null)
190 {
191 EditorRuler leftRuler = factory.createEditorRuler();
192 leftRuler.setHorizontal(false);
193 leftRuler.setUnit(UNIT_PIXELS);
194 mldc.setLeftRuler(leftRuler);
195 }
196
197 if (mldc.getTopRuler() == null)
198 {
199 EditorRuler topRuler = factory.createEditorRuler();
200 topRuler.setHorizontal(true);
201 topRuler.setUnit(UNIT_PIXELS);
202 mldc.setTopRuler(topRuler);
203 }
204 }
205
206
211 public RectangleDrawComponent createRectangleDrawComponent() {
212 RectangleDrawComponentImpl rectangleDrawComponent = new RectangleDrawComponentImpl();
213 return rectangleDrawComponent;
214 }
215
216
221 public EllipseDrawComponent createEllipseDrawComponent() {
222 EllipseDrawComponentImpl ellipseDrawComponent = new EllipseDrawComponentImpl();
223 return ellipseDrawComponent;
224 }
225
226
231 public TextDrawComponent createTextDrawComponent() {
232 TextDrawComponentImpl textDrawComponent = new TextDrawComponentImpl();
233 return textDrawComponent;
234 }
235
236
241 public DrawComponentContainer createDrawComponentContainer() {
242 DrawComponentContainerImpl drawComponentContainer = new DrawComponentContainerImpl();
243 return drawComponentContainer;
244 }
245
246
251 public LineDrawComponent createLineDrawComponent() {
252 LineDrawComponentImpl lineDrawComponent = new LineDrawComponentImpl();
253 return lineDrawComponent;
254 }
255
256
261 public EditorGuide createEditorGuide() {
262 EditorGuideImpl editorGuide = new EditorGuideImpl();
263 return editorGuide;
264 }
265
266
271 public EditorRuler createEditorRuler() {
272 EditorRulerImpl editorRuler = new EditorRulerImpl();
273 return editorRuler;
274 }
275
276
281 public ImageDrawComponent createImageDrawComponent() {
282 ImageDrawComponentImpl imageDrawComponent = new ImageDrawComponentImpl();
283 return imageDrawComponent;
284 }
285
286
291 public Color createColorFromString(String initialValue)
292 {
293 StringBuffer sb = new StringBuffer (initialValue);
294 Integer integerRed = new Integer (sb.substring(2,5));
295 Integer integerGreen = new Integer (sb.substring(8,11));
296 Integer integerBlue = new Integer (sb.substring(14,17));
297 Integer integerAlpha = new Integer (sb.substring(20,23));
298 Color c = new Color (integerRed.intValue(), integerGreen.intValue(), integerBlue.intValue(), integerAlpha.intValue());
299 return c;
300 }
301
302
307 public String convertColorToString(Object instanceValue)
308 {
309 java.awt.Color color = (java.awt.Color ) instanceValue;
310 StringBuffer sb = new StringBuffer ();
311
312 sb.append("R:");
313 sb.append(convertColorValue(color.getRed()));
314 sb.append(",");
315 sb.append("G:");
316 sb.append(convertColorValue(color.getGreen()));
317 sb.append(",");
318 sb.append("B:");
319 sb.append(convertColorValue(color.getBlue()));
320 sb.append(",");
321 sb.append("A:");
322 sb.append(convertColorValue(color.getAlpha()));
323 return sb.toString();
324 }
325
326
335
344 protected String convertColorValue(int rgbVal)
345 {
346 StringBuffer sb = new StringBuffer (String.valueOf(rgbVal));
347 int length = sb.length();
348 if (length == 2) {
349 sb.insert(0, 0);
350 } else if (length == 1) {
351 sb.insert(0, 0);
352 sb.insert(1, 0);
353 } else if (length == 0) {
354 sb.insert(0, 0);
355 sb.insert(1, 0);
356 sb.insert(2, 0);
357 } else if (length > 3) {
358 throw new IllegalArgumentException ("Param rgbVal must not be > 3!");
359 }
360 return sb.toString();
361 }
362
363
368 public GeneralShape createGeneralShapeFromString(String initialValue)
369 {
370 StringTokenizer st = new StringTokenizer (initialValue);
371 int type = 0;
372 GeneralShape gp = new GeneralShape();
373 while (st.hasMoreTokens())
374 {
375 StringBuffer sb = new StringBuffer (st.nextToken());
376 if (sb.substring(0,1).equals("T")) {
377 type = new Integer (sb.substring(1,2)).intValue();
378 }
379
380 switch (type)
381 {
382 case (PathIterator.SEG_MOVETO):
383 float mx1 = new Double (st.nextToken()).floatValue();
384 float my1 = new Double (st.nextToken()).floatValue();
385 gp.moveTo(mx1,my1);
386 break;
387 case (PathIterator.SEG_LINETO):
388 float lx1 = new Double (st.nextToken()).floatValue();
389 float ly1 = new Double (st.nextToken()).floatValue();
390 gp.lineTo(lx1,ly1);
391 break;
392 case (PathIterator.SEG_QUADTO):
393 float qx1 = new Double (st.nextToken()).floatValue();
394 float qy1 = new Double (st.nextToken()).floatValue();
395 float qx2 = new Double (st.nextToken()).floatValue();
396 float qy2 = new Double (st.nextToken()).floatValue();
397 gp.quadTo(qx1,qy1,qx2,qy2);
398 break;
399 case (PathIterator.SEG_CUBICTO):
400 float cx1 = new Double (st.nextToken()).floatValue();
401 float cy1 = new Double (st.nextToken()).floatValue();
402 float cx2 = new Double (st.nextToken()).floatValue();
403 float cy2 = new Double (st.nextToken()).floatValue();
404 float cx3 = new Double (st.nextToken()).floatValue();
405 float cy3 = new Double (st.nextToken()).floatValue();
406 gp.curveTo(cx1,cy1,cx2,cy2,cx3,cy3);
407 break;
408 case (PathIterator.SEG_CLOSE):
409 gp.closePath();
410 break;
411 }
412 }
413 return gp;
414 }
415
416
421 public String convertGeneralShapeToString(Object instanceValue)
422 {
423 GeneralShape gp =(GeneralShape) instanceValue;
424 double[] coords = new double[6];
425 StringBuffer sb = new StringBuffer ();
426 for (PathIterator pi = gp.getPathIterator(null); !pi.isDone(); pi.next())
427 {
428 int segType = pi.currentSegment(coords);
429 sb.append("T");
430 sb.append(segType);
431 sb.append(" ");
432 switch (segType)
433 {
434 case (PathIterator.SEG_MOVETO):
435 writeDouble(coords[0], sb);
436 writeDouble(coords[1], sb);
437 break;
438 case (PathIterator.SEG_LINETO):
439 writeDouble(coords[0], sb);
440 writeDouble(coords[1], sb);
441 break;
442 case (PathIterator.SEG_QUADTO):
443 writeDouble(coords[0], sb);
444 writeDouble(coords[1], sb);
445 writeDouble(coords[2], sb);
446 writeDouble(coords[3], sb);
447 break;
448 case (PathIterator.SEG_CUBICTO):
449 writeDouble(coords[0], sb);
450 writeDouble(coords[1], sb);
451 writeDouble(coords[2], sb);
452 writeDouble(coords[3], sb);
453 writeDouble(coords[4], sb);
454 writeDouble(coords[5], sb);
455 break;
456 case (PathIterator.SEG_CLOSE):
457 break;
458 }
459 }
460 return sb.toString();
461 }
462
463 protected final static String atSeperator = ", ";
464
469 public AffineTransform createAffineTransformFromString(String initialValue)
470 {
471 StringTokenizer st = new StringTokenizer (initialValue, atSeperator);
473 double[] matrix = new double[6];
474 int matrixLength = 6;
475 for (int i=0; i<matrixLength; i++)
476 {
477 matrix[i] = new Double (st.nextToken()).doubleValue();
478 }
479 return new AffineTransform (matrix);
480 }
481
482
488 public String convertAffineTransformToString(Object instanceValue)
489 {
490 AffineTransform at = (AffineTransform ) instanceValue;
491 StringBuffer sb = new StringBuffer ();
492 double[] matrix = new double[6];
493 at.getMatrix(matrix);
494 for (int i=0; i<matrix.length; i++)
495 {
496 sb.append(matrix[i]);
497 if (i!=matrix.length-1)
498 sb.append(atSeperator);
499 }
500 return sb.toString();
501 }
502
503
508 public BufferedImage createBufferedImageFromString(String initialValue)
509 {
510 byte[] imageData = createByteArrayFromString(initialValue);
512 ByteArrayInputStream inputStream = new ByteArrayInputStream (imageData);
513 JPEGImageDecoder decoder = JPEGCodec.createJPEGDecoder(inputStream);
514 BufferedImage image = null;
515 try {
516 image = decoder.decodeAsBufferedImage();
517 } catch (ImageFormatException e) {
518 e.printStackTrace();
520 } catch (IOException e) {
521 e.printStackTrace();
523 }
524 return image;
525 }
526
527 public String convertBufferedImageToString(Object instanceValue)
567 {
568 BufferedImage image = (BufferedImage ) instanceValue;
569 ByteArrayOutputStream outputStream = new ByteArrayOutputStream ();
570 JPEGImageEncoder encoder = JPEGCodec.createJPEGEncoder(outputStream);
571 try {
572 encoder.encode(image);
573 } catch (ImageFormatException e) {
574 e.printStackTrace();
576 } catch (IOException e) {
577 e.printStackTrace();
579 }
580 byte[] imageData = outputStream.toByteArray();
581 String imageString = convertByteArrayToString(imageData);
582 return imageString;
583 }
584
585 protected static final char [] HEX_DIGITS =
586 { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
587
588 protected String convertByteArrayToString(byte[] instanceValue)
589 {
590 if (instanceValue == null)
591 {
592 return null;
593 }
594 else
595 {
596 byte [] bytes = instanceValue;
597 char [] result = new char[2 * bytes.length];
598 for (int i = 0, j = 0; i < bytes.length; ++i)
599 {
600 int high = (bytes[i] >> 4) & 0xF;
601 int low = bytes[i] & 0xF;
602 result[j++] = HEX_DIGITS[high];
603 result[j++] = HEX_DIGITS[low];
604 }
605 return new String (result);
606 }
607 }
608
609 protected byte[] createByteArrayFromString(String initialValue)
610 {
611 if (initialValue == null)
612 {
613 return null;
614 }
615
616 int size = initialValue.length();
617 int limit = (size + 1) / 2;
618 byte [] result = new byte[limit];
619 if (size % 2 != 0)
620 {
621 result[--limit] = hexCharToByte(initialValue.charAt(size - 1));
622 }
623
624 for (int i = 0, j = 0; i < limit; ++i)
625 {
626 byte high = hexCharToByte(initialValue.charAt(j++));
627 byte low = hexCharToByte(initialValue.charAt(j++));
628 result[i] = (byte)(high << 4 | low);
629 }
630 return result;
631 }
632
633 protected static byte hexCharToByte(char character)
634 {
635 switch (character)
636 {
637 case '0':
638 case '1':
639 case '2':
640 case '3':
641 case '4':
642 case '5':
643 case '6':
644 case '7':
645 case '8':
646 case '9':
647 {
648 return (byte)(character - '0');
649 }
650 case 'a':
651 case 'b':
652 case 'c':
653 case 'd':
654 case 'e':
655 case 'f':
656 {
657 return (byte)(character - 'a' + 10);
658 }
659 case 'A':
660 case 'B':
661 case 'C':
662 case 'D':
663 case 'E':
664 case 'F':
665 {
666 return (byte)(character - 'A' + 10);
667 }
668 default:
669 {
670 throw new NumberFormatException ("Invalid hexadecimal");
671 }
672 }
673 }
674
675 protected String writeDouble(double d, StringBuffer sb)
676 {
677 sb.append(d);
678 sb.append(" ");
679 return sb.toString();
680 }
681
682 } |
Popular Tags |
Java API By Example, From Geeks To Geeks.