musictree.cpp

vc++ mp3 源码下载 使用vc写的mp3 播放器

            }
        }
    }

    if(trackItem)
    {
        TreeView_DeleteItem(m_hMusicView, trackItem);
    }

    if(albumItem && !album->m_trackList->size())
    {
        TreeView_DeleteItem(m_hMusicView, albumItem);
    }

    if(artistItem && !artist->m_albumList->size())
    {
        TreeView_DeleteItem(m_hMusicView, artistItem);
    }

    trackItem = FindTrack(m_hAllItem, item);

    if(trackItem)
    {
        TreeView_DeleteItem(m_hMusicView, trackItem);
    }

}

void MusicBrowserUI::MusicCatalogTrackAdded(const ArtistList* artist,
                                            const AlbumList* album,
                                            const PlaylistItem* item)
{
    const MetaData meta = item->GetMetaData();
    HTREEITEM newItem = NULL;

    // can we catagorize this track?
    if(!artist) 
    {
        if(m_hUncatItem)
        {
            // nope, stick in uncatagorized
            TV_INSERTSTRUCT insert;
            TreeData        data;
            MetaData        metadata;

            insert.item.mask = TVIF_TEXT | TVIF_IMAGE | TVIF_CHILDREN |
                                TVIF_SELECTEDIMAGE | TVIF_PARAM; 

            data.m_iLevel = 3;
            data.m_pArtist = NULL;
            data.m_pAlbum = NULL;
    
        
            data.m_pTrack = (PlaylistItem*)item;
            metadata = item->GetMetaData();

            if (metadata.Title() == string(" ") || 
                metadata.Title().length() == 0)
                insert.item.pszText = "Unknown";
            else    
                insert.item.pszText = (char *)(metadata.Title().c_str());
        
            insert.item.cchTextMax = metadata.Title().length();
            insert.item.iImage = 4;
            insert.item.iSelectedImage = 4;
            insert.item.cChildren= 0;
            insert.item.lParam = (LPARAM) new TreeData(data);
            insert.hInsertAfter = TVI_SORT;
            insert.hParent = m_hUncatItem;
            newItem = TreeView_InsertItem(m_hMusicView, &insert);
        }
    }
    else 
    {
        // yep, search for it
        HTREEITEM artistItem, albumItem;

        artistItem = FindArtist(artist);

        if(artistItem)
        {
            albumItem = FindAlbum(artistItem, album);

            if(albumItem)
            {
                if(TreeView_GetChild(m_hMusicView, albumItem))
                {
                    TV_INSERTSTRUCT insert;
                    TreeData        data;
                    MetaData        metadata;

                    insert.item.mask = TVIF_TEXT | TVIF_IMAGE | TVIF_CHILDREN |
                                        TVIF_SELECTEDIMAGE | TVIF_PARAM; 

                    data.m_iLevel = 3;
                    data.m_pArtist = (ArtistList*)artist;
                    data.m_pAlbum = (AlbumList*)album;
    
                    data.m_pTrack = (PlaylistItem*)item;
                    metadata = item->GetMetaData();

                    if (metadata.Title() == string(" ") || 
                        metadata.Title().length() == 0)
                        insert.item.pszText = "Unknown";
                    else    
                        insert.item.pszText = (char *)(metadata.Title().c_str());
    
                    insert.item.cchTextMax = metadata.Title().length();
                    insert.item.iImage = 4;
                    insert.item.iSelectedImage = 4;
                    insert.item.cChildren= 0;
                    insert.item.lParam = (LPARAM) new TreeData(data);
                    insert.hInsertAfter = TVI_LAST;
                    insert.hParent = albumItem;

                    TV_ITEM tv_item;
                    HTREEITEM sibling = NULL;

                    tv_item.mask = TVIF_PARAM;

                    if(tv_item.hItem = TreeView_GetChild(m_hMusicView, albumItem))
                    {
                        BOOL success;

                        do
                        {
                            success = TreeView_GetItem(m_hMusicView, &tv_item);

                            if(success)
                            {
                                TreeData* treedata = (TreeData*)tv_item.lParam;

                                if(treedata)
                                {
                                    PlaylistItem* track = treedata->m_pTrack;
                                    MetaData metadata = track->GetMetaData();
                                
                                    if(metadata.Track())
                                    {
                                        if(metadata.Track() > metadata.Track())
                                        {
                                            if(sibling)
                                                insert.hInsertAfter = sibling;
                                            else
                                                insert.hInsertAfter = TVI_FIRST;
                                            break;
                                        }
                                    }
                                    else
                                    {
                                        if(metadata.Track() || metadata.Title() >  metadata.Title())
                                        {
                                            if(sibling)
                                                insert.hInsertAfter = sibling;
                                            else
                                                insert.hInsertAfter = TVI_FIRST;
                                            break;
                                        }
                                    }
                                }
                            }

                            sibling = tv_item.hItem;
        
                        }while(success && 
                               (tv_item.hItem = TreeView_GetNextSibling(m_hMusicView, 
                                                                        tv_item.hItem)));
                    }

                    newItem = TreeView_InsertItem(m_hMusicView, &insert);
                }
            }
            else // might need to add the album
            {
                if(TreeView_GetChild(m_hMusicView, artistItem))
                {
                    TV_INSERTSTRUCT insert;
                    TreeData        data; 

                    insert.item.mask = TVIF_TEXT | TVIF_IMAGE | TVIF_CHILDREN |
                                        TVIF_SELECTEDIMAGE | TVIF_PARAM; 

                    data.m_iLevel = 2;
                    data.m_pArtist = (ArtistList*)artist;
                    data.m_pAlbum = (AlbumList*)album;

                    if (album->name == string(" ") || 
                        album->name.length() == 0)
                        insert.item.pszText = "Unknown";
                    else    
                        insert.item.pszText = (char *)album->name.c_str();
    
                    insert.item.cchTextMax = album->name.length();
                    insert.item.iImage = 3;
                    insert.item.iSelectedImage = 3;
                    insert.item.cChildren= 1;
                    insert.item.lParam = (LPARAM) new TreeData(data);
                    insert.hInsertAfter = TVI_SORT;
                    insert.hParent = artistItem;
                    newItem = TreeView_InsertItem(m_hMusicView, &insert);
                }
            }
        }
        else // might need to add the artist
        {
            if(TreeView_GetNextSibling(m_hMusicView, m_hUncatItem))
            {
                TV_INSERTSTRUCT insert;
                TreeData        data;

                insert.item.mask = TVIF_TEXT | TVIF_IMAGE | TVIF_CHILDREN |
                             TVIF_SELECTEDIMAGE | TVIF_PARAM; 

                data.m_iLevel = 1;
                data.m_pArtist = (ArtistList*)artist;

                insert.item.pszText = (char*)artist->name.c_str();
                insert.item.cchTextMax = artist->name.length();
                insert.item.iImage = 2;
                insert.item.iSelectedImage = 2;
                insert.item.cChildren= 1;
                insert.item.lParam = (LPARAM) new TreeData(data);
                insert.hInsertAfter = TVI_LAST;
                insert.hParent = m_hMyMusicItem;

                TV_ITEM tv_item;
                HTREEITEM sibling = m_hUncatItem;

                tv_item.mask = TVIF_PARAM;

                if(tv_item.hItem = TreeView_GetNextSibling(m_hMusicView, m_hUncatItem))
                {
                    BOOL success;

                    do
                    {
                        success = TreeView_GetItem(m_hMusicView, &tv_item);

                        if(success)
                        {
                            TreeData* treedata = (TreeData*)tv_item.lParam;

                            if(treedata)
                            {
                                ArtistList* artist2 = treedata->m_pArtist;
                            
                                if(lstrcmp(artist2->name.c_str(), artist->name.c_str()) > 0)
                                {
                                    insert.hInsertAfter = sibling;
                                    break;
                                }
                            }
                        }

                        sibling = tv_item.hItem;
    
                    }while(success && 
                           (tv_item.hItem = TreeView_GetNextSibling(m_hMusicView, 
                                                                    tv_item.hItem)));
                }

                newItem = TreeView_InsertItem(m_hMusicView, &insert);
            }       
        }
    }

    //TreeView_EnsureVisible(m_hMusicView, newItem);

    // put it under "All Tracks"
    if(TreeView_GetChild(m_hMusicView, m_hAllItem))
    {
        if(m_hAllItem)
        {
            TV_INSERTSTRUCT insert;
            TreeData        data;
            MetaData        metadata;

            insert.item.mask = TVIF_TEXT | TVIF_IMAGE | TVIF_CHILDREN |
                                TVIF_SELECTEDIMAGE | TVIF_PARAM;

            data.m_iLevel = 3;
            data.m_pArtist = (ArtistList*)artist;
            data.m_pAlbum = (AlbumList*)album;

            data.m_pTrack = (PlaylistItem*)item;
            metadata = item->GetMetaData();

            if (metadata.Title() == string(" ") || 
                metadata.Title().length() == 0)
                insert.item.pszText = "Unknown";
            else    
                insert.item.pszText = (char *)(metadata.Title().c_str());

            insert.item.cchTextMax = metadata.Title().length();
            insert.item.iImage = 4;
            insert.item.iSelectedImage = 4;
            insert.item.cChildren= 0;
            insert.item.lParam = (LPARAM) new TreeData(data);
            insert.hInsertAfter = TVI_SORT;
            insert.hParent = m_hAllItem;
            TreeView_InsertItem(m_hMusicView, &insert);
        }
    }
}

void MusicBrowserUI::TVBeginDrag(HWND hwnd, NM_TREEVIEW* nmtv)
{
    if(nmtv->itemNew.hItem != m_hNewPlaylistItem && 
       nmtv->itemNew.hItem != m_hPortableItem &&
       nmtv->itemNew.hItem != m_hNewPortableItem)
    {
        vector<PlaylistItem*> items;
        vector<string>* urls = new vector<string>;

        GetSelectedMusicTreeItems(&items); 

        vector<PlaylistItem*>::iterator i;

        for(i = items.begin(); i != items.end(); i++)
        {
            urls->push_back((*i)->URL().c_str());
        }

        GetSelectedPlaylistItems(urls);
        //GetSelectedStreamItems(urls);

        HIMAGELIST himl;
        RECT rcItem;
        POINT hotspot;

        himl = TreeView_CreateDragImage(hwnd, nmtv->itemNew.hItem);

        TreeView_GetItemRect(hwnd, nmtv->itemNew.hItem, &rcItem, TRUE); 

        hotspot.x = 0;
        hotspot.y = (rcItem.bottom - rcItem.top)/2;

        DataObject* data = new DataObject(CFSTR_FREEAMP_CATALOGITEM, urls);
        DropSource* src = new DropSource(hwnd, himl, hotspot, nmtv->ptDrag);
        DWORD dwEffect = 0;

        DoDragDrop(data, src, DROPEFFECT_COPY|DROPEFFECT_SCROLL, &dwEffect); 

        data->Release();
        src->Release();
    }
}

void MusicBrowserUI::AddAllTrackItems(vector<PlaylistItem*>* items)
{
    vector<ArtistList*>*            artistList;
    vector<ArtistList*>::iterator   artist;    

    artistList = (vector<ArtistList*>*)
            m_context->catalog->GetMusicList();

    for(artist = artistList->begin(); 
        artist != artistList->end(); 
        artist++)
    {
        vector<AlbumList*>::iterator album;

        for(album = (*artist)->m_albumList->begin();
            album != (*artist)->m_albumList->end();
            album++)
        {
            vector<PlaylistItem*>::iterator track;

            for(track = (*album)->m_trackList->begin();
                track != (*album)->m_trackList->end();
                track++)
            {
                items->push_back(*track);
            }
        }
    }

    AddUncatagorizedTrackItems(items);
}

void MusicBrowserUI::AddUncatagorizedTrackItems(vector<PlaylistItem*>* items)
{
    vector<PlaylistItem*>*          trackList;
    vector<PlaylistItem*>::iterator track;

    trackList = (vector<PlaylistItem*>*)
            m_context->catalog->GetUnsortedMusic();

    for(track = trackList->begin(); 
        track != trackList->end(); 
        track++)
    {
        items->push_back(*track);
    }
}

void MusicBrowserUI::AddTrackItems(TV_ITEM* tv_item, 
                                   vector<PlaylistItem*>* items)
{
    // we need to determine what this item is 
    // so we can properly iterate it

    TreeData* treedata = (TreeData*)tv_item->lParam;

    if(treedata)
    {
        if(treedata->IsArtist())
        {
            ArtistList* artist = treedata->m_pArtist;
            vector<AlbumList*>::iterator album;
        
            for(album = artist->m_albumList->begin();
                album != artist->m_albumList->end();
                album++)
            {
                vector<PlaylistItem*>::iterator track;

                for(track = (*album)->m_trackList->begin();
                    track != (*album)->m_trackList->end();
                    track++)
                {
                    items->push_back(*track);
                }

            }
        }
        else if(treedata->IsAlbum())
        {
            AlbumList* album = treedata->m_pAlbum;
            vector<PlaylistItem *>::iterator track;

            for(track = album->m_trackList->begin();
                track != album->m_trackList->end();
                track++)
            {
                items->push_back(*track);
            }
        }
        else if(treedata->IsTrack() || treedata->IsUncatagorized())
        {
            PlaylistItem* track = treedata->m_pTrack;

            items->push_back(track);
        }
    }
}

BOOL MusicBrowserUI::FindSelectedItems(HTREEITEM root, vector<PlaylistItem*>* items)
{
    BOOL result = FALSE;
    HWND hwnd = m_hMusicView;
    TV_ITEM tv_item;

    tv_item.hItem = root;
    tv_item.mask = TVIF_STATE|TVIF_PARAM;
    tv_item.stateMask = TVIS_SELECTED;
    tv_item.state = 0;

    do
    {
        result = TreeView_GetItem(hwnd, &tv_item);

        HTREEITEM childItem = TreeView_GetChild(hwnd, tv_item.hItem);

        if(result && (tv_item.state & TVIS_SELECTED))
        {
            AddTrackItems(&tv_item, items);
        }
        else if(result && childItem)
        {
            FindSelectedItems(childItem, items);        
        }

    }while(result && (tv_item.hItem = TreeView_GetNextSibling(hwnd, tv_item.hItem)));
    
    return result;
}