Logo Search packages:      
Sourcecode: d-conf version File versions  Download package

dconf-schema.c

/* dconf-schema.c generated by valac 0.12.0, the Vala compiler
 * generated from dconf-schema.vala, do not modify */


#include <glib.h>
#include <glib-object.h>
#include <stdlib.h>
#include <string.h>
#include <libxml/tree.h>
#include <libxml/parser.h>
#include <gio/gio.h>
#include <gobject/gvaluecollector.h>


#define TYPE_SCHEMA_KEY (schema_key_get_type ())
#define SCHEMA_KEY(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_SCHEMA_KEY, SchemaKey))
#define SCHEMA_KEY_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_SCHEMA_KEY, SchemaKeyClass))
#define IS_SCHEMA_KEY(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_SCHEMA_KEY))
#define IS_SCHEMA_KEY_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_SCHEMA_KEY))
#define SCHEMA_KEY_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_SCHEMA_KEY, SchemaKeyClass))

typedef struct _SchemaKey SchemaKey;
typedef struct _SchemaKeyClass SchemaKeyClass;
typedef struct _SchemaKeyPrivate SchemaKeyPrivate;

#define TYPE_SCHEMA (schema_get_type ())
#define SCHEMA(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_SCHEMA, Schema))
#define SCHEMA_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_SCHEMA, SchemaClass))
#define IS_SCHEMA(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_SCHEMA))
#define IS_SCHEMA_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_SCHEMA))
#define SCHEMA_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_SCHEMA, SchemaClass))

typedef struct _Schema Schema;
typedef struct _SchemaClass SchemaClass;

#define TYPE_SCHEMA_VALUE_RANGE (schema_value_range_get_type ())
#define SCHEMA_VALUE_RANGE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_SCHEMA_VALUE_RANGE, SchemaValueRange))
#define SCHEMA_VALUE_RANGE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_SCHEMA_VALUE_RANGE, SchemaValueRangeClass))
#define IS_SCHEMA_VALUE_RANGE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_SCHEMA_VALUE_RANGE))
#define IS_SCHEMA_VALUE_RANGE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_SCHEMA_VALUE_RANGE))
#define SCHEMA_VALUE_RANGE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_SCHEMA_VALUE_RANGE, SchemaValueRangeClass))

typedef struct _SchemaValueRange SchemaValueRange;
typedef struct _SchemaValueRangeClass SchemaValueRangeClass;

#define TYPE_SCHEMA_CHOICE (schema_choice_get_type ())
#define SCHEMA_CHOICE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_SCHEMA_CHOICE, SchemaChoice))
#define SCHEMA_CHOICE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_SCHEMA_CHOICE, SchemaChoiceClass))
#define IS_SCHEMA_CHOICE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_SCHEMA_CHOICE))
#define IS_SCHEMA_CHOICE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_SCHEMA_CHOICE))
#define SCHEMA_CHOICE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_SCHEMA_CHOICE, SchemaChoiceClass))

typedef struct _SchemaChoice SchemaChoice;
typedef struct _SchemaChoiceClass SchemaChoiceClass;
#define _schema_unref0(var) ((var == NULL) ? NULL : (var = (schema_unref (var), NULL)))
#define _g_free0(var) (var = (g_free (var), NULL))
#define _g_variant_unref0(var) ((var == NULL) ? NULL : (var = (g_variant_unref (var), NULL)))
#define _schema_value_range_unref0(var) ((var == NULL) ? NULL : (var = (schema_value_range_unref (var), NULL)))
#define __g_list_free__schema_choice_unref0_0(var) ((var == NULL) ? NULL : (var = (_g_list_free__schema_choice_unref0_ (var), NULL)))
#define _g_variant_type_free0(var) ((var == NULL) ? NULL : (var = (g_variant_type_free (var), NULL)))
#define _g_error_free0(var) ((var == NULL) ? NULL : (var = (g_error_free (var), NULL)))
typedef struct _ParamSpecSchemaKey ParamSpecSchemaKey;

#define TYPE_SCHEMA_VALUE (schema_value_get_type ())
#define SCHEMA_VALUE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_SCHEMA_VALUE, SchemaValue))
#define SCHEMA_VALUE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_SCHEMA_VALUE, SchemaValueClass))
#define IS_SCHEMA_VALUE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_SCHEMA_VALUE))
#define IS_SCHEMA_VALUE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_SCHEMA_VALUE))
#define SCHEMA_VALUE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_SCHEMA_VALUE, SchemaValueClass))

typedef struct _SchemaValue SchemaValue;
typedef struct _SchemaValueClass SchemaValueClass;
typedef struct _SchemaValuePrivate SchemaValuePrivate;
typedef struct _SchemaChoicePrivate SchemaChoicePrivate;
typedef struct _ParamSpecSchemaChoice ParamSpecSchemaChoice;
typedef struct _SchemaValueRangePrivate SchemaValueRangePrivate;
typedef struct _ParamSpecSchemaValueRange ParamSpecSchemaValueRange;

#define TYPE_SCHEMA_ENUM (schema_enum_get_type ())
#define SCHEMA_ENUM(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_SCHEMA_ENUM, SchemaEnum))
#define SCHEMA_ENUM_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_SCHEMA_ENUM, SchemaEnumClass))
#define IS_SCHEMA_ENUM(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_SCHEMA_ENUM))
#define IS_SCHEMA_ENUM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_SCHEMA_ENUM))
#define SCHEMA_ENUM_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_SCHEMA_ENUM, SchemaEnumClass))

typedef struct _SchemaEnum SchemaEnum;
typedef struct _SchemaEnumClass SchemaEnumClass;
typedef struct _SchemaEnumPrivate SchemaEnumPrivate;

#define TYPE_SCHEMA_LIST (schema_list_get_type ())
#define SCHEMA_LIST(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_SCHEMA_LIST, SchemaList))
#define SCHEMA_LIST_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_SCHEMA_LIST, SchemaListClass))
#define IS_SCHEMA_LIST(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_SCHEMA_LIST))
#define IS_SCHEMA_LIST_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_SCHEMA_LIST))
#define SCHEMA_LIST_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_SCHEMA_LIST, SchemaListClass))

typedef struct _SchemaList SchemaList;
typedef struct _SchemaListClass SchemaListClass;
#define _schema_list_unref0(var) ((var == NULL) ? NULL : (var = (schema_list_unref (var), NULL)))
#define __g_list_free__g_object_unref0_0(var) ((var == NULL) ? NULL : (var = (_g_list_free__g_object_unref0_ (var), NULL)))
#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
typedef struct _ParamSpecSchemaEnum ParamSpecSchemaEnum;

#define TYPE_SCHEMA_FLAGS (schema_flags_get_type ())
#define SCHEMA_FLAGS(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_SCHEMA_FLAGS, SchemaFlags))
#define SCHEMA_FLAGS_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_SCHEMA_FLAGS, SchemaFlagsClass))
#define IS_SCHEMA_FLAGS(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_SCHEMA_FLAGS))
#define IS_SCHEMA_FLAGS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_SCHEMA_FLAGS))
#define SCHEMA_FLAGS_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_SCHEMA_FLAGS, SchemaFlagsClass))

typedef struct _SchemaFlags SchemaFlags;
typedef struct _SchemaFlagsClass SchemaFlagsClass;
typedef struct _SchemaFlagsPrivate SchemaFlagsPrivate;
typedef struct _ParamSpecSchemaFlags ParamSpecSchemaFlags;
typedef struct _SchemaPrivate SchemaPrivate;
#define _g_hash_table_unref0(var) ((var == NULL) ? NULL : (var = (g_hash_table_unref (var), NULL)))
#define _schema_key_unref0(var) ((var == NULL) ? NULL : (var = (schema_key_unref (var), NULL)))
typedef struct _ParamSpecSchema ParamSpecSchema;
typedef struct _SchemaListPrivate SchemaListPrivate;
#define __g_list_free__schema_unref0_0(var) ((var == NULL) ? NULL : (var = (_g_list_free__schema_unref0_ (var), NULL)))
#define _g_list_free0(var) ((var == NULL) ? NULL : (var = (g_list_free (var), NULL)))
#define _schema_enum_unref0(var) ((var == NULL) ? NULL : (var = (schema_enum_unref (var), NULL)))
#define _schema_flags_unref0(var) ((var == NULL) ? NULL : (var = (schema_flags_unref (var), NULL)))
typedef struct _ParamSpecSchemaList ParamSpecSchemaList;

struct _SchemaKey {
      GTypeInstance parent_instance;
      volatile int ref_count;
      SchemaKeyPrivate * priv;
      Schema* schema;
      gchar* name;
      gchar* type;
      GVariant* default_value;
      SchemaValueRange* range;
      SchemaValueRange* type_range;
      GList* choices;
      gchar* enum_name;
      gchar* summary;
      gchar* description;
      gchar* gettext_domain;
};

struct _SchemaKeyClass {
      GTypeClass parent_class;
      void (*finalize) (SchemaKey *self);
};

00148 struct _ParamSpecSchemaKey {
      GParamSpec parent_instance;
};

struct _SchemaValue {
      GObject parent_instance;
      SchemaValuePrivate * priv;
      guint index;
      gchar* nick;
      gint value;
};

struct _SchemaValueClass {
      GObjectClass parent_class;
};

00164 struct _SchemaChoice {
      GTypeInstance parent_instance;
      volatile int ref_count;
      SchemaChoicePrivate * priv;
      gchar* name;
      GVariant* value;
};

00172 struct _SchemaChoiceClass {
      GTypeClass parent_class;
      void (*finalize) (SchemaChoice *self);
};

00177 struct _ParamSpecSchemaChoice {
      GParamSpec parent_instance;
};

struct _SchemaValueRange {
      GTypeInstance parent_instance;
      volatile int ref_count;
      SchemaValueRangePrivate * priv;
      GVariant* min;
      GVariant* max;
};

struct _SchemaValueRangeClass {
      GTypeClass parent_class;
      void (*finalize) (SchemaValueRange *self);
};

00194 struct _ParamSpecSchemaValueRange {
      GParamSpec parent_instance;
};

struct _SchemaEnum {
      GTypeInstance parent_instance;
      volatile int ref_count;
      SchemaEnumPrivate * priv;
      SchemaList* list;
      gchar* id;
      GList* values;
};

struct _SchemaEnumClass {
      GTypeClass parent_class;
      void (*finalize) (SchemaEnum *self);
};

00212 struct _ParamSpecSchemaEnum {
      GParamSpec parent_instance;
};

00216 struct _SchemaFlags {
      GTypeInstance parent_instance;
      volatile int ref_count;
      SchemaFlagsPrivate * priv;
      SchemaList* list;
      gchar* id;
      GList* values;
};

00225 struct _SchemaFlagsClass {
      GTypeClass parent_class;
      void (*finalize) (SchemaFlags *self);
};

00230 struct _ParamSpecSchemaFlags {
      GParamSpec parent_instance;
};

struct _Schema {
      GTypeInstance parent_instance;
      volatile int ref_count;
      SchemaPrivate * priv;
      SchemaList* list;
      gchar* id;
      gchar* path;
      GHashTable* keys;
};

struct _SchemaClass {
      GTypeClass parent_class;
      void (*finalize) (Schema *self);
};

00249 struct _ParamSpecSchema {
      GParamSpec parent_instance;
};

struct _SchemaList {
      GTypeInstance parent_instance;
      volatile int ref_count;
      SchemaListPrivate * priv;
      GList* schemas;
      GHashTable* keys;
      GHashTable* enums;
      GHashTable* flags;
};

struct _SchemaListClass {
      GTypeClass parent_class;
      void (*finalize) (SchemaList *self);
};

00268 struct _ParamSpecSchemaList {
      GParamSpec parent_instance;
};


static gpointer schema_key_parent_class = NULL;
static gpointer schema_value_parent_class = NULL;
static gpointer schema_choice_parent_class = NULL;
static gpointer schema_value_range_parent_class = NULL;
static gpointer schema_enum_parent_class = NULL;
static gpointer schema_flags_parent_class = NULL;
static gpointer schema_parent_class = NULL;
static gpointer schema_list_parent_class = NULL;

gpointer schema_key_ref (gpointer instance);
void schema_key_unref (gpointer instance);
GParamSpec* param_spec_schema_key (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);
void value_set_schema_key (GValue* value, gpointer v_object);
void value_take_schema_key (GValue* value, gpointer v_object);
gpointer value_get_schema_key (const GValue* value);
GType schema_key_get_type (void) G_GNUC_CONST;
gpointer schema_ref (gpointer instance);
void schema_unref (gpointer instance);
GParamSpec* param_spec_schema (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);
void value_set_schema (GValue* value, gpointer v_object);
void value_take_schema (GValue* value, gpointer v_object);
gpointer value_get_schema (const GValue* value);
GType schema_get_type (void) G_GNUC_CONST;
gpointer schema_value_range_ref (gpointer instance);
void schema_value_range_unref (gpointer instance);
GParamSpec* param_spec_schema_value_range (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);
void value_set_schema_value_range (GValue* value, gpointer v_object);
void value_take_schema_value_range (GValue* value, gpointer v_object);
gpointer value_get_schema_value_range (const GValue* value);
GType schema_value_range_get_type (void) G_GNUC_CONST;
gpointer schema_choice_ref (gpointer instance);
void schema_choice_unref (gpointer instance);
GParamSpec* param_spec_schema_choice (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);
void value_set_schema_choice (GValue* value, gpointer v_object);
void value_take_schema_choice (GValue* value, gpointer v_object);
gpointer value_get_schema_choice (const GValue* value);
GType schema_choice_get_type (void) G_GNUC_CONST;
enum  {
      SCHEMA_KEY_DUMMY_PROPERTY
};
static void _schema_choice_unref0_ (gpointer var);
static void _g_list_free__schema_choice_unref0_ (GList* self);
SchemaKey* schema_key_new_from_xml (xmlNode* node, Schema* schema, const gchar* gettext_domain);
SchemaKey* schema_key_construct_from_xml (GType object_type, xmlNode* node, Schema* schema, const gchar* gettext_domain);
SchemaValueRange* schema_value_range_new_from_xml (const gchar* type, xmlNode* node);
SchemaValueRange* schema_value_range_construct_from_xml (GType object_type, const gchar* type, xmlNode* node);
SchemaChoice* schema_choice_new (const gchar* name, GVariant* value);
SchemaChoice* schema_choice_construct (GType object_type, const gchar* name, GVariant* value);
SchemaKey* schema_key_new (void);
SchemaKey* schema_key_construct (GType object_type);
static void schema_key_finalize (SchemaKey* obj);
GType schema_value_get_type (void) G_GNUC_CONST;
enum  {
      SCHEMA_VALUE_DUMMY_PROPERTY
};
SchemaValue* schema_value_new (guint index, const gchar* nick, gint value);
SchemaValue* schema_value_construct (GType object_type, guint index, const gchar* nick, gint value);
static void schema_value_finalize (GObject* obj);
enum  {
      SCHEMA_CHOICE_DUMMY_PROPERTY
};
static void schema_choice_finalize (SchemaChoice* obj);
enum  {
      SCHEMA_VALUE_RANGE_DUMMY_PROPERTY
};
SchemaValueRange* schema_value_range_new (void);
SchemaValueRange* schema_value_range_construct (GType object_type);
static void schema_value_range_finalize (SchemaValueRange* obj);
gpointer schema_enum_ref (gpointer instance);
void schema_enum_unref (gpointer instance);
GParamSpec* param_spec_schema_enum (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);
void value_set_schema_enum (GValue* value, gpointer v_object);
void value_take_schema_enum (GValue* value, gpointer v_object);
gpointer value_get_schema_enum (const GValue* value);
GType schema_enum_get_type (void) G_GNUC_CONST;
gpointer schema_list_ref (gpointer instance);
void schema_list_unref (gpointer instance);
GParamSpec* param_spec_schema_list (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);
void value_set_schema_list (GValue* value, gpointer v_object);
void value_take_schema_list (GValue* value, gpointer v_object);
gpointer value_get_schema_list (const GValue* value);
GType schema_list_get_type (void) G_GNUC_CONST;
enum  {
      SCHEMA_ENUM_DUMMY_PROPERTY
};
static void _g_object_unref0_ (gpointer var);
static void _g_list_free__g_object_unref0_ (GList* self);
SchemaEnum* schema_enum_new_from_xml (SchemaList* list, xmlNode* node);
SchemaEnum* schema_enum_construct_from_xml (GType object_type, SchemaList* list, xmlNode* node);
SchemaEnum* schema_enum_new (void);
SchemaEnum* schema_enum_construct (GType object_type);
static void schema_enum_finalize (SchemaEnum* obj);
gpointer schema_flags_ref (gpointer instance);
void schema_flags_unref (gpointer instance);
GParamSpec* param_spec_schema_flags (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);
void value_set_schema_flags (GValue* value, gpointer v_object);
void value_take_schema_flags (GValue* value, gpointer v_object);
gpointer value_get_schema_flags (const GValue* value);
GType schema_flags_get_type (void) G_GNUC_CONST;
enum  {
      SCHEMA_FLAGS_DUMMY_PROPERTY
};
SchemaFlags* schema_flags_new_from_xml (SchemaList* list, xmlNode* node);
SchemaFlags* schema_flags_construct_from_xml (GType object_type, SchemaList* list, xmlNode* node);
SchemaFlags* schema_flags_new (void);
SchemaFlags* schema_flags_construct (GType object_type);
static void schema_flags_finalize (SchemaFlags* obj);
enum  {
      SCHEMA_DUMMY_PROPERTY
};
static void _g_free0_ (gpointer var);
static void _schema_key_unref0_ (gpointer var);
Schema* schema_new_from_xml (SchemaList* list, xmlNode* node, const gchar* gettext_domain);
Schema* schema_construct_from_xml (GType object_type, SchemaList* list, xmlNode* node, const gchar* gettext_domain);
Schema* schema_new (void);
Schema* schema_construct (GType object_type);
static void schema_finalize (Schema* obj);
enum  {
      SCHEMA_LIST_DUMMY_PROPERTY
};
static void _schema_unref0_ (gpointer var);
static void _g_list_free__schema_unref0_ (GList* self);
static void _schema_enum_unref0_ (gpointer var);
static void _schema_flags_unref0_ (gpointer var);
void schema_list_parse_file (SchemaList* self, const gchar* path);
void schema_list_load_directory (SchemaList* self, const gchar* dir, GError** error);
SchemaList* schema_list_new (void);
SchemaList* schema_list_construct (GType object_type);
static void schema_list_finalize (SchemaList* obj);


static void _schema_choice_unref0_ (gpointer var) {
      (var == NULL) ? NULL : (var = (schema_choice_unref (var), NULL));
}


static void _g_list_free__schema_choice_unref0_ (GList* self) {
      g_list_foreach (self, (GFunc) _schema_choice_unref0_, NULL);
      g_list_free (self);
}


static gpointer _schema_ref0 (gpointer self) {
      return self ? schema_ref (self) : NULL;
}


SchemaKey* schema_key_construct_from_xml (GType object_type, xmlNode* node, Schema* schema, const gchar* gettext_domain) {
      SchemaKey* self = NULL;
      Schema* _tmp0_;
      gchar* _tmp1_;
      GError * _inner_error_ = NULL;
      g_return_val_if_fail (schema != NULL, NULL);
      self = (SchemaKey*) g_type_create_instance (object_type);
      _tmp0_ = _schema_ref0 (schema);
      _schema_unref0 (self->schema);
      self->schema = _tmp0_;
      _tmp1_ = g_strdup (gettext_domain);
      _g_free0 (self->gettext_domain);
      self->gettext_domain = _tmp1_;
      {
            xmlAttr* prop;
            prop = node->properties;
            {
                  gboolean _tmp2_;
                  _tmp2_ = TRUE;
                  while (TRUE) {
                        if (!_tmp2_) {
                              prop = prop->next;
                        }
                        _tmp2_ = FALSE;
                        if (!(prop != NULL)) {
                              break;
                        }
                        if (g_strcmp0 (prop->name, "name") == 0) {
                              gchar* _tmp3_;
                              _tmp3_ = g_strdup (prop->children->content);
                              _g_free0 (self->name);
                              self->name = _tmp3_;
                        } else {
                              if (g_strcmp0 (prop->name, "type") == 0) {
                                    gchar* _tmp4_;
                                    _tmp4_ = g_strdup (prop->children->content);
                                    _g_free0 (self->type);
                                    self->type = _tmp4_;
                              } else {
                                    if (g_strcmp0 (prop->name, "enum") == 0) {
                                          gchar* _tmp5_;
                                          gchar* _tmp6_;
                                          _tmp5_ = g_strdup ("s");
                                          _g_free0 (self->type);
                                          self->type = _tmp5_;
                                          _tmp6_ = g_strdup (prop->children->content);
                                          _g_free0 (self->enum_name);
                                          self->enum_name = _tmp6_;
                                    } else {
                                          if (g_strcmp0 (prop->name, "flags") == 0) {
                                                gchar* _tmp7_;
                                                _tmp7_ = g_strdup ("as");
                                                _g_free0 (self->type);
                                                self->type = _tmp7_;
                                          } else {
                                                g_warning ("dconf-schema.vala:35: Unknown property on <key>, %s", prop->name);
                                          }
                                    }
                              }
                        }
                  }
            }
      }
      {
            xmlNode* child;
            child = node->children;
            {
                  gboolean _tmp8_;
                  _tmp8_ = TRUE;
                  while (TRUE) {
                        if (!_tmp8_) {
                              child = child->next;
                        }
                        _tmp8_ = FALSE;
                        if (!(child != NULL)) {
                              break;
                        }
                        if (g_strcmp0 (child->name, "default") == 0) {
                              GVariantType* _tmp9_ = NULL;
                              GVariantType* _tmp10_;
                              GVariant* _tmp11_ = NULL;
                              GVariant* _tmp12_;
                              GVariant* _tmp13_;
                              _tmp9_ = g_variant_type_new (self->type);
                              _tmp10_ = _tmp9_;
                              _tmp11_ = g_variant_parse (_tmp10_, child->children->content, NULL, NULL, &_inner_error_);
                              _tmp12_ = _tmp11_;
                              _g_variant_type_free0 (_tmp10_);
                              _tmp13_ = _tmp12_;
                              if (_inner_error_ != NULL) {
                                    if (_inner_error_->domain == G_VARIANT_PARSE_ERROR) {
                                          goto __catch4_g_variant_parse_error;
                                    }
                                    g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                                    g_clear_error (&_inner_error_);
                                    return NULL;
                              }
                              _g_variant_unref0 (self->default_value);
                              self->default_value = _tmp13_;
                              goto __finally4;
                              __catch4_g_variant_parse_error:
                              {
                                    GError * e;
                                    e = _inner_error_;
                                    _inner_error_ = NULL;
                                    _g_error_free0 (e);
                              }
                              __finally4:
                              if (_inner_error_ != NULL) {
                                    g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                                    g_clear_error (&_inner_error_);
                                    return NULL;
                              }
                        } else {
                              if (g_strcmp0 (child->name, "summary") == 0) {
                                    const gchar* _tmp14_ = NULL;
                                    gchar* _tmp15_;
                                    if (child->children == NULL) {
                                          _tmp14_ = "";
                                    } else {
                                          _tmp14_ = child->children->content;
                                    }
                                    _tmp15_ = g_strdup (_tmp14_);
                                    _g_free0 (self->summary);
                                    self->summary = _tmp15_;
                              } else {
                                    if (g_strcmp0 (child->name, "description") == 0) {
                                          const gchar* _tmp16_ = NULL;
                                          gchar* _tmp17_;
                                          if (child->children == NULL) {
                                                _tmp16_ = "";
                                          } else {
                                                _tmp16_ = child->children->content;
                                          }
                                          _tmp17_ = g_strdup (_tmp16_);
                                          _g_free0 (self->description);
                                          self->description = _tmp17_;
                                    } else {
                                          if (g_strcmp0 (child->name, "range") == 0) {
                                                SchemaValueRange* _tmp18_ = NULL;
                                                _tmp18_ = schema_value_range_new_from_xml (self->type, child);
                                                _schema_value_range_unref0 (self->range);
                                                self->range = _tmp18_;
                                          } else {
                                                if (g_strcmp0 (child->name, "choices") == 0) {
                                                      {
                                                            xmlNode* n;
                                                            n = child->children;
                                                            {
                                                                  gboolean _tmp19_;
                                                                  _tmp19_ = TRUE;
                                                                  while (TRUE) {
                                                                        gchar* value;
                                                                        GVariant* v = NULL;
                                                                        GVariant* _tmp22_ = NULL;
                                                                        SchemaChoice* _tmp23_ = NULL;
                                                                        if (!_tmp19_) {
                                                                              n = n->next;
                                                                        }
                                                                        _tmp19_ = FALSE;
                                                                        if (!(n != NULL)) {
                                                                              break;
                                                                        }
                                                                        if (n->type != XML_ELEMENT_NODE) {
                                                                              continue;
                                                                        }
                                                                        if (g_strcmp0 (n->name, "choice") != 0) {
                                                                              g_warning ("dconf-schema.vala:68: Unknown child tag in <choices>, <%s>", n->name);
                                                                              continue;
                                                                        }
                                                                        value = NULL;
                                                                        {
                                                                              xmlAttr* prop;
                                                                              prop = n->properties;
                                                                              {
                                                                                    gboolean _tmp20_;
                                                                                    _tmp20_ = TRUE;
                                                                                    while (TRUE) {
                                                                                          if (!_tmp20_) {
                                                                                                prop = prop->next;
                                                                                          }
                                                                                          _tmp20_ = FALSE;
                                                                                          if (!(prop != NULL)) {
                                                                                                break;
                                                                                          }
                                                                                          if (g_strcmp0 (prop->name, "value") == 0) {
                                                                                                gchar* _tmp21_;
                                                                                                _tmp21_ = g_strdup (prop->children->content);
                                                                                                _g_free0 (value);
                                                                                                value = _tmp21_;
                                                                                          } else {
                                                                                                g_warning ("dconf-schema.vala:78: Unknown property on <choice>, %s", prop->name);
                                                                                          }
                                                                                    }
                                                                              }
                                                                        }
                                                                        if (value == NULL) {
                                                                              g_warning ("dconf-schema.vala:83: Ignoring <choice> with no value");
                                                                              _g_free0 (value);
                                                                              continue;
                                                                        }
                                                                        _tmp22_ = g_variant_new_string (value);
                                                                        _g_variant_unref0 (v);
                                                                        v = g_variant_ref_sink (_tmp22_);
                                                                        _tmp23_ = schema_choice_new (value, v);
                                                                        self->choices = g_list_append (self->choices, _tmp23_);
                                                                        goto __finally5;
                                                                        __catch5_g_variant_parse_error:
                                                                        {
                                                                              GError * e;
                                                                              e = _inner_error_;
                                                                              _inner_error_ = NULL;
                                                                              g_warning ("dconf-schema.vala:95: Invalid choice value '%s'", value);
                                                                              _g_error_free0 (e);
                                                                        }
                                                                        __finally5:
                                                                        if (_inner_error_ != NULL) {
                                                                              _g_variant_unref0 (v);
                                                                              _g_free0 (value);
                                                                              g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                                                                              g_clear_error (&_inner_error_);
                                                                              return NULL;
                                                                        }
                                                                        _g_variant_unref0 (v);
                                                                        _g_free0 (value);
                                                                  }
                                                            }
                                                      }
                                                } else {
                                                      if (g_strcmp0 (child->name, "aliases") == 0) {
                                                            {
                                                                  xmlNode* n;
                                                                  n = child->children;
                                                                  {
                                                                        gboolean _tmp24_;
                                                                        _tmp24_ = TRUE;
                                                                        while (TRUE) {
                                                                              gchar* value;
                                                                              gchar* target;
                                                                              GVariant* v = NULL;
                                                                              GVariant* _tmp28_ = NULL;
                                                                              SchemaChoice* _tmp29_ = NULL;
                                                                              if (!_tmp24_) {
                                                                                    n = n->next;
                                                                              }
                                                                              _tmp24_ = FALSE;
                                                                              if (!(n != NULL)) {
                                                                                    break;
                                                                              }
                                                                              if (n->type != XML_ELEMENT_NODE) {
                                                                                    continue;
                                                                              }
                                                                              if (g_strcmp0 (n->name, "alias") != 0) {
                                                                                    g_warning ("dconf-schema.vala:107: Unknown child tag in <aliases>, <%s>", n->name);
                                                                                    continue;
                                                                              }
                                                                              value = NULL;
                                                                              target = NULL;
                                                                              {
                                                                                    xmlAttr* prop;
                                                                                    prop = n->properties;
                                                                                    {
                                                                                          gboolean _tmp25_;
                                                                                          _tmp25_ = TRUE;
                                                                                          while (TRUE) {
                                                                                                if (!_tmp25_) {
                                                                                                      prop = prop->next;
                                                                                                }
                                                                                                _tmp25_ = FALSE;
                                                                                                if (!(prop != NULL)) {
                                                                                                      break;
                                                                                                }
                                                                                                if (g_strcmp0 (prop->name, "value") == 0) {
                                                                                                      gchar* _tmp26_;
                                                                                                      _tmp26_ = g_strdup (prop->children->content);
                                                                                                      _g_free0 (value);
                                                                                                      value = _tmp26_;
                                                                                                } else {
                                                                                                      if (g_strcmp0 (prop->name, "target") == 0) {
                                                                                                            gchar* _tmp27_;
                                                                                                            _tmp27_ = g_strdup (prop->children->content);
                                                                                                            _g_free0 (target);
                                                                                                            target = _tmp27_;
                                                                                                      } else {
                                                                                                            g_warning ("dconf-schema.vala:119: Unknown property on <alias>, %s", prop->name);
                                                                                                      }
                                                                                                }
                                                                                          }
                                                                                    }
                                                                              }
                                                                              if (value == NULL) {
                                                                                    g_warning ("dconf-schema.vala:124: Ignoring <alias> with no value");
                                                                                    _g_free0 (target);
                                                                                    _g_free0 (value);
                                                                                    continue;
                                                                              }
                                                                              if (target == NULL) {
                                                                                    g_warning ("dconf-schema.vala:129: Ignoring <alias> with no target");
                                                                                    _g_free0 (target);
                                                                                    _g_free0 (value);
                                                                                    continue;
                                                                              }
                                                                              _tmp28_ = g_variant_new_string (target);
                                                                              _g_variant_unref0 (v);
                                                                              v = g_variant_ref_sink (_tmp28_);
                                                                              _tmp29_ = schema_choice_new (value, v);
                                                                              self->choices = g_list_append (self->choices, _tmp29_);
                                                                              goto __finally6;
                                                                              __catch6_g_variant_parse_error:
                                                                              {
                                                                                    GError * e;
                                                                                    e = _inner_error_;
                                                                                    _inner_error_ = NULL;
                                                                                    g_warning ("dconf-schema.vala:141: Invalid alias value '%s'", target);
                                                                                    _g_error_free0 (e);
                                                                              }
                                                                              __finally6:
                                                                              if (_inner_error_ != NULL) {
                                                                                    _g_variant_unref0 (v);
                                                                                    _g_free0 (target);
                                                                                    _g_free0 (value);
                                                                                    g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                                                                                    g_clear_error (&_inner_error_);
                                                                                    return NULL;
                                                                              }
                                                                              _g_variant_unref0 (v);
                                                                              _g_free0 (target);
                                                                              _g_free0 (value);
                                                                        }
                                                                  }
                                                            }
                                                      } else {
                                                            gboolean _tmp30_ = FALSE;
                                                            if (child->type != XML_TEXT_NODE) {
                                                                  _tmp30_ = child->type != XML_COMMENT_NODE;
                                                            } else {
                                                                  _tmp30_ = FALSE;
                                                            }
                                                            if (_tmp30_) {
                                                                  g_warning ("dconf-schema.vala:146: Unknown child tag in <key>, <%s>", child->name);
                                                            }
                                                      }
                                                }
                                          }
                                    }
                              }
                        }
                  }
            }
      }
      return self;
}


SchemaKey* schema_key_new_from_xml (xmlNode* node, Schema* schema, const gchar* gettext_domain) {
      return schema_key_construct_from_xml (TYPE_SCHEMA_KEY, node, schema, gettext_domain);
}


SchemaKey* schema_key_construct (GType object_type) {
      SchemaKey* self = NULL;
      self = (SchemaKey*) g_type_create_instance (object_type);
      return self;
}


SchemaKey* schema_key_new (void) {
      return schema_key_construct (TYPE_SCHEMA_KEY);
}


static void value_schema_key_init (GValue* value) {
      value->data[0].v_pointer = NULL;
}


static void value_schema_key_free_value (GValue* value) {
      if (value->data[0].v_pointer) {
            schema_key_unref (value->data[0].v_pointer);
      }
}


static void value_schema_key_copy_value (const GValue* src_value, GValue* dest_value) {
      if (src_value->data[0].v_pointer) {
            dest_value->data[0].v_pointer = schema_key_ref (src_value->data[0].v_pointer);
      } else {
            dest_value->data[0].v_pointer = NULL;
      }
}


static gpointer value_schema_key_peek_pointer (const GValue* value) {
      return value->data[0].v_pointer;
}


static gchar* value_schema_key_collect_value (GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {
      if (collect_values[0].v_pointer) {
            SchemaKey* object;
            object = collect_values[0].v_pointer;
            if (object->parent_instance.g_class == NULL) {
                  return g_strconcat ("invalid unclassed object pointer for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
            } else if (!g_value_type_compatible (G_TYPE_FROM_INSTANCE (object), G_VALUE_TYPE (value))) {
                  return g_strconcat ("invalid object type `", g_type_name (G_TYPE_FROM_INSTANCE (object)), "' for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
            }
            value->data[0].v_pointer = schema_key_ref (object);
      } else {
            value->data[0].v_pointer = NULL;
      }
      return NULL;
}


static gchar* value_schema_key_lcopy_value (const GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {
      SchemaKey** object_p;
      object_p = collect_values[0].v_pointer;
      if (!object_p) {
            return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
      }
      if (!value->data[0].v_pointer) {
            *object_p = NULL;
      } else if (collect_flags & G_VALUE_NOCOPY_CONTENTS) {
            *object_p = value->data[0].v_pointer;
      } else {
            *object_p = schema_key_ref (value->data[0].v_pointer);
      }
      return NULL;
}


GParamSpec* param_spec_schema_key (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags) {
      ParamSpecSchemaKey* spec;
      g_return_val_if_fail (g_type_is_a (object_type, TYPE_SCHEMA_KEY), NULL);
      spec = g_param_spec_internal (G_TYPE_PARAM_OBJECT, name, nick, blurb, flags);
      G_PARAM_SPEC (spec)->value_type = object_type;
      return G_PARAM_SPEC (spec);
}


gpointer value_get_schema_key (const GValue* value) {
      g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_SCHEMA_KEY), NULL);
      return value->data[0].v_pointer;
}


void value_set_schema_key (GValue* value, gpointer v_object) {
      SchemaKey* old;
      g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_SCHEMA_KEY));
      old = value->data[0].v_pointer;
      if (v_object) {
            g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, TYPE_SCHEMA_KEY));
            g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
            value->data[0].v_pointer = v_object;
            schema_key_ref (value->data[0].v_pointer);
      } else {
            value->data[0].v_pointer = NULL;
      }
      if (old) {
            schema_key_unref (old);
      }
}


void value_take_schema_key (GValue* value, gpointer v_object) {
      SchemaKey* old;
      g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_SCHEMA_KEY));
      old = value->data[0].v_pointer;
      if (v_object) {
            g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, TYPE_SCHEMA_KEY));
            g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
            value->data[0].v_pointer = v_object;
      } else {
            value->data[0].v_pointer = NULL;
      }
      if (old) {
            schema_key_unref (old);
      }
}


static void schema_key_class_init (SchemaKeyClass * klass) {
      schema_key_parent_class = g_type_class_peek_parent (klass);
      SCHEMA_KEY_CLASS (klass)->finalize = schema_key_finalize;
}


static void schema_key_instance_init (SchemaKey * self) {
      self->ref_count = 1;
}


static void schema_key_finalize (SchemaKey* obj) {
      SchemaKey * self;
      self = SCHEMA_KEY (obj);
      _schema_unref0 (self->schema);
      _g_free0 (self->name);
      _g_free0 (self->type);
      _g_variant_unref0 (self->default_value);
      _schema_value_range_unref0 (self->range);
      _schema_value_range_unref0 (self->type_range);
      __g_list_free__schema_choice_unref0_0 (self->choices);
      _g_free0 (self->enum_name);
      _g_free0 (self->summary);
      _g_free0 (self->description);
      _g_free0 (self->gettext_domain);
}


GType schema_key_get_type (void) {
      static volatile gsize schema_key_type_id__volatile = 0;
      if (g_once_init_enter (&schema_key_type_id__volatile)) {
            static const GTypeValueTable g_define_type_value_table = { value_schema_key_init, value_schema_key_free_value, value_schema_key_copy_value, value_schema_key_peek_pointer, "p", value_schema_key_collect_value, "p", value_schema_key_lcopy_value };
            static const GTypeInfo g_define_type_info = { sizeof (SchemaKeyClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) schema_key_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (SchemaKey), 0, (GInstanceInitFunc) schema_key_instance_init, &g_define_type_value_table };
            static const GTypeFundamentalInfo g_define_type_fundamental_info = { (G_TYPE_FLAG_CLASSED | G_TYPE_FLAG_INSTANTIATABLE | G_TYPE_FLAG_DERIVABLE | G_TYPE_FLAG_DEEP_DERIVABLE) };
            GType schema_key_type_id;
            schema_key_type_id = g_type_register_fundamental (g_type_fundamental_next (), "SchemaKey", &g_define_type_info, &g_define_type_fundamental_info, 0);
            g_once_init_leave (&schema_key_type_id__volatile, schema_key_type_id);
      }
      return schema_key_type_id__volatile;
}


gpointer schema_key_ref (gpointer instance) {
      SchemaKey* self;
      self = instance;
      g_atomic_int_inc (&self->ref_count);
      return instance;
}


void schema_key_unref (gpointer instance) {
      SchemaKey* self;
      self = instance;
      if (g_atomic_int_dec_and_test (&self->ref_count)) {
            SCHEMA_KEY_GET_CLASS (self)->finalize (self);
            g_type_free_instance ((GTypeInstance *) self);
      }
}


SchemaValue* schema_value_construct (GType object_type, guint index, const gchar* nick, gint value) {
      SchemaValue * self = NULL;
      gchar* _tmp0_;
      g_return_val_if_fail (nick != NULL, NULL);
      self = (SchemaValue*) g_object_new (object_type, NULL);
      self->index = index;
      _tmp0_ = g_strdup (nick);
      _g_free0 (self->nick);
      self->nick = _tmp0_;
      self->value = value;
      return self;
}


SchemaValue* schema_value_new (guint index, const gchar* nick, gint value) {
      return schema_value_construct (TYPE_SCHEMA_VALUE, index, nick, value);
}


static void schema_value_class_init (SchemaValueClass * klass) {
      schema_value_parent_class = g_type_class_peek_parent (klass);
      G_OBJECT_CLASS (klass)->finalize = schema_value_finalize;
}


static void schema_value_instance_init (SchemaValue * self) {
}


static void schema_value_finalize (GObject* obj) {
      SchemaValue * self;
      self = SCHEMA_VALUE (obj);
      _g_free0 (self->nick);
      G_OBJECT_CLASS (schema_value_parent_class)->finalize (obj);
}


GType schema_value_get_type (void) {
      static volatile gsize schema_value_type_id__volatile = 0;
      if (g_once_init_enter (&schema_value_type_id__volatile)) {
            static const GTypeInfo g_define_type_info = { sizeof (SchemaValueClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) schema_value_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (SchemaValue), 0, (GInstanceInitFunc) schema_value_instance_init, NULL };
            GType schema_value_type_id;
            schema_value_type_id = g_type_register_static (G_TYPE_OBJECT, "SchemaValue", &g_define_type_info, 0);
            g_once_init_leave (&schema_value_type_id__volatile, schema_value_type_id);
      }
      return schema_value_type_id__volatile;
}


static gpointer _g_variant_ref0 (gpointer self) {
      return self ? g_variant_ref (self) : NULL;
}


SchemaChoice* schema_choice_construct (GType object_type, const gchar* name, GVariant* value) {
      SchemaChoice* self = NULL;
      gchar* _tmp0_;
      GVariant* _tmp1_;
      g_return_val_if_fail (name != NULL, NULL);
      g_return_val_if_fail (value != NULL, NULL);
      self = (SchemaChoice*) g_type_create_instance (object_type);
      _tmp0_ = g_strdup (name);
      _g_free0 (self->name);
      self->name = _tmp0_;
      _tmp1_ = _g_variant_ref0 (value);
      _g_variant_unref0 (self->value);
      self->value = _tmp1_;
      return self;
}


SchemaChoice* schema_choice_new (const gchar* name, GVariant* value) {
      return schema_choice_construct (TYPE_SCHEMA_CHOICE, name, value);
}


static void value_schema_choice_init (GValue* value) {
      value->data[0].v_pointer = NULL;
}


static void value_schema_choice_free_value (GValue* value) {
      if (value->data[0].v_pointer) {
            schema_choice_unref (value->data[0].v_pointer);
      }
}


static void value_schema_choice_copy_value (const GValue* src_value, GValue* dest_value) {
      if (src_value->data[0].v_pointer) {
            dest_value->data[0].v_pointer = schema_choice_ref (src_value->data[0].v_pointer);
      } else {
            dest_value->data[0].v_pointer = NULL;
      }
}


static gpointer value_schema_choice_peek_pointer (const GValue* value) {
      return value->data[0].v_pointer;
}


static gchar* value_schema_choice_collect_value (GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {
      if (collect_values[0].v_pointer) {
            SchemaChoice* object;
            object = collect_values[0].v_pointer;
            if (object->parent_instance.g_class == NULL) {
                  return g_strconcat ("invalid unclassed object pointer for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
            } else if (!g_value_type_compatible (G_TYPE_FROM_INSTANCE (object), G_VALUE_TYPE (value))) {
                  return g_strconcat ("invalid object type `", g_type_name (G_TYPE_FROM_INSTANCE (object)), "' for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
            }
            value->data[0].v_pointer = schema_choice_ref (object);
      } else {
            value->data[0].v_pointer = NULL;
      }
      return NULL;
}


static gchar* value_schema_choice_lcopy_value (const GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {
      SchemaChoice** object_p;
      object_p = collect_values[0].v_pointer;
      if (!object_p) {
            return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
      }
      if (!value->data[0].v_pointer) {
            *object_p = NULL;
      } else if (collect_flags & G_VALUE_NOCOPY_CONTENTS) {
            *object_p = value->data[0].v_pointer;
      } else {
            *object_p = schema_choice_ref (value->data[0].v_pointer);
      }
      return NULL;
}


GParamSpec* param_spec_schema_choice (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags) {
      ParamSpecSchemaChoice* spec;
      g_return_val_if_fail (g_type_is_a (object_type, TYPE_SCHEMA_CHOICE), NULL);
      spec = g_param_spec_internal (G_TYPE_PARAM_OBJECT, name, nick, blurb, flags);
      G_PARAM_SPEC (spec)->value_type = object_type;
      return G_PARAM_SPEC (spec);
}


gpointer value_get_schema_choice (const GValue* value) {
      g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_SCHEMA_CHOICE), NULL);
      return value->data[0].v_pointer;
}


void value_set_schema_choice (GValue* value, gpointer v_object) {
      SchemaChoice* old;
      g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_SCHEMA_CHOICE));
      old = value->data[0].v_pointer;
      if (v_object) {
            g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, TYPE_SCHEMA_CHOICE));
            g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
            value->data[0].v_pointer = v_object;
            schema_choice_ref (value->data[0].v_pointer);
      } else {
            value->data[0].v_pointer = NULL;
      }
      if (old) {
            schema_choice_unref (old);
      }
}


void value_take_schema_choice (GValue* value, gpointer v_object) {
      SchemaChoice* old;
      g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_SCHEMA_CHOICE));
      old = value->data[0].v_pointer;
      if (v_object) {
            g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, TYPE_SCHEMA_CHOICE));
            g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
            value->data[0].v_pointer = v_object;
      } else {
            value->data[0].v_pointer = NULL;
      }
      if (old) {
            schema_choice_unref (old);
      }
}


static void schema_choice_class_init (SchemaChoiceClass * klass) {
      schema_choice_parent_class = g_type_class_peek_parent (klass);
      SCHEMA_CHOICE_CLASS (klass)->finalize = schema_choice_finalize;
}


static void schema_choice_instance_init (SchemaChoice * self) {
      self->ref_count = 1;
}


static void schema_choice_finalize (SchemaChoice* obj) {
      SchemaChoice * self;
      self = SCHEMA_CHOICE (obj);
      _g_free0 (self->name);
      _g_variant_unref0 (self->value);
}


GType schema_choice_get_type (void) {
      static volatile gsize schema_choice_type_id__volatile = 0;
      if (g_once_init_enter (&schema_choice_type_id__volatile)) {
            static const GTypeValueTable g_define_type_value_table = { value_schema_choice_init, value_schema_choice_free_value, value_schema_choice_copy_value, value_schema_choice_peek_pointer, "p", value_schema_choice_collect_value, "p", value_schema_choice_lcopy_value };
            static const GTypeInfo g_define_type_info = { sizeof (SchemaChoiceClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) schema_choice_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (SchemaChoice), 0, (GInstanceInitFunc) schema_choice_instance_init, &g_define_type_value_table };
            static const GTypeFundamentalInfo g_define_type_fundamental_info = { (G_TYPE_FLAG_CLASSED | G_TYPE_FLAG_INSTANTIATABLE | G_TYPE_FLAG_DERIVABLE | G_TYPE_FLAG_DEEP_DERIVABLE) };
            GType schema_choice_type_id;
            schema_choice_type_id = g_type_register_fundamental (g_type_fundamental_next (), "SchemaChoice", &g_define_type_info, &g_define_type_fundamental_info, 0);
            g_once_init_leave (&schema_choice_type_id__volatile, schema_choice_type_id);
      }
      return schema_choice_type_id__volatile;
}


gpointer schema_choice_ref (gpointer instance) {
      SchemaChoice* self;
      self = instance;
      g_atomic_int_inc (&self->ref_count);
      return instance;
}


void schema_choice_unref (gpointer instance) {
      SchemaChoice* self;
      self = instance;
      if (g_atomic_int_dec_and_test (&self->ref_count)) {
            SCHEMA_CHOICE_GET_CLASS (self)->finalize (self);
            g_type_free_instance ((GTypeInstance *) self);
      }
}


SchemaValueRange* schema_value_range_construct_from_xml (GType object_type, const gchar* type, xmlNode* node) {
      SchemaValueRange* self = NULL;
      GError * _inner_error_ = NULL;
      g_return_val_if_fail (type != NULL, NULL);
      self = (SchemaValueRange*) g_type_create_instance (object_type);
      {
            xmlAttr* prop;
            prop = node->properties;
            {
                  gboolean _tmp0_;
                  _tmp0_ = TRUE;
                  while (TRUE) {
                        if (!_tmp0_) {
                              prop = prop->next;
                        }
                        _tmp0_ = FALSE;
                        if (!(prop != NULL)) {
                              break;
                        }
                        if (g_strcmp0 (prop->name, "min") == 0) {
                              GVariantType* _tmp1_ = NULL;
                              GVariantType* _tmp2_;
                              GVariant* _tmp3_ = NULL;
                              GVariant* _tmp4_;
                              GVariant* _tmp5_;
                              _tmp1_ = g_variant_type_new (type);
                              _tmp2_ = _tmp1_;
                              _tmp3_ = g_variant_parse (_tmp2_, prop->children->content, NULL, NULL, &_inner_error_);
                              _tmp4_ = _tmp3_;
                              _g_variant_type_free0 (_tmp2_);
                              _tmp5_ = _tmp4_;
                              if (_inner_error_ != NULL) {
                                    if (_inner_error_->domain == G_VARIANT_PARSE_ERROR) {
                                          goto __catch7_g_variant_parse_error;
                                    }
                                    g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                                    g_clear_error (&_inner_error_);
                                    return NULL;
                              }
                              _g_variant_unref0 (self->min);
                              self->min = _tmp5_;
                              goto __finally7;
                              __catch7_g_variant_parse_error:
                              {
                                    GError * e;
                                    e = _inner_error_;
                                    _inner_error_ = NULL;
                                    _g_error_free0 (e);
                              }
                              __finally7:
                              if (_inner_error_ != NULL) {
                                    g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                                    g_clear_error (&_inner_error_);
                                    return NULL;
                              }
                        } else {
                              if (g_strcmp0 (prop->name, "max") == 0) {
                                    GVariantType* _tmp6_ = NULL;
                                    GVariantType* _tmp7_;
                                    GVariant* _tmp8_ = NULL;
                                    GVariant* _tmp9_;
                                    GVariant* _tmp10_;
                                    _tmp6_ = g_variant_type_new (type);
                                    _tmp7_ = _tmp6_;
                                    _tmp8_ = g_variant_parse (_tmp7_, prop->children->content, NULL, NULL, &_inner_error_);
                                    _tmp9_ = _tmp8_;
                                    _g_variant_type_free0 (_tmp7_);
                                    _tmp10_ = _tmp9_;
                                    if (_inner_error_ != NULL) {
                                          if (_inner_error_->domain == G_VARIANT_PARSE_ERROR) {
                                                goto __catch8_g_variant_parse_error;
                                          }
                                          g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                                          g_clear_error (&_inner_error_);
                                          return NULL;
                                    }
                                    _g_variant_unref0 (self->max);
                                    self->max = _tmp10_;
                                    goto __finally8;
                                    __catch8_g_variant_parse_error:
                                    {
                                          GError * e;
                                          e = _inner_error_;
                                          _inner_error_ = NULL;
                                          _g_error_free0 (e);
                                    }
                                    __finally8:
                                    if (_inner_error_ != NULL) {
                                          g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
                                          g_clear_error (&_inner_error_);
                                          return NULL;
                                    }
                              } else {
                                    g_warning ("dconf-schema.vala:212: Unknown property in <range>, %s", prop->name);
                              }
                        }
                  }
            }
      }
      return self;
}


SchemaValueRange* schema_value_range_new_from_xml (const gchar* type, xmlNode* node) {
      return schema_value_range_construct_from_xml (TYPE_SCHEMA_VALUE_RANGE, type, node);
}


SchemaValueRange* schema_value_range_construct (GType object_type) {
      SchemaValueRange* self = NULL;
      self = (SchemaValueRange*) g_type_create_instance (object_type);
      return self;
}


SchemaValueRange* schema_value_range_new (void) {
      return schema_value_range_construct (TYPE_SCHEMA_VALUE_RANGE);
}


static void value_schema_value_range_init (GValue* value) {
      value->data[0].v_pointer = NULL;
}


static void value_schema_value_range_free_value (GValue* value) {
      if (value->data[0].v_pointer) {
            schema_value_range_unref (value->data[0].v_pointer);
      }
}


static void value_schema_value_range_copy_value (const GValue* src_value, GValue* dest_value) {
      if (src_value->data[0].v_pointer) {
            dest_value->data[0].v_pointer = schema_value_range_ref (src_value->data[0].v_pointer);
      } else {
            dest_value->data[0].v_pointer = NULL;
      }
}


static gpointer value_schema_value_range_peek_pointer (const GValue* value) {
      return value->data[0].v_pointer;
}


static gchar* value_schema_value_range_collect_value (GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {
      if (collect_values[0].v_pointer) {
            SchemaValueRange* object;
            object = collect_values[0].v_pointer;
            if (object->parent_instance.g_class == NULL) {
                  return g_strconcat ("invalid unclassed object pointer for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
            } else if (!g_value_type_compatible (G_TYPE_FROM_INSTANCE (object), G_VALUE_TYPE (value))) {
                  return g_strconcat ("invalid object type `", g_type_name (G_TYPE_FROM_INSTANCE (object)), "' for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
            }
            value->data[0].v_pointer = schema_value_range_ref (object);
      } else {
            value->data[0].v_pointer = NULL;
      }
      return NULL;
}


static gchar* value_schema_value_range_lcopy_value (const GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {
      SchemaValueRange** object_p;
      object_p = collect_values[0].v_pointer;
      if (!object_p) {
            return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
      }
      if (!value->data[0].v_pointer) {
            *object_p = NULL;
      } else if (collect_flags & G_VALUE_NOCOPY_CONTENTS) {
            *object_p = value->data[0].v_pointer;
      } else {
            *object_p = schema_value_range_ref (value->data[0].v_pointer);
      }
      return NULL;
}


GParamSpec* param_spec_schema_value_range (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags) {
      ParamSpecSchemaValueRange* spec;
      g_return_val_if_fail (g_type_is_a (object_type, TYPE_SCHEMA_VALUE_RANGE), NULL);
      spec = g_param_spec_internal (G_TYPE_PARAM_OBJECT, name, nick, blurb, flags);
      G_PARAM_SPEC (spec)->value_type = object_type;
      return G_PARAM_SPEC (spec);
}


gpointer value_get_schema_value_range (const GValue* value) {
      g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_SCHEMA_VALUE_RANGE), NULL);
      return value->data[0].v_pointer;
}


void value_set_schema_value_range (GValue* value, gpointer v_object) {
      SchemaValueRange* old;
      g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_SCHEMA_VALUE_RANGE));
      old = value->data[0].v_pointer;
      if (v_object) {
            g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, TYPE_SCHEMA_VALUE_RANGE));
            g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
            value->data[0].v_pointer = v_object;
            schema_value_range_ref (value->data[0].v_pointer);
      } else {
            value->data[0].v_pointer = NULL;
      }
      if (old) {
            schema_value_range_unref (old);
      }
}


void value_take_schema_value_range (GValue* value, gpointer v_object) {
      SchemaValueRange* old;
      g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_SCHEMA_VALUE_RANGE));
      old = value->data[0].v_pointer;
      if (v_object) {
            g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, TYPE_SCHEMA_VALUE_RANGE));
            g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
            value->data[0].v_pointer = v_object;
      } else {
            value->data[0].v_pointer = NULL;
      }
      if (old) {
            schema_value_range_unref (old);
      }
}


static void schema_value_range_class_init (SchemaValueRangeClass * klass) {
      schema_value_range_parent_class = g_type_class_peek_parent (klass);
      SCHEMA_VALUE_RANGE_CLASS (klass)->finalize = schema_value_range_finalize;
}


static void schema_value_range_instance_init (SchemaValueRange * self) {
      self->ref_count = 1;
}


static void schema_value_range_finalize (SchemaValueRange* obj) {
      SchemaValueRange * self;
      self = SCHEMA_VALUE_RANGE (obj);
      _g_variant_unref0 (self->min);
      _g_variant_unref0 (self->max);
}


GType schema_value_range_get_type (void) {
      static volatile gsize schema_value_range_type_id__volatile = 0;
      if (g_once_init_enter (&schema_value_range_type_id__volatile)) {
            static const GTypeValueTable g_define_type_value_table = { value_schema_value_range_init, value_schema_value_range_free_value, value_schema_value_range_copy_value, value_schema_value_range_peek_pointer, "p", value_schema_value_range_collect_value, "p", value_schema_value_range_lcopy_value };
            static const GTypeInfo g_define_type_info = { sizeof (SchemaValueRangeClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) schema_value_range_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (SchemaValueRange), 0, (GInstanceInitFunc) schema_value_range_instance_init, &g_define_type_value_table };
            static const GTypeFundamentalInfo g_define_type_fundamental_info = { (G_TYPE_FLAG_CLASSED | G_TYPE_FLAG_INSTANTIATABLE | G_TYPE_FLAG_DERIVABLE | G_TYPE_FLAG_DEEP_DERIVABLE) };
            GType schema_value_range_type_id;
            schema_value_range_type_id = g_type_register_fundamental (g_type_fundamental_next (), "SchemaValueRange", &g_define_type_info, &g_define_type_fundamental_info, 0);
            g_once_init_leave (&schema_value_range_type_id__volatile, schema_value_range_type_id);
      }
      return schema_value_range_type_id__volatile;
}


gpointer schema_value_range_ref (gpointer instance) {
      SchemaValueRange* self;
      self = instance;
      g_atomic_int_inc (&self->ref_count);
      return instance;
}


void schema_value_range_unref (gpointer instance) {
      SchemaValueRange* self;
      self = instance;
      if (g_atomic_int_dec_and_test (&self->ref_count)) {
            SCHEMA_VALUE_RANGE_GET_CLASS (self)->finalize (self);
            g_type_free_instance ((GTypeInstance *) self);
      }
}


static void _g_object_unref0_ (gpointer var) {
      (var == NULL) ? NULL : (var = (g_object_unref (var), NULL));
}


static void _g_list_free__g_object_unref0_ (GList* self) {
      g_list_foreach (self, (GFunc) _g_object_unref0_, NULL);
      g_list_free (self);
}


static gpointer _schema_list_ref0 (gpointer self) {
      return self ? schema_list_ref (self) : NULL;
}


static gpointer _g_object_ref0 (gpointer self) {
      return self ? g_object_ref (self) : NULL;
}


SchemaEnum* schema_enum_construct_from_xml (GType object_type, SchemaList* list, xmlNode* node) {
      SchemaEnum* self = NULL;
      SchemaList* _tmp0_;
      g_return_val_if_fail (list != NULL, NULL);
      self = (SchemaEnum*) g_type_create_instance (object_type);
      _tmp0_ = _schema_list_ref0 (list);
      _schema_list_unref0 (self->list);
      self->list = _tmp0_;
      {
            xmlAttr* prop;
            prop = node->properties;
            {
                  gboolean _tmp1_;
                  _tmp1_ = TRUE;
                  while (TRUE) {
                        if (!_tmp1_) {
                              prop = prop->next;
                        }
                        _tmp1_ = FALSE;
                        if (!(prop != NULL)) {
                              break;
                        }
                        if (g_strcmp0 (prop->name, "id") == 0) {
                              gchar* _tmp2_;
                              _tmp2_ = g_strdup (prop->children->content);
                              _g_free0 (self->id);
                              self->id = _tmp2_;
                        } else {
                              g_warning ("dconf-schema.vala:235: Unknown property in <enum>, %s", prop->name);
                        }
                  }
            }
      }
      {
            xmlNode* child;
            child = node->children;
            {
                  gboolean _tmp3_;
                  _tmp3_ = TRUE;
                  while (TRUE) {
                        if (!_tmp3_) {
                              child = child->next;
                        }
                        _tmp3_ = FALSE;
                        if (!(child != NULL)) {
                              break;
                        }
                        if (g_strcmp0 (child->name, "value") == 0) {
                              gchar* nick;
                              gint value;
                              guint _tmp7_;
                              SchemaValue* _tmp8_ = NULL;
                              SchemaValue* schema_value;
                              SchemaValue* _tmp9_;
                              nick = NULL;
                              value = -1;
                              {
                                    xmlAttr* prop;
                                    prop = child->properties;
                                    {
                                          gboolean _tmp4_;
                                          _tmp4_ = TRUE;
                                          while (TRUE) {
                                                if (!_tmp4_) {
                                                      prop = prop->next;
                                                }
                                                _tmp4_ = FALSE;
                                                if (!(prop != NULL)) {
                                                      break;
                                                }
                                                if (g_strcmp0 (prop->name, "value") == 0) {
                                                      gint _tmp5_;
                                                      _tmp5_ = atoi (prop->children->content);
                                                      value = _tmp5_;
                                                } else {
                                                      if (g_strcmp0 (prop->name, "nick") == 0) {
                                                            gchar* _tmp6_;
                                                            _tmp6_ = g_strdup (prop->children->content);
                                                            _g_free0 (nick);
                                                            nick = _tmp6_;
                                                      } else {
                                                            g_warning ("dconf-schema.vala:255: Unknown property in enum <value>, %s", prop->name);
                                                      }
                                                }
                                          }
                                    }
                              }
                              _tmp7_ = g_list_length (self->values);
                              _tmp8_ = schema_value_new (_tmp7_, nick, value);
                              schema_value = _tmp8_;
                              _tmp9_ = _g_object_ref0 (schema_value);
                              self->values = g_list_append (self->values, _tmp9_);
                              _g_object_unref0 (schema_value);
                              _g_free0 (nick);
                        } else {
                              gboolean _tmp10_ = FALSE;
                              if (child->type != XML_TEXT_NODE) {
                                    _tmp10_ = child->type != XML_COMMENT_NODE;
                              } else {
                                    _tmp10_ = FALSE;
                              }
                              if (_tmp10_) {
                                    g_warning ("dconf-schema.vala:265: Unknown tag in <enum>, <%s>", child->name);
                              }
                        }
                  }
            }
      }
      return self;
}


SchemaEnum* schema_enum_new_from_xml (SchemaList* list, xmlNode* node) {
      return schema_enum_construct_from_xml (TYPE_SCHEMA_ENUM, list, node);
}


SchemaEnum* schema_enum_construct (GType object_type) {
      SchemaEnum* self = NULL;
      self = (SchemaEnum*) g_type_create_instance (object_type);
      return self;
}


SchemaEnum* schema_enum_new (void) {
      return schema_enum_construct (TYPE_SCHEMA_ENUM);
}


static void value_schema_enum_init (GValue* value) {
      value->data[0].v_pointer = NULL;
}


static void value_schema_enum_free_value (GValue* value) {
      if (value->data[0].v_pointer) {
            schema_enum_unref (value->data[0].v_pointer);
      }
}


static void value_schema_enum_copy_value (const GValue* src_value, GValue* dest_value) {
      if (src_value->data[0].v_pointer) {
            dest_value->data[0].v_pointer = schema_enum_ref (src_value->data[0].v_pointer);
      } else {
            dest_value->data[0].v_pointer = NULL;
      }
}


static gpointer value_schema_enum_peek_pointer (const GValue* value) {
      return value->data[0].v_pointer;
}


static gchar* value_schema_enum_collect_value (GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {
      if (collect_values[0].v_pointer) {
            SchemaEnum* object;
            object = collect_values[0].v_pointer;
            if (object->parent_instance.g_class == NULL) {
                  return g_strconcat ("invalid unclassed object pointer for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
            } else if (!g_value_type_compatible (G_TYPE_FROM_INSTANCE (object), G_VALUE_TYPE (value))) {
                  return g_strconcat ("invalid object type `", g_type_name (G_TYPE_FROM_INSTANCE (object)), "' for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
            }
            value->data[0].v_pointer = schema_enum_ref (object);
      } else {
            value->data[0].v_pointer = NULL;
      }
      return NULL;
}


static gchar* value_schema_enum_lcopy_value (const GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {
      SchemaEnum** object_p;
      object_p = collect_values[0].v_pointer;
      if (!object_p) {
            return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
      }
      if (!value->data[0].v_pointer) {
            *object_p = NULL;
      } else if (collect_flags & G_VALUE_NOCOPY_CONTENTS) {
            *object_p = value->data[0].v_pointer;
      } else {
            *object_p = schema_enum_ref (value->data[0].v_pointer);
      }
      return NULL;
}


GParamSpec* param_spec_schema_enum (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags) {
      ParamSpecSchemaEnum* spec;
      g_return_val_if_fail (g_type_is_a (object_type, TYPE_SCHEMA_ENUM), NULL);
      spec = g_param_spec_internal (G_TYPE_PARAM_OBJECT, name, nick, blurb, flags);
      G_PARAM_SPEC (spec)->value_type = object_type;
      return G_PARAM_SPEC (spec);
}


gpointer value_get_schema_enum (const GValue* value) {
      g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_SCHEMA_ENUM), NULL);
      return value->data[0].v_pointer;
}


void value_set_schema_enum (GValue* value, gpointer v_object) {
      SchemaEnum* old;
      g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_SCHEMA_ENUM));
      old = value->data[0].v_pointer;
      if (v_object) {
            g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, TYPE_SCHEMA_ENUM));
            g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
            value->data[0].v_pointer = v_object;
            schema_enum_ref (value->data[0].v_pointer);
      } else {
            value->data[0].v_pointer = NULL;
      }
      if (old) {
            schema_enum_unref (old);
      }
}


void value_take_schema_enum (GValue* value, gpointer v_object) {
      SchemaEnum* old;
      g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_SCHEMA_ENUM));
      old = value->data[0].v_pointer;
      if (v_object) {
            g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, TYPE_SCHEMA_ENUM));
            g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
            value->data[0].v_pointer = v_object;
      } else {
            value->data[0].v_pointer = NULL;
      }
      if (old) {
            schema_enum_unref (old);
      }
}


static void schema_enum_class_init (SchemaEnumClass * klass) {
      schema_enum_parent_class = g_type_class_peek_parent (klass);
      SCHEMA_ENUM_CLASS (klass)->finalize = schema_enum_finalize;
}


static void schema_enum_instance_init (SchemaEnum * self) {
      self->values = NULL;
      self->ref_count = 1;
}


static void schema_enum_finalize (SchemaEnum* obj) {
      SchemaEnum * self;
      self = SCHEMA_ENUM (obj);
      _schema_list_unref0 (self->list);
      _g_free0 (self->id);
      __g_list_free__g_object_unref0_0 (self->values);
}


GType schema_enum_get_type (void) {
      static volatile gsize schema_enum_type_id__volatile = 0;
      if (g_once_init_enter (&schema_enum_type_id__volatile)) {
            static const GTypeValueTable g_define_type_value_table = { value_schema_enum_init, value_schema_enum_free_value, value_schema_enum_copy_value, value_schema_enum_peek_pointer, "p", value_schema_enum_collect_value, "p", value_schema_enum_lcopy_value };
            static const GTypeInfo g_define_type_info = { sizeof (SchemaEnumClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) schema_enum_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (SchemaEnum), 0, (GInstanceInitFunc) schema_enum_instance_init, &g_define_type_value_table };
            static const GTypeFundamentalInfo g_define_type_fundamental_info = { (G_TYPE_FLAG_CLASSED | G_TYPE_FLAG_INSTANTIATABLE | G_TYPE_FLAG_DERIVABLE | G_TYPE_FLAG_DEEP_DERIVABLE) };
            GType schema_enum_type_id;
            schema_enum_type_id = g_type_register_fundamental (g_type_fundamental_next (), "SchemaEnum", &g_define_type_info, &g_define_type_fundamental_info, 0);
            g_once_init_leave (&schema_enum_type_id__volatile, schema_enum_type_id);
      }
      return schema_enum_type_id__volatile;
}


gpointer schema_enum_ref (gpointer instance) {
      SchemaEnum* self;
      self = instance;
      g_atomic_int_inc (&self->ref_count);
      return instance;
}


void schema_enum_unref (gpointer instance) {
      SchemaEnum* self;
      self = instance;
      if (g_atomic_int_dec_and_test (&self->ref_count)) {
            SCHEMA_ENUM_GET_CLASS (self)->finalize (self);
            g_type_free_instance ((GTypeInstance *) self);
      }
}


SchemaFlags* schema_flags_construct_from_xml (GType object_type, SchemaList* list, xmlNode* node) {
      SchemaFlags* self = NULL;
      SchemaList* _tmp0_;
      g_return_val_if_fail (list != NULL, NULL);
      self = (SchemaFlags*) g_type_create_instance (object_type);
      _tmp0_ = _schema_list_ref0 (list);
      _schema_list_unref0 (self->list);
      self->list = _tmp0_;
      {
            xmlAttr* prop;
            prop = node->properties;
            {
                  gboolean _tmp1_;
                  _tmp1_ = TRUE;
                  while (TRUE) {
                        if (!_tmp1_) {
                              prop = prop->next;
                        }
                        _tmp1_ = FALSE;
                        if (!(prop != NULL)) {
                              break;
                        }
                        if (g_strcmp0 (prop->name, "id") == 0) {
                              gchar* _tmp2_;
                              _tmp2_ = g_strdup (prop->children->content);
                              _g_free0 (self->id);
                              self->id = _tmp2_;
                        } else {
                              g_warning ("dconf-schema.vala:288: Unknown property in <flags>, %s", prop->name);
                        }
                  }
            }
      }
      {
            xmlNode* child;
            child = node->children;
            {
                  gboolean _tmp3_;
                  _tmp3_ = TRUE;
                  while (TRUE) {
                        if (!_tmp3_) {
                              child = child->next;
                        }
                        _tmp3_ = FALSE;
                        if (!(child != NULL)) {
                              break;
                        }
                        if (g_strcmp0 (child->name, "value") == 0) {
                              gchar* nick;
                              gint value;
                              guint _tmp7_;
                              SchemaValue* _tmp8_ = NULL;
                              SchemaValue* schema_value;
                              SchemaValue* _tmp9_;
                              nick = NULL;
                              value = -1;
                              {
                                    xmlAttr* prop;
                                    prop = child->properties;
                                    {
                                          gboolean _tmp4_;
                                          _tmp4_ = TRUE;
                                          while (TRUE) {
                                                if (!_tmp4_) {
                                                      prop = prop->next;
                                                }
                                                _tmp4_ = FALSE;
                                                if (!(prop != NULL)) {
                                                      break;
                                                }
                                                if (g_strcmp0 (prop->name, "value") == 0) {
                                                      gint _tmp5_;
                                                      _tmp5_ = atoi (prop->children->content);
                                                      value = _tmp5_;
                                                } else {
                                                      if (g_strcmp0 (prop->name, "nick") == 0) {
                                                            gchar* _tmp6_;
                                                            _tmp6_ = g_strdup (prop->children->content);
                                                            _g_free0 (nick);
                                                            nick = _tmp6_;
                                                      } else {
                                                            g_warning ("dconf-schema.vala:308: Unknown property in flags <value>, %s", prop->name);
                                                      }
                                                }
                                          }
                                    }
                              }
                              _tmp7_ = g_list_length (self->values);
                              _tmp8_ = schema_value_new (_tmp7_, nick, value);
                              schema_value = _tmp8_;
                              _tmp9_ = _g_object_ref0 (schema_value);
                              self->values = g_list_append (self->values, _tmp9_);
                              _g_object_unref0 (schema_value);
                              _g_free0 (nick);
                        } else {
                              gboolean _tmp10_ = FALSE;
                              if (child->type != XML_TEXT_NODE) {
                                    _tmp10_ = child->type != XML_COMMENT_NODE;
                              } else {
                                    _tmp10_ = FALSE;
                              }
                              if (_tmp10_) {
                                    g_warning ("dconf-schema.vala:318: Unknown tag in <flags>, <%s>", child->name);
                              }
                        }
                  }
            }
      }
      return self;
}


SchemaFlags* schema_flags_new_from_xml (SchemaList* list, xmlNode* node) {
      return schema_flags_construct_from_xml (TYPE_SCHEMA_FLAGS, list, node);
}


SchemaFlags* schema_flags_construct (GType object_type) {
      SchemaFlags* self = NULL;
      self = (SchemaFlags*) g_type_create_instance (object_type);
      return self;
}


SchemaFlags* schema_flags_new (void) {
      return schema_flags_construct (TYPE_SCHEMA_FLAGS);
}


static void value_schema_flags_init (GValue* value) {
      value->data[0].v_pointer = NULL;
}


static void value_schema_flags_free_value (GValue* value) {
      if (value->data[0].v_pointer) {
            schema_flags_unref (value->data[0].v_pointer);
      }
}


static void value_schema_flags_copy_value (const GValue* src_value, GValue* dest_value) {
      if (src_value->data[0].v_pointer) {
            dest_value->data[0].v_pointer = schema_flags_ref (src_value->data[0].v_pointer);
      } else {
            dest_value->data[0].v_pointer = NULL;
      }
}


static gpointer value_schema_flags_peek_pointer (const GValue* value) {
      return value->data[0].v_pointer;
}


static gchar* value_schema_flags_collect_value (GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {
      if (collect_values[0].v_pointer) {
            SchemaFlags* object;
            object = collect_values[0].v_pointer;
            if (object->parent_instance.g_class == NULL) {
                  return g_strconcat ("invalid unclassed object pointer for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
            } else if (!g_value_type_compatible (G_TYPE_FROM_INSTANCE (object), G_VALUE_TYPE (value))) {
                  return g_strconcat ("invalid object type `", g_type_name (G_TYPE_FROM_INSTANCE (object)), "' for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
            }
            value->data[0].v_pointer = schema_flags_ref (object);
      } else {
            value->data[0].v_pointer = NULL;
      }
      return NULL;
}


static gchar* value_schema_flags_lcopy_value (const GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {
      SchemaFlags** object_p;
      object_p = collect_values[0].v_pointer;
      if (!object_p) {
            return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
      }
      if (!value->data[0].v_pointer) {
            *object_p = NULL;
      } else if (collect_flags & G_VALUE_NOCOPY_CONTENTS) {
            *object_p = value->data[0].v_pointer;
      } else {
            *object_p = schema_flags_ref (value->data[0].v_pointer);
      }
      return NULL;
}


GParamSpec* param_spec_schema_flags (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags) {
      ParamSpecSchemaFlags* spec;
      g_return_val_if_fail (g_type_is_a (object_type, TYPE_SCHEMA_FLAGS), NULL);
      spec = g_param_spec_internal (G_TYPE_PARAM_OBJECT, name, nick, blurb, flags);
      G_PARAM_SPEC (spec)->value_type = object_type;
      return G_PARAM_SPEC (spec);
}


gpointer value_get_schema_flags (const GValue* value) {
      g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_SCHEMA_FLAGS), NULL);
      return value->data[0].v_pointer;
}


void value_set_schema_flags (GValue* value, gpointer v_object) {
      SchemaFlags* old;
      g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_SCHEMA_FLAGS));
      old = value->data[0].v_pointer;
      if (v_object) {
            g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, TYPE_SCHEMA_FLAGS));
            g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
            value->data[0].v_pointer = v_object;
            schema_flags_ref (value->data[0].v_pointer);
      } else {
            value->data[0].v_pointer = NULL;
      }
      if (old) {
            schema_flags_unref (old);
      }
}


void value_take_schema_flags (GValue* value, gpointer v_object) {
      SchemaFlags* old;
      g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_SCHEMA_FLAGS));
      old = value->data[0].v_pointer;
      if (v_object) {
            g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, TYPE_SCHEMA_FLAGS));
            g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
            value->data[0].v_pointer = v_object;
      } else {
            value->data[0].v_pointer = NULL;
      }
      if (old) {
            schema_flags_unref (old);
      }
}


static void schema_flags_class_init (SchemaFlagsClass * klass) {
      schema_flags_parent_class = g_type_class_peek_parent (klass);
      SCHEMA_FLAGS_CLASS (klass)->finalize = schema_flags_finalize;
}


static void schema_flags_instance_init (SchemaFlags * self) {
      self->values = NULL;
      self->ref_count = 1;
}


static void schema_flags_finalize (SchemaFlags* obj) {
      SchemaFlags * self;
      self = SCHEMA_FLAGS (obj);
      _schema_list_unref0 (self->list);
      _g_free0 (self->id);
      __g_list_free__g_object_unref0_0 (self->values);
}


GType schema_flags_get_type (void) {
      static volatile gsize schema_flags_type_id__volatile = 0;
      if (g_once_init_enter (&schema_flags_type_id__volatile)) {
            static const GTypeValueTable g_define_type_value_table = { value_schema_flags_init, value_schema_flags_free_value, value_schema_flags_copy_value, value_schema_flags_peek_pointer, "p", value_schema_flags_collect_value, "p", value_schema_flags_lcopy_value };
            static const GTypeInfo g_define_type_info = { sizeof (SchemaFlagsClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) schema_flags_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (SchemaFlags), 0, (GInstanceInitFunc) schema_flags_instance_init, &g_define_type_value_table };
            static const GTypeFundamentalInfo g_define_type_fundamental_info = { (G_TYPE_FLAG_CLASSED | G_TYPE_FLAG_INSTANTIATABLE | G_TYPE_FLAG_DERIVABLE | G_TYPE_FLAG_DEEP_DERIVABLE) };
            GType schema_flags_type_id;
            schema_flags_type_id = g_type_register_fundamental (g_type_fundamental_next (), "SchemaFlags", &g_define_type_info, &g_define_type_fundamental_info, 0);
            g_once_init_leave (&schema_flags_type_id__volatile, schema_flags_type_id);
      }
      return schema_flags_type_id__volatile;
}


gpointer schema_flags_ref (gpointer instance) {
      SchemaFlags* self;
      self = instance;
      g_atomic_int_inc (&self->ref_count);
      return instance;
}


void schema_flags_unref (gpointer instance) {
      SchemaFlags* self;
      self = instance;
      if (g_atomic_int_dec_and_test (&self->ref_count)) {
            SCHEMA_FLAGS_GET_CLASS (self)->finalize (self);
            g_type_free_instance ((GTypeInstance *) self);
      }
}


static void _g_free0_ (gpointer var) {
      var = (g_free (var), NULL);
}


static void _schema_key_unref0_ (gpointer var) {
      (var == NULL) ? NULL : (var = (schema_key_unref (var), NULL));
}


static gpointer _schema_key_ref0 (gpointer self) {
      return self ? schema_key_ref (self) : NULL;
}


Schema* schema_construct_from_xml (GType object_type, SchemaList* list, xmlNode* node, const gchar* gettext_domain) {
      Schema* self = NULL;
      SchemaList* _tmp0_;
      g_return_val_if_fail (list != NULL, NULL);
      self = (Schema*) g_type_create_instance (object_type);
      _tmp0_ = _schema_list_ref0 (list);
      _schema_list_unref0 (self->list);
      self->list = _tmp0_;
      {
            xmlAttr* prop;
            prop = node->properties;
            {
                  gboolean _tmp1_;
                  _tmp1_ = TRUE;
                  while (TRUE) {
                        if (!_tmp1_) {
                              prop = prop->next;
                        }
                        _tmp1_ = FALSE;
                        if (!(prop != NULL)) {
                              break;
                        }
                        if (g_strcmp0 (prop->name, "id") == 0) {
                              gchar* _tmp2_;
                              _tmp2_ = g_strdup (prop->children->content);
                              _g_free0 (self->id);
                              self->id = _tmp2_;
                        } else {
                              if (g_strcmp0 (prop->name, "path") == 0) {
                                    gchar* _tmp3_;
                                    _tmp3_ = g_strdup (prop->children->content);
                                    _g_free0 (self->path);
                                    self->path = _tmp3_;
                              } else {
                                    if (g_strcmp0 (prop->name, "gettext-domain") == 0) {
                                          gettext_domain = prop->children->content;
                                    } else {
                                          g_warning ("dconf-schema.vala:346: Unknown property on <schema>, %s", prop->name);
                                    }
                              }
                        }
                  }
            }
      }
      {
            xmlNode* child;
            child = node->children;
            {
                  gboolean _tmp4_;
                  _tmp4_ = TRUE;
                  while (TRUE) {
                        SchemaKey* _tmp5_ = NULL;
                        SchemaKey* key;
                        gchar* _tmp6_;
                        SchemaKey* _tmp7_;
                        if (!_tmp4_) {
                              child = child->next;
                        }
                        _tmp4_ = FALSE;
                        if (!(child != NULL)) {
                              break;
                        }
                        if (g_strcmp0 (child->name, "key") != 0) {
                              continue;
                        }
                        _tmp5_ = schema_key_new_from_xml (child, self, gettext_domain);
                        key = _tmp5_;
                        _tmp6_ = g_strdup (key->name);
                        _tmp7_ = _schema_key_ref0 (key);
                        g_hash_table_insert (self->keys, _tmp6_, _tmp7_);
                        _schema_key_unref0 (key);
                  }
            }
      }
      return self;
}


Schema* schema_new_from_xml (SchemaList* list, xmlNode* node, const gchar* gettext_domain) {
      return schema_construct_from_xml (TYPE_SCHEMA, list, node, gettext_domain);
}


Schema* schema_construct (GType object_type) {
      Schema* self = NULL;
      self = (Schema*) g_type_create_instance (object_type);
      return self;
}


Schema* schema_new (void) {
      return schema_construct (TYPE_SCHEMA);
}


static void value_schema_init (GValue* value) {
      value->data[0].v_pointer = NULL;
}


static void value_schema_free_value (GValue* value) {
      if (value->data[0].v_pointer) {
            schema_unref (value->data[0].v_pointer);
      }
}


static void value_schema_copy_value (const GValue* src_value, GValue* dest_value) {
      if (src_value->data[0].v_pointer) {
            dest_value->data[0].v_pointer = schema_ref (src_value->data[0].v_pointer);
      } else {
            dest_value->data[0].v_pointer = NULL;
      }
}


static gpointer value_schema_peek_pointer (const GValue* value) {
      return value->data[0].v_pointer;
}


static gchar* value_schema_collect_value (GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {
      if (collect_values[0].v_pointer) {
            Schema* object;
            object = collect_values[0].v_pointer;
            if (object->parent_instance.g_class == NULL) {
                  return g_strconcat ("invalid unclassed object pointer for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
            } else if (!g_value_type_compatible (G_TYPE_FROM_INSTANCE (object), G_VALUE_TYPE (value))) {
                  return g_strconcat ("invalid object type `", g_type_name (G_TYPE_FROM_INSTANCE (object)), "' for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
            }
            value->data[0].v_pointer = schema_ref (object);
      } else {
            value->data[0].v_pointer = NULL;
      }
      return NULL;
}


static gchar* value_schema_lcopy_value (const GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {
      Schema** object_p;
      object_p = collect_values[0].v_pointer;
      if (!object_p) {
            return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
      }
      if (!value->data[0].v_pointer) {
            *object_p = NULL;
      } else if (collect_flags & G_VALUE_NOCOPY_CONTENTS) {
            *object_p = value->data[0].v_pointer;
      } else {
            *object_p = schema_ref (value->data[0].v_pointer);
      }
      return NULL;
}


GParamSpec* param_spec_schema (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags) {
      ParamSpecSchema* spec;
      g_return_val_if_fail (g_type_is_a (object_type, TYPE_SCHEMA), NULL);
      spec = g_param_spec_internal (G_TYPE_PARAM_OBJECT, name, nick, blurb, flags);
      G_PARAM_SPEC (spec)->value_type = object_type;
      return G_PARAM_SPEC (spec);
}


gpointer value_get_schema (const GValue* value) {
      g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_SCHEMA), NULL);
      return value->data[0].v_pointer;
}


void value_set_schema (GValue* value, gpointer v_object) {
      Schema* old;
      g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_SCHEMA));
      old = value->data[0].v_pointer;
      if (v_object) {
            g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, TYPE_SCHEMA));
            g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
            value->data[0].v_pointer = v_object;
            schema_ref (value->data[0].v_pointer);
      } else {
            value->data[0].v_pointer = NULL;
      }
      if (old) {
            schema_unref (old);
      }
}


void value_take_schema (GValue* value, gpointer v_object) {
      Schema* old;
      g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_SCHEMA));
      old = value->data[0].v_pointer;
      if (v_object) {
            g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, TYPE_SCHEMA));
            g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
            value->data[0].v_pointer = v_object;
      } else {
            value->data[0].v_pointer = NULL;
      }
      if (old) {
            schema_unref (old);
      }
}


static void schema_class_init (SchemaClass * klass) {
      schema_parent_class = g_type_class_peek_parent (klass);
      SCHEMA_CLASS (klass)->finalize = schema_finalize;
}


static void schema_instance_init (Schema * self) {
      GHashTable* _tmp0_ = NULL;
      _tmp0_ = g_hash_table_new_full (g_str_hash, g_str_equal, _g_free0_, _schema_key_unref0_);
      self->keys = _tmp0_;
      self->ref_count = 1;
}


static void schema_finalize (Schema* obj) {
      Schema * self;
      self = SCHEMA (obj);
      _schema_list_unref0 (self->list);
      _g_free0 (self->id);
      _g_free0 (self->path);
      _g_hash_table_unref0 (self->keys);
}


GType schema_get_type (void) {
      static volatile gsize schema_type_id__volatile = 0;
      if (g_once_init_enter (&schema_type_id__volatile)) {
            static const GTypeValueTable g_define_type_value_table = { value_schema_init, value_schema_free_value, value_schema_copy_value, value_schema_peek_pointer, "p", value_schema_collect_value, "p", value_schema_lcopy_value };
            static const GTypeInfo g_define_type_info = { sizeof (SchemaClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) schema_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (Schema), 0, (GInstanceInitFunc) schema_instance_init, &g_define_type_value_table };
            static const GTypeFundamentalInfo g_define_type_fundamental_info = { (G_TYPE_FLAG_CLASSED | G_TYPE_FLAG_INSTANTIATABLE | G_TYPE_FLAG_DERIVABLE | G_TYPE_FLAG_DEEP_DERIVABLE) };
            GType schema_type_id;
            schema_type_id = g_type_register_fundamental (g_type_fundamental_next (), "Schema", &g_define_type_info, &g_define_type_fundamental_info, 0);
            g_once_init_leave (&schema_type_id__volatile, schema_type_id);
      }
      return schema_type_id__volatile;
}


gpointer schema_ref (gpointer instance) {
      Schema* self;
      self = instance;
      g_atomic_int_inc (&self->ref_count);
      return instance;
}


void schema_unref (gpointer instance) {
      Schema* self;
      self = instance;
      if (g_atomic_int_dec_and_test (&self->ref_count)) {
            SCHEMA_GET_CLASS (self)->finalize (self);
            g_type_free_instance ((GTypeInstance *) self);
      }
}


static void _schema_unref0_ (gpointer var) {
      (var == NULL) ? NULL : (var = (schema_unref (var), NULL));
}


static void _g_list_free__schema_unref0_ (GList* self) {
      g_list_foreach (self, (GFunc) _schema_unref0_, NULL);
      g_list_free (self);
}


static void _schema_enum_unref0_ (gpointer var) {
      (var == NULL) ? NULL : (var = (schema_enum_unref (var), NULL));
}


static void _schema_flags_unref0_ (gpointer var) {
      (var == NULL) ? NULL : (var = (schema_flags_unref (var), NULL));
}


static gpointer _schema_enum_ref0 (gpointer self) {
      return self ? schema_enum_ref (self) : NULL;
}


static gpointer _schema_flags_ref0 (gpointer self) {
      return self ? schema_flags_ref (self) : NULL;
}


void schema_list_parse_file (SchemaList* self, const gchar* path) {
      xmlDoc* _tmp0_ = NULL;
      xmlDoc* doc;
      xmlNode* _tmp1_ = NULL;
      xmlNode* root;
      gchar* gettext_domain;
      g_return_if_fail (self != NULL);
      g_return_if_fail (path != NULL);
      _tmp0_ = xmlParseFile (path);
      doc = _tmp0_;
      if (doc == NULL) {
            return;
      }
      _tmp1_ = xmlDocGetRootElement (doc);
      root = _tmp1_;
      if (root == NULL) {
            return;
      }
      if (g_strcmp0 (root->name, "schemalist") != 0) {
            return;
      }
      gettext_domain = NULL;
      {
            xmlAttr* prop;
            prop = root->properties;
            {
                  gboolean _tmp2_;
                  _tmp2_ = TRUE;
                  while (TRUE) {
                        if (!_tmp2_) {
                              prop = prop->next;
                        }
                        _tmp2_ = FALSE;
                        if (!(prop != NULL)) {
                              break;
                        }
                        if (g_strcmp0 (prop->name, "gettext-domain") == 0) {
                              gchar* _tmp3_;
                              _tmp3_ = g_strdup (prop->children->content);
                              _g_free0 (gettext_domain);
                              gettext_domain = _tmp3_;
                        }
                  }
            }
      }
      {
            xmlNode* node;
            node = root->children;
            {
                  gboolean _tmp4_;
                  _tmp4_ = TRUE;
                  while (TRUE) {
                        if (!_tmp4_) {
                              node = node->next;
                        }
                        _tmp4_ = FALSE;
                        if (!(node != NULL)) {
                              break;
                        }
                        if (g_strcmp0 (node->name, "schema") == 0) {
                              Schema* _tmp5_ = NULL;
                              Schema* schema;
                              GList* _tmp6_ = NULL;
                              Schema* _tmp10_;
                              _tmp5_ = schema_new_from_xml (self, node, gettext_domain);
                              schema = _tmp5_;
                              if (schema->path == NULL) {
                                    _schema_unref0 (schema);
                                    continue;
                              }
                              _tmp6_ = g_hash_table_get_values (schema->keys);
                              {
                                    GList* key_collection;
                                    GList* key_it;
                                    key_collection = _tmp6_;
                                    for (key_it = key_collection; key_it != NULL; key_it = key_it->next) {
                                          SchemaKey* key;
                                          key = (SchemaKey*) key_it->data;
                                          {
                                                gchar* _tmp7_;
                                                gchar* full_name;
                                                gchar* _tmp8_;
                                                SchemaKey* _tmp9_;
                                                _tmp7_ = g_strconcat (schema->path, key->name, NULL);
                                                full_name = _tmp7_;
                                                _tmp8_ = g_strdup (full_name);
                                                _tmp9_ = _schema_key_ref0 (key);
                                                g_hash_table_insert (self->keys, _tmp8_, _tmp9_);
                                                _g_free0 (full_name);
                                          }
                                    }
                                    _g_list_free0 (key_collection);
                              }
                              _tmp10_ = _schema_ref0 (schema);
                              self->schemas = g_list_append (self->schemas, _tmp10_);
                              _schema_unref0 (schema);
                        } else {
                              if (g_strcmp0 (node->name, "enum") == 0) {
                                    SchemaEnum* _tmp11_ = NULL;
                                    SchemaEnum* _enum_;
                                    gchar* _tmp12_;
                                    SchemaEnum* _tmp13_;
                                    _tmp11_ = schema_enum_new_from_xml (self, node);
                                    _enum_ = _tmp11_;
                                    _tmp12_ = g_strdup (_enum_->id);
                                    _tmp13_ = _schema_enum_ref0 (_enum_);
                                    g_hash_table_insert (self->enums, _tmp12_, _tmp13_);
                                    _schema_enum_unref0 (_enum_);
                              } else {
                                    if (g_strcmp0 (node->name, "flags") == 0) {
                                          SchemaFlags* _tmp14_ = NULL;
                                          SchemaFlags* f;
                                          gchar* _tmp15_;
                                          SchemaFlags* _tmp16_;
                                          _tmp14_ = schema_flags_new_from_xml (self, node);
                                          f = _tmp14_;
                                          _tmp15_ = g_strdup (f->id);
                                          _tmp16_ = _schema_flags_ref0 (f);
                                          g_hash_table_insert (self->flags, _tmp15_, _tmp16_);
                                          _schema_flags_unref0 (f);
                                    } else {
                                          if (node->type != XML_TEXT_NODE) {
                                                g_warning ("dconf-schema.vala:417: Unknown tag <%s>", node->name);
                                          }
                                    }
                              }
                        }
                  }
            }
      }
      xmlFreeDoc (doc);
      _g_free0 (gettext_domain);
}


void schema_list_load_directory (SchemaList* self, const gchar* dir, GError** error) {
      GFile* _tmp0_ = NULL;
      GFile* directory;
      GFileEnumerator* _tmp1_ = NULL;
      GFileEnumerator* i;
      GFileInfo* info = NULL;
      GError * _inner_error_ = NULL;
      g_return_if_fail (self != NULL);
      g_return_if_fail (dir != NULL);
      _tmp0_ = g_file_new_for_path (dir);
      directory = _tmp0_;
      _tmp1_ = g_file_enumerate_children (directory, G_FILE_ATTRIBUTE_STANDARD_NAME, 0, NULL, &_inner_error_);
      i = _tmp1_;
      if (_inner_error_ != NULL) {
            g_propagate_error (error, _inner_error_);
            _g_object_unref0 (directory);
            return;
      }
      while (TRUE) {
            GFileInfo* _tmp2_ = NULL;
            GFileInfo* _tmp3_;
            const gchar* _tmp4_ = NULL;
            gchar* _tmp5_;
            gchar* name;
            gboolean _tmp6_ = FALSE;
            gboolean _tmp7_;
            gchar* _tmp9_ = NULL;
            gchar* path;
            _tmp2_ = g_file_enumerator_next_file (i, NULL, &_inner_error_);
            _tmp3_ = _tmp2_;
            if (_inner_error_ != NULL) {
                  g_propagate_error (error, _inner_error_);
                  _g_object_unref0 (info);
                  _g_object_unref0 (i);
                  _g_object_unref0 (directory);
                  return;
            }
            _g_object_unref0 (info);
            info = _tmp3_;
            if (!(info != NULL)) {
                  break;
            }
            _tmp4_ = g_file_info_get_name (info);
            _tmp5_ = g_strdup (_tmp4_);
            name = _tmp5_;
            _tmp7_ = g_str_has_suffix (name, ".gschema.xml");
            if (!_tmp7_) {
                  gboolean _tmp8_;
                  _tmp8_ = g_str_has_suffix (name, ".enums.xml");
                  _tmp6_ = !_tmp8_;
            } else {
                  _tmp6_ = FALSE;
            }
            if (_tmp6_) {
                  _g_free0 (name);
                  continue;
            }
            _tmp9_ = g_build_filename (dir, name, NULL, NULL);
            path = _tmp9_;
            g_debug ("dconf-schema.vala:435: Loading schema: %s", path);
            schema_list_parse_file (self, path);
            _g_free0 (path);
            _g_free0 (name);
      }
      _g_object_unref0 (info);
      _g_object_unref0 (i);
      _g_object_unref0 (directory);
}


SchemaList* schema_list_construct (GType object_type) {
      SchemaList* self = NULL;
      self = (SchemaList*) g_type_create_instance (object_type);
      return self;
}


SchemaList* schema_list_new (void) {
      return schema_list_construct (TYPE_SCHEMA_LIST);
}


static void value_schema_list_init (GValue* value) {
      value->data[0].v_pointer = NULL;
}


static void value_schema_list_free_value (GValue* value) {
      if (value->data[0].v_pointer) {
            schema_list_unref (value->data[0].v_pointer);
      }
}


static void value_schema_list_copy_value (const GValue* src_value, GValue* dest_value) {
      if (src_value->data[0].v_pointer) {
            dest_value->data[0].v_pointer = schema_list_ref (src_value->data[0].v_pointer);
      } else {
            dest_value->data[0].v_pointer = NULL;
      }
}


static gpointer value_schema_list_peek_pointer (const GValue* value) {
      return value->data[0].v_pointer;
}


static gchar* value_schema_list_collect_value (GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {
      if (collect_values[0].v_pointer) {
            SchemaList* object;
            object = collect_values[0].v_pointer;
            if (object->parent_instance.g_class == NULL) {
                  return g_strconcat ("invalid unclassed object pointer for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
            } else if (!g_value_type_compatible (G_TYPE_FROM_INSTANCE (object), G_VALUE_TYPE (value))) {
                  return g_strconcat ("invalid object type `", g_type_name (G_TYPE_FROM_INSTANCE (object)), "' for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
            }
            value->data[0].v_pointer = schema_list_ref (object);
      } else {
            value->data[0].v_pointer = NULL;
      }
      return NULL;
}


static gchar* value_schema_list_lcopy_value (const GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {
      SchemaList** object_p;
      object_p = collect_values[0].v_pointer;
      if (!object_p) {
            return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
      }
      if (!value->data[0].v_pointer) {
            *object_p = NULL;
      } else if (collect_flags & G_VALUE_NOCOPY_CONTENTS) {
            *object_p = value->data[0].v_pointer;
      } else {
            *object_p = schema_list_ref (value->data[0].v_pointer);
      }
      return NULL;
}


GParamSpec* param_spec_schema_list (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags) {
      ParamSpecSchemaList* spec;
      g_return_val_if_fail (g_type_is_a (object_type, TYPE_SCHEMA_LIST), NULL);
      spec = g_param_spec_internal (G_TYPE_PARAM_OBJECT, name, nick, blurb, flags);
      G_PARAM_SPEC (spec)->value_type = object_type;
      return G_PARAM_SPEC (spec);
}


gpointer value_get_schema_list (const GValue* value) {
      g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_SCHEMA_LIST), NULL);
      return value->data[0].v_pointer;
}


void value_set_schema_list (GValue* value, gpointer v_object) {
      SchemaList* old;
      g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_SCHEMA_LIST));
      old = value->data[0].v_pointer;
      if (v_object) {
            g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, TYPE_SCHEMA_LIST));
            g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
            value->data[0].v_pointer = v_object;
            schema_list_ref (value->data[0].v_pointer);
      } else {
            value->data[0].v_pointer = NULL;
      }
      if (old) {
            schema_list_unref (old);
      }
}


void value_take_schema_list (GValue* value, gpointer v_object) {
      SchemaList* old;
      g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_SCHEMA_LIST));
      old = value->data[0].v_pointer;
      if (v_object) {
            g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, TYPE_SCHEMA_LIST));
            g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
            value->data[0].v_pointer = v_object;
      } else {
            value->data[0].v_pointer = NULL;
      }
      if (old) {
            schema_list_unref (old);
      }
}


static void schema_list_class_init (SchemaListClass * klass) {
      schema_list_parent_class = g_type_class_peek_parent (klass);
      SCHEMA_LIST_CLASS (klass)->finalize = schema_list_finalize;
}


static void schema_list_instance_init (SchemaList * self) {
      GHashTable* _tmp0_ = NULL;
      GHashTable* _tmp1_ = NULL;
      GHashTable* _tmp2_ = NULL;
      self->schemas = NULL;
      _tmp0_ = g_hash_table_new_full (g_str_hash, g_str_equal, _g_free0_, _schema_key_unref0_);
      self->keys = _tmp0_;
      _tmp1_ = g_hash_table_new_full (g_str_hash, g_str_equal, _g_free0_, _schema_enum_unref0_);
      self->enums = _tmp1_;
      _tmp2_ = g_hash_table_new_full (g_str_hash, g_str_equal, _g_free0_, _schema_flags_unref0_);
      self->flags = _tmp2_;
      self->ref_count = 1;
}


static void schema_list_finalize (SchemaList* obj) {
      SchemaList * self;
      self = SCHEMA_LIST (obj);
      __g_list_free__schema_unref0_0 (self->schemas);
      _g_hash_table_unref0 (self->keys);
      _g_hash_table_unref0 (self->enums);
      _g_hash_table_unref0 (self->flags);
}


GType schema_list_get_type (void) {
      static volatile gsize schema_list_type_id__volatile = 0;
      if (g_once_init_enter (&schema_list_type_id__volatile)) {
            static const GTypeValueTable g_define_type_value_table = { value_schema_list_init, value_schema_list_free_value, value_schema_list_copy_value, value_schema_list_peek_pointer, "p", value_schema_list_collect_value, "p", value_schema_list_lcopy_value };
            static const GTypeInfo g_define_type_info = { sizeof (SchemaListClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) schema_list_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (SchemaList), 0, (GInstanceInitFunc) schema_list_instance_init, &g_define_type_value_table };
            static const GTypeFundamentalInfo g_define_type_fundamental_info = { (G_TYPE_FLAG_CLASSED | G_TYPE_FLAG_INSTANTIATABLE | G_TYPE_FLAG_DERIVABLE | G_TYPE_FLAG_DEEP_DERIVABLE) };
            GType schema_list_type_id;
            schema_list_type_id = g_type_register_fundamental (g_type_fundamental_next (), "SchemaList", &g_define_type_info, &g_define_type_fundamental_info, 0);
            g_once_init_leave (&schema_list_type_id__volatile, schema_list_type_id);
      }
      return schema_list_type_id__volatile;
}


gpointer schema_list_ref (gpointer instance) {
      SchemaList* self;
      self = instance;
      g_atomic_int_inc (&self->ref_count);
      return instance;
}


void schema_list_unref (gpointer instance) {
      SchemaList* self;
      self = instance;
      if (g_atomic_int_dec_and_test (&self->ref_count)) {
            SCHEMA_LIST_GET_CLASS (self)->finalize (self);
            g_type_free_instance ((GTypeInstance *) self);
      }
}




Generated by  Doxygen 1.6.0   Back to index