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;
}
static nfdresult_t SetDefaultPath( IFileDialog *dialog, const char *defaultPath )
{
if ( !defaultPath || strlen(defaultPath) == 0 )
return NFD_OKAY;
wchar_t *defaultPathW = {0};
CopyNFDCharToWChar( defaultPath, &defaultPathW );
IShellItem *folder;
HRESULT result = SHCreateItemFromParsingName( defaultPathW, NULL, IID_PPV_ARGS(&folder) );
// Valid non results.
if ( result == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND) || result == HRESULT_FROM_WIN32(ERROR_INVALID_DRIVE) )
{
NFDi_Free( defaultPathW );
return NFD_OKAY;
}
if ( !SUCCEEDED(result) )
{
NFDi_SetError("Error creating ShellItem");
NFDi_Free( defaultPathW );
return NFD_ERROR;
}
// Could also call SetDefaultFolder(), but this guarantees defaultPath -- more consistency across API.
dialog->SetFolder( folder );
NFDi_Free( defaultPathW );
folder->Release();
return NFD_OKAY;
}
// @pymethod (int, <o PyIShellItem>|PyITransferSource|RecycleItem|Moves an item to the recycle bin
PyObject *PyITransferSource::RecycleItem(PyObject *self, PyObject *args)
{
ITransferSource *pITS = GetI(self);
if ( pITS == NULL )
return NULL;
// @pyparm <o PyIShellItem>|Source||The item to be recycled
// @pyparm <o PyIShellItem>|ParentDest||Shell item representing the recycle bin
TRANSFER_SOURCE_FLAGS flags;
// @pyparm int|flags||Combination of shellcon.TSF_* flags
PyObject *obpsiSource;
PyObject *obpsiParentDest;
IShellItem * psiSource;
IShellItem * psiParentDest;
IShellItem * ppsiNewDest;
if ( !PyArg_ParseTuple(args, "OOi:RecycleItem", &obpsiSource, &obpsiParentDest, &flags) )
return NULL;
if (!PyCom_InterfaceFromPyInstanceOrObject(obpsiSource, IID_IShellItem, (void **)&psiSource, FALSE))
return NULL;
if (!PyCom_InterfaceFromPyInstanceOrObject(obpsiParentDest, IID_IShellItem, (void **)&psiParentDest, FALSE)){
PYCOM_RELEASE(psiSource);
return NULL;
}
HRESULT hr;
PY_INTERFACE_PRECALL;
hr = pITS->RecycleItem( psiSource, psiParentDest, flags, &ppsiNewDest );
psiSource->Release();
psiParentDest->Release();
PY_INTERFACE_POSTCALL;
if ( FAILED(hr) )
return PyCom_BuildPyException(hr, pITS, IID_ITransferSource );
return Py_BuildValue("lO", hr, PyCom_PyObjectFromIUnknown(ppsiNewDest, IID_IShellItem, FALSE));
}
HRESULT ComposerShellMenu::GetTargetData()
{
IShellItem* item = NULL;
BOOLEAN isFile = false;
HRESULT hr = GetShellItem(&item, &isFile);
if (SUCCEEDED(hr))
{
if (isFile)
{
IShellItem* parent = NULL;
hr = GetShellItemParent(item, &parent);
if (SUCCEEDED(hr))
{
hr = this->GetDataFromShellItem(parent);
parent->Release();
}
}
else
{
hr = this->GetDataFromShellItem(item);
}
item->Release();
}
return hr;
}
// @pymethod str|PyITransferSource|GetDefaultDestinationName|Determines the name of an item as it would appear in a given folder
PyObject *PyITransferSource::GetDefaultDestinationName(PyObject *self, PyObject *args)
{
ITransferSource *pITS = GetI(self);
if ( pITS == NULL )
return NULL;
// @pyparm <o PyIShellItem>|Source||The item whose name is wanted
// @pyparm <o PyIShellItem>|ParentDest||The destination folder
PyObject *obpsiSource;
PyObject *obpsiParentDest;
IShellItem * psiSource;
IShellItem * psiParentDest;
LPWSTR pszDestinationName;
if ( !PyArg_ParseTuple(args, "OO:GetDefaultDestinationName", &obpsiSource, &obpsiParentDest) )
return NULL;
if (!PyCom_InterfaceFromPyInstanceOrObject(obpsiSource, IID_IShellItem, (void **)&psiSource, FALSE))
return NULL;
if (!PyCom_InterfaceFromPyInstanceOrObject(obpsiParentDest, IID_IShellItem, (void **)&psiParentDest, FALSE)){
PYCOM_RELEASE(psiSource);
return NULL;
}
HRESULT hr;
PY_INTERFACE_PRECALL;
hr = pITS->GetDefaultDestinationName( psiSource, psiParentDest, &pszDestinationName );
psiSource->Release();
psiParentDest->Release();
PY_INTERFACE_POSTCALL;
if ( FAILED(hr) )
return PyCom_BuildPyException(hr, pITS, IID_ITransferSource );
PyObject *ret = PyWinObject_FromWCHAR(pszDestinationName);
CoTaskMemFree(pszDestinationName);
return ret;
}
std::vector<std::wstring> APlayerWindow::showOpenFile()
{
HRESULT hr = S_OK;
std::vector<std::wstring> filePaths;
IFileOpenDialog *fileDlg = NULL;
hr = CoCreateInstance(CLSID_FileOpenDialog,
NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARGS(&fileDlg));
if (FAILED(hr)) return filePaths;
ON_SCOPE_EXIT([&] { fileDlg->Release(); });
IKnownFolderManager *pkfm = NULL;
hr = CoCreateInstance(CLSID_KnownFolderManager,
NULL,
CLSCTX_INPROC_SERVER,
IID_PPV_ARGS(&pkfm));
if (FAILED(hr)) return filePaths;
ON_SCOPE_EXIT([&] { pkfm->Release(); });
IKnownFolder *pKnownFolder = NULL;
hr = pkfm->GetFolder(FOLDERID_PublicMusic, &pKnownFolder);
if (FAILED(hr)) return filePaths;
ON_SCOPE_EXIT([&] { pKnownFolder->Release(); });
IShellItem *psi = NULL;
hr = pKnownFolder->GetShellItem(0, IID_PPV_ARGS(&psi));
if (FAILED(hr)) return filePaths;
ON_SCOPE_EXIT([&] { psi->Release(); });
hr = fileDlg->AddPlace(psi, FDAP_BOTTOM);
COMDLG_FILTERSPEC rgSpec[] = {
{ L"ÒôÀÖÎļþ", SupportType }
};
fileDlg->SetFileTypes(1, rgSpec);
DWORD dwOptions;
fileDlg->GetOptions(&dwOptions);
fileDlg->SetOptions(dwOptions | FOS_ALLOWMULTISELECT);
hr = fileDlg->Show(NULL);
if (SUCCEEDED(hr)) {
IShellItemArray *pRets;
hr = fileDlg->GetResults(&pRets);
if (SUCCEEDED(hr)) {
DWORD count;
pRets->GetCount(&count);
for (DWORD i = 0; i < count; i++) {
IShellItem *pRet;
LPWSTR nameBuffer;
pRets->GetItemAt(i, &pRet);
pRet->GetDisplayName(SIGDN_DESKTOPABSOLUTEPARSING, &nameBuffer);
filePaths.push_back(std::wstring(nameBuffer));
pRet->Release();
CoTaskMemFree(nameBuffer);
}
pRets->Release();
}
}
return filePaths;
}
HRESULT v_ExecuteLibCommand()
{
// Get the private and public save locations.
IShellItem *psiPrivateSaveLoc;
HRESULT hr = _plib->GetDefaultSaveFolder(DSFT_PRIVATE, IID_PPV_ARGS(&psiPrivateSaveLoc));
if (SUCCEEDED(hr))
{
IShellItem *psiPublicSaveLoc;
hr = _plib->GetDefaultSaveFolder(DSFT_PUBLIC, IID_PPV_ARGS(&psiPublicSaveLoc));
if (SUCCEEDED(hr))
{
// Get the list of folders that match the specified filter.
IShellItemArray *psiaFolders;
hr = _plib->GetFolders(_lffFilter, IID_PPV_ARGS(&psiaFolders));
if (SUCCEEDED(hr))
{
DWORD cFolders;
hr = psiaFolders->GetCount(&cFolders);
if (SUCCEEDED(hr))
{
Output(L"Library contains %u folders:\n", cFolders);
for (DWORD iFolder = 0; iFolder < cFolders; iFolder++)
{
IShellItem *psiFolder;
if (SUCCEEDED(psiaFolders->GetItemAt(iFolder, &psiFolder)))
{
// Print each folder's name as an absolute path, suitable for parsing in the Shell Namespace (e.g SHParseDisplayName).
// For file system folders (the typical case), this will be the file system path of the folder.
PWSTR pszDisplay;
if (SUCCEEDED(psiFolder->GetDisplayName(SIGDN_DESKTOPABSOLUTEPARSING, &pszDisplay)))
{
PCWSTR pszPrefix = L" ";
int iCompare;
if (S_OK == psiPrivateSaveLoc->Compare(psiFolder, SICHINT_CANONICAL | SICHINT_TEST_FILESYSPATH_IF_NOT_EQUAL, &iCompare))
{
pszPrefix = L"* ";
}
else if (S_OK == psiPublicSaveLoc->Compare(psiFolder, SICHINT_CANONICAL | SICHINT_TEST_FILESYSPATH_IF_NOT_EQUAL, &iCompare))
{
pszPrefix = L"# ";
}
Output(L"%s%s\n", pszPrefix, pszDisplay);
CoTaskMemFree(pszDisplay);
}
psiFolder->Release();
}
}
}
psiaFolders->Release();
}
psiPublicSaveLoc->Release();
}
psiPrivateSaveLoc->Release();
}
return hr;
}
// IObjectWithSelection
IFACEMETHODIMP SetSelection(IShellItemArray *aArray)
{
if (!aArray) {
return E_FAIL;
}
SetInterface(&mShellItemArray, aArray);
DWORD count = 0;
aArray->GetCount(&count);
if (!count) {
return E_FAIL;
}
#ifdef SHOW_CONSOLE
Log(L"SetSelection param count: %d", count);
for (DWORD idx = 0; idx < count; idx++) {
IShellItem* item = nullptr;
if (SUCCEEDED(aArray->GetItemAt(idx, &item))) {
LPWSTR str = nullptr;
if (FAILED(item->GetDisplayName(SIGDN_FILESYSPATH, &str))) {
if (FAILED(item->GetDisplayName(SIGDN_URL, &str))) {
Log(L"Failed to get a shell item array item.");
item->Release();
continue;
}
}
item->Release();
Log(L"SetSelection param: '%s'", str);
CoTaskMemFree(str);
}
}
#endif
IShellItem* item = nullptr;
if (FAILED(aArray->GetItemAt(0, &item))) {
return E_FAIL;
}
bool isFileSystem = false;
if (!SetTargetPath(item) || !mTarget.GetLength()) {
Log(L"SetTargetPath failed.");
return E_FAIL;
}
item->Release();
Log(L"SetSelection target: %s", mTarget);
return S_OK;
}
// @pymethod |PyIFileOperation|CopyItem|Adds a copy operation to the configuration
PyObject *PyIFileOperation::CopyItem(PyObject *self, PyObject *args)
{
IFileOperation *pIFO = GetI(self);
if ( pIFO == NULL )
return NULL;
// @pyparm <o PyIShellItem>|Item||Item to be copied
// @pyparm <o PyIShellItem>|DestinationFolder||Folder into which it will be copied
// @pyparm str|CopyName|None|New name for the copied file, use None to keep original name
// @pyparm <o PyGFileOperationProgressSink>|Sink|None|Progress sink for just this operation
PyObject *obItem;
PyObject *obDestinationFolder;
PyObject *obCopyName = Py_None;
PyObject *obSink = Py_None;
IShellItem * pItem;
IShellItem * pDestinationFolder;
TmpWCHAR CopyName;
IFileOperationProgressSink * pSink;
if (!PyArg_ParseTuple(args, "OO|OO:CopyItem", &obItem, &obDestinationFolder, &obCopyName, &obSink))
return NULL;
if (!PyWinObject_AsWCHAR(obCopyName, &CopyName, TRUE))
return NULL;
if (!PyCom_InterfaceFromPyInstanceOrObject(obItem, IID_IShellItem, (void **)&pItem, FALSE))
return NULL;
if (!PyCom_InterfaceFromPyInstanceOrObject(obDestinationFolder, IID_IShellItem, (void **)&pDestinationFolder, FALSE)) {
PYCOM_RELEASE(pItem);
return NULL;
}
if (!PyCom_InterfaceFromPyInstanceOrObject(obSink, IID_IFileOperationProgressSink, (void **)&pSink, TRUE)) {
PYCOM_RELEASE(pItem);
PYCOM_RELEASE(pDestinationFolder);
return NULL;
}
HRESULT hr;
PY_INTERFACE_PRECALL;
hr = pIFO->CopyItem( pItem, pDestinationFolder, CopyName, pSink);
pItem->Release();
pDestinationFolder->Release();
if (pSink)
pSink->Release();
PY_INTERFACE_POSTCALL;
if ( FAILED(hr) )
return PyCom_BuildPyException(hr, pIFO, IID_IFileOperation );
Py_INCREF(Py_None);
return Py_None;
}
// @pymethod |PyIShellLibrary|SetDefaultSaveFolder|Sets the default save location
PyObject *PyIShellLibrary::SetDefaultSaveFolder(PyObject *self, PyObject *args)
{
IShellLibrary *pISL = GetI(self);
if ( pISL == NULL )
return NULL;
DEFAULTSAVEFOLDERTYPE Type;
IShellItem *SaveFolder;
PyObject *obSaveFolder;
// @pyparm int|Type||Specifies public or private save location, shellcon.DSFT_*
// @pyparm <o PyIShellItem>|SaveFolder||New default location, must be in the library
if (!PyArg_ParseTuple(args, "iO:SetDefaultSaveFolder", &Type, &obSaveFolder))
return NULL;
if (!PyCom_InterfaceFromPyObject(obSaveFolder, IID_IShellItem, (void **)&SaveFolder, FALSE))
return NULL;
HRESULT hr;
PY_INTERFACE_PRECALL;
hr = pISL->SetDefaultSaveFolder(Type, SaveFolder);
SaveFolder->Release();
PY_INTERFACE_POSTCALL;
if ( FAILED(hr) )
return PyCom_BuildPyException(hr, pISL, IID_IShellLibrary );
Py_INCREF(Py_None);
return Py_None;
}
// @pymethod |PyIShellLibrary|LoadLibraryFromItem|Loads an existing library file
PyObject *PyIShellLibrary::LoadLibraryFromItem(PyObject *self, PyObject *args)
{
IShellLibrary *pISL = GetI(self);
if ( pISL == NULL )
return NULL;
IShellItem *Library;
PyObject *obLibrary;
DWORD Mode;
// @pyparm <o PyIShellItem>|Library||Shell item interface representing the library file
// @pyparm int|Mode||Access mode, combination of storagecon.STGM_* flags
if ( !PyArg_ParseTuple(args, "Ok:LoadLibraryFromItem", &obLibrary, &Mode) )
return NULL;
if (!PyCom_InterfaceFromPyObject(obLibrary, IID_IShellItem, (void **)&Library, FALSE))
return NULL;
HRESULT hr;
PY_INTERFACE_PRECALL;
hr = pISL->LoadLibraryFromItem(Library, Mode);
Library->Release();
PY_INTERFACE_POSTCALL;
if ( FAILED(hr) )
return PyCom_BuildPyException(hr, pISL, IID_IShellLibrary );
Py_INCREF(Py_None);
return Py_None;
}
// @pymethod <o PyIShellItem>|PyIShellLibrary|ResolveFolder|Attempts to locate a folder that has been moved or renamed
PyObject *PyIShellLibrary::ResolveFolder(PyObject *self, PyObject *args)
{
IShellLibrary *pISL = GetI(self);
if ( pISL == NULL )
return NULL;
IShellItem *FolderToResolve;
PyObject *obFolderToResolve;
DWORD Timeout;
IID riid = IID_IShellItem;
// @pyparm <o PyIShellItem>|FolderToResolve||Library item whose location has changed
// @pyparm int|Timeout||Max search time, specified in milliseconds
// @pyparm <o PyIID>|riid|IID_IShellItem|The interface to return
if (!PyArg_ParseTuple(args, "Ok|O&:ResolveFolder",
&obFolderToResolve, &Timeout,
PyWinObject_AsIID, &riid))
return NULL;
if (!PyCom_InterfaceFromPyObject(obFolderToResolve, IID_IShellItem, (void **)&FolderToResolve, FALSE))
return NULL;
void *pv;
HRESULT hr;
PY_INTERFACE_PRECALL;
hr = pISL->ResolveFolder(FolderToResolve, Timeout, riid, &pv );
FolderToResolve->Release();
PY_INTERFACE_POSTCALL;
if ( FAILED(hr) )
return PyCom_BuildPyException(hr, pISL, IID_IShellLibrary );
return PyCom_PyObjectFromIUnknown((IUnknown *)pv, riid, FALSE);
}
HRESULT ContextMenu::DisplayItems(IShellItemArray *psia, HWND hwndParent)
{
DWORD count;
psia->GetCount(&count);
for(DWORD i = 0; i < count; ++i)
{
IShellItem *psi;
HRESULT hr = psia->GetItemAt(i, &psi);
if (SUCCEEDED(hr))
{
PWSTR pszDisplayName;
hr = psi->GetDisplayName(SIGDN_NORMALDISPLAY, &pszDisplayName);
if (SUCCEEDED(hr))
{
MessageBoxW(hwndParent, pszDisplayName, pszDisplayName, MB_OK);
CoTaskMemFree(pszDisplayName);
}
psi->Release();
}
else
{
return hr;
}
}
return S_OK;
}
// On Vista or 7 we could use SHIL_JUMBO to get a 256x256 icon,
// but we'll use SHCreateItemFromParsingName as it'll give an identical
// icon to the one shown in explorer and it scales automatically.
bool WinIconProvider::addIconFromShellFactory(QString filePath, QIcon& icon) const
{
HRESULT hr = S_FALSE;
if (fnSHCreateItemFromParsingName)
{
IShellItem* psi = NULL;
hr = fnSHCreateItemFromParsingName((PCWSTR)filePath.utf16(), 0, IID_IShellItem, (void**)&psi);
if (hr == S_OK)
{
IShellItemImageFactory* psiif = NULL;
hr = psi->QueryInterface(IID_IShellItemImageFactory, (void**)&psiif);
if (hr == S_OK)
{
HBITMAP iconBitmap = NULL;
SIZE iconSize = {preferredSize, preferredSize};
hr = psiif->GetImage(iconSize, SIIGBF_RESIZETOFIT | SIIGBF_ICONONLY, &iconBitmap);
if (hr == S_OK)
{
QPixmap iconPixmap = QtWin::fromHBITMAP(iconBitmap);
icon.addPixmap(iconPixmap);
DeleteObject(iconBitmap);
}
psiif->Release();
}
psi->Release();
}
}
return hr == S_OK;
}
// @pymethod (int, <o PyIShellItem>)|PyITransferSource|RenameItem|Renames a shell item
PyObject *PyITransferSource::RenameItem(PyObject *self, PyObject *args)
{
ITransferSource *pITS = GetI(self);
if ( pITS == NULL )
return NULL;
// @pyparm <o PyIShellItem>|Source||Item to be renamed
// @pyparm str|NewName||The name to be given to the item
TRANSFER_SOURCE_FLAGS flags;
// @pyparm int|flags||Combination of shellcon.TSF_* flags
PyObject *obpsiSource;
PyObject *obNewName;
IShellItem * psiSource;
TmpWCHAR NewName;
IShellItem * ppsiNewDest;
if ( !PyArg_ParseTuple(args, "OOi:RenameItem", &obpsiSource, &obNewName, &flags) )
return NULL;
if (!PyWinObject_AsWCHAR(obNewName, &NewName, FALSE))
return NULL;
if (!PyCom_InterfaceFromPyInstanceOrObject(obpsiSource, IID_IShellItem, (void **)&psiSource, FALSE))
return NULL;
HRESULT hr;
PY_INTERFACE_PRECALL;
hr = pITS->RenameItem( psiSource, NewName, flags, &ppsiNewDest );
psiSource->Release();
PY_INTERFACE_POSTCALL;
if ( FAILED(hr) )
return PyCom_BuildPyException(hr, pITS, IID_ITransferSource );
return Py_BuildValue("lN", hr, PyCom_PyObjectFromIUnknown(ppsiNewDest, IID_IShellItem, FALSE));
}
// @pymethod |PyINameSpaceTreeControl|AppendRoot|Description of AppendRoot.
PyObject *PyINameSpaceTreeControl::AppendRoot(PyObject *self, PyObject *args)
{
INameSpaceTreeControl *pINSTC = GetI(self);
if ( pINSTC == NULL )
return NULL;
// @pyparm <o PyIShellItem>|psiRoot||Description for psiRoot
// @pyparm int|grfEnumFlags||Description for grfEnumFlags
// @pyparm int|grfRootStyle||Description for grfRootStyle
// @pyparm <o PyIShellItemFilter>|pif||Description for pif
PyObject *obpsiRoot;
PyObject *obpif;
IShellItem * psiRoot;
DWORD grfEnumFlags;
DWORD grfRootStyle;
IShellItemFilter * pif;
if ( !PyArg_ParseTuple(args, "OkkO:AppendRoot", &obpsiRoot, &grfEnumFlags, &grfRootStyle, &obpif) )
return NULL;
if (!PyCom_InterfaceFromPyInstanceOrObject(obpsiRoot, IID_IShellItem, (void **)&psiRoot, TRUE /* bNoneOK */))
return NULL;
if (!PyCom_InterfaceFromPyInstanceOrObject(obpif, IID_IShellItemFilter, (void **)&pif, TRUE /* bNoneOK */)) {
if (pif) pif->Release();
return NULL;
}
HRESULT hr;
PY_INTERFACE_PRECALL;
hr = pINSTC->AppendRoot( psiRoot, grfEnumFlags, grfRootStyle, pif );
if (psiRoot) psiRoot->Release();
if (pif) pif->Release();
PY_INTERFACE_POSTCALL;
if ( FAILED(hr) )
return PyCom_BuildPyException(hr, pINSTC, IID_INameSpaceTreeControl );
Py_INCREF(Py_None);
return Py_None;
}
// @pymethod int|PyIShellItem|Compare|Compares another shell item with this item
// @rdesc Returns 0 if items compare as equal, nonzero otherwise
PyObject *PyIShellItem::Compare(PyObject *self, PyObject *args)
{
IShellItem *pISI = GetI(self);
if ( pISI == NULL )
return NULL;
// @pyparm <o PyIShellItem>|psi||A shell item to be compared with this item
SICHINTF hint;
// @pyparm int|hint||shellcon.SICHINT_* value indicating how the comparison is to be performed
PyObject *obpsi;
IShellItem *psi;
if ( !PyArg_ParseTuple(args, "Oi:Compare", &obpsi, &hint) )
return NULL;
if (!PyCom_InterfaceFromPyInstanceOrObject(obpsi, IID_IShellItem, (void **)&psi, FALSE))
return NULL;
HRESULT hr;
int iOrder;
PY_INTERFACE_PRECALL;
hr = pISI->Compare( psi, hint, &iOrder );
psi->Release();
PY_INTERFACE_POSTCALL;
if ( FAILED(hr) )
return PyCom_BuildPyException(hr, pISI, IID_IShellItem );
return PyInt_FromLong(iOrder);
}
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();
}
}
PWSTR LoadFile() {
IFileOpenDialog *pFileOpen;
PWSTR pszFilePath = NULL;
// Create the FileOpenDialog object.
HRESULT hr = CoCreateInstance(CLSID_FileOpenDialog, NULL, CLSCTX_ALL,
IID_IFileOpenDialog, reinterpret_cast<void**>(&pFileOpen));
if (SUCCEEDED(hr))
{
//IShellItem *psiDocuments = NULL;
//hr = SHCreateItemInKnownFolder(FOLDERID_Documents, 0, NULL, IID_PPV_ARGS(&psiDocuments));
//if (SUCCEEDED(hr)) {
// hr = pFileOpen->SetFolder(psiDocuments);
// psiDocuments->Release();
//}
// Show the Open dialog box.
hr = pFileOpen->Show(NULL);
// Get the file name from the dialog box.
if (SUCCEEDED(hr))
{
IShellItem *pItem;
hr = pFileOpen->GetResult(&pItem);
if (SUCCEEDED(hr))
{
hr = pItem->GetDisplayName(SIGDN_FILESYSPATH, &pszFilePath);
pItem->Release();
}
}
pFileOpen->Release();
}
return pszFilePath;
}
// @pymethod |PyINameSpaceTreeControl|GetItemState|Description of GetItemState.
PyObject *PyINameSpaceTreeControl::GetItemState(PyObject *self, PyObject *args)
{
INameSpaceTreeControl *pINSTC = GetI(self);
if ( pINSTC == NULL )
return NULL;
// @pyparm <o PyIShellItem>|psi||Description for psi
// @pyparm int|nstcisMask||Description for nstcisMask
PyObject *obpsi;
IShellItem * psi;
DWORD nstcisMask;
DWORD nstcisFlags;
if ( !PyArg_ParseTuple(args, "Ok:GetItemState", &obpsi, &nstcisMask) )
return NULL;
BOOL bPythonIsHappy = TRUE;
if (bPythonIsHappy && !PyCom_InterfaceFromPyInstanceOrObject(obpsi, IID_IShellItem, (void **)&psi, TRUE /* bNoneOK */))
bPythonIsHappy = FALSE;
if (!bPythonIsHappy) return NULL;
HRESULT hr;
PY_INTERFACE_PRECALL;
hr = pINSTC->GetItemState( psi, nstcisMask, &nstcisFlags );
if (psi) psi->Release();
PY_INTERFACE_POSTCALL;
if ( FAILED(hr) )
return PyCom_BuildPyException(hr, pINSTC, IID_INameSpaceTreeControl );
return PyLong_FromUnsignedLong(nstcisFlags);
}
void ReportSelectedItems(IUnknown *punkSite, IShellItemArray *psia)
{
DWORD cItems;
HRESULT hr = psia->GetCount(&cItems);
for (DWORD i = 0; SUCCEEDED(hr) && (i < cItems); i++)
{
IShellItem *psi;
hr = psia->GetItemAt(i, &psi);
if (SUCCEEDED(hr))
{
PWSTR pszName;
hr = GetIDListName(psi, &pszName);
if (SUCCEEDED(hr))
{
HWND hwnd;
IUnknown_GetWindow(punkSite, &hwnd);
int nButton;
const TASKDIALOG_COMMON_BUTTON_FLAGS buttonFlags = (i == (cItems - 1)) ? TDCBF_OK_BUTTON : TDCBF_OK_BUTTON | TDCBF_CANCEL_BUTTON;
WCHAR szMsg[128];
StringCchPrintf(szMsg, ARRAYSIZE(szMsg), L"Item %d of %d added to basket", i + 1, cItems);
if (SUCCEEDED(TaskDialog(hwnd, 0, L"Items Addded to Basket", szMsg, pszName, buttonFlags, NULL, &nButton)))
{
hr = (nButton == IDCANCEL) ? HRESULT_FROM_WIN32(ERROR_CANCELLED) : S_OK;
}
CoTaskMemFree(pszName);
}
psi->Release();
}
}
}
// @pymethod (int, <o PyIShellItemResources>)|PyITransferSource|OpenItem|Initiates the copying of an item
PyObject *PyITransferSource::OpenItem(PyObject *self, PyObject *args)
{
ITransferSource *pITS = GetI(self);
if ( pITS == NULL )
return NULL;
// @pyparm <o PyIShellItem>|Item||The item to be copied.
TRANSFER_SOURCE_FLAGS flags;
// @pyparm int|flags||Combination of shellcon.TSF_* flags
// @pyparm <o PyIID>|riid|IID_IShellItemResources|The interface to return
void *pv;
PyObject *obpsi;
IShellItem * psi;
IID riid = IID_IShellItemResources;
if ( !PyArg_ParseTuple(args, "Oi|O&:OpenItem", &obpsi, &flags,
PyWinObject_AsIID, &riid))
return NULL;
if (!PyCom_InterfaceFromPyInstanceOrObject(obpsi, IID_IShellItem, (void **)&psi, FALSE))
return NULL;
HRESULT hr;
PY_INTERFACE_PRECALL;
hr = pITS->OpenItem( psi, flags, riid, &pv);
psi->Release();
PY_INTERFACE_POSTCALL;
if ( FAILED(hr) )
return PyCom_BuildPyException(hr, pITS, IID_ITransferSource );
return Py_BuildValue("lN", hr, PyCom_PyObjectFromIUnknown((IUnknown *)pv, riid, FALSE));
}
// @pymethod |PyINameSpaceTreeControl|SetItemCustomState|Description of SetItemCustomState.
PyObject *PyINameSpaceTreeControl::SetItemCustomState(PyObject *self, PyObject *args)
{
INameSpaceTreeControl *pINSTC = GetI(self);
if ( pINSTC == NULL )
return NULL;
// @pyparm <o PyIShellItem>|psi||Description for psi
// @pyparm int|iStateNumber||Description for iStateNumber
PyObject *obpsi;
IShellItem * psi;
int iStateNumber;
if ( !PyArg_ParseTuple(args, "Oi:SetItemCustomState", &obpsi, &iStateNumber) )
return NULL;
if (!PyCom_InterfaceFromPyInstanceOrObject(obpsi, IID_IShellItem, (void **)&psi, TRUE /* bNoneOK */))
return NULL;
HRESULT hr;
PY_INTERFACE_PRECALL;
hr = pINSTC->SetItemCustomState( psi, iStateNumber );
if (psi) psi->Release();
PY_INTERFACE_POSTCALL;
if ( FAILED(hr) )
return PyCom_BuildPyException(hr, pINSTC, IID_INameSpaceTreeControl );
Py_INCREF(Py_None);
return Py_None;
}
// @pymethod |PyIFileOperation|DeleteItem|Adds a delete operation to the configuration
PyObject *PyIFileOperation::DeleteItem(PyObject *self, PyObject *args)
{
IFileOperation *pIFO = GetI(self);
if ( pIFO == NULL )
return NULL;
// @pyparm <o PyIShellItem>|Item||Description for psiItem
// @pyparm <o PyGFileOperationProgressSink>|Sink|None|Progress sink for just this operation
PyObject *obItem;
PyObject *obSink = Py_None;
IShellItem * pItem;
IFileOperationProgressSink * pSink;
if (!PyArg_ParseTuple(args, "O|O:DeleteItem", &obItem, &obSink))
return NULL;
if (!PyCom_InterfaceFromPyInstanceOrObject(obItem, IID_IShellItem, (void **)&pItem, FALSE))
return NULL;
if (!PyCom_InterfaceFromPyInstanceOrObject(obSink, IID_IFileOperationProgressSink, (void **)&pSink, TRUE)) {
PYCOM_RELEASE(pItem);
return NULL;
}
HRESULT hr;
PY_INTERFACE_PRECALL;
hr = pIFO->DeleteItem(pItem, pSink);
pItem->Release();
if (pSink)
pSink->Release();
PY_INTERFACE_POSTCALL;
if ( FAILED(hr) )
return PyCom_BuildPyException(hr, pIFO, IID_IFileOperation );
Py_INCREF(Py_None);
return Py_None;
}
// @pymethod |PyIFileOperation|CopyItems|Adds multiple copy operations to the configuration
PyObject *PyIFileOperation::CopyItems(PyObject *self, PyObject *args)
{
IFileOperation *pIFO = GetI(self);
if ( pIFO == NULL )
return NULL;
// @pyparm <o PyIUnknown>|Items||<o PyIShellItemArray>, <o PyIDataObject>, or <o PyIEnumShellItems> containing items to be copied
// @pyparm <o PyIShellItem>|DestinationFolder||Folder into which they will be copied
PyObject *obItems;
PyObject *obDestinationFolder;
IUnknown * pItems;
IShellItem * pDestinationFolder;
if ( !PyArg_ParseTuple(args, "OO:CopyItems", &obItems, &obDestinationFolder) )
return NULL;
if (!PyCom_InterfaceFromPyInstanceOrObject(obItems, IID_IUnknown, (void **)&pItems, FALSE))
return NULL;
if (!PyCom_InterfaceFromPyInstanceOrObject(obDestinationFolder, IID_IShellItem, (void **)&pDestinationFolder, FALSE)) {
PYCOM_RELEASE(pItems);
return NULL;
}
HRESULT hr;
PY_INTERFACE_PRECALL;
hr = pIFO->CopyItems( pItems, pDestinationFolder );
pItems->Release();
pDestinationFolder->Release();
PY_INTERFACE_POSTCALL;
if ( FAILED(hr) )
return PyCom_BuildPyException(hr, pIFO, IID_IFileOperation );
Py_INCREF(Py_None);
return Py_None;
}
void ChangeDropImageType(DROPIMAGETYPE newType)
{
if (newType != _dropImageType) {
_dropImageType = newType;
if (_pdtobj != nullptr) {
IShellItem *psi;
HRESULT hr = CreateItemFromObject(_pdtobj, IID_PPV_ARGS(&psi));
if (SUCCEEDED(hr))
{
PWSTR pszName;
hr = psi->GetDisplayName(SIGDN_NORMALDISPLAY/*SIGDN_FILESYSPATH*/, &pszName);
if (SUCCEEDED(hr))
{
SetDropTip(_pdtobj, _dropImageType, _pszDropTipTemplate ? _pszDropTipTemplate : L"%1", pszName);
CoTaskMemFree(pszName);
}
psi->Release();
}
else {
auto strName = GetDisplayFullNameFromObject(_pdtobj);
if (!strName.IsEmpty()) {
SetDropTip(_pdtobj, _dropImageType, _pszDropTipTemplate ? _pszDropTipTemplate : L"%1", strName);
}
}
}
}
}
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;
}
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;
}
const bool Core::select_file() {
//Open file dialog, straight from https://msdn.microsoft.com/en-us/library/windows/desktop/ff485843(v=vs.85).aspx
HRESULT hr = CoInitializeEx(NULL, COINIT_APARTMENTTHREADED | COINIT_DISABLE_OLE1DDE);
PWSTR pszFilePath = nullptr;
if (SUCCEEDED(hr)) {
IFileOpenDialog *pFileOpen;
// Create the FileOpenDialog object.
hr = CoCreateInstance(CLSID_FileOpenDialog, NULL, CLSCTX_ALL,
IID_IFileOpenDialog, reinterpret_cast<void**>(&pFileOpen));
if (SUCCEEDED(hr)) {
//Boilerplate for only showing *.nes files in the dialog. See the MSDN docs more info.
COMDLG_FILTERSPEC fileFilter;
fileFilter.pszName = L"iNES";
fileFilter.pszSpec = L"*.nes";
pFileOpen->SetFileTypes(1, &fileFilter);
pFileOpen->SetFileTypeIndex(1);
pFileOpen->SetDefaultExtension(L"nes");
// Show the Open dialog box.
hr = pFileOpen->Show(NULL);
// Get the file name from the dialog box.
if (SUCCEEDED(hr)) {
IShellItem *pItem;
hr = pFileOpen->GetResult(&pItem);
if (SUCCEEDED(hr)) {
hr = pItem->GetDisplayName(SIGDN_FILESYSPATH, &pszFilePath);
if (SUCCEEDED(hr)) {
logmsg("Opening file");
} else {
pszFilePath = nullptr;
}
pItem->Release();
}
}
pFileOpen->Release();
}
CoUninitialize();
}
if (pszFilePath == nullptr) {
alert_error("Unable to open file! File must have the extension \".nes\"");
return false;
}
//Convert wchar_t string to char string
std::size_t i;
wcstombs_s(&i, fileSelection, pszFilePath, MAX_PATH);
return true;
}
extern "C" LXCWIN_API HRESULT fileOpenDialog(HWND hWnd, DWORD *count, LPWSTR **result) {
*result = NULL;
HRESULT hr = S_OK;
CoInitialize(nullptr);
IFileOpenDialog *pfd = NULL;
hr = CoCreateInstance(CLSID_FileOpenDialog, NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARGS(&pfd));
if (SUCCEEDED(hr)) {
// set default folder to "My Documents"
IShellItem *psiDocuments = NULL;
hr = SHCreateItemInKnownFolder(FOLDERID_Documents, 0, NULL,
IID_PPV_ARGS(&psiDocuments));
if (SUCCEEDED(hr)) {
hr = pfd->SetDefaultFolder(psiDocuments);
psiDocuments->Release();
}
// dialog title
pfd->SetTitle(L"Select files to share");
// allow multiselect, restrict to real files
DWORD dwOptions;
hr = pfd->GetOptions(&dwOptions);
if (SUCCEEDED(hr)) {
// ideally, allow selecting folders as well as files, but IFileDialog does not support this :(
pfd->SetOptions(dwOptions | FOS_ALLOWMULTISELECT | FOS_FORCEFILESYSTEM); // | FOS_PICKFOLDERS
}
// do not limit to certain file types
// show the open file dialog
hr = pfd->Show(hWnd);
if (SUCCEEDED(hr)) {
IShellItemArray *psiaResults;
hr = pfd->GetResults(&psiaResults);
if (SUCCEEDED(hr)) {
hr = psiaResults->GetCount(count);
if (SUCCEEDED(hr)) {
*result = (LPWSTR*)calloc(*count, sizeof(LPWSTR));
if (*result != NULL) {
for (DWORD i = 0; i < *count; i++) {
IShellItem *resultItem = NULL;
hr = psiaResults->GetItemAt(i, &resultItem);
if (SUCCEEDED(hr)) {
resultItem->GetDisplayName(SIGDN_FILESYSPATH, &((*result)[i]));
resultItem->Release();
}
}
// paths now contains selected files
}
}
psiaResults->Release();
}
}
pfd->Release();
}
return hr;
}