ImGuiMenu.h

Go to the documentation of this file.

#pragma  once
 
#include "MRViewerPlugin.h"
#include "MRViewerEventsListener.h"
#include "MRNotificationType.h"
#include "MRSignalCombiners.h"
#include "MRShowModal.h"
#include "imgui.h"
#include "MRMesh/MRIRenderObject.h" 
#include "MRMesh/MRFlagOperators.h"
#include "MRMesh/MRBox.h"
#include "MRMesh/MRColor.h"
#include <optional>
#include <unordered_map>
 
struct ImGuiContext;
struct ImGuiWindow;
 
namespace MR
{
 
 
class ShortcutManager;
class MeshModifier;
struct UiRenderManager;
class SceneObjectsListDrawer;
class ObjectComparableWithReference;
 
enum class SelectedTypesMask
{
    ObjectBit = 1 << 0,
    ObjectPointsHolderBit = 1 << 1,
    ObjectLinesHolderBit = 1 << 2,
    ObjectMeshHolderBit = 1 << 3,
    ObjectLabelBit = 1 << 4,
    ObjectMeshBit = 1 << 5,
    ObjectFeatureBit = 1 << 6,
    ObjectMeasurementBit = 1 << 7,
};
MR_MAKE_FLAG_OPERATORS( SelectedTypesMask )
 
class MRVIEWER_CLASS ImGuiMenu : public MR::ViewerPlugin,
    public MultiListener<
    MouseDownListener, MouseMoveListener, MouseUpListener, MouseScrollListener, CursorEntranceListener,
    CharPressedListener, KeyDownListener, KeyUpListener, KeyRepeatListener,
    SpaceMouseMoveListener, SpaceMouseDownListener,
    TouchpadRotateGestureBeginListener, TouchpadRotateGestureUpdateListener, TouchpadRotateGestureEndListener,
    TouchpadSwipeGestureBeginListener, TouchpadSwipeGestureUpdateListener, TouchpadSwipeGestureEndListener,
    TouchpadZoomGestureBeginListener, TouchpadZoomGestureUpdateListener, TouchpadZoomGestureEndListener,
    PostResizeListener, PostRescaleListener, PostFocusListener>
{
    using ImGuiMenuMultiListener = MultiListener<
        MouseDownListener, MouseMoveListener, MouseUpListener, MouseScrollListener,
        CharPressedListener, KeyDownListener, KeyUpListener, KeyRepeatListener,
        SpaceMouseMoveListener, SpaceMouseDownListener,
        TouchpadRotateGestureBeginListener, TouchpadRotateGestureUpdateListener, TouchpadRotateGestureEndListener,
        TouchpadSwipeGestureBeginListener, TouchpadSwipeGestureUpdateListener, TouchpadSwipeGestureEndListener,
        TouchpadZoomGestureBeginListener, TouchpadZoomGestureUpdateListener, TouchpadZoomGestureEndListener,
        PostResizeListener, PostRescaleListener, PostFocusListener>;
protected:
  float hidpi_scaling_;
 
  float pixel_ratio_;
 
  float userScaling_ = 1.0f;
 
  ImGuiContext * context_ = nullptr;
  ImGuiWindow* prevFrameFocusPlugin_ = nullptr;
 
  bool pollEventsInPreDraw = false; 
 
  bool showShortcuts_{ false };
  bool showStatistics_{ false };
  long long frameTimeMillisecThreshold_{ 25 };
  bool showRenameModal_{ false };
  std::string renameBuffer_;
  std::string popUpRenameBuffer_;
  bool needModalBgChange_{ false };
  bool showInfoModal_{ false };
  std::string storedModalMessage_;
  NotificationType modalMessageType_{ NotificationType::Error };
  std::shared_ptr<ShortcutManager> shortcutManager_;
 
  ImVec2 sceneWindowPos_;
  ImVec2 sceneWindowSize_;
  ImVec2 mainWindowPos_;
  ImVec2 mainWindowSize_;
 
  MRVIEWER_API virtual void setupShortcuts_();
 
  bool savedDialogPositionEnabled_{ false };
 
  std::weak_ptr<Object> lastRenameObj_;
  Box3f selectionLocalBox_; 
  Box3f selectionWorldBox_;
  enum class CoordType : int
  {
      Local,
      World,
  } coordType_{ CoordType::Local };
 
  struct LabelParams
  {
      std::string lastLabel;
      std::string labelBuffer;
      std::shared_ptr<ObjectLabel> obj{ nullptr };
  } oldLabelParams_;
 
  bool allowRemoval_{ true };
  bool uniformScale_{ true };
  bool xfHistUpdated_{ false };
  bool invertedRotation_{ false };
 
  std::optional<std::pair<std::string, Vector4f>> storedColor_;
  Vector4f getStoredColor_( const std::string& str, const Color& defaultColor ) const;
 
  std::string searchPluginsString_;
 
  std::vector<std::shared_ptr<MR::MeshModifier>> modifiers_;
 
  enum ViewportConfigurations
  {
      Single,
      Horizontal, 
      Vertical, 
      Quad 
  } viewportConfig_{ Single };
 
  bool selectionChangedToSingleObj_{ false };
  ViewportId selectedViewport_ = {};
 
  std::weak_ptr<Object> editedFeatureObject_;
  AffineXf3f editedFeatureObjectOldXf_;
 
    struct TagEditorState
    {
        std::string initName;
        std::string name;
        bool initHasFrontColor = false;
        bool hasFrontColor = false;
        ImVec4 selectedColor;
        ImVec4 unselectedColor;
    };
    TagEditorState tagEditorState_;
    bool showEditTag_ = false;
    std::string tagNewName_;
 
public:
  MRVIEWER_API static const std::shared_ptr<ImGuiMenu>& instance();
 
  MRVIEWER_API virtual void init(MR::Viewer *_viewer) override;
 
  MRVIEWER_API virtual void initBackend();
 
  MRVIEWER_API virtual void startFrame();
  MRVIEWER_API virtual void finishFrame();
 
  MRVIEWER_API virtual void load_font(int font_size = 13);
  MRVIEWER_API virtual void reload_font(int font_size = 13);
 
  MRVIEWER_API virtual void shutdown() override;
 
  MRVIEWER_API virtual void draw_menu();
 
  MRVIEWER_API void draw_helpers();
 
  MRVIEWER_API virtual void draw_viewer_window();
 
  virtual void draw_custom_window() {}
 
  std::function<void(void)> callback_draw_viewer_window;
  std::function<void(void)> callback_draw_viewer_menu;
  std::function<void(void)> callback_draw_custom_window;
 
  void draw_labels_window();
 
  MRVIEWER_API void draw_text(
      const Viewport& viewport,
      const Vector3f& pos,
      const Vector3f& normal,
      const std::string& text,
      const Color& color,
      bool clipByViewport );
 
  MRVIEWER_API float pixel_ratio();
 
  MRVIEWER_API float hidpi_scaling();
 
  MRVIEWER_API float menu_scaling() const;
 
  float getUserScaling() const { return userScaling_; }
  MRVIEWER_API void setUserScaling( float scaling );
 
  MRVIEWER_API ImGuiContext* getCurrentContext() const;
 
  ImGuiWindow* getLastFocusedPlugin() const { return prevFrameFocusPlugin_; };
 
  MRVIEWER_API virtual void showModalMessage( const std::string& msg, NotificationType msgType );
 
  MRVIEWER_API virtual std::filesystem::path getMenuFontPath() const;
 
  MRVIEWER_API void setDrawTimeMillisecThreshold( long long maxGoodTimeMillisec );
 
  MRVIEWER_API void draw_scene_list();
  MRVIEWER_API void draw_scene_list_content( const std::vector<std::shared_ptr<Object>>& selected, const std::vector<std::shared_ptr<Object>>& all );
 
  MRVIEWER_API virtual void draw_selection_properties( const std::vector<std::shared_ptr<Object>>& selected );
  MRVIEWER_API virtual void draw_selection_properties_content( const std::vector<std::shared_ptr<Object>>& selected );
 
  MRVIEWER_API virtual bool drawCollapsingHeader_( const char* label, ImGuiTreeNodeFlags flags = 0);
  MRVIEWER_API virtual bool drawCollapsingHeaderTransform_();
 
  bool make_visualize_checkbox( std::vector<std::shared_ptr<VisualObject>> selectedVisualObjs, const char* label, AnyVisualizeMaskEnum type, MR::ViewportMask viewportid, bool invert = false );
  template<typename ObjectT>
  void make_color_selector( std::vector<std::shared_ptr<ObjectT>> selectedVisualObjs, const char* label,
                            std::function<Vector4f( const ObjectT* )> getter,
                            std::function<void( ObjectT*, const Vector4f& )> setter );
  template<typename ObjType,typename ValueT>
  void make_width( std::vector<std::shared_ptr<VisualObject>> selectedVisualObjs, const char* label,
                   std::function<ValueT( const ObjType* )> getter,
                   std::function<void( ObjType*, const ValueT& )> setter );
 
  void make_light_strength( std::vector<std::shared_ptr<VisualObject>> selectedVisualObjs, const char* label,
    std::function<float( const VisualObject* )> getter,
    std::function<void( VisualObject*, const float& )> setter);
 
  template <typename T, typename ObjectType>
  void make_slider( std::vector<std::shared_ptr<ObjectType>> selectedVisualObjs, const char* label,
    std::function<T( const ObjectType* )> getter,
    std::function<void( ObjectType*, T )> setter, T min, T max );
 
  void make_points_discretization( std::vector<std::shared_ptr<VisualObject>> selectedVisualObjs, const char* label,
  std::function<int( const ObjectPointsHolder* )> getter,
  std::function<void( ObjectPointsHolder*, const int& )> setter );
 
  std::shared_ptr<ShortcutManager> getShortcutManager() { return shortcutManager_; };
 
  MRVIEWER_API void add_modifier( std::shared_ptr<MR::MeshModifier> modifier );
 
  MRVIEWER_API void allowSceneReorder( bool allow );
  bool checkPossibilityObjectRemoval() { return allowRemoval_; };
 
  MRVIEWER_API void allowObjectsRemoval( bool allow );
 
  MRVIEWER_API void tryRenameSelectedObject();
 
  MRVIEWER_API void setObjectTreeState( const Object* obj, bool open );
 
  MRVIEWER_API void expandObjectTreeAndScroll( const Object* obj );
 
  MRVIEWER_API void setShowShortcuts( bool val );
  MRVIEWER_API bool getShowShortcuts() const;
 
  void enableSavedDialogPositions( bool on ) { savedDialogPositionEnabled_ = on; }
  bool isSavedDialogPositionsEnabled() const { return savedDialogPositionEnabled_; }
 
  MRVIEWER_API virtual UiRenderManager& getUiRenderManager();
 
  MRVIEWER_API const std::shared_ptr<SceneObjectsListDrawer>& getSceneObjectsList() { return sceneObjectsList_; };
 
  enum class NameTagSelectionMode
  {
      selectOne,
      toggle,
  };
  using NameTagClickSignal = boost::signals2::signal<bool( Object& object, NameTagSelectionMode mode ), StopOnTrueCombiner>;
  NameTagClickSignal nameTagClickSignal;
  MRVIEWER_API bool simulateNameTagClick( Object& object, NameTagSelectionMode mode );
  MRVIEWER_API bool simulateNameTagClickWithKeyboardModifiers( Object& object );
 
  using DrawSceneUiSignal = boost::signals2::signal<void( ViewportId viewportId, UiRenderParams::UiTaskList& tasks )>;
  DrawSceneUiSignal drawSceneUiSignal;
 
  MRVIEWER_API bool anyImGuiWindowIsHovered() const;
  MRVIEWER_API bool anyUiObjectIsHovered() const;
 
    MRVIEWER_API SelectedTypesMask calcSelectedTypesMask( const std::vector<std::shared_ptr<Object>>& selectedObjs );
    MRVIEWER_API bool drawGeneralOptions( const std::vector<std::shared_ptr<Object>>& selectedObjs );
    MRVIEWER_API bool drawAdvancedOptions( const std::vector<std::shared_ptr<VisualObject>>& selectedObjs, SelectedTypesMask selectedMask );
    MRVIEWER_API bool drawRemoveButton( const std::vector<std::shared_ptr<Object>>& selectedObjs );
    MRVIEWER_API bool drawDrawOptionsCheckboxes( const std::vector<std::shared_ptr<VisualObject>>& selectedObjs, SelectedTypesMask selectedMask );
    MRVIEWER_API bool drawDrawOptionsColors( const std::vector<std::shared_ptr<VisualObject>>& selectedObjs );
 
    struct SelectionInformationStyle
    {
        Color textColor;
        Color labelColor;
        Color selectedTextColor;
        float itemWidth {};
        float item2Width {};
        float item3Width {};
    };
 
protected:
    MRVIEWER_API virtual void drawModalMessage_();
 
    bool capturedMouse_{ false };
    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;
    MRVIEWER_API virtual bool onMouseScroll_( float delta_y ) override;
    MRVIEWER_API virtual void cursorEntrance_( bool entered ) override;
    MRVIEWER_API virtual bool onCharPressed_( unsigned key, int modifiers ) override;
    MRVIEWER_API virtual bool onKeyDown_( int key, int modifiers ) override;
    MRVIEWER_API virtual bool onKeyUp_( int key, int modifiers ) override;
    MRVIEWER_API virtual bool onKeyRepeat_( int key, int modifiers ) override;
    MRVIEWER_API virtual void postResize_( int width, int height ) override;
    MRVIEWER_API virtual void postRescale_( float x, float y) override;
    MRVIEWER_API virtual bool spaceMouseMove_( const Vector3f& translate, const Vector3f& rotate ) override;
    MRVIEWER_API virtual bool spaceMouseDown_( int key ) override;
    MRVIEWER_API virtual bool touchpadRotateGestureBegin_() override;
    MRVIEWER_API virtual bool touchpadRotateGestureUpdate_( float angle ) override;
    MRVIEWER_API virtual bool touchpadRotateGestureEnd_() override;
    MRVIEWER_API virtual bool touchpadSwipeGestureBegin_() override;
    MRVIEWER_API virtual bool touchpadSwipeGestureUpdate_( float deltaX, float deltaY, bool kinetic ) override;
    MRVIEWER_API virtual bool touchpadSwipeGestureEnd_() override;
    MRVIEWER_API virtual bool touchpadZoomGestureBegin_() override;
    MRVIEWER_API virtual bool touchpadZoomGestureUpdate_( float scale, bool kinetic ) override;
    MRVIEWER_API virtual bool touchpadZoomGestureEnd_() override;
    MRVIEWER_API virtual void postFocus_( bool focused ) override;
 
    MRVIEWER_API virtual void rescaleStyle_();
 
    MRVIEWER_API float drawSelectionInformation_();
    MRVIEWER_API void drawFeaturePropertiesEditor_( const std::shared_ptr<Object>& object );
 
    MRVIEWER_API void drawComparablePropertiesEditor_( ObjectComparableWithReference& object );
 
    MRVIEWER_API virtual void drawCustomSelectionInformation_( const std::vector<std::shared_ptr<Object>>& selected, const SelectionInformationStyle& style );
 
    MRVIEWER_API virtual void draw_custom_selection_properties( const std::vector<std::shared_ptr<Object>>& selected );
 
    MRVIEWER_API void drawTagInformation_( const std::vector<std::shared_ptr<Object>>& selected );
 
    MRVIEWER_API float drawTransform_();
 
    MRVIEWER_API virtual bool drawTransformContextMenu_( const std::shared_ptr<Object>&  ) { return false; }
 
    MRVIEWER_API virtual void drawShortcutsWindow_();
    MRVIEWER_API float getSceneInfoItemWidth_( int itemCount  = 1 );
 
    class UiRenderManagerImpl : public UiRenderManager
    {
    public:
        MRVIEWER_API void preRenderViewport( ViewportId viewport ) override;
        MRVIEWER_API void postRenderViewport( ViewportId viewport ) override;
        MRVIEWER_API BasicUiRenderTask::BackwardPassParams beginBackwardPass( ViewportId viewport, UiRenderParams::UiTaskList& tasks ) override;
        MRVIEWER_API void finishBackwardPass( ViewportId viewport, const BasicUiRenderTask::BackwardPassParams& params ) override;
 
        BasicUiRenderTask::InteractionMask consumedInteractions{};
 
        MRVIEWER_API bool canConsumeEvent( BasicUiRenderTask::InteractionMask event ) const;
    };
    std::unique_ptr<UiRenderManagerImpl> uiRenderManager_;
    std::shared_ptr<SceneObjectsListDrawer> sceneObjectsList_;
};
 
 
MRVIEWER_API void reserveKeyEvent( ImGuiKey key );
 
 
}