git.maemo.org Git - fillmore/blob - src/marina/marina/project.c

   1 /* project.c generated by valac, the Vala compiler
   2  * generated from 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 <stdlib.h>
  13 #include <string.h>
  14 #include <gee.h>
  15 #include <float.h>
  16 #include <math.h>
  17 #include <gst/gst.h>
  18 #include <gdk-pixbuf/gdk-pixdata.h>
  19 #include <stdio.h>
  20 #include <gdk/gdk.h>
  21 #include <errno.h>
  22 #include <gtk/gtk.h>
  23
  24
  25 #define MODEL_TYPE_LOADER_HANDLER (model_loader_handler_get_type ())
  26 #define MODEL_LOADER_HANDLER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_LOADER_HANDLER, ModelLoaderHandler))
  27 #define MODEL_LOADER_HANDLER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_LOADER_HANDLER, ModelLoaderHandlerClass))
  28 #define MODEL_IS_LOADER_HANDLER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_LOADER_HANDLER))
  29 #define MODEL_IS_LOADER_HANDLER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_LOADER_HANDLER))
  30 #define MODEL_LOADER_HANDLER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_LOADER_HANDLER, ModelLoaderHandlerClass))
  31
  32 typedef struct _ModelLoaderHandler ModelLoaderHandler;
  33 typedef struct _ModelLoaderHandlerClass ModelLoaderHandlerClass;
  34 typedef struct _ModelLoaderHandlerPrivate ModelLoaderHandlerPrivate;
  35
  36 #define MODEL_TYPE_MEDIA_LOADER_HANDLER (model_media_loader_handler_get_type ())
  37 #define MODEL_MEDIA_LOADER_HANDLER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_MEDIA_LOADER_HANDLER, ModelMediaLoaderHandler))
  38 #define MODEL_MEDIA_LOADER_HANDLER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_MEDIA_LOADER_HANDLER, ModelMediaLoaderHandlerClass))
  39 #define MODEL_IS_MEDIA_LOADER_HANDLER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_MEDIA_LOADER_HANDLER))
  40 #define MODEL_IS_MEDIA_LOADER_HANDLER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_MEDIA_LOADER_HANDLER))
  41 #define MODEL_MEDIA_LOADER_HANDLER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_MEDIA_LOADER_HANDLER, ModelMediaLoaderHandlerClass))
  42
  43 typedef struct _ModelMediaLoaderHandler ModelMediaLoaderHandler;
  44 typedef struct _ModelMediaLoaderHandlerClass ModelMediaLoaderHandlerClass;
  45 typedef struct _ModelMediaLoaderHandlerPrivate ModelMediaLoaderHandlerPrivate;
  46
  47 #define MODEL_TYPE_PROJECT (model_project_get_type ())
  48 #define MODEL_PROJECT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_PROJECT, ModelProject))
  49 #define MODEL_PROJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_PROJECT, ModelProjectClass))
  50 #define MODEL_IS_PROJECT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_PROJECT))
  51 #define MODEL_IS_PROJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_PROJECT))
  52 #define MODEL_PROJECT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_PROJECT, ModelProjectClass))
  53
  54 typedef struct _ModelProject ModelProject;
  55 typedef struct _ModelProjectClass ModelProjectClass;
  56
  57 #define MODEL_TYPE_TRACK (model_track_get_type ())
  58 #define MODEL_TRACK(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_TRACK, ModelTrack))
  59 #define MODEL_TRACK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_TRACK, ModelTrackClass))
  60 #define MODEL_IS_TRACK(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_TRACK))
  61 #define MODEL_IS_TRACK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_TRACK))
  62 #define MODEL_TRACK_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_TRACK, ModelTrackClass))
  63
  64 typedef struct _ModelTrack ModelTrack;
  65 typedef struct _ModelTrackClass ModelTrackClass;
  66
  67 #define MODEL_TYPE_FETCHER (model_fetcher_get_type ())
  68 #define MODEL_FETCHER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_FETCHER, ModelFetcher))
  69 #define MODEL_FETCHER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_FETCHER, ModelFetcherClass))
  70 #define MODEL_IS_FETCHER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_FETCHER))
  71 #define MODEL_IS_FETCHER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_FETCHER))
  72 #define MODEL_FETCHER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_FETCHER, ModelFetcherClass))
  73
  74 typedef struct _ModelFetcher ModelFetcher;
  75 typedef struct _ModelFetcherClass ModelFetcherClass;
  76
  77 #define MODEL_TYPE_CLIP_FETCHER (model_clip_fetcher_get_type ())
  78 #define MODEL_CLIP_FETCHER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_CLIP_FETCHER, ModelClipFetcher))
  79 #define MODEL_CLIP_FETCHER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_CLIP_FETCHER, ModelClipFetcherClass))
  80 #define MODEL_IS_CLIP_FETCHER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_CLIP_FETCHER))
  81 #define MODEL_IS_CLIP_FETCHER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_CLIP_FETCHER))
  82 #define MODEL_CLIP_FETCHER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_CLIP_FETCHER, ModelClipFetcherClass))
  83
  84 typedef struct _ModelClipFetcher ModelClipFetcher;
  85 typedef struct _ModelClipFetcherClass ModelClipFetcherClass;
  86 #define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
  87 #define _g_free0(var) (var = (g_free (var), NULL))
  88
  89 #define TYPE_FRACTION (fraction_get_type ())
  90 typedef struct _Fraction Fraction;
  91
  92 #define MODEL_TYPE_AUDIO_TRACK (model_audio_track_get_type ())
  93 #define MODEL_AUDIO_TRACK(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_AUDIO_TRACK, ModelAudioTrack))
  94 #define MODEL_AUDIO_TRACK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_AUDIO_TRACK, ModelAudioTrackClass))
  95 #define MODEL_IS_AUDIO_TRACK(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_AUDIO_TRACK))
  96 #define MODEL_IS_AUDIO_TRACK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_AUDIO_TRACK))
  97 #define MODEL_AUDIO_TRACK_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_AUDIO_TRACK, ModelAudioTrackClass))
  98
  99 typedef struct _ModelAudioTrack ModelAudioTrack;
 100 typedef struct _ModelAudioTrackClass ModelAudioTrackClass;
 101
 102 #define MODEL_TYPE_VIDEO_TRACK (model_video_track_get_type ())
 103 #define MODEL_VIDEO_TRACK(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_VIDEO_TRACK, ModelVideoTrack))
 104 #define MODEL_VIDEO_TRACK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_VIDEO_TRACK, ModelVideoTrackClass))
 105 #define MODEL_IS_VIDEO_TRACK(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_VIDEO_TRACK))
 106 #define MODEL_IS_VIDEO_TRACK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_VIDEO_TRACK))
 107 #define MODEL_VIDEO_TRACK_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_VIDEO_TRACK, ModelVideoTrackClass))
 108
 109 typedef struct _ModelVideoTrack ModelVideoTrack;
 110 typedef struct _ModelVideoTrackClass ModelVideoTrackClass;
 111 typedef struct _ModelFetcherPrivate ModelFetcherPrivate;
 112
 113 #define MODEL_TYPE_CLIP_FILE (model_clip_file_get_type ())
 114 #define MODEL_CLIP_FILE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_CLIP_FILE, ModelClipFile))
 115 #define MODEL_CLIP_FILE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_CLIP_FILE, ModelClipFileClass))
 116 #define MODEL_IS_CLIP_FILE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_CLIP_FILE))
 117 #define MODEL_IS_CLIP_FILE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_CLIP_FILE))
 118 #define MODEL_CLIP_FILE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_CLIP_FILE, ModelClipFileClass))
 119
 120 typedef struct _ModelClipFile ModelClipFile;
 121 typedef struct _ModelClipFileClass ModelClipFileClass;
 122
 123 #define MODEL_TYPE_MEDIA_TYPE (model_media_type_get_type ())
 124
 125 #define MODEL_TYPE_CLIP (model_clip_get_type ())
 126 #define MODEL_CLIP(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_CLIP, ModelClip))
 127 #define MODEL_CLIP_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_CLIP, ModelClipClass))
 128 #define MODEL_IS_CLIP(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_CLIP))
 129 #define MODEL_IS_CLIP_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_CLIP))
 130 #define MODEL_CLIP_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_CLIP, ModelClipClass))
 131
 132 typedef struct _ModelClip ModelClip;
 133 typedef struct _ModelClipClass ModelClipClass;
 134
 135 #define LOGGING_TYPE_FACILITY (logging_facility_get_type ())
 136
 137 #define LOGGING_TYPE_LEVEL (logging_level_get_type ())
 138 typedef struct _ModelClipFilePrivate ModelClipFilePrivate;
 139 #define _g_error_free0(var) ((var == NULL) ? NULL : (var = (g_error_free (var), NULL)))
 140
 141 #define MODEL_TYPE_TEMPO_INFORMATION (model_tempo_information_get_type ())
 142 #define MODEL_TEMPO_INFORMATION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_TEMPO_INFORMATION, ModelTempoInformation))
 143 #define MODEL_IS_TEMPO_INFORMATION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_TEMPO_INFORMATION))
 144 #define MODEL_TEMPO_INFORMATION_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), MODEL_TYPE_TEMPO_INFORMATION, ModelTempoInformationIface))
 145
 146 typedef struct _ModelTempoInformation ModelTempoInformation;
 147 typedef struct _ModelTempoInformationIface ModelTempoInformationIface;
 148 typedef struct _ModelProjectPrivate ModelProjectPrivate;
 149
 150 #define TYPE_TIME_CODE (time_code_get_type ())
 151 typedef struct _TimeCode TimeCode;
 152
 153 #define VIEW_TYPE_MEDIA_ENGINE (view_media_engine_get_type ())
 154 #define VIEW_MEDIA_ENGINE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VIEW_TYPE_MEDIA_ENGINE, ViewMediaEngine))
 155 #define VIEW_MEDIA_ENGINE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VIEW_TYPE_MEDIA_ENGINE, ViewMediaEngineClass))
 156 #define VIEW_IS_MEDIA_ENGINE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VIEW_TYPE_MEDIA_ENGINE))
 157 #define VIEW_IS_MEDIA_ENGINE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VIEW_TYPE_MEDIA_ENGINE))
 158 #define VIEW_MEDIA_ENGINE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VIEW_TYPE_MEDIA_ENGINE, ViewMediaEngineClass))
 159
 160 typedef struct _ViewMediaEngine ViewMediaEngine;
 161 typedef struct _ViewMediaEngineClass ViewMediaEngineClass;
 162
 163 #define MODEL_TYPE_PROJECT_LOADER (model_project_loader_get_type ())
 164 #define MODEL_PROJECT_LOADER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_PROJECT_LOADER, ModelProjectLoader))
 165 #define MODEL_PROJECT_LOADER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_PROJECT_LOADER, ModelProjectLoaderClass))
 166 #define MODEL_IS_PROJECT_LOADER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_PROJECT_LOADER))
 167 #define MODEL_IS_PROJECT_LOADER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_PROJECT_LOADER))
 168 #define MODEL_PROJECT_LOADER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_PROJECT_LOADER, ModelProjectLoaderClass))
 169
 170 typedef struct _ModelProjectLoader ModelProjectLoader;
 171 typedef struct _ModelProjectLoaderClass ModelProjectLoaderClass;
 172
 173 #define MODEL_TYPE_UNDO_MANAGER (model_undo_manager_get_type ())
 174 #define MODEL_UNDO_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_UNDO_MANAGER, ModelUndoManager))
 175 #define MODEL_UNDO_MANAGER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_UNDO_MANAGER, ModelUndoManagerClass))
 176 #define MODEL_IS_UNDO_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_UNDO_MANAGER))
 177 #define MODEL_IS_UNDO_MANAGER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_UNDO_MANAGER))
 178 #define MODEL_UNDO_MANAGER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_UNDO_MANAGER, ModelUndoManagerClass))
 179
 180 typedef struct _ModelUndoManager ModelUndoManager;
 181 typedef struct _ModelUndoManagerClass ModelUndoManagerClass;
 182
 183 #define MODEL_TYPE_LIBRARY_IMPORTER (model_library_importer_get_type ())
 184 #define MODEL_LIBRARY_IMPORTER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_LIBRARY_IMPORTER, ModelLibraryImporter))
 185 #define MODEL_LIBRARY_IMPORTER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_LIBRARY_IMPORTER, ModelLibraryImporterClass))
 186 #define MODEL_IS_LIBRARY_IMPORTER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_LIBRARY_IMPORTER))
 187 #define MODEL_IS_LIBRARY_IMPORTER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_LIBRARY_IMPORTER))
 188 #define MODEL_LIBRARY_IMPORTER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_LIBRARY_IMPORTER, ModelLibraryImporterClass))
 189
 190 typedef struct _ModelLibraryImporter ModelLibraryImporter;
 191 typedef struct _ModelLibraryImporterClass ModelLibraryImporterClass;
 192
 193 #define MODEL_TYPE_THUMBNAIL_FETCHER (model_thumbnail_fetcher_get_type ())
 194 #define MODEL_THUMBNAIL_FETCHER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_THUMBNAIL_FETCHER, ModelThumbnailFetcher))
 195 #define MODEL_THUMBNAIL_FETCHER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_THUMBNAIL_FETCHER, ModelThumbnailFetcherClass))
 196 #define MODEL_IS_THUMBNAIL_FETCHER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_THUMBNAIL_FETCHER))
 197 #define MODEL_IS_THUMBNAIL_FETCHER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_THUMBNAIL_FETCHER))
 198 #define MODEL_THUMBNAIL_FETCHER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_THUMBNAIL_FETCHER, ModelThumbnailFetcherClass))
 199
 200 typedef struct _ModelThumbnailFetcher ModelThumbnailFetcher;
 201 typedef struct _ModelThumbnailFetcherClass ModelThumbnailFetcherClass;
 202
 203 #define MODEL_TYPE_FETCHER_COMPLETION (model_fetcher_completion_get_type ())
 204 #define MODEL_FETCHER_COMPLETION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_FETCHER_COMPLETION, ModelFetcherCompletion))
 205 #define MODEL_FETCHER_COMPLETION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_FETCHER_COMPLETION, ModelFetcherCompletionClass))
 206 #define MODEL_IS_FETCHER_COMPLETION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_FETCHER_COMPLETION))
 207 #define MODEL_IS_FETCHER_COMPLETION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_FETCHER_COMPLETION))
 208 #define MODEL_FETCHER_COMPLETION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_FETCHER_COMPLETION, ModelFetcherCompletionClass))
 209
 210 typedef struct _ModelFetcherCompletion ModelFetcherCompletion;
 211 typedef struct _ModelFetcherCompletionClass ModelFetcherCompletionClass;
 212 #define _model_fetcher_completion_unref0(var) ((var == NULL) ? NULL : (var = (model_fetcher_completion_unref (var), NULL)))
 213 #define _model_undo_manager_unref0(var) ((var == NULL) ? NULL : (var = (model_undo_manager_unref (var), NULL)))
 214
 215 #define TYPE_PLAY_STATE (play_state_get_type ())
 216 typedef struct _ModelTrackPrivate ModelTrackPrivate;
 217
 218 #define MODEL_TYPE_GAP (model_gap_get_type ())
 219 #define MODEL_GAP(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_GAP, ModelGap))
 220 #define MODEL_GAP_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_GAP, ModelGapClass))
 221 #define MODEL_IS_GAP(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_GAP))
 222 #define MODEL_IS_GAP_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_GAP))
 223 #define MODEL_GAP_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_GAP, ModelGapClass))
 224
 225 typedef struct _ModelGap ModelGap;
 226 typedef struct _ModelGapClass ModelGapClass;
 227 typedef struct _ModelGapPrivate ModelGapPrivate;
 228 #define _model_gap_unref0(var) ((var == NULL) ? NULL : (var = (model_gap_unref (var), NULL)))
 229
 230 #define TYPE_MULTI_FILE_PROGRESS_INTERFACE (multi_file_progress_interface_get_type ())
 231 #define MULTI_FILE_PROGRESS_INTERFACE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_MULTI_FILE_PROGRESS_INTERFACE, MultiFileProgressInterface))
 232 #define IS_MULTI_FILE_PROGRESS_INTERFACE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_MULTI_FILE_PROGRESS_INTERFACE))
 233 #define MULTI_FILE_PROGRESS_INTERFACE_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), TYPE_MULTI_FILE_PROGRESS_INTERFACE, MultiFileProgressInterfaceIface))
 234
 235 typedef struct _MultiFileProgressInterface MultiFileProgressInterface;
 236 typedef struct _MultiFileProgressInterfaceIface MultiFileProgressInterfaceIface;
 237 typedef struct _ViewMediaEnginePrivate ViewMediaEnginePrivate;
 238
 239 #define MODEL_TYPE_COMMAND (model_command_get_type ())
 240 #define MODEL_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_COMMAND, ModelCommand))
 241 #define MODEL_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_COMMAND, ModelCommandClass))
 242 #define MODEL_IS_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_COMMAND))
 243 #define MODEL_IS_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_COMMAND))
 244 #define MODEL_COMMAND_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_COMMAND, ModelCommandClass))
 245
 246 typedef struct _ModelCommand ModelCommand;
 247 typedef struct _ModelCommandClass ModelCommandClass;
 248
 249 #define MODEL_TYPE_ADD_CLIP_COMMAND (model_add_clip_command_get_type ())
 250 #define MODEL_ADD_CLIP_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_ADD_CLIP_COMMAND, ModelAddClipCommand))
 251 #define MODEL_ADD_CLIP_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_ADD_CLIP_COMMAND, ModelAddClipCommandClass))
 252 #define MODEL_IS_ADD_CLIP_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_ADD_CLIP_COMMAND))
 253 #define MODEL_IS_ADD_CLIP_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_ADD_CLIP_COMMAND))
 254 #define MODEL_ADD_CLIP_COMMAND_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_ADD_CLIP_COMMAND, ModelAddClipCommandClass))
 255
 256 typedef struct _ModelAddClipCommand ModelAddClipCommand;
 257 typedef struct _ModelAddClipCommandClass ModelAddClipCommandClass;
 258 #define _model_command_unref0(var) ((var == NULL) ? NULL : (var = (model_command_unref (var), NULL)))
 259 typedef struct _ModelClipPrivate ModelClipPrivate;
 260
 261 #define MODEL_TYPE_CLIP_FILE_DELETE_COMMAND (model_clip_file_delete_command_get_type ())
 262 #define MODEL_CLIP_FILE_DELETE_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_CLIP_FILE_DELETE_COMMAND, ModelClipFileDeleteCommand))
 263 #define MODEL_CLIP_FILE_DELETE_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_CLIP_FILE_DELETE_COMMAND, ModelClipFileDeleteCommandClass))
 264 #define MODEL_IS_CLIP_FILE_DELETE_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_CLIP_FILE_DELETE_COMMAND))
 265 #define MODEL_IS_CLIP_FILE_DELETE_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_CLIP_FILE_DELETE_COMMAND))
 266 #define MODEL_CLIP_FILE_DELETE_COMMAND_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_CLIP_FILE_DELETE_COMMAND, ModelClipFileDeleteCommandClass))
 267
 268 typedef struct _ModelClipFileDeleteCommand ModelClipFileDeleteCommand;
 269 typedef struct _ModelClipFileDeleteCommandClass ModelClipFileDeleteCommandClass;
 270 #define _fclose0(var) ((var == NULL) ? NULL : (var = (fclose (var), NULL)))
 271
 272 #define MODEL_TYPE_TIMELINE_IMPORTER (model_timeline_importer_get_type ())
 273 #define MODEL_TIMELINE_IMPORTER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_TIMELINE_IMPORTER, ModelTimelineImporter))
 274 #define MODEL_TIMELINE_IMPORTER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_TIMELINE_IMPORTER, ModelTimelineImporterClass))
 275 #define MODEL_IS_TIMELINE_IMPORTER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_TIMELINE_IMPORTER))
 276 #define MODEL_IS_TIMELINE_IMPORTER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_TIMELINE_IMPORTER))
 277 #define MODEL_TIMELINE_IMPORTER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_TIMELINE_IMPORTER, ModelTimelineImporterClass))
 278
 279 typedef struct _ModelTimelineImporter ModelTimelineImporter;
 280 typedef struct _ModelTimelineImporterClass ModelTimelineImporterClass;
 281 typedef struct _ModelLibraryImporterPrivate ModelLibraryImporterPrivate;
 282
 283 #define MODEL_TYPE_CLIP_IMPORTER (model_clip_importer_get_type ())
 284 #define MODEL_CLIP_IMPORTER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_CLIP_IMPORTER, ModelClipImporter))
 285 #define MODEL_CLIP_IMPORTER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_CLIP_IMPORTER, ModelClipImporterClass))
 286 #define MODEL_IS_CLIP_IMPORTER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_CLIP_IMPORTER))
 287 #define MODEL_IS_CLIP_IMPORTER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_CLIP_IMPORTER))
 288 #define MODEL_CLIP_IMPORTER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_CLIP_IMPORTER, ModelClipImporterClass))
 289
 290 typedef struct _ModelClipImporter ModelClipImporter;
 291 typedef struct _ModelClipImporterClass ModelClipImporterClass;
 292
 293 #define TYPE_MULTI_FILE_PROGRESS (multi_file_progress_get_type ())
 294 #define MULTI_FILE_PROGRESS(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_MULTI_FILE_PROGRESS, MultiFileProgress))
 295 #define MULTI_FILE_PROGRESS_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_MULTI_FILE_PROGRESS, MultiFileProgressClass))
 296 #define IS_MULTI_FILE_PROGRESS(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_MULTI_FILE_PROGRESS))
 297 #define IS_MULTI_FILE_PROGRESS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_MULTI_FILE_PROGRESS))
 298 #define MULTI_FILE_PROGRESS_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_MULTI_FILE_PROGRESS, MultiFileProgressClass))
 299
 300 typedef struct _MultiFileProgress MultiFileProgress;
 301 typedef struct _MultiFileProgressClass MultiFileProgressClass;
 302
 303 #define MODEL_TYPE_TIME_SIGNATURE_COMMAND (model_time_signature_command_get_type ())
 304 #define MODEL_TIME_SIGNATURE_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_TIME_SIGNATURE_COMMAND, ModelTimeSignatureCommand))
 305 #define MODEL_TIME_SIGNATURE_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_TIME_SIGNATURE_COMMAND, ModelTimeSignatureCommandClass))
 306 #define MODEL_IS_TIME_SIGNATURE_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_TIME_SIGNATURE_COMMAND))
 307 #define MODEL_IS_TIME_SIGNATURE_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_TIME_SIGNATURE_COMMAND))
 308 #define MODEL_TIME_SIGNATURE_COMMAND_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_TIME_SIGNATURE_COMMAND, ModelTimeSignatureCommandClass))
 309
 310 typedef struct _ModelTimeSignatureCommand ModelTimeSignatureCommand;
 311 typedef struct _ModelTimeSignatureCommandClass ModelTimeSignatureCommandClass;
 312
 313 #define MODEL_TYPE_BPM_COMMAND (model_bpm_command_get_type ())
 314 #define MODEL_BPM_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_BPM_COMMAND, ModelBpmCommand))
 315 #define MODEL_BPM_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_BPM_COMMAND, ModelBpmCommandClass))
 316 #define MODEL_IS_BPM_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_BPM_COMMAND))
 317 #define MODEL_IS_BPM_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_BPM_COMMAND))
 318 #define MODEL_BPM_COMMAND_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_BPM_COMMAND, ModelBpmCommandClass))
 319
 320 typedef struct _ModelBpmCommand ModelBpmCommand;
 321 typedef struct _ModelBpmCommandClass ModelBpmCommandClass;
 322
 323 struct _ModelLoaderHandler {
 324         GObject parent_instance;
 325         ModelLoaderHandlerPrivate * priv;
 326 };
 327
 328 struct _ModelLoaderHandlerClass {
 329         GObjectClass parent_class;
 330         gboolean (*commit_library) (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1);
 331         gboolean (*commit_marina) (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1);
 332         gboolean (*commit_track) (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1);
 333         gboolean (*commit_clip) (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1);
 334         gboolean (*commit_clipfile) (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1);
 335         gboolean (*commit_time_signature_entry) (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1);
 336         gboolean (*commit_tempo_entry) (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1);
 337         gboolean (*commit_click) (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1);
 338         gboolean (*commit_library_preference) (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1);
 339         void (*leave_library) (ModelLoaderHandler* self);
 340         void (*leave_marina) (ModelLoaderHandler* self);
 341         void (*leave_track) (ModelLoaderHandler* self);
 342         void (*leave_clip) (ModelLoaderHandler* self);
 343         void (*leave_clipfile) (ModelLoaderHandler* self);
 344 };
 345
 346 struct _ModelMediaLoaderHandler {
 347         ModelLoaderHandler parent_instance;
 348         ModelMediaLoaderHandlerPrivate * priv;
 349         ModelProject* the_project;
 350         ModelTrack* current_track;
 351 };
 352
 353 struct _ModelMediaLoaderHandlerClass {
 354         ModelLoaderHandlerClass parent_class;
 355 };
 356
 357 struct _ModelMediaLoaderHandlerPrivate {
 358         GeeArrayList* clipfetchers;
 359         gint num_clipfiles_complete;
 360 };
 361
 362 struct _Fraction {
 363         gint numerator;
 364         gint denominator;
 365 };
 366
 367 struct _ModelFetcher {
 368         GObject parent_instance;
 369         ModelFetcherPrivate * priv;
 370         GstElement* filesrc;
 371         GstElement* decodebin;
 372         GstPipeline* pipeline;
 373         ModelClipFile* clipfile;
 374         char* error_string;
 375 };
 376
 377 struct _ModelFetcherClass {
 378         GObjectClass parent_class;
 379         void (*on_pad_added) (ModelFetcher* self, GstPad* pad);
 380         void (*on_state_change) (ModelFetcher* self, GstBus* bus, GstMessage* message);
 381 };
 382
 383 typedef enum  {
 384         MODEL_MEDIA_TYPE_AUDIO,
 385         MODEL_MEDIA_TYPE_VIDEO
 386 } ModelMediaType;
 387
 388 typedef enum  {
 389         LOGGING_FACILITY_SIGNAL_HANDLERS,
 390         LOGGING_FACILITY_DEVELOPER_WARNINGS,
 391         LOGGING_FACILITY_GRAPH,
 392         LOGGING_FACILITY_LOADING,
 393         LOGGING_FACILITY_IMPORT,
 394         LOGGING_FACILITY_SINGLEDECODEBIN
 395 } LoggingFacility;
 396
 397 typedef enum  {
 398         LOGGING_LEVEL_CRITICAL,
 399         LOGGING_LEVEL_HIGH,
 400         LOGGING_LEVEL_MEDIUM,
 401         LOGGING_LEVEL_LOW,
 402         LOGGING_LEVEL_INFO,
 403         LOGGING_LEVEL_VERBOSE
 404 } LoggingLevel;
 405
 406 struct _ModelClipFile {
 407         GObject parent_instance;
 408         ModelClipFilePrivate * priv;
 409         char* filename;
 410         GstCaps* video_caps;
 411         GstCaps* audio_caps;
 412         GdkPixbuf* thumbnail;
 413 };
 414
 415 struct _ModelClipFileClass {
 416         GObjectClass parent_class;
 417 };
 418
 419 struct _ModelTempoInformationIface {
 420         GTypeInterface parent_iface;
 421         void (*get_time_signature) (ModelTempoInformation* self, Fraction* result);
 422         gint (*get_bpm) (ModelTempoInformation* self);
 423 };
 424
 425 struct _TimeCode {
 426         gint hour;
 427         gint minute;
 428         gint second;
 429         gint frame;
 430         gboolean drop_code;
 431 };
 432
 433 struct _ModelProject {
 434         GObject parent_instance;
 435         ModelProjectPrivate * priv;
 436         GeeArrayList* tracks;
 437         GeeArrayList* inactive_tracks;
 438         GeeArrayList* clipfiles;
 439         ViewMediaEngine* media_engine;
 440         char* project_file;
 441         ModelProjectLoader* loader;
 442         ModelUndoManager* undo_manager;
 443         ModelLibraryImporter* importer;
 444         Fraction default_framerate;
 445         gboolean click_during_play;
 446         gboolean click_during_record;
 447         double click_volume;
 448         gboolean library_visible;
 449         gint library_width;
 450         gboolean snap_to_clip;
 451 };
 452
 453 struct _ModelProjectClass {
 454         GObjectClass parent_class;
 455         void (*get_clip_time) (ModelProject* self, ModelClipFile* f, TimeCode* result);
 456         char* (*get_project_file) (ModelProject* self);
 457         void (*do_append) (ModelProject* self, ModelTrack* track, ModelClipFile* clipfile, const char* name, gint64 insert_time);
 458         void (*add_track) (ModelProject* self, ModelTrack* track);
 459         void (*insert_track) (ModelProject* self, gint index, ModelTrack* track);
 460         void (*load) (ModelProject* self, const char* fname);
 461         void (*save) (ModelProject* self, const char* filename);
 462         char* (*get_app_name) (ModelProject* self);
 463         void (*load_complete) (ModelProject* self);
 464 };
 465
 466 struct _ModelProjectPrivate {
 467         GeeHashSet* pending;
 468         GeeArrayList* pending_thumbs;
 469         ModelFetcherCompletion* fetcher_completion;
 470         gint tempo;
 471         Fraction time_signature;
 472 };
 473
 474 typedef enum  {
 475         PLAY_STATE_STOPPED,
 476         PLAY_STATE_PRE_PLAY,
 477         PLAY_STATE_PLAYING,
 478         PLAY_STATE_PRE_RECORD_NULL,
 479         PLAY_STATE_PRE_RECORD,
 480         PLAY_STATE_RECORDING,
 481         PLAY_STATE_POST_RECORD,
 482         PLAY_STATE_PRE_EXPORT,
 483         PLAY_STATE_EXPORTING,
 484         PLAY_STATE_CANCEL_EXPORT,
 485         PLAY_STATE_LOADING,
 486         PLAY_STATE_CLOSING,
 487         PLAY_STATE_CLOSED
 488 } PlayState;
 489
 490 struct _ModelTrack {
 491         GObject parent_instance;
 492         ModelTrackPrivate * priv;
 493         ModelProject* project;
 494         GeeArrayList* clips;
 495         char* display_name;
 496 };
 497
 498 struct _ModelTrackClass {
 499         GObjectClass parent_class;
 500         char* (*name) (ModelTrack* self);
 501         ModelMediaType (*media_type) (ModelTrack* self);
 502         gboolean (*check) (ModelTrack* self, ModelClip* clip);
 503         void (*on_clip_updated) (ModelTrack* self, ModelClip* clip);
 504         void (*write_attributes) (ModelTrack* self, FILE* f);
 505 };
 506
 507 struct _ModelGap {
 508         GTypeInstance parent_instance;
 509         volatile int ref_count;
 510         ModelGapPrivate * priv;
 511         gint64 start;
 512         gint64 end;
 513 };
 514
 515 struct _ModelGapClass {
 516         GTypeClass parent_class;
 517         void (*finalize) (ModelGap *self);
 518 };
 519
 520 struct _MultiFileProgressInterfaceIface {
 521         GTypeInterface parent_iface;
 522         void (*cancel) (MultiFileProgressInterface* self);
 523         void (*complete) (MultiFileProgressInterface* self);
 524 };
 525
 526 struct _ViewMediaEngine {
 527         GObject parent_instance;
 528         ViewMediaEnginePrivate * priv;
 529         GstPipeline* pipeline;
 530         GstBin* record_bin;
 531         GstElement* converter;
 532         GstElement* adder;
 533         GstState gst_state;
 534         PlayState play_state;
 535         gint64 position;
 536         gboolean playing;
 537         ModelAudioTrack* record_track;
 538         ModelClip* record_region;
 539 };
 540
 541 struct _ViewMediaEngineClass {
 542         GObjectClass parent_class;
 543         void (*do_null_state_export) (ViewMediaEngine* self, gint64 length);
 544         void (*pause) (ViewMediaEngine* self);
 545 };
 546
 547 struct _ModelClip {
 548         GObject parent_instance;
 549         ModelClipPrivate * priv;
 550         ModelClipFile* clipfile;
 551         ModelMediaType type;
 552         gboolean is_recording;
 553         char* name;
 554 };
 555
 556 struct _ModelClipClass {
 557         GObjectClass parent_class;
 558 };
 559
 560 struct _ModelLibraryImporter {
 561         GObject parent_instance;
 562         ModelLibraryImporterPrivate * priv;
 563         ModelProject* project;
 564         ModelClipImporter* importer;
 565 };
 566
 567 struct _ModelLibraryImporterClass {
 568         GObjectClass parent_class;
 569         void (*append_existing_clipfile) (ModelLibraryImporter* self, ModelClipFile* f);
 570         void (*on_clip_complete) (ModelLibraryImporter* self, ModelClipFile* f);
 571 };
 572
 573
 574 static gpointer model_media_loader_handler_parent_class = NULL;
 575 extern Fraction model_project_INVALID_FRAME_RATE;
 576 Fraction model_project_INVALID_FRAME_RATE = {0};
 577 static gpointer model_project_parent_class = NULL;
 578 static ModelTempoInformationIface* model_project_model_tempo_information_parent_iface = NULL;
 579
 580 GType model_loader_handler_get_type (void);
 581 GType model_media_loader_handler_get_type (void);
 582 GType model_project_get_type (void);
 583 GType model_track_get_type (void);
 584 GType model_fetcher_get_type (void);
 585 GType model_clip_fetcher_get_type (void);
 586 #define MODEL_MEDIA_LOADER_HANDLER_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), MODEL_TYPE_MEDIA_LOADER_HANDLER, ModelMediaLoaderHandlerPrivate))
 587 enum  {
 588         MODEL_MEDIA_LOADER_HANDLER_DUMMY_PROPERTY
 589 };
 590 ModelLoaderHandler* model_loader_handler_new (void);
 591 ModelLoaderHandler* model_loader_handler_construct (GType object_type);
 592 ModelMediaLoaderHandler* model_media_loader_handler_new (ModelProject* the_project);
 593 ModelMediaLoaderHandler* model_media_loader_handler_construct (GType object_type, ModelProject* the_project);
 594 gint model_project_get_file_version (ModelProject* self);
 595 static gboolean model_media_loader_handler_real_commit_marina (ModelLoaderHandler* base, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1);
 596 GType fraction_get_type (void);
 597 Fraction* fraction_dup (const Fraction* self);
 598 void fraction_free (Fraction* self);
 599 void model_project_set_default_framerate (ModelProject* self, Fraction* rate);
 600 void fraction_init (Fraction *self, gint numerator, gint denominator);
 601 static gboolean model_media_loader_handler_real_commit_library (ModelLoaderHandler* base, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1);
 602 ModelAudioTrack* model_audio_track_new (ModelProject* project, const char* display_name);
 603 ModelAudioTrack* model_audio_track_construct (GType object_type, ModelProject* project, const char* display_name);
 604 GType model_audio_track_get_type (void);
 605 void model_project_add_track (ModelProject* self, ModelTrack* track);
 606 void _model_audio_track_set_pan (ModelAudioTrack* self, double new_value);
 607 void _model_audio_track_set_volume (ModelAudioTrack* self, double new_volume);
 608 void model_audio_track_set_default_num_channels (ModelAudioTrack* self, gint num);
 609 ModelVideoTrack* model_video_track_new (ModelProject* project);
 610 ModelVideoTrack* model_video_track_construct (GType object_type, ModelProject* project);
 611 GType model_video_track_get_type (void);
 612 gboolean model_loader_handler_commit_track (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1);
 613 static gboolean model_media_loader_handler_real_commit_track (ModelLoaderHandler* base, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1);
 614 static void model_media_loader_handler_real_leave_track (ModelLoaderHandler* base);
 615 GType model_clip_file_get_type (void);
 616 GType model_media_type_get_type (void);
 617 ModelMediaType model_track_media_type (ModelTrack* self);
 618 ModelClip* model_clip_new (ModelClipFile* clipfile, ModelMediaType t, const char* name, gint64 start, gint64 media_start, gint64 duration, gboolean is_recording);
 619 ModelClip* model_clip_construct (GType object_type, ModelClipFile* clipfile, ModelMediaType t, const char* name, gint64 start, gint64 media_start, gint64 duration, gboolean is_recording);
 620 GType model_clip_get_type (void);
 621 void model_track_add (ModelTrack* self, ModelClip* c, gint64 pos, gboolean select);
 622 static gboolean model_media_loader_handler_real_commit_clip (ModelLoaderHandler* base, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1);
 623 GType logging_facility_get_type (void);
 624 GType logging_level_get_type (void);
 625 void logging_emit (GObject* object, LoggingFacility facility, LoggingLevel level, const char* message);
 626 void model_project_add_clipfile (ModelProject* self, ModelClipFile* clipfile);
 627 static void model_media_loader_handler_fetcher_ready (ModelMediaLoaderHandler* self, ModelFetcher* f);
 628 ModelClipFetcher* model_clip_fetcher_new (const char* filename, GError** error);
 629 ModelClipFetcher* model_clip_fetcher_construct (GType object_type, const char* filename, GError** error);
 630 static void _model_media_loader_handler_fetcher_ready_model_fetcher_ready (ModelFetcher* _sender, ModelFetcher* fetcher, gpointer self);
 631 static gboolean model_media_loader_handler_real_commit_clipfile (ModelLoaderHandler* base, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1);
 632 void _model_project_set_bpm (ModelProject* self, gint bpm);
 633 static gboolean model_media_loader_handler_real_commit_tempo_entry (ModelLoaderHandler* base, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1);
 634 void _model_project_set_time_signature (ModelProject* self, Fraction* time_signature);
 635 void fraction_init_from_string (Fraction *self, const char* s);
 636 static gboolean model_media_loader_handler_real_commit_time_signature_entry (ModelLoaderHandler* base, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1);
 637 GType model_tempo_information_get_type (void);
 638 GType time_code_get_type (void);
 639 TimeCode* time_code_dup (const TimeCode* self);
 640 void time_code_free (TimeCode* self);
 641 GType view_media_engine_get_type (void);
 642 GType model_project_loader_get_type (void);
 643 gpointer model_undo_manager_ref (gpointer instance);
 644 void model_undo_manager_unref (gpointer instance);
 645 GParamSpec* model_param_spec_undo_manager (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);
 646 void model_value_set_undo_manager (GValue* value, gpointer v_object);
 647 void model_value_take_undo_manager (GValue* value, gpointer v_object);
 648 gpointer model_value_get_undo_manager (const GValue* value);
 649 GType model_undo_manager_get_type (void);
 650 GType model_library_importer_get_type (void);
 651 static gboolean model_media_loader_handler_real_commit_click (ModelLoaderHandler* base, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1);
 652 static gboolean model_media_loader_handler_real_commit_library_preference (ModelLoaderHandler* base, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1);
 653 static void model_media_loader_handler_real_leave_library (ModelLoaderHandler* base);
 654 static void model_media_loader_handler_finalize (GObject* obj);
 655 GType model_thumbnail_fetcher_get_type (void);
 656 gpointer model_fetcher_completion_ref (gpointer instance);
 657 void model_fetcher_completion_unref (gpointer instance);
 658 GParamSpec* model_param_spec_fetcher_completion (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);
 659 void model_value_set_fetcher_completion (GValue* value, gpointer v_object);
 660 void model_value_take_fetcher_completion (GValue* value, gpointer v_object);
 661 gpointer model_value_get_fetcher_completion (const GValue* value);
 662 GType model_fetcher_completion_get_type (void);
 663 #define MODEL_PROJECT_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), MODEL_TYPE_PROJECT, ModelProjectPrivate))
 664 enum  {
 665         MODEL_PROJECT_DUMMY_PROPERTY
 666 };
 667 #define MODEL_PROJECT_FILLMORE_FILE_EXTENSION "fill"
 668 #define MODEL_PROJECT_FILLMORE_FILE_FILTER "*." MODEL_PROJECT_FILLMORE_FILE_EXTENSION
 669 #define MODEL_PROJECT_LOMBARD_FILE_EXTENSION "lom"
 670 #define MODEL_PROJECT_LOMBARD_FILE_FILTER "*." MODEL_PROJECT_LOMBARD_FILE_EXTENSION
 671 #define MODEL_PROJECT_license "\n" \
 672 "%s is free software; you can redistribute it and/or modify it under th" \
 673 "e \n" \
 674 "terms of the GNU Lesser General Public License as published by the Fre" \
 675 "e \n" \
 676 "Software Foundation; either version 2.1 of the License, or (at your op" \
 677 "tion) \n" \
 678 "any later version.\n" \
 679 "\n" \
 680 "%s is distributed in the hope that it will be useful, but WITHOUT \n" \
 681 "ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or " \
 682 "FITNESS\n" \
 683 "FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License f" \
 684 "or \n" \
 685 "more details.\n" \
 686 "\n" \
 687 "You should have received a copy of the GNU Lesser General Public Licen" \
 688 "se \n" \
 689 "along with %s; if not, write to the Free Software Foundation, Inc., \n" \
 690 "51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA\n"
 691 void model_project_get_clip_time (ModelProject* self, ModelClipFile* f, TimeCode* result);
 692 static void model_project_real_get_clip_time (ModelProject* self, ModelClipFile* f, TimeCode* result);
 693 ModelUndoManager* model_undo_manager_new (void);
 694 ModelUndoManager* model_undo_manager_construct (GType object_type);
 695 ViewMediaEngine* view_media_engine_new (ModelProject* project, gboolean include_video, GError** error);
 696 ViewMediaEngine* view_media_engine_construct (GType object_type, ModelProject* project, gboolean include_video, GError** error);
 697 void view_media_engine_on_track_added (ViewMediaEngine* self, ModelTrack* track);
 698 static void _view_media_engine_on_track_added_model_project_track_added (ModelProject* _sender, ModelTrack* track, gpointer self);
 699 void model_project_on_playstate_changed (ModelProject* self);
 700 static void _model_project_on_playstate_changed_view_media_engine_playstate_changed (ViewMediaEngine* _sender, gpointer self);
 701 void model_project_on_error_occurred (ModelProject* self, const char* major_error, const char* minor_error);
 702 static void _model_project_on_error_occurred_view_media_engine_error_occurred (ViewMediaEngine* _sender, const char* major_message, const char* minor_message, gpointer self);
 703 ModelProject* model_project_construct (GType object_type, const char* filename, gboolean include_video, GError** error);
 704 GType play_state_get_type (void);
 705 PlayState view_media_engine_get_play_state (ViewMediaEngine* self);
 706 static void model_project_ClearTrackMeters (ModelProject* self);
 707 char* model_project_get_project_file (ModelProject* self);
 708 static char* model_project_real_get_project_file (ModelProject* self);
 709 ModelClipFile* model_project_get_clipfile (ModelProject* self, gint index);
 710 gint model_project_get_clipfile_index (ModelProject* self, ModelClipFile* find);
 711 ModelTrack* model_project_track_from_clip (ModelProject* self, ModelClip* clip);
 712 void model_project_print_graph (ModelProject* self, GstBin* bin, const char* file_name);
 713 gint64 model_track_get_length (ModelTrack* self);
 714 gint64 model_project_get_length (ModelProject* self);
 715 gint64 model_track_snap_clip (ModelTrack* self, ModelClip* c, gint64 span);
 716 gint64 model_clip_get_start (ModelClip* self);
 717 gint64 model_project_snap_clip (ModelProject* self, ModelClip* c, gint64 span);
 718 gboolean model_track_snap_coord (ModelTrack* self, gint64* coord, gint64 span);
 719 void model_project_snap_coord (ModelProject* self, gint64* coord, gint64 span);
 720 gpointer model_gap_ref (gpointer instance);
 721 void model_gap_unref (gpointer instance);
 722 GParamSpec* model_param_spec_gap (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);
 723 void model_value_set_gap (GValue* value, gpointer v_object);
 724 void model_value_take_gap (GValue* value, gpointer v_object);
 725 gpointer model_value_get_gap (const GValue* value);
 726 GType model_gap_get_type (void);
 727 ModelGap* model_gap_intersect (ModelGap* self, ModelGap* g);
 728 ModelGap* model_track_find_first_gap (ModelTrack* self, gint64 start);
 729 static ModelGap* model_project_get_gap_intersection (ModelProject* self, ModelGap* gap);
 730 gboolean model_gap_is_empty (ModelGap* self);
 731 gboolean model_project_can_delete_gap (ModelProject* self, ModelGap* gap);
 732 void model_track_delete_gap (ModelTrack* self, ModelGap* g);
 733 void model_project_delete_gap (ModelProject* self, ModelGap* gap);
 734 gint64 model_clip_file_get_length (ModelClipFile* self);
 735 void model_track_append_at_time (ModelTrack* self, ModelClip* c, gint64 time, gboolean select);
 736 void model_project_do_append (ModelProject* self, ModelTrack* track, ModelClipFile* clipfile, const char* name, gint64 insert_time);
 737 static void model_project_real_do_append (ModelProject* self, ModelTrack* track, ModelClipFile* clipfile, const char* name, gint64 insert_time);
 738 char* isolate_filename (const char* path);
 739 void model_project_append (ModelProject* self, ModelTrack* track, ModelClipFile* clipfile);
 740 void model_project_add (ModelProject* self, ModelTrack* track, ModelClipFile* clipfile, gint64 time);
 741 void model_project_reseek (ModelProject* self);
 742 void model_project_on_clip_removed (ModelProject* self, ModelTrack* t, ModelClip* clip);
 743 void model_undo_manager_start_transaction (ModelUndoManager* self, const char* description);
 744 ModelClip* model_track_get_clip_by_position (ModelTrack* self, gint64 pos);
 745 gint64 model_project_transport_get_position (ModelProject* self);
 746 void model_track_split_at (ModelTrack* self, gint64 position);
 747 void model_undo_manager_end_transaction (ModelUndoManager* self, const char* description);
 748 void model_project_split_at_playhead (ModelProject* self);
 749 gint64 model_clip_get_end (ModelClip* self);
 750 gint64 model_clip_get_duration (ModelClip* self);
 751 gboolean model_project_can_trim (ModelProject* self, gboolean* left);
 752 void model_track_trim (ModelTrack* self, ModelClip* clip, gint64 delta, GdkWindowEdge edge);
 753 void model_project_transport_go (ModelProject* self, gint64 position);
 754 void model_project_trim_to_playhead (ModelProject* self);
 755 void view_media_engine_go (ViewMediaEngine* self, gint64 pos);
 756 GType multi_file_progress_interface_get_type (void);
 757 gboolean model_project_transport_is_playing (ModelProject* self);
 758 gboolean model_project_transport_is_recording (ModelProject* self);
 759 gboolean model_project_playhead_on_clip (ModelProject* self);
 760 gboolean model_track_are_contiguous_clips (ModelTrack* self, gint64 position);
 761 gboolean model_project_playhead_on_contiguous_clip (ModelProject* self);
 762 char* model_track_get_display_name (ModelTrack* self);
 763 gboolean model_project_is_duplicate_track_name (ModelProject* self, ModelTrack* track, const char* new_name);
 764 static void _model_project_on_clip_removed_model_track_clip_removed (ModelTrack* _sender, ModelClip* clip, gpointer self);
 765 static void _model_project_on_error_occurred_model_track_error_occurred (ModelTrack* _sender, const char* major_error, const char* minor_error, gpointer self);
 766 static void model_project_real_add_track (ModelProject* self, ModelTrack* track);
 767 void model_project_insert_track (ModelProject* self, gint index, ModelTrack* track);
 768 static void model_project_real_insert_track (ModelProject* self, gint index, ModelTrack* track);
 769 void model_track_hide (ModelTrack* self);
 770 void model_project_add_inactive_track (ModelProject* self, ModelTrack* track);
 771 void model_project_remove_track (ModelProject* self, ModelTrack* track);
 772 void model_project_remove_track_at (ModelProject* self, gint index);
 773 ModelAddClipCommand* model_add_clip_command_new (ModelProject* project, ModelClipFile* clip_file);
 774 ModelAddClipCommand* model_add_clip_command_construct (GType object_type, ModelProject* project, ModelClipFile* clip_file);
 775 gpointer model_command_ref (gpointer instance);
 776 void model_command_unref (gpointer instance);
 777 GParamSpec* model_param_spec_command (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);
 778 void model_value_set_command (GValue* value, gpointer v_object);
 779 void model_value_take_command (GValue* value, gpointer v_object);
 780 gpointer model_value_get_command (const GValue* value);
 781 GType model_command_get_type (void);
 782 GType model_add_clip_command_get_type (void);
 783 void model_project_do_command (ModelProject* self, ModelCommand* the_command);
 784 gboolean model_clip_file_is_online (ModelClipFile* self);
 785 gboolean model_clip_file_is_of_type (ModelClipFile* self, ModelMediaType t);
 786 ModelThumbnailFetcher* model_thumbnail_fetcher_new (ModelClipFile* f, gint64 time, GError** error);
 787 ModelThumbnailFetcher* model_thumbnail_fetcher_construct (GType object_type, ModelClipFile* f, gint64 time, GError** error);
 788 static void model_project_on_thumbnail_ready (ModelProject* self, ModelFetcher* f);
 789 static void _model_project_on_thumbnail_ready_model_fetcher_ready (ModelFetcher* _sender, ModelFetcher* fetcher, gpointer self);
 790 void _model_project_add_clipfile (ModelProject* self, ModelClipFile* clipfile, GError** error);
 791 ModelClipFile* model_project_find_clipfile (ModelProject* self, const char* filename);
 792 gboolean model_project_clipfile_on_track (ModelProject* self, const char* filename);
 793 void model_track_delete_clip (ModelTrack* self, ModelClip* clip);
 794 static void model_project_delete_clipfile_from_tracks (ModelProject* self, ModelClipFile* cf);
 795 void _model_project_remove_clipfile (ModelProject* self, ModelClipFile* cf);
 796 ModelClipFileDeleteCommand* model_clip_file_delete_command_new (ModelProject* p, ModelClipFile* cf);
 797 ModelClipFileDeleteCommand* model_clip_file_delete_command_construct (GType object_type, ModelProject* p, ModelClipFile* cf);
 798 GType model_clip_file_delete_command_get_type (void);
 799 void model_project_remove_clipfile (ModelProject* self, const char* filename);
 800 void model_project_go_start (ModelProject* self);
 801 void model_project_go_end (ModelProject* self);
 802 gint64 model_track_previous_edit (ModelTrack* self, gint64 pos);
 803 void model_project_go_previous (ModelProject* self);
 804 gint64 model_track_next_edit (ModelTrack* self, gint64 pos);
 805 void model_project_go_next (ModelProject* self);
 806 void model_project_set_name (ModelProject* self, const char* filename);
 807 char* model_project_get_app_name (ModelProject* self);
 808 char* model_project_get_file_display_name (ModelProject* self);
 809 void view_media_engine_set_gst_state (ViewMediaEngine* self, GstState state);
 810 void model_track_delete_all_clips (ModelTrack* self);
 811 void model_project_clear (ModelProject* self);
 812 gboolean model_project_can_export (ModelProject* self);
 813 void model_project_on_load_started (ModelProject* self, const char* filename);
 814 static void model_project_on_load_error (ModelProject* self, const char* _error_);
 815 void model_undo_manager_reset (ModelUndoManager* self);
 816 static void model_project_on_load_complete (ModelProject* self);
 817 ModelProjectLoader* model_project_loader_new (ModelLoaderHandler* loader_handler, const char* file_name);
 818 ModelProjectLoader* model_project_loader_construct (GType object_type, ModelLoaderHandler* loader_handler, const char* file_name);
 819 static void _model_project_on_load_started_model_project_loader_load_started (ModelProjectLoader* _sender, const char* filename, gpointer self);
 820 static void _model_project_on_load_error_model_project_loader_load_error (ModelProjectLoader* _sender, const char* _error_, gpointer self);
 821 static void _model_project_on_load_complete_model_project_loader_load_complete (ModelProjectLoader* _sender, gpointer self);
 822 void view_media_engine_on_load_complete (ViewMediaEngine* self);
 823 static void _view_media_engine_on_load_complete_model_project_loader_load_complete (ModelProjectLoader* _sender, gpointer self);
 824 void view_media_engine_set_play_state (ViewMediaEngine* self, PlayState play_state);
 825 void model_project_loader_load (ModelProjectLoader* self);
 826 void model_project_load (ModelProject* self, const char* fname);
 827 static void model_project_real_load (ModelProject* self, const char* fname);
 828 gboolean model_video_track_get_framerate (ModelVideoTrack* self, Fraction* rate);
 829 gboolean fraction_equal (Fraction *self, Fraction* f);
 830 void model_project_save_library (ModelProject* self, FILE* f);
 831 void model_track_save (ModelTrack* self, FILE* f);
 832 char* fraction_to_string (Fraction *self);
 833 void model_undo_manager_mark_clean (ModelUndoManager* self);
 834 void model_project_save (ModelProject* self, const char* filename);
 835 static void model_project_real_save (ModelProject* self, const char* filename);
 836 void view_media_engine_close (ViewMediaEngine* self);
 837 void model_project_close (ModelProject* self);
 838 void model_fetcher_completion_complete (ModelFetcherCompletion* self, ModelFetcher* fetcher);
 839 void model_project_on_importer_clip_complete (ModelProject* self, ModelClipFetcher* fetcher);
 840 static void model_project_on_fetcher_ready (ModelProject* self, ModelFetcher* fetcher);
 841 static void _model_project_on_fetcher_ready_model_fetcher_ready (ModelFetcher* _sender, ModelFetcher* fetcher, gpointer self);
 842 void model_project_create_clip_fetcher (ModelProject* self, ModelFetcherCompletion* fetcher_completion, const char* filename, GError** error);
 843 char* get_file_extension (const char* path);
 844 gboolean model_project_is_project_extension (ModelProject* self, const char* filename);
 845 void model_undo_manager_do_command (ModelUndoManager* self, ModelCommand* the_command);
 846 void model_undo_manager_undo (ModelUndoManager* self);
 847 void model_project_undo (ModelProject* self);
 848 ModelTimelineImporter* model_timeline_importer_new (ModelTrack* track, ModelProject* p, gint64 time_to_add, gboolean both_tracks);
 849 ModelTimelineImporter* model_timeline_importer_construct (GType object_type, ModelTrack* track, ModelProject* p, gint64 time_to_add, gboolean both_tracks);
 850 GType model_timeline_importer_get_type (void);
 851 ModelLibraryImporter* model_library_importer_new (ModelProject* p);
 852 ModelLibraryImporter* model_library_importer_construct (GType object_type, ModelProject* p);
 853 GType model_clip_importer_get_type (void);
 854 MultiFileProgress* multi_file_progress_new (GtkWindow* parent, gint num_files, const char* dialog_title, MultiFileProgressInterface* provider);
 855 MultiFileProgress* multi_file_progress_construct (GType object_type, GtkWindow* parent, gint num_files, const char* dialog_title, MultiFileProgressInterface* provider);
 856 GType multi_file_progress_get_type (void);
 857 void model_project_create_clip_importer (ModelProject* self, ModelTrack* track, gboolean timeline_add, gint64 time_to_add, gboolean both_tracks, GtkWindow* progress_window_parent, gint number);
 858 char* model_project_get_version (ModelProject* self);
 859 static char* model_project_real_get_app_name (ModelProject* self);
 860 char* model_project_get_license (ModelProject* self);
 861 ModelTimeSignatureCommand* model_time_signature_command_new (ModelProject* project, Fraction* new_time_signature);
 862 ModelTimeSignatureCommand* model_time_signature_command_construct (GType object_type, ModelProject* project, Fraction* new_time_signature);
 863 GType model_time_signature_command_get_type (void);
 864 void model_project_set_time_signature (ModelProject* self, Fraction* time_signature);
 865 static void model_project_real_get_time_signature (ModelTempoInformation* base, Fraction* result);
 866 ModelBpmCommand* model_bpm_command_new (ModelProject* project, gint new_bpm);
 867 ModelBpmCommand* model_bpm_command_construct (GType object_type, ModelProject* project, gint new_bpm);
 868 GType model_bpm_command_get_type (void);
 869 void model_project_set_bpm (ModelProject* self, gint bpm);
 870 static gint model_project_real_get_bpm (ModelTempoInformation* base);
 871 static char* model_project_get_path (ModelProject* self);
 872 char* model_project_get_audio_path (ModelProject* self);
 873 ModelVideoTrack* model_project_find_video_track (ModelProject* self);
 874 ModelAudioTrack* model_project_find_audio_track (ModelProject* self);
 875 void model_project_load_complete (ModelProject* self);
 876 static void model_project_real_load_complete (ModelProject* self);
 877 static void model_project_finalize (GObject* obj);
 878 static void _vala_array_destroy (gpointer array, gint array_length, GDestroyNotify destroy_func);
 879 static void _vala_array_free (gpointer array, gint array_length, GDestroyNotify destroy_func);
 880 static gint _vala_array_length (gpointer array);
 881 static int _vala_strcmp0 (const char * str1, const char * str2);
 882
 883 const char* MODEL_PROJECT_authors[5] = {"Robert Powell <rob@yorba.org>", "Adam Dingle <adam@yorba.org>", "Andrew O'Mahony <andrew.omahony@att.net>", "Dru Moore <usr@dru-id.co.uk>", NULL};
 884
 885 static void g_cclosure_user_marshal_VOID__STRING_STRING (GClosure * closure, GValue * return_value, guint n_param_values, const GValue * param_values, gpointer invocation_hint, gpointer marshal_data);
 886
 887 #line 19 "project.vala"
 888 ModelMediaLoaderHandler* model_media_loader_handler_construct (GType object_type, ModelProject* the_project) {
 889 #line 871 "project.c"
 890         ModelMediaLoaderHandler * self;
 891         ModelTrack* _tmp0_;
 892 #line 19 "project.vala"
 893         g_return_val_if_fail (MODEL_IS_PROJECT (the_project), NULL);
 894 #line 19 "project.vala"
 895         self = (ModelMediaLoaderHandler*) model_loader_handler_construct (object_type);
 896 #line 20 "project.vala"
 897         self->the_project = the_project;
 898 #line 21 "project.vala"
 899         self->current_track = (_tmp0_ = NULL, _g_object_unref0 (self->current_track), _tmp0_);
 900 #line 882 "project.c"
 901         return self;
 902 }
 903
 904
 905 #line 19 "project.vala"
 906 ModelMediaLoaderHandler* model_media_loader_handler_new (ModelProject* the_project) {
 907 #line 19 "project.vala"
 908         return model_media_loader_handler_construct (MODEL_TYPE_MEDIA_LOADER_HANDLER, the_project);
 909 #line 891 "project.c"
 910 }
 911
 912
 913 #line 24 "project.vala"
 914 static gboolean model_media_loader_handler_real_commit_marina (ModelLoaderHandler* base, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1) {
 915 #line 897 "project.c"
 916         ModelMediaLoaderHandler * self;
 917         gboolean result = FALSE;
 918         gint number_of_attributes;
 919         gboolean _tmp0_ = FALSE;
 920         self = MODEL_MEDIA_LOADER_HANDLER (base);
 921 #line 25 "project.vala"
 922         number_of_attributes = attr_names_length1;
 923 #line 26 "project.vala"
 924         if (number_of_attributes != 1) {
 925 #line 26 "project.vala"
 926                 _tmp0_ = TRUE;
 927 #line 909 "project.c"
 928         } else {
 929 #line 27 "project.vala"
 930                 _tmp0_ = _vala_strcmp0 (attr_names[0], "version") != 0;
 931 #line 913 "project.c"
 932         }
 933 #line 26 "project.vala"
 934         if (_tmp0_) {
 935 #line 28 "project.vala"
 936                 g_signal_emit_by_name (MODEL_LOADER_HANDLER (self), "load-error", "Missing version information");
 937 #line 919 "project.c"
 938                 result = FALSE;
 939 #line 29 "project.vala"
 940                 return result;
 941 #line 923 "project.c"
 942         }
 943 #line 32 "project.vala"
 944         if (model_project_get_file_version (self->the_project) < atoi (attr_values[0])) {
 945 #line 927 "project.c"
 946                 char* _tmp1_;
 947 #line 33 "project.vala"
 948                 g_signal_emit_by_name (MODEL_LOADER_HANDLER (self), "load-error", _tmp1_ = g_strdup_printf ("Version mismatch! (File Version: %d, App Version: %d)", model_project_get_file_version (self->the_project), atoi (attr_values[0])));
 949 #line 931 "project.c"
 950                 _g_free0 (_tmp1_);
 951                 result = FALSE;
 952 #line 35 "project.vala"
 953                 return result;
 954 #line 936 "project.c"
 955         }
 956 #line 38 "project.vala"
 957         self->priv->num_clipfiles_complete = 0;
 958 #line 940 "project.c"
 959         result = TRUE;
 960 #line 39 "project.vala"
 961         return result;
 962 #line 944 "project.c"
 963 }
 964
 965
 966 #line 42 "project.vala"
 967 static gboolean model_media_loader_handler_real_commit_library (ModelLoaderHandler* base, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1) {
 968 #line 950 "project.c"
 969         ModelMediaLoaderHandler * self;
 970         gboolean result = FALSE;
 971         char** _tmp1_;
 972         gint _arr_size_;
 973         gint arr_length1;
 974         char** _tmp0_;
 975         char** arr;
 976         Fraction _tmp3_;
 977         Fraction _tmp2_ = {0};
 978         self = MODEL_MEDIA_LOADER_HANDLER (base);
 979 #line 44 "project.vala"
 980         if (attr_names_length1 != 1) {
 981 #line 963 "project.c"
 982                 result = TRUE;
 983 #line 45 "project.vala"
 984                 return result;
 985 #line 967 "project.c"
 986         }
 987 #line 47 "project.vala"
 988         if (_vala_strcmp0 (attr_names[0], "framerate") != 0) {
 989 #line 48 "project.vala"
 990                 g_signal_emit_by_name (MODEL_LOADER_HANDLER (self), "load-error", "Missing framerate tag");
 991 #line 973 "project.c"
 992                 result = FALSE;
 993 #line 49 "project.vala"
 994                 return result;
 995 #line 977 "project.c"
 996         }
 997         arr = (_tmp1_ = _tmp0_ = g_strsplit (attr_values[0], "/", 0), arr_length1 = _vala_array_length (_tmp0_), _arr_size_ = arr_length1, _tmp1_);
 998 #line 53 "project.vala"
 999         if (arr_length1 != 2) {
1000 #line 54 "project.vala"
1001                 g_signal_emit_by_name (MODEL_LOADER_HANDLER (self), "load-error", "Invalid framerate attribute");
1002 #line 984 "project.c"
1003                 result = FALSE;
1004                 arr = (_vala_array_free (arr, arr_length1, (GDestroyNotify) g_free), NULL);
1005 #line 55 "project.vala"
1006                 return result;
1007 #line 989 "project.c"
1008         }
1009 #line 58 "project.vala"
1010         model_project_set_default_framerate (self->the_project, (_tmp3_ = (fraction_init (&_tmp2_, atoi (arr[0]), atoi (arr[1])), _tmp2_), &_tmp3_));
1011 #line 993 "project.c"
1012         result = TRUE;
1013         arr = (_vala_array_free (arr, arr_length1, (GDestroyNotify) g_free), NULL);
1014 #line 59 "project.vala"
1015         return result;
1016 #line 998 "project.c"
1017 }
1018
1019
1020 static gpointer _g_object_ref0 (gpointer self) {
1021         return self ? g_object_ref (self) : NULL;
1022 }
1023
1024
1025 #line 62 "project.vala"
1026 static gboolean model_media_loader_handler_real_commit_track (ModelLoaderHandler* base, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1) {
1027 #line 1009 "project.c"
1028         ModelMediaLoaderHandler * self;
1029         gboolean result = FALSE;
1030         gint number_of_attributes;
1031         char* name;
1032         char* type;
1033         self = MODEL_MEDIA_LOADER_HANDLER (base);
1034 #line 63 "project.vala"
1035         g_assert (self->current_track == NULL);
1036 #line 65 "project.vala"
1037         number_of_attributes = attr_names_length1;
1038 #line 66 "project.vala"
1039         name = NULL;
1040 #line 67 "project.vala"
1041         type = NULL;
1042 #line 1024 "project.c"
1043         {
1044                 gint i;
1045 #line 68 "project.vala"
1046                 i = 0;
1047 #line 1029 "project.c"
1048                 {
1049                         gboolean _tmp0_;
1050 #line 68 "project.vala"
1051                         _tmp0_ = TRUE;
1052 #line 68 "project.vala"
1053                         while (TRUE) {
1054 #line 1036 "project.c"
1055                                 GQuark _tmp4_;
1056                                 const char* _tmp3_;
1057                                 static GQuark _tmp4__label0 = 0;
1058                                 static GQuark _tmp4__label1 = 0;
1059 #line 68 "project.vala"
1060                                 if (!_tmp0_) {
1061 #line 68 "project.vala"
1062                                         i = i + 1;
1063 #line 1045 "project.c"
1064                                 }
1065 #line 68 "project.vala"
1066                                 _tmp0_ = FALSE;
1067 #line 68 "project.vala"
1068                                 if (!(i < number_of_attributes)) {
1069 #line 68 "project.vala"
1070                                         break;
1071 #line 1053 "project.c"
1072                                 }
1073                                 _tmp3_ = attr_names[i];
1074                                 _tmp4_ = (NULL == _tmp3_) ? 0 : g_quark_from_string (_tmp3_);
1075                                 if (_tmp4_ == ((0 != _tmp4__label0) ? _tmp4__label0 : (_tmp4__label0 = g_quark_from_static_string ("type"))))
1076                                 switch (0) {
1077                                         default:
1078                                         {
1079                                                 char* _tmp1_;
1080 #line 71 "project.vala"
1081                                                 type = (_tmp1_ = g_strdup (attr_values[i]), _g_free0 (type), _tmp1_);
1082 #line 72 "project.vala"
1083                                                 break;
1084 #line 1066 "project.c"
1085                                         }
1086                                 } else if (_tmp4_ == ((0 != _tmp4__label1) ? _tmp4__label1 : (_tmp4__label1 = g_quark_from_static_string ("name"))))
1087                                 switch (0) {
1088                                         default:
1089                                         {
1090                                                 char* _tmp2_;
1091 #line 74 "project.vala"
1092                                                 name = (_tmp2_ = g_strdup (attr_values[i]), _g_free0 (name), _tmp2_);
1093 #line 75 "project.vala"
1094                                                 break;
1095 #line 1077 "project.c"
1096                                         }
1097                                 } else
1098                                 switch (0) {
1099                                         default:
1100                                         {
1101 #line 77 "project.vala"
1102                                                 break;
1103 #line 1085 "project.c"
1104                                         }
1105                                 }
1106                         }
1107                 }
1108         }
1109 #line 81 "project.vala"
1110         if (name == NULL) {
1111 #line 82 "project.vala"
1112                 g_signal_emit_by_name (MODEL_LOADER_HANDLER (self), "load-error", "Missing track name");
1113 #line 1095 "project.c"
1114                 result = FALSE;
1115                 _g_free0 (name);
1116                 _g_free0 (type);
1117 #line 83 "project.vala"
1118                 return result;
1119 #line 1101 "project.c"
1120         }
1121 #line 86 "project.vala"
1122         if (type == NULL) {
1123 #line 87 "project.vala"
1124                 g_signal_emit_by_name (MODEL_LOADER_HANDLER (self), "load-error", "Missing track type");
1125 #line 1107 "project.c"
1126                 result = FALSE;
1127                 _g_free0 (name);
1128                 _g_free0 (type);
1129 #line 88 "project.vala"
1130                 return result;
1131 #line 1113 "project.c"
1132         }
1133 #line 91 "project.vala"
1134         if (_vala_strcmp0 (type, "audio") == 0) {
1135 #line 1117 "project.c"
1136                 ModelAudioTrack* audio_track;
1137                 ModelTrack* _tmp5_;
1138 #line 92 "project.vala"
1139                 audio_track = model_audio_track_new (self->the_project, name);
1140 #line 93 "project.vala"
1141                 self->current_track = (_tmp5_ = _g_object_ref0 (MODEL_TRACK (audio_track)), _g_object_unref0 (self->current_track), _tmp5_);
1142 #line 94 "project.vala"
1143                 model_project_add_track (self->the_project, self->current_track);
1144 #line 1126 "project.c"
1145                 {
1146                         gint i;
1147 #line 96 "project.vala"
1148                         i = 0;
1149 #line 1131 "project.c"
1150                         {
1151                                 gboolean _tmp6_;
1152 #line 96 "project.vala"
1153                                 _tmp6_ = TRUE;
1154 #line 96 "project.vala"
1155                                 while (TRUE) {
1156 #line 1138 "project.c"
1157                                         GQuark _tmp8_;
1158                                         const char* _tmp7_;
1159                                         static GQuark _tmp8__label0 = 0;
1160                                         static GQuark _tmp8__label1 = 0;
1161                                         static GQuark _tmp8__label2 = 0;
1162 #line 96 "project.vala"
1163                                         if (!_tmp6_) {
1164 #line 96 "project.vala"
1165                                                 i = i + 1;
1166 #line 1148 "project.c"
1167                                         }
1168 #line 96 "project.vala"
1169                                         _tmp6_ = FALSE;
1170 #line 96 "project.vala"
1171                                         if (!(i < number_of_attributes)) {
1172 #line 96 "project.vala"
1173                                                 break;
1174 #line 1156 "project.c"
1175                                         }
1176                                         _tmp7_ = attr_names[i];
1177                                         _tmp8_ = (NULL == _tmp7_) ? 0 : g_quark_from_string (_tmp7_);
1178                                         if (_tmp8_ == ((0 != _tmp8__label0) ? _tmp8__label0 : (_tmp8__label0 = g_quark_from_static_string ("panorama"))))
1179                                         switch (0) {
1180                                                 default:
1181                                                 {
1182 #line 99 "project.vala"
1183                                                         _model_audio_track_set_pan (audio_track, g_ascii_strtod (attr_values[i], NULL));
1184 #line 100 "project.vala"
1185                                                         break;
1186 #line 1168 "project.c"
1187                                                 }
1188                                         } else if (_tmp8_ == ((0 != _tmp8__label1) ? _tmp8__label1 : (_tmp8__label1 = g_quark_from_static_string ("volume"))))
1189                                         switch (0) {
1190                                                 default:
1191                                                 {
1192 #line 102 "project.vala"
1193                                                         _model_audio_track_set_volume (audio_track, g_ascii_strtod (attr_values[i], NULL));
1194 #line 103 "project.vala"
1195                                                         break;
1196 #line 1178 "project.c"
1197                                                 }
1198                                         } else if (_tmp8_ == ((0 != _tmp8__label2) ? _tmp8__label2 : (_tmp8__label2 = g_quark_from_static_string ("channels"))))
1199                                         switch (0) {
1200                                                 default:
1201                                                 {
1202 #line 105 "project.vala"
1203                                                         model_audio_track_set_default_num_channels (audio_track, atoi (attr_values[i]));
1204 #line 106 "project.vala"
1205                                                         break;
1206 #line 1188 "project.c"
1207                                                 }
1208                                         } else
1209                                         switch (0) {
1210                                                 default:
1211                                                 {
1212 #line 108 "project.vala"
1213                                                         break;
1214 #line 1196 "project.c"
1215                                                 }
1216                                         }
1217                                 }
1218                         }
1219                 }
1220                 result = TRUE;
1221                 _g_object_unref0 (audio_track);
1222                 _g_free0 (name);
1223                 _g_free0 (type);
1224 #line 111 "project.vala"
1225                 return result;
1226 #line 1208 "project.c"
1227         } else {
1228 #line 112 "project.vala"
1229                 if (_vala_strcmp0 (type, "video") == 0) {
1230 #line 1212 "project.c"
1231                         ModelTrack* _tmp9_;
1232 #line 113 "project.vala"
1233                         self->current_track = (_tmp9_ = MODEL_TRACK (model_video_track_new (self->the_project)), _g_object_unref0 (self->current_track), _tmp9_);
1234 #line 114 "project.vala"
1235                         model_project_add_track (self->the_project, self->current_track);
1236 #line 1218 "project.c"
1237                 }
1238         }
1239         result = MODEL_LOADER_HANDLER_CLASS (model_media_loader_handler_parent_class)->commit_track (MODEL_LOADER_HANDLER (self), attr_names, attr_names_length1, attr_values, attr_values_length1);
1240         _g_free0 (name);
1241         _g_free0 (type);
1242 #line 117 "project.vala"
1243         return result;
1244 #line 1226 "project.c"
1245 }
1246
1247
1248 #line 120 "project.vala"
1249 static void model_media_loader_handler_real_leave_track (ModelLoaderHandler* base) {
1250 #line 1232 "project.c"
1251         ModelMediaLoaderHandler * self;
1252         ModelTrack* _tmp0_;
1253         self = MODEL_MEDIA_LOADER_HANDLER (base);
1254 #line 121 "project.vala"
1255         g_assert (self->current_track != NULL);
1256 #line 122 "project.vala"
1257         self->current_track = (_tmp0_ = NULL, _g_object_unref0 (self->current_track), _tmp0_);
1258 #line 1240 "project.c"
1259 }
1260
1261
1262 #line 125 "project.vala"
1263 static gboolean model_media_loader_handler_real_commit_clip (ModelLoaderHandler* base, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1) {
1264 #line 1246 "project.c"
1265         ModelMediaLoaderHandler * self;
1266         gboolean result = FALSE;
1267         gint number_of_attributes;
1268         gint id;
1269         char* clip_name;
1270         gint64 start;
1271         gint64 media_start;
1272         gint64 duration;
1273         ModelClipFetcher* _tmp6_;
1274         ModelClip* _tmp7_;
1275         ModelClip* clip;
1276         self = MODEL_MEDIA_LOADER_HANDLER (base);
1277 #line 126 "project.vala"
1278         g_assert (self->current_track != NULL);
1279 #line 128 "project.vala"
1280         number_of_attributes = attr_names_length1;
1281 #line 129 "project.vala"
1282         id = -1;
1283 #line 130 "project.vala"
1284         clip_name = NULL;
1285 #line 131 "project.vala"
1286         start = (gint64) (-1);
1287 #line 132 "project.vala"
1288         media_start = (gint64) (-1);
1289 #line 133 "project.vala"
1290         duration = (gint64) (-1);
1291 #line 1273 "project.c"
1292         {
1293                 gint i;
1294 #line 134 "project.vala"
1295                 i = 0;
1296 #line 1278 "project.c"
1297                 {
1298                         gboolean _tmp0_;
1299 #line 134 "project.vala"
1300                         _tmp0_ = TRUE;
1301 #line 134 "project.vala"
1302                         while (TRUE) {
1303 #line 1285 "project.c"
1304                                 GQuark _tmp4_;
1305                                 const char* _tmp3_;
1306                                 static GQuark _tmp4__label0 = 0;
1307                                 static GQuark _tmp4__label1 = 0;
1308                                 static GQuark _tmp4__label2 = 0;
1309                                 static GQuark _tmp4__label3 = 0;
1310                                 static GQuark _tmp4__label4 = 0;
1311 #line 134 "project.vala"
1312                                 if (!_tmp0_) {
1313 #line 134 "project.vala"
1314                                         i++;
1315 #line 1297 "project.c"
1316                                 }
1317 #line 134 "project.vala"
1318                                 _tmp0_ = FALSE;
1319 #line 134 "project.vala"
1320                                 if (!(i < number_of_attributes)) {
1321 #line 134 "project.vala"
1322                                         break;
1323 #line 1305 "project.c"
1324                                 }
1325                                 _tmp3_ = attr_names[i];
1326                                 _tmp4_ = (NULL == _tmp3_) ? 0 : g_quark_from_string (_tmp3_);
1327                                 if (_tmp4_ == ((0 != _tmp4__label0) ? _tmp4__label0 : (_tmp4__label0 = g_quark_from_static_string ("id"))))
1328                                 switch (0) {
1329                                         default:
1330                                         {
1331 #line 137 "project.vala"
1332                                                 id = atoi (attr_values[i]);
1333 #line 138 "project.vala"
1334                                                 break;
1335 #line 1317 "project.c"
1336                                         }
1337                                 } else if (_tmp4_ == ((0 != _tmp4__label1) ? _tmp4__label1 : (_tmp4__label1 = g_quark_from_static_string ("name"))))
1338                                 switch (0) {
1339                                         default:
1340                                         {
1341                                                 char* _tmp1_;
1342 #line 140 "project.vala"
1343                                                 clip_name = (_tmp1_ = g_strdup (attr_values[i]), _g_free0 (clip_name), _tmp1_);
1344 #line 141 "project.vala"
1345                                                 break;
1346 #line 1328 "project.c"
1347                                         }
1348                                 } else if (_tmp4_ == ((0 != _tmp4__label2) ? _tmp4__label2 : (_tmp4__label2 = g_quark_from_static_string ("start"))))
1349                                 switch (0) {
1350                                         default:
1351                                         {
1352 #line 143 "project.vala"
1353                                                 start = g_ascii_strtoll (attr_values[i], NULL, 0);
1354 #line 144 "project.vala"
1355                                                 break;
1356 #line 1338 "project.c"
1357                                         }
1358                                 } else if (_tmp4_ == ((0 != _tmp4__label3) ? _tmp4__label3 : (_tmp4__label3 = g_quark_from_static_string ("media-start"))))
1359                                 switch (0) {
1360                                         default:
1361                                         {
1362 #line 146 "project.vala"
1363                                                 media_start = g_ascii_strtoll (attr_values[i], NULL, 0);
1364 #line 147 "project.vala"
1365                                                 break;
1366 #line 1348 "project.c"
1367                                         }
1368                                 } else if (_tmp4_ == ((0 != _tmp4__label4) ? _tmp4__label4 : (_tmp4__label4 = g_quark_from_static_string ("duration"))))
1369                                 switch (0) {
1370                                         default:
1371                                         {
1372 #line 149 "project.vala"
1373                                                 duration = g_ascii_strtoll (attr_values[i], NULL, 0);
1374 #line 150 "project.vala"
1375                                                 break;
1376 #line 1358 "project.c"
1377                                         }
1378                                 } else
1379                                 switch (0) {
1380                                         default:
1381                                         {
1382                                                 char* _tmp2_;
1383 #line 153 "project.vala"
1384                                                 g_signal_emit_by_name (MODEL_LOADER_HANDLER (self), "load-error", _tmp2_ = g_strdup_printf ("Unknown attribute %s", attr_names[i]));
1385 #line 1367 "project.c"
1386                                                 _g_free0 (_tmp2_);
1387                                                 result = FALSE;
1388                                                 _g_free0 (clip_name);
1389 #line 154 "project.vala"
1390                                                 return result;
1391 #line 1373 "project.c"
1392                                         }
1393                                 }
1394                         }
1395                 }
1396         }
1397 #line 158 "project.vala"
1398         if (id == (-1)) {
1399 #line 159 "project.vala"
1400                 g_signal_emit_by_name (MODEL_LOADER_HANDLER (self), "load-error", "missing clip id");
1401 #line 1383 "project.c"
1402                 result = FALSE;
1403                 _g_free0 (clip_name);
1404 #line 160 "project.vala"
1405                 return result;
1406 #line 1388 "project.c"
1407         }
1408 #line 163 "project.vala"
1409         if (clip_name == NULL) {
1410 #line 164 "project.vala"
1411                 g_signal_emit_by_name (MODEL_LOADER_HANDLER (self), "load-error", "missing clip_name");
1412 #line 1394 "project.c"
1413                 result = FALSE;
1414                 _g_free0 (clip_name);
1415 #line 165 "project.vala"
1416                 return result;
1417 #line 1399 "project.c"
1418         }
1419 #line 168 "project.vala"
1420         if (start == (-1)) {
1421 #line 169 "project.vala"
1422                 g_signal_emit_by_name (MODEL_LOADER_HANDLER (self), "load-error", "missing start time");
1423 #line 1405 "project.c"
1424                 result = FALSE;
1425                 _g_free0 (clip_name);
1426 #line 170 "project.vala"
1427                 return result;
1428 #line 1410 "project.c"
1429         }
1430 #line 173 "project.vala"
1431         if (media_start == (-1)) {
1432 #line 174 "project.vala"
1433                 g_signal_emit_by_name (MODEL_LOADER_HANDLER (self), "load-error", "missing media_start");
1434 #line 1416 "project.c"
1435                 result = FALSE;
1436                 _g_free0 (clip_name);
1437 #line 175 "project.vala"
1438                 return result;
1439 #line 1421 "project.c"
1440         }
1441 #line 178 "project.vala"
1442         if (duration == (-1)) {
1443 #line 179 "project.vala"
1444                 g_signal_emit_by_name (MODEL_LOADER_HANDLER (self), "load-error", "missing duration");
1445 #line 1427 "project.c"
1446                 result = FALSE;
1447                 _g_free0 (clip_name);
1448 #line 180 "project.vala"
1449                 return result;
1450 #line 1432 "project.c"
1451         }
1452 #line 183 "project.vala"
1453         if (id >= gee_collection_get_size (GEE_COLLECTION (self->priv->clipfetchers))) {
1454 #line 1436 "project.c"
1455                 char* _tmp5_;
1456 #line 184 "project.vala"
1457                 g_signal_emit_by_name (MODEL_LOADER_HANDLER (self), "load-error", _tmp5_ = g_strdup_printf ("clip file id %s was not loaded", clip_name));
1458 #line 1440 "project.c"
1459                 _g_free0 (_tmp5_);
1460                 result = FALSE;
1461                 _g_free0 (clip_name);
1462 #line 185 "project.vala"
1463                 return result;
1464 #line 1446 "project.c"
1465         }
1466 #line 188 "project.vala"
1467         clip = (_tmp7_ = model_clip_new (MODEL_FETCHER (_tmp6_ = (ModelClipFetcher*) gee_abstract_list_get (GEE_ABSTRACT_LIST (self->priv->clipfetchers), id))->clipfile, model_track_media_type (self->current_track), clip_name, start, media_start, duration, FALSE), _g_object_unref0 (_tmp6_), _tmp7_);
1468 #line 190 "project.vala"
1469         model_track_add (self->current_track, clip, start, FALSE);
1470 #line 1452 "project.c"
1471         result = TRUE;
1472         _g_free0 (clip_name);
1473         _g_object_unref0 (clip);
1474 #line 191 "project.vala"
1475         return result;
1476 #line 1458 "project.c"
1477 }
1478
1479
1480 #line 194 "project.vala"
1481 static void model_media_loader_handler_fetcher_ready (ModelMediaLoaderHandler* self, ModelFetcher* f) {
1482 #line 194 "project.vala"
1483         g_return_if_fail (MODEL_IS_MEDIA_LOADER_HANDLER (self));
1484 #line 194 "project.vala"
1485         g_return_if_fail (MODEL_IS_FETCHER (f));
1486 #line 195 "project.vala"
1487         logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "fetcher_ready");
1488 #line 196 "project.vala"
1489         if (f->error_string != NULL) {
1490 #line 1472 "project.c"
1491                 char* _tmp0_;
1492 #line 197 "project.vala"
1493                 g_signal_emit_by_name (MODEL_LOADER_HANDLER (self), "load-error", _tmp0_ = g_strdup_printf ("Could not load %s.", f->clipfile->filename));
1494 #line 1476 "project.c"
1495                 _g_free0 (_tmp0_);
1496 #line 198 "project.vala"
1497                 g_warning ("project.vala:198: Could not load %s: %s", f->clipfile->filename, f->error_string);
1498 #line 1480 "project.c"
1499         }
1500 #line 200 "project.vala"
1501         model_project_add_clipfile (self->the_project, f->clipfile);
1502 #line 201 "project.vala"
1503         self->priv->num_clipfiles_complete++;
1504 #line 202 "project.vala"
1505         if (self->priv->num_clipfiles_complete == gee_collection_get_size (GEE_COLLECTION (self->priv->clipfetchers))) {
1506 #line 203 "project.vala"
1507                 g_signal_emit_by_name (MODEL_LOADER_HANDLER (self), "complete");
1508 #line 1490 "project.c"
1509         }
1510 }
1511
1512
1513 #line 194 "project.vala"
1514 static void _model_media_loader_handler_fetcher_ready_model_fetcher_ready (ModelFetcher* _sender, ModelFetcher* fetcher, gpointer self) {
1515 #line 1497 "project.c"
1516         model_media_loader_handler_fetcher_ready (self, fetcher);
1517 }
1518
1519
1520 #line 207 "project.vala"
1521 static gboolean model_media_loader_handler_real_commit_clipfile (ModelLoaderHandler* base, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1) {
1522 #line 1504 "project.c"
1523         ModelMediaLoaderHandler * self;
1524         gboolean result = FALSE;
1525         GError * _inner_error_;
1526         char* filename;
1527         gint id;
1528         self = MODEL_MEDIA_LOADER_HANDLER (base);
1529         _inner_error_ = NULL;
1530 #line 208 "project.vala"
1531         filename = NULL;
1532 #line 209 "project.vala"
1533         id = -1;
1534 #line 1516 "project.c"
1535         {
1536                 gint i;
1537 #line 211 "project.vala"
1538                 i = 0;
1539 #line 1521 "project.c"
1540                 {
1541                         gboolean _tmp0_;
1542 #line 211 "project.vala"
1543                         _tmp0_ = TRUE;
1544 #line 211 "project.vala"
1545                         while (TRUE) {
1546 #line 211 "project.vala"
1547                                 if (!_tmp0_) {
1548 #line 211 "project.vala"
1549                                         i++;
1550 #line 1532 "project.c"
1551                                 }
1552 #line 211 "project.vala"
1553                                 _tmp0_ = FALSE;
1554 #line 211 "project.vala"
1555                                 if (!(i < attr_names_length1)) {
1556 #line 211 "project.vala"
1557                                         break;
1558 #line 1540 "project.c"
1559                                 }
1560 #line 212 "project.vala"
1561                                 if (_vala_strcmp0 (attr_names[i], "filename") == 0) {
1562 #line 1544 "project.c"
1563                                         char* _tmp1_;
1564 #line 213 "project.vala"
1565                                         filename = (_tmp1_ = g_strdup (attr_values[i]), _g_free0 (filename), _tmp1_);
1566 #line 1548 "project.c"
1567                                 } else {
1568 #line 214 "project.vala"
1569                                         if (_vala_strcmp0 (attr_names[i], "id") == 0) {
1570 #line 215 "project.vala"
1571                                                 id = atoi (attr_values[i]);
1572 #line 1554 "project.c"
1573                                         }
1574                                 }
1575                         }
1576                 }
1577         }
1578 #line 219 "project.vala"
1579         if (filename == NULL) {
1580 #line 220 "project.vala"
1581                 g_signal_emit_by_name (MODEL_LOADER_HANDLER (self), "load-error", "Invalid clipfile filename");
1582 #line 1564 "project.c"
1583                 result = FALSE;
1584                 _g_free0 (filename);
1585 #line 221 "project.vala"
1586                 return result;
1587 #line 1569 "project.c"
1588         }
1589 #line 224 "project.vala"
1590         if (id < 0) {
1591 #line 225 "project.vala"
1592                 g_signal_emit_by_name (MODEL_LOADER_HANDLER (self), "load-error", "Invalid clipfile id");
1593 #line 1575 "project.c"
1594                 result = FALSE;
1595                 _g_free0 (filename);
1596 #line 226 "project.vala"
1597                 return result;
1598 #line 1580 "project.c"
1599         }
1600         {
1601                 ModelClipFetcher* fetcher;
1602 #line 230 "project.vala"
1603                 fetcher = model_clip_fetcher_new (filename, &_inner_error_);
1604 #line 1586 "project.c"
1605                 if (_inner_error_ != NULL) {
1606                         goto __catch14_g_error;
1607                 }
1608 #line 231 "project.vala"
1609                 g_signal_connect_object (MODEL_FETCHER (fetcher), "ready", (GCallback) _model_media_loader_handler_fetcher_ready_model_fetcher_ready, self, 0);
1610 #line 232 "project.vala"
1611                 gee_abstract_list_insert (GEE_ABSTRACT_LIST (self->priv->clipfetchers), id, fetcher);
1612 #line 1594 "project.c"
1613                 _g_object_unref0 (fetcher);
1614         }
1615         goto __finally14;
1616         __catch14_g_error:
1617         {
1618                 GError * e;
1619                 e = _inner_error_;
1620                 _inner_error_ = NULL;
1621                 {
1622 #line 234 "project.vala"
1623                         g_signal_emit_by_name (MODEL_LOADER_HANDLER (self), "load-error", e->message);
1624 #line 1606 "project.c"
1625                         result = FALSE;
1626                         _g_error_free0 (e);
1627                         _g_free0 (filename);
1628 #line 235 "project.vala"
1629                         return result;
1630 #line 1612 "project.c"
1631                 }
1632         }
1633         __finally14:
1634         if (_inner_error_ != NULL) {
1635                 _g_free0 (filename);
1636                 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);
1637                 g_clear_error (&_inner_error_);
1638                 return FALSE;
1639         }
1640         result = TRUE;
1641         _g_free0 (filename);
1642 #line 237 "project.vala"
1643         return result;
1644 #line 1626 "project.c"
1645 }
1646
1647
1648 #line 240 "project.vala"
1649 static gboolean model_media_loader_handler_real_commit_tempo_entry (ModelLoaderHandler* base, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1) {
1650 #line 1632 "project.c"
1651         ModelMediaLoaderHandler * self;
1652         gboolean result = FALSE;
1653         self = MODEL_MEDIA_LOADER_HANDLER (base);
1654 #line 241 "project.vala"
1655         if (_vala_strcmp0 (attr_names[0], "tempo") != 0) {
1656 #line 242 "project.vala"
1657                 g_signal_emit_by_name (MODEL_LOADER_HANDLER (self), "load-error", "Invalid attribute on tempo entry");
1658 #line 1640 "project.c"
1659                 result = FALSE;
1660 #line 243 "project.vala"
1661                 return result;
1662 #line 1644 "project.c"
1663         }
1664 #line 246 "project.vala"
1665         _model_project_set_bpm (self->the_project, atoi (attr_values[0]));
1666 #line 1648 "project.c"
1667         result = TRUE;
1668 #line 247 "project.vala"
1669         return result;
1670 #line 1652 "project.c"
1671 }
1672
1673
1674 #line 250 "project.vala"
1675 static gboolean model_media_loader_handler_real_commit_time_signature_entry (ModelLoaderHandler* base, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1) {
1676 #line 1658 "project.c"
1677         ModelMediaLoaderHandler * self;
1678         gboolean result = FALSE;
1679         Fraction _tmp1_;
1680         Fraction _tmp0_ = {0};
1681         self = MODEL_MEDIA_LOADER_HANDLER (base);
1682 #line 251 "project.vala"
1683         if (_vala_strcmp0 (attr_names[0], "signature") != 0) {
1684 #line 252 "project.vala"
1685                 g_signal_emit_by_name (MODEL_LOADER_HANDLER (self), "load-error", "Invalid attribute on time signature");
1686 #line 1668 "project.c"
1687                 result = FALSE;
1688 #line 253 "project.vala"
1689                 return result;
1690 #line 1672 "project.c"
1691         }
1692 #line 256 "project.vala"
1693         _model_project_set_time_signature (self->the_project, (_tmp1_ = (fraction_init_from_string (&_tmp0_, attr_values[0]), _tmp0_), &_tmp1_));
1694 #line 1676 "project.c"
1695         result = TRUE;
1696 #line 257 "project.vala"
1697         return result;
1698 #line 1680 "project.c"
1699 }
1700
1701
1702 #line 260 "project.vala"
1703 static gboolean model_media_loader_handler_real_commit_click (ModelLoaderHandler* base, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1) {
1704 #line 1686 "project.c"
1705         ModelMediaLoaderHandler * self;
1706         gboolean result = FALSE;
1707         self = MODEL_MEDIA_LOADER_HANDLER (base);
1708         {
1709                 gint i;
1710 #line 261 "project.vala"
1711                 i = 0;
1712 #line 1694 "project.c"
1713                 {
1714                         gboolean _tmp0_;
1715 #line 261 "project.vala"
1716                         _tmp0_ = TRUE;
1717 #line 261 "project.vala"
1718                         while (TRUE) {
1719 #line 1701 "project.c"
1720                                 GQuark _tmp3_;
1721                                 const char* _tmp2_;
1722                                 static GQuark _tmp3__label0 = 0;
1723                                 static GQuark _tmp3__label1 = 0;
1724                                 static GQuark _tmp3__label2 = 0;
1725 #line 261 "project.vala"
1726                                 if (!_tmp0_) {
1727 #line 261 "project.vala"
1728                                         i = i + 1;
1729 #line 1711 "project.c"
1730                                 }
1731 #line 261 "project.vala"
1732                                 _tmp0_ = FALSE;
1733 #line 261 "project.vala"
1734                                 if (!(i < attr_names_length1)) {
1735 #line 261 "project.vala"
1736                                         break;
1737 #line 1719 "project.c"
1738                                 }
1739                                 _tmp2_ = attr_names[i];
1740                                 _tmp3_ = (NULL == _tmp2_) ? 0 : g_quark_from_string (_tmp2_);
1741                                 if (_tmp3_ == ((0 != _tmp3__label0) ? _tmp3__label0 : (_tmp3__label0 = g_quark_from_static_string ("on_play"))))
1742                                 switch (0) {
1743                                         default:
1744                                         {
1745 #line 264 "project.vala"
1746                                                 self->the_project->click_during_play = _vala_strcmp0 (attr_values[i], "true") == 0;
1747 #line 265 "project.vala"
1748                                                 break;
1749 #line 1731 "project.c"
1750                                         }
1751                                 } else if (_tmp3_ == ((0 != _tmp3__label1) ? _tmp3__label1 : (_tmp3__label1 = g_quark_from_static_string ("on_record"))))
1752                                 switch (0) {
1753                                         default:
1754                                         {
1755 #line 267 "project.vala"
1756                                                 self->the_project->click_during_record = _vala_strcmp0 (attr_values[i], "true") == 0;
1757 #line 268 "project.vala"
1758                                                 break;
1759 #line 1741 "project.c"
1760                                         }
1761                                 } else if (_tmp3_ == ((0 != _tmp3__label2) ? _tmp3__label2 : (_tmp3__label2 = g_quark_from_static_string ("volume"))))
1762                                 switch (0) {
1763                                         default:
1764                                         {
1765 #line 270 "project.vala"
1766                                                 self->the_project->click_volume = g_ascii_strtod (attr_values[i], NULL);
1767 #line 271 "project.vala"
1768                                                 break;
1769 #line 1751 "project.c"
1770                                         }
1771                                 } else
1772                                 switch (0) {
1773                                         default:
1774                                         {
1775                                                 char* _tmp1_;
1776 #line 273 "project.vala"
1777                                                 g_signal_emit_by_name (MODEL_LOADER_HANDLER (self), "load-error", _tmp1_ = g_strdup_printf ("unknown attribute for click '%s'", attr_names[i]));
1778 #line 1760 "project.c"
1779                                                 _g_free0 (_tmp1_);
1780                                                 result = FALSE;
1781 #line 274 "project.vala"
1782                                                 return result;
1783 #line 1765 "project.c"
1784                                         }
1785                                 }
1786                         }
1787                 }
1788         }
1789         result = TRUE;
1790 #line 277 "project.vala"
1791         return result;
1792 #line 1774 "project.c"
1793 }
1794
1795
1796 #line 280 "project.vala"
1797 static gboolean model_media_loader_handler_real_commit_library_preference (ModelLoaderHandler* base, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1) {
1798 #line 1780 "project.c"
1799         ModelMediaLoaderHandler * self;
1800         gboolean result = FALSE;
1801         self = MODEL_MEDIA_LOADER_HANDLER (base);
1802         {
1803                 gint i;
1804 #line 281 "project.vala"
1805                 i = 0;
1806 #line 1788 "project.c"
1807                 {
1808                         gboolean _tmp0_;
1809 #line 281 "project.vala"
1810                         _tmp0_ = TRUE;
1811 #line 281 "project.vala"
1812                         while (TRUE) {
1813 #line 1795 "project.c"
1814                                 GQuark _tmp3_;
1815                                 const char* _tmp2_;
1816                                 static GQuark _tmp3__label0 = 0;
1817                                 static GQuark _tmp3__label1 = 0;
1818 #line 281 "project.vala"
1819                                 if (!_tmp0_) {
1820 #line 281 "project.vala"
1821                                         i = i + 1;
1822 #line 1804 "project.c"
1823                                 }
1824 #line 281 "project.vala"
1825                                 _tmp0_ = FALSE;
1826 #line 281 "project.vala"
1827                                 if (!(i < attr_names_length1)) {
1828 #line 281 "project.vala"
1829                                         break;
1830 #line 1812 "project.c"
1831                                 }
1832                                 _tmp2_ = attr_names[i];
1833                                 _tmp3_ = (NULL == _tmp2_) ? 0 : g_quark_from_string (_tmp2_);
1834                                 if (_tmp3_ == ((0 != _tmp3__label0) ? _tmp3__label0 : (_tmp3__label0 = g_quark_from_static_string ("width"))))
1835                                 switch (0) {
1836                                         default:
1837                                         {
1838 #line 284 "project.vala"
1839                                                 self->the_project->library_width = atoi (attr_values[i]);
1840 #line 285 "project.vala"
1841                                                 break;
1842 #line 1824 "project.c"
1843                                         }
1844                                 } else if (_tmp3_ == ((0 != _tmp3__label1) ? _tmp3__label1 : (_tmp3__label1 = g_quark_from_static_string ("visible"))))
1845                                 switch (0) {
1846                                         default:
1847                                         {
1848 #line 287 "project.vala"
1849                                                 self->the_project->library_visible = _vala_strcmp0 (attr_values[i], "true") == 0;
1850 #line 288 "project.vala"
1851                                                 break;
1852 #line 1834 "project.c"
1853                                         }
1854                                 } else
1855                                 switch (0) {
1856                                         default:
1857                                         {
1858                                                 char* _tmp1_;
1859 #line 290 "project.vala"
1860                                                 g_signal_emit_by_name (MODEL_LOADER_HANDLER (self), "load-error", _tmp1_ = g_strdup_printf ("unknown attribute for library '%s'", attr_names[i]));
1861 #line 1843 "project.c"
1862                                                 _g_free0 (_tmp1_);
1863                                                 result = FALSE;
1864 #line 291 "project.vala"
1865                                                 return result;
1866 #line 1848 "project.c"
1867                                         }
1868                                 }
1869                         }
1870                 }
1871         }
1872         result = TRUE;
1873 #line 294 "project.vala"
1874         return result;
1875 #line 1857 "project.c"
1876 }
1877
1878
1879 #line 297 "project.vala"
1880 static void model_media_loader_handler_real_leave_library (ModelLoaderHandler* base) {
1881 #line 1863 "project.c"
1882         ModelMediaLoaderHandler * self;
1883         self = MODEL_MEDIA_LOADER_HANDLER (base);
1884 #line 298 "project.vala"
1885         if (gee_collection_get_size (GEE_COLLECTION (self->priv->clipfetchers)) == 0) {
1886 #line 299 "project.vala"
1887                 g_signal_emit_by_name (MODEL_LOADER_HANDLER (self), "complete");
1888 #line 1870 "project.c"
1889         }
1890 }
1891
1892
1893 static void model_media_loader_handler_class_init (ModelMediaLoaderHandlerClass * klass) {
1894         model_media_loader_handler_parent_class = g_type_class_peek_parent (klass);
1895         g_type_class_add_private (klass, sizeof (ModelMediaLoaderHandlerPrivate));
1896         MODEL_LOADER_HANDLER_CLASS (klass)->commit_marina = model_media_loader_handler_real_commit_marina;
1897         MODEL_LOADER_HANDLER_CLASS (klass)->commit_library = model_media_loader_handler_real_commit_library;
1898         MODEL_LOADER_HANDLER_CLASS (klass)->commit_track = model_media_loader_handler_real_commit_track;
1899         MODEL_LOADER_HANDLER_CLASS (klass)->leave_track = model_media_loader_handler_real_leave_track;
1900         MODEL_LOADER_HANDLER_CLASS (klass)->commit_clip = model_media_loader_handler_real_commit_clip;
1901         MODEL_LOADER_HANDLER_CLASS (klass)->commit_clipfile = model_media_loader_handler_real_commit_clipfile;
1902         MODEL_LOADER_HANDLER_CLASS (klass)->commit_tempo_entry = model_media_loader_handler_real_commit_tempo_entry;
1903         MODEL_LOADER_HANDLER_CLASS (klass)->commit_time_signature_entry = model_media_loader_handler_real_commit_time_signature_entry;
1904         MODEL_LOADER_HANDLER_CLASS (klass)->commit_click = model_media_loader_handler_real_commit_click;
1905         MODEL_LOADER_HANDLER_CLASS (klass)->commit_library_preference = model_media_loader_handler_real_commit_library_preference;
1906         MODEL_LOADER_HANDLER_CLASS (klass)->leave_library = model_media_loader_handler_real_leave_library;
1907         G_OBJECT_CLASS (klass)->finalize = model_media_loader_handler_finalize;
1908 }
1909
1910
1911 static void model_media_loader_handler_instance_init (ModelMediaLoaderHandler * self) {
1912         self->priv = MODEL_MEDIA_LOADER_HANDLER_GET_PRIVATE (self);
1913         self->priv->clipfetchers = gee_array_list_new (MODEL_TYPE_CLIP_FETCHER, (GBoxedCopyFunc) g_object_ref, g_object_unref, NULL);
1914 }
1915
1916
1917 static void model_media_loader_handler_finalize (GObject* obj) {
1918         ModelMediaLoaderHandler * self;
1919         self = MODEL_MEDIA_LOADER_HANDLER (obj);
1920         _g_object_unref0 (self->current_track);
1921         _g_object_unref0 (self->priv->clipfetchers);
1922         G_OBJECT_CLASS (model_media_loader_handler_parent_class)->finalize (obj);
1923 }
1924
1925
1926 GType model_media_loader_handler_get_type (void) {
1927         static volatile gsize model_media_loader_handler_type_id__volatile = 0;
1928         if (g_once_init_enter (&model_media_loader_handler_type_id__volatile)) {
1929                 static const GTypeInfo g_define_type_info = { sizeof (ModelMediaLoaderHandlerClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) model_media_loader_handler_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ModelMediaLoaderHandler), 0, (GInstanceInitFunc) model_media_loader_handler_instance_init, NULL };
1930                 GType model_media_loader_handler_type_id;
1931                 model_media_loader_handler_type_id = g_type_register_static (MODEL_TYPE_LOADER_HANDLER, "ModelMediaLoaderHandler", &g_define_type_info, 0);
1932                 g_once_init_leave (&model_media_loader_handler_type_id__volatile, model_media_loader_handler_type_id);
1933         }
1934         return model_media_loader_handler_type_id__volatile;
1935 }
1936
1937
1938 #line 383 "project.vala"
1939 static void model_project_real_get_clip_time (ModelProject* self, ModelClipFile* f, TimeCode* result) {
1940 #line 1922 "project.c"
1941         g_return_if_fail (MODEL_IS_PROJECT (self));
1942         g_critical ("Type `%s' does not implement abstract method `model_project_get_clip_time'", g_type_name (G_TYPE_FROM_INSTANCE (self)));
1943         return;
1944 }
1945
1946
1947 #line 383 "project.vala"
1948 void model_project_get_clip_time (ModelProject* self, ModelClipFile* f, TimeCode* result) {
1949 #line 383 "project.vala"
1950         MODEL_PROJECT_GET_CLASS (self)->get_clip_time (self, f, result);
1951 #line 1933 "project.c"
1952 }
1953
1954
1955 #line 1145 "MediaEngine.vala"
1956 static void _view_media_engine_on_track_added_model_project_track_added (ModelProject* _sender, ModelTrack* track, gpointer self) {
1957 #line 1939 "project.c"
1958         view_media_engine_on_track_added (self, track);
1959 }
1960
1961
1962 #line 397 "project.vala"
1963 static void _model_project_on_playstate_changed_view_media_engine_playstate_changed (ViewMediaEngine* _sender, gpointer self) {
1964 #line 1946 "project.c"
1965         model_project_on_playstate_changed (self);
1966 }
1967
1968
1969 #line 924 "project.vala"
1970 static void _model_project_on_error_occurred_view_media_engine_error_occurred (ViewMediaEngine* _sender, const char* major_message, const char* minor_message, gpointer self) {
1971 #line 1953 "project.c"
1972         model_project_on_error_occurred (self, major_message, minor_message);
1973 }
1974
1975
1976 #line 385 "project.vala"
1977 ModelProject* model_project_construct (GType object_type, const char* filename, gboolean include_video, GError** error) {
1978 #line 1960 "project.c"
1979         GError * _inner_error_;
1980         ModelProject * self;
1981         ModelUndoManager* _tmp0_;
1982         char* _tmp1_;
1983         ViewMediaEngine* _tmp2_;
1984         ViewMediaEngine* _tmp3_;
1985         _inner_error_ = NULL;
1986 #line 385 "project.vala"
1987         self = (ModelProject*) g_object_new (object_type, NULL);
1988 #line 386 "project.vala"
1989         self->undo_manager = (_tmp0_ = model_undo_manager_new (), _model_undo_manager_unref0 (self->undo_manager), _tmp0_);
1990 #line 387 "project.vala"
1991         self->project_file = (_tmp1_ = g_strdup (filename), _g_free0 (self->project_file), _tmp1_);
1992 #line 389 "project.vala"
1993         _tmp2_ = view_media_engine_new (self, include_video, &_inner_error_);
1994 #line 1976 "project.c"
1995         if (_inner_error_ != NULL) {
1996                 g_propagate_error (error, _inner_error_);
1997                 g_object_unref (self);
1998                 return NULL;
1999         }
2000 #line 389 "project.vala"
2001         self->media_engine = (_tmp3_ = _tmp2_, _g_object_unref0 (self->media_engine), _tmp3_);
2002 #line 390 "project.vala"
2003         g_signal_connect_object (self, "track-added", (GCallback) _view_media_engine_on_track_added_model_project_track_added, self->media_engine, 0);
2004 #line 391 "project.vala"
2005         g_signal_connect_object (self->media_engine, "playstate-changed", (GCallback) _model_project_on_playstate_changed_view_media_engine_playstate_changed, self, 0);
2006 #line 392 "project.vala"
2007         g_signal_connect_object (self->media_engine, "error-occurred", (GCallback) _model_project_on_error_occurred_view_media_engine_error_occurred, self, 0);
2008 #line 394 "project.vala"
2009         model_project_set_default_framerate (self, &model_project_INVALID_FRAME_RATE);
2010 #line 1992 "project.c"
2011         return self;
2012 }
2013
2014
2015 #line 397 "project.vala"
2016 void model_project_on_playstate_changed (ModelProject* self) {
2017 #line 397 "project.vala"
2018         g_return_if_fail (MODEL_IS_PROJECT (self));
2019 #line 398 "project.vala"
2020         logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_playstate_changed");
2021 #line 399 "project.vala"
2022         switch (view_media_engine_get_play_state (self->media_engine)) {
2023 #line 2005 "project.c"
2024                 case PLAY_STATE_STOPPED:
2025                 {
2026 #line 401 "project.vala"
2027                         model_project_ClearTrackMeters (self);
2028 #line 402 "project.vala"
2029                         break;
2030 #line 2012 "project.c"
2031                 }
2032                 case PLAY_STATE_CLOSED:
2033                 {
2034 #line 404 "project.vala"
2035                         g_signal_emit_by_name (self, "closed");
2036 #line 405 "project.vala"
2037                         break;
2038 #line 2020 "project.c"
2039                 }
2040         }
2041 #line 407 "project.vala"
2042         g_signal_emit_by_name (self, "playstate-changed", view_media_engine_get_play_state (self->media_engine));
2043 #line 2025 "project.c"
2044 }
2045
2046
2047 #line 410 "project.vala"
2048 static char* model_project_real_get_project_file (ModelProject* self) {
2049 #line 2031 "project.c"
2050         char* result = NULL;
2051 #line 410 "project.vala"
2052         g_return_val_if_fail (MODEL_IS_PROJECT (self), NULL);
2053 #line 2035 "project.c"
2054         result = g_strdup (self->project_file);
2055 #line 411 "project.vala"
2056         return result;
2057 #line 2039 "project.c"
2058 }
2059
2060
2061 #line 410 "project.vala"
2062 char* model_project_get_project_file (ModelProject* self) {
2063 #line 410 "project.vala"
2064         return MODEL_PROJECT_GET_CLASS (self)->get_project_file (self);
2065 #line 2047 "project.c"
2066 }
2067
2068
2069 #line 414 "project.vala"
2070 ModelClipFile* model_project_get_clipfile (ModelProject* self, gint index) {
2071 #line 2053 "project.c"
2072         ModelClipFile* result = NULL;
2073         gboolean _tmp0_ = FALSE;
2074 #line 414 "project.vala"
2075         g_return_val_if_fail (MODEL_IS_PROJECT (self), NULL);
2076 #line 415 "project.vala"
2077         if (index < 0) {
2078 #line 415 "project.vala"
2079                 _tmp0_ = TRUE;
2080 #line 2062 "project.c"
2081         } else {
2082 #line 416 "project.vala"
2083                 _tmp0_ = index >= gee_collection_get_size (GEE_COLLECTION (self->clipfiles));
2084 #line 2066 "project.c"
2085         }
2086 #line 415 "project.vala"
2087         if (_tmp0_) {
2088 #line 2070 "project.c"
2089                 result = NULL;
2090 #line 417 "project.vala"
2091                 return result;
2092 #line 2074 "project.c"
2093         }
2094         result = (ModelClipFile*) gee_abstract_list_get (GEE_ABSTRACT_LIST (self->clipfiles), index);
2095 #line 418 "project.vala"
2096         return result;
2097 #line 2079 "project.c"
2098 }
2099
2100
2101 #line 421 "project.vala"
2102 gint model_project_get_clipfile_index (ModelProject* self, ModelClipFile* find) {
2103 #line 2085 "project.c"
2104         gint result = 0;
2105         gint i;
2106 #line 421 "project.vala"
2107         g_return_val_if_fail (MODEL_IS_PROJECT (self), 0);
2108 #line 421 "project.vala"
2109         g_return_val_if_fail (MODEL_IS_CLIP_FILE (find), 0);
2110 #line 422 "project.vala"
2111         i = 0;
2112 #line 2094 "project.c"
2113         {
2114                 GeeIterator* _f_it;
2115                 _f_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (self->clipfiles));
2116 #line 423 "project.vala"
2117                 while (TRUE) {
2118 #line 2100 "project.c"
2119                         ModelClipFile* f;
2120 #line 423 "project.vala"
2121                         if (!gee_iterator_next (_f_it)) {
2122 #line 423 "project.vala"
2123                                 break;
2124 #line 2106 "project.c"
2125                         }
2126 #line 423 "project.vala"
2127                         f = (ModelClipFile*) gee_iterator_get (_f_it);
2128 #line 424 "project.vala"
2129                         if (f == find) {
2130 #line 2112 "project.c"
2131                                 result = i;
2132                                 _g_object_unref0 (f);
2133                                 _g_object_unref0 (_f_it);
2134 #line 425 "project.vala"
2135                                 return result;
2136 #line 2118 "project.c"
2137                         }
2138 #line 426 "project.vala"
2139                         i++;
2140 #line 2122 "project.c"
2141                         _g_object_unref0 (f);
2142                 }
2143                 _g_object_unref0 (_f_it);
2144         }
2145         result = -1;
2146 #line 428 "project.vala"
2147         return result;
2148 #line 2130 "project.c"
2149 }
2150
2151
2152 #line 431 "project.vala"
2153 ModelTrack* model_project_track_from_clip (ModelProject* self, ModelClip* clip) {
2154 #line 2136 "project.c"
2155         ModelTrack* result = NULL;
2156 #line 431 "project.vala"
2157         g_return_val_if_fail (MODEL_IS_PROJECT (self), NULL);
2158 #line 431 "project.vala"
2159         g_return_val_if_fail (MODEL_IS_CLIP (clip), NULL);
2160 #line 2142 "project.c"
2161         {
2162                 GeeIterator* _track_it;
2163                 _track_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (self->tracks));
2164 #line 432 "project.vala"
2165                 while (TRUE) {
2166 #line 2148 "project.c"
2167                         ModelTrack* track;
2168 #line 432 "project.vala"
2169                         if (!gee_iterator_next (_track_it)) {
2170 #line 432 "project.vala"
2171                                 break;
2172 #line 2154 "project.c"
2173                         }
2174 #line 432 "project.vala"
2175                         track = (ModelTrack*) gee_iterator_get (_track_it);
2176 #line 2158 "project.c"
2177                         {
2178                                 GeeIterator* _match_it;
2179                                 _match_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (track->clips));
2180 #line 433 "project.vala"
2181                                 while (TRUE) {
2182 #line 2164 "project.c"
2183                                         ModelClip* match;
2184 #line 433 "project.vala"
2185                                         if (!gee_iterator_next (_match_it)) {
2186 #line 433 "project.vala"
2187                                                 break;
2188 #line 2170 "project.c"
2189                                         }
2190 #line 433 "project.vala"
2191                                         match = (ModelClip*) gee_iterator_get (_match_it);
2192 #line 434 "project.vala"
2193                                         if (match == clip) {
2194 #line 2176 "project.c"
2195                                                 result = track;
2196                                                 _g_object_unref0 (match);
2197                                                 _g_object_unref0 (_match_it);
2198                                                 _g_object_unref0 (_track_it);
2199 #line 435 "project.vala"
2200                                                 return result;
2201 #line 2183 "project.c"
2202                                         }
2203                                         _g_object_unref0 (match);
2204                                 }
2205                                 _g_object_unref0 (_match_it);
2206                         }
2207                         _g_object_unref0 (track);
2208                 }
2209                 _g_object_unref0 (_track_it);
2210         }
2211         result = NULL;
2212 #line 439 "project.vala"
2213         return result;
2214 #line 2196 "project.c"
2215 }
2216
2217
2218 #line 442 "project.vala"
2219 void model_project_print_graph (ModelProject* self, GstBin* bin, const char* file_name) {
2220 #line 442 "project.vala"
2221         g_return_if_fail (MODEL_IS_PROJECT (self));
2222 #line 442 "project.vala"
2223         g_return_if_fail (GST_IS_BIN (bin));
2224 #line 442 "project.vala"
2225         g_return_if_fail (file_name != NULL);
2226 #line 443 "project.vala"
2227         GST_DEBUG_BIN_TO_DOT_FILE_WITH_TS (bin, GST_DEBUG_GRAPH_SHOW_ALL, file_name);
2228 #line 2210 "project.c"
2229 }
2230
2231
2232 #line 446 "project.vala"
2233 gint64 model_project_get_length (ModelProject* self) {
2234 #line 2216 "project.c"
2235         gint64 result = 0LL;
2236         gint64 max;
2237 #line 446 "project.vala"
2238         g_return_val_if_fail (MODEL_IS_PROJECT (self), 0LL);
2239 #line 447 "project.vala"
2240         max = (gint64) 0;
2241 #line 2223 "project.c"
2242         {
2243                 GeeIterator* _track_it;
2244                 _track_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (self->tracks));
2245 #line 448 "project.vala"
2246                 while (TRUE) {
2247 #line 2229 "project.c"
2248                         ModelTrack* track;
2249 #line 448 "project.vala"
2250                         if (!gee_iterator_next (_track_it)) {
2251 #line 448 "project.vala"
2252                                 break;
2253 #line 2235 "project.c"
2254                         }
2255 #line 448 "project.vala"
2256                         track = (ModelTrack*) gee_iterator_get (_track_it);
2257 #line 449 "project.vala"
2258                         max = MAX (max, model_track_get_length (track));
2259 #line 2241 "project.c"
2260                         _g_object_unref0 (track);
2261                 }
2262                 _g_object_unref0 (_track_it);
2263         }
2264         result = max;
2265 #line 451 "project.vala"
2266         return result;
2267 #line 2249 "project.c"
2268 }
2269
2270
2271 #line 454 "project.vala"
2272 gint64 model_project_snap_clip (ModelProject* self, ModelClip* c, gint64 span) {
2273 #line 2255 "project.c"
2274         gint64 result = 0LL;
2275 #line 454 "project.vala"
2276         g_return_val_if_fail (MODEL_IS_PROJECT (self), 0LL);
2277 #line 454 "project.vala"
2278         g_return_val_if_fail (MODEL_IS_CLIP (c), 0LL);
2279 #line 2261 "project.c"
2280         {
2281                 GeeIterator* _track_it;
2282                 _track_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (self->tracks));
2283 #line 455 "project.vala"
2284                 while (TRUE) {
2285 #line 2267 "project.c"
2286                         ModelTrack* track;
2287                         gint64 new_start;
2288 #line 455 "project.vala"
2289                         if (!gee_iterator_next (_track_it)) {
2290 #line 455 "project.vala"
2291                                 break;
2292 #line 2274 "project.c"
2293                         }
2294 #line 455 "project.vala"
2295                         track = (ModelTrack*) gee_iterator_get (_track_it);
2296 #line 456 "project.vala"
2297                         new_start = model_track_snap_clip (track, c, span);
2298 #line 457 "project.vala"
2299                         if (new_start != model_clip_get_start (c)) {
2300 #line 2282 "project.c"
2301                                 result = new_start;
2302                                 _g_object_unref0 (track);
2303                                 _g_object_unref0 (_track_it);
2304 #line 458 "project.vala"
2305                                 return result;
2306 #line 2288 "project.c"
2307                         }
2308                         _g_object_unref0 (track);
2309                 }
2310                 _g_object_unref0 (_track_it);
2311         }
2312         result = model_clip_get_start (c);
2313 #line 461 "project.vala"
2314         return result;
2315 #line 2297 "project.c"
2316 }
2317
2318
2319 #line 464 "project.vala"
2320 void model_project_snap_coord (ModelProject* self, gint64* coord, gint64 span) {
2321 #line 464 "project.vala"
2322         g_return_if_fail (MODEL_IS_PROJECT (self));
2323 #line 2305 "project.c"
2324         {
2325                 GeeIterator* _track_it;
2326                 _track_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (self->tracks));
2327 #line 465 "project.vala"
2328                 while (TRUE) {
2329 #line 2311 "project.c"
2330                         ModelTrack* track;
2331 #line 465 "project.vala"
2332                         if (!gee_iterator_next (_track_it)) {
2333 #line 465 "project.vala"
2334                                 break;
2335 #line 2317 "project.c"
2336                         }
2337 #line 465 "project.vala"
2338                         track = (ModelTrack*) gee_iterator_get (_track_it);
2339 #line 466 "project.vala"
2340                         if (model_track_snap_coord (track, coord, span)) {
2341 #line 2323 "project.c"
2342                                 _g_object_unref0 (track);
2343 #line 467 "project.vala"
2344                                 break;
2345 #line 2327 "project.c"
2346                         }
2347                         _g_object_unref0 (track);
2348                 }
2349                 _g_object_unref0 (_track_it);
2350         }
2351 }
2352
2353
2354 static gpointer _model_gap_ref0 (gpointer self) {
2355         return self ? model_gap_ref (self) : NULL;
2356 }
2357
2358
2359 #line 472 "project.vala"
2360 static ModelGap* model_project_get_gap_intersection (ModelProject* self, ModelGap* gap) {
2361 #line 2343 "project.c"
2362         ModelGap* result = NULL;
2363         ModelGap* intersection;
2364 #line 472 "project.vala"
2365         g_return_val_if_fail (MODEL_IS_PROJECT (self), NULL);
2366 #line 472 "project.vala"
2367         g_return_val_if_fail (MODEL_IS_GAP (gap), NULL);
2368 #line 473 "project.vala"
2369         intersection = _model_gap_ref0 (gap);
2370 #line 2352 "project.c"
2371         {
2372                 GeeIterator* _track_it;
2373                 _track_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (self->tracks));
2374 #line 475 "project.vala"
2375                 while (TRUE) {
2376 #line 2358 "project.c"
2377                         ModelTrack* track;
2378                         ModelGap* _tmp1_;
2379                         ModelGap* _tmp0_;
2380 #line 475 "project.vala"
2381                         if (!gee_iterator_next (_track_it)) {
2382 #line 475 "project.vala"
2383                                 break;
2384 #line 2366 "project.c"
2385                         }
2386 #line 475 "project.vala"
2387                         track = (ModelTrack*) gee_iterator_get (_track_it);
2388 #line 476 "project.vala"
2389                         intersection = (_tmp1_ = model_gap_intersect (intersection, _tmp0_ = model_track_find_first_gap (track, intersection->start)), _model_gap_unref0 (intersection), _tmp1_);
2390 #line 2372 "project.c"
2391                         _model_gap_unref0 (_tmp0_);
2392                         _g_object_unref0 (track);
2393                 }
2394                 _g_object_unref0 (_track_it);
2395         }
2396         result = intersection;
2397 #line 479 "project.vala"
2398         return result;
2399 #line 2381 "project.c"
2400 }
2401
2402
2403 #line 482 "project.vala"
2404 gboolean model_project_can_delete_gap (ModelProject* self, ModelGap* gap) {
2405 #line 2387 "project.c"
2406         gboolean result = FALSE;
2407         ModelGap* intersection;
2408 #line 482 "project.vala"
2409         g_return_val_if_fail (MODEL_IS_PROJECT (self), FALSE);
2410 #line 482 "project.vala"
2411         g_return_val_if_fail (MODEL_IS_GAP (gap), FALSE);
2412 #line 483 "project.vala"
2413         intersection = model_project_get_gap_intersection (self, gap);
2414 #line 2396 "project.c"
2415         result = !model_gap_is_empty (intersection);
2416         _model_gap_unref0 (intersection);
2417 #line 484 "project.vala"
2418         return result;
2419 #line 2401 "project.c"
2420 }
2421
2422
2423 #line 487 "project.vala"
2424 void model_project_delete_gap (ModelProject* self, ModelGap* gap) {
2425 #line 2407 "project.c"
2426         ModelGap* intersection;
2427 #line 487 "project.vala"
2428         g_return_if_fail (MODEL_IS_PROJECT (self));
2429 #line 487 "project.vala"
2430         g_return_if_fail (MODEL_IS_GAP (gap));
2431 #line 488 "project.vala"
2432         intersection = model_project_get_gap_intersection (self, gap);
2433 #line 489 "project.vala"
2434         g_assert (!model_gap_is_empty (intersection));
2435 #line 2417 "project.c"
2436         {
2437                 GeeIterator* _track_it;
2438                 _track_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (self->tracks));
2439 #line 491 "project.vala"
2440                 while (TRUE) {
2441 #line 2423 "project.c"
2442                         ModelTrack* track;
2443 #line 491 "project.vala"
2444                         if (!gee_iterator_next (_track_it)) {
2445 #line 491 "project.vala"
2446                                 break;
2447 #line 2429 "project.c"
2448                         }
2449 #line 491 "project.vala"
2450                         track = (ModelTrack*) gee_iterator_get (_track_it);
2451 #line 492 "project.vala"
2452                         model_track_delete_gap (track, intersection);
2453 #line 2435 "project.c"
2454                         _g_object_unref0 (track);
2455                 }
2456                 _g_object_unref0 (_track_it);
2457         }
2458         _model_gap_unref0 (intersection);
2459 }
2460
2461
2462 #line 496 "project.vala"
2463 static void model_project_real_do_append (ModelProject* self, ModelTrack* track, ModelClipFile* clipfile, const char* name, gint64 insert_time) {
2464 #line 2446 "project.c"
2465         ModelClip* clip;
2466 #line 496 "project.vala"
2467         g_return_if_fail (MODEL_IS_PROJECT (self));
2468 #line 496 "project.vala"
2469         g_return_if_fail (MODEL_IS_TRACK (track));
2470 #line 496 "project.vala"
2471         g_return_if_fail (MODEL_IS_CLIP_FILE (clipfile));
2472 #line 496 "project.vala"
2473         g_return_if_fail (name != NULL);
2474 #line 498 "project.vala"
2475         switch (model_track_media_type (track)) {
2476 #line 2458 "project.c"
2477                 case MODEL_MEDIA_TYPE_AUDIO:
2478                 {
2479 #line 500 "project.vala"
2480                         if (clipfile->audio_caps == NULL) {
2481 #line 501 "project.vala"
2482                                 return;
2483 #line 2465 "project.c"
2484                         }
2485 #line 503 "project.vala"
2486                         break;
2487 #line 2469 "project.c"
2488                 }
2489                 case MODEL_MEDIA_TYPE_VIDEO:
2490                 {
2491 #line 505 "project.vala"
2492                         if (clipfile->video_caps == NULL) {
2493 #line 506 "project.vala"
2494                                 return;
2495 #line 2477 "project.c"
2496                         }
2497 #line 508 "project.vala"
2498                         break;
2499 #line 2481 "project.c"
2500                 }
2501         }
2502 #line 511 "project.vala"
2503         clip = model_clip_new (clipfile, model_track_media_type (track), name, (gint64) 0, (gint64) 0, model_clip_file_get_length (clipfile), FALSE);
2504 #line 512 "project.vala"
2505         model_track_append_at_time (track, clip, insert_time, TRUE);
2506 #line 2488 "project.c"
2507         _g_object_unref0 (clip);
2508 }
2509
2510
2511 #line 496 "project.vala"
2512 void model_project_do_append (ModelProject* self, ModelTrack* track, ModelClipFile* clipfile, const char* name, gint64 insert_time) {
2513 #line 496 "project.vala"
2514         MODEL_PROJECT_GET_CLASS (self)->do_append (self, track, clipfile, name, insert_time);
2515 #line 2497 "project.c"
2516 }
2517
2518
2519 #line 515 "project.vala"
2520 void model_project_append (ModelProject* self, ModelTrack* track, ModelClipFile* clipfile) {
2521 #line 2503 "project.c"
2522         char* name;
2523         gint64 insert_time;
2524 #line 515 "project.vala"
2525         g_return_if_fail (MODEL_IS_PROJECT (self));
2526 #line 515 "project.vala"
2527         g_return_if_fail (MODEL_IS_TRACK (track));
2528 #line 515 "project.vala"
2529         g_return_if_fail (MODEL_IS_CLIP_FILE (clipfile));
2530 #line 516 "project.vala"
2531         name = isolate_filename (clipfile->filename);
2532 #line 517 "project.vala"
2533         insert_time = (gint64) 0;
2534 #line 2516 "project.c"
2535         {
2536                 GeeIterator* _temp_track_it;
2537                 _temp_track_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (self->tracks));
2538 #line 519 "project.vala"
2539                 while (TRUE) {
2540 #line 2522 "project.c"
2541                         ModelTrack* temp_track;
2542 #line 519 "project.vala"
2543                         if (!gee_iterator_next (_temp_track_it)) {
2544 #line 519 "project.vala"
2545                                 break;
2546 #line 2528 "project.c"
2547                         }
2548 #line 519 "project.vala"
2549                         temp_track = (ModelTrack*) gee_iterator_get (_temp_track_it);
2550 #line 520 "project.vala"
2551                         insert_time = MAX (insert_time, model_track_get_length (temp_track));
2552 #line 2534 "project.c"
2553                         _g_object_unref0 (temp_track);
2554                 }
2555                 _g_object_unref0 (_temp_track_it);
2556         }
2557 #line 522 "project.vala"
2558         model_project_do_append (self, track, clipfile, name, insert_time);
2559 #line 2541 "project.c"
2560         _g_free0 (name);
2561 }
2562
2563
2564 #line 525 "project.vala"
2565 void model_project_add (ModelProject* self, ModelTrack* track, ModelClipFile* clipfile, gint64 time) {
2566 #line 2548 "project.c"
2567         char* name;
2568 #line 525 "project.vala"
2569         g_return_if_fail (MODEL_IS_PROJECT (self));
2570 #line 525 "project.vala"
2571         g_return_if_fail (MODEL_IS_TRACK (track));
2572 #line 525 "project.vala"
2573         g_return_if_fail (MODEL_IS_CLIP_FILE (clipfile));
2574 #line 526 "project.vala"
2575         name = isolate_filename (clipfile->filename);
2576 #line 527 "project.vala"
2577         model_project_do_append (self, track, clipfile, name, time);
2578 #line 2560 "project.c"
2579         _g_free0 (name);
2580 }
2581
2582
2583 #line 530 "project.vala"
2584 void model_project_on_clip_removed (ModelProject* self, ModelTrack* t, ModelClip* clip) {
2585 #line 530 "project.vala"
2586         g_return_if_fail (MODEL_IS_PROJECT (self));
2587 #line 530 "project.vala"
2588         g_return_if_fail (MODEL_IS_TRACK (t));
2589 #line 530 "project.vala"
2590         g_return_if_fail (MODEL_IS_CLIP (clip));
2591 #line 531 "project.vala"
2592         logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_clip_removed");
2593 #line 532 "project.vala"
2594         model_project_reseek (self);
2595 #line 2577 "project.c"
2596 }
2597
2598
2599 #line 535 "project.vala"
2600 void model_project_split_at_playhead (ModelProject* self) {
2601 #line 2583 "project.c"
2602         char* description;
2603 #line 535 "project.vala"
2604         g_return_if_fail (MODEL_IS_PROJECT (self));
2605 #line 536 "project.vala"
2606         description = g_strdup ("Split At Playhead");
2607 #line 537 "project.vala"
2608         model_undo_manager_start_transaction (self->undo_manager, description);
2609 #line 2591 "project.c"
2610         {
2611                 GeeIterator* _track_it;
2612                 _track_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (self->tracks));
2613 #line 538 "project.vala"
2614                 while (TRUE) {
2615 #line 2597 "project.c"
2616                         ModelTrack* track;
2617                         ModelClip* _tmp0_;
2618                         gboolean _tmp1_;
2619 #line 538 "project.vala"
2620                         if (!gee_iterator_next (_track_it)) {
2621 #line 538 "project.vala"
2622                                 break;
2623 #line 2605 "project.c"
2624                         }
2625 #line 538 "project.vala"
2626                         track = (ModelTrack*) gee_iterator_get (_track_it);
2627 #line 539 "project.vala"
2628                         if ((_tmp1_ = (_tmp0_ = model_track_get_clip_by_position (track, model_project_transport_get_position (self))) != NULL, _g_object_unref0 (_tmp0_), _tmp1_)) {
2629 #line 540 "project.vala"
2630                                 model_track_split_at (track, model_project_transport_get_position (self));
2631 #line 2613 "project.c"
2632                         }
2633                         _g_object_unref0 (track);
2634                 }
2635                 _g_object_unref0 (_track_it);
2636         }
2637 #line 543 "project.vala"
2638         model_undo_manager_end_transaction (self->undo_manager, description);
2639 #line 2621 "project.c"
2640         _g_free0 (description);
2641 }
2642
2643
2644 #line 546 "project.vala"
2645 gboolean model_project_can_trim (ModelProject* self, gboolean* left) {
2646 #line 2628 "project.c"
2647         gboolean result = FALSE;
2648         ModelClip* first_clip;
2649         gint64 start;
2650         gint64 end;
2651         gboolean start_same;
2652         gboolean end_same;
2653         gboolean _tmp4_ = FALSE;
2654         gboolean _tmp5_ = FALSE;
2655 #line 546 "project.vala"
2656         g_return_val_if_fail (MODEL_IS_PROJECT (self), FALSE);
2657 #line 547 "project.vala"
2658         first_clip = NULL;
2659 #line 553 "project.vala"
2660         start = (gint64) 0;
2661 #line 554 "project.vala"
2662         end = (gint64) 0;
2663 #line 555 "project.vala"
2664         start_same = TRUE;
2665 #line 556 "project.vala"
2666         end_same = TRUE;
2667 #line 2649 "project.c"
2668         {
2669                 GeeIterator* _track_it;
2670                 _track_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (self->tracks));
2671 #line 557 "project.vala"
2672                 while (TRUE) {
2673 #line 2655 "project.c"
2674                         ModelTrack* track;
2675                         ModelClip* clip;
2676                         gboolean _tmp0_ = FALSE;
2677 #line 557 "project.vala"
2678                         if (!gee_iterator_next (_track_it)) {
2679 #line 557 "project.vala"
2680                                 break;
2681 #line 2663 "project.c"
2682                         }
2683 #line 557 "project.vala"
2684                         track = (ModelTrack*) gee_iterator_get (_track_it);
2685 #line 558 "project.vala"
2686                         clip = model_track_get_clip_by_position (track, model_project_transport_get_position (self));
2687 #line 559 "project.vala"
2688                         if (first_clip != NULL) {
2689 #line 559 "project.vala"
2690                                 _tmp0_ = clip != NULL;
2691 #line 2673 "project.c"
2692                         } else {
2693 #line 559 "project.vala"
2694                                 _tmp0_ = FALSE;
2695 #line 2677 "project.c"
2696                         }
2697 #line 559 "project.vala"
2698                         if (_tmp0_) {
2699 #line 2681 "project.c"
2700                                 gboolean _tmp1_ = FALSE;
2701                                 gboolean _tmp2_ = FALSE;
2702 #line 560 "project.vala"
2703                                 if (start_same) {
2704 #line 560 "project.vala"
2705                                         _tmp1_ = start == model_clip_get_start (clip);
2706 #line 2688 "project.c"
2707                                 } else {
2708 #line 560 "project.vala"
2709                                         _tmp1_ = FALSE;
2710 #line 2692 "project.c"
2711                                 }
2712 #line 560 "project.vala"
2713                                 start_same = _tmp1_;
2714 #line 561 "project.vala"
2715                                 if (end_same) {
2716 #line 561 "project.vala"
2717                                         _tmp2_ = end == model_clip_get_end (clip);
2718 #line 2700 "project.c"
2719                                 } else {
2720 #line 561 "project.vala"
2721                                         _tmp2_ = FALSE;
2722 #line 2704 "project.c"
2723                                 }
2724 #line 561 "project.vala"
2725                                 end_same = _tmp2_;
2726 #line 2708 "project.c"
2727                         } else {
2728 #line 562 "project.vala"
2729                                 if (clip != NULL) {
2730 #line 2712 "project.c"
2731                                         ModelClip* _tmp3_;
2732 #line 563 "project.vala"
2733                                         first_clip = (_tmp3_ = _g_object_ref0 (clip), _g_object_unref0 (first_clip), _tmp3_);
2734 #line 564 "project.vala"
2735                                         start = model_clip_get_start (first_clip);
2736 #line 565 "project.vala"
2737                                         end = model_clip_get_end (first_clip);
2738 #line 2720 "project.c"
2739                                 }
2740                         }
2741                         _g_object_unref0 (track);
2742                         _g_object_unref0 (clip);
2743                 }
2744                 _g_object_unref0 (_track_it);
2745         }
2746 #line 569 "project.vala"
2747         if (first_clip == NULL) {
2748 #line 2730 "project.c"
2749                 result = FALSE;
2750                 _g_object_unref0 (first_clip);
2751 #line 570 "project.vala"
2752                 return result;
2753 #line 2735 "project.c"
2754         }
2755 #line 573 "project.vala"
2756         if (start_same) {
2757 #line 573 "project.vala"
2758                 _tmp4_ = !end_same;
2759 #line 2741 "project.c"
2760         } else {
2761 #line 573 "project.vala"
2762                 _tmp4_ = FALSE;
2763 #line 2745 "project.c"
2764         }
2765 #line 573 "project.vala"
2766         if (_tmp4_) {
2767 #line 574 "project.vala"
2768                 *left = TRUE;
2769 #line 2751 "project.c"
2770                 result = TRUE;
2771                 _g_object_unref0 (first_clip);
2772 #line 575 "project.vala"
2773                 return result;
2774 #line 2756 "project.c"
2775         }
2776 #line 578 "project.vala"
2777         if (!start_same) {
2778 #line 578 "project.vala"
2779                 _tmp5_ = end_same;
2780 #line 2762 "project.c"
2781         } else {
2782 #line 578 "project.vala"
2783                 _tmp5_ = FALSE;
2784 #line 2766 "project.c"
2785         }
2786 #line 578 "project.vala"
2787         if (_tmp5_) {
2788 #line 579 "project.vala"
2789                 *left = FALSE;
2790 #line 2772 "project.c"
2791                 result = TRUE;
2792                 _g_object_unref0 (first_clip);
2793 #line 580 "project.vala"
2794                 return result;
2795 #line 2777 "project.c"
2796         }
2797 #line 584 "project.vala"
2798         *left = (model_project_transport_get_position (self) - model_clip_get_start (first_clip)) < (model_clip_get_duration (first_clip) / 2);
2799 #line 2781 "project.c"
2800         result = TRUE;
2801         _g_object_unref0 (first_clip);
2802 #line 585 "project.vala"
2803         return result;
2804 #line 2786 "project.c"
2805 }
2806
2807
2808 #line 588 "project.vala"
2809 void model_project_trim_to_playhead (ModelProject* self) {
2810 #line 2792 "project.c"
2811         gboolean left = FALSE;
2812         char* description;
2813         ModelClip* first_clip;
2814         gboolean _tmp1_ = FALSE;
2815 #line 588 "project.vala"
2816         g_return_if_fail (MODEL_IS_PROJECT (self));
2817 #line 590 "project.vala"
2818         if (!model_project_can_trim (self, &left)) {
2819 #line 591 "project.vala"
2820                 return;
2821 #line 2803 "project.c"
2822         }
2823 #line 593 "project.vala"
2824         description = g_strdup ("Trim To Playhead");
2825 #line 594 "project.vala"
2826         first_clip = NULL;
2827 #line 595 "project.vala"
2828         model_undo_manager_start_transaction (self->undo_manager, description);
2829 #line 2811 "project.c"
2830         {
2831                 GeeIterator* _track_it;
2832                 _track_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (self->tracks));
2833 #line 596 "project.vala"
2834                 while (TRUE) {
2835 #line 2817 "project.c"
2836                         ModelTrack* track;
2837                         ModelClip* clip;
2838 #line 596 "project.vala"
2839                         if (!gee_iterator_next (_track_it)) {
2840 #line 596 "project.vala"
2841                                 break;
2842 #line 2824 "project.c"
2843                         }
2844 #line 596 "project.vala"
2845                         track = (ModelTrack*) gee_iterator_get (_track_it);
2846 #line 597 "project.vala"
2847                         clip = model_track_get_clip_by_position (track, model_project_transport_get_position (self));
2848 #line 598 "project.vala"
2849                         if (clip != NULL) {
2850 #line 2832 "project.c"
2851                                 gint64 delta = 0LL;
2852                                 GdkWindowEdge _tmp0_ = 0;
2853 #line 600 "project.vala"
2854                                 if (left) {
2855 #line 601 "project.vala"
2856                                         delta = model_project_transport_get_position (self) - model_clip_get_start (clip);
2857 #line 2839 "project.c"
2858                                 } else {
2859 #line 603 "project.vala"
2860                                         delta = model_project_transport_get_position (self) - model_clip_get_end (clip);
2861 #line 2843 "project.c"
2862                                 }
2863 #line 605 "project.vala"
2864                                 if (left) {
2865 #line 605 "project.vala"
2866                                         _tmp0_ = GDK_WINDOW_EDGE_WEST;
2867 #line 2849 "project.c"
2868                                 } else {
2869 #line 605 "project.vala"
2870                                         _tmp0_ = GDK_WINDOW_EDGE_EAST;
2871 #line 2853 "project.c"
2872                                 }
2873 #line 605 "project.vala"
2874                                 model_track_trim (track, clip, delta, _tmp0_);
2875 #line 2857 "project.c"
2876                         }
2877                         _g_object_unref0 (track);
2878                         _g_object_unref0 (clip);
2879                 }
2880                 _g_object_unref0 (_track_it);
2881         }
2882 #line 608 "project.vala"
2883         model_undo_manager_end_transaction (self->undo_manager, description);
2884 #line 610 "project.vala"
2885         if (left) {
2886 #line 610 "project.vala"
2887                 _tmp1_ = first_clip != NULL;
2888 #line 2870 "project.c"
2889         } else {
2890 #line 610 "project.vala"
2891                 _tmp1_ = FALSE;
2892 #line 2874 "project.c"
2893         }
2894 #line 610 "project.vala"
2895         if (_tmp1_) {
2896 #line 611 "project.vala"
2897                 model_project_transport_go (self, model_clip_get_start (first_clip));
2898 #line 2880 "project.c"
2899         }
2900         _g_free0 (description);
2901         _g_object_unref0 (first_clip);
2902 }
2903
2904
2905 #line 615 "project.vala"
2906 void model_project_transport_go (ModelProject* self, gint64 position) {
2907 #line 615 "project.vala"
2908         g_return_if_fail (MODEL_IS_PROJECT (self));
2909 #line 616 "project.vala"
2910         view_media_engine_go (self->media_engine, position);
2911 #line 2893 "project.c"
2912 }
2913
2914
2915 #line 619 "project.vala"
2916 gboolean model_project_transport_is_playing (ModelProject* self) {
2917 #line 2899 "project.c"
2918         gboolean result = FALSE;
2919 #line 619 "project.vala"
2920         g_return_val_if_fail (MODEL_IS_PROJECT (self), FALSE);
2921 #line 2903 "project.c"
2922         result = self->media_engine->playing;
2923 #line 620 "project.vala"
2924         return result;
2925 #line 2907 "project.c"
2926 }
2927
2928
2929 #line 623 "project.vala"
2930 gboolean model_project_transport_is_recording (ModelProject* self) {
2931 #line 2913 "project.c"
2932         gboolean result = FALSE;
2933         gboolean _tmp0_ = FALSE;
2934 #line 623 "project.vala"
2935         g_return_val_if_fail (MODEL_IS_PROJECT (self), FALSE);
2936 #line 624 "project.vala"
2937         if (view_media_engine_get_play_state (self->media_engine) == PLAY_STATE_PRE_RECORD) {
2938 #line 624 "project.vala"
2939                 _tmp0_ = TRUE;
2940 #line 2922 "project.c"
2941         } else {
2942 #line 625 "project.vala"
2943                 _tmp0_ = view_media_engine_get_play_state (self->media_engine) == PLAY_STATE_RECORDING;
2944 #line 2926 "project.c"
2945         }
2946         result = _tmp0_;
2947 #line 624 "project.vala"
2948         return result;
2949 #line 2931 "project.c"
2950 }
2951
2952
2953 #line 628 "project.vala"
2954 gboolean model_project_playhead_on_clip (ModelProject* self) {
2955 #line 2937 "project.c"
2956         gboolean result = FALSE;
2957 #line 628 "project.vala"
2958         g_return_val_if_fail (MODEL_IS_PROJECT (self), FALSE);
2959 #line 2941 "project.c"
2960         {
2961                 GeeIterator* _track_it;
2962                 _track_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (self->tracks));
2963 #line 629 "project.vala"
2964                 while (TRUE) {
2965 #line 2947 "project.c"
2966                         ModelTrack* track;
2967                         ModelClip* _tmp0_;
2968                         gboolean _tmp1_;
2969 #line 629 "project.vala"
2970                         if (!gee_iterator_next (_track_it)) {
2971 #line 629 "project.vala"
2972                                 break;
2973 #line 2955 "project.c"
2974                         }
2975 #line 629 "project.vala"
2976                         track = (ModelTrack*) gee_iterator_get (_track_it);
2977 #line 630 "project.vala"
2978                         if ((_tmp1_ = (_tmp0_ = model_track_get_clip_by_position (track, model_project_transport_get_position (self))) != NULL, _g_object_unref0 (_tmp0_), _tmp1_)) {
2979 #line 2961 "project.c"
2980                                 result = TRUE;
2981                                 _g_object_unref0 (track);
2982                                 _g_object_unref0 (_track_it);
2983 #line 631 "project.vala"
2984                                 return result;
2985 #line 2967 "project.c"
2986                         }
2987                         _g_object_unref0 (track);
2988                 }
2989                 _g_object_unref0 (_track_it);
2990         }
2991         result = FALSE;
2992 #line 634 "project.vala"
2993         return result;
2994 #line 2976 "project.c"
2995 }
2996
2997
2998 #line 637 "project.vala"
2999 gboolean model_project_playhead_on_contiguous_clip (ModelProject* self) {
3000 #line 2982 "project.c"
3001         gboolean result = FALSE;
3002 #line 637 "project.vala"
3003         g_return_val_if_fail (MODEL_IS_PROJECT (self), FALSE);
3004 #line 2986 "project.c"
3005         {
3006                 GeeIterator* _track_it;
3007                 _track_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (self->tracks));
3008 #line 638 "project.vala"
3009                 while (TRUE) {
3010 #line 2992 "project.c"
3011                         ModelTrack* track;
3012 #line 638 "project.vala"
3013                         if (!gee_iterator_next (_track_it)) {
3014 #line 638 "project.vala"
3015                                 break;
3016 #line 2998 "project.c"
3017                         }
3018 #line 638 "project.vala"
3019                         track = (ModelTrack*) gee_iterator_get (_track_it);
3020 #line 639 "project.vala"
3021                         if (model_track_are_contiguous_clips (track, model_project_transport_get_position (self))) {
3022 #line 3004 "project.c"
3023                                 result = TRUE;
3024                                 _g_object_unref0 (track);
3025                                 _g_object_unref0 (_track_it);
3026 #line 640 "project.vala"
3027                                 return result;
3028 #line 3010 "project.c"
3029                         }
3030                         _g_object_unref0 (track);
3031                 }
3032                 _g_object_unref0 (_track_it);
3033         }
3034         result = FALSE;
3035 #line 643 "project.vala"
3036         return result;
3037 #line 3019 "project.c"
3038 }
3039
3040
3041 #line 646 "project.vala"
3042 gboolean model_project_is_duplicate_track_name (ModelProject* self, ModelTrack* track, const char* new_name) {
3043 #line 3025 "project.c"
3044         gboolean result = FALSE;
3045 #line 646 "project.vala"
3046         g_return_val_if_fail (MODEL_IS_PROJECT (self), FALSE);
3047 #line 646 "project.vala"
3048         g_return_val_if_fail ((track == NULL) || MODEL_IS_TRACK (track), FALSE);
3049 #line 646 "project.vala"
3050         g_return_val_if_fail (new_name != NULL, FALSE);
3051 #line 647 "project.vala"
3052         g_assert (_vala_strcmp0 (new_name, "") != 0);
3053 #line 3035 "project.c"
3054         {
3055                 GeeIterator* _this_track_it;
3056                 _this_track_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (self->tracks));
3057 #line 648 "project.vala"
3058                 while (TRUE) {
3059 #line 3041 "project.c"
3060                         ModelTrack* this_track;
3061 #line 648 "project.vala"
3062                         if (!gee_iterator_next (_this_track_it)) {
3063 #line 648 "project.vala"
3064                                 break;
3065 #line 3047 "project.c"
3066                         }
3067 #line 648 "project.vala"
3068                         this_track = (ModelTrack*) gee_iterator_get (_this_track_it);
3069 #line 649 "project.vala"
3070                         if (track != this_track) {
3071 #line 3053 "project.c"
3072                                 char* _tmp0_;
3073                                 gboolean _tmp1_;
3074 #line 650 "project.vala"
3075                                 if ((_tmp1_ = _vala_strcmp0 (_tmp0_ = model_track_get_display_name (this_track), new_name) == 0, _g_free0 (_tmp0_), _tmp1_)) {
3076 #line 3058 "project.c"
3077                                         result = TRUE;
3078                                         _g_object_unref0 (this_track);
3079                                         _g_object_unref0 (_this_track_it);
3080 #line 651 "project.vala"
3081                                         return result;
3082 #line 3064 "project.c"
3083                                 }
3084                         }
3085                         _g_object_unref0 (this_track);
3086                 }
3087                 _g_object_unref0 (_this_track_it);
3088         }
3089         {
3090                 GeeIterator* _this_track_it;
3091                 _this_track_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (self->inactive_tracks));
3092 #line 656 "project.vala"
3093                 while (TRUE) {
3094 #line 3076 "project.c"
3095                         ModelTrack* this_track;
3096 #line 656 "project.vala"
3097                         if (!gee_iterator_next (_this_track_it)) {
3098 #line 656 "project.vala"
3099                                 break;
3100 #line 3082 "project.c"
3101                         }
3102 #line 656 "project.vala"
3103                         this_track = (ModelTrack*) gee_iterator_get (_this_track_it);
3104 #line 657 "project.vala"
3105                         if (track != this_track) {
3106 #line 3088 "project.c"
3107                                 char* _tmp2_;
3108                                 gboolean _tmp3_;
3109 #line 658 "project.vala"
3110                                 if ((_tmp3_ = _vala_strcmp0 (_tmp2_ = model_track_get_display_name (this_track), new_name) == 0, _g_free0 (_tmp2_), _tmp3_)) {
3111 #line 3093 "project.c"
3112                                         result = TRUE;
3113                                         _g_object_unref0 (this_track);
3114                                         _g_object_unref0 (_this_track_it);
3115 #line 659 "project.vala"
3116                                         return result;
3117 #line 3099 "project.c"
3118                                 }
3119                         }
3120                         _g_object_unref0 (this_track);
3121                 }
3122                 _g_object_unref0 (_this_track_it);
3123         }
3124         result = FALSE;
3125 #line 663 "project.vala"
3126         return result;
3127 #line 3109 "project.c"
3128 }
3129
3130
3131 #line 530 "project.vala"
3132 static void _model_project_on_clip_removed_model_track_clip_removed (ModelTrack* _sender, ModelClip* clip, gpointer self) {
3133 #line 3115 "project.c"
3134         model_project_on_clip_removed (self, _sender, clip);
3135 }
3136
3137
3138 #line 924 "project.vala"
3139 static void _model_project_on_error_occurred_model_track_error_occurred (ModelTrack* _sender, const char* major_error, const char* minor_error, gpointer self) {
3140 #line 3122 "project.c"
3141         model_project_on_error_occurred (self, major_error, minor_error);
3142 }
3143
3144
3145 #line 666 "project.vala"
3146 static void model_project_real_add_track (ModelProject* self, ModelTrack* track) {
3147 #line 666 "project.vala"
3148         g_return_if_fail (MODEL_IS_PROJECT (self));
3149 #line 666 "project.vala"
3150         g_return_if_fail (MODEL_IS_TRACK (track));
3151 #line 667 "project.vala"
3152         g_signal_connect_object (track, "clip-removed", (GCallback) _model_project_on_clip_removed_model_track_clip_removed, self, 0);
3153 #line 668 "project.vala"
3154         g_signal_connect_object (track, "error-occurred", (GCallback) _model_project_on_error_occurred_model_track_error_occurred, self, 0);
3155 #line 669 "project.vala"
3156         gee_abstract_collection_add (GEE_ABSTRACT_COLLECTION (self->tracks), track);
3157 #line 670 "project.vala"
3158         g_signal_emit_by_name (self, "track-added", track);
3159 #line 3141 "project.c"
3160 }
3161
3162
3163 #line 666 "project.vala"
3164 void model_project_add_track (ModelProject* self, ModelTrack* track) {
3165 #line 666 "project.vala"
3166         MODEL_PROJECT_GET_CLASS (self)->add_track (self, track);
3167 #line 3149 "project.c"
3168 }
3169
3170
3171 #line 672 "project.vala"
3172 static void model_project_real_insert_track (ModelProject* self, gint index, ModelTrack* track) {
3173 #line 672 "project.vala"
3174         g_return_if_fail (MODEL_IS_PROJECT (self));
3175 #line 672 "project.vala"
3176         g_return_if_fail (MODEL_IS_TRACK (track));
3177 #line 673 "project.vala"
3178         if (0 > index) {
3179 #line 673 "project.vala"
3180                 index = 0;
3181 #line 3163 "project.c"
3182         }
3183 #line 674 "project.vala"
3184         if (gee_collection_get_size (GEE_COLLECTION (self->tracks)) <= index) {
3185 #line 675 "project.vala"
3186                 model_project_add_track (self, track);
3187 #line 3169 "project.c"
3188         } else {
3189 #line 678 "project.vala"
3190                 g_signal_connect_object (track, "clip-removed", (GCallback) _model_project_on_clip_removed_model_track_clip_removed, self, 0);
3191 #line 679 "project.vala"
3192                 g_signal_connect_object (track, "error-occurred", (GCallback) _model_project_on_error_occurred_model_track_error_occurred, self, 0);
3193 #line 680 "project.vala"
3194                 gee_abstract_list_insert (GEE_ABSTRACT_LIST (self->tracks), index, track);
3195 #line 681 "project.vala"
3196                 g_signal_emit_by_name (self, "track-added", track);
3197 #line 3179 "project.c"
3198         }
3199 }
3200
3201
3202 #line 672 "project.vala"
3203 void model_project_insert_track (ModelProject* self, gint index, ModelTrack* track) {
3204 #line 672 "project.vala"
3205         MODEL_PROJECT_GET_CLASS (self)->insert_track (self, index, track);
3206 #line 3188 "project.c"
3207 }
3208
3209
3210 #line 685 "project.vala"
3211 void model_project_add_inactive_track (ModelProject* self, ModelTrack* track) {
3212 #line 685 "project.vala"
3213         g_return_if_fail (MODEL_IS_PROJECT (self));
3214 #line 685 "project.vala"
3215         g_return_if_fail (MODEL_IS_TRACK (track));
3216 #line 686 "project.vala"
3217         model_track_hide (track);
3218 #line 687 "project.vala"
3219         gee_abstract_collection_add (GEE_ABSTRACT_COLLECTION (self->inactive_tracks), track);
3220 #line 3202 "project.c"
3221 }
3222
3223
3224 #line 690 "project.vala"
3225 void model_project_remove_track (ModelProject* self, ModelTrack* track) {
3226 #line 690 "project.vala"
3227         g_return_if_fail (MODEL_IS_PROJECT (self));
3228 #line 690 "project.vala"
3229         g_return_if_fail (MODEL_IS_TRACK (track));
3230 #line 691 "project.vala"
3231         gst_element_set_state (GST_ELEMENT (self->media_engine->pipeline), GST_STATE_NULL);
3232 #line 692 "project.vala"
3233         g_signal_emit_by_name (track, "track-removed", track);
3234 #line 693 "project.vala"
3235         gee_abstract_collection_remove (GEE_ABSTRACT_COLLECTION (self->tracks), track);
3236 #line 694 "project.vala"
3237         g_signal_emit_by_name (self, "track-removed", track);
3238 #line 3220 "project.c"
3239 }
3240
3241
3242 #line 697 "project.vala"
3243 void model_project_remove_track_at (ModelProject* self, gint index) {
3244 #line 3226 "project.c"
3245         ModelTrack* _tmp0_;
3246 #line 697 "project.vala"
3247         g_return_if_fail (MODEL_IS_PROJECT (self));
3248 #line 698 "project.vala"
3249         model_project_remove_track (self, _tmp0_ = (ModelTrack*) gee_abstract_list_get (GEE_ABSTRACT_LIST (self->tracks), index));
3250 #line 3232 "project.c"
3251         _g_object_unref0 (_tmp0_);
3252 }
3253
3254
3255 #line 701 "project.vala"
3256 void model_project_add_clipfile (ModelProject* self, ModelClipFile* clipfile) {
3257 #line 3239 "project.c"
3258         ModelCommand* command;
3259 #line 701 "project.vala"
3260         g_return_if_fail (MODEL_IS_PROJECT (self));
3261 #line 701 "project.vala"
3262         g_return_if_fail (MODEL_IS_CLIP_FILE (clipfile));
3263 #line 702 "project.vala"
3264         command = MODEL_COMMAND (model_add_clip_command_new (self, clipfile));
3265 #line 703 "project.vala"
3266         model_project_do_command (self, command);
3267 #line 3249 "project.c"
3268         _model_command_unref0 (command);
3269 }
3270
3271
3272 #line 717 "project.vala"
3273 static void _model_project_on_thumbnail_ready_model_fetcher_ready (ModelFetcher* _sender, ModelFetcher* fetcher, gpointer self) {
3274 #line 3256 "project.c"
3275         model_project_on_thumbnail_ready (self, fetcher);
3276 }
3277
3278
3279 #line 706 "project.vala"
3280 void _model_project_add_clipfile (ModelProject* self, ModelClipFile* clipfile, GError** error) {
3281 #line 3263 "project.c"
3282         GError * _inner_error_;
3283         gboolean _tmp0_ = FALSE;
3284 #line 706 "project.vala"
3285         g_return_if_fail (MODEL_IS_PROJECT (self));
3286 #line 706 "project.vala"
3287         g_return_if_fail (MODEL_IS_CLIP_FILE (clipfile));
3288 #line 3270 "project.c"
3289         _inner_error_ = NULL;
3290 #line 707 "project.vala"
3291         gee_abstract_collection_add (GEE_ABSTRACT_COLLECTION (self->clipfiles), clipfile);
3292 #line 708 "project.vala"
3293         if (model_clip_file_is_online (clipfile)) {
3294 #line 708 "project.vala"
3295                 _tmp0_ = model_clip_file_is_of_type (clipfile, MODEL_MEDIA_TYPE_VIDEO);
3296 #line 3278 "project.c"
3297         } else {
3298 #line 708 "project.vala"
3299                 _tmp0_ = FALSE;
3300 #line 3282 "project.c"
3301         }
3302 #line 708 "project.vala"
3303         if (_tmp0_) {
3304 #line 3286 "project.c"
3305                 ModelThumbnailFetcher* fetcher;
3306 #line 709 "project.vala"
3307                 fetcher = model_thumbnail_fetcher_new (clipfile, (gint64) 0, &_inner_error_);
3308 #line 3290 "project.c"
3309                 if (_inner_error_ != NULL) {
3310                         g_propagate_error (error, _inner_error_);
3311                         return;
3312                 }
3313 #line 710 "project.vala"
3314                 g_signal_connect_object (MODEL_FETCHER (fetcher), "ready", (GCallback) _model_project_on_thumbnail_ready_model_fetcher_ready, self, 0);
3315 #line 711 "project.vala"
3316                 gee_abstract_collection_add (GEE_ABSTRACT_COLLECTION (self->priv->pending_thumbs), fetcher);
3317 #line 3299 "project.c"
3318                 _g_object_unref0 (fetcher);
3319         } else {
3320 #line 713 "project.vala"
3321                 g_signal_emit_by_name (self, "clipfile-added", clipfile);
3322 #line 3304 "project.c"
3323         }
3324 }
3325
3326
3327 #line 717 "project.vala"
3328 static void model_project_on_thumbnail_ready (ModelProject* self, ModelFetcher* f) {
3329 #line 3311 "project.c"
3330         ModelFetcher* _tmp0_;
3331 #line 717 "project.vala"
3332         g_return_if_fail (MODEL_IS_PROJECT (self));
3333 #line 717 "project.vala"
3334         g_return_if_fail (MODEL_IS_FETCHER (f));
3335 #line 718 "project.vala"
3336         logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_thumbnail_ready");
3337 #line 719 "project.vala"
3338         g_signal_emit_by_name (self, "clipfile-added", f->clipfile);
3339 #line 720 "project.vala"
3340         gee_abstract_collection_remove (GEE_ABSTRACT_COLLECTION (self->priv->pending_thumbs), (_tmp0_ = f, MODEL_IS_THUMBNAIL_FETCHER (_tmp0_) ? ((ModelThumbnailFetcher*) _tmp0_) : NULL));
3341 #line 3323 "project.c"
3342 }
3343
3344
3345 #line 723 "project.vala"
3346 gboolean model_project_clipfile_on_track (ModelProject* self, const char* filename) {
3347 #line 3329 "project.c"
3348         gboolean result = FALSE;
3349         ModelClipFile* cf;
3350 #line 723 "project.vala"
3351         g_return_val_if_fail (MODEL_IS_PROJECT (self), FALSE);
3352 #line 723 "project.vala"
3353         g_return_val_if_fail (filename != NULL, FALSE);
3354 #line 724 "project.vala"
3355         cf = model_project_find_clipfile (self, filename);
3356 #line 3338 "project.c"
3357         {
3358                 GeeIterator* _t_it;
3359                 _t_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (self->tracks));
3360 #line 726 "project.vala"
3361                 while (TRUE) {
3362 #line 3344 "project.c"
3363                         ModelTrack* t;
3364 #line 726 "project.vala"
3365                         if (!gee_iterator_next (_t_it)) {
3366 #line 726 "project.vala"
3367                                 break;
3368 #line 3350 "project.c"
3369                         }
3370 #line 726 "project.vala"
3371                         t = (ModelTrack*) gee_iterator_get (_t_it);
3372 #line 3354 "project.c"
3373                         {
3374                                 GeeIterator* _c_it;
3375                                 _c_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (t->clips));
3376 #line 727 "project.vala"
3377                                 while (TRUE) {
3378 #line 3360 "project.c"
3379                                         ModelClip* c;
3380 #line 727 "project.vala"
3381                                         if (!gee_iterator_next (_c_it)) {
3382 #line 727 "project.vala"
3383                                                 break;
3384 #line 3366 "project.c"
3385                                         }
3386 #line 727 "project.vala"
3387                                         c = (ModelClip*) gee_iterator_get (_c_it);
3388 #line 728 "project.vala"
3389                                         if (c->clipfile == cf) {
3390 #line 3372 "project.c"
3391                                                 result = TRUE;
3392                                                 _g_object_unref0 (c);
3393                                                 _g_object_unref0 (_c_it);
3394                                                 _g_object_unref0 (t);
3395                                                 _g_object_unref0 (_t_it);
3396                                                 _g_object_unref0 (cf);
3397 #line 729 "project.vala"
3398                                                 return result;
3399 #line 3381 "project.c"
3400                                         }
3401                                         _g_object_unref0 (c);
3402                                 }
3403                                 _g_object_unref0 (_c_it);
3404                         }
3405                         _g_object_unref0 (t);
3406                 }
3407                 _g_object_unref0 (_t_it);
3408         }
3409         {
3410                 GeeIterator* _t_it;
3411                 _t_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (self->inactive_tracks));
3412 #line 733 "project.vala"
3413                 while (TRUE) {
3414 #line 3396 "project.c"
3415                         ModelTrack* t;
3416 #line 733 "project.vala"
3417                         if (!gee_iterator_next (_t_it)) {
3418 #line 733 "project.vala"
3419                                 break;
3420 #line 3402 "project.c"
3421                         }
3422 #line 733 "project.vala"
3423                         t = (ModelTrack*) gee_iterator_get (_t_it);
3424 #line 3406 "project.c"
3425                         {
3426                                 GeeIterator* _c_it;
3427                                 _c_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (t->clips));
3428 #line 734 "project.vala"
3429                                 while (TRUE) {
3430 #line 3412 "project.c"
3431                                         ModelClip* c;
3432 #line 734 "project.vala"
3433                                         if (!gee_iterator_next (_c_it)) {
3434 #line 734 "project.vala"
3435                                                 break;
3436 #line 3418 "project.c"
3437                                         }
3438 #line 734 "project.vala"
3439                                         c = (ModelClip*) gee_iterator_get (_c_it);
3440 #line 735 "project.vala"
3441                                         if (c->clipfile == cf) {
3442 #line 3424 "project.c"
3443                                                 result = TRUE;
3444                                                 _g_object_unref0 (c);
3445                                                 _g_object_unref0 (_c_it);
3446                                                 _g_object_unref0 (t);
3447                                                 _g_object_unref0 (_t_it);
3448                                                 _g_object_unref0 (cf);
3449 #line 736 "project.vala"
3450                                                 return result;
3451 #line 3433 "project.c"
3452                                         }
3453                                         _g_object_unref0 (c);
3454                                 }
3455                                 _g_object_unref0 (_c_it);
3456                         }
3457                         _g_object_unref0 (t);
3458                 }
3459                 _g_object_unref0 (_t_it);
3460         }
3461         result = FALSE;
3462         _g_object_unref0 (cf);
3463 #line 740 "project.vala"
3464         return result;
3465 #line 3447 "project.c"
3466 }
3467
3468
3469 #line 743 "project.vala"
3470 static void model_project_delete_clipfile_from_tracks (ModelProject* self, ModelClipFile* cf) {
3471 #line 743 "project.vala"
3472         g_return_if_fail (MODEL_IS_PROJECT (self));
3473 #line 743 "project.vala"
3474         g_return_if_fail (MODEL_IS_CLIP_FILE (cf));
3475 #line 3457 "project.c"
3476         {
3477                 GeeIterator* _t_it;
3478                 _t_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (self->tracks));
3479 #line 744 "project.vala"
3480                 while (TRUE) {
3481 #line 3463 "project.c"
3482                         ModelTrack* t;
3483 #line 744 "project.vala"
3484                         if (!gee_iterator_next (_t_it)) {
3485 #line 744 "project.vala"
3486                                 break;
3487 #line 3469 "project.c"
3488                         }
3489 #line 744 "project.vala"
3490                         t = (ModelTrack*) gee_iterator_get (_t_it);
3491 #line 3473 "project.c"
3492                         {
3493                                 gint i;
3494 #line 745 "project.vala"
3495                                 i = 0;
3496 #line 3478 "project.c"
3497                                 {
3498                                         gboolean _tmp0_;
3499 #line 745 "project.vala"
3500                                         _tmp0_ = TRUE;
3501 #line 745 "project.vala"
3502                                         while (TRUE) {
3503 #line 3485 "project.c"
3504                                                 ModelClip* _tmp1_;
3505                                                 gboolean _tmp2_;
3506 #line 745 "project.vala"
3507                                                 if (!_tmp0_) {
3508 #line 745 "project.vala"
3509                                                         i++;
3510 #line 3492 "project.c"
3511                                                 }
3512 #line 745 "project.vala"
3513                                                 _tmp0_ = FALSE;
3514 #line 745 "project.vala"
3515                                                 if (!(i < gee_collection_get_size (GEE_COLLECTION (t->clips)))) {
3516 #line 745 "project.vala"
3517                                                         break;
3518 #line 3500 "project.c"
3519                                                 }
3520 #line 746 "project.vala"
3521                                                 if ((_tmp2_ = (_tmp1_ = (ModelClip*) gee_abstract_list_get (GEE_ABSTRACT_LIST (t->clips), i))->clipfile == cf, _g_object_unref0 (_tmp1_), _tmp2_)) {
3522 #line 3504 "project.c"
3523                                                         ModelClip* _tmp3_;
3524 #line 747 "project.vala"
3525                                                         model_track_delete_clip (t, _tmp3_ = (ModelClip*) gee_abstract_list_get (GEE_ABSTRACT_LIST (t->clips), i));
3526 #line 3508 "project.c"
3527                                                         _g_object_unref0 (_tmp3_);
3528 #line 748 "project.vala"
3529                                                         i--;
3530 #line 3512 "project.c"
3531                                                 }
3532                                         }
3533                                 }
3534                         }
3535                         _g_object_unref0 (t);
3536                 }
3537                 _g_object_unref0 (_t_it);
3538         }
3539         {
3540                 GeeIterator* _t_it;
3541                 _t_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (self->inactive_tracks));
3542 #line 753 "project.vala"
3543                 while (TRUE) {
3544 #line 3526 "project.c"
3545                         ModelTrack* t;
3546 #line 753 "project.vala"
3547                         if (!gee_iterator_next (_t_it)) {
3548 #line 753 "project.vala"
3549                                 break;
3550 #line 3532 "project.c"
3551                         }
3552 #line 753 "project.vala"
3553                         t = (ModelTrack*) gee_iterator_get (_t_it);
3554 #line 3536 "project.c"
3555                         {
3556                                 gint i;
3557 #line 754 "project.vala"
3558                                 i = 0;
3559 #line 3541 "project.c"
3560                                 {
3561                                         gboolean _tmp4_;
3562 #line 754 "project.vala"
3563                                         _tmp4_ = TRUE;
3564 #line 754 "project.vala"
3565                                         while (TRUE) {
3566 #line 3548 "project.c"
3567                                                 ModelClip* _tmp5_;
3568                                                 gboolean _tmp6_;
3569 #line 754 "project.vala"
3570                                                 if (!_tmp4_) {
3571 #line 754 "project.vala"
3572                                                         i++;
3573 #line 3555 "project.c"
3574                                                 }
3575 #line 754 "project.vala"
3576                                                 _tmp4_ = FALSE;
3577 #line 754 "project.vala"
3578                                                 if (!(i < gee_collection_get_size (GEE_COLLECTION (t->clips)))) {
3579 #line 754 "project.vala"
3580                                                         break;
3581 #line 3563 "project.c"
3582                                                 }
3583 #line 755 "project.vala"
3584                                                 if ((_tmp6_ = (_tmp5_ = (ModelClip*) gee_abstract_list_get (GEE_ABSTRACT_LIST (t->clips), i))->clipfile == cf, _g_object_unref0 (_tmp5_), _tmp6_)) {
3585 #line 3567 "project.c"
3586                                                         ModelClip* _tmp7_;
3587 #line 756 "project.vala"
3588                                                         model_track_delete_clip (t, _tmp7_ = (ModelClip*) gee_abstract_list_get (GEE_ABSTRACT_LIST (t->clips), i));
3589 #line 3571 "project.c"
3590                                                         _g_object_unref0 (_tmp7_);
3591 #line 757 "project.vala"
3592                                                         i--;
3593 #line 3575 "project.c"
3594                                                 }
3595                                         }
3596                                 }
3597                         }
3598                         _g_object_unref0 (t);
3599                 }
3600                 _g_object_unref0 (_t_it);
3601         }
3602 }
3603
3604
3605 #line 763 "project.vala"
3606 void _model_project_remove_clipfile (ModelProject* self, ModelClipFile* cf) {
3607 #line 763 "project.vala"
3608         g_return_if_fail (MODEL_IS_PROJECT (self));
3609 #line 763 "project.vala"
3610         g_return_if_fail (MODEL_IS_CLIP_FILE (cf));
3611 #line 764 "project.vala"
3612         gee_abstract_collection_remove (GEE_ABSTRACT_COLLECTION (self->clipfiles), cf);
3613 #line 765 "project.vala"
3614         g_signal_emit_by_name (self, "clipfile-removed", cf);
3615 #line 3597 "project.c"
3616 }
3617
3618
3619 #line 768 "project.vala"
3620 void model_project_remove_clipfile (ModelProject* self, const char* filename) {
3621 #line 3603 "project.c"
3622         ModelClipFile* cf;
3623 #line 768 "project.vala"
3624         g_return_if_fail (MODEL_IS_PROJECT (self));
3625 #line 768 "project.vala"
3626         g_return_if_fail (filename != NULL);
3627 #line 769 "project.vala"
3628         cf = model_project_find_clipfile (self, filename);
3629 #line 770 "project.vala"
3630         if (cf != NULL) {
3631 #line 3613 "project.c"
3632                 char* description;
3633                 ModelCommand* clipfile_delete;
3634 #line 771 "project.vala"
3635                 description = g_strdup ("Delete From Library");
3636 #line 772 "project.vala"
3637                 model_undo_manager_start_transaction (self->undo_manager, description);
3638 #line 774 "project.vala"
3639                 model_project_delete_clipfile_from_tracks (self, cf);
3640 #line 776 "project.vala"
3641                 clipfile_delete = MODEL_COMMAND (model_clip_file_delete_command_new (self, cf));
3642 #line 777 "project.vala"
3643                 model_project_do_command (self, clipfile_delete);
3644 #line 779 "project.vala"
3645                 model_undo_manager_end_transaction (self->undo_manager, description);
3646 #line 3628 "project.c"
3647                 _g_free0 (description);
3648                 _model_command_unref0 (clipfile_delete);
3649         }
3650         _g_object_unref0 (cf);
3651 }
3652
3653
3654 #line 783 "project.vala"
3655 ModelClipFile* model_project_find_clipfile (ModelProject* self, const char* filename) {
3656 #line 3638 "project.c"
3657         ModelClipFile* result = NULL;
3658 #line 783 "project.vala"
3659         g_return_val_if_fail (MODEL_IS_PROJECT (self), NULL);
3660 #line 783 "project.vala"
3661         g_return_val_if_fail (filename != NULL, NULL);
3662 #line 3644 "project.c"
3663         {
3664                 GeeIterator* _cf_it;
3665                 _cf_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (self->clipfiles));
3666 #line 784 "project.vala"
3667                 while (TRUE) {
3668 #line 3650 "project.c"
3669                         ModelClipFile* cf;
3670 #line 784 "project.vala"
3671                         if (!gee_iterator_next (_cf_it)) {
3672 #line 784 "project.vala"
3673                                 break;
3674 #line 3656 "project.c"
3675                         }
3676 #line 784 "project.vala"
3677                         cf = (ModelClipFile*) gee_iterator_get (_cf_it);
3678 #line 785 "project.vala"
3679                         if (_vala_strcmp0 (cf->filename, filename) == 0) {
3680 #line 3662 "project.c"
3681                                 result = cf;
3682                                 _g_object_unref0 (_cf_it);
3683 #line 786 "project.vala"
3684                                 return result;
3685 #line 3667 "project.c"
3686                         }
3687                         _g_object_unref0 (cf);
3688                 }
3689                 _g_object_unref0 (_cf_it);
3690         }
3691         result = NULL;
3692 #line 787 "project.vala"
3693         return result;
3694 #line 3676 "project.c"
3695 }
3696
3697
3698 #line 790 "project.vala"
3699 void model_project_reseek (ModelProject* self) {
3700 #line 790 "project.vala"
3701         g_return_if_fail (MODEL_IS_PROJECT (self));
3702 #line 790 "project.vala"
3703         model_project_transport_go (self, model_project_transport_get_position (self));
3704 #line 3686 "project.c"
3705 }
3706
3707
3708 #line 792 "project.vala"
3709 void model_project_go_start (ModelProject* self) {
3710 #line 792 "project.vala"
3711         g_return_if_fail (MODEL_IS_PROJECT (self));
3712 #line 792 "project.vala"
3713         model_project_transport_go (self, (gint64) 0);
3714 #line 3696 "project.c"
3715 }
3716
3717
3718 #line 794 "project.vala"
3719 void model_project_go_end (ModelProject* self) {
3720 #line 794 "project.vala"
3721         g_return_if_fail (MODEL_IS_PROJECT (self));
3722 #line 794 "project.vala"
3723         model_project_transport_go (self, model_project_get_length (self));
3724 #line 3706 "project.c"
3725 }
3726
3727
3728 #line 796 "project.vala"
3729 void model_project_go_previous (ModelProject* self) {
3730 #line 3712 "project.c"
3731         gint64 start_pos;
3732         gint64 new_position;
3733 #line 796 "project.vala"
3734         g_return_if_fail (MODEL_IS_PROJECT (self));
3735 #line 797 "project.vala"
3736         start_pos = model_project_transport_get_position (self);
3737 #line 801 "project.vala"
3738         if (model_project_transport_is_playing (self)) {
3739 #line 802 "project.vala"
3740                 start_pos = start_pos - ((gint64) (1 * GST_SECOND));
3741 #line 3723 "project.c"
3742         }
3743 #line 804 "project.vala"
3744         new_position = (gint64) 0;
3745 #line 3727 "project.c"
3746         {
3747                 GeeIterator* _track_it;
3748                 _track_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (self->tracks));
3749 #line 805 "project.vala"
3750                 while (TRUE) {
3751 #line 3733 "project.c"
3752                         ModelTrack* track;
3753 #line 805 "project.vala"
3754                         if (!gee_iterator_next (_track_it)) {
3755 #line 805 "project.vala"
3756                                 break;
3757 #line 3739 "project.c"
3758                         }
3759 #line 805 "project.vala"
3760                         track = (ModelTrack*) gee_iterator_get (_track_it);
3761 #line 806 "project.vala"
3762                         new_position = MAX (new_position, model_track_previous_edit (track, start_pos));
3763 #line 3745 "project.c"
3764                         _g_object_unref0 (track);
3765                 }
3766                 _g_object_unref0 (_track_it);
3767         }
3768 #line 808 "project.vala"
3769         model_project_transport_go (self, new_position);
3770 #line 3752 "project.c"
3771 }
3772
3773
3774 #line 812 "project.vala"
3775 void model_project_go_next (ModelProject* self) {
3776 #line 3758 "project.c"
3777         gint64 start_pos;
3778         gint64 new_position;
3779 #line 812 "project.vala"
3780         g_return_if_fail (MODEL_IS_PROJECT (self));
3781 #line 813 "project.vala"
3782         start_pos = model_project_transport_get_position (self);
3783 #line 814 "project.vala"
3784         new_position = model_project_get_length (self);
3785 #line 3767 "project.c"
3786         {
3787                 GeeIterator* _track_it;
3788                 _track_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (self->tracks));
3789 #line 815 "project.vala"
3790                 while (TRUE) {
3791 #line 3773 "project.c"
3792                         ModelTrack* track;
3793 #line 815 "project.vala"
3794                         if (!gee_iterator_next (_track_it)) {
3795 #line 815 "project.vala"
3796                                 break;
3797 #line 3779 "project.c"
3798                         }
3799 #line 815 "project.vala"
3800                         track = (ModelTrack*) gee_iterator_get (_track_it);
3801 #line 816 "project.vala"
3802                         if (model_track_get_length (track) > start_pos) {
3803 #line 817 "project.vala"
3804                                 new_position = MIN (new_position, model_track_next_edit (track, start_pos));
3805 #line 3787 "project.c"
3806                         }
3807                         _g_object_unref0 (track);
3808                 }
3809                 _g_object_unref0 (_track_it);
3810         }
3811 #line 820 "project.vala"
3812         model_project_transport_go (self, new_position);
3813 #line 3795 "project.c"
3814 }
3815
3816
3817 #line 823 "project.vala"
3818 gint64 model_project_transport_get_position (ModelProject* self) {
3819 #line 3801 "project.c"
3820         gint64 result = 0LL;
3821 #line 823 "project.vala"
3822         g_return_val_if_fail (MODEL_IS_PROJECT (self), 0LL);
3823 #line 3805 "project.c"
3824         result = self->media_engine->position;
3825 #line 824 "project.vala"
3826         return result;
3827 #line 3809 "project.c"
3828 }
3829
3830
3831 #line 827 "project.vala"
3832 void model_project_set_name (ModelProject* self, const char* filename) {
3833 #line 827 "project.vala"
3834         g_return_if_fail (MODEL_IS_PROJECT (self));
3835 #line 828 "project.vala"
3836         if (filename != NULL) {
3837 #line 3819 "project.c"
3838                 char* _tmp0_;
3839 #line 829 "project.vala"
3840                 self->project_file = (_tmp0_ = g_strdup (filename), _g_free0 (self->project_file), _tmp0_);
3841 #line 3823 "project.c"
3842         }
3843 #line 831 "project.vala"
3844         g_signal_emit_by_name (self, "name-changed", filename);
3845 #line 3827 "project.c"
3846 }
3847
3848
3849 #line 834 "project.vala"
3850 void model_project_set_default_framerate (ModelProject* self, Fraction* rate) {
3851 #line 834 "project.vala"
3852         g_return_if_fail (MODEL_IS_PROJECT (self));
3853 #line 835 "project.vala"
3854         self->default_framerate = *rate;
3855 #line 3837 "project.c"
3856 }
3857
3858
3859 #line 1077 "glib-2.0.vapi"
3860 static char* string_substring (const char* self, glong offset, glong len) {
3861 #line 3843 "project.c"
3862         char* result = NULL;
3863         glong string_length;
3864         const char* start;
3865 #line 1077 "glib-2.0.vapi"
3866         g_return_val_if_fail (self != NULL, NULL);
3867 #line 1078 "glib-2.0.vapi"
3868         string_length = g_utf8_strlen (self, -1);
3869 #line 1079 "glib-2.0.vapi"
3870         if (offset < 0) {
3871 #line 1080 "glib-2.0.vapi"
3872                 offset = string_length + offset;
3873 #line 1081 "glib-2.0.vapi"
3874                 g_return_val_if_fail (offset >= 0, NULL);
3875 #line 3857 "project.c"
3876         } else {
3877 #line 1083 "glib-2.0.vapi"
3878                 g_return_val_if_fail (offset <= string_length, NULL);
3879 #line 3861 "project.c"
3880         }
3881 #line 1085 "glib-2.0.vapi"
3882         if (len < 0) {
3883 #line 1086 "glib-2.0.vapi"
3884                 len = string_length - offset;
3885 #line 3867 "project.c"
3886         }
3887 #line 1088 "glib-2.0.vapi"
3888         g_return_val_if_fail ((offset + len) <= string_length, NULL);
3889 #line 1089 "glib-2.0.vapi"
3890         start = g_utf8_offset_to_pointer (self, offset);
3891 #line 3873 "project.c"
3892         result = g_strndup (start, ((gchar*) g_utf8_offset_to_pointer (start, len)) - ((gchar*) start));
3893 #line 1090 "glib-2.0.vapi"
3894         return result;
3895 #line 3877 "project.c"
3896 }
3897
3898
3899 static glong string_get_length (const char* self) {
3900         glong result;
3901         g_return_val_if_fail (self != NULL, 0L);
3902         result = g_utf8_strlen (self, -1);
3903 #line 1158 "glib-2.0.vapi"
3904         return result;
3905 #line 3887 "project.c"
3906 }
3907
3908
3909 #line 838 "project.vala"
3910 char* model_project_get_file_display_name (ModelProject* self) {
3911 #line 3893 "project.c"
3912         char* result = NULL;
3913         char* filename;
3914 #line 838 "project.vala"
3915         g_return_val_if_fail (MODEL_IS_PROJECT (self), NULL);
3916 #line 839 "project.vala"
3917         filename = model_project_get_project_file (self);
3918 #line 840 "project.vala"
3919         if (filename == NULL) {
3920 #line 3902 "project.c"
3921                 char* _tmp0_;
3922                 char* _tmp1_;
3923                 result = (_tmp1_ = g_strdup_printf ("Unsaved Project - %s", _tmp0_ = model_project_get_app_name (self)), _g_free0 (_tmp0_), _tmp1_);
3924                 _g_free0 (filename);
3925 #line 841 "project.vala"
3926                 return result;
3927 #line 3909 "project.c"
3928         } else {
3929                 char* dir;
3930                 char* name;
3931                 char* home_path;
3932                 char* _tmp5_;
3933                 char* _tmp6_;
3934 #line 844 "project.vala"
3935                 dir = g_path_get_dirname (filename);
3936 #line 845 "project.vala"
3937                 name = g_path_get_basename (filename);
3938 #line 846 "project.vala"
3939                 home_path = g_strdup (g_get_home_dir ());
3940 #line 848 "project.vala"
3941                 if (_vala_strcmp0 (dir, ".") == 0) {
3942 #line 3924 "project.c"
3943                         char* _tmp2_;
3944 #line 849 "project.vala"
3945                         dir = (_tmp2_ = g_get_current_dir (), _g_free0 (dir), _tmp2_);
3946 #line 3928 "project.c"
3947                 }
3948 #line 851 "project.vala"
3949                 if (g_str_has_prefix (dir, home_path)) {
3950 #line 3932 "project.c"
3951                         char* _tmp4_;
3952                         char* _tmp3_;
3953 #line 852 "project.vala"
3954                         dir = (_tmp4_ = g_strconcat ("~", _tmp3_ = string_substring (dir, string_get_length (home_path), -1), NULL), _g_free0 (dir), _tmp4_);
3955 #line 3937 "project.c"
3956                         _g_free0 (_tmp3_);
3957                 }
3958                 result = (_tmp6_ = g_strdup_printf ("%s (%s) - %s", name, dir, _tmp5_ = model_project_get_app_name (self)), _g_free0 (_tmp5_), _tmp6_);
3959                 _g_free0 (dir);
3960                 _g_free0 (name);
3961                 _g_free0 (home_path);
3962                 _g_free0 (filename);
3963 #line 853 "project.vala"
3964                 return result;
3965 #line 3947 "project.c"
3966                 _g_free0 (dir);
3967                 _g_free0 (name);
3968                 _g_free0 (home_path);
3969         }
3970         _g_free0 (filename);
3971 }
3972
3973
3974 #line 857 "project.vala"
3975 void model_project_clear (ModelProject* self) {
3976 #line 857 "project.vala"
3977         g_return_if_fail (MODEL_IS_PROJECT (self));
3978 #line 858 "project.vala"
3979         view_media_engine_set_gst_state (self->media_engine, GST_STATE_NULL);
3980 #line 3962 "project.c"
3981         {
3982                 GeeIterator* _track_it;
3983                 _track_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (self->tracks));
3984 #line 860 "project.vala"
3985                 while (TRUE) {
3986 #line 3968 "project.c"
3987                         ModelTrack* track;
3988 #line 860 "project.vala"
3989                         if (!gee_iterator_next (_track_it)) {
3990 #line 860 "project.vala"
3991                                 break;
3992 #line 3974 "project.c"
3993                         }
3994 #line 860 "project.vala"
3995                         track = (ModelTrack*) gee_iterator_get (_track_it);
3996 #line 861 "project.vala"
3997                         model_track_delete_all_clips (track);
3998 #line 862 "project.vala"
3999                         g_signal_emit_by_name (track, "track-removed", track);
4000 #line 863 "project.vala"
4001                         g_signal_emit_by_name (self, "track-removed", track);
4002 #line 3984 "project.c"
4003                         _g_object_unref0 (track);
4004                 }
4005                 _g_object_unref0 (_track_it);
4006         }
4007 #line 866 "project.vala"
4008         gee_abstract_collection_clear (GEE_ABSTRACT_COLLECTION (self->tracks));
4009 #line 868 "project.vala"
4010         gee_abstract_collection_clear (GEE_ABSTRACT_COLLECTION (self->clipfiles));
4011 #line 869 "project.vala"
4012         model_project_set_name (self, NULL);
4013 #line 870 "project.vala"
4014         g_signal_emit_by_name (self, "cleared");
4015 #line 3997 "project.c"
4016 }
4017
4018
4019 #line 873 "project.vala"
4020 gboolean model_project_can_export (ModelProject* self) {
4021 #line 4003 "project.c"
4022         gboolean result = FALSE;
4023 #line 873 "project.vala"
4024         g_return_val_if_fail (MODEL_IS_PROJECT (self), FALSE);
4025 #line 874 "project.vala"
4026         if (view_media_engine_get_play_state (self->media_engine) != PLAY_STATE_STOPPED) {
4027 #line 4009 "project.c"
4028                 result = FALSE;
4029 #line 875 "project.vala"
4030                 return result;
4031 #line 4013 "project.c"
4032         }
4033         {
4034                 GeeIterator* _track_it;
4035                 _track_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (self->tracks));
4036 #line 877 "project.vala"
4037                 while (TRUE) {
4038 #line 4020 "project.c"
4039                         ModelTrack* track;
4040 #line 877 "project.vala"
4041                         if (!gee_iterator_next (_track_it)) {
4042 #line 877 "project.vala"
4043                                 break;
4044 #line 4026 "project.c"
4045                         }
4046 #line 877 "project.vala"
4047                         track = (ModelTrack*) gee_iterator_get (_track_it);
4048 #line 878 "project.vala"
4049                         if (model_track_get_length (track) > 0) {
4050 #line 4032 "project.c"
4051                                 result = TRUE;
4052                                 _g_object_unref0 (track);
4053                                 _g_object_unref0 (_track_it);
4054 #line 879 "project.vala"
4055                                 return result;
4056 #line 4038 "project.c"
4057                         }
4058                         _g_object_unref0 (track);
4059                 }
4060                 _g_object_unref0 (_track_it);
4061         }
4062         result = FALSE;
4063 #line 882 "project.vala"
4064         return result;
4065 #line 4047 "project.c"
4066 }
4067
4068
4069 #line 885 "project.vala"
4070 void model_project_on_load_started (ModelProject* self, const char* filename) {
4071 #line 4053 "project.c"
4072         char* _tmp0_;
4073 #line 885 "project.vala"
4074         g_return_if_fail (MODEL_IS_PROJECT (self));
4075 #line 885 "project.vala"
4076         g_return_if_fail (filename != NULL);
4077 #line 886 "project.vala"
4078         logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_load_started");
4079 #line 887 "project.vala"
4080         self->project_file = (_tmp0_ = g_strdup (filename), _g_free0 (self->project_file), _tmp0_);
4081 #line 4063 "project.c"
4082 }
4083
4084
4085 #line 890 "project.vala"
4086 static void model_project_on_load_error (ModelProject* self, const char* _error_) {
4087 #line 890 "project.vala"
4088         g_return_if_fail (MODEL_IS_PROJECT (self));
4089 #line 890 "project.vala"
4090         g_return_if_fail (_error_ != NULL);
4091 #line 891 "project.vala"
4092         logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_load_error");
4093 #line 892 "project.vala"
4094         g_signal_emit_by_name (self, "load-error", _error_);
4095 #line 4077 "project.c"
4096 }
4097
4098
4099 #line 895 "project.vala"
4100 static void model_project_on_load_complete (ModelProject* self) {
4101 #line 895 "project.vala"
4102         g_return_if_fail (MODEL_IS_PROJECT (self));
4103 #line 896 "project.vala"
4104         logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_load_complete");
4105 #line 897 "project.vala"
4106         model_undo_manager_reset (self->undo_manager);
4107 #line 898 "project.vala"
4108         model_project_set_name (self, self->project_file);
4109 #line 899 "project.vala"
4110         g_signal_emit_by_name (self, "load-complete");
4111 #line 4093 "project.c"
4112 }
4113
4114
4115 #line 885 "project.vala"
4116 static void _model_project_on_load_started_model_project_loader_load_started (ModelProjectLoader* _sender, const char* filename, gpointer self) {
4117 #line 4099 "project.c"
4118         model_project_on_load_started (self, filename);
4119 }
4120
4121
4122 #line 890 "project.vala"
4123 static void _model_project_on_load_error_model_project_loader_load_error (ModelProjectLoader* _sender, const char* _error_, gpointer self) {
4124 #line 4106 "project.c"
4125         model_project_on_load_error (self, _error_);
4126 }
4127
4128
4129 #line 895 "project.vala"
4130 static void _model_project_on_load_complete_model_project_loader_load_complete (ModelProjectLoader* _sender, gpointer self) {
4131 #line 4113 "project.c"
4132         model_project_on_load_complete (self);
4133 }
4134
4135
4136 #line 1041 "MediaEngine.vala"
4137 static void _view_media_engine_on_load_complete_model_project_loader_load_complete (ModelProjectLoader* _sender, gpointer self) {
4138 #line 4120 "project.c"
4139         view_media_engine_on_load_complete (self);
4140 }
4141
4142
4143 #line 905 "project.vala"
4144 static void model_project_real_load (ModelProject* self, const char* fname) {
4145 #line 4127 "project.c"
4146         ModelProjectLoader* _tmp1_;
4147         ModelMediaLoaderHandler* _tmp0_;
4148 #line 905 "project.vala"
4149         g_return_if_fail (MODEL_IS_PROJECT (self));
4150 #line 906 "project.vala"
4151         logging_emit (G_OBJECT (self), LOGGING_FACILITY_LOADING, LOGGING_LEVEL_INFO, "loading project");
4152 #line 907 "project.vala"
4153         model_project_clear (self);
4154 #line 908 "project.vala"
4155         model_project_set_name (self, NULL);
4156 #line 909 "project.vala"
4157         if (fname == NULL) {
4158 #line 910 "project.vala"
4159                 return;
4160 #line 4142 "project.c"
4161         }
4162 #line 913 "project.vala"
4163         self->loader = (_tmp1_ = model_project_loader_new (MODEL_LOADER_HANDLER (_tmp0_ = model_media_loader_handler_new (self)), fname), _g_object_unref0 (self->loader), _tmp1_);
4164 #line 4146 "project.c"
4165         _g_object_unref0 (_tmp0_);
4166 #line 915 "project.vala"
4167         g_signal_connect_object (self->loader, "load-started", (GCallback) _model_project_on_load_started_model_project_loader_load_started, self, 0);
4168 #line 916 "project.vala"
4169         g_signal_connect_object (self->loader, "load-error", (GCallback) _model_project_on_load_error_model_project_loader_load_error, self, 0);
4170 #line 917 "project.vala"
4171         g_signal_connect_object (self->loader, "load-complete", (GCallback) _model_project_on_load_complete_model_project_loader_load_complete, self, 0);
4172 #line 918 "project.vala"
4173         g_signal_connect_object (self->loader, "load-complete", (GCallback) _view_media_engine_on_load_complete_model_project_loader_load_complete, self->media_engine, 0);
4174 #line 919 "project.vala"
4175         view_media_engine_set_play_state (self->media_engine, PLAY_STATE_LOADING);
4176 #line 920 "project.vala"
4177         gst_element_set_state (GST_ELEMENT (self->media_engine->pipeline), GST_STATE_NULL);
4178 #line 921 "project.vala"
4179         model_project_loader_load (self->loader);
4180 #line 4162 "project.c"
4181 }
4182
4183
4184 #line 905 "project.vala"
4185 void model_project_load (ModelProject* self, const char* fname) {
4186 #line 905 "project.vala"
4187         MODEL_PROJECT_GET_CLASS (self)->load (self, fname);
4188 #line 4170 "project.c"
4189 }
4190
4191
4192 #line 924 "project.vala"
4193 void model_project_on_error_occurred (ModelProject* self, const char* major_error, const char* minor_error) {
4194 #line 924 "project.vala"
4195         g_return_if_fail (MODEL_IS_PROJECT (self));
4196 #line 924 "project.vala"
4197         g_return_if_fail (major_error != NULL);
4198 #line 925 "project.vala"
4199         logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_error_occurred");
4200 #line 926 "project.vala"
4201         g_signal_emit_by_name (self, "error-occurred", major_error, minor_error);
4202 #line 4184 "project.c"
4203 }
4204
4205
4206 #line 929 "project.vala"
4207 gint model_project_get_file_version (ModelProject* self) {
4208 #line 4190 "project.c"
4209         gint result = 0;
4210 #line 929 "project.vala"
4211         g_return_val_if_fail (MODEL_IS_PROJECT (self), 0);
4212 #line 4194 "project.c"
4213         result = 4;
4214 #line 930 "project.vala"
4215         return result;
4216 #line 4198 "project.c"
4217 }
4218
4219
4220 #line 933 "project.vala"
4221 void model_project_save_library (ModelProject* self, FILE* f) {
4222 #line 4204 "project.c"
4223         Fraction r;
4224 #line 933 "project.vala"
4225         g_return_if_fail (MODEL_IS_PROJECT (self));
4226 #line 933 "project.vala"
4227         g_return_if_fail (f != NULL);
4228 #line 934 "project.vala"
4229         fprintf (f, "  <library");
4230 #line 936 "project.vala"
4231         r = self->default_framerate;
4232 #line 4214 "project.c"
4233         {
4234                 GeeIterator* _t_it;
4235                 _t_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (self->tracks));
4236 #line 938 "project.vala"
4237                 while (TRUE) {
4238 #line 4220 "project.c"
4239                         ModelTrack* t;
4240 #line 938 "project.vala"
4241                         if (!gee_iterator_next (_t_it)) {
4242 #line 938 "project.vala"
4243                                 break;
4244 #line 4226 "project.c"
4245                         }
4246 #line 938 "project.vala"
4247                         t = (ModelTrack*) gee_iterator_get (_t_it);
4248 #line 939 "project.vala"
4249                         if (model_track_media_type (t) == MODEL_MEDIA_TYPE_VIDEO) {
4250 #line 4232 "project.c"
4251                                 ModelTrack* _tmp0_;
4252                                 ModelVideoTrack* video_track;
4253 #line 940 "project.vala"
4254                                 video_track = _g_object_ref0 ((_tmp0_ = t, MODEL_IS_VIDEO_TRACK (_tmp0_) ? ((ModelVideoTrack*) _tmp0_) : NULL));
4255 #line 941 "project.vala"
4256                                 if (model_video_track_get_framerate (video_track, &r)) {
4257 #line 4239 "project.c"
4258                                         _g_object_unref0 (video_track);
4259                                         _g_object_unref0 (t);
4260 #line 942 "project.vala"
4261                                         break;
4262 #line 4244 "project.c"
4263                                 }
4264                                 _g_object_unref0 (video_track);
4265                         }
4266                         _g_object_unref0 (t);
4267                 }
4268                 _g_object_unref0 (_t_it);
4269         }
4270 #line 945 "project.vala"
4271         if (!fraction_equal (&r, &model_project_INVALID_FRAME_RATE)) {
4272 #line 946 "project.vala"
4273                 fprintf (f, " framerate=\"%d/%d\"", r.numerator, r.denominator);
4274 #line 4256 "project.c"
4275         }
4276 #line 948 "project.vala"
4277         fprintf (f, ">\n");
4278 #line 4260 "project.c"
4279         {
4280                 gint i;
4281 #line 950 "project.vala"
4282                 i = 0;
4283 #line 4265 "project.c"
4284                 {
4285                         gboolean _tmp1_;
4286 #line 950 "project.vala"
4287                         _tmp1_ = TRUE;
4288 #line 950 "project.vala"
4289                         while (TRUE) {
4290 #line 4272 "project.c"
4291                                 ModelClipFile* _tmp2_;
4292 #line 950 "project.vala"
4293                                 if (!_tmp1_) {
4294 #line 950 "project.vala"
4295                                         i++;
4296 #line 4278 "project.c"
4297                                 }
4298 #line 950 "project.vala"
4299                                 _tmp1_ = FALSE;
4300 #line 950 "project.vala"
4301                                 if (!(i < gee_collection_get_size (GEE_COLLECTION (self->clipfiles)))) {
4302 #line 950 "project.vala"
4303                                         break;
4304 #line 4286 "project.c"
4305                                 }
4306 #line 951 "project.vala"
4307                                 fprintf (f, "    <clipfile filename=\"%s\" id=\"%d\"/>\n", (_tmp2_ = (ModelClipFile*) gee_abstract_list_get (GEE_ABSTRACT_LIST (self->clipfiles), i))->filename, i);
4308 #line 4290 "project.c"
4309                                 _g_object_unref0 (_tmp2_);
4310                         }
4311                 }
4312         }
4313 #line 954 "project.vala"
4314         fprintf (f, "  </library>\n");
4315 #line 4297 "project.c"
4316 }
4317
4318
4319 #line 957 "project.vala"
4320 static void model_project_real_save (ModelProject* self, const char* filename) {
4321 #line 4303 "project.c"
4322         FILE* f;
4323         const char* _tmp1_;
4324         const char* _tmp2_;
4325         const char* _tmp3_;
4326         char* _tmp4_;
4327 #line 957 "project.vala"
4328         g_return_if_fail (MODEL_IS_PROJECT (self));
4329 #line 958 "project.vala"
4330         if (filename != NULL) {
4331 #line 959 "project.vala"
4332                 model_project_set_name (self, filename);
4333 #line 4315 "project.c"
4334         }
4335 #line 962 "project.vala"
4336         f = fopen (self->project_file, "w");
4337 #line 963 "project.vala"
4338         if (f == NULL) {
4339 #line 4321 "project.c"
4340                 char* _tmp0_;
4341 #line 964 "project.vala"
4342                 g_signal_emit_by_name (self, "error-occurred", "Could not save project", _tmp0_ = g_strdup_printf ("%s: %s", self->project_file, g_strerror (errno)));
4343 #line 4325 "project.c"
4344                 _g_free0 (_tmp0_);
4345                 _fclose0 (f);
4346 #line 966 "project.vala"
4347                 return;
4348 #line 4330 "project.c"
4349         }
4350 #line 968 "project.vala"
4351         fprintf (f, "<marina version=\"%d\">\n", model_project_get_file_version (self));
4352 #line 970 "project.vala"
4353         model_project_save_library (self, f);
4354 #line 972 "project.vala"
4355         fprintf (f, "  <tracks>\n");
4356 #line 4338 "project.c"
4357         {
4358                 GeeIterator* _track_it;
4359                 _track_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (self->tracks));
4360 #line 973 "project.vala"
4361                 while (TRUE) {
4362 #line 4344 "project.c"
4363                         ModelTrack* track;
4364 #line 973 "project.vala"
4365                         if (!gee_iterator_next (_track_it)) {
4366 #line 973 "project.vala"
4367                                 break;
4368 #line 4350 "project.c"
4369                         }
4370 #line 973 "project.vala"
4371                         track = (ModelTrack*) gee_iterator_get (_track_it);
4372 #line 974 "project.vala"
4373                         model_track_save (track, f);
4374 #line 4356 "project.c"
4375                         _g_object_unref0 (track);
4376                 }
4377                 _g_object_unref0 (_track_it);
4378         }
4379         {
4380                 GeeIterator* _track_it;
4381                 _track_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (self->inactive_tracks));
4382 #line 977 "project.vala"
4383                 while (TRUE) {
4384 #line 4366 "project.c"
4385                         ModelTrack* track;
4386 #line 977 "project.vala"
4387                         if (!gee_iterator_next (_track_it)) {
4388 #line 977 "project.vala"
4389                                 break;
4390 #line 4372 "project.c"
4391                         }
4392 #line 977 "project.vala"
4393                         track = (ModelTrack*) gee_iterator_get (_track_it);
4394 #line 978 "project.vala"
4395                         model_track_save (track, f);
4396 #line 4378 "project.c"
4397                         _g_object_unref0 (track);
4398                 }
4399                 _g_object_unref0 (_track_it);
4400         }
4401 #line 980 "project.vala"
4402         fprintf (f, "  </tracks>\n");
4403 #line 981 "project.vala"
4404         fprintf (f, "  <preferences>\n");
4405 #line 4387 "project.c"
4406         _tmp1_ = NULL;
4407 #line 983 "project.vala"
4408         if (self->click_during_play) {
4409 #line 983 "project.vala"
4410                 _tmp1_ = "true";
4411 #line 4393 "project.c"
4412         } else {
4413 #line 983 "project.vala"
4414                 _tmp1_ = "false";
4415 #line 4397 "project.c"
4416         }
4417         _tmp2_ = NULL;
4418 #line 984 "project.vala"
4419         if (self->click_during_record) {
4420 #line 984 "project.vala"
4421                 _tmp2_ = "true";
4422 #line 4404 "project.c"
4423         } else {
4424 #line 984 "project.vala"
4425                 _tmp2_ = "false";
4426 #line 4408 "project.c"
4427         }
4428 #line 982 "project.vala"
4429         fprintf (f, "    <click on_play=\"%s\" on_record=\"%s\" volume=\"%lf\"/>\n", _tmp1_, _tmp2_, self->click_volume);
4430 #line 4412 "project.c"
4431         _tmp3_ = NULL;
4432 #line 987 "project.vala"
4433         if (self->library_visible) {
4434 #line 987 "project.vala"
4435                 _tmp3_ = "true";
4436 #line 4418 "project.c"
4437         } else {
4438 #line 987 "project.vala"
4439                 _tmp3_ = "false";
4440 #line 4422 "project.c"
4441         }
4442 #line 986 "project.vala"
4443         fprintf (f, "    <library width=\"%d\" visible=\"%s\" />\n", self->library_width, _tmp3_);
4444 #line 988 "project.vala"
4445         fprintf (f, "  </preferences>\n");
4446 #line 989 "project.vala"
4447         fprintf (f, "  <maps>\n");
4448 #line 990 "project.vala"
4449         fprintf (f, "    <tempo>\n");
4450 #line 991 "project.vala"
4451         fprintf (f, "      <entry tempo=\"%d\" />\n", self->priv->tempo);
4452 #line 992 "project.vala"
4453         fprintf (f, "    </tempo>\n");
4454 #line 993 "project.vala"
4455         fprintf (f, "    <time_signature>\n");
4456 #line 994 "project.vala"
4457         fprintf (f, "      <entry signature=\"%s\" />\n", _tmp4_ = fraction_to_string (&self->priv->time_signature));
4458 #line 4440 "project.c"
4459         _g_free0 (_tmp4_);
4460 #line 995 "project.vala"
4461         fprintf (f, "    </time_signature>\n");
4462 #line 996 "project.vala"
4463         fprintf (f, "  </maps>\n");
4464 #line 998 "project.vala"
4465         fprintf (f, "</marina>\n");
4466 #line 999 "project.vala"
4467         fflush (f);
4468 #line 1002 "project.vala"
4469         model_undo_manager_mark_clean (self->undo_manager);
4470 #line 4452 "project.c"
4471         _fclose0 (f);
4472 }
4473
4474
4475 #line 957 "project.vala"
4476 void model_project_save (ModelProject* self, const char* filename) {
4477 #line 957 "project.vala"
4478         MODEL_PROJECT_GET_CLASS (self)->save (self, filename);
4479 #line 4461 "project.c"
4480 }
4481
4482
4483 #line 1005 "project.vala"
4484 void model_project_close (ModelProject* self) {
4485 #line 1005 "project.vala"
4486         g_return_if_fail (MODEL_IS_PROJECT (self));
4487 #line 1006 "project.vala"
4488         view_media_engine_close (self->media_engine);
4489 #line 4471 "project.c"
4490 }
4491
4492
4493 #line 1009 "project.vala"
4494 void model_project_on_importer_clip_complete (ModelProject* self, ModelClipFetcher* fetcher) {
4495 #line 1009 "project.vala"
4496         g_return_if_fail (MODEL_IS_PROJECT (self));
4497 #line 1009 "project.vala"
4498         g_return_if_fail (MODEL_IS_CLIP_FETCHER (fetcher));
4499 #line 1010 "project.vala"
4500         if (MODEL_FETCHER (fetcher)->error_string != NULL) {
4501 #line 1011 "project.vala"
4502                 g_signal_emit_by_name (self, "error-occurred", "Error importing clip", MODEL_FETCHER (fetcher)->error_string);
4503 #line 4485 "project.c"
4504         } else {
4505 #line 1013 "project.vala"
4506                 model_fetcher_completion_complete (self->priv->fetcher_completion, MODEL_FETCHER (fetcher));
4507 #line 4489 "project.c"
4508         }
4509 }
4510
4511
4512 static gpointer _model_fetcher_completion_ref0 (gpointer self) {
4513         return self ? model_fetcher_completion_ref (self) : NULL;
4514 }
4515
4516
4517 #line 1026 "project.vala"
4518 static void _model_project_on_fetcher_ready_model_fetcher_ready (ModelFetcher* _sender, ModelFetcher* fetcher, gpointer self) {
4519 #line 4501 "project.c"
4520         model_project_on_fetcher_ready (self, fetcher);
4521 }
4522
4523
4524 #line 1017 "project.vala"
4525 void model_project_create_clip_fetcher (ModelProject* self, ModelFetcherCompletion* fetcher_completion, const char* filename, GError** error) {
4526 #line 4508 "project.c"
4527         GError * _inner_error_;
4528         ModelClipFetcher* fetcher;
4529         ModelFetcherCompletion* _tmp0_;
4530 #line 1017 "project.vala"
4531         g_return_if_fail (MODEL_IS_PROJECT (self));
4532 #line 1017 "project.vala"
4533         g_return_if_fail (MODEL_IS_FETCHER_COMPLETION (fetcher_completion));
4534 #line 1017 "project.vala"
4535         g_return_if_fail (filename != NULL);
4536 #line 4518 "project.c"
4537         _inner_error_ = NULL;
4538 #line 1019 "project.vala"
4539         fetcher = model_clip_fetcher_new (filename, &_inner_error_);
4540 #line 4522 "project.c"
4541         if (_inner_error_ != NULL) {
4542                 g_propagate_error (error, _inner_error_);
4543                 return;
4544         }
4545 #line 1020 "project.vala"
4546         self->priv->fetcher_completion = (_tmp0_ = _model_fetcher_completion_ref0 (fetcher_completion), _model_fetcher_completion_unref0 (self->priv->fetcher_completion), _tmp0_);
4547 #line 1021 "project.vala"
4548         g_signal_connect_object (MODEL_FETCHER (fetcher), "ready", (GCallback) _model_project_on_fetcher_ready_model_fetcher_ready, self, 0);
4549 #line 1022 "project.vala"
4550         gee_abstract_collection_add (GEE_ABSTRACT_COLLECTION (self->priv->pending), fetcher);
4551 #line 4533 "project.c"
4552         _g_object_unref0 (fetcher);
4553 }
4554
4555
4556 #line 1026 "project.vala"
4557 static void model_project_on_fetcher_ready (ModelProject* self, ModelFetcher* fetcher) {
4558 #line 4540 "project.c"
4559         ModelFetcher* _tmp0_;
4560 #line 1026 "project.vala"
4561         g_return_if_fail (MODEL_IS_PROJECT (self));
4562 #line 1026 "project.vala"
4563         g_return_if_fail (MODEL_IS_FETCHER (fetcher));
4564 #line 1027 "project.vala"
4565         logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_fetcher_ready");
4566 #line 1028 "project.vala"
4567         gee_abstract_collection_remove (GEE_ABSTRACT_COLLECTION (self->priv->pending), (_tmp0_ = fetcher, MODEL_IS_CLIP_FETCHER (_tmp0_) ? ((ModelClipFetcher*) _tmp0_) : NULL));
4568 #line 1029 "project.vala"
4569         if (fetcher->error_string != NULL) {
4570 #line 1030 "project.vala"
4571                 logging_emit (G_OBJECT (self), LOGGING_FACILITY_DEVELOPER_WARNINGS, LOGGING_LEVEL_INFO, fetcher->error_string);
4572 #line 1031 "project.vala"
4573                 g_signal_emit_by_name (self, "error-occurred", "Error retrieving clip", fetcher->error_string);
4574 #line 4556 "project.c"
4575         } else {
4576 #line 1033 "project.vala"
4577                 if (model_project_get_clipfile_index (self, fetcher->clipfile) == (-1)) {
4578 #line 1034 "project.vala"
4579                         model_project_add_clipfile (self, fetcher->clipfile);
4580 #line 4562 "project.c"
4581                 }
4582 #line 1036 "project.vala"
4583                 model_fetcher_completion_complete (self->priv->fetcher_completion, fetcher);
4584 #line 4566 "project.c"
4585         }
4586 }
4587
4588
4589 #line 1040 "project.vala"
4590 gboolean model_project_is_project_extension (ModelProject* self, const char* filename) {
4591 #line 4573 "project.c"
4592         gboolean result = FALSE;
4593         char* extension;
4594         gboolean _tmp0_ = FALSE;
4595 #line 1040 "project.vala"
4596         g_return_val_if_fail (MODEL_IS_PROJECT (self), FALSE);
4597 #line 1040 "project.vala"
4598         g_return_val_if_fail (filename != NULL, FALSE);
4599 #line 1041 "project.vala"
4600         extension = get_file_extension (filename);
4601 #line 1042 "project.vala"
4602         if (_vala_strcmp0 (extension, MODEL_PROJECT_LOMBARD_FILE_EXTENSION) == 0) {
4603 #line 1042 "project.vala"
4604                 _tmp0_ = TRUE;
4605 #line 4587 "project.c"
4606         } else {
4607 #line 1042 "project.vala"
4608                 _tmp0_ = _vala_strcmp0 (extension, MODEL_PROJECT_FILLMORE_FILE_EXTENSION) == 0;
4609 #line 4591 "project.c"
4610         }
4611         result = _tmp0_;
4612         _g_free0 (extension);
4613 #line 1042 "project.vala"
4614         return result;
4615 #line 4597 "project.c"
4616 }
4617
4618
4619 #line 1045 "project.vala"
4620 void model_project_do_command (ModelProject* self, ModelCommand* the_command) {
4621 #line 1045 "project.vala"
4622         g_return_if_fail (MODEL_IS_PROJECT (self));
4623 #line 1045 "project.vala"
4624         g_return_if_fail (MODEL_IS_COMMAND (the_command));
4625 #line 1046 "project.vala"
4626         model_undo_manager_do_command (self->undo_manager, the_command);
4627 #line 4609 "project.c"
4628 }
4629
4630
4631 #line 1049 "project.vala"
4632 void model_project_undo (ModelProject* self) {
4633 #line 1049 "project.vala"
4634         g_return_if_fail (MODEL_IS_PROJECT (self));
4635 #line 1050 "project.vala"
4636         model_undo_manager_undo (self->undo_manager);
4637 #line 4619 "project.c"
4638 }
4639
4640
4641 #line 1053 "project.vala"
4642 static void model_project_ClearTrackMeters (ModelProject* self) {
4643 #line 1053 "project.vala"
4644         g_return_if_fail (MODEL_IS_PROJECT (self));
4645 #line 4627 "project.c"
4646         {
4647                 GeeIterator* _track_it;
4648                 _track_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (self->tracks));
4649 #line 1054 "project.vala"
4650                 while (TRUE) {
4651 #line 4633 "project.c"
4652                         ModelTrack* track;
4653                         ModelTrack* _tmp0_;
4654                         ModelAudioTrack* audio_track;
4655 #line 1054 "project.vala"
4656                         if (!gee_iterator_next (_track_it)) {
4657 #line 1054 "project.vala"
4658                                 break;
4659 #line 4641 "project.c"
4660                         }
4661 #line 1054 "project.vala"
4662                         track = (ModelTrack*) gee_iterator_get (_track_it);
4663 #line 1055 "project.vala"
4664                         audio_track = _g_object_ref0 ((_tmp0_ = track, MODEL_IS_AUDIO_TRACK (_tmp0_) ? ((ModelAudioTrack*) _tmp0_) : NULL));
4665 #line 1056 "project.vala"
4666                         if (audio_track != NULL) {
4667 #line 1057 "project.vala"
4668                                 g_signal_emit_by_name (audio_track, "level-changed", (double) (-100), (double) (-100));
4669 #line 4651 "project.c"
4670                         }
4671                         _g_object_unref0 (track);
4672                         _g_object_unref0 (audio_track);
4673                 }
4674                 _g_object_unref0 (_track_it);
4675         }
4676 }
4677
4678
4679 #line 1062 "project.vala"
4680 void model_project_create_clip_importer (ModelProject* self, ModelTrack* track, gboolean timeline_add, gint64 time_to_add, gboolean both_tracks, GtkWindow* progress_window_parent, gint number) {
4681 #line 1062 "project.vala"
4682         g_return_if_fail (MODEL_IS_PROJECT (self));
4683 #line 1062 "project.vala"
4684         g_return_if_fail ((track == NULL) || MODEL_IS_TRACK (track));
4685 #line 1062 "project.vala"
4686         g_return_if_fail ((progress_window_parent == NULL) || GTK_IS_WINDOW (progress_window_parent));
4687 #line 1064 "project.vala"
4688         if (timeline_add) {
4689 #line 4671 "project.c"
4690                 ModelLibraryImporter* _tmp0_;
4691 #line 1065 "project.vala"
4692                 g_assert (track != NULL);
4693 #line 1066 "project.vala"
4694                 self->importer = (_tmp0_ = MODEL_LIBRARY_IMPORTER (model_timeline_importer_new (track, self, time_to_add, both_tracks)), _g_object_unref0 (self->importer), _tmp0_);
4695 #line 4677 "project.c"
4696         } else {
4697                 ModelLibraryImporter* _tmp1_;
4698 #line 1068 "project.vala"
4699                 self->importer = (_tmp1_ = model_library_importer_new (self), _g_object_unref0 (self->importer), _tmp1_);
4700 #line 4682 "project.c"
4701         }
4702 #line 1070 "project.vala"
4703         if (progress_window_parent != NULL) {
4704 #line 4686 "project.c"
4705                 MultiFileProgress* _tmp2_;
4706 #line 1071 "project.vala"
4707                 _tmp2_ = g_object_ref_sink (multi_file_progress_new (progress_window_parent, number, "Import", MULTI_FILE_PROGRESS_INTERFACE (self->importer->importer)));
4708 #line 4690 "project.c"
4709                 _g_object_unref0 (_tmp2_);
4710         }
4711 }
4712
4713
4714 #line 1077 "project.vala"
4715 char* model_project_get_version (ModelProject* self) {
4716 #line 4698 "project.c"
4717         char* result = NULL;
4718 #line 1077 "project.vala"
4719         g_return_val_if_fail (MODEL_IS_PROJECT (self), NULL);
4720 #line 4702 "project.c"
4721         result = g_strdup (_VERSION);
4722 #line 1078 "project.vala"
4723         return result;
4724 #line 4706 "project.c"
4725 }
4726
4727
4728 #line 1081 "project.vala"
4729 static char* model_project_real_get_app_name (ModelProject* self) {
4730 #line 4712 "project.c"
4731         g_return_val_if_fail (MODEL_IS_PROJECT (self), NULL);
4732         g_critical ("Type `%s' does not implement abstract method `model_project_get_app_name'", g_type_name (G_TYPE_FROM_INSTANCE (self)));
4733         return NULL;
4734 }
4735
4736
4737 #line 1081 "project.vala"
4738 char* model_project_get_app_name (ModelProject* self) {
4739 #line 1081 "project.vala"
4740         return MODEL_PROJECT_GET_CLASS (self)->get_app_name (self);
4741 #line 4723 "project.c"
4742 }
4743
4744
4745 #line 1083 "project.vala"
4746 char* model_project_get_license (ModelProject* self) {
4747 #line 4729 "project.c"
4748         char* result = NULL;
4749         char* _tmp2_;
4750         char* _tmp1_;
4751         char* _tmp0_;
4752         char* _tmp3_;
4753 #line 1083 "project.vala"
4754         g_return_val_if_fail (MODEL_IS_PROJECT (self), NULL);
4755 #line 4737 "project.c"
4756         result = (_tmp3_ = g_strdup_printf (MODEL_PROJECT_license, _tmp0_ = model_project_get_app_name (self), _tmp1_ = model_project_get_app_name (self), _tmp2_ = model_project_get_app_name (self)), _g_free0 (_tmp2_), _g_free0 (_tmp1_), _g_free0 (_tmp0_), _tmp3_);
4757 #line 1084 "project.vala"
4758         return result;
4759 #line 4741 "project.c"
4760 }
4761
4762
4763 #line 1087 "project.vala"
4764 void model_project_set_time_signature (ModelProject* self, Fraction* time_signature) {
4765 #line 4747 "project.c"
4766         ModelTimeSignatureCommand* command;
4767 #line 1087 "project.vala"
4768         g_return_if_fail (MODEL_IS_PROJECT (self));
4769 #line 1088 "project.vala"
4770         command = model_time_signature_command_new (self, time_signature);
4771 #line 1089 "project.vala"
4772         model_undo_manager_do_command (self->undo_manager, MODEL_COMMAND (command));
4773 #line 4755 "project.c"
4774         _model_command_unref0 (command);
4775 }
4776
4777
4778 #line 1092 "project.vala"
4779 void _model_project_set_time_signature (ModelProject* self, Fraction* time_signature) {
4780 #line 1092 "project.vala"
4781         g_return_if_fail (MODEL_IS_PROJECT (self));
4782 #line 1093 "project.vala"
4783         self->priv->time_signature = *time_signature;
4784 #line 1094 "project.vala"
4785         g_signal_emit_by_name (MODEL_TEMPO_INFORMATION (self), "time-signature-changed", time_signature);
4786 #line 4768 "project.c"
4787 }
4788
4789
4790 #line 1097 "project.vala"
4791 static void model_project_real_get_time_signature (ModelTempoInformation* base, Fraction* result) {
4792 #line 4774 "project.c"
4793         ModelProject * self;
4794         self = MODEL_PROJECT (base);
4795         *result = self->priv->time_signature;
4796 #line 1098 "project.vala"
4797         return;
4798 #line 4780 "project.c"
4799 }
4800
4801
4802 #line 1101 "project.vala"
4803 void model_project_set_bpm (ModelProject* self, gint bpm) {
4804 #line 4786 "project.c"
4805         ModelBpmCommand* command;
4806 #line 1101 "project.vala"
4807         g_return_if_fail (MODEL_IS_PROJECT (self));
4808 #line 1102 "project.vala"
4809         command = model_bpm_command_new (self, bpm);
4810 #line 1103 "project.vala"
4811         model_undo_manager_do_command (self->undo_manager, MODEL_COMMAND (command));
4812 #line 4794 "project.c"
4813         _model_command_unref0 (command);
4814 }
4815
4816
4817 #line 1106 "project.vala"
4818 void _model_project_set_bpm (ModelProject* self, gint bpm) {
4819 #line 1106 "project.vala"
4820         g_return_if_fail (MODEL_IS_PROJECT (self));
4821 #line 1107 "project.vala"
4822         self->priv->tempo = bpm;
4823 #line 1108 "project.vala"
4824         g_signal_emit_by_name (MODEL_TEMPO_INFORMATION (self), "bpm-changed", bpm);
4825 #line 4807 "project.c"
4826 }
4827
4828
4829 #line 1111 "project.vala"
4830 static gint model_project_real_get_bpm (ModelTempoInformation* base) {
4831 #line 4813 "project.c"
4832         ModelProject * self;
4833         gint result = 0;
4834         self = MODEL_PROJECT (base);
4835         result = self->priv->tempo;
4836 #line 1112 "project.vala"
4837         return result;
4838 #line 4820 "project.c"
4839 }
4840
4841
4842 #line 1115 "project.vala"
4843 char* model_project_get_audio_path (ModelProject* self) {
4844 #line 4826 "project.c"
4845         char* result = NULL;
4846         char* path;
4847         char* _tmp0_;
4848 #line 1115 "project.vala"
4849         g_return_val_if_fail (MODEL_IS_PROJECT (self), NULL);
4850 #line 1116 "project.vala"
4851         path = model_project_get_path (self);
4852 #line 4834 "project.c"
4853         _tmp0_ = NULL;
4854 #line 1117 "project.vala"
4855         if (path == NULL) {
4856 #line 4838 "project.c"
4857                 char* _tmp1_;
4858 #line 1117 "project.vala"
4859                 _tmp0_ = (_tmp1_ = NULL, _g_free0 (_tmp0_), _tmp1_);
4860 #line 4842 "project.c"
4861         } else {
4862                 char* _tmp2_;
4863 #line 1117 "project.vala"
4864                 _tmp0_ = (_tmp2_ = g_build_filename (path, "audio files", NULL), _g_free0 (_tmp0_), _tmp2_);
4865 #line 4847 "project.c"
4866         }
4867         result = _tmp0_;
4868         _g_free0 (path);
4869 #line 1117 "project.vala"
4870         return result;
4871 #line 4853 "project.c"
4872 }
4873
4874
4875 #line 1120 "project.vala"
4876 static char* model_project_get_path (ModelProject* self) {
4877 #line 4859 "project.c"
4878         char* result = NULL;
4879         char* _tmp0_;
4880 #line 1120 "project.vala"
4881         g_return_val_if_fail (MODEL_IS_PROJECT (self), NULL);
4882 #line 4864 "project.c"
4883         _tmp0_ = NULL;
4884 #line 1121 "project.vala"
4885         if (self->project_file == NULL) {
4886 #line 4868 "project.c"
4887                 char* _tmp1_;
4888 #line 1121 "project.vala"
4889                 _tmp0_ = (_tmp1_ = NULL, _g_free0 (_tmp0_), _tmp1_);
4890 #line 4872 "project.c"
4891         } else {
4892                 char* _tmp2_;
4893 #line 1121 "project.vala"
4894                 _tmp0_ = (_tmp2_ = g_path_get_dirname (self->project_file), _g_free0 (_tmp0_), _tmp2_);
4895 #line 4877 "project.c"
4896         }
4897         result = _tmp0_;
4898 #line 1121 "project.vala"
4899         return result;
4900 #line 4882 "project.c"
4901 }
4902
4903
4904 #line 1124 "project.vala"
4905 ModelVideoTrack* model_project_find_video_track (ModelProject* self) {
4906 #line 4888 "project.c"
4907         ModelVideoTrack* result = NULL;
4908 #line 1124 "project.vala"
4909         g_return_val_if_fail (MODEL_IS_PROJECT (self), NULL);
4910 #line 4892 "project.c"
4911         {
4912                 GeeIterator* _track_it;
4913                 _track_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (self->tracks));
4914 #line 1125 "project.vala"
4915                 while (TRUE) {
4916 #line 4898 "project.c"
4917                         ModelTrack* track;
4918 #line 1125 "project.vala"
4919                         if (!gee_iterator_next (_track_it)) {
4920 #line 1125 "project.vala"
4921                                 break;
4922 #line 4904 "project.c"
4923                         }
4924 #line 1125 "project.vala"
4925                         track = (ModelTrack*) gee_iterator_get (_track_it);
4926 #line 1126 "project.vala"
4927                         if (MODEL_IS_VIDEO_TRACK (track)) {
4928 #line 4910 "project.c"
4929                                 ModelTrack* _tmp0_;
4930                                 result = _g_object_ref0 ((_tmp0_ = track, MODEL_IS_VIDEO_TRACK (_tmp0_) ? ((ModelVideoTrack*) _tmp0_) : NULL));
4931                                 _g_object_unref0 (track);
4932                                 _g_object_unref0 (_track_it);
4933 #line 1127 "project.vala"
4934                                 return result;
4935 #line 4917 "project.c"
4936                         }
4937                         _g_object_unref0 (track);
4938                 }
4939                 _g_object_unref0 (_track_it);
4940         }
4941         result = NULL;
4942 #line 1130 "project.vala"
4943         return result;
4944 #line 4926 "project.c"
4945 }
4946
4947
4948 #line 1133 "project.vala"
4949 ModelAudioTrack* model_project_find_audio_track (ModelProject* self) {
4950 #line 4932 "project.c"
4951         ModelAudioTrack* result = NULL;
4952 #line 1133 "project.vala"
4953         g_return_val_if_fail (MODEL_IS_PROJECT (self), NULL);
4954 #line 4936 "project.c"
4955         {
4956                 GeeIterator* _track_it;
4957                 _track_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (self->tracks));
4958 #line 1134 "project.vala"
4959                 while (TRUE) {
4960 #line 4942 "project.c"
4961                         ModelTrack* track;
4962 #line 1134 "project.vala"
4963                         if (!gee_iterator_next (_track_it)) {
4964 #line 1134 "project.vala"
4965                                 break;
4966 #line 4948 "project.c"
4967                         }
4968 #line 1134 "project.vala"
4969                         track = (ModelTrack*) gee_iterator_get (_track_it);
4970 #line 1135 "project.vala"
4971                         if (MODEL_IS_AUDIO_TRACK (track)) {
4972 #line 4954 "project.c"
4973                                 ModelTrack* _tmp0_;
4974                                 result = _g_object_ref0 ((_tmp0_ = track, MODEL_IS_AUDIO_TRACK (_tmp0_) ? ((ModelAudioTrack*) _tmp0_) : NULL));
4975                                 _g_object_unref0 (track);
4976                                 _g_object_unref0 (_track_it);
4977 #line 1136 "project.vala"
4978                                 return result;
4979 #line 4961 "project.c"
4980                         }
4981                         _g_object_unref0 (track);
4982                 }
4983                 _g_object_unref0 (_track_it);
4984         }
4985         result = NULL;
4986 #line 1139 "project.vala"
4987         return result;
4988 #line 4970 "project.c"
4989 }
4990
4991
4992 #line 370 "project.vala"
4993 static void model_project_real_load_complete (ModelProject* self) {
4994 #line 370 "project.vala"
4995         g_return_if_fail (MODEL_IS_PROJECT (self));
4996 #line 4978 "project.c"
4997 }
4998
4999
5000 static void model_project_class_init (ModelProjectClass * klass) {
5001         Fraction _tmp1_ = {0};
5002         model_project_parent_class = g_type_class_peek_parent (klass);
5003         g_type_class_add_private (klass, sizeof (ModelProjectPrivate));
5004         MODEL_PROJECT_CLASS (klass)->get_clip_time = model_project_real_get_clip_time;
5005         MODEL_PROJECT_CLASS (klass)->get_project_file = model_project_real_get_project_file;
5006         MODEL_PROJECT_CLASS (klass)->do_append = model_project_real_do_append;
5007         MODEL_PROJECT_CLASS (klass)->add_track = model_project_real_add_track;
5008         MODEL_PROJECT_CLASS (klass)->insert_track = model_project_real_insert_track;
5009         MODEL_PROJECT_CLASS (klass)->load = model_project_real_load;
5010         MODEL_PROJECT_CLASS (klass)->save = model_project_real_save;
5011         MODEL_PROJECT_CLASS (klass)->get_app_name = model_project_real_get_app_name;
5012         MODEL_PROJECT_CLASS (klass)->load_complete = model_project_real_load_complete;
5013         G_OBJECT_CLASS (klass)->finalize = model_project_finalize;
5014         g_signal_new ("playstate_changed", MODEL_TYPE_PROJECT, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__ENUM, G_TYPE_NONE, 1, TYPE_PLAY_STATE);
5015         g_signal_new ("name_changed", MODEL_TYPE_PROJECT, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__STRING, G_TYPE_NONE, 1, G_TYPE_STRING);
5016         g_signal_new ("load_error", MODEL_TYPE_PROJECT, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__STRING, G_TYPE_NONE, 1, G_TYPE_STRING);
5017         g_signal_new ("load_complete", MODEL_TYPE_PROJECT, G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (ModelProjectClass, load_complete), NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
5018         g_signal_new ("closed", MODEL_TYPE_PROJECT, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
5019         g_signal_new ("track_added", MODEL_TYPE_PROJECT, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__OBJECT, G_TYPE_NONE, 1, MODEL_TYPE_TRACK);
5020         g_signal_new ("track_removed", MODEL_TYPE_PROJECT, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__OBJECT, G_TYPE_NONE, 1, MODEL_TYPE_TRACK);
5021         g_signal_new ("error_occurred", MODEL_TYPE_PROJECT, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_user_marshal_VOID__STRING_STRING, G_TYPE_NONE, 2, G_TYPE_STRING, G_TYPE_STRING);
5022         g_signal_new ("clipfile_added", MODEL_TYPE_PROJECT, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__OBJECT, G_TYPE_NONE, 1, MODEL_TYPE_CLIP_FILE);
5023         g_signal_new ("clipfile_removed", MODEL_TYPE_PROJECT, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__OBJECT, G_TYPE_NONE, 1, MODEL_TYPE_CLIP_FILE);
5024         g_signal_new ("cleared", MODEL_TYPE_PROJECT, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
5025         model_project_INVALID_FRAME_RATE = (fraction_init (&_tmp1_, -1, 1), _tmp1_);
5026 }
5027
5028
5029 static void model_project_model_tempo_information_interface_init (ModelTempoInformationIface * iface) {
5030         model_project_model_tempo_information_parent_iface = g_type_interface_peek_parent (iface);
5031         iface->get_time_signature = model_project_real_get_time_signature;
5032         iface->get_bpm = model_project_real_get_bpm;
5033 }
5034
5035
5036 static void model_project_instance_init (ModelProject * self) {
5037         Fraction _tmp0_ = {0};
5038         self->priv = MODEL_PROJECT_GET_PRIVATE (self);
5039         self->tracks = gee_array_list_new (MODEL_TYPE_TRACK, (GBoxedCopyFunc) g_object_ref, g_object_unref, NULL);
5040         self->inactive_tracks = gee_array_list_new (MODEL_TYPE_TRACK, (GBoxedCopyFunc) g_object_ref, g_object_unref, NULL);
5041         self->priv->pending = gee_hash_set_new (MODEL_TYPE_CLIP_FETCHER, (GBoxedCopyFunc) g_object_ref, g_object_unref, NULL, NULL);
5042         self->priv->pending_thumbs = gee_array_list_new (MODEL_TYPE_THUMBNAIL_FETCHER, (GBoxedCopyFunc) g_object_ref, g_object_unref, NULL);
5043         self->clipfiles = gee_array_list_new (MODEL_TYPE_CLIP_FILE, (GBoxedCopyFunc) g_object_ref, g_object_unref, NULL);
5044         self->priv->tempo = 120;
5045         self->priv->time_signature = (fraction_init (&_tmp0_, 4, 4), _tmp0_);
5046         self->click_during_play = FALSE;
5047         self->click_during_record = TRUE;
5048         self->click_volume = 0.8;
5049         self->library_visible = TRUE;
5050         self->library_width = 600;
5051 }
5052
5053
5054 static void model_project_finalize (GObject* obj) {
5055         ModelProject * self;
5056         self = MODEL_PROJECT (obj);
5057         _g_object_unref0 (self->tracks);
5058         _g_object_unref0 (self->inactive_tracks);
5059         _g_object_unref0 (self->priv->pending);
5060         _g_object_unref0 (self->priv->pending_thumbs);
5061         _g_object_unref0 (self->clipfiles);
5062         _g_object_unref0 (self->media_engine);
5063         _g_free0 (self->project_file);
5064         _g_object_unref0 (self->loader);
5065         _model_fetcher_completion_unref0 (self->priv->fetcher_completion);
5066         _model_undo_manager_unref0 (self->undo_manager);
5067         _g_object_unref0 (self->importer);
5068         G_OBJECT_CLASS (model_project_parent_class)->finalize (obj);
5069 }
5070
5071
5072 GType model_project_get_type (void) {
5073         static volatile gsize model_project_type_id__volatile = 0;
5074         if (g_once_init_enter (&model_project_type_id__volatile)) {
5075                 static const GTypeInfo g_define_type_info = { sizeof (ModelProjectClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) model_project_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ModelProject), 0, (GInstanceInitFunc) model_project_instance_init, NULL };
5076                 static const GInterfaceInfo model_tempo_information_info = { (GInterfaceInitFunc) model_project_model_tempo_information_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
5077                 GType model_project_type_id;
5078                 model_project_type_id = g_type_register_static (G_TYPE_OBJECT, "ModelProject", &g_define_type_info, G_TYPE_FLAG_ABSTRACT);
5079                 g_type_add_interface_static (model_project_type_id, MODEL_TYPE_TEMPO_INFORMATION, &model_tempo_information_info);
5080                 g_once_init_leave (&model_project_type_id__volatile, model_project_type_id);
5081         }
5082         return model_project_type_id__volatile;
5083 }
5084
5085
5086 static void _vala_array_destroy (gpointer array, gint array_length, GDestroyNotify destroy_func) {
5087         if ((array != NULL) && (destroy_func != NULL)) {
5088                 int i;
5089                 for (i = 0; i < array_length; i = i + 1) {
5090                         if (((gpointer*) array)[i] != NULL) {
5091                                 destroy_func (((gpointer*) array)[i]);
5092                         }
5093                 }
5094         }
5095 }
5096
5097
5098 static void _vala_array_free (gpointer array, gint array_length, GDestroyNotify destroy_func) {
5099         _vala_array_destroy (array, array_length, destroy_func);
5100         g_free (array);
5101 }
5102
5103
5104 static gint _vala_array_length (gpointer array) {
5105         int length;
5106         length = 0;
5107         if (array) {
5108                 while (((gpointer*) array)[length]) {
5109                         length++;
5110                 }
5111         }
5112         return length;
5113 }
5114
5115
5116 static int _vala_strcmp0 (const char * str1, const char * str2) {
5117         if (str1 == NULL) {
5118                 return -(str1 != str2);
5119         }
5120         if (str2 == NULL) {
5121                 return str1 != str2;
5122         }
5123         return strcmp (str1, str2);
5124 }
5125
5126
5127
5128 static void g_cclosure_user_marshal_VOID__STRING_STRING (GClosure * closure, GValue * return_value, guint n_param_values, const GValue * param_values, gpointer invocation_hint, gpointer marshal_data) {
5129         typedef void (*GMarshalFunc_VOID__STRING_STRING) (gpointer data1, const char* arg_1, const char* arg_2, gpointer data2);
5130         register GMarshalFunc_VOID__STRING_STRING callback;
5131         register GCClosure * cc;
5132         register gpointer data1, data2;
5133         cc = (GCClosure *) closure;
5134         g_return_if_fail (n_param_values == 3);
5135         if (G_CCLOSURE_SWAP_DATA (closure)) {
5136                 data1 = closure->data;
5137                 data2 = param_values->data[0].v_pointer;
5138         } else {
5139                 data1 = param_values->data[0].v_pointer;
5140                 data2 = closure->data;
5141         }
5142         callback = (GMarshalFunc_VOID__STRING_STRING) (marshal_data ? marshal_data : cc->callback);
5143         callback (data1, g_value_get_string (param_values + 1), g_value_get_string (param_values + 2), data2);
5144 }
5145
5146
5147