set_link(i, ValueNode_Const::create(seed));
}
}
+
+LinkableValueNode::Vocab
+ValueNode_Random::get_param_vocab()const
+{
+ LinkableValueNode::Vocab ret;
+
+ ret.push_back(ParamDesc(ValueBase(),"link")
+ .set_local_name(_("Link"))
+ .set_description(_("The value node source that provides the central value"))
+ );
+
+ ret.push_back(ParamDesc(ValueBase(),"radius")
+ .set_local_name(_("Radius"))
+ .set_description(_("The value of the maximum random difference"))
+ );
+
+ ret.push_back(ParamDesc(ValueBase(),"seed")
+ .set_local_name(_("Seed"))
+ .set_description(_("Seeds the random number generator"))
+ );
+
+ ret.push_back(ParamDesc(ValueBase(),"speed")
+ .set_local_name(_("Speed"))
+ .set_description(_("Defines how often a new random value is chosen (in choices per second) "))
+ );
+
+ ret.push_back(ParamDesc(ValueBase(),"smooth")
+ .set_local_name(_("Interpolation"))
+ .set_description(_("Determines how the value is interpolated from one random choice to the next"))
+ .set_hint("enum")
+ .add_enum_value(RandomNoise::SMOOTH_DEFAULT,"default",_("No interpolation"))
+ .add_enum_value(RandomNoise::SMOOTH_LINEAR,"linear",_("Linear"))
+ .add_enum_value(RandomNoise::SMOOTH_COSINE,"cosine",_("Cosine"))
+ .add_enum_value(RandomNoise::SMOOTH_SPLINE,"spline",_("Spline"))
+ .add_enum_value(RandomNoise::SMOOTH_CUBIC,"cubic",_("Cubic"))
+ );
+
+
+ ret.push_back(ParamDesc(ValueBase(),"loop")
+ .set_local_name(_("Loop Time"))
+ .set_description(_("Makes the random value repeat after the given time"))
+ );
+ return ret;
+}
using synfig::LinkableValueNode::set_link_vfunc;
static bool check_type(ValueBase::Type type);
static ValueNode_Random* create(const ValueBase &x);
+ virtual Vocab get_param_vocab()const;
}; // END of class ValueNode_Random
}; // END of namespace synfig
#include "valuenode.h"
#include "general.h"
#include "canvas.h"
-#include "paramdesc.h"
#include "releases.h"
#include "valuenode_const.h"
return description;
}
+
+/*
+int
+LinkableValueNode::link_count()const
+{
+ Vocab ret(get_param_vocab());
+ return ret.size();
+}
+*/
#include <sigc++/signal.h>
#include "guid.h"
#include <ETL/angle>
+#include "paramdesc.h"
#include "node.h"
class Canvas;
class LinkableValueNode;
class Layer;
+class ParamVocab;
/*! \class ValueNode
** \brief Base class for all Value Nodes
*/
typedef std::map<String,BookEntry> Book;
+ typedef ParamVocab Vocab;
+
static Book& book();
//! Creates a Linkable Value Node based on the name and the returned
//! Return a full description of the linked ValueNode given by the index
String get_description(int index = -1, bool show_exported_name = true)const;
+ //! Gets the parameter vocabulary for linkable value nodes
+ virtual Vocab get_param_vocab()const=0;
+
protected:
//! Sets the type of the ValueNode
void set_type(ValueBase::Type t) { ValueNode::set_type(t); }
|| type==ValueBase::TYPE_TIME
|| type==ValueBase::TYPE_VECTOR;
}
+
+LinkableValueNode::Vocab
+ValueNode_Add::get_param_vocab() const
+{
+ LinkableValueNode::Vocab ret;
+
+ ret.push_back(ParamDesc(ValueBase(),"lhs")
+ .set_local_name(_("LHS"))
+ .set_description(_("Left Hand Side of the add"))
+ );
+
+ ret.push_back(ParamDesc(ValueBase(),"rhs")
+ .set_local_name(_("RHS"))
+ .set_description(_("Right Hand Side of the add"))
+ );
+
+ ret.push_back(ParamDesc(ValueBase(),"scalar")
+ .set_local_name(_("Scalar"))
+ .set_description(_("Value that multiplies the add"))
+ );
+
+ return ret;
+}
virtual String get_name()const;
virtual String get_local_name()const;
static bool check_type(ValueBase::Type type);
+ virtual Vocab get_param_vocab()const;
}; // END of class ValueNode_Add
}; // END of namespace synfig
{
return type==ValueBase::TYPE_BOOL;
}
+
+LinkableValueNode::Vocab
+ValueNode_And::get_param_vocab() const
+{
+ LinkableValueNode::Vocab ret;
+
+ ret.push_back(ParamDesc(ValueBase(),"link1")
+ .set_local_name(_("Link1"))
+ .set_description(_("First operand of the AND operation"))
+ );
+
+ ret.push_back(ParamDesc(ValueBase(),"link2")
+ .set_local_name(_("Link2"))
+ .set_description(_("Second operand of the AND operation"))
+ );
+
+ return ret;
+}
using synfig::LinkableValueNode::set_link_vfunc;
static bool check_type(ValueBase::Type type);
static ValueNode_And* create(const ValueBase &x);
+ virtual LinkableValueNode::Vocab get_param_vocab()const;
}; // END of class ValueNode_And
}; // END of namespace synfig
return
type==ValueBase::TYPE_STRING;
}
+
+LinkableValueNode::Vocab
+ValueNode_AngleString::get_param_vocab()const
+{
+ LinkableValueNode::Vocab ret;
+
+ ret.push_back(ParamDesc(ValueBase(),"angle")
+ .set_local_name(_("Angle"))
+ .set_description(_("Value to convert to string"))
+ );
+
+ ret.push_back(ParamDesc(ValueBase(),"width")
+ .set_local_name(_("Width"))
+ .set_description(_("Width of the string"))
+ );
+
+ ret.push_back(ParamDesc(ValueBase(),"precision")
+ .set_local_name(_("Precision"))
+ .set_description(_("Number of decimal places"))
+ );
+
+ ret.push_back(ParamDesc(ValueBase(),"zero_pad")
+ .set_local_name(_("Zero Padded"))
+ .set_description(_("When checked, the string is left filled with zeros to match the width"))
+ );
+
+ return ret;
+}
using synfig::LinkableValueNode::set_link_vfunc;
static bool check_type(ValueBase::Type type);
static ValueNode_AngleString* create(const ValueBase &x);
+ virtual Vocab get_param_vocab()const;
}; // END of class ValueNode_AngleString
}; // END of namespace synfig
throw Exception::BadLinkName(name);
}
+
+LinkableValueNode::Vocab
+ValueNode_Atan2::get_param_vocab()const
+{
+ LinkableValueNode::Vocab ret;
+
+ ret.push_back(ParamDesc(ValueBase(),"x")
+ .set_local_name(_("X"))
+ .set_description(_("Cosine of the angle"))
+ );
+
+ ret.push_back(ParamDesc(ValueBase(),"y")
+ .set_local_name(_("Y"))
+ .set_description(_("Sine of the angle"))
+ );
+
+ return ret;
+}
using synfig::LinkableValueNode::set_link_vfunc;
static bool check_type(ValueBase::Type type);
static ValueNode_Atan2* create(const ValueBase &x);
+ virtual Vocab get_param_vocab()const;
}; // END of class ValueNode_Atan2
}; // END of namespace synfig
{
return type==ValueBase::TYPE_LIST;
}
+
+LinkableValueNode::Vocab
+ValueNode_BLine::get_param_vocab()const
+{
+ LinkableValueNode::Vocab ret;
+ for(unsigned int i=0; i<list.size();i++)
+ {
+ ret.push_back(ParamDesc(ValueBase(),strprintf("item%04d",i))
+ .set_local_name(etl::strprintf(_("Vertex %03d"),i+1))
+ );
+ }
+
+ return ret;
+}
//using synfig::LinkableValueNode::set_link_vfunc;
static bool check_type(ValueBase::Type type);
static ValueNode_BLine* create(const ValueBase &x=ValueBase::TYPE_LIST);
+ virtual Vocab get_param_vocab()const;
}; // END of class ValueNode_BLine
typedef ValueNode_BLine::ListEntry::ActivepointList ActivepointList;
type==ValueBase::TYPE_REAL ||
type==ValueBase::TYPE_VECTOR);
}
+
+LinkableValueNode::Vocab
+ValueNode_BLineCalcTangent::get_param_vocab()const
+{
+ LinkableValueNode::Vocab ret;
+
+ ret.push_back(ParamDesc(ValueBase(),"bline")
+ .set_local_name(_("BLine"))
+ .set_description(_("The BLine where the tangent is linked to"))
+ );
+
+ ret.push_back(ParamDesc(ValueBase(),"loop")
+ .set_local_name(_("Loop"))
+ .set_description(_("When checked, the amount would loop"))
+ );
+
+ ret.push_back(ParamDesc(ValueBase(),"amount")
+ .set_local_name(_("Amount"))
+ .set_description(_("The position of the linked tangent on the BLine (0,1]"))
+ );
+
+ ret.push_back(ParamDesc(ValueBase(),"offset")
+ .set_local_name(_("Offset"))
+ .set_description(_("Angle offset of the tangent"))
+ );
+
+ ret.push_back(ParamDesc(ValueBase(),"scale")
+ .set_local_name(_("Scale"))
+ .set_description(_("Scale of the tangent"))
+ );
+
+ ret.push_back(ParamDesc(ValueBase(),"fixed_length")
+ .set_local_name(_("Fixed Length"))
+ .set_description(_("When checked, the tangent's length is fixed"))
+ );
+ return ret;
+}
using synfig::LinkableValueNode::set_link_vfunc;
static bool check_type(ValueBase::Type type);
static ValueNode_BLineCalcTangent* create(const ValueBase &x=ValueBase::TYPE_VECTOR);
+ virtual Vocab get_param_vocab()const;
}; // END of class ValueNode_BLineCalcTangent
}; // END of namespace synfig
{
return type==ValueBase::TYPE_VECTOR;
}
+
+LinkableValueNode::Vocab
+ValueNode_BLineCalcVertex::get_param_vocab()const
+{
+ LinkableValueNode::Vocab ret;
+
+ ret.push_back(ParamDesc(ValueBase(),"bline")
+ .set_local_name(_("BLine"))
+ .set_description(_("The BLine where the vertex is linked to"))
+ );
+
+ ret.push_back(ParamDesc(ValueBase(),"loop")
+ .set_local_name(_("Loop"))
+ .set_description(_("When checked, the amount would loop"))
+ );
+
+ ret.push_back(ParamDesc(ValueBase(),"amount")
+ .set_local_name(_("Amount"))
+ .set_description(_("The position of the linked vertex on the BLine (0,1]"))
+ );
+
+ return ret;
+}
using synfig::LinkableValueNode::set_link_vfunc;
static bool check_type(ValueBase::Type type);
static ValueNode_BLineCalcVertex* create(const ValueBase &x=ValueBase::TYPE_VECTOR);
+ virtual Vocab get_param_vocab()const;
}; // END of class ValueNode_BLineCalcVertex
}; // END of namespace synfig
{
return type==ValueBase::TYPE_REAL;
}
+
+LinkableValueNode::Vocab
+ValueNode_BLineCalcWidth::get_param_vocab()const
+{
+ LinkableValueNode::Vocab ret;
+
+ ret.push_back(ParamDesc(ValueBase(),"bline")
+ .set_local_name(_("BLine"))
+ .set_description(_("The BLine where the width is linked to"))
+ );
+
+ ret.push_back(ParamDesc(ValueBase(),"loop")
+ .set_local_name(_("Loop"))
+ .set_description(_("When checked, the amount would loop"))
+ );
+
+ ret.push_back(ParamDesc(ValueBase(),"amount")
+ .set_local_name(_("Amount"))
+ .set_description(_("The position of the linked width on the BLine (0,1]"))
+ );
+
+ ret.push_back(ParamDesc(ValueBase(),"scale")
+ .set_local_name(_("Scale"))
+ .set_description(_("Scale of the width"))
+ );
+
+ return ret;
+}
+
using synfig::LinkableValueNode::set_link_vfunc;
static bool check_type(ValueBase::Type type);
static ValueNode_BLineCalcWidth* create(const ValueBase &x=ValueBase::TYPE_REAL);
+ virtual Vocab get_param_vocab()const;
}; // END of class ValueNode_BLineCalcWidth
}; // END of namespace synfig
{
return (type==ValueBase::TYPE_BLINEPOINT);
}
+
+LinkableValueNode::Vocab
+ValueNode_BLineRevTangent::get_param_vocab()const
+{
+ LinkableValueNode::Vocab ret;
+
+ ret.push_back(ParamDesc(ValueBase(),"reference")
+ .set_local_name(_("Reference"))
+ .set_description(_("The referenced tangent to reverse"))
+ );
+
+ ret.push_back(ParamDesc(ValueBase(),"reverse")
+ .set_local_name(_("Reverse"))
+ .set_description(_("When checked, the reference is reversed"))
+ );
+
+ return ret;
+}
using synfig::LinkableValueNode::set_link_vfunc;
static bool check_type(ValueBase::Type type);
static ValueNode_BLineRevTangent* create(const ValueBase &x=ValueBase::TYPE_VECTOR);
+ virtual Vocab get_param_vocab()const;
}; // END of class ValueNode_BLineRevTangent
}; // END of namespace synfig
{
return type==ValueBase::TYPE_BOOL;
}
+
+LinkableValueNode::Vocab
+ValueNode_Compare::get_param_vocab()const
+{
+ LinkableValueNode::Vocab ret;
+
+ ret.push_back(ParamDesc(ValueBase(),"lhs")
+ .set_local_name(_("LHS"))
+ .set_description(_("The left side of the comparison"))
+ );
+
+ ret.push_back(ParamDesc(ValueBase(),"rhs")
+ .set_local_name(_("RHS"))
+ .set_description(_("The right side of the comparison"))
+ );
+
+ ret.push_back(ParamDesc(ValueBase(),"greater")
+ .set_local_name(_("Greater"))
+ .set_description(_("When checked, returns true if LHS > RHS"))
+ );
+
+ ret.push_back(ParamDesc(ValueBase(),"equal")
+ .set_local_name(_("Equal"))
+ .set_description(_("When checked, returns true if LHS = RHS"))
+ );
+
+ ret.push_back(ParamDesc(ValueBase(),"less")
+ .set_local_name(_("Less"))
+ .set_description(_("When checked, returns true if LHS < RHS"))
+ );
+
+ return ret;
+}
using synfig::LinkableValueNode::set_link_vfunc;
static bool check_type(ValueBase::Type type);
static ValueNode_Compare* create(const ValueBase &x);
+ virtual Vocab get_param_vocab()const;
}; // END of class ValueNode_Compare
}; // END of namespace synfig
type==ValueBase::TYPE_COLOR ||
type==ValueBase::TYPE_BLINEPOINT;
}
+
+LinkableValueNode::Vocab
+ValueNode_Composite::get_param_vocab()const
+{
+ LinkableValueNode::Vocab ret;
+
+ switch(get_type())
+ {
+ case ValueBase::TYPE_COLOR:
+ ret.push_back(ParamDesc(ValueBase(),"red")
+ .set_local_name(_("Red"))
+ .set_description(_("The red component of the color"))
+ );
+ ret.push_back(ParamDesc(ValueBase(),"green")
+ .set_local_name(_("Green"))
+ .set_description(_("The green component of the color"))
+ );
+ ret.push_back(ParamDesc(ValueBase(),"blue")
+ .set_local_name(_("Blue"))
+ .set_description(_("The blue component of the color"))
+ );
+ ret.push_back(ParamDesc(ValueBase(),"alpha")
+ .set_local_name(_("Alpha"))
+ .set_description(_("The alpha of the color"))
+ );
+ return ret;
+ case ValueBase::TYPE_SEGMENT:
+ ret.push_back(ParamDesc(ValueBase(),"p1")
+ .set_local_name(_("Vertex 1"))
+ .set_description(_("The first vertex of the segment"))
+ );
+ ret.push_back(ParamDesc(ValueBase(),"t1")
+ .set_local_name(_("Tangent 1"))
+ .set_description(_("The first tangent of the segment"))
+ );
+ ret.push_back(ParamDesc(ValueBase(),"p2")
+ .set_local_name(_("Vertex 2"))
+ .set_description(_("The second vertex of the segment"))
+ );
+ ret.push_back(ParamDesc(ValueBase(),"t2")
+ .set_local_name(_("Tangent 2"))
+ .set_description(_("The second tangent of the segment"))
+ );
+ return ret;
+ case ValueBase::TYPE_VECTOR:
+ ret.push_back(ParamDesc(ValueBase(),"x")
+ .set_local_name(_("X-Axis"))
+ .set_description(_("The X-Axis component of the vector"))
+ );
+ ret.push_back(ParamDesc(ValueBase(),"y")
+ .set_local_name(_("Y-Axis"))
+ .set_description(_("The Y-Axis component of the vector"))
+ );
+ return ret;
+ case ValueBase::TYPE_BLINEPOINT:
+ ret.push_back(ParamDesc(ValueBase(),"point")
+ .set_local_name(_("Vertex"))
+ .set_description(_("The vertex of the BLine Point"))
+ );
+ ret.push_back(ParamDesc(ValueBase(),"width")
+ .set_local_name(_("Width"))
+ .set_description(_("The width of the BLine Point"))
+ );
+ ret.push_back(ParamDesc(ValueBase(),"origin")
+ .set_local_name(_("Origin"))
+ .set_description(_("Defines the Off and On position relative to neighbours"))
+ );
+ ret.push_back(ParamDesc(ValueBase(),"split")
+ .set_local_name(_("Split"))
+ .set_description(_("When checked, tangents are independent"))
+ );
+ ret.push_back(ParamDesc(ValueBase(),"t1")
+ .set_local_name(_("Tangent 1"))
+ .set_description(_("The first tangent of the BLine Point"))
+ );
+ ret.push_back(ParamDesc(ValueBase(),"t2")
+ .set_local_name(_("Tangent 2"))
+ .set_description(_("The second tangent of the BLine Point"))
+ );
+ return ret;
+ default:
+ break;
+ }
+
+ return ret;
+}
using synfig::LinkableValueNode::get_link_vfunc;
static bool check_type(ValueBase::Type type);
static ValueNode_Composite* create(const ValueBase &x);
+ virtual Vocab get_param_vocab()const;
}; // END of class ValueNode_Composite
}; // END of namespace synfig
throw Exception::BadLinkName(name);
}
+
+LinkableValueNode::Vocab
+ValueNode_Cos::get_param_vocab()const
+{
+ LinkableValueNode::Vocab ret;
+
+ ret.push_back(ParamDesc(ValueBase(),"angle")
+ .set_local_name(_("Angle"))
+ .set_description(_("Value to calculate the cosine"))
+ );
+
+ ret.push_back(ParamDesc(ValueBase(),"amp")
+ .set_local_name(_("Amplitude"))
+ .set_description(_("Multiplier of the resulting cosine"))
+ );
+
+ return ret;
+}
using synfig::LinkableValueNode::set_link_vfunc;
static bool check_type(ValueBase::Type type);
static ValueNode_Cos* create(const ValueBase &x);
+ virtual Vocab get_param_vocab()const;
}; // END of class ValueNode_Cos
}; // END of namespace synfig
type==ValueBase::TYPE_ANGLE ||
type==ValueBase::TYPE_REAL;
}
+
+LinkableValueNode::Vocab
+ValueNode_DotProduct::get_param_vocab()const
+{
+ LinkableValueNode::Vocab ret;
+
+ ret.push_back(ParamDesc(ValueBase(),"lhs")
+ .set_local_name(_("LHS"))
+ .set_description(_("The left side of the dot product"))
+ );
+
+ ret.push_back(ParamDesc(ValueBase(),"rhs")
+ .set_local_name(_("RHS"))
+ .set_description(_("The right side of the dot product"))
+ );
+
+ return ret;
+}
using synfig::LinkableValueNode::set_link_vfunc;
static bool check_type(ValueBase::Type type);
static ValueNode_DotProduct* create(const ValueBase &x);
+ virtual Vocab get_param_vocab()const;
}; // END of class ValueNode_DotProduct
}; // END of namespace synfig
// never offer this as a choice. it's used automatically by the 'Duplicate' layer.
return false;
}
+
+LinkableValueNode::Vocab
+ValueNode_Duplicate::get_param_vocab()const
+{
+ LinkableValueNode::Vocab ret;
+
+ ret.push_back(ParamDesc(ValueBase(),"from")
+ .set_local_name(_("From"))
+ .set_description(_("Initial value of the index "))
+ );
+
+ ret.push_back(ParamDesc(ValueBase(),"to")
+ .set_local_name(_("To"))
+ .set_description(_("Final value of the index"))
+ );
+
+ ret.push_back(ParamDesc(ValueBase(),"step")
+ .set_local_name(_("Step"))
+ .set_description(_("Amount increment of the index"))
+ );
+
+ return ret;
+}
using synfig::LinkableValueNode::set_link_vfunc;
static bool check_type(ValueBase::Type type);
static ValueNode_Duplicate* create(const ValueBase &x);
+ virtual Vocab get_param_vocab()const;
}; // END of class ValueNode_Duplicate
}; // END of namespace synfig
}
changed();
}
+
+LinkableValueNode::Vocab
+ValueNode_DynamicList::get_param_vocab()const
+{
+ LinkableValueNode::Vocab ret;
+ for(unsigned int i=0; i<list.size();i++)
+ {
+ ret.push_back(ParamDesc(ValueBase(),strprintf("item%04d",i))
+ .set_local_name(etl::strprintf(_("Item %03d"),i+1))
+ );
+ }
+
+ return ret;
+}
using synfig::LinkableValueNode::set_link_vfunc;
static bool check_type(ValueBase::Type type);
static ValueNode_DynamicList* create_from(const ValueBase &x=ValueBase::TYPE_GRADIENT);
+ virtual Vocab get_param_vocab()const;
}; // END of class ValueNode_DynamicList
typedef ValueNode_DynamicList::ListEntry::Activepoint Activepoint;
{
return type==ValueBase::TYPE_REAL;
}
+
+LinkableValueNode::Vocab
+ValueNode_Exp::get_param_vocab()const
+{
+ LinkableValueNode::Vocab ret;
+
+ ret.push_back(ParamDesc(ValueBase(),"exp")
+ .set_local_name(_("Exponent"))
+ .set_description(_("The value to raise the constant 'e'"))
+ );
+
+ ret.push_back(ParamDesc(ValueBase(),"scale")
+ .set_local_name(_("Scale"))
+ .set_description(_("Multiplier of the resulting exponent"))
+ );
+
+ return ret;
+}
using synfig::LinkableValueNode::set_link_vfunc;
static bool check_type(ValueBase::Type type);
static ValueNode_Exp* create(const ValueBase &x);
+ virtual Vocab get_param_vocab()const;
}; // END of class ValueNode_Exp
}; // END of namespace synfig
{
return type==ValueBase::TYPE_COLOR;
}
+
+LinkableValueNode::Vocab
+ValueNode_GradientColor::get_param_vocab()const
+{
+ LinkableValueNode::Vocab ret;
+
+ ret.push_back(ParamDesc(ValueBase(),"gradient")
+ .set_local_name(_("Gradient"))
+ .set_description(_("The gradient where the color is picked from"))
+ );
+
+ ret.push_back(ParamDesc(ValueBase(),"index")
+ .set_local_name(_("Index"))
+ .set_description(_("The position of the color at the gradient (0,1]"))
+ );
+
+ ret.push_back(ParamDesc(ValueBase(),"loop")
+ .set_local_name(_("Loop"))
+ .set_description(_("When checked, the index would loop"))
+ );
+
+ return ret;
+}
using synfig::LinkableValueNode::set_link_vfunc;
static bool check_type(ValueBase::Type type);
static ValueNode_GradientColor* create(const ValueBase &x);
+ virtual Vocab get_param_vocab()const;
}; // END of class ValueNode_GradientColor
}; // END of namespace synfig
{
return type==ValueBase::TYPE_GRADIENT;
}
+
+LinkableValueNode::Vocab
+ValueNode_GradientRotate::get_param_vocab()const
+{
+ LinkableValueNode::Vocab ret;
+
+ ret.push_back(ParamDesc(ValueBase(),"gradient")
+ .set_local_name(_("Gradient"))
+ .set_description(_("The source gradient to rotate"))
+ );
+
+ ret.push_back(ParamDesc(ValueBase(),"offset")
+ .set_local_name(_("Offset"))
+ .set_description(_("The amount to offset the gradient"))
+ );
+
+ return ret;
+}
using synfig::LinkableValueNode::set_link_vfunc;
static bool check_type(ValueBase::Type type);
static ValueNode_GradientRotate* create(const ValueBase &x=ValueBase::TYPE_GRADIENT);
+ virtual Vocab get_param_vocab()const;
}; // END of class ValueNode_GradientRotate
}; // END of namespace synfig
{
return _("Greyed");
}
+
+LinkableValueNode::Vocab
+ValueNode_Greyed::get_param_vocab()const
+{
+ LinkableValueNode::Vocab ret;
+
+ ret.push_back(ParamDesc(ValueBase(),"link")
+ .set_local_name(_("Link"))
+ .set_description(_("The greyed value"))
+ );
+
+ return ret;
+}
public:
static ValueNode_Greyed* create(const ValueBase &x);
-
+ virtual Vocab get_param_vocab()const;
}; // END of class ValueNode_Greyed
}; // END of namespace synfig
// type==ValueBase::TYPE_REAL ||
// type==ValueBase::TYPE_TIME;
}
+
+LinkableValueNode::Vocab
+ValueNode_Integer::get_param_vocab()const
+{
+ LinkableValueNode::Vocab ret;
+
+ ret.push_back(ParamDesc(ValueBase(),"integer")
+ .set_local_name(_("Integer"))
+ .set_description(_("The integer value to be converted"))
+ );
+
+ return ret;
+}
using synfig::LinkableValueNode::set_link_vfunc;
static bool check_type(ValueBase::Type type);
static ValueNode_Integer* create(const ValueBase &x);
+ virtual Vocab get_param_vocab()const;
}; // END of class ValueNode_Integer
}; // END of namespace synfig
return
type==ValueBase::TYPE_STRING;
}
+
+LinkableValueNode::Vocab
+ValueNode_IntString::get_param_vocab()const
+{
+ LinkableValueNode::Vocab ret;
+
+ ret.push_back(ParamDesc(ValueBase(),"int")
+ .set_local_name(_("Int"))
+ .set_description(_("Value to convert to string"))
+ );
+
+ ret.push_back(ParamDesc(ValueBase(),"width")
+ .set_local_name(_("Width"))
+ .set_description(_("Width of the string"))
+ );
+
+ ret.push_back(ParamDesc(ValueBase(),"zero_pad")
+ .set_local_name(_("Zero Padded"))
+ .set_description(_("When checked, the string is left filled with zeros to match the width"))
+ );
+
+ return ret;
+}
using synfig::LinkableValueNode::set_link_vfunc;
static bool check_type(ValueBase::Type type);
static ValueNode_IntString* create(const ValueBase &x);
+ virtual Vocab get_param_vocab()const;
}; // END of class ValueNode_IntString
}; // END of namespace synfig
return
type==ValueBase::TYPE_STRING;
}
+
+LinkableValueNode::Vocab
+ValueNode_Join::get_param_vocab()const
+{
+ LinkableValueNode::Vocab ret;
+
+ ret.push_back(ParamDesc(ValueBase(),"strings")
+ .set_local_name(_("Strings"))
+ .set_description(_("The List of strings to join"))
+ );
+
+ ret.push_back(ParamDesc(ValueBase(),"before")
+ .set_local_name(_("Before"))
+ .set_description(_("The string to place before the joined strings"))
+ );
+
+ ret.push_back(ParamDesc(ValueBase(),"separator")
+ .set_local_name(_("Separator"))
+ .set_description(_("The string to place between each string joined"))
+ );
+
+ ret.push_back(ParamDesc(ValueBase(),"after")
+ .set_local_name(_("After"))
+ .set_description(_("The string to place after the joined strings"))
+ );
+
+ return ret;
+}
using synfig::LinkableValueNode::set_link_vfunc;
static bool check_type(ValueBase::Type type);
static ValueNode_Join* create(const ValueBase &x);
+ virtual Vocab get_param_vocab()const;
}; // END of class ValueNode_Join
}; // END of namespace synfig
throw Exception::BadLinkName(name);
}
+
+
+LinkableValueNode::Vocab
+ValueNode_Linear::get_param_vocab()const
+{
+ LinkableValueNode::Vocab ret;
+
+ switch(get_type())
+ {
+ case ValueBase::TYPE_ANGLE:
+ case ValueBase::TYPE_COLOR:
+ case ValueBase::TYPE_INTEGER:
+ case ValueBase::TYPE_REAL:
+ case ValueBase::TYPE_TIME:
+ ret.push_back(ParamDesc(ValueBase(),"slope")
+ .set_local_name(_("Rate"))
+ .set_description(_("Value that is multiplied by the current time (in seconds)"))
+ );
+ break;
+ case ValueBase::TYPE_VECTOR:
+ default:
+ ret.push_back(ParamDesc(ValueBase(),"slope")
+ .set_local_name(_("Slope"))
+ .set_description(_("Value that is multiplied by the current time (in seconds)"))
+ );
+ }
+
+ ret.push_back(ParamDesc(ValueBase(),"offset")
+ .set_local_name(_("Offset"))
+ .set_description(_("Returned value when the current time is zero"))
+ );
+
+ return ret;
+}
using synfig::LinkableValueNode::set_link_vfunc;
static bool check_type(ValueBase::Type type);
static ValueNode_Linear* create(const ValueBase &x);
+ virtual Vocab get_param_vocab()const;
}; // END of class ValueNode_Linear
}; // END of namespace synfig
return type==ValueBase::TYPE_REAL;
}
+LinkableValueNode::Vocab
+ValueNode_Logarithm::get_param_vocab()const
+{
+ LinkableValueNode::Vocab ret;
+
+ ret.push_back(ParamDesc(ValueBase(),"link")
+ .set_local_name(_("Link"))
+ .set_description(_("Value node used to calculate the Neperian logarithm"))
+ );
+
+ ret.push_back(ParamDesc(ValueBase(),"epsilon")
+ .set_local_name(_("Epsilon"))
+ .set_description(_("Value used to compare 'link' with zero "))
+ );
+
+ ret.push_back(ParamDesc(ValueBase(),"infinite")
+ .set_local_name(_("Infinite"))
+ .set_description(_("Returned value when result tends to infinite"))
+ );
+
+ return ret;
+}
using synfig::LinkableValueNode::set_link_vfunc;
static bool check_type(ValueBase::Type type);
static ValueNode_Logarithm* create(const ValueBase &x);
+ virtual Vocab get_param_vocab()const;
}; // END of class ValueNode_Logarithm
}; // END of namespace synfig
{
return type==ValueBase::TYPE_BOOL;
}
+
+LinkableValueNode::Vocab
+ValueNode_Not::get_param_vocab()const
+{
+ LinkableValueNode::Vocab ret;
+
+ ret.push_back(ParamDesc(ValueBase(),"link")
+ .set_local_name(_("Link"))
+ .set_description(_("Value node used to do the NOT operation"))
+ );
+
+ return ret;
+}
using synfig::LinkableValueNode::set_link_vfunc;
static bool check_type(ValueBase::Type type);
static ValueNode_Not* create(const ValueBase &x);
+ virtual Vocab get_param_vocab()const;
}; // END of class ValueNode_Not
}; // END of namespace synfig
{
return type==ValueBase::TYPE_BOOL;
}
+
+LinkableValueNode::Vocab
+ValueNode_Or::get_param_vocab()const
+{
+ LinkableValueNode::Vocab ret;
+
+ ret.push_back(ParamDesc(ValueBase(),"link1")
+ .set_local_name(_("Link1"))
+ .set_description(_("Value node used for the OR boolean operation"))
+ );
+
+ ret.push_back(ParamDesc(ValueBase(),"link2")
+ .set_local_name(_("Link2"))
+ .set_description(_("Value node used for the OR boolean operation"))
+ );
+
+ return ret;
+}
using synfig::LinkableValueNode::set_link_vfunc;
static bool check_type(ValueBase::Type type);
static ValueNode_Or* create(const ValueBase &x);
+ virtual Vocab get_param_vocab()const;
}; // END of class ValueNode_Or
}; // END of namespace synfig
{
return type==ValueBase::TYPE_REAL;
}
+
+LinkableValueNode::Vocab
+ValueNode_Pow::get_param_vocab()const
+{
+ LinkableValueNode::Vocab ret;
+
+ ret.push_back(ParamDesc(ValueBase(),"base")
+ .set_local_name(_("Base"))
+ .set_description(_("The base to be raised to the power"))
+ );
+
+ ret.push_back(ParamDesc(ValueBase(),"power")
+ .set_local_name(_("Power"))
+ .set_description(_("The power used to raise the base"))
+ );
+
+ ret.push_back(ParamDesc(ValueBase(),"epsilon")
+ .set_local_name(_("Epsilon"))
+ .set_description(_("Value used to compare base or power with zero "))
+ );
+
+ ret.push_back(ParamDesc(ValueBase(),"infinite")
+ .set_local_name(_("Infinite"))
+ .set_description(_("Returned value when result tends to infinite"))
+ );
+
+ return ret;
+}
using synfig::LinkableValueNode::set_link_vfunc;
static bool check_type(ValueBase::Type type);
static ValueNode_Pow* create(const ValueBase &x);
+ virtual Vocab get_param_vocab()const;
}; // END of class ValueNode_Pow
}; // END of namespace synfig
type==ValueBase::TYPE_VECTOR ||
type==ValueBase::TYPE_COLOR;
}
+
+LinkableValueNode::Vocab
+ValueNode_RadialComposite::get_param_vocab()const
+{
+ LinkableValueNode::Vocab ret;
+
+ switch(get_type())
+ {
+ case ValueBase::TYPE_COLOR:
+ ret.push_back(ParamDesc(ValueBase(),"y_luma")
+ .set_local_name(_("Luma"))
+ );
+ ret.push_back(ParamDesc(ValueBase(),"saturation")
+ .set_local_name(_("Saturation"))
+ );
+ ret.push_back(ParamDesc(ValueBase(),"hue")
+ .set_local_name(_("Hue"))
+ );
+ ret.push_back(ParamDesc(ValueBase(),"alpha")
+ .set_local_name(_("Saturation"))
+ );
+ return ret;
+ break;
+ case ValueBase::TYPE_VECTOR:
+ ret.push_back(ParamDesc(ValueBase(),"radius")
+ .set_local_name(_("Radius"))
+ .set_description(_("The length of the vector"))
+ );
+ ret.push_back(ParamDesc(ValueBase(),"theta")
+ .set_local_name(_("Theta"))
+ .set_description(_("The angle of the vector with the X axis"))
+ );
+ return ret;
+ break;
+ default:
+ break;
+ }
+
+ return ret;
+}
using synfig::LinkableValueNode::get_link_vfunc;
static bool check_type(ValueBase::Type type);
static ValueNode_RadialComposite* create(const ValueBase &x);
+ virtual Vocab get_param_vocab()const;
}; // END of class ValueNode_RadialComposite
}; // END of namespace synfig
|| type==ValueBase::TYPE_REAL
|| type==ValueBase::TYPE_TIME;
}
+
+LinkableValueNode::Vocab
+ValueNode_Range::get_param_vocab()const
+{
+ LinkableValueNode::Vocab ret;
+
+ ret.push_back(ParamDesc(ValueBase(),"min")
+ .set_local_name(_("Min"))
+ .set_description(_("Returned value when 'Link' is smaller"))
+ );
+
+ ret.push_back(ParamDesc(ValueBase(),"max")
+ .set_local_name(_("Max"))
+ .set_description(_("Returned value when 'Link' is greater"))
+ );
+
+ ret.push_back(ParamDesc(ValueBase(),"link")
+ .set_local_name(_("Link"))
+ .set_description(_("The value node to limit its range"))
+ );
+
+ return ret;
+}
using synfig::LinkableValueNode::set_link_vfunc;
static bool check_type(ValueBase::Type type);
static ValueNode_Range* create(const ValueBase &value=ValueBase());
+ virtual Vocab get_param_vocab()const;
}; // END of class ValueNode_Range
}; // END of namespace synfig
return
type==ValueBase::TYPE_STRING;
}
+
+LinkableValueNode::Vocab
+ValueNode_RealString::get_param_vocab()const
+{
+ LinkableValueNode::Vocab ret;
+
+ ret.push_back(ParamDesc(ValueBase(),"real")
+ .set_local_name(_("Real"))
+ .set_description(_("Value to convert to string"))
+ );
+
+ ret.push_back(ParamDesc(ValueBase(),"width")
+ .set_local_name(_("Width"))
+ .set_description(_("Width of the string"))
+ );
+
+ ret.push_back(ParamDesc(ValueBase(),"precision")
+ .set_local_name(_("Precision"))
+ .set_description(_("Number of decimal places"))
+ );
+
+ ret.push_back(ParamDesc(ValueBase(),"zero_pad")
+ .set_local_name(_("Zero Padded"))
+ .set_description(_("When checked, the string is left filled with zeros to match the width"))
+ );
+
+
+ return ret;
+}
using synfig::LinkableValueNode::set_link_vfunc;
static bool check_type(ValueBase::Type type);
static ValueNode_RealString* create(const ValueBase &x);
+ virtual Vocab get_param_vocab()const;
}; // END of class ValueNode_RealString
}; // END of namespace synfig
{
return type==ValueBase::TYPE_REAL;
}
+
+LinkableValueNode::Vocab
+ValueNode_Reciprocal::get_param_vocab()const
+{
+ LinkableValueNode::Vocab ret;
+
+ ret.push_back(ParamDesc(ValueBase(),"link")
+ .set_local_name(_("Link"))
+ .set_description(_("The value node used to calculate its reciprocal"))
+ );
+
+ ret.push_back(ParamDesc(ValueBase(),"epsilon")
+ .set_local_name(_("Epsilon"))
+ .set_description(_("The value used to decide whether 'Link' is too small to obtain its reciprocal"))
+ );
+
+ ret.push_back(ParamDesc(ValueBase(),"infinite")
+ .set_local_name(_("Infinite"))
+ .set_description(_("The resulting value when 'Link' < 'Epsilon'"))
+ );
+
+ return ret;
+}
using synfig::LinkableValueNode::set_link_vfunc;
static bool check_type(ValueBase::Type type);
static ValueNode_Reciprocal* create(const ValueBase &x);
+ virtual Vocab get_param_vocab()const;
}; // END of class ValueNode_Reciprocal
}; // END of namespace synfig
return true;
return false;
}
+
+LinkableValueNode::Vocab
+ValueNode_Reference::get_param_vocab()const
+{
+ LinkableValueNode::Vocab ret;
+
+ ret.push_back(ParamDesc(ValueBase(),"link")
+ .set_local_name(_("Link"))
+ .set_description(_("The referenced value"))
+ );
+
+ return ret;
+}
using synfig::LinkableValueNode::set_link_vfunc;
static bool check_type(ValueBase::Type type);
static ValueNode_Reference* create(const ValueBase &x);
+ virtual Vocab get_param_vocab()const;
}; // END of class ValueNode_Reference
}; // END of namespace synfig
{
return type==ValueBase::TYPE_GRADIENT;
}
+
+LinkableValueNode::Vocab
+ValueNode_Repeat_Gradient::get_param_vocab()const
+{
+ LinkableValueNode::Vocab ret;
+
+ ret.push_back(ParamDesc(ValueBase(),"gradient")
+ .set_local_name(_("Gradient"))
+ .set_description(_("The source gradient to repeat"))
+ );
+
+ ret.push_back(ParamDesc(ValueBase(),"count")
+ .set_local_name(_("Count"))
+ .set_description(_("The number of repetition of the gradient"))
+ );
+
+ ret.push_back(ParamDesc(ValueBase(),"width")
+ .set_local_name(_("Width"))
+ .set_description(_("Specifies how much biased is the source gradeint in the repetition [0,1]"))
+ );
+
+ ret.push_back(ParamDesc(ValueBase(),"specify_start")
+ .set_local_name(_("Specify Start"))
+ .set_description(_("When checked, 'Start Color' is used as the start of the resulting gradient"))
+ );
+
+ ret.push_back(ParamDesc(ValueBase(),"specify_end")
+ .set_local_name(_("Specify End"))
+ .set_description(_("When checked, 'End Color' is used as the start of the resulting gradient"))
+ );
+
+ ret.push_back(ParamDesc(ValueBase(),"start_color")
+ .set_local_name(_("Start Color"))
+ .set_description(_("Used as the start of the resulting gradient"))
+ );
+
+ ret.push_back(ParamDesc(ValueBase(),"end_color")
+ .set_local_name(_("End Color"))
+ .set_description(_("Used as the end of the resulting gradient"))
+ );
+
+ return ret;
+}
using synfig::LinkableValueNode::set_link_vfunc;
static bool check_type(ValueBase::Type type);
static ValueNode_Repeat_Gradient* create(const ValueBase &x=ValueBase::TYPE_GRADIENT);
+ virtual Vocab get_param_vocab()const;
}; // END of class ValueNode_Repeat_Gradient
}; // END of namespace synfig
type==ValueBase::TYPE_TIME ||
type==ValueBase::TYPE_VECTOR;
}
+
+LinkableValueNode::Vocab
+ValueNode_Scale::get_param_vocab()const
+{
+ LinkableValueNode::Vocab ret;
+
+ ret.push_back(ParamDesc(ValueBase(),"link")
+ .set_local_name(_("Link"))
+ .set_description(_("The value node used to scale"))
+ );
+
+ ret.push_back(ParamDesc(ValueBase(),"scalar")
+ .set_local_name(_("Scalar"))
+ .set_description(_("Value that multiplies the value node"))
+ );
+
+ return ret;
+}
using synfig::LinkableValueNode::set_link_vfunc;
static bool check_type(ValueBase::Type type);
static ValueNode_Scale* create(const ValueBase &x);
+ virtual Vocab get_param_vocab()const;
}; // END of class ValueNode_Scale
}; // END of namespace synfig
{
return new ValueNode_SegCalcTangent(ValueBase::TYPE_VECTOR);
}
+
+LinkableValueNode::Vocab
+ValueNode_SegCalcTangent::get_param_vocab()const
+{
+ LinkableValueNode::Vocab ret;
+
+ ret.push_back(ParamDesc(ValueBase(),"segment")
+ .set_local_name(_("Segment"))
+ .set_description(_("The Segment where the tangent is linked to"))
+ );
+
+ ret.push_back(ParamDesc(ValueBase(),"amount")
+ .set_local_name(_("Amount"))
+ .set_description(_("The position of the linked tangent on the Segment (0,1]"))
+ );
+ return ret;
+}
using synfig::LinkableValueNode::set_link_vfunc;
static bool check_type(ValueBase::Type type);
static ValueNode_SegCalcTangent* create(const ValueBase &x=ValueBase::TYPE_VECTOR);
+ virtual Vocab get_param_vocab()const;
}; // END of class ValueNode_SegCalcTangent
}; // END of namespace synfig
{
return new ValueNode_SegCalcVertex(ValueBase::TYPE_VECTOR);
}
+
+LinkableValueNode::Vocab
+ValueNode_SegCalcVertex::get_param_vocab()const
+{
+ LinkableValueNode::Vocab ret;
+
+ ret.push_back(ParamDesc(ValueBase(),"segment")
+ .set_local_name(_("Segment"))
+ .set_description(_("The Segment where the vertex is linked to"))
+ );
+
+ ret.push_back(ParamDesc(ValueBase(),"amount")
+ .set_local_name(_("Amount"))
+ .set_description(_("The position of the linked vertex on the Segment (0,1]"))
+ );
+ return ret;
+}
using synfig::LinkableValueNode::set_link_vfunc;
static bool check_type(ValueBase::Type type);
static ValueNode_SegCalcVertex* create(const ValueBase &x=ValueBase::TYPE_VECTOR);
+ virtual Vocab get_param_vocab()const;
}; // END of class ValueNode_SegCalcVertex
}; // END of namespace synfig
throw Exception::BadLinkName(name);
}
+
+LinkableValueNode::Vocab
+ValueNode_Sine::get_param_vocab()const
+{
+ LinkableValueNode::Vocab ret;
+
+ ret.push_back(ParamDesc(ValueBase(),"angle")
+ .set_local_name(_("Angle"))
+ .set_description(_("The angle where the sine is calculated from"))
+ );
+
+ ret.push_back(ParamDesc(ValueBase(),"amp")
+ .set_local_name(_("Amplitude"))
+ .set_description(_("The value that multiplies the resulting sine"))
+ );
+
+ return ret;
+}
using synfig::LinkableValueNode::set_link_vfunc;
static bool check_type(ValueBase::Type type);
static ValueNode_Sine* create(const ValueBase &x);
+ virtual Vocab get_param_vocab()const;
}; // END of class ValueNode_Sine
}; // END of namespace synfig
throw Exception::BadLinkName(name);
}
+
+LinkableValueNode::Vocab
+ValueNode_Step::get_param_vocab()const
+{
+ LinkableValueNode::Vocab ret;
+
+ ret.push_back(ParamDesc(ValueBase(),"link")
+ .set_local_name(_("Link"))
+ .set_description(_("The value node used to make the step"))
+ );
+
+ ret.push_back(ParamDesc(ValueBase(),"duration")
+ .set_local_name(_("Duration"))
+ .set_description(_("The duration of the step"))
+ );
+
+ ret.push_back(ParamDesc(ValueBase(),"start_time")
+ .set_local_name(_("Start Time"))
+ .set_description(_("The time when the step conversion starts"))
+ );
+
+ ret.push_back(ParamDesc(ValueBase(),"intersection")
+ .set_local_name(_("Intersection"))
+ .set_description(_("Value that define whether the step is centerd on the value [0,1]"))
+ );
+
+ return ret;
+}
using synfig::LinkableValueNode::set_link_vfunc;
static bool check_type(ValueBase::Type type);
static ValueNode_Step* create(const ValueBase &x);
+ virtual Vocab get_param_vocab()const;
}; // END of class ValueNode_Step
}; // END of namespace synfig
{
return type==ValueBase::TYPE_GRADIENT;
}
+
+LinkableValueNode::Vocab
+ValueNode_Stripes::get_param_vocab()const
+{
+ LinkableValueNode::Vocab ret;
+
+ ret.push_back(ParamDesc(ValueBase(),"color1")
+ .set_local_name(_("Color 1"))
+ .set_description(_("One color of the gradient stripes"))
+ );
+
+ ret.push_back(ParamDesc(ValueBase(),"color2")
+ .set_local_name(_("Color 2"))
+ .set_description(_("Other color of the gradient stripes"))
+ );
+
+ ret.push_back(ParamDesc(ValueBase(),"stripes")
+ .set_local_name(_("Stripe Count"))
+ .set_description(_("Number of stripes in the gradient"))
+ );
+
+ ret.push_back(ParamDesc(ValueBase(),"width")
+ .set_local_name(_("Width"))
+ .set_description(_("Width of stripes in the gradient between [0,1]"))
+ );
+
+ return ret;
+}
using synfig::LinkableValueNode::set_link_vfunc;
static bool check_type(ValueBase::Type type);
static ValueNode_Stripes* create(const ValueBase &x=ValueBase::TYPE_GRADIENT);
+ virtual Vocab get_param_vocab()const;
}; // END of class ValueNode_Stripes
}; // END of namespace synfig
|| type==ValueBase::TYPE_TIME
|| type==ValueBase::TYPE_VECTOR;
}
+
+LinkableValueNode::Vocab
+ValueNode_Subtract::get_param_vocab()const
+{
+ LinkableValueNode::Vocab ret;
+
+ ret.push_back(ParamDesc(ValueBase(),"lhs")
+ .set_local_name(_("LHS"))
+ .set_description(_("Left Hand Side of the subtraction"))
+ );
+
+ ret.push_back(ParamDesc(ValueBase(),"rhs")
+ .set_local_name(_("RHS"))
+ .set_description(_("Right Hand Side of the subtraction"))
+ );
+
+ ret.push_back(ParamDesc(ValueBase(),"scalar")
+ .set_local_name(_("Scalar"))
+ .set_description(_("Value that multiplies the subtraction"))
+ );
+
+ return ret;
+}
//! Gets the scalar value_node
ValueNode::Handle get_scalar()const { return scalar; }
+ virtual Vocab get_param_vocab()const;
}; // END of class ValueNode_Subtract
}; // END of namespace synfig
return true;
return false;
}
+
+LinkableValueNode::Vocab
+ValueNode_Switch::get_param_vocab()const
+{
+ LinkableValueNode::Vocab ret;
+
+ ret.push_back(ParamDesc(ValueBase(),"link_off")
+ .set_local_name(_("Link Off"))
+ .set_description(_("The value node returned when the switch is off"))
+ );
+
+ ret.push_back(ParamDesc(ValueBase(),"link_on")
+ .set_local_name(_("Link On"))
+ .set_description(_("The value node returned when the switch is on"))
+ );
+
+ ret.push_back(ParamDesc(ValueBase(),"switch")
+ .set_local_name(_("Switch"))
+ .set_description(_("When checked, returns 'Link On', otherwise returns 'Link Off'"))
+ );
+
+ return ret;
+}
using synfig::LinkableValueNode::set_link_vfunc;
static bool check_type(ValueBase::Type type);
static ValueNode_Switch* create(const ValueBase &x);
+ virtual Vocab get_param_vocab()const;
}; // END of class ValueNode_Switch
}; // END of namespace synfig
type==ValueBase::TYPE_TIME ||
type==ValueBase::TYPE_VECTOR;
}
+
+LinkableValueNode::Vocab
+ValueNode_TimedSwap::get_param_vocab()const
+{
+ LinkableValueNode::Vocab ret;
+
+ ret.push_back(ParamDesc(ValueBase(),"before")
+ .set_local_name(_("Before"))
+ .set_description(_("The value node returned when current time is before 'time' - 'length'"))
+ );
+
+ ret.push_back(ParamDesc(ValueBase(),"after")
+ .set_local_name(_("After"))
+ .set_description(_("The value node returned when current time is after 'time'"))
+ );
+
+ ret.push_back(ParamDesc(ValueBase(),"time")
+ .set_local_name(_("Time"))
+ .set_description(_("The time when the linear interpolation ends"))
+ );
+
+ ret.push_back(ParamDesc(ValueBase(),"length")
+ .set_local_name(_("Length"))
+ .set_description(_("The length of time when the linear interpolation between 'Before' and 'After' is made"))
+ );
+
+ return ret;
+}
using synfig::LinkableValueNode::set_link_vfunc;
static bool check_type(ValueBase::Type type);
static ValueNode_TimedSwap* create(const ValueBase &x);
+ virtual Vocab get_param_vocab()const;
}; // END of class ValueNode_TimedSwap
}; // END of namespace synfig
return true;
return false;
}
+
+
+LinkableValueNode::Vocab
+ValueNode_TimeLoop::get_param_vocab()const
+{
+ LinkableValueNode::Vocab ret;
+
+ ret.push_back(ParamDesc("link")
+ .set_local_name(_("Link"))
+ .set_description(_("The value node to time loop"))
+ );
+
+ ret.push_back(ParamDesc("link_time")
+ .set_local_name(_("Link Time"))
+ .set_description(_("Start time of the loop for the value node timeline"))
+ );
+
+ ret.push_back(ParamDesc("local_time")
+ .set_local_name(_("Local Time"))
+ .set_description(_("The time when the resulted loop starts"))
+ );
+
+ ret.push_back(ParamDesc("duration")
+ .set_local_name(_("Duration"))
+ .set_description(_("Lenght of the loop"))
+ );
+ return ret;
+}
using synfig::LinkableValueNode::set_link_vfunc;
static bool check_type(ValueBase::Type type);
static ValueNode_TimeLoop* create(const ValueBase &x);
+ virtual Vocab get_param_vocab()const;
}; // END of class ValueNode_TimeLoop
}; // END of namespace synfig
return
type==ValueBase::TYPE_STRING;
}
+
+LinkableValueNode::Vocab
+ValueNode_TimeString::get_param_vocab()const
+{
+ LinkableValueNode::Vocab ret;
+
+ ret.push_back(ParamDesc(ValueBase(),"time")
+ .set_local_name(_("Time"))
+ .set_description(_("The time that is converted to string"))
+ );
+
+ return ret;
+}
using synfig::LinkableValueNode::set_link_vfunc;
static bool check_type(ValueBase::Type type);
static ValueNode_TimeString* create(const ValueBase &x);
+ virtual Vocab get_param_vocab()const;
}; // END of class ValueNode_TimeString
}; // END of namespace synfig
{
return type==ValueBase::TYPE_GRADIENT;
}
+
+LinkableValueNode::Vocab
+ValueNode_TwoTone::get_param_vocab()const
+{
+ LinkableValueNode::Vocab ret;
+
+ ret.push_back(ParamDesc(ValueBase(),"color1")
+ .set_local_name(_("Color 1"))
+ .set_description(_("The start color of the gradient"))
+ );
+
+ ret.push_back(ParamDesc(ValueBase(),"color2")
+ .set_local_name(_("Color 2"))
+ .set_description(_("The end color of the gradient"))
+ );
+
+ return ret;
+}
using synfig::LinkableValueNode::set_link_vfunc;
static bool check_type(ValueBase::Type type);
static ValueNode_TwoTone* create(const ValueBase &x);
+ virtual Vocab get_param_vocab()const;
}; // END of class ValueNode_TwoTone
}; // END of namespace synfig
{
return type==ValueBase::TYPE_ANGLE;
}
+
+
+LinkableValueNode::Vocab
+ValueNode_VectorAngle::get_param_vocab()const
+{
+ LinkableValueNode::Vocab ret;
+
+ ret.push_back(ParamDesc(ValueBase(),"vector")
+ .set_local_name(_("Vector"))
+ .set_description(_("The vector where the angle is calculated from"))
+ );
+
+ return ret;
+}
using synfig::LinkableValueNode::set_link_vfunc;
static bool check_type(ValueBase::Type type);
static ValueNode_VectorAngle* create(const ValueBase &x);
+ virtual Vocab get_param_vocab()const;
}; // END of class ValueNode_VectorAngle
}; // END of namespace synfig
{
return type==ValueBase::TYPE_REAL;
}
+
+LinkableValueNode::Vocab
+ValueNode_VectorLength::get_param_vocab()const
+{
+ LinkableValueNode::Vocab ret;
+
+ ret.push_back(ParamDesc(ValueBase(),"vector")
+ .set_local_name(_("Vector"))
+ .set_description(_("The vector where the length is calculated from"))
+ );
+
+ return ret;
+}
using synfig::LinkableValueNode::set_link_vfunc;
static bool check_type(ValueBase::Type type);
static ValueNode_VectorLength* create(const ValueBase &x);
+ virtual Vocab get_param_vocab()const;
}; // END of class ValueNode_VectorLength
}; // END of namespace synfig
{
return type==ValueBase::TYPE_REAL;
}
+
+LinkableValueNode::Vocab
+ValueNode_VectorX::get_param_vocab()const
+{
+ LinkableValueNode::Vocab ret;
+
+ ret.push_back(ParamDesc(ValueBase(),"vector")
+ .set_local_name(_("Vector"))
+ .set_description(_("The vector where the X coordinate is extracted from"))
+ );
+
+ return ret;
+}
using synfig::LinkableValueNode::set_link_vfunc;
static bool check_type(ValueBase::Type type);
static ValueNode_VectorX* create(const ValueBase &x);
+ virtual Vocab get_param_vocab()const;
}; // END of class ValueNode_VectorX
}; // END of namespace synfig
{
return type==ValueBase::TYPE_REAL;
}
+
+LinkableValueNode::Vocab
+ValueNode_VectorY::get_param_vocab()const
+{
+ LinkableValueNode::Vocab ret;
+
+ ret.push_back(ParamDesc(ValueBase(),"vector")
+ .set_local_name(_("Vector"))
+ .set_description(_("The vector where the Y coordinate is extracted from"))
+ );
+
+ return ret;
+}
using synfig::LinkableValueNode::set_link_vfunc;
static bool check_type(ValueBase::Type type);
static ValueNode_VectorY* create(const ValueBase &x);
+ virtual Vocab get_param_vocab()const;
}; // END of class ValueNode_VectorY
}; // END of namespace synfig
projects / synfig.git / commitdiff