sprk_exchange.h

// Copyright (c) Tech Soft 3D, Inc.
//
// The information contained herein is confidential and proprietary to Tech Soft 3D, Inc.,
// and considered a trade secret as defined under civil and criminal statutes.
// Tech Soft 3D, Inc. shall pursue its civil and criminal remedies in the event of
// unauthorized use or misappropriation of its trade secrets.  Use of this information
// by anyone other than authorized employees of Tech Soft 3D, Inc. is granted only under
// a written non-disclosure agreement, expressly prescribing the scope and manner of such use.

#ifndef SPRK_EXCHANGE_H
#define SPRK_EXCHANGE_H

#include "sprk.h"

typedef void A3DEntity;
typedef void A3DAsmModelFile;
typedef void A3DRWParamsPrcReadHelper;

#ifdef _MSC_VER
#ifndef STATIC_APP
#   ifdef SPRK_EXCHANGE
#       define EXCHANGE_API __declspec (dllexport)
#   else
#       define EXCHANGE_API __declspec (dllimport)
#   endif
#endif
#else
#   include <stddef.h>
#   if defined(LINUX_SYSTEM) && defined(SPRK_EXCHANGE)
#       ifndef STATIC_APP
#           define EXCHANGE_API __attribute__ ((visibility ("default")))
#       endif
#   endif
#endif

#ifndef EXCHANGE_API
#   define EXCHANGE_API 
#endif

namespace HPS
{

class EXCHANGE_API Exchange
{
public:

    class Component;
    class Configuration;
    class Sheet;
    class TessellationOptionsKit;
    class TranslationNotifier;
    class TranslationOptionsKit; 
#if !defined(TARGET_OS_ANDROID)
    class ExportParasolidOptionsKit;
#endif
    class ReloadNotifier;

    typedef std::vector<Configuration, HPS::Allocator<Configuration> >                          ConfigurationArray;
    typedef std::vector<Sheet, HPS::Allocator<Sheet> >                                          SheetArray;
    typedef HPS::IntArray                                                                       ParasolidEntityArray;

    enum class Units
    {
        Unknown,        
        Point,          
        Inch,           
        Millimeter,     
        Centimeter,     
        Pica,           
        Foot,           
        Yard,           
        Meter,          
        Kilometer,      
        Mile            
    };

    enum class UnloadMode
    {
        ExchangeAndVisualization,

        ExchangeOnly,
    };

    enum class LoadStatus
    {
        Unknown,
        Loaded,
        VisualizationOnly,
        PartiallyLoaded,
        NotLoaded
    };

    class EXCHANGE_API Component : public HPS::Component
    {
    public:
        Component();

        Component(HPS::Component const & in_that);

        Component(Exchange::Component const & in_that);

        Component(Exchange::Component && in_that);

        virtual ~Component();

    static const HPS::Type staticType = HPS::Type::ExchangeComponent;
        HPS::Type               ObjectType() const { return staticType; }

#if !defined(_MSC_VER) || _MSC_VER >= 1900
        Component &             operator=(Component const & in_that) = default;
#endif

        Component &             operator=(Exchange::Component && in_that);


        A3DEntity *             GetExchangeEntity() const;


        void                    Tessellate(TessellationOptionsKit const & in_options);

        TranslationNotifier     Translate(Units in_units, TranslationOptionsKit const & in_translation_options);

        ReloadNotifier          Reload(TessellationOptionsKit const & in_tessellation_options = TessellationOptionsKit(), TranslationOptionsKit const & in_translation_options = TranslationOptionsKit());

        bool                    SetTransform(MatrixKit const & in_transform);

        bool                    AddTransform(MatrixKit const & in_transform);

        HPS::Component          CopyTo(HPS::Component const & in_new_owner);

        bool                    SetName(char const * in_new_name);
    };

    class EXCHANGE_API ProductOccurrence : public Exchange::Component
    {
    public:
        ProductOccurrence();

        ProductOccurrence(HPS::Component const & in_that);

        ProductOccurrence(Component const & in_that);

        ProductOccurrence(ProductOccurrence const & in_sheet);

        ProductOccurrence(ProductOccurrence && in_that);

        ProductOccurrence & operator=(ProductOccurrence && in_that);

        virtual ~ProductOccurrence();

    static const HPS::Type staticType = HPS::Type::ExchangeProductOccurrence;
        HPS::Type               ObjectType() const { return staticType; }

        bool                    Equals(ProductOccurrence const & in_kit) const;

        bool                    operator==(ProductOccurrence const & in_kit) const;

        bool                    operator!=(ProductOccurrence const & in_kit) const;

        void                    Unload(UnloadMode in_mode = UnloadMode::ExchangeAndVisualization);

        LoadStatus              GetLoadStatus() const;

        bool                    IsExternalData() const;
    };

    class EXCHANGE_API Sheet : public Exchange::Component
    {
    public:
        Sheet();

        Sheet(HPS::Component const & in_that);

        Sheet(Component const & in_that);

        Sheet(Sheet const & in_sheet);

        Sheet(Sheet && in_that);

        Sheet & operator=(Sheet && in_that);

        virtual ~Sheet();

    static const HPS::Type staticType = HPS::Type::ExchangeSheet;
        HPS::Type               ObjectType() const { return staticType; }

        bool                    Equals(Sheet const & in_kit) const;

#if !defined(_MSC_VER) || _MSC_VER >= 1900
        Sheet &             operator=(Sheet const & in_that) = default;
#endif

        bool                    operator==(Sheet const & in_kit) const;

        bool                    operator!=(Sheet const & in_kit) const;

        /* Activates this sheet */
        HPS::View               Activate();
    };

    class EXCHANGE_API CADModel : public HPS::CADModel
    {
    public:
        CADModel();

        CADModel(Component const & in_that);

        CADModel(HPS::CADModel const & in_that);

        CADModel(Exchange::CADModel const & in_that);

        CADModel(Exchange::CADModel && in_that);

        virtual ~CADModel();

    static const HPS::Type staticType = HPS::Type::ExchangeCADModel;
        HPS::Type               ObjectType() const { return staticType; }

#if !defined(_MSC_VER) || _MSC_VER >= 1900
        CADModel &              operator=(Exchange::CADModel const & in_that) = default;
#endif

        CADModel &              operator=(Exchange::CADModel && in_that);


        A3DEntity *             GetExchangeEntity() const;

        HPS::Component          GetComponentFromEntity(A3DEntity * in_entity) const;

        bool                    GetEntityOwnership() const;


        UTF8Array               GetCurrentConfiguration() const;

        ConfigurationArray      GetConfigurations() const;

        /* Gets a list of sheets for this CADModel (if any). Only formats which support the concept of sheets can return a non-empty array.
         * \return The list of sheets for this CADModel */
        SheetArray              GetSheets() const;

        TranslationNotifier     Translate(TranslationOptionsKit const & in_translation_options);

        ReloadNotifier          Reload(TessellationOptionsKit const & in_options = TessellationOptionsKit(), TranslationOptionsKit const & in_translation_options = TranslationOptionsKit());

        void                    ShowAllPMI(Canvas const & in_canvas, size_t in_layer = 0);

        void                    SetAllPMIInFront(bool in_enable, Canvas const & in_canvas, size_t in_layer = 0);

        void                    HideAllPMI(Canvas const & in_canvas, size_t in_layer = 0);

        void                    Tessellate(TessellationOptionsKit const & in_options);
        
        bool                    ReplaceExchangeEntity(Component const & in_component, A3DEntity* in_a3d_entity);
    };

    class EXCHANGE_API Capture : public HPS::Capture
    {
    public:
        Capture();

        Capture(Component const & in_that);

        Capture(HPS::Capture const & in_that);

        Capture(Exchange::Capture const & in_that);

        Capture(Exchange::Capture && in_that);

        virtual ~Capture();

    static const HPS::Type staticType = HPS::Type::ExchangeCapture;
        HPS::Type               ObjectType() const { return staticType; }

#if !defined(_MSC_VER) || _MSC_VER >= 1900
        Capture &               operator=(Exchange::Capture const & in_that) = default;
#endif

        Capture &               operator=(Exchange::Capture && in_that);


        A3DEntity *             GetExchangeEntity() const;

        /* Activates this capture */
        HPS::View               Activate(HPS::ComponentPath const & in_capture_path = HPS::ComponentPath());
    };

    class EXCHANGE_API Filter : public HPS::Filter
    {
    public:
        Filter();

        Filter(Component const & in_that);

        Filter(HPS::Filter const & in_that);

        Filter(Exchange::Filter const & in_that);

        Filter(Exchange::Filter && in_that);

        virtual ~Filter();

    static const HPS::Type staticType = HPS::Type::ExchangeFilter;
        HPS::Type               ObjectType() const { return staticType; }

#if !defined(_MSC_VER) || _MSC_VER >= 1900
        Filter &                operator=(Exchange::Filter const & in_that) = default;
#endif

        Filter &                operator=(Exchange::Filter && in_that);


        A3DEntity *             GetExchangeEntity() const;
    };

    class EXCHANGE_API Factory : public Sprocket
    {
    public:
        static Component    CreateComponent(HPS::Component const & in_owner, HPS::Component::ComponentType in_type, A3DEntity * in_entity = nullptr);

        static CADModel     CreateCADModel(Model const & in_model = HPS::Factory::CreateModel(), A3DAsmModelFile * in_entity = nullptr, bool in_owns_entity = false);

        static Filter       CreateFilter(HPS::Component const & in_owner, A3DEntity * in_entity = nullptr);

        static Capture      CreateCapture(HPS::Component const & in_owner, A3DEntity * in_entity = nullptr, bool in_is_default = false);

        static Sheet        CreateSheet(HPS::Component const & in_owner, A3DEntity * in_entity = nullptr);

        static Component    DeInstanceComponent(HPS::ComponentPath const & in_component_path);

    private:
        Factory();
    };

    class EXCHANGE_API ImportNotifier : public IONotifier
    {
    public:
        ImportNotifier();

        ImportNotifier(ImportNotifier const & in_that);

        ImportNotifier(IONotifier const & in_that);

        ImportNotifier(ImportNotifier && in_that);

        ImportNotifier &        operator=(ImportNotifier && in_that);

        virtual ~ImportNotifier();

    static const HPS::Type staticType = HPS::Type::ExchangeImportNotifier;
        HPS::Type               ObjectType() const { return staticType; };

        ImportNotifier &        operator=(ImportNotifier const & in_that);

        void                    Assign(ImportNotifier const & in_that);

        Exchange::CADModel      GetCADModel() const;

        A3DRWParamsPrcReadHelper * GetPRCReadHelper() const;

        Time                    GetImportTime() const;

        Time                    GetParseTime() const;
    };

    class EXCHANGE_API TranslationNotifier : public IONotifier
    {
    public:
        TranslationNotifier();

        TranslationNotifier(TranslationNotifier const & in_that);

        TranslationNotifier(IONotifier const & in_that);

        TranslationNotifier(TranslationNotifier && in_that);

        TranslationNotifier &       operator=(TranslationNotifier && in_that);

        virtual ~TranslationNotifier();

    static const HPS::Type staticType = HPS::Type::ExchangeTranslationNotifier;
        HPS::Type                           ObjectType() const { return staticType; };

        TranslationNotifier &               operator=(TranslationNotifier const & in_that);

        void                                Assign(TranslationNotifier const & in_that);

        Exchange::ParasolidEntityArray      GetParasolidParts() const;

        HPS::Time                           GetImportTime() const;

        HPS::Time                           GetTranslationTime() const;
    };

    class EXCHANGE_API ExportNotifier : public IONotifier
    {
    public:
        ExportNotifier();

        ExportNotifier(ExportNotifier const & in_that);

        ExportNotifier(IONotifier const & in_that);

        ExportNotifier(ExportNotifier && in_that);

        ExportNotifier &        operator=(ExportNotifier && in_that);

        virtual ~ExportNotifier();

    static const HPS::Type staticType = HPS::Type::ExchangeExportNotifier;
        HPS::Type               ObjectType() const { return staticType; };

        ExportNotifier &        operator=(ExportNotifier const & in_that);

        void                    Assign(ExportNotifier const & in_that);

        A3DAsmModelFile *       GetModelFile() const;
    };

    class EXCHANGE_API ReloadNotifier : public IONotifier
    {
    public:
        ReloadNotifier();

        ReloadNotifier(ReloadNotifier const & in_that);

        ReloadNotifier(IONotifier const & in_that);

        ReloadNotifier(ReloadNotifier && in_that);

        ReloadNotifier &        operator=(ReloadNotifier && in_that);

        virtual ~ReloadNotifier();

    static const HPS::Type staticType = HPS::Type::ExchangeReloadNotifier;
        HPS::Type               ObjectType() const { return staticType; };

        ReloadNotifier &        operator=(ReloadNotifier const & in_that);

        void                    Assign(ReloadNotifier const & in_that);
    };


    class ImportOptionsKit;
    class ModelFileImportOptionsKit;

#if TARGET_OS_ANDROID == 0 && TARGET_OS_IPHONE == 0
    class Export3MFOptionsKit;
    class ExportFBXOptionsKit;
    class ExportACISOptionsKit;
    class ExportJTOptionsKit;
    class ExportPRCOptionsKit;
    class ExportSTLOptionsKit;
    class ExportOBJOptionsKit;
    class ExportU3DOptionsKit;
    class ExportXMLOptionsKit;
    class ExportGLTFOptionsKit;
#endif

#if !defined(TARGET_OS_ANDROID)
    class ExportSTEPOptionsKit;
    class ExportIGESOptionsKit;
#endif

    enum class BRepMode
    {
        TessellationOnly,
        BRepOnly,
        BRepAndTessellation,
    };

    enum class ImportMode
    {
        Complete,
        Incremental,
    };

    enum class SurfaceType
    {
        Blend01,    
        Blend02,    
        Blend03,    
        Blend04,    
        NURBS,      
        Cone,       
        Cylinder,   
        Offset,     
        Pipe,       
        Plane,      
        Ruled,      
        Sphere,     
        Revolution, 
        Extrusion,  
        FromCurve,  
        Torus,      
        Transform,  
    };

    enum class CurveType
    {
        Blend,          
        NURBS,          
        Circle,         
        Composite,      
        CurveOnSurface, 
        Ellipse,        
        Equation,       
        Helix,          
        Hyperbola,      
        Intersection,   
        Line,           
        Offset,         
        Parabola,       
        Polyline,       
        Transform,      
    };

    typedef std::vector<SurfaceType, HPS::Allocator<SurfaceType> >  SurfaceTypeArray; 
    typedef std::vector<CurveType, HPS::Allocator<CurveType> >      CurveTypeArray; 

    enum class AnnotationCaptureFitting
    {
        PMIOnly,        
        ModelAndPMI     
    };

    class EXCHANGE_API Tessellation
    {
    public:
        enum class Type
        {
            Standard,       
            Custom          
        };


        enum class Level
        {
            ExtraLow,       
            Low,            
            Medium,         
            High,           
            ExtraHigh,      
        };

        class EXCHANGE_API Chord
        {
        public:
            enum class Limit
            {
                Ratio,
                Height
            };

        private:
            Chord();
        };

        enum class Accuracy
        {
            Standard,
            Accurate,
            GridAccurate
        };

    private:
        Tessellation();
    };

    class EXCHANGE_API JT
    {
    public:
        enum class Content
        {
            Geometry,                   
            Tessellation,               
            GeometryAndTessellation     
        };

        enum class TessellationLevel
        {
            Low,                            
            Medium,                         
            High,                           
        };

        enum class Version
        {
            JT81,       
            JT95,       
            JT100,      
        };

    private:
        JT();
    };

    class EXCHANGE_API STEP
    {
    public:
        enum class Field
        {
            ProductName,                                
            NextAssemblyUsageOccurrenceID,              
            NextAssemblyUsageOccurrenceName,            
            NextAssemblyUsageOccurrenceDescription      
        };

        enum class Format
        {
            AP203,      
            AP214,      
            AP242,      
        };

    private:
        STEP();
    };

    class EXCHANGE_API PRC
    {
    public:
        enum class BRepCompression
        {
            None,       
            Low,        
            Medium,     
            High        
        };

    private:
        PRC();
    };

    class EXCHANGE_API ProE
    {
    public:
        enum class SessionColor
        {
            LastCreoVersion,
            ExchangeDefault,
            UserDefined
        };

        enum class FamilyTable
        {
            BRepOnly,
            BRepOrTessellation,
            BRepOrTessellationOrGeneric
        };

        enum class ConstructionEntities
        {
            On,
            Off,
            AsDatum,
        }; 

    private:
        ProE();
    };

    class EXCHANGE_API U3D
    {
    public:
        enum class Version
        {
            ECMA1,      
            ECMA3       
        };

    private:
        U3D();
    };

    class EXCHANGE_API Revit
    {
    public:
        enum class PhysicalProperties
        {
            NotComputed,
            Computed
        };

    private:
        Revit();
    };

    class EXCHANGE_API Configuration : public HPS::Sprocket
    {
    public:
        Configuration();

        Configuration(char const * in_name);

        Configuration(char const * in_name, size_t in_count, Configuration const in_subconfigurations[]);

        Configuration(char const * in_name, ConfigurationArray const & in_subconfigurations);

        Configuration(Configuration const & in_configuration);

        Configuration(Configuration && in_that);

        Configuration & operator=(Configuration && in_that);

        virtual ~Configuration();

    static const HPS::Type staticType = HPS::Type::ExchangeConfiguration;
        HPS::Type               ObjectType() const { return staticType; }


        void                    Set(Configuration const & in_kit);

        void                    Show(Configuration & out_kit) const;

        Configuration &         operator=(Configuration const & in_kit);

        bool                    Empty() const;

        bool                    Equals(Configuration const & in_kit) const;

        bool                    operator==(Configuration const & in_kit) const;

        bool                    operator!=(Configuration const & in_kit) const;


        HPS::UTF8               GetName() const;

        ConfigurationArray      GetSubconfigurations() const;
    };

    class EXCHANGE_API File
    {
    public:
        enum class Format
        {
            Unsupported,            
            ACIS,                   
            CADDS,                  
            CATIAV4,                
            CATIAV5,                
            CGR,                    
            COLLADA,                
            CreoProE,               
            DWG,                    
            DXF,                    
            IDEAS,                  
            IFC,                    
            IGES,                   
            Inventor,               
            JT,                     
            KeyholeMarkupLanguage,  
            LatticeXVL,             
            OneSpaceDesigner,       
            Parasolid,              
            PDF,                    
            PRC,                    
            Rhino,                  
            NXUnigraphics,          
            SolidEdge,              
            SolidWorks,             
            STEP,                   
            StereoLithography,      
            ThreeDStudioMax,        
            ThreeDXML,              
            Universal3D,            
            VDAFS,                  
            VRML,                   
            WavefrontObject,        
            Revit,                  
            GLTF,                   
            DWF,                    
            FBX,                    
            STEPXML,                
            ThreeMF,                
            Navisworks,             
        };

        static Format GetFormat(char const * in_file_name);

        static ConfigurationArray GetConfigurations(char const * in_file_name);

        static void GetInformation(const char * in_file_name, Format & out_format, UTF8 & out_model_name, UTF8 & out_version, UTF8 & out_author, UTF8 & out_organization, UTF8 & out_time_stamp);

        static HPS::ImageKit GetThumbnailImage(const char * in_file_name);

        static ImportNotifier Import(char const * in_file_name, ImportOptionsKit const & in_options);

        static ImportNotifier Import(A3DAsmModelFile const * in_model_file, ModelFileImportOptionsKit const & in_options);

        static ImportNotifier Import(size_t in_byte_count, byte const in_prc_data[], ModelFileImportOptionsKit const & in_options);

        static ImportNotifier Import(ByteArray const & in_prc_data, ModelFileImportOptionsKit const & in_options);


        static TranslationNotifier Translate(char const * in_file_name, ImportOptionsKit const & in_options, TranslationOptionsKit const & in_translation_options);

#if TARGET_OS_ANDROID == 0 && TARGET_OS_IPHONE == 0

        static ExportNotifier Export3MF(CADModel const & in_cad_model, char const * in_file_name, Export3MFOptionsKit const & in_options);

        static ExportNotifier Export3MF(KeyPathArray const & in_source, char const * in_file_name, Export3MFOptionsKit const & in_options);

        static ExportNotifier Export3MF(size_t in_count, KeyPath const in_source[], char const * in_file_name, Export3MFOptionsKit const & in_options);

        static ExportNotifier Export3MF(KeyPath in_source, char const * in_file_name, Export3MFOptionsKit const & in_options);

        static void ExportFBX(CADModel const & in_cad_model, char const * in_file_name, ExportFBXOptionsKit const & in_options);

        static void ExportACIS(CADModel const & in_cad_model, char const * in_file_name, ExportACISOptionsKit const & in_options);

        static void ExportJT(CADModel const & in_cad_model, char const * in_file_name, ExportJTOptionsKit const & in_options);

        static ExportNotifier ExportPRC(CADModel const & in_cad_model, char const * in_file_name, ExportPRCOptionsKit const & in_options);

        static ExportNotifier ExportPRC(KeyPathArray const & in_source, char const * in_file_name, bool in_compress_tessellation = false);

        static ExportNotifier ExportPRC(size_t in_count, KeyPath const in_source [], char const * in_file_name, bool in_compress_tessellation = false);

        static ExportNotifier ExportPRC(KeyPath const & in_source, char const * in_file_name, bool in_compress_tessellation = false);

        static ExportNotifier ExportPRC(KeyPathArray const & in_source);

        static ExportNotifier ExportPRC(size_t in_count, KeyPath const in_source []);

        static ExportNotifier ExportPRC(KeyPath const & in_source);

        static void ExportSTL(CADModel const & in_cad_model, char const * in_file_name, ExportSTLOptionsKit const & in_options);

        static void ExportOBJ(CADModel const & in_cad_model, char const * in_file_name, ExportOBJOptionsKit const & in_options);

        static void ExportU3D(CADModel const & in_cad_model, char const * in_file_name, ExportU3DOptionsKit const & in_options);

        static void ExportVRML(CADModel const & in_cad_model, char const * in_file_name);

        static void ExportXML(CADModel const & in_cad_model, char const * in_file_name, ExportXMLOptionsKit const & in_options);

        static void ExportGLTF(CADModel const & in_cad_model, char const * in_file_name, ExportGLTFOptionsKit const & in_options);

#endif

#if TARGET_OS_ANDROID == 0

        static void ExportIGES(CADModel const & in_cad_model, char const * in_file_name, ExportIGESOptionsKit const & in_options);

        static void ExportParasolid(CADModel const & in_cad_model, char const * in_file_name, ExportParasolidOptionsKit const & in_options);

        static void ExportSTEP(CADModel const & in_cad_model, char const * in_file_name, ExportSTEPOptionsKit const & in_options);
#endif

    private:
        File();
    };

    class EXCHANGE_API NURBSConversionOptionsKit : public SprocketKit
    {
    public:
        NURBSConversionOptionsKit();

        NURBSConversionOptionsKit(NURBSConversionOptionsKit const & in_kit);

        NURBSConversionOptionsKit(NURBSConversionOptionsKit && in_that);

        NURBSConversionOptionsKit & operator=(NURBSConversionOptionsKit && in_that);

        virtual ~NURBSConversionOptionsKit();

    static const HPS::Type staticType = HPS::Type::ExchangeNURBSConversionOptionsKit;
        HPS::Type                   ObjectType() const { return staticType; }

        void                        Set(NURBSConversionOptionsKit const & in_kit);

        void                        Show(NURBSConversionOptionsKit & out_kit) const;

        NURBSConversionOptionsKit &         operator=(NURBSConversionOptionsKit const & in_kit);

        bool                        Empty() const;

        bool                        Equals(NURBSConversionOptionsKit const & in_kit) const;

        bool                        operator==(NURBSConversionOptionsKit const & in_kit) const;

        bool                        operator!=(NURBSConversionOptionsKit const & in_kit) const;

        static NURBSConversionOptionsKit        GetDefault();

        NURBSConversionOptionsKit & SetCrossSeamCurveReplacement(bool in_state);

        NURBSConversionOptionsKit & Set3DCurvesComputation(bool in_state);

        NURBSConversionOptionsKit & SetUVCurvesComputation(bool in_state, bool in_allow_cross_seam_curves);

        NURBSConversionOptionsKit & SetClosedFaceSplitting(bool in_state);

        NURBSConversionOptionsKit & SetPeriodicFaceSplitting(bool in_state);

        NURBSConversionOptionsKit & SetParameterization(bool in_state);

        NURBSConversionOptionsKit & SetTolerance(double in_tolerance);

        NURBSConversionOptionsKit & SetAllowedSurfaces(SurfaceTypeArray const & in_allowed_surfaces);

        NURBSConversionOptionsKit & SetAllowedSurfaces(size_t in_count, SurfaceType const in_allowed_surfaces []);

        NURBSConversionOptionsKit & SetAllowedCurves(CurveTypeArray const & in_allowed_curves);

        NURBSConversionOptionsKit & SetAllowedCurves(size_t in_count, CurveType const in_allowed_curves []);


        NURBSConversionOptionsKit & UnsetCrossSeamCurveReplacement();

        NURBSConversionOptionsKit & Unset3DCurvesComputation();

        NURBSConversionOptionsKit & UnsetUVCurvesComputation();

        NURBSConversionOptionsKit & UnsetClosedFaceSplitting();

        NURBSConversionOptionsKit & UnsetPeriodicFaceSplitting();

        NURBSConversionOptionsKit & UnsetParameterization();

        NURBSConversionOptionsKit & UnsetTolerance();

        NURBSConversionOptionsKit & UnsetAllowedSurfaces();

        NURBSConversionOptionsKit & UnsetAllowedCurves();

        NURBSConversionOptionsKit & UnsetEverything();



        bool ShowCrossSeamCurveReplacement(bool & out_state) const;

        bool Show3DCurvesComputation(bool & out_state) const;

        bool ShowUVCurvesComputation(bool & out_state, bool & out_allow_cross_seam_curves) const;

        bool ShowClosedFaceSplitting(bool & out_state) const;

        bool ShowPeriodicFaceSplitting(bool & out_state) const;

        bool ShowParameterization(bool & out_state) const;

        bool ShowTolerance(double & out_tolerance) const;

        bool ShowAllowedSurfaces(SurfaceTypeArray & out_allowed_surfaces) const;
        
        bool ShowAllowedCurves(CurveTypeArray & out_allowed_curves) const;
    };

    class EXCHANGE_API ImportOptionsKit : public SprocketKit
    {
    public:
        ImportOptionsKit();

        ImportOptionsKit(ImportOptionsKit const & in_kit);

        ImportOptionsKit(ImportOptionsKit && in_that);

        ImportOptionsKit & operator=(ImportOptionsKit && in_that);

        virtual ~ImportOptionsKit();

        static const HPS::Type staticType = HPS::Type::ExchangeImportOptionsKit;
        HPS::Type                   ObjectType() const { return staticType; }

        static ImportOptionsKit     GetDefault();

        void                        Set(ImportOptionsKit const & in_kit);

        void                        Show(ImportOptionsKit & out_kit) const;

        ImportOptionsKit &          operator=(ImportOptionsKit const & in_kit);

        bool                        Empty() const;

        bool                        Equals(ImportOptionsKit const & in_kit) const;

        bool                        operator==(ImportOptionsKit const & in_kit) const;

        bool                        operator!=(ImportOptionsKit const & in_kit) const;


        ImportOptionsKit &          SetBRepMode(BRepMode in_mode);

        ImportOptionsKit &          SetSolids(bool in_state);

        ImportOptionsKit &          SetSurfaces(bool in_state);

        ImportOptionsKit &          SetWireframes(bool in_state);

        ImportOptionsKit &          SetPMI(bool in_state);

        ImportOptionsKit &          SetAttributes(bool in_state);

        ImportOptionsKit &          SetHiddenObjects(bool in_state);

        ImportOptionsKit &          SetConstructionAndReferences(bool in_state);

        ImportOptionsKit &          SetActiveFilter(bool in_state);

        ImportOptionsKit&           SetConstraintsInfo(bool in_state);

        ImportOptionsKit &          SetFeatureTrees(bool in_state);

        ImportOptionsKit &          SetDrawings(bool in_state);

        ImportOptionsKit &          SetDefaultUnits(Units in_units);

        ImportOptionsKit &          SetMultiProcessCount(unsigned int in_count);

        ImportOptionsKit &          SetSewingTolerance(double in_tolerance);

        ImportOptionsKit &          SetComputePreferredOpenShellOrientation(bool in_state);

        ImportOptionsKit &          SetPMISubstitutionFont(char const * in_font_name, bool in_always_substitute = false);

        ImportOptionsKit &          SetPMIPrecision(size_t in_precision);

        ImportOptionsKit &          SetPMIDefaultUnits(Units in_units);

        ImportOptionsKit &          SetPMIFlipping(bool in_flip);

        ImportOptionsKit &          SetRemovedViews(bool read_removed_views);

        ImportOptionsKit &          SetExternalProductOccurrence(bool read_external_po);

        ImportOptionsKit &          SetPMIDefaultColor(RGBColor const & in_color, bool in_override_color = false);

        ImportOptionsKit &          SetTessellationCleanup(bool in_cleanup);

        ImportOptionsKit &          SetTessellationLevel(Tessellation::Level in_level);

        ImportOptionsKit &          SetTessellationLevel(Tessellation::Chord::Limit in_limit_type, double in_limit, double in_angle_tolerance);

        ImportOptionsKit &          SetTessellationAccuracy(Tessellation::Accuracy in_type, bool in_accurate_normals = true, bool in_accurate_surface_curvatures = false, double in_accurate_grid_maximum_stitch_length = 0.0);

        ImportOptionsKit &          SetTessellationPreservesUVPoints(bool in_state);

        ImportOptionsKit &          SetTessellationMaximumEdgeLength(double in_length);

        ImportOptionsKit &          SetTextureDirectories(size_t in_count, UTF8 const in_directories[]);

        ImportOptionsKit &          SetTextureDirectories(UTF8Array const & in_directories);

        ImportOptionsKit &          SetSearchDirectories(size_t in_count, UTF8 const in_directories[], bool const in_recurse_flags[]);

        ImportOptionsKit &          SetSearchDirectories(UTF8Array const & in_directories, BoolArray const & in_recurse_flags);

        ImportOptionsKit &          SetSearchDirectories(size_t in_count, UTF8 const in_directories[], UTF8 const in_logical_names[], bool const in_recurse_flags[]);

        ImportOptionsKit &          SetSearchDirectories(UTF8Array const & in_directories, UTF8Array const & in_logical_names, BoolArray const & in_recurse_flags);

        ImportOptionsKit &          SetSearchDirectoriesByFile(size_t in_count, UTF8 const in_file_names[]);

        ImportOptionsKit &          SetSearchDirectoriesByFile(UTF8Array const & in_file_names);

        ImportOptionsKit &          SetSearchRootDirectory(bool in_state, bool in_recursive = true);

        ImportOptionsKit &          SetConfiguration(char const * in_configuration);

        ImportOptionsKit &          SetConfiguration(size_t in_count, UTF8 const in_configuration[]);

        ImportOptionsKit &          SetConfiguration(UTF8Array const & in_configuration);

        ImportOptionsKit &          SetCatiaV4LogicalNameForRootDirectory(char const * in_name);

        ImportOptionsKit &          SetCatiaV4LogicalNameSearching(bool in_state);

        ImportOptionsKit &          SetCatiaV5Cache(bool in_active, char const * in_path);

        ImportOptionsKit &          SetCatiaV5MaterialRendering(bool in_active);

        ImportOptionsKit &          SetUnigraphicsPreferredReferenceSets(size_t in_count, UTF8 const in_reference_sets[], bool in_apply_to_all_levels);

        ImportOptionsKit &          SetUnigraphicsPreferredReferenceSets(UTF8Array const & in_reference_sets, bool in_apply_to_all_levels);

        ImportOptionsKit &          SetUnigraphicsFittedCamera(bool in_state);

        ImportOptionsKit &          SetProECodePageName(char const * in_name);

        ImportOptionsKit &          SetProEDimensionTolerance(bool in_state);

        ImportOptionsKit &          SetProESubpartPMI(bool in_state);

        ImportOptionsKit &          SetProESessionColor(ProE::SessionColor in_type);

        ImportOptionsKit &          SetProEMissingBoolean(bool in_state);

        ImportOptionsKit &          SetProEMissingFlexibleComponent(bool in_state);

        ImportOptionsKit &          SetProEFamilyTableSource(ProE::FamilyTable in_source);

        ImportOptionsKit &          SetProEHomeView(bool in_state);

        ImportOptionsKit &          SetProEExplodedViews(bool in_state);

        ImportOptionsKit &          SetProEDatum(bool in_state);


        ImportOptionsKit &          SetProEConstructionEntities(ProE::ConstructionEntities in_state);

        ImportOptionsKit &          SetProESkeletons(bool in_state);

        ImportOptionsKit &          SetSTEPNamePreference(STEP::Field in_field);

        ImportOptionsKit &          SetSTEPCodePageName(char const * in_name);

        ImportOptionsKit &          SetSTEPFirstColorPreference(bool in_state);

        ImportOptionsKit &          SetSTEPShellBasedSurfaceModelSplitting(bool in_state);

        ImportOptionsKit &          SetSTEPOrientationHealing(bool in_state);

        ImportOptionsKit &          SetSTEPValidationProperties(bool in_state);

        ImportOptionsKit &          SetIFCCodePageName(char const * in_name);

        ImportOptionsKit &          SetIFCAttributeXMLFile(char const * in_filename);

        ImportOptionsKit &          SetIFCOwnerHistoryOptimization(bool in_state);

        ImportOptionsKit &          SetIFCFaceOptimization(bool in_state);

        ImportOptionsKit &          SetIFCEdges(bool in_state);

        ImportOptionsKit &          SetIFCMetadata(bool in_state);

        ImportOptionsKit &          SetIFCRelationships(bool in_state);

        ImportOptionsKit &          SetIFCOpenings(bool in_state);

        ImportOptionsKit &          SetPDF3DStreamIndex(size_t in_index);

        ImportOptionsKit &          SetJTTessellationLevel(JT::TessellationLevel in_jt_tessellation_level);

        ImportOptionsKit&           SetSolidworksDisplayVisibleDatum(bool in_state);

        ImportOptionsKit &          SetInventorEmbeddedTessellation(bool in_state);

        ImportOptionsKit &          SetPRCReadHelper(bool in_use_helper);

        ImportOptionsKit &          SetRhinoForceRenderedModeColors(bool in_state);

        ImportOptionsKit &          SetRevitPhysicalProperties(Revit::PhysicalProperties in_physical_properties);

        ImportOptionsKit &          SetAnnotationCaptureFitting(AnnotationCaptureFitting in_fitting);

        ImportOptionsKit &          SetLocation(ComponentPath const & in_path, MatrixKit const & in_transform = MatrixKit());

        ImportOptionsKit &          SetMode(ImportMode in_mode);

        ImportOptionsKit &          SetIncrementalComponentPath(HPS::ComponentPath const & in_path);

        ImportOptionsKit &          SetIncrementalComponentPaths(size_t in_count, HPS::ComponentPath const in_paths[]);

        ImportOptionsKit &          SetIncrementalComponentPaths(HPS::ComponentPathArray const & in_paths);

        ImportOptionsKit &          SetNURBSConversion(HPS::Exchange::NURBSConversionOptionsKit const & in_nurbs_conversion_options);

        ImportOptionsKit &          SetGeometryDefaultColor(RGBAColor const & in_color);

        /* When this option is enabled, translations that are deemed to be especially large compared to the model size are removed from the
        * scene graph and instead imported as user data, at the index specified, on the segment where the translation would have been.
        * Removing very large translation is useful to avoid visual artifacts due to loss in precision.
        * Note that only part of a translation might be extracted.
        * If you are adding a model to an existing scene through the SetLocation feature, and the original model was loaded using the
        * SetLargeTranslationExtraction setting, the same data_index value should be used for the model being added to the existing scene,
        * so that any translations previously extracted from the model can be taken into account during import.
        *   \param in_state Whether to enable large translation extraction
        *   \param in_data_index The index at which the user data representing the extracted translation will be stored
        *   \return A reference to this ImportOptionsKit. */
        ImportOptionsKit &          SetLargeTranslationExtraction(bool in_state, intptr_t in_data_index = 1);

        ImportOptionsKit &          UnsetBRepMode();

        ImportOptionsKit &          UnsetSolids();

        ImportOptionsKit &          UnsetSurfaces();

        ImportOptionsKit &          UnsetWireframes();

        ImportOptionsKit &          UnsetPMI();

        ImportOptionsKit &          UnsetAttributes();

        ImportOptionsKit &          UnsetHiddenObjects();

        ImportOptionsKit &          UnsetConstructionAndReferences();

        ImportOptionsKit &          UnsetActiveFilter();

        ImportOptionsKit &          UnsetDrawings();

        ImportOptionsKit&           UnsetConstraintsInfo();

        ImportOptionsKit &          UnsetFeatureTrees();

        ImportOptionsKit &          UnsetSewingTolerance();

        ImportOptionsKit &          UnsetComputePreferredOpenShellOrientation();

        ImportOptionsKit &          UnsetDefaultUnits();

        ImportOptionsKit &          UnsetMultiProcessCount();

        ImportOptionsKit &          UnsetPMISubstitutionFont();

        ImportOptionsKit &          UnsetPMIPrecision();

        ImportOptionsKit &          UnsetPMIDefaultUnits();

        ImportOptionsKit &          UnsetPMIDefaultColor();

        ImportOptionsKit &          UnsetTessellationLevel();

        ImportOptionsKit &          UnsetTessellationAccuracy();

        ImportOptionsKit &          UnsetTessellationCleanup();

        ImportOptionsKit &          UnsetPMIFlipping();

        ImportOptionsKit &          UnsetRemovedViews();

        ImportOptionsKit &          UnsetExternalProductOccurrence();

        ImportOptionsKit &          UnsetTessellationPreservesUVPoints();

        ImportOptionsKit &          UnsetTessellationMaximumEdgeLength();

        ImportOptionsKit &          UnsetTextureDirectories();

        ImportOptionsKit &          UnsetSearchDirectories();

        ImportOptionsKit &          UnsetSearchDirectoriesByFile();

        ImportOptionsKit &          UnsetSearchRootDirectory();

        ImportOptionsKit &          UnsetConfiguration();

        ImportOptionsKit &          UnsetCatiaV4LogicalNameForRootDirectory();

        ImportOptionsKit &          UnsetCatiaV4LogicalNameSearching();

        ImportOptionsKit &          UnsetCatiaV5Cache();

        ImportOptionsKit &          UnsetCatiaV5MaterialRendering();

        ImportOptionsKit &          UnsetUnigraphicsPreferredReferenceSets();

        ImportOptionsKit &          UnsetUnigraphicsFittedCamera();

        ImportOptionsKit &          UnsetProECodePageName();

        ImportOptionsKit &          UnsetProEDimensionTolerance();

        ImportOptionsKit &          UnsetProESubpartPMI();

        ImportOptionsKit &          UnsetProESessionColor();

        ImportOptionsKit &          UnsetProEDatum();

        ImportOptionsKit &          UnsetProEHomeView();

        ImportOptionsKit &          UnsetProEExplodedViews();

        ImportOptionsKit &          UnsetProEMissingBoolean();

        ImportOptionsKit &          UnsetProEMissingFlexibleComponent();

        ImportOptionsKit &          UnsetProEFamilyTreeSource();

        ImportOptionsKit &          UnsetProEConstructionEntities();

        ImportOptionsKit &          UnsetProESkeletons();

        ImportOptionsKit &          UnsetSTEPNamePreference();

        ImportOptionsKit &          UnsetSTEPFirstColorPreference();

        ImportOptionsKit &          UnsetSTEPCodePageName();

        ImportOptionsKit &          UnsetSTEPShellBasedSurfaceModelSplitting();

        ImportOptionsKit &          UnsetSTEPOrientationHealing();

        ImportOptionsKit &          UnsetSTEPValidationProperties();

        ImportOptionsKit &          UnsetIFCCodePageName();

        ImportOptionsKit &          UnsetIFCAttributeXMLFile();

        ImportOptionsKit &          UnsetIFCOwnerHistoryOptimization();

        ImportOptionsKit &          UnsetIFCFaceOptimization();

        ImportOptionsKit &          UnsetIFCEdges();

        ImportOptionsKit &          UnsetIFCMetadata();

        ImportOptionsKit &          UnsetIFCRelationships();

        ImportOptionsKit &          UnsetIFCOpenings();

        ImportOptionsKit &          UnsetPDF3DStreamIndex();

        ImportOptionsKit &          UnsetJTTessellationLevel();

        ImportOptionsKit&           UnsetSolidworksDisplayVisibleDatum();

        ImportOptionsKit &          UnsetInventorEmbeddedTessellation();

        ImportOptionsKit &          UnsetPRCReadHelper();

        ImportOptionsKit &          UnsetRhinoForceRenderedModeColors();

        ImportOptionsKit &          UnsetRevitPhysicalProperties();

        ImportOptionsKit &          UnsetAnnotationCaptureFitting();

        ImportOptionsKit &          UnsetLocation();

        ImportOptionsKit &          UnsetMode();

        ImportOptionsKit &          UnsetIncrementalComponentPaths();

        ImportOptionsKit &          UnsetNURBSConversion();

        ImportOptionsKit &          UnsetGeometryDefaultColor();

        /* Removes the large translation extraction setting.
        *   \return A reference to this ImportOptionsKit. */
        ImportOptionsKit &          UnsetLargeTranslationExtraction();

        ImportOptionsKit &          UnsetEverything();

        bool                        ShowBRepMode(BRepMode & out_mode) const;

        bool                        ShowSolids(bool & out_state) const;

        bool                        ShowSurfaces(bool & out_state) const;

        bool                        ShowWireframes(bool & out_state) const;

        bool                        ShowPMI(bool & out_state) const;

        bool                        ShowAttributes(bool & out_state) const;

        bool                        ShowHiddenObjects(bool & out_state) const;

        bool                        ShowConstructionAndReferences(bool & out_state) const;

        bool                        ShowActiveFilter(bool & out_state) const;

        bool                        ShowDrawings(bool & out_state) const;

        bool                        ShowConstraintsInfo(bool& out_state) const;

        bool                        ShowFeatureTrees(bool & out_state) const;

        bool                        ShowSewingTolerance(double & out_tolerance) const;

        bool                        ShowComputePreferredOpenShellOrientation(bool & out_state) const;

        bool                        ShowDefaultUnits(Units & out_units) const;

        bool                        ShowMultiProcessCount(unsigned int & out_count) const;

        bool                        ShowPMISubstitutionFont(UTF8 & out_font_name, bool & out_always_substitute) const;

        bool                        ShowPMIPrecision(size_t & out_precision) const;

        bool                        ShowPMIDefaultUnits(Units & out_units) const;

        bool                        ShowPMIDefaultColor(RGBColor & out_color, bool & out_override) const;

        bool                        ShowTessellationLevel(Tessellation::Type & out_type, Tessellation::Level & out_level, Tessellation::Chord::Limit & out_limit_type, double & out_limit, double & out_angle_tolerance) const;

        bool                        ShowTessellationAccuracy(Tessellation::Accuracy & out_type, bool & out_accurate_normals, bool & out_accurate_surface_curvatures, double & out_accurate_grid_maximum_stitch_length) const;

        bool                        ShowTessellationCleanup(bool & out_cleanup) const;

        bool                        ShowPMIFlipping(bool & out_pmi_flipping) const;

        bool                        ShowRemovedViews(bool & out_read_removed_views) const;

        bool                        ShowExternalProductOccurrence(bool & out_read_external_po) const;

        bool                        ShowTessellationPreservesUVPoints(bool & out_state) const;

        bool                        ShowTessellationMaximumEdgeLength(double & out_length) const;

        bool                        ShowTextureDirectories(UTF8Array & out_directories) const;

        bool                        ShowSearchDirectories(UTF8Array & out_directories, UTF8Array & out_logical_names, BoolArray & out_recurse_flags) const;

        bool                        ShowSearchDirectoriesByFile(UTF8Array & out_file_names) const;

        bool                        ShowSearchRootDirectory(bool & out_state, bool & out_recursive) const;

        bool                        ShowConfiguration(UTF8Array & out_configuration) const;

        bool                        ShowCatiaV4LogicalNameForRootDirectory(UTF8 & out_name) const;

        bool                        ShowCatiaV4LogicalNameSearching(bool & out_state) const;

        bool                        ShowCatiaV5Cache(bool & out_active, UTF8 & out_path) const;

        bool                        ShowCatiaV5MaterialRendering(bool & out_active) const;

        bool                        ShowUnigraphicsPreferredReferenceSets(UTF8Array & out_reference_sets, bool & out_apply_to_all_levels) const;

        bool                        ShowUnigraphicsFittedCamera(bool & out_state) const;

        bool                        ShowProECodePageName(UTF8 & out_name) const;

        bool                        ShowProEDimensionTolerance(bool & out_state) const;

        bool                        ShowProESubpartPMI(bool & out_state) const;

        bool                        ShowProESessionColor(ProE::SessionColor & out_type) const;

        bool                        ShowProEDatum(bool & out_state) const;

        bool                        ShowProEHomeView(bool & out_state) const;

        bool                        ShowProEExplodedViews(bool & out_state) const;

        bool                        ShowProEMissingBoolean(bool & out_state) const;

        bool                        ShowProEMissingFlexibleComponent(bool & out_state) const;

        bool                        ShowProEFamilyTableSource(ProE::FamilyTable & out_source) const;

        bool                        ShowProEConstructionEntities(ProE::ConstructionEntities & out_state) const;

        bool                        ShowProESkeletons(bool & out_state) const;

        bool                        ShowSTEPNamePreference(STEP::Field & out_field) const;

        bool                        ShowSTEPFirstColorPreference(bool & out_state) const;

        bool                        ShowSTEPCodePageName(UTF8 & out_name) const;

        bool                        ShowSTEPShellBasedSurfaceModelSplitting(bool & out_state) const;

        bool                        ShowSTEPOrientationHealing(bool & out_state) const;

        bool                        ShowSTEPValidationProperties(bool & out_state) const;

        bool                        ShowIFCCodePageName(UTF8 & out_name) const;

        bool                        ShowIFCAttributeXMLFile(UTF8 & out_filename) const;

        bool                        ShowIFCOwnerHistoryOptimization(bool & out_state) const;

        bool                        ShowIFCFaceOptimization(bool & out_state) const;

        bool                        ShowIFCEdges(bool & out_state) const;

        bool                        ShowIFCMetadata(bool & out_state) const;

        bool                        ShowIFCRelationships(bool & out_state) const;

        bool                        ShowIFCOpenings(bool & out_state) const;

        bool                        ShowPDF3DStreamIndex(size_t & out_index) const;

        bool                        ShowJTTessellationLevel(JT::TessellationLevel & out_tessellation_level) const;

        bool                        ShowSolidworksDisplayVisibleDatum(bool& out_state) const;
        
        bool                        ShowInventorEmbeddedTessellation(bool & out_state) const;

        bool                        ShowPRCReadHelper(bool & out_use_helper) const;

        bool                        ShowRhinoForceRenderedModeColors(bool & out_state) const;

        bool                        ShowRevitPhysicalProperties(Revit::PhysicalProperties & out_physical_properties) const;

        bool                        ShowAnnotationCaptureFitting(AnnotationCaptureFitting & out_fitting) const;

        bool                        ShowLocation(ComponentPath & out_path, MatrixKit & out_transform) const;

        bool                        ShowMode(ImportMode & out_mode) const;

        bool                        ShowIncrementalComponentPaths(HPS::ComponentPathArray & out_paths) const;

        bool                        ShowNURBSConversion(HPS::Exchange::NURBSConversionOptionsKit & out_nurbs_conversion_options) const;

        bool                        ShowGeometryDefaultColor(RGBAColor & out_color) const;

        /* Shows the large translation extraction setting.
        *   \param out_state Whether to extract large translations during an import.
        *   \param out_data_index The index at which the user data representing the extracted translation will be stored
        *   \return <span class='code'>true</span> if a large translation extraction setting was specified, <span class='code'>false</span> otherwise. */
        bool                        ShowLargeTranslationExtraction(bool & out_state, intptr_t & out_data_index) const;
    };

    class EXCHANGE_API Translation
    {
    public:
        enum class Healing
        {
            Off,                    
            On,                     
            OnlyIfNotParasolid,     
        };

        enum class AccurateEdges
        {
            Off,                    
            On,                     
            OnlyIfNotParasolid,     
        };

        enum class Simplification
        {
            Off,                    
            On,                     
            OnlyIfNotParasolid,     
        };

        enum class Merging
        {
            Off,                    
            On,                     
            OnlyIfNotParasolid,     
        };

    private:
        Translation();
    };

    class EXCHANGE_API TranslationOptionsKit : public SprocketKit
    {
        public:
        TranslationOptionsKit();

        TranslationOptionsKit(TranslationOptionsKit const & in_kit);

        TranslationOptionsKit(TranslationOptionsKit && in_that);

        TranslationOptionsKit & operator=(TranslationOptionsKit && in_that);

        virtual ~TranslationOptionsKit();

    static const HPS::Type staticType = HPS::Type::ExchangeTranslationOptionsKit;
        HPS::Type                       ObjectType() const { return staticType; }

        static TranslationOptionsKit    GetDefault();

        void                            Set(TranslationOptionsKit const & in_kit);

        void                            Show(TranslationOptionsKit & out_kit) const;

        TranslationOptionsKit &         operator=(TranslationOptionsKit const & in_kit);

        bool                            Empty() const;

        bool                            Equals(TranslationOptionsKit const & in_kit) const;

        bool                            operator==(TranslationOptionsKit const & in_kit) const;

        bool                            operator!=(TranslationOptionsKit const & in_kit) const;

        TranslationOptionsKit &         SetSolidsAsFaces(bool in_state);

        TranslationOptionsKit &         SetTessellation(bool in_state);

        TranslationOptionsKit &         SetHiddenObjects(bool in_state);

        TranslationOptionsKit &         SetApplication(char const * in_name);

        TranslationOptionsKit &         SetVersion(char const * in_version);

        TranslationOptionsKit&          SetExplodeMultiBodies(bool in_state);

        TranslationOptionsKit &         SetHealing(Translation::Healing in_healing);

        TranslationOptionsKit &         SetAccurateEdges(Translation::AccurateEdges in_accurate_edges);

        TranslationOptionsKit &         SetSimplification(Translation::Simplification in_simplification);

        TranslationOptionsKit &         SetEntityMerging(Translation::Merging in_merging);

        TranslationOptionsKit &         SetSewing(bool in_state, double in_tolerance = 0.0);

        TranslationOptionsKit &         SetDisjointFaces(bool in_state);

        TranslationOptionsKit &         UnsetSolidsAsFaces();

        TranslationOptionsKit &         UnsetTessellation();

        TranslationOptionsKit &         UnsetHiddenObjects();

        TranslationOptionsKit &         UnsetApplication();

        TranslationOptionsKit &         UnsetVersion();

        TranslationOptionsKit &         UnsetHealing();

        TranslationOptionsKit &         UnsetAccurateEdges();

        TranslationOptionsKit &         UnsetSimplification();

        TranslationOptionsKit &         UnsetEntityMerging();

        TranslationOptionsKit &         UnsetSewing();

        TranslationOptionsKit &         UnsetDisjointFaces();

        TranslationOptionsKit&          UnsetExplodeMultiBodies();

        TranslationOptionsKit &         UnsetEverything();


        bool                            ShowSolidsAsFaces(bool & out_state) const;

        bool                            ShowTessellation(bool & out_state) const;

        bool                            ShowHiddenObjects(bool & out_state) const;

        bool                            ShowApplication(UTF8 & out_name) const;

        bool                            ShowVersion(UTF8 & out_version) const;

        bool                            ShowExplodeMultiBodies(bool& out_state) const;

        bool                            ShowHealing(Translation::Healing & out_healing) const;

        bool                            ShowAccurateEdges(Translation::AccurateEdges & out_accurate_edges) const;

        bool                            ShowSimplification(Translation::Simplification & out_simplification) const;

        bool                            ShowEntityMerging(Translation::Merging & out_merging) const;

        bool                            ShowSewing(bool & out_state, double & out_tolerance) const;

        bool                            ShowDisjointFaces(bool & out_state) const;

        TranslationOptionsKit &         SetMultiProcessCount(unsigned int in_count);

        TranslationOptionsKit &         UnsetMultiProcessCount();

        bool                            ShowMultiProcessCount(unsigned int & out_count) const;
    };



    class EXCHANGE_API ModelFileImportOptionsKit : public SprocketKit
    {
    public:
        ModelFileImportOptionsKit();

        ModelFileImportOptionsKit(ModelFileImportOptionsKit const & in_kit);

        ModelFileImportOptionsKit(ModelFileImportOptionsKit && in_that);

        ModelFileImportOptionsKit & operator=(ModelFileImportOptionsKit && in_that);

        virtual ~ModelFileImportOptionsKit();

    static const HPS::Type staticType = HPS::Type::ExchangeModelFileImportOptionsKit;
        HPS::Type                           ObjectType() const { return staticType; }

        static ModelFileImportOptionsKit    GetDefault();

        void                                Set(ModelFileImportOptionsKit const & in_kit);

        void                                Show(ModelFileImportOptionsKit & out_kit) const;

        ModelFileImportOptionsKit &         operator=(ModelFileImportOptionsKit const & in_kit);

        bool                                Empty() const;

        bool                                Equals(ModelFileImportOptionsKit const & in_kit) const;

        bool                                operator==(ModelFileImportOptionsKit const & in_kit) const;

        bool                                operator!=(ModelFileImportOptionsKit const & in_kit) const;


        /* Dictates whether Visualize will flip pmi when rotating so that text / symbols remain readable.
        *   \note If exchange reports that a markup does not contain leader lines, but the tessellation does contain lines that markup will not be 
        *   flipped. This is a precaution for models where the leader line geometry was included as part of the markup tessellation and 
        *   flipping the geometry would cause any present leader lines to point in the wrong direction. 
        *   \param in_cleanup Whether or not to have visualize flip pmi when rotating.
        *   \return A reference to this ModelFileImportOptionsKit.
        */
        ModelFileImportOptionsKit &         SetPMIFlipping(bool in_flip);

        ModelFileImportOptionsKit &         SetTessellationLevel(Tessellation::Level in_level);

        ModelFileImportOptionsKit &         SetTessellationLevel(Tessellation::Chord::Limit in_limit_type, double in_limit, double in_angle_tolerance);

        ModelFileImportOptionsKit &         SetTessellationAccuracy(Tessellation::Accuracy in_type, bool in_accurate_normals = true, bool in_accurate_surface_curvatures = false, double accurate_grid_maximum_stitch_length = 0.0);

        /* Dictates whether Exchange tesselation data will be released from their parent representation items during import.
        *   \warning Setting this option to true will cause future exports to output without tessellation data.  
        *   \param in_cleanup Whether to clean up tessellation data from representation items.
        *   \return A reference to this ImportOptionsKit.
        */
        ModelFileImportOptionsKit &         SetTessellationCleanup(bool in_cleanup);

        ModelFileImportOptionsKit &         SetTessellationPreservesUVPoints(bool in_state);

        ModelFileImportOptionsKit &         SetTessellationMaximumEdgeLength(double in_length);

        ModelFileImportOptionsKit &         SetIFCEdges(bool in_state);

        ModelFileImportOptionsKit &         SetAnnotationCaptureFitting(AnnotationCaptureFitting in_fitting);

        ModelFileImportOptionsKit &         SetLocation(ComponentPath const & in_path, MatrixKit const & in_transform = MatrixKit());

        ModelFileImportOptionsKit &         SetSewingTolerance(double in_tolerance);

        ModelFileImportOptionsKit &         SetComputePreferredOpenShellOrientation(bool in_state);

        ModelFileImportOptionsKit &         SetNURBSConversion(HPS::Exchange::NURBSConversionOptionsKit const & in_nurbs_conversion_options);

        ModelFileImportOptionsKit &         SetGeometryDefaultColor(RGBAColor const & in_color);

        ModelFileImportOptionsKit &         SetHiddenObjects(bool in_state);

        ModelFileImportOptionsKit &         UnsetTessellationLevel();

        ModelFileImportOptionsKit &         UnsetTessellationAccuracy();

        ModelFileImportOptionsKit &         UnsetTessellationCleanup();

        ModelFileImportOptionsKit &         UnsetPMIFlipping();

        ModelFileImportOptionsKit &         UnsetTessellationPreservesUVPoints();

        ModelFileImportOptionsKit &         UnsetTessellationMaximumEdgeLength();

        ModelFileImportOptionsKit &         UnsetIFCEdges();

        ModelFileImportOptionsKit &         UnsetAnnotationCaptureFitting();

        ModelFileImportOptionsKit &         UnsetLocation();

        ModelFileImportOptionsKit &         UnsetSewingTolerance();

        ModelFileImportOptionsKit &         UnsetComputePreferredOpenShellOrientation();

        ModelFileImportOptionsKit &         UnsetNURBSConversion();

        ModelFileImportOptionsKit &         UnsetGeometryDefaultColor();

        ModelFileImportOptionsKit &         UnsetHiddenObjects();

        ModelFileImportOptionsKit &         UnsetEverything();


        bool                                ShowTessellationLevel(Tessellation::Type & out_type, Tessellation::Level & out_level, Tessellation::Chord::Limit & out_limit_type, double & out_limit, double & out_angle_tolerance) const;

        bool                        ShowTessellationAccuracy(Tessellation::Accuracy & out_type, bool & out_accurate_normals, bool & out_accurate_surface_curvatures, double & out_accurate_grid_maximum_stitch_length) const;

        bool                                ShowTessellationCleanup(bool & out_cleanup) const;

        bool                                ShowPMIFlipping(bool & out_pmi_flipping) const;

        bool                                ShowTessellationPreservesUVPoints(bool & out_state) const;

        bool                                ShowTessellationMaximumEdgeLength(double & out_length) const;

        bool                                ShowIFCEdges(bool & out_state) const;

        bool                                ShowAnnotationCaptureFitting(AnnotationCaptureFitting & out_fitting) const;

        bool                                ShowLocation(ComponentPath & out_path, MatrixKit & out_transform) const;

        bool                                ShowSewingTolerance(double & out_tolerance) const;


        bool                                ShowComputePreferredOpenShellOrientation(bool & out_state) const;

        bool                                ShowNURBSConversion(HPS::Exchange::NURBSConversionOptionsKit & out_nurbs_conversion_options) const;

        bool                                ShowGeometryDefaultColor(RGBAColor & out_color) const;

        bool                                ShowHiddenObjects(bool & out_state) const;
    };

#if TARGET_OS_ANDROID == 0 && TARGET_OS_IPHONE == 0

    class EXCHANGE_API Export3MFOptionsKit : public SprocketKit
    {
    public:
        Export3MFOptionsKit();

        Export3MFOptionsKit(Export3MFOptionsKit const & in_kit);

        Export3MFOptionsKit(Export3MFOptionsKit && in_that);

        virtual ~Export3MFOptionsKit();

    static const HPS::Type staticType = HPS::Type::ExchangeExport3MFOptionsKit;
        HPS::Type ObjectType() const { return staticType; }

        static Export3MFOptionsKit GetDefault();

        void Set(Export3MFOptionsKit const & in_kit);

        void Show(Export3MFOptionsKit& out_kit) const;

        Export3MFOptionsKit & operator=(Export3MFOptionsKit const & in_kit);

        Export3MFOptionsKit & operator=(Export3MFOptionsKit && in_that);

        bool                            Empty() const;

        bool                            Equals(Export3MFOptionsKit const & in_kit) const;

        bool                            operator==(Export3MFOptionsKit const & in_kit) const;

        bool                            operator!=(Export3MFOptionsKit const & in_kit) const;

        Export3MFOptionsKit &       SetAdditionalKeyPaths(KeyPathArray const & in_additional_key_paths);

        Export3MFOptionsKit &       SetAdditionalKeyPaths(size_t in_count, KeyPath const in_additional_key_paths[]);

        Export3MFOptionsKit &       UnsetAdditionalKeyPaths();

        bool                        ShowAdditionalKeyPaths(KeyPathArray & out_additional_key_paths) const;

        Export3MFOptionsKit & SetCurrentTessellationRetention(bool in_state, TessellationOptionsKit const & in_tessellation_kit = TessellationOptionsKit());

        Export3MFOptionsKit & UnsetCurrentTessellationRetention();

        bool ShowCurrentTessellationRetention(bool & out_state, Exchange::TessellationOptionsKit & out_tessellation_kit) const;

        Export3MFOptionsKit & SetDescription(char const * in_description);

        Export3MFOptionsKit & UnsetDescription();

        bool ShowDescription(HPS::UTF8 & out_state) const;

        Export3MFOptionsKit & SetCopyright(char const * in_state);

        Export3MFOptionsKit & UnsetCopyright();

        bool ShowCopyright(HPS::UTF8 & out_state) const;

        Export3MFOptionsKit & SetLicenseTerms(char const * in_license);

        Export3MFOptionsKit & UnsetLicenseTerms();

        bool ShowLicenseTerms(HPS::UTF8 & out_license) const;

        Export3MFOptionsKit & UnsetEverything();
    };  

    class EXCHANGE_API ExportFBXOptionsKit : public SprocketKit
    {
    public:
        ExportFBXOptionsKit();

        ExportFBXOptionsKit(ExportFBXOptionsKit const & in_kit);

        ExportFBXOptionsKit(ExportFBXOptionsKit && in_that);

        virtual ~ExportFBXOptionsKit();

    static const HPS::Type staticType = HPS::Type::ExchangeExportFBXOptionsKit;
        HPS::Type                       ObjectType() const { return staticType; }

        static ExportFBXOptionsKit      GetDefault();

        void                            Set(ExportFBXOptionsKit const & in_kit);

        void                            Show(ExportFBXOptionsKit & out_kit) const;

        ExportFBXOptionsKit &           operator=(ExportFBXOptionsKit const & in_kit);

        ExportFBXOptionsKit &           operator=(ExportFBXOptionsKit && in_that);

        bool                            Empty() const;

        bool                            Equals(ExportFBXOptionsKit const & in_kit) const;

        bool                            operator==(ExportFBXOptionsKit const & in_kit) const;

        bool                            operator!=(ExportFBXOptionsKit const & in_kit) const;


        ExportFBXOptionsKit &           SetTextureFolder(char const * in_name);


        ExportFBXOptionsKit &           SetAscii(bool in_state);


        ExportFBXOptionsKit &           UnsetTextureFolder();

        ExportFBXOptionsKit &           UnsetAscii();

        ExportFBXOptionsKit &           UnsetEverything();


        bool                            ShowTextureFolder(UTF8 & out_path) const;

        bool                            ShowAscii(bool & out_state) const;
    };

    class EXCHANGE_API ExportACISOptionsKit : public SprocketKit
    {
    public:
        ExportACISOptionsKit();

        ExportACISOptionsKit(ExportACISOptionsKit const & in_kit);

        ExportACISOptionsKit(ExportACISOptionsKit && in_that);

        virtual ~ExportACISOptionsKit();

    static const HPS::Type staticType = HPS::Type::ExchangeExportACISOptionsKit;
        HPS::Type                       ObjectType() const { return staticType; }

        static ExportACISOptionsKit     GetDefault();

        void                            Set(ExportACISOptionsKit const & in_kit);

        void                            Show(ExportACISOptionsKit & out_kit) const;

        ExportACISOptionsKit &          operator=(ExportACISOptionsKit const & in_kit);

        ExportACISOptionsKit &          operator=(ExportACISOptionsKit && in_that);

        bool                            Empty() const;

        bool                            Equals(ExportACISOptionsKit const & in_kit) const;

        bool                            operator==(ExportACISOptionsKit const & in_kit) const;

        bool                            operator!=(ExportACISOptionsKit const & in_kit) const;


        ExportACISOptionsKit &          SetMillimeterUnits(bool in_state);

        ExportACISOptionsKit &          SetBinary(bool in_state);


        ExportACISOptionsKit &          UnsetMillimeterUnits();

        ExportACISOptionsKit &          UnsetBinary();

        ExportACISOptionsKit &          UnsetEverything();


        bool                            ShowMillimeterUnits(bool & out_state) const;

        bool                            ShowBinary(bool & out_state) const;
    };

    class EXCHANGE_API ExportJTOptionsKit : public SprocketKit
    {
    public:
        ExportJTOptionsKit();

        ExportJTOptionsKit(ExportJTOptionsKit const & in_kit);

        ExportJTOptionsKit(ExportJTOptionsKit && in_that);

        virtual ~ExportJTOptionsKit();

    static const HPS::Type staticType = HPS::Type::ExchangeExportJTOptionsKit;
        HPS::Type                       ObjectType() const { return staticType; }

        static ExportJTOptionsKit       GetDefault();

        void                            Set(ExportJTOptionsKit const & in_kit);

        void                            Show(ExportJTOptionsKit & out_kit) const;

        ExportJTOptionsKit &            operator=(ExportJTOptionsKit const & in_kit);

        ExportJTOptionsKit &            operator=(ExportJTOptionsKit && in_that);

        bool                            Empty() const;

        bool                            Equals(ExportJTOptionsKit const & in_kit) const;

        bool                            operator==(ExportJTOptionsKit const & in_kit) const;

        bool                            operator!=(ExportJTOptionsKit const & in_kit) const;


        ExportJTOptionsKit &            SetContent(JT::Content in_content);

        ExportJTOptionsKit &            SetHiddenObjects(bool in_state);

        ExportJTOptionsKit &            SetPMI(bool in_state);

        ExportJTOptionsKit &            SetVersion(JT::Version in_version);


        ExportJTOptionsKit &            UnsetContent();

        ExportJTOptionsKit &            UnsetHiddenObjects();

        ExportJTOptionsKit &            UnsetPMI();

        ExportJTOptionsKit &            UnsetVersion();

        ExportJTOptionsKit &            UnsetEverything();


        bool                            ShowContent(JT::Content & out_content) const;

        bool                            ShowHiddenObjects(bool & out_state) const;

        bool                            ShowPMI(bool & out_state) const;

        bool                            ShowVersion(JT::Version & out_version) const;
    };

    class EXCHANGE_API ExportPRCOptionsKit : public SprocketKit
    {
    public:
        ExportPRCOptionsKit();

        ExportPRCOptionsKit(ExportPRCOptionsKit const & in_kit);

        ExportPRCOptionsKit(ExportPRCOptionsKit && in_that);

        virtual ~ExportPRCOptionsKit();

    static const HPS::Type staticType = HPS::Type::ExchangeExportPRCOptionsKit;
        HPS::Type                   ObjectType() const { return staticType; }

        static ExportPRCOptionsKit  GetDefault();

        void                        Set(ExportPRCOptionsKit const & in_kit);

        void                        Show(ExportPRCOptionsKit & out_kit) const;

        ExportPRCOptionsKit &       operator=(ExportPRCOptionsKit const & in_kit);

        ExportPRCOptionsKit &       operator=(ExportPRCOptionsKit && in_that);

        bool                        Empty() const;

        bool                        Equals(ExportPRCOptionsKit const & in_kit) const;

        bool                        operator==(ExportPRCOptionsKit const & in_kit) const;

        bool                        operator!=(ExportPRCOptionsKit const & in_kit) const;


        ExportPRCOptionsKit &       SetTessellationCompression(bool in_state);

        ExportPRCOptionsKit &       SetBRepCompression(PRC::BRepCompression in_level);

        ExportPRCOptionsKit &       SetBRepRemoval(bool in_state);

        ExportPRCOptionsKit &       SetAttributeRemoval(bool in_state);

        ExportPRCOptionsKit &       SetAdditionalKeyPaths(KeyPathArray const & in_additional_key_paths);

        ExportPRCOptionsKit &       SetAdditionalKeyPaths(size_t in_count, KeyPath const in_additional_key_paths []);


        ExportPRCOptionsKit &       UnsetTessellationCompression();

        ExportPRCOptionsKit &       UnsetBRepCompression();

        ExportPRCOptionsKit &       UnsetBRepRemoval();

        ExportPRCOptionsKit &       UnsetAttributeRemoval();

        ExportPRCOptionsKit &       UnsetAdditionalKeyPaths();

        ExportPRCOptionsKit &       UnsetEverything();


        bool                        ShowTessellationCompression(bool & out_state) const;

        bool                        ShowBRepCompression(PRC::BRepCompression & out_level) const;

        bool                        ShowBRepRemoval(bool & out_state) const;

        bool                        ShowAttributeRemoval(bool & out_state) const;

        bool                        ShowAdditionalKeyPaths(KeyPathArray & out_additional_key_paths) const;
    };

    class EXCHANGE_API ExportSTLOptionsKit : public SprocketKit
    {
    public:
        ExportSTLOptionsKit();

        ExportSTLOptionsKit(ExportSTLOptionsKit const & in_kit);

        ExportSTLOptionsKit(ExportSTLOptionsKit && in_that);

        virtual ~ExportSTLOptionsKit();

    static const HPS::Type staticType = HPS::Type::ExchangeExportSTLOptionsKit;
        HPS::Type                   ObjectType() const { return staticType; }

        static ExportSTLOptionsKit  GetDefault();

        void                        Set(ExportSTLOptionsKit const & in_kit);

        void                        Show(ExportSTLOptionsKit & out_kit) const;

        ExportSTLOptionsKit &       operator=(ExportSTLOptionsKit const & in_kit);

        ExportSTLOptionsKit &       operator=(ExportSTLOptionsKit && in_that);

        bool                        Empty() const;

        bool                        Equals(ExportSTLOptionsKit const & in_kit) const;

        bool                        operator==(ExportSTLOptionsKit const & in_kit) const;

        bool                        operator!=(ExportSTLOptionsKit const & in_kit) const;


        ExportSTLOptionsKit &       SetBinary(bool in_state);

        ExportSTLOptionsKit &       SetTessellationLevel(Tessellation::Level in_level);

        ExportSTLOptionsKit &       SetTessellationLevel(Tessellation::Chord::Limit in_limit_type, double in_limit, double in_angle_tolerance);

        ExportSTLOptionsKit &       SetTessellationAccuracy(Tessellation::Accuracy in_type);

        ExportSTLOptionsKit &       SetCurrentTessellationRetention(bool in_state);

        ExportSTLOptionsKit &       SetMaximumEdgeLength(double in_length);

        ExportSTLOptionsKit &       SetUnits(Units in_units);


        ExportSTLOptionsKit &       UnsetBinary();

        ExportSTLOptionsKit &       UnsetTessellationLevel();

        ExportSTLOptionsKit &       UnsetTessellationAccuracy();

        ExportSTLOptionsKit &       UnsetCurrentTessellationRetention();

        ExportSTLOptionsKit &       UnsetMaximumEdgeLength();

        ExportSTLOptionsKit &       UnsetUnits();

        ExportSTLOptionsKit &       UnsetEverything();


        bool                        ShowBinary(bool & out_state) const;

        bool                        ShowTessellationLevel(Tessellation::Type & out_type, Tessellation::Level & out_level, Tessellation::Chord::Limit & out_limit_type, double & out_limit, double & out_angle_tolerance) const;

        bool                        ShowTessellationAccuracy(Tessellation::Accuracy & out_type) const;

        bool                        ShowCurrentTessellationRetention(bool & out_state) const;

        bool                        ShowMaximumEdgeLength(double & out_length) const;

        bool                        ShowUnits(Units & out_units) const;
    };

    class EXCHANGE_API ExportOBJOptionsKit : public SprocketKit
    {
    public:
        ExportOBJOptionsKit();

        ExportOBJOptionsKit(ExportOBJOptionsKit const & in_kit);

        ExportOBJOptionsKit(ExportOBJOptionsKit && in_that);

        virtual ~ExportOBJOptionsKit();

        static const HPS::Type staticType = HPS::Type::ExchangeExportOBJOptionsKit;
        HPS::Type                   ObjectType() const { return staticType; }

        static ExportOBJOptionsKit  GetDefault();

        void                        Set(ExportOBJOptionsKit const & in_kit);

        void                        Show(ExportOBJOptionsKit & out_kit) const;

        ExportOBJOptionsKit &       operator=(ExportOBJOptionsKit const & in_kit);

        ExportOBJOptionsKit &       operator=(ExportOBJOptionsKit && in_that);

        bool                        Empty() const;

        bool                        Equals(ExportOBJOptionsKit const & in_kit) const;

        bool                        operator==(ExportOBJOptionsKit const & in_kit) const;

        bool                        operator!=(ExportOBJOptionsKit const & in_kit) const;

        ExportOBJOptionsKit &           SetTextureFolder(char const * in_name);

        bool                            ShowTextureFolder(UTF8 & out_path) const;

        ExportOBJOptionsKit &           UnsetTextureFolder();

        ExportOBJOptionsKit &           UnsetEverything();
    };

    class EXCHANGE_API ExportU3DOptionsKit : public SprocketKit
    {
    public:
        ExportU3DOptionsKit();

        ExportU3DOptionsKit(ExportU3DOptionsKit const & in_kit);

        ExportU3DOptionsKit(ExportU3DOptionsKit && in_that);

        virtual ~ExportU3DOptionsKit();

    static const HPS::Type staticType = HPS::Type::ExchangeExportU3DOptionsKit;
        HPS::Type                   ObjectType() const { return staticType; }

        static ExportU3DOptionsKit  GetDefault();

        void                        Set(ExportU3DOptionsKit const & in_kit);

        void                        Show(ExportU3DOptionsKit & out_kit) const;

        ExportU3DOptionsKit &       operator=(ExportU3DOptionsKit const & in_kit);

        ExportU3DOptionsKit &       operator=(ExportU3DOptionsKit && in_that);

        bool                        Empty() const;

        bool                        Equals(ExportU3DOptionsKit const & in_kit) const;

        bool                        operator==(ExportU3DOptionsKit const & in_kit) const;

        bool                        operator!=(ExportU3DOptionsKit const & in_kit) const;


        ExportU3DOptionsKit &       SetVersion(U3D::Version in_version);

        ExportU3DOptionsKit &       SetCompression(unsigned char in_level);


        ExportU3DOptionsKit &       UnsetVersion();

        ExportU3DOptionsKit &       UnsetCompression();

        ExportU3DOptionsKit &       UnsetEverything();


        bool                        ShowVersion(U3D::Version & out_version) const;

        bool                        ShowCompression(unsigned char & out_level) const;
    };

    class EXCHANGE_API ExportXMLOptionsKit : public SprocketKit
    {
    public:
        ExportXMLOptionsKit();

        ExportXMLOptionsKit(ExportXMLOptionsKit const & in_kit);

        ExportXMLOptionsKit(ExportXMLOptionsKit && in_that);

        virtual ~ExportXMLOptionsKit();

    static const HPS::Type staticType = HPS::Type::ExchangeExportXMLOptionsKit;
        HPS::Type                   ObjectType() const { return staticType; }

        static ExportXMLOptionsKit  GetDefault();

        void                        Set(ExportXMLOptionsKit const & in_kit);

        void                        Show(ExportXMLOptionsKit & out_kit) const;

        ExportXMLOptionsKit &       operator=(ExportXMLOptionsKit const & in_kit);

        ExportXMLOptionsKit &       operator=(ExportXMLOptionsKit && in_that);

        bool                        Empty() const;

        bool                        Equals(ExportXMLOptionsKit const & in_kit) const;

        bool                        operator==(ExportXMLOptionsKit const & in_kit) const;

        bool                        operator!=(ExportXMLOptionsKit const & in_kit) const;


        ExportXMLOptionsKit &       SetMetadata(bool in_state);

        ExportXMLOptionsKit &       SetTransformations(bool in_state);

        ExportXMLOptionsKit &       SetMaterials(bool in_state);


        ExportXMLOptionsKit &       UnsetMetadata();

        ExportXMLOptionsKit &       UnsetTransformations();

        ExportXMLOptionsKit &       UnsetMaterials();

        ExportXMLOptionsKit &       UnsetEverything();


        bool                        ShowMetadata(bool & out_state) const;

        bool                        ShowTransformations(bool & out_state) const;

        bool                        ShowMaterials(bool & out_state) const;
    };
#endif

#if !defined(TARGET_OS_ANDROID)

    class EXCHANGE_API ExportIGESOptionsKit : public SprocketKit
    {
    public:
        ExportIGESOptionsKit();

        ExportIGESOptionsKit(ExportIGESOptionsKit const & in_kit);

        ExportIGESOptionsKit(ExportIGESOptionsKit && in_that);

        virtual ~ExportIGESOptionsKit();

    static const HPS::Type staticType = HPS::Type::ExchangeExportIGESOptionsKit;
        HPS::Type                       ObjectType() const { return staticType; }

        static ExportIGESOptionsKit     GetDefault();

        void                            Set(ExportIGESOptionsKit const & in_kit);

        void                            Show(ExportIGESOptionsKit & out_kit) const;

        ExportIGESOptionsKit &          operator=(ExportIGESOptionsKit const & in_kit);

        ExportIGESOptionsKit &          operator=(ExportIGESOptionsKit && in_that);

        bool                            Empty() const;

        bool                            Equals(ExportIGESOptionsKit const & in_kit) const;

        bool                            operator==(ExportIGESOptionsKit const & in_kit) const;

        bool                            operator!=(ExportIGESOptionsKit const & in_kit) const;


        ExportIGESOptionsKit &          SetAnalyticsAsNURBS(bool in_state);

        ExportIGESOptionsKit &          SetFacetedAsWireframe(bool in_state);

        ExportIGESOptionsKit &          SetSolidsAsFaces(bool in_state);

        ExportIGESOptionsKit &          SetHiddenObjects(bool in_state);

        ExportIGESOptionsKit &          SetTessellation(bool in_state);

        ExportIGESOptionsKit &          SetApplication(char const * in_name);

        ExportIGESOptionsKit &          SetVersion(char const * in_version);


        ExportIGESOptionsKit &          UnsetAnalyticsAsNURBS();

        ExportIGESOptionsKit &          UnsetFacetedAsWireframe();

        ExportIGESOptionsKit &          UnsetSolidsAsFaces();

        ExportIGESOptionsKit &          UnsetHiddenObjects();

        ExportIGESOptionsKit &          UnsetTessellation();

        ExportIGESOptionsKit &          UnsetApplication();

        ExportIGESOptionsKit &          UnsetVersion();

        ExportIGESOptionsKit &          UnsetEverything();


        bool                            ShowAnalyticsAsNURBS(bool & out_state) const;

        bool                            ShowFacetedAsWireframe(bool & out_state) const;

        bool                            ShowSolidsAsFaces(bool & out_state) const;

        bool                            ShowHiddenObjects(bool & out_state) const;

        bool                            ShowTessellation(bool & out_state) const;

        bool                            ShowApplication(UTF8 & out_name) const;

        bool                            ShowVersion(UTF8 & out_version) const;
    };

    class EXCHANGE_API ExportParasolidOptionsKit : public SprocketKit
    {
    public:
        ExportParasolidOptionsKit();

        ExportParasolidOptionsKit(ExportParasolidOptionsKit const & in_kit);

        ExportParasolidOptionsKit(ExportParasolidOptionsKit && in_that);

        virtual ~ExportParasolidOptionsKit();

    static const HPS::Type staticType = HPS::Type::ExchangeExportParasolidOptionsKit;
        HPS::Type                           ObjectType() const { return staticType; }

        static ExportParasolidOptionsKit    GetDefault();

        void                                Set(ExportParasolidOptionsKit const & in_kit);

        void                                Show(ExportParasolidOptionsKit & out_kit) const;

        ExportParasolidOptionsKit &         operator=(ExportParasolidOptionsKit const & in_kit);

        ExportParasolidOptionsKit &         operator=(ExportParasolidOptionsKit && in_that);

        bool                                Empty() const;

        bool                                Equals(ExportParasolidOptionsKit const & in_kit) const;

        bool                                operator==(ExportParasolidOptionsKit const & in_kit) const;

        bool                                operator!=(ExportParasolidOptionsKit const & in_kit) const;


        ExportParasolidOptionsKit &         SetSolidsAsFaces(bool in_state);

        ExportParasolidOptionsKit &         SetTessellation(bool in_state);

        ExportParasolidOptionsKit &         SetHiddenObjects(bool in_state);

        ExportParasolidOptionsKit &         SetApplication(char const * in_name);

        ExportParasolidOptionsKit &         SetVersion(char const * in_version);

        ExportParasolidOptionsKit&          SetExplodeMultiBodies(bool in_state);

        ExportParasolidOptionsKit &         UnsetSolidsAsFaces();

        ExportParasolidOptionsKit &         UnsetTessellation();

        ExportParasolidOptionsKit &         UnsetHiddenObjects();

        ExportParasolidOptionsKit &         UnsetApplication();

        ExportParasolidOptionsKit &         UnsetVersion();

        ExportParasolidOptionsKit&          UnsetExplodeMultiBodies();

        ExportParasolidOptionsKit &         UnsetEverything();
        

        bool                                ShowSolidsAsFaces(bool & out_state) const;

        bool                                ShowTessellation(bool & out_state) const;

        bool                                ShowHiddenObjects(bool & out_state) const;

        bool                                ShowApplication(UTF8 & out_name) const;

        bool                                ShowVersion(UTF8 & out_version) const;

        bool                                ShowExplodeMultiBodies(bool& out_state) const;
    };

    class EXCHANGE_API ExportSTEPOptionsKit : public SprocketKit
    {
    public:
        ExportSTEPOptionsKit();

        ExportSTEPOptionsKit(ExportSTEPOptionsKit const & in_kit);

        ExportSTEPOptionsKit(ExportSTEPOptionsKit && in_that);

        virtual ~ExportSTEPOptionsKit();

    static const HPS::Type staticType = HPS::Type::ExchangeExportSTEPOptionsKit;
        HPS::Type                       ObjectType() const { return staticType; }

        static ExportSTEPOptionsKit     GetDefault();

        void                            Set(ExportSTEPOptionsKit const & in_kit);

        void                            Show(ExportSTEPOptionsKit & out_kit) const;

        ExportSTEPOptionsKit &          operator=(ExportSTEPOptionsKit const & in_kit);

        ExportSTEPOptionsKit &          operator=(ExportSTEPOptionsKit && in_that);

        bool                            Empty() const;

        bool                            Equals(ExportSTEPOptionsKit const & in_kit) const;

        bool                            operator==(ExportSTEPOptionsKit const & in_kit) const;

        bool                            operator!=(ExportSTEPOptionsKit const & in_kit) const;


        ExportSTEPOptionsKit &          SetFormat(STEP::Format in_format);

        ExportSTEPOptionsKit &          SetAnalyticsAsNURBS(bool in_state);

        ExportSTEPOptionsKit &          SetFacetedAsWireframe(bool in_state);

        ExportSTEPOptionsKit &          SetNameShortening(bool in_state);

        ExportSTEPOptionsKit &          SetApplication(char const * in_name);

        ExportSTEPOptionsKit &          SetVersion(char const * in_version);

        ExportSTEPOptionsKit &          SetPMI(bool in_state);

        ExportSTEPOptionsKit &          SetCurves(bool in_state);

        ExportSTEPOptionsKit &          SetAttributes(bool in_state);

        ExportSTEPOptionsKit &          SetPMIWithSemantic(bool in_state);

        ExportSTEPOptionsKit &          SetPMIAsTessellated(bool in_state);

        ExportSTEPOptionsKit &          UnsetFormat();

        ExportSTEPOptionsKit &          UnsetAnalyticsAsNURBS();

        ExportSTEPOptionsKit &          UnsetFacetedAsWireframe();

        ExportSTEPOptionsKit &          UnsetNameShortening();

        ExportSTEPOptionsKit &          UnsetApplication();

        ExportSTEPOptionsKit &          UnsetVersion();

        ExportSTEPOptionsKit &          UnsetPMI();

        ExportSTEPOptionsKit &          UnsetCurves();

        ExportSTEPOptionsKit &          UnsetAttributes();

        ExportSTEPOptionsKit &          UnsetPMIWithSemantic();

        ExportSTEPOptionsKit &          UnsetPMIAsTessellated();

        ExportSTEPOptionsKit &          UnsetEverything();


        bool                            ShowFormat(STEP::Format & out_format) const;

        bool                            ShowAnalyticsAsNURBS(bool & out_state) const;

        bool                            ShowFacetedAsWireframe(bool & out_state) const;

        bool                            ShowNameShortening(bool & out_state) const;

        bool                            ShowApplication(UTF8 & out_name) const;

        bool                            ShowVersion(UTF8 & out_version) const;

        bool                            ShowPMI(bool & out_state) const;

        bool                            ShowCurves(bool & out_state) const;

        bool                            ShowAttributes(bool & out_state) const;

        bool                            ShowPMIWithSemantic(bool & out_state) const;

        bool                            ShowPMIAsTessellated(bool & out_state) const;
    };

    class EXCHANGE_API ExportGLTFOptionsKit : public SprocketKit
    {
    public:
        ExportGLTFOptionsKit();

        ExportGLTFOptionsKit(ExportGLTFOptionsKit const & in_kit);

        ExportGLTFOptionsKit(ExportGLTFOptionsKit && in_that);

        virtual ~ExportGLTFOptionsKit();

        static const HPS::Type staticType = HPS::Type::ExchangeExportGLTFOptionsKit;
        HPS::Type                       ObjectType() const { return staticType; }

        static ExportGLTFOptionsKit     GetDefault();

        void                            Set(ExportGLTFOptionsKit const & in_kit);

        void                            Show(ExportGLTFOptionsKit & out_kit) const;

        ExportGLTFOptionsKit &          operator=(ExportGLTFOptionsKit const & in_kit);

        ExportGLTFOptionsKit &          operator=(ExportGLTFOptionsKit && in_that);

        bool                            Empty() const;

        bool                            Equals(ExportGLTFOptionsKit const & in_kit) const;

        bool                            operator==(ExportGLTFOptionsKit const & in_kit) const;

        bool                            operator!=(ExportGLTFOptionsKit const & in_kit) const;


        ExportGLTFOptionsKit &          SetTextureFolder(char const * in_name);


        ExportGLTFOptionsKit &          SetAscii(bool in_state);


        ExportGLTFOptionsKit &          UnsetTextureFolder();

        ExportGLTFOptionsKit &          UnsetAscii();

        ExportGLTFOptionsKit &          UnsetEverything();


        bool                            ShowTextureFolder(UTF8 & out_path) const;

        bool                            ShowAscii(bool & out_state) const;
    };
#endif

    class EXCHANGE_API TessellationOptionsKit : public SprocketKit
    {
    public:
        TessellationOptionsKit();

        TessellationOptionsKit(TessellationOptionsKit const & in_kit);

        TessellationOptionsKit(TessellationOptionsKit && in_that);

        virtual ~TessellationOptionsKit();

    static const HPS::Type staticType = HPS::Type::ExchangeTessellationOptionsKit;
        HPS::Type                       ObjectType() const { return staticType; }

        static TessellationOptionsKit   GetDefault();

        void                            Set(TessellationOptionsKit const & in_kit);

        void                            Show(TessellationOptionsKit & out_kit) const;

        TessellationOptionsKit &        operator=(TessellationOptionsKit const & in_kit);

        TessellationOptionsKit &        operator=(TessellationOptionsKit && in_that);

        bool                            Empty() const;

        bool                            Equals(TessellationOptionsKit const & in_kit) const;

        bool                            operator==(TessellationOptionsKit const & in_kit) const;

        bool                            operator!=(TessellationOptionsKit const & in_kit) const;


        TessellationOptionsKit &        SetLevel(Tessellation::Level in_level);

        TessellationOptionsKit &        SetLevel(Tessellation::Chord::Limit in_limit_type, double in_limit, double in_angle_tolerance);

        TessellationOptionsKit &        SetAccuracy(Tessellation::Accuracy in_type, bool in_accurate_normals = true, bool in_accurate_surface_curvatures = false, double in_accurate_grid_maximum_stitch_length = 0.0);

        TessellationOptionsKit &        SetUVPointPreservation(bool in_state);

        TessellationOptionsKit &        SetMaximumEdgeLength(double in_length);


        TessellationOptionsKit &        UnsetLevel();

        TessellationOptionsKit &        UnsetAccuracy();

        TessellationOptionsKit &        UnsetUVPointPreservation();

        TessellationOptionsKit &        UnsetMaximumEdgeLength();

        TessellationOptionsKit &        UnsetEverything();


        bool                            ShowLevel(Tessellation::Type & out_type, Tessellation::Level & out_level, Tessellation::Chord::Limit & out_limit_type, double & out_limit, double & out_angle_tolerance) const;

        bool                            ShowAccuracy(Tessellation::Accuracy & out_type, bool & out_accurate_normals, bool & out_accurate_surface_curvatures, double & out_accurate_grid_maximum_stitch_length) const;

        bool                            ShowUVPointPreservation(bool & out_state) const;

        bool                            ShowMaximumEdgeLength(double & out_length) const;
    };

    class EXCHANGE_API CommonMeasurementOperator : public Operator
    {
    public:
        enum class Tags
        {
            Name = 0,
            MeasurementType,
            Radius,
            Inverted,
            VectorX,
            VectorY,
            VectorZ,
        };

        CommonMeasurementOperator();

        CommonMeasurementOperator(Exchange::CADModel const & in_cad_model, MouseButtons in_mouse_trigger = MouseButtons::ButtonLeft(), ModifierKeys in_modifier_trigger = ModifierKeys());

        virtual HPS::UTF8 GetName() const override { return "HPS_ExchangeCommonMeasurementOperator"; }

        virtual void            OnViewAttached(HPS::View const & in_attached_view) override;
        virtual void            OnViewDetached(HPS::View const & in_detached_view) override;

        Exchange::CADModel GetCADModel() const;
        void SetCADModel(Exchange::CADModel const & in_cad_model);

        size_t              GetPrecision() const;

        void                SetPrecision(size_t in_precision);
        
        MaterialMappingKit  GetMaterial() const;

        void                SetMaterial(MaterialMappingKit const & in_material_mapping);

        TextAttributeKit    GetTextAttributes() const;

        void                SetTextAttribute(TextAttributeKit const & in_text_attributes);

        SegmentKey          GetMeasurementSegment() const;

        static UTF8         GetNewMeasurementSegmentName(HPS::UTF8 const & in_prefix);

        /* Deletes all measurements */
        void                DeleteMeasurements();

        class EXCHANGE_API MeasurementInsertedEvent : public HPS::Event
        {
        public:
            MeasurementInsertedEvent() : Event()
            {
                channel = GetClassID();
                consumable = false;
            }

            MeasurementInsertedEvent(HPS::Key const & in_measurement_key, HPS::View const & in_view) : Event()
            {
                channel = GetClassID();
                consumable = false;
                measurement_key = in_measurement_key;
                view = in_view;
            }

            MeasurementInsertedEvent(Event const & in_event) : Event(in_event)
            {
                if (in_event.GetChannel() == Object::ClassID<MeasurementInsertedEvent>())
                {
                    auto that = static_cast<MeasurementInsertedEvent const &>(in_event);
                    measurement_key = that.measurement_key;
                    view = that.view;
                }
                else
                    throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
            }

            ~MeasurementInsertedEvent();

            Event * Clone() const
 {
                MeasurementInsertedEvent * new_event = new MeasurementInsertedEvent(*this);
                return new_event;
            }

            Key measurement_key;
            View view;
        };

        class EXCHANGE_API MeasurementDeletedEvent : public HPS::Event
        {
        public:
            MeasurementDeletedEvent() : Event()
            {
                channel = GetClassID();
                consumable = false;
            }

            MeasurementDeletedEvent(HPS::UTF8 const & in_measurement_name, HPS::View const & in_view) : Event()
            {
                channel = GetClassID();
                consumable = false;
                measurement_name = in_measurement_name;
                view = in_view;
            }

            MeasurementDeletedEvent(Event const & in_event) : Event(in_event)
            {
                if (in_event.GetChannel() == Object::ClassID<MeasurementDeletedEvent>())
                {
                    auto that = static_cast<MeasurementDeletedEvent const &>(in_event);
                    measurement_name = that.measurement_name;
                    view = that.view;
                }
                else
                    throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
            }

            ~MeasurementDeletedEvent();

            Event * Clone() const
 {
                MeasurementDeletedEvent * new_event = new MeasurementDeletedEvent(*this);
                return new_event;
            }

            UTF8 measurement_name;
            View view;
        };

    protected:
        Exchange::CADModel  cad_model;
        size_t              measurement_precision;
        UTF8                units;
        MaterialMappingKit  materials;
        TextAttributeKit    text_attributes;
        SegmentKey          measurement_segment;
        GlyphDefinition     left_arrow;
        GlyphDefinition     right_arrow;
        SelectionOptionsKit selection_options;
        bool                manipulate_measurement;             //whether we are manipulating a previously entered measurement
        Vector              camera_direction;
        PortfolioKey        portfolio;
        SegmentKey          style_segment;
        HighlightOptionsKit highlight_options;

        static size_t       length_measurement_index;
        static size_t       radius_measurement_index;
        static size_t       distance_measurement_index;
        static size_t       angle_measurement_index;

        void Tag(HPS::Key & tag, const char * message, Tags tag_index);
        void GetUnits();
        void SetGlyphColor();
        void GetCameraDirection();
        void SetupConstructionSegment();
        void PositionLinearMeasurementGeometry(WindowPoint const & window_cursor_location, KeyPath const & event_path, LineKey & leader_line_one, LineKey & leader_line_two, 
            LineKey & measurement_line, LineKey & line_to_cursor, Point & original_point_one, Point & original_point_two, TextKey & text, UTF8 const & text_string,
            Point & distance_point_one, Point & distance_point_two, SegmentKey & current_measurement_segment, Plane const & measurement_plane = Plane(), Vector const & explicit_direction = Vector());
        float GetModelScale(Exchange::Component const & component);
        void SetMaterialsOnMeasurementSegment(HPS::SegmentKey const & set_materials_here, HPS::MaterialMappingKit const & materials_to_apply);
    };

    class EXCHANGE_API MeasurementOperator : public CommonMeasurementOperator
    {
    public:
        enum class MeasurementType
        {
            PointToPoint,
            EdgeAndRadius,
            FeatureToFeature,
            FaceAngle,
        };

        MeasurementOperator();

        MeasurementOperator(Exchange::CADModel const & in_cad_model, MouseButtons in_mouse_trigger = MouseButtons::ButtonLeft(), ModifierKeys in_modifier_trigger = ModifierKeys());

        virtual HPS::UTF8 GetName() const override{ return "HPS_ExchangeMeasurementOperator"; }

        virtual void OnViewAttached(HPS::View const & in_attached_view) override;
        virtual void OnViewDetached(HPS::View const & in_detached_view) override;

        virtual bool OnMouseDown(MouseState const & in_state) override;

        virtual bool OnMouseUp(MouseState const & in_state) override;

        virtual bool OnMouseMove(MouseState const & in_state) override;
    
        virtual bool OnTouchDown(TouchState const & in_state) override;
    
        virtual bool OnTouchUp(TouchState const & in_state) override;
    
        virtual bool OnTouchMove(TouchState const & in_state) override;

        virtual bool OnKeyDown(KeyboardState const & in_state) override;

        void SetMeasurementType(MeasurementType in_measurement_type);

        MeasurementType GetMeasurementType();

        void SetMouseOverHighlighting(bool in_highlighting);

        void SetMouseOverHighlighting(bool in_highlighting, HighlightOptionsKit const & in_highlight_options_kit);

        bool GetMouseOverHighlighting();

        HighlightOptionsKit GetHighlightOptions();

        bool IsMeasurementActive();

        void DeleteLastMeasurement();

    private:
        enum class EdgeType                                         //used to determine the type of edge measured when using the EdgeAndRadius measurement type
        {
            Circle,
            Line,
            Generic,
        };

        class Surface                                               //helper class containing surfaces properties. Used for the FeatureToFeature measurement type
        {
        public:
            Surface();

            enum class SurfaceType
            {
                Plane,
                ConeOrCylinder,
                Unsupported,
            };

            SurfaceType     surface_type;                           //the type of surface being measured
            Point           center;                                 //the center point of the surface
            Vector          normal;                                 //the center line of surfaces of type Cylinder or Cone
            LineKey         normal_points;                          //the line representing the center line of surfaces of type Cylinder or Cone
            ComponentPath   path;                                   //the ComponentPath to this surface
        };

        //bookkeeping
        MeasurementType     measurement_type;                       //the type of measurement to be inserted
        MeasurementType     temporary_measurement_type;             //the type of the measurement to be edited
        TouchID             tracked_touch_id;                       //the ID of the touch to track for OnTouchMove operations
        TouchID             current_touch_id;                       //the ID of the touch being processed
        SegmentKey          current_measurement;                    //segment of the measurement being inserted / edited
        bool                operator_active;                        //whether a measurement is in progress
        bool                end_measurement;                        //whether we should end the current measurement
        CanvasArray         canvases;                               //canvases related to the view where this operator is attached

        //measurement anchors
        size_t              anchors;                                //valid for point-to-point and face-angle measurements
        bool                anchors_in_place;                       //true if all the anchors have been placed
        Point               first_click_position;                   //position of the first anchor
        Point               second_click_position;                  //position of the second anchor

        //geometry for linear measurements
        MarkerKey           anchor_one;                             //marker corresponding to the start of the measurement
        MarkerKey           anchor_two;                             //marker corresponding to the end of the measurement
        LineKey             distance_line;                          //a line representing the distance measured
        LineKey             leader_line_one;                        //line connecting the first anchor point to the distance line
        LineKey             leader_line_two;                        //line connecting the second anchor point to the distance line
        Point               distance_point_one;                     //intersection of leader_line_one and distance_line
        Point               distance_point_two;                     //intersection of leader_line_two and distance_line
        LineKey             line_to_cursor;                         //line extending from distance_point_one to the cursor
        TextKey             text;                                   //text representing the measurement and units
        UTF8                text_string;                            //the contents of the text
        Vector              measurement_direction;                  //the direction of the measurement
        bool                use_explicit_direction;                 //if true, we are moving the measurement along a specific vector, called explicit_direction
        Vector              explicit_direction;                     //used if use_explicit_direction is true

        //geometry for radius measurement
        MarkerKey           center_marker;                          //marker representing the center of the circle
        Point               circle_center;                          //circle center
        float               radius;                                 //circle radius

        //edge specific data
        LineKey             edge_line;                              //the edge being measured
        double              edge_length;                            //length of the measured edge
        EdgeType            edge_type;                              //the type of edge being measured

        //feature-to-feature specific data
        Surface             surface_one;                            //data related to first selected surface
        Surface             surface_two;                            //data related to second selected surface
        Plane               measurement_plane;                      //the measurement plane
        LineKey             current_normal;                         //the center line of surfaces of type Cone and Cylinder

        //angle specific data
        Vector              leader_line_one_direction;              //the direction of the first leader line
        Vector              leader_line_two_direction;              //the direction of the second leader line
        Vector              first_face_normal;                      //the normal of the first selected face
        Vector              second_face_normal;                     //the normal of the second selected face
        bool                inverted_measurement;                   //the smallest of the two possible angles is always chosen. If the user wants the other angle, the measurement is marked as 'inverted'
        CircularArcKey      measurement_arc;                        //an arc representing the measured angle
        LineKey             line_to_leader_line;                    //line extending from one anchor to a leader line
        Vector              mid_point_direction;

        //selection kits
        SelectionOptionsKit point_to_point_selection;
        SelectionOptionsKit edge_radius_selection;
        SelectionOptionsKit feature_to_feature_selection;
        SelectionOptionsKit angle_selection;

        //highlighting
        bool                highlight_on_mouse_over;                //whether measurable geometry should be highlighted on mouse over
        HighlightOptionsKit mouse_over_highlight_options;           //the options used for mouse over highlighting
        HighlightOptionsKit edit_measurement_highlight_options;     //the options used for highlighting measurements while editing them
        UpdateNotifier      highlight_update_notifier;              //notifier used to know if the last highlight update has completed
        KeyPath             highlighted_path;                       //highlighted_path
        bool                disable_highlighting;                   //in some situation we temporarily disable highlighting to improve performance
        bool Highlight(MeasurementType in_measurement_type, WindowPoint const & in_location, WindowKey & in_window, KeyPath const & in_path);

        //input handling
        bool InputDown(WindowPoint const & in_location, WindowKey & in_window, KeyPath const & in_path, size_t number_of_clicks);
        bool InputMove(WindowPoint const & in_location, KeyPath const & in_path);
        bool InputUp(WindowKey & in_window);
        void ResetMeasurement();

        //inserting measurements
        void InsertPointToPointMeasurement(Point const & in_world_point);
        bool InsertEdgeRadiusMeasurement(KeyPath const & in_selection_path, WindowPoint & in_selection_position, Key const & in_edge_key);
        bool InsertFeatureToFeatureMeasurement(KeyPath const & in_selection_path, WindowPoint & in_selection_position, Key const & in_face_key, WindowKey & in_window);
        void InsertFeatureToFeatureGeometry(Point const & point_one, Point const & point_two, float distance);
        bool InsertAngleMeasurement(KeyPath const & in_selection_path, WindowPoint & in_selection_position, Key const & in_face_key, WindowKey & in_window, SelectionResults const & in_selection_results);
        void InvertMeasuredAngle(WindowKey & in_window);
        void AdjustLineToCursor(Point const & cursor_position);

        //saving measurements
        void TagMeasurement();
        void TagPointToPointMeasurement();
        void TagEdgeMeasurement();
        void TagRadiusMeasurement();
        void TagGenericEdgeMeasurement();
        void TagFeatureToFeatureMeasurement();
        void TagAngleMeasurement();

        //restoring measurements
        void RestoreMeasurement(SegmentKey const & measurement_segment);
        void RestorePointToPointMeasurement(SegmentKey const & measurement_segment);
        void RestoreEdgeMeasurement(SegmentKey const & measurement_segment);
        void RestoreRadiusMeasurement(SegmentKey const & measurement_segment);
        void RestoreGenericEdgeMeasurement(SegmentKey const & measurement_segment);
        void RestoreFeatureToFeatureMeasurement(SegmentKey const & measurement_segment);
        void RestoreAngleMeasurement(SegmentKey const & measurement_segment);

        //topology functions
        void GetEdgeLengthAndType(Exchange::Component const & edge_component);
        void GetSurfaceType(Exchange::Component const & face_component, Surface & surface);
        void PlaneToCenterLineDistance();
        void PlaneToPlaneDistance();
        void LineToLineDistance();
        float LineSegmentDistance(Point & p0, Point & p1, Point & q0, Point & q1, LineKey & normal_one, LineKey & normal_two, Point & out_point_on_edge, Point & out_point_on_center_line, bool clamp = true);
        Point ClosestPointOnTriangleToPoint(Point const & p, Point const & a, Point const & b, Point const & c);
        float ClosestPointSegmentSegment(Point const & p1, Point const & q1, Point const & p2, Point const & q2, Point & c1, Point & c2);
        bool IsPlane(Exchange::Component const & face_component);
        Point GetPlaneIntersection(Plane const & in_plane, KeyPath const & in_key_path, WindowPoint const & in_window_point);
    };

private:
    Exchange();
};

}

#endif