sprk.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_H
#define SPRK_H

#include "hps.h"

#include <memory>
#include <unordered_map>

#ifdef _MSC_VER
#   pragma warning(disable: 4251) //Not an issue as long as debug and release libraries aren't mixed
#ifndef STATIC_APP
#   ifdef SPRK
#       define SPRK_API __declspec (dllexport)
#   else
#       define SPRK_API __declspec (dllimport)
#   endif
#endif
#else
#   include <stddef.h>
#   if defined(LINUX_SYSTEM) && defined(SPRK)
#       ifndef STATIC_APP
#           define SPRK_API __attribute__ ((visibility ("default")))
#       endif
#   endif
#endif

#ifndef SPRK_API
#   define SPRK_API
#endif
namespace SPRKI
{
    class X;
};

namespace HPS
{

class Factory;
class Canvas;
class Layout;
class View;
class Model;
class Operator;
class OperatorControl;
class AnimationControl;
class NavigationCubeControl;
class AxisTriadControl;
class Component;
class ComponentPath;
class ComponentHighlightEvent;
class Filter;
class Capture;
class CADModel;
class Metadata;
class Sampler;
class Channel;
class Animation;

class SPRK_API Sprocket : public HPS::Object
{
public:
    Sprocket() {}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
    Sprocket(HPS::Sprocket const & in_that) = default;
#endif
    Sprocket(Sprocket && in_that) : HPS::Object(std::move(in_that)) {}

    virtual ~Sprocket() {}
};

struct SPRK_API RGBColorKeyframe
{
    RGBColorKeyframe(uint32_t in_ticks, RGBColor const & in_value);

    bool                    operator!=(RGBColorKeyframe const & in_that) const;

    bool                    operator==(RGBColorKeyframe const & in_that) const;

    uint32_t time_in_ticks;
    RGBColor value;
};

struct SPRK_API RGBColorSplineControlValues
{
    RGBColorSplineControlValues(RGBColor const & in_input, RGBColor const & in_output);

    bool                    operator!=(RGBColorSplineControlValues const & in_that) const;

    bool                    operator==(RGBColorSplineControlValues const & in_that) const;

    RGBColor input;
    RGBColor output;
};

struct SPRK_API VectorKeyframe
{
    VectorKeyframe(uint32_t in_ticks, Vector const & in_value);

    bool                    operator!=(VectorKeyframe const & in_that) const;

    bool                    operator==(VectorKeyframe const & in_that) const;

    uint32_t time_in_ticks;
    Vector value;
};

struct SPRK_API VectorSplineControlValues
{
    VectorSplineControlValues(Vector const & in_input, Vector const & in_output);

    bool                    operator!=(VectorSplineControlValues const & in_that) const;

    bool                    operator==(VectorSplineControlValues const & in_that) const;

    Vector input;
    Vector output;
};

struct SPRK_API PointKeyframe
{
    PointKeyframe(uint32_t in_ticks, Point const & in_value);

    bool                    operator!=(PointKeyframe const & in_that) const;

    bool                    operator==(PointKeyframe const & in_that) const;

    uint32_t time_in_ticks;
    Point value;
};

struct SPRK_API PointSplineControlValues
{
    PointSplineControlValues(Point const & in_input, Point const & in_output);

    bool                    operator!=(PointSplineControlValues const & in_that) const;

    bool                    operator==(PointSplineControlValues const & in_that) const;

    Point input;
    Point output;
};

struct SPRK_API QuaternionKeyframe
{
    QuaternionKeyframe(uint32_t in_ticks, Quaternion const & in_value);

    bool                    operator!=(QuaternionKeyframe const & in_that) const;

    bool                    operator==(QuaternionKeyframe const & in_that) const;

    uint32_t time_in_ticks;
    Quaternion value;
};

struct SPRK_API QuaternionSplineControlValues
{
    QuaternionSplineControlValues(Quaternion const & in_input, Quaternion const & in_output);

    bool                    operator!=(QuaternionSplineControlValues const & in_that) const;

    bool                    operator==(QuaternionSplineControlValues const & in_that) const;

    Quaternion input;
    Quaternion output;
};

struct SPRK_API FloatKeyframe
{
    FloatKeyframe(uint32_t in_ticks, float in_value);

    bool                    operator!=(FloatKeyframe const & in_that) const;

    bool                    operator==(FloatKeyframe const & in_that) const;

    uint32_t time_in_ticks;
    float value;
};

struct SPRK_API FloatSplineControlValues
{
    FloatSplineControlValues(float in_input, float in_output);

    bool                    operator!=(FloatSplineControlValues const & in_that) const;

    bool                    operator==(FloatSplineControlValues const & in_that) const;

    float input;
    float output;
};

typedef std::shared_ptr<Operator>                                       OperatorPtr; 

typedef std::vector<OperatorPtr, Allocator<OperatorPtr> >               OperatorPtrArray;

typedef std::vector<Canvas, Allocator<Canvas> >                         CanvasArray;
typedef std::vector<Layout, Allocator<Layout> >                         LayoutArray;
typedef std::vector<View, Allocator<View> >                             ViewArray;
typedef std::vector<Model, Allocator<Model> >                           ModelArray;

typedef std::vector<Component, Allocator<Component> >                   ComponentArray;
typedef std::vector<Metadata, Allocator<Metadata> >                     MetadataArray;
typedef std::vector<Filter, Allocator<Filter> >                         FilterArray;
typedef std::vector<Capture, Allocator<Capture> >                       CaptureArray;
typedef std::vector<CADModel, Allocator<CADModel> >                     CADModelArray;
typedef std::vector<ReferenceKeyArray, Allocator<ReferenceKeyArray>>    ReferenceKeyArrayArray;
typedef std::vector<ComponentPath, Allocator<ComponentPath>>            ComponentPathArray;
typedef std::vector<HighlightOptionsKit, Allocator<HighlightOptionsKit>> HighlightOptionsKitArray;

typedef std::vector<Sampler, Allocator<Sampler> > SamplerArray;
typedef std::vector<Channel, Allocator<Channel> > ChannelArray;
typedef std::vector<Animation, Allocator<Animation> > AnimationArray;
typedef std::vector<VectorKeyframe, Allocator<VectorKeyframe> > VectorKeyframeArray;
typedef std::vector<PointKeyframe, Allocator<PointKeyframe> > PointKeyframeArray;
typedef std::vector<FloatKeyframe, Allocator<FloatKeyframe> > FloatKeyframeArray;
typedef std::vector<QuaternionKeyframe, Allocator<QuaternionKeyframe> > QuaternionKeyframeArray;
typedef std::vector<RGBColorKeyframe, Allocator<RGBColorKeyframe> > RGBColorKeyframeArray;

typedef std::vector<VectorSplineControlValues, Allocator<VectorSplineControlValues>> VectorSplineControlValuesArray;
typedef std::vector<PointSplineControlValues, Allocator<PointSplineControlValues>> PointSplineControlValuesArray;
typedef std::vector<FloatSplineControlValues, Allocator<FloatSplineControlValues>> FloatSplineControlValuesArray;
typedef std::vector<QuaternionSplineControlValues, Allocator<QuaternionSplineControlValues>> QuaternionSplineControlValuesArray;
typedef std::vector<RGBColorSplineControlValues, Allocator<RGBColorSplineControlValues>> RGBColorSplineControlValuesArray;
/* Sampler is an abstract class which is contains settings common to all kinds of Samplers.
 * A Sampler is an object that contains a series of Keyframes and which describe how the Animation will interpolate
 * between the values specified in the Keyframes.
 * Objects of the Sampler class should not be instantiated directly, rather, users should created objects of type
 * FloatSampler, VectorSampler, PointSampler or RGBColorSampler, based on the type of data required by the Channel to which the Sampler
 * will be assigned. */
class SPRK_API Sampler : public Sprocket
{
public:
    enum class InterpolationType
    {
        Constant,           
        Linear,             
        SphericalLinear,    
        Spline              
    };

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

    Sampler();
    Sampler(Sampler const & in_that);
    virtual ~Sampler();

    void                    Assign(Sampler const & in_that);
    Sampler &               operator=(Sampler const & in_that);
    Sampler &               operator=(Sampler && in_that);

    bool                    Equals(Sampler const & in_that) const;

    bool                    operator!=(Sampler const & in_that) const;

    bool                    operator==(Sampler const & in_that) const;

    void SetInterpolation(InterpolationType in_interpolation);

    InterpolationType GetInterpolation() const;
};

/* A RGBColorSampler is a type of Sampler which holds Keyframe which specify values as RGBColors.
 * For example, if a Channel is setup to animate the color of a target segment, the values assumed by that
 * color will have to be specified as RGBColors, and therefore be held in RGBColorKeyframes, which will be collected
 * in a RGBColorSampler. */
class SPRK_API RGBColorSampler : public Sampler
{
public:
    static const HPS::Type  staticType = HPS::Type::RGBColorSampler;
    HPS::Type               ObjectType() const { return staticType; }

    RGBColorSampler();
    explicit RGBColorSampler(Sampler const & in_that);
    RGBColorSampler(RGBColorSampler const & in_that);
    virtual ~RGBColorSampler();

    void                       SetKeyframes(RGBColorKeyframeArray const & in_keyframes);

    void                        SetKeyframes(size_t in_count, RGBColorKeyframe const in_keyframes[]);

    void                        AddKeyframes(RGBColorKeyframeArray const & in_keyframes);

    void                        AddKeyframes(size_t in_count, RGBColorKeyframe const in_keyframes[]);

    void                        AddKeyframe(RGBColorKeyframe const & in_keyframe);

    RGBColorKeyframeArray const & GetKeyframes() const;

    void                       SetControlValues(RGBColorSplineControlValuesArray const & in_control_points);

    RGBColorSplineControlValuesArray const &           GetControlValues() const;
};

/* A VectorSampler is a type of Sampler which holds Keyframe which specify values as Vectors.
 * For example, if a Channel is setup to animate the value of the camera's up vector, the values assumed by the
 * up vector will have to be specified as Vectors, and therefore be held in VectorKeyframes, which will be collected
 * in a VectorSampler. */
class SPRK_API VectorSampler : public Sampler
{
public:
    static const HPS::Type  staticType = HPS::Type::VectorSampler;
    HPS::Type               ObjectType() const { return staticType; }

    VectorSampler();
    explicit VectorSampler(Sampler const & in_that);
    VectorSampler(VectorSampler const & in_that);
    virtual ~VectorSampler();

    void                       SetKeyframes(VectorKeyframeArray const & in_keyframes);

    void                        SetKeyframes(size_t in_count, VectorKeyframe const in_keyframes[]);

    void                        AddKeyframes(VectorKeyframeArray const & in_keyframes);

    void                        AddKeyframes(size_t in_count, VectorKeyframe const in_keyframes[]);

    void                        AddKeyframe(VectorKeyframe const & in_keyframe);

    VectorKeyframeArray const & GetKeyframes() const;

    void                       SetControlValues(VectorSplineControlValuesArray const & in_control_points);

    VectorSplineControlValuesArray const &         GetControlValues() const;
};

/* A PointSampler is a type of Sampler which holds Keyframe which specify values as Points.
 * For example, if a Channel is setup to animate the value of the camera's target, the values assumed by the
 * camera target will have to be specified as Points, and therefore be held in PointKeyframes, which will be collected
 * in a PointSampler. */
class SPRK_API PointSampler : public Sampler
{
public:
    static const HPS::Type  staticType = HPS::Type::PointSampler;
    HPS::Type               ObjectType() const { return staticType; }

    PointSampler();
    explicit PointSampler(Sampler const & in_that);
    PointSampler(PointSampler const & in_that);
    virtual ~PointSampler();

    void                       SetKeyframes(PointKeyframeArray const & in_keyframes);

    void                        SetKeyframes(size_t in_count, PointKeyframe const in_keyframes[]);

    void                        AddKeyframes(PointKeyframeArray const & in_keyframes);

    void                        AddKeyframes(size_t in_count, PointKeyframe const in_keyframes[]);

    void                        AddKeyframe(PointKeyframe const & in_keyframe);

    PointKeyframeArray const & GetKeyframes() const;

    void                       SetControlValues(PointSplineControlValuesArray const & in_control_points);

    PointSplineControlValuesArray const &          GetControlValues() const;
};

/* A QuaternionSampler is a type of Sampler which holds Keyframe which specify values as Quaternions.
 * For example, if a Channel is setup to animate the value of the camera's target, the values assumed by the
 * camera target will have to be specified as Quaternions, and therefore be held in QuaternionKeyframes, which will be collected
 * in a QuaternionSampler. */
class SPRK_API QuaternionSampler : public Sampler
{
public:
    static const HPS::Type  staticType = HPS::Type::QuaternionSampler;
    HPS::Type               ObjectType() const { return staticType; }

    QuaternionSampler();
    explicit QuaternionSampler(Sampler const & in_that);
    QuaternionSampler(QuaternionSampler const & in_that);
    virtual ~QuaternionSampler();

    void                       SetKeyframes(QuaternionKeyframeArray const & in_keyframes);

    void                        SetKeyframes(size_t in_count, QuaternionKeyframe const in_keyframes[]);

    void                        AddKeyframes(QuaternionKeyframeArray const & in_keyframes);

    void                        AddKeyframes(size_t in_count, QuaternionKeyframe const in_keyframes[]);

    void                        AddKeyframe(QuaternionKeyframe const & in_keyframe);

    QuaternionKeyframeArray const & GetKeyframes() const;

    void                       SetControlValues(QuaternionSplineControlValuesArray const & in_control_points);

    QuaternionSplineControlValuesArray const &    GetControlValues() const;
};

/* A FloatSampler is a type of Sampler which holds Keyframe which specify values as floats.
 * For example, if a Channel is setup to animate the target's opacity, the target's alpha channel value
 * will be specified in floats, and therefore be held in FloatKeyframes, which will be collected
 * in a FloatSampler. */
class SPRK_API FloatSampler : public Sampler
{
public:
    static const HPS::Type  staticType = HPS::Type::FloatSampler;
    HPS::Type               ObjectType() const { return staticType; }

    FloatSampler();
    explicit FloatSampler(Sampler const & in_that);
    FloatSampler(FloatSampler const & in_that);
    virtual ~FloatSampler();

    void                        SetKeyframes(FloatKeyframeArray const & in_keyframes);

    void                        SetKeyframes(size_t in_count, FloatKeyframe const in_keyframes[]);

    void                        AddKeyframes(FloatKeyframeArray const & in_keyframes);

    void                        AddKeyframes(size_t in_count, FloatKeyframe const in_keyframes[]);

    void                        AddKeyframe(FloatKeyframe const & in_keyframe);

    FloatKeyframeArray const &  GetKeyframes() const;

    void                       SetControlValues(FloatSplineControlValuesArray const & in_control_points);

    FloatSplineControlValuesArray const &          GetControlValues() const;
};

class SPRK_API Channel : public Sprocket
{
public:
    enum class ChannelType
    {
        Translation,    
        Rotation,       
        Scale,          
        Color,          
        Opacity,        
        CameraPosition, 
        CameraTarget,   
        CameraUp        
    };

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

    Channel();
    Channel(Channel const & in_that);
    ~Channel();

    void                    Assign(Channel const & in_that);
    Channel &               operator=(Channel const & in_that);
    Channel &               operator=(Channel && in_that);

    bool                    Equals(Channel const & in_that) const;

    bool                    operator!=(Channel const & in_that) const;

    bool                    operator==(Channel const & in_that) const;

    KeyPath const &         GetTarget() const;

    Sampler const &         GetSampler() const;

    Sampler &               GetSampler();

    UTF8 &                  GetName() const;

    ChannelType             GetChannelType() const;

    void                    SetSampler(Sampler const & sampler);
};

class SPRK_API Animation : public Sprocket
{
public:
    static const HPS::Type  staticType = HPS::Type::Animation;
    HPS::Type               ObjectType() const { return staticType; }

    Animation();
    Animation(Animation const & in_that);
    ~Animation();

    void                    Assign(Animation const & in_that);
    Animation &             operator=(Animation const & in_that);
    Animation &             operator=(Animation && in_that);

    bool                    Equals(Animation const & in_that) const;

    bool                    operator!=(Animation const & in_that) const;

    bool                    operator==(Animation const & in_that) const;

    Channel                 AddTranslationChannel(char const * in_name, KeyPath const & in_target, VectorSampler const & in_sampler);

    Channel                 AddRotationChannel(char const * in_name, KeyPath const & in_target, QuaternionSampler const & in_sampler);

    Channel                 AddScaleChannel(char const * in_name, KeyPath const & in_target, VectorSampler const & in_sampler);

    Channel                 AddColorChannel(char const * in_name, KeyPath const & in_target, RGBColorSampler const & in_sampler);

    Channel                 AddOpacityChannel(char const * in_name, KeyPath const & in_target, FloatSampler const & in_sampler);

    Channel                 AddCameraPositionChannel(char const * in_name, PointSampler const & in_sampler);

    Channel                 AddCameraTargetChannel(char const * in_name, PointSampler const & in_sampler);

    Channel                 AddCameraUpChannel(char const * in_name, VectorSampler const & in_sampler);

    void                    RemoveChannel(Channel & in_channel);

    /* Returns a list of Channels currently associated with this Animation.
     * \return a list of Channels currently associated with this Animation. */
    ChannelArray const &    GetChannels() const;

    /* Returns the name given to this Animation when it was created.
     * \return The name of this Animation. */
    UTF8 const &            GetName() const;

    void                    Delete();
};

class SPRK_API Canvas : public Sprocket
{
public:
    Canvas();
    Canvas(Canvas const & that);
    ~Canvas();

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

    void                    Delete();

    Canvas &                operator=(Canvas const & in_that);
    void                    Assign(Canvas const & in_that);

    bool                    Equals(Canvas const & in_that) const;
    bool                    operator!= (Canvas const & in_that) const;
    bool                    operator== (Canvas const & in_that) const;

    UTF8                    GetName() const;

    void                    AttachLayout(Layout const & in_layout);

    void                    AttachViewAsLayout(View const & in_view);

    void                    DetachLayout();

    Layout                  GetAttachedLayout() const;

    IncludeKey              GetAttachedLayoutIncludeLink() const;

    View                    GetFrontView() const;

    WindowKey const         GetWindowKey() const;

    WindowKey               GetWindowKey();

    PortfolioKey const      GetPortfolioKey() const;

    PortfolioKey            GetPortfolioKey();

    void                    Update() const;

    UpdateNotifier          UpdateWithNotifier() const;

    void                    Update(HPS::Window::UpdateType in_type, HPS::Time in_time_limit = -1.0) const;

    UpdateNotifier          UpdateWithNotifier(HPS::Window::UpdateType in_type, HPS::Time in_time_limit = -1.0) const;

    void                    SetFrameRate(float in_frame_rate=20);

    float                   GetFrameRate() const;
};

class SPRK_API Rendering
{
public:
    enum class Mode
    {
        Gouraud,            
        GouraudWithLines,   
        Flat,               
        FlatWithLines,      
        Phong,              
        PhongWithLines,     
        HiddenLine,         
        FastHiddenLine,     
        Wireframe,          
        Default = Phong     
    };

private:
    Rendering() {}
};

class SPRK_API SprocketControl : public Sprocket
{
public:
    static const HPS::Type staticType = HPS::Type::SprocketControl;
    HPS::Type       ObjectType() const {return staticType;}

#if !defined(_MSC_VER) || _MSC_VER >= 1900
    SprocketControl(HPS::SprocketControl const & in_that) = default;
#endif

protected:
    SprocketControl() {}

    SprocketControl(SprocketControl && in_that) : Sprocket(std::move(in_that)) {}

    SprocketControl & operator=(SprocketControl && in_that)
    {
        this->Object::operator=(std::move(in_that));
        return *this;
    }
};

class SPRK_API SprocketKit : public Sprocket
{
public:
    static const HPS::Type staticType = HPS::Type::SprocketKit;
    HPS::Type       ObjectType() const { return staticType; }

#if !defined(_MSC_VER) || _MSC_VER >= 1900
    SprocketKit(HPS::SprocketKit const & in_that) = default;
#endif

protected:
    SprocketKit() {}

    SprocketKit(SprocketKit && in_that) : Sprocket(std::move(in_that)) {}

    SprocketKit & operator=(SprocketKit && in_that)
    {
        this->Object::operator=(std::move(in_that));
        return *this;
    }
};

class SPRK_API View : public Sprocket
{
public:
    View();
    View(View const & that);
    explicit View(SprocketControl const & in_ctrl);
    ~View();

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

    void                    Delete();

    View &                  operator=(View const & in_that);
    void                    Assign(View const & in_that);

    bool                    Equals(View const & in_that) const;
    bool                    operator!= (View const & in_that) const;
    bool                    operator== (View const & in_that) const;

    UTF8                    GetName() const;


    HPS::View &             ComputeFitWorldCamera(HPS::CameraKit & out_camera);

    HPS::View &             ComputeFitWorldCamera(SegmentKey const & in_segment, HPS::CameraKit & out_camera);


    HPS::View &             ComputeFitWorldCamera(BoundingKit const & in_bounding, HPS::CameraKit & out_camera);

    HPS::View &             ComputeFitWorldCamera(SegmentKey const & in_segment, MatrixKit const & in_transform, HPS::CameraKit & out_camera);


    HPS::View &             ComputeFitWorldCamera(BoundingKit const & in_bounding, MatrixKit const & in_transform, HPS::CameraKit & out_camera);


    HPS::View &             FitWorld();

    HPS::View &             FitWorld(SegmentKey const & in_segment);


    HPS::View &             FitWorld(BoundingKit const & in_bounding);

    HPS::View &             FitWorld(SegmentKey const & in_segment, MatrixKit const & in_transform);


    HPS::View &             FitWorld(BoundingKit const & in_bounding, MatrixKit const & in_transform);

    void                    AttachModel(Model const & in_model);

    void                    DetachModel();

    Model                   GetAttachedModel() const;

    IncludeKey              GetAttachedModelIncludeLink() const;

    void                    SetRenderingMode(Rendering::Mode in_mode);

    Rendering::Mode         GetRenderingMode() const;

    OperatorPtrArray        GetOperators() const;

    void                    SetOperators(OperatorPtrArray & in_operators);

    void                    SetOperators(size_t in_count, OperatorPtr in_operators []);

    void                    SetOperator(OperatorPtr const & in_operator);

    void                    SetOperator(Operator * in_operator);

    OperatorControl         GetOperatorControl();
    OperatorControl const   GetOperatorControl() const;

    AnimationControl        GetAnimationControl();
    AnimationControl const  GetAnimationControl() const;

    NavigationCubeControl   GetNavigationCubeControl();
    NavigationCubeControl const GetNavigationCubeControl() const;

    AxisTriadControl        GetAxisTriadControl();
    AxisTriadControl const  GetAxisTriadControl() const;

    SegmentKey              GetSegmentKey();
    SegmentKey const        GetSegmentKey() const;

    SegmentKey              GetModelOverrideSegmentKey();
    SegmentKey const        GetModelOverrideSegmentKey() const;


    PortfolioKey const      GetPortfolioKey() const;

    PortfolioKey            GetPortfolioKey();

    void                    SetSimpleShadow(bool in_state, float in_percent_offset = 5.0f);

    bool                    GetSimpleShadow();

    void                    SetSimpleReflection(bool in_state, float in_percent_offset = 5.0f);

    bool                    GetSimpleReflection();

    void                    Update() const;

    UpdateNotifier          UpdateWithNotifier() const;

    void                    Update(HPS::Window::UpdateType in_type, HPS::Time in_time_limit = -1.0) const;

    UpdateNotifier          UpdateWithNotifier(HPS::Window::UpdateType in_type, HPS::Time in_time_limit = -1.0) const;

    void                    SmoothTransition(HPS::CameraKit const & in_camera_kit, HPS::Time in_duration = 0.5);

    KeyArray const          GetNavigationKeys();

    LayoutArray             GetOwningLayouts();
    LayoutArray const       GetOwningLayouts() const;
};

class SPRK_API Model : public Sprocket
{
public:
    Model();
    Model(Model const & that);
    ~Model();

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

    void                    Delete();

    Model &                 operator=(Model const & in_that);
    void                    Assign(Model const & in_that);

    bool                    Equals(Model const & in_that) const;
    bool                    operator!= (Model const & in_that) const;
    bool                    operator== (Model const & in_that) const;

    UTF8                    GetName() const;

    SegmentKey              GetSegmentKey();
    SegmentKey const        GetSegmentKey() const;

    SegmentKey              GetLibraryKey();
    SegmentKey const        GetLibraryKey() const;

    PortfolioKey            GetPortfolioKey();
    PortfolioKey const      GetPortfolioKey() const;

    HPS::Vector             GetUpVector();
    HPS::Vector const       GetUpVector() const;

    HPS::Vector             GetFrontVector();
    HPS::Vector const       GetFrontVector() const;

    HPS::ViewArray          GetOwningViews();
    HPS::ViewArray const    GetOwningViews() const;

    void                    SetOrientation(HPS::Vector const & in_up_vector, HPS::Vector const & in_front_vector);

    bool                    ShowOrientation(HPS::Vector & out_up_vector, HPS::Vector & out_front_vector) const;

    void                    Update() const;

    UpdateNotifier          UpdateWithNotifier() const;

    void                    Update(HPS::Window::UpdateType in_type, HPS::Time in_time_limit = -1.0) const;

    UpdateNotifier          UpdateWithNotifier(HPS::Window::UpdateType in_type, HPS::Time in_time_limit = -1.0) const;

    Animation               CreateAnimation(const char * in_name);

    AnimationArray const &  GetAnimations();
};

class SPRK_API Layout : public Sprocket
{
public:
    Layout();
    Layout(Layout const & that);
    ~Layout();

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

    void                    Delete();

    Layout &                operator=(Layout const & in_that);
    void                    Assign(Layout const & in_that);

    bool                    Equals(Layout const & in_that) const;
    bool                    operator!= (Layout const & in_that) const;
    bool                    operator== (Layout const & in_that) const;

    UTF8                    GetName() const;

    size_t                  GetLayerCount() const;

    void                    AttachViewFront(View const & in_view, HPS::Rectangle const & in_position = HPS::Rectangle(-1.0f, 1.0f, -1.0f, 1.0f));
    void                    AttachViewBack(View const & in_view, HPS::Rectangle const & in_position = HPS::Rectangle(-1.0f, 1.0f, -1.0f, 1.0f));

    void                    DetachLayer(size_t in_layer);

    void                    DetachView(View const & in_view);   // everywhere it occurs

    void                    BringToFront(size_t in_layer);

    void                    ReassignLayer(size_t in_layer, HPS::View in_view);

    void                    RepositionLayer(size_t in_layer, HPS::Rectangle const & in_position);

    View                    GetFrontView() const;

    View                    GetAttachedView(size_t in_layer = 0) const;

    Rectangle               GetPosition(size_t in_layer) const;

    IncludeKey              GetAttachedViewIncludeLink(size_t in_layer) const;

    SegmentKey              GetLayerSegmentKey(size_t in_layer) const;

    size_t                  GetLayerAt(HPS::WindowPoint const & in_point) const;

    bool                    ShowLayerAt(HPS::WindowPoint const & in_point) const;

    SegmentKey              GetSegmentKey();
    SegmentKey const        GetSegmentKey() const;

    CanvasArray             GetOwningCanvases();
    CanvasArray const       GetOwningCanvases() const;

    void                    Update() const;

    UpdateNotifier          UpdateWithNotifier() const;

    void                    Update(HPS::Window::UpdateType in_type, HPS::Time in_time_limit = -1.0) const;

    UpdateNotifier          UpdateWithNotifier(HPS::Window::UpdateType in_type, HPS::Time in_time_limit = -1.0) const;

};

class SPRK_API CanvasDeletedEvent : public Event
{
public:
    CanvasDeletedEvent() : Event()
    {
        channel = GetClassID();
        consumable = false;
    }

    CanvasDeletedEvent(Canvas const & in_canvas)
        : Event(), canvas(in_canvas)
    {
        channel = GetClassID();
        consumable = false;
    }

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

    ~CanvasDeletedEvent();

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

    Canvas canvas;
};

class SPRK_API LayoutDetachedEvent : public Event
{
public:
    LayoutDetachedEvent() : Event()
    {
        channel = GetClassID();
        consumable = false;
    }

    LayoutDetachedEvent(Canvas const & in_canvas, Layout const & in_layout)
        : Event(), canvas(in_canvas), layout(in_layout)
    {
        channel = GetClassID();
        consumable = false;
    }

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

    ~LayoutDetachedEvent();

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

    Canvas canvas;
    Layout layout;
};

class SPRK_API LayoutDeletedEvent : public Event
{
public:
    LayoutDeletedEvent() : Event()
    {
        channel = GetClassID();
        consumable = false;
    }

    LayoutDeletedEvent(Layout const & in_layout)
        : Event(), layout(in_layout)
    {
        channel = GetClassID();
        consumable = false;
    }

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

    ~LayoutDeletedEvent();

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

    Layout layout;
};

class SPRK_API ViewDetachedEvent : public Event
{
public:
    enum class Action
    {
        None = 0,
        SpecificLayer,
        AllLayers,
    };

    ViewDetachedEvent() : Event(), action(Action::None), layer(0)
    {
        channel = GetClassID();
        consumable = false;
    }

    ViewDetachedEvent(Layout const & in_layout, size_t in_layer, View const & in_view)
        : Event(), layout(in_layout), action(Action::SpecificLayer), layer(in_layer), view(in_view)
    {
        channel = GetClassID();
        consumable = false;
    }

    ViewDetachedEvent(Layout const & in_layout, View const & in_view)
        : Event(), layout(in_layout), action(Action::AllLayers), layer(std::numeric_limits<size_t>::max()), view(in_view)
    {
        channel = GetClassID();
        consumable = false;
    }

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

    ~ViewDetachedEvent();

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

    Layout layout;
    Action action;
    size_t layer;
    View view;
};

class SPRK_API ViewDeletedEvent : public Event
{
public:
    ViewDeletedEvent() : Event()
    {
        channel = GetClassID();
        consumable = false;
    }

    ViewDeletedEvent(View const & in_view)
        : Event(), view(in_view)
    {
        channel = GetClassID();
        consumable = false;
    }

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

    ~ViewDeletedEvent();

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

    View view;
};

class SPRK_API ModelDetachedEvent : public Event
{
public:
    ModelDetachedEvent() : Event()
    {
        channel = GetClassID();
        consumable = false;
    }

    ModelDetachedEvent(View const & in_view, Model const & in_model)
        : Event(), view(in_view), model(in_model)
    {
        channel = GetClassID();
        consumable = false;
    }

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

    ~ModelDetachedEvent();

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

    View view;
    Model model;
};

class SPRK_API ModelDeletedEvent : public Event
{
public:
    ModelDeletedEvent() : Event()
    {
        channel = GetClassID();
        consumable = false;
    }

    ModelDeletedEvent(Model const & in_model)
        : Event(), model(in_model)
    {
        channel = GetClassID();
        consumable = false;
    }

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

    ~ModelDeletedEvent();

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

    Model model;
};

class SPRK_API CameraChangedEvent : public Event
{
public:
    CameraChangedEvent() : Event()
    {
        channel = GetClassID();
        consumable = false;
    }

    CameraChangedEvent(View const & in_view)
        : Event(), view(in_view)
    {
        channel = GetClassID();
        consumable = false;
    }

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

    ~CameraChangedEvent();

    virtual bool Drop(Event const * in_that_event) const
 {
        CameraChangedEvent const * that_event = static_cast<CameraChangedEvent const *>(in_that_event);

        if (view == that_event->view)
            return true;

        return false;
    }

    virtual intptr_t Freshen() const
 {
        return GetClassID();
    }

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

    View view;
};

class SPRK_API SprocketPath : public Sprocket
{
public:
    SprocketPath();
    SprocketPath(Model const & in_model, View const & in_view, Layout const & in_layout, Canvas const & in_canvas);
    SprocketPath(Canvas const & in_canvas, Layout const & in_layout, View const & in_view, Model const & in_model);
    SprocketPath(Canvas const & in_canvas, size_t in_layer = 0);
    SprocketPath(SprocketPath const & that);
    ~SprocketPath();

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

    SprocketPath &          operator=(SprocketPath const & in_that);
    void                    Set(SprocketPath const & in_that);

    bool                    Equals(SprocketPath const & in_that) const;
    bool                    operator!= (SprocketPath const & in_that) const;
    bool                    operator== (SprocketPath const & in_that) const;

    Canvas                  GetCanvas() const;

    Layout                  GetLayout() const;

    View                    GetView() const;

    Model                   GetModel() const;

    KeyPath                 GetKeyPath() const;
};


class SPRK_API Operator : public Sprocket
{
public:
    Operator(MouseButtons in_mouse_trigger = MouseButtons::ButtonLeft(), ModifierKeys in_modifier_trigger = ModifierKeys());
    Operator(Operator const & in_that);

    virtual ~Operator();

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

    virtual Operator &      operator= (Operator const & in_that);

    virtual void            Assign(Operator const & in_that);

    virtual bool            Equals(Operator const & in_that) const;

    virtual bool            operator!= (Operator const & in_that) const;

    virtual bool            operator== (Operator const & in_that) const;

    void                    DetachView();

    View                    GetAttachedView() const;

    virtual UTF8 GetName() const { return "Operator"; }

    virtual bool OnMouseDown(MouseState const  & in_state) { HPS_UNREFERENCED(in_state); return false; }

    virtual bool OnMouseUp(MouseState const  & in_state) { HPS_UNREFERENCED(in_state); return false; }

    virtual bool OnMouseMove(MouseState const  & in_state) { HPS_UNREFERENCED(in_state); return false; }

    virtual bool OnMouseWheel(MouseState const  & in_state) { HPS_UNREFERENCED(in_state); return false; }

    virtual bool OnMouseEnter(MouseState const  & in_state) { HPS_UNREFERENCED(in_state); return false; }

    virtual bool OnMouseLeave(MouseState const  & in_state) { HPS_UNREFERENCED(in_state); return false; }

    virtual bool OnTouchDown(TouchState const  & in_state) { HPS_UNREFERENCED(in_state); return false; }

    virtual bool OnTouchUp(TouchState const  & in_state) { HPS_UNREFERENCED(in_state); return false; }

    virtual bool OnTouchMove(TouchState const  & in_state) { HPS_UNREFERENCED(in_state); return false; }

    virtual bool OnKeyDown(KeyboardState const & in_state) { HPS_UNREFERENCED(in_state); return false; }

    virtual bool OnKeyUp(KeyboardState const & in_state) { HPS_UNREFERENCED(in_state); return false; }

    virtual bool OnTextInput(HPS::UTF8 const & in_text) { HPS_UNREFERENCED(in_text); return false; }

    virtual bool OnTimerTick(HPS::TimerTickEvent const & in_event) { HPS_UNREFERENCED(in_event); return false; }

    virtual void OnViewAttached(HPS::View const & in_attached_view) { HPS_UNREFERENCED(in_attached_view); return; }

    virtual void OnViewDetached(HPS::View const & in_detached_view) { HPS_UNREFERENCED(in_detached_view); return; }

    virtual void OnModelAttached() { return; }

    virtual void OnModelDetached() { return; }

    void SetMouseTrigger(MouseButtons in_buttons) { mouse_trigger = in_buttons; }

    MouseButtons GetMouseTrigger() const { return mouse_trigger; }

    void SetModifierTrigger(ModifierKeys in_modifiers) { modifier_trigger = in_modifiers; }

    ModifierKeys GetModifierTrigger() const { return modifier_trigger; }

    virtual bool IsMouseTriggered(MouseState const  & in_state) { return in_state.HasAll(mouse_trigger, modifier_trigger); }

    enum class Priority
    {
        Low,
        Default,
        High
    };

protected:

    HPS::MouseButtons       mouse_trigger;
    HPS::ModifierKeys       modifier_trigger;
};

class SPRK_API OperatorUtility
{
    static double internal_acos(double x)
    {
        return (((x)<-1) ? (HPS::PI) : (((x)>1) ? (0) : (acos(x))));
    }

public:

    enum ProjectedPlane
    {
        Plane_XY,
        Plane_YZ,
        Plane_XZ
    };

    static void ScreenToSphereMousePoint(HPS::Point const &in_pt, HPS::Vector &out_vec)
    {
        out_vec = HPS::Vector(in_pt);
        float len = static_cast<float>(out_vec.Length());
        if (len > 1.0f)
        {
            out_vec /= len;
            out_vec.z = 0;
        }
        else
            out_vec.z = (float)sqrt(1.0f - (len*len));
    }

    static float CalculateAngleOrbitOnPlane(HPS::Vector const &axis, ProjectedPlane plane)
    {
        float theta;

        HPS::Vector vtmp;
        if (plane == Plane_XY)
            vtmp = HPS::Vector(axis.x, axis.y, 0);
        else if (plane == Plane_YZ)
            vtmp = HPS::Vector(0, axis.y, axis.z);
        else
            vtmp = HPS::Vector(axis.x, 0, axis.z);
        Vector naxis = axis;

        naxis.Normalize();
        vtmp.Normalize();

        float tmp = naxis.Dot(vtmp);
        if (static_cast<float>(Abs(tmp)) > 1.001f || static_cast<float>(Abs(tmp)) < 0.999f)
            theta = static_cast<float>(internal_acos(tmp));
        else
            theta = 0.0f;

        return theta;
    }
};

class SPRK_API OperatorControl : public SprocketControl
{
public:
    explicit OperatorControl(View const & in_view);

    OperatorControl(OperatorControl const & in_that);

    OperatorControl(OperatorControl && in_that);

    OperatorControl & operator=(OperatorControl && in_that);

    ~OperatorControl();

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

    OperatorControl &       operator=(OperatorControl const & in_that);


    size_t                  GetCount();

    size_t                  GetCount(Operator::Priority in_priority);


    OperatorControl &       Push(OperatorPtr const & in_operator, Operator::Priority in_priority = Operator::Priority::Default);

    OperatorControl &       Push(Operator * in_operator, Operator::Priority in_priority = Operator::Priority::Default);

    bool                    Pop(Operator::Priority in_priority = Operator::Priority::Default);

    bool                    Pop(OperatorPtr & out_operator);

    bool                    Pop(Operator::Priority in_priority, OperatorPtr & out_operator);


    OperatorControl &       Set(OperatorPtr const & in_operator, Operator::Priority in_priority = Operator::Priority::Default);

    OperatorControl &       Set(Operator * in_operator, Operator::Priority in_priority = Operator::Priority::Default);

    OperatorControl &       Set(OperatorPtrArray & in_operators, Operator::Priority in_priority = Operator::Priority::Default);

    OperatorControl &       Set(size_t in_count, OperatorPtr in_operators [], Operator::Priority in_priority = Operator::Priority::Default);


    OperatorControl &       UnsetTop(Operator::Priority in_priority = Operator::Priority::Default);

    OperatorControl &       UnsetEverything(Operator::Priority in_priority);

    OperatorControl &       UnsetEverything();


    bool                    ShowTop(OperatorPtr & out_operator) const;

    bool                    ShowTop(Operator::Priority in_priority, OperatorPtr & out_operator) const;

    bool                    Show(OperatorPtrArray & out_operators) const;

    bool                    Show(Operator::Priority in_priority, OperatorPtrArray & out_operators) const;

private:
    OperatorControl() {}
};

class SPRK_API NavigationCubeControl : public SprocketControl
{
public:

    enum class Location
    {
        TopRight,   
        TopLeft,    
        BottomRight,
        BottomLeft, 
        Custom,     
    };

    explicit NavigationCubeControl(View const & in_view);

    NavigationCubeControl(NavigationCubeControl const & in_that);

    NavigationCubeControl(NavigationCubeControl && in_that);

    NavigationCubeControl & operator=(NavigationCubeControl && in_that);

    ~NavigationCubeControl();

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

    NavigationCubeControl & operator=(NavigationCubeControl const & in_that);

    NavigationCubeControl & SetLocation(Location in_location, HPS::Rectangle const & in_rectangle = HPS::Rectangle(), HPS::IntRectangle in_offsets = HPS::IntRectangle::Zero());

    Location                GetLocation() const;

    NavigationCubeControl & SetPosition(HPS::Rectangle const & in_rectangle);

    HPS::Rectangle          GetPosition() const;

    NavigationCubeControl &     SetPositionOffsets(HPS::IntRectangle const & in_offsets);

    HPS::IntRectangle           GetPositionOffsets() const;

    NavigationCubeControl & SetVisibility(bool in_visibility);

    bool                    GetVisibility() const;

    NavigationCubeControl & SetTextVisibility(bool in_text_visibility);

    bool                    GetTextVisibility() const;

    NavigationCubeControl & SetMaterialPalette(char const * in_material_palette);

    HPS::UTF8           GetMaterialPalette() const;

    NavigationCubeControl & SetInteractivity(bool in_interactivity);


    bool                    GetInteractivity() const;

    NavigationCubeControl & SetSize(float in_size);

    float                   GetSize() const;

    /* Sets the text displayed on the navigation cube.
     * note that if you plan on using the navigation cube on a very large and pixel dense screen
     * (example: a large TV), if you wish to specify a custom text size, you should do so using
     * one of the window relative text sizes.
     * \param in_back_string The text to display on the back face of the navigation cube
     * \param in_top_string The text to display on the top face of the navigation cube
     * \param in_left_string The text to display on the left face of the navigation cube
     * \param in_front_string The text to display on the front face of the navigation cube
     * \param in_bottom_string The text to display on the bottom face of the navigation cube
     * \param in_right_string The text to display on the right face of the navigation cube
     * \param in_text_attributes The attributes applied to the text on the navigation cube
     * \param in_fallback_fonts An array of fonts to use in case the one specified in in_text_attributes cannot be found at runtime.
     *  Generally this should be the same array passed to SetFallbackFonts.
     *  If the font specified is not found at runtime, and no fallback fonts are specified, a stroked representation of the text will be
     *  used. Non-Latin characters might render as boxes in this eventuality.
     * \return A reference to this object. */
    NavigationCubeControl & SetText(const char * in_back_string, const char * in_top_string, const char * in_left_string,
        const char * in_front_string, const char * in_bottom_string, const char * in_right_string,
        HPS::TextAttributeKit const & in_text_attributes, HPS::UTF8Array const & in_fallback_fonts = HPS::UTF8Array());

    /* Gets the text displayed on the navigation cube.
    * \param out_back_string The text displayed on the back face of the navigation cube
    * \param out_top_string The text displayed on the top face of the navigation cube
    * \param out_left_string The text displayed on the left face of the navigation cube
    * \param out_front_string The text displayed on the front face of the navigation cube
    * \param out_bottom_string The text displayed on the bottom face of the navigation cube
    * \param out_right_string The text displayed on the right face of the navigation cube
    * \param out_text_attributes The attributes applied to the text on the navigation cube
    * \param out_fallback_fonts The fonts that will be used if the preferred font specified when setting text could not be found at runtime. Can be empty.
    * \return <span class='code'>true</span> if the navigation cube text was retrieved successfully, <span class='code'>false</span> otherwise. */
    bool GetText(UTF8 & out_back_string, UTF8 & out_top_string, UTF8 & out_left_string,
        UTF8 & out_front_string, UTF8 & out_bottom_string, UTF8 & out_right_string,
        HPS::TextAttributeKit & out_text_attributes, HPS::UTF8Array & out_fallback_fonts) const;

    HPS::SegmentKey         GetSegmentKey() const;

private:
    NavigationCubeControl() {}

    HPS::SegmentKey GetNavigationCubeSegment() const;
    void SetNavigationCubeVisibilityLink(bool in_visibility) const;

    bool IsTextVisible() const;
};

class SPRK_API AxisTriadControl : public SprocketControl
{
public:

    enum class Location
    {
        TopRight,   
        TopLeft,    
        BottomRight,
        BottomLeft, 
        Custom,     
    };

    explicit AxisTriadControl(View const & in_view);

    AxisTriadControl(AxisTriadControl const & in_that);

    AxisTriadControl(AxisTriadControl && in_that);

    AxisTriadControl & operator=(AxisTriadControl && in_that);

    ~AxisTriadControl();

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

    AxisTriadControl &      operator=(AxisTriadControl const & in_that);

    HPS::AxisTriadControl & SetLocation(Location in_location, HPS::Rectangle const & in_position = HPS::Rectangle(), HPS::IntRectangle in_offsets = HPS::IntRectangle::Zero());

    Location                GetLocation() const;

    AxisTriadControl &      SetPosition(HPS::Rectangle const & in_position);

    HPS::Rectangle          GetPosition() const;

    AxisTriadControl &      SetPositionOffsets(HPS::IntRectangle const & in_offsets);

    HPS::IntRectangle           GetPositionOffsets() const;

    HPS::AxisTriadControl & SetVisibility(bool in_visibility);

    bool                    GetVisibility() const;

    HPS::AxisTriadControl & SetTextVisibility(bool in_text_visibility);

    bool                    GetTextVisibility() const;

    HPS::AxisTriadControl & SetMaterialPalette(char const * in_material_palette);

    HPS::UTF8           GetMaterialPalette() const;

    HPS::AxisTriadControl & SetInteractivity(bool in_interactivity);

    bool                    GetInteractivity() const;

    AxisTriadControl &      SetSize(float in_size);

    float                   GetSize() const;

    HPS::SegmentKey         GetSegmentKey() const;

private:
    AxisTriadControl(){};

    HPS::SegmentKey         GetAxisTriadSegment() const;

    void    SetAxisVisibilityLink(bool in_visibility) const;
};

class SPRK_API Component : public Sprocket
{
public:

    enum class ComponentType : uint32_t
    {
        None                                    = 0x00000000,
        GenericMask                             = 0xfffff000,

        ExchangeComponentMask                   = 0x00001000,       
        ExchangeModelFile                       = 0x00001001,       
        ExchangeProductOccurrence               = 0x00001002,       
        ExchangePartDefinition                  = 0x00001003,       

        ExchangeView                            = 0x00001004,       
        ExchangeFilter                          = 0x00001005,       

        ExchangeRepresentationItemMask          = 0x00003000,       
        ExchangeRIBRepModel                     = 0x00003001,       
        ExchangeRICurve                         = 0x00003002,       
        ExchangeRIDirection                     = 0x00003003,       
        ExchangeRIPlane                         = 0x00003004,       
        ExchangeRIPointSet                      = 0x00003005,       
        ExchangeRIPolyBRepModel                 = 0x00003006,       
        ExchangeRIPolyWire                      = 0x00003007,       
        ExchangeRISet                           = 0x00003008,       
        ExchangeRICoordinateSystem              = 0x00003009,       

        ExchangeTopologyMask                    = 0x00005000,       
        ExchangeTopoBody                        = 0x00005001,       
        ExchangeTopoConnex                      = 0x00005002,       
        ExchangeTopoShell                       = 0x00005003,       
        ExchangeTopoFace                        = 0x00005004,       
        ExchangeTopoLoop                        = 0x00005005,       
        ExchangeTopoCoEdge                      = 0x00005006,       
        ExchangeTopoEdge                        = 0x00005007,       
        ExchangeTopoVertex                      = 0x00005008,       
        ExchangeTopoSingleWireBody              = 0x00005009,       
        ExchangeTopoWireEdge                    = 0x0000500a,       

        ExchangeDrawingMask                     = 0x00009000,       
        ExchangeDrawingModel                    = 0x00009001,       
        ExchangeDrawingView                     = 0x00009002,       
        ExchangeDrawingSheet                    = 0x00009003,       
        ExchangeBasicDrawingBlock               = 0x00009004,       
        ExchangeOperatorDrawingBlock            = 0x00009005,       

        ExchangePMIMask                         = 0x00011000,       
        ExchangePMI                             = ExchangePMIMask,  
        ExchangePMIText                         = 0x00011100,       
        ExchangePMIRichText                     = 0x00011200,       
        ExchangePMIRoughness                    = 0x00011300,       
        ExchangePMIGDT                          = 0x00011400,       
        ExchangePMIDatum                        = 0x00011500,       
        ExchangePMILineWelding                  = 0x00011600,       
        ExchangePMISpotWelding                  = 0x00011700,       
        ExchangePMIDimension                    = 0x00011800,       
        ExchangePMIBalloon                      = 0x00011900,       
        ExchangePMICoordinate                   = 0x00011a00,       
        ExchangePMIFastener                     = 0x00011b00,       
        ExchangePMILocator                      = 0x00011c00,       
        ExchangePMIMeasurementPoint             = 0x00011d00,       


        ParasolidComponentMask                  = 0x00020000,       

        ParasolidModelFile                      = 0x00020001,       
        ParasolidAssembly                       = 0x00020002,       
        ParasolidInstance                       = 0x00020003,       

        ParasolidTopologyMask                   = 0x00060000,       
        ParasolidTopoBody                       = 0x00060001,       
        ParasolidTopoRegion                     = 0x00060002,       
        ParasolidTopoShell                      = 0x00060003,       
        ParasolidTopoFace                       = 0x00060004,       
        ParasolidTopoLoop                       = 0x00060005,       
        ParasolidTopoFin                        = 0x00060006,       
        ParasolidTopoEdge                       = 0x00060007,       
        ParasolidTopoVertex                     = 0x00060008,       


        DWGComponentMask                        = 0x00100000,       
        DWGModelFile                            = 0x00100001,       
        DWGLayout                               = 0x00100002,       
        DWGBlockTable                           = 0x00100003,       
        DWGBlockTableRecord                     = 0x00100004,       
        DWGEntity                               = 0x00100005,       
        DWGLayerTable                           = 0x00100006,       
        DWGLayer                                = 0x00100007,       


        UserComponent                           = 0x01000000,       
    };

    enum class DeleteMode
    {
        Standard,   // subcomponents will be deleted if they don't have multiple owners, otherwise their reference count will be decremented
        Full,       // subcomponents will always be deleted, even if they are shared
        StandardAndExchange // Subcomponent will deleted if they don't have multiple owners, otherwise their reference count will be decremented.
                    // The Exchange Entity associated to the Component will be deleted.
    };

    Component();

    Component(Component const & in_that);

    Component(Component && in_that);

    virtual ~Component();

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


    Component &             operator=(Component const & in_that);

    Component &             operator=(Component && in_that);

    virtual void            Assign(Component const & in_that);

    bool                    Equals(Component const & in_that) const;

    bool                    operator!=(Component const & in_that) const;

    bool                    operator==(Component const & in_that) const;


    ComponentType           GetComponentType() const;

    bool                    HasComponentType(ComponentType in_mask) const;



    void                    AddKey(Key const & in_key);

    KeyArray                GetKeys() const;



    void                    AddOwner(Component & in_owner, IncludeKey const & in_include = IncludeKey());

    ComponentArray          GetOwners() const;

    ComponentArray          GetSubcomponents() const;

    ComponentArray          GetAllSubcomponents(ComponentType in_type) const;



    void                    AddReference(Component & in_reference);

    ComponentArray          GetReferrers() const;

    ComponentArray          GetReferences() const;



    MetadataArray           GetAllMetadata() const;

    Metadata                GetMetadata(char const * in_name) const;

    UTF8                    GetName() const;



    void                    Delete(HPS::Component::DeleteMode mode = HPS::Component::DeleteMode::Standard);

    void                    Flush();


    static KeyPathArray     GetKeyPath(Component const & in_component);

    static KeyPathArray     GetKeyPath(size_t in_count, Component const in_components[]);

    static KeyPathArray     GetKeyPath(ComponentArray const & in_components);

    bool                    SetTransform(MatrixKit const & in_transform);

    bool                    AddTransform(MatrixKit const & in_transform);

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

    bool                    SetName(char const * in_new_name);
};

class SPRK_API ComponentPath : public Sprocket
{
public:
    enum class PathType : uint32_t
    {
        Complete,       
        Unique,         
    };

    ComponentPath();

    ComponentPath(ComponentArray const & in_components);

    ComponentPath(size_t in_count, Component const in_components[]);

    ComponentPath(ComponentPath const & in_that);

    ComponentPath(ComponentPath && in_that);

    ComponentPath & operator=(ComponentPath && in_that);

    virtual ~ComponentPath();

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

    bool                    Empty() const;

    ComponentPath &         operator+=(Component const & in_component);

    ComponentPath &         operator+=(ComponentPath const & in_path);

    ComponentPath &         operator+=(ComponentArray const & in_components);

    ComponentPath &         Append(Component const & in_component);

    ComponentPath &         Append(ComponentPath const & in_path);

    ComponentPath &         Append(ComponentArray const & in_components);

    ComponentPath &         operator=(ComponentPath const & in_that);

    ComponentPath &         operator=(ComponentArray const & in_path);

    void                    Set(ComponentPath const & in_that);

    bool                    Equals(ComponentPath const & in_that) const;

    bool                    operator!= (ComponentPath const & in_that) const;

    bool                    operator== (ComponentPath const & in_that) const;


    ComponentPath &         SetComponents(ComponentArray const & in_components);

    ComponentPath &         SetComponents(size_t in_count, Component const in_components[]);

    ComponentArray          GetComponents() const;

    KeyPathArray            GetKeyPaths() const;

    KeyPathArray            GetKeyPaths(Canvas const & in_canvas, size_t in_layer = 0) const;


    void                    Highlight(Canvas const & in_canvas, HighlightOptionsKit const & in_options, bool in_remove_existing = true) const;

    void                    Highlight(Canvas const & in_canvas, size_t in_layer, HighlightOptionsKit const & in_options, bool in_remove_existing = true) const;

    void                    Unhighlight(Canvas const & in_canvas, HighlightOptionsKit const & in_options = HighlightOptionsKit()) const;

    void                    Unhighlight(Canvas const & in_canvas, size_t in_layer, HighlightOptionsKit const & in_options = HighlightOptionsKit()) const;


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

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

    bool                    IsHidden(Canvas const & in_canvas, size_t in_layer = 0) const;

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

    static void             Isolate(HPS::ComponentPathArray & in_component_paths, Canvas const & in_canvas, size_t in_layer = 0);

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

    static void             ResetVisibility(HPS::ComponentPathArray & in_component_paths, Canvas const & in_canvas, size_t in_layer = 0);

    /* Returns the number of Components contained in this ComponentPath object.
    *  \return the number of Components in this ComponentPath.*/
    size_t                  Size() const;

    /* Access a Component in this ComponentPath object. An HPS::IndexOutOfRangeException exception is thrown if in_index is out of range.
    *  \param in_index The index of the Component to access, zero based.
    *  \return The Component at position in_index in this ComponentPath.*/
    Component &             At(size_t in_index);

    /* Access a Component in this ComponentPath object. An HPS::IndexOutOfRangeException exception is thrown if in_index is out of range.
    *  \param in_index The index of the Component to access, zero based.
    *  \return The Component at position in_index in this ComponentPath.*/
    Component const &       At(size_t in_index) const;

    /* Inserts in_item in the ComponentPath before the element at position in_index, increasing the size of the ComponentPath by one.
    *  An HPS::IndexOutOfRangeException exception is thrown if in_index is out of range.
    *  \param in_index The index where in_item will be inserted
    *  \param in_item The component to insert in this key path. */
    void                    Insert(size_t in_index, Component const & in_item);

    /* Traverses the components in this ComponentPath and removes the first one which matches in_item
    *  NOTE: A useful ComponentPath should not contain duplicate components.
    *  \param in_item The item to remove from the ComponentPath. */
    void                    Remove(Component const & in_item);

    /* Removes the the component at position in_index from this ComponentPath. An HPS::IndexOutOfRangeException exception is thrown if in_index is out of range.
    *  \param in_index The index of the component to remove, zero based. */
    void                    Remove(size_t in_index);

    /* Creates and returns a new ComponentPath object, with the components organized in the reverse order.
    *  \return A new ComponentPath object, containing components organized in the reverse order. */
    ComponentPath           Reverse() const;

    /* Returns the first component of this ComponentPath. An HPS::IndexOutOfRangeException exception is thrown if the ComponentPath is empty.
    *  \return The first component of this ComponentPath.*/
    Component &             Front();

    /* Returns the first component of this ComponentPath. An HPS::IndexOutOfRangeException exception is thrown if the ComponentPath is empty.
    *  \return The first component of this ComponentPath.*/
    Component const &       Front() const;

    /* Returns the last component of this ComponentPath. An HPS::IndexOutOfRangeException exception is thrown if the ComponentPath is empty.
    *  \return The last component of this ComponentPath.*/
    Component &             Back();

    /* Returns the last component of this ComponentPath. An HPS::IndexOutOfRangeException exception is thrown if the ComponentPath is empty.
    *  \return The last component of this ComponentPath.*/
    Component const &       Back() const;

    /* Returns the first component of this ComponentPath and returns it. An HPS::IndexOutOfRangeException exception is thrown if the ComponentPath is empty.
    *  \return The first component of this ComponentPath.*/
    Component               PopFront();

    /* Returns the last component of this ComponentPath and returns it. An HPS::IndexOutOfRangeException exception is thrown if the ComponentPath is empty.
    *  \return The last component of this ComponentPath.*/
    Component               PopBack();

    /* Adds in_component to the front of the ComponentPath.
    *  \param in_component The component to add to the front of the ComponentPath.
    *  \return A reference to this object.*/
    ComponentPath &         PushFront(Component const & in_component);

    /* Adds in_component to the end of the ComponentPath.
    *  \param in_component The component to add to the end of the ComponentPath.
    *  \return A reference to this object.*/
    ComponentPath &         PushBack(Component const & in_component);

    ComponentPath &         PushBack(ComponentPath const & in_path);

    ComponentPath &         PushBack(ComponentArray const & in_components);

#ifndef HPS_GULP_CLANG
    using iterator = HPS::ComponentArray::iterator;
    using const_iterator = HPS::ComponentArray::const_iterator;
    using reverse_iterator = HPS::ComponentArray::reverse_iterator;
    using const_reverse_iterator = HPS::ComponentArray::const_reverse_iterator;

    /* Returns an iterator pointing to the first Component contained in this ComponentPath
    * \return An iterator pointing to the first Component contained in this ComponentPath. */
    iterator            begin();

    /* Returns an iterator pointing to the first Component contained in this ComponentPath
    * \return An iterator pointing to the first Component contained in this ComponentPath. */
    const_iterator      begin() const;

    /* Returns a constant iterator pointing to the last Component contained in this ComponentPath
    * \return A constant iterator pointing to the last Component contained in this ComponentPath. */
    iterator            end();

    /* Returns a constant iterator pointing to the last Component contained in this ComponentPath
    * \return A constant iterator pointing to the last Component contained in this ComponentPath. */
    const_iterator      end() const;

    /* Returns a constant iterator pointing to the first Component contained in this ComponentPath
    * \return A constant iterator pointing to the first Component contained in this ComponentPath. */
    const_iterator      cbegin() const;

    /* Returns a constant iterator pointing to the last Component contained in this ComponentPath
    * \return A constant iterator pointing to the last Component contained in this ComponentPath. */
    const_iterator      cend() const;

    /* Returns a reverse iterator pointing to the last Component contained in this ComponentPath
    * \return A reverse iterator pointing to the last Component contained in this ComponentPath. */
    reverse_iterator    rbegin();

    /* Returns a reverse iterator pointing to the first Component contained in this ComponentPath
    * \return A reverse iterator pointing to the first Component contained in this ComponentPath. */
    reverse_iterator    rend();

    /* Returns a constant reverse iterator pointing to the last Component contained in this ComponentPath
    * \return A constant reverse iterator pointing to the last Component contained in this ComponentPath. */
    const_reverse_iterator  rbegin() const;

    /* Returns a constant iterator pointing to the first Component contained in this ComponentPath
    * \return A constant iterator pointing to the first Component contained in this ComponentPath. */
    const_reverse_iterator  rend() const;
#endif
};


inline ComponentPath operator+(Component const & in_lhs, Component const & in_rhs)
{
    return HPS::ComponentPath().PushBack(in_lhs).PushBack(in_rhs);
}

inline ComponentPath operator+(Component const & in_lhs, ComponentArray const & in_rhs)
{
    return HPS::ComponentPath().PushBack(in_lhs).PushBack(in_rhs);
}

inline ComponentPath operator+(Component const & in_lhs, ComponentPath const & in_rhs)
{
    return HPS::ComponentPath().PushBack(in_lhs).PushBack(in_rhs);
}

inline ComponentPath operator+(ComponentArray const & in_lhs, Component const & in_rhs)
{
    return HPS::ComponentPath().PushBack(in_lhs).PushBack(in_rhs);
}

inline ComponentPath operator+(ComponentArray const & in_lhs, ComponentArray const & in_rhs)
{
    return HPS::ComponentPath().PushBack(in_lhs).PushBack(in_rhs);
}

inline ComponentPath operator+(ComponentArray const & in_lhs, ComponentPath const & in_rhs)
{
    return HPS::ComponentPath().PushBack(in_lhs).PushBack(in_rhs);
}

inline ComponentPath operator+(ComponentPath const & in_lhs, Component const & in_rhs)
{
    return HPS::ComponentPath().PushBack(in_lhs).PushBack(in_rhs);
}

inline ComponentPath operator+(ComponentPath const & in_lhs, ComponentArray const & in_rhs)
{
    return HPS::ComponentPath().PushBack(in_lhs).PushBack(in_rhs);
}

inline ComponentPath operator+(ComponentPath const & in_lhs, ComponentPath const & in_rhs)
{
    return HPS::ComponentPath().PushBack(in_lhs).PushBack(in_rhs);
}

class SPRK_API ComponentResetEvent : public HPS::Event
{
public:

    ComponentResetEvent() : Event()
    {
        channel = GetClassID();
        consumable = false;
    }

    ComponentResetEvent(HPS::ComponentPath const & in_path, HPS::Canvas const & in_canvas, size_t in_layer = 0)
        : Event(), path(in_path), canvas(in_canvas), layer(in_layer)
    {
        channel = GetClassID();
        consumable = false;
    }

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

    virtual ~ComponentResetEvent() {}

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

    HPS::ComponentPath path;
    HPS::Canvas canvas;
    size_t layer;
};

class SPRK_API ComponentShownEvent : public HPS::Event
{
public:

    ComponentShownEvent() : Event()
    {
        channel = GetClassID();
        consumable = false;
    }

    ComponentShownEvent(HPS::ComponentPath const & in_path, HPS::Canvas const & in_canvas, size_t in_layer = 0)
        : Event(), path(in_path), canvas(in_canvas), layer(in_layer)
    {
        channel = GetClassID();
        consumable = false;
    }

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

    virtual ~ComponentShownEvent() {}

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

    HPS::ComponentPath path;
    HPS::Canvas canvas;
    size_t layer;
};

class SPRK_API ComponentHiddenEvent : public HPS::Event
{
public:

    ComponentHiddenEvent() : Event()
    {
        channel = GetClassID();
        consumable = false;
    }

    ComponentHiddenEvent(HPS::ComponentPath const & in_path, HPS::Canvas const & in_canvas, size_t in_layer = 0)
        : Event(), path(in_path), canvas(in_canvas), layer(in_layer)
    {
        channel = GetClassID();
        consumable = false;
    }

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

    virtual ~ComponentHiddenEvent() {}

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

    HPS::ComponentPath path;
    HPS::Canvas canvas;
    size_t layer;
};

class SPRK_API ComponentIsolatedEvent : public Event
{
public:

    ComponentIsolatedEvent() : Event()
    {
        channel = GetClassID();
        consumable = false;
    }

    ComponentIsolatedEvent(HPS::ComponentPath const & in_path, HPS::Canvas const & in_canvas, size_t in_layer = 0)
        : Event(), path(in_path), canvas(in_canvas), layer(in_layer)
    {
        channel = GetClassID();
        consumable = false;
    }

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

    virtual ~ComponentIsolatedEvent();

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

    ComponentPath path;
    HPS::Canvas canvas;
    size_t layer;
};


class SPRK_API ComponentHighlightEvent : public Event
{
public:
    enum class Action
    {
        None = 0,
        Highlight,
        Unhighlight,
    };

    ComponentHighlightEvent() : Event()
    {
        channel = GetClassID();
        consumable = false;
        action = Action::None;
    }

    ComponentHighlightEvent(Action in_action,
        HPS::Canvas const & in_canvas,
        size_t in_layer = 0,
        ComponentPath const & in_path = ComponentPath(),
        HighlightOptionsKit const & in_options = HighlightOptionsKit())
        : Event(), action(in_action), path(in_path), options(in_options), canvas(in_canvas), layer(in_layer)
    {
        channel = GetClassID();
        consumable = false;
    }

    ComponentHighlightEvent(Event const & in_event) : Event(in_event)
    {
        if (in_event.GetChannel() == Object::ClassID<ComponentHighlightEvent>())
        {
            auto that = static_cast<ComponentHighlightEvent const &>(in_event);
            action = that.action;
            path = that.path;
            options = that.options;
            canvas = that.canvas;
            layer = that.layer;
        }
        else
            throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
    }

    virtual ~ComponentHighlightEvent();

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

    Action action;
    ComponentPath path;
    HighlightOptionsKit options;
    HPS::Canvas canvas;
    size_t layer;
};


class SPRK_API Filter : public Component
{
public:
    Filter();

    Filter(Component const & in_that);

    Filter(Filter const & in_that);

    Filter(Filter && in_that);

    virtual ~Filter();

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


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

    Filter &                operator=(Filter && in_that);


    void                    Activate(View const & in_view);

    void                    Deactivate(View const & in_view);
};


class SPRK_API FilterActivationEvent : public Event
{
public:
    enum class Action
    {
        None = 0,
        Activate,
        Deactivate,
    };

    FilterActivationEvent() : Event()
    {
        channel = GetClassID();
        consumable = false;
    }

    FilterActivationEvent(Filter in_filter, Action in_action, View in_view) : Event(), filter(in_filter), action(in_action), view(in_view)
    {
        channel = GetClassID();
        consumable = false;
    }

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

    ~FilterActivationEvent();

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

    Filter filter;
    Action action;
    View view;
};


class SPRK_API Capture : public Component
{
public:
    Capture();

    Capture(Component const & in_that);

    Capture(Capture const & in_that);

    Capture(Capture && in_that);

    virtual ~Capture();

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

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

    Capture &               operator=(Capture && in_that);


    View                    Activate();
};


class SPRK_API CaptureActivationEvent : public Event
{
public:
    CaptureActivationEvent() : Event()
    {
        channel = GetClassID();
        consumable = false;
    }

    CaptureActivationEvent(Capture in_capture, View in_view) : Event(), capture(in_capture), view(in_view)
    {
        channel = GetClassID();
        consumable = false;
    }

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

    ~CaptureActivationEvent();

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

    Capture capture;
    View view;
};


class SPRK_API CADModel : public Component
{
public:
    CADModel();

    CADModel(Component const & in_that);

    CADModel(CADModel const & in_that);

    CADModel(CADModel && in_that);

    CADModel(Model const & in_that);

    virtual ~CADModel();

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

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

    CADModel &              operator=(CADModel && in_that);


    Component               GetComponentFromKey(Key const & in_key) const;

    ComponentPath           GetComponentPath(KeyPath const & in_key_path, ComponentPath::PathType in_path_type = ComponentPath::PathType::Unique) const;

    ComponentPath           GetComponentPath(SelectionItem const & in_item, ComponentPath::PathType in_path_type = ComponentPath::PathType::Unique) const;


    Model                   GetModel() const;

    FilterArray             GetAllFilters() const;

    CaptureArray            GetAllCaptures() const;

    FilterArray             GetActiveFilters(View const & in_view) const;


    View                    ActivateDefaultCapture();


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



class SPRK_API Metadata : public Sprocket
{
public:
    Metadata();

    Metadata(Metadata const & in_that);

    Metadata(Metadata && in_that);

    Metadata(char const * in_name);

    virtual ~Metadata();

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


    Metadata &              operator=(Metadata const & in_that);

    Metadata &              operator=(Metadata && in_that);

    virtual void            Assign(Metadata const & in_that);

    bool                    Equals(Metadata const & in_that) const;

    bool                    operator!=(Metadata const & in_that) const;

    bool                    operator==(Metadata const & in_that) const;


    HPS::UTF8               GetName() const;

    void                    SetName(char const * in_name);
};

class SPRK_API IntegerMetadata : public Metadata
{
public:
    IntegerMetadata();

    IntegerMetadata(Metadata const & in_that);

    IntegerMetadata(IntegerMetadata const & in_that);

    IntegerMetadata(IntegerMetadata && in_that);

    IntegerMetadata(char const * in_name, int in_value);

    virtual ~IntegerMetadata();

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

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

    IntegerMetadata &       operator=(IntegerMetadata && in_that);


    int                     GetValue() const;

    void                    SetValue(int in_value);
};

class SPRK_API UnsignedIntegerMetadata : public Metadata
{
public:
    UnsignedIntegerMetadata();

    UnsignedIntegerMetadata(Metadata const & in_that);

    UnsignedIntegerMetadata(UnsignedIntegerMetadata const & in_that);

    UnsignedIntegerMetadata(UnsignedIntegerMetadata && in_that);

    UnsignedIntegerMetadata(char const * in_name, unsigned int in_value);

    virtual ~UnsignedIntegerMetadata();

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

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

    UnsignedIntegerMetadata &   operator=(UnsignedIntegerMetadata && in_that);


    unsigned int                GetValue() const;

    void                        SetValue(unsigned int in_value);
};

class SPRK_API DoubleMetadata : public Metadata
{
public:
    DoubleMetadata();

    DoubleMetadata(Metadata const & in_that);

    DoubleMetadata(DoubleMetadata const & in_that);

    DoubleMetadata(DoubleMetadata && in_that);

    DoubleMetadata(char const * in_name, double in_value);

    virtual ~DoubleMetadata();

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

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

    DoubleMetadata &        operator=(DoubleMetadata && in_that);


    double                  GetValue() const;

    void                    SetValue(double in_value);
};

class SPRK_API StringMetadata : public Metadata
{
public:
    StringMetadata();

    StringMetadata(Metadata const & in_that);

    StringMetadata(StringMetadata const & in_that);

    StringMetadata(StringMetadata && in_that);

    StringMetadata(char const * in_name, char const * in_value);

    virtual ~StringMetadata();

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

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

    StringMetadata &        operator=(StringMetadata && in_that);


    UTF8                    GetValue() const;

    void                    SetValue(char const * in_value);
};

class SPRK_API TimeMetadata : public Metadata
{
public:
    TimeMetadata();

    TimeMetadata(Metadata const & in_that);

    TimeMetadata(TimeMetadata const & in_that);

    TimeMetadata(TimeMetadata && in_that);

    TimeMetadata(char const * in_name, unsigned int in_value);

    virtual ~TimeMetadata();

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

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

    TimeMetadata &          operator=(TimeMetadata && in_that);


    unsigned int            GetValue() const;

    HPS::UTF8               GetValueAsString() const;

    void                    SetValue(unsigned int in_value);
};


class SPRK_API BooleanMetadata : public Metadata
{
public:
    BooleanMetadata();

    BooleanMetadata(Metadata const & in_that);

    BooleanMetadata(BooleanMetadata const & in_that);

    BooleanMetadata(BooleanMetadata && in_that);

    BooleanMetadata(char const * in_name, bool in_value);

    virtual ~BooleanMetadata();

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

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

    BooleanMetadata &       operator=(BooleanMetadata && in_that);


    bool                    GetValue() const;

    void                    SetValue(bool in_value);
};



class SPRK_API Factory : public Sprocket
{
public:
    static CanvasArray      GetCanvases();

    static LayoutArray      GetLayouts();

    static ViewArray        GetViews();

    static ModelArray       GetModels();

    static CADModelArray    GetCADModels();

    static Canvas           CreateCanvas(HPS::WindowHandle in_window_handle, char const * in_name = "", HPS::ApplicationWindowOptionsKit const & in_options = HPS::ApplicationWindowOptionsKit());

#if TARGET_OS_ANDROID == 0 && !defined(__APPLE__)

    static Canvas           CreateCanvas(char const * in_name = "", HPS::StandAloneWindowOptionsKit const & in_options = HPS::StandAloneWindowOptionsKit());
#endif

    static Canvas           CreateCanvas(HPS::WindowKey const & in_window_key, HPS::PortfolioKey const & in_portfolio_key = HPS::PortfolioKey(), char const * in_name = "");

    static Layout           CreateLayout(char const * in_name = "");

    static View             CreateView(char const * in_name = "");

    static Model            CreateModel(char const * in_name = "");

    static Component        CreateComponent(Component const & in_owner, char const * in_name = "");

    static Component        DeInstanceComponent(ComponentPath const & in_component_path);

private:
    Factory() {}
};

class SPRK_API AxisTriadOperator : public Operator
{
public:
    AxisTriadOperator(MouseButtons in_mouse_trigger = MouseButtons::ButtonLeft(), ModifierKeys in_modifier_trigger = ModifierKeys());
    virtual HPS::UTF8 GetName() const { return "HPS_AxisTriadOperator"; }

    virtual bool            OnMouseDown(MouseState const & in_state);
    virtual bool            OnMouseUp(MouseState const & in_state);
    virtual bool            OnMouseMove(MouseState const & in_state);

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

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

private:

    bool                    AxisOrbit(HPS::WindowPoint const & in_loc);
    void                    Transition(HPS::SelectionResults selection_results);
    void                    TranslatePoint(HPS::WindowPoint * point);
    bool                    IsEventRelevant(HPS::Point const & event_location);

    bool                    operator_active;
    HPS::WindowPoint        start_point;
    HPS::Vector             start_sphere_point;
    float                   axis_subwindow_width;
    float                   axis_subwindow_height;
    HPS::TouchID            tracked_touch_ID;
    HPS::Rectangle          axis_subwindow;
    HPS::IntRectangle       axis_subwindow_offsets;
    HPS::SegmentKey         axis_triad_segment;

};

class SPRK_API SmoothTransitionCompleteEvent: public HPS::Event
{
public:
    SmoothTransitionCompleteEvent() : Event(0) {}
    virtual ~SmoothTransitionCompleteEvent();

    SmoothTransitionCompleteEvent(HPS::View const & in_view) : view(in_view)
    { channel = HPS::Object::ClassID<SmoothTransitionCompleteEvent>(); }

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

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

    virtual bool Drop(Event const * in_that_event) const
 {
        HPS_UNREFERENCED(in_that_event);
        return false;
    }

    HPS::View                   view;
};

class SPRK_API NavigationCubeOperator : public Operator
{
public:
    NavigationCubeOperator(MouseButtons in_mouse_trigger = MouseButtons::ButtonLeft(), ModifierKeys in_modifier_trigger = ModifierKeys());
    ~NavigationCubeOperator() { }

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

    virtual bool            OnMouseDown(MouseState const & in_state);
    virtual bool            OnMouseUp(MouseState const & in_state);
    virtual bool            OnMouseMove(MouseState const & in_state);

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

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

    virtual void            OnModelAttached();

    void                    SetReferenceSegment(HPS::KeyPath const & in_path_to_segment);

    void                    SetReferenceSegment(HPS::KeyPathArray const & in_path_to_segments);

    HPS::KeyPathArray       ShowReferenceSegment();

    void                    SetTransitionTime(HPS::Time const & in_time);

    HPS::Time               GetTransitionTime() const;

private:
    void                    Transition(HPS::SelectionResults const & selection_results);
    bool                    Orbit(HPS::WindowPoint const & in_loc);
    void                    TranslatePoint(HPS::WindowPoint * point);
    bool                    IsEventRelevant(HPS::Point const & event_location, HPS::KeyPath const & event_path);
    bool                    AreCamerasEqual(HPS::CameraKit const & this_camera, HPS::CameraKit const & that_camera);


    bool                    operator_active;
    HPS::TouchID            tracked_touch_ID;
    HPS::WindowPoint        start_point;
    HPS::WindowPoint        down_position;
    HPS::Vector             start_sphere_point;
    HPS::KeyPathArray       reference_segments;         //rotation and zooming happen around these segments

    HPS::SegmentKey             nav_cube_segment;
    SegmentKeyArray             style_segments;         //in order: left / right / bottom / top / front / back
    UTF8Array                   named_styles;           //in order: left / right / bottom / top / front / back
    HighlightOptionsKit         highlight_options_kit;
    std::unordered_map<intptr_t, UTF8> key_to_style_map;
    HPS::PortfolioKey           portfolio;
    HPS::ReferenceKeyArrayArray groups;
    HPS::CameraKit              previous_camera;
    int                         previous_face;
    bool                        suppress_mouse_over_highlights;

    HPS::Rectangle          nav_cube_subwindow;
    HPS::IntRectangle       nav_cube_subwindow_offsets;
    float                   nav_cube_subwindow_width;
    float                   nav_cube_subwindow_height;

    int                     highlighted_group;

    bool                    moving;
    HPS::Time               transition_time;
    HPS::SelectionOptionsKit selection_options;

    class SmoothTransitionCompleteEventHandler : public EventHandler
    {
    public:
        SmoothTransitionCompleteEventHandler(View const & in_view, bool & in_moving)
            : handler_view(in_view), handler_moving(&in_moving) {}

        ~SmoothTransitionCompleteEventHandler() { Shutdown(); }

        virtual HandleResult Handle(HPS::Event const * in_event);

    private:
        View                handler_view;
        bool *              handler_moving;
    };

    SmoothTransitionCompleteEventHandler * handler;
};




class SceneTreeItem;
typedef std::shared_ptr<SceneTreeItem> SceneTreeItemPtr;
class SceneTree;
typedef std::shared_ptr<SceneTree> SceneTreePtr;

class SPRK_API SceneTree : public Sprocket
{
public:
    enum class ItemType : uint32_t
    {
        None                            = 0x00000000,       
        GenericMask                     = 0xffff0000,       

        Segment                         = 0x00000001,       
        Include                         = 0x00000002,       
        ConditionalExpression           = 0x00000003,       
        StaticModelSegment              = 0x00000004,       
        AttributeFilter                 = 0x00000005,       

        Geometry                        = 0x00010000,       
        CuttingSection                  = 0x00010001,       
        Shell                           = 0x00010002,       
        Mesh                            = 0x00010003,       
        Grid                            = 0x00010004,       
        NURBSSurface                    = 0x00010005,       
        Cylinder                        = 0x00010006,       
        Sphere                          = 0x00010007,       
        Polygon                         = 0x00010008,       
        Circle                          = 0x00010009,       
        CircularWedge                   = 0x0001000a,       
        Ellipse                         = 0x0001000b,       
        Line                            = 0x0001000c,       
        NURBSCurve                      = 0x0001000d,       
        CircularArc                     = 0x0001000e,       
        EllipticalArc                   = 0x0001000f,       
        InfiniteLine                    = 0x00010010,       
        InfiniteRay                     = 0x00010011,       
        Marker                          = 0x00010012,       
        Text                            = 0x00010013,       
        Reference                       = 0x00010014,       
        DistantLight                    = 0x00010015,       
        Spotlight                       = 0x00010016,       

        Attribute                       = 0x00020000,       
        Portfolio                       = 0x00020001,       
        SegmentStyle                    = 0x00020002,       
        NamedStyle                      = 0x00020003,       
        MaterialPalette                 = 0x00020004,       
        Priority                        = 0x00020005,       
        Material                        = 0x00020006,       
        Camera                          = 0x00020007,       
        ModellingMatrix                 = 0x00020008,       
        UserData                        = 0x00020009,       
        TextureMatrix                   = 0x0002000a,       
        Culling                         = 0x0002000b,       
        CurveAttribute                  = 0x0002000c,       
        CylinderAttribute               = 0x0002000d,       
        EdgeAttribute                   = 0x0002000e,       
        LightingAttribute               = 0x0002000f,       
        LineAttribute                   = 0x00020010,       
        MarkerAttribute                 = 0x00020011,       
        SurfaceAttribute                = 0x00020012,       
        Selectability                   = 0x00020013,       
        SphereAttribute                 = 0x00020014,       
        Subwindow                       = 0x00020015,       
        TextAttribute                   = 0x00020016,       
        Transparency                    = 0x00020017,       
        Visibility                      = 0x00020018,       
        VisualEffects                   = 0x00020019,       
        Performance                     = 0x00020020,       
        DrawingAttribute                = 0x00020021,       
        HiddenLineAttribute             = 0x00020022,       
        ContourLine                     = 0x00020023,       
        Condition                       = 0x00020024,       
        Bounding                        = 0x00020025,       
        AttributeLock                   = 0x00020026,       
        TransformMask                   = 0x00020027,       
        ColorInterpolation              = 0x00020028,       
        CuttingSectionAttribute         = 0x00020029,       

        // window only attributes
        Debugging                       = 0x00020030,       
        PostProcessEffects              = 0x00020031,       
        SelectionOptions                = 0x00020032,       
        UpdateOptions                   = 0x00020033,       

        Definition                      = 0x00040000,       
        NamedStyleDefinition            = 0x00040001,       
        TextureDefinition               = 0x00040002,       
        LinePatternDefinition           = 0x00040003,       
        GlyphDefinition                 = 0x00040004,       
        CubeMapDefinition               = 0x00040005,       
        ImageDefinition                 = 0x00040006,       
        MaterialPaletteDefinition       = 0x00040007,       
        ShaderDefinition                = 0x00040008,       
        ShapeDefinition                 = 0x00040009,       

        Group                           = 0x00080000,       
        SegmentGroup                    = 0x00080100,       
        GeometryGroup                   = 0x00080200,       
        AttributeGroup                  = 0x00080300,       
        PortfolioGroup                  = 0x00080400,       
        StyleGroup                      = 0x00080500,       
        IncludeGroup                    = 0x00080600,       
        DefinitionGroup                 = 0x00180000,       
        NamedStyleDefinitionGroup       = 0x00180700,       
        TextureDefinitionGroup          = 0x00180800,       
        LinePatternDefinitionGroup      = 0x00180900,       
        GlyphDefinitionGroup            = 0x00180a00,       
        CubeMapDefinitionGroup          = 0x00180b00,       
        ImageDefinitionGroup            = 0x00180c00,       
        MaterialPaletteDefinitionGroup  = 0x00180d00,       
        ShaderDefinitionGroup           = 0x00180e00,       
        ShapeDefinitionGroup            = 0x00180f00,       
        GeometryGroupMask               = 0x00280000,       
        CuttingSectionGroup             = 0x00280001,       
        ShellGroup                      = 0x00280002,       
        MeshGroup                       = 0x00280003,       
        GridGroup                       = 0x00280004,       
        NURBSSurfaceGroup               = 0x00280005,       
        CylinderGroup                   = 0x00280006,       
        SphereGroup                     = 0x00280007,       
        PolygonGroup                    = 0x00280008,       
        CircleGroup                     = 0x00280009,       
        CircularWedgeGroup              = 0x0028000a,       
        EllipseGroup                    = 0x0028000b,       
        LineGroup                       = 0x0028000c,       
        NURBSCurveGroup                 = 0x0028000d,       
        CircularArcGroup                = 0x0028000e,       
        EllipticalArcGroup              = 0x0028000f,       
        InfiniteLineGroup               = 0x00280010,       
        InfiniteRayGroup                = 0x00280011,       
        MarkerGroup                     = 0x00280012,       
        TextGroup                       = 0x00280013,       
        ReferenceGroup                  = 0x00280014,       
        DistantLightGroup               = 0x00280015,       
        SpotlightGroup                  = 0x00280016,       
    };

    SceneTree();

    SceneTree(Canvas const & in_canvas);

    SceneTree(SceneTree const & in_that);

    SceneTree(SceneTree && in_that);

    virtual ~SceneTree();

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

    SceneTree &             operator=(SceneTree const & in_that);

    SceneTree &             operator=(SceneTree && in_that);

    virtual void            Assign(SceneTree const & in_that);

    bool                    Equals(SceneTree const & in_that) const;

    bool                    operator!=(SceneTree const & in_that) const;

    bool                    operator==(SceneTree const & in_that) const;


    void                    SetHighlightOptions(HighlightOptionsKit const & in_options);

    void                    SetHighlightOptions(HighlightOptionsKitArray const & in_options);

    void                    SetHighlightOptions(size_t in_count, HighlightOptionsKit const in_options []);

    void                    AddHighlightOptions(HighlightOptionsKit const & in_options);

    HighlightOptionsKitArray        GetHighlightOptions() const;


    void                    SetGroupingLimit(size_t in_limit);

    size_t                  GetGroupingLimit() const;


    void                    SetRoot(SceneTreeItemPtr const & in_root);

    SceneTreeItemPtr        GetRoot() const;


    virtual void            Flush();

    void                    SetHighlightEventHandling(bool in_state);

    bool                    GetHighlightEventHandling() const;

    void                    ReExpand();
};


class SPRK_API SceneTreeItem : public Sprocket
{
public:
    SceneTreeItem();

    SceneTreeItem(SceneTreeItem const & in_that);

    SceneTreeItem(SceneTreeItem && in_that);

    SceneTreeItem(SceneTreePtr const & in_tree, Model const & in_model);

    SceneTreeItem(SceneTreePtr const & in_tree, View const & in_view);

    SceneTreeItem(SceneTreePtr const & in_tree, Layout const & in_layout);

    SceneTreeItem(SceneTreePtr const & in_tree, Canvas const & in_canvas);

    SceneTreeItem(SceneTreePtr const & in_tree, Key const & in_key, SceneTree::ItemType in_type, char const * in_title = nullptr);

    virtual ~SceneTreeItem();

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

    SceneTreeItem &             operator=(SceneTreeItem const & in_that);

    SceneTreeItem &             operator=(SceneTreeItem && in_that);

    virtual void                Assign(SceneTreeItem const & in_that);

    bool                        Equals(SceneTreeItem const & in_that) const;

    bool                        operator!=(SceneTreeItem const & in_that) const;

    bool                        operator==(SceneTreeItem const & in_that) const;


    SceneTreePtr                GetTree() const;

    UTF8                        GetTitle() const;

    SceneTree::ItemType         GetItemType() const;

    bool                        HasItemType(SceneTree::ItemType in_mask) const;

    Key                         GetKey() const;

    KeyPath                     GetKeyPath() const;

    bool                        HasChildren() const;


    virtual SceneTreeItemPtr    AddChild(Key const & in_key, SceneTree::ItemType in_type, char const * in_title = nullptr) = 0;


    virtual void                Expand();

    virtual void                Collapse();


    bool                        IsSelected() const;

    virtual void                Select();

    virtual void                Unselect();

    bool                        IsHighlightable() const;

    bool                        IsHighlighted() const;

    void                        Highlight(size_t in_highlight_options_index = 0);

    void                        Highlight(HighlightOptionsKit const & in_highlight_options);

    void                        Unhighlight(size_t in_highlight_options_index = 0);

    void                        Unhighlight(HighlightOptionsKit const & in_highlight_options);

    bool                        IsExpanded() const;

    void                        ReExpand();
};



class ComponentTreeItem;
typedef std::shared_ptr<ComponentTreeItem> ComponentTreeItemPtr;
class ComponentTree;
typedef std::shared_ptr<ComponentTree> ComponentTreePtr;

class SPRK_API ComponentTree : public Sprocket
{
public:
    enum class ItemType
    {
        None,                           
        ExchangeComponent,              
        ExchangeModelFile,              

        ExchangeViewGroup,              
        ExchangeAnnotationViewGroup,    
        ExchangePMIGroup,               
        ExchangeModelGroup,             

        ParasolidComponent,
        ParasolidModelFile,

        DWGComponent,
        DWGModelFile,
    };

    ComponentTree();

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

    ComponentTree(ComponentTree const & in_that);

    ComponentTree(ComponentTree && in_that);

    virtual ~ComponentTree();

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

    ComponentTree &         operator=(ComponentTree const & in_that);

    ComponentTree &         operator=(ComponentTree && in_that);

    virtual void            Assign(ComponentTree const & in_that);

    bool                    Equals(ComponentTree const & in_that) const;

    bool                    operator!=(ComponentTree const & in_that) const;

    bool                    operator==(ComponentTree const & in_that) const;


    void                    SetHighlightOptions(HighlightOptionsKit const & in_options);

    void                    SetHighlightOptions(HighlightOptionsKitArray const & in_options);

    void                    SetHighlightOptions(size_t in_count, HighlightOptionsKit const in_options []);

    void                    AddHighlightOptions(HighlightOptionsKit const & in_options);

    HighlightOptionsKitArray        GetHighlightOptions() const;


    void                    SetRoot(ComponentTreeItemPtr const & in_root);

    ComponentTreeItemPtr    GetRoot() const;


    virtual void            Flush();

    void                    ReExpand();

    void                    SetHighlightEventHandling(bool in_state);

    bool                    GetHighlightEventHandling() const;
};


class SPRK_API ComponentTreeItem : public Sprocket
{
public:
    ComponentTreeItem();

    ComponentTreeItem(ComponentTreeItem const & in_that);

    ComponentTreeItem(ComponentTreeItem && in_that);

    ComponentTreeItem(ComponentTreePtr const & in_tree, CADModel const & in_cad_model);

    ComponentTreeItem(ComponentTreePtr const & in_tree, Component const & in_component, ComponentTree::ItemType in_type);

    virtual ~ComponentTreeItem();

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

    ComponentTreeItem &             operator=(ComponentTreeItem const & in_that);

    ComponentTreeItem &             operator=(ComponentTreeItem && in_that);

    virtual void                    Assign(ComponentTreeItem const & in_that);

    bool                            Equals(ComponentTreeItem const & in_that) const;

    bool                            operator!=(ComponentTreeItem const & in_that) const;

    bool                            operator==(ComponentTreeItem const & in_that) const;



    ComponentTreePtr                GetTree() const;

    UTF8                            GetTitle() const;

    ComponentTree::ItemType         GetItemType() const;

    Component                       GetComponent() const;

    bool                            HasChildren() const;

    ComponentPath                   GetPath() const;


    virtual ComponentTreeItemPtr    AddChild(Component const & in_component, ComponentTree::ItemType in_type) = 0;


    virtual void                    Expand();

    virtual void                    Collapse();


    bool                            IsHighlighted() const;

    virtual void                    OnHighlight(HighlightOptionsKit const & in_options);

    virtual void                    OnUnhighlight(HighlightOptionsKit const & in_options);


    void                            Highlight(size_t in_highlight_options_index = 0);

    void                            Highlight(HighlightOptionsKit const & in_highlight_options);

    void                            Unhighlight(size_t in_highlight_options_index = 0);

    void                            Unhighlight(HighlightOptionsKit const & in_highlight_options);


    bool                            IsHidden() const;

    virtual void                    OnHide();

    virtual void                    OnShow();

    void                            Hide();

    void                            Show();

    void                            Isolate();

    void                            ResetVisibility();

    bool                            IsExpanded() const;

    void                            ReExpand();
};

class SPRK_API AnimationControl : public SprocketControl
{
public:
    explicit AnimationControl(View const & in_view);

    AnimationControl(AnimationControl const & in_that);

    AnimationControl(AnimationControl && in_that);

    AnimationControl & operator=(AnimationControl && in_that);

    ~AnimationControl();

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

    AnimationControl &      operator=(AnimationControl const & in_that);

    void                    SetMillisecondsPerTick(Time const & in_duration);

    Time                    GetMillisecondsPerTick() const;

    void                    Play(uint32_t in_start_tick, uint32_t in_end_tick);

    void                    Play();

    void                    Stop();

    void                    Resume();

    void                    Wait();

    void                    Undo();

    void                    SetAnimation(Animation const & in_animation);

    void                    SetAnimations(size_t in_count, Animation const * const in_animations);


    void                    SetAnimations(AnimationArray const & in_animations);


    bool                    ShowAnimations(AnimationArray & out_animations);
};

}


#endif