MRRibbonSchema.h

Go to the documentation of this file.

#pragma once
#include "MRViewerFwd.h"
#include "MRRibbonRegisterItem.h"
#include "MRShortcutKey.h"
#include "MRMesh/MRId.h"
#include "MRMesh/MRMeshFwd.h"
#include "MRMesh/MRphmap.h"
#include <json/forwards.h>
#include <filesystem>
#include <vector>
#include <string>
#include <memory>
#include <optional>
 
namespace MR
{
 

using SplitCaptionInfo = std::vector<std::pair<size_t, float>>;
 
struct MenuItemCaptionSize
{
    float baseSize{ 0.0f };
    SplitCaptionInfo splitInfo;
};

struct MenuItemShortcut
{
    Shortcut shortcut;
    std::vector<std::string> tags;
};
 
struct MenuItemInfo
{
    std::shared_ptr<RibbonMenuItem> item;
    std::string caption;
    std::string tooltip;
    std::string icon;
    MenuItemCaptionSize captionSize; 
    std::string helpLink; 
    LocaleDomainId localeDomainId; 
    std::optional<MenuItemShortcut> shortcut; 
 
    const std::string& getCaption() const { return !caption.empty() ? caption : item->name(); }
};

class MRVIEWER_CLASS RibbonSchemaLoadListener
{
public:
    virtual ~RibbonSchemaLoadListener() = default;
 
protected:
    friend class RibbonSchemaLoader;
    virtual void onRibbonSchemaLoad_() = 0;
};
 
using ItemMap = HashMap<std::string, MenuItemInfo>;
using TabsGroupsMap = HashMap<std::string, std::vector<std::string>>;
using GroupsItemsMap = TabsGroupsMap;
using MenuItemsList = std::vector<std::string>;
struct RibbonTab
{
    std::string name;
    int priority{ 0 };
    bool experimental{ false };
    LocaleDomainId localeDomainId; 
};

struct RibbonSchema
{
    std::vector<RibbonTab> tabsOrder;
    TabsGroupsMap tabsMap;
    GroupsItemsMap groupsMap;
    ItemMap items;
    MenuItemsList defaultQuickAccessList;
    MenuItemsList headerQuickAccessList;
    MenuItemsList sceneButtonsList;

    MRVIEWER_API void eliminateEmptyGroups();

    MRVIEWER_API void sortTabsByPriority();

    MRVIEWER_API void updateCaptions();
};

class MRVIEWER_CLASS RibbonSchemaHolder
{
public:
    MRVIEWER_API static RibbonSchema& schema();

    MRVIEWER_API static bool addItem( const std::shared_ptr<RibbonMenuItem>& item );

    MRVIEWER_API static bool delItem( const std::shared_ptr<RibbonMenuItem>& item );

    MRVIEWER_API static MenuItemInfo * findItem( const std::string& name );

    struct SearchResult
    {
        int tabIndex{ -1 }; 
        const MenuItemInfo* item{ nullptr }; 
    };

    struct SearchResultWeight
    {
        float captionWeight{ 1.f };
        float captionOrderWeight{ 1.f };
        float tooltipWeight{ 1.f };
        float tooltipOrderWeight{ 1.f };
    };

    struct SearchParams
    {
        int* captionCount = nullptr;
        std::vector<SearchResultWeight>* weights = nullptr;
        RequirementsFunction requirementsFunc = {};
    };

    MRVIEWER_API static std::vector<SearchResult> search( const std::string& searchStr, const SearchParams& params );

    MRVIEWER_API static int findItemTab( const std::shared_ptr<RibbonMenuItem>& item );
 
private:
    RibbonSchemaHolder() = default;
};

class MRVIEWER_CLASS RibbonSchemaLoader
{
public:
    RibbonSchemaLoader() = default;
    virtual ~RibbonSchemaLoader() = default;

    MRVIEWER_API virtual void loadSchema() const;

    MRVIEWER_API static void readMenuItemsList( const Json::Value& root, MenuItemsList& list );

    MRVIEWER_API static void recalcItemSizes();
protected:
    MRVIEWER_API virtual std::vector<std::filesystem::path> getStructureFiles_( const std::string& fileExtension ) const;
    MRVIEWER_API void sortFilesByOrder_( std::vector<std::filesystem::path>& files ) const;
    MRVIEWER_API void readItemsJson_( const std::filesystem::path& path ) const;
    MRVIEWER_API void readItemsJson_( const Json::Value& root, const std::string& schemaName = {} ) const;
    MRVIEWER_API void readUIJson_( const std::filesystem::path& path ) const;
    MRVIEWER_API void readUIJson_( const Json::Value& root, LocaleDomainId domainId = {} ) const;
};
 
 
template<typename T>
class RibbonMenuItemCall
{
    static_assert( std::is_base_of_v<RibbonMenuItem, T> );
public:
    template<typename F>
    RibbonMenuItemCall( F f, std::function<void(std::shared_ptr<T>)> g ) : g_( std::move( g ) )
    {
        const auto& items = RibbonSchemaHolder::schema().items;
        for ( const auto& item : items )
        {
            auto plugin = std::dynamic_pointer_cast< T >( item.second.item );
            if ( !plugin )
                continue;
            f( plugin_ = std::move( plugin ) );
            break;
        }
    }
    ~RibbonMenuItemCall()
    {
        if ( g_ && plugin_ )
            g_( plugin_ );
    }
private:
    std::shared_ptr<T> plugin_;
    std::function<void(std::shared_ptr<T>)> g_;
};

#define MR_RIBBON_ITEM_CALL(pluginType,f,g) \
    static MR::RibbonMenuItemCall<pluginType> ribbonMenuItemCall##func##pluginType##_( f, g );
 
}