Respect map dimension changes in undo/redo history

editor.cpp

 
 void Editor::undo() {
     if (current_view) {
-        ((MapPixmapItem*)current_view)->undo();
+        map->undo();
+        map_item->draw();
     }
 }
 
 void Editor::redo() {
     if (current_view) {
-        ((MapPixmapItem*)current_view)->redo();
+        map->redo();
+        map_item->draw();
     }
 }
 
     }
 }
 
-void MapPixmapItem::undo() {
-    if (map) {
-        map->undo();
-        draw();
-    }
-}
-
-void MapPixmapItem::redo() {
-    if (map) {
-        map->redo();
-        draw();
-    }
-}
-
 void MapPixmapItem::updateCurHoveredTile(QPointF pos) {
     int x = ((int)pos.x()) / 16;
     int y = ((int)pos.y()) / 16;

editor.h

     virtual void floodFill(QGraphicsSceneMouseEvent*);
     virtual void pick(QGraphicsSceneMouseEvent*);
     virtual void select(QGraphicsSceneMouseEvent*);
-    virtual void undo();
-    virtual void redo();
     virtual void draw(bool ignoreCache = false);
 
 private:

mainwindow.cpp

         return;
     }
     editor->setMap(map_name);
+    redrawMapScene();
+    displayMapProperties();
+
+    setWindowTitle(map_name + " - " + editor->project->getProjectTitle() + " - pretmap");
+
+    connect(editor->map, SIGNAL(mapChanged(Map*)), this, SLOT(onMapChanged(Map *)));
+    connect(editor->map, SIGNAL(mapNeedsRedrawing(Map*)), this, SLOT(onMapNeedsRedrawing(Map *)));
+    connect(editor->map, SIGNAL(statusBarMessage(QString)), this, SLOT(setStatusBarMessage(QString)));
 
+    setRecentMap(map_name);
+    updateMapList();
+}
+
+void MainWindow::redrawMapScene()
+{
+    editor->displayMap();
     on_tabWidget_currentChanged(ui->tabWidget->currentIndex());
 
     ui->graphicsView_Map->setScene(editor->scene);
     ui->graphicsView_Elevation->setScene(editor->scene_elevation_metatiles);
     //ui->graphicsView_Elevation->setSceneRect(editor->scene_elevation_metatiles->sceneRect());
     ui->graphicsView_Elevation->setFixedSize(editor->elevation_metatiles_item->pixmap().width() + 2, editor->elevation_metatiles_item->pixmap().height() + 2);
-
-    displayMapProperties();
-
-    setWindowTitle(map_name + " - " + editor->project->getProjectTitle() + " - pretmap");
-
-    connect(editor->map, SIGNAL(mapChanged(Map*)), this, SLOT(onMapChanged(Map *)));
-    connect(editor->map, SIGNAL(statusBarMessage(QString)), this, SLOT(setStatusBarMessage(QString)));
-
-    setRecentMap(map_name);
-    updateMapList();
 }
 
 void MainWindow::setRecentMap(QString map_name) {
     updateMapList();
 }
 
+void MainWindow::onMapNeedsRedrawing(Map *map) {
+    redrawMapScene();
+}
+
 void MainWindow::on_action_Export_Map_Image_triggered()
 {
     QString defaultFilepath = QString("%1/%2.png").arg(editor->project->root).arg(editor->map->name);
 
     if (dialog.exec() == QDialog::Accepted) {
         editor->map->setDimensions(widthSpinBox->value(), heightSpinBox->value());
-        setMap(editor->map->name);
+        editor->map->commit();
+        onMapNeedsRedrawing(editor->map);
     }
 }

mainwindow.h

 
     void onLoadMapRequested(QString, QString);
     void onMapChanged(Map *map);
+    void onMapNeedsRedrawing(Map *map);
 
     void on_action_Save_triggered();
     void on_tabWidget_2_currentChanged(int index);
     Editor *editor = NULL;
     QIcon* mapIcon;
     void setMap(QString);
+    void redrawMapScene();
     void loadDataStructures();
     void populateMapList();
     QString getExistingDirectory(QString);

map.cpp

 #include <QImage>
 #include <QRegularExpression>
 
+
 Map::Map(QObject *parent) : QObject(parent)
 {
     paint_tile_index = 1;
         cacheBlockdata();
         pixmap = pixmap.fromImage(image);
     }
+
     return pixmap;
 }
 
     return QPixmap::fromImage(image);
 }
 
-void Map::setDimensions(int newWidth, int newHeight) {
+void Map::setNewDimensionsBlockdata(int newWidth, int newHeight) {
     int oldWidth = getWidth();
     int oldHeight = getHeight();
 
     }
 
     layout->blockdata->copyFrom(newBlockData);
+}
+
+void Map::setDimensions(int newWidth, int newHeight, bool setNewBlockdata) {
+    if (setNewBlockdata) {
+        setNewDimensionsBlockdata(newWidth, newHeight);
+    }
+
     layout->width = QString::number(newWidth);
     layout->height = QString::number(newHeight);
-    commit();
 
     emit mapChanged(this);
 }
 
 
 void Map::undo() {
+    HistoryItem *commit = history.back();
+    if (!commit)
+        return;
+
     if (layout->blockdata) {
-        Blockdata *commit = history.back();
-        if (commit != NULL) {
-            layout->blockdata->copyFrom(commit);
-            emit mapChanged(this);
+        layout->blockdata->copyFrom(commit->metatiles);
+        if (commit->layoutWidth != this->getWidth() || commit->layoutHeight != this->getHeight())
+        {
+            this->setDimensions(commit->layoutWidth, commit->layoutHeight, false);
+            emit mapNeedsRedrawing(this);
         }
+
+        emit mapChanged(this);
     }
 }
 
 void Map::redo() {
+    HistoryItem *commit = history.next();
+    if (!commit)
+        return;
+
     if (layout->blockdata) {
-        Blockdata *commit = history.next();
-        if (commit != NULL) {
-            layout->blockdata->copyFrom(commit);
-            emit mapChanged(this);
+        layout->blockdata->copyFrom(commit->metatiles);
+        if (commit->layoutWidth != this->getWidth() || commit->layoutHeight != this->getHeight())
+        {
+            this->setDimensions(commit->layoutWidth, commit->layoutHeight, false);
+            emit mapNeedsRedrawing(this);
         }
+
+        emit mapChanged(this);
     }
 }
 
 void Map::commit() {
     if (layout->blockdata) {
-        if (!layout->blockdata->equals(history.current())) {
-            Blockdata* commit = layout->blockdata->copy();
+        HistoryItem *item = history.current();
+        bool atCurrentHistory = item
+                && layout->blockdata->equals(item->metatiles)
+                && this->getWidth() == item->layoutWidth
+                && this->getHeight() == item->layoutHeight;
+        if (!atCurrentHistory) {
+            HistoryItem *commit = new HistoryItem(layout->blockdata->copy(), this->getWidth(), this->getHeight());
             history.push(commit);
             emit mapChanged(this);
         }

map.h

 #include <QDebug>
 #include <QGraphicsPixmapItem>
 
+class HistoryItem {
+public:
+    Blockdata *metatiles;
+    short layoutWidth;
+    short layoutHeight;
+    HistoryItem(Blockdata *metatiles_, short layoutWidth_, short layoutHeight_) {
+        this->metatiles = metatiles_;
+        this->layoutWidth = layoutWidth_;
+        this->layoutHeight = layoutHeight_;
+    }
+};
 
 template <typename T>
 class History {
     void floodFillCollisionElevation(int x, int y, uint collision, uint elevation);
     void _floodFillCollisionElevation(int x, int y, uint collision, uint elevation);
 
-    History<Blockdata*> history;
+    History<HistoryItem*> history;
     void undo();
     void redo();
     void commit();
 
     QList<Connection*> connections;
     QPixmap renderConnection(Connection);
-    void setDimensions(int, int);
+    void setNewDimensionsBlockdata(int newWidth, int newHeight);
+    void setDimensions(int newWidth, int newHeight, bool setNewBlockData = true);
 
     QPixmap renderBorder();
     void cacheBorder();
     void paintTileChanged(Map *map);
     void paintCollisionChanged(Map *map);
     void mapChanged(Map *map);
+    void mapNeedsRedrawing(Map *map);
     void statusBarMessage(QString);
 
 public slots: