index 5169ff22f5d6345239138627e044244fecb1917c..6acba000ce5f9376dc7802190dfcaf37f68a1959 100644 (file)
/*
* Inkscape::LivePathEffect
*
-* Copyright (C) Johan Engelen 2007 <j.b.c.engelen@utwente.nl>
+* Copyright (C) Johan Engelen 2007-2008 <j.b.c.engelen@utwente.nl>
*
* Released under GNU GPL, read the file 'COPYING' for more information
*/
-#include "display/display-forward.h"
#include <map>
#include <glibmm/ustring.h>
-#include <2geom/path.h>
+#include <2geom/forward.h>
#include "ui/widget/registry.h"
-#include "util/enums.h"
+#include "parameter/bool.h"
+#include "effect-enum.h"
#define LPE_CONVERSION_TOLERANCE 0.01 // FIXME: find good solution for this.
-//#define LPE_ENABLE_TEST_EFFECTS
-
-struct SPShape;
struct SPDocument;
-class NArtBpath;
+struct SPDesktop;
+struct SPItem;
+class SPNodeContext;
struct LivePathEffectObject;
+class SPLPEItem;
+class KnotHolder;
+class KnotHolderEntity;
+class SPPath;
+struct SPCurve;
namespace Gtk {
class Widget;
class Node;
}
+namespace NodePath {
+ class Path ;
+}
+
namespace LivePathEffect {
-enum EffectType {
- SKELETAL_STROKES = 0,
-#ifdef LPE_ENABLE_TEST_EFFECTS
- SLANT,
- DOEFFECTSTACK_TEST,
-#endif
- GEARS,
- CURVE_STITCH,
- INVALID_LPE // This must be last
+enum LPEPathFlashType {
+ SUPPRESS_FLASH,
+// PERMANENT_FLASH,
+ DEFAULT
};
-extern const Util::EnumData<EffectType> LPETypeData[INVALID_LPE];
-extern const Util::EnumDataConverter<EffectType> LPETypeConverter;
-
-class Parameter;
-
class Effect {
public:
+ static Effect* New(EffectType lpenr, LivePathEffectObject *lpeobj);
+ static void createAndApply(const char* name, SPDocument *doc, SPItem *item);
+ static void createAndApply(EffectType type, SPDocument *doc, SPItem *item);
+
virtual ~Effect();
- Glib::ustring getName();
+ EffectType effectType ();
+
+ virtual void doOnApply (SPLPEItem *lpeitem);
+ virtual void doBeforeEffect (SPLPEItem *lpeitem);
+
+ void writeParamsToSVG();
+
+ virtual void acceptParamPath (SPPath *param_path);
+ static int acceptsNumClicks(EffectType type);
+ int acceptsNumClicks() { return acceptsNumClicks(effectType()); }
+ void doAcceptPathPreparations(SPLPEItem *lpeitem);
+
+ /*
+ * isReady() indicates whether all preparations which are necessary to apply the LPE are done,
+ * e.g., waiting for a parameter path either before the effect is created or when it needs a
+ * path as argument. This is set in sp_lpe_item_add_path_effect().
+ */
+ inline bool isReady() { return is_ready; }
+ inline void setReady(bool ready = true) { is_ready = ready; }
virtual void doEffect (SPCurve * curve);
- static Effect* New(EffectType lpenr, LivePathEffectObject *lpeobj);
+ virtual Gtk::Widget * newWidget(Gtk::Tooltips * tooltips);
+
+ /**
+ * Sets all parameters to their default values and writes them to SVG.
+ */
+ virtual void resetDefaults(SPItem * item);
- virtual Gtk::Widget * getWidget();
+ /// /todo: is this method really necessary? it causes UI inconsistensies... (johan)
+ virtual void transform_multiply(Geom::Matrix const& postmul, bool set);
- Inkscape::XML::Node * getRepr();
- SPDocument * getSPDoc();
+ // /TODO: providesKnotholder() is currently used as an indicator of whether a nodepath is
+ // created for an item or not. When we allow both at the same time, this needs rethinking!
+ bool providesKnotholder();
+ // /TODO: in view of providesOwnFlashPaths() below, this is somewhat redundant
+ // (but spiro lpe still needs it!)
+ virtual LPEPathFlashType pathFlashType() { return DEFAULT; }
+ void addHandles(KnotHolder *knotholder, SPDesktop *desktop, SPItem *item);
+ std::vector<Geom::PathVector> getHelperPaths(SPLPEItem *lpeitem);
+
+ inline bool providesOwnFlashPaths() {
+ return provides_own_flash_paths || show_orig_path;
+ }
+ inline bool showOrigPath() { return show_orig_path; }
+
+ Glib::ustring getName();
+ Inkscape::XML::Node * getRepr();
+ SPDocument * getSPDoc();
+ LivePathEffectObject * getLPEObj() {return lpeobj;};
+ Parameter * getParameter(const char * key);
void readallParameters(Inkscape::XML::Node * repr);
- void setParameter(Inkscape::XML::Node * repr, const gchar * key, const gchar * old_value, const gchar * new_value);
+ void setParameter(const gchar * key, const gchar * new_value);
+
+ inline bool isVisible() { return is_visible; }
+
+ void editNextParamOncanvas(SPItem * item, SPDesktop * desktop);
protected:
Effect(LivePathEffectObject *lpeobject);
- // provide a set of doEffect functions so the developer has a choice
+ // provide a set of doEffect functions so the developer has a choice
// of what kind of input/output parameters he desires.
- // the order in which they appear is the order in which they are
+ // the order in which they appear is the order in which they are
// called by this base class. (i.e. doEffect(SPCurve * curve) defaults to calling
// doEffect(std::vector<Geom::Path> )
- virtual NArtBpath *
- doEffect (NArtBpath * path_in);
- virtual std::vector<Geom::Path>
- doEffect (std::vector<Geom::Path> & path_in);
- virtual Geom::Piecewise<Geom::D2<Geom::SBasis> >
- doEffect (Geom::Piecewise<Geom::D2<Geom::SBasis> > & pwd2_in);
+ virtual std::vector<Geom::Path>
+ doEffect_path (std::vector<Geom::Path> const & path_in);
+ virtual Geom::Piecewise<Geom::D2<Geom::SBasis> >
+ doEffect_pwd2 (Geom::Piecewise<Geom::D2<Geom::SBasis> > const & pwd2_in);
void registerParameter(Parameter * param);
+ void registerKnotHolderHandle(KnotHolderEntity* entity, const char* descr);
+ Parameter * getNextOncanvasEditableParam();
+
+ void addKnotHolderEntities(KnotHolder *knotholder, SPDesktop *desktop, SPItem *item);
+
+ //virtual std::vector<Geom::PathVector> getCanvasIndicators(SPLPEItem *lpeitem);
+ virtual void addCanvasIndicators(SPLPEItem *lpeitem, std::vector<Geom::PathVector> &hp_vec);
+
- typedef std::map<Glib::ustring, Parameter *> param_map_type;
- param_map_type param_map;
+ std::vector<Parameter *> param_vector;
+ std::vector<std::pair<KnotHolderEntity*, const char*> > kh_entity_vector;
+ int oncanvasedit_it;
+ BoolParam is_visible;
- Inkscape::UI::Widget::Registry wr;
- Gtk::VBox * vbox;
- Gtk::Tooltips * tooltips;
+ bool show_orig_path; // set this to true in derived effects to automatically have the original
+ // path displayed as helperpath
+
+ Inkscape::UI::Widget::Registry wr;
LivePathEffectObject *lpeobj;
+ // this boolean defaults to false, it concatenates the input path to one pwd2,
+ // instead of normally 'splitting' the path into continuous pwd2 paths.
+ bool concatenate_before_pwd2;
+
private:
+ bool provides_own_flash_paths; // if true, the standard flash path is suppressed
+
+ bool is_ready;
+
Effect(const Effect&);
Effect& operator=(const Effect&);
};
-
} //namespace LivePathEffect
} //namespace Inkscape
#endif
+
+/*
+ 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 :