prefsdialog.cpp

linux下的一款播放器

            }
            break;

        case HX_TRANSPORT_PNA:
            for(i = 0; i < sizeof(g_pna_prefs_map) / sizeof(*g_pna_prefs_map); i++)
            {
                g_pna_prefs_map[i].read_func(xml, &g_pna_prefs_map[i], NULL);
            }
            break;
        default:
            g_assert_not_reached();
            break;
    }

    do
    {
        response = gtk_dialog_run (GTK_DIALOG (dialog));

        switch(response)
        {
            case GTK_RESPONSE_OK:
            case GTK_RESPONSE_APPLY:
                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].write_func(xml, &g_rtsp_prefs_map[i], NULL);
                        }
                        break;

                    case HX_TRANSPORT_PNA:
                        for(i = 0; i < sizeof(g_pna_prefs_map) / sizeof(*g_pna_prefs_map); i++)
                        {
                            g_pna_prefs_map[i].write_func(xml, &g_pna_prefs_map[i], NULL);
                        }
                        break;
                    default:
                        g_assert_not_reached();
                        break;
                }
                break;

            case GTK_RESPONSE_CANCEL:
            default:
                break;
        }
    } while(response != GTK_RESPONSE_OK &&
            response != GTK_RESPONSE_CANCEL &&
            response != GTK_RESPONSE_DELETE_EVENT);

    gtk_widget_destroy (dialog);
    glade_xml_destroy (xml);
}

void
hpd_configure_rtsp(GtkWidget* widget)
{
    hpd_configure_transport(widget, HX_TRANSPORT_RTSP);
}

void
hpd_configure_pna(GtkWidget* widget)
{
    hpd_configure_transport(widget, HX_TRANSPORT_PNA);
}

static void
set_entry_from_file_selection_dialog(GtkWindow* parent,
                                     const gchar* entry_name,
                                     gboolean show_files)
{
    GtkWidget* entry;
    GladeXML* xml;
    const gchar* filename;
    GtkWidget* fs;
    gint fs_response;
    const gchar* select_files = _("Select files");
    
    xml = (GladeXML*)g_object_get_data(G_OBJECT (parent), "hxprefs_xml");
    g_return_if_fail(xml != NULL);

    entry = glade_xml_get_widget(xml, entry_name);
    g_return_if_fail(entry != NULL);

#if GTK_CHECK_VERSION(2, 4, 0)
    GtkFileChooserAction action;
    if(show_files)
    {
        action = GTK_FILE_CHOOSER_ACTION_OPEN;
    }
    else
    {
        action = GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER;        
    }
    
    fs = gtk_file_chooser_dialog_new (select_files,
				      NULL,
				      action,
				      GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
				      GTK_STOCK_OPEN, GTK_RESPONSE_OK,
				      NULL);

    gtk_file_chooser_set_local_only(GTK_FILE_CHOOSER(fs), TRUE);
#else	
    fs = gtk_file_selection_new (select_files);
    gtk_file_selection_hide_fileop_buttons(GTK_FILE_SELECTION(fs));
#endif

    gtk_window_set_transient_for(GTK_WINDOW(fs),
                                 parent);

    fs_response = gtk_dialog_run (GTK_DIALOG (fs));
    gtk_widget_hide (fs);

    if (fs_response == GTK_RESPONSE_OK || fs_response == GTK_RESPONSE_ACCEPT)
    {
#if GTK_CHECK_VERSION(2, 4, 0)
        filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(fs));
#else
        filename = gtk_file_selection_get_filename(GTK_FILE_SELECTION(fs));
#endif
    }
    else
    {
        filename = NULL;
    }

    if(filename)
    {
        gtk_entry_set_text(GTK_ENTRY(entry), filename);
    }
}

void
hpd_media_files_browse(GtkWidget* widget)
{
    GtkWidget* toplevel;

    toplevel = gtk_widget_get_toplevel(widget);

    g_assert(GTK_IS_DIALOG(toplevel));
    
    set_entry_from_file_selection_dialog(GTK_WINDOW(toplevel),
                                         "hpd_media_files_path",
                                         FALSE);
}

void
hpd_web_browser_browse(GtkWidget* widget)
{
    GtkWidget* toplevel;

    toplevel = gtk_widget_get_toplevel(widget);

    g_assert(GTK_IS_DIALOG(toplevel));
    
    set_entry_from_file_selection_dialog(GTK_WINDOW(toplevel),
                                         "hpd_web_browser_path",
                                         TRUE);
}

void
hpd_clear_recent_clips(GtkWidget* widget)
{
    HXMainWindow* window;
    GtkWidget* toplevel;

    toplevel = gtk_widget_get_toplevel(widget);    
    window = (HXMainWindow*) g_object_get_data(G_OBJECT (toplevel),
                                               "hxprefs_main_window");

    if(window)
    {
        hxwindow_recent_urls_remove_all(window);
    }
}

void
hpd_auto_transport_toggled(GtkToggleButton *togglebutton)
{
    GtkWidget* toplevel;
    GtkWidget* rtsp_button;
    GtkWidget* pna_button;
    GladeXML* xml;
    gboolean sensitive;

    toplevel = gtk_widget_get_toplevel(GTK_WIDGET(togglebutton));

    xml = (GladeXML*)g_object_get_data(G_OBJECT (toplevel), "hxprefs_xml");
    g_return_if_fail(xml != NULL);

    rtsp_button = glade_xml_get_widget(xml, "hpd_configure_rtsp_button");
    g_return_if_fail(rtsp_button != NULL);

    pna_button = glade_xml_get_widget(xml, "hpd_configure_pna_button");
    g_return_if_fail(pna_button != NULL);


    sensitive = !gtk_toggle_button_get_active(togglebutton);

    gtk_widget_set_sensitive(rtsp_button, sensitive);
    gtk_widget_set_sensitive(pna_button, sensitive);    
}

void
hpd_empty_clip_cache(GtkWidget *widget)
{
    HXMainWindow* window;
    GtkWidget* toplevel;
    GtkWidget* player;
    
    toplevel = gtk_widget_get_toplevel(widget);    
    window = (HXMainWindow*) g_object_get_data(G_OBJECT (toplevel),
                                               "hxprefs_main_window");
    if(window)
    {
        player = hxwindow_get_player(window);

        HX_RESULT retVal;
        IUnknown* pUnkPlayer = NULL;
        IUnknown* pUnkEngine = NULL;
        IUnknown* pUnkHTTP = NULL;
        IHXFileSystemCache* pFileSystemCache = NULL;
        IHXPlugin2Handler* pPlugin2Handler = NULL;
        IHXPlugin* pPlugin = NULL;

        gboolean result;

        result = hx_player_get_unknown(HX_PLAYER(player),
                                       (void**)&pUnkPlayer);
        g_return_if_fail(result != FALSE);

        result = hx_player_get_engine_unknown(HX_PLAYER(player),
                                              (void**)&pUnkEngine);
        g_return_if_fail(result != FALSE);

        retVal = pUnkPlayer->QueryInterface(IID_IHXPlugin2Handler,
                                      (void**)&pPlugin2Handler);

        if(SUCCEEDED(retVal))
        {
            g_assert(pPlugin2Handler != NULL);            
            retVal = pPlugin2Handler->FindPluginUsingStrings( "PluginType",
                                                              "PLUGIN_FILE_SYSTEM",
                                                              "FileProtocol",
                                                              "http",
                                                              NULL,
                                                              NULL,
                                                              pUnkHTTP );
        }

        if(SUCCEEDED(retVal))
        {        
            g_assert(pUnkHTTP != NULL);
            retVal = pUnkHTTP->QueryInterface(IID_IHXPlugin, (void**)&pPlugin);
        }

        if(SUCCEEDED(retVal))
        {        
            g_assert(pPlugin != NULL);
                        
            retVal = pPlugin->InitPlugin(pUnkEngine);

            if(SUCCEEDED(retVal))
            {
                retVal = pPlugin->QueryInterface(IID_IHXFileSystemCache,
                                                 (void**)&pFileSystemCache);
            }
        }

        if(SUCCEEDED(retVal))
        {
            g_assert(pFileSystemCache);

            /* Victory! */
            pFileSystemCache->EmptyCache();
        }
        
        if(pFileSystemCache)
        {
            HX_RELEASE(pFileSystemCache);
        }

        if(pUnkHTTP)
        {
            HX_RELEASE(pUnkHTTP);
        }

        if(pPlugin2Handler)
        {
            HX_RELEASE(pPlugin2Handler);
        }

        g_return_if_fail(SUCCEEDED(retVal));
    }
}

static void
hpd_destroy(GtkWidget* /* widget */,
            HXPrefsDialog* prefs_dlg)
{
    glade_xml_destroy (prefs_dlg->xml);
    
    if(prefs_dlg->mime_types_dialog_info)
    {
        hxplay_mime_types_pane_destroy(prefs_dlg->mime_types_dialog_info);
    }

    g_free(prefs_dlg);
}

static void
hpd_response(GtkWidget* dialog,
             gint response_id,
             HXPrefsDialog* info)
{
    guint i;
    
    switch(response_id)
    {
        case GTK_RESPONSE_OK:
        case GTK_RESPONSE_APPLY:
            for(i = 0; i < sizeof(g_helix_prefs_map) / sizeof(*g_helix_prefs_map); i++)
            {
                g_helix_prefs_map[i].write_func(info->xml, &g_helix_prefs_map[i], info);
            }

            if (info->window)
            {
                /* We're not in embedded player mode */
                for(i = 0; i < sizeof(g_player_prefs_map) / sizeof(*g_player_prefs_map); i++)
                {
                    g_player_prefs_map[i].write_func(info->xml, &g_player_prefs_map[i], info);
                }
            }
            
            for(i = 0; i < sizeof(g_smil_prefs_map) / sizeof(*g_smil_prefs_map); i++)
            {
                g_smil_prefs_map[i].write_func(info->xml, &g_smil_prefs_map[i], info);
            }

            if(info->mime_types_dialog_info)
            {        
                hxplay_mime_types_pane_apply(info->mime_types_dialog_info);
            }

            if(info->window)
            {
                /* Updates main window ui to reflect preference changes */
                hpd_apply_main_window_preferences(info->window);
            }
            break;

        case GTK_RESPONSE_CANCEL:
        default:
            break;
    }
}

GtkDialog*
hxplay_preferences_dialog_new (HXPlayer*  player,
                               HXMainWindow* window)
{
    GladeXML* xml;
    GtkWidget* dialog;
    gchar* filename;
    guint i;
    HXPrefsDialog* dialog_info = NULL;
    
    filename = hxcommon_locate_file("preferences.glade");
    xml = glade_xml_new (filename, NULL, NULL);
    g_free(filename);
    g_return_val_if_fail(xml != NULL, NULL);

    dialog_info = g_new0(HXPrefsDialog, 1);

    dialog = glade_xml_get_widget (xml, "hxplayer_preferences_dialog");

    g_object_set_data(G_OBJECT (dialog), "hxprefs_xml", xml);
    g_object_set_data(G_OBJECT (dialog), "hxprefs_main_window", window);    
    
    /* Populate the languages drop-down combo */
    GtkWidget* lang_combo = glade_xml_get_widget (xml, "hpd_content_language_combo");
    if(lang_combo)
    {
        hpd_populate_lang_combo(GTK_COMBO(lang_combo));
    }

    dialog_info->xml = xml;
    dialog_info->window = window;    
    dialog_info->mime_types_dialog_info = hxplay_mime_types_pane_new (xml, player);    

    /* Update dialog from preferences */
    for(i = 0; i < sizeof(g_helix_prefs_map) / sizeof(*g_helix_prefs_map); i++)
    {
        g_helix_prefs_map[i].read_func(xml, &g_helix_prefs_map[i], dialog_info);
    }

    if(window)
    {
        /* We're not in embedded mode */
        for(i = 0; i < sizeof(g_player_prefs_map) / sizeof(*g_player_prefs_map); i++)
        {
            g_player_prefs_map[i].read_func(xml, &g_player_prefs_map[i], dialog_info);
        }
    }
    
    for(i = 0; i < sizeof(g_smil_prefs_map) / sizeof(*g_smil_prefs_map); i++)
    {
        g_smil_prefs_map[i].read_func(xml, &g_smil_prefs_map[i], dialog_info);
    }

    g_signal_connect (G_OBJECT (dialog), "destroy",
                      G_CALLBACK (hpd_destroy),
                      dialog_info);

    g_signal_connect (G_OBJECT (dialog), "response",
                      G_CALLBACK (hpd_response),
                      dialog_info);


    return GTK_DIALOG(dialog);
}