OOPClasses/Protos/gtx.pb.h

// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: gtx.proto

#ifndef GOOGLE_PROTOBUF_INCLUDED_gtx_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_gtx_2eproto

#include <limits>
#include <string>

#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3013000
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers. Please update
#error your headers.
#endif
#if 3013000 < PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers. Please
#error regenerate this file with a newer version of protoc.
#endif

#include <google/protobuf/port_undef.inc>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_table_driven.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/inlined_string_field.h>
#include <google/protobuf/metadata_lite.h>
#include <google/protobuf/generated_message_reflection.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
#include <google/protobuf/extension_set.h>  // IWYU pragma: export
#include <google/protobuf/generated_enum_reflection.h>
#include <google/protobuf/unknown_field_set.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_gtx_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_gtx_2eproto {
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[5]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
  static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_gtx_2eproto;
namespace gtxilib {
namespace oopclasses {
namespace protos {
class ElementType;
class ElementTypeDefaultTypeInternal;
extern ElementTypeDefaultTypeInternal _ElementType_default_instance_;
class Point;
class PointDefaultTypeInternal;
extern PointDefaultTypeInternal _Point_default_instance_;
class Rect;
class RectDefaultTypeInternal;
extern RectDefaultTypeInternal _Rect_default_instance_;
class Size;
class SizeDefaultTypeInternal;
extern SizeDefaultTypeInternal _Size_default_instance_;
class UIElement;
class UIElementDefaultTypeInternal;
extern UIElementDefaultTypeInternal _UIElement_default_instance_;
}  // namespace protos
}  // namespace oopclasses
}  // namespace gtxilib
PROTOBUF_NAMESPACE_OPEN
template<> ::gtxilib::oopclasses::protos::ElementType* Arena::CreateMaybeMessage<::gtxilib::oopclasses::protos::ElementType>(Arena*);
template<> ::gtxilib::oopclasses::protos::Point* Arena::CreateMaybeMessage<::gtxilib::oopclasses::protos::Point>(Arena*);
template<> ::gtxilib::oopclasses::protos::Rect* Arena::CreateMaybeMessage<::gtxilib::oopclasses::protos::Rect>(Arena*);
template<> ::gtxilib::oopclasses::protos::Size* Arena::CreateMaybeMessage<::gtxilib::oopclasses::protos::Size>(Arena*);
template<> ::gtxilib::oopclasses::protos::UIElement* Arena::CreateMaybeMessage<::gtxilib::oopclasses::protos::UIElement>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace gtxilib {
namespace oopclasses {
namespace protos {

enum ElementType_ElementTypeEnum : int {
  ElementType_ElementTypeEnum_ANY = 0,
  ElementType_ElementTypeEnum_OTHER = 1,
  ElementType_ElementTypeEnum_APPLICATION = 2,
  ElementType_ElementTypeEnum_GROUP = 3,
  ElementType_ElementTypeEnum_WINDOW = 4,
  ElementType_ElementTypeEnum_SHEET = 5,
  ElementType_ElementTypeEnum_DRAWER = 6,
  ElementType_ElementTypeEnum_ALERT = 7,
  ElementType_ElementTypeEnum_DIALOG = 8,
  ElementType_ElementTypeEnum_BUTTON = 9,
  ElementType_ElementTypeEnum_RADIO_BUTTON = 10,
  ElementType_ElementTypeEnum_RADIO_GROUP = 11,
  ElementType_ElementTypeEnum_CHECK_BOX = 12,
  ElementType_ElementTypeEnum_DISCLOSURE_TRIANGLE = 13,
  ElementType_ElementTypeEnum_POP_UP_BUTTON = 14,
  ElementType_ElementTypeEnum_COMBO_BOX = 15,
  ElementType_ElementTypeEnum_MENU_BUTTON = 16,
  ElementType_ElementTypeEnum_TOOLBAR_BUTTON = 17,
  ElementType_ElementTypeEnum_POPOVER = 18,
  ElementType_ElementTypeEnum_KEYBOARD = 19,
  ElementType_ElementTypeEnum_KEY = 20,
  ElementType_ElementTypeEnum_NAVIGATION_BAR = 21,
  ElementType_ElementTypeEnum_TAB_BAR = 22,
  ElementType_ElementTypeEnum_TAB_GROUP = 23,
  ElementType_ElementTypeEnum_TOOLBAR = 24,
  ElementType_ElementTypeEnum_STATUS_BAR = 25,
  ElementType_ElementTypeEnum_TABLE = 26,
  ElementType_ElementTypeEnum_TABLE_ROW = 27,
  ElementType_ElementTypeEnum_TABLE_COLUMN = 28,
  ElementType_ElementTypeEnum_OUTLINE = 29,
  ElementType_ElementTypeEnum_OUTLINE_ROW = 30,
  ElementType_ElementTypeEnum_BROWSER = 31,
  ElementType_ElementTypeEnum_COLLECTION_VIEW = 32,
  ElementType_ElementTypeEnum_SLIDER = 33,
  ElementType_ElementTypeEnum_PAGE_INDICATOR = 34,
  ElementType_ElementTypeEnum_PROGRESS_INDICATOR = 35,
  ElementType_ElementTypeEnum_ACTIVITY_INDICATOR = 36,
  ElementType_ElementTypeEnum_SEGMENTED_CONTROL = 37,
  ElementType_ElementTypeEnum_PICKER = 38,
  ElementType_ElementTypeEnum_PICKER_WHEEL = 39,
  ElementType_ElementTypeEnum_SWITCH = 40,
  ElementType_ElementTypeEnum_TOGGLE = 41,
  ElementType_ElementTypeEnum_LINK = 42,
  ElementType_ElementTypeEnum_IMAGE = 43,
  ElementType_ElementTypeEnum_ICON = 44,
  ElementType_ElementTypeEnum_SEARCH_FIELD = 45,
  ElementType_ElementTypeEnum_SCROLL_VIEW = 46,
  ElementType_ElementTypeEnum_SCROLL_BAR = 47,
  ElementType_ElementTypeEnum_STATIC_TEXT = 48,
  ElementType_ElementTypeEnum_TEXT_FIELD = 49,
  ElementType_ElementTypeEnum_SECURE_TEXT_FIELD = 50,
  ElementType_ElementTypeEnum_DATE_PICKER = 51,
  ElementType_ElementTypeEnum_TEXT_VIEW = 52,
  ElementType_ElementTypeEnum_MENU = 53,
  ElementType_ElementTypeEnum_MENU_ITEM = 54,
  ElementType_ElementTypeEnum_MENU_BAR = 55,
  ElementType_ElementTypeEnum_MENU_BAR_ITEM = 56,
  ElementType_ElementTypeEnum_MAP = 57,
  ElementType_ElementTypeEnum_WEB_VIEW = 58,
  ElementType_ElementTypeEnum_INCREMENT_ARROW = 59,
  ElementType_ElementTypeEnum_DECREMENT_ARROW = 60,
  ElementType_ElementTypeEnum_TIMELINE = 61,
  ElementType_ElementTypeEnum_RATING_INDICATOR = 62,
  ElementType_ElementTypeEnum_VALUE_INDICATOR = 63,
  ElementType_ElementTypeEnum_SPLIT_GROUP = 64,
  ElementType_ElementTypeEnum_SPLITTER = 65,
  ElementType_ElementTypeEnum_RELEVANCE_INDICATOR = 66,
  ElementType_ElementTypeEnum_COLOR_WELL = 67,
  ElementType_ElementTypeEnum_HELP_TAG = 68,
  ElementType_ElementTypeEnum_MATTE = 69,
  ElementType_ElementTypeEnum_DOCK_ITEM = 70,
  ElementType_ElementTypeEnum_RULER = 71,
  ElementType_ElementTypeEnum_RULER_MARKER = 72,
  ElementType_ElementTypeEnum_GRID = 73,
  ElementType_ElementTypeEnum_LEVEL_INDICATOR = 74,
  ElementType_ElementTypeEnum_CELL = 75,
  ElementType_ElementTypeEnum_LAYOUT_AREA = 76,
  ElementType_ElementTypeEnum_LAYOUT_ITEM = 77,
  ElementType_ElementTypeEnum_HANDLE = 78,
  ElementType_ElementTypeEnum_STEPPER = 79,
  ElementType_ElementTypeEnum_TAB = 80,
  ElementType_ElementTypeEnum_TOUCH_BAR = 81,
  ElementType_ElementTypeEnum_STATUS_ITEM = 82,
  ElementType_ElementTypeEnum_ElementType_ElementTypeEnum_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  ElementType_ElementTypeEnum_ElementType_ElementTypeEnum_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool ElementType_ElementTypeEnum_IsValid(int value);
constexpr ElementType_ElementTypeEnum ElementType_ElementTypeEnum_ElementTypeEnum_MIN = ElementType_ElementTypeEnum_ANY;
constexpr ElementType_ElementTypeEnum ElementType_ElementTypeEnum_ElementTypeEnum_MAX = ElementType_ElementTypeEnum_STATUS_ITEM;
constexpr int ElementType_ElementTypeEnum_ElementTypeEnum_ARRAYSIZE = ElementType_ElementTypeEnum_ElementTypeEnum_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ElementType_ElementTypeEnum_descriptor();
template<typename T>
inline const std::string& ElementType_ElementTypeEnum_Name(T enum_t_value) {
  static_assert(::std::is_same<T, ElementType_ElementTypeEnum>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function ElementType_ElementTypeEnum_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    ElementType_ElementTypeEnum_descriptor(), enum_t_value);
}
inline bool ElementType_ElementTypeEnum_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ElementType_ElementTypeEnum* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ElementType_ElementTypeEnum>(
    ElementType_ElementTypeEnum_descriptor(), name, value);
}
// ===================================================================

class Point PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:gtxilib.oopclasses.protos.Point) */ {
 public:
  inline Point() : Point(nullptr) {}
  virtual ~Point();

  Point(const Point& from);
  Point(Point&& from) noexcept
    : Point() {
    *this = ::std::move(from);
  }

  inline Point& operator=(const Point& from) {
    CopyFrom(from);
    return *this;
  }
  inline Point& operator=(Point&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const Point& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const Point* internal_default_instance() {
    return reinterpret_cast<const Point*>(
               &_Point_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;

  friend void swap(Point& a, Point& b) {
    a.Swap(&b);
  }
  inline void Swap(Point* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Point* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline Point* New() const final {
    return CreateMaybeMessage<Point>(nullptr);
  }

  Point* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<Point>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const Point& from);
  void MergeFrom(const Point& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Point* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "gtxilib.oopclasses.protos.Point";
  }
  protected:
  explicit Point(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_gtx_2eproto);
    return ::descriptor_table_gtx_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kXFieldNumber = 1,
    kYFieldNumber = 2,
  };
  // float x = 1;
  void clear_x();
  float x() const;
  void set_x(float value);
  private:
  float _internal_x() const;
  void _internal_set_x(float value);
  public:

  // float y = 2;
  void clear_y();
  float y() const;
  void set_y(float value);
  private:
  float _internal_y() const;
  void _internal_set_y(float value);
  public:

  // @@protoc_insertion_point(class_scope:gtxilib.oopclasses.protos.Point)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  float x_;
  float y_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_gtx_2eproto;
};
// -------------------------------------------------------------------

class Size PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:gtxilib.oopclasses.protos.Size) */ {
 public:
  inline Size() : Size(nullptr) {}
  virtual ~Size();

  Size(const Size& from);
  Size(Size&& from) noexcept
    : Size() {
    *this = ::std::move(from);
  }

  inline Size& operator=(const Size& from) {
    CopyFrom(from);
    return *this;
  }
  inline Size& operator=(Size&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const Size& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const Size* internal_default_instance() {
    return reinterpret_cast<const Size*>(
               &_Size_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;

  friend void swap(Size& a, Size& b) {
    a.Swap(&b);
  }
  inline void Swap(Size* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Size* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline Size* New() const final {
    return CreateMaybeMessage<Size>(nullptr);
  }

  Size* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<Size>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const Size& from);
  void MergeFrom(const Size& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Size* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "gtxilib.oopclasses.protos.Size";
  }
  protected:
  explicit Size(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_gtx_2eproto);
    return ::descriptor_table_gtx_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kWidthFieldNumber = 1,
    kHeightFieldNumber = 2,
  };
  // float width = 1;
  void clear_width();
  float width() const;
  void set_width(float value);
  private:
  float _internal_width() const;
  void _internal_set_width(float value);
  public:

  // float height = 2;
  void clear_height();
  float height() const;
  void set_height(float value);
  private:
  float _internal_height() const;
  void _internal_set_height(float value);
  public:

  // @@protoc_insertion_point(class_scope:gtxilib.oopclasses.protos.Size)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  float width_;
  float height_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_gtx_2eproto;
};
// -------------------------------------------------------------------

class Rect PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:gtxilib.oopclasses.protos.Rect) */ {
 public:
  inline Rect() : Rect(nullptr) {}
  virtual ~Rect();

  Rect(const Rect& from);
  Rect(Rect&& from) noexcept
    : Rect() {
    *this = ::std::move(from);
  }

  inline Rect& operator=(const Rect& from) {
    CopyFrom(from);
    return *this;
  }
  inline Rect& operator=(Rect&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const Rect& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const Rect* internal_default_instance() {
    return reinterpret_cast<const Rect*>(
               &_Rect_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;

  friend void swap(Rect& a, Rect& b) {
    a.Swap(&b);
  }
  inline void Swap(Rect* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Rect* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline Rect* New() const final {
    return CreateMaybeMessage<Rect>(nullptr);
  }

  Rect* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<Rect>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const Rect& from);
  void MergeFrom(const Rect& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Rect* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "gtxilib.oopclasses.protos.Rect";
  }
  protected:
  explicit Rect(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_gtx_2eproto);
    return ::descriptor_table_gtx_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kOriginFieldNumber = 1,
    kSizeFieldNumber = 2,
  };
  // .gtxilib.oopclasses.protos.Point origin = 1;
  bool has_origin() const;
  private:
  bool _internal_has_origin() const;
  public:
  void clear_origin();
  const ::gtxilib::oopclasses::protos::Point& origin() const;
  ::gtxilib::oopclasses::protos::Point* release_origin();
  ::gtxilib::oopclasses::protos::Point* mutable_origin();
  void set_allocated_origin(::gtxilib::oopclasses::protos::Point* origin);
  private:
  const ::gtxilib::oopclasses::protos::Point& _internal_origin() const;
  ::gtxilib::oopclasses::protos::Point* _internal_mutable_origin();
  public:
  void unsafe_arena_set_allocated_origin(
      ::gtxilib::oopclasses::protos::Point* origin);
  ::gtxilib::oopclasses::protos::Point* unsafe_arena_release_origin();

  // .gtxilib.oopclasses.protos.Size size = 2;
  bool has_size() const;
  private:
  bool _internal_has_size() const;
  public:
  void clear_size();
  const ::gtxilib::oopclasses::protos::Size& size() const;
  ::gtxilib::oopclasses::protos::Size* release_size();
  ::gtxilib::oopclasses::protos::Size* mutable_size();
  void set_allocated_size(::gtxilib::oopclasses::protos::Size* size);
  private:
  const ::gtxilib::oopclasses::protos::Size& _internal_size() const;
  ::gtxilib::oopclasses::protos::Size* _internal_mutable_size();
  public:
  void unsafe_arena_set_allocated_size(
      ::gtxilib::oopclasses::protos::Size* size);
  ::gtxilib::oopclasses::protos::Size* unsafe_arena_release_size();

  // @@protoc_insertion_point(class_scope:gtxilib.oopclasses.protos.Rect)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::gtxilib::oopclasses::protos::Point* origin_;
  ::gtxilib::oopclasses::protos::Size* size_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_gtx_2eproto;
};
// -------------------------------------------------------------------

class ElementType PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:gtxilib.oopclasses.protos.ElementType) */ {
 public:
  inline ElementType() : ElementType(nullptr) {}
  virtual ~ElementType();

  ElementType(const ElementType& from);
  ElementType(ElementType&& from) noexcept
    : ElementType() {
    *this = ::std::move(from);
  }

  inline ElementType& operator=(const ElementType& from) {
    CopyFrom(from);
    return *this;
  }
  inline ElementType& operator=(ElementType&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const ElementType& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const ElementType* internal_default_instance() {
    return reinterpret_cast<const ElementType*>(
               &_ElementType_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    3;

  friend void swap(ElementType& a, ElementType& b) {
    a.Swap(&b);
  }
  inline void Swap(ElementType* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ElementType* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline ElementType* New() const final {
    return CreateMaybeMessage<ElementType>(nullptr);
  }

  ElementType* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<ElementType>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const ElementType& from);
  void MergeFrom(const ElementType& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ElementType* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "gtxilib.oopclasses.protos.ElementType";
  }
  protected:
  explicit ElementType(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_gtx_2eproto);
    return ::descriptor_table_gtx_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  typedef ElementType_ElementTypeEnum ElementTypeEnum;
  static constexpr ElementTypeEnum ANY =
    ElementType_ElementTypeEnum_ANY;
  static constexpr ElementTypeEnum OTHER =
    ElementType_ElementTypeEnum_OTHER;
  static constexpr ElementTypeEnum APPLICATION =
    ElementType_ElementTypeEnum_APPLICATION;
  static constexpr ElementTypeEnum GROUP =
    ElementType_ElementTypeEnum_GROUP;
  static constexpr ElementTypeEnum WINDOW =
    ElementType_ElementTypeEnum_WINDOW;
  static constexpr ElementTypeEnum SHEET =
    ElementType_ElementTypeEnum_SHEET;
  static constexpr ElementTypeEnum DRAWER =
    ElementType_ElementTypeEnum_DRAWER;
  static constexpr ElementTypeEnum ALERT =
    ElementType_ElementTypeEnum_ALERT;
  static constexpr ElementTypeEnum DIALOG =
    ElementType_ElementTypeEnum_DIALOG;
  static constexpr ElementTypeEnum BUTTON =
    ElementType_ElementTypeEnum_BUTTON;
  static constexpr ElementTypeEnum RADIO_BUTTON =
    ElementType_ElementTypeEnum_RADIO_BUTTON;
  static constexpr ElementTypeEnum RADIO_GROUP =
    ElementType_ElementTypeEnum_RADIO_GROUP;
  static constexpr ElementTypeEnum CHECK_BOX =
    ElementType_ElementTypeEnum_CHECK_BOX;
  static constexpr ElementTypeEnum DISCLOSURE_TRIANGLE =
    ElementType_ElementTypeEnum_DISCLOSURE_TRIANGLE;
  static constexpr ElementTypeEnum POP_UP_BUTTON =
    ElementType_ElementTypeEnum_POP_UP_BUTTON;
  static constexpr ElementTypeEnum COMBO_BOX =
    ElementType_ElementTypeEnum_COMBO_BOX;
  static constexpr ElementTypeEnum MENU_BUTTON =
    ElementType_ElementTypeEnum_MENU_BUTTON;
  static constexpr ElementTypeEnum TOOLBAR_BUTTON =
    ElementType_ElementTypeEnum_TOOLBAR_BUTTON;
  static constexpr ElementTypeEnum POPOVER =
    ElementType_ElementTypeEnum_POPOVER;
  static constexpr ElementTypeEnum KEYBOARD =
    ElementType_ElementTypeEnum_KEYBOARD;
  static constexpr ElementTypeEnum KEY =
    ElementType_ElementTypeEnum_KEY;
  static constexpr ElementTypeEnum NAVIGATION_BAR =
    ElementType_ElementTypeEnum_NAVIGATION_BAR;
  static constexpr ElementTypeEnum TAB_BAR =
    ElementType_ElementTypeEnum_TAB_BAR;
  static constexpr ElementTypeEnum TAB_GROUP =
    ElementType_ElementTypeEnum_TAB_GROUP;
  static constexpr ElementTypeEnum TOOLBAR =
    ElementType_ElementTypeEnum_TOOLBAR;
  static constexpr ElementTypeEnum STATUS_BAR =
    ElementType_ElementTypeEnum_STATUS_BAR;
  static constexpr ElementTypeEnum TABLE =
    ElementType_ElementTypeEnum_TABLE;
  static constexpr ElementTypeEnum TABLE_ROW =
    ElementType_ElementTypeEnum_TABLE_ROW;
  static constexpr ElementTypeEnum TABLE_COLUMN =
    ElementType_ElementTypeEnum_TABLE_COLUMN;
  static constexpr ElementTypeEnum OUTLINE =
    ElementType_ElementTypeEnum_OUTLINE;
  static constexpr ElementTypeEnum OUTLINE_ROW =
    ElementType_ElementTypeEnum_OUTLINE_ROW;
  static constexpr ElementTypeEnum BROWSER =
    ElementType_ElementTypeEnum_BROWSER;
  static constexpr ElementTypeEnum COLLECTION_VIEW =
    ElementType_ElementTypeEnum_COLLECTION_VIEW;
  static constexpr ElementTypeEnum SLIDER =
    ElementType_ElementTypeEnum_SLIDER;
  static constexpr ElementTypeEnum PAGE_INDICATOR =
    ElementType_ElementTypeEnum_PAGE_INDICATOR;
  static constexpr ElementTypeEnum PROGRESS_INDICATOR =
    ElementType_ElementTypeEnum_PROGRESS_INDICATOR;
  static constexpr ElementTypeEnum ACTIVITY_INDICATOR =
    ElementType_ElementTypeEnum_ACTIVITY_INDICATOR;
  static constexpr ElementTypeEnum SEGMENTED_CONTROL =
    ElementType_ElementTypeEnum_SEGMENTED_CONTROL;
  static constexpr ElementTypeEnum PICKER =
    ElementType_ElementTypeEnum_PICKER;
  static constexpr ElementTypeEnum PICKER_WHEEL =
    ElementType_ElementTypeEnum_PICKER_WHEEL;
  static constexpr ElementTypeEnum SWITCH =
    ElementType_ElementTypeEnum_SWITCH;
  static constexpr ElementTypeEnum TOGGLE =
    ElementType_ElementTypeEnum_TOGGLE;
  static constexpr ElementTypeEnum LINK =
    ElementType_ElementTypeEnum_LINK;
  static constexpr ElementTypeEnum IMAGE =
    ElementType_ElementTypeEnum_IMAGE;
  static constexpr ElementTypeEnum ICON =
    ElementType_ElementTypeEnum_ICON;
  static constexpr ElementTypeEnum SEARCH_FIELD =
    ElementType_ElementTypeEnum_SEARCH_FIELD;
  static constexpr ElementTypeEnum SCROLL_VIEW =
    ElementType_ElementTypeEnum_SCROLL_VIEW;
  static constexpr ElementTypeEnum SCROLL_BAR =
    ElementType_ElementTypeEnum_SCROLL_BAR;
  static constexpr ElementTypeEnum STATIC_TEXT =
    ElementType_ElementTypeEnum_STATIC_TEXT;
  static constexpr ElementTypeEnum TEXT_FIELD =
    ElementType_ElementTypeEnum_TEXT_FIELD;
  static constexpr ElementTypeEnum SECURE_TEXT_FIELD =
    ElementType_ElementTypeEnum_SECURE_TEXT_FIELD;
  static constexpr ElementTypeEnum DATE_PICKER =
    ElementType_ElementTypeEnum_DATE_PICKER;
  static constexpr ElementTypeEnum TEXT_VIEW =
    ElementType_ElementTypeEnum_TEXT_VIEW;
  static constexpr ElementTypeEnum MENU =
    ElementType_ElementTypeEnum_MENU;
  static constexpr ElementTypeEnum MENU_ITEM =
    ElementType_ElementTypeEnum_MENU_ITEM;
  static constexpr ElementTypeEnum MENU_BAR =
    ElementType_ElementTypeEnum_MENU_BAR;
  static constexpr ElementTypeEnum MENU_BAR_ITEM =
    ElementType_ElementTypeEnum_MENU_BAR_ITEM;
  static constexpr ElementTypeEnum MAP =
    ElementType_ElementTypeEnum_MAP;
  static constexpr ElementTypeEnum WEB_VIEW =
    ElementType_ElementTypeEnum_WEB_VIEW;
  static constexpr ElementTypeEnum INCREMENT_ARROW =
    ElementType_ElementTypeEnum_INCREMENT_ARROW;
  static constexpr ElementTypeEnum DECREMENT_ARROW =
    ElementType_ElementTypeEnum_DECREMENT_ARROW;
  static constexpr ElementTypeEnum TIMELINE =
    ElementType_ElementTypeEnum_TIMELINE;
  static constexpr ElementTypeEnum RATING_INDICATOR =
    ElementType_ElementTypeEnum_RATING_INDICATOR;
  static constexpr ElementTypeEnum VALUE_INDICATOR =
    ElementType_ElementTypeEnum_VALUE_INDICATOR;
  static constexpr ElementTypeEnum SPLIT_GROUP =
    ElementType_ElementTypeEnum_SPLIT_GROUP;
  static constexpr ElementTypeEnum SPLITTER =
    ElementType_ElementTypeEnum_SPLITTER;
  static constexpr ElementTypeEnum RELEVANCE_INDICATOR =
    ElementType_ElementTypeEnum_RELEVANCE_INDICATOR;
  static constexpr ElementTypeEnum COLOR_WELL =
    ElementType_ElementTypeEnum_COLOR_WELL;
  static constexpr ElementTypeEnum HELP_TAG =
    ElementType_ElementTypeEnum_HELP_TAG;
  static constexpr ElementTypeEnum MATTE =
    ElementType_ElementTypeEnum_MATTE;
  static constexpr ElementTypeEnum DOCK_ITEM =
    ElementType_ElementTypeEnum_DOCK_ITEM;
  static constexpr ElementTypeEnum RULER =
    ElementType_ElementTypeEnum_RULER;
  static constexpr ElementTypeEnum RULER_MARKER =
    ElementType_ElementTypeEnum_RULER_MARKER;
  static constexpr ElementTypeEnum GRID =
    ElementType_ElementTypeEnum_GRID;
  static constexpr ElementTypeEnum LEVEL_INDICATOR =
    ElementType_ElementTypeEnum_LEVEL_INDICATOR;
  static constexpr ElementTypeEnum CELL =
    ElementType_ElementTypeEnum_CELL;
  static constexpr ElementTypeEnum LAYOUT_AREA =
    ElementType_ElementTypeEnum_LAYOUT_AREA;
  static constexpr ElementTypeEnum LAYOUT_ITEM =
    ElementType_ElementTypeEnum_LAYOUT_ITEM;
  static constexpr ElementTypeEnum HANDLE =
    ElementType_ElementTypeEnum_HANDLE;
  static constexpr ElementTypeEnum STEPPER =
    ElementType_ElementTypeEnum_STEPPER;
  static constexpr ElementTypeEnum TAB =
    ElementType_ElementTypeEnum_TAB;
  static constexpr ElementTypeEnum TOUCH_BAR =
    ElementType_ElementTypeEnum_TOUCH_BAR;
  static constexpr ElementTypeEnum STATUS_ITEM =
    ElementType_ElementTypeEnum_STATUS_ITEM;
  static inline bool ElementTypeEnum_IsValid(int value) {
    return ElementType_ElementTypeEnum_IsValid(value);
  }
  static constexpr ElementTypeEnum ElementTypeEnum_MIN =
    ElementType_ElementTypeEnum_ElementTypeEnum_MIN;
  static constexpr ElementTypeEnum ElementTypeEnum_MAX =
    ElementType_ElementTypeEnum_ElementTypeEnum_MAX;
  static constexpr int ElementTypeEnum_ARRAYSIZE =
    ElementType_ElementTypeEnum_ElementTypeEnum_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  ElementTypeEnum_descriptor() {
    return ElementType_ElementTypeEnum_descriptor();
  }
  template<typename T>
  static inline const std::string& ElementTypeEnum_Name(T enum_t_value) {
    static_assert(::std::is_same<T, ElementTypeEnum>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function ElementTypeEnum_Name.");
    return ElementType_ElementTypeEnum_Name(enum_t_value);
  }
  static inline bool ElementTypeEnum_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      ElementTypeEnum* value) {
    return ElementType_ElementTypeEnum_Parse(name, value);
  }

  // accessors -------------------------------------------------------

  // @@protoc_insertion_point(class_scope:gtxilib.oopclasses.protos.ElementType)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_gtx_2eproto;
};
// -------------------------------------------------------------------

class UIElement PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:gtxilib.oopclasses.protos.UIElement) */ {
 public:
  inline UIElement() : UIElement(nullptr) {}
  virtual ~UIElement();

  UIElement(const UIElement& from);
  UIElement(UIElement&& from) noexcept
    : UIElement() {
    *this = ::std::move(from);
  }

  inline UIElement& operator=(const UIElement& from) {
    CopyFrom(from);
    return *this;
  }
  inline UIElement& operator=(UIElement&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const UIElement& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const UIElement* internal_default_instance() {
    return reinterpret_cast<const UIElement*>(
               &_UIElement_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    4;

  friend void swap(UIElement& a, UIElement& b) {
    a.Swap(&b);
  }
  inline void Swap(UIElement* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(UIElement* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline UIElement* New() const final {
    return CreateMaybeMessage<UIElement>(nullptr);
  }

  UIElement* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<UIElement>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const UIElement& from);
  void MergeFrom(const UIElement& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(UIElement* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "gtxilib.oopclasses.protos.UIElement";
  }
  protected:
  explicit UIElement(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_gtx_2eproto);
    return ::descriptor_table_gtx_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kAxLabelFieldNumber = 3,
    kAxFrameFieldNumber = 4,
    kAxTraitsFieldNumber = 2,
    kIsAxElementFieldNumber = 1,
    kAxElementTypeFieldNumber = 5,
  };
  // string ax_label = 3;
  void clear_ax_label();
  const std::string& ax_label() const;
  void set_ax_label(const std::string& value);
  void set_ax_label(std::string&& value);
  void set_ax_label(const char* value);
  void set_ax_label(const char* value, size_t size);
  std::string* mutable_ax_label();
  std::string* release_ax_label();
  void set_allocated_ax_label(std::string* ax_label);
  private:
  const std::string& _internal_ax_label() const;
  void _internal_set_ax_label(const std::string& value);
  std::string* _internal_mutable_ax_label();
  public:

  // .gtxilib.oopclasses.protos.Rect ax_frame = 4;
  bool has_ax_frame() const;
  private:
  bool _internal_has_ax_frame() const;
  public:
  void clear_ax_frame();
  const ::gtxilib::oopclasses::protos::Rect& ax_frame() const;
  ::gtxilib::oopclasses::protos::Rect* release_ax_frame();
  ::gtxilib::oopclasses::protos::Rect* mutable_ax_frame();
  void set_allocated_ax_frame(::gtxilib::oopclasses::protos::Rect* ax_frame);
  private:
  const ::gtxilib::oopclasses::protos::Rect& _internal_ax_frame() const;
  ::gtxilib::oopclasses::protos::Rect* _internal_mutable_ax_frame();
  public:
  void unsafe_arena_set_allocated_ax_frame(
      ::gtxilib::oopclasses::protos::Rect* ax_frame);
  ::gtxilib::oopclasses::protos::Rect* unsafe_arena_release_ax_frame();

  // uint64 ax_traits = 2;
  void clear_ax_traits();
  ::PROTOBUF_NAMESPACE_ID::uint64 ax_traits() const;
  void set_ax_traits(::PROTOBUF_NAMESPACE_ID::uint64 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint64 _internal_ax_traits() const;
  void _internal_set_ax_traits(::PROTOBUF_NAMESPACE_ID::uint64 value);
  public:

  // bool is_ax_element = 1;
  void clear_is_ax_element();
  bool is_ax_element() const;
  void set_is_ax_element(bool value);
  private:
  bool _internal_is_ax_element() const;
  void _internal_set_is_ax_element(bool value);
  public:

  // .gtxilib.oopclasses.protos.ElementType.ElementTypeEnum ax_element_type = 5;
  void clear_ax_element_type();
  ::gtxilib::oopclasses::protos::ElementType_ElementTypeEnum ax_element_type() const;
  void set_ax_element_type(::gtxilib::oopclasses::protos::ElementType_ElementTypeEnum value);
  private:
  ::gtxilib::oopclasses::protos::ElementType_ElementTypeEnum _internal_ax_element_type() const;
  void _internal_set_ax_element_type(::gtxilib::oopclasses::protos::ElementType_ElementTypeEnum value);
  public:

  // @@protoc_insertion_point(class_scope:gtxilib.oopclasses.protos.UIElement)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr ax_label_;
  ::gtxilib::oopclasses::protos::Rect* ax_frame_;
  ::PROTOBUF_NAMESPACE_ID::uint64 ax_traits_;
  bool is_ax_element_;
  int ax_element_type_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_gtx_2eproto;
};
// ===================================================================


// ===================================================================

#ifdef __GNUC__
  #pragma GCC diagnostic push
  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif  // __GNUC__
// Point

// float x = 1;
inline void Point::clear_x() {
  x_ = 0;
}
inline float Point::_internal_x() const {
  return x_;
}
inline float Point::x() const {
  // @@protoc_insertion_point(field_get:gtxilib.oopclasses.protos.Point.x)
  return _internal_x();
}
inline void Point::_internal_set_x(float value) {
  
  x_ = value;
}
inline void Point::set_x(float value) {
  _internal_set_x(value);
  // @@protoc_insertion_point(field_set:gtxilib.oopclasses.protos.Point.x)
}

// float y = 2;
inline void Point::clear_y() {
  y_ = 0;
}
inline float Point::_internal_y() const {
  return y_;
}
inline float Point::y() const {
  // @@protoc_insertion_point(field_get:gtxilib.oopclasses.protos.Point.y)
  return _internal_y();
}
inline void Point::_internal_set_y(float value) {
  
  y_ = value;
}
inline void Point::set_y(float value) {
  _internal_set_y(value);
  // @@protoc_insertion_point(field_set:gtxilib.oopclasses.protos.Point.y)
}

// -------------------------------------------------------------------

// Size

// float width = 1;
inline void Size::clear_width() {
  width_ = 0;
}
inline float Size::_internal_width() const {
  return width_;
}
inline float Size::width() const {
  // @@protoc_insertion_point(field_get:gtxilib.oopclasses.protos.Size.width)
  return _internal_width();
}
inline void Size::_internal_set_width(float value) {
  
  width_ = value;
}
inline void Size::set_width(float value) {
  _internal_set_width(value);
  // @@protoc_insertion_point(field_set:gtxilib.oopclasses.protos.Size.width)
}

// float height = 2;
inline void Size::clear_height() {
  height_ = 0;
}
inline float Size::_internal_height() const {
  return height_;
}
inline float Size::height() const {
  // @@protoc_insertion_point(field_get:gtxilib.oopclasses.protos.Size.height)
  return _internal_height();
}
inline void Size::_internal_set_height(float value) {
  
  height_ = value;
}
inline void Size::set_height(float value) {
  _internal_set_height(value);
  // @@protoc_insertion_point(field_set:gtxilib.oopclasses.protos.Size.height)
}

// -------------------------------------------------------------------

// Rect

// .gtxilib.oopclasses.protos.Point origin = 1;
inline bool Rect::_internal_has_origin() const {
  return this != internal_default_instance() && origin_ != nullptr;
}
inline bool Rect::has_origin() const {
  return _internal_has_origin();
}
inline void Rect::clear_origin() {
  if (GetArena() == nullptr && origin_ != nullptr) {
    delete origin_;
  }
  origin_ = nullptr;
}
inline const ::gtxilib::oopclasses::protos::Point& Rect::_internal_origin() const {
  const ::gtxilib::oopclasses::protos::Point* p = origin_;
  return p != nullptr ? *p : *reinterpret_cast<const ::gtxilib::oopclasses::protos::Point*>(
      &::gtxilib::oopclasses::protos::_Point_default_instance_);
}
inline const ::gtxilib::oopclasses::protos::Point& Rect::origin() const {
  // @@protoc_insertion_point(field_get:gtxilib.oopclasses.protos.Rect.origin)
  return _internal_origin();
}
inline void Rect::unsafe_arena_set_allocated_origin(
    ::gtxilib::oopclasses::protos::Point* origin) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(origin_);
  }
  origin_ = origin;
  if (origin) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:gtxilib.oopclasses.protos.Rect.origin)
}
inline ::gtxilib::oopclasses::protos::Point* Rect::release_origin() {
  
  ::gtxilib::oopclasses::protos::Point* temp = origin_;
  origin_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::gtxilib::oopclasses::protos::Point* Rect::unsafe_arena_release_origin() {
  // @@protoc_insertion_point(field_release:gtxilib.oopclasses.protos.Rect.origin)
  
  ::gtxilib::oopclasses::protos::Point* temp = origin_;
  origin_ = nullptr;
  return temp;
}
inline ::gtxilib::oopclasses::protos::Point* Rect::_internal_mutable_origin() {
  
  if (origin_ == nullptr) {
    auto* p = CreateMaybeMessage<::gtxilib::oopclasses::protos::Point>(GetArena());
    origin_ = p;
  }
  return origin_;
}
inline ::gtxilib::oopclasses::protos::Point* Rect::mutable_origin() {
  // @@protoc_insertion_point(field_mutable:gtxilib.oopclasses.protos.Rect.origin)
  return _internal_mutable_origin();
}
inline void Rect::set_allocated_origin(::gtxilib::oopclasses::protos::Point* origin) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete origin_;
  }
  if (origin) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(origin);
    if (message_arena != submessage_arena) {
      origin = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, origin, submessage_arena);
    }
    
  } else {
    
  }
  origin_ = origin;
  // @@protoc_insertion_point(field_set_allocated:gtxilib.oopclasses.protos.Rect.origin)
}

// .gtxilib.oopclasses.protos.Size size = 2;
inline bool Rect::_internal_has_size() const {
  return this != internal_default_instance() && size_ != nullptr;
}
inline bool Rect::has_size() const {
  return _internal_has_size();
}
inline void Rect::clear_size() {
  if (GetArena() == nullptr && size_ != nullptr) {
    delete size_;
  }
  size_ = nullptr;
}
inline const ::gtxilib::oopclasses::protos::Size& Rect::_internal_size() const {
  const ::gtxilib::oopclasses::protos::Size* p = size_;
  return p != nullptr ? *p : *reinterpret_cast<const ::gtxilib::oopclasses::protos::Size*>(
      &::gtxilib::oopclasses::protos::_Size_default_instance_);
}
inline const ::gtxilib::oopclasses::protos::Size& Rect::size() const {
  // @@protoc_insertion_point(field_get:gtxilib.oopclasses.protos.Rect.size)
  return _internal_size();
}
inline void Rect::unsafe_arena_set_allocated_size(
    ::gtxilib::oopclasses::protos::Size* size) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(size_);
  }
  size_ = size;
  if (size) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:gtxilib.oopclasses.protos.Rect.size)
}
inline ::gtxilib::oopclasses::protos::Size* Rect::release_size() {
  
  ::gtxilib::oopclasses::protos::Size* temp = size_;
  size_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::gtxilib::oopclasses::protos::Size* Rect::unsafe_arena_release_size() {
  // @@protoc_insertion_point(field_release:gtxilib.oopclasses.protos.Rect.size)
  
  ::gtxilib::oopclasses::protos::Size* temp = size_;
  size_ = nullptr;
  return temp;
}
inline ::gtxilib::oopclasses::protos::Size* Rect::_internal_mutable_size() {
  
  if (size_ == nullptr) {
    auto* p = CreateMaybeMessage<::gtxilib::oopclasses::protos::Size>(GetArena());
    size_ = p;
  }
  return size_;
}
inline ::gtxilib::oopclasses::protos::Size* Rect::mutable_size() {
  // @@protoc_insertion_point(field_mutable:gtxilib.oopclasses.protos.Rect.size)
  return _internal_mutable_size();
}
inline void Rect::set_allocated_size(::gtxilib::oopclasses::protos::Size* size) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete size_;
  }
  if (size) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(size);
    if (message_arena != submessage_arena) {
      size = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, size, submessage_arena);
    }
    
  } else {
    
  }
  size_ = size;
  // @@protoc_insertion_point(field_set_allocated:gtxilib.oopclasses.protos.Rect.size)
}

// -------------------------------------------------------------------

// ElementType

// -------------------------------------------------------------------

// UIElement

// bool is_ax_element = 1;
inline void UIElement::clear_is_ax_element() {
  is_ax_element_ = false;
}
inline bool UIElement::_internal_is_ax_element() const {
  return is_ax_element_;
}
inline bool UIElement::is_ax_element() const {
  // @@protoc_insertion_point(field_get:gtxilib.oopclasses.protos.UIElement.is_ax_element)
  return _internal_is_ax_element();
}
inline void UIElement::_internal_set_is_ax_element(bool value) {
  
  is_ax_element_ = value;
}
inline void UIElement::set_is_ax_element(bool value) {
  _internal_set_is_ax_element(value);
  // @@protoc_insertion_point(field_set:gtxilib.oopclasses.protos.UIElement.is_ax_element)
}

// uint64 ax_traits = 2;
inline void UIElement::clear_ax_traits() {
  ax_traits_ = PROTOBUF_ULONGLONG(0);
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 UIElement::_internal_ax_traits() const {
  return ax_traits_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 UIElement::ax_traits() const {
  // @@protoc_insertion_point(field_get:gtxilib.oopclasses.protos.UIElement.ax_traits)
  return _internal_ax_traits();
}
inline void UIElement::_internal_set_ax_traits(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  
  ax_traits_ = value;
}
inline void UIElement::set_ax_traits(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  _internal_set_ax_traits(value);
  // @@protoc_insertion_point(field_set:gtxilib.oopclasses.protos.UIElement.ax_traits)
}

// string ax_label = 3;
inline void UIElement::clear_ax_label() {
  ax_label_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline const std::string& UIElement::ax_label() const {
  // @@protoc_insertion_point(field_get:gtxilib.oopclasses.protos.UIElement.ax_label)
  return _internal_ax_label();
}
inline void UIElement::set_ax_label(const std::string& value) {
  _internal_set_ax_label(value);
  // @@protoc_insertion_point(field_set:gtxilib.oopclasses.protos.UIElement.ax_label)
}
inline std::string* UIElement::mutable_ax_label() {
  // @@protoc_insertion_point(field_mutable:gtxilib.oopclasses.protos.UIElement.ax_label)
  return _internal_mutable_ax_label();
}
inline const std::string& UIElement::_internal_ax_label() const {
  return ax_label_.Get();
}
inline void UIElement::_internal_set_ax_label(const std::string& value) {
  
  ax_label_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void UIElement::set_ax_label(std::string&& value) {
  
  ax_label_.Set(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:gtxilib.oopclasses.protos.UIElement.ax_label)
}
inline void UIElement::set_ax_label(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  ax_label_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:gtxilib.oopclasses.protos.UIElement.ax_label)
}
inline void UIElement::set_ax_label(const char* value,
    size_t size) {
  
  ax_label_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:gtxilib.oopclasses.protos.UIElement.ax_label)
}
inline std::string* UIElement::_internal_mutable_ax_label() {
  
  return ax_label_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* UIElement::release_ax_label() {
  // @@protoc_insertion_point(field_release:gtxilib.oopclasses.protos.UIElement.ax_label)
  return ax_label_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void UIElement::set_allocated_ax_label(std::string* ax_label) {
  if (ax_label != nullptr) {
    
  } else {
    
  }
  ax_label_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ax_label,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:gtxilib.oopclasses.protos.UIElement.ax_label)
}

// .gtxilib.oopclasses.protos.Rect ax_frame = 4;
inline bool UIElement::_internal_has_ax_frame() const {
  return this != internal_default_instance() && ax_frame_ != nullptr;
}
inline bool UIElement::has_ax_frame() const {
  return _internal_has_ax_frame();
}
inline void UIElement::clear_ax_frame() {
  if (GetArena() == nullptr && ax_frame_ != nullptr) {
    delete ax_frame_;
  }
  ax_frame_ = nullptr;
}
inline const ::gtxilib::oopclasses::protos::Rect& UIElement::_internal_ax_frame() const {
  const ::gtxilib::oopclasses::protos::Rect* p = ax_frame_;
  return p != nullptr ? *p : *reinterpret_cast<const ::gtxilib::oopclasses::protos::Rect*>(
      &::gtxilib::oopclasses::protos::_Rect_default_instance_);
}
inline const ::gtxilib::oopclasses::protos::Rect& UIElement::ax_frame() const {
  // @@protoc_insertion_point(field_get:gtxilib.oopclasses.protos.UIElement.ax_frame)
  return _internal_ax_frame();
}
inline void UIElement::unsafe_arena_set_allocated_ax_frame(
    ::gtxilib::oopclasses::protos::Rect* ax_frame) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(ax_frame_);
  }
  ax_frame_ = ax_frame;
  if (ax_frame) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:gtxilib.oopclasses.protos.UIElement.ax_frame)
}
inline ::gtxilib::oopclasses::protos::Rect* UIElement::release_ax_frame() {
  
  ::gtxilib::oopclasses::protos::Rect* temp = ax_frame_;
  ax_frame_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::gtxilib::oopclasses::protos::Rect* UIElement::unsafe_arena_release_ax_frame() {
  // @@protoc_insertion_point(field_release:gtxilib.oopclasses.protos.UIElement.ax_frame)
  
  ::gtxilib::oopclasses::protos::Rect* temp = ax_frame_;
  ax_frame_ = nullptr;
  return temp;
}
inline ::gtxilib::oopclasses::protos::Rect* UIElement::_internal_mutable_ax_frame() {
  
  if (ax_frame_ == nullptr) {
    auto* p = CreateMaybeMessage<::gtxilib::oopclasses::protos::Rect>(GetArena());
    ax_frame_ = p;
  }
  return ax_frame_;
}
inline ::gtxilib::oopclasses::protos::Rect* UIElement::mutable_ax_frame() {
  // @@protoc_insertion_point(field_mutable:gtxilib.oopclasses.protos.UIElement.ax_frame)
  return _internal_mutable_ax_frame();
}
inline void UIElement::set_allocated_ax_frame(::gtxilib::oopclasses::protos::Rect* ax_frame) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete ax_frame_;
  }
  if (ax_frame) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(ax_frame);
    if (message_arena != submessage_arena) {
      ax_frame = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, ax_frame, submessage_arena);
    }
    
  } else {
    
  }
  ax_frame_ = ax_frame;
  // @@protoc_insertion_point(field_set_allocated:gtxilib.oopclasses.protos.UIElement.ax_frame)
}

// .gtxilib.oopclasses.protos.ElementType.ElementTypeEnum ax_element_type = 5;
inline void UIElement::clear_ax_element_type() {
  ax_element_type_ = 0;
}
inline ::gtxilib::oopclasses::protos::ElementType_ElementTypeEnum UIElement::_internal_ax_element_type() const {
  return static_cast< ::gtxilib::oopclasses::protos::ElementType_ElementTypeEnum >(ax_element_type_);
}
inline ::gtxilib::oopclasses::protos::ElementType_ElementTypeEnum UIElement::ax_element_type() const {
  // @@protoc_insertion_point(field_get:gtxilib.oopclasses.protos.UIElement.ax_element_type)
  return _internal_ax_element_type();
}
inline void UIElement::_internal_set_ax_element_type(::gtxilib::oopclasses::protos::ElementType_ElementTypeEnum value) {
  
  ax_element_type_ = value;
}
inline void UIElement::set_ax_element_type(::gtxilib::oopclasses::protos::ElementType_ElementTypeEnum value) {
  _internal_set_ax_element_type(value);
  // @@protoc_insertion_point(field_set:gtxilib.oopclasses.protos.UIElement.ax_element_type)
}

#ifdef __GNUC__
  #pragma GCC diagnostic pop
#endif  // __GNUC__
// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------


// @@protoc_insertion_point(namespace_scope)

}  // namespace protos
}  // namespace oopclasses
}  // namespace gtxilib

PROTOBUF_NAMESPACE_OPEN

template <> struct is_proto_enum< ::gtxilib::oopclasses::protos::ElementType_ElementTypeEnum> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::gtxilib::oopclasses::protos::ElementType_ElementTypeEnum>() {
  return ::gtxilib::oopclasses::protos::ElementType_ElementTypeEnum_descriptor();
}

PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)

#include <google/protobuf/port_undef.inc>
#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_gtx_2eproto