mimetypes.cpp

linux下的一款播放器

    store = gtk_tree_store_new(NUM_COLUMNS,
                               G_TYPE_STRING,
                               G_TYPE_STRING,
                               G_TYPE_BOOLEAN,
                               G_TYPE_POINTER,
                               G_TYPE_STRING);
    
    ff_iter = info->file_formats_list;
    while(ff_iter)
    {
        const char** pszMimeTypes;
        const char** pszExtensions;
        const char** pszOpenNames;

        pFileFormat = (IHXFileFormatObject*)ff_iter->data;        
        pFileFormat->GetFileFormatInfo( pszMimeTypes,
                                        pszExtensions,
                                        pszOpenNames);
        while(*pszMimeTypes)
        {
            /* Properties that show up at the top treeview level */
            gboolean bToplevelHandlerIsHxplay = TRUE;
            const char* szToplevelApp = APP_NAME_SHORT;
            
            gtk_tree_store_append (store, &iter, NULL);
            
            mime_iter = info->mime_association_managers_list;
            while(mime_iter)
            {
                gboolean bHandlerIsHxplay = FALSE;
                const char* szMimeType = *pszMimeTypes;
                const char* szAppId = NULL;
                const char* szDatabaseName;
                const char* szDatabaseDescription;
                UINT32 uDatabaseVersion;
                HX_RESULT retVal;
                
                pMimeAssocMgr = (IHXMimeAssocManager*)mime_iter->data;

                pMimeAssocMgr->GetMimeSystemInfo(szDatabaseName,
                                                 szDatabaseDescription,
                                                 uDatabaseVersion);

		// setup unknown mime types
		if (!pMimeAssocMgr->MimeExists(szMimeType))
		{
		    IHXMimeInfo* pMimeInfo = NULL;
		    if (SUCCEEDED(pMimeAssocMgr->GetMime(szMimeType,
							 pMimeInfo)))
		    {
                        gchar* icon_filename;
                        icon_filename = hxcommon_locate_file("icon.png");

			pMimeInfo->SetName(szMimeType);
			pMimeInfo->SetIcon(icon_filename);

                        g_free(icon_filename);
                        
			const char** pExt = pszExtensions;
			while (*pExt)
			{
			    pMimeInfo->AddExt(*pExt);
			    ++pExt;
			}
			HX_RELEASE(pMimeInfo);
		    }
		}

                retVal = pMimeAssocMgr->GetAssoc(szMimeType, szAppId);
                if(SUCCEEDED(retVal))
                {
                    if(!szAppId)
                    {
                        szAppId = _("unknown");
                    }
                }
                else
                {		    
                    szAppId = _("none");                    
                }

                if(strstr(szAppId, APP_NAME_SHORT))
                {
                    bHandlerIsHxplay = TRUE;
                }
                else
                {
                    bToplevelHandlerIsHxplay = FALSE;
                    szToplevelApp = szAppId;
                }
                            
                gtk_tree_store_append (store, &child_iter, &iter);
                gtk_tree_store_set(store, &child_iter,
                                   COLUMN_MIME_TYPE_ASSOCIATION, szDatabaseName,
                                   COLUMN_CURRENT_APPLICATION, szAppId,
                                   COLUMN_ASSIGN, bHandlerIsHxplay,
                                   COLUMN_MIME_ASSOCIATION_MANAGER, pMimeAssocMgr,
                                   COLUMN_MIME_TYPE, *pszMimeTypes,
                                   -1);

                mime_iter = g_list_next(mime_iter);
            }            

            gtk_tree_store_set(store, &iter,
                               COLUMN_MIME_TYPE_ASSOCIATION, *pszMimeTypes,
                               COLUMN_CURRENT_APPLICATION, szToplevelApp,
                               COLUMN_ASSIGN, bToplevelHandlerIsHxplay,
                               COLUMN_MIME_ASSOCIATION_MANAGER, NULL,
                               COLUMN_MIME_TYPE, *pszMimeTypes,
                               -1);
            pszMimeTypes++;
        }

        ff_iter = g_list_next(ff_iter);
    }
        
    /* Add the model to the view */
    gtk_tree_view_set_model(info->tree_view,
			    GTK_TREE_MODEL(store));

    /* Create columns */
    text_renderer = gtk_cell_renderer_text_new();
    toggle_renderer = gtk_cell_renderer_toggle_new();

    g_signal_connect (G_OBJECT (toggle_renderer),
                      "toggled",
                      G_CALLBACK (mime_type_assign_toggled),
                      store);

    column = gtk_tree_view_column_new_with_attributes(_("MIME Info"),
                                                      text_renderer,
                                                      "text", COLUMN_MIME_TYPE_ASSOCIATION,
                                                      NULL);
    gtk_tree_view_append_column(info->tree_view, column);
    gtk_tree_view_column_set_sort_column_id(column, COLUMN_MIME_TYPE_ASSOCIATION);


    column = gtk_tree_view_column_new_with_attributes(_("Application"),
                                                      text_renderer,
                                                      "text", COLUMN_CURRENT_APPLICATION,
                                                      NULL);
    gtk_tree_view_append_column(info->tree_view, column);
    gtk_tree_view_column_set_sort_column_id(column, COLUMN_CURRENT_APPLICATION);
    
    column = gtk_tree_view_column_new_with_attributes(_("Assign to hxplay"),
                                                      toggle_renderer,
                                                      "active", COLUMN_ASSIGN,
                                                      NULL);
    gtk_tree_view_append_column(info->tree_view, column);
    gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (column), TRUE);    
}

void
hxplay_mime_types_pane_destroy(HXMimeTypesDialogInfo* info)
{
    IHXMimeAssocManager* pMimeAssocMgr;
    IHXFileFormatObject* pFileFormat;
    GList* ff_iter;
    GList* mime_iter;
    
    ff_iter = info->file_formats_list;
    while(ff_iter)
    {
        pFileFormat = (IHXFileFormatObject*)ff_iter->data;
        HX_RELEASE(pFileFormat);
        ff_iter = g_list_next(ff_iter);
    }

    g_list_free(info->file_formats_list);

    mime_iter = info->mime_association_managers_list;   
    while(mime_iter)
    {
        pMimeAssocMgr = (IHXMimeAssocManager*)mime_iter->data;
        HX_RELEASE(pMimeAssocMgr);
        mime_iter = g_list_next(mime_iter);
    }

    g_list_free(info->mime_association_managers_list);
}


HXMimeTypesDialogInfo*
hxplay_mime_types_pane_new(GladeXML* xml,
                           HXPlayer* player)
{
    HXMimeTypesDialogInfo *info;
    GtkWidget* tree_view;    
    GtkWidget* notebook;   

    tree_view = glade_xml_get_widget (xml, "hpd_mime_types_tree_view");
    if(tree_view == NULL)
    {
        /* No mime types pane available to hook onto */
        return NULL;
    }

    notebook = glade_xml_get_widget (xml, "hpd_mime_types_notebook");
    g_return_val_if_fail(notebook != NULL, NULL);    

    info = g_new0(HXMimeTypesDialogInfo, 1);
    info->tree_view = GTK_TREE_VIEW(tree_view);
    
    /* Get the plugin manager */
    HX_RESULT retVal;
    gboolean result;
    IUnknown* pUnk;
    IHXPlugin2Handler* pPlugin2Handler;
    IHXPluginEnumerator* pPluginEnumerator;
    IHXMimeAssocManager* pMimeAssocMgr;
    IHXFileFormatObject* pFileFormat;

    result = hx_player_get_unknown(player,
                                   (void**)&pUnk);
    g_return_val_if_fail(result != FALSE, NULL);

    retVal = pUnk->QueryInterface(IID_IHXPlugin2Handler,
                                  (void**)&pPlugin2Handler);
    g_return_val_if_fail(pPlugin2Handler && SUCCEEDED(retVal), NULL);

    retVal = pUnk->QueryInterface(IID_IHXPluginEnumerator,
                                  (void**)&pPluginEnumerator);
    g_return_val_if_fail(pPluginEnumerator && SUCCEEDED(retVal), NULL);

    /* Build a list of datatypes */
    UINT32 nFileFormatPlugins = 0;
    UINT32 nMimeMgrPlugins = 0;
    UINT32 nPlugins;
    UINT32 i;
    
    /* Get supported mime types */
    nPlugins = pPluginEnumerator->GetNumOfPlugins();

    for(i = 0; i < nPlugins; i++)
    {        
        pMimeAssocMgr = NULL;
        pFileFormat = NULL;

        retVal = pPluginEnumerator->GetPlugin(i, pUnk);

        if(SUCCEEDED(retVal))
        {
            retVal = pUnk->QueryInterface(IID_IHXMimeAssocManager,
                                          (void**)&pMimeAssocMgr);
        }

        if(SUCCEEDED(retVal))
        {

            retVal = pUnk->QueryInterface(IID_IHXFileFormatObject,
                                          (void**)&pFileFormat);
        }

        if(SUCCEEDED(retVal))
        {
            info->mime_association_managers_list =
                g_list_append(info->mime_association_managers_list,
                              pMimeAssocMgr);

            info->file_formats_list = g_list_append(info->file_formats_list,
                                                    pFileFormat);
        }
    }
    
    /* Get mime type association plugins */
    nMimeMgrPlugins = g_list_length(info->mime_association_managers_list);
    nFileFormatPlugins = g_list_length(info->file_formats_list);
            
    if(nMimeMgrPlugins == 0)
    {
        /* Switch tree view to a "no mime plugins found" tab & return. */
        gtk_notebook_set_current_page(GTK_NOTEBOOK(notebook), 1);
        hxplay_mime_types_pane_destroy(info);
        info = NULL;
    }
    else
    {
        gtk_notebook_set_current_page(GTK_NOTEBOOK(notebook), 0);
        populate_mime_types_tree_view(info);        
    }

    HX_RELEASE(pPlugin2Handler);
    HX_RELEASE(pPluginEnumerator);

    return info;
}