MRDirectionWidget.h

Go to the documentation of this file.

#pragma once
 
#include "exports.h"
#include "MRViewerEventsListener.h"
#include "MRMesh/MRMeshFwd.h"
#include "MRMesh/MRVector3.h"
#include "MRMesh/MRChangeXfAction.h"
#include "MRMesh/MRColor.h"
#include "MRMesh/MRObjectMesh.h"
 
namespace MR
{
class MRVIEWER_CLASS DirectionWidget : public MultiListener<MouseDownListener, MouseMoveListener, MouseUpListener>
{
public:
    using OnDirectionChangedCallback = std::function<void( const Vector3f&, bool )>;
 
    class ChangeDirAction : public ChangeXfAction
    {
    public:
        ChangeDirAction( DirectionWidget& widget, const std::string& name = "Change Direction" ) :
            ChangeXfAction( name, static_pointer_cast<Object>( widget.directionObj_ ) )
        {}
    };
 
    class ChangeVisibleAction : public HistoryAction
    {
    public:
        ChangeVisibleAction( DirectionWidget& widget ) :
            widget_{ widget },
            visible_{ widget.directionObj_->visibilityMask() }
        {}
        virtual void action( Type ) override
        {
            auto oldVisible = widget_.directionObj_->visibilityMask();
            widget_.directionObj_->setVisibilityMask( visible_ );
            visible_ = oldVisible;
        }
        virtual std::string name() const override
        {
            return name_;
        }
        [[nodiscard]] virtual size_t heapBytes() const override
        {
            return name_.capacity();
        }
    private:
        DirectionWidget& widget_;
        ViewportMask visible_;
        std::string name_ = "Change Visible";
    };
 
private:
    std::shared_ptr<ObjectMesh> directionObj_;
 
    bool mousePressed_ = false;
    // if blocked cannot be moved with mouse
    bool blockedMouse_{ false };
    Vector3f worldStartPoint_;
    float viewportStartPointZ_{ 0.0f };
    OnDirectionChangedCallback onDirectionChanged_;
    Color color_ = Color::red();
    bool needToSaveHistory_ = true;
    void clear_();
 
public:
    struct Arrow
    {
        Vector3f dir;     
        Vector3f base;    
        float length = 1; 
    };
 
    MRVIEWER_API void create( Object* parent = nullptr );
 
    MRVIEWER_API void create( const Vector3f& worldDir, const Vector3f& worldBase, float worldLength, OnDirectionChangedCallback onDirectionChanged, Object* parent = nullptr );
 
    MRVIEWER_API void reset();
 
    MRVIEWER_API void setOnDirectionChangedCallback( OnDirectionChangedCallback cb );
 
    MRVIEWER_API void updateArrow( const Arrow& arrow );
 
    MRVIEWER_API void updateLocalArrow( const Arrow& arrow );
 
    MRVIEWER_API void updateDirection( const Vector3f& dir );
 
    MRVIEWER_API void updateLocalDirection( const Vector3f& dir );
 
    MRVIEWER_API void updateBase( const Vector3f& base );
 
    MRVIEWER_API void updateLocalBase( const Vector3f& base );
 
    MRVIEWER_API void updateLength( float length );
 
    MRVIEWER_API void updateLocalLength( float length );
 
    const std::shared_ptr<ObjectMesh>& obj() const { return directionObj_; }
 
    MRVIEWER_API void setVisible( bool visible );
 
    MRVIEWER_API bool isVisible() const;
 
    MRVIEWER_API void setColor( const Color& color );
 
    MRVIEWER_API const Color& getColor() const;
 
    MRVIEWER_API Arrow getArrow() const;
 
    MRVIEWER_API Arrow getLocalArrow() const;
 
    MRVIEWER_API Vector3f getBase() const;
 
    MRVIEWER_API Vector3f getLocalBase() const;
 
    MRVIEWER_API Vector3f getDirection() const;
 
    MRVIEWER_API Vector3f getLocalDirection() const;
 
    MRVIEWER_API float getLength() const;
 
    MRVIEWER_API float getLocalLength() const;
 
    MRVIEWER_API Object* getParentPtr() const;
 
    bool isMouseBlocked() const { return blockedMouse_; }
 
    void setMouseBlocked( bool blocked ) { blockedMouse_ = blocked; }
 
private:
    MRVIEWER_API virtual bool onMouseDown_( MouseButton button, int modifier ) override;
    MRVIEWER_API virtual bool onMouseUp_( MouseButton button, int modifier ) override;
    MRVIEWER_API virtual bool onMouseMove_( int mouse_x, int mouse_y ) override;
};
 
} //namespace MR