VertexSelectorInput.hpp

#ifndef VERTECSELECTORINPUT_HPP
#define VERTECSELECTORINPUT_HPP
 
#include "VertexSelector.hpp"
#include <sstream>
#include <ocean/plankton/VValue.hpp>
 
namespace Wizt
{
 
struct  VertexSelectorValue
{
        MemCore::RefPtr< VertexSelector > selector;
 
        bool    operator==(const VertexSelectorValue&V) const
        {
                return selector == V.selector;
        }
};
 
//enable a slot for a VertexSelector
template<>
class VValueTrait< VertexSelectorValue >
{
public:
        static bool setValueFromText( VertexSelectorValue& vsc,
                                      const string& s )
        {
                return false;
        }
 
        static string Text( const VertexSelectorValue& vsv )
        {
                assert( vsv.selector && "VValueTrait< RefPtr<VertexSelector> >::Text() invalid pointer" );
 
                std::stringstream tmp;
 
                char buf[512];
                vsv.selector.speak(buf, "");
 
                tmp << buf << ":";
 
                return tmp.str();
        }
};
 
 
// Enable collection of VertexSelections usable for slots
struct VertexSelectorCollection
{
        std::vector< RefPtr<VertexSelector> > VertexSelections;
};
 
template<>
class VValueTrait < VertexSelectorCollection >
{
public:
        static bool setValueFromText( VertexSelectorCollection& vsc,
                                      const string& s )
        {
                return false;
        }
 
        // Not sure if this is a good idea? To use the actual pointer information for text conversion and updating
        // The selection should not be called for each text conversion and writing all the bools to
        // text also seems not to be a good idea. (mr)
        static string Text( const VertexSelectorCollection& vsc )
        {
                std::stringstream tmp;
 
                if( vsc.VertexSelections.size() > 0 )
                {
                        for( unsigned i = 0; i <  vsc.VertexSelections.size(); i++ )
                        {
                                //check for NullPtr()
                                if( vsc.VertexSelections[i] )
                                {
                                        const RefPtr<VertexSelector>& current_selector = vsc.VertexSelections.at(i);
                                        char buf[512];
                                        current_selector.speak(buf, "");
                                        tmp << buf << ":";
                                }
                         }
 
                        return tmp.str();
                }
 
                return "";
        }
};
}
 
#endif // VERTECSELECTORINPUT_HPP