InitialInstance.h

/*
 * GDevelop Core
 * Copyright 2008-2016 Florian Rival ([email protected]). All rights
 * reserved. This project is released under the MIT License.
 */
 
#pragma once
 
#include <map>
 
#include "GDCore/Project/VariablesContainer.h"
#include "GDCore/Project/BehaviorsContainer.h"
#include "GDCore/String.h"
namespace gd {
class PropertyDescriptor;
class Project;
class Layout;
class ObjectsContainer;
class Object;
class Behavior;
}  // namespace gd
 
namespace gd {
 
class GD_CORE_API InitialInstance {
 public:
  InitialInstance();
  virtual ~InitialInstance() {};
 
  InitialInstance* Clone() const { return new InitialInstance(*this); }
 
 
  const gd::String& GetObjectName() const { return objectName; }
 
  void SetObjectName(const gd::String& name) { objectName = name; }
 
  double GetX() const { return x; }
 
  void SetX(double x_) { x = x_; }
 
  double GetY() const { return y; }
 
  void SetY(double y_) { y = y_; }
 
  double GetZ() const { return z; }
 
  void SetZ(double z_) { z = z_; }
 
  double GetAngle() const { return angle; }
 
  void SetAngle(double angle_) { angle = angle_; }
 
  double GetRotationX() const { return rotationX; }
 
  void SetRotationX(double rotationX_) { rotationX = rotationX_; }
 
  double GetRotationY() const { return rotationY; }
 
  void SetRotationY(double rotationY_) { rotationY = rotationY_; }
 
  int GetZOrder() const { return zOrder; }
 
  void SetZOrder(int zOrder_) { zOrder = zOrder_; }
 
  int GetOpacity() const { return opacity; }
 
  void SetOpacity(int opacity_) { opacity = opacity_; }
 
  bool IsFlippedX() const { return flippedX; }
 
  void SetFlippedX(bool flippedX_) { flippedX = flippedX_; }
 
  bool IsFlippedY() const { return flippedY; }
 
  void SetFlippedY(bool flippedY_) { flippedY = flippedY_; }
 
  bool IsFlippedZ() const { return flippedZ; }
 
  void SetFlippedZ(bool flippedZ_) { flippedZ = flippedZ_; }
 
  const gd::String& GetLayer() const { return layer; }
 
  void SetLayer(const gd::String& layer_) { layer = layer_; }
 
  bool HasCustomSize() const { return customSize; }
 
  bool HasCustomDepth() const { return customDepth; }
 
  void SetHasCustomSize(bool hasCustomSize_) { customSize = hasCustomSize_; }
 
  void SetHasCustomDepth(bool hasCustomDepth_) {
    customDepth = hasCustomDepth_;
  }
 
  double GetCustomWidth() const { return width; }
  void SetCustomWidth(double width_) { width = width_; }
  double GetCustomHeight() const { return height; }
  void SetCustomHeight(double height_) { height = height_; }
  double GetCustomDepth() const { return depth; }
  void SetCustomDepth(double depth_) { depth = depth_; }
 
  double GetDefaultWidth() const { return defaultWidth; }
  double GetDefaultHeight() const { return defaultHeight; }
  double GetDefaultDepth() const { return defaultDepth; }
  void SetDefaultWidth(double width_) { defaultWidth = width_; }
  void SetDefaultHeight(double height_) { defaultHeight = height_; }
  void SetDefaultDepth(double depth_) { defaultDepth = depth_; }
 
  bool IsLocked() const { return locked; };
 
  void SetLocked(bool enable = true) { locked = enable; }
 
  bool IsSealed() const { return sealed; };
 
  void SetSealed(bool enable = true) { sealed = enable; }
 
  bool ShouldKeepRatio() const { return keepRatio; };
 
  void SetShouldKeepRatio(bool enable = true) { keepRatio = enable; }
 
  bool IsHidden() const { return hidden; };
 
  void SetHidden(bool enable = true) { hidden = enable; }
 
 
 
  const gd::VariablesContainer& GetVariables() const {
    return initialVariables;
  }
 
  gd::VariablesContainer& GetVariables() { return initialVariables; }
 
 
  bool HasAnyOverriddenProperty(const gd::Object &object);
 
  bool HasAnyOverriddenPropertyForBehavior(const gd::Behavior &behavior);
 
  Behavior &GetBehaviorOverriding(const gd::String &name);
 
  const Behavior &GetBehaviorOverriding(const gd::String &name) const;
 
  bool HasBehaviorOverridingNamed(const gd::String &name) const;
 
  void RemoveBehaviorOverriding(const gd::String &name);
 
  bool RenameBehaviorOverriding(const gd::String &name,
                                const gd::String &newName);
 
  gd::Behavior *AddNewBehaviorOverriding(const gd::Project &project,
                                         const gd::String &type,
                                         const gd::String &name);
 
 
  std::map<gd::String, gd::PropertyDescriptor> GetCustomProperties(
      gd::ObjectsContainer& globalObjectsContainer,
      gd::ObjectsContainer& objectsContainer);
 
  bool UpdateCustomProperty(const gd::String& name,
                            const gd::String& value,
                            gd::ObjectsContainer& globalObjectsContainer,
                            gd::ObjectsContainer& objectsContainer);
 
  double GetRawDoubleProperty(const gd::String& name) const;
 
  const gd::String& GetRawStringProperty(const gd::String& name) const;
 
  void SetRawDoubleProperty(const gd::String& name, double value);
 
  void SetRawStringProperty(const gd::String& name, const gd::String& value);
 
 
  virtual void SerializeTo(SerializerElement& element) const;
 
  virtual void UnserializeFrom(gd::Project &project,
                               const SerializerElement &element);
 
  InitialInstance& ResetPersistentUuid();
 
  const gd::String& GetPersistentUuid() const { return persistentUuid; }
 
 private:
  // More properties can be stored in numberProperties and stringProperties.
  // These properties are then managed by the Object class.
  std::map<gd::String, double>
      numberProperties;  
  std::map<gd::String, gd::String>
      stringProperties;  
 
  gd::String objectName;    
  double x = 0;             
  double y = 0;             
  double z = 0;             
  double angle = 0;         
  double rotationX = 0;     
  double rotationY = 0;     
  int zOrder = 0;           
  int opacity = 255;        
  bool flippedX = false;    
  bool flippedY = false;    
  bool flippedZ = false;    
  gd::String layer;         
  bool customSize = false;  
  bool customDepth = false; 
  double width = 0;         
  double height = 0;        
  double depth = 0;         
  double defaultWidth = 0;  
  double defaultHeight = 0; 
  double defaultDepth = 0;  
  gd::VariablesContainer initialVariables;  
  gd::BehaviorsContainer
      behaviorOverridings; 
  bool locked = false;     
  bool sealed = false;     
  bool keepRatio = true;   
  bool hidden = false;     
  mutable gd::String persistentUuid;  
 
  static gd::String* badStringPropertyValue;  
};
 
}  // namespace gd