gtk/src/settings.c

   1 /* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 4; tab-width: 4 -*- */
   2 /*
   3  * settings.c
   4  * Copyright (C) John Stebbins 2008-2011 <stebbins@stebbins>
   5  *
   6  * settings.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 #include <fcntl.h>
  15 #include <unistd.h>
  16 #include <glib.h>
  17 #include <glib/gstdio.h>
  18 #include <string.h>
  19 #include <gtk/gtk.h>
  20 #include "settings.h"
  21 #include "hb-backend.h"
  22 #include "values.h"
  23
  24 void dump_settings(GValue *settings);
  25 void ghb_pref_audio_init(signal_user_data_t *ud);
  26
  27 GObject*
  28 debug_get_object(GtkBuilder* b, const gchar *n)
  29 {
  30         g_message("name %s\n", n);
  31         return gtk_builder_get_object(b, n);
  32 }
  33
  34 GValue*
  35 ghb_settings_new()
  36 {
  37         return ghb_dict_value_new();
  38 }
  39
  40 void
  41 ghb_settings_set_value(
  42         GValue *settings,
  43         const gchar *key,
  44         const GValue *value)
  45 {
  46         if (key == NULL || value == NULL)
  47                 return;
  48         ghb_dict_insert(settings, g_strdup(key), ghb_value_dup(value));
  49 }
  50
  51 void
  52 ghb_settings_take_value(GValue *settings, const gchar *key, GValue *value)
  53 {
  54         ghb_dict_insert(settings, g_strdup(key), value);
  55 }
  56
  57 void
  58 ghb_settings_set_string(
  59         GValue *settings,
  60         const gchar *key,
  61         const gchar *sval)
  62 {
  63         GValue *value;
  64         value = ghb_string_value_new(sval);
  65         ghb_dict_insert(settings, g_strdup(key), value);
  66 }
  67
  68 void
  69 ghb_settings_set_double(GValue *settings, const gchar *key, gdouble dval)
  70 {
  71         GValue *value;
  72         value = ghb_double_value_new(dval);
  73         ghb_dict_insert(settings, g_strdup(key), value);
  74 }
  75
  76 void
  77 ghb_settings_set_int64(GValue *settings, const gchar *key, gint64 ival)
  78 {
  79         GValue *value;
  80         value = ghb_int64_value_new(ival);
  81         ghb_dict_insert(settings, g_strdup(key), value);
  82 }
  83
  84 void
  85 ghb_settings_set_int(GValue *settings, const gchar *key, gint ival)
  86 {
  87         GValue *value;
  88         value = ghb_int64_value_new((gint64)ival);
  89         ghb_dict_insert(settings, g_strdup(key), value);
  90 }
  91
  92 void
  93 ghb_settings_set_boolean(GValue *settings, const gchar *key, gboolean bval)
  94 {
  95         GValue *value;
  96         value = ghb_boolean_value_new(bval);
  97         ghb_dict_insert(settings, g_strdup(key), value);
  98 }
  99
 100 GValue*
 101 ghb_settings_get_value(const GValue *settings, const gchar *key)
 102 {
 103         GValue *value;
 104         value = ghb_dict_lookup(settings, key);
 105         if (value == NULL)
 106                 g_warning("returning null (%s)", key);
 107         return value;
 108 }
 109
 110 gboolean
 111 ghb_settings_get_boolean(const GValue *settings, const gchar *key)
 112 {
 113         const GValue* value;
 114         value = ghb_settings_get_value(settings, key);
 115         if (value == NULL) return FALSE;
 116         return ghb_value_boolean(value);
 117 }
 118
 119 gint64
 120 ghb_settings_get_int64(const GValue *settings, const gchar *key)
 121 {
 122         const GValue* value;
 123         value = ghb_settings_get_value(settings, key);
 124         if (value == NULL) return 0;
 125         return ghb_value_int64(value);
 126 }
 127
 128 gint
 129 ghb_settings_get_int(const GValue *settings, const gchar *key)
 130 {
 131         const GValue* value;
 132         value = ghb_settings_get_value(settings, key);
 133         if (value == NULL) return 0;
 134         return ghb_value_int(value);
 135 }
 136
 137 gdouble
 138 ghb_settings_get_double(const GValue *settings, const gchar *key)
 139 {
 140         const GValue* value;
 141         value = ghb_settings_get_value(settings, key);
 142         if (value == NULL) return 0;
 143         return ghb_value_double(value);
 144 }
 145
 146 gchar*
 147 ghb_settings_get_string(const GValue *settings, const gchar *key)
 148 {
 149         const GValue* value;
 150         value = ghb_settings_get_value(settings, key);
 151         if (value == NULL) return g_strdup("");
 152         return ghb_value_string(value);
 153 }
 154
 155 gint
 156 ghb_settings_combo_int(const GValue *settings, const gchar *key)
 157 {
 158         return ghb_lookup_combo_int(key, ghb_settings_get_value(settings, key));
 159 }
 160
 161 gdouble
 162 ghb_settings_combo_double(const GValue *settings, const gchar *key)
 163 {
 164         return ghb_lookup_combo_double(key, ghb_settings_get_value(settings, key));
 165 }
 166
 167 const gchar*
 168 ghb_settings_combo_option(const GValue *settings, const gchar *key)
 169 {
 170         return ghb_lookup_combo_option(key, ghb_settings_get_value(settings, key));
 171 }
 172
 173 const gchar*
 174 ghb_settings_combo_string(const GValue *settings, const gchar *key)
 175 {
 176         return ghb_lookup_combo_string(key, ghb_settings_get_value(settings, key));
 177 }
 178
 179 // Map widget names to setting keys
 180 // Widgets that map to settings have names
 181 // of this format: s_<setting key>
 182 const gchar*
 183 ghb_get_setting_key(GtkWidget *widget)
 184 {
 185         const gchar *name;
 186
 187         g_debug("get_setting_key ()\n");
 188         if (widget == NULL) return NULL;
 189         name = gtk_buildable_get_name(GTK_BUILDABLE(widget));
 190
 191         if (name == NULL)
 192         {
 193                 // Bad widget pointer?  Should never happen.
 194                 g_debug("Bad widget\n");
 195                 return NULL;
 196         }
 197         return name;
 198 }
 199
 200 GValue*
 201 ghb_widget_value(GtkWidget *widget)
 202 {
 203         GValue *value = NULL;
 204         const gchar *name;
 205         GType type;
 206
 207         if (widget == NULL)
 208         {
 209                 g_debug("NULL widget\n");
 210                 return NULL;
 211         }
 212
 213         type = GTK_WIDGET_TYPE(widget);
 214         name = ghb_get_setting_key(widget);
 215         g_debug("ghb_widget_value widget (%s)\n", name);
 216         if (type == GTK_TYPE_ENTRY)
 217         {
 218                 const gchar *str = gtk_entry_get_text(GTK_ENTRY(widget));
 219                 value = ghb_string_value_new(str);
 220         }
 221         else if (type == GTK_TYPE_RADIO_BUTTON)
 222         {
 223                 g_debug("\tradio_button");
 224                 gboolean bval;
 225                 bval = gtk_toggle_button_get_inconsistent(GTK_TOGGLE_BUTTON(widget));
 226                 if (bval)
 227                 {
 228                         value = ghb_boolean_value_new(FALSE);
 229                 }
 230                 else
 231                 {
 232                         bval = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget));
 233                         value = ghb_boolean_value_new(bval);
 234                 }
 235         }
 236         else if (type == GTK_TYPE_CHECK_BUTTON)
 237         {
 238                 g_debug("\tcheck_button");
 239                 gboolean bval;
 240                 bval = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget));
 241                 value = ghb_boolean_value_new(bval);
 242         }
 243         else if (type == GTK_TYPE_TOGGLE_TOOL_BUTTON)
 244         {
 245                 g_debug("\ttoggle_tool_button");
 246                 gboolean bval;
 247                 bval = gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON(widget));
 248                 value = ghb_boolean_value_new(bval);
 249         }
 250         else if (type == GTK_TYPE_TOGGLE_BUTTON)
 251         {
 252                 g_debug("\ttoggle_button");
 253                 gboolean bval;
 254                 bval = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget));
 255                 value = ghb_boolean_value_new(bval);
 256         }
 257         else if (type == GTK_TYPE_TOGGLE_ACTION)
 258         {
 259                 g_debug("\ttoggle action");
 260                 gboolean bval;
 261                 bval = gtk_toggle_action_get_active(GTK_TOGGLE_ACTION(widget));
 262                 value = ghb_boolean_value_new(bval);
 263         }
 264         else if (type == GTK_TYPE_CHECK_MENU_ITEM)
 265         {
 266                 g_debug("\tcheck_menu_item");
 267                 gboolean bval;
 268                 bval = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(widget));
 269                 value = ghb_boolean_value_new(bval);
 270         }
 271         else if (type == GTK_TYPE_COMBO_BOX)
 272         {
 273                 g_debug("\tcombo_box");
 274                 GtkTreeModel *store;
 275                 GtkTreeIter iter;
 276                 gchar *shortOpt;
 277
 278                 store = gtk_combo_box_get_model(GTK_COMBO_BOX(widget));
 279                 if (gtk_combo_box_get_active_iter(GTK_COMBO_BOX(widget), &iter))
 280                 {
 281                         gtk_tree_model_get(store, &iter, 2, &shortOpt, -1);
 282                         value = ghb_string_value_new(shortOpt);
 283                         g_free(shortOpt);
 284                 }
 285                 else
 286                 {
 287                         value = ghb_string_value_new("");
 288                 }
 289         }
 290         else if (type == GTK_TYPE_COMBO_BOX_ENTRY)
 291         {
 292                 GtkTreeModel *store;
 293                 GtkTreeIter iter;
 294                 gchar *shortOpt;
 295
 296                 g_debug("\tcombo_box_entry");
 297                 store = gtk_combo_box_get_model(GTK_COMBO_BOX(widget));
 298                 if (gtk_combo_box_get_active_iter(GTK_COMBO_BOX(widget), &iter))
 299                 {
 300                         gtk_tree_model_get(store, &iter, 2, &shortOpt, -1);
 301                         value = ghb_string_value_new(shortOpt);
 302                         g_free(shortOpt);
 303                 }
 304                 else
 305                 {
 306                         const gchar *str;
 307                         str = gtk_combo_box_get_active_text(GTK_COMBO_BOX(widget));
 308                         if (str == NULL) str = "";
 309                         value = ghb_string_value_new(str);
 310                 }
 311         }
 312         else if (type == GTK_TYPE_SPIN_BUTTON)
 313         {
 314                 gint ival;
 315                 ival = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(widget));
 316                 value = ghb_int64_value_new(ival);
 317         }
 318         else if (type == GTK_TYPE_HSCALE)
 319         {
 320                 gdouble dval;
 321                 gint digits;
 322
 323                 digits = gtk_scale_get_digits(GTK_SCALE(widget));
 324                 dval = gtk_range_get_value(GTK_RANGE(widget));
 325                 if (digits)
 326                 {
 327                         value = ghb_double_value_new(dval);
 328                 }
 329                 else
 330                 {
 331                         value = ghb_int_value_new(dval);
 332                 }
 333         }
 334         else if (type == GTK_TYPE_SCALE_BUTTON)
 335         {
 336                 gdouble dval;
 337
 338                 dval = gtk_scale_button_get_value(GTK_SCALE_BUTTON(widget));
 339                 value = ghb_double_value_new(dval);
 340         }
 341         else if (type == GTK_TYPE_TEXT_VIEW)
 342         {
 343                 GtkTextBuffer *buffer;
 344                 GtkTextIter start, end;
 345                 gchar *str;
 346
 347                 buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(widget));
 348                 gtk_text_buffer_get_bounds(buffer, &start, &end);
 349                 str = gtk_text_buffer_get_text(buffer, &start, &end, FALSE);
 350                 value = ghb_string_value_new(str);
 351                 g_free(str);
 352         }
 353         else if (type == GTK_TYPE_LABEL)
 354         {
 355                 const gchar *str;
 356                 str = gtk_label_get_text (GTK_LABEL(widget));
 357                 value = ghb_string_value_new(str);
 358         }
 359         else if (type == GTK_TYPE_FILE_CHOOSER_BUTTON)
 360         {
 361                 gchar *str;
 362                 str = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER(widget));
 363                 if (str == NULL)
 364                         str = gtk_file_chooser_get_current_folder(GTK_FILE_CHOOSER(widget));
 365                 value = ghb_string_value_new(str);
 366                 if (str != NULL)
 367                         g_free(str);
 368         }
 369         else
 370         {
 371                 g_debug("Attempt to set unknown widget type: %s\n", name);
 372                 g_free(value);
 373                 value = NULL;
 374         }
 375         return value;
 376 }
 377
 378 gchar*
 379 ghb_widget_string(GtkWidget *widget)
 380 {
 381         GValue *value;
 382         gchar *sval;
 383
 384         value = ghb_widget_value(widget);
 385         sval = ghb_value_string(value);
 386         ghb_value_free(value);
 387         return sval;
 388 }
 389
 390 gdouble
 391 ghb_widget_double(GtkWidget *widget)
 392 {
 393         GValue *value;
 394         gdouble dval;
 395
 396         value = ghb_widget_value(widget);
 397         dval = ghb_value_double(value);
 398         ghb_value_free(value);
 399         return dval;
 400 }
 401
 402 gint64
 403 ghb_widget_int64(GtkWidget *widget)
 404 {
 405         GValue *value;
 406         gint64 ival;
 407
 408         value = ghb_widget_value(widget);
 409         ival = ghb_value_int64(value);
 410         ghb_value_free(value);
 411         return ival;
 412 }
 413
 414 gint
 415 ghb_widget_int(GtkWidget *widget)
 416 {
 417         GValue *value;
 418         gint ival;
 419
 420         value = ghb_widget_value(widget);
 421         ival = (gint)ghb_value_int64(value);
 422         ghb_value_free(value);
 423         return ival;
 424 }
 425
 426 gint
 427 ghb_widget_boolean(GtkWidget *widget)
 428 {
 429         GValue *value;
 430         gboolean bval;
 431
 432         value = ghb_widget_value(widget);
 433         bval = ghb_value_boolean(value);
 434         ghb_value_free(value);
 435         return bval;
 436 }
 437
 438 static void check_radio_consistency(GValue *settings, GtkWidget *widget)
 439 {
 440         const gchar *key = NULL;
 441         GValue *value;
 442
 443         if (widget == NULL) return;
 444         if (G_OBJECT_TYPE(widget) == GTK_TYPE_RADIO_BUTTON)
 445         {
 446                 // Find corresponding setting
 447                 key = ghb_get_setting_key(widget);
 448                 if (key == NULL) return;
 449                 value = ghb_widget_value(widget);
 450                 if (value == NULL) return;
 451                 if (ghb_value_boolean(value) == ghb_settings_get_boolean(settings, key))
 452                 {
 453                         gtk_toggle_button_set_inconsistent(GTK_TOGGLE_BUTTON(widget), FALSE);
 454                 }
 455         }
 456 }
 457
 458 void
 459 ghb_widget_to_setting(GValue *settings, GtkWidget *widget)
 460 {
 461         const gchar *key = NULL;
 462         GValue *value;
 463
 464         if (widget == NULL) return;
 465         g_debug("ghb_widget_to_setting");
 466         // Find corresponding setting
 467         key = ghb_get_setting_key(widget);
 468         if (key == NULL) return;
 469         value = ghb_widget_value(widget);
 470         if (value != NULL)
 471         {
 472                 check_radio_consistency(settings, widget);
 473                 ghb_settings_take_value(settings, key, value);
 474         }
 475         else
 476         {
 477                 g_debug("No value found for %s\n", key);
 478         }
 479 }
 480
 481 static void
 482 update_widget(GtkWidget *widget, const GValue *value)
 483 {
 484         GType type;
 485         gchar *str;
 486         gint ival;
 487         gdouble dval;
 488
 489         g_debug("update_widget");
 490         type = G_VALUE_TYPE(value);
 491         if (type == ghb_array_get_type() || type == ghb_dict_get_type())
 492                 return;
 493         if (value == NULL) return;
 494         str = ghb_value_string(value);
 495         ival = ghb_value_int(value);
 496         dval = ghb_value_double(value);
 497         type = GTK_OBJECT_TYPE(widget);
 498         if (type == GTK_TYPE_ENTRY)
 499         {
 500                 g_debug("entry");
 501                 gtk_entry_set_text((GtkEntry*)widget, str);
 502         }
 503         else if (type == GTK_TYPE_RADIO_BUTTON)
 504         {
 505                 g_debug("radio button");
 506                 int cur_val = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget));
 507                 if (cur_val && !ival)
 508                 {
 509                         gtk_toggle_button_set_inconsistent(GTK_TOGGLE_BUTTON(widget), TRUE);
 510                 }
 511                 else
 512                 {
 513                         gtk_toggle_button_set_inconsistent(GTK_TOGGLE_BUTTON(widget), FALSE);
 514                         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget), ival);
 515                 }
 516         }
 517         else if (type == GTK_TYPE_CHECK_BUTTON)
 518         {
 519                 g_debug("check button");
 520                 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget), ival);
 521         }
 522         else if (type == GTK_TYPE_TOGGLE_TOOL_BUTTON)
 523         {
 524                 g_debug("toggle button");
 525                 gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(widget), ival);
 526         }
 527         else if (type == GTK_TYPE_TOGGLE_BUTTON)
 528         {
 529                 g_debug("toggle button");
 530                 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget), ival);
 531         }
 532         else if (type == GTK_TYPE_TOGGLE_ACTION)
 533         {
 534                 g_debug("toggle action");
 535                 gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(widget), ival);
 536         }
 537         else if (type == GTK_TYPE_CHECK_MENU_ITEM)
 538         {
 539                 g_debug("check menu item");
 540                 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(widget), ival);
 541         }
 542         else if (type == GTK_TYPE_COMBO_BOX)
 543         {
 544                 GtkTreeModel *store;
 545                 GtkTreeIter iter;
 546                 gchar *shortOpt;
 547                 gdouble ivalue;
 548                 gboolean foundit = FALSE;
 549
 550                 g_debug("combo (%s)", str);
 551                 store = gtk_combo_box_get_model(GTK_COMBO_BOX(widget));
 552                 if (gtk_tree_model_get_iter_first (store, &iter))
 553                 {
 554                         do
 555                         {
 556                                 gtk_tree_model_get(store, &iter, 2, &shortOpt, -1);
 557                                 if (strcmp(shortOpt, str) == 0)
 558                                 {
 559                                         gtk_combo_box_set_active_iter (
 560                                                 GTK_COMBO_BOX(widget), &iter);
 561                                         g_free(shortOpt);
 562                                         foundit = TRUE;
 563                                         break;
 564                                 }
 565                                 g_free(shortOpt);
 566                         } while (gtk_tree_model_iter_next (store, &iter));
 567                 }
 568                 if (!foundit && gtk_tree_model_get_iter_first (store, &iter))
 569                 {
 570                         do
 571                         {
 572                                 gtk_tree_model_get(store, &iter, 3, &ivalue, -1);
 573                                 if ((gint)ivalue == ival || ivalue == dval)
 574                                 {
 575                                         gtk_combo_box_set_active_iter (
 576                                                 GTK_COMBO_BOX(widget), &iter);
 577                                         foundit = TRUE;
 578                                         break;
 579                                 }
 580                         } while (gtk_tree_model_iter_next (store, &iter));
 581                 }
 582                 if (!foundit)
 583                 {
 584                         gtk_combo_box_set_active (GTK_COMBO_BOX(widget), 0);
 585                 }
 586         }
 587         else if (type == GTK_TYPE_COMBO_BOX_ENTRY)
 588         {
 589                 GtkTreeModel *store;
 590                 GtkTreeIter iter;
 591                 gchar *shortOpt;
 592                 gdouble ivalue;
 593                 gboolean foundit = FALSE;
 594
 595                 g_debug("GTK_COMBO_BOX_ENTRY");
 596                 store = gtk_combo_box_get_model(GTK_COMBO_BOX(widget));
 597                 if (gtk_tree_model_get_iter_first (store, &iter))
 598                 {
 599                         do
 600                         {
 601                                 gtk_tree_model_get(store, &iter, 2, &shortOpt, -1);
 602                                 if (strcmp(shortOpt, str) == 0)
 603                                 {
 604                                         gtk_combo_box_set_active_iter (
 605                                                 GTK_COMBO_BOX(widget), &iter);
 606                                         g_free(shortOpt);
 607                                         foundit = TRUE;
 608                                         break;
 609                                 }
 610                                 g_free(shortOpt);
 611                         } while (gtk_tree_model_iter_next (store, &iter));
 612                 }
 613                 if (!foundit && gtk_tree_model_get_iter_first (store, &iter))
 614                 {
 615                         do
 616                         {
 617                                 gtk_tree_model_get(store, &iter, 3, &ivalue, -1);
 618                                 if ((gint)ivalue == ival || ivalue == dval)
 619                                 {
 620                                         gtk_combo_box_set_active_iter (
 621                                                 GTK_COMBO_BOX(widget), &iter);
 622                                         foundit = TRUE;
 623                                         break;
 624                                 }
 625                         } while (gtk_tree_model_iter_next (store, &iter));
 626                 }
 627                 if (!foundit)
 628                 {
 629                         GtkEntry *entry = GTK_ENTRY(gtk_bin_get_child(GTK_BIN(widget)));
 630                         if (entry)
 631                         {
 632                                 gtk_entry_set_text (entry, str);
 633                         }
 634                 }
 635         }
 636         else if (type == GTK_TYPE_SPIN_BUTTON)
 637         {
 638                 g_debug("spin (%s)", str);
 639                 gtk_spin_button_set_value(GTK_SPIN_BUTTON(widget), dval);
 640         }
 641         else if (type == GTK_TYPE_HSCALE)
 642         {
 643                 g_debug("hscale");
 644                 gtk_range_set_value(GTK_RANGE(widget), dval);
 645         }
 646         else if (type == GTK_TYPE_SCALE_BUTTON)
 647         {
 648                 g_debug("scale_button");
 649                 gtk_scale_button_set_value(GTK_SCALE_BUTTON(widget), dval);
 650         }
 651         else if (type == GTK_TYPE_TEXT_VIEW)
 652         {
 653                 g_debug("textview (%s)", str);
 654                 GtkTextBuffer *buffer = gtk_text_view_get_buffer(
 655                                                                                                 GTK_TEXT_VIEW(widget));
 656                 gtk_text_buffer_set_text (buffer, str, -1);
 657         }
 658         else if (type == GTK_TYPE_LABEL)
 659         {
 660                 gtk_label_set_markup (GTK_LABEL(widget), str);
 661         }
 662         else if (type == GTK_TYPE_FILE_CHOOSER_BUTTON)
 663         {
 664                 GtkFileChooserAction act;
 665                 act = gtk_file_chooser_get_action(GTK_FILE_CHOOSER(widget));
 666                 if (str[0] == 0)
 667                 {
 668                         // Do nothing
 669                         ;
 670                 }
 671                 else if (act == GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER ||
 672                         act == GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER)
 673                 {
 674                         gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(widget), str);
 675                 }
 676                 else if (act == GTK_FILE_CHOOSER_ACTION_SAVE)
 677                 {
 678                         gtk_file_chooser_set_filename (GTK_FILE_CHOOSER(widget), str);
 679                 }
 680                 else
 681                 {
 682                         if (g_file_test(str, G_FILE_TEST_IS_DIR))
 683                         {
 684                                 gtk_file_chooser_set_current_folder(
 685                                         GTK_FILE_CHOOSER(widget), str);
 686                         }
 687                         else if (g_file_test(str, G_FILE_TEST_EXISTS))
 688                         {
 689                                 gtk_file_chooser_set_filename (GTK_FILE_CHOOSER(widget), str);
 690                         }
 691                         else
 692                         {
 693                                 gchar *dirname;
 694
 695                                 dirname = g_path_get_dirname(str);
 696                                 gtk_file_chooser_set_current_folder(
 697                                         GTK_FILE_CHOOSER(widget), dirname);
 698                                 g_free(dirname);
 699                         }
 700                 }
 701         }
 702         else
 703         {
 704                 g_debug("Attempt to set unknown widget type");
 705         }
 706         g_free(str);
 707 }
 708
 709 int
 710 ghb_ui_update(signal_user_data_t *ud, const gchar *name, const GValue *value)
 711 {
 712         GObject *object;
 713
 714         g_debug("ghb_ui_update() %s", name);
 715         if (name == NULL || value == NULL)
 716                 return 0;
 717         object = GHB_OBJECT(ud->builder, name);
 718         if (object == NULL)
 719         {
 720                 g_debug("Failed to find widget for key: %s\n", name);
 721                 return -1;
 722         }
 723         update_widget((GtkWidget*)object, value);
 724         // Its possible the value hasn't changed. Since settings are only
 725         // updated when the value changes, I'm initializing settings here as well.
 726         ghb_widget_to_setting(ud->settings, (GtkWidget*)object);
 727         return 0;
 728 }
 729