Code/Sandbox/Plugins/EditorSchematyc/PluginUtils.cpp

   1 // Copyright 2001-2018 Crytek GmbH / Crytek Group. All rights reserved.
   2
   3 #include "StdAfx.h"
   4
   5 #include "PluginUtils.h"
   6
   7 #include <IActionMapManager.h> // #SchematycTODO : Remove dependency on CryAction!
   8 #include <IResourceSelectorHost.h>
   9 #include <ISourceControl.h>
  10 #include <CryEntitySystem/IEntityClass.h>
  11 #include <CryEntitySystem/IEntitySystem.h>
  12 #include <Cry3DEngine/I3DEngine.h>
  13 #include <CryGame/IGameFramework.h>
  14 #include <CryString/CryStringUtils.h>
  15 #include <CrySchematyc/Utils/Assert.h>
  16
  17 #include <Controls/DictionaryWidget.h>
  18 #include <Controls/QPopupWidget.h>
  19
  20 #include <QtUtil.h>
  21 #include <QClipboard>
  22 #include <QMimeData>
  23 #include <QApplication>
  24
  25 namespace CrySchematycEditor {
  26
  27 enum EColumn : int32
  28 {
  29         Column_Name,
  30         Column_COUNT
  31 };
  32
  33 class CStringListDictionaryEntry : public CAbstractDictionaryEntry
  34 {
  35         friend class CStringListDictionary;
  36
  37 public:
  38         CStringListDictionaryEntry() {}
  39         virtual ~CStringListDictionaryEntry() {}
  40
  41         // CAbstractDictionaryEntry
  42         virtual uint32   GetType() const override { return CAbstractDictionaryEntry::Type_Entry; }
  43
  44         virtual QVariant GetColumnValue(int32 columnIndex) const override
  45         {
  46                 if (columnIndex == Column_Name)
  47                 {
  48                         return m_name;
  49                 }
  50                 return QVariant();
  51         }
  52         // ~CAbstractDictionaryEntry
  53
  54         QString GetName() const { return m_name; }
  55
  56 private:
  57         QString m_name;
  58 };
  59
  60 class CStringListDictionary : public CAbstractDictionary
  61 {
  62 public:
  63         CStringListDictionary(const Serialization::StringListStatic& names)
  64         {
  65                 Load(names);
  66         }
  67         CStringListDictionary(const Serialization::StringList& names)
  68         {
  69                 Load(names);
  70         }
  71         virtual ~CStringListDictionary() {}
  72
  73         // CryGraphEditor::CAbstractDictionary
  74         virtual void                            ResetEntries() override              { m_func(); }
  75         virtual int32                           GetNumEntries() const override       { return m_names.size(); }
  76         virtual const CAbstractDictionaryEntry* GetEntry(int32 index) const override { return (m_names.size() > index) ? &m_names[index] : nullptr; }
  77
  78         virtual int32                           GetNumColumns() const override       { return Column_COUNT; };
  79         virtual QString                         GetColumnName(int32 index) const override
  80         {
  81                 if (index == Column_Name)
  82                         return QString("Name");
  83                 return QString();
  84         }
  85
  86         virtual int32 GetDefaultFilterColumn() const override { return Column_Name; }
  87         // ~CryGraphEditor::CAbstractDictionary
  88
  89         template <class StringList> void Load(const StringList& names)
  90         {
  91                 m_func = std::bind([this, names]()
  92                 {
  93                         for (string name : names)
  94                         {
  95                                 CStringListDictionaryEntry entry;
  96                                 entry.m_name = name;
  97                                 m_names.emplace_back(entry);
  98                         }
  99                 });
 100
 101                 Reset();
 102
 103                 m_func = std::bind([]() {});
 104         }
 105
 106 private:
 107         std::function<void()>                   m_func;
 108         std::vector<CStringListDictionaryEntry> m_names;
 109 };
 110
 111 class CActionMapActionQuickSearchOptions : public IActionMapPopulateCallBack
 112 {
 113 public:
 114         CActionMapActionQuickSearchOptions()
 115         {
 116                 IActionMapManager* pActionMapManager = gEnv->pGameFramework->GetIActionMapManager();
 117                 if (pActionMapManager && (pActionMapManager->GetActionsCount() > 0))
 118                 {
 119                         pActionMapManager->EnumerateActions(this);
 120                 }
 121         }
 122
 123         // IActionMapPopulateCallBack
 124         virtual void AddActionName(const char* const szName) override
 125         {
 126                 m_names.push_back(szName);
 127         }
 128         // ~IActionMapPopulateCallBack
 129
 130         Serialization::StringListStatic& GetNames() { return m_names; }
 131
 132 private:
 133         Serialization::StringListStatic m_names;
 134 };
 135
 136 }
 137
 138 namespace {
 139
 140 dll_string EntityClassNameSelector(const SResourceSelectorContext& context, const char* szPreviousValue, Serialization::StringListValue* pStringListValue)
 141 {
 142         Serialization::StringListStatic names;
 143
 144         IEntityClassRegistry& entityClassRegistry = *gEnv->pEntitySystem->GetClassRegistry();
 145         entityClassRegistry.IteratorMoveFirst();
 146
 147         while (IEntityClass* pClass = entityClassRegistry.IteratorNext())
 148         {
 149                 if ((pClass->GetFlags() & ECLF_INVISIBLE) != 0)
 150                         continue;
 151
 152                 names.push_back(pClass->GetName());
 153         }
 154
 155         CrySchematycEditor::CStringListDictionary dict(names);
 156         CModalPopupDictionary dictionary("Entity Class", dict);
 157
 158         const QPoint pos = QCursor::pos();
 159         dictionary.ExecAt(pos);
 160
 161         CrySchematycEditor::CStringListDictionaryEntry* pEntry = static_cast<CrySchematycEditor::CStringListDictionaryEntry*>(dictionary.GetResult());
 162         if (pEntry)
 163         {
 164                 return QtUtil::ToString(pEntry->GetName()).c_str();
 165         }
 166
 167         return "";
 168 }
 169
 170 dll_string ActionMapNameSelector(const SResourceSelectorContext& context, const char* szPreviousValue, Serialization::StringListValue* pStringListValue)
 171 {
 172         Serialization::StringListStatic names;
 173
 174         IActionMapIteratorPtr itActionMap = gEnv->pGameFramework->GetIActionMapManager()->CreateActionMapIterator();
 175         while (IActionMap* pActionMap = itActionMap->Next())
 176         {
 177                 const char* szName = pActionMap->GetName();
 178                 if (strcmp(szName, "default"))
 179                 {
 180                         names.push_back(szName);
 181                 }
 182         }
 183
 184         CrySchematycEditor::CStringListDictionary dict(names);
 185         CModalPopupDictionary dictionary("Action Map", dict);
 186
 187         const QPoint pos = QCursor::pos();
 188         dictionary.ExecAt(pos);
 189
 190         CrySchematycEditor::CStringListDictionaryEntry* pEntry = static_cast<CrySchematycEditor::CStringListDictionaryEntry*>(dictionary.GetResult());
 191         if (pEntry)
 192         {
 193                 return QtUtil::ToString(pEntry->GetName()).c_str();
 194         }
 195
 196         return "";
 197 }
 198
 199 dll_string ActionMapActionNameSelector(const SResourceSelectorContext& context, const char* szPreviousValue, Serialization::StringListValue* pStringListValue)
 200 {
 201         CrySchematycEditor::CActionMapActionQuickSearchOptions quickSearchOptions;
 202
 203         CrySchematycEditor::CStringListDictionary dict(quickSearchOptions.GetNames());
 204         CModalPopupDictionary dictionary("Action Map Action", dict);
 205
 206         const QPoint pos = QCursor::pos();
 207         dictionary.ExecAt(pos);
 208
 209         CrySchematycEditor::CStringListDictionaryEntry* pEntry = static_cast<CrySchematycEditor::CStringListDictionaryEntry*>(dictionary.GetResult());
 210         if (pEntry)
 211         {
 212                 return QtUtil::ToString(pEntry->GetName()).c_str();
 213         }
 214
 215         return "";
 216 }
 217
 218 dll_string SurfaceTypeNameSelector(const SResourceSelectorContext& context, const char* szPreviousValue, Serialization::StringListValue* pStringListValue)
 219 {
 220         Serialization::StringListStatic names;
 221
 222         ISurfaceTypeEnumerator* pEnumerator = gEnv->p3DEngine->GetMaterialManager()->GetSurfaceTypeManager()->GetEnumerator();
 223         for (ISurfaceType* pSurfaceType = pEnumerator->GetFirst(); pSurfaceType != nullptr; pSurfaceType = pEnumerator->GetNext())
 224         {
 225                 cstr name = pSurfaceType->GetName();
 226                 if (strlen(name) >= 4 && !strncmp(name, "mat_", 4))
 227                         name += 4;
 228                 names.push_back(name);
 229         }
 230
 231         CrySchematycEditor::CStringListDictionary dict(names);
 232         CModalPopupDictionary dictionary("Surface Type", dict);
 233
 234         const QPoint pos = QCursor::pos();
 235         dictionary.ExecAt(pos);
 236
 237         CrySchematycEditor::CStringListDictionaryEntry* pEntry = static_cast<CrySchematycEditor::CStringListDictionaryEntry*>(dictionary.GetResult());
 238         if (pEntry)
 239         {
 240                 return QtUtil::ToString(pEntry->GetName()).c_str();
 241         }
 242
 243         return "";
 244 }
 245
 246 static dll_string MannequinScopeContextName(const SResourceSelectorContext& context, const char* szPreviousValue, Serialization::StringListValue* pStringListValue)
 247 {
 248         if (std::shared_ptr<Serialization::SMannequinControllerDefResourceParams> pParams = std::static_pointer_cast<Serialization::SMannequinControllerDefResourceParams>(context.pCustomParams))
 249         {
 250                 if (pParams->pControllerDef != nullptr)
 251                 {
 252                         Serialization::StringListStatic names;
 253
 254                         for (int i = 0, n = pParams->pControllerDef->m_scopeContexts.GetNum(); i < n; ++i)
 255                         {
 256                                 names.push_back(pParams->pControllerDef->m_scopeContexts.GetTagName(i));
 257                         }
 258
 259                         CrySchematycEditor::CStringListDictionary dict(names);
 260                         CModalPopupDictionary dictionary("Mannequin Scope Context", dict);
 261
 262                         const QPoint pos = QCursor::pos();
 263                         dictionary.ExecAt(pos);
 264
 265                         CrySchematycEditor::CStringListDictionaryEntry* pEntry = static_cast<CrySchematycEditor::CStringListDictionaryEntry*>(dictionary.GetResult());
 266                         if (pEntry)
 267                         {
 268                                 return QtUtil::ToString(pEntry->GetName()).c_str();
 269                         }
 270                 }
 271         }
 272
 273         return "";
 274 }
 275
 276 static dll_string MannequinFragmentName(const SResourceSelectorContext& context, const char* szPreviousValue, Serialization::StringListValue* pStringListValue)
 277 {
 278         if (std::shared_ptr<Serialization::SMannequinControllerDefResourceParams> pParams = std::static_pointer_cast<Serialization::SMannequinControllerDefResourceParams>(context.pCustomParams))
 279         {
 280                 if (pParams->pControllerDef != nullptr)
 281                 {
 282                         Serialization::StringListStatic names;
 283
 284                         for (int i = 0, n = pParams->pControllerDef->m_fragmentIDs.GetNum(); i < n; ++i)
 285                         {
 286                                 names.push_back(pParams->pControllerDef->m_fragmentIDs.GetTagName(i));
 287                         }
 288
 289                         CrySchematycEditor::CStringListDictionary dict(names);
 290                         CModalPopupDictionary dictionary("Mannequin Fragment", dict);
 291
 292                         const QPoint pos = QCursor::pos();
 293                         dictionary.ExecAt(pos);
 294
 295                         CrySchematycEditor::CStringListDictionaryEntry* pEntry = static_cast<CrySchematycEditor::CStringListDictionaryEntry*>(dictionary.GetResult());
 296                         if (pEntry)
 297                         {
 298                                 return QtUtil::ToString(pEntry->GetName()).c_str();
 299                         }
 300                 }
 301         }
 302
 303         return "";
 304 }
 305
 306 REGISTER_RESOURCE_SELECTOR("EntityClass", EntityClassNameSelector, "")
 307 REGISTER_RESOURCE_SELECTOR("ActionMap", ActionMapNameSelector, "")
 308 REGISTER_RESOURCE_SELECTOR("ActionMapAction", ActionMapActionNameSelector, "")
 309 REGISTER_RESOURCE_SELECTOR("SurfaceTypeName", SurfaceTypeNameSelector, "")
 310 REGISTER_RESOURCE_SELECTOR("MannequinScopeContextName", MannequinScopeContextName, "")
 311 REGISTER_RESOURCE_SELECTOR("MannequinFragmentName", MannequinFragmentName, "")
 312 }
 313
 314 namespace CrySchematycEditor {
 315 namespace Utils {
 316
 317 void ConstructAbsolutePath(Schematyc::IString& output, const char* szFileName)
 318 {
 319         char currentDirectory[512] = "";
 320         GetCurrentDirectory(sizeof(currentDirectory) - 1, currentDirectory);
 321
 322         Schematyc::CStackString temp = currentDirectory;
 323         temp.append("\\");
 324         temp.append(szFileName);
 325         temp.replace("/", "\\");
 326
 327         output.assign(temp);
 328 }
 329
 330 bool WriteToClipboard(const char* szText, const char* szPrefix)
 331 {
 332         SCHEMATYC_EDITOR_ASSERT(szText);
 333         if (szText)
 334         {
 335                 QMimeData* pMimeData = new QMimeData();
 336                 if (szPrefix)
 337                         pMimeData->setData(szPrefix, szText);
 338                 else
 339                         pMimeData->setText(szText);
 340
 341                 QClipboard* pClipboard = QApplication::clipboard();
 342                 pClipboard->setMimeData(pMimeData);
 343
 344                 return true;
 345         }
 346         return false;
 347 }
 348
 349 bool ReadFromClipboard(string& text, const char* szPrefix)
 350 {
 351         QClipboard* pClipboard = QApplication::clipboard();
 352         if (pClipboard)
 353         {
 354                 const QMimeData* pMimeData = pClipboard->mimeData();
 355                 if (szPrefix)
 356                 {
 357                         QByteArray byteArray = pMimeData->data(szPrefix);
 358                         if (byteArray.length() > 0)
 359                         {
 360                                 text.reserve(byteArray.length());
 361                                 text.assign(byteArray.data(), byteArray.length());
 362                                 return true;
 363                         }
 364                 }
 365                 else
 366                 {
 367                         text = pMimeData->text().toUtf8();
 368                         return text.length() > 0;
 369                 }
 370         }
 371
 372         text.clear();
 373         return false;
 374 }
 375
 376 bool ValidateClipboardContents(const char* szPrefix)
 377 {
 378         SCHEMATYC_EDITOR_ASSERT(szPrefix);
 379
 380         QClipboard* pClipboard = QApplication::clipboard();
 381         if (pClipboard)
 382         {
 383                 const QMimeData* pMimeData = pClipboard->mimeData();
 384                 QByteArray byteArray = pMimeData->data(szPrefix);
 385                 if (byteArray.length() > 0)
 386                 {
 387                         return true;
 388                 }
 389         }
 390         return false;
 391 }
 392
 393 }
 394 }