musictree.cpp

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

            tv_item.hItem = m_hAllItem;
            tv_item.mask = TVIF_CHILDREN;
            tv_item.cChildren = 0;

            TreeView_SetItem(m_hMusicView, &tv_item);
        }
    }

}

void MusicBrowserUI::MusicCatalogStreamAdded(const PlaylistItem* item)
{
    if(TreeView_GetChild(m_hMusicView, m_hFavoritesItem))
    {
        TV_INSERTSTRUCT insert;
        TreeData        data;

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

        data.m_iLevel = 1;

    
        PlaylistItem* stream = new PlaylistItem(*item);
        MetaData metadata;

        data.m_pStream = stream;

        insert.item.pszText = (char*)stream->GetMetaData().Title().c_str();
        insert.item.cchTextMax = strlen(insert.item.pszText);
        insert.item.iImage = 8;
        insert.item.iSelectedImage = 8;
        insert.item.cChildren= 0;
        insert.item.lParam = (LPARAM) new TreeData(data);
        insert.hInsertAfter = TVI_SORT;
        insert.hParent = m_hFavoritesItem;
        TreeView_InsertItem(m_hMusicView, &insert);

        TreeView_DeleteItem(m_hMusicView, m_hNewFavoritesItem);
        insert.item.pszText = kNewFavorite;
        insert.item.cchTextMax = strlen(insert.item.pszText);
        insert.item.iImage = 8;
        insert.item.iSelectedImage = 8;
        insert.item.cChildren= 0;
        insert.item.lParam = NULL;
        insert.hInsertAfter = TVI_FIRST;
        insert.hParent = m_hFavoritesItem;
        m_hNewFavoritesItem = TreeView_InsertItem(m_hMusicView, &insert);
    }
}

void MusicBrowserUI::MusicCatalogStreamRemoved(const PlaylistItem* item)
{
    HTREEITEM streamItem = NULL;

    streamItem = FindFavorite(item);

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

void MusicBrowserUI::TVBeginDrag(HWND hwnd, NM_TREEVIEW* nmtv)
{
    if(nmtv->itemNew.hItem != m_hNewPlaylistItem && 
       nmtv->itemNew.hItem != m_hPortableItem &&
       nmtv->itemNew.hItem != m_hNewPortableItem &&
       nmtv->itemNew.hItem != m_hNewFavoritesItem &&
       nmtv->itemNew.hItem != m_hStreamsItem)
    {
        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);
        
        items.clear();

        GetSelectedFavoritesItems(&items);
        GetSelectedStreamItems(&items);

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

        GetSelectedCDItems(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;

    char buf[256];

    tv_item.hItem = root;
    tv_item.mask = TVIF_STATE|TVIF_PARAM|TVIF_TEXT;
    tv_item.stateMask = TVIS_SELECTED;
    tv_item.state = 0;
    tv_item.pszText = buf;
    tv_item.cchTextMax = sizeof(buf);

    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;
}

void MusicBrowserUI::GetSelectedCDItems(vector<string>* urls)
{
    TV_ITEM tv_root;

    tv_root.hItem = m_hCDItem;
    tv_root.mask = TVIF_STATE;
    tv_root.stateMask = TVIS_SELECTED;
    tv_root.state = 0;

    TreeView_GetItem(m_hMusicView, &tv_root);

    bool addAll = false;

    // if selected then we add all the cd tracks
    if(tv_root.state & TVIS_SELECTED)
    {
        addAll = true;
    }

    TV_ITEM tv_item;

    // get the first cd item
    tv_item.hItem = TreeView_GetChild(m_hMusicView, m_hCDItem);
    tv_item.mask = TVIF_STATE|TVIF_PARAM;
    tv_item.stateMask = TVIS_SELECTED;
    tv_item.state = 0;

    if(tv_item.hItem)
    {
        BOOL result = FALSE;

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

            if(result && ((tv_item.state & TVIS_SELECTED) || addAll))
            {
                TreeData* treedata = (TreeData*)tv_item.lParam;

                if(treedata)
                {
                    PlaylistItem* track = treedata->m_pTrack;

                    urls->push_back(track->URL());
                }
            }
    
        }while(result && 
               (tv_item.hItem = TreeView_GetNextSibling(m_hMusicView, 
                                                        tv_item.hItem)));
    }
}

void MusicBrowserUI::GetSelectedFavoritesItems(vector<PlaylistItem*>* items)
{
    TV_ITEM tv_root;

    tv_root.hItem = m_hFavoritesItem;
    tv_root.mask = TVIF_STATE;
    tv_root.stateMask = TVIS_SELECTED;
    tv_root.state = 0;

    TreeView_GetItem(m_hMusicView, &tv_root);

    bool addAll = false;

    // if selected then we add all the streams
    if(tv_root.state & TVIS_SELECTED)
    {
        addAll = true;
    }

    TV_ITEM tv_item;

    // get the first item
    tv_item.hItem = TreeView_GetChild(m_hMusicView, m_hFavoritesItem);
    tv_item.mask = TVIF_STATE|TVIF_PARAM;
    tv_item.stateMask = TVIS_SELECTED;
    tv_item.state = 0;

    if(tv_item.hItem)
    {
        BOOL result = FALSE;

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

            if(result && ((tv_item.state & TVIS_SELECTED) || addAll))
            {
                TreeData* treedata = (TreeData*)tv_item.lParam;

                if(treedata)
                {
                    items->push_back(treedata->m_pStream);
                }
            }
    
        }while(result && 
               (tv_item.hItem = TreeView_GetNextSibling(m_hMusicView, 
                                                        tv_item.hItem)));
    }
}

void MusicBrowserUI::GetSelectedStreamItems(vector<PlaylistItem*>* items, HTREEITEM rootItem)
{
    TV_ITEM tv_root;

	if(rootItem)
		tv_root.hItem = rootItem;
	else
		tv_root.hItem = m_hStreamsItem;

    tv_root.mask = TVIF_STATE;
    tv_root.stateMask = TVIS_SELECTED;
    tv_root.state = 0;

    TreeView_GetItem(m_hMusicView, &tv_root);

    bool addAll = false;

    // if selected then we add all the streams
    if(tv_root.state & TVIS_SELECTED)
    {
        addAll = true;
    }
   
    TV_ITEM tv_item;

    // get the first stream item
    tv_item.hItem = TreeView_GetChild(m_hMusicView, tv_root.hItem);
    tv_item.mask = TVIF_STATE|TVIF_PARAM;
    tv_item.stateMask = TVIS_SELECTED;
    tv_item.state = 0;

    if(tv_item.hItem)
    {
        BOOL result = FALSE;

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

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

			if(result && childItem)
			{
				GetSelectedStreamItems(items, tv_item.hItem);
			}
            else if(result && ((tv_item.state & TVIS_SELECTED) || addAll))
            {
                TreeData* treedata = (TreeData*)tv_item.lParam;

                if(treedata)
                {
                    items->push_back(treedata->m_pStream);
                }
            }
    
        }while(result && 
               (tv_item.hItem = TreeView_GetNextSibling(m_hMusicView, 
                                                        tv_item.hItem)));
    }
}

void MusicBrowserUI::GetSelectedPlaylistItems(vector<string>* urls)
{
    TV_ITEM tv_root;

    tv_root.hItem = m_hPlaylistItem;
    tv_root.mask = TVIF_STATE;
    tv_root.stateMask = TVIS_SELECTED;
    tv_root.state = 0;

    TreeView_GetItem(m_hMu