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/String.h"
namespace gd {
class PropertyDescriptor;
class Project;
class Layout;
class ObjectsContainer;
}  // 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; }
 
 
 
  const gd::VariablesContainer& GetVariables() const {
    return initialVariables;
  }
 
  gd::VariablesContainer& GetVariables() { return initialVariables; }
 
 
  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(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;               
  double y;               
  double z;               
  double angle;           
  double rotationX;       
  double rotationY;       
  int zOrder;             
  int opacity;            
  bool flippedX;          
  bool flippedY;          
  bool flippedZ;          
  gd::String layer;       
  bool customSize;        
  bool customDepth;       
  double width;           
  double height;          
  double depth;           
  double defaultWidth = 0;  
  double defaultHeight = 0; 
  double defaultDepth = 0;  
  gd::VariablesContainer initialVariables;  
  bool locked;                              
  bool sealed;                              
  bool keepRatio;                     
  mutable gd::String persistentUuid;  
 
  static gd::String* badStringPropertyValue;  
};
 
}  // namespace gd