X-Git-Url: https://git.tokkee.org/?a=blobdiff_plain;f=src%2Fsp-filter.cpp;h=e075087d3af3d6bd84899348e6181678e8ea90aa;hb=80d34fe4a953d704430b44c6201a4fcbf455dfc6;hp=ef5d71483ee599e5d8c1e7d2815380ff83019bdf;hpb=7333a6d3d0e1b6b738726a859e5875d5d97b27d9;p=inkscape.git diff --git a/src/sp-filter.cpp b/src/sp-filter.cpp index ef5d71483..e075087d3 100644 --- a/src/sp-filter.cpp +++ b/src/sp-filter.cpp @@ -6,8 +6,9 @@ /* * Authors: * Hugo Rodrigues + * Niko Kiirala * - * Copyright (C) 2006 Hugo Rodrigues + * Copyright (C) 2006,2007 Authors * * Released under GNU GPL, read the file 'COPYING' for more information */ @@ -16,16 +17,26 @@ # include "config.h" #endif +#include +#include +using std::map; +using std::pair; + +#include + #include "attributes.h" #include "document.h" #include "sp-filter.h" #include "sp-filter-reference.h" #include "uri.h" #include "xml/repr.h" +#include +#include #define SP_MACROS_SILENT #include "macros.h" +#include "display/nr-filter.h" /* Filter base class */ @@ -40,7 +51,7 @@ static void sp_filter_child_added(SPObject *object, Inkscape::XML::Node *child, Inkscape::XML::Node *ref); static void sp_filter_remove_child(SPObject *object, Inkscape::XML::Node *child); -static Inkscape::XML::Node *sp_filter_write(SPObject *object, Inkscape::XML::Node *repr, guint flags); +static Inkscape::XML::Node *sp_filter_write(SPObject *object, Inkscape::XML::Document *doc, Inkscape::XML::Node *repr, guint flags); static void filter_ref_changed(SPObject *old_ref, SPObject *ref, SPFilter *filter); static void filter_ref_modified(SPObject *href, guint flags, SPFilter *filter); @@ -100,12 +111,16 @@ sp_filter_init(SPFilter *filter) filter->primitiveUnits = SP_FILTER_UNITS_OBJECTBOUNDINGBOX; filter->filterUnits_set = FALSE; filter->primitiveUnits_set = FALSE; - filter->_primitive_count=0; - - filter->_primitive_table_size = 1; - filter->_primitives = new SPFilterPrimitive*[1]; - filter->_primitives[0] = NULL; + filter->_renderer = NULL; + + filter->_image_name = new std::map; + filter->_image_name->clear(); + filter->_image_number_next = 0; + + filter->filterRes = NumberOptNumber(); + + new (&filter->modified_connection) sigc::connection(); } /** @@ -151,14 +166,15 @@ sp_filter_release(SPObject *object) //release href if (filter->href) { - if (filter->href->getObject()) { - sp_signal_disconnect_by_data(filter->href->getObject(), filter); - } + filter->modified_connection.disconnect(); filter->href->detach(); delete filter->href; filter->href = NULL; } + filter->modified_connection.~connection(); + delete filter->_image_name; + if (((SPObjectClass *) filter_parent_class)->release) ((SPObjectClass *) filter_parent_class)->release(object); } @@ -200,24 +216,25 @@ sp_filter_set(SPObject *object, unsigned int key, gchar const *value) } object->requestModified(SP_OBJECT_MODIFIED_FLAG); break; - case SP_ATTR_X: + case SP_ATTR_X: filter->x.readOrUnset(value); - object->requestModified(SP_OBJECT_MODIFIED_FLAG); + object->requestModified(SP_OBJECT_MODIFIED_FLAG); break; - case SP_ATTR_Y: - filter->y.readOrUnset(value); - object->requestModified(SP_OBJECT_MODIFIED_FLAG); + case SP_ATTR_Y: + filter->y.readOrUnset(value); + object->requestModified(SP_OBJECT_MODIFIED_FLAG); break; - case SP_ATTR_WIDTH: - filter->width.readOrUnset(value); - object->requestModified(SP_OBJECT_MODIFIED_FLAG); + case SP_ATTR_WIDTH: + filter->width.readOrUnset(value); + object->requestModified(SP_OBJECT_MODIFIED_FLAG); break; - case SP_ATTR_HEIGHT: - filter->height.readOrUnset(value); - object->requestModified(SP_OBJECT_MODIFIED_FLAG); + case SP_ATTR_HEIGHT: + filter->height.readOrUnset(value); + object->requestModified(SP_OBJECT_MODIFIED_FLAG); break; - case SP_ATTR_FILTERRES: - filter->filterRes.set(value); + case SP_ATTR_FILTERRES: + filter->filterRes.set(value); + object->requestModified(SP_OBJECT_MODIFIED_FLAG); break; case SP_ATTR_XLINK_HREF: if (value) { @@ -232,7 +249,7 @@ sp_filter_set(SPObject *object, unsigned int key, gchar const *value) } break; default: - // See if any parents need this value. + // See if any parents need this value. if (((SPObjectClass *) filter_parent_class)->set) { ((SPObjectClass *) filter_parent_class)->set(object, key, value); } @@ -264,12 +281,12 @@ sp_filter_update(SPObject *object, SPCtx *ctx, guint flags) * Writes its settings to an incoming repr object, if any. */ static Inkscape::XML::Node * -sp_filter_write(SPObject *object, Inkscape::XML::Node *repr, guint flags) +sp_filter_write(SPObject *object, Inkscape::XML::Document *doc, Inkscape::XML::Node *repr, guint flags) { SPFilter *filter = SP_FILTER(object); if (!repr) { - repr = SP_OBJECT_REPR(object)->duplicate(repr->document()); + repr = SP_OBJECT_REPR(object)->duplicate(doc); } if ((flags & SP_OBJECT_WRITE_ALL) || filter->filterUnits_set) { @@ -333,7 +350,7 @@ sp_filter_write(SPObject *object, Inkscape::XML::Node *repr, guint flags) } if (((SPObjectClass *) filter_parent_class)->write) { - ((SPObjectClass *) filter_parent_class)->write(object, repr, flags); + ((SPObjectClass *) filter_parent_class)->write(object, doc, repr, flags); } return repr; @@ -347,61 +364,36 @@ static void filter_ref_changed(SPObject *old_ref, SPObject *ref, SPFilter *filter) { if (old_ref) { - sp_signal_disconnect_by_data(old_ref, filter); + filter->modified_connection.disconnect(); } if ( SP_IS_FILTER(ref) && ref != filter ) { - ref->connectModified(sigc::bind(sigc::ptr_fun(&filter_ref_modified), filter)); - //g_signal_connect(G_OBJECT(ref), "modified", G_CALLBACK(filter_ref_modified), filter); + filter->modified_connection = + ref->connectModified(sigc::bind(sigc::ptr_fun(&filter_ref_modified), filter)); } filter_ref_modified(ref, 0, filter); } static void -filter_ref_modified(SPObject *href, guint flags, SPFilter *filter) +filter_ref_modified(SPObject */*href*/, guint /*flags*/, SPFilter *filter) { SP_OBJECT(filter)->requestModified(SP_OBJECT_MODIFIED_FLAG); } - -void _enlarge_primitive_table(SPFilter * filter) { - SPFilterPrimitive **new_tbl = new SPFilterPrimitive*[filter->_primitive_table_size * 2]; - for (int i = 0 ; i < filter->_primitive_count ; i++) { - new_tbl[i] = filter->_primitives[i]; - } - filter->_primitive_table_size *= 2; - for (int i = filter->_primitive_count ; i < filter->_primitive_table_size ; i++) { - new_tbl[i] = NULL; - } - delete[] filter->_primitives; - filter->_primitives = new_tbl; -} - -SPFilterPrimitive *add_primitive(SPFilter *filter, SPFilterPrimitive *primitive) -{ - if (filter->_primitive_count >= filter->_primitive_table_size) { - _enlarge_primitive_table(filter); - } - filter->_primitives[filter->_primitive_count] = primitive; - filter->_primitive_count++; - return primitive; -} - /** * Callback for child_added event. */ static void sp_filter_child_added(SPObject *object, Inkscape::XML::Node *child, Inkscape::XML::Node *ref) -{/* - SPFilter *f = SP_FILTER(object); +{ + //SPFilter *f = SP_FILTER(object); if (((SPObjectClass *) filter_parent_class)->child_added) (* ((SPObjectClass *) filter_parent_class)->child_added)(object, child, ref); object->requestModified(SP_OBJECT_MODIFIED_FLAG); - */ } /** @@ -409,17 +401,109 @@ sp_filter_child_added(SPObject *object, Inkscape::XML::Node *child, Inkscape::XM */ static void sp_filter_remove_child(SPObject *object, Inkscape::XML::Node *child) -{/* - SPFilter *f = SP_FILTER(object); +{ +// SPFilter *f = SP_FILTER(object); if (((SPObjectClass *) filter_parent_class)->remove_child) (* ((SPObjectClass *) filter_parent_class)->remove_child)(object, child); - SPObject *ochild; - - object->requestModified(SP_OBJECT_MODIFIED_FLAG); - */ +} + +void sp_filter_build_renderer(SPFilter *sp_filter, NR::Filter *nr_filter) +{ + g_assert(sp_filter != NULL); + g_assert(nr_filter != NULL); + + sp_filter->_renderer = nr_filter; + + nr_filter->set_x(sp_filter->x); + nr_filter->set_y(sp_filter->y); + nr_filter->set_width(sp_filter->width); + nr_filter->set_height(sp_filter->height); + + if (sp_filter->filterRes.getNumber() >= 0) { + if (sp_filter->filterRes.getOptNumber() >= 0) { + nr_filter->set_resolution(sp_filter->filterRes.getNumber(), + sp_filter->filterRes.getOptNumber()); + } else { + nr_filter->set_resolution(sp_filter->filterRes.getNumber()); + } + } + + nr_filter->clear_primitives(); + SPObject *primitive_obj = sp_filter->children; + while (primitive_obj) { + if (SP_IS_FILTER_PRIMITIVE(primitive_obj)) { + SPFilterPrimitive *primitive = SP_FILTER_PRIMITIVE(primitive_obj); + g_assert(primitive != NULL); + if (((SPFilterPrimitiveClass*) G_OBJECT_GET_CLASS(primitive))->build_renderer) { + ((SPFilterPrimitiveClass *) G_OBJECT_GET_CLASS(primitive))->build_renderer(primitive, nr_filter); + } else { + g_warning("Cannot build filter renderer: missing builder"); + } + } + primitive_obj = primitive_obj->next; + } +} + +int sp_filter_primitive_count(SPFilter *filter) { + g_assert(filter != NULL); + int count = 0; + + SPObject *primitive_obj = filter->children; + while (primitive_obj) { + if (SP_IS_FILTER_PRIMITIVE(primitive_obj)) count++; + primitive_obj = primitive_obj->next; + } + return count; +} + +int sp_filter_get_image_name(SPFilter *filter, gchar const *name) { + gchar *name_copy = strdup(name); + map::iterator result = filter->_image_name->find(name_copy); + free(name_copy); + if (result == filter->_image_name->end()) return -1; + else return (*result).second; +} + +int sp_filter_set_image_name(SPFilter *filter, gchar const *name) { + int value = filter->_image_number_next; + filter->_image_number_next++; + gchar *name_copy = strdup(name); + pair new_pair(name_copy, value); + pair::iterator,bool> ret = filter->_image_name->insert(new_pair); + if (ret.second == false) { + return (*ret.first).second; + } + return value; +} + +Glib::ustring sp_filter_get_new_result_name(SPFilter *filter) { + g_assert(filter != NULL); + int largest = 0; + + SPObject *primitive_obj = filter->children; + while (primitive_obj) { + if (SP_IS_FILTER_PRIMITIVE(primitive_obj)) { + Inkscape::XML::Node *repr = SP_OBJECT_REPR(primitive_obj); + char const *result = repr->attribute("result"); + int index; + if (result && sscanf(result, "result%d", &index) == 1) { + if (index > largest) { + largest = index; + } + } + } + primitive_obj = primitive_obj->next; + } + + return "result" + Glib::Ascii::dtostr(largest + 1); +} + +bool ltstr::operator()(const char* s1, const char* s2) const +{ + return strcmp(s1, s2) < 0; }