#ifndef __grts_structs_h__
#define __grts_structs_h__

#include <grtpp.h>

#ifdef _WIN32
  #pragma warning(disable: 4355) // 'this' : used in base member initizalizer list
  #ifdef GRT_STRUCTS_EXPORT
  #define GRT_STRUCTS_PUBLIC __declspec(dllexport)
#else
  #define GRT_STRUCTS_PUBLIC __declspec(dllimport)
#endif
#else
  #define GRT_STRUCTS_PUBLIC
#endif



class GrtObject;
typedef grt::Ref<GrtObject> GrtObjectRef;
class GrtVersion;
typedef grt::Ref<GrtVersion> GrtVersionRef;
class GrtMessage;
typedef grt::Ref<GrtMessage> GrtMessageRef;
class GrtLogEntry;
typedef grt::Ref<GrtLogEntry> GrtLogEntryRef;
class GrtLogObject;
typedef grt::Ref<GrtLogObject> GrtLogObjectRef;
class GrtNamedObject;
typedef grt::Ref<GrtNamedObject> GrtNamedObjectRef;
class GrtStoredNote;
typedef grt::Ref<GrtStoredNote> GrtStoredNoteRef;


class  GrtObject : public grt::internal::Object
{
  typedef grt::internal::Object super;
public:
  GrtObject(grt::GRT *grt, grt::MetaClass *meta=0)
  : grt::internal::Object(grt, meta ? meta : grt->get_metaclass(static_class_name())),
     _name("")

  {
  }

  static std::string static_class_name() { return "GrtObject"; }

  grt::StringRef name() const { return _name; }
  virtual void name(const grt::StringRef &value)
  {
    grt::ValueRef ovalue(_name);
   _name= value;
    member_changed("name", ovalue, value);
  }

  GrtObjectRef owner() const { return _owner; }
  virtual void owner(const GrtObjectRef &value)
  {
    grt::ValueRef ovalue(_owner);
   _owner= value;
    member_changed("owner", ovalue, value);
  }

protected:

  grt::StringRef _name;
  GrtObjectRef _owner;
private: // wrapper methods for use by grt
  static grt::ObjectRef create(grt::GRT *grt)
  {
    return grt::ObjectRef(new GrtObject(grt));
  }


public:
  static void grt_register(grt::GRT *grt)
  {
    grt::MetaClass *meta= grt->get_metaclass(static_class_name());
    if (!meta) throw std::runtime_error("error initializing grt object class, metaclass not found");
    meta->bind_allocator(&GrtObject::create);
    {
      void (GrtObject::*setter)(const grt::StringRef &)= &GrtObject::name;
      grt::StringRef (GrtObject::*getter)() const= &GrtObject::name;
      meta->bind_member("name", new grt::MetaClass::Property<GrtObject,grt::StringRef >(getter,setter));
    }
    {
      void (GrtObject::*setter)(const GrtObjectRef &)= &GrtObject::owner;
      GrtObjectRef (GrtObject::*getter)() const= &GrtObject::owner;
      meta->bind_member("owner", new grt::MetaClass::Property<GrtObject,GrtObjectRef >(getter,setter));
    }
  }
};


class  GrtVersion : public GrtObject
{
  typedef GrtObject super;
public:
  GrtVersion(grt::GRT *grt, grt::MetaClass *meta=0)
  : GrtObject(grt, meta ? meta : grt->get_metaclass(static_class_name())),
     _buildNumber(0),
     _majorNumber(0),
     _minorNumber(0),
     _releaseNumber(0),
     _status(0)

  {
  }

  static std::string static_class_name() { return "GrtVersion"; }

  grt::IntegerRef buildNumber() const { return _buildNumber; }
  virtual void buildNumber(const grt::IntegerRef &value)
  {
    grt::ValueRef ovalue(_buildNumber);
   _buildNumber= value;
    member_changed("buildNumber", ovalue, value);
  }

  grt::IntegerRef majorNumber() const { return _majorNumber; }
  virtual void majorNumber(const grt::IntegerRef &value)
  {
    grt::ValueRef ovalue(_majorNumber);
   _majorNumber= value;
    member_changed("majorNumber", ovalue, value);
  }

  grt::IntegerRef minorNumber() const { return _minorNumber; }
  virtual void minorNumber(const grt::IntegerRef &value)
  {
    grt::ValueRef ovalue(_minorNumber);
   _minorNumber= value;
    member_changed("minorNumber", ovalue, value);
  }

  grt::IntegerRef releaseNumber() const { return _releaseNumber; }
  virtual void releaseNumber(const grt::IntegerRef &value)
  {
    grt::ValueRef ovalue(_releaseNumber);
   _releaseNumber= value;
    member_changed("releaseNumber", ovalue, value);
  }

  grt::IntegerRef status() const { return _status; }
  virtual void status(const grt::IntegerRef &value)
  {
    grt::ValueRef ovalue(_status);
   _status= value;
    member_changed("status", ovalue, value);
  }

protected:

  grt::IntegerRef _buildNumber;
  grt::IntegerRef _majorNumber;
  grt::IntegerRef _minorNumber;
  grt::IntegerRef _releaseNumber;
  grt::IntegerRef _status;
private: // wrapper methods for use by grt
  static grt::ObjectRef create(grt::GRT *grt)
  {
    return grt::ObjectRef(new GrtVersion(grt));
  }


public:
  static void grt_register(grt::GRT *grt)
  {
    grt::MetaClass *meta= grt->get_metaclass(static_class_name());
    if (!meta) throw std::runtime_error("error initializing grt object class, metaclass not found");
    meta->bind_allocator(&GrtVersion::create);
    {
      void (GrtVersion::*setter)(const grt::IntegerRef &)= &GrtVersion::buildNumber;
      grt::IntegerRef (GrtVersion::*getter)() const= &GrtVersion::buildNumber;
      meta->bind_member("buildNumber", new grt::MetaClass::Property<GrtVersion,grt::IntegerRef >(getter,setter));
    }
    {
      void (GrtVersion::*setter)(const grt::IntegerRef &)= &GrtVersion::majorNumber;
      grt::IntegerRef (GrtVersion::*getter)() const= &GrtVersion::majorNumber;
      meta->bind_member("majorNumber", new grt::MetaClass::Property<GrtVersion,grt::IntegerRef >(getter,setter));
    }
    {
      void (GrtVersion::*setter)(const grt::IntegerRef &)= &GrtVersion::minorNumber;
      grt::IntegerRef (GrtVersion::*getter)() const= &GrtVersion::minorNumber;
      meta->bind_member("minorNumber", new grt::MetaClass::Property<GrtVersion,grt::IntegerRef >(getter,setter));
    }
    {
      void (GrtVersion::*setter)(const grt::IntegerRef &)= &GrtVersion::releaseNumber;
      grt::IntegerRef (GrtVersion::*getter)() const= &GrtVersion::releaseNumber;
      meta->bind_member("releaseNumber", new grt::MetaClass::Property<GrtVersion,grt::IntegerRef >(getter,setter));
    }
    {
      void (GrtVersion::*setter)(const grt::IntegerRef &)= &GrtVersion::status;
      grt::IntegerRef (GrtVersion::*getter)() const= &GrtVersion::status;
      meta->bind_member("status", new grt::MetaClass::Property<GrtVersion,grt::IntegerRef >(getter,setter));
    }
  }
};


class  GrtMessage : public GrtObject
{
  typedef GrtObject super;
public:
  GrtMessage(grt::GRT *grt, grt::MetaClass *meta=0)
  : GrtObject(grt, meta ? meta : grt->get_metaclass(static_class_name())),
    _details(grt, this, false),
     _msg(""),
     _msgType(0)

  {
  }

  static std::string static_class_name() { return "GrtMessage"; }

  grt::StringListRef details() const { return _details; }
private: // the next attribute is read-only
  virtual void details(const grt::StringListRef &value)
  {
    grt::ValueRef ovalue(_details);
   _details= value;
    member_changed("details", ovalue, value);
  }
public:

  grt::StringRef msg() const { return _msg; }
  virtual void msg(const grt::StringRef &value)
  {
    grt::ValueRef ovalue(_msg);
   _msg= value;
    member_changed("msg", ovalue, value);
  }

  grt::IntegerRef msgType() const { return _msgType; }
  virtual void msgType(const grt::IntegerRef &value)
  {
    grt::ValueRef ovalue(_msgType);
   _msgType= value;
    member_changed("msgType", ovalue, value);
  }


protected:

  grt::StringListRef _details;
  grt::StringRef _msg;
  grt::IntegerRef _msgType;
private: // wrapper methods for use by grt
  static grt::ObjectRef create(grt::GRT *grt)
  {
    return grt::ObjectRef(new GrtMessage(grt));
  }


public:
  static void grt_register(grt::GRT *grt)
  {
    grt::MetaClass *meta= grt->get_metaclass(static_class_name());
    if (!meta) throw std::runtime_error("error initializing grt object class, metaclass not found");
    meta->bind_allocator(&GrtMessage::create);
    {
      void (GrtMessage::*setter)(const grt::StringListRef &)= &GrtMessage::details;
      grt::StringListRef (GrtMessage::*getter)() const= &GrtMessage::details;
      meta->bind_member("details", new grt::MetaClass::Property<GrtMessage,grt::StringListRef >(getter,setter));
    }
    {
      void (GrtMessage::*setter)(const grt::StringRef &)= &GrtMessage::msg;
      grt::StringRef (GrtMessage::*getter)() const= &GrtMessage::msg;
      meta->bind_member("msg", new grt::MetaClass::Property<GrtMessage,grt::StringRef >(getter,setter));
    }
    {
      void (GrtMessage::*setter)(const grt::IntegerRef &)= &GrtMessage::msgType;
      grt::IntegerRef (GrtMessage::*getter)() const= &GrtMessage::msgType;
      meta->bind_member("msgType", new grt::MetaClass::Property<GrtMessage,grt::IntegerRef >(getter,setter));
    }
    {
      void (GrtMessage::*setter)(const grt::StringRef &)= 0;
      grt::StringRef (GrtMessage::*getter)() const= 0;
      meta->bind_member("name", new grt::MetaClass::Property<GrtMessage,grt::StringRef >(getter,setter));
    }
  }
};


class  GrtLogEntry : public GrtObject
{
  typedef GrtObject super;
public:
  GrtLogEntry(grt::GRT *grt, grt::MetaClass *meta=0)
  : GrtObject(grt, meta ? meta : grt->get_metaclass(static_class_name())),
    _customData(grt, this, false),
     _entryType(0)

  {
  }

  static std::string static_class_name() { return "GrtLogEntry"; }

  grt::DictRef customData() const { return _customData; }
private: // the next attribute is read-only
  virtual void customData(const grt::DictRef &value)
  {
    grt::ValueRef ovalue(_customData);
   _customData= value;
    member_changed("customData", ovalue, value);
  }
public:

  grt::IntegerRef entryType() const { return _entryType; }
  virtual void entryType(const grt::IntegerRef &value)
  {
    grt::ValueRef ovalue(_entryType);
   _entryType= value;
    member_changed("entryType", ovalue, value);
  }


protected:

  grt::DictRef _customData;
  grt::IntegerRef _entryType;
private: // wrapper methods for use by grt
  static grt::ObjectRef create(grt::GRT *grt)
  {
    return grt::ObjectRef(new GrtLogEntry(grt));
  }


public:
  static void grt_register(grt::GRT *grt)
  {
    grt::MetaClass *meta= grt->get_metaclass(static_class_name());
    if (!meta) throw std::runtime_error("error initializing grt object class, metaclass not found");
    meta->bind_allocator(&GrtLogEntry::create);
    {
      void (GrtLogEntry::*setter)(const grt::DictRef &)= &GrtLogEntry::customData;
      grt::DictRef (GrtLogEntry::*getter)() const= &GrtLogEntry::customData;
      meta->bind_member("customData", new grt::MetaClass::Property<GrtLogEntry,grt::DictRef >(getter,setter));
    }
    {
      void (GrtLogEntry::*setter)(const grt::IntegerRef &)= &GrtLogEntry::entryType;
      grt::IntegerRef (GrtLogEntry::*getter)() const= &GrtLogEntry::entryType;
      meta->bind_member("entryType", new grt::MetaClass::Property<GrtLogEntry,grt::IntegerRef >(getter,setter));
    }
    {
      void (GrtLogEntry::*setter)(const grt::StringRef &)= 0;
      grt::StringRef (GrtLogEntry::*getter)() const= 0;
      meta->bind_member("name", new grt::MetaClass::Property<GrtLogEntry,grt::StringRef >(getter,setter));
    }
  }
};


class  GrtLogObject : public GrtObject
{
  typedef GrtObject super;
public:
  GrtLogObject(grt::GRT *grt, grt::MetaClass *meta=0)
  : GrtObject(grt, meta ? meta : grt->get_metaclass(static_class_name())),
    _entries(grt, this, false)

  {
  }

  static std::string static_class_name() { return "GrtLogObject"; }

  // entries is owned by GrtLogObject
  grt::ListRef<GrtLogEntry> entries() const { return _entries; }
private: // the next attribute is read-only
  virtual void entries(const grt::ListRef<GrtLogEntry> &value)
  {
    grt::ValueRef ovalue(_entries);

    _entries= value;
    owned_member_changed("entries", ovalue, value);
  }
public:

  GrtObjectRef logObject() const { return _logObject; }
  virtual void logObject(const GrtObjectRef &value)
  {
    grt::ValueRef ovalue(_logObject);
   _logObject= value;
    member_changed("logObject", ovalue, value);
  }

  GrtObjectRef refObject() const { return _refObject; }
  virtual void refObject(const GrtObjectRef &value)
  {
    grt::ValueRef ovalue(_refObject);
   _refObject= value;
    member_changed("refObject", ovalue, value);
  }

protected:

  grt::ListRef<GrtLogEntry> _entries;// owned
  GrtObjectRef _logObject;
  GrtObjectRef _refObject;
private: // wrapper methods for use by grt
  static grt::ObjectRef create(grt::GRT *grt)
  {
    return grt::ObjectRef(new GrtLogObject(grt));
  }


public:
  static void grt_register(grt::GRT *grt)
  {
    grt::MetaClass *meta= grt->get_metaclass(static_class_name());
    if (!meta) throw std::runtime_error("error initializing grt object class, metaclass not found");
    meta->bind_allocator(&GrtLogObject::create);
    {
      void (GrtLogObject::*setter)(const grt::ListRef<GrtLogEntry> &)= &GrtLogObject::entries;
      grt::ListRef<GrtLogEntry> (GrtLogObject::*getter)() const= &GrtLogObject::entries;
      meta->bind_member("entries", new grt::MetaClass::Property<GrtLogObject,grt::ListRef<GrtLogEntry> >(getter,setter));
    }
    {
      void (GrtLogObject::*setter)(const GrtObjectRef &)= &GrtLogObject::logObject;
      GrtObjectRef (GrtLogObject::*getter)() const= &GrtLogObject::logObject;
      meta->bind_member("logObject", new grt::MetaClass::Property<GrtLogObject,GrtObjectRef >(getter,setter));
    }
    {
      void (GrtLogObject::*setter)(const GrtObjectRef &)= &GrtLogObject::refObject;
      GrtObjectRef (GrtLogObject::*getter)() const= &GrtLogObject::refObject;
      meta->bind_member("refObject", new grt::MetaClass::Property<GrtLogObject,GrtObjectRef >(getter,setter));
    }
  }
};


class  GrtNamedObject : public GrtObject
{
  typedef GrtObject super;
public:
  GrtNamedObject(grt::GRT *grt, grt::MetaClass *meta=0)
  : GrtObject(grt, meta ? meta : grt->get_metaclass(static_class_name())),
     _comment(""),
     _oldName("")

  {
  }

  static std::string static_class_name() { return "GrtNamedObject"; }

  grt::StringRef comment() const { return _comment; }
  virtual void comment(const grt::StringRef &value)
  {
    grt::ValueRef ovalue(_comment);
   _comment= value;
    member_changed("comment", ovalue, value);
  }


  grt::StringRef oldName() const { return _oldName; }
  virtual void oldName(const grt::StringRef &value)
  {
    grt::ValueRef ovalue(_oldName);
   _oldName= value;
    member_changed("oldName", ovalue, value);
  }

protected:

  grt::StringRef _comment;
  grt::StringRef _oldName;
private: // wrapper methods for use by grt
  static grt::ObjectRef create(grt::GRT *grt)
  {
    return grt::ObjectRef(new GrtNamedObject(grt));
  }


public:
  static void grt_register(grt::GRT *grt)
  {
    grt::MetaClass *meta= grt->get_metaclass(static_class_name());
    if (!meta) throw std::runtime_error("error initializing grt object class, metaclass not found");
    meta->bind_allocator(&GrtNamedObject::create);
    {
      void (GrtNamedObject::*setter)(const grt::StringRef &)= &GrtNamedObject::comment;
      grt::StringRef (GrtNamedObject::*getter)() const= &GrtNamedObject::comment;
      meta->bind_member("comment", new grt::MetaClass::Property<GrtNamedObject,grt::StringRef >(getter,setter));
    }
    {
      void (GrtNamedObject::*setter)(const grt::StringRef &)= 0;
      grt::StringRef (GrtNamedObject::*getter)() const= 0;
      meta->bind_member("name", new grt::MetaClass::Property<GrtNamedObject,grt::StringRef >(getter,setter));
    }
    {
      void (GrtNamedObject::*setter)(const grt::StringRef &)= &GrtNamedObject::oldName;
      grt::StringRef (GrtNamedObject::*getter)() const= &GrtNamedObject::oldName;
      meta->bind_member("oldName", new grt::MetaClass::Property<GrtNamedObject,grt::StringRef >(getter,setter));
    }
  }
};


class  GrtStoredNote : public GrtNamedObject
{
  typedef GrtNamedObject super;
public:
  GrtStoredNote(grt::GRT *grt, grt::MetaClass *meta=0)
  : GrtNamedObject(grt, meta ? meta : grt->get_metaclass(static_class_name())),
     _createDate(""),
     _filename(""),
     _lastChangeDate("")

  {
  }

  static std::string static_class_name() { return "GrtStoredNote"; }

  grt::StringRef createDate() const { return _createDate; }
  virtual void createDate(const grt::StringRef &value)
  {
    grt::ValueRef ovalue(_createDate);
   _createDate= value;
    member_changed("createDate", ovalue, value);
  }

  grt::StringRef filename() const { return _filename; }
  virtual void filename(const grt::StringRef &value)
  {
    grt::ValueRef ovalue(_filename);
   _filename= value;
    member_changed("filename", ovalue, value);
  }

  grt::StringRef lastChangeDate() const { return _lastChangeDate; }
  virtual void lastChangeDate(const grt::StringRef &value)
  {
    grt::ValueRef ovalue(_lastChangeDate);
   _lastChangeDate= value;
    member_changed("lastChangeDate", ovalue, value);
  }

protected:

  grt::StringRef _createDate;
  grt::StringRef _filename;
  grt::StringRef _lastChangeDate;
private: // wrapper methods for use by grt
  static grt::ObjectRef create(grt::GRT *grt)
  {
    return grt::ObjectRef(new GrtStoredNote(grt));
  }


public:
  static void grt_register(grt::GRT *grt)
  {
    grt::MetaClass *meta= grt->get_metaclass(static_class_name());
    if (!meta) throw std::runtime_error("error initializing grt object class, metaclass not found");
    meta->bind_allocator(&GrtStoredNote::create);
    {
      void (GrtStoredNote::*setter)(const grt::StringRef &)= &GrtStoredNote::createDate;
      grt::StringRef (GrtStoredNote::*getter)() const= &GrtStoredNote::createDate;
      meta->bind_member("createDate", new grt::MetaClass::Property<GrtStoredNote,grt::StringRef >(getter,setter));
    }
    {
      void (GrtStoredNote::*setter)(const grt::StringRef &)= &GrtStoredNote::filename;
      grt::StringRef (GrtStoredNote::*getter)() const= &GrtStoredNote::filename;
      meta->bind_member("filename", new grt::MetaClass::Property<GrtStoredNote,grt::StringRef >(getter,setter));
    }
    {
      void (GrtStoredNote::*setter)(const grt::StringRef &)= &GrtStoredNote::lastChangeDate;
      grt::StringRef (GrtStoredNote::*getter)() const= &GrtStoredNote::lastChangeDate;
      meta->bind_member("lastChangeDate", new grt::MetaClass::Property<GrtStoredNote,grt::StringRef >(getter,setter));
    }
  }
};




inline void register_structs_xml()
{
  grt::internal::ClassRegistry::register_class<GrtObject>();
  grt::internal::ClassRegistry::register_class<GrtVersion>();
  grt::internal::ClassRegistry::register_class<GrtMessage>();
  grt::internal::ClassRegistry::register_class<GrtLogEntry>();
  grt::internal::ClassRegistry::register_class<GrtLogObject>();
  grt::internal::ClassRegistry::register_class<GrtNamedObject>();
  grt::internal::ClassRegistry::register_class<GrtStoredNote>();
}

#ifdef AUTO_REGISTER_GRT_CLASSES
static struct _autoreg__structs_xml { _autoreg__structs_xml() { register_structs_xml(); } } __autoreg__structs_xml;
#endif

#endif
