ImGuiHelpers.h

Go to the documentation of this file.

#pragma once
#include "MRMesh/MRFlagOperators.h"
#include "exports.h"
#include "MRMesh/MRVector2.h"
#include "MRMesh/MRColor.h"
#include "MRViewer/MRViewerFwd.h"
#include "MRViewer/MRImGui.h"
#include "MRViewer/MRImGuiVectorOperators.h"
#include <misc/cpp/imgui_stdlib.h>
#include <algorithm>
#include <functional>
#include <cstddef>
#include <limits>
#include <string>
#include <vector>
#include <optional>
 
struct ImGuiWindow;

namespace ImGui
{
 
static const char* getVectorValue( void* vec, int idx )
{
    auto& vector = *static_cast<std::vector<std::string>*>( vec );
    if ( idx < 0 || idx >= static_cast< int >( vector.size() ) )
    {
        assert( false && "Combo: getVectorValue invalid index" );
        return "";
    }
    return vector.at( idx ).c_str();
}
 
[[deprecated]] static auto vector_getter = [] ( void* vec, int idx ) -> const char*
{
    return getVectorValue( vec, idx );
};
 
inline bool Combo( const char* label, int* idx, const std::vector<std::string>& values )
{
    if ( values.empty() )
        return false;
    return Combo( label, idx, getVectorValue, const_cast<void*>( static_cast<const void*>( &values ) ), (int) values.size() );
}
 
inline bool Combo( const char* label, int* idx, std::function<const char*( int )> getter, int itemsCount )
{
    auto func = [] ( void* data, int i ) -> const char*
    {
        auto& getter = *reinterpret_cast< std::function<const char*( int )> * >( data );
        const char* s = getter( i );
        if ( s )
            return s;
        else
        {
            assert( false && "Combo: getter return nullptr" );
            return "";
        }
    };
    return Combo( label, idx, func, reinterpret_cast< void* >( &getter ), itemsCount );
}
 
inline bool ListBox( const char* label, int* idx, const std::vector<std::string>& values )
{
    if ( values.empty() )
        return false;
    return ListBox( label, idx, getVectorValue, const_cast<void*>( static_cast<const void*>( &values ) ), (int) values.size() );
}
 
inline bool InputText(const char* label, std::string &str, ImGuiInputTextFlags flags = 0, ImGuiInputTextCallback callback = NULL, void* user_data = NULL)
{
    return InputText( label, &str, flags, callback, user_data );
}
 

MRVIEWER_API bool DragFloatValid( const char *label, float* value, float speed=1.0f,
                                float min = std::numeric_limits<float>::lowest(),
                                float max = std::numeric_limits<float>::max(),
                                const char* format = "%.3f", ImGuiSliderFlags flags = 0 );

MRVIEWER_API bool DragFloatValidLineWidth( const char* label, float* value );
 
struct MultiDragRes
{
    bool valueChanged = false; 
    bool itemDeactivatedAfterEdit = false; 
    explicit operator bool() const { return valueChanged; }
};

MRVIEWER_API MultiDragRes DragFloatValid2( const char* label, float v[2], float v_speed = 1.0f,
    float min = std::numeric_limits<float>::lowest(),
    float max = std::numeric_limits<float>::max(),
    const char* format = "%.3f", ImGuiSliderFlags flags = 0,
    const char* ( *tooltips )[2] = nullptr );

MRVIEWER_API MultiDragRes DragFloatValid3( const char * label, float v[3], float v_speed = 1.0f,
    float min = std::numeric_limits<float>::lowest(),
    float max = std::numeric_limits<float>::max(),
    const char* format = "%.3f", ImGuiSliderFlags flags = 0,
    const char* (*tooltips)[3] = nullptr );

MRVIEWER_API bool DragIntValid( const char *label, int* value, float speed = 1,
                                int min = std::numeric_limits<int>::lowest(),
                                int max = std::numeric_limits<int>::max(),
                                const char* format = "%d" );

MRVIEWER_API MultiDragRes DragIntValid3( const char* label, int v[3], float speed = 1,
                                int min = std::numeric_limits<int>::lowest(),
                                int max = std::numeric_limits<int>::max(),
                                const char* format = "%d",
                                const char* ( *tooltips )[3] = nullptr );

MRVIEWER_API bool InputIntValid( const char* label, int* value, int min, int max,
    int step = 1, int step_fast = 100, ImGuiInputTextFlags flags = 0 );

template<typename GetValueFunc, typename SetValueFunc>
inline bool Checkbox(const char* label, GetValueFunc getValue, SetValueFunc setValue)
{
    bool value = getValue();
    bool result = ImGui::Checkbox(label, &value);
    setValue(value);
    return result;
}

struct HistogramGridLine
{
    float value{};
    std::string label;
    std::string tooltip;
};

MRVIEWER_API void PlotCustomHistogram( const char* str_id,
                                 std::function<float( int idx )> values_getter,
                                 std::function<void( int idx )> tooltip,
                                 std::function<void( int idx )> on_click,
                                 int values_count, int values_offset = 0,
                                 float scale_min = FLT_MAX, float scale_max = FLT_MAX,
                                 ImVec2 frame_size = ImVec2( 0, 0 ), int selectedBarId = -1, int hoveredBarId = -1,
                                 const std::vector<HistogramGridLine>& gridIndexes = {},
                                 const std::vector<HistogramGridLine>& gridValues = {} );

MRVIEWER_API bool BeginStatePlugin( const char* label, bool* open, float width );

struct CustomStatePluginWindowParameters
{

    bool* collapsed{ nullptr };
    float width{ 0.0f };
    float height{ 0.0f };
    bool allowScrollbar = true;
    ImVec2* position{ nullptr };
    ImVec2 pivot{ 0.0f, 0.0f };
    ImGuiWindowFlags flags = ImGuiWindowFlags_NoResize | ImGuiWindowFlags_AlwaysAutoResize;
    ImVec2* changedSize{ nullptr };
    std::function<void()> customHeaderFn = nullptr;
    std::function<void()> helpBtnFn = nullptr;
    bool closeWithEscape{ true };
};

MRVIEWER_API ImVec2 GetDownPosition( const float width );

MRVIEWER_API float GetTitleBarHeght();

MRVIEWER_API std::pair<ImVec2, bool> LoadSavedWindowPos( const char* label, ImGuiWindow* window, float width, const ImVec2* position = nullptr );
MRVIEWER_API std::pair<ImVec2, bool> LoadSavedWindowPos( const char* label, float width, const ImVec2* position = nullptr );

MRVIEWER_API void SaveWindowPosition( const char* label, ImGuiWindow* window );
MRVIEWER_API void SaveWindowPosition( const char* label );

struct SavedWindowPosParams
{
    ImVec2 size = { -1, -1 };
    const ImVec2* pos = 0;
    ImGuiWindowFlags flags = 0;
};

MRVIEWER_API bool BeginSavedWindowPos( const std::string& name, bool* open, const SavedWindowPosParams& params );

MRVIEWER_API bool BeginCustomStatePlugin( const char* label, bool* open, const CustomStatePluginWindowParameters& params = {} );
MRVIEWER_API void EndCustomStatePlugin();

MRVIEWER_API bool BeginModalNoAnimation( const char* label, bool* open = nullptr, ImGuiWindowFlags flags = 0 );

MRVIEWER_API bool InputIntBitSet( const char* label, int* v, const MR::BitSet& bs, int step = 1, int step_fast = 100, ImGuiInputTextFlags flags = 0 );

MRVIEWER_API bool DragInputInt( const char* label, int* value, float speed = 1, int min = std::numeric_limits<int>::lowest(),
                                int max = std::numeric_limits<int>::max(), const char* format = "%d", ImGuiSliderFlags flags = ImGuiSliderFlags_None );

MRVIEWER_API bool Link( const char* label, uint32_t color = MR::Color( 60, 120, 255 ).getUInt32() );

enum class PaletteChanges
{
    None    = 0,
    Reset   = 1, 
    Texture = 2, 
    Ranges  = 4, 
    All = Texture | Ranges | Reset, 
};
MR_MAKE_FLAG_OPERATORS( PaletteChanges )
 

MRVIEWER_API PaletteChanges Palette(
    const char* label,
    MR::Palette& palette,
    std::string& presetName,
    float width,
    bool* fixZero = nullptr,
    float speed = 1.0f,
    float min = std::numeric_limits<float>::lowest(),
    float max = std::numeric_limits<float>::max()
);

enum class PlaneWidgetFlags
{
    None = 0,   
    DisableVisibility = 1   
};
MR_MAKE_FLAG_OPERATORS( PlaneWidgetFlags )
 

MRVIEWER_API void Plane( MR::PlaneWidget& planeWidget, PlaneWidgetFlags flags = {} );

MRVIEWER_API bool Direction( MR::DirectionWidget& dirWidget, bool& editDragging, const std::string& historyName );

MRVIEWER_API void Image( const MR::ImGuiImage& image, const ImVec2& size, const MR::Color& multColor );
MRVIEWER_API void Image( const MR::ImGuiImage& image, const ImVec2& size, const ImVec4& multColor = { 1, 1, 1, 1 } );

MRVIEWER_API MR::Vector2i GetImagePointerCoord( const MR::ImGuiImage& image, const ImVec2& size, const ImVec2& imagePos );
 

MRVIEWER_API void Spinner( float radius );

MRVIEWER_API bool ModalBigTitle( const char* title );

MRVIEWER_API bool ModalExitButton();

inline float getExpSpeed( float val, float frac = 0.01f, float min = 1e-5f )
    { return std::max( val * frac, min ); }

inline float getLuminance( const ImVec4& col )
{
    return 0.2126f * col.x + 0.7152f * col.y + 0.0722f * col.z;
}

MRVIEWER_API bool isMultiViewportEnabled();
 
#ifdef IMGUI_DISABLE_OBSOLETE_FUNCTIONS
MRVIEWER_API ImVec2 GetWindowContentRegionMax();

inline ImVec2 GetContentRegionMax()
{
    return GetContentRegionAvail() + GetCursorScreenPos() - GetWindowPos();
}
#endif
 
}