gtk/src/callbacks.c

   1 /* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 4; tab-width: 4 -*- */
   2 /*
   3  * callbacks.c
   4  * Copyright (C) John Stebbins 2008 <stebbins@stebbins>
   5  *
   6  * callbacks.c is free software.
   7  *
   8  * You may redistribute it and/or modify it under the terms of the
   9  * GNU General Public License, as published by the Free Software
  10  * Foundation; either version 2 of the License, or (at your option)
  11  * any later version.
  12  */
  13
  14 #ifdef HAVE_CONFIG_H
  15 #  include <config.h>
  16 #endif
  17
  18 #include <string.h>
  19 #include <fcntl.h>
  20 #include <sys/stat.h>
  21 #include <time.h>
  22
  23 #if !defined(_WIN32)
  24 #include <poll.h>
  25 #include <libhal-storage.h>
  26 #include <dbus/dbus-glib.h>
  27 #include <dbus/dbus-glib-lowlevel.h>
  28
  29 #include <netinet/in.h>
  30 #include <netdb.h>
  31 #if defined(_OLD_WEBKIT)
  32 #include <webkit.h>
  33 #else
  34 #include <webkit/webkit.h>
  35 #endif
  36 #include <libnotify/notify.h>
  37 #include <gdk/gdkx.h>
  38 #else
  39 #define WINVER 0x0500
  40 #include <winsock2.h>
  41 #include <dbt.h>
  42 #endif
  43
  44 #include <gtk/gtk.h>
  45 #include <gdk/gdkkeysyms.h>
  46 #include <glib/gstdio.h>
  47 #include <gio/gio.h>
  48
  49 #include "hb.h"
  50 #include "callbacks.h"
  51 #include "queuehandler.h"
  52 #include "audiohandler.h"
  53 #include "subtitlehandler.h"
  54 #include "resources.h"
  55 #include "settings.h"
  56 #include "presets.h"
  57 #include "preview.h"
  58 #include "values.h"
  59 #include "plist.h"
  60 #include "appcast.h"
  61 #include "hb-backend.h"
  62 #include "ghb-dvd.h"
  63 #include "ghbcellrenderertext.h"
  64
  65 static void reset_chapter_list(signal_user_data_t *ud, GValue *settings);
  66 static void update_chapter_list(signal_user_data_t *ud);
  67 static GList* dvd_device_list();
  68 static void prune_logs(signal_user_data_t *ud);
  69 void ghb_notify_done(signal_user_data_t *ud);
  70 gpointer ghb_check_update(signal_user_data_t *ud);
  71 static gboolean ghb_can_shutdown_gsm();
  72 static void ghb_shutdown_gsm();
  73 static gboolean ghb_can_suspend_gpm();
  74 static void ghb_suspend_gpm();
  75 static gboolean appcast_busy = FALSE;
  76
  77 // This is a dependency map used for greying widgets
  78 // that are dependent on the state of another widget.
  79 // The enable_value comes from the values that are
  80 // obtained from ghb_widget_value().  For combo boxes
  81 // you will have to look further to combo box options
  82 // maps in hb-backend.c
  83
  84 GValue *dep_map;
  85 GValue *rev_map;
  86
  87 void
  88 ghb_init_dep_map()
  89 {
  90         dep_map = ghb_resource_get("widget-deps");
  91         rev_map = ghb_resource_get("widget-reverse-deps");
  92 }
  93
  94 static gboolean
  95 dep_check(signal_user_data_t *ud, const gchar *name, gboolean *out_hide)
  96 {
  97         GtkWidget *widget;
  98         GObject *dep_object;
  99         gint ii;
 100         gint count;
 101         gboolean result = TRUE;
 102         GValue *array, *data;
 103         gchar *widget_name;
 104
 105         g_debug("dep_check () %s", name);
 106
 107         if (rev_map == NULL) return TRUE;
 108         array = ghb_dict_lookup(rev_map, name);
 109         count = ghb_array_len(array);
 110         *out_hide = FALSE;
 111         for (ii = 0; ii < count; ii++)
 112         {
 113                 data = ghb_array_get_nth(array, ii);
 114                 widget_name = ghb_value_string(ghb_array_get_nth(data, 0));
 115                 widget = GHB_WIDGET(ud->builder, widget_name);
 116                 dep_object = gtk_builder_get_object(ud->builder, name);
 117                 if (widget != NULL && !GTK_WIDGET_SENSITIVE(widget))
 118                         continue;
 119                 if (dep_object == NULL)
 120                 {
 121                         g_message("Failed to find widget");
 122                 }
 123                 else
 124                 {
 125                         gchar *value;
 126                         gint jj = 0;
 127                         gchar **values;
 128                         gboolean sensitive = FALSE;
 129                         gboolean die, hide;
 130
 131                         die = ghb_value_boolean(ghb_array_get_nth(data, 2));
 132                         hide = ghb_value_boolean(ghb_array_get_nth(data, 3));
 133                         value = ghb_value_string(ghb_array_get_nth(data, 1));
 134                         values = g_strsplit(value, "|", 10);
 135                         g_free(value);
 136
 137                         if (widget)
 138                                 value = ghb_widget_string(widget);
 139                         else
 140                                 value = ghb_settings_get_string(ud->settings, widget_name);
 141                         while (values && values[jj])
 142                         {
 143                                 if (values[jj][0] == '>')
 144                                 {
 145                                         gdouble dbl = g_strtod (&values[jj][1], NULL);
 146                                         gdouble dvalue = ghb_widget_double(widget);
 147                                         if (dvalue > dbl)
 148                                         {
 149                                                 sensitive = TRUE;
 150                                                 break;
 151                                         }
 152                                 }
 153                                 else if (values[jj][0] == '<')
 154                                 {
 155                                         gdouble dbl = g_strtod (&values[jj][1], NULL);
 156                                         gdouble dvalue = ghb_widget_double(widget);
 157                                         if (dvalue < dbl)
 158                                         {
 159                                                 sensitive = TRUE;
 160                                                 break;
 161                                         }
 162                                 }
 163                                 if (strcmp(values[jj], value) == 0)
 164                                 {
 165                                         sensitive = TRUE;
 166                                         break;
 167                                 }
 168                                 jj++;
 169                         }
 170                         sensitive = die ^ sensitive;
 171                         if (!sensitive)
 172                         {
 173                                 result = FALSE;
 174                                 *out_hide |= hide;
 175                         }
 176                         g_strfreev (values);
 177                         g_free(value);
 178                 }
 179                 g_free(widget_name);
 180         }
 181         return result;
 182 }
 183
 184 void
 185 ghb_check_dependency(
 186         signal_user_data_t *ud,
 187         GtkWidget *widget,
 188         const char *alt_name)
 189 {
 190         GObject *dep_object;
 191         const gchar *name;
 192         GValue *array, *data;
 193         gint count, ii;
 194         gchar *dep_name;
 195         GType type;
 196
 197         if (widget != NULL)
 198         {
 199                 type = GTK_WIDGET_TYPE(widget);
 200                 if (type == GTK_TYPE_COMBO_BOX || type == GTK_TYPE_COMBO_BOX_ENTRY)
 201                         if (gtk_combo_box_get_active(GTK_COMBO_BOX(widget)) < 0) return;
 202                 name = gtk_widget_get_name(widget);
 203         }
 204         else
 205                 name = alt_name;
 206
 207         g_debug("ghb_check_dependency () %s", name);
 208
 209         if (dep_map == NULL) return;
 210         array = ghb_dict_lookup(dep_map, name);
 211         count = ghb_array_len(array);
 212         for (ii = 0; ii < count; ii++)
 213         {
 214                 gboolean sensitive;
 215                 gboolean hide;
 216
 217                 data = ghb_array_get_nth(array, ii);
 218                 dep_name = ghb_value_string(data);
 219                 dep_object = gtk_builder_get_object(ud->builder, dep_name);
 220                 if (dep_object == NULL)
 221                 {
 222                         g_message("Failed to find dependent widget %s", dep_name);
 223                         g_free(dep_name);
 224                         continue;
 225                 }
 226                 sensitive = dep_check(ud, dep_name, &hide);
 227                 g_free(dep_name);
 228                 if (GTK_IS_ACTION(dep_object))
 229                 {
 230                         gtk_action_set_sensitive(GTK_ACTION(dep_object), sensitive);
 231                         gtk_action_set_visible(GTK_ACTION(dep_object), sensitive || !hide);
 232                 }
 233                 else
 234                 {
 235                         gtk_widget_set_sensitive(GTK_WIDGET(dep_object), sensitive);
 236                         if (!sensitive && hide)
 237                         {
 238                                 gtk_widget_hide(GTK_WIDGET(dep_object));
 239                         }
 240                         else
 241                         {
 242                                 gtk_widget_show_now(GTK_WIDGET(dep_object));
 243                         }
 244                 }
 245         }
 246 }
 247
 248 void
 249 ghb_check_all_depencencies(signal_user_data_t *ud)
 250 {
 251         GHashTableIter iter;
 252         gchar *dep_name;
 253         GValue *value;
 254         GObject *dep_object;
 255
 256         g_debug("ghb_check_all_depencencies ()");
 257         if (rev_map == NULL) return;
 258         ghb_dict_iter_init(&iter, rev_map);
 259         // middle (void*) cast prevents gcc warning "defreferencing type-punned
 260         // pointer will break strict-aliasing rules"
 261         while (g_hash_table_iter_next(
 262                         &iter, (gpointer*)(void*)&dep_name, (gpointer*)(void*)&value))
 263         {
 264                 gboolean sensitive;
 265                 gboolean hide;
 266
 267                 dep_object = gtk_builder_get_object (ud->builder, dep_name);
 268                 if (dep_object == NULL)
 269                 {
 270                         g_message("Failed to find dependent widget %s", dep_name);
 271                         continue;
 272                 }
 273                 sensitive = dep_check(ud, dep_name, &hide);
 274                 if (GTK_IS_ACTION(dep_object))
 275                 {
 276                         gtk_action_set_sensitive(GTK_ACTION(dep_object), sensitive);
 277                         gtk_action_set_visible(GTK_ACTION(dep_object), sensitive || !hide);
 278                 }
 279                 else
 280                 {
 281                         gtk_widget_set_sensitive(GTK_WIDGET(dep_object), sensitive);
 282                         if (!sensitive && hide)
 283                         {
 284                                 gtk_widget_hide(GTK_WIDGET(dep_object));
 285                         }
 286                         else
 287                         {
 288                                 gtk_widget_show_now(GTK_WIDGET(dep_object));
 289                         }
 290                 }
 291         }
 292 }
 293
 294 G_MODULE_EXPORT void
 295 on_quit1_activate(GtkMenuItem *quit, signal_user_data_t *ud)
 296 {
 297         gint state = ghb_get_queue_state();
 298         g_debug("on_quit1_activate ()");
 299         if (state & GHB_STATE_WORKING)
 300         {
 301                 if (ghb_cancel_encode2(ud, "Closing HandBrake will terminate encoding.\n"))
 302                 {
 303                         ghb_hb_cleanup(FALSE);
 304                         prune_logs(ud);
 305                         gtk_main_quit();
 306                         return;
 307                 }
 308                 return;
 309         }
 310         ghb_hb_cleanup(FALSE);
 311         prune_logs(ud);
 312         gtk_main_quit();
 313 }
 314
 315 gboolean
 316 uppers_and_unders(gchar *str)
 317 {
 318         if (str == NULL) return FALSE;
 319         str = g_strchomp(g_strchug(str));
 320         while (*str)
 321         {
 322                 if (*str == ' ')
 323                 {
 324                         return FALSE;
 325                 }
 326                 if (*str >= 'a' && *str <= 'z')
 327                 {
 328                         return FALSE;
 329                 }
 330                 str++;
 331         }
 332         return TRUE;
 333 }
 334
 335 enum
 336 {
 337         CAMEL_FIRST_UPPER,
 338         CAMEL_OTHER
 339 };
 340
 341 void
 342 camel_convert(gchar *str)
 343 {
 344         gint state = CAMEL_OTHER;
 345
 346         if (str == NULL) return;
 347         while (*str)
 348         {
 349                 if (*str == '_') *str = ' ';
 350                 switch (state)
 351                 {
 352                         case CAMEL_OTHER:
 353                         {
 354                                 if (*str >= 'A' && *str <= 'Z')
 355                                         state = CAMEL_FIRST_UPPER;
 356                                 else
 357                                         state = CAMEL_OTHER;
 358
 359                         } break;
 360                         case CAMEL_FIRST_UPPER:
 361                         {
 362                                 if (*str >= 'A' && *str <= 'Z')
 363                                         *str = *str - 'A' + 'a';
 364                                 else
 365                                         state = CAMEL_OTHER;
 366                         } break;
 367                 }
 368                 str++;
 369         }
 370 }
 371
 372 #if defined(_WIN32)
 373 static gchar*
 374 get_dvd_device_name(gchar *device)
 375 {
 376         return g_strdup(device);
 377 }
 378 #else
 379 static gchar*
 380 get_dvd_device_name(GDrive *gd)
 381 {
 382         return g_drive_get_identifier(gd, G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE);
 383 }
 384 #endif
 385
 386 static GHashTable *volname_hash = NULL;
 387 static GMutex     *volname_mutex = NULL;
 388
 389 static void
 390 free_volname_key(gpointer data)
 391 {
 392         if (data != NULL)
 393                 g_free(data);
 394 }
 395
 396 static void
 397 free_volname_value(gpointer data)
 398 {
 399         if (data != NULL)
 400                 g_free(data);
 401 }
 402
 403 #if defined(_WIN32)
 404 static gchar*
 405 get_direct_dvd_volume_name(const gchar *drive)
 406 {
 407         gchar *result = NULL;
 408         gchar vname[51], fsname[51];
 409
 410         if (GetVolumeInformation(drive, vname, 50, NULL, NULL, NULL, fsname, 50))
 411         {
 412                 result = g_strdup_printf("%s", vname);
 413         }
 414         return result;
 415 }
 416 #else
 417 static gchar*
 418 get_direct_dvd_volume_name(const gchar *drive)
 419 {
 420         gchar *result;
 421
 422         result = ghb_dvd_volname (drive);
 423         return result;
 424 }
 425 #endif
 426
 427 static gchar*
 428 get_dvd_volume_name(gpointer gd)
 429 {
 430         gchar *label = NULL;
 431         gchar *result;
 432         gchar *drive;
 433
 434         drive = get_dvd_device_name(gd);
 435         g_mutex_lock(volname_mutex);
 436         label = g_strdup(g_hash_table_lookup(volname_hash, drive));
 437         g_mutex_unlock(volname_mutex);
 438         if (label != NULL)
 439         {
 440                 if (uppers_and_unders(label))
 441                 {
 442                         camel_convert(label);
 443                 }
 444 #if defined(_WIN32)
 445                 result = g_strdup_printf("%s (%s)", label, drive);
 446 #else
 447                 result = g_strdup_printf("%s - %s", drive, label);
 448 #endif
 449                 g_free(label);
 450         }
 451         else
 452         {
 453                 result = g_strdup_printf("%s", drive);
 454         }
 455         g_free(drive);
 456         return result;
 457 }
 458
 459 void
 460 ghb_volname_cache_init(void)
 461 {
 462         volname_mutex = g_mutex_new();
 463         volname_hash = g_hash_table_new_full(g_str_hash, g_str_equal,
 464                                                                                 free_volname_key, free_volname_value);
 465 }
 466
 467 static void
 468 free_drive(gpointer drive)
 469 {
 470 #if defined(_WIN32)
 471                 g_free(drive);
 472 #else
 473                 g_object_unref(drive);
 474 #endif
 475 }
 476
 477 gpointer
 478 ghb_cache_volnames(signal_user_data_t *ud)
 479 {
 480         GList *link, *drives;
 481
 482         g_debug("ghb_cache_volnames()");
 483         link = drives = dvd_device_list();
 484         if (drives == NULL)
 485                 return NULL;
 486
 487         g_mutex_lock(volname_mutex);
 488         g_hash_table_remove_all(volname_hash);
 489         while (link != NULL)
 490         {
 491                 gchar *name, *drive;
 492
 493 #if !defined(_WIN32)
 494                 if (!g_drive_has_media (link->data))
 495                 {
 496                         g_object_unref(link->data);
 497                         link = link->next;
 498                         continue;
 499                 }
 500 #endif
 501                 drive = get_dvd_device_name(link->data);
 502                 name = get_direct_dvd_volume_name(drive);
 503
 504                 if (drive != NULL && name != NULL)
 505                 {
 506                         g_hash_table_insert(volname_hash, drive, name);
 507                 }
 508                 else
 509                 {
 510                         if (drive != NULL)
 511                                 g_free(drive);
 512                         if (name != NULL)
 513                                 g_free(name);
 514                 }
 515
 516                 free_drive(link->data);
 517                 link = link->next;
 518         }
 519         g_mutex_unlock(volname_mutex);
 520
 521         g_list_free(drives);
 522
 523         g_idle_add((GSourceFunc)ghb_file_menu_add_dvd, ud);
 524
 525         return NULL;
 526 }
 527
 528 static const gchar*
 529 get_extension(signal_user_data_t *ud)
 530 {
 531         int container;
 532         const gchar *extension = "error";
 533         GValue *audio_list;
 534         GValue *subtitle_list;
 535
 536         container = ghb_settings_combo_int(ud->settings, "FileFormat");
 537         if (container == HB_MUX_MP4)
 538         {
 539                 extension = "mp4";
 540                 audio_list = ghb_settings_get_value(ud->settings, "audio_list");
 541                 subtitle_list = ghb_settings_get_value(ud->settings, "subtitle_list");
 542                 if (ghb_ac3_in_audio_list(audio_list) ||
 543                         ghb_soft_in_subtitle_list(subtitle_list) ||
 544                         ghb_settings_get_boolean(ud->settings, "ChapterMarkers") ||
 545                         ghb_settings_get_boolean(ud->settings, "UseM4v"))
 546                 {
 547                         extension = "m4v";
 548                 }
 549         }
 550         else if (container == HB_MUX_MKV)
 551         {
 552                 extension = "mkv";
 553         }
 554         return extension;
 555 }
 556
 557 static void
 558 set_destination(signal_user_data_t *ud)
 559 {
 560         g_debug("set_destination");
 561         if (ghb_settings_get_boolean(ud->settings, "use_source_name"))
 562         {
 563                 GString *str = g_string_new("");
 564                 gchar *vol_name, *filename;
 565                 const gchar *extension;
 566                 gchar *new_name;
 567                 gint title;
 568
 569                 filename = ghb_settings_get_string(ud->settings, "dest_file");
 570                 extension = get_extension(ud);
 571                 vol_name = ghb_settings_get_string(ud->settings, "volume_label");
 572                 g_string_append_printf(str, "%s", vol_name);
 573                 title = ghb_settings_combo_int(ud->settings, "title");
 574                 if (title >= 0)
 575                 {
 576                         if (ghb_settings_get_boolean(
 577                                         ud->settings, "title_no_in_destination"))
 578                         {
 579
 580                                 title = ghb_settings_combo_int(ud->settings, "title");
 581                                 g_string_append_printf(str, " - %d", title+1);
 582                         }
 583                         if (ghb_settings_get_boolean(
 584                                         ud->settings, "chapters_in_destination"))
 585                         {
 586                                 gint start, end;
 587
 588                                 if (!ghb_settings_get_boolean(
 589                                                 ud->settings, "title_no_in_destination"))
 590                                 {
 591                                         g_string_append_printf(str, " -");
 592                                 }
 593                                 start = ghb_settings_get_int(ud->settings, "start_chapter");
 594                                 end = ghb_settings_get_int(ud->settings, "end_chapter");
 595                                 if (start == end)
 596                                         g_string_append_printf(str, " Ch %d", start);
 597                                 else
 598                                         g_string_append_printf(str, " Ch %d-%d", start, end);
 599                         }
 600                 }
 601                 g_string_append_printf(str, ".%s", extension);
 602                 new_name = g_string_free(str, FALSE);
 603                 ghb_ui_update(ud, "dest_file", ghb_string_value(new_name));
 604                 g_free(filename);
 605                 g_free(vol_name);
 606                 g_free(new_name);
 607         }
 608 }
 609
 610 static gchar*
 611 get_file_label(const gchar *filename)
 612 {
 613         gchar *base, *pos, *end;
 614
 615         base = g_path_get_basename(filename);
 616         pos = strrchr(base, '.');
 617         if (pos != NULL)
 618         {
 619                 // If the last '.' is within 4 chars of end of name, assume
 620                 // there is an extension we want to strip.
 621                 end = &base[strlen(base) - 1];
 622                 if (end - pos <= 4)
 623                         *pos = 0;
 624         }
 625         return base;
 626 }
 627
 628 static gchar*
 629 resolve_drive_name(gchar *filename)
 630 {
 631 #if defined(_WIN32)
 632         if (filename[1] == ':')
 633         {
 634                 gchar drive[4];
 635                 gchar *name;
 636                 gint dtype;
 637
 638                 g_strlcpy(drive, filename, 4);
 639                 dtype = GetDriveType(drive);
 640                 if (dtype == DRIVE_CDROM)
 641                 {
 642                         gchar vname[51], fsname[51];
 643                         GetVolumeInformation(drive, vname, 50, NULL,
 644                                                                 NULL, NULL, fsname, 50);
 645                         name = g_strdup(vname);
 646                         return name;
 647                 }
 648         }
 649         return NULL;
 650 #else
 651         return NULL;
 652 #endif
 653 }
 654
 655 static gboolean
 656 update_source_label(signal_user_data_t *ud, const gchar *source, gboolean update_dest)
 657 {
 658         gchar *label = NULL;
 659         gint len;
 660         gchar **path;
 661         gchar *start;
 662         gchar *filename = g_strdup(source);
 663
 664         g_debug("update_source_label()");
 665         len = strlen(filename);
 666         if (g_file_test(filename, G_FILE_TEST_IS_DIR))
 667         {
 668                 // Skip dos drive letters
 669 #if defined(_WIN32)
 670                 start = strchr(filename, ':');
 671 #else
 672                 start = filename;
 673 #endif
 674                 label = resolve_drive_name(filename);
 675                 if (label != NULL)
 676                 {
 677                         if (uppers_and_unders(label))
 678                         {
 679                                 camel_convert(label);
 680                         }
 681                 }
 682                 else
 683                 {
 684                         if (filename[len-1] == G_DIR_SEPARATOR) filename[len-1] = 0;
 685                         if (start != NULL)
 686                                 start++;
 687                         else
 688                                 start = filename;
 689
 690                         path = g_strsplit(start, G_DIR_SEPARATOR_S, -1);
 691                         len = g_strv_length (path);
 692                         if ((len > 1) && (strcmp("VIDEO_TS", path[len-1]) == 0))
 693                         {
 694                                 label = g_strdup(path[len-2]);
 695                                 if (uppers_and_unders(label))
 696                                 {
 697                                         camel_convert(label);
 698                                 }
 699                         }
 700                         else if (len > 0)
 701                         {
 702                                 if (path[len-1][0] != 0)
 703                                 {
 704                                         label = g_strdup(path[len-1]);
 705                                         if (uppers_and_unders(label))
 706                                         {
 707                                                 camel_convert(label);
 708                                         }
 709                                 }
 710                                 else
 711                                         label = g_strdup("new_video");
 712                         }
 713                         else
 714                                 label = g_strdup("new_video");
 715                         g_strfreev (path);
 716                 }
 717         }
 718         else
 719         {
 720                 // Is regular file or block dev.
 721                 // Check to see if it is a dvd image
 722                 label = ghb_dvd_volname (filename);
 723                 if (label == NULL)
 724                 {
 725                         label = get_file_label(filename);
 726                 }
 727                 else
 728                 {
 729                         if (uppers_and_unders(label))
 730                         {
 731                                 camel_convert(label);
 732                         }
 733                 }
 734         }
 735         g_free(filename);
 736         GtkWidget *widget = GHB_WIDGET (ud->builder, "source_title");
 737         if (label != NULL)
 738         {
 739                 gtk_label_set_text (GTK_LABEL(widget), label);
 740                 ghb_settings_set_string(ud->settings, "volume_label", label);
 741                 g_free(label);
 742                 if (update_dest)
 743                         set_destination(ud);
 744         }
 745         else
 746         {
 747                 label = "No Title Found";
 748                 gtk_label_set_text (GTK_LABEL(widget), label);
 749                 ghb_settings_set_string(ud->settings, "volume_label", label);
 750                 return FALSE;
 751         }
 752         return TRUE;
 753 }
 754
 755 G_MODULE_EXPORT void
 756 chooser_file_selected_cb(GtkFileChooser *dialog, signal_user_data_t *ud)
 757 {
 758         gchar *name = gtk_file_chooser_get_filename (dialog);
 759         GtkTreeModel *store;
 760         GtkTreeIter iter;
 761         const gchar *device;
 762         gboolean foundit = FALSE;
 763         GtkComboBox *combo;
 764
 765         if (name == NULL) return;
 766         combo = GTK_COMBO_BOX(GHB_WIDGET(ud->builder, "source_device"));
 767         store = gtk_combo_box_get_model(combo);
 768         if (gtk_tree_model_get_iter_first(store, &iter))
 769         {
 770                 do
 771                 {
 772                         gtk_tree_model_get(store, &iter, 0, &device, -1);
 773                         if (strcmp(name, device) == 0)
 774                         {
 775                                 foundit = TRUE;
 776                                 break;
 777                         }
 778                 } while (gtk_tree_model_iter_next(GTK_TREE_MODEL(store), &iter));
 779         }
 780         if (foundit)
 781                 gtk_combo_box_set_active_iter (combo, &iter);
 782         else
 783                 gtk_combo_box_set_active (combo, 0);
 784
 785         g_free(name);
 786 }
 787
 788 G_MODULE_EXPORT void
 789 dvd_device_changed_cb(GtkComboBox *combo, signal_user_data_t *ud)
 790 {
 791         GtkWidget *dialog;
 792         gint ii;
 793
 794         ii = gtk_combo_box_get_active (combo);
 795         if (ii > 0)
 796         {
 797                 const gchar *device;
 798                 gchar *name;
 799
 800                 dialog = GHB_WIDGET(ud->builder, "source_dialog");
 801                 device = gtk_combo_box_get_active_text (combo);
 802                 name = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER(dialog));
 803                 if (name == NULL || strcmp(name, device) != 0)
 804                         gtk_file_chooser_select_filename (GTK_FILE_CHOOSER(dialog), device);
 805                 if (name != NULL)
 806                         g_free(name);
 807         }
 808 }
 809
 810 G_MODULE_EXPORT void
 811 source_type_changed_cb(GtkToggleButton *toggle, signal_user_data_t *ud)
 812 {
 813         gchar *folder;
 814         GtkFileChooser *chooser;
 815         GtkWidget *dvd_device_combo;
 816
 817         g_debug("source_type_changed_cb ()");
 818         chooser = GTK_FILE_CHOOSER(GHB_WIDGET(ud->builder, "source_dialog"));
 819         dvd_device_combo = GHB_WIDGET(ud->builder, "source_device");
 820         folder = gtk_file_chooser_get_current_folder (chooser);
 821         if (gtk_toggle_button_get_active (toggle))
 822         {
 823                 gtk_file_chooser_set_action (chooser,
 824                                                                         GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER);
 825                 gtk_widget_set_sensitive (dvd_device_combo, FALSE);
 826                 gtk_combo_box_set_active (GTK_COMBO_BOX(dvd_device_combo), 0);
 827         }
 828         else
 829         {
 830                 gtk_file_chooser_set_action (chooser, GTK_FILE_CHOOSER_ACTION_OPEN);
 831                 gtk_widget_set_sensitive (dvd_device_combo, TRUE);
 832         }
 833         if (folder != NULL)
 834         {
 835                 gtk_file_chooser_set_current_folder(chooser, folder);
 836                 g_free(folder);
 837         }
 838 }
 839
 840 static void
 841 source_dialog_extra_widgets(
 842         signal_user_data_t *ud,
 843         GtkWidget *dialog,
 844         gboolean checkbutton_active)
 845 {
 846         GtkToggleButton *checkbutton;
 847         GtkComboBox *combo;
 848         GList *drives, *link;
 849
 850         checkbutton = GTK_TOGGLE_BUTTON(
 851                 GHB_WIDGET(ud->builder, "source_folder_flag"));
 852         gtk_toggle_button_set_active(checkbutton, checkbutton_active);
 853         combo = GTK_COMBO_BOX(GHB_WIDGET(ud->builder, "source_device"));
 854         gtk_list_store_clear(GTK_LIST_STORE(
 855                                                 gtk_combo_box_get_model(combo)));
 856
 857         link = drives = dvd_device_list();
 858         gtk_combo_box_append_text (combo, "Not Selected");
 859         while (link != NULL)
 860         {
 861                 gchar *name = get_dvd_device_name(link->data);
 862                 gtk_combo_box_append_text(combo, name);
 863                 g_free(name);
 864                 free_drive(link->data);
 865                 link = link->next;
 866         }
 867         g_list_free(drives);
 868 }
 869
 870 extern GValue *ghb_queue_edit_settings;
 871 static gchar *last_scan_file = NULL;
 872
 873 static void
 874 show_scan_progress(signal_user_data_t *ud)
 875 {
 876         GtkProgressBar *progress;
 877         GtkLabel *label;
 878
 879         progress = GTK_PROGRESS_BAR(GHB_WIDGET(ud->builder, "scan_prog"));
 880         gtk_progress_bar_set_fraction (progress, 0);
 881         gtk_widget_show(GTK_WIDGET(progress));
 882
 883         label = GTK_LABEL(GHB_WIDGET(ud->builder, "source_title"));
 884         gtk_label_set_text( label, "Scanning ..." );
 885 }
 886
 887 static void
 888 start_scan(
 889         signal_user_data_t *ud,
 890         const gchar *path,
 891         gint titlenum,
 892         gint preview_count)
 893 {
 894         GtkWidget *widget;
 895         GtkAction *action;
 896         ghb_status_t status;
 897
 898         ghb_get_status(&status);
 899         if (status.scan.state != GHB_STATE_IDLE)
 900                 return;
 901
 902         widget = GHB_WIDGET(ud->builder, "sourcetoolbutton");
 903         gtk_tool_button_set_icon_name(GTK_TOOL_BUTTON(widget), "hb-stop");
 904         gtk_tool_button_set_label(GTK_TOOL_BUTTON(widget), "Stop Scan");
 905         gtk_tool_item_set_tooltip_text(GTK_TOOL_ITEM(widget), "Stop Scan");
 906         //gtk_widget_set_sensitive(widget, FALSE);
 907
 908         action = GHB_ACTION(ud->builder, "source_action");
 909         gtk_action_set_sensitive(action, FALSE);
 910         action = GHB_ACTION(ud->builder, "source_single_action");
 911         gtk_action_set_sensitive(action, FALSE);
 912         ghb_backend_scan(path, titlenum, preview_count);
 913 }
 914
 915 void
 916 ghb_do_scan(
 917         signal_user_data_t *ud,
 918         const gchar *filename,
 919         gint titlenum,
 920         gboolean force)
 921 {
 922         g_debug("ghb_do_scan()");
 923         if (!force && last_scan_file != NULL &&
 924                 strcmp(last_scan_file, filename) == 0)
 925         {
 926                 if (ghb_queue_edit_settings)
 927                 {
 928                         ghb_settings_to_ui(ud, ghb_queue_edit_settings);
 929                         ghb_set_audio(ud, ghb_queue_edit_settings);
 930                         ghb_reset_subtitles(ud, ghb_queue_edit_settings);
 931                         reset_chapter_list(ud, ghb_queue_edit_settings);
 932                         ghb_value_free(ghb_queue_edit_settings);
 933                         ghb_queue_edit_settings = NULL;
 934                 }
 935                 return;
 936         }
 937         if (last_scan_file != NULL)
 938                 g_free(last_scan_file);
 939         last_scan_file = NULL;
 940         if (filename != NULL)
 941         {
 942                 last_scan_file = g_strdup(filename);
 943                 ghb_settings_set_string(ud->settings, "scan_source", filename);
 944                 if (update_source_label(ud, filename, TRUE))
 945                 {
 946                         gchar *path;
 947                         gint preview_count;
 948
 949                         show_scan_progress(ud);
 950                         path = ghb_settings_get_string( ud->settings, "scan_source");
 951                         prune_logs(ud);
 952
 953                         preview_count = ghb_settings_get_int(ud->settings, "preview_count");
 954                         start_scan(ud, path, titlenum, preview_count);
 955                         g_free(path);
 956                 }
 957                 else
 958                 {
 959                         // TODO: error dialog
 960                 }
 961         }
 962 }
 963
 964 static gboolean
 965 update_source_name(gpointer data)
 966 {
 967         signal_user_data_t *ud = (signal_user_data_t*)data;
 968         GtkWidget *dialog;
 969         gchar *sourcename;
 970
 971         sourcename = ghb_settings_get_string(ud->settings, "scan_source");
 972         dialog = GHB_WIDGET(ud->builder, "source_dialog");
 973         gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(dialog), sourcename);
 974         g_free(sourcename);
 975         return FALSE;
 976 }
 977
 978 static void
 979 do_source_dialog(GtkButton *button, gboolean single, signal_user_data_t *ud)
 980 {
 981         GtkWidget *dialog;
 982         gchar *sourcename;
 983         gint    response;
 984         GtkFileChooserAction action;
 985         gboolean checkbutton_active;
 986
 987         g_debug("source_browse_clicked_cb ()");
 988         sourcename = ghb_settings_get_string(ud->settings, "scan_source");
 989         checkbutton_active = FALSE;
 990         if (g_file_test(sourcename, G_FILE_TEST_IS_DIR))
 991         {
 992                 action = GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER;
 993                 checkbutton_active = TRUE;
 994         }
 995         else
 996         {
 997                 action = GTK_FILE_CHOOSER_ACTION_OPEN;
 998         }
 999         GtkWidget *widget;
1000         widget = GHB_WIDGET(ud->builder, "single_title_box");
1001         if (single)
1002                 gtk_widget_show(widget);
1003         else
1004                 gtk_widget_hide(widget);
1005         dialog = GHB_WIDGET(ud->builder, "source_dialog");
1006         source_dialog_extra_widgets(ud, dialog, checkbutton_active);
1007         gtk_file_chooser_set_action(GTK_FILE_CHOOSER(dialog), action);
1008         // Updating the filename in the file chooser dialog doesn't seem
1009         // to work unless the dialog is running for some reason.
1010         // So handle it in an "idle" event.
1011         //gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(dialog), sourcename);
1012         g_idle_add((GSourceFunc)update_source_name, ud);
1013         response = gtk_dialog_run(GTK_DIALOG (dialog));
1014         gtk_widget_hide(dialog);
1015         if (response == GTK_RESPONSE_ACCEPT)
1016         {
1017                 gchar *filename;
1018
1019                 filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
1020                 if (filename != NULL)
1021                 {
1022                         gint titlenum;
1023
1024                         if (single)
1025                                 titlenum = ghb_settings_get_int(ud->settings, "single_title");
1026                         else
1027                                 titlenum = 0;
1028                         ghb_do_scan(ud, filename, titlenum, TRUE);
1029                         if (strcmp(sourcename, filename) != 0)
1030                         {
1031                                 ghb_settings_set_string (ud->settings,
1032                                                                                 "default_source", filename);
1033                                 ghb_pref_save (ud->settings, "default_source");
1034                                 ghb_dvd_set_current (filename, ud);
1035                         }
1036                         g_free(filename);
1037                 }
1038         }
1039         g_free(sourcename);
1040 }
1041
1042 G_MODULE_EXPORT void
1043 source_button_clicked_cb(GtkButton *button, signal_user_data_t *ud)
1044 {
1045         ghb_status_t status;
1046         ghb_get_status(&status);
1047         if (status.scan.state & GHB_STATE_SCANNING)
1048         {
1049                 ghb_backend_scan_stop();
1050         }
1051         else
1052         {
1053                 do_source_dialog(button, FALSE, ud);
1054         }
1055 }
1056
1057 G_MODULE_EXPORT void
1058 single_title_source_cb(GtkButton *button, signal_user_data_t *ud)
1059 {
1060         do_source_dialog(button, TRUE, ud);
1061 }
1062
1063 G_MODULE_EXPORT void
1064 dvd_source_activate_cb(GtkAction *action, signal_user_data_t *ud)
1065 {
1066         const gchar *filename;
1067         gchar *sourcename;
1068
1069         sourcename = ghb_settings_get_string(ud->settings, "scan_source");
1070         filename = gtk_action_get_name(action);
1071         ghb_do_scan(ud, filename, 0, TRUE);
1072         if (strcmp(sourcename, filename) != 0)
1073         {
1074                 ghb_settings_set_string (ud->settings, "default_source", filename);
1075                 ghb_pref_save (ud->settings, "default_source");
1076                 ghb_dvd_set_current (filename, ud);
1077         }
1078         g_free(sourcename);
1079 }
1080
1081 void
1082 ghb_update_destination_extension(signal_user_data_t *ud)
1083 {
1084         static gchar *containers[] = {".mkv", ".mp4", ".m4v", NULL};
1085         gchar *filename;
1086         const gchar *extension;
1087         gint ii;
1088         GtkEntry *entry;
1089         static gboolean busy = FALSE;
1090
1091         g_debug("ghb_update_destination_extension ()");
1092         // Since this function modifies the thing that triggers it's
1093         // invocation, check to see if busy to prevent accidental infinite
1094         // recursion.
1095         if (busy)
1096                 return;
1097         busy = TRUE;
1098         extension = get_extension(ud);
1099         entry = GTK_ENTRY(GHB_WIDGET(ud->builder, "dest_file"));
1100         filename = g_strdup(gtk_entry_get_text(entry));
1101         for (ii = 0; containers[ii] != NULL; ii++)
1102         {
1103                 if (g_str_has_suffix(filename, containers[ii]))
1104                 {
1105                         gchar *pos;
1106                         gchar *new_name;
1107
1108                         pos = g_strrstr( filename, "." );
1109                         if (pos == NULL)
1110                         {
1111                                 // No period? shouldn't happen
1112                                 break;
1113                         }
1114                         *pos = 0;
1115                         if (strcmp(extension, &pos[1]) == 0)
1116                         {
1117                                 // Extension is already correct
1118                                 break;
1119                         }
1120                         new_name = g_strjoin(".", filename, extension, NULL);
1121                         ghb_ui_update(ud, "dest_file", ghb_string_value(new_name));
1122                         g_free(new_name);
1123                         break;
1124                 }
1125         }
1126         g_free(filename);
1127         busy = FALSE;
1128 }
1129
1130 static void
1131 destination_select_title(GtkEntry *entry)
1132 {
1133         const gchar *dest;
1134         gint start, end;
1135
1136         dest = gtk_entry_get_text(entry);
1137         for (end = strlen(dest)-1; end > 0; end--)
1138         {
1139                 if (dest[end] == '.')
1140                 {
1141                         break;
1142                 }
1143         }
1144         for (start = end; start >= 0; start--)
1145         {
1146                 if (dest[start] == G_DIR_SEPARATOR)
1147                 {
1148                         start++;
1149                         break;
1150                 }
1151         }
1152         if (start < 0) start = 0;
1153         if (start < end)
1154         {
1155                 gtk_editable_select_region(GTK_EDITABLE(entry), start, end);
1156         }
1157 }
1158
1159 G_MODULE_EXPORT gboolean
1160 destination_grab_cb(
1161         GtkEntry *entry,
1162         signal_user_data_t *ud)
1163 {
1164         destination_select_title(entry);
1165         return FALSE;
1166 }
1167
1168 static gboolean update_default_destination = FALSE;
1169
1170 G_MODULE_EXPORT void
1171 dest_dir_set_cb(GtkFileChooserButton *dest_chooser, signal_user_data_t *ud)
1172 {
1173         gchar *dest_file, *dest_dir, *dest;
1174
1175         g_debug("dest_dir_set_cb ()");
1176         ghb_widget_to_setting(ud->settings, (GtkWidget*)dest_chooser);
1177         dest_file = ghb_settings_get_string(ud->settings, "dest_file");
1178         dest_dir = ghb_settings_get_string(ud->settings, "dest_dir");
1179         dest = g_strdup_printf("%s" G_DIR_SEPARATOR_S "%s", dest_dir, dest_file);
1180         ghb_settings_set_string(ud->settings, "destination", dest);
1181         g_free(dest_file);
1182         g_free(dest_dir);
1183         g_free(dest);
1184         update_default_destination = TRUE;
1185 }
1186
1187 G_MODULE_EXPORT void
1188 dest_file_changed_cb(GtkEntry *entry, signal_user_data_t *ud)
1189 {
1190         gchar *dest_file, *dest_dir, *dest;
1191
1192         g_debug("dest_file_changed_cb ()");
1193         ghb_update_destination_extension(ud);
1194         ghb_widget_to_setting(ud->settings, (GtkWidget*)entry);
1195         // This signal goes off with ever keystroke, so I'm putting this
1196         // update on the timer.
1197         dest_file = ghb_settings_get_string(ud->settings, "dest_file");
1198         dest_dir = ghb_settings_get_string(ud->settings, "dest_dir");
1199         dest = g_strdup_printf("%s" G_DIR_SEPARATOR_S "%s", dest_dir, dest_file);
1200         ghb_settings_set_string(ud->settings, "destination", dest);
1201         g_free(dest_file);
1202         g_free(dest_dir);
1203         g_free(dest);
1204         update_default_destination = TRUE;
1205 }
1206
1207 G_MODULE_EXPORT void
1208 destination_browse_clicked_cb(GtkButton *button, signal_user_data_t *ud)
1209 {
1210         GtkWidget *dialog;
1211         GtkEntry *entry;
1212         gchar *destname;
1213         gchar *basename;
1214
1215         g_debug("destination_browse_clicked_cb ()");
1216         destname = ghb_settings_get_string(ud->settings, "destination");
1217         dialog = gtk_file_chooser_dialog_new ("Choose Destination",
1218                                           NULL,
1219                                           GTK_FILE_CHOOSER_ACTION_SAVE,
1220                                           GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
1221                                           GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
1222                                           NULL);
1223         gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(dialog), destname);
1224         basename = g_path_get_basename(destname);
1225         g_free(destname);
1226         gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog), basename);
1227         g_free(basename);
1228         if (gtk_dialog_run(GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT)
1229         {
1230                 char *filename, *dirname;
1231                 GtkFileChooser *dest_chooser;
1232
1233                 filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
1234                 basename = g_path_get_basename(filename);
1235                 dirname = g_path_get_dirname(filename);
1236                 entry = (GtkEntry*)GHB_WIDGET(ud->builder, "dest_file");
1237                 gtk_entry_set_text(entry, basename);
1238                 dest_chooser = GTK_FILE_CHOOSER(GHB_WIDGET(ud->builder, "dest_dir"));
1239                 gtk_file_chooser_set_filename(dest_chooser, dirname);
1240                 g_free (dirname);
1241                 g_free (basename);
1242                 g_free (filename);
1243         }
1244         gtk_widget_destroy(dialog);
1245 }
1246
1247 G_MODULE_EXPORT gboolean
1248 window_destroy_event_cb(GtkWidget *widget, GdkEvent *event, signal_user_data_t *ud)
1249 {
1250         g_debug("window_destroy_event_cb ()");
1251         ghb_hb_cleanup(FALSE);
1252         prune_logs(ud);
1253         gtk_main_quit();
1254         return FALSE;
1255 }
1256
1257 G_MODULE_EXPORT gboolean
1258 window_delete_event_cb(GtkWidget *widget, GdkEvent *event, signal_user_data_t *ud)
1259 {
1260         gint state = ghb_get_queue_state();
1261         g_debug("window_delete_event_cb ()");
1262         if (state & GHB_STATE_WORKING)
1263         {
1264                 if (ghb_cancel_encode2(ud, "Closing HandBrake will terminate encoding.\n"))
1265                 {
1266                         ghb_hb_cleanup(FALSE);
1267                         prune_logs(ud);
1268                         gtk_main_quit();
1269                         return FALSE;
1270                 }
1271                 return TRUE;
1272         }
1273         ghb_hb_cleanup(FALSE);
1274         prune_logs(ud);
1275         gtk_main_quit();
1276         return FALSE;
1277 }
1278
1279 static void
1280 update_acodec_combo(signal_user_data_t *ud)
1281 {
1282         ghb_grey_combo_options (ud->builder);
1283 }
1284
1285 G_MODULE_EXPORT void
1286 container_changed_cb(GtkWidget *widget, signal_user_data_t *ud)
1287 {
1288         g_debug("container_changed_cb ()");
1289         ghb_widget_to_setting(ud->settings, widget);
1290         ghb_check_dependency(ud, widget, NULL);
1291         update_acodec_combo(ud);
1292         ghb_update_destination_extension(ud);
1293         ghb_clear_presets_selection(ud);
1294         ghb_live_reset(ud);
1295         ghb_subtitle_prune(ud);
1296         ghb_audio_list_refresh_selected(ud);
1297 }
1298
1299 static gchar*
1300 get_aspect_string(gint aspect_n, gint aspect_d)
1301 {
1302         gchar *aspect;
1303
1304         if (aspect_d < 10)
1305         {
1306                 aspect = g_strdup_printf("%d:%d", aspect_n, aspect_d);
1307         }
1308         else
1309         {
1310                 gdouble aspect_nf = (gdouble)aspect_n / aspect_d;
1311                 aspect = g_strdup_printf("%.2f:1", aspect_nf);
1312         }
1313         return aspect;
1314 }
1315
1316 static gchar*
1317 get_rate_string(gint rate_base, gint rate)
1318 {
1319         gdouble rate_f = (gdouble)rate / rate_base;
1320         gchar *rate_s;
1321
1322         rate_s = g_strdup_printf("%.6g", rate_f);
1323         return rate_s;
1324 }
1325
1326 static void
1327 update_title_duration(signal_user_data_t *ud)
1328 {
1329         gint ti;
1330         gint hh, mm, ss, start, end;
1331         gchar *text;
1332         GtkWidget *widget;
1333
1334         ti = ghb_settings_combo_int(ud->settings, "title");
1335         widget = GHB_WIDGET (ud->builder, "title_duration");
1336
1337         start = ghb_settings_get_int(ud->settings, "start_chapter");
1338         end = ghb_settings_get_int(ud->settings, "end_chapter");
1339         ghb_part_duration(ti, start, end, &hh, &mm, &ss);
1340         text = g_strdup_printf("%02d:%02d:%02d", hh, mm, ss);
1341         gtk_label_set_text (GTK_LABEL(widget), text);
1342         g_free(text);
1343 }
1344
1345 static void
1346 show_title_info(signal_user_data_t *ud, ghb_title_info_t *tinfo)
1347 {
1348         GtkWidget *widget;
1349         gchar *text;
1350
1351         ghb_settings_set_string(ud->settings, "source", tinfo->path);
1352         if (tinfo->type == HB_STREAM_TYPE)
1353         {
1354                 GtkWidget *widget = GHB_WIDGET (ud->builder, "source_title");
1355                 if (tinfo->name != NULL && tinfo->name[0] != 0)
1356                 {
1357                         gtk_label_set_text (GTK_LABEL(widget), tinfo->name);
1358                         ghb_settings_set_string(ud->settings, "volume_label", tinfo->name);
1359                         set_destination(ud);
1360                 }
1361                 else
1362                 {
1363                         gchar *label = "No Title Found";
1364                         gtk_label_set_text (GTK_LABEL(widget), label);
1365                         ghb_settings_set_string(ud->settings, "volume_label", label);
1366                 }
1367         }
1368         ud->dont_clear_presets = TRUE;
1369         update_title_duration(ud);
1370         widget = GHB_WIDGET (ud->builder, "source_dimensions");
1371         text = g_strdup_printf ("%d x %d", tinfo->width, tinfo->height);
1372         gtk_label_set_text (GTK_LABEL(widget), text);
1373         ghb_settings_set_int(ud->settings, "source_width", tinfo->width);
1374         ghb_settings_set_int(ud->settings, "source_height", tinfo->height);
1375         g_free(text);
1376         widget = GHB_WIDGET (ud->builder, "source_aspect");
1377         text = get_aspect_string(tinfo->aspect_n, tinfo->aspect_d);
1378         gtk_label_set_text (GTK_LABEL(widget), text);
1379         g_free(text);
1380
1381         widget = GHB_WIDGET (ud->builder, "source_frame_rate");
1382         text = (gchar*)get_rate_string(tinfo->rate_base, tinfo->rate);
1383         gtk_label_set_text (GTK_LABEL(widget), text);
1384         g_free(text);
1385
1386         ghb_ui_update(ud, "scale_width",
1387                 ghb_int64_value(tinfo->width - tinfo->crop[2] - tinfo->crop[3]));
1388         // If anamorphic or keep_aspect, the hight will be automatically calculated
1389         gboolean keep_aspect;
1390         gint pic_par;
1391         keep_aspect = ghb_settings_get_boolean(ud->settings, "PictureKeepRatio");
1392         pic_par = ghb_settings_combo_int(ud->settings, "PicturePAR");
1393         if (!(keep_aspect || pic_par) || pic_par == 3)
1394         {
1395                 ghb_ui_update(ud, "scale_height",
1396                         ghb_int64_value(tinfo->height - tinfo->crop[0] - tinfo->crop[1]));
1397         }
1398
1399         // Set the limits of cropping.  hb_set_anamorphic_size crashes if
1400         // you pass it a cropped width or height == 0.
1401         gint bound;
1402         bound = tinfo->height / 2 - 8;
1403         widget = GHB_WIDGET (ud->builder, "PictureTopCrop");
1404         gtk_spin_button_set_range (GTK_SPIN_BUTTON(widget), 0, bound);
1405         widget = GHB_WIDGET (ud->builder, "PictureBottomCrop");
1406         gtk_spin_button_set_range (GTK_SPIN_BUTTON(widget), 0, bound);
1407         bound = tinfo->width / 2 - 8;
1408         widget = GHB_WIDGET (ud->builder, "PictureLeftCrop");
1409         gtk_spin_button_set_range (GTK_SPIN_BUTTON(widget), 0, bound);
1410         widget = GHB_WIDGET (ud->builder, "PictureRightCrop");
1411         gtk_spin_button_set_range (GTK_SPIN_BUTTON(widget), 0, bound);
1412         if (ghb_settings_get_boolean(ud->settings, "PictureAutoCrop"))
1413         {
1414                 ghb_ui_update(ud, "PictureTopCrop", ghb_int64_value(tinfo->crop[0]));
1415                 ghb_ui_update(ud, "PictureBottomCrop", ghb_int64_value(tinfo->crop[1]));
1416                 ghb_ui_update(ud, "PictureLeftCrop", ghb_int64_value(tinfo->crop[2]));
1417                 ghb_ui_update(ud, "PictureRightCrop", ghb_int64_value(tinfo->crop[3]));
1418         }
1419         ghb_set_scale (ud, GHB_PIC_KEEP_PAR);
1420         gint width, height, crop[4];
1421         crop[0] = ghb_settings_get_int(ud->settings, "PictureTopCrop");
1422         crop[1] = ghb_settings_get_int(ud->settings, "PictureBottomCrop");
1423         crop[2] = ghb_settings_get_int(ud->settings, "PictureLeftCrop");
1424         crop[3] = ghb_settings_get_int(ud->settings, "PictureRightCrop");
1425         width = tinfo->width - crop[2] - crop[3];
1426         height = tinfo->height - crop[0] - crop[1];
1427         widget = GHB_WIDGET (ud->builder, "crop_dimensions");
1428         text = g_strdup_printf ("%d x %d", width, height);
1429         gtk_label_set_text (GTK_LABEL(widget), text);
1430         g_free(text);
1431
1432         g_debug("setting max end chapter %d", tinfo->num_chapters);
1433         widget = GHB_WIDGET (ud->builder, "end_chapter");
1434         gtk_spin_button_set_range (GTK_SPIN_BUTTON(widget), 1, tinfo->num_chapters);
1435         gtk_spin_button_set_value (GTK_SPIN_BUTTON(widget), tinfo->num_chapters);
1436         widget = GHB_WIDGET (ud->builder, "start_chapter");
1437         gtk_spin_button_set_value (GTK_SPIN_BUTTON(widget), 1);
1438         gtk_spin_button_set_range (GTK_SPIN_BUTTON(widget), 1, tinfo->num_chapters);
1439
1440         widget = GHB_WIDGET (ud->builder, "angle");
1441         gtk_spin_button_set_value (GTK_SPIN_BUTTON(widget), 1);
1442         gtk_spin_button_set_range (GTK_SPIN_BUTTON(widget), 1, tinfo->angle_count);
1443         ud->dont_clear_presets = FALSE;
1444 }
1445
1446 static gboolean update_preview = FALSE;
1447
1448 G_MODULE_EXPORT void
1449 title_changed_cb(GtkWidget *widget, signal_user_data_t *ud)
1450 {
1451         ghb_title_info_t tinfo;
1452         gint titleindex;
1453
1454         g_debug("title_changed_cb ()");
1455         ghb_widget_to_setting(ud->settings, widget);
1456         ghb_check_dependency(ud, widget, NULL);
1457
1458         titleindex = ghb_settings_combo_int(ud->settings, "title");
1459         ghb_update_ui_combo_box (ud, "AudioTrack", titleindex, FALSE);
1460         ghb_update_ui_combo_box (ud, "SubtitleTrack", titleindex, FALSE);
1461
1462         if (ghb_get_title_info (&tinfo, titleindex))
1463         {
1464                 show_title_info(ud, &tinfo);
1465         }
1466         update_chapter_list (ud);
1467         ghb_adjust_audio_rate_combos(ud);
1468         ghb_set_pref_audio(titleindex, ud);
1469         ghb_set_pref_subtitle(titleindex, ud);
1470         if (ghb_settings_get_boolean(ud->settings, "vquality_type_target"))
1471         {
1472                 gint bitrate = ghb_calculate_target_bitrate (ud->settings, titleindex);
1473                 ghb_ui_update(ud, "VideoAvgBitrate", ghb_int64_value(bitrate));
1474         }
1475
1476         // Unfortunately, there is no way to query how many frames were
1477         // actually generated during the scan.
1478         // If I knew how many were generated, I would adjust the spin
1479         // control range here.
1480         // I do know how many were asked for.
1481         gint preview_count;
1482         preview_count = ghb_settings_get_int(ud->settings, "preview_count");
1483         widget = GHB_WIDGET(ud->builder, "preview_frame");
1484         gtk_range_set_range (GTK_RANGE(widget), 1, preview_count);
1485         ghb_ui_update(ud, "preview_frame", ghb_int64_value(2));
1486
1487         ghb_set_preview_image (ud);
1488         if (ghb_settings_get_boolean(ud->settings, "title_no_in_destination"))
1489         {
1490                 set_destination(ud);
1491         }
1492         ghb_preview_set_visible(ud);
1493 }
1494
1495 G_MODULE_EXPORT void
1496 setting_widget_changed_cb(GtkWidget *widget, signal_user_data_t *ud)
1497 {
1498         ghb_widget_to_setting(ud->settings, widget);
1499         ghb_check_dependency(ud, widget, NULL);
1500         ghb_clear_presets_selection(ud);
1501         ghb_live_reset(ud);
1502 }
1503
1504 G_MODULE_EXPORT void
1505 chapter_markers_changed_cb(GtkWidget *widget, signal_user_data_t *ud)
1506 {
1507         ghb_widget_to_setting(ud->settings, widget);
1508         ghb_check_dependency(ud, widget, NULL);
1509         ghb_clear_presets_selection(ud);
1510         ghb_live_reset(ud);
1511         ghb_update_destination_extension(ud);
1512 }
1513
1514 G_MODULE_EXPORT void
1515 vquality_changed_cb(GtkWidget *widget, signal_user_data_t *ud)
1516 {
1517         ghb_widget_to_setting(ud->settings, widget);
1518         ghb_check_dependency(ud, widget, NULL);
1519         ghb_clear_presets_selection(ud);
1520         ghb_live_reset(ud);
1521
1522         gint vcodec = ghb_settings_combo_int(ud->settings, "VideoEncoder");
1523         gdouble step;
1524         if (vcodec == HB_VCODEC_X264)
1525         {
1526                 step = ghb_settings_combo_double(ud->settings,
1527                                                                                         "VideoQualityGranularity");
1528         }
1529         else
1530         {
1531                 step = 1;
1532         }
1533         gdouble val = gtk_range_get_value(GTK_RANGE(widget));
1534         val = ((int)((val + step / 2) / step)) * step;
1535         gtk_range_set_value(GTK_RANGE(widget), val);
1536 }
1537
1538 G_MODULE_EXPORT void
1539 http_opt_changed_cb(GtkWidget *widget, signal_user_data_t *ud)
1540 {
1541         ghb_widget_to_setting(ud->settings, widget);
1542         ghb_check_dependency(ud, widget, NULL);
1543         ghb_clear_presets_selection(ud);
1544         ghb_live_reset(ud);
1545         // AC3 is not allowed when Web optimized
1546         ghb_grey_combo_options (ud->builder);
1547 }
1548
1549 G_MODULE_EXPORT void
1550 vcodec_changed_cb(GtkWidget *widget, signal_user_data_t *ud)
1551 {
1552         gdouble vqmin, vqmax, step, page;
1553         gboolean inverted;
1554         gint digits;
1555
1556         ghb_widget_to_setting(ud->settings, widget);
1557         ghb_check_dependency(ud, widget, NULL);
1558         ghb_clear_presets_selection(ud);
1559         ghb_live_reset(ud);
1560         ghb_vquality_range(ud, &vqmin, &vqmax, &step, &page, &digits, &inverted);
1561         GtkWidget *qp = GHB_WIDGET(ud->builder, "VideoQualitySlider");
1562         gtk_range_set_range (GTK_RANGE(qp), vqmin, vqmax);
1563         gtk_range_set_increments (GTK_RANGE(qp), step, page);
1564         gtk_scale_set_digits(GTK_SCALE(qp), digits);
1565         gtk_range_set_inverted (GTK_RANGE(qp), inverted);
1566 }
1567
1568 G_MODULE_EXPORT void
1569 target_size_changed_cb(GtkWidget *widget, signal_user_data_t *ud)
1570 {
1571         const gchar *name = gtk_widget_get_name(widget);
1572         g_debug("target_size_changed_cb () %s", name);
1573         ghb_widget_to_setting(ud->settings, widget);
1574         ghb_check_dependency(ud, widget, NULL);
1575         ghb_clear_presets_selection(ud);
1576         ghb_live_reset(ud);
1577         if (ghb_settings_get_boolean(ud->settings, "vquality_type_target"))
1578         {
1579                 gint titleindex;
1580                 titleindex = ghb_settings_combo_int(ud->settings, "title");
1581                 gint bitrate = ghb_calculate_target_bitrate (ud->settings, titleindex);
1582                 ghb_ui_update(ud, "VideoAvgBitrate", ghb_int64_value(bitrate));
1583         }
1584 }
1585
1586 G_MODULE_EXPORT void
1587 start_chapter_changed_cb(GtkWidget *widget, signal_user_data_t *ud)
1588 {
1589         gint start, end;
1590         const gchar *name = gtk_widget_get_name(widget);
1591
1592         g_debug("start_chapter_changed_cb () %s", name);
1593         ghb_widget_to_setting(ud->settings, widget);
1594         start = ghb_settings_get_int(ud->settings, "start_chapter");
1595         end = ghb_settings_get_int(ud->settings, "end_chapter");
1596         if (start > end)
1597                 ghb_ui_update(ud, "end_chapter", ghb_int_value(start));
1598         ghb_check_dependency(ud, widget, NULL);
1599         if (ghb_settings_get_boolean(ud->settings, "chapters_in_destination"))
1600         {
1601                 set_destination(ud);
1602         }
1603         widget = GHB_WIDGET (ud->builder, "chapters_tab");
1604         // End may have been changed above, get it again
1605         end = ghb_settings_get_int(ud->settings, "end_chapter");
1606         if (start == end)
1607         {
1608                 gtk_widget_hide(widget);
1609         }
1610         else
1611         {
1612                 gtk_widget_show(widget);
1613         }
1614         update_title_duration(ud);
1615 }
1616
1617 G_MODULE_EXPORT void
1618 end_chapter_changed_cb(GtkWidget *widget, signal_user_data_t *ud)
1619 {
1620         gint start, end;
1621         const gchar *name = gtk_widget_get_name(widget);
1622
1623         g_debug("end_chapter_changed_cb () %s", name);
1624         ghb_widget_to_setting(ud->settings, widget);
1625         start = ghb_settings_get_int(ud->settings, "start_chapter");
1626         end = ghb_settings_get_int(ud->settings, "end_chapter");
1627         if (start > end)
1628                 ghb_ui_update(ud, "start_chapter", ghb_int_value(end));
1629         ghb_check_dependency(ud, widget, NULL);
1630         if (ghb_settings_get_boolean(ud->settings, "chapters_in_destination"))
1631         {
1632                 set_destination(ud);
1633         }
1634         widget = GHB_WIDGET (ud->builder, "chapters_tab");
1635         // Start may have been changed above, get it again
1636         start = ghb_settings_get_int(ud->settings, "start_chapter");
1637         if (start == end)
1638         {
1639                 gtk_widget_hide(widget);
1640         }
1641         else
1642         {
1643                 gtk_widget_show(widget);
1644         }
1645         update_title_duration(ud);
1646 }
1647
1648 G_MODULE_EXPORT void
1649 scale_width_changed_cb(GtkWidget *widget, signal_user_data_t *ud)
1650 {
1651         g_debug("scale_width_changed_cb ()");
1652         ghb_widget_to_setting(ud->settings, widget);
1653         ghb_check_dependency(ud, widget, NULL);
1654         ghb_clear_presets_selection(ud);
1655         if (GTK_WIDGET_SENSITIVE(widget))
1656                 ghb_set_scale (ud, GHB_PIC_KEEP_WIDTH);
1657         update_preview = TRUE;
1658         gchar *text;
1659         gint width = ghb_settings_get_int(ud->settings, "scale_width");
1660         gint height = ghb_settings_get_int(ud->settings, "scale_height");
1661         widget = GHB_WIDGET (ud->builder, "scale_dimensions");
1662         text = g_strdup_printf ("%d x %d", width, height);
1663         gtk_label_set_text (GTK_LABEL(widget), text);
1664         g_free(text);
1665         ghb_live_reset(ud);
1666 }
1667
1668 G_MODULE_EXPORT void
1669 scale_height_changed_cb(GtkWidget *widget, signal_user_data_t *ud)
1670 {
1671         g_debug("scale_height_changed_cb ()");
1672         ghb_widget_to_setting(ud->settings, widget);
1673         ghb_check_dependency(ud, widget, NULL);
1674         ghb_clear_presets_selection(ud);
1675         if (GTK_WIDGET_SENSITIVE(widget))
1676                 ghb_set_scale (ud, GHB_PIC_KEEP_HEIGHT);
1677         update_preview = TRUE;
1678         gchar *text;
1679         gint width = ghb_settings_get_int(ud->settings, "scale_width");
1680         gint height = ghb_settings_get_int(ud->settings, "scale_height");
1681         widget = GHB_WIDGET (ud->builder, "scale_dimensions");
1682         text = g_strdup_printf ("%d x %d", width, height);
1683         gtk_label_set_text (GTK_LABEL(widget), text);
1684         g_free(text);
1685         ghb_live_reset(ud);
1686 }
1687
1688 G_MODULE_EXPORT void
1689 crop_changed_cb(GtkWidget *widget, signal_user_data_t *ud)
1690 {
1691         gint titleindex, crop[4];
1692         ghb_title_info_t tinfo;
1693
1694         g_debug("crop_changed_cb ()");
1695         ghb_widget_to_setting(ud->settings, widget);
1696         ghb_check_dependency(ud, widget, NULL);
1697         ghb_clear_presets_selection(ud);
1698         if (GTK_WIDGET_SENSITIVE(widget))
1699                 ghb_set_scale (ud, 0);
1700
1701         crop[0] = ghb_settings_get_int(ud->settings, "PictureTopCrop");
1702         crop[1] = ghb_settings_get_int(ud->settings, "PictureBottomCrop");
1703         crop[2] = ghb_settings_get_int(ud->settings, "PictureLeftCrop");
1704         crop[3] = ghb_settings_get_int(ud->settings, "PictureRightCrop");
1705         titleindex = ghb_settings_combo_int(ud->settings, "title");
1706         if (ghb_get_title_info (&tinfo, titleindex))
1707         {
1708                 gint width, height;
1709                 gchar *text;
1710
1711                 width = tinfo.width - crop[2] - crop[3];
1712                 height = tinfo.height - crop[0] - crop[1];
1713                 widget = GHB_WIDGET (ud->builder, "crop_dimensions");
1714                 text = g_strdup_printf ("%d x %d", width, height);
1715                 gtk_label_set_text (GTK_LABEL(widget), text);
1716                 widget = GHB_WIDGET (ud->builder, "crop_dimensions2");
1717                 gtk_label_set_text (GTK_LABEL(widget), text);
1718                 g_free(text);
1719         }
1720         gchar *text;
1721         widget = GHB_WIDGET (ud->builder, "crop_values");
1722         text = g_strdup_printf ("%d:%d:%d:%d", crop[0], crop[1], crop[2], crop[3]);
1723         gtk_label_set_text (GTK_LABEL(widget), text);
1724         g_free(text);
1725         update_preview = TRUE;
1726         ghb_live_reset(ud);
1727 }
1728
1729 G_MODULE_EXPORT void
1730 display_width_changed_cb(GtkWidget *widget, signal_user_data_t *ud)
1731 {
1732         g_debug("display_width_changed_cb ()");
1733         ghb_widget_to_setting(ud->settings, widget);
1734         ghb_check_dependency(ud, widget, NULL);
1735         ghb_clear_presets_selection(ud);
1736         ghb_live_reset(ud);
1737         if (GTK_WIDGET_SENSITIVE(widget))
1738                 ghb_set_scale (ud, GHB_PIC_KEEP_DISPLAY_WIDTH);
1739
1740         update_preview = TRUE;
1741 }
1742
1743 G_MODULE_EXPORT void
1744 display_height_changed_cb(GtkWidget *widget, signal_user_data_t *ud)
1745 {
1746         g_debug("display_height_changed_cb ()");
1747         ghb_widget_to_setting(ud->settings, widget);
1748         ghb_check_dependency(ud, widget, NULL);
1749         ghb_clear_presets_selection(ud);
1750         ghb_live_reset(ud);
1751         if (GTK_WIDGET_SENSITIVE(widget))
1752                 ghb_set_scale (ud, GHB_PIC_KEEP_DISPLAY_HEIGHT);
1753
1754         update_preview = TRUE;
1755 }
1756
1757 G_MODULE_EXPORT void
1758 par_changed_cb(GtkWidget *widget, signal_user_data_t *ud)
1759 {
1760         g_debug("par_changed_cb ()");
1761         ghb_widget_to_setting(ud->settings, widget);
1762         ghb_check_dependency(ud, widget, NULL);
1763         ghb_clear_presets_selection(ud);
1764         ghb_live_reset(ud);
1765         if (GTK_WIDGET_SENSITIVE(widget))
1766                 ghb_set_scale (ud, GHB_PIC_KEEP_PAR);
1767
1768         update_preview = TRUE;
1769 }
1770
1771 G_MODULE_EXPORT void
1772 scale_changed_cb(GtkWidget *widget, signal_user_data_t *ud)
1773 {
1774         g_debug("scale_changed_cb ()");
1775         ghb_widget_to_setting(ud->settings, widget);
1776         ghb_check_dependency(ud, widget, NULL);
1777         ghb_clear_presets_selection(ud);
1778         ghb_live_reset(ud);
1779         if (GTK_WIDGET_SENSITIVE(widget))
1780                 ghb_set_scale (ud, 0);
1781         update_preview = TRUE;
1782
1783         gchar *text;
1784
1785         text = ghb_settings_get_boolean(ud->settings, "PictureAutoCrop") ? "On" : "Off";
1786         widget = GHB_WIDGET (ud->builder, "crop_auto");
1787         gtk_label_set_text (GTK_LABEL(widget), text);
1788         text = ghb_settings_get_boolean(ud->settings, "autoscale") ? "On" : "Off";
1789         widget = GHB_WIDGET (ud->builder, "scale_auto");
1790         gtk_label_set_text (GTK_LABEL(widget), text);
1791         switch (ghb_settings_combo_int(ud->settings, "PicturePAR"))
1792         {
1793                 case 0:
1794                         text = "Off";
1795                         break;
1796                 case 1:
1797                         text = "Strict";
1798                         break;
1799                 case 2:
1800                         text = "Loose";
1801                         break;
1802                 case 3:
1803                         text = "Custom";
1804                         break;
1805                 default:
1806                         text = "Unknown";
1807                         break;
1808         }
1809         widget = GHB_WIDGET (ud->builder, "scale_anamorphic");
1810         gtk_label_set_text (GTK_LABEL(widget), text);
1811 }
1812
1813 G_MODULE_EXPORT void
1814 show_crop_changed_cb(GtkWidget *widget, signal_user_data_t *ud)
1815 {
1816         g_debug("show_crop_changed_cb ()");
1817         ghb_widget_to_setting(ud->settings, widget);
1818         ghb_check_dependency(ud, widget, NULL);
1819         ghb_live_reset(ud);
1820         if (GTK_WIDGET_SENSITIVE(widget))
1821                 ghb_set_scale (ud, 0);
1822         update_preview = TRUE;
1823 }
1824
1825 G_MODULE_EXPORT void
1826 generic_entry_changed_cb(GtkEntry *entry, signal_user_data_t *ud)
1827 {
1828         // Normally (due to user input) I only want to process the entry
1829         // when editing is done and the focus-out signal is sent.
1830         // But... there's always a but.
1831         // If the entry is changed by software, the focus-out signal is not sent.
1832         // The changed signal is sent ... so here we are.
1833         // I don't want to process upon every keystroke, so I prevent processing
1834         // while the widget has focus.
1835         g_debug("generic_entry_changed_cb ()");
1836         if (!GTK_WIDGET_HAS_FOCUS((GtkWidget*)entry))
1837         {
1838                 ghb_widget_to_setting(ud->settings, (GtkWidget*)entry);
1839         }
1840 }
1841
1842 G_MODULE_EXPORT void
1843 prefs_dialog_cb(GtkWidget *xwidget, signal_user_data_t *ud)
1844 {
1845         GtkWidget *dialog;
1846         GtkResponseType response;
1847
1848         g_debug("prefs_dialog_cb ()");
1849         dialog = GHB_WIDGET(ud->builder, "prefs_dialog");
1850         response = gtk_dialog_run(GTK_DIALOG(dialog));
1851         gtk_widget_hide(dialog);
1852 }
1853
1854 typedef struct
1855 {
1856         GtkMessageDialog *dlg;
1857         const gchar *msg;
1858         const gchar *action;
1859         gint timeout;
1860 } countdown_t;
1861
1862 static gboolean
1863 shutdown_cb(countdown_t *cd)
1864 {
1865         gchar *str;
1866
1867         cd->timeout--;
1868         if (cd->timeout == 0)
1869         {
1870                 ghb_shutdown_gsm();
1871                 gtk_main_quit();
1872                 return FALSE;
1873         }
1874         str = g_strdup_printf("%s\n\n%s in %d seconds ...",
1875                                                         cd->msg, cd->action, cd->timeout);
1876         gtk_message_dialog_set_markup(cd->dlg, str);
1877         g_free(str);
1878         return TRUE;
1879 }
1880
1881 static gboolean
1882 suspend_cb(countdown_t *cd)
1883 {
1884         gchar *str;
1885
1886         cd->timeout--;
1887         if (cd->timeout == 0)
1888         {
1889                 gtk_widget_destroy (GTK_WIDGET(cd->dlg));
1890                 ghb_suspend_gpm();
1891                 return FALSE;
1892         }
1893         str = g_strdup_printf("%s\n\n%s in %d seconds ...",
1894                                                         cd->msg, cd->action, cd->timeout);
1895         gtk_message_dialog_set_markup(cd->dlg, str);
1896         g_free(str);
1897         return TRUE;
1898 }
1899
1900 void
1901 ghb_countdown_dialog(
1902         GtkMessageType type,
1903         const gchar *message,
1904         const gchar *action,
1905         const gchar *cancel,
1906         GSourceFunc action_func,
1907         gint timeout)
1908 {
1909         GtkWidget *dialog;
1910         GtkResponseType response;
1911         guint timeout_id;
1912         countdown_t cd;
1913
1914         cd.msg = message;
1915         cd.action = action;
1916         cd.timeout = timeout;
1917
1918         // Toss up a warning dialog
1919         dialog = gtk_message_dialog_new(NULL, GTK_DIALOG_MODAL,
1920                                                         type, GTK_BUTTONS_NONE,
1921                                                         "%s\n\n%s in %d seconds ...",
1922                                                         message, action, timeout);
1923         gtk_dialog_add_buttons( GTK_DIALOG(dialog),
1924                                                    cancel, GTK_RESPONSE_CANCEL,
1925                                                    NULL);
1926
1927         cd.dlg = GTK_MESSAGE_DIALOG(dialog);
1928         timeout_id = g_timeout_add(1000, action_func, &cd);
1929         response = gtk_dialog_run(GTK_DIALOG(dialog));
1930         gtk_widget_destroy (dialog);
1931         if (response == GTK_RESPONSE_CANCEL)
1932         {
1933                 GMainContext *mc;
1934                 GSource *source;
1935
1936                 mc = g_main_context_default();
1937                 source = g_main_context_find_source_by_id(mc, timeout_id);
1938                 if (source != NULL)
1939                         g_source_destroy(source);
1940         }
1941 }
1942
1943 gboolean
1944 ghb_message_dialog(GtkMessageType type, const gchar *message, const gchar *no, const gchar *yes)
1945 {
1946         GtkWidget *dialog;
1947         GtkResponseType response;
1948
1949         // Toss up a warning dialog
1950         dialog = gtk_message_dialog_new(NULL, GTK_DIALOG_MODAL,
1951                                                         type, GTK_BUTTONS_NONE,
1952                                                         "%s", message);
1953         gtk_dialog_add_buttons( GTK_DIALOG(dialog),
1954                                                    no, GTK_RESPONSE_NO,
1955                                                    yes, GTK_RESPONSE_YES, NULL);
1956         response = gtk_dialog_run(GTK_DIALOG(dialog));
1957         gtk_widget_destroy (dialog);
1958         if (response == GTK_RESPONSE_NO)
1959         {
1960                 return FALSE;
1961         }
1962         return TRUE;
1963 }
1964
1965 void
1966 ghb_error_dialog(GtkMessageType type, const gchar *message, const gchar *cancel)
1967 {
1968         GtkWidget *dialog;
1969         GtkResponseType response;
1970
1971         // Toss up a warning dialog
1972         dialog = gtk_message_dialog_new(NULL, GTK_DIALOG_MODAL,
1973                                                         type, GTK_BUTTONS_NONE,
1974                                                         "%s", message);
1975         gtk_dialog_add_buttons( GTK_DIALOG(dialog),
1976                                                    cancel, GTK_RESPONSE_CANCEL, NULL);
1977         response = gtk_dialog_run(GTK_DIALOG(dialog));
1978         gtk_widget_destroy (dialog);
1979 }
1980
1981 void
1982 ghb_cancel_encode(signal_user_data_t *ud, const gchar *extra_msg)
1983 {
1984         GtkWidget *dialog;
1985         GtkResponseType response;
1986
1987         if (extra_msg == NULL) extra_msg = "";
1988         // Toss up a warning dialog
1989         dialog = gtk_message_dialog_new(NULL, GTK_DIALOG_MODAL,
1990                                 GTK_MESSAGE_WARNING, GTK_BUTTONS_NONE,
1991                                 "%sYour movie will be lost if you don't continue encoding.",
1992                                 extra_msg);
1993         gtk_dialog_add_buttons( GTK_DIALOG(dialog),
1994                                                    "Cancel Current and Stop", 1,
1995                                                    "Cancel Current, Start Next", 2,
1996                                                    "Finish Current, then Stop", 3,
1997                                                    "Continue Encoding", 4,
1998                                                    NULL);
1999         response = gtk_dialog_run(GTK_DIALOG(dialog));
2000         gtk_widget_destroy (dialog);
2001         switch (response)
2002         {
2003                 case 1:
2004                         ghb_stop_queue();
2005                         ud->cancel_encode = GHB_CANCEL_ALL;
2006                         break;
2007                 case 2:
2008                         ghb_stop_queue();
2009                         ud->cancel_encode = GHB_CANCEL_CURRENT;
2010                         break;
2011                 case 3:
2012                         ud->cancel_encode = GHB_CANCEL_FINISH;
2013                         break;
2014                 case 4:
2015                 default:
2016                         ud->cancel_encode = GHB_CANCEL_NONE;
2017                         break;
2018         }
2019 }
2020
2021 gboolean
2022 ghb_cancel_encode2(signal_user_data_t *ud, const gchar *extra_msg)
2023 {
2024         GtkWidget *dialog;
2025         GtkResponseType response;
2026
2027         if (extra_msg == NULL) extra_msg = "";
2028         // Toss up a warning dialog
2029         dialog = gtk_message_dialog_new(NULL, GTK_DIALOG_MODAL,
2030                                 GTK_MESSAGE_WARNING, GTK_BUTTONS_NONE,
2031                                 "%sYour movie will be lost if you don't continue encoding.",
2032                                 extra_msg);
2033         gtk_dialog_add_buttons( GTK_DIALOG(dialog),
2034                                                    "Cancel Current and Stop", 1,
2035                                                    "Continue Encoding", 4,
2036                                                    NULL);
2037         response = gtk_dialog_run(GTK_DIALOG(dialog));
2038         gtk_widget_destroy (dialog);
2039         switch (response)
2040         {
2041                 case 1:
2042                         ghb_stop_queue();
2043                         ud->cancel_encode = GHB_CANCEL_ALL;
2044                         return TRUE;
2045                 case 4:
2046                 default:
2047                         break;
2048         }
2049         return FALSE;
2050 }
2051
2052 static void
2053 submit_job(GValue *settings)
2054 {
2055         static gint unique_id = 1;
2056         gchar *type, *modified, *preset;
2057         const GValue *path;
2058         gboolean preset_modified;
2059
2060         g_debug("submit_job");
2061         if (settings == NULL) return;
2062         preset_modified = ghb_settings_get_boolean(settings, "preset_modified");
2063         path = ghb_settings_get_value(settings, "preset");
2064         preset = ghb_preset_path_string(path);
2065         type = ghb_preset_is_custom() ? "Custom " : "";
2066         modified = preset_modified ? "Modified " : "";
2067         ghb_log("%s%sPreset: %s", modified, type, preset);
2068         g_free(preset);
2069
2070         ghb_settings_set_int(settings, "job_unique_id", unique_id);
2071         ghb_settings_set_int(settings, "job_status", GHB_QUEUE_RUNNING);
2072         ghb_add_job (settings, unique_id);
2073         ghb_start_queue();
2074         unique_id++;
2075 }
2076
2077 static void
2078 prune_logs(signal_user_data_t *ud)
2079 {
2080         gchar *dest_dir;
2081         gint days;
2082
2083         // Only prune logs stored in the default config dir location
2084         days = ghb_settings_combo_int(ud->settings, "LogLongevity");
2085         if (days > 365)
2086                 return;
2087
2088         dest_dir = ghb_get_user_config_dir("EncodeLogs");
2089         if (g_file_test(dest_dir, G_FILE_TEST_IS_DIR))
2090         {
2091                 const gchar *file;
2092                 gint duration = days * 24 * 60 * 60;
2093
2094                 GDir *gdir = g_dir_open(dest_dir, 0, NULL);
2095                 time_t now;
2096
2097                 now = time(NULL);
2098                 file = g_dir_read_name(gdir);
2099                 while (file)
2100                 {
2101                         gchar *path;
2102                         struct stat stbuf;
2103
2104                         path = g_strdup_printf("%s/%s", dest_dir, file);
2105                         g_stat(path, &stbuf);
2106                         if (now - stbuf.st_mtime > duration)
2107                         {
2108                                 g_unlink(path);
2109                         }
2110                         g_free(path);
2111                         file = g_dir_read_name(gdir);
2112                 }
2113                 g_dir_close(gdir);
2114         }
2115         g_free(dest_dir);
2116         ghb_preview_cleanup(ud);
2117 }
2118
2119 static void
2120 queue_scan(signal_user_data_t *ud, GValue *js)
2121 {
2122         gchar *path;
2123         gint titlenum;
2124         time_t  _now;
2125         struct tm *now;
2126         gchar *log_path, *pos, *destname, *basename, *dest_dir;
2127
2128         _now = time(NULL);
2129         now = localtime(&_now);
2130         destname = ghb_settings_get_string(js, "destination");
2131         basename = g_path_get_basename(destname);
2132         if (ghb_settings_get_boolean(ud->settings, "EncodeLogLocation"))
2133         {
2134                 dest_dir = g_path_get_dirname (destname);
2135         }
2136         else
2137         {
2138                 dest_dir = ghb_get_user_config_dir("EncodeLogs");
2139         }
2140         g_free(destname);
2141         pos = g_strrstr( basename, "." );
2142         if (pos != NULL)
2143         {
2144                 *pos = 0;
2145         }
2146         log_path = g_strdup_printf("%s/%s %d-%02d-%02d %02d-%02d-%02d.log",
2147                 dest_dir,
2148                 basename,
2149                 now->tm_year + 1900, now->tm_mon + 1, now->tm_mday,
2150                 now->tm_hour, now->tm_min, now->tm_sec);
2151         g_free(basename);
2152         g_free(dest_dir);
2153         if (ud->job_activity_log)
2154                 g_io_channel_unref(ud->job_activity_log);
2155         ud->job_activity_log = g_io_channel_new_file (log_path, "w", NULL);
2156         if (ud->job_activity_log)
2157         {
2158                 gchar *ver_str;
2159
2160                 ver_str = g_strdup_printf("Handbrake Version: %s (%d)\n",
2161                                                                         hb_get_version(NULL), hb_get_build(NULL));
2162                 g_io_channel_write_chars (ud->job_activity_log, ver_str,
2163                                                                         -1, NULL, NULL);
2164                 g_free(ver_str);
2165         }
2166         g_free(log_path);
2167
2168         path = ghb_settings_get_string( js, "source");
2169         titlenum = ghb_settings_get_int(js, "titlenum");
2170         ghb_backend_queue_scan(path, titlenum);
2171         g_free(path);
2172 }
2173
2174 static gint
2175 queue_pending_count(GValue *queue)
2176 {
2177         gint nn, ii, count;
2178         GValue *js;
2179         gint status;
2180
2181         nn = 0;
2182         count = ghb_array_len(queue);
2183         for (ii = 0; ii < count; ii++)
2184         {
2185
2186                 js = ghb_array_get_nth(queue, ii);
2187                 status = ghb_settings_get_int(js, "job_status");
2188                 if (status == GHB_QUEUE_PENDING)
2189                 {
2190                         nn++;
2191                 }
2192         }
2193         return nn;
2194 }
2195
2196 void
2197 ghb_update_pending(signal_user_data_t *ud)
2198 {
2199         GtkLabel *label;
2200         gint pending;
2201         gchar *str;
2202
2203         label = GTK_LABEL(GHB_WIDGET(ud->builder, "pending_status"));
2204         pending = queue_pending_count(ud->queue);
2205         str = g_strdup_printf("%d encode(s) pending", pending);
2206         gtk_label_set_text(label, str);
2207         g_free(str);
2208 }
2209
2210 GValue*
2211 ghb_start_next_job(signal_user_data_t *ud, gboolean find_first)
2212 {
2213         static gint current = 0;
2214         gint count, ii, jj;
2215         GValue *js;
2216         gint status;
2217         GtkWidget *prog;
2218
2219         g_debug("start_next_job");
2220         prog = GHB_WIDGET(ud->builder, "progressbar");
2221         gtk_widget_show(prog);
2222
2223         count = ghb_array_len(ud->queue);
2224         if (find_first)
2225         {       // Start the first pending item in the queue
2226                 current = 0;
2227                 for (ii = 0; ii < count; ii++)
2228                 {
2229
2230                         js = ghb_array_get_nth(ud->queue, ii);
2231                         status = ghb_settings_get_int(js, "job_status");
2232                         if (status == GHB_QUEUE_PENDING)
2233                         {
2234                                 current = ii;
2235                                 ghb_inhibit_gsm(ud);
2236                                 queue_scan(ud, js);
2237                                 ghb_update_pending(ud);
2238                                 return js;
2239                         }
2240                 }
2241                 // Nothing pending
2242                 ghb_uninhibit_gsm();
2243                 ghb_notify_done(ud);
2244                 return NULL;
2245         }
2246         // Find the next pending item after the current running item
2247         for (ii = 0; ii < count-1; ii++)
2248         {
2249                 js = ghb_array_get_nth(ud->queue, ii);
2250                 status = ghb_settings_get_int(js, "job_status");
2251                 if (status == GHB_QUEUE_RUNNING)
2252                 {
2253                         for (jj = ii+1; jj < count; jj++)
2254                         {
2255                                 js = ghb_array_get_nth(ud->queue, jj);
2256                                 status = ghb_settings_get_int(js, "job_status");
2257                                 if (status == GHB_QUEUE_PENDING)
2258                                 {
2259                                         current = jj;
2260                                         ghb_inhibit_gsm(ud);
2261                                         queue_scan(ud, js);
2262                                         ghb_update_pending(ud);
2263                                         return js;
2264                                 }
2265                         }
2266                 }
2267         }
2268         // No running item found? Maybe it was deleted
2269         // Look for a pending item starting from the last index we started
2270         for (ii = current; ii < count; ii++)
2271         {
2272                 js = ghb_array_get_nth(ud->queue, ii);
2273                 status = ghb_settings_get_int(js, "job_status");
2274                 if (status == GHB_QUEUE_PENDING)
2275                 {
2276                         current = ii;
2277                         ghb_inhibit_gsm(ud);
2278                         queue_scan(ud, js);
2279                         ghb_update_pending(ud);
2280                         return js;
2281                 }
2282         }
2283         // Nothing found
2284         ghb_uninhibit_gsm();
2285         ghb_notify_done(ud);
2286         ghb_update_pending(ud);
2287         gtk_widget_hide(prog);
2288         return NULL;
2289 }
2290
2291 static gint
2292 find_queue_job(GValue *queue, gint unique_id, GValue **job)
2293 {
2294         GValue *js;
2295         gint ii, count;
2296         gint job_unique_id;
2297
2298         *job = NULL;
2299         g_debug("find_queue_job");
2300         if (unique_id == 0)  // Invalid Id
2301                 return -1;
2302
2303         count = ghb_array_len(queue);
2304         for (ii = 0; ii < count; ii++)
2305         {
2306                 js = ghb_array_get_nth(queue, ii);
2307                 job_unique_id = ghb_settings_get_int(js, "job_unique_id");
2308                 if (job_unique_id == unique_id)
2309                 {
2310                         *job = js;
2311                         return ii;
2312                 }
2313         }
2314         return -1;
2315 }
2316
2317 gchar*
2318 working_status_string(signal_user_data_t *ud, ghb_instance_status_t *status)
2319 {
2320         gchar *task_str, *job_str, *status_str;
2321         gint qcount;
2322         gint index;
2323         GValue *js;
2324         gboolean subtitle_scan = FALSE;
2325
2326         qcount = ghb_array_len(ud->queue);
2327         index = find_queue_job(ud->queue, status->unique_id, &js);
2328         if (js != NULL)
2329         {
2330                 subtitle_scan = ghb_settings_get_boolean(js, "subtitle_scan");
2331         }
2332         if (qcount > 1)
2333         {
2334                 job_str = g_strdup_printf("job %d of %d, ", index+1, qcount);
2335         }
2336         else
2337         {
2338                 job_str = g_strdup("");
2339         }
2340         if (status->job_count > 1)
2341         {
2342                 if (status->job_cur == 1 && subtitle_scan)
2343                 {
2344                         task_str = g_strdup_printf("pass %d (subtitle scan) of %d, ",
2345                                 status->job_cur, status->job_count);
2346                 }
2347                 else
2348                 {
2349                         task_str = g_strdup_printf("pass %d of %d, ",
2350                                 status->job_cur, status->job_count);
2351                 }
2352         }
2353         else
2354         {
2355                 task_str = g_strdup("");
2356         }
2357         if(status->seconds > -1)
2358         {
2359                 status_str= g_strdup_printf(
2360                         "Encoding: %s%s%.2f %%"
2361                         " (%.2f fps, avg %.2f fps, ETA %02dh%02dm%02ds)",
2362                         job_str, task_str,
2363                         100.0 * status->progress,
2364                         status->rate_cur, status->rate_avg, status->hours,
2365                         status->minutes, status->seconds );
2366         }
2367         else
2368         {
2369                 status_str= g_strdup_printf(
2370                         "Encoding: %s%s%.2f %%",
2371                         job_str, task_str,
2372                         100.0 * status->progress );
2373         }
2374         g_free(task_str);
2375         g_free(job_str);
2376         return status_str;
2377 }
2378
2379 static void
2380 ghb_backend_events(signal_user_data_t *ud)
2381 {
2382         ghb_status_t status;
2383         gchar *status_str;
2384         GtkProgressBar *progress;
2385         GtkLabel       *work_status;
2386         gint titleindex;
2387         GValue *js;
2388         gint index;
2389         GtkTreeView *treeview;
2390         GtkTreeStore *store;
2391         GtkTreeIter iter;
2392         static gint prev_scan_state = 0;
2393         static gint prev_queue_state = 0;
2394
2395         ghb_track_status();
2396         ghb_get_status(&status);
2397         if (prev_scan_state != status.scan.state ||
2398                 prev_queue_state != status.queue.state)
2399         {
2400                 ghb_queue_buttons_grey(ud);
2401                 prev_scan_state = status.scan.state;
2402                 prev_queue_state = status.queue.state;
2403         }
2404         progress = GTK_PROGRESS_BAR(GHB_WIDGET (ud->builder, "progressbar"));
2405         work_status = GTK_LABEL(GHB_WIDGET (ud->builder, "work_status"));
2406         if (status.scan.state == GHB_STATE_IDLE &&
2407                 status.queue.state == GHB_STATE_IDLE)
2408         {
2409                 static gboolean prev_dvdnav;
2410                 gboolean dvdnav = ghb_settings_get_boolean(ud->settings, "use_dvdnav");
2411                 if (dvdnav != prev_dvdnav)
2412                 {
2413                         hb_dvd_set_dvdnav(dvdnav);
2414                         prev_dvdnav = dvdnav;
2415                 }
2416         }
2417         // First handle the status of title scans
2418         // Then handle the status of the queue
2419         if (status.scan.state & GHB_STATE_SCANNING)
2420         {
2421                 GtkProgressBar *scan_prog;
2422                 GtkLabel *label;
2423
2424                 scan_prog = GTK_PROGRESS_BAR(GHB_WIDGET (ud->builder, "scan_prog"));
2425                 label = GTK_LABEL(GHB_WIDGET (ud->builder, "source_title"));
2426
2427                 if (status.scan.title_cur == 0)
2428                 {
2429                         status_str = g_strdup ("Scanning...");
2430                 }
2431                 else
2432                 {
2433                         status_str = g_strdup_printf ("Scanning title %d of %d...",
2434                                                           status.scan.title_cur, status.scan.title_count );
2435                 }
2436                 gtk_label_set_text (label, status_str);
2437                 g_free(status_str);
2438                 if (status.scan.title_count > 0)
2439                 {
2440                         gtk_progress_bar_set_fraction (scan_prog,
2441                                 (gdouble)status.scan.title_cur / status.scan.title_count);
2442                 }
2443         }
2444         else if (status.scan.state & GHB_STATE_SCANDONE)
2445         {
2446                 gchar *source;
2447                 GtkProgressBar *scan_prog;
2448                 GtkLabel *label;
2449
2450                 GtkWidget *widget;
2451                 GtkAction *action;
2452
2453                 widget = GHB_WIDGET(ud->builder, "sourcetoolbutton");
2454                 gtk_tool_button_set_icon_name(GTK_TOOL_BUTTON(widget), "hb-source");
2455                 gtk_tool_button_set_label(GTK_TOOL_BUTTON(widget), "Source");
2456                 gtk_tool_item_set_tooltip_text(GTK_TOOL_ITEM(widget), "Choose Video Source");
2457
2458                 action = GHB_ACTION(ud->builder, "source_action");
2459                 gtk_action_set_sensitive(action, TRUE);
2460                 action = GHB_ACTION(ud->builder, "source_single_action");
2461                 gtk_action_set_sensitive(action, TRUE);
2462
2463                 source = ghb_settings_get_string(ud->settings, "scan_source");
2464                 update_source_label(ud, source, FALSE);
2465
2466                 scan_prog = GTK_PROGRESS_BAR(GHB_WIDGET (ud->builder, "scan_prog"));
2467                 gtk_progress_bar_set_fraction (scan_prog, 1.0);
2468                 gtk_widget_hide(GTK_WIDGET(scan_prog));
2469
2470                 ghb_title_info_t tinfo;
2471
2472                 ghb_update_ui_combo_box(ud, "title", 0, FALSE);
2473                 titleindex = ghb_longest_title();
2474                 ghb_ui_update(ud, "title", ghb_int64_value(titleindex));
2475
2476                 label = GTK_LABEL(GHB_WIDGET (ud->builder, "source_title"));
2477                 // Are there really any titles.
2478                 if (!ghb_get_title_info(&tinfo, titleindex))
2479                 {
2480                         gtk_label_set_text(label, "None");
2481                 }
2482                 ghb_clear_scan_state(GHB_STATE_SCANDONE);
2483                 if (ghb_queue_edit_settings)
2484                 {
2485                         ghb_settings_to_ui(ud, ghb_queue_edit_settings);
2486                         ghb_set_audio(ud, ghb_queue_edit_settings);
2487                         ghb_reset_subtitles(ud, ghb_queue_edit_settings);
2488                         reset_chapter_list(ud, ghb_queue_edit_settings);
2489                         ghb_value_free(ghb_queue_edit_settings);
2490                         ghb_queue_edit_settings = NULL;
2491                 }
2492         }
2493
2494         if (status.queue.state & GHB_STATE_SCANNING)
2495         {
2496                 // This needs to be in scanning and working since scanning
2497                 // happens fast enough that it can be missed
2498                 gtk_label_set_text (work_status, "Scanning ...");
2499                 gtk_progress_bar_set_fraction (progress, 0);
2500         }
2501         else if (status.queue.state & GHB_STATE_SCANDONE)
2502         {
2503                 ghb_clear_queue_state(GHB_STATE_SCANDONE);
2504                 usleep(2000000);
2505                 submit_job(ud->current_job);
2506                 ghb_update_pending(ud);
2507         }
2508         else if (status.queue.state & GHB_STATE_PAUSED)
2509         {
2510                 gtk_label_set_text (work_status, "Paused");
2511         }
2512         else if (status.queue.state & GHB_STATE_WORKING)
2513         {
2514                 static gint working = 0;
2515
2516                 // This needs to be in scanning and working since scanning
2517                 // happens fast enough that it can be missed
2518                 index = find_queue_job(ud->queue, status.queue.unique_id, &js);
2519                 if (status.queue.unique_id != 0 && index >= 0)
2520                 {
2521                         gchar working_icon[] = "hb-working0";
2522                         working_icon[10] = '0' + working;
2523                         working = (working+1) % 6;
2524                         treeview = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "queue_list"));
2525                         store = GTK_TREE_STORE(gtk_tree_view_get_model(treeview));
2526                         gchar *path = g_strdup_printf ("%d", index);
2527                         if (gtk_tree_model_get_iter_from_string(
2528                                         GTK_TREE_MODEL(store), &iter, path))
2529                         {
2530                                 gtk_tree_store_set(store, &iter, 0, working_icon, -1);
2531                         }
2532                         g_free(path);
2533                 }
2534                 GtkLabel *label;
2535                 gchar *status_str;
2536
2537                 status_str = working_status_string(ud, &status.queue);
2538                 label = GTK_LABEL(GHB_WIDGET(ud->builder, "queue_status"));
2539                 gtk_label_set_text (label, status_str);
2540 #if !GTK_CHECK_VERSION(2, 16, 0)
2541                 GtkStatusIcon *si;
2542
2543                 si = GTK_STATUS_ICON(GHB_OBJECT(ud->builder, "hb_status"));
2544                 gtk_status_icon_set_tooltip(si, status_str);
2545 #endif
2546                 gtk_label_set_text (work_status, status_str);
2547                 gtk_progress_bar_set_fraction (progress, status.queue.progress);
2548                 g_free(status_str);
2549         }
2550         else if (status.queue.state & GHB_STATE_WORKDONE)
2551         {
2552                 gint qstatus;
2553
2554                 index = find_queue_job(ud->queue, status.queue.unique_id, &js);
2555                 treeview = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "queue_list"));
2556                 store = GTK_TREE_STORE(gtk_tree_view_get_model(treeview));
2557                 if (ud->cancel_encode == GHB_CANCEL_ALL ||
2558                         ud->cancel_encode == GHB_CANCEL_CURRENT)
2559                         status.queue.error = GHB_ERROR_CANCELED;
2560                 switch( status.queue.error )
2561                 {
2562                         case GHB_ERROR_NONE:
2563                                 gtk_label_set_text (work_status, "Rip Done!");
2564                                 qstatus = GHB_QUEUE_DONE;
2565                                 if (js != NULL)
2566                                 {
2567                                         gchar *path = g_strdup_printf ("%d", index);
2568                                         if (gtk_tree_model_get_iter_from_string(
2569                                                         GTK_TREE_MODEL(store), &iter, path))
2570                                         {
2571                                                 gtk_tree_store_set(store, &iter, 0, "hb-complete", -1);
2572                                         }
2573                                         g_free(path);
2574                                 }
2575                                 break;
2576                         case GHB_ERROR_CANCELED:
2577                                 gtk_label_set_text (work_status, "Rip Canceled.");
2578                                 qstatus = GHB_QUEUE_CANCELED;
2579                                 if (js != NULL)
2580                                 {
2581                                         gchar *path = g_strdup_printf ("%d", index);
2582                                         if (gtk_tree_model_get_iter_from_string(
2583                                                         GTK_TREE_MODEL(store), &iter, path))
2584                                         {
2585                                                 gtk_tree_store_set(store, &iter, 0, "hb-canceled", -1);
2586                                         }
2587                                         g_free(path);
2588                                 }
2589                                 break;
2590                         default:
2591                                 gtk_label_set_text (work_status, "Rip Failed.");
2592                                 qstatus = GHB_QUEUE_CANCELED;
2593                                 if (js != NULL)
2594                                 {
2595                                         gchar *path = g_strdup_printf ("%d", index);
2596                                         if (gtk_tree_model_get_iter_from_string(
2597                                                         GTK_TREE_MODEL(store), &iter, path))
2598                                         {
2599                                                 gtk_tree_store_set(store, &iter, 0, "hb-canceled", -1);
2600                                         }
2601                                         g_free(path);
2602                                 }
2603                 }
2604                 gtk_progress_bar_set_fraction (progress, 1.0);
2605                 ghb_clear_queue_state(GHB_STATE_WORKDONE);
2606                 if (ud->job_activity_log)
2607                         g_io_channel_unref(ud->job_activity_log);
2608                 ud->job_activity_log = NULL;
2609                 if (ud->cancel_encode != GHB_CANCEL_ALL &&
2610                         ud->cancel_encode != GHB_CANCEL_FINISH)
2611                 {
2612                         ud->current_job = ghb_start_next_job(ud, FALSE);
2613                 }
2614                 else
2615                 {
2616                         ghb_uninhibit_gsm();
2617                         ud->current_job = NULL;
2618                         gtk_widget_hide(GTK_WIDGET(progress));
2619                 }
2620                 if (js)
2621                         ghb_settings_set_int(js, "job_status", qstatus);
2622                 ghb_save_queue(ud->queue);
2623                 ud->cancel_encode = GHB_CANCEL_NONE;
2624 #if !GTK_CHECK_VERSION(2, 16, 0)
2625                 GtkStatusIcon *si;
2626
2627                 si = GTK_STATUS_ICON(GHB_OBJECT(ud->builder, "hb_status"));
2628                 gtk_status_icon_set_tooltip(si, "HandBrake");
2629 #endif
2630         }
2631         else if (status.queue.state & GHB_STATE_MUXING)
2632         {
2633                 gtk_label_set_text (work_status, "Muxing: This may take a while...");
2634         }
2635
2636         if (status.scan.state & GHB_STATE_WORKING)
2637         {
2638                 GtkProgressBar *live_progress;
2639                 live_progress = GTK_PROGRESS_BAR(
2640                         GHB_WIDGET(ud->builder, "live_encode_progress"));
2641                 status_str = working_status_string(ud, &status.scan);
2642                 gtk_progress_bar_set_text (live_progress, status_str);
2643                 gtk_progress_bar_set_fraction (live_progress, status.scan.progress);
2644                 g_free(status_str);
2645         }
2646         if (status.scan.state & GHB_STATE_WORKDONE)
2647         {
2648                 switch( status.scan.error )
2649                 {
2650                         case GHB_ERROR_NONE:
2651                         {
2652                                 ghb_live_encode_done(ud, TRUE);
2653                         } break;
2654                         default:
2655                         {
2656                                 ghb_live_encode_done(ud, FALSE);
2657                         } break;
2658                 }
2659                 ghb_clear_scan_state(GHB_STATE_WORKDONE);
2660         }
2661 }
2662
2663 #if GTK_CHECK_VERSION(2, 16, 0)
2664 G_MODULE_EXPORT gboolean
2665 status_icon_query_tooltip_cb(
2666         GtkStatusIcon *si,
2667         gint           x,
2668         gint           y,
2669         gboolean       kbd_mode,
2670         GtkTooltip    *tt,
2671         signal_user_data_t *ud)
2672 {
2673         ghb_status_t status;
2674         gchar *status_str;
2675
2676         ghb_get_status(&status);
2677         if (status.queue.state & GHB_STATE_WORKING)
2678                 status_str = working_status_string(ud, &status.queue);
2679         else if (status.queue.state & GHB_STATE_WORKDONE)
2680                 status_str = g_strdup("Encode Complete");
2681         else
2682                 status_str = g_strdup("HandBrake");
2683
2684         gtk_tooltip_set_text(tt, status_str);
2685         gtk_tooltip_set_icon_from_icon_name(tt, "hb-icon", GTK_ICON_SIZE_BUTTON);
2686         g_free(status_str);
2687         return TRUE;
2688 }
2689 #endif
2690
2691 G_MODULE_EXPORT gboolean
2692 ghb_timer_cb(gpointer data)
2693 {
2694         signal_user_data_t *ud = (signal_user_data_t*)data;
2695
2696         ghb_live_preview_progress(ud);
2697         ghb_backend_events(ud);
2698         if (update_default_destination)
2699         {
2700                 gchar *dest, *dest_dir, *def_dest;
2701                 dest = ghb_settings_get_string(ud->settings, "destination");
2702                 dest_dir = g_path_get_dirname (dest);
2703                 def_dest = ghb_settings_get_string(ud->settings, "destination_dir");
2704                 if (strcmp(dest_dir, def_dest) != 0)
2705                 {
2706                         ghb_settings_set_string (ud->settings, "destination_dir", dest_dir);
2707                         ghb_pref_save (ud->settings, "destination_dir");
2708                 }
2709                 g_free(dest);
2710                 g_free(dest_dir);
2711                 g_free(def_dest);
2712                 update_default_destination = FALSE;
2713         }
2714         if (update_preview)
2715         {
2716                 g_debug("Updating preview\n");
2717                 ghb_set_preview_image (ud);
2718                 update_preview = FALSE;
2719         }
2720
2721         if (!appcast_busy)
2722         {
2723                 gchar *updates;
2724                 updates = ghb_settings_get_string(ud->settings, "check_updates");
2725                 gint64 duration = 0;
2726                 if (strcmp(updates, "daily") == 0)
2727                         duration = 60 * 60 * 24;
2728                 else if (strcmp(updates, "weekly") == 0)
2729                         duration = 60 * 60 * 24 * 7;
2730                 else if (strcmp(updates, "monthly") == 0)
2731                         duration = 60 * 60 * 24 * 7;
2732
2733                 g_free(updates);
2734                 if (duration != 0)
2735                 {
2736                         gint64 last;
2737                         time_t tt;
2738
2739                         last = ghb_settings_get_int64(ud->settings, "last_update_check");
2740                         time(&tt);
2741                         if (last + duration < tt)
2742                         {
2743                                 ghb_settings_set_int64(ud->settings,
2744                                                                                 "last_update_check", tt);
2745                                 ghb_pref_save(ud->settings, "last_update_check");
2746                                 g_thread_create((GThreadFunc)ghb_check_update, ud,
2747                                                                 FALSE, NULL);
2748                         }
2749                 }
2750         }
2751         return TRUE;
2752 }
2753
2754 G_MODULE_EXPORT gboolean
2755 ghb_log_cb(GIOChannel *source, GIOCondition cond, gpointer data)
2756 {
2757         gchar *text = NULL;
2758         gsize length, outlength;
2759         GtkTextView *textview;
2760         GtkTextBuffer *buffer;
2761         GtkTextIter iter;
2762         GtkTextMark *mark;
2763         GError *gerror = NULL;
2764         GIOStatus status;
2765
2766         signal_user_data_t *ud = (signal_user_data_t*)data;
2767
2768         status = g_io_channel_read_line (source, &text, &length, NULL, &gerror);
2769         // Trim nils from end of text, they cause g_io_channel_write_chars to
2770         // fail with an assertion that aborts
2771         while (length > 0 && text[length-1] == 0)
2772                 length--;
2773         if (text != NULL && length > 0)
2774         {
2775                 GdkWindow *window;
2776                 gint width, height;
2777                 gint x, y;
2778                 gboolean bottom = FALSE;
2779                 gchar *utf8_text;
2780
2781                 textview = GTK_TEXT_VIEW(GHB_WIDGET (ud->builder, "activity_view"));
2782                 buffer = gtk_text_view_get_buffer (textview);
2783                 // I would like to auto-scroll the window when the scrollbar
2784                 // is at the bottom,
2785                 // must determine whether the insert point is at
2786                 // the bottom of the window
2787                 window = gtk_text_view_get_window(textview, GTK_TEXT_WINDOW_TEXT);
2788                 if (window != NULL)
2789                 {
2790                         gdk_drawable_get_size(GDK_DRAWABLE(window), &width, &height);
2791                         gtk_text_view_window_to_buffer_coords(textview,
2792                                 GTK_TEXT_WINDOW_TEXT, width, height, &x, &y);
2793                         gtk_text_view_get_iter_at_location(textview, &iter, x, y);
2794                         if (gtk_text_iter_is_end(&iter))
2795                         {
2796                                 bottom = TRUE;
2797                         }
2798                 }
2799                 else
2800                 {
2801                         // If the window isn't available, assume bottom
2802                         bottom = TRUE;
2803                 }
2804                 gtk_text_buffer_get_end_iter(buffer, &iter);
2805                 utf8_text = g_convert_with_fallback(text, -1, "UTF-8", "ISO-8859-1",
2806                                                                                         "?", NULL, &length, NULL);
2807                 if (utf8_text != NULL)
2808                 {
2809                         gtk_text_buffer_insert(buffer, &iter, utf8_text, -1);
2810                         if (bottom)
2811                         {
2812                                 gtk_text_buffer_get_end_iter(buffer, &iter);
2813                                 mark = gtk_text_buffer_create_mark(buffer, NULL, &iter, FALSE);
2814                                 gtk_text_view_scroll_mark_onscreen(textview, mark);
2815                                 gtk_text_buffer_delete_mark(buffer, mark);
2816                         }
2817 #if defined(_WIN32)
2818                         gsize one = 1;
2819                         utf8_text[length-1] = '\r';
2820 #endif
2821                         g_io_channel_write_chars (ud->activity_log, utf8_text,
2822                                                                         length, &outlength, NULL);
2823 #if defined(_WIN32)
2824                         g_io_channel_write_chars (ud->activity_log, "\n",
2825                                                                         one, &one, NULL);
2826 #endif
2827                         g_io_channel_flush(ud->activity_log, NULL);
2828                         if (ud->job_activity_log)
2829                         {
2830                                 g_io_channel_write_chars (ud->job_activity_log, utf8_text,
2831                                                                                 length, &outlength, NULL);
2832 #if defined(_WIN32)
2833                                 g_io_channel_write_chars (ud->activity_log, "\n",
2834                                                                                 one, &outlength, NULL);
2835 #endif
2836                                 g_io_channel_flush(ud->job_activity_log, NULL);
2837                         }
2838                         g_free(utf8_text);
2839                 }
2840         }
2841         if (text != NULL)
2842                 g_free(text);
2843
2844         if (status != G_IO_STATUS_NORMAL)
2845         {
2846                 // This should never happen, but if it does I would get into an
2847                 // infinite loop.  Returning false removes this callback.
2848                 g_warning("Error while reading activity from pipe");
2849                 if (gerror != NULL)
2850                 {
2851                         g_warning("%s", gerror->message);
2852                         g_error_free (gerror);
2853                 }
2854                 return FALSE;
2855         }
2856         if (gerror != NULL)
2857                 g_error_free (gerror);
2858         return TRUE;
2859 }
2860
2861 static void
2862 set_visible(GtkWidget *widget, gboolean visible)
2863 {
2864         if (visible)
2865         {
2866                 gtk_widget_show_now(widget);
2867         }
2868         else
2869         {
2870                 gtk_widget_hide(widget);
2871         }
2872 }
2873
2874 G_MODULE_EXPORT void
2875 show_activity_clicked_cb(GtkWidget *xwidget, signal_user_data_t *ud)
2876 {
2877         GtkWidget *widget = GHB_WIDGET (ud->builder, "activity_window");
2878         set_visible(widget, gtk_toggle_tool_button_get_active(
2879                                                 GTK_TOGGLE_TOOL_BUTTON(xwidget)));
2880 }
2881
2882 G_MODULE_EXPORT void
2883 show_activity_menu_clicked_cb(GtkWidget *xwidget, signal_user_data_t *ud)
2884 {
2885         GtkWidget *widget = GHB_WIDGET (ud->builder, "activity_window");
2886         set_visible(widget, TRUE);
2887         widget = GHB_WIDGET (ud->builder, "show_activity");
2888         gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(widget), TRUE);
2889 }
2890
2891 G_MODULE_EXPORT gboolean
2892 activity_window_delete_cb(GtkWidget *xwidget, GdkEvent *event, signal_user_data_t *ud)
2893 {
2894         set_visible(xwidget, FALSE);
2895         GtkWidget *widget = GHB_WIDGET (ud->builder, "show_activity");
2896         gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(widget), FALSE);
2897         return TRUE;
2898 }
2899
2900 void
2901 ghb_log(gchar *log, ...)
2902 {
2903         va_list args;
2904         time_t _now;
2905     struct tm *now;
2906         gchar fmt[362];
2907
2908         _now = time(NULL);
2909         now = localtime( &_now );
2910         snprintf(fmt, 362, "[%02d:%02d:%02d] gtkgui: %s\n",
2911                         now->tm_hour, now->tm_min, now->tm_sec, log);
2912         va_start(args, log);
2913         vfprintf(stderr, fmt, args);
2914         va_end(args);
2915 }
2916
2917 static void
2918 browse_url(const gchar *url)
2919 {
2920         gboolean result;
2921         char *argv[] =
2922                 {"xdg-open",NULL,NULL,NULL};
2923         argv[1] = (gchar*)url;
2924         result = g_spawn_async(NULL, argv, NULL, G_SPAWN_SEARCH_PATH, NULL,
2925                                 NULL, NULL, NULL);
2926         if (result) return;
2927
2928         argv[0] = "gnome-open";
2929         result = g_spawn_async(NULL, argv, NULL, G_SPAWN_SEARCH_PATH, NULL,
2930                                 NULL, NULL, NULL);
2931         if (result) return;
2932
2933         argv[0] = "kfmclient";
2934         argv[1] = "exec";
2935         argv[2] = "http://trac.handbrake.fr/wiki/HandBrakeGuide";
2936         result = g_spawn_async(NULL, argv, NULL, G_SPAWN_SEARCH_PATH, NULL,
2937                                 NULL, NULL, NULL);
2938         if (result) return;
2939
2940         argv[0] = "firefox";
2941         argv[1] = "http://trac.handbrake.fr/wiki/HandBrakeGuide";
2942         argv[2] = NULL;
2943         result = g_spawn_async(NULL, argv, NULL, G_SPAWN_SEARCH_PATH, NULL,
2944                                 NULL, NULL, NULL);
2945 }
2946
2947 void
2948 about_web_hook(GtkAboutDialog *about, const gchar *link, gpointer data)
2949 {
2950         browse_url(link);
2951 }
2952
2953 G_MODULE_EXPORT void
2954 about_activate_cb(GtkWidget *xwidget, signal_user_data_t *ud)
2955 {
2956         GtkWidget *widget = GHB_WIDGET (ud->builder, "hb_about");
2957         gchar *ver;
2958
2959         ver = g_strdup_printf("%s (%s)", HB_PROJECT_VERSION, HB_PROJECT_BUILD_ARCH);
2960         gtk_about_dialog_set_url_hook(about_web_hook, NULL, NULL);
2961         gtk_about_dialog_set_version(GTK_ABOUT_DIALOG(widget), ver);
2962         g_free(ver);
2963         gtk_about_dialog_set_website(GTK_ABOUT_DIALOG(widget),
2964                                                                 HB_PROJECT_URL_WEBSITE);
2965         gtk_about_dialog_set_website_label(GTK_ABOUT_DIALOG(widget),
2966                                                                                 HB_PROJECT_URL_WEBSITE);
2967         gtk_widget_show (widget);
2968 }
2969
2970 G_MODULE_EXPORT void
2971 guide_activate_cb(GtkWidget *xwidget, signal_user_data_t *ud)
2972 {
2973         browse_url("http://trac.handbrake.fr/wiki/HandBrakeGuide");
2974 }
2975
2976 G_MODULE_EXPORT void
2977 hb_about_response_cb(GtkWidget *widget, gint response, signal_user_data_t *ud)
2978 {
2979         gtk_widget_hide (widget);
2980 }
2981
2982 G_MODULE_EXPORT void
2983 show_queue_clicked_cb(GtkWidget *xwidget, signal_user_data_t *ud)
2984 {
2985         GtkWidget *widget = GHB_WIDGET (ud->builder, "queue_window");
2986         set_visible(widget, gtk_toggle_tool_button_get_active(
2987                                                 GTK_TOGGLE_TOOL_BUTTON(xwidget)));
2988 }
2989
2990 G_MODULE_EXPORT void
2991 show_queue_menu_clicked_cb(GtkWidget *xwidget, signal_user_data_t *ud)
2992 {
2993         GtkWidget *widget = GHB_WIDGET (ud->builder, "queue_window");
2994         set_visible(widget, TRUE);
2995         widget = GHB_WIDGET (ud->builder, "show_queue");
2996         gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(widget), TRUE);
2997 }
2998
2999 G_MODULE_EXPORT gboolean
3000 queue_window_delete_cb(GtkWidget *xwidget, GdkEvent *event, signal_user_data_t *ud)
3001 {
3002         set_visible(xwidget, FALSE);
3003         GtkWidget *widget = GHB_WIDGET (ud->builder, "show_queue");
3004         gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(widget), FALSE);
3005         return TRUE;
3006 }
3007
3008 G_MODULE_EXPORT void
3009 show_presets_toggled_cb(GtkWidget *action, signal_user_data_t *ud)
3010 {
3011         GtkWidget *widget;
3012         GtkWindow *hb_window;
3013
3014         g_debug("show_presets_clicked_cb ()");
3015         widget = GHB_WIDGET (ud->builder, "presets_frame");
3016         ghb_widget_to_setting(ud->settings, action);
3017         if (ghb_settings_get_boolean(ud->settings, "show_presets"))
3018         {
3019                 gtk_widget_show_now(widget);
3020         }
3021         else
3022         {
3023                 gtk_widget_hide(widget);
3024                 hb_window = GTK_WINDOW(GHB_WIDGET (ud->builder, "hb_window"));
3025                 gtk_window_resize(hb_window, 16, 16);
3026         }
3027         ghb_pref_save(ud->settings, "show_presets");
3028 }
3029
3030 static void
3031 reset_chapter_list(signal_user_data_t *ud, GValue *settings)
3032 {
3033         GtkTreeView *treeview;
3034         GtkTreeIter iter;
3035         GtkListStore *store;
3036         gboolean done;
3037         GValue *chapters;
3038         gint titleindex, ii;
3039         gint count;
3040
3041         g_debug("reset_chapter_list ()");
3042         chapters = ghb_value_dup(ghb_settings_get_value(settings, "chapter_list"));
3043         count = ghb_array_len(chapters);
3044         ghb_settings_set_value(ud->settings, "chapter_list", chapters);
3045         titleindex = ghb_settings_combo_int(ud->settings, "title");
3046
3047         treeview = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "chapters_list"));
3048         store = GTK_LIST_STORE(gtk_tree_view_get_model(treeview));
3049         ii = 0;
3050         if (gtk_tree_model_get_iter_first(GTK_TREE_MODEL(store), &iter))
3051         {
3052                 do
3053                 {
3054
3055                         if (ii < count)
3056                         {
3057                                 gchar *chapter, *duration;
3058                                 gint hh, mm, ss;
3059
3060                                 // Update row with settings data
3061                                 g_debug("Updating row");
3062                                 chapter = ghb_value_string(ghb_array_get_nth(chapters, ii));
3063                                 ghb_get_chapter_duration(titleindex, ii, &hh, &mm, &ss);
3064                                 duration = g_strdup_printf("%02d:%02d:%02d", hh, mm, ss);
3065                                 gtk_list_store_set(store, &iter,
3066                                         0, ii+1,
3067                                         1, duration,
3068                                         2, chapter,
3069                                         3, TRUE,
3070                                         -1);
3071                                 g_free(chapter);
3072                                 g_free(duration);
3073                                 ii++;
3074                                 done = !gtk_tree_model_iter_next(GTK_TREE_MODEL(store), &iter);
3075                         }
3076                         else
3077                         {
3078                                 // No more settings data, remove row
3079                                 g_debug("Removing row");
3080                                 done = !gtk_list_store_remove(store, &iter);
3081                         }
3082                 } while (!done);
3083         }
3084         while (ii < count)
3085         {
3086                 gchar *chapter, *duration;
3087                 gint hh, mm, ss;
3088
3089                 // Additional settings, add row
3090                 g_debug("Adding row");
3091                 chapter = ghb_value_string(ghb_array_get_nth(chapters, ii));
3092                 ghb_get_chapter_duration(titleindex, ii, &hh, &mm, &ss);
3093                 duration = g_strdup_printf("%02d:%02d:%02d", hh, mm, ss);
3094                 gtk_list_store_append(store, &iter);
3095                 gtk_list_store_set(store, &iter,
3096                         0, ii+1,
3097                         1, duration,
3098                         2, chapter,
3099                         3, TRUE,
3100                         -1);
3101                 g_free(chapter);
3102                 g_free(duration);
3103                 ii++;
3104         }
3105 }
3106
3107 static void
3108 update_chapter_list(signal_user_data_t *ud)
3109 {
3110         GtkTreeView *treeview;
3111         GtkTreeIter iter;
3112         GtkListStore *store;
3113         gboolean done;
3114         GValue *chapters;
3115         gint titleindex, ii;
3116         gint count;
3117
3118         g_debug("update_chapter_list ()");
3119         titleindex = ghb_settings_combo_int(ud->settings, "title");
3120         chapters = ghb_get_chapters(titleindex);
3121         count = ghb_array_len(chapters);
3122         if (chapters)
3123                 ghb_settings_set_value(ud->settings, "chapter_list", chapters);
3124
3125         treeview = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "chapters_list"));
3126         store = GTK_LIST_STORE(gtk_tree_view_get_model(treeview));
3127         ii = 0;
3128         if (gtk_tree_model_get_iter_first(GTK_TREE_MODEL(store), &iter))
3129         {
3130                 do
3131                 {
3132
3133                         if (ii < count)
3134                         {
3135                                 gchar *chapter, *duration;
3136                                 gint hh, mm, ss;
3137
3138                                 // Update row with settings data
3139                                 g_debug("Updating row");
3140                                 chapter = ghb_value_string(ghb_array_get_nth(chapters, ii));
3141                                 ghb_get_chapter_duration(titleindex, ii, &hh, &mm, &ss);
3142                                 duration = g_strdup_printf("%02d:%02d:%02d", hh, mm, ss);
3143                                 gtk_list_store_set(store, &iter,
3144                                         0, ii+1,
3145                                         1, duration,
3146                                         2, chapter,
3147                                         3, TRUE,
3148                                         -1);
3149                                 g_free(chapter);
3150                                 g_free(duration);
3151                                 ii++;
3152                                 done = !gtk_tree_model_iter_next(GTK_TREE_MODEL(store), &iter);
3153                         }
3154                         else
3155                         {
3156                                 // No more settings data, remove row
3157                                 g_debug("Removing row");
3158                                 done = !gtk_list_store_remove(store, &iter);
3159                         }
3160                 } while (!done);
3161         }
3162         while (ii < count)
3163         {
3164                 gchar *chapter, *duration;
3165                 gint hh, mm, ss;
3166
3167                 // Additional settings, add row
3168                 g_debug("Adding row");
3169                 chapter = ghb_value_string(ghb_array_get_nth(chapters, ii));
3170                 ghb_get_chapter_duration(titleindex, ii, &hh, &mm, &ss);
3171                 duration = g_strdup_printf("%02d:%02d:%02d", hh, mm, ss);
3172                 gtk_list_store_append(store, &iter);
3173                 gtk_list_store_set(store, &iter,
3174                         0, ii+1,
3175                         1, duration,
3176                         2, chapter,
3177                         3, TRUE,
3178                         -1);
3179                 g_free(chapter);
3180                 g_free(duration);
3181                 ii++;
3182         }
3183 }
3184
3185 static gint chapter_edit_key = 0;
3186
3187 G_MODULE_EXPORT gboolean
3188 chapter_keypress_cb(
3189         GhbCellRendererText *cell,
3190         GdkEventKey *event,
3191         signal_user_data_t *ud)
3192 {
3193         chapter_edit_key = event->keyval;
3194         return FALSE;
3195 }
3196
3197 G_MODULE_EXPORT void
3198 chapter_edited_cb(
3199         GhbCellRendererText *cell,
3200         gchar *path,
3201         gchar *text,
3202         signal_user_data_t *ud)
3203 {
3204         GtkTreePath *treepath;
3205         GtkListStore *store;
3206         GtkTreeView *treeview;
3207         GtkTreeIter iter;
3208         gint index;
3209         gint *pi;
3210         gint row;
3211
3212         g_debug("chapter_edited_cb ()");
3213         g_debug("path (%s)", path);
3214         g_debug("text (%s)", text);
3215         treeview = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "chapters_list"));
3216         store = GTK_LIST_STORE(gtk_tree_view_get_model(treeview));
3217         treepath = gtk_tree_path_new_from_string (path);
3218         pi = gtk_tree_path_get_indices(treepath);
3219         row = pi[0];
3220         gtk_tree_model_get_iter(GTK_TREE_MODEL(store), &iter, treepath);
3221         gtk_list_store_set(store, &iter,
3222                 2, text,
3223                 3, TRUE,
3224                 -1);
3225         gtk_tree_model_get(GTK_TREE_MODEL(store), &iter, 0, &index, -1);
3226
3227         const GValue *chapters;
3228         GValue *chapter;
3229
3230         chapters = ghb_settings_get_value(ud->settings, "chapter_list");
3231         chapter = ghb_array_get_nth(chapters, index-1);
3232         g_value_set_string(chapter, text);
3233         if ((chapter_edit_key == GDK_Return || chapter_edit_key == GDK_Down) &&
3234                 gtk_tree_model_iter_next(GTK_TREE_MODEL(store), &iter))
3235         {
3236                 GtkTreeViewColumn *column;
3237
3238                 gtk_tree_path_next(treepath);
3239                 // When a cell has been edited, I want to advance to the
3240                 // next cell and start editing it automaitcally.
3241                 // Unfortunately, we may not be in a state here where
3242                 // editing is allowed.  This happens when the user selects
3243                 // a new cell with the mouse instead of just hitting enter.
3244                 // Some kind of Gtk quirk.  widget_editable==NULL assertion.
3245                 // Editing is enabled again once the selection event has been
3246                 // processed.  So I'm queueing up a callback to be called
3247                 // when things go idle.  There, I will advance to the next
3248                 // cell and initiate editing.
3249                 //
3250                 // Now, you might be asking why I don't catch the keypress
3251                 // event and determine what action to take based on that.
3252                 // The Gtk developers in their infinite wisdom have made the
3253                 // actual GtkEdit widget being used a private member of
3254                 // GtkCellRendererText, so it can not be accessed to hang a
3255                 // signal handler off of.  And they also do not propagate the
3256                 // keypress signals in any other way.  So that information is lost.
3257                 //g_idle_add((GSourceFunc)next_cell, ud);
3258                 //
3259                 // Keeping the above comment for posterity.
3260                 // I got industrious and made my own CellTextRendererText that
3261                 // passes on the key-press-event. So now I have much better
3262                 // control of this.
3263                 column = gtk_tree_view_get_column(treeview, 2);
3264                 gtk_tree_view_set_cursor(treeview, treepath, column, TRUE);
3265         }
3266         else if (chapter_edit_key == GDK_Up && row > 0)
3267         {
3268                 GtkTreeViewColumn *column;
3269                 gtk_tree_path_prev(treepath);
3270                 column = gtk_tree_view_get_column(treeview, 2);
3271                 gtk_tree_view_set_cursor(treeview, treepath, column, TRUE);
3272         }
3273         gtk_tree_path_free (treepath);
3274 }
3275
3276 void
3277 debug_log_handler(const gchar *domain, GLogLevelFlags flags, const gchar *msg, gpointer data)
3278 {
3279         signal_user_data_t *ud = (signal_user_data_t*)data;
3280
3281         if (ud->debug)
3282         {
3283                 printf("%s: %s\n", domain, msg);
3284         }
3285 }
3286
3287 void
3288 warn_log_handler(const gchar *domain, GLogLevelFlags flags, const gchar *msg, gpointer data)
3289 {
3290         printf("%s: %s\n", domain, msg);
3291 }
3292
3293 void
3294 ghb_hbfd(signal_user_data_t *ud, gboolean hbfd)
3295 {
3296         GtkWidget *widget;
3297         g_debug("ghb_hbfd");
3298         widget = GHB_WIDGET(ud->builder, "queue_pause1");
3299         set_visible(widget, !hbfd);
3300         widget = GHB_WIDGET(ud->builder, "queue_add");
3301         set_visible(widget, !hbfd);
3302         widget = GHB_WIDGET(ud->builder, "show_queue");
3303         set_visible(widget, !hbfd);
3304         widget = GHB_WIDGET(ud->builder, "show_activity");
3305         set_visible(widget, !hbfd);
3306
3307         widget = GHB_WIDGET(ud->builder, "chapter_box");
3308         set_visible(widget, !hbfd);
3309         widget = GHB_WIDGET(ud->builder, "container_box");
3310         set_visible(widget, !hbfd);
3311         widget = GHB_WIDGET(ud->builder, "settings_box");
3312         set_visible(widget, !hbfd);
3313         widget = GHB_WIDGET(ud->builder, "presets_save");
3314         set_visible(widget, !hbfd);
3315         widget = GHB_WIDGET(ud->builder, "presets_remove");
3316         set_visible(widget, !hbfd);
3317         widget = GHB_WIDGET (ud->builder, "hb_window");
3318         gtk_window_resize(GTK_WINDOW(widget), 16, 16);
3319
3320 }
3321
3322 G_MODULE_EXPORT void
3323 hbfd_toggled_cb(GtkWidget *widget, signal_user_data_t *ud)
3324 {
3325         g_debug("hbfd_toggled_cb");
3326         ghb_widget_to_setting (ud->settings, widget);
3327         gboolean hbfd = ghb_settings_get_boolean(ud->settings, "hbfd");
3328         ghb_hbfd(ud, hbfd);
3329         ghb_pref_save(ud->settings, "hbfd");
3330 }
3331
3332 G_MODULE_EXPORT void
3333 pref_changed_cb(GtkWidget *widget, signal_user_data_t *ud)
3334 {
3335         g_debug("pref_changed_cb");
3336         ghb_widget_to_setting (ud->settings, widget);
3337         ghb_check_dependency(ud, widget, NULL);
3338         const gchar *name = gtk_widget_get_name(widget);
3339         ghb_pref_save(ud->settings, name);
3340 }
3341
3342 G_MODULE_EXPORT void
3343 use_m4v_changed_cb(GtkWidget *widget, signal_user_data_t *ud)
3344 {
3345         g_debug("use_m4v_changed_cb");
3346         ghb_widget_to_setting (ud->settings, widget);
3347         ghb_check_dependency(ud, widget, NULL);
3348         const gchar *name = gtk_widget_get_name(widget);
3349         ghb_pref_save(ud->settings, name);
3350         ghb_update_destination_extension(ud);
3351 }
3352
3353 G_MODULE_EXPORT void
3354 show_status_cb(GtkWidget *widget, signal_user_data_t *ud)
3355 {
3356         g_debug("show_status_cb");
3357         ghb_widget_to_setting (ud->settings, widget);
3358         ghb_check_dependency(ud, widget, NULL);
3359         const gchar *name = gtk_widget_get_name(widget);
3360         ghb_pref_save(ud->settings, name);
3361
3362         GtkStatusIcon *si;
3363
3364         si = GTK_STATUS_ICON(GHB_OBJECT (ud->builder, "hb_status"));
3365         gtk_status_icon_set_visible(si,
3366                         ghb_settings_get_boolean(ud->settings, "show_status"));
3367 }
3368
3369 G_MODULE_EXPORT void
3370 vqual_granularity_changed_cb(GtkWidget *widget, signal_user_data_t *ud)
3371 {
3372         g_debug("vqual_granularity_changed_cb");
3373         ghb_widget_to_setting (ud->settings, widget);
3374         ghb_check_dependency(ud, widget, NULL);
3375
3376         const gchar *name = gtk_widget_get_name(widget);
3377         ghb_pref_save(ud->settings, name);
3378
3379         gdouble vqmin, vqmax, step, page;
3380         gboolean inverted;
3381         gint digits;
3382
3383         ghb_vquality_range(ud, &vqmin, &vqmax, &step, &page, &digits, &inverted);
3384         GtkWidget *qp = GHB_WIDGET(ud->builder, "VideoQualitySlider");
3385         gtk_range_set_increments (GTK_RANGE(qp), step, page);
3386 }
3387
3388 G_MODULE_EXPORT void
3389 tweaks_changed_cb(GtkWidget *widget, signal_user_data_t *ud)
3390 {
3391         g_debug("tweaks_changed_cb");
3392         ghb_widget_to_setting (ud->settings, widget);
3393         const gchar *name = gtk_widget_get_name(widget);
3394         ghb_pref_save(ud->settings, name);
3395 }
3396
3397 G_MODULE_EXPORT void
3398 hbfd_feature_changed_cb(GtkWidget *widget, signal_user_data_t *ud)
3399 {
3400         g_debug("hbfd_feature_changed_cb");
3401         ghb_widget_to_setting (ud->settings, widget);
3402         const gchar *name = gtk_widget_get_name(widget);
3403         ghb_pref_save(ud->settings, name);
3404
3405         gboolean hbfd = ghb_settings_get_boolean(ud->settings, "hbfd_feature");
3406         GtkAction *action;
3407         if (hbfd)
3408         {
3409                 const GValue *val;
3410                 val = ghb_settings_get_value(ud->settings, "hbfd");
3411                 ghb_ui_update(ud, "hbfd", val);
3412         }
3413         action = GHB_ACTION (ud->builder, "hbfd");
3414         gtk_action_set_visible(action, hbfd);
3415 }
3416
3417 gboolean
3418 ghb_file_menu_add_dvd(signal_user_data_t *ud)
3419 {
3420         GList *link, *drives;
3421         static GtkActionGroup *agroup = NULL;
3422         static gint merge_id;
3423
3424         g_debug("ghb_file_menu_add_dvd()");
3425         link = drives = dvd_device_list();
3426         if (drives != NULL)
3427         {
3428                 GtkUIManager *ui = GTK_UI_MANAGER(
3429                         gtk_builder_get_object(ud->builder, "uimanager1"));
3430
3431                 if (agroup == NULL)
3432                 {
3433                         agroup = gtk_action_group_new("dvdgroup");
3434                         gtk_ui_manager_insert_action_group(ui, agroup, 0);
3435                 }
3436                 else
3437                         gtk_ui_manager_remove_ui(ui, merge_id);
3438
3439                 merge_id = gtk_ui_manager_new_merge_id(ui);
3440                 // Add separator
3441                 gtk_ui_manager_add_ui(ui, merge_id,
3442                         "ui/menubar1/menuitem1/quit1", "dvdsep", NULL,
3443                         GTK_UI_MANAGER_SEPARATOR, TRUE);
3444
3445                 while (link != NULL)
3446                 {
3447                         GtkAction *action;
3448                         gchar *drive = get_dvd_device_name(link->data);
3449                         gchar *name = get_dvd_volume_name(link->data);
3450
3451                         action = gtk_action_group_get_action(agroup, drive);
3452                         if (action != NULL)
3453                         {
3454                                 gtk_action_group_remove_action(agroup, action);
3455                                 g_object_unref(G_OBJECT(action));
3456                         }
3457                         // Create action for this drive
3458                         action = gtk_action_new(drive, name,
3459                                 "Scan this DVD source", "gtk-cdrom");
3460                         // Add action to action group
3461                         gtk_action_group_add_action_with_accel(agroup, action, NULL);
3462                         // Add to ui manager
3463                         gtk_ui_manager_add_ui(ui, merge_id,
3464                                 "ui/menubar1/menuitem1/dvdsep", drive, drive,
3465                                 GTK_UI_MANAGER_AUTO, TRUE);
3466                         // Connect signal to action (menu item)
3467                         g_signal_connect(action, "activate",
3468                                 (GCallback)dvd_source_activate_cb, ud);
3469                         g_free(name);
3470                         g_free(drive);
3471                         free_drive(link->data);
3472                         link = link->next;
3473                 }
3474                 g_list_free(drives);
3475         }
3476         return FALSE;
3477 }
3478
3479 gboolean ghb_is_cd(GDrive *gd);
3480
3481 static GList*
3482 dvd_device_list()
3483 {
3484         GList *dvd_devices = NULL;
3485
3486 #if defined(_WIN32)
3487         gint ii, drives;
3488         gchar drive[5];
3489
3490         strcpy(drive, "A:" G_DIR_SEPARATOR_S);
3491         drives = GetLogicalDrives();
3492         for (ii = 0; ii < 26; ii++)
3493         {
3494                 if (drives & 0x01)
3495                 {
3496                         guint dtype;
3497
3498                         drive[0] = 'A' + ii;
3499                         dtype = GetDriveType(drive);
3500                         if (dtype == DRIVE_CDROM)
3501                         {
3502                                 dvd_devices = g_list_append(dvd_devices,
3503                                                 (gpointer)g_strdup(drive));
3504                         }
3505                 }
3506                 drives >>= 1;
3507         }
3508 #else
3509         GVolumeMonitor *gvm;
3510         GList *drives, *link;
3511
3512         gvm = g_volume_monitor_get ();
3513         drives = g_volume_monitor_get_connected_drives (gvm);
3514         link = drives;
3515         while (link != NULL)
3516         {
3517                 GDrive *gd;
3518
3519                 gd = (GDrive*)link->data;
3520                 if (ghb_is_cd(gd))
3521                 {
3522                         dvd_devices = g_list_append(dvd_devices, gd);
3523                 }
3524                 else
3525                         g_object_unref (gd);
3526                 link = link->next;
3527         }
3528         g_list_free(drives);
3529 #endif
3530
3531         return dvd_devices;
3532 }
3533
3534 #if !defined(_WIN32)
3535 static LibHalContext *hal_ctx = NULL;
3536 #endif
3537
3538 gboolean
3539 ghb_is_cd(GDrive *gd)
3540 {
3541 #if !defined(_WIN32)
3542         gchar *device;
3543         LibHalDrive *halDrive;
3544         LibHalDriveType dtype;
3545
3546         if (hal_ctx == NULL)
3547                 return FALSE;
3548
3549         device = g_drive_get_identifier(gd, G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE);
3550         if (device == NULL)
3551                 return FALSE;
3552         halDrive = libhal_drive_from_device_file (hal_ctx, device);
3553         g_free(device);
3554         if (halDrive == NULL)
3555                 return FALSE;
3556         dtype = libhal_drive_get_type(halDrive);
3557         libhal_drive_free(halDrive);
3558         return (dtype == LIBHAL_DRIVE_TYPE_CDROM);
3559 #else
3560         return FALSE;
3561 #endif
3562 }
3563
3564 #if defined(_WIN32)
3565 static void
3566 handle_media_change(const gchar *device, gboolean insert, signal_user_data_t *ud)
3567 {
3568         guint dtype;
3569         static gint ins_count = 0;
3570         static gint rem_count = 0;
3571
3572         // The media change event in windows bounces around a bit
3573         // so I debounce it here
3574         // DVD insertion detected.  Scan it.
3575         dtype = GetDriveType(device);
3576         if (dtype != DRIVE_CDROM)
3577                 return;
3578         if (insert)
3579         {
3580                 rem_count = 0;
3581                 ins_count++;
3582                 if (ins_count == 2)
3583                 {
3584                         g_thread_create((GThreadFunc)ghb_cache_volnames, ud, FALSE, NULL);
3585                         if (ghb_settings_get_boolean(ud->settings, "AutoScan") &&
3586                                 ud->current_dvd_device != NULL &&
3587                                 strcmp(device, ud->current_dvd_device) == 0)
3588                         {
3589                                 show_scan_progress(ud);
3590                                 update_source_label(ud, device, TRUE);
3591                                 gint preview_count;
3592                                 preview_count = ghb_settings_get_int(ud->settings, "preview_count");
3593                                 ghb_settings_set_string(ud->settings, "scan_source", device);
3594                                 start_scan(ud, device, 0, preview_count);
3595                         }
3596                 }
3597         }
3598         else
3599         {
3600                 ins_count = 0;
3601                 rem_count++;
3602                 if (rem_count == 2)
3603                 {
3604                         g_thread_create((GThreadFunc)ghb_cache_volnames, ud, FALSE, NULL);
3605                         if (ud->current_dvd_device != NULL &&
3606                                 strcmp(device, ud->current_dvd_device) == 0)
3607                         {
3608                                 ghb_hb_cleanup(TRUE);
3609                                 prune_logs(ud);
3610                                 ghb_settings_set_string(ud->settings, "scan_source", "/dev/null");
3611                                 start_scan(ud, "/dev/null", 0, 1);
3612                         }
3613                 }
3614         }
3615 }
3616
3617 static gchar
3618 FindDriveFromMask(ULONG unitmask)
3619 {
3620         gchar cc;
3621         for (cc = 0; cc < 26; cc++)
3622         {
3623                 if (unitmask & 0x01)
3624                         return 'A' + cc;
3625                 unitmask >>= 1;
3626         }
3627         return 0;
3628 }
3629
3630 void
3631 wm_drive_changed(MSG *msg, signal_user_data_t *ud)
3632 {
3633         PDEV_BROADCAST_HDR bch = (PDEV_BROADCAST_HDR)msg->lParam;
3634         gchar drive[4];
3635
3636         g_strlcpy(drive, "A:" G_DIR_SEPARATOR_S, 4);
3637         switch (msg->wParam)
3638         {
3639                 case DBT_DEVICEARRIVAL:
3640                 {
3641                         if (bch->dbch_devicetype == DBT_DEVTYP_VOLUME)
3642                         {
3643                                 PDEV_BROADCAST_VOLUME bcv = (PDEV_BROADCAST_VOLUME)bch;
3644
3645                                 if (bcv->dbcv_flags & DBTF_MEDIA)
3646                                 {
3647                                         drive[0] = FindDriveFromMask(bcv->dbcv_unitmask);
3648                                         handle_media_change(drive, TRUE, ud);
3649                                 }
3650                         }
3651                 } break;
3652
3653                 case DBT_DEVICEREMOVECOMPLETE:
3654                 {
3655                         if (bch->dbch_devicetype == DBT_DEVTYP_VOLUME)
3656                         {
3657                                 PDEV_BROADCAST_VOLUME bcv = (PDEV_BROADCAST_VOLUME)bch;
3658
3659                                 if (bcv->dbcv_flags & DBTF_MEDIA)
3660                                 {
3661                                         drive[0] = FindDriveFromMask(bcv->dbcv_unitmask);
3662                                         handle_media_change(drive, FALSE, ud);
3663                                 }
3664                         }
3665                 } break;
3666                 default: ;
3667         }
3668 }
3669
3670 #else
3671
3672 G_MODULE_EXPORT void
3673 drive_changed_cb(GVolumeMonitor *gvm, GDrive *gd, signal_user_data_t *ud)
3674 {
3675         gchar *device;
3676         gint state;
3677
3678         g_debug("drive_changed_cb()");
3679         g_thread_create((GThreadFunc)ghb_cache_volnames, ud, FALSE, NULL);
3680
3681         state = ghb_get_scan_state();
3682         device = g_drive_get_identifier(gd, G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE);
3683         if (ud->current_dvd_device == NULL ||
3684                 strcmp(device, ud->current_dvd_device) != 0 ||
3685                 state != GHB_STATE_IDLE )
3686         {
3687                 return;
3688         }
3689         if (g_drive_has_media(gd))
3690         {
3691                 if (ghb_settings_get_boolean(ud->settings, "AutoScan"))
3692                 {
3693                         show_scan_progress(ud);
3694                         update_source_label(ud, device, TRUE);
3695                         gint preview_count;
3696                         preview_count = ghb_settings_get_int(ud->settings, "preview_count");
3697                         ghb_settings_set_string(ud->settings, "scan_source", device);
3698                         start_scan(ud, device, 0, preview_count);
3699                 }
3700         }
3701         else
3702         {
3703                 ghb_hb_cleanup(TRUE);
3704                 prune_logs(ud);
3705                 ghb_settings_set_string(ud->settings, "scan_source", "/dev/null");
3706                 start_scan(ud, "/dev/null", 0, 1);
3707         }
3708 }
3709 #endif
3710
3711 #if !defined(_WIN32)
3712 static void
3713 dbus_init (void)
3714 {
3715         dbus_g_thread_init();
3716 }
3717
3718 #define GPM_DBUS_PM_SERVICE                     "org.freedesktop.PowerManagement"
3719 #define GPM_DBUS_PM_PATH                        "/org/freedesktop/PowerManagement"
3720 #define GPM_DBUS_PM_INTERFACE           "org.freedesktop.PowerManagement"
3721 #define GPM_DBUS_INHIBIT_PATH           "/org/freedesktop/PowerManagement/Inhibit"
3722 #define GPM_DBUS_INHIBIT_INTERFACE      "org.freedesktop.PowerManagement.Inhibit"
3723 static gboolean gpm_inhibited = FALSE;
3724 static guint gpm_cookie = -1;
3725 #endif
3726
3727 static gboolean
3728 ghb_can_suspend_gpm()
3729 {
3730         gboolean can_suspend = FALSE;
3731 #if !defined(_WIN32)
3732         DBusGConnection *conn;
3733         DBusGProxy      *proxy;
3734         GError *error = NULL;
3735         gboolean res;
3736
3737
3738         g_debug("ghb_can_suspend_gpm()");
3739         conn = dbus_g_bus_get(DBUS_BUS_SESSION, &error);
3740         if (error != NULL)
3741         {
3742                 g_warning("DBUS cannot connect: %s", error->message);
3743                 g_error_free(error);
3744                 return FALSE;
3745         }
3746         proxy = dbus_g_proxy_new_for_name(conn, GPM_DBUS_PM_SERVICE,
3747                                                         GPM_DBUS_PM_PATH, GPM_DBUS_PM_INTERFACE);
3748         if (proxy == NULL)
3749         {
3750                 g_warning("Could not get DBUS proxy: %s", GPM_DBUS_PM_SERVICE);
3751                 dbus_g_connection_unref(conn);
3752                 return FALSE;
3753         }
3754         res = dbus_g_proxy_call(proxy, "CanSuspend", &error,
3755                                                         G_TYPE_INVALID,
3756                                                         G_TYPE_BOOLEAN, &can_suspend,
3757                                                         G_TYPE_INVALID);
3758         if (!res)
3759         {
3760                 if (error != NULL)
3761                 {
3762                         g_warning("CanSuspend failed: %s", error->message);
3763                         g_error_free(error);
3764                 }
3765                 else
3766                         g_warning("CanSuspend failed");
3767                 // Try to shutdown anyway
3768                 can_suspend = TRUE;
3769         }
3770         g_object_unref(G_OBJECT(proxy));
3771         dbus_g_connection_unref(conn);
3772 #endif
3773         return can_suspend;
3774 }
3775
3776 static void
3777 ghb_suspend_gpm()
3778 {
3779 #if !defined(_WIN32)
3780         DBusGConnection *conn;
3781         DBusGProxy      *proxy;
3782         GError *error = NULL;
3783         gboolean res;
3784
3785
3786         g_debug("ghb_suspend_gpm()");
3787         conn = dbus_g_bus_get(DBUS_BUS_SESSION, &error);
3788         if (error != NULL)
3789         {
3790                 g_warning("DBUS cannot connect: %s", error->message);
3791                 g_error_free(error);
3792                 return;
3793         }
3794         proxy = dbus_g_proxy_new_for_name(conn, GPM_DBUS_PM_SERVICE,
3795                                                         GPM_DBUS_PM_PATH, GPM_DBUS_PM_INTERFACE);
3796         if (proxy == NULL)
3797         {
3798                 g_warning("Could not get DBUS proxy: %s", GPM_DBUS_PM_SERVICE);
3799                 dbus_g_connection_unref(conn);
3800                 return;
3801         }
3802         res = dbus_g_proxy_call(proxy, "Suspend", &error,
3803                                                         G_TYPE_INVALID,
3804                                                         G_TYPE_INVALID);
3805         if (!res)
3806         {
3807                 if (error != NULL)
3808                 {
3809                         g_warning("Suspend failed: %s", error->message);
3810                         g_error_free(error);
3811                 }
3812                 else
3813                         g_warning("Suspend failed");
3814         }
3815         g_object_unref(G_OBJECT(proxy));
3816         dbus_g_connection_unref(conn);
3817 #endif
3818 }
3819
3820 static gboolean
3821 ghb_can_shutdown_gpm()
3822 {
3823         gboolean can_shutdown = FALSE;
3824 #if !defined(_WIN32)
3825         DBusGConnection *conn;
3826         DBusGProxy      *proxy;
3827         GError *error = NULL;
3828         gboolean res;
3829
3830
3831         g_debug("ghb_can_shutdown_gpm()");
3832         conn = dbus_g_bus_get(DBUS_BUS_SESSION, &error);
3833         if (error != NULL)
3834         {
3835                 g_warning("DBUS cannot connect: %s", error->message);
3836                 g_error_free(error);
3837                 return FALSE;
3838         }
3839         proxy = dbus_g_proxy_new_for_name(conn, GPM_DBUS_PM_SERVICE,
3840                                                         GPM_DBUS_PM_PATH, GPM_DBUS_PM_INTERFACE);
3841         if (proxy == NULL)
3842         {
3843                 g_warning("Could not get DBUS proxy: %s", GPM_DBUS_PM_SERVICE);
3844                 dbus_g_connection_unref(conn);
3845                 return FALSE;
3846         }
3847         res = dbus_g_proxy_call(proxy, "CanShutdown", &error,
3848                                                         G_TYPE_INVALID,
3849                                                         G_TYPE_BOOLEAN, &can_shutdown,
3850                                                         G_TYPE_INVALID);
3851         if (!res)
3852         {
3853                 if (error != NULL)
3854                 {
3855                         g_warning("CanShutdown failed: %s", error->message);
3856                         g_error_free(error);
3857                 }
3858                 else
3859                         g_warning("CanShutdown failed");
3860                 // Try to shutdown anyway
3861                 can_shutdown = TRUE;
3862         }
3863         g_object_unref(G_OBJECT(proxy));
3864         dbus_g_connection_unref(conn);
3865 #endif
3866         return can_shutdown;
3867 }
3868
3869 static void
3870 ghb_shutdown_gpm()
3871 {
3872 #if !defined(_WIN32)
3873         DBusGConnection *conn;
3874         DBusGProxy      *proxy;
3875         GError *error = NULL;
3876         gboolean res;
3877
3878
3879         g_debug("ghb_shutdown_gpm()");
3880         conn = dbus_g_bus_get(DBUS_BUS_SESSION, &error);
3881         if (error != NULL)
3882         {
3883                 g_warning("DBUS cannot connect: %s", error->message);
3884                 g_error_free(error);
3885                 return;
3886         }
3887         proxy = dbus_g_proxy_new_for_name(conn, GPM_DBUS_PM_SERVICE,
3888                                                         GPM_DBUS_PM_PATH, GPM_DBUS_PM_INTERFACE);
3889         if (proxy == NULL)
3890         {
3891                 g_warning("Could not get DBUS proxy: %s", GPM_DBUS_PM_SERVICE);
3892                 dbus_g_connection_unref(conn);
3893                 return;
3894         }
3895         res = dbus_g_proxy_call(proxy, "Shutdown", &error,
3896                                                         G_TYPE_INVALID,
3897                                                         G_TYPE_INVALID);
3898         if (!res)
3899         {
3900                 if (error != NULL)
3901                 {
3902                         g_warning("Shutdown failed: %s", error->message);
3903                         g_error_free(error);
3904                 }
3905                 else
3906                         g_warning("Shutdown failed");
3907         }
3908         g_object_unref(G_OBJECT(proxy));
3909         dbus_g_connection_unref(conn);
3910 #endif
3911 }
3912
3913 void
3914 ghb_inhibit_gpm()
3915 {
3916 #if !defined(_WIN32)
3917         DBusGConnection *conn;
3918         DBusGProxy      *proxy;
3919         GError *error = NULL;
3920         gboolean res;
3921
3922
3923         if (gpm_inhibited)
3924         {
3925                 // Already inhibited
3926                 return;
3927         }
3928         g_debug("ghb_inhibit_gpm()");
3929         conn = dbus_g_bus_get(DBUS_BUS_SESSION, &error);
3930         if (error != NULL)
3931         {
3932                 g_warning("DBUS cannot connect: %s", error->message);
3933                 g_error_free(error);
3934                 return;
3935         }
3936         proxy = dbus_g_proxy_new_for_name(conn, GPM_DBUS_PM_SERVICE,
3937                                                         GPM_DBUS_INHIBIT_PATH, GPM_DBUS_INHIBIT_INTERFACE);
3938         if (proxy == NULL)
3939         {
3940                 g_warning("Could not get DBUS proxy: %s", GPM_DBUS_PM_SERVICE);
3941                 dbus_g_connection_unref(conn);
3942                 return;
3943         }
3944         res = dbus_g_proxy_call(proxy, "Inhibit", &error,
3945                                                         G_TYPE_STRING, "ghb",
3946                                                         G_TYPE_STRING, "Encoding",
3947                                                         G_TYPE_INVALID,
3948                                                         G_TYPE_UINT, &gpm_cookie,
3949                                                         G_TYPE_INVALID);
3950         gpm_inhibited = TRUE;
3951         if (!res)
3952         {
3953                 if (error != NULL)
3954                 {
3955                         g_warning("Inhibit failed: %s", error->message);
3956                         g_error_free(error);
3957                         gpm_cookie = -1;
3958                 }
3959                 else
3960                         g_warning("Inhibit failed");
3961                 gpm_cookie = -1;
3962                 gpm_inhibited = FALSE;
3963         }
3964         g_object_unref(G_OBJECT(proxy));
3965         dbus_g_connection_unref(conn);
3966 #endif
3967 }
3968
3969 void
3970 ghb_uninhibit_gpm()
3971 {
3972 #if !defined(_WIN32)
3973         DBusGConnection *conn;
3974         DBusGProxy      *proxy;
3975         GError *error = NULL;
3976         gboolean res;
3977
3978         g_debug("ghb_uninhibit_gpm() gpm_cookie %u", gpm_cookie);
3979
3980         if (!gpm_inhibited)
3981         {
3982                 // Not inhibited
3983                 return;
3984         }
3985         conn = dbus_g_bus_get(DBUS_BUS_SESSION, &error);
3986         if (error != NULL)
3987         {
3988                 g_warning("DBUS cannot connect: %s", error->message);
3989                 g_error_free(error);
3990                 return;
3991         }
3992         proxy = dbus_g_proxy_new_for_name(conn, GPM_DBUS_PM_SERVICE,
3993                                                         GPM_DBUS_INHIBIT_PATH, GPM_DBUS_INHIBIT_INTERFACE);
3994         if (proxy == NULL)
3995         {
3996                 g_warning("Could not get DBUS proxy: %s", GPM_DBUS_PM_SERVICE);
3997                 dbus_g_connection_unref(conn);
3998                 return;
3999         }
4000         res = dbus_g_proxy_call(proxy, "UnInhibit", &error,
4001                                                         G_TYPE_UINT, gpm_cookie,
4002                                                         G_TYPE_INVALID,
4003                                                         G_TYPE_INVALID);
4004         if (!res)
4005         {
4006                 if (error != NULL)
4007                 {
4008                         g_warning("UnInhibit failed: %s", error->message);
4009                         g_error_free(error);
4010                 }
4011                 else
4012                         g_warning("UnInhibit failed");
4013         }
4014         gpm_inhibited = FALSE;
4015         dbus_g_connection_unref(conn);
4016         g_object_unref(G_OBJECT(proxy));
4017 #endif
4018 }
4019
4020 #if !defined(_WIN32)
4021
4022 // For inhibit and shutdown
4023 #define GPM_DBUS_SM_SERVICE                     "org.gnome.SessionManager"
4024 #define GPM_DBUS_SM_PATH                        "/org/gnome/SessionManager"
4025 #define GPM_DBUS_SM_INTERFACE           "org.gnome.SessionManager"
4026
4027 #endif
4028
4029 static gboolean
4030 ghb_can_shutdown_gsm()
4031 {
4032         gboolean can_shutdown = FALSE;
4033 #if !defined(_WIN32)
4034         DBusGConnection *conn;
4035         DBusGProxy      *proxy;
4036         GError *error = NULL;
4037         gboolean res;
4038
4039
4040         g_debug("ghb_can_shutdown_gpm()");
4041         conn = dbus_g_bus_get(DBUS_BUS_SESSION, &error);
4042         if (error != NULL)
4043         {
4044                 g_warning("DBUS cannot connect: %s", error->message);
4045                 g_error_free(error);
4046                 return FALSE;
4047         }
4048         proxy = dbus_g_proxy_new_for_name(conn, GPM_DBUS_SM_SERVICE,
4049                                                         GPM_DBUS_SM_PATH, GPM_DBUS_SM_INTERFACE);
4050         if (proxy == NULL)
4051         {
4052                 g_warning("Could not get DBUS proxy: %s", GPM_DBUS_SM_SERVICE);
4053                 dbus_g_connection_unref(conn);
4054                 return FALSE;
4055         }
4056         res = dbus_g_proxy_call(proxy, "CanShutdown", &error,
4057                                                         G_TYPE_INVALID,
4058                                                         G_TYPE_BOOLEAN, &can_shutdown,
4059                                                         G_TYPE_INVALID);
4060         g_object_unref(G_OBJECT(proxy));
4061         dbus_g_connection_unref(conn);
4062         if (!res)
4063         {
4064                 if (error != NULL)
4065                 {
4066                         g_error_free(error);
4067                 }
4068                 // Try to shutdown anyway
4069                 can_shutdown = TRUE;
4070                 // Try the gpm version
4071                 return ghb_can_shutdown_gpm();
4072         }
4073 #endif
4074         return can_shutdown;
4075 }
4076
4077 static void
4078 ghb_shutdown_gsm()
4079 {
4080 #if !defined(_WIN32)
4081         DBusGConnection *conn;
4082         DBusGProxy      *proxy;
4083         GError *error = NULL;
4084         gboolean res;
4085
4086
4087         g_debug("ghb_shutdown_gpm()");
4088         conn = dbus_g_bus_get(DBUS_BUS_SESSION, &error);
4089         if (error != NULL)
4090         {
4091                 g_warning("DBUS cannot connect: %s", error->message);
4092                 g_error_free(error);
4093                 return;
4094         }
4095         proxy = dbus_g_proxy_new_for_name(conn, GPM_DBUS_SM_SERVICE,
4096                                                         GPM_DBUS_SM_PATH, GPM_DBUS_SM_INTERFACE);
4097         if (proxy == NULL)
4098         {
4099                 g_warning("Could not get DBUS proxy: %s", GPM_DBUS_SM_SERVICE);
4100                 dbus_g_connection_unref(conn);
4101                 return;
4102         }
4103         res = dbus_g_proxy_call(proxy, "Shutdown", &error,
4104                                                         G_TYPE_INVALID,
4105                                                         G_TYPE_INVALID);
4106         g_object_unref(G_OBJECT(proxy));
4107         dbus_g_connection_unref(conn);
4108         if (!res)
4109         {
4110                 if (error != NULL)
4111                 {
4112                         g_error_free(error);
4113                 }
4114                 // Try the gpm version
4115                 ghb_shutdown_gpm();
4116         }
4117 #endif
4118 }
4119
4120 void
4121 ghb_inhibit_gsm(signal_user_data_t *ud)
4122 {
4123 #if !defined(_WIN32)
4124         DBusGConnection *conn;
4125         DBusGProxy      *proxy;
4126         GError *error = NULL;
4127         gboolean res;
4128         guint xid;
4129         GtkWidget *widget;
4130
4131
4132         if (gpm_inhibited)
4133         {
4134                 // Already inhibited
4135                 return;
4136         }
4137         g_debug("ghb_inhibit_gsm()");
4138         conn = dbus_g_bus_get(DBUS_BUS_SESSION, &error);
4139         if (error != NULL)
4140         {
4141                 g_warning("DBUS cannot connect: %s", error->message);
4142                 g_error_free(error);
4143                 return;
4144         }
4145         proxy = dbus_g_proxy_new_for_name(conn, GPM_DBUS_SM_SERVICE,
4146                                                         GPM_DBUS_SM_PATH, GPM_DBUS_SM_INTERFACE);
4147         if (proxy == NULL)
4148         {
4149                 g_warning("Could not get DBUS proxy: %s", GPM_DBUS_SM_SERVICE);
4150                 dbus_g_connection_unref(conn);
4151                 return;
4152         }
4153         widget = GHB_WIDGET(ud->builder, "hb_window");
4154         xid = GDK_DRAWABLE_XID(widget->window);
4155         res = dbus_g_proxy_call(proxy, "Inhibit", &error,
4156                                                         G_TYPE_STRING, "ghb",
4157                                                         G_TYPE_UINT, xid,
4158                                                         G_TYPE_STRING, "Encoding",
4159                                                         G_TYPE_UINT, 1 | 4,
4160                                                         G_TYPE_INVALID,
4161                                                         G_TYPE_UINT, &gpm_cookie,
4162                                                         G_TYPE_INVALID);
4163         gpm_inhibited = TRUE;
4164         g_object_unref(G_OBJECT(proxy));
4165         dbus_g_connection_unref(conn);
4166         if (!res)
4167         {
4168                 if (error != NULL)
4169                 {
4170                         g_error_free(error);
4171                         gpm_cookie = -1;
4172                 }
4173                 gpm_cookie = -1;
4174                 gpm_inhibited = FALSE;
4175                 // Try the gpm version
4176                 ghb_inhibit_gpm();
4177         }
4178 #endif
4179 }
4180
4181 void
4182 ghb_uninhibit_gsm()
4183 {
4184 #if !defined(_WIN32)
4185         DBusGConnection *conn;
4186         DBusGProxy      *proxy;
4187         GError *error = NULL;
4188         gboolean res;
4189
4190         g_debug("ghb_uninhibit_gsm() gpm_cookie %u", gpm_cookie);
4191
4192         if (!gpm_inhibited)
4193         {
4194                 // Not inhibited
4195                 return;
4196         }
4197         conn = dbus_g_bus_get(DBUS_BUS_SESSION, &error);
4198         if (error != NULL)
4199         {
4200                 g_warning("DBUS cannot connect: %s", error->message);
4201                 g_error_free(error);
4202                 return;
4203         }
4204         proxy = dbus_g_proxy_new_for_name(conn, GPM_DBUS_SM_SERVICE,
4205                                                         GPM_DBUS_SM_PATH, GPM_DBUS_SM_INTERFACE);
4206         if (proxy == NULL)
4207         {
4208                 g_warning("Could not get DBUS proxy: %s", GPM_DBUS_SM_SERVICE);
4209                 dbus_g_connection_unref(conn);
4210                 return;
4211         }
4212         res = dbus_g_proxy_call(proxy, "Uninhibit", &error,
4213                                                         G_TYPE_UINT, gpm_cookie,
4214                                                         G_TYPE_INVALID,
4215                                                         G_TYPE_INVALID);
4216         dbus_g_connection_unref(conn);
4217         g_object_unref(G_OBJECT(proxy));
4218         if (!res)
4219         {
4220                 if (error != NULL)
4221                 {
4222                         g_error_free(error);
4223                 }
4224                 ghb_uninhibit_gpm();
4225         }
4226         gpm_inhibited = FALSE;
4227 #endif
4228 }
4229
4230 void
4231 ghb_hal_init()
4232 {
4233 #if !defined(_WIN32)
4234         DBusGConnection *gconn;
4235         DBusConnection *conn;
4236         GError *gerror = NULL;
4237         DBusError error;
4238         char **devices;
4239         int nr;
4240
4241         dbus_init ();
4242
4243         if (!(hal_ctx = libhal_ctx_new ())) {
4244                 g_warning ("failed to create a HAL context!");
4245                 return;
4246         }
4247
4248         gconn = dbus_g_bus_get(DBUS_BUS_SYSTEM, &gerror);
4249         if (gerror != NULL)
4250         {
4251                 g_warning("DBUS cannot connect: %s", gerror->message);
4252                 g_error_free(gerror);
4253                 return;
4254         }
4255         conn = dbus_g_connection_get_connection(gconn);
4256         libhal_ctx_set_dbus_connection (hal_ctx, conn);
4257         dbus_error_init (&error);
4258         if (!libhal_ctx_init (hal_ctx, &error)) {
4259                 g_warning ("libhal_ctx_init failed: %s", error.message ? error.message : "unknown");
4260                 dbus_error_free (&error);
4261                 libhal_ctx_free (hal_ctx);
4262                 dbus_g_connection_unref(gconn);
4263                 hal_ctx = NULL;
4264                 return;
4265         }
4266
4267         /*
4268          * Do something to ping the HAL daemon - the above functions will
4269          * succeed even if hald is not running, so long as DBUS is.  But we
4270          * want to exit silently if hald is not running, to behave on
4271          * pre-2.6 systems.
4272          */
4273         if (!(devices = libhal_get_all_devices (hal_ctx, &nr, &error))) {
4274                 g_warning ("seems that HAL is not running: %s", error.message ? error.message : "unknown");
4275                 dbus_error_free (&error);
4276
4277                 libhal_ctx_shutdown (hal_ctx, NULL);
4278                 libhal_ctx_free (hal_ctx);
4279                 hal_ctx = NULL;
4280                 dbus_g_connection_unref(gconn);
4281                 return;
4282         }
4283
4284         libhal_free_string_array (devices);
4285         dbus_g_connection_unref(gconn);
4286 #endif
4287 }
4288
4289 G_MODULE_EXPORT gboolean
4290 tweak_setting_cb(
4291         GtkWidget *widget,
4292         GdkEventButton *event,
4293         signal_user_data_t *ud)
4294 {
4295         const gchar *name;
4296         gchar *tweak_name;
4297         gboolean ret = FALSE;
4298         gboolean allow_tweaks;
4299
4300         g_debug("press %d %d", event->type, event->button);
4301         allow_tweaks = ghb_settings_get_boolean(ud->settings, "allow_tweaks");
4302         if (allow_tweaks && event->type == GDK_BUTTON_PRESS && event->button == 3)
4303         { // Its a right mouse click
4304                 GtkWidget *dialog;
4305                 GtkEntry *entry;
4306                 GtkResponseType response;
4307                 gchar *tweak = NULL;
4308
4309                 name = gtk_widget_get_name(widget);
4310                 if (g_str_has_prefix(name, "tweak_"))
4311                 {
4312                         tweak_name = g_strdup(name);
4313                 }
4314                 else
4315                 {
4316                         tweak_name = g_strdup_printf("tweak_%s", name);
4317                 }
4318
4319                 tweak = ghb_settings_get_string (ud->settings, tweak_name);
4320                 dialog = GHB_WIDGET(ud->builder, "tweak_dialog");
4321                 gtk_window_set_title(GTK_WINDOW(dialog), tweak_name);
4322                 entry = GTK_ENTRY(GHB_WIDGET(ud->builder, "tweak_setting"));
4323                 if (tweak)
4324                 {
4325                         gtk_entry_set_text(entry, tweak);
4326                         g_free(tweak);
4327                 }
4328                 response = gtk_dialog_run(GTK_DIALOG(dialog));
4329                 gtk_widget_hide(dialog);
4330                 if (response == GTK_RESPONSE_OK)
4331                 {
4332                         tweak = (gchar*)gtk_entry_get_text(entry);
4333                         if (ghb_validate_filter_string(tweak, -1))
4334                                 ghb_settings_set_string(ud->settings, tweak_name, tweak);
4335                         else
4336                         {
4337                                 gchar *message;
4338                                 message = g_strdup_printf(
4339                                                         "Invalid Settings:\n%s",
4340                                                         tweak);
4341                                 ghb_message_dialog(GTK_MESSAGE_ERROR, message, "Cancel", NULL);
4342                                 g_free(message);
4343                         }
4344                 }
4345                 g_free(tweak_name);
4346                 ret = TRUE;
4347         }
4348         return ret;
4349 }
4350
4351 G_MODULE_EXPORT gboolean
4352 easter_egg_cb(
4353         GtkWidget *widget,
4354         GdkEventButton *event,
4355         signal_user_data_t *ud)
4356 {
4357         g_debug("press %d %d", event->type, event->button);
4358         if (event->type == GDK_3BUTTON_PRESS && event->button == 1)
4359         { // Its a tripple left mouse button click
4360                 GtkWidget *widget;
4361                 widget = GHB_WIDGET(ud->builder, "allow_tweaks");
4362                 gtk_widget_show(widget);
4363                 widget = GHB_WIDGET(ud->builder, "hbfd_feature");
4364                 gtk_widget_show(widget);
4365         }
4366         else if (event->type == GDK_BUTTON_PRESS && event->button == 1)
4367         {
4368                 GtkWidget *widget;
4369                 widget = GHB_WIDGET(ud->builder, "allow_tweaks");
4370                 gtk_widget_hide(widget);
4371                 widget = GHB_WIDGET(ud->builder, "hbfd_feature");
4372                 gtk_widget_hide(widget);
4373         }
4374         return FALSE;
4375 }
4376
4377 G_MODULE_EXPORT gchar*
4378 format_deblock_cb(GtkScale *scale, gdouble val, signal_user_data_t *ud)
4379 {
4380         if (val < 5.0)
4381         {
4382                 return g_strdup_printf("Off");
4383         }
4384         else
4385         {
4386                 return g_strdup_printf("%d", (gint)val);
4387         }
4388 }
4389
4390 G_MODULE_EXPORT gchar*
4391 format_drc_cb(GtkScale *scale, gdouble val, signal_user_data_t *ud)
4392 {
4393         if (val <= 0.0)
4394         {
4395                 return g_strdup_printf("Off");
4396         }
4397         else
4398         {
4399                 return g_strdup_printf("%.1f", val);
4400         }
4401 }
4402
4403 G_MODULE_EXPORT gchar*
4404 format_vquality_cb(GtkScale *scale, gdouble val, signal_user_data_t *ud)
4405 {
4406         gdouble percent;
4407
4408         gint vcodec = ghb_settings_combo_int(ud->settings, "VideoEncoder");
4409         switch (vcodec)
4410         {
4411                 case HB_VCODEC_X264:
4412                 {
4413                         percent = 100. * (51 - val) / 51.;
4414                         return g_strdup_printf("RF: %.4g (%.0f%%)", val, percent);
4415                 } break;
4416
4417                 case HB_VCODEC_FFMPEG:
4418                 {
4419                         percent = 100. * (30 - (val - 1)) / 30.;
4420                         return g_strdup_printf("QP: %d (%.0f%%)", (int)val, percent);
4421                 } break;
4422
4423                 case HB_VCODEC_THEORA:
4424                 {
4425                         percent = 100. * val / 63.;
4426                         return g_strdup_printf("QP: %d (%.0f%%)", (int)val, percent);
4427                 } break;
4428
4429                 default:
4430                 {
4431                         percent = 0;
4432                 } break;
4433         }
4434         return g_strdup_printf("QP: %.1f / %.1f%%", val, percent);
4435 }
4436
4437 static void
4438 process_appcast(signal_user_data_t *ud)
4439 {
4440         gchar *description = NULL, *build = NULL, *version = NULL, *msg;
4441 #if !defined(_WIN32)
4442         GtkWidget *window;
4443         static GtkWidget *html = NULL;
4444 #endif
4445         GtkWidget *dialog, *label;
4446         gint    response, ibuild = 0, skip;
4447
4448         if (ud->appcast == NULL || ud->appcast_len < 15 ||
4449                 strncmp(&(ud->appcast[9]), "200 OK", 6))
4450         {
4451                 goto done;
4452         }
4453         ghb_appcast_parse(ud->appcast, &description, &build, &version);
4454         if (build)
4455                 ibuild = g_strtod(build, NULL);
4456         skip = ghb_settings_get_int(ud->settings, "update_skip_version");
4457         if (description == NULL || build == NULL || version == NULL
4458                 || ibuild <= hb_get_build(NULL) || skip == ibuild)
4459         {
4460                 goto done;
4461         }
4462         msg = g_strdup_printf("HandBrake %s/%s is now available (you have %s/%d).",
4463                         version, build, hb_get_version(NULL), hb_get_build(NULL));
4464         label = GHB_WIDGET(ud->builder, "update_message");
4465         gtk_label_set_text(GTK_LABEL(label), msg);
4466
4467 #if !defined(_WIN32)
4468         if (html == NULL)
4469         {
4470                 html = webkit_web_view_new();
4471                 window = GHB_WIDGET(ud->builder, "update_scroll");
4472                 gtk_container_add(GTK_CONTAINER(window), html);
4473                 // Show it
4474                 gtk_widget_set_size_request(html, 420, 240);
4475                 gtk_widget_show(html);
4476         }
4477         webkit_web_view_open(WEBKIT_WEB_VIEW(html), description);
4478 #endif
4479         dialog = GHB_WIDGET(ud->builder, "update_dialog");
4480         response = gtk_dialog_run(GTK_DIALOG(dialog));
4481         gtk_widget_hide(dialog);
4482         if (response == GTK_RESPONSE_OK)
4483         {
4484                 // Skip
4485                 ghb_settings_set_int(ud->settings, "update_skip_version", ibuild);
4486                 ghb_pref_save(ud->settings, "update_skip_version");
4487         }
4488         g_free(msg);
4489
4490 done:
4491         if (description) g_free(description);
4492         if (build) g_free(build);
4493         if (version) g_free(version);
4494         g_free(ud->appcast);
4495         ud->appcast_len = 0;
4496         ud->appcast = NULL;
4497         appcast_busy = FALSE;
4498 }
4499
4500 void
4501 ghb_net_close(GIOChannel *ioc)
4502 {
4503         gint fd;
4504
4505         g_debug("ghb_net_close");
4506         if (ioc == NULL) return;
4507         fd = g_io_channel_unix_get_fd(ioc);
4508         close(fd);
4509         g_io_channel_unref(ioc);
4510 }
4511
4512 G_MODULE_EXPORT gboolean
4513 ghb_net_recv_cb(GIOChannel *ioc, GIOCondition cond, gpointer data)
4514 {
4515         gchar buf[2048];
4516         gsize len;
4517         GError *gerror = NULL;
4518         GIOStatus status;
4519
4520         g_debug("ghb_net_recv_cb");
4521         signal_user_data_t *ud = (signal_user_data_t*)data;
4522
4523         status = g_io_channel_read_chars (ioc, buf, 2048, &len, &gerror);
4524         if ((status == G_IO_STATUS_NORMAL || status == G_IO_STATUS_EOF) &&
4525                 len > 0)
4526         {
4527                 gint new_len = ud->appcast_len + len;
4528                 ud->appcast = g_realloc(ud->appcast, new_len + 1);
4529                 memcpy(&(ud->appcast[ud->appcast_len]), buf, len);
4530                 ud->appcast_len = new_len;
4531         }
4532         if (status == G_IO_STATUS_EOF)
4533         {
4534                 ud->appcast[ud->appcast_len] = 0;
4535                 ghb_net_close(ioc);
4536                 process_appcast(ud);
4537                 return FALSE;
4538         }
4539         return TRUE;
4540 }
4541
4542 GIOChannel*
4543 ghb_net_open(signal_user_data_t *ud, gchar *address, gint port)
4544 {
4545         GIOChannel *ioc;
4546         gint fd;
4547
4548         struct sockaddr_in   sock;
4549         struct hostent     * host;
4550
4551         g_debug("ghb_net_open");
4552         if( !( host = gethostbyname( address ) ) )
4553         {
4554                 g_warning( "gethostbyname failed (%s)", address );
4555                 appcast_busy = FALSE;
4556                 return NULL;
4557         }
4558
4559         memset( &sock, 0, sizeof( struct sockaddr_in ) );
4560         sock.sin_family = host->h_addrtype;
4561         sock.sin_port   = htons( port );
4562         memcpy( &sock.sin_addr, host->h_addr, host->h_length );
4563
4564         fd = socket(host->h_addrtype, SOCK_STREAM, 0);
4565         if( fd < 0 )
4566         {
4567                 g_debug( "socket failed" );
4568                 appcast_busy = FALSE;
4569                 return NULL;
4570         }
4571
4572         if(connect(fd, (struct sockaddr*)&sock, sizeof(struct sockaddr_in )) < 0 )
4573         {
4574                 g_debug( "connect failed" );
4575                 appcast_busy = FALSE;
4576                 return NULL;
4577         }
4578         ioc = g_io_channel_unix_new(fd);
4579         g_io_channel_set_encoding (ioc, NULL, NULL);
4580         g_io_channel_set_flags(ioc, G_IO_FLAG_NONBLOCK, NULL);
4581         g_io_add_watch (ioc, G_IO_IN, ghb_net_recv_cb, (gpointer)ud );
4582
4583         return ioc;
4584 }
4585
4586 gpointer
4587 ghb_check_update(signal_user_data_t *ud)
4588 {
4589         gchar *query;
4590         gsize len;
4591         GIOChannel *ioc;
4592         GError *gerror = NULL;
4593         GRegex *regex;
4594         GMatchInfo *mi;
4595         gchar *host, *appcast;
4596
4597         g_debug("ghb_check_update");
4598         appcast_busy = TRUE;
4599         regex = g_regex_new("^http://(.+)/(.+)$", 0, 0, NULL);
4600         if (!g_regex_match(regex, HB_PROJECT_URL_APPCAST, 0, &mi))
4601         {
4602                 return NULL;
4603         }
4604
4605         host = g_match_info_fetch(mi, 1);
4606         appcast = g_match_info_fetch(mi, 2);
4607
4608         if (host == NULL || appcast == NULL)
4609                 return NULL;
4610
4611         query = g_strdup_printf( "GET /%s HTTP/1.0\r\nHost: %s\r\n\r\n",
4612                                                         appcast, host);
4613
4614         ioc = ghb_net_open(ud, host, 80);
4615         if (ioc == NULL)
4616                 return NULL;
4617
4618         g_io_channel_write_chars(ioc, query, strlen(query), &len, &gerror);
4619         g_io_channel_flush(ioc, &gerror);
4620         g_free(query);
4621         g_free(host);
4622         g_free(appcast);
4623         g_match_info_free(mi);
4624         g_regex_unref(regex);
4625         return NULL;
4626 }
4627
4628 G_MODULE_EXPORT gboolean
4629 hb_visibility_event_cb(
4630         GtkWidget *widget,
4631         GdkEventVisibility *vs,
4632         signal_user_data_t *ud)
4633 {
4634         ud->hb_visibility = vs->state;
4635         return FALSE;
4636 }
4637
4638 G_MODULE_EXPORT void
4639 status_activate_cb(GtkStatusIcon *si, signal_user_data_t *ud)
4640 {
4641         GtkWindow *window;
4642         GdkWindowState state;
4643
4644         window = GTK_WINDOW(GHB_WIDGET(ud->builder, "hb_window"));
4645         state = gdk_window_get_state(GTK_WIDGET(window)->window);
4646         if ((state & GDK_WINDOW_STATE_ICONIFIED) ||
4647                 (ud->hb_visibility != GDK_VISIBILITY_UNOBSCURED))
4648         {
4649                 gtk_window_present(window);
4650                 gtk_window_set_skip_taskbar_hint(window, FALSE);
4651         }
4652         else
4653         {
4654                 gtk_window_set_skip_taskbar_hint(window, TRUE);
4655                 gtk_window_iconify(window);
4656         }
4657 }
4658
4659 #if !defined(_WIN32)
4660 G_MODULE_EXPORT void
4661 notify_closed_cb(NotifyNotification *notification, signal_user_data_t *ud)
4662 {
4663         g_object_unref(G_OBJECT(notification));
4664 }
4665 #endif
4666
4667 void
4668 ghb_notify_done(signal_user_data_t *ud)
4669 {
4670         GtkStatusIcon *si;
4671
4672         if (ghb_settings_combo_int(ud->settings, "WhenComplete") == 0)
4673                 return;
4674
4675         si = GTK_STATUS_ICON(GHB_OBJECT(ud->builder, "hb_status"));
4676
4677 #if !defined(_WIN32)
4678         NotifyNotification *notification;
4679         notification = notify_notification_new(
4680                 "Encode Complete",
4681                 "Put down that cocktail, Your HandBrake queue is done!",
4682                 "hb-icon",
4683                 NULL);
4684         notify_notification_attach_to_status_icon(notification, si);
4685         g_signal_connect(notification, "closed", (GCallback)notify_closed_cb, ud);
4686         notify_notification_show(notification, NULL);
4687 #endif
4688
4689         if (ghb_settings_combo_int(ud->settings, "WhenComplete") == 3)
4690         {
4691                 if (ghb_can_shutdown_gsm())
4692                 {
4693                         ghb_countdown_dialog(GTK_MESSAGE_WARNING,
4694                                 "Your encode is complete.",
4695                                 "Shutting down the computer",
4696                                 "Cancel", (GSourceFunc)shutdown_cb, 60);
4697                 }
4698         }
4699         if (ghb_settings_combo_int(ud->settings, "WhenComplete") == 2)
4700         {
4701                 if (ghb_can_suspend_gpm())
4702                 {
4703                         ghb_countdown_dialog(GTK_MESSAGE_WARNING,
4704                                 "Your encode is complete.",
4705                                 "Putting computer to sleep",
4706                                 "Cancel", (GSourceFunc)suspend_cb, 60);
4707                 }
4708         }
4709 }