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

   1 /* command.c generated by valac, the Vala compiler
   2  * generated from command.vala, do not modify */
   3
   4 /* Copyright 2009 Yorba Foundation
   5  *
   6  * This software is licensed under the GNU Lesser General Public License
   7  * (version 2.1 or later).  See the COPYING file in this distribution.
   8  */
   9
  10 #include <glib.h>
  11 #include <glib-object.h>
  12 #include <stdlib.h>
  13 #include <string.h>
  14 #include <float.h>
  15 #include <math.h>
  16 #include <gdk/gdk.h>
  17 #include <gobject/gvaluecollector.h>
  18
  19
  20 #define MODEL_TYPE_COMMAND (model_command_get_type ())
  21 #define MODEL_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_COMMAND, ModelCommand))
  22 #define MODEL_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_COMMAND, ModelCommandClass))
  23 #define MODEL_IS_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_COMMAND))
  24 #define MODEL_IS_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_COMMAND))
  25 #define MODEL_COMMAND_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_COMMAND, ModelCommandClass))
  26
  27 typedef struct _ModelCommand ModelCommand;
  28 typedef struct _ModelCommandClass ModelCommandClass;
  29 typedef struct _ModelCommandPrivate ModelCommandPrivate;
  30 typedef struct _ModelParamSpecCommand ModelParamSpecCommand;
  31
  32 #define MODEL_TYPE_PARAMETER (model_parameter_get_type ())
  33
  34 #define MODEL_TYPE_PARAMETER_COMMAND (model_parameter_command_get_type ())
  35 #define MODEL_PARAMETER_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_PARAMETER_COMMAND, ModelParameterCommand))
  36 #define MODEL_PARAMETER_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_PARAMETER_COMMAND, ModelParameterCommandClass))
  37 #define MODEL_IS_PARAMETER_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_PARAMETER_COMMAND))
  38 #define MODEL_IS_PARAMETER_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_PARAMETER_COMMAND))
  39 #define MODEL_PARAMETER_COMMAND_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_PARAMETER_COMMAND, ModelParameterCommandClass))
  40
  41 typedef struct _ModelParameterCommand ModelParameterCommand;
  42 typedef struct _ModelParameterCommandClass ModelParameterCommandClass;
  43 typedef struct _ModelParameterCommandPrivate ModelParameterCommandPrivate;
  44
  45 #define MODEL_TYPE_TRACK (model_track_get_type ())
  46 #define MODEL_TRACK(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_TRACK, ModelTrack))
  47 #define MODEL_TRACK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_TRACK, ModelTrackClass))
  48 #define MODEL_IS_TRACK(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_TRACK))
  49 #define MODEL_IS_TRACK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_TRACK))
  50 #define MODEL_TRACK_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_TRACK, ModelTrackClass))
  51
  52 typedef struct _ModelTrack ModelTrack;
  53 typedef struct _ModelTrackClass ModelTrackClass;
  54
  55 #define MODEL_TYPE_AUDIO_TRACK (model_audio_track_get_type ())
  56 #define MODEL_AUDIO_TRACK(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_AUDIO_TRACK, ModelAudioTrack))
  57 #define MODEL_AUDIO_TRACK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_AUDIO_TRACK, ModelAudioTrackClass))
  58 #define MODEL_IS_AUDIO_TRACK(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_AUDIO_TRACK))
  59 #define MODEL_IS_AUDIO_TRACK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_AUDIO_TRACK))
  60 #define MODEL_AUDIO_TRACK_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_AUDIO_TRACK, ModelAudioTrackClass))
  61
  62 typedef struct _ModelAudioTrack ModelAudioTrack;
  63 typedef struct _ModelAudioTrackClass ModelAudioTrackClass;
  64 #define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
  65 #define _model_command_unref0(var) ((var == NULL) ? NULL : (var = (model_command_unref (var), NULL)))
  66
  67 #define MODEL_TYPE_CLIP_COMMAND (model_clip_command_get_type ())
  68 #define MODEL_CLIP_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_CLIP_COMMAND, ModelClipCommand))
  69 #define MODEL_CLIP_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_CLIP_COMMAND, ModelClipCommandClass))
  70 #define MODEL_IS_CLIP_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_CLIP_COMMAND))
  71 #define MODEL_IS_CLIP_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_CLIP_COMMAND))
  72 #define MODEL_CLIP_COMMAND_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_CLIP_COMMAND, ModelClipCommandClass))
  73
  74 typedef struct _ModelClipCommand ModelClipCommand;
  75 typedef struct _ModelClipCommandClass ModelClipCommandClass;
  76 typedef struct _ModelClipCommandPrivate ModelClipCommandPrivate;
  77
  78 #define MODEL_TYPE_CLIP (model_clip_get_type ())
  79 #define MODEL_CLIP(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_CLIP, ModelClip))
  80 #define MODEL_CLIP_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_CLIP, ModelClipClass))
  81 #define MODEL_IS_CLIP(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_CLIP))
  82 #define MODEL_IS_CLIP_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_CLIP))
  83 #define MODEL_CLIP_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_CLIP, ModelClipClass))
  84
  85 typedef struct _ModelClip ModelClip;
  86 typedef struct _ModelClipClass ModelClipClass;
  87
  88 #define MODEL_CLIP_COMMAND_TYPE_ACTION (model_clip_command_action_get_type ())
  89
  90 #define MODEL_TYPE_CLIP_ADD_COMMAND (model_clip_add_command_get_type ())
  91 #define MODEL_CLIP_ADD_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_CLIP_ADD_COMMAND, ModelClipAddCommand))
  92 #define MODEL_CLIP_ADD_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_CLIP_ADD_COMMAND, ModelClipAddCommandClass))
  93 #define MODEL_IS_CLIP_ADD_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_CLIP_ADD_COMMAND))
  94 #define MODEL_IS_CLIP_ADD_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_CLIP_ADD_COMMAND))
  95 #define MODEL_CLIP_ADD_COMMAND_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_CLIP_ADD_COMMAND, ModelClipAddCommandClass))
  96
  97 typedef struct _ModelClipAddCommand ModelClipAddCommand;
  98 typedef struct _ModelClipAddCommandClass ModelClipAddCommandClass;
  99 typedef struct _ModelClipAddCommandPrivate ModelClipAddCommandPrivate;
 100
 101 #define MODEL_TYPE_CLIP_SPLIT_COMMAND (model_clip_split_command_get_type ())
 102 #define MODEL_CLIP_SPLIT_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_CLIP_SPLIT_COMMAND, ModelClipSplitCommand))
 103 #define MODEL_CLIP_SPLIT_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_CLIP_SPLIT_COMMAND, ModelClipSplitCommandClass))
 104 #define MODEL_IS_CLIP_SPLIT_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_CLIP_SPLIT_COMMAND))
 105 #define MODEL_IS_CLIP_SPLIT_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_CLIP_SPLIT_COMMAND))
 106 #define MODEL_CLIP_SPLIT_COMMAND_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_CLIP_SPLIT_COMMAND, ModelClipSplitCommandClass))
 107
 108 typedef struct _ModelClipSplitCommand ModelClipSplitCommand;
 109 typedef struct _ModelClipSplitCommandClass ModelClipSplitCommandClass;
 110 typedef struct _ModelClipSplitCommandPrivate ModelClipSplitCommandPrivate;
 111
 112 #define MODEL_CLIP_SPLIT_COMMAND_TYPE_ACTION (model_clip_split_command_action_get_type ())
 113
 114 #define MODEL_TYPE_CLIP_FILE_DELETE_COMMAND (model_clip_file_delete_command_get_type ())
 115 #define MODEL_CLIP_FILE_DELETE_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_CLIP_FILE_DELETE_COMMAND, ModelClipFileDeleteCommand))
 116 #define MODEL_CLIP_FILE_DELETE_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_CLIP_FILE_DELETE_COMMAND, ModelClipFileDeleteCommandClass))
 117 #define MODEL_IS_CLIP_FILE_DELETE_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_CLIP_FILE_DELETE_COMMAND))
 118 #define MODEL_IS_CLIP_FILE_DELETE_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_CLIP_FILE_DELETE_COMMAND))
 119 #define MODEL_CLIP_FILE_DELETE_COMMAND_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_CLIP_FILE_DELETE_COMMAND, ModelClipFileDeleteCommandClass))
 120
 121 typedef struct _ModelClipFileDeleteCommand ModelClipFileDeleteCommand;
 122 typedef struct _ModelClipFileDeleteCommandClass ModelClipFileDeleteCommandClass;
 123 typedef struct _ModelClipFileDeleteCommandPrivate ModelClipFileDeleteCommandPrivate;
 124
 125 #define MODEL_TYPE_CLIP_FILE (model_clip_file_get_type ())
 126 #define MODEL_CLIP_FILE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_CLIP_FILE, ModelClipFile))
 127 #define MODEL_CLIP_FILE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_CLIP_FILE, ModelClipFileClass))
 128 #define MODEL_IS_CLIP_FILE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_CLIP_FILE))
 129 #define MODEL_IS_CLIP_FILE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_CLIP_FILE))
 130 #define MODEL_CLIP_FILE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_CLIP_FILE, ModelClipFileClass))
 131
 132 typedef struct _ModelClipFile ModelClipFile;
 133 typedef struct _ModelClipFileClass ModelClipFileClass;
 134
 135 #define MODEL_TYPE_PROJECT (model_project_get_type ())
 136 #define MODEL_PROJECT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_PROJECT, ModelProject))
 137 #define MODEL_PROJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_PROJECT, ModelProjectClass))
 138 #define MODEL_IS_PROJECT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_PROJECT))
 139 #define MODEL_IS_PROJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_PROJECT))
 140 #define MODEL_PROJECT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_PROJECT, ModelProjectClass))
 141
 142 typedef struct _ModelProject ModelProject;
 143 typedef struct _ModelProjectClass ModelProjectClass;
 144 #define _g_error_free0(var) ((var == NULL) ? NULL : (var = (g_error_free (var), NULL)))
 145
 146 #define MODEL_TYPE_CLIP_TRIM_COMMAND (model_clip_trim_command_get_type ())
 147 #define MODEL_CLIP_TRIM_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_CLIP_TRIM_COMMAND, ModelClipTrimCommand))
 148 #define MODEL_CLIP_TRIM_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_CLIP_TRIM_COMMAND, ModelClipTrimCommandClass))
 149 #define MODEL_IS_CLIP_TRIM_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_CLIP_TRIM_COMMAND))
 150 #define MODEL_IS_CLIP_TRIM_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_CLIP_TRIM_COMMAND))
 151 #define MODEL_CLIP_TRIM_COMMAND_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_CLIP_TRIM_COMMAND, ModelClipTrimCommandClass))
 152
 153 typedef struct _ModelClipTrimCommand ModelClipTrimCommand;
 154 typedef struct _ModelClipTrimCommandClass ModelClipTrimCommandClass;
 155 typedef struct _ModelClipTrimCommandPrivate ModelClipTrimCommandPrivate;
 156
 157 #define MODEL_TYPE_CLIP_REVERT_COMMAND (model_clip_revert_command_get_type ())
 158 #define MODEL_CLIP_REVERT_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_CLIP_REVERT_COMMAND, ModelClipRevertCommand))
 159 #define MODEL_CLIP_REVERT_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_CLIP_REVERT_COMMAND, ModelClipRevertCommandClass))
 160 #define MODEL_IS_CLIP_REVERT_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_CLIP_REVERT_COMMAND))
 161 #define MODEL_IS_CLIP_REVERT_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_CLIP_REVERT_COMMAND))
 162 #define MODEL_CLIP_REVERT_COMMAND_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_CLIP_REVERT_COMMAND, ModelClipRevertCommandClass))
 163
 164 typedef struct _ModelClipRevertCommand ModelClipRevertCommand;
 165 typedef struct _ModelClipRevertCommandClass ModelClipRevertCommandClass;
 166 typedef struct _ModelClipRevertCommandPrivate ModelClipRevertCommandPrivate;
 167
 168 #define MODEL_TYPE_TIME_SIGNATURE_COMMAND (model_time_signature_command_get_type ())
 169 #define MODEL_TIME_SIGNATURE_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_TIME_SIGNATURE_COMMAND, ModelTimeSignatureCommand))
 170 #define MODEL_TIME_SIGNATURE_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_TIME_SIGNATURE_COMMAND, ModelTimeSignatureCommandClass))
 171 #define MODEL_IS_TIME_SIGNATURE_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_TIME_SIGNATURE_COMMAND))
 172 #define MODEL_IS_TIME_SIGNATURE_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_TIME_SIGNATURE_COMMAND))
 173 #define MODEL_TIME_SIGNATURE_COMMAND_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_TIME_SIGNATURE_COMMAND, ModelTimeSignatureCommandClass))
 174
 175 typedef struct _ModelTimeSignatureCommand ModelTimeSignatureCommand;
 176 typedef struct _ModelTimeSignatureCommandClass ModelTimeSignatureCommandClass;
 177 typedef struct _ModelTimeSignatureCommandPrivate ModelTimeSignatureCommandPrivate;
 178
 179 #define TYPE_FRACTION (fraction_get_type ())
 180 typedef struct _Fraction Fraction;
 181
 182 #define MODEL_TYPE_TEMPO_INFORMATION (model_tempo_information_get_type ())
 183 #define MODEL_TEMPO_INFORMATION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_TEMPO_INFORMATION, ModelTempoInformation))
 184 #define MODEL_IS_TEMPO_INFORMATION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_TEMPO_INFORMATION))
 185 #define MODEL_TEMPO_INFORMATION_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), MODEL_TYPE_TEMPO_INFORMATION, ModelTempoInformationIface))
 186
 187 typedef struct _ModelTempoInformation ModelTempoInformation;
 188 typedef struct _ModelTempoInformationIface ModelTempoInformationIface;
 189
 190 #define MODEL_TYPE_BPM_COMMAND (model_bpm_command_get_type ())
 191 #define MODEL_BPM_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_BPM_COMMAND, ModelBpmCommand))
 192 #define MODEL_BPM_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_BPM_COMMAND, ModelBpmCommandClass))
 193 #define MODEL_IS_BPM_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_BPM_COMMAND))
 194 #define MODEL_IS_BPM_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_BPM_COMMAND))
 195 #define MODEL_BPM_COMMAND_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_BPM_COMMAND, ModelBpmCommandClass))
 196
 197 typedef struct _ModelBpmCommand ModelBpmCommand;
 198 typedef struct _ModelBpmCommandClass ModelBpmCommandClass;
 199 typedef struct _ModelBpmCommandPrivate ModelBpmCommandPrivate;
 200
 201 #define MODEL_TYPE_ADD_CLIP_COMMAND (model_add_clip_command_get_type ())
 202 #define MODEL_ADD_CLIP_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_ADD_CLIP_COMMAND, ModelAddClipCommand))
 203 #define MODEL_ADD_CLIP_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_ADD_CLIP_COMMAND, ModelAddClipCommandClass))
 204 #define MODEL_IS_ADD_CLIP_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_ADD_CLIP_COMMAND))
 205 #define MODEL_IS_ADD_CLIP_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_ADD_CLIP_COMMAND))
 206 #define MODEL_ADD_CLIP_COMMAND_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_ADD_CLIP_COMMAND, ModelAddClipCommandClass))
 207
 208 typedef struct _ModelAddClipCommand ModelAddClipCommand;
 209 typedef struct _ModelAddClipCommandClass ModelAddClipCommandClass;
 210 typedef struct _ModelAddClipCommandPrivate ModelAddClipCommandPrivate;
 211
 212 #define MODEL_TYPE_TRANSACTION_COMMAND (model_transaction_command_get_type ())
 213 #define MODEL_TRANSACTION_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_TRANSACTION_COMMAND, ModelTransactionCommand))
 214 #define MODEL_TRANSACTION_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_TRANSACTION_COMMAND, ModelTransactionCommandClass))
 215 #define MODEL_IS_TRANSACTION_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_TRANSACTION_COMMAND))
 216 #define MODEL_IS_TRANSACTION_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_TRANSACTION_COMMAND))
 217 #define MODEL_TRANSACTION_COMMAND_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_TRANSACTION_COMMAND, ModelTransactionCommandClass))
 218
 219 typedef struct _ModelTransactionCommand ModelTransactionCommand;
 220 typedef struct _ModelTransactionCommandClass ModelTransactionCommandClass;
 221 typedef struct _ModelTransactionCommandPrivate ModelTransactionCommandPrivate;
 222 #define _g_free0(var) (var = (g_free (var), NULL))
 223
 224 struct _ModelCommand {
 225         GTypeInstance parent_instance;
 226         volatile int ref_count;
 227         ModelCommandPrivate * priv;
 228 };
 229
 230 struct _ModelCommandClass {
 231         GTypeClass parent_class;
 232         void (*finalize) (ModelCommand *self);
 233         void (*apply) (ModelCommand* self);
 234         void (*undo) (ModelCommand* self);
 235         gboolean (*merge) (ModelCommand* self, ModelCommand* command);
 236         char* (*description) (ModelCommand* self);
 237 };
 238
 239 struct _ModelParamSpecCommand {
 240         GParamSpec parent_instance;
 241 };
 242
 243 typedef enum  {
 244         MODEL_PARAMETER_PAN,
 245         MODEL_PARAMETER_VOLUME
 246 } ModelParameter;
 247
 248 struct _ModelParameterCommand {
 249         ModelCommand parent_instance;
 250         ModelParameterCommandPrivate * priv;
 251 };
 252
 253 struct _ModelParameterCommandClass {
 254         ModelCommandClass parent_class;
 255 };
 256
 257 struct _ModelParameterCommandPrivate {
 258         ModelAudioTrack* target;
 259         ModelParameter parameter;
 260         double delta;
 261 };
 262
 263 struct _ModelClipCommand {
 264         ModelCommand parent_instance;
 265         ModelClipCommandPrivate * priv;
 266 };
 267
 268 struct _ModelClipCommandClass {
 269         ModelCommandClass parent_class;
 270 };
 271
 272 typedef enum  {
 273         MODEL_CLIP_COMMAND_ACTION_APPEND,
 274         MODEL_CLIP_COMMAND_ACTION_DELETE
 275 } ModelClipCommandAction;
 276
 277 struct _ModelClipCommandPrivate {
 278         ModelTrack* track;
 279         ModelClip* clip;
 280         gint64 time;
 281         ModelClipCommandAction action;
 282         gint index;
 283         gboolean select;
 284 };
 285
 286 struct _ModelClipAddCommand {
 287         ModelCommand parent_instance;
 288         ModelClipAddCommandPrivate * priv;
 289 };
 290
 291 struct _ModelClipAddCommandClass {
 292         ModelCommandClass parent_class;
 293 };
 294
 295 struct _ModelClipAddCommandPrivate {
 296         ModelTrack* track;
 297         ModelClip* clip;
 298         gint64 delta;
 299 };
 300
 301 struct _ModelClipSplitCommand {
 302         ModelCommand parent_instance;
 303         ModelClipSplitCommandPrivate * priv;
 304 };
 305
 306 struct _ModelClipSplitCommandClass {
 307         ModelCommandClass parent_class;
 308 };
 309
 310 struct _ModelClipSplitCommandPrivate {
 311         ModelTrack* track;
 312         gint64 time;
 313         gboolean do_split;
 314 };
 315
 316 typedef enum  {
 317         MODEL_CLIP_SPLIT_COMMAND_ACTION_SPLIT,
 318         MODEL_CLIP_SPLIT_COMMAND_ACTION_JOIN
 319 } ModelClipSplitCommandAction;
 320
 321 struct _ModelClipFileDeleteCommand {
 322         ModelCommand parent_instance;
 323         ModelClipFileDeleteCommandPrivate * priv;
 324 };
 325
 326 struct _ModelClipFileDeleteCommandClass {
 327         ModelCommandClass parent_class;
 328 };
 329
 330 struct _ModelClipFileDeleteCommandPrivate {
 331         ModelClipFile* clipfile;
 332         ModelProject* project;
 333 };
 334
 335 struct _ModelClipTrimCommand {
 336         ModelCommand parent_instance;
 337         ModelClipTrimCommandPrivate * priv;
 338 };
 339
 340 struct _ModelClipTrimCommandClass {
 341         ModelCommandClass parent_class;
 342 };
 343
 344 struct _ModelClipTrimCommandPrivate {
 345         ModelTrack* track;
 346         ModelClip* clip;
 347         gint64 delta;
 348         GdkWindowEdge edge;
 349 };
 350
 351 struct _ModelClipRevertCommand {
 352         ModelCommand parent_instance;
 353         ModelClipRevertCommandPrivate * priv;
 354 };
 355
 356 struct _ModelClipRevertCommandClass {
 357         ModelCommandClass parent_class;
 358 };
 359
 360 struct _ModelClipRevertCommandPrivate {
 361         ModelTrack* track;
 362         ModelClip* clip;
 363         gint64 left_delta;
 364         gint64 right_delta;
 365 };
 366
 367 struct _ModelTimeSignatureCommand {
 368         ModelCommand parent_instance;
 369         ModelTimeSignatureCommandPrivate * priv;
 370 };
 371
 372 struct _ModelTimeSignatureCommandClass {
 373         ModelCommandClass parent_class;
 374 };
 375
 376 struct _Fraction {
 377         gint numerator;
 378         gint denominator;
 379 };
 380
 381 struct _ModelTimeSignatureCommandPrivate {
 382         Fraction new_time_signature;
 383         Fraction old_time_signature;
 384         ModelProject* project;
 385 };
 386
 387 struct _ModelTempoInformationIface {
 388         GTypeInterface parent_iface;
 389         void (*get_time_signature) (ModelTempoInformation* self, Fraction* result);
 390         gint (*get_bpm) (ModelTempoInformation* self);
 391 };
 392
 393 struct _ModelBpmCommand {
 394         ModelCommand parent_instance;
 395         ModelBpmCommandPrivate * priv;
 396 };
 397
 398 struct _ModelBpmCommandClass {
 399         ModelCommandClass parent_class;
 400 };
 401
 402 struct _ModelBpmCommandPrivate {
 403         gint delta;
 404         ModelProject* project;
 405 };
 406
 407 struct _ModelAddClipCommand {
 408         ModelCommand parent_instance;
 409         ModelAddClipCommandPrivate * priv;
 410 };
 411
 412 struct _ModelAddClipCommandClass {
 413         ModelCommandClass parent_class;
 414 };
 415
 416 struct _ModelAddClipCommandPrivate {
 417         ModelClipFile* clip_file;
 418         ModelProject* project;
 419 };
 420
 421 struct _ModelTransactionCommand {
 422         ModelCommand parent_instance;
 423         ModelTransactionCommandPrivate * priv;
 424 };
 425
 426 struct _ModelTransactionCommandClass {
 427         ModelCommandClass parent_class;
 428 };
 429
 430 struct _ModelTransactionCommandPrivate {
 431         gboolean open;
 432         char* transaction_description;
 433 };
 434
 435
 436 static gpointer model_command_parent_class = NULL;
 437 static gpointer model_parameter_command_parent_class = NULL;
 438 static gpointer model_clip_command_parent_class = NULL;
 439 static gpointer model_clip_add_command_parent_class = NULL;
 440 static gpointer model_clip_split_command_parent_class = NULL;
 441 static gpointer model_clip_file_delete_command_parent_class = NULL;
 442 static gpointer model_clip_trim_command_parent_class = NULL;
 443 static gpointer model_clip_revert_command_parent_class = NULL;
 444 static gpointer model_time_signature_command_parent_class = NULL;
 445 static gpointer model_bpm_command_parent_class = NULL;
 446 static gpointer model_add_clip_command_parent_class = NULL;
 447 static gpointer model_transaction_command_parent_class = NULL;
 448
 449 gpointer model_command_ref (gpointer instance);
 450 void model_command_unref (gpointer instance);
 451 GParamSpec* model_param_spec_command (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);
 452 void model_value_set_command (GValue* value, gpointer v_object);
 453 void model_value_take_command (GValue* value, gpointer v_object);
 454 gpointer model_value_get_command (const GValue* value);
 455 GType model_command_get_type (void);
 456 enum  {
 457         MODEL_COMMAND_DUMMY_PROPERTY
 458 };
 459 void model_command_apply (ModelCommand* self);
 460 static void model_command_real_apply (ModelCommand* self);
 461 void model_command_undo (ModelCommand* self);
 462 static void model_command_real_undo (ModelCommand* self);
 463 gboolean model_command_merge (ModelCommand* self, ModelCommand* command);
 464 static gboolean model_command_real_merge (ModelCommand* self, ModelCommand* command);
 465 char* model_command_description (ModelCommand* self);
 466 static char* model_command_real_description (ModelCommand* self);
 467 ModelCommand* model_command_construct (GType object_type);
 468 static void model_command_finalize (ModelCommand* obj);
 469 GType model_parameter_get_type (void);
 470 GType model_parameter_command_get_type (void);
 471 GType model_track_get_type (void);
 472 GType model_audio_track_get_type (void);
 473 #define MODEL_PARAMETER_COMMAND_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), MODEL_TYPE_PARAMETER_COMMAND, ModelParameterCommandPrivate))
 474 enum  {
 475         MODEL_PARAMETER_COMMAND_DUMMY_PROPERTY
 476 };
 477 ModelParameterCommand* model_parameter_command_new (ModelAudioTrack* target, ModelParameter parameter, double new_value, double old_value);
 478 ModelParameterCommand* model_parameter_command_construct (GType object_type, ModelAudioTrack* target, ModelParameter parameter, double new_value, double old_value);
 479 void _model_audio_track_set_pan (ModelAudioTrack* self, double new_value);
 480 double model_audio_track_get_pan (ModelAudioTrack* self);
 481 void _model_audio_track_set_volume (ModelAudioTrack* self, double new_volume);
 482 double model_audio_track_get_volume (ModelAudioTrack* self);
 483 static void model_parameter_command_change_parameter (ModelParameterCommand* self, double amount);
 484 static void model_parameter_command_real_apply (ModelCommand* base);
 485 static void model_parameter_command_real_undo (ModelCommand* base);
 486 static gboolean model_parameter_command_real_merge (ModelCommand* base, ModelCommand* command);
 487 static char* model_parameter_command_real_description (ModelCommand* base);
 488 static void model_parameter_command_finalize (ModelCommand* obj);
 489 GType model_clip_command_get_type (void);
 490 GType model_clip_get_type (void);
 491 GType model_clip_command_action_get_type (void);
 492 #define MODEL_CLIP_COMMAND_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), MODEL_TYPE_CLIP_COMMAND, ModelClipCommandPrivate))
 493 enum  {
 494         MODEL_CLIP_COMMAND_DUMMY_PROPERTY
 495 };
 496 gint model_track_get_clip_index (ModelTrack* self, ModelClip* c);
 497 ModelClipCommand* model_clip_command_new (ModelClipCommandAction action, ModelTrack* track, ModelClip* clip, gint64 time, gboolean select);
 498 ModelClipCommand* model_clip_command_construct (GType object_type, ModelClipCommandAction action, ModelTrack* track, ModelClip* clip, gint64 time, gboolean select);
 499 void _model_track_append_at_time (ModelTrack* self, ModelClip* c, gint64 time, gboolean select);
 500 void _model_track_delete_clip (ModelTrack* self, ModelClip* clip);
 501 static void model_clip_command_real_apply (ModelCommand* base);
 502 void model_track_add (ModelTrack* self, ModelClip* c, gint64 pos, gboolean select);
 503 static void model_clip_command_real_undo (ModelCommand* base);
 504 static gboolean model_clip_command_real_merge (ModelCommand* base, ModelCommand* command);
 505 static char* model_clip_command_real_description (ModelCommand* base);
 506 static void model_clip_command_finalize (ModelCommand* obj);
 507 GType model_clip_add_command_get_type (void);
 508 #define MODEL_CLIP_ADD_COMMAND_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), MODEL_TYPE_CLIP_ADD_COMMAND, ModelClipAddCommandPrivate))
 509 enum  {
 510         MODEL_CLIP_ADD_COMMAND_DUMMY_PROPERTY
 511 };
 512 ModelClipAddCommand* model_clip_add_command_new (ModelTrack* track, ModelClip* clip, gint64 original_time, gint64 new_start);
 513 ModelClipAddCommand* model_clip_add_command_construct (GType object_type, ModelTrack* track, ModelClip* clip, gint64 original_time, gint64 new_start);
 514 void _model_track_move (ModelTrack* self, ModelClip* c, gint64 pos);
 515 gint64 model_clip_get_start (ModelClip* self);
 516 static void model_clip_add_command_real_apply (ModelCommand* base);
 517 void model_track_remove_clip_from_array (ModelTrack* self, ModelClip* pos);
 518 static void model_clip_add_command_real_undo (ModelCommand* base);
 519 static gboolean model_clip_add_command_real_merge (ModelCommand* base, ModelCommand* command);
 520 static char* model_clip_add_command_real_description (ModelCommand* base);
 521 static void model_clip_add_command_finalize (ModelCommand* obj);
 522 GType model_clip_split_command_get_type (void);
 523 #define MODEL_CLIP_SPLIT_COMMAND_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), MODEL_TYPE_CLIP_SPLIT_COMMAND, ModelClipSplitCommandPrivate))
 524 enum  {
 525         MODEL_CLIP_SPLIT_COMMAND_DUMMY_PROPERTY
 526 };
 527 GType model_clip_split_command_action_get_type (void);
 528 ModelClipSplitCommand* model_clip_split_command_new (ModelClipSplitCommandAction action, ModelTrack* track, gint64 time);
 529 ModelClipSplitCommand* model_clip_split_command_construct (GType object_type, ModelClipSplitCommandAction action, ModelTrack* track, gint64 time);
 530 void _model_track_split_at (ModelTrack* self, gint64 position);
 531 void _model_track_join (ModelTrack* self, gint64 position);
 532 static void model_clip_split_command_real_apply (ModelCommand* base);
 533 static void model_clip_split_command_real_undo (ModelCommand* base);
 534 static gboolean model_clip_split_command_real_merge (ModelCommand* base, ModelCommand* command);
 535 static char* model_clip_split_command_real_description (ModelCommand* base);
 536 static void model_clip_split_command_finalize (ModelCommand* obj);
 537 GType model_clip_file_delete_command_get_type (void);
 538 GType model_clip_file_get_type (void);
 539 GType model_project_get_type (void);
 540 #define MODEL_CLIP_FILE_DELETE_COMMAND_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), MODEL_TYPE_CLIP_FILE_DELETE_COMMAND, ModelClipFileDeleteCommandPrivate))
 541 enum  {
 542         MODEL_CLIP_FILE_DELETE_COMMAND_DUMMY_PROPERTY
 543 };
 544 ModelClipFileDeleteCommand* model_clip_file_delete_command_new (ModelProject* p, ModelClipFile* cf);
 545 ModelClipFileDeleteCommand* model_clip_file_delete_command_construct (GType object_type, ModelProject* p, ModelClipFile* cf);
 546 void _model_project_remove_clipfile (ModelProject* self, ModelClipFile* cf);
 547 static void model_clip_file_delete_command_real_apply (ModelCommand* base);
 548 void _model_project_add_clipfile (ModelProject* self, ModelClipFile* clipfile, GError** error);
 549 static void model_clip_file_delete_command_real_undo (ModelCommand* base);
 550 static gboolean model_clip_file_delete_command_real_merge (ModelCommand* base, ModelCommand* command);
 551 static char* model_clip_file_delete_command_real_description (ModelCommand* base);
 552 static void model_clip_file_delete_command_finalize (ModelCommand* obj);
 553 GType model_clip_trim_command_get_type (void);
 554 #define MODEL_CLIP_TRIM_COMMAND_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), MODEL_TYPE_CLIP_TRIM_COMMAND, ModelClipTrimCommandPrivate))
 555 enum  {
 556         MODEL_CLIP_TRIM_COMMAND_DUMMY_PROPERTY
 557 };
 558 ModelClipTrimCommand* model_clip_trim_command_new (ModelTrack* track, ModelClip* clip, gint64 delta, GdkWindowEdge edge);
 559 ModelClipTrimCommand* model_clip_trim_command_construct (GType object_type, ModelTrack* track, ModelClip* clip, gint64 delta, GdkWindowEdge edge);
 560 void _model_track_trim (ModelTrack* self, ModelClip* clip, gint64 delta, GdkWindowEdge edge);
 561 static void model_clip_trim_command_real_apply (ModelCommand* base);
 562 static void model_clip_trim_command_real_undo (ModelCommand* base);
 563 static gboolean model_clip_trim_command_real_merge (ModelCommand* base, ModelCommand* command);
 564 static char* model_clip_trim_command_real_description (ModelCommand* base);
 565 static void model_clip_trim_command_finalize (ModelCommand* obj);
 566 GType model_clip_revert_command_get_type (void);
 567 #define MODEL_CLIP_REVERT_COMMAND_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), MODEL_TYPE_CLIP_REVERT_COMMAND, ModelClipRevertCommandPrivate))
 568 enum  {
 569         MODEL_CLIP_REVERT_COMMAND_DUMMY_PROPERTY
 570 };
 571 ModelClipRevertCommand* model_clip_revert_command_new (ModelTrack* track, ModelClip* clip);
 572 ModelClipRevertCommand* model_clip_revert_command_construct (GType object_type, ModelTrack* track, ModelClip* clip);
 573 gint64 model_clip_get_end (ModelClip* self);
 574 gint64 model_clip_get_media_start (ModelClip* self);
 575 void _model_track_revert_to_original (ModelTrack* self, ModelClip* c);
 576 static void model_clip_revert_command_real_apply (ModelCommand* base);
 577 static void model_clip_revert_command_real_undo (ModelCommand* base);
 578 static gboolean model_clip_revert_command_real_merge (ModelCommand* base, ModelCommand* command);
 579 static char* model_clip_revert_command_real_description (ModelCommand* base);
 580 static void model_clip_revert_command_finalize (ModelCommand* obj);
 581 GType model_time_signature_command_get_type (void);
 582 GType fraction_get_type (void);
 583 Fraction* fraction_dup (const Fraction* self);
 584 void fraction_free (Fraction* self);
 585 #define MODEL_TIME_SIGNATURE_COMMAND_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), MODEL_TYPE_TIME_SIGNATURE_COMMAND, ModelTimeSignatureCommandPrivate))
 586 enum  {
 587         MODEL_TIME_SIGNATURE_COMMAND_DUMMY_PROPERTY
 588 };
 589 GType model_tempo_information_get_type (void);
 590 void model_tempo_information_get_time_signature (ModelTempoInformation* self, Fraction* result);
 591 ModelTimeSignatureCommand* model_time_signature_command_new (ModelProject* project, Fraction* new_time_signature);
 592 ModelTimeSignatureCommand* model_time_signature_command_construct (GType object_type, ModelProject* project, Fraction* new_time_signature);
 593 void _model_project_set_time_signature (ModelProject* self, Fraction* time_signature);
 594 static void model_time_signature_command_real_apply (ModelCommand* base);
 595 static void model_time_signature_command_real_undo (ModelCommand* base);
 596 static gboolean model_time_signature_command_real_merge (ModelCommand* base, ModelCommand* command);
 597 static char* model_time_signature_command_real_description (ModelCommand* base);
 598 static void model_time_signature_command_finalize (ModelCommand* obj);
 599 GType model_bpm_command_get_type (void);
 600 #define MODEL_BPM_COMMAND_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), MODEL_TYPE_BPM_COMMAND, ModelBpmCommandPrivate))
 601 enum  {
 602         MODEL_BPM_COMMAND_DUMMY_PROPERTY
 603 };
 604 gint model_tempo_information_get_bpm (ModelTempoInformation* self);
 605 ModelBpmCommand* model_bpm_command_new (ModelProject* project, gint new_bpm);
 606 ModelBpmCommand* model_bpm_command_construct (GType object_type, ModelProject* project, gint new_bpm);
 607 void _model_project_set_bpm (ModelProject* self, gint bpm);
 608 static void model_bpm_command_real_apply (ModelCommand* base);
 609 static void model_bpm_command_real_undo (ModelCommand* base);
 610 static gboolean model_bpm_command_real_merge (ModelCommand* base, ModelCommand* command);
 611 static char* model_bpm_command_real_description (ModelCommand* base);
 612 static void model_bpm_command_finalize (ModelCommand* obj);
 613 GType model_add_clip_command_get_type (void);
 614 #define MODEL_ADD_CLIP_COMMAND_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), MODEL_TYPE_ADD_CLIP_COMMAND, ModelAddClipCommandPrivate))
 615 enum  {
 616         MODEL_ADD_CLIP_COMMAND_DUMMY_PROPERTY
 617 };
 618 ModelAddClipCommand* model_add_clip_command_new (ModelProject* project, ModelClipFile* clip_file);
 619 ModelAddClipCommand* model_add_clip_command_construct (GType object_type, ModelProject* project, ModelClipFile* clip_file);
 620 static void model_add_clip_command_real_apply (ModelCommand* base);
 621 static void model_add_clip_command_real_undo (ModelCommand* base);
 622 static gboolean model_add_clip_command_real_merge (ModelCommand* base, ModelCommand* command);
 623 static char* model_add_clip_command_real_description (ModelCommand* base);
 624 static void model_add_clip_command_finalize (ModelCommand* obj);
 625 GType model_transaction_command_get_type (void);
 626 #define MODEL_TRANSACTION_COMMAND_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), MODEL_TYPE_TRANSACTION_COMMAND, ModelTransactionCommandPrivate))
 627 enum  {
 628         MODEL_TRANSACTION_COMMAND_DUMMY_PROPERTY
 629 };
 630 ModelTransactionCommand* model_transaction_command_new (gboolean open, const char* transaction_description);
 631 ModelTransactionCommand* model_transaction_command_construct (GType object_type, gboolean open, const char* transaction_description);
 632 gboolean model_transaction_command_in_transaction (ModelTransactionCommand* self);
 633 static void model_transaction_command_real_apply (ModelCommand* base);
 634 static void model_transaction_command_real_undo (ModelCommand* base);
 635 static gboolean model_transaction_command_real_merge (ModelCommand* base, ModelCommand* command);
 636 static char* model_transaction_command_real_description (ModelCommand* base);
 637 static void model_transaction_command_finalize (ModelCommand* obj);
 638
 639
 640
 641 #line 9 "command.vala"
 642 static void model_command_real_apply (ModelCommand* self) {
 643 #line 644 "command.c"
 644         g_return_if_fail (MODEL_IS_COMMAND (self));
 645         g_critical ("Type `%s' does not implement abstract method `model_command_apply'", g_type_name (G_TYPE_FROM_INSTANCE (self)));
 646         return;
 647 }
 648
 649
 650 #line 9 "command.vala"
 651 void model_command_apply (ModelCommand* self) {
 652 #line 9 "command.vala"
 653         MODEL_COMMAND_GET_CLASS (self)->apply (self);
 654 #line 655 "command.c"
 655 }
 656
 657
 658 #line 10 "command.vala"
 659 static void model_command_real_undo (ModelCommand* self) {
 660 #line 661 "command.c"
 661         g_return_if_fail (MODEL_IS_COMMAND (self));
 662         g_critical ("Type `%s' does not implement abstract method `model_command_undo'", g_type_name (G_TYPE_FROM_INSTANCE (self)));
 663         return;
 664 }
 665
 666
 667 #line 10 "command.vala"
 668 void model_command_undo (ModelCommand* self) {
 669 #line 10 "command.vala"
 670         MODEL_COMMAND_GET_CLASS (self)->undo (self);
 671 #line 672 "command.c"
 672 }
 673
 674
 675 #line 11 "command.vala"
 676 static gboolean model_command_real_merge (ModelCommand* self, ModelCommand* command) {
 677 #line 678 "command.c"
 678         g_return_val_if_fail (MODEL_IS_COMMAND (self), FALSE);
 679         g_critical ("Type `%s' does not implement abstract method `model_command_merge'", g_type_name (G_TYPE_FROM_INSTANCE (self)));
 680         return FALSE;
 681 }
 682
 683
 684 #line 11 "command.vala"
 685 gboolean model_command_merge (ModelCommand* self, ModelCommand* command) {
 686 #line 11 "command.vala"
 687         return MODEL_COMMAND_GET_CLASS (self)->merge (self, command);
 688 #line 689 "command.c"
 689 }
 690
 691
 692 #line 12 "command.vala"
 693 static char* model_command_real_description (ModelCommand* self) {
 694 #line 695 "command.c"
 695         g_return_val_if_fail (MODEL_IS_COMMAND (self), NULL);
 696         g_critical ("Type `%s' does not implement abstract method `model_command_description'", g_type_name (G_TYPE_FROM_INSTANCE (self)));
 697         return NULL;
 698 }
 699
 700
 701 #line 12 "command.vala"
 702 char* model_command_description (ModelCommand* self) {
 703 #line 12 "command.vala"
 704         return MODEL_COMMAND_GET_CLASS (self)->description (self);
 705 #line 706 "command.c"
 706 }
 707
 708
 709 #line 8 "command.vala"
 710 ModelCommand* model_command_construct (GType object_type) {
 711 #line 712 "command.c"
 712         ModelCommand* self;
 713         self = (ModelCommand*) g_type_create_instance (object_type);
 714         return self;
 715 }
 716
 717
 718 static void model_value_command_init (GValue* value) {
 719         value->data[0].v_pointer = NULL;
 720 }
 721
 722
 723 static void model_value_command_free_value (GValue* value) {
 724         if (value->data[0].v_pointer) {
 725                 model_command_unref (value->data[0].v_pointer);
 726         }
 727 }
 728
 729
 730 static void model_value_command_copy_value (const GValue* src_value, GValue* dest_value) {
 731         if (src_value->data[0].v_pointer) {
 732                 dest_value->data[0].v_pointer = model_command_ref (src_value->data[0].v_pointer);
 733         } else {
 734                 dest_value->data[0].v_pointer = NULL;
 735         }
 736 }
 737
 738
 739 static gpointer model_value_command_peek_pointer (const GValue* value) {
 740         return value->data[0].v_pointer;
 741 }
 742
 743
 744 static gchar* model_value_command_collect_value (GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {
 745         if (collect_values[0].v_pointer) {
 746                 ModelCommand* object;
 747                 object = collect_values[0].v_pointer;
 748                 if (object->parent_instance.g_class == NULL) {
 749                         return g_strconcat ("invalid unclassed object pointer for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
 750                 } else if (!g_value_type_compatible (G_TYPE_FROM_INSTANCE (object), G_VALUE_TYPE (value))) {
 751                         return g_strconcat ("invalid object type `", g_type_name (G_TYPE_FROM_INSTANCE (object)), "' for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
 752                 }
 753                 value->data[0].v_pointer = model_command_ref (object);
 754         } else {
 755                 value->data[0].v_pointer = NULL;
 756         }
 757         return NULL;
 758 }
 759
 760
 761 static gchar* model_value_command_lcopy_value (const GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {
 762         ModelCommand** object_p;
 763         object_p = collect_values[0].v_pointer;
 764         if (!object_p) {
 765                 return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
 766         }
 767         if (!value->data[0].v_pointer) {
 768                 *object_p = NULL;
 769         } else if (collect_flags && G_VALUE_NOCOPY_CONTENTS) {
 770                 *object_p = value->data[0].v_pointer;
 771         } else {
 772                 *object_p = model_command_ref (value->data[0].v_pointer);
 773         }
 774         return NULL;
 775 }
 776
 777
 778 GParamSpec* model_param_spec_command (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags) {
 779         ModelParamSpecCommand* spec;
 780         g_return_val_if_fail (g_type_is_a (object_type, MODEL_TYPE_COMMAND), NULL);
 781         spec = g_param_spec_internal (G_TYPE_PARAM_OBJECT, name, nick, blurb, flags);
 782         G_PARAM_SPEC (spec)->value_type = object_type;
 783         return G_PARAM_SPEC (spec);
 784 }
 785
 786
 787 gpointer model_value_get_command (const GValue* value) {
 788         g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, MODEL_TYPE_COMMAND), NULL);
 789         return value->data[0].v_pointer;
 790 }
 791
 792
 793 void model_value_set_command (GValue* value, gpointer v_object) {
 794         ModelCommand* old;
 795         g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, MODEL_TYPE_COMMAND));
 796         old = value->data[0].v_pointer;
 797         if (v_object) {
 798                 g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, MODEL_TYPE_COMMAND));
 799                 g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
 800                 value->data[0].v_pointer = v_object;
 801                 model_command_ref (value->data[0].v_pointer);
 802         } else {
 803                 value->data[0].v_pointer = NULL;
 804         }
 805         if (old) {
 806                 model_command_unref (old);
 807         }
 808 }
 809
 810
 811 void model_value_take_command (GValue* value, gpointer v_object) {
 812         ModelCommand* old;
 813         g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, MODEL_TYPE_COMMAND));
 814         old = value->data[0].v_pointer;
 815         if (v_object) {
 816                 g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, MODEL_TYPE_COMMAND));
 817                 g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
 818                 value->data[0].v_pointer = v_object;
 819         } else {
 820                 value->data[0].v_pointer = NULL;
 821         }
 822         if (old) {
 823                 model_command_unref (old);
 824         }
 825 }
 826
 827
 828 static void model_command_class_init (ModelCommandClass * klass) {
 829         model_command_parent_class = g_type_class_peek_parent (klass);
 830         MODEL_COMMAND_CLASS (klass)->finalize = model_command_finalize;
 831         MODEL_COMMAND_CLASS (klass)->apply = model_command_real_apply;
 832         MODEL_COMMAND_CLASS (klass)->undo = model_command_real_undo;
 833         MODEL_COMMAND_CLASS (klass)->merge = model_command_real_merge;
 834         MODEL_COMMAND_CLASS (klass)->description = model_command_real_description;
 835 }
 836
 837
 838 static void model_command_instance_init (ModelCommand * self) {
 839         self->ref_count = 1;
 840 }
 841
 842
 843 static void model_command_finalize (ModelCommand* obj) {
 844         ModelCommand * self;
 845         self = MODEL_COMMAND (obj);
 846 }
 847
 848
 849 GType model_command_get_type (void) {
 850         static volatile gsize model_command_type_id__volatile = 0;
 851         if (g_once_init_enter (&model_command_type_id__volatile)) {
 852                 static const GTypeValueTable g_define_type_value_table = { model_value_command_init, model_value_command_free_value, model_value_command_copy_value, model_value_command_peek_pointer, "p", model_value_command_collect_value, "p", model_value_command_lcopy_value };
 853                 static const GTypeInfo g_define_type_info = { sizeof (ModelCommandClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) model_command_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ModelCommand), 0, (GInstanceInitFunc) model_command_instance_init, &g_define_type_value_table };
 854                 static const GTypeFundamentalInfo g_define_type_fundamental_info = { (G_TYPE_FLAG_CLASSED | G_TYPE_FLAG_INSTANTIATABLE | G_TYPE_FLAG_DERIVABLE | G_TYPE_FLAG_DEEP_DERIVABLE) };
 855                 GType model_command_type_id;
 856                 model_command_type_id = g_type_register_fundamental (g_type_fundamental_next (), "ModelCommand", &g_define_type_info, &g_define_type_fundamental_info, G_TYPE_FLAG_ABSTRACT);
 857                 g_once_init_leave (&model_command_type_id__volatile, model_command_type_id);
 858         }
 859         return model_command_type_id__volatile;
 860 }
 861
 862
 863 gpointer model_command_ref (gpointer instance) {
 864         ModelCommand* self;
 865         self = instance;
 866         g_atomic_int_inc (&self->ref_count);
 867         return instance;
 868 }
 869
 870
 871 void model_command_unref (gpointer instance) {
 872         ModelCommand* self;
 873         self = instance;
 874         if (g_atomic_int_dec_and_test (&self->ref_count)) {
 875                 MODEL_COMMAND_GET_CLASS (self)->finalize (self);
 876                 g_type_free_instance ((GTypeInstance *) self);
 877         }
 878 }
 879
 880
 881 GType model_parameter_get_type (void) {
 882         static volatile gsize model_parameter_type_id__volatile = 0;
 883         if (g_once_init_enter (&model_parameter_type_id__volatile)) {
 884                 static const GEnumValue values[] = {{MODEL_PARAMETER_PAN, "MODEL_PARAMETER_PAN", "pan"}, {MODEL_PARAMETER_VOLUME, "MODEL_PARAMETER_VOLUME", "volume"}, {0, NULL, NULL}};
 885                 GType model_parameter_type_id;
 886                 model_parameter_type_id = g_enum_register_static ("ModelParameter", values);
 887                 g_once_init_leave (&model_parameter_type_id__volatile, model_parameter_type_id);
 888         }
 889         return model_parameter_type_id__volatile;
 890 }
 891
 892
 893 static gpointer _g_object_ref0 (gpointer self) {
 894         return self ? g_object_ref (self) : NULL;
 895 }
 896
 897
 898 #line 22 "command.vala"
 899 ModelParameterCommand* model_parameter_command_construct (GType object_type, ModelAudioTrack* target, ModelParameter parameter, double new_value, double old_value) {
 900 #line 901 "command.c"
 901         ModelParameterCommand* self;
 902         ModelAudioTrack* _tmp0_;
 903 #line 22 "command.vala"
 904         g_return_val_if_fail (MODEL_IS_AUDIO_TRACK (target), NULL);
 905 #line 22 "command.vala"
 906         self = (ModelParameterCommand*) model_command_construct (object_type);
 907 #line 24 "command.vala"
 908         self->priv->target = (_tmp0_ = _g_object_ref0 (target), _g_object_unref0 (self->priv->target), _tmp0_);
 909 #line 25 "command.vala"
 910         self->priv->parameter = parameter;
 911 #line 26 "command.vala"
 912         self->priv->delta = new_value - old_value;
 913 #line 914 "command.c"
 914         return self;
 915 }
 916
 917
 918 #line 22 "command.vala"
 919 ModelParameterCommand* model_parameter_command_new (ModelAudioTrack* target, ModelParameter parameter, double new_value, double old_value) {
 920 #line 22 "command.vala"
 921         return model_parameter_command_construct (MODEL_TYPE_PARAMETER_COMMAND, target, parameter, new_value, old_value);
 922 #line 923 "command.c"
 923 }
 924
 925
 926 #line 29 "command.vala"
 927 static void model_parameter_command_change_parameter (ModelParameterCommand* self, double amount) {
 928 #line 29 "command.vala"
 929         g_return_if_fail (MODEL_IS_PARAMETER_COMMAND (self));
 930 #line 30 "command.vala"
 931         switch (self->priv->parameter) {
 932 #line 933 "command.c"
 933                 case MODEL_PARAMETER_PAN:
 934                 {
 935 #line 32 "command.vala"
 936                         _model_audio_track_set_pan (self->priv->target, model_audio_track_get_pan (self->priv->target) + amount);
 937 #line 33 "command.vala"
 938                         break;
 939 #line 940 "command.c"
 940                 }
 941                 case MODEL_PARAMETER_VOLUME:
 942                 {
 943 #line 35 "command.vala"
 944                         _model_audio_track_set_volume (self->priv->target, model_audio_track_get_volume (self->priv->target) + amount);
 945 #line 36 "command.vala"
 946                         break;
 947 #line 948 "command.c"
 948                 }
 949         }
 950 }
 951
 952
 953 #line 40 "command.vala"
 954 static void model_parameter_command_real_apply (ModelCommand* base) {
 955 #line 956 "command.c"
 956         ModelParameterCommand * self;
 957         self = MODEL_PARAMETER_COMMAND (base);
 958 #line 41 "command.vala"
 959         model_parameter_command_change_parameter (self, self->priv->delta);
 960 #line 961 "command.c"
 961 }
 962
 963
 964 #line 44 "command.vala"
 965 static void model_parameter_command_real_undo (ModelCommand* base) {
 966 #line 967 "command.c"
 967         ModelParameterCommand * self;
 968         self = MODEL_PARAMETER_COMMAND (base);
 969 #line 45 "command.vala"
 970         model_parameter_command_change_parameter (self, -self->priv->delta);
 971 #line 972 "command.c"
 972 }
 973
 974
 975 static gpointer _model_command_ref0 (gpointer self) {
 976         return self ? model_command_ref (self) : NULL;
 977 }
 978
 979
 980 #line 48 "command.vala"
 981 static gboolean model_parameter_command_real_merge (ModelCommand* base, ModelCommand* command) {
 982 #line 983 "command.c"
 983         ModelParameterCommand * self;
 984         gboolean result = FALSE;
 985         ModelCommand* _tmp0_;
 986         ModelParameterCommand* parameter_command;
 987         gboolean _tmp1_ = FALSE;
 988         self = MODEL_PARAMETER_COMMAND (base);
 989 #line 48 "command.vala"
 990         g_return_val_if_fail (MODEL_IS_COMMAND (command), FALSE);
 991 #line 49 "command.vala"
 992         parameter_command = _model_command_ref0 ((_tmp0_ = command, MODEL_IS_PARAMETER_COMMAND (_tmp0_) ? ((ModelParameterCommand*) _tmp0_) : NULL));
 993 #line 50 "command.vala"
 994         if (parameter_command != NULL) {
 995 #line 50 "command.vala"
 996                 _tmp1_ = parameter_command->priv->parameter == self->priv->parameter;
 997 #line 998 "command.c"
 998         } else {
 999 #line 50 "command.vala"
1000                 _tmp1_ = FALSE;
1001 #line 1002 "command.c"
1002         }
1003 #line 50 "command.vala"
1004         if (_tmp1_) {
1005 #line 51 "command.vala"
1006                 self->priv->delta = self->priv->delta + parameter_command->priv->delta;
1007 #line 1008 "command.c"
1008                 result = TRUE;
1009                 _model_command_unref0 (parameter_command);
1010 #line 52 "command.vala"
1011                 return result;
1012 #line 1013 "command.c"
1013         }
1014         result = FALSE;
1015         _model_command_unref0 (parameter_command);
1016 #line 54 "command.vala"
1017         return result;
1018 #line 1019 "command.c"
1019 }
1020
1021
1022 #line 57 "command.vala"
1023 static char* model_parameter_command_real_description (ModelCommand* base) {
1024 #line 1025 "command.c"
1025         ModelParameterCommand * self;
1026         char* result = NULL;
1027         self = MODEL_PARAMETER_COMMAND (base);
1028 #line 58 "command.vala"
1029         switch (self->priv->parameter) {
1030 #line 1031 "command.c"
1031                 case MODEL_PARAMETER_PAN:
1032                 {
1033                         result = g_strdup ("Adjust Pan");
1034 #line 60 "command.vala"
1035                         return result;
1036 #line 1037 "command.c"
1037                 }
1038                 case MODEL_PARAMETER_VOLUME:
1039                 {
1040                         result = g_strdup ("Adjust Level");
1041 #line 62 "command.vala"
1042                         return result;
1043 #line 1044 "command.c"
1044                 }
1045                 default:
1046                 {
1047 #line 64 "command.vala"
1048                         g_assert (FALSE);
1049 #line 1050 "command.c"
1050                         result = g_strdup ("");
1051 #line 65 "command.vala"
1052                         return result;
1053 #line 1054 "command.c"
1054                 }
1055         }
1056 }
1057
1058
1059 static void model_parameter_command_class_init (ModelParameterCommandClass * klass) {
1060         model_parameter_command_parent_class = g_type_class_peek_parent (klass);
1061         MODEL_COMMAND_CLASS (klass)->finalize = model_parameter_command_finalize;
1062         g_type_class_add_private (klass, sizeof (ModelParameterCommandPrivate));
1063         MODEL_COMMAND_CLASS (klass)->apply = model_parameter_command_real_apply;
1064         MODEL_COMMAND_CLASS (klass)->undo = model_parameter_command_real_undo;
1065         MODEL_COMMAND_CLASS (klass)->merge = model_parameter_command_real_merge;
1066         MODEL_COMMAND_CLASS (klass)->description = model_parameter_command_real_description;
1067 }
1068
1069
1070 static void model_parameter_command_instance_init (ModelParameterCommand * self) {
1071         self->priv = MODEL_PARAMETER_COMMAND_GET_PRIVATE (self);
1072 }
1073
1074
1075 static void model_parameter_command_finalize (ModelCommand* obj) {
1076         ModelParameterCommand * self;
1077         self = MODEL_PARAMETER_COMMAND (obj);
1078         _g_object_unref0 (self->priv->target);
1079         MODEL_COMMAND_CLASS (model_parameter_command_parent_class)->finalize (obj);
1080 }
1081
1082
1083 GType model_parameter_command_get_type (void) {
1084         static volatile gsize model_parameter_command_type_id__volatile = 0;
1085         if (g_once_init_enter (&model_parameter_command_type_id__volatile)) {
1086                 static const GTypeInfo g_define_type_info = { sizeof (ModelParameterCommandClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) model_parameter_command_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ModelParameterCommand), 0, (GInstanceInitFunc) model_parameter_command_instance_init, NULL };
1087                 GType model_parameter_command_type_id;
1088                 model_parameter_command_type_id = g_type_register_static (MODEL_TYPE_COMMAND, "ModelParameterCommand", &g_define_type_info, 0);
1089                 g_once_init_leave (&model_parameter_command_type_id__volatile, model_parameter_command_type_id);
1090         }
1091         return model_parameter_command_type_id__volatile;
1092 }
1093
1094
1095 GType model_clip_command_action_get_type (void) {
1096         static volatile gsize model_clip_command_action_type_id__volatile = 0;
1097         if (g_once_init_enter (&model_clip_command_action_type_id__volatile)) {
1098                 static const GEnumValue values[] = {{MODEL_CLIP_COMMAND_ACTION_APPEND, "MODEL_CLIP_COMMAND_ACTION_APPEND", "append"}, {MODEL_CLIP_COMMAND_ACTION_DELETE, "MODEL_CLIP_COMMAND_ACTION_DELETE", "delete"}, {0, NULL, NULL}};
1099                 GType model_clip_command_action_type_id;
1100                 model_clip_command_action_type_id = g_enum_register_static ("ModelClipCommandAction", values);
1101                 g_once_init_leave (&model_clip_command_action_type_id__volatile, model_clip_command_action_type_id);
1102         }
1103         return model_clip_command_action_type_id__volatile;
1104 }
1105
1106
1107 #line 79 "command.vala"
1108 ModelClipCommand* model_clip_command_construct (GType object_type, ModelClipCommandAction action, ModelTrack* track, ModelClip* clip, gint64 time, gboolean select) {
1109 #line 1110 "command.c"
1110         ModelClipCommand* self;
1111         ModelTrack* _tmp0_;
1112         ModelClip* _tmp1_;
1113 #line 79 "command.vala"
1114         g_return_val_if_fail (MODEL_IS_TRACK (track), NULL);
1115 #line 79 "command.vala"
1116         g_return_val_if_fail (MODEL_IS_CLIP (clip), NULL);
1117 #line 79 "command.vala"
1118         self = (ModelClipCommand*) model_command_construct (object_type);
1119 #line 80 "command.vala"
1120         self->priv->track = (_tmp0_ = _g_object_ref0 (track), _g_object_unref0 (self->priv->track), _tmp0_);
1121 #line 81 "command.vala"
1122         self->priv->clip = (_tmp1_ = _g_object_ref0 (clip), _g_object_unref0 (self->priv->clip), _tmp1_);
1123 #line 82 "command.vala"
1124         self->priv->time = time;
1125 #line 83 "command.vala"
1126         self->priv->action = action;
1127 #line 84 "command.vala"
1128         self->priv->select = select;
1129 #line 85 "command.vala"
1130         self->priv->index = model_track_get_clip_index (track, clip);
1131 #line 1132 "command.c"
1132         return self;
1133 }
1134
1135
1136 #line 79 "command.vala"
1137 ModelClipCommand* model_clip_command_new (ModelClipCommandAction action, ModelTrack* track, ModelClip* clip, gint64 time, gboolean select) {
1138 #line 79 "command.vala"
1139         return model_clip_command_construct (MODEL_TYPE_CLIP_COMMAND, action, track, clip, time, select);
1140 #line 1141 "command.c"
1141 }
1142
1143
1144 #line 88 "command.vala"
1145 static void model_clip_command_real_apply (ModelCommand* base) {
1146 #line 1147 "command.c"
1147         ModelClipCommand * self;
1148         self = MODEL_CLIP_COMMAND (base);
1149 #line 89 "command.vala"
1150         switch (self->priv->action) {
1151 #line 1152 "command.c"
1152                 case MODEL_CLIP_COMMAND_ACTION_APPEND:
1153                 {
1154 #line 91 "command.vala"
1155                         _model_track_append_at_time (self->priv->track, self->priv->clip, self->priv->time, self->priv->select);
1156 #line 92 "command.vala"
1157                         break;
1158 #line 1159 "command.c"
1159                 }
1160                 case MODEL_CLIP_COMMAND_ACTION_DELETE:
1161                 {
1162 #line 94 "command.vala"
1163                         _model_track_delete_clip (self->priv->track, self->priv->clip);
1164 #line 95 "command.vala"
1165                         break;
1166 #line 1167 "command.c"
1167                 }
1168                 default:
1169                 {
1170 #line 97 "command.vala"
1171                         g_assert (FALSE);
1172 #line 98 "command.vala"
1173                         break;
1174 #line 1175 "command.c"
1175                 }
1176         }
1177 }
1178
1179
1180 #line 102 "command.vala"
1181 static void model_clip_command_real_undo (ModelCommand* base) {
1182 #line 1183 "command.c"
1183         ModelClipCommand * self;
1184         self = MODEL_CLIP_COMMAND (base);
1185 #line 103 "command.vala"
1186         switch (self->priv->action) {
1187 #line 1188 "command.c"
1188                 case MODEL_CLIP_COMMAND_ACTION_APPEND:
1189                 {
1190 #line 105 "command.vala"
1191                         _model_track_delete_clip (self->priv->track, self->priv->clip);
1192 #line 106 "command.vala"
1193                         break;
1194 #line 1195 "command.c"
1195                 }
1196                 case MODEL_CLIP_COMMAND_ACTION_DELETE:
1197                 {
1198 #line 108 "command.vala"
1199                         model_track_add (self->priv->track, self->priv->clip, self->priv->time, FALSE);
1200 #line 109 "command.vala"
1201                         break;
1202 #line 1203 "command.c"
1203                 }
1204                 default:
1205                 {
1206 #line 111 "command.vala"
1207                         g_assert (FALSE);
1208 #line 112 "command.vala"
1209                         break;
1210 #line 1211 "command.c"
1211                 }
1212         }
1213 }
1214
1215
1216 #line 116 "command.vala"
1217 static gboolean model_clip_command_real_merge (ModelCommand* base, ModelCommand* command) {
1218 #line 1219 "command.c"
1219         ModelClipCommand * self;
1220         gboolean result = FALSE;
1221         self = MODEL_CLIP_COMMAND (base);
1222 #line 116 "command.vala"
1223         g_return_val_if_fail (MODEL_IS_COMMAND (command), FALSE);
1224 #line 1225 "command.c"
1225         result = FALSE;
1226 #line 117 "command.vala"
1227         return result;
1228 #line 1229 "command.c"
1229 }
1230
1231
1232 #line 120 "command.vala"
1233 static char* model_clip_command_real_description (ModelCommand* base) {
1234 #line 1235 "command.c"
1235         ModelClipCommand * self;
1236         char* result = NULL;
1237         self = MODEL_CLIP_COMMAND (base);
1238 #line 121 "command.vala"
1239         switch (self->priv->action) {
1240 #line 1241 "command.c"
1241                 case MODEL_CLIP_COMMAND_ACTION_APPEND:
1242                 {
1243                         result = g_strdup ("Create Clip");
1244 #line 123 "command.vala"
1245                         return result;
1246 #line 1247 "command.c"
1247                 }
1248                 case MODEL_CLIP_COMMAND_ACTION_DELETE:
1249                 {
1250                         result = g_strdup ("Delete Clip");
1251 #line 125 "command.vala"
1252                         return result;
1253 #line 1254 "command.c"
1254                 }
1255                 default:
1256                 {
1257 #line 127 "command.vala"
1258                         g_assert (FALSE);
1259 #line 1260 "command.c"
1260                         result = g_strdup ("");
1261 #line 128 "command.vala"
1262                         return result;
1263 #line 1264 "command.c"
1264                 }
1265         }
1266 }
1267
1268
1269 static void model_clip_command_class_init (ModelClipCommandClass * klass) {
1270         model_clip_command_parent_class = g_type_class_peek_parent (klass);
1271         MODEL_COMMAND_CLASS (klass)->finalize = model_clip_command_finalize;
1272         g_type_class_add_private (klass, sizeof (ModelClipCommandPrivate));
1273         MODEL_COMMAND_CLASS (klass)->apply = model_clip_command_real_apply;
1274         MODEL_COMMAND_CLASS (klass)->undo = model_clip_command_real_undo;
1275         MODEL_COMMAND_CLASS (klass)->merge = model_clip_command_real_merge;
1276         MODEL_COMMAND_CLASS (klass)->description = model_clip_command_real_description;
1277 }
1278
1279
1280 static void model_clip_command_instance_init (ModelClipCommand * self) {
1281         self->priv = MODEL_CLIP_COMMAND_GET_PRIVATE (self);
1282 }
1283
1284
1285 static void model_clip_command_finalize (ModelCommand* obj) {
1286         ModelClipCommand * self;
1287         self = MODEL_CLIP_COMMAND (obj);
1288         _g_object_unref0 (self->priv->track);
1289         _g_object_unref0 (self->priv->clip);
1290         MODEL_COMMAND_CLASS (model_clip_command_parent_class)->finalize (obj);
1291 }
1292
1293
1294 GType model_clip_command_get_type (void) {
1295         static volatile gsize model_clip_command_type_id__volatile = 0;
1296         if (g_once_init_enter (&model_clip_command_type_id__volatile)) {
1297                 static const GTypeInfo g_define_type_info = { sizeof (ModelClipCommandClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) model_clip_command_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ModelClipCommand), 0, (GInstanceInitFunc) model_clip_command_instance_init, NULL };
1298                 GType model_clip_command_type_id;
1299                 model_clip_command_type_id = g_type_register_static (MODEL_TYPE_COMMAND, "ModelClipCommand", &g_define_type_info, 0);
1300                 g_once_init_leave (&model_clip_command_type_id__volatile, model_clip_command_type_id);
1301         }
1302         return model_clip_command_type_id__volatile;
1303 }
1304
1305
1306 #line 138 "command.vala"
1307 ModelClipAddCommand* model_clip_add_command_construct (GType object_type, ModelTrack* track, ModelClip* clip, gint64 original_time, gint64 new_start) {
1308 #line 1309 "command.c"
1309         ModelClipAddCommand* self;
1310         ModelTrack* _tmp0_;
1311         ModelClip* _tmp1_;
1312 #line 138 "command.vala"
1313         g_return_val_if_fail (MODEL_IS_TRACK (track), NULL);
1314 #line 138 "command.vala"
1315         g_return_val_if_fail (MODEL_IS_CLIP (clip), NULL);
1316 #line 138 "command.vala"
1317         self = (ModelClipAddCommand*) model_command_construct (object_type);
1318 #line 140 "command.vala"
1319         self->priv->track = (_tmp0_ = _g_object_ref0 (track), _g_object_unref0 (self->priv->track), _tmp0_);
1320 #line 141 "command.vala"
1321         self->priv->clip = (_tmp1_ = _g_object_ref0 (clip), _g_object_unref0 (self->priv->clip), _tmp1_);
1322 #line 142 "command.vala"
1323         self->priv->delta = new_start - original_time;
1324 #line 1325 "command.c"
1325         return self;
1326 }
1327
1328
1329 #line 138 "command.vala"
1330 ModelClipAddCommand* model_clip_add_command_new (ModelTrack* track, ModelClip* clip, gint64 original_time, gint64 new_start) {
1331 #line 138 "command.vala"
1332         return model_clip_add_command_construct (MODEL_TYPE_CLIP_ADD_COMMAND, track, clip, original_time, new_start);
1333 #line 1334 "command.c"
1334 }
1335
1336
1337 #line 145 "command.vala"
1338 static void model_clip_add_command_real_apply (ModelCommand* base) {
1339 #line 1340 "command.c"
1340         ModelClipAddCommand * self;
1341         self = MODEL_CLIP_ADD_COMMAND (base);
1342 #line 146 "command.vala"
1343         _model_track_move (self->priv->track, self->priv->clip, model_clip_get_start (self->priv->clip));
1344 #line 1345 "command.c"
1345 }
1346
1347
1348 #line 149 "command.vala"
1349 static void model_clip_add_command_real_undo (ModelCommand* base) {
1350 #line 1351 "command.c"
1351         ModelClipAddCommand * self;
1352         self = MODEL_CLIP_ADD_COMMAND (base);
1353 #line 150 "command.vala"
1354         model_track_remove_clip_from_array (self->priv->track, self->priv->clip);
1355 #line 151 "command.vala"
1356         _model_track_move (self->priv->track, self->priv->clip, model_clip_get_start (self->priv->clip) - self->priv->delta);
1357 #line 1358 "command.c"
1358 }
1359
1360
1361 #line 154 "command.vala"
1362 static gboolean model_clip_add_command_real_merge (ModelCommand* base, ModelCommand* command) {
1363 #line 1364 "command.c"
1364         ModelClipAddCommand * self;
1365         gboolean result = FALSE;
1366         self = MODEL_CLIP_ADD_COMMAND (base);
1367 #line 154 "command.vala"
1368         g_return_val_if_fail (MODEL_IS_COMMAND (command), FALSE);
1369 #line 1370 "command.c"
1370         result = FALSE;
1371 #line 155 "command.vala"
1372         return result;
1373 #line 1374 "command.c"
1374 }
1375
1376
1377 #line 158 "command.vala"
1378 static char* model_clip_add_command_real_description (ModelCommand* base) {
1379 #line 1380 "command.c"
1380         ModelClipAddCommand * self;
1381         char* result = NULL;
1382         self = MODEL_CLIP_ADD_COMMAND (base);
1383         result = g_strdup ("Move Clip");
1384 #line 159 "command.vala"
1385         return result;
1386 #line 1387 "command.c"
1387 }
1388
1389
1390 static void model_clip_add_command_class_init (ModelClipAddCommandClass * klass) {
1391         model_clip_add_command_parent_class = g_type_class_peek_parent (klass);
1392         MODEL_COMMAND_CLASS (klass)->finalize = model_clip_add_command_finalize;
1393         g_type_class_add_private (klass, sizeof (ModelClipAddCommandPrivate));
1394         MODEL_COMMAND_CLASS (klass)->apply = model_clip_add_command_real_apply;
1395         MODEL_COMMAND_CLASS (klass)->undo = model_clip_add_command_real_undo;
1396         MODEL_COMMAND_CLASS (klass)->merge = model_clip_add_command_real_merge;
1397         MODEL_COMMAND_CLASS (klass)->description = model_clip_add_command_real_description;
1398 }
1399
1400
1401 static void model_clip_add_command_instance_init (ModelClipAddCommand * self) {
1402         self->priv = MODEL_CLIP_ADD_COMMAND_GET_PRIVATE (self);
1403 }
1404
1405
1406 static void model_clip_add_command_finalize (ModelCommand* obj) {
1407         ModelClipAddCommand * self;
1408         self = MODEL_CLIP_ADD_COMMAND (obj);
1409         _g_object_unref0 (self->priv->track);
1410         _g_object_unref0 (self->priv->clip);
1411         MODEL_COMMAND_CLASS (model_clip_add_command_parent_class)->finalize (obj);
1412 }
1413
1414
1415 GType model_clip_add_command_get_type (void) {
1416         static volatile gsize model_clip_add_command_type_id__volatile = 0;
1417         if (g_once_init_enter (&model_clip_add_command_type_id__volatile)) {
1418                 static const GTypeInfo g_define_type_info = { sizeof (ModelClipAddCommandClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) model_clip_add_command_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ModelClipAddCommand), 0, (GInstanceInitFunc) model_clip_add_command_instance_init, NULL };
1419                 GType model_clip_add_command_type_id;
1420                 model_clip_add_command_type_id = g_type_register_static (MODEL_TYPE_COMMAND, "ModelClipAddCommand", &g_define_type_info, 0);
1421                 g_once_init_leave (&model_clip_add_command_type_id__volatile, model_clip_add_command_type_id);
1422         }
1423         return model_clip_add_command_type_id__volatile;
1424 }
1425
1426
1427 GType model_clip_split_command_action_get_type (void) {
1428         static volatile gsize model_clip_split_command_action_type_id__volatile = 0;
1429         if (g_once_init_enter (&model_clip_split_command_action_type_id__volatile)) {
1430                 static const GEnumValue values[] = {{MODEL_CLIP_SPLIT_COMMAND_ACTION_SPLIT, "MODEL_CLIP_SPLIT_COMMAND_ACTION_SPLIT", "split"}, {MODEL_CLIP_SPLIT_COMMAND_ACTION_JOIN, "MODEL_CLIP_SPLIT_COMMAND_ACTION_JOIN", "join"}, {0, NULL, NULL}};
1431                 GType model_clip_split_command_action_type_id;
1432                 model_clip_split_command_action_type_id = g_enum_register_static ("ModelClipSplitCommandAction", values);
1433                 g_once_init_leave (&model_clip_split_command_action_type_id__volatile, model_clip_split_command_action_type_id);
1434         }
1435         return model_clip_split_command_action_type_id__volatile;
1436 }
1437
1438
1439 #line 170 "command.vala"
1440 ModelClipSplitCommand* model_clip_split_command_construct (GType object_type, ModelClipSplitCommandAction action, ModelTrack* track, gint64 time) {
1441 #line 1442 "command.c"
1442         ModelClipSplitCommand* self;
1443         ModelTrack* _tmp0_;
1444 #line 170 "command.vala"
1445         g_return_val_if_fail (MODEL_IS_TRACK (track), NULL);
1446 #line 170 "command.vala"
1447         self = (ModelClipSplitCommand*) model_command_construct (object_type);
1448 #line 171 "command.vala"
1449         self->priv->track = (_tmp0_ = _g_object_ref0 (track), _g_object_unref0 (self->priv->track), _tmp0_);
1450 #line 172 "command.vala"
1451         self->priv->time = time;
1452 #line 173 "command.vala"
1453         self->priv->do_split = action == MODEL_CLIP_SPLIT_COMMAND_ACTION_SPLIT;
1454 #line 1455 "command.c"
1455         return self;
1456 }
1457
1458
1459 #line 170 "command.vala"
1460 ModelClipSplitCommand* model_clip_split_command_new (ModelClipSplitCommandAction action, ModelTrack* track, gint64 time) {
1461 #line 170 "command.vala"
1462         return model_clip_split_command_construct (MODEL_TYPE_CLIP_SPLIT_COMMAND, action, track, time);
1463 #line 1464 "command.c"
1464 }
1465
1466
1467 #line 176 "command.vala"
1468 static void model_clip_split_command_real_apply (ModelCommand* base) {
1469 #line 1470 "command.c"
1470         ModelClipSplitCommand * self;
1471         self = MODEL_CLIP_SPLIT_COMMAND (base);
1472 #line 177 "command.vala"
1473         if (self->priv->do_split) {
1474 #line 178 "command.vala"
1475                 _model_track_split_at (self->priv->track, self->priv->time);
1476 #line 1477 "command.c"
1477         } else {
1478 #line 180 "command.vala"
1479                 _model_track_join (self->priv->track, self->priv->time);
1480 #line 1481 "command.c"
1481         }
1482 }
1483
1484
1485 #line 184 "command.vala"
1486 static void model_clip_split_command_real_undo (ModelCommand* base) {
1487 #line 1488 "command.c"
1488         ModelClipSplitCommand * self;
1489         self = MODEL_CLIP_SPLIT_COMMAND (base);
1490 #line 185 "command.vala"
1491         if (self->priv->do_split) {
1492 #line 186 "command.vala"
1493                 _model_track_join (self->priv->track, self->priv->time);
1494 #line 1495 "command.c"
1495         } else {
1496 #line 188 "command.vala"
1497                 _model_track_split_at (self->priv->track, self->priv->time);
1498 #line 1499 "command.c"
1499         }
1500 }
1501
1502
1503 #line 192 "command.vala"
1504 static gboolean model_clip_split_command_real_merge (ModelCommand* base, ModelCommand* command) {
1505 #line 1506 "command.c"
1506         ModelClipSplitCommand * self;
1507         gboolean result = FALSE;
1508         self = MODEL_CLIP_SPLIT_COMMAND (base);
1509 #line 192 "command.vala"
1510         g_return_val_if_fail (MODEL_IS_COMMAND (command), FALSE);
1511 #line 1512 "command.c"
1512         result = FALSE;
1513 #line 193 "command.vala"
1514         return result;
1515 #line 1516 "command.c"
1516 }
1517
1518
1519 #line 196 "command.vala"
1520 static char* model_clip_split_command_real_description (ModelCommand* base) {
1521 #line 1522 "command.c"
1522         ModelClipSplitCommand * self;
1523         char* result = NULL;
1524         self = MODEL_CLIP_SPLIT_COMMAND (base);
1525 #line 197 "command.vala"
1526         if (self->priv->do_split) {
1527 #line 1528 "command.c"
1528                 result = g_strdup ("Split Clip");
1529 #line 198 "command.vala"
1530                 return result;
1531 #line 1532 "command.c"
1532         } else {
1533                 result = g_strdup ("Join Clip");
1534 #line 200 "command.vala"
1535                 return result;
1536 #line 1537 "command.c"
1537         }
1538 }
1539
1540
1541 static void model_clip_split_command_class_init (ModelClipSplitCommandClass * klass) {
1542         model_clip_split_command_parent_class = g_type_class_peek_parent (klass);
1543         MODEL_COMMAND_CLASS (klass)->finalize = model_clip_split_command_finalize;
1544         g_type_class_add_private (klass, sizeof (ModelClipSplitCommandPrivate));
1545         MODEL_COMMAND_CLASS (klass)->apply = model_clip_split_command_real_apply;
1546         MODEL_COMMAND_CLASS (klass)->undo = model_clip_split_command_real_undo;
1547         MODEL_COMMAND_CLASS (klass)->merge = model_clip_split_command_real_merge;
1548         MODEL_COMMAND_CLASS (klass)->description = model_clip_split_command_real_description;
1549 }
1550
1551
1552 static void model_clip_split_command_instance_init (ModelClipSplitCommand * self) {
1553         self->priv = MODEL_CLIP_SPLIT_COMMAND_GET_PRIVATE (self);
1554 }
1555
1556
1557 static void model_clip_split_command_finalize (ModelCommand* obj) {
1558         ModelClipSplitCommand * self;
1559         self = MODEL_CLIP_SPLIT_COMMAND (obj);
1560         _g_object_unref0 (self->priv->track);
1561         MODEL_COMMAND_CLASS (model_clip_split_command_parent_class)->finalize (obj);
1562 }
1563
1564
1565 GType model_clip_split_command_get_type (void) {
1566         static volatile gsize model_clip_split_command_type_id__volatile = 0;
1567         if (g_once_init_enter (&model_clip_split_command_type_id__volatile)) {
1568                 static const GTypeInfo g_define_type_info = { sizeof (ModelClipSplitCommandClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) model_clip_split_command_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ModelClipSplitCommand), 0, (GInstanceInitFunc) model_clip_split_command_instance_init, NULL };
1569                 GType model_clip_split_command_type_id;
1570                 model_clip_split_command_type_id = g_type_register_static (MODEL_TYPE_COMMAND, "ModelClipSplitCommand", &g_define_type_info, 0);
1571                 g_once_init_leave (&model_clip_split_command_type_id__volatile, model_clip_split_command_type_id);
1572         }
1573         return model_clip_split_command_type_id__volatile;
1574 }
1575
1576
1577 #line 209 "command.vala"
1578 ModelClipFileDeleteCommand* model_clip_file_delete_command_construct (GType object_type, ModelProject* p, ModelClipFile* cf) {
1579 #line 1580 "command.c"
1580         ModelClipFileDeleteCommand* self;
1581         ModelClipFile* _tmp0_;
1582         ModelProject* _tmp1_;
1583 #line 209 "command.vala"
1584         g_return_val_if_fail (MODEL_IS_PROJECT (p), NULL);
1585 #line 209 "command.vala"
1586         g_return_val_if_fail (MODEL_IS_CLIP_FILE (cf), NULL);
1587 #line 209 "command.vala"
1588         self = (ModelClipFileDeleteCommand*) model_command_construct (object_type);
1589 #line 210 "command.vala"
1590         self->priv->clipfile = (_tmp0_ = _g_object_ref0 (cf), _g_object_unref0 (self->priv->clipfile), _tmp0_);
1591 #line 211 "command.vala"
1592         self->priv->project = (_tmp1_ = _g_object_ref0 (p), _g_object_unref0 (self->priv->project), _tmp1_);
1593 #line 1594 "command.c"
1594         return self;
1595 }
1596
1597
1598 #line 209 "command.vala"
1599 ModelClipFileDeleteCommand* model_clip_file_delete_command_new (ModelProject* p, ModelClipFile* cf) {
1600 #line 209 "command.vala"
1601         return model_clip_file_delete_command_construct (MODEL_TYPE_CLIP_FILE_DELETE_COMMAND, p, cf);
1602 #line 1603 "command.c"
1603 }
1604
1605
1606 #line 214 "command.vala"
1607 static void model_clip_file_delete_command_real_apply (ModelCommand* base) {
1608 #line 1609 "command.c"
1609         ModelClipFileDeleteCommand * self;
1610         self = MODEL_CLIP_FILE_DELETE_COMMAND (base);
1611 #line 215 "command.vala"
1612         _model_project_remove_clipfile (self->priv->project, self->priv->clipfile);
1613 #line 1614 "command.c"
1614 }
1615
1616
1617 #line 218 "command.vala"
1618 static void model_clip_file_delete_command_real_undo (ModelCommand* base) {
1619 #line 1620 "command.c"
1620         ModelClipFileDeleteCommand * self;
1621         GError * _inner_error_;
1622         self = MODEL_CLIP_FILE_DELETE_COMMAND (base);
1623         _inner_error_ = NULL;
1624         {
1625 #line 220 "command.vala"
1626                 _model_project_add_clipfile (self->priv->project, self->priv->clipfile, &_inner_error_);
1627 #line 1628 "command.c"
1628                 if (_inner_error_ != NULL) {
1629                         goto __catch5_g_error;
1630                 }
1631         }
1632         goto __finally5;
1633         __catch5_g_error:
1634         {
1635                 GError * e;
1636                 e = _inner_error_;
1637                 _inner_error_ = NULL;
1638                 {
1639 #line 222 "command.vala"
1640                         g_signal_emit_by_name (self->priv->project, "error-occurred", "Could not add clipfile.", e->message);
1641 #line 1642 "command.c"
1642                         _g_error_free0 (e);
1643                 }
1644         }
1645         __finally5:
1646         if (_inner_error_ != NULL) {
1647                 g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
1648                 g_clear_error (&_inner_error_);
1649                 return;
1650         }
1651 }
1652
1653
1654 #line 226 "command.vala"
1655 static gboolean model_clip_file_delete_command_real_merge (ModelCommand* base, ModelCommand* command) {
1656 #line 1657 "command.c"
1657         ModelClipFileDeleteCommand * self;
1658         gboolean result = FALSE;
1659         self = MODEL_CLIP_FILE_DELETE_COMMAND (base);
1660 #line 226 "command.vala"
1661         g_return_val_if_fail (MODEL_IS_COMMAND (command), FALSE);
1662 #line 1663 "command.c"
1663         result = FALSE;
1664 #line 227 "command.vala"
1665         return result;
1666 #line 1667 "command.c"
1667 }
1668
1669
1670 #line 230 "command.vala"
1671 static char* model_clip_file_delete_command_real_description (ModelCommand* base) {
1672 #line 1673 "command.c"
1673         ModelClipFileDeleteCommand * self;
1674         char* result = NULL;
1675         self = MODEL_CLIP_FILE_DELETE_COMMAND (base);
1676         result = g_strdup ("Delete from Library");
1677 #line 231 "command.vala"
1678         return result;
1679 #line 1680 "command.c"
1680 }
1681
1682
1683 static void model_clip_file_delete_command_class_init (ModelClipFileDeleteCommandClass * klass) {
1684         model_clip_file_delete_command_parent_class = g_type_class_peek_parent (klass);
1685         MODEL_COMMAND_CLASS (klass)->finalize = model_clip_file_delete_command_finalize;
1686         g_type_class_add_private (klass, sizeof (ModelClipFileDeleteCommandPrivate));
1687         MODEL_COMMAND_CLASS (klass)->apply = model_clip_file_delete_command_real_apply;
1688         MODEL_COMMAND_CLASS (klass)->undo = model_clip_file_delete_command_real_undo;
1689         MODEL_COMMAND_CLASS (klass)->merge = model_clip_file_delete_command_real_merge;
1690         MODEL_COMMAND_CLASS (klass)->description = model_clip_file_delete_command_real_description;
1691 }
1692
1693
1694 static void model_clip_file_delete_command_instance_init (ModelClipFileDeleteCommand * self) {
1695         self->priv = MODEL_CLIP_FILE_DELETE_COMMAND_GET_PRIVATE (self);
1696 }
1697
1698
1699 static void model_clip_file_delete_command_finalize (ModelCommand* obj) {
1700         ModelClipFileDeleteCommand * self;
1701         self = MODEL_CLIP_FILE_DELETE_COMMAND (obj);
1702         _g_object_unref0 (self->priv->clipfile);
1703         _g_object_unref0 (self->priv->project);
1704         MODEL_COMMAND_CLASS (model_clip_file_delete_command_parent_class)->finalize (obj);
1705 }
1706
1707
1708 GType model_clip_file_delete_command_get_type (void) {
1709         static volatile gsize model_clip_file_delete_command_type_id__volatile = 0;
1710         if (g_once_init_enter (&model_clip_file_delete_command_type_id__volatile)) {
1711                 static const GTypeInfo g_define_type_info = { sizeof (ModelClipFileDeleteCommandClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) model_clip_file_delete_command_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ModelClipFileDeleteCommand), 0, (GInstanceInitFunc) model_clip_file_delete_command_instance_init, NULL };
1712                 GType model_clip_file_delete_command_type_id;
1713                 model_clip_file_delete_command_type_id = g_type_register_static (MODEL_TYPE_COMMAND, "ModelClipFileDeleteCommand", &g_define_type_info, 0);
1714                 g_once_init_leave (&model_clip_file_delete_command_type_id__volatile, model_clip_file_delete_command_type_id);
1715         }
1716         return model_clip_file_delete_command_type_id__volatile;
1717 }
1718
1719
1720 #line 241 "command.vala"
1721 ModelClipTrimCommand* model_clip_trim_command_construct (GType object_type, ModelTrack* track, ModelClip* clip, gint64 delta, GdkWindowEdge edge) {
1722 #line 1723 "command.c"
1723         ModelClipTrimCommand* self;
1724         ModelTrack* _tmp0_;
1725         ModelClip* _tmp1_;
1726 #line 241 "command.vala"
1727         g_return_val_if_fail (MODEL_IS_TRACK (track), NULL);
1728 #line 241 "command.vala"
1729         g_return_val_if_fail (MODEL_IS_CLIP (clip), NULL);
1730 #line 241 "command.vala"
1731         self = (ModelClipTrimCommand*) model_command_construct (object_type);
1732 #line 242 "command.vala"
1733         self->priv->track = (_tmp0_ = _g_object_ref0 (track), _g_object_unref0 (self->priv->track), _tmp0_);
1734 #line 243 "command.vala"
1735         self->priv->clip = (_tmp1_ = _g_object_ref0 (clip), _g_object_unref0 (self->priv->clip), _tmp1_);
1736 #line 244 "command.vala"
1737         self->priv->delta = delta;
1738 #line 245 "command.vala"
1739         self->priv->edge = edge;
1740 #line 1741 "command.c"
1741         return self;
1742 }
1743
1744
1745 #line 241 "command.vala"
1746 ModelClipTrimCommand* model_clip_trim_command_new (ModelTrack* track, ModelClip* clip, gint64 delta, GdkWindowEdge edge) {
1747 #line 241 "command.vala"
1748         return model_clip_trim_command_construct (MODEL_TYPE_CLIP_TRIM_COMMAND, track, clip, delta, edge);
1749 #line 1750 "command.c"
1750 }
1751
1752
1753 #line 248 "command.vala"
1754 static void model_clip_trim_command_real_apply (ModelCommand* base) {
1755 #line 1756 "command.c"
1756         ModelClipTrimCommand * self;
1757         self = MODEL_CLIP_TRIM_COMMAND (base);
1758 #line 249 "command.vala"
1759         _model_track_trim (self->priv->track, self->priv->clip, self->priv->delta, self->priv->edge);
1760 #line 1761 "command.c"
1761 }
1762
1763
1764 #line 252 "command.vala"
1765 static void model_clip_trim_command_real_undo (ModelCommand* base) {
1766 #line 1767 "command.c"
1767         ModelClipTrimCommand * self;
1768         self = MODEL_CLIP_TRIM_COMMAND (base);
1769 #line 253 "command.vala"
1770         _model_track_trim (self->priv->track, self->priv->clip, -self->priv->delta, self->priv->edge);
1771 #line 1772 "command.c"
1772 }
1773
1774
1775 #line 256 "command.vala"
1776 static gboolean model_clip_trim_command_real_merge (ModelCommand* base, ModelCommand* command) {
1777 #line 1778 "command.c"
1778         ModelClipTrimCommand * self;
1779         gboolean result = FALSE;
1780         self = MODEL_CLIP_TRIM_COMMAND (base);
1781 #line 256 "command.vala"
1782         g_return_val_if_fail (MODEL_IS_COMMAND (command), FALSE);
1783 #line 1784 "command.c"
1784         result = FALSE;
1785 #line 257 "command.vala"
1786         return result;
1787 #line 1788 "command.c"
1788 }
1789
1790
1791 #line 260 "command.vala"
1792 static char* model_clip_trim_command_real_description (ModelCommand* base) {
1793 #line 1794 "command.c"
1794         ModelClipTrimCommand * self;
1795         char* result = NULL;
1796         self = MODEL_CLIP_TRIM_COMMAND (base);
1797         result = g_strdup ("Trim To Playhead");
1798 #line 261 "command.vala"
1799         return result;
1800 #line 1801 "command.c"
1801 }
1802
1803
1804 static void model_clip_trim_command_class_init (ModelClipTrimCommandClass * klass) {
1805         model_clip_trim_command_parent_class = g_type_class_peek_parent (klass);
1806         MODEL_COMMAND_CLASS (klass)->finalize = model_clip_trim_command_finalize;
1807         g_type_class_add_private (klass, sizeof (ModelClipTrimCommandPrivate));
1808         MODEL_COMMAND_CLASS (klass)->apply = model_clip_trim_command_real_apply;
1809         MODEL_COMMAND_CLASS (klass)->undo = model_clip_trim_command_real_undo;
1810         MODEL_COMMAND_CLASS (klass)->merge = model_clip_trim_command_real_merge;
1811         MODEL_COMMAND_CLASS (klass)->description = model_clip_trim_command_real_description;
1812 }
1813
1814
1815 static void model_clip_trim_command_instance_init (ModelClipTrimCommand * self) {
1816         self->priv = MODEL_CLIP_TRIM_COMMAND_GET_PRIVATE (self);
1817 }
1818
1819
1820 static void model_clip_trim_command_finalize (ModelCommand* obj) {
1821         ModelClipTrimCommand * self;
1822         self = MODEL_CLIP_TRIM_COMMAND (obj);
1823         _g_object_unref0 (self->priv->track);
1824         _g_object_unref0 (self->priv->clip);
1825         MODEL_COMMAND_CLASS (model_clip_trim_command_parent_class)->finalize (obj);
1826 }
1827
1828
1829 GType model_clip_trim_command_get_type (void) {
1830         static volatile gsize model_clip_trim_command_type_id__volatile = 0;
1831         if (g_once_init_enter (&model_clip_trim_command_type_id__volatile)) {
1832                 static const GTypeInfo g_define_type_info = { sizeof (ModelClipTrimCommandClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) model_clip_trim_command_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ModelClipTrimCommand), 0, (GInstanceInitFunc) model_clip_trim_command_instance_init, NULL };
1833                 GType model_clip_trim_command_type_id;
1834                 model_clip_trim_command_type_id = g_type_register_static (MODEL_TYPE_COMMAND, "ModelClipTrimCommand", &g_define_type_info, 0);
1835                 g_once_init_leave (&model_clip_trim_command_type_id__volatile, model_clip_trim_command_type_id);
1836         }
1837         return model_clip_trim_command_type_id__volatile;
1838 }
1839
1840
1841 #line 271 "command.vala"
1842 ModelClipRevertCommand* model_clip_revert_command_construct (GType object_type, ModelTrack* track, ModelClip* clip) {
1843 #line 1844 "command.c"
1844         ModelClipRevertCommand* self;
1845         ModelTrack* _tmp0_;
1846         ModelClip* _tmp1_;
1847 #line 271 "command.vala"
1848         g_return_val_if_fail (MODEL_IS_TRACK (track), NULL);
1849 #line 271 "command.vala"
1850         g_return_val_if_fail (MODEL_IS_CLIP (clip), NULL);
1851 #line 271 "command.vala"
1852         self = (ModelClipRevertCommand*) model_command_construct (object_type);
1853 #line 272 "command.vala"
1854         self->priv->track = (_tmp0_ = _g_object_ref0 (track), _g_object_unref0 (self->priv->track), _tmp0_);
1855 #line 273 "command.vala"
1856         self->priv->clip = (_tmp1_ = _g_object_ref0 (clip), _g_object_unref0 (self->priv->clip), _tmp1_);
1857 #line 1858 "command.c"
1858         return self;
1859 }
1860
1861
1862 #line 271 "command.vala"
1863 ModelClipRevertCommand* model_clip_revert_command_new (ModelTrack* track, ModelClip* clip) {
1864 #line 271 "command.vala"
1865         return model_clip_revert_command_construct (MODEL_TYPE_CLIP_REVERT_COMMAND, track, clip);
1866 #line 1867 "command.c"
1867 }
1868
1869
1870 #line 276 "command.vala"
1871 static void model_clip_revert_command_real_apply (ModelCommand* base) {
1872 #line 1873 "command.c"
1873         ModelClipRevertCommand * self;
1874         self = MODEL_CLIP_REVERT_COMMAND (base);
1875 #line 277 "command.vala"
1876         self->priv->right_delta = model_clip_get_end (self->priv->clip);
1877 #line 278 "command.vala"
1878         self->priv->left_delta = model_clip_get_media_start (self->priv->clip);
1879 #line 279 "command.vala"
1880         _model_track_revert_to_original (self->priv->track, self->priv->clip);
1881 #line 280 "command.vala"
1882         self->priv->left_delta = self->priv->left_delta - model_clip_get_media_start (self->priv->clip);
1883 #line 281 "command.vala"
1884         self->priv->right_delta = (model_clip_get_end (self->priv->clip) - self->priv->right_delta) - self->priv->left_delta;
1885 #line 1886 "command.c"
1886 }
1887
1888
1889 #line 284 "command.vala"
1890 static void model_clip_revert_command_real_undo (ModelCommand* base) {
1891 #line 1892 "command.c"
1892         ModelClipRevertCommand * self;
1893         self = MODEL_CLIP_REVERT_COMMAND (base);
1894 #line 285 "command.vala"
1895         _model_track_trim (self->priv->track, self->priv->clip, -self->priv->left_delta, GDK_WINDOW_EDGE_WEST);
1896 #line 286 "command.vala"
1897         _model_track_trim (self->priv->track, self->priv->clip, -self->priv->right_delta, GDK_WINDOW_EDGE_EAST);
1898 #line 1899 "command.c"
1899 }
1900
1901
1902 #line 289 "command.vala"
1903 static gboolean model_clip_revert_command_real_merge (ModelCommand* base, ModelCommand* command) {
1904 #line 1905 "command.c"
1905         ModelClipRevertCommand * self;
1906         gboolean result = FALSE;
1907         self = MODEL_CLIP_REVERT_COMMAND (base);
1908 #line 289 "command.vala"
1909         g_return_val_if_fail (MODEL_IS_COMMAND (command), FALSE);
1910 #line 1911 "command.c"
1911         result = FALSE;
1912 #line 290 "command.vala"
1913         return result;
1914 #line 1915 "command.c"
1915 }
1916
1917
1918 #line 293 "command.vala"
1919 static char* model_clip_revert_command_real_description (ModelCommand* base) {
1920 #line 1921 "command.c"
1921         ModelClipRevertCommand * self;
1922         char* result = NULL;
1923         self = MODEL_CLIP_REVERT_COMMAND (base);
1924         result = g_strdup ("Revert To Original");
1925 #line 294 "command.vala"
1926         return result;
1927 #line 1928 "command.c"
1928 }
1929
1930
1931 static void model_clip_revert_command_class_init (ModelClipRevertCommandClass * klass) {
1932         model_clip_revert_command_parent_class = g_type_class_peek_parent (klass);
1933         MODEL_COMMAND_CLASS (klass)->finalize = model_clip_revert_command_finalize;
1934         g_type_class_add_private (klass, sizeof (ModelClipRevertCommandPrivate));
1935         MODEL_COMMAND_CLASS (klass)->apply = model_clip_revert_command_real_apply;
1936         MODEL_COMMAND_CLASS (klass)->undo = model_clip_revert_command_real_undo;
1937         MODEL_COMMAND_CLASS (klass)->merge = model_clip_revert_command_real_merge;
1938         MODEL_COMMAND_CLASS (klass)->description = model_clip_revert_command_real_description;
1939 }
1940
1941
1942 static void model_clip_revert_command_instance_init (ModelClipRevertCommand * self) {
1943         self->priv = MODEL_CLIP_REVERT_COMMAND_GET_PRIVATE (self);
1944 }
1945
1946
1947 static void model_clip_revert_command_finalize (ModelCommand* obj) {
1948         ModelClipRevertCommand * self;
1949         self = MODEL_CLIP_REVERT_COMMAND (obj);
1950         _g_object_unref0 (self->priv->track);
1951         _g_object_unref0 (self->priv->clip);
1952         MODEL_COMMAND_CLASS (model_clip_revert_command_parent_class)->finalize (obj);
1953 }
1954
1955
1956 GType model_clip_revert_command_get_type (void) {
1957         static volatile gsize model_clip_revert_command_type_id__volatile = 0;
1958         if (g_once_init_enter (&model_clip_revert_command_type_id__volatile)) {
1959                 static const GTypeInfo g_define_type_info = { sizeof (ModelClipRevertCommandClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) model_clip_revert_command_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ModelClipRevertCommand), 0, (GInstanceInitFunc) model_clip_revert_command_instance_init, NULL };
1960                 GType model_clip_revert_command_type_id;
1961                 model_clip_revert_command_type_id = g_type_register_static (MODEL_TYPE_COMMAND, "ModelClipRevertCommand", &g_define_type_info, 0);
1962                 g_once_init_leave (&model_clip_revert_command_type_id__volatile, model_clip_revert_command_type_id);
1963         }
1964         return model_clip_revert_command_type_id__volatile;
1965 }
1966
1967
1968 #line 303 "command.vala"
1969 ModelTimeSignatureCommand* model_time_signature_command_construct (GType object_type, ModelProject* project, Fraction* new_time_signature) {
1970 #line 1971 "command.c"
1971         ModelTimeSignatureCommand* self;
1972         ModelProject* _tmp0_;
1973         Fraction _tmp1_ = {0};
1974 #line 303 "command.vala"
1975         g_return_val_if_fail (MODEL_IS_PROJECT (project), NULL);
1976 #line 303 "command.vala"
1977         self = (ModelTimeSignatureCommand*) model_command_construct (object_type);
1978 #line 304 "command.vala"
1979         self->priv->project = (_tmp0_ = _g_object_ref0 (project), _g_object_unref0 (self->priv->project), _tmp0_);
1980 #line 305 "command.vala"
1981         self->priv->new_time_signature = *new_time_signature;
1982 #line 306 "command.vala"
1983         self->priv->old_time_signature = (model_tempo_information_get_time_signature (MODEL_TEMPO_INFORMATION (project), &_tmp1_), _tmp1_);
1984 #line 1985 "command.c"
1985         return self;
1986 }
1987
1988
1989 #line 303 "command.vala"
1990 ModelTimeSignatureCommand* model_time_signature_command_new (ModelProject* project, Fraction* new_time_signature) {
1991 #line 303 "command.vala"
1992         return model_time_signature_command_construct (MODEL_TYPE_TIME_SIGNATURE_COMMAND, project, new_time_signature);
1993 #line 1994 "command.c"
1994 }
1995
1996
1997 #line 309 "command.vala"
1998 static void model_time_signature_command_real_apply (ModelCommand* base) {
1999 #line 2000 "command.c"
2000         ModelTimeSignatureCommand * self;
2001         self = MODEL_TIME_SIGNATURE_COMMAND (base);
2002 #line 310 "command.vala"
2003         _model_project_set_time_signature (self->priv->project, &self->priv->new_time_signature);
2004 #line 2005 "command.c"
2005 }
2006
2007
2008 #line 313 "command.vala"
2009 static void model_time_signature_command_real_undo (ModelCommand* base) {
2010 #line 2011 "command.c"
2011         ModelTimeSignatureCommand * self;
2012         self = MODEL_TIME_SIGNATURE_COMMAND (base);
2013 #line 314 "command.vala"
2014         _model_project_set_time_signature (self->priv->project, &self->priv->old_time_signature);
2015 #line 2016 "command.c"
2016 }
2017
2018
2019 #line 317 "command.vala"
2020 static gboolean model_time_signature_command_real_merge (ModelCommand* base, ModelCommand* command) {
2021 #line 2022 "command.c"
2022         ModelTimeSignatureCommand * self;
2023         gboolean result = FALSE;
2024         self = MODEL_TIME_SIGNATURE_COMMAND (base);
2025 #line 317 "command.vala"
2026         g_return_val_if_fail (MODEL_IS_COMMAND (command), FALSE);
2027 #line 2028 "command.c"
2028         result = FALSE;
2029 #line 318 "command.vala"
2030         return result;
2031 #line 2032 "command.c"
2032 }
2033
2034
2035 #line 321 "command.vala"
2036 static char* model_time_signature_command_real_description (ModelCommand* base) {
2037 #line 2038 "command.c"
2038         ModelTimeSignatureCommand * self;
2039         char* result = NULL;
2040         self = MODEL_TIME_SIGNATURE_COMMAND (base);
2041         result = g_strdup ("Set Time Signature");
2042 #line 322 "command.vala"
2043         return result;
2044 #line 2045 "command.c"
2045 }
2046
2047
2048 static void model_time_signature_command_class_init (ModelTimeSignatureCommandClass * klass) {
2049         model_time_signature_command_parent_class = g_type_class_peek_parent (klass);
2050         MODEL_COMMAND_CLASS (klass)->finalize = model_time_signature_command_finalize;
2051         g_type_class_add_private (klass, sizeof (ModelTimeSignatureCommandPrivate));
2052         MODEL_COMMAND_CLASS (klass)->apply = model_time_signature_command_real_apply;
2053         MODEL_COMMAND_CLASS (klass)->undo = model_time_signature_command_real_undo;
2054         MODEL_COMMAND_CLASS (klass)->merge = model_time_signature_command_real_merge;
2055         MODEL_COMMAND_CLASS (klass)->description = model_time_signature_command_real_description;
2056 }
2057
2058
2059 static void model_time_signature_command_instance_init (ModelTimeSignatureCommand * self) {
2060         self->priv = MODEL_TIME_SIGNATURE_COMMAND_GET_PRIVATE (self);
2061 }
2062
2063
2064 static void model_time_signature_command_finalize (ModelCommand* obj) {
2065         ModelTimeSignatureCommand * self;
2066         self = MODEL_TIME_SIGNATURE_COMMAND (obj);
2067         _g_object_unref0 (self->priv->project);
2068         MODEL_COMMAND_CLASS (model_time_signature_command_parent_class)->finalize (obj);
2069 }
2070
2071
2072 GType model_time_signature_command_get_type (void) {
2073         static volatile gsize model_time_signature_command_type_id__volatile = 0;
2074         if (g_once_init_enter (&model_time_signature_command_type_id__volatile)) {
2075                 static const GTypeInfo g_define_type_info = { sizeof (ModelTimeSignatureCommandClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) model_time_signature_command_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ModelTimeSignatureCommand), 0, (GInstanceInitFunc) model_time_signature_command_instance_init, NULL };
2076                 GType model_time_signature_command_type_id;
2077                 model_time_signature_command_type_id = g_type_register_static (MODEL_TYPE_COMMAND, "ModelTimeSignatureCommand", &g_define_type_info, 0);
2078                 g_once_init_leave (&model_time_signature_command_type_id__volatile, model_time_signature_command_type_id);
2079         }
2080         return model_time_signature_command_type_id__volatile;
2081 }
2082
2083
2084 #line 330 "command.vala"
2085 ModelBpmCommand* model_bpm_command_construct (GType object_type, ModelProject* project, gint new_bpm) {
2086 #line 2087 "command.c"
2087         ModelBpmCommand* self;
2088         ModelProject* _tmp0_;
2089 #line 330 "command.vala"
2090         g_return_val_if_fail (MODEL_IS_PROJECT (project), NULL);
2091 #line 330 "command.vala"
2092         self = (ModelBpmCommand*) model_command_construct (object_type);
2093 #line 331 "command.vala"
2094         self->priv->delta = new_bpm - model_tempo_information_get_bpm (MODEL_TEMPO_INFORMATION (project));
2095 #line 332 "command.vala"
2096         self->priv->project = (_tmp0_ = _g_object_ref0 (project), _g_object_unref0 (self->priv->project), _tmp0_);
2097 #line 2098 "command.c"
2098         return self;
2099 }
2100
2101
2102 #line 330 "command.vala"
2103 ModelBpmCommand* model_bpm_command_new (ModelProject* project, gint new_bpm) {
2104 #line 330 "command.vala"
2105         return model_bpm_command_construct (MODEL_TYPE_BPM_COMMAND, project, new_bpm);
2106 #line 2107 "command.c"
2107 }
2108
2109
2110 #line 335 "command.vala"
2111 static void model_bpm_command_real_apply (ModelCommand* base) {
2112 #line 2113 "command.c"
2113         ModelBpmCommand * self;
2114         self = MODEL_BPM_COMMAND (base);
2115 #line 336 "command.vala"
2116         _model_project_set_bpm (self->priv->project, model_tempo_information_get_bpm (MODEL_TEMPO_INFORMATION (self->priv->project)) + self->priv->delta);
2117 #line 2118 "command.c"
2118 }
2119
2120
2121 #line 339 "command.vala"
2122 static void model_bpm_command_real_undo (ModelCommand* base) {
2123 #line 2124 "command.c"
2124         ModelBpmCommand * self;
2125         self = MODEL_BPM_COMMAND (base);
2126 #line 340 "command.vala"
2127         _model_project_set_bpm (self->priv->project, model_tempo_information_get_bpm (MODEL_TEMPO_INFORMATION (self->priv->project)) - self->priv->delta);
2128 #line 2129 "command.c"
2129 }
2130
2131
2132 #line 343 "command.vala"
2133 static gboolean model_bpm_command_real_merge (ModelCommand* base, ModelCommand* command) {
2134 #line 2135 "command.c"
2135         ModelBpmCommand * self;
2136         gboolean result = FALSE;
2137         self = MODEL_BPM_COMMAND (base);
2138 #line 343 "command.vala"
2139         g_return_val_if_fail (MODEL_IS_COMMAND (command), FALSE);
2140 #line 2141 "command.c"
2141         result = FALSE;
2142 #line 344 "command.vala"
2143         return result;
2144 #line 2145 "command.c"
2145 }
2146
2147
2148 #line 347 "command.vala"
2149 static char* model_bpm_command_real_description (ModelCommand* base) {
2150 #line 2151 "command.c"
2151         ModelBpmCommand * self;
2152         char* result = NULL;
2153         self = MODEL_BPM_COMMAND (base);
2154         result = g_strdup ("Set Tempo");
2155 #line 348 "command.vala"
2156         return result;
2157 #line 2158 "command.c"
2158 }
2159
2160
2161 static void model_bpm_command_class_init (ModelBpmCommandClass * klass) {
2162         model_bpm_command_parent_class = g_type_class_peek_parent (klass);
2163         MODEL_COMMAND_CLASS (klass)->finalize = model_bpm_command_finalize;
2164         g_type_class_add_private (klass, sizeof (ModelBpmCommandPrivate));
2165         MODEL_COMMAND_CLASS (klass)->apply = model_bpm_command_real_apply;
2166         MODEL_COMMAND_CLASS (klass)->undo = model_bpm_command_real_undo;
2167         MODEL_COMMAND_CLASS (klass)->merge = model_bpm_command_real_merge;
2168         MODEL_COMMAND_CLASS (klass)->description = model_bpm_command_real_description;
2169 }
2170
2171
2172 static void model_bpm_command_instance_init (ModelBpmCommand * self) {
2173         self->priv = MODEL_BPM_COMMAND_GET_PRIVATE (self);
2174 }
2175
2176
2177 static void model_bpm_command_finalize (ModelCommand* obj) {
2178         ModelBpmCommand * self;
2179         self = MODEL_BPM_COMMAND (obj);
2180         _g_object_unref0 (self->priv->project);
2181         MODEL_COMMAND_CLASS (model_bpm_command_parent_class)->finalize (obj);
2182 }
2183
2184
2185 GType model_bpm_command_get_type (void) {
2186         static volatile gsize model_bpm_command_type_id__volatile = 0;
2187         if (g_once_init_enter (&model_bpm_command_type_id__volatile)) {
2188                 static const GTypeInfo g_define_type_info = { sizeof (ModelBpmCommandClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) model_bpm_command_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ModelBpmCommand), 0, (GInstanceInitFunc) model_bpm_command_instance_init, NULL };
2189                 GType model_bpm_command_type_id;
2190                 model_bpm_command_type_id = g_type_register_static (MODEL_TYPE_COMMAND, "ModelBpmCommand", &g_define_type_info, 0);
2191                 g_once_init_leave (&model_bpm_command_type_id__volatile, model_bpm_command_type_id);
2192         }
2193         return model_bpm_command_type_id__volatile;
2194 }
2195
2196
2197 #line 356 "command.vala"
2198 ModelAddClipCommand* model_add_clip_command_construct (GType object_type, ModelProject* project, ModelClipFile* clip_file) {
2199 #line 2200 "command.c"
2200         ModelAddClipCommand* self;
2201         ModelProject* _tmp0_;
2202         ModelClipFile* _tmp1_;
2203 #line 356 "command.vala"
2204         g_return_val_if_fail (MODEL_IS_PROJECT (project), NULL);
2205 #line 356 "command.vala"
2206         g_return_val_if_fail (MODEL_IS_CLIP_FILE (clip_file), NULL);
2207 #line 356 "command.vala"
2208         self = (ModelAddClipCommand*) model_command_construct (object_type);
2209 #line 357 "command.vala"
2210         self->priv->project = (_tmp0_ = _g_object_ref0 (project), _g_object_unref0 (self->priv->project), _tmp0_);
2211 #line 358 "command.vala"
2212         self->priv->clip_file = (_tmp1_ = _g_object_ref0 (clip_file), _g_object_unref0 (self->priv->clip_file), _tmp1_);
2213 #line 2214 "command.c"
2214         return self;
2215 }
2216
2217
2218 #line 356 "command.vala"
2219 ModelAddClipCommand* model_add_clip_command_new (ModelProject* project, ModelClipFile* clip_file) {
2220 #line 356 "command.vala"
2221         return model_add_clip_command_construct (MODEL_TYPE_ADD_CLIP_COMMAND, project, clip_file);
2222 #line 2223 "command.c"
2223 }
2224
2225
2226 #line 361 "command.vala"
2227 static void model_add_clip_command_real_apply (ModelCommand* base) {
2228 #line 2229 "command.c"
2229         ModelAddClipCommand * self;
2230         GError * _inner_error_;
2231         self = MODEL_ADD_CLIP_COMMAND (base);
2232         _inner_error_ = NULL;
2233         {
2234 #line 363 "command.vala"
2235                 _model_project_add_clipfile (self->priv->project, self->priv->clip_file, &_inner_error_);
2236 #line 2237 "command.c"
2237                 if (_inner_error_ != NULL) {
2238                         goto __catch6_g_error;
2239                 }
2240         }
2241         goto __finally6;
2242         __catch6_g_error:
2243         {
2244                 GError * _error_;
2245                 _error_ = _inner_error_;
2246                 _inner_error_ = NULL;
2247                 {
2248 #line 365 "command.vala"
2249                         g_signal_emit_by_name (self->priv->project, "error-occurred", "Error importing", "An error occurred importing this file.");
2250 #line 2251 "command.c"
2251                         _g_error_free0 (_error_);
2252                 }
2253         }
2254         __finally6:
2255         if (_inner_error_ != NULL) {
2256                 g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
2257                 g_clear_error (&_inner_error_);
2258                 return;
2259         }
2260 }
2261
2262
2263 #line 369 "command.vala"
2264 static void model_add_clip_command_real_undo (ModelCommand* base) {
2265 #line 2266 "command.c"
2266         ModelAddClipCommand * self;
2267         self = MODEL_ADD_CLIP_COMMAND (base);
2268 #line 370 "command.vala"
2269         _model_project_remove_clipfile (self->priv->project, self->priv->clip_file);
2270 #line 2271 "command.c"
2271 }
2272
2273
2274 #line 373 "command.vala"
2275 static gboolean model_add_clip_command_real_merge (ModelCommand* base, ModelCommand* command) {
2276 #line 2277 "command.c"
2277         ModelAddClipCommand * self;
2278         gboolean result = FALSE;
2279         self = MODEL_ADD_CLIP_COMMAND (base);
2280 #line 373 "command.vala"
2281         g_return_val_if_fail (MODEL_IS_COMMAND (command), FALSE);
2282 #line 2283 "command.c"
2283         result = FALSE;
2284 #line 374 "command.vala"
2285         return result;
2286 #line 2287 "command.c"
2287 }
2288
2289
2290 #line 377 "command.vala"
2291 static char* model_add_clip_command_real_description (ModelCommand* base) {
2292 #line 2293 "command.c"
2293         ModelAddClipCommand * self;
2294         char* result = NULL;
2295         self = MODEL_ADD_CLIP_COMMAND (base);
2296         result = g_strdup ("Add Clip To Library");
2297 #line 378 "command.vala"
2298         return result;
2299 #line 2300 "command.c"
2300 }
2301
2302
2303 static void model_add_clip_command_class_init (ModelAddClipCommandClass * klass) {
2304         model_add_clip_command_parent_class = g_type_class_peek_parent (klass);
2305         MODEL_COMMAND_CLASS (klass)->finalize = model_add_clip_command_finalize;
2306         g_type_class_add_private (klass, sizeof (ModelAddClipCommandPrivate));
2307         MODEL_COMMAND_CLASS (klass)->apply = model_add_clip_command_real_apply;
2308         MODEL_COMMAND_CLASS (klass)->undo = model_add_clip_command_real_undo;
2309         MODEL_COMMAND_CLASS (klass)->merge = model_add_clip_command_real_merge;
2310         MODEL_COMMAND_CLASS (klass)->description = model_add_clip_command_real_description;
2311 }
2312
2313
2314 static void model_add_clip_command_instance_init (ModelAddClipCommand * self) {
2315         self->priv = MODEL_ADD_CLIP_COMMAND_GET_PRIVATE (self);
2316 }
2317
2318
2319 static void model_add_clip_command_finalize (ModelCommand* obj) {
2320         ModelAddClipCommand * self;
2321         self = MODEL_ADD_CLIP_COMMAND (obj);
2322         _g_object_unref0 (self->priv->clip_file);
2323         _g_object_unref0 (self->priv->project);
2324         MODEL_COMMAND_CLASS (model_add_clip_command_parent_class)->finalize (obj);
2325 }
2326
2327
2328 GType model_add_clip_command_get_type (void) {
2329         static volatile gsize model_add_clip_command_type_id__volatile = 0;
2330         if (g_once_init_enter (&model_add_clip_command_type_id__volatile)) {
2331                 static const GTypeInfo g_define_type_info = { sizeof (ModelAddClipCommandClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) model_add_clip_command_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ModelAddClipCommand), 0, (GInstanceInitFunc) model_add_clip_command_instance_init, NULL };
2332                 GType model_add_clip_command_type_id;
2333                 model_add_clip_command_type_id = g_type_register_static (MODEL_TYPE_COMMAND, "ModelAddClipCommand", &g_define_type_info, 0);
2334                 g_once_init_leave (&model_add_clip_command_type_id__volatile, model_add_clip_command_type_id);
2335         }
2336         return model_add_clip_command_type_id__volatile;
2337 }
2338
2339
2340 #line 386 "command.vala"
2341 ModelTransactionCommand* model_transaction_command_construct (GType object_type, gboolean open, const char* transaction_description) {
2342 #line 2343 "command.c"
2343         ModelTransactionCommand* self;
2344         char* _tmp0_;
2345 #line 386 "command.vala"
2346         g_return_val_if_fail (transaction_description != NULL, NULL);
2347 #line 386 "command.vala"
2348         self = (ModelTransactionCommand*) model_command_construct (object_type);
2349 #line 387 "command.vala"
2350         self->priv->open = open;
2351 #line 388 "command.vala"
2352         self->priv->transaction_description = (_tmp0_ = g_strdup (transaction_description), _g_free0 (self->priv->transaction_description), _tmp0_);
2353 #line 2354 "command.c"
2354         return self;
2355 }
2356
2357
2358 #line 386 "command.vala"
2359 ModelTransactionCommand* model_transaction_command_new (gboolean open, const char* transaction_description) {
2360 #line 386 "command.vala"
2361         return model_transaction_command_construct (MODEL_TYPE_TRANSACTION_COMMAND, open, transaction_description);
2362 #line 2363 "command.c"
2363 }
2364
2365
2366 #line 391 "command.vala"
2367 gboolean model_transaction_command_in_transaction (ModelTransactionCommand* self) {
2368 #line 2369 "command.c"
2369         gboolean result = FALSE;
2370 #line 391 "command.vala"
2371         g_return_val_if_fail (MODEL_IS_TRANSACTION_COMMAND (self), FALSE);
2372 #line 2373 "command.c"
2373         result = self->priv->open;
2374 #line 392 "command.vala"
2375         return result;
2376 #line 2377 "command.c"
2377 }
2378
2379
2380 #line 395 "command.vala"
2381 static void model_transaction_command_real_apply (ModelCommand* base) {
2382 #line 2383 "command.c"
2383         ModelTransactionCommand * self;
2384         self = MODEL_TRANSACTION_COMMAND (base);
2385 }
2386
2387
2388 #line 398 "command.vala"
2389 static void model_transaction_command_real_undo (ModelCommand* base) {
2390 #line 2391 "command.c"
2391         ModelTransactionCommand * self;
2392         self = MODEL_TRANSACTION_COMMAND (base);
2393 }
2394
2395
2396 #line 401 "command.vala"
2397 static gboolean model_transaction_command_real_merge (ModelCommand* base, ModelCommand* command) {
2398 #line 2399 "command.c"
2399         ModelTransactionCommand * self;
2400         gboolean result = FALSE;
2401         self = MODEL_TRANSACTION_COMMAND (base);
2402 #line 401 "command.vala"
2403         g_return_val_if_fail (MODEL_IS_COMMAND (command), FALSE);
2404 #line 2405 "command.c"
2405         result = FALSE;
2406 #line 402 "command.vala"
2407         return result;
2408 #line 2409 "command.c"
2409 }
2410
2411
2412 #line 405 "command.vala"
2413 static char* model_transaction_command_real_description (ModelCommand* base) {
2414 #line 2415 "command.c"
2415         ModelTransactionCommand * self;
2416         char* result = NULL;
2417         self = MODEL_TRANSACTION_COMMAND (base);
2418         result = g_strdup (self->priv->transaction_description);
2419 #line 406 "command.vala"
2420         return result;
2421 #line 2422 "command.c"
2422 }
2423
2424
2425 static void model_transaction_command_class_init (ModelTransactionCommandClass * klass) {
2426         model_transaction_command_parent_class = g_type_class_peek_parent (klass);
2427         MODEL_COMMAND_CLASS (klass)->finalize = model_transaction_command_finalize;
2428         g_type_class_add_private (klass, sizeof (ModelTransactionCommandPrivate));
2429         MODEL_COMMAND_CLASS (klass)->apply = model_transaction_command_real_apply;
2430         MODEL_COMMAND_CLASS (klass)->undo = model_transaction_command_real_undo;
2431         MODEL_COMMAND_CLASS (klass)->merge = model_transaction_command_real_merge;
2432         MODEL_COMMAND_CLASS (klass)->description = model_transaction_command_real_description;
2433 }
2434
2435
2436 static void model_transaction_command_instance_init (ModelTransactionCommand * self) {
2437         self->priv = MODEL_TRANSACTION_COMMAND_GET_PRIVATE (self);
2438 }
2439
2440
2441 static void model_transaction_command_finalize (ModelCommand* obj) {
2442         ModelTransactionCommand * self;
2443         self = MODEL_TRANSACTION_COMMAND (obj);
2444         _g_free0 (self->priv->transaction_description);
2445         MODEL_COMMAND_CLASS (model_transaction_command_parent_class)->finalize (obj);
2446 }
2447
2448
2449 GType model_transaction_command_get_type (void) {
2450         static volatile gsize model_transaction_command_type_id__volatile = 0;
2451         if (g_once_init_enter (&model_transaction_command_type_id__volatile)) {
2452                 static const GTypeInfo g_define_type_info = { sizeof (ModelTransactionCommandClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) model_transaction_command_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ModelTransactionCommand), 0, (GInstanceInitFunc) model_transaction_command_instance_init, NULL };
2453                 GType model_transaction_command_type_id;
2454                 model_transaction_command_type_id = g_type_register_static (MODEL_TYPE_COMMAND, "ModelTransactionCommand", &g_define_type_info, 0);
2455                 g_once_init_leave (&model_transaction_command_type_id__volatile, model_transaction_command_type_id);
2456         }
2457         return model_transaction_command_type_id__volatile;
2458 }
2459
2460
2461
2462