event.cpp

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

            
                GetCursorPos(&sPoint);

                menu = LoadMenu(g_hinst, MAKEINTRESOURCE(IDR_LVPOPUP));
                subMenu = GetSubMenu(menu, 0);

                if(m_pParent)
                {
                    DeleteMenu(subMenu, ID_POPUP_PLAY, MF_BYCOMMAND);
                }

                // Can we move items up and down?
                uint32 count = ListView_GetItemCount(m_hPlaylistView);
                uint32 selected = ListView_GetSelectedCount(m_hPlaylistView);

                if(count)
                {
                    uint32 state;

                    EnableMenuItem(subMenu, ID_POPUP_PLAY, MF_BYCOMMAND|
                                   (selected > 1) ? MF_GRAYED : MF_ENABLED );

                    state = ListView_GetItemState(m_hPlaylistView,
                                                  count - 1, 
                                                  LVIS_SELECTED);

                    EnableMenuItem(subMenu, ID_POPUP_MOVEDOWN, MF_BYCOMMAND|
                                   (state & LVIS_SELECTED) ? MF_GRAYED : MF_ENABLED );

                    state = ListView_GetItemState(m_hPlaylistView, 
                                                  0, 
                                                  LVIS_SELECTED);

                    EnableMenuItem(subMenu, ID_POPUP_MOVEUP, MF_BYCOMMAND|
                                   (state & LVIS_SELECTED) ? MF_GRAYED : MF_ENABLED );

                    uint32 index = 0;
                    uint32 found = 0;


                    for(index = 0; index < count, found < selected; index++)
                    {
                        uint32 state = ListView_GetItemState(m_hPlaylistView, 
                                                             index, 
                                                             LVIS_SELECTED);
                        if(state & LVIS_SELECTED)
                        {
                            found++;

                            PlaylistItem* item = m_plm->ItemAt(index);

                            if(!item->URL().compare(0, 4, "http"))
                            {
                                MENUITEMINFO mii;

                                mii.cbSize = sizeof(MENUITEMINFO);
                                mii.fMask = MIIM_ID | MIIM_TYPE;
                                mii.wID = ID_POPUP_FAVORITE;
                                mii.fType = MFT_STRING;
                                mii.dwTypeData = "Add to Favorites";
                                mii.cch = strlen(mii.dwTypeData);

                                InsertMenuItem(subMenu, ID_POPUP_EDITINFO, FALSE, &mii);
                                
                                break;
                            }
                        }
                    }
                }
                else
                {
                    EnableMenuItem(subMenu, ID_POPUP_PLAY, MF_BYCOMMAND|MF_GRAYED);
                    EnableMenuItem(subMenu, ID_POPUP_MOVEUP, MF_BYCOMMAND|MF_GRAYED);
                    EnableMenuItem(subMenu, ID_POPUP_MOVEDOWN, MF_BYCOMMAND|MF_GRAYED);
                    EnableMenuItem(subMenu, ID_POPUP_REMOVE, MF_BYCOMMAND|MF_GRAYED);
                    EnableMenuItem(subMenu, ID_POPUP_EDITINFO, MF_BYCOMMAND|MF_GRAYED);
                }

                TrackPopupMenu(subMenu, 
                               TPM_LEFTALIGN, sPoint.x, sPoint.y, 
                               0, m_hWnd, NULL);

                DestroyMenu(menu);
                break;
            }

            case LVN_ITEMCHANGED:
            {
                // update only when focus is set
                //if(pListView->uNewState&LVIS_FOCUSED)
                    UpdateButtonStates();
                break;
            }

            case NM_DBLCLK:
            {
                // only do this for the root browser
                if(!m_pParent)
                {
                    m_playerEQ->AcceptEvent(new Event(CMD_Stop));
                    m_plm->SetCurrentIndex(pListView->iItem);
                    m_playerEQ->AcceptEvent(new Event(CMD_Play));
                }
                break;
            }

            case LVN_COLUMNCLICK:
            {
                int column = pListView->iSubItem;
                const char *columnText = GetColumnText(column);

                if (stricmp(columnText, ARTIST_COLUMN) == 0)
                {
                    SendMessage(m_hWnd, WM_COMMAND, ID_SORT_ARTIST, 0);
                }
                else if (stricmp(columnText, TITLE_COLUMN) == 0)
                {
                    SendMessage(m_hWnd, WM_COMMAND, ID_SORT_TITLE, 0);
                }
                else if (stricmp(columnText, ALBUM_COLUMN) == 0)
                {
                    SendMessage(m_hWnd, WM_COMMAND, ID_SORT_ALBUM, 0);
                }
                else if (stricmp(columnText, TIME_COLUMN) == 0)
                {
                    SendMessage(m_hWnd, WM_COMMAND, ID_SORT_LENGTH, 0);
                }
                else if (stricmp(columnText, GENRE_COLUMN) == 0)
                {
                    SendMessage(m_hWnd, WM_COMMAND, ID_SORT_GENRE, 0);
                }
                else if (stricmp(columnText, COMMENT_COLUMN) == 0)
                {
                    SendMessage(m_hWnd, WM_COMMAND, ID_SORT_COMMENT, 0);
                }
                else if (stricmp(columnText, YEAR_COLUMN) == 0)
                {
                    SendMessage(m_hWnd, WM_COMMAND, ID_SORT_YEAR, 0);
                }
                else if (stricmp(columnText, LOCATION_COLUMN) == 0)
                {
                    SendMessage(m_hWnd, WM_COMMAND, ID_SORT_LOCATION, 0);
                }
                break;
            }

            case LVN_KEYDOWN:
            {
                LV_KEYDOWN* pnkd = (LV_KEYDOWN*)pHdr; 

                if(pnkd->wVKey == VK_DELETE)
                {
                    RemoveEvent();  
                }
                else if(pnkd->wVKey == 'A' && (GetKeyState(VK_CONTROL) < 0))
                {
                    uint32 count = ListView_GetItemCount(pListView->hdr.hwndFrom);
                
                    for(uint32 index = 0; index < count; index++)
                        ListView_SetItemState(pListView->hdr.hwndFrom,
                                              index,
                                              LVIS_SELECTED,
                                              LVIS_SELECTED);
                }

                break;
            }
        }
    }
    
    if(pHdr->code == TTN_NEEDTEXT)
    {
        pToolTipText = (LPTOOLTIPTEXT)pHdr;

        switch(pToolTipText->hdr.idFrom)
        {
            case ID_FILE_NEWPLAYLIST:
                pToolTipText->lpszText = "Create a new playlist";
                result = TRUE;
                break;
            case ID_FILE_SAVEPLAYLIST:
                pToolTipText->lpszText = "Save current playlist";
                result = TRUE;
                break;
            case ID_FILE_IMPORT:
                pToolTipText->lpszText = "Import tracks and playlists from disk";
                result = TRUE;
                break;
            case ID_EDIT_REMOVE:
                pToolTipText->lpszText = "Remove selected tracks and playlists";
                result = TRUE;
                break;
            case ID_EDIT_EDITINFO:
                pToolTipText->lpszText = "Edit track or playlist info";
                result = TRUE;
                break;
            case ID_EDIT_ADDTRACK:
                pToolTipText->lpszText = "Add selected tracks and playlists to playlist";
                result = TRUE;
                break;
            case ID_EDIT_ADDFILE:
                pToolTipText->lpszText = "Add files from disk to playlist";
                result = TRUE;
                break;
            case ID_EDIT_MOVEUP:
                pToolTipText->lpszText = "Move selected playlist items up";
                result = TRUE;
                break;
            case ID_EDIT_MOVEDOWN:
                pToolTipText->lpszText = "Move selected playlist items down";
                result = TRUE;
                break;
        }      
    }
 
	return result;
}


void MusicBrowserUI::SortEvent(int id)
{
    PlaylistSortKey oldKey, newKey;
    PlaylistSortType type;
    
    if(!m_plm->CountItems())
        return;

    switch(id)
    {
        case ID_SORT_ARTIST:
            newKey = kPlaylistSortKey_Artist;
            break;     
        case ID_SORT_ALBUM:
            newKey = kPlaylistSortKey_Album;
            break;     
        case ID_SORT_TITLE:
            newKey = kPlaylistSortKey_Title;
            break;     
        case ID_SORT_LENGTH:
            newKey = kPlaylistSortKey_Time;
            break;     
        case ID_SORT_YEAR:
            newKey = kPlaylistSortKey_Year;
            break;     
        case ID_SORT_TRACK:
            newKey = kPlaylistSortKey_Track;
            break;     
        case ID_SORT_GENRE:
            newKey = kPlaylistSortKey_Genre;
            break;    
        case ID_SORT_COMMENT:
            newKey = kPlaylistSortKey_Comment;
            break; 
        case ID_SORT_LOCATION:
            newKey = kPlaylistSortKey_Location;
            break;
        case ID_SORT_FILENAME:
            newKey = kPlaylistSortKey_FileName;
            break;  
        case IDC_RANDOMIZE:
        case ID_SORT_RANDOMIZE:
            newKey = kPlaylistSortKey_Random;
            break;     
        default:
             return;
    }

    oldKey = m_plm->GetPlaylistSortKey();

    type = (oldKey == newKey && 
            m_plm->GetPlaylistSortType() == kPlaylistSortType_Ascending)
            ? kPlaylistSortType_Descending : kPlaylistSortType_Ascending;

    ::SetCursor(LoadCursor(NULL, IDC_WAIT));
    m_plm->Sort(newKey, type);
    ::SetCursor(LoadCursor(NULL, IDC_ARROW));
}

void MusicBrowserUI::ToggleVisEvent(void)
{
    Event *e;

    if (m_state == STATE_COLLAPSED)
        e = new Event(CMD_TogglePlaylistUI);
    else
        e = new Event(CMD_ToggleMusicBrowserUI);

    AcceptEvent(e);
    
    delete e;
}

void MusicBrowserUI::PlayNowEvent(void)
{
    if(!m_pParent)
    {
        uint32 count = ListView_GetItemCount(m_hPlaylistView);
        uint32 index = 0;

        for(index = 0; index < count; index++)
        {
            uint32 state = ListView_GetItemState(m_hPlaylistView, 
                                                 index, 
                                                 LVIS_SELECTED);
            if(state & LVIS_SELECTED)
            {
                // only do this for the root browser
                m_playerEQ->AcceptEvent(new Event(CMD_Stop));
                m_plm->SetCurrentIndex(index);
                m_playerEQ->AcceptEvent(new Event(CMD_Play));
                break;
            }
        }
    }
}

void MusicBrowserUI::VisitWebEvent(void)
{
    vector<PlaylistItem*> items;

    GetSelectedStreamItems(&items);
	if (items.size() <= 0 || items[0]->WebURL().size() == 0)
		return;

	ShellExecute(m_hParent, "open", items[0]->WebURL().c_str(), 
		         NULL, NULL, SW_SHOWNORMAL);
}

void MusicBrowserUI::AddTrackEvent(void)
{
    vector<PlaylistItem*> items;
    vector<string> urls;

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

    // we know that we are gonna be adding a 
    // bunch of items so let windows know.
    // it will make the adds more efficient
    uint32 newSize = ListView_GetItemCount(m_hPlaylistView);
    newSize += urls.size();
    ListView_SetItemCount(m_hPlaylistView, newSize);

    m_plm->AddItems(urls);
    
}

void MusicBrowserUI::AddTrackAndPlayEvent(void)
{
    uint32 count = m_plm->CountItems();

    AddTrackEvent();

    if(m_plm->CountItems())
    {
		m_context->target->AcceptEvent(new Event(CMD_Stop));
        m_plm->SetCurrentIndex(count);
        m_context->target->AcceptEvent(new Event(CMD_Play));
    }
}

void MusicBrowserUI::AddFileEvent(HWND hwndParent, bool playNow)
{
    PlaylistFormatInfo format;
    int32 i, iOffset = 0;

    char szFilter[10