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 *\r
10 * Copyright (C) 2008 Authors\r
11 *\r
12 * Released under GNU GPL, read the file 'COPYING' for more information\r
13 */\r
14 \r
15 \r
16 #ifdef HAVE_CONFIG_H\r
17 # include <config.h>\r
18 #endif\r
19 #include "javafx-out.h"\r
20 #include <inkscape.h>\r
21 #include <inkscape_version.h>\r
22 #include <sp-path.h>\r
23 #include <sp-linear-gradient.h>\r
24 #include <sp-radial-gradient.h>\r
25 #include <style.h>\r
26 #include <display/curve.h>\r
27 #include <extension/system.h>\r
28 #include <2geom/pathvector.h>\r
29 #include <2geom/rect.h>\r
30 #include <2geom/bezier-curve.h>\r
31 #include <2geom/hvlinesegment.h>\r
32 #include "helper/geom.h"\r
33 #include <io/sys.h>\r
34 \r
35 \r
36 #include <string>\r
37 #include <stdio.h>\r
38 #include <stdarg.h>\r
39 \r
40 \r
41 namespace Inkscape\r
42 {\r
43 namespace Extension\r
44 {\r
45 namespace Internal\r
46 {\r
47 \r
48 \r
49 \r
50 \r
51 //########################################################################\r
52 //# M E S S A G E S\r
53 //########################################################################\r
54 \r
55 static void err(const char *fmt, ...)\r
56 {\r
57 va_list args;\r
58 va_start(args, fmt);\r
59 g_logv(NULL, G_LOG_LEVEL_WARNING, fmt, args);\r
60 va_end(args);\r
61 }\r
62 \r
63 \r
64 //########################################################################\r
65 //# U T I L I T Y\r
66 //########################################################################\r
67 \r
68 /**\r
69 * Got this method from Bulia, and modified it a bit. It basically\r
70 * starts with this style, gets its SPObject parent, walks up the object\r
71 * tree and finds all of the opacities and multiplies them.\r
72 *\r
73 * We use this for our "flat" object output. If the code is modified\r
74 * to reflect a tree of <groups>, then this will be unneccessary.\r
75 */\r
76 static double effective_opacity(const SPStyle *style)\r
77 {\r
78 double val = 1.0;\r
79 for (SPObject const *obj = style->object; obj ; obj = obj->parent)\r
80 {\r
81 style = SP_OBJECT_STYLE(obj);\r
82 if (!style)\r
83 return val;\r
84 val *= SP_SCALE24_TO_FLOAT(style->opacity.value);\r
85 }\r
86 return val;\r
87 }\r
88 \r
89 //########################################################################\r
90 //# OUTPUT FORMATTING\r
91 //########################################################################\r
92 \r
93 \r
94 /**\r
95 * We want to control floating output format\r
96 */\r
97 static JavaFXOutput::String dstr(double d)\r
98 {\r
99 char dbuf[G_ASCII_DTOSTR_BUF_SIZE+1];\r
100 g_ascii_formatd(dbuf, G_ASCII_DTOSTR_BUF_SIZE,\r
101 "%.8f", (gdouble)d);\r
102 JavaFXOutput::String s = dbuf;\r
103 return s;\r
104 }\r
105 \r
106 \r
107 \r
108 /**\r
109 * Format an rgba() string\r
110 */\r
111 static JavaFXOutput::String rgba(guint32 rgba)\r
112 {\r
113 unsigned int r = SP_RGBA32_R_U(rgba);\r
114 unsigned int g = SP_RGBA32_G_U(rgba);\r
115 unsigned int b = SP_RGBA32_B_U(rgba);\r
116 unsigned int a = SP_RGBA32_A_U(rgba);\r
117 char buf[80];\r
118 snprintf(buf, 79, "rgba(0x%02x, 0x%02x, 0x%02x, 0x%02x)",\r
119 r, g, b, a);\r
120 JavaFXOutput::String s = buf;\r
121 return s;\r
122 }\r
123 \r
124 \r
125 /**\r
126 * Format an rgba() string for a color and a 0.0-1.0 alpha\r
127 */\r
128 static JavaFXOutput::String rgba(SPColor color, gdouble alpha)\r
129 {\r
130 return rgba(color.toRGBA32(alpha));\r
131 }\r
132 \r
133 \r
134 \r
135 \r
136 /**\r
137 * Output data to the buffer, printf()-style\r
138 */\r
139 void JavaFXOutput::out(const char *fmt, ...)\r
140 {\r
141 va_list args;\r
142 va_start(args, fmt);\r
143 gchar *output = g_strdup_vprintf(fmt, args);\r
144 va_end(args);\r
145 outbuf.append(output);\r
146 g_free(output);\r
147 }\r
148 \r
149 /**\r
150 * Output header data to the buffer, printf()-style\r
151 */\r
152 void JavaFXOutput::fout(const char *fmt, ...)\r
153 {\r
154 va_list args;\r
155 va_start(args, fmt);\r
156 gchar *output = g_strdup_vprintf(fmt, args);\r
157 va_end(args);\r
158 foutbuf.append(output);\r
159 g_free(output);\r
160 }\r
161 \r
162 \r
163 /**\r
164 * Output the file header\r
165 */\r
166 bool JavaFXOutput::doHeader()\r
167 {\r
168 time_t tim = time(NULL);\r
169 out("/*###################################################################\n");\r
170 out("### This JavaFX document was generated by Inkscape\n");\r
171 out("### http://www.inkscape.org\n");\r
172 out("### Created: %s", ctime(&tim));\r
173 out("### Version: %s\n", INKSCAPE_VERSION);\r
174 out("#####################################################################\n");\r
175 out("### NOTES:\n");\r
176 out("### ============\n");\r
177 out("### JavaFX information can be found at\n");\r
178 out("### hhttps://openjfx.dev.java.net\n");\r
179 out("###\n");\r
180 out("### If you have any problems with this output, please see the\n");\r
181 out("### Inkscape project at http://www.inkscape.org, or visit\n");\r
182 out("### the #inkscape channel on irc.freenode.net . \n");\r
183 out("###\n");\r
184 out("###################################################################*/\n");\r
185 out("\n\n");\r
186 out("/*###################################################################\n");\r
187 out("## Exports in this file\n");\r
188 out("##==========================\n");\r
189 out("## Shapes : %d\n", nrShapes);\r
190 out("## Segments : %d\n", nrSegments);\r
191 out("## Nodes : %d\n", nrNodes);\r
192 out("###################################################################*/\n");\r
193 out("\n\n");\r
194 out("import javafx.ui.UIElement;\n");\r
195 out("import javafx.ui.*;\n");\r
196 out("import javafx.ui.canvas.*;\n");\r
197 out("\n");\r
198 out("import java.lang.System;\n");\r
199 out("\n\n");\r
200 out("public class %s extends CompositeNode {\n", name.c_str());\r
201 for (unsigned int i = 0 ; i < linearGradients.size() ; i++)\r
202 {\r
203 out(" public function %s(): LinearGradient;\n",\r
204 linearGradients[i].c_str());\r
205 }\r
206 for (unsigned int i = 0 ; i < radialGradients.size() ; i++)\r
207 {\r
208 out(" public function %s(): RadialGradient;\n",\r
209 radialGradients[i].c_str());\r
210 }\r
211 out("}\n");\r
212 out("\n\n");\r
213 outbuf.append(foutbuf);\r
214 out("\n\n");\r
215 out("function %s.composeNode() =\n", name.c_str());\r
216 out("Group\n");\r
217 out(" {\n");\r
218 out(" content:\n");\r
219 out(" [\n");\r
220 return true;\r
221 }\r
222 \r
223 \r
224 \r
225 /**\r
226 * Output the file footer\r
227 */\r
228 bool JavaFXOutput::doTail()\r
229 {\r
230 int border = 25.0;\r
231 out(" ] // content\n");\r
232 out(" transform: [ translate(%s, %s), ]\n",\r
233 dstr((-minx) + border).c_str(), dstr((-miny) + border).c_str());\r
234 out(" }; // Group\n");\r
235 out("// end function %s.composeNode()\n", name.c_str());\r
236 out("\n\n\n\n");\r
237 out("Frame {\n");\r
238 out(" title: \"Test\"\n");\r
239 out(" width: %s\n", dstr(maxx-minx + border * 2.0).c_str());\r
240 out(" height: %s\n", dstr(maxy-miny + border * 2.0).c_str());\r
241 out(" onClose: function()\n");\r
242 out(" {\n");\r
243 out(" return System.exit( 0 );\n");\r
244 out(" }\n");\r
245 out(" visible: true\n");\r
246 out(" content: Canvas {\n");\r
247 out(" content: %s{}\n", name.c_str());\r
248 out(" }\n");\r
249 out("}\n");\r
250 out("/*###################################################################\n");\r
251 out("### E N D C L A S S %s\n", name.c_str());\r
252 out("###################################################################*/\n");\r
253 out("\n\n");\r
254 return true;\r
255 }\r
256 \r
257 \r
258 \r
259 /**\r
260 * Output gradient information to the buffer\r
261 */\r
262 bool JavaFXOutput::doGradient(SPGradient *grad, const String &id)\r
263 {\r
264 if (SP_IS_LINEARGRADIENT(grad))\r
265 {\r
266 SPLinearGradient *g = SP_LINEARGRADIENT(grad);\r
267 linearGradients.push_back(id);\r
268 fout("function %s.%s() =\n", name.c_str(), id.c_str());\r
269 fout(" [\n");\r
270 fout(" LinearGradient\n");\r
271 fout(" {\n");\r
272 std::vector<SPGradientStop> stops = g->vector.stops;\r
273 if (stops.size() > 0)\r
274 {\r
275 fout(" stops:\n");\r
276 fout(" [\n");\r
277 for (unsigned int i = 0 ; i<stops.size() ; i++)\r
278 {\r
279 SPGradientStop stop = stops[i];\r
280 fout(" Stop\n");\r
281 fout(" {\n");\r
282 fout(" offset: %s\n", dstr(stop.offset).c_str());\r
283 fout(" color: %s\n", rgba(stop.color, stop.opacity).c_str());\r
284 fout(" },\n");\r
285 }\r
286 fout(" ]\n");\r
287 }\r
288 fout(" },\n");\r
289 fout(" ];\n");\r
290 fout("\n\n");\r
291 }\r
292 else if (SP_IS_RADIALGRADIENT(grad))\r
293 {\r
294 SPRadialGradient *g = SP_RADIALGRADIENT(grad);\r
295 radialGradients.push_back(id);\r
296 fout("function %s.%s() =\n", name.c_str(), id.c_str());\r
297 fout(" [\n");\r
298 fout(" RadialGradient\n");\r
299 fout(" {\n");\r
300 fout(" cx: %s\n", dstr(g->cx.value).c_str());\r
301 fout(" cy: %s\n", dstr(g->cy.value).c_str());\r
302 fout(" focusX: %s\n", dstr(g->fx.value).c_str());\r
303 fout(" focusY: %s\n", dstr(g->fy.value).c_str());\r
304 fout(" radius: %s\n", dstr(g->r.value).c_str());\r
305 fout(" gradientUnits: OBJECT_BOUNDING_BOX\n");\r
306 fout(" spreadMethod: PAD\n");\r
307 std::vector<SPGradientStop> stops = g->vector.stops;\r
308 if (stops.size() > 0)\r
309 {\r
310 fout(" stops:\n");\r
311 fout(" [\n");\r
312 for (unsigned int i = 0 ; i<stops.size() ; i++)\r
313 {\r
314 SPGradientStop stop = stops[i];\r
315 fout(" Stop\n");\r
316 fout(" {\n");\r
317 fout(" offset: %s\n", dstr(stop.offset).c_str());\r
318 fout(" color: %s\n", rgba(stop.color, stop.opacity).c_str());\r
319 fout(" },\n");\r
320 }\r
321 fout(" ]\n");\r
322 }\r
323 fout(" },\n");\r
324 fout(" ];\n");\r
325 fout("\n\n");\r
326 }\r
327 else\r
328 {\r
329 err("Unknown gradient type for '%s'\n", id.c_str());\r
330 return false;\r
331 }\r
332 \r
333 \r
334 return true;\r
335 }\r
336 \r
337 \r
338 \r
339 \r
340 /**\r
341 * Output an element's style attribute\r
342 */\r
343 bool JavaFXOutput::doStyle(SPStyle *style)\r
344 {\r
345 if (!style)\r
346 return true;\r
347 \r
348 out(" opacity: %s\n", dstr(effective_opacity(style)).c_str());\r
349 \r
350 /**\r
351 * Fill\r
352 */\r
353 SPIPaint fill = style->fill;\r
354 if (fill.isColor())\r
355 {\r
356 // see color.h for how to parse SPColor\r
357 out(" fill: %s\n",\r
358 rgba(fill.value.color, SP_SCALE24_TO_FLOAT(style->fill_opacity.value)).c_str());\r
359 }\r
360 else if (fill.isPaintserver())\r
361 {\r
362 if (fill.value.href && fill.value.href->getURI() )\r
363 {\r
364 String uri = fill.value.href->getURI()->toString();\r
365 if (uri.size()>0 && uri[0]=='#')\r
366 uri = uri.substr(1);\r
367 out(" fill: %s()\n", uri.c_str());\r
368 }\r
369 }\r
370 \r
371 \r
372 /**\r
373 * Stroke\r
374 */\r
375 /**\r
376 *NOTE: Things in style we can use:\r
377 * SPIPaint stroke;\r
378 * SPILength stroke_width;\r
379 * SPIEnum stroke_linecap;\r
380 * SPIEnum stroke_linejoin;\r
381 * SPIFloat stroke_miterlimit;\r
382 * NRVpathDash stroke_dash;\r
383 * unsigned stroke_dasharray_set : 1;\r
384 * unsigned stroke_dasharray_inherit : 1;\r
385 * unsigned stroke_dashoffset_set : 1;\r
386 * SPIScale24 stroke_opacity;\r
387 */\r
388 if (style->stroke_opacity.value > 0)\r
389 {\r
390 SPIPaint stroke = style->stroke;\r
391 out(" stroke: %s\n",\r
392 rgba(stroke.value.color, SP_SCALE24_TO_FLOAT(style->stroke_opacity.value)).c_str());\r
393 double strokewidth = style->stroke_width.value;\r
394 out(" strokeWidth: %s\n", dstr(strokewidth).c_str());\r
395 }\r
396 \r
397 return true;\r
398 }\r
399 \r
400 \r
401 \r
402 \r
403 /**\r
404 * Output the curve data to buffer\r
405 */\r
406 bool JavaFXOutput::doCurve(SPItem *item, const String &id)\r
407 {\r
408 using Geom::X;\r
409 using Geom::Y;\r
410 \r
411 //### Get the Shape\r
412 if (!SP_IS_SHAPE(item))//Bulia's suggestion. Allow all shapes\r
413 return true;\r
414 \r
415 SPShape *shape = SP_SHAPE(item);\r
416 SPCurve *curve = shape->curve;\r
417 if (curve->is_empty())\r
418 return true;\r
419 \r
420 nrShapes++;\r
421 \r
422 out(" /*###################################################\n");\r
423 out(" ### PATH: %s\n", id.c_str());\r
424 out(" ###################################################*/\n");\r
425 out(" Path \n");\r
426 out(" {\n");\r
427 out(" id: \"%s\"\n", id.c_str());\r
428 \r
429 /**\r
430 * Output the style information\r
431 */\r
432 if (!doStyle(SP_OBJECT_STYLE(shape)))\r
433 return false;\r
434 \r
435 // convert the path to only lineto's and cubic curveto's:\r
436 Geom::Scale yflip(1.0, -1.0);\r
437 Geom::Matrix tf = sp_item_i2d_affine(item) * yflip;\r
438 Geom::PathVector pathv = pathv_to_linear_and_cubic_beziers( curve->get_pathvector() * tf );\r
439 \r
440 //Count the NR_CURVETOs/LINETOs (including closing line segment)\r
441 guint segmentCount = 0;\r
442 for(Geom::PathVector::const_iterator it = pathv.begin(); it != pathv.end(); ++it) {\r
443 segmentCount += (*it).size();\r
444 if (it->closed())\r
445 segmentCount += 1;\r
446 }\r
447 \r
448 out(" d:\n");\r
449 out(" [\n");\r
450 \r
451 unsigned int segmentNr = 0;\r
452 \r
453 nrSegments += segmentCount;\r
454 \r
455 Geom::Rect cminmax( pathv.front().initialPoint(), pathv.front().initialPoint() ); \r
456 \r
457 /**\r
458 * For all Subpaths in the <path>\r
459 */ \r
460 for (Geom::PathVector::const_iterator pit = pathv.begin(); pit != pathv.end(); ++pit)\r
461 {\r
462 Geom::Point p = pit->front().initialPoint();\r
463 cminmax.expandTo(p);\r
464 out(" MoveTo {\n");\r
465 out(" x: %s\n", dstr(p[X]).c_str());\r
466 out(" y: %s\n", dstr(p[Y]).c_str());\r
467 out(" absolute: true\n");\r
468 out(" },\n");\r
469 \r
470 /**\r
471 * For all segments in the subpath\r
472 */ \r
473 for (Geom::Path::const_iterator cit = pit->begin(); cit != pit->end_closed(); ++cit)\r
474 {\r
475 //### LINE\r
476 if( dynamic_cast<Geom::LineSegment const *> (&*cit) ||\r
477 dynamic_cast<Geom::HLineSegment const *>(&*cit) ||\r
478 dynamic_cast<Geom::VLineSegment const *>(&*cit) )\r
479 {\r
480 Geom::Point p = cit->finalPoint();\r
481 out(" LineTo {\n");\r
482 out(" x: %s\n", dstr(p[X]).c_str());\r
483 out(" y: %s\n", dstr(p[Y]).c_str());\r
484 out(" absolute: true\n");\r
485 out(" },\n");\r
486 nrNodes++;\r
487 }\r
488 //### BEZIER\r
489 else if(Geom::CubicBezier const *cubic = dynamic_cast<Geom::CubicBezier const*>(&*cit))\r
490 {\r
491 std::vector<Geom::Point> points = cubic->points();\r
492 Geom::Point p1 = points[1];\r
493 Geom::Point p2 = points[2];\r
494 Geom::Point p3 = points[3];\r
495 out(" CurveTo {\n");\r
496 out(" x1: %s\n", dstr(p1[X]).c_str());\r
497 out(" y1: %s\n", dstr(p1[Y]).c_str());\r
498 out(" x2: %s\n", dstr(p2[X]).c_str());\r
499 out(" y2: %s\n", dstr(p2[Y]).c_str());\r
500 out(" x3: %s\n", dstr(p3[X]).c_str());\r
501 out(" y3: %s\n", dstr(p3[Y]).c_str());\r
502 out(" absolute: true\n");\r
503 out(" },\n");\r
504 nrNodes++;\r
505 }\r
506 else\r
507 {\r
508 g_error ("logical error, because pathv_to_linear_and_cubic_beziers was used");\r
509 }\r
510 segmentNr++;\r
511 cminmax.expandTo(cit->finalPoint());\r
512 }\r
513 if (pit->closed())\r
514 {\r
515 out(" ClosePath {},\n");\r
516 }\r
517 }\r
518 \r
519 out(" ] // d\n");\r
520 out(" }, // Path\n");\r
521 \r
522 \r
523 out(" /*###################################################\n");\r
524 out(" ### end path %s\n", id.c_str());\r
525 out(" ###################################################*/\n\n\n\n");\r
526 \r
527 double cminx = cminmax.min()[X];\r
528 double cmaxx = cminmax.max()[X];\r
529 double cminy = cminmax.min()[Y];\r
530 double cmaxy = cminmax.max()[Y];\r
531 \r
532 if (cminx < minx)\r
533 minx = cminx;\r
534 if (cmaxx > maxx)\r
535 maxx = cmaxx;\r
536 if (cminy < miny)\r
537 miny = cminy;\r
538 if (cmaxy > maxy)\r
539 maxy = cmaxy;\r
540 \r
541 return true;\r
542 }\r
543 \r
544 \r
545 /**\r
546 * Output the curve data to buffer\r
547 */\r
548 bool JavaFXOutput::doCurvesRecursive(SPDocument *doc, Inkscape::XML::Node *node)\r
549 {\r
550 /**\r
551 * Check the type of node and process\r
552 */\r
553 String id;\r
554 char *idstr = (char *) node->attribute("id");\r
555 if (!idstr)\r
556 {\r
557 char buf[16];\r
558 sprintf(buf, "id%d", idindex++);\r
559 id = buf;\r
560 }\r
561 else\r
562 {\r
563 id = idstr;\r
564 }\r
565 SPObject *reprobj = doc->getObjectByRepr(node);\r
566 if (SP_IS_ITEM(reprobj))\r
567 {\r
568 SPItem *item = SP_ITEM(reprobj);\r
569 if (!doCurve(item, id))\r
570 return false;\r
571 }\r
572 else if (SP_IS_GRADIENT(reprobj))\r
573 {\r
574 SPGradient *grad = SP_GRADIENT(reprobj);\r
575 if (!doGradient(grad, id))\r
576 return false;\r
577 }\r
578 \r
579 /**\r
580 * Descend into children\r
581 */ \r
582 for (Inkscape::XML::Node *child = node->firstChild() ; child ;\r
583 child = child->next())\r
584 {\r
585 if (!doCurvesRecursive(doc, child))\r
586 return false;\r
587 }\r
588 \r
589 return true;\r
590 }\r
591 \r
592 \r
593 /**\r
594 * Output the curve data to buffer\r
595 */\r
596 bool JavaFXOutput::doCurves(SPDocument *doc)\r
597 {\r
598 \r
599 double bignum = 1000000.0;\r
600 minx = bignum;\r
601 maxx = -bignum;\r
602 miny = bignum;\r
603 maxy = -bignum;\r
604 \r
605 if (!doCurvesRecursive(doc, doc->rroot))\r
606 return false;\r
607 \r
608 return true;\r
609 \r
610 }\r
611 \r
612 \r
613 \r
614 \r
615 //########################################################################\r
616 //# M A I N O U T P U T\r
617 //########################################################################\r
618 \r
619 \r
620 \r
621 /**\r
622 * Set values back to initial state\r
623 */\r
624 void JavaFXOutput::reset()\r
625 {\r
626 nrNodes = 0;\r
627 nrSegments = 0;\r
628 nrShapes = 0;\r
629 idindex = 0;\r
630 name.clear();\r
631 outbuf.clear();\r
632 foutbuf.clear();\r
633 linearGradients.clear();\r
634 radialGradients.clear();\r
635 }\r
636 \r
637 \r
638 \r
639 /**\r
640 * Saves the <paths> of an Inkscape SVG file as JavaFX spline definitions\r
641 */\r
642 bool JavaFXOutput::saveDocument(SPDocument *doc, gchar const *uri)\r
643 {\r
644 reset();\r
645 \r
646 \r
647 name = Glib::path_get_basename(uri);\r
648 int pos = name.find('.');\r
649 if (pos > 0)\r
650 name = name.substr(0, pos);\r
651 \r
652 \r
653 //###### SAVE IN POV FORMAT TO BUFFER\r
654 //# Lets do the curves first, to get the stats\r
655 \r
656 if (!doCurves(doc))\r
657 return false;\r
658 String curveBuf = outbuf;\r
659 outbuf.clear();\r
660 \r
661 if (!doHeader())\r
662 return false;\r
663 \r
664 outbuf.append(curveBuf);\r
665 \r
666 if (!doTail())\r
667 return false;\r
668 \r
669 \r
670 \r
671 \r
672 //###### WRITE TO FILE\r
673 FILE *f = Inkscape::IO::fopen_utf8name(uri, "w");\r
674 if (!f)\r
675 {\r
676 err("Could open JavaFX file '%s' for writing", uri);\r
677 return false;\r
678 }\r
679 \r
680 for (String::iterator iter = outbuf.begin() ; iter!=outbuf.end(); iter++)\r
681 {\r
682 fputc(*iter, f);\r
683 }\r
684 \r
685 fclose(f);\r
686 \r
687 return true;\r
688 }\r
689 \r
690 \r
691 \r
692 \r
693 //########################################################################\r
694 //# EXTENSION API\r
695 //########################################################################\r
696 \r
697 \r
698 \r
699 #include "clear-n_.h"\r
700 \r
701 \r
702 \r
703 /**\r
704 * API call to save document\r
705 */\r
706 void\r
707 JavaFXOutput::save(Inkscape::Extension::Output */*mod*/,\r
708 SPDocument *doc, gchar const *uri)\r
709 {\r
710 if (!saveDocument(doc, uri))\r
711 {\r
712 g_warning("Could not save JavaFX file '%s'", uri);\r
713 }\r
714 }\r
715 \r
716 \r
717 \r
718 /**\r
719 * Make sure that we are in the database\r
720 */\r
721 bool JavaFXOutput::check (Inkscape::Extension::Extension */*module*/)\r
722 {\r
723 /* We don't need a Key\r
724 if (NULL == Inkscape::Extension::db.get(SP_MODULE_KEY_OUTPUT_JFX))\r
725 return FALSE;\r
726 */\r
727 \r
728 return true;\r
729 }\r
730 \r
731 \r
732 \r
733 /**\r
734 * This is the definition of JavaFX output. This function just\r
735 * calls the extension system with the memory allocated XML that\r
736 * describes the data.\r
737 */\r
738 void\r
739 JavaFXOutput::init()\r
740 {\r
741 Inkscape::Extension::build_from_mem(\r
742 "<inkscape-extension xmlns=\"" INKSCAPE_EXTENSION_URI "\">\n"\r
743 "<name>" N_("JavaFX Output") "</name>\n"\r
744 "<id>org.inkscape.output.jfx</id>\n"\r
745 "<output>\n"\r
746 "<extension>.fx</extension>\n"\r
747 "<mimetype>text/x-javafx-script</mimetype>\n"\r
748 "<filetypename>" N_("JavaFX (*.fx)") "</filetypename>\n"\r
749 "<filetypetooltip>" N_("JavaFX Raytracer File") "</filetypetooltip>\n"\r
750 "</output>\n"\r
751 "</inkscape-extension>",\r
752 new JavaFXOutput());\r
753 }\r
754 \r
755 \r
756 \r
757 \r
758 \r
759 } // namespace Internal\r
760 } // namespace Extension\r
761 } // namespace Inkscape\r
762 \r
763 \r
764 /*\r
765 Local Variables:\r
766 mode:c++\r
767 c-file-style:"stroustrup"\r
768 c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))\r
769 indent-tabs-mode:nil\r
770 fill-column:99\r
771 End:\r
772 */\r
773 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :\r