1 7 package com.nightlabs.editor2d.impl; 8 9 import java.awt.Color ; 10 import java.awt.geom.AffineTransform ; 11 import java.awt.geom.PathIterator ; 12 import java.awt.image.BufferedImage ; 13 import java.io.ByteArrayInputStream ; 14 import java.io.ByteArrayOutputStream ; 15 import java.io.IOException ; 16 import java.util.StringTokenizer ; 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 43 public class Editor2DFactoryImpl 44 implements Editor2DFactory 45 { 46 52 public Editor2DFactoryImpl() { 53 super(); 54 } 55 56 80 106 111 public DrawComponent createDrawComponent() { 112 DrawComponentImpl drawComponent = new DrawComponentImpl(); 113 return drawComponent; 114 } 115 116 121 public ShapeDrawComponent createShapeDrawComponent() { 122 ShapeDrawComponentImpl shapeDrawComponent = new ShapeDrawComponentImpl(); 123 return shapeDrawComponent; 124 } 125 126 131 public Layer createLayer() { 132 LayerImpl layer = new LayerImpl(); 133 return layer; 134 } 135 136 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 ("Param mldc must not be null!"); 153 154 Editor2DFactory factory = Editor2DFactory.eINSTANCE; 156 157 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 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 191 public RectangleDrawComponent createRectangleDrawComponent() { 192 RectangleDrawComponentImpl rectangleDrawComponent = new RectangleDrawComponentImpl(); 193 return rectangleDrawComponent; 194 } 195 196 201 public EllipseDrawComponent createEllipseDrawComponent() { 202 EllipseDrawComponentImpl ellipseDrawComponent = new EllipseDrawComponentImpl(); 203 return ellipseDrawComponent; 204 } 205 206 211 public TextDrawComponent createTextDrawComponent() { 212 TextDrawComponentImpl textDrawComponent = new TextDrawComponentImpl(); 213 return textDrawComponent; 214 } 215 216 221 public DrawComponentContainer createDrawComponentContainer() { 222 DrawComponentContainerImpl drawComponentContainer = new DrawComponentContainerImpl(); 223 return drawComponentContainer; 224 } 225 226 231 public LineDrawComponent createLineDrawComponent() { 232 LineDrawComponentImpl lineDrawComponent = new LineDrawComponentImpl(); 233 return lineDrawComponent; 234 } 235 236 241 public EditorGuide createEditorGuide() { 242 EditorGuideImpl editorGuide = new EditorGuideImpl(); 243 return editorGuide; 244 } 245 246 251 public EditorRuler createEditorRuler() { 252 EditorRulerImpl editorRuler = new EditorRulerImpl(); 253 return editorRuler; 254 } 255 256 261 public ImageDrawComponent createImageDrawComponent() { 262 ImageDrawComponentImpl imageDrawComponent = new ImageDrawComponentImpl(); 263 return imageDrawComponent; 264 } 265 266 271 public Color createColorFromString(String initialValue) 272 { 273 StringBuffer sb = new StringBuffer (initialValue); 274 Integer integerRed = new Integer (sb.substring(2,5)); 275 Integer integerGreen = new Integer (sb.substring(8,11)); 276 Integer integerBlue = new Integer (sb.substring(14,17)); 277 Integer integerAlpha = new Integer (sb.substring(20,23)); 278 Color c = new Color (integerRed.intValue(), integerGreen.intValue(), integerBlue.intValue(), integerAlpha.intValue()); 279 return c; 280 } 281 282 287 public String convertColorToString(Object instanceValue) 288 { 289 java.awt.Color color = (java.awt.Color ) instanceValue; 290 StringBuffer sb = new StringBuffer (); 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 315 324 protected String convertColorValue(int rgbVal) 325 { 326 StringBuffer sb = new StringBuffer (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 ("Param rgbVal must not be > 3!"); 339 } 340 return sb.toString(); 341 } 342 343 348 public GeneralShape createGeneralShapeFromString(String initialValue) 349 { 350 StringTokenizer st = new StringTokenizer (initialValue); 351 int type = 0; 352 GeneralShape gp = new GeneralShape(); 353 while (st.hasMoreTokens()) 354 { 355 StringBuffer sb = new StringBuffer (st.nextToken()); 356 if (sb.substring(0,1).equals("T")) { 357 type = new Integer (sb.substring(1,2)).intValue(); 358 } 359 360 switch (type) 361 { 362 case (PathIterator.SEG_MOVETO): 363 float mx1 = new Double (st.nextToken()).floatValue(); 364 float my1 = new Double (st.nextToken()).floatValue(); 365 gp.moveTo(mx1,my1); 366 break; 367 case (PathIterator.SEG_LINETO): 368 float lx1 = new Double (st.nextToken()).floatValue(); 369 float ly1 = new Double (st.nextToken()).floatValue(); 370 gp.lineTo(lx1,ly1); 371 break; 372 case (PathIterator.SEG_QUADTO): 373 float qx1 = new Double (st.nextToken()).floatValue(); 374 float qy1 = new Double (st.nextToken()).floatValue(); 375 float qx2 = new Double (st.nextToken()).floatValue(); 376 float qy2 = new Double (st.nextToken()).floatValue(); 377 gp.quadTo(qx1,qy1,qx2,qy2); 378 break; 379 case (PathIterator.SEG_CUBICTO): 380 float cx1 = new Double (st.nextToken()).floatValue(); 381 float cy1 = new Double (st.nextToken()).floatValue(); 382 float cx2 = new Double (st.nextToken()).floatValue(); 383 float cy2 = new Double (st.nextToken()).floatValue(); 384 float cx3 = new Double (st.nextToken()).floatValue(); 385 float cy3 = new Double (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 401 public String convertGeneralShapeToString(Object instanceValue) 402 { 403 GeneralShape gp =(GeneralShape) instanceValue; 404 double[] coords = new double[6]; 405 StringBuffer sb = new StringBuffer (); 406 for (PathIterator 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 atSeperator = ", "; 444 449 public AffineTransform createAffineTransformFromString(String initialValue) 450 { 451 StringTokenizer st = new StringTokenizer (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 (st.nextToken()).doubleValue(); 458 } 459 return new AffineTransform (matrix); 460 } 461 462 468 public String convertAffineTransformToString(Object instanceValue) 469 { 470 AffineTransform at = (AffineTransform ) instanceValue; 471 StringBuffer sb = new StringBuffer (); 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 488 public BufferedImage createBufferedImageFromString(String initialValue) 489 { 490 byte[] imageData = createByteArrayFromString(initialValue); 492 ByteArrayInputStream inputStream = new ByteArrayInputStream (imageData); 493 JPEGImageDecoder decoder = JPEGCodec.createJPEGDecoder(inputStream); 494 BufferedImage image = null; 495 try { 496 image = decoder.decodeAsBufferedImage(); 497 } catch (ImageFormatException e) { 498 e.printStackTrace(); 500 } catch (IOException e) { 501 e.printStackTrace(); 503 } 504 return image; 505 } 506 507 public String convertBufferedImageToString(Object instanceValue) 547 { 548 BufferedImage image = (BufferedImage ) instanceValue; 549 ByteArrayOutputStream outputStream = new ByteArrayOutputStream (); 550 JPEGImageEncoder encoder = JPEGCodec.createJPEGEncoder(outputStream); 551 try { 552 encoder.encode(image); 553 } catch (ImageFormatException e) { 554 e.printStackTrace(); 556 } catch (IOException e) { 557 e.printStackTrace(); 559 } 560 byte[] imageData = outputStream.toByteArray(); 561 String 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 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 (result); 586 } 587 } 588 589 protected byte[] createByteArrayFromString(String 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 ("Invalid hexadecimal"); 651 } 652 } 653 } 654 655 protected String writeDouble(double d, StringBuffer sb) 656 { 657 sb.append(d); 658 sb.append(" "); 659 return sb.toString(); 660 } 661 662 } | Popular Tags |