git.maemo.org Git - fillmore/blob - src/test/debug/ProjectLoader.c

   1 /* ProjectLoader.c generated by valac, the Vala compiler
   2  * generated from ProjectLoader.vala, do not modify */
   3
   4 /* Copyright 2009 Yorba Foundation
   5  *
   6  * This software is licensed under the GNU Lesser General Public License
   7  * (version 2.1 or later).  See the COPYING file in this distribution.
   8  */
   9
  10 #include <glib.h>
  11 #include <glib-object.h>
  12 #include <stdlib.h>
  13 #include <string.h>
  14 #include <gee.h>
  15 #include <glib/gstdio.h>
  16 #include <gobject/gvaluecollector.h>
  17
  18
  19 #define MODEL_TYPE_LOADER_HANDLER (model_loader_handler_get_type ())
  20 #define MODEL_LOADER_HANDLER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_LOADER_HANDLER, ModelLoaderHandler))
  21 #define MODEL_LOADER_HANDLER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_LOADER_HANDLER, ModelLoaderHandlerClass))
  22 #define MODEL_IS_LOADER_HANDLER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_LOADER_HANDLER))
  23 #define MODEL_IS_LOADER_HANDLER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_LOADER_HANDLER))
  24 #define MODEL_LOADER_HANDLER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_LOADER_HANDLER, ModelLoaderHandlerClass))
  25
  26 typedef struct _ModelLoaderHandler ModelLoaderHandler;
  27 typedef struct _ModelLoaderHandlerClass ModelLoaderHandlerClass;
  28 typedef struct _ModelLoaderHandlerPrivate ModelLoaderHandlerPrivate;
  29
  30 #define MODEL_TYPE_XML_TREE_LOADER (model_xml_tree_loader_get_type ())
  31 #define MODEL_XML_TREE_LOADER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_XML_TREE_LOADER, ModelXmlTreeLoader))
  32 #define MODEL_XML_TREE_LOADER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_XML_TREE_LOADER, ModelXmlTreeLoaderClass))
  33 #define MODEL_IS_XML_TREE_LOADER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_XML_TREE_LOADER))
  34 #define MODEL_IS_XML_TREE_LOADER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_XML_TREE_LOADER))
  35 #define MODEL_XML_TREE_LOADER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_XML_TREE_LOADER, ModelXmlTreeLoaderClass))
  36
  37 typedef struct _ModelXmlTreeLoader ModelXmlTreeLoader;
  38 typedef struct _ModelXmlTreeLoaderClass ModelXmlTreeLoaderClass;
  39 typedef struct _ModelXmlTreeLoaderPrivate ModelXmlTreeLoaderPrivate;
  40
  41 #define MODEL_TYPE_XML_ELEMENT (model_xml_element_get_type ())
  42 #define MODEL_XML_ELEMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_XML_ELEMENT, ModelXmlElement))
  43 #define MODEL_XML_ELEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_XML_ELEMENT, ModelXmlElementClass))
  44 #define MODEL_IS_XML_ELEMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_XML_ELEMENT))
  45 #define MODEL_IS_XML_ELEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_XML_ELEMENT))
  46 #define MODEL_XML_ELEMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_XML_ELEMENT, ModelXmlElementClass))
  47
  48 typedef struct _ModelXmlElement ModelXmlElement;
  49 typedef struct _ModelXmlElementClass ModelXmlElementClass;
  50 #define _model_xml_element_unref0(var) ((var == NULL) ? NULL : (var = (model_xml_element_unref (var), NULL)))
  51 #define _g_markup_parse_context_free0(var) ((var == NULL) ? NULL : (var = (g_markup_parse_context_free (var), NULL)))
  52 #define _g_error_free0(var) ((var == NULL) ? NULL : (var = (g_error_free (var), NULL)))
  53 typedef struct _ModelParamSpecXmlTreeLoader ModelParamSpecXmlTreeLoader;
  54
  55 #define MODEL_TYPE_PROJECT_BUILDER (model_project_builder_get_type ())
  56 #define MODEL_PROJECT_BUILDER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_PROJECT_BUILDER, ModelProjectBuilder))
  57 #define MODEL_PROJECT_BUILDER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_PROJECT_BUILDER, ModelProjectBuilderClass))
  58 #define MODEL_IS_PROJECT_BUILDER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_PROJECT_BUILDER))
  59 #define MODEL_IS_PROJECT_BUILDER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_PROJECT_BUILDER))
  60 #define MODEL_PROJECT_BUILDER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_PROJECT_BUILDER, ModelProjectBuilderClass))
  61
  62 typedef struct _ModelProjectBuilder ModelProjectBuilder;
  63 typedef struct _ModelProjectBuilderClass ModelProjectBuilderClass;
  64 typedef struct _ModelProjectBuilderPrivate ModelProjectBuilderPrivate;
  65 #define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
  66 #define _g_free0(var) (var = (g_free (var), NULL))
  67 typedef struct _ModelXmlElementPrivate ModelXmlElementPrivate;
  68
  69 #define LOGGING_TYPE_FACILITY (logging_facility_get_type ())
  70
  71 #define LOGGING_TYPE_LEVEL (logging_level_get_type ())
  72 typedef struct _ModelParamSpecXmlElement ModelParamSpecXmlElement;
  73
  74 #define MODEL_TYPE_PROJECT_LOADER (model_project_loader_get_type ())
  75 #define MODEL_PROJECT_LOADER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_PROJECT_LOADER, ModelProjectLoader))
  76 #define MODEL_PROJECT_LOADER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_PROJECT_LOADER, ModelProjectLoaderClass))
  77 #define MODEL_IS_PROJECT_LOADER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_PROJECT_LOADER))
  78 #define MODEL_IS_PROJECT_LOADER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_PROJECT_LOADER))
  79 #define MODEL_PROJECT_LOADER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_PROJECT_LOADER, ModelProjectLoaderClass))
  80
  81 typedef struct _ModelProjectLoader ModelProjectLoader;
  82 typedef struct _ModelProjectLoaderClass ModelProjectLoaderClass;
  83 typedef struct _ModelProjectLoaderPrivate ModelProjectLoaderPrivate;
  84 #define _model_xml_tree_loader_unref0(var) ((var == NULL) ? NULL : (var = (model_xml_tree_loader_unref (var), NULL)))
  85
  86 struct _ModelLoaderHandler {
  87         GObject parent_instance;
  88         ModelLoaderHandlerPrivate * priv;
  89 };
  90
  91 struct _ModelLoaderHandlerClass {
  92         GObjectClass parent_class;
  93         gboolean (*commit_library) (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1);
  94         gboolean (*commit_marina) (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1);
  95         gboolean (*commit_track) (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1);
  96         gboolean (*commit_clip) (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1);
  97         gboolean (*commit_clipfile) (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1);
  98         gboolean (*commit_time_signature_entry) (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1);
  99         gboolean (*commit_tempo_entry) (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1);
 100         gboolean (*commit_click) (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1);
 101         gboolean (*commit_library_preference) (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1);
 102         void (*leave_library) (ModelLoaderHandler* self);
 103         void (*leave_marina) (ModelLoaderHandler* self);
 104         void (*leave_track) (ModelLoaderHandler* self);
 105         void (*leave_clip) (ModelLoaderHandler* self);
 106         void (*leave_clipfile) (ModelLoaderHandler* self);
 107 };
 108
 109 struct _ModelXmlTreeLoader {
 110         GTypeInstance parent_instance;
 111         volatile int ref_count;
 112         ModelXmlTreeLoaderPrivate * priv;
 113         ModelXmlElement* root;
 114 };
 115
 116 struct _ModelXmlTreeLoaderClass {
 117         GTypeClass parent_class;
 118         void (*finalize) (ModelXmlTreeLoader *self);
 119 };
 120
 121 struct _ModelXmlTreeLoaderPrivate {
 122         ModelXmlElement* current_element;
 123 };
 124
 125 struct _ModelParamSpecXmlTreeLoader {
 126         GParamSpec parent_instance;
 127 };
 128
 129 struct _ModelProjectBuilder {
 130         GObject parent_instance;
 131         ModelProjectBuilderPrivate * priv;
 132 };
 133
 134 struct _ModelProjectBuilderClass {
 135         GObjectClass parent_class;
 136 };
 137
 138 struct _ModelProjectBuilderPrivate {
 139         ModelLoaderHandler* handler;
 140 };
 141
 142 struct _ModelXmlElement {
 143         GTypeInstance parent_instance;
 144         volatile int ref_count;
 145         ModelXmlElementPrivate * priv;
 146         char** attribute_names;
 147         gint attribute_names_length1;
 148         char** attribute_values;
 149         gint attribute_values_length1;
 150 };
 151
 152 struct _ModelXmlElementClass {
 153         GTypeClass parent_class;
 154         void (*finalize) (ModelXmlElement *self);
 155 };
 156
 157 typedef enum  {
 158         LOGGING_FACILITY_SIGNAL_HANDLERS,
 159         LOGGING_FACILITY_DEVELOPER_WARNINGS,
 160         LOGGING_FACILITY_GRAPH,
 161         LOGGING_FACILITY_LOADING,
 162         LOGGING_FACILITY_IMPORT,
 163         LOGGING_FACILITY_SINGLEDECODEBIN
 164 } LoggingFacility;
 165
 166 typedef enum  {
 167         LOGGING_LEVEL_CRITICAL,
 168         LOGGING_LEVEL_HIGH,
 169         LOGGING_LEVEL_MEDIUM,
 170         LOGGING_LEVEL_LOW,
 171         LOGGING_LEVEL_INFO,
 172         LOGGING_LEVEL_VERBOSE
 173 } LoggingLevel;
 174
 175 struct _ModelXmlElementPrivate {
 176         char* _name;
 177         ModelXmlElement* _parent;
 178         GeeArrayList* _children;
 179 };
 180
 181 struct _ModelParamSpecXmlElement {
 182         GParamSpec parent_instance;
 183 };
 184
 185 struct _ModelProjectLoader {
 186         GObject parent_instance;
 187         ModelProjectLoaderPrivate * priv;
 188 };
 189
 190 struct _ModelProjectLoaderClass {
 191         GObjectClass parent_class;
 192 };
 193
 194 struct _ModelProjectLoaderPrivate {
 195         char* file_name;
 196         ModelLoaderHandler* loader_handler;
 197         char* text;
 198         gsize text_len;
 199         gboolean project_load_completed;
 200         gboolean load_completed_fired;
 201         gboolean handler_completed;
 202 };
 203
 204
 205 static gpointer model_loader_handler_parent_class = NULL;
 206 static gpointer model_xml_tree_loader_parent_class = NULL;
 207 static gpointer model_project_builder_parent_class = NULL;
 208 static gpointer model_xml_element_parent_class = NULL;
 209 static gpointer model_project_loader_parent_class = NULL;
 210
 211 GType model_loader_handler_get_type (void);
 212 enum  {
 213         MODEL_LOADER_HANDLER_DUMMY_PROPERTY
 214 };
 215 ModelLoaderHandler* model_loader_handler_new (void);
 216 ModelLoaderHandler* model_loader_handler_construct (GType object_type);
 217 gboolean model_loader_handler_commit_library (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1);
 218 static gboolean model_loader_handler_real_commit_library (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1);
 219 gboolean model_loader_handler_commit_marina (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1);
 220 static gboolean model_loader_handler_real_commit_marina (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1);
 221 gboolean model_loader_handler_commit_track (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1);
 222 static gboolean model_loader_handler_real_commit_track (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1);
 223 gboolean model_loader_handler_commit_clip (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1);
 224 static gboolean model_loader_handler_real_commit_clip (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1);
 225 gboolean model_loader_handler_commit_clipfile (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1);
 226 static gboolean model_loader_handler_real_commit_clipfile (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1);
 227 gboolean model_loader_handler_commit_time_signature_entry (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1);
 228 static gboolean model_loader_handler_real_commit_time_signature_entry (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1);
 229 gboolean model_loader_handler_commit_tempo_entry (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1);
 230 static gboolean model_loader_handler_real_commit_tempo_entry (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1);
 231 gboolean model_loader_handler_commit_click (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1);
 232 static gboolean model_loader_handler_real_commit_click (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1);
 233 gboolean model_loader_handler_commit_library_preference (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1);
 234 static gboolean model_loader_handler_real_commit_library_preference (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1);
 235 void model_loader_handler_leave_library (ModelLoaderHandler* self);
 236 static void model_loader_handler_real_leave_library (ModelLoaderHandler* self);
 237 void model_loader_handler_leave_marina (ModelLoaderHandler* self);
 238 static void model_loader_handler_real_leave_marina (ModelLoaderHandler* self);
 239 void model_loader_handler_leave_track (ModelLoaderHandler* self);
 240 static void model_loader_handler_real_leave_track (ModelLoaderHandler* self);
 241 void model_loader_handler_leave_clip (ModelLoaderHandler* self);
 242 static void model_loader_handler_real_leave_clip (ModelLoaderHandler* self);
 243 void model_loader_handler_leave_clipfile (ModelLoaderHandler* self);
 244 static void model_loader_handler_real_leave_clipfile (ModelLoaderHandler* self);
 245 gpointer model_xml_tree_loader_ref (gpointer instance);
 246 void model_xml_tree_loader_unref (gpointer instance);
 247 GParamSpec* model_param_spec_xml_tree_loader (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);
 248 void model_value_set_xml_tree_loader (GValue* value, gpointer v_object);
 249 void model_value_take_xml_tree_loader (GValue* value, gpointer v_object);
 250 gpointer model_value_get_xml_tree_loader (const GValue* value);
 251 GType model_xml_tree_loader_get_type (void);
 252 gpointer model_xml_element_ref (gpointer instance);
 253 void model_xml_element_unref (gpointer instance);
 254 GParamSpec* model_param_spec_xml_element (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);
 255 void model_value_set_xml_element (GValue* value, gpointer v_object);
 256 void model_value_take_xml_element (GValue* value, gpointer v_object);
 257 gpointer model_value_get_xml_element (const GValue* value);
 258 GType model_xml_element_get_type (void);
 259 #define MODEL_XML_TREE_LOADER_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), MODEL_TYPE_XML_TREE_LOADER, ModelXmlTreeLoaderPrivate))
 260 enum  {
 261         MODEL_XML_TREE_LOADER_DUMMY_PROPERTY
 262 };
 263 static void model_xml_tree_loader_xml_start_element (ModelXmlTreeLoader* self, GMarkupParseContext* c, const char* name, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1);
 264 static void _model_xml_tree_loader_xml_start_element_gmarkup_parser_start_element_func (GMarkupParseContext* context, const char* element_name, char** attribute_names, char** attribute_values, gpointer self);
 265 static void model_xml_tree_loader_xml_end_element (ModelXmlTreeLoader* self, GMarkupParseContext* c, const char* name);
 266 static void _model_xml_tree_loader_xml_end_element_gmarkup_parser_end_element_func (GMarkupParseContext* context, const char* element_name, gpointer self);
 267 ModelXmlTreeLoader* model_xml_tree_loader_new (const char* document);
 268 ModelXmlTreeLoader* model_xml_tree_loader_construct (GType object_type, const char* document);
 269 ModelXmlElement* model_xml_element_new (const char* name, char** attribute_names, int attribute_names_length1, char** attribute_values, int attribute_values_length1, ModelXmlElement* parent);
 270 ModelXmlElement* model_xml_element_construct (GType object_type, const char* name, char** attribute_names, int attribute_names_length1, char** attribute_values, int attribute_values_length1, ModelXmlElement* parent);
 271 void model_xml_element_add_child (ModelXmlElement* self, ModelXmlElement* child_element);
 272 ModelXmlElement* model_xml_element_get_parent (ModelXmlElement* self);
 273 static void model_xml_tree_loader_finalize (ModelXmlTreeLoader* obj);
 274 GType model_project_builder_get_type (void);
 275 #define MODEL_PROJECT_BUILDER_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), MODEL_TYPE_PROJECT_BUILDER, ModelProjectBuilderPrivate))
 276 enum  {
 277         MODEL_PROJECT_BUILDER_DUMMY_PROPERTY
 278 };
 279 ModelProjectBuilder* model_project_builder_new (ModelLoaderHandler* handler);
 280 ModelProjectBuilder* model_project_builder_construct (GType object_type, ModelLoaderHandler* handler);
 281 const char* model_xml_element_get_name (ModelXmlElement* self);
 282 static gboolean model_project_builder_check_name (ModelProjectBuilder* self, const char* expected_name, ModelXmlElement* node);
 283 GeeArrayList* model_xml_element_get_children (ModelXmlElement* self);
 284 static void model_project_builder_handle_clip (ModelProjectBuilder* self, ModelXmlElement* clip);
 285 GType logging_facility_get_type (void);
 286 GType logging_level_get_type (void);
 287 void logging_emit (GObject* object, LoggingFacility facility, LoggingLevel level, const char* message);
 288 static void model_project_builder_handle_track (ModelProjectBuilder* self, ModelXmlElement* track);
 289 static void model_project_builder_handle_preference (ModelProjectBuilder* self, ModelXmlElement* preference);
 290 static void model_project_builder_handle_time_signature (ModelProjectBuilder* self, ModelXmlElement* time_signature);
 291 static void model_project_builder_handle_tempo (ModelProjectBuilder* self, ModelXmlElement* tempo);
 292 static void model_project_builder_handle_map (ModelProjectBuilder* self, ModelXmlElement* map);
 293 static void model_project_builder_handle_library (ModelProjectBuilder* self, ModelXmlElement* library);
 294 static void model_project_builder_handle_tracks (ModelProjectBuilder* self, ModelXmlElement* tracks);
 295 static void model_project_builder_handle_preferences (ModelProjectBuilder* self, ModelXmlElement* preferences);
 296 static void model_project_builder_handle_maps (ModelProjectBuilder* self, ModelXmlElement* maps);
 297 gboolean model_project_builder_check_project (ModelProjectBuilder* self, ModelXmlElement* root);
 298 void model_project_builder_build_project (ModelProjectBuilder* self, ModelXmlElement* root);
 299 static void model_project_builder_finalize (GObject* obj);
 300 #define MODEL_XML_ELEMENT_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), MODEL_TYPE_XML_ELEMENT, ModelXmlElementPrivate))
 301 enum  {
 302         MODEL_XML_ELEMENT_DUMMY_PROPERTY
 303 };
 304 static void model_xml_element_set_name (ModelXmlElement* self, const char* value);
 305 char** copy_array (char** source, int source_length1, int* result_length1);
 306 static void model_xml_element_set_parent (ModelXmlElement* self, ModelXmlElement* value);
 307 static void model_xml_element_finalize (ModelXmlElement* obj);
 308 GType model_project_loader_get_type (void);
 309 #define MODEL_PROJECT_LOADER_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), MODEL_TYPE_PROJECT_LOADER, ModelProjectLoaderPrivate))
 310 enum  {
 311         MODEL_PROJECT_LOADER_DUMMY_PROPERTY
 312 };
 313 static void model_project_loader_on_load_error (ModelProjectLoader* self, const char* _error_);
 314 static void _model_project_loader_on_load_error_model_loader_handler_load_error (ModelLoaderHandler* _sender, const char* error_message, gpointer self);
 315 static void model_project_loader_on_handler_complete (ModelProjectLoader* self);
 316 static void _model_project_loader_on_handler_complete_model_loader_handler_complete (ModelLoaderHandler* _sender, gpointer self);
 317 ModelProjectLoader* model_project_loader_new (ModelLoaderHandler* loader_handler, const char* file_name);
 318 ModelProjectLoader* model_project_loader_construct (GType object_type, ModelLoaderHandler* loader_handler, const char* file_name);
 319 static void _model_project_loader_on_load_error_model_project_builder_error_occurred (ModelProjectBuilder* _sender, const char* _error_, gpointer self);
 320 void model_project_loader_load (ModelProjectLoader* self);
 321 static void model_project_loader_finalize (GObject* obj);
 322 static void _vala_array_destroy (gpointer array, gint array_length, GDestroyNotify destroy_func);
 323 static void _vala_array_free (gpointer array, gint array_length, GDestroyNotify destroy_func);
 324 static gint _vala_array_length (gpointer array);
 325 static int _vala_strcmp0 (const char * str1, const char * str2);
 326
 327
 328
 329 #line 15 "ProjectLoader.vala"
 330 ModelLoaderHandler* model_loader_handler_construct (GType object_type) {
 331 #line 332 "ProjectLoader.c"
 332         ModelLoaderHandler * self;
 333 #line 15 "ProjectLoader.vala"
 334         self = (ModelLoaderHandler*) g_object_new (object_type, NULL);
 335 #line 336 "ProjectLoader.c"
 336         return self;
 337 }
 338
 339
 340 #line 15 "ProjectLoader.vala"
 341 ModelLoaderHandler* model_loader_handler_new (void) {
 342 #line 15 "ProjectLoader.vala"
 343         return model_loader_handler_construct (MODEL_TYPE_LOADER_HANDLER);
 344 #line 345 "ProjectLoader.c"
 345 }
 346
 347
 348 #line 18 "ProjectLoader.vala"
 349 static gboolean model_loader_handler_real_commit_library (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1) {
 350 #line 351 "ProjectLoader.c"
 351         gboolean result = FALSE;
 352 #line 18 "ProjectLoader.vala"
 353         g_return_val_if_fail (MODEL_IS_LOADER_HANDLER (self), FALSE);
 354 #line 355 "ProjectLoader.c"
 355         result = TRUE;
 356 #line 19 "ProjectLoader.vala"
 357         return result;
 358 #line 359 "ProjectLoader.c"
 359 }
 360
 361
 362 #line 18 "ProjectLoader.vala"
 363 gboolean model_loader_handler_commit_library (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1) {
 364 #line 18 "ProjectLoader.vala"
 365         return MODEL_LOADER_HANDLER_GET_CLASS (self)->commit_library (self, attr_names, attr_names_length1, attr_values, attr_values_length1);
 366 #line 367 "ProjectLoader.c"
 367 }
 368
 369
 370 #line 22 "ProjectLoader.vala"
 371 static gboolean model_loader_handler_real_commit_marina (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1) {
 372 #line 373 "ProjectLoader.c"
 373         gboolean result = FALSE;
 374 #line 22 "ProjectLoader.vala"
 375         g_return_val_if_fail (MODEL_IS_LOADER_HANDLER (self), FALSE);
 376 #line 377 "ProjectLoader.c"
 377         result = TRUE;
 378 #line 23 "ProjectLoader.vala"
 379         return result;
 380 #line 381 "ProjectLoader.c"
 381 }
 382
 383
 384 #line 22 "ProjectLoader.vala"
 385 gboolean model_loader_handler_commit_marina (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1) {
 386 #line 22 "ProjectLoader.vala"
 387         return MODEL_LOADER_HANDLER_GET_CLASS (self)->commit_marina (self, attr_names, attr_names_length1, attr_values, attr_values_length1);
 388 #line 389 "ProjectLoader.c"
 389 }
 390
 391
 392 #line 26 "ProjectLoader.vala"
 393 static gboolean model_loader_handler_real_commit_track (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1) {
 394 #line 395 "ProjectLoader.c"
 395         gboolean result = FALSE;
 396 #line 26 "ProjectLoader.vala"
 397         g_return_val_if_fail (MODEL_IS_LOADER_HANDLER (self), FALSE);
 398 #line 399 "ProjectLoader.c"
 399         result = TRUE;
 400 #line 27 "ProjectLoader.vala"
 401         return result;
 402 #line 403 "ProjectLoader.c"
 403 }
 404
 405
 406 #line 26 "ProjectLoader.vala"
 407 gboolean model_loader_handler_commit_track (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1) {
 408 #line 26 "ProjectLoader.vala"
 409         return MODEL_LOADER_HANDLER_GET_CLASS (self)->commit_track (self, attr_names, attr_names_length1, attr_values, attr_values_length1);
 410 #line 411 "ProjectLoader.c"
 411 }
 412
 413
 414 #line 30 "ProjectLoader.vala"
 415 static gboolean model_loader_handler_real_commit_clip (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1) {
 416 #line 417 "ProjectLoader.c"
 417         gboolean result = FALSE;
 418 #line 30 "ProjectLoader.vala"
 419         g_return_val_if_fail (MODEL_IS_LOADER_HANDLER (self), FALSE);
 420 #line 421 "ProjectLoader.c"
 421         result = TRUE;
 422 #line 31 "ProjectLoader.vala"
 423         return result;
 424 #line 425 "ProjectLoader.c"
 425 }
 426
 427
 428 #line 30 "ProjectLoader.vala"
 429 gboolean model_loader_handler_commit_clip (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1) {
 430 #line 30 "ProjectLoader.vala"
 431         return MODEL_LOADER_HANDLER_GET_CLASS (self)->commit_clip (self, attr_names, attr_names_length1, attr_values, attr_values_length1);
 432 #line 433 "ProjectLoader.c"
 433 }
 434
 435
 436 #line 34 "ProjectLoader.vala"
 437 static gboolean model_loader_handler_real_commit_clipfile (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1) {
 438 #line 439 "ProjectLoader.c"
 439         gboolean result = FALSE;
 440 #line 34 "ProjectLoader.vala"
 441         g_return_val_if_fail (MODEL_IS_LOADER_HANDLER (self), FALSE);
 442 #line 443 "ProjectLoader.c"
 443         result = TRUE;
 444 #line 35 "ProjectLoader.vala"
 445         return result;
 446 #line 447 "ProjectLoader.c"
 447 }
 448
 449
 450 #line 34 "ProjectLoader.vala"
 451 gboolean model_loader_handler_commit_clipfile (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1) {
 452 #line 34 "ProjectLoader.vala"
 453         return MODEL_LOADER_HANDLER_GET_CLASS (self)->commit_clipfile (self, attr_names, attr_names_length1, attr_values, attr_values_length1);
 454 #line 455 "ProjectLoader.c"
 455 }
 456
 457
 458 #line 38 "ProjectLoader.vala"
 459 static gboolean model_loader_handler_real_commit_time_signature_entry (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1) {
 460 #line 461 "ProjectLoader.c"
 461         gboolean result = FALSE;
 462 #line 38 "ProjectLoader.vala"
 463         g_return_val_if_fail (MODEL_IS_LOADER_HANDLER (self), FALSE);
 464 #line 465 "ProjectLoader.c"
 465         result = TRUE;
 466 #line 39 "ProjectLoader.vala"
 467         return result;
 468 #line 469 "ProjectLoader.c"
 469 }
 470
 471
 472 #line 38 "ProjectLoader.vala"
 473 gboolean model_loader_handler_commit_time_signature_entry (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1) {
 474 #line 38 "ProjectLoader.vala"
 475         return MODEL_LOADER_HANDLER_GET_CLASS (self)->commit_time_signature_entry (self, attr_names, attr_names_length1, attr_values, attr_values_length1);
 476 #line 477 "ProjectLoader.c"
 477 }
 478
 479
 480 #line 42 "ProjectLoader.vala"
 481 static gboolean model_loader_handler_real_commit_tempo_entry (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1) {
 482 #line 483 "ProjectLoader.c"
 483         gboolean result = FALSE;
 484 #line 42 "ProjectLoader.vala"
 485         g_return_val_if_fail (MODEL_IS_LOADER_HANDLER (self), FALSE);
 486 #line 487 "ProjectLoader.c"
 487         result = TRUE;
 488 #line 43 "ProjectLoader.vala"
 489         return result;
 490 #line 491 "ProjectLoader.c"
 491 }
 492
 493
 494 #line 42 "ProjectLoader.vala"
 495 gboolean model_loader_handler_commit_tempo_entry (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1) {
 496 #line 42 "ProjectLoader.vala"
 497         return MODEL_LOADER_HANDLER_GET_CLASS (self)->commit_tempo_entry (self, attr_names, attr_names_length1, attr_values, attr_values_length1);
 498 #line 499 "ProjectLoader.c"
 499 }
 500
 501
 502 #line 46 "ProjectLoader.vala"
 503 static gboolean model_loader_handler_real_commit_click (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1) {
 504 #line 505 "ProjectLoader.c"
 505         gboolean result = FALSE;
 506 #line 46 "ProjectLoader.vala"
 507         g_return_val_if_fail (MODEL_IS_LOADER_HANDLER (self), FALSE);
 508 #line 509 "ProjectLoader.c"
 509         result = TRUE;
 510 #line 47 "ProjectLoader.vala"
 511         return result;
 512 #line 513 "ProjectLoader.c"
 513 }
 514
 515
 516 #line 46 "ProjectLoader.vala"
 517 gboolean model_loader_handler_commit_click (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1) {
 518 #line 46 "ProjectLoader.vala"
 519         return MODEL_LOADER_HANDLER_GET_CLASS (self)->commit_click (self, attr_names, attr_names_length1, attr_values, attr_values_length1);
 520 #line 521 "ProjectLoader.c"
 521 }
 522
 523
 524 #line 50 "ProjectLoader.vala"
 525 static gboolean model_loader_handler_real_commit_library_preference (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1) {
 526 #line 527 "ProjectLoader.c"
 527         gboolean result = FALSE;
 528 #line 50 "ProjectLoader.vala"
 529         g_return_val_if_fail (MODEL_IS_LOADER_HANDLER (self), FALSE);
 530 #line 531 "ProjectLoader.c"
 531         result = TRUE;
 532 #line 51 "ProjectLoader.vala"
 533         return result;
 534 #line 535 "ProjectLoader.c"
 535 }
 536
 537
 538 #line 50 "ProjectLoader.vala"
 539 gboolean model_loader_handler_commit_library_preference (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1) {
 540 #line 50 "ProjectLoader.vala"
 541         return MODEL_LOADER_HANDLER_GET_CLASS (self)->commit_library_preference (self, attr_names, attr_names_length1, attr_values, attr_values_length1);
 542 #line 543 "ProjectLoader.c"
 543 }
 544
 545
 546 #line 54 "ProjectLoader.vala"
 547 static void model_loader_handler_real_leave_library (ModelLoaderHandler* self) {
 548 #line 54 "ProjectLoader.vala"
 549         g_return_if_fail (MODEL_IS_LOADER_HANDLER (self));
 550 #line 551 "ProjectLoader.c"
 551 }
 552
 553
 554 #line 54 "ProjectLoader.vala"
 555 void model_loader_handler_leave_library (ModelLoaderHandler* self) {
 556 #line 54 "ProjectLoader.vala"
 557         MODEL_LOADER_HANDLER_GET_CLASS (self)->leave_library (self);
 558 #line 559 "ProjectLoader.c"
 559 }
 560
 561
 562 #line 57 "ProjectLoader.vala"
 563 static void model_loader_handler_real_leave_marina (ModelLoaderHandler* self) {
 564 #line 57 "ProjectLoader.vala"
 565         g_return_if_fail (MODEL_IS_LOADER_HANDLER (self));
 566 #line 567 "ProjectLoader.c"
 567 }
 568
 569
 570 #line 57 "ProjectLoader.vala"
 571 void model_loader_handler_leave_marina (ModelLoaderHandler* self) {
 572 #line 57 "ProjectLoader.vala"
 573         MODEL_LOADER_HANDLER_GET_CLASS (self)->leave_marina (self);
 574 #line 575 "ProjectLoader.c"
 575 }
 576
 577
 578 #line 60 "ProjectLoader.vala"
 579 static void model_loader_handler_real_leave_track (ModelLoaderHandler* self) {
 580 #line 60 "ProjectLoader.vala"
 581         g_return_if_fail (MODEL_IS_LOADER_HANDLER (self));
 582 #line 583 "ProjectLoader.c"
 583 }
 584
 585
 586 #line 60 "ProjectLoader.vala"
 587 void model_loader_handler_leave_track (ModelLoaderHandler* self) {
 588 #line 60 "ProjectLoader.vala"
 589         MODEL_LOADER_HANDLER_GET_CLASS (self)->leave_track (self);
 590 #line 591 "ProjectLoader.c"
 591 }
 592
 593
 594 #line 63 "ProjectLoader.vala"
 595 static void model_loader_handler_real_leave_clip (ModelLoaderHandler* self) {
 596 #line 63 "ProjectLoader.vala"
 597         g_return_if_fail (MODEL_IS_LOADER_HANDLER (self));
 598 #line 599 "ProjectLoader.c"
 599 }
 600
 601
 602 #line 63 "ProjectLoader.vala"
 603 void model_loader_handler_leave_clip (ModelLoaderHandler* self) {
 604 #line 63 "ProjectLoader.vala"
 605         MODEL_LOADER_HANDLER_GET_CLASS (self)->leave_clip (self);
 606 #line 607 "ProjectLoader.c"
 607 }
 608
 609
 610 #line 66 "ProjectLoader.vala"
 611 static void model_loader_handler_real_leave_clipfile (ModelLoaderHandler* self) {
 612 #line 66 "ProjectLoader.vala"
 613         g_return_if_fail (MODEL_IS_LOADER_HANDLER (self));
 614 #line 615 "ProjectLoader.c"
 615 }
 616
 617
 618 #line 66 "ProjectLoader.vala"
 619 void model_loader_handler_leave_clipfile (ModelLoaderHandler* self) {
 620 #line 66 "ProjectLoader.vala"
 621         MODEL_LOADER_HANDLER_GET_CLASS (self)->leave_clipfile (self);
 622 #line 623 "ProjectLoader.c"
 623 }
 624
 625
 626 static void model_loader_handler_class_init (ModelLoaderHandlerClass * klass) {
 627         model_loader_handler_parent_class = g_type_class_peek_parent (klass);
 628         MODEL_LOADER_HANDLER_CLASS (klass)->commit_library = model_loader_handler_real_commit_library;
 629         MODEL_LOADER_HANDLER_CLASS (klass)->commit_marina = model_loader_handler_real_commit_marina;
 630         MODEL_LOADER_HANDLER_CLASS (klass)->commit_track = model_loader_handler_real_commit_track;
 631         MODEL_LOADER_HANDLER_CLASS (klass)->commit_clip = model_loader_handler_real_commit_clip;
 632         MODEL_LOADER_HANDLER_CLASS (klass)->commit_clipfile = model_loader_handler_real_commit_clipfile;
 633         MODEL_LOADER_HANDLER_CLASS (klass)->commit_time_signature_entry = model_loader_handler_real_commit_time_signature_entry;
 634         MODEL_LOADER_HANDLER_CLASS (klass)->commit_tempo_entry = model_loader_handler_real_commit_tempo_entry;
 635         MODEL_LOADER_HANDLER_CLASS (klass)->commit_click = model_loader_handler_real_commit_click;
 636         MODEL_LOADER_HANDLER_CLASS (klass)->commit_library_preference = model_loader_handler_real_commit_library_preference;
 637         MODEL_LOADER_HANDLER_CLASS (klass)->leave_library = model_loader_handler_real_leave_library;
 638         MODEL_LOADER_HANDLER_CLASS (klass)->leave_marina = model_loader_handler_real_leave_marina;
 639         MODEL_LOADER_HANDLER_CLASS (klass)->leave_track = model_loader_handler_real_leave_track;
 640         MODEL_LOADER_HANDLER_CLASS (klass)->leave_clip = model_loader_handler_real_leave_clip;
 641         MODEL_LOADER_HANDLER_CLASS (klass)->leave_clipfile = model_loader_handler_real_leave_clipfile;
 642         g_signal_new ("load_error", MODEL_TYPE_LOADER_HANDLER, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__STRING, G_TYPE_NONE, 1, G_TYPE_STRING);
 643         g_signal_new ("complete", MODEL_TYPE_LOADER_HANDLER, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
 644 }
 645
 646
 647 static void model_loader_handler_instance_init (ModelLoaderHandler * self) {
 648 }
 649
 650
 651 GType model_loader_handler_get_type (void) {
 652         static volatile gsize model_loader_handler_type_id__volatile = 0;
 653         if (g_once_init_enter (&model_loader_handler_type_id__volatile)) {
 654                 static const GTypeInfo g_define_type_info = { sizeof (ModelLoaderHandlerClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) model_loader_handler_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ModelLoaderHandler), 0, (GInstanceInitFunc) model_loader_handler_instance_init, NULL };
 655                 GType model_loader_handler_type_id;
 656                 model_loader_handler_type_id = g_type_register_static (G_TYPE_OBJECT, "ModelLoaderHandler", &g_define_type_info, 0);
 657                 g_once_init_leave (&model_loader_handler_type_id__volatile, model_loader_handler_type_id);
 658         }
 659         return model_loader_handler_type_id__volatile;
 660 }
 661
 662
 663 #line 87 "ProjectLoader.vala"
 664 static void _model_xml_tree_loader_xml_start_element_gmarkup_parser_start_element_func (GMarkupParseContext* context, const char* element_name, char** attribute_names, char** attribute_values, gpointer self) {
 665 #line 666 "ProjectLoader.c"
 666         model_xml_tree_loader_xml_start_element (self, context, element_name, attribute_names, _vala_array_length (attribute_names), attribute_values, _vala_array_length (attribute_values));
 667 }
 668
 669
 670 #line 100 "ProjectLoader.vala"
 671 static void _model_xml_tree_loader_xml_end_element_gmarkup_parser_end_element_func (GMarkupParseContext* context, const char* element_name, gpointer self) {
 672 #line 673 "ProjectLoader.c"
 673         model_xml_tree_loader_xml_end_element (self, context, element_name);
 674 }
 675
 676
 677 static glong string_get_length (const char* self) {
 678         glong result;
 679         g_return_val_if_fail (self != NULL, 0L);
 680         result = g_utf8_strlen (self, -1);
 681 #line 1158 "glib-2.0.vapi"
 682         return result;
 683 #line 684 "ProjectLoader.c"
 684 }
 685
 686
 687 #line 76 "ProjectLoader.vala"
 688 ModelXmlTreeLoader* model_xml_tree_loader_construct (GType object_type, const char* document) {
 689 #line 690 "ProjectLoader.c"
 690         GError * _inner_error_;
 691         ModelXmlTreeLoader* self;
 692         GMarkupParser _tmp0_ = {0};
 693         GMarkupParser parser;
 694         GMarkupParseContext* context;
 695 #line 76 "ProjectLoader.vala"
 696         g_return_val_if_fail (document != NULL, NULL);
 697 #line 698 "ProjectLoader.c"
 698         _inner_error_ = NULL;
 699         self = (ModelXmlTreeLoader*) g_type_create_instance (object_type);
 700 #line 77 "ProjectLoader.vala"
 701         parser = (_tmp0_.start_element = _model_xml_tree_loader_xml_start_element_gmarkup_parser_start_element_func, _tmp0_.end_element = _model_xml_tree_loader_xml_end_element_gmarkup_parser_end_element_func, _tmp0_.text = NULL, _tmp0_.passthrough = NULL, _tmp0_);
 702 #line 79 "ProjectLoader.vala"
 703         context = g_markup_parse_context_new (&parser, (GMarkupParseFlags) 0, self, NULL);
 704 #line 705 "ProjectLoader.c"
 705         {
 706 #line 81 "ProjectLoader.vala"
 707                 g_markup_parse_context_parse (context, document, (gssize) string_get_length (document), &_inner_error_);
 708 #line 709 "ProjectLoader.c"
 709                 if (_inner_error_ != NULL) {
 710                         if (_inner_error_->domain == G_MARKUP_ERROR) {
 711                                 goto __catch0_g_markup_error;
 712                         }
 713                         _g_markup_parse_context_free0 (context);
 714                         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);
 715                         g_clear_error (&_inner_error_);
 716                         return NULL;
 717                 }
 718         }
 719         goto __finally0;
 720         __catch0_g_markup_error:
 721         {
 722                 GError * e;
 723                 e = _inner_error_;
 724                 _inner_error_ = NULL;
 725                 {
 726                         _g_error_free0 (e);
 727                 }
 728         }
 729         __finally0:
 730         if (_inner_error_ != NULL) {
 731                 _g_markup_parse_context_free0 (context);
 732                 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);
 733                 g_clear_error (&_inner_error_);
 734                 return NULL;
 735         }
 736         _g_markup_parse_context_free0 (context);
 737         return self;
 738 }
 739
 740
 741 #line 76 "ProjectLoader.vala"
 742 ModelXmlTreeLoader* model_xml_tree_loader_new (const char* document) {
 743 #line 76 "ProjectLoader.vala"
 744         return model_xml_tree_loader_construct (MODEL_TYPE_XML_TREE_LOADER, document);
 745 #line 746 "ProjectLoader.c"
 746 }
 747
 748
 749 static gpointer _model_xml_element_ref0 (gpointer self) {
 750         return self ? model_xml_element_ref (self) : NULL;
 751 }
 752
 753
 754 #line 87 "ProjectLoader.vala"
 755 static void model_xml_tree_loader_xml_start_element (ModelXmlTreeLoader* self, GMarkupParseContext* c, const char* name, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1) {
 756 #line 757 "ProjectLoader.c"
 757         ModelXmlElement* new_element;
 758         ModelXmlElement* _tmp1_;
 759 #line 87 "ProjectLoader.vala"
 760         g_return_if_fail (MODEL_IS_XML_TREE_LOADER (self));
 761 #line 87 "ProjectLoader.vala"
 762         g_return_if_fail (c != NULL);
 763 #line 87 "ProjectLoader.vala"
 764         g_return_if_fail (name != NULL);
 765 #line 89 "ProjectLoader.vala"
 766         new_element = model_xml_element_new (name, attr_names, attr_names_length1, attr_values, attr_values_length1, self->priv->current_element);
 767 #line 90 "ProjectLoader.vala"
 768         if (self->root == NULL) {
 769 #line 770 "ProjectLoader.c"
 770                 ModelXmlElement* _tmp0_;
 771 #line 91 "ProjectLoader.vala"
 772                 self->root = (_tmp0_ = _model_xml_element_ref0 (new_element), _model_xml_element_unref0 (self->root), _tmp0_);
 773 #line 774 "ProjectLoader.c"
 774         } else {
 775 #line 93 "ProjectLoader.vala"
 776                 g_assert (self->priv->current_element != NULL);
 777 #line 94 "ProjectLoader.vala"
 778                 model_xml_element_add_child (self->priv->current_element, new_element);
 779 #line 780 "ProjectLoader.c"
 780         }
 781 #line 97 "ProjectLoader.vala"
 782         self->priv->current_element = (_tmp1_ = _model_xml_element_ref0 (new_element), _model_xml_element_unref0 (self->priv->current_element), _tmp1_);
 783 #line 784 "ProjectLoader.c"
 784         _model_xml_element_unref0 (new_element);
 785 }
 786
 787
 788 #line 100 "ProjectLoader.vala"
 789 static void model_xml_tree_loader_xml_end_element (ModelXmlTreeLoader* self, GMarkupParseContext* c, const char* name) {
 790 #line 791 "ProjectLoader.c"
 791         ModelXmlElement* _tmp0_;
 792 #line 100 "ProjectLoader.vala"
 793         g_return_if_fail (MODEL_IS_XML_TREE_LOADER (self));
 794 #line 100 "ProjectLoader.vala"
 795         g_return_if_fail (c != NULL);
 796 #line 100 "ProjectLoader.vala"
 797         g_return_if_fail (name != NULL);
 798 #line 101 "ProjectLoader.vala"
 799         g_assert (self->priv->current_element != NULL);
 800 #line 102 "ProjectLoader.vala"
 801         self->priv->current_element = (_tmp0_ = _model_xml_element_ref0 (model_xml_element_get_parent (self->priv->current_element)), _model_xml_element_unref0 (self->priv->current_element), _tmp0_);
 802 #line 803 "ProjectLoader.c"
 803 }
 804
 805
 806 static void model_value_xml_tree_loader_init (GValue* value) {
 807         value->data[0].v_pointer = NULL;
 808 }
 809
 810
 811 static void model_value_xml_tree_loader_free_value (GValue* value) {
 812         if (value->data[0].v_pointer) {
 813                 model_xml_tree_loader_unref (value->data[0].v_pointer);
 814         }
 815 }
 816
 817
 818 static void model_value_xml_tree_loader_copy_value (const GValue* src_value, GValue* dest_value) {
 819         if (src_value->data[0].v_pointer) {
 820                 dest_value->data[0].v_pointer = model_xml_tree_loader_ref (src_value->data[0].v_pointer);
 821         } else {
 822                 dest_value->data[0].v_pointer = NULL;
 823         }
 824 }
 825
 826
 827 static gpointer model_value_xml_tree_loader_peek_pointer (const GValue* value) {
 828         return value->data[0].v_pointer;
 829 }
 830
 831
 832 static gchar* model_value_xml_tree_loader_collect_value (GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {
 833         if (collect_values[0].v_pointer) {
 834                 ModelXmlTreeLoader* object;
 835                 object = collect_values[0].v_pointer;
 836                 if (object->parent_instance.g_class == NULL) {
 837                         return g_strconcat ("invalid unclassed object pointer for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
 838                 } else if (!g_value_type_compatible (G_TYPE_FROM_INSTANCE (object), G_VALUE_TYPE (value))) {
 839                         return g_strconcat ("invalid object type `", g_type_name (G_TYPE_FROM_INSTANCE (object)), "' for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
 840                 }
 841                 value->data[0].v_pointer = model_xml_tree_loader_ref (object);
 842         } else {
 843                 value->data[0].v_pointer = NULL;
 844         }
 845         return NULL;
 846 }
 847
 848
 849 static gchar* model_value_xml_tree_loader_lcopy_value (const GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {
 850         ModelXmlTreeLoader** object_p;
 851         object_p = collect_values[0].v_pointer;
 852         if (!object_p) {
 853                 return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
 854         }
 855         if (!value->data[0].v_pointer) {
 856                 *object_p = NULL;
 857         } else if (collect_flags && G_VALUE_NOCOPY_CONTENTS) {
 858                 *object_p = value->data[0].v_pointer;
 859         } else {
 860                 *object_p = model_xml_tree_loader_ref (value->data[0].v_pointer);
 861         }
 862         return NULL;
 863 }
 864
 865
 866 GParamSpec* model_param_spec_xml_tree_loader (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags) {
 867         ModelParamSpecXmlTreeLoader* spec;
 868         g_return_val_if_fail (g_type_is_a (object_type, MODEL_TYPE_XML_TREE_LOADER), NULL);
 869         spec = g_param_spec_internal (G_TYPE_PARAM_OBJECT, name, nick, blurb, flags);
 870         G_PARAM_SPEC (spec)->value_type = object_type;
 871         return G_PARAM_SPEC (spec);
 872 }
 873
 874
 875 gpointer model_value_get_xml_tree_loader (const GValue* value) {
 876         g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, MODEL_TYPE_XML_TREE_LOADER), NULL);
 877         return value->data[0].v_pointer;
 878 }
 879
 880
 881 void model_value_set_xml_tree_loader (GValue* value, gpointer v_object) {
 882         ModelXmlTreeLoader* old;
 883         g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, MODEL_TYPE_XML_TREE_LOADER));
 884         old = value->data[0].v_pointer;
 885         if (v_object) {
 886                 g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, MODEL_TYPE_XML_TREE_LOADER));
 887                 g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
 888                 value->data[0].v_pointer = v_object;
 889                 model_xml_tree_loader_ref (value->data[0].v_pointer);
 890         } else {
 891                 value->data[0].v_pointer = NULL;
 892         }
 893         if (old) {
 894                 model_xml_tree_loader_unref (old);
 895         }
 896 }
 897
 898
 899 void model_value_take_xml_tree_loader (GValue* value, gpointer v_object) {
 900         ModelXmlTreeLoader* old;
 901         g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, MODEL_TYPE_XML_TREE_LOADER));
 902         old = value->data[0].v_pointer;
 903         if (v_object) {
 904                 g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, MODEL_TYPE_XML_TREE_LOADER));
 905                 g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
 906                 value->data[0].v_pointer = v_object;
 907         } else {
 908                 value->data[0].v_pointer = NULL;
 909         }
 910         if (old) {
 911                 model_xml_tree_loader_unref (old);
 912         }
 913 }
 914
 915
 916 static void model_xml_tree_loader_class_init (ModelXmlTreeLoaderClass * klass) {
 917         model_xml_tree_loader_parent_class = g_type_class_peek_parent (klass);
 918         MODEL_XML_TREE_LOADER_CLASS (klass)->finalize = model_xml_tree_loader_finalize;
 919         g_type_class_add_private (klass, sizeof (ModelXmlTreeLoaderPrivate));
 920 }
 921
 922
 923 static void model_xml_tree_loader_instance_init (ModelXmlTreeLoader * self) {
 924         self->priv = MODEL_XML_TREE_LOADER_GET_PRIVATE (self);
 925         self->priv->current_element = NULL;
 926         self->root = NULL;
 927         self->ref_count = 1;
 928 }
 929
 930
 931 static void model_xml_tree_loader_finalize (ModelXmlTreeLoader* obj) {
 932         ModelXmlTreeLoader * self;
 933         self = MODEL_XML_TREE_LOADER (obj);
 934         _model_xml_element_unref0 (self->priv->current_element);
 935         _model_xml_element_unref0 (self->root);
 936 }
 937
 938
 939 GType model_xml_tree_loader_get_type (void) {
 940         static volatile gsize model_xml_tree_loader_type_id__volatile = 0;
 941         if (g_once_init_enter (&model_xml_tree_loader_type_id__volatile)) {
 942                 static const GTypeValueTable g_define_type_value_table = { model_value_xml_tree_loader_init, model_value_xml_tree_loader_free_value, model_value_xml_tree_loader_copy_value, model_value_xml_tree_loader_peek_pointer, "p", model_value_xml_tree_loader_collect_value, "p", model_value_xml_tree_loader_lcopy_value };
 943                 static const GTypeInfo g_define_type_info = { sizeof (ModelXmlTreeLoaderClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) model_xml_tree_loader_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ModelXmlTreeLoader), 0, (GInstanceInitFunc) model_xml_tree_loader_instance_init, &g_define_type_value_table };
 944                 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) };
 945                 GType model_xml_tree_loader_type_id;
 946                 model_xml_tree_loader_type_id = g_type_register_fundamental (g_type_fundamental_next (), "ModelXmlTreeLoader", &g_define_type_info, &g_define_type_fundamental_info, 0);
 947                 g_once_init_leave (&model_xml_tree_loader_type_id__volatile, model_xml_tree_loader_type_id);
 948         }
 949         return model_xml_tree_loader_type_id__volatile;
 950 }
 951
 952
 953 gpointer model_xml_tree_loader_ref (gpointer instance) {
 954         ModelXmlTreeLoader* self;
 955         self = instance;
 956         g_atomic_int_inc (&self->ref_count);
 957         return instance;
 958 }
 959
 960
 961 void model_xml_tree_loader_unref (gpointer instance) {
 962         ModelXmlTreeLoader* self;
 963         self = instance;
 964         if (g_atomic_int_dec_and_test (&self->ref_count)) {
 965                 MODEL_XML_TREE_LOADER_GET_CLASS (self)->finalize (self);
 966                 g_type_free_instance ((GTypeInstance *) self);
 967         }
 968 }
 969
 970
 971 static gpointer _g_object_ref0 (gpointer self) {
 972         return self ? g_object_ref (self) : NULL;
 973 }
 974
 975
 976 #line 114 "ProjectLoader.vala"
 977 ModelProjectBuilder* model_project_builder_construct (GType object_type, ModelLoaderHandler* handler) {
 978 #line 979 "ProjectLoader.c"
 979         ModelProjectBuilder * self;
 980         ModelLoaderHandler* _tmp0_;
 981 #line 114 "ProjectLoader.vala"
 982         g_return_val_if_fail (MODEL_IS_LOADER_HANDLER (handler), NULL);
 983 #line 114 "ProjectLoader.vala"
 984         self = (ModelProjectBuilder*) g_object_new (object_type, NULL);
 985 #line 115 "ProjectLoader.vala"
 986         self->priv->handler = (_tmp0_ = _g_object_ref0 (handler), _g_object_unref0 (self->priv->handler), _tmp0_);
 987 #line 988 "ProjectLoader.c"
 988         return self;
 989 }
 990
 991
 992 #line 114 "ProjectLoader.vala"
 993 ModelProjectBuilder* model_project_builder_new (ModelLoaderHandler* handler) {
 994 #line 114 "ProjectLoader.vala"
 995         return model_project_builder_construct (MODEL_TYPE_PROJECT_BUILDER, handler);
 996 #line 997 "ProjectLoader.c"
 997 }
 998
 999
1000 #line 118 "ProjectLoader.vala"
1001 static gboolean model_project_builder_check_name (ModelProjectBuilder* self, const char* expected_name, ModelXmlElement* node) {
1002 #line 1003 "ProjectLoader.c"
1003         gboolean result = FALSE;
1004         char* _tmp0_;
1005 #line 118 "ProjectLoader.vala"
1006         g_return_val_if_fail (MODEL_IS_PROJECT_BUILDER (self), FALSE);
1007 #line 118 "ProjectLoader.vala"
1008         g_return_val_if_fail (expected_name != NULL, FALSE);
1009 #line 118 "ProjectLoader.vala"
1010         g_return_val_if_fail (MODEL_IS_XML_ELEMENT (node), FALSE);
1011 #line 119 "ProjectLoader.vala"
1012         if (_vala_strcmp0 (model_xml_element_get_name (node), expected_name) == 0) {
1013 #line 1014 "ProjectLoader.c"
1014                 result = TRUE;
1015 #line 120 "ProjectLoader.vala"
1016                 return result;
1017 #line 1018 "ProjectLoader.c"
1018         }
1019 #line 123 "ProjectLoader.vala"
1020         g_signal_emit_by_name (self, "error-occurred", _tmp0_ = g_strdup_printf ("expected %s, got %s", expected_name, model_xml_element_get_name (node)));
1021 #line 1022 "ProjectLoader.c"
1022         _g_free0 (_tmp0_);
1023         result = FALSE;
1024 #line 124 "ProjectLoader.vala"
1025         return result;
1026 #line 1027 "ProjectLoader.c"
1027 }
1028
1029
1030 #line 127 "ProjectLoader.vala"
1031 static void model_project_builder_handle_clip (ModelProjectBuilder* self, ModelXmlElement* clip) {
1032 #line 127 "ProjectLoader.vala"
1033         g_return_if_fail (MODEL_IS_PROJECT_BUILDER (self));
1034 #line 127 "ProjectLoader.vala"
1035         g_return_if_fail (MODEL_IS_XML_ELEMENT (clip));
1036 #line 128 "ProjectLoader.vala"
1037         if (model_project_builder_check_name (self, "clip", clip)) {
1038 #line 129 "ProjectLoader.vala"
1039                 if (model_loader_handler_commit_clip (self->priv->handler, clip->attribute_names, clip->attribute_names_length1, clip->attribute_values, clip->attribute_values_length1)) {
1040 #line 130 "ProjectLoader.vala"
1041                         if (gee_collection_get_size (GEE_COLLECTION (model_xml_element_get_children (clip))) != 0) {
1042 #line 131 "ProjectLoader.vala"
1043                                 g_signal_emit_by_name (self, "error-occurred", "clip cannot have children");
1044 #line 1045 "ProjectLoader.c"
1045                         }
1046 #line 133 "ProjectLoader.vala"
1047                         model_loader_handler_leave_clip (self->priv->handler);
1048 #line 1049 "ProjectLoader.c"
1049                 }
1050         }
1051 }
1052
1053
1054 #line 138 "ProjectLoader.vala"
1055 static void model_project_builder_handle_track (ModelProjectBuilder* self, ModelXmlElement* track) {
1056 #line 138 "ProjectLoader.vala"
1057         g_return_if_fail (MODEL_IS_PROJECT_BUILDER (self));
1058 #line 138 "ProjectLoader.vala"
1059         g_return_if_fail (MODEL_IS_XML_ELEMENT (track));
1060 #line 139 "ProjectLoader.vala"
1061         if (model_project_builder_check_name (self, "track", track)) {
1062 #line 140 "ProjectLoader.vala"
1063                 logging_emit (G_OBJECT (self), LOGGING_FACILITY_LOADING, LOGGING_LEVEL_VERBOSE, "loading track");
1064 #line 141 "ProjectLoader.vala"
1065                 if (model_loader_handler_commit_track (self->priv->handler, track->attribute_names, track->attribute_names_length1, track->attribute_values, track->attribute_values_length1)) {
1066 #line 1067 "ProjectLoader.c"
1067                         {
1068                                 GeeIterator* _child_it;
1069                                 _child_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (model_xml_element_get_children (track)));
1070 #line 142 "ProjectLoader.vala"
1071                                 while (TRUE) {
1072 #line 1073 "ProjectLoader.c"
1073                                         ModelXmlElement* child;
1074 #line 142 "ProjectLoader.vala"
1075                                         if (!gee_iterator_next (_child_it)) {
1076 #line 142 "ProjectLoader.vala"
1077                                                 break;
1078 #line 1079 "ProjectLoader.c"
1079                                         }
1080 #line 142 "ProjectLoader.vala"
1081                                         child = (ModelXmlElement*) gee_iterator_get (_child_it);
1082 #line 143 "ProjectLoader.vala"
1083                                         model_project_builder_handle_clip (self, child);
1084 #line 1085 "ProjectLoader.c"
1085                                         _model_xml_element_unref0 (child);
1086                                 }
1087                                 _g_object_unref0 (_child_it);
1088                         }
1089 #line 145 "ProjectLoader.vala"
1090                         model_loader_handler_leave_track (self->priv->handler);
1091 #line 1092 "ProjectLoader.c"
1092                 }
1093         }
1094 }
1095
1096
1097 #line 150 "ProjectLoader.vala"
1098 static void model_project_builder_handle_preference (ModelProjectBuilder* self, ModelXmlElement* preference) {
1099 #line 150 "ProjectLoader.vala"
1100         g_return_if_fail (MODEL_IS_PROJECT_BUILDER (self));
1101 #line 150 "ProjectLoader.vala"
1102         g_return_if_fail (MODEL_IS_XML_ELEMENT (preference));
1103 #line 151 "ProjectLoader.vala"
1104         if (_vala_strcmp0 ("click", model_xml_element_get_name (preference)) == 0) {
1105 #line 152 "ProjectLoader.vala"
1106                 model_loader_handler_commit_click (self->priv->handler, preference->attribute_names, preference->attribute_names_length1, preference->attribute_values, preference->attribute_values_length1);
1107 #line 1108 "ProjectLoader.c"
1108         } else {
1109 #line 153 "ProjectLoader.vala"
1110                 if (_vala_strcmp0 ("library", model_xml_element_get_name (preference)) == 0) {
1111 #line 154 "ProjectLoader.vala"
1112                         model_loader_handler_commit_library_preference (self->priv->handler, preference->attribute_names, preference->attribute_names_length1, preference->attribute_values, preference->attribute_values_length1);
1113 #line 1114 "ProjectLoader.c"
1114                 } else {
1115                         char* _tmp0_;
1116 #line 157 "ProjectLoader.vala"
1117                         g_signal_emit_by_name (self, "error-occurred", _tmp0_ = g_strdup_printf ("Unknown preference: %s", model_xml_element_get_name (preference)));
1118 #line 1119 "ProjectLoader.c"
1119                         _g_free0 (_tmp0_);
1120                 }
1121         }
1122 }
1123
1124
1125 #line 161 "ProjectLoader.vala"
1126 static void model_project_builder_handle_time_signature (ModelProjectBuilder* self, ModelXmlElement* time_signature) {
1127 #line 161 "ProjectLoader.vala"
1128         g_return_if_fail (MODEL_IS_PROJECT_BUILDER (self));
1129 #line 161 "ProjectLoader.vala"
1130         g_return_if_fail (MODEL_IS_XML_ELEMENT (time_signature));
1131 #line 1132 "ProjectLoader.c"
1132         {
1133                 GeeIterator* _child_it;
1134                 _child_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (model_xml_element_get_children (time_signature)));
1135 #line 162 "ProjectLoader.vala"
1136                 while (TRUE) {
1137 #line 1138 "ProjectLoader.c"
1138                         ModelXmlElement* child;
1139 #line 162 "ProjectLoader.vala"
1140                         if (!gee_iterator_next (_child_it)) {
1141 #line 162 "ProjectLoader.vala"
1142                                 break;
1143 #line 1144 "ProjectLoader.c"
1144                         }
1145 #line 162 "ProjectLoader.vala"
1146                         child = (ModelXmlElement*) gee_iterator_get (_child_it);
1147 #line 163 "ProjectLoader.vala"
1148                         if (model_project_builder_check_name (self, "entry", child)) {
1149 #line 164 "ProjectLoader.vala"
1150                                 if (!model_loader_handler_commit_time_signature_entry (self->priv->handler, child->attribute_names, child->attribute_names_length1, child->attribute_values, child->attribute_values_length1)) {
1151 #line 166 "ProjectLoader.vala"
1152                                         g_signal_emit_by_name (self, "error-occurred", "Improper time signature node");
1153 #line 1154 "ProjectLoader.c"
1154                                 }
1155                         }
1156                         _model_xml_element_unref0 (child);
1157                 }
1158                 _g_object_unref0 (_child_it);
1159         }
1160 }
1161
1162
1163 #line 172 "ProjectLoader.vala"
1164 static void model_project_builder_handle_tempo (ModelProjectBuilder* self, ModelXmlElement* tempo) {
1165 #line 172 "ProjectLoader.vala"
1166         g_return_if_fail (MODEL_IS_PROJECT_BUILDER (self));
1167 #line 172 "ProjectLoader.vala"
1168         g_return_if_fail (MODEL_IS_XML_ELEMENT (tempo));
1169 #line 1170 "ProjectLoader.c"
1170         {
1171                 GeeIterator* _child_it;
1172                 _child_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (model_xml_element_get_children (tempo)));
1173 #line 173 "ProjectLoader.vala"
1174                 while (TRUE) {
1175 #line 1176 "ProjectLoader.c"
1176                         ModelXmlElement* child;
1177 #line 173 "ProjectLoader.vala"
1178                         if (!gee_iterator_next (_child_it)) {
1179 #line 173 "ProjectLoader.vala"
1180                                 break;
1181 #line 1182 "ProjectLoader.c"
1182                         }
1183 #line 173 "ProjectLoader.vala"
1184                         child = (ModelXmlElement*) gee_iterator_get (_child_it);
1185 #line 174 "ProjectLoader.vala"
1186                         if (model_project_builder_check_name (self, "entry", child)) {
1187 #line 175 "ProjectLoader.vala"
1188                                 if (!model_loader_handler_commit_tempo_entry (self->priv->handler, child->attribute_names, child->attribute_names_length1, child->attribute_values, child->attribute_values_length1)) {
1189 #line 176 "ProjectLoader.vala"
1190                                         g_signal_emit_by_name (self, "error-occurred", "Improper tempo node");
1191 #line 1192 "ProjectLoader.c"
1192                                 }
1193                         }
1194                         _model_xml_element_unref0 (child);
1195                 }
1196                 _g_object_unref0 (_child_it);
1197         }
1198 }
1199
1200
1201 #line 182 "ProjectLoader.vala"
1202 static void model_project_builder_handle_map (ModelProjectBuilder* self, ModelXmlElement* map) {
1203 #line 1204 "ProjectLoader.c"
1204         GQuark _tmp1_;
1205         const char* _tmp0_;
1206         static GQuark _tmp1__label0 = 0;
1207         static GQuark _tmp1__label1 = 0;
1208 #line 182 "ProjectLoader.vala"
1209         g_return_if_fail (MODEL_IS_PROJECT_BUILDER (self));
1210 #line 182 "ProjectLoader.vala"
1211         g_return_if_fail (MODEL_IS_XML_ELEMENT (map));
1212 #line 1213 "ProjectLoader.c"
1213         _tmp0_ = model_xml_element_get_name (map);
1214         _tmp1_ = (NULL == _tmp0_) ? 0 : g_quark_from_string (_tmp0_);
1215         if (_tmp1_ == ((0 != _tmp1__label0) ? _tmp1__label0 : (_tmp1__label0 = g_quark_from_static_string ("tempo"))))
1216         switch (0) {
1217                 default:
1218                 {
1219 #line 185 "ProjectLoader.vala"
1220                         model_project_builder_handle_tempo (self, map);
1221 #line 186 "ProjectLoader.vala"
1222                         break;
1223 #line 1224 "ProjectLoader.c"
1224                 }
1225         } else if (_tmp1_ == ((0 != _tmp1__label1) ? _tmp1__label1 : (_tmp1__label1 = g_quark_from_static_string ("time_signature"))))
1226         switch (0) {
1227                 default:
1228                 {
1229 #line 188 "ProjectLoader.vala"
1230                         model_project_builder_handle_time_signature (self, map);
1231 #line 189 "ProjectLoader.vala"
1232                         break;
1233 #line 1234 "ProjectLoader.c"
1234                 }
1235         } else
1236         switch (0) {
1237                 default:
1238                 {
1239 #line 191 "ProjectLoader.vala"
1240                         g_signal_emit_by_name (self, "error-occurred", "improper map node");
1241 #line 192 "ProjectLoader.vala"
1242                         break;
1243 #line 1244 "ProjectLoader.c"
1244                 }
1245         }
1246 }
1247
1248
1249 #line 196 "ProjectLoader.vala"
1250 static void model_project_builder_handle_library (ModelProjectBuilder* self, ModelXmlElement* library) {
1251 #line 196 "ProjectLoader.vala"
1252         g_return_if_fail (MODEL_IS_PROJECT_BUILDER (self));
1253 #line 196 "ProjectLoader.vala"
1254         g_return_if_fail (MODEL_IS_XML_ELEMENT (library));
1255 #line 197 "ProjectLoader.vala"
1256         if (model_loader_handler_commit_library (self->priv->handler, library->attribute_names, library->attribute_names_length1, library->attribute_values, library->attribute_values_length1)) {
1257 #line 1258 "ProjectLoader.c"
1258                 {
1259                         GeeIterator* _child_it;
1260                         _child_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (model_xml_element_get_children (library)));
1261 #line 198 "ProjectLoader.vala"
1262                         while (TRUE) {
1263 #line 1264 "ProjectLoader.c"
1264                                 ModelXmlElement* child;
1265 #line 198 "ProjectLoader.vala"
1266                                 if (!gee_iterator_next (_child_it)) {
1267 #line 198 "ProjectLoader.vala"
1268                                         break;
1269 #line 1270 "ProjectLoader.c"
1270                                 }
1271 #line 198 "ProjectLoader.vala"
1272                                 child = (ModelXmlElement*) gee_iterator_get (_child_it);
1273 #line 199 "ProjectLoader.vala"
1274                                 if (!model_loader_handler_commit_clipfile (self->priv->handler, child->attribute_names, child->attribute_names_length1, child->attribute_values, child->attribute_values_length1)) {
1275 #line 200 "ProjectLoader.vala"
1276                                         g_signal_emit_by_name (self, "error-occurred", "Improper library node");
1277 #line 1278 "ProjectLoader.c"
1278                                 }
1279                                 _model_xml_element_unref0 (child);
1280                         }
1281                         _g_object_unref0 (_child_it);
1282                 }
1283 #line 202 "ProjectLoader.vala"
1284                 model_loader_handler_leave_library (self->priv->handler);
1285 #line 1286 "ProjectLoader.c"
1286         }
1287 }
1288
1289
1290 #line 206 "ProjectLoader.vala"
1291 static void model_project_builder_handle_tracks (ModelProjectBuilder* self, ModelXmlElement* tracks) {
1292 #line 206 "ProjectLoader.vala"
1293         g_return_if_fail (MODEL_IS_PROJECT_BUILDER (self));
1294 #line 206 "ProjectLoader.vala"
1295         g_return_if_fail (MODEL_IS_XML_ELEMENT (tracks));
1296 #line 1297 "ProjectLoader.c"
1297         {
1298                 GeeIterator* _child_it;
1299                 _child_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (model_xml_element_get_children (tracks)));
1300 #line 207 "ProjectLoader.vala"
1301                 while (TRUE) {
1302 #line 1303 "ProjectLoader.c"
1303                         ModelXmlElement* child;
1304 #line 207 "ProjectLoader.vala"
1305                         if (!gee_iterator_next (_child_it)) {
1306 #line 207 "ProjectLoader.vala"
1307                                 break;
1308 #line 1309 "ProjectLoader.c"
1309                         }
1310 #line 207 "ProjectLoader.vala"
1311                         child = (ModelXmlElement*) gee_iterator_get (_child_it);
1312 #line 208 "ProjectLoader.vala"
1313                         model_project_builder_handle_track (self, child);
1314 #line 1315 "ProjectLoader.c"
1315                         _model_xml_element_unref0 (child);
1316                 }
1317                 _g_object_unref0 (_child_it);
1318         }
1319 }
1320
1321
1322 #line 212 "ProjectLoader.vala"
1323 static void model_project_builder_handle_preferences (ModelProjectBuilder* self, ModelXmlElement* preferences) {
1324 #line 212 "ProjectLoader.vala"
1325         g_return_if_fail (MODEL_IS_PROJECT_BUILDER (self));
1326 #line 212 "ProjectLoader.vala"
1327         g_return_if_fail (MODEL_IS_XML_ELEMENT (preferences));
1328 #line 1329 "ProjectLoader.c"
1329         {
1330                 GeeIterator* _child_it;
1331                 _child_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (model_xml_element_get_children (preferences)));
1332 #line 213 "ProjectLoader.vala"
1333                 while (TRUE) {
1334 #line 1335 "ProjectLoader.c"
1335                         ModelXmlElement* child;
1336 #line 213 "ProjectLoader.vala"
1337                         if (!gee_iterator_next (_child_it)) {
1338 #line 213 "ProjectLoader.vala"
1339                                 break;
1340 #line 1341 "ProjectLoader.c"
1341                         }
1342 #line 213 "ProjectLoader.vala"
1343                         child = (ModelXmlElement*) gee_iterator_get (_child_it);
1344 #line 214 "ProjectLoader.vala"
1345                         model_project_builder_handle_preference (self, child);
1346 #line 1347 "ProjectLoader.c"
1347                         _model_xml_element_unref0 (child);
1348                 }
1349                 _g_object_unref0 (_child_it);
1350         }
1351 }
1352
1353
1354 #line 217 "ProjectLoader.vala"
1355 static void model_project_builder_handle_maps (ModelProjectBuilder* self, ModelXmlElement* maps) {
1356 #line 217 "ProjectLoader.vala"
1357         g_return_if_fail (MODEL_IS_PROJECT_BUILDER (self));
1358 #line 217 "ProjectLoader.vala"
1359         g_return_if_fail (MODEL_IS_XML_ELEMENT (maps));
1360 #line 1361 "ProjectLoader.c"
1361         {
1362                 GeeIterator* _child_it;
1363                 _child_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (model_xml_element_get_children (maps)));
1364 #line 218 "ProjectLoader.vala"
1365                 while (TRUE) {
1366 #line 1367 "ProjectLoader.c"
1367                         ModelXmlElement* child;
1368 #line 218 "ProjectLoader.vala"
1369                         if (!gee_iterator_next (_child_it)) {
1370 #line 218 "ProjectLoader.vala"
1371                                 break;
1372 #line 1373 "ProjectLoader.c"
1373                         }
1374 #line 218 "ProjectLoader.vala"
1375                         child = (ModelXmlElement*) gee_iterator_get (_child_it);
1376 #line 219 "ProjectLoader.vala"
1377                         model_project_builder_handle_map (self, child);
1378 #line 1379 "ProjectLoader.c"
1379                         _model_xml_element_unref0 (child);
1380                 }
1381                 _g_object_unref0 (_child_it);
1382         }
1383 }
1384
1385
1386 #line 222 "ProjectLoader.vala"
1387 gboolean model_project_builder_check_project (ModelProjectBuilder* self, ModelXmlElement* root) {
1388 #line 1389 "ProjectLoader.c"
1389         gboolean result = FALSE;
1390         gboolean _tmp0_ = FALSE;
1391 #line 222 "ProjectLoader.vala"
1392         g_return_val_if_fail (MODEL_IS_PROJECT_BUILDER (self), FALSE);
1393 #line 222 "ProjectLoader.vala"
1394         g_return_val_if_fail ((root == NULL) || MODEL_IS_XML_ELEMENT (root), FALSE);
1395 #line 223 "ProjectLoader.vala"
1396         if (root == NULL) {
1397 #line 224 "ProjectLoader.vala"
1398                 g_signal_emit_by_name (self, "error-occurred", "Invalid XML file!");
1399 #line 1400 "ProjectLoader.c"
1400                 result = FALSE;
1401 #line 225 "ProjectLoader.vala"
1402                 return result;
1403 #line 1404 "ProjectLoader.c"
1404         }
1405 #line 228 "ProjectLoader.vala"
1406         if (model_project_builder_check_name (self, "marina", root)) {
1407 #line 229 "ProjectLoader.vala"
1408                 _tmp0_ = model_loader_handler_commit_marina (self->priv->handler, root->attribute_names, root->attribute_names_length1, root->attribute_values, root->attribute_values_length1);
1409 #line 1410 "ProjectLoader.c"
1410         } else {
1411 #line 228 "ProjectLoader.vala"
1412                 _tmp0_ = FALSE;
1413 #line 1414 "ProjectLoader.c"
1414         }
1415 #line 228 "ProjectLoader.vala"
1416         if (_tmp0_) {
1417 #line 1418 "ProjectLoader.c"
1418                 gboolean _tmp1_ = FALSE;
1419                 gboolean _tmp2_ = FALSE;
1420                 gboolean _tmp3_ = FALSE;
1421                 ModelXmlElement* _tmp4_;
1422                 gboolean _tmp5_;
1423                 gboolean _tmp8_ = FALSE;
1424 #line 230 "ProjectLoader.vala"
1425                 if (gee_collection_get_size (GEE_COLLECTION (model_xml_element_get_children (root))) != 3) {
1426 #line 230 "ProjectLoader.vala"
1427                         _tmp1_ = gee_collection_get_size (GEE_COLLECTION (model_xml_element_get_children (root))) != 4;
1428 #line 1429 "ProjectLoader.c"
1429                 } else {
1430 #line 230 "ProjectLoader.vala"
1431                         _tmp1_ = FALSE;
1432 #line 1433 "ProjectLoader.c"
1433                 }
1434 #line 230 "ProjectLoader.vala"
1435                 if (_tmp1_) {
1436 #line 231 "ProjectLoader.vala"
1437                         g_signal_emit_by_name (self, "error-occurred", "Improper number of children!");
1438 #line 1439 "ProjectLoader.c"
1439                         result = FALSE;
1440 #line 232 "ProjectLoader.vala"
1441                         return result;
1442 #line 1443 "ProjectLoader.c"
1443                 }
1444 #line 235 "ProjectLoader.vala"
1445                 if ((_tmp5_ = !model_project_builder_check_name (self, "library", _tmp4_ = (ModelXmlElement*) gee_abstract_list_get (GEE_ABSTRACT_LIST (model_xml_element_get_children (root)), 0)), _model_xml_element_unref0 (_tmp4_), _tmp5_)) {
1446 #line 235 "ProjectLoader.vala"
1447                         _tmp3_ = TRUE;
1448 #line 1449 "ProjectLoader.c"
1449                 } else {
1450                         ModelXmlElement* _tmp6_;
1451 #line 236 "ProjectLoader.vala"
1452                         _tmp3_ = !model_project_builder_check_name (self, "tracks", _tmp6_ = (ModelXmlElement*) gee_abstract_list_get (GEE_ABSTRACT_LIST (model_xml_element_get_children (root)), 1));
1453 #line 1454 "ProjectLoader.c"
1454                         _model_xml_element_unref0 (_tmp6_);
1455                 }
1456 #line 235 "ProjectLoader.vala"
1457                 if (_tmp3_) {
1458 #line 235 "ProjectLoader.vala"
1459                         _tmp2_ = TRUE;
1460 #line 1461 "ProjectLoader.c"
1461                 } else {
1462                         ModelXmlElement* _tmp7_;
1463 #line 237 "ProjectLoader.vala"
1464                         _tmp2_ = !model_project_builder_check_name (self, "preferences", _tmp7_ = (ModelXmlElement*) gee_abstract_list_get (GEE_ABSTRACT_LIST (model_xml_element_get_children (root)), 2));
1465 #line 1466 "ProjectLoader.c"
1466                         _model_xml_element_unref0 (_tmp7_);
1467                 }
1468 #line 235 "ProjectLoader.vala"
1469                 if (_tmp2_) {
1470 #line 1471 "ProjectLoader.c"
1471                         result = FALSE;
1472 #line 238 "ProjectLoader.vala"
1473                         return result;
1474 #line 1475 "ProjectLoader.c"
1475                 }
1476 #line 240 "ProjectLoader.vala"
1477                 if (gee_collection_get_size (GEE_COLLECTION (model_xml_element_get_children (root))) == 4) {
1478 #line 1479 "ProjectLoader.c"
1479                         ModelXmlElement* _tmp9_;
1480 #line 240 "ProjectLoader.vala"
1481                         _tmp8_ = !model_project_builder_check_name (self, "maps", _tmp9_ = (ModelXmlElement*) gee_abstract_list_get (GEE_ABSTRACT_LIST (model_xml_element_get_children (root)), 3));
1482 #line 1483 "ProjectLoader.c"
1483                         _model_xml_element_unref0 (_tmp9_);
1484                 } else {
1485 #line 240 "ProjectLoader.vala"
1486                         _tmp8_ = FALSE;
1487 #line 1488 "ProjectLoader.c"
1488                 }
1489 #line 240 "ProjectLoader.vala"
1490                 if (_tmp8_) {
1491 #line 1492 "ProjectLoader.c"
1492                         result = FALSE;
1493 #line 241 "ProjectLoader.vala"
1494                         return result;
1495 #line 1496 "ProjectLoader.c"
1496                 }
1497         } else {
1498                 result = FALSE;
1499 #line 244 "ProjectLoader.vala"
1500                 return result;
1501 #line 1502 "ProjectLoader.c"
1502         }
1503         result = TRUE;
1504 #line 245 "ProjectLoader.vala"
1505         return result;
1506 #line 1507 "ProjectLoader.c"
1507 }
1508
1509
1510 #line 248 "ProjectLoader.vala"
1511 void model_project_builder_build_project (ModelProjectBuilder* self, ModelXmlElement* root) {
1512 #line 1513 "ProjectLoader.c"
1513         ModelXmlElement* _tmp0_;
1514         ModelXmlElement* _tmp1_;
1515         ModelXmlElement* _tmp2_;
1516 #line 248 "ProjectLoader.vala"
1517         g_return_if_fail (MODEL_IS_PROJECT_BUILDER (self));
1518 #line 248 "ProjectLoader.vala"
1519         g_return_if_fail ((root == NULL) || MODEL_IS_XML_ELEMENT (root));
1520 #line 249 "ProjectLoader.vala"
1521         model_project_builder_handle_library (self, _tmp0_ = (ModelXmlElement*) gee_abstract_list_get (GEE_ABSTRACT_LIST (model_xml_element_get_children (root)), 0));
1522 #line 1523 "ProjectLoader.c"
1523         _model_xml_element_unref0 (_tmp0_);
1524 #line 250 "ProjectLoader.vala"
1525         model_project_builder_handle_tracks (self, _tmp1_ = (ModelXmlElement*) gee_abstract_list_get (GEE_ABSTRACT_LIST (model_xml_element_get_children (root)), 1));
1526 #line 1527 "ProjectLoader.c"
1527         _model_xml_element_unref0 (_tmp1_);
1528 #line 251 "ProjectLoader.vala"
1529         model_project_builder_handle_preferences (self, _tmp2_ = (ModelXmlElement*) gee_abstract_list_get (GEE_ABSTRACT_LIST (model_xml_element_get_children (root)), 2));
1530 #line 1531 "ProjectLoader.c"
1531         _model_xml_element_unref0 (_tmp2_);
1532 #line 252 "ProjectLoader.vala"
1533         if (gee_collection_get_size (GEE_COLLECTION (model_xml_element_get_children (root))) == 4) {
1534 #line 1535 "ProjectLoader.c"
1535                 ModelXmlElement* _tmp3_;
1536 #line 253 "ProjectLoader.vala"
1537                 model_project_builder_handle_maps (self, _tmp3_ = (ModelXmlElement*) gee_abstract_list_get (GEE_ABSTRACT_LIST (model_xml_element_get_children (root)), 3));
1538 #line 1539 "ProjectLoader.c"
1539                 _model_xml_element_unref0 (_tmp3_);
1540         }
1541 #line 256 "ProjectLoader.vala"
1542         model_loader_handler_leave_marina (self->priv->handler);
1543 #line 1544 "ProjectLoader.c"
1544 }
1545
1546
1547 static void model_project_builder_class_init (ModelProjectBuilderClass * klass) {
1548         model_project_builder_parent_class = g_type_class_peek_parent (klass);
1549         g_type_class_add_private (klass, sizeof (ModelProjectBuilderPrivate));
1550         G_OBJECT_CLASS (klass)->finalize = model_project_builder_finalize;
1551         g_signal_new ("error_occurred", MODEL_TYPE_PROJECT_BUILDER, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__STRING, G_TYPE_NONE, 1, G_TYPE_STRING);
1552 }
1553
1554
1555 static void model_project_builder_instance_init (ModelProjectBuilder * self) {
1556         self->priv = MODEL_PROJECT_BUILDER_GET_PRIVATE (self);
1557 }
1558
1559
1560 static void model_project_builder_finalize (GObject* obj) {
1561         ModelProjectBuilder * self;
1562         self = MODEL_PROJECT_BUILDER (obj);
1563         _g_object_unref0 (self->priv->handler);
1564         G_OBJECT_CLASS (model_project_builder_parent_class)->finalize (obj);
1565 }
1566
1567
1568 GType model_project_builder_get_type (void) {
1569         static volatile gsize model_project_builder_type_id__volatile = 0;
1570         if (g_once_init_enter (&model_project_builder_type_id__volatile)) {
1571                 static const GTypeInfo g_define_type_info = { sizeof (ModelProjectBuilderClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) model_project_builder_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ModelProjectBuilder), 0, (GInstanceInitFunc) model_project_builder_instance_init, NULL };
1572                 GType model_project_builder_type_id;
1573                 model_project_builder_type_id = g_type_register_static (G_TYPE_OBJECT, "ModelProjectBuilder", &g_define_type_info, 0);
1574                 g_once_init_leave (&model_project_builder_type_id__volatile, model_project_builder_type_id);
1575         }
1576         return model_project_builder_type_id__volatile;
1577 }
1578
1579
1580 #line 272 "ProjectLoader.vala"
1581 ModelXmlElement* model_xml_element_construct (GType object_type, const char* name, char** attribute_names, int attribute_names_length1, char** attribute_values, int attribute_values_length1, ModelXmlElement* parent) {
1582 #line 1583 "ProjectLoader.c"
1583         ModelXmlElement* self;
1584         char** _tmp1_;
1585         gint _tmp0_;
1586         char** _tmp3_;
1587         gint _tmp2_;
1588         GeeArrayList* _tmp4_;
1589 #line 272 "ProjectLoader.vala"
1590         g_return_val_if_fail (name != NULL, NULL);
1591 #line 272 "ProjectLoader.vala"
1592         g_return_val_if_fail ((parent == NULL) || MODEL_IS_XML_ELEMENT (parent), NULL);
1593 #line 1594 "ProjectLoader.c"
1594         self = (ModelXmlElement*) g_type_create_instance (object_type);
1595 #line 274 "ProjectLoader.vala"
1596         model_xml_element_set_name (self, name);
1597 #line 276 "ProjectLoader.vala"
1598         self->attribute_names = (_tmp1_ = copy_array (attribute_names, attribute_names_length1, &_tmp0_), self->attribute_names = (_vala_array_free (self->attribute_names, self->attribute_names_length1, (GDestroyNotify) g_free), NULL), self->attribute_names_length1 = _tmp0_, _tmp1_);
1599 #line 277 "ProjectLoader.vala"
1600         self->attribute_values = (_tmp3_ = copy_array (attribute_values, attribute_values_length1, &_tmp2_), self->attribute_values = (_vala_array_free (self->attribute_values, self->attribute_values_length1, (GDestroyNotify) g_free), NULL), self->attribute_values_length1 = _tmp2_, _tmp3_);
1601 #line 278 "ProjectLoader.vala"
1602         model_xml_element_set_parent (self, parent);
1603 #line 279 "ProjectLoader.vala"
1604         self->priv->_children = (_tmp4_ = gee_array_list_new (MODEL_TYPE_XML_ELEMENT, (GBoxedCopyFunc) model_xml_element_ref, model_xml_element_unref, NULL), _g_object_unref0 (self->priv->_children), _tmp4_);
1605 #line 1606 "ProjectLoader.c"
1606         return self;
1607 }
1608
1609
1610 #line 272 "ProjectLoader.vala"
1611 ModelXmlElement* model_xml_element_new (const char* name, char** attribute_names, int attribute_names_length1, char** attribute_values, int attribute_values_length1, ModelXmlElement* parent) {
1612 #line 272 "ProjectLoader.vala"
1613         return model_xml_element_construct (MODEL_TYPE_XML_ELEMENT, name, attribute_names, attribute_names_length1, attribute_values, attribute_values_length1, parent);
1614 #line 1615 "ProjectLoader.c"
1615 }
1616
1617
1618 #line 282 "ProjectLoader.vala"
1619 void model_xml_element_add_child (ModelXmlElement* self, ModelXmlElement* child_element) {
1620 #line 282 "ProjectLoader.vala"
1621         g_return_if_fail (MODEL_IS_XML_ELEMENT (self));
1622 #line 282 "ProjectLoader.vala"
1623         g_return_if_fail (MODEL_IS_XML_ELEMENT (child_element));
1624 #line 283 "ProjectLoader.vala"
1625         gee_abstract_collection_add (GEE_ABSTRACT_COLLECTION (self->priv->_children), child_element);
1626 #line 1627 "ProjectLoader.c"
1627 }
1628
1629
1630 const char* model_xml_element_get_name (ModelXmlElement* self) {
1631         const char* result;
1632         g_return_val_if_fail (MODEL_IS_XML_ELEMENT (self), NULL);
1633         result = self->priv->_name;
1634 #line 261 "ProjectLoader.vala"
1635         return result;
1636 #line 1637 "ProjectLoader.c"
1637 }
1638
1639
1640 static void model_xml_element_set_name (ModelXmlElement* self, const char* value) {
1641         char* _tmp0_;
1642         g_return_if_fail (MODEL_IS_XML_ELEMENT (self));
1643         self->priv->_name = (_tmp0_ = g_strdup (value), _g_free0 (self->priv->_name), _tmp0_);
1644 }
1645
1646
1647 GeeArrayList* model_xml_element_get_children (ModelXmlElement* self) {
1648         GeeArrayList* result;
1649         g_return_val_if_fail (MODEL_IS_XML_ELEMENT (self), NULL);
1650         result = self->priv->_children;
1651 #line 267 "ProjectLoader.vala"
1652         return result;
1653 #line 1654 "ProjectLoader.c"
1654 }
1655
1656
1657 ModelXmlElement* model_xml_element_get_parent (ModelXmlElement* self) {
1658         ModelXmlElement* result;
1659         g_return_val_if_fail (MODEL_IS_XML_ELEMENT (self), NULL);
1660         result = self->priv->_parent;
1661 #line 269 "ProjectLoader.vala"
1662         return result;
1663 #line 1664 "ProjectLoader.c"
1664 }
1665
1666
1667 static void model_xml_element_set_parent (ModelXmlElement* self, ModelXmlElement* value) {
1668         g_return_if_fail (MODEL_IS_XML_ELEMENT (self));
1669         self->priv->_parent = value;
1670 }
1671
1672
1673 static void model_value_xml_element_init (GValue* value) {
1674         value->data[0].v_pointer = NULL;
1675 }
1676
1677
1678 static void model_value_xml_element_free_value (GValue* value) {
1679         if (value->data[0].v_pointer) {
1680                 model_xml_element_unref (value->data[0].v_pointer);
1681         }
1682 }
1683
1684
1685 static void model_value_xml_element_copy_value (const GValue* src_value, GValue* dest_value) {
1686         if (src_value->data[0].v_pointer) {
1687                 dest_value->data[0].v_pointer = model_xml_element_ref (src_value->data[0].v_pointer);
1688         } else {
1689                 dest_value->data[0].v_pointer = NULL;
1690         }
1691 }
1692
1693
1694 static gpointer model_value_xml_element_peek_pointer (const GValue* value) {
1695         return value->data[0].v_pointer;
1696 }
1697
1698
1699 static gchar* model_value_xml_element_collect_value (GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {
1700         if (collect_values[0].v_pointer) {
1701                 ModelXmlElement* object;
1702                 object = collect_values[0].v_pointer;
1703                 if (object->parent_instance.g_class == NULL) {
1704                         return g_strconcat ("invalid unclassed object pointer for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
1705                 } else if (!g_value_type_compatible (G_TYPE_FROM_INSTANCE (object), G_VALUE_TYPE (value))) {
1706                         return g_strconcat ("invalid object type `", g_type_name (G_TYPE_FROM_INSTANCE (object)), "' for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
1707                 }
1708                 value->data[0].v_pointer = model_xml_element_ref (object);
1709         } else {
1710                 value->data[0].v_pointer = NULL;
1711         }
1712         return NULL;
1713 }
1714
1715
1716 static gchar* model_value_xml_element_lcopy_value (const GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {
1717         ModelXmlElement** object_p;
1718         object_p = collect_values[0].v_pointer;
1719         if (!object_p) {
1720                 return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
1721         }
1722         if (!value->data[0].v_pointer) {
1723                 *object_p = NULL;
1724         } else if (collect_flags && G_VALUE_NOCOPY_CONTENTS) {
1725                 *object_p = value->data[0].v_pointer;
1726         } else {
1727                 *object_p = model_xml_element_ref (value->data[0].v_pointer);
1728         }
1729         return NULL;
1730 }
1731
1732
1733 GParamSpec* model_param_spec_xml_element (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags) {
1734         ModelParamSpecXmlElement* spec;
1735         g_return_val_if_fail (g_type_is_a (object_type, MODEL_TYPE_XML_ELEMENT), NULL);
1736         spec = g_param_spec_internal (G_TYPE_PARAM_OBJECT, name, nick, blurb, flags);
1737         G_PARAM_SPEC (spec)->value_type = object_type;
1738         return G_PARAM_SPEC (spec);
1739 }
1740
1741
1742 gpointer model_value_get_xml_element (const GValue* value) {
1743         g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, MODEL_TYPE_XML_ELEMENT), NULL);
1744         return value->data[0].v_pointer;
1745 }
1746
1747
1748 void model_value_set_xml_element (GValue* value, gpointer v_object) {
1749         ModelXmlElement* old;
1750         g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, MODEL_TYPE_XML_ELEMENT));
1751         old = value->data[0].v_pointer;
1752         if (v_object) {
1753                 g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, MODEL_TYPE_XML_ELEMENT));
1754                 g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
1755                 value->data[0].v_pointer = v_object;
1756                 model_xml_element_ref (value->data[0].v_pointer);
1757         } else {
1758                 value->data[0].v_pointer = NULL;
1759         }
1760         if (old) {
1761                 model_xml_element_unref (old);
1762         }
1763 }
1764
1765
1766 void model_value_take_xml_element (GValue* value, gpointer v_object) {
1767         ModelXmlElement* old;
1768         g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, MODEL_TYPE_XML_ELEMENT));
1769         old = value->data[0].v_pointer;
1770         if (v_object) {
1771                 g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, MODEL_TYPE_XML_ELEMENT));
1772                 g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
1773                 value->data[0].v_pointer = v_object;
1774         } else {
1775                 value->data[0].v_pointer = NULL;
1776         }
1777         if (old) {
1778                 model_xml_element_unref (old);
1779         }
1780 }
1781
1782
1783 static void model_xml_element_class_init (ModelXmlElementClass * klass) {
1784         model_xml_element_parent_class = g_type_class_peek_parent (klass);
1785         MODEL_XML_ELEMENT_CLASS (klass)->finalize = model_xml_element_finalize;
1786         g_type_class_add_private (klass, sizeof (ModelXmlElementPrivate));
1787 }
1788
1789
1790 static void model_xml_element_instance_init (ModelXmlElement * self) {
1791         self->priv = MODEL_XML_ELEMENT_GET_PRIVATE (self);
1792         self->ref_count = 1;
1793 }
1794
1795
1796 static void model_xml_element_finalize (ModelXmlElement* obj) {
1797         ModelXmlElement * self;
1798         self = MODEL_XML_ELEMENT (obj);
1799         _g_free0 (self->priv->_name);
1800         self->attribute_names = (_vala_array_free (self->attribute_names, self->attribute_names_length1, (GDestroyNotify) g_free), NULL);
1801         self->attribute_values = (_vala_array_free (self->attribute_values, self->attribute_values_length1, (GDestroyNotify) g_free), NULL);
1802         _g_object_unref0 (self->priv->_children);
1803 }
1804
1805
1806 GType model_xml_element_get_type (void) {
1807         static volatile gsize model_xml_element_type_id__volatile = 0;
1808         if (g_once_init_enter (&model_xml_element_type_id__volatile)) {
1809                 static const GTypeValueTable g_define_type_value_table = { model_value_xml_element_init, model_value_xml_element_free_value, model_value_xml_element_copy_value, model_value_xml_element_peek_pointer, "p", model_value_xml_element_collect_value, "p", model_value_xml_element_lcopy_value };
1810                 static const GTypeInfo g_define_type_info = { sizeof (ModelXmlElementClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) model_xml_element_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ModelXmlElement), 0, (GInstanceInitFunc) model_xml_element_instance_init, &g_define_type_value_table };
1811                 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) };
1812                 GType model_xml_element_type_id;
1813                 model_xml_element_type_id = g_type_register_fundamental (g_type_fundamental_next (), "ModelXmlElement", &g_define_type_info, &g_define_type_fundamental_info, 0);
1814                 g_once_init_leave (&model_xml_element_type_id__volatile, model_xml_element_type_id);
1815         }
1816         return model_xml_element_type_id__volatile;
1817 }
1818
1819
1820 gpointer model_xml_element_ref (gpointer instance) {
1821         ModelXmlElement* self;
1822         self = instance;
1823         g_atomic_int_inc (&self->ref_count);
1824         return instance;
1825 }
1826
1827
1828 void model_xml_element_unref (gpointer instance) {
1829         ModelXmlElement* self;
1830         self = instance;
1831         if (g_atomic_int_dec_and_test (&self->ref_count)) {
1832                 MODEL_XML_ELEMENT_GET_CLASS (self)->finalize (self);
1833                 g_type_free_instance ((GTypeInstance *) self);
1834         }
1835 }
1836
1837
1838 #line 307 "ProjectLoader.vala"
1839 static void _model_project_loader_on_load_error_model_loader_handler_load_error (ModelLoaderHandler* _sender, const char* error_message, gpointer self) {
1840 #line 1841 "ProjectLoader.c"
1841         model_project_loader_on_load_error (self, error_message);
1842 }
1843
1844
1845 #line 312 "ProjectLoader.vala"
1846 static void _model_project_loader_on_handler_complete_model_loader_handler_complete (ModelLoaderHandler* _sender, gpointer self) {
1847 #line 1848 "ProjectLoader.c"
1848         model_project_loader_on_handler_complete (self);
1849 }
1850
1851
1852 #line 300 "ProjectLoader.vala"
1853 ModelProjectLoader* model_project_loader_construct (GType object_type, ModelLoaderHandler* loader_handler, const char* file_name) {
1854 #line 1855 "ProjectLoader.c"
1855         ModelProjectLoader * self;
1856         char* _tmp0_;
1857         ModelLoaderHandler* _tmp1_;
1858 #line 300 "ProjectLoader.vala"
1859         g_return_val_if_fail (MODEL_IS_LOADER_HANDLER (loader_handler), NULL);
1860 #line 300 "ProjectLoader.vala"
1861         self = (ModelProjectLoader*) g_object_new (object_type, NULL);
1862 #line 301 "ProjectLoader.vala"
1863         self->priv->file_name = (_tmp0_ = g_strdup (file_name), _g_free0 (self->priv->file_name), _tmp0_);
1864 #line 302 "ProjectLoader.vala"
1865         self->priv->loader_handler = (_tmp1_ = _g_object_ref0 (loader_handler), _g_object_unref0 (self->priv->loader_handler), _tmp1_);
1866 #line 303 "ProjectLoader.vala"
1867         g_signal_connect_object (loader_handler, "load-error", (GCallback) _model_project_loader_on_load_error_model_loader_handler_load_error, self, 0);
1868 #line 304 "ProjectLoader.vala"
1869         g_signal_connect_object (loader_handler, "complete", (GCallback) _model_project_loader_on_handler_complete_model_loader_handler_complete, self, 0);
1870 #line 1871 "ProjectLoader.c"
1871         return self;
1872 }
1873
1874
1875 #line 300 "ProjectLoader.vala"
1876 ModelProjectLoader* model_project_loader_new (ModelLoaderHandler* loader_handler, const char* file_name) {
1877 #line 300 "ProjectLoader.vala"
1878         return model_project_loader_construct (MODEL_TYPE_PROJECT_LOADER, loader_handler, file_name);
1879 #line 1880 "ProjectLoader.c"
1880 }
1881
1882
1883 #line 307 "ProjectLoader.vala"
1884 static void model_project_loader_on_load_error (ModelProjectLoader* self, const char* _error_) {
1885 #line 307 "ProjectLoader.vala"
1886         g_return_if_fail (MODEL_IS_PROJECT_LOADER (self));
1887 #line 307 "ProjectLoader.vala"
1888         g_return_if_fail (_error_ != NULL);
1889 #line 308 "ProjectLoader.vala"
1890         logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_load_error");
1891 #line 309 "ProjectLoader.vala"
1892         g_signal_emit_by_name (self, "load-error", _error_);
1893 #line 1894 "ProjectLoader.c"
1894 }
1895
1896
1897 #line 312 "ProjectLoader.vala"
1898 static void model_project_loader_on_handler_complete (ModelProjectLoader* self) {
1899 #line 1900 "ProjectLoader.c"
1900         gboolean _tmp0_ = FALSE;
1901 #line 312 "ProjectLoader.vala"
1902         g_return_if_fail (MODEL_IS_PROJECT_LOADER (self));
1903 #line 313 "ProjectLoader.vala"
1904         logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_handler_complete");
1905 #line 314 "ProjectLoader.vala"
1906         self->priv->handler_completed = TRUE;
1907 #line 315 "ProjectLoader.vala"
1908         if (self->priv->project_load_completed) {
1909 #line 315 "ProjectLoader.vala"
1910                 _tmp0_ = !self->priv->load_completed_fired;
1911 #line 1912 "ProjectLoader.c"
1912         } else {
1913 #line 315 "ProjectLoader.vala"
1914                 _tmp0_ = FALSE;
1915 #line 1916 "ProjectLoader.c"
1916         }
1917 #line 315 "ProjectLoader.vala"
1918         if (_tmp0_) {
1919 #line 316 "ProjectLoader.vala"
1920                 self->priv->load_completed_fired = TRUE;
1921 #line 317 "ProjectLoader.vala"
1922                 g_signal_emit_by_name (self, "load-complete");
1923 #line 1924 "ProjectLoader.c"
1924         }
1925 }
1926
1927
1928 #line 307 "ProjectLoader.vala"
1929 static void _model_project_loader_on_load_error_model_project_builder_error_occurred (ModelProjectBuilder* _sender, const char* _error_, gpointer self) {
1930 #line 1931 "ProjectLoader.c"
1931         model_project_loader_on_load_error (self, _error_);
1932 }
1933
1934
1935 #line 321 "ProjectLoader.vala"
1936 void model_project_loader_load (ModelProjectLoader* self) {
1937 #line 1938 "ProjectLoader.c"
1938         GError * _inner_error_;
1939         char* _tmp3_;
1940         ModelXmlTreeLoader* tree_loader;
1941         ModelProjectBuilder* builder;
1942 #line 321 "ProjectLoader.vala"
1943         g_return_if_fail (MODEL_IS_PROJECT_LOADER (self));
1944 #line 1945 "ProjectLoader.c"
1945         _inner_error_ = NULL;
1946         {
1947                 char* _tmp1_;
1948                 char* _tmp0_ = NULL;
1949 #line 323 "ProjectLoader.vala"
1950                 g_file_get_contents (self->priv->file_name, &_tmp0_, &self->priv->text_len, &_inner_error_);
1951 #line 323 "ProjectLoader.vala"
1952                 self->priv->text = (_tmp1_ = _tmp0_, _g_free0 (self->priv->text), _tmp1_);
1953 #line 1954 "ProjectLoader.c"
1954                 if (_inner_error_ != NULL) {
1955                         if (_inner_error_->domain == G_FILE_ERROR) {
1956                                 goto __catch1_g_file_error;
1957                         }
1958                         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);
1959                         g_clear_error (&_inner_error_);
1960                         return;
1961                 }
1962         }
1963         goto __finally1;
1964         __catch1_g_file_error:
1965         {
1966                 GError * e;
1967                 e = _inner_error_;
1968                 _inner_error_ = NULL;
1969                 {
1970                         char* _tmp2_;
1971 #line 325 "ProjectLoader.vala"
1972                         logging_emit (G_OBJECT (self), LOGGING_FACILITY_LOADING, LOGGING_LEVEL_MEDIUM, _tmp2_ = g_strdup_printf ("error loading %s: %s", self->priv->file_name, e->message));
1973 #line 1974 "ProjectLoader.c"
1974                         _g_free0 (_tmp2_);
1975 #line 327 "ProjectLoader.vala"
1976                         g_signal_emit_by_name (self, "load-error", e->message);
1977 #line 328 "ProjectLoader.vala"
1978                         g_signal_emit_by_name (self, "load-complete");
1979 #line 1980 "ProjectLoader.c"
1980                         _g_error_free0 (e);
1981 #line 329 "ProjectLoader.vala"
1982                         return;
1983 #line 1984 "ProjectLoader.c"
1984                 }
1985         }
1986         __finally1:
1987         if (_inner_error_ != NULL) {
1988                 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);
1989                 g_clear_error (&_inner_error_);
1990                 return;
1991         }
1992 #line 331 "ProjectLoader.vala"
1993         logging_emit (G_OBJECT (self), LOGGING_FACILITY_LOADING, LOGGING_LEVEL_VERBOSE, _tmp3_ = g_strdup_printf ("Building tree for %s", self->priv->file_name));
1994 #line 1995 "ProjectLoader.c"
1995         _g_free0 (_tmp3_);
1996 #line 332 "ProjectLoader.vala"
1997         tree_loader = model_xml_tree_loader_new (self->priv->text);
1998 #line 334 "ProjectLoader.vala"
1999         builder = model_project_builder_new (self->priv->loader_handler);
2000 #line 335 "ProjectLoader.vala"
2001         g_signal_connect_object (builder, "error-occurred", (GCallback) _model_project_loader_on_load_error_model_project_builder_error_occurred, self, 0);
2002 #line 337 "ProjectLoader.vala"
2003         if (model_project_builder_check_project (builder, tree_loader->root)) {
2004 #line 2005 "ProjectLoader.c"
2005                 gboolean _tmp4_ = FALSE;
2006 #line 338 "ProjectLoader.vala"
2007                 logging_emit (G_OBJECT (self), LOGGING_FACILITY_LOADING, LOGGING_LEVEL_VERBOSE, "project checked out.  starting load");
2008 #line 339 "ProjectLoader.vala"
2009                 g_signal_emit_by_name (self, "load-started", self->priv->file_name);
2010 #line 340 "ProjectLoader.vala"
2011                 model_project_builder_build_project (builder, tree_loader->root);
2012 #line 341 "ProjectLoader.vala"
2013                 self->priv->project_load_completed = TRUE;
2014 #line 342 "ProjectLoader.vala"
2015                 if (self->priv->handler_completed) {
2016 #line 342 "ProjectLoader.vala"
2017                         _tmp4_ = !self->priv->load_completed_fired;
2018 #line 2019 "ProjectLoader.c"
2019                 } else {
2020 #line 342 "ProjectLoader.vala"
2021                         _tmp4_ = FALSE;
2022 #line 2023 "ProjectLoader.c"
2023                 }
2024 #line 342 "ProjectLoader.vala"
2025                 if (_tmp4_) {
2026 #line 343 "ProjectLoader.vala"
2027                         self->priv->load_completed_fired = TRUE;
2028 #line 344 "ProjectLoader.vala"
2029                         g_signal_emit_by_name (self, "load-complete");
2030 #line 2031 "ProjectLoader.c"
2031                 }
2032         } else {
2033 #line 348 "ProjectLoader.vala"
2034                 logging_emit (G_OBJECT (self), LOGGING_FACILITY_LOADING, LOGGING_LEVEL_INFO, "project did not check out.  stopping.");
2035 #line 349 "ProjectLoader.vala"
2036                 g_signal_emit_by_name (self, "load-complete");
2037 #line 2038 "ProjectLoader.c"
2038         }
2039         _model_xml_tree_loader_unref0 (tree_loader);
2040         _g_object_unref0 (builder);
2041 }
2042
2043
2044 static void model_project_loader_class_init (ModelProjectLoaderClass * klass) {
2045         model_project_loader_parent_class = g_type_class_peek_parent (klass);
2046         g_type_class_add_private (klass, sizeof (ModelProjectLoaderPrivate));
2047         G_OBJECT_CLASS (klass)->finalize = model_project_loader_finalize;
2048         g_signal_new ("load_started", MODEL_TYPE_PROJECT_LOADER, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__STRING, G_TYPE_NONE, 1, G_TYPE_STRING);
2049         g_signal_new ("load_complete", MODEL_TYPE_PROJECT_LOADER, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
2050         g_signal_new ("load_error", MODEL_TYPE_PROJECT_LOADER, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__STRING, G_TYPE_NONE, 1, G_TYPE_STRING);
2051 }
2052
2053
2054 static void model_project_loader_instance_init (ModelProjectLoader * self) {
2055         self->priv = MODEL_PROJECT_LOADER_GET_PRIVATE (self);
2056         self->priv->project_load_completed = FALSE;
2057         self->priv->load_completed_fired = FALSE;
2058         self->priv->handler_completed = FALSE;
2059 }
2060
2061
2062 static void model_project_loader_finalize (GObject* obj) {
2063         ModelProjectLoader * self;
2064         self = MODEL_PROJECT_LOADER (obj);
2065         _g_free0 (self->priv->file_name);
2066         _g_object_unref0 (self->priv->loader_handler);
2067         _g_free0 (self->priv->text);
2068         G_OBJECT_CLASS (model_project_loader_parent_class)->finalize (obj);
2069 }
2070
2071
2072 GType model_project_loader_get_type (void) {
2073         static volatile gsize model_project_loader_type_id__volatile = 0;
2074         if (g_once_init_enter (&model_project_loader_type_id__volatile)) {
2075                 static const GTypeInfo g_define_type_info = { sizeof (ModelProjectLoaderClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) model_project_loader_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ModelProjectLoader), 0, (GInstanceInitFunc) model_project_loader_instance_init, NULL };
2076                 GType model_project_loader_type_id;
2077                 model_project_loader_type_id = g_type_register_static (G_TYPE_OBJECT, "ModelProjectLoader", &g_define_type_info, 0);
2078                 g_once_init_leave (&model_project_loader_type_id__volatile, model_project_loader_type_id);
2079         }
2080         return model_project_loader_type_id__volatile;
2081 }
2082
2083
2084 static void _vala_array_destroy (gpointer array, gint array_length, GDestroyNotify destroy_func) {
2085         if ((array != NULL) && (destroy_func != NULL)) {
2086                 int i;
2087                 for (i = 0; i < array_length; i = i + 1) {
2088                         if (((gpointer*) array)[i] != NULL) {
2089                                 destroy_func (((gpointer*) array)[i]);
2090                         }
2091                 }
2092         }
2093 }
2094
2095
2096 static void _vala_array_free (gpointer array, gint array_length, GDestroyNotify destroy_func) {
2097         _vala_array_destroy (array, array_length, destroy_func);
2098         g_free (array);
2099 }
2100
2101
2102 static gint _vala_array_length (gpointer array) {
2103         int length;
2104         length = 0;
2105         if (array) {
2106                 while (((gpointer*) array)[length]) {
2107                         length++;
2108                 }
2109         }
2110         return length;
2111 }
2112
2113
2114 static int _vala_strcmp0 (const char * str1, const char * str2) {
2115         if (str1 == NULL) {
2116                 return -(str1 != str2);
2117         }
2118         if (str2 == NULL) {
2119                 return str1 != str2;
2120         }
2121         return strcmp (str1, str2);
2122 }
2123
2124
2125
2126