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_OBJECTBOUNDINGBOX;
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, "userSpaceOnUse")) {
208 filter->primitiveUnits = SP_FILTER_UNITS_USERSPACEONUSE;
209 } else {
210 filter->primitiveUnits = SP_FILTER_UNITS_OBJECTBOUNDINGBOX;
211 }
212 filter->primitiveUnits_set = TRUE;
213 } else {
214 filter->primitiveUnits = SP_FILTER_UNITS_OBJECTBOUNDINGBOX;
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 if (!repr) {
289 repr = SP_OBJECT_REPR(object)->duplicate(doc);
290 }
292 if ((flags & SP_OBJECT_WRITE_ALL) || filter->filterUnits_set) {
293 switch (filter->filterUnits) {
294 case SP_FILTER_UNITS_USERSPACEONUSE:
295 repr->setAttribute("filterUnits", "userSpaceOnUse");
296 break;
297 default:
298 repr->setAttribute("filterUnits", "objectBoundingBox");
299 break;
300 }
301 }
303 if ((flags & SP_OBJECT_WRITE_ALL) || filter->primitiveUnits_set) {
304 switch (filter->primitiveUnits) {
305 case SP_FILTER_UNITS_USERSPACEONUSE:
306 repr->setAttribute("primitiveUnits", "userSpaceOnUse");
307 break;
308 default:
309 repr->setAttribute("primitiveUnits", "objectBoundingBox");
310 break;
311 }
312 }
314 if (filter->x._set) {
315 sp_repr_set_svg_double(repr, "x", filter->x.computed);
316 } else {
317 repr->setAttribute("x", NULL);
318 }
320 if (filter->y._set) {
321 sp_repr_set_svg_double(repr, "y", filter->y.computed);
322 } else {
323 repr->setAttribute("y", NULL);
324 }
326 if (filter->width._set) {
327 sp_repr_set_svg_double(repr, "width", filter->width.computed);
328 } else {
329 repr->setAttribute("width", NULL);
330 }
332 if (filter->height._set) {
333 sp_repr_set_svg_double(repr, "height", filter->height.computed);
334 } else {
335 repr->setAttribute("height", NULL);
336 }
338 if (filter->filterRes.getNumber()>=0) {
339 gchar *tmp = filter->filterRes.getValueString();
340 repr->setAttribute("filterRes", tmp);
341 g_free(tmp);
342 } else {
343 repr->setAttribute("filterRes", NULL);
344 }
346 if (filter->href->getURI()) {
347 gchar *uri_string = filter->href->getURI()->toString();
348 repr->setAttribute("xlink:href", uri_string);
349 g_free(uri_string);
350 }
352 // TODO: This is evil, correctly implement support for color-interpolation-filters!!!
353 // The color-interpolation-filters attribute is initially set to linearRGB according to the SVG standard.
354 // However, Inkscape completely ignores it and implicitly assumes that it is sRGB (like color-interpolation-filters).
355 // This results in a discrepancy between Inkscape and other renderers in how they render filters.
356 // To mitigate this problem I've (Jasper van de Gronde,th.v.d.gronde@hccnet.nl) added this to ensure that at least
357 // any filters written by Inkscape will henceforth be rendered the same in other renderers.
358 // In the future Inkscape should have proper support for the color-interpolation properties and this should be changed.
359 repr->setAttribute("color-interpolation-filters", "sRGB");
361 if (((SPObjectClass *) filter_parent_class)->write) {
362 ((SPObjectClass *) filter_parent_class)->write(object, doc, repr, flags);
363 }
365 return repr;
366 }
369 /**
370 * Gets called when the filter is (re)attached to another filter.
371 */
372 static void
373 filter_ref_changed(SPObject *old_ref, SPObject *ref, SPFilter *filter)
374 {
375 if (old_ref) {
376 filter->modified_connection.disconnect();
377 }
378 if ( SP_IS_FILTER(ref)
379 && ref != filter )
380 {
381 filter->modified_connection =
382 ref->connectModified(sigc::bind(sigc::ptr_fun(&filter_ref_modified), filter));
383 }
385 filter_ref_modified(ref, 0, filter);
386 }
388 static void
389 filter_ref_modified(SPObject */*href*/, guint /*flags*/, SPFilter *filter)
390 {
391 SP_OBJECT(filter)->requestModified(SP_OBJECT_MODIFIED_FLAG);
392 }
394 /**
395 * Callback for child_added event.
396 */
397 static void
398 sp_filter_child_added(SPObject *object, Inkscape::XML::Node *child, Inkscape::XML::Node *ref)
399 {
400 //SPFilter *f = SP_FILTER(object);
402 if (((SPObjectClass *) filter_parent_class)->child_added)
403 (* ((SPObjectClass *) filter_parent_class)->child_added)(object, child, ref);
405 object->requestModified(SP_OBJECT_MODIFIED_FLAG);
406 }
408 /**
409 * Callback for remove_child event.
410 */
411 static void
412 sp_filter_remove_child(SPObject *object, Inkscape::XML::Node *child)
413 {
414 // SPFilter *f = SP_FILTER(object);
416 if (((SPObjectClass *) filter_parent_class)->remove_child)
417 (* ((SPObjectClass *) filter_parent_class)->remove_child)(object, child);
419 object->requestModified(SP_OBJECT_MODIFIED_FLAG);
420 }
422 void sp_filter_build_renderer(SPFilter *sp_filter, Inkscape::Filters::Filter *nr_filter)
423 {
424 g_assert(sp_filter != NULL);
425 g_assert(nr_filter != NULL);
427 sp_filter->_renderer = nr_filter;
429 nr_filter->set_x(sp_filter->x);
430 nr_filter->set_y(sp_filter->y);
431 nr_filter->set_width(sp_filter->width);
432 nr_filter->set_height(sp_filter->height);
434 if (sp_filter->filterRes.getNumber() >= 0) {
435 if (sp_filter->filterRes.getOptNumber() >= 0) {
436 nr_filter->set_resolution(sp_filter->filterRes.getNumber(),
437 sp_filter->filterRes.getOptNumber());
438 } else {
439 nr_filter->set_resolution(sp_filter->filterRes.getNumber());
440 }
441 }
443 nr_filter->clear_primitives();
444 SPObject *primitive_obj = sp_filter->children;
445 while (primitive_obj) {
446 if (SP_IS_FILTER_PRIMITIVE(primitive_obj)) {
447 SPFilterPrimitive *primitive = SP_FILTER_PRIMITIVE(primitive_obj);
448 g_assert(primitive != NULL);
449 if (((SPFilterPrimitiveClass*) G_OBJECT_GET_CLASS(primitive))->build_renderer) {
450 ((SPFilterPrimitiveClass *) G_OBJECT_GET_CLASS(primitive))->build_renderer(primitive, nr_filter);
451 } else {
452 g_warning("Cannot build filter renderer: missing builder");
453 }
454 }
455 primitive_obj = primitive_obj->next;
456 }
457 }
459 int sp_filter_primitive_count(SPFilter *filter) {
460 g_assert(filter != NULL);
461 int count = 0;
463 SPObject *primitive_obj = filter->children;
464 while (primitive_obj) {
465 if (SP_IS_FILTER_PRIMITIVE(primitive_obj)) count++;
466 primitive_obj = primitive_obj->next;
467 }
468 return count;
469 }
471 int sp_filter_get_image_name(SPFilter *filter, gchar const *name) {
472 gchar *name_copy = strdup(name);
473 map<gchar *, int, ltstr>::iterator result = filter->_image_name->find(name_copy);
474 free(name_copy);
475 if (result == filter->_image_name->end()) return -1;
476 else return (*result).second;
477 }
479 int sp_filter_set_image_name(SPFilter *filter, gchar const *name) {
480 int value = filter->_image_number_next;
481 filter->_image_number_next++;
482 gchar *name_copy = strdup(name);
483 pair<gchar*,int> new_pair(name_copy, value);
484 pair<map<gchar*,int,ltstr>::iterator,bool> ret = filter->_image_name->insert(new_pair);
485 if (ret.second == false) {
486 return (*ret.first).second;
487 }
488 return value;
489 }
491 Glib::ustring sp_filter_get_new_result_name(SPFilter *filter) {
492 g_assert(filter != NULL);
493 int largest = 0;
495 SPObject *primitive_obj = filter->children;
496 while (primitive_obj) {
497 if (SP_IS_FILTER_PRIMITIVE(primitive_obj)) {
498 Inkscape::XML::Node *repr = SP_OBJECT_REPR(primitive_obj);
499 char const *result = repr->attribute("result");
500 int index;
501 if (result && sscanf(result, "result%d", &index) == 1) {
502 if (index > largest) {
503 largest = index;
504 }
505 }
506 }
507 primitive_obj = primitive_obj->next;
508 }
510 return "result" + Glib::Ascii::dtostr(largest + 1);
511 }
513 bool ltstr::operator()(const char* s1, const char* s2) const
514 {
515 return strcmp(s1, s2) < 0;
516 }
519 /*
520 Local Variables:
521 mode:c++
522 c-file-style:"stroustrup"
523 c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
524 indent-tabs-mode:nil
525 fill-column:99
526 End:
527 */
528 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :