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 if (((SPObjectClass *) filter_parent_class)->write) {
353 ((SPObjectClass *) filter_parent_class)->write(object, doc, repr, flags);
354 }
356 return repr;
357 }
360 /**
361 * Gets called when the filter is (re)attached to another filter.
362 */
363 static void
364 filter_ref_changed(SPObject *old_ref, SPObject *ref, SPFilter *filter)
365 {
366 if (old_ref) {
367 filter->modified_connection.disconnect();
368 }
369 if ( SP_IS_FILTER(ref)
370 && ref != filter )
371 {
372 filter->modified_connection =
373 ref->connectModified(sigc::bind(sigc::ptr_fun(&filter_ref_modified), filter));
374 }
376 filter_ref_modified(ref, 0, filter);
377 }
379 static void
380 filter_ref_modified(SPObject */*href*/, guint /*flags*/, SPFilter *filter)
381 {
382 SP_OBJECT(filter)->requestModified(SP_OBJECT_MODIFIED_FLAG);
383 }
385 /**
386 * Callback for child_added event.
387 */
388 static void
389 sp_filter_child_added(SPObject *object, Inkscape::XML::Node *child, Inkscape::XML::Node *ref)
390 {
391 //SPFilter *f = SP_FILTER(object);
393 if (((SPObjectClass *) filter_parent_class)->child_added)
394 (* ((SPObjectClass *) filter_parent_class)->child_added)(object, child, ref);
396 object->requestModified(SP_OBJECT_MODIFIED_FLAG);
397 }
399 /**
400 * Callback for remove_child event.
401 */
402 static void
403 sp_filter_remove_child(SPObject *object, Inkscape::XML::Node *child)
404 {
405 // SPFilter *f = SP_FILTER(object);
407 if (((SPObjectClass *) filter_parent_class)->remove_child)
408 (* ((SPObjectClass *) filter_parent_class)->remove_child)(object, child);
410 object->requestModified(SP_OBJECT_MODIFIED_FLAG);
411 }
413 void sp_filter_build_renderer(SPFilter *sp_filter, Inkscape::Filters::Filter *nr_filter)
414 {
415 g_assert(sp_filter != NULL);
416 g_assert(nr_filter != NULL);
418 sp_filter->_renderer = nr_filter;
420 nr_filter->set_x(sp_filter->x);
421 nr_filter->set_y(sp_filter->y);
422 nr_filter->set_width(sp_filter->width);
423 nr_filter->set_height(sp_filter->height);
425 if (sp_filter->filterRes.getNumber() >= 0) {
426 if (sp_filter->filterRes.getOptNumber() >= 0) {
427 nr_filter->set_resolution(sp_filter->filterRes.getNumber(),
428 sp_filter->filterRes.getOptNumber());
429 } else {
430 nr_filter->set_resolution(sp_filter->filterRes.getNumber());
431 }
432 }
434 nr_filter->clear_primitives();
435 SPObject *primitive_obj = sp_filter->children;
436 while (primitive_obj) {
437 if (SP_IS_FILTER_PRIMITIVE(primitive_obj)) {
438 SPFilterPrimitive *primitive = SP_FILTER_PRIMITIVE(primitive_obj);
439 g_assert(primitive != NULL);
440 if (((SPFilterPrimitiveClass*) G_OBJECT_GET_CLASS(primitive))->build_renderer) {
441 ((SPFilterPrimitiveClass *) G_OBJECT_GET_CLASS(primitive))->build_renderer(primitive, nr_filter);
442 } else {
443 g_warning("Cannot build filter renderer: missing builder");
444 }
445 }
446 primitive_obj = primitive_obj->next;
447 }
448 }
450 int sp_filter_primitive_count(SPFilter *filter) {
451 g_assert(filter != NULL);
452 int count = 0;
454 SPObject *primitive_obj = filter->children;
455 while (primitive_obj) {
456 if (SP_IS_FILTER_PRIMITIVE(primitive_obj)) count++;
457 primitive_obj = primitive_obj->next;
458 }
459 return count;
460 }
462 int sp_filter_get_image_name(SPFilter *filter, gchar const *name) {
463 gchar *name_copy = strdup(name);
464 map<gchar *, int, ltstr>::iterator result = filter->_image_name->find(name_copy);
465 free(name_copy);
466 if (result == filter->_image_name->end()) return -1;
467 else return (*result).second;
468 }
470 int sp_filter_set_image_name(SPFilter *filter, gchar const *name) {
471 int value = filter->_image_number_next;
472 filter->_image_number_next++;
473 gchar *name_copy = strdup(name);
474 pair<gchar*,int> new_pair(name_copy, value);
475 pair<map<gchar*,int,ltstr>::iterator,bool> ret = filter->_image_name->insert(new_pair);
476 if (ret.second == false) {
477 return (*ret.first).second;
478 }
479 return value;
480 }
482 Glib::ustring sp_filter_get_new_result_name(SPFilter *filter) {
483 g_assert(filter != NULL);
484 int largest = 0;
486 SPObject *primitive_obj = filter->children;
487 while (primitive_obj) {
488 if (SP_IS_FILTER_PRIMITIVE(primitive_obj)) {
489 Inkscape::XML::Node *repr = SP_OBJECT_REPR(primitive_obj);
490 char const *result = repr->attribute("result");
491 int index;
492 if (result && sscanf(result, "result%d", &index) == 1) {
493 if (index > largest) {
494 largest = index;
495 }
496 }
497 }
498 primitive_obj = primitive_obj->next;
499 }
501 return "result" + Glib::Ascii::dtostr(largest + 1);
502 }
504 bool ltstr::operator()(const char* s1, const char* s2) const
505 {
506 return strcmp(s1, s2) < 0;
507 }
510 /*
511 Local Variables:
512 mode:c++
513 c-file-style:"stroustrup"
514 c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
515 indent-tabs-mode:nil
516 fill-column:99
517 End:
518 */
519 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :