browsertree.cpp

FreeAMP(MP3播放)程序源代码-用来研究MP3解码

        name[0] = (char *)album->name.c_str();
        albTree = gtk_ctree_insert_node(musicBrowserTree, artTree,
                                          NULL, name, 5, album_pmap, album_mask,
                                          album_pmap, album_mask, false, false);
        data = NewTreeData(kTreeAlbum, NULL, artist, album);
        gtk_ctree_node_set_row_data_full(musicBrowserTree, albTree, data,
                                         (GtkDestroyNotify)kill_treedata);
        if (expand)
            gtk_ctree_expand(musicBrowserTree, albTree);
    }

    string title = item->GetMetaData().Title();
    char *fullname = new char[title.size() + 10];
    uint32 trackno = item->GetMetaData().Track();

    if (trackno > 0) 
        sprintf(fullname, "%d - %s", trackno, title.c_str());
    else
        sprintf(fullname, "? - %s", title.c_str());

    name[0] = fullname;

    newItem = gtk_ctree_insert_node(musicBrowserTree, albTree, NULL, name, 5,
                                    track_pmap, track_mask, track_pmap, 
                                    track_mask, true, false);
    data = NewTreeData(kTreeTrack, NULL, artist, album, item);
    gtk_ctree_node_set_row_data_full(musicBrowserTree, newItem, data,
                                     (GtkDestroyNotify)kill_treedata);

    delete [] fullname;

    gtk_ctree_sort_node(musicBrowserTree, albTree);
    if (expand) {
        gtk_ctree_expand_recursive(musicBrowserTree, newItem);
        gtk_ctree_select(musicBrowserTree, newItem);
        gtk_ctree_node_moveto(musicBrowserTree, newItem, 0, 0.5, 0);
    }

    name[0] = (char *)title.c_str();

    newItem = gtk_ctree_insert_node(musicBrowserTree, allTree, NULL, name, 5,
                                    track_pmap, track_mask, track_pmap, 
                                    track_mask, true, false);
    data = NewTreeData(kTreeTrack, NULL, artist, album, item);
    gtk_ctree_node_set_row_data_full(musicBrowserTree, newItem, data, 
                                     (GtkDestroyNotify)kill_treedata);

    gtk_ctree_sort_recursive(musicBrowserTree, allTree);
    gtk_clist_thaw(GTK_CLIST(musicBrowserTree));
}

void GTKMusicBrowser::RemoveCatTrack(ArtistList *artist, AlbumList *album,
                                     PlaylistItem *item)
{
    GtkCTreeNode *toRemove;

    gtk_clist_freeze(GTK_CLIST(musicBrowserTree));

    toRemove = FindNode(kTreeTrack, artist, album, item, allTree);

    if (toRemove)
        gtk_ctree_remove_node(musicBrowserTree, toRemove);

    toRemove = FindNode(kTreeTrack, artist, album, item);

    if (toRemove) {
        GtkCTreeRow *row = GTK_CTREE_ROW(toRemove);
        GtkCTreeNode *alb = row->parent;
        GtkCTreeNode *art = GTK_CTREE_ROW(alb)->parent;

        gtk_ctree_remove_node(musicBrowserTree, toRemove);
        if (!GTK_CTREE_ROW(alb)->children) {
            gtk_ctree_remove_node(musicBrowserTree, alb);
            if (!GTK_CTREE_ROW(art)->children)
                gtk_ctree_remove_node(musicBrowserTree, art);
        }
    }
    gtk_clist_thaw(GTK_CLIST(musicBrowserTree));
}

GtkCTreeNode *GTKMusicBrowser::FindStreamNode(PlaylistItem *stream)
{
    GtkCTreeNode *retnode;
    TreeData *data = NewTreeData(kTreeFavStream, NULL, NULL, NULL, stream);

    retnode = gtk_ctree_find_by_row_data_custom(musicBrowserTree, favoritesTree,
                                                data,
                                                (GCompareFunc)TreeDataCompare);

    delete data;
    return retnode;
}

void GTKMusicBrowser::AddCatStream(PlaylistItem *item)
{
    char         *name[1];
    TreeData     *data;
    GtkCTreeNode *node;

    name[0] = (char *)(item->GetMetaData().Title().c_str());

    node = gtk_ctree_insert_node(musicBrowserTree, favoritesTree, NULL,
                                 name, 5, stream_pmap, stream_mask, stream_pmap,
                                 stream_mask,
                                 true, false);
    data = NewTreeData(kTreeFavStream, NULL, NULL, NULL, item);
    gtk_ctree_node_set_row_data_full(musicBrowserTree, node, data,
                                     (GtkDestroyNotify)kill_treedata);
}

void GTKMusicBrowser::RemoveCatStream(PlaylistItem *item)
{
    GtkCTreeNode *toRemove;

    toRemove = FindStreamNode(item);

    if (toRemove)
        gtk_ctree_remove_node(musicBrowserTree, toRemove);
}

GtkCTreeNode *GTKMusicBrowser::FindPlaylistNode(const string &playlist)
{
    GtkCTreeNode *retnode;
    TreeData *data = NewTreeData(kTreePlaylist, NULL, NULL, NULL, NULL,
                                 (char *)playlist.c_str());

    retnode = gtk_ctree_find_by_row_data_custom(musicBrowserTree, playlistTree,
                                                data,
                                                (GCompareFunc)TreeDataCompare);

    delete data;
    return retnode;
}

void GTKMusicBrowser::AddCatPlaylist(const string &playlist)
{
    char *fullname = new char[playlist.length() + 1];
    strcpy(fullname, playlist.c_str());
    char *listname = fullname;
    char *temp = strrchr(fullname, '.');
    if (temp)
        *temp = '\0';
    temp = strrchr(fullname, '/');
    if (temp)
        listname = temp + 1;

    char *name[1];
    name[0] = listname;
    TreeData  *data;
    GtkCTreeNode *allItem;
    allItem = gtk_ctree_insert_node(musicBrowserTree, playlistTree, NULL,
                                    name, 5, playlist_pmap, playlist_mask, 
                                    playlist_pmap, playlist_mask,
                                    true, false);
    data = NewTreeData(kTreePlaylist, NULL, NULL, NULL, NULL,
                       (char *)playlist.c_str(), (char *)playlist.c_str());
    gtk_ctree_node_set_row_data_full(musicBrowserTree, allItem, data,
                                     (GtkDestroyNotify)kill_treedata);

    delete [] fullname;
}

void GTKMusicBrowser::RemoveCatPlaylist(const string &playlist)
{
    GtkCTreeNode *toRemove;

    toRemove = FindPlaylistNode(playlist);

    if (toRemove)
        gtk_ctree_remove_node(musicBrowserTree, toRemove);
}

void GTKMusicBrowser::UpdateCDTree(PlaylistItem *update)
{
    if (!CDTree)
        return;

    GtkCTreeNode *find = FindNode(kTreeCD, NULL, NULL, update, CDTree);

    if (!find) {
        return;
    }
    GdkPixmap *pixmap;
    GdkBitmap *mask;

    MetaData mdata = (MetaData)update->GetMetaData();
    if (mdata.Title().size() > 0) {
        gtk_ctree_node_get_pixtext(musicBrowserTree, find, 0, NULL, NULL,
                                   &pixmap, &mask);
        gtk_ctree_node_set_pixtext(musicBrowserTree, find, 0,
                                   mdata.Title().c_str(), 5, pixmap, mask);
    }

    char *tempstr = new char[mdata.Album().size() + mdata.Artist().size() + 50];
    if (mdata.Album().size() > 0)
        sprintf(tempstr, "%s ", mdata.Album().c_str());
    else
        sprintf(tempstr, "Unknown Album ");
    strcat(tempstr, "(");
    if (mdata.Artist().size() > 0)
        strcat(tempstr, mdata.Artist().c_str());
    else
        strcat(tempstr, "Unknown Artist");
    strcat(tempstr, ")");

    gtk_ctree_node_get_pixtext(musicBrowserTree, CDTree, 0, NULL, NULL,
                               &pixmap, &mask);
    gtk_ctree_node_set_pixtext(musicBrowserTree, CDTree, 0, tempstr, 5,
                               pixmap, mask);

    delete [] tempstr;
}

void GTKMusicBrowser::RegenerateCDTree(void)
{
    GtkCTreeRow *row = GTK_CTREE_ROW(CDTree);

    gtk_clist_freeze(GTK_CLIST(musicBrowserTree));

    while (row->children) {
        GtkCTreeNode *todelete = row->children;
        gtk_ctree_remove_node(musicBrowserTree, todelete);
    }

    while (CDTracks->size() > 0)
        CDTracks->erase(CDTracks->begin());

    char url[40];
    char *name[1];
    GtkCTreeNode *cdItem;
    TreeData *data;
    PlaylistItem *newitem;

    for (uint32 tracknum = 1; tracknum <= CD_numtracks; tracknum++) {
        sprintf(url, "file://%d.cda", tracknum);
        newitem = new PlaylistItem(url);

        name[0] = (char *)newitem->URL().c_str();
        cdItem = gtk_ctree_insert_node(musicBrowserTree, CDTree, NULL, name,
                                       5, track_pmap, track_mask, track_pmap, 
                                       track_mask, true,
                                       false);
        data = NewTreeData(kTreeCD, NULL, NULL, NULL, newitem);
        gtk_ctree_node_set_row_data_full(musicBrowserTree, cdItem, data,
                                         (GtkDestroyNotify)kill_treedata);

        CDTracks->push_back(newitem);
    }
    if (CDTracks->size() > 0) {
        vector<PlaylistItem *> *metalist =
                                   new vector<PlaylistItem *>(CDTracks->size());

        copy(CDTracks->begin(), CDTracks->end(), metalist->begin());
        m_plm->RetrieveMetaData(metalist);
    }

    GdkPixmap *pixmap;
    GdkBitmap *mask;

    gtk_ctree_node_get_pixtext(musicBrowserTree, CDTree, 0, NULL, NULL, &pixmap,
                               &mask);
    gtk_ctree_node_set_pixtext(musicBrowserTree, CDTree, 0, "CD Audio", 5,
                               pixmap, mask);

    gtk_clist_thaw(GTK_CLIST(musicBrowserTree));

    gtk_widget_set_sensitive(gtk_item_factory_get_widget(menuFactory,
                             "/Controls/Eject CD"), (CD_numtracks > 0));
}

void GTKMusicBrowser::ClearTree(void)
{
    gtk_clist_freeze(GTK_CLIST(musicBrowserTree));
    gtk_clist_clear(GTK_CLIST(musicBrowserTree));

    CreateMainTreeItems();

    gtk_clist_thaw(GTK_CLIST(musicBrowserTree));
}

void GTKMusicBrowser::HandleKeypress(char key)
{
    GtkCTreeNode *sibling = GTK_CTREE_ROW(mainTree)->children;
    sibling = GTK_CTREE_ROW(sibling)->sibling;
    sibling = GTK_CTREE_ROW(sibling)->sibling;

    while (sibling) {
        GtkCListRow *row = (GtkCListRow *)GTK_CTREE_ROW(sibling);
        char *sibtext = GTK_CELL_PIXTEXT(row->cell[0])->text;
        if (tolower(sibtext[0]) == key) {
            gtk_ctree_expand(musicBrowserTree, GTK_CTREE_NODE(mainTree));
            gtk_ctree_node_moveto(musicBrowserTree, GTK_CTREE_NODE(sibling), 
                                  0, 0.5, 0);
            gtk_ctree_unselect_recursive(musicBrowserTree, 
                                         GTK_CTREE_NODE(mainTree));
            gtk_ctree_select(musicBrowserTree, GTK_CTREE_NODE(sibling));
            break;
        }
        sibling = GTK_CTREE_ROW(sibling)->sibling;
    }
}

static void tree_keypress(GtkWidget *w, GdkEventKey *event, GTKMusicBrowser *p)
{
    assert(event);
    p->HandleKeypress(tolower((char)event->keyval));
}

bool GTKMusicBrowser::CheckEmptyDatabase(void)
{
    if (m_context->catalog->GetPlaylists()->size() > 0 ||
        m_context->catalog->GetMusicList()->size() > 0 ||
        m_context->catalog->GetUnsortedMusic()->size() > 0)
        return false;

    bool welcome = false;

    m_context->prefs->GetPrefBoolean(kWelcomePref, &welcome);

    if (welcome) {
        m_context->prefs->SetPrefBoolean(kWelcomePref, false);
        StartMusicSearch(false, true);
    }
    else {
        GTKMessageDialog oBox;
        string oMessage = string("Your music database does not contain any items.  Would you like to start a music search to find music and playlists on your machine?");

        if (oBox.Show(oMessage.c_str(), "MusicBrowser", kMessageYesNo)
            == kMessageReturnYes)
           StartMusicSearch(false);
    }
    return true;
}

void GTKMusicBrowser::UpdateCatalog(void)

{
    m_musicCatalog = m_context->catalog;
    m_musicCatalog->GetCatalogLock();

    vector<ArtistList *> *artistList =
                         (vector<ArtistList *> *)m_musicCatalog->GetMusicList();
    vector<PlaylistItem *> *unsorted =
                   (vector<PlaylistItem *> *)m_musicCatalog->GetUnsortedMusic();
    vector<string> *playlists =
                               (vector<string> *)m_musicCatalog->GetPlaylists();
    vector<PlaylistItem *> *streams =