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 <poll.h>
  20 #include <fcntl.h>
  21 #include <sys/stat.h>
  22 #include <netinet/in.h>
  23 #include <netdb.h>
  24 #include <libhal-storage.h>
  25 #include <gtk/gtk.h>
  26 #include <gtkhtml/gtkhtml.h>
  27 #include <gdk/gdkkeysyms.h>
  28 #include <glib/gstdio.h>
  29 #include <gio/gio.h>
  30
  31 #include "hb.h"
  32 #include "callbacks.h"
  33 #include "queuehandler.h"
  34 #include "audiohandler.h"
  35 #include "resources.h"
  36 #include "settings.h"
  37 #include "presets.h"
  38 #include "preview.h"
  39 #include "values.h"
  40 #include "plist.h"
  41 #include "appcast.h"
  42 #include "hb-backend.h"
  43 #include "ghb-dvd.h"
  44 #include "ghbcellrenderertext.h"
  45
  46 static void update_chapter_list(signal_user_data_t *ud);
  47 static GList* dvd_device_list();
  48 static void prune_logs(signal_user_data_t *ud);
  49
  50 // This is a dependency map used for greying widgets
  51 // that are dependent on the state of another widget.
  52 // The enable_value comes from the values that are
  53 // obtained from ghb_widget_value().  For combo boxes
  54 // you will have to look further to combo box options
  55 // maps in hb-backend.c
  56
  57 GValue *dep_map;
  58 GValue *rev_map;
  59
  60 void
  61 ghb_init_dep_map()
  62 {
  63         dep_map = ghb_resource_get("widget-deps");
  64         rev_map = ghb_resource_get("widget-reverse-deps");
  65 }
  66
  67 static gboolean
  68 dep_check(signal_user_data_t *ud, const gchar *name)
  69 {
  70         GtkWidget *widget;
  71         GObject *dep_object;
  72         gint ii;
  73         gint count;
  74         gboolean result = TRUE;
  75         GValue *array, *data;
  76         gchar *widget_name;
  77
  78         g_debug("dep_check () %s", name);
  79
  80         array = ghb_dict_lookup(rev_map, name);
  81         count = ghb_array_len(array);
  82         for (ii = 0; ii < count; ii++)
  83         {
  84                 data = ghb_array_get_nth(array, ii);
  85                 widget_name = ghb_value_string(ghb_array_get_nth(data, 0));
  86                 widget = GHB_WIDGET(ud->builder, widget_name);
  87                 dep_object = gtk_builder_get_object(ud->builder, name);
  88                 g_free(widget_name);
  89                 if (dep_object == NULL)
  90                 {
  91                         g_message("Failed to find widget");
  92                 }
  93                 else
  94                 {
  95                         gchar *value;
  96                         gint jj = 0;
  97                         gchar **values;
  98                         gboolean sensitive = FALSE;
  99                         gboolean die;
 100
 101                         die = ghb_value_boolean(ghb_array_get_nth(data, 2));
 102                         value = ghb_value_string(ghb_array_get_nth(data, 1));
 103                         values = g_strsplit(value, "|", 10);
 104                         g_free(value);
 105
 106                         if (widget)
 107                                 value = ghb_widget_string(widget);
 108                         else
 109                                 value = ghb_settings_get_string(ud->settings, name);
 110                         while (values && values[jj])
 111                         {
 112                                 if (values[jj][0] == '>')
 113                                 {
 114                                         gdouble dbl = g_strtod (&values[jj][1], NULL);
 115                                         gdouble dvalue = ghb_widget_double(widget);
 116                                         if (dvalue > dbl)
 117                                         {
 118                                                 sensitive = TRUE;
 119                                                 break;
 120                                         }
 121                                 }
 122                                 else if (values[jj][0] == '<')
 123                                 {
 124                                         gdouble dbl = g_strtod (&values[jj][1], NULL);
 125                                         gdouble dvalue = ghb_widget_double(widget);
 126                                         if (dvalue < dbl)
 127                                         {
 128                                                 sensitive = TRUE;
 129                                                 break;
 130                                         }
 131                                 }
 132                                 if (strcmp(values[jj], value) == 0)
 133                                 {
 134                                         sensitive = TRUE;
 135                                         break;
 136                                 }
 137                                 jj++;
 138                         }
 139                         sensitive = die ^ sensitive;
 140                         if (!sensitive) result = FALSE;
 141                         g_strfreev (values);
 142                         g_free(value);
 143                 }
 144         }
 145         return result;
 146 }
 147
 148 void
 149 ghb_check_dependency(signal_user_data_t *ud, GtkWidget *widget)
 150 {
 151         GObject *dep_object;
 152         const gchar *name;
 153         GValue *array, *data;
 154         gint count, ii;
 155         gchar *dep_name;
 156         GType type;
 157
 158         type = GTK_WIDGET_TYPE(widget);
 159         if (type == GTK_TYPE_COMBO_BOX || type == GTK_TYPE_COMBO_BOX_ENTRY)
 160                 if (gtk_combo_box_get_active(GTK_COMBO_BOX(widget)) < 0) return;
 161
 162         name = gtk_widget_get_name(widget);
 163         g_debug("ghb_check_dependency () %s", name);
 164
 165         array = ghb_dict_lookup(dep_map, name);
 166         count = ghb_array_len(array);
 167         for (ii = 0; ii < count; ii++)
 168         {
 169                 gboolean sensitive;
 170
 171                 data = ghb_array_get_nth(array, ii);
 172                 dep_name = ghb_value_string(data);
 173                 dep_object = gtk_builder_get_object(ud->builder, dep_name);
 174                 if (dep_object == NULL)
 175                 {
 176                         g_message("Failed to find dependent widget %s", dep_name);
 177                         g_free(dep_name);
 178                         continue;
 179                 }
 180                 sensitive = dep_check(ud, dep_name);
 181                 g_free(dep_name);
 182                 if (GTK_IS_ACTION(dep_object))
 183                         gtk_action_set_sensitive(GTK_ACTION(dep_object), sensitive);
 184                 else
 185                         gtk_widget_set_sensitive(GTK_WIDGET(dep_object), sensitive);
 186         }
 187 }
 188
 189 void
 190 ghb_check_all_depencencies(signal_user_data_t *ud)
 191 {
 192         GHashTableIter iter;
 193         gchar *dep_name;
 194         GValue *value;
 195         GObject *dep_object;
 196
 197         g_debug("ghb_check_all_depencencies ()");
 198         ghb_dict_iter_init(&iter, rev_map);
 199         // middle (void*) cast prevents gcc warning "defreferencing type-punned
 200         // pointer will break strict-aliasing rules"
 201         while (g_hash_table_iter_next(
 202                         &iter, (gpointer*)(void*)&dep_name, (gpointer*)(void*)&value))
 203         {
 204                 gboolean sensitive;
 205                 dep_object = gtk_builder_get_object (ud->builder, dep_name);
 206                 if (dep_object == NULL)
 207                 {
 208                         g_message("Failed to find dependent widget %s", dep_name);
 209                         continue;
 210                 }
 211                 sensitive = dep_check(ud, dep_name);
 212                 if (GTK_IS_ACTION(dep_object))
 213                         gtk_action_set_sensitive(GTK_ACTION(dep_object), sensitive);
 214                 else
 215                         gtk_widget_set_sensitive(GTK_WIDGET(dep_object), sensitive);
 216         }
 217 }
 218
 219 void
 220 on_quit1_activate(GtkMenuItem *quit, signal_user_data_t *ud)
 221 {
 222         gint state = ghb_get_queue_state();
 223         g_debug("on_quit1_activate ()");
 224         if (state & GHB_STATE_WORKING)
 225         {
 226                 if (ghb_cancel_encode("Closing HandBrake will terminate encoding.\n"))
 227                 {
 228                         ghb_hb_cleanup(FALSE);
 229                         prune_logs(ud);
 230                         gtk_main_quit();
 231                         return;
 232                 }
 233                 return;
 234         }
 235         ghb_hb_cleanup(FALSE);
 236         prune_logs(ud);
 237         gtk_main_quit();
 238 }
 239
 240 static void
 241 set_destination(signal_user_data_t *ud)
 242 {
 243         g_debug("set_destination");
 244         if (ghb_settings_get_boolean(ud->settings, "use_source_name"))
 245         {
 246                 gchar *vol_name, *filename, *extension;
 247                 gchar *new_name;
 248
 249                 filename = ghb_settings_get_string(ud->settings, "dest_file");
 250                 extension = ghb_settings_get_string(ud->settings, "FileFormat");
 251                 vol_name = ghb_settings_get_string(ud->settings, "volume_label");
 252                 if (ghb_settings_get_boolean(ud->settings, "chapters_in_destination"))
 253                 {
 254                         gint start, end;
 255
 256                         start = ghb_settings_get_int(ud->settings, "start_chapter");
 257                         end = ghb_settings_get_int(ud->settings, "end_chapter");
 258                         if (start == end)
 259                         {
 260                                 new_name = g_strdup_printf("%s-%d.%s",
 261                                         vol_name, start, extension);
 262                         }
 263                         else
 264                         {
 265                                 new_name = g_strdup_printf("%s-%d-%d.%s",
 266                                         vol_name, start, end, extension);
 267                         }
 268                 }
 269                 else
 270                 {
 271                         new_name = g_strdup_printf("%s.%s", vol_name, extension);
 272                 }
 273                 ghb_ui_update(ud, "dest_file", ghb_string_value(new_name));
 274                 g_free(filename);
 275                 g_free(extension);
 276                 g_free(vol_name);
 277                 g_free(new_name);
 278         }
 279 }
 280
 281 gboolean
 282 uppers_and_unders(const gchar *str)
 283 {
 284         if (str == NULL) return FALSE;
 285         while (*str)
 286         {
 287                 if (*str == ' ')
 288                 {
 289                         return FALSE;
 290                 }
 291                 if (*str >= 'a' && *str <= 'z')
 292                 {
 293                         return FALSE;
 294                 }
 295                 str++;
 296         }
 297         return TRUE;
 298 }
 299
 300 enum
 301 {
 302         CAMEL_FIRST_UPPER,
 303         CAMEL_OTHER
 304 };
 305
 306 void
 307 camel_convert(gchar *str)
 308 {
 309         gint state = CAMEL_OTHER;
 310
 311         if (str == NULL) return;
 312         while (*str)
 313         {
 314                 if (*str == '_') *str = ' ';
 315                 switch (state)
 316                 {
 317                         case CAMEL_OTHER:
 318                         {
 319                                 if (*str >= 'A' && *str <= 'Z')
 320                                         state = CAMEL_FIRST_UPPER;
 321                                 else
 322                                         state = CAMEL_OTHER;
 323
 324                         } break;
 325                         case CAMEL_FIRST_UPPER:
 326                         {
 327                                 if (*str >= 'A' && *str <= 'Z')
 328                                         *str = *str - 'A' + 'a';
 329                                 else
 330                                         state = CAMEL_OTHER;
 331                         } break;
 332                 }
 333                 str++;
 334         }
 335 }
 336
 337 static gchar*
 338 get_file_label(const gchar *filename)
 339 {
 340         static gchar *containers[] =
 341                 {".vob", ".mpg", ".m2ts", ".mkv", ".mp4", ".m4v", ".avi", ".ogm", NULL};
 342         gchar *base;
 343         gint ii;
 344
 345         base = g_path_get_basename(filename);
 346         for (ii = 0; containers[ii] != NULL; ii++)
 347         {
 348                 if (g_str_has_suffix(base, containers[ii]))
 349                 {
 350                         gchar *pos;
 351                         pos = strrchr(base, '.');
 352                         *pos = 0;
 353                         break;
 354                 }
 355         }
 356         return base;
 357 }
 358
 359 static gboolean
 360 update_source_label(signal_user_data_t *ud, const gchar *source)
 361 {
 362         gchar *label = NULL;
 363         gint len;
 364         gchar **path;
 365         gchar *filename = g_strdup(source);
 366
 367         len = strlen(filename);
 368         if (filename[len-1] == '/') filename[len-1] = 0;
 369         if (g_file_test(filename, G_FILE_TEST_IS_DIR))
 370         {
 371                 path = g_strsplit(filename, "/", -1);
 372                 len = g_strv_length (path);
 373                 if ((len > 1) && (strcmp("VIDEO_TS", path[len-1]) == 0))
 374                 {
 375                         label = g_strdup(path[len-2]);
 376                 }
 377                 else
 378                 {
 379                         label = g_strdup(path[len-1]);
 380                 }
 381                 g_strfreev (path);
 382         }
 383         else
 384         {
 385                 // Is regular file or block dev.
 386                 // Check to see if it is a dvd image
 387                 label = ghb_dvd_volname (filename);
 388                 if (label == NULL)
 389                 {
 390                         label = get_file_label(filename);
 391                 }
 392                 else
 393                 {
 394                         if (uppers_and_unders(label))
 395                         {
 396                                 camel_convert(label);
 397                         }
 398                 }
 399         }
 400         g_free(filename);
 401         GtkWidget *widget = GHB_WIDGET (ud->builder, "source_title");
 402         if (label != NULL)
 403         {
 404                 gtk_label_set_text (GTK_LABEL(widget), label);
 405                 ghb_settings_set_string(ud->settings, "volume_label", label);
 406                 g_free(label);
 407                 set_destination(ud);
 408         }
 409         else
 410         {
 411                 label = "No Title Found";
 412                 gtk_label_set_text (GTK_LABEL(widget), label);
 413                 ghb_settings_set_string(ud->settings, "volume_label", label);
 414                 return FALSE;
 415         }
 416         return TRUE;
 417 }
 418
 419 static GtkWidget *dvd_device_combo = NULL;
 420
 421 void
 422 chooser_file_selected_cb(GtkFileChooser *dialog, GtkComboBox *combo)
 423 {
 424         const gchar *name = gtk_file_chooser_get_filename (dialog);
 425         GtkTreeModel *store;
 426         GtkTreeIter iter;
 427         const gchar *device;
 428         gboolean foundit = FALSE;
 429
 430         if (name == NULL) return;
 431         store = gtk_combo_box_get_model(combo);
 432         if (gtk_tree_model_get_iter_first(store, &iter))
 433         {
 434                 do
 435                 {
 436                         gtk_tree_model_get(store, &iter, 0, &device, -1);
 437                         if (strcmp(name, device) == 0)
 438                         {
 439                                 foundit = TRUE;
 440                                 break;
 441                         }
 442                 } while (gtk_tree_model_iter_next(GTK_TREE_MODEL(store), &iter));
 443         }
 444         if (foundit)
 445                 gtk_combo_box_set_active_iter (combo, &iter);
 446         else
 447                 gtk_combo_box_set_active (combo, 0);
 448 }
 449
 450 void
 451 dvd_device_changed_cb(GtkComboBox *combo, GtkWidget *dialog)
 452 {
 453         gint ii = gtk_combo_box_get_active (combo);
 454         if (ii != 0)
 455         {
 456                 const gchar *device = gtk_combo_box_get_active_text (combo);
 457                 const gchar *name = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER(dialog));
 458                 if (name == NULL || strcmp(name, device) != 0)
 459                         gtk_file_chooser_select_filename (GTK_FILE_CHOOSER(dialog), device);
 460         }
 461 }
 462
 463 void
 464 source_type_changed_cb(GtkToggleButton *toggle, GtkFileChooser *chooser)
 465 {
 466         gchar *folder;
 467
 468         g_debug("source_type_changed_cb ()");
 469         folder = gtk_file_chooser_get_current_folder (chooser);
 470         if (gtk_toggle_button_get_active (toggle))
 471         {
 472                 gtk_file_chooser_set_action (chooser, GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER);
 473                 gtk_widget_set_sensitive (dvd_device_combo, FALSE);
 474                 gtk_combo_box_set_active (GTK_COMBO_BOX(dvd_device_combo), 0);
 475         }
 476         else
 477         {
 478                 gtk_file_chooser_set_action (chooser, GTK_FILE_CHOOSER_ACTION_OPEN);
 479                 gtk_widget_set_sensitive (dvd_device_combo, TRUE);
 480         }
 481         if (folder != NULL)
 482         {
 483                 gtk_file_chooser_set_current_folder(chooser, folder);
 484                 g_free(folder);
 485         }
 486 }
 487
 488 static GtkWidget*
 489 source_dialog_extra_widgets(GtkWidget *dialog, gboolean checkbutton_active)
 490 {
 491         GtkBox *vbox;
 492         GtkWidget *checkbutton;
 493
 494         vbox = GTK_BOX(gtk_vbox_new (FALSE, 2));
 495         checkbutton = gtk_check_button_new_with_label ("Open VIDEO_TS folder");
 496         gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(checkbutton), checkbutton_active);
 497         gtk_box_pack_start (vbox, checkbutton, FALSE, FALSE, 1);
 498         gtk_widget_show(checkbutton);
 499
 500         GtkWidget *combo;
 501         GtkBox *hbox;
 502         GList *drives, *link;
 503         GtkWidget *label, *blank;
 504
 505         hbox = GTK_BOX(gtk_hbox_new (FALSE, 2));
 506         combo = gtk_combo_box_new_text();
 507         label = gtk_label_new("Detected DVD devices:");
 508         blank = gtk_label_new("");
 509         link = drives = dvd_device_list();
 510         gtk_combo_box_append_text (GTK_COMBO_BOX(combo), "Not Selected");
 511         while (link != NULL)
 512         {
 513                 gchar *name = (gchar*)link->data;
 514                 gtk_combo_box_append_text (GTK_COMBO_BOX(combo), name);
 515                 g_free(name);
 516                 link = link->next;
 517         }
 518         g_list_free(drives);
 519         gtk_combo_box_set_active (GTK_COMBO_BOX(combo), 0);
 520         gtk_box_pack_start (vbox, GTK_WIDGET(hbox), FALSE, FALSE, 1);
 521         gtk_widget_show(GTK_WIDGET(hbox));
 522         gtk_box_pack_start (hbox, label, FALSE, FALSE, 1);
 523         gtk_widget_show(label);
 524         gtk_box_pack_start (hbox, combo, FALSE, FALSE, 2);
 525         gtk_widget_show(combo);
 526         gtk_box_pack_start (hbox, blank, TRUE, TRUE, 1);
 527         gtk_widget_show(blank);
 528
 529         // Ugly hackish global alert
 530         dvd_device_combo = combo;
 531         g_signal_connect(combo, "changed", (GCallback)dvd_device_changed_cb, dialog);
 532         g_signal_connect(dialog, "selection-changed", (GCallback)chooser_file_selected_cb, combo);
 533
 534         g_signal_connect(checkbutton, "toggled", (GCallback)source_type_changed_cb, dialog);
 535         return GTK_WIDGET(vbox);
 536 }
 537
 538 extern GValue *ghb_queue_edit_settings;
 539 static gchar *last_scan_file = NULL;
 540
 541 void
 542 ghb_do_scan(signal_user_data_t *ud, const gchar *filename, gboolean force)
 543 {
 544         if (!force && last_scan_file != NULL &&
 545                 strcmp(last_scan_file, filename) == 0)
 546         {
 547                 if (ghb_queue_edit_settings)
 548                 {
 549                         gint jstatus;
 550
 551                         jstatus = ghb_settings_get_int(ghb_queue_edit_settings, "job_status");
 552                         ghb_settings_to_ui(ud, ghb_queue_edit_settings);
 553                         ghb_set_audio(ud, ghb_queue_edit_settings);
 554                         if (jstatus == GHB_QUEUE_PENDING)
 555                         {
 556                                 ghb_value_free(ghb_queue_edit_settings);
 557                         }
 558                         ghb_queue_edit_settings = NULL;
 559                 }
 560                 return;
 561         }
 562         if (last_scan_file != NULL)
 563                 g_free(last_scan_file);
 564         last_scan_file = NULL;
 565         if (filename != NULL)
 566         {
 567                 last_scan_file = g_strdup(filename);
 568                 ghb_settings_set_string(ud->settings, "source", filename);
 569                 if (update_source_label(ud, filename))
 570                 {
 571                         GtkProgressBar *progress;
 572                         progress = GTK_PROGRESS_BAR(GHB_WIDGET(ud->builder, "progressbar"));
 573                         gchar *path;
 574                         path = ghb_settings_get_string( ud->settings, "source");
 575                         gtk_progress_bar_set_fraction (progress, 0);
 576                         gtk_progress_bar_set_text (progress, "Scanning ...");
 577                         ghb_hb_cleanup(TRUE);
 578                         prune_logs(ud);
 579                         ghb_backend_scan (path, 0);
 580                         g_free(path);
 581                 }
 582                 else
 583                 {
 584                         // TODO: error dialog
 585                 }
 586         }
 587 }
 588
 589 void
 590 source_button_clicked_cb(GtkButton *button, signal_user_data_t *ud)
 591 {
 592         GtkWidget *dialog;
 593         GtkWidget *widget;
 594         gchar *sourcename;
 595         gint    response;
 596         GtkFileChooserAction action;
 597         gboolean checkbutton_active;
 598
 599         g_debug("source_browse_clicked_cb ()");
 600         sourcename = ghb_settings_get_string(ud->settings, "source");
 601         checkbutton_active = FALSE;
 602         if (g_file_test(sourcename, G_FILE_TEST_IS_DIR))
 603         {
 604                 action = GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER;
 605                 checkbutton_active = TRUE;
 606         }
 607         else
 608         {
 609                 action = GTK_FILE_CHOOSER_ACTION_OPEN;
 610         }
 611         dialog = gtk_file_chooser_dialog_new ("Select Source",
 612                                                                 NULL,
 613                                                                 action,
 614                                                                 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
 615                                                                 GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
 616                                                                 NULL);
 617         widget = source_dialog_extra_widgets(dialog, checkbutton_active);
 618         gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER(dialog), widget);
 619         gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(dialog), sourcename);
 620         response = gtk_dialog_run(GTK_DIALOG (dialog));
 621         gtk_widget_hide(dialog);
 622         if (response == GTK_RESPONSE_ACCEPT)
 623         {
 624                 char *filename;
 625
 626                 filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
 627                 if (filename != NULL)
 628                 {
 629                         ghb_do_scan(ud, filename, TRUE);
 630                         if (strcmp(sourcename, filename) != 0)
 631                         {
 632                                 ghb_settings_set_string (ud->settings, "default_source", filename);
 633                                 ghb_pref_save (ud->settings, "default_source");
 634                                 ghb_dvd_set_current (filename, ud);
 635                         }
 636                         g_free(filename);
 637                 }
 638         }
 639         g_free(sourcename);
 640         gtk_widget_destroy(dialog);
 641 }
 642
 643 void
 644 dvd_source_activate_cb(GtkAction *action, signal_user_data_t *ud)
 645 {
 646         const gchar *filename;
 647         gchar *sourcename;
 648
 649         sourcename = ghb_settings_get_string(ud->settings, "source");
 650         filename = gtk_action_get_name(action);
 651         ghb_do_scan(ud, filename, TRUE);
 652         if (strcmp(sourcename, filename) != 0)
 653         {
 654                 ghb_settings_set_string (ud->settings, "default_source", filename);
 655                 ghb_pref_save (ud->settings, "default_source");
 656                 ghb_dvd_set_current (filename, ud);
 657         }
 658         g_free(sourcename);
 659 }
 660
 661 static void
 662 update_destination_extension(signal_user_data_t *ud)
 663 {
 664         static gchar *containers[] = {".mkv", ".mp4", ".m4v", ".avi", ".ogm", NULL};
 665         gchar *filename;
 666         gchar *extension;
 667         gint ii;
 668         GtkEntry *entry;
 669
 670         g_debug("update_destination_extension ()");
 671         extension = ghb_settings_get_string(ud->settings, "FileFormat");
 672         entry = GTK_ENTRY(GHB_WIDGET(ud->builder, "dest_file"));
 673         filename = g_strdup(gtk_entry_get_text(entry));
 674         for (ii = 0; containers[ii] != NULL; ii++)
 675         {
 676                 if (g_str_has_suffix(filename, containers[ii]))
 677                 {
 678                         gchar *pos;
 679                         gchar *new_name;
 680
 681                         pos = g_strrstr( filename, "." );
 682                         if (pos == NULL)
 683                         {
 684                                 // No period? shouldn't happen
 685                                 break;
 686                         }
 687                         *pos = 0;
 688                         if (strcmp(extension, &pos[1]) == 0)
 689                         {
 690                                 // Extension is already correct
 691                                 break;
 692                         }
 693                         new_name = g_strjoin(".", filename, extension, NULL);
 694                         ghb_ui_update(ud, "dest_file", ghb_string_value(new_name));
 695                         g_free(new_name);
 696                         break;
 697                 }
 698         }
 699         g_free(extension);
 700         g_free(filename);
 701 }
 702
 703 static void
 704 destination_select_title(GtkEntry *entry)
 705 {
 706         const gchar *dest;
 707         gint start, end;
 708
 709         dest = gtk_entry_get_text(entry);
 710         for (end = strlen(dest)-1; end > 0; end--)
 711         {
 712                 if (dest[end] == '.')
 713                 {
 714                         break;
 715                 }
 716         }
 717         for (start = end; start >= 0; start--)
 718         {
 719                 if (dest[start] == '/')
 720                 {
 721                         start++;
 722                         break;
 723                 }
 724         }
 725         if (start < 0) start = 0;
 726         if (start < end)
 727         {
 728                 gtk_editable_select_region(GTK_EDITABLE(entry), start, end);
 729         }
 730 }
 731
 732 gboolean
 733 destination_grab_cb(
 734         GtkEntry *entry,
 735         signal_user_data_t *ud)
 736 {
 737         destination_select_title(entry);
 738         return FALSE;
 739 }
 740
 741 static gboolean update_default_destination = FALSE;
 742
 743 void
 744 dest_dir_set_cb(GtkFileChooserButton *dest_chooser, signal_user_data_t *ud)
 745 {
 746         gchar *dest_file, *dest_dir, *dest;
 747
 748         g_debug("dest_dir_set_cb ()");
 749         ghb_widget_to_setting(ud->settings, (GtkWidget*)dest_chooser);
 750         dest_file = ghb_settings_get_string(ud->settings, "dest_file");
 751         dest_dir = ghb_settings_get_string(ud->settings, "dest_dir");
 752         dest = g_strdup_printf("%s/%s", dest_dir, dest_file);
 753         ghb_settings_set_string(ud->settings, "destination", dest);
 754         g_free(dest_file);
 755         g_free(dest_dir);
 756         g_free(dest);
 757         update_default_destination = TRUE;
 758 }
 759
 760 void
 761 dest_file_changed_cb(GtkEntry *entry, signal_user_data_t *ud)
 762 {
 763         gchar *dest_file, *dest_dir, *dest;
 764
 765         g_debug("dest_file_changed_cb ()");
 766         update_destination_extension(ud);
 767         ghb_widget_to_setting(ud->settings, (GtkWidget*)entry);
 768         // This signal goes off with ever keystroke, so I'm putting this
 769         // update on the timer.
 770         dest_file = ghb_settings_get_string(ud->settings, "dest_file");
 771         dest_dir = ghb_settings_get_string(ud->settings, "dest_dir");
 772         dest = g_strdup_printf("%s/%s", dest_dir, dest_file);
 773         ghb_settings_set_string(ud->settings, "destination", dest);
 774         g_free(dest_file);
 775         g_free(dest_dir);
 776         g_free(dest);
 777         update_default_destination = TRUE;
 778 }
 779
 780 void
 781 destination_browse_clicked_cb(GtkButton *button, signal_user_data_t *ud)
 782 {
 783         GtkWidget *dialog;
 784         GtkEntry *entry;
 785         gchar *destname;
 786         gchar *basename;
 787
 788         g_debug("destination_browse_clicked_cb ()");
 789         destname = ghb_settings_get_string(ud->settings, "destination");
 790         dialog = gtk_file_chooser_dialog_new ("Choose Destination",
 791                                           NULL,
 792                                           GTK_FILE_CHOOSER_ACTION_SAVE,
 793                                           GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
 794                                           GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
 795                                           NULL);
 796         gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(dialog), destname);
 797         basename = g_path_get_basename(destname);
 798         g_free(destname);
 799         gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog), basename);
 800         g_free(basename);
 801         if (gtk_dialog_run(GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT)
 802         {
 803                 char *filename, *dirname;
 804                 GtkFileChooser *dest_chooser;
 805
 806                 filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
 807                 basename = g_path_get_basename(filename);
 808                 dirname = g_path_get_dirname(filename);
 809                 entry = (GtkEntry*)GHB_WIDGET(ud->builder, "dest_file");
 810                 gtk_entry_set_text(entry, basename);
 811                 dest_chooser = GTK_FILE_CHOOSER(GHB_WIDGET(ud->builder, "dest_dir"));
 812                 gtk_file_chooser_set_filename(dest_chooser, dirname);
 813                 g_free (dirname);
 814                 g_free (basename);
 815                 g_free (filename);
 816         }
 817         gtk_widget_destroy(dialog);
 818 }
 819
 820 gboolean
 821 window_destroy_event_cb(GtkWidget *widget, GdkEvent *event, signal_user_data_t *ud)
 822 {
 823         g_debug("window_destroy_event_cb ()");
 824         ghb_hb_cleanup(FALSE);
 825         prune_logs(ud);
 826         gtk_main_quit();
 827         return FALSE;
 828 }
 829
 830 gboolean
 831 window_delete_event_cb(GtkWidget *widget, GdkEvent *event, signal_user_data_t *ud)
 832 {
 833         gint state = ghb_get_queue_state();
 834         g_debug("window_delete_event_cb ()");
 835         if (state & GHB_STATE_WORKING)
 836         {
 837                 if (ghb_cancel_encode("Closing HandBrake will terminate encoding.\n"))
 838                 {
 839                         ghb_hb_cleanup(FALSE);
 840                         prune_logs(ud);
 841                         gtk_main_quit();
 842                         return FALSE;
 843                 }
 844                 return TRUE;
 845         }
 846         ghb_hb_cleanup(FALSE);
 847         prune_logs(ud);
 848         gtk_main_quit();
 849         return FALSE;
 850 }
 851
 852 static void
 853 update_acodec_combo(signal_user_data_t *ud)
 854 {
 855         ghb_grey_combo_options (ud->builder);
 856 }
 857
 858 void
 859 container_changed_cb(GtkWidget *widget, signal_user_data_t *ud)
 860 {
 861         const GValue *audio_list;
 862         g_debug("container_changed_cb ()");
 863         ghb_widget_to_setting(ud->settings, widget);
 864         update_destination_extension(ud);
 865         ghb_check_dependency(ud, widget);
 866         update_acodec_combo(ud);
 867         ghb_clear_presets_selection(ud);
 868         ghb_live_reset(ud);
 869
 870         audio_list = ghb_settings_get_value(ud->settings, "audio_list");
 871         if (ghb_ac3_in_audio_list (audio_list))
 872         {
 873                 gchar *container;
 874
 875                 container = ghb_settings_get_string(ud->settings, "FileFormat");
 876                 if (strcmp(container, "mp4") == 0)
 877                 {
 878                         ghb_ui_update(ud, "FileFormat", ghb_string_value("m4v"));
 879                 }
 880                 g_free(container);
 881         }
 882 }
 883
 884 static gchar*
 885 get_aspect_string(gint aspect_n, gint aspect_d)
 886 {
 887         gchar *aspect;
 888
 889         if (aspect_d < 10)
 890         {
 891                 aspect = g_strdup_printf("%d:%d", aspect_n, aspect_d);
 892         }
 893         else
 894         {
 895                 gdouble aspect_nf = (gdouble)aspect_n / aspect_d;
 896                 aspect = g_strdup_printf("%.2f:1", aspect_nf);
 897         }
 898         return aspect;
 899 }
 900
 901 static gchar*
 902 get_rate_string(gint rate_base, gint rate)
 903 {
 904         gdouble rate_f = (gdouble)rate / rate_base;
 905         gchar *rate_s;
 906
 907         rate_s = g_strdup_printf("%.6g", rate_f);
 908         return rate_s;
 909 }
 910 static void
 911 show_title_info(signal_user_data_t *ud, ghb_title_info_t *tinfo)
 912 {
 913         GtkWidget *widget;
 914         gchar *text;
 915
 916         widget = GHB_WIDGET (ud->builder, "title_duration");
 917         if (tinfo->duration != 0)
 918         {
 919                 text = g_strdup_printf ("%02d:%02d:%02d", tinfo->hours,
 920                                 tinfo->minutes, tinfo->seconds);
 921         }
 922         else
 923         {
 924                 text = g_strdup_printf ("Unknown");
 925         }
 926         gtk_label_set_text (GTK_LABEL(widget), text);
 927         g_free(text);
 928         widget = GHB_WIDGET (ud->builder, "source_dimensions");
 929         text = g_strdup_printf ("%d x %d", tinfo->width, tinfo->height);
 930         gtk_label_set_text (GTK_LABEL(widget), text);
 931         ghb_settings_set_int(ud->settings, "source_width", tinfo->width);
 932         ghb_settings_set_int(ud->settings, "source_height", tinfo->height);
 933         g_free(text);
 934         widget = GHB_WIDGET (ud->builder, "source_aspect");
 935         text = get_aspect_string(tinfo->aspect_n, tinfo->aspect_d);
 936         gtk_label_set_text (GTK_LABEL(widget), text);
 937         g_free(text);
 938
 939         widget = GHB_WIDGET (ud->builder, "source_frame_rate");
 940         text = (gchar*)get_rate_string(tinfo->rate_base, tinfo->rate);
 941         gtk_label_set_text (GTK_LABEL(widget), text);
 942         g_free(text);
 943
 944         ghb_ui_update(ud, "scale_width",
 945                 ghb_int64_value(tinfo->width - tinfo->crop[2] - tinfo->crop[3]));
 946         // If anamorphic or keep_aspect, the hight will be automatically calculated
 947         gboolean keep_aspect, anamorphic;
 948         keep_aspect = ghb_settings_get_boolean(ud->settings, "PictureKeepRatio");
 949         anamorphic = ghb_settings_get_boolean(ud->settings, "anamorphic");
 950         if (!(keep_aspect || anamorphic))
 951         {
 952                 ghb_ui_update(ud, "scale_height",
 953                         ghb_int64_value(tinfo->height - tinfo->crop[0] - tinfo->crop[1]));
 954         }
 955
 956         // Set the limits of cropping.  hb_set_anamorphic_size crashes if
 957         // you pass it a cropped width or height == 0.
 958         gint bound;
 959         bound = tinfo->height / 2 - 2;
 960         widget = GHB_WIDGET (ud->builder, "PictureTopCrop");
 961         gtk_spin_button_set_range (GTK_SPIN_BUTTON(widget), 0, bound);
 962         widget = GHB_WIDGET (ud->builder, "PictureBottomCrop");
 963         gtk_spin_button_set_range (GTK_SPIN_BUTTON(widget), 0, bound);
 964         bound = tinfo->width / 2 - 2;
 965         widget = GHB_WIDGET (ud->builder, "PictureLeftCrop");
 966         gtk_spin_button_set_range (GTK_SPIN_BUTTON(widget), 0, bound);
 967         widget = GHB_WIDGET (ud->builder, "PictureRightCrop");
 968         gtk_spin_button_set_range (GTK_SPIN_BUTTON(widget), 0, bound);
 969         if (ghb_settings_get_boolean(ud->settings, "PictureAutoCrop"))
 970         {
 971                 ghb_ui_update(ud, "PictureTopCrop", ghb_int64_value(tinfo->crop[0]));
 972                 ghb_ui_update(ud, "PictureBottomCrop", ghb_int64_value(tinfo->crop[1]));
 973                 ghb_ui_update(ud, "PictureLeftCrop", ghb_int64_value(tinfo->crop[2]));
 974                 ghb_ui_update(ud, "PictureRightCrop", ghb_int64_value(tinfo->crop[3]));
 975         }
 976         ghb_set_scale (ud, GHB_SCALE_KEEP_NONE);
 977         gint width, height, crop[4];
 978         crop[0] = ghb_settings_get_int(ud->settings, "PictureTopCrop");
 979         crop[1] = ghb_settings_get_int(ud->settings, "PictureBottomCrop");
 980         crop[2] = ghb_settings_get_int(ud->settings, "PictureLeftCrop");
 981         crop[3] = ghb_settings_get_int(ud->settings, "PictureRightCrop");
 982         width = tinfo->width - crop[2] - crop[3];
 983         height = tinfo->height - crop[0] - crop[1];
 984         widget = GHB_WIDGET (ud->builder, "crop_dimensions");
 985         text = g_strdup_printf ("%d x %d", width, height);
 986         gtk_label_set_text (GTK_LABEL(widget), text);
 987         g_free(text);
 988
 989         g_debug("setting max end chapter %d", tinfo->num_chapters);
 990         widget = GHB_WIDGET (ud->builder, "end_chapter");
 991         gtk_spin_button_set_range (GTK_SPIN_BUTTON(widget), 1, tinfo->num_chapters);
 992         gtk_spin_button_set_value (GTK_SPIN_BUTTON(widget), tinfo->num_chapters);
 993         widget = GHB_WIDGET (ud->builder, "start_chapter");
 994         gtk_spin_button_set_value (GTK_SPIN_BUTTON(widget), 1);
 995         gtk_spin_button_set_range (GTK_SPIN_BUTTON(widget), 1, tinfo->num_chapters);
 996 }
 997
 998 static gboolean update_preview = FALSE;
 999
1000 void
1001 title_changed_cb(GtkWidget *widget, signal_user_data_t *ud)
1002 {
1003         ghb_title_info_t tinfo;
1004         gint titleindex;
1005
1006         g_debug("title_changed_cb ()");
1007         ghb_widget_to_setting(ud->settings, widget);
1008         ghb_check_dependency(ud, widget);
1009
1010         titleindex = ghb_settings_combo_int(ud->settings, "title");
1011         ghb_update_ui_combo_box (ud->builder, "AudioTrack", titleindex, FALSE);
1012         ghb_update_ui_combo_box (ud->builder, "Subtitles", titleindex, FALSE);
1013
1014         ghb_update_from_preset(ud, "Subtitles");
1015         if (ghb_get_title_info (&tinfo, titleindex))
1016         {
1017                 show_title_info(ud, &tinfo);
1018         }
1019         update_chapter_list (ud);
1020         ghb_adjust_audio_rate_combos(ud);
1021         ghb_set_pref_audio(titleindex, ud);
1022         if (ghb_settings_get_boolean(ud->settings, "vquality_type_target"))
1023         {
1024                 gint bitrate = ghb_calculate_target_bitrate (ud->settings, titleindex);
1025                 ghb_ui_update(ud, "VideoAvgBitrate", ghb_int64_value(bitrate));
1026         }
1027
1028         // Unfortunately, there is no way to query how many frames were
1029         // actually generated during the scan.  It attempts to make 10.
1030         // If I knew how many were generated, I would adjust the spin
1031         // control range here.
1032         ghb_ui_update(ud, "preview_frame", ghb_int64_value(1));
1033
1034         ghb_set_preview_image (ud);
1035 }
1036
1037 void
1038 setting_widget_changed_cb(GtkWidget *widget, signal_user_data_t *ud)
1039 {
1040         ghb_widget_to_setting(ud->settings, widget);
1041         ghb_check_dependency(ud, widget);
1042         ghb_clear_presets_selection(ud);
1043         ghb_live_reset(ud);
1044 }
1045
1046 static void
1047 validate_filter_widget(signal_user_data_t *ud, const gchar *name)
1048 {
1049         GtkTreeModel *store;
1050         GtkTreeIter iter;
1051         const gchar *str;
1052         gboolean foundit = FALSE;
1053         GtkComboBox *combo = GTK_COMBO_BOX(GHB_WIDGET(ud->builder, name));
1054         if (gtk_combo_box_get_active(combo) < 0)
1055         { // Validate user input
1056                 gchar *val = ghb_settings_get_string(ud->settings, name);
1057                 store = gtk_combo_box_get_model(combo);
1058                 // Check to see if user manually entered one of the combo options
1059                 if (gtk_tree_model_get_iter_first(store, &iter))
1060                 {
1061                         do
1062                         {
1063                                 gtk_tree_model_get(store, &iter, 0, &str, -1);
1064                                 if (strcasecmp(val, str) == 0)
1065                                 {
1066                                         gtk_combo_box_set_active_iter(combo, &iter);
1067                                         foundit = TRUE;
1068                                         break;
1069                                 }
1070                         } while (gtk_tree_model_iter_next(store, &iter));
1071                 }
1072                 if (!foundit)
1073                 { // validate format of filter string
1074                         if (!ghb_validate_filter_string(val, -1))
1075                                 gtk_combo_box_set_active(combo, 0);
1076                 }
1077                 g_free(val);
1078         }
1079 }
1080
1081 gboolean
1082 deint_tweak_focus_out_cb(GtkWidget *widget, GdkEventFocus *event,
1083         signal_user_data_t *ud)
1084 {
1085         g_debug("deint_tweak_focus_out_cb ()");
1086         validate_filter_widget(ud, "tweak_PictureDeinterlace");
1087         return FALSE;
1088 }
1089
1090 gboolean
1091 denoise_tweak_focus_out_cb(GtkWidget *widget, GdkEventFocus *event,
1092         signal_user_data_t *ud)
1093 {
1094         g_debug("denoise_tweak_focus_out_cb ()");
1095         validate_filter_widget(ud, "tweak_PictureDenoise");
1096         return FALSE;
1097 }
1098
1099 void
1100 http_opt_changed_cb(GtkWidget *widget, signal_user_data_t *ud)
1101 {
1102         ghb_widget_to_setting(ud->settings, widget);
1103         ghb_check_dependency(ud, widget);
1104         ghb_clear_presets_selection(ud);
1105         ghb_live_reset(ud);
1106         // AC3 is not allowed when Web optimized
1107         ghb_grey_combo_options (ud->builder);
1108 }
1109
1110 void
1111 vcodec_changed_cb(GtkWidget *widget, signal_user_data_t *ud)
1112 {
1113         gdouble vqmin, vqmax, step, page;
1114         gint digits;
1115         gint vcodec;
1116
1117         ghb_widget_to_setting(ud->settings, widget);
1118         ghb_check_dependency(ud, widget);
1119         ghb_clear_presets_selection(ud);
1120         ghb_live_reset(ud);
1121         ghb_vquality_range(ud, &vqmin, &vqmax, &step, &page, &digits);
1122         GtkWidget *qp = GHB_WIDGET(ud->builder, "VideoQualitySlider");
1123         gtk_range_set_range (GTK_RANGE(qp), vqmin, vqmax);
1124         gtk_range_set_increments (GTK_RANGE(qp), step, page);
1125         gtk_scale_set_digits(GTK_SCALE(qp), digits);
1126         vcodec = ghb_settings_combo_int(ud->settings, "VideoEncoder");
1127         if (vcodec != HB_VCODEC_X264 && vcodec != HB_VCODEC_FFMPEG)
1128         {
1129                 ghb_ui_update(ud, "directqp", ghb_boolean_value(FALSE));
1130         }
1131 }
1132
1133 void
1134 target_size_changed_cb(GtkWidget *widget, signal_user_data_t *ud)
1135 {
1136         const gchar *name = gtk_widget_get_name(widget);
1137         g_debug("setting_widget_changed_cb () %s", name);
1138         ghb_widget_to_setting(ud->settings, widget);
1139         ghb_check_dependency(ud, widget);
1140         ghb_clear_presets_selection(ud);
1141         ghb_live_reset(ud);
1142         if (ghb_settings_get_boolean(ud->settings, "vquality_type_target"))
1143         {
1144                 gint titleindex;
1145                 titleindex = ghb_settings_combo_int(ud->settings, "title");
1146                 gint bitrate = ghb_calculate_target_bitrate (ud->settings, titleindex);
1147                 ghb_ui_update(ud, "VideoAvgBitrate", ghb_int64_value(bitrate));
1148         }
1149 }
1150
1151 void
1152 start_chapter_changed_cb(GtkWidget *widget, signal_user_data_t *ud)
1153 {
1154         gint start, end;
1155         const gchar *name = gtk_widget_get_name(widget);
1156
1157         g_debug("start_chapter_changed_cb () %s", name);
1158         ghb_widget_to_setting(ud->settings, widget);
1159         start = ghb_settings_get_int(ud->settings, "start_chapter");
1160         end = ghb_settings_get_int(ud->settings, "end_chapter");
1161         if (start > end)
1162                 ghb_ui_update(ud, "end_chapter", ghb_int_value(start));
1163         ghb_check_dependency(ud, widget);
1164         if (ghb_settings_get_boolean(ud->settings, "chapters_in_destination"))
1165         {
1166                 set_destination(ud);
1167         }
1168 }
1169
1170 void
1171 end_chapter_changed_cb(GtkWidget *widget, signal_user_data_t *ud)
1172 {
1173         gint start, end;
1174         const gchar *name = gtk_widget_get_name(widget);
1175
1176         g_debug("end_chapter_changed_cb () %s", name);
1177         ghb_widget_to_setting(ud->settings, widget);
1178         start = ghb_settings_get_int(ud->settings, "start_chapter");
1179         end = ghb_settings_get_int(ud->settings, "end_chapter");
1180         if (start > end)
1181                 ghb_ui_update(ud, "start_chapter", ghb_int_value(end));
1182         ghb_check_dependency(ud, widget);
1183         if (ghb_settings_get_boolean(ud->settings, "chapters_in_destination"))
1184         {
1185                 set_destination(ud);
1186         }
1187 }
1188
1189 void
1190 scale_width_changed_cb(GtkWidget *widget, signal_user_data_t *ud)
1191 {
1192         g_debug("scale_width_changed_cb ()");
1193         ghb_widget_to_setting(ud->settings, widget);
1194         ghb_check_dependency(ud, widget);
1195         ghb_set_scale (ud, GHB_SCALE_KEEP_WIDTH);
1196         update_preview = TRUE;
1197         gchar *text;
1198         gint width = ghb_settings_get_int(ud->settings, "scale_width");
1199         gint height = ghb_settings_get_int(ud->settings, "scale_height");
1200         widget = GHB_WIDGET (ud->builder, "scale_dimensions");
1201         text = g_strdup_printf ("%d x %d", width, height);
1202         gtk_label_set_text (GTK_LABEL(widget), text);
1203         g_free(text);
1204         ghb_live_reset(ud);
1205 }
1206
1207 void
1208 scale_height_changed_cb(GtkWidget *widget, signal_user_data_t *ud)
1209 {
1210         g_debug("scale_height_changed_cb ()");
1211         ghb_widget_to_setting(ud->settings, widget);
1212         ghb_check_dependency(ud, widget);
1213         ghb_set_scale (ud, GHB_SCALE_KEEP_HEIGHT);
1214         update_preview = TRUE;
1215         gchar *text;
1216         gint width = ghb_settings_get_int(ud->settings, "scale_width");
1217         gint height = ghb_settings_get_int(ud->settings, "scale_height");
1218         widget = GHB_WIDGET (ud->builder, "scale_dimensions");
1219         text = g_strdup_printf ("%d x %d", width, height);
1220         gtk_label_set_text (GTK_LABEL(widget), text);
1221         g_free(text);
1222         ghb_live_reset(ud);
1223 }
1224
1225 void
1226 crop_changed_cb(GtkWidget *widget, signal_user_data_t *ud)
1227 {
1228         gint titleindex, crop[4];
1229         ghb_title_info_t tinfo;
1230
1231         g_debug("crop_changed_cb ()");
1232         ghb_widget_to_setting(ud->settings, widget);
1233         ghb_check_dependency(ud, widget);
1234         ghb_set_scale (ud, GHB_SCALE_KEEP_NONE);
1235
1236         crop[0] = ghb_settings_get_int(ud->settings, "PictureTopCrop");
1237         crop[1] = ghb_settings_get_int(ud->settings, "PictureBottomCrop");
1238         crop[2] = ghb_settings_get_int(ud->settings, "PictureLeftCrop");
1239         crop[3] = ghb_settings_get_int(ud->settings, "PictureRightCrop");
1240         titleindex = ghb_settings_combo_int(ud->settings, "title");
1241         if (ghb_get_title_info (&tinfo, titleindex))
1242         {
1243                 gint width, height;
1244                 gchar *text;
1245
1246                 width = tinfo.width - crop[2] - crop[3];
1247                 height = tinfo.height - crop[0] - crop[1];
1248                 widget = GHB_WIDGET (ud->builder, "crop_dimensions");
1249                 text = g_strdup_printf ("%d x %d", width, height);
1250                 gtk_label_set_text (GTK_LABEL(widget), text);
1251                 g_free(text);
1252         }
1253         gchar *text;
1254         widget = GHB_WIDGET (ud->builder, "crop_values");
1255         text = g_strdup_printf ("%d:%d:%d:%d", crop[0], crop[1], crop[2], crop[3]);
1256         gtk_label_set_text (GTK_LABEL(widget), text);
1257         g_free(text);
1258         update_preview = TRUE;
1259         ghb_live_reset(ud);
1260 }
1261
1262 void
1263 scale_changed_cb(GtkWidget *widget, signal_user_data_t *ud)
1264 {
1265         g_debug("scale_changed_cb ()");
1266         ghb_widget_to_setting(ud->settings, widget);
1267         ghb_check_dependency(ud, widget);
1268         ghb_clear_presets_selection(ud);
1269         ghb_live_reset(ud);
1270         ghb_set_scale (ud, GHB_SCALE_KEEP_NONE);
1271         update_preview = TRUE;
1272
1273         gchar *text;
1274
1275         text = ghb_settings_get_boolean(ud->settings, "PictureAutoCrop") ? "On" : "Off";
1276         widget = GHB_WIDGET (ud->builder, "crop_auto");
1277         gtk_label_set_text (GTK_LABEL(widget), text);
1278         text = ghb_settings_get_boolean(ud->settings, "autoscale") ? "On" : "Off";
1279         widget = GHB_WIDGET (ud->builder, "scale_auto");
1280         gtk_label_set_text (GTK_LABEL(widget), text);
1281         text = ghb_settings_get_boolean(ud->settings, "anamorphic") ? "On" : "Off";
1282         widget = GHB_WIDGET (ud->builder, "scale_anamorphic");
1283         gtk_label_set_text (GTK_LABEL(widget), text);
1284 }
1285
1286 void
1287 generic_entry_changed_cb(GtkEntry *entry, signal_user_data_t *ud)
1288 {
1289         // Normally (due to user input) I only want to process the entry
1290         // when editing is done and the focus-out signal is sent.
1291         // But... there's always a but.
1292         // If the entry is changed by software, the focus-out signal is not sent.
1293         // The changed signal is sent ... so here we are.
1294         // I don't want to process upon every keystroke, so I prevent processing
1295         // while the widget has focus.
1296         g_debug("generic_entry_changed_cb ()");
1297         if (!GTK_WIDGET_HAS_FOCUS((GtkWidget*)entry))
1298         {
1299                 ghb_widget_to_setting(ud->settings, (GtkWidget*)entry);
1300         }
1301 }
1302
1303 void
1304 prefs_dialog_cb(GtkWidget *xwidget, signal_user_data_t *ud)
1305 {
1306         GtkWidget *dialog;
1307         GtkResponseType response;
1308
1309         g_debug("prefs_dialog_cb ()");
1310         dialog = GHB_WIDGET(ud->builder, "prefs_dialog");
1311         response = gtk_dialog_run(GTK_DIALOG(dialog));
1312         gtk_widget_hide(dialog);
1313 }
1314
1315 gboolean
1316 ghb_message_dialog(GtkMessageType type, const gchar *message, const gchar *no, const gchar *yes)
1317 {
1318         GtkWidget *dialog;
1319         GtkResponseType response;
1320
1321         // Toss up a warning dialog
1322         dialog = gtk_message_dialog_new(NULL, GTK_DIALOG_MODAL,
1323                                                         type, GTK_BUTTONS_NONE,
1324                                                         "%s", message);
1325         gtk_dialog_add_buttons( GTK_DIALOG(dialog),
1326                                                    no, GTK_RESPONSE_NO,
1327                                                    yes, GTK_RESPONSE_YES, NULL);
1328         response = gtk_dialog_run(GTK_DIALOG(dialog));
1329         gtk_widget_destroy (dialog);
1330         if (response == GTK_RESPONSE_NO)
1331         {
1332                 return FALSE;
1333         }
1334         return TRUE;
1335 }
1336
1337 gboolean
1338 ghb_cancel_encode(const gchar *extra_msg)
1339 {
1340         GtkWidget *dialog;
1341         GtkResponseType response;
1342
1343         if (extra_msg == NULL) extra_msg = "";
1344         // Toss up a warning dialog
1345         dialog = gtk_message_dialog_new(NULL, GTK_DIALOG_MODAL,
1346                                 GTK_MESSAGE_WARNING, GTK_BUTTONS_NONE,
1347                                 "%sYour movie will be lost if you don't continue encoding.",
1348                                 extra_msg);
1349         gtk_dialog_add_buttons( GTK_DIALOG(dialog),
1350                                                    "Continue Encoding", GTK_RESPONSE_NO,
1351                                                    "Stop Encoding", GTK_RESPONSE_YES, NULL);
1352         response = gtk_dialog_run(GTK_DIALOG(dialog));
1353         gtk_widget_destroy (dialog);
1354         if (response == GTK_RESPONSE_NO) return FALSE;
1355         ghb_stop_queue();
1356         return TRUE;
1357 }
1358
1359 static void
1360 submit_job(GValue *settings)
1361 {
1362         static gint unique_id = 1;
1363         gchar *type, *modified, *preset;
1364         GValue *path;
1365         gboolean preset_modified;
1366
1367         g_debug("submit_job");
1368         if (settings == NULL) return;
1369         preset_modified = ghb_settings_get_boolean(settings, "preset_modified");
1370         path = ghb_settings_get_value(settings, "preset");
1371         preset = ghb_preset_path_string(path);
1372         type = ghb_preset_is_custom() ? "Custom " : "";
1373         modified = preset_modified ? "Modified " : "";
1374         ghb_log("%s%sPreset: %s", modified, type, preset);
1375         g_free(preset);
1376
1377         ghb_settings_set_int(settings, "job_unique_id", unique_id);
1378         ghb_settings_set_int(settings, "job_status", GHB_QUEUE_RUNNING);
1379         ghb_add_job (settings, unique_id);
1380         ghb_start_queue();
1381         unique_id++;
1382 }
1383
1384 static void
1385 prune_logs(signal_user_data_t *ud)
1386 {
1387         gchar *dest_dir;
1388
1389         // Only prune logs stored in the default config dir location
1390         dest_dir = ghb_get_user_config_dir("EncodeLogs");
1391         if (g_file_test(dest_dir, G_FILE_TEST_IS_DIR))
1392         {
1393                 const gchar *file;
1394                 int week = 7*24*60*60;
1395                 GDir *gdir = g_dir_open(dest_dir, 0, NULL);
1396                 time_t now;
1397
1398                 now = time(NULL);
1399                 file = g_dir_read_name(gdir);
1400                 while (file)
1401                 {
1402                         gchar *path;
1403                         struct stat stbuf;
1404
1405                         path = g_strdup_printf("%s/%s", dest_dir, file);
1406                         g_stat(path, &stbuf);
1407                         if (now - stbuf.st_mtime > week)
1408                         {
1409                                 g_unlink(path);
1410                         }
1411                         g_free(path);
1412                         file = g_dir_read_name(gdir);
1413                 }
1414                 g_dir_close(gdir);
1415         }
1416         g_free(dest_dir);
1417         ghb_preview_cleanup(ud);
1418 }
1419
1420 static void
1421 queue_scan(signal_user_data_t *ud, GValue *js)
1422 {
1423         gchar *path;
1424         gint titlenum;
1425         time_t  _now;
1426         struct tm *now;
1427         gchar *log_path, *pos, *destname, *basename, *dest_dir;
1428
1429         _now = time(NULL);
1430         now = localtime(&_now);
1431         destname = ghb_settings_get_string(js, "destination");
1432         basename = g_path_get_basename(destname);
1433         if (ghb_settings_get_boolean(ud->settings, "EncodeLogLocation"))
1434         {
1435                 dest_dir = g_path_get_dirname (destname);
1436         }
1437         else
1438         {
1439                 dest_dir = ghb_get_user_config_dir("EncodeLogs");
1440         }
1441         g_free(destname);
1442         pos = g_strrstr( basename, "." );
1443         if (pos != NULL)
1444         {
1445                 *pos = 0;
1446         }
1447         log_path = g_strdup_printf("%s/%d-%02d-%02d %02d-%02d-%02d %s.log",
1448                 dest_dir,
1449                 now->tm_year + 1900, now->tm_mon + 1, now->tm_mday,
1450                 now->tm_hour, now->tm_min, now->tm_sec, basename);
1451         g_free(basename);
1452         g_free(dest_dir);
1453         if (ud->job_activity_log)
1454                 g_io_channel_unref(ud->job_activity_log);
1455         ud->job_activity_log = g_io_channel_new_file (log_path, "w", NULL);
1456         if (ud->job_activity_log)
1457         {
1458                 gchar *ver_str;
1459
1460                 ver_str = g_strdup_printf("Handbrake Version: %s (%d)\n",
1461                                                                         HB_VERSION, HB_BUILD);
1462                 g_io_channel_write_chars (ud->job_activity_log, ver_str,
1463                                                                         -1, NULL, NULL);
1464                 g_free(ver_str);
1465         }
1466         g_free(log_path);
1467
1468         path = ghb_settings_get_string( js, "source");
1469         titlenum = ghb_settings_get_int(js, "titlenum");
1470         ghb_backend_queue_scan(path, titlenum);
1471         g_free(path);
1472 }
1473
1474 GValue*
1475 ghb_start_next_job(signal_user_data_t *ud, gboolean find_first)
1476 {
1477         static gint current = 0;
1478         gint count, ii, jj;
1479         GValue *js;
1480         gint status;
1481
1482         g_debug("start_next_job");
1483         count = ghb_array_len(ud->queue);
1484         if (find_first)
1485         {       // Start the first pending item in the queue
1486                 current = 0;
1487                 for (ii = 0; ii < count; ii++)
1488                 {
1489
1490                         js = ghb_array_get_nth(ud->queue, ii);
1491                         status = ghb_settings_get_int(js, "job_status");
1492                         if (status == GHB_QUEUE_PENDING)
1493                         {
1494                                 current = ii;
1495                                 queue_scan(ud, js);
1496                                 return js;
1497                         }
1498                 }
1499                 // Nothing pending
1500                 return NULL;
1501         }
1502         // Find the next pending item after the current running item
1503         for (ii = 0; ii < count-1; ii++)
1504         {
1505                 js = ghb_array_get_nth(ud->queue, ii);
1506                 status = ghb_settings_get_int(js, "job_status");
1507                 if (status == GHB_QUEUE_RUNNING)
1508                 {
1509                         for (jj = ii+1; jj < count; jj++)
1510                         {
1511                                 js = ghb_array_get_nth(ud->queue, jj);
1512                                 status = ghb_settings_get_int(js, "job_status");
1513                                 if (status == GHB_QUEUE_PENDING)
1514                                 {
1515                                         current = jj;
1516                                         queue_scan(ud, js);
1517                                         return js;
1518                                 }
1519                         }
1520                 }
1521         }
1522         // No running item found? Maybe it was deleted
1523         // Look for a pending item starting from the last index we started
1524         for (ii = current; ii < count; ii++)
1525         {
1526                 js = ghb_array_get_nth(ud->queue, ii);
1527                 status = ghb_settings_get_int(js, "job_status");
1528                 if (status == GHB_QUEUE_PENDING)
1529                 {
1530                         current = ii;
1531                         queue_scan(ud, js);
1532                         return js;
1533                 }
1534         }
1535         // Nothing found
1536         return NULL;
1537 }
1538
1539 static gint
1540 find_queue_job(GValue *queue, gint unique_id, GValue **job)
1541 {
1542         GValue *js;
1543         gint ii, count;
1544         gint job_unique_id;
1545
1546         *job = NULL;
1547         g_debug("find_queue_job");
1548         count = ghb_array_len(queue);
1549         for (ii = 0; ii < count; ii++)
1550         {
1551                 js = ghb_array_get_nth(queue, ii);
1552                 job_unique_id = ghb_settings_get_int(js, "job_unique_id");
1553                 if (job_unique_id == unique_id)
1554                 {
1555                         *job = js;
1556                         return ii;
1557                 }
1558         }
1559         return -1;
1560 }
1561
1562 gchar*
1563 working_status_string(signal_user_data_t *ud, ghb_instance_status_t *status)
1564 {
1565         gchar *task_str, *job_str, *status_str;
1566         gint qcount;
1567         gint index;
1568         GValue *js;
1569
1570         if (status->job_count > 1)
1571         {
1572                 task_str = g_strdup_printf("pass %d of %d, ",
1573                         status->job_cur, status->job_count);
1574         }
1575         else
1576         {
1577                 task_str = g_strdup("");
1578         }
1579         qcount = ghb_array_len(ud->queue);
1580         if (qcount > 1)
1581         {
1582                 index = find_queue_job(ud->queue, status->unique_id, &js);
1583                 job_str = g_strdup_printf("job %d of %d, ", index+1, qcount);
1584         }
1585         else
1586         {
1587                 job_str = g_strdup("");
1588         }
1589         if(status->seconds > -1)
1590         {
1591                 status_str= g_strdup_printf(
1592                         "Encoding: %s%s%.2f %%"
1593                         " (%.2f fps, avg %.2f fps, ETA %02dh%02dm%02ds)",
1594                         job_str, task_str,
1595                         100.0 * status->progress,
1596                         status->rate_cur, status->rate_avg, status->hours,
1597                         status->minutes, status->seconds );
1598         }
1599         else
1600         {
1601                 status_str= g_strdup_printf(
1602                         "Encoding: %s%s%.2f %%",
1603                         job_str, task_str,
1604                         100.0 * status->progress );
1605         }
1606         g_free(task_str);
1607         g_free(job_str);
1608         return status_str;
1609 }
1610
1611 static void
1612 ghb_backend_events(signal_user_data_t *ud)
1613 {
1614         ghb_status_t status;
1615         gchar *status_str;
1616         GtkProgressBar *progress;
1617         gint titleindex;
1618         GValue *js;
1619         gint index;
1620         GtkTreeView *treeview;
1621         GtkTreeStore *store;
1622         GtkTreeIter iter;
1623         static gint working = 0;
1624         static gboolean work_started = FALSE;
1625
1626         ghb_track_status();
1627         ghb_get_status(&status);
1628         progress = GTK_PROGRESS_BAR(GHB_WIDGET (ud->builder, "progressbar"));
1629         // First handle the status of title scans
1630         // Then handle the status of the queue
1631         if (status.scan.state & GHB_STATE_SCANNING)
1632         {
1633                 if (status.scan.title_cur == 0)
1634                 {
1635                         status_str = g_strdup ("Scanning...");
1636                 }
1637                 else
1638                 {
1639                         status_str = g_strdup_printf ("Scanning title %d of %d...",
1640                                                           status.scan.title_cur, status.scan.title_count );
1641                 }
1642                 gtk_progress_bar_set_text (progress, status_str);
1643                 g_free(status_str);
1644                 if (status.scan.title_count > 0)
1645                 {
1646                         gtk_progress_bar_set_fraction (progress,
1647                                 (gdouble)status.scan.title_cur / status.scan.title_count);
1648                 }
1649         }
1650         else if (status.scan.state & GHB_STATE_SCANDONE)
1651         {
1652                 status_str = g_strdup_printf ("Scan done");
1653                 gtk_progress_bar_set_text (progress, status_str);
1654                 g_free(status_str);
1655                 gtk_progress_bar_set_fraction (progress, 1.0);
1656
1657                 ghb_title_info_t tinfo;
1658
1659                 ghb_update_ui_combo_box(ud->builder, "title", 0, FALSE);
1660                 titleindex = ghb_longest_title();
1661                 ghb_ui_update(ud, "title", ghb_int64_value(titleindex));
1662
1663                 // Are there really any titles.
1664                 if (!ghb_get_title_info(&tinfo, titleindex))
1665                 {
1666                         GtkProgressBar *progress;
1667                         progress = GTK_PROGRESS_BAR(GHB_WIDGET (ud->builder, "progressbar"));
1668                         gtk_progress_bar_set_fraction (progress, 0);
1669                         gtk_progress_bar_set_text (progress, "No Source");
1670                 }
1671                 ghb_clear_scan_state(GHB_STATE_SCANDONE);
1672                 ghb_queue_buttons_grey(ud, work_started);
1673                 if (ghb_queue_edit_settings)
1674                 {
1675                         gint jstatus;
1676
1677                         jstatus = ghb_settings_get_int(ghb_queue_edit_settings, "job_status");
1678                         ghb_settings_to_ui(ud, ghb_queue_edit_settings);
1679                         ghb_set_audio(ud, ghb_queue_edit_settings);
1680                         if (jstatus == GHB_QUEUE_PENDING)
1681                         {
1682                                 ghb_value_free(ghb_queue_edit_settings);
1683                         }
1684                         ghb_queue_edit_settings = NULL;
1685                 }
1686         }
1687         else if (status.queue.state & GHB_STATE_SCANNING)
1688         {
1689                 status_str = g_strdup_printf ("Scanning ...");
1690                 gtk_progress_bar_set_text (progress, status_str);
1691                 g_free(status_str);
1692                 gtk_progress_bar_set_fraction (progress, 0);
1693         }
1694         else if (status.queue.state & GHB_STATE_SCANDONE)
1695         {
1696                 ghb_clear_queue_state(GHB_STATE_SCANDONE);
1697                 submit_job(ud->current_job);
1698         }
1699         else if (status.queue.state & GHB_STATE_PAUSED)
1700         {
1701                 status_str = g_strdup_printf ("Paused");
1702                 gtk_progress_bar_set_text (progress, status_str);
1703                 g_free(status_str);
1704         }
1705         else if (status.queue.state & GHB_STATE_WORKING)
1706         {
1707                 status_str = working_status_string(ud, &status.queue);
1708                 gtk_progress_bar_set_text (progress, status_str);
1709                 gtk_progress_bar_set_fraction (progress, status.queue.progress);
1710                 g_free(status_str);
1711         }
1712         else if (status.queue.state & GHB_STATE_WORKDONE)
1713         {
1714                 gint qstatus;
1715
1716                 work_started = FALSE;
1717                 ghb_queue_buttons_grey(ud, FALSE);
1718                 index = find_queue_job(ud->queue, status.queue.unique_id, &js);
1719                 treeview = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "queue_list"));
1720                 store = GTK_TREE_STORE(gtk_tree_view_get_model(treeview));
1721                 if (ud->cancel_encode)
1722                         status.queue.error = GHB_ERROR_CANCELED;
1723                 switch( status.queue.error )
1724                 {
1725                         case GHB_ERROR_NONE:
1726                                 gtk_progress_bar_set_text( progress, "Rip done!" );
1727                                 qstatus = GHB_QUEUE_DONE;
1728                                 if (js != NULL)
1729                                 {
1730                                         gchar *path = g_strdup_printf ("%d", index);
1731                                         if (gtk_tree_model_get_iter_from_string(
1732                                                         GTK_TREE_MODEL(store), &iter, path))
1733                                         {
1734                                                 gtk_tree_store_set(store, &iter, 0, "hb-complete", -1);
1735                                         }
1736                                         g_free(path);
1737                                 }
1738                                 break;
1739                         case GHB_ERROR_CANCELED:
1740                                 gtk_progress_bar_set_text( progress, "Rip canceled." );
1741                                 qstatus = GHB_QUEUE_CANCELED;
1742                                 if (js != NULL)
1743                                 {
1744                                         gchar *path = g_strdup_printf ("%d", index);
1745                                         if (gtk_tree_model_get_iter_from_string(
1746                                                         GTK_TREE_MODEL(store), &iter, path))
1747                                         {
1748                                                 gtk_tree_store_set(store, &iter, 0, "hb-canceled", -1);
1749                                         }
1750                                         g_free(path);
1751                                 }
1752                                 break;
1753                         default:
1754                                 gtk_progress_bar_set_text( progress, "Rip failed.");
1755                                 qstatus = GHB_QUEUE_CANCELED;
1756                                 if (js != NULL)
1757                                 {
1758                                         gchar *path = g_strdup_printf ("%d", index);
1759                                         if (gtk_tree_model_get_iter_from_string(
1760                                                         GTK_TREE_MODEL(store), &iter, path))
1761                                         {
1762                                                 gtk_tree_store_set(store, &iter, 0, "hb-canceled", -1);
1763                                         }
1764                                         g_free(path);
1765                                 }
1766                 }
1767                 gtk_progress_bar_set_fraction (progress, 1.0);
1768                 ghb_clear_queue_state(GHB_STATE_WORKDONE);
1769                 if (!ud->cancel_encode)
1770                         ud->current_job = ghb_start_next_job(ud, FALSE);
1771                 else
1772                         ud->current_job = NULL;
1773                 if (js)
1774                         ghb_settings_set_int(js, "job_status", qstatus);
1775                 ghb_save_queue(ud->queue);
1776                 ud->cancel_encode = FALSE;
1777                 g_io_channel_unref(ud->job_activity_log);
1778                 ud->job_activity_log = NULL;
1779         }
1780         else if (status.queue.state & GHB_STATE_MUXING)
1781         {
1782                 gtk_progress_bar_set_text(progress, "Muxing: this may take awhile...");
1783         }
1784         if (status.queue.state & GHB_STATE_SCANNING)
1785         {
1786                 // This needs to be in scanning and working since scanning
1787                 // happens fast enough that it can be missed
1788                 if (!work_started)
1789                 {
1790                         work_started = TRUE;
1791                         ghb_queue_buttons_grey(ud, TRUE);
1792                 }
1793         }
1794         if (status.queue.state & GHB_STATE_WORKING)
1795         {
1796                 // This needs to be in scanning and working since scanning
1797                 // happens fast enough that it can be missed
1798                 if (!work_started)
1799                 {
1800                         work_started = TRUE;
1801                         ghb_queue_buttons_grey(ud, TRUE);
1802                 }
1803                 index = find_queue_job(ud->queue, status.queue.unique_id, &js);
1804                 if (status.queue.unique_id != 0 && index >= 0)
1805                 {
1806                         gchar working_icon[] = "hb-working0";
1807                         working_icon[10] = '0' + working;
1808                         working = (working+1) % 6;
1809                         treeview = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "queue_list"));
1810                         store = GTK_TREE_STORE(gtk_tree_view_get_model(treeview));
1811                         gchar *path = g_strdup_printf ("%d", index);
1812                         if (gtk_tree_model_get_iter_from_string(
1813                                         GTK_TREE_MODEL(store), &iter, path))
1814                         {
1815                                 gtk_tree_store_set(store, &iter, 0, working_icon, -1);
1816                         }
1817                         g_free(path);
1818                 }
1819                 GtkLabel *label;
1820                 gchar *status_str;
1821
1822                 status_str = working_status_string(ud, &status.queue);
1823                 label = GTK_LABEL(GHB_WIDGET(ud->builder, "queue_status"));
1824                 gtk_label_set_text (label, status_str);
1825                 g_free(status_str);
1826         }
1827         if (status.scan.state & GHB_STATE_WORKING)
1828         {
1829                 GtkProgressBar *live_progress;
1830                 live_progress = GTK_PROGRESS_BAR(
1831                         GHB_WIDGET(ud->builder, "live_encode_progress"));
1832                 status_str = working_status_string(ud, &status.scan);
1833                 gtk_progress_bar_set_text (live_progress, status_str);
1834                 gtk_progress_bar_set_fraction (live_progress, status.scan.progress);
1835                 g_free(status_str);
1836         }
1837         if (status.scan.state & GHB_STATE_WORKDONE)
1838         {
1839                 switch( status.scan.error )
1840                 {
1841                         case GHB_ERROR_NONE:
1842                         {
1843                                 ghb_live_encode_done(ud, TRUE);
1844                         } break;
1845                         default:
1846                         {
1847                                 ghb_live_encode_done(ud, FALSE);
1848                         } break;
1849                 }
1850                 ghb_clear_scan_state(GHB_STATE_WORKDONE);
1851         }
1852 }
1853
1854 gboolean
1855 ghb_timer_cb(gpointer data)
1856 {
1857         signal_user_data_t *ud = (signal_user_data_t*)data;
1858
1859         ghb_live_preview_progress(ud);
1860         ghb_backend_events(ud);
1861         if (update_default_destination)
1862         {
1863                 gchar *dest, *dest_dir, *def_dest;
1864                 dest = ghb_settings_get_string(ud->settings, "destination");
1865                 dest_dir = g_path_get_dirname (dest);
1866                 def_dest = ghb_settings_get_string(ud->settings, "destination_dir");
1867                 if (strcmp(dest_dir, def_dest) != 0)
1868                 {
1869                         ghb_settings_set_string (ud->settings, "destination_dir", dest_dir);
1870                         ghb_pref_save (ud->settings, "destination_dir");
1871                 }
1872                 g_free(dest);
1873                 g_free(dest_dir);
1874                 g_free(def_dest);
1875                 update_default_destination = FALSE;
1876         }
1877         if (update_preview)
1878         {
1879                 ghb_set_preview_image (ud);
1880                 update_preview = FALSE;
1881         }
1882         return TRUE;
1883 }
1884
1885 gboolean
1886 ghb_log_cb(GIOChannel *source, GIOCondition cond, gpointer data)
1887 {
1888         gchar *text = NULL;
1889         gsize length;
1890         GtkTextView *textview;
1891         GtkTextBuffer *buffer;
1892         GtkTextIter iter;
1893         GtkTextMark *mark;
1894         GError *gerror = NULL;
1895         GIOStatus status;
1896
1897         signal_user_data_t *ud = (signal_user_data_t*)data;
1898
1899         status = g_io_channel_read_line (source, &text, &length, NULL, &gerror);
1900         if (text != NULL)
1901         {
1902                 GdkWindow *window;
1903                 gint width, height;
1904                 gint x, y;
1905                 gboolean bottom = FALSE;
1906
1907                 textview = GTK_TEXT_VIEW(GHB_WIDGET (ud->builder, "activity_view"));
1908                 buffer = gtk_text_view_get_buffer (textview);
1909                 // I would like to auto-scroll the window when the scrollbar
1910                 // is at the bottom,
1911                 // must determining whether the insert point is at
1912                 // the bottom of the window
1913                 window = gtk_text_view_get_window(textview, GTK_TEXT_WINDOW_TEXT);
1914                 if (window != NULL)
1915                 {
1916                         gdk_drawable_get_size(GDK_DRAWABLE(window), &width, &height);
1917                         gtk_text_view_window_to_buffer_coords(textview,
1918                                 GTK_TEXT_WINDOW_TEXT, width, height, &x, &y);
1919                         gtk_text_view_get_iter_at_location(textview, &iter, x, y);
1920                         if (gtk_text_iter_is_end(&iter))
1921                         {
1922                                 bottom = TRUE;
1923                         }
1924                 }
1925                 else
1926                 {
1927                         // If the window isn't available, assume bottom
1928                         bottom = TRUE;
1929                 }
1930                 gtk_text_buffer_get_end_iter(buffer, &iter);
1931                 gtk_text_buffer_insert(buffer, &iter, text, -1);
1932                 if (bottom)
1933                 {
1934                         //gtk_text_view_scroll_to_iter(textview, &iter, 0, FALSE, 0, 0);
1935                         mark = gtk_text_buffer_get_insert (buffer);
1936                         gtk_text_view_scroll_mark_onscreen(textview, mark);
1937                 }
1938                 g_io_channel_write_chars (ud->activity_log, text,
1939                                                                 length, &length, NULL);
1940                 if (ud->job_activity_log)
1941                         g_io_channel_write_chars (ud->job_activity_log, text,
1942                                                                         length, &length, NULL);
1943                 g_free(text);
1944         }
1945         if (status != G_IO_STATUS_NORMAL)
1946         {
1947                 // This should never happen, but if it does I would get into an
1948                 // infinite loop.  Returning false removes this callback.
1949                 g_warning("Error while reading activity from pipe");
1950                 if (gerror != NULL)
1951                 {
1952                         g_warning("%s", gerror->message);
1953                         g_error_free (gerror);
1954                 }
1955                 return FALSE;
1956         }
1957         if (gerror != NULL)
1958                 g_error_free (gerror);
1959         return TRUE;
1960 }
1961
1962 void
1963 show_activity_clicked_cb(GtkWidget *xwidget, signal_user_data_t *ud)
1964 {
1965         GtkWidget *widget = GHB_WIDGET (ud->builder, "activity_window");
1966         gtk_widget_show (widget);
1967 }
1968
1969 void
1970 ghb_log(gchar *log, ...)
1971 {
1972         va_list args;
1973         time_t _now;
1974     struct tm *now;
1975         gchar fmt[362];
1976
1977         _now = time(NULL);
1978         now = localtime( &_now );
1979         snprintf(fmt, 362, "[%02d:%02d:%02d] lingui: %s\n",
1980                         now->tm_hour, now->tm_min, now->tm_sec, log);
1981         va_start(args, log);
1982         vfprintf(stderr, fmt, args);
1983         va_end(args);
1984 }
1985
1986 void
1987 about_activate_cb(GtkWidget *xwidget, signal_user_data_t *ud)
1988 {
1989         GtkWidget *widget = GHB_WIDGET (ud->builder, "hb_about");
1990         gtk_about_dialog_set_version(GTK_ABOUT_DIALOG(widget), ghb_version());
1991         gtk_widget_show (widget);
1992 }
1993
1994 static void
1995 browse_url(const gchar *url)
1996 {
1997         gboolean result;
1998         char *argv[] =
1999                 {"xdg-open",NULL,NULL,NULL};
2000         argv[1] = (gchar*)url;
2001         result = g_spawn_async(NULL, argv, NULL, G_SPAWN_SEARCH_PATH, NULL,
2002                                 NULL, NULL, NULL);
2003         if (result) return;
2004
2005         argv[0] = "gnome-open";
2006         result = g_spawn_async(NULL, argv, NULL, G_SPAWN_SEARCH_PATH, NULL,
2007                                 NULL, NULL, NULL);
2008         if (result) return;
2009
2010         argv[0] = "kfmclient";
2011         argv[1] = "exec";
2012         argv[2] = "http://trac.handbrake.fr/wiki/HandBrakeGuide";
2013         result = g_spawn_async(NULL, argv, NULL, G_SPAWN_SEARCH_PATH, NULL,
2014                                 NULL, NULL, NULL);
2015         if (result) return;
2016
2017         argv[0] = "firefox";
2018         argv[1] = "http://trac.handbrake.fr/wiki/HandBrakeGuide";
2019         argv[2] = NULL;
2020         result = g_spawn_async(NULL, argv, NULL, G_SPAWN_SEARCH_PATH, NULL,
2021                                 NULL, NULL, NULL);
2022 }
2023
2024 void
2025 guide_activate_cb(GtkWidget *xwidget, signal_user_data_t *ud)
2026 {
2027         browse_url("http://trac.handbrake.fr/wiki/HandBrakeGuide");
2028 }
2029
2030 void
2031 hb_about_response_cb(GtkWidget *widget, gint response, signal_user_data_t *ud)
2032 {
2033         gtk_widget_hide (widget);
2034 }
2035
2036 void
2037 show_queue_clicked_cb(GtkWidget *xwidget, signal_user_data_t *ud)
2038 {
2039         GtkWidget *widget = GHB_WIDGET (ud->builder, "queue_window");
2040         gtk_widget_show (widget);
2041 }
2042
2043 void
2044 show_presets_toggled_cb(GtkToggleButton *button, signal_user_data_t *ud)
2045 {
2046         GtkWidget *widget;
2047         GtkWindow *hb_window;
2048
2049         g_debug("show_presets_clicked_cb ()");
2050         widget = GHB_WIDGET (ud->builder, "presets_frame");
2051         if (gtk_toggle_button_get_active(button))
2052         {
2053                 gtk_widget_show_now(widget);
2054         }
2055         else
2056         {
2057                 gtk_widget_hide(widget);
2058                 hb_window = GTK_WINDOW(GHB_WIDGET (ud->builder, "hb_window"));
2059                 gtk_window_resize(hb_window, 16, 16);
2060         }
2061         ghb_widget_to_setting(ud->settings, GTK_WIDGET(button));
2062         ghb_pref_save(ud->settings, "show_presets");
2063 }
2064
2065 static void
2066 update_chapter_list(signal_user_data_t *ud)
2067 {
2068         GtkTreeView *treeview;
2069         GtkTreeIter iter;
2070         GtkListStore *store;
2071         gboolean done;
2072         GValue *chapters;
2073         gint titleindex, ii;
2074         gint count;
2075
2076         g_debug("update_chapter_list ()");
2077         titleindex = ghb_settings_combo_int(ud->settings, "title");
2078         chapters = ghb_get_chapters(titleindex);
2079         count = ghb_array_len(chapters);
2080         if (chapters)
2081                 ghb_settings_set_value(ud->settings, "chapter_list", chapters);
2082
2083         treeview = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "chapters_list"));
2084         store = GTK_LIST_STORE(gtk_tree_view_get_model(treeview));
2085         ii = 0;
2086         if (gtk_tree_model_get_iter_first(GTK_TREE_MODEL(store), &iter))
2087         {
2088                 do
2089                 {
2090
2091                         if (ii < count)
2092                         {
2093                                 gchar *chapter;
2094
2095                                 // Update row with settings data
2096                                 g_debug("Updating row");
2097                                 chapter = ghb_value_string(ghb_array_get_nth(chapters, ii));
2098                                 gtk_list_store_set(store, &iter,
2099                                         0, ii+1,
2100                                         1, chapter,
2101                                         2, TRUE,
2102                                         -1);
2103                                 g_free(chapter);
2104                                 ii++;
2105                                 done = !gtk_tree_model_iter_next(GTK_TREE_MODEL(store), &iter);
2106                         }
2107                         else
2108                         {
2109                                 // No more settings data, remove row
2110                                 g_debug("Removing row");
2111                                 done = !gtk_list_store_remove(store, &iter);
2112                         }
2113                 } while (!done);
2114         }
2115         while (ii < count)
2116         {
2117                 gchar *chapter;
2118
2119                 // Additional settings, add row
2120                 g_debug("Adding row");
2121                 chapter = ghb_value_string(ghb_array_get_nth(chapters, ii));
2122                 gtk_list_store_append(store, &iter);
2123                 gtk_list_store_set(store, &iter,
2124                         0, ii+1,
2125                         1, chapter,
2126                         2, TRUE,
2127                         -1);
2128                 g_free(chapter);
2129                 ii++;
2130         }
2131 }
2132
2133 static gint chapter_edit_key = 0;
2134
2135 gboolean
2136 chapter_keypress_cb(
2137         GhbCellRendererText *cell,
2138         GdkEventKey *event,
2139         signal_user_data_t *ud)
2140 {
2141         chapter_edit_key = event->keyval;
2142         return FALSE;
2143 }
2144
2145 void
2146 chapter_edited_cb(
2147         GhbCellRendererText *cell,
2148         gchar *path,
2149         gchar *text,
2150         signal_user_data_t *ud)
2151 {
2152         GtkTreePath *treepath;
2153         GtkListStore *store;
2154         GtkTreeView *treeview;
2155         GtkTreeIter iter;
2156         gint index;
2157         gint *pi;
2158         gint row;
2159
2160         g_debug("chapter_edited_cb ()");
2161         g_debug("path (%s)", path);
2162         g_debug("text (%s)", text);
2163         treeview = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "chapters_list"));
2164         store = GTK_LIST_STORE(gtk_tree_view_get_model(treeview));
2165         treepath = gtk_tree_path_new_from_string (path);
2166         pi = gtk_tree_path_get_indices(treepath);
2167         row = pi[0];
2168         gtk_tree_model_get_iter(GTK_TREE_MODEL(store), &iter, treepath);
2169         gtk_list_store_set(store, &iter,
2170                 1, text,
2171                 2, TRUE,
2172                 -1);
2173         gtk_tree_model_get(GTK_TREE_MODEL(store), &iter, 0, &index, -1);
2174
2175         GValue *chapters;
2176         GValue *chapter;
2177
2178         chapters = ghb_settings_get_value(ud->settings, "chapter_list");
2179         chapter = ghb_array_get_nth(chapters, index-1);
2180         g_value_set_string(chapter, text);
2181         if ((chapter_edit_key == GDK_Return || chapter_edit_key == GDK_Down) &&
2182                 gtk_tree_model_iter_next(GTK_TREE_MODEL(store), &iter))
2183         {
2184                 GtkTreeViewColumn *column;
2185
2186                 gtk_tree_path_next(treepath);
2187                 // When a cell has been edited, I want to advance to the
2188                 // next cell and start editing it automaitcally.
2189                 // Unfortunately, we may not be in a state here where
2190                 // editing is allowed.  This happens when the user selects
2191                 // a new cell with the mouse instead of just hitting enter.
2192                 // Some kind of Gtk quirk.  widget_editable==NULL assertion.
2193                 // Editing is enabled again once the selection event has been
2194                 // processed.  So I'm queueing up a callback to be called
2195                 // when things go idle.  There, I will advance to the next
2196                 // cell and initiate editing.
2197                 //
2198                 // Now, you might be asking why I don't catch the keypress
2199                 // event and determine what action to take based on that.
2200                 // The Gtk developers in their infinite wisdom have made the
2201                 // actual GtkEdit widget being used a private member of
2202                 // GtkCellRendererText, so it can not be accessed to hang a
2203                 // signal handler off of.  And they also do not propagate the
2204                 // keypress signals in any other way.  So that information is lost.
2205                 //g_idle_add((GSourceFunc)next_cell, ud);
2206                 //
2207                 // Keeping the above comment for posterity.
2208                 // I got industrious and made my own CellTextRendererText that
2209                 // passes on the key-press-event. So now I have much better
2210                 // control of this.
2211                 column = gtk_tree_view_get_column(treeview, 1);
2212                 gtk_tree_view_set_cursor(treeview, treepath, column, TRUE);
2213         }
2214         else if (chapter_edit_key == GDK_Up && row > 0)
2215         {
2216                 GtkTreeViewColumn *column;
2217                 gtk_tree_path_prev(treepath);
2218                 column = gtk_tree_view_get_column(treeview, 1);
2219                 gtk_tree_view_set_cursor(treeview, treepath, column, TRUE);
2220         }
2221         gtk_tree_path_free (treepath);
2222 }
2223
2224 void
2225 chapter_list_selection_changed_cb(GtkTreeSelection *selection, signal_user_data_t *ud)
2226 {
2227         g_debug("chapter_list_selection_changed_cb ()");
2228         //chapter_selection_changed = TRUE;
2229 }
2230
2231 void
2232 debug_log_handler(const gchar *domain, GLogLevelFlags flags, const gchar *msg, gpointer data)
2233 {
2234         signal_user_data_t *ud = (signal_user_data_t*)data;
2235
2236         if (ud->debug)
2237         {
2238                 printf("%s: %s\n", domain, msg);
2239         }
2240 }
2241
2242 static void
2243 set_visible(GtkWidget *widget, gboolean visible)
2244 {
2245         if (visible)
2246         {
2247                 gtk_widget_show_now(widget);
2248         }
2249         else
2250         {
2251                 gtk_widget_hide(widget);
2252         }
2253 }
2254
2255 void
2256 ghb_hbfd(signal_user_data_t *ud, gboolean hbfd)
2257 {
2258         GtkWidget *widget;
2259         g_debug("ghb_hbfd");
2260         widget = GHB_WIDGET(ud->builder, "queue_pause1");
2261         set_visible(widget, !hbfd);
2262         widget = GHB_WIDGET(ud->builder, "queue_add");
2263         set_visible(widget, !hbfd);
2264         widget = GHB_WIDGET(ud->builder, "show_queue");
2265         set_visible(widget, !hbfd);
2266         widget = GHB_WIDGET(ud->builder, "show_activity");
2267         set_visible(widget, !hbfd);
2268
2269         widget = GHB_WIDGET(ud->builder, "chapter_box");
2270         set_visible(widget, !hbfd);
2271         widget = GHB_WIDGET(ud->builder, "container_box");
2272         set_visible(widget, !hbfd);
2273         widget = GHB_WIDGET(ud->builder, "settings_box");
2274         set_visible(widget, !hbfd);
2275         widget = GHB_WIDGET(ud->builder, "presets_save");
2276         set_visible(widget, !hbfd);
2277         widget = GHB_WIDGET(ud->builder, "presets_remove");
2278         set_visible(widget, !hbfd);
2279         widget = GHB_WIDGET(ud->builder, "presets_default");
2280         set_visible(widget, !hbfd);
2281         widget = GHB_WIDGET (ud->builder, "hb_window");
2282         gtk_window_resize(GTK_WINDOW(widget), 16, 16);
2283
2284 }
2285
2286 void
2287 hbfd_toggled_cb(GtkWidget *widget, signal_user_data_t *ud)
2288 {
2289         g_debug("hbfd_toggled_cb");
2290         ghb_widget_to_setting (ud->settings, widget);
2291         gboolean hbfd = ghb_settings_get_boolean(ud->settings, "hbfd");
2292         ghb_hbfd(ud, hbfd);
2293         ghb_pref_save(ud->settings, "hbfd");
2294 }
2295
2296 void
2297 pref_changed_cb(GtkWidget *widget, signal_user_data_t *ud)
2298 {
2299         g_debug("pref_changed_cb");
2300         ghb_widget_to_setting (ud->settings, widget);
2301         ghb_check_dependency(ud, widget);
2302         const gchar *name = gtk_widget_get_name(widget);
2303         ghb_pref_save(ud->settings, name);
2304 }
2305
2306 void
2307 tweaks_changed_cb(GtkWidget *widget, signal_user_data_t *ud)
2308 {
2309         g_debug("tweaks_changed_cb");
2310         ghb_widget_to_setting (ud->settings, widget);
2311         const gchar *name = gtk_widget_get_name(widget);
2312         ghb_pref_save(ud->settings, name);
2313
2314         gboolean tweaks = ghb_settings_get_boolean(ud->settings, "allow_tweaks");
2315         widget = GHB_WIDGET(ud->builder, "PictureDeinterlace");
2316         tweaks ? gtk_widget_hide(widget) : gtk_widget_show(widget);
2317         widget = GHB_WIDGET(ud->builder, "tweak_PictureDeinterlace");
2318         !tweaks ? gtk_widget_hide(widget) : gtk_widget_show(widget);
2319
2320         widget = GHB_WIDGET(ud->builder, "PictureDenoise");
2321         tweaks ? gtk_widget_hide(widget) : gtk_widget_show(widget);
2322         widget = GHB_WIDGET(ud->builder, "tweak_PictureDenoise");
2323         !tweaks ? gtk_widget_hide(widget) : gtk_widget_show(widget);
2324         if (tweaks)
2325         {
2326                 const GValue *value;
2327                 value = ghb_settings_get_value(ud->settings, "PictureDeinterlace");
2328                 ghb_ui_update(ud, "tweak_PictureDeinterlace", value);
2329                 value = ghb_settings_get_value(ud->settings, "PictureDenoise");
2330                 ghb_ui_update(ud, "tweak_PictureDenoise", value);
2331         }
2332         else
2333         {
2334                 const GValue *value;
2335                 value = ghb_settings_get_value(ud->settings, "tweak_PictureDeinterlace");
2336                 ghb_ui_update(ud, "PictureDeinterlace", value);
2337                 value = ghb_settings_get_value(ud->settings, "tweak_PictureDenoise");
2338                 ghb_ui_update(ud, "PictureDenoise", value);
2339         }
2340 }
2341
2342 void
2343 hbfd_feature_changed_cb(GtkWidget *widget, signal_user_data_t *ud)
2344 {
2345         g_debug("hbfd_feature_changed_cb");
2346         ghb_widget_to_setting (ud->settings, widget);
2347         const gchar *name = gtk_widget_get_name(widget);
2348         ghb_pref_save(ud->settings, name);
2349
2350         gboolean hbfd = ghb_settings_get_boolean(ud->settings, "hbfd_feature");
2351         GtkAction *action;
2352         if (hbfd)
2353         {
2354                 const GValue *val;
2355                 val = ghb_settings_get_value(ud->settings, "hbfd");
2356                 ghb_ui_update(ud, "hbfd", val);
2357         }
2358         action = GHB_ACTION (ud->builder, "hbfd");
2359         gtk_action_set_visible(action, hbfd);
2360 }
2361
2362 void
2363 ghb_file_menu_add_dvd(signal_user_data_t *ud)
2364 {
2365         GList *link, *drives;
2366
2367         GtkActionGroup *agroup = GTK_ACTION_GROUP(
2368                 gtk_builder_get_object(ud->builder, "actiongroup1"));
2369         GtkUIManager *ui = GTK_UI_MANAGER(
2370                 gtk_builder_get_object(ud->builder, "uimanager1"));
2371         guint merge_id = gtk_ui_manager_new_merge_id(ui);
2372
2373         link = drives = dvd_device_list();
2374         while (link != NULL)
2375         {
2376                 gchar *name = (gchar*)link->data;
2377                 // Create action for this drive
2378                 GtkAction *action = gtk_action_new(name, name,
2379                         "Scan this DVD source", "gtk-cdrom");
2380                 // Add action to action group
2381                 gtk_action_group_add_action_with_accel(agroup, action, "");
2382                 // Add to ui manager
2383                 gtk_ui_manager_add_ui(ui, merge_id,
2384                         "ui/menubar1/menuitem1/quit1", name, name,
2385                         GTK_UI_MANAGER_AUTO, TRUE);
2386                 // Connect signal to action (menu item)
2387                 g_signal_connect(action, "activate",
2388                         (GCallback)dvd_source_activate_cb, ud);
2389                 g_free(name);
2390                 link = link->next;
2391         }
2392         g_list_free(drives);
2393
2394         // Add separator
2395         gtk_ui_manager_add_ui(ui, merge_id,
2396                 "ui/menubar1/menuitem1/quit1", "", NULL,
2397                 GTK_UI_MANAGER_AUTO, TRUE);
2398 }
2399
2400 gboolean ghb_is_cd(GDrive *gd);
2401
2402 static GList*
2403 dvd_device_list()
2404 {
2405         GVolumeMonitor *gvm;
2406         GList *drives, *link;
2407         GList *dvd_devices = NULL;
2408
2409         gvm = g_volume_monitor_get ();
2410         drives = g_volume_monitor_get_connected_drives (gvm);
2411         link = drives;
2412         while (link != NULL)
2413         {
2414                 GDrive *gd;
2415
2416                 gd = (GDrive*)link->data;
2417                 if (ghb_is_cd(gd))
2418                 {
2419                         gchar *device;
2420                         device = g_drive_get_identifier(gd, G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE);
2421                         dvd_devices = g_list_append(dvd_devices, (gpointer)device);
2422                 }
2423                 g_object_unref (gd);
2424                 link = link->next;
2425         }
2426         g_list_free(drives);
2427         return dvd_devices;
2428 }
2429
2430
2431 static DBusConnection *dbus_connection = NULL;
2432 static LibHalContext *hal_ctx;
2433
2434 gboolean
2435 ghb_is_cd(GDrive *gd)
2436 {
2437         gchar *device;
2438         LibHalDrive *halDrive;
2439         LibHalDriveType dtype;
2440
2441         device = g_drive_get_identifier(gd, G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE);
2442         halDrive = libhal_drive_from_device_file (hal_ctx, device);
2443         dtype = libhal_drive_get_type(halDrive);
2444         libhal_drive_free(halDrive);
2445         g_free(device);
2446         return (dtype == LIBHAL_DRIVE_TYPE_CDROM);
2447 }
2448
2449 void
2450 drive_changed_cb(GVolumeMonitor *gvm, GDrive *gd, signal_user_data_t *ud)
2451 {
2452         gchar *device;
2453         gint state = ghb_get_scan_state();
2454         static gboolean first_time = TRUE;
2455
2456         if (state != GHB_STATE_IDLE) return;
2457         if (ud->current_dvd_device == NULL) return;
2458         // A drive change event happens when the program initially starts
2459         // and I don't want to automatically scan at that time.
2460         if (first_time)
2461         {
2462                 first_time = FALSE;
2463                 return;
2464         }
2465         device = g_drive_get_identifier(gd, G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE);
2466
2467         // DVD insertion detected.  Scan it.
2468         if (strcmp(device, ud->current_dvd_device) == 0)
2469         {
2470                 if (g_drive_has_media (gd))
2471                 {
2472                         GtkProgressBar *progress;
2473                         progress = GTK_PROGRESS_BAR(GHB_WIDGET (ud->builder, "progressbar"));
2474                         gtk_progress_bar_set_text (progress, "Scanning ...");
2475                         gtk_progress_bar_set_fraction (progress, 0);
2476                         update_source_label(ud, device);
2477                         ghb_hb_cleanup(TRUE);
2478                         prune_logs(ud);
2479                         ghb_backend_scan(device, 0);
2480                 }
2481                 else
2482                 {
2483                         ghb_hb_cleanup(TRUE);
2484                         prune_logs(ud);
2485                         ghb_backend_scan("/dev/null", 0);
2486                 }
2487         }
2488         g_free(device);
2489 }
2490
2491
2492 static gboolean
2493 dbus_init (void)
2494 {
2495         DBusError error;
2496
2497         if (dbus_connection != NULL)
2498                 return TRUE;
2499
2500         dbus_error_init (&error);
2501         if (!(dbus_connection = dbus_bus_get (DBUS_BUS_SYSTEM, &error))) {
2502                 g_debug ("could not get system bus: %s", error.message);
2503                 dbus_error_free (&error);
2504                 return FALSE;
2505         }
2506
2507         //dbus_connection_setup_with_g_main (dbus_connection, NULL);
2508         //dbus_connection_set_exit_on_disconnect (dbus_connection, FALSE);
2509         //dbus_connection_add_filter (dbus_connection, gvm_dbus_filter_function, NULL, NULL);
2510
2511         return TRUE;
2512 }
2513
2514 void
2515 ghb_hal_init()
2516 {
2517         DBusError error;
2518         char **devices;
2519         int nr;
2520
2521         if (!dbus_init ())
2522                 return;
2523
2524         if (!(hal_ctx = libhal_ctx_new ())) {
2525                 g_warning ("failed to create a HAL context!");
2526                 return;
2527         }
2528
2529         libhal_ctx_set_dbus_connection (hal_ctx, dbus_connection);
2530         dbus_error_init (&error);
2531         if (!libhal_ctx_init (hal_ctx, &error)) {
2532                 g_warning ("libhal_ctx_init failed: %s", error.message ? error.message : "unknown");
2533                 dbus_error_free (&error);
2534                 libhal_ctx_free (hal_ctx);
2535                 return;
2536         }
2537
2538         /*
2539          * Do something to ping the HAL daemon - the above functions will
2540          * succeed even if hald is not running, so long as DBUS is.  But we
2541          * want to exit silently if hald is not running, to behave on
2542          * pre-2.6 systems.
2543          */
2544         if (!(devices = libhal_get_all_devices (hal_ctx, &nr, &error))) {
2545                 g_warning ("seems that HAL is not running: %s", error.message ? error.message : "unknown");
2546                 dbus_error_free (&error);
2547
2548                 libhal_ctx_shutdown (hal_ctx, NULL);
2549                 libhal_ctx_free (hal_ctx);
2550                 return;
2551         }
2552
2553         libhal_free_string_array (devices);
2554
2555         //gvm_hal_claim_branch ("/org/freedesktop/Hal/devices/local");
2556 }
2557
2558 gboolean
2559 tweak_setting_cb(
2560         GtkWidget *widget,
2561         GdkEventButton *event,
2562         signal_user_data_t *ud)
2563 {
2564         const gchar *name;
2565         gchar *tweak_name;
2566         gboolean ret = FALSE;
2567         gboolean allow_tweaks;
2568
2569         g_debug("press %d %d", event->type, event->button);
2570         allow_tweaks = ghb_settings_get_boolean(ud->settings, "allow_tweaks");
2571         if (allow_tweaks && event->type == GDK_BUTTON_PRESS && event->button == 3)
2572         { // Its a right mouse click
2573                 GtkWidget *dialog;
2574                 GtkEntry *entry;
2575                 GtkResponseType response;
2576                 gchar *tweak = NULL;
2577
2578                 name = gtk_widget_get_name(widget);
2579                 if (g_str_has_prefix(name, "tweak_"))
2580                 {
2581                         tweak_name = g_strdup(name);
2582                 }
2583                 else
2584                 {
2585                         tweak_name = g_strdup_printf("tweak_%s", name);
2586                 }
2587
2588                 tweak = ghb_settings_get_string (ud->settings, tweak_name);
2589                 dialog = GHB_WIDGET(ud->builder, "tweak_dialog");
2590                 gtk_window_set_title(GTK_WINDOW(dialog), tweak_name);
2591                 entry = GTK_ENTRY(GHB_WIDGET(ud->builder, "tweak_setting"));
2592                 if (tweak)
2593                 {
2594                         gtk_entry_set_text(entry, tweak);
2595                         g_free(tweak);
2596                 }
2597                 response = gtk_dialog_run(GTK_DIALOG(dialog));
2598                 gtk_widget_hide(dialog);
2599                 if (response == GTK_RESPONSE_OK)
2600                 {
2601                         tweak = (gchar*)gtk_entry_get_text(entry);
2602                         if (ghb_validate_filter_string(tweak, -1))
2603                                 ghb_settings_set_string(ud->settings, tweak_name, tweak);
2604                         else
2605                         {
2606                                 gchar *message;
2607                                 message = g_strdup_printf(
2608                                                         "Invalid Settings:\n%s",
2609                                                         tweak);
2610                                 ghb_message_dialog(GTK_MESSAGE_ERROR, message, "Cancel", NULL);
2611                                 g_free(message);
2612                         }
2613                 }
2614                 g_free(tweak_name);
2615                 ret = TRUE;
2616         }
2617         return ret;
2618 }
2619
2620 gboolean
2621 easter_egg_cb(
2622         GtkWidget *widget,
2623         GdkEventButton *event,
2624         signal_user_data_t *ud)
2625 {
2626         g_debug("press %d %d", event->type, event->button);
2627         if (event->type == GDK_3BUTTON_PRESS && event->button == 1)
2628         { // Its a tripple left mouse button click
2629                 GtkWidget *widget;
2630                 widget = GHB_WIDGET(ud->builder, "allow_tweaks");
2631                 gtk_widget_show(widget);
2632                 widget = GHB_WIDGET(ud->builder, "hbfd_feature");
2633                 gtk_widget_show(widget);
2634         }
2635         else if (event->type == GDK_BUTTON_PRESS && event->button == 1)
2636         {
2637                 GtkWidget *widget;
2638                 widget = GHB_WIDGET(ud->builder, "allow_tweaks");
2639                 gtk_widget_hide(widget);
2640                 widget = GHB_WIDGET(ud->builder, "hbfd_feature");
2641                 gtk_widget_hide(widget);
2642         }
2643         return FALSE;
2644 }
2645
2646 gchar*
2647 format_deblock_cb(GtkScale *scale, gdouble val, signal_user_data_t *ud)
2648 {
2649         if (val < 5.0)
2650         {
2651                 return g_strdup_printf("Off");
2652         }
2653         else
2654         {
2655                 return g_strdup_printf("%d", (gint)val);
2656         }
2657 }
2658
2659 gchar*
2660 format_vquality_cb(GtkScale *scale, gdouble val, signal_user_data_t *ud)
2661 {
2662         if (ghb_settings_get_boolean(ud->settings, "directqp"))
2663         {
2664                 gint vcodec = ghb_settings_combo_int(ud->settings, "VideoEncoder");
2665                 // Only x264 and ffmpeg currently support direct qp/crf entry
2666                 if (vcodec != HB_VCODEC_X264 && vcodec != HB_VCODEC_FFMPEG)
2667                 {
2668                         val *= 100;
2669                         return g_strdup_printf("%.1f", val);
2670                 }
2671                 return g_strdup_printf("%d", (gint)val);
2672         }
2673         else
2674         {
2675                 val *= 100;
2676                 return g_strdup_printf("%.1f", val);
2677         }
2678 }
2679
2680 static void
2681 html_link_cb(GtkHTML *html, const gchar *url, signal_user_data_t *ud)
2682 {
2683         browse_url(url);
2684 }
2685
2686 static gpointer check_stable_update(signal_user_data_t *ud);
2687 static gboolean stable_update_lock = FALSE;
2688
2689 static void
2690 process_appcast(signal_user_data_t *ud)
2691 {
2692         gchar *description = NULL, *build = NULL, *version = NULL, *msg;
2693         GtkWidget *html, *window, *dialog, *label;
2694         gint    response, ibuild = 0, skip;
2695
2696         if (ud->appcast == NULL || ud->appcast_len < 15 ||
2697                 strncmp(&(ud->appcast[9]), "200 OK", 6))
2698         {
2699                 if (!stable_update_lock && HB_BUILD % 100)
2700                         g_idle_add((GSourceFunc)check_stable_update, ud);
2701                 goto done;
2702         }
2703         ghb_appcast_parse(ud->appcast, &description, &build, &version);
2704         if (build)
2705                 ibuild = g_strtod(build, NULL);
2706         skip = ghb_settings_get_int(ud->settings, "update_skip_version");
2707         if (description == NULL || build == NULL || version == NULL
2708                 || ibuild <= HB_BUILD || skip == ibuild)
2709         {
2710                 if (!stable_update_lock && HB_BUILD % 100)
2711                         g_thread_create((GThreadFunc)check_stable_update, ud, FALSE, NULL);
2712                 goto done;
2713         }
2714         msg = g_strdup_printf("HandBrake %s/%s is now available (you have %s/%d).",
2715                         version, build, HB_VERSION, HB_BUILD);
2716         label = GHB_WIDGET(ud->builder, "update_message");
2717         gtk_label_set_text(GTK_LABEL(label), msg);
2718         html = gtk_html_new_from_string(description, -1);
2719         g_signal_connect(html, "link_clicked", G_CALLBACK(html_link_cb), ud);
2720         window = GHB_WIDGET(ud->builder, "update_scroll");
2721         gtk_container_add(GTK_CONTAINER(window), html);
2722         // Show it
2723         dialog = GHB_WIDGET(ud->builder, "update_dialog");
2724         gtk_widget_set_size_request(html, 420, 240);
2725         gtk_widget_show(html);
2726         response = gtk_dialog_run(GTK_DIALOG(dialog));
2727         gtk_widget_hide(dialog);
2728         gtk_widget_destroy(html);
2729         if (response == GTK_RESPONSE_OK)
2730         {
2731                 // Skip
2732                 ghb_settings_set_int(ud->settings, "update_skip_version", ibuild);
2733                 ghb_pref_save(ud->settings, "update_skip_version");
2734         }
2735         g_free(msg);
2736
2737 done:
2738         if (description) g_free(description);
2739         if (build) g_free(build);
2740         if (version) g_free(version);
2741         g_free(ud->appcast);
2742         ud->appcast_len = 0;
2743         ud->appcast = NULL;
2744 }
2745
2746 void
2747 ghb_net_close(GIOChannel *ioc)
2748 {
2749         gint fd;
2750
2751         g_debug("ghb_net_close");
2752         if (ioc == NULL) return;
2753         fd = g_io_channel_unix_get_fd(ioc);
2754         close(fd);
2755         g_io_channel_unref(ioc);
2756 }
2757
2758 gboolean
2759 ghb_net_recv_cb(GIOChannel *ioc, GIOCondition cond, gpointer data)
2760 {
2761         gchar buf[2048];
2762         gsize len;
2763         GError *gerror = NULL;
2764         GIOStatus status;
2765
2766         g_debug("ghb_net_recv_cb");
2767         signal_user_data_t *ud = (signal_user_data_t*)data;
2768
2769         status = g_io_channel_read_chars (ioc, buf, 2048, &len, &gerror);
2770         if ((status == G_IO_STATUS_NORMAL || status == G_IO_STATUS_EOF) &&
2771                 len > 0)
2772         {
2773                 gint new_len = ud->appcast_len + len;
2774                 ud->appcast = g_realloc(ud->appcast, new_len + 1);
2775                 memcpy(&(ud->appcast[ud->appcast_len]), buf, len);
2776                 ud->appcast_len = new_len;
2777         }
2778         if (status == G_IO_STATUS_EOF)
2779         {
2780                 ud->appcast[ud->appcast_len] = 0;
2781                 ghb_net_close(ioc);
2782                 process_appcast(ud);
2783                 return FALSE;
2784         }
2785         return TRUE;
2786 }
2787
2788 GIOChannel*
2789 ghb_net_open(signal_user_data_t *ud, gchar *address, gint port)
2790 {
2791         GIOChannel *ioc;
2792         gint fd;
2793
2794         struct sockaddr_in   sock;
2795         struct hostent     * host;
2796
2797         g_debug("ghb_net_open");
2798         if( !( host = gethostbyname( address ) ) )
2799         {
2800                 g_warning( "gethostbyname failed (%s)", address );
2801                 return NULL;
2802         }
2803
2804         memset( &sock, 0, sizeof( struct sockaddr_in ) );
2805         sock.sin_family = host->h_addrtype;
2806         sock.sin_port   = htons( port );
2807         memcpy( &sock.sin_addr, host->h_addr, host->h_length );
2808
2809         fd = socket(host->h_addrtype, SOCK_STREAM, 0);
2810         if( fd < 0 )
2811         {
2812                 g_debug( "socket failed" );
2813                 return NULL;
2814         }
2815
2816         if(connect(fd, (struct sockaddr*)&sock, sizeof(struct sockaddr_in )) < 0 )
2817         {
2818                 g_debug( "connect failed" );
2819                 return NULL;
2820         }
2821         ioc = g_io_channel_unix_new(fd);
2822         g_io_channel_set_encoding (ioc, NULL, NULL);
2823         g_io_channel_set_flags(ioc, G_IO_FLAG_NONBLOCK, NULL);
2824         g_io_add_watch (ioc, G_IO_IN, ghb_net_recv_cb, (gpointer)ud );
2825
2826         return ioc;
2827 }
2828
2829 gpointer
2830 ghb_check_update(signal_user_data_t *ud)
2831 {
2832         gchar *query;
2833         gsize len;
2834         GIOChannel *ioc;
2835         GError *gerror = NULL;
2836
2837         g_debug("ghb_check_update");
2838         if (HB_BUILD % 100)
2839         {
2840         query =
2841                 "GET /appcast_unstable.xml HTTP/1.0\r\nHost: handbrake.fr\r\n\r\n";
2842         }
2843         else
2844         {
2845                 stable_update_lock = TRUE;
2846         query = "GET /appcast.xml HTTP/1.0\r\nHost: handbrake.fr\r\n\r\n";
2847         }
2848         ioc = ghb_net_open(ud, "handbrake.fr", 80);
2849         if (ioc == NULL)
2850                 return NULL;
2851
2852         g_io_channel_write_chars(ioc, query, strlen(query), &len, &gerror);
2853         g_io_channel_flush(ioc, &gerror);
2854         // This function is initiated by g_idle_add.  Must return false
2855         // so that it is not called again
2856         return NULL;
2857 }
2858
2859 static gpointer
2860 check_stable_update(signal_user_data_t *ud)
2861 {
2862         gchar *query;
2863         gsize len;
2864         GIOChannel *ioc;
2865         GError *gerror = NULL;
2866
2867         g_debug("check_stable_update");
2868         stable_update_lock = TRUE;
2869         query = "GET /appcast.xml HTTP/1.0\r\nHost: handbrake.fr\r\n\r\n";
2870         ioc = ghb_net_open(ud, "handbrake.fr", 80);
2871         if (ioc == NULL)
2872                 return NULL;
2873
2874         g_io_channel_write_chars(ioc, query, strlen(query), &len, &gerror);
2875         g_io_channel_flush(ioc, &gerror);
2876         // This function is initiated by g_idle_add.  Must return false
2877         // so that it is not called again
2878         return NULL;
2879 }
2880