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 <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 const gchar*
 162 ghb_settings_combo_option(const GValue *settings, const gchar *key)
 163 {
 164         return ghb_lookup_combo_option(key, ghb_settings_get_value(settings, key));
 165 }
 166
 167 // Map widget names to setting keys
 168 // Widgets that map to settings have names
 169 // of this format: s_<setting key>
 170 static const gchar*
 171 get_setting_key(GtkWidget *widget)
 172 {
 173         const gchar *name;
 174
 175         g_debug("get_setting_key ()\n");
 176         if (widget == NULL) return NULL;
 177         if (GTK_IS_ACTION(widget))
 178                 name = gtk_action_get_name(GTK_ACTION(widget));
 179         else
 180                 name = gtk_widget_get_name(widget);
 181
 182         if (name == NULL)
 183         {
 184                 // Bad widget pointer?  Should never happen.
 185                 g_debug("Bad widget\n");
 186                 return NULL;
 187         }
 188         return name;
 189 }
 190
 191 GValue*
 192 ghb_widget_value(GtkWidget *widget)
 193 {
 194         GValue *value = NULL;
 195         const gchar *name;
 196         GType type;
 197
 198         if (widget == NULL)
 199         {
 200                 g_debug("NULL widget\n");
 201                 return NULL;
 202         }
 203
 204         type = GTK_WIDGET_TYPE(widget);
 205         if (GTK_IS_ACTION(widget))
 206                 name = gtk_action_get_name(GTK_ACTION(widget));
 207         else
 208                 name = gtk_widget_get_name(widget);
 209         g_debug("ghb_widget_value widget (%s)\n", name);
 210         if (type == GTK_TYPE_ENTRY)
 211         {
 212                 const gchar *str = gtk_entry_get_text(GTK_ENTRY(widget));
 213                 value = ghb_string_value_new(str);
 214         }
 215         else if (type == GTK_TYPE_RADIO_BUTTON)
 216         {
 217                 g_debug("\tradio_button");
 218                 gboolean bval;
 219                 bval = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget));
 220                 value = ghb_boolean_value_new(bval);
 221         }
 222         else if (type == GTK_TYPE_CHECK_BUTTON)
 223         {
 224                 g_debug("\tcheck_button");
 225                 gboolean bval;
 226                 bval = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget));
 227                 value = ghb_boolean_value_new(bval);
 228         }
 229         else if (type == GTK_TYPE_TOGGLE_ACTION)
 230         {
 231                 g_debug("\ttoggle action");
 232                 gboolean bval;
 233                 bval = gtk_toggle_action_get_active(GTK_TOGGLE_ACTION(widget));
 234                 value = ghb_boolean_value_new(bval);
 235         }
 236         else if (type == GTK_TYPE_CHECK_MENU_ITEM)
 237         {
 238                 g_debug("\tcheck_menu_item");
 239                 gboolean bval;
 240                 bval = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(widget));
 241                 value = ghb_boolean_value_new(bval);
 242         }
 243         else if (type == GTK_TYPE_COMBO_BOX)
 244         {
 245                 g_debug("\tcombo_box");
 246                 GtkTreeModel *store;
 247                 GtkTreeIter iter;
 248                 gchar *shortOpt;
 249
 250                 store = gtk_combo_box_get_model(GTK_COMBO_BOX(widget));
 251                 if (gtk_combo_box_get_active_iter(GTK_COMBO_BOX(widget), &iter))
 252                 {
 253                         gtk_tree_model_get(store, &iter, 2, &shortOpt, -1);
 254                         value = ghb_string_value_new(shortOpt);
 255                         g_free(shortOpt);
 256                 }
 257                 else
 258                 {
 259                         value = ghb_string_value_new("");
 260                 }
 261         }
 262         else if (type == GTK_TYPE_COMBO_BOX_ENTRY)
 263         {
 264                 GtkTreeModel *store;
 265                 GtkTreeIter iter;
 266                 gchar *shortOpt;
 267
 268                 g_debug("\tcombo_box_entry");
 269                 store = gtk_combo_box_get_model(GTK_COMBO_BOX(widget));
 270                 if (gtk_combo_box_get_active_iter(GTK_COMBO_BOX(widget), &iter))
 271                 {
 272                         gtk_tree_model_get(store, &iter, 2, &shortOpt, -1);
 273                         value = ghb_string_value_new(shortOpt);
 274                         g_free(shortOpt);
 275                 }
 276                 else
 277                 {
 278                         const gchar *str;
 279                         str = gtk_combo_box_get_active_text(GTK_COMBO_BOX(widget));
 280                         if (str == NULL) str = "";
 281                         value = ghb_string_value_new(str);
 282                 }
 283         }
 284         else if (type == GTK_TYPE_SPIN_BUTTON)
 285         {
 286                 gint ival;
 287                 ival = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(widget));
 288                 value = ghb_int64_value_new(ival);
 289         }
 290         else if (type == GTK_TYPE_HSCALE)
 291         {
 292                 gdouble dval;
 293                 gint digits;
 294
 295                 digits = gtk_scale_get_digits(GTK_SCALE(widget));
 296                 dval = gtk_range_get_value(GTK_RANGE(widget));
 297                 if (digits)
 298                 {
 299                         value = ghb_double_value_new(dval);
 300                 }
 301                 else
 302                 {
 303                         value = ghb_int_value_new(dval);
 304                 }
 305         }
 306         else if (type == GTK_TYPE_TEXT_VIEW)
 307         {
 308                 GtkTextBuffer *buffer;
 309                 GtkTextIter start, end;
 310                 gchar *str;
 311
 312                 buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(widget));
 313                 gtk_text_buffer_get_bounds(buffer, &start, &end);
 314                 str = gtk_text_buffer_get_text(buffer, &start, &end, FALSE);
 315                 value = ghb_string_value_new(str);
 316                 g_free(str);
 317         }
 318         else if (type == GTK_TYPE_LABEL)
 319         {
 320                 const gchar *str;
 321                 str = gtk_label_get_text (GTK_LABEL(widget));
 322                 value = ghb_string_value_new(str);
 323         }
 324         else if (type == GTK_TYPE_FILE_CHOOSER_BUTTON)
 325         {
 326                 const gchar *str;
 327                 str = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER(widget));
 328                 value = ghb_string_value_new(str);
 329         }
 330         else
 331         {
 332                 g_debug("Attempt to set unknown widget type: %s\n", name);
 333                 g_free(value);
 334                 value = NULL;
 335         }
 336         return value;
 337 }
 338
 339 gchar*
 340 ghb_widget_string(GtkWidget *widget)
 341 {
 342         GValue *value;
 343         gchar *sval;
 344
 345         value = ghb_widget_value(widget);
 346         sval = ghb_value_string(value);
 347         ghb_value_free(value);
 348         return sval;
 349 }
 350
 351 gdouble
 352 ghb_widget_double(GtkWidget *widget)
 353 {
 354         GValue *value;
 355         gdouble dval;
 356
 357         value = ghb_widget_value(widget);
 358         dval = ghb_value_double(value);
 359         ghb_value_free(value);
 360         return dval;
 361 }
 362
 363 gint64
 364 ghb_widget_int64(GtkWidget *widget)
 365 {
 366         GValue *value;
 367         gint64 ival;
 368
 369         value = ghb_widget_value(widget);
 370         ival = ghb_value_int64(value);
 371         ghb_value_free(value);
 372         return ival;
 373 }
 374
 375 gint
 376 ghb_widget_int(GtkWidget *widget)
 377 {
 378         GValue *value;
 379         gint ival;
 380
 381         value = ghb_widget_value(widget);
 382         ival = (gint)ghb_value_int64(value);
 383         ghb_value_free(value);
 384         return ival;
 385 }
 386
 387 gint
 388 ghb_widget_boolean(GtkWidget *widget)
 389 {
 390         GValue *value;
 391         gboolean bval;
 392
 393         value = ghb_widget_value(widget);
 394         bval = ghb_value_boolean(value);
 395         ghb_value_free(value);
 396         return bval;
 397 }
 398
 399 void
 400 ghb_widget_to_setting(GValue *settings, GtkWidget *widget)
 401 {
 402         const gchar *key = NULL;
 403         GValue *value;
 404
 405         if (widget == NULL) return;
 406         g_debug("ghb_widget_to_setting");
 407         // Find corresponding setting
 408         key = get_setting_key(widget);
 409         if (key == NULL) return;
 410         value = ghb_widget_value(widget);
 411         if (value != NULL)
 412         {
 413                 ghb_settings_take_value(settings, key, value);
 414         }
 415         else
 416         {
 417                 g_debug("No value found for %s\n", key);
 418         }
 419 }
 420
 421 static void
 422 update_widget(GtkWidget *widget, const GValue *value)
 423 {
 424         GType type;
 425         gchar *str;
 426         gint ival;
 427         gdouble dval;
 428
 429         g_debug("update_widget");
 430         type = G_VALUE_TYPE(value);
 431         if (type == ghb_array_get_type() || type == ghb_dict_get_type())
 432                 return;
 433         if (value == NULL) return;
 434         str = ghb_value_string(value);
 435         ival = ghb_value_int(value);
 436         dval = ghb_value_double(value);
 437         type = GTK_OBJECT_TYPE(widget);
 438         if (type == GTK_TYPE_ENTRY)
 439         {
 440                 g_debug("entry");
 441                 gtk_entry_set_text((GtkEntry*)widget, str);
 442         }
 443         else if (type == GTK_TYPE_RADIO_BUTTON)
 444         {
 445                 g_debug("radio button");
 446                 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget), ival);
 447         }
 448         else if (type == GTK_TYPE_CHECK_BUTTON)
 449         {
 450                 g_debug("check button");
 451                 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget), ival);
 452         }
 453         else if (type == GTK_TYPE_TOGGLE_ACTION)
 454         {
 455                 g_debug("toggle action");
 456                 gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(widget), ival);
 457         }
 458         else if (type == GTK_TYPE_CHECK_MENU_ITEM)
 459         {
 460                 g_debug("check menu item");
 461                 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(widget), ival);
 462         }
 463         else if (type == GTK_TYPE_COMBO_BOX)
 464         {
 465                 GtkTreeModel *store;
 466                 GtkTreeIter iter;
 467                 gchar *shortOpt;
 468                 gint ivalue;
 469                 gboolean foundit = FALSE;
 470
 471                 g_debug("combo (%s)", str);
 472                 store = gtk_combo_box_get_model(GTK_COMBO_BOX(widget));
 473                 if (gtk_tree_model_get_iter_first (store, &iter))
 474                 {
 475                         do
 476                         {
 477                                 gtk_tree_model_get(store, &iter, 2, &shortOpt, -1);
 478                                 if (strcmp(shortOpt, str) == 0)
 479                                 {
 480                                         gtk_combo_box_set_active_iter (
 481                                                 GTK_COMBO_BOX(widget), &iter);
 482                                         g_free(shortOpt);
 483                                         foundit = TRUE;
 484                                         break;
 485                                 }
 486                                 g_free(shortOpt);
 487                         } while (gtk_tree_model_iter_next (store, &iter));
 488                 }
 489                 if (!foundit && gtk_tree_model_get_iter_first (store, &iter))
 490                 {
 491                         do
 492                         {
 493                                 gtk_tree_model_get(store, &iter, 3, &ivalue, -1);
 494                                 if (ivalue == ival)
 495                                 {
 496                                         gtk_combo_box_set_active_iter (
 497                                                 GTK_COMBO_BOX(widget), &iter);
 498                                         foundit = TRUE;
 499                                         break;
 500                                 }
 501                         } while (gtk_tree_model_iter_next (store, &iter));
 502                 }
 503                 if (!foundit)
 504                 {
 505                         gtk_combo_box_set_active (GTK_COMBO_BOX(widget), 0);
 506                 }
 507         }
 508         else if (type == GTK_TYPE_COMBO_BOX_ENTRY)
 509         {
 510                 GtkTreeModel *store;
 511                 GtkTreeIter iter;
 512                 gchar *shortOpt;
 513                 gint ivalue;
 514                 gboolean foundit = FALSE;
 515
 516                 g_debug("GTK_COMBO_BOX_ENTRY");
 517                 store = gtk_combo_box_get_model(GTK_COMBO_BOX(widget));
 518                 if (gtk_tree_model_get_iter_first (store, &iter))
 519                 {
 520                         do
 521                         {
 522                                 gtk_tree_model_get(store, &iter, 2, &shortOpt, -1);
 523                                 if (strcmp(shortOpt, str) == 0)
 524                                 {
 525                                         gtk_combo_box_set_active_iter (
 526                                                 GTK_COMBO_BOX(widget), &iter);
 527                                         g_free(shortOpt);
 528                                         foundit = TRUE;
 529                                         break;
 530                                 }
 531                                 g_free(shortOpt);
 532                         } while (gtk_tree_model_iter_next (store, &iter));
 533                 }
 534                 if (!foundit && gtk_tree_model_get_iter_first (store, &iter))
 535                 {
 536                         do
 537                         {
 538                                 gtk_tree_model_get(store, &iter, 3, &ivalue, -1);
 539                                 if (ivalue == ival)
 540                                 {
 541                                         gtk_combo_box_set_active_iter (
 542                                                 GTK_COMBO_BOX(widget), &iter);
 543                                         foundit = TRUE;
 544                                         break;
 545                                 }
 546                         } while (gtk_tree_model_iter_next (store, &iter));
 547                 }
 548                 if (!foundit)
 549                 {
 550                         GtkEntry *entry = GTK_ENTRY(gtk_bin_get_child(GTK_BIN(widget)));
 551                         if (entry)
 552                         {
 553                                 gtk_entry_set_text (entry, str);
 554                         }
 555                 }
 556         }
 557         else if (type == GTK_TYPE_SPIN_BUTTON)
 558         {
 559                 g_debug("spin (%s)", str);
 560                 gtk_spin_button_set_value(GTK_SPIN_BUTTON(widget), dval);
 561         }
 562         else if (type == GTK_TYPE_HSCALE)
 563         {
 564                 g_debug("hscale");
 565                 gtk_range_set_value(GTK_RANGE(widget), dval);
 566         }
 567         else if (type == GTK_TYPE_TEXT_VIEW)
 568         {
 569                 g_debug("textview (%s)", str);
 570                 GtkTextBuffer *buffer = gtk_text_view_get_buffer(
 571                                                                                                 GTK_TEXT_VIEW(widget));
 572                 gtk_text_buffer_set_text (buffer, str, -1);
 573         }
 574         else if (type == GTK_TYPE_LABEL)
 575         {
 576                 gtk_label_set_text (GTK_LABEL(widget), str);
 577         }
 578         else if (type == GTK_TYPE_FILE_CHOOSER_BUTTON)
 579         {
 580                 GtkFileChooserAction act;
 581                 act = gtk_file_chooser_get_action(GTK_FILE_CHOOSER(widget));
 582                 if (act == GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER ||
 583                         act == GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER)
 584                 {
 585                         gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(widget), str);
 586                 }
 587                 else
 588                 {
 589                         gtk_file_chooser_set_filename (GTK_FILE_CHOOSER(widget), str);
 590                 }
 591         }
 592         else
 593         {
 594                 g_debug("Attempt to set unknown widget type");
 595         }
 596         g_free(str);
 597 }
 598
 599 int
 600 ghb_ui_update(signal_user_data_t *ud, const gchar *name, const GValue *value)
 601 {
 602         GObject *object;
 603
 604         g_debug("ghb_ui_update() %s", name);
 605         if (name == NULL || value == NULL)
 606                 return 0;
 607         object = GHB_OBJECT(ud->builder, name);
 608         if (object == NULL)
 609         {
 610                 g_debug("Failed to find widget for key: %s\n", name);
 611                 return -1;
 612         }
 613         update_widget((GtkWidget*)object, value);
 614         // Its possible the value hasn't changed. Since settings are only
 615         // updated when the value changes, I'm initializing settings here as well.
 616         ghb_widget_to_setting(ud->settings, (GtkWidget*)object);
 617         return 0;
 618 }
 619