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

   1 /* track.c generated by valac, the Vala compiler
   2  * generated from track.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 <stdio.h>
  15 #include <gee.h>
  16 #include <gdk/gdk.h>
  17 #include <float.h>
  18 #include <math.h>
  19
  20
  21 #define MODEL_TYPE_TRACK (model_track_get_type ())
  22 #define MODEL_TRACK(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_TRACK, ModelTrack))
  23 #define MODEL_TRACK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_TRACK, ModelTrackClass))
  24 #define MODEL_IS_TRACK(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_TRACK))
  25 #define MODEL_IS_TRACK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_TRACK))
  26 #define MODEL_TRACK_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_TRACK, ModelTrackClass))
  27
  28 typedef struct _ModelTrack ModelTrack;
  29 typedef struct _ModelTrackClass ModelTrackClass;
  30 typedef struct _ModelTrackPrivate ModelTrackPrivate;
  31
  32 #define MODEL_TYPE_MEDIA_TYPE (model_media_type_get_type ())
  33
  34 #define MODEL_TYPE_CLIP (model_clip_get_type ())
  35 #define MODEL_CLIP(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_CLIP, ModelClip))
  36 #define MODEL_CLIP_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_CLIP, ModelClipClass))
  37 #define MODEL_IS_CLIP(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_CLIP))
  38 #define MODEL_IS_CLIP_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_CLIP))
  39 #define MODEL_CLIP_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_CLIP, ModelClipClass))
  40
  41 typedef struct _ModelClip ModelClip;
  42 typedef struct _ModelClipClass ModelClipClass;
  43
  44 #define MODEL_TYPE_PROJECT (model_project_get_type ())
  45 #define MODEL_PROJECT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_PROJECT, ModelProject))
  46 #define MODEL_PROJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_PROJECT, ModelProjectClass))
  47 #define MODEL_IS_PROJECT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_PROJECT))
  48 #define MODEL_IS_PROJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_PROJECT))
  49 #define MODEL_PROJECT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_PROJECT, ModelProjectClass))
  50
  51 typedef struct _ModelProject ModelProject;
  52 typedef struct _ModelProjectClass ModelProjectClass;
  53 #define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
  54 #define _g_free0(var) (var = (g_free (var), NULL))
  55 typedef struct _ModelClipPrivate ModelClipPrivate;
  56
  57 #define MODEL_TYPE_CLIP_FILE (model_clip_file_get_type ())
  58 #define MODEL_CLIP_FILE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_CLIP_FILE, ModelClipFile))
  59 #define MODEL_CLIP_FILE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_CLIP_FILE, ModelClipFileClass))
  60 #define MODEL_IS_CLIP_FILE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_CLIP_FILE))
  61 #define MODEL_IS_CLIP_FILE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_CLIP_FILE))
  62 #define MODEL_CLIP_FILE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_CLIP_FILE, ModelClipFileClass))
  63
  64 typedef struct _ModelClipFile ModelClipFile;
  65 typedef struct _ModelClipFileClass ModelClipFileClass;
  66
  67 #define MODEL_TYPE_GAP (model_gap_get_type ())
  68 #define MODEL_GAP(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_GAP, ModelGap))
  69 #define MODEL_GAP_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_GAP, ModelGapClass))
  70 #define MODEL_IS_GAP(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_GAP))
  71 #define MODEL_IS_GAP_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_GAP))
  72 #define MODEL_GAP_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_GAP, ModelGapClass))
  73
  74 typedef struct _ModelGap ModelGap;
  75 typedef struct _ModelGapClass ModelGapClass;
  76 #define _model_gap_unref0(var) ((var == NULL) ? NULL : (var = (model_gap_unref (var), NULL)))
  77 typedef struct _ModelGapPrivate ModelGapPrivate;
  78
  79 #define MODEL_TYPE_TEMPO_INFORMATION (model_tempo_information_get_type ())
  80 #define MODEL_TEMPO_INFORMATION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_TEMPO_INFORMATION, ModelTempoInformation))
  81 #define MODEL_IS_TEMPO_INFORMATION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_TEMPO_INFORMATION))
  82 #define MODEL_TEMPO_INFORMATION_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), MODEL_TYPE_TEMPO_INFORMATION, ModelTempoInformationIface))
  83
  84 typedef struct _ModelTempoInformation ModelTempoInformation;
  85 typedef struct _ModelTempoInformationIface ModelTempoInformationIface;
  86
  87 #define TYPE_FRACTION (fraction_get_type ())
  88 typedef struct _Fraction Fraction;
  89 typedef struct _ModelProjectPrivate ModelProjectPrivate;
  90
  91 #define TYPE_TIME_CODE (time_code_get_type ())
  92 typedef struct _TimeCode TimeCode;
  93
  94 #define VIEW_TYPE_MEDIA_ENGINE (view_media_engine_get_type ())
  95 #define VIEW_MEDIA_ENGINE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VIEW_TYPE_MEDIA_ENGINE, ViewMediaEngine))
  96 #define VIEW_MEDIA_ENGINE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VIEW_TYPE_MEDIA_ENGINE, ViewMediaEngineClass))
  97 #define VIEW_IS_MEDIA_ENGINE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VIEW_TYPE_MEDIA_ENGINE))
  98 #define VIEW_IS_MEDIA_ENGINE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VIEW_TYPE_MEDIA_ENGINE))
  99 #define VIEW_MEDIA_ENGINE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VIEW_TYPE_MEDIA_ENGINE, ViewMediaEngineClass))
 100
 101 typedef struct _ViewMediaEngine ViewMediaEngine;
 102 typedef struct _ViewMediaEngineClass ViewMediaEngineClass;
 103
 104 #define MODEL_TYPE_PROJECT_LOADER (model_project_loader_get_type ())
 105 #define MODEL_PROJECT_LOADER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_PROJECT_LOADER, ModelProjectLoader))
 106 #define MODEL_PROJECT_LOADER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_PROJECT_LOADER, ModelProjectLoaderClass))
 107 #define MODEL_IS_PROJECT_LOADER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_PROJECT_LOADER))
 108 #define MODEL_IS_PROJECT_LOADER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_PROJECT_LOADER))
 109 #define MODEL_PROJECT_LOADER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_PROJECT_LOADER, ModelProjectLoaderClass))
 110
 111 typedef struct _ModelProjectLoader ModelProjectLoader;
 112 typedef struct _ModelProjectLoaderClass ModelProjectLoaderClass;
 113
 114 #define MODEL_TYPE_UNDO_MANAGER (model_undo_manager_get_type ())
 115 #define MODEL_UNDO_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_UNDO_MANAGER, ModelUndoManager))
 116 #define MODEL_UNDO_MANAGER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_UNDO_MANAGER, ModelUndoManagerClass))
 117 #define MODEL_IS_UNDO_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_UNDO_MANAGER))
 118 #define MODEL_IS_UNDO_MANAGER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_UNDO_MANAGER))
 119 #define MODEL_UNDO_MANAGER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_UNDO_MANAGER, ModelUndoManagerClass))
 120
 121 typedef struct _ModelUndoManager ModelUndoManager;
 122 typedef struct _ModelUndoManagerClass ModelUndoManagerClass;
 123
 124 #define MODEL_TYPE_LIBRARY_IMPORTER (model_library_importer_get_type ())
 125 #define MODEL_LIBRARY_IMPORTER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_LIBRARY_IMPORTER, ModelLibraryImporter))
 126 #define MODEL_LIBRARY_IMPORTER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_LIBRARY_IMPORTER, ModelLibraryImporterClass))
 127 #define MODEL_IS_LIBRARY_IMPORTER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_LIBRARY_IMPORTER))
 128 #define MODEL_IS_LIBRARY_IMPORTER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_LIBRARY_IMPORTER))
 129 #define MODEL_LIBRARY_IMPORTER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_LIBRARY_IMPORTER, ModelLibraryImporterClass))
 130
 131 typedef struct _ModelLibraryImporter ModelLibraryImporter;
 132 typedef struct _ModelLibraryImporterClass ModelLibraryImporterClass;
 133
 134 #define MODEL_TYPE_COMMAND (model_command_get_type ())
 135 #define MODEL_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_COMMAND, ModelCommand))
 136 #define MODEL_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_COMMAND, ModelCommandClass))
 137 #define MODEL_IS_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_COMMAND))
 138 #define MODEL_IS_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_COMMAND))
 139 #define MODEL_COMMAND_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_COMMAND, ModelCommandClass))
 140
 141 typedef struct _ModelCommand ModelCommand;
 142 typedef struct _ModelCommandClass ModelCommandClass;
 143
 144 #define MODEL_TYPE_CLIP_ADD_COMMAND (model_clip_add_command_get_type ())
 145 #define MODEL_CLIP_ADD_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_CLIP_ADD_COMMAND, ModelClipAddCommand))
 146 #define MODEL_CLIP_ADD_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_CLIP_ADD_COMMAND, ModelClipAddCommandClass))
 147 #define MODEL_IS_CLIP_ADD_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_CLIP_ADD_COMMAND))
 148 #define MODEL_IS_CLIP_ADD_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_CLIP_ADD_COMMAND))
 149 #define MODEL_CLIP_ADD_COMMAND_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_CLIP_ADD_COMMAND, ModelClipAddCommandClass))
 150
 151 typedef struct _ModelClipAddCommand ModelClipAddCommand;
 152 typedef struct _ModelClipAddCommandClass ModelClipAddCommandClass;
 153 #define _model_command_unref0(var) ((var == NULL) ? NULL : (var = (model_command_unref (var), NULL)))
 154
 155 #define LOGGING_TYPE_FACILITY (logging_facility_get_type ())
 156
 157 #define LOGGING_TYPE_LEVEL (logging_level_get_type ())
 158
 159 #define MODEL_CLIP_COMMAND_TYPE_ACTION (model_clip_command_action_get_type ())
 160
 161 #define MODEL_TYPE_CLIP_COMMAND (model_clip_command_get_type ())
 162 #define MODEL_CLIP_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_CLIP_COMMAND, ModelClipCommand))
 163 #define MODEL_CLIP_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_CLIP_COMMAND, ModelClipCommandClass))
 164 #define MODEL_IS_CLIP_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_CLIP_COMMAND))
 165 #define MODEL_IS_CLIP_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_CLIP_COMMAND))
 166 #define MODEL_CLIP_COMMAND_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_CLIP_COMMAND, ModelClipCommandClass))
 167
 168 typedef struct _ModelClipCommand ModelClipCommand;
 169 typedef struct _ModelClipCommandClass ModelClipCommandClass;
 170
 171 #define MODEL_TYPE_CLIP_REVERT_COMMAND (model_clip_revert_command_get_type ())
 172 #define MODEL_CLIP_REVERT_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_CLIP_REVERT_COMMAND, ModelClipRevertCommand))
 173 #define MODEL_CLIP_REVERT_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_CLIP_REVERT_COMMAND, ModelClipRevertCommandClass))
 174 #define MODEL_IS_CLIP_REVERT_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_CLIP_REVERT_COMMAND))
 175 #define MODEL_IS_CLIP_REVERT_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_CLIP_REVERT_COMMAND))
 176 #define MODEL_CLIP_REVERT_COMMAND_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_CLIP_REVERT_COMMAND, ModelClipRevertCommandClass))
 177
 178 typedef struct _ModelClipRevertCommand ModelClipRevertCommand;
 179 typedef struct _ModelClipRevertCommandClass ModelClipRevertCommandClass;
 180
 181 #define MODEL_CLIP_SPLIT_COMMAND_TYPE_ACTION (model_clip_split_command_action_get_type ())
 182
 183 #define MODEL_TYPE_CLIP_SPLIT_COMMAND (model_clip_split_command_get_type ())
 184 #define MODEL_CLIP_SPLIT_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_CLIP_SPLIT_COMMAND, ModelClipSplitCommand))
 185 #define MODEL_CLIP_SPLIT_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_CLIP_SPLIT_COMMAND, ModelClipSplitCommandClass))
 186 #define MODEL_IS_CLIP_SPLIT_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_CLIP_SPLIT_COMMAND))
 187 #define MODEL_IS_CLIP_SPLIT_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_CLIP_SPLIT_COMMAND))
 188 #define MODEL_CLIP_SPLIT_COMMAND_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_CLIP_SPLIT_COMMAND, ModelClipSplitCommandClass))
 189
 190 typedef struct _ModelClipSplitCommand ModelClipSplitCommand;
 191 typedef struct _ModelClipSplitCommandClass ModelClipSplitCommandClass;
 192
 193 #define MODEL_TYPE_CLIP_TRIM_COMMAND (model_clip_trim_command_get_type ())
 194 #define MODEL_CLIP_TRIM_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_CLIP_TRIM_COMMAND, ModelClipTrimCommand))
 195 #define MODEL_CLIP_TRIM_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_CLIP_TRIM_COMMAND, ModelClipTrimCommandClass))
 196 #define MODEL_IS_CLIP_TRIM_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_CLIP_TRIM_COMMAND))
 197 #define MODEL_IS_CLIP_TRIM_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_CLIP_TRIM_COMMAND))
 198 #define MODEL_CLIP_TRIM_COMMAND_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_CLIP_TRIM_COMMAND, ModelClipTrimCommandClass))
 199
 200 typedef struct _ModelClipTrimCommand ModelClipTrimCommand;
 201 typedef struct _ModelClipTrimCommandClass ModelClipTrimCommandClass;
 202
 203 #define MODEL_TYPE_AUDIO_TRACK (model_audio_track_get_type ())
 204 #define MODEL_AUDIO_TRACK(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_AUDIO_TRACK, ModelAudioTrack))
 205 #define MODEL_AUDIO_TRACK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_AUDIO_TRACK, ModelAudioTrackClass))
 206 #define MODEL_IS_AUDIO_TRACK(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_AUDIO_TRACK))
 207 #define MODEL_IS_AUDIO_TRACK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_AUDIO_TRACK))
 208 #define MODEL_AUDIO_TRACK_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_AUDIO_TRACK, ModelAudioTrackClass))
 209
 210 typedef struct _ModelAudioTrack ModelAudioTrack;
 211 typedef struct _ModelAudioTrackClass ModelAudioTrackClass;
 212 typedef struct _ModelAudioTrackPrivate ModelAudioTrackPrivate;
 213
 214 #define MODEL_TYPE_PARAMETER (model_parameter_get_type ())
 215
 216 #define MODEL_TYPE_PARAMETER_COMMAND (model_parameter_command_get_type ())
 217 #define MODEL_PARAMETER_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_PARAMETER_COMMAND, ModelParameterCommand))
 218 #define MODEL_PARAMETER_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_PARAMETER_COMMAND, ModelParameterCommandClass))
 219 #define MODEL_IS_PARAMETER_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_PARAMETER_COMMAND))
 220 #define MODEL_IS_PARAMETER_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_PARAMETER_COMMAND))
 221 #define MODEL_PARAMETER_COMMAND_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_PARAMETER_COMMAND, ModelParameterCommandClass))
 222
 223 typedef struct _ModelParameterCommand ModelParameterCommand;
 224 typedef struct _ModelParameterCommandClass ModelParameterCommandClass;
 225
 226 typedef enum  {
 227         MODEL_MEDIA_TYPE_AUDIO,
 228         MODEL_MEDIA_TYPE_VIDEO
 229 } ModelMediaType;
 230
 231 struct _ModelTrack {
 232         GObject parent_instance;
 233         ModelTrackPrivate * priv;
 234         ModelProject* project;
 235         GeeArrayList* clips;
 236         char* display_name;
 237 };
 238
 239 struct _ModelTrackClass {
 240         GObjectClass parent_class;
 241         char* (*name) (ModelTrack* self);
 242         ModelMediaType (*media_type) (ModelTrack* self);
 243         gboolean (*check) (ModelTrack* self, ModelClip* clip);
 244         void (*on_clip_updated) (ModelTrack* self, ModelClip* clip);
 245         void (*write_attributes) (ModelTrack* self, FILE* f);
 246 };
 247
 248 struct _ModelTrackPrivate {
 249         gboolean is_selected;
 250 };
 251
 252 struct _ModelClip {
 253         GObject parent_instance;
 254         ModelClipPrivate * priv;
 255         ModelClipFile* clipfile;
 256         ModelMediaType type;
 257         gboolean is_recording;
 258         char* name;
 259 };
 260
 261 struct _ModelClipClass {
 262         GObjectClass parent_class;
 263 };
 264
 265 struct _ModelGap {
 266         GTypeInstance parent_instance;
 267         volatile int ref_count;
 268         ModelGapPrivate * priv;
 269         gint64 start;
 270         gint64 end;
 271 };
 272
 273 struct _ModelGapClass {
 274         GTypeClass parent_class;
 275         void (*finalize) (ModelGap *self);
 276 };
 277
 278 struct _Fraction {
 279         gint numerator;
 280         gint denominator;
 281 };
 282
 283 struct _ModelTempoInformationIface {
 284         GTypeInterface parent_iface;
 285         void (*get_time_signature) (ModelTempoInformation* self, Fraction* result);
 286         gint (*get_bpm) (ModelTempoInformation* self);
 287 };
 288
 289 struct _TimeCode {
 290         gint hour;
 291         gint minute;
 292         gint second;
 293         gint frame;
 294         gboolean drop_code;
 295 };
 296
 297 struct _ModelProject {
 298         GObject parent_instance;
 299         ModelProjectPrivate * priv;
 300         GeeArrayList* tracks;
 301         GeeArrayList* inactive_tracks;
 302         GeeArrayList* clipfiles;
 303         ViewMediaEngine* media_engine;
 304         char* project_file;
 305         ModelProjectLoader* loader;
 306         ModelUndoManager* undo_manager;
 307         ModelLibraryImporter* importer;
 308         Fraction default_framerate;
 309         gboolean click_during_play;
 310         gboolean click_during_record;
 311         double click_volume;
 312         gboolean library_visible;
 313         gint library_width;
 314         gboolean snap_to_clip;
 315 };
 316
 317 struct _ModelProjectClass {
 318         GObjectClass parent_class;
 319         void (*get_clip_time) (ModelProject* self, ModelClipFile* f, TimeCode* result);
 320         char* (*get_project_file) (ModelProject* self);
 321         void (*do_append) (ModelProject* self, ModelTrack* track, ModelClipFile* clipfile, const char* name, gint64 insert_time);
 322         void (*add_track) (ModelProject* self, ModelTrack* track);
 323         void (*insert_track) (ModelProject* self, gint index, ModelTrack* track);
 324         void (*load) (ModelProject* self, const char* fname);
 325         void (*save) (ModelProject* self, const char* filename);
 326         char* (*get_app_name) (ModelProject* self);
 327         void (*load_complete) (ModelProject* self);
 328 };
 329
 330 typedef enum  {
 331         LOGGING_FACILITY_SIGNAL_HANDLERS,
 332         LOGGING_FACILITY_DEVELOPER_WARNINGS,
 333         LOGGING_FACILITY_GRAPH,
 334         LOGGING_FACILITY_LOADING,
 335         LOGGING_FACILITY_IMPORT,
 336         LOGGING_FACILITY_SINGLEDECODEBIN
 337 } LoggingFacility;
 338
 339 typedef enum  {
 340         LOGGING_LEVEL_CRITICAL,
 341         LOGGING_LEVEL_HIGH,
 342         LOGGING_LEVEL_MEDIUM,
 343         LOGGING_LEVEL_LOW,
 344         LOGGING_LEVEL_INFO,
 345         LOGGING_LEVEL_VERBOSE
 346 } LoggingLevel;
 347
 348 typedef enum  {
 349         MODEL_CLIP_COMMAND_ACTION_APPEND,
 350         MODEL_CLIP_COMMAND_ACTION_DELETE
 351 } ModelClipCommandAction;
 352
 353 typedef enum  {
 354         MODEL_CLIP_SPLIT_COMMAND_ACTION_SPLIT,
 355         MODEL_CLIP_SPLIT_COMMAND_ACTION_JOIN
 356 } ModelClipSplitCommandAction;
 357
 358 struct _ModelAudioTrack {
 359         ModelTrack parent_instance;
 360         ModelAudioTrackPrivate * priv;
 361 };
 362
 363 struct _ModelAudioTrackClass {
 364         ModelTrackClass parent_class;
 365 };
 366
 367 struct _ModelAudioTrackPrivate {
 368         double pan;
 369         double volume;
 370         gint default_num_channels;
 371 };
 372
 373 typedef enum  {
 374         MODEL_PARAMETER_PAN,
 375         MODEL_PARAMETER_VOLUME
 376 } ModelParameter;
 377
 378
 379 static gpointer model_track_parent_class = NULL;
 380 static gpointer model_audio_track_parent_class = NULL;
 381
 382 GType model_track_get_type (void);
 383 GType model_media_type_get_type (void);
 384 GType model_clip_get_type (void);
 385 GType model_project_get_type (void);
 386 #define MODEL_TRACK_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), MODEL_TYPE_TRACK, ModelTrackPrivate))
 387 enum  {
 388         MODEL_TRACK_DUMMY_PROPERTY
 389 };
 390 ModelTrack* model_track_construct (GType object_type, ModelProject* project, const char* display_name);
 391 char* model_track_name (ModelTrack* self);
 392 static char* model_track_real_name (ModelTrack* self);
 393 ModelMediaType model_track_media_type (ModelTrack* self);
 394 static ModelMediaType model_track_real_media_type (ModelTrack* self);
 395 void model_track_hide (ModelTrack* self);
 396 GType model_clip_file_get_type (void);
 397 gboolean model_track_contains_clipfile (ModelTrack* self, ModelClipFile* f);
 398 gboolean model_track_check (ModelTrack* self, ModelClip* clip);
 399 static gboolean model_track_real_check (ModelTrack* self, ModelClip* clip);
 400 gint64 model_clip_get_start (ModelClip* self);
 401 gint64 model_clip_get_duration (ModelClip* self);
 402 gint64 model_track_get_time_from_pos (ModelTrack* self, ModelClip* clip, gboolean after);
 403 gint64 model_clip_get_end (ModelClip* self);
 404 static gint model_track_get_clip_from_time (ModelTrack* self, gint64 time);
 405 gint64 model_clip_snap (ModelClip* self, ModelClip* other, gint64 pad);
 406 gint64 model_track_snap_clip (ModelTrack* self, ModelClip* c, gint64 span);
 407 gboolean model_clip_snap_coord (ModelClip* self, gint64* s, gint64 span);
 408 gboolean model_track_snap_coord (ModelTrack* self, gint64* coord, gint64 span);
 409 gboolean model_track_clip_is_near (ModelTrack* self, ModelClip* clip, gint64 range, gint64* adjustment);
 410 static gint model_track_get_insert_index (ModelTrack* self, gint64 time);
 411 ModelGap* model_gap_new (gint64 start, gint64 end);
 412 ModelGap* model_gap_construct (GType object_type, gint64 start, gint64 end);
 413 gpointer model_gap_ref (gpointer instance);
 414 void model_gap_unref (gpointer instance);
 415 GParamSpec* model_param_spec_gap (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);
 416 void model_value_set_gap (GValue* value, gpointer v_object);
 417 void model_value_take_gap (GValue* value, gpointer v_object);
 418 gpointer model_value_get_gap (const GValue* value);
 419 GType model_gap_get_type (void);
 420 ModelGap* model_track_find_first_gap (ModelTrack* self, gint64 start);
 421 static gint model_track_get_gap_index (ModelTrack* self, gint64 time);
 422 void model_track_find_containing_gap (ModelTrack* self, gint64 time, ModelGap** g);
 423 gboolean model_clip_overlap_pos (ModelClip* self, gint64 start, gint64 length);
 424 ModelClip* model_track_find_overlapping_clip (ModelTrack* self, gint64 start, gint64 length);
 425 ModelClip* model_track_find_nearest_clip_edge (ModelTrack* self, gint64 time, gboolean* after);
 426 gint64 model_clip_get_media_start (ModelClip* self);
 427 ModelClip* model_clip_new (ModelClipFile* clipfile, ModelMediaType t, const char* name, gint64 start, gint64 media_start, gint64 duration, gboolean is_recording);
 428 ModelClip* model_clip_construct (GType object_type, ModelClipFile* clipfile, ModelMediaType t, const char* name, gint64 start, gint64 media_start, gint64 duration, gboolean is_recording);
 429 void model_track_append_at_time (ModelTrack* self, ModelClip* c, gint64 time, gboolean select);
 430 void model_track_trim (ModelTrack* self, ModelClip* clip, gint64 delta, GdkWindowEdge edge);
 431 GType fraction_get_type (void);
 432 Fraction* fraction_dup (const Fraction* self);
 433 void fraction_free (Fraction* self);
 434 GType model_tempo_information_get_type (void);
 435 GType time_code_get_type (void);
 436 TimeCode* time_code_dup (const TimeCode* self);
 437 void time_code_free (TimeCode* self);
 438 GType view_media_engine_get_type (void);
 439 GType model_project_loader_get_type (void);
 440 gpointer model_undo_manager_ref (gpointer instance);
 441 void model_undo_manager_unref (gpointer instance);
 442 GParamSpec* model_param_spec_undo_manager (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);
 443 void model_value_set_undo_manager (GValue* value, gpointer v_object);
 444 void model_value_take_undo_manager (GValue* value, gpointer v_object);
 445 gpointer model_value_get_undo_manager (const GValue* value);
 446 GType model_undo_manager_get_type (void);
 447 GType model_library_importer_get_type (void);
 448 gboolean model_undo_manager_get_in_undo (ModelUndoManager* self);
 449 void model_track_delete_clip (ModelTrack* self, ModelClip* clip);
 450 static void model_track_do_clip_overwrite (ModelTrack* self, ModelClip* c);
 451 ModelClipAddCommand* model_clip_add_command_new (ModelTrack* track, ModelClip* clip, gint64 original_time, gint64 new_start);
 452 ModelClipAddCommand* model_clip_add_command_construct (GType object_type, ModelTrack* track, ModelClip* clip, gint64 original_time, gint64 new_start);
 453 gpointer model_command_ref (gpointer instance);
 454 void model_command_unref (gpointer instance);
 455 GParamSpec* model_param_spec_command (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);
 456 void model_value_set_command (GValue* value, gpointer v_object);
 457 void model_value_take_command (GValue* value, gpointer v_object);
 458 gpointer model_value_get_command (const GValue* value);
 459 GType model_command_get_type (void);
 460 GType model_clip_add_command_get_type (void);
 461 void model_project_do_command (ModelProject* self, ModelCommand* the_command);
 462 void model_track_move (ModelTrack* self, ModelClip* c, gint64 pos, gint64 original_time);
 463 void model_clip_set_start (ModelClip* self, gint64 value);
 464 static void model_track_insert_clip_into_array (ModelTrack* self, ModelClip* c, gint pos);
 465 void model_project_reseek (ModelProject* self);
 466 void _model_track_move (ModelTrack* self, ModelClip* c, gint64 pos);
 467 void model_track_add (ModelTrack* self, ModelClip* c, gint64 pos, gboolean select);
 468 GType logging_facility_get_type (void);
 469 GType logging_level_get_type (void);
 470 void logging_emit (GObject* object, LoggingFacility facility, LoggingLevel level, const char* message);
 471 void model_track_on_clip_updated (ModelTrack* self, ModelClip* clip);
 472 static void model_track_real_on_clip_updated (ModelTrack* self, ModelClip* clip);
 473 void model_track_do_clip_paste (ModelTrack* self, ModelClip* clip, gint64 position);
 474 ModelClip* model_track_get_clip (ModelTrack* self, gint i);
 475 gint model_track_get_clip_index (ModelTrack* self, ModelClip* c);
 476 ModelClip* model_track_get_clip_by_position (ModelTrack* self, gint64 pos);
 477 gint64 model_track_get_length (ModelTrack* self);
 478 void _model_track_append_at_time (ModelTrack* self, ModelClip* c, gint64 time, gboolean select);
 479 GType model_clip_command_action_get_type (void);
 480 ModelClipCommand* model_clip_command_new (ModelClipCommandAction action, ModelTrack* track, ModelClip* clip, gint64 time, gboolean select);
 481 ModelClipCommand* model_clip_command_construct (GType object_type, ModelClipCommandAction action, ModelTrack* track, ModelClip* clip, gint64 time, gboolean select);
 482 GType model_clip_command_get_type (void);
 483 void _model_track_delete_clip (ModelTrack* self, ModelClip* clip);
 484 void model_track_delete_gap (ModelTrack* self, ModelGap* g);
 485 void model_track_remove_clip_from_array (ModelTrack* self, ModelClip* pos);
 486 static void _model_track_on_clip_updated_model_clip_updated (ModelClip* _sender, ModelClip* clip, gpointer self);
 487 void view_media_engine_go (ViewMediaEngine* self, gint64 pos);
 488 void model_track_delete_all_clips (ModelTrack* self);
 489 ModelClipRevertCommand* model_clip_revert_command_new (ModelTrack* track, ModelClip* clip);
 490 ModelClipRevertCommand* model_clip_revert_command_construct (GType object_type, ModelTrack* track, ModelClip* clip);
 491 GType model_clip_revert_command_get_type (void);
 492 void model_track_revert_to_original (ModelTrack* self, ModelClip* clip);
 493 void model_clip_set_media_start_duration (ModelClip* self, gint64 media_start, gint64 duration);
 494 gint64 model_clip_file_get_length (ModelClipFile* self);
 495 void _model_track_revert_to_original (ModelTrack* self, ModelClip* c);
 496 gboolean model_track_are_contiguous_clips (ModelTrack* self, gint64 position);
 497 GType model_clip_split_command_action_get_type (void);
 498 ModelClipSplitCommand* model_clip_split_command_new (ModelClipSplitCommandAction action, ModelTrack* track, gint64 time);
 499 ModelClipSplitCommand* model_clip_split_command_construct (GType object_type, ModelClipSplitCommandAction action, ModelTrack* track, gint64 time);
 500 GType model_clip_split_command_get_type (void);
 501 void model_track_split_at (ModelTrack* self, gint64 position);
 502 void model_clip_set_duration (ModelClip* self, gint64 value);
 503 void _model_track_split_at (ModelTrack* self, gint64 position);
 504 void model_track_join (ModelTrack* self, gint64 position);
 505 void _model_track_join (ModelTrack* self, gint64 position);
 506 ModelClipTrimCommand* model_clip_trim_command_new (ModelTrack* track, ModelClip* clip, gint64 delta, GdkWindowEdge edge);
 507 ModelClipTrimCommand* model_clip_trim_command_construct (GType object_type, ModelTrack* track, ModelClip* clip, gint64 delta, GdkWindowEdge edge);
 508 GType model_clip_trim_command_get_type (void);
 509 void model_clip_trim (ModelClip* self, gint64 delta, GdkWindowEdge edge);
 510 void _model_track_trim (ModelTrack* self, ModelClip* clip, gint64 delta, GdkWindowEdge edge);
 511 gint64 model_track_previous_edit (ModelTrack* self, gint64 pos);
 512 gint64 model_track_next_edit (ModelTrack* self, gint64 pos);
 513 char* model_track_get_display_name (ModelTrack* self);
 514 void model_track_write_attributes (ModelTrack* self, FILE* f);
 515 static void model_track_real_write_attributes (ModelTrack* self, FILE* f);
 516 void model_clip_save (ModelClip* self, FILE* f, gint id);
 517 gint model_project_get_clipfile_index (ModelProject* self, ModelClipFile* find);
 518 void model_track_save (ModelTrack* self, FILE* f);
 519 void model_track_set_display_name (ModelTrack* self, const char* new_display_name);
 520 void model_track_set_selected (ModelTrack* self, gboolean is_selected);
 521 gboolean model_track_get_is_selected (ModelTrack* self);
 522 static void model_track_finalize (GObject* obj);
 523 GType model_audio_track_get_type (void);
 524 #define MODEL_AUDIO_TRACK_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), MODEL_TYPE_AUDIO_TRACK, ModelAudioTrackPrivate))
 525 enum  {
 526         MODEL_AUDIO_TRACK_DUMMY_PROPERTY
 527 };
 528 #define MODEL_AUDIO_TRACK_INVALID_CHANNEL_COUNT (-1)
 529 void model_audio_track_set_default_num_channels (ModelAudioTrack* self, gint num);
 530 void _model_audio_track_set_pan (ModelAudioTrack* self, double new_value);
 531 void _model_audio_track_set_volume (ModelAudioTrack* self, double new_volume);
 532 ModelAudioTrack* model_audio_track_new (ModelProject* project, const char* display_name);
 533 ModelAudioTrack* model_audio_track_construct (GType object_type, ModelProject* project, const char* display_name);
 534 static char* model_audio_track_real_name (ModelTrack* base);
 535 static ModelMediaType model_audio_track_real_media_type (ModelTrack* base);
 536 double model_audio_track_get_volume (ModelAudioTrack* self);
 537 double model_audio_track_get_pan (ModelAudioTrack* self);
 538 gboolean model_audio_track_get_num_channels (ModelAudioTrack* self, gint* num);
 539 static void model_audio_track_real_write_attributes (ModelTrack* base, FILE* f);
 540 gboolean float_within (double f, double epsilon);
 541 GType model_parameter_get_type (void);
 542 ModelParameterCommand* model_parameter_command_new (ModelAudioTrack* target, ModelParameter parameter, double new_value, double old_value);
 543 ModelParameterCommand* model_parameter_command_construct (GType object_type, ModelAudioTrack* target, ModelParameter parameter, double new_value, double old_value);
 544 GType model_parameter_command_get_type (void);
 545 void model_audio_track_set_pan (ModelAudioTrack* self, double new_value);
 546 void model_audio_track_set_volume (ModelAudioTrack* self, double new_volume);
 547 gboolean model_clip_file_is_online (ModelClipFile* self);
 548 gboolean model_clip_file_get_num_channels (ModelClipFile* self, gint* channels);
 549 static gboolean model_audio_track_real_check (ModelTrack* base, ModelClip* clip);
 550 void model_audio_track_on_level_changed (ModelAudioTrack* self, double level_left, double level_right);
 551 static void model_audio_track_real_on_clip_updated (ModelTrack* base, ModelClip* clip);
 552 static void model_audio_track_finalize (GObject* obj);
 553 static int _vala_strcmp0 (const char * str1, const char * str2);
 554
 555
 556 static void g_cclosure_user_marshal_VOID__OBJECT_BOOLEAN (GClosure * closure, GValue * return_value, guint n_param_values, const GValue * param_values, gpointer invocation_hint, gpointer marshal_data);
 557 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);
 558 static void g_cclosure_user_marshal_VOID__ENUM_DOUBLE (GClosure * closure, GValue * return_value, guint n_param_values, const GValue * param_values, gpointer invocation_hint, gpointer marshal_data);
 559 static void g_cclosure_user_marshal_VOID__DOUBLE_DOUBLE (GClosure * closure, GValue * return_value, guint n_param_values, const GValue * param_values, gpointer invocation_hint, gpointer marshal_data);
 560
 561 #line 26 "track.vala"
 562 ModelTrack* model_track_construct (GType object_type, ModelProject* project, const char* display_name) {
 563 #line 564 "track.c"
 564         ModelTrack * self;
 565         char* _tmp0_;
 566 #line 26 "track.vala"
 567         g_return_val_if_fail (MODEL_IS_PROJECT (project), NULL);
 568 #line 26 "track.vala"
 569         g_return_val_if_fail (display_name != NULL, NULL);
 570 #line 26 "track.vala"
 571         self = (ModelTrack*) g_object_new (object_type, NULL);
 572 #line 27 "track.vala"
 573         self->project = project;
 574 #line 28 "track.vala"
 575         self->display_name = (_tmp0_ = g_strdup (display_name), _g_free0 (self->display_name), _tmp0_);
 576 #line 577 "track.c"
 577         return self;
 578 }
 579
 580
 581 #line 31 "track.vala"
 582 static char* model_track_real_name (ModelTrack* self) {
 583 #line 584 "track.c"
 584         g_return_val_if_fail (MODEL_IS_TRACK (self), NULL);
 585         g_critical ("Type `%s' does not implement abstract method `model_track_name'", g_type_name (G_TYPE_FROM_INSTANCE (self)));
 586         return NULL;
 587 }
 588
 589
 590 #line 31 "track.vala"
 591 char* model_track_name (ModelTrack* self) {
 592 #line 31 "track.vala"
 593         return MODEL_TRACK_GET_CLASS (self)->name (self);
 594 #line 595 "track.c"
 595 }
 596
 597
 598 #line 32 "track.vala"
 599 static ModelMediaType model_track_real_media_type (ModelTrack* self) {
 600 #line 601 "track.c"
 601         g_return_val_if_fail (MODEL_IS_TRACK (self), 0);
 602         g_critical ("Type `%s' does not implement abstract method `model_track_media_type'", g_type_name (G_TYPE_FROM_INSTANCE (self)));
 603         return 0;
 604 }
 605
 606
 607 #line 32 "track.vala"
 608 ModelMediaType model_track_media_type (ModelTrack* self) {
 609 #line 32 "track.vala"
 610         return MODEL_TRACK_GET_CLASS (self)->media_type (self);
 611 #line 612 "track.c"
 612 }
 613
 614
 615 #line 34 "track.vala"
 616 void model_track_hide (ModelTrack* self) {
 617 #line 34 "track.vala"
 618         g_return_if_fail (MODEL_IS_TRACK (self));
 619 #line 35 "track.vala"
 620         g_signal_emit_by_name (self, "track-hidden", self);
 621 #line 622 "track.c"
 622 }
 623
 624
 625 #line 38 "track.vala"
 626 gboolean model_track_contains_clipfile (ModelTrack* self, ModelClipFile* f) {
 627 #line 628 "track.c"
 628         gboolean result = FALSE;
 629 #line 38 "track.vala"
 630         g_return_val_if_fail (MODEL_IS_TRACK (self), FALSE);
 631 #line 38 "track.vala"
 632         g_return_val_if_fail (MODEL_IS_CLIP_FILE (f), FALSE);
 633 #line 634 "track.c"
 634         {
 635                 GeeIterator* _c_it;
 636                 _c_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (self->clips));
 637 #line 39 "track.vala"
 638                 while (TRUE) {
 639 #line 640 "track.c"
 640                         ModelClip* c;
 641 #line 39 "track.vala"
 642                         if (!gee_iterator_next (_c_it)) {
 643 #line 39 "track.vala"
 644                                 break;
 645 #line 646 "track.c"
 646                         }
 647 #line 39 "track.vala"
 648                         c = (ModelClip*) gee_iterator_get (_c_it);
 649 #line 40 "track.vala"
 650                         if (c->clipfile == f) {
 651 #line 652 "track.c"
 652                                 result = TRUE;
 653                                 _g_object_unref0 (c);
 654                                 _g_object_unref0 (_c_it);
 655 #line 41 "track.vala"
 656                                 return result;
 657 #line 658 "track.c"
 658                         }
 659                         _g_object_unref0 (c);
 660                 }
 661                 _g_object_unref0 (_c_it);
 662         }
 663         result = FALSE;
 664 #line 43 "track.vala"
 665         return result;
 666 #line 667 "track.c"
 667 }
 668
 669
 670 #line 46 "track.vala"
 671 static gboolean model_track_real_check (ModelTrack* self, ModelClip* clip) {
 672 #line 673 "track.c"
 673         g_return_val_if_fail (MODEL_IS_TRACK (self), FALSE);
 674         g_critical ("Type `%s' does not implement abstract method `model_track_check'", g_type_name (G_TYPE_FROM_INSTANCE (self)));
 675         return FALSE;
 676 }
 677
 678
 679 #line 46 "track.vala"
 680 gboolean model_track_check (ModelTrack* self, ModelClip* clip) {
 681 #line 46 "track.vala"
 682         return MODEL_TRACK_GET_CLASS (self)->check (self, clip);
 683 #line 684 "track.c"
 684 }
 685
 686
 687 #line 48 "track.vala"
 688 gint64 model_track_get_time_from_pos (ModelTrack* self, ModelClip* clip, gboolean after) {
 689 #line 690 "track.c"
 690         gint64 result = 0LL;
 691 #line 48 "track.vala"
 692         g_return_val_if_fail (MODEL_IS_TRACK (self), 0LL);
 693 #line 48 "track.vala"
 694         g_return_val_if_fail (MODEL_IS_CLIP (clip), 0LL);
 695 #line 49 "track.vala"
 696         if (after) {
 697 #line 698 "track.c"
 698                 result = model_clip_get_start (clip) + model_clip_get_duration (clip);
 699 #line 50 "track.vala"
 700                 return result;
 701 #line 702 "track.c"
 702         } else {
 703                 result = model_clip_get_start (clip);
 704 #line 52 "track.vala"
 705                 return result;
 706 #line 707 "track.c"
 707         }
 708 }
 709
 710
 711 #line 55 "track.vala"
 712 static gint model_track_get_clip_from_time (ModelTrack* self, gint64 time) {
 713 #line 714 "track.c"
 714         gint result = 0;
 715 #line 55 "track.vala"
 716         g_return_val_if_fail (MODEL_IS_TRACK (self), 0);
 717 #line 718 "track.c"
 718         {
 719                 gint i;
 720 #line 56 "track.vala"
 721                 i = 0;
 722 #line 723 "track.c"
 723                 {
 724                         gboolean _tmp0_;
 725 #line 56 "track.vala"
 726                         _tmp0_ = TRUE;
 727 #line 56 "track.vala"
 728                         while (TRUE) {
 729 #line 730 "track.c"
 730                                 gboolean _tmp1_ = FALSE;
 731                                 ModelClip* _tmp2_;
 732                                 gboolean _tmp3_;
 733 #line 56 "track.vala"
 734                                 if (!_tmp0_) {
 735 #line 56 "track.vala"
 736                                         i++;
 737 #line 738 "track.c"
 738                                 }
 739 #line 56 "track.vala"
 740                                 _tmp0_ = FALSE;
 741 #line 56 "track.vala"
 742                                 if (!(i < gee_collection_get_size (GEE_COLLECTION (self->clips)))) {
 743 #line 56 "track.vala"
 744                                         break;
 745 #line 746 "track.c"
 746                                 }
 747 #line 57 "track.vala"
 748                                 if ((_tmp3_ = time >= model_clip_get_start (_tmp2_ = (ModelClip*) gee_abstract_list_get (GEE_ABSTRACT_LIST (self->clips), i)), _g_object_unref0 (_tmp2_), _tmp3_)) {
 749 #line 750 "track.c"
 750                                         ModelClip* _tmp4_;
 751 #line 58 "track.vala"
 752                                         _tmp1_ = time < model_clip_get_end (_tmp4_ = (ModelClip*) gee_abstract_list_get (GEE_ABSTRACT_LIST (self->clips), i));
 753 #line 754 "track.c"
 754                                         _g_object_unref0 (_tmp4_);
 755                                 } else {
 756 #line 57 "track.vala"
 757                                         _tmp1_ = FALSE;
 758 #line 759 "track.c"
 759                                 }
 760 #line 57 "track.vala"
 761                                 if (_tmp1_) {
 762 #line 763 "track.c"
 763                                         result = i;
 764 #line 59 "track.vala"
 765                                         return result;
 766 #line 767 "track.c"
 767                                 }
 768                         }
 769                 }
 770         }
 771         result = -1;
 772 #line 61 "track.vala"
 773         return result;
 774 #line 775 "track.c"
 775 }
 776
 777
 778 #line 64 "track.vala"
 779 gint64 model_track_snap_clip (ModelTrack* self, ModelClip* c, gint64 span) {
 780 #line 781 "track.c"
 781         gint64 result = 0LL;
 782 #line 64 "track.vala"
 783         g_return_val_if_fail (MODEL_IS_TRACK (self), 0LL);
 784 #line 64 "track.vala"
 785         g_return_val_if_fail (MODEL_IS_CLIP (c), 0LL);
 786 #line 787 "track.c"
 787         {
 788                 GeeIterator* _cl_it;
 789                 _cl_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (self->clips));
 790 #line 65 "track.vala"
 791                 while (TRUE) {
 792 #line 793 "track.c"
 793                         ModelClip* cl;
 794                         gint64 new_start;
 795 #line 65 "track.vala"
 796                         if (!gee_iterator_next (_cl_it)) {
 797 #line 65 "track.vala"
 798                                 break;
 799 #line 800 "track.c"
 800                         }
 801 #line 65 "track.vala"
 802                         cl = (ModelClip*) gee_iterator_get (_cl_it);
 803 #line 66 "track.vala"
 804                         new_start = model_clip_snap (c, cl, span);
 805 #line 67 "track.vala"
 806                         if (new_start != model_clip_get_start (c)) {
 807 #line 808 "track.c"
 808                                 result = new_start;
 809                                 _g_object_unref0 (cl);
 810                                 _g_object_unref0 (_cl_it);
 811 #line 68 "track.vala"
 812                                 return result;
 813 #line 814 "track.c"
 814                         }
 815                         _g_object_unref0 (cl);
 816                 }
 817                 _g_object_unref0 (_cl_it);
 818         }
 819         result = model_clip_get_start (c);
 820 #line 71 "track.vala"
 821         return result;
 822 #line 823 "track.c"
 823 }
 824
 825
 826 #line 74 "track.vala"
 827 gboolean model_track_snap_coord (ModelTrack* self, gint64* coord, gint64 span) {
 828 #line 829 "track.c"
 829         gboolean result = FALSE;
 830 #line 74 "track.vala"
 831         g_return_val_if_fail (MODEL_IS_TRACK (self), FALSE);
 832 #line 833 "track.c"
 833         {
 834                 GeeIterator* _c_it;
 835                 _c_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (self->clips));
 836 #line 75 "track.vala"
 837                 while (TRUE) {
 838 #line 839 "track.c"
 839                         ModelClip* c;
 840 #line 75 "track.vala"
 841                         if (!gee_iterator_next (_c_it)) {
 842 #line 75 "track.vala"
 843                                 break;
 844 #line 845 "track.c"
 845                         }
 846 #line 75 "track.vala"
 847                         c = (ModelClip*) gee_iterator_get (_c_it);
 848 #line 76 "track.vala"
 849                         if (model_clip_snap_coord (c, coord, span)) {
 850 #line 851 "track.c"
 851                                 result = TRUE;
 852                                 _g_object_unref0 (c);
 853                                 _g_object_unref0 (_c_it);
 854 #line 77 "track.vala"
 855                                 return result;
 856 #line 857 "track.c"
 857                         }
 858                         _g_object_unref0 (c);
 859                 }
 860                 _g_object_unref0 (_c_it);
 861         }
 862         result = FALSE;
 863 #line 79 "track.vala"
 864         return result;
 865 #line 866 "track.c"
 866 }
 867
 868
 869 #line 82 "track.vala"
 870 gboolean model_track_clip_is_near (ModelTrack* self, ModelClip* clip, gint64 range, gint64* adjustment) {
 871 #line 872 "track.c"
 872         gboolean result = FALSE;
 873 #line 82 "track.vala"
 874         g_return_val_if_fail (MODEL_IS_TRACK (self), FALSE);
 875 #line 82 "track.vala"
 876         g_return_val_if_fail (MODEL_IS_CLIP (clip), FALSE);
 877 #line 878 "track.c"
 878         {
 879                 GeeIterator* _potential_clip_it;
 880                 _potential_clip_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (self->clips));
 881 #line 83 "track.vala"
 882                 while (TRUE) {
 883 #line 884 "track.c"
 884                         ModelClip* potential_clip;
 885 #line 83 "track.vala"
 886                         if (!gee_iterator_next (_potential_clip_it)) {
 887 #line 83 "track.vala"
 888                                 break;
 889 #line 890 "track.c"
 890                         }
 891 #line 83 "track.vala"
 892                         potential_clip = (ModelClip*) gee_iterator_get (_potential_clip_it);
 893 #line 84 "track.vala"
 894                         if (potential_clip != clip) {
 895 #line 896 "track.c"
 896                                 gint64 difference;
 897 #line 85 "track.vala"
 898                                 difference = model_clip_get_start (clip) - model_clip_get_end (potential_clip);
 899 #line 86 "track.vala"
 900                                 if (llabs (difference) < range) {
 901 #line 87 "track.vala"
 902                                         *adjustment = -difference;
 903 #line 904 "track.c"
 904                                         result = TRUE;
 905                                         _g_object_unref0 (potential_clip);
 906                                         _g_object_unref0 (_potential_clip_it);
 907 #line 88 "track.vala"
 908                                         return result;
 909 #line 910 "track.c"
 910                                 }
 911 #line 91 "track.vala"
 912                                 difference = model_clip_get_start (potential_clip) - model_clip_get_end (clip);
 913 #line 92 "track.vala"
 914                                 if (llabs (difference) < range) {
 915 #line 93 "track.vala"
 916                                         *adjustment = difference;
 917 #line 918 "track.c"
 918                                         result = TRUE;
 919                                         _g_object_unref0 (potential_clip);
 920                                         _g_object_unref0 (_potential_clip_it);
 921 #line 94 "track.vala"
 922                                         return result;
 923 #line 924 "track.c"
 924                                 }
 925                         }
 926                         _g_object_unref0 (potential_clip);
 927                 }
 928                 _g_object_unref0 (_potential_clip_it);
 929         }
 930         result = FALSE;
 931 #line 98 "track.vala"
 932         return result;
 933 #line 934 "track.c"
 934 }
 935
 936
 937 #line 101 "track.vala"
 938 static gint model_track_get_insert_index (ModelTrack* self, gint64 time) {
 939 #line 940 "track.c"
 940         gint result = 0;
 941         gint end_ret;
 942 #line 101 "track.vala"
 943         g_return_val_if_fail (MODEL_IS_TRACK (self), 0);
 944 #line 102 "track.vala"
 945         end_ret = 0;
 946 #line 947 "track.c"
 947         {
 948                 gint i;
 949 #line 103 "track.vala"
 950                 i = 0;
 951 #line 952 "track.c"
 952                 {
 953                         gboolean _tmp0_;
 954 #line 103 "track.vala"
 955                         _tmp0_ = TRUE;
 956 #line 103 "track.vala"
 957                         while (TRUE) {
 958 #line 959 "track.c"
 959                                 ModelClip* c;
 960 #line 103 "track.vala"
 961                                 if (!_tmp0_) {
 962 #line 103 "track.vala"
 963                                         i++;
 964 #line 965 "track.c"
 965                                 }
 966 #line 103 "track.vala"
 967                                 _tmp0_ = FALSE;
 968 #line 103 "track.vala"
 969                                 if (!(i < gee_collection_get_size (GEE_COLLECTION (self->clips)))) {
 970 #line 103 "track.vala"
 971                                         break;
 972 #line 973 "track.c"
 973                                 }
 974                                 c = (ModelClip*) gee_abstract_list_get (GEE_ABSTRACT_LIST (self->clips), i);
 975 #line 106 "track.vala"
 976                                 if (time >= model_clip_get_start (c)) {
 977 #line 107 "track.vala"
 978                                         if (time < (model_clip_get_start (c) + (model_clip_get_duration (c) / 2))) {
 979 #line 980 "track.c"
 980                                                 result = i;
 981                                                 _g_object_unref0 (c);
 982 #line 108 "track.vala"
 983                                                 return result;
 984 #line 985 "track.c"
 985                                         } else {
 986 #line 109 "track.vala"
 987                                                 if (time < (model_clip_get_start (c) + model_clip_get_duration (c))) {
 988 #line 989 "track.c"
 989                                                         result = i + 1;
 990                                                         _g_object_unref0 (c);
 991 #line 110 "track.vala"
 992                                                         return result;
 993 #line 994 "track.c"
 994                                                 } else {
 995 #line 112 "track.vala"
 996                                                         end_ret++;
 997 #line 998 "track.c"
 998                                                 }
 999                                         }
1000                                 }
1001                                 _g_object_unref0 (c);
1002                         }
1003                 }
1004         }
1005         result = end_ret;
1006 #line 115 "track.vala"
1007         return result;
1008 #line 1009 "track.c"
1009 }
1010
1011
1012 #line 119 "track.vala"
1013 ModelGap* model_track_find_first_gap (ModelTrack* self, gint64 start) {
1014 #line 1015 "track.c"
1015         ModelGap* result = NULL;
1016         gint64 new_start;
1017         gint64 new_end;
1018 #line 119 "track.vala"
1019         g_return_val_if_fail (MODEL_IS_TRACK (self), NULL);
1020 #line 120 "track.vala"
1021         new_start = (gint64) 0;
1022 #line 121 "track.vala"
1023         new_end = G_MAXINT64;
1024 #line 1025 "track.c"
1025         {
1026                 GeeIterator* _c_it;
1027                 _c_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (self->clips));
1028 #line 123 "track.vala"
1029                 while (TRUE) {
1030 #line 1031 "track.c"
1031                         ModelClip* c;
1032                         gboolean _tmp0_ = FALSE;
1033 #line 123 "track.vala"
1034                         if (!gee_iterator_next (_c_it)) {
1035 #line 123 "track.vala"
1036                                 break;
1037 #line 1038 "track.c"
1038                         }
1039 #line 123 "track.vala"
1040                         c = (ModelClip*) gee_iterator_get (_c_it);
1041 #line 124 "track.vala"
1042                         if (model_clip_get_start (c) > new_start) {
1043 #line 125 "track.vala"
1044                                 _tmp0_ = model_clip_get_start (c) > start;
1045 #line 1046 "track.c"
1046                         } else {
1047 #line 124 "track.vala"
1048                                 _tmp0_ = FALSE;
1049 #line 1050 "track.c"
1050                         }
1051 #line 124 "track.vala"
1052                         if (_tmp0_) {
1053 #line 126 "track.vala"
1054                                 new_end = model_clip_get_start (c);
1055 #line 1056 "track.c"
1056                                 _g_object_unref0 (c);
1057 #line 127 "track.vala"
1058                                 break;
1059 #line 1060 "track.c"
1060                         }
1061 #line 129 "track.vala"
1062                         new_start = model_clip_get_end (c);
1063 #line 1064 "track.c"
1064                         _g_object_unref0 (c);
1065                 }
1066                 _g_object_unref0 (_c_it);
1067         }
1068         result = model_gap_new (new_start, new_end);
1069 #line 131 "track.vala"
1070         return result;
1071 #line 1072 "track.c"
1072 }
1073
1074
1075 #line 135 "track.vala"
1076 static gint model_track_get_gap_index (ModelTrack* self, gint64 time) {
1077 #line 1078 "track.c"
1078         gint result = 0;
1079         gint i;
1080 #line 135 "track.vala"
1081         g_return_val_if_fail (MODEL_IS_TRACK (self), 0);
1082 #line 136 "track.vala"
1083         i = 0;
1084 #line 137 "track.vala"
1085         while (TRUE) {
1086 #line 1087 "track.c"
1087                 ModelClip* _tmp0_;
1088                 gboolean _tmp1_;
1089 #line 137 "track.vala"
1090                 if (!(i < gee_collection_get_size (GEE_COLLECTION (self->clips)))) {
1091 #line 137 "track.vala"
1092                         break;
1093 #line 1094 "track.c"
1094                 }
1095 #line 138 "track.vala"
1096                 if ((_tmp1_ = time <= model_clip_get_start (_tmp0_ = (ModelClip*) gee_abstract_list_get (GEE_ABSTRACT_LIST (self->clips), i)), _g_object_unref0 (_tmp0_), _tmp1_)) {
1097 #line 139 "track.vala"
1098                         break;
1099 #line 1100 "track.c"
1100                 }
1101 #line 140 "track.vala"
1102                 i++;
1103 #line 1104 "track.c"
1104         }
1105         result = i;
1106 #line 142 "track.vala"
1107         return result;
1108 #line 1109 "track.c"
1109 }
1110
1111
1112 #line 147 "track.vala"
1113 void model_track_find_containing_gap (ModelTrack* self, gint64 time, ModelGap** g) {
1114 #line 1115 "track.c"
1115         ModelGap* _tmp0_;
1116         gint index;
1117 #line 147 "track.vala"
1118         g_return_if_fail (MODEL_IS_TRACK (self));
1119 #line 1120 "track.c"
1120         if (g != NULL) {
1121                 *g = NULL;
1122         }
1123 #line 148 "track.vala"
1124         *g = (_tmp0_ = model_gap_new ((gint64) 0, (gint64) 0), _model_gap_unref0 (*g), _tmp0_);
1125 #line 150 "track.vala"
1126         index = model_track_get_gap_index (self, time);
1127 #line 151 "track.vala"
1128         if (index < gee_collection_get_size (GEE_COLLECTION (self->clips))) {
1129 #line 1130 "track.c"
1130                 gint64 _tmp1_ = 0LL;
1131                 ModelClip* _tmp3_;
1132 #line 152 "track.vala"
1133                 if (index > 0) {
1134 #line 1135 "track.c"
1135                         ModelClip* _tmp2_;
1136 #line 152 "track.vala"
1137                         _tmp1_ = model_clip_get_end (_tmp2_ = (ModelClip*) gee_abstract_list_get (GEE_ABSTRACT_LIST (self->clips), index - 1));
1138 #line 1139 "track.c"
1139                         _g_object_unref0 (_tmp2_);
1140                 } else {
1141 #line 152 "track.vala"
1142                         _tmp1_ = (gint64) 0;
1143 #line 1144 "track.c"
1144                 }
1145 #line 152 "track.vala"
1146                 (*g)->start = _tmp1_;
1147 #line 153 "track.vala"
1148                 (*g)->end = model_clip_get_start (_tmp3_ = (ModelClip*) gee_abstract_list_get (GEE_ABSTRACT_LIST (self->clips), index));
1149 #line 1150 "track.c"
1150                 _g_object_unref0 (_tmp3_);
1151         }
1152 }
1153
1154
1155 #line 157 "track.vala"
1156 ModelClip* model_track_find_overlapping_clip (ModelTrack* self, gint64 start, gint64 length) {
1157 #line 1158 "track.c"
1158         ModelClip* result = NULL;
1159 #line 157 "track.vala"
1160         g_return_val_if_fail (MODEL_IS_TRACK (self), NULL);
1161 #line 1162 "track.c"
1162         {
1163                 gint i;
1164 #line 158 "track.vala"
1165                 i = 0;
1166 #line 1167 "track.c"
1167                 {
1168                         gboolean _tmp0_;
1169 #line 158 "track.vala"
1170                         _tmp0_ = TRUE;
1171 #line 158 "track.vala"
1172                         while (TRUE) {
1173 #line 1174 "track.c"
1174                                 ModelClip* c;
1175 #line 158 "track.vala"
1176                                 if (!_tmp0_) {
1177 #line 158 "track.vala"
1178                                         i++;
1179 #line 1180 "track.c"
1180                                 }
1181 #line 158 "track.vala"
1182                                 _tmp0_ = FALSE;
1183 #line 158 "track.vala"
1184                                 if (!(i < gee_collection_get_size (GEE_COLLECTION (self->clips)))) {
1185 #line 158 "track.vala"
1186                                         break;
1187 #line 1188 "track.c"
1188                                 }
1189                                 c = (ModelClip*) gee_abstract_list_get (GEE_ABSTRACT_LIST (self->clips), i);
1190 #line 160 "track.vala"
1191                                 if (model_clip_overlap_pos (c, start, length)) {
1192 #line 1193 "track.c"
1193                                         result = c;
1194 #line 161 "track.vala"
1195                                         return result;
1196 #line 1197 "track.c"
1197                                 }
1198                                 _g_object_unref0 (c);
1199                         }
1200                 }
1201         }
1202         result = NULL;
1203 #line 163 "track.vala"
1204         return result;
1205 #line 1206 "track.c"
1206 }
1207
1208
1209 #line 166 "track.vala"
1210 ModelClip* model_track_find_nearest_clip_edge (ModelTrack* self, gint64 time, gboolean* after) {
1211 #line 1212 "track.c"
1212         ModelClip* result = NULL;
1213         gint limit;
1214         ModelClip* _tmp0_;
1215         gint64 _tmp1_;
1216         gint64 prev_time;
1217 #line 166 "track.vala"
1218         g_return_val_if_fail (MODEL_IS_TRACK (self), NULL);
1219 #line 167 "track.vala"
1220         limit = gee_collection_get_size (GEE_COLLECTION (self->clips)) * 2;
1221 #line 168 "track.vala"
1222         prev_time = (_tmp1_ = model_clip_get_start (_tmp0_ = (ModelClip*) gee_abstract_list_get (GEE_ABSTRACT_LIST (self->clips), 0)), _g_object_unref0 (_tmp0_), _tmp1_);
1223 #line 1224 "track.c"
1224         {
1225                 gint i;
1226 #line 170 "track.vala"
1227                 i = 1;
1228 #line 1229 "track.c"
1229                 {
1230                         gboolean _tmp2_;
1231 #line 170 "track.vala"
1232                         _tmp2_ = TRUE;
1233 #line 170 "track.vala"
1234                         while (TRUE) {
1235 #line 1236 "track.c"
1236                                 ModelClip* c;
1237                                 gint64 t = 0LL;
1238 #line 170 "track.vala"
1239                                 if (!_tmp2_) {
1240 #line 170 "track.vala"
1241                                         i++;
1242 #line 1243 "track.c"
1243                                 }
1244 #line 170 "track.vala"
1245                                 _tmp2_ = FALSE;
1246 #line 170 "track.vala"
1247                                 if (!(i < limit)) {
1248 #line 170 "track.vala"
1249                                         break;
1250 #line 1251 "track.c"
1251                                 }
1252                                 c = (ModelClip*) gee_abstract_list_get (GEE_ABSTRACT_LIST (self->clips), i / 2);
1253 #line 174 "track.vala"
1254                                 if ((i % 2) == 0) {
1255 #line 175 "track.vala"
1256                                         t = model_clip_get_start (c);
1257 #line 1258 "track.c"
1258                                 } else {
1259 #line 177 "track.vala"
1260                                         t = model_clip_get_end (c);
1261 #line 1262 "track.c"
1262                                 }
1263 #line 179 "track.vala"
1264                                 if (t > time) {
1265 #line 180 "track.vala"
1266                                         if ((t - time) < (time - prev_time)) {
1267 #line 181 "track.vala"
1268                                                 *after = (i % 2) != 0;
1269 #line 1270 "track.c"
1270                                                 result = (ModelClip*) gee_abstract_list_get (GEE_ABSTRACT_LIST (self->clips), i / 2);
1271                                                 _g_object_unref0 (c);
1272 #line 182 "track.vala"
1273                                                 return result;
1274 #line 1275 "track.c"
1275                                         } else {
1276 #line 184 "track.vala"
1277                                                 *after = (i % 2) == 0;
1278 #line 1279 "track.c"
1279                                                 result = (ModelClip*) gee_abstract_list_get (GEE_ABSTRACT_LIST (self->clips), (i - 1) / 2);
1280                                                 _g_object_unref0 (c);
1281 #line 185 "track.vala"
1282                                                 return result;
1283 #line 1284 "track.c"
1284                                         }
1285                                 }
1286 #line 188 "track.vala"
1287                                 prev_time = t;
1288 #line 1289 "track.c"
1289                                 _g_object_unref0 (c);
1290                         }
1291                 }
1292         }
1293 #line 191 "track.vala"
1294         *after = TRUE;
1295 #line 1296 "track.c"
1296         result = (ModelClip*) gee_abstract_list_get (GEE_ABSTRACT_LIST (self->clips), gee_collection_get_size (GEE_COLLECTION (self->clips)) - 1);
1297 #line 192 "track.vala"
1298         return result;
1299 #line 1300 "track.c"
1300 }
1301
1302
1303 #line 195 "track.vala"
1304 static void model_track_do_clip_overwrite (ModelTrack* self, ModelClip* c) {
1305 #line 1306 "track.c"
1306         gint start_index;
1307         gint end_index;
1308         gboolean _tmp11_ = FALSE;
1309         gint i;
1310 #line 195 "track.vala"
1311         g_return_if_fail (MODEL_IS_TRACK (self));
1312 #line 195 "track.vala"
1313         g_return_if_fail (MODEL_IS_CLIP (c));
1314 #line 196 "track.vala"
1315         start_index = model_track_get_clip_from_time (self, model_clip_get_start (c));
1316 #line 197 "track.vala"
1317         end_index = model_track_get_clip_from_time (self, model_clip_get_end (c));
1318 #line 199 "track.vala"
1319         if (end_index >= 0) {
1320 #line 1321 "track.c"
1321                 ModelClip* _tmp0_;
1322                 gint64 _tmp1_;
1323                 gint64 diff;
1324 #line 200 "track.vala"
1325                 diff = (_tmp1_ = model_clip_get_end (c) - model_clip_get_start (_tmp0_ = (ModelClip*) gee_abstract_list_get (GEE_ABSTRACT_LIST (self->clips), end_index)), _g_object_unref0 (_tmp0_), _tmp1_);
1326 #line 201 "track.vala"
1327                 if (end_index == start_index) {
1328 #line 1329 "track.c"
1329                         ModelClip* _tmp2_;
1330                         gboolean _tmp3_;
1331 #line 202 "track.vala"
1332                         if ((_tmp3_ = c == (_tmp2_ = (ModelClip*) gee_abstract_list_get (GEE_ABSTRACT_LIST (self->clips), end_index)), _g_object_unref0 (_tmp2_), _tmp3_)) {
1333 #line 203 "track.vala"
1334                                 return;
1335 #line 1336 "track.c"
1336                         }
1337 #line 206 "track.vala"
1338                         if (diff > 0) {
1339 #line 1340 "track.c"
1340                                 ModelClip* _tmp8_;
1341                                 ModelClip* _tmp7_;
1342                                 ModelClip* _tmp6_;
1343                                 ModelClip* _tmp5_;
1344                                 ModelClip* _tmp4_;
1345                                 ModelClip* _tmp9_;
1346                                 ModelClip* cl;
1347 #line 207 "track.vala"
1348                                 cl = (_tmp9_ = model_clip_new ((_tmp4_ = (ModelClip*) gee_abstract_list_get (GEE_ABSTRACT_LIST (self->clips), end_index))->clipfile, (_tmp5_ = (ModelClip*) gee_abstract_list_get (GEE_ABSTRACT_LIST (self->clips), end_index))->type, (_tmp6_ = (ModelClip*) gee_abstract_list_get (GEE_ABSTRACT_LIST (self->clips), end_index))->name, model_clip_get_end (c), model_clip_get_media_start (_tmp7_ = (ModelClip*) gee_abstract_list_get (GEE_ABSTRACT_LIST (self->clips), end_index)) + diff, model_clip_get_duration (_tmp8_ = (ModelClip*) gee_abstract_list_get (GEE_ABSTRACT_LIST (self->clips), end_index)) - diff, FALSE), _g_object_unref0 (_tmp8_), _g_object_unref0 (_tmp7_), _g_object_unref0 (_tmp6_), _g_object_unref0 (_tmp5_), _g_object_unref0 (_tmp4_), _tmp9_);
1349 #line 211 "track.vala"
1350                                 model_track_append_at_time (self, cl, model_clip_get_start (cl), FALSE);
1351 #line 1352 "track.c"
1352                                 _g_object_unref0 (cl);
1353                         }
1354                 } else {
1355                         ModelClip* _tmp10_;
1356 #line 214 "track.vala"
1357                         model_track_trim (self, _tmp10_ = (ModelClip*) gee_abstract_list_get (GEE_ABSTRACT_LIST (self->clips), end_index), diff, GDK_WINDOW_EDGE_WEST);
1358 #line 1359 "track.c"
1359                         _g_object_unref0 (_tmp10_);
1360                 }
1361         }
1362 #line 217 "track.vala"
1363         if (start_index >= 0) {
1364 #line 1365 "track.c"
1365                 ModelClip* _tmp12_;
1366 #line 217 "track.vala"
1367                 _tmp11_ = (_tmp12_ = (ModelClip*) gee_abstract_list_get (GEE_ABSTRACT_LIST (self->clips), start_index)) != c;
1368 #line 1369 "track.c"
1369                 _g_object_unref0 (_tmp12_);
1370         } else {
1371 #line 217 "track.vala"
1372                 _tmp11_ = FALSE;
1373 #line 1374 "track.c"
1374         }
1375 #line 217 "track.vala"
1376         if (_tmp11_) {
1377 #line 1378 "track.c"
1378                 ModelClip* _tmp13_;
1379                 gint64 _tmp14_;
1380                 gint64 delta;
1381                 ModelClip* _tmp15_;
1382 #line 218 "track.vala"
1383                 delta = (_tmp14_ = model_clip_get_end (_tmp13_ = (ModelClip*) gee_abstract_list_get (GEE_ABSTRACT_LIST (self->clips), start_index)) - model_clip_get_start (c), _g_object_unref0 (_tmp13_), _tmp14_);
1384 #line 219 "track.vala"
1385                 model_track_trim (self, _tmp15_ = (ModelClip*) gee_abstract_list_get (GEE_ABSTRACT_LIST (self->clips), start_index), -delta, GDK_WINDOW_EDGE_EAST);
1386 #line 1387 "track.c"
1387                 _g_object_unref0 (_tmp15_);
1388         }
1389 #line 222 "track.vala"
1390         i = 0;
1391 #line 226 "track.vala"
1392         if (!model_undo_manager_get_in_undo (self->project->undo_manager)) {
1393 #line 227 "track.vala"
1394                 while (TRUE) {
1395 #line 1396 "track.c"
1396                         gboolean _tmp16_ = FALSE;
1397                         gboolean _tmp17_ = FALSE;
1398                         ModelClip* _tmp18_;
1399                         gboolean _tmp19_;
1400 #line 227 "track.vala"
1401                         if (!(i < gee_collection_get_size (GEE_COLLECTION (self->clips)))) {
1402 #line 227 "track.vala"
1403                                 break;
1404 #line 1405 "track.c"
1405                         }
1406 #line 228 "track.vala"
1407                         if ((_tmp19_ = (_tmp18_ = (ModelClip*) gee_abstract_list_get (GEE_ABSTRACT_LIST (self->clips), i)) != c, _g_object_unref0 (_tmp18_), _tmp19_)) {
1408 #line 1409 "track.c"
1409                                 ModelClip* _tmp20_;
1410 #line 229 "track.vala"
1411                                 _tmp17_ = model_clip_get_start (_tmp20_ = (ModelClip*) gee_abstract_list_get (GEE_ABSTRACT_LIST (self->clips), i)) >= model_clip_get_start (c);
1412 #line 1413 "track.c"
1413                                 _g_object_unref0 (_tmp20_);
1414                         } else {
1415 #line 228 "track.vala"
1416                                 _tmp17_ = FALSE;
1417 #line 1418 "track.c"
1418                         }
1419 #line 228 "track.vala"
1420                         if (_tmp17_) {
1421 #line 1422 "track.c"
1422                                 ModelClip* _tmp21_;
1423 #line 230 "track.vala"
1424                                 _tmp16_ = model_clip_get_end (_tmp21_ = (ModelClip*) gee_abstract_list_get (GEE_ABSTRACT_LIST (self->clips), i)) <= model_clip_get_end (c);
1425 #line 1426 "track.c"
1426                                 _g_object_unref0 (_tmp21_);
1427                         } else {
1428 #line 228 "track.vala"
1429                                 _tmp16_ = FALSE;
1430 #line 1431 "track.c"
1431                         }
1432 #line 228 "track.vala"
1433                         if (_tmp16_) {
1434 #line 1435 "track.c"
1435                                 ModelClip* _tmp22_;
1436 #line 231 "track.vala"
1437                                 model_track_delete_clip (self, _tmp22_ = (ModelClip*) gee_abstract_list_get (GEE_ABSTRACT_LIST (self->clips), i));
1438 #line 1439 "track.c"
1439                                 _g_object_unref0 (_tmp22_);
1440                         } else {
1441 #line 234 "track.vala"
1442                                 i++;
1443 #line 1444 "track.c"
1444                         }
1445                 }
1446         }
1447 }
1448
1449
1450 #line 239 "track.vala"
1451 void model_track_move (ModelTrack* self, ModelClip* c, gint64 pos, gint64 original_time) {
1452 #line 1453 "track.c"
1453         ModelCommand* command;
1454 #line 239 "track.vala"
1455         g_return_if_fail (MODEL_IS_TRACK (self));
1456 #line 239 "track.vala"
1457         g_return_if_fail (MODEL_IS_CLIP (c));
1458 #line 240 "track.vala"
1459         command = MODEL_COMMAND (model_clip_add_command_new (self, c, original_time, pos));
1460 #line 241 "track.vala"
1461         model_project_do_command (self->project, command);
1462 #line 1463 "track.c"
1463         _model_command_unref0 (command);
1464 }
1465
1466
1467 #line 244 "track.vala"
1468 void _model_track_move (ModelTrack* self, ModelClip* c, gint64 pos) {
1469 #line 244 "track.vala"
1470         g_return_if_fail (MODEL_IS_TRACK (self));
1471 #line 244 "track.vala"
1472         g_return_if_fail (MODEL_IS_CLIP (c));
1473 #line 245 "track.vala"
1474         if (pos < 0) {
1475 #line 246 "track.vala"
1476                 pos = (gint64) 0;
1477 #line 1478 "track.c"
1478         }
1479 #line 248 "track.vala"
1480         model_clip_set_start (c, pos);
1481 #line 249 "track.vala"
1482         model_track_do_clip_overwrite (self, c);
1483 #line 251 "track.vala"
1484         model_track_insert_clip_into_array (self, c, model_track_get_insert_index (self, model_clip_get_start (c)));
1485 #line 252 "track.vala"
1486         model_project_reseek (self->project);
1487 #line 1488 "track.c"
1488 }
1489
1490
1491 #line 255 "track.vala"
1492 void model_track_add (ModelTrack* self, ModelClip* c, gint64 pos, gboolean select) {
1493 #line 255 "track.vala"
1494         g_return_if_fail (MODEL_IS_TRACK (self));
1495 #line 255 "track.vala"
1496         g_return_if_fail (MODEL_IS_CLIP (c));
1497 #line 256 "track.vala"
1498         if (!model_track_check (self, c)) {
1499 #line 257 "track.vala"
1500                 return;
1501 #line 1502 "track.c"
1502         }
1503 #line 259 "track.vala"
1504         _model_track_move (self, c, pos);
1505 #line 260 "track.vala"
1506         g_signal_emit_by_name (self, "clip-added", c, select);
1507 #line 1508 "track.c"
1508 }
1509
1510
1511 #line 263 "track.vala"
1512 static void model_track_real_on_clip_updated (ModelTrack* self, ModelClip* clip) {
1513 #line 263 "track.vala"
1514         g_return_if_fail (MODEL_IS_TRACK (self));
1515 #line 263 "track.vala"
1516         g_return_if_fail (MODEL_IS_CLIP (clip));
1517 #line 264 "track.vala"
1518         logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_clip_updated");
1519 #line 1520 "track.c"
1520 }
1521
1522
1523 #line 263 "track.vala"
1524 void model_track_on_clip_updated (ModelTrack* self, ModelClip* clip) {
1525 #line 263 "track.vala"
1526         MODEL_TRACK_GET_CLASS (self)->on_clip_updated (self, clip);
1527 #line 1528 "track.c"
1528 }
1529
1530
1531 #line 267 "track.vala"
1532 void model_track_do_clip_paste (ModelTrack* self, ModelClip* clip, gint64 position) {
1533 #line 267 "track.vala"
1534         g_return_if_fail (MODEL_IS_TRACK (self));
1535 #line 267 "track.vala"
1536         g_return_if_fail (MODEL_IS_CLIP (clip));
1537 #line 268 "track.vala"
1538         model_track_append_at_time (self, clip, position, TRUE);
1539 #line 1540 "track.c"
1540 }
1541
1542
1543 #line 271 "track.vala"
1544 ModelClip* model_track_get_clip (ModelTrack* self, gint i) {
1545 #line 1546 "track.c"
1546         ModelClip* result = NULL;
1547         gboolean _tmp0_ = FALSE;
1548 #line 271 "track.vala"
1549         g_return_val_if_fail (MODEL_IS_TRACK (self), NULL);
1550 #line 272 "track.vala"
1551         if (i < 0) {
1552 #line 272 "track.vala"
1553                 _tmp0_ = TRUE;
1554 #line 1555 "track.c"
1555         } else {
1556 #line 272 "track.vala"
1557                 _tmp0_ = i >= gee_collection_get_size (GEE_COLLECTION (self->clips));
1558 #line 1559 "track.c"
1559         }
1560 #line 272 "track.vala"
1561         if (_tmp0_) {
1562 #line 273 "track.vala"
1563                 g_error ("track.vala:273: get_clip: Invalid index! %d (%d)", i, gee_collection_get_size (GEE_COLLECTION (self->clips)));
1564 #line 1565 "track.c"
1565         }
1566         result = (ModelClip*) gee_abstract_list_get (GEE_ABSTRACT_LIST (self->clips), i);
1567 #line 274 "track.vala"
1568         return result;
1569 #line 1570 "track.c"
1570 }
1571
1572
1573 #line 277 "track.vala"
1574 gint model_track_get_clip_index (ModelTrack* self, ModelClip* c) {
1575 #line 1576 "track.c"
1576         gint result = 0;
1577 #line 277 "track.vala"
1578         g_return_val_if_fail (MODEL_IS_TRACK (self), 0);
1579 #line 277 "track.vala"
1580         g_return_val_if_fail (MODEL_IS_CLIP (c), 0);
1581 #line 1582 "track.c"
1582         {
1583                 gint i;
1584 #line 278 "track.vala"
1585                 i = 0;
1586 #line 1587 "track.c"
1587                 {
1588                         gboolean _tmp0_;
1589 #line 278 "track.vala"
1590                         _tmp0_ = TRUE;
1591 #line 278 "track.vala"
1592                         while (TRUE) {
1593 #line 1594 "track.c"
1594                                 ModelClip* _tmp1_;
1595                                 gboolean _tmp2_;
1596 #line 278 "track.vala"
1597                                 if (!_tmp0_) {
1598 #line 278 "track.vala"
1599                                         i++;
1600 #line 1601 "track.c"
1601                                 }
1602 #line 278 "track.vala"
1603                                 _tmp0_ = FALSE;
1604 #line 278 "track.vala"
1605                                 if (!(i < gee_collection_get_size (GEE_COLLECTION (self->clips)))) {
1606 #line 278 "track.vala"
1607                                         break;
1608 #line 1609 "track.c"
1609                                 }
1610 #line 279 "track.vala"
1611                                 if ((_tmp2_ = (_tmp1_ = (ModelClip*) gee_abstract_list_get (GEE_ABSTRACT_LIST (self->clips), i)) == c, _g_object_unref0 (_tmp1_), _tmp2_)) {
1612 #line 1613 "track.c"
1613                                         result = i;
1614 #line 280 "track.vala"
1615                                         return result;
1616 #line 1617 "track.c"
1617                                 }
1618                         }
1619                 }
1620         }
1621         result = -1;
1622 #line 283 "track.vala"
1623         return result;
1624 #line 1625 "track.c"
1625 }
1626
1627
1628 #line 286 "track.vala"
1629 ModelClip* model_track_get_clip_by_position (ModelTrack* self, gint64 pos) {
1630 #line 1631 "track.c"
1631         ModelClip* result = NULL;
1632         gint length;
1633 #line 286 "track.vala"
1634         g_return_val_if_fail (MODEL_IS_TRACK (self), NULL);
1635 #line 287 "track.vala"
1636         length = gee_collection_get_size (GEE_COLLECTION (self->clips));
1637 #line 1638 "track.c"
1638         {
1639                 gint i;
1640 #line 289 "track.vala"
1641                 i = length - 1;
1642 #line 1643 "track.c"
1643                 {
1644                         gboolean _tmp0_;
1645 #line 289 "track.vala"
1646                         _tmp0_ = TRUE;
1647 #line 289 "track.vala"
1648                         while (TRUE) {
1649 #line 1650 "track.c"
1650                                 ModelClip* _tmp1_;
1651                                 gboolean _tmp2_;
1652 #line 289 "track.vala"
1653                                 if (!_tmp0_) {
1654 #line 289 "track.vala"
1655                                         i--;
1656 #line 1657 "track.c"
1657                                 }
1658 #line 289 "track.vala"
1659                                 _tmp0_ = FALSE;
1660 #line 289 "track.vala"
1661                                 if (!(i >= 0)) {
1662 #line 289 "track.vala"
1663                                         break;
1664 #line 1665 "track.c"
1665                                 }
1666 #line 290 "track.vala"
1667                                 if ((_tmp2_ = model_clip_get_start (_tmp1_ = (ModelClip*) gee_abstract_list_get (GEE_ABSTRACT_LIST (self->clips), i)) < pos, _g_object_unref0 (_tmp1_), _tmp2_)) {
1668 #line 1669 "track.c"
1669                                         ModelClip* _tmp3_;
1670                                         ModelClip* _tmp4_;
1671                                         gboolean _tmp5_;
1672                                         _tmp3_ = NULL;
1673 #line 291 "track.vala"
1674                                         if ((_tmp5_ = pos >= model_clip_get_end (_tmp4_ = (ModelClip*) gee_abstract_list_get (GEE_ABSTRACT_LIST (self->clips), i)), _g_object_unref0 (_tmp4_), _tmp5_)) {
1675 #line 1676 "track.c"
1676                                                 ModelClip* _tmp6_;
1677 #line 291 "track.vala"
1678                                                 _tmp3_ = (_tmp6_ = NULL, _g_object_unref0 (_tmp3_), _tmp6_);
1679 #line 1680 "track.c"
1680                                         } else {
1681                                                 ModelClip* _tmp7_;
1682                                                 _tmp3_ = (_tmp7_ = (ModelClip*) gee_abstract_list_get (GEE_ABSTRACT_LIST (self->clips), i), _g_object_unref0 (_tmp3_), _tmp7_);
1683                                         }
1684                                         result = _tmp3_;
1685 #line 291 "track.vala"
1686                                         return result;
1687 #line 1688 "track.c"
1688                                 }
1689                         }
1690                 }
1691         }
1692         result = NULL;
1693 #line 292 "track.vala"
1694         return result;
1695 #line 1696 "track.c"
1696 }
1697
1698
1699 #line 295 "track.vala"
1700 gint64 model_track_get_length (ModelTrack* self) {
1701 #line 1702 "track.c"
1702         gint64 result = 0LL;
1703         gint64 _tmp0_ = 0LL;
1704 #line 295 "track.vala"
1705         g_return_val_if_fail (MODEL_IS_TRACK (self), 0LL);
1706 #line 296 "track.vala"
1707         if (gee_collection_get_size (GEE_COLLECTION (self->clips)) == 0) {
1708 #line 296 "track.vala"
1709                 _tmp0_ = (gint64) 0;
1710 #line 1711 "track.c"
1711         } else {
1712                 ModelClip* _tmp2_;
1713                 ModelClip* _tmp1_;
1714 #line 296 "track.vala"
1715                 _tmp0_ = model_clip_get_start (_tmp1_ = (ModelClip*) gee_abstract_list_get (GEE_ABSTRACT_LIST (self->clips), gee_collection_get_size (GEE_COLLECTION (self->clips)) - 1)) + model_clip_get_duration (_tmp2_ = (ModelClip*) gee_abstract_list_get (GEE_ABSTRACT_LIST (self->clips), gee_collection_get_size (GEE_COLLECTION (self->clips)) - 1));
1716 #line 1717 "track.c"
1717                 _g_object_unref0 (_tmp2_);
1718                 _g_object_unref0 (_tmp1_);
1719         }
1720         result = _tmp0_;
1721 #line 296 "track.vala"
1722         return result;
1723 #line 1724 "track.c"
1724 }
1725
1726
1727 #line 299 "track.vala"
1728 void _model_track_append_at_time (ModelTrack* self, ModelClip* c, gint64 time, gboolean select) {
1729 #line 299 "track.vala"
1730         g_return_if_fail (MODEL_IS_TRACK (self));
1731 #line 299 "track.vala"
1732         g_return_if_fail (MODEL_IS_CLIP (c));
1733 #line 300 "track.vala"
1734         model_track_add (self, c, time, select);
1735 #line 1736 "track.c"
1736 }
1737
1738
1739 #line 303 "track.vala"
1740 void model_track_append_at_time (ModelTrack* self, ModelClip* c, gint64 time, gboolean select) {
1741 #line 1742 "track.c"
1742         ModelCommand* command;
1743 #line 303 "track.vala"
1744         g_return_if_fail (MODEL_IS_TRACK (self));
1745 #line 303 "track.vala"
1746         g_return_if_fail (MODEL_IS_CLIP (c));
1747 #line 304 "track.vala"
1748         command = MODEL_COMMAND (model_clip_command_new (MODEL_CLIP_COMMAND_ACTION_APPEND, self, c, time, select));
1749 #line 305 "track.vala"
1750         model_project_do_command (self->project, command);
1751 #line 1752 "track.c"
1752         _model_command_unref0 (command);
1753 }
1754
1755
1756 #line 308 "track.vala"
1757 void model_track_delete_clip (ModelTrack* self, ModelClip* clip) {
1758 #line 1759 "track.c"
1759         ModelCommand* clip_command;
1760 #line 308 "track.vala"
1761         g_return_if_fail (MODEL_IS_TRACK (self));
1762 #line 308 "track.vala"
1763         g_return_if_fail (MODEL_IS_CLIP (clip));
1764 #line 309 "track.vala"
1765         clip_command = MODEL_COMMAND (model_clip_command_new (MODEL_CLIP_COMMAND_ACTION_DELETE, self, clip, model_clip_get_start (clip), FALSE));
1766 #line 311 "track.vala"
1767         model_project_do_command (self->project, clip_command);
1768 #line 1769 "track.c"
1769         _model_command_unref0 (clip_command);
1770 }
1771
1772
1773 #line 314 "track.vala"
1774 void _model_track_delete_clip (ModelTrack* self, ModelClip* clip) {
1775 #line 1776 "track.c"
1776         gint index;
1777         ModelClip* _tmp0_;
1778 #line 314 "track.vala"
1779         g_return_if_fail (MODEL_IS_TRACK (self));
1780 #line 314 "track.vala"
1781         g_return_if_fail (MODEL_IS_CLIP (clip));
1782 #line 315 "track.vala"
1783         index = model_track_get_clip_index (self, clip);
1784 #line 316 "track.vala"
1785         g_assert (index != (-1));
1786 #line 317 "track.vala"
1787         _tmp0_ = (ModelClip*) gee_abstract_list_remove_at (GEE_ABSTRACT_LIST (self->clips), index);
1788 #line 1789 "track.c"
1789         _g_object_unref0 (_tmp0_);
1790 #line 319 "track.vala"
1791         g_signal_emit_by_name (clip, "removed", clip);
1792 #line 320 "track.vala"
1793         g_signal_emit_by_name (self, "clip-removed", clip);
1794 #line 1795 "track.c"
1795 }
1796
1797
1798 #line 323 "track.vala"
1799 void model_track_delete_gap (ModelTrack* self, ModelGap* g) {
1800 #line 323 "track.vala"
1801         g_return_if_fail (MODEL_IS_TRACK (self));
1802 #line 323 "track.vala"
1803         g_return_if_fail (MODEL_IS_GAP (g));
1804 #line 324 "track.vala"
1805         model_project_reseek (self->project);
1806 #line 1807 "track.c"
1807 }
1808
1809
1810 #line 327 "track.vala"
1811 void model_track_remove_clip_from_array (ModelTrack* self, ModelClip* pos) {
1812 #line 327 "track.vala"
1813         g_return_if_fail (MODEL_IS_TRACK (self));
1814 #line 327 "track.vala"
1815         g_return_if_fail (MODEL_IS_CLIP (pos));
1816 #line 328 "track.vala"
1817         gee_abstract_collection_remove (GEE_ABSTRACT_COLLECTION (self->clips), pos);
1818 #line 1819 "track.c"
1819 }
1820
1821
1822 #line 263 "track.vala"
1823 static void _model_track_on_clip_updated_model_clip_updated (ModelClip* _sender, ModelClip* clip, gpointer self) {
1824 #line 1825 "track.c"
1825         model_track_on_clip_updated (self, clip);
1826 }
1827
1828
1829 #line 331 "track.vala"
1830 static void model_track_insert_clip_into_array (ModelTrack* self, ModelClip* c, gint pos) {
1831 #line 331 "track.vala"
1832         g_return_if_fail (MODEL_IS_TRACK (self));
1833 #line 331 "track.vala"
1834         g_return_if_fail (MODEL_IS_CLIP (c));
1835 #line 332 "track.vala"
1836         g_signal_connect_object (c, "updated", (GCallback) _model_track_on_clip_updated_model_clip_updated, self, 0);
1837 #line 333 "track.vala"
1838         gee_abstract_list_insert (GEE_ABSTRACT_LIST (self->clips), pos, c);
1839 #line 1840 "track.c"
1840 }
1841
1842
1843 #line 336 "track.vala"
1844 void model_track_delete_all_clips (ModelTrack* self) {
1845 #line 1846 "track.c"
1846         guint size;
1847 #line 336 "track.vala"
1848         g_return_if_fail (MODEL_IS_TRACK (self));
1849 #line 337 "track.vala"
1850         size = (guint) gee_collection_get_size (GEE_COLLECTION (self->clips));
1851 #line 1852 "track.c"
1852         {
1853                 gint i;
1854 #line 338 "track.vala"
1855                 i = 0;
1856 #line 1857 "track.c"
1857                 {
1858                         gboolean _tmp0_;
1859 #line 338 "track.vala"
1860                         _tmp0_ = TRUE;
1861 #line 338 "track.vala"
1862                         while (TRUE) {
1863 #line 1864 "track.c"
1864                                 ModelClip* _tmp1_;
1865 #line 338 "track.vala"
1866                                 if (!_tmp0_) {
1867 #line 338 "track.vala"
1868                                         i++;
1869 #line 1870 "track.c"
1870                                 }
1871 #line 338 "track.vala"
1872                                 _tmp0_ = FALSE;
1873 #line 338 "track.vala"
1874                                 if (!(i < size)) {
1875 #line 338 "track.vala"
1876                                         break;
1877 #line 1878 "track.c"
1878                                 }
1879 #line 339 "track.vala"
1880                                 model_track_delete_clip (self, _tmp1_ = (ModelClip*) gee_abstract_list_get (GEE_ABSTRACT_LIST (self->clips), 0));
1881 #line 1882 "track.c"
1882                                 _g_object_unref0 (_tmp1_);
1883                         }
1884                 }
1885         }
1886 #line 341 "track.vala"
1887         view_media_engine_go (self->project->media_engine, (gint64) 0);
1888 #line 1889 "track.c"
1889 }
1890
1891
1892 #line 344 "track.vala"
1893 void model_track_revert_to_original (ModelTrack* self, ModelClip* clip) {
1894 #line 1895 "track.c"
1895         ModelCommand* command;
1896 #line 344 "track.vala"
1897         g_return_if_fail (MODEL_IS_TRACK (self));
1898 #line 344 "track.vala"
1899         g_return_if_fail (MODEL_IS_CLIP (clip));
1900 #line 345 "track.vala"
1901         command = MODEL_COMMAND (model_clip_revert_command_new (self, clip));
1902 #line 346 "track.vala"
1903         model_project_do_command (self->project, command);
1904 #line 1905 "track.c"
1905         _model_command_unref0 (command);
1906 }
1907
1908
1909 #line 349 "track.vala"
1910 void _model_track_revert_to_original (ModelTrack* self, ModelClip* c) {
1911 #line 1912 "track.c"
1912         gint index;
1913 #line 349 "track.vala"
1914         g_return_if_fail (MODEL_IS_TRACK (self));
1915 #line 349 "track.vala"
1916         g_return_if_fail (MODEL_IS_CLIP (c));
1917 #line 350 "track.vala"
1918         index = model_track_get_clip_index (self, c);
1919 #line 351 "track.vala"
1920         if (index == (-1)) {
1921 #line 352 "track.vala"
1922                 g_error ("track.vala:352: revert_to_original: Clip not in track array!");
1923 #line 1924 "track.c"
1924         }
1925 #line 354 "track.vala"
1926         model_clip_set_media_start_duration (c, (gint64) 0, model_clip_file_get_length (c->clipfile));
1927 #line 356 "track.vala"
1928         view_media_engine_go (self->project->media_engine, model_clip_get_start (c));
1929 #line 1930 "track.c"
1930 }
1931
1932
1933 #line 359 "track.vala"
1934 gboolean model_track_are_contiguous_clips (ModelTrack* self, gint64 position) {
1935 #line 1936 "track.c"
1936         gboolean result = FALSE;
1937         ModelClip* right_clip;
1938         ModelClip* left_clip;
1939         gboolean _tmp0_ = FALSE;
1940         gboolean _tmp1_ = FALSE;
1941         gboolean _tmp2_ = FALSE;
1942         gboolean _tmp3_ = FALSE;
1943 #line 359 "track.vala"
1944         g_return_val_if_fail (MODEL_IS_TRACK (self), FALSE);
1945 #line 360 "track.vala"
1946         right_clip = model_track_get_clip_by_position (self, position + 1);
1947 #line 361 "track.vala"
1948         left_clip = model_track_get_clip_by_position (self, position - 1);
1949 #line 363 "track.vala"
1950         if (left_clip != NULL) {
1951 #line 363 "track.vala"
1952                 _tmp3_ = right_clip != NULL;
1953 #line 1954 "track.c"
1954         } else {
1955 #line 363 "track.vala"
1956                 _tmp3_ = FALSE;
1957 #line 1958 "track.c"
1958         }
1959 #line 363 "track.vala"
1960         if (_tmp3_) {
1961 #line 364 "track.vala"
1962                 _tmp2_ = left_clip != right_clip;
1963 #line 1964 "track.c"
1964         } else {
1965 #line 363 "track.vala"
1966                 _tmp2_ = FALSE;
1967 #line 1968 "track.c"
1968         }
1969 #line 363 "track.vala"
1970         if (_tmp2_) {
1971 #line 365 "track.vala"
1972                 _tmp1_ = left_clip->clipfile == right_clip->clipfile;
1973 #line 1974 "track.c"
1974         } else {
1975 #line 363 "track.vala"
1976                 _tmp1_ = FALSE;
1977 #line 1978 "track.c"
1978         }
1979 #line 363 "track.vala"
1980         if (_tmp1_) {
1981 #line 366 "track.vala"
1982                 _tmp0_ = model_clip_get_end (left_clip) == model_clip_get_start (right_clip);
1983 #line 1984 "track.c"
1984         } else {
1985 #line 363 "track.vala"
1986                 _tmp0_ = FALSE;
1987 #line 1988 "track.c"
1988         }
1989         result = _tmp0_;
1990         _g_object_unref0 (right_clip);
1991         _g_object_unref0 (left_clip);
1992 #line 363 "track.vala"
1993         return result;
1994 #line 1995 "track.c"
1995 }
1996
1997
1998 #line 369 "track.vala"
1999 void model_track_split_at (ModelTrack* self, gint64 position) {
2000 #line 2001 "track.c"
2001         ModelCommand* command;
2002 #line 369 "track.vala"
2003         g_return_if_fail (MODEL_IS_TRACK (self));
2004 #line 370 "track.vala"
2005         command = MODEL_COMMAND (model_clip_split_command_new (MODEL_CLIP_SPLIT_COMMAND_ACTION_SPLIT, self, position));
2006 #line 371 "track.vala"
2007         model_project_do_command (self->project, command);
2008 #line 2009 "track.c"
2009         _model_command_unref0 (command);
2010 }
2011
2012
2013 #line 374 "track.vala"
2014 void _model_track_split_at (ModelTrack* self, gint64 position) {
2015 #line 2016 "track.c"
2016         ModelClip* c;
2017         ModelClip* cn;
2018 #line 374 "track.vala"
2019         g_return_if_fail (MODEL_IS_TRACK (self));
2020 #line 375 "track.vala"
2021         c = model_track_get_clip_by_position (self, position);
2022 #line 376 "track.vala"
2023         if (c == NULL) {
2024 #line 2025 "track.c"
2025                 _g_object_unref0 (c);
2026 #line 377 "track.vala"
2027                 return;
2028 #line 2029 "track.c"
2029         }
2030 #line 379 "track.vala"
2031         cn = model_clip_new (c->clipfile, c->type, c->name, position, (position - model_clip_get_start (c)) + model_clip_get_media_start (c), (model_clip_get_start (c) + model_clip_get_duration (c)) - position, FALSE);
2032 #line 383 "track.vala"
2033         model_clip_set_duration (c, position - model_clip_get_start (c));
2034 #line 385 "track.vala"
2035         model_track_add (self, cn, position, FALSE);
2036 #line 2037 "track.c"
2037         _g_object_unref0 (c);
2038         _g_object_unref0 (cn);
2039 }
2040
2041
2042 #line 388 "track.vala"
2043 void model_track_join (ModelTrack* self, gint64 position) {
2044 #line 2045 "track.c"
2045         ModelCommand* command;
2046 #line 388 "track.vala"
2047         g_return_if_fail (MODEL_IS_TRACK (self));
2048 #line 389 "track.vala"
2049         command = MODEL_COMMAND (model_clip_split_command_new (MODEL_CLIP_SPLIT_COMMAND_ACTION_JOIN, self, position));
2050 #line 390 "track.vala"
2051         model_project_do_command (self->project, command);
2052 #line 2053 "track.c"
2053         _model_command_unref0 (command);
2054 }
2055
2056
2057 #line 393 "track.vala"
2058 void _model_track_join (ModelTrack* self, gint64 position) {
2059 #line 393 "track.vala"
2060         g_return_if_fail (MODEL_IS_TRACK (self));
2061 #line 394 "track.vala"
2062         g_assert (model_track_are_contiguous_clips (self, position));
2063 #line 395 "track.vala"
2064         if (model_track_are_contiguous_clips (self, position)) {
2065 #line 2066 "track.c"
2066                 ModelClip* right_clip;
2067                 gint right_clip_index;
2068                 gint left_clip_index;
2069                 ModelClip* left_clip;
2070 #line 396 "track.vala"
2071                 right_clip = model_track_get_clip_by_position (self, position + 1);
2072 #line 397 "track.vala"
2073                 g_assert (right_clip != NULL);
2074 #line 399 "track.vala"
2075                 right_clip_index = model_track_get_clip_index (self, right_clip);
2076 #line 400 "track.vala"
2077                 g_assert (right_clip_index > 0);
2078 #line 402 "track.vala"
2079                 left_clip_index = right_clip_index - 1;
2080 #line 403 "track.vala"
2081                 left_clip = model_track_get_clip (self, left_clip_index);
2082 #line 404 "track.vala"
2083                 g_assert (left_clip != NULL);
2084 #line 405 "track.vala"
2085                 model_clip_set_duration (left_clip, model_clip_get_end (right_clip) - model_clip_get_start (left_clip));
2086 #line 406 "track.vala"
2087                 _model_track_delete_clip (self, right_clip);
2088 #line 2089 "track.c"
2089                 _g_object_unref0 (right_clip);
2090                 _g_object_unref0 (left_clip);
2091         }
2092 }
2093
2094
2095 #line 410 "track.vala"
2096 void model_track_trim (ModelTrack* self, ModelClip* clip, gint64 delta, GdkWindowEdge edge) {
2097 #line 2098 "track.c"
2098         ModelCommand* command;
2099 #line 410 "track.vala"
2100         g_return_if_fail (MODEL_IS_TRACK (self));
2101 #line 410 "track.vala"
2102         g_return_if_fail (MODEL_IS_CLIP (clip));
2103 #line 411 "track.vala"
2104         command = MODEL_COMMAND (model_clip_trim_command_new (self, clip, delta, edge));
2105 #line 412 "track.vala"
2106         model_project_do_command (self->project, command);
2107 #line 2108 "track.c"
2108         _model_command_unref0 (command);
2109 }
2110
2111
2112 #line 415 "track.vala"
2113 void _model_track_trim (ModelTrack* self, ModelClip* clip, gint64 delta, GdkWindowEdge edge) {
2114 #line 415 "track.vala"
2115         g_return_if_fail (MODEL_IS_TRACK (self));
2116 #line 415 "track.vala"
2117         g_return_if_fail (MODEL_IS_CLIP (clip));
2118 #line 416 "track.vala"
2119         model_clip_trim (clip, delta, edge);
2120 #line 417 "track.vala"
2121         model_track_do_clip_overwrite (self, clip);
2122 #line 2123 "track.c"
2123 }
2124
2125
2126 #line 420 "track.vala"
2127 gint64 model_track_previous_edit (ModelTrack* self, gint64 pos) {
2128 #line 2129 "track.c"
2129         gint64 result = 0LL;
2130 #line 420 "track.vala"
2131         g_return_val_if_fail (MODEL_IS_TRACK (self), 0LL);
2132 #line 2133 "track.c"
2133         {
2134                 gint i;
2135 #line 421 "track.vala"
2136                 i = gee_collection_get_size (GEE_COLLECTION (self->clips)) - 1;
2137 #line 2138 "track.c"
2138                 {
2139                         gboolean _tmp0_;
2140 #line 421 "track.vala"
2141                         _tmp0_ = TRUE;
2142 #line 421 "track.vala"
2143                         while (TRUE) {
2144 #line 2145 "track.c"
2145                                 ModelClip* c;
2146 #line 421 "track.vala"
2147                                 if (!_tmp0_) {
2148 #line 421 "track.vala"
2149                                         i = i - 1;
2150 #line 2151 "track.c"
2151                                 }
2152 #line 421 "track.vala"
2153                                 _tmp0_ = FALSE;
2154 #line 421 "track.vala"
2155                                 if (!(i >= 0)) {
2156 #line 421 "track.vala"
2157                                         break;
2158 #line 2159 "track.c"
2159                                 }
2160                                 c = (ModelClip*) gee_abstract_list_get (GEE_ABSTRACT_LIST (self->clips), i);
2161 #line 423 "track.vala"
2162                                 if (model_clip_get_end (c) < pos) {
2163 #line 2164 "track.c"
2164                                         result = model_clip_get_end (c);
2165                                         _g_object_unref0 (c);
2166 #line 424 "track.vala"
2167                                         return result;
2168 #line 2169 "track.c"
2169                                 }
2170 #line 425 "track.vala"
2171                                 if (model_clip_get_start (c) < pos) {
2172 #line 2173 "track.c"
2173                                         result = model_clip_get_start (c);
2174                                         _g_object_unref0 (c);
2175 #line 426 "track.vala"
2176                                         return result;
2177 #line 2178 "track.c"
2178                                 }
2179                                 _g_object_unref0 (c);
2180                         }
2181                 }
2182         }
2183         result = (gint64) 0;
2184 #line 428 "track.vala"
2185         return result;
2186 #line 2187 "track.c"
2187 }
2188
2189
2190 #line 431 "track.vala"
2191 gint64 model_track_next_edit (ModelTrack* self, gint64 pos) {
2192 #line 2193 "track.c"
2193         gint64 result = 0LL;
2194 #line 431 "track.vala"
2195         g_return_val_if_fail (MODEL_IS_TRACK (self), 0LL);
2196 #line 2197 "track.c"
2197         {
2198                 GeeIterator* _c_it;
2199                 _c_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (self->clips));
2200 #line 432 "track.vala"
2201                 while (TRUE) {
2202 #line 2203 "track.c"
2203                         ModelClip* c;
2204 #line 432 "track.vala"
2205                         if (!gee_iterator_next (_c_it)) {
2206 #line 432 "track.vala"
2207                                 break;
2208 #line 2209 "track.c"
2209                         }
2210 #line 432 "track.vala"
2211                         c = (ModelClip*) gee_iterator_get (_c_it);
2212 #line 433 "track.vala"
2213                         if (model_clip_get_start (c) > pos) {
2214 #line 2215 "track.c"
2215                                 result = model_clip_get_start (c);
2216                                 _g_object_unref0 (c);
2217                                 _g_object_unref0 (_c_it);
2218 #line 434 "track.vala"
2219                                 return result;
2220 #line 2221 "track.c"
2221                         } else {
2222 #line 435 "track.vala"
2223                                 if (model_clip_get_end (c) > pos) {
2224 #line 2225 "track.c"
2225                                         result = model_clip_get_end (c);
2226                                         _g_object_unref0 (c);
2227                                         _g_object_unref0 (_c_it);
2228 #line 436 "track.vala"
2229                                         return result;
2230 #line 2231 "track.c"
2231                                 }
2232                         }
2233                         _g_object_unref0 (c);
2234                 }
2235                 _g_object_unref0 (_c_it);
2236         }
2237         result = model_track_get_length (self);
2238 #line 437 "track.vala"
2239         return result;
2240 #line 2241 "track.c"
2241 }
2242
2243
2244 #line 440 "track.vala"
2245 static void model_track_real_write_attributes (ModelTrack* self, FILE* f) {
2246 #line 2247 "track.c"
2247         char* _tmp1_;
2248         char* _tmp0_;
2249 #line 440 "track.vala"
2250         g_return_if_fail (MODEL_IS_TRACK (self));
2251 #line 440 "track.vala"
2252         g_return_if_fail (f != NULL);
2253 #line 441 "track.vala"
2254         fprintf (f, "type=\"%s\" name=\"%s\" ", _tmp0_ = model_track_name (self), _tmp1_ = model_track_get_display_name (self));
2255 #line 2256 "track.c"
2256         _g_free0 (_tmp1_);
2257         _g_free0 (_tmp0_);
2258 }
2259
2260
2261 #line 440 "track.vala"
2262 void model_track_write_attributes (ModelTrack* self, FILE* f) {
2263 #line 440 "track.vala"
2264         MODEL_TRACK_GET_CLASS (self)->write_attributes (self, f);
2265 #line 2266 "track.c"
2266 }
2267
2268
2269 #line 444 "track.vala"
2270 void model_track_save (ModelTrack* self, FILE* f) {
2271 #line 444 "track.vala"
2272         g_return_if_fail (MODEL_IS_TRACK (self));
2273 #line 444 "track.vala"
2274         g_return_if_fail (f != NULL);
2275 #line 445 "track.vala"
2276         fprintf (f, "    <track ");
2277 #line 446 "track.vala"
2278         model_track_write_attributes (self, f);
2279 #line 447 "track.vala"
2280         fprintf (f, ">\n");
2281 #line 2282 "track.c"
2282         {
2283                 gint i;
2284 #line 448 "track.vala"
2285                 i = 0;
2286 #line 2287 "track.c"
2287                 {
2288                         gboolean _tmp0_;
2289 #line 448 "track.vala"
2290                         _tmp0_ = TRUE;
2291 #line 448 "track.vala"
2292                         while (TRUE) {
2293 #line 2294 "track.c"
2294                                 ModelClip* _tmp2_;
2295                                 ModelClip* _tmp1_;
2296 #line 448 "track.vala"
2297                                 if (!_tmp0_) {
2298 #line 448 "track.vala"
2299                                         i++;
2300 #line 2301 "track.c"
2301                                 }
2302 #line 448 "track.vala"
2303                                 _tmp0_ = FALSE;
2304 #line 448 "track.vala"
2305                                 if (!(i < gee_collection_get_size (GEE_COLLECTION (self->clips)))) {
2306 #line 448 "track.vala"
2307                                         break;
2308 #line 2309 "track.c"
2309                                 }
2310 #line 449 "track.vala"
2311                                 model_clip_save (_tmp1_ = (ModelClip*) gee_abstract_list_get (GEE_ABSTRACT_LIST (self->clips), i), f, model_project_get_clipfile_index (self->project, (_tmp2_ = (ModelClip*) gee_abstract_list_get (GEE_ABSTRACT_LIST (self->clips), i))->clipfile));
2312 #line 2313 "track.c"
2313                                 _g_object_unref0 (_tmp2_);
2314                                 _g_object_unref0 (_tmp1_);
2315                         }
2316                 }
2317         }
2318 #line 450 "track.vala"
2319         fputs ("    </track>\n", f);
2320 #line 2321 "track.c"
2321 }
2322
2323
2324 #line 453 "track.vala"
2325 char* model_track_get_display_name (ModelTrack* self) {
2326 #line 2327 "track.c"
2327         char* result = NULL;
2328 #line 453 "track.vala"
2329         g_return_val_if_fail (MODEL_IS_TRACK (self), NULL);
2330 #line 2331 "track.c"
2331         result = g_strdup (self->display_name);
2332 #line 454 "track.vala"
2333         return result;
2334 #line 2335 "track.c"
2335 }
2336
2337
2338 #line 457 "track.vala"
2339 void model_track_set_display_name (ModelTrack* self, const char* new_display_name) {
2340 #line 457 "track.vala"
2341         g_return_if_fail (MODEL_IS_TRACK (self));
2342 #line 457 "track.vala"
2343         g_return_if_fail (new_display_name != NULL);
2344 #line 458 "track.vala"
2345         if (_vala_strcmp0 (self->display_name, new_display_name) != 0) {
2346 #line 2347 "track.c"
2347                 char* _tmp0_;
2348 #line 459 "track.vala"
2349                 self->display_name = (_tmp0_ = g_strdup (new_display_name), _g_free0 (self->display_name), _tmp0_);
2350 #line 460 "track.vala"
2351                 g_signal_emit_by_name (self, "track-renamed", self);
2352 #line 2353 "track.c"
2353         }
2354 }
2355
2356
2357 #line 464 "track.vala"
2358 void model_track_set_selected (ModelTrack* self, gboolean is_selected) {
2359 #line 464 "track.vala"
2360         g_return_if_fail (MODEL_IS_TRACK (self));
2361 #line 465 "track.vala"
2362         if (self->priv->is_selected != is_selected) {
2363 #line 466 "track.vala"
2364                 self->priv->is_selected = is_selected;
2365 #line 467 "track.vala"
2366                 g_signal_emit_by_name (self, "track-selection-changed", self);
2367 #line 2368 "track.c"
2368         }
2369 }
2370
2371
2372 #line 471 "track.vala"
2373 gboolean model_track_get_is_selected (ModelTrack* self) {
2374 #line 2375 "track.c"
2375         gboolean result = FALSE;
2376 #line 471 "track.vala"
2377         g_return_val_if_fail (MODEL_IS_TRACK (self), FALSE);
2378 #line 2379 "track.c"
2379         result = self->priv->is_selected;
2380 #line 472 "track.vala"
2381         return result;
2382 #line 2383 "track.c"
2383 }
2384
2385
2386 static void model_track_class_init (ModelTrackClass * klass) {
2387         model_track_parent_class = g_type_class_peek_parent (klass);
2388         g_type_class_add_private (klass, sizeof (ModelTrackPrivate));
2389         MODEL_TRACK_CLASS (klass)->name = model_track_real_name;
2390         MODEL_TRACK_CLASS (klass)->media_type = model_track_real_media_type;
2391         MODEL_TRACK_CLASS (klass)->check = model_track_real_check;
2392         MODEL_TRACK_CLASS (klass)->on_clip_updated = model_track_real_on_clip_updated;
2393         MODEL_TRACK_CLASS (klass)->write_attributes = model_track_real_write_attributes;
2394         G_OBJECT_CLASS (klass)->finalize = model_track_finalize;
2395         g_signal_new ("clip_added", MODEL_TYPE_TRACK, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_user_marshal_VOID__OBJECT_BOOLEAN, G_TYPE_NONE, 2, MODEL_TYPE_CLIP, G_TYPE_BOOLEAN);
2396         g_signal_new ("clip_removed", MODEL_TYPE_TRACK, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__OBJECT, G_TYPE_NONE, 1, MODEL_TYPE_CLIP);
2397         g_signal_new ("track_renamed", MODEL_TYPE_TRACK, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__OBJECT, G_TYPE_NONE, 1, MODEL_TYPE_TRACK);
2398         g_signal_new ("track_selection_changed", MODEL_TYPE_TRACK, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__OBJECT, G_TYPE_NONE, 1, MODEL_TYPE_TRACK);
2399         g_signal_new ("track_hidden", MODEL_TYPE_TRACK, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__OBJECT, G_TYPE_NONE, 1, MODEL_TYPE_TRACK);
2400         g_signal_new ("track_removed", MODEL_TYPE_TRACK, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__OBJECT, G_TYPE_NONE, 1, MODEL_TYPE_TRACK);
2401         g_signal_new ("error_occurred", MODEL_TYPE_TRACK, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_user_marshal_VOID__STRING_STRING, G_TYPE_NONE, 2, G_TYPE_STRING, G_TYPE_STRING);
2402 }
2403
2404
2405 static void model_track_instance_init (ModelTrack * self) {
2406         self->priv = MODEL_TRACK_GET_PRIVATE (self);
2407         self->clips = gee_array_list_new (MODEL_TYPE_CLIP, (GBoxedCopyFunc) g_object_ref, g_object_unref, NULL);
2408 }
2409
2410
2411 static void model_track_finalize (GObject* obj) {
2412         ModelTrack * self;
2413         self = MODEL_TRACK (obj);
2414         _g_object_unref0 (self->clips);
2415         _g_free0 (self->display_name);
2416         G_OBJECT_CLASS (model_track_parent_class)->finalize (obj);
2417 }
2418
2419
2420 GType model_track_get_type (void) {
2421         static volatile gsize model_track_type_id__volatile = 0;
2422         if (g_once_init_enter (&model_track_type_id__volatile)) {
2423                 static const GTypeInfo g_define_type_info = { sizeof (ModelTrackClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) model_track_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ModelTrack), 0, (GInstanceInitFunc) model_track_instance_init, NULL };
2424                 GType model_track_type_id;
2425                 model_track_type_id = g_type_register_static (G_TYPE_OBJECT, "ModelTrack", &g_define_type_info, G_TYPE_FLAG_ABSTRACT);
2426                 g_once_init_leave (&model_track_type_id__volatile, model_track_type_id);
2427         }
2428         return model_track_type_id__volatile;
2429 }
2430
2431
2432 #line 487 "track.vala"
2433 ModelAudioTrack* model_audio_track_construct (GType object_type, ModelProject* project, const char* display_name) {
2434 #line 2435 "track.c"
2435         ModelAudioTrack * self;
2436 #line 487 "track.vala"
2437         g_return_val_if_fail (MODEL_IS_PROJECT (project), NULL);
2438 #line 487 "track.vala"
2439         g_return_val_if_fail (display_name != NULL, NULL);
2440 #line 488 "track.vala"
2441         self = (ModelAudioTrack*) model_track_construct (object_type, project, display_name);
2442 #line 490 "track.vala"
2443         model_audio_track_set_default_num_channels (self, MODEL_AUDIO_TRACK_INVALID_CHANNEL_COUNT);
2444 #line 491 "track.vala"
2445         _model_audio_track_set_pan (self, (double) 0);
2446 #line 492 "track.vala"
2447         _model_audio_track_set_volume (self, 1.0);
2448 #line 2449 "track.c"
2449         return self;
2450 }
2451
2452
2453 #line 487 "track.vala"
2454 ModelAudioTrack* model_audio_track_new (ModelProject* project, const char* display_name) {
2455 #line 487 "track.vala"
2456         return model_audio_track_construct (MODEL_TYPE_AUDIO_TRACK, project, display_name);
2457 #line 2458 "track.c"
2458 }
2459
2460
2461 #line 495 "track.vala"
2462 static char* model_audio_track_real_name (ModelTrack* base) {
2463 #line 2464 "track.c"
2464         ModelAudioTrack * self;
2465         char* result = NULL;
2466         self = MODEL_AUDIO_TRACK (base);
2467         result = g_strdup ("audio");
2468 #line 495 "track.vala"
2469         return result;
2470 #line 2471 "track.c"
2471 }
2472
2473
2474 #line 497 "track.vala"
2475 static ModelMediaType model_audio_track_real_media_type (ModelTrack* base) {
2476 #line 2477 "track.c"
2477         ModelAudioTrack * self;
2478         ModelMediaType result = 0;
2479         self = MODEL_AUDIO_TRACK (base);
2480         result = MODEL_MEDIA_TYPE_AUDIO;
2481 #line 498 "track.vala"
2482         return result;
2483 #line 2484 "track.c"
2484 }
2485
2486
2487 #line 501 "track.vala"
2488 static void model_audio_track_real_write_attributes (ModelTrack* base, FILE* f) {
2489 #line 2490 "track.c"
2490         ModelAudioTrack * self;
2491         gint channels = 0;
2492         gboolean _tmp0_ = FALSE;
2493         self = MODEL_AUDIO_TRACK (base);
2494 #line 501 "track.vala"
2495         g_return_if_fail (f != NULL);
2496 #line 502 "track.vala"
2497         MODEL_TRACK_CLASS (model_audio_track_parent_class)->write_attributes (MODEL_TRACK (self), f);
2498 #line 503 "track.vala"
2499         fprintf (f, "volume=\"%f\" panorama=\"%f\" ", model_audio_track_get_volume (self), model_audio_track_get_pan (self));
2500 #line 506 "track.vala"
2501         if (model_audio_track_get_num_channels (self, &channels)) {
2502 #line 507 "track.vala"
2503                 _tmp0_ = channels != MODEL_AUDIO_TRACK_INVALID_CHANNEL_COUNT;
2504 #line 2505 "track.c"
2505         } else {
2506 #line 506 "track.vala"
2507                 _tmp0_ = FALSE;
2508 #line 2509 "track.c"
2509         }
2510 #line 506 "track.vala"
2511         if (_tmp0_) {
2512 #line 508 "track.vala"
2513                 fprintf (f, "channels=\"%d\" ", channels);
2514 #line 2515 "track.c"
2515         }
2516 }
2517
2518
2519 #line 511 "track.vala"
2520 void model_audio_track_set_pan (ModelAudioTrack* self, double new_value) {
2521 #line 2522 "track.c"
2522         double old_value;
2523 #line 511 "track.vala"
2524         g_return_if_fail (MODEL_IS_AUDIO_TRACK (self));
2525 #line 512 "track.vala"
2526         old_value = model_audio_track_get_pan (self);
2527 #line 513 "track.vala"
2528         if (!float_within (new_value - old_value, 0.05)) {
2529 #line 2530 "track.c"
2530                 ModelParameterCommand* parameter_command;
2531 #line 515 "track.vala"
2532                 parameter_command = model_parameter_command_new (self, MODEL_PARAMETER_PAN, new_value, old_value);
2533 #line 516 "track.vala"
2534                 model_project_do_command (MODEL_TRACK (self)->project, MODEL_COMMAND (parameter_command));
2535 #line 2536 "track.c"
2536                 _model_command_unref0 (parameter_command);
2537         }
2538 }
2539
2540
2541 #line 520 "track.vala"
2542 void _model_audio_track_set_pan (ModelAudioTrack* self, double new_value) {
2543 #line 2544 "track.c"
2544         double old_value;
2545 #line 520 "track.vala"
2546         g_return_if_fail (MODEL_IS_AUDIO_TRACK (self));
2547 #line 521 "track.vala"
2548         g_assert ((new_value <= 1.0) && (new_value >= (-1.0)));
2549 #line 522 "track.vala"
2550         old_value = model_audio_track_get_pan (self);
2551 #line 523 "track.vala"
2552         if (!float_within (old_value - new_value, 0.05)) {
2553 #line 524 "track.vala"
2554                 self->priv->pan = new_value;
2555 #line 525 "track.vala"
2556                 g_signal_emit_by_name (self, "parameter-changed", MODEL_PARAMETER_PAN, new_value);
2557 #line 2558 "track.c"
2558         }
2559 }
2560
2561
2562 #line 529 "track.vala"
2563 double model_audio_track_get_pan (ModelAudioTrack* self) {
2564 #line 2565 "track.c"
2565         double result = 0.0;
2566 #line 529 "track.vala"
2567         g_return_val_if_fail (MODEL_IS_AUDIO_TRACK (self), 0.0);
2568 #line 2569 "track.c"
2569         result = self->priv->pan;
2570 #line 530 "track.vala"
2571         return result;
2572 #line 2573 "track.c"
2573 }
2574
2575
2576 #line 533 "track.vala"
2577 void model_audio_track_set_volume (ModelAudioTrack* self, double new_volume) {
2578 #line 2579 "track.c"
2579         double old_volume;
2580 #line 533 "track.vala"
2581         g_return_if_fail (MODEL_IS_AUDIO_TRACK (self));
2582 #line 534 "track.vala"
2583         old_volume = model_audio_track_get_volume (self);
2584 #line 535 "track.vala"
2585         if (!float_within (old_volume - new_volume, 0.005)) {
2586 #line 2587 "track.c"
2587                 ModelParameterCommand* parameter_command;
2588 #line 537 "track.vala"
2589                 parameter_command = model_parameter_command_new (self, MODEL_PARAMETER_VOLUME, new_volume, old_volume);
2590 #line 538 "track.vala"
2591                 model_project_do_command (MODEL_TRACK (self)->project, MODEL_COMMAND (parameter_command));
2592 #line 2593 "track.c"
2593                 _model_command_unref0 (parameter_command);
2594         }
2595 }
2596
2597
2598 #line 542 "track.vala"
2599 void _model_audio_track_set_volume (ModelAudioTrack* self, double new_volume) {
2600 #line 2601 "track.c"
2601         double old_volume;
2602 #line 542 "track.vala"
2603         g_return_if_fail (MODEL_IS_AUDIO_TRACK (self));
2604 #line 543 "track.vala"
2605         g_assert ((new_volume >= 0.0) && (new_volume <= 10.0));
2606 #line 544 "track.vala"
2607         old_volume = model_audio_track_get_volume (self);
2608 #line 545 "track.vala"
2609         if (!float_within (old_volume - new_volume, 0.005)) {
2610 #line 546 "track.vala"
2611                 self->priv->volume = new_volume;
2612 #line 547 "track.vala"
2613                 g_signal_emit_by_name (self, "parameter-changed", MODEL_PARAMETER_VOLUME, new_volume);
2614 #line 2615 "track.c"
2615         }
2616 }
2617
2618
2619 #line 551 "track.vala"
2620 double model_audio_track_get_volume (ModelAudioTrack* self) {
2621 #line 2622 "track.c"
2622         double result = 0.0;
2623 #line 551 "track.vala"
2624         g_return_val_if_fail (MODEL_IS_AUDIO_TRACK (self), 0.0);
2625 #line 2626 "track.c"
2626         result = self->priv->volume;
2627 #line 552 "track.vala"
2628         return result;
2629 #line 2630 "track.c"
2630 }
2631
2632
2633 #line 555 "track.vala"
2634 void model_audio_track_set_default_num_channels (ModelAudioTrack* self, gint num) {
2635 #line 555 "track.vala"
2636         g_return_if_fail (MODEL_IS_AUDIO_TRACK (self));
2637 #line 556 "track.vala"
2638         self->priv->default_num_channels = num;
2639 #line 2640 "track.c"
2640 }
2641
2642
2643 #line 559 "track.vala"
2644 gboolean model_audio_track_get_num_channels (ModelAudioTrack* self, gint* num) {
2645 #line 2646 "track.c"
2646         gboolean result = FALSE;
2647 #line 559 "track.vala"
2648         g_return_val_if_fail (MODEL_IS_AUDIO_TRACK (self), FALSE);
2649 #line 560 "track.vala"
2650         if (gee_collection_get_size (GEE_COLLECTION (MODEL_TRACK (self)->clips)) == 0) {
2651 #line 2652 "track.c"
2652                 result = FALSE;
2653 #line 561 "track.vala"
2654                 return result;
2655 #line 2656 "track.c"
2656         }
2657         {
2658                 GeeIterator* _c_it;
2659                 _c_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (MODEL_TRACK (self)->clips));
2660 #line 563 "track.vala"
2661                 while (TRUE) {
2662 #line 2663 "track.c"
2663                         ModelClip* c;
2664 #line 563 "track.vala"
2665                         if (!gee_iterator_next (_c_it)) {
2666 #line 563 "track.vala"
2667                                 break;
2668 #line 2669 "track.c"
2669                         }
2670 #line 563 "track.vala"
2671                         c = (ModelClip*) gee_iterator_get (_c_it);
2672 #line 564 "track.vala"
2673                         if (model_clip_file_is_online (c->clipfile)) {
2674 #line 2675 "track.c"
2675                                 gboolean can;
2676 #line 565 "track.vala"
2677                                 can = model_clip_file_get_num_channels (c->clipfile, num);
2678 #line 566 "track.vala"
2679                                 g_assert (can);
2680 #line 2681 "track.c"
2681                                 result = can;
2682                                 _g_object_unref0 (c);
2683                                 _g_object_unref0 (_c_it);
2684 #line 568 "track.vala"
2685                                 return result;
2686 #line 2687 "track.c"
2687                         }
2688                         _g_object_unref0 (c);
2689                 }
2690                 _g_object_unref0 (_c_it);
2691         }
2692 #line 572 "track.vala"
2693         if (self->priv->default_num_channels == MODEL_AUDIO_TRACK_INVALID_CHANNEL_COUNT) {
2694 #line 2695 "track.c"
2695                 result = FALSE;
2696 #line 573 "track.vala"
2697                 return result;
2698 #line 2699 "track.c"
2699         }
2700 #line 575 "track.vala"
2701         *num = self->priv->default_num_channels;
2702 #line 2703 "track.c"
2703         result = TRUE;
2704 #line 576 "track.vala"
2705         return result;
2706 #line 2707 "track.c"
2707 }
2708
2709
2710 #line 579 "track.vala"
2711 static gboolean model_audio_track_real_check (ModelTrack* base, ModelClip* clip) {
2712 #line 2713 "track.c"
2713         ModelAudioTrack * self;
2714         gboolean result = FALSE;
2715         gboolean good;
2716         gint number_of_channels = 0;
2717         self = MODEL_AUDIO_TRACK (base);
2718 #line 579 "track.vala"
2719         g_return_val_if_fail (MODEL_IS_CLIP (clip), FALSE);
2720 #line 580 "track.vala"
2721         if (!model_clip_file_is_online (clip->clipfile)) {
2722 #line 2723 "track.c"
2723                 result = TRUE;
2724 #line 581 "track.vala"
2725                 return result;
2726 #line 2727 "track.c"
2727         }
2728 #line 584 "track.vala"
2729         if (gee_collection_get_size (GEE_COLLECTION (MODEL_TRACK (self)->clips)) == 0) {
2730 #line 2731 "track.c"
2731                 gint number_of_channels;
2732 #line 585 "track.vala"
2733                 number_of_channels = 0;
2734 #line 586 "track.vala"
2735                 if (model_clip_file_get_num_channels (clip->clipfile, &number_of_channels)) {
2736 #line 587 "track.vala"
2737                         g_signal_emit_by_name (self, "channel-count-changed", number_of_channels);
2738 #line 2739 "track.c"
2739                 }
2740                 result = TRUE;
2741 #line 589 "track.vala"
2742                 return result;
2743 #line 2744 "track.c"
2744         }
2745 #line 592 "track.vala"
2746         good = FALSE;
2747 #line 594 "track.vala"
2748         if (model_clip_file_get_num_channels (clip->clipfile, &number_of_channels)) {
2749 #line 2750 "track.c"
2750                 gint track_channel_count = 0;
2751 #line 596 "track.vala"
2752                 if (model_audio_track_get_num_channels (self, &track_channel_count)) {
2753 #line 597 "track.vala"
2754                         good = track_channel_count == number_of_channels;
2755 #line 2756 "track.c"
2756                 }
2757         }
2758 #line 601 "track.vala"
2759         if (!good) {
2760 #line 2761 "track.c"
2761                 const char* _tmp0_;
2762                 char* sub_error;
2763                 _tmp0_ = NULL;
2764 #line 602 "track.vala"
2765                 if (number_of_channels == 1) {
2766 #line 603 "track.vala"
2767                         _tmp0_ = "Mono clips cannot go on stereo tracks.";
2768 #line 2769 "track.c"
2769                 } else {
2770 #line 604 "track.vala"
2771                         _tmp0_ = "Stereo clips cannot go on mono tracks.";
2772 #line 2773 "track.c"
2773                 }
2774 #line 602 "track.vala"
2775                 sub_error = g_strdup (_tmp0_);
2776 #line 605 "track.vala"
2777                 g_signal_emit_by_name (MODEL_TRACK (self), "error-occurred", "Cannot add clip to track", sub_error);
2778 #line 2779 "track.c"
2779                 _g_free0 (sub_error);
2780         }
2781         result = good;
2782 #line 607 "track.vala"
2783         return result;
2784 #line 2785 "track.c"
2785 }
2786
2787
2788 #line 610 "track.vala"
2789 void model_audio_track_on_level_changed (ModelAudioTrack* self, double level_left, double level_right) {
2790 #line 610 "track.vala"
2791         g_return_if_fail (MODEL_IS_AUDIO_TRACK (self));
2792 #line 611 "track.vala"
2793         logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_level_changed");
2794 #line 612 "track.vala"
2795         g_signal_emit_by_name (self, "level-changed", level_left, level_right);
2796 #line 2797 "track.c"
2797 }
2798
2799
2800 #line 615 "track.vala"
2801 static void model_audio_track_real_on_clip_updated (ModelTrack* base, ModelClip* clip) {
2802 #line 2803 "track.c"
2803         ModelAudioTrack * self;
2804         self = MODEL_AUDIO_TRACK (base);
2805 #line 615 "track.vala"
2806         g_return_if_fail (MODEL_IS_CLIP (clip));
2807 #line 616 "track.vala"
2808         if (model_clip_file_is_online (clip->clipfile)) {
2809 #line 2810 "track.c"
2810                 gint number_of_channels;
2811 #line 617 "track.vala"
2812                 number_of_channels = 0;
2813 #line 618 "track.vala"
2814                 if (model_audio_track_get_num_channels (self, &number_of_channels)) {
2815 #line 619 "track.vala"
2816                         g_signal_emit_by_name (self, "channel-count-changed", number_of_channels);
2817 #line 2818 "track.c"
2818                 }
2819         }
2820 }
2821
2822
2823 static void model_audio_track_class_init (ModelAudioTrackClass * klass) {
2824         model_audio_track_parent_class = g_type_class_peek_parent (klass);
2825         g_type_class_add_private (klass, sizeof (ModelAudioTrackPrivate));
2826         MODEL_TRACK_CLASS (klass)->name = model_audio_track_real_name;
2827         MODEL_TRACK_CLASS (klass)->media_type = model_audio_track_real_media_type;
2828         MODEL_TRACK_CLASS (klass)->write_attributes = model_audio_track_real_write_attributes;
2829         MODEL_TRACK_CLASS (klass)->check = model_audio_track_real_check;
2830         MODEL_TRACK_CLASS (klass)->on_clip_updated = model_audio_track_real_on_clip_updated;
2831         G_OBJECT_CLASS (klass)->finalize = model_audio_track_finalize;
2832         g_signal_new ("parameter_changed", MODEL_TYPE_AUDIO_TRACK, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_user_marshal_VOID__ENUM_DOUBLE, G_TYPE_NONE, 2, MODEL_TYPE_PARAMETER, G_TYPE_DOUBLE);
2833         g_signal_new ("level_changed", MODEL_TYPE_AUDIO_TRACK, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_user_marshal_VOID__DOUBLE_DOUBLE, G_TYPE_NONE, 2, G_TYPE_DOUBLE, G_TYPE_DOUBLE);
2834         g_signal_new ("channel_count_changed", MODEL_TYPE_AUDIO_TRACK, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__INT, G_TYPE_NONE, 1, G_TYPE_INT);
2835 }
2836
2837
2838 static void model_audio_track_instance_init (ModelAudioTrack * self) {
2839         self->priv = MODEL_AUDIO_TRACK_GET_PRIVATE (self);
2840 }
2841
2842
2843 static void model_audio_track_finalize (GObject* obj) {
2844         ModelAudioTrack * self;
2845         self = MODEL_AUDIO_TRACK (obj);
2846         G_OBJECT_CLASS (model_audio_track_parent_class)->finalize (obj);
2847 }
2848
2849
2850 GType model_audio_track_get_type (void) {
2851         static volatile gsize model_audio_track_type_id__volatile = 0;
2852         if (g_once_init_enter (&model_audio_track_type_id__volatile)) {
2853                 static const GTypeInfo g_define_type_info = { sizeof (ModelAudioTrackClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) model_audio_track_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ModelAudioTrack), 0, (GInstanceInitFunc) model_audio_track_instance_init, NULL };
2854                 GType model_audio_track_type_id;
2855                 model_audio_track_type_id = g_type_register_static (MODEL_TYPE_TRACK, "ModelAudioTrack", &g_define_type_info, 0);
2856                 g_once_init_leave (&model_audio_track_type_id__volatile, model_audio_track_type_id);
2857         }
2858         return model_audio_track_type_id__volatile;
2859 }
2860
2861
2862 static int _vala_strcmp0 (const char * str1, const char * str2) {
2863         if (str1 == NULL) {
2864                 return -(str1 != str2);
2865         }
2866         if (str2 == NULL) {
2867                 return str1 != str2;
2868         }
2869         return strcmp (str1, str2);
2870 }
2871
2872
2873
2874 static void g_cclosure_user_marshal_VOID__OBJECT_BOOLEAN (GClosure * closure, GValue * return_value, guint n_param_values, const GValue * param_values, gpointer invocation_hint, gpointer marshal_data) {
2875         typedef void (*GMarshalFunc_VOID__OBJECT_BOOLEAN) (gpointer data1, gpointer arg_1, gboolean arg_2, gpointer data2);
2876         register GMarshalFunc_VOID__OBJECT_BOOLEAN callback;
2877         register GCClosure * cc;
2878         register gpointer data1, data2;
2879         cc = (GCClosure *) closure;
2880         g_return_if_fail (n_param_values == 3);
2881         if (G_CCLOSURE_SWAP_DATA (closure)) {
2882                 data1 = closure->data;
2883                 data2 = param_values->data[0].v_pointer;
2884         } else {
2885                 data1 = param_values->data[0].v_pointer;
2886                 data2 = closure->data;
2887         }
2888         callback = (GMarshalFunc_VOID__OBJECT_BOOLEAN) (marshal_data ? marshal_data : cc->callback);
2889         callback (data1, g_value_get_object (param_values + 1), g_value_get_boolean (param_values + 2), data2);
2890 }
2891
2892
2893 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) {
2894         typedef void (*GMarshalFunc_VOID__STRING_STRING) (gpointer data1, const char* arg_1, const char* arg_2, gpointer data2);
2895         register GMarshalFunc_VOID__STRING_STRING callback;
2896         register GCClosure * cc;
2897         register gpointer data1, data2;
2898         cc = (GCClosure *) closure;
2899         g_return_if_fail (n_param_values == 3);
2900         if (G_CCLOSURE_SWAP_DATA (closure)) {
2901                 data1 = closure->data;
2902                 data2 = param_values->data[0].v_pointer;
2903         } else {
2904                 data1 = param_values->data[0].v_pointer;
2905                 data2 = closure->data;
2906         }
2907         callback = (GMarshalFunc_VOID__STRING_STRING) (marshal_data ? marshal_data : cc->callback);
2908         callback (data1, g_value_get_string (param_values + 1), g_value_get_string (param_values + 2), data2);
2909 }
2910
2911
2912 static void g_cclosure_user_marshal_VOID__ENUM_DOUBLE (GClosure * closure, GValue * return_value, guint n_param_values, const GValue * param_values, gpointer invocation_hint, gpointer marshal_data) {
2913         typedef void (*GMarshalFunc_VOID__ENUM_DOUBLE) (gpointer data1, gint arg_1, double arg_2, gpointer data2);
2914         register GMarshalFunc_VOID__ENUM_DOUBLE callback;
2915         register GCClosure * cc;
2916         register gpointer data1, data2;
2917         cc = (GCClosure *) closure;
2918         g_return_if_fail (n_param_values == 3);
2919         if (G_CCLOSURE_SWAP_DATA (closure)) {
2920                 data1 = closure->data;
2921                 data2 = param_values->data[0].v_pointer;
2922         } else {
2923                 data1 = param_values->data[0].v_pointer;
2924                 data2 = closure->data;
2925         }
2926         callback = (GMarshalFunc_VOID__ENUM_DOUBLE) (marshal_data ? marshal_data : cc->callback);
2927         callback (data1, g_value_get_enum (param_values + 1), g_value_get_double (param_values + 2), data2);
2928 }
2929
2930
2931 static void g_cclosure_user_marshal_VOID__DOUBLE_DOUBLE (GClosure * closure, GValue * return_value, guint n_param_values, const GValue * param_values, gpointer invocation_hint, gpointer marshal_data) {
2932         typedef void (*GMarshalFunc_VOID__DOUBLE_DOUBLE) (gpointer data1, double arg_1, double arg_2, gpointer data2);
2933         register GMarshalFunc_VOID__DOUBLE_DOUBLE callback;
2934         register GCClosure * cc;
2935         register gpointer data1, data2;
2936         cc = (GCClosure *) closure;
2937         g_return_if_fail (n_param_values == 3);
2938         if (G_CCLOSURE_SWAP_DATA (closure)) {
2939                 data1 = closure->data;
2940                 data2 = param_values->data[0].v_pointer;
2941         } else {
2942                 data1 = param_values->data[0].v_pointer;
2943                 data2 = closure->data;
2944         }
2945         callback = (GMarshalFunc_VOID__DOUBLE_DOUBLE) (marshal_data ? marshal_data : cc->callback);
2946         callback (data1, g_value_get_double (param_values + 1), g_value_get_double (param_values + 2), data2);
2947 }
2948
2949
2950