EventsBasedObject.h

/*
 * GDevelop Core
 * Copyright 2008-2016 Florian Rival ([email protected]). All rights
 * reserved. This project is released under the MIT License.
 */
#pragma once
 
#include <vector>
#include "GDCore/Project/AbstractEventsBasedEntity.h"
#include "GDCore/Project/ObjectsContainer.h"
#include "GDCore/Project/InitialInstancesContainer.h"
#include "GDCore/Project/LayersContainer.h"
#include "GDCore/String.h"
namespace gd {
class SerializerElement;
class Project;
}  // namespace gd
 
namespace gd {
// TODO EBO Add a way to mark some parts of children configuration as readonly.
class GD_CORE_API EventsBasedObject: public AbstractEventsBasedEntity {
 public:
  EventsBasedObject();
  virtual ~EventsBasedObject();
 
  EventsBasedObject* Clone() const { return new EventsBasedObject(*this); };
 
  const gd::String& GetDefaultName() const { return defaultName; };
 
  EventsBasedObject& SetDefaultName(const gd::String& defaultName_) {
    defaultName = defaultName_;
    return *this;
  }
 
  EventsBasedObject& SetDescription(const gd::String& description_) override {
    AbstractEventsBasedEntity::SetDescription(description_);
    return *this;
  }
 
  EventsBasedObject& SetName(const gd::String& name_) {
    AbstractEventsBasedEntity::SetName(name_);
    return *this;
  }
 
  EventsBasedObject& SetFullName(const gd::String& fullName_) {
    AbstractEventsBasedEntity::SetFullName(fullName_);
    return *this;
  }
 
  EventsBasedObject& MarkAsRenderedIn3D(bool isRenderedIn3D_) {
    isRenderedIn3D = isRenderedIn3D_;
    return *this;
  }
 
  bool IsRenderedIn3D() const { return isRenderedIn3D; }
 
  EventsBasedObject& MarkAsAnimatable(bool isAnimatable_) {
    isAnimatable = isAnimatable_;
    return *this;
  }
 
  bool IsAnimatable() const { return isAnimatable; }
 
  EventsBasedObject &MarkAsTextContainer(bool isTextContainer_) {
    isTextContainer = isTextContainer_;
    return *this;
  }
 
  EventsBasedObject &
  MarkAsInnerAreaFollowingParentSize(bool isInnerAreaExpandingWithParent_) {
    isInnerAreaFollowingParentSize = isInnerAreaExpandingWithParent_;
    return *this;
  }
 
  bool IsInnerAreaFollowingParentSize() const {
    return isInnerAreaFollowingParentSize;
  }
 
  EventsBasedObject &
  MakAsUsingLegacyInstancesRenderer(bool isUsingLegacyInstancesRenderer_) {
    isUsingLegacyInstancesRenderer = isUsingLegacyInstancesRenderer_;
    return *this;
  }
 
  bool IsUsingLegacyInstancesRenderer() const {
    return isUsingLegacyInstancesRenderer;
  }
 
  bool IsTextContainer() const { return isTextContainer; }
 
 
  const gd::LayersContainer& GetLayers() const { return layers; }
 
  gd::LayersContainer& GetLayers() { return layers; }
 
 
  gd::ObjectsContainer& GetObjects() {
    return objectsContainer;
  }
 
  const gd::ObjectsContainer& GetObjects() const {
    return objectsContainer;
  }
 
 
  gd::InitialInstancesContainer& GetInitialInstances() {
    return initialInstances;
  }
 
  const gd::InitialInstancesContainer& GetInitialInstances() const {
    return initialInstances;
  }
 
  int GetAreaMinX() const {
    return areaMinX;
  }
 
  void SetAreaMinX(int areaMinX_) {
    areaMinX = areaMinX_;
  }
 
  int GetAreaMinY() const {
    return areaMinY;
  }
 
  void SetAreaMinY(int areaMinY_) {
    areaMinY = areaMinY_;
  }
 
  int GetAreaMinZ() const {
    return areaMinZ;
  }
 
  void SetAreaMinZ(int areaMinZ_) {
    areaMinZ = areaMinZ_;
  }
 
  int GetAreaMaxX() const {
    return areaMaxX;
  }
 
  void SetAreaMaxX(int areaMaxX_) {
    areaMaxX = areaMaxX_;
  }
 
  int GetAreaMaxY() const {
    return areaMaxY;
  }
 
  void SetAreaMaxY(int areaMaxY_) {
    areaMaxY = areaMaxY_;
  }
 
  int GetAreaMaxZ() const {
    return areaMaxZ;
  }
 
  void SetAreaMaxZ(int areaMaxZ_) {
    areaMaxZ = areaMaxZ_;
  }
 
  void SerializeTo(SerializerElement& element) const override;
 
  void UnserializeFrom(gd::Project& project,
                       const SerializerElement& element) override;
 
 private:
  gd::String defaultName;
  bool isRenderedIn3D;
  bool isAnimatable;
  bool isTextContainer;
  bool isInnerAreaFollowingParentSize;
  bool isUsingLegacyInstancesRenderer;
  gd::InitialInstancesContainer initialInstances;
  gd::LayersContainer layers;
  gd::ObjectsContainer objectsContainer;
  double areaMinX;
  double areaMinY;
  double areaMinZ;
  double areaMaxX;
  double areaMaxY;
  double areaMaxZ;
};
 
}  // namespace gd