1 #define __SP_FILTER_CPP__
3 /** \file
4 * SVG <filter> implementation.
5 */
6 /*
7 * Authors:
8 * Hugo Rodrigues <haa.rodrigues@gmail.com>
9 * Niko Kiirala <niko@kiirala.com>
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 sp_object_read_attr(object, "filterUnits");
140 sp_object_read_attr(object, "primitiveUnits");
141 sp_object_read_attr(object, "x");
142 sp_object_read_attr(object, "y");
143 sp_object_read_attr(object, "width");
144 sp_object_read_attr(object, "height");
145 sp_object_read_attr(object, "filterRes");
146 sp_object_read_attr(object, "xlink:href");
148 //is this necessary?
149 sp_document_add_resource(document, "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_document_remove_resource(SP_OBJECT_DOCUMENT(object), "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);
287 SPObject *child;
288 Inkscape::XML::Node *crepr;
290 /* Original from sp-item-group.cpp */
291 if (flags & SP_OBJECT_WRITE_BUILD) {
292 GSList *l;
293 if (!repr) {
294 repr = doc->createElement("svg:filter");
295 }
296 l = NULL;
297 for (child = sp_object_first_child(object); child != NULL; child = SP_OBJECT_NEXT(child) ) {
298 crepr = child->updateRepr(doc, NULL, flags);
299 if (crepr) l = g_slist_prepend (l, crepr);
300 }
301 while (l) {
302 repr->addChild((Inkscape::XML::Node *) l->data, NULL);
303 Inkscape::GC::release((Inkscape::XML::Node *) l->data);
304 l = g_slist_remove (l, l->data);
305 }
306 } else {
307 for (child = sp_object_first_child(object) ; child != NULL; child = SP_OBJECT_NEXT(child) ) {
308 child->updateRepr(flags);
309 }
310 }
312 if ((flags & SP_OBJECT_WRITE_ALL) || filter->filterUnits_set) {
313 switch (filter->filterUnits) {
314 case SP_FILTER_UNITS_USERSPACEONUSE:
315 repr->setAttribute("filterUnits", "userSpaceOnUse");
316 break;
317 default:
318 repr->setAttribute("filterUnits", "objectBoundingBox");
319 break;
320 }
321 }
323 if ((flags & SP_OBJECT_WRITE_ALL) || filter->primitiveUnits_set) {
324 switch (filter->primitiveUnits) {
325 case SP_FILTER_UNITS_OBJECTBOUNDINGBOX:
326 repr->setAttribute("primitiveUnits", "objectBoundingBox");
327 break;
328 default:
329 repr->setAttribute("primitiveUnits", "userSpaceOnUse");
330 break;
331 }
332 }
334 if (filter->x._set) {
335 sp_repr_set_svg_double(repr, "x", filter->x.computed);
336 } else {
337 repr->setAttribute("x", NULL);
338 }
340 if (filter->y._set) {
341 sp_repr_set_svg_double(repr, "y", filter->y.computed);
342 } else {
343 repr->setAttribute("y", NULL);
344 }
346 if (filter->width._set) {
347 sp_repr_set_svg_double(repr, "width", filter->width.computed);
348 } else {
349 repr->setAttribute("width", NULL);
350 }
352 if (filter->height._set) {
353 sp_repr_set_svg_double(repr, "height", filter->height.computed);
354 } else {
355 repr->setAttribute("height", NULL);
356 }
358 if (filter->filterRes.getNumber()>=0) {
359 gchar *tmp = filter->filterRes.getValueString();
360 repr->setAttribute("filterRes", tmp);
361 g_free(tmp);
362 } else {
363 repr->setAttribute("filterRes", NULL);
364 }
366 if (filter->href->getURI()) {
367 gchar *uri_string = filter->href->getURI()->toString();
368 repr->setAttribute("xlink:href", uri_string);
369 g_free(uri_string);
370 }
372 // TODO: This is evil, correctly implement support for color-interpolation-filters!!!
373 // The color-interpolation-filters attribute is initially set to linearRGB according to the SVG standard.
374 // However, Inkscape completely ignores it and implicitly assumes that it is sRGB (like color-interpolation-filters).
375 // This results in a discrepancy between Inkscape and other renderers in how they render filters.
376 // To mitigate this problem I've (Jasper van de Gronde,th.v.d.gronde@hccnet.nl) added this to ensure that at least
377 // any filters written by Inkscape will henceforth be rendered the same in other renderers.
378 // In the future Inkscape should have proper support for the color-interpolation properties and this should be changed.
379 repr->setAttribute("color-interpolation-filters", "sRGB");
381 if (((SPObjectClass *) filter_parent_class)->write) {
382 ((SPObjectClass *) filter_parent_class)->write(object, doc, repr, flags);
383 }
385 return repr;
386 }
389 /**
390 * Gets called when the filter is (re)attached to another filter.
391 */
392 static void
393 filter_ref_changed(SPObject *old_ref, SPObject *ref, SPFilter *filter)
394 {
395 if (old_ref) {
396 filter->modified_connection.disconnect();
397 }
398 if ( SP_IS_FILTER(ref)
399 && ref != filter )
400 {
401 filter->modified_connection =
402 ref->connectModified(sigc::bind(sigc::ptr_fun(&filter_ref_modified), filter));
403 }
405 filter_ref_modified(ref, 0, filter);
406 }
408 static void
409 filter_ref_modified(SPObject */*href*/, guint /*flags*/, SPFilter *filter)
410 {
411 SP_OBJECT(filter)->requestModified(SP_OBJECT_MODIFIED_FLAG);
412 }
414 /**
415 * Callback for child_added event.
416 */
417 static void
418 sp_filter_child_added(SPObject *object, Inkscape::XML::Node *child, Inkscape::XML::Node *ref)
419 {
420 //SPFilter *f = SP_FILTER(object);
422 if (((SPObjectClass *) filter_parent_class)->child_added)
423 (* ((SPObjectClass *) filter_parent_class)->child_added)(object, child, ref);
425 object->requestModified(SP_OBJECT_MODIFIED_FLAG);
426 }
428 /**
429 * Callback for remove_child event.
430 */
431 static void
432 sp_filter_remove_child(SPObject *object, Inkscape::XML::Node *child)
433 {
434 // SPFilter *f = SP_FILTER(object);
436 if (((SPObjectClass *) filter_parent_class)->remove_child)
437 (* ((SPObjectClass *) filter_parent_class)->remove_child)(object, child);
439 object->requestModified(SP_OBJECT_MODIFIED_FLAG);
440 }
442 void sp_filter_build_renderer(SPFilter *sp_filter, Inkscape::Filters::Filter *nr_filter)
443 {
444 g_assert(sp_filter != NULL);
445 g_assert(nr_filter != NULL);
447 sp_filter->_renderer = nr_filter;
449 nr_filter->set_filter_units(sp_filter->filterUnits);
450 nr_filter->set_primitive_units(sp_filter->primitiveUnits);
451 nr_filter->set_x(sp_filter->x);
452 nr_filter->set_y(sp_filter->y);
453 nr_filter->set_width(sp_filter->width);
454 nr_filter->set_height(sp_filter->height);
456 if (sp_filter->filterRes.getNumber() >= 0) {
457 if (sp_filter->filterRes.getOptNumber() >= 0) {
458 nr_filter->set_resolution(sp_filter->filterRes.getNumber(),
459 sp_filter->filterRes.getOptNumber());
460 } else {
461 nr_filter->set_resolution(sp_filter->filterRes.getNumber());
462 }
463 }
465 nr_filter->clear_primitives();
466 SPObject *primitive_obj = sp_filter->children;
467 while (primitive_obj) {
468 if (SP_IS_FILTER_PRIMITIVE(primitive_obj)) {
469 SPFilterPrimitive *primitive = SP_FILTER_PRIMITIVE(primitive_obj);
470 g_assert(primitive != NULL);
471 if (((SPFilterPrimitiveClass*) G_OBJECT_GET_CLASS(primitive))->build_renderer) {
472 ((SPFilterPrimitiveClass *) G_OBJECT_GET_CLASS(primitive))->build_renderer(primitive, nr_filter);
473 } else {
474 g_warning("Cannot build filter renderer: missing builder");
475 }
476 }
477 primitive_obj = primitive_obj->next;
478 }
479 }
481 int sp_filter_primitive_count(SPFilter *filter) {
482 g_assert(filter != NULL);
483 int count = 0;
485 SPObject *primitive_obj = filter->children;
486 while (primitive_obj) {
487 if (SP_IS_FILTER_PRIMITIVE(primitive_obj)) count++;
488 primitive_obj = primitive_obj->next;
489 }
490 return count;
491 }
493 int sp_filter_get_image_name(SPFilter *filter, gchar const *name) {
494 gchar *name_copy = strdup(name);
495 map<gchar *, int, ltstr>::iterator result = filter->_image_name->find(name_copy);
496 free(name_copy);
497 if (result == filter->_image_name->end()) return -1;
498 else return (*result).second;
499 }
501 int sp_filter_set_image_name(SPFilter *filter, gchar const *name) {
502 int value = filter->_image_number_next;
503 filter->_image_number_next++;
504 gchar *name_copy = strdup(name);
505 pair<gchar*,int> new_pair(name_copy, value);
506 pair<map<gchar*,int,ltstr>::iterator,bool> ret = filter->_image_name->insert(new_pair);
507 if (ret.second == false) {
508 return (*ret.first).second;
509 }
510 return value;
511 }
513 gchar const *sp_filter_name_for_image(SPFilter const *filter, int const image) {
514 switch (image) {
515 case Inkscape::Filters::NR_FILTER_SOURCEGRAPHIC:
516 return "SourceGraphic";
517 break;
518 case Inkscape::Filters::NR_FILTER_SOURCEALPHA:
519 return "SourceAlpha";
520 break;
521 case Inkscape::Filters::NR_FILTER_BACKGROUNDIMAGE:
522 return "BackgroundImage";
523 break;
524 case Inkscape::Filters::NR_FILTER_BACKGROUNDALPHA:
525 return "BackgroundAlpha";
526 break;
527 case Inkscape::Filters::NR_FILTER_STROKEPAINT:
528 return "StrokePaint";
529 break;
530 case Inkscape::Filters::NR_FILTER_FILLPAINT:
531 return "FillPaint";
532 break;
533 case Inkscape::Filters::NR_FILTER_SLOT_NOT_SET:
534 case Inkscape::Filters::NR_FILTER_UNNAMED_SLOT:
535 return 0;
536 break;
537 default:
538 for (map<gchar *, int, ltstr>::const_iterator i
539 = filter->_image_name->begin() ;
540 i != filter->_image_name->end() ; i++) {
541 if (i->second == image) {
542 return i->first;
543 }
544 }
545 }
546 return 0;
547 }
549 Glib::ustring sp_filter_get_new_result_name(SPFilter *filter) {
550 g_assert(filter != NULL);
551 int largest = 0;
553 SPObject *primitive_obj = filter->children;
554 while (primitive_obj) {
555 if (SP_IS_FILTER_PRIMITIVE(primitive_obj)) {
556 Inkscape::XML::Node *repr = SP_OBJECT_REPR(primitive_obj);
557 char const *result = repr->attribute("result");
558 int index;
559 if (result && sscanf(result, "result%d", &index) == 1) {
560 if (index > largest) {
561 largest = index;
562 }
563 }
564 }
565 primitive_obj = primitive_obj->next;
566 }
568 return "result" + Glib::Ascii::dtostr(largest + 1);
569 }
571 bool ltstr::operator()(const char* s1, const char* s2) const
572 {
573 return strcmp(s1, s2) < 0;
574 }
577 /*
578 Local Variables:
579 mode:c++
580 c-file-style:"stroustrup"
581 c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
582 indent-tabs-mode:nil
583 fill-column:99
584 End:
585 */
586 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :