PropertyDescriptor.h

/*
 * GDevelop Core
 * Copyright 2008-present Florian Rival ([email protected]). All rights
 * reserved. This project is released under the MIT License.
 */
#ifndef GDCORE_PROPERTYDESCRIPTOR
#define GDCORE_PROPERTYDESCRIPTOR
#include <vector>
 
#include "GDCore/Project/MeasurementUnit.h"
#include "GDCore/Project/QuickCustomization.h"
#include "GDCore/String.h"
 
namespace gd {
class SerializerElement;
}
 
namespace gd {
 
class GD_CORE_API PropertyDescriptorChoice {
 public:
  PropertyDescriptorChoice(const gd::String& value, const gd::String& label)
      : value(value), label(label) {}
 
  const gd::String& GetValue() const { return value; }
  const gd::String& GetLabel() const { return label; }
 
 private:
  gd::String value;
  gd::String label;
};
 
class GD_CORE_API PropertyDescriptor {
 public:
  PropertyDescriptor(gd::String propertyValue)
      : currentValue(propertyValue),
        type("string"),
        label(""),
        hidden(false),
        deprecated(false),
        advanced(false),
        hasImpactOnOtherProperties(false),
        measurementUnit(gd::MeasurementUnit::GetUndefined()),
        quickCustomizationVisibility(QuickCustomization::Visibility::Default) {}
 
  PropertyDescriptor()
      : hidden(false),
        deprecated(false),
        advanced(false),
        hasImpactOnOtherProperties(false),
        measurementUnit(gd::MeasurementUnit::GetUndefined()),
        quickCustomizationVisibility(QuickCustomization::Visibility::Default) {
        };
 
  virtual ~PropertyDescriptor();
 
  PropertyDescriptor& SetValue(gd::String value) {
    currentValue = value;
    return *this;
  }
 
  PropertyDescriptor& SetType(gd::String type_) {
    type = type_;
    return *this;
  }
 
  PropertyDescriptor& SetLabel(gd::String label_) {
    label = label_;
    return *this;
  }
 
  PropertyDescriptor& SetDescription(gd::String description_) {
    description = description_;
    return *this;
  }
 
  PropertyDescriptor& SetGroup(gd::String group_) {
    group = group_;
    return *this;
  }
 
  PropertyDescriptor& AddChoice(const gd::String& value,
                                const gd::String& label) {
    choices.push_back(PropertyDescriptorChoice(value, label));
    return *this;
  }
 
  PropertyDescriptor& SetExtraInfo(const std::vector<gd::String>& info) {
    extraInformation = info;
    return *this;
  }
 
  PropertyDescriptor& AddExtraInfo(const gd::String& info) {
    extraInformation.push_back(info);
    return *this;
  }
 
  PropertyDescriptor& SetMeasurementUnit(
      const gd::MeasurementUnit& measurementUnit_) {
    measurementUnit = measurementUnit_;
    return *this;
  }
 
  const gd::String& GetValue() const { return currentValue; }
  const gd::String& GetType() const { return type; }
  const gd::String& GetLabel() const { return label; }
  const gd::String& GetDescription() const { return description; }
  const gd::String& GetGroup() const { return group; }
  const gd::MeasurementUnit& GetMeasurementUnit() const {
    return measurementUnit;
  }
 
  const std::vector<gd::String>& GetExtraInfo() const {
    return extraInformation;
  }
 
  std::vector<gd::String>& GetExtraInfo() { return extraInformation; }
 
  const std::vector<PropertyDescriptorChoice>& GetChoices() const {
    return choices;
  }
 
  PropertyDescriptor& SetHidden(bool enable = true) {
    hidden = enable;
    return *this;
  }
 
  bool IsHidden() const { return hidden; }
 
  PropertyDescriptor& SetDeprecated(bool enable = true) {
    deprecated = enable;
    return *this;
  }
 
  bool IsDeprecated() const { return deprecated; }
 
  PropertyDescriptor& SetAdvanced(bool enable = true) {
    advanced = enable;
    return *this;
  }
 
  bool IsAdvanced() const { return advanced; }
 
  bool HasImpactOnOtherProperties() const { return hasImpactOnOtherProperties; }
 
  PropertyDescriptor& SetHasImpactOnOtherProperties(bool enable) {
    hasImpactOnOtherProperties = enable;
    return *this;
  }
 
  QuickCustomization::Visibility GetQuickCustomizationVisibility() const {
    return quickCustomizationVisibility;
  }
 
  PropertyDescriptor& SetQuickCustomizationVisibility(
      QuickCustomization::Visibility visibility) {
    quickCustomizationVisibility = visibility;
    return *this;
  }
 
 
  virtual void SerializeTo(SerializerElement& element) const;
 
  virtual void UnserializeFrom(const SerializerElement& element);
 
  virtual void SerializeValuesTo(SerializerElement& element) const;
 
  virtual void UnserializeValuesFrom(const SerializerElement& element);
 
 private:
  gd::String currentValue;  
  gd::String
      type;  
  gd::String label;        //< The user-friendly property name
  gd::String description;  //< The user-friendly property description
  gd::String group;        //< The user-friendly property group
  std::vector<PropertyDescriptorChoice>
      choices;  //< The optional choices for the property.
  std::vector<gd::String>
      extraInformation;  
  bool hidden;
  bool deprecated;
  bool advanced;
  bool hasImpactOnOtherProperties;
  gd::MeasurementUnit
      measurementUnit;  //< The unit of measurement of the property vale.
  QuickCustomization::Visibility quickCustomizationVisibility;
};
 
}  // namespace gd
 
#endif