gtk/src/callbacks.c

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