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

   1 /* ui_clip.c generated by valac, the Vala compiler
   2  * generated from ui_clip.vala, do not modify */
   3
   4 /* Copyright 2009-2010 Yorba Foundation
   5  *
   6  * This software is licensed under the GNU Lesser General Public License
   7  * (version 2.1 or later).  See the COPYING file in this distribution.
   8  */
   9
  10 #include <glib.h>
  11 #include <glib-object.h>
  12 #include <gtk/gtk.h>
  13 #include <gdk/gdk.h>
  14 #include <float.h>
  15 #include <math.h>
  16 #include <stdlib.h>
  17 #include <string.h>
  18 #include <pango/pango.h>
  19
  20
  21 #define TYPE_GAP_VIEW (gap_view_get_type ())
  22 #define GAP_VIEW(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_GAP_VIEW, GapView))
  23 #define GAP_VIEW_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_GAP_VIEW, GapViewClass))
  24 #define IS_GAP_VIEW(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_GAP_VIEW))
  25 #define IS_GAP_VIEW_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_GAP_VIEW))
  26 #define GAP_VIEW_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_GAP_VIEW, GapViewClass))
  27
  28 typedef struct _GapView GapView;
  29 typedef struct _GapViewClass GapViewClass;
  30 typedef struct _GapViewPrivate GapViewPrivate;
  31
  32 #define MODEL_TYPE_GAP (model_gap_get_type ())
  33 #define MODEL_GAP(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_GAP, ModelGap))
  34 #define MODEL_GAP_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_GAP, ModelGapClass))
  35 #define MODEL_IS_GAP(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_GAP))
  36 #define MODEL_IS_GAP_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_GAP))
  37 #define MODEL_GAP_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_GAP, ModelGapClass))
  38
  39 typedef struct _ModelGap ModelGap;
  40 typedef struct _ModelGapClass ModelGapClass;
  41 #define _model_gap_unref0(var) ((var == NULL) ? NULL : (var = (model_gap_unref (var), NULL)))
  42
  43 #define TYPE_CLIP_VIEW (clip_view_get_type ())
  44 #define CLIP_VIEW(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_CLIP_VIEW, ClipView))
  45 #define CLIP_VIEW_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_CLIP_VIEW, ClipViewClass))
  46 #define IS_CLIP_VIEW(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_CLIP_VIEW))
  47 #define IS_CLIP_VIEW_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_CLIP_VIEW))
  48 #define CLIP_VIEW_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_CLIP_VIEW, ClipViewClass))
  49
  50 typedef struct _ClipView ClipView;
  51 typedef struct _ClipViewClass ClipViewClass;
  52 typedef struct _ClipViewPrivate ClipViewPrivate;
  53
  54 #define MODEL_TYPE_CLIP (model_clip_get_type ())
  55 #define MODEL_CLIP(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_CLIP, ModelClip))
  56 #define MODEL_CLIP_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_CLIP, ModelClipClass))
  57 #define MODEL_IS_CLIP(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_CLIP))
  58 #define MODEL_IS_CLIP_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_CLIP))
  59 #define MODEL_CLIP_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_CLIP, ModelClipClass))
  60
  61 typedef struct _ModelClip ModelClip;
  62 typedef struct _ModelClipClass ModelClipClass;
  63
  64 #define MODEL_TYPE_TIME_SYSTEM (model_time_system_get_type ())
  65 #define MODEL_TIME_SYSTEM(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_TIME_SYSTEM, ModelTimeSystem))
  66 #define MODEL_IS_TIME_SYSTEM(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_TIME_SYSTEM))
  67 #define MODEL_TIME_SYSTEM_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), MODEL_TYPE_TIME_SYSTEM, ModelTimeSystemIface))
  68
  69 typedef struct _ModelTimeSystem ModelTimeSystem;
  70 typedef struct _ModelTimeSystemIface ModelTimeSystemIface;
  71
  72 #define TYPE_TRANSPORT_DELEGATE (transport_delegate_get_type ())
  73 #define TRANSPORT_DELEGATE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_TRANSPORT_DELEGATE, TransportDelegate))
  74 #define IS_TRANSPORT_DELEGATE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_TRANSPORT_DELEGATE))
  75 #define TRANSPORT_DELEGATE_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), TYPE_TRANSPORT_DELEGATE, TransportDelegateIface))
  76
  77 typedef struct _TransportDelegate TransportDelegate;
  78 typedef struct _TransportDelegateIface TransportDelegateIface;
  79
  80 #define CLIP_VIEW_TYPE_MOTION_MODE (clip_view_motion_mode_get_type ())
  81 #define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
  82 typedef struct _ModelClipPrivate ModelClipPrivate;
  83
  84 #define MODEL_TYPE_CLIP_FILE (model_clip_file_get_type ())
  85 #define MODEL_CLIP_FILE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_CLIP_FILE, ModelClipFile))
  86 #define MODEL_CLIP_FILE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_CLIP_FILE, ModelClipFileClass))
  87 #define MODEL_IS_CLIP_FILE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_CLIP_FILE))
  88 #define MODEL_IS_CLIP_FILE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_CLIP_FILE))
  89 #define MODEL_CLIP_FILE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_CLIP_FILE, ModelClipFileClass))
  90
  91 typedef struct _ModelClipFile ModelClipFile;
  92 typedef struct _ModelClipFileClass ModelClipFileClass;
  93
  94 #define MODEL_TYPE_MEDIA_TYPE (model_media_type_get_type ())
  95
  96 #define LOGGING_TYPE_FACILITY (logging_facility_get_type ())
  97
  98 #define LOGGING_TYPE_LEVEL (logging_level_get_type ())
  99 #define _g_free0(var) (var = (g_free (var), NULL))
 100
 101 struct _GapView {
 102         GtkDrawingArea parent_instance;
 103         GapViewPrivate * priv;
 104         ModelGap* gap;
 105 };
 106
 107 struct _GapViewClass {
 108         GtkDrawingAreaClass parent_class;
 109 };
 110
 111 struct _GapViewPrivate {
 112         GdkColor fill_color;
 113 };
 114
 115 struct _ClipView {
 116         GtkDrawingArea parent_instance;
 117         ClipViewPrivate * priv;
 118         ModelClip* clip;
 119         gint64 initial_time;
 120         gboolean is_selected;
 121         gint height;
 122 };
 123
 124 struct _ClipViewClass {
 125         GtkDrawingAreaClass parent_class;
 126 };
 127
 128 struct _ModelTimeSystemIface {
 129         GTypeInterface parent_iface;
 130         void (*calculate_pixel_step) (ModelTimeSystem* self, float inc, float pixel_min, float pixel_div);
 131         gint64 (*xpos_to_time) (ModelTimeSystem* self, gint x);
 132         gint64 (*xsize_to_time) (ModelTimeSystem* self, gint x);
 133         gint (*time_to_xpos) (ModelTimeSystem* self, gint64 time);
 134         gint64 (*get_pixel_snap_time) (ModelTimeSystem* self);
 135         gint (*time_to_xsize) (ModelTimeSystem* self, gint64 time);
 136         float (*get_pixel_percentage) (ModelTimeSystem* self);
 137         gint (*get_start_token) (ModelTimeSystem* self, gint xsize);
 138         gint (*get_next_position) (ModelTimeSystem* self, gint token);
 139         gint (*get_pixel_height) (ModelTimeSystem* self, gint token);
 140         char* (*get_display_string) (ModelTimeSystem* self, gint token);
 141         gint (*frame_to_xsize) (ModelTimeSystem* self, gint frame);
 142         gint (*xsize_to_frame) (ModelTimeSystem* self, gint xsize);
 143         char* (*get_time_string) (ModelTimeSystem* self, gint64 time);
 144         char* (*get_time_duration) (ModelTimeSystem* self, gint64 time);
 145 };
 146
 147 struct _TransportDelegateIface {
 148         GTypeInterface parent_iface;
 149         gboolean (*is_playing) (TransportDelegate* self);
 150         gboolean (*is_recording) (TransportDelegate* self);
 151         gboolean (*is_stopped) (TransportDelegate* self);
 152 };
 153
 154 typedef enum  {
 155         CLIP_VIEW_MOTION_MODE_NONE,
 156         CLIP_VIEW_MOTION_MODE_DRAGGING,
 157         CLIP_VIEW_MOTION_MODE_LEFT_TRIM,
 158         CLIP_VIEW_MOTION_MODE_RIGHT_TRIM
 159 } ClipViewMotionMode;
 160
 161 struct _ClipViewPrivate {
 162         ModelTimeSystem* time_provider;
 163         TransportDelegate* transport_delegate;
 164         GdkColor color_black;
 165         GdkColor color_normal;
 166         GdkColor color_selected;
 167         gint drag_point;
 168         gint snap_amount;
 169         gboolean snapped;
 170         ClipViewMotionMode motion_mode;
 171         gboolean button_down;
 172         gboolean pending_selection;
 173 };
 174
 175 typedef enum  {
 176         MODEL_MEDIA_TYPE_AUDIO,
 177         MODEL_MEDIA_TYPE_VIDEO
 178 } ModelMediaType;
 179
 180 struct _ModelClip {
 181         GObject parent_instance;
 182         ModelClipPrivate * priv;
 183         ModelClipFile* clipfile;
 184         ModelMediaType type;
 185         gboolean is_recording;
 186         char* name;
 187 };
 188
 189 struct _ModelClipClass {
 190         GObjectClass parent_class;
 191 };
 192
 193 typedef enum  {
 194         LOGGING_FACILITY_SIGNAL_HANDLERS,
 195         LOGGING_FACILITY_DEVELOPER_WARNINGS,
 196         LOGGING_FACILITY_GRAPH,
 197         LOGGING_FACILITY_LOADING,
 198         LOGGING_FACILITY_IMPORT,
 199         LOGGING_FACILITY_SINGLEDECODEBIN
 200 } LoggingFacility;
 201
 202 typedef enum  {
 203         LOGGING_LEVEL_CRITICAL,
 204         LOGGING_LEVEL_HIGH,
 205         LOGGING_LEVEL_MEDIUM,
 206         LOGGING_LEVEL_LOW,
 207         LOGGING_LEVEL_INFO,
 208         LOGGING_LEVEL_VERBOSE
 209 } LoggingLevel;
 210
 211
 212 static gpointer gap_view_parent_class = NULL;
 213 extern GtkMenu* clip_view_context_menu;
 214 GtkMenu* clip_view_context_menu = NULL;
 215 static GdkCursor* clip_view_left_trim_cursor;
 216 static GdkCursor* clip_view_left_trim_cursor = NULL;
 217 static GdkCursor* clip_view_right_trim_cursor;
 218 static GdkCursor* clip_view_right_trim_cursor = NULL;
 219 static GdkCursor* clip_view_hand_cursor;
 220 static GdkCursor* clip_view_hand_cursor = NULL;
 221 static GdkCursor* clip_view_plus_cursor;
 222 static GdkCursor* clip_view_plus_cursor = NULL;
 223 static gpointer clip_view_parent_class = NULL;
 224
 225 GType gap_view_get_type (void);
 226 gpointer model_gap_ref (gpointer instance);
 227 void model_gap_unref (gpointer instance);
 228 GParamSpec* model_param_spec_gap (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);
 229 void model_value_set_gap (GValue* value, gpointer v_object);
 230 void model_value_take_gap (GValue* value, gpointer v_object);
 231 gpointer model_value_get_gap (const GValue* value);
 232 GType model_gap_get_type (void);
 233 #define GAP_VIEW_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), TYPE_GAP_VIEW, GapViewPrivate))
 234 enum  {
 235         GAP_VIEW_DUMMY_PROPERTY
 236 };
 237 ModelGap* model_gap_new (gint64 start, gint64 end);
 238 ModelGap* model_gap_construct (GType object_type, gint64 start, gint64 end);
 239 GapView* gap_view_new (gint64 start, gint64 length, gint width, gint height);
 240 GapView* gap_view_construct (GType object_type, gint64 start, gint64 length, gint width, gint height);
 241 void gap_view_remove (GapView* self);
 242 void gap_view_unselect (GapView* self);
 243 void draw_rounded_rectangle (GdkWindow* window, GdkColor* color, gboolean filled, gint x0, gint y0, gint width, gint height);
 244 static gboolean gap_view_real_expose_event (GtkWidget* base, GdkEventExpose* e);
 245 static void gap_view_finalize (GObject* obj);
 246 GType clip_view_get_type (void);
 247 GType model_clip_get_type (void);
 248 GType model_time_system_get_type (void);
 249 GType transport_delegate_get_type (void);
 250 static GType clip_view_motion_mode_get_type (void) G_GNUC_UNUSED;
 251 #define CLIP_VIEW_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), TYPE_CLIP_VIEW, ClipViewPrivate))
 252 enum  {
 253         CLIP_VIEW_DUMMY_PROPERTY
 254 };
 255 #define CLIP_VIEW_MIN_DRAG 5
 256 #define CLIP_VIEW_TRIM_WIDTH 10
 257 #define CLIP_VIEW_SNAP_DELTA 10
 258 void clip_view_on_clip_moved (ClipView* self, ModelClip* clip);
 259 static void _clip_view_on_clip_moved_model_clip_moved (ModelClip* _sender, ModelClip* clip, gpointer self);
 260 static void clip_view_on_clip_updated (ClipView* self);
 261 static void _clip_view_on_clip_updated_model_clip_updated (ModelClip* _sender, ModelClip* clip, gpointer self);
 262 static void clip_view_get_clip_colors (ClipView* self);
 263 void clip_view_adjust_size (ClipView* self, gint height);
 264 ClipView* clip_view_new (TransportDelegate* transport_delegate, ModelClip* clip, ModelTimeSystem* time_provider, gint height);
 265 ClipView* clip_view_construct (GType object_type, TransportDelegate* transport_delegate, ModelClip* clip, ModelTimeSystem* time_provider, gint height);
 266 GType model_clip_file_get_type (void);
 267 GType model_media_type_get_type (void);
 268 gboolean model_clip_file_is_online (ModelClipFile* self);
 269 GType logging_facility_get_type (void);
 270 GType logging_level_get_type (void);
 271 void logging_emit (GObject* object, LoggingFacility facility, LoggingLevel level, const char* message);
 272 gint model_time_system_time_to_xpos (ModelTimeSystem* self, gint64 time);
 273 gint64 model_clip_get_start (ModelClip* self);
 274 gint64 model_clip_get_duration (ModelClip* self);
 275 void clip_view_delete_clip (ClipView* self);
 276 gint64 model_clip_get_media_start (ModelClip* self);
 277 gint64 model_clip_file_get_length (ModelClipFile* self);
 278 void draw_left_rounded_rectangle (GdkWindow* window, GdkColor* color, gboolean filled, gint x0, gint y0, gint width, gint height);
 279 void draw_right_rounded_rectangle (GdkWindow* window, GdkColor* color, gboolean filled, gint x0, gint y0, gint width, gint height);
 280 void draw_square_rectangle (GdkWindow* window, GdkColor* color, gboolean filled, gint x, gint y, gint width, gint height);
 281 void clip_view_draw (ClipView* self);
 282 static gboolean clip_view_real_expose_event (GtkWidget* base, GdkEventExpose* event);
 283 gboolean transport_delegate_is_stopped (TransportDelegate* self);
 284 static gboolean clip_view_is_left_trim (ClipView* self, double x, double y);
 285 static gboolean clip_view_is_right_trim (ClipView* self, double x, double y);
 286 static gboolean clip_view_real_button_press_event (GtkWidget* base, GdkEventButton* event);
 287 gint64 model_time_system_xsize_to_time (ModelTimeSystem* self, gint x);
 288 static gboolean clip_view_real_button_release_event (GtkWidget* base, GdkEventButton* event);
 289 void model_clip_trim (ModelClip* self, gint64 delta, GdkWindowEdge edge);
 290 static gboolean clip_view_real_motion_notify_event (GtkWidget* base, GdkEventMotion* event);
 291 static gboolean clip_view_is_trim_height (ClipView* self, double y);
 292 void clip_view_select (ClipView* self);
 293 gint model_time_system_time_to_xsize (ModelTimeSystem* self, gint64 time);
 294 void clip_view_snap (ClipView* self, gint64 amount);
 295 static void clip_view_finalize (GObject* obj);
 296
 297
 298 static void g_cclosure_user_marshal_VOID__OBJECT_BOOLEAN (GClosure * closure, GValue * return_value, guint n_param_values, const GValue * param_values, gpointer invocation_hint, gpointer marshal_data);
 299 static void g_cclosure_user_marshal_VOID__OBJECT_INT64 (GClosure * closure, GValue * return_value, guint n_param_values, const GValue * param_values, gpointer invocation_hint, gpointer marshal_data);
 300 static void g_cclosure_user_marshal_VOID__OBJECT_ENUM (GClosure * closure, GValue * return_value, guint n_param_values, const GValue * param_values, gpointer invocation_hint, gpointer marshal_data);
 301
 302 #line 13 "ui_clip.vala"
 303 GapView* gap_view_construct (GType object_type, gint64 start, gint64 length, gint width, gint height) {
 304 #line 305 "ui_clip.c"
 305         GapView * self;
 306         ModelGap* _tmp0_;
 307         self = g_object_newv (object_type, 0, NULL);
 308 #line 15 "ui_clip.vala"
 309         self->gap = (_tmp0_ = model_gap_new (start, start + length), _model_gap_unref0 (self->gap), _tmp0_);
 310 #line 17 "ui_clip.vala"
 311         gdk_color_parse ("#777", &self->priv->fill_color);
 312 #line 19 "ui_clip.vala"
 313         GTK_WIDGET_SET_FLAGS (GTK_WIDGET (self), GTK_NO_WINDOW);
 314 #line 21 "ui_clip.vala"
 315         gtk_widget_set_size_request (GTK_WIDGET (self), width, height);
 316 #line 317 "ui_clip.c"
 317         return self;
 318 }
 319
 320
 321 #line 13 "ui_clip.vala"
 322 GapView* gap_view_new (gint64 start, gint64 length, gint width, gint height) {
 323 #line 13 "ui_clip.vala"
 324         return gap_view_construct (TYPE_GAP_VIEW, start, length, width, height);
 325 #line 326 "ui_clip.c"
 326 }
 327
 328
 329 #line 27 "ui_clip.vala"
 330 void gap_view_remove (GapView* self) {
 331 #line 27 "ui_clip.vala"
 332         g_return_if_fail (IS_GAP_VIEW (self));
 333 #line 28 "ui_clip.vala"
 334         g_signal_emit_by_name (self, "removed", self);
 335 #line 336 "ui_clip.c"
 336 }
 337
 338
 339 #line 31 "ui_clip.vala"
 340 void gap_view_unselect (GapView* self) {
 341 #line 31 "ui_clip.vala"
 342         g_return_if_fail (IS_GAP_VIEW (self));
 343 #line 32 "ui_clip.vala"
 344         g_signal_emit_by_name (self, "unselected", self);
 345 #line 346 "ui_clip.c"
 346 }
 347
 348
 349 #line 35 "ui_clip.vala"
 350 static gboolean gap_view_real_expose_event (GtkWidget* base, GdkEventExpose* e) {
 351 #line 352 "ui_clip.c"
 352         GapView * self;
 353         gboolean result = FALSE;
 354         self = GAP_VIEW (base);
 355 #line 36 "ui_clip.vala"
 356         draw_rounded_rectangle (GTK_WIDGET (self)->window, &self->priv->fill_color, TRUE, GTK_WIDGET (self)->allocation.x, GTK_WIDGET (self)->allocation.y, GTK_WIDGET (self)->allocation.width - 1, GTK_WIDGET (self)->allocation.height - 1);
 357 #line 358 "ui_clip.c"
 358         result = TRUE;
 359 #line 38 "ui_clip.vala"
 360         return result;
 361 #line 362 "ui_clip.c"
 362 }
 363
 364
 365 static void gap_view_class_init (GapViewClass * klass) {
 366         gap_view_parent_class = g_type_class_peek_parent (klass);
 367         g_type_class_add_private (klass, sizeof (GapViewPrivate));
 368         GTK_WIDGET_CLASS (klass)->expose_event = gap_view_real_expose_event;
 369         G_OBJECT_CLASS (klass)->finalize = gap_view_finalize;
 370         g_signal_new ("removed", TYPE_GAP_VIEW, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__OBJECT, G_TYPE_NONE, 1, TYPE_GAP_VIEW);
 371         g_signal_new ("unselected", TYPE_GAP_VIEW, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__OBJECT, G_TYPE_NONE, 1, TYPE_GAP_VIEW);
 372 }
 373
 374
 375 static void gap_view_instance_init (GapView * self) {
 376         self->priv = GAP_VIEW_GET_PRIVATE (self);
 377 }
 378
 379
 380 static void gap_view_finalize (GObject* obj) {
 381         GapView * self;
 382         self = GAP_VIEW (obj);
 383         _model_gap_unref0 (self->gap);
 384         G_OBJECT_CLASS (gap_view_parent_class)->finalize (obj);
 385 }
 386
 387
 388 GType gap_view_get_type (void) {
 389         static volatile gsize gap_view_type_id__volatile = 0;
 390         if (g_once_init_enter (&gap_view_type_id__volatile)) {
 391                 static const GTypeInfo g_define_type_info = { sizeof (GapViewClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) gap_view_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (GapView), 0, (GInstanceInitFunc) gap_view_instance_init, NULL };
 392                 GType gap_view_type_id;
 393                 gap_view_type_id = g_type_register_static (GTK_TYPE_DRAWING_AREA, "GapView", &g_define_type_info, 0);
 394                 g_once_init_leave (&gap_view_type_id__volatile, gap_view_type_id);
 395         }
 396         return gap_view_type_id__volatile;
 397 }
 398
 399
 400 static GType clip_view_motion_mode_get_type (void) {
 401         static volatile gsize clip_view_motion_mode_type_id__volatile = 0;
 402         if (g_once_init_enter (&clip_view_motion_mode_type_id__volatile)) {
 403                 static const GEnumValue values[] = {{CLIP_VIEW_MOTION_MODE_NONE, "CLIP_VIEW_MOTION_MODE_NONE", "none"}, {CLIP_VIEW_MOTION_MODE_DRAGGING, "CLIP_VIEW_MOTION_MODE_DRAGGING", "dragging"}, {CLIP_VIEW_MOTION_MODE_LEFT_TRIM, "CLIP_VIEW_MOTION_MODE_LEFT_TRIM", "left-trim"}, {CLIP_VIEW_MOTION_MODE_RIGHT_TRIM, "CLIP_VIEW_MOTION_MODE_RIGHT_TRIM", "right-trim"}, {0, NULL, NULL}};
 404                 GType clip_view_motion_mode_type_id;
 405                 clip_view_motion_mode_type_id = g_enum_register_static ("ClipViewMotionMode", values);
 406                 g_once_init_leave (&clip_view_motion_mode_type_id__volatile, clip_view_motion_mode_type_id);
 407         }
 408         return clip_view_motion_mode_type_id__volatile;
 409 }
 410
 411
 412 static gpointer _g_object_ref0 (gpointer self) {
 413         return self ? g_object_ref (self) : NULL;
 414 }
 415
 416
 417 #line 132 "ui_clip.vala"
 418 static void _clip_view_on_clip_moved_model_clip_moved (ModelClip* _sender, ModelClip* clip, gpointer self) {
 419 #line 420 "ui_clip.c"
 420         clip_view_on_clip_moved (self, clip);
 421 }
 422
 423
 424 #line 117 "ui_clip.vala"
 425 static void _clip_view_on_clip_updated_model_clip_updated (ModelClip* _sender, ModelClip* clip, gpointer self) {
 426 #line 427 "ui_clip.c"
 427         clip_view_on_clip_updated (self);
 428 }
 429
 430
 431 #line 86 "ui_clip.vala"
 432 ClipView* clip_view_construct (GType object_type, TransportDelegate* transport_delegate, ModelClip* clip, ModelTimeSystem* time_provider, gint height) {
 433 #line 434 "ui_clip.c"
 434         ClipView * self;
 435         TransportDelegate* _tmp0_;
 436         ModelClip* _tmp1_;
 437 #line 86 "ui_clip.vala"
 438         g_return_val_if_fail (IS_TRANSPORT_DELEGATE (transport_delegate), NULL);
 439 #line 86 "ui_clip.vala"
 440         g_return_val_if_fail (MODEL_IS_CLIP (clip), NULL);
 441 #line 86 "ui_clip.vala"
 442         g_return_val_if_fail (MODEL_IS_TIME_SYSTEM (time_provider), NULL);
 443 #line 444 "ui_clip.c"
 444         self = g_object_newv (object_type, 0, NULL);
 445 #line 88 "ui_clip.vala"
 446         self->priv->transport_delegate = (_tmp0_ = _g_object_ref0 (transport_delegate), _g_object_unref0 (self->priv->transport_delegate), _tmp0_);
 447 #line 89 "ui_clip.vala"
 448         self->clip = (_tmp1_ = _g_object_ref0 (clip), _g_object_unref0 (self->clip), _tmp1_);
 449 #line 90 "ui_clip.vala"
 450         self->priv->time_provider = time_provider;
 451 #line 91 "ui_clip.vala"
 452         self->height = height;
 453 #line 92 "ui_clip.vala"
 454         self->is_selected = FALSE;
 455 #line 94 "ui_clip.vala"
 456         g_signal_connect_object (clip, "moved", (GCallback) _clip_view_on_clip_moved_model_clip_moved, self, 0);
 457 #line 95 "ui_clip.vala"
 458         g_signal_connect_object (clip, "updated", (GCallback) _clip_view_on_clip_updated_model_clip_updated, self, 0);
 459 #line 97 "ui_clip.vala"
 460         gdk_color_parse ("000", &self->priv->color_black);
 461 #line 98 "ui_clip.vala"
 462         clip_view_get_clip_colors (self);
 463 #line 100 "ui_clip.vala"
 464         GTK_WIDGET_SET_FLAGS (GTK_WIDGET (self), GTK_NO_WINDOW);
 465 #line 102 "ui_clip.vala"
 466         clip_view_adjust_size (self, height);
 467 #line 468 "ui_clip.c"
 468         return self;
 469 }
 470
 471
 472 #line 86 "ui_clip.vala"
 473 ClipView* clip_view_new (TransportDelegate* transport_delegate, ModelClip* clip, ModelTimeSystem* time_provider, gint height) {
 474 #line 86 "ui_clip.vala"
 475         return clip_view_construct (TYPE_CLIP_VIEW, transport_delegate, clip, time_provider, height);
 476 #line 477 "ui_clip.c"
 477 }
 478
 479
 480 #line 105 "ui_clip.vala"
 481 static void clip_view_get_clip_colors (ClipView* self) {
 482 #line 105 "ui_clip.vala"
 483         g_return_if_fail (IS_CLIP_VIEW (self));
 484 #line 106 "ui_clip.vala"
 485         if (model_clip_file_is_online (self->clip->clipfile)) {
 486 #line 487 "ui_clip.c"
 487                 const char* _tmp0_;
 488                 const char* _tmp1_;
 489                 _tmp0_ = NULL;
 490 #line 107 "ui_clip.vala"
 491                 if (self->clip->type == MODEL_MEDIA_TYPE_VIDEO) {
 492 #line 107 "ui_clip.vala"
 493                         _tmp0_ = "#d82";
 494 #line 495 "ui_clip.c"
 495                 } else {
 496 #line 107 "ui_clip.vala"
 497                         _tmp0_ = "#84a";
 498 #line 499 "ui_clip.c"
 499                 }
 500 #line 107 "ui_clip.vala"
 501                 gdk_color_parse (_tmp0_, &self->priv->color_selected);
 502 #line 503 "ui_clip.c"
 503                 _tmp1_ = NULL;
 504 #line 109 "ui_clip.vala"
 505                 if (self->clip->type == MODEL_MEDIA_TYPE_VIDEO) {
 506 #line 109 "ui_clip.vala"
 507                         _tmp1_ = "#da5";
 508 #line 509 "ui_clip.c"
 509                 } else {
 510 #line 109 "ui_clip.vala"
 511                         _tmp1_ = "#b9d";
 512 #line 513 "ui_clip.c"
 513                 }
 514 #line 109 "ui_clip.vala"
 515                 gdk_color_parse (_tmp1_, &self->priv->color_normal);
 516 #line 517 "ui_clip.c"
 517         } else {
 518 #line 112 "ui_clip.vala"
 519                 gdk_color_parse ("red", &self->priv->color_selected);
 520 #line 113 "ui_clip.vala"
 521                 gdk_color_parse ("#AA0000", &self->priv->color_normal);
 522 #line 523 "ui_clip.c"
 523         }
 524 }
 525
 526
 527 #line 117 "ui_clip.vala"
 528 static void clip_view_on_clip_updated (ClipView* self) {
 529 #line 117 "ui_clip.vala"
 530         g_return_if_fail (IS_CLIP_VIEW (self));
 531 #line 118 "ui_clip.vala"
 532         logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_clip_updated");
 533 #line 119 "ui_clip.vala"
 534         clip_view_get_clip_colors (self);
 535 #line 120 "ui_clip.vala"
 536         gtk_widget_queue_draw (GTK_WIDGET (self));
 537 #line 538 "ui_clip.c"
 538 }
 539
 540
 541 #line 126 "ui_clip.vala"
 542 void clip_view_adjust_size (ClipView* self, gint height) {
 543 #line 544 "ui_clip.c"
 544         gint width;
 545 #line 126 "ui_clip.vala"
 546         g_return_if_fail (IS_CLIP_VIEW (self));
 547 #line 127 "ui_clip.vala"
 548         width = model_time_system_time_to_xpos (self->priv->time_provider, model_clip_get_start (self->clip) + model_clip_get_duration (self->clip)) - model_time_system_time_to_xpos (self->priv->time_provider, model_clip_get_start (self->clip));
 549 #line 129 "ui_clip.vala"
 550         gtk_widget_set_size_request (GTK_WIDGET (self), width + 1, height);
 551 #line 552 "ui_clip.c"
 552 }
 553
 554
 555 #line 132 "ui_clip.vala"
 556 void clip_view_on_clip_moved (ClipView* self, ModelClip* clip) {
 557 #line 132 "ui_clip.vala"
 558         g_return_if_fail (IS_CLIP_VIEW (self));
 559 #line 132 "ui_clip.vala"
 560         g_return_if_fail (MODEL_IS_CLIP (clip));
 561 #line 133 "ui_clip.vala"
 562         logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_clip_moved");
 563 #line 134 "ui_clip.vala"
 564         clip_view_adjust_size (self, self->height);
 565 #line 135 "ui_clip.vala"
 566         g_signal_emit_by_name (self, "clip-moved", self);
 567 #line 568 "ui_clip.c"
 568 }
 569
 570
 571 #line 138 "ui_clip.vala"
 572 void clip_view_delete_clip (ClipView* self) {
 573 #line 138 "ui_clip.vala"
 574         g_return_if_fail (IS_CLIP_VIEW (self));
 575 #line 139 "ui_clip.vala"
 576         g_signal_emit_by_name (self, "clip-deleted", self->clip);
 577 #line 578 "ui_clip.c"
 578 }
 579
 580
 581 #line 142 "ui_clip.vala"
 582 void clip_view_draw (ClipView* self) {
 583 #line 584 "ui_clip.c"
 584         GdkColor _tmp0_ = {0};
 585         GdkColor fill;
 586         gboolean _tmp1_ = FALSE;
 587         gboolean left_trimmed;
 588         gboolean _tmp2_ = FALSE;
 589         gboolean right_trimmed;
 590         gboolean _tmp3_ = FALSE;
 591         GdkGC* gc;
 592         GdkRectangle _tmp6_ = {0};
 593         GdkRectangle r;
 594         PangoLayout* layout;
 595         gint width = 0;
 596         gint height = 0;
 597 #line 142 "ui_clip.vala"
 598         g_return_if_fail (IS_CLIP_VIEW (self));
 599 #line 143 "ui_clip.vala"
 600         if (self->is_selected) {
 601 #line 143 "ui_clip.vala"
 602                 _tmp0_ = self->priv->color_selected;
 603 #line 604 "ui_clip.c"
 604         } else {
 605 #line 143 "ui_clip.vala"
 606                 _tmp0_ = self->priv->color_normal;
 607 #line 608 "ui_clip.c"
 608         }
 609 #line 143 "ui_clip.vala"
 610         fill = _tmp0_;
 611 #line 145 "ui_clip.vala"
 612         if (model_clip_get_media_start (self->clip) != 0) {
 613 #line 145 "ui_clip.vala"
 614                 _tmp1_ = !self->clip->is_recording;
 615 #line 616 "ui_clip.c"
 616         } else {
 617 #line 145 "ui_clip.vala"
 618                 _tmp1_ = FALSE;
 619 #line 620 "ui_clip.c"
 620         }
 621 #line 145 "ui_clip.vala"
 622         left_trimmed = _tmp1_;
 623 #line 147 "ui_clip.vala"
 624         if (model_clip_file_is_online (self->clip->clipfile)) {
 625 #line 148 "ui_clip.vala"
 626                 _tmp2_ = (model_clip_get_media_start (self->clip) + model_clip_get_duration (self->clip)) != model_clip_file_get_length (self->clip->clipfile);
 627 #line 628 "ui_clip.c"
 628         } else {
 629 #line 148 "ui_clip.vala"
 630                 _tmp2_ = FALSE;
 631 #line 632 "ui_clip.c"
 632         }
 633 #line 147 "ui_clip.vala"
 634         right_trimmed = _tmp2_;
 635 #line 150 "ui_clip.vala"
 636         if (!left_trimmed) {
 637 #line 150 "ui_clip.vala"
 638                 _tmp3_ = !right_trimmed;
 639 #line 640 "ui_clip.c"
 640         } else {
 641 #line 150 "ui_clip.vala"
 642                 _tmp3_ = FALSE;
 643 #line 644 "ui_clip.c"
 644         }
 645 #line 150 "ui_clip.vala"
 646         if (_tmp3_) {
 647 #line 151 "ui_clip.vala"
 648                 draw_rounded_rectangle (GTK_WIDGET (self)->window, &fill, TRUE, GTK_WIDGET (self)->allocation.x + 1, GTK_WIDGET (self)->allocation.y + 1, GTK_WIDGET (self)->allocation.width - 2, GTK_WIDGET (self)->allocation.height - 2);
 649 #line 153 "ui_clip.vala"
 650                 draw_rounded_rectangle (GTK_WIDGET (self)->window, &self->priv->color_black, FALSE, GTK_WIDGET (self)->allocation.x, GTK_WIDGET (self)->allocation.y, GTK_WIDGET (self)->allocation.width - 1, GTK_WIDGET (self)->allocation.height - 1);
 651 #line 652 "ui_clip.c"
 652         } else {
 653                 gboolean _tmp4_ = FALSE;
 654 #line 156 "ui_clip.vala"
 655                 if (!left_trimmed) {
 656 #line 156 "ui_clip.vala"
 657                         _tmp4_ = right_trimmed;
 658 #line 659 "ui_clip.c"
 659                 } else {
 660 #line 156 "ui_clip.vala"
 661                         _tmp4_ = FALSE;
 662 #line 663 "ui_clip.c"
 663                 }
 664 #line 156 "ui_clip.vala"
 665                 if (_tmp4_) {
 666 #line 157 "ui_clip.vala"
 667                         draw_left_rounded_rectangle (GTK_WIDGET (self)->window, &fill, TRUE, GTK_WIDGET (self)->allocation.x + 1, GTK_WIDGET (self)->allocation.y + 1, GTK_WIDGET (self)->allocation.width - 2, GTK_WIDGET (self)->allocation.height - 2);
 668 #line 159 "ui_clip.vala"
 669                         draw_left_rounded_rectangle (GTK_WIDGET (self)->window, &self->priv->color_black, FALSE, GTK_WIDGET (self)->allocation.x, GTK_WIDGET (self)->allocation.y, GTK_WIDGET (self)->allocation.width - 1, GTK_WIDGET (self)->allocation.height - 1);
 670 #line 671 "ui_clip.c"
 671                 } else {
 672                         gboolean _tmp5_ = FALSE;
 673 #line 162 "ui_clip.vala"
 674                         if (left_trimmed) {
 675 #line 162 "ui_clip.vala"
 676                                 _tmp5_ = !right_trimmed;
 677 #line 678 "ui_clip.c"
 678                         } else {
 679 #line 162 "ui_clip.vala"
 680                                 _tmp5_ = FALSE;
 681 #line 682 "ui_clip.c"
 682                         }
 683 #line 162 "ui_clip.vala"
 684                         if (_tmp5_) {
 685 #line 163 "ui_clip.vala"
 686                                 draw_right_rounded_rectangle (GTK_WIDGET (self)->window, &fill, TRUE, GTK_WIDGET (self)->allocation.x + 1, GTK_WIDGET (self)->allocation.y + 1, GTK_WIDGET (self)->allocation.width - 2, GTK_WIDGET (self)->allocation.height - 2);
 687 #line 165 "ui_clip.vala"
 688                                 draw_right_rounded_rectangle (GTK_WIDGET (self)->window, &self->priv->color_black, FALSE, GTK_WIDGET (self)->allocation.x, GTK_WIDGET (self)->allocation.y, GTK_WIDGET (self)->allocation.width - 1, GTK_WIDGET (self)->allocation.height - 1);
 689 #line 690 "ui_clip.c"
 690                         } else {
 691 #line 169 "ui_clip.vala"
 692                                 draw_square_rectangle (GTK_WIDGET (self)->window, &fill, TRUE, GTK_WIDGET (self)->allocation.x + 1, GTK_WIDGET (self)->allocation.y + 1, GTK_WIDGET (self)->allocation.width - 2, GTK_WIDGET (self)->allocation.height - 2);
 693 #line 171 "ui_clip.vala"
 694                                 draw_square_rectangle (GTK_WIDGET (self)->window, &self->priv->color_black, FALSE, GTK_WIDGET (self)->allocation.x, GTK_WIDGET (self)->allocation.y, GTK_WIDGET (self)->allocation.width - 1, GTK_WIDGET (self)->allocation.height - 1);
 695 #line 696 "ui_clip.c"
 696                         }
 697                 }
 698         }
 699 #line 175 "ui_clip.vala"
 700         gc = gdk_gc_new (GDK_DRAWABLE (GTK_WIDGET (self)->window));
 701 #line 176 "ui_clip.vala"
 702         r = (_tmp6_.x = 0, _tmp6_.y = 0, _tmp6_.width = 0, _tmp6_.height = 0, _tmp6_);
 703 #line 179 "ui_clip.vala"
 704         r.x = GTK_WIDGET (self)->allocation.x;
 705 #line 180 "ui_clip.vala"
 706         r.y = GTK_WIDGET (self)->allocation.y;
 707 #line 181 "ui_clip.vala"
 708         r.width = GTK_WIDGET (self)->allocation.width;
 709 #line 182 "ui_clip.vala"
 710         r.height = GTK_WIDGET (self)->allocation.height;
 711 #line 184 "ui_clip.vala"
 712         gdk_gc_set_clip_rectangle (gc, &r);
 713 #line 714 "ui_clip.c"
 714         layout = NULL;
 715 #line 187 "ui_clip.vala"
 716         if (self->clip->is_recording) {
 717 #line 718 "ui_clip.c"
 718                 PangoLayout* _tmp7_;
 719 #line 188 "ui_clip.vala"
 720                 layout = (_tmp7_ = gtk_widget_create_pango_layout (GTK_WIDGET (self), "Recording"), _g_object_unref0 (layout), _tmp7_);
 721 #line 722 "ui_clip.c"
 722         } else {
 723 #line 189 "ui_clip.vala"
 724                 if (!model_clip_file_is_online (self->clip->clipfile)) {
 725 #line 726 "ui_clip.c"
 726                         PangoLayout* _tmp9_;
 727                         char* _tmp8_;
 728 #line 190 "ui_clip.vala"
 729                         layout = (_tmp9_ = gtk_widget_create_pango_layout (GTK_WIDGET (self), _tmp8_ = g_strdup_printf ("%s (Offline)", self->clip->name)), _g_object_unref0 (layout), _tmp9_);
 730 #line 731 "ui_clip.c"
 731                         _g_free0 (_tmp8_);
 732                 } else {
 733                         PangoLayout* _tmp11_;
 734                         char* _tmp10_;
 735 #line 193 "ui_clip.vala"
 736                         layout = (_tmp11_ = gtk_widget_create_pango_layout (GTK_WIDGET (self), _tmp10_ = g_strdup_printf ("%s", self->clip->name)), _g_object_unref0 (layout), _tmp11_);
 737 #line 738 "ui_clip.c"
 738                         _g_free0 (_tmp10_);
 739                 }
 740         }
 741 #line 196 "ui_clip.vala"
 742         pango_layout_get_pixel_size (layout, &width, &height);
 743 #line 197 "ui_clip.vala"
 744         gdk_draw_layout (GDK_DRAWABLE (GTK_WIDGET (self)->window), gc, GTK_WIDGET (self)->allocation.x + 10, GTK_WIDGET (self)->allocation.y + height, layout);
 745 #line 746 "ui_clip.c"
 746         _g_object_unref0 (gc);
 747         _g_object_unref0 (layout);
 748 }
 749
 750
 751 #line 200 "ui_clip.vala"
 752 static gboolean clip_view_real_expose_event (GtkWidget* base, GdkEventExpose* event) {
 753 #line 754 "ui_clip.c"
 754         ClipView * self;
 755         gboolean result = FALSE;
 756         self = CLIP_VIEW (base);
 757 #line 201 "ui_clip.vala"
 758         clip_view_draw (self);
 759 #line 760 "ui_clip.c"
 760         result = TRUE;
 761 #line 202 "ui_clip.vala"
 762         return result;
 763 #line 764 "ui_clip.c"
 764 }
 765
 766
 767 #line 205 "ui_clip.vala"
 768 static gboolean clip_view_real_button_press_event (GtkWidget* base, GdkEventButton* event) {
 769 #line 770 "ui_clip.c"
 770         ClipView * self;
 771         gboolean result = FALSE;
 772         gboolean primary_press;
 773         gboolean extend_selection;
 774         self = CLIP_VIEW (base);
 775 #line 206 "ui_clip.vala"
 776         if (!transport_delegate_is_stopped (self->priv->transport_delegate)) {
 777 #line 778 "ui_clip.c"
 778                 result = TRUE;
 779 #line 207 "ui_clip.vala"
 780                 return result;
 781 #line 782 "ui_clip.c"
 782         }
 783 #line 210 "ui_clip.vala"
 784         (*event).x = (*event).x - ((double) GTK_WIDGET (self)->allocation.x);
 785 #line 211 "ui_clip.vala"
 786         primary_press = (*event).button == 1;
 787 #line 212 "ui_clip.vala"
 788         if (primary_press) {
 789 #line 213 "ui_clip.vala"
 790                 self->priv->button_down = TRUE;
 791 #line 214 "ui_clip.vala"
 792                 self->priv->drag_point = (gint) (*event).x;
 793 #line 215 "ui_clip.vala"
 794                 self->priv->snap_amount = 0;
 795 #line 216 "ui_clip.vala"
 796                 self->priv->snapped = FALSE;
 797 #line 798 "ui_clip.c"
 798         }
 799 #line 219 "ui_clip.vala"
 800         extend_selection = ((*event).state & GDK_CONTROL_MASK) != 0;
 801 #line 223 "ui_clip.vala"
 802         if (clip_view_is_left_trim (self, (*event).x, (*event).y)) {
 803 #line 224 "ui_clip.vala"
 804                 g_signal_emit_by_name (self, "selection-request", self, FALSE);
 805 #line 225 "ui_clip.vala"
 806                 if (primary_press) {
 807 #line 226 "ui_clip.vala"
 808                         g_signal_emit_by_name (self, "trim-begin", self, GDK_WINDOW_EDGE_WEST);
 809 #line 227 "ui_clip.vala"
 810                         self->priv->motion_mode = CLIP_VIEW_MOTION_MODE_LEFT_TRIM;
 811 #line 812 "ui_clip.c"
 812                 }
 813         } else {
 814 #line 229 "ui_clip.vala"
 815                 if (clip_view_is_right_trim (self, (*event).x, (*event).y)) {
 816 #line 230 "ui_clip.vala"
 817                         g_signal_emit_by_name (self, "selection-request", self, FALSE);
 818 #line 231 "ui_clip.vala"
 819                         if (primary_press) {
 820 #line 232 "ui_clip.vala"
 821                                 g_signal_emit_by_name (self, "trim-begin", self, GDK_WINDOW_EDGE_EAST);
 822 #line 233 "ui_clip.vala"
 823                                 self->priv->motion_mode = CLIP_VIEW_MOTION_MODE_RIGHT_TRIM;
 824 #line 825 "ui_clip.c"
 825                         }
 826                 } else {
 827 #line 236 "ui_clip.vala"
 828                         if (!self->is_selected) {
 829 #line 237 "ui_clip.vala"
 830                                 self->priv->pending_selection = FALSE;
 831 #line 238 "ui_clip.vala"
 832                                 g_signal_emit_by_name (self, "selection-request", self, extend_selection);
 833 #line 834 "ui_clip.c"
 834                         } else {
 835 #line 240 "ui_clip.vala"
 836                                 self->priv->pending_selection = TRUE;
 837 #line 838 "ui_clip.c"
 838                         }
 839                 }
 840         }
 841 #line 244 "ui_clip.vala"
 842         if ((*event).button == 3) {
 843 #line 245 "ui_clip.vala"
 844                 gtk_menu_shell_select_first (GTK_MENU_SHELL (clip_view_context_menu), TRUE);
 845 #line 246 "ui_clip.vala"
 846                 gtk_menu_popup (clip_view_context_menu, NULL, NULL, NULL, NULL, (*event).button, (*event).time);
 847 #line 848 "ui_clip.c"
 848         } else {
 849 #line 248 "ui_clip.vala"
 850                 gtk_menu_popdown (clip_view_context_menu);
 851 #line 852 "ui_clip.c"
 852         }
 853         result = TRUE;
 854 #line 251 "ui_clip.vala"
 855         return result;
 856 #line 857 "ui_clip.c"
 857 }
 858
 859
 860 #line 254 "ui_clip.vala"
 861 static gboolean clip_view_real_button_release_event (GtkWidget* base, GdkEventButton* event) {
 862 #line 863 "ui_clip.c"
 863         ClipView * self;
 864         gboolean result = FALSE;
 865         self = CLIP_VIEW (base);
 866 #line 255 "ui_clip.vala"
 867         if (!transport_delegate_is_stopped (self->priv->transport_delegate)) {
 868 #line 869 "ui_clip.c"
 869                 result = TRUE;
 870 #line 256 "ui_clip.vala"
 871                 return result;
 872 #line 873 "ui_clip.c"
 873         }
 874 #line 259 "ui_clip.vala"
 875         (*event).x = (*event).x - ((double) GTK_WIDGET (self)->allocation.x);
 876 #line 260 "ui_clip.vala"
 877         self->priv->button_down = FALSE;
 878 #line 261 "ui_clip.vala"
 879         if ((*event).button == 1) {
 880 #line 262 "ui_clip.vala"
 881                 switch (self->priv->motion_mode) {
 882 #line 883 "ui_clip.c"
 883                         case CLIP_VIEW_MOTION_MODE_NONE:
 884                         {
 885                                 {
 886 #line 264 "ui_clip.vala"
 887                                         if (self->priv->pending_selection) {
 888 #line 265 "ui_clip.vala"
 889                                                 g_signal_emit_by_name (self, "selection-request", self, TRUE);
 890 #line 891 "ui_clip.c"
 891                                         }
 892                                 }
 893 #line 268 "ui_clip.vala"
 894                                 break;
 895 #line 896 "ui_clip.c"
 896                         }
 897                         case CLIP_VIEW_MOTION_MODE_DRAGGING:
 898                         {
 899                                 {
 900                                         gint64 delta;
 901 #line 270 "ui_clip.vala"
 902                                         delta = model_time_system_xsize_to_time (self->priv->time_provider, ((gint) (*event).x) - self->priv->drag_point);
 903 #line 271 "ui_clip.vala"
 904                                         if (self->priv->motion_mode == CLIP_VIEW_MOTION_MODE_DRAGGING) {
 905 #line 272 "ui_clip.vala"
 906                                                 g_signal_emit_by_name (self, "move-commit", self, delta);
 907 #line 908 "ui_clip.c"
 908                                         }
 909                                 }
 910 #line 275 "ui_clip.vala"
 911                                 break;
 912 #line 913 "ui_clip.c"
 913                         }
 914                         case CLIP_VIEW_MOTION_MODE_LEFT_TRIM:
 915                         {
 916 #line 277 "ui_clip.vala"
 917                                 g_signal_emit_by_name (self, "trim-commit", self, GDK_WINDOW_EDGE_WEST);
 918 #line 278 "ui_clip.vala"
 919                                 break;
 920 #line 921 "ui_clip.c"
 921                         }
 922                         case CLIP_VIEW_MOTION_MODE_RIGHT_TRIM:
 923                         {
 924 #line 280 "ui_clip.vala"
 925                                 g_signal_emit_by_name (self, "trim-commit", self, GDK_WINDOW_EDGE_EAST);
 926 #line 281 "ui_clip.vala"
 927                                 break;
 928 #line 929 "ui_clip.c"
 929                         }
 930                 }
 931         }
 932 #line 284 "ui_clip.vala"
 933         self->priv->motion_mode = CLIP_VIEW_MOTION_MODE_NONE;
 934 #line 935 "ui_clip.c"
 935         result = TRUE;
 936 #line 285 "ui_clip.vala"
 937         return result;
 938 #line 939 "ui_clip.c"
 939 }
 940
 941
 942 #line 288 "ui_clip.vala"
 943 static gboolean clip_view_real_motion_notify_event (GtkWidget* base, GdkEventMotion* event) {
 944 #line 945 "ui_clip.c"
 945         ClipView * self;
 946         gboolean result = FALSE;
 947         gint delta_pixels;
 948         gint64 delta_time;
 949         self = CLIP_VIEW (base);
 950 #line 289 "ui_clip.vala"
 951         if (!transport_delegate_is_stopped (self->priv->transport_delegate)) {
 952 #line 953 "ui_clip.c"
 953                 result = TRUE;
 954 #line 290 "ui_clip.vala"
 955                 return result;
 956 #line 957 "ui_clip.c"
 957         }
 958 #line 293 "ui_clip.vala"
 959         (*event).x = (*event).x - ((double) GTK_WIDGET (self)->allocation.x);
 960 #line 294 "ui_clip.vala"
 961         delta_pixels = ((gint) ((*event).x - self->priv->drag_point)) - self->priv->snap_amount;
 962 #line 295 "ui_clip.vala"
 963         if (self->priv->snapped) {
 964 #line 296 "ui_clip.vala"
 965                 self->priv->snap_amount = self->priv->snap_amount + delta_pixels;
 966 #line 297 "ui_clip.vala"
 967                 if (abs (self->priv->snap_amount) < CLIP_VIEW_SNAP_DELTA) {
 968 #line 969 "ui_clip.c"
 969                         result = TRUE;
 970 #line 298 "ui_clip.vala"
 971                         return result;
 972 #line 973 "ui_clip.c"
 973                 }
 974 #line 300 "ui_clip.vala"
 975                 delta_pixels = delta_pixels + self->priv->snap_amount;
 976 #line 301 "ui_clip.vala"
 977                 self->priv->snap_amount = 0;
 978 #line 302 "ui_clip.vala"
 979                 self->priv->snapped = FALSE;
 980 #line 981 "ui_clip.c"
 981         }
 982 #line 305 "ui_clip.vala"
 983         delta_time = model_time_system_xsize_to_time (self->priv->time_provider, delta_pixels);
 984 #line 307 "ui_clip.vala"
 985         switch (self->priv->motion_mode) {
 986 #line 987 "ui_clip.c"
 987                 case CLIP_VIEW_MOTION_MODE_NONE:
 988                 {
 989                         gboolean _tmp0_ = FALSE;
 990 #line 309 "ui_clip.vala"
 991                         if (!self->priv->button_down) {
 992 #line 309 "ui_clip.vala"
 993                                 _tmp0_ = clip_view_is_left_trim (self, (*event).x, (*event).y);
 994 #line 995 "ui_clip.c"
 995                         } else {
 996 #line 309 "ui_clip.vala"
 997                                 _tmp0_ = FALSE;
 998 #line 999 "ui_clip.c"
 999                         }
1000 #line 309 "ui_clip.vala"
1001                         if (_tmp0_) {
1002 #line 310 "ui_clip.vala"
1003                                 gdk_window_set_cursor (GTK_WIDGET (self)->window, clip_view_left_trim_cursor);
1004 #line 1005 "ui_clip.c"
1005                         } else {
1006                                 gboolean _tmp1_ = FALSE;
1007 #line 311 "ui_clip.vala"
1008                                 if (!self->priv->button_down) {
1009 #line 311 "ui_clip.vala"
1010                                         _tmp1_ = clip_view_is_right_trim (self, (*event).x, (*event).y);
1011 #line 1012 "ui_clip.c"
1012                                 } else {
1013 #line 311 "ui_clip.vala"
1014                                         _tmp1_ = FALSE;
1015 #line 1016 "ui_clip.c"
1016                                 }
1017 #line 311 "ui_clip.vala"
1018                                 if (_tmp1_) {
1019 #line 312 "ui_clip.vala"
1020                                         gdk_window_set_cursor (GTK_WIDGET (self)->window, clip_view_right_trim_cursor);
1021 #line 1022 "ui_clip.c"
1022                                 } else {
1023                                         gboolean _tmp2_ = FALSE;
1024 #line 313 "ui_clip.vala"
1025                                         if (self->is_selected) {
1026 #line 313 "ui_clip.vala"
1027                                                 _tmp2_ = self->priv->button_down;
1028 #line 1029 "ui_clip.c"
1029                                         } else {
1030 #line 313 "ui_clip.vala"
1031                                                 _tmp2_ = FALSE;
1032 #line 1033 "ui_clip.c"
1033                                         }
1034 #line 313 "ui_clip.vala"
1035                                         if (_tmp2_) {
1036 #line 314 "ui_clip.vala"
1037                                                 if (abs (delta_pixels) > CLIP_VIEW_MIN_DRAG) {
1038 #line 1039 "ui_clip.c"
1039                                                         gboolean do_copy;
1040 #line 315 "ui_clip.vala"
1041                                                         do_copy = ((*event).state & GDK_CONTROL_MASK) != 0;
1042 #line 316 "ui_clip.vala"
1043                                                         if (do_copy) {
1044 #line 317 "ui_clip.vala"
1045                                                                 gdk_window_set_cursor (GTK_WIDGET (self)->window, clip_view_plus_cursor);
1046 #line 1047 "ui_clip.c"
1047                                                         } else {
1048 #line 319 "ui_clip.vala"
1049                                                                 gdk_window_set_cursor (GTK_WIDGET (self)->window, clip_view_hand_cursor);
1050 #line 1051 "ui_clip.c"
1051                                                         }
1052 #line 321 "ui_clip.vala"
1053                                                         self->priv->motion_mode = CLIP_VIEW_MOTION_MODE_DRAGGING;
1054 #line 322 "ui_clip.vala"
1055                                                         g_signal_emit_by_name (self, "move-begin", self, do_copy);
1056 #line 1057 "ui_clip.c"
1057                                                 }
1058                                         } else {
1059 #line 325 "ui_clip.vala"
1060                                                 gdk_window_set_cursor (GTK_WIDGET (self)->window, NULL);
1061 #line 1062 "ui_clip.c"
1062                                         }
1063                                 }
1064                         }
1065 #line 327 "ui_clip.vala"
1066                         break;
1067 #line 1068 "ui_clip.c"
1068                 }
1069                 case CLIP_VIEW_MOTION_MODE_RIGHT_TRIM:
1070                 case CLIP_VIEW_MOTION_MODE_LEFT_TRIM:
1071                 {
1072 #line 330 "ui_clip.vala"
1073                         if (self->priv->button_down) {
1074 #line 331 "ui_clip.vala"
1075                                 if (self->priv->motion_mode == CLIP_VIEW_MOTION_MODE_LEFT_TRIM) {
1076 #line 332 "ui_clip.vala"
1077                                         model_clip_trim (self->clip, delta_time, GDK_WINDOW_EDGE_WEST);
1078 #line 1079 "ui_clip.c"
1079                                 } else {
1080                                         gint64 duration;
1081 #line 334 "ui_clip.vala"
1082                                         duration = model_clip_get_duration (self->clip);
1083 #line 335 "ui_clip.vala"
1084                                         model_clip_trim (self->clip, delta_time, GDK_WINDOW_EDGE_EAST);
1085 #line 336 "ui_clip.vala"
1086                                         if (duration != model_clip_get_duration (self->clip)) {
1087 #line 337 "ui_clip.vala"
1088                                                 self->priv->drag_point = self->priv->drag_point + ((gint) delta_pixels);
1089 #line 1090 "ui_clip.c"
1090                                         }
1091                                 }
1092                         }
1093                         result = TRUE;
1094 #line 341 "ui_clip.vala"
1095                         return result;
1096 #line 1097 "ui_clip.c"
1097                 }
1098                 case CLIP_VIEW_MOTION_MODE_DRAGGING:
1099                 {
1100 #line 343 "ui_clip.vala"
1101                         g_signal_emit_by_name (self, "move-request", self, delta_time);
1102 #line 1103 "ui_clip.c"
1103                         result = TRUE;
1104 #line 344 "ui_clip.vala"
1105                         return result;
1106 #line 1107 "ui_clip.c"
1107                 }
1108         }
1109         result = FALSE;
1110 #line 346 "ui_clip.vala"
1111         return result;
1112 #line 1113 "ui_clip.c"
1113 }
1114
1115
1116 #line 349 "ui_clip.vala"
1117 static gboolean clip_view_is_trim_height (ClipView* self, double y) {
1118 #line 1119 "ui_clip.c"
1119         gboolean result = FALSE;
1120 #line 349 "ui_clip.vala"
1121         g_return_val_if_fail (IS_CLIP_VIEW (self), FALSE);
1122 #line 1123 "ui_clip.c"
1123         result = (y - GTK_WIDGET (self)->allocation.y) > (GTK_WIDGET (self)->allocation.height / 2);
1124 #line 350 "ui_clip.vala"
1125         return result;
1126 #line 1127 "ui_clip.c"
1127 }
1128
1129
1130 #line 353 "ui_clip.vala"
1131 static gboolean clip_view_is_left_trim (ClipView* self, double x, double y) {
1132 #line 1133 "ui_clip.c"
1133         gboolean result = FALSE;
1134         gboolean _tmp0_ = FALSE;
1135         gboolean _tmp1_ = FALSE;
1136 #line 353 "ui_clip.vala"
1137         g_return_val_if_fail (IS_CLIP_VIEW (self), FALSE);
1138 #line 354 "ui_clip.vala"
1139         if (clip_view_is_trim_height (self, y)) {
1140 #line 354 "ui_clip.vala"
1141                 _tmp1_ = x > 0;
1142 #line 1143 "ui_clip.c"
1143         } else {
1144 #line 354 "ui_clip.vala"
1145                 _tmp1_ = FALSE;
1146 #line 1147 "ui_clip.c"
1147         }
1148 #line 354 "ui_clip.vala"
1149         if (_tmp1_) {
1150 #line 354 "ui_clip.vala"
1151                 _tmp0_ = x < CLIP_VIEW_TRIM_WIDTH;
1152 #line 1153 "ui_clip.c"
1153         } else {
1154 #line 354 "ui_clip.vala"
1155                 _tmp0_ = FALSE;
1156 #line 1157 "ui_clip.c"
1157         }
1158         result = _tmp0_;
1159 #line 354 "ui_clip.vala"
1160         return result;
1161 #line 1162 "ui_clip.c"
1162 }
1163
1164
1165 #line 357 "ui_clip.vala"
1166 static gboolean clip_view_is_right_trim (ClipView* self, double x, double y) {
1167 #line 1168 "ui_clip.c"
1168         gboolean result = FALSE;
1169         gboolean _tmp0_ = FALSE;
1170         gboolean _tmp1_ = FALSE;
1171 #line 357 "ui_clip.vala"
1172         g_return_val_if_fail (IS_CLIP_VIEW (self), FALSE);
1173 #line 358 "ui_clip.vala"
1174         if (clip_view_is_trim_height (self, y)) {
1175 #line 358 "ui_clip.vala"
1176                 _tmp1_ = x > (GTK_WIDGET (self)->allocation.width - CLIP_VIEW_TRIM_WIDTH);
1177 #line 1178 "ui_clip.c"
1178         } else {
1179 #line 358 "ui_clip.vala"
1180                 _tmp1_ = FALSE;
1181 #line 1182 "ui_clip.c"
1182         }
1183 #line 358 "ui_clip.vala"
1184         if (_tmp1_) {
1185 #line 359 "ui_clip.vala"
1186                 _tmp0_ = x < GTK_WIDGET (self)->allocation.width;
1187 #line 1188 "ui_clip.c"
1188         } else {
1189 #line 358 "ui_clip.vala"
1190                 _tmp0_ = FALSE;
1191 #line 1192 "ui_clip.c"
1192         }
1193         result = _tmp0_;
1194 #line 358 "ui_clip.vala"
1195         return result;
1196 #line 1197 "ui_clip.c"
1197 }
1198
1199
1200 #line 362 "ui_clip.vala"
1201 void clip_view_select (ClipView* self) {
1202 #line 362 "ui_clip.vala"
1203         g_return_if_fail (IS_CLIP_VIEW (self));
1204 #line 363 "ui_clip.vala"
1205         if (!self->is_selected) {
1206 #line 364 "ui_clip.vala"
1207                 g_signal_emit_by_name (self, "selection-request", self, TRUE);
1208 #line 1209 "ui_clip.c"
1209         }
1210 }
1211
1212
1213 #line 368 "ui_clip.vala"
1214 void clip_view_snap (ClipView* self, gint64 amount) {
1215 #line 368 "ui_clip.vala"
1216         g_return_if_fail (IS_CLIP_VIEW (self));
1217 #line 369 "ui_clip.vala"
1218         self->priv->snap_amount = model_time_system_time_to_xsize (self->priv->time_provider, amount);
1219 #line 370 "ui_clip.vala"
1220         self->priv->snapped = TRUE;
1221 #line 1222 "ui_clip.c"
1222 }
1223
1224
1225 static void clip_view_class_init (ClipViewClass * klass) {
1226         clip_view_parent_class = g_type_class_peek_parent (klass);
1227         g_type_class_add_private (klass, sizeof (ClipViewPrivate));
1228         GTK_WIDGET_CLASS (klass)->expose_event = clip_view_real_expose_event;
1229         GTK_WIDGET_CLASS (klass)->button_press_event = clip_view_real_button_press_event;
1230         GTK_WIDGET_CLASS (klass)->button_release_event = clip_view_real_button_release_event;
1231         GTK_WIDGET_CLASS (klass)->motion_notify_event = clip_view_real_motion_notify_event;
1232         G_OBJECT_CLASS (klass)->finalize = clip_view_finalize;
1233         g_signal_new ("clip_deleted", TYPE_CLIP_VIEW, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__OBJECT, G_TYPE_NONE, 1, MODEL_TYPE_CLIP);
1234         g_signal_new ("clip_moved", TYPE_CLIP_VIEW, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__OBJECT, G_TYPE_NONE, 1, TYPE_CLIP_VIEW);
1235         g_signal_new ("selection_request", TYPE_CLIP_VIEW, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_user_marshal_VOID__OBJECT_BOOLEAN, G_TYPE_NONE, 2, TYPE_CLIP_VIEW, G_TYPE_BOOLEAN);
1236         g_signal_new ("move_request", TYPE_CLIP_VIEW, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_user_marshal_VOID__OBJECT_INT64, G_TYPE_NONE, 2, TYPE_CLIP_VIEW, G_TYPE_INT64);
1237         g_signal_new ("move_commit", TYPE_CLIP_VIEW, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_user_marshal_VOID__OBJECT_INT64, G_TYPE_NONE, 2, TYPE_CLIP_VIEW, G_TYPE_INT64);
1238         g_signal_new ("move_begin", TYPE_CLIP_VIEW, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_user_marshal_VOID__OBJECT_BOOLEAN, G_TYPE_NONE, 2, TYPE_CLIP_VIEW, G_TYPE_BOOLEAN);
1239         g_signal_new ("trim_begin", TYPE_CLIP_VIEW, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_user_marshal_VOID__OBJECT_ENUM, G_TYPE_NONE, 2, TYPE_CLIP_VIEW, GDK_TYPE_WINDOW_EDGE);
1240         g_signal_new ("trim_commit", TYPE_CLIP_VIEW, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_user_marshal_VOID__OBJECT_ENUM, G_TYPE_NONE, 2, TYPE_CLIP_VIEW, GDK_TYPE_WINDOW_EDGE);
1241         clip_view_left_trim_cursor = gdk_cursor_new (GDK_LEFT_SIDE);
1242         clip_view_right_trim_cursor = gdk_cursor_new (GDK_RIGHT_SIDE);
1243         clip_view_hand_cursor = gdk_cursor_new_from_name (gdk_display_get_default (), "dnd-none");
1244         clip_view_plus_cursor = gdk_cursor_new_from_name (gdk_display_get_default (), "dnd-copy");
1245 }
1246
1247
1248 static void clip_view_instance_init (ClipView * self) {
1249         self->priv = CLIP_VIEW_GET_PRIVATE (self);
1250         self->priv->motion_mode = CLIP_VIEW_MOTION_MODE_NONE;
1251         self->priv->button_down = FALSE;
1252 }
1253
1254
1255 static void clip_view_finalize (GObject* obj) {
1256         ClipView * self;
1257         self = CLIP_VIEW (obj);
1258         _g_object_unref0 (self->clip);
1259         _g_object_unref0 (self->priv->transport_delegate);
1260         G_OBJECT_CLASS (clip_view_parent_class)->finalize (obj);
1261 }
1262
1263
1264 GType clip_view_get_type (void) {
1265         static volatile gsize clip_view_type_id__volatile = 0;
1266         if (g_once_init_enter (&clip_view_type_id__volatile)) {
1267                 static const GTypeInfo g_define_type_info = { sizeof (ClipViewClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) clip_view_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ClipView), 0, (GInstanceInitFunc) clip_view_instance_init, NULL };
1268                 GType clip_view_type_id;
1269                 clip_view_type_id = g_type_register_static (GTK_TYPE_DRAWING_AREA, "ClipView", &g_define_type_info, 0);
1270                 g_once_init_leave (&clip_view_type_id__volatile, clip_view_type_id);
1271         }
1272         return clip_view_type_id__volatile;
1273 }
1274
1275
1276
1277 static void g_cclosure_user_marshal_VOID__OBJECT_BOOLEAN (GClosure * closure, GValue * return_value, guint n_param_values, const GValue * param_values, gpointer invocation_hint, gpointer marshal_data) {
1278         typedef void (*GMarshalFunc_VOID__OBJECT_BOOLEAN) (gpointer data1, gpointer arg_1, gboolean arg_2, gpointer data2);
1279         register GMarshalFunc_VOID__OBJECT_BOOLEAN callback;
1280         register GCClosure * cc;
1281         register gpointer data1, data2;
1282         cc = (GCClosure *) closure;
1283         g_return_if_fail (n_param_values == 3);
1284         if (G_CCLOSURE_SWAP_DATA (closure)) {
1285                 data1 = closure->data;
1286                 data2 = param_values->data[0].v_pointer;
1287         } else {
1288                 data1 = param_values->data[0].v_pointer;
1289                 data2 = closure->data;
1290         }
1291         callback = (GMarshalFunc_VOID__OBJECT_BOOLEAN) (marshal_data ? marshal_data : cc->callback);
1292         callback (data1, g_value_get_object (param_values + 1), g_value_get_boolean (param_values + 2), data2);
1293 }
1294
1295
1296 static void g_cclosure_user_marshal_VOID__OBJECT_INT64 (GClosure * closure, GValue * return_value, guint n_param_values, const GValue * param_values, gpointer invocation_hint, gpointer marshal_data) {
1297         typedef void (*GMarshalFunc_VOID__OBJECT_INT64) (gpointer data1, gpointer arg_1, gint64 arg_2, gpointer data2);
1298         register GMarshalFunc_VOID__OBJECT_INT64 callback;
1299         register GCClosure * cc;
1300         register gpointer data1, data2;
1301         cc = (GCClosure *) closure;
1302         g_return_if_fail (n_param_values == 3);
1303         if (G_CCLOSURE_SWAP_DATA (closure)) {
1304                 data1 = closure->data;
1305                 data2 = param_values->data[0].v_pointer;
1306         } else {
1307                 data1 = param_values->data[0].v_pointer;
1308                 data2 = closure->data;
1309         }
1310         callback = (GMarshalFunc_VOID__OBJECT_INT64) (marshal_data ? marshal_data : cc->callback);
1311         callback (data1, g_value_get_object (param_values + 1), g_value_get_int64 (param_values + 2), data2);
1312 }
1313
1314
1315 static void g_cclosure_user_marshal_VOID__OBJECT_ENUM (GClosure * closure, GValue * return_value, guint n_param_values, const GValue * param_values, gpointer invocation_hint, gpointer marshal_data) {
1316         typedef void (*GMarshalFunc_VOID__OBJECT_ENUM) (gpointer data1, gpointer arg_1, gint arg_2, gpointer data2);
1317         register GMarshalFunc_VOID__OBJECT_ENUM callback;
1318         register GCClosure * cc;
1319         register gpointer data1, data2;
1320         cc = (GCClosure *) closure;
1321         g_return_if_fail (n_param_values == 3);
1322         if (G_CCLOSURE_SWAP_DATA (closure)) {
1323                 data1 = closure->data;
1324                 data2 = param_values->data[0].v_pointer;
1325         } else {
1326                 data1 = param_values->data[0].v_pointer;
1327                 data2 = closure->data;
1328         }
1329         callback = (GMarshalFunc_VOID__OBJECT_ENUM) (marshal_data ? marshal_data : cc->callback);
1330         callback (data1, g_value_get_object (param_values + 1), g_value_get_enum (param_values + 2), data2);
1331 }
1332
1333
1334