Layout.h

/*
 * GDevelop Core
 * Copyright 2008-2016 Florian Rival ([email protected]). All rights
 * reserved. This project is released under the MIT License.
 */
 
#ifndef GDCORE_LAYOUT_H
#define GDCORE_LAYOUT_H
#include <map>
#include <memory>
#include <vector>
#include "GDCore/Events/EventsList.h"
#include "GDCore/Project/BehaviorsSharedData.h"
#include "GDCore/Project/InitialInstancesContainer.h"
#include "GDCore/Project/Layer.h"
#include "GDCore/Project/ObjectGroupsContainer.h"
#include "GDCore/Project/ObjectsContainer.h"
#include "GDCore/Project/VariablesContainer.h"
#include "GDCore/String.h"
#include "GDCore/IDE/Dialogs/LayoutEditorCanvas/EditorSettings.h"
 
namespace gd {
class BaseEvent;
class Object;
class Project;
class InitialInstancesContainer;
}  // namespace gd
class TiXmlElement;
class BaseProfiler;
#undef GetObject  // Disable an annoying macro
 
namespace gd {
 
class GD_CORE_API Layout : public ObjectsContainer {
 public:
  Layout();
  Layout(const Layout&);
  virtual ~Layout();
  Layout& operator=(const Layout& rhs);
 
  Layout* Clone() const { return new Layout(*this); };
 
 
  void SetName(const gd::String& name_);
 
  const gd::String& GetName() const { return name; };
 
  const gd::String& GetMangledName() const { return mangledName; };
 
  void SetBackgroundColor(unsigned int r, unsigned int g, unsigned int b) {
    backgroundColorR = r;
    backgroundColorG = g;
    backgroundColorB = b;
  }
 
  unsigned int GetBackgroundColorRed() const { return backgroundColorR; }
 
  unsigned int GetBackgroundColorGreen() const { return backgroundColorG; }
 
  unsigned int GetBackgroundColorBlue() const { return backgroundColorB; }
 
  const gd::String& GetWindowDefaultTitle() const { return title; };
 
  void SetWindowDefaultTitle(const gd::String& title_) { title = title_; };
 
 
 
  const gd::InitialInstancesContainer& GetInitialInstances() const {
    return initialInstances;
  }
 
  gd::InitialInstancesContainer& GetInitialInstances() {
    return initialInstances;
  }
 
 
  const gd::EventsList& GetEvents() const { return events; }
 
  gd::EventsList& GetEvents() { return events; }
 
 
 
  inline const gd::VariablesContainer& GetVariables() const {
    return variables;
  }
 
  inline gd::VariablesContainer& GetVariables() { return variables; }
 
 
 
  bool HasLayerNamed(const gd::String& name) const;
 
  Layer& GetLayer(const gd::String& name);
 
  const Layer& GetLayer(const gd::String& name) const;
 
  Layer& GetLayer(std::size_t index);
 
  const Layer& GetLayer(std::size_t index) const;
 
  std::size_t GetLayerPosition(const gd::String& name) const;
 
  std::size_t GetLayersCount() const;
 
  void InsertNewLayer(const gd::String& name, std::size_t position);
 
  void InsertLayer(const Layer& theLayer, std::size_t position);
 
  void RemoveLayer(const gd::String& name);
 
  void SwapLayers(std::size_t firstLayerIndex, std::size_t secondLayerIndex);
 
  void MoveLayer(std::size_t oldIndex, std::size_t newIndex);
 
  void SerializeLayersTo(SerializerElement& element) const;
 
  void UnserializeLayersFrom(const SerializerElement& element);
 
  void UpdateBehaviorsSharedData(gd::Project& project);
 
  std::vector<gd::String> GetAllBehaviorSharedDataNames() const;
 
  bool HasBehaviorSharedData(const gd::String& behaviorName);
 
  const gd::BehaviorsSharedData& GetBehaviorSharedData(
      const gd::String& behaviorName) const;
 
  gd::BehaviorsSharedData& GetBehaviorSharedData(const gd::String& behaviorName);
 
  const std::map<gd::String, std::unique_ptr<gd::BehaviorsSharedData>>&
  GetAllBehaviorSharedData() const;
 
 
  const gd::EditorSettings& GetAssociatedEditorSettings() const {
    return editorSettings;
  }
 
  gd::EditorSettings& GetAssociatedEditorSettings() {
    return editorSettings;
  }
 
 
  void DisableInputWhenFocusIsLost(bool disable = true) {
    disableInputWhenNotFocused = disable;
  }
 
  bool IsInputDisabledWhenFocusIsLost() { return disableInputWhenNotFocused; }
 
  void SetStandardSortMethod(bool enable = true) {
    standardSortMethod = enable;
  }
 
  bool StandardSortMethod() const { return standardSortMethod; }
 
  void SetStopSoundsOnStartup(bool enable = true) {
    stopSoundsOnStartup = enable;
  }
 
  bool StopSoundsOnStartup() const { return stopSoundsOnStartup; }
 
 
  void SerializeTo(SerializerElement& element) const;
 
  void UnserializeFrom(gd::Project& project, const SerializerElement& element);
 
// TODO: GD C++ Platform specific code below
  BaseProfiler* GetProfiler() const { return profiler; };
 
  void SetProfiler(BaseProfiler* profiler_) { profiler = profiler_; };
 
 private:
  gd::String name;         
  gd::String mangledName;  
  unsigned int backgroundColorR;     
  unsigned int backgroundColorG;     
  unsigned int backgroundColorB;     
  gd::String title;                  
  gd::VariablesContainer variables;  
  gd::InitialInstancesContainer initialInstances;  
  std::vector<gd::Layer> initialLayers;            
  std::map<gd::String, std::unique_ptr<gd::BehaviorsSharedData>>
      behaviorsSharedData;   
  bool stopSoundsOnStartup;  
  bool standardSortMethod;   
  bool disableInputWhenNotFocused;  
  static gd::Layer badLayer;  
  static gd::BehaviorsSharedData
      badBehaviorSharedData;  
 
  EventsList events;  
  gd::EditorSettings editorSettings;
 
// TODO: GD C++ Platform specific code below
 
  BaseProfiler* profiler;  
 
  void Init(const gd::Layout& other);
 
  std::unique_ptr<gd::BehaviorsSharedData> CreateBehaviorsSharedData(
      gd::Project& project,
      const gd::String& name,
      const gd::String& behaviorsType);
};
 
struct LayoutHasName
    : public std::binary_function<std::unique_ptr<Layout>, gd::String, bool> {
  bool operator()(const std::unique_ptr<Layout>& layout,
                  gd::String name) const {
    return layout->GetName() == name;
  }
};
 
std::vector<gd::String> GetHiddenLayers(const Layout& layout);
 
gd::String GD_CORE_API GetTypeOfObject(const ObjectsContainer& game,
                                       const ObjectsContainer& layout,
                                       gd::String objectName,
                                       bool searchInGroups = true);
bool GD_CORE_API HasBehaviorInObjectOrGroup(const gd::ObjectsContainer &project,
                                            const gd::ObjectsContainer &layout,
                                            const gd::String &objectOrGroupName,
                                            const gd::String &behaviorName,
                                            bool searchInGroups = true);
std::vector<gd::String> GD_CORE_API GetBehaviorNamesInObjectOrGroup(
    const gd::ObjectsContainer &project, const gd::ObjectsContainer &layout,
    const gd::String &objectOrGroupName, const gd::String &behaviorType,
    bool searchInGroups);
 
bool GD_CORE_API IsDefaultBehavior(const gd::ObjectsContainer& project,
                                   const gd::ObjectsContainer& layout,
                                   gd::String objectOrGroupName,
                                   gd::String behaviorName,
                                   bool searchInGroups = true);
 
gd::String GD_CORE_API GetTypeOfBehaviorInObjectOrGroup(const gd::ObjectsContainer &project,
                                            const gd::ObjectsContainer &layout,
                                            const gd::String &objectOrGroupName,
                                            const gd::String &behaviorName,
                                            bool searchInGroups = true);
gd::String GD_CORE_API GetTypeOfBehavior(const ObjectsContainer& game,
                                         const ObjectsContainer& layout,
                                         gd::String behaviorName,
                                         bool searchInGroups = true);
 
std::vector<gd::String> GD_CORE_API
GetBehaviorsOfObject(const ObjectsContainer& game,
                     const ObjectsContainer& layout,
                     const gd::String& objectName,
                     bool searchInGroups = true);
 
}  // namespace gd
 
typedef gd::Layout Scene;
 
#endif  // GDCORE_LAYOUT_H