git.maemo.org Git - fillmore/blob - src/fillmore/fillmore/audio_project.c

   1 /* audio_project.c generated by valac, the Vala compiler
   2  * generated from audio_project.vala, do not modify */
   3
   4 /* Copyright 2009-2010 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 <marina.h>
  13 #include <stdlib.h>
  14 #include <string.h>
  15 #include <time.h>
  16 #include <gee.h>
  17 #include <glib/gstdio.h>
  18
  19
  20 #define MODEL_TYPE_RECORD_FETCHER_COMPLETION (model_record_fetcher_completion_get_type ())
  21 #define MODEL_RECORD_FETCHER_COMPLETION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_RECORD_FETCHER_COMPLETION, ModelRecordFetcherCompletion))
  22 #define MODEL_RECORD_FETCHER_COMPLETION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_RECORD_FETCHER_COMPLETION, ModelRecordFetcherCompletionClass))
  23 #define MODEL_IS_RECORD_FETCHER_COMPLETION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_RECORD_FETCHER_COMPLETION))
  24 #define MODEL_IS_RECORD_FETCHER_COMPLETION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_RECORD_FETCHER_COMPLETION))
  25 #define MODEL_RECORD_FETCHER_COMPLETION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_RECORD_FETCHER_COMPLETION, ModelRecordFetcherCompletionClass))
  26
  27 typedef struct _ModelRecordFetcherCompletion ModelRecordFetcherCompletion;
  28 typedef struct _ModelRecordFetcherCompletionClass ModelRecordFetcherCompletionClass;
  29 typedef struct _ModelRecordFetcherCompletionPrivate ModelRecordFetcherCompletionPrivate;
  30 #define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
  31 #define _g_free0(var) (var = (g_free (var), NULL))
  32
  33 #define MODEL_TYPE_AUDIO_PROJECT (model_audio_project_get_type ())
  34 #define MODEL_AUDIO_PROJECT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_AUDIO_PROJECT, ModelAudioProject))
  35 #define MODEL_AUDIO_PROJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_AUDIO_PROJECT, ModelAudioProjectClass))
  36 #define MODEL_IS_AUDIO_PROJECT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_AUDIO_PROJECT))
  37 #define MODEL_IS_AUDIO_PROJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_AUDIO_PROJECT))
  38 #define MODEL_AUDIO_PROJECT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_AUDIO_PROJECT, ModelAudioProjectClass))
  39
  40 typedef struct _ModelAudioProject ModelAudioProject;
  41 typedef struct _ModelAudioProjectClass ModelAudioProjectClass;
  42 typedef struct _ModelAudioProjectPrivate ModelAudioProjectPrivate;
  43 #define _g_regex_unref0(var) ((var == NULL) ? NULL : (var = (g_regex_unref (var), NULL)))
  44 #define _g_error_free0(var) ((var == NULL) ? NULL : (var = (g_error_free (var), NULL)))
  45 #define _model_fetcher_completion_unref0(var) ((var == NULL) ? NULL : (var = (model_fetcher_completion_unref (var), NULL)))
  46 #define _g_dir_close0(var) ((var == NULL) ? NULL : (var = (g_dir_close (var), NULL)))
  47
  48 struct _ModelRecordFetcherCompletion {
  49         ModelFetcherCompletion parent_instance;
  50         ModelRecordFetcherCompletionPrivate * priv;
  51 };
  52
  53 struct _ModelRecordFetcherCompletionClass {
  54         ModelFetcherCompletionClass parent_class;
  55 };
  56
  57 struct _ModelRecordFetcherCompletionPrivate {
  58         ModelTrack* track;
  59         ModelProject* project;
  60         gint64 position;
  61 };
  62
  63 struct _ModelAudioProject {
  64         ModelProject parent_instance;
  65         ModelAudioProjectPrivate * priv;
  66 };
  67
  68 struct _ModelAudioProjectClass {
  69         ModelProjectClass parent_class;
  70 };
  71
  72 struct _ModelAudioProjectPrivate {
  73         gboolean has_been_saved;
  74 };
  75
  76
  77 static gpointer model_record_fetcher_completion_parent_class = NULL;
  78 static gpointer model_audio_project_parent_class = NULL;
  79
  80 GType model_record_fetcher_completion_get_type (void);
  81 #define MODEL_RECORD_FETCHER_COMPLETION_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), MODEL_TYPE_RECORD_FETCHER_COMPLETION, ModelRecordFetcherCompletionPrivate))
  82 enum  {
  83         MODEL_RECORD_FETCHER_COMPLETION_DUMMY_PROPERTY
  84 };
  85 ModelRecordFetcherCompletion* model_record_fetcher_completion_new (ModelProject* project, ModelTrack* track, gint64 position);
  86 ModelRecordFetcherCompletion* model_record_fetcher_completion_construct (GType object_type, ModelProject* project, ModelTrack* track, gint64 position);
  87 static void model_record_fetcher_completion_real_complete (ModelFetcherCompletion* base, ModelFetcher* fetch);
  88 static void model_record_fetcher_completion_finalize (ModelFetcherCompletion* obj);
  89 GType model_audio_project_get_type (void);
  90 #define MODEL_AUDIO_PROJECT_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), MODEL_TYPE_AUDIO_PROJECT, ModelAudioProjectPrivate))
  91 enum  {
  92         MODEL_AUDIO_PROJECT_DUMMY_PROPERTY
  93 };
  94 static char* model_audio_project_generate_filename (ModelAudioProject* self);
  95 static void _view_media_engine_on_callback_pulse_view_media_engine_callback_pulse (ViewMediaEngine* _sender, gpointer self);
  96 void model_audio_project_on_record_completed (ModelAudioProject* self);
  97 static void _model_audio_project_on_record_completed_view_media_engine_record_completed (ViewMediaEngine* _sender, gpointer self);
  98 ModelAudioProject* model_audio_project_new (const char* filename, GError** error);
  99 ModelAudioProject* model_audio_project_construct (GType object_type, const char* filename, GError** error);
 100 static void model_audio_project_real_get_clip_time (ModelProject* base, ModelClipFile* f, TimeCode* result);
 101 static char* model_audio_project_real_get_project_file (ModelProject* base);
 102 #define RECORDER_NAME "Fillmore"
 103 static char* model_audio_project_real_get_app_name (ModelProject* base);
 104 static void model_audio_project_real_add_track (ModelProject* base, ModelTrack* track);
 105 void model_audio_project_record (ModelAudioProject* self, ModelAudioTrack* track);
 106 static void model_audio_project_real_load (ModelProject* base, const char* filename);
 107 static void model_audio_project_move_audio_files (ModelAudioProject* self, const char* filename);
 108 static void model_audio_project_real_save (ModelProject* base, const char* filename);
 109 static void model_audio_project_finalize (GObject* obj);
 110 static int _vala_strcmp0 (const char * str1, const char * str2);
 111
 112
 113
 114 static gpointer _g_object_ref0 (gpointer self) {
 115         return self ? g_object_ref (self) : NULL;
 116 }
 117
 118
 119 #line 15 "audio_project.vala"
 120 ModelRecordFetcherCompletion* model_record_fetcher_completion_construct (GType object_type, ModelProject* project, ModelTrack* track, gint64 position) {
 121 #line 122 "audio_project.c"
 122         ModelRecordFetcherCompletion* self;
 123         ModelTrack* _tmp0_;
 124         ModelProject* _tmp1_;
 125 #line 15 "audio_project.vala"
 126         g_return_val_if_fail (MODEL_IS_PROJECT (project), NULL);
 127 #line 15 "audio_project.vala"
 128         g_return_val_if_fail (MODEL_IS_TRACK (track), NULL);
 129 #line 16 "audio_project.vala"
 130         self = (ModelRecordFetcherCompletion*) model_fetcher_completion_construct (object_type);
 131 #line 17 "audio_project.vala"
 132         self->priv->track = (_tmp0_ = _g_object_ref0 (track), _g_object_unref0 (self->priv->track), _tmp0_);
 133 #line 18 "audio_project.vala"
 134         self->priv->project = (_tmp1_ = _g_object_ref0 (project), _g_object_unref0 (self->priv->project), _tmp1_);
 135 #line 19 "audio_project.vala"
 136         self->priv->position = position;
 137 #line 138 "audio_project.c"
 138         return self;
 139 }
 140
 141
 142 #line 15 "audio_project.vala"
 143 ModelRecordFetcherCompletion* model_record_fetcher_completion_new (ModelProject* project, ModelTrack* track, gint64 position) {
 144 #line 15 "audio_project.vala"
 145         return model_record_fetcher_completion_construct (MODEL_TYPE_RECORD_FETCHER_COMPLETION, project, track, position);
 146 #line 147 "audio_project.c"
 147 }
 148
 149
 150 #line 22 "audio_project.vala"
 151 static void model_record_fetcher_completion_real_complete (ModelFetcherCompletion* base, ModelFetcher* fetch) {
 152 #line 153 "audio_project.c"
 153         ModelRecordFetcherCompletion * self;
 154         char* _tmp0_;
 155         ModelClip* _tmp1_;
 156         ModelClip* the_clip;
 157         self = MODEL_RECORD_FETCHER_COMPLETION (base);
 158 #line 22 "audio_project.vala"
 159         g_return_if_fail (MODEL_IS_FETCHER (fetch));
 160 #line 23 "audio_project.vala"
 161         MODEL_FETCHER_COMPLETION_CLASS (model_record_fetcher_completion_parent_class)->complete (MODEL_FETCHER_COMPLETION (self), fetch);
 162 #line 24 "audio_project.vala"
 163         the_clip = (_tmp1_ = model_clip_new (fetch->clipfile, MODEL_MEDIA_TYPE_AUDIO, _tmp0_ = isolate_filename (fetch->clipfile->filename), (gint64) 0, (gint64) 0, model_clip_file_get_length (fetch->clipfile), FALSE), _g_free0 (_tmp0_), _tmp1_);
 164 #line 26 "audio_project.vala"
 165         model_undo_manager_start_transaction (self->priv->project->undo_manager, "Record");
 166 #line 27 "audio_project.vala"
 167         model_track_append_at_time (self->priv->track, the_clip, self->priv->position, TRUE);
 168 #line 28 "audio_project.vala"
 169         model_undo_manager_end_transaction (self->priv->project->undo_manager, "Record");
 170 #line 171 "audio_project.c"
 171         _g_object_unref0 (the_clip);
 172 }
 173
 174
 175 static void model_record_fetcher_completion_class_init (ModelRecordFetcherCompletionClass * klass) {
 176         model_record_fetcher_completion_parent_class = g_type_class_peek_parent (klass);
 177         MODEL_FETCHER_COMPLETION_CLASS (klass)->finalize = model_record_fetcher_completion_finalize;
 178         g_type_class_add_private (klass, sizeof (ModelRecordFetcherCompletionPrivate));
 179         MODEL_FETCHER_COMPLETION_CLASS (klass)->complete = model_record_fetcher_completion_real_complete;
 180 }
 181
 182
 183 static void model_record_fetcher_completion_instance_init (ModelRecordFetcherCompletion * self) {
 184         self->priv = MODEL_RECORD_FETCHER_COMPLETION_GET_PRIVATE (self);
 185 }
 186
 187
 188 static void model_record_fetcher_completion_finalize (ModelFetcherCompletion* obj) {
 189         ModelRecordFetcherCompletion * self;
 190         self = MODEL_RECORD_FETCHER_COMPLETION (obj);
 191         _g_object_unref0 (self->priv->track);
 192         _g_object_unref0 (self->priv->project);
 193         MODEL_FETCHER_COMPLETION_CLASS (model_record_fetcher_completion_parent_class)->finalize (obj);
 194 }
 195
 196
 197 GType model_record_fetcher_completion_get_type (void) {
 198         static volatile gsize model_record_fetcher_completion_type_id__volatile = 0;
 199         if (g_once_init_enter (&model_record_fetcher_completion_type_id__volatile)) {
 200                 static const GTypeInfo g_define_type_info = { sizeof (ModelRecordFetcherCompletionClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) model_record_fetcher_completion_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ModelRecordFetcherCompletion), 0, (GInstanceInitFunc) model_record_fetcher_completion_instance_init, NULL };
 201                 GType model_record_fetcher_completion_type_id;
 202                 model_record_fetcher_completion_type_id = g_type_register_static (MODEL_TYPE_FETCHER_COMPLETION, "ModelRecordFetcherCompletion", &g_define_type_info, 0);
 203                 g_once_init_leave (&model_record_fetcher_completion_type_id__volatile, model_record_fetcher_completion_type_id);
 204         }
 205         return model_record_fetcher_completion_type_id__volatile;
 206 }
 207
 208
 209 #line 75 "marina.vapi"
 210 static void _view_media_engine_on_callback_pulse_view_media_engine_callback_pulse (ViewMediaEngine* _sender, gpointer self) {
 211 #line 212 "audio_project.c"
 212         view_media_engine_on_callback_pulse (self);
 213 }
 214
 215
 216 #line 92 "audio_project.vala"
 217 static void _model_audio_project_on_record_completed_view_media_engine_record_completed (ViewMediaEngine* _sender, gpointer self) {
 218 #line 219 "audio_project.c"
 219         model_audio_project_on_record_completed (self);
 220 }
 221
 222
 223 #line 35 "audio_project.vala"
 224 ModelAudioProject* model_audio_project_construct (GType object_type, const char* filename, GError** error) {
 225 #line 226 "audio_project.c"
 226         ModelAudioProject * self;
 227 #line 36 "audio_project.vala"
 228         self = (ModelAudioProject*) model_project_construct (object_type, filename, FALSE, error);
 229 #line 38 "audio_project.vala"
 230         if (self != NULL) {
 231 #line 39 "audio_project.vala"
 232                 self->priv->has_been_saved = filename != NULL;
 233 #line 40 "audio_project.vala"
 234                 if (!self->priv->has_been_saved) {
 235 #line 236 "audio_project.c"
 236                         char* _tmp1_;
 237                         char* *_tmp0_;
 238 #line 41 "audio_project.vala"
 239                         _tmp0_ = &MODEL_PROJECT (self)->project_file;
 240 #line 41 "audio_project.vala"
 241                         (*_tmp0_) = (_tmp1_ = model_audio_project_generate_filename (self), _g_free0 ((*_tmp0_)), _tmp1_);
 242 #line 243 "audio_project.c"
 243                 }
 244 #line 43 "audio_project.vala"
 245                 g_signal_connect_object (MODEL_PROJECT (self)->media_engine, "callback-pulse", (GCallback) _view_media_engine_on_callback_pulse_view_media_engine_callback_pulse, MODEL_PROJECT (self)->media_engine, 0);
 246 #line 44 "audio_project.vala"
 247                 g_signal_connect_object (MODEL_PROJECT (self)->media_engine, "record-completed", (GCallback) _model_audio_project_on_record_completed_view_media_engine_record_completed, self, 0);
 248 #line 249 "audio_project.c"
 249         }
 250         return self;
 251 }
 252
 253
 254 #line 35 "audio_project.vala"
 255 ModelAudioProject* model_audio_project_new (const char* filename, GError** error) {
 256 #line 35 "audio_project.vala"
 257         return model_audio_project_construct (MODEL_TYPE_AUDIO_PROJECT, filename, error);
 258 #line 259 "audio_project.c"
 259 }
 260
 261
 262 #line 48 "audio_project.vala"
 263 static void model_audio_project_real_get_clip_time (ModelProject* base, ModelClipFile* f, TimeCode* result) {
 264 #line 265 "audio_project.c"
 265         ModelAudioProject * self;
 266         TimeCode _tmp0_ = {0};
 267         TimeCode t;
 268         self = MODEL_AUDIO_PROJECT (base);
 269 #line 48 "audio_project.vala"
 270         g_return_if_fail (MODEL_IS_CLIP_FILE (f));
 271 #line 49 "audio_project.vala"
 272         t = (_tmp0_);
 273 #line 51 "audio_project.vala"
 274         time_code_get_from_length (&t, model_clip_file_get_length (f));
 275 #line 276 "audio_project.c"
 276         *result = t;
 277 #line 52 "audio_project.vala"
 278         return;
 279 #line 280 "audio_project.c"
 280 }
 281
 282
 283 #line 55 "audio_project.vala"
 284 static char* model_audio_project_real_get_project_file (ModelProject* base) {
 285 #line 286 "audio_project.c"
 286         ModelAudioProject * self;
 287         char* result = NULL;
 288         self = MODEL_AUDIO_PROJECT (base);
 289 #line 56 "audio_project.vala"
 290         if (!self->priv->has_been_saved) {
 291 #line 292 "audio_project.c"
 292                 result = NULL;
 293 #line 57 "audio_project.vala"
 294                 return result;
 295 #line 296 "audio_project.c"
 296         } else {
 297                 result = MODEL_PROJECT_CLASS (model_audio_project_parent_class)->get_project_file (MODEL_PROJECT (self));
 298 #line 59 "audio_project.vala"
 299                 return result;
 300 #line 301 "audio_project.c"
 301         }
 302 }
 303
 304
 305 #line 2153 "glib-2.0.vapi"
 306 static void g_time_local (time_t time, struct tm* result) {
 307 #line 308 "audio_project.c"
 308         struct tm _result_ = {0};
 309 #line 2155 "glib-2.0.vapi"
 310         localtime_r (&time, &_result_);
 311 #line 312 "audio_project.c"
 312         *result = _result_;
 313 #line 2156 "glib-2.0.vapi"
 314         return;
 315 #line 316 "audio_project.c"
 316 }
 317
 318
 319 #line 2159 "glib-2.0.vapi"
 320 static char* g_time_to_string (struct tm *self) {
 321 #line 322 "audio_project.c"
 322         char* result = NULL;
 323         result = g_strdup_printf ("%04d-%02d-%02d %02d:%02d:%02d", (*self).tm_year + 1900, (*self).tm_mon + 1, (*self).tm_mday, (*self).tm_hour, (*self).tm_min, (*self).tm_sec);
 324 #line 2160 "glib-2.0.vapi"
 325         return result;
 326 #line 327 "audio_project.c"
 327 }
 328
 329
 330 #line 1148 "glib-2.0.vapi"
 331 static char* string_replace (const char* self, const char* old, const char* replacement) {
 332 #line 333 "audio_project.c"
 333         char* result = NULL;
 334         GError * _inner_error_;
 335 #line 1148 "glib-2.0.vapi"
 336         g_return_val_if_fail (self != NULL, NULL);
 337 #line 1148 "glib-2.0.vapi"
 338         g_return_val_if_fail (old != NULL, NULL);
 339 #line 1148 "glib-2.0.vapi"
 340         g_return_val_if_fail (replacement != NULL, NULL);
 341 #line 342 "audio_project.c"
 342         _inner_error_ = NULL;
 343         {
 344                 char* _tmp0_;
 345                 GRegex* _tmp1_;
 346                 GRegex* regex;
 347                 char* _tmp2_;
 348 #line 1150 "glib-2.0.vapi"
 349                 regex = (_tmp1_ = g_regex_new (_tmp0_ = g_regex_escape_string (old, -1), 0, 0, &_inner_error_), _g_free0 (_tmp0_), _tmp1_);
 350 #line 351 "audio_project.c"
 351                 if (_inner_error_ != NULL) {
 352                         if (_inner_error_->domain == G_REGEX_ERROR) {
 353                                 goto __catch0_g_regex_error;
 354                         }
 355                         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);
 356                         g_clear_error (&_inner_error_);
 357                         return NULL;
 358                 }
 359 #line 1151 "glib-2.0.vapi"
 360                 _tmp2_ = g_regex_replace_literal (regex, self, (gssize) (-1), 0, replacement, 0, &_inner_error_);
 361 #line 362 "audio_project.c"
 362                 if (_inner_error_ != NULL) {
 363                         _g_regex_unref0 (regex);
 364                         if (_inner_error_->domain == G_REGEX_ERROR) {
 365                                 goto __catch0_g_regex_error;
 366                         }
 367                         _g_regex_unref0 (regex);
 368                         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);
 369                         g_clear_error (&_inner_error_);
 370                         return NULL;
 371                 }
 372                 result = _tmp2_;
 373                 _g_regex_unref0 (regex);
 374 #line 1151 "glib-2.0.vapi"
 375                 return result;
 376 #line 377 "audio_project.c"
 377         }
 378         goto __finally0;
 379         __catch0_g_regex_error:
 380         {
 381                 GError * e;
 382                 e = _inner_error_;
 383                 _inner_error_ = NULL;
 384                 {
 385 #line 1153 "glib-2.0.vapi"
 386                         g_assert_not_reached ();
 387 #line 388 "audio_project.c"
 388                         _g_error_free0 (e);
 389                 }
 390         }
 391         __finally0:
 392         if (_inner_error_ != NULL) {
 393                 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);
 394                 g_clear_error (&_inner_error_);
 395                 return NULL;
 396         }
 397 }
 398
 399
 400 #line 63 "audio_project.vala"
 401 static char* model_audio_project_generate_filename (ModelAudioProject* self) {
 402 #line 403 "audio_project.c"
 403         char* result = NULL;
 404         struct tm _tmp0_ = {0};
 405         struct tm now;
 406         char* timestring;
 407         char* _tmp1_;
 408         char* pathname;
 409         char* filename;
 410 #line 63 "audio_project.vala"
 411         g_return_val_if_fail (MODEL_IS_AUDIO_PROJECT (self), NULL);
 412 #line 64 "audio_project.vala"
 413         now = (g_time_local (time (NULL), &_tmp0_), _tmp0_);
 414 #line 65 "audio_project.vala"
 415         timestring = g_time_to_string (&now);
 416 #line 66 "audio_project.vala"
 417         timestring = (_tmp1_ = string_replace (timestring, ":", "_"), _g_free0 (timestring), _tmp1_);
 418 #line 67 "audio_project.vala"
 419         pathname = g_build_filename (g_get_home_dir (), ".fillmore", timestring, NULL);
 420 #line 69 "audio_project.vala"
 421         g_mkdir (pathname, 0777);
 422 #line 70 "audio_project.vala"
 423         filename = g_strdup_printf ("%s.%s", timestring, "fill");
 424 #line 425 "audio_project.c"
 425         result = g_build_filename (pathname, filename, NULL);
 426         _g_free0 (timestring);
 427         _g_free0 (pathname);
 428         _g_free0 (filename);
 429 #line 71 "audio_project.vala"
 430         return result;
 431 #line 432 "audio_project.c"
 432 }
 433
 434
 435 #line 74 "audio_project.vala"
 436 static char* model_audio_project_real_get_app_name (ModelProject* base) {
 437 #line 438 "audio_project.c"
 438         ModelAudioProject * self;
 439         char* result = NULL;
 440         self = MODEL_AUDIO_PROJECT (base);
 441         result = g_strdup (RECORDER_NAME);
 442 #line 75 "audio_project.vala"
 443         return result;
 444 #line 445 "audio_project.c"
 445 }
 446
 447
 448 #line 78 "audio_project.vala"
 449 static void model_audio_project_real_add_track (ModelProject* base, ModelTrack* track) {
 450 #line 451 "audio_project.c"
 451         ModelAudioProject * self;
 452         self = MODEL_AUDIO_PROJECT (base);
 453 #line 78 "audio_project.vala"
 454         g_return_if_fail (MODEL_IS_TRACK (track));
 455 #line 79 "audio_project.vala"
 456         if (model_track_media_type (track) == MODEL_MEDIA_TYPE_VIDEO) {
 457 #line 80 "audio_project.vala"
 458                 model_track_hide (track);
 459 #line 81 "audio_project.vala"
 460                 gee_abstract_collection_add (GEE_ABSTRACT_COLLECTION (MODEL_PROJECT (self)->inactive_tracks), track);
 461 #line 82 "audio_project.vala"
 462                 return;
 463 #line 464 "audio_project.c"
 464         }
 465 #line 85 "audio_project.vala"
 466         MODEL_PROJECT_CLASS (model_audio_project_parent_class)->add_track (MODEL_PROJECT (self), track);
 467 #line 468 "audio_project.c"
 468 }
 469
 470
 471 #line 88 "audio_project.vala"
 472 void model_audio_project_record (ModelAudioProject* self, ModelAudioTrack* track) {
 473 #line 88 "audio_project.vala"
 474         g_return_if_fail (MODEL_IS_AUDIO_PROJECT (self));
 475 #line 88 "audio_project.vala"
 476         g_return_if_fail (MODEL_IS_AUDIO_TRACK (track));
 477 #line 89 "audio_project.vala"
 478         view_media_engine_record (MODEL_PROJECT (self)->media_engine, track);
 479 #line 480 "audio_project.c"
 480 }
 481
 482
 483 #line 92 "audio_project.vala"
 484 void model_audio_project_on_record_completed (ModelAudioProject* self) {
 485 #line 486 "audio_project.c"
 486         GError * _inner_error_;
 487 #line 92 "audio_project.vala"
 488         g_return_if_fail (MODEL_IS_AUDIO_PROJECT (self));
 489 #line 490 "audio_project.c"
 490         _inner_error_ = NULL;
 491 #line 93 "audio_project.vala"
 492         logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_record_completed");
 493 #line 494 "audio_project.c"
 494         {
 495                 ModelRecordFetcherCompletion* _tmp0_;
 496 #line 95 "audio_project.vala"
 497                 model_project_create_clip_fetcher (MODEL_PROJECT (self), MODEL_FETCHER_COMPLETION (_tmp0_ = model_record_fetcher_completion_new (MODEL_PROJECT (self), MODEL_TRACK (MODEL_PROJECT (self)->media_engine->record_track), model_clip_get_start (MODEL_PROJECT (self)->media_engine->record_region))), MODEL_PROJECT (self)->media_engine->record_region->clipfile->filename, &_inner_error_);
 498 #line 499 "audio_project.c"
 499                 _model_fetcher_completion_unref0 (_tmp0_);
 500                 if (_inner_error_ != NULL) {
 501                         goto __catch1_g_error;
 502                 }
 503         }
 504         goto __finally1;
 505         __catch1_g_error:
 506         {
 507                 GError * e;
 508                 e = _inner_error_;
 509                 _inner_error_ = NULL;
 510                 {
 511 #line 98 "audio_project.vala"
 512                         g_signal_emit_by_name (MODEL_PROJECT (self), "error-occurred", "Could not complete recording", e->message);
 513 #line 514 "audio_project.c"
 514                         _g_error_free0 (e);
 515                 }
 516         }
 517         __finally1:
 518         if (_inner_error_ != NULL) {
 519                 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);
 520                 g_clear_error (&_inner_error_);
 521                 return;
 522         }
 523 }
 524
 525
 526 #line 102 "audio_project.vala"
 527 static void model_audio_project_real_load (ModelProject* base, const char* filename) {
 528 #line 529 "audio_project.c"
 529         ModelAudioProject * self;
 530         self = MODEL_AUDIO_PROJECT (base);
 531 #line 103 "audio_project.vala"
 532         self->priv->has_been_saved = filename != NULL;
 533 #line 104 "audio_project.vala"
 534         if (!self->priv->has_been_saved) {
 535 #line 536 "audio_project.c"
 536                 char* _tmp1_;
 537                 char* *_tmp0_;
 538 #line 105 "audio_project.vala"
 539                 _tmp0_ = &MODEL_PROJECT (self)->project_file;
 540 #line 105 "audio_project.vala"
 541                 (*_tmp0_) = (_tmp1_ = model_audio_project_generate_filename (self), _g_free0 ((*_tmp0_)), _tmp1_);
 542 #line 543 "audio_project.c"
 543         }
 544 #line 107 "audio_project.vala"
 545         MODEL_PROJECT_CLASS (model_audio_project_parent_class)->load (MODEL_PROJECT (self), filename);
 546 #line 547 "audio_project.c"
 547 }
 548
 549
 550 #line 110 "audio_project.vala"
 551 static void model_audio_project_real_save (ModelProject* base, const char* filename) {
 552 #line 553 "audio_project.c"
 553         ModelAudioProject * self;
 554         gboolean _tmp0_ = FALSE;
 555         self = MODEL_AUDIO_PROJECT (base);
 556 #line 111 "audio_project.vala"
 557         if (!self->priv->has_been_saved) {
 558 #line 111 "audio_project.vala"
 559                 _tmp0_ = filename != NULL;
 560 #line 561 "audio_project.c"
 561         } else {
 562 #line 111 "audio_project.vala"
 563                 _tmp0_ = FALSE;
 564 #line 565 "audio_project.c"
 565         }
 566 #line 111 "audio_project.vala"
 567         if (_tmp0_) {
 568 #line 569 "audio_project.c"
 569                 char* _tmp1_;
 570 #line 112 "audio_project.vala"
 571                 model_audio_project_move_audio_files (self, filename);
 572 #line 113 "audio_project.vala"
 573                 g_remove (MODEL_PROJECT (self)->project_file);
 574 #line 114 "audio_project.vala"
 575                 g_rmdir (_tmp1_ = g_path_get_dirname (MODEL_PROJECT (self)->project_file));
 576 #line 577 "audio_project.c"
 577                 _g_free0 (_tmp1_);
 578         }
 579 #line 117 "audio_project.vala"
 580         MODEL_PROJECT_CLASS (model_audio_project_parent_class)->save (MODEL_PROJECT (self), filename);
 581 #line 118 "audio_project.vala"
 582         self->priv->has_been_saved = TRUE;
 583 #line 584 "audio_project.c"
 584 }
 585
 586
 587 #line 121 "audio_project.vala"
 588 static void model_audio_project_move_audio_files (ModelAudioProject* self, const char* filename) {
 589 #line 590 "audio_project.c"
 590         GError * _inner_error_;
 591         char* audio_path;
 592         char* _tmp0_;
 593         char* _tmp1_;
 594         char* destination_path;
 595         GDir* dir;
 596         const char* base_name;
 597 #line 121 "audio_project.vala"
 598         g_return_if_fail (MODEL_IS_AUDIO_PROJECT (self));
 599 #line 121 "audio_project.vala"
 600         g_return_if_fail (filename != NULL);
 601 #line 602 "audio_project.c"
 602         _inner_error_ = NULL;
 603 #line 122 "audio_project.vala"
 604         audio_path = model_project_get_audio_path (MODEL_PROJECT (self));
 605 #line 123 "audio_project.vala"
 606         destination_path = (_tmp1_ = g_build_filename (_tmp0_ = g_path_get_dirname (filename), "audio files", NULL), _g_free0 (_tmp0_), _tmp1_);
 607 #line 124 "audio_project.vala"
 608         g_mkdir (destination_path, 0777);
 609 #line 610 "audio_project.c"
 610         dir = NULL;
 611         {
 612                 GDir* _tmp2_;
 613                 GDir* _tmp3_;
 614 #line 127 "audio_project.vala"
 615                 _tmp2_ = g_dir_open (audio_path, 0, &_inner_error_);
 616 #line 617 "audio_project.c"
 617                 if (_inner_error_ != NULL) {
 618                         if (_inner_error_->domain == G_FILE_ERROR) {
 619                                 goto __catch2_g_file_error;
 620                         }
 621                         _g_free0 (audio_path);
 622                         _g_free0 (destination_path);
 623                         _g_dir_close0 (dir);
 624                         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);
 625                         g_clear_error (&_inner_error_);
 626                         return;
 627                 }
 628 #line 127 "audio_project.vala"
 629                 dir = (_tmp3_ = _tmp2_, _g_dir_close0 (dir), _tmp3_);
 630 #line 631 "audio_project.c"
 631         }
 632         goto __finally2;
 633         __catch2_g_file_error:
 634         {
 635                 GError * e;
 636                 e = _inner_error_;
 637                 _inner_error_ = NULL;
 638                 {
 639                         _g_error_free0 (e);
 640                         _g_free0 (audio_path);
 641                         _g_free0 (destination_path);
 642                         _g_dir_close0 (dir);
 643 #line 129 "audio_project.vala"
 644                         return;
 645 #line 646 "audio_project.c"
 646                 }
 647         }
 648         __finally2:
 649         if (_inner_error_ != NULL) {
 650                 _g_free0 (audio_path);
 651                 _g_free0 (destination_path);
 652                 _g_dir_close0 (dir);
 653                 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);
 654                 g_clear_error (&_inner_error_);
 655                 return;
 656         }
 657 #line 133 "audio_project.vala"
 658         base_name = NULL;
 659 #line 660 "audio_project.c"
 660         {
 661                 gboolean _tmp4_;
 662 #line 134 "audio_project.vala"
 663                 _tmp4_ = TRUE;
 664 #line 134 "audio_project.vala"
 665                 while (TRUE) {
 666 #line 667 "audio_project.c"
 667                         char* destination;
 668                         char* _tmp5_;
 669 #line 134 "audio_project.vala"
 670                         if (!_tmp4_) {
 671 #line 138 "audio_project.vala"
 672                                 if (!(base_name != NULL)) {
 673 #line 138 "audio_project.vala"
 674                                         break;
 675 #line 676 "audio_project.c"
 676                                 }
 677                         }
 678 #line 134 "audio_project.vala"
 679                         _tmp4_ = FALSE;
 680 #line 135 "audio_project.vala"
 681                         base_name = g_dir_read_name (dir);
 682 #line 136 "audio_project.vala"
 683                         destination = g_build_filename (destination_path, base_name, NULL);
 684 #line 137 "audio_project.vala"
 685                         g_rename (_tmp5_ = g_build_filename (audio_path, base_name, NULL), destination);
 686 #line 687 "audio_project.c"
 687                         _g_free0 (_tmp5_);
 688                         _g_free0 (destination);
 689                 }
 690         }
 691         {
 692                 GeeIterator* _clip_file_it;
 693                 _clip_file_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (MODEL_PROJECT (self)->clipfiles));
 694 #line 141 "audio_project.vala"
 695                 while (TRUE) {
 696 #line 697 "audio_project.c"
 697                         ModelClipFile* clip_file;
 698                         char* _tmp6_;
 699                         gboolean _tmp7_;
 700 #line 141 "audio_project.vala"
 701                         if (!gee_iterator_next (_clip_file_it)) {
 702 #line 141 "audio_project.vala"
 703                                 break;
 704 #line 705 "audio_project.c"
 705                         }
 706 #line 141 "audio_project.vala"
 707                         clip_file = (ModelClipFile*) gee_iterator_get (_clip_file_it);
 708 #line 142 "audio_project.vala"
 709                         if ((_tmp7_ = _vala_strcmp0 (_tmp6_ = g_path_get_dirname (clip_file->filename), audio_path) == 0, _g_free0 (_tmp6_), _tmp7_)) {
 710 #line 711 "audio_project.c"
 711                                 char* file_name;
 712                                 char* destination;
 713                                 char* _tmp8_;
 714 #line 143 "audio_project.vala"
 715                                 file_name = g_path_get_basename (clip_file->filename);
 716 #line 144 "audio_project.vala"
 717                                 destination = g_build_filename (destination_path, file_name, NULL);
 718 #line 145 "audio_project.vala"
 719                                 clip_file->filename = (_tmp8_ = g_strdup (destination), _g_free0 (clip_file->filename), _tmp8_);
 720 #line 721 "audio_project.c"
 721                                 _g_free0 (file_name);
 722                                 _g_free0 (destination);
 723                         }
 724                         _g_object_unref0 (clip_file);
 725                 }
 726                 _g_object_unref0 (_clip_file_it);
 727         }
 728 #line 149 "audio_project.vala"
 729         g_rmdir (audio_path);
 730 #line 731 "audio_project.c"
 731         _g_free0 (audio_path);
 732         _g_free0 (destination_path);
 733         _g_dir_close0 (dir);
 734 }
 735
 736
 737 static void model_audio_project_class_init (ModelAudioProjectClass * klass) {
 738         model_audio_project_parent_class = g_type_class_peek_parent (klass);
 739         g_type_class_add_private (klass, sizeof (ModelAudioProjectPrivate));
 740         MODEL_PROJECT_CLASS (klass)->get_clip_time = model_audio_project_real_get_clip_time;
 741         MODEL_PROJECT_CLASS (klass)->get_project_file = model_audio_project_real_get_project_file;
 742         MODEL_PROJECT_CLASS (klass)->get_app_name = model_audio_project_real_get_app_name;
 743         MODEL_PROJECT_CLASS (klass)->add_track = model_audio_project_real_add_track;
 744         MODEL_PROJECT_CLASS (klass)->load = model_audio_project_real_load;
 745         MODEL_PROJECT_CLASS (klass)->save = model_audio_project_real_save;
 746         G_OBJECT_CLASS (klass)->finalize = model_audio_project_finalize;
 747 }
 748
 749
 750 static void model_audio_project_instance_init (ModelAudioProject * self) {
 751         self->priv = MODEL_AUDIO_PROJECT_GET_PRIVATE (self);
 752 }
 753
 754
 755 static void model_audio_project_finalize (GObject* obj) {
 756         ModelAudioProject * self;
 757         self = MODEL_AUDIO_PROJECT (obj);
 758         G_OBJECT_CLASS (model_audio_project_parent_class)->finalize (obj);
 759 }
 760
 761
 762 GType model_audio_project_get_type (void) {
 763         static volatile gsize model_audio_project_type_id__volatile = 0;
 764         if (g_once_init_enter (&model_audio_project_type_id__volatile)) {
 765                 static const GTypeInfo g_define_type_info = { sizeof (ModelAudioProjectClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) model_audio_project_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ModelAudioProject), 0, (GInstanceInitFunc) model_audio_project_instance_init, NULL };
 766                 GType model_audio_project_type_id;
 767                 model_audio_project_type_id = g_type_register_static (MODEL_TYPE_PROJECT, "ModelAudioProject", &g_define_type_info, 0);
 768                 g_once_init_leave (&model_audio_project_type_id__volatile, model_audio_project_type_id);
 769         }
 770         return model_audio_project_type_id__volatile;
 771 }
 772
 773
 774 static int _vala_strcmp0 (const char * str1, const char * str2) {
 775         if (str1 == NULL) {
 776                 return -(str1 != str2);
 777         }
 778         if (str2 == NULL) {
 779                 return str1 != str2;
 780         }
 781         return strcmp (str1, str2);
 782 }
 783
 784
 785
 786