Code/Sandbox/EditorQt/Undo/CommandHistory.cpp

   1 // Copyright 2001-2018 Crytek GmbH / Crytek Group. All rights reserved.
   2
   3 #include "StdAfx.h"
   4
   5 #include "CommandHistory.h"
   6 #include "RecursionLoopGuard.h"
   7 #include "IUndoManager.h"
   8 #include <QMouseEvent>
   9 #include <QLayout>
  10 #include <QAdvancedTreeView.h>
  11 #include <EditorStyleHelper.h>
  12 #include "IEditorClassFactory.h"
  13
  14 REGISTER_HIDDEN_VIEWPANE_FACTORY(CHistoryPanel, "Undo History", "Tools", true)
  15
  16 namespace Private_CommandHistory
  17 {
  18 class QHistoryModel : public QAbstractTableModel
  19 {
  20 public:
  21         QHistoryModel(QWidget* parent, IUndoManager* pCommandManager);
  22         ~QHistoryModel();
  23         int      rowCount(const QModelIndex& parent = QModelIndex()) const;
  24         int      columnCount(const QModelIndex& parent = QModelIndex()) const;
  25         QVariant data(const QModelIndex& index, int role = Qt::DisplayRole) const;
  26         QVariant headerData(int section, Qt::Orientation orientation, int role) const;
  27         void     OnCommandBufferChange(CUndoStep* pCommand, IUndoManager::ECommandChangeType change, int index);
  28         void     FillHistoryFromCommandBuffer();
  29
  30         CCrySignal<void(CUndoStep*, IUndoManager::ECommandChangeType, int)> signalBufferChanged;
  31
  32 private:
  33         IUndoManager*           m_pCommandManager;
  34         std::vector<CUndoStep*> m_commands;
  35         QFont                   m_font;
  36         QFont                   m_disabledFont;
  37
  38         int getCurrentIndex() const
  39         {
  40                 if (m_pCommandManager)
  41                         return m_pCommandManager->GetUndoStackLen();
  42                 return 0;
  43         }
  44 };
  45
  46 QHistoryModel::QHistoryModel(QWidget* parent, IUndoManager* pCommandManager)
  47         : QAbstractTableModel(parent)
  48         , m_pCommandManager(pCommandManager)
  49 {
  50         FillHistoryFromCommandBuffer();
  51         if (m_pCommandManager)
  52                 m_pCommandManager->signalBufferChanged.Connect(this, &QHistoryModel::OnCommandBufferChange);
  53
  54         m_font = QFont(parent->font());
  55
  56 }
  57
  58 QHistoryModel::~QHistoryModel()
  59 {
  60         if (m_pCommandManager)
  61                 m_pCommandManager->signalBufferChanged.DisconnectObject(this);
  62 }
  63
  64 void QHistoryModel::FillHistoryFromCommandBuffer()
  65 {
  66         m_commands.clear();
  67
  68         if (m_pCommandManager)
  69         {
  70                 for (CUndoStep* pCommand : m_pCommandManager->GetUndoStack())
  71                         m_commands.push_back(pCommand);
  72                 for (CUndoStep* pCommand : m_pCommandManager->GetRedoStack())
  73                         m_commands.push_back(pCommand);
  74         }
  75
  76         dataChanged(index(0, 0), index(rowCount() - 1, columnCount() - 1));
  77 }
  78
  79 void QHistoryModel::OnCommandBufferChange(CUndoStep* pCommand, IUndoManager::ECommandChangeType changeType, int changedIndex)
  80 {
  81         if (!m_pCommandManager)
  82                 return;
  83
  84         if (IUndoManager::eCommandChangeType_Move & changeType)
  85         {
  86                 dataChanged(index(0, 0), index(rowCount() - 1, columnCount() - 1));
  87         }
  88
  89         if (IUndoManager::eCommandChangeType_Insert & changeType)
  90         {
  91                 beginInsertRows(QModelIndex(), changedIndex + 1, changedIndex + 1);
  92                 m_commands.insert(m_commands.begin() + changedIndex, pCommand);
  93                 endInsertRows();
  94         }
  95
  96         if (IUndoManager::eCommandChangeType_Remove & changeType)
  97         {
  98                 if (-1 != changedIndex && 0 != m_commands.size())
  99                 {
 100                         if (pCommand)
 101                         {
 102                                 beginRemoveRows(QModelIndex(), changedIndex + 1, changedIndex + 1);
 103                                 m_commands.erase(m_commands.begin() + changedIndex);
 104                                 endRemoveRows();
 105                         }
 106                         else if (IUndoManager::eCommandChangeType_Undo & changeType)
 107                         {
 108                                 beginRemoveRows(QModelIndex(), 1, changedIndex);
 109                                 m_commands.erase(m_commands.begin(), m_commands.begin() + changedIndex);
 110                                 endRemoveRows();
 111                         }
 112                         else if (IUndoManager::eCommandChangeType_Redo & changeType)
 113                         {
 114                                 beginRemoveRows(QModelIndex(), rowCount() - (changedIndex + 1), rowCount() - 1);
 115                                 m_commands.erase(m_commands.end() - changedIndex, m_commands.end());
 116                                 endRemoveRows();
 117                         }
 118                 }
 119         }
 120
 121         signalBufferChanged(pCommand, changeType, changedIndex);
 122 }
 123
 124 int QHistoryModel::rowCount(const QModelIndex& parent) const
 125 {
 126         if (!parent.isValid() && m_pCommandManager)
 127                 return 1 + m_commands.size();
 128         return 1;
 129 }
 130
 131 int QHistoryModel::columnCount(const QModelIndex& parent) const
 132 {
 133         if (!parent.isValid())
 134                 return 1;
 135         return 0;
 136 }
 137
 138 QVariant QHistoryModel::data(const QModelIndex& index, int role) const
 139 {
 140         int row = index.row();
 141         int col = index.column();
 142
 143         switch (role)
 144         {
 145         case Qt::DisplayRole:
 146                 if (0 == row)
 147                 {
 148                         return QString("Starting Point");
 149                 }
 150                 else if (m_commands.size() >= row && m_pCommandManager)
 151                 {
 152                         string name;
 153                         m_pCommandManager->GetCommandName(m_commands[row - 1], name);
 154                         return QString(name.GetBuffer());
 155                 }
 156                 break;
 157
 158         case Qt::FontRole:
 159                 if (row > getCurrentIndex())
 160                 {
 161                         QFont font;
 162                         font.setItalic(true);
 163                         return font;
 164                 }
 165                 break;
 166
 167         case Qt::TextColorRole:
 168                 if (row > getCurrentIndex())
 169                 {
 170                         QColor color = GetStyleHelper()->disabledWindowTextColor();
 171                         return color;
 172                 }
 173                 break;
 174         }
 175         return QVariant();
 176 }
 177
 178 QVariant QHistoryModel::headerData(int section, Qt::Orientation orientation, int role) const
 179 {
 180         if (orientation == Qt::Horizontal && role == Qt::DisplayRole)
 181         {
 182                 switch (section)
 183                 {
 184                 case 0:
 185                         return QString("Commands");
 186                 }
 187         }
 188
 189         return QVariant();
 190 }
 191
 192 class QHistoryView : public QAdvancedTreeView
 193 {
 194 public:
 195         QHistoryView(IUndoManager* pCommandManager, QHistoryModel* pModel)
 196                 : m_pCommandManager(pCommandManager)
 197                 , m_validating(false)
 198                 , m_pModel(pModel)
 199         {
 200                 setSelectionMode(QAbstractItemView::SingleSelection);
 201
 202                 if (m_pCommandManager && pModel)
 203                 {
 204                         pModel->signalBufferChanged.Connect(this, &QHistoryView::OnCommandBufferChange);
 205                 }
 206         }
 207
 208         ~QHistoryView()
 209         {
 210         }
 211
 212 protected:
 213         void selectRow(int row)
 214         {
 215                 if (selectionModel() && model())
 216                         selectionModel()->select(model()->index(row, 0), QItemSelectionModel::ClearAndSelect);
 217         }
 218
 219         void QHistoryView::OnCommandBufferChange(CUndoStep* pCommand, IUndoManager::ECommandChangeType changeType, int index)
 220         {
 221                 RECURSION_GUARD(m_validating);
 222
 223                 if (IUndoManager::eCommandChangeType_Move & changeType)
 224                 {
 225                         selectRow(index + 1);
 226                 }
 227
 228                 if (IUndoManager::eCommandChangeType_Insert & changeType)
 229                 {
 230                         selectRow(index + 1);
 231                 }
 232
 233                 if (IUndoManager::eCommandChangeType_Remove & changeType)
 234                 {
 235                         if (-1 != index)
 236                         {
 237                                 if (m_pCommandManager)
 238                                 {
 239                                         selectRow(index);
 240                                 }
 241                                 else if (IUndoManager::eCommandChangeType_Undo & changeType)
 242                                 {
 243                                         selectRow(model()->rowCount() - 1);
 244                                 }
 245                                 else if (IUndoManager::eCommandChangeType_Redo & changeType)
 246                                 {
 247                                         selectRow(model()->rowCount() - 1);
 248                                 }
 249                         }
 250                 }
 251         }
 252
 253         virtual void selectionChanged(const QItemSelection& selected, const QItemSelection& deselected) override
 254         {
 255                 RECURSION_GUARD(m_validating);
 256
 257                 if (0 != selected.size() && m_pCommandManager)
 258                 {
 259                         int row = selected.front().top();
 260                         int count = m_pCommandManager->GetRedoStackLen() + m_pCommandManager->GetUndoStackLen() + 1;
 261
 262                         if (0 <= row && count > row)
 263                         {
 264                                 int undoCount = m_pCommandManager->GetUndoStackLen();
 265                                 int commandIndex = row - undoCount;
 266
 267                                 if (commandIndex > 0)
 268                                         m_pCommandManager->Redo(commandIndex);
 269                                 else if (commandIndex < 0)
 270                                         m_pCommandManager->Undo(abs(commandIndex));
 271                         }
 272                 }
 273
 274                 __super::selectionChanged(selected, deselected);
 275         }
 276
 277 private:
 278         bool           m_validating;
 279         IUndoManager*  m_pCommandManager;
 280         QHistoryModel* m_pModel;
 281 };
 282 }
 283
 284 CHistoryPanel::CHistoryPanel()
 285         : CDockableWidget()
 286 {
 287         QVBoxLayout* layout = new QVBoxLayout();
 288         layout->setContentsMargins(1, 1, 1, 1);
 289         setLayout(layout);
 290
 291         IUndoManager* pCommandManager = GetIEditorImpl()->GetIUndoManager();
 292         if (pCommandManager)
 293         {
 294                 Private_CommandHistory::QHistoryModel* pHistoryModel = new Private_CommandHistory::QHistoryModel(this, pCommandManager);
 295                 Private_CommandHistory::QHistoryView* pHistoryList = new Private_CommandHistory::QHistoryView(pCommandManager, pHistoryModel);
 296                 pHistoryList->setModel(pHistoryModel);
 297                 layout->addWidget(pHistoryList);
 298         }
 299 }
 300
 301 CHistoryPanel::~CHistoryPanel()
 302 {
 303 }