EditContext.hpp

#pragma once
#include <Process/Dataflow/CableData.hpp>
#include <Process/TimeValue.hpp>
 
#include <score/document/DocumentContext.hpp>
 
#include <ossia-qt/js_utilities.hpp>
 
#include <QJSValue>
#include <QList>
#include <QObject>
#include <QStringList>
#include <QVariant>
 
#include <score_plugin_js_export.h>
 
#include <memory>
#include <verdigris>
namespace score
{
struct DocumentContext;
class Command;
}
namespace Scenario::Command
{
class Macro;
}
namespace JS
{
class GlobalDeviceEnumerator;
class DeviceListener;
class SCORE_PLUGIN_JS_EXPORT EditJsContext : public QObject
{
  W_OBJECT(EditJsContext)
  using Macro = Scenario::Command::Macro;
 
  std::unique_ptr<Macro> m_macro;
  struct MacroClear
  {
    using Macro = Scenario::Command::Macro;
    std::unique_ptr<Macro>& macro;
    bool clearOnDelete{};
    ~MacroClear();
  };
 
  MacroClear macro(const score::DocumentContext& doc);
 
public:
  EditJsContext();
  ~EditJsContext();
 
  const score::DocumentContext* ctx();
  W_INVOKABLE(ctx);
 
  QObject* device(QString name);
  W_SLOT(device)
 
  QString deviceToJson(QString addr);
  W_SLOT(deviceToJson)
 
  QString deviceToOSCQuery(QString addr);
  W_SLOT(deviceToOSCQuery)
 
  void createDevice(QString name, QString uuid, QJSValue obj);
  W_SLOT(createDevice, (QString, QString, QJSValue))
 
  void createDevice(QString name, QString uuid, QVariant obj);
  W_SLOT(createDevice, (QString, QString, QVariant))
 
  void createOSCDevice(QString name, QString host, int in, int out);
  W_SLOT(createOSCDevice)
 
  void connectOSCQueryDevice(QString name, QString host);
  W_SLOT(connectOSCQueryDevice)
 
  void removeDevice(QString name);
  W_SLOT(removeDevice)
 
  void createQMLWebSocketDevice(QString name, QString text);
  W_SLOT(createQMLWebSocketDevice)
 
  void createQMLSerialDevice(QString name, QString port, QString text);
  W_SLOT(createQMLSerialDevice)
 
  GlobalDeviceEnumerator* enumerateDevices();
  W_SLOT(enumerateDevices, ())
 
  GlobalDeviceEnumerator* enumerateDevices(const QString& protocol);
  W_SLOT(enumerateDevices, (const QString&))
 
  GlobalDeviceEnumerator* enumerateDevices(const QStringList& protocols);
  W_SLOT(enumerateDevices, (const QStringList&))
 
  DeviceListener* listenDevice(const QString& name);
  W_SLOT(listenDevice, (const QString&))
 
  void iterateDevice(const QString& name, const QJSValue& op);
  W_SLOT(iterateDevice, (const QString&, const QJSValue&))
 
  void setDeviceLearn(const QString& name, bool learn);
  W_SLOT(setDeviceLearn, (const QString&, bool))
  void createAddress(QString addr, QString type);
  W_SLOT(createAddress)
 
  
  void setUnit(QString addr, QString unit);
  W_SLOT(setUnit)
 
  QObject* createProcess(QObject* interval, QString name, QString data);
  W_SLOT(createProcess)
 
  
  int processes(QObject* obj);
  W_SLOT(processes)
 
  
  QObject* process(QObject* obj, int index);
  W_SLOT(process)
 
  
  QObject* parentProcess(QObject* obj);
  W_SLOT(parentProcess)
 
  
  QObject* parentInterval(QObject* obj);
  W_SLOT(parentInterval)
 
  void loadPreset(QObject* process, QString json);
  W_SLOT(loadPreset)
  QString savePreset(QObject* process);
  W_SLOT(savePreset)
 
  void setName(QObject* sel, QString new_name);
  W_SLOT(setName)
 
  QObject* createBox(QObject* obj, QString startTime, QString duration, double y);
  W_SLOT(createBox, (QObject*, QString, QString, double))
 
  QObject*
  createBox(QObject* obj, double startTimeFlicks, double durationFlicks, double y);
  W_SLOT(createBox, (QObject*, double, double, double))
 
  QObject* createState(QObject* ev, double y);
  W_SLOT(createState)
 
  QObject* createIntervalAfter(QObject* obj, QString duration, double y);
  W_SLOT(createIntervalAfter)
 
  QObject* createIntervalBetween(QObject* startState, QObject* endState);
  W_SLOT(createIntervalBetween)
 
  // Triggers and conditions.
  // A trigger lives on a time sync; intervals (their end), states and events
  // resolve to theirs. A condition lives on an event; states resolve to theirs.
  void enableTrigger(QObject* obj);
  W_SLOT(enableTrigger)
  void disableTrigger(QObject* obj);
  W_SLOT(disableTrigger)
  void enableCondition(QObject* obj);
  W_SLOT(enableCondition)
  void disableCondition(QObject* obj);
  W_SLOT(disableCondition)
  void setExpression(QObject* obj, QString expression);
  W_SLOT(setExpression)
  QString expression(QObject* obj);
  W_SLOT(expression)
 
  void setIntervalDuration(QObject* object, TimeVal flicks);
  W_SLOT(setIntervalDuration)
  void setIntervalMinDuration(QObject* object, TimeVal flicks);
  W_SLOT(setIntervalMinDuration)
  void setIntervalMaxDuration(QObject* object, TimeVal flicks);
  W_SLOT(setIntervalMaxDuration)
  void setIntervalMaxInfinite(QObject* object, bool);
  W_SLOT(setIntervalMaxInfinite)
  void setIntervalSpeed(QObject* object, double);
  W_SLOT(setIntervalSpeed)
 
  void setAutoTrigger(QObject* timeSync, bool);
  W_SLOT(setAutoTrigger)
 
  void setProcessLoop(QObject* process, bool);
  W_SLOT(setProcessLoop)
 
  
  QObject* port(QObject* obj, QString name);
  W_SLOT(port)
 
  QObject* inlet(QObject* obj, int index);
  W_SLOT(inlet, (QObject*, int))
 
  
  QObject* inlet(QObject* obj, QString name);
  W_SLOT(inlet, (QObject*, QString))
 
  int inlets(QObject* obj);
  W_SLOT(inlets)
 
  QObject* outlet(QObject* obj, int index);
  W_SLOT(outlet, (QObject*, int))
 
  
  QObject* outlet(QObject* obj, QString name);
  W_SLOT(outlet, (QObject*, QString))
 
  int outlets(QObject* obj);
  W_SLOT(outlets)
 
  QObject* createCable(QObject* outlet, QObject* inlet);
  W_SLOT(createCable, (QObject*, QObject*))
  QObject* createCable(QObject* outlet, QObject* inlet, Process::CableType type);
  W_SLOT(createCable, (QObject*, QObject*, Process::CableType))
 
  
  QObject* cable(QObject* port, int index);
  W_SLOT(cable, (QObject*, int))
 
  
  int cables(QObject* port);
  W_SLOT(cables)
 
  
  QObject* source(QObject* cable);
  W_SLOT(source)
 
  
  QObject* sink(QObject* cable);
  W_SLOT(sink)
 
  
  QObject* cable(QObject* outlet, QObject* inlet);
  W_SLOT(cable, (QObject*, QObject*))
 
  void setAddress(QObject* obj, QString addr);
  W_SLOT(setAddress)
 
  void setValue(QObject* obj, double value);
  W_SLOT(setValue, (QObject*, double))
 
  void setValue(QObject* obj, QVector2D value);
  W_SLOT(setValue, (QObject*, QVector2D))
 
  void setValue(QObject* obj, QVector3D value);
  W_SLOT(setValue, (QObject*, QVector3D))
 
  void setValue(QObject* obj, QVector4D value);
  W_SLOT(setValue, (QObject*, QVector4D))
 
  void setValue(QObject* obj, QString value);
  W_SLOT(setValue, (QObject*, QString))
 
  void setValue(QObject* obj, bool value);
  W_SLOT(setValue, (QObject*, bool))
 
  void setValue(QObject* obj, int value);
  W_SLOT(setValue, (QObject*, int))
 
  void setValue(QObject* obj, QList<QString> value);
  W_SLOT(setValue, (QObject*, QList<QString>))
 
  void setValue(QObject* obj, QList<qreal> value);
  W_SLOT(setValue, (QObject*, QList<qreal>))
 
  void setValue(QObject* obj, QList<QVariant> value);
  W_SLOT(setValue, (QObject*, QList<QVariant>))
 
  QString portName(QObject* port);
  W_SLOT(portName)
  QString valueType(QObject* obj);
  W_SLOT(valueType)
 
  double min(QObject* obj);
  W_SLOT(min)
 
  double max(QObject* obj);
  W_SLOT(max)
 
  QVector<QVariant> enumValues(QObject* obj);
  W_SLOT(enumValues)
 
  QObject* metadata(QObject* obj) const noexcept;
  W_SLOT(metadata)
 
  
  QObject* documentMetadata() const noexcept;
  W_SLOT(documentMetadata)
 
  
  QString documentName() const noexcept;
  W_SLOT(documentName)
 
  
  void setDocumentName(QString name);
  W_SLOT(setDocumentName)
 
  QObject* startState(QObject* obj);
  W_SLOT(startState)
 
  QObject* startEvent(QObject* obj);
  W_SLOT(startEvent)
 
  QObject* startSync(QObject* obj);
  W_SLOT(startSync)
 
  QObject* endState(QObject* obj);
  W_SLOT(endState)
 
  QObject* endEvent(QObject* obj);
  W_SLOT(endEvent)
 
  QObject* endSync(QObject* obj);
  W_SLOT(endSync)
 
  void remove(QObject* obj);
  W_SLOT(remove)
 
  void setCurvePoints(QObject* process, QVector<QVariantList> points);
  W_SLOT(setCurvePoints)
 
  void setSteps(QObject* process, QVector<double> points);
  W_SLOT(setSteps)
 
  QVariantList messages(QObject* state);
  W_SLOT(messages)
 
  void setMessages(QObject* state, QVariantList msgs);
  W_SLOT(setMessages)
 
  void replaceAddress(QObjectList objects, QString before, QString after);
  W_SLOT(replaceAddress)
 
  
  QVariantList automate(QObject* interval, QString addr);
  W_SLOT(automate, (QObject*, QString))
 
  
  QObject* automate(QObject* interval, QObject* port);
  W_SLOT(automate, (QObject*, QObject*))
 
  
  void startMacro();
  W_SLOT(startMacro)
 
  void endMacro();
  W_SLOT(endMacro)
 
  void undo();
  W_SLOT(undo)
 
  void redo();
  W_SLOT(redo)
 
  void load(QString path);
  W_SLOT(load)
 
  void save();
  W_SLOT(save)
 
  void saveAs(QString path);
  W_SLOT(saveAs)
 
  
  QObject* find(QString p);
  W_SLOT(find)
 
  QObject* findByLabel(QString p);
  W_SLOT(findByLabel)
  QString path(QObject* obj);
  W_SLOT(path)
  QObject* findByPath(QString path);
  W_SLOT(findByPath)
 
  QObject* document();
  W_SLOT(document)
 
  QObject* rootInterval();
  W_SLOT(rootInterval)
 
  QObject* documentPlugin(QString key);
  W_SLOT(documentPlugin)
 
  
  void play();
  W_SLOT(play, ())
 
  void play(QObject* obj);
  W_SLOT(play, (QObject*))
 
  void pause();
  W_SLOT(pause, ())
 
  void resume();
  W_SLOT(resume, ())
 
  void stop();
  W_SLOT(stop)
 
  void reinitialize();
  W_SLOT(reinitialize)
 
  void scrub(double z);
  W_SLOT(scrub)
 
  QObject* transport();
  W_INVOKABLE(transport)
 
  
  QString readFile(QString path);
  W_SLOT(readFile)
 
  QString relativizeFilePath(QString path);
  W_SLOT(relativizeFilePath)
 
  QString locateFilePath(QString path);
  W_SLOT(locateFilePath)
 
  
  QObject* selectedObject();
  W_SLOT(selectedObject)
 
  QVariantList selectedObjects();
  W_SLOT(selectedObjects)
 
  void select(QObject* obj);
  W_SLOT(select, (QObject*))
 
  void select(QVariantList objs);
  W_SLOT(select, (QVariantList))
 
  void zoom(double zx, double zy);
  W_SLOT(zoom, (double, double));
 
  void scroll(double zx, double zy);
  W_SLOT(scroll, (double, double));
 
  QVariant prompt(QVariant v);
  W_SLOT(prompt)
 
  bool hasProcessUI(QObject* process);
  W_SLOT(hasProcessUI)
 
  void showProcessUI(QObject* process, bool show);
  W_SLOT(showProcessUI)
 
  bool hasProcessScriptEditor(QObject* process);
  W_SLOT(hasProcessScriptEditor)
 
  void showProcessScriptEditor(QObject* process, bool show);
  W_SLOT(showProcessScriptEditor)
 
  
  void setProcessScriptEditorPlacement(QObject* process, QString placement);
  W_SLOT(setProcessScriptEditorPlacement)
  void setProcessUIPlacement(QObject* process, QString placement);
  W_SLOT(setProcessUIPlacement)
 
  
  QVariantMap availableProcesses() const noexcept;
  W_SLOT(availableProcesses)
  QVariant availableProcessesAndPresets() const noexcept;
  W_SLOT(availableProcessesAndPresets)
  QVariantList libraryEntries(QString filter) const noexcept;
  W_SLOT(libraryEntries)
  QVariant availableProtocols() const noexcept;
  W_SLOT(availableProtocols)
 
  QByteArray serializeAsJson() noexcept;
  W_SLOT(serializeAsJson)
private:
  void submit(Macro& m, score::Command* c);
};
}
 
W_REGISTER_ARGTYPE(QVector<QVariantList>)
W_REGISTER_ARGTYPE(QList<QObject*>)
W_REGISTER_ARGTYPE(JS::GlobalDeviceEnumerator*)