bool getOpenDirectory(char* out, int max_size, const char* starting_dir) { bool ret = false; IFileDialog* pfd; if (SUCCEEDED(CoCreateInstance(CLSID_FileOpenDialog, NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARGS(&pfd)))) { if (starting_dir) { PIDLIST_ABSOLUTE pidl; WCHAR wstarting_dir[MAX_PATH]; WCHAR* wc = wstarting_dir; for (const char *c = starting_dir; *c && wc - wstarting_dir < MAX_PATH - 1; ++c, ++wc) { *wc = *c == '/' ? '\\' : *c; } *wc = 0; HRESULT hresult = ::SHParseDisplayName(wstarting_dir, 0, &pidl, SFGAO_FOLDER, 0); if (SUCCEEDED(hresult)) { IShellItem* psi; hresult = ::SHCreateShellItem(NULL, NULL, pidl, &psi); if (SUCCEEDED(hresult)) { pfd->SetFolder(psi); } ILFree(pidl); } } DWORD dwOptions; if (SUCCEEDED(pfd->GetOptions(&dwOptions))) { pfd->SetOptions(dwOptions | FOS_PICKFOLDERS); } if (SUCCEEDED(pfd->Show(NULL))) { IShellItem* psi; if (SUCCEEDED(pfd->GetResult(&psi))) { WCHAR* tmp; if (SUCCEEDED(psi->GetDisplayName(SIGDN_DESKTOPABSOLUTEPARSING, &tmp))) { char* c = out; while (*tmp && c - out < max_size - 1) { *c = (char)*tmp; ++c; ++tmp; } *c = '\0'; ret = true; } psi->Release(); } } pfd->Release(); } return ret; }
bool ShowOpenDirectoryDialog(Path& path) { bool pathSelected = false; // check current OS version OSVERSIONINFO osvi; memset(&osvi, 0, sizeof(OSVERSIONINFO)); osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO); IFileDialog *pfd; if (SUCCEEDED(CoCreateInstance(CLSID_FileOpenDialog, NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARGS(&pfd)))) { // configure the dialog to Select Folders only DWORD dwOptions; if (SUCCEEDED(pfd->GetOptions(&dwOptions))) { pfd->SetOptions(dwOptions | FOS_PICKFOLDERS | FOS_DONTADDTORECENT); if (SUCCEEDED(pfd->Show(GetActiveWindow()))) { IShellItem *psi; if (SUCCEEDED(pfd->GetResult(&psi))) { LPWSTR lpwszName = NULL; if (SUCCEEDED(psi->GetDisplayName(SIGDN_DESKTOPABSOLUTEPARSING, (LPWSTR*) &lpwszName))) { // Add directory path to the result //ConvertToUnixPath(pathName); path = Path(lpwszName); pathSelected = true; ::CoTaskMemFree(lpwszName); } psi->Release(); } } } pfd->Release(); } return pathSelected; }
static void openFile(HWND hWnd) { HRESULT hr; IFileDialog *pFileDialog = nullptr; IShellItem *pShellItem = nullptr; PWSTR pFilePath = nullptr; DWORD dwFlags; /* Create FileOpenDialog */ hr = CoCreateInstance(CLSID_FileOpenDialog, nullptr, CLSCTX_INPROC_SERVER, IID_PPV_ARGS(&pFileDialog)); if (FAILED(hr)) goto FINISH; /* Get options */ hr = pFileDialog->GetOptions(&dwFlags); if (FAILED(hr)) goto FINISH; /* Get shell items only for file system items */ hr = pFileDialog->SetOptions(dwFlags | FOS_FORCEFILESYSTEM); if (FAILED(hr)) goto FINISH; /* Set file types */ COMDLG_FILTERSPEC fileTypes[] = { { L"All supported images", L"*.png;*.jpg;*.jpeg;*.psd" }, }; hr = pFileDialog->SetFileTypes(ARRAYSIZE(fileTypes), fileTypes); if (FAILED(hr)) goto FINISH; /* Show dialog */ hr = pFileDialog->Show(hWnd); if (FAILED(hr)) goto FINISH; hr = pFileDialog->GetResult(&pShellItem); if (FAILED(hr)) goto FINISH; hr = pShellItem->GetDisplayName(SIGDN_FILESYSPATH, &pFilePath); if (FAILED(hr)) goto FINISH; loadImage(hWnd, pFilePath); FINISH: if (pFilePath) CoTaskMemFree(pFilePath); if (pShellItem) pShellItem->Release(); if (pFileDialog) pFileDialog->Release(); }
void OnFileOpen(HWND hwnd) { HRESULT hr = S_OK; IFileDialog *pDialog = NULL; IShellItem *pItem = NULL; LPWSTR pwszFilePath = NULL; // Create the FileOpenDialog object. hr = CoCreateInstance( __uuidof(FileOpenDialog), NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARGS(&pDialog) ); if (FAILED(hr)) { goto done; } hr = pDialog->SetTitle(L"Select a File to Play"); if (FAILED(hr)) { goto done; } // Show the file-open dialog. hr = pDialog->Show(hwnd); if (hr == HRESULT_FROM_WIN32(ERROR_CANCELLED)) { // User cancelled. hr = S_OK; goto done; } if (FAILED(hr)) { goto done; } hr = pDialog->GetResult(&pItem); if (FAILED(hr)) { goto done; } hr = pItem->GetDisplayName(SIGDN_FILESYSPATH, &pwszFilePath); if (FAILED(hr)) { goto done; } // Open the file and create bitmaps. hr = OpenVideoFile(hwnd, pwszFilePath); done: if (FAILED(hr)) { ShowErrorMessage(L"Cannot open file.", hr); } CoTaskMemFree(pwszFilePath); SafeRelease(&pItem); SafeRelease(&pDialog); }
void DeletePerUserDialogState() { IFileDialog *pfd; HRESULT hr = CoCreateInstance(CLSID_FileOpenDialog, NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARGS(&pfd)); if (SUCCEEDED(hr)) { // Delete window size, MRU and other saved data for testing initial case pfd->ClearClientData(); pfd->Release(); } }
IFACEMETHODIMP OnButtonClicked(IFileDialogCustomize *fdc, DWORD idCtl) { DBGW(L"OnButtonClicked\n"); if (idCtl == ID_SELECT) { IFileDialog *fd = NULL; if (SUCCEEDED(fdc->QueryInterface(&fd))) { if (GetSelectedItems(fd, res) && res->size()) { fd->Close(S_OK); fd->Release(); } } } return S_OK; }
IFACEMETHODIMP OnButtonClicked(IFileDialogCustomize *pfdc, DWORD dwIDCtl) { switch (dwIDCtl) { case c_idDone: IFileDialog *pfd; if (SUCCEEDED(pfdc->QueryInterface(&pfd))) { pfd->Close(S_OK); pfd->Release(); } break; default: break; } return S_OK; }
bool Gwen::Platform::FolderOpen( const String& Name, const String& StartPath, Gwen::Event::Handler* pHandler, Event::Handler::FunctionWithInformation fnCallback ) { IFileDialog *pfd = NULL; bool bSuccess = false; if ( CoCreateInstance( CLSID_FileOpenDialog, NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARGS( &pfd ) ) != S_OK ) return bSuccess; DWORD dwOptions; if ( pfd->GetOptions(&dwOptions) != S_OK ) { pfd->Release(); return bSuccess; } pfd->SetOptions( dwOptions | FOS_PICKFOLDERS ); // // TODO: SetDefaultFolder -> StartPath // if ( pfd->Show(NULL) == S_OK ) { IShellItem *psi; if ( pfd->GetResult(&psi) == S_OK ) { WCHAR* strOut = NULL; if ( psi->GetDisplayName(SIGDN_DESKTOPABSOLUTEPARSING, &strOut ) != S_OK ) { return bSuccess; } // // GWEN callback - call it. // if ( pHandler && fnCallback ) { Gwen::Event::Information info; info.Control = NULL; info.ControlCaller = NULL; info.String = Gwen::Utility::UnicodeToString( strOut ); (pHandler->*fnCallback)( info ); } CoTaskMemFree( strOut ); psi->Release(); bSuccess = true; } } pfd->Release(); return bSuccess; }
void PickContainer() { IFileDialog *pfd; if (SUCCEEDED(CoCreateInstance(CLSID_FileOpenDialog, NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARGS(&pfd)))) { DWORD dwOptions; if (SUCCEEDED(pfd->GetOptions(&dwOptions))) { pfd->SetOptions(dwOptions | FOS_PICKFOLDERS); } if (SUCCEEDED(pfd->Show(NULL))) { IShellItem *psi; if (SUCCEEDED(pfd->GetResult(&psi))) { PWSTR pszPath; if (SUCCEEDED(GetIDListName(psi, &pszPath))) { MessageBox(NULL, pszPath, L"Selected Container", MB_OK); CoTaskMemFree(pszPath); } psi->Release(); } } pfd->Release(); } }
// This opens up the common file dialog to an IShellItem and waits for the user to select a file from the results. // It then displays the name of the selected item in a message box. HRESULT OpenCommonFileDialogTo(IShellItem *pShellItemSearch) { // Create an instance of IFileOpenDialog IFileDialog* pFileDialog; HRESULT hr = CoCreateInstance(CLSID_FileOpenDialog, NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARGS(&pFileDialog)); if (SUCCEEDED(hr)) { // Set it to the folder we want to show hr = pFileDialog->SetFolder(pShellItemSearch); if (SUCCEEDED(hr)) { // Show the File Dialog hr = pFileDialog->Show(NULL); if (SUCCEEDED(hr)) { // Now get the file that the user selected IShellItem *pShellItemSelected; hr = pFileDialog->GetResult(&pShellItemSelected); if (SUCCEEDED(hr)) { // Get the name from that file PWSTR pszName; hr = pShellItemSelected->GetDisplayName(SIGDN_NORMALDISPLAY, &pszName); if (SUCCEEDED(hr)) { // Display it back to the user WCHAR szMsg[128]; StringCchPrintf(szMsg, ARRAYSIZE(szMsg), L"You Chose '%s'\r", pszName); MessageBox(NULL, szMsg, L"Search Folder Sample", MB_OK); CoTaskMemFree(pszName); } pShellItemSelected->Release(); } } } pFileDialog->Release(); } return hr; }
char *commonItemDialog(HWND parent, REFCLSID clsid, REFIID iid, FILEOPENDIALOGOPTIONS optsadd) { IFileDialog *d = NULL; FILEOPENDIALOGOPTIONS opts; IShellItem *result = NULL; WCHAR *wname = NULL; char *name = NULL; HRESULT hr; hr = CoCreateInstance(clsid, NULL, CLSCTX_INPROC_SERVER, iid, (LPVOID *) (&d)); if (hr != S_OK) { logHRESULT(L"error creating common item dialog", hr); // always return NULL on error goto out; } hr = d->GetOptions(&opts); if (hr != S_OK) { logHRESULT(L"error getting current options", hr); goto out; } opts |= optsadd; // the other platforms don't check read-only; we won't either opts &= ~FOS_NOREADONLYRETURN; hr = d->SetOptions(opts); if (hr != S_OK) { logHRESULT(L"error setting options", hr); goto out; } hr = d->Show(parent); if (hr == HRESULT_FROM_WIN32(ERROR_CANCELLED)) // cancelled; return NULL like we have ready goto out; if (hr != S_OK) { logHRESULT(L"error showing dialog", hr); goto out; } hr = d->GetResult(&result); if (hr != S_OK) { logHRESULT(L"error getting dialog result", hr); goto out; } hr = result->GetDisplayName(SIGDN_FILESYSPATH, &wname); if (hr != S_OK) { logHRESULT(L"error getting filename", hr); goto out; } name = toUTF8(wname); out: if (wname != NULL) CoTaskMemFree(wname); if (result != NULL) result->Release(); if (d != NULL) d->Release(); return name; }
void PickItem() { IFileDialog *pfd; if (SUCCEEDED(CoCreateInstance(CLSID_FileOpenDialog, NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARGS(&pfd)))) { if (SUCCEEDED(pfd->Show(NULL))) { IShellItem *psi; if (SUCCEEDED(pfd->GetResult(&psi))) { PWSTR pszPath; if (SUCCEEDED(GetIDListName(psi, &pszPath))) { MessageBox(NULL, pszPath, L"Selected Item", MB_OK); CoTaskMemFree(pszPath); } psi->Release(); } } pfd->Release(); } }
void OnCommand(HWND hwnd, int id, HWND hwndCtl, UINT codeNotify) { switch (id) { case ID_FILE_OPEN: { IFileDialog *pFileDialog = NULL; HRESULT hr = CoCreateInstance(CLSID_FileOpenDialog, NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARGS(&pFileDialog)); if (SUCCEEDED(hr)) { COMDLG_FILTERSPEC filter[3]; filter[0].pszName = L"位图文件(*.bmp)"; filter[0].pszSpec = L"*.bmp"; filter[1].pszName = L"JPEG(*.jpg;*.jpeg)"; filter[1].pszSpec = L"*.jpg;*.jpeg"; filter[2].pszName = L"所有支持的文件(*.jpg;*.jpeg;*.bmp;*.png)"; filter[2].pszSpec = L"*.jpg;*.jpeg;*.bmp;*.png"; hr = pFileDialog->SetFileTypes(3, filter); hr = pFileDialog->SetFileTypeIndex(3); hr = pFileDialog->Show(hwnd); if (SUCCEEDED(hr)) { IShellItem *psi = NULL; hr = pFileDialog->GetResult(&psi); if (SUCCEEDED(hr)) { PWSTR pwszFilePath = NULL; hr = psi->GetDisplayName(SIGDN_FILESYSPATH, &pwszFilePath); if (SUCCEEDED(hr)) { wchar_t * pext = wcsrchr(pwszFilePath, L'.'); if(pext != NULL && _wcsicmp(pext, L".bmp") == 0) SendMessage(hwnd, WM_USER_IMG, 0, (LPARAM)pwszFilePath); else SendMessage(hwnd, WM_USER_IMG, 1, (LPARAM)pwszFilePath); CoTaskMemFree(pwszFilePath); } psi->Release(); } } } pFileDialog->Release(); break; } case ID_FILE_EXIT: PostQuitMessage(0); break; default: FORWARD_WM_COMMAND(hwnd, id, hwndCtl, codeNotify, DefWindowProc); } }
bool getOpenDirectory(char* out, int max_size) { bool ret = false; IFileDialog *pfd; if (SUCCEEDED(CoCreateInstance( CLSID_FileOpenDialog, NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARGS(&pfd)))) { DWORD dwOptions; if (SUCCEEDED(pfd->GetOptions(&dwOptions))) { pfd->SetOptions(dwOptions | FOS_PICKFOLDERS); } if (SUCCEEDED(pfd->Show(NULL))) { IShellItem* psi; if (SUCCEEDED(pfd->GetResult(&psi))) { WCHAR* tmp; if (SUCCEEDED(psi->GetDisplayName(SIGDN_DESKTOPABSOLUTEPARSING, &tmp))) { char* c = out; while (*tmp && c - out < max_size - 1) { *c = (char)*tmp; ++c; ++tmp; } *c = '\0'; ret = true; } psi->Release(); } } pfd->Release(); } return ret; }
string get_directory(string dname, string caption) { //NOTE: This uses the Windows Vista or later file chooser, which is different than the one used by GM8 and lower //because I could not find out which one it uses, since IFileDialog is used by both wxWidgets and QtFramework //and there doesn't appear to be a standard file picker for XP or lower in the Windows API except SHBrowseForFolder that is //used by Game Maker for get_directory_alt IFileDialog* fileDialog; CoCreateInstance(CLSID_FileOpenDialog, NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARGS(&fileDialog)); DWORD options; fileDialog->GetOptions(&options); options &= ~FOS_FILEMUSTEXIST; options &= ~FOS_PATHMUSTEXIST; fileDialog->SetOptions(options | FOS_PICKFOLDERS); //TODO: Set default directory to dname fileDialog->SetTitle(std::wstring(caption.begin(), caption.end()).c_str()); fileDialog->Show(enigma::hWnd); string res = ""; IShellItem *psi; if (SUCCEEDED(fileDialog->GetResult(&psi))) { LPWSTR wideres; psi->GetDisplayName(SIGDN_DESKTOPABSOLUTEPARSING, &wideres); psi->Release(); //TODO: F**k Microsoft with a wooden spoon std::wstring wtf = wideres; res = string(wtf.begin(), wtf.end()); } return res; }
HRESULT BasicFileOpen(PWSTR* filePath) { // CoCreate the File Open Dialog object. IFileDialog *pfd = NULL; HRESULT hr = CoCreateInstance(CLSID_FileOpenDialog, NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARGS(&pfd)); if (SUCCEEDED(hr)) { // Create an event handling object, and hook it up to the dialog. IFileDialogEvents *pfde = NULL; //DWORD dwCookie; // Set the options on the dialog. DWORD dwFlags; // Before setting, always get the options first in order // not to override existing options. hr = pfd->GetOptions(&dwFlags); if (SUCCEEDED(hr)) { // In this case, get shell items only for file system items. hr = pfd->SetOptions(dwFlags | FOS_FORCEFILESYSTEM); if (SUCCEEDED(hr)) { static const COMDLG_FILTERSPEC c_rgSaveTypes[] = { {L"Executable Files(*.exe)", L"*.exe"}, }; // Set the file types to display only. // Notice that this is a 1-based array. hr = pfd->SetFileTypes(ARRAYSIZE(c_rgSaveTypes), c_rgSaveTypes); if (SUCCEEDED(hr)) { // Set the selected file type index to Word Docs for this example. hr = pfd->SetFileTypeIndex(1); if (SUCCEEDED(hr)) { // Set the default extension to be ".doc" file. hr = pfd->SetDefaultExtension(L"exe"); if (SUCCEEDED(hr)) { // Show the dialog hr = pfd->Show(g_hwnd); if (SUCCEEDED(hr)) { // Obtain the result once the user clicks // the 'Open' button. // The result is an IShellItem object. IShellItem *psiResult; hr = pfd->GetResult(&psiResult); if (SUCCEEDED(hr)) { // We are just going to print out the // name of the file for sample sake. PWSTR pszFilePath = NULL; hr = psiResult->GetDisplayName(SIGDN_FILESYSPATH, &pszFilePath); if (SUCCEEDED(hr)) { *filePath=pszFilePath; } psiResult->Release(); } } } } } } } pfd->Release(); } else { hr=E_OUTOFMEMORY; OPENFILENAME ofn; LPWSTR pszFile=(LPWSTR)CoTaskMemAlloc(260*2); if(pszFile!=NULL) { memset1(&ofn,0,sizeof(ofn)); ofn.lStructSize = sizeof(ofn); ofn.hwndOwner = g_hwnd; ofn.lpstrFile = pszFile; // Set lpstrFile[0] to '\0' so that GetOpenFileName does not // use the contents of szFile to initialize itself. ofn.lpstrFile[0] = L'\0'; ofn.nMaxFile = 260; ofn.lpstrFilter = L"Executable Files(*.exe)\0*.exe\0"; ofn.nFilterIndex = 1; ofn.lpstrFileTitle = NULL; ofn.nMaxFileTitle = 0; ofn.lpstrInitialDir = NULL; ofn.Flags = OFN_PATHMUSTEXIST | OFN_FILEMUSTEXIST; if (GetOpenFileName(&ofn)==TRUE) { *filePath=pszFile; hr=0; } } } return hr; }
void openBrowseDialogCore(FileDialogType type, const Path& defaultPath, const String& filterList, Vector<Path>& paths, AsyncOp& returnValue) { // Init COM library. CoInitializeEx(nullptr, COINIT_APARTMENTTHREADED | COINIT_DISABLE_OLE1DDE); IFileDialog* fileDialog = nullptr; UINT32 dialogType = ((UINT32)type & (UINT32)FileDialogType::TypeMask); bool isOpenDialog = dialogType == (UINT32)FileDialogType::OpenFile || dialogType == (UINT32)FileDialogType::OpenFolder; // Create dialog IID classId = isOpenDialog ? CLSID_FileOpenDialog : CLSID_FileSaveDialog; CoCreateInstance(classId, nullptr, CLSCTX_ALL, IID_PPV_ARGS(&fileDialog)); addFiltersToDialog(fileDialog, filterList); setDefaultPath(fileDialog, defaultPath); // Apply multiselect flags bool isMultiselect = false; if (isOpenDialog) { if (dialogType == (UINT32)FileDialogType::OpenFile) { if (((UINT32)type & (UINT32)FileDialogType::Multiselect) != 0) { DWORD dwFlags; fileDialog->GetOptions(&dwFlags); fileDialog->SetOptions(dwFlags | FOS_ALLOWMULTISELECT); isMultiselect = true; } } else { DWORD dwFlags; fileDialog->GetOptions(&dwFlags); fileDialog->SetOptions(dwFlags | FOS_PICKFOLDERS); } } // Show the dialog bool finalResult = false; // Need to enable all windows, otherwise when the browse dialog closes the active window will become some // background window Win32Window::_enableAllWindows(); if (SUCCEEDED(fileDialog->Show(nullptr))) { if (isMultiselect) { // Get file names IFileOpenDialog* fileOpenDialog; fileDialog->QueryInterface(IID_IFileOpenDialog, (void**)&fileOpenDialog); IShellItemArray* shellItems = nullptr; fileOpenDialog->GetResults(&shellItems); getPaths(shellItems, paths); shellItems->Release(); fileOpenDialog->Release(); } else { // Get the file name IShellItem* shellItem = nullptr; fileDialog->GetResult(&shellItem); LPWSTR filePath = nullptr; shellItem->GetDisplayName(SIGDN_FILESYSPATH, &filePath); paths.push_back((Path)UTF8::fromWide(WString(filePath))); CoTaskMemFree(filePath); shellItem->Release(); } finalResult = true; } // Restore modal window state (before we enabled all windows) Win32Window::_restoreModalWindows(); CoUninitialize(); returnValue._completeOperation(finalResult); }
//----------------------------------------------------------------------------- bool VistaFileSelector::runModalInternal () { fileDialog = 0; HRESULT hr = -1; if (style == kSelectSaveFile) { hr = CoCreateInstance (CLSID_FileSaveDialog, NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARG(IFileDialog, &fileDialog)); if (defaultSaveName) { fileDialog->SetFileName (UTF8StringHelper (defaultSaveName)); } } else { hr = CoCreateInstance (CLSID_FileOpenDialog, NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARG(IFileDialog, &fileDialog)); if (SUCCEEDED (hr)) { if (style == kSelectDirectory) { DWORD dwOptions = 0; hr = fileDialog->GetOptions (&dwOptions); if (SUCCEEDED (hr)) hr = fileDialog->SetOptions (dwOptions | FOS_PICKFOLDERS); if (FAILED (hr)) { fileDialog->Release (); fileDialog = 0; return false; } } if (allowMultiFileSelection) { DWORD dwOptions = 0; hr = fileDialog->GetOptions (&dwOptions); if (SUCCEEDED (hr)) hr = fileDialog->SetOptions (dwOptions | FOS_ALLOWMULTISELECT); if (FAILED (hr)) { fileDialog->Release (); fileDialog = 0; return false; } } } } if (FAILED (hr)) { fileDialog = 0; return false; } if (title) hr = fileDialog->SetTitle (UTF8StringHelper (title)); DWORD numExtensions = 0; DWORD defaultFileTypeIndex = 0; COMDLG_FILTERSPEC* filters = buildExtensionFilter (extensions, defaultExtension, numExtensions, defaultFileTypeIndex); if (filters) { fileDialog->SetFileTypes (numExtensions, filters); if (defaultFileTypeIndex) fileDialog->SetFileTypeIndex (defaultFileTypeIndex); } if (initialPath && _SHCreateItemFromParsingName) { IShellItem* shellItem; hr = _SHCreateItemFromParsingName (UTF8StringHelper (initialPath), 0, IID_PPV_ARG (IShellItem, &shellItem)); if (SUCCEEDED (hr)) { fileDialog->SetFolder (shellItem); shellItem->Release (); } } Win32Frame* win32Frame = frame->getPlatformFrame () ? dynamic_cast<Win32Frame*> (frame->getPlatformFrame ()) : 0; hr = fileDialog->Show (win32Frame ? win32Frame->getPlatformWindow () : 0); if (SUCCEEDED (hr)) { if (allowMultiFileSelection) { IFileOpenDialog* openFileDialog = 0; hr = fileDialog->QueryInterface (IID_PPV_ARG(IFileOpenDialog, &openFileDialog)); if (SUCCEEDED (hr)) { IShellItemArray* items; hr = openFileDialog->GetResults (&items); if (SUCCEEDED (hr)) { DWORD count; hr = items->GetCount (&count); for (DWORD i = 0; i < count; i++) { IShellItem* item; hr = items->GetItemAt (i, &item); if (SUCCEEDED (hr)) { LPWSTR filesysPath = 0; hr = item->GetDisplayName (SIGDN_FILESYSPATH, &filesysPath); if (SUCCEEDED (hr)) { UTF8StringHelper str (filesysPath); UTF8StringBuffer resultPath = String::newWithString (str); result.push_back (resultPath); } item->Release (); } } items->Release (); } openFileDialog->Release (); } } else { IShellItem *item; hr = fileDialog->GetResult (&item); if (SUCCEEDED (hr)) { LPWSTR filesysPath = 0; hr = item->GetDisplayName (SIGDN_FILESYSPATH, &filesysPath); if (SUCCEEDED (hr)) { UTF8StringHelper str (filesysPath); UTF8StringBuffer resultPath = String::newWithString (str); result.push_back (resultPath); } item->Release (); } } } fileDialog->Release (); fileDialog = 0; freeExtensionFilter (filters); return SUCCEEDED (hr); }
String ShowOpenDirectoryDialog() { String ret; bool pathSelected = false; // check current OS version OSVERSIONINFO osvi; memset(&osvi, 0, sizeof(OSVERSIONINFO)); osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO); if (GetVersionEx(&osvi) && (osvi.dwMajorVersion >= 6)) { // for Vista or later, use the MSDN-preferred implementation of the Open File dialog in pick folders mode IFileDialog *pfd; if (SUCCEEDED(CoCreateInstance(CLSID_FileOpenDialog, NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARGS(&pfd)))) { // configure the dialog to Select Folders only DWORD dwOptions; if (SUCCEEDED(pfd->GetOptions(&dwOptions))) { pfd->SetOptions(dwOptions | FOS_PICKFOLDERS | FOS_DONTADDTORECENT); if (SUCCEEDED(pfd->Show(GetActiveWindow()))) { IShellItem *psi; if (SUCCEEDED(pfd->GetResult(&psi))) { LPWSTR lpwszName = NULL; if (SUCCEEDED(psi->GetDisplayName(SIGDN_DESKTOPABSOLUTEPARSING, (LPWSTR*) &lpwszName))) { // Add directory path to the result //ConvertToUnixPath(pathName); ret = lpwszName; pathSelected = true; ::CoTaskMemFree(lpwszName); } psi->Release(); } } } pfd->Release(); } } else { // for XP, use the old-styled SHBrowseForFolder() implementation BROWSEINFO bi = {0}; bi.hwndOwner = GetActiveWindow(); bi.ulFlags = BIF_NEWDIALOGSTYLE | BIF_EDITBOX; LPITEMIDLIST pidl = SHBrowseForFolder(&bi); if (pidl != 0) { TCHAR szFile[MAX_PATH]; szFile[0] = 0; if (SHGetPathFromIDList(pidl, szFile)) { // Add directory path to the result //ConvertToUnixPath(pathName); ret = szFile; pathSelected = true; } IMalloc* pMalloc = NULL; SHGetMalloc(&pMalloc); if (pMalloc) { pMalloc->Free(pidl); pMalloc->Release(); } } } return ret; }
/* ANT_CANVAS::LOAD_FILE() ----------------------- */ long long ANT_canvas::load_file(void) { long long lines; IFileDialog *pfd = NULL; IShellItem *psiResult; DWORD dwFlags; PWSTR pszFilePath = NULL; char chosen_filter[1024]; char chosen_filename[MAX_PATH]; OPENFILENAME parameters; /* Create the Open Dialg object IFileDialog */ if ((CoCreateInstance(CLSID_FileOpenDialog, NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARGS(&pfd)) == S_OK)) { /* we're on VISTA / Windows 7 or later */ const COMDLG_FILTERSPEC c_rgSaveTypes[] = { {L"C/C++ files", L"*.c;*.cxx;*.cpp;*.h;*.hpp.*.hxx;*.mak;makefile"}, {L"All Documents (*.*)", L"*.*"} }; pfd->GetOptions(&dwFlags); pfd->SetOptions(dwFlags | FOS_FORCEFILESYSTEM); // we want to see a file pfd->SetFileTypes(ARRAYSIZE(c_rgSaveTypes), c_rgSaveTypes); pfd->SetFileTypeIndex(1); // first item in the list is the default pfd->SetDefaultExtension(L"doc;docx"); if (pfd->Show(NULL) == S_OK) { if (pfd->GetResult(&psiResult) == S_OK) // get the result object if the user clicks "Open" { psiResult->GetDisplayName(SIGDN_FILESYSPATH, &pszFilePath); lines = file->read_file((char *)pszFilePath); CoTaskMemFree(pszFilePath); psiResult->Release(); } } pfd->Release(); return lines; } else { /* we're on something prior to VISTA (NT through to XP) so use the old-style common control */ memset(chosen_filename, 0, sizeof(chosen_filename)); parameters.lStructSize = sizeof(parameters); parameters.hwndOwner = window; parameters.hInstance = hInstance; parameters.lpstrFilter = L"C/C++ files\0*.c;*.cxx;*.cpp;*.h;*.hpp.*.hxx\0\0\0"; parameters.lpstrCustomFilter = (LPWSTR)chosen_filter; parameters.nMaxCustFilter = sizeof(chosen_filter) - 1; parameters.nFilterIndex = 1; parameters.lpstrFile = (LPWSTR)chosen_filename; parameters.nMaxFile = sizeof(chosen_filename) - 1; parameters.lpstrFileTitle = NULL; parameters.nMaxFileTitle = 0; parameters.lpstrInitialDir = NULL; parameters.lpstrTitle = L"Open..."; parameters.Flags = OFN_LONGNAMES; parameters.nFileOffset = 0; parameters.nFileExtension = 0; parameters.lpstrDefExt = NULL; parameters.lCustData = 0; parameters.lpfnHook = NULL; parameters.lpTemplateName = 0; #if (_WIN32_WINNT >= 0x0500) parameters.pvReserved = NULL; parameters.dwReserved = 0; parameters.FlagsEx = 0; #endif if ((GetOpenFileNameW(¶meters)) != 0) return file->read_file((char *)parameters.lpstrFile); } return 0; }
//----------------------------------------------------------------------------- void VistaFileSelector::cancelInternal () { if (fileDialog) fileDialog->Close (-1); }
void prefs_file::LoadFile(int filename_id, int metadata_id, int level_id, int enable_id) { COMDLG_FILTERSPEC c_rgSaveTypes[] = { { _T("Audio Files"), L"*.aiff;*.au;*.caf;*.flac;*.iff;*.mat;*.nist;*.ogg;*.paf;*.rf64;*.sf;*.snd;*.sph;*.svx;*.voc;*.w64;*.wav" }, { _T("All Files"), L"*.*"} }; // CoCreate the File Open Dialog object. IFileDialog *pfd = NULL; HRESULT hr = CoCreateInstance(CLSID_FileOpenDialog, NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARGS(&pfd)); if (SUCCEEDED(hr)) { // Set the file types to display only. // Notice that this is a 1-based array. hr = pfd->SetFileTypes(ARRAYSIZE(c_rgSaveTypes), c_rgSaveTypes); if (SUCCEEDED(hr)) { // Show the dialog hr = pfd->Show(NULL); if (SUCCEEDED(hr)) { // Obtain the result once the user clicks // the 'Open' button. // The result is an IShellItem object. IShellItem *psiResult; hr = pfd->GetResult(&psiResult); if (SUCCEEDED(hr)) { PWSTR pszFilePath = NULL; hr = psiResult->GetDisplayName(SIGDN_FILESYSPATH, &pszFilePath); if (SUCCEEDED(hr)) { int n_channels; int n_frames; int sampling_rate; double attenuation; // Calculate the optimum attentuation to prevent clipping if (preprocessor::calculate_attenuation(pszFilePath, FILTER_LEN, REALSIZE, &attenuation, &n_channels, &n_frames, &sampling_rate)) { SetDlgItemText(filename_id, pszFilePath); std::wstringstream info; info << n_frames << L" samples, " << n_channels << L" channels, " << sampling_rate << L" Hz"; SetDlgItemText(metadata_id, info.str().c_str()); CTrackBarCtrl slider = GetDlgItem(IDC_SLIDER_LEVEL1); slider.SetPos((int)(attenuation * FILE_LEVEL_STEPS_PER_DB)); CheckDlgButton(enable_id, 1); RefreshFileLevelLabel(); } CoTaskMemFree(pszFilePath); } psiResult->Release(); } } } } pfd->Release(); }