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