grts/structs.app.h

#ifndef __grts_structs_app_h__
#define __grts_structs_app_h__

#include <grtpp.h>

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

#include <grts/structs.h>


class app_PluginInputDefinition;
typedef grt::Ref<app_PluginInputDefinition> app_PluginInputDefinitionRef;
class app_PluginObjectInput;
typedef grt::Ref<app_PluginObjectInput> app_PluginObjectInputRef;
class app_PluginFileInput;
typedef grt::Ref<app_PluginFileInput> app_PluginFileInputRef;
class app_PluginSelectionInput;
typedef grt::Ref<app_PluginSelectionInput> app_PluginSelectionInputRef;
class app_Plugin;
typedef grt::Ref<app_Plugin> app_PluginRef;
class app_DocumentPlugin;
typedef grt::Ref<app_DocumentPlugin> app_DocumentPluginRef;
class app_PluginGroup;
typedef grt::Ref<app_PluginGroup> app_PluginGroupRef;
class app_Toolbar;
typedef grt::Ref<app_Toolbar> app_ToolbarRef;
class app_CommandItem;
typedef grt::Ref<app_CommandItem> app_CommandItemRef;
class app_ToolbarItem;
typedef grt::Ref<app_ToolbarItem> app_ToolbarItemRef;
class app_ShortcutItem;
typedef grt::Ref<app_ShortcutItem> app_ShortcutItemRef;
class app_MenuItem;
typedef grt::Ref<app_MenuItem> app_MenuItemRef;
class app_CustomDataField;
typedef grt::Ref<app_CustomDataField> app_CustomDataFieldRef;
class app_PageSettings;
typedef grt::Ref<app_PageSettings> app_PageSettingsRef;
class app_PaperType;
typedef grt::Ref<app_PaperType> app_PaperTypeRef;
class app_Registry;
typedef grt::Ref<app_Registry> app_RegistryRef;
class app_Starter;
typedef grt::Ref<app_Starter> app_StarterRef;
class app_Starters;
typedef grt::Ref<app_Starters> app_StartersRef;
class app_Options;
typedef grt::Ref<app_Options> app_OptionsRef;
class app_DocumentInfo;
typedef grt::Ref<app_DocumentInfo> app_DocumentInfoRef;
class app_Info;
typedef grt::Ref<app_Info> app_InfoRef;
class app_Document;
typedef grt::Ref<app_Document> app_DocumentRef;
class app_Application;
typedef grt::Ref<app_Application> app_ApplicationRef;


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

  {
  }

  static std::string static_class_name() { return "app.PluginInputDefinition"; }

protected:

private: // wrapper methods for use by grt
  static grt::ObjectRef create(grt::GRT *grt)
  {
    return grt::ObjectRef(new app_PluginInputDefinition(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(&app_PluginInputDefinition::create);
  }
};


class  app_PluginObjectInput : public app_PluginInputDefinition
{
  typedef app_PluginInputDefinition super;
public:
  app_PluginObjectInput(grt::GRT *grt, grt::MetaClass *meta=0)
  : app_PluginInputDefinition(grt, meta ? meta : grt->get_metaclass(static_class_name())),
     _objectStructName("")

  {
  }

  static std::string static_class_name() { return "app.PluginObjectInput"; }

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

protected:

  grt::StringRef _objectStructName;
private: // wrapper methods for use by grt
  static grt::ObjectRef create(grt::GRT *grt)
  {
    return grt::ObjectRef(new app_PluginObjectInput(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(&app_PluginObjectInput::create);
    {
      void (app_PluginObjectInput::*setter)(const grt::StringRef &)= &app_PluginObjectInput::objectStructName;
      grt::StringRef (app_PluginObjectInput::*getter)() const= &app_PluginObjectInput::objectStructName;
      meta->bind_member("objectStructName", new grt::MetaClass::Property<app_PluginObjectInput,grt::StringRef >(getter,setter));
    }
  }
};


class  app_PluginFileInput : public app_PluginInputDefinition
{
  typedef app_PluginInputDefinition super;
public:
  app_PluginFileInput(grt::GRT *grt, grt::MetaClass *meta=0)
  : app_PluginInputDefinition(grt, meta ? meta : grt->get_metaclass(static_class_name())),
     _dialogTitle(""),
     _dialogType(""),
     _fileExtensions("")

  {
  }

  static std::string static_class_name() { return "app.PluginFileInput"; }

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

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

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

protected:

  grt::StringRef _dialogTitle;
  grt::StringRef _dialogType;
  grt::StringRef _fileExtensions;
private: // wrapper methods for use by grt
  static grt::ObjectRef create(grt::GRT *grt)
  {
    return grt::ObjectRef(new app_PluginFileInput(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(&app_PluginFileInput::create);
    {
      void (app_PluginFileInput::*setter)(const grt::StringRef &)= &app_PluginFileInput::dialogTitle;
      grt::StringRef (app_PluginFileInput::*getter)() const= &app_PluginFileInput::dialogTitle;
      meta->bind_member("dialogTitle", new grt::MetaClass::Property<app_PluginFileInput,grt::StringRef >(getter,setter));
    }
    {
      void (app_PluginFileInput::*setter)(const grt::StringRef &)= &app_PluginFileInput::dialogType;
      grt::StringRef (app_PluginFileInput::*getter)() const= &app_PluginFileInput::dialogType;
      meta->bind_member("dialogType", new grt::MetaClass::Property<app_PluginFileInput,grt::StringRef >(getter,setter));
    }
    {
      void (app_PluginFileInput::*setter)(const grt::StringRef &)= &app_PluginFileInput::fileExtensions;
      grt::StringRef (app_PluginFileInput::*getter)() const= &app_PluginFileInput::fileExtensions;
      meta->bind_member("fileExtensions", new grt::MetaClass::Property<app_PluginFileInput,grt::StringRef >(getter,setter));
    }
  }
};


class  app_PluginSelectionInput : public app_PluginInputDefinition
{
  typedef app_PluginInputDefinition super;
public:
  app_PluginSelectionInput(grt::GRT *grt, grt::MetaClass *meta=0)
  : app_PluginInputDefinition(grt, meta ? meta : grt->get_metaclass(static_class_name())),
     _argumentCardinality(""),
    _objectStructNames(grt, this, false)

  {
  }

  static std::string static_class_name() { return "app.PluginSelectionInput"; }

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

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

protected:

  grt::StringRef _argumentCardinality;
  grt::StringListRef _objectStructNames;
private: // wrapper methods for use by grt
  static grt::ObjectRef create(grt::GRT *grt)
  {
    return grt::ObjectRef(new app_PluginSelectionInput(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(&app_PluginSelectionInput::create);
    {
      void (app_PluginSelectionInput::*setter)(const grt::StringRef &)= &app_PluginSelectionInput::argumentCardinality;
      grt::StringRef (app_PluginSelectionInput::*getter)() const= &app_PluginSelectionInput::argumentCardinality;
      meta->bind_member("argumentCardinality", new grt::MetaClass::Property<app_PluginSelectionInput,grt::StringRef >(getter,setter));
    }
    {
      void (app_PluginSelectionInput::*setter)(const grt::StringListRef &)= &app_PluginSelectionInput::objectStructNames;
      grt::StringListRef (app_PluginSelectionInput::*getter)() const= &app_PluginSelectionInput::objectStructNames;
      meta->bind_member("objectStructNames", new grt::MetaClass::Property<app_PluginSelectionInput,grt::StringListRef >(getter,setter));
    }
  }
};


class  app_Plugin : public GrtObject
{
  typedef GrtObject super;
public:
  app_Plugin(grt::GRT *grt, grt::MetaClass *meta=0)
  : GrtObject(grt, meta ? meta : grt->get_metaclass(static_class_name())),
    _attributes(grt, this, false),
     _caption(""),
     _description(""),
    _documentStructNames(grt, this, false),
    _groups(grt, this, false),
    _inputValues(grt, this, false),
     _moduleFunctionName(""),
     _moduleName(""),
     _pluginType(""),
     _rating(0),
     _showProgress(0)

  {
  }

  static std::string static_class_name() { return "app.Plugin"; }

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

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

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

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

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

  // inputValues is owned by app_Plugin
  grt::ListRef<app_PluginInputDefinition> inputValues() const { return _inputValues; }
private: // the next attribute is read-only
  virtual void inputValues(const grt::ListRef<app_PluginInputDefinition> &value)
  {
    grt::ValueRef ovalue(_inputValues);

    _inputValues= value;
    owned_member_changed("inputValues", ovalue, value);
  }
public:

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

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

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

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

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

protected:

  grt::DictRef _attributes;
  grt::StringRef _caption;
  grt::StringRef _description;
  grt::StringListRef _documentStructNames;
  grt::StringListRef _groups;
  grt::ListRef<app_PluginInputDefinition> _inputValues;// owned
  grt::StringRef _moduleFunctionName;
  grt::StringRef _moduleName;
  grt::StringRef _pluginType;
  grt::IntegerRef _rating;
  grt::IntegerRef _showProgress;
private: // wrapper methods for use by grt
  static grt::ObjectRef create(grt::GRT *grt)
  {
    return grt::ObjectRef(new app_Plugin(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(&app_Plugin::create);
    {
      void (app_Plugin::*setter)(const grt::DictRef &)= &app_Plugin::attributes;
      grt::DictRef (app_Plugin::*getter)() const= &app_Plugin::attributes;
      meta->bind_member("attributes", new grt::MetaClass::Property<app_Plugin,grt::DictRef >(getter,setter));
    }
    {
      void (app_Plugin::*setter)(const grt::StringRef &)= &app_Plugin::caption;
      grt::StringRef (app_Plugin::*getter)() const= &app_Plugin::caption;
      meta->bind_member("caption", new grt::MetaClass::Property<app_Plugin,grt::StringRef >(getter,setter));
    }
    {
      void (app_Plugin::*setter)(const grt::StringRef &)= &app_Plugin::description;
      grt::StringRef (app_Plugin::*getter)() const= &app_Plugin::description;
      meta->bind_member("description", new grt::MetaClass::Property<app_Plugin,grt::StringRef >(getter,setter));
    }
    {
      void (app_Plugin::*setter)(const grt::StringListRef &)= &app_Plugin::documentStructNames;
      grt::StringListRef (app_Plugin::*getter)() const= &app_Plugin::documentStructNames;
      meta->bind_member("documentStructNames", new grt::MetaClass::Property<app_Plugin,grt::StringListRef >(getter,setter));
    }
    {
      void (app_Plugin::*setter)(const grt::StringListRef &)= &app_Plugin::groups;
      grt::StringListRef (app_Plugin::*getter)() const= &app_Plugin::groups;
      meta->bind_member("groups", new grt::MetaClass::Property<app_Plugin,grt::StringListRef >(getter,setter));
    }
    {
      void (app_Plugin::*setter)(const grt::ListRef<app_PluginInputDefinition> &)= &app_Plugin::inputValues;
      grt::ListRef<app_PluginInputDefinition> (app_Plugin::*getter)() const= &app_Plugin::inputValues;
      meta->bind_member("inputValues", new grt::MetaClass::Property<app_Plugin,grt::ListRef<app_PluginInputDefinition> >(getter,setter));
    }
    {
      void (app_Plugin::*setter)(const grt::StringRef &)= &app_Plugin::moduleFunctionName;
      grt::StringRef (app_Plugin::*getter)() const= &app_Plugin::moduleFunctionName;
      meta->bind_member("moduleFunctionName", new grt::MetaClass::Property<app_Plugin,grt::StringRef >(getter,setter));
    }
    {
      void (app_Plugin::*setter)(const grt::StringRef &)= &app_Plugin::moduleName;
      grt::StringRef (app_Plugin::*getter)() const= &app_Plugin::moduleName;
      meta->bind_member("moduleName", new grt::MetaClass::Property<app_Plugin,grt::StringRef >(getter,setter));
    }
    {
      void (app_Plugin::*setter)(const grt::StringRef &)= &app_Plugin::pluginType;
      grt::StringRef (app_Plugin::*getter)() const= &app_Plugin::pluginType;
      meta->bind_member("pluginType", new grt::MetaClass::Property<app_Plugin,grt::StringRef >(getter,setter));
    }
    {
      void (app_Plugin::*setter)(const grt::IntegerRef &)= &app_Plugin::rating;
      grt::IntegerRef (app_Plugin::*getter)() const= &app_Plugin::rating;
      meta->bind_member("rating", new grt::MetaClass::Property<app_Plugin,grt::IntegerRef >(getter,setter));
    }
    {
      void (app_Plugin::*setter)(const grt::IntegerRef &)= &app_Plugin::showProgress;
      grt::IntegerRef (app_Plugin::*getter)() const= &app_Plugin::showProgress;
      meta->bind_member("showProgress", new grt::MetaClass::Property<app_Plugin,grt::IntegerRef >(getter,setter));
    }
  }
};


class  app_DocumentPlugin : public app_Plugin
{
  typedef app_Plugin super;
public:
  app_DocumentPlugin(grt::GRT *grt, grt::MetaClass *meta=0)
  : app_Plugin(grt, meta ? meta : grt->get_metaclass(static_class_name()))

  {
    _documentStructNames.content().__retype(grt::ObjectType, "");
  }

  static std::string static_class_name() { return "app.DocumentPlugin"; }

private: // the next attribute is read-only
public:

protected:

private: // wrapper methods for use by grt
  static grt::ObjectRef create(grt::GRT *grt)
  {
    return grt::ObjectRef(new app_DocumentPlugin(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(&app_DocumentPlugin::create);
    {
      void (app_DocumentPlugin::*setter)(const grt::StringListRef &)= 0;
      grt::StringListRef (app_DocumentPlugin::*getter)() const= 0;
      meta->bind_member("documentStructNames", new grt::MetaClass::Property<app_DocumentPlugin,grt::StringListRef >(getter,setter));
    }
  }
};


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

  {
  }

  static std::string static_class_name() { return "app.PluginGroup"; }

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

  // plugins is owned by app_PluginGroup
  grt::ListRef<app_Plugin> plugins() const { return _plugins; }
private: // the next attribute is read-only
  virtual void plugins(const grt::ListRef<app_Plugin> &value)
  {
    grt::ValueRef ovalue(_plugins);

    _plugins= value;
    owned_member_changed("plugins", ovalue, value);
  }
public:

protected:

  grt::StringRef _category;
  grt::ListRef<app_Plugin> _plugins;// owned
private: // wrapper methods for use by grt
  static grt::ObjectRef create(grt::GRT *grt)
  {
    return grt::ObjectRef(new app_PluginGroup(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(&app_PluginGroup::create);
    {
      void (app_PluginGroup::*setter)(const grt::StringRef &)= &app_PluginGroup::category;
      grt::StringRef (app_PluginGroup::*getter)() const= &app_PluginGroup::category;
      meta->bind_member("category", new grt::MetaClass::Property<app_PluginGroup,grt::StringRef >(getter,setter));
    }
    {
      void (app_PluginGroup::*setter)(const grt::ListRef<app_Plugin> &)= &app_PluginGroup::plugins;
      grt::ListRef<app_Plugin> (app_PluginGroup::*getter)() const= &app_PluginGroup::plugins;
      meta->bind_member("plugins", new grt::MetaClass::Property<app_PluginGroup,grt::ListRef<app_Plugin> >(getter,setter));
    }
  }
};


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

  {
  }

  static std::string static_class_name() { return "app.Toolbar"; }

  // items is owned by app_Toolbar
  grt::ListRef<app_ToolbarItem> items() const { return _items; }
private: // the next attribute is read-only
  virtual void items(const grt::ListRef<app_ToolbarItem> &value)
  {
    grt::ValueRef ovalue(_items);

    _items= value;
    owned_member_changed("items", ovalue, value);
  }
public:

protected:

  grt::ListRef<app_ToolbarItem> _items;// owned
private: // wrapper methods for use by grt
  static grt::ObjectRef create(grt::GRT *grt)
  {
    return grt::ObjectRef(new app_Toolbar(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(&app_Toolbar::create);
    {
      void (app_Toolbar::*setter)(const grt::ListRef<app_ToolbarItem> &)= &app_Toolbar::items;
      grt::ListRef<app_ToolbarItem> (app_Toolbar::*getter)() const= &app_Toolbar::items;
      meta->bind_member("items", new grt::MetaClass::Property<app_Toolbar,grt::ListRef<app_ToolbarItem> >(getter,setter));
    }
  }
};


class  app_CommandItem : public GrtObject
{
  typedef GrtObject super;
public:
  app_CommandItem(grt::GRT *grt, grt::MetaClass *meta=0)
  : GrtObject(grt, meta ? meta : grt->get_metaclass(static_class_name())),
     _command(""),
     _context(""),
     _platform("")

  {
  }

  static std::string static_class_name() { return "app.CommandItem"; }

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

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

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

protected:

  grt::StringRef _command;
  grt::StringRef _context;
  grt::StringRef _platform;
private: // wrapper methods for use by grt
  static grt::ObjectRef create(grt::GRT *grt)
  {
    return grt::ObjectRef(new app_CommandItem(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(&app_CommandItem::create);
    {
      void (app_CommandItem::*setter)(const grt::StringRef &)= &app_CommandItem::command;
      grt::StringRef (app_CommandItem::*getter)() const= &app_CommandItem::command;
      meta->bind_member("command", new grt::MetaClass::Property<app_CommandItem,grt::StringRef >(getter,setter));
    }
    {
      void (app_CommandItem::*setter)(const grt::StringRef &)= &app_CommandItem::context;
      grt::StringRef (app_CommandItem::*getter)() const= &app_CommandItem::context;
      meta->bind_member("context", new grt::MetaClass::Property<app_CommandItem,grt::StringRef >(getter,setter));
    }
    {
      void (app_CommandItem::*setter)(const grt::StringRef &)= &app_CommandItem::platform;
      grt::StringRef (app_CommandItem::*getter)() const= &app_CommandItem::platform;
      meta->bind_member("platform", new grt::MetaClass::Property<app_CommandItem,grt::StringRef >(getter,setter));
    }
  }
};


class  app_ToolbarItem : public app_CommandItem
{
  typedef app_CommandItem super;
public:
  app_ToolbarItem(grt::GRT *grt, grt::MetaClass *meta=0)
  : app_CommandItem(grt, meta ? meta : grt->get_metaclass(static_class_name())),
     _altIcon(""),
     _icon(""),
     _itemType(""),
     _tooltip("")

  {
  }

  static std::string static_class_name() { return "app.ToolbarItem"; }

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

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

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

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

protected:

  grt::StringRef _altIcon;
  grt::StringRef _icon;
  grt::StringRef _itemType;
  grt::StringRef _tooltip;
private: // wrapper methods for use by grt
  static grt::ObjectRef create(grt::GRT *grt)
  {
    return grt::ObjectRef(new app_ToolbarItem(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(&app_ToolbarItem::create);
    {
      void (app_ToolbarItem::*setter)(const grt::StringRef &)= &app_ToolbarItem::altIcon;
      grt::StringRef (app_ToolbarItem::*getter)() const= &app_ToolbarItem::altIcon;
      meta->bind_member("altIcon", new grt::MetaClass::Property<app_ToolbarItem,grt::StringRef >(getter,setter));
    }
    {
      void (app_ToolbarItem::*setter)(const grt::StringRef &)= &app_ToolbarItem::icon;
      grt::StringRef (app_ToolbarItem::*getter)() const= &app_ToolbarItem::icon;
      meta->bind_member("icon", new grt::MetaClass::Property<app_ToolbarItem,grt::StringRef >(getter,setter));
    }
    {
      void (app_ToolbarItem::*setter)(const grt::StringRef &)= &app_ToolbarItem::itemType;
      grt::StringRef (app_ToolbarItem::*getter)() const= &app_ToolbarItem::itemType;
      meta->bind_member("itemType", new grt::MetaClass::Property<app_ToolbarItem,grt::StringRef >(getter,setter));
    }
    {
      void (app_ToolbarItem::*setter)(const grt::StringRef &)= &app_ToolbarItem::tooltip;
      grt::StringRef (app_ToolbarItem::*getter)() const= &app_ToolbarItem::tooltip;
      meta->bind_member("tooltip", new grt::MetaClass::Property<app_ToolbarItem,grt::StringRef >(getter,setter));
    }
  }
};


class  app_ShortcutItem : public app_CommandItem
{
  typedef app_CommandItem super;
public:
  app_ShortcutItem(grt::GRT *grt, grt::MetaClass *meta=0)
  : app_CommandItem(grt, meta ? meta : grt->get_metaclass(static_class_name())),
     _shortcut("")

  {
  }

  static std::string static_class_name() { return "app.ShortcutItem"; }

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

protected:

  grt::StringRef _shortcut;
private: // wrapper methods for use by grt
  static grt::ObjectRef create(grt::GRT *grt)
  {
    return grt::ObjectRef(new app_ShortcutItem(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(&app_ShortcutItem::create);
    {
      void (app_ShortcutItem::*setter)(const grt::StringRef &)= &app_ShortcutItem::shortcut;
      grt::StringRef (app_ShortcutItem::*getter)() const= &app_ShortcutItem::shortcut;
      meta->bind_member("shortcut", new grt::MetaClass::Property<app_ShortcutItem,grt::StringRef >(getter,setter));
    }
  }
};


class  app_MenuItem : public app_CommandItem
{
  typedef app_CommandItem super;
public:
  app_MenuItem(grt::GRT *grt, grt::MetaClass *meta=0)
  : app_CommandItem(grt, meta ? meta : grt->get_metaclass(static_class_name())),
     _caption(""),
     _itemType(""),
     _shortcut(""),
    _subItems(grt, this, false)

  {
  }

  static std::string static_class_name() { return "app.MenuItem"; }

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

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

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

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

    _subItems= value;
    owned_member_changed("subItems", ovalue, value);
  }
public:

protected:

  grt::StringRef _caption;
  grt::StringRef _itemType;
  grt::StringRef _shortcut;
  grt::ListRef<app_MenuItem> _subItems;// owned
private: // wrapper methods for use by grt
  static grt::ObjectRef create(grt::GRT *grt)
  {
    return grt::ObjectRef(new app_MenuItem(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(&app_MenuItem::create);
    {
      void (app_MenuItem::*setter)(const grt::StringRef &)= &app_MenuItem::caption;
      grt::StringRef (app_MenuItem::*getter)() const= &app_MenuItem::caption;
      meta->bind_member("caption", new grt::MetaClass::Property<app_MenuItem,grt::StringRef >(getter,setter));
    }
    {
      void (app_MenuItem::*setter)(const grt::StringRef &)= &app_MenuItem::itemType;
      grt::StringRef (app_MenuItem::*getter)() const= &app_MenuItem::itemType;
      meta->bind_member("itemType", new grt::MetaClass::Property<app_MenuItem,grt::StringRef >(getter,setter));
    }
    {
      void (app_MenuItem::*setter)(const grt::StringRef &)= &app_MenuItem::shortcut;
      grt::StringRef (app_MenuItem::*getter)() const= &app_MenuItem::shortcut;
      meta->bind_member("shortcut", new grt::MetaClass::Property<app_MenuItem,grt::StringRef >(getter,setter));
    }
    {
      void (app_MenuItem::*setter)(const grt::ListRef<app_MenuItem> &)= &app_MenuItem::subItems;
      grt::ListRef<app_MenuItem> (app_MenuItem::*getter)() const= &app_MenuItem::subItems;
      meta->bind_member("subItems", new grt::MetaClass::Property<app_MenuItem,grt::ListRef<app_MenuItem> >(getter,setter));
    }
  }
};


class  app_CustomDataField : public GrtObject
{
  typedef GrtObject super;
public:
  app_CustomDataField(grt::GRT *grt, grt::MetaClass *meta=0)
  : GrtObject(grt, meta ? meta : grt->get_metaclass(static_class_name())),
     _defaultValue(""),
     _description(""),
     _objectStruct(""),
     _type("")

  {
  }

  static std::string static_class_name() { return "app.CustomDataField"; }

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

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

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

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

protected:

  grt::StringRef _defaultValue;
  grt::StringRef _description;
  grt::StringRef _objectStruct;
  grt::StringRef _type;
private: // wrapper methods for use by grt
  static grt::ObjectRef create(grt::GRT *grt)
  {
    return grt::ObjectRef(new app_CustomDataField(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(&app_CustomDataField::create);
    {
      void (app_CustomDataField::*setter)(const grt::StringRef &)= &app_CustomDataField::defaultValue;
      grt::StringRef (app_CustomDataField::*getter)() const= &app_CustomDataField::defaultValue;
      meta->bind_member("defaultValue", new grt::MetaClass::Property<app_CustomDataField,grt::StringRef >(getter,setter));
    }
    {
      void (app_CustomDataField::*setter)(const grt::StringRef &)= &app_CustomDataField::description;
      grt::StringRef (app_CustomDataField::*getter)() const= &app_CustomDataField::description;
      meta->bind_member("description", new grt::MetaClass::Property<app_CustomDataField,grt::StringRef >(getter,setter));
    }
    {
      void (app_CustomDataField::*setter)(const grt::StringRef &)= &app_CustomDataField::objectStruct;
      grt::StringRef (app_CustomDataField::*getter)() const= &app_CustomDataField::objectStruct;
      meta->bind_member("objectStruct", new grt::MetaClass::Property<app_CustomDataField,grt::StringRef >(getter,setter));
    }
    {
      void (app_CustomDataField::*setter)(const grt::StringRef &)= &app_CustomDataField::type;
      grt::StringRef (app_CustomDataField::*getter)() const= &app_CustomDataField::type;
      meta->bind_member("type", new grt::MetaClass::Property<app_CustomDataField,grt::StringRef >(getter,setter));
    }
  }
};


class  app_PageSettings : public GrtObject
{
  typedef GrtObject super;
public:
  app_PageSettings(grt::GRT *grt, grt::MetaClass *meta=0)
  : GrtObject(grt, meta ? meta : grt->get_metaclass(static_class_name())),
     _marginBottom(0.0),
     _marginLeft(0.0),
     _marginRight(0.0),
     _marginTop(0.0),
     _orientation(""),
     _scale(5)

  {
  }

  static std::string static_class_name() { return "app.PageSettings"; }

  grt::DoubleRef marginBottom() const { return _marginBottom; }
  virtual void marginBottom(const grt::DoubleRef &value)
  {
    grt::ValueRef ovalue(_marginBottom);
   _marginBottom= value;
    member_changed("marginBottom", ovalue, value);
  }

  grt::DoubleRef marginLeft() const { return _marginLeft; }
  virtual void marginLeft(const grt::DoubleRef &value)
  {
    grt::ValueRef ovalue(_marginLeft);
   _marginLeft= value;
    member_changed("marginLeft", ovalue, value);
  }

  grt::DoubleRef marginRight() const { return _marginRight; }
  virtual void marginRight(const grt::DoubleRef &value)
  {
    grt::ValueRef ovalue(_marginRight);
   _marginRight= value;
    member_changed("marginRight", ovalue, value);
  }

  grt::DoubleRef marginTop() const { return _marginTop; }
  virtual void marginTop(const grt::DoubleRef &value)
  {
    grt::ValueRef ovalue(_marginTop);
   _marginTop= value;
    member_changed("marginTop", ovalue, value);
  }

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

  app_PaperTypeRef paperType() const { return _paperType; }
  virtual void paperType(const app_PaperTypeRef &value)
  {
    grt::ValueRef ovalue(_paperType);
   _paperType= value;
    member_changed("paperType", ovalue, value);
  }

  grt::DoubleRef scale() const { return _scale; }
  virtual void scale(const grt::DoubleRef &value)
  {
    grt::ValueRef ovalue(_scale);
   _scale= value;
    member_changed("scale", ovalue, value);
  }

protected:

  grt::DoubleRef _marginBottom;
  grt::DoubleRef _marginLeft;
  grt::DoubleRef _marginRight;
  grt::DoubleRef _marginTop;
  grt::StringRef _orientation;
  app_PaperTypeRef _paperType;
  grt::DoubleRef _scale;
private: // wrapper methods for use by grt
  static grt::ObjectRef create(grt::GRT *grt)
  {
    return grt::ObjectRef(new app_PageSettings(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(&app_PageSettings::create);
    {
      void (app_PageSettings::*setter)(const grt::DoubleRef &)= &app_PageSettings::marginBottom;
      grt::DoubleRef (app_PageSettings::*getter)() const= &app_PageSettings::marginBottom;
      meta->bind_member("marginBottom", new grt::MetaClass::Property<app_PageSettings,grt::DoubleRef >(getter,setter));
    }
    {
      void (app_PageSettings::*setter)(const grt::DoubleRef &)= &app_PageSettings::marginLeft;
      grt::DoubleRef (app_PageSettings::*getter)() const= &app_PageSettings::marginLeft;
      meta->bind_member("marginLeft", new grt::MetaClass::Property<app_PageSettings,grt::DoubleRef >(getter,setter));
    }
    {
      void (app_PageSettings::*setter)(const grt::DoubleRef &)= &app_PageSettings::marginRight;
      grt::DoubleRef (app_PageSettings::*getter)() const= &app_PageSettings::marginRight;
      meta->bind_member("marginRight", new grt::MetaClass::Property<app_PageSettings,grt::DoubleRef >(getter,setter));
    }
    {
      void (app_PageSettings::*setter)(const grt::DoubleRef &)= &app_PageSettings::marginTop;
      grt::DoubleRef (app_PageSettings::*getter)() const= &app_PageSettings::marginTop;
      meta->bind_member("marginTop", new grt::MetaClass::Property<app_PageSettings,grt::DoubleRef >(getter,setter));
    }
    {
      void (app_PageSettings::*setter)(const grt::StringRef &)= &app_PageSettings::orientation;
      grt::StringRef (app_PageSettings::*getter)() const= &app_PageSettings::orientation;
      meta->bind_member("orientation", new grt::MetaClass::Property<app_PageSettings,grt::StringRef >(getter,setter));
    }
    {
      void (app_PageSettings::*setter)(const app_PaperTypeRef &)= &app_PageSettings::paperType;
      app_PaperTypeRef (app_PageSettings::*getter)() const= &app_PageSettings::paperType;
      meta->bind_member("paperType", new grt::MetaClass::Property<app_PageSettings,app_PaperTypeRef >(getter,setter));
    }
    {
      void (app_PageSettings::*setter)(const grt::DoubleRef &)= &app_PageSettings::scale;
      grt::DoubleRef (app_PageSettings::*getter)() const= &app_PageSettings::scale;
      meta->bind_member("scale", new grt::MetaClass::Property<app_PageSettings,grt::DoubleRef >(getter,setter));
    }
  }
};


class  app_PaperType : public GrtObject
{
  typedef GrtObject super;
public:
  app_PaperType(grt::GRT *grt, grt::MetaClass *meta=0)
  : GrtObject(grt, meta ? meta : grt->get_metaclass(static_class_name())),
     _caption(""),
     _height(0.0),
     _marginBottom(0.0),
     _marginLeft(0.0),
     _marginRight(0.0),
     _marginTop(0.0),
     _marginsSet(0),
     _width(0.0)

  {
  }

  static std::string static_class_name() { return "app.PaperType"; }

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

  grt::DoubleRef height() const { return _height; }
  virtual void height(const grt::DoubleRef &value)
  {
    grt::ValueRef ovalue(_height);
   _height= value;
    member_changed("height", ovalue, value);
  }

  grt::DoubleRef marginBottom() const { return _marginBottom; }
  virtual void marginBottom(const grt::DoubleRef &value)
  {
    grt::ValueRef ovalue(_marginBottom);
   _marginBottom= value;
    member_changed("marginBottom", ovalue, value);
  }

  grt::DoubleRef marginLeft() const { return _marginLeft; }
  virtual void marginLeft(const grt::DoubleRef &value)
  {
    grt::ValueRef ovalue(_marginLeft);
   _marginLeft= value;
    member_changed("marginLeft", ovalue, value);
  }

  grt::DoubleRef marginRight() const { return _marginRight; }
  virtual void marginRight(const grt::DoubleRef &value)
  {
    grt::ValueRef ovalue(_marginRight);
   _marginRight= value;
    member_changed("marginRight", ovalue, value);
  }

  grt::DoubleRef marginTop() const { return _marginTop; }
  virtual void marginTop(const grt::DoubleRef &value)
  {
    grt::ValueRef ovalue(_marginTop);
   _marginTop= value;
    member_changed("marginTop", ovalue, value);
  }

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

  grt::DoubleRef width() const { return _width; }
  virtual void width(const grt::DoubleRef &value)
  {
    grt::ValueRef ovalue(_width);
   _width= value;
    member_changed("width", ovalue, value);
  }

protected:

  grt::StringRef _caption;
  grt::DoubleRef _height;
  grt::DoubleRef _marginBottom;
  grt::DoubleRef _marginLeft;
  grt::DoubleRef _marginRight;
  grt::DoubleRef _marginTop;
  grt::IntegerRef _marginsSet;
  grt::DoubleRef _width;
private: // wrapper methods for use by grt
  static grt::ObjectRef create(grt::GRT *grt)
  {
    return grt::ObjectRef(new app_PaperType(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(&app_PaperType::create);
    {
      void (app_PaperType::*setter)(const grt::StringRef &)= &app_PaperType::caption;
      grt::StringRef (app_PaperType::*getter)() const= &app_PaperType::caption;
      meta->bind_member("caption", new grt::MetaClass::Property<app_PaperType,grt::StringRef >(getter,setter));
    }
    {
      void (app_PaperType::*setter)(const grt::DoubleRef &)= &app_PaperType::height;
      grt::DoubleRef (app_PaperType::*getter)() const= &app_PaperType::height;
      meta->bind_member("height", new grt::MetaClass::Property<app_PaperType,grt::DoubleRef >(getter,setter));
    }
    {
      void (app_PaperType::*setter)(const grt::DoubleRef &)= &app_PaperType::marginBottom;
      grt::DoubleRef (app_PaperType::*getter)() const= &app_PaperType::marginBottom;
      meta->bind_member("marginBottom", new grt::MetaClass::Property<app_PaperType,grt::DoubleRef >(getter,setter));
    }
    {
      void (app_PaperType::*setter)(const grt::DoubleRef &)= &app_PaperType::marginLeft;
      grt::DoubleRef (app_PaperType::*getter)() const= &app_PaperType::marginLeft;
      meta->bind_member("marginLeft", new grt::MetaClass::Property<app_PaperType,grt::DoubleRef >(getter,setter));
    }
    {
      void (app_PaperType::*setter)(const grt::DoubleRef &)= &app_PaperType::marginRight;
      grt::DoubleRef (app_PaperType::*getter)() const= &app_PaperType::marginRight;
      meta->bind_member("marginRight", new grt::MetaClass::Property<app_PaperType,grt::DoubleRef >(getter,setter));
    }
    {
      void (app_PaperType::*setter)(const grt::DoubleRef &)= &app_PaperType::marginTop;
      grt::DoubleRef (app_PaperType::*getter)() const= &app_PaperType::marginTop;
      meta->bind_member("marginTop", new grt::MetaClass::Property<app_PaperType,grt::DoubleRef >(getter,setter));
    }
    {
      void (app_PaperType::*setter)(const grt::IntegerRef &)= &app_PaperType::marginsSet;
      grt::IntegerRef (app_PaperType::*getter)() const= &app_PaperType::marginsSet;
      meta->bind_member("marginsSet", new grt::MetaClass::Property<app_PaperType,grt::IntegerRef >(getter,setter));
    }
    {
      void (app_PaperType::*setter)(const grt::DoubleRef &)= &app_PaperType::width;
      grt::DoubleRef (app_PaperType::*getter)() const= &app_PaperType::width;
      meta->bind_member("width", new grt::MetaClass::Property<app_PaperType,grt::DoubleRef >(getter,setter));
    }
  }
};


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

  {
  }

  static std::string static_class_name() { return "app.Registry"; }

  // customDataFields is owned by app_Registry
  grt::ListRef<app_CustomDataField> customDataFields() const { return _customDataFields; }
private: // the next attribute is read-only
  virtual void customDataFields(const grt::ListRef<app_CustomDataField> &value)
  {
    grt::ValueRef ovalue(_customDataFields);

    _customDataFields= value;
    owned_member_changed("customDataFields", ovalue, value);
  }
public:

  // pluginGroups is owned by app_Registry
  grt::ListRef<app_PluginGroup> pluginGroups() const { return _pluginGroups; }
private: // the next attribute is read-only
  virtual void pluginGroups(const grt::ListRef<app_PluginGroup> &value)
  {
    grt::ValueRef ovalue(_pluginGroups);

    _pluginGroups= value;
    owned_member_changed("pluginGroups", ovalue, value);
  }
public:

  // plugins is owned by app_Registry
  grt::ListRef<app_Plugin> plugins() const { return _plugins; }
private: // the next attribute is read-only
  virtual void plugins(const grt::ListRef<app_Plugin> &value)
  {
    grt::ValueRef ovalue(_plugins);

    _plugins= value;
    owned_member_changed("plugins", ovalue, value);
  }
public:

protected:

  grt::ListRef<app_CustomDataField> _customDataFields;// owned
  grt::ListRef<app_PluginGroup> _pluginGroups;// owned
  grt::ListRef<app_Plugin> _plugins;// owned
private: // wrapper methods for use by grt
  static grt::ObjectRef create(grt::GRT *grt)
  {
    return grt::ObjectRef(new app_Registry(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(&app_Registry::create);
    {
      void (app_Registry::*setter)(const grt::ListRef<app_CustomDataField> &)= &app_Registry::customDataFields;
      grt::ListRef<app_CustomDataField> (app_Registry::*getter)() const= &app_Registry::customDataFields;
      meta->bind_member("customDataFields", new grt::MetaClass::Property<app_Registry,grt::ListRef<app_CustomDataField> >(getter,setter));
    }
    {
      void (app_Registry::*setter)(const grt::ListRef<app_PluginGroup> &)= &app_Registry::pluginGroups;
      grt::ListRef<app_PluginGroup> (app_Registry::*getter)() const= &app_Registry::pluginGroups;
      meta->bind_member("pluginGroups", new grt::MetaClass::Property<app_Registry,grt::ListRef<app_PluginGroup> >(getter,setter));
    }
    {
      void (app_Registry::*setter)(const grt::ListRef<app_Plugin> &)= &app_Registry::plugins;
      grt::ListRef<app_Plugin> (app_Registry::*getter)() const= &app_Registry::plugins;
      meta->bind_member("plugins", new grt::MetaClass::Property<app_Registry,grt::ListRef<app_Plugin> >(getter,setter));
    }
  }
};


class  app_Starter : public GrtObject
{
  typedef GrtObject super;
public:
  app_Starter(grt::GRT *grt, grt::MetaClass *meta=0)
  : GrtObject(grt, meta ? meta : grt->get_metaclass(static_class_name())),
     _authorHome(""),
     _command(""),
     _description(""),
     _largeIcon(""),
     _publisher(""),
     _smallIcon("0"),
     _title(""),
     _type("")

  {
  }

  static std::string static_class_name() { return "app.Starter"; }

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

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

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

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

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

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

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

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

protected:

  grt::StringRef _authorHome;
  grt::StringRef _command;
  grt::StringRef _description;
  grt::StringRef _largeIcon;
  grt::StringRef _publisher;
  grt::StringRef _smallIcon;
  grt::StringRef _title;
  grt::StringRef _type;
private: // wrapper methods for use by grt
  static grt::ObjectRef create(grt::GRT *grt)
  {
    return grt::ObjectRef(new app_Starter(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(&app_Starter::create);
    {
      void (app_Starter::*setter)(const grt::StringRef &)= &app_Starter::authorHome;
      grt::StringRef (app_Starter::*getter)() const= &app_Starter::authorHome;
      meta->bind_member("authorHome", new grt::MetaClass::Property<app_Starter,grt::StringRef >(getter,setter));
    }
    {
      void (app_Starter::*setter)(const grt::StringRef &)= &app_Starter::command;
      grt::StringRef (app_Starter::*getter)() const= &app_Starter::command;
      meta->bind_member("command", new grt::MetaClass::Property<app_Starter,grt::StringRef >(getter,setter));
    }
    {
      void (app_Starter::*setter)(const grt::StringRef &)= &app_Starter::description;
      grt::StringRef (app_Starter::*getter)() const= &app_Starter::description;
      meta->bind_member("description", new grt::MetaClass::Property<app_Starter,grt::StringRef >(getter,setter));
    }
    {
      void (app_Starter::*setter)(const grt::StringRef &)= &app_Starter::largeIcon;
      grt::StringRef (app_Starter::*getter)() const= &app_Starter::largeIcon;
      meta->bind_member("largeIcon", new grt::MetaClass::Property<app_Starter,grt::StringRef >(getter,setter));
    }
    {
      void (app_Starter::*setter)(const grt::StringRef &)= &app_Starter::publisher;
      grt::StringRef (app_Starter::*getter)() const= &app_Starter::publisher;
      meta->bind_member("publisher", new grt::MetaClass::Property<app_Starter,grt::StringRef >(getter,setter));
    }
    {
      void (app_Starter::*setter)(const grt::StringRef &)= &app_Starter::smallIcon;
      grt::StringRef (app_Starter::*getter)() const= &app_Starter::smallIcon;
      meta->bind_member("smallIcon", new grt::MetaClass::Property<app_Starter,grt::StringRef >(getter,setter));
    }
    {
      void (app_Starter::*setter)(const grt::StringRef &)= &app_Starter::title;
      grt::StringRef (app_Starter::*getter)() const= &app_Starter::title;
      meta->bind_member("title", new grt::MetaClass::Property<app_Starter,grt::StringRef >(getter,setter));
    }
    {
      void (app_Starter::*setter)(const grt::StringRef &)= &app_Starter::type;
      grt::StringRef (app_Starter::*getter)() const= &app_Starter::type;
      meta->bind_member("type", new grt::MetaClass::Property<app_Starter,grt::StringRef >(getter,setter));
    }
  }
};


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

  {
  }

  static std::string static_class_name() { return "app.Starters"; }

  // custom is owned by app_Starters
  grt::ListRef<app_Starter> custom() const { return _custom; }
private: // the next attribute is read-only
  virtual void custom(const grt::ListRef<app_Starter> &value)
  {
    grt::ValueRef ovalue(_custom);

    _custom= value;
    owned_member_changed("custom", ovalue, value);
  }
public:

  grt::ListRef<app_Starter> displayList() const { return _displayList; }
private: // the next attribute is read-only
  virtual void displayList(const grt::ListRef<app_Starter> &value)
  {
    grt::ValueRef ovalue(_displayList);
   _displayList= value;
    member_changed("displayList", ovalue, value);
  }
public:

  // predefined is owned by app_Starters
  grt::ListRef<app_Starter> predefined() const { return _predefined; }
private: // the next attribute is read-only
  virtual void predefined(const grt::ListRef<app_Starter> &value)
  {
    grt::ValueRef ovalue(_predefined);

    _predefined= value;
    owned_member_changed("predefined", ovalue, value);
  }
public:

protected:

  grt::ListRef<app_Starter> _custom;// owned
  grt::ListRef<app_Starter> _displayList;
  grt::ListRef<app_Starter> _predefined;// owned
private: // wrapper methods for use by grt
  static grt::ObjectRef create(grt::GRT *grt)
  {
    return grt::ObjectRef(new app_Starters(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(&app_Starters::create);
    {
      void (app_Starters::*setter)(const grt::ListRef<app_Starter> &)= &app_Starters::custom;
      grt::ListRef<app_Starter> (app_Starters::*getter)() const= &app_Starters::custom;
      meta->bind_member("custom", new grt::MetaClass::Property<app_Starters,grt::ListRef<app_Starter> >(getter,setter));
    }
    {
      void (app_Starters::*setter)(const grt::ListRef<app_Starter> &)= &app_Starters::displayList;
      grt::ListRef<app_Starter> (app_Starters::*getter)() const= &app_Starters::displayList;
      meta->bind_member("displayList", new grt::MetaClass::Property<app_Starters,grt::ListRef<app_Starter> >(getter,setter));
    }
    {
      void (app_Starters::*setter)(const grt::ListRef<app_Starter> &)= &app_Starters::predefined;
      grt::ListRef<app_Starter> (app_Starters::*getter)() const= &app_Starters::predefined;
      meta->bind_member("predefined", new grt::MetaClass::Property<app_Starters,grt::ListRef<app_Starter> >(getter,setter));
    }
  }
};


class  app_Options : public GrtObject
{
  typedef GrtObject super;
public:
  app_Options(grt::GRT *grt, grt::MetaClass *meta=0)
  : GrtObject(grt, meta ? meta : grt->get_metaclass(static_class_name())),
    _commonOptions(grt, this, false),
    _options(grt, this, false),
    _paperTypes(grt, this, false),
    _recentFiles(grt, this, false)

  {
  }

  static std::string static_class_name() { return "app.Options"; }

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

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

  // paperTypes is owned by app_Options
  grt::ListRef<app_PaperType> paperTypes() const { return _paperTypes; }
private: // the next attribute is read-only
  virtual void paperTypes(const grt::ListRef<app_PaperType> &value)
  {
    grt::ValueRef ovalue(_paperTypes);

    _paperTypes= value;
    owned_member_changed("paperTypes", ovalue, value);
  }
public:

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

protected:

  grt::DictRef _commonOptions;
  grt::DictRef _options;
  grt::ListRef<app_PaperType> _paperTypes;// owned
  grt::StringListRef _recentFiles;
private: // wrapper methods for use by grt
  static grt::ObjectRef create(grt::GRT *grt)
  {
    return grt::ObjectRef(new app_Options(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(&app_Options::create);
    {
      void (app_Options::*setter)(const grt::DictRef &)= &app_Options::commonOptions;
      grt::DictRef (app_Options::*getter)() const= &app_Options::commonOptions;
      meta->bind_member("commonOptions", new grt::MetaClass::Property<app_Options,grt::DictRef >(getter,setter));
    }
    {
      void (app_Options::*setter)(const grt::DictRef &)= &app_Options::options;
      grt::DictRef (app_Options::*getter)() const= &app_Options::options;
      meta->bind_member("options", new grt::MetaClass::Property<app_Options,grt::DictRef >(getter,setter));
    }
    {
      void (app_Options::*setter)(const grt::ListRef<app_PaperType> &)= &app_Options::paperTypes;
      grt::ListRef<app_PaperType> (app_Options::*getter)() const= &app_Options::paperTypes;
      meta->bind_member("paperTypes", new grt::MetaClass::Property<app_Options,grt::ListRef<app_PaperType> >(getter,setter));
    }
    {
      void (app_Options::*setter)(const grt::StringListRef &)= &app_Options::recentFiles;
      grt::StringListRef (app_Options::*getter)() const= &app_Options::recentFiles;
      meta->bind_member("recentFiles", new grt::MetaClass::Property<app_Options,grt::StringListRef >(getter,setter));
    }
  }
};


class  app_DocumentInfo : public GrtObject
{
  typedef GrtObject super;
public:
  app_DocumentInfo(grt::GRT *grt, grt::MetaClass *meta=0)
  : GrtObject(grt, meta ? meta : grt->get_metaclass(static_class_name())),
     _author(""),
     _caption(""),
     _dateChanged(""),
     _dateCreated(""),
     _description(""),
     _project(""),
     _version("")

  {
  }

  static std::string static_class_name() { return "app.DocumentInfo"; }

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

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

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

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

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

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

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

protected:

  grt::StringRef _author;
  grt::StringRef _caption;
  grt::StringRef _dateChanged;
  grt::StringRef _dateCreated;
  grt::StringRef _description;
  grt::StringRef _project;
  grt::StringRef _version;
private: // wrapper methods for use by grt
  static grt::ObjectRef create(grt::GRT *grt)
  {
    return grt::ObjectRef(new app_DocumentInfo(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(&app_DocumentInfo::create);
    {
      void (app_DocumentInfo::*setter)(const grt::StringRef &)= &app_DocumentInfo::author;
      grt::StringRef (app_DocumentInfo::*getter)() const= &app_DocumentInfo::author;
      meta->bind_member("author", new grt::MetaClass::Property<app_DocumentInfo,grt::StringRef >(getter,setter));
    }
    {
      void (app_DocumentInfo::*setter)(const grt::StringRef &)= &app_DocumentInfo::caption;
      grt::StringRef (app_DocumentInfo::*getter)() const= &app_DocumentInfo::caption;
      meta->bind_member("caption", new grt::MetaClass::Property<app_DocumentInfo,grt::StringRef >(getter,setter));
    }
    {
      void (app_DocumentInfo::*setter)(const grt::StringRef &)= &app_DocumentInfo::dateChanged;
      grt::StringRef (app_DocumentInfo::*getter)() const= &app_DocumentInfo::dateChanged;
      meta->bind_member("dateChanged", new grt::MetaClass::Property<app_DocumentInfo,grt::StringRef >(getter,setter));
    }
    {
      void (app_DocumentInfo::*setter)(const grt::StringRef &)= &app_DocumentInfo::dateCreated;
      grt::StringRef (app_DocumentInfo::*getter)() const= &app_DocumentInfo::dateCreated;
      meta->bind_member("dateCreated", new grt::MetaClass::Property<app_DocumentInfo,grt::StringRef >(getter,setter));
    }
    {
      void (app_DocumentInfo::*setter)(const grt::StringRef &)= &app_DocumentInfo::description;
      grt::StringRef (app_DocumentInfo::*getter)() const= &app_DocumentInfo::description;
      meta->bind_member("description", new grt::MetaClass::Property<app_DocumentInfo,grt::StringRef >(getter,setter));
    }
    {
      void (app_DocumentInfo::*setter)(const grt::StringRef &)= &app_DocumentInfo::project;
      grt::StringRef (app_DocumentInfo::*getter)() const= &app_DocumentInfo::project;
      meta->bind_member("project", new grt::MetaClass::Property<app_DocumentInfo,grt::StringRef >(getter,setter));
    }
    {
      void (app_DocumentInfo::*setter)(const grt::StringRef &)= &app_DocumentInfo::version;
      grt::StringRef (app_DocumentInfo::*getter)() const= &app_DocumentInfo::version;
      meta->bind_member("version", new grt::MetaClass::Property<app_DocumentInfo,grt::StringRef >(getter,setter));
    }
  }
};


class  app_Info : public GrtObject
{
  typedef GrtObject super;
public:
  app_Info(grt::GRT *grt, grt::MetaClass *meta=0)
  : GrtObject(grt, meta ? meta : grt->get_metaclass(static_class_name())),
     _caption(""),
     _copyright(""),
     _description(""),
     _license("")

  {
  }

  static std::string static_class_name() { return "app.Info"; }

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

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

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

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

  // version is owned by app_Info
  GrtVersionRef version() const { return _version; }
  virtual void version(const GrtVersionRef &value)
  {
    grt::ValueRef ovalue(_version);

    _version= value;
    owned_member_changed("version", ovalue, value);
  }

protected:

  grt::StringRef _caption;
  grt::StringRef _copyright;
  grt::StringRef _description;
  grt::StringRef _license;
  GrtVersionRef _version;// owned
private: // wrapper methods for use by grt
  static grt::ObjectRef create(grt::GRT *grt)
  {
    return grt::ObjectRef(new app_Info(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(&app_Info::create);
    {
      void (app_Info::*setter)(const grt::StringRef &)= &app_Info::caption;
      grt::StringRef (app_Info::*getter)() const= &app_Info::caption;
      meta->bind_member("caption", new grt::MetaClass::Property<app_Info,grt::StringRef >(getter,setter));
    }
    {
      void (app_Info::*setter)(const grt::StringRef &)= &app_Info::copyright;
      grt::StringRef (app_Info::*getter)() const= &app_Info::copyright;
      meta->bind_member("copyright", new grt::MetaClass::Property<app_Info,grt::StringRef >(getter,setter));
    }
    {
      void (app_Info::*setter)(const grt::StringRef &)= &app_Info::description;
      grt::StringRef (app_Info::*getter)() const= &app_Info::description;
      meta->bind_member("description", new grt::MetaClass::Property<app_Info,grt::StringRef >(getter,setter));
    }
    {
      void (app_Info::*setter)(const grt::StringRef &)= &app_Info::license;
      grt::StringRef (app_Info::*getter)() const= &app_Info::license;
      meta->bind_member("license", new grt::MetaClass::Property<app_Info,grt::StringRef >(getter,setter));
    }
    {
      void (app_Info::*setter)(const GrtVersionRef &)= &app_Info::version;
      GrtVersionRef (app_Info::*getter)() const= &app_Info::version;
      meta->bind_member("version", new grt::MetaClass::Property<app_Info,GrtVersionRef >(getter,setter));
    }
  }
};


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

  {
  }

  static std::string static_class_name() { return "app.Document"; }

  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:

  // info is owned by app_Document
  app_DocumentInfoRef info() const { return _info; }
  virtual void info(const app_DocumentInfoRef &value)
  {
    grt::ValueRef ovalue(_info);

    _info= value;
    owned_member_changed("info", ovalue, value);
  }

  // pageSettings is owned by app_Document
  app_PageSettingsRef pageSettings() const { return _pageSettings; }
  virtual void pageSettings(const app_PageSettingsRef &value)
  {
    grt::ValueRef ovalue(_pageSettings);

    _pageSettings= value;
    owned_member_changed("pageSettings", ovalue, value);
  }

protected:

  grt::DictRef _customData;
  app_DocumentInfoRef _info;// owned
  app_PageSettingsRef _pageSettings;// owned
private: // wrapper methods for use by grt
  static grt::ObjectRef create(grt::GRT *grt)
  {
    return grt::ObjectRef(new app_Document(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(&app_Document::create);
    {
      void (app_Document::*setter)(const grt::DictRef &)= &app_Document::customData;
      grt::DictRef (app_Document::*getter)() const= &app_Document::customData;
      meta->bind_member("customData", new grt::MetaClass::Property<app_Document,grt::DictRef >(getter,setter));
    }
    {
      void (app_Document::*setter)(const app_DocumentInfoRef &)= &app_Document::info;
      app_DocumentInfoRef (app_Document::*getter)() const= &app_Document::info;
      meta->bind_member("info", new grt::MetaClass::Property<app_Document,app_DocumentInfoRef >(getter,setter));
    }
    {
      void (app_Document::*setter)(const app_PageSettingsRef &)= &app_Document::pageSettings;
      app_PageSettingsRef (app_Document::*getter)() const= &app_Document::pageSettings;
      meta->bind_member("pageSettings", new grt::MetaClass::Property<app_Document,app_PageSettingsRef >(getter,setter));
    }
  }
};


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

  {
  }

  static std::string static_class_name() { return "app.Application"; }

  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:

  // doc is owned by app_Application
  app_DocumentRef doc() const { return _doc; }
  virtual void doc(const app_DocumentRef &value)
  {
    grt::ValueRef ovalue(_doc);

    _doc= value;
    owned_member_changed("doc", ovalue, value);
  }

  app_InfoRef info() const { return _info; }
  virtual void info(const app_InfoRef &value)
  {
    grt::ValueRef ovalue(_info);
   _info= value;
    member_changed("info", ovalue, value);
  }

  app_OptionsRef options() const { return _options; }
  virtual void options(const app_OptionsRef &value)
  {
    grt::ValueRef ovalue(_options);
   _options= value;
    member_changed("options", ovalue, value);
  }

  app_RegistryRef registry() const { return _registry; }
  virtual void registry(const app_RegistryRef &value)
  {
    grt::ValueRef ovalue(_registry);
   _registry= value;
    member_changed("registry", ovalue, value);
  }

  app_StartersRef starters() const { return _starters; }
  virtual void starters(const app_StartersRef &value)
  {
    grt::ValueRef ovalue(_starters);
   _starters= value;
    member_changed("starters", ovalue, value);
  }

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

protected:

  grt::DictRef _customData;
  app_DocumentRef _doc;// owned
  app_InfoRef _info;
  app_OptionsRef _options;
  app_RegistryRef _registry;
  app_StartersRef _starters;
  grt::DictRef _state;
private: // wrapper methods for use by grt
  static grt::ObjectRef create(grt::GRT *grt)
  {
    return grt::ObjectRef(new app_Application(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(&app_Application::create);
    {
      void (app_Application::*setter)(const grt::DictRef &)= &app_Application::customData;
      grt::DictRef (app_Application::*getter)() const= &app_Application::customData;
      meta->bind_member("customData", new grt::MetaClass::Property<app_Application,grt::DictRef >(getter,setter));
    }
    {
      void (app_Application::*setter)(const app_DocumentRef &)= &app_Application::doc;
      app_DocumentRef (app_Application::*getter)() const= &app_Application::doc;
      meta->bind_member("doc", new grt::MetaClass::Property<app_Application,app_DocumentRef >(getter,setter));
    }
    {
      void (app_Application::*setter)(const app_InfoRef &)= &app_Application::info;
      app_InfoRef (app_Application::*getter)() const= &app_Application::info;
      meta->bind_member("info", new grt::MetaClass::Property<app_Application,app_InfoRef >(getter,setter));
    }
    {
      void (app_Application::*setter)(const app_OptionsRef &)= &app_Application::options;
      app_OptionsRef (app_Application::*getter)() const= &app_Application::options;
      meta->bind_member("options", new grt::MetaClass::Property<app_Application,app_OptionsRef >(getter,setter));
    }
    {
      void (app_Application::*setter)(const app_RegistryRef &)= &app_Application::registry;
      app_RegistryRef (app_Application::*getter)() const= &app_Application::registry;
      meta->bind_member("registry", new grt::MetaClass::Property<app_Application,app_RegistryRef >(getter,setter));
    }
    {
      void (app_Application::*setter)(const app_StartersRef &)= &app_Application::starters;
      app_StartersRef (app_Application::*getter)() const= &app_Application::starters;
      meta->bind_member("starters", new grt::MetaClass::Property<app_Application,app_StartersRef >(getter,setter));
    }
    {
      void (app_Application::*setter)(const grt::DictRef &)= &app_Application::state;
      grt::DictRef (app_Application::*getter)() const= &app_Application::state;
      meta->bind_member("state", new grt::MetaClass::Property<app_Application,grt::DictRef >(getter,setter));
    }
  }
};




inline void register_structs_app_xml()
{
  grt::internal::ClassRegistry::register_class<app_PluginInputDefinition>();
  grt::internal::ClassRegistry::register_class<app_PluginObjectInput>();
  grt::internal::ClassRegistry::register_class<app_PluginFileInput>();
  grt::internal::ClassRegistry::register_class<app_PluginSelectionInput>();
  grt::internal::ClassRegistry::register_class<app_Plugin>();
  grt::internal::ClassRegistry::register_class<app_DocumentPlugin>();
  grt::internal::ClassRegistry::register_class<app_PluginGroup>();
  grt::internal::ClassRegistry::register_class<app_Toolbar>();
  grt::internal::ClassRegistry::register_class<app_CommandItem>();
  grt::internal::ClassRegistry::register_class<app_ToolbarItem>();
  grt::internal::ClassRegistry::register_class<app_ShortcutItem>();
  grt::internal::ClassRegistry::register_class<app_MenuItem>();
  grt::internal::ClassRegistry::register_class<app_CustomDataField>();
  grt::internal::ClassRegistry::register_class<app_PageSettings>();
  grt::internal::ClassRegistry::register_class<app_PaperType>();
  grt::internal::ClassRegistry::register_class<app_Registry>();
  grt::internal::ClassRegistry::register_class<app_Starter>();
  grt::internal::ClassRegistry::register_class<app_Starters>();
  grt::internal::ClassRegistry::register_class<app_Options>();
  grt::internal::ClassRegistry::register_class<app_DocumentInfo>();
  grt::internal::ClassRegistry::register_class<app_Info>();
  grt::internal::ClassRegistry::register_class<app_Document>();
  grt::internal::ClassRegistry::register_class<app_Application>();
}

#ifdef AUTO_REGISTER_GRT_CLASSES
static struct _autoreg__structs_app_xml { _autoreg__structs_app_xml() { register_structs_app_xml(); } } __autoreg__structs_app_xml;
#endif

#endif