From 55d43e4e27e0ba58a47fad70957dfa989aa173ad Mon Sep 17 00:00:00 2001 From: "Johan B. C. Engelen" Date: Tue, 14 Aug 2007 20:54:48 +0000 Subject: Commit LivePathEffect branch to trunk! (disabled extension/internal/bitmap/*.* in build.xml to fix compilation) (bzr r3472) --- src/live_effects/effect.cpp | 232 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 232 insertions(+) create mode 100644 src/live_effects/effect.cpp (limited to 'src/live_effects/effect.cpp') diff --git a/src/live_effects/effect.cpp b/src/live_effects/effect.cpp new file mode 100644 index 000000000..a0a8f3db9 --- /dev/null +++ b/src/live_effects/effect.cpp @@ -0,0 +1,232 @@ +#define INKSCAPE_LIVEPATHEFFECT_CPP + +/* + * Copyright (C) Johan Engelen 2007 + * + * Released under GNU GPL, read the file 'COPYING' for more information + */ + +#include "display/display-forward.h" +#include "xml/node-event-vector.h" +#include "sp-object.h" +#include "attributes.h" + +#include "desktop.h" + +#include "document.h" +#include + +#include "live_effects/effect.h" +#include "live_effects/lpeobject.h" +#include "live_effects/parameter/parameter.h" +#include +#include "live_effects/n-art-bpath-2geom.h" +#include "display/curve.h" +#include <2geom/sbasis-to-bezier.h> +#include + +// include effects: +#include "live_effects/lpe-skeletalstrokes.h" +#include "live_effects/lpe-slant.h" +#include "live_effects/lpe-test-doEffect-stack.h" +#include "live_effects/lpe-gears.h" + +namespace Inkscape { + +namespace LivePathEffect { + +const Util::EnumData LPETypeData[ENDTYPE_LPE] = { + {INVALID_LPE, _("Invalid effect"), "invalid"}, + {SKELETAL_STROKES, _("Skeletal Strokes"), "skeletal"}, + {SLANT, _("Slant"), "slant"}, + {DOEFFECTSTACK_TEST, _("doEffect stack test"), "doeffectstacktest"}, + {GEARS, _("Gears"), "gears"} +}; +const Util::EnumDataConverter LPETypeConverter(LPETypeData, ENDTYPE_LPE); + +Effect* +Effect::New(EffectType lpenr, LivePathEffectObject *lpeobj) +{ + switch (lpenr) { + case INVALID_LPE: + g_warning("LivePathEffect::Effect::New called with invalid patheffect type"); + return NULL; + case SKELETAL_STROKES: + return (Effect*) new LPESkeletalStrokes(lpeobj); + case SLANT: + return (Effect*) new LPESlant(lpeobj); + case DOEFFECTSTACK_TEST: + return (Effect*) new LPEdoEffectStackTest(lpeobj); + case GEARS: + return (Effect*) new LPEGears(lpeobj); + case ENDTYPE_LPE: + return NULL; + } + + return NULL; +} + +Effect::Effect(LivePathEffectObject *lpeobject) +{ + vbox = NULL; + tooltips = NULL; + lpeobj = lpeobject; +} + +Effect::~Effect() +{ + if (tooltips) { + delete tooltips; + } +} + +Glib::ustring +Effect::getName() +{ + return Glib::ustring( LPETypeConverter.get_label(lpeobj->effecttype) ); +} + +/* + * Here be the doEffect function chain: + */ +void +Effect::doEffect (SPCurve * curve) +{ + NArtBpath *new_bpath = doEffect(SP_CURVE_BPATH(curve)); + + if (new_bpath) { // FIXME, add function to SPCurve to change bpath? or a copy function? + if (curve->_bpath) { + g_free(curve->_bpath); //delete old bpath + } + curve->_bpath = new_bpath; + } +} + +NArtBpath * +Effect::doEffect (NArtBpath * path_in) +{ + std::vector orig_pathv = BPath_to_2GeomPath(path_in); + + std::vector result_pathv = doEffect(orig_pathv); + + NArtBpath *new_bpath = BPath_from_2GeomPath(result_pathv); + + return new_bpath; +} + +std::vector +Effect::doEffect (std::vector & path_in) +{ + Geom::Piecewise > pwd2_in; + // FIXME: find standard function to convert std::vector ==> Piecewise< D2 > + for (unsigned int i=0; i < path_in.size(); i++) { + pwd2_in.concat( path_in[i].toPwSb() ); + } + + Geom::Piecewise > pwd2_out = doEffect(pwd2_in); + + std::vector path_out = Geom::path_from_piecewise( pwd2_out, LPE_CONVERSION_TOLERANCE); + + return path_out; +} + +Geom::Piecewise > +Effect::doEffect (Geom::Piecewise > & pwd2_in) +{ + g_warning("Effect has no doEffect implementation"); + return pwd2_in; +} + +void +Effect::readallParameters(Inkscape::XML::Node * repr) +{ + param_map_type::iterator it = param_map.begin(); + while (it != param_map.end()) { + const gchar * key = (*it).first.c_str(); + const gchar * value = repr->attribute(key); + if(value) { + setParameter(repr, key, NULL, value); + } + it++; + } +} + +void +Effect::setParameter(Inkscape::XML::Node * repr, const gchar * key, const gchar * old_value, const gchar * new_value) +{ + Glib::ustring stringkey(key); + + param_map_type::iterator it = param_map.find(stringkey); + if (it != param_map.end()) { + bool accepted = it->second->param_readSVGValue(new_value); + /* think: can this backfire and create infinite loop when started with unacceptable old_value? + if (!accepted) { // change was not accepted, so change it back. + repr->setAttribute(key, old_value); + } */ + } +} + +void +Effect::registerParameter(Parameter * param) +{ + param_map[param->param_key] = param; // inserts or updates +} + +Gtk::Widget * +Effect::getWidget() +{ + if (!vbox) { + vbox = Gtk::manage( new Gtk::VBox() ); // use manage here, because after deletion of Effect object, others might still be pointing to this widget. + //if (!tooltips) + tooltips = new Gtk::Tooltips(); + + vbox->set_border_width(5); + + param_map_type::iterator it = param_map.begin(); + while (it != param_map.end()) { + Parameter * param = it->second; + Gtk::Widget * widg = param->param_getWidget(); + Glib::ustring * tip = param->param_getTooltip(); + if (widg) { + vbox->pack_start(*widg, true, true, 2); + if (tip != NULL) { + tooltips->set_tip(*widg, *tip); + } + } + + it++; + } + } + + return dynamic_cast(vbox); +} + + +Inkscape::XML::Node * +Effect::getRepr() +{ + return SP_OBJECT_REPR(lpeobj); +} + +SPDocument * +Effect::getSPDoc() +{ + if (SP_OBJECT_DOCUMENT(lpeobj) == NULL) g_message("oh crap"); + return SP_OBJECT_DOCUMENT(lpeobj); +} + + +}; /* namespace LivePathEffect */ + +}; /* namespace Inkscape */ + +/* + Local Variables: + mode:c++ + c-file-style:"stroustrup" + c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +)) + indent-tabs-mode:nil + fill-column:99 + End: +*/ +// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4 : -- cgit v1.2.3