AutomationDropHandler.cpp

// This is an open source non-commercial project. Dear PVS-Studio, please check
// it. PVS-Studio Static Code Analyzer for C, C++ and C#: http://www.viva64.com
#include "AutomationDropHandler.hpp"
 
#include <Device/Node/NodeListMimeSerialization.hpp>
 
#include <Process/ProcessMimeSerialization.hpp>
 
#include <Scenario/Commands/Cohesion/CreateCurves.hpp>
#include <Scenario/Commands/CommandAPI.hpp>
#include <Scenario/Document/ScenarioEditor.hpp>
#include <Scenario/Commands/Scenario/PasteAnchors.hpp>
#include <Scenario/Commands/Interval/AddLayerInNewSlot.hpp>
#include <Scenario/Commands/Interval/AddProcessToInterval.hpp>
#include <Scenario/Commands/Interval/ResizeInterval.hpp>
#include <Scenario/Commands/Metadata/ChangeElementName.hpp>
#include <Scenario/Commands/Scenario/ScenarioPasteElements.hpp>
#include <Scenario/Document/ScenarioDocument/ScenarioDocumentModel.hpp>
#include <Scenario/Process/ScenarioModel.hpp>
#include <Scenario/Process/ScenarioPresenter.hpp>
 
#include <Dataflow/Commands/CableHelpers.hpp>
 
#include <score/document/DocumentContext.hpp>
 
#include <ossia/detail/thread.hpp>
#include <ossia/network/value/value_traits.hpp>
 
#include <QFileInfo>
#include <QUrl>
namespace Scenario
{
 
DropScenario::DropScenario()
{
  // TODO give them a mime type ?
  m_acceptableSuffixes.push_back("scenario");
}
 
bool DropScenario::drop(
    const ScenarioPresenter& pres, QPointF pos, const QMimeData& mime)
{
  if(mime.hasUrls())
  {
    const auto& doc = pres.context().context;
    auto& sm = pres.model();
    auto path = mime.urls().first().toLocalFile();
    if(QFile f{path}; QFileInfo{f}.suffix() == "scenario" && f.open(QIODevice::ReadOnly))
    {
      CommandDispatcher<> d{doc.commandStack};
      d.submit(new Scenario::Command::ScenarioPasteElements(
          sm, readJson(f.readAll()), pres.toScenarioPoint(pos)));
      return true;
    }
  }
 
  return false;
}
 
DropScoreInScenario::DropScoreInScenario()
{
  m_acceptableSuffixes.push_back("score");
  m_acceptableSuffixes.push_back("scorebin");
}
 
bool DropScoreInScenario::drop(
    const ScenarioPresenter& pres, QPointF pos, const QMimeData& mime)
{
  if(mime.hasUrls())
  {
    const auto& doc = pres.context().context;
    auto& sm = pres.model();
    auto path = mime.urls().first().toLocalFile();
    if(QFile f{path}; QFileInfo{f}.suffix() == "score" && f.open(QIODevice::ReadOnly))
    {
      rapidjson::Document res;
      res.SetObject();
 
      auto obj = readJson(f.readAll());
      auto& docobj = obj["Document"];
 
      // ScenarioPasteElements expects the cable address to start from the topmost interval in the copied
      // content
      res.AddMember("Cables", docobj["Cables"], res.GetAllocator());
      for(auto& c : res["Cables"].GetArray())
      {
        auto source = c["Source"].GetArray();
        source.Erase(source.Begin());
        source.Erase(source.Begin());
        auto sink = c["Sink"].GetArray();
        sink.Erase(sink.Begin());
        sink.Erase(sink.Begin());
      }
 
      auto& scenar = docobj["BaseScenario"];
 
      {
        rapidjson::Value arr(rapidjson::kArrayType);
        arr.PushBack(scenar["Constraint"], obj.GetAllocator());
        res.AddMember("Intervals", arr, res.GetAllocator());
      }
      {
        rapidjson::Value arr(rapidjson::kArrayType);
        arr.PushBack(scenar["StartState"], obj.GetAllocator());
        arr.PushBack(scenar["EndState"], obj.GetAllocator());
        res.AddMember("States", arr, res.GetAllocator());
      }
      {
        rapidjson::Value arr(rapidjson::kArrayType);
        arr.PushBack(scenar["StartEvent"], obj.GetAllocator());
        arr.PushBack(scenar["EndEvent"], obj.GetAllocator());
        res.AddMember("Events", arr, res.GetAllocator());
      }
      {
        rapidjson::Value arr(rapidjson::kArrayType);
        arr.PushBack(scenar["StartTimeNode"], obj.GetAllocator());
        arr.PushBack(scenar["EndTimeNode"], obj.GetAllocator());
        res.AddMember("TimeNodes", arr, res.GetAllocator());
      }
 
      // Anchors between elements of the file's base scenario move to the pasted ones
      {
        auto& alloc = res.GetAllocator();
        rapidjson::Value origin(rapidjson::kArrayType);
        auto id = [&](const char* name, int i) {
          rapidjson::Value v(rapidjson::kObjectType);
          v.AddMember("ObjectName", rapidjson::StringRef(name), alloc);
          v.AddMember("ObjectId", i, alloc);
          origin.PushBack(v, alloc);
        };
        id("Scenario::ScenarioDocumentModel", 1);
        id("Scenario::BaseScenario", 0);
        res.AddMember("Origin", origin, alloc);
      }
 
      CommandDispatcher<> d{doc.commandStack};
      d.submit(new Scenario::Command::ScenarioPasteElements(
          sm, res, pres.toScenarioPoint(pos)));
      return true;
    }
  }
 
  return false;
}
 
static void getAddressesRecursively(
    const Device::Node& node, State::Address curAddr,
    std::vector<Device::FullAddressSettings>& addresses)
{
  // TODO refactor with CreateCurves and AddressAccessorEditWidget
  if(node.is<Device::AddressSettings>())
  {
    const Device::AddressSettings& addr = node.get<Device::AddressSettings>();
    // FIXME see https://github.com/ossia/libossia/issues/291
    if(ossia::is_numeric(addr.value) || ossia::is_array(addr.value))
    {
      Device::FullAddressSettings as;
      static_cast<Device::AddressSettingsCommon&>(as) = addr;
      as.address = curAddr;
      addresses.push_back(std::move(as));
    }
    // TODO interpolation
  }
 
  for(auto& child : node)
  {
    const Device::AddressSettings& addr = child.get<Device::AddressSettings>();
 
    State::Address newAddr{curAddr};
    newAddr.path.append(addr.name);
    getAddressesRecursively(child, newAddr, addresses);
  }
}
 
bool AutomationDropHandler::drop(
    const score::DocumentContext& ctx, const IntervalModel& cst, QPointF p,
    const QMimeData& mime)
{
  // TODO refactor with AddressEditWidget
  if(mime.hasFormat(score::mime::nodelist()))
  {
    Mime<Device::FreeNodeList>::Deserializer des{mime};
    Device::FreeNodeList nl = des.deserialize();
    if(nl.empty())
      return false;
 
    std::vector<Device::FullAddressSettings> addresses;
    for(auto& np : nl)
    {
      getAddressesRecursively(np.second, np.first, addresses);
    }
 
    if(addresses.empty())
      return false;
 
    CreateCurvesFromAddresses({&cst}, addresses, ctx.commandStack);
 
    return true;
  }
  else
  {
    return false;
  }
}
 
bool DropScoreInInterval::drop(
    const score::DocumentContext& doc, const IntervalModel& interval, QPointF p,
    const QMimeData& mime)
{
  if(mime.hasUrls())
  {
    auto path = mime.urls().first().toLocalFile();
    if(QFile f{path}; QFileInfo{f}.suffix() == "score" && f.open(QIODevice::ReadOnly))
    {
      auto obj = readJson(f.readAll());
      auto& docobj = obj["Document"];
      auto& scenar = docobj["BaseScenario"];
      auto& itv = scenar["Constraint"];
 
      Scenario::Command::Macro m{new Command::DropProcessInIntervalMacro, doc};
      const ObjectPath old_path{
          {"Scenario::ScenarioDocumentModel", 1},
          {"Scenario::BaseScenario", 0},
          {"Scenario::IntervalModel", 0}};
 
      // Anchors between objects of the file's base interval move to the copies
      std::vector<std::pair<int32_t, int32_t>> proc_id_map;
      std::vector<ObjectPath> pasted;
      {
        rapidjson::Document copy;
        copy.SetObject();
        auto& alloc = copy.GetAllocator();
        copy.AddMember("Processes", rapidjson::Value(itv["Processes"], alloc), alloc);
        JSONReader r;
        r.readFrom(old_path);
        const auto parent = readJson(r.toByteArray());
        copy.AddMember("ProcessesParent", rapidjson::Value(parent, alloc), alloc);
        pasted = loadCopiedProcesses(m, interval, copy, proc_id_map, doc);
      }
 
      // Reload cables
      {
        auto new_path = score::IDocument::path(interval).unsafePath();
        auto cables = Dataflow::serializedCablesFromCableJson(
            old_path, docobj["Cables"].GetArray());
 
        auto& document
            = score::IDocument::get<Scenario::ScenarioDocumentModel>(doc.document);
        for(auto& c : cables)
        {
          c.first = getStrongId(document.cables);
          // The copies may have new identifiers
          auto remap = [&](ObjectPath& path) {
            auto& vec = path.vec();
            if(vec.empty())
              return;
            for(auto& [old_id, new_id] : proc_id_map)
              if(vec.front().id() == old_id)
              {
                vec.front() = ObjectIdentifier{vec.front().objectName(), new_id};
                break;
              }
          };
          remap(c.second.source.unsafePath());
          remap(c.second.sink.unsafePath());
        }
        m.loadCables(new_path, cables);
      }
      if(!pasted.empty())
        m.submit(new Command::FollowPasted{std::move(pasted)});
 
      // Finally we show the newly created rack
      m.showRack(interval);
 
      m.commit();
 
      return true;
    }
  }
 
  return false;
}
 
}