prefsdialog.cpp

linux下的一款播放器

    {
        hx_prefs_set_entry(info->pref_name, NULL);
    }
}

static void
prefs_bits_per_sample_read(GladeXML* prefs_dialog,
                           const HXPrefsControlInfo* info,
                           const HXPrefsDialog*)
{
    HXEntry* entry;
    HXValue* value;
    gboolean checked;
    GtkWidget* checkbutton;

    checkbutton = glade_xml_get_widget(prefs_dialog, info->widget_name);
    g_return_if_fail(checkbutton != NULL);
    
    entry = hx_prefs_get_entry(info->pref_name);
    if(entry)
    {
        value = hx_entry_get_value(entry);
        checked = strcmp(hx_value_get_string(value), "8") == 0;
    }
    else
    {
        checked = FALSE;
    }

    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbutton), checked);
}

static void
prefs_bits_per_sample_write(GladeXML* prefs_dialog,
                            const HXPrefsControlInfo* info,
                            const HXPrefsDialog*)
{
    GtkWidget* checkbutton;
    HXValue* value;
    gboolean is_active;

    checkbutton = glade_xml_get_widget(prefs_dialog, info->widget_name);
    g_return_if_fail(checkbutton != NULL);

    is_active = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(checkbutton));

    if(is_active)
    {
        value = hx_value_new(HX_VALUE_STRING);
        hx_value_set_string_nocopy(value, "8");
        hx_prefs_set_entry(info->pref_name, value);
    }
    else
    {
        hx_prefs_set_entry(info->pref_name, NULL);
    }
}

static void
prefs_content_language_read(GladeXML* prefs_dialog,
                            const HXPrefsControlInfo* info,
                            const HXPrefsDialog*)
{
    HXEntry* entry;
    HXValue* value;
    const gchar* lang_name;
    GtkWidget* widget;
    GtkWidget* entry_widget;

    widget = glade_xml_get_widget(prefs_dialog, info->widget_name);
    g_return_if_fail(widget != NULL);
    
    entry = hx_prefs_get_entry(info->pref_name);
    if(entry)
    {
        const gchar* lang_code;
        
        value = hx_entry_get_value(entry);
        lang_code = hx_value_get_string(value);        
        lang_name = hpd_get_lang_name_from_code(lang_code);
    }
    else
    {
        lang_name = hpd_get_lang_name_from_code(info->default_value);
    }

    entry_widget = GTK_COMBO(widget)->entry;
    gtk_entry_set_text(GTK_ENTRY(entry_widget), lang_name);
}

static void
prefs_content_language_write(GladeXML* prefs_dialog,
                             const HXPrefsControlInfo* info,
                             const HXPrefsDialog*)
{
    const gchar* lang_name = NULL;
    const gchar* lang_code = NULL;    
    GtkWidget* combo;
    GtkWidget* entry;
    HXValue* value;
    

    combo = glade_xml_get_widget(prefs_dialog, info->widget_name);
    g_return_if_fail(combo != NULL);

    entry = GTK_COMBO(combo)->entry;
    lang_name = gtk_entry_get_text(GTK_ENTRY(entry));
    if(lang_name)
    {
        lang_code = hpd_get_lang_code_from_name(lang_name);
    }

    if(!lang_code)
    {
        lang_code = info->default_value;        
    }
    
    value = hx_value_new(HX_VALUE_STRING);
    hx_value_set_string_nocopy(value, g_strdup(lang_code));    
    hx_prefs_set_entry(info->pref_name, value);    
}

static void
prefs_overdub_caption_read(GladeXML* prefs_dialog,
                           const HXPrefsControlInfo* info,
                           const HXPrefsDialog*)
{
    HXEntry* entry;
    HXValue* value;
    const gchar* str;
    
    entry = hx_prefs_get_entry(info->pref_name);
    if(entry)
    {
        value = hx_entry_get_value(entry);
        str = hx_value_get_string(value);
    }
    else
    {
        str = info->default_value;
    }
    
    if(strcmp(str, "caption") == 0)
    {
        GtkWidget* show_subtitles;
        show_subtitles = glade_xml_get_widget(prefs_dialog, "hpd_show_subtitles");
        g_return_if_fail(show_subtitles != NULL);

        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(show_subtitles),
                                     TRUE);
    }
    else if(strcmp(str, "overdub") == 0)
    {
        GtkWidget* play_overdub;
        play_overdub = glade_xml_get_widget(prefs_dialog, "hpd_play_overdub_track");
        g_return_if_fail(play_overdub != NULL);
        
        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(play_overdub),
                                     TRUE);
    }
    else
    {
        GtkWidget* no_subtitles_overdub;
        no_subtitles_overdub = glade_xml_get_widget(prefs_dialog, "hpd_no_subtitles_overdub");
        g_return_if_fail(no_subtitles_overdub != NULL);

        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(no_subtitles_overdub),
                                     TRUE);
    }
}

static void
prefs_overdub_caption_write(GladeXML* prefs_dialog,
                            const HXPrefsControlInfo* info,
                            const HXPrefsDialog*)
{
    GtkWidget* no_subtitles_overdub;
    GtkWidget* show_subtitles;
    GtkWidget* play_overdub;
    HXValue* value;
    const gchar* str_value;
    
    no_subtitles_overdub = glade_xml_get_widget(prefs_dialog, "hpd_no_subtitles_overdub");
    g_return_if_fail(no_subtitles_overdub != NULL);

    show_subtitles = glade_xml_get_widget(prefs_dialog, "hpd_show_subtitles");
    g_return_if_fail(show_subtitles != NULL);

    play_overdub = glade_xml_get_widget(prefs_dialog, "hpd_play_overdub_track");
    g_return_if_fail(play_overdub != NULL);

    if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(no_subtitles_overdub)))
    {
        str_value = "none";
    }
    else if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(show_subtitles)))
    {
        str_value = "caption";
    }
    else if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(play_overdub)))
    {
        str_value = "overdub";        
    }
    else
    {
        str_value = info->default_value;
    }
    
    value = hx_value_new(HX_VALUE_STRING);
    hx_value_set_string_nocopy(value, g_strdup(str_value));
    
    hx_prefs_set_entry(info->pref_name, value);        
}

static void
prefs_auto_transport_read(GladeXML* prefs_dialog,
                          const HXPrefsControlInfo* info,
                          const HXPrefsDialog*)
{
    HXEntry* entry;
    HXValue* value;
    gboolean checked;
    
    entry = hx_prefs_get_entry(info->pref_name);
    if(entry)
    {
        value = hx_entry_get_value(entry);
        checked = atoi(hx_value_get_string(value));
    }
    else
    {
        checked = atoi(info->default_value);
    }
    
    if(checked)
    {
        GtkWidget* auto_transport_on;
        auto_transport_on = glade_xml_get_widget(prefs_dialog, "hpd_auto_transport_on");
        g_return_if_fail(auto_transport_on != NULL);

        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(auto_transport_on),
                                     TRUE);
    }
    else
    {
        GtkWidget* auto_transport_off;
        auto_transport_off = glade_xml_get_widget(prefs_dialog, "hpd_auto_transport_off");
        g_return_if_fail(auto_transport_off != NULL);
        
        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(auto_transport_off),
                                     TRUE);
    }
}

static void
prefs_auto_transport_write(GladeXML* prefs_dialog,
                           const HXPrefsControlInfo* info,
                           const HXPrefsDialog*)
{
    GtkWidget* auto_transport_on;
    GtkWidget* auto_transport_off;
    HXValue* value;
    const gchar* str_value;
    
    auto_transport_on = glade_xml_get_widget(prefs_dialog, "hpd_auto_transport_on");
    g_return_if_fail(auto_transport_on != NULL);

    auto_transport_off = glade_xml_get_widget(prefs_dialog, "hpd_auto_transport_off");
    g_return_if_fail(auto_transport_off != NULL);

    if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(auto_transport_off)))
    {
        str_value = "0";
    }
    else if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(auto_transport_on)))
    {
        str_value = "1";
    }
    else
    {
        str_value = info->default_value;
    }
    
    value = hx_value_new(HX_VALUE_STRING);
    hx_value_set_string_nocopy(value, g_strdup(str_value));
    
    hx_prefs_set_entry(info->pref_name, value);        
}

/* Prefs for the helix engine */
static const HXPrefsControlInfo g_helix_prefs_map[] = {
//  preference              default        widget                        read                                 write    
    { "Bandwidth",          "10485800",    "hpd_normal_bandwidth",       prefs_bandwidth_option_menu_read,    prefs_bandwidth_option_menu_write    },
    { "MaxBandwidth",       "10485800",    "hpd_max_bandwidth",          prefs_bandwidth_option_menu_read,    prefs_bandwidth_option_menu_write    },
    { "RTSPProxySupport",   "0",           "hpd_rtsp_proxy_support",     prefs_checkbutton_read,              prefs_checkbutton_write              },
    { "RTSPProxyHost",      "",            "hpd_rtsp_proxy_host",        prefs_entry_read,                    prefs_entry_write                    },
    { "RTSPProxyPort",      "554",         "hpd_rtsp_proxy_port",        prefs_entry_read,                    prefs_entry_write                    },
    { "PNAProxySupport",    "0",           "hpd_pna_proxy_support",      prefs_checkbutton_read,              prefs_checkbutton_write              },
    { "PNAProxyHost",       "",            "hpd_pna_proxy_host",         prefs_entry_read,                    prefs_entry_write                    },
    { "PNAProxyPort",       "1090",        "hpd_pna_proxy_port",         prefs_entry_read,                    prefs_entry_write                    },
    { "HTTPProxySupport",   "0",           "hpd_http_proxy_support",     prefs_checkbutton_read,              prefs_checkbutton_write              },
    { "HTTPProxyHost",      "",            "hpd_http_proxy_host",        prefs_entry_read,                    prefs_entry_write                    },
    { "HTTPProxyPort",      "80",          "hpd_http_proxy_port",        prefs_entry_read,                    prefs_entry_write                    },
    { "Quality",            "4",           "hpd_quality",                prefs_scale_read,                    prefs_scale_write                    },
    { "UseOverlay",         "1",           "hpd_use_overlay",            prefs_checkbutton_read,              prefs_checkbutton_write              },
    { "OverlayMode",        "1",           "hpd_use_overlay",            prefs_checkbutton_read,              prefs_checkbutton_write              },
//  { "SoundDriver",        "1" /* oss */, "hpd_sound_driver",           prefs_sound_driver_option_menu_read, prefs_sound_driver_option_menu_write },
//  { "UseUDPPort",         "0",           "hpd_use_udp_port",           prefs_checkbutton_read,              prefs_checkbutton_write              },
//  { "UDPPort",            "7070",        "hpd_udp_port",               prefs_entry_read,                    prefs_entry_write                    },
    { "NoProxyFor",         "",            "hpd_no_proxy_for",           prefs_entry_read,                    prefs_entry_write                    },
    { "PerfPlayEntireClip", "0",           "hpd_perf_play_entire_clip",  prefs_checkbutton_read,              prefs_checkbutton_write              },
    { "BufferedPlayTime",   "10",          "hpd_buffered_play_time",     prefs_entry_read,                    prefs_entry_write                    },
    { "CookiesEnabled",     "1",           "hpd_cookies_enabled",        prefs_checkbutton_read,              prefs_checkbutton_write              },
    { "AllowAuthID",        "0",           "hpd_allow_auth_id",          prefs_checkbutton_read,              prefs_checkbutton_write              },
    { "SendStatistics",     "1",           "hpd_send_statistics",        prefs_checkbutton_read,              prefs_checkbutton_write              },
    { "SamplingRate",       NULL,          "hpd_sampling_rate",          prefs_sampling_rate_read,            prefs_sampling_rate_write            },
    { "BitsPerSample",      NULL,          "hpd_bits_per_sample",        prefs_bits_per_sample_read,          prefs_bits_per_sample_write          },
    { "AutoTransport",      "1",           NULL,                         prefs_auto_transport_read,           prefs_auto_transport_write           },
    { "CacheEnabled",       "1",           "hpd_cache_enabled",          prefs_checkbutton_read,              prefs_checkbutton_write              },
    { "CacheMaxSize",       "4",           "hpd_cache_max_size",         prefs_entry_read,                    prefs_entry_write                    },
    { "ConnectionTimeOut",  "20",          "hpd_connection_time_out",    prefs_entry_read,                    prefs_entry_write                    },
    { "SynchMM",            "1",           "hpd_synch_mm",               prefs_checkbutton_read,              prefs_checkbutton_write              },    
    { "TurboPlay",          "0",           "hpd_turbo_play",             prefs_checkbutton_read,              prefs_checkbutton_write              },

//  No support for automatic proxy configuration    
//     { "RTSPPNMProxyAutoConfig", "0" },
//     { "ProxyAutoConfigURL"     NULL },

//  Other preferences to consider adding to the preferences dialog (some of these are mac/windows only)    
//     { "PreferredBrowser",      "0",   },
//     { "InternalBrowser",       "1",   },
//     { "CookieData",             NULL, },

//     { "CountryID",             "us",  },
//     { "RegionData",            "",    },

};                                         

static const HXPrefsControlInfo g_smil_prefs_map[] = {
//  preference              default  widget                        read                         write    
//  { "useNestedMeta", 
    { "Language",           "en-us", "hpd_content_language_combo", prefs_content_language_read, prefs_content_language_write  },
    { "caption_switch",     "0",     "hpd_caption_switch",         prefs_checkbutton_read,      prefs_checkbutton_write       },
    { "overdub_or_caption", "none",  NULL,                         prefs_overdub_caption_read,  prefs_overdub_caption_write   },
    { "systemAudioDesc",    "0",     "hpd_system_audio_desc",      prefs_checkbutton_read,      prefs_checkbutton_write       },
    { "UseSystemCPU",       "1",     "hpd_use_system_cpu",         prefs_checkbutton_read,      prefs_checkbutton_write       },
    { "UseSystemOS",        "1",     "hpd_use_system_os",          prefs_checkbutton_read,      prefs_checkbutton_write       },
};

/* prefs for the player */
static const HXPrefsControlInfo g_player_prefs_map[] = {
//  preference                default  widget                         read                              write    
    { "EnableRecentUrlsList", "1",     "hpd_enable_recent_urls_list", prefs_checkbutton_read_window,    prefs_checkbutton_write_window    },
    { "MediaFilesPath",       "",      "hpd_media_files_path",        prefs_entry_read_window,          prefs_entry_write_window          },
    { "WebBrowserPath",       "",      "hpd_web_browser_path",        prefs_entry_read_window,          prefs_entry_write_window          },
};

/* RTSP transport prefs */
static const HXPrefsControlInfo g_rtsp_prefs_map[] = {
//  preference                 default  widget                    read                              write    
    { "AttemptRTSPvMulticast", "1",     "htd_attempt_multicast",  prefs_checkbutton_read,           prefs_checkbutton_write           },
    { "AttemptRTSPvUDP",       "1",     "htd_attempt_udp",        prefs_checkbutton_read,           prefs_checkbutton_write           },
    { "AttemptRTSPvTCP",       "1",     "htd_attempt_tcp",        prefs_checkbutton_read,           prefs_checkbutton_write           },
    { "AttemptRTSPvHTTP",      "1",     "htd_attempt_http",       prefs_checkbutton_read,           prefs_checkbutton_write           },
    { "UDPTimeout",            "3000",  "htd_udp_timeout",        prefs_entry_read,                 prefs_entry_write                 },        
    { "TCPTimeout",            "3000",  "htd_tcp_timeout",        prefs_entry_read,                 prefs_entry_write                 },        
    { "MulticastTimeout",      "3000",  "htd_multicast_timeout",  prefs_entry_read,                 prefs_entry_write                 },
};

/* PNA transport prefs */
static const HXPrefsControlInfo g_pna_prefs_map[] = {
//  preference                default   widget                    read                              write    
    { "AttemptPNAvMulticast", "1",      "htd_attempt_multicast",  prefs_checkbutton_read,           prefs_checkbutton_write           },
    { "AttemptPNAvUDP",       "1",      "htd_attempt_udp",        prefs_checkbutton_read,           prefs_checkbutton_write           },
    { "AttemptPNAvTCP",       "1",      "htd_attempt_tcp",        prefs_checkbutton_read,           prefs_checkbutton_write           },
    { "AttemptPNAvHTTP",      "1",      "htd_attempt_http",       prefs_checkbutton_read,           prefs_checkbutton_write           },
    { "UDPTimeout",           "3000",   "htd_udp_timeout",        prefs_entry_read,                 prefs_entry_write                 },        
    { "TCPTimeout",           "3000",   "htd_tcp_timeout",        prefs_entry_read,                 prefs_entry_write                 },        
    { "MulticastTimeout",     "3000",   "htd_multicast_timeout",  prefs_entry_read,                 prefs_entry_write                 },
};

static void
hpd_apply_main_window_preferences(HXMainWindow* window)
{
    GValue value;
    memset(&value, 0, sizeof(value));
    
    if(window)
    {
        hxwindow_get_property(window, "EnableRecentUrlsList", &value);        
        hxwindow_recent_urls_hide(window);
        
        if(g_value_get_boolean(&value))
        {
            hxwindow_recent_urls_show(window);
        }
    }
}

void
hpd_configure_transport(GtkWidget* widget, HXTransportType transport_type)
{
    GtkWidget* toplevel;
    gchar* filename;
    GladeXML* xml;
    GtkWidget* dialog;
    gint response;
    guint i;
    
    toplevel = gtk_widget_get_toplevel(widget);

    filename = hxcommon_locate_file("transport.glade");
    xml = glade_xml_new (filename, NULL, NULL);
    g_free(filename);
    g_return_if_fail(xml != NULL);

    dialog = glade_xml_get_widget(xml, "hxplayer_transport_settings");
    
    gtk_window_set_transient_for (GTK_WINDOW (dialog),
				  GTK_WINDOW (toplevel));    

    /* Update dialog from preferences */
    switch(transport_type)
    {
        case HX_TRANSPORT_RTSP:
            for(i = 0; i < sizeof(g_rtsp_prefs_map) / sizeof(*g_rtsp_prefs_map); i++)
            {
                g_rtsp_prefs_map[i].read_func(xml, &g_rtsp_prefs_map[i], NULL);