#endif
#include "props.hxx"
+#include "PropertyInterpolationMgr.hxx"
#include "vectorPropTemplates.hxx"
#include <algorithm>
#include <limits>
+#include <set>
#include <sstream>
#include <iomanip>
#include <iterator>
using namespace simgear;
-\f
////////////////////////////////////////////////////////////////////////
// Local classes.
////////////////////////////////////////////////////////////////////////
};
-\f
////////////////////////////////////////////////////////////////////////
// Convenience macros for value access.
////////////////////////////////////////////////////////////////////////
#define TEST_READ(dflt) if (!getAttribute(READ)) return dflt
#define TEST_WRITE if (!getAttribute(WRITE)) return false
-\f
////////////////////////////////////////////////////////////////////////
// Local path normalization code.
is_alnum() || is_any_of("_-."));
}
-\f
////////////////////////////////////////////////////////////////////////
// Other static utility functions.
////////////////////////////////////////////////////////////////////////
static char *
copy_string (const char * s)
{
- unsigned long int slen = strlen(s);
+ size_t slen = strlen(s);
char * copy = new char[slen + 1];
// the source string length is known so no need to check for '\0'
static int
find_child (Itr begin, Itr end, int index, const PropertyList& nodes)
{
- int nNodes = nodes.size();
+ size_t nNodes = nodes.size();
boost::iterator_range<Itr> name(begin, end);
- for (int i = 0; i < nNodes; i++) {
+ for (size_t i = 0; i < nNodes; i++) {
SGPropertyNode * node = nodes[i];
- // searching for a mathing index is a lot less time consuming than
+ // searching for a matching index is a lot less time consuming than
// comparing two strings so do that first.
if (node->getIndex() == index && boost::equals(node->getName(), name))
- return i;
+ return static_cast<int>(i);
}
return -1;
}
static int
find_last_child (const char * name, const PropertyList& nodes)
{
- int nNodes = nodes.size();
- int index = 0;
+ size_t nNodes = nodes.size();
+ int index = -1;
- for (int i = 0; i < nNodes; i++) {
+ for (size_t i = 0; i < nNodes; i++) {
SGPropertyNode * node = nodes[i];
if (compare_strings(node->getName(), name))
{
return index;
}
- SG_LOG(SG_GENERAL, SG_ALERT, "Too much nodes: " << name);
+ SG_LOG(SG_GENERAL, SG_ALERT, "Too many nodes: " << name);
return -1;
}
return find_node_aux(current, itr, create, last_index);
}
-\f
////////////////////////////////////////////////////////////////////////
// Private methods from SGPropertyNode (may be inlined for speed).
////////////////////////////////////////////////////////////////////////
#endif
}
-\f
////////////////////////////////////////////////////////////////////////
// Public methods from SGPropertyNode.
////////////////////////////////////////////////////////////////////////
return node;
}
+/**
+ * Create multiple children with unused indices
+ */
+simgear::PropertyList
+SGPropertyNode::addChildren( const std::string& name,
+ size_t count,
+ int min_index,
+ bool append )
+{
+ simgear::PropertyList nodes;
+ std::set<int> used_indices;
+
+ if( !append )
+ {
+ // First grab all used indices. This saves us of testing every index if it
+ // is used for every element to be created
+ for( size_t i = 0; i < nodes.size(); i++ )
+ {
+ const SGPropertyNode* node = nodes[i];
+
+ if( node->getNameString() == name && node->getIndex() >= min_index )
+ used_indices.insert(node->getIndex());
+ }
+ }
+ else
+ {
+ // If we don't want to fill the holes just find last node
+ min_index = std::max(find_last_child(name.c_str(), _children) + 1, min_index);
+ }
+
+ for( int index = min_index;
+ index < std::numeric_limits<int>::max() && nodes.size() < count;
+ ++index )
+ {
+ if( used_indices.find(index) == used_indices.end() )
+ {
+ SGPropertyNode_ptr node;
+ node = new SGPropertyNode(name, index, this);
+ _children.push_back(node);
+ fireChildAdded(node);
+ nodes.push_back(node);
+ }
+ }
+
+ return nodes;
+}
/**
* Get a non-const child by index.
SGPropertyNode::getChildren (const char * name) const
{
PropertyList children;
- int max = _children.size();
+ size_t max = _children.size();
- for (int i = 0; i < max; i++)
+ for (size_t i = 0; i < max; i++)
if (compare_strings(_children[i]->getName(), name))
children.push_back(_children[i]);
{
PropertyList children;
- for (int pos = _children.size() - 1; pos >= 0; pos--)
+ for (int pos = static_cast<int>(_children.size() - 1); pos >= 0; pos--)
if (compare_strings(_children[pos]->getName(), name))
children.push_back(removeChild(pos, keep));
return result;
}
+//------------------------------------------------------------------------------
+bool SGPropertyNode::interpolate( const std::string& type,
+ const SGPropertyNode& target,
+ double duration,
+ const std::string& easing )
+{
+ if( !_interpolation_mgr )
+ {
+ SG_LOG(SG_GENERAL, SG_WARN, "No property interpolator available");
+
+ // no interpolation possible -> set to target immediately
+ setUnspecifiedValue( target.getStringValue() );
+ return false;
+ }
+
+ return _interpolation_mgr->interpolate(this, type, target, duration, easing);
+}
+
+//------------------------------------------------------------------------------
+bool SGPropertyNode::interpolate( const std::string& type,
+ const PropertyList& values,
+ const double_list& deltas,
+ const std::string& easing )
+{
+ if( !_interpolation_mgr )
+ {
+ SG_LOG(SG_GENERAL, SG_WARN, "No property interpolator available");
+
+ // no interpolation possible -> set to last value immediately
+ if( !values.empty() )
+ setUnspecifiedValue(values.back()->getStringValue());
+ return false;
+ }
+
+ return _interpolation_mgr->interpolate(this, type, values, deltas, easing);
+}
+
+//------------------------------------------------------------------------------
+void SGPropertyNode::setInterpolationMgr(simgear::PropertyInterpolationMgr* mgr)
+{
+ _interpolation_mgr = mgr;
+}
+
+simgear::PropertyInterpolationMgr* SGPropertyNode::_interpolation_mgr = 0;
+
+//------------------------------------------------------------------------------
std::ostream& SGPropertyNode::printOn(std::ostream& stream) const
{
if (!getAttribute(READ))
return ((SGPropertyNode *)this)->getNode(relative_path, index, false);
}
-\f
////////////////////////////////////////////////////////////////////////
// Convenience methods using relative paths.
////////////////////////////////////////////////////////////////////////
fireChildAdded(this, child);
}
+void
+SGPropertyNode::fireCreatedRecursive(bool fire_self)
+{
+ if( fire_self )
+ {
+ _parent->fireChildAdded(this);
+
+ if( _children.empty() && getType() != simgear::props::NONE )
+ return fireValueChanged();
+ }
+
+ for(size_t i = 0; i < _children.size(); ++i)
+ _children[i]->fireCreatedRecursive(true);
+}
+
void
SGPropertyNode::fireChildRemoved (SGPropertyNode * child)
{
fireChildRemoved(this, child);
}
+void
+SGPropertyNode::fireChildrenRemovedRecursive()
+{
+ for(size_t i = 0; i < _children.size(); ++i)
+ {
+ SGPropertyNode* child = _children[i];
+ fireChildRemoved(this, child);
+ child->fireChildrenRemovedRecursive();
+ }
+}
+
void
SGPropertyNode::fireValueChanged (SGPropertyNode * node)
{
_parent->fireChildRemoved(parent, child);
}
-\f
////////////////////////////////////////////////////////////////////////
// Implementation of SGPropertyChangeListener.
////////////////////////////////////////////////////////////////////////
SGPropertyChangeListener::~SGPropertyChangeListener ()
{
- for (int i = _properties.size() - 1; i >= 0; i--)
+ for (int i = static_cast<int>(_properties.size() - 1); i >= 0; i--)
_properties[i]->removeChangeListener(this);
}
projects / simgear.git / blobdiff