ProcessEntry.hpp

#pragma once
#include <Process/ProcessFactory.hpp>
#include <Process/ProcessMimeSerialization.hpp>
 
#include <score/tools/File.hpp>
 
#include <QIcon>
#include <QStringList>
 
#include <memory>
#include <mutex>
#include <optional>
#include <vector>
 
#include <score_plugin_library_export.h>
 
namespace score
{
struct ApplicationContext;
}
 
namespace Library
{
struct ProcessData : Process::ProcessData
{
  QIcon icon;
};
 
struct StagedNode
{
  ProcessData data;
  std::vector<StagedNode> children;
};
 
struct ProcessEntry
{
  Process::ProcessModelFactory::ConcreteKey rootKey;
  QStringList categoryPath;
  StagedNode node;
};
 
inline QStringList categoryPathForFile(
    const score::PathInfo& file, std::string_view packagesRoot,
    std::string_view presetsPath) noexcept
{
  if(file.absolutePath == packagesRoot || file.absolutePath.ends_with(presetsPath))
    return {};
  return {QString::fromUtf8(file.parentDirName.data(), file.parentDirName.size())};
}
 
class SCORE_PLUGIN_LIBRARY_EXPORT CategoryPaths
{
public:
  struct Paths
  {
    std::string packagesRoot;
    std::string presets;
  };
 
  void init(std::string processName, const score::ApplicationContext& ctx);
 
  QStringList operator()(const score::PathInfo& file) const noexcept
  {
    if(auto p = get())
      return categoryPathForFile(file, p->packagesRoot, p->presets);
    return {};
  }
 
  std::shared_ptr<const Paths> get() const noexcept
  {
    std::lock_guard lock{m_mutex};
    return m_paths;
  }
 
private:
  mutable std::mutex m_mutex;
  std::shared_ptr<const Paths> m_paths;
};
}