ProcessesItemModel.hpp

#pragma once
#include <Process/ProcessFactory.hpp>
#include <Process/ProcessMimeSerialization.hpp>
 
#include <Library/LibrarySettings.hpp>
#include <Library/ProcessEntry.hpp>
 
#include <score/application/ApplicationContext.hpp>
#include <score/model/tree/TreeNode.hpp>
#include <score/model/tree/TreeNodeItemModel.hpp>
#include <score/tools/File.hpp>
#include <score/tools/RecursiveWatch.hpp>
#include <score/tools/std/Optional.hpp>
#include <score/tools/std/StringHash.hpp>
 
#include <ossia/detail/hash_map.hpp>
 
#include <QDir>
#include <QIcon>
 
#include <nano_observer.hpp>
#include <score_plugin_library_export.h>
 
#include <verdigris>
 
namespace score
{
struct GUIApplicationContext;
}
 
namespace Library
{
using ProcessNode = TreeNode<ProcessData>;
 
class SCORE_PLUGIN_LIBRARY_EXPORT ProcessesItemModel
    : public TreeNodeBasedItemModel<ProcessNode>
    , public Nano::Observer
{
public:
  ProcessesItemModel(const score::GUIApplicationContext& ctx, QObject* parent);
 
  void rescan();
  QModelIndex find(const Process::ProcessModelFactory::ConcreteKey& k);
 
  void publish(ProcessEntry&& entry);
 
  void publish(ProcessEntry&& entry, uint64_t generation);
 
  uint64_t generation() const noexcept { return m_generation; }
 
  void replaceChildren(
      const Process::ProcessModelFactory::ConcreteKey& key,
      std::vector<StagedNode> children);
 
  void clearAnchorKey(const Process::ProcessModelFactory::ConcreteKey& key);
 
  void flushPending();
 
  ProcessNode& rootNode() override;
  const ProcessNode& rootNode() const override;
 
  // Data reading
  int columnCount(const QModelIndex& parent) const override;
  QVariant data(const QModelIndex& index, int role) const override;
 
  QVariant headerData(int section, Qt::Orientation orientation, int role) const override;
  Qt::ItemFlags flags(const QModelIndex& index) const override;
 
  // Drag, drop, etc.
  QStringList mimeTypes() const override;
  QMimeData* mimeData(const QModelIndexList& indexes) const override;
  Qt::DropActions supportedDragActions() const override;
 
  void on_newPlugin(const score::InterfaceBase& fact);
 
private:
  struct PendingEntry
  {
    ProcessEntry entry;
    uint64_t generation{};
  };
 
  ProcessNode& addCategory(const QString& cat);
  QModelIndex indexFromNode(ProcessNode& n);
  void publishRun(PendingEntry* entries, std::size_t count);
  void scheduleFlush();
 
  const score::GUIApplicationContext& context;
  ProcessNode m_root;
 
  // The process nodes entries anchor to, by concrete key. Owned by the tree;
  // rebuilt by rescan() and extended by on_newPlugin, so it never dangles.
  ossia::hash_map<Process::ProcessModelFactory::ConcreteKey, ProcessNode*> m_anchors;
 
  std::vector<PendingEntry> m_pending;
  uint64_t m_generation{};
  bool m_flushQueued{};
  bool m_inReset{};
};
 
}
 
inline QDataStream& operator<<(QDataStream& i, const Library::ProcessData& sel)
{
  return i;
}
inline QDataStream& operator>>(QDataStream& i, Library::ProcessData& sel)
{
  return i;
}
 
W_REGISTER_ARGTYPE(Library::ProcessData)
Q_DECLARE_METATYPE(Library::ProcessData)
W_REGISTER_ARGTYPE(std::optional<Library::ProcessData>)