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

   1 /* header_area.c generated by valac, the Vala compiler
   2  * generated from header_area.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 <marina.h>
  14 #include <gdk/gdk.h>
  15 #include <gdk-pixbuf/gdk-pixdata.h>
  16 #include <gio/gio.h>
  17 #include <float.h>
  18 #include <math.h>
  19 #include <pango/pango.h>
  20 #include <hildon/hildon.h>
  21 #include <stdlib.h>
  22 #include <string.h>
  23 #include <gee.h>
  24
  25
  26 #define TYPE_TRACK_HEADER (track_header_get_type ())
  27 #define TRACK_HEADER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_TRACK_HEADER, TrackHeader))
  28 #define TRACK_HEADER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_TRACK_HEADER, TrackHeaderClass))
  29 #define IS_TRACK_HEADER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_TRACK_HEADER))
  30 #define IS_TRACK_HEADER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_TRACK_HEADER))
  31 #define TRACK_HEADER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_TRACK_HEADER, TrackHeaderClass))
  32
  33 typedef struct _TrackHeader TrackHeader;
  34 typedef struct _TrackHeaderClass TrackHeaderClass;
  35 typedef struct _TrackHeaderPrivate TrackHeaderPrivate;
  36
  37 #define TYPE_HEADER_AREA (header_area_get_type ())
  38 #define HEADER_AREA(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_HEADER_AREA, HeaderArea))
  39 #define HEADER_AREA_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_HEADER_AREA, HeaderAreaClass))
  40 #define IS_HEADER_AREA(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_HEADER_AREA))
  41 #define IS_HEADER_AREA_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_HEADER_AREA))
  42 #define HEADER_AREA_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_HEADER_AREA, HeaderAreaClass))
  43
  44 typedef struct _HeaderArea HeaderArea;
  45 typedef struct _HeaderAreaClass HeaderAreaClass;
  46 #define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
  47 typedef struct _HeaderAreaPrivate HeaderAreaPrivate;
  48
  49 #define TYPE_SLIDER_BASE (slider_base_get_type ())
  50 #define SLIDER_BASE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_SLIDER_BASE, SliderBase))
  51 #define SLIDER_BASE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_SLIDER_BASE, SliderBaseClass))
  52 #define IS_SLIDER_BASE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_SLIDER_BASE))
  53 #define IS_SLIDER_BASE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_SLIDER_BASE))
  54 #define SLIDER_BASE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_SLIDER_BASE, SliderBaseClass))
  55
  56 typedef struct _SliderBase SliderBase;
  57 typedef struct _SliderBaseClass SliderBaseClass;
  58 typedef struct _SliderBasePrivate SliderBasePrivate;
  59 #define _g_free0(var) (var = (g_free (var), NULL))
  60 #define _g_error_free0(var) ((var == NULL) ? NULL : (var = (g_error_free (var), NULL)))
  61
  62 #define TYPE_PAN_SLIDER (pan_slider_get_type ())
  63 #define PAN_SLIDER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_PAN_SLIDER, PanSlider))
  64 #define PAN_SLIDER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_PAN_SLIDER, PanSliderClass))
  65 #define IS_PAN_SLIDER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_PAN_SLIDER))
  66 #define IS_PAN_SLIDER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_PAN_SLIDER))
  67 #define PAN_SLIDER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_PAN_SLIDER, PanSliderClass))
  68
  69 typedef struct _PanSlider PanSlider;
  70 typedef struct _PanSliderClass PanSliderClass;
  71 typedef struct _PanSliderPrivate PanSliderPrivate;
  72
  73 #define TYPE_VOLUME_SLIDER (volume_slider_get_type ())
  74 #define VOLUME_SLIDER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_VOLUME_SLIDER, VolumeSlider))
  75 #define VOLUME_SLIDER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_VOLUME_SLIDER, VolumeSliderClass))
  76 #define IS_VOLUME_SLIDER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_VOLUME_SLIDER))
  77 #define IS_VOLUME_SLIDER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_VOLUME_SLIDER))
  78 #define VOLUME_SLIDER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_VOLUME_SLIDER, VolumeSliderClass))
  79
  80 typedef struct _VolumeSlider VolumeSlider;
  81 typedef struct _VolumeSliderClass VolumeSliderClass;
  82 typedef struct _VolumeSliderPrivate VolumeSliderPrivate;
  83
  84 #define TYPE_AUDIO_TRACK_HEADER (audio_track_header_get_type ())
  85 #define AUDIO_TRACK_HEADER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_AUDIO_TRACK_HEADER, AudioTrackHeader))
  86 #define AUDIO_TRACK_HEADER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_AUDIO_TRACK_HEADER, AudioTrackHeaderClass))
  87 #define IS_AUDIO_TRACK_HEADER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_AUDIO_TRACK_HEADER))
  88 #define IS_AUDIO_TRACK_HEADER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_AUDIO_TRACK_HEADER))
  89 #define AUDIO_TRACK_HEADER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_AUDIO_TRACK_HEADER, AudioTrackHeaderClass))
  90
  91 typedef struct _AudioTrackHeader AudioTrackHeader;
  92 typedef struct _AudioTrackHeaderClass AudioTrackHeaderClass;
  93 typedef struct _AudioTrackHeaderPrivate AudioTrackHeaderPrivate;
  94 #define _pango_font_description_free0(var) ((var == NULL) ? NULL : (var = (pango_font_description_free (var), NULL)))
  95
  96 #define ID_WORKS_TYPE_VOLUME_AND_PAN_POP_UP (id_works_volume_and_pan_pop_up_get_type ())
  97 #define ID_WORKS_VOLUME_AND_PAN_POP_UP(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), ID_WORKS_TYPE_VOLUME_AND_PAN_POP_UP, IdWorksVolumeAndPanPopUp))
  98 #define ID_WORKS_VOLUME_AND_PAN_POP_UP_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), ID_WORKS_TYPE_VOLUME_AND_PAN_POP_UP, IdWorksVolumeAndPanPopUpClass))
  99 #define ID_WORKS_IS_VOLUME_AND_PAN_POP_UP(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), ID_WORKS_TYPE_VOLUME_AND_PAN_POP_UP))
 100 #define ID_WORKS_IS_VOLUME_AND_PAN_POP_UP_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), ID_WORKS_TYPE_VOLUME_AND_PAN_POP_UP))
 101 #define ID_WORKS_VOLUME_AND_PAN_POP_UP_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), ID_WORKS_TYPE_VOLUME_AND_PAN_POP_UP, IdWorksVolumeAndPanPopUpClass))
 102
 103 typedef struct _IdWorksVolumeAndPanPopUp IdWorksVolumeAndPanPopUp;
 104 typedef struct _IdWorksVolumeAndPanPopUpClass IdWorksVolumeAndPanPopUpClass;
 105
 106 #define TYPE_RECORDER (recorder_get_type ())
 107 #define RECORDER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_RECORDER, Recorder))
 108 #define RECORDER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_RECORDER, RecorderClass))
 109 #define IS_RECORDER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_RECORDER))
 110 #define IS_RECORDER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_RECORDER))
 111 #define RECORDER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_RECORDER, RecorderClass))
 112
 113 typedef struct _Recorder Recorder;
 114 typedef struct _RecorderClass RecorderClass;
 115 typedef struct _RecorderPrivate RecorderPrivate;
 116
 117 #define MODEL_TYPE_AUDIO_PROJECT (model_audio_project_get_type ())
 118 #define MODEL_AUDIO_PROJECT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_AUDIO_PROJECT, ModelAudioProject))
 119 #define MODEL_AUDIO_PROJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_AUDIO_PROJECT, ModelAudioProjectClass))
 120 #define MODEL_IS_AUDIO_PROJECT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_AUDIO_PROJECT))
 121 #define MODEL_IS_AUDIO_PROJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_AUDIO_PROJECT))
 122 #define MODEL_AUDIO_PROJECT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_AUDIO_PROJECT, ModelAudioProjectClass))
 123
 124 typedef struct _ModelAudioProject ModelAudioProject;
 125 typedef struct _ModelAudioProjectClass ModelAudioProjectClass;
 126
 127 #define TYPE_TRACK_SEPARATOR (track_separator_get_type ())
 128 #define TRACK_SEPARATOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_TRACK_SEPARATOR, TrackSeparator))
 129 #define TRACK_SEPARATOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_TRACK_SEPARATOR, TrackSeparatorClass))
 130 #define IS_TRACK_SEPARATOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_TRACK_SEPARATOR))
 131 #define IS_TRACK_SEPARATOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_TRACK_SEPARATOR))
 132 #define TRACK_SEPARATOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_TRACK_SEPARATOR, TrackSeparatorClass))
 133
 134 typedef struct _TrackSeparator TrackSeparator;
 135 typedef struct _TrackSeparatorClass TrackSeparatorClass;
 136 #define _g_list_free0(var) ((var == NULL) ? NULL : (var = (g_list_free (var), NULL)))
 137
 138 struct _TrackHeader {
 139         GtkEventBox parent_instance;
 140         TrackHeaderPrivate * priv;
 141         ModelTrack* track;
 142         HeaderArea* header_area;
 143         GtkLabel* track_label;
 144 };
 145
 146 struct _TrackHeaderClass {
 147         GtkEventBoxClass parent_class;
 148 };
 149
 150 struct _HeaderArea {
 151         GtkEventBox parent_instance;
 152         HeaderAreaPrivate * priv;
 153         GdkColor background_color;
 154 };
 155
 156 struct _HeaderAreaClass {
 157         GtkEventBoxClass parent_class;
 158 };
 159
 160 struct _SliderBase {
 161         GtkHScrollbar parent_instance;
 162         SliderBasePrivate * priv;
 163 };
 164
 165 struct _SliderBaseClass {
 166         GtkHScrollbarClass parent_class;
 167 };
 168
 169 struct _SliderBasePrivate {
 170         GdkPixbuf* slider_image;
 171 };
 172
 173 struct _PanSlider {
 174         SliderBase parent_instance;
 175         PanSliderPrivate * priv;
 176 };
 177
 178 struct _PanSliderClass {
 179         SliderBaseClass parent_class;
 180 };
 181
 182 struct _VolumeSlider {
 183         SliderBase parent_instance;
 184         VolumeSliderPrivate * priv;
 185 };
 186
 187 struct _VolumeSliderClass {
 188         SliderBaseClass parent_class;
 189 };
 190
 191 struct _AudioTrackHeader {
 192         TrackHeader parent_instance;
 193         AudioTrackHeaderPrivate * priv;
 194         double panorama;
 195         double volume;
 196 };
 197
 198 struct _AudioTrackHeaderClass {
 199         TrackHeaderClass parent_class;
 200 };
 201
 202 struct _HeaderAreaPrivate {
 203         ModelProject* project;
 204         GtkVBox* vbox;
 205 };
 206
 207 struct _Recorder {
 208         GtkWindow parent_instance;
 209         RecorderPrivate * priv;
 210         ModelAudioProject* project;
 211         TimeLine* timeline;
 212 };
 213
 214 struct _RecorderClass {
 215         GtkWindowClass parent_class;
 216 };
 217
 218
 219 static gpointer track_header_parent_class = NULL;
 220 static gpointer slider_base_parent_class = NULL;
 221 static gpointer pan_slider_parent_class = NULL;
 222 static gpointer volume_slider_parent_class = NULL;
 223 static gpointer audio_track_header_parent_class = NULL;
 224 static gpointer header_area_parent_class = NULL;
 225
 226 GType track_header_get_type (void);
 227 GType header_area_get_type (void);
 228 enum  {
 229         TRACK_HEADER_DUMMY_PROPERTY
 230 };
 231 #define TRACK_HEADER_width 100
 232 static void track_header_on_track_renamed (TrackHeader* self);
 233 static void _track_header_on_track_renamed_model_track_track_renamed (ModelTrack* _sender, ModelTrack* track, gpointer self);
 234 static void track_header_on_track_selection_changed (TrackHeader* self, ModelTrack* track);
 235 static void _track_header_on_track_selection_changed_model_track_track_selection_changed (ModelTrack* _sender, ModelTrack* track, gpointer self);
 236 TrackHeader* track_header_new (ModelTrack* track, HeaderArea* area, gint height);
 237 TrackHeader* track_header_construct (GType object_type, ModelTrack* track, HeaderArea* area, gint height);
 238 void header_area_select (HeaderArea* self, ModelTrack* track);
 239 static gboolean track_header_real_button_press_event (GtkWidget* base, GdkEventButton* event);
 240 ModelTrack* track_header_get_track (TrackHeader* self);
 241 static void track_header_finalize (GObject* obj);
 242 GType slider_base_get_type (void);
 243 #define SLIDER_BASE_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), TYPE_SLIDER_BASE, SliderBasePrivate))
 244 enum  {
 245         SLIDER_BASE_DUMMY_PROPERTY
 246 };
 247 static gboolean slider_base_real_expose_event (GtkWidget* base, GdkEventExpose* event);
 248 SliderBase* slider_base_new (void);
 249 SliderBase* slider_base_construct (GType object_type);
 250 static GObject * slider_base_constructor (GType type, guint n_construct_properties, GObjectConstructParam * construct_properties);
 251 static void slider_base_finalize (GObject* obj);
 252 GType pan_slider_get_type (void);
 253 enum  {
 254         PAN_SLIDER_DUMMY_PROPERTY
 255 };
 256 PanSlider* pan_slider_new (void);
 257 PanSlider* pan_slider_construct (GType object_type);
 258 static GObject * pan_slider_constructor (GType type, guint n_construct_properties, GObjectConstructParam * construct_properties);
 259 GType volume_slider_get_type (void);
 260 enum  {
 261         VOLUME_SLIDER_DUMMY_PROPERTY
 262 };
 263 VolumeSlider* volume_slider_new (void);
 264 VolumeSlider* volume_slider_construct (GType object_type);
 265 static GObject * volume_slider_constructor (GType type, guint n_construct_properties, GObjectConstructParam * construct_properties);
 266 GType audio_track_header_get_type (void);
 267 enum  {
 268         AUDIO_TRACK_HEADER_DUMMY_PROPERTY
 269 };
 270 static void audio_track_header_on_parameter_changed (AudioTrackHeader* self, ModelParameter parameter, double new_value);
 271 static void _audio_track_header_on_parameter_changed_model_audio_track_parameter_changed (ModelAudioTrack* _sender, ModelParameter parameter, double new_value, gpointer self);
 272 static void audio_track_header_do_volpan_popup (AudioTrackHeader* self);
 273 static void _audio_track_header_do_volpan_popup_gtk_button_clicked (GtkButton* _sender, gpointer self);
 274 AudioTrackHeader* audio_track_header_new (ModelAudioTrack* track, HeaderArea* header, gint height);
 275 AudioTrackHeader* audio_track_header_construct (GType object_type, ModelAudioTrack* track, HeaderArea* header, gint height);
 276 IdWorksVolumeAndPanPopUp* id_works_volume_and_pan_pop_up_new (GtkWidget* parent, const char* title);
 277 IdWorksVolumeAndPanPopUp* id_works_volume_and_pan_pop_up_construct (GType object_type, GtkWidget* parent, const char* title);
 278 GType id_works_volume_and_pan_pop_up_get_type (void);
 279 void id_works_volume_and_pan_pop_up_set_volume (IdWorksVolumeAndPanPopUp* self, double volume);
 280 void id_works_volume_and_pan_pop_up_set_panorama (IdWorksVolumeAndPanPopUp* self, double panorama);
 281 static void audio_track_header_on_volume_updated (AudioTrackHeader* self, double val);
 282 static void _audio_track_header_on_volume_updated_id_works_volume_and_pan_pop_up_volume_updated (IdWorksVolumeAndPanPopUp* _sender, double volume, gpointer self);
 283 static void audio_track_header_on_panorama_updated (AudioTrackHeader* self, double val);
 284 static void _audio_track_header_on_panorama_updated_id_works_volume_and_pan_pop_up_panorama_updated (IdWorksVolumeAndPanPopUp* _sender, double panorama, gpointer self);
 285 static void audio_track_header_finalize (GObject* obj);
 286 #define HEADER_AREA_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), TYPE_HEADER_AREA, HeaderAreaPrivate))
 287 enum  {
 288         HEADER_AREA_DUMMY_PROPERTY
 289 };
 290 GType recorder_get_type (void);
 291 GType model_audio_project_get_type (void);
 292 void header_area_on_trackview_removed (HeaderArea* self, TrackView* trackview);
 293 static void _header_area_on_trackview_removed_time_line_trackview_removed (TimeLine* _sender, TrackView* trackview, gpointer self);
 294 void header_area_on_trackview_added (HeaderArea* self, TrackView* trackview);
 295 static void _header_area_on_trackview_added_time_line_trackview_added (TimeLine* _sender, TrackView* trackview, gpointer self);
 296 TrackSeparator* track_separator_new (void);
 297 TrackSeparator* track_separator_construct (GType object_type);
 298 GType track_separator_get_type (void);
 299 HeaderArea* header_area_new (Recorder* recorder, ModelTimeSystem* provider, gint height);
 300 HeaderArea* header_area_construct (GType object_type, Recorder* recorder, ModelTimeSystem* provider, gint height);
 301 static void header_area_finalize (GObject* obj);
 302
 303
 304
 305 #line 30 "header_area.vala"
 306 static void _track_header_on_track_renamed_model_track_track_renamed (ModelTrack* _sender, ModelTrack* track, gpointer self) {
 307 #line 308 "header_area.c"
 308         track_header_on_track_renamed (self);
 309 }
 310
 311
 312 #line 35 "header_area.vala"
 313 static void _track_header_on_track_selection_changed_model_track_track_selection_changed (ModelTrack* _sender, ModelTrack* track, gpointer self) {
 314 #line 315 "header_area.c"
 315         track_header_on_track_selection_changed (self, track);
 316 }
 317
 318
 319 #line 16 "header_area.vala"
 320 TrackHeader* track_header_construct (GType object_type, ModelTrack* track, HeaderArea* area, gint height) {
 321 #line 322 "header_area.c"
 322         TrackHeader * self;
 323         GdkColor _tmp1_;
 324         GdkColor _tmp0_ = {0};
 325         GtkLabel* _tmp2_;
 326         GdkColor _tmp4_;
 327         GdkColor _tmp3_ = {0};
 328 #line 16 "header_area.vala"
 329         g_return_val_if_fail (MODEL_IS_TRACK (track), NULL);
 330 #line 16 "header_area.vala"
 331         g_return_val_if_fail (IS_HEADER_AREA (area), NULL);
 332 #line 333 "header_area.c"
 333         self = g_object_newv (object_type, 0, NULL);
 334 #line 17 "header_area.vala"
 335         self->track = track;
 336 #line 18 "header_area.vala"
 337         self->header_area = area;
 338 #line 20 "header_area.vala"
 339         g_signal_connect_object (track, "track-renamed", (GCallback) _track_header_on_track_renamed_model_track_track_renamed, self, 0);
 340 #line 21 "header_area.vala"
 341         g_signal_connect_object (track, "track-selection-changed", (GCallback) _track_header_on_track_selection_changed_model_track_track_selection_changed, self, 0);
 342 #line 22 "header_area.vala"
 343         gtk_widget_set_size_request (GTK_WIDGET (self), TRACK_HEADER_width, height);
 344 #line 23 "header_area.vala"
 345         gtk_widget_modify_bg (GTK_WIDGET (self), GTK_STATE_NORMAL, &self->header_area->background_color);
 346 #line 24 "header_area.vala"
 347         gtk_widget_modify_bg (GTK_WIDGET (self), GTK_STATE_SELECTED, (_tmp1_ = (parse_color ("#68a", &_tmp0_), _tmp0_), &_tmp1_));
 348 #line 26 "header_area.vala"
 349         self->track_label = (_tmp2_ = g_object_ref_sink ((GtkLabel*) gtk_label_new (track->display_name)), _g_object_unref0 (self->track_label), _tmp2_);
 350 #line 27 "header_area.vala"
 351         gtk_widget_modify_fg (GTK_WIDGET (self->track_label), GTK_STATE_NORMAL, (_tmp4_ = (parse_color ("#fff", &_tmp3_), _tmp3_), &_tmp4_));
 352 #line 353 "header_area.c"
 353         return self;
 354 }
 355
 356
 357 #line 16 "header_area.vala"
 358 TrackHeader* track_header_new (ModelTrack* track, HeaderArea* area, gint height) {
 359 #line 16 "header_area.vala"
 360         return track_header_construct (TYPE_TRACK_HEADER, track, area, height);
 361 #line 362 "header_area.c"
 362 }
 363
 364
 365 #line 30 "header_area.vala"
 366 static void track_header_on_track_renamed (TrackHeader* self) {
 367 #line 30 "header_area.vala"
 368         g_return_if_fail (IS_TRACK_HEADER (self));
 369 #line 31 "header_area.vala"
 370         logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_track_renamed");
 371 #line 32 "header_area.vala"
 372         gtk_label_set_text (self->track_label, self->track->display_name);
 373 #line 374 "header_area.c"
 374 }
 375
 376
 377 #line 35 "header_area.vala"
 378 static void track_header_on_track_selection_changed (TrackHeader* self, ModelTrack* track) {
 379 #line 380 "header_area.c"
 380         GtkStateType _tmp0_ = 0;
 381 #line 35 "header_area.vala"
 382         g_return_if_fail (IS_TRACK_HEADER (self));
 383 #line 35 "header_area.vala"
 384         g_return_if_fail (MODEL_IS_TRACK (track));
 385 #line 36 "header_area.vala"
 386         logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_track_selection_changed");
 387 #line 37 "header_area.vala"
 388         if (model_track_get_is_selected (track)) {
 389 #line 37 "header_area.vala"
 390                 _tmp0_ = GTK_STATE_SELECTED;
 391 #line 392 "header_area.c"
 392         } else {
 393 #line 37 "header_area.vala"
 394                 _tmp0_ = GTK_STATE_NORMAL;
 395 #line 396 "header_area.c"
 396         }
 397 #line 37 "header_area.vala"
 398         gtk_widget_set_state (GTK_WIDGET (self), _tmp0_);
 399 #line 400 "header_area.c"
 400 }
 401
 402
 403 #line 40 "header_area.vala"
 404 static gboolean track_header_real_button_press_event (GtkWidget* base, GdkEventButton* event) {
 405 #line 406 "header_area.c"
 406         TrackHeader * self;
 407         gboolean result = FALSE;
 408         self = TRACK_HEADER (base);
 409 #line 41 "header_area.vala"
 410         header_area_select (self->header_area, self->track);
 411 #line 412 "header_area.c"
 412         result = TRUE;
 413 #line 42 "header_area.vala"
 414         return result;
 415 #line 416 "header_area.c"
 416 }
 417
 418
 419 static gpointer _g_object_ref0 (gpointer self) {
 420         return self ? g_object_ref (self) : NULL;
 421 }
 422
 423
 424 #line 45 "header_area.vala"
 425 ModelTrack* track_header_get_track (TrackHeader* self) {
 426 #line 427 "header_area.c"
 427         ModelTrack* result = NULL;
 428 #line 45 "header_area.vala"
 429         g_return_val_if_fail (IS_TRACK_HEADER (self), NULL);
 430 #line 431 "header_area.c"
 431         result = _g_object_ref0 (self->track);
 432 #line 46 "header_area.vala"
 433         return result;
 434 #line 435 "header_area.c"
 435 }
 436
 437
 438 static void track_header_class_init (TrackHeaderClass * klass) {
 439         track_header_parent_class = g_type_class_peek_parent (klass);
 440         GTK_WIDGET_CLASS (klass)->button_press_event = track_header_real_button_press_event;
 441         G_OBJECT_CLASS (klass)->finalize = track_header_finalize;
 442 }
 443
 444
 445 static void track_header_instance_init (TrackHeader * self) {
 446 }
 447
 448
 449 static void track_header_finalize (GObject* obj) {
 450         TrackHeader * self;
 451         self = TRACK_HEADER (obj);
 452         _g_object_unref0 (self->track_label);
 453         G_OBJECT_CLASS (track_header_parent_class)->finalize (obj);
 454 }
 455
 456
 457 GType track_header_get_type (void) {
 458         static volatile gsize track_header_type_id__volatile = 0;
 459         if (g_once_init_enter (&track_header_type_id__volatile)) {
 460                 static const GTypeInfo g_define_type_info = { sizeof (TrackHeaderClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) track_header_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (TrackHeader), 0, (GInstanceInitFunc) track_header_instance_init, NULL };
 461                 GType track_header_type_id;
 462                 track_header_type_id = g_type_register_static (GTK_TYPE_EVENT_BOX, "TrackHeader", &g_define_type_info, 0);
 463                 g_once_init_leave (&track_header_type_id__volatile, track_header_type_id);
 464         }
 465         return track_header_type_id__volatile;
 466 }
 467
 468
 469 #line 62 "header_area.vala"
 470 static gboolean slider_base_real_expose_event (GtkWidget* base, GdkEventExpose* event) {
 471 #line 472 "header_area.c"
 472         SliderBase * self;
 473         gboolean result = FALSE;
 474         GdkGC* gc;
 475         gint radius;
 476         gint center;
 477         gint height;
 478         self = SLIDER_BASE (base);
 479 #line 63 "header_area.vala"
 480         gc = _g_object_ref0 (gtk_widget_get_style (GTK_WIDGET (self))->fg_gc[(gint) GTK_STATE_NORMAL]);
 481 #line 64 "header_area.vala"
 482         radius = (GTK_RANGE (self)->slider_end - GTK_RANGE (self)->slider_start) / 2;
 483 #line 65 "header_area.vala"
 484         center = (GTK_WIDGET (self)->allocation.x + GTK_RANGE (self)->slider_start) + radius;
 485 #line 66 "header_area.vala"
 486         height = GTK_WIDGET (self)->allocation.y + (GTK_WIDGET (self)->allocation.height / 2);
 487 #line 68 "header_area.vala"
 488         gdk_draw_rectangle (GDK_DRAWABLE ((*event).window), gc, FALSE, GTK_WIDGET (self)->allocation.x + radius, height - 2, GTK_WIDGET (self)->allocation.width - (2 * radius), 1);
 489 #line 71 "header_area.vala"
 490         gdk_draw_pixbuf (GDK_DRAWABLE ((*event).window), gc, self->priv->slider_image, 0, 0, center - radius, GTK_WIDGET (self)->allocation.y + 2, gdk_pixbuf_get_width (self->priv->slider_image), gdk_pixbuf_get_height (self->priv->slider_image), GDK_RGB_DITHER_NORMAL, 0, 0);
 491 #line 492 "header_area.c"
 492         result = TRUE;
 493         _g_object_unref0 (gc);
 494 #line 73 "header_area.vala"
 495         return result;
 496 #line 497 "header_area.c"
 497 }
 498
 499
 500 #line 50 "header_area.vala"
 501 SliderBase* slider_base_construct (GType object_type) {
 502 #line 503 "header_area.c"
 503         SliderBase * self;
 504         self = g_object_newv (object_type, 0, NULL);
 505         return self;
 506 }
 507
 508
 509 #line 50 "header_area.vala"
 510 SliderBase* slider_base_new (void) {
 511 #line 50 "header_area.vala"
 512         return slider_base_construct (TYPE_SLIDER_BASE);
 513 #line 514 "header_area.c"
 514 }
 515
 516
 517 static GObject * slider_base_constructor (GType type, guint n_construct_properties, GObjectConstructParam * construct_properties) {
 518         GObject * obj;
 519         GObjectClass * parent_class;
 520         SliderBase * self;
 521         GError * _inner_error_;
 522         parent_class = G_OBJECT_CLASS (slider_base_parent_class);
 523         obj = parent_class->constructor (type, n_construct_properties, construct_properties);
 524         self = SLIDER_BASE (obj);
 525         _inner_error_ = NULL;
 526         {
 527 #line 53 "header_area.vala"
 528                 g_object_set (GTK_WIDGET (self), "can-focus", TRUE, NULL);
 529 #line 530 "header_area.c"
 530                 {
 531                         char* _tmp2_;
 532                         GFile* _tmp1_;
 533                         GFile* _tmp0_;
 534                         GdkPixbuf* _tmp3_;
 535                         GdkPixbuf* _tmp4_;
 536                         GdkPixbuf* _tmp5_;
 537 #line 55 "header_area.vala"
 538                         _tmp4_ = (_tmp3_ = gdk_pixbuf_new_from_file (_tmp2_ = g_file_get_path (_tmp1_ = g_file_get_child (_tmp0_ = app_dirs_get_resources_dir (), "dot.png")), &_inner_error_), _g_free0 (_tmp2_), _g_object_unref0 (_tmp1_), _g_object_unref0 (_tmp0_), _tmp3_);
 539 #line 540 "header_area.c"
 540                         if (_inner_error_ != NULL) {
 541                                 goto __catch14_g_error;
 542                         }
 543 #line 55 "header_area.vala"
 544                         self->priv->slider_image = (_tmp5_ = _tmp4_, _g_object_unref0 (self->priv->slider_image), _tmp5_);
 545 #line 546 "header_area.c"
 546                 }
 547                 goto __finally14;
 548                 __catch14_g_error:
 549                 {
 550                         GError * e;
 551                         e = _inner_error_;
 552                         _inner_error_ = NULL;
 553                         {
 554 #line 58 "header_area.vala"
 555                                 g_warning ("header_area.vala:58: Could not load resource for slider: %s", e->message);
 556 #line 557 "header_area.c"
 557                                 _g_error_free0 (e);
 558                         }
 559                 }
 560                 __finally14:
 561                 if (_inner_error_ != NULL) {
 562                         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);
 563                         g_clear_error (&_inner_error_);
 564                 }
 565         }
 566         return obj;
 567 }
 568
 569
 570 static void slider_base_class_init (SliderBaseClass * klass) {
 571         slider_base_parent_class = g_type_class_peek_parent (klass);
 572         g_type_class_add_private (klass, sizeof (SliderBasePrivate));
 573         GTK_WIDGET_CLASS (klass)->expose_event = slider_base_real_expose_event;
 574         G_OBJECT_CLASS (klass)->constructor = slider_base_constructor;
 575         G_OBJECT_CLASS (klass)->finalize = slider_base_finalize;
 576 }
 577
 578
 579 static void slider_base_instance_init (SliderBase * self) {
 580         self->priv = SLIDER_BASE_GET_PRIVATE (self);
 581 }
 582
 583
 584 static void slider_base_finalize (GObject* obj) {
 585         SliderBase * self;
 586         self = SLIDER_BASE (obj);
 587         _g_object_unref0 (self->priv->slider_image);
 588         G_OBJECT_CLASS (slider_base_parent_class)->finalize (obj);
 589 }
 590
 591
 592 GType slider_base_get_type (void) {
 593         static volatile gsize slider_base_type_id__volatile = 0;
 594         if (g_once_init_enter (&slider_base_type_id__volatile)) {
 595                 static const GTypeInfo g_define_type_info = { sizeof (SliderBaseClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) slider_base_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (SliderBase), 0, (GInstanceInitFunc) slider_base_instance_init, NULL };
 596                 GType slider_base_type_id;
 597                 slider_base_type_id = g_type_register_static (GTK_TYPE_HSCROLLBAR, "SliderBase", &g_define_type_info, 0);
 598                 g_once_init_leave (&slider_base_type_id__volatile, slider_base_type_id);
 599         }
 600         return slider_base_type_id__volatile;
 601 }
 602
 603
 604 #line 77 "header_area.vala"
 605 PanSlider* pan_slider_construct (GType object_type) {
 606 #line 607 "header_area.c"
 607         PanSlider * self;
 608         self = g_object_newv (object_type, 0, NULL);
 609         return self;
 610 }
 611
 612
 613 #line 77 "header_area.vala"
 614 PanSlider* pan_slider_new (void) {
 615 #line 77 "header_area.vala"
 616         return pan_slider_construct (TYPE_PAN_SLIDER);
 617 #line 618 "header_area.c"
 618 }
 619
 620
 621 static GObject * pan_slider_constructor (GType type, guint n_construct_properties, GObjectConstructParam * construct_properties) {
 622         GObject * obj;
 623         GObjectClass * parent_class;
 624         PanSlider * self;
 625         parent_class = G_OBJECT_CLASS (pan_slider_parent_class);
 626         obj = parent_class->constructor (type, n_construct_properties, construct_properties);
 627         self = PAN_SLIDER (obj);
 628         {
 629         }
 630         return obj;
 631 }
 632
 633
 634 static void pan_slider_class_init (PanSliderClass * klass) {
 635         pan_slider_parent_class = g_type_class_peek_parent (klass);
 636         G_OBJECT_CLASS (klass)->constructor = pan_slider_constructor;
 637 }
 638
 639
 640 static void pan_slider_instance_init (PanSlider * self) {
 641 }
 642
 643
 644 GType pan_slider_get_type (void) {
 645         static volatile gsize pan_slider_type_id__volatile = 0;
 646         if (g_once_init_enter (&pan_slider_type_id__volatile)) {
 647                 static const GTypeInfo g_define_type_info = { sizeof (PanSliderClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) pan_slider_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (PanSlider), 0, (GInstanceInitFunc) pan_slider_instance_init, NULL };
 648                 GType pan_slider_type_id;
 649                 pan_slider_type_id = g_type_register_static (TYPE_SLIDER_BASE, "PanSlider", &g_define_type_info, 0);
 650                 g_once_init_leave (&pan_slider_type_id__volatile, pan_slider_type_id);
 651         }
 652         return pan_slider_type_id__volatile;
 653 }
 654
 655
 656 #line 82 "header_area.vala"
 657 VolumeSlider* volume_slider_construct (GType object_type) {
 658 #line 659 "header_area.c"
 659         VolumeSlider * self;
 660         self = g_object_newv (object_type, 0, NULL);
 661         return self;
 662 }
 663
 664
 665 #line 82 "header_area.vala"
 666 VolumeSlider* volume_slider_new (void) {
 667 #line 82 "header_area.vala"
 668         return volume_slider_construct (TYPE_VOLUME_SLIDER);
 669 #line 670 "header_area.c"
 670 }
 671
 672
 673 static GObject * volume_slider_constructor (GType type, guint n_construct_properties, GObjectConstructParam * construct_properties) {
 674         GObject * obj;
 675         GObjectClass * parent_class;
 676         VolumeSlider * self;
 677         parent_class = G_OBJECT_CLASS (volume_slider_parent_class);
 678         obj = parent_class->constructor (type, n_construct_properties, construct_properties);
 679         self = VOLUME_SLIDER (obj);
 680         {
 681         }
 682         return obj;
 683 }
 684
 685
 686 static void volume_slider_class_init (VolumeSliderClass * klass) {
 687         volume_slider_parent_class = g_type_class_peek_parent (klass);
 688         G_OBJECT_CLASS (klass)->constructor = volume_slider_constructor;
 689 }
 690
 691
 692 static void volume_slider_instance_init (VolumeSlider * self) {
 693 }
 694
 695
 696 GType volume_slider_get_type (void) {
 697         static volatile gsize volume_slider_type_id__volatile = 0;
 698         if (g_once_init_enter (&volume_slider_type_id__volatile)) {
 699                 static const GTypeInfo g_define_type_info = { sizeof (VolumeSliderClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) volume_slider_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (VolumeSlider), 0, (GInstanceInitFunc) volume_slider_instance_init, NULL };
 700                 GType volume_slider_type_id;
 701                 volume_slider_type_id = g_type_register_static (TYPE_SLIDER_BASE, "VolumeSlider", &g_define_type_info, 0);
 702                 g_once_init_leave (&volume_slider_type_id__volatile, volume_slider_type_id);
 703         }
 704         return volume_slider_type_id__volatile;
 705 }
 706
 707
 708 #line 164 "header_area.vala"
 709 static void _audio_track_header_on_parameter_changed_model_audio_track_parameter_changed (ModelAudioTrack* _sender, ModelParameter parameter, double new_value, gpointer self) {
 710 #line 711 "header_area.c"
 711         audio_track_header_on_parameter_changed (self, parameter, new_value);
 712 }
 713
 714
 715 #line 119 "header_area.vala"
 716 static void _audio_track_header_do_volpan_popup_gtk_button_clicked (GtkButton* _sender, gpointer self) {
 717 #line 718 "header_area.c"
 718         audio_track_header_do_volpan_popup (self);
 719 }
 720
 721
 722 #line 91 "header_area.vala"
 723 AudioTrackHeader* audio_track_header_construct (GType object_type, ModelAudioTrack* track, HeaderArea* header, gint height) {
 724 #line 725 "header_area.c"
 725         AudioTrackHeader * self;
 726         PangoFontDescription* _tmp0_;
 727         GtkVBox* vbox;
 728         HildonButton* volpan_button;
 729         GtkImage* _tmp1_;
 730 #line 91 "header_area.vala"
 731         g_return_val_if_fail (MODEL_IS_AUDIO_TRACK (track), NULL);
 732 #line 91 "header_area.vala"
 733         g_return_val_if_fail (IS_HEADER_AREA (header), NULL);
 734 #line 92 "header_area.vala"
 735         self = (AudioTrackHeader*) track_header_construct (object_type, MODEL_TRACK (track), header, height);
 736 #line 94 "header_area.vala"
 737         gtk_widget_modify_font (GTK_WIDGET (TRACK_HEADER (self)->track_label), _tmp0_ = pango_font_description_from_string ("Sans 10"));
 738 #line 739 "header_area.c"
 739         _pango_font_description_free0 (_tmp0_);
 740 #line 95 "header_area.vala"
 741         gtk_misc_set_padding (GTK_MISC (TRACK_HEADER (self)->track_label), 4, 2);
 742 #line 96 "header_area.vala"
 743         gtk_misc_set_alignment (GTK_MISC (TRACK_HEADER (self)->track_label), (float) 0, (float) 0);
 744 #line 98 "header_area.vala"
 745         g_signal_connect_object (track, "parameter-changed", (GCallback) _audio_track_header_on_parameter_changed_model_audio_track_parameter_changed, self, 0);
 746 #line 100 "header_area.vala"
 747         self->volume = model_audio_track_get_volume (track);
 748 #line 101 "header_area.vala"
 749         self->panorama = model_audio_track_get_pan (track);
 750 #line 103 "header_area.vala"
 751         vbox = g_object_ref_sink ((GtkVBox*) gtk_vbox_new (FALSE, 0));
 752 #line 104 "header_area.vala"
 753         gtk_box_pack_start (GTK_BOX (vbox), GTK_WIDGET (TRACK_HEADER (self)->track_label), TRUE, TRUE, (guint) 0);
 754 #line 105 "header_area.vala"
 755         volpan_button = g_object_ref_sink ((HildonButton*) hildon_button_new (HILDON_SIZE_AUTO_HEIGHT | HILDON_SIZE_AUTO_WIDTH, HILDON_BUTTON_ARRANGEMENT_HORIZONTAL));
 756 #line 107 "header_area.vala"
 757         hildon_button_set_image (volpan_button, GTK_WIDGET (_tmp1_ = g_object_ref_sink ((GtkImage*) gtk_image_new_from_icon_name ("statusarea_volumelevel4", GTK_ICON_SIZE_BUTTON))));
 758 #line 759 "header_area.c"
 759         _g_object_unref0 (_tmp1_);
 760 #line 108 "header_area.vala"
 761         hildon_button_set_image_position (volpan_button, GTK_POS_LEFT);
 762 #line 109 "header_area.vala"
 763         g_signal_connect_object (GTK_BUTTON (volpan_button), "clicked", (GCallback) _audio_track_header_do_volpan_popup_gtk_button_clicked, self, 0);
 764 #line 110 "header_area.vala"
 765         gtk_container_add (GTK_CONTAINER (vbox), GTK_WIDGET (volpan_button));
 766 #line 116 "header_area.vala"
 767         gtk_container_add (GTK_CONTAINER (self), GTK_WIDGET (vbox));
 768 #line 769 "header_area.c"
 769         _g_object_unref0 (vbox);
 770         _g_object_unref0 (volpan_button);
 771         return self;
 772 }
 773
 774
 775 #line 91 "header_area.vala"
 776 AudioTrackHeader* audio_track_header_new (ModelAudioTrack* track, HeaderArea* header, gint height) {
 777 #line 91 "header_area.vala"
 778         return audio_track_header_construct (TYPE_AUDIO_TRACK_HEADER, track, header, height);
 779 #line 780 "header_area.c"
 780 }
 781
 782
 783 #line 148 "header_area.vala"
 784 static void _audio_track_header_on_volume_updated_id_works_volume_and_pan_pop_up_volume_updated (IdWorksVolumeAndPanPopUp* _sender, double volume, gpointer self) {
 785 #line 786 "header_area.c"
 786         audio_track_header_on_volume_updated (self, volume);
 787 }
 788
 789
 790 #line 131 "header_area.vala"
 791 static void _audio_track_header_on_panorama_updated_id_works_volume_and_pan_pop_up_panorama_updated (IdWorksVolumeAndPanPopUp* _sender, double panorama, gpointer self) {
 792 #line 793 "header_area.c"
 793         audio_track_header_on_panorama_updated (self, panorama);
 794 }
 795
 796
 797 #line 119 "header_area.vala"
 798 static void audio_track_header_do_volpan_popup (AudioTrackHeader* self) {
 799 #line 800 "header_area.c"
 800         char* _tmp0_;
 801         IdWorksVolumeAndPanPopUp* _tmp1_;
 802         IdWorksVolumeAndPanPopUp* dlg;
 803         IdWorksVolumeAndPanPopUp* _tmp2_;
 804 #line 119 "header_area.vala"
 805         g_return_if_fail (IS_AUDIO_TRACK_HEADER (self));
 806 #line 120 "header_area.vala"
 807         dlg = (_tmp1_ = g_object_ref_sink (id_works_volume_and_pan_pop_up_new (GTK_WIDGET (self), _tmp0_ = g_strconcat ("Volume / Pan: ", TRACK_HEADER (self)->track->display_name, NULL))), _g_free0 (_tmp0_), _tmp1_);
 808 #line 122 "header_area.vala"
 809         id_works_volume_and_pan_pop_up_set_volume (dlg, self->volume);
 810 #line 123 "header_area.vala"
 811         id_works_volume_and_pan_pop_up_set_panorama (dlg, self->panorama);
 812 #line 124 "header_area.vala"
 813         g_signal_connect_object (dlg, "volume-updated", (GCallback) _audio_track_header_on_volume_updated_id_works_volume_and_pan_pop_up_volume_updated, self, 0);
 814 #line 125 "header_area.vala"
 815         g_signal_connect_object (dlg, "panorama-updated", (GCallback) _audio_track_header_on_panorama_updated_id_works_volume_and_pan_pop_up_panorama_updated, self, 0);
 816 #line 126 "header_area.vala"
 817         gtk_dialog_run (GTK_DIALOG (dlg));
 818 #line 127 "header_area.vala"
 819         gtk_object_destroy (GTK_OBJECT (dlg));
 820 #line 128 "header_area.vala"
 821         dlg = (_tmp2_ = NULL, _g_object_unref0 (dlg), _tmp2_);
 822 #line 823 "header_area.c"
 823         _g_object_unref0 (dlg);
 824 }
 825
 826
 827 #line 131 "header_area.vala"
 828 static void audio_track_header_on_panorama_updated (AudioTrackHeader* self, double val) {
 829 #line 830 "header_area.c"
 830         ModelTrack* _tmp0_;
 831         ModelAudioTrack* audio_track;
 832 #line 131 "header_area.vala"
 833         g_return_if_fail (IS_AUDIO_TRACK_HEADER (self));
 834 #line 132 "header_area.vala"
 835         logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_pan_value_changed");
 836 #line 133 "header_area.vala"
 837         audio_track = _g_object_ref0 ((_tmp0_ = TRACK_HEADER (self)->track, MODEL_IS_AUDIO_TRACK (_tmp0_) ? ((ModelAudioTrack*) _tmp0_) : NULL));
 838 #line 134 "header_area.vala"
 839         if (audio_track != NULL) {
 840 #line 135 "header_area.vala"
 841                 model_audio_track_set_pan (audio_track, val);
 842 #line 843 "header_area.c"
 843         }
 844         _g_object_unref0 (audio_track);
 845 }
 846
 847
 848 #line 148 "header_area.vala"
 849 static void audio_track_header_on_volume_updated (AudioTrackHeader* self, double val) {
 850 #line 851 "header_area.c"
 851         ModelTrack* _tmp0_;
 852         ModelAudioTrack* audio_track;
 853 #line 148 "header_area.vala"
 854         g_return_if_fail (IS_AUDIO_TRACK_HEADER (self));
 855 #line 149 "header_area.vala"
 856         logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_volume_value_changed");
 857 #line 150 "header_area.vala"
 858         audio_track = _g_object_ref0 ((_tmp0_ = TRACK_HEADER (self)->track, MODEL_IS_AUDIO_TRACK (_tmp0_) ? ((ModelAudioTrack*) _tmp0_) : NULL));
 859 #line 151 "header_area.vala"
 860         if (audio_track != NULL) {
 861 #line 152 "header_area.vala"
 862                 model_audio_track_set_volume (audio_track, val);
 863 #line 864 "header_area.c"
 864         }
 865         _g_object_unref0 (audio_track);
 866 }
 867
 868
 869 #line 164 "header_area.vala"
 870 static void audio_track_header_on_parameter_changed (AudioTrackHeader* self, ModelParameter parameter, double new_value) {
 871 #line 872 "header_area.c"
 872         ModelTrack* _tmp0_;
 873         ModelAudioTrack* audio_track;
 874 #line 164 "header_area.vala"
 875         g_return_if_fail (IS_AUDIO_TRACK_HEADER (self));
 876 #line 165 "header_area.vala"
 877         logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_parameter_changed");
 878 #line 166 "header_area.vala"
 879         audio_track = _g_object_ref0 ((_tmp0_ = TRACK_HEADER (self)->track, MODEL_IS_AUDIO_TRACK (_tmp0_) ? ((ModelAudioTrack*) _tmp0_) : NULL));
 880 #line 167 "header_area.vala"
 881         g_assert (audio_track != NULL);
 882 #line 168 "header_area.vala"
 883         switch (parameter) {
 884 #line 885 "header_area.c"
 885                 case MODEL_PARAMETER_VOLUME:
 886                 {
 887 #line 170 "header_area.vala"
 888                         self->volume = new_value;
 889 #line 171 "header_area.vala"
 890                         break;
 891 #line 892 "header_area.c"
 892                 }
 893                 case MODEL_PARAMETER_PAN:
 894                 {
 895 #line 173 "header_area.vala"
 896                         self->panorama = new_value;
 897 #line 174 "header_area.vala"
 898                         break;
 899 #line 900 "header_area.c"
 900                 }
 901         }
 902         _g_object_unref0 (audio_track);
 903 }
 904
 905
 906 static void audio_track_header_class_init (AudioTrackHeaderClass * klass) {
 907         audio_track_header_parent_class = g_type_class_peek_parent (klass);
 908         G_OBJECT_CLASS (klass)->finalize = audio_track_header_finalize;
 909 }
 910
 911
 912 static void audio_track_header_instance_init (AudioTrackHeader * self) {
 913 }
 914
 915
 916 static void audio_track_header_finalize (GObject* obj) {
 917         AudioTrackHeader * self;
 918         self = AUDIO_TRACK_HEADER (obj);
 919         G_OBJECT_CLASS (audio_track_header_parent_class)->finalize (obj);
 920 }
 921
 922
 923 GType audio_track_header_get_type (void) {
 924         static volatile gsize audio_track_header_type_id__volatile = 0;
 925         if (g_once_init_enter (&audio_track_header_type_id__volatile)) {
 926                 static const GTypeInfo g_define_type_info = { sizeof (AudioTrackHeaderClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) audio_track_header_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (AudioTrackHeader), 0, (GInstanceInitFunc) audio_track_header_instance_init, NULL };
 927                 GType audio_track_header_type_id;
 928                 audio_track_header_type_id = g_type_register_static (TYPE_TRACK_HEADER, "AudioTrackHeader", &g_define_type_info, 0);
 929                 g_once_init_leave (&audio_track_header_type_id__volatile, audio_track_header_type_id);
 930         }
 931         return audio_track_header_type_id__volatile;
 932 }
 933
 934
 935 #line 233 "header_area.vala"
 936 static void _header_area_on_trackview_removed_time_line_trackview_removed (TimeLine* _sender, TrackView* trackview, gpointer self) {
 937 #line 938 "header_area.c"
 938         header_area_on_trackview_removed (self, trackview);
 939 }
 940
 941
 942 #line 219 "header_area.vala"
 943 static void _header_area_on_trackview_added_time_line_trackview_added (TimeLine* _sender, TrackView* trackview, gpointer self) {
 944 #line 945 "header_area.c"
 945         header_area_on_trackview_added (self, trackview);
 946 }
 947
 948
 949 #line 198 "header_area.vala"
 950 HeaderArea* header_area_construct (GType object_type, Recorder* recorder, ModelTimeSystem* provider, gint height) {
 951 #line 952 "header_area.c"
 952         HeaderArea * self;
 953         GtkVBox* _tmp0_;
 954         GtkDrawingArea* status_bar;
 955         TrackSeparator* _tmp1_;
 956 #line 198 "header_area.vala"
 957         g_return_val_if_fail (IS_RECORDER (recorder), NULL);
 958 #line 198 "header_area.vala"
 959         g_return_val_if_fail (MODEL_IS_TIME_SYSTEM (provider), NULL);
 960 #line 961 "header_area.c"
 961         self = g_object_newv (object_type, 0, NULL);
 962 #line 199 "header_area.vala"
 963         self->priv->project = MODEL_PROJECT (recorder->project);
 964 #line 200 "header_area.vala"
 965         g_signal_connect_object (recorder->timeline, "trackview-removed", (GCallback) _header_area_on_trackview_removed_time_line_trackview_removed, self, 0);
 966 #line 201 "header_area.vala"
 967         g_signal_connect_object (recorder->timeline, "trackview-added", (GCallback) _header_area_on_trackview_added_time_line_trackview_added, self, 0);
 968 #line 203 "header_area.vala"
 969         gtk_widget_set_size_request (GTK_WIDGET (self), TRACK_HEADER_width, 0);
 970 #line 204 "header_area.vala"
 971         gtk_widget_modify_bg (GTK_WIDGET (self), GTK_STATE_NORMAL, &self->background_color);
 972 #line 206 "header_area.vala"
 973         self->priv->vbox = (_tmp0_ = g_object_ref_sink ((GtkVBox*) gtk_vbox_new (FALSE, 0)), _g_object_unref0 (self->priv->vbox), _tmp0_);
 974 #line 207 "header_area.vala"
 975         gtk_container_add (GTK_CONTAINER (self), GTK_WIDGET (self->priv->vbox));
 976 #line 208 "header_area.vala"
 977         status_bar = GTK_DRAWING_AREA (g_object_ref_sink (view_status_bar_new (self->priv->project, provider, height)));
 978 #line 210 "header_area.vala"
 979         gtk_box_pack_start (GTK_BOX (self->priv->vbox), GTK_WIDGET (status_bar), FALSE, FALSE, (guint) 0);
 980 #line 212 "header_area.vala"
 981         gtk_box_pack_start (GTK_BOX (self->priv->vbox), GTK_WIDGET (_tmp1_ = g_object_ref_sink (track_separator_new ())), FALSE, FALSE, (guint) 0);
 982 #line 983 "header_area.c"
 983         _g_object_unref0 (_tmp1_);
 984         {
 985                 GeeIterator* _track_it;
 986                 _track_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (recorder->timeline->tracks));
 987 #line 214 "header_area.vala"
 988                 while (TRUE) {
 989 #line 990 "header_area.c"
 990                         TrackView* track;
 991 #line 214 "header_area.vala"
 992                         if (!gee_iterator_next (_track_it)) {
 993 #line 214 "header_area.vala"
 994                                 break;
 995 #line 996 "header_area.c"
 996                         }
 997 #line 214 "header_area.vala"
 998                         track = (TrackView*) gee_iterator_get (_track_it);
 999 #line 215 "header_area.vala"
1000                         header_area_on_trackview_added (self, track);
1001 #line 1002 "header_area.c"
1002                         _g_object_unref0 (track);
1003                 }
1004                 _g_object_unref0 (_track_it);
1005         }
1006         _g_object_unref0 (status_bar);
1007         return self;
1008 }
1009
1010
1011 #line 198 "header_area.vala"
1012 HeaderArea* header_area_new (Recorder* recorder, ModelTimeSystem* provider, gint height) {
1013 #line 198 "header_area.vala"
1014         return header_area_construct (TYPE_HEADER_AREA, recorder, provider, height);
1015 #line 1016 "header_area.c"
1016 }
1017
1018
1019 #line 219 "header_area.vala"
1020 void header_area_on_trackview_added (HeaderArea* self, TrackView* trackview) {
1021 #line 1022 "header_area.c"
1022         ModelTrack* _tmp0_;
1023         ModelAudioTrack* audio_track;
1024         TrackHeader* header;
1025         TrackSeparator* _tmp1_;
1026 #line 219 "header_area.vala"
1027         g_return_if_fail (IS_HEADER_AREA (self));
1028 #line 219 "header_area.vala"
1029         g_return_if_fail (IS_TRACK_VIEW (trackview));
1030 #line 220 "header_area.vala"
1031         logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_trackview_added");
1032 #line 221 "header_area.vala"
1033         audio_track = (_tmp0_ = track_view_get_track (trackview), MODEL_IS_AUDIO_TRACK (_tmp0_) ? ((ModelAudioTrack*) _tmp0_) : NULL);
1034 #line 222 "header_area.vala"
1035         g_assert (audio_track != NULL);
1036 #line 226 "header_area.vala"
1037         header = TRACK_HEADER (g_object_ref_sink (audio_track_header_new (audio_track, self, track_view_get_track_height (trackview))));
1038 #line 227 "header_area.vala"
1039         gtk_box_pack_start (GTK_BOX (self->priv->vbox), GTK_WIDGET (header), FALSE, FALSE, (guint) 0);
1040 #line 228 "header_area.vala"
1041         gtk_box_pack_start (GTK_BOX (self->priv->vbox), GTK_WIDGET (_tmp1_ = g_object_ref_sink (track_separator_new ())), FALSE, FALSE, (guint) 0);
1042 #line 1043 "header_area.c"
1043         _g_object_unref0 (_tmp1_);
1044 #line 229 "header_area.vala"
1045         gtk_widget_show_all (GTK_WIDGET (self->priv->vbox));
1046 #line 230 "header_area.vala"
1047         header_area_select (self, MODEL_TRACK (audio_track));
1048 #line 1049 "header_area.c"
1049         _g_object_unref0 (audio_track);
1050         _g_object_unref0 (header);
1051 }
1052
1053
1054 #line 233 "header_area.vala"
1055 void header_area_on_trackview_removed (HeaderArea* self, TrackView* trackview) {
1056 #line 1057 "header_area.c"
1057         ModelTrack* track;
1058         TrackHeader* my_track_header;
1059         GtkHSeparator* my_separator;
1060 #line 233 "header_area.vala"
1061         g_return_if_fail (IS_HEADER_AREA (self));
1062 #line 233 "header_area.vala"
1063         g_return_if_fail (IS_TRACK_VIEW (trackview));
1064 #line 234 "header_area.vala"
1065         logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_trackview_removed");
1066 #line 235 "header_area.vala"
1067         track = track_view_get_track (trackview);
1068 #line 236 "header_area.vala"
1069         my_track_header = NULL;
1070 #line 237 "header_area.vala"
1071         my_separator = NULL;
1072 #line 1073 "header_area.c"
1073         {
1074                 GList* widget_collection;
1075                 GList* widget_it;
1076 #line 238 "header_area.vala"
1077                 widget_collection = gtk_container_get_children (GTK_CONTAINER (self->priv->vbox));
1078 #line 1079 "header_area.c"
1079                 for (widget_it = widget_collection; widget_it != NULL; widget_it = widget_it->next) {
1080                         GtkWidget* widget;
1081 #line 238 "header_area.vala"
1082                         widget = _g_object_ref0 ((GtkWidget*) widget_it->data);
1083 #line 1084 "header_area.c"
1084                         {
1085 #line 239 "header_area.vala"
1086                                 if (my_track_header == NULL) {
1087 #line 1088 "header_area.c"
1088                                         GtkWidget* _tmp0_;
1089                                         TrackHeader* track_header;
1090                                         gboolean _tmp1_ = FALSE;
1091 #line 240 "header_area.vala"
1092                                         track_header = _g_object_ref0 ((_tmp0_ = widget, IS_TRACK_HEADER (_tmp0_) ? ((TrackHeader*) _tmp0_) : NULL));
1093 #line 241 "header_area.vala"
1094                                         if (track_header != NULL) {
1095 #line 1096 "header_area.c"
1096                                                 ModelTrack* _tmp2_;
1097 #line 241 "header_area.vala"
1098                                                 _tmp1_ = (_tmp2_ = track_header_get_track (track_header)) == track;
1099 #line 1100 "header_area.c"
1100                                                 _g_object_unref0 (_tmp2_);
1101                                         } else {
1102 #line 241 "header_area.vala"
1103                                                 _tmp1_ = FALSE;
1104 #line 1105 "header_area.c"
1105                                         }
1106 #line 241 "header_area.vala"
1107                                         if (_tmp1_) {
1108 #line 1109 "header_area.c"
1109                                                 TrackHeader* _tmp3_;
1110 #line 242 "header_area.vala"
1111                                                 my_track_header = (_tmp3_ = _g_object_ref0 (track_header), _g_object_unref0 (my_track_header), _tmp3_);
1112 #line 1113 "header_area.c"
1113                                         }
1114                                         _g_object_unref0 (track_header);
1115                                 } else {
1116                                         GtkHSeparator* _tmp5_;
1117                                         GtkWidget* _tmp4_;
1118 #line 245 "header_area.vala"
1119                                         my_separator = (_tmp5_ = _g_object_ref0 ((_tmp4_ = widget, GTK_IS_HSEPARATOR (_tmp4_) ? ((GtkHSeparator*) _tmp4_) : NULL)), _g_object_unref0 (my_separator), _tmp5_);
1120 #line 1121 "header_area.c"
1121                                         _g_object_unref0 (widget);
1122 #line 246 "header_area.vala"
1123                                         break;
1124 #line 1125 "header_area.c"
1125                                 }
1126                                 _g_object_unref0 (widget);
1127                         }
1128                 }
1129 #line 238 "header_area.vala"
1130                 _g_list_free0 (widget_collection);
1131 #line 1132 "header_area.c"
1132         }
1133 #line 250 "header_area.vala"
1134         if (my_track_header != NULL) {
1135 #line 251 "header_area.vala"
1136                 gtk_container_remove (GTK_CONTAINER (self->priv->vbox), GTK_WIDGET (my_track_header));
1137 #line 1138 "header_area.c"
1138         }
1139 #line 254 "header_area.vala"
1140         if (my_separator != NULL) {
1141 #line 255 "header_area.vala"
1142                 gtk_container_remove (GTK_CONTAINER (self->priv->vbox), GTK_WIDGET (my_separator));
1143 #line 1144 "header_area.c"
1144         }
1145 #line 258 "header_area.vala"
1146         if (gee_collection_get_size (GEE_COLLECTION (self->priv->project->tracks)) != 0) {
1147 #line 1148 "header_area.c"
1148                 ModelTrack* _tmp6_;
1149 #line 259 "header_area.vala"
1150                 header_area_select (self, _tmp6_ = (ModelTrack*) gee_abstract_list_get (GEE_ABSTRACT_LIST (self->priv->project->tracks), 0));
1151 #line 1152 "header_area.c"
1152                 _g_object_unref0 (_tmp6_);
1153         }
1154         _g_object_unref0 (track);
1155         _g_object_unref0 (my_track_header);
1156         _g_object_unref0 (my_separator);
1157 }
1158
1159
1160 #line 263 "header_area.vala"
1161 void header_area_select (HeaderArea* self, ModelTrack* track) {
1162 #line 263 "header_area.vala"
1163         g_return_if_fail (IS_HEADER_AREA (self));
1164 #line 263 "header_area.vala"
1165         g_return_if_fail (MODEL_IS_TRACK (track));
1166 #line 1167 "header_area.c"
1167         {
1168                 GeeIterator* _t_it;
1169                 _t_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (self->priv->project->tracks));
1170 #line 264 "header_area.vala"
1171                 while (TRUE) {
1172 #line 1173 "header_area.c"
1173                         ModelTrack* t;
1174 #line 264 "header_area.vala"
1175                         if (!gee_iterator_next (_t_it)) {
1176 #line 264 "header_area.vala"
1177                                 break;
1178 #line 1179 "header_area.c"
1179                         }
1180 #line 264 "header_area.vala"
1181                         t = (ModelTrack*) gee_iterator_get (_t_it);
1182 #line 265 "header_area.vala"
1183                         model_track_set_selected (t, t == track);
1184 #line 1185 "header_area.c"
1185                         _g_object_unref0 (t);
1186                 }
1187                 _g_object_unref0 (_t_it);
1188         }
1189 }
1190
1191
1192 static void header_area_class_init (HeaderAreaClass * klass) {
1193         header_area_parent_class = g_type_class_peek_parent (klass);
1194         g_type_class_add_private (klass, sizeof (HeaderAreaPrivate));
1195         G_OBJECT_CLASS (klass)->finalize = header_area_finalize;
1196 }
1197
1198
1199 static void header_area_instance_init (HeaderArea * self) {
1200         GdkColor _tmp6_ = {0};
1201         self->priv = HEADER_AREA_GET_PRIVATE (self);
1202         self->background_color = (parse_color ("#666", &_tmp6_), _tmp6_);
1203 }
1204
1205
1206 static void header_area_finalize (GObject* obj) {
1207         HeaderArea * self;
1208         self = HEADER_AREA (obj);
1209         _g_object_unref0 (self->priv->vbox);
1210         G_OBJECT_CLASS (header_area_parent_class)->finalize (obj);
1211 }
1212
1213
1214 GType header_area_get_type (void) {
1215         static volatile gsize header_area_type_id__volatile = 0;
1216         if (g_once_init_enter (&header_area_type_id__volatile)) {
1217                 static const GTypeInfo g_define_type_info = { sizeof (HeaderAreaClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) header_area_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (HeaderArea), 0, (GInstanceInitFunc) header_area_instance_init, NULL };
1218                 GType header_area_type_id;
1219                 header_area_type_id = g_type_register_static (GTK_TYPE_EVENT_BOX, "HeaderArea", &g_define_type_info, 0);
1220                 g_once_init_leave (&header_area_type_id__volatile, header_area_type_id);
1221         }
1222         return header_area_type_id__volatile;
1223 }
1224
1225
1226
1227