Add new map to group that was selected (UI functionality only)

mainwindow.cpp

     QIcon folderIcon;
     folderIcon.addFile(QStringLiteral(":/icons/folder_closed.ico"), QSize(), QIcon::Normal, QIcon::Off);
 
-    QIcon mapIcon;
-    mapIcon.addFile(QStringLiteral(":/icons/map.ico"), QSize(), QIcon::Normal, QIcon::Off);
-    mapIcon.addFile(QStringLiteral(":/icons/image.ico"), QSize(), QIcon::Normal, QIcon::On);
+    mapIcon = new QIcon;
+    mapIcon->addFile(QStringLiteral(":/icons/map.ico"), QSize(), QIcon::Normal, QIcon::Off);
+    mapIcon->addFile(QStringLiteral(":/icons/image.ico"), QSize(), QIcon::Normal, QIcon::On);
 
     mapListModel = new QStandardItemModel;
+    mapGroupsModel = new QList<QStandardItem*>;
 
     QStandardItem *entry = new QStandardItem;
     entry->setText(project->getProjectTitle());
         group->setEditable(false);
         group->setData(group_name, Qt::UserRole);
         group->setData("map_group", MapListUserRoles::TypeRole);
+        group->setData(i, MapListUserRoles::GroupRole);
         maps->appendRow(group);
+        mapGroupsModel->append(group);
         QStringList *names = project->groupedMapNames->value(i);
         for (int j = 0; j < names->length(); j++) {
             QString map_name = names->value(j);
-            QStandardItem *map = new QStandardItem;
-            map->setText(QString("[%1.%2] ").arg(i).arg(j, 2, 10, QLatin1Char('0')) + map_name);
-            map->setIcon(mapIcon);
-            map->setEditable(false);
-            map->setData(map_name, Qt::UserRole);
-            map->setData("map_name", MapListUserRoles::TypeRole);
+            QStandardItem *map = createMapItem(map_name, i, j);
             group->appendRow(map);
         }
     }
     ui->mapList->repaint();
 }
 
+QStandardItem* MainWindow::createMapItem(QString mapName, int groupNum, int inGroupNum) {
+    QStandardItem *map = new QStandardItem;
+    map->setText(QString("[%1.%2] ").arg(groupNum).arg(inGroupNum, 2, 10, QLatin1Char('0')) + mapName);
+    map->setIcon(*mapIcon);
+    map->setEditable(false);
+    map->setData(mapName, Qt::UserRole);
+    map->setData("map_name", MapListUserRoles::TypeRole);
+    return map;
+}
+
 void MainWindow::onOpenMapListContextMenu(const QPoint &point)
 {
     QModelIndex index = ui->mapList->indexAt(point);
     // Build custom context menu depending on which type of item was selected (map group, map name, etc.)
     if (itemType == "map_group") {
         QString groupName = selectedItem->data(Qt::UserRole).toString();
+        int groupNum = selectedItem->data(MapListUserRoles::GroupRole).toInt();
         QMenu* menu = new QMenu();
         QActionGroup* actions = new QActionGroup(menu);
-        actions->addAction(menu->addAction("Add New Map to Group"))->setData(groupName);
-        connect(actions, SIGNAL(triggered(QAction*)), this, SLOT(addNewMapToGroup(QAction*)));
+        actions->addAction(menu->addAction("Add New Map to Group"))->setData(groupNum);
+        connect(actions, SIGNAL(triggered(QAction*)), this, SLOT(onAddNewMapToGroupClick(QAction*)));
         menu->exec(QCursor::pos());
     }
 }
 
-void MainWindow::addNewMapToGroup(QAction* triggeredAction)
+void MainWindow::onAddNewMapToGroupClick(QAction* triggeredAction)
 {
-    QString groupName = triggeredAction->data().toString();
-    qDebug() << "Adding new map " << groupName;
+    int groupNum = triggeredAction->data().toInt();
+    QStandardItem* groupItem = mapGroupsModel->at(groupNum);
+
+    QString newMapName = editor->project->getNewMapName();
+    editor->project->addNewMapToGroup(newMapName, groupNum);
+
+    int numMapsInGroup = groupItem->rowCount();
+    QStandardItem *newMapItem = createMapItem(newMapName, groupNum, numMapsInGroup);
+    groupItem->appendRow(newMapItem);
 }
 
 void MainWindow::on_mapList_activated(const QModelIndex &index)

mainwindow.h

     void on_toolButton_Dropper_clicked();
 
     void onOpenMapListContextMenu(const QPoint &point);
-    void addNewMapToGroup(QAction* triggeredAction);
+    void onAddNewMapToGroupClick(QAction* triggeredAction);
 
 private:
     Ui::MainWindow *ui;
     QStandardItemModel *mapListModel;
+    QList<QStandardItem*> *mapGroupsModel;
     Editor *editor = NULL;
+    QIcon* mapIcon;
     void setMap(QString);
     void populateMapList();
     QString getExistingDirectory(QString);
     void openProject(QString dir);
     QString getDefaultMap();
     void setRecentMap(QString map_name);
+    QStandardItem* createMapItem(QString mapName, int groupNum, int inGroupNum);
 
     void markAllEdited(QAbstractItemModel *model);
     void markEdited(QModelIndex index);
 };
 
 enum MapListUserRoles {
+    GroupRole = Qt::UserRole + 1, // Used to hold the map group number.
     TypeRole = Qt::UserRole + 10, // Used to differentiate between the different layers of the map list tree view.
 };
 

map.h

 public:
     QString name;
     QString constantName;
+    QString group_num;
     QString attributes_label;
     QString events_label;
     QString scripts_label;
 public slots:
 };
 
+class MapGroup : public QObject
+{
+    Q_OBJECT
+public:
+    QString name;
+    int group_num;
+    QList<Map*> maps;
+};
+
 #endif // MAP_H

project.cpp

 #include <QDebug>
 #include <QFile>
 #include <QTextStream>
+#include <QStandardItem>
 #include <QMessageBox>
 #include <QRegularExpression>
 
 Project::Project()
 {
     groupNames = new QStringList;
+    map_groups = new QMap<QString, int>;
     groupedMapNames = new QList<QStringList*>;
     mapNames = new QStringList;
     map_cache = new QMap<QString, Map*>;
+    mapConstantsToMapNames = new QMap<QString, QString>;
+    mapNamesToMapConstants = new QMap<QString, QString>;
     tileset_cache = new QMap<QString, Tileset*>;
 }
 
                     connection->direction = command.value(1);
                     connection->offset = command.value(2);
                     QString mapConstant = command.value(3);
-                    if (mapConstantsToMapNames.contains(mapConstant)) {
-                        connection->map_name = mapConstantsToMapNames[mapConstant];
+                    if (mapConstantsToMapNames->contains(mapConstant)) {
+                        connection->map_name = mapConstantsToMapNames->value(mapConstant);
                         map->connections.append(connection);
                     } else {
                         qDebug() << QString("Failed to find connected map for map constant '%1'").arg(mapConstant);
                     QStringList *list = groupedMaps->value(group);
                     list->append(mapName);
                     maps->append(mapName);
+                    map_groups->insert(mapName, group);
 
                     // Build the mapping and reverse mapping between map constants and map names.
                     QString mapConstant = Map::mapConstantFromName(mapName);
-                    mapConstantsToMapNames.insert(mapConstant, mapName);
-                    mapNamesToMapConstants.insert(mapName, mapConstant);
+                    mapConstantsToMapNames->insert(mapConstant, mapName);
+                    mapNamesToMapConstants->insert(mapName, mapConstant);
                 }
             }
         }
     mapNames = maps;
 }
 
+void Project::addNewMapToGroup(QString mapName, int groupNum) {
+    mapNames->append(mapName);
+    map_groups->insert(mapName, groupNum);
+    groupedMapNames->value(groupNum)->append(mapName);
+}
+
+QString Project::getNewMapName() {
+    // Ensure default name doesn't already exist.
+    int i = 0;
+    QString newMapName;
+    do {
+        newMapName = QString("NewMap%1").arg(++i);
+    } while (mapNames->contains(newMapName));
+
+    return newMapName;
+}
+
 QList<QStringList>* Project::parse(QString text) {
     Asm *parser = new Asm;
     return parser->parse(text);
             text += QString(", %1").arg(warp->get("y"));
             text += QString(", %1").arg(warp->get("elevation"));
             text += QString(", %1").arg(warp->get("destination_warp"));
-            text += QString(", %1").arg(mapNamesToMapConstants[warp->get("destination_map_name")]);
+            text += QString(", %1").arg(mapNamesToMapConstants->value(warp->get("destination_map_name")));
             text += "\n";
         }
         text += "\n";
 
             // Ensure the warp destination map constant is valid before adding it to the warps.
             QString mapConstant = command.value(i++);
-            if (mapConstantsToMapNames.contains(mapConstant)) {
-                warp->put("destination_map_name", mapConstantsToMapNames[mapConstant]);
+            if (mapConstantsToMapNames->contains(mapConstant)) {
+                warp->put("destination_map_name", mapConstantsToMapNames->value(mapConstant));
                 warp->put("event_type", "warp");
                 map->events["warp"].append(warp);
             } else {

project.h

 
 #include <QStringList>
 #include <QList>
+#include <QStandardItem>
 
 class Project
 {
     Project();
     QString root;
     QStringList *groupNames = NULL;
+    QMap<QString, int> *map_groups;
     QList<QStringList*> *groupedMapNames = NULL;
     QStringList *mapNames = NULL;
-    QMap<QString, QString> mapConstantsToMapNames;
-    QMap<QString, QString> mapNamesToMapConstants;
+    QMap<QString, QString> *mapConstantsToMapNames;
+    QMap<QString, QString> *mapNamesToMapConstants;
 
     QMap<QString, Map*> *map_cache;
     Map* loadMap(QString);
     void saveTextFile(QString path, QString text);
 
     void readMapGroups();
+    void addNewMapToGroup(QString mapName, int groupNum);
+    QString getNewMapName();
     QString getProjectTitle();
 
     QList<QStringList>* getLabelMacros(QList<QStringList>*, QString);