git.maemo.org Git - fillmore/blob - src/test/debug/util.c

   1 /* util.c generated by valac, the Vala compiler
   2  * generated from util.vala, do not modify */
   3
   4 /* Copyright 2009 Yorba Foundation
   5  *
   6  * This software is licensed under the GNU Lesser General Public License
   7  * (version 2.1 or later).  See the COPYING file in this distribution.
   8  */
   9
  10 #include <glib.h>
  11 #include <glib-object.h>
  12 #include <float.h>
  13 #include <math.h>
  14 #include <stdlib.h>
  15 #include <string.h>
  16 #include <gst/gst.h>
  17 #include <glib/gstdio.h>
  18 #include <gdk/gdk.h>
  19 #include <gtk/gtk.h>
  20 #include <cairo.h>
  21
  22 #define _g_free0(var) (var = (g_free (var), NULL))
  23
  24 #define TYPE_FRACTION (fraction_get_type ())
  25 typedef struct _Fraction Fraction;
  26
  27 #define TYPE_TIME_CODE (time_code_get_type ())
  28 typedef struct _TimeCode TimeCode;
  29 #define _g_error_free0(var) ((var == NULL) ? NULL : (var = (g_error_free (var), NULL)))
  30 #define _g_checksum_free0(var) ((var == NULL) ? NULL : (var = (g_checksum_free (var), NULL)))
  31 #define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
  32 #define _cairo_destroy0(var) ((var == NULL) ? NULL : (var = (cairo_destroy (var), NULL)))
  33 #define _gst_object_unref0(var) ((var == NULL) ? NULL : (var = (gst_object_unref (var), NULL)))
  34
  35 typedef enum  {
  36         MEDIA_ERROR_MISSING_PLUGIN
  37 } MediaError;
  38 #define MEDIA_ERROR media_error_quark ()
  39 struct _Fraction {
  40         gint numerator;
  41         gint denominator;
  42 };
  43
  44 struct _TimeCode {
  45         gint hour;
  46         gint minute;
  47         gint second;
  48         gint frame;
  49         gboolean drop_code;
  50 };
  51
  52 typedef enum  {
  53         GDK_Control_L,
  54         GDK_Control_R,
  55         GDK_Down,
  56         GDK_equal,
  57         GDK_Escape,
  58         GDK_KP_Add,
  59         GDK_KP_Enter,
  60         GDK_KP_Subtract,
  61         GDK_Left,
  62         GDK_minus,
  63         GDK_plus,
  64         GDK_Return,
  65         GDK_Right,
  66         GDK_Shift_L,
  67         GDK_Shift_R,
  68         GDK_underscore,
  69         GDK_Up
  70 } KeySyms;
  71
  72
  73 extern gboolean debug_enabled;
  74 gboolean debug_enabled = FALSE;
  75 extern GdkModifierType GDK_SHIFT_ALT_CONTROL_MASK;
  76 GdkModifierType GDK_SHIFT_ALT_CONTROL_MASK = (GDK_SHIFT_MASK | GDK_MOD1_MASK) | GDK_CONTROL_MASK;
  77
  78 GQuark media_error_quark (void);
  79 float float_abs (float f);
  80 gboolean float_within (double f, double epsilon);
  81 gint sign (gint x);
  82 gint stricmp (const char* str1, const char* str2);
  83 char** copy_array (char** source, int source_length1, int* result_length1);
  84 void print_debug (const char* text);
  85 GType fraction_get_type (void);
  86 Fraction* fraction_dup (const Fraction* self);
  87 void fraction_free (Fraction* self);
  88 void fraction_init (Fraction *self, gint numerator, gint denominator);
  89 void fraction_init_from_string (Fraction *self, const char* s);
  90 gboolean fraction_equal (Fraction *self, Fraction* f);
  91 gint fraction_nearest_int (Fraction *self);
  92 char* fraction_to_string (Fraction *self);
  93 GType time_code_get_type (void);
  94 TimeCode* time_code_dup (const TimeCode* self);
  95 void time_code_free (TimeCode* self);
  96 void time_code_get_from_length (TimeCode *self, gint64 length);
  97 char* time_code_to_string (TimeCode *self);
  98 gboolean time_in_range (gint64 time, gint64 center, gint64 delta);
  99 char* isolate_filename (const char* path);
 100 char* get_file_extension (const char* path);
 101 char* append_extension (const char* path, const char* extension);
 102 gboolean version_at_least (const char* v, const char* w);
 103 gboolean get_file_md5_checksum (const char* filename, char** checksum);
 104 void save_file_md5_checksum (const char* filename, const char* checksum);
 105 gboolean md5_checksum_on_file (const char* filename, char** checksum);
 106 void parse_color (const char* color, GdkColor* result);
 107 GtkWidget* get_widget (GtkUIManager* manager, const char* name);
 108 #define LINE_WIDTH 1.0
 109 #define RADIUS 15.0
 110 #define ANTIALIAS CAIRO_ANTIALIAS_DEFAULT
 111 void draw_rounded_rectangle (GdkWindow* window, GdkColor* color, gboolean filled, gint x0, gint y0, gint width, gint height);
 112 void draw_right_rounded_rectangle (GdkWindow* window, GdkColor* color, gboolean filled, gint x0, gint y0, gint width, gint height);
 113 void draw_left_rounded_rectangle (GdkWindow* window, GdkColor* color, gboolean filled, gint x0, gint y0, gint width, gint height);
 114 void draw_square_rectangle (GdkWindow* window, GdkColor* color, gboolean filled, gint x, gint y, gint width, gint height);
 115 gboolean is_drop_frame_rate (Fraction* r);
 116 gint64 frame_to_time_with_rate (gint frame, Fraction* rate);
 117 gint time_to_frame_with_rate (gint64 time, Fraction* rate);
 118 void frame_to_time (gint frame, Fraction* rate, TimeCode* result);
 119 char* frame_to_string (gint frame, Fraction* rate);
 120 void breakup_time (gint64 time, gint* hours, gint* minutes, double* seconds);
 121 char* time_to_HHMMSS (gint64 time);
 122 char* time_to_string (gint64 time);
 123 GstElement* make_element_with_name (const char* element_name, const char* display_name, GError** error);
 124 GstElement* make_element (const char* name, GError** error);
 125 static void _vala_array_destroy (gpointer array, gint array_length, GDestroyNotify destroy_func);
 126 static void _vala_array_free (gpointer array, gint array_length, GDestroyNotify destroy_func);
 127 static gint _vala_array_length (gpointer array);
 128 static int _vala_strcmp0 (const char * str1, const char * str2);
 129
 130 const GtkTargetEntry drag_target_entries[1] = {{"text/uri-list", (guint) 0, (guint) 0}};
 131
 132
 133 GQuark media_error_quark (void) {
 134         return g_quark_from_static_string ("media_error-quark");
 135 }
 136
 137
 138 #line 12 "util.vala"
 139 float float_abs (float f) {
 140 #line 141 "util.c"
 141         float result = 0.0F;
 142 #line 13 "util.vala"
 143         if (f < 0.0f) {
 144 #line 145 "util.c"
 145                 result = -f;
 146 #line 14 "util.vala"
 147                 return result;
 148 #line 149 "util.c"
 149         }
 150         result = f;
 151 #line 15 "util.vala"
 152         return result;
 153 #line 154 "util.c"
 154 }
 155
 156
 157 #line 18 "util.vala"
 158 gboolean float_within (double f, double epsilon) {
 159 #line 160 "util.c"
 160         gboolean result = FALSE;
 161         result = float_abs ((float) f) < epsilon;
 162 #line 19 "util.vala"
 163         return result;
 164 #line 165 "util.c"
 165 }
 166
 167
 168 #line 22 "util.vala"
 169 gint sign (gint x) {
 170 #line 171 "util.c"
 171         gint result = 0;
 172         gint _tmp0_ = 0;
 173 #line 23 "util.vala"
 174         if (x == 0) {
 175 #line 176 "util.c"
 176                 result = 0;
 177 #line 24 "util.vala"
 178                 return result;
 179 #line 180 "util.c"
 180         }
 181 #line 25 "util.vala"
 182         if (x < 0) {
 183 #line 25 "util.vala"
 184                 _tmp0_ = -1;
 185 #line 186 "util.c"
 186         } else {
 187 #line 25 "util.vala"
 188                 _tmp0_ = 1;
 189 #line 190 "util.c"
 190         }
 191         result = _tmp0_;
 192 #line 25 "util.vala"
 193         return result;
 194 #line 195 "util.c"
 195 }
 196
 197
 198 #line 28 "util.vala"
 199 gint stricmp (const char* str1, const char* str2) {
 200 #line 201 "util.c"
 201         gint result = 0;
 202         char* temp_str1;
 203         char* temp_str2;
 204 #line 28 "util.vala"
 205         g_return_val_if_fail (str1 != NULL, 0);
 206 #line 28 "util.vala"
 207         g_return_val_if_fail (str2 != NULL, 0);
 208 #line 29 "util.vala"
 209         temp_str1 = g_utf8_casefold (str1, (gssize) (-1));
 210 #line 30 "util.vala"
 211         temp_str2 = g_utf8_casefold (str2, (gssize) (-1));
 212 #line 213 "util.c"
 213         result = g_utf8_collate (temp_str1, temp_str2);
 214         _g_free0 (temp_str1);
 215         _g_free0 (temp_str2);
 216 #line 32 "util.vala"
 217         return result;
 218 #line 219 "util.c"
 219 }
 220
 221
 222 #line 36 "util.vala"
 223 char** copy_array (char** source, int source_length1, int* result_length1) {
 224 #line 225 "util.c"
 225         char** result = NULL;
 226         char** _tmp0_;
 227         gint _destination_size_;
 228         gint destination_length1;
 229         char** destination;
 230         gint i;
 231         char** _tmp2_;
 232         destination = (_tmp0_ = g_new0 (char*, source_length1 + 1), destination_length1 = source_length1, _destination_size_ = destination_length1, _tmp0_);
 233 #line 38 "util.vala"
 234         i = 0;
 235 #line 236 "util.c"
 236         {
 237                 char** item_collection;
 238                 int item_collection_length1;
 239                 int item_it;
 240 #line 39 "util.vala"
 241                 item_collection = source;
 242 #line 243 "util.c"
 243                 item_collection_length1 = source_length1;
 244                 for (item_it = 0; item_it < source_length1; item_it = item_it + 1) {
 245                         char* item;
 246                         item = g_strdup (item_collection[item_it]);
 247                         {
 248                                 char* _tmp1_;
 249 #line 40 "util.vala"
 250                                 destination[i] = (_tmp1_ = g_strdup (item), _g_free0 (destination[i]), _tmp1_);
 251 #line 41 "util.vala"
 252                                 i = i + 1;
 253 #line 254 "util.c"
 254                                 _g_free0 (item);
 255                         }
 256                 }
 257         }
 258         result = (_tmp2_ = destination, *result_length1 = destination_length1, _tmp2_);
 259 #line 43 "util.vala"
 260         return result;
 261 #line 262 "util.c"
 262         destination = (_vala_array_free (destination, destination_length1, (GDestroyNotify) g_free), NULL);
 263 }
 264
 265
 266 #line 50 "util.vala"
 267 void print_debug (const char* text) {
 268 #line 50 "util.vala"
 269         g_return_if_fail (text != NULL);
 270 #line 51 "util.vala"
 271         if (!debug_enabled) {
 272 #line 52 "util.vala"
 273                 return;
 274 #line 275 "util.c"
 275         }
 276 #line 54 "util.vala"
 277         g_debug ("util.vala:54: %s", text);
 278 #line 279 "util.c"
 279 }
 280
 281
 282 #line 61 "util.vala"
 283 void fraction_init (Fraction *self, gint numerator, gint denominator) {
 284 #line 285 "util.c"
 285         memset (self, 0, sizeof (Fraction));
 286 #line 62 "util.vala"
 287         (*self).numerator = numerator;
 288 #line 63 "util.vala"
 289         (*self).denominator = denominator;
 290 #line 291 "util.c"
 291 }
 292
 293
 294 #line 66 "util.vala"
 295 void fraction_init_from_string (Fraction *self, const char* s) {
 296 #line 297 "util.c"
 297         char** _tmp1_;
 298         gint _elements_size_;
 299         gint elements_length1;
 300         char** _tmp0_;
 301         char** elements;
 302 #line 66 "util.vala"
 303         g_return_if_fail (s != NULL);
 304 #line 305 "util.c"
 305         memset (self, 0, sizeof (Fraction));
 306         elements = (_tmp1_ = _tmp0_ = g_strsplit (s, "/", 0), elements_length1 = _vala_array_length (_tmp0_), _elements_size_ = elements_length1, _tmp1_);
 307 #line 68 "util.vala"
 308         if (elements_length1 != 2) {
 309 #line 69 "util.vala"
 310                 (*self).numerator = 0;
 311 #line 70 "util.vala"
 312                 (*self).denominator = 0;
 313 #line 314 "util.c"
 314         } else {
 315 #line 72 "util.vala"
 316                 (*self).numerator = atoi (elements[0]);
 317 #line 73 "util.vala"
 318                 (*self).denominator = atoi (elements[1]);
 319 #line 320 "util.c"
 320         }
 321         elements = (_vala_array_free (elements, elements_length1, (GDestroyNotify) g_free), NULL);
 322 }
 323
 324
 325 #line 77 "util.vala"
 326 gboolean fraction_equal (Fraction *self, Fraction* f) {
 327 #line 328 "util.c"
 328         gboolean result = FALSE;
 329 #line 78 "util.vala"
 330         if (float_abs (((*self).numerator / ((float) (*self).denominator)) - ((*f).numerator / ((float) (*f).denominator))) <= (1000.0f / 1001.0f)) {
 331 #line 332 "util.c"
 332                 result = TRUE;
 333 #line 80 "util.vala"
 334                 return result;
 335 #line 336 "util.c"
 336         }
 337         result = FALSE;
 338 #line 81 "util.vala"
 339         return result;
 340 #line 341 "util.c"
 341 }
 342
 343
 344 #line 84 "util.vala"
 345 gint fraction_nearest_int (Fraction *self) {
 346 #line 347 "util.c"
 347         gint result = 0;
 348         result = (gint) ((((double) (*self).numerator) / (*self).denominator) + 0.5);
 349 #line 85 "util.vala"
 350         return result;
 351 #line 352 "util.c"
 352 }
 353
 354
 355 #line 88 "util.vala"
 356 char* fraction_to_string (Fraction *self) {
 357 #line 358 "util.c"
 358         char* result = NULL;
 359         result = g_strdup_printf ("%d/%d", (*self).numerator, (*self).denominator);
 360 #line 89 "util.vala"
 361         return result;
 362 #line 363 "util.c"
 363 }
 364
 365
 366 Fraction* fraction_dup (const Fraction* self) {
 367         Fraction* dup;
 368         dup = g_new0 (Fraction, 1);
 369         memcpy (dup, self, sizeof (Fraction));
 370         return dup;
 371 }
 372
 373
 374 void fraction_free (Fraction* self) {
 375         g_free (self);
 376 }
 377
 378
 379 GType fraction_get_type (void) {
 380         static volatile gsize fraction_type_id__volatile = 0;
 381         if (g_once_init_enter (&fraction_type_id__volatile)) {
 382                 GType fraction_type_id;
 383                 fraction_type_id = g_boxed_type_register_static ("Fraction", (GBoxedCopyFunc) fraction_dup, (GBoxedFreeFunc) fraction_free);
 384                 g_once_init_leave (&fraction_type_id__volatile, fraction_type_id);
 385         }
 386         return fraction_type_id__volatile;
 387 }
 388
 389
 390 #line 101 "util.vala"
 391 void time_code_get_from_length (TimeCode *self, gint64 length) {
 392 #line 102 "util.vala"
 393         length = length / ((gint64) GST_SECOND);
 394 #line 104 "util.vala"
 395         (*self).hour = (gint) (length / 3600);
 396 #line 105 "util.vala"
 397         (*self).minute = (gint) ((length % 3600) / 60);
 398 #line 106 "util.vala"
 399         (*self).second = (gint) ((length % 3600) % 60);
 400 #line 107 "util.vala"
 401         (*self).frame = 0;
 402 #line 403 "util.c"
 403 }
 404
 405
 406 #line 110 "util.vala"
 407 char* time_code_to_string (TimeCode *self) {
 408 #line 409 "util.c"
 409         char* result = NULL;
 410         char* ret;
 411         char* _tmp3_;
 412         char* _tmp2_;
 413         char* _tmp5_;
 414         char* _tmp4_;
 415         char* _tmp9_;
 416         char* _tmp8_;
 417 #line 111 "util.vala"
 418         ret = g_strdup ("");
 419 #line 112 "util.vala"
 420         if ((*self).hour != 0) {
 421 #line 422 "util.c"
 422                 char* _tmp1_;
 423                 char* _tmp0_;
 424 #line 113 "util.vala"
 425                 ret = (_tmp1_ = g_strconcat (ret, _tmp0_ = g_strdup_printf ("%.2d:", (*self).hour), NULL), _g_free0 (ret), _tmp1_);
 426 #line 427 "util.c"
 427                 _g_free0 (_tmp0_);
 428         }
 429 #line 115 "util.vala"
 430         ret = (_tmp3_ = g_strconcat (ret, _tmp2_ = g_strdup_printf ("%.2d:", (*self).minute), NULL), _g_free0 (ret), _tmp3_);
 431 #line 432 "util.c"
 432         _g_free0 (_tmp2_);
 433 #line 116 "util.vala"
 434         ret = (_tmp5_ = g_strconcat (ret, _tmp4_ = g_strdup_printf ("%.2d", (*self).second), NULL), _g_free0 (ret), _tmp5_);
 435 #line 436 "util.c"
 436         _g_free0 (_tmp4_);
 437 #line 118 "util.vala"
 438         if ((*self).drop_code) {
 439 #line 440 "util.c"
 440                 char* _tmp6_;
 441 #line 119 "util.vala"
 442                 ret = (_tmp6_ = g_strconcat (ret, ";", NULL), _g_free0 (ret), _tmp6_);
 443 #line 444 "util.c"
 444         } else {
 445                 char* _tmp7_;
 446 #line 121 "util.vala"
 447                 ret = (_tmp7_ = g_strconcat (ret, ":", NULL), _g_free0 (ret), _tmp7_);
 448 #line 449 "util.c"
 449         }
 450 #line 122 "util.vala"
 451         ret = (_tmp9_ = g_strconcat (ret, _tmp8_ = g_strdup_printf ("%.2d", (*self).frame), NULL), _g_free0 (ret), _tmp9_);
 452 #line 453 "util.c"
 453         _g_free0 (_tmp8_);
 454         result = ret;
 455 #line 124 "util.vala"
 456         return result;
 457 #line 458 "util.c"
 458 }
 459
 460
 461 TimeCode* time_code_dup (const TimeCode* self) {
 462         TimeCode* dup;
 463         dup = g_new0 (TimeCode, 1);
 464         memcpy (dup, self, sizeof (TimeCode));
 465         return dup;
 466 }
 467
 468
 469 void time_code_free (TimeCode* self) {
 470         g_free (self);
 471 }
 472
 473
 474 GType time_code_get_type (void) {
 475         static volatile gsize time_code_type_id__volatile = 0;
 476         if (g_once_init_enter (&time_code_type_id__volatile)) {
 477                 GType time_code_type_id;
 478                 time_code_type_id = g_boxed_type_register_static ("TimeCode", (GBoxedCopyFunc) time_code_dup, (GBoxedFreeFunc) time_code_free);
 479                 g_once_init_leave (&time_code_type_id__volatile, time_code_type_id);
 480         }
 481         return time_code_type_id__volatile;
 482 }
 483
 484
 485 #line 128 "util.vala"
 486 gboolean time_in_range (gint64 time, gint64 center, gint64 delta) {
 487 #line 488 "util.c"
 488         gboolean result = FALSE;
 489         gint64 diff;
 490 #line 129 "util.vala"
 491         diff = time - center;
 492 #line 493 "util.c"
 493         result = llabs (diff) <= delta;
 494 #line 130 "util.vala"
 495         return result;
 496 #line 497 "util.c"
 497 }
 498
 499
 500 #line 133 "util.vala"
 501 char* isolate_filename (const char* path) {
 502 #line 503 "util.c"
 503         char* result = NULL;
 504         char* str;
 505         gint _tmp1__length1;
 506         char** _tmp1_;
 507         char** _tmp0_;
 508         char* _tmp2_;
 509 #line 133 "util.vala"
 510         g_return_val_if_fail (path != NULL, NULL);
 511 #line 134 "util.vala"
 512         str = g_path_get_basename (path);
 513 #line 514 "util.c"
 514         result = (_tmp2_ = g_strdup ((_tmp1_ = _tmp0_ = g_strsplit (str, ".", 0), _tmp1__length1 = _vala_array_length (_tmp0_), _tmp1_)[0]), _tmp1_ = (_vala_array_free (_tmp1_, _tmp1__length1, (GDestroyNotify) g_free), NULL), _tmp2_);
 515         _g_free0 (str);
 516 #line 135 "util.vala"
 517         return result;
 518 #line 519 "util.c"
 519         _g_free0 (str);
 520 }
 521
 522
 523 #line 138 "util.vala"
 524 char* get_file_extension (const char* path) {
 525 #line 526 "util.c"
 526         char* result = NULL;
 527         const char* dot;
 528         const char* _tmp0_;
 529 #line 138 "util.vala"
 530         g_return_val_if_fail (path != NULL, NULL);
 531 #line 139 "util.vala"
 532         dot = g_utf8_strrchr (path, (gssize) (-1), (gunichar) '.');
 533 #line 534 "util.c"
 534         _tmp0_ = NULL;
 535 #line 140 "util.vala"
 536         if (dot == NULL) {
 537 #line 140 "util.vala"
 538                 _tmp0_ = "";
 539 #line 540 "util.c"
 540         } else {
 541 #line 140 "util.vala"
 542                 _tmp0_ = g_utf8_next_char (dot);
 543 #line 544 "util.c"
 544         }
 545         result = g_strdup (_tmp0_);
 546 #line 140 "util.vala"
 547         return result;
 548 #line 549 "util.c"
 549 }
 550
 551
 552 #line 143 "util.vala"
 553 char* append_extension (const char* path, const char* extension) {
 554 #line 555 "util.c"
 555         char* result = NULL;
 556         char* _tmp0_;
 557         gboolean _tmp1_;
 558         char* _tmp2_;
 559         char* _tmp3_;
 560 #line 143 "util.vala"
 561         g_return_val_if_fail (path != NULL, NULL);
 562 #line 143 "util.vala"
 563         g_return_val_if_fail (extension != NULL, NULL);
 564 #line 144 "util.vala"
 565         if ((_tmp1_ = _vala_strcmp0 (_tmp0_ = get_file_extension (path), extension) == 0, _g_free0 (_tmp0_), _tmp1_)) {
 566 #line 567 "util.c"
 567                 result = g_strdup (path);
 568 #line 145 "util.vala"
 569                 return result;
 570 #line 571 "util.c"
 571         }
 572         result = (_tmp3_ = g_strconcat (_tmp2_ = g_strconcat (path, ".", NULL), extension, NULL), _g_free0 (_tmp2_), _tmp3_);
 573 #line 147 "util.vala"
 574         return result;
 575 #line 576 "util.c"
 576 }
 577
 578
 579 #line 152 "util.vala"
 580 gboolean version_at_least (const char* v, const char* w) {
 581 #line 582 "util.c"
 582         gboolean result = FALSE;
 583         char** _tmp1_;
 584         gint _va_size_;
 585         gint va_length1;
 586         char** _tmp0_;
 587         char** va;
 588         char** _tmp3_;
 589         gint _wa_size_;
 590         gint wa_length1;
 591         char** _tmp2_;
 592         char** wa;
 593 #line 152 "util.vala"
 594         g_return_val_if_fail (v != NULL, FALSE);
 595 #line 152 "util.vala"
 596         g_return_val_if_fail (w != NULL, FALSE);
 597 #line 598 "util.c"
 598         va = (_tmp1_ = _tmp0_ = g_strsplit (v, ".", 0), va_length1 = _vala_array_length (_tmp0_), _va_size_ = va_length1, _tmp1_);
 599         wa = (_tmp3_ = _tmp2_ = g_strsplit (w, ".", 0), wa_length1 = _vala_array_length (_tmp2_), _wa_size_ = wa_length1, _tmp3_);
 600         {
 601                 gint i;
 602 #line 155 "util.vala"
 603                 i = 0;
 604 #line 605 "util.c"
 605                 {
 606                         gboolean _tmp4_;
 607 #line 155 "util.vala"
 608                         _tmp4_ = TRUE;
 609 #line 155 "util.vala"
 610                         while (TRUE) {
 611 #line 612 "util.c"
 612                                 gint vi;
 613                                 gint wi;
 614 #line 155 "util.vala"
 615                                 if (!_tmp4_) {
 616 #line 155 "util.vala"
 617                                         i = i + 1;
 618 #line 619 "util.c"
 619                                 }
 620 #line 155 "util.vala"
 621                                 _tmp4_ = FALSE;
 622 #line 155 "util.vala"
 623                                 if (!(i < wa_length1)) {
 624 #line 155 "util.vala"
 625                                         break;
 626 #line 627 "util.c"
 627                                 }
 628 #line 156 "util.vala"
 629                                 if (i >= va_length1) {
 630 #line 631 "util.c"
 631                                         result = FALSE;
 632                                         va = (_vala_array_free (va, va_length1, (GDestroyNotify) g_free), NULL);
 633                                         wa = (_vala_array_free (wa, wa_length1, (GDestroyNotify) g_free), NULL);
 634 #line 157 "util.vala"
 635                                         return result;
 636 #line 637 "util.c"
 637                                 }
 638 #line 158 "util.vala"
 639                                 vi = atoi (va[i]);
 640 #line 159 "util.vala"
 641                                 wi = atoi (wa[i]);
 642 #line 160 "util.vala"
 643                                 if (vi > wi) {
 644 #line 645 "util.c"
 645                                         result = TRUE;
 646                                         va = (_vala_array_free (va, va_length1, (GDestroyNotify) g_free), NULL);
 647                                         wa = (_vala_array_free (wa, wa_length1, (GDestroyNotify) g_free), NULL);
 648 #line 161 "util.vala"
 649                                         return result;
 650 #line 651 "util.c"
 651                                 }
 652 #line 162 "util.vala"
 653                                 if (wi > vi) {
 654 #line 655 "util.c"
 655                                         result = FALSE;
 656                                         va = (_vala_array_free (va, va_length1, (GDestroyNotify) g_free), NULL);
 657                                         wa = (_vala_array_free (wa, wa_length1, (GDestroyNotify) g_free), NULL);
 658 #line 163 "util.vala"
 659                                         return result;
 660 #line 661 "util.c"
 661                                 }
 662                         }
 663                 }
 664         }
 665         result = TRUE;
 666         va = (_vala_array_free (va, va_length1, (GDestroyNotify) g_free), NULL);
 667         wa = (_vala_array_free (wa, wa_length1, (GDestroyNotify) g_free), NULL);
 668 #line 165 "util.vala"
 669         return result;
 670 #line 671 "util.c"
 671 }
 672
 673
 674 #line 168 "util.vala"
 675 gboolean get_file_md5_checksum (const char* filename, char** checksum) {
 676 #line 677 "util.c"
 677         gboolean result = FALSE;
 678         GError * _inner_error_;
 679         char* new_filename;
 680         gsize buffer_length = 0UL;
 681 #line 168 "util.vala"
 682         g_return_val_if_fail (filename != NULL, FALSE);
 683 #line 684 "util.c"
 684         if (checksum != NULL) {
 685                 *checksum = NULL;
 686         }
 687         _inner_error_ = NULL;
 688 #line 169 "util.vala"
 689         new_filename = append_extension (filename, "md5");
 690 #line 691 "util.c"
 691         {
 692                 char* _tmp1_;
 693                 char* _tmp0_ = NULL;
 694 #line 173 "util.vala"
 695                 g_file_get_contents (new_filename, &_tmp0_, &buffer_length, &_inner_error_);
 696 #line 173 "util.vala"
 697                 *checksum = (_tmp1_ = _tmp0_, _g_free0 (*checksum), _tmp1_);
 698 #line 699 "util.c"
 699                 if (_inner_error_ != NULL) {
 700                         if (_inner_error_->domain == G_FILE_ERROR) {
 701                                 goto __catch2_g_file_error;
 702                         }
 703                         _g_free0 (new_filename);
 704                         g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
 705                         g_clear_error (&_inner_error_);
 706                         return FALSE;
 707                 }
 708         }
 709         goto __finally2;
 710         __catch2_g_file_error:
 711         {
 712                 GError * e;
 713                 e = _inner_error_;
 714                 _inner_error_ = NULL;
 715                 {
 716                         result = FALSE;
 717                         _g_error_free0 (e);
 718                         _g_free0 (new_filename);
 719 #line 175 "util.vala"
 720                         return result;
 721 #line 722 "util.c"
 722                 }
 723         }
 724         __finally2:
 725         if (_inner_error_ != NULL) {
 726                 _g_free0 (new_filename);
 727                 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);
 728                 g_clear_error (&_inner_error_);
 729                 return FALSE;
 730         }
 731         result = buffer_length == 32;
 732         _g_free0 (new_filename);
 733 #line 178 "util.vala"
 734         return result;
 735 #line 736 "util.c"
 736 }
 737
 738
 739 #line 181 "util.vala"
 740 void save_file_md5_checksum (const char* filename, const char* checksum) {
 741 #line 742 "util.c"
 742         GError * _inner_error_;
 743         char* new_filename;
 744 #line 181 "util.vala"
 745         g_return_if_fail (filename != NULL);
 746 #line 181 "util.vala"
 747         g_return_if_fail (checksum != NULL);
 748 #line 749 "util.c"
 749         _inner_error_ = NULL;
 750 #line 182 "util.vala"
 751         new_filename = append_extension (filename, "md5");
 752 #line 753 "util.c"
 753         {
 754 #line 185 "util.vala"
 755                 g_file_set_contents (new_filename, checksum, -1, &_inner_error_);
 756 #line 757 "util.c"
 757                 if (_inner_error_ != NULL) {
 758                         if (_inner_error_->domain == G_FILE_ERROR) {
 759                                 goto __catch3_g_file_error;
 760                         }
 761                         _g_free0 (new_filename);
 762                         g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
 763                         g_clear_error (&_inner_error_);
 764                         return;
 765                 }
 766         }
 767         goto __finally3;
 768         __catch3_g_file_error:
 769         {
 770                 GError * e;
 771                 e = _inner_error_;
 772                 _inner_error_ = NULL;
 773                 {
 774 #line 187 "util.vala"
 775                         g_error ("util.vala:187: Cannot save md5 file %s!\n", new_filename);
 776 #line 777 "util.c"
 777                         _g_error_free0 (e);
 778                 }
 779         }
 780         __finally3:
 781         if (_inner_error_ != NULL) {
 782                 _g_free0 (new_filename);
 783                 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);
 784                 g_clear_error (&_inner_error_);
 785                 return;
 786         }
 787         _g_free0 (new_filename);
 788 }
 789
 790
 791 #line 191 "util.vala"
 792 gboolean md5_checksum_on_file (const char* filename, char** checksum) {
 793 #line 794 "util.c"
 794         gboolean result = FALSE;
 795         GError * _inner_error_;
 796         char* file_buffer;
 797         gsize len = 0UL;
 798         GChecksum* c;
 799         char* _tmp2_;
 800 #line 191 "util.vala"
 801         g_return_val_if_fail (filename != NULL, FALSE);
 802 #line 803 "util.c"
 803         if (checksum != NULL) {
 804                 *checksum = NULL;
 805         }
 806         _inner_error_ = NULL;
 807         file_buffer = NULL;
 808         {
 809                 char* _tmp1_;
 810                 char* _tmp0_ = NULL;
 811 #line 196 "util.vala"
 812                 g_file_get_contents (filename, &_tmp0_, &len, &_inner_error_);
 813 #line 196 "util.vala"
 814                 file_buffer = (_tmp1_ = _tmp0_, _g_free0 (file_buffer), _tmp1_);
 815 #line 816 "util.c"
 816                 if (_inner_error_ != NULL) {
 817                         if (_inner_error_->domain == G_FILE_ERROR) {
 818                                 goto __catch4_g_file_error;
 819                         }
 820                         _g_free0 (file_buffer);
 821                         g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
 822                         g_clear_error (&_inner_error_);
 823                         return FALSE;
 824                 }
 825         }
 826         goto __finally4;
 827         __catch4_g_file_error:
 828         {
 829                 GError * e;
 830                 e = _inner_error_;
 831                 _inner_error_ = NULL;
 832                 {
 833                         result = FALSE;
 834                         _g_error_free0 (e);
 835                         _g_free0 (file_buffer);
 836 #line 198 "util.vala"
 837                         return result;
 838 #line 839 "util.c"
 839                 }
 840         }
 841         __finally4:
 842         if (_inner_error_ != NULL) {
 843                 _g_free0 (file_buffer);
 844                 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);
 845                 g_clear_error (&_inner_error_);
 846                 return FALSE;
 847         }
 848 #line 201 "util.vala"
 849         c = g_checksum_new (G_CHECKSUM_MD5);
 850 #line 202 "util.vala"
 851         g_checksum_update (c, (guchar*) file_buffer, len);
 852 #line 203 "util.vala"
 853         *checksum = (_tmp2_ = g_strdup (g_checksum_get_string (c)), _g_free0 (*checksum), _tmp2_);
 854 #line 855 "util.c"
 855         result = TRUE;
 856         _g_free0 (file_buffer);
 857         _g_checksum_free0 (c);
 858 #line 204 "util.vala"
 859         return result;
 860 #line 861 "util.c"
 861 }
 862
 863
 864 #line 239 "util.vala"
 865 void parse_color (const char* color, GdkColor* result) {
 866 #line 867 "util.c"
 867         GdkColor c = {0};
 868 #line 239 "util.vala"
 869         g_return_if_fail (color != NULL);
 870 #line 241 "util.vala"
 871         if (!gdk_color_parse (color, &c)) {
 872 #line 242 "util.vala"
 873                 g_error ("util.vala:242: can't parse color");
 874 #line 875 "util.c"
 875         }
 876         *result = c;
 877 #line 243 "util.vala"
 878         return;
 879 #line 880 "util.c"
 880 }
 881
 882
 883 static gpointer _g_object_ref0 (gpointer self) {
 884         return self ? g_object_ref (self) : NULL;
 885 }
 886
 887
 888 #line 246 "util.vala"
 889 GtkWidget* get_widget (GtkUIManager* manager, const char* name) {
 890 #line 891 "util.c"
 891         GtkWidget* result = NULL;
 892         GtkWidget* widget;
 893 #line 246 "util.vala"
 894         g_return_val_if_fail (GTK_IS_UI_MANAGER (manager), NULL);
 895 #line 246 "util.vala"
 896         g_return_val_if_fail (name != NULL, NULL);
 897 #line 247 "util.vala"
 898         widget = _g_object_ref0 (gtk_ui_manager_get_widget (manager, name));
 899 #line 248 "util.vala"
 900         if (widget == NULL) {
 901 #line 249 "util.vala"
 902                 g_error ("util.vala:249: can't find widget");
 903 #line 904 "util.c"
 904         }
 905         result = widget;
 906 #line 250 "util.vala"
 907         return result;
 908 #line 909 "util.c"
 909 }
 910
 911
 912 #line 262 "util.vala"
 913 void draw_rounded_rectangle (GdkWindow* window, GdkColor* color, gboolean filled, gint x0, gint y0, gint width, gint height) {
 914 #line 915 "util.c"
 915         gboolean _tmp0_ = FALSE;
 916         double x1;
 917         double y1;
 918         cairo_t* cairo_window;
 919 #line 262 "util.vala"
 920         g_return_if_fail (GDK_IS_WINDOW (window));
 921 #line 264 "util.vala"
 922         if (width == 0) {
 923 #line 264 "util.vala"
 924                 _tmp0_ = TRUE;
 925 #line 926 "util.c"
 926         } else {
 927 #line 264 "util.vala"
 928                 _tmp0_ = height == 0;
 929 #line 930 "util.c"
 930         }
 931 #line 264 "util.vala"
 932         if (_tmp0_) {
 933 #line 265 "util.vala"
 934                 return;
 935 #line 936 "util.c"
 936         }
 937 #line 267 "util.vala"
 938         x1 = (double) (x0 + width);
 939 #line 268 "util.vala"
 940         y1 = (double) (y0 + height);
 941 #line 270 "util.vala"
 942         cairo_window = gdk_cairo_create (GDK_DRAWABLE (window));
 943 #line 271 "util.vala"
 944         gdk_cairo_set_source_color (cairo_window, color);
 945 #line 272 "util.vala"
 946         cairo_set_antialias (cairo_window, ANTIALIAS);
 947 #line 274 "util.vala"
 948         if ((width / 2) < RADIUS) {
 949 #line 275 "util.vala"
 950                 if ((height / 2) < RADIUS) {
 951 #line 276 "util.vala"
 952                         cairo_move_to (cairo_window, (double) x0, (y0 + y1) / 2);
 953 #line 277 "util.vala"
 954                         cairo_curve_to (cairo_window, (double) x0, (double) y0, (double) x0, (double) y0, (x0 + x1) / 2, (double) y0);
 955 #line 278 "util.vala"
 956                         cairo_curve_to (cairo_window, x1, (double) y0, x1, (double) y0, x1, (y0 + y1) / 2);
 957 #line 279 "util.vala"
 958                         cairo_curve_to (cairo_window, x1, y1, x1, y1, (x1 + x0) / 2, y1);
 959 #line 280 "util.vala"
 960                         cairo_curve_to (cairo_window, (double) x0, y1, (double) x0, y1, (double) x0, (y0 + y1) / 2);
 961 #line 962 "util.c"
 962                 } else {
 963 #line 282 "util.vala"
 964                         cairo_move_to (cairo_window, (double) x0, y0 + RADIUS);
 965 #line 283 "util.vala"
 966                         cairo_curve_to (cairo_window, (double) x0, (double) y0, (double) x0, (double) y0, (x0 + x1) / 2, (double) y0);
 967 #line 284 "util.vala"
 968                         cairo_curve_to (cairo_window, x1, (double) y0, x1, (double) y0, x1, y0 + RADIUS);
 969 #line 285 "util.vala"
 970                         cairo_line_to (cairo_window, x1, y1 - RADIUS);
 971 #line 286 "util.vala"
 972                         cairo_curve_to (cairo_window, x1, y1, x1, y1, (x1 + x0) / 2, y1);
 973 #line 287 "util.vala"
 974                         cairo_curve_to (cairo_window, (double) x0, y1, (double) x0, y1, (double) x0, y1 - RADIUS);
 975 #line 976 "util.c"
 976                 }
 977         } else {
 978 #line 290 "util.vala"
 979                 if ((height / 2) < RADIUS) {
 980 #line 291 "util.vala"
 981                         cairo_move_to (cairo_window, (double) x0, (y0 + y1) / 2);
 982 #line 292 "util.vala"
 983                         cairo_curve_to (cairo_window, (double) x0, (double) y0, (double) x0, (double) y0, x0 + RADIUS, (double) y0);
 984 #line 293 "util.vala"
 985                         cairo_line_to (cairo_window, x1 - RADIUS, (double) y0);
 986 #line 294 "util.vala"
 987                         cairo_curve_to (cairo_window, x1, (double) y0, x1, (double) y0, x1, (y0 + y1) / 2);
 988 #line 295 "util.vala"
 989                         cairo_curve_to (cairo_window, x1, y1, x1, y1, x1 - RADIUS, y1);
 990 #line 296 "util.vala"
 991                         cairo_line_to (cairo_window, x0 + RADIUS, y1);
 992 #line 297 "util.vala"
 993                         cairo_curve_to (cairo_window, (double) x0, y1, (double) x0, y1, (double) x0, (y0 + y1) / 2);
 994 #line 995 "util.c"
 995                 } else {
 996 #line 299 "util.vala"
 997                         cairo_move_to (cairo_window, (double) x0, y0 + RADIUS);
 998 #line 300 "util.vala"
 999                         cairo_curve_to (cairo_window, (double) x0, (double) y0, (double) x0, (double) y0, x0 + RADIUS, (double) y0);
1000 #line 301 "util.vala"
1001                         cairo_line_to (cairo_window, x1 - RADIUS, (double) y0);
1002 #line 302 "util.vala"
1003                         cairo_curve_to (cairo_window, x1, (double) y0, x1, (double) y0, x1, y0 + RADIUS);
1004 #line 303 "util.vala"
1005                         cairo_line_to (cairo_window, x1, y1 - RADIUS);
1006 #line 304 "util.vala"
1007                         cairo_curve_to (cairo_window, x1, y1, x1, y1, x1 - RADIUS, y1);
1008 #line 305 "util.vala"
1009                         cairo_line_to (cairo_window, x0 + RADIUS, y1);
1010 #line 306 "util.vala"
1011                         cairo_curve_to (cairo_window, (double) x0, y1, (double) x0, y1, (double) x0, y1 - RADIUS);
1012 #line 1013 "util.c"
1013                 }
1014         }
1015 #line 309 "util.vala"
1016         cairo_close_path (cairo_window);
1017 #line 311 "util.vala"
1018         if (filled) {
1019 #line 312 "util.vala"
1020                 cairo_fill (cairo_window);
1021 #line 1022 "util.c"
1022         } else {
1023 #line 314 "util.vala"
1024                 cairo_set_line_width (cairo_window, LINE_WIDTH);
1025 #line 315 "util.vala"
1026                 cairo_stroke (cairo_window);
1027 #line 1028 "util.c"
1028         }
1029         _cairo_destroy0 (cairo_window);
1030 }
1031
1032
1033 #line 319 "util.vala"
1034 void draw_right_rounded_rectangle (GdkWindow* window, GdkColor* color, gboolean filled, gint x0, gint y0, gint width, gint height) {
1035 #line 1036 "util.c"
1036         gboolean _tmp0_ = FALSE;
1037         double x1;
1038         double y1;
1039         cairo_t* cairo_window;
1040 #line 319 "util.vala"
1041         g_return_if_fail (GDK_IS_WINDOW (window));
1042 #line 321 "util.vala"
1043         if (width == 0) {
1044 #line 321 "util.vala"
1045                 _tmp0_ = TRUE;
1046 #line 1047 "util.c"
1047         } else {
1048 #line 321 "util.vala"
1049                 _tmp0_ = height == 0;
1050 #line 1051 "util.c"
1051         }
1052 #line 321 "util.vala"
1053         if (_tmp0_) {
1054 #line 322 "util.vala"
1055                 return;
1056 #line 1057 "util.c"
1057         }
1058 #line 324 "util.vala"
1059         x1 = (double) (x0 + width);
1060 #line 325 "util.vala"
1061         y1 = (double) (y0 + height);
1062 #line 327 "util.vala"
1063         cairo_window = gdk_cairo_create (GDK_DRAWABLE (window));
1064 #line 328 "util.vala"
1065         gdk_cairo_set_source_color (cairo_window, color);
1066 #line 329 "util.vala"
1067         cairo_set_antialias (cairo_window, ANTIALIAS);
1068 #line 331 "util.vala"
1069         if ((width / 2) < RADIUS) {
1070 #line 332 "util.vala"
1071                 if ((height / 2) < RADIUS) {
1072 #line 333 "util.vala"
1073                         cairo_move_to (cairo_window, (double) x0, (double) y0);
1074 #line 334 "util.vala"
1075                         cairo_line_to (cairo_window, (x0 + x1) / 2, (double) y0);
1076 #line 335 "util.vala"
1077                         cairo_curve_to (cairo_window, x1, (double) y0, x1, (double) y0, x1, (y0 + y1) / 2);
1078 #line 336 "util.vala"
1079                         cairo_curve_to (cairo_window, x1, y1, x1, y1, (x1 + x0) / 2, y1);
1080 #line 337 "util.vala"
1081                         cairo_line_to (cairo_window, (double) x0, y1);
1082 #line 338 "util.vala"
1083                         cairo_line_to (cairo_window, (double) x0, (double) y0);
1084 #line 1085 "util.c"
1085                 } else {
1086 #line 340 "util.vala"
1087                         cairo_move_to (cairo_window, (double) x0, (double) y0);
1088 #line 341 "util.vala"
1089                         cairo_line_to (cairo_window, (x0 + x1) / 2, (double) y0);
1090 #line 342 "util.vala"
1091                         cairo_curve_to (cairo_window, x1, (double) y0, x1, (double) y0, x1, y0 + RADIUS);
1092 #line 343 "util.vala"
1093                         cairo_line_to (cairo_window, x1, y1 - RADIUS);
1094 #line 344 "util.vala"
1095                         cairo_curve_to (cairo_window, x1, y1, x1, y1, (x1 + x0) / 2, y1);
1096 #line 345 "util.vala"
1097                         cairo_line_to (cairo_window, (double) x0, y1);
1098 #line 346 "util.vala"
1099                         cairo_line_to (cairo_window, (double) x0, (double) y0);
1100 #line 1101 "util.c"
1101                 }
1102         } else {
1103 #line 349 "util.vala"
1104                 if ((height / 2) < RADIUS) {
1105 #line 350 "util.vala"
1106                         cairo_move_to (cairo_window, (double) x0, (double) y0);
1107 #line 351 "util.vala"
1108                         cairo_line_to (cairo_window, x1 - RADIUS, (double) y0);
1109 #line 352 "util.vala"
1110                         cairo_curve_to (cairo_window, x1, (double) y0, x1, (double) y0, x1, (y0 + y1) / 2);
1111 #line 353 "util.vala"
1112                         cairo_curve_to (cairo_window, x1, y1, x1, y1, x1 - RADIUS, y1);
1113 #line 354 "util.vala"
1114                         cairo_line_to (cairo_window, (double) x0, y1);
1115 #line 355 "util.vala"
1116                         cairo_line_to (cairo_window, (double) x0, (double) y0);
1117 #line 1118 "util.c"
1118                 } else {
1119 #line 357 "util.vala"
1120                         cairo_move_to (cairo_window, (double) x0, (double) y0);
1121 #line 358 "util.vala"
1122                         cairo_line_to (cairo_window, x1 - RADIUS, (double) y0);
1123 #line 359 "util.vala"
1124                         cairo_curve_to (cairo_window, x1, (double) y0, x1, (double) y0, x1, y0 + RADIUS);
1125 #line 360 "util.vala"
1126                         cairo_line_to (cairo_window, x1, y1 - RADIUS);
1127 #line 361 "util.vala"
1128                         cairo_curve_to (cairo_window, x1, y1, x1, y1, x1 - RADIUS, y1);
1129 #line 362 "util.vala"
1130                         cairo_line_to (cairo_window, (double) x0, y1);
1131 #line 363 "util.vala"
1132                         cairo_line_to (cairo_window, (double) x0, (double) y0);
1133 #line 1134 "util.c"
1134                 }
1135         }
1136 #line 366 "util.vala"
1137         cairo_close_path (cairo_window);
1138 #line 368 "util.vala"
1139         if (filled) {
1140 #line 369 "util.vala"
1141                 cairo_fill (cairo_window);
1142 #line 1143 "util.c"
1143         } else {
1144 #line 371 "util.vala"
1145                 cairo_set_line_width (cairo_window, LINE_WIDTH);
1146 #line 372 "util.vala"
1147                 cairo_stroke (cairo_window);
1148 #line 1149 "util.c"
1149         }
1150         _cairo_destroy0 (cairo_window);
1151 }
1152
1153
1154 #line 376 "util.vala"
1155 void draw_left_rounded_rectangle (GdkWindow* window, GdkColor* color, gboolean filled, gint x0, gint y0, gint width, gint height) {
1156 #line 1157 "util.c"
1157         gboolean _tmp0_ = FALSE;
1158         double x1;
1159         double y1;
1160         cairo_t* cairo_window;
1161 #line 376 "util.vala"
1162         g_return_if_fail (GDK_IS_WINDOW (window));
1163 #line 378 "util.vala"
1164         if (width == 0) {
1165 #line 378 "util.vala"
1166                 _tmp0_ = TRUE;
1167 #line 1168 "util.c"
1168         } else {
1169 #line 378 "util.vala"
1170                 _tmp0_ = height == 0;
1171 #line 1172 "util.c"
1172         }
1173 #line 378 "util.vala"
1174         if (_tmp0_) {
1175 #line 379 "util.vala"
1176                 return;
1177 #line 1178 "util.c"
1178         }
1179 #line 381 "util.vala"
1180         x1 = (double) (x0 + width);
1181 #line 382 "util.vala"
1182         y1 = (double) (y0 + height);
1183 #line 384 "util.vala"
1184         cairo_window = gdk_cairo_create (GDK_DRAWABLE (window));
1185 #line 385 "util.vala"
1186         gdk_cairo_set_source_color (cairo_window, color);
1187 #line 386 "util.vala"
1188         cairo_set_antialias (cairo_window, ANTIALIAS);
1189 #line 388 "util.vala"
1190         if ((width / 2) < RADIUS) {
1191 #line 389 "util.vala"
1192                 if ((height / 2) < RADIUS) {
1193 #line 390 "util.vala"
1194                         cairo_move_to (cairo_window, (double) x0, (y0 + y1) / 2);
1195 #line 391 "util.vala"
1196                         cairo_curve_to (cairo_window, (double) x0, (double) y0, (double) x0, (double) y0, (x0 + x1) / 2, (double) y0);
1197 #line 392 "util.vala"
1198                         cairo_line_to (cairo_window, x1, (double) y0);
1199 #line 393 "util.vala"
1200                         cairo_line_to (cairo_window, x1, y1);
1201 #line 394 "util.vala"
1202                         cairo_line_to (cairo_window, (x1 + x0) / 2, y1);
1203 #line 395 "util.vala"
1204                         cairo_curve_to (cairo_window, (double) x0, y1, (double) x0, y1, (double) x0, (y0 + y1) / 2);
1205 #line 1206 "util.c"
1206                 } else {
1207 #line 397 "util.vala"
1208                         cairo_move_to (cairo_window, (double) x0, y0 + RADIUS);
1209 #line 398 "util.vala"
1210                         cairo_curve_to (cairo_window, (double) x0, (double) y0, (double) x0, (double) y0, (x0 + x1) / 2, (double) y0);
1211 #line 399 "util.vala"
1212                         cairo_line_to (cairo_window, x1, (double) y0);
1213 #line 400 "util.vala"
1214                         cairo_line_to (cairo_window, x1, y1);
1215 #line 401 "util.vala"
1216                         cairo_line_to (cairo_window, (x1 + x0) / 2, y1);
1217 #line 402 "util.vala"
1218                         cairo_curve_to (cairo_window, (double) x0, y1, (double) x0, y1, (double) x0, y1 - RADIUS);
1219 #line 1220 "util.c"
1220                 }
1221         } else {
1222 #line 405 "util.vala"
1223                 if ((height / 2) < RADIUS) {
1224 #line 406 "util.vala"
1225                         cairo_move_to (cairo_window, (double) x0, (y0 + y1) / 2);
1226 #line 407 "util.vala"
1227                         cairo_curve_to (cairo_window, (double) x0, (double) y0, (double) x0, (double) y0, x0 + RADIUS, (double) y0);
1228 #line 408 "util.vala"
1229                         cairo_line_to (cairo_window, x1, (double) y0);
1230 #line 409 "util.vala"
1231                         cairo_line_to (cairo_window, x1, y1);
1232 #line 410 "util.vala"
1233                         cairo_line_to (cairo_window, x0 + RADIUS, y1);
1234 #line 411 "util.vala"
1235                         cairo_curve_to (cairo_window, (double) x0, y1, (double) x0, y1, (double) x0, (y0 + y1) / 2);
1236 #line 1237 "util.c"
1237                 } else {
1238 #line 413 "util.vala"
1239                         cairo_move_to (cairo_window, (double) x0, y0 + RADIUS);
1240 #line 414 "util.vala"
1241                         cairo_curve_to (cairo_window, (double) x0, (double) y0, (double) x0, (double) y0, x0 + RADIUS, (double) y0);
1242 #line 415 "util.vala"
1243                         cairo_line_to (cairo_window, x1, (double) y0);
1244 #line 416 "util.vala"
1245                         cairo_line_to (cairo_window, x1, y1);
1246 #line 417 "util.vala"
1247                         cairo_line_to (cairo_window, x0 + RADIUS, y1);
1248 #line 418 "util.vala"
1249                         cairo_curve_to (cairo_window, (double) x0, y1, (double) x0, y1, (double) x0, y1 - RADIUS);
1250 #line 1251 "util.c"
1251                 }
1252         }
1253 #line 421 "util.vala"
1254         cairo_close_path (cairo_window);
1255 #line 423 "util.vala"
1256         if (filled) {
1257 #line 424 "util.vala"
1258                 cairo_fill (cairo_window);
1259 #line 1260 "util.c"
1260         } else {
1261 #line 426 "util.vala"
1262                 cairo_set_line_width (cairo_window, LINE_WIDTH);
1263 #line 427 "util.vala"
1264                 cairo_stroke (cairo_window);
1265 #line 1266 "util.c"
1266         }
1267         _cairo_destroy0 (cairo_window);
1268 }
1269
1270
1271 #line 431 "util.vala"
1272 void draw_square_rectangle (GdkWindow* window, GdkColor* color, gboolean filled, gint x, gint y, gint width, gint height) {
1273 #line 1274 "util.c"
1274         gboolean _tmp0_ = FALSE;
1275         cairo_t* cairo_window;
1276 #line 431 "util.vala"
1277         g_return_if_fail (GDK_IS_WINDOW (window));
1278 #line 433 "util.vala"
1279         if (width == 0) {
1280 #line 433 "util.vala"
1281                 _tmp0_ = TRUE;
1282 #line 1283 "util.c"
1283         } else {
1284 #line 433 "util.vala"
1285                 _tmp0_ = height == 0;
1286 #line 1287 "util.c"
1287         }
1288 #line 433 "util.vala"
1289         if (_tmp0_) {
1290 #line 434 "util.vala"
1291                 return;
1292 #line 1293 "util.c"
1293         }
1294 #line 436 "util.vala"
1295         cairo_window = gdk_cairo_create (GDK_DRAWABLE (window));
1296 #line 437 "util.vala"
1297         gdk_cairo_set_source_color (cairo_window, color);
1298 #line 438 "util.vala"
1299         cairo_set_antialias (cairo_window, ANTIALIAS);
1300 #line 440 "util.vala"
1301         cairo_rectangle (cairo_window, (double) x, (double) y, (double) width, (double) height);
1302 #line 442 "util.vala"
1303         if (filled) {
1304 #line 443 "util.vala"
1305                 cairo_fill (cairo_window);
1306 #line 1307 "util.c"
1307         } else {
1308 #line 445 "util.vala"
1309                 cairo_set_line_width (cairo_window, LINE_WIDTH);
1310 #line 446 "util.vala"
1311                 cairo_stroke (cairo_window);
1312 #line 1313 "util.c"
1313         }
1314         _cairo_destroy0 (cairo_window);
1315 }
1316
1317
1318 #line 452 "util.vala"
1319 gboolean is_drop_frame_rate (Fraction* r) {
1320 #line 1321 "util.c"
1321         gboolean result = FALSE;
1322         gboolean _tmp0_ = FALSE;
1323         gboolean _tmp1_ = FALSE;
1324 #line 453 "util.vala"
1325         if ((*r).numerator == 2997) {
1326 #line 453 "util.vala"
1327                 _tmp1_ = (*r).denominator == 100;
1328 #line 1329 "util.c"
1329         } else {
1330 #line 453 "util.vala"
1331                 _tmp1_ = FALSE;
1332 #line 1333 "util.c"
1333         }
1334 #line 453 "util.vala"
1335         if (_tmp1_) {
1336 #line 453 "util.vala"
1337                 _tmp0_ = TRUE;
1338 #line 1339 "util.c"
1339         } else {
1340                 gboolean _tmp2_ = FALSE;
1341 #line 454 "util.vala"
1342                 if ((*r).numerator == 30000) {
1343 #line 454 "util.vala"
1344                         _tmp2_ = (*r).denominator == 1001;
1345 #line 1346 "util.c"
1346                 } else {
1347 #line 454 "util.vala"
1348                         _tmp2_ = FALSE;
1349 #line 1350 "util.c"
1350                 }
1351 #line 454 "util.vala"
1352                 _tmp0_ = _tmp2_;
1353 #line 1354 "util.c"
1354         }
1355         result = _tmp0_;
1356 #line 453 "util.vala"
1357         return result;
1358 #line 1359 "util.c"
1359 }
1360
1361
1362 #line 457 "util.vala"
1363 gint64 frame_to_time_with_rate (gint frame, Fraction* rate) {
1364 #line 1365 "util.c"
1365         gint64 result = 0LL;
1366         gint64 time;
1367 #line 458 "util.vala"
1368         time = (gint64) gst_util_uint64_scale ((guint64) frame, (guint64) (GST_SECOND * (*rate).denominator), (guint64) (*rate).numerator);
1369 #line 1370 "util.c"
1370         result = time;
1371 #line 459 "util.vala"
1372         return result;
1373 #line 1374 "util.c"
1374 }
1375
1376
1377 #line 462 "util.vala"
1378 gint time_to_frame_with_rate (gint64 time, Fraction* rate) {
1379 #line 1380 "util.c"
1380         gint result = 0;
1381         gint frame;
1382         gint _tmp0_ = 0;
1383 #line 463 "util.vala"
1384         frame = (gint) gst_util_uint64_scale ((guint64) time, (guint64) (*rate).numerator, (guint64) (GST_SECOND * (*rate).denominator));
1385 #line 469 "util.vala"
1386         if (time >= frame_to_time_with_rate (frame + 1, rate)) {
1387 #line 469 "util.vala"
1388                 _tmp0_ = frame + 1;
1389 #line 1390 "util.c"
1390         } else {
1391 #line 469 "util.vala"
1392                 _tmp0_ = frame;
1393 #line 1394 "util.c"
1394         }
1395         result = _tmp0_;
1396 #line 469 "util.vala"
1397         return result;
1398 #line 1399 "util.c"
1399 }
1400
1401
1402 #line 472 "util.vala"
1403 void frame_to_time (gint frame, Fraction* rate, TimeCode* result) {
1404 #line 1405 "util.c"
1405         gint frame_rate;
1406         TimeCode _tmp0_ = {0};
1407         TimeCode t;
1408         gint64 secs;
1409 #line 473 "util.vala"
1410         frame_rate = 0;
1411 #line 475 "util.vala"
1412         t = (_tmp0_);
1413 #line 477 "util.vala"
1414         t.drop_code = FALSE;
1415 #line 478 "util.vala"
1416         if ((*rate).denominator == 1) {
1417 #line 479 "util.vala"
1418                 frame_rate = (*rate).numerator;
1419 #line 1420 "util.c"
1420         } else {
1421 #line 480 "util.vala"
1422                 if (is_drop_frame_rate (rate)) {
1423 #line 1424 "util.c"
1424                         gint FRAMES_PER_MINUTE;
1425                         gint FRAMES_PER_10_MINUTES;
1426                         gint block;
1427                         gint minute_in_block;
1428                         gint minutes;
1429 #line 481 "util.vala"
1430                         t.drop_code = TRUE;
1431 #line 482 "util.vala"
1432                         frame_rate = 30;
1433 #line 485 "util.vala"
1434                         FRAMES_PER_MINUTE = (30 * 60) - 2;
1435 #line 486 "util.vala"
1436                         FRAMES_PER_10_MINUTES = (10 * FRAMES_PER_MINUTE) + 2;
1437 #line 488 "util.vala"
1438                         block = frame / FRAMES_PER_10_MINUTES;
1439 #line 489 "util.vala"
1440                         minute_in_block = ((frame % FRAMES_PER_10_MINUTES) - 2) / FRAMES_PER_MINUTE;
1441 #line 490 "util.vala"
1442                         minutes = (10 * block) + minute_in_block;
1443 #line 491 "util.vala"
1444                         frame = frame + ((2 * minutes) - (2 * block));
1445 #line 1446 "util.c"
1446                 } else {
1447 #line 495 "util.vala"
1448                         frame_rate = (*rate).numerator / (*rate).denominator;
1449 #line 1450 "util.c"
1450                 }
1451         }
1452 #line 498 "util.vala"
1453         t.frame = frame % frame_rate;
1454 #line 500 "util.vala"
1455         secs = (gint64) (frame / frame_rate);
1456 #line 501 "util.vala"
1457         t.hour = ((gint) secs) / 3600;
1458 #line 502 "util.vala"
1459         t.minute = (((gint) secs) % 3600) / 60;
1460 #line 503 "util.vala"
1461         t.second = (((gint) secs) % 3600) % 60;
1462 #line 1463 "util.c"
1463         *result = t;
1464 #line 505 "util.vala"
1465         return;
1466 #line 1467 "util.c"
1467 }
1468
1469
1470 #line 508 "util.vala"
1471 char* frame_to_string (gint frame, Fraction* rate) {
1472 #line 1473 "util.c"
1473         char* result = NULL;
1474         TimeCode _tmp1_;
1475         TimeCode _tmp0_ = {0};
1476         result = time_code_to_string ((_tmp1_ = (frame_to_time (frame, rate, &_tmp0_), _tmp0_), &_tmp1_));
1477 #line 509 "util.vala"
1478         return result;
1479 #line 1480 "util.c"
1480 }
1481
1482
1483 #line 512 "util.vala"
1484 void breakup_time (gint64 time, gint* hours, gint* minutes, double* seconds) {
1485 #line 1486 "util.c"
1486         gint64 the_time;
1487         gint64 minute;
1488         gint64 hour;
1489 #line 513 "util.vala"
1490         the_time = time;
1491 #line 514 "util.vala"
1492         minute = (gint64) (GST_SECOND * 60);
1493 #line 515 "util.vala"
1494         hour = minute * 60;
1495 #line 516 "util.vala"
1496         *hours = (gint) (the_time / hour);
1497 #line 517 "util.vala"
1498         the_time = the_time % hour;
1499 #line 518 "util.vala"
1500         *minutes = (gint) (the_time / minute);
1501 #line 519 "util.vala"
1502         the_time = the_time % minute;
1503 #line 520 "util.vala"
1504         *seconds = ((double) the_time) / GST_SECOND;
1505 #line 1506 "util.c"
1506 }
1507
1508
1509 #line 523 "util.vala"
1510 char* time_to_HHMMSS (gint64 time) {
1511 #line 1512 "util.c"
1512         char* result = NULL;
1513         gint hours = 0;
1514         gint minutes = 0;
1515         double seconds = 0.0;
1516 #line 528 "util.vala"
1517         breakup_time (time, &hours, &minutes, &seconds);
1518 #line 1519 "util.c"
1519         result = g_strdup_printf ("%02d:%02d:%05.2lf", hours, minutes, seconds);
1520 #line 529 "util.vala"
1521         return result;
1522 #line 1523 "util.c"
1523 }
1524
1525
1526 #line 532 "util.vala"
1527 char* time_to_string (gint64 time) {
1528 #line 1529 "util.c"
1529         char* result = NULL;
1530         gint hours = 0;
1531         gint minutes = 0;
1532         double seconds = 0.0;
1533         char* return_value;
1534         gboolean _tmp0_ = FALSE;
1535 #line 537 "util.vala"
1536         breakup_time (time, &hours, &minutes, &seconds);
1537 #line 538 "util.vala"
1538         return_value = g_strdup_printf ("%1.2lfs", seconds);
1539 #line 539 "util.vala"
1540         if (hours > 0) {
1541 #line 539 "util.vala"
1542                 _tmp0_ = TRUE;
1543 #line 1544 "util.c"
1544         } else {
1545 #line 539 "util.vala"
1546                 _tmp0_ = minutes > 0;
1547 #line 1548 "util.c"
1548         }
1549 #line 539 "util.vala"
1550         if (_tmp0_) {
1551 #line 1552 "util.c"
1552                 char* _tmp2_;
1553                 char* _tmp1_;
1554 #line 540 "util.vala"
1555                 return_value = (_tmp2_ = g_strconcat (_tmp1_ = g_strdup_printf ("%dm ", minutes), return_value, NULL), _g_free0 (return_value), _tmp2_);
1556 #line 1557 "util.c"
1557                 _g_free0 (_tmp1_);
1558         }
1559 #line 543 "util.vala"
1560         if (hours > 0) {
1561 #line 1562 "util.c"
1562                 char* _tmp4_;
1563                 char* _tmp3_;
1564 #line 544 "util.vala"
1565                 return_value = (_tmp4_ = g_strconcat (_tmp3_ = g_strdup_printf ("%dh ", hours), return_value, NULL), _g_free0 (return_value), _tmp4_);
1566 #line 1567 "util.c"
1567                 _g_free0 (_tmp3_);
1568         }
1569         result = return_value;
1570 #line 547 "util.vala"
1571         return result;
1572 #line 1573 "util.c"
1573 }
1574
1575
1576 #line 550 "util.vala"
1577 GstElement* make_element_with_name (const char* element_name, const char* display_name, GError** error) {
1578 #line 1579 "util.c"
1579         GstElement* result = NULL;
1580         GError * _inner_error_;
1581         GstElement* e;
1582 #line 550 "util.vala"
1583         g_return_val_if_fail (element_name != NULL, NULL);
1584 #line 1585 "util.c"
1585         _inner_error_ = NULL;
1586 #line 552 "util.vala"
1587         e = gst_element_factory_make (element_name, display_name);
1588 #line 553 "util.vala"
1589         if (e == NULL) {
1590 #line 1591 "util.c"
1591                 char* _tmp0_;
1592                 GError* _tmp1_;
1593                 _inner_error_ = (_tmp1_ = g_error_new_literal (MEDIA_ERROR, MEDIA_ERROR_MISSING_PLUGIN, _tmp0_ = g_strdup_printf ("Could not create element %s(%s)", element_name, display_name)), _g_free0 (_tmp0_), _tmp1_);
1594                 {
1595                         g_propagate_error (error, _inner_error_);
1596                         _gst_object_unref0 (e);
1597                         return NULL;
1598                 }
1599         }
1600         result = e;
1601 #line 557 "util.vala"
1602         return result;
1603 #line 1604 "util.c"
1604 }
1605
1606
1607 #line 560 "util.vala"
1608 GstElement* make_element (const char* name, GError** error) {
1609 #line 1610 "util.c"
1610         GstElement* result = NULL;
1611         GError * _inner_error_;
1612         GstElement* _tmp0_;
1613 #line 560 "util.vala"
1614         g_return_val_if_fail (name != NULL, NULL);
1615 #line 1616 "util.c"
1616         _inner_error_ = NULL;
1617 #line 561 "util.vala"
1618         _tmp0_ = make_element_with_name (name, NULL, &_inner_error_);
1619 #line 1620 "util.c"
1620         if (_inner_error_ != NULL) {
1621                 g_propagate_error (error, _inner_error_);
1622                 return NULL;
1623         }
1624         result = _tmp0_;
1625 #line 561 "util.vala"
1626         return result;
1627 #line 1628 "util.c"
1628 }
1629
1630
1631 static void _vala_array_destroy (gpointer array, gint array_length, GDestroyNotify destroy_func) {
1632         if ((array != NULL) && (destroy_func != NULL)) {
1633                 int i;
1634                 for (i = 0; i < array_length; i = i + 1) {
1635                         if (((gpointer*) array)[i] != NULL) {
1636                                 destroy_func (((gpointer*) array)[i]);
1637                         }
1638                 }
1639         }
1640 }
1641
1642
1643 static void _vala_array_free (gpointer array, gint array_length, GDestroyNotify destroy_func) {
1644         _vala_array_destroy (array, array_length, destroy_func);
1645         g_free (array);
1646 }
1647
1648
1649 static gint _vala_array_length (gpointer array) {
1650         int length;
1651         length = 0;
1652         if (array) {
1653                 while (((gpointer*) array)[length]) {
1654                         length++;
1655                 }
1656         }
1657         return length;
1658 }
1659
1660
1661 static int _vala_strcmp0 (const char * str1, const char * str2) {
1662         if (str1 == NULL) {
1663                 return -(str1 != str2);
1664         }
1665         if (str2 == NULL) {
1666                 return str1 != str2;
1667         }
1668         return strcmp (str1, str2);
1669 }
1670
1671
1672
1673