KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > com > nightlabs > editor2d > impl > Editor2DFactoryImpl


1 /**
2  * <copyright>
3  * </copyright>
4  *
5  * $Id: Editor2DFactoryImpl.java 1634 2005-08-26 19:26:15Z nozkiller $
6  */

7 package com.nightlabs.editor2d.impl;
8
9 import java.awt.Color JavaDoc;
10 import java.awt.geom.AffineTransform JavaDoc;
11 import java.awt.geom.PathIterator JavaDoc;
12 import java.awt.image.BufferedImage JavaDoc;
13 import java.io.ByteArrayInputStream JavaDoc;
14 import java.io.ByteArrayOutputStream JavaDoc;
15 import java.io.IOException JavaDoc;
16 import java.util.StringTokenizer JavaDoc;
17
18 import com.nightlabs.editor2d.DrawComponent;
19 import com.nightlabs.editor2d.DrawComponentContainer;
20 import com.nightlabs.editor2d.Editor2DFactory;
21 import com.nightlabs.editor2d.EditorGuide;
22 import com.nightlabs.editor2d.EditorRuler;
23 import com.nightlabs.editor2d.EllipseDrawComponent;
24 import com.nightlabs.editor2d.ImageDrawComponent;
25 import com.nightlabs.editor2d.Layer;
26 import com.nightlabs.editor2d.LineDrawComponent;
27 import com.nightlabs.editor2d.MultiLayerDrawComponent;
28 import com.nightlabs.editor2d.RectangleDrawComponent;
29 import com.nightlabs.editor2d.ShapeDrawComponent;
30 import com.nightlabs.editor2d.TextDrawComponent;
31 import com.nightlabs.editor2d.j2d.GeneralShape;
32 import com.sun.image.codec.jpeg.ImageFormatException;
33 import com.sun.image.codec.jpeg.JPEGCodec;
34 import com.sun.image.codec.jpeg.JPEGImageDecoder;
35 import com.sun.image.codec.jpeg.JPEGImageEncoder;
36
37 /**
38  * <!-- begin-user-doc -->
39  * An implementation of the model <b>Factory</b>.
40  * <!-- end-user-doc -->
41  *
42  */

43 public class Editor2DFactoryImpl
44 implements Editor2DFactory
45 {
46     /**
47      * Creates an instance of the factory.
48      * <!-- begin-user-doc -->
49    * <!-- end-user-doc -->
50      * @generated
51      */

52   public Editor2DFactoryImpl() {
53         super();
54     }
55
56 // /**
57
// * <!-- begin-user-doc -->
58
// * <!-- end-user-doc -->
59
// * @generated
60
// */
61
// public Object createFromString(EDataType eDataType, String initialValue) {
62
// switch (eDataType.getClassifierID()) {
63
// case Editor2DPackage.COLOR:
64
// return createColorFromString(eDataType, initialValue);
65
// case Editor2DPackage.RECTANGLE:
66
// return createRectangleFromString(eDataType, initialValue);
67
// case Editor2DPackage.GENERAL_SHAPE:
68
// return createGeneralShapeFromString(eDataType, initialValue);
69
// case Editor2DPackage.AFFINE_TRANSFORM:
70
// return createAffineTransformFromString(eDataType, initialValue);
71
// case Editor2DPackage.BUFFERED_IMAGE:
72
// return createBufferedImageFromString(eDataType, initialValue);
73
// case Editor2DPackage.COLLECTION:
74
// return createCollectionFromString(eDataType, initialValue);
75
// default:
76
// throw new IllegalArgumentException("The datatype '" + eDataType.getName() + "' is not a valid classifier");
77
// }
78
// }
79

80 // /**
81
// * <!-- begin-user-doc -->
82
// * <!-- end-user-doc -->
83
// * @generated
84
// */
85
// public String convertToString(EDataType eDataType, Object instanceValue)
86
// {
87
// switch (eDataType.getClassifierID())
88
// {
89
// case Editor2DPackage.COLOR:
90
// return convertColorToString(eDataType, instanceValue);
91
// case Editor2DPackage.RECTANGLE:
92
// return convertRectangleToString(eDataType, instanceValue);
93
// case Editor2DPackage.GENERAL_SHAPE:
94
// return convertGeneralShapeToString(eDataType, instanceValue);
95
// case Editor2DPackage.AFFINE_TRANSFORM:
96
// return convertAffineTransformToString(eDataType, instanceValue);
97
// case Editor2DPackage.BUFFERED_IMAGE:
98
// return convertBufferedImageToString(eDataType, instanceValue);
99
// case Editor2DPackage.COLLECTION:
100
// return convertCollectionToString(eDataType, instanceValue);
101
// default:
102
// throw new IllegalArgumentException("The datatype '" + eDataType.getName() + "' is not a valid classifier");
103
// }
104
// }
105

106     /**
107      * <!-- begin-user-doc -->
108    * <!-- end-user-doc -->
109      * @generated
110      */

111   public DrawComponent createDrawComponent() {
112         DrawComponentImpl drawComponent = new DrawComponentImpl();
113         return drawComponent;
114     }
115
116     /**
117      * <!-- begin-user-doc -->
118    * <!-- end-user-doc -->
119      * @generated
120      */

121   public ShapeDrawComponent createShapeDrawComponent() {
122         ShapeDrawComponentImpl shapeDrawComponent = new ShapeDrawComponentImpl();
123         return shapeDrawComponent;
124     }
125
126     /**
127      * <!-- begin-user-doc -->
128    * <!-- end-user-doc -->
129      * @generated
130      */

131   public Layer createLayer() {
132         LayerImpl layer = new LayerImpl();
133         return layer;
134     }
135
136     /**
137      * <!-- begin-user-doc -->
138    * <!-- end-user-doc -->
139      * @generated
140      */

141   public MultiLayerDrawComponent createMultiLayerDrawComponent() {
142         MultiLayerDrawComponentImpl multiLayerDrawComponent = new MultiLayerDrawComponentImpl();
143         validateMLDC(multiLayerDrawComponent);
144         return multiLayerDrawComponent;
145     }
146
147   public static final int UNIT_PIXELS = 2;
148   public static final int UNIT_CENTIMETER = 1;
149   protected void validateMLDC(MultiLayerDrawComponent mldc)
150   {
151     if (mldc == null)
152       throw new IllegalStateException JavaDoc("Param mldc must not be null!");
153     
154     // create Factory
155
Editor2DFactory factory = Editor2DFactory.eINSTANCE;
156     
157     // check Layers
158
if (mldc.getCurrentLayer() == null)
159     {
160       Layer l = factory.createLayer();
161       if (l.getParent() == null)
162         l.setParent(mldc);
163       
164       mldc.addDrawComponent(l);
165       mldc.setCurrentLayer(l);
166     }
167     
168     // check Rulers
169
if (mldc.getLeftRuler() == null)
170     {
171       EditorRuler leftRuler = factory.createEditorRuler();
172       leftRuler.setHorizontal(false);
173       leftRuler.setUnit(UNIT_PIXELS);
174       mldc.setLeftRuler(leftRuler);
175     }
176     
177     if (mldc.getTopRuler() == null)
178     {
179       EditorRuler topRuler = factory.createEditorRuler();
180       topRuler.setHorizontal(true);
181       topRuler.setUnit(UNIT_PIXELS);
182       mldc.setTopRuler(topRuler);
183     }
184   }
185   
186     /**
187      * <!-- begin-user-doc -->
188    * <!-- end-user-doc -->
189      * @generated
190      */

191   public RectangleDrawComponent createRectangleDrawComponent() {
192         RectangleDrawComponentImpl rectangleDrawComponent = new RectangleDrawComponentImpl();
193         return rectangleDrawComponent;
194     }
195
196     /**
197      * <!-- begin-user-doc -->
198    * <!-- end-user-doc -->
199      * @generated
200      */

201   public EllipseDrawComponent createEllipseDrawComponent() {
202         EllipseDrawComponentImpl ellipseDrawComponent = new EllipseDrawComponentImpl();
203         return ellipseDrawComponent;
204     }
205
206     /**
207      * <!-- begin-user-doc -->
208    * <!-- end-user-doc -->
209      * @generated
210      */

211   public TextDrawComponent createTextDrawComponent() {
212         TextDrawComponentImpl textDrawComponent = new TextDrawComponentImpl();
213         return textDrawComponent;
214     }
215
216     /**
217      * <!-- begin-user-doc -->
218    * <!-- end-user-doc -->
219      * @generated
220      */

221   public DrawComponentContainer createDrawComponentContainer() {
222         DrawComponentContainerImpl drawComponentContainer = new DrawComponentContainerImpl();
223         return drawComponentContainer;
224     }
225
226     /**
227      * <!-- begin-user-doc -->
228    * <!-- end-user-doc -->
229      * @generated
230      */

231   public LineDrawComponent createLineDrawComponent() {
232         LineDrawComponentImpl lineDrawComponent = new LineDrawComponentImpl();
233         return lineDrawComponent;
234     }
235
236     /**
237      * <!-- begin-user-doc -->
238    * <!-- end-user-doc -->
239      * @generated
240      */

241   public EditorGuide createEditorGuide() {
242         EditorGuideImpl editorGuide = new EditorGuideImpl();
243         return editorGuide;
244     }
245
246     /**
247      * <!-- begin-user-doc -->
248    * <!-- end-user-doc -->
249      * @generated
250      */

251   public EditorRuler createEditorRuler() {
252         EditorRulerImpl editorRuler = new EditorRulerImpl();
253         return editorRuler;
254     }
255
256     /**
257      * <!-- begin-user-doc -->
258    * <!-- end-user-doc -->
259      * @generated
260      */

261   public ImageDrawComponent createImageDrawComponent() {
262         ImageDrawComponentImpl imageDrawComponent = new ImageDrawComponentImpl();
263         return imageDrawComponent;
264     }
265
266   /**
267    * <!-- begin-user-doc -->
268    * <!-- end-user-doc -->
269    *
270    */

271   public Color JavaDoc createColorFromString(String JavaDoc initialValue)
272   {
273     StringBuffer JavaDoc sb = new StringBuffer JavaDoc(initialValue);
274     Integer JavaDoc integerRed = new Integer JavaDoc(sb.substring(2,5));
275     Integer JavaDoc integerGreen = new Integer JavaDoc(sb.substring(8,11));
276     Integer JavaDoc integerBlue = new Integer JavaDoc(sb.substring(14,17));
277     Integer JavaDoc integerAlpha = new Integer JavaDoc(sb.substring(20,23));
278     Color JavaDoc c = new Color JavaDoc(integerRed.intValue(), integerGreen.intValue(), integerBlue.intValue(), integerAlpha.intValue());
279     return c;
280   }
281
282   /**
283    * <!-- begin-user-doc -->
284    * <!-- end-user-doc -->
285    *
286    */

287   public String JavaDoc convertColorToString(Object JavaDoc instanceValue)
288   {
289     java.awt.Color JavaDoc color = (java.awt.Color JavaDoc) instanceValue;
290     StringBuffer JavaDoc sb = new StringBuffer JavaDoc();
291     
292     sb.append("R:");
293     sb.append(convertColorValue(color.getRed()));
294     sb.append(",");
295     sb.append("G:");
296     sb.append(convertColorValue(color.getGreen()));
297     sb.append(",");
298     sb.append("B:");
299     sb.append(convertColorValue(color.getBlue()));
300     sb.append(",");
301     sb.append("A:");
302     sb.append(convertColorValue(color.getAlpha()));
303     return sb.toString();
304   }
305
306 // /**
307
// * <!-- begin-user-doc -->
308
// * <!-- end-user-doc -->
309
// * @generated
310
// */
311
// public Rectangle createRectangleFromString(EDataType eDataType, String initialValue) {
312
// return (Rectangle)super.createFromString(eDataType, initialValue);
313
// }
314

315 // /**
316
// * <!-- begin-user-doc -->
317
// * <!-- end-user-doc -->
318
// * @generated
319
// */
320
// public String convertRectangleToString(Object instanceValue) {
321
// return super.convertToString(eDataType, instanceValue);
322
// }
323

324   protected String JavaDoc convertColorValue(int rgbVal)
325   {
326     StringBuffer JavaDoc sb = new StringBuffer JavaDoc(String.valueOf(rgbVal));
327     int length = sb.length();
328     if (length == 2) {
329       sb.insert(0, 0);
330     } else if (length == 1) {
331       sb.insert(0, 0);
332       sb.insert(1, 0);
333     } else if (length == 0) {
334       sb.insert(0, 0);
335       sb.insert(1, 0);
336       sb.insert(2, 0);
337     } else if (length > 3) {
338       throw new IllegalArgumentException JavaDoc("Param rgbVal must not be > 3!");
339     }
340     return sb.toString();
341   }
342     
343   /**
344    * <!-- begin-user-doc -->
345    * <!-- end-user-doc -->
346    *
347    */

348   public GeneralShape createGeneralShapeFromString(String JavaDoc initialValue)
349   {
350     StringTokenizer JavaDoc st = new StringTokenizer JavaDoc(initialValue);
351     int type = 0;
352     GeneralShape gp = new GeneralShape();
353     while (st.hasMoreTokens())
354     {
355       StringBuffer JavaDoc sb = new StringBuffer JavaDoc(st.nextToken());
356       if (sb.substring(0,1).equals("T")) {
357         type = new Integer JavaDoc(sb.substring(1,2)).intValue();
358       }
359       
360       switch (type)
361       {
362         case (PathIterator.SEG_MOVETO):
363           float mx1 = new Double JavaDoc(st.nextToken()).floatValue();
364             float my1 = new Double JavaDoc(st.nextToken()).floatValue();
365             gp.moveTo(mx1,my1);
366             break;
367         case (PathIterator.SEG_LINETO):
368           float lx1 = new Double JavaDoc(st.nextToken()).floatValue();
369             float ly1 = new Double JavaDoc(st.nextToken()).floatValue();
370             gp.lineTo(lx1,ly1);
371             break;
372         case (PathIterator.SEG_QUADTO):
373           float qx1 = new Double JavaDoc(st.nextToken()).floatValue();
374             float qy1 = new Double JavaDoc(st.nextToken()).floatValue();
375           float qx2 = new Double JavaDoc(st.nextToken()).floatValue();
376             float qy2 = new Double JavaDoc(st.nextToken()).floatValue();
377             gp.quadTo(qx1,qy1,qx2,qy2);
378             break;
379         case (PathIterator.SEG_CUBICTO):
380           float cx1 = new Double JavaDoc(st.nextToken()).floatValue();
381             float cy1 = new Double JavaDoc(st.nextToken()).floatValue();
382           float cx2 = new Double JavaDoc(st.nextToken()).floatValue();
383             float cy2 = new Double JavaDoc(st.nextToken()).floatValue();
384           float cx3 = new Double JavaDoc(st.nextToken()).floatValue();
385             float cy3 = new Double JavaDoc(st.nextToken()).floatValue();
386             gp.curveTo(cx1,cy1,cx2,cy2,cx3,cy3);
387             break;
388         case (PathIterator.SEG_CLOSE):
389           gp.closePath();
390             break;
391       }
392     }
393     return gp;
394   }
395
396   /**
397    * <!-- begin-user-doc -->
398    * <!-- end-user-doc -->
399    *
400    */

401   public String JavaDoc convertGeneralShapeToString(Object JavaDoc instanceValue)
402   {
403     GeneralShape gp =(GeneralShape) instanceValue;
404     double[] coords = new double[6];
405     StringBuffer JavaDoc sb = new StringBuffer JavaDoc();
406     for (PathIterator JavaDoc pi = gp.getPathIterator(null); !pi.isDone(); pi.next())
407     {
408       int segType = pi.currentSegment(coords);
409       sb.append("T");
410       sb.append(segType);
411       sb.append(" ");
412       switch (segType)
413       {
414         case (PathIterator.SEG_MOVETO):
415             writeDouble(coords[0], sb);
416             writeDouble(coords[1], sb);
417           break;
418         case (PathIterator.SEG_LINETO):
419                 writeDouble(coords[0], sb);
420                 writeDouble(coords[1], sb);
421           break;
422         case (PathIterator.SEG_QUADTO):
423                 writeDouble(coords[0], sb);
424                 writeDouble(coords[1], sb);
425                 writeDouble(coords[2], sb);
426                 writeDouble(coords[3], sb);
427           break;
428         case (PathIterator.SEG_CUBICTO):
429                 writeDouble(coords[0], sb);
430                 writeDouble(coords[1], sb);
431                 writeDouble(coords[2], sb);
432                 writeDouble(coords[3], sb);
433                 writeDouble(coords[4], sb);
434                 writeDouble(coords[5], sb);
435           break;
436         case (PathIterator.SEG_CLOSE):
437           break;
438       }
439     }
440     return sb.toString();
441   }
442     
443   protected final static String JavaDoc atSeperator = ", ";
444   /**
445    * <!-- begin-user-doc -->
446    * <!-- end-user-doc -->
447    *
448    */

449   public AffineTransform JavaDoc createAffineTransformFromString(String JavaDoc initialValue)
450   {
451 // return (AffineTransform)super.createFromString(eDataType, initialValue);
452
StringTokenizer JavaDoc st = new StringTokenizer JavaDoc(initialValue, atSeperator);
453     double[] matrix = new double[6];
454     int matrixLength = 6;
455     for (int i=0; i<matrixLength; i++)
456     {
457       matrix[i] = new Double JavaDoc(st.nextToken()).doubleValue();
458     }
459     return new AffineTransform JavaDoc(matrix);
460   }
461   
462   /**
463    * <!-- begin-user-doc -->
464    * <!-- end-user-doc -->
465    *
466    * converts the AffineTransform Matrix into a String, similar to AffineTransform.toString()
467    */

468   public String JavaDoc convertAffineTransformToString(Object JavaDoc instanceValue)
469   {
470     AffineTransform JavaDoc at = (AffineTransform JavaDoc) instanceValue;
471     StringBuffer JavaDoc sb = new StringBuffer JavaDoc();
472     double[] matrix = new double[6];
473     at.getMatrix(matrix);
474     for (int i=0; i<matrix.length; i++)
475     {
476       sb.append(matrix[i]);
477       if (i!=matrix.length-1)
478         sb.append(atSeperator);
479     }
480     return sb.toString();
481   }
482
483   /**
484    * <!-- begin-user-doc -->
485    * <!-- end-user-doc -->
486    *
487    */

488   public BufferedImage JavaDoc createBufferedImageFromString(String JavaDoc initialValue)
489   {
490 // return (BufferedImage)super.createFromString(eDataType, initialValue);
491
byte[] imageData = createByteArrayFromString(initialValue);
492     ByteArrayInputStream JavaDoc inputStream = new ByteArrayInputStream JavaDoc(imageData);
493     JPEGImageDecoder decoder = JPEGCodec.createJPEGDecoder(inputStream);
494     BufferedImage JavaDoc image = null;
495     try {
496       image = decoder.decodeAsBufferedImage();
497     } catch (ImageFormatException e) {
498       // TODO Auto-generated catch block
499
e.printStackTrace();
500     } catch (IOException JavaDoc e) {
501       // TODO Auto-generated catch block
502
e.printStackTrace();
503     }
504     return image;
505   }
506
507 // public String convertBufferedImageToString(EDataType eDataType, Object instanceValue)
508
// {
509
// return super.convertToString(eDataType, instanceValue);
510
//// MessageDigest md;
511
//// String hash = "";
512
//// try
513
//// {
514
//// md = MessageDigest.getInstance("SHA");
515
//// BufferedImage image = (BufferedImage) instanceValue;
516
//// DataBuffer dataBuffer = image.getData().getDataBuffer();
517
//// int dataType = dataBuffer.getDataType();
518
//// if (dataType == DataBuffer.TYPE_BYTE)
519
//// {
520
//// DataBufferByte byteBuffer = (DataBufferByte) dataBuffer;
521
//// byte[][] bankData = byteBuffer.getBankData();
522
//// for (int i = 0; i < bankData.length; i++)
523
//// {
524
//// byte[] byteArray = bankData[i];
525
//// md.update(byteArray);
526
//// }
527
//// }
528
//// byte[] d = md.digest();
529
//// StringBuffer digestStr = new StringBuffer();
530
//// for (int i = 0; i < d.length; ++i)
531
//// {
532
//// String b = Integer.toHexString((int)d[i] & 0xFF);
533
//// if (b.length() == 1)
534
//// digestStr.append('0');
535
////
536
//// digestStr.append(b);
537
//// }
538
//// hash = digestStr.toString();
539
//// }
540
//// catch (NoSuchAlgorithmException e) {
541
//// // TODO Auto-generated catch block
542
//// e.printStackTrace();
543
//// }
544
//// return hash;
545
// }
546
public String JavaDoc convertBufferedImageToString(Object JavaDoc instanceValue)
547   {
548         BufferedImage JavaDoc image = (BufferedImage JavaDoc) instanceValue;
549         ByteArrayOutputStream JavaDoc outputStream = new ByteArrayOutputStream JavaDoc();
550         JPEGImageEncoder encoder = JPEGCodec.createJPEGEncoder(outputStream);
551         try {
552       encoder.encode(image);
553     } catch (ImageFormatException e) {
554       // TODO Auto-generated catch block
555
e.printStackTrace();
556     } catch (IOException JavaDoc e) {
557       // TODO Auto-generated catch block
558
e.printStackTrace();
559     }
560         byte[] imageData = outputStream.toByteArray();
561         String JavaDoc imageString = convertByteArrayToString(imageData);
562         return imageString;
563   }
564   
565   protected static final char [] HEX_DIGITS =
566   { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
567   
568   protected String JavaDoc convertByteArrayToString(byte[] instanceValue)
569   {
570     if (instanceValue == null)
571     {
572       return null;
573     }
574     else
575     {
576       byte [] bytes = instanceValue;
577       char [] result = new char[2 * bytes.length];
578       for (int i = 0, j = 0; i < bytes.length; ++i)
579       {
580         int high = (bytes[i] >> 4) & 0xF;
581         int low = bytes[i] & 0xF;
582         result[j++] = HEX_DIGITS[high];
583         result[j++] = HEX_DIGITS[low];
584       }
585       return new String JavaDoc(result);
586     }
587   }
588   
589   protected byte[] createByteArrayFromString(String JavaDoc initialValue)
590   {
591     if (initialValue == null)
592     {
593       return null;
594     }
595
596     int size = initialValue.length();
597     int limit = (size + 1) / 2;
598     byte [] result = new byte[limit];
599     if (size % 2 != 0)
600     {
601       result[--limit] = hexCharToByte(initialValue.charAt(size - 1));
602     }
603     
604     for (int i = 0, j = 0; i < limit; ++i)
605     {
606       byte high = hexCharToByte(initialValue.charAt(j++));
607       byte low = hexCharToByte(initialValue.charAt(j++));
608       result[i] = (byte)(high << 4 | low);
609     }
610     return result;
611   }
612   
613   protected static byte hexCharToByte(char character)
614   {
615     switch (character)
616     {
617       case '0':
618       case '1':
619       case '2':
620       case '3':
621       case '4':
622       case '5':
623       case '6':
624       case '7':
625       case '8':
626       case '9':
627       {
628         return (byte)(character - '0');
629       }
630       case 'a':
631       case 'b':
632       case 'c':
633       case 'd':
634       case 'e':
635       case 'f':
636       {
637         return (byte)(character - 'a' + 10);
638       }
639       case 'A':
640       case 'B':
641       case 'C':
642       case 'D':
643       case 'E':
644       case 'F':
645       {
646         return (byte)(character - 'A' + 10);
647       }
648       default:
649       {
650         throw new NumberFormatException JavaDoc("Invalid hexadecimal");
651       }
652     }
653   }
654   
655   protected String JavaDoc writeDouble(double d, StringBuffer JavaDoc sb)
656   {
657     sb.append(d);
658     sb.append(" ");
659     return sb.toString();
660   }
661   
662 } //Editor2DFactoryImpl
663
Popular Tags