ObjectFolderOrObject.h

/*
 * GDevelop Core
 * Copyright 2008-2023 Florian Rival ([email protected]). All rights
 * reserved. This project is released under the MIT License.
 */
#pragma once
 
#include <memory>
#include <vector>
 
#include "GDCore/Serialization/SerializerElement.h"
#include "GDCore/String.h"
#include "GDCore/Project/QuickCustomization.h"
#include "GDCore/Project/MemoryTrackedRegistry.h"
 
namespace gd {
class Project;
class Object;
class SerializerElement;
class ObjectsContainer;
}  // namespace gd
 
namespace gd {
 
class GD_CORE_API ObjectFolderOrObject {
 public:
  ObjectFolderOrObject();
  virtual ~ObjectFolderOrObject();
  ObjectFolderOrObject(gd::String folderName_,
                       ObjectFolderOrObject* parent_ = nullptr);
  ObjectFolderOrObject(gd::Object* object_,
                       ObjectFolderOrObject* parent_ = nullptr);
 
  gd::Object& GetObject() const { return *object; }
 
  bool IsFolder() const { return !folderName.empty(); }
  const gd::String& GetFolderName() const { return folderName; }
 
  void SetFolderName(const gd::String& name);
 
  bool HasObjectNamed(const gd::String& name);
  ObjectFolderOrObject& GetObjectNamed(const gd::String& name);
 
  std::size_t GetChildrenCount() const {
    if (IsFolder()) return children.size();
    return 0;
  }
  ObjectFolderOrObject& GetChildAt(std::size_t index);
  const ObjectFolderOrObject& GetChildAt(std::size_t index) const;
  ObjectFolderOrObject& GetObjectChild(const gd::String& name);
 
  ObjectFolderOrObject& GetParent() {
    if (parent == nullptr) {
      return badObjectFolderOrObject;
    }
    return *parent;
  };
 
  bool IsRootFolder() { return !object && !parent; }
 
  void MoveChild(std::size_t oldIndex, std::size_t newIndex);
  void RemoveFolderChild(const ObjectFolderOrObject& childToRemove);
  void RemoveRecursivelyObjectNamed(const gd::String& name);
  void Clear();
 
  void InsertObject(gd::Object* insertedObject,
                    std::size_t position = (size_t)-1);
  ObjectFolderOrObject& InsertNewFolder(const gd::String& newFolderName,
                                        std::size_t position);
 
  ObjectFolderOrObject &GetOrCreateFolderChild(const gd::String &name);
 
  bool IsADescendantOf(const ObjectFolderOrObject& otherObjectFolderOrObject);
 
  std::size_t GetChildPosition(const ObjectFolderOrObject& child) const;
  void MoveObjectFolderOrObjectToAnotherFolder(
      gd::ObjectFolderOrObject& objectFolderOrObject,
      gd::ObjectFolderOrObject& newParentFolder,
      std::size_t newPosition);
 
  QuickCustomization::Visibility GetQuickCustomizationVisibility() const { return quickCustomizationVisibility; }
  void SetQuickCustomizationVisibility(QuickCustomization::Visibility visibility) {
    quickCustomizationVisibility = visibility;
  }
 
 
  void SerializeTo(SerializerElement& element) const;
 
  void UnserializeFrom(gd::Project& project,
                       const SerializerElement& element,
                       ObjectsContainer& objectsContainer);
 
 private:
  static gd::ObjectFolderOrObject badObjectFolderOrObject;
 
  gd::ObjectFolderOrObject*
      parent = nullptr;  // nullptr if root folder, points to the parent folder otherwise.
  QuickCustomization::Visibility quickCustomizationVisibility;
 
  // Representing an object:
  gd::Object* object;  // nullptr if folderName is set.
 
  // or representing a folder:
  gd::String folderName;  // Empty if object is set.
  std::vector<std::unique_ptr<ObjectFolderOrObject>>
      children;  // Folder children.
 
  gd::MemoryTracked _memoryTracked{this, "ObjectFolderOrObject"};
};
 
}  // namespace gd