sprk_ops.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_STD_OPERATORS_H
#define SPRK_STD_OPERATORS_H
#include "sprk.h"

#include <list>
#include <stack>
#include <unordered_map>
#include <set>
#include <mutex>

namespace std
{
    template<>
    struct hash<HPS::RGBColor>
    {
        size_t operator()(HPS::RGBColor const & x) const
 {
            return (
                (51 + std::hash<float>()(x.red)) * 51 + std::hash<float>()(x.green) * 51 + std::hash<float>()(x.blue));
        }
    };
}

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

#ifndef SPRK_OPS_API
#   define SPRK_OPS_API 
#endif


namespace HPS
{

class SPRK_OPS_API PanOrbitZoomOperator : public Operator
{
public:
    PanOrbitZoomOperator(MouseButtons in_mouse_trigger = MouseButtons::ButtonLeft(), ModifierKeys in_modifier_trigger = ModifierKeys());
    virtual HPS::UTF8 GetName() const { return "HPS_PanOrbitZoomOperator"; }

    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);

private:
    HPS::WorldPoint         start;

    HPS::WindowPoint        start_point, new_point;
    HPS::Vector             start_sphere_pos, new_sphere_pos;

    bool                    operator_active;
    float                   zoom_limit;
    float                   focal_length;
    HPS::WindowPoint        last_zoom;
    HPS::Vector             last_relative;
    float                   zoom_start_field_width;
    float                   zoom_start_field_height;
    HPS::Vector             zoom_start_camera_look;
    size_t                  current_touches;

    void                    ZoomStart();
    void                    UpdateZoom(float zoom_factor);
    void                    UpdateZoomLimit();
    void                    UpdatePan(HPS::WorldPoint const & newLocation);
    void                    UpdateRoll(HPS::Vector const & relative);
};

class SPRK_OPS_API PanOperator : public Operator
{
public:
    PanOperator(MouseButtons in_mouse_trigger = MouseButtons::ButtonLeft(), ModifierKeys in_modifier_trigger = ModifierKeys());
    virtual HPS::UTF8 GetName() const { return "HPS_PanOperator"; }

    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);

private:
    bool                    PanCommon(HPS::WindowPoint const & in_loc, HPS::KeyPath const & in_key_path);

    bool                    operator_active;
    HPS::TouchID            tracked_touch_ID;
    HPS::WorldPoint         start;
};

class SPRK_OPS_API OrbitOperator : public Operator
{
public:
    OrbitOperator(MouseButtons in_mouse_trigger = MouseButtons::ButtonLeft(), ModifierKeys in_modifier_trigger = ModifierKeys());
    virtual HPS::UTF8 GetName() const { return "HPS_OrbitOperator"; }
    
    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);

private:
    bool                    OrbitCommon(HPS::WindowPoint const & in_loc);

    bool                    operator_active;
    HPS::TouchID            tracked_touch_ID;
    HPS::WindowPoint        start_point, new_point;
    HPS::Vector             start_sphere_pos, new_sphere_pos;
};


class SPRK_OPS_API RelativeOrbitOperator : public Operator
{

public:
    RelativeOrbitOperator(MouseButtons in_mouse_trigger = MouseButtons::ButtonMiddle(), ModifierKeys in_modifier_trigger = ModifierKeys());
    virtual HPS::UTF8 GetName() const { return "HPS_RelativeOrbitOperator"; }
    
    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);

    bool                    ShowCenterOfRotation(HPS::Point & out_point) const;

private:
    bool                    OrbitCommon(HPS::WindowPoint const & in_loc, HPS::CameraKit & out_camera);
    bool                    RelativeOrbitCommon(HPS::WindowPoint const & in_loc, HPS::KeyPath & in_event_path);
    void                    CalculateTarget(KeyArray const & in_event_path);

    HPS::Point                  center_of_rotation;
    bool                        operator_active;
    HPS::TouchID                tracked_touch_ID;
    HPS::Vector                 start_sphere_pos, new_sphere_pos;
    HPS::WindowPoint            start_point, new_point;
    HPS::SelectionOptionsKit    selection_options;
};

class SPRK_OPS_API ZoomOperator : public Operator
{
public:
    ZoomOperator(MouseButtons in_mouse_trigger = MouseButtons::ButtonLeft(), ModifierKeys in_modifier_trigger = ModifierKeys());
    virtual HPS::UTF8 GetName() const { return "HPS_ZoomOperator"; }

    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            OnTouchMove(TouchState const & in_state);

private:
    bool                    operator_active;
    HPS::TouchID            tracked_touch_ID;
    HPS::WindowPoint        start_point;
    float                   zoom_limit;
    float                   focal_length;
    HPS::WindowPoint        last_zoom;
    HPS::Vector             last_relative;
    float                   zoom_start_field_width;
    float                   zoom_start_field_height;
    HPS::Vector             zoom_start_camera_look;
    HPS::Point              zoom_start_camera_target;

    void                    ZoomStart();
    void                    UpdateZoom(float zoom_factor);
    void                    UpdateZoomLimit();
};


class SPRK_OPS_API ConstructRectangleOperator : public Operator
{
public:
    ConstructRectangleOperator(MouseButtons in_mouse_trigger = MouseButtons::ButtonLeft(), ModifierKeys in_modifier_trigger = ModifierKeys(), bool draw_faces = false);
    virtual HPS::UTF8 GetName() const { return "HPS_ConstructRectangleOperator"; }

    virtual void            OnViewAttached(HPS::View const & in_attached_view);
    
    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);

    bool                    IsRectangleValid() const { return is_rect_valid; }
    
    HPS::Rectangle GetWindowRectangle() const { return window_rect; }
    HPS::Rectangle GetInnerWindowRectangle() const { return inner_window_rect; }

private:
    bool                    ConstructRectCommon(WindowPoint const & in_loc);
    void                    SetupConstructionSegment();

    bool                    draw_faces;
    bool                    use_center_marker;
    bool                    is_rect_valid;
    bool                    operator_active;
    HPS::WindowPoint        window_start_point;
    HPS::WindowPoint        inner_window_start_point;
    HPS::SegmentKey         scratch_seg;
    HPS::Rectangle          window_rect;
    HPS::Rectangle          inner_window_rect;
    HPS::LineKey            temp_line_key;
    HPS::PolygonKey         temp_polygon_key;
    HPS::MarkerKey          temp_marker_key;
    HPS::TouchID            tracked_touch_ID;
};

class SPRK_OPS_API ZoomBoxOperator : public ConstructRectangleOperator
{
public:
    ZoomBoxOperator(MouseButtons in_mouse_trigger = MouseButtons::ButtonLeft(), ModifierKeys in_modifier_trigger = ModifierKeys());
    virtual HPS::UTF8 GetName() const { return "HPS_ZoomBoxOperator"; }

    virtual bool            OnMouseUp(MouseState const & in_state);
    virtual bool            OnTouchUp(TouchState const & in_state);

private:
    bool                    ZoomCommon(HPS::WindowKey const & in_window, HPS::KeyPath const & in_event_path);

};

class SPRK_OPS_API SelectAreaOperator : public ConstructRectangleOperator
{
public:
    SelectAreaOperator(MouseButtons in_mouse_trigger = MouseButtons::ButtonLeft(), ModifierKeys in_modifier_trigger = ModifierKeys());

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

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

    virtual bool                    OnMouseUp(MouseState const & in_state);
    virtual bool                    OnTouchUp(TouchState const & in_state);

    HPS::SelectionResults           GetActiveSelection() const;

    void SetSelectionOptions(HPS::SelectionOptionsKit const & in_options) { selection_options = in_options; }

    HPS::SelectionOptionsKit GetSelectionOptions() const { return selection_options; }

private:
    bool                            SelectCommon(HPS::WindowKey & in_window, HPS::ModifierKeys in_modifiers = HPS::ModifierKeys());

    HPS::SelectionResults           active_selection;
    HPS::SelectionOptionsKit        selection_options;
};


class SPRK_OPS_API HighlightAreaOperator : public SelectAreaOperator
{
public:
    HighlightAreaOperator(MouseButtons in_mouse_trigger = MouseButtons::ButtonLeft(), ModifierKeys in_modifier_trigger = ModifierKeys());

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

    virtual void                    OnViewAttached(HPS::View const & in_attached_view);
    
    virtual bool                    OnMouseUp(MouseState const & in_state);
    virtual bool                    OnTouchUp(TouchState const & in_state);

    void SetHighlightOptions(HPS::HighlightOptionsKit const & in_options) { highlight_options = in_options; }

    HPS::HighlightOptionsKit GetHighlightOptions() const { return highlight_options; }

private:
    bool                            HighlightCommon(WindowKey & in_window, ModifierKeys in_modifiers);

    HPS::HighlightOptionsKit        highlight_options;

};


class SPRK_OPS_API SelectOperator : public Operator
{
public:
    SelectOperator(MouseButtons in_mouse_trigger = MouseButtons::ButtonLeft(), ModifierKeys in_modifier_trigger = ModifierKeys());

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

    virtual bool                        OnMouseDown(MouseState const & in_state);
    virtual bool                        OnTouchDown(TouchState const & in_state);

    HPS::SelectionResults               GetActiveSelection() const;

    void SetSelectionOptions(HPS::SelectionOptionsKit const & in_options) { selection_options = in_options; }
    
    HPS::SelectionOptionsKit GetSelectionOptions() const { return selection_options; }

protected:
    HPS::SelectionResults               active_selection;

private:
    bool                                SelectCommon(HPS::Point const & in_loc, HPS::WindowKey & in_window, HPS::ModifierKeys in_modifiers = HPS::ModifierKeys());

    HPS::SelectionOptionsKit            selection_options;
};


class SPRK_OPS_API HighlightOperator : public SelectOperator
{
public:
    HighlightOperator(MouseButtons in_mouse_trigger = MouseButtons::ButtonLeft(), ModifierKeys in_modifier_trigger = ModifierKeys());

    virtual HPS::UTF8 GetName() const { return "HPS_HighlightOperator"; }
    
    virtual bool                    OnMouseDown(MouseState const & in_state);
    virtual bool                    OnTouchDown(TouchState const & in_state);

    void SetHighlightOptions(HPS::HighlightOptionsKit const & in_options) { highlight_options = in_options; }

    HPS::HighlightOptionsKit GetHighlightOptions() const { return highlight_options; }

private:
    bool                            HighlightCommon(HPS::WindowKey & in_window, HPS::ModifierKeys in_modifiers);

    HPS::HighlightOptionsKit        highlight_options;
};

class SPRK_OPS_API MouseWheelOperator : public Operator
{
public:
    enum class ZoomType
    {
        Fast,           
        Accurate,       
    };

    MouseWheelOperator(ZoomType in_default_type = ZoomType::Accurate, HPS::ModifierKeys in_alternate_type_modifiers = HPS::ModifierKeys::KeyControl());

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

    void                    UpdateZoomLimit();

    virtual bool            OnMouseWheel(HPS::MouseState const & in_state);

    virtual void            OnModelAttached();

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

private:
    float                   zoom_limit;
    ZoomType                zoom_type;
    HPS::ModifierKeys       zoom_modifier;
};

class SPRK_OPS_API TurntableOperator : public Operator
{
public:
    TurntableOperator(MouseButtons in_mouse_trigger = MouseButtons::ButtonLeft(), ModifierKeys in_modifier_trigger = ModifierKeys());
    virtual HPS::UTF8 GetName() const { return "HPS_TurntableOperator"; }
    
    virtual bool            OnMouseDown(MouseState const & in_state);
    virtual bool            OnMouseUp(MouseState const & in_state);
    virtual bool            OnMouseMove(MouseState const & in_state);
    virtual bool            OnMouseWheel(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);

private:
    void                    TurntableCommon(HPS::WindowPoint const & delta, HPS::Vector const & rotation_axis);
    void                    CalculateCenterPoint(HPS::WindowKey const & window, HPS::Point const & location);

    bool                        operator_active;
    bool                        center_point_set;
    HPS::WorldPoint             center_point;
    HPS::TouchID                tracked_touch_ID;
    HPS::WindowPoint            start_point;
    HPS::SelectionOptionsKit    selection_options;
};
    
class SPRK_OPS_API ZoomFitTouchOperator : public Operator
{
public:
    ZoomFitTouchOperator();
    virtual HPS::UTF8 GetName() const { return "HPS_ZoomFitTouchOperator"; }

    virtual bool            OnTouchDown(TouchState const & in_state);
    virtual bool            OnTouchUp(TouchState const & in_state);
    
private:
    HPS::TouchID            tracked_touch_ID;
};

class SPRK_OPS_API FlyOperator : public Operator
{
public:
    FlyOperator(MouseButtons in_mouse_trigger = MouseButtons::ButtonRight(), ModifierKeys in_modifier_trigger = ModifierKeys());
    virtual HPS::UTF8 GetName() const { return "HPS_FlyOperator"; }

    virtual bool            OnKeyDown(KeyboardState const & in_state);
    virtual bool            OnKeyUp(KeyboardState const & in_state);

    virtual bool            OnMouseDown(MouseState const & in_state);
    virtual bool            OnMouseUp(MouseState const & in_state);
    virtual bool            OnMouseMove(MouseState const & in_state);
    virtual bool            OnMouseWheel(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 bool            OnTimerTick(HPS::TimerTickEvent const & in_event);
    
    virtual void            OnModelAttached();

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

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

    /* getters/setters for inverting the X and Y axis */
    void                    InvertXAxis() { invert_x_axis = !invert_x_axis;}
    void                    InvertYAxis() { invert_y_axis = !invert_y_axis;}
    bool                    IsXAxisInverted() const { return invert_x_axis; }
    bool                    IsYAxisInverted() const { return invert_y_axis; }

    /* getters/setters for sensitivity */
    /* Keyboard sensitivity affects the speed of movement of action triggered from the keyboard, such as walking forward by pressing W */
    float                   GetKeyboardSensitivity() const { return keyboard_sensitivity; }
    void                    SetKeyboardSensitivity(float in_keyboard_sensitivity) { keyboard_sensitivity = in_keyboard_sensitivity; }

    /* Mouse sensitivity affects the speed of movement of action triggered from the mouse, such as rotating */
    float                   GetMouseSensitivity() const { return mouse_sensitivity; }
    void                    SetMouseSensitivity(float in_mouse_sensitivity) { mouse_sensitivity = in_mouse_sensitivity; }

    /* Left Joystick sensitivity affects the speed of movement of action triggered from the left joystick on touch devices */
    float                   GetLeftJoystickSensitivity() const { return left_joystick_sensitivity; }
    void                    SetLeftJoystickSensitivity(float in_left_joystick_sensitivity) { left_joystick_sensitivity = in_left_joystick_sensitivity; }

    /* Right Joystick sensitivity affects the speed of movement of action triggered from the right joystick on touch devices */
    float                   GetRightJoystickSensitivity() const { return right_joystick_sensitivity; }
    void                    SetRightJoystickSensitivity(float in_right_joystick_sensitivity) { right_joystick_sensitivity = in_right_joystick_sensitivity; }

    /* getters/setters for joystick dead zone
       The dead zone is an area around the initial touch down position where the user can move its finger
       without triggering any movement.
       The default value is 0.07. */
    float                   GetJoystickDeadZone() const { return joystick_dead_zone; }
    void                    SetJoystickDeadZone(float in_dead_zone) { joystick_dead_zone = in_dead_zone; }

    float                   GetSceneExtents() const { return scene_extents; }

protected:
    
    enum MovementFlags
    {
        no_movement             = 0x0000,
        moving_forward          = 0x0001,
        moving_back             = 0x0002,
        moving_left             = 0x0004,
        moving_right            = 0x0008,
        moving_up               = 0x0010,
        moving_down             = 0x0020,
        roll_left               = 0x0040,
        roll_right              = 0x0080,
        rotating                = 0x0100,
        move_with_touch         = 0x0200,
        rotate_with_touch       = 0x0400
    };

    unsigned int movement_flags;

    //movement functions
    void            MoveLeft(HPS::Point & position, HPS::Point & target, HPS::Vector & up);
    void            MoveRight(HPS::Point & position, HPS::Point & target, HPS::Vector & up);
    void            MoveUp(HPS::Point & position, HPS::Point & target, HPS::Vector & up);
    void            MoveDown(HPS::Point & position, HPS::Point & target, HPS::Vector & up);
    void            MoveForward(HPS::Point & position, HPS::Point & target, HPS::Vector const & direction);
    void            MoveBack(HPS::Point & position, HPS::Point & target, HPS::Vector const & direction);
    bool            MoveWithTouch(HPS::Point & position, HPS::Point & target, HPS::Vector & up, HPS::Vector const & walking_direction);
    bool            RotateScene(HPS::Point & position, HPS::Point & target);
    bool            RotateWithTouch(HPS::Point & position, HPS::Point & target);
    void            RotateCommon(HPS::Point const & delta, HPS::Point & position, HPS::Point & target);

private:
    
    enum class TouchPosition
    {
        Left,
        Right,
        None
    };
    
    //touch IDs tracked by the operator
    HPS::TouchID            left_side_touch;
    HPS::TouchID            right_side_touch;
    HPS::TouchID            second_right_touch;
    
    //current and start location for touch operations
    HPS::WindowPoint        start_point;
    HPS::WindowPoint        left_start_point;
    HPS::WindowPoint        right_start_point;
    HPS::WindowPoint        current_right_touch_position;
    HPS::WindowPoint        second_right_start_point;
    HPS::WindowPoint        current_second_right_touch_position;
    HPS::WindowPoint        start_mid_point;
    
    //virtual joystick information
    HPS::SegmentKey         left_joystick_segment;
    HPS::SegmentKey         right_joystick_segment;
    float                   joystick_dead_zone;

    //step length for left touch, right touch, and desktop operation
    float                   keyboard_sensitivity;
    float                   old_keyboard_sensitivity;
    float                   left_joystick_sensitivity;
    float                   old_left_joystick_sensitivity;
    float                   right_joystick_sensitivity;
    float                   old_right_joystick_sensitivity;
    float                   mouse_sensitivity;
    float                   scene_extents;
    
    //operator state flags
    bool                    two_right_fingers_down;
    bool                    invert_x_axis;
    bool                    invert_y_axis;
    Drawing::Handedness     world_handedness;
    bool                    shift_pressed;
    bool                    ctrl_pressed;
    HPS::KeyPath            event_path;
    HPS::WindowPoint        rotation_location;
    HPS::WindowPoint        moving_position;

    //utility functions
    void                    UpdateKeyboardState(KeyboardState const & in_state);
    float                   CalculateSceneExtents();
    void                    ComputeReasonableStepLength();
    void                    CreateJoystick(HPS::TouchState const & in_state, TouchPosition touch_position);
};

class SPRK_OPS_API WalkOperator : public FlyOperator
{
public:
    WalkOperator(MouseButtons in_mouse_trigger = MouseButtons::ButtonRight(), ModifierKeys in_modifier_trigger = ModifierKeys());

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

    virtual void            OnModelAttached();

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

    virtual bool            OnTimerTick(HPS::TimerTickEvent const & in_event);

    /* Getters / Setters for the plane the operator walks on. */
    void                    SetGroundPlane(HPS::Plane const & in_plane) { ground = in_plane; }
    HPS::Plane              GetGroundPlane() const { return ground; }

    /* Getters / Setters for camera vertical offset from the ground plane */
    void                    SetWalkerHeight(float height) { height_off_ground = height; }
    float                   GetWalkerHeight() const { return height_off_ground; }

    /* An enumeration for the direction of a vector. */
    enum class              Axis { X, Y, Z, Negative_X, Negative_Y, Negative_Z };
    static Axis             GetPrimaryAxis(HPS::Vector const & v);

    /* Returns the primary direction of the camera Up vector. */
    Axis                    GetPrimaryUpAxis() const { return primary_up_axis; }

    Axis                    UpdatePrimaryUpAxis(HPS::Vector const & v);

private:
    HPS::Plane              ground;
    HPS::Vector             walking_direction;
    float                   height_off_ground;

    Axis                    primary_up_axis;

    void                    CalculateGroundPlane();
    void                    SnapToPlane();
    void                    AdjustWalkingDirection(HPS::Vector const & camera_direction, HPS::Vector const & camera_up);
};

class SPRK_OPS_API SimpleWalkOperator : public WalkOperator
{
public:
    SimpleWalkOperator(MouseButtons in_mouse_trigger = MouseButtons::ButtonLeft(), ModifierKeys in_modifier_trigger = ModifierKeys());

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

    virtual void            OnModelAttached();

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

    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            OnMouseWheel(MouseState const & in_state);

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

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

    virtual bool            OnTimerTick(HPS::TimerTickEvent const & in_event);

    void                    SetKeyboardShiftKey(bool in_state);

    void                    SetKeyboardControlKey(bool in_state);

    void                    SetEnableMiddleMouseButtonDolly(bool in_enable);

    bool                    GetEnableMiddleMouseButtonDolly() const;

    bool                    IsMouseTriggered(MouseState const  & in_state);

private:
    class ScaleFactor
    {
    public:
        float time;
        float forward, horizontal, vertical; 
        float roll, pitch, yaw;
        ScaleFactor(float time) : time(time), 
                                  forward(1), horizontal(1), vertical(1), 
                                  roll(1), pitch(1), yaw(1) {}

        void SetTime(float t) { time = t; }
        void SetForward(float f) { forward=f; }
        void SetHorizontal(float h) { horizontal = h; }
        void SetVertical(float v) { vertical = v; }
        void SetRoll(float r) { roll = r; }
        void SetPitch(float p) { pitch = p; }
        void SetYaw(float y) { yaw = y; }

        float GetTime() const { return time; }
        float GetForward() const { return forward; }
        float GetHorizontal() const { return horizontal; }
        float GetVertical() const { return vertical; }
        float GetRoll() const { return roll; }
        float GetPitch() const { return pitch; }
        float GetYaw() const { return yaw; }

        float Forward() const { return forward*time; }
        float Horizontal() const { return horizontal*time; }
        float Vertical() const { return vertical*time; }
        float Roll() const { return roll*time; }
        float Pitch() const { return pitch*time; }
        float Yaw() const { return yaw*time; }
    };

    void                    Pan(float in_theta, float in_phi);
    void                    Dolly(float in_right, float in_up, float in_forward);
    void                    ResetCamera(HPS::CameraKit & camera) const;
    float                   CalculatePitch(HPS::CameraKit & camera) const;
    bool                    NotableCameraDifference(HPS::CameraKit const & camera1, HPS::CameraKit const & camera2);

    int                     DirectionForward() const { return 0x1; }
    int                     DirectionHorizontal() const { return 0x2; }
    int                     DirectionVertical() const { return 0x4; }
    int                     DirectionRoll() const { return 0x8; }
    int                     DirectionPitch() const { return 0x10; }
    int                     DirectionYaw() const { return 0x20; }

    bool                    Move(HPS::Point const & start, HPS::Point const & current, int directions, HPS::CameraKit & camera, ScaleFactor const & scale);

    void                    Init();

    HPS::WindowPoint        mouse_current_point;
    HPS::WindowPoint        mouse_start_point;
    bool                    mouse_operator_started;
    bool                    mouse_moving;
    bool                    middle_mouse_button_active;

    HPS::WindowPoint        touch_current_point;
    HPS::WindowPoint        touch_start_point;
    bool                    touch_operator_started;
    bool                    touch_moving;
    bool                    double_touch_active;
    HPS::Touch              touch1, touch2;

    bool                    keybrd_control;
    bool                    keybrd_shift;
    bool                    enable_middle_button_dolly;
    HPS::UpdateNotifier     last_notifier;
    bool                    pending_camera_valid;
    HPS::CameraKit          pending_camera;
    HPS::CameraKit          last_camera;
};


class SPRK_OPS_API CuttingSectionOperator : public SelectOperator
{
private:
    enum class OpState
    {
        Uninitialized,
        Initialized,
        Translating,
        FacePicking,
    };

public:
    CuttingSectionOperator(MouseButtons in_mouse_trigger = MouseButtons::ButtonLeft(), ModifierKeys in_modifier_trigger = ModifierKeys());

    virtual HPS::UTF8 GetName() const { return "HPS_CuttingSectionOperator"; }
    
    virtual void                    OnViewAttached(HPS::View const & in_attached_view);
    virtual void                    OnViewDetached(HPS::View const & in_detached_view);

    void                            SetPlanes(PlaneArray const & in_planes);

    PlaneArray                      GetPlanes();

    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 bool                    OnTimerTick(TimerTickEvent const & in_event);

    float GetIndicatorScale() const { return indicator_scale; }

    void SetIndicatorScale(float in_scale) { indicator_scale = in_scale; }

    MaterialMappingKit GetPlaneMaterial() const { return plane_material; }

    void                            SetPlaneMaterial(MaterialMappingKit const & in_plane_material);

    HighlightOptionsKit GetPlaneHighlightOptions() const { return highlight_options; }

    void SetPlaneHighlightOptions(HighlightOptionsKit const & in_highlight_options) { highlight_options = in_highlight_options; }

    bool GetMouseOverHighlighting() const { return enable_mouse_over_highlighting; }

    void SetMouseOverHighlighting(bool in_enable_mouse_over_highlighting) { enable_mouse_over_highlighting = in_enable_mouse_over_highlighting; }

    void                            SetSectioning(bool in_sectioning);

    bool GetSectioning() { return sectioning; }

    void                            SetIndicatorVisibility(bool in_use_indicator);

    bool GetIndicatorVisibility() { return (op_state == OpState::Uninitialized || op_state == OpState::FacePicking) ? true : false; }

    void                            SetPlaneVisibility(bool in_visibility);

    bool                            GetPlaneVisibility();

    /* The operator needs to know the model bounding in order to display cutting sections of the appropriate size.
    * The bounding is calculated automatically the first time a section is inserted, and when the operator detects that a Component
    * has been Shown, Hidden, Isolated or its Visibility has been Reset.
    * If changes are made to the scene outside of the ones listed above, which should warrant the model bounding to be recalculated for 
    * purposes of displaying cutting sections, the operator can be asked to do so by calling this function. */
    void                            RecalculateModelBounding();
    
private:

    class ShowHideIsolateResetHandler : public HPS::EventHandler
    {
    public:
        ShowHideIsolateResetHandler()
            : EventHandler()
        { }

        virtual ~ShowHideIsolateResetHandler()
        {
            Shutdown();
        }

        virtual HandleResult Handle(Event const * /*in_event*/)
        {
            op->model_bounding.Invalidate();
            if (!op->sections.empty())
                op->ResizeCuttingPlanes();
            return HandleResult::Handled;
        }

        void SetOperator(CuttingSectionOperator * in_operator) { op = in_operator; }

    private:
        CuttingSectionOperator * op;
    };

    void                            SetupOperatorSegment();
    void                            InsertNormalIndicator(float scale);
    ShellKey                        InsertCuttingPlaneGeometry();
    void                            MouseOverHighlighting(MouseState const & in_state);
    void                            TranslateCuttingPlane(KeyPath const & in_event_path, WindowPoint const & in_event_location);
    bool                            HandleMouseAndTouchDown(WindowKey const & in_event_source, size_t in_number_of_clicks,
                                                            KeyPath const & in_event_path, WindowPoint const & in_event_location);
    void                            ViewAlignSectionPlanes(HPS::PlaneArray & in_out_planes) const;
    void                            ResizeCuttingPlanes();
    
    struct SectionInfo
    {
        SectionInfo()
        {}

        SectionInfo(CuttingSectionKey const & in_cutting_section, ShellKeyArray const & in_shell_keys)
            : cutting_section_key(in_cutting_section)
            , shell_key_array(in_shell_keys)
        {}

        CuttingSectionKey cutting_section_key;
        ShellKeyArray shell_key_array;
    };

    typedef std::vector<SectionInfo> SectionArray;
    SectionArray                    sections;

    SegmentKey                      operator_root_segment;
    SegmentKey                      cutting_sections_segment;
    SegmentKey                      plane_representation_segment;
    bool                            sectioning;

    CuttingSectionKey               translating_section;
    size_t                          translating_plane_offset;
    ShellKey                        translating_plane_representation;

    TouchID                         tracked_touch_ID;
    MaterialMappingKit              plane_material;
    SegmentKey                      indicator_seg;
    OpState                         op_state;
    WorldPoint                      start_world_point;
    SelectionOptionsKit             selection_options;
    SelectionOptionsKit             mouse_over_selection_options;
    float                           indicator_scale;
    Vector                          plane_normal;
    bool                            plane_normal_valid;
    WorldPoint                      anchor_point;
    SimpleCuboid                    model_bounding;

    UpdateNotifier                  last_highlight_notifier;
    bool                            last_skipped_highlight_state_valid;
    MouseState                      last_skipped_highlight_state;
    bool                            is_plane_highlighted;
    PortfolioKey                    portfolio;
    SegmentKey                      style_segment;
    HighlightOptionsKit             highlight_options;
    bool                            enable_mouse_over_highlighting;
    bool                            skip_mouse_overs;

    View                            attached_view;
    KeyArray                        navigation_keys;

    ShowHideIsolateResetHandler     handler;
};

class SPRK_OPS_API MarkupOperator : public Operator
{
public:
    enum class MarkupType
    {
        Freehand,
        Text,
        Circle,
        Rectangle,
    };

    MarkupOperator(MouseButtons in_mouse_trigger = MouseButtons::ButtonLeft(), ModifierKeys in_modifier_trigger = ModifierKeys());

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

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

    virtual bool            OnMouseDown(MouseState const & in_state) override;

    virtual bool            OnMouseUp(MouseState const & in_state) override;

    virtual bool            OnMouseMove(MouseState const & in_state) override;


    virtual bool            OnTouchDown(TouchState const & in_state) override;

    virtual bool            OnTouchUp(TouchState const & in_state) override;

    virtual bool            OnTouchMove(TouchState const & in_state) override;

    virtual bool            OnKeyDown(KeyboardState const & in_state) override;

    virtual bool            OnTextInput(HPS::UTF8 const & in_text) override;

    MarkupType              GetMarkupType() { return markup_type; }

    void SetMarkupType(MarkupType in_markup_type) { markup_type = in_markup_type; }

    RGBColor GetColor() { return current_attributes.color; }

    void SetColor(RGBColor const & in_color) { current_attributes.color = in_color; }

    TextAttributeKit GetTextAttributes() { return current_attributes.text_attributes; }

    void SetTextAttribute(TextAttributeKit const & in_text_attributes) { current_attributes.text_attributes = in_text_attributes; }

    LineAttributeKit GetLineAttributes() { return current_attributes.line_attributes; }

    void SetLineAttribute(LineAttributeKit const & in_line_attributes) {current_attributes.line_attributes = in_line_attributes; }

    SegmentKey GetSegmentKey() { return markup_segment; }

    void                    DeleteMarkups();

    bool IsMarkupActive() { return operator_active; }

    class SPRK_OPS_API MarkupInsertedEvent : public HPS::Event
    {
        public:
        MarkupInsertedEvent() : Event()
        {
            channel = GetClassID();
            consumable = false;
        }

        MarkupInsertedEvent(HPS::Key const & in_markup_key, HPS::View const & in_view) : Event()
        {
            channel = GetClassID();
            consumable = false;
            markup_key = in_markup_key;
            view = in_view;
        }

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

        ~MarkupInsertedEvent();

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

        Key markup_key;
        View view;
    };

private:
    struct Attributes
    {
        RGBColor color;
        LineAttributeKit line_attributes;
        TextAttributeKit text_attributes;
    };
    
    class KeyboardHiddenEventHandler : public EventHandler
    {
    public:
        KeyboardHiddenEventHandler()
        : EventHandler()
        { }
        
        virtual ~KeyboardHiddenEventHandler()
        { Shutdown(); }
        
        virtual HandleResult Handle(Event const * /*in_event*/)
        {
            markup_operator->keyboard_active = false;
            
            markup_operator->ResetCameras();
            return HandleResult::Handled;
        }
        
        void SetOperator(MarkupOperator * in_operator) { markup_operator = in_operator; }
        
    private:
        MarkupOperator * markup_operator;
    };

    std::unordered_multimap<RGBColor, SegmentKey> attribute_map;

    MouseButtons            mouse_trigger;
    ModifierKeys            modifier_trigger;

    MarkupType              markup_type;
    SegmentKey              markup_segment;
    SegmentKey              current_segment;
    Attributes              current_attributes;

    static const RGBColor           default_color;
    static const TextAttributeKit   default_text_attributes;
    static const LineAttributeKit   default_line_attributes;

    Point                   start_point;
    bool                    start_new_line;
    LineKey                 current_line;
    size_t                  current_line_size;
    CircleKey               current_circle;
    LineKey                 current_circle_line;
    LineKey                 current_rectangle;
    View                    last_attached_view;

    bool                    start_new_note;
    bool                    keyboard_active;
    TextKey                 default_text;
    TextKey                 current_text;
    SizeTArray              text_columns;
    size_t                  current_text_row;

    bool                    operator_active;
    TouchID                 tracked_touch_id;
    TouchID                 second_tracked_touch_id;
    
    CameraKit               original_camera;
    CameraKit               original_markup_camera;
    
    KeyboardHiddenEventHandler handler;

    bool                    SetupConstructionSegments();
    void                    LookupSegment();
    void                    CreateNewMarkupSegment();
    void                    DrawFreehand(Point const & location);
    void                    DrawText();
    void                    DrawCircle(Point const & location);
    void                    DrawCircleFromTwoPoints(Point const & point_one, Point const & point_two);
    void                    DrawRectangleFromTwoPoints(Point const & point_one, Point const & point_two);
    void                    DrawRectangle(Point const & location);
    void                    CenterCameras(Point const & main_camera_center, Point const & markup_camera_center);
    void                    ResetCameras();
    void                    EndTextNote();
};

class SPRK_OPS_API AnnotationOperator : public Operator
{
public:
    AnnotationOperator(MouseButtons in_mouse_trigger = MouseButtons::ButtonLeft(), ModifierKeys in_modifier_trigger = ModifierKeys());

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

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

    virtual bool            OnMouseDown(MouseState const & in_state) override;

    virtual bool            OnMouseMove(MouseState const & in_state) override;


    virtual bool            OnTouchDown(TouchState const & in_state) override;

    virtual bool            OnTouchUp(TouchState const & in_state) override;

    virtual bool            OnTouchMove(TouchState const & in_state) override;


    virtual bool            OnKeyDown(KeyboardState const & in_state) override;

    virtual bool            OnTextInput(HPS::UTF8 const & in_text) override;

    void                    SetBackgroundShape(const char * in_shape);

    UTF8                    GetBackgroundShape() const;

    class SPRK_OPS_API AnnotationInsertedEvent : public HPS::Event
    {
        public:
        AnnotationInsertedEvent() : Event()
        {
            channel = GetClassID();
            consumable = false;
        }

        AnnotationInsertedEvent(HPS::SegmentKey const & in_text_key, HPS::View const & in_view) : Event()
        {
            channel = GetClassID();
            consumable = false;
            text_key = in_text_key;
            view = in_view;
        }

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

        ~AnnotationInsertedEvent();

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

        SegmentKey text_key;    //the key of the segment containing the annotation
        View view;
    };

private:
    void AddAnnotationUserData();
    void StartNewNote();

    bool InputDown(WindowKey const & window_key, Point const & location, KeyPath & event_path);
    bool InputMove(Point const & location, KeyPath & event_path);

    void CenterCamera(Point const & camera_center);
    void ResetCamera();

    class KeyboardHiddenEventHandler : public EventHandler
    {
    public:
        KeyboardHiddenEventHandler()
        : EventHandler()
        { }
    
        virtual ~KeyboardHiddenEventHandler()
        { Shutdown(); }
    
        virtual HandleResult Handle(Event const * /*in_event*/)
        {
            annotation_operator->keyboard_active = false;
        
            annotation_operator->ResetCamera();
            return HandleResult::Handled;
        }
    
        void SetOperator(AnnotationOperator * in_operator) { annotation_operator = in_operator; }
        
    private:
        AnnotationOperator * annotation_operator;
    };


    SegmentKey annotation_segment;                      //segment containing all annotations
    View last_attached_view;                            //the last view that was attached to this operator
    SelectionOptionsKit selection_options;              //selection options used to select geometry
    SelectionOptionsKit annotation_selection_options;   //selection options used when trying to select annotations
    bool editing_text;                                  //whether we are in a state which allows editing of an annotation
    bool start_new_note;                                //whether we should delete the text of an annotation when typing
    UTF8 annotation_user_data;                          //the user data set on annotation geometry to distinguish it from non annotation geometry
    UTF8 annotation_shape;                              //the name of the shape definition used to draw the annotation background
    
    PortfolioKey current_portfolio;                     //the portfolio used to store the default definitions used by this operator
    SegmentKey highlight_style_segment;                 //the highlight background style

    RGBColor background_color;                          //the color of the annotation background
    RGBColor leader_line_color;                         //the color of the annotation leader line and edges
    RGBColor highlight_color;                           //the color the annotation becomes while it is being edited

    TextKey text_to_edit;                               //the annotation text which we are working on
    SizeTArray text_columns;                            //the number of columns of the text for the current annotation
    size_t current_text_row;                            //the number of rows of the text for the current annotation

    //touch only flags -- these flags are only relevant when running the operator on a touch enabled device
    TouchID tracked_touch_id;                           //the ID of the touch we are tracking
    bool keyboard_active;                               //whether the software keyboard is visible
    CameraKit original_camera;                          //the camera setting as they were just before the annotation text is edited
    KeyboardHiddenEventHandler handler;                 //a handler that takes care of resetting the camera when the software keyboard is hidden
    Point touch_down_position;                          //the position the last touch down occurred at
    bool always_show_keyboard_on_touch_up;              //true if we are just inserting the annotation, false if we are editing a previously inserted one.
};

class SPRK_OPS_API HandlesOperator : public Operator
{
public:
    HandlesOperator(MouseButtons in_mouse_trigger = MouseButtons::ButtonLeft(), ModifierKeys in_modifier_trigger = ModifierKeys());
    ~HandlesOperator();

    enum class HandleType
    {
        Rotation,               
        RotationX,              
        RotationY,              
        RotationZ,              
        AxisTranslation,        
        AxisTranslationX,       
        AxisTranslationY,       
        AxisTranslationZ,       
        PlaneTranslation,       
        PlaneTranslationXY,     
        PlaneTranslationYZ,     
        PlaneTranslationZX,     
        CenterPoint,            
    };

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

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

    virtual bool            OnMouseDown(MouseState const & in_state) override;

    virtual bool            OnMouseMove(MouseState const & in_state) override;

    virtual bool            OnMouseUp(MouseState const & in_state) override;

    virtual bool            OnTouchDown(TouchState const & in_state) override;

    virtual bool            OnTouchMove(TouchState const & in_state) override;

    virtual bool            OnTouchUp(TouchState const & in_state) override;

    void SetHandlesColors(MaterialKitArray const & in_colors) { handles_colors = in_colors; }

    MaterialKitArray GetHandlesColors() const { return handles_colors; }

    void                    SetHighlightColor(RGBAColor const & in_highlight_color);

    RGBAColor GetHighlightColor() const { return highlight_color; }

    void                    SetHandlesAppearance(float in_length = 0.16f, float in_radius = 0.005f, size_t in_handles_points = 30);

    void                    SetRotationHandleAppearance(float in_offset = 0.045f, float in_angle = 25.0f, float in_tip_size = 0.15f);

    void                    SetPlaneTranslationAppearance(float in_plane_offset = 0.2f, float in_plane_length = 0.6f, float in_center_radius = 0.2f);

    void                    SetCADModel(CADModel const & in_cad_model);

    void                    GetHandlesAppearance(float & out_length, float & out_radius, size_t & out_handles_points) const;

    void                    GetRotationHandleAppearance(float & out_offset, float & out_angle, float & out_tip_size) const;

    void                    GetPlaneTranslationAppearance(float & out_plane_offset, float & out_plane_length, float & out_center_radius) const;

    void SetTrailingGeometry(bool in_state) { display_trailing_geometry = in_state; }

    bool GetTrailingGeometry() const { return display_trailing_geometry; }

    CADModel GetCADModel() const { return cad_model; }

    void                    AddHandles(HandleType handle_type);

    void                    RemoveHandles(HandleType handle_type);

    /* Dismisses the handles.*/
    void                    DismissHandles();

    class SPRK_OPS_API GeometryTransformedEvent : public HPS::Event
    {
        public:
        GeometryTransformedEvent() : Event()
        {
            channel = GetClassID();
            consumable = false;
        }

        GeometryTransformedEvent(HPS::View const & in_view, HPS::SegmentKey const & in_segment_key, HPS::MatrixKit const & in_transform) : Event()
        {
            channel = GetClassID();
            consumable = false;
            view = in_view;
            segment_key = in_segment_key;
            transform = in_transform;
        }

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

        ~GeometryTransformedEvent();

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

        SegmentKey segment_key;
        MatrixKit transform;
        View view;
    };

private:
    enum class Movement
    {
        None,
        Translation,
        Rotation,
        PlaneTranslation,
        ViewPlaneTranslation,
    };

    enum InternalHandleType : size_t
    {
        rotation_x = 0,
        rotation_y,
        rotation_z,
        axis_translation_x,
        axis_translation_y,
        axis_translation_z,
        plane_translation_x,
        plane_translation_y,
        plane_translation_z,
        center_point_translation,
        last = center_point_translation,
    };

    CanvasArray             canvases;                   //A list of Canvas objects that the View attached to this operator belongs to. This value only gets updated on OnViewAttached.
    View                    last_attached_view;         //The last View to where this operator was pushed.
    TouchID                 tracked_touch_id;           

    SegmentKey              handles;                    //top level segment
    SegmentKey              handles_segment;            //segment where the matrices for the handles transformations are accumulated
    SegmentKey              handles_geometry;           //segment where the handles geometry lives  
    SegmentKey              center_sphere;
    SegmentKey              reference_segment;          //segment containing all the net attributes of segment_to_move
    SegmentKey              segment_to_move;            //segment containing geometry affected by the handles
    SegmentKey              temporary_segment_to_move;  //segment where we accumulate changes while the handles are active
    SegmentKey              handles_trail;              //segment containing the trailing geometry
    KeyPath                 path_to_segment_to_move;
    KeyPath                 complete_referenced_path;

    //Component level variables
    CADModel                cad_model;                  //The CADModel associated with this operator. Might be Invalid.
    HPS::Type               cad_model_type;             //HPS::Type::None when cad_model is not valid.
    ComponentPath           component_path_to_move;     //Analogous to path_to_segment_to_move in the case where a CADModel is valid.
    Component               component_to_move;          //Analogous to segment_to_move in the case where a CADModel is valid.

    std::vector<bool>       requested_handle_type;
    std::vector<bool>       current_handle_type;

    WorldPoint              handles_origin_point;
    WorldPoint              movement_start_point;
    Point                   input_down_position;

    Camera::Projection      camera_projection;

    SelectionOptionsKit     geometry_selection_options;
    SelectionOptionsKit     handles_selection_options;

    HighlightOptionsKit     hide_highlight_options;
    HighlightOptionsKit     partial_transparency_options;
    HighlightOptionsKit     highlight_options;
    SegmentKey              style_segment;
    SegmentKey              transparency_style_segment;
    UTF8                    style_name;
    bool                    something_is_highlighted;
    MaterialKitArray        handles_colors;
    RGBAColor               highlight_color;
    Key                     highlighted_handle;

    //state flags
    bool                    are_handles_on;
    bool                    remove_handles;
    Movement                move_geometry;
    Movement                previous_movement;
    Vector                  movement_direction;
    Plane                   movement_plane;
    Vector                  base_vector;

    //handles appearance
    float                   handles_length;     //Length of the handles. Expressed in percentage of screen [0 - 1]
    float                   handles_radius;     //Radius of the handles. Expressed in percentage of screen [0 - 1]
    float                   arc_offset;         //Distance between the end of the translation handle and the start of the translation arc. Expressed in percentage of handles_length [0 - 1].
    float                   arc_angle;          //The angle formed by the arc handles. Must be greater than zero.
    size_t                  arc_points;         //The number of points used to draw the arc handles.
    float                   tip_size;           //The size of the tips at the end of the handles, specified as a percentage of the handles length
    float                   plane_offset;       //The distance between the axis translation handle and the start of the plane translation handle, specified as a percentage of handles_length.
    float                   plane_length;       //The length of the plane translation handle, specified as a percentage of handles_length.
    float                   center_radius;

    //handle geometry
    CylinderKey             x;
    CylinderKey             y;
    CylinderKey             z;
    CylinderKey             arc_x;
    CylinderKey             arc_y;
    CylinderKey             arc_z;
    ShellKey                xy;
    ShellKey                xz;
    ShellKey                yz;
    SphereKey               center;

    //trailing geometry
    bool                    display_trailing_geometry;
    Point                   trailing_line_start;
    Point                   trailing_circle_start;
    Point                   trailing_circle_center;
    Vector                  trailing_rotation;
    MarkerKey               trail_marker;
    LineKey                 trailing_line;
    CircularArcKey          trailing_circle;
    float                   rotation_direction;

    bool                    InputDown(size_t in_click_count, WindowKey const & in_window, KeyArray const & in_event_path, Point const & in_location);
    bool                    InputMove(KeyPath const & in_path, Point const & in_location);
    void                    InputUp(Point const & in_location);

    void                    InsertHandles();
    void                    InsertRotationHandles(bool in_x, bool in_y, bool in_z);
    void                    InsertAxisTranslationHandles(bool in_x, bool in_y, bool in_z);
    void                    InsertPlaneTranslationHandles(bool in_x, bool in_y, bool in_z);
    void                    InsertCenterPoint();

    bool                    HighlightHandles(WindowKey & in_window, KeyArray const & in_event_path, Point const & in_location);

    //moves the geometry affected by handles into a new segment, and hides the original
    void                    ReferenceGeometry(KeyPath const & in_path);

    //copies the accumulated transform from the reference geometry segment back into the original place.
    //removes the hide highlight from the original geometry
    //if a CADModel is associated with this operator, it propagates the changes to the Component and PRC/Parasolid geometry
    void                    CommitChanges();
};

class SPRK_OPS_API MeasurementOperator : public Operator
{
public:
    MeasurementOperator(MouseButtons in_mouse_trigger = MouseButtons::ButtonLeft(), ModifierKeys in_modifier_trigger = ModifierKeys());
    ~MeasurementOperator();

    enum class MeasurementType
    {
        PointToPoint,       
        Line,               
        Angle,              
        Area,               
    };

    enum class LineMeasurementPosition
    {
        LastPoint,          
        FirstPoint,         
        MidPoint,           
    };

#if TARGET_OS_IPHONE == 0 && TARGET_OS_ANDROID == 0
    enum class SelectionHint
    {
        Snapped,            
        Valid,              
        Invalid,            
    };

    SegmentKey              GetHintSegment(SelectionHint in_hint);
#endif

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

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

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

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

    virtual bool            OnKeyDown(KeyboardState const & in_state) override;

    void                    SetMeasurementType(MeasurementType in_measurement_type);

    MeasurementType GetMeasurementType() const { return current_measurement_type; }

    void                    SetVertexSnapping(bool in_state, float in_proximity = 0.0f);

    void                    GetVertexSnapping(bool & out_state, float & out_proximity) const;

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

    void                    SetSelectionHinting(bool in_state);

    bool                    GetSelectionHinting();
#endif

    void                    SetPrecision(size_t in_precision);

    size_t                  GetPrecision() const;

    void                    DeleteAllMeasurements();

    void SetLineMeasurementPosition(LineMeasurementPosition in_position) { line_measurement_position = in_position; }

    LineMeasurementPosition GetLineMeasurementPosition() const { return line_measurement_position; }

    /* An event which will be injected when a measurement is inserted into the scene through this operator.
    * Intercepting this event through a class derived from HPS::EventHandler allows for fine control over measurements
    * by having access to their backing SegmentKey.
    * Information about the inserted measurement, such as its type and value is also conveyed through this Event */
    class SPRK_OPS_API MeasurementEvent : public HPS::Event
    {
    public:
        MeasurementEvent() : Event()
        {
            channel = GetClassID();
            consumable = false;
        }

        MeasurementEvent(
            HPS::View const & in_view, 
            HPS::SegmentKey const & in_segment_key, 
            MeasurementOperator::MeasurementType in_measurement_type,
            float in_measurement_value) 
            : Event()
            , view(in_view)
            , segment_key(in_segment_key)
            , measurement_type(in_measurement_type)
            , measurement_value(in_measurement_value)
        {
            channel = GetClassID();
            consumable = false;
        }

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

        ~MeasurementEvent();

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

        SegmentKey segment_key;
        MeasurementOperator::MeasurementType measurement_type;
        float measurement_value;
        View view;
    };

private:

#if TARGET_OS_IPHONE == 0 && TARGET_OS_ANDROID == 0
    void                    SetHintState(SelectionHint in_state, HPS::Point const & world_space_point);
#endif
    bool                    EstablishSelectionScope(HPS::KeyArray const & event_path);
    bool                    InputDown(size_t in_click_count, WindowKey const & in_window, KeyArray const & in_event_path, Point const & in_location);
    bool                    InputMove(WindowKey const & in_window, KeyPath const & in_path, Point const & in_location);
    void                    InputUp(WindowKey const & in_window, KeyArray const & in_event_path, Point const & in_location);

    SegmentKey              CreateMeasurementSegment();

    void                    InsertAngleMeasurement();
    void                    InsertPointToPointMeasurement();
    void                    InsertAreaMeasurement(bool in_last_point = false);
    void                    InsertLineMeasurement(bool in_last_point = false);

    void                    RemoveMeasurementPoint();
    
    void                    CalculateAndInsertArea();
    UTF8                    FormatMeasurementText(float measurement, HPS::UTF8 const & suffix_str = HPS::UTF8());
    TextKey                 InsertMeasurementText(Point const & text_insertion_point, float measurement, HPS::UTF8 const & suffix_str = HPS::UTF8());
    void                    FinalizeMeasurement(float measurement);
    void                    CleanupActiveMeasurement(bool delete_segment = false);
    Point                   CalculateLineMeasurementPosition();

    bool                    SelectSnappingToVertex(WindowKey const & in_window, Point const & in_location, bool & point_is_snap_point);
    bool                    SelectSnappingToVertex(WindowKey const & in_window, Point const & in_location);
    bool                    SelectWithoutSnapping(WindowKey const & in_window, Point const & in_location);

    Point                   GetWorldPointFromVertex(size_t in_vertex_index, Key in_owning_geometry, KeyPath const & in_path_to_geometry);
    template <class T> Point GetPointFromGeometry(size_t in_point_index, T in_geometry)
    {
        PointArray points;
        if (in_geometry.ShowPointsByRange(in_point_index, 1, points))
            return points[0];
        return Point();
    }
    bool                    MeasurementLabelUnderCursor(WindowKey const & in_window, WindowPoint const & in_location, TextKey & out_text);
    static std::mutex       index_mutex;
    static size_t           point_to_point_index;
    static size_t           line_index;
    static size_t           angle_index;
    static size_t           area_index;

    TouchID                 tracked_touch_ID;               // for touch events, the ID of the touch that started the measurement insertion
    MeasurementType         current_measurement_type;       // what kind of measurement is currently being inserted
    bool                    measurement_in_progress;        // true is a  measurement is in the process of being inserted
    HighlightOptionsKit     highlight_options;
    SegmentKey              measurement_segment;
    View                    last_attached_view;
    CADModel                cad_model;
    HPS::Type               cad_model_type;
    UTF8                    length_units;
    UTF8                    area_units;
    WindowPoint             input_down_location;
    size_t                  input_down_click_count;

    // Selection Members
    bool                    established_selection_scope;
    SelectionOptionsKit     subentity_selection_options;
    SelectionOptionsKit     entity_selection_options;
    SelectionOptionsKit     markup_selection_options;
    TreeContext             tree_context;

    // members only valid if a measurement is being repositioned
    bool                    measurement_selected;
    PointArray              selected_measurement_points;
    Point                   selected_measurement_position;
    MeasurementType         selected_measurement_type;
    TextKey                 selected_measurement_text;
    LineKeyArray            selected_measurement_leaders;
    SegmentKeyArray         selected_measurement_segments;
    Vector                  selected_camera_direction;
    CircularArcKey          selected_angle_arc;
    Plane                   selected_angle_plane;

    // Construction Geometry Members
    SegmentKey              current_measurement_segment; //segment where the current measurement should be inserted
    
    // Angle specific members
    CircularArcKey          angle_arc;
    TextKey                 angle_text;
    float                   last_angle_measurement;
    bool                    angle_measurement_inserted;

    // selection hint members
#if TARGET_OS_IPHONE == 0 && TARGET_OS_ANDROID == 0
    bool                    selection_hint_enabled;
    bool                    selection_hint_active;
    SelectionHint           selection_hint_state;
    SegmentKey              preview_marker_root_segment;
    SegmentKey              snapped_marker_segment;
    MarkerKey               snapped_marker;
    SegmentKey              valid_marker_segment;
    MarkerKey               valid_marker;
    SegmentKey              invalid_marker_segment;
    MarkerKey               invalid_marker;
#endif

    // snapping data
    bool                    snap_to_vertex;
    float                   snap_proximity;
    size_t                  measurement_precision;

    // shared measurement variables
    PointArray              measurement_points;
    bool                    processing_double_click;

    // Area specific data
    Vector                  area_normal;

    // Line measurement variables
    LineMeasurementPosition line_measurement_position;
    LineKey                 last_inserted_line;
    TextKey                 last_inserted_length;
    float                   line_length;
};

}
#endif