Merge pull request #515 from garakmon/slam

Separate Layouts and Maps

include/ui/bordermetatilespixmapitem.h

@@ -1,21 +1,21 @@
 #ifndef BORDERMETATILESPIXMAPITEM_H
 #define BORDERMETATILESPIXMAPITEM_H
 
-#include "map.h"
+#include "maplayout.h"
 #include "metatileselector.h"
 #include <QGraphicsPixmapItem>
 
 class BorderMetatilesPixmapItem : public QObject, public QGraphicsPixmapItem {
     Q_OBJECT
 public:
-    BorderMetatilesPixmapItem(Map *map_, MetatileSelector *metatileSelector) {
-        this->map = map_;
-        this->map->setBorderItem(this);
+    BorderMetatilesPixmapItem(Layout *layout, MetatileSelector *metatileSelector) {
+        this->layout = layout;
+        this->layout->setBorderItem(this);
         this->metatileSelector = metatileSelector;
         setAcceptHoverEvents(true);
     }
     MetatileSelector *metatileSelector;
-    Map *map;
+    Layout *layout;
     void draw();
 signals:
     void hoveredBorderMetatileSelectionChanged(uint16_t);

include/ui/collisionpixmapitem.h

@@ -4,19 +4,20 @@
 #include <QSpinBox>
 
 #include "metatileselector.h"
-#include "mappixmapitem.h"
+#include "movementpermissionsselector.h"
+#include "layoutpixmapitem.h"
 #include "map.h"
 #include "settings.h"
 
-class CollisionPixmapItem : public MapPixmapItem {
+class CollisionPixmapItem : public LayoutPixmapItem {
     Q_OBJECT
 public:
-    CollisionPixmapItem(Map *map, QSpinBox * selectedCollision, QSpinBox * selectedElevation, MetatileSelector *metatileSelector, Settings *settings, qreal *opacity)
-        : MapPixmapItem(map, metatileSelector, settings){
+    CollisionPixmapItem(Layout *layout, QSpinBox * selectedCollision, QSpinBox * selectedElevation, MetatileSelector *metatileSelector, Settings *settings, qreal *opacity)
+        : LayoutPixmapItem(layout, metatileSelector, settings){
         this->selectedCollision = selectedCollision;
         this->selectedElevation = selectedElevation;
         this->opacity = opacity;
-        map->setCollisionItem(this);
+        layout->setCollisionItem(this);
     }
     QSpinBox * selectedCollision;
     QSpinBox * selectedElevation;

include/ui/connectionpixmapitem.h

@@ -5,6 +5,7 @@
 #include <QGraphicsPixmapItem>
 #include <QPainter>
 #include <QPointer>
+#include <QKeyEvent>
 
 class ConnectionPixmapItem : public QObject, public QGraphicsPixmapItem {
     Q_OBJECT
@@ -36,14 +37,17 @@ private:
     static const int mHeight = 16;
 
 protected:
-    QVariant itemChange(GraphicsItemChange change, const QVariant &value) override;
-    void mousePressEvent(QGraphicsSceneMouseEvent*) override;
-    void mouseReleaseEvent(QGraphicsSceneMouseEvent*) override;
-    void mouseDoubleClickEvent(QGraphicsSceneMouseEvent*) override;
+    virtual QVariant itemChange(GraphicsItemChange change, const QVariant &value) override;
+    virtual void mousePressEvent(QGraphicsSceneMouseEvent*) override;
+    virtual void mouseReleaseEvent(QGraphicsSceneMouseEvent*) override;
+    virtual void mouseDoubleClickEvent(QGraphicsSceneMouseEvent*) override;
+    virtual void keyPressEvent(QKeyEvent*) override;
+    virtual void focusInEvent(QFocusEvent*) override;
 
 signals:
     void connectionItemDoubleClicked(MapConnection*);
     void selectionChanged(bool selected);
+    void deleteRequested(MapConnection*);
 };
 
 #endif // CONNECTIONPIXMAPITEM_H

include/ui/connectionslistitem.h

@@ -34,11 +34,12 @@ private:
     unsigned actionId = 0;
 
 protected:
-    void mousePressEvent(QMouseEvent*) override;
+    virtual void mousePressEvent(QMouseEvent*) override;
+    virtual void focusInEvent(QFocusEvent*) override;
+    virtual void keyPressEvent(QKeyEvent*) override;
 
 signals:
     void selected();
-    void removed(MapConnection*);
     void openMapClicked(MapConnection*);
 
 private slots:

include/ui/currentselectedmetatilespixmapitem.h

@@ -1,23 +1,24 @@
 #ifndef CURRENTSELECTEDMETATILESPIXMAPITEM_H
 #define CURRENTSELECTEDMETATILESPIXMAPITEM_H
 
-#include "map.h"
 #include "metatileselector.h"
 #include <QGraphicsPixmapItem>
 
+class Layout;
+
 class CurrentSelectedMetatilesPixmapItem : public QGraphicsPixmapItem {
 public:
-    CurrentSelectedMetatilesPixmapItem(Map *map, MetatileSelector *metatileSelector) {
-        this->map = map;
+    CurrentSelectedMetatilesPixmapItem(Layout *layout, MetatileSelector *metatileSelector) {
+        this->layout = layout;
         this->metatileSelector = metatileSelector;
     }
-    Map* map = nullptr;
+    Layout *layout = nullptr;
     MetatileSelector *metatileSelector;
     void draw();
 
-    void setMap(Map *map) { this->map = map; }
+    void setLayout(Layout *layout) { this->layout = layout; }
 };
 
-QPixmap drawMetatileSelection(MetatileSelection selection, Map *map);
+QPixmap drawMetatileSelection(MetatileSelection selection, Layout *layout);
 
 #endif // CURRENTSELECTEDMETATILESPIXMAPITEM_H

include/ui/eventfilters.h

@@ -0,0 +1,28 @@
+#include <QObject>
+#include <QEvent>
+
+
+
+/// Prevent wheel scroll
+class WheelFilter : public QObject {
+    Q_OBJECT
+public:
+    WheelFilter(QObject *parent) : QObject(parent) {}
+    virtual ~WheelFilter() {}
+    bool eventFilter(QObject *obj, QEvent *event) override;
+};
+
+
+
+/// Ctrl+Wheel = zoom
+class MapSceneEventFilter : public QObject {
+    Q_OBJECT
+protected:
+    bool eventFilter(QObject *obj, QEvent *event) override;
+public:
+    explicit MapSceneEventFilter(QObject *parent = nullptr) : QObject(parent) {}
+
+signals:
+    void wheelZoom(int delta);
+public slots:
+};

include/ui/filterchildrenproxymodel.h

@@ -9,9 +9,11 @@ class FilterChildrenProxyModel : public QSortFilterProxyModel
 
 public:
     explicit FilterChildrenProxyModel(QObject *parent = nullptr);
+    void setHideEmpty(bool hidden) { this->hideEmpty = hidden; }
 protected:
     bool filterAcceptsRow(int source_row, const QModelIndex & source_parent) const;
-
+private:
+    bool hideEmpty = false;
 };
 
 #endif // FILTERCHILDRENPROXYMODEL_H

include/ui/graphicsview.h

@@ -34,6 +34,7 @@ signals:
 
 class Editor;
 
+// TODO: This should just be MapView. It makes map-based assumptions, and no other class inherits GraphicsView.
 class GraphicsView : public QGraphicsView
 {
 public:
@@ -44,10 +45,10 @@ public:
 //    GraphicsView_Object object;
     Editor *editor;
 protected:
-    void mousePressEvent(QMouseEvent *event);
-    void mouseMoveEvent(QMouseEvent *event);
-    void mouseReleaseEvent(QMouseEvent *event);
-    void moveEvent(QMoveEvent *event);
+    virtual void mousePressEvent(QMouseEvent *event) override;
+    virtual void mouseMoveEvent(QMouseEvent *event) override;
+    virtual void mouseReleaseEvent(QMouseEvent *event) override;
+    virtual void moveEvent(QMoveEvent *event) override;
 };
 
 //Q_DECLARE_METATYPE(GraphicsView)

include/ui/layoutpixmapitem.h

@@ -1,54 +1,58 @@
 #ifndef MAPPIXMAPITEM_H
 #define MAPPIXMAPITEM_H
 
-#include "map.h"
 #include "settings.h"
 #include "metatileselector.h"
 #include <QGraphicsPixmapItem>
 
-class MapPixmapItem : public QObject, public QGraphicsPixmapItem {
+class Layout;
+
+class LayoutPixmapItem : public QObject, public QGraphicsPixmapItem {
     Q_OBJECT
 
 private:
     using QGraphicsPixmapItem::paint;
 
 public:
-    enum class PaintMode {
-        Disabled,
-        Metatiles,
-        EventObjects
-    };
-    MapPixmapItem(Map *map_, MetatileSelector *metatileSelector, Settings *settings) {
-        this->map = map_;
-        this->map->setMapItem(this);
+    LayoutPixmapItem(Layout *layout, MetatileSelector *metatileSelector, Settings *settings) {
+        this->layout = layout;
+        // this->map->setMapItem(this);
         this->metatileSelector = metatileSelector;
         this->settings = settings;
-        this->paintingMode = PaintMode::Metatiles;
-        this->lockedAxis = MapPixmapItem::Axis::None;
+        this->lockedAxis = LayoutPixmapItem::Axis::None;
         this->prevStraightPathState = false;
         setAcceptHoverEvents(true);
     }
-    MapPixmapItem::PaintMode paintingMode;
-    Map *map;
+
+    Layout *layout;
+
     MetatileSelector *metatileSelector;
+
     Settings *settings;
+
     bool active;
     bool has_mouse = false;
     bool right_click;
+
     int paint_tile_initial_x;
     int paint_tile_initial_y;
     bool prevStraightPathState;
     int straight_path_initial_x;
     int straight_path_initial_y;
+
     QPoint metatilePos;
+
     enum Axis {
         None = 0,
         X,
         Y
     };
-    MapPixmapItem::Axis lockedAxis;
+
+    LayoutPixmapItem::Axis lockedAxis;
+
     QPoint selection_origin;
     QList<QPoint> selection;
+
     virtual void paint(QGraphicsSceneMouseEvent*);
     virtual void floodFill(QGraphicsSceneMouseEvent*);
     virtual void magicFill(QGraphicsSceneMouseEvent*);
@@ -70,26 +74,33 @@ public:
                    QList<CollisionSelectionItem> selectedCollisions,
                    bool fromScriptCall = false);
     void floodFillSmartPath(int initialX, int initialY, bool fromScriptCall = false);
+
     virtual void pick(QGraphicsSceneMouseEvent*);
     virtual void select(QGraphicsSceneMouseEvent*);
     virtual void shift(QGraphicsSceneMouseEvent*);
     void shift(int xDelta, int yDelta, bool fromScriptCall = false);
     virtual void draw(bool ignoreCache = false);
+
     void updateMetatileSelection(QGraphicsSceneMouseEvent *event);
     void paintNormal(int x, int y, bool fromScriptCall = false);
     void lockNondominantAxis(QGraphicsSceneMouseEvent *event);
     QPoint adjustCoords(QPoint pos);
 
+    void setEditsEnabled(bool enabled) { this->editsEnabled = enabled; }
+    bool getEditsEnabled() { return this->editsEnabled; }
+
 private:
     void paintSmartPath(int x, int y, bool fromScriptCall = false);
     static QList<int> smartPathTable;
 
     unsigned actionId_ = 0;
 
+    bool editsEnabled = true;
+
 signals:
-    void startPaint(QGraphicsSceneMouseEvent *, MapPixmapItem *);
-    void endPaint(QGraphicsSceneMouseEvent *, MapPixmapItem *);
-    void mouseEvent(QGraphicsSceneMouseEvent *, MapPixmapItem *);
+    void startPaint(QGraphicsSceneMouseEvent *, LayoutPixmapItem *);
+    void endPaint(QGraphicsSceneMouseEvent *, LayoutPixmapItem *);
+    void mouseEvent(QGraphicsSceneMouseEvent *, LayoutPixmapItem *);
     void hoveredMapMetatileChanged(const QPoint &pos);
     void hoveredMapMetatileCleared();
 

include/ui/mapimageexporter.h

@@ -45,6 +45,7 @@ public:
 private:
     Ui::MapImageExporter *ui;
 
+    Layout *layout = nullptr;
     Map *map = nullptr;
     Editor *editor = nullptr;
     QGraphicsScene *scene = nullptr;

include/ui/maplistmodels.h

@@ -0,0 +1,208 @@
+#pragma once
+#ifndef MAPLISTMODELS_H
+#define MAPLISTMODELS_H
+
+#include <QTreeView>
+#include <QFontDatabase>
+#include <QStyledItemDelegate>
+#include <QStandardItemModel>
+#include <QMap>
+
+
+
+class Project;
+
+enum MapListUserRoles {
+    GroupRole = Qt::UserRole + 1, // Used to hold the map group number.
+    TypeRole,  // Used to differentiate between the different layers of the map list tree view.
+    TypeRole2, // Used for various extra data needed.
+};
+
+
+
+class MapTree : public QTreeView {
+    Q_OBJECT
+public:
+    MapTree(QWidget *parent) : QTreeView(parent) {
+        this->setDropIndicatorShown(true);
+        this->setFont(QFontDatabase::systemFont(QFontDatabase::FixedFont));
+        this->setFocusPolicy(Qt::StrongFocus);
+        this->setContextMenuPolicy(Qt::CustomContextMenu);
+    }
+
+protected:
+    virtual void keyPressEvent(QKeyEvent *event) override;
+
+public slots:
+    void removeSelected();
+};
+
+
+
+class GroupNameDelegate : public QStyledItemDelegate {
+    Q_OBJECT
+
+public:
+    GroupNameDelegate(Project *project, QObject *parent = nullptr) : QStyledItemDelegate(parent), project(project) {}
+
+    QWidget *createEditor(QWidget *parent, const QStyleOptionViewItem &option, const QModelIndex &index) const override;
+    void setEditorData(QWidget *editor, const QModelIndex &index) const override;
+    void setModelData(QWidget *editor, QAbstractItemModel *model, const QModelIndex &index) const override;
+    void updateEditorGeometry(QWidget *editor, const QStyleOptionViewItem &option, const QModelIndex &index) const override;
+
+private:
+    Project *project = nullptr;
+};
+
+
+
+class QRegularExpressionValidator;
+
+class MapListModel : public QStandardItemModel {
+    Q_OBJECT
+
+public:
+    MapListModel(QObject *parent = nullptr) : QStandardItemModel(parent) {};
+    ~MapListModel() { }
+
+    virtual QModelIndex indexOf(QString id) const = 0;
+    virtual void removeItemAt(const QModelIndex &index);
+    virtual QStandardItem *getItem(const QModelIndex &index) const = 0;
+
+protected:
+    virtual void removeItem(QStandardItem *item) = 0;
+};
+
+class MapGroupModel : public MapListModel {
+    Q_OBJECT
+
+public:
+    MapGroupModel(Project *project, QObject *parent = nullptr);
+    ~MapGroupModel() { }
+
+    QVariant data(const QModelIndex &index, int role) const override;
+
+    Qt::DropActions supportedDropActions() const override;
+    QStringList mimeTypes() const override;
+    virtual QMimeData *mimeData(const QModelIndexList &indexes) const override;
+    virtual bool dropMimeData(const QMimeData *data, Qt::DropAction action, int row, int column, const QModelIndex &parent) override;
+
+    virtual bool setData(const QModelIndex &index, const QVariant &value, int role = Qt::EditRole) override;
+
+public:
+    void setMap(QString mapName) { this->openMap = mapName; }
+
+    QStandardItem *createGroupItem(QString groupName, int groupIndex, QStandardItem *fromItem = nullptr);
+    QStandardItem *createMapItem(QString mapName, QStandardItem *fromItem = nullptr);
+
+    QStandardItem *insertGroupItem(QString groupName);
+    QStandardItem *insertMapItem(QString mapName, QString groupName);
+
+    virtual QStandardItem *getItem(const QModelIndex &index) const override;
+    virtual QModelIndex indexOf(QString mapName) const override;
+
+    void initialize();
+
+protected:
+    virtual void removeItem(QStandardItem *item) override;
+
+private:
+    friend class MapTree;
+    void updateProject();
+
+private:
+    Project *project;
+    QStandardItem *root = nullptr;
+
+    QMap<QString, QStandardItem *> groupItems;
+    QMap<QString, QStandardItem *> mapItems;
+
+    QString openMap;
+
+signals:
+    void dragMoveCompleted();
+};
+
+
+
+class MapAreaModel : public MapListModel {
+    Q_OBJECT
+
+public:
+    MapAreaModel(Project *project, QObject *parent = nullptr);
+    ~MapAreaModel() {}
+
+    QVariant data(const QModelIndex &index, int role) const override;
+
+public:
+    void setMap(QString mapName) { this->openMap = mapName; }
+
+    QStandardItem *createAreaItem(QString areaName);
+    QStandardItem *createMapItem(QString mapName, int areaIndex, int mapIndex);
+
+    QStandardItem *insertAreaItem(QString areaName);
+    QStandardItem *insertMapItem(QString mapName, QString areaName, int groupIndex);
+
+    virtual QStandardItem *getItem(const QModelIndex &index) const override;
+    virtual QModelIndex indexOf(QString mapName) const override;
+
+    void initialize();
+
+protected:
+    virtual void removeItem(QStandardItem *item) override;
+
+private:
+    Project *project;
+    QStandardItem *root = nullptr;
+
+    QMap<QString, QStandardItem *> areaItems;
+    QMap<QString, QStandardItem *> mapItems;
+
+    QString openMap;
+
+signals:
+    void edited();
+};
+
+
+
+class LayoutTreeModel : public MapListModel {
+    Q_OBJECT
+
+public:
+    LayoutTreeModel(Project *project, QObject *parent = nullptr);
+    ~LayoutTreeModel() {}
+
+    QVariant data(const QModelIndex &index, int role) const override;
+
+public:
+    void setLayout(QString layoutId) { this->openLayout = layoutId; }
+
+    QStandardItem *createLayoutItem(QString layoutId);
+    QStandardItem *createMapItem(QString mapName);
+
+    QStandardItem *insertLayoutItem(QString layoutId);
+    QStandardItem *insertMapItem(QString mapName, QString layoutId);
+
+    virtual QStandardItem *getItem(const QModelIndex &index) const override;
+    virtual QModelIndex indexOf(QString layoutName) const override;
+
+    void initialize();
+
+protected:
+    virtual void removeItem(QStandardItem *item) override;
+
+private:
+    Project *project;
+    QStandardItem *root = nullptr;
+
+    QMap<QString, QStandardItem *> layoutItems;
+    QMap<QString, QStandardItem *> mapItems;
+
+    QString openLayout;
+
+signals:
+    void edited();
+};
+
+#endif // MAPLISTMODELS_H

include/ui/maplisttoolbar.h

@@ -0,0 +1,52 @@
+#ifndef MAPLISTTOOLBAR_H
+#define MAPLISTTOOLBAR_H
+
+#include "maplistmodels.h"
+#include "filterchildrenproxymodel.h"
+
+#include <QFrame>
+#include <QPointer>
+
+namespace Ui {
+class MapListToolBar;
+}
+
+class MapListToolBar : public QFrame
+{
+    Q_OBJECT
+
+public:
+    explicit MapListToolBar(QWidget *parent = nullptr);
+    ~MapListToolBar();
+
+    MapTree* list() const { return m_list; }
+    void setList(MapTree *list);
+
+    void setEditsAllowedButtonVisible(bool visible);
+    void setEditsAllowed(bool allowed);
+    void toggleEditsAllowed();
+
+    void setEmptyFoldersVisible(bool visible);
+    void toggleEmptyFolders();
+
+    void expandList();
+    void collapseList();
+
+    void applyFilter(const QString &filterText);
+    void clearFilter();
+    void setFilterLocked(bool locked) { m_filterLocked = locked; }
+    bool isFilterLocked() const { return m_filterLocked; }
+
+signals:
+    void filterCleared(MapTree*);
+    void addFolderClicked();
+
+private:
+    Ui::MapListToolBar *ui;
+    QPointer<MapTree> m_list;
+    bool m_filterLocked = false;
+    bool m_editsAllowed = false;
+    bool m_emptyFoldersVisible = true;
+};
+
+#endif // MAPLISTTOOLBAR_H

include/ui/mapsceneeventfilter.h

@@ -1,19 +0,0 @@
-#ifndef MAPSCENEEVENTFILTER_H
-#define MAPSCENEEVENTFILTER_H
-
-#include <QObject>
-
-class MapSceneEventFilter : public QObject
-{
-    Q_OBJECT
-protected:
-    bool eventFilter(QObject *obj, QEvent *event) override;
-public:
-    explicit MapSceneEventFilter(QObject *parent = nullptr);
-
-signals:
-    void wheelZoom(int delta);
-public slots:
-};
-
-#endif // MAPSCENEEVENTFILTER_H

include/ui/mapview.h

@@ -73,7 +73,8 @@ public:
 private:
     QMap<int, Overlay*> overlayMap;
 protected:
-    void drawForeground(QPainter *painter, const QRectF &rect);
+    virtual void drawForeground(QPainter *painter, const QRectF &rect) override;
+    virtual void keyPressEvent(QKeyEvent*) override;
 };
 
 #endif // GRAPHICSVIEW_H

include/ui/metatileselector.h

@@ -31,13 +31,13 @@ struct MetatileSelection
 class MetatileSelector: public SelectablePixmapItem {
     Q_OBJECT
 public:
-    MetatileSelector(int numMetatilesWide, Map *map): SelectablePixmapItem(16, 16) {
+    MetatileSelector(int numMetatilesWide, Layout *layout): SelectablePixmapItem(16, 16) {
         this->externalSelection = false;
         this->prefabSelection = false;
         this->numMetatilesWide = numMetatilesWide;
-        this->map = map;
-        this->primaryTileset = map->layout->tileset_primary;
-        this->secondaryTileset = map->layout->tileset_secondary;
+        this->layout = layout;
+        this->primaryTileset = layout->tileset_primary;
+        this->secondaryTileset = layout->tileset_secondary;
         this->selection = MetatileSelection{};
         this->cellPos = QPoint(-1, -1);
         setAcceptHoverEvents(true);
@@ -51,7 +51,7 @@ public:
     void setPrefabSelection(MetatileSelection selection);
     void setExternalSelection(int, int, QList<uint16_t>, QList<QPair<uint16_t, uint16_t>>);
     QPoint getMetatileIdCoordsOnWidget(uint16_t);
-    void setMap(Map*);
+    void setLayout(Layout *layout);
     bool isInternalSelection() const { return (!this->externalSelection && !this->prefabSelection); }
     Tileset *primaryTileset;
     Tileset *secondaryTileset;
@@ -65,7 +65,7 @@ private:
     bool externalSelection;
     bool prefabSelection;
     int numMetatilesWide;
-    Map *map;
+    Layout *layout;
     int externalSelectionWidth;
     int externalSelectionHeight;
     QList<uint16_t> externalSelectedMetatiles;

include/ui/montabwidget.h

@@ -32,8 +32,6 @@ public slots:
     void deactivateTab(int tabIndex);
 
 private:
-    bool eventFilter(QObject *object, QEvent *event);
-
     void actionCopyTab(int index);
     void actionAddDeleteTab(int index);
 

include/ui/newmappopup.h

@@ -23,8 +23,9 @@ public:
     bool importedMap;
     QString layoutId;
     void init();
-    void init(MapSortOrder type, QVariant data);
-    void init(MapLayout *);
+    void initUi();
+    void init(int tabIndex, QString data);
+    void init(Layout *);
     static void setDefaultSettings(Project *project);
 
 signals:
@@ -37,7 +38,7 @@ private:
     bool checkNewMapGroup();
     void saveSettings();
     void useLayout(QString layoutId);
-    void useLayoutSettings(MapLayout *mapLayout);
+    void useLayoutSettings(Layout *mapLayout);
 
     struct Settings {
         QString group;
@@ -60,6 +61,8 @@ private:
     static struct Settings settings;
 
 private slots:
+    void on_checkBox_UseExistingLayout_stateChanged(int state);
+    void on_comboBox_Layout_currentTextChanged(const QString &text);
     void on_pushButton_NewMap_Accept_clicked();
     void on_lineEdit_NewMap_Name_textChanged(const QString &);
 };

include/ui/prefab.h

@@ -20,9 +20,9 @@ struct PrefabItem
 class Prefab
 {
 public:
-    void initPrefabUI(MetatileSelector *selector, QWidget *prefabWidget, QLabel *emptyPrefabLabel, Map *map);
-    void addPrefab(MetatileSelection selection, Map *map, QString name);
-    void updatePrefabUi(Map *map);
+    void initPrefabUI(MetatileSelector *selector, QWidget *prefabWidget, QLabel *emptyPrefabLabel, Layout *layout);
+    void addPrefab(MetatileSelection selection, Layout *layout, QString name);
+    void updatePrefabUi(Layout *layout);
     bool tryImportDefaultPrefabs(QWidget * parent, BaseGameVersion version, QString filepath = "");
 
 private:

include/ui/prefabcreationdialog.h

@@ -2,10 +2,11 @@
 #define PREFABCREATIONDIALOG_H
 
 #include "metatileselector.h"
-#include "map.h"
 
 #include <QDialog>
 
+class Layout;
+
 namespace Ui {
 class PrefabCreationDialog;
 }
@@ -15,12 +16,12 @@ class PrefabCreationDialog : public QDialog
     Q_OBJECT
 
 public:
-    explicit PrefabCreationDialog(QWidget *parent, MetatileSelector *metatileSelector, Map *map);
+    explicit PrefabCreationDialog(QWidget *parent, MetatileSelector *metatileSelector, Layout *layout);
     ~PrefabCreationDialog();
     void savePrefab();
 
 private:
-    Map *map;
+    Layout *layout = nullptr;
     Ui::PrefabCreationDialog *ui;
     MetatileSelection selection;
 };

include/ui/regionmapeditor.h

@@ -57,7 +57,6 @@ private:
     tsl::ordered_map<QString, RegionMap *> region_maps;
 
     QString configFilepath;
-    QString mapSectionFilepath;
 
     poryjson::Json rmConfigJson;
 
@@ -96,7 +95,7 @@ private:
     void saveConfig();
     bool loadRegionMapEntries();
     bool saveRegionMapEntries();
-    tsl::ordered_map<QString, MapSectionEntry> region_map_entries;
+    QMap<QString, MapSectionEntry> region_map_entries;
 
     bool buildConfigDialog();
     poryjson::Json configRegionMapDialog();

include/ui/tileseteditor.h

@@ -8,7 +8,8 @@
 #include "tileseteditormetatileselector.h"
 #include "tileseteditortileselector.h"
 #include "metatilelayersitem.h"
-#include "map.h"
+
+class Layout;
 
 namespace Ui {
 class TilesetEditor;
@@ -39,10 +40,10 @@ class TilesetEditor : public QMainWindow
     Q_OBJECT
 
 public:
-    explicit TilesetEditor(Project*, Map*, QWidget *parent = nullptr);
+    explicit TilesetEditor(Project *project, Layout *layout, QWidget *parent = nullptr);
     ~TilesetEditor();
-    void update(Map *map, QString primaryTilsetLabel, QString secondaryTilesetLabel);
-    void updateMap(Map *map);
+    void update(Layout *layout, QString primaryTilsetLabel, QString secondaryTilesetLabel);
+    void updateLayout(Layout *layout);
     void updateTilesets(QString primaryTilsetLabel, QString secondaryTilesetLabel);
     bool selectMetatile(uint16_t metatileId);
     uint16_t getSelectedMetatileId();
@@ -155,7 +156,7 @@ private:
     MetatileLayersItem *metatileLayersItem = nullptr;
     PaletteEditor *paletteEditor = nullptr;
     Project *project = nullptr;
-    Map *map = nullptr;
+    Layout *layout = nullptr;
     Metatile *metatile = nullptr;
     Metatile *copiedMetatile = nullptr;
     QString copiedMetatileLabel;

include/ui/tileseteditormetatileselector.h

@@ -3,13 +3,14 @@
 
 #include "selectablepixmapitem.h"
 #include "tileset.h"
-#include "map.h"
+
+class Layout;
 
 class TilesetEditorMetatileSelector: public SelectablePixmapItem {
     Q_OBJECT
 public:
-    TilesetEditorMetatileSelector(Tileset *primaryTileset, Tileset *secondaryTileset, Map *map);
-    Map *map = nullptr;
+    TilesetEditorMetatileSelector(Tileset *primaryTileset, Tileset *secondaryTileset, Layout *layout);
+    Layout *layout = nullptr;
     void draw();
     bool select(uint16_t metatileId);
     void setTilesets(Tileset*, Tileset*, bool draw = true);