FieldObject.hpp

#ifndef __FISH_FIELDOBJECT_HPP
#define __FISH_FIELDOBJECT_HPP
 
#include "fishboneDllApi.h"
 
#include <bundle/Bundle.hpp>
#include <ocean/shrimp/VObjectStatus.hpp>
#include <ocean/shrimp/VEnum.hpp>
 
#include "FishField.hpp"
#include "FishSlice.hpp"
#include "GridObject.hpp"
#include "TypedCreationPreferences.hpp"
 
 
 
namespace Wizt
{
 
 
class fishbone_API FieldObject : public VObject
                               , public Fish<Fiber::Slice>
                               , public Fish<Fiber::Grid>
                               , public StatusIndicator
//                             , public VChartDependent
{
public:
        TypedSlot<VStringList>  MyFieldNames;
 
        in<VEnum>       inSkeletonType;
 
        Fiber::TypeList_t AcceptedFields;
 
        VOutput<Fiber::Field>   theField; 
 
        VOutput<string>         theFieldName; 
 
//      out<Range>      outFieldRange;
 
        const Fiber::TypeList_t&OutputFieldTypes() const
        {
                return theField().FieldTypes();
        }
 
        FieldObject(const string&name, int p = 0, const RefPtr<VCreationPreferences>&VP = NullPtr(), bool ExportGrid = true);
 
        ~FieldObject();
 
static  bool    HasFields(const WeakPtr<VCreatorBase>&, const RefPtr<VObject>&vobj, const Fiber::TypeList_t&AcceptedFields);
 
        bool    update(VRequest&R, double precision) override;
 
        const char*const*xpm_icon() const override; 
 
        string help(HelpType) const override;
 
        std::string type_key() const override;
};
 
 
template <class FieldVObject>
struct  FieldObjectCreator : VCreator<FieldVObject, AcceptList<Fiber::Grid> >
{
        typedef VCreator<FieldVObject, AcceptList<Fiber::Grid> >  Base_t;
 
        FieldObjectCreator(const string&name, int p=0, 
                           const RefPtr<VCreationPreferences>&VP=NullPtr() )
        : Base_t(name, p, VP)
        {}
 
        template <unsigned ID>
        FieldObjectCreator(const VCreatorProperty<ID>&CreatorProperties, int quality,
                           const RefPtr<VCreationPreferences>&VP=NullPtr() )
        : Base_t(CreatorProperties, quality, VP)
        {}
 
#if     0
        string createChildname(const string&parent_name) const override
        {
        string  BaseName = right_of( this->Name(), '/');
                return BaseName + "On" + parent_name;
 
 
//              return parent_name + "->" + BaseName;
//              return parent_name + "(" + this->Name() + ")";
        }
#endif
 
        VAcceptInfoList_t accept(const RefPtr<VObject>&vobj) const override
        {
        VAcceptInfoList_t AcceptedGridConnections = Base_t::accept(vobj); 
 
                /*
                  Filtering of the grid connections according to the fields
                  that are to be connected.
                 */
        VAcceptInfoList_t AcceptedFieldConnections;
                for(VAcceptInfoList_t::const_iterator git = AcceptedGridConnections.begin(); 
                    git != AcceptedGridConnections.end(); git++)
                {
                        if (RefPtr<VAcceptInfo>  VAI = *git)
                        {
                        Fiber::TypeList_t AcceptedFields;
                                if (RefPtr<TypedCreationPreferencesBase> TypedPrefs = this->CreationPreferences() )
                                {
                                        TypedPrefs->getAcceptTypes(AcceptedFields);
                                }
 
                                if (FieldVObject::HasFields(this->self(), vobj, AcceptedFields) )
                                {
                                        AcceptedFieldConnections.push_back( VAI );
                                }
                        }
                } 
 
                return AcceptedFieldConnections;
        }
};
 
} // namespace Wizt
 
#endif /* __FISH_FISHOBJECT_HPP */