1 /** \file
2 * SVG <filter> implementation.
3 */
4 /*
5 * Authors:
6 * Hugo Rodrigues <haa.rodrigues@gmail.com>
7 * Niko Kiirala <niko@kiirala.com>
8 * Jon A. Cruz <jon@joncruz.org>
9 * Abhishek Sharma
10 *
11 * Copyright (C) 2006,2007 Authors
12 *
13 * Released under GNU GPL, read the file 'COPYING' for more information
14 */
16 #ifdef HAVE_CONFIG_H
17 # include "config.h"
18 #endif
20 #include <map>
21 #include <string.h>
22 using std::map;
23 using std::pair;
25 #include <gtkmm.h>
27 #include "attributes.h"
28 #include "document.h"
29 #include "sp-filter.h"
30 #include "sp-filter-reference.h"
31 #include "uri.h"
32 #include "xml/repr.h"
33 #include <cstring>
34 #include <string>
36 #define SP_MACROS_SILENT
37 #include "macros.h"
39 #include "display/nr-filter.h"
41 /* Filter base class */
43 static void sp_filter_class_init(SPFilterClass *klass);
44 static void sp_filter_init(SPFilter *filter);
46 static void sp_filter_build(SPObject *object, SPDocument *document, Inkscape::XML::Node *repr);
47 static void sp_filter_release(SPObject *object);
48 static void sp_filter_set(SPObject *object, unsigned int key, gchar const *value);
49 static void sp_filter_update(SPObject *object, SPCtx *ctx, guint flags);
50 static void sp_filter_child_added(SPObject *object,
51 Inkscape::XML::Node *child,
52 Inkscape::XML::Node *ref);
53 static void sp_filter_remove_child(SPObject *object, Inkscape::XML::Node *child);
54 static Inkscape::XML::Node *sp_filter_write(SPObject *object, Inkscape::XML::Document *doc, Inkscape::XML::Node *repr, guint flags);
56 static void filter_ref_changed(SPObject *old_ref, SPObject *ref, SPFilter *filter);
57 static void filter_ref_modified(SPObject *href, guint flags, SPFilter *filter);
59 static SPObjectClass *filter_parent_class;
61 GType
62 sp_filter_get_type()
63 {
64 static GType filter_type = 0;
66 if (!filter_type) {
67 GTypeInfo filter_info = {
68 sizeof(SPFilterClass),
69 NULL, NULL,
70 (GClassInitFunc) sp_filter_class_init,
71 NULL, NULL,
72 sizeof(SPFilter),
73 16,
74 (GInstanceInitFunc) sp_filter_init,
75 NULL, /* value_table */
76 };
77 filter_type = g_type_register_static(SP_TYPE_OBJECT, "SPFilter", &filter_info, (GTypeFlags)0);
78 }
79 return filter_type;
80 }
82 static void
83 sp_filter_class_init(SPFilterClass *klass)
84 {
86 SPObjectClass *sp_object_class = (SPObjectClass *)klass;
88 filter_parent_class = (SPObjectClass*)g_type_class_peek_parent(klass);
90 sp_object_class->build = sp_filter_build;
91 sp_object_class->release = sp_filter_release;
92 sp_object_class->write = sp_filter_write;
93 sp_object_class->set = sp_filter_set;
94 sp_object_class->update = sp_filter_update;
95 sp_object_class->child_added = sp_filter_child_added;
96 sp_object_class->remove_child = sp_filter_remove_child;
97 }
99 static void
100 sp_filter_init(SPFilter *filter)
101 {
102 filter->href = new SPFilterReference(SP_OBJECT(filter));
103 filter->href->changedSignal().connect(sigc::bind(sigc::ptr_fun(filter_ref_changed), filter));
105 filter->x = 0;
106 filter->y = 0;
107 filter->width = 0;
108 filter->height = 0;
110 filter->filterUnits = SP_FILTER_UNITS_OBJECTBOUNDINGBOX;
111 filter->primitiveUnits = SP_FILTER_UNITS_USERSPACEONUSE;
112 filter->filterUnits_set = FALSE;
113 filter->primitiveUnits_set = FALSE;
115 filter->_renderer = NULL;
117 filter->_image_name = new std::map<gchar *, int, ltstr>;
118 filter->_image_name->clear();
119 filter->_image_number_next = 0;
121 filter->filterRes = NumberOptNumber();
123 new (&filter->modified_connection) sigc::connection();
124 }
126 /**
127 * Reads the Inkscape::XML::Node, and initializes SPFilter variables. For this to get called,
128 * our name must be associated with a repr via "sp_object_type_register". Best done through
129 * sp-object-repr.cpp's repr_name_entries array.
130 */
131 static void
132 sp_filter_build(SPObject *object, SPDocument *document, Inkscape::XML::Node *repr)
133 {
134 if (((SPObjectClass *) filter_parent_class)->build) {
135 ((SPObjectClass *) filter_parent_class)->build(object, document, repr);
136 }
138 //Read values of key attributes from XML nodes into object.
139 object->readAttr( "filterUnits" );
140 object->readAttr( "primitiveUnits" );
141 object->readAttr( "x" );
142 object->readAttr( "y" );
143 object->readAttr( "width" );
144 object->readAttr( "height" );
145 object->readAttr( "filterRes" );
146 object->readAttr( "xlink:href" );
148 //is this necessary?
149 document->addResource("filter", object);
150 }
152 /**
153 * Drops any allocated memory.
154 */
155 static void
156 sp_filter_release(SPObject *object)
157 {
158 SPFilter *filter = SP_FILTER(object);
160 if (SP_OBJECT_DOCUMENT(object)) {
161 /* Unregister ourselves */
162 SP_OBJECT_DOCUMENT(object)->removeResource("filter", SP_OBJECT(object));
163 }
165 //TODO: release resources here
167 //release href
168 if (filter->href) {
169 filter->modified_connection.disconnect();
170 filter->href->detach();
171 delete filter->href;
172 filter->href = NULL;
173 }
175 filter->modified_connection.~connection();
176 delete filter->_image_name;
178 if (((SPObjectClass *) filter_parent_class)->release)
179 ((SPObjectClass *) filter_parent_class)->release(object);
180 }
182 /**
183 * Sets a specific value in the SPFilter.
184 */
185 static void
186 sp_filter_set(SPObject *object, unsigned int key, gchar const *value)
187 {
188 SPFilter *filter = SP_FILTER(object);
190 switch (key) {
191 case SP_ATTR_FILTERUNITS:
192 if (value) {
193 if (!strcmp(value, "userSpaceOnUse")) {
194 filter->filterUnits = SP_FILTER_UNITS_USERSPACEONUSE;
195 } else {
196 filter->filterUnits = SP_FILTER_UNITS_OBJECTBOUNDINGBOX;
197 }
198 filter->filterUnits_set = TRUE;
199 } else {
200 filter->filterUnits = SP_FILTER_UNITS_OBJECTBOUNDINGBOX;
201 filter->filterUnits_set = FALSE;
202 }
203 object->requestModified(SP_OBJECT_MODIFIED_FLAG);
204 break;
205 case SP_ATTR_PRIMITIVEUNITS:
206 if (value) {
207 if (!strcmp(value, "objectBoundingBox")) {
208 filter->primitiveUnits = SP_FILTER_UNITS_OBJECTBOUNDINGBOX;
209 } else {
210 filter->primitiveUnits = SP_FILTER_UNITS_USERSPACEONUSE;
211 }
212 filter->primitiveUnits_set = TRUE;
213 } else {
214 filter->primitiveUnits = SP_FILTER_UNITS_USERSPACEONUSE;
215 filter->primitiveUnits_set = FALSE;
216 }
217 object->requestModified(SP_OBJECT_MODIFIED_FLAG);
218 break;
219 case SP_ATTR_X:
220 filter->x.readOrUnset(value);
221 object->requestModified(SP_OBJECT_MODIFIED_FLAG);
222 break;
223 case SP_ATTR_Y:
224 filter->y.readOrUnset(value);
225 object->requestModified(SP_OBJECT_MODIFIED_FLAG);
226 break;
227 case SP_ATTR_WIDTH:
228 filter->width.readOrUnset(value);
229 object->requestModified(SP_OBJECT_MODIFIED_FLAG);
230 break;
231 case SP_ATTR_HEIGHT:
232 filter->height.readOrUnset(value);
233 object->requestModified(SP_OBJECT_MODIFIED_FLAG);
234 break;
235 case SP_ATTR_FILTERRES:
236 filter->filterRes.set(value);
237 object->requestModified(SP_OBJECT_MODIFIED_FLAG);
238 break;
239 case SP_ATTR_XLINK_HREF:
240 if (value) {
241 try {
242 filter->href->attach(Inkscape::URI(value));
243 } catch (Inkscape::BadURIException &e) {
244 g_warning("%s", e.what());
245 filter->href->detach();
246 }
247 } else {
248 filter->href->detach();
249 }
250 break;
251 default:
252 // See if any parents need this value.
253 if (((SPObjectClass *) filter_parent_class)->set) {
254 ((SPObjectClass *) filter_parent_class)->set(object, key, value);
255 }
256 break;
257 }
258 }
260 /**
261 * Receives update notifications.
262 */
263 static void
264 sp_filter_update(SPObject *object, SPCtx *ctx, guint flags)
265 {
266 //SPFilter *filter = SP_FILTER(object);
268 if (flags & (SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_STYLE_MODIFIED_FLAG |
269 SP_OBJECT_VIEWPORT_MODIFIED_FLAG)) {
271 /* do something to trigger redisplay, updates? */
273 }
275 if (((SPObjectClass *) filter_parent_class)->update) {
276 ((SPObjectClass *) filter_parent_class)->update(object, ctx, flags);
277 }
278 }
280 /**
281 * Writes its settings to an incoming repr object, if any.
282 */
283 static Inkscape::XML::Node *
284 sp_filter_write(SPObject *object, Inkscape::XML::Document *doc, Inkscape::XML::Node *repr, guint flags)
285 {
286 SPFilter *filter = SP_FILTER(object);
288 // Original from sp-item-group.cpp
289 if (flags & SP_OBJECT_WRITE_BUILD) {
290 if (!repr) {
291 repr = doc->createElement("svg:filter");
292 }
293 GSList *l = NULL;
294 for ( SPObject *child = object->firstChild(); child; child = child->getNext() ) {
295 Inkscape::XML::Node *crepr = child->updateRepr(doc, NULL, flags);
296 if (crepr) {
297 l = g_slist_prepend (l, crepr);
298 }
299 }
300 while (l) {
301 repr->addChild((Inkscape::XML::Node *) l->data, NULL);
302 Inkscape::GC::release((Inkscape::XML::Node *) l->data);
303 l = g_slist_remove (l, l->data);
304 }
305 } else {
306 for ( SPObject *child = object->firstChild() ; child; child = child->getNext() ) {
307 child->updateRepr(flags);
308 }
309 }
311 if ((flags & SP_OBJECT_WRITE_ALL) || filter->filterUnits_set) {
312 switch (filter->filterUnits) {
313 case SP_FILTER_UNITS_USERSPACEONUSE:
314 repr->setAttribute("filterUnits", "userSpaceOnUse");
315 break;
316 default:
317 repr->setAttribute("filterUnits", "objectBoundingBox");
318 break;
319 }
320 }
322 if ((flags & SP_OBJECT_WRITE_ALL) || filter->primitiveUnits_set) {
323 switch (filter->primitiveUnits) {
324 case SP_FILTER_UNITS_OBJECTBOUNDINGBOX:
325 repr->setAttribute("primitiveUnits", "objectBoundingBox");
326 break;
327 default:
328 repr->setAttribute("primitiveUnits", "userSpaceOnUse");
329 break;
330 }
331 }
333 if (filter->x._set) {
334 sp_repr_set_svg_double(repr, "x", filter->x.computed);
335 } else {
336 repr->setAttribute("x", NULL);
337 }
339 if (filter->y._set) {
340 sp_repr_set_svg_double(repr, "y", filter->y.computed);
341 } else {
342 repr->setAttribute("y", NULL);
343 }
345 if (filter->width._set) {
346 sp_repr_set_svg_double(repr, "width", filter->width.computed);
347 } else {
348 repr->setAttribute("width", NULL);
349 }
351 if (filter->height._set) {
352 sp_repr_set_svg_double(repr, "height", filter->height.computed);
353 } else {
354 repr->setAttribute("height", NULL);
355 }
357 if (filter->filterRes.getNumber()>=0) {
358 gchar *tmp = filter->filterRes.getValueString();
359 repr->setAttribute("filterRes", tmp);
360 g_free(tmp);
361 } else {
362 repr->setAttribute("filterRes", NULL);
363 }
365 if (filter->href->getURI()) {
366 gchar *uri_string = filter->href->getURI()->toString();
367 repr->setAttribute("xlink:href", uri_string);
368 g_free(uri_string);
369 }
371 // TODO: This is evil, correctly implement support for color-interpolation-filters!!!
372 // The color-interpolation-filters attribute is initially set to linearRGB according to the SVG standard.
373 // However, Inkscape completely ignores it and implicitly assumes that it is sRGB (like color-interpolation-filters).
374 // This results in a discrepancy between Inkscape and other renderers in how they render filters.
375 // To mitigate this problem I've (Jasper van de Gronde,th.v.d.gronde@hccnet.nl) added this to ensure that at least
376 // any filters written by Inkscape will henceforth be rendered the same in other renderers.
377 // In the future Inkscape should have proper support for the color-interpolation properties and this should be changed.
378 repr->setAttribute("color-interpolation-filters", "sRGB");
380 if (((SPObjectClass *) filter_parent_class)->write) {
381 ((SPObjectClass *) filter_parent_class)->write(object, doc, repr, flags);
382 }
384 return repr;
385 }
388 /**
389 * Gets called when the filter is (re)attached to another filter.
390 */
391 static void
392 filter_ref_changed(SPObject *old_ref, SPObject *ref, SPFilter *filter)
393 {
394 if (old_ref) {
395 filter->modified_connection.disconnect();
396 }
397 if ( SP_IS_FILTER(ref)
398 && ref != filter )
399 {
400 filter->modified_connection =
401 ref->connectModified(sigc::bind(sigc::ptr_fun(&filter_ref_modified), filter));
402 }
404 filter_ref_modified(ref, 0, filter);
405 }
407 static void
408 filter_ref_modified(SPObject */*href*/, guint /*flags*/, SPFilter *filter)
409 {
410 SP_OBJECT(filter)->requestModified(SP_OBJECT_MODIFIED_FLAG);
411 }
413 /**
414 * Callback for child_added event.
415 */
416 static void
417 sp_filter_child_added(SPObject *object, Inkscape::XML::Node *child, Inkscape::XML::Node *ref)
418 {
419 //SPFilter *f = SP_FILTER(object);
421 if (((SPObjectClass *) filter_parent_class)->child_added)
422 (* ((SPObjectClass *) filter_parent_class)->child_added)(object, child, ref);
424 object->requestModified(SP_OBJECT_MODIFIED_FLAG);
425 }
427 /**
428 * Callback for remove_child event.
429 */
430 static void
431 sp_filter_remove_child(SPObject *object, Inkscape::XML::Node *child)
432 {
433 // SPFilter *f = SP_FILTER(object);
435 if (((SPObjectClass *) filter_parent_class)->remove_child)
436 (* ((SPObjectClass *) filter_parent_class)->remove_child)(object, child);
438 object->requestModified(SP_OBJECT_MODIFIED_FLAG);
439 }
441 void sp_filter_build_renderer(SPFilter *sp_filter, Inkscape::Filters::Filter *nr_filter)
442 {
443 g_assert(sp_filter != NULL);
444 g_assert(nr_filter != NULL);
446 sp_filter->_renderer = nr_filter;
448 nr_filter->set_filter_units(sp_filter->filterUnits);
449 nr_filter->set_primitive_units(sp_filter->primitiveUnits);
450 nr_filter->set_x(sp_filter->x);
451 nr_filter->set_y(sp_filter->y);
452 nr_filter->set_width(sp_filter->width);
453 nr_filter->set_height(sp_filter->height);
455 if (sp_filter->filterRes.getNumber() >= 0) {
456 if (sp_filter->filterRes.getOptNumber() >= 0) {
457 nr_filter->set_resolution(sp_filter->filterRes.getNumber(),
458 sp_filter->filterRes.getOptNumber());
459 } else {
460 nr_filter->set_resolution(sp_filter->filterRes.getNumber());
461 }
462 }
464 nr_filter->clear_primitives();
465 SPObject *primitive_obj = sp_filter->children;
466 while (primitive_obj) {
467 if (SP_IS_FILTER_PRIMITIVE(primitive_obj)) {
468 SPFilterPrimitive *primitive = SP_FILTER_PRIMITIVE(primitive_obj);
469 g_assert(primitive != NULL);
470 if (((SPFilterPrimitiveClass*) G_OBJECT_GET_CLASS(primitive))->build_renderer) {
471 ((SPFilterPrimitiveClass *) G_OBJECT_GET_CLASS(primitive))->build_renderer(primitive, nr_filter);
472 } else {
473 g_warning("Cannot build filter renderer: missing builder");
474 }
475 }
476 primitive_obj = primitive_obj->next;
477 }
478 }
480 int sp_filter_primitive_count(SPFilter *filter) {
481 g_assert(filter != NULL);
482 int count = 0;
484 SPObject *primitive_obj = filter->children;
485 while (primitive_obj) {
486 if (SP_IS_FILTER_PRIMITIVE(primitive_obj)) count++;
487 primitive_obj = primitive_obj->next;
488 }
489 return count;
490 }
492 int sp_filter_get_image_name(SPFilter *filter, gchar const *name) {
493 gchar *name_copy = strdup(name);
494 map<gchar *, int, ltstr>::iterator result = filter->_image_name->find(name_copy);
495 free(name_copy);
496 if (result == filter->_image_name->end()) return -1;
497 else return (*result).second;
498 }
500 int sp_filter_set_image_name(SPFilter *filter, gchar const *name) {
501 int value = filter->_image_number_next;
502 filter->_image_number_next++;
503 gchar *name_copy = strdup(name);
504 pair<gchar*,int> new_pair(name_copy, value);
505 pair<map<gchar*,int,ltstr>::iterator,bool> ret = filter->_image_name->insert(new_pair);
506 if (ret.second == false) {
507 return (*ret.first).second;
508 }
509 return value;
510 }
512 gchar const *sp_filter_name_for_image(SPFilter const *filter, int const image) {
513 switch (image) {
514 case Inkscape::Filters::NR_FILTER_SOURCEGRAPHIC:
515 return "SourceGraphic";
516 break;
517 case Inkscape::Filters::NR_FILTER_SOURCEALPHA:
518 return "SourceAlpha";
519 break;
520 case Inkscape::Filters::NR_FILTER_BACKGROUNDIMAGE:
521 return "BackgroundImage";
522 break;
523 case Inkscape::Filters::NR_FILTER_BACKGROUNDALPHA:
524 return "BackgroundAlpha";
525 break;
526 case Inkscape::Filters::NR_FILTER_STROKEPAINT:
527 return "StrokePaint";
528 break;
529 case Inkscape::Filters::NR_FILTER_FILLPAINT:
530 return "FillPaint";
531 break;
532 case Inkscape::Filters::NR_FILTER_SLOT_NOT_SET:
533 case Inkscape::Filters::NR_FILTER_UNNAMED_SLOT:
534 return 0;
535 break;
536 default:
537 for (map<gchar *, int, ltstr>::const_iterator i
538 = filter->_image_name->begin() ;
539 i != filter->_image_name->end() ; i++) {
540 if (i->second == image) {
541 return i->first;
542 }
543 }
544 }
545 return 0;
546 }
548 Glib::ustring sp_filter_get_new_result_name(SPFilter *filter) {
549 g_assert(filter != NULL);
550 int largest = 0;
552 SPObject *primitive_obj = filter->children;
553 while (primitive_obj) {
554 if (SP_IS_FILTER_PRIMITIVE(primitive_obj)) {
555 Inkscape::XML::Node *repr = SP_OBJECT_REPR(primitive_obj);
556 char const *result = repr->attribute("result");
557 int index;
558 if (result && sscanf(result, "result%d", &index) == 1) {
559 if (index > largest) {
560 largest = index;
561 }
562 }
563 }
564 primitive_obj = primitive_obj->next;
565 }
567 return "result" + Glib::Ascii::dtostr(largest + 1);
568 }
570 bool ltstr::operator()(const char* s1, const char* s2) const
571 {
572 return strcmp(s1, s2) < 0;
573 }
576 /*
577 Local Variables:
578 mode:c++
579 c-file-style:"stroustrup"
580 c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
581 indent-tabs-mode:nil
582 fill-column:99
583 End:
584 */
585 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 :