mainapp.cpp

linux下的一款播放器

    children_iter = GTK_MENU_SHELL(file_menu)->children;

    while(children_iter)
    {
        child = (GtkWidget*)children_iter->data;
        children_iter = g_list_next(children_iter);
        
        if(g_object_get_data(G_OBJECT(child), "is_mru"))
        {
            gtk_container_remove(GTK_CONTAINER(file_menu), child);
        }
    }
}

static void
recent_urls_menu_populate(HXMainWindow* window)
{
    GtkWidget *separator;
    GtkWidget *file_menu, *file_menu_item;
    gint pos;
    guint i;
    GList *children;
    GtkWidget *menu_item;

    separator = glade_xml_get_widget(window->xml, "hmw_mru_separator");
    g_return_if_fail(separator != NULL);

    file_menu_item = glade_xml_get_widget(window->xml, "hmw_file_menu");
    g_return_if_fail(file_menu_item != NULL);

    file_menu = gtk_menu_item_get_submenu(GTK_MENU_ITEM(file_menu_item));
    g_return_if_fail(file_menu != NULL);

    children = GTK_MENU_SHELL(file_menu)->children;
    
    pos = g_list_index(children, separator);
    g_return_if_fail(pos >= 0);

    pos++;
    i = 0;

    GList* iter = window->recent_urls_list;
    while(iter && i < DEF_NUM_FILE_MENU_URLS)
    {
        // XXXNH: we really need to fix how we store recent urls to
        // include the actual title of the clip. for now we'll just
        // shorten the url        
        gchar* escaped_filename;
        gchar* menu_item_text; 
        gchar* title;
        gchar* url;

        url = g_strdup((const char*)iter->data);
        title = hxcommon_get_title_from_url(url);

        escaped_filename = hxcommon_escape_underscores(title);
        g_free(title);
        
        menu_item_text = g_strdup_printf("_%d. %s", i+1, escaped_filename);
        g_free(escaped_filename);
                            
        menu_item = gtk_menu_item_new_with_mnemonic(menu_item_text);
        g_free(menu_item_text);
        g_object_set_data(G_OBJECT(menu_item), "is_mru", (gpointer)TRUE);
        gtk_widget_show(GTK_WIDGET(menu_item));
        gtk_menu_shell_insert(GTK_MENU_SHELL(file_menu), menu_item, pos);

        g_object_set_data(G_OBJECT(menu_item), "item_type", (gpointer) PLAY_MENU_TYPE_MRU);

        g_signal_connect(G_OBJECT(menu_item), "activate",
                         G_CALLBACK(hmw_play_from_menu_item), url);

        g_object_set_data(G_OBJECT(menu_item), "url", url);
        
        /* Free the g_strdup'd url from above on menu destruction */
        g_signal_connect_swapped(G_OBJECT(menu_item), "destroy",
                                 G_CALLBACK(g_free), url);        
        i++;
        pos++;
        iter = g_list_next(iter);
    }

    /* Only insert the extra separator if there are recent url's
       in the file menu */
    if(window->recent_urls_list)
    {
        menu_item = gtk_menu_item_new ();
        g_object_set_data(G_OBJECT(menu_item), "is_mru", (gpointer)TRUE);
        gtk_widget_show(GTK_WIDGET(menu_item));
        gtk_widget_set_sensitive (menu_item, FALSE);
        gtk_menu_shell_insert(GTK_MENU_SHELL(file_menu), menu_item, pos);
    }
}

static void
recent_urls_menu_refresh(HXMainWindow* window)
{
    recent_urls_menu_unpopulate(window);

    if(window->enable_recent_urls)
    {
        recent_urls_menu_populate(window);
    }
}

static void
recent_urls_add(HXMainWindow* window,
                const gchar* url,
                gboolean append)
{
    gint len;
    GList* last;
    GList* pos;
    GList* iter;

    /* Check for duplicates */
    iter = window->recent_urls_list;
    while(iter)
    {
        if(strcmp(url, (gchar*)iter->data) == 0)
        {
            /* Already in our list */
            return;
        }
        
        iter = g_list_next(iter);
    }
    
    len = g_list_length(window->recent_urls_list);
    last = g_list_last(window->recent_urls_list);
    
    while(len >= DEF_NUM_RECENT_URLS)
    {
        /* Remove old items from the end of the list until we have
           the right number of urls */

        pos = g_list_previous(last);
        g_free(last->data);
        window->recent_urls_list =
            g_list_delete_link(window->recent_urls_list, last);
        last = pos;
        len--;
    }

    if(append)
    {
        window->recent_urls_list =
            g_list_append(window->recent_urls_list,
                          g_strdup(url));    
    }
    else
    {
        window->recent_urls_list =
            g_list_prepend(window->recent_urls_list,
                           g_strdup(url));    
    }
    
    /* Refresh the menu */
    recent_urls_menu_refresh(window);
}

static void
populate_clip_list_menu(HXMainWindow* window)
{
    GtkWidget* clip_list_menu_item;
    GtkWidget* menu_item;
    GtkWidget* clip_list_menu;
    gchar* menu_item_text;
    guint i;
    guint group_count;

    clip_list_menu_item = glade_xml_get_widget(window->xml, "hmw_clip_list_menu_item");
    g_return_if_fail(clip_list_menu_item != NULL);

    /* get rid of the old sub-menu */
    gtk_menu_item_remove_submenu(GTK_MENU_ITEM(clip_list_menu_item));

    group_count = hx_player_get_group_count(HX_PLAYER(window->player));
    if(group_count == 0)
    {
        gtk_widget_set_sensitive(clip_list_menu_item, FALSE);
    }
    else
    {
        gtk_widget_set_sensitive(clip_list_menu_item, TRUE);

        clip_list_menu = gtk_menu_new();
        gtk_menu_item_set_submenu(GTK_MENU_ITEM(clip_list_menu_item), clip_list_menu);

        for(i = 0; i < group_count; i++)
        {
            const gchar* group_title_raw = hx_player_get_group_title(HX_PLAYER(window->player), i);
            gchar* group_title;

            if(!group_title_raw)
            {
                group_title_raw = _("Untitled");
            }
            
            if(group_title_raw)
            {
                group_title = g_strdup(group_title_raw);
                if(strlen(group_title_raw) > MAX_GROUP_TITLE_LENGTH)
                {
                    group_title[MAX_GROUP_TITLE_LENGTH] = '\0';
                }
            }

            gchar* escaped_group_title;
            escaped_group_title = hxcommon_escape_underscores(group_title);

            menu_item_text = g_strdup_printf("_%d. %s", i+1, escaped_group_title);
            g_free(escaped_group_title);
            
            menu_item = gtk_menu_item_new_with_mnemonic(menu_item_text);
            g_free(menu_item_text);
            gtk_widget_show(GTK_WIDGET(menu_item));
            gtk_menu_shell_append(GTK_MENU_SHELL(clip_list_menu), menu_item);
        
            g_signal_connect(G_OBJECT(menu_item), "activate",
                             G_CALLBACK(hmw_play_group), (gpointer)i);        
        }
    }
}

/* setup assistant helper functions */
gboolean check_registered()
{
    gboolean bRegistered = FALSE;

    HXEntry* entry = hx_prefs_get_entry(REGISTERED_PREF);
    if (entry)
    {
	HXValue* value = hx_entry_get_value(entry);
	if (atoi(hx_value_get_string(value)) != 0)
	{
	    bRegistered = TRUE;
	}
    }
    
    return bRegistered;
}


gint
show_setup_assistant(HXMainWindow* window)
{
    gint nResult = 0;
    gchar* filename;
    GladeXML* xml;
    
    filename = hxcommon_locate_file("setup.glade");
    xml = glade_xml_new (filename, NULL, NULL);
    g_free(filename);

    // XXXRGG: This will only work for the generated source glade build.
    // Setup assistant has to be fixed to work with libglade.
    GtkWidget* pSetupAssistant = GTK_WIDGET(xml);
    g_return_val_if_fail(pSetupAssistant != NULL, -1);
        
    if (pSetupAssistant)
    {
	nResult = 1;

	gtk_widget_show(pSetupAssistant);
	while (gtk_events_pending() || GTK_WIDGET_VISIBLE(pSetupAssistant))
	    gtk_main_iteration();

#ifdef HELIX_FEATURE_REAL_BRANDING // XXXNH: no EULA for helix player
	if (!g_object_get_data(G_OBJECT(pSetupAssistant), "eula-accepted"))
	{
	    nResult = -1;
	}
#endif

	if (nResult >= 0)
	{
	    HXValue* value = hx_value_new(HX_VALUE_STRING);
	    hx_value_set_string(value, "1");
	    hx_prefs_set_entry(REGISTERED_PREF, value);
            hxcommon_save_preferences(window);
        }
    }
    return nResult;
}

void
hxwindow_recent_urls_remove_all(HXMainWindow* window)
{
    g_list_foreach(window->recent_urls_list, (GFunc)g_free, NULL);
    g_list_free(window->recent_urls_list);
    window->recent_urls_list = NULL;
    
    recent_urls_menu_unpopulate(window);
}

void
hxwindow_recent_urls_hide(HXMainWindow* window)
{
    recent_urls_menu_unpopulate(window);
}


void
hxwindow_recent_urls_show(HXMainWindow* window)
{    
    recent_urls_menu_unpopulate(window);
    recent_urls_menu_populate(window);
}

void
hxwindow_recent_urls_prepend(HXMainWindow* window,
                             const gchar* url)
{
    recent_urls_add(window, url, FALSE);
}

void
hxwindow_recent_urls_append(HXMainWindow* window,
                            const gchar* url)
{
    recent_urls_add(window, url, TRUE);    
}

/* Favorites management implementation
 * ===================================
 */
static void
favorites_menu_unpopulate(HXMainWindow* window)
{
    GtkWidget* separator;
    GtkWidget* favorites_menu;
    GtkWidget* child;
    GtkWidget* menu_shell;
    GList* children_iter;
    gboolean remove_items = FALSE;

    separator = glade_xml_get_widget(window->xml, "hmw_favorites_separator");
    g_return_if_fail(separator != NULL);

    favorites_menu = glade_xml_get_widget(window->xml, "hmw_favorites_menu");
    g_return_if_fail(favorites_menu != NULL);

    menu_shell = gtk_menu_item_get_submenu(GTK_MENU_ITEM(favorites_menu));
    g_return_if_fail(menu_shell != NULL);

    children_iter = GTK_MENU_SHELL(menu_shell)->children;

    while(children_iter)
    {
        child = (GtkWidget*)children_iter->data;
        children_iter = g_list_next(children_iter);
        
        if(remove_items)
        {
            gtk_container_remove(GTK_CONTAINER(menu_shell), child);
        }

        if(child == separator)
        {
            remove_items = TRUE;
        }
    }
}

static void
favorites_menu_populate(HXMainWindow* window)
{
    GtkWidget* separator;
    GtkWidget* favorites_menu;
    gint pos;
    GList* children;
    GtkWidget* menu_item;
    GtkWidget* menu_shell;

    separator = glade_xml_get_widget(window->xml, "hmw_favorites_separator");
    g_return_if_fail(separator != NULL);

    favorites_menu = glade_xml_get_widget(window->xml, "hmw_favorites_menu");
    g_return_if_fail(favorites_menu != NULL);

    menu_shell = gtk_menu_item_get_submenu(GTK_MENU_ITEM(favorites_menu));
    g_return_if_fail(menu_shell != NULL);

    children = GTK_MENU_SHELL(menu_shell)->children;
    
    pos = g_list_index(children, separator);
    g_return_if_fail(pos >= 0);

    pos++;

    gint i = 0;
    GList* iter = g_hx_main_app->favorites_list;
    while(iter)
    {
        gchar* escaped_title;
        gchar* menu_item_text;
        gchar* url;
        HXFavorite* favorite = (HXFavorite*)iter->data;
        
        escaped_title = hxcommon_escape_underscores(favorite->title);

        menu_item_text = g_strdup_printf("_%d. %s", i+1, escaped_title);
        g_free(escaped_title);
                            
        menu_item = gtk_menu_item_new_with_mnemonic(menu_item_text);
        g_free(menu_item_text);
        gtk_widget_show(GTK_WIDGET(menu_item));
        gtk_menu_shell_insert(GTK_MENU_SHELL(menu_shell), menu_item, pos);

        g_object_set_data(G_OBJECT(menu_item), "item_type", (gpointer) PLAY_MENU_TYPE_FAVORITE);
        
        url = g_strdup(favorite->url);
        g_signal_connect(G_OBJECT(menu_item), "activate",
                         G_CALLBACK(hmw_play_from_menu_item), url);
        
        /* Free the g_strdup'd url from above on menu destruction */
        g_signal_connect_swapped(G_OBJECT(menu_item), "destroy",
                                 G_CALLBACK(g_free), url);        
        i++;
        pos++;
        iter = g_list_next(iter);
    }
}

static void
favorites_menu_refresh(HXMainWindow* window)
{
    favorites_menu_unpopulate(window);
    favorites_menu_populate(window);
}

void
hxwindow_favorite_add(HXMainWindow* window,
                      const gchar*  favorite_title,
                      const gchar*  favorite_url)
{