ImGuiHelpers.h

#pragma once
// This file is part of libigl, a simple c++ geometry processing library.
//
// Copyright (C) 2018 Jérémie Dumas <jeremie.dumas@ens-lyon.org>
//
// This Source Code Form is subject to the terms of the Mozilla Public License
// v. 2.0. If a copy of the MPL was not distributed with this file, You can
// obtain one at http://mozilla.org/MPL/2.0/.
 
#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;
 
// Extend ImGui by populating its namespace directly
//
// Code snippets taken from there:
// https://eliasdaler.github.io/using-imgui-with-sfml-pt2/
namespace ImGui
{
 
static auto vector_getter = [] ( void* vec, int idx ) -> const char*
{
    auto& vector = *static_cast< std::vector<std::string>* >( vec );
    if ( idx < 0 || idx >= static_cast< int >( vector.size() ) )
    {
        assert( false && "Combo: vector_getter invalid index" );
        return "";
    }
    return vector.at( idx ).c_str();
};
 
inline bool Combo(const char* label, int* idx, const std::vector<std::string>& values)
{
  if (values.empty()) { return false; }
  return Combo(label, idx, vector_getter,
    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 items_count)
{
  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), items_count);
}
 
inline bool ListBox(const char* label, int* idx, const std::vector<std::string>& values)
{
  if (values.empty()) { return false; }
  return ListBox(label, idx, vector_getter,
    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 ImGui::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; // any of N
    bool itemDeactivatedAfterEdit = false; //any of N
    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 );
 
// similar to ImGui::InputInt but
// 1) value on output is forced to be in [min,max] range;
// 2) tooltip about valid range is shown when the item is active
MRVIEWER_API bool InputIntValid( const char* label, int* value, int min, int max,
    int step = 1, int step_fast = 100, ImGuiInputTextFlags flags = 0 );
 
// draw check-box that takes initial value from Getter and then saves the final value in Setter
template<typename Getter, typename Setter>
inline bool Checkbox(const char* label, Getter get, Setter set)
{
    bool value = get();
    bool ret = ImGui::Checkbox(label, &value);
    set(value);
    return ret;
}
 
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
{
    // All fields those have explicit initializers, even if they have sane default constructors.
    // This makes it so that Clangd doens't warn when they aren't initialized in partial aggregate initialization.
 
    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, // reset palette
    Texture = 2, // texture and legend must be updated
    Ranges  = 4, // uv-coordinates must be recomputed for the same values
    All = Texture | Ranges | Reset, // 0b111
};
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()
);
 
// Parameters for the `Plane( MR::PlaneWidget& ... )` function
enum class PlaneWidgetFlags
{
    None = 0,   // Default setup
    DisableVisibility = 1   // Don't show "Show Plane" checkbox (and the preceding separator)
};
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
 
} // namespace ImGui