00001 #ifndef __grts_structs_h__
00002 #define __grts_structs_h__
00003
00004 #include <grtpp.h>
00005
00006 #ifdef _WIN32
00007 #pragma warning(disable: 4355) // 'this' : used in base member initizalizer list
00008 #ifdef GRT_STRUCTS_EXPORT
00009 #define GRT_STRUCTS_PUBLIC __declspec(dllexport)
00010 #else
00011 #define GRT_STRUCTS_PUBLIC __declspec(dllimport)
00012 #endif
00013 #else
00014 #define GRT_STRUCTS_PUBLIC
00015 #endif
00016
00017
00018
00019 class GrtObject;
00020 typedef grt::Ref<GrtObject> GrtObjectRef;
00021 class GrtVersion;
00022 typedef grt::Ref<GrtVersion> GrtVersionRef;
00023 class GrtMessage;
00024 typedef grt::Ref<GrtMessage> GrtMessageRef;
00025 class GrtLogEntry;
00026 typedef grt::Ref<GrtLogEntry> GrtLogEntryRef;
00027 class GrtLogObject;
00028 typedef grt::Ref<GrtLogObject> GrtLogObjectRef;
00029 class GrtNamedObject;
00030 typedef grt::Ref<GrtNamedObject> GrtNamedObjectRef;
00031 class GrtStoredNote;
00032 typedef grt::Ref<GrtStoredNote> GrtStoredNoteRef;
00033
00034
00036 class GrtObject : public grt::internal::Object
00037 {
00038 typedef grt::internal::Object super;
00039 public:
00040 GrtObject(grt::GRT *grt, grt::MetaClass *meta=0)
00041 : grt::internal::Object(grt, meta ? meta : grt->get_metaclass(static_class_name())),
00042 _name("")
00043
00044 {
00045 }
00046
00047 static std::string static_class_name() { return "GrtObject"; }
00048
00055 grt::StringRef name() const { return _name; }
00062 virtual void name(const grt::StringRef &value)
00063 {
00064 grt::ValueRef ovalue(_name);
00065 _name= value;
00066 member_changed("name", ovalue, value);
00067 }
00068
00075 GrtObjectRef owner() const { return _owner; }
00082 virtual void owner(const GrtObjectRef &value)
00083 {
00084 grt::ValueRef ovalue(_owner);
00085 _owner= value;
00086 member_changed("owner", ovalue, value);
00087 }
00088
00089 protected:
00090
00091 grt::StringRef _name;
00092 GrtObjectRef _owner;
00093 private:
00094 static grt::ObjectRef create(grt::GRT *grt)
00095 {
00096 return grt::ObjectRef(new GrtObject(grt));
00097 }
00098
00099
00100 public:
00101 static void grt_register(grt::GRT *grt)
00102 {
00103 grt::MetaClass *meta= grt->get_metaclass(static_class_name());
00104 if (!meta) throw std::runtime_error("error initializing grt object class, metaclass not found");
00105 meta->bind_allocator(&GrtObject::create);
00106 {
00107 void (GrtObject::*setter)(const grt::StringRef &)= &GrtObject::name;
00108 grt::StringRef (GrtObject::*getter)() const= &GrtObject::name;
00109 meta->bind_member("name", new grt::MetaClass::Property<GrtObject,grt::StringRef >(getter,setter));
00110 }
00111 {
00112 void (GrtObject::*setter)(const GrtObjectRef &)= &GrtObject::owner;
00113 GrtObjectRef (GrtObject::*getter)() const= &GrtObject::owner;
00114 meta->bind_member("owner", new grt::MetaClass::Property<GrtObject,GrtObjectRef >(getter,setter));
00115 }
00116 }
00117 };
00118
00119
00121 class GrtVersion : public GrtObject
00122 {
00123 typedef GrtObject super;
00124 public:
00125 GrtVersion(grt::GRT *grt, grt::MetaClass *meta=0)
00126 : GrtObject(grt, meta ? meta : grt->get_metaclass(static_class_name())),
00127 _buildNumber(0),
00128 _majorNumber(0),
00129 _minorNumber(0),
00130 _releaseNumber(0),
00131 _status(0)
00132
00133 {
00134 }
00135
00136 static std::string static_class_name() { return "GrtVersion"; }
00137
00144 grt::IntegerRef buildNumber() const { return _buildNumber; }
00151 virtual void buildNumber(const grt::IntegerRef &value)
00152 {
00153 grt::ValueRef ovalue(_buildNumber);
00154 _buildNumber= value;
00155 member_changed("buildNumber", ovalue, value);
00156 }
00157
00164 grt::IntegerRef majorNumber() const { return _majorNumber; }
00171 virtual void majorNumber(const grt::IntegerRef &value)
00172 {
00173 grt::ValueRef ovalue(_majorNumber);
00174 _majorNumber= value;
00175 member_changed("majorNumber", ovalue, value);
00176 }
00177
00184 grt::IntegerRef minorNumber() const { return _minorNumber; }
00191 virtual void minorNumber(const grt::IntegerRef &value)
00192 {
00193 grt::ValueRef ovalue(_minorNumber);
00194 _minorNumber= value;
00195 member_changed("minorNumber", ovalue, value);
00196 }
00197
00204 grt::IntegerRef releaseNumber() const { return _releaseNumber; }
00211 virtual void releaseNumber(const grt::IntegerRef &value)
00212 {
00213 grt::ValueRef ovalue(_releaseNumber);
00214 _releaseNumber= value;
00215 member_changed("releaseNumber", ovalue, value);
00216 }
00217
00224 grt::IntegerRef status() const { return _status; }
00231 virtual void status(const grt::IntegerRef &value)
00232 {
00233 grt::ValueRef ovalue(_status);
00234 _status= value;
00235 member_changed("status", ovalue, value);
00236 }
00237
00238 protected:
00239
00240 grt::IntegerRef _buildNumber;
00241 grt::IntegerRef _majorNumber;
00242 grt::IntegerRef _minorNumber;
00243 grt::IntegerRef _releaseNumber;
00244 grt::IntegerRef _status;
00245 private:
00246 static grt::ObjectRef create(grt::GRT *grt)
00247 {
00248 return grt::ObjectRef(new GrtVersion(grt));
00249 }
00250
00251
00252 public:
00253 static void grt_register(grt::GRT *grt)
00254 {
00255 grt::MetaClass *meta= grt->get_metaclass(static_class_name());
00256 if (!meta) throw std::runtime_error("error initializing grt object class, metaclass not found");
00257 meta->bind_allocator(&GrtVersion::create);
00258 {
00259 void (GrtVersion::*setter)(const grt::IntegerRef &)= &GrtVersion::buildNumber;
00260 grt::IntegerRef (GrtVersion::*getter)() const= &GrtVersion::buildNumber;
00261 meta->bind_member("buildNumber", new grt::MetaClass::Property<GrtVersion,grt::IntegerRef >(getter,setter));
00262 }
00263 {
00264 void (GrtVersion::*setter)(const grt::IntegerRef &)= &GrtVersion::majorNumber;
00265 grt::IntegerRef (GrtVersion::*getter)() const= &GrtVersion::majorNumber;
00266 meta->bind_member("majorNumber", new grt::MetaClass::Property<GrtVersion,grt::IntegerRef >(getter,setter));
00267 }
00268 {
00269 void (GrtVersion::*setter)(const grt::IntegerRef &)= &GrtVersion::minorNumber;
00270 grt::IntegerRef (GrtVersion::*getter)() const= &GrtVersion::minorNumber;
00271 meta->bind_member("minorNumber", new grt::MetaClass::Property<GrtVersion,grt::IntegerRef >(getter,setter));
00272 }
00273 {
00274 void (GrtVersion::*setter)(const grt::IntegerRef &)= &GrtVersion::releaseNumber;
00275 grt::IntegerRef (GrtVersion::*getter)() const= &GrtVersion::releaseNumber;
00276 meta->bind_member("releaseNumber", new grt::MetaClass::Property<GrtVersion,grt::IntegerRef >(getter,setter));
00277 }
00278 {
00279 void (GrtVersion::*setter)(const grt::IntegerRef &)= &GrtVersion::status;
00280 grt::IntegerRef (GrtVersion::*getter)() const= &GrtVersion::status;
00281 meta->bind_member("status", new grt::MetaClass::Property<GrtVersion,grt::IntegerRef >(getter,setter));
00282 }
00283 }
00284 };
00285
00286
00288 class GrtMessage : public GrtObject
00289 {
00290 typedef GrtObject super;
00291 public:
00292 GrtMessage(grt::GRT *grt, grt::MetaClass *meta=0)
00293 : GrtObject(grt, meta ? meta : grt->get_metaclass(static_class_name())),
00294 _details(grt, this, false),
00295 _msg(""),
00296 _msgType(0)
00297
00298 {
00299 }
00300
00301 static std::string static_class_name() { return "GrtMessage"; }
00302
00309 grt::StringListRef details() const { return _details; }
00310 private:
00311 virtual void details(const grt::StringListRef &value)
00312 {
00313 grt::ValueRef ovalue(_details);
00314 _details= value;
00315 member_changed("details", ovalue, value);
00316 }
00317 public:
00318
00325 grt::StringRef msg() const { return _msg; }
00332 virtual void msg(const grt::StringRef &value)
00333 {
00334 grt::ValueRef ovalue(_msg);
00335 _msg= value;
00336 member_changed("msg", ovalue, value);
00337 }
00338
00345 grt::IntegerRef msgType() const { return _msgType; }
00352 virtual void msgType(const grt::IntegerRef &value)
00353 {
00354 grt::ValueRef ovalue(_msgType);
00355 _msgType= value;
00356 member_changed("msgType", ovalue, value);
00357 }
00358
00372 protected:
00373
00374 grt::StringListRef _details;
00375 grt::StringRef _msg;
00376 grt::IntegerRef _msgType;
00377 private:
00378 static grt::ObjectRef create(grt::GRT *grt)
00379 {
00380 return grt::ObjectRef(new GrtMessage(grt));
00381 }
00382
00383
00384 public:
00385 static void grt_register(grt::GRT *grt)
00386 {
00387 grt::MetaClass *meta= grt->get_metaclass(static_class_name());
00388 if (!meta) throw std::runtime_error("error initializing grt object class, metaclass not found");
00389 meta->bind_allocator(&GrtMessage::create);
00390 {
00391 void (GrtMessage::*setter)(const grt::StringListRef &)= &GrtMessage::details;
00392 grt::StringListRef (GrtMessage::*getter)() const= &GrtMessage::details;
00393 meta->bind_member("details", new grt::MetaClass::Property<GrtMessage,grt::StringListRef >(getter,setter));
00394 }
00395 {
00396 void (GrtMessage::*setter)(const grt::StringRef &)= &GrtMessage::msg;
00397 grt::StringRef (GrtMessage::*getter)() const= &GrtMessage::msg;
00398 meta->bind_member("msg", new grt::MetaClass::Property<GrtMessage,grt::StringRef >(getter,setter));
00399 }
00400 {
00401 void (GrtMessage::*setter)(const grt::IntegerRef &)= &GrtMessage::msgType;
00402 grt::IntegerRef (GrtMessage::*getter)() const= &GrtMessage::msgType;
00403 meta->bind_member("msgType", new grt::MetaClass::Property<GrtMessage,grt::IntegerRef >(getter,setter));
00404 }
00405 {
00406 void (GrtMessage::*setter)(const grt::StringRef &)= 0;
00407 grt::StringRef (GrtMessage::*getter)() const= 0;
00408 meta->bind_member("name", new grt::MetaClass::Property<GrtMessage,grt::StringRef >(getter,setter));
00409 }
00410 }
00411 };
00412
00413
00415 class GrtLogEntry : public GrtObject
00416 {
00417 typedef GrtObject super;
00418 public:
00419 GrtLogEntry(grt::GRT *grt, grt::MetaClass *meta=0)
00420 : GrtObject(grt, meta ? meta : grt->get_metaclass(static_class_name())),
00421 _customData(grt, this, false),
00422 _entryType(0)
00423
00424 {
00425 }
00426
00427 static std::string static_class_name() { return "GrtLogEntry"; }
00428
00435 grt::DictRef customData() const { return _customData; }
00436 private:
00437 virtual void customData(const grt::DictRef &value)
00438 {
00439 grt::ValueRef ovalue(_customData);
00440 _customData= value;
00441 member_changed("customData", ovalue, value);
00442 }
00443 public:
00444
00451 grt::IntegerRef entryType() const { return _entryType; }
00458 virtual void entryType(const grt::IntegerRef &value)
00459 {
00460 grt::ValueRef ovalue(_entryType);
00461 _entryType= value;
00462 member_changed("entryType", ovalue, value);
00463 }
00464
00478 protected:
00479
00480 grt::DictRef _customData;
00481 grt::IntegerRef _entryType;
00482 private:
00483 static grt::ObjectRef create(grt::GRT *grt)
00484 {
00485 return grt::ObjectRef(new GrtLogEntry(grt));
00486 }
00487
00488
00489 public:
00490 static void grt_register(grt::GRT *grt)
00491 {
00492 grt::MetaClass *meta= grt->get_metaclass(static_class_name());
00493 if (!meta) throw std::runtime_error("error initializing grt object class, metaclass not found");
00494 meta->bind_allocator(&GrtLogEntry::create);
00495 {
00496 void (GrtLogEntry::*setter)(const grt::DictRef &)= &GrtLogEntry::customData;
00497 grt::DictRef (GrtLogEntry::*getter)() const= &GrtLogEntry::customData;
00498 meta->bind_member("customData", new grt::MetaClass::Property<GrtLogEntry,grt::DictRef >(getter,setter));
00499 }
00500 {
00501 void (GrtLogEntry::*setter)(const grt::IntegerRef &)= &GrtLogEntry::entryType;
00502 grt::IntegerRef (GrtLogEntry::*getter)() const= &GrtLogEntry::entryType;
00503 meta->bind_member("entryType", new grt::MetaClass::Property<GrtLogEntry,grt::IntegerRef >(getter,setter));
00504 }
00505 {
00506 void (GrtLogEntry::*setter)(const grt::StringRef &)= 0;
00507 grt::StringRef (GrtLogEntry::*getter)() const= 0;
00508 meta->bind_member("name", new grt::MetaClass::Property<GrtLogEntry,grt::StringRef >(getter,setter));
00509 }
00510 }
00511 };
00512
00513
00515 class GrtLogObject : public GrtObject
00516 {
00517 typedef GrtObject super;
00518 public:
00519 GrtLogObject(grt::GRT *grt, grt::MetaClass *meta=0)
00520 : GrtObject(grt, meta ? meta : grt->get_metaclass(static_class_name())),
00521 _entries(grt, this, false)
00522
00523 {
00524 }
00525
00526 static std::string static_class_name() { return "GrtLogObject"; }
00527
00528
00535 grt::ListRef<GrtLogEntry> entries() const { return _entries; }
00536 private:
00537 virtual void entries(const grt::ListRef<GrtLogEntry> &value)
00538 {
00539 grt::ValueRef ovalue(_entries);
00540
00541 _entries= value;
00542 owned_member_changed("entries", ovalue, value);
00543 }
00544 public:
00545
00552 GrtObjectRef logObject() const { return _logObject; }
00559 virtual void logObject(const GrtObjectRef &value)
00560 {
00561 grt::ValueRef ovalue(_logObject);
00562 _logObject= value;
00563 member_changed("logObject", ovalue, value);
00564 }
00565
00572 GrtObjectRef refObject() const { return _refObject; }
00579 virtual void refObject(const GrtObjectRef &value)
00580 {
00581 grt::ValueRef ovalue(_refObject);
00582 _refObject= value;
00583 member_changed("refObject", ovalue, value);
00584 }
00585
00586 protected:
00587
00588 grt::ListRef<GrtLogEntry> _entries;
00589 GrtObjectRef _logObject;
00590 GrtObjectRef _refObject;
00591 private:
00592 static grt::ObjectRef create(grt::GRT *grt)
00593 {
00594 return grt::ObjectRef(new GrtLogObject(grt));
00595 }
00596
00597
00598 public:
00599 static void grt_register(grt::GRT *grt)
00600 {
00601 grt::MetaClass *meta= grt->get_metaclass(static_class_name());
00602 if (!meta) throw std::runtime_error("error initializing grt object class, metaclass not found");
00603 meta->bind_allocator(&GrtLogObject::create);
00604 {
00605 void (GrtLogObject::*setter)(const grt::ListRef<GrtLogEntry> &)= &GrtLogObject::entries;
00606 grt::ListRef<GrtLogEntry> (GrtLogObject::*getter)() const= &GrtLogObject::entries;
00607 meta->bind_member("entries", new grt::MetaClass::Property<GrtLogObject,grt::ListRef<GrtLogEntry> >(getter,setter));
00608 }
00609 {
00610 void (GrtLogObject::*setter)(const GrtObjectRef &)= &GrtLogObject::logObject;
00611 GrtObjectRef (GrtLogObject::*getter)() const= &GrtLogObject::logObject;
00612 meta->bind_member("logObject", new grt::MetaClass::Property<GrtLogObject,GrtObjectRef >(getter,setter));
00613 }
00614 {
00615 void (GrtLogObject::*setter)(const GrtObjectRef &)= &GrtLogObject::refObject;
00616 GrtObjectRef (GrtLogObject::*getter)() const= &GrtLogObject::refObject;
00617 meta->bind_member("refObject", new grt::MetaClass::Property<GrtLogObject,GrtObjectRef >(getter,setter));
00618 }
00619 }
00620 };
00621
00622
00624 class GrtNamedObject : public GrtObject
00625 {
00626 typedef GrtObject super;
00627 public:
00628 GrtNamedObject(grt::GRT *grt, grt::MetaClass *meta=0)
00629 : GrtObject(grt, meta ? meta : grt->get_metaclass(static_class_name())),
00630 _comment(""),
00631 _oldName("")
00632
00633 {
00634 }
00635
00636 static std::string static_class_name() { return "GrtNamedObject"; }
00637
00644 grt::StringRef comment() const { return _comment; }
00651 virtual void comment(const grt::StringRef &value)
00652 {
00653 grt::ValueRef ovalue(_comment);
00654 _comment= value;
00655 member_changed("comment", ovalue, value);
00656 }
00657
00677 grt::StringRef oldName() const { return _oldName; }
00684 virtual void oldName(const grt::StringRef &value)
00685 {
00686 grt::ValueRef ovalue(_oldName);
00687 _oldName= value;
00688 member_changed("oldName", ovalue, value);
00689 }
00690
00691 protected:
00692
00693 grt::StringRef _comment;
00694 grt::StringRef _oldName;
00695 private:
00696 static grt::ObjectRef create(grt::GRT *grt)
00697 {
00698 return grt::ObjectRef(new GrtNamedObject(grt));
00699 }
00700
00701
00702 public:
00703 static void grt_register(grt::GRT *grt)
00704 {
00705 grt::MetaClass *meta= grt->get_metaclass(static_class_name());
00706 if (!meta) throw std::runtime_error("error initializing grt object class, metaclass not found");
00707 meta->bind_allocator(&GrtNamedObject::create);
00708 {
00709 void (GrtNamedObject::*setter)(const grt::StringRef &)= &GrtNamedObject::comment;
00710 grt::StringRef (GrtNamedObject::*getter)() const= &GrtNamedObject::comment;
00711 meta->bind_member("comment", new grt::MetaClass::Property<GrtNamedObject,grt::StringRef >(getter,setter));
00712 }
00713 {
00714 void (GrtNamedObject::*setter)(const grt::StringRef &)= 0;
00715 grt::StringRef (GrtNamedObject::*getter)() const= 0;
00716 meta->bind_member("name", new grt::MetaClass::Property<GrtNamedObject,grt::StringRef >(getter,setter));
00717 }
00718 {
00719 void (GrtNamedObject::*setter)(const grt::StringRef &)= &GrtNamedObject::oldName;
00720 grt::StringRef (GrtNamedObject::*getter)() const= &GrtNamedObject::oldName;
00721 meta->bind_member("oldName", new grt::MetaClass::Property<GrtNamedObject,grt::StringRef >(getter,setter));
00722 }
00723 }
00724 };
00725
00726
00728 class GrtStoredNote : public GrtNamedObject
00729 {
00730 typedef GrtNamedObject super;
00731 public:
00732 GrtStoredNote(grt::GRT *grt, grt::MetaClass *meta=0)
00733 : GrtNamedObject(grt, meta ? meta : grt->get_metaclass(static_class_name())),
00734 _createDate(""),
00735 _filename(""),
00736 _lastChangeDate("")
00737
00738 {
00739 }
00740
00741 static std::string static_class_name() { return "GrtStoredNote"; }
00742
00749 grt::StringRef createDate() const { return _createDate; }
00756 virtual void createDate(const grt::StringRef &value)
00757 {
00758 grt::ValueRef ovalue(_createDate);
00759 _createDate= value;
00760 member_changed("createDate", ovalue, value);
00761 }
00762
00769 grt::StringRef filename() const { return _filename; }
00776 virtual void filename(const grt::StringRef &value)
00777 {
00778 grt::ValueRef ovalue(_filename);
00779 _filename= value;
00780 member_changed("filename", ovalue, value);
00781 }
00782
00789 grt::StringRef lastChangeDate() const { return _lastChangeDate; }
00796 virtual void lastChangeDate(const grt::StringRef &value)
00797 {
00798 grt::ValueRef ovalue(_lastChangeDate);
00799 _lastChangeDate= value;
00800 member_changed("lastChangeDate", ovalue, value);
00801 }
00802
00803 protected:
00804
00805 grt::StringRef _createDate;
00806 grt::StringRef _filename;
00807 grt::StringRef _lastChangeDate;
00808 private:
00809 static grt::ObjectRef create(grt::GRT *grt)
00810 {
00811 return grt::ObjectRef(new GrtStoredNote(grt));
00812 }
00813
00814
00815 public:
00816 static void grt_register(grt::GRT *grt)
00817 {
00818 grt::MetaClass *meta= grt->get_metaclass(static_class_name());
00819 if (!meta) throw std::runtime_error("error initializing grt object class, metaclass not found");
00820 meta->bind_allocator(&GrtStoredNote::create);
00821 {
00822 void (GrtStoredNote::*setter)(const grt::StringRef &)= &GrtStoredNote::createDate;
00823 grt::StringRef (GrtStoredNote::*getter)() const= &GrtStoredNote::createDate;
00824 meta->bind_member("createDate", new grt::MetaClass::Property<GrtStoredNote,grt::StringRef >(getter,setter));
00825 }
00826 {
00827 void (GrtStoredNote::*setter)(const grt::StringRef &)= &GrtStoredNote::filename;
00828 grt::StringRef (GrtStoredNote::*getter)() const= &GrtStoredNote::filename;
00829 meta->bind_member("filename", new grt::MetaClass::Property<GrtStoredNote,grt::StringRef >(getter,setter));
00830 }
00831 {
00832 void (GrtStoredNote::*setter)(const grt::StringRef &)= &GrtStoredNote::lastChangeDate;
00833 grt::StringRef (GrtStoredNote::*getter)() const= &GrtStoredNote::lastChangeDate;
00834 meta->bind_member("lastChangeDate", new grt::MetaClass::Property<GrtStoredNote,grt::StringRef >(getter,setter));
00835 }
00836 }
00837 };
00838
00839
00840
00841
00842 inline void register_structs_xml()
00843 {
00844 grt::internal::ClassRegistry::register_class<GrtObject>();
00845 grt::internal::ClassRegistry::register_class<GrtVersion>();
00846 grt::internal::ClassRegistry::register_class<GrtMessage>();
00847 grt::internal::ClassRegistry::register_class<GrtLogEntry>();
00848 grt::internal::ClassRegistry::register_class<GrtLogObject>();
00849 grt::internal::ClassRegistry::register_class<GrtNamedObject>();
00850 grt::internal::ClassRegistry::register_class<GrtStoredNote>();
00851 }
00852
00853 #ifdef AUTO_REGISTER_GRT_CLASSES
00854 static struct _autoreg__structs_xml { _autoreg__structs_xml() { register_structs_xml(); } } __autoreg__structs_xml;
00855 #endif
00856
00857 #endif
