1 #define __SP_FILTER_CPP__
3 /** \file
4 * SVG <filter> implementation.
5 */
6 /*
7 * Authors:
8 * Hugo Rodrigues <haa.rodrigues@gmail.com>
9 *
10 * Copyright (C) 2006 Hugo Rodrigues
11 *
12 * Released under GNU GPL, read the file 'COPYING' for more information
13 */
15 #ifdef HAVE_CONFIG_H
16 # include "config.h"
17 #endif
19 #include "attributes.h"
20 #include "document.h"
21 #include "sp-filter.h"
22 #include "sp-filter-reference.h"
23 #include "uri.h"
24 #include "xml/repr.h"
26 #define SP_MACROS_SILENT
27 #include "macros.h"
30 /* Filter base class */
32 static void sp_filter_class_init(SPFilterClass *klass);
33 static void sp_filter_init(SPFilter *filter);
35 static void sp_filter_build(SPObject *object, SPDocument *document, Inkscape::XML::Node *repr);
36 static void sp_filter_release(SPObject *object);
37 static void sp_filter_set(SPObject *object, unsigned int key, gchar const *value);
38 static void sp_filter_update(SPObject *object, SPCtx *ctx, guint flags);
39 static void sp_filter_child_added(SPObject *object,
40 Inkscape::XML::Node *child,
41 Inkscape::XML::Node *ref);
42 static void sp_filter_remove_child(SPObject *object, Inkscape::XML::Node *child);
43 static Inkscape::XML::Node *sp_filter_write(SPObject *object, Inkscape::XML::Node *repr, guint flags);
45 static void filter_ref_changed(SPObject *old_ref, SPObject *ref, SPFilter *filter);
46 static void filter_ref_modified(SPObject *href, guint flags, SPFilter *filter);
48 static SPObjectClass *filter_parent_class;
50 GType
51 sp_filter_get_type()
52 {
53 static GType filter_type = 0;
55 if (!filter_type) {
56 GTypeInfo filter_info = {
57 sizeof(SPFilterClass),
58 NULL, NULL,
59 (GClassInitFunc) sp_filter_class_init,
60 NULL, NULL,
61 sizeof(SPFilter),
62 16,
63 (GInstanceInitFunc) sp_filter_init,
64 NULL, /* value_table */
65 };
66 filter_type = g_type_register_static(SP_TYPE_OBJECT, "SPFilter", &filter_info, (GTypeFlags)0);
67 }
68 return filter_type;
69 }
71 static void
72 sp_filter_class_init(SPFilterClass *klass)
73 {
75 SPObjectClass *sp_object_class = (SPObjectClass *)klass;
77 filter_parent_class = (SPObjectClass*)g_type_class_peek_parent(klass);
79 sp_object_class->build = sp_filter_build;
80 sp_object_class->release = sp_filter_release;
81 sp_object_class->write = sp_filter_write;
82 sp_object_class->set = sp_filter_set;
83 sp_object_class->update = sp_filter_update;
84 sp_object_class->child_added = sp_filter_child_added;
85 sp_object_class->remove_child = sp_filter_remove_child;
86 }
88 static void
89 sp_filter_init(SPFilter *filter)
90 {
91 filter->href = new SPFilterReference(SP_OBJECT(filter));
92 filter->href->changedSignal().connect(sigc::bind(sigc::ptr_fun(filter_ref_changed), filter));
94 filter->x = 0;
95 filter->y = 0;
96 filter->width = 0;
97 filter->height = 0;
99 filter->filterUnits = SP_FILTER_UNITS_OBJECTBOUNDINGBOX;
100 filter->primitiveUnits = SP_FILTER_UNITS_OBJECTBOUNDINGBOX;
101 filter->filterUnits_set = FALSE;
102 filter->primitiveUnits_set = FALSE;
103 filter->_primitive_count=0;
105 filter->_primitive_table_size = 1;
106 filter->_primitives = new SPFilterPrimitive*[1];
107 filter->_primitives[0] = NULL;
109 }
111 /**
112 * Reads the Inkscape::XML::Node, and initializes SPFilter variables. For this to get called,
113 * our name must be associated with a repr via "sp_object_type_register". Best done through
114 * sp-object-repr.cpp's repr_name_entries array.
115 */
116 static void
117 sp_filter_build(SPObject *object, SPDocument *document, Inkscape::XML::Node *repr)
118 {
119 if (((SPObjectClass *) filter_parent_class)->build) {
120 ((SPObjectClass *) filter_parent_class)->build(object, document, repr);
121 }
123 //Read values of key attributes from XML nodes into object.
124 sp_object_read_attr(object, "filterUnits");
125 sp_object_read_attr(object, "primitiveUnits");
126 sp_object_read_attr(object, "x");
127 sp_object_read_attr(object, "y");
128 sp_object_read_attr(object, "width");
129 sp_object_read_attr(object, "height");
130 sp_object_read_attr(object, "filterRes");
131 sp_object_read_attr(object, "xlink:href");
133 //is this necessary?
134 sp_document_add_resource(document, "filter", object);
135 }
137 /**
138 * Drops any allocated memory.
139 */
140 static void
141 sp_filter_release(SPObject *object)
142 {
143 SPFilter *filter = SP_FILTER(object);
145 if (SP_OBJECT_DOCUMENT(object)) {
146 /* Unregister ourselves */
147 sp_document_remove_resource(SP_OBJECT_DOCUMENT(object), "filter", SP_OBJECT(object));
148 }
150 //TODO: release resources here
152 //release href
153 if (filter->href) {
154 if (filter->href->getObject()) {
155 sp_signal_disconnect_by_data(filter->href->getObject(), filter);
156 }
157 filter->href->detach();
158 delete filter->href;
159 filter->href = NULL;
160 }
162 if (((SPObjectClass *) filter_parent_class)->release)
163 ((SPObjectClass *) filter_parent_class)->release(object);
164 }
166 /**
167 * Sets a specific value in the SPFilter.
168 */
169 static void
170 sp_filter_set(SPObject *object, unsigned int key, gchar const *value)
171 {
172 SPFilter *filter = SP_FILTER(object);
174 switch (key) {
175 case SP_ATTR_FILTERUNITS:
176 if (value) {
177 if (!strcmp(value, "userSpaceOnUse")) {
178 filter->filterUnits = SP_FILTER_UNITS_USERSPACEONUSE;
179 } else {
180 filter->filterUnits = SP_FILTER_UNITS_OBJECTBOUNDINGBOX;
181 }
182 filter->filterUnits_set = TRUE;
183 } else {
184 filter->filterUnits = SP_FILTER_UNITS_OBJECTBOUNDINGBOX;
185 filter->filterUnits_set = FALSE;
186 }
187 object->requestModified(SP_OBJECT_MODIFIED_FLAG);
188 break;
189 case SP_ATTR_PRIMITIVEUNITS:
190 if (value) {
191 if (!strcmp(value, "userSpaceOnUse")) {
192 filter->primitiveUnits = SP_FILTER_UNITS_USERSPACEONUSE;
193 } else {
194 filter->primitiveUnits = SP_FILTER_UNITS_OBJECTBOUNDINGBOX;
195 }
196 filter->primitiveUnits_set = TRUE;
197 } else {
198 filter->primitiveUnits = SP_FILTER_UNITS_OBJECTBOUNDINGBOX;
199 filter->primitiveUnits_set = FALSE;
200 }
201 object->requestModified(SP_OBJECT_MODIFIED_FLAG);
202 break;
203 case SP_ATTR_X:
204 filter->x.readOrUnset(value);
205 object->requestModified(SP_OBJECT_MODIFIED_FLAG);
206 break;
207 case SP_ATTR_Y:
208 filter->y.readOrUnset(value);
209 object->requestModified(SP_OBJECT_MODIFIED_FLAG);
210 break;
211 case SP_ATTR_WIDTH:
212 filter->width.readOrUnset(value);
213 object->requestModified(SP_OBJECT_MODIFIED_FLAG);
214 break;
215 case SP_ATTR_HEIGHT:
216 filter->height.readOrUnset(value);
217 object->requestModified(SP_OBJECT_MODIFIED_FLAG);
218 break;
219 case SP_ATTR_FILTERRES:
220 filter->filterRes.set(value);
221 break;
222 case SP_ATTR_XLINK_HREF:
223 if (value) {
224 try {
225 filter->href->attach(Inkscape::URI(value));
226 } catch (Inkscape::BadURIException &e) {
227 g_warning("%s", e.what());
228 filter->href->detach();
229 }
230 } else {
231 filter->href->detach();
232 }
233 break;
234 default:
235 // See if any parents need this value.
236 if (((SPObjectClass *) filter_parent_class)->set) {
237 ((SPObjectClass *) filter_parent_class)->set(object, key, value);
238 }
239 break;
240 }
241 }
243 /**
244 * Receives update notifications.
245 */
246 static void
247 sp_filter_update(SPObject *object, SPCtx *ctx, guint flags)
248 {
249 //SPFilter *filter = SP_FILTER(object);
251 if (flags & (SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_STYLE_MODIFIED_FLAG |
252 SP_OBJECT_VIEWPORT_MODIFIED_FLAG)) {
254 /* do something to trigger redisplay, updates? */
256 }
258 if (((SPObjectClass *) filter_parent_class)->update) {
259 ((SPObjectClass *) filter_parent_class)->update(object, ctx, flags);
260 }
261 }
263 /**
264 * Writes its settings to an incoming repr object, if any.
265 */
266 static Inkscape::XML::Node *
267 sp_filter_write(SPObject *object, Inkscape::XML::Node *repr, guint flags)
268 {
269 SPFilter *filter = SP_FILTER(object);
271 if (!repr) {
272 repr = SP_OBJECT_REPR(object)->duplicate();
273 }
275 if ((flags & SP_OBJECT_WRITE_ALL) || filter->filterUnits_set) {
276 switch (filter->filterUnits) {
277 case SP_FILTER_UNITS_USERSPACEONUSE:
278 repr->setAttribute("filterUnits", "userSpaceOnUse");
279 break;
280 default:
281 repr->setAttribute("filterUnits", "objectBoundingBox");
282 break;
283 }
284 }
286 if ((flags & SP_OBJECT_WRITE_ALL) || filter->primitiveUnits_set) {
287 switch (filter->primitiveUnits) {
288 case SP_FILTER_UNITS_USERSPACEONUSE:
289 repr->setAttribute("primitiveUnits", "userSpaceOnUse");
290 break;
291 default:
292 repr->setAttribute("primitiveUnits", "objectBoundingBox");
293 break;
294 }
295 }
297 if (filter->x._set) {
298 sp_repr_set_svg_double(repr, "x", filter->x.computed);
299 } else {
300 repr->setAttribute("x", NULL);
301 }
303 if (filter->y._set) {
304 sp_repr_set_svg_double(repr, "y", filter->y.computed);
305 } else {
306 repr->setAttribute("y", NULL);
307 }
309 if (filter->width._set) {
310 sp_repr_set_svg_double(repr, "width", filter->width.computed);
311 } else {
312 repr->setAttribute("width", NULL);
313 }
315 if (filter->height._set) {
316 sp_repr_set_svg_double(repr, "height", filter->height.computed);
317 } else {
318 repr->setAttribute("height", NULL);
319 }
321 if (filter->filterRes.getNumber()>=0) {
322 gchar *tmp = filter->filterRes.getValueString();
323 repr->setAttribute("filterRes", tmp);
324 g_free(tmp);
325 } else {
326 repr->setAttribute("filterRes", NULL);
327 }
329 if (filter->href->getURI()) {
330 gchar *uri_string = filter->href->getURI()->toString();
331 repr->setAttribute("xlink:href", uri_string);
332 g_free(uri_string);
333 }
335 if (((SPObjectClass *) filter_parent_class)->write) {
336 ((SPObjectClass *) filter_parent_class)->write(object, repr, flags);
337 }
339 return repr;
340 }
343 /**
344 * Gets called when the filter is (re)attached to another filter.
345 */
346 static void
347 filter_ref_changed(SPObject *old_ref, SPObject *ref, SPFilter *filter)
348 {
349 if (old_ref) {
350 sp_signal_disconnect_by_data(old_ref, filter);
351 }
352 if ( SP_IS_FILTER(ref)
353 && ref != filter )
354 {
355 ref->connectModified(sigc::bind(sigc::ptr_fun(&filter_ref_modified), filter));
356 //g_signal_connect(G_OBJECT(ref), "modified", G_CALLBACK(filter_ref_modified), filter);
357 }
359 filter_ref_modified(ref, 0, filter);
360 }
362 static void
363 filter_ref_modified(SPObject *href, guint flags, SPFilter *filter)
364 {
365 SP_OBJECT(filter)->requestModified(SP_OBJECT_MODIFIED_FLAG);
366 }
369 void _enlarge_primitive_table(SPFilter * filter) {
370 SPFilterPrimitive **new_tbl = new SPFilterPrimitive*[filter->_primitive_table_size * 2];
371 for (int i = 0 ; i < filter->_primitive_count ; i++) {
372 new_tbl[i] = filter->_primitives[i];
373 }
374 filter->_primitive_table_size *= 2;
375 for (int i = filter->_primitive_count ; i < filter->_primitive_table_size ; i++) {
376 new_tbl[i] = NULL;
377 }
378 delete[] filter->_primitives;
379 filter->_primitives = new_tbl;
380 }
382 SPFilterPrimitive *add_primitive(SPFilter *filter, SPFilterPrimitive *primitive)
383 {
384 if (filter->_primitive_count >= filter->_primitive_table_size) {
385 _enlarge_primitive_table(filter);
386 }
387 filter->_primitives[filter->_primitive_count] = primitive;
388 filter->_primitive_count++;
389 return primitive;
390 }
392 /**
393 * Callback for child_added event.
394 */
395 static void
396 sp_filter_child_added(SPObject *object, Inkscape::XML::Node *child, Inkscape::XML::Node *ref)
397 {/*
398 SPFilter *f = SP_FILTER(object);
400 if (((SPObjectClass *) filter_parent_class)->child_added)
401 (* ((SPObjectClass *) filter_parent_class)->child_added)(object, child, ref);
403 object->requestModified(SP_OBJECT_MODIFIED_FLAG);
404 */
405 }
407 /**
408 * Callback for remove_child event.
409 */
410 static void
411 sp_filter_remove_child(SPObject *object, Inkscape::XML::Node *child)
412 {/*
413 SPFilter *f = SP_FILTER(object);
415 if (((SPObjectClass *) filter_parent_class)->remove_child)
416 (* ((SPObjectClass *) filter_parent_class)->remove_child)(object, child);
418 SPObject *ochild;
421 object->requestModified(SP_OBJECT_MODIFIED_FLAG);
422 */
423 }
426 /*
427 Local Variables:
428 mode:c++
429 c-file-style:"stroustrup"
430 c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
431 indent-tabs-mode:nil
432 fill-column:99
433 End:
434 */
435 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :