Code/Sandbox/Plugins/EditorCommon/DockingSystem/DockableContainer.cpp

   1 // Copyright 2001-2018 Crytek GmbH / Crytek Group. All rights reserved.
   2
   3 #include "StdAfx.h"
   4 #include "DockableContainer.h"
   5 #include "QTrackingTooltip.h"
   6 #include "Menu/AbstractMenu.h"
   7
   8 QToolWindowManagerClassFactory* CDockableContainer::s_dockingFactory = nullptr;
   9
  10 CDockableContainer::CDockableContainer(QWidget* parent, QVariantMap startingLayout /*= QVariantMap()*/)
  11         : QWidget(parent), m_startingLayout(startingLayout), m_toolManager(nullptr), m_defaultLayoutCallback(nullptr), m_pMenu(nullptr)
  12 {
  13 }
  14
  15 CDockableContainer::~CDockableContainer()
  16 {
  17         if (m_toolManager)
  18         {
  19                 disconnect(m_layoutChangedConnection);
  20         }
  21
  22         for (auto& pair : m_spawned)
  23         {
  24                 disconnect(pair.second.m_widget, 0, this, 0);
  25         }
  26         m_spawned.clear();
  27 }
  28
  29 void CDockableContainer::Register(QString name, std::function<QWidget*()> factory, bool isUnique, bool isInternal)
  30 {
  31         m_registry[name] = FactoryInfo(factory, isUnique, isInternal);
  32 }
  33
  34 QWidget* CDockableContainer::Spawn(QString name, QString forceObjectName)
  35 {
  36         auto it = m_registry.find(name);
  37         if (it != m_registry.end())
  38         {
  39                 if (it->second.m_isUnique)
  40                 {
  41                         for (auto wi : m_spawned)
  42                         {
  43                                 if (wi.second.m_spawnName == name)
  44                                 {
  45                                         // Already created, return existing instance
  46                                         return wi.second.m_widget;
  47                                 }
  48                         }
  49                 }
  50                 QWidget* w = it->second.m_factory();
  51                 if (forceObjectName.isEmpty())
  52                 {
  53                         w->setObjectName(CreateObjectName(name));
  54                 }
  55                 else
  56                 {
  57                         w->setObjectName(forceObjectName);
  58                 }
  59                 m_spawned[w->objectName()] = WidgetInstance(w, name);
  60                 connect(w, &QObject::destroyed, this, &CDockableContainer::OnWidgetDestroyed);
  61
  62                 return w;
  63         }
  64         return nullptr;
  65 }
  66
  67 QWidget* CDockableContainer::SpawnWidget(QString name, const QToolWindowAreaTarget& target)
  68 {
  69         return SpawnWidget(name, "", target);
  70 }
  71
  72 QWidget* CDockableContainer::SpawnWidget(QString name, QWidget* pTargetWidget, const QToolWindowAreaTarget& target)
  73 {
  74         IToolWindowArea* pToolArea = m_toolManager->areaOf(pTargetWidget);
  75         if (pToolArea)
  76         {
  77                 return SpawnWidget(name, "", pToolArea, target.reference, target.index, target.geometry);
  78         }
  79         return nullptr;
  80 }
  81
  82 QWidget* CDockableContainer::SpawnWidget(QString name, QString objectName, const QToolWindowAreaTarget& target)
  83 {
  84         return SpawnWidget(name, objectName, target.area, target.reference, target.index, target.geometry);
  85 }
  86
  87 QWidget* CDockableContainer::SpawnWidget(QString name, IToolWindowArea* area /*= nullptr*/, QToolWindowAreaReference reference /*= QToolWindowAreaTarget::Combine*/, int index /*= -1*/, QRect geometry /*= QRect()*/)
  88 {
  89         return SpawnWidget(name, "", area, reference, index, geometry);
  90 }
  91
  92 QWidget* CDockableContainer::SpawnWidget(QString name, QString objectName, IToolWindowArea* area /*= nullptr*/, QToolWindowAreaReference reference /*= QToolWindowManager::AreaReference::Combine*/, int index /*= -1*/, QRect geometry /*= QRect()*/)
  93 {
  94         QWidget* w = Spawn(name, objectName);
  95         if (w)
  96         {
  97                 if (!m_toolManager->ownsToolWindow(w)) //If it's already owned, this is a single-instance widget, so don't move it
  98                 {
  99                         m_toolManager->addToolWindow(w, area, reference, index, geometry);
 100                 }
 101                 m_toolManager->bringToFront(w);
 102         }
 103         return w;
 104 }
 105
 106 void CDockableContainer::SetDefaultLayoutCallback(std::function<void(CDockableContainer*)> callback)
 107 {
 108         m_defaultLayoutCallback = callback;
 109 }
 110
 111 void CDockableContainer::SetMenu(CAbstractMenu* pAbstractMenu)
 112 {
 113         m_pMenu = pAbstractMenu;
 114 }
 115
 116 void CDockableContainer::SetSplitterSizes(QWidget* widget, QList<int> sizes)
 117 {
 118         m_toolManager->resizeSplitter(widget, sizes);
 119 }
 120
 121 QVariantMap CDockableContainer::GetState() const
 122 {
 123         QVariantMap result;
 124         if (m_toolManager)
 125         {
 126                 QVariantMap stateMap;
 127                 for (auto sw : m_spawned)
 128                 {
 129                         CDockableContainer::WidgetInstance& w = sw.second;
 130                         if (m_toolManager->areaOf(w.m_widget))
 131                         {
 132                                 QVariantMap toolData;
 133                                 toolData.insert("class", w.m_spawnName);
 134                                 IStateSerializable* ssw = qobject_cast<IStateSerializable*>(w.m_widget);
 135                                 if (ssw)
 136                                 {
 137                                         toolData.insert("state", ssw->GetState());
 138                                 }
 139                                 stateMap[w.m_widget->objectName()] = toolData;
 140                         }
 141                 }
 142                 result["Windows"] = stateMap;
 143                 result["ToolsLayout"] = m_toolManager->saveState();
 144         }
 145         return result;
 146 }
 147
 148 void CDockableContainer::SetState(const QVariantMap& state)
 149 {
 150         if (!m_toolManager)
 151         {
 152                 m_startingLayout = state;
 153                 return;
 154         }
 155         auto lock = m_toolManager->getNotifyLock(false);
 156         m_toolManager->hide();
 157         m_toolManager->clear();
 158         m_spawned.clear();
 159         QVariantMap openToolsMap = state.value("Windows").toMap();
 160         for (QVariantMap::const_iterator iter = openToolsMap.begin(); iter != openToolsMap.end(); ++iter)
 161         {
 162                 QString key = iter.key();
 163                 QVariantMap v = iter.value().toMap();
 164                 QString className = v.value("class").toString();
 165                 QVariantMap toolState = v.value("state", QVariantMap()).toMap();
 166
 167                 QWidget* w = SpawnWidget(className, key);
 168                 IStateSerializable* ssw = qobject_cast<IStateSerializable*>(w);
 169                 if (w)
 170                 {
 171                         if (!toolState.empty() && ssw)
 172                         {
 173                                 ssw->SetState(toolState);
 174                         }
 175                 }
 176         }
 177
 178         m_toolManager->restoreState(state["ToolsLayout"]);
 179         BuildWindowMenu();
 180         m_toolManager->show();
 181         m_startingLayout = QVariantMap();
 182 }
 183
 184 void CDockableContainer::OnWidgetDestroyed(QObject* pObject)
 185 {
 186         auto it = m_spawned.find(pObject->objectName());
 187         if (it != m_spawned.end() && it->second.m_widget == pObject)
 188         {
 189                 m_spawned.erase(it);
 190                 BuildWindowMenu();
 191         }
 192 }
 193
 194 QString CDockableContainer::CreateObjectName(QString title) const
 195 {
 196         QString result = title;
 197         while (m_spawned.find(result) != m_spawned.end())
 198         {
 199                 int i = qrand();
 200                 result = QString::asprintf("%s#%d", title.toStdString().c_str(), i);
 201         }
 202         return result;
 203 }
 204
 205 void CDockableContainer::showEvent(QShowEvent* event)
 206 {
 207         // Construct everything in the show event to ensure owner is fully constructed
 208         if (m_toolManager)
 209         {
 210                 return;
 211         }
 212
 213         QVariantMap config = CEditorDialog::s_config;
 214         config[QTWM_RELEASE_POLICY] = rcpDelete;
 215         m_toolManager = new QToolWindowManager(this, config, s_dockingFactory);
 216         connect(m_toolManager, &QToolWindowManager::updateTrackingTooltip, [](const QString& str, const QPoint& p) { QTrackingTooltip::ShowTextTooltip(str, p); });
 217         setLayout(new QVBoxLayout());
 218         layout()->setContentsMargins(0, 0, 0, 0);
 219         setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
 220         layout()->addWidget(m_toolManager);
 221         if (!m_startingLayout.isEmpty())
 222         {
 223                 SetState(m_startingLayout);
 224         }
 225         else
 226         {
 227                 m_defaultLayoutCallback(this);
 228         }
 229
 230         m_layoutChangedConnection = connect(m_toolManager, &QToolWindowManager::layoutChanged, [=]() { OnLayoutChange(GetState()); BuildWindowMenu(); });
 231         BuildWindowMenu();
 232 }
 233
 234 void CDockableContainer::BuildWindowMenu()
 235 {
 236         if (!m_pMenu)
 237         {
 238                 return;
 239         }
 240
 241         m_pMenu->Clear();
 242
 243         CAbstractMenu* addMenu = nullptr;
 244         for (auto it : m_registry)
 245         {
 246                 if (it.second.m_isInternal)
 247                 {
 248                         continue;
 249                 }
 250
 251                 if (!addMenu)
 252                 {
 253                         addMenu = m_pMenu->CreateMenu("&Add Pane");
 254                 }
 255
 256                 QString s = it.first;
 257                 QAction* action = addMenu->CreateAction(s);
 258                 connect(action, &QAction::triggered, [=]() { return SpawnWidget(s); });
 259         }
 260
 261         QAction* action = m_pMenu->CreateAction("&Reset layout");
 262         connect(action, &QAction::triggered, [=] { ResetLayout(); });
 263
 264         int sec = m_pMenu->GetNextEmptySection();
 265
 266         foreach(QWidget* q, m_toolManager->toolWindows())
 267         {
 268                 QAction* action = m_pMenu->CreateAction(q->windowTitle(), sec);
 269                 connect(action, &QAction::triggered, [=] { m_toolManager->bringToFront(q); });
 270         }
 271 }
 272
 273 void CDockableContainer::ResetLayout()
 274 {
 275         QToolWindowManager::QTWMNotifyLock lock = m_toolManager->getNotifyLock();
 276         m_toolManager->hide();
 277         m_toolManager->clear();
 278         m_spawned.clear();
 279         m_defaultLayoutCallback(this);
 280         m_toolManager->show();
 281 }
 282
 283 CDockableContainer::FactoryInfo::FactoryInfo(std::function<QWidget*()> factory, bool isUnique, bool isInternal) : m_factory(factory), m_isUnique(isUnique), m_isInternal(isInternal)
 284 {
 285 }
 286
 287 CDockableContainer::WidgetInstance::WidgetInstance(QWidget* widget, QString spawnName) : m_widget(widget), m_spawnName(spawnName)
 288 {
 289 }