All editors implemented

Editor/ProjectModel.cpp

@@ -336,10 +336,38 @@ ProjectModel::ProjectModel(const QString& path, QObject* parent)
     SoundGroupNode::Icon = QIcon(":/icons/IconSoundGroup.svg");
 }
 
+void ProjectModel::_buildSortedList()
+{
+    m_sorted.clear();
+    m_sorted.reserve(m_groups.size());
+    for (auto it = m_groups.begin() ; it != m_groups.end() ; ++it)
+        m_sorted.emplace_back(it);
+    std::sort(m_sorted.begin(), m_sorted.end());
+}
+
+QModelIndex ProjectModel::_indexOfGroup(const QString& groupName) const
+{
+    auto search = std::lower_bound(m_sorted.cbegin(), m_sorted.cend(), groupName);
+    if (search == m_sorted.cend() || search->m_it->first != groupName)
+        return QModelIndex();
+    else
+    {
+        int idx = search - m_sorted.begin();
+        return createIndex(idx, 0, m_root->child(idx));
+    }
+}
+
+int ProjectModel::_hypotheticalIndexOfGroup(const QString& groupName) const
+{
+    auto search = std::lower_bound(m_sorted.cbegin(), m_sorted.cend(), groupName);
+    return search - m_sorted.begin();
+}
+
 bool ProjectModel::clearProjectData()
 {
     m_projectDatabase = amuse::ProjectDatabase();
     m_groups.clear();
+    m_sorted.clear();
     m_midiFiles.clear();
 
     m_needsReset = true;
@@ -473,92 +501,98 @@ bool ProjectModel::saveToFile(UIMessenger& messenger)
     return true;
 }
 
-void ProjectModel::_resetModelData()
+void ProjectModel::_buildGroupNode(GroupNode& gn)
 {
-    beginResetModel();
-    m_projectDatabase.setIdDatabases();
-    m_root = amuse::MakeObj<RootNode>();
-    m_root->reserve(m_groups.size());
-    for (auto it = m_groups.begin() ; it != m_groups.end() ; ++it)
+    amuse::AudioGroup& group = gn.m_it->second;
+    auto& songGroups = group.getProj().songGroups();
+    auto& sfxGroups = group.getProj().sfxGroups();
+    auto& soundMacros = group.getPool().soundMacros();
+    auto& tables = group.getPool().tables();
+    auto& keymaps = group.getPool().keymaps();
+    auto& layers = group.getPool().layers();
+    auto& samples = group.getSdir().sampleEntries();
+    gn.reserve(songGroups.size() + sfxGroups.size() + 4);
+    for (const auto& grp : SortUnorderedMap(songGroups))
+        gn.makeChild<SongGroupNode>(grp.first, grp.second.get());
+    for (const auto& grp : SortUnorderedMap(sfxGroups))
+        gn.makeChild<SoundGroupNode>(grp.first, grp.second.get());
     {
-        it->second.setIdDatabases();
-        GroupNode& gn = m_root->makeChild<GroupNode>(it);
-        amuse::AudioGroup& group = it->second;
-        auto& songGroups = group.getProj().songGroups();
-        auto& sfxGroups = group.getProj().sfxGroups();
-        auto& soundMacros = group.getPool().soundMacros();
-        auto& tables = group.getPool().tables();
-        auto& keymaps = group.getPool().keymaps();
-        auto& layers = group.getPool().layers();
-        auto& samples = group.getSdir().sampleEntries();
-        gn.reserve(songGroups.size() + sfxGroups.size() + 4);
-        for (const auto& grp : SortUnorderedMap(songGroups))
-            gn.makeChild<SongGroupNode>(grp.first, grp.second.get());
-        for (const auto& grp : SortUnorderedMap(sfxGroups))
-            gn.makeChild<SoundGroupNode>(grp.first, grp.second.get());
+        CollectionNode& col =
+            gn.makeChild<CollectionNode>(tr("Sound Macros"), QIcon(":/icons/IconSoundMacro.svg"), INode::Type::SoundMacro);
+        col.reserve(soundMacros.size());
+        for (const auto& macro : SortUnorderedMap(soundMacros))
+            col.makeChild<SoundMacroNode>(macro.first, macro.second.get());
+    }
+    {
+        auto tablesSort = SortUnorderedMap(tables);
+        size_t ADSRCount = 0;
+        size_t curveCount = 0;
+        for (auto& t : tablesSort)
         {
-            CollectionNode& col =
-                gn.makeChild<CollectionNode>(tr("Sound Macros"), QIcon(":/icons/IconSoundMacro.svg"), INode::Type::SoundMacro);
-            col.reserve(soundMacros.size());
-            for (const auto& macro : SortUnorderedMap(soundMacros))
-                col.makeChild<SoundMacroNode>(macro.first, macro.second.get());
+            amuse::ITable::Type tp = (*t.second.get())->Isa();
+            if (tp == amuse::ITable::Type::ADSR || tp == amuse::ITable::Type::ADSRDLS)
+                ADSRCount += 1;
+            else if (tp == amuse::ITable::Type::Curve)
+                curveCount += 1;
         }
         {
-            auto tablesSort = SortUnorderedMap(tables);
-            size_t ADSRCount = 0;
-            size_t curveCount = 0;
+            CollectionNode& col =
+                gn.makeChild<CollectionNode>(tr("ADSRs"), QIcon(":/icons/IconADSR.svg"), INode::Type::ADSR);
+            col.reserve(ADSRCount);
             for (auto& t : tablesSort)
             {
                 amuse::ITable::Type tp = (*t.second.get())->Isa();
                 if (tp == amuse::ITable::Type::ADSR || tp == amuse::ITable::Type::ADSRDLS)
-                    ADSRCount += 1;
-                else if (tp == amuse::ITable::Type::Curve)
-                    curveCount += 1;
+                    col.makeChild<ADSRNode>(t.first, t.second.get());
             }
+        }
+        {
+            CollectionNode& col =
+                gn.makeChild<CollectionNode>(tr("Curves"), QIcon(":/icons/IconCurve.svg"), INode::Type::Curve);
+            col.reserve(curveCount);
+            for (auto& t : tablesSort)
             {
-                CollectionNode& col =
-                    gn.makeChild<CollectionNode>(tr("ADSRs"), QIcon(":/icons/IconADSR.svg"), INode::Type::ADSR);
-                col.reserve(ADSRCount);
-                for (auto& t : tablesSort)
-                {
-                    amuse::ITable::Type tp = (*t.second.get())->Isa();
-                    if (tp == amuse::ITable::Type::ADSR || tp == amuse::ITable::Type::ADSRDLS)
-                        col.makeChild<ADSRNode>(t.first, t.second.get());
-                }
-            }
-            {
-                CollectionNode& col =
-                    gn.makeChild<CollectionNode>(tr("Curves"), QIcon(":/icons/IconCurve.svg"), INode::Type::Curve);
-                col.reserve(curveCount);
-                for (auto& t : tablesSort)
-                {
-                    amuse::ITable::Type tp = (*t.second.get())->Isa();
-                    if (tp == amuse::ITable::Type::Curve)
-                        col.makeChild<CurveNode>(t.first, t.second.get());
-                }
+                amuse::ITable::Type tp = (*t.second.get())->Isa();
+                if (tp == amuse::ITable::Type::Curve)
+                    col.makeChild<CurveNode>(t.first, t.second.get());
             }
         }
-        {
-            CollectionNode& col =
-                gn.makeChild<CollectionNode>(tr("Keymaps"), QIcon(":/icons/IconKeymap.svg"), INode::Type::Keymap);
-            col.reserve(keymaps.size());
-            for (auto& keymap : SortUnorderedMap(keymaps))
-                col.makeChild<KeymapNode>(keymap.first, keymap.second.get());
-        }
-        {
-            CollectionNode& col =
-                gn.makeChild<CollectionNode>(tr("Layers"), QIcon(":/icons/IconLayers.svg"), INode::Type::Layer);
-            col.reserve(layers.size());
-            for (auto& keymap : SortUnorderedMap(layers))
-                col.makeChild<LayersNode>(keymap.first, keymap.second.get());
-        }
-        {
-            CollectionNode& col =
-                gn.makeChild<CollectionNode>(tr("Samples"), QIcon(":/icons/IconSample.svg"), INode::Type::Sample);
-            col.reserve(samples.size());
-            for (auto& sample : SortUnorderedMap(samples))
-                col.makeChild<SampleNode>(sample.first, sample.second.get());
-        }
+    }
+    {
+        CollectionNode& col =
+            gn.makeChild<CollectionNode>(tr("Keymaps"), QIcon(":/icons/IconKeymap.svg"), INode::Type::Keymap);
+        col.reserve(keymaps.size());
+        for (auto& keymap : SortUnorderedMap(keymaps))
+            col.makeChild<KeymapNode>(keymap.first, keymap.second.get());
+    }
+    {
+        CollectionNode& col =
+            gn.makeChild<CollectionNode>(tr("Layers"), QIcon(":/icons/IconLayers.svg"), INode::Type::Layer);
+        col.reserve(layers.size());
+        for (auto& keymap : SortUnorderedMap(layers))
+            col.makeChild<LayersNode>(keymap.first, keymap.second.get());
+    }
+    {
+        CollectionNode& col =
+            gn.makeChild<CollectionNode>(tr("Samples"), QIcon(":/icons/IconSample.svg"), INode::Type::Sample);
+        col.reserve(samples.size());
+        for (auto& sample : SortUnorderedMap(samples))
+            col.makeChild<SampleNode>(sample.first, sample.second.get());
+    }
+}
+
+void ProjectModel::_resetModelData()
+{
+    beginResetModel();
+    _buildSortedList();
+    m_projectDatabase.setIdDatabases();
+    m_root = amuse::MakeObj<RootNode>();
+    m_root->reserve(m_sorted.size());
+    for (auto it = m_sorted.begin() ; it != m_sorted.end() ; ++it)
+    {
+        it->m_it->second.setIdDatabases();
+        GroupNode& gn = m_root->makeChild<GroupNode>(it->m_it);
+        _buildGroupNode(gn);
     }
     endResetModel();
 }
@@ -704,32 +738,41 @@ class DeleteNodeUndoCommand : public QUndoCommand
 {
     QModelIndex m_deleteIdx;
     amuse::ObjToken<ProjectModel::INode> m_node;
+    ProjectModel::NameUndoRegistry m_nameReg;
 public:
     DeleteNodeUndoCommand(const QModelIndex& index)
      : QUndoCommand(ProjectModel::tr("Delete %1").arg(index.data().toString())), m_deleteIdx(index) {}
     void undo()
     {
-        g_MainWindow->projectModel()->_undoDel(m_deleteIdx, std::move(m_node));
+        g_MainWindow->projectModel()->_undoDel(m_deleteIdx, std::move(m_node), m_nameReg);
         m_node.reset();
+        m_nameReg.clear();
     }
     void redo()
     {
-        m_node = g_MainWindow->projectModel()->_redoDel(m_deleteIdx);
+        m_node = g_MainWindow->projectModel()->_redoDel(m_deleteIdx, m_nameReg);
     }
 };
 
-void ProjectModel::_undoDel(const QModelIndex& index, amuse::ObjToken<ProjectModel::INode> n)
+void ProjectModel::_undoDel(const QModelIndex& index, amuse::ObjToken<ProjectModel::INode> n, const NameUndoRegistry& nameReg)
 {
     beginInsertRows(index.parent(), index.row(), index.row());
-    node(index.parent())->insertChild(index.row(), std::move(n));
+    node(index.parent())->insertChild(index.row(), n);
+    setIdDatabases(n.get());
+    n->depthTraverse([&nameReg](INode* node)
+    {
+        node->registerNames(nameReg);
+        return true;
+    });
     endInsertRows();
 }
 
-amuse::ObjToken<ProjectModel::INode> ProjectModel::_redoDel(const QModelIndex& index)
+amuse::ObjToken<ProjectModel::INode> ProjectModel::_redoDel(const QModelIndex& index, NameUndoRegistry& nameReg)
 {
-    node(index)->depthTraverse([](INode* node)
+    node(index)->depthTraverse([&nameReg](INode* node)
     {
         g_MainWindow->aboutToDeleteNode(node);
+        node->unregisterNames(nameReg);
         return true;
     });
     beginRemoveRows(index.parent(), index.row(), index.row());
@@ -745,6 +788,186 @@ void ProjectModel::del(const QModelIndex& index)
     g_MainWindow->pushUndoCommand(new DeleteNodeUndoCommand(index));
 }
 
+ProjectModel::GroupNode* ProjectModel::newSubproject(const QString& name, UIMessenger& messenger)
+{
+    if (m_groups.find(name) != m_groups.cend())
+    {
+        messenger.critical(tr("Subproject Conflict"), tr("The subproject %1 is already defined").arg(name));
+        return nullptr;
+    }
+    QDir dir(QFileInfo(m_dir, name).filePath());
+    if (!MkPath(dir.path(), messenger))
+        return nullptr;
+    QFile(QFileInfo(dir, QStringLiteral("!project.yaml")).filePath()).open(QFile::WriteOnly);
+    QFile(QFileInfo(dir, QStringLiteral("!pool.yaml")).filePath()).open(QFile::WriteOnly);
+    int idx = _hypotheticalIndexOfGroup(name);
+    beginInsertRows(QModelIndex(), idx, idx);
+    auto it = m_groups.emplace(std::make_pair(name, amuse::AudioGroupDatabase(QStringToSysString(dir.path())))).first;
+    _buildSortedList();
+    m_projectDatabase.setIdDatabases();
+    it->second.setIdDatabases();
+    GroupNode& gn = m_root->makeChildAtIdx<GroupNode>(idx, it);
+    _buildGroupNode(gn);
+    endInsertRows();
+    return &gn;
+}
+
+ProjectModel::SoundGroupNode* ProjectModel::newSoundGroup(GroupNode* group, const QString& name, UIMessenger& messenger)
+{
+    setIdDatabases(group);
+    auto nameKey = name.toUtf8();
+    if (amuse::GroupId::CurNameDB->m_stringToId.find(nameKey.data()) != amuse::GroupId::CurNameDB->m_stringToId.cend())
+    {
+        messenger.critical(tr("Sound Group Conflict"), tr("The group %1 is already defined").arg(name));
+        return nullptr;
+    }
+    beginInsertRows(index(group), 0, 0);
+    amuse::GroupId newId = amuse::GroupId::CurNameDB->generateId(amuse::NameDB::Type::Group);
+    amuse::GroupId::CurNameDB->registerPair(nameKey.data(), newId);
+    auto node = amuse::MakeObj<amuse::SFXGroupIndex>();
+    group->getAudioGroup()->getProj().sfxGroups()[newId] = node;
+    SoundGroupNode& ret = group->makeChildAtIdx<SoundGroupNode>(0, newId, node);
+    endInsertRows();
+    return &ret;
+}
+
+ProjectModel::SongGroupNode* ProjectModel::newSongGroup(GroupNode* group, const QString& name, UIMessenger& messenger)
+{
+    setIdDatabases(group);
+    auto nameKey = name.toUtf8();
+    if (amuse::GroupId::CurNameDB->m_stringToId.find(nameKey.data()) != amuse::GroupId::CurNameDB->m_stringToId.cend())
+    {
+        messenger.critical(tr("Song Group Conflict"), tr("The group %1 is already defined").arg(name));
+        return nullptr;
+    }
+    beginInsertRows(index(group), 0, 0);
+    amuse::GroupId newId = amuse::GroupId::CurNameDB->generateId(amuse::NameDB::Type::Group);
+    amuse::GroupId::CurNameDB->registerPair(nameKey.data(), newId);
+    auto node = amuse::MakeObj<amuse::SongGroupIndex>();
+    group->getAudioGroup()->getProj().songGroups()[newId] = node;
+    SongGroupNode& ret = group->makeChildAtIdx<SongGroupNode>(0, newId, node);
+    endInsertRows();
+    return &ret;
+}
+
+ProjectModel::SoundMacroNode* ProjectModel::newSoundMacro(GroupNode* group, const QString& name, UIMessenger& messenger,
+                                                          const SoundMacroTemplateEntry* templ)
+{
+    setIdDatabases(group);
+    auto nameKey = name.toUtf8();
+    if (amuse::SoundMacroId::CurNameDB->m_stringToId.find(nameKey.data()) != amuse::SoundMacroId::CurNameDB->m_stringToId.cend())
+    {
+        messenger.critical(tr("Sound Macro Conflict"), tr("The macro %1 is already defined").arg(name));
+        return nullptr;
+    }
+    ProjectModel::CollectionNode* coll = group->getCollectionOfType(INode::Type::SoundMacro);
+    QModelIndex parentIdx = index(coll);
+    int insertIdx = rowCount(parentIdx);
+    beginInsertRows(parentIdx, insertIdx, insertIdx);
+    amuse::SoundMacroId newId = amuse::SoundMacroId::CurNameDB->generateId(amuse::NameDB::Type::SoundMacro);
+    amuse::SoundMacroId::CurNameDB->registerPair(nameKey.data(), newId);
+    auto node = amuse::MakeObj<amuse::SoundMacro>();
+    if (templ)
+    {
+        athena::io::MemoryReader r(templ->m_data, templ->m_length);
+        node->readCmds<athena::utility::NotSystemEndian>(r, templ->m_length);
+    }
+    group->getAudioGroup()->getPool().soundMacros()[newId] = node;
+    SoundMacroNode& ret = coll->makeChildAtIdx<SoundMacroNode>(insertIdx, newId, node);
+    endInsertRows();
+    return &ret;
+}
+
+ProjectModel::ADSRNode* ProjectModel::newADSR(GroupNode* group, const QString& name, UIMessenger& messenger)
+{
+    setIdDatabases(group);
+    auto nameKey = name.toUtf8();
+    if (amuse::TableId::CurNameDB->m_stringToId.find(nameKey.data()) != amuse::TableId::CurNameDB->m_stringToId.cend())
+    {
+        messenger.critical(tr("ADSR Conflict"), tr("The ADSR %1 is already defined").arg(name));
+        return nullptr;
+    }
+    ProjectModel::CollectionNode* coll = group->getCollectionOfType(INode::Type::ADSR);
+    QModelIndex parentIdx = index(coll);
+    int insertIdx = rowCount(parentIdx);
+    beginInsertRows(parentIdx, insertIdx, insertIdx);
+    amuse::TableId newId = amuse::TableId::CurNameDB->generateId(amuse::NameDB::Type::Table);
+    amuse::TableId::CurNameDB->registerPair(nameKey.data(), newId);
+    auto node = amuse::MakeObj<std::unique_ptr<amuse::ITable>>();
+    *node = std::make_unique<amuse::ADSR>();
+    group->getAudioGroup()->getPool().tables()[newId] = node;
+    ADSRNode& ret = coll->makeChildAtIdx<ADSRNode>(insertIdx, newId, node);
+    endInsertRows();
+    return &ret;
+}
+
+ProjectModel::CurveNode* ProjectModel::newCurve(GroupNode* group, const QString& name, UIMessenger& messenger)
+{
+    setIdDatabases(group);
+    auto nameKey = name.toUtf8();
+    if (amuse::TableId::CurNameDB->m_stringToId.find(nameKey.data()) != amuse::TableId::CurNameDB->m_stringToId.cend())
+    {
+        messenger.critical(tr("Curve Conflict"), tr("The Curve %1 is already defined").arg(name));
+        return nullptr;
+    }
+    ProjectModel::CollectionNode* coll = group->getCollectionOfType(INode::Type::Curve);
+    QModelIndex parentIdx = index(coll);
+    int insertIdx = rowCount(parentIdx);
+    beginInsertRows(parentIdx, insertIdx, insertIdx);
+    amuse::TableId newId = amuse::TableId::CurNameDB->generateId(amuse::NameDB::Type::Table);
+    amuse::TableId::CurNameDB->registerPair(nameKey.data(), newId);
+    auto node = amuse::MakeObj<std::unique_ptr<amuse::ITable>>();
+    *node = std::make_unique<amuse::Curve>();
+    group->getAudioGroup()->getPool().tables()[newId] = node;
+    CurveNode& ret = coll->makeChildAtIdx<CurveNode>(insertIdx, newId, node);
+    endInsertRows();
+    return &ret;
+}
+
+ProjectModel::KeymapNode* ProjectModel::newKeymap(GroupNode* group, const QString& name, UIMessenger& messenger)
+{
+    setIdDatabases(group);
+    auto nameKey = name.toUtf8();
+    if (amuse::KeymapId::CurNameDB->m_stringToId.find(nameKey.data()) != amuse::KeymapId::CurNameDB->m_stringToId.cend())
+    {
+        messenger.critical(tr("Keymap Conflict"), tr("The Keymap %1 is already defined").arg(name));
+        return nullptr;
+    }
+    ProjectModel::CollectionNode* coll = group->getCollectionOfType(INode::Type::Keymap);
+    QModelIndex parentIdx = index(coll);
+    int insertIdx = rowCount(parentIdx);
+    beginInsertRows(parentIdx, insertIdx, insertIdx);
+    amuse::KeymapId newId = amuse::KeymapId::CurNameDB->generateId(amuse::NameDB::Type::Keymap);
+    amuse::KeymapId::CurNameDB->registerPair(nameKey.data(), newId);
+    auto node = amuse::MakeObj<std::array<amuse::Keymap, 128>>();
+    group->getAudioGroup()->getPool().keymaps()[newId] = node;
+    KeymapNode& ret = coll->makeChildAtIdx<KeymapNode>(insertIdx, newId, node);
+    endInsertRows();
+    return &ret;
+}
+
+ProjectModel::LayersNode* ProjectModel::newLayers(GroupNode* group, const QString& name, UIMessenger& messenger)
+{
+    setIdDatabases(group);
+    auto nameKey = name.toUtf8();
+    if (amuse::LayersId::CurNameDB->m_stringToId.find(nameKey.data()) != amuse::LayersId::CurNameDB->m_stringToId.cend())
+    {
+        messenger.critical(tr("Layers Conflict"), tr("Layers %1 is already defined").arg(name));
+        return nullptr;
+    }
+    ProjectModel::CollectionNode* coll = group->getCollectionOfType(INode::Type::Layer);
+    QModelIndex parentIdx = index(coll);
+    int insertIdx = rowCount(parentIdx);
+    beginInsertRows(parentIdx, insertIdx, insertIdx);
+    amuse::LayersId newId = amuse::LayersId::CurNameDB->generateId(amuse::NameDB::Type::Layer);
+    amuse::LayersId::CurNameDB->registerPair(nameKey.data(), newId);
+    auto node = amuse::MakeObj<std::vector<amuse::LayerMapping>>();
+    group->getAudioGroup()->getPool().layers()[newId] = node;
+    LayersNode& ret = coll->makeChildAtIdx<LayersNode>(insertIdx, newId, node);
+    endInsertRows();
+    return &ret;
+}
+
 ProjectModel::GroupNode* ProjectModel::getGroupOfSfx(amuse::SFXId id) const
 {
     ProjectModel::GroupNode* ret = nullptr;
@@ -797,3 +1020,10 @@ void ProjectModel::setMIDIPathOfSong(amuse::SongId id, const QString& path)
 {
     m_midiFiles[id] = path;
 }
+
+void ProjectModel::setIdDatabases(INode* context) const
+{
+    m_projectDatabase.setIdDatabases();
+    if (ProjectModel::GroupNode* group = getGroupNode(context))
+        group->getAudioGroup()->setIdDatabases();
+}