libmvrgdtf/_g_d_t_f_manager_8h_source.html

//-----------------------------------------------------------------------------

//----- Copyright deersoft 2015 - 2017 www.deersoft.de

//-----------------------------------------------------------------------------

#pragma once

#include "Prefix/StdAfx.h"

#include "CieColor.h"

#include "GdtfError.h"

#include "Include/GDTFPrefix.h"


using namespace VectorworksMVR::Filing;

using namespace VectorworksMVR::GdtfDefines;


typedef VectorworksMVR::VWFC::Tools::VWUUID GdtfFixtureGUID;

typedef TXString                            GdtfPNGFile;

typedef TXString                            Gdtf3DSFile;

typedef Sint32                              StatusID;


namespace SceneData

{

    // Forward declarations

    class GdtfPhysicalEmitter;

    typedef GdtfPhysicalEmitter*                GdtfPhysicalEmitterPtr;

    typedef std::vector<GdtfPhysicalEmitter*>   TGdtfPhysicalEmitterArray;


    class GdtfFeatureGroup;

    class GdtfAttribute;

    class GdtfWheel;

    class GdtfFixture;

    class GdtfDmxLogicalChannel;

    class GdtfDmxChannel;

    class GdtfMacroDMX;

    class GdtfMacroVisual;

    class GdtfDmxChannelFunction;

    class GdtfFTRDM;

    class GdtfArtNet;

    class GdtfsAcn;

    class GdtfKiNET;

    class GdtfPosiStageNet;

    class GdtfOpenSoundControl;

    class GdtfCITP;

    class GdtfDmxMode;

    class GdtfSoftwareVersionID;

    typedef std::vector<GdtfSoftwareVersionID*> TGdtfSoftwareVersionIDArray;

    typedef GdtfSoftwareVersionID*  GdtfSoftwareVersionIDPtr;


    class GdtfDMXProfile;

    typedef GdtfDMXProfile* GdtfDMXProfilePtr;

    typedef std::vector<GdtfDMXProfile*>    TGdtfDMXProfileArray;


    class GdtfCRIGroup;

    typedef GdtfCRIGroup*   GdtfCRIGroupPtr;

    typedef std::vector<GdtfCRIGroup*>  TGdtf_CRIGroupArray;


    class GdtfMeasurementPoint;

    class GdtfMeasurement; typedef std::vector<GdtfMeasurement*>    TGdtfMeasurementArray;


    class GdtfFilter;

    typedef GdtfFilter* GdtfFilterPtr;

    typedef std::vector<GdtfFilter*>    TGdtfFilterArray;


    class GdtfConnector;

    typedef GdtfConnector*  GdtfConnectorPtr;

    typedef std::vector<GdtfConnector*> TGdtfConnectorArray;


    class GdtfGeometryWiringObject;

    typedef GdtfGeometryWiringObject* GdtfGeometryWiringObjectPtr;


    const Sint32 kDmxBreakOverwriteValue = 0;

    //------------------------------------------------------------------------------------

    // Attributes


    class GdtfObject

    {

    public:

                                        GdtfObject();

        virtual                         ~GdtfObject();


    private:

        void*                           fBindValue;

        IXMLFileNodePtr                 fNode;

        bool                            fAbortReading = false;


    public:

        // Write

        void                            WriteToNode(IXMLFileNodePtr pContainerNode);

        void                            ReadFromNode(const IXMLFileNodePtr& pNode);


        void                            GetNode(IXMLFileNodePtr& pNode);


        static void                     SetAbortCallback( const std::function<void( bool& )>& cb );


        // Bind Behavoir

        void                            SetBind(void* ptr);

        void*                           GetBind();


    public:

        virtual EGdtfObjectType         GetObjectType() = 0;

        virtual TXString                GetNodeReference();


    protected:

        virtual TXString                GetNodeName() = 0;


        virtual void                    OnPrintToFile(IXMLFileNodePtr pNode);

        virtual void                    OnReadFromNode(const IXMLFileNodePtr& pNode);

        virtual void                    OnErrorCheck(const IXMLFileNodePtr& pNode);


        bool                            CheckAbort();


    };


    //------------------------------------------------------------------------------------

    // Attribute Definitions


    //------------------------------------------------------------------------------------

    // GdtfActivationGroup


    class GdtfActivationGroup : public GdtfObject

    {

    public:

                                            GdtfActivationGroup();

                                            GdtfActivationGroup(const TXString& name);

                                            ~GdtfActivationGroup();


    private:

        TXString                            fName;


        std::vector<GdtfAttribute*>         fLinkedAttributes;


    public:


    public:

        const TXString&                     GetName() const;

        virtual EGdtfObjectType             GetObjectType();

        virtual TXString                    GetNodeReference();


        void                                SetName(const TXString& name);


        const std::vector<GdtfAttribute*>&  GetLinkedAttributes() const;

        void                                AddLinkedAttribute(GdtfAttribute* attr);


    protected:

        virtual TXString                    GetNodeName();

        virtual void                        OnPrintToFile(IXMLFileNodePtr pNode);

        virtual void                        OnReadFromNode(const IXMLFileNodePtr& pNode);

        virtual void                        OnErrorCheck(const IXMLFileNodePtr& pNode);


    };


    typedef GdtfActivationGroup*                GdtfActivationGroupPtr;

    typedef std::vector<GdtfActivationGroupPtr> TGdtfActivationGroupArray;


    //------------------------------------------------------------------------------------

    // Feature Groups


    class GdtfFeature : public GdtfObject

    {

    public:

                                                GdtfFeature(GdtfFeatureGroup* parent);

                                                ~GdtfFeature();


    private:

        TXString                                fName;

        GdtfFeatureGroup*                       fParent;


        std::vector<GdtfAttribute*>             fLinkedAttributes;


    public:

        const TXString&                         GetName() const;

        GdtfFeatureGroup*                       GetFeatureGroup() const;

        void                                    SetName(const TXString& name);


        const std::vector<GdtfAttribute*>&      GetLinkedAttributes() const;

        void                                    AddLinkedAttribute(GdtfAttribute* attr);


    public:

        virtual EGdtfObjectType                 GetObjectType();

        virtual TXString                        GetNodeReference();


    protected:

        virtual TXString                        GetNodeName();

        virtual void                            OnPrintToFile(IXMLFileNodePtr pNode);

        virtual void                            OnReadFromNode(const IXMLFileNodePtr& pNode);

        virtual void                            OnErrorCheck(const IXMLFileNodePtr& pNode);


    };


    typedef GdtfFeature*                GdtfFeaturePtr;

    typedef std::vector<GdtfFeature*>   TGdtfFeatureArray;


    class GdtfFeatureGroup : public GdtfObject

    {

    public:

                                                GdtfFeatureGroup();

                                                GdtfFeatureGroup(const TXString& name, const TXString& prettyName);

                                                ~GdtfFeatureGroup();


    private:

        TXString                                fName;

        TXString                                fPrettyName;

        //

        TGdtfFeatureArray                       fFeatures;


    public:


    public:

        const TXString&                         GetName() const;

        const TXString&                         GetPrettyName() const;

        const TGdtfFeatureArray                 GetFeatureArray();

        virtual EGdtfObjectType                 GetObjectType();


        GdtfFeature*                            AddFeature(const TXString& name);

        void                                    SetName(const TXString& name);

        void                                    SetPrettyName(const TXString& prettyName);


    protected:

        virtual TXString                        GetNodeName();

        virtual void                            OnPrintToFile(IXMLFileNodePtr pNode);

        virtual void                            OnReadFromNode(const IXMLFileNodePtr& pNode);

        virtual void                            OnErrorCheck(const IXMLFileNodePtr& pNode);


    };


    typedef GdtfFeatureGroup*               GdtfFeatureGroupPtr;

    typedef std::vector<GdtfFeatureGroupPtr>TGdtfFeatureGroupArray;


    class GdtfSubPhysicalUnit : public GdtfObject

    {

    public:

                                                GdtfSubPhysicalUnit();

                                                GdtfSubPhysicalUnit(EGdtfSubPhysicalUnitType type);

                                                ~GdtfSubPhysicalUnit();


    private:

        EGdtfSubPhysicalUnitType                fType;

        EGdtfPhysicalUnit                       fPhysicalUnit;

        double                                  fPhysicalFrom;

        double                                  fPhysicalTo;


    private:


    public:

        // Getter

        EGdtfSubPhysicalUnitType                GetType() const;

        EGdtfPhysicalUnit                       GetPhysicalUnit() const;

        double                                  GetPhysicalFrom() const;

        double                                  GetPhysicalTo() const;

        // Setter

        void                                    SetType(const EGdtfSubPhysicalUnitType& type);

        void                                    SetPhysicalUnit(const EGdtfPhysicalUnit& physicalUnit);

        void                                    SetPhysicalFrom(double physicalFrom);

        void                                    SetPhysicalTo(double physicalTo);


        virtual EGdtfObjectType                 GetObjectType();

        virtual TXString                        GetNodeReference();


    protected:

        virtual TXString                        GetNodeName();

        virtual void                            OnPrintToFile(IXMLFileNodePtr pNode);

        virtual void                            OnReadFromNode(const IXMLFileNodePtr& pNode);

        virtual void                            OnErrorCheck(const IXMLFileNodePtr& pNode);


    };


    typedef GdtfSubPhysicalUnit*                GdtfSubPhysicalUnitPtr;

    typedef std::vector<GdtfSubPhysicalUnit*>   TGdtfSubPhysicalUnitArray;


    class GdtfAttribute : public GdtfObject

    {

    public:

                                                GdtfAttribute(const TXString& name, const TXString& prettyName);

                                                GdtfAttribute();

                                                ~GdtfAttribute();

    private:

        // Attributes

        TXString                                fName;

        TXString                                fPrettyName;

        GdtfActivationGroupPtr                  fActivationGroup;

        GdtfFeaturePtr                          fFeature;

        GdtfAttribute*                          fMainAttribute;

        EGdtfPhysicalUnit                       fPhysicalUnit;

        CCieColor                               fColor;

        bool                                    fHasColor;

        // Children

        TGdtfSubPhysicalUnitArray               fSubPhysicalUnits;


    private:

        // Unresolved Ptrs

        TXString                                fUnresolvedActGroup;

        TXString                                fUnresolvedFeature;

        TXString                                fUnresolvedMainAttrib;


    public:

        // Getter

        const TXString&                         GetName() const;

        const TXString&                         GetPrettyName() const;

        GdtfActivationGroupPtr                  GetActivationGroup() const;

        GdtfFeaturePtr                          GetFeature() const;

        GdtfAttribute*                          GetMainAttribute();

        EGdtfPhysicalUnit                       GetPhysicalUnit();

        CCieColor                               GetColor();

        bool                                    HasColor() const;

        TGdtfSubPhysicalUnitArray               GetSubPhysicalUnitArray() const;


        // Setters

        void                                    SetName(const TXString& name);

        void                                    SetPrettyName(const TXString& name);

        void                                    SetFeature(GdtfFeaturePtr newFeat);

        void                                    SetActivationGroup(GdtfActivationGroupPtr ptr);

        void                                    SetMainAttribute(GdtfAttribute* attr);

        void                                    SetPhysicalUnit(EGdtfPhysicalUnit unit);

        void                                    SetColor(const CCieColor & col);

        GdtfSubPhysicalUnitPtr                  CreateSubPhysicalUnit(EGdtfSubPhysicalUnitType type);


        virtual EGdtfObjectType                 GetObjectType();

        virtual TXString                        GetNodeReference();


        const TXString&                         GetUnresolvedActGroup() const;

        const TXString&                         GetUnresolvedFeature() const;

        const TXString&                         GetUnresolvedMainAttribute() const;


    protected:

        virtual TXString                        GetNodeName();

        virtual void                            OnPrintToFile(IXMLFileNodePtr pNode);

        virtual void                            OnReadFromNode(const IXMLFileNodePtr& pNode);

        virtual void                            OnErrorCheck(const IXMLFileNodePtr& pNode);


    };


    typedef GdtfAttribute*              GdtfAttributePtr;

    typedef std::vector<GdtfAttribute*> TGdtfAttributeArray;


    //------------------------------------------------------------------------------------

    // Wheel Definition


    class GdtfWheelSlotPrismFacet : public GdtfObject

    {

    public:

                                                GdtfWheelSlotPrismFacet();

                                                ~GdtfWheelSlotPrismFacet();

    private:

        CCieColor                               fColor;

        VWTransformMatrix                       fTransform; // RotationMatrix


    public:

        CCieColor                               GetColor();

        VWTransformMatrix                       GetTransformMatrix();


        void                                    SetColor(const CCieColor& color);

        void                                    SetTransformMatrix(const VWTransformMatrix& ma);

    public:

        virtual EGdtfObjectType                 GetObjectType();


    protected:

        virtual TXString                        GetNodeName();

        virtual void                            OnPrintToFile(IXMLFileNodePtr pNode);

        virtual void                            OnReadFromNode(const IXMLFileNodePtr& pNode);

        virtual void                            OnErrorCheck(const IXMLFileNodePtr& pNode);


    };


    typedef GdtfWheelSlotPrismFacet*                GdtfWheelSlotPrismFacetPtr;

    typedef std::vector<GdtfWheelSlotPrismFacetPtr> TGdtfWheelSlotPrismFacetArray;


    class GdtfWheelSlotAnimationSystem : public GdtfObject

    {

    public:

                                                GdtfWheelSlotAnimationSystem();

                                                ~GdtfWheelSlotAnimationSystem();

    private:

        double                                  fP1_X;

        double                                  fP1_Y;

        double                                  fP2_X;

        double                                  fP2_Y;

        double                                  fP3_X;

        double                                  fP3_Y;

        double                                  fRadius;


    public:

        double                                  GetP1_X();

        double                                  GetP1_Y();

        double                                  GetP2_X();

        double                                  GetP2_Y();

        double                                  GetP3_X();

        double                                  GetP3_Y();

        double                                  GetRadius();


        void                                    SetP1_X(double p1_X);

        void                                    SetP1_Y(double p1_Y);

        void                                    SetP2_X(double p2_X);

        void                                    SetP2_Y(double p2_Y);

        void                                    SetP3_X(double p3_X);

        void                                    SetP3_Y(double p3_Y);

        void                                    SetRadius(double radius);

    public:

        virtual EGdtfObjectType                 GetObjectType();


    protected:

        virtual TXString                        GetNodeName();

        virtual void                            OnPrintToFile(IXMLFileNodePtr pNode);

        virtual void                            OnReadFromNode(const IXMLFileNodePtr& pNode);

        virtual void                            OnErrorCheck(const IXMLFileNodePtr& pNode);

    };


    typedef GdtfWheelSlotAnimationSystem*               GdtfWheelSlotAnimationSystemPtr;


    class GdtfWheelSlot : public GdtfObject

    {

    public:


                                                GdtfWheelSlot(GdtfWheel* parent);

                                                GdtfWheelSlot(const TXString& name, GdtfWheel* parent);

                                                ~GdtfWheelSlot();


    private:

        TXString                                fName;

        CCieColor                               fColor;

        TXString                                fGobo;

        TGdtfWheelSlotPrismFacetArray           fPrismFacts;

        GdtfWheel*                              fWheelParent;

        TXString                                fGoboFile; // MediaFileName

        GdtfFilter*                             fFilter;

        TXString                                fUnresolvedFilter;

        GdtfWheelSlotAnimationSystem*           fAnimationSystem;


    public:

        const TXString&                         GetGobo() const;

        const TXString&                         GetGoboFileFullPath();

        CCieColor                               GetColor() const;

        const TXString&                         GetName() const;

        TGdtfWheelSlotPrismFacetArray           GetPrismFacets();

        GdtfFilter*                             GetFilter() const;

        GdtfWheelSlotAnimationSystem*           GetAnimationSystem() const;


        void                                    SetName(const TXString& name);

        void                                    SetGobo(const GdtfPNGFile& png);

        void                                    SetColor(const CCieColor& color);

        void                                    SetFilter(GdtfFilter* filter);

        GdtfWheelSlotPrismFacet*                AddPrismFacet();

        GdtfWheelSlotAnimationSystem*           AddAnimationSystem();


        virtual TXString                        GetNodeReference();


        const TXString&                         GetUnresolvedFilter() const;


    public:

        virtual EGdtfObjectType                 GetObjectType();


    protected:

        virtual TXString                        GetNodeName();

        virtual void                            OnPrintToFile(IXMLFileNodePtr pNode);

        virtual void                            OnReadFromNode(const IXMLFileNodePtr& pNode);

        virtual void                            OnErrorCheck(const IXMLFileNodePtr& pNode);


    };


    typedef GdtfWheelSlot*                  GdtfWheelSlotPtr;

    typedef std::vector<GdtfWheelSlotPtr>   TGdtfWheelSlotArray;


    class GdtfColorSpace : public GdtfObject

    {

    public:

                                                GdtfColorSpace();

                                                GdtfColorSpace(const TXString& name, EGdtfColorSpace colorSpace);

                                                ~GdtfColorSpace();

    private:

        EGdtfColorSpace                         fColorSpace;


        TXString                                fUniqueName;

        CCieColor                               fRed;

        CCieColor                               fGreen;

        CCieColor                               fBlue;

        CCieColor                               fWhitePoint;

    public:

        virtual EGdtfObjectType                 GetObjectType();

        virtual TXString                        GetNodeReference();


    public:

        // Getter

        const TXString&                         GetName() const;

        EGdtfColorSpace                         GetColorSpace();

        CCieColor                               GetRed();

        CCieColor                               GetGreen();

        CCieColor                               GetBlue();

        CCieColor                               GetWhite();

        // Setter

        void                                    SetName(const TXString& name);

        void                                    SetColorSpace(EGdtfColorSpace val);

        void                                    SetRed(CCieColor val);

        void                                    SetGreen(CCieColor val);

        void                                    SetBlue(CCieColor val);

        void                                    SetWhite(CCieColor val);

    protected:

        virtual TXString                        GetNodeName();

        virtual void                            OnPrintToFile(IXMLFileNodePtr pNode);

        virtual void                            OnReadFromNode(const IXMLFileNodePtr& pNode);

        virtual void                            OnErrorCheck(const IXMLFileNodePtr& pNode);


    };


    typedef GdtfColorSpace*                 GdtfColorSpacePtr;

    typedef std::vector<GdtfColorSpace*>    TGdtfColorSpaceArray;


    class GdtfGamut : public GdtfObject

    {

    public:

                                                GdtfGamut();

                                                GdtfGamut(const TXString& name, CCieColorPtr color);

                                                ~GdtfGamut();

    private:

        TXString                                fUniqueName;

        TCCieColorArray                         fGamutPoints;

    public:

        virtual EGdtfObjectType                 GetObjectType();

        virtual TXString                        GetNodeReference();

    public:

        // Getters

        const TXString&                         GetName() const;

        const TCCieColorArray&                  GetGamutPoints() const;

        // Setters

        void                                    SetName(const TXString& name);

        void                                    AddGamutPoint(CCieColorPtr newPoint);

    protected:

        virtual TXString                        GetNodeName();

        virtual void                            OnPrintToFile(IXMLFileNodePtr pNode);

        virtual void                            OnReadFromNode(const IXMLFileNodePtr& pNode);

        virtual void                            OnErrorCheck(const IXMLFileNodePtr& pNode);

    };


    typedef GdtfGamut*                  GdtfGamutPtr;

    typedef std::vector<GdtfGamutPtr>   TGdtfGamutArray;


    class GdtfPhysicalDescriptions : public GdtfObject

    {

    public:

                                                GdtfPhysicalDescriptions();

                                                ~GdtfPhysicalDescriptions();

    private:

        GdtfColorSpace                          fColorSpace;

        TGdtfColorSpaceArray                    fAdditionalColorSpaces;

        TGdtfGamutArray                         fGamuts;

        TGdtfPhysicalEmitterArray               fEmitters;

        TGdtfFilterArray                        fFilters;

        TGdtfDMXProfileArray                    fDmxProfiles;

        TGdtf_CRIGroupArray                     fCRI_Groups;

        TGdtfConnectorArray                     fConnectors;


        //Properties Collect

        double                                  fOperatingTemperatureLow;

        double                                  fOperatingTemperatureHigh;

        double                                  fWeight;

        double                                  fLegHeight;


    public:

        virtual EGdtfObjectType                 GetObjectType();


    public:

        // Getter

        GdtfColorSpace*                         GetColorSpace();


        const TGdtfColorSpaceArray&             GetAdditionalColorSpaceArray();

        const TGdtfGamutArray&                  GetGamutArray();

        const TGdtfPhysicalEmitterArray&        GetPhysicalEmitterArray();

        const TGdtfFilterArray&                 GetFilterArray();

        const TGdtfDMXProfileArray&             GetDmxProfileArray();

        const TGdtf_CRIGroupArray&              GetCRIGroupArray();

        const TGdtfConnectorArray&              GetConnectorArray();

        double                                  GetOperatingTemperatureLow();

        double                                  GetOperatingTemperatureHigh();

        double                                  GetWeight();

        double                                  GetLegHeight();


        void                                    SetOperatingTemperatureLow(double value);

        void                                    SetOperatingTemperatureHigh(double value);

        void                                    SetWeight(double value);

        void                                    SetLegHeight(double value);


        GdtfColorSpacePtr                       AddAdditionalColorSpace(const TXString& name, EGdtfColorSpace colorSpace);

        GdtfGamutPtr                            AddGamut(const TXString& name, CCieColorPtr color);

        GdtfPhysicalEmitterPtr                  AddEmitter(const TXString& name, CCieColor color);

        GdtfFilterPtr                           AddFilter(const TXString& name,  CCieColor color);

        GdtfDMXProfilePtr                       AddDmxProfile();

        GdtfCRIGroupPtr                         AddCRIGroup(double colorTsemp);

        GdtfConnectorPtr                        AddConnector(const TXString& name,  const TXString& type);


    protected:

        virtual TXString                        GetNodeName();

        virtual void                            OnPrintToFile(IXMLFileNodePtr pNode);

        virtual void                            OnReadFromNode(const IXMLFileNodePtr& pNode);

    };


    typedef GdtfPhysicalDescriptions*   GdtfPhysicalDescriptionsPtr;


    class GdtfFilter : public GdtfObject

    {

    public:

                                                GdtfFilter();

                                                GdtfFilter(const TXString& name, const CCieColor& col);

                                                ~GdtfFilter();

    private:

        TXString                                fName;

        CCieColor                               fColor;

        TGdtfMeasurementArray                   fMeasurementsArray;

    public:

        virtual EGdtfObjectType                 GetObjectType();

        virtual TXString                        GetNodeReference();

    public:

        const TXString&                         GetName();

        CCieColor                               GetColor();

        const TGdtfMeasurementArray&            GetMeasurementsArray();

        // Setter

        void                                    SetName(const TXString& name);

        void                                    SetColor(CCieColor val);

        GdtfMeasurement*                        CreateMeasurement();

    protected:

        virtual TXString                        GetNodeName();

        virtual void                            OnPrintToFile(IXMLFileNodePtr pNode);

        virtual void                            OnReadFromNode(const IXMLFileNodePtr& pNode);

    };


    class GdtfWheel : public GdtfObject

    {

    public:

                                                GdtfWheel(GdtfFixture* parentFixture);

                                                GdtfWheel(GdtfFixture* parentFixture, const TXString& name);

                                                ~GdtfWheel();

    private:

        TXString                                fName;

        TGdtfWheelSlotArray                     fWheelSlots;

        GdtfFixture*                            fParentFixture;

    public:

        GdtfWheelSlotPtr                        AddWheelSlot(const TXString& name);


        void                                    SetName(const TXString& name);

        const TXString&                         GetName() const;


        const TGdtfWheelSlotArray&              GetWheelSlotArray() const;

        bool                                    IsGoboWheel() const;

        virtual TXString                        GetNodeReference();


        GdtfFixture*                            GetParentFixture() const;


    public:

        virtual EGdtfObjectType                 GetObjectType();


    protected:

        virtual TXString                        GetNodeName();

        virtual void                            OnPrintToFile(IXMLFileNodePtr pNode);

        virtual void                            OnReadFromNode(const IXMLFileNodePtr& pNode);

        virtual void                            OnErrorCheck(const IXMLFileNodePtr& pNode);


    };


    typedef GdtfWheel*                  GdtfWheelPtr;

    typedef std::vector<GdtfWheelPtr>   TGdtfWheelArray;


    //------------------------------------------------------------------------------------

    // Model Defintion


    class GdtfModel : public GdtfObject

    {

    public:

                                                GdtfModel(GdtfFixture* fixture);

                                                GdtfModel(const TXString& name, GdtfFixture* fixture);

                                                ~GdtfModel();

    private:

        TXString                                fUniqueName;

        double                                  fLength;

        double                                  fWidth;

        double                                  fHeight;

        EGdtfModel_PrimitiveType                fPrimitiveType;

        TXString                                fGeometryFile;  // FileName without the extension.

        TXString                                fFullPath3DS;

        TXString                                fFullPathSVG;

        TXString                                fFullPathGLTF;


        char*                                   fBuffer3DS;

        char*                                   fBufferSVG;

        char*                                   fBufferGLTF;


        size_t                                  fBufferSize3DS;

        size_t                                  fBufferSizeSVG;

        size_t                                  fBufferSizeGLTF;


        double                                  fSVGOffsetX;

        double                                  fSVGOffsetY;

        double                                  fSVGSideOffsetX;

        double                                  fSVGSideOffsetY;

        double                                  fSVGFrontOffsetX;

        double                                  fSVGFrontOffsetY;

        //

        GdtfFixture*                            fParentFixture;


    public:

        // Getter

        const TXString&                         GetName() const;

        double                                  GetLength() const;

        double                                  GetWidth() const;

        double                                  GetHeight() const;

        EGdtfModel_PrimitiveType                GetPrimitiveType() const;

        //

        const TXString&                         GetGeometryFileName() const;

        const TXString&                         GetGeometryFile_3DS_FullPath();

        const TXString&                         GetGeometryFile_3DSLow_FullPath();

        const TXString&                         GetGeometryFile_3DSHigh_FullPath();

        const TXString&                         GetGeometryFile_SVG_FullPath();

        const TXString&                         GetGeometryFile_SVGSide_FullPath();

        const TXString&                         GetGeometryFile_SVGFront_FullPath();

        const TXString&                         GetGeometryFile_GLTF_FullPath();

        const TXString&                         GetGeometryFile_GLTFLow_FullPath();

        const TXString&                         GetGeometryFile_GLTFHigh_FullPath();


        void                                    GetBuffer3DS(void** bufferToCopy, size_t& length);

        void                                    GetBufferSVG(void** bufferToCopy, size_t& length);

        void                                    GetBufferGLTF(void** bufferToCopy, size_t& length);


        double                                  GetSVGOffsetX() const;

        double                                  GetSVGOffsetY() const;

        double                                  GetSVGSideOffsetX() const;

        double                                  GetSVGSideOffsetY() const;

        double                                  GetSVGFrontOffsetX() const;

        double                                  GetSVGFrontOffsetY() const;


        // Setter

        void                                    SetName(const TXString& name);

        void                                    SetLength(const double& length);

        void                                    SetWidth(const double& width);

        void                                    SetHeight(const double& height);

        void                                    SetPrimitiveType(const EGdtfModel_PrimitiveType& type);

        void                                    SetGeometryFile(const TXString& file);


        void                                    SetBuffer3DS(void* bufferToCopy, size_t length);

        void                                    SetBufferSVG(void* bufferToCopy, size_t length);

        void                                    SetBufferGLTF(void* bufferToCopy, size_t length);


        void                                    SetSVGOffsetX(double svgOffsetX);

        void                                    SetSVGOffsetY(double svgOffsetY);

        void                                    SetSVGSideOffsetX(double svgSideOffsetX);

        void                                    SetSVGSideOffsetY(double svgSideOffsetY);

        void                                    SetSVGFrontOffsetX(double svgFrontOffsetX);

        void                                    SetSVGFrontOffsetY(double svgFrontOffsetY);


    public:

        virtual EGdtfObjectType                 GetObjectType();

        virtual TXString                        GetNodeReference();


    protected:

        virtual TXString                        GetNodeName();

        virtual void                            OnPrintToFile(IXMLFileNodePtr pNode);

        virtual void                            OnReadFromNode(const IXMLFileNodePtr& pNode);

        virtual void                            OnErrorCheck(const IXMLFileNodePtr& pNode);


    };


    typedef GdtfModel*                  GdtfModelPtr;

    typedef std::vector<GdtfModelPtr>   TGdtfModelArray;


    //------------------------------------------------------------------------------------

    // Geometry Definition

    class GdtfGeometryAxis;

    class GdtfGeometryBeamFilter;

    class GdtfGeometryColorFilter;

    class GdtfGeometryGoboFilter;

    class GdtfGeometryShaperFilter;

    class GdtfGeometryLamp;


    class GdtfGeometry : public GdtfObject

    {

    public:

                                                GdtfGeometry(GdtfGeometry* parent);

                                                GdtfGeometry(const TXString& name, GdtfModelPtr refToModel,const VWTransformMatrix& ma, GdtfGeometry* parent);

                                                ~GdtfGeometry();

    private:

        TXString                                fUniqueName;

        GdtfModelPtr                            fModelReference;

        TXString                                fUnresolvedModelRef;

        VWTransformMatrix                       fMatrix;

        std::vector<GdtfGeometry*>              fInternalGeometries;

        GdtfGeometry*                           fParent;


    public:

        // Getter

        const TXString&                         GetName() const;

        GdtfModelPtr                            GetModelRef() const;

        void                                    GetTransformMatrix(VWTransformMatrix& ma) const;

        const std::vector<GdtfGeometry*>        GetInternalGeometries();

        virtual TXString                        GetNodeReference();

        GdtfGeometry*                           GetParentGeometry();


        // Setter

        void                                    SetName(const TXString& name);

        void                                    SetModel(GdtfModelPtr model);

        void                                    SetTransformMatrix(const VWTransformMatrix& ma);


        GdtfGeometry*                           AddGeometry(                    const TXString& name, GdtfModelPtr refToModel, const VWTransformMatrix& ma);

        GdtfGeometry*                           AddGeometryReference(           const TXString& name, GdtfModelPtr refToModel, const VWTransformMatrix& ma);

        GdtfGeometry*                           AddGeometryShaper(              const TXString& name, GdtfModelPtr refToModel, const VWTransformMatrix& ma);

        GdtfGeometry*                           AddGeometryColor(               const TXString& name, GdtfModelPtr refToModel, const VWTransformMatrix& ma);

        GdtfGeometry*                           AddGeometryGobo(                const TXString& name, GdtfModelPtr refToModel, const VWTransformMatrix& ma);

        GdtfGeometry*                           AddGeometryBeam(                const TXString& name, GdtfModelPtr refToModel, const VWTransformMatrix& ma);

        GdtfGeometry*                           AddGeometryMediaServerCamera(   const TXString& name, GdtfModelPtr refToModel, const VWTransformMatrix& ma);

        GdtfGeometry*                           AddGeometryMediaServerLayer(    const TXString& name, GdtfModelPtr refToModel, const VWTransformMatrix& ma);

        GdtfGeometry*                           AddGeometryMediaServerMaster(   const TXString& name, GdtfModelPtr refToModel, const VWTransformMatrix& ma);

        GdtfGeometry*                           AddGeometryWithAxis(            const TXString& name, GdtfModelPtr refToModel, const VWTransformMatrix& ma);

        GdtfGeometry*                           AddGeometryWithLamp(            const TXString& name, GdtfModelPtr refToModel, const VWTransformMatrix& ma);

        GdtfGeometry*                           AddGeometryDisplay(             const TXString& name, GdtfModelPtr refToModel, const VWTransformMatrix& ma);

        GdtfGeometry*                           AddGeometryLaser(               const TXString& name, GdtfModelPtr refToModel, const VWTransformMatrix& ma);

        GdtfGeometry*                           AddGeometryWiringObject(        const TXString& name, GdtfModelPtr refToModel, const VWTransformMatrix& ma);

        GdtfGeometry*                           AddGeometryInventory(           const TXString& name, GdtfModelPtr refToModel, const VWTransformMatrix& ma);

        GdtfGeometry*                           AddGeometryStructure(           const TXString& name, GdtfModelPtr refToModel, const VWTransformMatrix& ma);

        GdtfGeometry*                           AddGeometrySupport(             const TXString& name, GdtfModelPtr refToModel, const VWTransformMatrix& ma);

        GdtfGeometry*                           AddGeometryMagnet(              const TXString& name, GdtfModelPtr refToModel, const VWTransformMatrix& ma);


    protected:

        virtual TXString                        GetNodeName();

        virtual void                            OnPrintToFile(IXMLFileNodePtr pNode);

        virtual void                            OnReadFromNode(const IXMLFileNodePtr& pNode);

        virtual void                            OnErrorCheck(const IXMLFileNodePtr& pNode);


    public:

        virtual EGdtfObjectType                 GetObjectType();


    public:

        //----------------------------------------------------------------------------------------------------------------------------------------------------------------

        // Resolve Model Ref

        TXString                                GetUnresolvedModelRef() const;

        void                                    SetUnresolvedModelRef(GdtfModelPtr ref);

    };


    typedef GdtfGeometry*                   GdtfGeometryPtr;

    typedef std::vector<GdtfGeometryPtr>    TGdtfGeometryArray;


    class GdtfGeometryAxis : public GdtfGeometry

    {

    public:

                                                GdtfGeometryAxis(GdtfGeometry* parent);

                                                GdtfGeometryAxis(const TXString& name, GdtfModelPtr refToModel,const VWTransformMatrix& ma, GdtfGeometry* parent);

                                                ~GdtfGeometryAxis();


    private:


    public:

        virtual EGdtfObjectType                 GetObjectType();


    protected:

        virtual TXString                        GetNodeName();

        virtual void                            OnPrintToFile(IXMLFileNodePtr pNode);

        virtual void                            OnReadFromNode(const IXMLFileNodePtr& pNode);

        virtual void                            OnErrorCheck(const IXMLFileNodePtr& pNode);

    };


    class GdtfGeometryBeamFilter : public GdtfGeometry

    {

    public:

                                                GdtfGeometryBeamFilter(GdtfGeometry* parent);

                                                GdtfGeometryBeamFilter(const TXString& name, GdtfModelPtr refToModel,const VWTransformMatrix& ma, GdtfGeometry* parent);

                                                ~GdtfGeometryBeamFilter();

    public:

        virtual EGdtfObjectType                 GetObjectType();

    protected:

        virtual TXString                        GetNodeName();

        virtual void                            OnPrintToFile(IXMLFileNodePtr pNode);

        virtual void                            OnReadFromNode(const IXMLFileNodePtr& pNode);

        virtual void                            OnErrorCheck(const IXMLFileNodePtr& pNode);

    };


    class GdtfGeometryColorFilter : public GdtfGeometry

    {

    public:

                                                GdtfGeometryColorFilter(GdtfGeometry* parent);

                                                GdtfGeometryColorFilter(const TXString& name, GdtfModelPtr refToModel,const VWTransformMatrix& ma, GdtfGeometry* parent);

                                                ~GdtfGeometryColorFilter();

    public:

        virtual EGdtfObjectType                 GetObjectType();

    protected:

        virtual TXString                        GetNodeName();

        virtual void                            OnPrintToFile(IXMLFileNodePtr pNode);

        virtual void                            OnReadFromNode(const IXMLFileNodePtr& pNode);

        virtual void                            OnErrorCheck(const IXMLFileNodePtr& pNode);

    };


    class GdtfGeometryGoboFilter : public GdtfGeometry

    {

    public:

                                                GdtfGeometryGoboFilter(GdtfGeometry* parent);

                                                GdtfGeometryGoboFilter( const TXString& name, GdtfModelPtr refToModel, const VWTransformMatrix& ma, GdtfGeometry* parent );

                                                ~GdtfGeometryGoboFilter();

    public:

        virtual EGdtfObjectType                 GetObjectType();

    protected:

        virtual TXString                        GetNodeName();

        virtual void                            OnPrintToFile(IXMLFileNodePtr pNode);

        virtual void                            OnReadFromNode(const IXMLFileNodePtr& pNode);

        virtual void                            OnErrorCheck(const IXMLFileNodePtr& pNode);

    };


    class GdtfGeometryShaperFilter : public GdtfGeometry

    {

    public:

                                                GdtfGeometryShaperFilter(GdtfGeometry* parent);

                                                GdtfGeometryShaperFilter(const TXString& name, GdtfModelPtr refToModel,const VWTransformMatrix& ma, GdtfGeometry* parent);

                                                ~GdtfGeometryShaperFilter();

    public:

        virtual EGdtfObjectType                 GetObjectType();

    protected:

        virtual TXString                        GetNodeName();

        virtual void                            OnPrintToFile(IXMLFileNodePtr pNode);

        virtual void                            OnReadFromNode(const IXMLFileNodePtr& pNode);

        virtual void                            OnErrorCheck(const IXMLFileNodePtr& pNode);

    };


    class GdtfGeometryMediaServerCamera : public GdtfGeometry

    {

    public:

                                                GdtfGeometryMediaServerCamera(GdtfGeometry* parent);

                                                GdtfGeometryMediaServerCamera( const TXString& name, GdtfModelPtr refToModel, const VWTransformMatrix& ma, GdtfGeometry* parent );

                                                ~GdtfGeometryMediaServerCamera();

    public:

        virtual EGdtfObjectType                 GetObjectType();

    protected:

        virtual TXString                        GetNodeName();

        virtual void                            OnPrintToFile(IXMLFileNodePtr pNode);

        virtual void                            OnReadFromNode(const IXMLFileNodePtr& pNode);

        virtual void                            OnErrorCheck(const IXMLFileNodePtr& pNode);

    };


    class GdtfGeometryMediaServerLayer : public GdtfGeometry

    {

    public:

                                                GdtfGeometryMediaServerLayer(GdtfGeometry* parent);

                                                GdtfGeometryMediaServerLayer(const TXString& name, GdtfModelPtr refToModel,const VWTransformMatrix& ma, GdtfGeometry* parent);

                                                ~GdtfGeometryMediaServerLayer();

    public:

        virtual EGdtfObjectType                 GetObjectType();

    protected:

        virtual TXString                        GetNodeName();

        virtual void                            OnPrintToFile(IXMLFileNodePtr pNode);

        virtual void                            OnReadFromNode(const IXMLFileNodePtr& pNode);

        virtual void                            OnErrorCheck(const IXMLFileNodePtr& pNode);

    };


    class GdtfGeometryMediaServerMaster : public GdtfGeometry

    {

    public:

                                                GdtfGeometryMediaServerMaster(GdtfGeometry* parent);

                                                GdtfGeometryMediaServerMaster(const TXString& name, GdtfModelPtr refToModel,const VWTransformMatrix& ma, GdtfGeometry* parent);

                                                ~GdtfGeometryMediaServerMaster();

    public:

        virtual EGdtfObjectType                 GetObjectType();

    protected:

        virtual TXString                        GetNodeName();

        virtual void                            OnPrintToFile(IXMLFileNodePtr pNode);

        virtual void                            OnReadFromNode(const IXMLFileNodePtr& pNode);

        virtual void                            OnErrorCheck(const IXMLFileNodePtr& pNode);

    };


    class GdtfGeometryDisplay : public GdtfGeometry

    {

    public:

                                                GdtfGeometryDisplay(GdtfGeometry* parent);

                                                GdtfGeometryDisplay(const TXString& name, GdtfModelPtr refToModel,const VWTransformMatrix& ma, GdtfGeometry* parent);

                                                ~GdtfGeometryDisplay();

    private:

        TXString                                fTexture;

    public:

        virtual EGdtfObjectType                 GetObjectType();

        const TXString&                         GetTexture();

        void                                    SetTexture(const TXString& texture);

    protected:

        virtual TXString                        GetNodeName();

        virtual void                            OnPrintToFile(IXMLFileNodePtr pNode);

        virtual void                            OnReadFromNode(const IXMLFileNodePtr& pNode);

        virtual void                            OnErrorCheck(const IXMLFileNodePtr& pNode);

    };


    typedef GdtfGeometryDisplay* GdtfGeometryDisplayPtr;


    class GdtfLaserProtocol : public GdtfObject

    {

    public:

                                                GdtfLaserProtocol();

                                                GdtfLaserProtocol(const TXString& name);

                                                ~GdtfLaserProtocol();

    private:

        TXString                                fName;

    public:

        virtual EGdtfObjectType                 GetObjectType();


        const TXString&                         GetName() const;

        void                                    SetName(const TXString& name);

    protected:

        virtual TXString                        GetNodeName();

        virtual void                            OnPrintToFile(IXMLFileNodePtr pNode);

        virtual void                            OnReadFromNode(const IXMLFileNodePtr& pNode);

        virtual void                            OnErrorCheck(const IXMLFileNodePtr& pNode);

    };


    typedef GdtfLaserProtocol*                  GdtfLaserProtocolPtr;

    typedef std::vector<GdtfLaserProtocolPtr>   TGdtfLaserProtocolArray;


    class GdtfGeometryLaser : public GdtfGeometry

    {

    public:

                                                GdtfGeometryLaser(GdtfGeometry* parent);

                                                GdtfGeometryLaser(const TXString& name, GdtfModelPtr refToModel,const VWTransformMatrix& ma, GdtfGeometry* parent);

                                                ~GdtfGeometryLaser();


    private:

        EGdtfLaserColorType                     fColorType;

        double                                  fColor; //Wavelength

        double                                  fOutputStrength;

        GdtfPhysicalEmitter*                    fEmitter;

        double                                  fBeamDiameter;

        double                                  fBeamDivergenceMin;

        double                                  fBeamDivergenceMax;

        double                                  fScanAnglePan;

        double                                  fScanAngleTilt;

        double                                  fScanSpeed;


        TXString                                fUnresolvedEmitter;


        TGdtfLaserProtocolArray                 fLaserProtocols;


    public:

        virtual EGdtfObjectType                 GetObjectType();


        // Getters

        EGdtfLaserColorType                     GetColorType() const;

        double                                  GetColor() const;

        double                                  GetOutputStrength() const;

        GdtfPhysicalEmitter*                    GetEmitter() const;

        double                                  GetBeamDiameter() const;

        double                                  GetBeamDivergenceMin() const;

        double                                  GetBeamDivergenceMax() const;

        double                                  GetScanAnglePan() const;

        double                                  GetScanAngleTilt() const;

        double                                  GetScanSpeed() const;


        const TXString&                         GetUnresolvedEmitter() const;


        const TGdtfLaserProtocolArray&          GetLaserProtocolArray() const;


        // Setters

        void                                    SetColorType(const EGdtfLaserColorType& colorType);

        void                                    SetColor(double waveLength);

        void                                    SetOutputStrength(double outputStrength);

        void                                    SetEmitter(GdtfPhysicalEmitter* emitter);

        void                                    SetBeamDiameter(double beamDiameter);

        void                                    SetBeamDivergenceMin(double beamDivergenceMin);

        void                                    SetBeamDivergenceMax(double beamDivergenceMax);

        void                                    SetScanAnglePan(double scanAnglePan);

        void                                    SetScanAngleTilt(double scanAngleTilt);

        void                                    SetScanSpeed(double scanSpeed);


        GdtfLaserProtocolPtr                    CreateLaserProtocol(const TXString& name);


    protected:

        virtual TXString                        GetNodeName();

        virtual void                            OnPrintToFile(IXMLFileNodePtr pNode);

        virtual void                            OnReadFromNode(const IXMLFileNodePtr& pNode);

        virtual void                            OnErrorCheck(const IXMLFileNodePtr& pNode);

    };


    typedef GdtfGeometryLaser* GdtfGeometryLaserPtr;


    class GdtfPinPatch : public GdtfObject

    {

    public:

                                                GdtfPinPatch();

                                                GdtfPinPatch(GdtfGeometryWiringObjectPtr toWiringObject, size_t fromPin, size_t toPin);

                                                ~GdtfPinPatch();

    private:

        GdtfGeometryWiringObjectPtr             fToWiringObject;

        size_t                                  fFromPin;

        size_t                                  fToPin;


        TXString                                fUnresolvedWiringObject;


    public:

        virtual EGdtfObjectType                 GetObjectType();


        // Getters

        GdtfGeometryWiringObjectPtr             GetToWiringObject() const;

        size_t                                  GetFromPin() const;

        size_t                                  GetToPin() const;


        const TXString&                         GetUnresolvedWiringObject() const;


        // Setters

        void                                    SetToWiringObject(GdtfGeometryWiringObjectPtr toWiringObject);

        void                                    SetFromPin(size_t fromPin);

        void                                    SetToPin(size_t toPin);


    protected:

        virtual TXString                        GetNodeName();

        virtual void                            OnPrintToFile(IXMLFileNodePtr pNode);

        virtual void                            OnReadFromNode(const IXMLFileNodePtr& pNode);

        virtual void                            OnErrorCheck(const IXMLFileNodePtr& pNode);

    };


    typedef GdtfPinPatch*                   GdtfPinPatchPtr;

    typedef std::vector<GdtfPinPatchPtr>    TGdtfPinPatchArray;


    class GdtfGeometryWiringObject : public GdtfGeometry

    {

    public:

                                                GdtfGeometryWiringObject(GdtfGeometry* parent);

                                                GdtfGeometryWiringObject(const TXString& name, GdtfModelPtr refToModel,const VWTransformMatrix& ma, GdtfGeometry* parent);

                                                ~GdtfGeometryWiringObject();

    private:

        // Attributes

        TXString                                fConnectorType;

        EGdtfComponentType                      fComponentType;

        TXString                                fSignalType;

        size_t                                  fPinCount;

        size_t                                  fSignalLayer;

        EGdtfOrientation                        fOrientation;

        TXString                                fWireGroup;

        double                                  fElectricalPayLoad; //Consumer

        double                                  fVoltageRangeMin;   //Consumer

        double                                  fVoltageRangeMax;   //Consumer

        double                                  fFrequencyRangeMin; //Consumer

        double                                  fFrequencyRangeMax; //Consumer

        double                                  fCosPhi;            //Consumer

        double                                  fMaxPayLoad;        //PowerSource

        double                                  fVoltage;           //PowerSource

        double                                  fFuseCurrent;       //Fuse

        EGdtfFuseRating                         fFuseRating;        //Fuse


        // Children

        TGdtfPinPatchArray                      fPinPatches;


    public:

        virtual EGdtfObjectType                 GetObjectType();


        // Getters

        const TXString&                         GetConnectorType() const;

        EGdtfComponentType                      GetComponentType() const;

        const TXString&                         GetSignalType() const;

        size_t                                  GetPinCount() const;

        size_t                                  GetSignalLayer() const;

        EGdtfOrientation                        GetOrientation() const;

        const TXString&                         GetWireGroup() const;

        double                                  GetElectricalPayLoad() const;

        double                                  GetVoltageRangeMin() const;

        double                                  GetVoltageRangeMax() const;

        double                                  GetFrequencyRangeMin() const;

        double                                  GetFrequencyRangeMax() const;

        double                                  GetCosPhi() const;

        double                                  GetMaxPayLoad() const;

        double                                  GetVoltage() const;

        double                                  GetFuseCurrent() const;

        EGdtfFuseRating                         GetFuseRating() const;

        const TGdtfPinPatchArray&               GetPinPatchArray() const;


        // Setters

        void                                    SetConnectorType(const TXString& connectorType);

        void                                    SetComponentType(const EGdtfComponentType& componentType);

        void                                    SetSignalType(const TXString& signalType);

        void                                    SetPinCount(size_t pinCount);

        void                                    SetSignalLayer(size_t signalLayer);

        void                                    SetOrientation(const EGdtfOrientation& orientation);

        void                                    SetWireGroup(const TXString& wireGroup);

        void                                    SetElectricalPayLoad(double electricalPayLoad);

        void                                    SetVoltageRangeMin(double voltageRangeMin);

        void                                    SetVoltageRangeMax(double voltageRangeMax);

        void                                    SetFrequencyRangeMin(double frequencyRangeMin);

        void                                    SetFrequencyRangeMax(double frequencyRangeMax);

        void                                    SetCosPhi(double cosPhi);

        void                                    SetMaxPayLoad(double maxPayload);

        void                                    SetVoltage(double voltage);

        void                                    SetFuseCurrent(double fuseCurrent);

        void                                    SetFuseRating(const EGdtfFuseRating& fuseRating);

        GdtfPinPatchPtr                         CreatePinPatch(GdtfGeometryWiringObject* toWiringObject, size_t fromPin, size_t toPin);


    protected:

        virtual TXString                        GetNodeName();

        virtual void                            OnPrintToFile(IXMLFileNodePtr pNode);

        virtual void                            OnReadFromNode(const IXMLFileNodePtr& pNode);

        virtual void                            OnErrorCheck(const IXMLFileNodePtr& pNode);

    };


    class GdtfGeometryInventory : public GdtfGeometry

    {

    public:

                                                GdtfGeometryInventory(GdtfGeometry* parent);

                                                GdtfGeometryInventory(const TXString& name, GdtfModelPtr refToModel,const VWTransformMatrix& ma, GdtfGeometry* parent);

                                                ~GdtfGeometryInventory();

    private:

        size_t                                  fCount;


    public:

        virtual EGdtfObjectType                 GetObjectType();


        size_t                                  GetCount() const;

        void                                    SetCount(size_t count);


    protected:

        virtual TXString                        GetNodeName();

        virtual void                            OnPrintToFile(IXMLFileNodePtr pNode);

        virtual void                            OnReadFromNode(const IXMLFileNodePtr& pNode);

        virtual void                            OnErrorCheck(const IXMLFileNodePtr& pNode);

    };


    typedef GdtfGeometryInventory* GdtfGeometryInventoryPtr;


    class GdtfGeometryStructure : public GdtfGeometry

    {

    public:

                                                GdtfGeometryStructure(GdtfGeometry* parent);

                                                GdtfGeometryStructure(const TXString& name, GdtfModelPtr refToModel,const VWTransformMatrix& ma, GdtfGeometry* parent);

                                                ~GdtfGeometryStructure();


    private:

        GdtfGeometry*                           fLinkedGeometry;

        EGdtfStructureType                      fStructureType;

        EGdtfCrossSectionType                   fCrossSectionType;

        double                                  fCrossSectionHeight; //Tube

        double                                  fCrossSectionWallThickness; //Tube

        TXString                                fTrussCrossSection; //TrussFramework


        TXString                                fUnresolvedLinkedGeometry;


    public:

        virtual EGdtfObjectType                 GetObjectType();


        // Getters

        GdtfGeometry*                           GetLinkedGeometry() const;

        EGdtfStructureType                      GetStructureType() const;

        EGdtfCrossSectionType                   GetCrossSectionType() const;

        double                                  GetCrossSectionHeight() const;

        double                                  GetCrossSectionWallThickness() const;

        const TXString&                         GetTrussCrossSection() const;


        const TXString&                         GetUnresolvedLinkedGeometry() const;


        // Setters

        void                                    SetLinkedGeometry(GdtfGeometry* linkedGeometry);

        void                                    SetStructureType(const EGdtfStructureType& structureType);

        void                                    SetCrossSectionType(const EGdtfCrossSectionType& crossSectionType);

        void                                    SetCrossSectionHeight(double crossSectionHeight);

        void                                    SetCrossSectionWallThickness(double crossSectionWallThickness);

        void                                    SetTrussCrossSection(const TXString& trussCrossSection);


    protected:

        virtual TXString                        GetNodeName();

        virtual void                            OnPrintToFile(IXMLFileNodePtr pNode);

        virtual void                            OnReadFromNode(const IXMLFileNodePtr& pNode);

        virtual void                            OnErrorCheck(const IXMLFileNodePtr& pNode);

    };


    typedef GdtfGeometryStructure* GdtfGeometryStructurePtr;


    class GdtfGeometrySupport : public GdtfGeometry

    {

    public:

                                                GdtfGeometrySupport(GdtfGeometry* parent);

                                                GdtfGeometrySupport(const TXString& name, GdtfModelPtr refToModel,const VWTransformMatrix& ma, GdtfGeometry* parent);

                                                ~GdtfGeometrySupport();


    private:

        EGdtfSupportType                        fSupportType;

        double                                  fCapacityX;

        double                                  fCapacityY;

        double                                  fCapacityZ;

        double                                  fCapacityXX;

        double                                  fCapacityYY;

        double                                  fCapacityZZ;

        TXString                                fRopeCrossSection;  //Rope

        VWPoint3D                               fRopeOffset;        //Rope

        double                                  fResistanceX;       //GroundSupport

        double                                  fResistanceY;       //GroundSupport

        double                                  fResistanceZ;       //GroundSupport

        double                                  fResistanceXX;      //GroundSupport

        double                                  fResistanceYY;      //GroundSupport

        double                                  fResistanceZZ;      //GroundSupport


    public:

        virtual EGdtfObjectType                 GetObjectType();


        // Getters

        EGdtfSupportType                        GetSupportType() const;

        double                                  GetCapacityX() const;

        double                                  GetCapacityY() const;

        double                                  GetCapacityZ() const;

        double                                  GetCapacityXX() const;

        double                                  GetCapacityYY() const;

        double                                  GetCapacityZZ() const;

        const TXString&                         GetRopeCrossSection() const;

        VWPoint3D                               GetRopeOffset();

        double                                  GetResistanceX() const;

        double                                  GetResistanceY() const;

        double                                  GetResistanceZ() const;

        double                                  GetResistanceXX() const;

        double                                  GetResistanceYY() const;

        double                                  GetResistanceZZ() const;


        // Setters

        void                                    SetSupportType(const EGdtfSupportType& supportType);

        void                                    SetCapacityX(double capacityX);

        void                                    SetCapacityY(double capacityY);

        void                                    SetCapacityZ(double capacityZ);

        void                                    SetCapacityXX(double capacityXX);

        void                                    SetCapacityYY(double capacityYY);

        void                                    SetCapacityZZ(double capacityZZ);

        void                                    SetRopeCrossSection(const TXString& ropeCrossSection);

        void                                    SetRopeOffset(double x, double y, double z);

        void                                    SetResistanceX(double resistanceX);

        void                                    SetResistanceY(double resistanceY);

        void                                    SetResistanceZ(double resistanceZ);

        void                                    SetResistanceXX(double resistanceXX);

        void                                    SetResistanceYY(double resistanceYY);

        void                                    SetResistanceZZ(double resistanceZZ);


    protected:

        virtual TXString                        GetNodeName();

        virtual void                            OnPrintToFile(IXMLFileNodePtr pNode);

        virtual void                            OnReadFromNode(const IXMLFileNodePtr& pNode);

        virtual void                            OnErrorCheck(const IXMLFileNodePtr& pNode);

    };


    typedef GdtfGeometrySupport* GdtfGeometrySupportPtr;


    class GdtfGeometryMagnet : public GdtfGeometry

    {

    public:

                                                GdtfGeometryMagnet(GdtfGeometry* parent);

                                                GdtfGeometryMagnet(const TXString& name, GdtfModelPtr refToModel,const VWTransformMatrix& ma, GdtfGeometry* parent);

                                                ~GdtfGeometryMagnet();

    public:

        virtual EGdtfObjectType                 GetObjectType();


    protected:

        virtual TXString                        GetNodeName();

        virtual void                            OnPrintToFile(IXMLFileNodePtr pNode);

        virtual void                            OnReadFromNode(const IXMLFileNodePtr& pNode);

        virtual void                            OnErrorCheck(const IXMLFileNodePtr& pNode);

    };


    typedef GdtfGeometryMagnet* GdtfGeometryMagnetPtr;


    class GdtfGeometryLamp : public GdtfGeometry

    {

    public:

                                                GdtfGeometryLamp(GdtfGeometry* parent);

                                                GdtfGeometryLamp(const TXString& name, GdtfModelPtr refToModel,const VWTransformMatrix& ma, GdtfGeometry* parent);

                                                ~GdtfGeometryLamp();

    private:

        EGdtfLampType                           fLampType;

        double                                  fPowerConsuption;   // Unit ?? -> W cos phi???

        double                                  fLuminousIntensity;

        double                                  fColorTemperature;

        double                                  fBeamAngle;         // Unit ?? -> Degree

        double                                  fFieldAngle;

        double                                  fBeamRadius;        // Unit Meter

        double                                  fThrowRatio;

        double                                  fRectangleRatio;

        EGdtfBeamType                           fBeamType;          // Unit Meter

        Sint32                                  fColorIndex;

        GdtfPhysicalEmitter*                    fEmitterSpectrum;


        TXString                                fUnresolvedEmitterRef;


    public:

        // Getter

        virtual EGdtfObjectType                 GetObjectType();

        EGdtfLampType                           GetLampType();

        double                                  GetPowerConsumption();

        double                                  GetLuminousIntensity();

        double                                  GetColorTemperature();

        double                                  GetBeamAngle();

        double                                  GetFieldAngle();

        double                                  GetBeamRadius();

        double                                  GetThrowRatio();

        double                                  GetRectangleRatio();

        EGdtfBeamType                           GetBeamType();

        Sint32                                  GetColorIndex();

        GdtfPhysicalEmitter*                    GetEmitterSpectrum();


        TXString                                GetUnresolvedEmitterRef() const;


        // Setter

        void                                    SetLampType(EGdtfLampType type);

        void                                    SetPowerConsumption(double powerConsumption);

        void                                    SetLuminousIntensity(double intensity);

        void                                    SetColorTemperature(double temperature);

        void                                    SetBeamAngle(double angle);

        void                                    SetFieldAngle(double angle);

        void                                    SetBeamRadius(double radius);

        void                                    SetThrowRatio(double ratio);

        void                                    SetRectangleRatio(double ratio);

        void                                    SetBeamType(EGdtfBeamType type);

        void                                    SetColorIndex(Sint32 idx);

        void                                    SetEmitterSpectrum(GdtfPhysicalEmitter* emitterSpectrum);


    protected:

        void                                    InitializeMembersWithDefaultsVals();

        virtual TXString                        GetNodeName();

        virtual void                            OnPrintToFile(IXMLFileNodePtr pNode);

        virtual void                            OnReadFromNode(const IXMLFileNodePtr& pNode);

        virtual void                            OnErrorCheck(const IXMLFileNodePtr& pNode);

    };


    typedef GdtfGeometryLamp*           GdtfGeometryLampePtr;


    class GdtfBreak : public GdtfObject

    {

    public:

                                                GdtfBreak();

                                                ~GdtfBreak();

    private:

        Sint32                                  fDmxBreak;

        DMXAddress                              fDmxAdress;

    public:

        // Getter

        virtual EGdtfObjectType                 GetObjectType();

        Sint32                                  GetDmxBreak();

        DMXAddress                              GetDmxAddress();

        // Setter

        void                                    SetDmxBreak(Sint32 dmxBreak);

        void                                    SetDmxAddress(DMXAddress dmxAddress);


    protected:

        virtual TXString                        GetNodeName();

        virtual void                            OnPrintToFile(IXMLFileNodePtr pNode);

        virtual void                            OnReadFromNode(const IXMLFileNodePtr& pNode);

        virtual void                            OnErrorCheck(const IXMLFileNodePtr& pNode);

    };


    typedef GdtfBreak*              GdtfBreakPtr;

    typedef std::vector<GdtfBreak*> TGdtfBreakArray;


    class GdtfGeometryReference : public GdtfGeometry

    {

        friend GdtfGeometry;

    public:

                                                GdtfGeometryReference(GdtfGeometry* parent);

                                                GdtfGeometryReference(const TXString& name, GdtfModelPtr refToModel,const VWTransformMatrix& ma, GdtfGeometry* parent);

                                                ~GdtfGeometryReference();


    private:

        TGdtfBreakArray                         fBreaks;

        GdtfGeometry*                           fLinkedGeometry;

        TXString                                fUnresolvedGeoRef;


    public:

        virtual EGdtfObjectType                 GetObjectType();

        TGdtfBreakArray                         GetBreakArray();

        GdtfBreakPtr                            AddBreak();


        GdtfGeometry*                           GetLinkedGeometry();

        void                                    SetLinkedGeometry(GdtfGeometry* ptr);


        const TXString&                         GetUnresolvedLinkedGeometry();


    protected:

        virtual TXString                        GetNodeName();

        virtual void                            OnPrintToFile(IXMLFileNodePtr pNode);

        virtual void                            OnReadFromNode(const IXMLFileNodePtr& pNode);

        virtual void                            OnErrorCheck(const IXMLFileNodePtr& pNode);

    };


    typedef GdtfGeometryReference*      GdtfGeometryReferencePtr;


    //------------------------------------------------------------------------------------

    // DMX Definition


    class GdtfDmxChannelSet : public GdtfObject

    {

    public:

                                                GdtfDmxChannelSet(GdtfDmxChannelFunction* parent);

                                                GdtfDmxChannelSet(const TXString& name, GdtfDmxChannelFunction* parent);

                                                ~GdtfDmxChannelSet();


    private:

        TXString                                fUniqueName;

        DmxValue                                fDmxStart;

        DmxValue                                fDmxEnd;

        bool                                    fSetPhysical;

        double                                  fPhysicalStart;

        double                                  fPhysicalEnd;

        Sint32                                  fWheelSlotIdx;

        bool                                    fValid;


        GdtfDmxChannelFunction*                 fParentChnlFunction;

        GdtfDmxChannelSet*                      fNextChannelSet;


    public:

        // Getter

        virtual EGdtfObjectType                 GetObjectType();

        //

        const TXString&                         GetName() const;

        DmxValue                                GetDmxStart() const;

        DmxValue                                GetDmxEnd() const;

        double                                  GetPhysicalStart() const;

        double                                  GetPhysicalEnd() const;

        Sint32                                  GetWheelSlot();

        bool                                    GetUsePhysicalFromParent() const;

        //

        GdtfDmxChannel*                         GetParentDMXChannel() const;

        // Setter

        void                                    SetName(const TXString& name);

        void                                    SetDmxStart(DmxValue start);

        void                                    SetDmxEnd(DmxValue end);

        void                                    SetPhysicalStart(double start);

        void                                    SetPhysicalEnd(double end);

        void                                    SetWheelSlot(Sint32 slotIndex);


        bool                                    SetNextChannelSet(GdtfDmxChannelSet* next, IXMLFileNodePtr objNode);


        bool                                    IsValid();


    protected:

        virtual TXString                        GetNodeName();

        virtual void                            OnPrintToFile(IXMLFileNodePtr pNode);

        virtual void                            OnReadFromNode(const IXMLFileNodePtr& pNode);

        virtual void                            OnErrorCheck(const IXMLFileNodePtr& pNode);


    };


    typedef GdtfDmxChannelSet*              GdtfDmxChannelSetPtr;

    typedef std::vector<GdtfDmxChannelSet*> TGdtfDmxChannelSetArray;


    class GdtfDmxSubChannelSet : public GdtfObject

    {

    public:

                                                GdtfDmxSubChannelSet();

                                                GdtfDmxSubChannelSet(GdtfSubPhysicalUnitPtr subPhysicalUnit, const TXString& name);

                                                ~GdtfDmxSubChannelSet();


    private:

        TXString                                fUniqueName;

        double                                  fPhysicalFrom;

        double                                  fPhysicalTo;

        GdtfSubPhysicalUnitPtr                  fSubPhysicalUnit;

        GdtfDMXProfilePtr                       fDMXProfile;


        TXString                                fUnresolvedSubPhysicalUnitRef;

        TXString                                fUnresolvedDMXProfileRef;


    public:

        virtual EGdtfObjectType                 GetObjectType();


        // Getters

        const TXString&                         GetName() const;

        double                                  GetPhysicalFrom() const;

        double                                  GetPhysicalTo() const;

        GdtfSubPhysicalUnitPtr                  GetSubPhysicalUnit() const;

        GdtfDMXProfilePtr                       GetDMXProfile() const;

        //

        const TXString&                         GetUnresolvedSubPhysicalUnitRef() const;

        const TXString&                         GetUnresolvedDMXProfileRef() const;


        // Setter

        void                                    SetName(const TXString& name);

        void                                    SetPhysicalFrom(double from);

        void                                    SetPhysicalTo(double to);

        void                                    SetSubPhysicalUnit(GdtfSubPhysicalUnitPtr subPhysicalUnit);

        void                                    SetDMXProfile(GdtfDMXProfilePtr dmxProfile);


    protected:

        virtual TXString                        GetNodeName();

        virtual void                            OnPrintToFile(IXMLFileNodePtr pNode);

        virtual void                            OnReadFromNode(const IXMLFileNodePtr& pNode);

        virtual void                            OnErrorCheck(const IXMLFileNodePtr& pNode);


    };


    typedef GdtfDmxSubChannelSet*               GdtfDmxSubChannelSetPtr;

    typedef std::vector<GdtfDmxSubChannelSet*>  TGdtfDmxSubChannelSetArray;


    class GdtfDmxChannelFunction : public GdtfObject

    {

    public:

                                                GdtfDmxChannelFunction(GdtfDmxLogicalChannel* parent);

                                                GdtfDmxChannelFunction(const TXString& name, GdtfDmxLogicalChannel* parent);

                                                ~GdtfDmxChannelFunction();

    private:

        TXString                                fName;

        GdtfAttribute*                          fAttribute;

        TXString                                fOrignalAttribute;

        DmxValue                                fDefaultValue;

        DmxValue                                fAdressStart;

        double                                  fPhysicalStart;

        double                                  fPhysicalEnd;

        double                                  fRealFade;

        double                                  fRealAcceleration;

        GdtfWheelPtr                            fOnWheel;

        GdtfPhysicalEmitter*                    fEmitter;


        GdtfDmxChannel*                         fModeMaster_Channel;

        GdtfDmxChannelFunction*                 fModeMaster_Function;

        DmxValue                                fDmxModeStart;

        DmxValue                                fDmxModeEnd;

        GdtfFilterPtr                           fFilter;


        GdtfColorSpacePtr                       fColorSpace;

        GdtfGamutPtr                            fGamut;

        GdtfDMXProfilePtr                       fDMXProfile;

        double                                  fMin;

        double                                  fMax;

        TXString                                fCustomName;

        // Children

        TGdtfDmxChannelSetArray                 fChannelSets;

        TGdtfDmxSubChannelSetArray              fSubChannelSets;


        // Unresolved Refs

        TXString                                fUnresolvedAttrRef;

        TXString                                fUnresolvedWheelRef;

        TXString                                fUnresolvedEmitterRef;

        TXString                                fUnresolvedDmxModeStart;

        TXString                                fUnresolvedDmxModeEnd;

        TXString                                fUnresolvedModeMaster;

        TXString                                fUnresolvedFilterRef;

        TXString                                fUnresolvedColorSpaceRef;

        TXString                                fUnresolvedGamutRef;

        TXString                                fUnresolvedDMXProfileRef;


        // Parent Logical Channel

        GdtfDmxLogicalChannel*                  fParentLogicalChannel;

        GdtfDmxChannelFunction*                 fNextFunction;


    public:

        virtual EGdtfObjectType                 GetObjectType();

        virtual TXString                        GetNodeReference();

        //

        const TXString&                         GetName() const;

        GdtfAttribute*                          GetAttribute();

        const TXString&                         GetOriginalAttribute();

        DmxValue                                GetDefaultValue() const;

        DmxValue                                GetStartAdress() const;

        DmxValue                                GetEndAdress() const;

        double                                  GetPhysicalStart() const;

        double                                  GetPhysicalEnd() const;

        double                                  GetRealFade() const;

        double                                  GetRealAcceleration() const;

        GdtfWheelPtr                            GetOnWheel() const;

        GdtfPhysicalEmitter*                    GetEmitter() const;

        GdtfFilterPtr                           GetFilter() const;

        GdtfColorSpacePtr                       GetColorSpace() const;

        GdtfGamutPtr                            GetGamut() const;

        GdtfDMXProfilePtr                       GetDMXProfile() const;

        double                                  GetMin() const;

        double                                  GetMax() const;

        const TXString&                         GetCustomName() const;


        GdtfDmxChannel*                         GetModeMaster_Channel() const;

        GdtfDmxChannelFunction*                 GetModeMaster_Function() const;

        DmxValue                                GetModeMasterDmxStart() const;

        DmxValue                                GetModeMasterDmxEnd() const;


        size_t                                  GetNumberInParent() const;


        //

        const TGdtfDmxChannelSetArray&          GetChannelSets() const;

        const TGdtfDmxSubChannelSetArray&       GetSubChannelSets() const;

        //

        TXString                                getUnresolvedAttrRef() const;

        TXString                                getUnresolvedWheelRef() const;

        TXString                                getUnresolvedEmitterRef() const;

        TXString                                getUnresolvedModeMasterRef() const;

        const TXString&                         getUnresolvedFilterRef();

        const TXString&                         getUnresolvedColorSpaceRef() const;

        const TXString&                         getUnresolvedGamutRef() const;

        const TXString&                         getUnresolvedDMXProfileRef() const;


        GdtfDmxChannel*                         GetParentDMXChannel() const;

        GdtfDmxLogicalChannel*                  GetParentLogicalChannel() const;

        void                                    ResolveModeMasterDmx(EGdtfChannelBitResolution resolution);


        void                                    SetNextFunction(GdtfDmxChannelFunction* next);

        GdtfDmxChannelFunction*                 GetNextFunction() const;


        void                                    SetWheel(GdtfWheelPtr newWhl);

        void                                    SetName(const TXString& name);

        void                                    SetOriginalAttribute(const TXString& attribute);

        void                                    SetAttribute(GdtfAttribute* newAttr);

        void                                    SetDefaultValue(DmxValue defaultValue);

        void                                    SetStartAddress(DmxValue address);

        void                                    SetPhysicalStart(double start);

        void                                    SetPhysicalEnd(double end);

        void                                    SetRealFade(double fade);

        void                                    SetRealAcceleration(double fade);

        void                                    SetEmitter(GdtfPhysicalEmitter* newEmit);

        void                                    SetFilter(GdtfFilterPtr val);

        void                                    SetColorSpace(GdtfColorSpacePtr colorSpace);

        void                                    SetGamut(GdtfGamutPtr gamut);

        void                                    SetDMXProfile(GdtfDMXProfilePtr dmxProfile);

        void                                    SetMin(double min);

        void                                    SetMax(double max);

        void                                    SetCustomName(const TXString& customName);


        void                                    SetModeMaster_Channel(GdtfDmxChannel* channel);

        void                                    SetModeMaster_Function(GdtfDmxChannelFunction* function);

        void                                    SetModeMasterDmxStart(DmxValue start);

        void                                    SetModeMasterDmxEnd(DmxValue end);


        //

        GdtfDmxChannelSet*                      AddChannelSet(const TXString& name);

        GdtfDmxSubChannelSet*                   AddSubChannelSet(GdtfSubPhysicalUnit* subPhysicalUnit, const TXString& name);

    protected:

        virtual TXString                        GetNodeName();

        virtual void                            OnPrintToFile(IXMLFileNodePtr pNode);

        virtual void                            OnReadFromNode(const IXMLFileNodePtr& pNode);

        virtual void                            OnErrorCheck(const IXMLFileNodePtr& pNode);


    };


    typedef GdtfDmxChannelFunction*                 GdtfDmxChannelFunctionPtr;

    typedef std::vector<GdtfDmxChannelFunctionPtr>  TGdtfDmxChannelFuntionArray;


    class GdtfDmxLogicalChannel : public GdtfObject

    {

    public:

        GdtfDmxLogicalChannel(GdtfDmxChannel* parent);

        ~GdtfDmxLogicalChannel();

    private:

        TXString                                fName_AutoGenerated;

        GdtfAttribute*                          fAttribute;

        TXString                                fUnresolvedAttribRef;

        EGdtfDmxSnap                            fSnap;

        EGdtfDmxMaster                          fDmxMaster;

        //

        TGdtfDmxChannelFuntionArray             fFunctions;


        GdtfDmxChannel*                         fParentDmxChannel;

        GdtfDmxLogicalChannel*                  fNextLogicalChannel;

        double                                  fMoveInBlackFrames;                         //is frames here the best unit

        double                                  fDmxChangeTimeLimit;


    public:


        virtual EGdtfObjectType                 GetObjectType();

        virtual TXString                        GetNodeReference();


        const TXString&                         GetName();

        GdtfAttribute*                          GetAttribute();

        EGdtfDmxSnap                            GetDmxSnap() const;

        EGdtfDmxMaster                          GetDmxMaster() const;

        const TGdtfDmxChannelFuntionArray       GetDmxChannelFunctions();

        TXString                                GetUnresolvedAttribRef() const;

        GdtfDmxChannel*                         GetParentDMXChannel() const;

        GdtfDmxLogicalChannel*                  GetNextLogicalChannel() ;

        double                                  GetMoveInBlackFrames() const;

        double                                  GetDmxChangeTimeLimit() const;


        void                                    SetName(const TXString& name);

        void                                    SetAttribute(GdtfAttributePtr newAttr);

        void                                    SetDmxSnap(EGdtfDmxSnap snap);

        void                                    SetDmxMaster(EGdtfDmxMaster master);

        GdtfDmxChannelFunctionPtr               AddDmxChannelFunction(const TXString& name);

        void                                    SetNextLogicalChannel(GdtfDmxLogicalChannel* next) ;

        void                                    SetMoveInBlackFrames(double moveInBlackFrames);

        void                                    SetDmxChangeTimeLimit(double changeLimit);

    protected:

        virtual TXString                        GetNodeName();

        virtual void                            OnPrintToFile(IXMLFileNodePtr pNode);

        virtual void                            OnReadFromNode(const IXMLFileNodePtr& pNode);

        virtual void                            OnErrorCheck(const IXMLFileNodePtr& pNode);


    };


    typedef GdtfDmxLogicalChannel*              GdtfDmxLogicalChannelPtr;

    typedef std::vector<GdtfDmxLogicalChannel*> TGdtfDmxLogicalChannelArray;


    class GdtfDmxChannel : public GdtfObject

    {

    public:

                                                GdtfDmxChannel(GdtfDmxMode* parent);

                                                ~GdtfDmxChannel();

    private:

        TXString                                fName_AutoGenerated;

        Sint32                                  fDmxBreak;

        DMXAddress                              fCoarse;

        DMXAddress                              fFine;

        DMXAddress                              fUltra;

        DMXAddress                              fUber;

        DmxValue                                fHeighlight;    bool fHeighlightNone;

        DmxValue                                fDefaultValue_old;

        GdtfGeometryPtr                         fGeomRef;

        TXString                                fUnresolvedGeomRef;

        GdtfDmxChannelFunctionPtr               fInitialFunction;

        TXString                                fUnresolvedInitialFunction;

        //

        TGdtfDmxLogicalChannelArray             fLogicalChannels;


        //

        GdtfDmxMode*                            fParent;


    public:

        virtual EGdtfObjectType                 GetObjectType();

        virtual TXString                        GetNodeReference();


        const TXString&                         GetName();

        Sint32                                  GetDmxBreak() const;

        Sint32                                  GetCoarse() const;

        Sint32                                  GetFine() const;

        Sint32                                  GetUltra() const;

        Sint32                                  GetUber() const;

        DmxValue                                GetHighlight() const;

        bool                                    HasHighlight() const;

        DmxValue                                GetOldDefaultValue() const;

        const TGdtfDmxLogicalChannelArray       GetLogicalChannelArray();

        GdtfGeometryPtr                         GetGeomRef();

        TXString                                GetUnresolvedGeomRef() const;

        GdtfDmxChannelFunctionPtr               GetInitialFunction();

        TXString                                GetUnresolvedInitialFunction() const;

        EGdtfChannelBitResolution               GetChannelBitResolution();

        DmxValue                                GetChannelMaxDmx();

        bool                                    IsVirtual() const;


        void                                    SetName(const TXString& name);

        void                                    SetDmxBreak(Sint32 dmxBreak);

        void                                    SetDmxCoarse(Sint32 coarse);

        void                                    SetDmxFine(Sint32 fine);

        void                                    SetDmxUltra(Sint32 ultra);

        void                                    SetDmxUber(Sint32 uber);

        void                                    SetHighlight(DmxValue highlight);

        void                                    SetModel(GdtfModelPtr ptr);

        GdtfDmxLogicalChannel*                  AddLogicalChannel();

        void                                    SetGeomRef(GdtfGeometryPtr newGeom);

        void                                    SetInitialFunction(GdtfDmxChannelFunctionPtr initialFunction);


        // Get Parent

        GdtfDmxMode*                            GetParentMode();


    protected:

        virtual TXString                        GetNodeName();

        virtual void                            OnPrintToFile(IXMLFileNodePtr pNode);

        virtual void                            OnReadFromNode(const IXMLFileNodePtr& pNode);

        virtual void                            OnErrorCheck(const IXMLFileNodePtr& pNode);


    };


    typedef GdtfDmxChannel*                 GdtfDmxChannelPtr;

    typedef std::vector<GdtfDmxChannelPtr>  TGdtfDmxChannelArray;


    class GdtfDmxRelation : public GdtfObject

    {

    public:

                                                GdtfDmxRelation();

                                                GdtfDmxRelation(GdtfDmxChannelPtr master, GdtfDmxChannelFunctionPtr slave, const TXString& name);

                                                ~GdtfDmxRelation();

    private:

        TXString                                fUniqueName;

        GdtfDmxChannelPtr                       fMasterDmxChannel;

        GdtfDmxChannelFunctionPtr               fSlaveChannelFunction;

        EGdtfDmxRelationType                    fRelationType;


        // Pointer Resolve

        TXString                                fUnresolvedMasterRef;

        TXString                                fUnresolvedSlaveRef;


    public:

        TXString                                GetUnresolvedMasterRef() const;

        TXString                                GetUnresolvedSlaveRef() const;

        // Getter

        virtual EGdtfObjectType                 GetObjectType();

        const TXString&                         GetName() const;

        GdtfDmxChannelPtr                       GetMasterChannel() const;

        GdtfDmxChannelFunctionPtr               GetSlaveChannel() const;

        EGdtfDmxRelationType                    GetRelationType() const;

        DmxValue                                GetDmxStart() const;

        DmxValue                                GetDmxEnd() const;

        // Setter

        void                                    SetName(const TXString& name);

        void                                    SetMasterChannel(GdtfDmxChannelPtr newMaster);

        void                                    SetSlaveChannel(GdtfDmxChannelFunctionPtr newSlave);

        void                                    SetRelationType(EGdtfDmxRelationType type);

        void                                    SetDmxStart(DmxValue start);

        void                                    SetDmxEnd(DmxValue end);

    protected:

        virtual TXString                        GetNodeName();

        virtual void                            OnPrintToFile(IXMLFileNodePtr pNode);

        virtual void                            OnReadFromNode(const IXMLFileNodePtr& pNode);

        virtual void                            OnErrorCheck(const IXMLFileNodePtr& pNode);


    };


    typedef GdtfDmxRelation*                GdtfDmxRelationPtr;

    typedef std::vector<GdtfDmxRelation*>   TGdtfDmxRelationArray;


    //------------------------------------------------------------------------------------

    // Macro Definitions


    class GdtfMacro : public GdtfObject

    {

    public:

                                                GdtfMacro();

                                                GdtfMacro(const TXString& name);

                                                ~GdtfMacro();


    private:

        TXString                                fName;

        GdtfDmxChannelFunction*                 fChannelFunction;


        TXString                                fUnresolvedChannelFunction;

        // Children

        GdtfMacroDMX*                           fMacroDMX;

        GdtfMacroVisual*                        fMacroVisual;

    public:

        virtual EGdtfObjectType                 GetObjectType();

    public:

        // Getter

        const TXString&                         GetName() const;

        GdtfDmxChannelFunction*                 GetChannelFunction() const;

        const TXString&                         GetUnresolvedChannelFunction() const;

        GdtfMacroDMX*                           GetMacroDMX() const;

        GdtfMacroVisual*                        GetMacroVisual() const;

        // Setter

        void                                    SetName(const TXString & name);

        void                                    SetChannelFunction(GdtfDmxChannelFunction* channelFunction);

        void                                    SetMacroDMX(GdtfMacroDMX* val);

        void                                    SetMacroVisual(GdtfMacroVisual* val);

    protected:

        virtual TXString                        GetNodeName();

        virtual void                            OnPrintToFile(IXMLFileNodePtr pNode);

        virtual void                            OnReadFromNode(const IXMLFileNodePtr& pNode);

        virtual void                            OnErrorCheck(const IXMLFileNodePtr& pNode);

    };


    typedef GdtfMacro*                  GdtfMacroPtr;

    typedef std::vector<GdtfMacroPtr>   TGdtfMacroArray;


    class GdtfMacroDMXValue : public GdtfObject

    {

    public:

                                                GdtfMacroDMXValue();

                                                GdtfMacroDMXValue(DmxValue dmxVal, GdtfDmxChannelPtr dmxChannel);

                                                ~GdtfMacroDMXValue();

    private:

        TXString                                funresolvedValue;

        DmxValue                                fValue;

        TXString                                funresolvedDMXChannel;

        GdtfDmxChannelPtr                       fDMXChannel;

    public:

        virtual EGdtfObjectType                 GetObjectType();


        // Getter

        DmxValue                                GetValue() const;

        const TXString&                         GetUnresolvedDMXChannel() const;

        GdtfDmxChannelPtr                       GetDMXChannel() const;

        const TXString&                         GetUnresolvedDMXValue() const;

        // Setter

        void                                    SetValue(DmxValue val);

        void                                    SetDMXChannel(GdtfDmxChannelPtr chnl);


    protected:

        virtual TXString                        GetNodeName();

        virtual void                            OnPrintToFile(IXMLFileNodePtr pNode);

        virtual void                            OnReadFromNode(const IXMLFileNodePtr& pNode);

        virtual void                            OnErrorCheck(const IXMLFileNodePtr& pNode);

    };


    typedef GdtfMacroDMXValue*  GdtfMacroDMXValuePtr;

    typedef std::vector<GdtfMacroDMXValue*> TGdtfMacroDMXValueArray;


    class GdtfMacroDMXStep : public GdtfObject

    {

    public:

                                                GdtfMacroDMXStep();

                                                GdtfMacroDMXStep(double duration);

                                                ~GdtfMacroDMXStep();

    private:

        double                                  fDuration;

        // Childs

        TGdtfMacroDMXValueArray                 fDMXValues;

    public:

        virtual EGdtfObjectType                 GetObjectType();


    public:

        // Getter

        double                                  GetDuration() const;

        TGdtfMacroDMXValueArray                 GetDMXValueArray() const;

        // Setter

        void                                    SetDuration(double d);

        //

        GdtfMacroDMXValuePtr                    AddDmxValue(DmxValue dmxVal, GdtfDmxChannelPtr dmxChannel);

    protected:

        virtual TXString                        GetNodeName();

        virtual void                            OnPrintToFile(IXMLFileNodePtr pNode);

        virtual void                            OnReadFromNode(const IXMLFileNodePtr& pNode);

        virtual void                            OnErrorCheck(const IXMLFileNodePtr& pNode);

    };


    typedef GdtfMacroDMXStep*   GdtfMacroDMXStepPtr;

    typedef std::vector<GdtfMacroDMXStep*>  TGdtfMacroDMXStepArray;


    class GdtfMacroDMX : public GdtfObject

    {

    public:

                                                GdtfMacroDMX();

                                                ~GdtfMacroDMX();

    private:

        TGdtfMacroDMXStepArray                  fDMXSetps;

    public:

        virtual EGdtfObjectType                 GetObjectType();

        virtual TGdtfMacroDMXStepArray          GetStepArray();

    public:

        GdtfMacroDMXStepPtr                     AddDmxStep(double& duration);

    protected:

        virtual TXString                        GetNodeName();

        virtual void                            OnPrintToFile(IXMLFileNodePtr pNode);

        virtual void                            OnReadFromNode(const IXMLFileNodePtr& pNode);

    };


    class GdtfMacroVisualValue : public GdtfObject

    {

    public:

                                                GdtfMacroVisualValue();

                                                GdtfMacroVisualValue(DmxValue dmxVal, GdtfDmxChannelFunctionPtr channelFunctionRef);

                                                ~GdtfMacroVisualValue();

    private:

        TXString                                funresolvedValue;

        DmxValue                                fDmxValue;

        TXString                                fUnresolvedChannelFunctionRef;

        GdtfDmxChannelFunctionPtr               fChannelFunctionRef;

    public:

        virtual EGdtfObjectType                 GetObjectType();


        // Getter

        DmxValue                                GetDmxValue() const;

        const TXString&                         GetUnresolvedChannelFunctionRef() const;

        GdtfDmxChannelFunctionPtr               GetChannelFunctionRef() const;

        const TXString&                         GetUnresolvedDMXValue() const;

        // Setter

        void                                    SetDmxValue(DmxValue val);

        void                                    SetUnresolvedChannelFunctionRef(const TXString& ref);

        void                                    SetChannelFunction(GdtfDmxChannelFunctionPtr ref);

    protected:

        virtual TXString                        GetNodeName();

        virtual void                            OnPrintToFile(IXMLFileNodePtr pNode);

        virtual void                            OnReadFromNode(const IXMLFileNodePtr& pNode);

        virtual void                            OnErrorCheck(const IXMLFileNodePtr& pNode);

    };


    typedef GdtfMacroVisualValue*   GdtfMacroVisualValuePtr;

    typedef std::vector<GdtfMacroVisualValue*>  TGdtfMacroVisualValueArray;


    class GdtfMacroVisualStep : public GdtfObject

    {

    public:

                                                GdtfMacroVisualStep();

                                                ~GdtfMacroVisualStep();

    private:

        double                                  fDuration;

        double                                  fFade;

        double                                  fDelay;

        // Childs

        TGdtfMacroVisualValueArray              fVisualValues;

    public:

        TGdtfMacroVisualValueArray              GetVisualValueArray();

        virtual EGdtfObjectType                 GetObjectType();


    public:

        // Getter

        double                                  getDuration();

        double                                  getFade();

        double                                  getDelay();

        // Setter

        void                                    setDuration(double d);

        void                                    setFade(double f);

        void                                    setDelay(double d);

        //

        GdtfMacroVisualValue*                   AddVisualValue(DmxValue& dmxVal, GdtfDmxChannelFunctionPtr channelFunctionRef);

    protected:

        virtual TXString                        GetNodeName();

        virtual void                            OnPrintToFile(IXMLFileNodePtr pNode);

        virtual void                            OnReadFromNode(const IXMLFileNodePtr& pNode);

        virtual void                            OnErrorCheck(const IXMLFileNodePtr& pNode);

    };


    typedef GdtfMacroVisualStep*    GdtfMacroVisualStepPtr;

    typedef std::vector<GdtfMacroVisualStep*>   TGdtfMacroVisualStepArray;


    class GdtfMacroVisual : public GdtfObject

    {

    public:

                                                GdtfMacroVisual();

                                                ~GdtfMacroVisual();

    private:

        TGdtfMacroVisualStepArray               fVisualSteps;

    public:

        virtual EGdtfObjectType                 GetObjectType();


        TGdtfMacroVisualStepArray               GetVisualStepArray();

        GdtfMacroVisualStepPtr                  AddVisualStep();


    protected:

        virtual TXString                        GetNodeName();

        virtual void                            OnPrintToFile(IXMLFileNodePtr pNode);

        virtual void                            OnReadFromNode(const IXMLFileNodePtr& pNode);

    };


    typedef GdtfMacroVisual*    GdtfMacroVisualPtr;


    class GdtfDmxMode : public GdtfObject

    {

    public:

                                                GdtfDmxMode(GdtfFixture* fixture, const TXString& name);

                                                ~GdtfDmxMode();


    private:

        TXString                                fName;

        TXString                                fDescription;

        GdtfGeometryPtr                         fGeomRef;

        GdtfFixture*                            fFixture;

        TXString                                fUnresolvedGeomRef;

        //

        TGdtfDmxChannelArray                    fChannels;

        TGdtfDmxRelationArray                   fRelations;

        TGdtfMacroArray                         fMacros;


    public:

        const TXString&                         GetModeName() const;

        const TXString&                         GetDescription() const;

        const TGdtfDmxChannelArray              GetChannelArray() const;

        GdtfDmxChannelPtr                       GetMasterByRef(const TXString& ref) const;

        GdtfDmxChannelFunctionPtr               GetSlaveByRef(const TXString& ref) const;

        GdtfGeometryPtr                         GetGeomRef();

        TGdtfDmxChannelArray                    GetChannelsForGeometry(GdtfGeometryPtr geometry);


        const TXString&                         GetUnresolvedGeomRef();

        const TGdtfDmxRelationArray             GetDmxRelations();

        size_t                                  GetFootPrintForBreak(size_t breakId);

        TSint32Array                            GetBreakArray() const;

        void                                    GetAddressesFromChannel(TDMXAddressArray& addresses, GdtfDmxChannel* channel, DMXAddress offset) const;

        const TGdtfMacroArray                   GetDmxMacrosArray();


        void                                    SetName(const TXString& name);

        void                                    SetDescription(const TXString& description);

        GdtfDmxChannelPtr                       AddChannel();

        void                                    SetGeomRef(GdtfGeometryPtr ptr);

        void                                    SetModel(GdtfGeometryPtr ptr);

        GdtfDmxRelation*                        AddDmxRelation(GdtfDmxChannel* master, GdtfDmxChannelFunctionPtr slave, const TXString &name);

        GdtfMacroPtr                            AddMacro(const TXString &name);

    public:

        virtual EGdtfObjectType                 GetObjectType();


    protected:

        virtual TXString                        GetNodeName();

        virtual void                            OnPrintToFile(IXMLFileNodePtr pNode);

        virtual void                            OnReadFromNode(const IXMLFileNodePtr& pNode);

        virtual void                            OnErrorCheck(const IXMLFileNodePtr& pNode);


    };


    typedef GdtfDmxMode*                GdtfDmxModePtr;

    typedef std::vector<GdtfDmxMode*>   TGdtfDmxModeArray;


    //------------------------------------------------------------------------------------

    // GdtfRevision Definition


    class GdtfRevision : public GdtfObject

    {

    public:

                                                GdtfRevision();

                                                ~GdtfRevision();


    private:

        TXString                                fText;

        STime                                   fDateS;

        size_t                                  fUserId;

        TXString                                fModifiedBy;


    public:

        virtual EGdtfObjectType                 GetObjectType();


    public:

        // Getter

        const STime&                            GetDate() const;

        const TXString&                         GetText() const;

        size_t                                  GetUserId() const;

        const TXString&                         GetModifiedBy() const;

        // Setter

        void                                    SetText(const TXString& text);

        void                                    SetDate(const STime& date);

        void                                    SetUserId(size_t userId);

        void                                    SetModifiedBy(const TXString& text);

    protected:

        virtual TXString                        GetNodeName();

        virtual void                            OnPrintToFile(IXMLFileNodePtr pNode);

        virtual void                            OnReadFromNode(const IXMLFileNodePtr& pNode);

        virtual void                            OnErrorCheck(const IXMLFileNodePtr& pNode);

    };


    typedef GdtfRevision*   GdtfRevisionPtr;

    typedef std::vector<GdtfRevision*>  TGdtfRevisionArray;


    //------------------------------------------------------------------------------------

    // Protocolls Definitions


    class GdtfProtocols : public GdtfObject

    {

    public:

                                                GdtfProtocols();

                                                ~GdtfProtocols();

    private:

        // Childs

        GdtfFTRDM*                              fRDM;

        GdtfArtNet*                             fArtNet;

        GdtfsAcn*                               fsACN;

        GdtfKiNET*                              fKiNET;

        GdtfPosiStageNet*                       fPosiStageNet;

        GdtfOpenSoundControl*                   fOpenSoundControl;

        GdtfCITP*                               fCITP;

    public:

        virtual EGdtfObjectType                 GetObjectType();


    public:

        // Getter

        GdtfFTRDM*                              GetRDM();

        GdtfArtNet*                             GetArtNet();

        GdtfsAcn*                               GetSACN();

        GdtfKiNET*                              GetKiNET();

        GdtfPosiStageNet*                       GetPosiStageNet();

        GdtfOpenSoundControl*                   GetOpenSoundControl();

        GdtfCITP*                               GetCITP();

        // Setter

        GdtfFTRDM*                              CreateRDM();

        GdtfArtNet*                             CreateArtNet();

        GdtfsAcn*                               CreateSACN();

        void                                    SetKiNET(GdtfKiNET* val);

        void                                    SetPosiStageNet(GdtfPosiStageNet* val);

        void                                    SetOpenSoundControl(GdtfOpenSoundControl* val);

        void                                    SetCITP(GdtfCITP* val);


    protected:

        virtual TXString                        GetNodeName();

        virtual void                            OnPrintToFile(IXMLFileNodePtr pNode);

        virtual void                            OnReadFromNode(const IXMLFileNodePtr& pNode);

        virtual void                            OnErrorCheck(const IXMLFileNodePtr& pNode);

    };


    typedef GdtfProtocols*  GdtfProtocolsPtr;


    class GdtfFTRDM : public GdtfObject

    {

    public:

                                                GdtfFTRDM();

                                                GdtfFTRDM(size_t manufacturerID, size_t deviceModelID);

                                                ~GdtfFTRDM();

    private:

        // Attributes

        size_t                                  fManufacturerID;  // Manufacturer ESTA ID; Size: 2 bytes

        size_t                                  fDeviceModelID;   // Unique device model ID; Size: 2 bytes


        TGdtfSoftwareVersionIDArray             fSoftwareVersionIDArray;

    public:

        virtual EGdtfObjectType                 GetObjectType();


    public:

        // Getter

        size_t                                  GetManufacturerID() const;

        size_t                                  GetDeviceModelID()  const;

        const TGdtfSoftwareVersionIDArray&      GetSoftwareVersIDs() const;

        // Setter

        void                                    SetManufacturerID(size_t val);

        void                                    SetDeviceModelID(size_t val);

        GdtfSoftwareVersionIDPtr                AddSoftwareVersID(size_t value);

    protected:

        virtual TXString                        GetNodeName();

        virtual void                            OnPrintToFile(IXMLFileNodePtr pNode);

        virtual void                            OnReadFromNode(const IXMLFileNodePtr& pNode);

        virtual void                            OnErrorCheck(const IXMLFileNodePtr& pNode);

    };


    typedef GdtfFTRDM*  GdtfFTRDMPtr;


    class GdtfDMXPersonality : public GdtfObject

    {

    public:

                                                GdtfDMXPersonality();

                                                GdtfDMXPersonality(size_t value, GdtfDmxModePtr dmxMode);

                                                ~GdtfDMXPersonality();

    private:

        size_t                                  fValue;

        TXString                                fDMXMode_Unresolved;

        GdtfDmxModePtr                          fDMXMode;

    public:

        virtual EGdtfObjectType                 GetObjectType();


    public:

        // Getter

        size_t                                  GetValue() const;

        GdtfDmxModePtr                          GetDMXMode() const;

        const TXString&                         GetUnresolvedDMXMode() const;

        // Setter

        void                                    SetValue(size_t val);

        void                                    SetDMXMode(GdtfDmxModePtr mode);

    protected:

        virtual TXString                        GetNodeName();

        virtual void                            OnPrintToFile(IXMLFileNodePtr pNode);

        virtual void                            OnReadFromNode(const IXMLFileNodePtr& pNode);

    };


    typedef GdtfDMXPersonality* GdtfDMXPersonalityPtr;

    typedef std::vector<GdtfDMXPersonality*>    TGdtfDMXPersonalityArray;


    class GdtfSoftwareVersionID : public GdtfObject

    {

    public:

                                                GdtfSoftwareVersionID();

                                                GdtfSoftwareVersionID(size_t value);

                                                ~GdtfSoftwareVersionID();

    private:

        size_t                                  fValue;

        TGdtfDMXPersonalityArray                fDmxPersonalityArray;

    public:

        virtual EGdtfObjectType                 GetObjectType();


        // Getter

        size_t                                  GetValue() const;

        const TGdtfDMXPersonalityArray&         GetDMXPersonalityArray();

        // Setter

        void                                    SetValue(size_t val);

        GdtfDMXPersonalityPtr                   AddDMXPersonality(size_t value, GdtfDmxModePtr dmxMode);

    protected:

        virtual TXString                        GetNodeName();

        virtual void                            OnPrintToFile(IXMLFileNodePtr pNode);

        virtual void                            OnReadFromNode(const IXMLFileNodePtr& pNode);

    };


    typedef GdtfSoftwareVersionID*  GdtfSoftwareVersionIDPtr;

    typedef std::vector<GdtfSoftwareVersionID*> TGdtfSoftwareVersionIDArray;


    class GdtfMap : public GdtfObject

    {

    public:

                                                GdtfMap();

                                                GdtfMap(Uint32 key, Uint32 value);

                                                ~GdtfMap();

    private:

        Uint32                                  fKey;

        Uint32                                  fValue;

    public:

        virtual EGdtfObjectType                 GetObjectType();

        // Getters

        Uint32                                  GetKey() const;

        Uint32                                  GetValue() const;


        // Setters

        void                                    SetKey(Uint32 key);

        void                                    SetValue(Uint32 value);


    protected:

        virtual TXString                        GetNodeName();

        virtual void                            OnPrintToFile(IXMLFileNodePtr pNode);

        virtual void                            OnReadFromNode(const IXMLFileNodePtr& pNode);

        virtual void                            OnErrorCheck(const IXMLFileNodePtr& pNode);

    };


    typedef GdtfMap* GdtfMapPtr;

    typedef std::vector<GdtfMapPtr> TGdtfMapArray;


    class GdtfArtNet : public GdtfObject

    {

    public:

                                                GdtfArtNet();

                                                ~GdtfArtNet();

    private:

        TGdtfMapArray                           fMaps;

    public:

        virtual EGdtfObjectType                 GetObjectType();


        // Getters

        const TGdtfMapArray&                    GetMapArray();


        // Setters

        GdtfMapPtr                              CreateMap(Uint32 key, Uint32 value);

    protected:

        virtual TXString                        GetNodeName();

        virtual void                            OnPrintToFile(IXMLFileNodePtr pNode);

        virtual void                            OnReadFromNode(const IXMLFileNodePtr& pNode);

    };


    typedef GdtfArtNet* GdtfArtNetPtr;


    class GdtfsAcn : public GdtfObject

    {

    public:

                                                GdtfsAcn();

                                                ~GdtfsAcn();

    private:

        TGdtfMapArray                           fMaps;

    public:

        virtual EGdtfObjectType                 GetObjectType();


        // Getters

        const TGdtfMapArray&                    GetMapArray();


        // Setters

        GdtfMapPtr                              CreateMap(Uint32 key, Uint32 value);


    protected:

        virtual TXString                        GetNodeName();

        virtual void                            OnPrintToFile(IXMLFileNodePtr pNode);

        virtual void                            OnReadFromNode(const IXMLFileNodePtr& pNode);

    };


    typedef GdtfsAcn*   GdtfsAcnPtr;


    class GdtfKiNET : public GdtfObject

    {

    public:

                                                GdtfKiNET();

                                                ~GdtfKiNET();

    private:

        // Atributes

        // TODO: This TYPE not defined in the docu to this day(26.09.18). Implement later.

    public:

        virtual EGdtfObjectType                 GetObjectType();


    public:

        // Getter

        // ...

        // Setter

        // ...

    protected:

        virtual TXString                        GetNodeName();

        //virtual   void                    OnPrintToFile(IXMLFileNodePtr pNode);

        //virtual   void                    OnReadFromNode(const IXMLFileNodePtr& pNode);

    };


    typedef GdtfKiNET*  GdtfKiNETPtr;


    class GdtfPosiStageNet : public GdtfObject

    {

    public:

                                                GdtfPosiStageNet();

                                                ~GdtfPosiStageNet();

    private:

        // Atributes

        // TODO: This TYPE not defined in the docu to this day(26.09.18). Implement later.

    public:

        virtual EGdtfObjectType                 GetObjectType();


    public:

        // Getter

        // ...

        // Setter

        // ...

    protected:

        virtual TXString                        GetNodeName();

        //virtual   void                    OnPrintToFile(IXMLFileNodePtr pNode);

        //virtual   void                    OnReadFromNode(const IXMLFileNodePtr& pNode);

    };


    typedef GdtfPosiStageNet*   GdtfPosiStageNetPtr;


    class GdtfOpenSoundControl : public GdtfObject

    {

    public:

                                                GdtfOpenSoundControl();

                                                ~GdtfOpenSoundControl();

    private:

        // Atributes

        // TODO: This TYPE not defined in the docu to this day(26.09.18). Implement later.

    public:

        virtual EGdtfObjectType                 GetObjectType();


    public:

        // Getter

        // ...

        // Setter

        // ...

    protected:

        virtual TXString                        GetNodeName();

        //virtual   void                    OnPrintToFile(IXMLFileNodePtr pNode);

        //virtual   void                    OnReadFromNode(const IXMLFileNodePtr& pNode);

    };


    typedef GdtfOpenSoundControl*   GdtfOpenSoundControlPtr;


    class GdtfCITP : public GdtfObject

    {

    public:

                                                GdtfCITP();

                                                ~GdtfCITP();

    private:

        // Atributes

        // TODO: This TYPE not defined in the docu to this day(26.09.18). Implement later.

    public:

        virtual EGdtfObjectType                 GetObjectType();


    public:

        // Getter

        // ...

        // Setter

        // ...

    protected:

        virtual TXString                        GetNodeName();

        //virtual   void                    OnPrintToFile(IXMLFileNodePtr pNode);

        //virtual   void                    OnReadFromNode(const IXMLFileNodePtr& pNode);

    };


    typedef GdtfCITP*   GdtfCITPPtr;


    //------------------------------------------------------------------------------------

    // GdtfUserPreset Definition


    class GdtfUserPreset : public GdtfObject

    {

    public:

                                                GdtfUserPreset();

                                                ~GdtfUserPreset();


    public:

        virtual EGdtfObjectType                 GetObjectType();


    protected:

        virtual TXString                        GetNodeName();

        virtual void                            OnPrintToFile(IXMLFileNodePtr pNode);

        virtual void                            OnReadFromNode(const IXMLFileNodePtr& pNode);


    };


    typedef GdtfUserPreset*                 GdtfUserPresetPtr;

    typedef std::vector<GdtfUserPresetPtr>  TGdtfUserPresetArray;


    class GdtfMeasurementPoint : public GdtfObject

    {

    public:

                                                GdtfMeasurementPoint();

                                                ~GdtfMeasurementPoint();


    private:

        double                                  fWaveLength;    // Unit nm

        double                                  fEngergy;       // Unit W/m^2*/nm


    public:

        virtual EGdtfObjectType                 GetObjectType();

        double                                  GetWavelength();

        double                                  GetEnergy();


        void                                    SetWavelength(double wavelength);

        void                                    SetEnergy(double energy);


    protected:

        virtual TXString                        GetNodeName();

        virtual void                            OnPrintToFile(IXMLFileNodePtr pNode);

        virtual void                            OnReadFromNode(const IXMLFileNodePtr& pNode);

        virtual void                            OnErrorCheck(const IXMLFileNodePtr& pNode);


    };


    typedef GdtfMeasurementPoint*               GdtfMeasurementPointPtr;

    typedef std::vector<GdtfMeasurementPoint*>  TGdtfMeasurementPointArray;


    class GdtfMeasurement : public GdtfObject

    {

    public:

                                                GdtfMeasurement(bool forFilter);

                                                ~GdtfMeasurement();

    private:

        double                                  fPhysical;

        double                                  fLuminousIntensity;

        double                                  fTransmission;

        EGdtfInterpolationTo                    fInterpolationTo;

        bool                                    fIsForFilter;

        TGdtfMeasurementPointArray              fMeasurementPoints;


    public:

        virtual EGdtfObjectType                 GetObjectType();


        // Getter

        double                                  GetPhysical();

        double                                  GetLuminousIntensity();

        double                                  GetTransmission();

        EGdtfInterpolationTo                    GetInterpolationTo();

        const TGdtfMeasurementPointArray&       GetMeasurementPointsArray();

        // Setter

        void                                    SetPhysical(double val);

        void                                    SetLuminousIntensity(double val);

        void                                    SetTransmission(double val);

        void                                    SetInterpolationTo(EGdtfInterpolationTo val);

        GdtfMeasurementPoint*                   CreateMeasurementPoint();

    protected:

        virtual TXString                        GetNodeName();

        virtual void                            OnPrintToFile(IXMLFileNodePtr pNode);

        virtual void                            OnReadFromNode(const IXMLFileNodePtr& pNode);

    };


    typedef GdtfMeasurement*    GdtfMeasurementPtr;


    //------------------------------------------------------------------------------------

    // GdtfPhysicalDescription Definition


    class GdtfPhysicalEmitter : public GdtfObject

    {

    public:

                                                GdtfPhysicalEmitter();

                                                GdtfPhysicalEmitter(const TXString& name, CCieColor color);

                                                ~GdtfPhysicalEmitter();

    private:

        TXString                                fName;

        CCieColor                               fColor;

        double                                  fDominantWaveLength;

        TXString                                fDiodePart;

        //

        TGdtfMeasurementArray                   fMeasurements;


    public:

        // Getter

        virtual EGdtfObjectType                 GetObjectType();

        const TXString&                         GetName() const;

        CCieColor                               GetColor() const;

        virtual TXString                        GetNodeReference();

        const TXString&                         GetDiodePart();

        double                                  GetDominantWaveLength();

        const TGdtfMeasurementArray             GetMeasurements();

        // Setter

        void                                    SetName(const TXString& name);

        void                                    SetColor(CCieColor color);

        void                                    SetDiodePart(const TXString& val);

        void                                    SetDominantWaveLength(double val);


        GdtfMeasurement*                        AddMeasurement();


    protected:

        virtual TXString                        GetNodeName();

        virtual void                            OnPrintToFile(IXMLFileNodePtr pNode);

        virtual void                            OnReadFromNode(const IXMLFileNodePtr& pNode);

        virtual void                            OnErrorCheck(const IXMLFileNodePtr& pNode);


    };


    class GdtfCRI : public GdtfObject

    {

    public:

                                                GdtfCRI();

                                                GdtfCRI(EGdtfColorSample ces, Uint8 cri);

                                                ~GdtfCRI();

    private:

        // Attributes

        EGdtfColorSample                        fCES;

        Uint8                                   fCRI;

    public:

        virtual EGdtfObjectType                 GetObjectType();


        // Getter

        EGdtfColorSample                        GetColorSample() const;

        Uint8                                   GetColorRenderingIndex() const;

        // Setter

        void                                    SetColorSample(EGdtfColorSample val);

        void                                    SetColorRenderingIndex(Uint8 val);

    protected:

        virtual TXString                        GetNodeName();

        virtual void                            OnPrintToFile(IXMLFileNodePtr pNode);

        virtual void                            OnReadFromNode(const IXMLFileNodePtr& pNode);

        virtual void                            OnErrorCheck(const IXMLFileNodePtr& pNode);

    };


    typedef GdtfCRI*    GdtfCRIPtr;

    typedef std::vector<GdtfCRI*>   TGdtf_CRIArray;


    class GdtfCRIGroup : public GdtfObject

    {

    public:

                                                GdtfCRIGroup();

                                                GdtfCRIGroup(double colorTsemp);

                                                ~GdtfCRIGroup();

    private:

        // Attributes

        double                                  fColorTemperature; // Color temperature; Default value : 6000; Unit: kelvin


        // Childs

        TGdtf_CRIArray                          fCRI_Array;

    public:

        virtual EGdtfObjectType                 GetObjectType();


        // Getter

        double                                  GetColorTemperature() const;

        TGdtf_CRIArray                          GetCRI_Array() const;

        // Setter

        void                                    SetColorTemperature(double val);

        GdtfCRIPtr                              Add_CRI(EGdtfColorSample ces, Sint32 colorTemp);

    protected:

        virtual TXString                        GetNodeName();

        virtual void                            OnPrintToFile(IXMLFileNodePtr pNode);

        virtual void                            OnReadFromNode(const IXMLFileNodePtr& pNode);

        virtual void                            OnErrorCheck(const IXMLFileNodePtr& pNode);

    };


    class GdtfPoint : public GdtfObject

    {

    public:

                                                GdtfPoint();

                                                GdtfPoint(double DMXPercentage, double CFC3, double CFC2, double CFC1, double CFC0);

                                                ~GdtfPoint();

    private:

        // Attributes

        double                                  fDMXPercentage;

        double                                  fCFC3;

        double                                  fCFC2;

        double                                  fCFC1;

        double                                  fCFC0;

    public:

        virtual EGdtfObjectType                 GetObjectType();


        // Getters

        double                                  GetDMXPercentage() const;

        double                                  GetCFC3() const;

        double                                  GetCFC2() const;

        double                                  GetCFC1() const;

        double                                  GetCFC0() const;


        // Setters

        void                                    SetDMXPercentage(double dmxPercentage);

        void                                    SetCFC3(double CFC3);

        void                                    SetCFC2(double CFC2);

        void                                    SetCFC1(double CFC1);

        void                                    SetCFC0(double CFC0);


    protected:

        virtual TXString                        GetNodeName();

        virtual void                            OnPrintToFile(IXMLFileNodePtr pNode);

        virtual void                            OnReadFromNode(const IXMLFileNodePtr& pNode);

        virtual void                            OnErrorCheck(const IXMLFileNodePtr& pNode);

    };


    typedef GdtfPoint*  GdtfPointPtr;

    typedef std::vector<GdtfPoint*> TGdtfPointArray;


    class GdtfDMXProfile : public GdtfObject

    {

    public:

                                                GdtfDMXProfile();

                                                ~GdtfDMXProfile();

    private:

        // Attributes

        TXString                                fUniqueName;


        // Children

        TGdtfPointArray                         fPoints;

    public:

        virtual EGdtfObjectType                 GetObjectType();

        virtual TXString                        GetNodeReference();


        // Getters

        const TXString&                         GetName() const;

        TGdtfPointArray                         GetPointArray() const;

        // Setters

        void                                    SetName(const TXString& name);

        GdtfPointPtr                            AddPoint(double DMXPercentage, double CFC3, double CFC2, double CFC1, double CFC0);

    protected:

        virtual TXString                        GetNodeName();

        virtual void                            OnPrintToFile(IXMLFileNodePtr pNode);

        virtual void                            OnReadFromNode(const IXMLFileNodePtr& pNode);

        virtual void                            OnErrorCheck(const IXMLFileNodePtr& pNode);

    };


    class GdtfConnector : public GdtfObject

    {

    public:

                                                GdtfConnector();

                                                GdtfConnector(const TXString& name, const TXString& type);

                                                ~GdtfConnector();

    private:

        TXString                                fName;

        TXString                                fType;

        Uint32                                  fDmxBreak;

        Sint32                                  fGender;

        double                                  fLength;


    public:

        // Getter

        virtual EGdtfObjectType                 GetObjectType();

        virtual TXString                        GetNodeReference();


        const TXString&                         GetName() const;

        const TXString&                         GetType() const;

        Uint32                                  GetDmxBreak();

        Sint32                                  GetGender();

        double                                  GetLength();


        // Setter

        void                                    SetName(const TXString& name);

        void                                    SetType(const TXString& type);

        void                                    SetDmxBreak(Uint32 dmxBreak);

        void                                    SetGender(Sint32 gender);

        void                                    SetLength(double length);


    protected:

        virtual TXString                        GetNodeName();

        virtual void                            OnPrintToFile(IXMLFileNodePtr pNode);

        virtual void                            OnReadFromNode(const IXMLFileNodePtr& pNode);

        virtual void                            OnErrorCheck(const IXMLFileNodePtr& pNode);


    };


    //------------------------------------------------------------------------------------

    // GdtfFixture Definition


    class GdtfFixture : public GdtfObject

    {

    public:

                                                GdtfFixture();

                                                ~GdtfFixture();


    private:

        //------------------------------------------------

        // Parameters for a GdtfFixture

        TXString                                fName;

        TXString                                fShortName;

        TXString                                fLongName;

        TXString                                fManufacturer;

        TXString                                fFixtureTypeDescription;

        TXString                                fFunction;

        GdtfFixtureGUID                         fGuid;

        TXString                                fTumbnailName;

        Sint32                                  fThumbnailOffsetX;

        Sint32                                  fThumbnailOffsetY;

        bool                                    fCanHaveChildren;

        TXString                                fTumbnailFullPath_PNG;

        TXString                                fTumbnailFullPath_SVG;


        GdtfFixtureGUID                         fLinkedGuid;

        bool                                    fHasLinkedGuid;


        GdtfProtocols                           fProtocollContainer;

        //------------------------------------------------

        // Storage


        // This are not seperated here and placed in the AttributeDefinitions node

        // there is no special class for this

        TGdtfActivationGroupArray               fActivationGroups;

        TGdtfFeatureGroupArray                  fFeatureGroups;

        TGdtfAttributeArray                     fAttributes;


        TGdtfWheelArray                         fWheels;

        TGdtfModelArray                         fModels;

        TGdtfGeometryArray                      fGeometries;

        TGdtfDmxModeArray                       fDmxModes;

        TGdtfRevisionArray                      fRevisions;

        TGdtfUserPresetArray                    fPresets;

        GdtfPhysicalDescriptions                fPhysicalDesciptions;

        //------------------------------------------------

        // Reading support

        TVWArray_IFileIdentifier                fLocalFiles;

        TXStringArray                           fLocalFilesFullPath;

        bool                                    fReaded;

        IFolderIdentifierPtr                    fWorkingFolder;

        TGdtfParsingErrorArray                  fParsingErrors;


        size_t                                  fTotalNodesCount = 0;


        Sint32                                  fMajorVersion = 0;

        Sint32                                  fMinorVersion = 0;


        //

        GdtfAttributePtr                        fNoFeature;


        std::map<TXString, std::pair<char*, size_t> > fFileBuffers;


    public:

        static TGdtfParsingErrorArray*          __ERROR_CONTAINER_POINTER;

        static void                             AddError(const GdtfParsingError& error);

        TGdtfParsingErrorArray&                 GetParsingErrorArray();


        TXString                                GetFullThumbNailPath(const TXString & fileExtension);

        size_t                                  GetAttachedFileCount();

        bool                                    GetAttachedFileCountAt(size_t at, TXString*& outFile);


    private:

        TGdtfParsingErrorArray                  fErrorContainer;


    public:

        //----------------------------------------------------------------------------------------------------------------------------------------------------------------

        // Getter

        const TXString&                         GetName() const;

        const TXString&                         GetShortName() const;

        const TXString&                         GetLongName() const;

        const TXString&                         GetManufacturer() const;

        const TXString&                         GetFixtureTypeDescription() const;

        GdtfFixtureGUID                         GetGuid() const;

        GdtfFixtureGUID                         GetLinkedGuid() const;

        bool                                    HasLinkedGuid() const;

        const TXString&                         GetThumbnailName() const;

        Sint32                                  GetThumbnailOffsetX() const;

        Sint32                                  GetThumbnailOffsetY() const;

        bool                                    GetCanHaveChildren() const;

        const GdtfPNGFile&                      GetPNGThumnailFullPath();

        const TXString&                         GetSVGThumnailFullPath();

        GdtfProtocols&                          GetProtocollContainer();

        GdtfPhysicalDescriptions&               GetPhysicalDesciptionsContainer();

        Sint32                                  GetMajorVersion() const;

        Sint32                                  GetMinorVersion() const;


        // Setter

        void                                    SetName(const TXString& name);

        void                                    SetShortName(const TXString& shortName);

        void                                    SetLongName(const TXString& longName);

        void                                    SetManufacturer(const TXString& manu);

        void                                    SetFixtureTypeDescription(const TXString& desc);

        void                                    SetGuid(const VWFC::Tools::VWUUID& uuid);

        void                                    SetLinkedGuid(const VWFC::Tools::VWUUID& uuid);

        void                                    SetThumbnailName(const TXString& fileName);

        void                                    SetThumbnailOffsetX(Sint32 thumbnailOffsetX);

        void                                    SetThumbnailOffsetY(Sint32 thumbnailOffsetY);

        void                                    SetCanHaveChildren(bool canHaveChildren);


        void                                    SetMajorVersion( Sint32 majorVersion );

        void                                    SetMinorVersion( Sint32 minorVersion );


    public:

        //----------------------------------------------------------------------------------------------------------------------------------------------------------------

        // Add calls

        GdtfRevisionPtr                         AddRevision(const TXString& text, const STime& date);

        GdtfAttributePtr                        AddAttribute(const TXString& name, const TXString& prettyName);


        GdtfModelPtr                            AddModel(const TXString& name);

        GdtfGeometryPtr                         AddGeometry(                    const TXString& name, GdtfModelPtr refToModel, const VWTransformMatrix& ma);

        GdtfGeometryPtr                         AddGeometryReference(           const TXString& name, GdtfModelPtr refToModel, const VWTransformMatrix& ma);

        GdtfGeometryPtr                         AddGeometryShaper(              const TXString& name, GdtfModelPtr refToModel, const VWTransformMatrix& ma);

        GdtfGeometryPtr                         AddGeometryColor(               const TXString& name, GdtfModelPtr refToModel, const VWTransformMatrix& ma);

        GdtfGeometryPtr                         AddGeometryGobo(                const TXString& name, GdtfModelPtr refToModel, const VWTransformMatrix& ma);

        GdtfGeometryPtr                         AddGeometryBeam(                const TXString& name, GdtfModelPtr refToModel, const VWTransformMatrix& ma);

        GdtfGeometryPtr                         AddGeometryMediaServerCamera(   const TXString& name, GdtfModelPtr refToModel, const VWTransformMatrix& ma);

        GdtfGeometryPtr                         AddGeometryMediaServerLayer(    const TXString& name, GdtfModelPtr refToModel, const VWTransformMatrix& ma);

        GdtfGeometryPtr                         AddGeometryMediaServerMaster(   const TXString& name, GdtfModelPtr refToModel, const VWTransformMatrix& ma);

        GdtfGeometryPtr                         AddGeometryWithAxis(            const TXString& name, GdtfModelPtr refToModel, const VWTransformMatrix& ma);

        GdtfGeometryPtr                         AddGeometryWithLamp(            const TXString& name, GdtfModelPtr refToModel, const VWTransformMatrix& ma);

        GdtfGeometryPtr                         AddGeometryDisplay(             const TXString& name, GdtfModelPtr refToModel, const VWTransformMatrix& ma);

        GdtfGeometryPtr                         AddGeometryLaser(               const TXString& name, GdtfModelPtr refToModel, const VWTransformMatrix& ma);

        GdtfGeometryPtr                         AddGeometryWiringObject(        const TXString& name, GdtfModelPtr refToModel, const VWTransformMatrix& ma);

        GdtfGeometryPtr                         AddGeometryInventory(           const TXString& name, GdtfModelPtr refToModel, const VWTransformMatrix& ma);

        GdtfGeometryPtr                         AddGeometryStructure(           const TXString& name, GdtfModelPtr refToModel, const VWTransformMatrix& ma);

        GdtfGeometryPtr                         AddGeometrySupport(             const TXString& name, GdtfModelPtr refToModel, const VWTransformMatrix& ma);

        GdtfGeometryPtr                         AddGeometryMagnet(              const TXString& name, GdtfModelPtr refToModel, const VWTransformMatrix& ma);


        GdtfWheelPtr                            AddWheel(TXString name);

        GdtfDmxModePtr                          AddDmxMode(const TXString& name);

        GdtfMacroPtr                            AddMacro(const TXString& name);


        GdtfUserPresetPtr                       AddUserPreset();

        GdtfFeatureGroupPtr                     AddFeatureGroup(const TXString& name, const TXString& prettyName);

        GdtfActivationGroupPtr                  AddActivationGroup(const TXString& name);


        //----------------------------------------------------------------------------------------------------------------------------------------------------------------

        // Read calls

        const TGdtfWheelArray&                  GetWheelArray();

        const TGdtfGeometryArray&               GetGeometryArray();

        const TGdtfActivationGroupArray&        GetActivationGroupArray();

        const TGdtfFeatureGroupArray&           GetFeatureGroupArray();

        const TGdtfAttributeArray&              GetAttributeArray();

        const TGdtfModelArray&                  GetModelArray();

        const TGdtfDmxModeArray&                GetDmxModeArray();

        const TGdtfRevisionArray&               GetRevisionArray();

        const TGdtfUserPresetArray&             GetPresetArray();

        const TGdtfMacroArray&                  GetMacroArray();


        const std::map<TXString, std::pair<char*, size_t> >& GetFileBuffers();


    public:

        virtual EGdtfObjectType                 GetObjectType();


    protected:

        virtual TXString                        GetNodeName();

        virtual void                            OnPrintToFile(IXMLFileNodePtr pNode);

        virtual void                            OnReadFromNode(const IXMLFileNodePtr& pNode);

        virtual void                            OnErrorCheck(const IXMLFileNodePtr& pNode);


        void                                    CreateNoFeatureAttribute();

        GdtfAttributePtr                        getAttributeByRef(const TXString& ref);

        GdtfWheelPtr                            getWheelByRef(const TXString& ref);

        GdtfPhysicalEmitterPtr                  getEmiterByRef(const TXString& ref);

        GdtfDmxChannelFunctionPtr               getDmxFunctionByRef(const TXString& ref, GdtfDmxModePtr mode);

        GdtfDmxChannelPtr                       getDmxChannelByRef(const TXString& ref, GdtfDmxModePtr mode);

        GdtfFilterPtr                           getFilterByRef(const TXString& ref);

        GdtfConnectorPtr                        getConnectorByRef(const TXString& ref);

        GdtfColorSpacePtr                       getColorSpaceByRef(const TXString& ref);

        GdtfGamutPtr                            getGamutByRef(const TXString& ref);

        GdtfDMXProfilePtr                       getDMXProfileByRef(const TXString& ref);

        GdtfSubPhysicalUnitPtr                  getSubPhysicalUnitByRef(const TXString& ref);


        //

        void                                    AutoGenerateNames(GdtfDmxModePtr dmxMode);


        // Resolve References

        void                                    ResolveAllReferences();

        void                                    ResolveGeometryRefs();

        void                                    ResolveGeometryRefs_Recursive(GdtfGeometryPtr geometry);


        void                                    ResolveAttribRefs();

        void                                    ResolveWheelSlots();

        void                                    ResolveDmxModeRefs();

        void                                    ResolveDMXModeMasters();

        void                                    ResolveDMXPersonalityRefs();

        void                                    ResolveDmxRelationRefs(GdtfDmxModePtr dmxMode);

        void                                    ResolveDmxChannelRefs(GdtfDmxModePtr dmxMode);

        GdtfGeometryPtr                         ResolveGeometryRef(const TXString& unresolvedGeoRef, const TGdtfGeometryArray& geometryArray);

        GdtfDmxModePtr                          ResolveDMXMode(const TXString & unresolvedDMXmode);


        void                                    ResolveDmxLogicalChanRefs(GdtfDmxChannelPtr dmxChnl);

        void                                    ResolveDmxChanelFunctionRefs(GdtfDmxLogicalChannelPtr dmxLogChnl);

        void                                    ResolveDmxSubChannelSetRefs(GdtfDmxChannelFunctionPtr channelFunction);

        void                                    ResolveMacroRefs(GdtfDmxModePtr dmxMode);


    private:

        void                                    CheckForMissingModeMasters();

        //----------------------------------------------------------------------------------------------------------------------------------------------------------------


    private:

        bool                                    ImportFromZip(IZIPFilePtr& zipfile);

        void                                    PrepareWorkingFolder(TXString folderName);

        void                                    GetFileNodesCount(const IXMLFileNodePtr& rootNode);


    public:

        bool                                    ExportToFile(IZIPFilePtr& zipfile);

        void                                    ImportFromFile(IFileIdentifierPtr inZipFile, const TXString& folder);

        void                                    ImportFromBuffer(const char*buffer, size_t length, const TXString& folder);


        bool                                    IsReaded();

        void                                    GetWorkingFolder(IFolderIdentifierPtr& folder);

    };


}


CieColor.h

StatusID
Sint32 StatusID
Definition GDTFManager.h:16

Gdtf3DSFile
TXString Gdtf3DSFile
Definition GDTFManager.h:15

GdtfFixtureGUID
VectorworksMVR::VWFC::Tools::VWUUID GdtfFixtureGUID
Definition GDTFManager.h:13

GdtfPNGFile
TXString GdtfPNGFile
Definition GDTFManager.h:14

GDTFPrefix.h

Uint8
uint8_t Uint8
Definition GSTypes.h:25

Sint32
int32_t Sint32
Definition GSTypes.h:36

Uint32
uint32_t Uint32
Definition GSTypes.h:27

GdtfError.h

StdAfx.h

TDMXAddressArray
std::vector< VectorworksMVR::GdtfDefines::DMXAddress > TDMXAddressArray
Definition StdAfx.h:96

TSint32Array
std::vector< Sint32 > TSint32Array
Definition StdAfx.h:94

SceneData::GdtfActivationGroup
Definition GDTFManager.h:119

SceneData::GdtfActivationGroup::GetName
const TXString & GetName() const
Definition GDTFManager.cpp:190

SceneData::GdtfActivationGroup::AddLinkedAttribute
void AddLinkedAttribute(GdtfAttribute *attr)
Definition GDTFManager.cpp:200

SceneData::GdtfActivationGroup::OnReadFromNode
virtual void OnReadFromNode(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:150

SceneData::GdtfActivationGroup::OnPrintToFile
virtual void OnPrintToFile(IXMLFileNodePtr pNode)
Definition GDTFManager.cpp:137

SceneData::GdtfActivationGroup::~GdtfActivationGroup
~GdtfActivationGroup()
Definition GDTFManager.cpp:127

SceneData::GdtfActivationGroup::GetNodeReference
virtual TXString GetNodeReference()
Definition GDTFManager.cpp:205

SceneData::GdtfActivationGroup::GetLinkedAttributes
const std::vector< GdtfAttribute * > & GetLinkedAttributes() const
Definition GDTFManager.cpp:195

SceneData::GdtfActivationGroup::GdtfActivationGroup
GdtfActivationGroup()
Definition GDTFManager.cpp:122

SceneData::GdtfActivationGroup::GetObjectType
virtual EGdtfObjectType GetObjectType()
Definition GDTFManager.cpp:180

SceneData::GdtfActivationGroup::OnErrorCheck
virtual void OnErrorCheck(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:163

SceneData::GdtfActivationGroup::GetNodeName
virtual TXString GetNodeName()
Definition GDTFManager.cpp:185

SceneData::GdtfActivationGroup::SetName
void SetName(const TXString &name)
Definition GDTFManager.cpp:132

SceneData::GdtfArtNet
Definition GDTFManager.h:2323

SceneData::GdtfArtNet::GdtfArtNet
GdtfArtNet()
Definition GDTFManager.cpp:11000

SceneData::GdtfArtNet::OnPrintToFile
virtual void OnPrintToFile(IXMLFileNodePtr pNode)
Definition GDTFManager.cpp:11021

SceneData::GdtfArtNet::GetMapArray
const TGdtfMapArray & GetMapArray()
Definition GDTFManager.cpp:11009

SceneData::GdtfArtNet::CreateMap
GdtfMapPtr CreateMap(Uint32 key, Uint32 value)
Definition GDTFManager.cpp:11014

SceneData::GdtfArtNet::OnReadFromNode
virtual void OnReadFromNode(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:11033

SceneData::GdtfArtNet::GetObjectType
virtual EGdtfObjectType GetObjectType()
Definition GDTFManager.cpp:11055

SceneData::GdtfArtNet::~GdtfArtNet
~GdtfArtNet()
Definition GDTFManager.cpp:11004

SceneData::GdtfArtNet::GetNodeName
virtual TXString GetNodeName()
Definition GDTFManager.cpp:11060

SceneData::GdtfAttribute
Definition GDTFManager.h:266

SceneData::GdtfAttribute::GetNodeName
virtual TXString GetNodeName()
Definition GDTFManager.cpp:719

SceneData::GdtfAttribute::GdtfAttribute
GdtfAttribute(const TXString &name, const TXString &prettyName)
Definition GDTFManager.cpp:569

SceneData::GdtfAttribute::GetName
const TXString & GetName() const
Definition GDTFManager.cpp:724

SceneData::GdtfAttribute::SetFeature
void SetFeature(GdtfFeaturePtr newFeat)
Definition GDTFManager.cpp:754

SceneData::GdtfAttribute::~GdtfAttribute
~GdtfAttribute()
Definition GDTFManager.cpp:580

SceneData::GdtfAttribute::SetPhysicalUnit
void SetPhysicalUnit(EGdtfPhysicalUnit unit)
Definition GDTFManager.cpp:609

SceneData::GdtfAttribute::SetPrettyName
void SetPrettyName(const TXString &name)
Definition GDTFManager.cpp:590

SceneData::GdtfAttribute::GetUnresolvedActGroup
const TXString & GetUnresolvedActGroup() const
Definition GDTFManager.cpp:783

SceneData::GdtfAttribute::SetMainAttribute
void SetMainAttribute(GdtfAttribute *attr)
Definition GDTFManager.cpp:604

SceneData::GdtfAttribute::GetActivationGroup
GdtfActivationGroupPtr GetActivationGroup() const
Definition GDTFManager.cpp:734

SceneData::GdtfAttribute::HasColor
bool HasColor() const
Definition GDTFManager.cpp:744

SceneData::GdtfAttribute::OnPrintToFile
virtual void OnPrintToFile(IXMLFileNodePtr pNode)
Definition GDTFManager.cpp:627

SceneData::GdtfAttribute::SetActivationGroup
void SetActivationGroup(GdtfActivationGroupPtr ptr)
Definition GDTFManager.cpp:595

SceneData::GdtfAttribute::GetPhysicalUnit
EGdtfPhysicalUnit GetPhysicalUnit()
Definition GDTFManager.cpp:768

SceneData::GdtfAttribute::OnReadFromNode
virtual void OnReadFromNode(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:653

SceneData::GdtfAttribute::GetObjectType
virtual EGdtfObjectType GetObjectType()
Definition GDTFManager.cpp:715

SceneData::GdtfAttribute::SetColor
void SetColor(const CCieColor &col)
Definition GDTFManager.cpp:614

SceneData::GdtfAttribute::GdtfAttribute
GdtfAttribute()
Definition GDTFManager.cpp:559

SceneData::GdtfAttribute::GetUnresolvedFeature
const TXString & GetUnresolvedFeature() const
Definition GDTFManager.cpp:793

SceneData::GdtfAttribute::OnErrorCheck
virtual void OnErrorCheck(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:692

SceneData::GdtfAttribute::GetUnresolvedMainAttribute
const TXString & GetUnresolvedMainAttribute() const
Definition GDTFManager.cpp:788

SceneData::GdtfAttribute::GetFeature
GdtfFeaturePtr GetFeature() const
Definition GDTFManager.cpp:739

SceneData::GdtfAttribute::CreateSubPhysicalUnit
GdtfSubPhysicalUnitPtr CreateSubPhysicalUnit(EGdtfSubPhysicalUnitType type)
Definition GDTFManager.cpp:620

SceneData::GdtfAttribute::GetSubPhysicalUnitArray
TGdtfSubPhysicalUnitArray GetSubPhysicalUnitArray() const
Definition GDTFManager.cpp:749

SceneData::GdtfAttribute::GetNodeReference
virtual TXString GetNodeReference()
Definition GDTFManager.cpp:778

SceneData::GdtfAttribute::GetPrettyName
const TXString & GetPrettyName() const
Definition GDTFManager.cpp:729

SceneData::GdtfAttribute::SetName
void SetName(const TXString &name)
Definition GDTFManager.cpp:585

SceneData::GdtfAttribute::GetColor
CCieColor GetColor()
Definition GDTFManager.cpp:773

SceneData::GdtfAttribute::GetMainAttribute
GdtfAttribute * GetMainAttribute()
Definition GDTFManager.cpp:763

SceneData::GdtfBreak
Definition GDTFManager.h:1388

SceneData::GdtfBreak::SetDmxAddress
void SetDmxAddress(DMXAddress dmxAddress)
Definition GDTFManager.cpp:4594

SceneData::GdtfBreak::OnErrorCheck
virtual void OnErrorCheck(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:4626

SceneData::GdtfBreak::GetNodeName
virtual TXString GetNodeName()
Definition GDTFManager.cpp:4649

SceneData::GdtfBreak::GdtfBreak
GdtfBreak()
Definition GDTFManager.cpp:4578

SceneData::GdtfBreak::SetDmxBreak
void SetDmxBreak(Sint32 dmxBreak)
Definition GDTFManager.cpp:4589

SceneData::GdtfBreak::GetDmxBreak
Sint32 GetDmxBreak()
Definition GDTFManager.cpp:4654

SceneData::GdtfBreak::OnPrintToFile
virtual void OnPrintToFile(IXMLFileNodePtr pNode)
Definition GDTFManager.cpp:4599

SceneData::GdtfBreak::OnReadFromNode
virtual void OnReadFromNode(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:4613

SceneData::GdtfBreak::GetObjectType
virtual EGdtfObjectType GetObjectType()
Definition GDTFManager.cpp:4644

SceneData::GdtfBreak::~GdtfBreak
~GdtfBreak()
Definition GDTFManager.cpp:4585

SceneData::GdtfBreak::GetDmxAddress
DMXAddress GetDmxAddress()
Definition GDTFManager.cpp:4659

SceneData::GdtfCITP
Definition GDTFManager.h:2437

SceneData::GdtfCITP::GetObjectType
virtual EGdtfObjectType GetObjectType()
Definition GDTFManager.cpp:11207

SceneData::GdtfCITP::GdtfCITP
GdtfCITP()
Definition GDTFManager.cpp:11199

SceneData::GdtfCITP::~GdtfCITP
~GdtfCITP()
Definition GDTFManager.cpp:11203

SceneData::GdtfCITP::GetNodeName
virtual TXString GetNodeName()
Definition GDTFManager.cpp:11212

SceneData::GdtfCRIGroup
Definition GDTFManager.h:2614

SceneData::GdtfCRIGroup::Add_CRI
GdtfCRIPtr Add_CRI(EGdtfColorSample ces, Sint32 colorTemp)
Definition GDTFManager.cpp:10345

SceneData::GdtfCRIGroup::OnPrintToFile
virtual void OnPrintToFile(IXMLFileNodePtr pNode)
Definition GDTFManager.cpp:10359

SceneData::GdtfCRIGroup::GetNodeName
virtual TXString GetNodeName()
Definition GDTFManager.cpp:10354

SceneData::GdtfCRIGroup::GetColorTemperature
double GetColorTemperature() const
Definition GDTFManager.cpp:10330

SceneData::GdtfCRIGroup::GetObjectType
virtual EGdtfObjectType GetObjectType()
Definition GDTFManager.cpp:10325

SceneData::GdtfCRIGroup::OnErrorCheck
virtual void OnErrorCheck(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:10403

SceneData::GdtfCRIGroup::GetCRI_Array
TGdtf_CRIArray GetCRI_Array() const
Definition GDTFManager.cpp:10335

SceneData::GdtfCRIGroup::SetColorTemperature
void SetColorTemperature(double val)
Definition GDTFManager.cpp:10340

SceneData::GdtfCRIGroup::GdtfCRIGroup
GdtfCRIGroup()
Definition GDTFManager.cpp:10310

SceneData::GdtfCRIGroup::OnReadFromNode
virtual void OnReadFromNode(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:10377

SceneData::GdtfCRIGroup::~GdtfCRIGroup
~GdtfCRIGroup()
Definition GDTFManager.cpp:10320

SceneData::GdtfCRI
Definition GDTFManager.h:2586

SceneData::GdtfCRI::SetColorRenderingIndex
void SetColorRenderingIndex(Uint8 val)
Definition GDTFManager.cpp:10456

SceneData::GdtfCRI::GetNodeName
virtual TXString GetNodeName()
Definition GDTFManager.cpp:10461

SceneData::GdtfCRI::OnPrintToFile
virtual void OnPrintToFile(IXMLFileNodePtr pNode)
Definition GDTFManager.cpp:10466

SceneData::GdtfCRI::GdtfCRI
GdtfCRI()
Definition GDTFManager.cpp:10420

SceneData::GdtfCRI::GetObjectType
virtual EGdtfObjectType GetObjectType()
Definition GDTFManager.cpp:10436

SceneData::GdtfCRI::SetColorSample
void SetColorSample(EGdtfColorSample val)
Definition GDTFManager.cpp:10451

SceneData::GdtfCRI::OnReadFromNode
virtual void OnReadFromNode(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:10479

SceneData::GdtfCRI::~GdtfCRI
~GdtfCRI()
Definition GDTFManager.cpp:10432

SceneData::GdtfCRI::GetColorSample
EGdtfColorSample GetColorSample() const
Definition GDTFManager.cpp:10441

SceneData::GdtfCRI::GetColorRenderingIndex
Uint8 GetColorRenderingIndex() const
Definition GDTFManager.cpp:10446

SceneData::GdtfCRI::OnErrorCheck
virtual void OnErrorCheck(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:10494

SceneData::GdtfColorSpace
Definition GDTFManager.h:454

SceneData::GdtfColorSpace::SetRed
void SetRed(CCieColor val)
Definition GDTFManager.cpp:12506

SceneData::GdtfColorSpace::GetBlue
CCieColor GetBlue()
Definition GDTFManager.cpp:12478

SceneData::GdtfColorSpace::GetRed
CCieColor GetRed()
Definition GDTFManager.cpp:12460

SceneData::GdtfColorSpace::GetObjectType
virtual EGdtfObjectType GetObjectType()
Definition GDTFManager.cpp:12440

SceneData::GdtfColorSpace::SetWhite
void SetWhite(CCieColor val)
Definition GDTFManager.cpp:12521

SceneData::GdtfColorSpace::OnErrorCheck
virtual void OnErrorCheck(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:12573

SceneData::GdtfColorSpace::SetColorSpace
void SetColorSpace(EGdtfColorSpace val)
Definition GDTFManager.cpp:12501

SceneData::GdtfColorSpace::GetName
const TXString & GetName() const
Definition GDTFManager.cpp:12450

SceneData::GdtfColorSpace::GetColorSpace
EGdtfColorSpace GetColorSpace()
Definition GDTFManager.cpp:12455

SceneData::GdtfColorSpace::GetNodeName
virtual TXString GetNodeName()
Definition GDTFManager.cpp:12526

SceneData::GdtfColorSpace::GetGreen
CCieColor GetGreen()
Definition GDTFManager.cpp:12469

SceneData::GdtfColorSpace::GetWhite
CCieColor GetWhite()
Definition GDTFManager.cpp:12487

SceneData::GdtfColorSpace::SetName
void SetName(const TXString &name)
Definition GDTFManager.cpp:12496

SceneData::GdtfColorSpace::SetBlue
void SetBlue(CCieColor val)
Definition GDTFManager.cpp:12516

SceneData::GdtfColorSpace::OnReadFromNode
virtual void OnReadFromNode(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:12551

SceneData::GdtfColorSpace::GetNodeReference
virtual TXString GetNodeReference()
Definition GDTFManager.cpp:12445

SceneData::GdtfColorSpace::GdtfColorSpace
GdtfColorSpace()
Definition GDTFManager.cpp:12424

SceneData::GdtfColorSpace::OnPrintToFile
virtual void OnPrintToFile(IXMLFileNodePtr pNode)
Definition GDTFManager.cpp:12531

SceneData::GdtfColorSpace::~GdtfColorSpace
~GdtfColorSpace()
Definition GDTFManager.cpp:12436

SceneData::GdtfColorSpace::SetGreen
void SetGreen(CCieColor val)
Definition GDTFManager.cpp:12511

SceneData::GdtfConnector
Definition GDTFManager.h:2709

SceneData::GdtfConnector::SetType
void SetType(const TXString &type)
Definition GDTFManager.cpp:12871

SceneData::GdtfConnector::GetNodeReference
virtual TXString GetNodeReference()
Definition GDTFManager.cpp:12952

SceneData::GdtfConnector::SetLength
void SetLength(double length)
Definition GDTFManager.cpp:12886

SceneData::GdtfConnector::GetNodeName
virtual TXString GetNodeName()
Definition GDTFManager.cpp:12957

SceneData::GdtfConnector::GetLength
double GetLength()
Definition GDTFManager.cpp:12982

SceneData::GdtfConnector::OnReadFromNode
virtual void OnReadFromNode(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:12906

SceneData::GdtfConnector::SetDmxBreak
void SetDmxBreak(Uint32 dmxBreak)
Definition GDTFManager.cpp:12876

SceneData::GdtfConnector::GdtfConnector
GdtfConnector()
Definition GDTFManager.cpp:12846

SceneData::GdtfConnector::OnErrorCheck
virtual void OnErrorCheck(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:12925

SceneData::GdtfConnector::SetName
void SetName(const TXString &name)
Definition GDTFManager.cpp:12866

SceneData::GdtfConnector::OnPrintToFile
virtual void OnPrintToFile(IXMLFileNodePtr pNode)
Definition GDTFManager.cpp:12891

SceneData::GdtfConnector::GetObjectType
virtual EGdtfObjectType GetObjectType()
Definition GDTFManager.cpp:12947

SceneData::GdtfConnector::GetDmxBreak
Uint32 GetDmxBreak()
Definition GDTFManager.cpp:12972

SceneData::GdtfConnector::SetGender
void SetGender(Sint32 gender)
Definition GDTFManager.cpp:12881

SceneData::GdtfConnector::GetGender
Sint32 GetGender()
Definition GDTFManager.cpp:12977

SceneData::GdtfConnector::GetName
const TXString & GetName() const
Definition GDTFManager.cpp:12962

SceneData::GdtfConnector::GetType
const TXString & GetType() const
Definition GDTFManager.cpp:12967

SceneData::GdtfConnector::~GdtfConnector
~GdtfConnector()
Definition GDTFManager.cpp:12862

SceneData::GdtfDMXPersonality
Definition GDTFManager.h:2239

SceneData::GdtfDMXPersonality::GetUnresolvedDMXMode
const TXString & GetUnresolvedDMXMode() const
Definition GDTFManager.cpp:10667

SceneData::GdtfDMXPersonality::GetDMXMode
GdtfDmxModePtr GetDMXMode() const
Definition GDTFManager.cpp:10672

SceneData::GdtfDMXPersonality::GetObjectType
virtual EGdtfObjectType GetObjectType()
Definition GDTFManager.cpp:10657

SceneData::GdtfDMXPersonality::GdtfDMXPersonality
GdtfDMXPersonality()
Definition GDTFManager.cpp:10639

SceneData::GdtfDMXPersonality::OnReadFromNode
virtual void OnReadFromNode(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:10704

SceneData::GdtfDMXPersonality::OnPrintToFile
virtual void OnPrintToFile(IXMLFileNodePtr pNode)
Definition GDTFManager.cpp:10692

SceneData::GdtfDMXPersonality::SetValue
void SetValue(size_t val)
Definition GDTFManager.cpp:10677

SceneData::GdtfDMXPersonality::GetNodeName
virtual TXString GetNodeName()
Definition GDTFManager.cpp:10687

SceneData::GdtfDMXPersonality::~GdtfDMXPersonality
~GdtfDMXPersonality()
Definition GDTFManager.cpp:10653

SceneData::GdtfDMXPersonality::SetDMXMode
void SetDMXMode(GdtfDmxModePtr mode)
Definition GDTFManager.cpp:10682

SceneData::GdtfDMXPersonality::GetValue
size_t GetValue() const
Definition GDTFManager.cpp:10662

SceneData::GdtfDMXProfile
Definition GDTFManager.h:2681

SceneData::GdtfDMXProfile::GetNodeName
virtual TXString GetNodeName()
Definition GDTFManager.cpp:10245

SceneData::GdtfDMXProfile::GetName
const TXString & GetName() const
Definition GDTFManager.cpp:10223

SceneData::GdtfDMXProfile::~GdtfDMXProfile
~GdtfDMXProfile()
Definition GDTFManager.cpp:10208

SceneData::GdtfDMXProfile::OnPrintToFile
virtual void OnPrintToFile(IXMLFileNodePtr pNode)
Definition GDTFManager.cpp:10250

SceneData::GdtfDMXProfile::OnReadFromNode
virtual void OnReadFromNode(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:10268

SceneData::GdtfDMXProfile::AddPoint
GdtfPointPtr AddPoint(double DMXPercentage, double CFC3, double CFC2, double CFC1, double CFC0)
Definition GDTFManager.cpp:10238

SceneData::GdtfDMXProfile::GetNodeReference
virtual TXString GetNodeReference()
Definition GDTFManager.cpp:10218

SceneData::GdtfDMXProfile::GetPointArray
TGdtfPointArray GetPointArray() const
Definition GDTFManager.cpp:10228

SceneData::GdtfDMXProfile::OnErrorCheck
virtual void OnErrorCheck(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:10293

SceneData::GdtfDMXProfile::GdtfDMXProfile
GdtfDMXProfile()
Definition GDTFManager.cpp:10203

SceneData::GdtfDMXProfile::SetName
void SetName(const TXString &name)
Definition GDTFManager.cpp:10233

SceneData::GdtfDMXProfile::GetObjectType
virtual EGdtfObjectType GetObjectType()
Definition GDTFManager.cpp:10213

SceneData::GdtfDmxChannelFunction
Definition GDTFManager.h:1549

SceneData::GdtfDmxChannelFunction::SetWheel
void SetWheel(GdtfWheelPtr newWhl)
Definition GDTFManager.cpp:6437

SceneData::GdtfDmxChannelFunction::GetModeMasterDmxEnd
DmxValue GetModeMasterDmxEnd() const
Definition GDTFManager.cpp:6467

SceneData::GdtfDmxChannelFunction::ResolveModeMasterDmx
void ResolveModeMasterDmx(EGdtfChannelBitResolution resolution)
Definition GDTFManager.cpp:6472

SceneData::GdtfDmxChannelFunction::GetSubChannelSets
const TGdtfDmxSubChannelSetArray & GetSubChannelSets() const
Definition GDTFManager.cpp:6447

SceneData::GdtfDmxChannelFunction::SetMin
void SetMin(double min)
Definition GDTFManager.cpp:6530

SceneData::GdtfDmxChannelFunction::SetName
void SetName(const TXString &name)
Definition GDTFManager.cpp:5922

SceneData::GdtfDmxChannelFunction::GetColorSpace
GdtfColorSpacePtr GetColorSpace() const
Definition GDTFManager.cpp:6407

SceneData::GdtfDmxChannelFunction::GetPhysicalStart
double GetPhysicalStart() const
Definition GDTFManager.cpp:6372

SceneData::GdtfDmxChannelFunction::SetDMXProfile
void SetDMXProfile(GdtfDMXProfilePtr dmxProfile)
Definition GDTFManager.cpp:6525

SceneData::GdtfDmxChannelFunction::GetOriginalAttribute
const TXString & GetOriginalAttribute()
Definition GDTFManager.cpp:6343

SceneData::GdtfDmxChannelFunction::GetOnWheel
GdtfWheelPtr GetOnWheel() const
Definition GDTFManager.cpp:6392

SceneData::GdtfDmxChannelFunction::GdtfDmxChannelFunction
GdtfDmxChannelFunction(GdtfDmxLogicalChannel *parent)
Definition GDTFManager.cpp:5843

SceneData::GdtfDmxChannelFunction::GetNodeReference
virtual TXString GetNodeReference()
Definition GDTFManager.cpp:6301

SceneData::GdtfDmxChannelFunction::OnPrintToFile
virtual void OnPrintToFile(IXMLFileNodePtr pNode)
Definition GDTFManager.cpp:5981

SceneData::GdtfDmxChannelFunction::SetFilter
void SetFilter(GdtfFilterPtr val)
Definition GDTFManager.cpp:6510

SceneData::GdtfDmxChannelFunction::SetMax
void SetMax(double max)
Definition GDTFManager.cpp:6535

SceneData::GdtfDmxChannelFunction::GetEmitter
GdtfPhysicalEmitter * GetEmitter() const
Definition GDTFManager.cpp:6397

SceneData::GdtfDmxChannelFunction::SetPhysicalEnd
void SetPhysicalEnd(double end)
Definition GDTFManager.cpp:5952

SceneData::GdtfDmxChannelFunction::GetGamut
GdtfGamutPtr GetGamut() const
Definition GDTFManager.cpp:6412

SceneData::GdtfDmxChannelFunction::SetModeMaster_Channel
void SetModeMaster_Channel(GdtfDmxChannel *channel)
Definition GDTFManager.cpp:6481

SceneData::GdtfDmxChannelFunction::SetPhysicalStart
void SetPhysicalStart(double start)
Definition GDTFManager.cpp:5947

SceneData::GdtfDmxChannelFunction::GetChannelSets
const TGdtfDmxChannelSetArray & GetChannelSets() const
Definition GDTFManager.cpp:6442

SceneData::GdtfDmxChannelFunction::OnReadFromNode
virtual void OnReadFromNode(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:6108

SceneData::GdtfDmxChannelFunction::getUnresolvedColorSpaceRef
const TXString & getUnresolvedColorSpaceRef() const
Definition GDTFManager.cpp:6570

SceneData::GdtfDmxChannelFunction::GetRealFade
double GetRealFade() const
Definition GDTFManager.cpp:6382

SceneData::GdtfDmxChannelFunction::SetRealAcceleration
void SetRealAcceleration(double fade)
Definition GDTFManager.cpp:5962

SceneData::GdtfDmxChannelFunction::GetDMXProfile
GdtfDMXProfilePtr GetDMXProfile() const
Definition GDTFManager.cpp:6417

SceneData::GdtfDmxChannelFunction::GetModeMaster_Function
GdtfDmxChannelFunction * GetModeMaster_Function() const
Definition GDTFManager.cpp:6457

SceneData::GdtfDmxChannelFunction::GetRealAcceleration
double GetRealAcceleration() const
Definition GDTFManager.cpp:6387

SceneData::GdtfDmxChannelFunction::GetCustomName
const TXString & GetCustomName() const
Definition GDTFManager.cpp:6432

SceneData::GdtfDmxChannelFunction::GetObjectType
virtual EGdtfObjectType GetObjectType()
Definition GDTFManager.cpp:6291

SceneData::GdtfDmxChannelFunction::AddChannelSet
GdtfDmxChannelSet * AddChannelSet(const TXString &name)
Definition GDTFManager.cpp:5967

SceneData::GdtfDmxChannelFunction::GetAttribute
GdtfAttribute * GetAttribute()
Definition GDTFManager.cpp:6338

SceneData::GdtfDmxChannelFunction::SetStartAddress
void SetStartAddress(DmxValue address)
Definition GDTFManager.cpp:5942

SceneData::GdtfDmxChannelFunction::getUnresolvedFilterRef
const TXString & getUnresolvedFilterRef()
Definition GDTFManager.cpp:6565

SceneData::GdtfDmxChannelFunction::SetEmitter
void SetEmitter(GdtfPhysicalEmitter *newEmit)
Definition GDTFManager.cpp:6505

SceneData::GdtfDmxChannelFunction::GetEndAdress
DmxValue GetEndAdress() const
Definition GDTFManager.cpp:6358

SceneData::GdtfDmxChannelFunction::SetColorSpace
void SetColorSpace(GdtfColorSpacePtr colorSpace)
Definition GDTFManager.cpp:6515

SceneData::GdtfDmxChannelFunction::SetOriginalAttribute
void SetOriginalAttribute(const TXString &attribute)
Definition GDTFManager.cpp:5932

SceneData::GdtfDmxChannelFunction::SetCustomName
void SetCustomName(const TXString &customName)
Definition GDTFManager.cpp:6540

SceneData::GdtfDmxChannelFunction::GetMax
double GetMax() const
Definition GDTFManager.cpp:6427

SceneData::GdtfDmxChannelFunction::getUnresolvedEmitterRef
TXString getUnresolvedEmitterRef() const
Definition GDTFManager.cpp:6555

SceneData::GdtfDmxChannelFunction::OnErrorCheck
virtual void OnErrorCheck(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:6255

SceneData::GdtfDmxChannelFunction::getUnresolvedAttrRef
TXString getUnresolvedAttrRef() const
Definition GDTFManager.cpp:6545

SceneData::GdtfDmxChannelFunction::GetName
const TXString & GetName() const
Definition GDTFManager.cpp:6333

SceneData::GdtfDmxChannelFunction::SetModeMaster_Function
void SetModeMaster_Function(GdtfDmxChannelFunction *function)
Definition GDTFManager.cpp:6488

SceneData::GdtfDmxChannelFunction::GetDefaultValue
DmxValue GetDefaultValue() const
Definition GDTFManager.cpp:6348

SceneData::GdtfDmxChannelFunction::SetModeMasterDmxEnd
void SetModeMasterDmxEnd(DmxValue end)
Definition GDTFManager.cpp:6500

SceneData::GdtfDmxChannelFunction::GetStartAdress
DmxValue GetStartAdress() const
Definition GDTFManager.cpp:6353

SceneData::GdtfDmxChannelFunction::SetAttribute
void SetAttribute(GdtfAttribute *newAttr)
Definition GDTFManager.cpp:5927

SceneData::GdtfDmxChannelFunction::getUnresolvedGamutRef
const TXString & getUnresolvedGamutRef() const
Definition GDTFManager.cpp:6575

SceneData::GdtfDmxChannelFunction::SetRealFade
void SetRealFade(double fade)
Definition GDTFManager.cpp:5957

SceneData::GdtfDmxChannelFunction::GetModeMasterDmxStart
DmxValue GetModeMasterDmxStart() const
Definition GDTFManager.cpp:6462

SceneData::GdtfDmxChannelFunction::AddSubChannelSet
GdtfDmxSubChannelSet * AddSubChannelSet(GdtfSubPhysicalUnit *subPhysicalUnit, const TXString &name)
Definition GDTFManager.cpp:5974

SceneData::GdtfDmxChannelFunction::SetGamut
void SetGamut(GdtfGamutPtr gamut)
Definition GDTFManager.cpp:6520

SceneData::GdtfDmxChannelFunction::GetMin
double GetMin() const
Definition GDTFManager.cpp:6422

SceneData::GdtfDmxChannelFunction::GetNumberInParent
size_t GetNumberInParent() const
Definition GDTFManager.cpp:6318

SceneData::GdtfDmxChannelFunction::GetNodeName
virtual TXString GetNodeName()
Definition GDTFManager.cpp:6296

SceneData::GdtfDmxChannelFunction::SetModeMasterDmxStart
void SetModeMasterDmxStart(DmxValue start)
Definition GDTFManager.cpp:6495

SceneData::GdtfDmxChannelFunction::GetFilter
GdtfFilterPtr GetFilter() const
Definition GDTFManager.cpp:6402

SceneData::GdtfDmxChannelFunction::GetParentLogicalChannel
GdtfDmxLogicalChannel * GetParentLogicalChannel() const
Definition GDTFManager.cpp:6590

SceneData::GdtfDmxChannelFunction::GetModeMaster_Channel
GdtfDmxChannel * GetModeMaster_Channel() const
Definition GDTFManager.cpp:6452

SceneData::GdtfDmxChannelFunction::getUnresolvedDMXProfileRef
const TXString & getUnresolvedDMXProfileRef() const
Definition GDTFManager.cpp:6580

SceneData::GdtfDmxChannelFunction::getUnresolvedWheelRef
TXString getUnresolvedWheelRef() const
Definition GDTFManager.cpp:6550

SceneData::GdtfDmxChannelFunction::GetPhysicalEnd
double GetPhysicalEnd() const
Definition GDTFManager.cpp:6377

SceneData::GdtfDmxChannelFunction::SetDefaultValue
void SetDefaultValue(DmxValue defaultValue)
Definition GDTFManager.cpp:5937

SceneData::GdtfDmxChannelFunction::~GdtfDmxChannelFunction
~GdtfDmxChannelFunction()
Definition GDTFManager.cpp:5910

SceneData::GdtfDmxChannelFunction::GetParentDMXChannel
GdtfDmxChannel * GetParentDMXChannel() const
Definition GDTFManager.cpp:6585

SceneData::GdtfDmxChannelFunction::SetNextFunction
void SetNextFunction(GdtfDmxChannelFunction *next)
Definition GDTFManager.cpp:5916

SceneData::GdtfDmxChannelFunction::getUnresolvedModeMasterRef
TXString getUnresolvedModeMasterRef() const
Definition GDTFManager.cpp:6560

SceneData::GdtfDmxChannelFunction::GetNextFunction
GdtfDmxChannelFunction * GetNextFunction() const
Definition GDTFManager.cpp:6595

SceneData::GdtfDmxChannel
Definition GDTFManager.h:1744

SceneData::GdtfDmxChannel::GetOldDefaultValue
DmxValue GetOldDefaultValue() const
Definition GDTFManager.cpp:5550

SceneData::GdtfDmxChannel::GetDmxBreak
Sint32 GetDmxBreak() const
Definition GDTFManager.cpp:5515

SceneData::GdtfDmxChannel::GetUnresolvedInitialFunction
TXString GetUnresolvedInitialFunction() const
Definition GDTFManager.cpp:5580

SceneData::GdtfDmxChannel::GetLogicalChannelArray
const TGdtfDmxLogicalChannelArray GetLogicalChannelArray()
Definition GDTFManager.cpp:5585

SceneData::GdtfDmxChannel::SetModel
void SetModel(GdtfModelPtr ptr)

SceneData::GdtfDmxChannel::GetNodeName
virtual TXString GetNodeName()
Definition GDTFManager.cpp:5492

SceneData::GdtfDmxChannel::SetDmxFine
void SetDmxFine(Sint32 fine)
Definition GDTFManager.cpp:5330

SceneData::GdtfDmxChannel::GetCoarse
Sint32 GetCoarse() const
Definition GDTFManager.cpp:5520

SceneData::GdtfDmxChannel::HasHighlight
bool HasHighlight() const
Definition GDTFManager.cpp:5545

SceneData::GdtfDmxChannel::AddLogicalChannel
GdtfDmxLogicalChannel * AddLogicalChannel()
Definition GDTFManager.cpp:5357

SceneData::GdtfDmxChannel::GetChannelMaxDmx
DmxValue GetChannelMaxDmx()
Definition GDTFManager.cpp:5600

SceneData::GdtfDmxChannel::OnErrorCheck
virtual void OnErrorCheck(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:5455

SceneData::GdtfDmxChannel::GetInitialFunction
GdtfDmxChannelFunctionPtr GetInitialFunction()
Definition GDTFManager.cpp:5575

SceneData::GdtfDmxChannel::OnReadFromNode
virtual void OnReadFromNode(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:5389

SceneData::GdtfDmxChannel::SetDmxUber
void SetDmxUber(Sint32 uber)
Definition GDTFManager.cpp:5343

SceneData::GdtfDmxChannel::SetGeomRef
void SetGeomRef(GdtfGeometryPtr newGeom)
Definition GDTFManager.cpp:5555

SceneData::GdtfDmxChannel::GetUber
Sint32 GetUber() const
Definition GDTFManager.cpp:5535

SceneData::GdtfDmxChannel::GdtfDmxChannel
GdtfDmxChannel(GdtfDmxMode *parent)
Definition GDTFManager.cpp:5292

SceneData::GdtfDmxChannel::GetUltra
Sint32 GetUltra() const
Definition GDTFManager.cpp:5530

SceneData::GdtfDmxChannel::GetName
const TXString & GetName()
Definition GDTFManager.cpp:5497

SceneData::GdtfDmxChannel::GetUnresolvedGeomRef
TXString GetUnresolvedGeomRef() const
Definition GDTFManager.cpp:5565

SceneData::GdtfDmxChannel::SetDmxUltra
void SetDmxUltra(Sint32 ultra)
Definition GDTFManager.cpp:5336

SceneData::GdtfDmxChannel::SetDmxBreak
void SetDmxBreak(Sint32 dmxBreak)
Definition GDTFManager.cpp:5319

SceneData::GdtfDmxChannel::GetParentMode
GdtfDmxMode * GetParentMode()
Definition GDTFManager.cpp:5487

SceneData::GdtfDmxChannel::SetName
void SetName(const TXString &name)
Definition GDTFManager.cpp:5314

SceneData::GdtfDmxChannel::GetChannelBitResolution
EGdtfChannelBitResolution GetChannelBitResolution()
Definition GDTFManager.cpp:5590

SceneData::GdtfDmxChannel::OnPrintToFile
virtual void OnPrintToFile(IXMLFileNodePtr pNode)
Definition GDTFManager.cpp:5366

SceneData::GdtfDmxChannel::~GdtfDmxChannel
~GdtfDmxChannel()
Definition GDTFManager.cpp:5309

SceneData::GdtfDmxChannel::IsVirtual
bool IsVirtual() const
Definition GDTFManager.cpp:5605

SceneData::GdtfDmxChannel::GetHighlight
DmxValue GetHighlight() const
Definition GDTFManager.cpp:5540

SceneData::GdtfDmxChannel::GetFine
Sint32 GetFine() const
Definition GDTFManager.cpp:5525

SceneData::GdtfDmxChannel::SetDmxCoarse
void SetDmxCoarse(Sint32 coarse)
Definition GDTFManager.cpp:5324

SceneData::GdtfDmxChannel::GetNodeReference
virtual TXString GetNodeReference()
Definition GDTFManager.cpp:5482

SceneData::GdtfDmxChannel::GetGeomRef
GdtfGeometryPtr GetGeomRef()
Definition GDTFManager.cpp:5560

SceneData::GdtfDmxChannel::SetInitialFunction
void SetInitialFunction(GdtfDmxChannelFunctionPtr initialFunction)
Definition GDTFManager.cpp:5570

SceneData::GdtfDmxChannel::GetObjectType
virtual EGdtfObjectType GetObjectType()
Definition GDTFManager.cpp:5477

SceneData::GdtfDmxChannel::SetHighlight
void SetHighlight(DmxValue highlight)
Definition GDTFManager.cpp:5351

SceneData::GdtfDmxChannelSet
Definition GDTFManager.h:1447

SceneData::GdtfDmxChannelSet::OnPrintToFile
virtual void OnPrintToFile(IXMLFileNodePtr pNode)
Definition GDTFManager.cpp:6684

SceneData::GdtfDmxChannelSet::SetNextChannelSet
bool SetNextChannelSet(GdtfDmxChannelSet *next, IXMLFileNodePtr objNode)
Definition GDTFManager.cpp:6633

SceneData::GdtfDmxChannelSet::SetPhysicalStart
void SetPhysicalStart(double start)
Definition GDTFManager.cpp:6662

SceneData::GdtfDmxChannelSet::SetPhysicalEnd
void SetPhysicalEnd(double end)
Definition GDTFManager.cpp:6668

SceneData::GdtfDmxChannelSet::OnErrorCheck
virtual void OnErrorCheck(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:6731

SceneData::GdtfDmxChannelSet::GetName
const TXString & GetName() const
Definition GDTFManager.cpp:6772

SceneData::GdtfDmxChannelSet::SetDmxEnd
void SetDmxEnd(DmxValue end)
Definition GDTFManager.cpp:6657

SceneData::GdtfDmxChannelSet::SetName
void SetName(const TXString &name)
Definition GDTFManager.cpp:6647

SceneData::GdtfDmxChannelSet::GetDmxStart
DmxValue GetDmxStart() const
Definition GDTFManager.cpp:6782

SceneData::GdtfDmxChannelSet::~GdtfDmxChannelSet
~GdtfDmxChannelSet()
Definition GDTFManager.cpp:6629

SceneData::GdtfDmxChannelSet::OnReadFromNode
virtual void OnReadFromNode(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:6705

SceneData::GdtfDmxChannelSet::IsValid
bool IsValid()
Definition GDTFManager.cpp:6679

SceneData::GdtfDmxChannelSet::GetParentDMXChannel
GdtfDmxChannel * GetParentDMXChannel() const
Definition GDTFManager.cpp:6808

SceneData::GdtfDmxChannelSet::GetWheelSlot
Sint32 GetWheelSlot()
Definition GDTFManager.cpp:6803

SceneData::GdtfDmxChannelSet::GetObjectType
virtual EGdtfObjectType GetObjectType()
Definition GDTFManager.cpp:6762

SceneData::GdtfDmxChannelSet::GdtfDmxChannelSet
GdtfDmxChannelSet(GdtfDmxChannelFunction *parent)
Definition GDTFManager.cpp:6602

SceneData::GdtfDmxChannelSet::GetDmxEnd
DmxValue GetDmxEnd() const
Definition GDTFManager.cpp:6787

SceneData::GdtfDmxChannelSet::GetUsePhysicalFromParent
bool GetUsePhysicalFromParent() const
Definition GDTFManager.cpp:6777

SceneData::GdtfDmxChannelSet::SetWheelSlot
void SetWheelSlot(Sint32 slotIndex)
Definition GDTFManager.cpp:6674

SceneData::GdtfDmxChannelSet::GetNodeName
virtual TXString GetNodeName()
Definition GDTFManager.cpp:6767

SceneData::GdtfDmxChannelSet::GetPhysicalStart
double GetPhysicalStart() const
Definition GDTFManager.cpp:6793

SceneData::GdtfDmxChannelSet::SetDmxStart
void SetDmxStart(DmxValue start)
Definition GDTFManager.cpp:6652

SceneData::GdtfDmxChannelSet::GetPhysicalEnd
double GetPhysicalEnd() const
Definition GDTFManager.cpp:6798

SceneData::GdtfDmxLogicalChannel
Definition GDTFManager.h:1691

SceneData::GdtfDmxLogicalChannel::SetMoveInBlackFrames
void SetMoveInBlackFrames(double moveInBlackFrames)
Definition GDTFManager.cpp:5655

SceneData::GdtfDmxLogicalChannel::OnReadFromNode
virtual void OnReadFromNode(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:5714

SceneData::GdtfDmxLogicalChannel::SetNextLogicalChannel
void SetNextLogicalChannel(GdtfDmxLogicalChannel *next)
Definition GDTFManager.cpp:5649

SceneData::GdtfDmxLogicalChannel::GetDmxMaster
EGdtfDmxMaster GetDmxMaster() const
Definition GDTFManager.cpp:5821

SceneData::GdtfDmxLogicalChannel::GdtfDmxLogicalChannel
GdtfDmxLogicalChannel(GdtfDmxChannel *parent)
Definition GDTFManager.cpp:5613

SceneData::GdtfDmxLogicalChannel::GetNodeName
virtual TXString GetNodeName()
Definition GDTFManager.cpp:5793

SceneData::GdtfDmxLogicalChannel::SetAttribute
void SetAttribute(GdtfAttributePtr newAttr)
Definition GDTFManager.cpp:5634

SceneData::GdtfDmxLogicalChannel::OnErrorCheck
virtual void OnErrorCheck(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:5763

SceneData::GdtfDmxLogicalChannel::OnPrintToFile
virtual void OnPrintToFile(IXMLFileNodePtr pNode)
Definition GDTFManager.cpp:5692

SceneData::GdtfDmxLogicalChannel::~GdtfDmxLogicalChannel
~GdtfDmxLogicalChannel()
Definition GDTFManager.cpp:5624

SceneData::GdtfDmxLogicalChannel::GetDmxChannelFunctions
const TGdtfDmxChannelFuntionArray GetDmxChannelFunctions()
Definition GDTFManager.cpp:5826

SceneData::GdtfDmxLogicalChannel::GetName
const TXString & GetName()
Definition GDTFManager.cpp:5798

SceneData::GdtfDmxLogicalChannel::GetMoveInBlackFrames
double GetMoveInBlackFrames() const
Definition GDTFManager.cpp:5670

SceneData::GdtfDmxLogicalChannel::GetNextLogicalChannel
GdtfDmxLogicalChannel * GetNextLogicalChannel()
Definition GDTFManager.cpp:5665

SceneData::GdtfDmxLogicalChannel::GetObjectType
virtual EGdtfObjectType GetObjectType()
Definition GDTFManager.cpp:5783

SceneData::GdtfDmxLogicalChannel::GetDmxSnap
EGdtfDmxSnap GetDmxSnap() const
Definition GDTFManager.cpp:5816

SceneData::GdtfDmxLogicalChannel::SetDmxSnap
void SetDmxSnap(EGdtfDmxSnap snap)
Definition GDTFManager.cpp:5639

SceneData::GdtfDmxLogicalChannel::GetUnresolvedAttribRef
TXString GetUnresolvedAttribRef() const
Definition GDTFManager.cpp:5831

SceneData::GdtfDmxLogicalChannel::SetDmxChangeTimeLimit
void SetDmxChangeTimeLimit(double changeLimit)
Definition GDTFManager.cpp:5660

SceneData::GdtfDmxLogicalChannel::SetName
void SetName(const TXString &name)
Definition GDTFManager.cpp:5629

SceneData::GdtfDmxLogicalChannel::SetDmxMaster
void SetDmxMaster(EGdtfDmxMaster master)
Definition GDTFManager.cpp:5644

SceneData::GdtfDmxLogicalChannel::GetParentDMXChannel
GdtfDmxChannel * GetParentDMXChannel() const
Definition GDTFManager.cpp:5836

SceneData::GdtfDmxLogicalChannel::AddDmxChannelFunction
GdtfDmxChannelFunctionPtr AddDmxChannelFunction(const TXString &name)
Definition GDTFManager.cpp:5680

SceneData::GdtfDmxLogicalChannel::GetNodeReference
virtual TXString GetNodeReference()
Definition GDTFManager.cpp:5788

SceneData::GdtfDmxLogicalChannel::GetAttribute
GdtfAttribute * GetAttribute()
Definition GDTFManager.cpp:5811

SceneData::GdtfDmxLogicalChannel::GetDmxChangeTimeLimit
double GetDmxChangeTimeLimit() const
Definition GDTFManager.cpp:5675

SceneData::GdtfDmxMode
Definition GDTFManager.h:2069

SceneData::GdtfDmxMode::GdtfDmxMode
GdtfDmxMode(GdtfFixture *fixture, const TXString &name)
Definition GDTFManager.cpp:4777

SceneData::GdtfDmxMode::~GdtfDmxMode
~GdtfDmxMode()
Definition GDTFManager.cpp:4784

SceneData::GdtfDmxMode::GetGeomRef
GdtfGeometryPtr GetGeomRef()
Definition GDTFManager.cpp:5007

SceneData::GdtfDmxMode::OnReadFromNode
virtual void OnReadFromNode(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:4841

SceneData::GdtfDmxMode::GetMasterByRef
GdtfDmxChannelPtr GetMasterByRef(const TXString &ref) const
Definition GDTFManager.cpp:4933

SceneData::GdtfDmxMode::SetDescription
void SetDescription(const TXString &description)
Definition GDTFManager.cpp:4983

SceneData::GdtfDmxMode::GetDescription
const TXString & GetDescription() const
Definition GDTFManager.cpp:4978

SceneData::GdtfDmxMode::SetName
void SetName(const TXString &name)
Definition GDTFManager.cpp:4973

SceneData::GdtfDmxMode::SetGeomRef
void SetGeomRef(GdtfGeometryPtr ptr)
Definition GDTFManager.cpp:4988

SceneData::GdtfDmxMode::AddDmxRelation
GdtfDmxRelation * AddDmxRelation(GdtfDmxChannel *master, GdtfDmxChannelFunctionPtr slave, const TXString &name)
Definition GDTFManager.cpp:4993

SceneData::GdtfDmxMode::GetDmxRelations
const TGdtfDmxRelationArray GetDmxRelations()
Definition GDTFManager.cpp:5031

SceneData::GdtfDmxMode::SetModel
void SetModel(GdtfGeometryPtr ptr)

SceneData::GdtfDmxMode::GetSlaveByRef
GdtfDmxChannelFunctionPtr GetSlaveByRef(const TXString &ref) const
Definition GDTFManager.cpp:4948

SceneData::GdtfDmxMode::GetAddressesFromChannel
void GetAddressesFromChannel(TDMXAddressArray &addresses, GdtfDmxChannel *channel, DMXAddress offset) const
Definition GDTFManager.cpp:5275

SceneData::GdtfDmxMode::GetBreakArray
TSint32Array GetBreakArray() const
Definition GDTFManager.cpp:5036

SceneData::GdtfDmxMode::GetDmxMacrosArray
const TGdtfMacroArray GetDmxMacrosArray()
Definition GDTFManager.cpp:5285

SceneData::GdtfDmxMode::GetUnresolvedGeomRef
const TXString & GetUnresolvedGeomRef()
Definition GDTFManager.cpp:5026

SceneData::GdtfDmxMode::GetChannelArray
const TGdtfDmxChannelArray GetChannelArray() const
Definition GDTFManager.cpp:4928

SceneData::GdtfDmxMode::GetFootPrintForBreak
size_t GetFootPrintForBreak(size_t breakId)
Definition GDTFManager.cpp:5118

SceneData::GdtfDmxMode::AddMacro
GdtfMacroPtr AddMacro(const TXString &name)
Definition GDTFManager.cpp:5000

SceneData::GdtfDmxMode::GetChannelsForGeometry
TGdtfDmxChannelArray GetChannelsForGeometry(GdtfGeometryPtr geometry)
Definition GDTFManager.cpp:5012

SceneData::GdtfDmxMode::OnErrorCheck
virtual void OnErrorCheck(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:4891

SceneData::GdtfDmxMode::GetModeName
const TXString & GetModeName() const
Definition GDTFManager.cpp:4968

SceneData::GdtfDmxMode::GetNodeName
virtual TXString GetNodeName()
Definition GDTFManager.cpp:4915

SceneData::GdtfDmxMode::OnPrintToFile
virtual void OnPrintToFile(IXMLFileNodePtr pNode)
Definition GDTFManager.cpp:4793

SceneData::GdtfDmxMode::AddChannel
GdtfDmxChannelPtr AddChannel()
Definition GDTFManager.cpp:4920

SceneData::GdtfDmxMode::GetObjectType
virtual EGdtfObjectType GetObjectType()
Definition GDTFManager.cpp:4910

SceneData::GdtfDmxRelation
Definition GDTFManager.h:1816

SceneData::GdtfDmxRelation::OnReadFromNode
virtual void OnReadFromNode(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:7012

SceneData::GdtfDmxRelation::GetNodeName
virtual TXString GetNodeName()
Definition GDTFManager.cpp:7051

SceneData::GdtfDmxRelation::OnErrorCheck
virtual void OnErrorCheck(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:7026

SceneData::GdtfDmxRelation::GetMasterChannel
GdtfDmxChannelPtr GetMasterChannel() const
Definition GDTFManager.cpp:7061

SceneData::GdtfDmxRelation::GetDmxEnd
DmxValue GetDmxEnd() const

SceneData::GdtfDmxRelation::GetUnresolvedSlaveRef
TXString GetUnresolvedSlaveRef() const
Definition GDTFManager.cpp:7086

SceneData::GdtfDmxRelation::OnPrintToFile
virtual void OnPrintToFile(IXMLFileNodePtr pNode)
Definition GDTFManager.cpp:6996

SceneData::GdtfDmxRelation::GetSlaveChannel
GdtfDmxChannelFunctionPtr GetSlaveChannel() const
Definition GDTFManager.cpp:7071

SceneData::GdtfDmxRelation::GetObjectType
virtual EGdtfObjectType GetObjectType()
Definition GDTFManager.cpp:7046

SceneData::GdtfDmxRelation::SetName
void SetName(const TXString &name)
Definition GDTFManager.cpp:6986

SceneData::GdtfDmxRelation::SetDmxStart
void SetDmxStart(DmxValue start)

SceneData::GdtfDmxRelation::~GdtfDmxRelation
~GdtfDmxRelation()
Definition GDTFManager.cpp:6982

SceneData::GdtfDmxRelation::GetName
const TXString & GetName() const
Definition GDTFManager.cpp:7056

SceneData::GdtfDmxRelation::GetRelationType
EGdtfDmxRelationType GetRelationType() const
Definition GDTFManager.cpp:7091

SceneData::GdtfDmxRelation::SetDmxEnd
void SetDmxEnd(DmxValue end)

SceneData::GdtfDmxRelation::GetDmxStart
DmxValue GetDmxStart() const

SceneData::GdtfDmxRelation::GdtfDmxRelation
GdtfDmxRelation()
Definition GDTFManager.cpp:6966

SceneData::GdtfDmxRelation::SetMasterChannel
void SetMasterChannel(GdtfDmxChannelPtr newMaster)
Definition GDTFManager.cpp:7066

SceneData::GdtfDmxRelation::SetRelationType
void SetRelationType(EGdtfDmxRelationType type)
Definition GDTFManager.cpp:6991

SceneData::GdtfDmxRelation::SetSlaveChannel
void SetSlaveChannel(GdtfDmxChannelFunctionPtr newSlave)
Definition GDTFManager.cpp:7076

SceneData::GdtfDmxRelation::GetUnresolvedMasterRef
TXString GetUnresolvedMasterRef() const
Definition GDTFManager.cpp:7081

SceneData::GdtfDmxSubChannelSet
Definition GDTFManager.h:1502

SceneData::GdtfDmxSubChannelSet::SetName
void SetName(const TXString &name)
Definition GDTFManager.cpp:6842

SceneData::GdtfDmxSubChannelSet::OnReadFromNode
virtual void OnReadFromNode(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:6883

SceneData::GdtfDmxSubChannelSet::GetObjectType
virtual EGdtfObjectType GetObjectType()
Definition GDTFManager.cpp:6919

SceneData::GdtfDmxSubChannelSet::GetSubPhysicalUnit
GdtfSubPhysicalUnitPtr GetSubPhysicalUnit() const
Definition GDTFManager.cpp:6944

SceneData::GdtfDmxSubChannelSet::SetSubPhysicalUnit
void SetSubPhysicalUnit(GdtfSubPhysicalUnitPtr subPhysicalUnit)
Definition GDTFManager.cpp:6857

SceneData::GdtfDmxSubChannelSet::~GdtfDmxSubChannelSet
~GdtfDmxSubChannelSet()
Definition GDTFManager.cpp:6838

SceneData::GdtfDmxSubChannelSet::SetPhysicalTo
void SetPhysicalTo(double to)
Definition GDTFManager.cpp:6852

SceneData::GdtfDmxSubChannelSet::GetUnresolvedSubPhysicalUnitRef
const TXString & GetUnresolvedSubPhysicalUnitRef() const
Definition GDTFManager.cpp:6954

SceneData::GdtfDmxSubChannelSet::SetPhysicalFrom
void SetPhysicalFrom(double from)
Definition GDTFManager.cpp:6847

SceneData::GdtfDmxSubChannelSet::GetUnresolvedDMXProfileRef
const TXString & GetUnresolvedDMXProfileRef() const
Definition GDTFManager.cpp:6959

SceneData::GdtfDmxSubChannelSet::GetNodeName
virtual TXString GetNodeName()
Definition GDTFManager.cpp:6924

SceneData::GdtfDmxSubChannelSet::GetName
const TXString & GetName() const
Definition GDTFManager.cpp:6929

SceneData::GdtfDmxSubChannelSet::GetPhysicalFrom
double GetPhysicalFrom() const
Definition GDTFManager.cpp:6934

SceneData::GdtfDmxSubChannelSet::OnErrorCheck
virtual void OnErrorCheck(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:6898

SceneData::GdtfDmxSubChannelSet::OnPrintToFile
virtual void OnPrintToFile(IXMLFileNodePtr pNode)
Definition GDTFManager.cpp:6867

SceneData::GdtfDmxSubChannelSet::SetDMXProfile
void SetDMXProfile(GdtfDMXProfilePtr dmxProfile)
Definition GDTFManager.cpp:6862

SceneData::GdtfDmxSubChannelSet::GdtfDmxSubChannelSet
GdtfDmxSubChannelSet()
Definition GDTFManager.cpp:6815

SceneData::GdtfDmxSubChannelSet::GetDMXProfile
GdtfDMXProfilePtr GetDMXProfile() const
Definition GDTFManager.cpp:6949

SceneData::GdtfDmxSubChannelSet::GetPhysicalTo
double GetPhysicalTo() const
Definition GDTFManager.cpp:6939

SceneData::GdtfFTRDM
Definition GDTFManager.h:2207

SceneData::GdtfFTRDM::AddSoftwareVersID
GdtfSoftwareVersionIDPtr AddSoftwareVersID(size_t value)
Definition GDTFManager.cpp:10630

SceneData::GdtfFTRDM::GetSoftwareVersIDs
const TGdtfSoftwareVersionIDArray & GetSoftwareVersIDs() const
Definition GDTFManager.cpp:10614

SceneData::GdtfFTRDM::GetNodeName
virtual TXString GetNodeName()
Definition GDTFManager.cpp:10513

SceneData::GdtfFTRDM::SetManufacturerID
void SetManufacturerID(size_t val)
Definition GDTFManager.cpp:10619

SceneData::GdtfFTRDM::OnReadFromNode
virtual void OnReadFromNode(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:10535

SceneData::GdtfFTRDM::GdtfFTRDM
GdtfFTRDM()
Definition GDTFManager.cpp:10582

SceneData::GdtfFTRDM::OnPrintToFile
virtual void OnPrintToFile(IXMLFileNodePtr pNode)
Definition GDTFManager.cpp:10518

SceneData::GdtfFTRDM::OnErrorCheck
virtual void OnErrorCheck(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:10564

SceneData::GdtfFTRDM::GetDeviceModelID
size_t GetDeviceModelID() const
Definition GDTFManager.cpp:10609

SceneData::GdtfFTRDM::GetObjectType
virtual EGdtfObjectType GetObjectType()
Definition GDTFManager.cpp:10599

SceneData::GdtfFTRDM::~GdtfFTRDM
~GdtfFTRDM()
Definition GDTFManager.cpp:10594

SceneData::GdtfFTRDM::GetManufacturerID
size_t GetManufacturerID() const
Definition GDTFManager.cpp:10604

SceneData::GdtfFTRDM::SetDeviceModelID
void SetDeviceModelID(size_t val)
Definition GDTFManager.cpp:10624

SceneData::GdtfFeatureGroup
Definition GDTFManager.h:190

SceneData::GdtfFeatureGroup::OnReadFromNode
virtual void OnReadFromNode(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:356

SceneData::GdtfFeatureGroup::OnPrintToFile
virtual void OnPrintToFile(IXMLFileNodePtr pNode)
Definition GDTFManager.cpp:336

SceneData::GdtfFeatureGroup::GetFeatureArray
const TGdtfFeatureArray GetFeatureArray()
Definition GDTFManager.cpp:431

SceneData::GdtfFeatureGroup::AddFeature
GdtfFeature * AddFeature(const TXString &name)
Definition GDTFManager.cpp:412

SceneData::GdtfFeatureGroup::~GdtfFeatureGroup
~GdtfFeatureGroup()
Definition GDTFManager.cpp:321

SceneData::GdtfFeatureGroup::GetObjectType
virtual EGdtfObjectType GetObjectType()
Definition GDTFManager.cpp:403

SceneData::GdtfFeatureGroup::OnErrorCheck
virtual void OnErrorCheck(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:385

SceneData::GdtfFeatureGroup::GetNodeName
virtual TXString GetNodeName()
Definition GDTFManager.cpp:407

SceneData::GdtfFeatureGroup::SetPrettyName
void SetPrettyName(const TXString &prettyName)
Definition GDTFManager.cpp:331

SceneData::GdtfFeatureGroup::GdtfFeatureGroup
GdtfFeatureGroup()
Definition GDTFManager.cpp:310

SceneData::GdtfFeatureGroup::GetName
const TXString & GetName() const
Definition GDTFManager.cpp:421

SceneData::GdtfFeatureGroup::SetName
void SetName(const TXString &name)
Definition GDTFManager.cpp:326

SceneData::GdtfFeatureGroup::GetPrettyName
const TXString & GetPrettyName() const
Definition GDTFManager.cpp:426

SceneData::GdtfFeature
Definition GDTFManager.h:155

SceneData::GdtfFeature::SetName
void SetName(const TXString &name)
Definition GDTFManager.cpp:297

SceneData::GdtfFeature::GetFeatureGroup
GdtfFeatureGroup * GetFeatureGroup() const
Definition GDTFManager.cpp:281

SceneData::GdtfFeature::~GdtfFeature
~GdtfFeature()
Definition GDTFManager.cpp:219

SceneData::GdtfFeature::OnReadFromNode
virtual void OnReadFromNode(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:236

SceneData::GdtfFeature::GetNodeReference
virtual TXString GetNodeReference()
Definition GDTFManager.cpp:302

SceneData::GdtfFeature::OnPrintToFile
virtual void OnPrintToFile(IXMLFileNodePtr pNode)
Definition GDTFManager.cpp:223

SceneData::GdtfFeature::AddLinkedAttribute
void AddLinkedAttribute(GdtfAttribute *attr)
Definition GDTFManager.cpp:291

SceneData::GdtfFeature::GetNodeName
virtual TXString GetNodeName()
Definition GDTFManager.cpp:271

SceneData::GdtfFeature::GetObjectType
virtual EGdtfObjectType GetObjectType()
Definition GDTFManager.cpp:266

SceneData::GdtfFeature::GetLinkedAttributes
const std::vector< GdtfAttribute * > & GetLinkedAttributes() const
Definition GDTFManager.cpp:286

SceneData::GdtfFeature::GetName
const TXString & GetName() const
Definition GDTFManager.cpp:276

SceneData::GdtfFeature::GdtfFeature
GdtfFeature(GdtfFeatureGroup *parent)
Definition GDTFManager.cpp:213

SceneData::GdtfFeature::OnErrorCheck
virtual void OnErrorCheck(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:249

SceneData::GdtfFilter
Definition GDTFManager.h:585

SceneData::GdtfFilter::SetColor
void SetColor(CCieColor val)
Definition GDTFManager.cpp:12636

SceneData::GdtfFilter::GetNodeName
virtual TXString GetNodeName()
Definition GDTFManager.cpp:12649

SceneData::GdtfFilter::GdtfFilter
GdtfFilter()
Definition GDTFManager.cpp:12595

SceneData::GdtfFilter::OnReadFromNode
virtual void OnReadFromNode(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:12673

SceneData::GdtfFilter::GetObjectType
virtual EGdtfObjectType GetObjectType()
Definition GDTFManager.cpp:12611

SceneData::GdtfFilter::GetNodeReference
virtual TXString GetNodeReference()
Definition GDTFManager.cpp:12707

SceneData::GdtfFilter::OnPrintToFile
virtual void OnPrintToFile(IXMLFileNodePtr pNode)
Definition GDTFManager.cpp:12654

SceneData::GdtfFilter::GetColor
CCieColor GetColor()
Definition GDTFManager.cpp:12621

SceneData::GdtfFilter::~GdtfFilter
~GdtfFilter()
Definition GDTFManager.cpp:12606

SceneData::GdtfFilter::CreateMeasurement
GdtfMeasurement * CreateMeasurement()
Definition GDTFManager.cpp:12641

SceneData::GdtfFilter::SetName
void SetName(const TXString &name)
Definition GDTFManager.cpp:12631

SceneData::GdtfFilter::GetName
const TXString & GetName()
Definition GDTFManager.cpp:12616

SceneData::GdtfFilter::GetMeasurementsArray
const TGdtfMeasurementArray & GetMeasurementsArray()
Definition GDTFManager.cpp:12626

SceneData::GdtfFixture
Definition GDTFManager.h:2750

SceneData::GdtfFixture::GetThumbnailOffsetX
Sint32 GetThumbnailOffsetX() const
Definition GDTFManager.cpp:9931

SceneData::GdtfFixture::GetMinorVersion
Sint32 GetMinorVersion() const
Definition GDTFManager.cpp:9991

SceneData::GdtfFixture::AddError
static void AddError(const GdtfParsingError &error)
Definition GDTFManager.cpp:7883

SceneData::GdtfFixture::GetGuid
GdtfFixtureGUID GetGuid() const
Definition GDTFManager.cpp:9911

SceneData::GdtfFixture::getSubPhysicalUnitByRef
GdtfSubPhysicalUnitPtr getSubPhysicalUnitByRef(const TXString &ref)
Definition GDTFManager.cpp:8133

SceneData::GdtfFixture::SetLinkedGuid
void SetLinkedGuid(const VWFC::Tools::VWUUID &uuid)
Definition GDTFManager.cpp:10026

SceneData::GdtfFixture::AddGeometryGobo
GdtfGeometryPtr AddGeometryGobo(const TXString &name, GdtfModelPtr refToModel, const VWTransformMatrix &ma)
Definition GDTFManager.cpp:9687

SceneData::GdtfFixture::AddActivationGroup
GdtfActivationGroupPtr AddActivationGroup(const TXString &name)
Definition GDTFManager.cpp:9822

SceneData::GdtfFixture::AddFeatureGroup
GdtfFeatureGroupPtr AddFeatureGroup(const TXString &name, const TXString &prettyName)
Definition GDTFManager.cpp:9813

SceneData::GdtfFixture::GetNodeName
virtual TXString GetNodeName()
Definition GDTFManager.cpp:9507

SceneData::GdtfFixture::GetLongName
const TXString & GetLongName() const
Definition GDTFManager.cpp:9896

SceneData::GdtfFixture::SetName
void SetName(const TXString &name)
Definition GDTFManager.cpp:9996

SceneData::GdtfFixture::SetThumbnailOffsetX
void SetThumbnailOffsetX(Sint32 thumbnailOffsetX)
Definition GDTFManager.cpp:10037

SceneData::GdtfFixture::ResolveGeometryRef
GdtfGeometryPtr ResolveGeometryRef(const TXString &unresolvedGeoRef, const TGdtfGeometryArray &geometryArray)
Definition GDTFManager.cpp:8741

SceneData::GdtfFixture::AddGeometryShaper
GdtfGeometryPtr AddGeometryShaper(const TXString &name, GdtfModelPtr refToModel, const VWTransformMatrix &ma)
Definition GDTFManager.cpp:9669

SceneData::GdtfFixture::AddGeometryColor
GdtfGeometryPtr AddGeometryColor(const TXString &name, GdtfModelPtr refToModel, const VWTransformMatrix &ma)
Definition GDTFManager.cpp:9678

SceneData::GdtfFixture::AddGeometryInventory
GdtfGeometryPtr AddGeometryInventory(const TXString &name, GdtfModelPtr refToModel, const VWTransformMatrix &ma)
Definition GDTFManager.cpp:9759

SceneData::GdtfFixture::GetSVGThumnailFullPath
const TXString & GetSVGThumnailFullPath()
Definition GDTFManager.cpp:9973

SceneData::GdtfFixture::GetThumbnailOffsetY
Sint32 GetThumbnailOffsetY() const
Definition GDTFManager.cpp:9936

SceneData::GdtfFixture::AddGeometrySupport
GdtfGeometryPtr AddGeometrySupport(const TXString &name, GdtfModelPtr refToModel, const VWTransformMatrix &ma)
Definition GDTFManager.cpp:9777

SceneData::GdtfFixture::GetFileBuffers
const std::map< TXString, std::pair< char *, size_t > > & GetFileBuffers()
Definition GDTFManager.cpp:9876

SceneData::GdtfFixture::ResolveDmxChannelRefs
void ResolveDmxChannelRefs(GdtfDmxModePtr dmxMode)
Definition GDTFManager.cpp:8652

SceneData::GdtfFixture::AddGeometryWithLamp
GdtfGeometryPtr AddGeometryWithLamp(const TXString &name, GdtfModelPtr refToModel, const VWTransformMatrix &ma)
Definition GDTFManager.cpp:9642

SceneData::GdtfFixture::SetFixtureTypeDescription
void SetFixtureTypeDescription(const TXString &desc)
Definition GDTFManager.cpp:10016

SceneData::GdtfFixture::AddRevision
GdtfRevisionPtr AddRevision(const TXString &text, const STime &date)
Definition GDTFManager.cpp:9593

SceneData::GdtfFixture::getDmxChannelByRef
GdtfDmxChannelPtr getDmxChannelByRef(const TXString &ref, GdtfDmxModePtr mode)
Definition GDTFManager.cpp:8169

SceneData::GdtfFixture::AddGeometryMagnet
GdtfGeometryPtr AddGeometryMagnet(const TXString &name, GdtfModelPtr refToModel, const VWTransformMatrix &ma)
Definition GDTFManager.cpp:9786

SceneData::GdtfFixture::ResolveWheelSlots
void ResolveWheelSlots()
Definition GDTFManager.cpp:8324

SceneData::GdtfFixture::GetAttachedFileCount
size_t GetAttachedFileCount()
Definition GDTFManager.cpp:9065

SceneData::GdtfFixture::ResolveDMXPersonalityRefs
void ResolveDMXPersonalityRefs()
Definition GDTFManager.cpp:8610

SceneData::GdtfFixture::AddWheel
GdtfWheelPtr AddWheel(TXString name)
Definition GDTFManager.cpp:9613

SceneData::GdtfFixture::AddGeometry
GdtfGeometryPtr AddGeometry(const TXString &name, GdtfModelPtr refToModel, const VWTransformMatrix &ma)
Definition GDTFManager.cpp:9651

SceneData::GdtfFixture::getConnectorByRef
GdtfConnectorPtr getConnectorByRef(const TXString &ref)
Definition GDTFManager.cpp:8081

SceneData::GdtfFixture::ResolveDmxSubChannelSetRefs
void ResolveDmxSubChannelSetRefs(GdtfDmxChannelFunctionPtr channelFunction)
Definition GDTFManager.cpp:8926

SceneData::GdtfFixture::IsReaded
bool IsReaded()
Definition GDTFManager.cpp:9078

SceneData::GdtfFixture::__ERROR_CONTAINER_POINTER
static TGdtfParsingErrorArray * __ERROR_CONTAINER_POINTER
Definition GDTFManager.h:2811

SceneData::GdtfFixture::SetThumbnailOffsetY
void SetThumbnailOffsetY(Sint32 thumbnailOffsetY)
Definition GDTFManager.cpp:10042

SceneData::GdtfFixture::AddGeometryBeam
GdtfGeometryPtr AddGeometryBeam(const TXString &name, GdtfModelPtr refToModel, const VWTransformMatrix &ma)
Definition GDTFManager.cpp:9696

SceneData::GdtfFixture::SetMinorVersion
void SetMinorVersion(Sint32 minorVersion)
Definition GDTFManager.cpp:10057

SceneData::GdtfFixture::GetGeometryArray
const TGdtfGeometryArray & GetGeometryArray()
Definition GDTFManager.cpp:9851

SceneData::GdtfFixture::AddGeometryWithAxis
GdtfGeometryPtr AddGeometryWithAxis(const TXString &name, GdtfModelPtr refToModel, const VWTransformMatrix &ma)
Definition GDTFManager.cpp:9633

SceneData::GdtfFixture::GetModelArray
const TGdtfModelArray & GetModelArray()
Definition GDTFManager.cpp:9861

SceneData::GdtfFixture::SetGuid
void SetGuid(const VWFC::Tools::VWUUID &uuid)
Definition GDTFManager.cpp:10021

SceneData::GdtfFixture::GetLinkedGuid
GdtfFixtureGUID GetLinkedGuid() const
Definition GDTFManager.cpp:9916

SceneData::GdtfFixture::ResolveDMXMode
GdtfDmxModePtr ResolveDMXMode(const TXString &unresolvedDMXmode)
Definition GDTFManager.cpp:8597

SceneData::GdtfFixture::getFilterByRef
GdtfFilterPtr getFilterByRef(const TXString &ref)
Definition GDTFManager.cpp:8068

SceneData::GdtfFixture::getAttributeByRef
GdtfAttributePtr getAttributeByRef(const TXString &ref)
Definition GDTFManager.cpp:7970

SceneData::GdtfFixture::OnPrintToFile
virtual void OnPrintToFile(IXMLFileNodePtr pNode)
Definition GDTFManager.cpp:9088

SceneData::GdtfFixture::getDMXProfileByRef
GdtfDMXProfilePtr getDMXProfileByRef(const TXString &ref)
Definition GDTFManager.cpp:8120

SceneData::GdtfFixture::AddGeometryStructure
GdtfGeometryPtr AddGeometryStructure(const TXString &name, GdtfModelPtr refToModel, const VWTransformMatrix &ma)
Definition GDTFManager.cpp:9768

SceneData::GdtfFixture::GetAttachedFileCountAt
bool GetAttachedFileCountAt(size_t at, TXString *&outFile)
Definition GDTFManager.cpp:9070

SceneData::GdtfFixture::getWheelByRef
GdtfWheelPtr getWheelByRef(const TXString &ref)
Definition GDTFManager.cpp:8042

SceneData::GdtfFixture::GetFullThumbNailPath
TXString GetFullThumbNailPath(const TXString &fileExtension)
Definition GDTFManager.cpp:9946

SceneData::GdtfFixture::OnErrorCheck
virtual void OnErrorCheck(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:9476

SceneData::GdtfFixture::ExportToFile
bool ExportToFile(IZIPFilePtr &zipfile)
Definition GDTFManager.cpp:9512

SceneData::GdtfFixture::ResolveMacroRefs
void ResolveMacroRefs(GdtfDmxModePtr dmxMode)
Definition GDTFManager.cpp:8413

SceneData::GdtfFixture::GetDmxModeArray
const TGdtfDmxModeArray & GetDmxModeArray()
Definition GDTFManager.cpp:9856

SceneData::GdtfFixture::ResolveDmxModeRefs
void ResolveDmxModeRefs()
Definition GDTFManager.cpp:8495

SceneData::GdtfFixture::AddAttribute
GdtfAttributePtr AddAttribute(const TXString &name, const TXString &prettyName)
Definition GDTFManager.cpp:9604

SceneData::GdtfFixture::AddGeometryReference
GdtfGeometryPtr AddGeometryReference(const TXString &name, GdtfModelPtr refToModel, const VWTransformMatrix &ma)
Definition GDTFManager.cpp:9660

SceneData::GdtfFixture::GdtfFixture
GdtfFixture()
Definition GDTFManager.cpp:9028

SceneData::GdtfFixture::GetThumbnailName
const TXString & GetThumbnailName() const
Definition GDTFManager.cpp:9926

SceneData::GdtfFixture::getDmxFunctionByRef
GdtfDmxChannelFunctionPtr getDmxFunctionByRef(const TXString &ref, GdtfDmxModePtr mode)
Definition GDTFManager.cpp:8150

SceneData::GdtfFixture::getColorSpaceByRef
GdtfColorSpacePtr getColorSpaceByRef(const TXString &ref)
Definition GDTFManager.cpp:8094

SceneData::GdtfFixture::ResolveDmxLogicalChanRefs
void ResolveDmxLogicalChanRefs(GdtfDmxChannelPtr dmxChnl)
Definition GDTFManager.cpp:8756

SceneData::GdtfFixture::AutoGenerateNames
void AutoGenerateNames(GdtfDmxModePtr dmxMode)
Definition GDTFManager.cpp:7897

SceneData::GdtfFixture::~GdtfFixture
~GdtfFixture()
Definition GDTFManager.cpp:9039

SceneData::GdtfFixture::ResolveGeometryRefs
void ResolveGeometryRefs()
Definition GDTFManager.cpp:8191

SceneData::GdtfFixture::GetPresetArray
const TGdtfUserPresetArray & GetPresetArray()
Definition GDTFManager.cpp:9871

SceneData::GdtfFixture::GetFixtureTypeDescription
const TXString & GetFixtureTypeDescription() const
Definition GDTFManager.cpp:9906

SceneData::GdtfFixture::AddGeometryDisplay
GdtfGeometryPtr AddGeometryDisplay(const TXString &name, GdtfModelPtr refToModel, const VWTransformMatrix &ma)
Definition GDTFManager.cpp:9732

SceneData::GdtfFixture::GetParsingErrorArray
TGdtfParsingErrorArray & GetParsingErrorArray()
Definition GDTFManager.cpp:7892

SceneData::GdtfFixture::GetActivationGroupArray
const TGdtfActivationGroupArray & GetActivationGroupArray()
Definition GDTFManager.cpp:9836

SceneData::GdtfFixture::GetWheelArray
const TGdtfWheelArray & GetWheelArray()
Definition GDTFManager.cpp:9831

SceneData::GdtfFixture::GetPNGThumnailFullPath
const GdtfPNGFile & GetPNGThumnailFullPath()
Definition GDTFManager.cpp:9965

SceneData::GdtfFixture::GetMacroArray
const TGdtfMacroArray & GetMacroArray()

SceneData::GdtfFixture::HasLinkedGuid
bool HasLinkedGuid() const
Definition GDTFManager.cpp:9921

SceneData::GdtfFixture::AddGeometryMediaServerLayer
GdtfGeometryPtr AddGeometryMediaServerLayer(const TXString &name, GdtfModelPtr refToModel, const VWTransformMatrix &ma)
Definition GDTFManager.cpp:9714

SceneData::GdtfFixture::SetLongName
void SetLongName(const TXString &longName)
Definition GDTFManager.cpp:10006

SceneData::GdtfFixture::ResolveAllReferences
void ResolveAllReferences()
Definition GDTFManager.cpp:8180

SceneData::GdtfFixture::getGamutByRef
GdtfGamutPtr getGamutByRef(const TXString &ref)
Definition GDTFManager.cpp:8107

SceneData::GdtfFixture::GetAttributeArray
const TGdtfAttributeArray & GetAttributeArray()
Definition GDTFManager.cpp:9846

SceneData::GdtfFixture::GetProtocollContainer
GdtfProtocols & GetProtocollContainer()
Definition GDTFManager.cpp:9881

SceneData::GdtfFixture::ResolveAttribRefs
void ResolveAttribRefs()
Definition GDTFManager.cpp:8342

SceneData::GdtfFixture::GetMajorVersion
Sint32 GetMajorVersion() const
Definition GDTFManager.cpp:9986

SceneData::GdtfFixture::GetObjectType
virtual EGdtfObjectType GetObjectType()
Definition GDTFManager.cpp:9503

SceneData::GdtfFixture::SetThumbnailName
void SetThumbnailName(const TXString &fileName)
Definition GDTFManager.cpp:10032

SceneData::GdtfFixture::GetFeatureGroupArray
const TGdtfFeatureGroupArray & GetFeatureGroupArray()
Definition GDTFManager.cpp:9841

SceneData::GdtfFixture::SetMajorVersion
void SetMajorVersion(Sint32 majorVersion)
Definition GDTFManager.cpp:10052

SceneData::GdtfFixture::AddModel
GdtfModelPtr AddModel(const TXString &name)
Definition GDTFManager.cpp:9625

SceneData::GdtfFixture::CreateNoFeatureAttribute
void CreateNoFeatureAttribute()
Definition GDTFManager.cpp:7994

SceneData::GdtfFixture::GetManufacturer
const TXString & GetManufacturer() const
Definition GDTFManager.cpp:9901

SceneData::GdtfFixture::ImportFromBuffer
void ImportFromBuffer(const char *buffer, size_t length, const TXString &folder)
Definition GDTFManager.cpp:7677

SceneData::GdtfFixture::ResolveGeometryRefs_Recursive
void ResolveGeometryRefs_Recursive(GdtfGeometryPtr geometry)
Definition GDTFManager.cpp:8201

SceneData::GdtfFixture::AddUserPreset
GdtfUserPresetPtr AddUserPreset()
Definition GDTFManager.cpp:9804

SceneData::GdtfFixture::SetManufacturer
void SetManufacturer(const TXString &manu)
Definition GDTFManager.cpp:10011

SceneData::GdtfFixture::ImportFromFile
void ImportFromFile(IFileIdentifierPtr inZipFile, const TXString &folder)
Definition GDTFManager.cpp:7667

SceneData::GdtfFixture::SetCanHaveChildren
void SetCanHaveChildren(bool canHaveChildren)
Definition GDTFManager.cpp:10047

SceneData::GdtfFixture::GetWorkingFolder
void GetWorkingFolder(IFolderIdentifierPtr &folder)
Definition GDTFManager.cpp:9083

SceneData::GdtfFixture::AddDmxMode
GdtfDmxModePtr AddDmxMode(const TXString &name)
Definition GDTFManager.cpp:9795

SceneData::GdtfFixture::GetShortName
const TXString & GetShortName() const
Definition GDTFManager.cpp:9891

SceneData::GdtfFixture::AddGeometryLaser
GdtfGeometryPtr AddGeometryLaser(const TXString &name, GdtfModelPtr refToModel, const VWTransformMatrix &ma)
Definition GDTFManager.cpp:9741

SceneData::GdtfFixture::ResolveDmxChanelFunctionRefs
void ResolveDmxChanelFunctionRefs(GdtfDmxLogicalChannelPtr dmxLogChnl)
Definition GDTFManager.cpp:8841

SceneData::GdtfFixture::SetShortName
void SetShortName(const TXString &shortName)
Definition GDTFManager.cpp:10001

SceneData::GdtfFixture::OnReadFromNode
virtual void OnReadFromNode(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:9229

SceneData::GdtfFixture::GetCanHaveChildren
bool GetCanHaveChildren() const
Definition GDTFManager.cpp:9941

SceneData::GdtfFixture::GetPhysicalDesciptionsContainer
GdtfPhysicalDescriptions & GetPhysicalDesciptionsContainer()
Definition GDTFManager.cpp:9981

SceneData::GdtfFixture::GetRevisionArray
const TGdtfRevisionArray & GetRevisionArray()
Definition GDTFManager.cpp:9866

SceneData::GdtfFixture::AddMacro
GdtfMacroPtr AddMacro(const TXString &name)

SceneData::GdtfFixture::AddGeometryMediaServerCamera
GdtfGeometryPtr AddGeometryMediaServerCamera(const TXString &name, GdtfModelPtr refToModel, const VWTransformMatrix &ma)
Definition GDTFManager.cpp:9705

SceneData::GdtfFixture::GetName
const TXString & GetName() const
Definition GDTFManager.cpp:9886

SceneData::GdtfFixture::ResolveDMXModeMasters
void ResolveDMXModeMasters()
Definition GDTFManager.cpp:8539

SceneData::GdtfFixture::AddGeometryWiringObject
GdtfGeometryPtr AddGeometryWiringObject(const TXString &name, GdtfModelPtr refToModel, const VWTransformMatrix &ma)
Definition GDTFManager.cpp:9750

SceneData::GdtfFixture::ResolveDmxRelationRefs
void ResolveDmxRelationRefs(GdtfDmxModePtr dmxMode)
Definition GDTFManager.cpp:8638

SceneData::GdtfFixture::getEmiterByRef
GdtfPhysicalEmitterPtr getEmiterByRef(const TXString &ref)
Definition GDTFManager.cpp:8055

SceneData::GdtfFixture::AddGeometryMediaServerMaster
GdtfGeometryPtr AddGeometryMediaServerMaster(const TXString &name, GdtfModelPtr refToModel, const VWTransformMatrix &ma)
Definition GDTFManager.cpp:9723

SceneData::GdtfGamut
Definition GDTFManager.h:497

SceneData::GdtfGamut::OnReadFromNode
virtual void OnReadFromNode(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:11949

SceneData::GdtfGamut::GdtfGamut
GdtfGamut()
Definition GDTFManager.cpp:11903

SceneData::GdtfGamut::GetGamutPoints
const TCCieColorArray & GetGamutPoints() const
Definition GDTFManager.cpp:11924

SceneData::GdtfGamut::OnPrintToFile
virtual void OnPrintToFile(IXMLFileNodePtr pNode)
Definition GDTFManager.cpp:11939

SceneData::GdtfGamut::GetName
const TXString & GetName() const
Definition GDTFManager.cpp:11919

SceneData::GdtfGamut::GetObjectType
virtual EGdtfObjectType GetObjectType()
Definition GDTFManager.cpp:11976

SceneData::GdtfGamut::SetName
void SetName(const TXString &name)
Definition GDTFManager.cpp:11929

SceneData::GdtfGamut::~GdtfGamut
~GdtfGamut()
Definition GDTFManager.cpp:11914

SceneData::GdtfGamut::GetNodeName
virtual TXString GetNodeName()
Definition GDTFManager.cpp:11981

SceneData::GdtfGamut::AddGamutPoint
void AddGamutPoint(CCieColorPtr newPoint)
Definition GDTFManager.cpp:11934

SceneData::GdtfGamut::OnErrorCheck
virtual void OnErrorCheck(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:11959

SceneData::GdtfGamut::GetNodeReference
virtual TXString GetNodeReference()
Definition GDTFManager.cpp:11986

SceneData::GdtfGeometryAxis
Definition GDTFManager.h:823

SceneData::GdtfGeometryAxis::GetNodeName
virtual TXString GetNodeName()
Definition GDTFManager.cpp:2470

SceneData::GdtfGeometryAxis::GdtfGeometryAxis
GdtfGeometryAxis(GdtfGeometry *parent)
Definition GDTFManager.cpp:2413

SceneData::GdtfGeometryAxis::OnPrintToFile
virtual void OnPrintToFile(IXMLFileNodePtr pNode)
Definition GDTFManager.cpp:2429

SceneData::GdtfGeometryAxis::OnReadFromNode
virtual void OnReadFromNode(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:2438

SceneData::GdtfGeometryAxis::OnErrorCheck
virtual void OnErrorCheck(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:2446

SceneData::GdtfGeometryAxis::GetObjectType
virtual EGdtfObjectType GetObjectType()
Definition GDTFManager.cpp:2465

SceneData::GdtfGeometryAxis::~GdtfGeometryAxis
~GdtfGeometryAxis()
Definition GDTFManager.cpp:2425

SceneData::GdtfGeometryBeamFilter
Definition GDTFManager.h:842

SceneData::GdtfGeometryBeamFilter::OnReadFromNode
virtual void OnReadFromNode(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:2499

SceneData::GdtfGeometryBeamFilter::OnPrintToFile
virtual void OnPrintToFile(IXMLFileNodePtr pNode)
Definition GDTFManager.cpp:2491

SceneData::GdtfGeometryBeamFilter::OnErrorCheck
virtual void OnErrorCheck(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:2506

SceneData::GdtfGeometryBeamFilter::GetObjectType
virtual EGdtfObjectType GetObjectType()
Definition GDTFManager.cpp:2525

SceneData::GdtfGeometryBeamFilter::GetNodeName
virtual TXString GetNodeName()
Definition GDTFManager.cpp:2530

SceneData::GdtfGeometryBeamFilter::GdtfGeometryBeamFilter
GdtfGeometryBeamFilter(GdtfGeometry *parent)
Definition GDTFManager.cpp:2477

SceneData::GdtfGeometryBeamFilter::~GdtfGeometryBeamFilter
~GdtfGeometryBeamFilter()
Definition GDTFManager.cpp:2487

SceneData::GdtfGeometryColorFilter
Definition GDTFManager.h:857

SceneData::GdtfGeometryColorFilter::GetObjectType
virtual EGdtfObjectType GetObjectType()
Definition GDTFManager.cpp:2587

SceneData::GdtfGeometryColorFilter::OnErrorCheck
virtual void OnErrorCheck(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:2568

SceneData::GdtfGeometryColorFilter::OnReadFromNode
virtual void OnReadFromNode(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:2561

SceneData::GdtfGeometryColorFilter::~GdtfGeometryColorFilter
~GdtfGeometryColorFilter()
Definition GDTFManager.cpp:2549

SceneData::GdtfGeometryColorFilter::OnPrintToFile
virtual void OnPrintToFile(IXMLFileNodePtr pNode)
Definition GDTFManager.cpp:2553

SceneData::GdtfGeometryColorFilter::GdtfGeometryColorFilter
GdtfGeometryColorFilter(GdtfGeometry *parent)
Definition GDTFManager.cpp:2537

SceneData::GdtfGeometryColorFilter::GetNodeName
virtual TXString GetNodeName()
Definition GDTFManager.cpp:2592

SceneData::GdtfGeometryDisplay
Definition GDTFManager.h:947

SceneData::GdtfGeometryDisplay::GetTexture
const TXString & GetTexture()
Definition GDTFManager.cpp:2921

SceneData::GdtfGeometryDisplay::OnPrintToFile
virtual void OnPrintToFile(IXMLFileNodePtr pNode)
Definition GDTFManager.cpp:2931

SceneData::GdtfGeometryDisplay::GdtfGeometryDisplay
GdtfGeometryDisplay(GdtfGeometry *parent)
Definition GDTFManager.cpp:2905

SceneData::GdtfGeometryDisplay::SetTexture
void SetTexture(const TXString &texture)
Definition GDTFManager.cpp:2926

SceneData::GdtfGeometryDisplay::GetNodeName
virtual TXString GetNodeName()
Definition GDTFManager.cpp:2973

SceneData::GdtfGeometryDisplay::~GdtfGeometryDisplay
~GdtfGeometryDisplay()
Definition GDTFManager.cpp:2917

SceneData::GdtfGeometryDisplay::GetObjectType
virtual EGdtfObjectType GetObjectType()
Definition GDTFManager.cpp:2968

SceneData::GdtfGeometryDisplay::OnErrorCheck
virtual void OnErrorCheck(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:2948

SceneData::GdtfGeometryDisplay::OnReadFromNode
virtual void OnReadFromNode(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:2939

SceneData::GdtfGeometryGoboFilter
Definition GDTFManager.h:872

SceneData::GdtfGeometryGoboFilter::GetObjectType
virtual EGdtfObjectType GetObjectType()
Definition GDTFManager.cpp:2710

SceneData::GdtfGeometryGoboFilter::~GdtfGeometryGoboFilter
~GdtfGeometryGoboFilter()
Definition GDTFManager.cpp:2672

SceneData::GdtfGeometryGoboFilter::OnPrintToFile
virtual void OnPrintToFile(IXMLFileNodePtr pNode)
Definition GDTFManager.cpp:2676

SceneData::GdtfGeometryGoboFilter::GetNodeName
virtual TXString GetNodeName()
Definition GDTFManager.cpp:2715

SceneData::GdtfGeometryGoboFilter::GdtfGeometryGoboFilter
GdtfGeometryGoboFilter(GdtfGeometry *parent)
Definition GDTFManager.cpp:2661

SceneData::GdtfGeometryGoboFilter::OnReadFromNode
virtual void OnReadFromNode(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:2684

SceneData::GdtfGeometryGoboFilter::OnErrorCheck
virtual void OnErrorCheck(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:2691

SceneData::GdtfGeometry
Definition GDTFManager.h:757

SceneData::GdtfGeometry::GetNodeName
virtual TXString GetNodeName()
Definition GDTFManager.cpp:2379

SceneData::GdtfGeometry::GetUnresolvedModelRef
TXString GetUnresolvedModelRef() const
Definition GDTFManager.cpp:2368

SceneData::GdtfGeometry::AddGeometryMagnet
GdtfGeometry * AddGeometryMagnet(const TXString &name, GdtfModelPtr refToModel, const VWTransformMatrix &ma)
Definition GDTFManager.cpp:2223

SceneData::GdtfGeometry::AddGeometryBeam
GdtfGeometry * AddGeometryBeam(const TXString &name, GdtfModelPtr refToModel, const VWTransformMatrix &ma)
Definition GDTFManager.cpp:2133

SceneData::GdtfGeometry::AddGeometryLaser
GdtfGeometry * AddGeometryLaser(const TXString &name, GdtfModelPtr refToModel, const VWTransformMatrix &ma)
Definition GDTFManager.cpp:2178

SceneData::GdtfGeometry::SetModel
void SetModel(GdtfModelPtr model)
Definition GDTFManager.cpp:2065

SceneData::GdtfGeometry::GetInternalGeometries
const std::vector< GdtfGeometry * > GetInternalGeometries()
Definition GDTFManager.cpp:2394

SceneData::GdtfGeometry::AddGeometryDisplay
GdtfGeometry * AddGeometryDisplay(const TXString &name, GdtfModelPtr refToModel, const VWTransformMatrix &ma)
Definition GDTFManager.cpp:2169

SceneData::GdtfGeometry::SetTransformMatrix
void SetTransformMatrix(const VWTransformMatrix &ma)
Definition GDTFManager.cpp:2060

SceneData::GdtfGeometry::OnErrorCheck
virtual void OnErrorCheck(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:2338

SceneData::GdtfGeometry::AddGeometry
GdtfGeometry * AddGeometry(const TXString &name, GdtfModelPtr refToModel, const VWTransformMatrix &ma)
Definition GDTFManager.cpp:2088

SceneData::GdtfGeometry::AddGeometrySupport
GdtfGeometry * AddGeometrySupport(const TXString &name, GdtfModelPtr refToModel, const VWTransformMatrix &ma)
Definition GDTFManager.cpp:2214

SceneData::GdtfGeometry::AddGeometryWithAxis
GdtfGeometry * AddGeometryWithAxis(const TXString &name, GdtfModelPtr refToModel, const VWTransformMatrix &ma)
Definition GDTFManager.cpp:2070

SceneData::GdtfGeometry::~GdtfGeometry
~GdtfGeometry()
Definition GDTFManager.cpp:2050

SceneData::GdtfGeometry::AddGeometryStructure
GdtfGeometry * AddGeometryStructure(const TXString &name, GdtfModelPtr refToModel, const VWTransformMatrix &ma)
Definition GDTFManager.cpp:2205

SceneData::GdtfGeometry::SetName
void SetName(const TXString &name)
Definition GDTFManager.cpp:2055

SceneData::GdtfGeometry::AddGeometryMediaServerLayer
GdtfGeometry * AddGeometryMediaServerLayer(const TXString &name, GdtfModelPtr refToModel, const VWTransformMatrix &ma)
Definition GDTFManager.cpp:2151

SceneData::GdtfGeometry::GetParentGeometry
GdtfGeometry * GetParentGeometry()
Definition GDTFManager.cpp:2406

SceneData::GdtfGeometry::AddGeometryReference
GdtfGeometry * AddGeometryReference(const TXString &name, GdtfModelPtr refToModel, const VWTransformMatrix &ma)
Definition GDTFManager.cpp:2097

SceneData::GdtfGeometry::GetName
const TXString & GetName() const
Definition GDTFManager.cpp:2389

SceneData::GdtfGeometry::GetObjectType
virtual EGdtfObjectType GetObjectType()
Definition GDTFManager.cpp:2384

SceneData::GdtfGeometry::OnPrintToFile
virtual void OnPrintToFile(IXMLFileNodePtr pNode)
Definition GDTFManager.cpp:2232

SceneData::GdtfGeometry::AddGeometryShaper
GdtfGeometry * AddGeometryShaper(const TXString &name, GdtfModelPtr refToModel, const VWTransformMatrix &ma)
Definition GDTFManager.cpp:2106

SceneData::GdtfGeometry::OnReadFromNode
virtual void OnReadFromNode(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:2255

SceneData::GdtfGeometry::AddGeometryMediaServerMaster
GdtfGeometry * AddGeometryMediaServerMaster(const TXString &name, GdtfModelPtr refToModel, const VWTransformMatrix &ma)
Definition GDTFManager.cpp:2160

SceneData::GdtfGeometry::AddGeometryGobo
GdtfGeometry * AddGeometryGobo(const TXString &name, GdtfModelPtr refToModel, const VWTransformMatrix &ma)
Definition GDTFManager.cpp:2124

SceneData::GdtfGeometry::AddGeometryWiringObject
GdtfGeometry * AddGeometryWiringObject(const TXString &name, GdtfModelPtr refToModel, const VWTransformMatrix &ma)
Definition GDTFManager.cpp:2187

SceneData::GdtfGeometry::GdtfGeometry
GdtfGeometry(GdtfGeometry *parent)
Definition GDTFManager.cpp:2034

SceneData::GdtfGeometry::AddGeometryInventory
GdtfGeometry * AddGeometryInventory(const TXString &name, GdtfModelPtr refToModel, const VWTransformMatrix &ma)
Definition GDTFManager.cpp:2196

SceneData::GdtfGeometry::GetTransformMatrix
void GetTransformMatrix(VWTransformMatrix &ma) const
Definition GDTFManager.cpp:2363

SceneData::GdtfGeometry::SetUnresolvedModelRef
void SetUnresolvedModelRef(GdtfModelPtr ref)
Definition GDTFManager.cpp:2373

SceneData::GdtfGeometry::AddGeometryWithLamp
GdtfGeometry * AddGeometryWithLamp(const TXString &name, GdtfModelPtr refToModel, const VWTransformMatrix &ma)
Definition GDTFManager.cpp:2079

SceneData::GdtfGeometry::GetModelRef
GdtfModelPtr GetModelRef() const
Definition GDTFManager.cpp:2358

SceneData::GdtfGeometry::GetNodeReference
virtual TXString GetNodeReference()
Definition GDTFManager.cpp:2399

SceneData::GdtfGeometry::AddGeometryMediaServerCamera
GdtfGeometry * AddGeometryMediaServerCamera(const TXString &name, GdtfModelPtr refToModel, const VWTransformMatrix &ma)
Definition GDTFManager.cpp:2142

SceneData::GdtfGeometry::AddGeometryColor
GdtfGeometry * AddGeometryColor(const TXString &name, GdtfModelPtr refToModel, const VWTransformMatrix &ma)
Definition GDTFManager.cpp:2115

SceneData::GdtfGeometryInventory
Definition GDTFManager.h:1169

SceneData::GdtfGeometryInventory::OnPrintToFile
virtual void OnPrintToFile(IXMLFileNodePtr pNode)
Definition GDTFManager.cpp:3782

SceneData::GdtfGeometryInventory::SetCount
void SetCount(size_t count)
Definition GDTFManager.cpp:3777

SceneData::GdtfGeometryInventory::GetNodeName
virtual TXString GetNodeName()
Definition GDTFManager.cpp:3825

SceneData::GdtfGeometryInventory::GetCount
size_t GetCount() const
Definition GDTFManager.cpp:3772

SceneData::GdtfGeometryInventory::OnErrorCheck
virtual void OnErrorCheck(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:3800

SceneData::GdtfGeometryInventory::~GdtfGeometryInventory
~GdtfGeometryInventory()
Definition GDTFManager.cpp:3768

SceneData::GdtfGeometryInventory::OnReadFromNode
virtual void OnReadFromNode(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:3791

SceneData::GdtfGeometryInventory::GetObjectType
virtual EGdtfObjectType GetObjectType()
Definition GDTFManager.cpp:3820

SceneData::GdtfGeometryInventory::GdtfGeometryInventory
GdtfGeometryInventory(GdtfGeometry *parent)
Definition GDTFManager.cpp:3758

SceneData::GdtfGeometryLamp
Definition GDTFManager.h:1325

SceneData::GdtfGeometryLamp::GetColorIndex
Sint32 GetColorIndex()
Definition GDTFManager.cpp:4561

SceneData::GdtfGeometryLamp::SetLampType
void SetLampType(EGdtfLampType type)
Definition GDTFManager.cpp:4360

SceneData::GdtfGeometryLamp::SetRectangleRatio
void SetRectangleRatio(double ratio)
Definition GDTFManager.cpp:4400

SceneData::GdtfGeometryLamp::OnReadFromNode
virtual void OnReadFromNode(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:4445

SceneData::GdtfGeometryLamp::~GdtfGeometryLamp
~GdtfGeometryLamp()
Definition GDTFManager.cpp:4356

SceneData::GdtfGeometryLamp::GetRectangleRatio
double GetRectangleRatio()
Definition GDTFManager.cpp:4551

SceneData::GdtfGeometryLamp::GetLuminousIntensity
double GetLuminousIntensity()
Definition GDTFManager.cpp:4521

SceneData::GdtfGeometryLamp::GetFieldAngle
double GetFieldAngle()
Definition GDTFManager.cpp:4536

SceneData::GdtfGeometryLamp::GetLampType
EGdtfLampType GetLampType()
Definition GDTFManager.cpp:4511

SceneData::GdtfGeometryLamp::SetBeamRadius
void SetBeamRadius(double radius)
Definition GDTFManager.cpp:4390

SceneData::GdtfGeometryLamp::GetThrowRatio
double GetThrowRatio()
Definition GDTFManager.cpp:4546

SceneData::GdtfGeometryLamp::SetFieldAngle
void SetFieldAngle(double angle)
Definition GDTFManager.cpp:4385

SceneData::GdtfGeometryLamp::SetEmitterSpectrum
void SetEmitterSpectrum(GdtfPhysicalEmitter *emitterSpectrum)
Definition GDTFManager.cpp:4415

SceneData::GdtfGeometryLamp::GetPowerConsumption
double GetPowerConsumption()
Definition GDTFManager.cpp:4516

SceneData::GdtfGeometryLamp::SetColorTemperature
void SetColorTemperature(double temperature)
Definition GDTFManager.cpp:4375

SceneData::GdtfGeometryLamp::GetColorTemperature
double GetColorTemperature()
Definition GDTFManager.cpp:4526

SceneData::GdtfGeometryLamp::InitializeMembersWithDefaultsVals
void InitializeMembersWithDefaultsVals()
Definition GDTFManager.cpp:4340

SceneData::GdtfGeometryLamp::SetBeamType
void SetBeamType(EGdtfBeamType type)
Definition GDTFManager.cpp:4405

SceneData::GdtfGeometryLamp::OnPrintToFile
virtual void OnPrintToFile(IXMLFileNodePtr pNode)
Definition GDTFManager.cpp:4420

SceneData::GdtfGeometryLamp::SetThrowRatio
void SetThrowRatio(double ratio)
Definition GDTFManager.cpp:4395

SceneData::GdtfGeometryLamp::GdtfGeometryLamp
GdtfGeometryLamp(GdtfGeometry *parent)
Definition GDTFManager.cpp:4328

SceneData::GdtfGeometryLamp::GetUnresolvedEmitterRef
TXString GetUnresolvedEmitterRef() const
Definition GDTFManager.cpp:4571

SceneData::GdtfGeometryLamp::SetPowerConsumption
void SetPowerConsumption(double powerConsumption)
Definition GDTFManager.cpp:4365

SceneData::GdtfGeometryLamp::GetBeamType
EGdtfBeamType GetBeamType()
Definition GDTFManager.cpp:4556

SceneData::GdtfGeometryLamp::SetColorIndex
void SetColorIndex(Sint32 idx)
Definition GDTFManager.cpp:4410

SceneData::GdtfGeometryLamp::GetNodeName
virtual TXString GetNodeName()
Definition GDTFManager.cpp:4506

SceneData::GdtfGeometryLamp::SetLuminousIntensity
void SetLuminousIntensity(double intensity)
Definition GDTFManager.cpp:4370

SceneData::GdtfGeometryLamp::GetBeamAngle
double GetBeamAngle()
Definition GDTFManager.cpp:4531

SceneData::GdtfGeometryLamp::SetBeamAngle
void SetBeamAngle(double angle)
Definition GDTFManager.cpp:4380

SceneData::GdtfGeometryLamp::GetBeamRadius
double GetBeamRadius()
Definition GDTFManager.cpp:4541

SceneData::GdtfGeometryLamp::GetEmitterSpectrum
GdtfPhysicalEmitter * GetEmitterSpectrum()
Definition GDTFManager.cpp:4566

SceneData::GdtfGeometryLamp::OnErrorCheck
virtual void OnErrorCheck(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:4469

SceneData::GdtfGeometryLamp::GetObjectType
virtual EGdtfObjectType GetObjectType()
Definition GDTFManager.cpp:4501

SceneData::GdtfGeometryLaser
Definition GDTFManager.h:989

SceneData::GdtfGeometryLaser::GetBeamDivergenceMax
double GetBeamDivergenceMax() const
Definition GDTFManager.cpp:3098

SceneData::GdtfGeometryLaser::OnReadFromNode
virtual void OnReadFromNode(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:3210

SceneData::GdtfGeometryLaser::OnErrorCheck
virtual void OnErrorCheck(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:3239

SceneData::GdtfGeometryLaser::~GdtfGeometryLaser
~GdtfGeometryLaser()
Definition GDTFManager.cpp:3064

SceneData::GdtfGeometryLaser::GetEmitter
GdtfPhysicalEmitter * GetEmitter() const
Definition GDTFManager.cpp:3083

SceneData::GdtfGeometryLaser::OnPrintToFile
virtual void OnPrintToFile(IXMLFileNodePtr pNode)
Definition GDTFManager.cpp:3185

SceneData::GdtfGeometryLaser::SetOutputStrength
void SetOutputStrength(double outputStrength)
Definition GDTFManager.cpp:3138

SceneData::GdtfGeometryLaser::SetBeamDivergenceMax
void SetBeamDivergenceMax(double beamDivergenceMax)
Definition GDTFManager.cpp:3158

SceneData::GdtfGeometryLaser::GetBeamDiameter
double GetBeamDiameter() const
Definition GDTFManager.cpp:3088

SceneData::GdtfGeometryLaser::GetLaserProtocolArray
const TGdtfLaserProtocolArray & GetLaserProtocolArray() const
Definition GDTFManager.cpp:3123

SceneData::GdtfGeometryLaser::GetOutputStrength
double GetOutputStrength() const
Definition GDTFManager.cpp:3078

SceneData::GdtfGeometryLaser::GetNodeName
virtual TXString GetNodeName()
Definition GDTFManager.cpp:3275

SceneData::GdtfGeometryLaser::GetObjectType
virtual EGdtfObjectType GetObjectType()
Definition GDTFManager.cpp:3270

SceneData::GdtfGeometryLaser::SetScanAnglePan
void SetScanAnglePan(double scanAnglePan)
Definition GDTFManager.cpp:3163

SceneData::GdtfGeometryLaser::GdtfGeometryLaser
GdtfGeometryLaser(GdtfGeometry *parent)
Definition GDTFManager.cpp:3050

SceneData::GdtfGeometryLaser::GetScanAngleTilt
double GetScanAngleTilt() const
Definition GDTFManager.cpp:3108

SceneData::GdtfGeometryLaser::SetScanSpeed
void SetScanSpeed(double scanSpeed)
Definition GDTFManager.cpp:3173

SceneData::GdtfGeometryLaser::GetScanSpeed
double GetScanSpeed() const
Definition GDTFManager.cpp:3113

SceneData::GdtfGeometryLaser::GetScanAnglePan
double GetScanAnglePan() const
Definition GDTFManager.cpp:3103

SceneData::GdtfGeometryLaser::GetColor
double GetColor() const
Definition GDTFManager.cpp:3074

SceneData::GdtfGeometryLaser::SetScanAngleTilt
void SetScanAngleTilt(double scanAngleTilt)
Definition GDTFManager.cpp:3168

SceneData::GdtfGeometryLaser::SetBeamDiameter
void SetBeamDiameter(double beamDiameter)
Definition GDTFManager.cpp:3148

SceneData::GdtfGeometryLaser::GetUnresolvedEmitter
const TXString & GetUnresolvedEmitter() const
Definition GDTFManager.cpp:3118

SceneData::GdtfGeometryLaser::SetEmitter
void SetEmitter(GdtfPhysicalEmitter *emitter)
Definition GDTFManager.cpp:3143

SceneData::GdtfGeometryLaser::SetColorType
void SetColorType(const EGdtfLaserColorType &colorType)
Definition GDTFManager.cpp:3128

SceneData::GdtfGeometryLaser::GetBeamDivergenceMin
double GetBeamDivergenceMin() const
Definition GDTFManager.cpp:3093

SceneData::GdtfGeometryLaser::SetColor
void SetColor(double waveLength)
Definition GDTFManager.cpp:3133

SceneData::GdtfGeometryLaser::CreateLaserProtocol
GdtfLaserProtocolPtr CreateLaserProtocol(const TXString &name)
Definition GDTFManager.cpp:3178

SceneData::GdtfGeometryLaser::GetColorType
EGdtfLaserColorType GetColorType() const
Definition GDTFManager.cpp:3069

SceneData::GdtfGeometryLaser::SetBeamDivergenceMin
void SetBeamDivergenceMin(double beamDivergenceMin)
Definition GDTFManager.cpp:3153

SceneData::GdtfGeometryMagnet
Definition GDTFManager.h:1308

SceneData::GdtfGeometryMagnet::OnErrorCheck
virtual void OnErrorCheck(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:4297

SceneData::GdtfGeometryMagnet::GetNodeName
virtual TXString GetNodeName()
Definition GDTFManager.cpp:4321

SceneData::GdtfGeometryMagnet::GdtfGeometryMagnet
GdtfGeometryMagnet(GdtfGeometry *parent)
Definition GDTFManager.cpp:4269

SceneData::GdtfGeometryMagnet::GetObjectType
virtual EGdtfObjectType GetObjectType()
Definition GDTFManager.cpp:4316

SceneData::GdtfGeometryMagnet::OnPrintToFile
virtual void OnPrintToFile(IXMLFileNodePtr pNode)
Definition GDTFManager.cpp:4283

SceneData::GdtfGeometryMagnet::~GdtfGeometryMagnet
~GdtfGeometryMagnet()
Definition GDTFManager.cpp:4279

SceneData::GdtfGeometryMagnet::OnReadFromNode
virtual void OnReadFromNode(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:4290

SceneData::GdtfGeometryMediaServerCamera::GetObjectType
virtual EGdtfObjectType GetObjectType()
Definition GDTFManager.cpp:2771

SceneData::GdtfGeometryMediaServerCamera::OnPrintToFile
virtual void OnPrintToFile(IXMLFileNodePtr pNode)
Definition GDTFManager.cpp:2737

SceneData::GdtfGeometryMediaServerCamera::GdtfGeometryMediaServerCamera
GdtfGeometryMediaServerCamera(GdtfGeometry *parent)
Definition GDTFManager.cpp:2722

SceneData::GdtfGeometryMediaServerCamera::~GdtfGeometryMediaServerCamera
~GdtfGeometryMediaServerCamera()
Definition GDTFManager.cpp:2733

SceneData::GdtfGeometryMediaServerCamera::OnErrorCheck
virtual void OnErrorCheck(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:2752

SceneData::GdtfGeometryMediaServerCamera::OnReadFromNode
virtual void OnReadFromNode(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:2745

SceneData::GdtfGeometryMediaServerCamera::GetNodeName
virtual TXString GetNodeName()
Definition GDTFManager.cpp:2776

SceneData::GdtfGeometryMediaServerLayer::GdtfGeometryMediaServerLayer
GdtfGeometryMediaServerLayer(GdtfGeometry *parent)
Definition GDTFManager.cpp:2783

SceneData::GdtfGeometryMediaServerLayer::GetNodeName
virtual TXString GetNodeName()
Definition GDTFManager.cpp:2837

SceneData::GdtfGeometryMediaServerLayer::GetObjectType
virtual EGdtfObjectType GetObjectType()
Definition GDTFManager.cpp:2832

SceneData::GdtfGeometryMediaServerLayer::OnErrorCheck
virtual void OnErrorCheck(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:2813

SceneData::GdtfGeometryMediaServerLayer::~GdtfGeometryMediaServerLayer
~GdtfGeometryMediaServerLayer()
Definition GDTFManager.cpp:2794

SceneData::GdtfGeometryMediaServerLayer::OnPrintToFile
virtual void OnPrintToFile(IXMLFileNodePtr pNode)
Definition GDTFManager.cpp:2798

SceneData::GdtfGeometryMediaServerLayer::OnReadFromNode
virtual void OnReadFromNode(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:2806

SceneData::GdtfGeometryMediaServerMaster::~GdtfGeometryMediaServerMaster
~GdtfGeometryMediaServerMaster()
Definition GDTFManager.cpp:2855

SceneData::GdtfGeometryMediaServerMaster::GetObjectType
virtual EGdtfObjectType GetObjectType()
Definition GDTFManager.cpp:2893

SceneData::GdtfGeometryMediaServerMaster::GdtfGeometryMediaServerMaster
GdtfGeometryMediaServerMaster(GdtfGeometry *parent)
Definition GDTFManager.cpp:2844

SceneData::GdtfGeometryMediaServerMaster::OnReadFromNode
virtual void OnReadFromNode(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:2867

SceneData::GdtfGeometryMediaServerMaster::OnErrorCheck
virtual void OnErrorCheck(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:2874

SceneData::GdtfGeometryMediaServerMaster::GetNodeName
virtual TXString GetNodeName()
Definition GDTFManager.cpp:2898

SceneData::GdtfGeometryMediaServerMaster::OnPrintToFile
virtual void OnPrintToFile(IXMLFileNodePtr pNode)
Definition GDTFManager.cpp:2859

SceneData::GdtfGeometryReference
Definition GDTFManager.h:1414

SceneData::GdtfGeometryReference::GetUnresolvedLinkedGeometry
const TXString & GetUnresolvedLinkedGeometry()
Definition GDTFManager.cpp:4697

SceneData::GdtfGeometryReference::OnErrorCheck
virtual void OnErrorCheck(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:4739

SceneData::GdtfGeometryReference::GetBreakArray
TGdtfBreakArray GetBreakArray()
Definition GDTFManager.cpp:4769

SceneData::GdtfGeometryReference::OnReadFromNode
virtual void OnReadFromNode(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:4726

SceneData::GdtfGeometryReference::~GdtfGeometryReference
~GdtfGeometryReference()
Definition GDTFManager.cpp:4680

SceneData::GdtfGeometryReference::AddBreak
GdtfBreakPtr AddBreak()
Definition GDTFManager.cpp:4685

SceneData::GdtfGeometryReference::GetObjectType
virtual EGdtfObjectType GetObjectType()
Definition GDTFManager.cpp:4759

SceneData::GdtfGeometryReference::GetLinkedGeometry
GdtfGeometry * GetLinkedGeometry()
Definition GDTFManager.cpp:4692

SceneData::GdtfGeometryReference::GetNodeName
virtual TXString GetNodeName()
Definition GDTFManager.cpp:4764

SceneData::GdtfGeometryReference::SetLinkedGeometry
void SetLinkedGeometry(GdtfGeometry *ptr)
Definition GDTFManager.cpp:4702

SceneData::GdtfGeometryReference::OnPrintToFile
virtual void OnPrintToFile(IXMLFileNodePtr pNode)
Definition GDTFManager.cpp:4707

SceneData::GdtfGeometryReference::GdtfGeometryReference
GdtfGeometryReference(GdtfGeometry *parent)
Definition GDTFManager.cpp:4668

SceneData::GdtfGeometryShaperFilter
Definition GDTFManager.h:887

SceneData::GdtfGeometryShaperFilter::OnErrorCheck
virtual void OnErrorCheck(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:2630

SceneData::GdtfGeometryShaperFilter::GdtfGeometryShaperFilter
GdtfGeometryShaperFilter(GdtfGeometry *parent)
Definition GDTFManager.cpp:2599

SceneData::GdtfGeometryShaperFilter::OnReadFromNode
virtual void OnReadFromNode(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:2623

SceneData::GdtfGeometryShaperFilter::OnPrintToFile
virtual void OnPrintToFile(IXMLFileNodePtr pNode)
Definition GDTFManager.cpp:2615

SceneData::GdtfGeometryShaperFilter::GetNodeName
virtual TXString GetNodeName()
Definition GDTFManager.cpp:2654

SceneData::GdtfGeometryShaperFilter::~GdtfGeometryShaperFilter
~GdtfGeometryShaperFilter()
Definition GDTFManager.cpp:2611

SceneData::GdtfGeometryShaperFilter::GetObjectType
virtual EGdtfObjectType GetObjectType()
Definition GDTFManager.cpp:2649

SceneData::GdtfGeometryStructure
Definition GDTFManager.h:1192

SceneData::GdtfGeometryStructure::SetCrossSectionHeight
void SetCrossSectionHeight(double crossSectionHeight)
Definition GDTFManager.cpp:3900

SceneData::GdtfGeometryStructure::GetStructureType
EGdtfStructureType GetStructureType() const
Definition GDTFManager.cpp:3855

SceneData::GdtfGeometryStructure::SetCrossSectionWallThickness
void SetCrossSectionWallThickness(double crossSectionWallThickness)
Definition GDTFManager.cpp:3905

SceneData::GdtfGeometryStructure::GetNodeName
virtual TXString GetNodeName()
Definition GDTFManager.cpp:3984

SceneData::GdtfGeometryStructure::SetStructureType
void SetStructureType(const EGdtfStructureType &structureType)
Definition GDTFManager.cpp:3890

SceneData::GdtfGeometryStructure::OnPrintToFile
virtual void OnPrintToFile(IXMLFileNodePtr pNode)
Definition GDTFManager.cpp:3915

SceneData::GdtfGeometryStructure::OnErrorCheck
virtual void OnErrorCheck(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:3945

SceneData::GdtfGeometryStructure::GetLinkedGeometry
GdtfGeometry * GetLinkedGeometry() const
Definition GDTFManager.cpp:3850

SceneData::GdtfGeometryStructure::GetUnresolvedLinkedGeometry
const TXString & GetUnresolvedLinkedGeometry() const
Definition GDTFManager.cpp:3880

SceneData::GdtfGeometryStructure::GetCrossSectionWallThickness
double GetCrossSectionWallThickness() const
Definition GDTFManager.cpp:3870

SceneData::GdtfGeometryStructure::GetCrossSectionHeight
double GetCrossSectionHeight() const
Definition GDTFManager.cpp:3865

SceneData::GdtfGeometryStructure::GetTrussCrossSection
const TXString & GetTrussCrossSection() const
Definition GDTFManager.cpp:3875

SceneData::GdtfGeometryStructure::SetTrussCrossSection
void SetTrussCrossSection(const TXString &trussCrossSection)
Definition GDTFManager.cpp:3910

SceneData::GdtfGeometryStructure::~GdtfGeometryStructure
~GdtfGeometryStructure()
Definition GDTFManager.cpp:3846

SceneData::GdtfGeometryStructure::GetCrossSectionType
EGdtfCrossSectionType GetCrossSectionType() const
Definition GDTFManager.cpp:3860

SceneData::GdtfGeometryStructure::SetCrossSectionType
void SetCrossSectionType(const EGdtfCrossSectionType &crossSectionType)
Definition GDTFManager.cpp:3895

SceneData::GdtfGeometryStructure::SetLinkedGeometry
void SetLinkedGeometry(GdtfGeometry *linkedGeometry)
Definition GDTFManager.cpp:3885

SceneData::GdtfGeometryStructure::GetObjectType
virtual EGdtfObjectType GetObjectType()
Definition GDTFManager.cpp:3979

SceneData::GdtfGeometryStructure::OnReadFromNode
virtual void OnReadFromNode(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:3932

SceneData::GdtfGeometryStructure::GdtfGeometryStructure
GdtfGeometryStructure(GdtfGeometry *parent)
Definition GDTFManager.cpp:3832

SceneData::GdtfGeometrySupport
Definition GDTFManager.h:1238

SceneData::GdtfGeometrySupport::SetResistanceZZ
void SetResistanceZZ(double resistanceZZ)
Definition GDTFManager.cpp:4152

SceneData::GdtfGeometrySupport::SetResistanceXX
void SetResistanceXX(double resistanceXX)
Definition GDTFManager.cpp:4142

SceneData::GdtfGeometrySupport::SetResistanceYY
void SetResistanceYY(double resistanceYY)
Definition GDTFManager.cpp:4147

SceneData::GdtfGeometrySupport::SetResistanceZ
void SetResistanceZ(double resistanceZ)
Definition GDTFManager.cpp:4137

SceneData::GdtfGeometrySupport::GetResistanceY
double GetResistanceY() const
Definition GDTFManager.cpp:4057

SceneData::GdtfGeometrySupport::SetCapacityZ
void SetCapacityZ(double capacityZ)
Definition GDTFManager.cpp:4097

SceneData::GdtfGeometrySupport::GetNodeName
virtual TXString GetNodeName()
Definition GDTFManager.cpp:4262

SceneData::GdtfGeometrySupport::GetCapacityZ
double GetCapacityZ() const
Definition GDTFManager.cpp:4022

SceneData::GdtfGeometrySupport::SetCapacityYY
void SetCapacityYY(double capacityYY)
Definition GDTFManager.cpp:4107

SceneData::GdtfGeometrySupport::GdtfGeometrySupport
GdtfGeometrySupport(GdtfGeometry *parent)
Definition GDTFManager.cpp:3991

SceneData::GdtfGeometrySupport::GetResistanceZ
double GetResistanceZ() const
Definition GDTFManager.cpp:4062

SceneData::GdtfGeometrySupport::GetResistanceYY
double GetResistanceYY() const
Definition GDTFManager.cpp:4072

SceneData::GdtfGeometrySupport::SetResistanceX
void SetResistanceX(double resistanceX)
Definition GDTFManager.cpp:4127

SceneData::GdtfGeometrySupport::SetSupportType
void SetSupportType(const EGdtfSupportType &supportType)
Definition GDTFManager.cpp:4082

SceneData::GdtfGeometrySupport::GetResistanceZZ
double GetResistanceZZ() const
Definition GDTFManager.cpp:4077

SceneData::GdtfGeometrySupport::SetCapacityX
void SetCapacityX(double capacityX)
Definition GDTFManager.cpp:4087

SceneData::GdtfGeometrySupport::GetCapacityXX
double GetCapacityXX() const
Definition GDTFManager.cpp:4027

SceneData::GdtfGeometrySupport::OnErrorCheck
virtual void OnErrorCheck(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:4202

SceneData::GdtfGeometrySupport::GetResistanceX
double GetResistanceX() const
Definition GDTFManager.cpp:4052

SceneData::GdtfGeometrySupport::~GdtfGeometrySupport
~GdtfGeometrySupport()
Definition GDTFManager.cpp:4003

SceneData::GdtfGeometrySupport::GetSupportType
EGdtfSupportType GetSupportType() const
Definition GDTFManager.cpp:4007

SceneData::GdtfGeometrySupport::GetRopeOffset
VWPoint3D GetRopeOffset()
Definition GDTFManager.cpp:4047

SceneData::GdtfGeometrySupport::GetRopeCrossSection
const TXString & GetRopeCrossSection() const
Definition GDTFManager.cpp:4042

SceneData::GdtfGeometrySupport::GetCapacityY
double GetCapacityY() const
Definition GDTFManager.cpp:4017

SceneData::GdtfGeometrySupport::SetCapacityXX
void SetCapacityXX(double capacityXX)
Definition GDTFManager.cpp:4102

SceneData::GdtfGeometrySupport::GetCapacityX
double GetCapacityX() const
Definition GDTFManager.cpp:4012

SceneData::GdtfGeometrySupport::OnPrintToFile
virtual void OnPrintToFile(IXMLFileNodePtr pNode)
Definition GDTFManager.cpp:4157

SceneData::GdtfGeometrySupport::OnReadFromNode
virtual void OnReadFromNode(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:4180

SceneData::GdtfGeometrySupport::SetCapacityY
void SetCapacityY(double capacityY)
Definition GDTFManager.cpp:4092

SceneData::GdtfGeometrySupport::GetCapacityYY
double GetCapacityYY() const
Definition GDTFManager.cpp:4032

SceneData::GdtfGeometrySupport::GetObjectType
virtual EGdtfObjectType GetObjectType()
Definition GDTFManager.cpp:4257

SceneData::GdtfGeometrySupport::SetRopeOffset
void SetRopeOffset(double x, double y, double z)
Definition GDTFManager.cpp:4122

SceneData::GdtfGeometrySupport::SetCapacityZZ
void SetCapacityZZ(double capacityZZ)
Definition GDTFManager.cpp:4112

SceneData::GdtfGeometrySupport::SetRopeCrossSection
void SetRopeCrossSection(const TXString &ropeCrossSection)
Definition GDTFManager.cpp:4117

SceneData::GdtfGeometrySupport::SetResistanceY
void SetResistanceY(double resistanceY)
Definition GDTFManager.cpp:4132

SceneData::GdtfGeometrySupport::GetResistanceXX
double GetResistanceXX() const
Definition GDTFManager.cpp:4067

SceneData::GdtfGeometrySupport::GetCapacityZZ
double GetCapacityZZ() const
Definition GDTFManager.cpp:4037

SceneData::GdtfGeometryWiringObject
Definition GDTFManager.h:1090

SceneData::GdtfGeometryWiringObject::GetFuseRating
EGdtfFuseRating GetFuseRating() const
Definition GDTFManager.cpp:3508

SceneData::GdtfGeometryWiringObject::GetComponentType
EGdtfComponentType GetComponentType() const
Definition GDTFManager.cpp:3433

SceneData::GdtfGeometryWiringObject::SetFrequencyRangeMin
void SetFrequencyRangeMin(double frequencyRangeMin)
Definition GDTFManager.cpp:3568

SceneData::GdtfGeometryWiringObject::SetCosPhi
void SetCosPhi(double cosPhi)
Definition GDTFManager.cpp:3578

SceneData::GdtfGeometryWiringObject::GetNodeName
virtual TXString GetNodeName()
Definition GDTFManager.cpp:3751

SceneData::GdtfGeometryWiringObject::SetPinCount
void SetPinCount(size_t pinCount)
Definition GDTFManager.cpp:3533

SceneData::GdtfGeometryWiringObject::SetFrequencyRangeMax
void SetFrequencyRangeMax(double frequencyRangeMax)
Definition GDTFManager.cpp:3573

SceneData::GdtfGeometryWiringObject::SetElectricalPayLoad
void SetElectricalPayLoad(double electricalPayLoad)
Definition GDTFManager.cpp:3553

SceneData::GdtfGeometryWiringObject::GetFrequencyRangeMax
double GetFrequencyRangeMax() const
Definition GDTFManager.cpp:3483

SceneData::GdtfGeometryWiringObject::GetPinCount
size_t GetPinCount() const
Definition GDTFManager.cpp:3443

SceneData::GdtfGeometryWiringObject::SetWireGroup
void SetWireGroup(const TXString &wireGroup)
Definition GDTFManager.cpp:3548

SceneData::GdtfGeometryWiringObject::SetMaxPayLoad
void SetMaxPayLoad(double maxPayload)
Definition GDTFManager.cpp:3583

SceneData::GdtfGeometryWiringObject::GetElectricalPayLoad
double GetElectricalPayLoad() const
Definition GDTFManager.cpp:3463

SceneData::GdtfGeometryWiringObject::OnErrorCheck
virtual void OnErrorCheck(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:3678

SceneData::GdtfGeometryWiringObject::OnPrintToFile
virtual void OnPrintToFile(IXMLFileNodePtr pNode)
Definition GDTFManager.cpp:3610

SceneData::GdtfGeometryWiringObject::GetSignalType
const TXString & GetSignalType() const
Definition GDTFManager.cpp:3438

SceneData::GdtfGeometryWiringObject::GetFrequencyRangeMin
double GetFrequencyRangeMin() const
Definition GDTFManager.cpp:3478

SceneData::GdtfGeometryWiringObject::GetSignalLayer
size_t GetSignalLayer() const
Definition GDTFManager.cpp:3448

SceneData::GdtfGeometryWiringObject::OnReadFromNode
virtual void OnReadFromNode(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:3641

SceneData::GdtfGeometryWiringObject::GetObjectType
virtual EGdtfObjectType GetObjectType()
Definition GDTFManager.cpp:3746

SceneData::GdtfGeometryWiringObject::SetVoltageRangeMax
void SetVoltageRangeMax(double voltageRangeMax)
Definition GDTFManager.cpp:3563

SceneData::GdtfGeometryWiringObject::GetMaxPayLoad
double GetMaxPayLoad() const
Definition GDTFManager.cpp:3493

SceneData::GdtfGeometryWiringObject::SetVoltageRangeMin
void SetVoltageRangeMin(double voltageRangeMin)
Definition GDTFManager.cpp:3558

SceneData::GdtfGeometryWiringObject::GetFuseCurrent
double GetFuseCurrent() const
Definition GDTFManager.cpp:3503

SceneData::GdtfGeometryWiringObject::SetConnectorType
void SetConnectorType(const TXString &connectorType)
Definition GDTFManager.cpp:3518

SceneData::GdtfGeometryWiringObject::GetVoltageRangeMin
double GetVoltageRangeMin() const
Definition GDTFManager.cpp:3468

SceneData::GdtfGeometryWiringObject::GetCosPhi
double GetCosPhi() const
Definition GDTFManager.cpp:3488

SceneData::GdtfGeometryWiringObject::SetVoltage
void SetVoltage(double voltage)
Definition GDTFManager.cpp:3588

SceneData::GdtfGeometryWiringObject::GdtfGeometryWiringObject
GdtfGeometryWiringObject(GdtfGeometry *parent)
Definition GDTFManager.cpp:3385

SceneData::GdtfGeometryWiringObject::GetVoltage
double GetVoltage() const
Definition GDTFManager.cpp:3498

SceneData::GdtfGeometryWiringObject::SetComponentType
void SetComponentType(const EGdtfComponentType &componentType)
Definition GDTFManager.cpp:3523

SceneData::GdtfGeometryWiringObject::GetConnectorType
const TXString & GetConnectorType() const
Definition GDTFManager.cpp:3428

SceneData::GdtfGeometryWiringObject::SetFuseRating
void SetFuseRating(const EGdtfFuseRating &fuseRating)
Definition GDTFManager.cpp:3598

SceneData::GdtfGeometryWiringObject::CreatePinPatch
GdtfPinPatchPtr CreatePinPatch(GdtfGeometryWiringObject *toWiringObject, size_t fromPin, size_t toPin)
Definition GDTFManager.cpp:3603

SceneData::GdtfGeometryWiringObject::GetOrientation
EGdtfOrientation GetOrientation() const
Definition GDTFManager.cpp:3453

SceneData::GdtfGeometryWiringObject::GetVoltageRangeMax
double GetVoltageRangeMax() const
Definition GDTFManager.cpp:3473

SceneData::GdtfGeometryWiringObject::SetSignalLayer
void SetSignalLayer(size_t signalLayer)
Definition GDTFManager.cpp:3538

SceneData::GdtfGeometryWiringObject::SetFuseCurrent
void SetFuseCurrent(double fuseCurrent)
Definition GDTFManager.cpp:3593

SceneData::GdtfGeometryWiringObject::SetOrientation
void SetOrientation(const EGdtfOrientation &orientation)
Definition GDTFManager.cpp:3543

SceneData::GdtfGeometryWiringObject::SetSignalType
void SetSignalType(const TXString &signalType)
Definition GDTFManager.cpp:3528

SceneData::GdtfGeometryWiringObject::GetPinPatchArray
const TGdtfPinPatchArray & GetPinPatchArray() const
Definition GDTFManager.cpp:3513

SceneData::GdtfGeometryWiringObject::GetWireGroup
const TXString & GetWireGroup() const
Definition GDTFManager.cpp:3458

SceneData::GdtfGeometryWiringObject::~GdtfGeometryWiringObject
~GdtfGeometryWiringObject()
Definition GDTFManager.cpp:3423

SceneData::GdtfKiNET
Definition GDTFManager.h:2368

SceneData::GdtfKiNET::~GdtfKiNET
~GdtfKiNET()
Definition GDTFManager.cpp:11140

SceneData::GdtfKiNET::GdtfKiNET
GdtfKiNET()
Definition GDTFManager.cpp:11136

SceneData::GdtfKiNET::GetObjectType
virtual EGdtfObjectType GetObjectType()
Definition GDTFManager.cpp:11144

SceneData::GdtfKiNET::GetNodeName
virtual TXString GetNodeName()
Definition GDTFManager.cpp:11149

SceneData::GdtfLaserProtocol
Definition GDTFManager.h:967

SceneData::GdtfLaserProtocol::OnPrintToFile
virtual void OnPrintToFile(IXMLFileNodePtr pNode)
Definition GDTFManager.cpp:3004

SceneData::GdtfLaserProtocol::GetObjectType
virtual EGdtfObjectType GetObjectType()
Definition GDTFManager.cpp:3038

SceneData::GdtfLaserProtocol::GdtfLaserProtocol
GdtfLaserProtocol()
Definition GDTFManager.cpp:2980

SceneData::GdtfLaserProtocol::~GdtfLaserProtocol
~GdtfLaserProtocol()
Definition GDTFManager.cpp:2990

SceneData::GdtfLaserProtocol::OnErrorCheck
virtual void OnErrorCheck(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:3022

SceneData::GdtfLaserProtocol::GetName
const TXString & GetName() const
Definition GDTFManager.cpp:2994

SceneData::GdtfLaserProtocol::OnReadFromNode
virtual void OnReadFromNode(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:3013

SceneData::GdtfLaserProtocol::SetName
void SetName(const TXString &name)
Definition GDTFManager.cpp:2999

SceneData::GdtfLaserProtocol::GetNodeName
virtual TXString GetNodeName()
Definition GDTFManager.cpp:3043

SceneData::GdtfMacroDMX
Definition GDTFManager.h:1963

SceneData::GdtfMacroDMX::~GdtfMacroDMX
~GdtfMacroDMX()
Definition GDTFManager.cpp:11224

SceneData::GdtfMacroDMX::GetNodeName
virtual TXString GetNodeName()
Definition GDTFManager.cpp:11246

SceneData::GdtfMacroDMX::OnPrintToFile
virtual void OnPrintToFile(IXMLFileNodePtr pNode)
Definition GDTFManager.cpp:11251

SceneData::GdtfMacroDMX::OnReadFromNode
virtual void OnReadFromNode(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:11268

SceneData::GdtfMacroDMX::AddDmxStep
GdtfMacroDMXStepPtr AddDmxStep(double &duration)
Definition GDTFManager.cpp:11238

SceneData::GdtfMacroDMX::GetObjectType
virtual EGdtfObjectType GetObjectType()
Definition GDTFManager.cpp:11228

SceneData::GdtfMacroDMX::GetStepArray
virtual TGdtfMacroDMXStepArray GetStepArray()
Definition GDTFManager.cpp:11233

SceneData::GdtfMacroDMX::GdtfMacroDMX
GdtfMacroDMX()
Definition GDTFManager.cpp:11220

SceneData::GdtfMacroDMXStep
Definition GDTFManager.h:1933

SceneData::GdtfMacroDMXStep::OnReadFromNode
virtual void OnReadFromNode(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:11371

SceneData::GdtfMacroDMXStep::GetNodeName
virtual TXString GetNodeName()
Definition GDTFManager.cpp:11348

SceneData::GdtfMacroDMXStep::SetDuration
void SetDuration(double d)
Definition GDTFManager.cpp:11335

SceneData::GdtfMacroDMXStep::AddDmxValue
GdtfMacroDMXValuePtr AddDmxValue(DmxValue dmxVal, GdtfDmxChannelPtr dmxChannel)
Definition GDTFManager.cpp:11340

SceneData::GdtfMacroDMXStep::GetObjectType
virtual EGdtfObjectType GetObjectType()
Definition GDTFManager.cpp:11320

SceneData::GdtfMacroDMXStep::GdtfMacroDMXStep
GdtfMacroDMXStep()
Definition GDTFManager.cpp:11307

SceneData::GdtfMacroDMXStep::GetDMXValueArray
TGdtfMacroDMXValueArray GetDMXValueArray() const
Definition GDTFManager.cpp:11330

SceneData::GdtfMacroDMXStep::GetDuration
double GetDuration() const
Definition GDTFManager.cpp:11325

SceneData::GdtfMacroDMXStep::~GdtfMacroDMXStep
~GdtfMacroDMXStep()
Definition GDTFManager.cpp:11316

SceneData::GdtfMacroDMXStep::OnErrorCheck
virtual void OnErrorCheck(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:11394

SceneData::GdtfMacroDMXStep::OnPrintToFile
virtual void OnPrintToFile(IXMLFileNodePtr pNode)
Definition GDTFManager.cpp:11353

SceneData::GdtfMacroDMXValue
Definition GDTFManager.h:1901

SceneData::GdtfMacroDMXValue::OnErrorCheck
virtual void OnErrorCheck(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:11483

SceneData::GdtfMacroDMXValue::GetValue
DmxValue GetValue() const
Definition GDTFManager.cpp:11421

SceneData::GdtfMacroDMXValue::OnReadFromNode
virtual void OnReadFromNode(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:11471

SceneData::GdtfMacroDMXValue::GetNodeName
virtual TXString GetNodeName()
Definition GDTFManager.cpp:11446

SceneData::GdtfMacroDMXValue::~GdtfMacroDMXValue
~GdtfMacroDMXValue()
Definition GDTFManager.cpp:11302

SceneData::GdtfMacroDMXValue::GdtfMacroDMXValue
GdtfMacroDMXValue()
Definition GDTFManager.cpp:11290

SceneData::GdtfMacroDMXValue::GetDMXChannel
GdtfDmxChannelPtr GetDMXChannel() const
Definition GDTFManager.cpp:11431

SceneData::GdtfMacroDMXValue::SetValue
void SetValue(DmxValue val)
Definition GDTFManager.cpp:11436

SceneData::GdtfMacroDMXValue::GetUnresolvedDMXChannel
const TXString & GetUnresolvedDMXChannel() const
Definition GDTFManager.cpp:11426

SceneData::GdtfMacroDMXValue::GetObjectType
virtual EGdtfObjectType GetObjectType()
Definition GDTFManager.cpp:11411

SceneData::GdtfMacroDMXValue::SetDMXChannel
void SetDMXChannel(GdtfDmxChannelPtr chnl)
Definition GDTFManager.cpp:11441

SceneData::GdtfMacroDMXValue::OnPrintToFile
virtual void OnPrintToFile(IXMLFileNodePtr pNode)
Definition GDTFManager.cpp:11451

SceneData::GdtfMacroDMXValue::GetUnresolvedDMXValue
const TXString & GetUnresolvedDMXValue() const
Definition GDTFManager.cpp:11416

SceneData::GdtfMacro
Definition GDTFManager.h:1863

SceneData::GdtfMacro::SetChannelFunction
void SetChannelFunction(GdtfDmxChannelFunction *channelFunction)
Definition GDTFManager.cpp:7552

SceneData::GdtfMacro::SetMacroVisual
void SetMacroVisual(GdtfMacroVisual *val)
Definition GDTFManager.cpp:7563

SceneData::GdtfMacro::~GdtfMacro
~GdtfMacro()
Definition GDTFManager.cpp:7445

SceneData::GdtfMacro::OnPrintToFile
virtual void OnPrintToFile(IXMLFileNodePtr pNode)
Definition GDTFManager.cpp:7451

SceneData::GdtfMacro::GetUnresolvedChannelFunction
const TXString & GetUnresolvedChannelFunction() const
Definition GDTFManager.cpp:7537

SceneData::GdtfMacro::GetMacroVisual
GdtfMacroVisual * GetMacroVisual() const
Definition GDTFManager.cpp:7542

SceneData::GdtfMacro::GetChannelFunction
GdtfDmxChannelFunction * GetChannelFunction() const
Definition GDTFManager.cpp:7532

SceneData::GdtfMacro::SetName
void SetName(const TXString &name)
Definition GDTFManager.cpp:7547

SceneData::GdtfMacro::GetNodeName
virtual TXString GetNodeName()
Definition GDTFManager.cpp:7574

SceneData::GdtfMacro::OnReadFromNode
virtual void OnReadFromNode(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:7475

SceneData::GdtfMacro::GetName
const TXString & GetName() const
Definition GDTFManager.cpp:7522

SceneData::GdtfMacro::GdtfMacro
GdtfMacro()
Definition GDTFManager.cpp:7430

SceneData::GdtfMacro::GetObjectType
virtual EGdtfObjectType GetObjectType()
Definition GDTFManager.cpp:7569

SceneData::GdtfMacro::SetMacroDMX
void SetMacroDMX(GdtfMacroDMX *val)
Definition GDTFManager.cpp:7557

SceneData::GdtfMacro::OnErrorCheck
virtual void OnErrorCheck(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:7504

SceneData::GdtfMacro::GetMacroDMX
GdtfMacroDMX * GetMacroDMX() const
Definition GDTFManager.cpp:7527

SceneData::GdtfMacroVisual
Definition GDTFManager.h:2049

SceneData::GdtfMacroVisual::OnPrintToFile
virtual void OnPrintToFile(IXMLFileNodePtr pNode)
Definition GDTFManager.cpp:11533

SceneData::GdtfMacroVisual::GetObjectType
virtual EGdtfObjectType GetObjectType()
Definition GDTFManager.cpp:11510

SceneData::GdtfMacroVisual::GetNodeName
virtual TXString GetNodeName()
Definition GDTFManager.cpp:11528

SceneData::GdtfMacroVisual::GetVisualStepArray
TGdtfMacroVisualStepArray GetVisualStepArray()
Definition GDTFManager.cpp:11515

SceneData::GdtfMacroVisual::~GdtfMacroVisual
~GdtfMacroVisual()
Definition GDTFManager.cpp:11505

SceneData::GdtfMacroVisual::OnReadFromNode
virtual void OnReadFromNode(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:11550

SceneData::GdtfMacroVisual::GdtfMacroVisual
GdtfMacroVisual()
Definition GDTFManager.cpp:11501

SceneData::GdtfMacroVisual::AddVisualStep
GdtfMacroVisualStepPtr AddVisualStep()
Definition GDTFManager.cpp:11520

SceneData::GdtfMacroVisualStep
Definition GDTFManager.h:2014

SceneData::GdtfMacroVisualStep::GetVisualValueArray
TGdtfMacroVisualValueArray GetVisualValueArray()
Definition GDTFManager.cpp:11584

SceneData::GdtfMacroVisualStep::getFade
double getFade()
Definition GDTFManager.cpp:11599

SceneData::GdtfMacroVisualStep::GetObjectType
virtual EGdtfObjectType GetObjectType()
Definition GDTFManager.cpp:11589

SceneData::GdtfMacroVisualStep::setDuration
void setDuration(double d)
Definition GDTFManager.cpp:11609

SceneData::GdtfMacroVisualStep::getDuration
double getDuration()
Definition GDTFManager.cpp:11594

SceneData::GdtfMacroVisualStep::OnErrorCheck
virtual void OnErrorCheck(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:11686

SceneData::GdtfMacroVisualStep::AddVisualValue
GdtfMacroVisualValue * AddVisualValue(DmxValue &dmxVal, GdtfDmxChannelFunctionPtr channelFunctionRef)
Definition GDTFManager.cpp:11624

SceneData::GdtfMacroVisualStep::setDelay
void setDelay(double d)
Definition GDTFManager.cpp:11619

SceneData::GdtfMacroVisualStep::setFade
void setFade(double f)
Definition GDTFManager.cpp:11614

SceneData::GdtfMacroVisualStep::GdtfMacroVisualStep
GdtfMacroVisualStep()
Definition GDTFManager.cpp:11572

SceneData::GdtfMacroVisualStep::~GdtfMacroVisualStep
~GdtfMacroVisualStep()
Definition GDTFManager.cpp:11579

SceneData::GdtfMacroVisualStep::OnPrintToFile
virtual void OnPrintToFile(IXMLFileNodePtr pNode)
Definition GDTFManager.cpp:11638

SceneData::GdtfMacroVisualStep::OnReadFromNode
virtual void OnReadFromNode(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:11658

SceneData::GdtfMacroVisualStep::getDelay
double getDelay()
Definition GDTFManager.cpp:11604

SceneData::GdtfMacroVisualStep::GetNodeName
virtual TXString GetNodeName()
Definition GDTFManager.cpp:11633

SceneData::GdtfMacroVisualValue
Definition GDTFManager.h:1981

SceneData::GdtfMacroVisualValue::GetObjectType
virtual EGdtfObjectType GetObjectType()
Definition GDTFManager.cpp:11721

SceneData::GdtfMacroVisualValue::SetDmxValue
void SetDmxValue(DmxValue val)
Definition GDTFManager.cpp:11746

SceneData::GdtfMacroVisualValue::GetDmxValue
DmxValue GetDmxValue() const
Definition GDTFManager.cpp:11731

SceneData::GdtfMacroVisualValue::SetUnresolvedChannelFunctionRef
void SetUnresolvedChannelFunctionRef(const TXString &ref)
Definition GDTFManager.cpp:11751

SceneData::GdtfMacroVisualValue::GetUnresolvedChannelFunctionRef
const TXString & GetUnresolvedChannelFunctionRef() const
Definition GDTFManager.cpp:11736

SceneData::GdtfMacroVisualValue::GetChannelFunctionRef
GdtfDmxChannelFunctionPtr GetChannelFunctionRef() const
Definition GDTFManager.cpp:11741

SceneData::GdtfMacroVisualValue::OnPrintToFile
virtual void OnPrintToFile(IXMLFileNodePtr pNode)
Definition GDTFManager.cpp:11766

SceneData::GdtfMacroVisualValue::OnReadFromNode
virtual void OnReadFromNode(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:11782

SceneData::GdtfMacroVisualValue::GetUnresolvedDMXValue
const TXString & GetUnresolvedDMXValue() const
Definition GDTFManager.cpp:11726

SceneData::GdtfMacroVisualValue::GdtfMacroVisualValue
GdtfMacroVisualValue()
Definition GDTFManager.cpp:11705

SceneData::GdtfMacroVisualValue::GetNodeName
virtual TXString GetNodeName()
Definition GDTFManager.cpp:11761

SceneData::GdtfMacroVisualValue::OnErrorCheck
virtual void OnErrorCheck(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:11793

SceneData::GdtfMacroVisualValue::~GdtfMacroVisualValue
~GdtfMacroVisualValue()
Definition GDTFManager.cpp:11716

SceneData::GdtfMacroVisualValue::SetChannelFunction
void SetChannelFunction(GdtfDmxChannelFunctionPtr ref)
Definition GDTFManager.cpp:11756

SceneData::GdtfMap
Definition GDTFManager.h:2295

SceneData::GdtfMap::SetValue
void SetValue(Uint32 value)
Definition GDTFManager.cpp:10945

SceneData::GdtfMap::GetObjectType
virtual EGdtfObjectType GetObjectType()
Definition GDTFManager.cpp:10987

SceneData::GdtfMap::~GdtfMap
~GdtfMap()
Definition GDTFManager.cpp:10926

SceneData::GdtfMap::OnErrorCheck
virtual void OnErrorCheck(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:10970

SceneData::GdtfMap::OnPrintToFile
virtual void OnPrintToFile(IXMLFileNodePtr pNode)
Definition GDTFManager.cpp:10950

SceneData::GdtfMap::GetValue
Uint32 GetValue() const
Definition GDTFManager.cpp:10935

SceneData::GdtfMap::GdtfMap
GdtfMap()
Definition GDTFManager.cpp:10916

SceneData::GdtfMap::GetNodeName
virtual TXString GetNodeName()
Definition GDTFManager.cpp:10992

SceneData::GdtfMap::GetKey
Uint32 GetKey() const
Definition GDTFManager.cpp:10930

SceneData::GdtfMap::SetKey
void SetKey(Uint32 key)
Definition GDTFManager.cpp:10940

SceneData::GdtfMap::OnReadFromNode
virtual void OnReadFromNode(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:10960

SceneData::GdtfMeasurement
Definition GDTFManager.h:2510

SceneData::GdtfMeasurement::SetPhysical
void SetPhysical(double val)
Definition GDTFManager.cpp:12756

SceneData::GdtfMeasurement::GetMeasurementPointsArray
const TGdtfMeasurementPointArray & GetMeasurementPointsArray()
Definition GDTFManager.cpp:12751

SceneData::GdtfMeasurement::CreateMeasurementPoint
GdtfMeasurementPoint * CreateMeasurementPoint()
Definition GDTFManager.cpp:12776

SceneData::GdtfMeasurement::SetTransmission
void SetTransmission(double val)
Definition GDTFManager.cpp:12766

SceneData::GdtfMeasurement::GetNodeName
virtual TXString GetNodeName()
Definition GDTFManager.cpp:12783

SceneData::GdtfMeasurement::OnReadFromNode
virtual void OnReadFromNode(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:12811

SceneData::GdtfMeasurement::SetLuminousIntensity
void SetLuminousIntensity(double val)
Definition GDTFManager.cpp:12761

SceneData::GdtfMeasurement::GetLuminousIntensity
double GetLuminousIntensity()
Definition GDTFManager.cpp:12736

SceneData::GdtfMeasurement::GdtfMeasurement
GdtfMeasurement(bool forFilter)
Definition GDTFManager.cpp:12712

SceneData::GdtfMeasurement::~GdtfMeasurement
~GdtfMeasurement()
Definition GDTFManager.cpp:12721

SceneData::GdtfMeasurement::SetInterpolationTo
void SetInterpolationTo(EGdtfInterpolationTo val)
Definition GDTFManager.cpp:12771

SceneData::GdtfMeasurement::GetPhysical
double GetPhysical()
Definition GDTFManager.cpp:12731

SceneData::GdtfMeasurement::OnPrintToFile
virtual void OnPrintToFile(IXMLFileNodePtr pNode)
Definition GDTFManager.cpp:12788

SceneData::GdtfMeasurement::GetTransmission
double GetTransmission()
Definition GDTFManager.cpp:12741

SceneData::GdtfMeasurement::GetInterpolationTo
EGdtfInterpolationTo GetInterpolationTo()
Definition GDTFManager.cpp:12746

SceneData::GdtfMeasurement::GetObjectType
virtual EGdtfObjectType GetObjectType()
Definition GDTFManager.cpp:12726

SceneData::GdtfMeasurementPoint
Definition GDTFManager.h:2481

SceneData::GdtfMeasurementPoint::GetWavelength
double GetWavelength()
Definition GDTFManager.cpp:7653

SceneData::GdtfMeasurementPoint::OnPrintToFile
virtual void OnPrintToFile(IXMLFileNodePtr pNode)
Definition GDTFManager.cpp:7601

SceneData::GdtfMeasurementPoint::~GdtfMeasurementPoint
~GdtfMeasurementPoint()
Definition GDTFManager.cpp:7587

SceneData::GdtfMeasurementPoint::GetEnergy
double GetEnergy()
Definition GDTFManager.cpp:7658

SceneData::GdtfMeasurementPoint::OnErrorCheck
virtual void OnErrorCheck(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:7625

SceneData::GdtfMeasurementPoint::SetWavelength
void SetWavelength(double wavelength)
Definition GDTFManager.cpp:7591

SceneData::GdtfMeasurementPoint::GetObjectType
virtual EGdtfObjectType GetObjectType()
Definition GDTFManager.cpp:7643

SceneData::GdtfMeasurementPoint::OnReadFromNode
virtual void OnReadFromNode(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:7613

SceneData::GdtfMeasurementPoint::GdtfMeasurementPoint
GdtfMeasurementPoint()
Definition GDTFManager.cpp:7581

SceneData::GdtfMeasurementPoint::GetNodeName
virtual TXString GetNodeName()
Definition GDTFManager.cpp:7648

SceneData::GdtfMeasurementPoint::SetEnergy
void SetEnergy(double energy)
Definition GDTFManager.cpp:7596

SceneData::GdtfModel
Definition GDTFManager.h:651

SceneData::GdtfModel::GetGeometryFile_SVGFront_FullPath
const TXString & GetGeometryFile_SVGFront_FullPath()
Definition GDTFManager.cpp:1806

SceneData::GdtfModel::GetGeometryFile_GLTF_FullPath
const TXString & GetGeometryFile_GLTF_FullPath()
Definition GDTFManager.cpp:1830

SceneData::GdtfModel::SetSVGSideOffsetY
void SetSVGSideOffsetY(double svgSideOffsetY)
Definition GDTFManager.cpp:1534

SceneData::GdtfModel::GetGeometryFile_3DSHigh_FullPath
const TXString & GetGeometryFile_3DSHigh_FullPath()
Definition GDTFManager.cpp:1736

SceneData::GdtfModel::GetGeometryFile_SVG_FullPath
const TXString & GetGeometryFile_SVG_FullPath()
Definition GDTFManager.cpp:1758

SceneData::GdtfModel::OnErrorCheck
virtual void OnErrorCheck(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:1645

SceneData::GdtfModel::OnPrintToFile
virtual void OnPrintToFile(IXMLFileNodePtr pNode)
Definition GDTFManager.cpp:1549

SceneData::GdtfModel::GetGeometryFile_3DS_FullPath
const TXString & GetGeometryFile_3DS_FullPath()
Definition GDTFManager.cpp:1692

SceneData::GdtfModel::OnReadFromNode
virtual void OnReadFromNode(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:1572

SceneData::GdtfModel::GetWidth
double GetWidth() const
Definition GDTFManager.cpp:1939

SceneData::GdtfModel::SetSVGFrontOffsetY
void SetSVGFrontOffsetY(double svgFrontOffsetY)
Definition GDTFManager.cpp:1544

SceneData::GdtfModel::GetGeometryFile_SVGSide_FullPath
const TXString & GetGeometryFile_SVGSide_FullPath()
Definition GDTFManager.cpp:1782

SceneData::GdtfModel::GetHeight
double GetHeight() const
Definition GDTFManager.cpp:1944

SceneData::GdtfModel::SetSVGFrontOffsetX
void SetSVGFrontOffsetX(double svgFrontOffsetX)
Definition GDTFManager.cpp:1539

SceneData::GdtfModel::GetSVGFrontOffsetY
double GetSVGFrontOffsetY() const
Definition GDTFManager.cpp:2027

SceneData::GdtfModel::GetSVGFrontOffsetX
double GetSVGFrontOffsetX() const
Definition GDTFManager.cpp:2022

SceneData::GdtfModel::GetGeometryFileName
const TXString & GetGeometryFileName() const
Definition GDTFManager.cpp:1687

SceneData::GdtfModel::GetBufferSVG
void GetBufferSVG(void **bufferToCopy, size_t &length)
Definition GDTFManager.cpp:1970

SceneData::GdtfModel::SetBufferSVG
void SetBufferSVG(void *bufferToCopy, size_t length)
Definition GDTFManager.cpp:1493

SceneData::GdtfModel::GetSVGSideOffsetY
double GetSVGSideOffsetY() const
Definition GDTFManager.cpp:2017

SceneData::GdtfModel::~GdtfModel
~GdtfModel()
Definition GDTFManager.cpp:1443

SceneData::GdtfModel::SetBufferGLTF
void SetBufferGLTF(void *bufferToCopy, size_t length)
Definition GDTFManager.cpp:1506

SceneData::GdtfModel::SetBuffer3DS
void SetBuffer3DS(void *bufferToCopy, size_t length)
Definition GDTFManager.cpp:1480

SceneData::GdtfModel::GetBuffer3DS
void GetBuffer3DS(void **bufferToCopy, size_t &length)
Definition GDTFManager.cpp:1954

SceneData::GdtfModel::GetSVGSideOffsetX
double GetSVGSideOffsetX() const
Definition GDTFManager.cpp:2012

SceneData::GdtfModel::GetGeometryFile_3DSLow_FullPath
const TXString & GetGeometryFile_3DSLow_FullPath()
Definition GDTFManager.cpp:1714

SceneData::GdtfModel::GetBufferGLTF
void GetBufferGLTF(void **bufferToCopy, size_t &length)
Definition GDTFManager.cpp:1986

SceneData::GdtfModel::SetGeometryFile
void SetGeometryFile(const TXString &file)
Definition GDTFManager.cpp:1475

SceneData::GdtfModel::SetWidth
void SetWidth(const double &width)
Definition GDTFManager.cpp:1460

SceneData::GdtfModel::SetPrimitiveType
void SetPrimitiveType(const EGdtfModel_PrimitiveType &type)
Definition GDTFManager.cpp:1470

SceneData::GdtfModel::GetObjectType
virtual EGdtfObjectType GetObjectType()
Definition GDTFManager.cpp:1673

SceneData::GdtfModel::GetSVGOffsetX
double GetSVGOffsetX() const
Definition GDTFManager.cpp:2002

SceneData::GdtfModel::SetName
void SetName(const TXString &name)
Definition GDTFManager.cpp:1450

SceneData::GdtfModel::SetSVGSideOffsetX
void SetSVGSideOffsetX(double svgSideOffsetX)
Definition GDTFManager.cpp:1529

SceneData::GdtfModel::SetSVGOffsetX
void SetSVGOffsetX(double svgOffsetX)
Definition GDTFManager.cpp:1519

SceneData::GdtfModel::GetSVGOffsetY
double GetSVGOffsetY() const
Definition GDTFManager.cpp:2007

SceneData::GdtfModel::GetGeometryFile_GLTFHigh_FullPath
const TXString & GetGeometryFile_GLTFHigh_FullPath()
Definition GDTFManager.cpp:1896

SceneData::GdtfModel::SetHeight
void SetHeight(const double &height)
Definition GDTFManager.cpp:1465

SceneData::GdtfModel::GetNodeName
virtual TXString GetNodeName()
Definition GDTFManager.cpp:1677

SceneData::GdtfModel::GetLength
double GetLength() const
Definition GDTFManager.cpp:1934

SceneData::GdtfModel::GetName
const TXString & GetName() const
Definition GDTFManager.cpp:1929

SceneData::GdtfModel::SetSVGOffsetY
void SetSVGOffsetY(double svgOffsetY)
Definition GDTFManager.cpp:1524

SceneData::GdtfModel::GdtfModel
GdtfModel(GdtfFixture *fixture)
Definition GDTFManager.cpp:1395

SceneData::GdtfModel::GetPrimitiveType
EGdtfModel_PrimitiveType GetPrimitiveType() const
Definition GDTFManager.cpp:1949

SceneData::GdtfModel::GetGeometryFile_GLTFLow_FullPath
const TXString & GetGeometryFile_GLTFLow_FullPath()
Definition GDTFManager.cpp:1863

SceneData::GdtfModel::SetLength
void SetLength(const double &length)
Definition GDTFManager.cpp:1455

SceneData::GdtfModel::GetNodeReference
virtual TXString GetNodeReference()
Definition GDTFManager.cpp:1682

SceneData::GdtfObject::ReadFromNode
void ReadFromNode(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:43

SceneData::GdtfObject::GdtfObject
GdtfObject()
Definition GDTFManager.cpp:20

SceneData::GdtfObject::WriteToNode
void WriteToNode(IXMLFileNodePtr pContainerNode)
Definition GDTFManager.cpp:29

SceneData::GdtfObject::SetBind
void SetBind(void *ptr)
Definition GDTFManager.cpp:76

SceneData::GdtfObject::GetObjectType
virtual EGdtfObjectType GetObjectType()=0

SceneData::GdtfObject::CheckAbort
bool CheckAbort()
Definition GDTFManager.cpp:92

SceneData::GdtfObject::GetBind
void * GetBind()
Definition GDTFManager.cpp:81

SceneData::GdtfObject::GetNodeName
virtual TXString GetNodeName()=0

SceneData::GdtfObject::SetAbortCallback
static void SetAbortCallback(const std::function< void(bool &)> &cb)
Definition GDTFManager.cpp:86

SceneData::GdtfObject::GetNodeReference
virtual TXString GetNodeReference()
Definition GDTFManager.cpp:108

SceneData::GdtfObject::~GdtfObject
virtual ~GdtfObject()
Definition GDTFManager.cpp:25

SceneData::GdtfObject::OnErrorCheck
virtual void OnErrorCheck(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:71

SceneData::GdtfObject::OnReadFromNode
virtual void OnReadFromNode(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:66

SceneData::GdtfObject::GetNode
void GetNode(IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:56

SceneData::GdtfObject::OnPrintToFile
virtual void OnPrintToFile(IXMLFileNodePtr pNode)
Definition GDTFManager.cpp:61

SceneData::GdtfOpenSoundControl
Definition GDTFManager.h:2414

SceneData::GdtfOpenSoundControl::GetObjectType
virtual EGdtfObjectType GetObjectType()
Definition GDTFManager.cpp:11186

SceneData::GdtfOpenSoundControl::GetNodeName
virtual TXString GetNodeName()
Definition GDTFManager.cpp:11191

SceneData::GdtfOpenSoundControl::~GdtfOpenSoundControl
~GdtfOpenSoundControl()
Definition GDTFManager.cpp:11182

SceneData::GdtfOpenSoundControl::GdtfOpenSoundControl
GdtfOpenSoundControl()
Definition GDTFManager.cpp:11178

SceneData::GdtfPhysicalDescriptions
Definition GDTFManager.h:525

SceneData::GdtfPhysicalDescriptions::AddCRIGroup
GdtfCRIGroupPtr AddCRIGroup(double colorTsemp)
Definition GDTFManager.cpp:12143

SceneData::GdtfPhysicalDescriptions::GetOperatingTemperatureHigh
double GetOperatingTemperatureHigh()
Definition GDTFManager.cpp:12063

SceneData::GdtfPhysicalDescriptions::AddEmitter
GdtfPhysicalEmitterPtr AddEmitter(const TXString &name, CCieColor color)
Definition GDTFManager.cpp:12116

SceneData::GdtfPhysicalDescriptions::GetGamutArray
const TGdtfGamutArray & GetGamutArray()
Definition GDTFManager.cpp:12028

SceneData::GdtfPhysicalDescriptions::SetOperatingTemperatureLow
void SetOperatingTemperatureLow(double value)
Definition GDTFManager.cpp:12078

SceneData::GdtfPhysicalDescriptions::GetWeight
double GetWeight()
Definition GDTFManager.cpp:12068

SceneData::GdtfPhysicalDescriptions::GetOperatingTemperatureLow
double GetOperatingTemperatureLow()
Definition GDTFManager.cpp:12058

SceneData::GdtfPhysicalDescriptions::GdtfPhysicalDescriptions
GdtfPhysicalDescriptions()
Definition GDTFManager.cpp:11994

SceneData::GdtfPhysicalDescriptions::GetPhysicalEmitterArray
const TGdtfPhysicalEmitterArray & GetPhysicalEmitterArray()
Definition GDTFManager.cpp:12033

SceneData::GdtfPhysicalDescriptions::GetLegHeight
double GetLegHeight()
Definition GDTFManager.cpp:12073

SceneData::GdtfPhysicalDescriptions::AddDmxProfile
GdtfDMXProfilePtr AddDmxProfile()
Definition GDTFManager.cpp:12134

SceneData::GdtfPhysicalDescriptions::SetOperatingTemperatureHigh
void SetOperatingTemperatureHigh(double value)
Definition GDTFManager.cpp:12083

SceneData::GdtfPhysicalDescriptions::GetObjectType
virtual EGdtfObjectType GetObjectType()
Definition GDTFManager.cpp:12013

SceneData::GdtfPhysicalDescriptions::AddAdditionalColorSpace
GdtfColorSpacePtr AddAdditionalColorSpace(const TXString &name, EGdtfColorSpace colorSpace)
Definition GDTFManager.cpp:12098

SceneData::GdtfPhysicalDescriptions::OnPrintToFile
virtual void OnPrintToFile(IXMLFileNodePtr pNode)
Definition GDTFManager.cpp:12164

SceneData::GdtfPhysicalDescriptions::SetWeight
void SetWeight(double value)
Definition GDTFManager.cpp:12088

SceneData::GdtfPhysicalDescriptions::GetFilterArray
const TGdtfFilterArray & GetFilterArray()
Definition GDTFManager.cpp:12038

SceneData::GdtfPhysicalDescriptions::AddConnector
GdtfConnectorPtr AddConnector(const TXString &name, const TXString &type)
Definition GDTFManager.cpp:12151

SceneData::GdtfPhysicalDescriptions::GetNodeName
virtual TXString GetNodeName()
Definition GDTFManager.cpp:12159

SceneData::GdtfPhysicalDescriptions::~GdtfPhysicalDescriptions
~GdtfPhysicalDescriptions()
Definition GDTFManager.cpp:12002

SceneData::GdtfPhysicalDescriptions::GetColorSpace
GdtfColorSpace * GetColorSpace()
Definition GDTFManager.cpp:12018

SceneData::GdtfPhysicalDescriptions::GetDmxProfileArray
const TGdtfDMXProfileArray & GetDmxProfileArray()
Definition GDTFManager.cpp:12043

SceneData::GdtfPhysicalDescriptions::SetLegHeight
void SetLegHeight(double value)
Definition GDTFManager.cpp:12093

SceneData::GdtfPhysicalDescriptions::AddFilter
GdtfFilterPtr AddFilter(const TXString &name, CCieColor color)
Definition GDTFManager.cpp:12125

SceneData::GdtfPhysicalDescriptions::GetConnectorArray
const TGdtfConnectorArray & GetConnectorArray()
Definition GDTFManager.cpp:12053

SceneData::GdtfPhysicalDescriptions::AddGamut
GdtfGamutPtr AddGamut(const TXString &name, CCieColorPtr color)
Definition GDTFManager.cpp:12107

SceneData::GdtfPhysicalDescriptions::OnReadFromNode
virtual void OnReadFromNode(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:12274

SceneData::GdtfPhysicalDescriptions::GetAdditionalColorSpaceArray
const TGdtfColorSpaceArray & GetAdditionalColorSpaceArray()
Definition GDTFManager.cpp:12023

SceneData::GdtfPhysicalDescriptions::GetCRIGroupArray
const TGdtf_CRIGroupArray & GetCRIGroupArray()
Definition GDTFManager.cpp:12048

SceneData::GdtfPhysicalEmitter
Definition GDTFManager.h:2547

SceneData::GdtfPhysicalEmitter::~GdtfPhysicalEmitter
~GdtfPhysicalEmitter()
Definition GDTFManager.cpp:7242

SceneData::GdtfPhysicalEmitter::SetDiodePart
void SetDiodePart(const TXString &val)
Definition GDTFManager.cpp:7257

SceneData::GdtfPhysicalEmitter::GetDominantWaveLength
double GetDominantWaveLength()
Definition GDTFManager.cpp:7389

SceneData::GdtfPhysicalEmitter::GetName
const TXString & GetName() const
Definition GDTFManager.cpp:7364

SceneData::GdtfPhysicalEmitter::GetNodeReference
virtual TXString GetNodeReference()
Definition GDTFManager.cpp:7379

SceneData::GdtfPhysicalEmitter::OnErrorCheck
virtual void OnErrorCheck(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:7331

SceneData::GdtfPhysicalEmitter::OnReadFromNode
virtual void OnReadFromNode(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:7294

SceneData::GdtfPhysicalEmitter::GetNodeName
virtual TXString GetNodeName()
Definition GDTFManager.cpp:7359

SceneData::GdtfPhysicalEmitter::SetDominantWaveLength
void SetDominantWaveLength(double val)
Definition GDTFManager.cpp:7262

SceneData::GdtfPhysicalEmitter::OnPrintToFile
virtual void OnPrintToFile(IXMLFileNodePtr pNode)
Definition GDTFManager.cpp:7274

SceneData::GdtfPhysicalEmitter::SetColor
void SetColor(CCieColor color)
Definition GDTFManager.cpp:7252

SceneData::GdtfPhysicalEmitter::AddMeasurement
GdtfMeasurement * AddMeasurement()
Definition GDTFManager.cpp:7267

SceneData::GdtfPhysicalEmitter::GetDiodePart
const TXString & GetDiodePart()
Definition GDTFManager.cpp:7384

SceneData::GdtfPhysicalEmitter::GdtfPhysicalEmitter
GdtfPhysicalEmitter()
Definition GDTFManager.cpp:7227

SceneData::GdtfPhysicalEmitter::GetColor
CCieColor GetColor() const
Definition GDTFManager.cpp:7369

SceneData::GdtfPhysicalEmitter::GetObjectType
virtual EGdtfObjectType GetObjectType()
Definition GDTFManager.cpp:7354

SceneData::GdtfPhysicalEmitter::SetName
void SetName(const TXString &name)
Definition GDTFManager.cpp:7247

SceneData::GdtfPhysicalEmitter::GetMeasurements
const TGdtfMeasurementArray GetMeasurements()
Definition GDTFManager.cpp:7374

SceneData::GdtfPinPatch
Definition GDTFManager.h:1053

SceneData::GdtfPinPatch::SetToPin
void SetToPin(size_t toPin)
Definition GDTFManager.cpp:3328

SceneData::GdtfPinPatch::GdtfPinPatch
GdtfPinPatch()
Definition GDTFManager.cpp:3282

SceneData::GdtfPinPatch::~GdtfPinPatch
~GdtfPinPatch()
Definition GDTFManager.cpp:3294

SceneData::GdtfPinPatch::OnReadFromNode
virtual void OnReadFromNode(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:3344

SceneData::GdtfPinPatch::GetFromPin
size_t GetFromPin() const
Definition GDTFManager.cpp:3303

SceneData::GdtfPinPatch::GetToWiringObject
GdtfGeometryWiringObjectPtr GetToWiringObject() const
Definition GDTFManager.cpp:3298

SceneData::GdtfPinPatch::GetToPin
size_t GetToPin() const
Definition GDTFManager.cpp:3308

SceneData::GdtfPinPatch::GetNodeName
virtual TXString GetNodeName()
Definition GDTFManager.cpp:3378

SceneData::GdtfPinPatch::GetUnresolvedWiringObject
const TXString & GetUnresolvedWiringObject() const
Definition GDTFManager.cpp:3313

SceneData::GdtfPinPatch::SetFromPin
void SetFromPin(size_t fromPin)
Definition GDTFManager.cpp:3323

SceneData::GdtfPinPatch::OnPrintToFile
virtual void OnPrintToFile(IXMLFileNodePtr pNode)
Definition GDTFManager.cpp:3333

SceneData::GdtfPinPatch::SetToWiringObject
void SetToWiringObject(GdtfGeometryWiringObjectPtr toWiringObject)
Definition GDTFManager.cpp:3318

SceneData::GdtfPinPatch::GetObjectType
virtual EGdtfObjectType GetObjectType()
Definition GDTFManager.cpp:3373

SceneData::GdtfPinPatch::OnErrorCheck
virtual void OnErrorCheck(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:3355

SceneData::GdtfPoint
Definition GDTFManager.h:2642

SceneData::GdtfPoint::SetCFC2
void SetCFC2(double CFC2)
Definition GDTFManager.cpp:10128

SceneData::GdtfPoint::GetNodeName
virtual TXString GetNodeName()
Definition GDTFManager.cpp:10143

SceneData::GdtfPoint::SetCFC3
void SetCFC3(double CFC3)
Definition GDTFManager.cpp:10123

SceneData::GdtfPoint::GetCFC2
double GetCFC2() const
Definition GDTFManager.cpp:10102

SceneData::GdtfPoint::GetCFC1
double GetCFC1() const
Definition GDTFManager.cpp:10107

SceneData::GdtfPoint::OnErrorCheck
virtual void OnErrorCheck(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:10179

SceneData::GdtfPoint::SetDMXPercentage
void SetDMXPercentage(double dmxPercentage)
Definition GDTFManager.cpp:10118

SceneData::GdtfPoint::OnPrintToFile
virtual void OnPrintToFile(IXMLFileNodePtr pNode)
Definition GDTFManager.cpp:10148

SceneData::GdtfPoint::~GdtfPoint
~GdtfPoint()
Definition GDTFManager.cpp:10082

SceneData::GdtfPoint::OnReadFromNode
virtual void OnReadFromNode(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:10164

SceneData::GdtfPoint::GdtfPoint
GdtfPoint()
Definition GDTFManager.cpp:10064

SceneData::GdtfPoint::GetCFC0
double GetCFC0() const
Definition GDTFManager.cpp:10112

SceneData::GdtfPoint::GetDMXPercentage
double GetDMXPercentage() const
Definition GDTFManager.cpp:10092

SceneData::GdtfPoint::SetCFC1
void SetCFC1(double CFC1)
Definition GDTFManager.cpp:10133

SceneData::GdtfPoint::GetCFC3
double GetCFC3() const
Definition GDTFManager.cpp:10097

SceneData::GdtfPoint::SetCFC0
void SetCFC0(double CFC0)
Definition GDTFManager.cpp:10138

SceneData::GdtfPoint::GetObjectType
virtual EGdtfObjectType GetObjectType()
Definition GDTFManager.cpp:10086

SceneData::GdtfPosiStageNet
Definition GDTFManager.h:2391

SceneData::GdtfPosiStageNet::GetNodeName
virtual TXString GetNodeName()
Definition GDTFManager.cpp:11170

SceneData::GdtfPosiStageNet::GetObjectType
virtual EGdtfObjectType GetObjectType()
Definition GDTFManager.cpp:11165

SceneData::GdtfPosiStageNet::~GdtfPosiStageNet
~GdtfPosiStageNet()
Definition GDTFManager.cpp:11161

SceneData::GdtfPosiStageNet::GdtfPosiStageNet
GdtfPosiStageNet()
Definition GDTFManager.cpp:11157

SceneData::GdtfProtocols
Definition GDTFManager.h:2164

SceneData::GdtfProtocols::SetOpenSoundControl
void SetOpenSoundControl(GdtfOpenSoundControl *val)
Definition GDTFManager.cpp:10809

SceneData::GdtfProtocols::SetPosiStageNet
void SetPosiStageNet(GdtfPosiStageNet *val)
Definition GDTFManager.cpp:10804

SceneData::GdtfProtocols::CreateArtNet
GdtfArtNet * CreateArtNet()
Definition GDTFManager.cpp:10787

SceneData::GdtfProtocols::SetKiNET
void SetKiNET(GdtfKiNET *val)
Definition GDTFManager.cpp:10799

SceneData::GdtfProtocols::GetRDM
GdtfFTRDM * GetRDM()
Definition GDTFManager.cpp:10746

SceneData::GdtfProtocols::GetObjectType
virtual EGdtfObjectType GetObjectType()
Definition GDTFManager.cpp:10741

SceneData::GdtfProtocols::CreateRDM
GdtfFTRDM * CreateRDM()
Definition GDTFManager.cpp:10781

SceneData::GdtfProtocols::GdtfProtocols
GdtfProtocols()
Definition GDTFManager.cpp:10719

SceneData::GdtfProtocols::~GdtfProtocols
~GdtfProtocols()
Definition GDTFManager.cpp:10730

SceneData::GdtfProtocols::OnErrorCheck
virtual void OnErrorCheck(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:10898

SceneData::GdtfProtocols::GetNodeName
virtual TXString GetNodeName()
Definition GDTFManager.cpp:10819

SceneData::GdtfProtocols::GetSACN
GdtfsAcn * GetSACN()
Definition GDTFManager.cpp:10756

SceneData::GdtfProtocols::GetCITP
GdtfCITP * GetCITP()
Definition GDTFManager.cpp:10776

SceneData::GdtfProtocols::OnPrintToFile
virtual void OnPrintToFile(IXMLFileNodePtr pNode)
Definition GDTFManager.cpp:10824

SceneData::GdtfProtocols::CreateSACN
GdtfsAcn * CreateSACN()
Definition GDTFManager.cpp:10793

SceneData::GdtfProtocols::GetArtNet
GdtfArtNet * GetArtNet()
Definition GDTFManager.cpp:10751

SceneData::GdtfProtocols::GetOpenSoundControl
GdtfOpenSoundControl * GetOpenSoundControl()
Definition GDTFManager.cpp:10771

SceneData::GdtfProtocols::OnReadFromNode
virtual void OnReadFromNode(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:10840

SceneData::GdtfProtocols::GetPosiStageNet
GdtfPosiStageNet * GetPosiStageNet()
Definition GDTFManager.cpp:10766

SceneData::GdtfProtocols::GetKiNET
GdtfKiNET * GetKiNET()
Definition GDTFManager.cpp:10761

SceneData::GdtfProtocols::SetCITP
void SetCITP(GdtfCITP *val)
Definition GDTFManager.cpp:10814

SceneData::GdtfRevision
Definition GDTFManager.h:2126

SceneData::GdtfRevision::GetObjectType
virtual EGdtfObjectType GetObjectType()
Definition GDTFManager.cpp:7168

SceneData::GdtfRevision::OnPrintToFile
virtual void OnPrintToFile(IXMLFileNodePtr pNode)
Definition GDTFManager.cpp:7116

SceneData::GdtfRevision::SetText
void SetText(const TXString &text)
Definition GDTFManager.cpp:7178

SceneData::GdtfRevision::SetDate
void SetDate(const STime &date)
Definition GDTFManager.cpp:7183

SceneData::GdtfRevision::~GdtfRevision
~GdtfRevision()
Definition GDTFManager.cpp:7112

SceneData::GdtfRevision::OnReadFromNode
virtual void OnReadFromNode(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:7132

SceneData::GdtfRevision::GetModifiedBy
const TXString & GetModifiedBy() const
Definition GDTFManager.cpp:7218

SceneData::GdtfRevision::SetModifiedBy
void SetModifiedBy(const TXString &text)
Definition GDTFManager.cpp:7198

SceneData::GdtfRevision::GetUserId
size_t GetUserId() const
Definition GDTFManager.cpp:7213

SceneData::GdtfRevision::GdtfRevision
GdtfRevision()
Definition GDTFManager.cpp:7098

SceneData::GdtfRevision::GetDate
const STime & GetDate() const
Definition GDTFManager.cpp:7208

SceneData::GdtfRevision::GetText
const TXString & GetText() const
Definition GDTFManager.cpp:7203

SceneData::GdtfRevision::OnErrorCheck
virtual void OnErrorCheck(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:7148

SceneData::GdtfRevision::SetUserId
void SetUserId(size_t userId)
Definition GDTFManager.cpp:7193

SceneData::GdtfRevision::GetNodeName
virtual TXString GetNodeName()
Definition GDTFManager.cpp:7173

SceneData::GdtfSoftwareVersionID
Definition GDTFManager.h:2269

SceneData::GdtfSoftwareVersionID::GdtfSoftwareVersionID
GdtfSoftwareVersionID()
Definition GDTFManager.cpp:11811

SceneData::GdtfSoftwareVersionID::OnReadFromNode
virtual void OnReadFromNode(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:11877

SceneData::GdtfSoftwareVersionID::~GdtfSoftwareVersionID
~GdtfSoftwareVersionID()
Definition GDTFManager.cpp:11821

SceneData::GdtfSoftwareVersionID::GetNodeName
virtual TXString GetNodeName()
Definition GDTFManager.cpp:11854

SceneData::GdtfSoftwareVersionID::GetDMXPersonalityArray
const TGdtfDMXPersonalityArray & GetDMXPersonalityArray()
Definition GDTFManager.cpp:11836

SceneData::GdtfSoftwareVersionID::GetObjectType
virtual EGdtfObjectType GetObjectType()
Definition GDTFManager.cpp:11826

SceneData::GdtfSoftwareVersionID::SetValue
void SetValue(size_t val)
Definition GDTFManager.cpp:11841

SceneData::GdtfSoftwareVersionID::OnPrintToFile
virtual void OnPrintToFile(IXMLFileNodePtr pNode)
Definition GDTFManager.cpp:11859

SceneData::GdtfSoftwareVersionID::AddDMXPersonality
GdtfDMXPersonalityPtr AddDMXPersonality(size_t value, GdtfDmxModePtr dmxMode)
Definition GDTFManager.cpp:11846

SceneData::GdtfSoftwareVersionID::GetValue
size_t GetValue() const
Definition GDTFManager.cpp:11831

SceneData::GdtfSubPhysicalUnit
Definition GDTFManager.h:225

SceneData::GdtfSubPhysicalUnit::GetNodeReference
virtual TXString GetNodeReference()
Definition GDTFManager.cpp:547

SceneData::GdtfSubPhysicalUnit::GetNodeName
virtual TXString GetNodeName()
Definition GDTFManager.cpp:552

SceneData::GdtfSubPhysicalUnit::GetType
EGdtfSubPhysicalUnitType GetType() const
Definition GDTFManager.cpp:458

SceneData::GdtfSubPhysicalUnit::~GdtfSubPhysicalUnit
~GdtfSubPhysicalUnit()
Definition GDTFManager.cpp:454

SceneData::GdtfSubPhysicalUnit::GdtfSubPhysicalUnit
GdtfSubPhysicalUnit()
Definition GDTFManager.cpp:438

SceneData::GdtfSubPhysicalUnit::OnPrintToFile
virtual void OnPrintToFile(IXMLFileNodePtr pNode)
Definition GDTFManager.cpp:499

SceneData::GdtfSubPhysicalUnit::SetType
void SetType(const EGdtfSubPhysicalUnitType &type)
Definition GDTFManager.cpp:478

SceneData::GdtfSubPhysicalUnit::SetPhysicalTo
void SetPhysicalTo(double physicalTo)
Definition GDTFManager.cpp:494

SceneData::GdtfSubPhysicalUnit::OnErrorCheck
virtual void OnErrorCheck(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:523

SceneData::GdtfSubPhysicalUnit::OnReadFromNode
virtual void OnReadFromNode(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:511

SceneData::GdtfSubPhysicalUnit::GetPhysicalTo
double GetPhysicalTo() const
Definition GDTFManager.cpp:473

SceneData::GdtfSubPhysicalUnit::GetObjectType
virtual EGdtfObjectType GetObjectType()
Definition GDTFManager.cpp:542

SceneData::GdtfSubPhysicalUnit::SetPhysicalFrom
void SetPhysicalFrom(double physicalFrom)
Definition GDTFManager.cpp:489

SceneData::GdtfSubPhysicalUnit::SetPhysicalUnit
void SetPhysicalUnit(const EGdtfPhysicalUnit &physicalUnit)
Definition GDTFManager.cpp:484

SceneData::GdtfSubPhysicalUnit::GetPhysicalUnit
EGdtfPhysicalUnit GetPhysicalUnit() const
Definition GDTFManager.cpp:463

SceneData::GdtfSubPhysicalUnit::GetPhysicalFrom
double GetPhysicalFrom() const
Definition GDTFManager.cpp:468

SceneData::GdtfUserPreset
Definition GDTFManager.h:2462

SceneData::GdtfUserPreset::GdtfUserPreset
GdtfUserPreset()
Definition GDTFManager.cpp:7396

SceneData::GdtfUserPreset::~GdtfUserPreset
~GdtfUserPreset()
Definition GDTFManager.cpp:7400

SceneData::GdtfUserPreset::OnReadFromNode
virtual void OnReadFromNode(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:7411

SceneData::GdtfUserPreset::OnPrintToFile
virtual void OnPrintToFile(IXMLFileNodePtr pNode)
Definition GDTFManager.cpp:7404

SceneData::GdtfUserPreset::GetObjectType
virtual EGdtfObjectType GetObjectType()
Definition GDTFManager.cpp:7418

SceneData::GdtfUserPreset::GetNodeName
virtual TXString GetNodeName()
Definition GDTFManager.cpp:7423

SceneData::GdtfWheel
Definition GDTFManager.h:612

SceneData::GdtfWheel::AddWheelSlot
GdtfWheelSlotPtr AddWheelSlot(const TXString &name)
Definition GDTFManager.cpp:816

SceneData::GdtfWheel::OnErrorCheck
virtual void OnErrorCheck(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:904

SceneData::GdtfWheel::GetParentFixture
GdtfFixture * GetParentFixture() const
Definition GDTFManager.cpp:846

SceneData::GdtfWheel::OnPrintToFile
virtual void OnPrintToFile(IXMLFileNodePtr pNode)
Definition GDTFManager.cpp:856

SceneData::GdtfWheel::GdtfWheel
GdtfWheel(GdtfFixture *parentFixture)
Definition GDTFManager.cpp:800

SceneData::GdtfWheel::GetName
const TXString & GetName() const
Definition GDTFManager.cpp:931

SceneData::GdtfWheel::~GdtfWheel
~GdtfWheel()
Definition GDTFManager.cpp:811

SceneData::GdtfWheel::GetObjectType
virtual EGdtfObjectType GetObjectType()
Definition GDTFManager.cpp:921

SceneData::GdtfWheel::OnReadFromNode
virtual void OnReadFromNode(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:874

SceneData::GdtfWheel::GetWheelSlotArray
const TGdtfWheelSlotArray & GetWheelSlotArray() const
Definition GDTFManager.cpp:851

SceneData::GdtfWheel::SetName
void SetName(const TXString &name)
Definition GDTFManager.cpp:826

SceneData::GdtfWheel::IsGoboWheel
bool IsGoboWheel() const
Definition GDTFManager.cpp:831

SceneData::GdtfWheel::GetNodeReference
virtual TXString GetNodeReference()
Definition GDTFManager.cpp:841

SceneData::GdtfWheel::GetNodeName
virtual TXString GetNodeName()
Definition GDTFManager.cpp:926

SceneData::GdtfWheelSlotAnimationSystem
Definition GDTFManager.h:361

SceneData::GdtfWheelSlotAnimationSystem::SetP3_Y
void SetP3_Y(double p3_Y)
Definition GDTFManager.cpp:1085

SceneData::GdtfWheelSlotAnimationSystem::OnErrorCheck
virtual void OnErrorCheck(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:1119

SceneData::GdtfWheelSlotAnimationSystem::SetP3_X
void SetP3_X(double p3_X)
Definition GDTFManager.cpp:1080

SceneData::GdtfWheelSlotAnimationSystem::SetRadius
void SetRadius(double radius)
Definition GDTFManager.cpp:1090

SceneData::GdtfWheelSlotAnimationSystem::GetP2_X
double GetP2_X()
Definition GDTFManager.cpp:1035

SceneData::GdtfWheelSlotAnimationSystem::GetP3_X
double GetP3_X()
Definition GDTFManager.cpp:1045

SceneData::GdtfWheelSlotAnimationSystem::~GdtfWheelSlotAnimationSystem
~GdtfWheelSlotAnimationSystem()
Definition GDTFManager.cpp:1021

SceneData::GdtfWheelSlotAnimationSystem::SetP1_Y
void SetP1_Y(double p1_Y)
Definition GDTFManager.cpp:1065

SceneData::GdtfWheelSlotAnimationSystem::SetP2_X
void SetP2_X(double p2_X)
Definition GDTFManager.cpp:1070

SceneData::GdtfWheelSlotAnimationSystem::GetObjectType
virtual EGdtfObjectType GetObjectType()
Definition GDTFManager.cpp:1139

SceneData::GdtfWheelSlotAnimationSystem::GetP3_Y
double GetP3_Y()
Definition GDTFManager.cpp:1050

SceneData::GdtfWheelSlotAnimationSystem::SetP1_X
void SetP1_X(double p1_X)
Definition GDTFManager.cpp:1060

SceneData::GdtfWheelSlotAnimationSystem::GdtfWheelSlotAnimationSystem
GdtfWheelSlotAnimationSystem()
Definition GDTFManager.cpp:1017

SceneData::GdtfWheelSlotAnimationSystem::OnPrintToFile
virtual void OnPrintToFile(IXMLFileNodePtr pNode)
Definition GDTFManager.cpp:1095

SceneData::GdtfWheelSlotAnimationSystem::GetP1_X
double GetP1_X()
Definition GDTFManager.cpp:1025

SceneData::GdtfWheelSlotAnimationSystem::GetRadius
double GetRadius()
Definition GDTFManager.cpp:1055

SceneData::GdtfWheelSlotAnimationSystem::GetP2_Y
double GetP2_Y()
Definition GDTFManager.cpp:1040

SceneData::GdtfWheelSlotAnimationSystem::OnReadFromNode
virtual void OnReadFromNode(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:1107

SceneData::GdtfWheelSlotAnimationSystem::GetNodeName
virtual TXString GetNodeName()
Definition GDTFManager.cpp:1144

SceneData::GdtfWheelSlotAnimationSystem::GetP1_Y
double GetP1_Y()
Definition GDTFManager.cpp:1030

SceneData::GdtfWheelSlotAnimationSystem::SetP2_Y
void SetP2_Y(double p2_Y)
Definition GDTFManager.cpp:1075

SceneData::GdtfWheelSlot
Definition GDTFManager.h:402

SceneData::GdtfWheelSlot::GdtfWheelSlot
GdtfWheelSlot(GdtfWheel *parent)
Definition GDTFManager.cpp:1151

SceneData::GdtfWheelSlot::GetColor
CCieColor GetColor() const
Definition GDTFManager.cpp:1250

SceneData::GdtfWheelSlot::GetUnresolvedFilter
const TXString & GetUnresolvedFilter() const
Definition GDTFManager.cpp:1222

SceneData::GdtfWheelSlot::GetAnimationSystem
GdtfWheelSlotAnimationSystem * GetAnimationSystem() const
Definition GDTFManager.cpp:1388

SceneData::GdtfWheelSlot::OnErrorCheck
virtual void OnErrorCheck(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:1347

SceneData::GdtfWheelSlot::OnPrintToFile
virtual void OnPrintToFile(IXMLFileNodePtr pNode)
Definition GDTFManager.cpp:1260

SceneData::GdtfWheelSlot::~GdtfWheelSlot
~GdtfWheelSlot()
Definition GDTFManager.cpp:1167

SceneData::GdtfWheelSlot::SetColor
void SetColor(const CCieColor &color)
Definition GDTFManager.cpp:1185

SceneData::GdtfWheelSlot::GetNodeName
virtual TXString GetNodeName()
Definition GDTFManager.cpp:1372

SceneData::GdtfWheelSlot::AddAnimationSystem
GdtfWheelSlotAnimationSystem * AddAnimationSystem()
Definition GDTFManager.cpp:1202

SceneData::GdtfWheelSlot::GetNodeReference
virtual TXString GetNodeReference()
Definition GDTFManager.cpp:1382

SceneData::GdtfWheelSlot::GetPrismFacets
TGdtfWheelSlotPrismFacetArray GetPrismFacets()
Definition GDTFManager.cpp:1377

SceneData::GdtfWheelSlot::AddPrismFacet
GdtfWheelSlotPrismFacet * AddPrismFacet()
Definition GDTFManager.cpp:1195

SceneData::GdtfWheelSlot::GetGoboFileFullPath
const TXString & GetGoboFileFullPath()
Definition GDTFManager.cpp:1227

SceneData::GdtfWheelSlot::GetGobo
const TXString & GetGobo() const
Definition GDTFManager.cpp:1212

SceneData::GdtfWheelSlot::OnReadFromNode
virtual void OnReadFromNode(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:1286

SceneData::GdtfWheelSlot::SetGobo
void SetGobo(const GdtfPNGFile &png)
Definition GDTFManager.cpp:1180

SceneData::GdtfWheelSlot::GetFilter
GdtfFilter * GetFilter() const
Definition GDTFManager.cpp:1217

SceneData::GdtfWheelSlot::SetFilter
void SetFilter(GdtfFilter *filter)
Definition GDTFManager.cpp:1190

SceneData::GdtfWheelSlot::GetName
const TXString & GetName() const
Definition GDTFManager.cpp:1255

SceneData::GdtfWheelSlot::SetName
void SetName(const TXString &name)
Definition GDTFManager.cpp:1175

SceneData::GdtfWheelSlot::GetObjectType
virtual EGdtfObjectType GetObjectType()
Definition GDTFManager.cpp:1368

SceneData::GdtfWheelSlotPrismFacet
Definition GDTFManager.h:333

SceneData::GdtfWheelSlotPrismFacet::OnReadFromNode
virtual void OnReadFromNode(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:977

SceneData::GdtfWheelSlotPrismFacet::OnPrintToFile
virtual void OnPrintToFile(IXMLFileNodePtr pNode)
Definition GDTFManager.cpp:957

SceneData::GdtfWheelSlotPrismFacet::GdtfWheelSlotPrismFacet
GdtfWheelSlotPrismFacet()
Definition GDTFManager.cpp:938

SceneData::GdtfWheelSlotPrismFacet::OnErrorCheck
virtual void OnErrorCheck(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:988

SceneData::GdtfWheelSlotPrismFacet::~GdtfWheelSlotPrismFacet
~GdtfWheelSlotPrismFacet()
Definition GDTFManager.cpp:943

SceneData::GdtfWheelSlotPrismFacet::GetTransformMatrix
VWTransformMatrix GetTransformMatrix()
Definition GDTFManager.cpp:972

SceneData::GdtfWheelSlotPrismFacet::SetTransformMatrix
void SetTransformMatrix(const VWTransformMatrix &ma)
Definition GDTFManager.cpp:952

SceneData::GdtfWheelSlotPrismFacet::GetColor
CCieColor GetColor()
Definition GDTFManager.cpp:967

SceneData::GdtfWheelSlotPrismFacet::GetNodeName
virtual TXString GetNodeName()
Definition GDTFManager.cpp:1010

SceneData::GdtfWheelSlotPrismFacet::GetObjectType
virtual EGdtfObjectType GetObjectType()
Definition GDTFManager.cpp:1006

SceneData::GdtfWheelSlotPrismFacet::SetColor
void SetColor(const CCieColor &color)
Definition GDTFManager.cpp:947

SceneData::GdtfsAcn
Definition GDTFManager.h:2345

SceneData::GdtfsAcn::GetNodeName
virtual TXString GetNodeName()
Definition GDTFManager.cpp:11128

SceneData::GdtfsAcn::CreateMap
GdtfMapPtr CreateMap(Uint32 key, Uint32 value)
Definition GDTFManager.cpp:11082

SceneData::GdtfsAcn::GetObjectType
virtual EGdtfObjectType GetObjectType()
Definition GDTFManager.cpp:11123

SceneData::GdtfsAcn::OnReadFromNode
virtual void OnReadFromNode(const IXMLFileNodePtr &pNode)
Definition GDTFManager.cpp:11101

SceneData::GdtfsAcn::~GdtfsAcn
~GdtfsAcn()
Definition GDTFManager.cpp:11072

SceneData::GdtfsAcn::GetMapArray
const TGdtfMapArray & GetMapArray()
Definition GDTFManager.cpp:11077

SceneData::GdtfsAcn::GdtfsAcn
GdtfsAcn()
Definition GDTFManager.cpp:11068

SceneData::GdtfsAcn::OnPrintToFile
virtual void OnPrintToFile(IXMLFileNodePtr pNode)
Definition GDTFManager.cpp:11089

VectorworksMVR::CCieColor
Definition CieColor.h:11

VectorworksMVR::GdtfParsingError
Definition GdtfError.h:16

VectorworksMVR::TXString
Definition GSString.h:132

VectorworksMVR::VWFC::Math::VWPoint3D
Definition VWPoint3D.h:19

VectorworksMVR::VWFC::Math::VWTransformMatrix
Definition VWTransformMatrix.h:16

VectorworksMVR::VWFC::Tools::VWUUID
Definition UUID.h:18

SceneData
Definition GDTFManager.h:19

SceneData::GdtfBreakPtr
GdtfBreak * GdtfBreakPtr
Definition GDTFManager.h:1410

SceneData::GdtfGeometryReferencePtr
GdtfGeometryReference * GdtfGeometryReferencePtr
Definition GDTFManager.h:1442

SceneData::GdtfDMXPersonalityPtr
GdtfDMXPersonality * GdtfDMXPersonalityPtr
Definition GDTFManager.h:2264

SceneData::TGdtfWheelSlotArray
std::vector< GdtfWheelSlotPtr > TGdtfWheelSlotArray
Definition GDTFManager.h:451

SceneData::TGdtfUserPresetArray
std::vector< GdtfUserPresetPtr > TGdtfUserPresetArray
Definition GDTFManager.h:2477

SceneData::TGdtfMapArray
std::vector< GdtfMapPtr > TGdtfMapArray
Definition GDTFManager.h:2320

SceneData::TGdtfModelArray
std::vector< GdtfModelPtr > TGdtfModelArray
Definition GDTFManager.h:745

SceneData::GdtfMacroVisualValuePtr
GdtfMacroVisualValue * GdtfMacroVisualValuePtr
Definition GDTFManager.h:2010

SceneData::GdtfMeasurementPointPtr
GdtfMeasurementPoint * GdtfMeasurementPointPtr
Definition GDTFManager.h:2505

SceneData::kDmxBreakOverwriteValue
const Sint32 kDmxBreakOverwriteValue
Definition GDTFManager.h:69

SceneData::GdtfDmxModePtr
GdtfDmxMode * GdtfDmxModePtr
Definition GDTFManager.h:2120

SceneData::TGdtfMacroVisualValueArray
std::vector< GdtfMacroVisualValue * > TGdtfMacroVisualValueArray
Definition GDTFManager.h:2011

SceneData::GdtfGeometryWiringObjectPtr
GdtfGeometryWiringObject * GdtfGeometryWiringObjectPtr
Definition GDTFManager.h:66

SceneData::GdtfUserPresetPtr
GdtfUserPreset * GdtfUserPresetPtr
Definition GDTFManager.h:2476

SceneData::GdtfWheelPtr
GdtfWheel * GdtfWheelPtr
Definition GDTFManager.h:643

SceneData::TGdtfBreakArray
std::vector< GdtfBreak * > TGdtfBreakArray
Definition GDTFManager.h:1411

SceneData::TGdtfFeatureGroupArray
std::vector< GdtfFeatureGroupPtr > TGdtfFeatureGroupArray
Definition GDTFManager.h:222

SceneData::GdtfDmxChannelFunctionPtr
GdtfDmxChannelFunction * GdtfDmxChannelFunctionPtr
Definition GDTFManager.h:1687

SceneData::GdtfPinPatchPtr
GdtfPinPatch * GdtfPinPatchPtr
Definition GDTFManager.h:1086

SceneData::GdtfGeometryLaserPtr
GdtfGeometryLaser * GdtfGeometryLaserPtr
Definition GDTFManager.h:1050

SceneData::TGdtfMeasurementPointArray
std::vector< GdtfMeasurementPoint * > TGdtfMeasurementPointArray
Definition GDTFManager.h:2506

SceneData::GdtfWheelSlotPrismFacetPtr
GdtfWheelSlotPrismFacet * GdtfWheelSlotPrismFacetPtr
Definition GDTFManager.h:357

SceneData::TGdtfPhysicalEmitterArray
std::vector< GdtfPhysicalEmitter * > TGdtfPhysicalEmitterArray
Definition GDTFManager.h:23

SceneData::GdtfFeaturePtr
GdtfFeature * GdtfFeaturePtr
Definition GDTFManager.h:186

SceneData::TGdtfSubPhysicalUnitArray
std::vector< GdtfSubPhysicalUnit * > TGdtfSubPhysicalUnitArray
Definition GDTFManager.h:262

SceneData::GdtfArtNetPtr
GdtfArtNet * GdtfArtNetPtr
Definition GDTFManager.h:2342

SceneData::GdtfDmxLogicalChannelPtr
GdtfDmxLogicalChannel * GdtfDmxLogicalChannelPtr
Definition GDTFManager.h:1740

SceneData::GdtfDmxRelationPtr
GdtfDmxRelation * GdtfDmxRelationPtr
Definition GDTFManager.h:1856

SceneData::GdtfConnectorPtr
GdtfConnector * GdtfConnectorPtr
Definition GDTFManager.h:62

SceneData::GdtfProtocolsPtr
GdtfProtocols * GdtfProtocolsPtr
Definition GDTFManager.h:2204

SceneData::GdtfGeometryLampePtr
GdtfGeometryLamp * GdtfGeometryLampePtr
Definition GDTFManager.h:1385

SceneData::TGdtfMacroDMXValueArray
std::vector< GdtfMacroDMXValue * > TGdtfMacroDMXValueArray
Definition GDTFManager.h:1930

SceneData::GdtfKiNETPtr
GdtfKiNET * GdtfKiNETPtr
Definition GDTFManager.h:2388

SceneData::GdtfGamutPtr
GdtfGamut * GdtfGamutPtr
Definition GDTFManager.h:521

SceneData::GdtfGeometryMagnetPtr
GdtfGeometryMagnet * GdtfGeometryMagnetPtr
Definition GDTFManager.h:1322

SceneData::GdtfPhysicalDescriptionsPtr
GdtfPhysicalDescriptions * GdtfPhysicalDescriptionsPtr
Definition GDTFManager.h:582

SceneData::GdtfDmxChannelPtr
GdtfDmxChannel * GdtfDmxChannelPtr
Definition GDTFManager.h:1812

SceneData::GdtfMeasurementPtr
GdtfMeasurement * GdtfMeasurementPtr
Definition GDTFManager.h:2542

SceneData::GdtfGeometrySupportPtr
GdtfGeometrySupport * GdtfGeometrySupportPtr
Definition GDTFManager.h:1305

SceneData::TGdtfFilterArray
std::vector< GdtfFilter * > TGdtfFilterArray
Definition GDTFManager.h:59

SceneData::GdtfDmxChannelSetPtr
GdtfDmxChannelSet * GdtfDmxChannelSetPtr
Definition GDTFManager.h:1498

SceneData::TGdtfMacroVisualStepArray
std::vector< GdtfMacroVisualStep * > TGdtfMacroVisualStepArray
Definition GDTFManager.h:2046

SceneData::TGdtfAttributeArray
std::vector< GdtfAttribute * > TGdtfAttributeArray
Definition GDTFManager.h:327

SceneData::GdtfCRIGroupPtr
GdtfCRIGroup * GdtfCRIGroupPtr
Definition GDTFManager.h:51

SceneData::TGdtfRevisionArray
std::vector< GdtfRevision * > TGdtfRevisionArray
Definition GDTFManager.h:2158

SceneData::TGdtfDMXProfileArray
std::vector< GdtfDMXProfile * > TGdtfDMXProfileArray
Definition GDTFManager.h:48

SceneData::GdtfWheelSlotPtr
GdtfWheelSlot * GdtfWheelSlotPtr
Definition GDTFManager.h:450

SceneData::TGdtfDmxModeArray
std::vector< GdtfDmxMode * > TGdtfDmxModeArray
Definition GDTFManager.h:2121

SceneData::TGdtfDmxChannelArray
std::vector< GdtfDmxChannelPtr > TGdtfDmxChannelArray
Definition GDTFManager.h:1813

SceneData::GdtfRevisionPtr
GdtfRevision * GdtfRevisionPtr
Definition GDTFManager.h:2157

SceneData::TGdtfDmxRelationArray
std::vector< GdtfDmxRelation * > TGdtfDmxRelationArray
Definition GDTFManager.h:1857

SceneData::TGdtfColorSpaceArray
std::vector< GdtfColorSpace * > TGdtfColorSpaceArray
Definition GDTFManager.h:494

SceneData::TGdtfDmxSubChannelSetArray
std::vector< GdtfDmxSubChannelSet * > TGdtfDmxSubChannelSetArray
Definition GDTFManager.h:1546

SceneData::GdtfMacroPtr
GdtfMacro * GdtfMacroPtr
Definition GDTFManager.h:1897

SceneData::GdtfsAcnPtr
GdtfsAcn * GdtfsAcnPtr
Definition GDTFManager.h:2365

SceneData::TGdtfActivationGroupArray
std::vector< GdtfActivationGroupPtr > TGdtfActivationGroupArray
Definition GDTFManager.h:150

SceneData::GdtfPosiStageNetPtr
GdtfPosiStageNet * GdtfPosiStageNetPtr
Definition GDTFManager.h:2411

SceneData::GdtfGeometryPtr
GdtfGeometry * GdtfGeometryPtr
Definition GDTFManager.h:819

SceneData::GdtfColorSpacePtr
GdtfColorSpace * GdtfColorSpacePtr
Definition GDTFManager.h:493

SceneData::GdtfFTRDMPtr
GdtfFTRDM * GdtfFTRDMPtr
Definition GDTFManager.h:2236

SceneData::GdtfPhysicalEmitterPtr
GdtfPhysicalEmitter * GdtfPhysicalEmitterPtr
Definition GDTFManager.h:22

SceneData::TGdtfDmxLogicalChannelArray
std::vector< GdtfDmxLogicalChannel * > TGdtfDmxLogicalChannelArray
Definition GDTFManager.h:1741

SceneData::TGdtfGeometryArray
std::vector< GdtfGeometryPtr > TGdtfGeometryArray
Definition GDTFManager.h:820

SceneData::TGdtfMacroDMXStepArray
std::vector< GdtfMacroDMXStep * > TGdtfMacroDMXStepArray
Definition GDTFManager.h:1960

SceneData::GdtfCITPPtr
GdtfCITP * GdtfCITPPtr
Definition GDTFManager.h:2457

SceneData::GdtfFeatureGroupPtr
GdtfFeatureGroup * GdtfFeatureGroupPtr
Definition GDTFManager.h:221

SceneData::GdtfGeometryStructurePtr
GdtfGeometryStructure * GdtfGeometryStructurePtr
Definition GDTFManager.h:1235

SceneData::TGdtfWheelArray
std::vector< GdtfWheelPtr > TGdtfWheelArray
Definition GDTFManager.h:644

SceneData::TGdtf_CRIGroupArray
std::vector< GdtfCRIGroup * > TGdtf_CRIGroupArray
Definition GDTFManager.h:52

SceneData::GdtfMacroVisualStepPtr
GdtfMacroVisualStep * GdtfMacroVisualStepPtr
Definition GDTFManager.h:2045

SceneData::GdtfAttributePtr
GdtfAttribute * GdtfAttributePtr
Definition GDTFManager.h:326

SceneData::TGdtfSoftwareVersionIDArray
std::vector< GdtfSoftwareVersionID * > TGdtfSoftwareVersionIDArray
Definition GDTFManager.h:43

SceneData::TGdtfDmxChannelFuntionArray
std::vector< GdtfDmxChannelFunctionPtr > TGdtfDmxChannelFuntionArray
Definition GDTFManager.h:1688

SceneData::GdtfCRIPtr
GdtfCRI * GdtfCRIPtr
Definition GDTFManager.h:2610

SceneData::GdtfMapPtr
GdtfMap * GdtfMapPtr
Definition GDTFManager.h:2319

SceneData::TGdtfFeatureArray
std::vector< GdtfFeature * > TGdtfFeatureArray
Definition GDTFManager.h:187

SceneData::GdtfSubPhysicalUnitPtr
GdtfSubPhysicalUnit * GdtfSubPhysicalUnitPtr
Definition GDTFManager.h:261

SceneData::TGdtfWheelSlotPrismFacetArray
std::vector< GdtfWheelSlotPrismFacetPtr > TGdtfWheelSlotPrismFacetArray
Definition GDTFManager.h:358

SceneData::GdtfDmxSubChannelSetPtr
GdtfDmxSubChannelSet * GdtfDmxSubChannelSetPtr
Definition GDTFManager.h:1545

SceneData::TGdtfConnectorArray
std::vector< GdtfConnector * > TGdtfConnectorArray
Definition GDTFManager.h:63

SceneData::TGdtfLaserProtocolArray
std::vector< GdtfLaserProtocolPtr > TGdtfLaserProtocolArray
Definition GDTFManager.h:986

SceneData::TGdtfMacroArray
std::vector< GdtfMacroPtr > TGdtfMacroArray
Definition GDTFManager.h:1898

SceneData::TGdtfGamutArray
std::vector< GdtfGamutPtr > TGdtfGamutArray
Definition GDTFManager.h:522

SceneData::TGdtfMeasurementArray
std::vector< GdtfMeasurement * > TGdtfMeasurementArray
Definition GDTFManager.h:55

SceneData::GdtfMacroDMXStepPtr
GdtfMacroDMXStep * GdtfMacroDMXStepPtr
Definition GDTFManager.h:1959

SceneData::GdtfOpenSoundControlPtr
GdtfOpenSoundControl * GdtfOpenSoundControlPtr
Definition GDTFManager.h:2434

SceneData::GdtfActivationGroupPtr
GdtfActivationGroup * GdtfActivationGroupPtr
Definition GDTFManager.h:149

SceneData::GdtfPointPtr
GdtfPoint * GdtfPointPtr
Definition GDTFManager.h:2677

SceneData::GdtfMacroVisualPtr
GdtfMacroVisual * GdtfMacroVisualPtr
Definition GDTFManager.h:2066

SceneData::TGdtfPinPatchArray
std::vector< GdtfPinPatchPtr > TGdtfPinPatchArray
Definition GDTFManager.h:1087

SceneData::GdtfDMXProfilePtr
GdtfDMXProfile * GdtfDMXProfilePtr
Definition GDTFManager.h:47

SceneData::TGdtfDmxChannelSetArray
std::vector< GdtfDmxChannelSet * > TGdtfDmxChannelSetArray
Definition GDTFManager.h:1499

SceneData::TGdtf_CRIArray
std::vector< GdtfCRI * > TGdtf_CRIArray
Definition GDTFManager.h:2611

SceneData::GdtfLaserProtocolPtr
GdtfLaserProtocol * GdtfLaserProtocolPtr
Definition GDTFManager.h:985

SceneData::GdtfModelPtr
GdtfModel * GdtfModelPtr
Definition GDTFManager.h:744

SceneData::GdtfWheelSlotAnimationSystemPtr
GdtfWheelSlotAnimationSystem * GdtfWheelSlotAnimationSystemPtr
Definition GDTFManager.h:399

SceneData::GdtfGeometryDisplayPtr
GdtfGeometryDisplay * GdtfGeometryDisplayPtr
Definition GDTFManager.h:964

SceneData::TGdtfDMXPersonalityArray
std::vector< GdtfDMXPersonality * > TGdtfDMXPersonalityArray
Definition GDTFManager.h:2265

SceneData::GdtfFilterPtr
GdtfFilter * GdtfFilterPtr
Definition GDTFManager.h:58

SceneData::TGdtfPointArray
std::vector< GdtfPoint * > TGdtfPointArray
Definition GDTFManager.h:2678

SceneData::GdtfMacroDMXValuePtr
GdtfMacroDMXValue * GdtfMacroDMXValuePtr
Definition GDTFManager.h:1929

SceneData::GdtfGeometryInventoryPtr
GdtfGeometryInventory * GdtfGeometryInventoryPtr
Definition GDTFManager.h:1189

SceneData::GdtfSoftwareVersionIDPtr
GdtfSoftwareVersionID * GdtfSoftwareVersionIDPtr
Definition GDTFManager.h:44

VectorworksMVR::Filing
Definition IFileIdentifier.h:15

VectorworksMVR::Filing::IFileIdentifierPtr
VCOMPtr< IFileIdentifier > IFileIdentifierPtr
Definition IFileIdentifier.h:51

VectorworksMVR::Filing::TVWArray_IFileIdentifier
std::vector< IFileIdentifierPtr > TVWArray_IFileIdentifier
Definition IFileIdentifier.h:52

VectorworksMVR::Filing::IFolderIdentifierPtr
VCOMPtr< IFolderIdentifier > IFolderIdentifierPtr
Definition IFolderIdentifier.h:119

VectorworksMVR::Filing::IZIPFilePtr
VCOMPtr< IZIPFile > IZIPFilePtr
Definition IZIPFile.h:81

VectorworksMVR::Filing::IXMLFileNodePtr
VCOMPtr< IXMLFileNode > IXMLFileNodePtr
Definition IXMLFile.h:140

VectorworksMVR::GdtfDefines
Definition GDTFPrefix.h:11

VectorworksMVR::GdtfDefines::EGdtfChannelBitResolution
EGdtfChannelBitResolution
Definition GDTFPrefix.h:306

VectorworksMVR::GdtfDefines::EGdtfColorSample
EGdtfColorSample
Definition GDTFPrefix.h:528

VectorworksMVR::GdtfDefines::EGdtfDmxMaster
EGdtfDmxMaster
Definition GDTFPrefix.h:277

VectorworksMVR::GdtfDefines::EGdtfColorSpace
EGdtfColorSpace
Definition GDTFPrefix.h:631

VectorworksMVR::GdtfDefines::DMXAddress
Uint16 DMXAddress
Definition GDTFPrefix.h:13

VectorworksMVR::GdtfDefines::EGdtfLampType
EGdtfLampType
Definition GDTFPrefix.h:258

VectorworksMVR::GdtfDefines::EGdtfInterpolationTo
EGdtfInterpolationTo
Definition GDTFPrefix.h:639

VectorworksMVR::GdtfDefines::EGdtfCrossSectionType
EGdtfCrossSectionType
Definition GDTFPrefix.h:703

VectorworksMVR::GdtfDefines::EGdtfLaserColorType
EGdtfLaserColorType
Definition GDTFPrefix.h:661

VectorworksMVR::GdtfDefines::EGdtfOrientation
EGdtfOrientation
Definition GDTFPrefix.h:680

VectorworksMVR::GdtfDefines::EGdtfSupportType
EGdtfSupportType
Definition GDTFPrefix.h:709

VectorworksMVR::GdtfDefines::EGdtfStructureType
EGdtfStructureType
Definition GDTFPrefix.h:697

VectorworksMVR::GdtfDefines::EGdtfFuseRating
EGdtfFuseRating
Definition GDTFPrefix.h:688

VectorworksMVR::GdtfDefines::EGdtfComponentType
EGdtfComponentType
Definition GDTFPrefix.h:667

VectorworksMVR::GdtfDefines::EGdtfDmxRelationType
EGdtfDmxRelationType
Definition GDTFPrefix.h:300

VectorworksMVR::GdtfDefines::EGdtfSubPhysicalUnitType
EGdtfSubPhysicalUnitType
Definition GDTFPrefix.h:715

VectorworksMVR::GdtfDefines::EGdtfBeamType
EGdtfBeamType
Definition GDTFPrefix.h:266

VectorworksMVR::GdtfDefines::EGdtfObjectType
EGdtfObjectType
Definition GDTFPrefix.h:35

VectorworksMVR::GdtfDefines::EGdtfDmxSnap
EGdtfDmxSnap
Definition GDTFPrefix.h:285

VectorworksMVR::GdtfDefines::EGdtfPhysicalUnit
EGdtfPhysicalUnit
Definition GDTFPrefix.h:196

VectorworksMVR::GdtfDefines::DmxValue
Uint64 DmxValue
Definition GDTFPrefix.h:17

VectorworksMVR::GdtfDefines::EGdtfModel_PrimitiveType
EGdtfModel_PrimitiveType
Definition GDTFPrefix.h:241

VectorworksMVR::TCCieColorArray
std::vector< CCieColor * > TCCieColorArray
Definition CieColor.h:37

VectorworksMVR::TXStringArray
std::vector< TXString > TXStringArray
Definition GSString.h:545

VectorworksMVR::TGdtfParsingErrorArray
std::vector< GdtfParsingError > TGdtfParsingErrorArray
Definition GdtfError.h:43

VectorworksMVR::CCieColorPtr
CCieColor * CCieColorPtr
Definition CieColor.h:36

VectorworksMVR::STime
Definition IMediaRessourceVectorInterface.h:36