dialog.cpp

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

           trackCount)
        {
            EnableMenuItem(hMenu, ID_EDIT_EDITINFO, MF_ENABLED);
            SendMessage(m_hToolbar, TB_ENABLEBUTTON, 
                    ID_EDIT_EDITINFO, MAKELPARAM(TRUE, 0));
        }

        /*if(!IsItemSelected(m_hNewPlaylistItem) && !IsItemSelected(m_hAllItem) &&
           !IsItemSelected(m_hMyMusicItem) && !IsItemSelected(m_hUncatItem) &&
           !IsItemSelected(m_hPlaylistItem) && !IsItemSelected(m_hPortableItem) &&
           (playlistCount && !trackCount) &&
           !IsItemSelected(m_hMyMusicItem) &&
           !IsItemSelected(m_hUncatItem) &&
           !IsItemSelected(m_hAllItem))
        {
            EnableMenuItem(hMenu, ID_EDIT_EDITINFO, MF_ENABLED);
            SendMessage(m_hToolbar, TB_ENABLEBUTTON, 
                    ID_EDIT_EDITINFO, MAKELPARAM(TRUE, 0)); 
        }*/       

        sMenuItem.cbSize = sizeof(MENUITEMINFO);
        sMenuItem.fMask =  MIIM_DATA|MIIM_TYPE;
        sMenuItem.fType = MFT_STRING;
        sMenuItem.dwTypeData = "&Remove Items from Catalog...";
        sMenuItem.cch = strlen(sMenuItem.dwTypeData);

        SetMenuItemInfo(hMenu, ID_EDIT_REMOVE, false, &sMenuItem);

        TV_ITEM tv_item;
        bool enableEditPlaylist = false;

        if(m_hNewPlaylistItem)
        {
            // get the first playlist item
            tv_item.hItem = TreeView_GetChild(m_hMusicView, m_hPlaylistItem);
            tv_item.mask = TVIF_STATE|TVIF_PARAM;
            tv_item.stateMask = TVIS_SELECTED;
            tv_item.state = 0;

            // skip the "Create New Playlist..." item
            if(tv_item.hItem)
                tv_item.hItem = TreeView_GetNextSibling(m_hMusicView, tv_item.hItem);

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

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

                    if(result && (tv_item.state & TVIS_SELECTED))
                    {
                        enableEditPlaylist = true;               
                        break;
                    }
            
                }while(result &&
                       (tv_item.hItem = TreeView_GetNextSibling(m_hMusicView, 
                                                                tv_item.hItem)));
            }
        }

        EnableMenuItem(hMenu, ID_EDIT_EDITPLAYLIST, 
                        enableEditPlaylist ? MF_ENABLED : MF_GRAYED);

        EnableMenuItem(GetSubMenu(hMenuRoot, 0), ID_FILE_EXPORTPLAYLIST, 
                       enableEditPlaylist ? MF_ENABLED : MF_GRAYED);
    }
    else
    {
        EnableMenuItem(hMenu, ID_EDIT_EDITPLAYLIST, MF_GRAYED);
    }

    sMenuItem.cbSize = sizeof(MENUITEMINFO);
    sMenuItem.fMask =  MIIM_DATA;
    sMenuItem.fType = MFT_STRING;
    //sMenuItem.fState = (oType.length() == 0) ? MFS_GRAYED : MFS_ENABLED;

    //oText = string("&Edit") + oType + string("...");
    //sMenuItem.dwTypeData = (char *)oText.c_str();
    //sMenuItem.cch = strlen(sMenuItem.dwTypeData);
    //SetMenuItemInfo(hMenu, ID_EDIT_EDIT, false, &sMenuItem);

    //oText = string("&Remove") + oType + string(" from Catalog...");
    //sMenuItem.dwTypeData = (char *)oText.c_str();
    //sMenuItem.cch = strlen(sMenuItem.dwTypeData);
    //SetMenuItemInfo(hMenu, ID_EDIT_REMOVE, false, &sMenuItem);
    
    //oText = string("Remove") + oType + string(" from &Disk...");
    //sMenuItem.dwTypeData = (char *)oText.c_str();
    //sMenuItem.cch = strlen(sMenuItem.dwTypeData);
    //SetMenuItemInfo(hMenu, ID_EDIT_REMOVEFROMDISK, false, &sMenuItem);
    
    //SendMessage(m_hToolbar, TB_ENABLEBUTTON, ID_EDIT_EDIT, 
    //            MAKELONG(oType.length() != 0, 0));    
    //SendMessage(m_hToolbar, TB_ENABLEBUTTON, ID_EDIT_REMOVE, 
    ///            MAKELONG(oType.length() != 0, 0)); 
    
    hMenu = GetSubMenu(hMenuRoot, 3);


    sMenuItem.fMask = MIIM_STATE;

	switch(m_oPlm->GetRepeatMode()) 
    {
		case kPlaylistMode_RepeatNone:
            sMenuItem.fState = MFS_CHECKED;
            SetMenuItemInfo(hMenu, ID_CONTROLS_REPEATNONE, false, &sMenuItem);
            sMenuItem.fState = MFS_UNCHECKED;
            SetMenuItemInfo(hMenu, ID_CONTROLS_REPEATONE, false, &sMenuItem);
            sMenuItem.fState = MFS_UNCHECKED;
            SetMenuItemInfo(hMenu, ID_CONTROLS_REPEATALL, false, &sMenuItem);
			break;

		case kPlaylistMode_RepeatOne:
            sMenuItem.fState = MFS_UNCHECKED;
            SetMenuItemInfo(hMenu, ID_CONTROLS_REPEATNONE, false, &sMenuItem);
            sMenuItem.fState = MFS_CHECKED;
            SetMenuItemInfo(hMenu, ID_CONTROLS_REPEATONE, false, &sMenuItem);
            sMenuItem.fState = MFS_UNCHECKED;
            SetMenuItemInfo(hMenu, ID_CONTROLS_REPEATALL, false, &sMenuItem);
			break;

		case kPlaylistMode_RepeatAll:
            sMenuItem.fState = MFS_UNCHECKED;
            SetMenuItemInfo(hMenu, ID_CONTROLS_REPEATNONE, false, &sMenuItem);
            sMenuItem.fState = MFS_UNCHECKED;
            SetMenuItemInfo(hMenu, ID_CONTROLS_REPEATONE, false, &sMenuItem);
            sMenuItem.fState = MFS_CHECKED;
            SetMenuItemInfo(hMenu, ID_CONTROLS_REPEATALL, false, &sMenuItem);
            break;
	}
    
    sMenuItem.fState = m_oPlm->GetShuffleMode() ? MFS_CHECKED:MFS_UNCHECKED;
    SetMenuItemInfo(hMenu, ID_CONTROLS_SHUFFLE, false, &sMenuItem);
 
    sMenuItem.fState = m_oPlm->GetShuffleMode() ? MFS_UNCHECKED: MFS_CHECKED;
    SetMenuItemInfo(hMenu, ID_CONTROLS_NORMALORDER, false, &sMenuItem);

}

void MusicBrowserUI::ShowHelp(uint32 topic)
{
    string            oHelpFile;
    char              dir[MAX_PATH];
    uint32            len = sizeof(dir);

    m_context->prefs->GetInstallDirectory(dir, &len);
    oHelpFile = string(dir);
    oHelpFile += string("\\"HELP_FILE);    

    WinHelp(m_hWnd, oHelpFile.c_str(), HELP_CONTEXT, topic);
}        


static
UINT 
APIENTRY 
OpenFileHookProc(   HWND hwnd, 
                    UINT msg, 
                    WPARAM wParam, 
                    LPARAM lParam)
{
    UINT result = 0;
    static OPENFILENAME* ofn = NULL;

    switch(msg)
    {
        case WM_INITDIALOG:
        {
            ofn = (OPENFILENAME*)lParam;

            HWND hwndURL = GetDlgItem(hwnd, IDC_URL);
            
            vector<PlaylistItem*>* url_list = (vector<PlaylistItem*>*)ofn->lCustData; 
            vector<PlaylistItem*>::iterator i = url_list->begin();

            for(i; i != url_list->end(); i++)
            {
                ComboBox_AddString(hwndURL, (*i)->URL().c_str());               
            }

            ofn->lCustData = 0;
            break;
        }

        case WM_COMMAND:
        {
            switch(wParam)
            {
                case IDC_OPEN_URL:
                {
                    char* url = new char[ofn->nMaxFile + 1];

                    if(GetDlgItemText(  hwnd,
                                        IDC_URL,
                                        url,
                                        ofn->nMaxFile))
                    {
                        *ofn->lpstrFile = 0x00;

                        if(!strstr(url, "://"))
                        {
                            strcpy(ofn->lpstrFile, "http://");
                        }

                        strcat(ofn->lpstrFile, url);

                        PostMessage(GetParent(hwnd), 
                                    WM_COMMAND, 
                                    IDCANCEL,
                                    0);

                        ofn->lCustData = 1;
                    }

                    delete url;
                    
                    result = 1;
                    break;
                }
            }

            break;
        }

        case WM_NOTIFY:
        {
            OFNOTIFY* notify = (OFNOTIFY*)lParam;

            switch(notify->hdr.code)
            {
                case CDN_FILEOK:
                {
                    
                    break;
                }                
            }

            break;
        }
    }

    return result;
}

bool
MusicBrowserUI::
FileOpenDialog(HWND hwnd, 
               const char* title,
               const char* filter,
               vector<string>* fileList,
               bool allowURL)
{
    bool result = false;
    OPENFILENAME ofn;
    char initialDir[MAX_PATH] = {0x00};
    uint32 initialDirSize = sizeof(initialDir);
    char installDir[MAX_PATH] = {0x00};
    uint32 installDirSize = sizeof(installDir);
    char urlPath[MAX_PATH + 7];
    uint32 urlPathSize = sizeof(urlPath);
    const int32 kBufferSize = MAX_PATH * 128;
    char* fileBuffer = new char[kBufferSize];
    vector<PlaylistItem*> url_list;

    *fileBuffer = 0x00;

    m_context->prefs->GetInstallDirectory( installDir, &initialDirSize);

    if(*installDir)
    {
        strcat(installDir, "\\urls.m3u");

        if(IsntError(FilePathToURL(installDir, urlPath, &urlPathSize)))
        {
            m_oPlm->ReadPlaylist(urlPath, &url_list);
        }
    }

    m_context->prefs->GetOpenSaveDirectory( initialDir, &initialDirSize);

    int hookFlags = 0;

    if(allowURL)
        hookFlags = OFN_ENABLEHOOK | OFN_ENABLETEMPLATE;

    // Setup open file dialog box structure
    ofn.lStructSize       = sizeof(OPENFILENAME);
    ofn.hwndOwner         = hwnd;
    ofn.hInstance         = g_hinst;
    ofn.lpstrFilter       = filter;
    ofn.lpstrCustomFilter = NULL;
    ofn.nMaxCustFilter    = 0;
    ofn.nFilterIndex      = 1;
    ofn.lpstrFile         = fileBuffer;
    ofn.nMaxFile          = kBufferSize;
    ofn.lpstrFileTitle    = NULL;
    ofn.nMaxFileTitle     = 0;
    ofn.lpstrInitialDir   = initialDir;
    ofn.lpstrTitle        = title;
    ofn.Flags             = OFN_FILEMUSTEXIST | 
					        OFN_PATHMUSTEXIST |
  	     			        OFN_HIDEREADONLY | 
					        OFN_ALLOWMULTISELECT |
					        OFN_EXPLORER | 
                            hookFlags;
    ofn.nFileOffset       = 0;
    ofn.nFileExtension    = 0;
    ofn.lpstrDefExt       = "MP3";
    ofn.lCustData         = (DWORD)&url_list;
    ofn.lpfnHook          = OpenFileHookProc;
    ofn.lpTemplateName    = (allowURL ? MAKEINTRESOURCE(IDD_OPENURL) : NULL);

    if(GetOpenFileName(&ofn) || ofn.lCustData)
    {
        char file[MAX_PATH];
        char* cp = NULL;

        if(ofn.lCustData) // URL
        {
            fileList->push_back(fileBuffer);

            if(*urlPath)
            {
                bool found = false;
                vector<PlaylistItem*>::iterator i = url_list.begin();

                for(i; i != url_list.end(); i++)
                {
                    if((*i)->URL() == fileBuffer)
                    {
                        PlaylistItem* item = *i;
                        url_list.erase(i);
                        url_list.insert(url_list.begin(), item);

                        found = true;
                        break;
                    }
                }

                if(!found)
                {
                    PlaylistItem* item = new PlaylistItem(fileBuffer);
                    url_list.insert(url_list.begin(), item);
                    int32 numToRemember = 10;

                    m_context->prefs->GetNumberOfURLsToRemember(&numToRemember);

                    if(url_list.size() > numToRemember)
                    {
                        i = url_list.begin() + numToRemember;

                        for(i; i != url_list.end(); i++)
                        {
                            delete *i;
                        }

                        url_list.erase(url_list.begin() + numToRemember, url_list.end());
                    }                    
                }

                m_oPlm->WritePlaylist(urlPath, &url_list);
            }
        }
        else // potential list of files
        {
            strncpy(file, fileBuffer, ofn.nFileOffset);

            if(*(fileBuffer + ofn.nFileOffset - 1) != DIR_MARKER)
                strcat(file, DIR_MARKER_STR);

            cp = fileBuffer + ofn.nFileOffset;

            while(*cp)
            {
                char url[MAX_PATH + 7];
                uint32 length = sizeof(url);

	            strcpy(file + ofn.nFileOffset, cp);

                FilePathToURL(file, url, &length);

                fileList->push_back(url);

	            cp += strlen(cp) + 1;
            }

            *(fileBuffer + ofn.nFileOffset - 1) = 0x00;

            m_context->prefs->SetOpenSaveDirectory(fileBuffer);
        }

        result = true;
    }

    /*if(CommDlgExtendedError() == CDERR_NOHINSTANCE)
    {   
        MessageBox(hwnd, "CDERR_NOHINSTANCE", 0, M