1 /*\r
2 * A simple utility for exporting Inkscape svg Shapes as JavaFX paths.\r
3 *\r
4 * For information on the JavaFX file format, see:\r
5 * https://openjfx.dev.java.net/\r
6 *\r
7 * Authors:\r
8 * Bob Jamison <ishmal@inkscape.org>\r
9 * Silveira Neto <silveiraneto@gmail.com>\r
10 * Jim Clarke <Jim.Clarke@sun.com>\r
11 *\r
12 * Copyright (C) 2008 Authors\r
13 *\r
14 * Released under GNU GPL, read the file 'COPYING' for more information\r
15 */\r
16 \r
17 \r
18 #ifdef HAVE_CONFIG_H\r
19 # include <config.h>\r
20 #endif\r
21 #include "javafx-out.h"\r
22 #include <inkscape.h>\r
23 #include <inkscape_version.h>\r
24 #include <sp-path.h>\r
25 #include <sp-linear-gradient.h>\r
26 #include <sp-radial-gradient.h>\r
27 #include <style.h>\r
28 #include <display/curve.h>\r
29 #include <display/canvas-bpath.h>\r
30 #include <svg/svg.h>\r
31 #include <extension/system.h>\r
32 #include <2geom/pathvector.h>\r
33 #include <2geom/rect.h>\r
34 #include <2geom/bezier-curve.h>\r
35 #include <2geom/hvlinesegment.h>\r
36 #include "helper/geom.h"\r
37 #include "helper/geom-curves.h"\r
38 #include <io/sys.h>\r
39 \r
40 \r
41 #include <string>\r
42 #include <stdio.h>\r
43 #include <stdarg.h>\r
44 \r
45 \r
46 namespace Inkscape\r
47 {\r
48 namespace Extension\r
49 {\r
50 namespace Internal\r
51 {\r
52 \r
53 \r
54 \r
55 \r
56 //########################################################################\r
57 //# M E S S A G E S\r
58 //########################################################################\r
59 \r
60 static void err(const char *fmt, ...)\r
61 {\r
62 va_list args;\r
63 g_log(NULL, G_LOG_LEVEL_WARNING, "javafx-out err: ");\r
64 va_start(args, fmt);\r
65 g_logv(NULL, G_LOG_LEVEL_WARNING, fmt, args);\r
66 va_end(args);\r
67 g_log(NULL, G_LOG_LEVEL_WARNING, "\n");\r
68 }\r
69 \r
70 \r
71 //########################################################################\r
72 //# U T I L I T Y\r
73 //########################################################################\r
74 \r
75 /**\r
76 * Got this method from Bulia, and modified it a bit. It basically\r
77 * starts with this style, gets its SPObject parent, walks up the object\r
78 * tree and finds all of the opacities and multiplies them.\r
79 *\r
80 * We use this for our "flat" object output. If the code is modified\r
81 * to reflect a tree of <groups>, then this will be unneccessary.\r
82 */\r
83 static double effective_opacity(const SPStyle *style)\r
84 {\r
85 double val = 1.0;\r
86 for (SPObject const *obj = style->object; obj ; obj = obj->parent)\r
87 {\r
88 style = SP_OBJECT_STYLE(obj);\r
89 if (style)\r
90 val *= SP_SCALE24_TO_FLOAT(style->opacity.value);\r
91 }\r
92 return val;\r
93 }\r
94 \r
95 //########################################################################\r
96 //# OUTPUT FORMATTING\r
97 //########################################################################\r
98 \r
99 \r
100 /**\r
101 * We want to control floating output format.\r
102 * Especially to avoid localization. (decimal ',' for example)\r
103 */\r
104 static JavaFXOutput::String dstr(double d)\r
105 {\r
106 char dbuf[G_ASCII_DTOSTR_BUF_SIZE+1];\r
107 g_ascii_formatd(dbuf, G_ASCII_DTOSTR_BUF_SIZE,\r
108 "%.8f", (gdouble)d);\r
109 JavaFXOutput::String s = dbuf;\r
110 return s;\r
111 }\r
112 \r
113 #define DSTR(d) (dstr(d).c_str())\r
114 \r
115 \r
116 /**\r
117 * Format a double as an integer\r
118 */\r
119 static JavaFXOutput::String istr(double d)\r
120 {\r
121 char dbuf[G_ASCII_DTOSTR_BUF_SIZE+1];\r
122 g_ascii_formatd(dbuf, G_ASCII_DTOSTR_BUF_SIZE,\r
123 "%.0f", (gdouble)d);\r
124 JavaFXOutput::String s = dbuf;\r
125 return s;\r
126 }\r
127 \r
128 #define ISTR(d) (istr(d).c_str())\r
129 \r
130 \r
131 /**\r
132 * Format an rgba() string\r
133 */\r
134 static JavaFXOutput::String rgba(guint32 rgba)\r
135 {\r
136 unsigned int r = SP_RGBA32_R_U(rgba);\r
137 unsigned int g = SP_RGBA32_G_U(rgba);\r
138 unsigned int b = SP_RGBA32_B_U(rgba);\r
139 unsigned int a = SP_RGBA32_A_U(rgba);\r
140 char buf[80];\r
141 snprintf(buf, 79, "Color.rgb(0x%02x, 0x%02x, 0x%02x, %s)",\r
142 r, g, b, DSTR((double)a/256.0));\r
143 JavaFXOutput::String s = buf;\r
144 return s;\r
145 }\r
146 \r
147 \r
148 /**\r
149 * Format an rgba() string for a color and a 0.0-1.0 alpha\r
150 */\r
151 static JavaFXOutput::String rgba(SPColor color, gdouble alpha)\r
152 {\r
153 return rgba(color.toRGBA32(alpha));\r
154 }\r
155 \r
156 /**\r
157 * Map Inkscape linecap styles to JavaFX\r
158 */\r
159 static JavaFXOutput::String getStrokeLineCap(unsigned value) {\r
160 switch(value) {\r
161 case SP_STROKE_LINECAP_BUTT:\r
162 return "StrokeLineCap.BUTT";\r
163 case SP_STROKE_LINECAP_ROUND:\r
164 return "StrokeLineCap.ROUND";\r
165 case SP_STROKE_LINECAP_SQUARE:\r
166 return "StrokeLineCap.SQUARE";\r
167 default:\r
168 return "INVALID LINE CAP";\r
169 }\r
170 }\r
171 \r
172 \r
173 /**\r
174 * Map Inkscape linejoin styles to JavaFX\r
175 */\r
176 static JavaFXOutput::String getStrokeLineJoin(unsigned value) {\r
177 switch(value) {\r
178 case SP_STROKE_LINEJOIN_MITER:\r
179 return "StrokeLineJoin.MITER";\r
180 case SP_STROKE_LINEJOIN_ROUND:\r
181 return "StrokeLineJoin.ROUND";\r
182 case SP_STROKE_LINEJOIN_BEVEL:\r
183 return "StrokeLineJoin.BEVEL";\r
184 default:\r
185 return "INVALID LINE JOIN";\r
186 }\r
187 }\r
188 \r
189 \r
190 /**\r
191 * Replace illegal characters for JavaFX for a underscore.\r
192 */\r
193 static JavaFXOutput::String sanatize(const JavaFXOutput::String &badstr){\r
194 JavaFXOutput::String good(badstr);\r
195 for (int pos = 0; pos < badstr.length(); ++pos )\r
196 if((badstr.at(pos)=='-')||(badstr.at(pos)==' '))\r
197 good.replace(pos, 1, "_");\r
198 return good;\r
199 }\r
200 \r
201 /**\r
202 * Output data to the buffer, printf()-style\r
203 */\r
204 void JavaFXOutput::out(const char *fmt, ...)\r
205 {\r
206 va_list args;\r
207 va_start(args, fmt);\r
208 gchar *output = g_strdup_vprintf(fmt, args);\r
209 va_end(args);\r
210 outbuf.append(output);\r
211 g_free(output);\r
212 }\r
213 \r
214 \r
215 \r
216 /**\r
217 * Output the file header\r
218 */\r
219 bool JavaFXOutput::doHeader()\r
220 {\r
221 time_t tim = time(NULL);\r
222 out("/*###################################################################\n");\r
223 out("### This JavaFX document was generated by Inkscape\n");\r
224 out("### http://www.inkscape.org\n");\r
225 out("### Created: %s", ctime(&tim));\r
226 out("### Version: %s\n", INKSCAPE_VERSION);\r
227 out("#####################################################################\n");\r
228 out("### NOTES:\n");\r
229 out("### ============\n");\r
230 out("### JavaFX information can be found at\n");\r
231 out("### hhttps://openjfx.dev.java.net\n");\r
232 out("###\n");\r
233 out("### If you have any problems with this output, please see the\n");\r
234 out("### Inkscape project at http://www.inkscape.org, or visit\n");\r
235 out("### the #inkscape channel on irc.freenode.net . \n");\r
236 out("###\n");\r
237 out("###################################################################*/\n");\r
238 out("\n\n");\r
239 out("/*###################################################################\n");\r
240 out("## Exports in this file\n");\r
241 out("##==========================\n");\r
242 out("## Shapes : %d\n", nrShapes);\r
243 out("## Nodes : %d\n", nrNodes);\r
244 out("###################################################################*/\n");\r
245 out("\n\n");\r
246 \r
247 // import javafx libraries we can need\r
248 out("import javafx.application.*;\n");\r
249 out("import javafx.scene.*;\n");\r
250 out("import javafx.scene.geometry.*;\n");\r
251 out("import javafx.scene.transform.*;\n");\r
252 out("import javafx.scene.paint.*;\n");\r
253 out("\n");\r
254 \r
255 out("\n\n");\r
256 \r
257 // Creates a class extended from CustomNode\r
258 out("public class %s extends CustomNode {\n", name.c_str());\r
259 \r
260 return true;\r
261 }\r
262 \r
263 \r
264 \r
265 /**\r
266 * Output the file footer\r
267 */\r
268 bool JavaFXOutput::doTail()\r
269 {\r
270 float border = 25.0;\r
271 \r
272 // Write the tail of CustomNode\r
273 out(" ] // content\n");\r
274 out(" transform: Translate { x : %s, y : %s }\n",\r
275 DSTR((-minx) + border), DSTR((-miny) + border) );\r
276 out(" } // Group\n");\r
277 out(" } // function create()\n");\r
278 out("} // class %s\n", name.c_str());\r
279 out("\n");\r
280 \r
281 // Frame\r
282 out("Frame {\n");\r
283 out(" title: \"%s\"\n", name.c_str());\r
284 out(" width: %s\n", ISTR(maxx-minx + border * 2.0));\r
285 out(" height: %s\n", ISTR(maxy-miny + border * 2.0));\r
286 out(" visible: true\n");\r
287 \r
288 // Stage\r
289 out(" stage: Stage {\n");\r
290 out(" content: %s{}\n", name.c_str());\r
291 out(" } // Stage\n");\r
292 \r
293 out("} // Frame\n");\r
294 \r
295 out("\n");\r
296 \r
297 out("/*###################################################################\n");\r
298 out("### E N D C L A S S %s\n", name.c_str());\r
299 out("###################################################################*/\n");\r
300 out("\n\n");\r
301 return true;\r
302 }\r
303 \r
304 \r
305 \r
306 /**\r
307 * Output gradient information to the buffer\r
308 */\r
309 bool JavaFXOutput::doGradient(SPGradient *grad, const String &id)\r
310 {\r
311 String jfxid = sanatize(id);\r
312 \r
313 if (SP_IS_LINEARGRADIENT(grad))\r
314 {\r
315 SPLinearGradient *g = SP_LINEARGRADIENT(grad);\r
316 out(" /* create LinearGradient for %s */\n", jfxid.c_str());\r
317 out(" private function %s(): LinearGradient {\n", jfxid.c_str());\r
318 out(" LinearGradient {\n");\r
319 std::vector<SPGradientStop> stops = g->vector.stops;\r
320 if (stops.size() > 0)\r
321 {\r
322 out(" stops:\n");\r
323 out(" [\n");\r
324 for (unsigned int i = 0 ; i<stops.size() ; i++)\r
325 {\r
326 SPGradientStop stop = stops[i];\r
327 out(" Stop {\n");\r
328 out(" offset: %s\n", DSTR(stop.offset));\r
329 out(" color: %s\n", rgba(stop.color, stop.opacity).c_str());\r
330 out(" },\n");\r
331 }\r
332 out(" ]\n");\r
333 }\r
334 out(" };\n");\r
335 out(" } // end LinearGradient: %s\n", jfxid.c_str());\r
336 out("\n\n");\r
337 }\r
338 else if (SP_IS_RADIALGRADIENT(grad))\r
339 {\r
340 SPRadialGradient *g = SP_RADIALGRADIENT(grad);\r
341 out(" /* create RadialGradient for %s */\n", jfxid.c_str());\r
342 out(" private function %s() {\n", jfxid.c_str());\r
343 out(" RadialGradient {\n");\r
344 out(" centerX: %s\n", DSTR(g->cx.value));\r
345 out(" centerY: %s\n", DSTR(g->cy.value));\r
346 out(" focusX: %s\n", DSTR(g->fx.value));\r
347 out(" focusY: %s\n", DSTR(g->fy.value));\r
348 out(" radius: %s\n", DSTR(g->r.value ));\r
349 std::vector<SPGradientStop> stops = g->vector.stops;\r
350 if (stops.size() > 0)\r
351 {\r
352 out(" stops:\n");\r
353 out(" [\n");\r
354 for (unsigned int i = 0 ; i<stops.size() ; i++)\r
355 {\r
356 SPGradientStop stop = stops[i];\r
357 out(" Stop {\n");\r
358 out(" offset: %s\n", DSTR(stop.offset));\r
359 out(" color: %s\n", rgba(stop.color, stop.opacity).c_str());\r
360 out(" },\n");\r
361 }\r
362 out(" ]\n");\r
363 }\r
364 out(" };\n");\r
365 out(" } // end RadialGradient: %s\n", jfxid.c_str());\r
366 out("\n\n");\r
367 }\r
368 else\r
369 {\r
370 err("Unknown gradient type for '%s'\n", jfxid.c_str());\r
371 return false;\r
372 }\r
373 \r
374 \r
375 return true;\r
376 }\r
377 \r
378 \r
379 \r
380 \r
381 /**\r
382 * Output an element's style attribute\r
383 */\r
384 bool JavaFXOutput::doStyle(SPStyle *style)\r
385 {\r
386 if (!style)\r
387 return true;\r
388 \r
389 out(" opacity: %s\n", DSTR(effective_opacity(style)));\r
390 \r
391 /**\r
392 * Fill\r
393 */\r
394 SPIPaint fill = style->fill;\r
395 if (fill.isColor())\r
396 {\r
397 // see color.h for how to parse SPColor\r
398 out(" fill: %s\n",\r
399 rgba(fill.value.color, SP_SCALE24_TO_FLOAT(style->fill_opacity.value)).c_str());\r
400 }\r
401 else if (fill.isPaintserver()){\r
402 if (fill.value.href && fill.value.href->getURI() ){\r
403 String uri = fill.value.href->getURI()->toString();\r
404 /* trim the anchor '#' from the front */\r
405 if (uri.size() > 0 && uri[0]=='#')\r
406 uri = uri.substr(1);\r
407 out(" fill: %s()\n", sanatize(uri).c_str());\r
408 }\r
409 }\r
410 \r
411 \r
412 /**\r
413 * Stroke\r
414 */\r
415 /**\r
416 *NOTE: Things in style we can use:\r
417 * SPIPaint stroke;\r
418 * SPILength stroke_width;\r
419 * SPIEnum stroke_linecap;\r
420 * SPIEnum stroke_linejoin;\r
421 * SPIFloat stroke_miterlimit;\r
422 * NRVpathDash stroke_dash;\r
423 * unsigned stroke_dasharray_set : 1;\r
424 * unsigned stroke_dasharray_inherit : 1;\r
425 * unsigned stroke_dashoffset_set : 1;\r
426 * SPIScale24 stroke_opacity;\r
427 */\r
428 if (style->stroke_opacity.value > 0)\r
429 {\r
430 SPIPaint stroke = style->stroke;\r
431 out(" stroke: %s\n",\r
432 rgba(stroke.value.color, SP_SCALE24_TO_FLOAT(style->stroke_opacity.value)).c_str());\r
433 double strokewidth = style->stroke_width.value;\r
434 unsigned linecap = style->stroke_linecap.value;\r
435 unsigned linejoin = style->stroke_linejoin.value;\r
436 out(" strokeWidth: %s\n", DSTR(strokewidth));\r
437 out(" strokeLineCap: %s\n", getStrokeLineCap(linecap).c_str());\r
438 out(" strokeLineJoin: %s\n", getStrokeLineJoin(linejoin).c_str());\r
439 out(" strokeMiterLimit: %s\n", DSTR(style->stroke_miterlimit.value));\r
440 if(style->stroke_dasharray_set) {\r
441 if(style->stroke_dashoffset_set) {\r
442 out(" strokeDashOffset: %s\n", DSTR(style->stroke_dash.offset));\r
443 }\r
444 out(" strokeDashArray: [ ");\r
445 for(int i = 0; i < style->stroke_dash.n_dash; i++ ) {\r
446 if(i > 0) {\r
447 out(", %.2lf", style->stroke_dash.dash[i]);\r
448 }else {\r
449 out(" %.2lf", style->stroke_dash.dash[i]);\r
450 }\r
451 }\r
452 out(" ]\n");\r
453 }\r
454 \r
455 }\r
456 \r
457 return true;\r
458 }\r
459 \r
460 \r
461 #if 1\r
462 \r
463 /**\r
464 * Output the curve data to buffer\r
465 */\r
466 bool JavaFXOutput::doCurve(SPItem *item, const String &id)\r
467 {\r
468 using Geom::X;\r
469 using Geom::Y;\r
470 \r
471 String jfxid = sanatize(id);\r
472 \r
473 //### Get the Shape\r
474 if (!SP_IS_SHAPE(item))//Bulia's suggestion. Allow all shapes\r
475 return true;\r
476 \r
477 SPShape *shape = SP_SHAPE(item);\r
478 SPCurve *curve = shape->curve;\r
479 if (curve->is_empty())\r
480 return true;\r
481 \r
482 nrShapes++;\r
483 \r
484 out(" /** path %s */\n", jfxid.c_str());\r
485 out(" private function %s() : Path {\n",jfxid.c_str());\r
486 out(" Path {\n");\r
487 out(" id: \"%s\"\n", jfxid.c_str());\r
488 \r
489 /**\r
490 * Output the style information\r
491 */\r
492 if (!doStyle(SP_OBJECT_STYLE(shape)))\r
493 return false;\r
494 \r
495 // convert the path to only lineto's and cubic curveto's:\r
496 Geom::Scale yflip(1.0, -1.0);\r
497 Geom::Matrix tf = sp_item_i2d_affine(item) * yflip;\r
498 Geom::PathVector pathv = pathv_to_linear_and_cubic_beziers( curve->get_pathvector() * tf );\r
499 \r
500 //Count the NR_CURVETOs/LINETOs (including closing line segment)\r
501 guint segmentCount = 0;\r
502 for(Geom::PathVector::const_iterator it = pathv.begin(); it != pathv.end(); ++it) {\r
503 segmentCount += (*it).size();\r
504 if (it->closed())\r
505 segmentCount += 1;\r
506 }\r
507 \r
508 out(" elements: [\n");\r
509 \r
510 unsigned int segmentNr = 0;\r
511 \r
512 nrNodes += segmentCount;\r
513 \r
514 Geom::Rect cminmax( pathv.front().initialPoint(), pathv.front().initialPoint() );\r
515 \r
516 /**\r
517 * For all Subpaths in the <path>\r
518 */\r
519 for (Geom::PathVector::const_iterator pit = pathv.begin(); pit != pathv.end(); ++pit)\r
520 {\r
521 Geom::Point p = pit->front().initialPoint();\r
522 cminmax.expandTo(p);\r
523 out(" MoveTo {\n");\r
524 out(" x: %s\n", DSTR(p[X]));\r
525 out(" y: %s\n", DSTR(p[Y]));\r
526 out(" },\n");\r
527 \r
528 /**\r
529 * For all segments in the subpath\r
530 */\r
531 for (Geom::Path::const_iterator cit = pit->begin(); cit != pit->end_closed(); ++cit)\r
532 {\r
533 //### LINE\r
534 if( dynamic_cast<Geom::LineSegment const *> (&*cit) ||\r
535 dynamic_cast<Geom::HLineSegment const *> (&*cit) ||\r
536 dynamic_cast<Geom::VLineSegment const *> (&*cit) )\r
537 {\r
538 Geom::Point p = cit->finalPoint();\r
539 out(" LineTo {\n");\r
540 out(" x: %s\n", DSTR(p[X]));\r
541 out(" y: %s\n", DSTR(p[Y]));\r
542 out(" },\n");\r
543 nrNodes++;\r
544 }\r
545 //### BEZIER\r
546 else if(Geom::CubicBezier const *cubic = dynamic_cast<Geom::CubicBezier const*>(&*cit))\r
547 {\r
548 std::vector<Geom::Point> points = cubic->points();\r
549 Geom::Point p1 = points[1];\r
550 Geom::Point p2 = points[2];\r
551 Geom::Point p3 = points[3];\r
552 out(" CurveTo {\n");\r
553 out(" controlX1: %s\n", DSTR(p1[X]));\r
554 out(" controlY1: %s\n", DSTR(p1[Y]));\r
555 out(" controlX2: %s\n", DSTR(p2[X]));\r
556 out(" controlY2: %s\n", DSTR(p2[Y]));\r
557 out(" x: %s\n", DSTR(p3[X]));\r
558 out(" y: %s\n", DSTR(p3[Y]));\r
559 out(" },\n");\r
560 nrNodes++;\r
561 }\r
562 else\r
563 {\r
564 g_error ("logical error, because pathv_to_linear_and_cubic_beziers was used");\r
565 }\r
566 segmentNr++;\r
567 cminmax.expandTo(cit->finalPoint());\r
568 }\r
569 if (pit->closed())\r
570 {\r
571 out(" ClosePath {},\n");\r
572 }\r
573 }\r
574 \r
575 out(" ] // elements\n");\r
576 out(" }; // Path\n");\r
577 out(" } // end path %s\n\n", jfxid.c_str());\r
578 \r
579 double cminx = cminmax.min()[X];\r
580 double cmaxx = cminmax.max()[X];\r
581 double cminy = cminmax.min()[Y];\r
582 double cmaxy = cminmax.max()[Y];\r
583 \r
584 if (cminx < minx)\r
585 minx = cminx;\r
586 if (cmaxx > maxx)\r
587 maxx = cmaxx;\r
588 if (cminy < miny)\r
589 miny = cminy;\r
590 if (cmaxy > maxy)\r
591 maxy = cmaxy;\r
592 \r
593 return true;\r
594 }\r
595 \r
596 \r
597 \r
598 #else\r
599 \r
600 /**\r
601 * Output the curve data to buffer\r
602 */\r
603 bool JavaFXOutput::doCurve(SPItem *item, const String &id)\r
604 {\r
605 using Geom::X;\r
606 using Geom::Y;\r
607 \r
608 //### Get the Shape\r
609 if (!SP_IS_SHAPE(item))//Bulia's suggestion. Allow all shapes\r
610 return true;\r
611 \r
612 SPShape *shape = SP_SHAPE(item);\r
613 SPCurve *curve = shape->curve;\r
614 if (curve->is_empty())\r
615 return true;\r
616 \r
617 nrShapes++;\r
618 \r
619 out(" SVGPath \n");\r
620 out(" {\n");\r
621 out(" id: \"%s\"\n", id.c_str());\r
622 \r
623 /**\r
624 * Output the style information\r
625 */\r
626 if (!doStyle(SP_OBJECT_STYLE(shape)))\r
627 return false;\r
628 \r
629 // convert the path to only lineto's and cubic curveto's:\r
630 Geom::Scale yflip(1.0, -1.0);\r
631 Geom::Matrix tf = sp_item_i2d_affine(item) * yflip;\r
632 Geom::PathVector pathv = pathv_to_linear_and_cubic_beziers( curve->get_pathvector() * tf );\r
633 \r
634 //Count the NR_CURVETOs/LINETOs (including closing line segment)\r
635 nrNodes = 0;\r
636 for(Geom::PathVector::const_iterator it = pathv.begin(); it != pathv.end(); ++it) {\r
637 nrNodes += (*it).size();\r
638 if (it->closed())\r
639 nrNodes += 1;\r
640 }\r
641 \r
642 char *dataStr = sp_svg_write_path(pathv);\r
643 out(" content: \"%s\"\n", dataStr);\r
644 free(dataStr);\r
645 \r
646 Geom::Rect cminmax( pathv.front().initialPoint(), pathv.front().initialPoint() ); \r
647 \r
648 /**\r
649 * Get the Min and Max X and Y extends for the Path. \r
650 * ....For all Subpaths in the <path>\r
651 */ \r
652 for (Geom::PathVector::const_iterator pit = pathv.begin(); pit != pathv.end(); ++pit)\r
653 {\r
654 cminmax.expandTo(pit->front().initialPoint());\r
655 /**\r
656 * For all segments in the subpath\r
657 */ \r
658 for (Geom::Path::const_iterator cit = pit->begin(); cit != pit->end_closed(); ++cit)\r
659 {\r
660 cminmax.expandTo(cit->finalPoint());\r
661 }\r
662 }\r
663 \r
664 out(" },\n");\r
665 \r
666 double cminx = cminmax.min()[X];\r
667 double cmaxx = cminmax.max()[X];\r
668 double cminy = cminmax.min()[Y];\r
669 double cmaxy = cminmax.max()[Y];\r
670 \r
671 if (cminx < minx)\r
672 minx = cminx;\r
673 if (cmaxx > maxx)\r
674 maxx = cmaxx;\r
675 if (cminy < miny)\r
676 miny = cminy;\r
677 if (cmaxy > maxy)\r
678 maxy = cmaxy;\r
679 \r
680 return true;\r
681 }\r
682 \r
683 \r
684 \r
685 #endif /* #if o */\r
686 \r
687 \r
688 \r
689 /**\r
690 * Output the tree data to buffer\r
691 */\r
692 bool JavaFXOutput::doTreeRecursive(SPDocument *doc, SPObject *obj)\r
693 {\r
694 /**\r
695 * Check the type of node and process\r
696 */\r
697 String id;\r
698 if (!obj->id)\r
699 {\r
700 char buf[16];\r
701 sprintf(buf, "id%d", idindex++);\r
702 id = buf;\r
703 }\r
704 else\r
705 {\r
706 id = obj->id;\r
707 }\r
708 if (SP_IS_ITEM(obj))\r
709 {\r
710 SPItem *item = SP_ITEM(obj);\r
711 if (!doCurve(item, id))\r
712 return false;\r
713 }\r
714 else if (SP_IS_GRADIENT(obj))\r
715 {\r
716 SPGradient *grad = SP_GRADIENT(obj);\r
717 if (!doGradient(grad, id))\r
718 return false;\r
719 }\r
720 \r
721 /**\r
722 * Descend into children\r
723 */ \r
724 for (SPObject *child = obj->firstChild() ; child ; child = child->next)\r
725 {\r
726 if (!doTreeRecursive(doc, child))\r
727 return false;\r
728 }\r
729 \r
730 return true;\r
731 }\r
732 \r
733 \r
734 /**\r
735 * Output the curve data to buffer\r
736 */\r
737 bool JavaFXOutput::doTree(SPDocument *doc)\r
738 {\r
739 \r
740 double bignum = 1000000.0;\r
741 minx = bignum;\r
742 maxx = -bignum;\r
743 miny = bignum;\r
744 maxy = -bignum;\r
745 \r
746 if (!doTreeRecursive(doc, doc->root))\r
747 return false;\r
748 \r
749 return true;\r
750 \r
751 }\r
752 \r
753 \r
754 bool JavaFXOutput::doBody(SPDocument *doc, SPObject *obj)\r
755 {\r
756 /**\r
757 * Check the type of node and process\r
758 */\r
759 String id;\r
760 if (!obj->id)\r
761 {\r
762 char buf[16];\r
763 sprintf(buf, "id%d", idindex++);\r
764 id = buf;\r
765 }\r
766 else\r
767 {\r
768 id = obj->id;\r
769 }\r
770 \r
771 if (SP_IS_ITEM(obj)) {\r
772 SPItem *item = SP_ITEM(obj);\r
773 //### Get the Shape\r
774 if (SP_IS_SHAPE(item)) {//Bulia's suggestion. Allow all shapes\r
775 SPShape *shape = SP_SHAPE(item);\r
776 SPCurve *curve = shape->curve;\r
777 if (!curve->is_empty())\r
778 out(" %s(),\n", id.c_str());\r
779 }\r
780 }\r
781 else if (SP_IS_GRADIENT(obj)) {\r
782 //TODO: what to do with Gradient within body?????\r
783 //SPGradient *grad = SP_GRADIENT(reprobj);\r
784 //if (!doGradient(grad, id))\r
785 // return false;\r
786 }\r
787 \r
788 /**\r
789 * Descend into children\r
790 */\r
791 for (SPObject *child = obj->firstChild() ; child ; child = child->next)\r
792 {\r
793 if (!doBody(doc, child))\r
794 return false;\r
795 }\r
796 \r
797 return true;\r
798 }\r
799 \r
800 \r
801 \r
802 //########################################################################\r
803 //# M A I N O U T P U T\r
804 //########################################################################\r
805 \r
806 \r
807 \r
808 /**\r
809 * Set values back to initial state\r
810 */\r
811 void JavaFXOutput::reset()\r
812 {\r
813 nrNodes = 0;\r
814 nrShapes = 0;\r
815 idindex = 0;\r
816 name.clear();\r
817 outbuf.clear();\r
818 foutbuf.clear();\r
819 }\r
820 \r
821 \r
822 \r
823 /**\r
824 * Saves the <paths> of an Inkscape SVG file as JavaFX spline definitions\r
825 */\r
826 bool JavaFXOutput::saveDocument(SPDocument *doc, gchar const *uri)\r
827 {\r
828 reset();\r
829 \r
830 \r
831 name = Glib::path_get_basename(uri);\r
832 int pos = name.find('.');\r
833 if (pos > 0)\r
834 name = name.substr(0, pos);\r
835 \r
836 \r
837 //###### SAVE IN JAVAFX FORMAT TO BUFFER\r
838 //# Lets do the curves first, to get the stats\r
839 \r
840 if (!doTree(doc))\r
841 return false;\r
842 String curveBuf = outbuf;\r
843 outbuf.clear();\r
844 \r
845 if (!doHeader())\r
846 return false;\r
847 \r
848 outbuf.append(curveBuf);\r
849 \r
850 #ifdef JAVAFX_SDK_1_0\r
851 out(" override function create(): Node {\n");\r
852 #else\r
853 out(" public function create(): Node {\n");\r
854 #endif\r
855 out(" Group {\n");\r
856 out(" content: [\n");\r
857 idindex = 0;\r
858 \r
859 doBody(doc, doc->root);\r
860 \r
861 if (!doTail())\r
862 return false;\r
863 \r
864 \r
865 \r
866 //###### WRITE TO FILE\r
867 FILE *f = Inkscape::IO::fopen_utf8name(uri, "w");\r
868 if (!f)\r
869 {\r
870 err("Could open JavaFX file '%s' for writing", uri);\r
871 return false;\r
872 }\r
873 \r
874 for (String::iterator iter = outbuf.begin() ; iter!=outbuf.end(); iter++)\r
875 {\r
876 fputc(*iter, f);\r
877 }\r
878 \r
879 fclose(f);\r
880 \r
881 return true;\r
882 }\r
883 \r
884 \r
885 \r
886 \r
887 //########################################################################\r
888 //# EXTENSION API\r
889 //########################################################################\r
890 \r
891 \r
892 \r
893 #include "clear-n_.h"\r
894 \r
895 \r
896 \r
897 /**\r
898 * API call to save document\r
899 */\r
900 void\r
901 JavaFXOutput::save(Inkscape::Extension::Output */*mod*/,\r
902 SPDocument *doc, gchar const *uri)\r
903 {\r
904 if (!saveDocument(doc, uri))\r
905 {\r
906 g_warning("Could not save JavaFX file '%s'", uri);\r
907 }\r
908 }\r
909 \r
910 \r
911 \r
912 /**\r
913 * Make sure that we are in the database\r
914 */\r
915 bool JavaFXOutput::check (Inkscape::Extension::Extension */*module*/)\r
916 {\r
917 /* We don't need a Key\r
918 if (NULL == Inkscape::Extension::db.get(SP_MODULE_KEY_OUTPUT_JFX))\r
919 return FALSE;\r
920 */\r
921 \r
922 return true;\r
923 }\r
924 \r
925 \r
926 \r
927 /**\r
928 * This is the definition of JavaFX output. This function just\r
929 * calls the extension system with the memory allocated XML that\r
930 * describes the data.\r
931 */\r
932 void\r
933 JavaFXOutput::init()\r
934 {\r
935 Inkscape::Extension::build_from_mem(\r
936 "<inkscape-extension xmlns=\"" INKSCAPE_EXTENSION_URI "\">\n"\r
937 "<name>" N_("JavaFX Output") "</name>\n"\r
938 "<id>org.inkscape.output.jfx</id>\n"\r
939 "<output>\n"\r
940 "<extension>.fx</extension>\n"\r
941 "<mimetype>text/x-javafx-script</mimetype>\n"\r
942 "<filetypename>" N_("JavaFX (*.fx)") "</filetypename>\n"\r
943 "<filetypetooltip>" N_("JavaFX Raytracer File") "</filetypetooltip>\n"\r
944 "</output>\n"\r
945 "</inkscape-extension>",\r
946 new JavaFXOutput());\r
947 }\r
948 \r
949 \r
950 \r
951 \r
952 \r
953 } // namespace Internal\r
954 } // namespace Extension\r
955 } // namespace Inkscape\r
956 \r
957 \r
958 /*\r
959 Local Variables:\r
960 mode:c++\r
961 c-file-style:"stroustrup"\r
962 c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))\r
963 indent-tabs-mode:nil\r
964 fill-column:99\r
965 End:\r
966 */\r
967 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :\r