← Back to branch summary

~siretart/gxine/bug.542506

« back to all changes in this revision

Viewing changes to src/preferences.c

  • Committer: Bazaar Package Importer
  • Author(s): Reinhard Tartler
  • Date: 2008-03-21 11:24:59 UTC
  • mfrom: (1.1.8 upstream)
  • Revision ID: james.westby@ubuntu.com-20080321112459-igb0jy01nytpdrzt
Tags: 0.5.901-1ubuntu1
https://launchpad.net/bugs/204563
https://launchpad.net/bugs/128864
* merge debian changes for hardy PPA. Remaining changes:
  - debian/control: added Xb-Npp-xxx tags accordingly to "firefox distro
    add-on suport" spec,
    (https://blueprints.launchpad.net/ubuntu/+spec/firefox-distro-addon-support)
* Feature Freeze exception granted in LP: #204563
* New upstream release fixes playing DVDs. LP: #128864
* mime.default: add "x-content/video-dvd;x-content/video-vcd;x-content/video-svcd;"
  to get it listed as a player for dvd and video cds in nautilus. Thanks to
  Sebastien Bacher for the hint.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/preferences.c
1
1
/*
2
 
 * Copyright (C) 2001-2006 the xine project
 
2
 * Copyright (C) 2001-2007 the xine project
3
3
 *
4
4
 * This program is free software; you can redistribute it and/or modify
5
5
 * it under the terms of the GNU General Public License as published by
15
15
 * along with this program; if not, write to the Free Software
16
16
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
17
17
 *
18
 
 * $Id: preferences.c,v 1.61 2006/04/05 19:08:33 dsalt Exp $
19
 
 *
20
18
 * Functions to stup and deal with a preferences dialog interfacing with
21
19
 * the xine config system.
22
20
 *
41
39
 
42
40
#include "mediamarks.h"
43
41
#include "preferences.h"
 
42
#include "ui.h"
44
43
#include "utils.h"
45
44
 
46
45
#include <jsapi.h>
48
47
 
49
48
typedef struct {
50
49
  void *notebook; /* NULL - get from parent */
51
 
  GtkWidget *editable, *label, *separator;
 
50
  GtkWidget *todefault, *revert, *editable, *label, *separator;
52
51
  int exp;
53
52
} pref_item_t;
54
53
#define PREF_ITEM_T(NODE) ((pref_item_t *)(NODE)->data)
117
116
      }
118
117
      if (pref->exp <= exp)
119
118
        last = pref;
 
119
      func (pref->todefault);
 
120
      func (pref->revert);
120
121
      func (pref->editable);
121
122
      func (pref->label);
122
123
      func (pref->separator);
289
290
  }
290
291
}
291
292
 
 
293
#ifdef WITH_HAL
 
294
#include <unistd.h>
 
295
#include <hal/libhal.h>
 
296
 
 
297
static LibHalContext *hal = NULL;
 
298
 
 
299
static gboolean check_hal (void)
 
300
{
 
301
  if (hal)
 
302
    return TRUE;
 
303
  DBusConnection *dbus = dbus_bus_get (DBUS_BUS_SYSTEM, NULL);
 
304
  if (!dbus)
 
305
    return FALSE;
 
306
  hal = libhal_ctx_new ();
 
307
  if (!hal)
 
308
    return FALSE;
 
309
  libhal_ctx_set_dbus_connection (hal, dbus);
 
310
  return TRUE;
 
311
}
 
312
 
 
313
static char *
 
314
get_hal_property (const char *dev, const char *dev_tag, const char *prop_tag)
 
315
{
 
316
  int count;
 
317
  char **devs = libhal_manager_find_device_string_match
 
318
                  (hal, dev_tag, dev, &count, NULL);
 
319
  if (!devs)
 
320
    return NULL;
 
321
  if (!devs[0])
 
322
  {
 
323
    libhal_free_string_array (devs);
 
324
    return NULL;
 
325
  }
 
326
 
 
327
  char *prop = libhal_device_get_property_string (hal, devs[0], prop_tag, NULL);
 
328
  char *ret = (prop && prop[0]) ? strdup (prop) : NULL;
 
329
  libhal_free_string (prop);
 
330
  libhal_free_string_array (devs);
 
331
  return ret;
 
332
}
 
333
 
 
334
static char *
 
335
get_hal_device_info (const char *dev)
 
336
{
 
337
  if (!check_hal () || !dev)
 
338
    return NULL;
 
339
 
 
340
  int ldev = strlen (dev);
 
341
  char buf[FILENAME_MAX + ldev + 1];
 
342
  strcpy (buf, dev); /* safe! */
 
343
  if (buf[0] == '/')
 
344
  {
 
345
    ldev = strrchr (buf, '/') - buf + 1;
 
346
    int tmp = readlink (dev, buf + ldev, FILENAME_MAX - 1);
 
347
    if (tmp <= 0)
 
348
      strcpy (buf, dev); /* safe! */
 
349
    else if (buf[ldev] == '/')
 
350
    {
 
351
      memmove (buf, buf + ldev, tmp);
 
352
      buf[tmp] = 0;
 
353
    }
 
354
    else
 
355
    {
 
356
      char *p;
 
357
      buf[ldev + tmp] = 0;
 
358
      while ((p = strstr (buf, "//")))
 
359
        memmove (p, p + 1, strlen (p));
 
360
      while ((p = strstr (buf, "/./")))
 
361
        memmove (p, p + 2, strlen (p) - 1);
 
362
      while ((p = strstr (buf, "/../")))
 
363
      {
 
364
        char *q = p;
 
365
        while (--q >= buf && *q != '/')
 
366
          /**/;
 
367
        memmove (q, p + 3, strlen (p) - 2);
 
368
      }
 
369
    }
 
370
  }
 
371
 
 
372
#ifdef HAL_DEVICE_FILE_PREFIX
 
373
  char *const buf_unprefixed =
 
374
    strncmp (buf, HAL_DEVICE_FILE_PREFIX, sizeof (HAL_DEVICE_FILE_PREFIX) - 1)
 
375
    ? "" : buf + sizeof (HAL_DEVICE_FILE_PREFIX) - 2;
 
376
#else
 
377
  char *const buf_unprefixed = buf;
 
378
#endif
 
379
 
 
380
  return get_hal_property (buf, "block.device", "storage.model")
 
381
         ? : get_hal_property (buf, "block.device", "info.product")
 
382
         ? : get_hal_property (buf_unprefixed, HAL_DEVICE_FILE_PROPERTY, "info.product")
 
383
         /* FIXME - BSD etc. */
 
384
         ;
 
385
}
 
386
 
 
387
static void
 
388
display_hal_device_info (GtkWidget *widget, const char *dev)
 
389
{
 
390
  GtkLabel *info = g_object_get_data (G_OBJECT (widget), "extra");
 
391
  if (info)
 
392
  {
 
393
    char *hal = get_hal_device_info (dev);
 
394
    char *content = g_markup_printf_escaped ("<small>%s</small>", hal ? : "");
 
395
    gtk_label_set_markup (info, content);
 
396
    free (content);
 
397
    free (hal);
 
398
  }
 
399
}
 
400
#endif /* WITH_HAL */
 
401
 
292
402
static void file_cb (GtkWidget *widget, int response, gpointer data)
293
403
{
294
404
  xine_cfg_entry_t entry;
295
 
  gchar *key = (gchar *) data;
 
405
  gchar *key = g_object_get_data (data, "cfg");
296
406
 
297
407
  if (update_lock || response != GTK_RESPONSE_ACCEPT)
298
408
    return;
308
418
    logprintf ("preferences: updating entry\n");
309
419
    entry.str_value = key;
310
420
    xine_config_update_entry (xine, &entry);
 
421
#ifdef WITH_HAL
 
422
    if (entry.num_value == 2 /* XINE_CONFIG_STRING_IS_DEVICE_NAME */)
 
423
      display_hal_device_info (data, key); 
 
424
#endif
311
425
  }
312
426
  free (key);
313
427
}
317
431
  file_cb (widget, GTK_RESPONSE_ACCEPT, data);
318
432
}
319
433
 
320
 
static void file_map_cb (GtkWidget *fcb, gpointer key)
321
 
{
322
 
  if (!g_object_get_data (fcb, "gxine"))
323
 
  {
324
 
    g_signal_connect (fcb, "current-folder-changed",
325
 
                      G_CALLBACK(file_activate_cb), key);
326
 
    g_object_set_data (fcb, "gxine", fcb);
327
 
  }
 
434
#ifdef WITH_HAL
 
435
static void file_preview_cb (GtkFileChooser *fc, gpointer data)
 
436
{
 
437
  GtkLabel *info = GTK_LABEL (gtk_file_chooser_get_preview_widget (fc));
 
438
  char *file = gtk_file_chooser_get_preview_filename (fc);
 
439
  if (!file)
 
440
    file = gtk_file_chooser_get_filename (fc);
 
441
  char *content = get_hal_device_info (file);
 
442
  gtk_label_set_text (info, content ? : "");
 
443
  free (content);
 
444
  g_free (file);
 
445
}
 
446
#endif
 
447
 
 
448
static void file_map_cb (GtkFileChooser *fcb, gpointer fc)
 
449
{
 
450
  if (!g_object_get_data (fc, "gxine"))
 
451
  {
 
452
    g_signal_connect_swapped (fcb, "current-folder-changed",
 
453
                              G_CALLBACK(file_activate_cb), fc);
 
454
    g_object_set_data (fc, "gxine", fc);
 
455
  }
 
456
#ifdef WITH_HAL
 
457
  file_preview_cb (fcb, fc);
 
458
#endif
 
459
}
 
460
 
 
461
static void
 
462
default_item_cb (GtkWidget *w, gpointer key)
 
463
{
 
464
  xine_cfg_entry_t entry;
 
465
  xine_config_lookup_entry (xine, key, &entry);
 
466
  if (entry.type == XINE_CONFIG_TYPE_STRING)
 
467
    entry.str_value = entry.str_default;
 
468
  else
 
469
    entry.num_value = entry.num_default;
 
470
  preferences_update_entry (&entry);
 
471
}
 
472
 
 
473
static inline GtkWidget *
 
474
create_item_default (const xine_cfg_entry_t * entry)
 
475
{
 
476
  char *tip;
 
477
  gboolean alloc = FALSE;
 
478
 
 
479
  switch (entry->type)
 
480
  {
 
481
  case XINE_CONFIG_TYPE_ENUM:
 
482
    tip = entry->enum_values[entry->num_default];
 
483
    break;
 
484
 
 
485
  case XINE_CONFIG_TYPE_RANGE:
 
486
  case XINE_CONFIG_TYPE_NUM:
 
487
    alloc = TRUE;
 
488
    tip = g_strdup_printf ("%d", entry->num_default);
 
489
    break;
 
490
 
 
491
  case XINE_CONFIG_TYPE_BOOL:
 
492
    tip = entry->num_default ? "✓" : "✗";
 
493
    break;
 
494
 
 
495
  case XINE_CONFIG_TYPE_STRING:
 
496
    tip = entry->str_default;
 
497
    break;
 
498
 
 
499
  default:
 
500
    return NULL;
 
501
  }
 
502
 
 
503
  GtkWidget *widget = ui_button_new_stock (GTK_STOCK_CLEAR);
 
504
  gtk_tooltips_set_tip (tooltips, widget, tip, NULL);
 
505
  if (alloc)
 
506
    free (tip);
 
507
 
 
508
  g_signal_connect ((GObject *) widget, "clicked",
 
509
                    G_CALLBACK (default_item_cb), (gpointer) entry->key);
 
510
  return widget;
 
511
}
 
512
 
 
513
static void
 
514
revert_item_cb (GtkWidget *w, gpointer key)
 
515
{
 
516
  xine_cfg_entry_t entry;
 
517
  xine_config_lookup_entry (xine, key, &entry);
 
518
  if (entry.type == XINE_CONFIG_TYPE_STRING)
 
519
    entry.str_value = g_object_get_data ((GObject *) w, "revert");
 
520
  else
 
521
    entry.num_value = (int) (intptr_t) g_object_get_data ((GObject *) w, "revert");
 
522
  preferences_update_entry (&entry);
 
523
}
 
524
 
 
525
static inline GtkWidget *
 
526
create_item_revert (const xine_cfg_entry_t *entry)
 
527
{
 
528
  intptr_t value;
 
529
  char *tip;
 
530
  gboolean alloc = FALSE;
 
531
 
 
532
  switch (entry->type)
 
533
  {
 
534
  case XINE_CONFIG_TYPE_ENUM:
 
535
    tip = entry->enum_values[entry->num_value];
 
536
    value = entry->num_value;
 
537
    break;
 
538
 
 
539
  case XINE_CONFIG_TYPE_RANGE:
 
540
  case XINE_CONFIG_TYPE_NUM:
 
541
    alloc = TRUE;
 
542
    tip = g_strdup_printf ("%d", entry->num_value);
 
543
    value = entry->num_value;
 
544
    break;
 
545
 
 
546
  case XINE_CONFIG_TYPE_BOOL:
 
547
    tip = entry->num_value ? "✓" : "✗";
 
548
    value = entry->num_value;
 
549
    break;
 
550
 
 
551
  case XINE_CONFIG_TYPE_STRING:
 
552
    tip = entry->str_value;
 
553
    value = (intptr_t) strdup (entry->str_value);
 
554
    break;
 
555
 
 
556
  default:
 
557
    return NULL;
 
558
  }
 
559
 
 
560
  GtkWidget *widget = ui_button_new_stock (GTK_STOCK_REVERT_TO_SAVED);
 
561
  g_object_set_data ((GObject *) widget, "revert", (void *) value);
 
562
  g_signal_connect ((GObject *) widget, "clicked",
 
563
                    G_CALLBACK (revert_item_cb), (gpointer) entry->key);
 
564
  gtk_tooltips_set_tip (tooltips, widget, tip, NULL);
 
565
  if (alloc)
 
566
    free (tip);
 
567
 
 
568
  return widget;
328
569
}
329
570
 
330
571
static GtkWidget *create_item_editable (const xine_cfg_entry_t *entry)
353
594
  case XINE_CONFIG_TYPE_STRING:
354
595
    if (xine_check_version (1, 1, 4) && entry->num_value)
355
596
    {
356
 
      widget = gtk_file_chooser_dialog_new (entry->key, GTK_WINDOW (prefs_dialog),
 
597
      GtkWidget *fc = gtk_file_chooser_dialog_new (entry->key, GTK_WINDOW (prefs_dialog),
357
598
                                            entry->num_value == 3 /* XINE_CONFIG_STRING_IS_DIRECTORY_NAME */
358
599
                                              ? GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER
359
600
                                              : GTK_FILE_CHOOSER_ACTION_OPEN,
360
601
                                            GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
361
602
                                            GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
362
603
                                            NULL);
363
 
      gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (widget), TRUE);
 
604
      widget = gtk_file_chooser_button_new_with_dialog (fc);
 
605
      gtk_file_chooser_set_local_only ((GtkFileChooser *) fc, TRUE);
364
606
      struct stat st;
365
607
      if (stat (entry->str_value, &st))
366
608
      {
370
612
                  entry->key, entry->str_value);
371
613
      }
372
614
      else
373
 
        gtk_file_chooser_set_filename ((GtkFileChooser *) widget, entry->str_value);
374
 
      g_object_connect (G_OBJECT(widget),
375
 
        "signal::response", G_CALLBACK(file_cb), (gchar *)entry->key,
376
 
        "signal::file-activated", G_CALLBACK(file_activate_cb), (gchar *)entry->key,
 
615
        gtk_file_chooser_set_filename ((GtkFileChooser *) fc, entry->str_value);
 
616
#ifdef WITH_HAL
 
617
      gtk_file_chooser_set_use_preview_label ((GtkFileChooser *) fc, FALSE);
 
618
      GtkWidget *preview = g_object_new (GTK_TYPE_LABEL, "angle", 90.0,
 
619
                                         "selectable", FALSE, NULL);
 
620
      gtk_file_chooser_set_preview_widget ((GtkFileChooser *) fc, preview);
 
621
#endif
 
622
      g_object_connect (G_OBJECT(fc),
 
623
        "signal::response", G_CALLBACK(file_cb), widget,
 
624
        "signal::file-activated", G_CALLBACK(file_activate_cb), widget,
 
625
#ifdef WITH_HAL
 
626
        "signal::update-preview", G_CALLBACK(file_preview_cb), widget,
 
627
        "signal::map", G_CALLBACK(file_preview_cb), fc,
 
628
#endif
377
629
        NULL);
378
 
      widget = gtk_file_chooser_button_new_with_dialog (widget);
379
 
      g_signal_connect (G_OBJECT(widget), "map", G_CALLBACK(file_map_cb), (gchar *)entry->key);
 
630
      g_signal_connect_after (G_OBJECT(widget), "map", G_CALLBACK(file_map_cb), fc);
380
631
    }
381
632
    else
382
633
    {
383
634
      widget = gtk_entry_new();
384
 
      g_object_set_data (G_OBJECT(widget), "cfg", (gpointer)entry->key);
385
635
      g_object_connect (G_OBJECT(widget),
386
636
        "signal::key-press-event", G_CALLBACK(entry_keypress_cb), (gchar *)entry->key,
387
637
        "signal::focus-out-event", G_CALLBACK(entry_cb), (gchar *)entry->key,
388
638
        NULL);
389
639
      gtk_entry_set_text (GTK_ENTRY(widget), entry->str_value);
390
640
    }
 
641
    g_object_set_data (G_OBJECT(widget), "cfg", (gpointer)entry->key);
391
642
 
392
643
    break;
393
644
 
395
646
    {
396
647
      GtkObject *adj = gtk_adjustment_new (entry->num_value, entry->range_min,
397
648
                                           entry->range_max, 1.0, 10.0, 0.0);
398
 
      widget = gtk_hscale_new (GTK_ADJUSTMENT(adj));
399
 
      gtk_scale_set_draw_value (GTK_SCALE(widget), TRUE);
400
 
      gtk_scale_set_value_pos (GTK_SCALE(widget), GTK_POS_TOP);
401
 
      gtk_scale_set_digits (GTK_SCALE(widget), 0);
 
649
      widget = ui_hscale_new (adj, GTK_POS_TOP, 0);
 
650
      gtk_widget_set_size_request (widget, 128, -1);
402
651
      g_signal_connect (adj, "value-changed",
403
652
                        G_CALLBACK (range_cb), (gchar *)entry->key);
404
653
    }
408
657
    {
409
658
      GtkObject *adj = gtk_adjustment_new (entry->num_value, INT_MIN, INT_MAX,
410
659
                                           1, 10, 0);
411
 
      widget = gtk_spin_button_new (GTK_ADJUSTMENT(adj), 1, 0);
412
 
      gtk_spin_button_set_update_policy (GTK_SPIN_BUTTON(widget),
413
 
                                         GTK_UPDATE_ALWAYS);
414
 
      gtk_spin_button_set_numeric (GTK_SPIN_BUTTON(widget), TRUE);
 
660
      widget = ui_spin_button_new (adj);
415
661
      g_signal_connect (G_OBJECT(widget), "value-changed",
416
662
                        G_CALLBACK(spin_cb), (gchar *)entry->key);
417
663
    }
449
695
    labeltext = g_markup_printf_escaped ("<b>• <i>%s</i></b>\n%s",
450
696
                                         labelkey, entry->description);
451
697
 
452
 
  label = gtk_label_new (labeltext);
 
698
  label = ui_label_new_with_markup (labeltext);
453
699
  free (labeltext);
454
700
 
455
 
  gtk_label_set_use_markup (GTK_LABEL(label), TRUE);
456
701
  gtk_label_set_line_wrap (GTK_LABEL(label), TRUE);
 
702
  gtk_label_set_line_wrap_mode (GTK_LABEL(label), PANGO_WRAP_WORD);
457
703
  gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
458
704
  gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
459
705
 
460
706
  return label;
461
707
}
462
708
 
 
709
static GtkWidget *create_item_extra (const xine_cfg_entry_t *entry)
 
710
{
 
711
  switch (entry->type)
 
712
  {
 
713
  case XINE_CONFIG_TYPE_STRING:
 
714
#ifdef WITH_HAL
 
715
    if (entry->num_value == 2 /* XINE_CONFIG_STRING_IS_DEVICE_NAME */)
 
716
      return gtk_label_new (NULL);
 
717
#endif
 
718
    break;
 
719
  }
 
720
  return NULL;
 
721
}
 
722
 
463
723
static GNode *create_item (const xine_cfg_entry_t *entry)
464
724
{
465
725
  pref_item_t *item = malloc (sizeof (pref_item_t));
466
726
  item->notebook = NULL;
 
727
  item->todefault = create_item_default (entry);
 
728
  item->revert = create_item_revert (entry);
467
729
  item->editable = create_item_editable (entry);
468
730
  item->label = create_item_label (entry);
 
731
  GtkWidget *extra = create_item_extra (entry);
 
732
  if (extra)
 
733
    g_object_set_data (G_OBJECT (item->editable), "extra", extra);
469
734
  item->separator = gtk_hseparator_new ();
470
735
  item->exp = entry->exp_level;
471
736
  return g_node_new (item);
476
741
  pref_page_t *page = malloc (sizeof (pref_page_t));
477
742
  page->notebook = GINT_TO_POINTER (1); /* dummy value - filled in later */
478
743
  page->page = page->table = NULL;
479
 
  page->prefix = malloc (length + 1);
480
 
  sprintf (page->prefix, "%.*s", (int) length, key);
 
744
  page->prefix = g_strdup_printf ("%.*s", (int) length, key);
481
745
  page->label = strrchr (page->prefix, '.');
482
746
  if (page->label)
483
747
    ++page->label;
634
898
    /* we have a config item */
635
899
    int r = g_node_child_position (node->parent, node) * 2;
636
900
    GtkTable *table = GTK_TABLE(parent->page.table);
637
 
    gtk_table_attach (table, pref->item.editable, 0, 1, r, r + 1,
638
 
                      GTK_EXPAND | GTK_FILL, GTK_SHRINK, 2, 5);
639
 
    gtk_table_attach (table, pref->item.label, 1, 4, r, r + 1,
 
901
    gtk_table_attach (table, pref->item.todefault, 0, 1, r, r + 1,
 
902
                      GTK_FILL, GTK_SHRINK, 2, 5);
 
903
    gtk_table_attach (table, pref->item.revert, 1, 2, r, r + 1,
 
904
                      GTK_FILL, GTK_SHRINK, 2, 5);
 
905
    GtkWidget *extra = g_object_get_data (G_OBJECT (pref->item.editable), "extra");
 
906
    if (extra)
 
907
    {
 
908
      GtkBox *box = GTK_BOX (gtk_vbox_new (2, FALSE));
 
909
      gtk_table_attach (table, (GtkWidget *) box, 2, 3, r, r + 1,
 
910
                        GTK_EXPAND | GTK_FILL, GTK_SHRINK, 2, 5);
 
911
      gtk_box_pack_start_defaults (box, pref->item.editable);
 
912
      gtk_box_pack_start_defaults (box, extra);
 
913
#ifdef WITH_HAL
 
914
      xine_cfg_entry_t entry;
 
915
      const char *key = g_object_get_data (G_OBJECT (pref->item.editable), "cfg");
 
916
      if (xine_config_lookup_entry (xine, key, &entry))
 
917
        display_hal_device_info (pref->item.editable, entry.str_value);
 
918
#endif
 
919
    }
 
920
    else
 
921
      gtk_table_attach (table, pref->item.editable, 2, 3, r, r + 1,
 
922
                        GTK_EXPAND | GTK_FILL, GTK_SHRINK, 2, 5);
 
923
    gtk_table_attach (table, pref->item.label, 3, 6, r, r + 1,
640
924
                      GTK_EXPAND | GTK_FILL, GTK_SHRINK, 5, 5);
641
 
    gtk_table_attach (table, pref->item.separator, 0, 4, r + 1, r + 2,
 
925
    gtk_table_attach (table, pref->item.separator, 0, 6, r + 1, r + 2,
642
926
                      GTK_EXPAND | GTK_FILL, GTK_SHRINK | GTK_FILL, 5, 5);
 
927
    g_signal_connect (pref->item.todefault, "focus",
 
928
                      G_CALLBACK (focus_item_cb), node);
 
929
    g_signal_connect (pref->item.revert, "focus",
 
930
                      G_CALLBACK (focus_item_cb), node);
643
931
    g_signal_connect (pref->item.editable, "focus",
644
 
                      focus_item_cb, node);
 
932
                      G_CALLBACK (focus_item_cb), node);
645
933
  }
646
934
 
647
935
  return FALSE;
729
1017
  return JS_TRUE;
730
1018
}
731
1019
 
732
 
static gpointer preferences_init_dbox (gpointer unused)
 
1020
static void preferences_init_dbox (void)
733
1021
{
734
1022
  prefs_dialog = gtk_dialog_new_with_buttons (_("Preferences"), NULL, 0,
735
1023
                                GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
745
1033
  gtk_box_pack_start_defaults (GTK_BOX(GTK_DIALOG(prefs_dialog)->vbox),
746
1034
                               prefs_notebook);
747
1035
 
748
 
  GtkWidget *w = gtk_label_new (_("Items marked “<b>• <i>like this</i></b>” require "
749
 
                                  "gxine to be restarted to take effect."));
750
 
  gtk_label_set_use_markup (GTK_LABEL(w), TRUE);
 
1036
  GtkWidget *w = ui_label_new_with_markup
 
1037
                   (_("Items marked “<b>• <i>like this</i></b>” require "
 
1038
                      "gxine to be restarted to take effect."));
751
1039
  gtk_box_pack_end (GTK_BOX(GTK_DIALOG(prefs_dialog)->vbox), w,
752
1040
                    FALSE, FALSE, 2);
753
 
 
754
 
  gtk_widget_show_all (prefs_notebook);
755
 
 
 
1041
}
 
1042
 
 
1043
static gpointer preferences_first_show (gpointer unused)
 
1044
{
 
1045
  static int value = 0;
756
1046
  xine_cfg_entry_t entry;
 
1047
 
 
1048
  gtk_widget_show_all (GTK_DIALOG (prefs_dialog)->vbox);
757
1049
  if (xine_config_lookup_entry (xine, "gui.experience_level", &entry))
758
 
  {
759
 
    static int value;
760
1050
    value = entry.num_value;
761
 
    select_show_pref_widgets (&value);
762
 
  }
763
1051
 
 
1052
  select_show_pref_widgets (&value);
764
1053
  return NULL;
765
1054
}
766
1055
 
775
1064
  {
776
1065
    is_visible = TRUE;
777
1066
    static GOnce once = G_ONCE_INIT;
778
 
    g_once (&once, preferences_init_dbox, NULL);
779
 
    window_show (prefs_dialog, NULL);
 
1067
    g_once (&once, preferences_first_show, NULL);
 
1068
    window_present (prefs_dialog, NULL);
780
1069
  }
781
1070
}
782
1071
 
786
1075
  /* script engine functions */
787
1076
  se_defun (gse, NULL, "preferences_show", js_preferences_show, 0, 0,
788
1077
            SE_GROUP_DIALOGUE, NULL, NULL);
 
1078
 
 
1079
  preferences_init_dbox ();
789
1080
}
790
1081
 
791
1082
void preferences_update_entry (const xine_cfg_entry_t *entry)
801
1092
 
802
1093
    case XINE_CONFIG_TYPE_STRING:
803
1094
      if (xine_check_version (1, 1, 4) && entry->num_value)
 
1095
      {
804
1096
        gtk_file_chooser_set_filename (widget, entry->str_value);
 
1097
#ifdef WITH_HAL
 
1098
        display_hal_device_info (widget, entry->str_value);
 
1099
#endif
 
1100
      }
805
1101
      else
806
1102
        gtk_entry_set_text (widget, entry->str_value);
807
1103
      break;