update reference's current cell when x/y-coordinates are modified

apps/opencs/model/world/commanddispatcher.cpp

@@ -2,6 +2,7 @@
 #include "commanddispatcher.hpp"
 
 #include <algorithm>
+#include <memory>
 
 #include <components/misc/stringops.hpp>
 
@@ -10,6 +11,7 @@
 #include "idtable.hpp"
 #include "record.hpp"
 #include "commands.hpp"
+#include "idtableproxymodel.hpp"
 
 std::vector<std::string> CSMWorld::CommandDispatcher::getDeletableRecords() const
 {
@@ -136,7 +138,47 @@ void CSMWorld::CommandDispatcher::executeModify (QAbstractItemModel *model, cons
     if (mLocked)
         return;
 
-    mDocument.getUndoStack().push (new CSMWorld::ModifyCommand (*model, index, new_));
+    std::auto_ptr<CSMWorld::UpdateCellCommand> modifyCell;
+
+    int columnId = model->data (index, ColumnBase::Role_ColumnId).toInt();
+
+    if (columnId==Columns::ColumnId_PositionXPos || columnId==Columns::ColumnId_PositionYPos)
+    {
+        IdTableProxyModel *proxy = dynamic_cast<IdTableProxyModel *> (model);
+
+        int row = proxy ? proxy->mapToSource (index).row() : index.row();
+
+        // This is not guaranteed to be the same as \a model, since a proxy could be used.
+        IdTable& model2 = dynamic_cast<IdTable&> (*mDocument.getData().getTableModel (mId));
+
+        int cellColumn = model2.searchColumnIndex (Columns::ColumnId_Cell);
+
+        if (cellColumn!=-1)
+        {
+            QModelIndex cellIndex = model2.index (row, cellColumn);
+
+            std::string cellId = model2.data (cellIndex).toString().toUtf8().data();
+
+            if (cellId.find ('#')!=std::string::npos)
+            {
+                // Need to recalculate the cell
+                modifyCell.reset (new UpdateCellCommand (model2, row));
+            }
+        }
+    }
+
+    std::auto_ptr<CSMWorld::ModifyCommand> modifyData (
+        new CSMWorld::ModifyCommand (*model, index, new_));
+
+    if (modifyCell.get())
+    {
+        mDocument.getUndoStack().beginMacro (modifyData->text());
+        mDocument.getUndoStack().push (modifyData.release());
+        mDocument.getUndoStack().push (modifyCell.release());
+        mDocument.getUndoStack().endMacro();
+    }
+    else
+        mDocument.getUndoStack().push (modifyData.release());
 }
 
 void CSMWorld::CommandDispatcher::executeDelete()

apps/opencs/model/world/commands.cpp

@@ -1,11 +1,16 @@
 
 #include "commands.hpp"
 
+#include <cmath>
+
+#include <sstream>
+
 #include <QAbstractItemModel>
 
-#include "idtable.hpp"
 #include <components/misc/stringops.hpp>
 
+#include "idtable.hpp"
+
 CSMWorld::ModifyCommand::ModifyCommand (QAbstractItemModel& model, const QModelIndex& index,
                                         const QVariant& new_, QUndoCommand* parent)
 : QUndoCommand (parent), mModel (model), mIndex (index), mNew (new_)
@@ -171,3 +176,43 @@ void CSMWorld::CloneCommand::undo()
 {
     mModel.removeRow (mModel.getModelIndex (mId, 0).row());
 }
+
+
+CSMWorld::UpdateCellCommand::UpdateCellCommand (IdTable& model, int row, QUndoCommand *parent)
+: QUndoCommand (parent), mModel (model), mRow (row)
+{
+    setText ("Update cell ID");
+}
+
+void CSMWorld::UpdateCellCommand::redo()
+{
+    if (!mNew.isValid())
+    {
+        int cellColumn = mModel.searchColumnIndex (Columns::ColumnId_Cell);
+        mIndex = mModel.index (mRow, cellColumn);
+
+        const int cellSize = 8192;
+
+        QModelIndex xIndex = mModel.index (
+            mRow, mModel.findColumnIndex (Columns::ColumnId_PositionXPos));
+
+        QModelIndex yIndex = mModel.index (
+            mRow, mModel.findColumnIndex (Columns::ColumnId_PositionYPos));
+
+        int x = std::floor (mModel.data (xIndex).toFloat() / cellSize);
+        int y = std::floor (mModel.data (yIndex).toFloat() / cellSize);
+
+        std::ostringstream stream;
+
+        stream << "#" << x << " " << y;
+
+        mNew = QString::fromUtf8 (stream.str().c_str());
+    }
+
+    mModel.setData (mIndex, mNew);
+}
+
+void CSMWorld::UpdateCellCommand::undo()
+{
+    mModel.setData (mIndex, mOld);
+}

apps/opencs/model/world/commands.hpp

@@ -18,7 +18,6 @@ class QAbstractItemModel;
 
 namespace CSMWorld
 {
-    class IdTable;
     class IdTable;
     class RecordBase;
 
@@ -139,6 +138,28 @@ namespace CSMWorld
 
             virtual void undo();
     };
+
+    /// \brief Update cell ID according to x/y-coordinates
+    ///
+    /// \note The new value will be calculated in the first call to redo instead of the
+    /// constructor to accommodate multiple coordinate-affecting commands being executed
+    /// in a macro.
+    class UpdateCellCommand : public QUndoCommand
+    {
+            IdTable& mModel;
+            int mRow;
+            QModelIndex mIndex;
+            QVariant mNew; // invalid, if new cell ID has not been calculated yet
+            QVariant mOld;
+
+        public:
+
+            UpdateCellCommand (IdTable& model, int row, QUndoCommand *parent = 0);
+
+            virtual void redo();
+
+            virtual void undo();
+    };
 }
 
 #endif