MRUIStyle.h

Go to the documentation of this file.

#pragma once
 
#include "MRMesh/MRFinally.h"
#include "MRNotificationType.h"
#include "exports.h"
#include "MRUnits.h"
#include "MRVectorTraits.h"
#include "MRImGui.h"
#include <span>
#include <string>
#include <optional>
#include <filesystem>
 
namespace MR
{
 
 
class ImGuiImage;
 
namespace UI
{
 
[[nodiscard]] MRVIEWER_API float scale();
 
namespace detail
{
    MRVIEWER_API void setScale( float newScale );
}
 
[[nodiscard]] MRVIEWER_API bool isItemActive( const char* name );
 
namespace StateStorage
{
 
[[nodiscard]] MRVIEWER_API bool readBool( std::string_view key, bool defaultValue = false );
MRVIEWER_API void writeBool( std::string_view key, bool value );
 
}
 
enum class TextureType
{
    Mono,
    Gradient,
    GradientBtn,
    GradientBtnSecond,
    GradientBtnGray,
    RainbowRect,
    Count
};
 
MRVIEWER_API std::unique_ptr<ImGuiImage>& getTexture( TextureType type );
 
MRVIEWER_API void init();
 
struct ButtonCustomizationParams
{
    bool enabled = true;
 
    ImGuiButtonFlags flags = ImGuiButtonFlags_None;
 
    ImGuiImage* customTexture = nullptr;
 
    bool forceImGuiBackground = false;
 
    bool forceImguiTextColor = false;
    bool border = false;
 
    bool underlineFirstLetter = false;
 
    bool enableTestEngine = true;
 
    std::string testEngineName;
};
 
struct ButtonIconCustomizationParams
{
    ButtonCustomizationParams baseParams;
 
    bool textUnderImage = true;
};
 
struct PlotAxis
{
    ImVec2 startAxisPoint;
 
    float size = 100.f;
    float optimalLenth = 10.0f;
    float minValue = 0.0f;
    float maxValue = 1.0f;
    size_t textDashIndicesStep = 1;
 
    float lenDash = 8.0f;
    float lenDashWithText = 12.0f;
    float textPadding = 3.0f;
    VarUnitToStringParams labelFormatParams;
};
 
MRVIEWER_API ImGuiKey getImGuiModPrimaryCtrl();
 
MRVIEWER_API const char* getImGuiPrimaryCtrlName();
 
MRVIEWER_API bool checkKey( ImGuiKey passedKey );
 
[[deprecated( "Use UI::buttonEx( label, size, params ) instead" )]]
MRVIEWER_API bool buttonEx( const char* label,bool active, const Vector2f& size = Vector2f( 0, 0 ),
    ImGuiButtonFlags flags = ImGuiButtonFlags_None, const ButtonCustomizationParams& customParams = {} );
 
MRVIEWER_API bool buttonEx( const char* label, const Vector2f& size = Vector2f( 0, 0 ), const ButtonCustomizationParams& customParams = {} );
MRVIEWER_API bool button( const char* label, bool active, const Vector2f& size = Vector2f( 0, 0 ), ImGuiKey key = ImGuiKey_None );
inline bool button( const char* label, const Vector2f& size = Vector2f( 0, 0 ), ImGuiKey key = ImGuiKey_None )
{
    return button( label, true, size, key );
}
MRVIEWER_API bool buttonCommonSize( const char* label, const Vector2f& size = Vector2f( 0, 0 ), ImGuiKey key = ImGuiKey_None );
MRVIEWER_API bool buttonUnique( const char* label, int* value, int ownValue, const Vector2f& size = Vector2f( 0, 0 ), ImGuiKey key = ImGuiKey_None );
 
MRVIEWER_API void drawPoltHorizontalAxis( const PlotAxis& plotAxis );
MRVIEWER_API void drawPoltVerticalAxis( const PlotAxis& plotAxis );
 
MRVIEWER_API bool buttonIconEx(
    const std::string& name,
    const Vector2f& iconSize,
    const std::string& text,
    const ImVec2& buttonSize,
    const ButtonIconCustomizationParams& params = {} );
 
inline bool buttonIcon( const std::string& name, const Vector2f& iconSize, const std::string& text, const ImVec2& buttonSize )
{
    return buttonIconEx( name, iconSize, text, buttonSize );
}
inline bool buttonIconFlatBG(
    const std::string& name,
    const Vector2f& iconSize,
    const std::string& text,
    const ImVec2& buttonSize,
    bool textUnderIcon = true,
    ImGuiKey key = ImGuiKey_None )
{
    ButtonIconCustomizationParams params;
    params.baseParams.forceImGuiBackground = true;
    params.baseParams.forceImguiTextColor = true;
    params.textUnderImage = textUnderIcon;
    params.baseParams.underlineFirstLetter = std::string_view( ImGui::GetKeyName( key ) ) == std::string_view( text.c_str(), 1 );
    return buttonIconEx( name, iconSize, text, buttonSize, params ) || checkKey( key );
}
MRVIEWER_API bool buttonUniqueIcon(
    const std::string& iconName,
    const Vector2f& iconSize,
    const std::string& text,
    const ImVec2& buttonSize,
    int* value,
    int ownValue,
    bool textUnderIcon = true,
    ImGuiKey key = ImGuiKey_None );
 
 
MRVIEWER_API bool toggle( const char* label, bool* value );
MRVIEWER_API bool checkbox( const char* label, bool* value );
MRVIEWER_API bool checkboxOrFixedValue( const char* label, bool* value, std::optional<bool> valueOverride );
MRVIEWER_API bool checkboxValid( const char* label, bool* value, bool valid );
MRVIEWER_API bool checkboxMixed( const char* label, bool* value, bool mixed );
template <typename Getter, typename Setter>
bool checkbox( const char* label, Getter get, Setter set )
{
    bool value = get();
    bool ret = checkbox( label, &value );
    set( value );
    return ret;
}
template <typename Getter, typename Setter>
bool checkboxValid( const char* label, Getter get, Setter set, bool valid )
{
    bool value = get();
    bool ret = checkboxValid( label, &value, valid );
    set( value );
    return ret;
}
 
template <typename T>
bool checkboxFlags( const char* label, T& target, T flags )
{
    bool value = bool( target & flags );
    bool mixed = value && ( target & flags ) != flags;
    if ( checkboxMixed( label, &value, mixed ) )
    {
        if ( value )
            target |= flags;
        else
            target &= ~flags;
        return true;
    }
    return false;
}
 
struct CheckboxOrModifierState
{
    bool baseValue = false;
    bool modifierHeld = false;
 
    CheckboxOrModifierState() {}
 
    CheckboxOrModifierState( bool baseValue ) : baseValue( baseValue ) {}
 
    [[nodiscard]] explicit operator bool() const { return baseValue != modifierHeld; }
};
 
MRVIEWER_API bool checkboxOrModifier( const char* label, CheckboxOrModifierState& value, int modifiers, int respectedModifiers = -1, std::optional<bool> valueOverride = {} );
 
 
MRVIEWER_API bool radioButton( const char* label, int* value, int valButton );
MRVIEWER_API bool radioButtonOrFixedValue( const char* label, int* value, int valButton, std::optional<int> valueOverride );
 
struct RadioButtonOrModifierState
{
    int value{};
    int effectiveValue{};
 
    [[nodiscard]] explicit operator int() const
    {
        return effectiveValue;
    }
};
 
MRVIEWER_API bool radioButtonOrModifier( const char* label, RadioButtonOrModifierState& value, int valButton, int modifiers, int respectedModifiers = -1, std::optional<int> valueOverride = {} );
 
MRVIEWER_API bool colorEdit4( const char* label, Vector4f& color, ImGuiColorEditFlags flags = ImGuiColorEditFlags_None );
MRVIEWER_API bool colorEdit4( const char* label, Color& color, ImGuiColorEditFlags flags = ImGuiColorEditFlags_None );
 
MRVIEWER_API bool combo( const char* label, int* v, const std::vector<std::string>& options,
    bool showPreview = true, const std::vector<std::string>& tooltips = {}, const std::string& defaultText = "Not selected" );
 
MRVIEWER_API bool beginCombo( const char* label, const std::string& text = "Not selected", bool showPreview = true );
MRVIEWER_API void endCombo( bool showPreview = true );
 
MRVIEWER_API bool inputText( const char* label, std::string& str, ImGuiInputTextFlags flags = 0, ImGuiInputTextCallback callback = nullptr, void* user_data = nullptr );
MRVIEWER_API bool inputTextIntoArray( const char* label, char* array, std::size_t size, ImGuiInputTextFlags flags = 0, ImGuiInputTextCallback callback = nullptr, void* user_data = nullptr );
 
MRVIEWER_API bool inputTextMultiline( const char* label, std::string& str, const ImVec2& size = ImVec2(), ImGuiInputTextFlags flags = 0, ImGuiInputTextCallback callback = nullptr, void* user_data = nullptr );
MRVIEWER_API bool inputTextIntoArrayMultiline( const char* label, char* buf, size_t buf_size, const ImVec2& size = ImVec2(), ImGuiInputTextFlags flags = 0, ImGuiInputTextCallback callback = nullptr, void* user_data = nullptr );
 
struct CachedTextSize
{
    std::optional<ImVec2> cachedSize; 
};
MRVIEWER_API bool inputTextMultilineFullyScrollable( CachedTextSize& cache, const char* label, std::string& str, const ImVec2& size = ImVec2(), ImGuiInputTextFlags flags = 0, ImGuiInputTextCallback callback = nullptr, void* user_data = nullptr );
MRVIEWER_API bool inputTextIntoArrayMultilineFullyScrollable( CachedTextSize& cache, const char* label, char* buf, size_t buf_size, const ImVec2& size = ImVec2(), ImGuiInputTextFlags flags = 0, ImGuiInputTextCallback callback = nullptr, void* user_data = nullptr );
 
MRVIEWER_API bool inputTextCentered( const char* label, std::string& str, float width = 0.0f, ImGuiInputTextFlags flags = 0, ImGuiInputTextCallback callback = nullptr, void* user_data = nullptr );
 
MRVIEWER_API void inputTextCenteredReadOnly( const char* label, const std::string& str, float width = 0.0f, const std::optional<ImVec4>& textColor = {}, const std::optional<ImVec4>& labelColor = {} );
 
 
namespace detail
{
    MRVIEWER_API bool genericSlider( const char* label, ImGuiDataType data_type, void* p_data, const void* p_min, const void* p_max, const char* format, ImGuiSliderFlags flags );
 
    template <typename T>
    concept Scalar = std::is_arithmetic_v<T> && !std::is_same_v<T, bool>;
 
    template <typename T>
    concept VectorOrScalar = Scalar<typename VectorTraits<T>::BaseType>;
 
    template <typename Bound, typename Target>
    concept ValidBoundForTargetType =
        std::same_as<Bound, Target> ||
        ( VectorTraits<Bound>::size == 1 && std::same_as<typename VectorTraits<Bound>::BaseType, typename VectorTraits<Target>::BaseType> );
 
    template <typename Speed, typename Target>
    concept ValidDragSpeedForTargetType =
        std::same_as<Speed, typename VectorTraits<Target>::BaseType> || std::same_as<Speed, float> ||
        std::same_as<Speed, Target> || std::same_as<Speed, typename VectorTraits<Target>::template ChangeBase<float>>;
 
    template <UnitEnum E, VectorOrScalar T, typename F>
    [[nodiscard]] bool unitWidget( const char* label, T& v, UnitToStringParams<E>& unitParams, F&& func );
 
}
 
inline constexpr int defaultSliderFlags = ImGuiSliderFlags_AlwaysClamp;
 
template <UnitEnum E, detail::VectorOrScalar T>
requires ( VectorTraits<T>::size == 1 )
[[nodiscard]] float getDefaultDragSpeed();
 
template <UnitEnum E, detail::VectorOrScalar T, detail::VectorOrScalar TargetType>
[[nodiscard]] T getDefaultStep( bool fast );
 
template <UnitEnum E, detail::VectorOrScalar T, detail::ValidBoundForTargetType<T> U = typename VectorTraits<T>::BaseType>
bool slider( const char* label, T& v, const U& vMin, const U& vMax, UnitToStringParams<E> unitParams = {}, ImGuiSliderFlags flags = defaultSliderFlags );
 
template <UnitEnum E, detail::VectorOrScalar T, detail::ValidDragSpeedForTargetType<T> SpeedType = float, detail::ValidBoundForTargetType<T> U = typename VectorTraits<T>::BaseType>
bool drag( const char* label, T& v, SpeedType vSpeed = getDefaultDragSpeed<E, SpeedType>(), const U& vMin = std::numeric_limits<U>::lowest(), const U& vMax = std::numeric_limits<U>::max(), UnitToStringParams<E> unitParams = {}, ImGuiSliderFlags flags = defaultSliderFlags, const U& step = getDefaultStep<E, U, T>( false ), const U& stepFast = getDefaultStep<E, U, T>( true ) );
 
template <UnitEnum E, detail::VectorOrScalar T, detail::ValidBoundForTargetType<T> U = typename VectorTraits<T>::BaseType>
bool input( const char* label, T& v, const U& vMin = std::numeric_limits<U>::lowest(), const U& vMax = std::numeric_limits<U>::max(), UnitToStringParams<E> unitParams = {}, ImGuiSliderFlags flags = defaultSliderFlags );
 
template <UnitEnum E, detail::VectorOrScalar T>
void readOnlyValue( const char* label, const T& v, std::optional<ImVec4> textColor = {}, UnitToStringParams<E> unitParams = {}, std::optional<ImVec4> labelColor = {} );
 
 
template <UnitEnum E, detail::Scalar T, typename F>
bool plusMinusGeneric( const char* label, T& plus, T& minus, UnitToStringParams<E> unitToStringParams, F&& func );
 
template <UnitEnum E, detail::Scalar T, detail::ValidDragSpeedForTargetType<T> SpeedType = float, typename F = std::nullptr_t>
bool dragPlusMinus( const char* label, T& plus, T& minus, SpeedType speed = getDefaultDragSpeed<E, SpeedType>(), T plusMin = T{}, T plusMax = std::numeric_limits<T>::max(), UnitToStringParams<E> unitParams = {}, ImGuiSliderFlags flags = defaultSliderFlags, F&& wrapFunc = nullptr );
 
template <UnitEnum E, detail::Scalar T, typename F = std::nullptr_t>
bool inputPlusMinus( const char* label, T& plus, T& minus, T plusMin = T{}, T plusMax = std::numeric_limits<T>::max(), UnitToStringParams<E> unitParams = {}, ImGuiSliderFlags flags = defaultSliderFlags, F&& wrapFunc = nullptr );
 
 
MRVIEWER_API const std::pair<const char*, ImU32>& notificationChar( NotificationType type );
 
MRVIEWER_API void mouseControlHint( ImGuiMouseButton btn, const std::string& hint );
 
MRVIEWER_API void transparentText( const char* fmt, ... );
MRVIEWER_API void transparentTextWrapped( const char* fmt, ... );
MRVIEWER_API void notificationFrame( NotificationType type, const std::string& str );
 
MRVIEWER_API void setTooltipIfHovered( const std::string& text );
 
struct SeparatorParams
{
    const ImGuiImage* icon{ nullptr };
 
    Vector2f iconSize; 
 
    std::string label;
 
    std::string suffix;
 
    std::optional<Color> suffixFrameColor;
 
    bool forceImGuiSpacing = false;
 
    float extraScale = 1;
};
 
MRVIEWER_API void separator( const SeparatorParams& params );
 
MRVIEWER_API void separator( const std::string& text = "", int issueCount = -1 );
MRVIEWER_API void separator(
    const std::string& text,
    const ImVec4& color,
    const std::string& issueCount );
MRVIEWER_API void separator( const ImGuiImage& icon, const std::string& text, const Vector2f& iconSize = { 24.f, 24.f } );
MRVIEWER_API void separator( const std::string& iconName, const std::string& text, const Vector2f& iconSize = { 24.f, 24.f } );
 
MRVIEWER_API void progressBar( float fraction, const Vector2f& size = Vector2f( -1, 0 ) );
 
MRVIEWER_API bool beginTabBar( const char* str_id, ImGuiTabBarFlags flags = 0 );
MRVIEWER_API void endTabBar();
MRVIEWER_API bool beginTabItem( const char* label, bool* p_open = NULL, ImGuiTabItemFlags flags = 0 );
MRVIEWER_API void endTabItem();
 
MRVIEWER_API void alignTextToFramePadding( float padding );
MRVIEWER_API void alignTextToControl( float controlHeight );
MRVIEWER_API void alignTextToRadioButton();
MRVIEWER_API void alignTextToCheckBox();
MRVIEWER_API void alignTextToButton();
 
MRVIEWER_API void highlightWindowArea( const ImVec2& min = {-1.0f, -1.0f}, const ImVec2& max = { -1.0f, -1.0f } );
 
struct CustomConfigModalSettings
{
    std::string configName;
    std::string imGuiIdKey;
    std::filesystem::path configDirectory;
    std::string* inputName{ nullptr };
    bool inputNameDialog = true;
    bool triggerSave = false;
    bool warnExisting = true;
    std::function<bool( const std::string& name )> onSave;
    
    MRVIEWER_API std::string popupName() const;
};
 
MRVIEWER_API void saveCustomConfigModal(const CustomConfigModalSettings& settings );
 
class Disabler
{
    ImDrawList& list;
    ImDrawFlags oldFlags{};
 
public:
    Disabler( ImDrawList& list, ImDrawFlags mask )
        : list( list ), oldFlags( list.Flags )
    {
        list.Flags &= mask;
    }
 
    Disabler( const Disabler& ) = delete;
    Disabler& operator=( const Disabler& ) = delete;
 
    ~Disabler()
    {
        list.Flags = oldFlags;
    }
};
 
class LineAntialiasingDisabler : Disabler
{
public:
    LineAntialiasingDisabler( ImDrawList& list ) : Disabler( list, ~ImDrawListFlags_AntiAliasedLines )
    {
    }
};
 
} 
 
}
 
#include "MRUIStyle.ipp"