void TestDominoDocArtifact::TestCreateRelatedDocumentWithTmpFileName()
{
DomDocHelper dominoDocument(TEST_ARTIFACT_FILE);
DominoDocArtifact artifact(m_spLibrary, dominoDocument.DocumentId, dominoDocument.GetVersionLabel());
std::wstring tempFile = _bstr_t(CTempFileManager::GetTempFileName().c_str());
std::wstring extension = PathFindExtensionW(tempFile.c_str());
std::wstring w3TempFile = tempFile.substr(0, tempFile.length() - extension.length());
w3TempFile.append(L".W3");
rename(bstr_t(tempFile.c_str()), bstr_t(w3TempFile.c_str()));
std::tofstream outFile(w3TempFile.c_str());
outFile << _T("Some junk") << std::endl;
outFile.close();
Artifact relatedArtifact = artifact.CreateRelatedItem(w3TempFile, L"W3", L"", false);
DominoDocManager manager;
manager.SetDocumentToDelete(relatedArtifact);
CTempFileManager::DeleteTempFileName(w3TempFile);
std::wstring dominoFileName = GetDominoDocumentFileName(relatedArtifact, m_spLibrary);
extension = PathFindExtensionW(dominoFileName.c_str());
dominoFileName = dominoFileName.substr(0, dominoFileName.length() - extension.length());
assertEqualsNoCase(_T(".W3"), bstr_t(extension.c_str()));
assertEquals(artifact.Name, dominoFileName);
assertEquals(artifact.Name + L".W3", relatedArtifact.Name);
}
HRESULT WINAPI CRecycleBin::GetDetailsOf(PCUITEMID_CHILD pidl, UINT iColumn, LPSHELLDETAILS pDetails)
{
PIDLRecycleStruct * pFileDetails;
WCHAR buffer[MAX_PATH];
WCHAR szTypeName[100];
LPWSTR pszBackslash;
UINT Length;
TRACE("(%p, %p, %d, %p)\n", this, pidl, iColumn, pDetails);
if (iColumn >= COLUMNS_COUNT)
return E_FAIL;
pDetails->fmt = RecycleBinColumns[iColumn].fmt;
pDetails->cxChar = RecycleBinColumns[iColumn].cxChars;
if (pidl == NULL)
return SHSetStrRet(&pDetails->str, RecycleBinColumns[iColumn].column_name_id);
if (iColumn == COLUMN_NAME)
return GetDisplayNameOf(pidl, SHGDN_NORMAL, &pDetails->str);
pFileDetails = _ILGetRecycleStruct(pidl);
switch (iColumn)
{
case COLUMN_DATEDEL:
FormatDateTime(buffer, MAX_PATH, &pFileDetails->DeletionTime);
break;
case COLUMN_DELFROM:
pszBackslash = wcsrchr(pFileDetails->szName, L'\\');
Length = (pszBackslash - pFileDetails->szName);
memcpy((LPVOID)buffer, pFileDetails->szName, Length * sizeof(WCHAR));
buffer[Length] = L'\0';
break;
case COLUMN_SIZE:
StrFormatKBSizeW(pFileDetails->FileSize.QuadPart, buffer, MAX_PATH);
break;
case COLUMN_MTIME:
FormatDateTime(buffer, MAX_PATH, &pFileDetails->LastModification);
break;
case COLUMN_TYPE:
// FIXME: We should in fact use a UNICODE version of _ILGetFileType
szTypeName[0] = L'\0';
wcscpy(buffer, PathFindExtensionW(pFileDetails->szName));
if (!( HCR_MapTypeToValueW(buffer, buffer, _countof(buffer), TRUE) &&
HCR_MapTypeToValueW(buffer, szTypeName, _countof(szTypeName), FALSE )))
{
/* load localized file string */
szTypeName[0] = '\0';
if(LoadStringW(shell32_hInstance, IDS_ANY_FILE, szTypeName, _countof(szTypeName)))
{
szTypeName[63] = '\0';
StringCchPrintfW(buffer, _countof(buffer), szTypeName, PathFindExtensionW(pFileDetails->szName));
}
}
return SHSetStrRet(&pDetails->str, szTypeName);
default:
return E_FAIL;
}
return SHSetStrRet(&pDetails->str, buffer);
}
/*--------------------------------------------------------------------------*/
char *FindFileExtension(char *filename)
{
char *extension = NULL;
if (filename)
{
#ifndef _MSC_VER
int lengthfilename = (int) strlen(filename);
int i = lengthfilename;
while(filename[i] != '.' && i > 0) i--;
if(i > 0)
{
int lengthextension = lengthfilename - i;
extension = (char*)MALLOC(sizeof(char)*(lengthextension+1));
if (extension) sprintf(extension,"%s",&filename[i]);
}
#else
{
wchar_t *wcFilename = to_wide_string(filename);
if (wcFilename)
{
extension = wide_string_to_UTF8(PathFindExtensionW(wcFilename));
FREE(wcFilename);
wcFilename = NULL;
}
}
#endif
}
return extension;
}
LRESULT MetroWindow::OnDropfiles(UINT nMsg, WPARAM wParam, LPARAM lParam, BOOL & bHandled)
{
const LPCWSTR PackageSubffix[] = { L".exe", L".dll", L".com", L".sys", L"scr", L"fon", L"drv" };
HDROP hDrop = (HDROP)wParam;
UINT nfilecounts = DragQueryFile(hDrop, 0xFFFFFFFF, NULL, 0);
WCHAR dropfile_name[MAX_PATH];
std::vector<std::wstring> filelist;
for (UINT i = 0; i < nfilecounts; i++) {
DragQueryFileW(hDrop, i, dropfile_name, MAX_PATH);
auto ext=PathFindExtensionW(dropfile_name);
if (ext) {
for (auto s : PackageSubffix) {
if (_wcsicmp(s, ext)) {
filelist.push_back(dropfile_name);
break;
}
}
}
if (!filelist.empty()) {
::SetWindowTextW(::GetDlgItem(m_hWnd, IDC_IMAGE_URI_EDIT), filelist[0].c_str());
if (PortableExecutableFileRander(filelist.at(0)) != S_OK) {
::MessageBoxW(m_hWnd, filelist.at(0).c_str(), L"Cannot analyzer this file", MB_OK | MB_ICONSTOP);
return S_FALSE;
}
}
}
DragFinish(hDrop);
::InvalidateRect(m_hWnd, NULL, TRUE);
return S_OK;
}
/***********************************************************************
* FD31_UpdateResult [internal]
* update the displayed file name (with path)
*/
static void FD31_UpdateResult(PFD31_DATA lfs, WCHAR *tmpstr)
{
int lenstr2;
LPOPENFILENAMEW ofnW = lfs->ofnW;
WCHAR tmpstr2[BUFFILE];
WCHAR *p;
TRACE("%s\n", debugstr_w(tmpstr));
if(ofnW->Flags & OFN_NOVALIDATE)
tmpstr2[0] = '\0';
else
GetCurrentDirectoryW(BUFFILE, tmpstr2);
lenstr2 = strlenW(tmpstr2);
if (lenstr2 > 3)
tmpstr2[lenstr2++]='\\';
lstrcpynW(tmpstr2+lenstr2, tmpstr, BUFFILE-lenstr2);
if (ofnW->lpstrFile)
lstrcpynW(ofnW->lpstrFile, tmpstr2, ofnW->nMaxFile);
/* set filename offset */
p = PathFindFileNameW(ofnW->lpstrFile);
ofnW->nFileOffset = (p - ofnW->lpstrFile);
/* set extension offset */
p = PathFindExtensionW(ofnW->lpstrFile);
ofnW->nFileExtension = (*p) ? (p - ofnW->lpstrFile) + 1 : 0;
TRACE("file %s, file offset %d, ext offset %d\n",
debugstr_w(ofnW->lpstrFile), ofnW->nFileOffset, ofnW->nFileExtension);
/* update the real client structures if any */
lfs->callbacks->UpdateResult(lfs);
}
/*************************************************************************
* PathFindExtension [SHELL32.31]
*/
LPVOID WINAPI PathFindExtensionAW(LPCVOID lpszPath)
{
if (SHELL_OsIsUnicode())
return PathFindExtensionW(lpszPath);
return PathFindExtensionA(lpszPath);
}
/*************************************************************************
* PathGetExtensionW [internal]
*/
static LPWSTR PathGetExtensionW(LPCWSTR lpszPath)
{
TRACE("(%s)\n",debugstr_w(lpszPath));
lpszPath = PathFindExtensionW(lpszPath);
return (LPWSTR)(*lpszPath?(lpszPath+1):lpszPath);
}
std::wstring DominoDocArtifact::GetFileExtension() const throw()
{
std::wstring fileName = (const wchar_t*)GetDocument()->FileName;
wchar_t* pszExtension = PathFindExtensionW(fileName.c_str());
if(pszExtension != 0)
pszExtension++; // skip the dot
else
pszExtension = L"";
return pszExtension;
}
std::shared_ptr<ISeekableSource> InputFactory::open(const wchar_t *path)
{
std::map<std::wstring, std::shared_ptr<ISeekableSource> >::iterator
pos = m_sources.find(path);
if (pos != m_sources.end())
return pos->second;
const wchar_t *ext = PathFindExtensionW(path);
std::shared_ptr<FILE> fp(win32::fopen(path, L"rb"));
if (m_is_raw) {
std::shared_ptr<RawSource> src =
std::make_shared<RawSource>(fp, m_raw_format);
m_sources[path] = src;
return src;
}
if (avisynth.loaded() && strutil::wslower(ext) == L".avs")
return std::make_shared<AvisynthSource>(avisynth, path);
#define TRY_MAKE_SHARED(type, ...) \
do { \
try { \
std::shared_ptr<type> src = \
std::make_shared<type>(__VA_ARGS__); \
m_sources[path] = src; \
return src; \
} catch (...) { \
_lseeki64(fileno(fp.get()), 0, SEEK_SET); \
} \
} while (0)
TRY_MAKE_SHARED(WaveSource, fp, m_ignore_length);
if (!win32::is_seekable(fileno(fp.get())))
throw std::runtime_error("Not available input file format");
if (libflac.loaded())
TRY_MAKE_SHARED(FLACSource, libflac, fp);
if (libwavpack.loaded())
TRY_MAKE_SHARED(WavpackSource, libwavpack, path);
if (libtak.loaded() && libtak.compatible())
TRY_MAKE_SHARED(TakSource, libtak, fp);
TRY_MAKE_SHARED(MP4Source, fp);
#ifdef QAAC
TRY_MAKE_SHARED(ExtAFSource, fp);
#endif
if (libsndfile.loaded())
TRY_MAKE_SHARED(LibSndfileSource, libsndfile, fp);
throw std::runtime_error("Not available input file format");
}
HRESULT WINAPI CRecycleBin::CompareIDs(LPARAM lParam, PCUIDLIST_RELATIVE pidl1, PCUIDLIST_RELATIVE pidl2)
{
PIDLRecycleStruct* pData1 = _ILGetRecycleStruct(pidl1);
PIDLRecycleStruct* pData2 = _ILGetRecycleStruct(pidl2);
LPWSTR pName1, pName2;
if(!pData1 || !pData2 || LOWORD(lParam) >= COLUMNS_COUNT)
return E_INVALIDARG;
SHORT result;
LONGLONG diff;
switch (LOWORD(lParam))
{
case 0: /* Name */
pName1 = PathFindFileNameW(pData1->szName);
pName2 = PathFindFileNameW(pData2->szName);
result = wcsicmp(pName1, pName2);
break;
case 1: /* Orig. Location */
result = wcsicmp(pData1->szName, pData2->szName);
break;
case 2: /* Date Deleted */
result = CompareFileTime(&pData1->DeletionTime, &pData2->DeletionTime);
break;
case 3: /* Size */
diff = pData1->FileSize.QuadPart - pData2->FileSize.QuadPart;
return MAKE_COMPARE_HRESULT(diff);
case 4: /* Type */
pName1 = PathFindExtensionW(pData1->szName);
pName2 = PathFindExtensionW(pData2->szName);
result = wcsicmp(pName1, pName2);
break;
case 5: /* Modified */
result = CompareFileTime(&pData1->LastModification, &pData2->LastModification);
break;
}
return MAKE_COMPARE_HRESULT(result);
}
BOOL
CFileDefExt::InitFileType(HWND hwndDlg)
{
TRACE("path %s\n", debugstr_w(m_wszPath));
HWND hDlgCtrl = GetDlgItem(hwndDlg, 14005);
if (hDlgCtrl == NULL)
return FALSE;
/* Get file information */
SHFILEINFO fi;
if (!SHGetFileInfoW(m_wszPath, 0, &fi, sizeof(fi), SHGFI_TYPENAME|SHGFI_ICON))
{
ERR("SHGetFileInfoW failed for %ls (%lu)\n", m_wszPath, GetLastError());
fi.szTypeName[0] = L'\0';
fi.hIcon = NULL;
}
LPCWSTR pwszExt = PathFindExtensionW(m_wszPath);
if (pwszExt[0])
{
WCHAR wszBuf[256];
if (!fi.szTypeName[0])
{
/* The file type is unknown, so default to string "FileExtension File" */
size_t cchRemaining = 0;
LPWSTR pwszEnd = NULL;
StringCchPrintfExW(wszBuf, _countof(wszBuf), &pwszEnd, &cchRemaining, 0, L"%s ", pwszExt + 1);
SendMessageW(hDlgCtrl, WM_GETTEXT, (WPARAM)cchRemaining, (LPARAM)pwszEnd);
SendMessageW(hDlgCtrl, WM_SETTEXT, (WPARAM)NULL, (LPARAM)wszBuf);
}
else
{
/* Update file type */
StringCbPrintfW(wszBuf, sizeof(wszBuf), L"%s (%s)", fi.szTypeName, pwszExt);
SendMessageW(hDlgCtrl, WM_SETTEXT, (WPARAM)NULL, (LPARAM)wszBuf);
}
}
/* Update file icon */
if (fi.hIcon)
SendDlgItemMessageW(hwndDlg, 14000, STM_SETICON, (WPARAM)fi.hIcon, 0);
else
ERR("No icon %ls\n", m_wszPath);
return TRUE;
}
bool CImageUtility::IsCanHandleFileCheckByExt(const std::wstring& wstrTempDirect)
{
wstring wstrExtName = PathFindExtensionW(wstrTempDirect.c_str());
if (wstrExtName.empty())
{
return false;
}
wstring lowerExtName = ultra::ToLower(wstrExtName);
lowerExtName.append(L";");
wstring wstrCanSuperBatchFileExtList = CanHandleFileExt;
if(wstrCanSuperBatchFileExtList.find(lowerExtName.c_str()) == wstring::npos)
{
return false;
}
return true;
}
HMODULE WINAPI HookLoadLibrary(LPCWSTR lpFileName)
{
LPCWSTR name = PathFindFileNameW(lpFileName);
LPCWSTR ext = PathFindExtensionW(name);
size_t length = ext - name;
// Load our own library again so the ref count is incremented.
if (wcsncmp(name, ovrModuleName, length) == 0)
return TrueLoadLibrary(revModuleName);
// We've already injected OpenVR, block attempts to override it.
if (wcsncmp(name, L"openvr_api.dll", length) == 0)
return NULL;
return TrueLoadLibrary(lpFileName);
}
/***********************************************************************
* URLDownloadToCacheFileW (URLMON.@)
*/
HRESULT WINAPI URLDownloadToCacheFileW(LPUNKNOWN lpUnkCaller, LPCWSTR szURL, LPWSTR szFileName,
DWORD dwBufLength, DWORD dwReserved, LPBINDSTATUSCALLBACK pBSC)
{
WCHAR cache_path[MAX_PATH + 1];
FILETIME expire, modified;
HRESULT hr;
LPWSTR ext;
static WCHAR header[] = {
'H','T','T','P','/','1','.','0',' ','2','0','0',' ',
'O','K','\\','r','\\','n','\\','r','\\','n',0
};
TRACE("(%p, %s, %p, %d, %d, %p)\n", lpUnkCaller, debugstr_w(szURL),
szFileName, dwBufLength, dwReserved, pBSC);
if (!szURL || !szFileName)
return E_INVALIDARG;
ext = PathFindExtensionW(szURL);
if (!CreateUrlCacheEntryW(szURL, 0, ext, cache_path, 0))
return E_FAIL;
hr = URLDownloadToFileW(lpUnkCaller, szURL, cache_path, 0, pBSC);
if (FAILED(hr))
return hr;
expire.dwHighDateTime = 0;
expire.dwLowDateTime = 0;
modified.dwHighDateTime = 0;
modified.dwLowDateTime = 0;
if (!CommitUrlCacheEntryW(szURL, cache_path, expire, modified, NORMAL_CACHE_ENTRY,
header, sizeof(header), NULL, NULL))
return E_FAIL;
if (strlenW(cache_path) > dwBufLength)
return E_OUTOFMEMORY;
lstrcpyW(szFileName, cache_path);
return S_OK;
}
static UINT
LoadPropSheetHandlers(LPCWSTR pwszPath, PROPSHEETHEADERW *pHeader, UINT cMaxPages, HPSXA *phpsxa, IDataObject *pDataObj)
{
WCHAR wszBuf[MAX_PATH];
UINT cPages = 0, i = 0;
LPWSTR pwszFilename = PathFindFileNameW(pwszPath);
BOOL bDir = PathIsDirectoryW(pwszPath);
if (bDir)
{
phpsxa[i] = SHCreatePropSheetExtArrayEx(HKEY_CLASSES_ROOT, L"Folder", cMaxPages - cPages, pDataObj);
cPages += SHAddFromPropSheetExtArray(phpsxa[i++], AddPropSheetPageCallback, (LPARAM)pHeader);
phpsxa[i] = SHCreatePropSheetExtArrayEx(HKEY_CLASSES_ROOT, L"Directory", cMaxPages - cPages, pDataObj);
cPages += SHAddFromPropSheetExtArray(phpsxa[i++], AddPropSheetPageCallback, (LPARAM)pHeader);
}
else
{
/* Load property sheet handlers from ext key */
LPWSTR pwszExt = PathFindExtensionW(pwszFilename);
phpsxa[i] = SHCreatePropSheetExtArrayEx(HKEY_CLASSES_ROOT, pwszExt, cMaxPages - cPages, pDataObj);
cPages += SHAddFromPropSheetExtArray(phpsxa[i++], AddPropSheetPageCallback, (LPARAM)pHeader);
/* Load property sheet handlers from prog id key */
DWORD cbBuf = sizeof(wszBuf);
if (RegGetValueW(HKEY_CLASSES_ROOT, pwszExt, L"", RRF_RT_REG_SZ, NULL, wszBuf, &cbBuf) == ERROR_SUCCESS)
{
TRACE("EnumPropSheetExt wszBuf %s, pwszExt %s\n", debugstr_w(wszBuf), debugstr_w(pwszExt));
phpsxa[i] = SHCreatePropSheetExtArrayEx(HKEY_CLASSES_ROOT, wszBuf, cMaxPages - cPages, pDataObj);
cPages += SHAddFromPropSheetExtArray(phpsxa[i++], AddPropSheetPageCallback, (LPARAM)pHeader);
}
/* Add property sheet handlers from "*" key */
phpsxa[i] = SHCreatePropSheetExtArrayEx(HKEY_CLASSES_ROOT, L"*", cMaxPages - cPages, pDataObj);
cPages += SHAddFromPropSheetExtArray(phpsxa[i++], AddPropSheetPageCallback, (LPARAM)pHeader);
}
return cPages;
}
static bool getWebLocData(IDataObject* dataObject, String& url, String* title)
{
bool succeeded = false;
#if PLATFORM(CF)
WCHAR filename[MAX_PATH];
WCHAR urlBuffer[INTERNET_MAX_URL_LENGTH];
STGMEDIUM medium;
if (FAILED(dataObject->GetData(cfHDropFormat(), &medium)))
return false;
HDROP hdrop = static_cast<HDROP>(GlobalLock(medium.hGlobal));
if (!hdrop)
return false;
if (!DragQueryFileW(hdrop, 0, filename, ARRAYSIZE(filename)))
goto exit;
if (_wcsicmp(PathFindExtensionW(filename), L".url"))
goto exit;
if (!GetPrivateProfileStringW(L"InternetShortcut", L"url", 0, urlBuffer, ARRAYSIZE(urlBuffer), filename))
goto exit;
if (title) {
PathRemoveExtension(filename);
*title = String((UChar*)filename);
}
url = String((UChar*)urlBuffer);
succeeded = true;
exit:
// Free up memory.
DragFinish(hdrop);
GlobalUnlock(medium.hGlobal);
#endif
return succeeded;
}
HMODULE WINAPI HookLoadLibrary(LPCWSTR lpFileName)
{
LPCWSTR name = PathFindFileNameW(lpFileName);
LPCWSTR ext = PathFindExtensionW(name);
size_t length = ext - name;
// Load our own library again so the ref count is incremented.
if (wcsncmp(name, ovrModuleName, length) == 0)
return TrueLoadLibrary(revModuleName);
// The following functions will patch the module, so we have to load it here.
HMODULE module = TrueLoadLibrary(lpFileName);
// Patch the export table of Oculus Platform to point to our entitlement functions.
if (wcsncmp(name, ovrPlatformName, length) == 0)
{
TrueIsError = (_IsError)DetourEATptr("ovr_Message_IsError", ovr_Message_IsError, module);
DetourEATptr("ovr_IsEntitled", ovr_IsEntitled, module);
}
return module;
}
BOOL CNetInstall::CheckFile(LPCWSTR lpszPath, tagFileInfo* pInfo)
{
BOOL bRet = FALSE;
if (StrCmpIW(PathFindExtensionW(lpszPath), L".cia"))
{
return FALSE;
}
HANDLE hFile = CreateFileW(lpszPath, FILE_READ_ATTRIBUTES, FILE_SHARE_READ, 0, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
if (hFile != INVALID_HANDLE_VALUE)
{
LARGE_INTEGER LargeInt;
if (GetFileSizeEx(hFile, &LargeInt))
{
if (pInfo)
{
pInfo->uFileSize = LargeInt.QuadPart;
pInfo->strPath = lpszPath;
bRet = TRUE;
}
}
CloseHandle(hFile);
}
return bRet;
}
/*************************************************************************
* SHGetFileInfoW [SHELL32.@]
*
*/
DWORD_PTR WINAPI SHGetFileInfoW(LPCWSTR path,DWORD dwFileAttributes,
SHFILEINFOW *psfi, UINT sizeofpsfi, UINT flags )
{
WCHAR szLocation[MAX_PATH], szFullPath[MAX_PATH];
int iIndex;
DWORD_PTR ret = TRUE;
DWORD dwAttributes = 0;
IShellFolder * psfParent = NULL;
IExtractIconW * pei = NULL;
LPITEMIDLIST pidlLast = NULL, pidl = NULL;
HRESULT hr = S_OK;
BOOL IconNotYetLoaded=TRUE;
UINT uGilFlags = 0;
HIMAGELIST big_icons, small_icons;
TRACE("%s fattr=0x%x sfi=%p(attr=0x%08x) size=0x%x flags=0x%x\n",
(flags & SHGFI_PIDL)? "pidl" : debugstr_w(path), dwFileAttributes,
psfi, psfi->dwAttributes, sizeofpsfi, flags);
if (!path)
return FALSE;
/* windows initializes these values regardless of the flags */
if (psfi != NULL)
{
psfi->szDisplayName[0] = '\0';
psfi->szTypeName[0] = '\0';
psfi->iIcon = 0;
}
if (!(flags & SHGFI_PIDL))
{
/* SHGetFileInfo should work with absolute and relative paths */
if (PathIsRelativeW(path))
{
GetCurrentDirectoryW(MAX_PATH, szLocation);
PathCombineW(szFullPath, szLocation, path);
}
else
{
lstrcpynW(szFullPath, path, MAX_PATH);
}
}
if (flags & SHGFI_EXETYPE)
{
if (flags != SHGFI_EXETYPE)
return 0;
return shgfi_get_exe_type(szFullPath);
}
/*
* psfi is NULL normally to query EXE type. If it is NULL, none of the
* below makes sense anyway. Windows allows this and just returns FALSE
*/
if (psfi == NULL)
return FALSE;
/*
* translate the path into a pidl only when SHGFI_USEFILEATTRIBUTES
* is not specified.
* The pidl functions fail on not existing file names
*/
if (flags & SHGFI_PIDL)
{
pidl = ILClone((LPCITEMIDLIST)path);
}
else if (!(flags & SHGFI_USEFILEATTRIBUTES))
{
hr = SHILCreateFromPathW(szFullPath, &pidl, &dwAttributes);
}
if ((flags & SHGFI_PIDL) || !(flags & SHGFI_USEFILEATTRIBUTES))
{
/* get the parent shellfolder */
if (pidl)
{
hr = SHBindToParent( pidl, &IID_IShellFolder, (LPVOID*)&psfParent,
(LPCITEMIDLIST*)&pidlLast );
if (SUCCEEDED(hr))
pidlLast = ILClone(pidlLast);
ILFree(pidl);
}
else
{
ERR("pidl is null!\n");
return FALSE;
}
}
/* get the attributes of the child */
if (SUCCEEDED(hr) && (flags & SHGFI_ATTRIBUTES))
{
if (!(flags & SHGFI_ATTR_SPECIFIED))
{
psfi->dwAttributes = 0xffffffff;
}
if (psfParent)
IShellFolder_GetAttributesOf( psfParent, 1, (LPCITEMIDLIST*)&pidlLast,
&(psfi->dwAttributes) );
}
/* get the displayname */
if (SUCCEEDED(hr) && (flags & SHGFI_DISPLAYNAME))
{
if (flags & SHGFI_USEFILEATTRIBUTES && !(flags & SHGFI_PIDL))
{
lstrcpyW (psfi->szDisplayName, PathFindFileNameW(szFullPath));
}
else
{
STRRET str;
hr = IShellFolder_GetDisplayNameOf( psfParent, pidlLast,
SHGDN_INFOLDER, &str);
StrRetToStrNW (psfi->szDisplayName, MAX_PATH, &str, pidlLast);
}
}
/* get the type name */
if (SUCCEEDED(hr) && (flags & SHGFI_TYPENAME))
{
static const WCHAR szFile[] = { 'F','i','l','e',0 };
static const WCHAR szDashFile[] = { '-','f','i','l','e',0 };
if (!(flags & SHGFI_USEFILEATTRIBUTES) || (flags & SHGFI_PIDL))
{
char ftype[80];
_ILGetFileType(pidlLast, ftype, 80);
MultiByteToWideChar(CP_ACP, 0, ftype, -1, psfi->szTypeName, 80 );
}
else
{
if (dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
strcatW (psfi->szTypeName, szFile);
else
{
WCHAR sTemp[64];
lstrcpyW(sTemp,PathFindExtensionW(szFullPath));
if (!( HCR_MapTypeToValueW(sTemp, sTemp, 64, TRUE) &&
HCR_MapTypeToValueW(sTemp, psfi->szTypeName, 80, FALSE )))
{
lstrcpynW (psfi->szTypeName, sTemp, 64);
strcatW (psfi->szTypeName, szDashFile);
}
}
}
}
/* ### icons ###*/
Shell_GetImageLists( &big_icons, &small_icons );
if (flags & SHGFI_OPENICON)
uGilFlags |= GIL_OPENICON;
if (flags & SHGFI_LINKOVERLAY)
uGilFlags |= GIL_FORSHORTCUT;
else if ((flags&SHGFI_ADDOVERLAYS) ||
(flags&(SHGFI_ICON|SHGFI_SMALLICON))==SHGFI_ICON)
{
if (SHELL_IsShortcut(pidlLast))
uGilFlags |= GIL_FORSHORTCUT;
}
if (flags & SHGFI_OVERLAYINDEX)
FIXME("SHGFI_OVERLAYINDEX unhandled\n");
if (flags & SHGFI_SELECTED)
FIXME("set icon to selected, stub\n");
if (flags & SHGFI_SHELLICONSIZE)
FIXME("set icon to shell size, stub\n");
/* get the iconlocation */
if (SUCCEEDED(hr) && (flags & SHGFI_ICONLOCATION ))
{
UINT uDummy,uFlags;
if (flags & SHGFI_USEFILEATTRIBUTES && !(flags & SHGFI_PIDL))
{
if (dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
{
lstrcpyW(psfi->szDisplayName, swShell32Name);
psfi->iIcon = -IDI_SHELL_FOLDER;
}
else
{
WCHAR* szExt;
static const WCHAR p1W[] = {'%','1',0};
WCHAR sTemp [MAX_PATH];
szExt = PathFindExtensionW(szFullPath);
TRACE("szExt=%s\n", debugstr_w(szExt));
if ( szExt &&
HCR_MapTypeToValueW(szExt, sTemp, MAX_PATH, TRUE) &&
HCR_GetDefaultIconW(sTemp, sTemp, MAX_PATH, &psfi->iIcon))
{
if (lstrcmpW(p1W, sTemp))
strcpyW(psfi->szDisplayName, sTemp);
else
{
/* the icon is in the file */
strcpyW(psfi->szDisplayName, szFullPath);
}
}
else
ret = FALSE;
}
}
else
{
hr = IShellFolder_GetUIObjectOf(psfParent, 0, 1,
(LPCITEMIDLIST*)&pidlLast, &IID_IExtractIconW,
&uDummy, (LPVOID*)&pei);
if (SUCCEEDED(hr))
{
hr = IExtractIconW_GetIconLocation(pei, uGilFlags,
szLocation, MAX_PATH, &iIndex, &uFlags);
if (uFlags & GIL_NOTFILENAME)
ret = FALSE;
else
{
lstrcpyW (psfi->szDisplayName, szLocation);
psfi->iIcon = iIndex;
}
IExtractIconW_Release(pei);
}
}
}
/* get icon index (or load icon)*/
if (SUCCEEDED(hr) && (flags & (SHGFI_ICON | SHGFI_SYSICONINDEX)))
{
if (flags & SHGFI_USEFILEATTRIBUTES && !(flags & SHGFI_PIDL))
{
WCHAR sTemp [MAX_PATH];
WCHAR * szExt;
int icon_idx=0;
lstrcpynW(sTemp, szFullPath, MAX_PATH);
if (dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
psfi->iIcon = SIC_GetIconIndex(swShell32Name, -IDI_SHELL_FOLDER, 0);
else
{
static const WCHAR p1W[] = {'%','1',0};
psfi->iIcon = 0;
szExt = PathFindExtensionW(sTemp);
if ( szExt &&
HCR_MapTypeToValueW(szExt, sTemp, MAX_PATH, TRUE) &&
HCR_GetDefaultIconW(sTemp, sTemp, MAX_PATH, &icon_idx))
{
if (!lstrcmpW(p1W,sTemp)) /* icon is in the file */
strcpyW(sTemp, szFullPath);
if (flags & SHGFI_SYSICONINDEX)
{
psfi->iIcon = SIC_GetIconIndex(sTemp,icon_idx,0);
if (psfi->iIcon == -1)
psfi->iIcon = 0;
}
else
{
UINT ret;
if (flags & SHGFI_SMALLICON)
ret = PrivateExtractIconsW( sTemp,icon_idx,
GetSystemMetrics( SM_CXSMICON ),
GetSystemMetrics( SM_CYSMICON ),
&psfi->hIcon, 0, 1, 0);
else
ret = PrivateExtractIconsW( sTemp, icon_idx,
GetSystemMetrics( SM_CXICON),
GetSystemMetrics( SM_CYICON),
&psfi->hIcon, 0, 1, 0);
if (ret != 0 && ret != (UINT)-1)
{
IconNotYetLoaded=FALSE;
psfi->iIcon = icon_idx;
}
}
}
}
}
else
{
if (!(PidlToSicIndex(psfParent, pidlLast, !(flags & SHGFI_SMALLICON),
uGilFlags, &(psfi->iIcon))))
{
ret = FALSE;
}
}
if (ret && (flags & SHGFI_SYSICONINDEX))
{
if (flags & SHGFI_SMALLICON)
ret = (DWORD_PTR)small_icons;
else
ret = (DWORD_PTR)big_icons;
}
}
/* icon handle */
if (SUCCEEDED(hr) && (flags & SHGFI_ICON) && IconNotYetLoaded)
{
if (flags & SHGFI_SMALLICON)
psfi->hIcon = ImageList_GetIcon( small_icons, psfi->iIcon, ILD_NORMAL);
else
psfi->hIcon = ImageList_GetIcon( big_icons, psfi->iIcon, ILD_NORMAL);
}
if (flags & ~SHGFI_KNOWN_FLAGS)
FIXME("unknown flags %08x\n", flags & ~SHGFI_KNOWN_FLAGS);
if (psfParent)
IShellFolder_Release(psfParent);
if (hr != S_OK)
ret = FALSE;
SHFree(pidlLast);
TRACE ("icon=%p index=0x%08x attr=0x%08x name=%s type=%s ret=0x%08lx\n",
psfi->hIcon, psfi->iIcon, psfi->dwAttributes,
debugstr_w(psfi->szDisplayName), debugstr_w(psfi->szTypeName), ret);
return ret;
}
/*************************************************************************
* FM_InitMenuPopup [internal]
*
*/
static int FM_InitMenuPopup(HMENU hmenu, LPCITEMIDLIST pAlternatePidl)
{ IShellFolder *lpsf, *lpsf2;
ULONG ulItemAttr = SFGAO_FOLDER;
UINT uID, uEnumFlags;
LPFNFMCALLBACK lpfnCallback;
LPCITEMIDLIST pidl;
WCHAR sTemp[MAX_PATH];
int NumberOfItems = 0, iIcon;
MENUINFO MenuInfo;
LPFMINFO menudata;
TRACE("%p %p\n", hmenu, pAlternatePidl);
MenuInfo.cbSize = sizeof(MENUINFO);
MenuInfo.fMask = MIM_MENUDATA;
if (! GetMenuInfo(hmenu, &MenuInfo))
return FALSE;
menudata = (LPFMINFO)MenuInfo.dwMenuData;
if ((menudata == 0) || (MenuInfo.cbSize != sizeof(MENUINFO)))
{
ERR("menudata corrupt: %p %u\n", menudata, MenuInfo.cbSize);
return 0;
}
if (menudata->bInitialized)
return 0;
pidl = (pAlternatePidl? pAlternatePidl: menudata->pidl);
if (!pidl)
return 0;
uID = menudata->uID;
uEnumFlags = menudata->uEnumFlags;
lpfnCallback = menudata->lpfnCallback;
menudata->bInitialized = FALSE;
SetMenuInfo(hmenu, &MenuInfo);
if (SUCCEEDED (SHGetDesktopFolder(&lpsf)))
{
if (SUCCEEDED(IShellFolder_BindToObject(lpsf, pidl,0,(REFIID)&IID_IShellFolder,(LPVOID *)&lpsf2)))
{
IEnumIDList *lpe = NULL;
if (SUCCEEDED (IShellFolder_EnumObjects(lpsf2, 0, uEnumFlags, &lpe )))
{
LPITEMIDLIST pidlTemp = NULL;
ULONG ulFetched;
while ((!bAbortInit) && (NOERROR == IEnumIDList_Next(lpe,1,&pidlTemp,&ulFetched)))
{
if (SUCCEEDED (IShellFolder_GetAttributesOf(lpsf, 1, (LPCITEMIDLIST*)&pidlTemp, &ulItemAttr)))
{
ILGetDisplayNameExW(NULL, pidlTemp, sTemp, ILGDN_FORPARSING);
if (! (PidlToSicIndex(lpsf, pidlTemp, FALSE, 0, &iIcon)))
iIcon = FM_BLANK_ICON;
if ( SFGAO_FOLDER & ulItemAttr)
{
LPFMINFO lpFmMi;
MENUINFO MenuInfo;
HMENU hMenuPopup = CreatePopupMenu();
lpFmMi = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(FMINFO));
lpFmMi->pidl = ILCombine(pidl, pidlTemp);
lpFmMi->uEnumFlags = SHCONTF_FOLDERS | SHCONTF_NONFOLDERS;
MenuInfo.cbSize = sizeof(MENUINFO);
MenuInfo.fMask = MIM_MENUDATA;
MenuInfo.dwMenuData = (ULONG_PTR) lpFmMi;
SetMenuInfo (hMenuPopup, &MenuInfo);
FileMenu_AppendItemW (hmenu, sTemp, uID, iIcon, hMenuPopup, FM_DEFAULT_HEIGHT);
}
else
{
LPWSTR pExt = PathFindExtensionW(sTemp);
if (pExt)
*pExt = 0;
FileMenu_AppendItemW (hmenu, sTemp, uID, iIcon, 0, FM_DEFAULT_HEIGHT);
}
}
if (lpfnCallback)
{
TRACE("enter callback\n");
lpfnCallback ( pidl, pidlTemp);
TRACE("leave callback\n");
}
NumberOfItems++;
}
IEnumIDList_Release (lpe);
}
IShellFolder_Release(lpsf2);
}
IShellFolder_Release(lpsf);
}
if ( GetMenuItemCount (hmenu) == 0 )
{
static const WCHAR szEmpty[] = { '(','e','m','p','t','y',')',0 };
FileMenu_AppendItemW (hmenu, szEmpty, uID, FM_BLANK_ICON, 0, FM_DEFAULT_HEIGHT);
NumberOfItems++;
}
menudata->bInitialized = TRUE;
SetMenuInfo(hmenu, &MenuInfo);
return NumberOfItems;
}
/*
010509 Carl Corcoran
*/
int CCString::Path_FindExtension()
{
return PathFindExtensionW(this->wszString) - this->wszString;
}
/**************************************************************************
* ISF_Desktop_fnSetNameOf
* Changes the name of a file object or subfolder, possibly changing its item
* identifier in the process.
*
* PARAMETERS
* HWND hwndOwner, //[in ] Owner window for output
* LPCITEMIDLIST pidl, //[in ] simple pidl of item to change
* LPCOLESTR lpszName, //[in ] the items new display name
* DWORD dwFlags, //[in ] SHGNO formatting flags
* LPITEMIDLIST* ppidlOut) //[out] simple pidl returned
*/
static HRESULT WINAPI ISF_Desktop_fnSetNameOf (IShellFolder2 * iface,
HWND hwndOwner, LPCITEMIDLIST pidl, /* simple pidl */
LPCOLESTR lpName, DWORD dwFlags, LPITEMIDLIST * pPidlOut)
{
IGenericSFImpl *This = (IGenericSFImpl *)iface;
IShellFolder2 * psf;
HRESULT hr;
WCHAR szSrc[MAX_PATH + 1], szDest[MAX_PATH + 1];
LPWSTR ptr;
BOOL bIsFolder = _ILIsFolder (ILFindLastID (pidl));
TRACE ("(%p)->(%p,pidl=%p,%s,%u,%p)\n", This, hwndOwner, pidl,
debugstr_w (lpName), dwFlags, pPidlOut);
if (_ILGetGUIDPointer(pidl))
{
if (SUCCEEDED(IShellFolder2_BindToObject(iface, pidl, NULL, &IID_IShellFolder2, (LPVOID*)&psf)))
{
hr = IShellFolder2_SetNameOf(psf, hwndOwner, pidl, lpName, dwFlags, pPidlOut);
IShellFolder2_Release(psf);
return hr;
}
}
/* build source path */
lstrcpynW(szSrc, This->sPathTarget, MAX_PATH);
ptr = PathAddBackslashW (szSrc);
if (ptr)
_ILSimpleGetTextW (pidl, ptr, MAX_PATH + 1 - (ptr - szSrc));
/* build destination path */
if (dwFlags == SHGDN_NORMAL || dwFlags & SHGDN_INFOLDER) {
lstrcpynW(szDest, This->sPathTarget, MAX_PATH);
ptr = PathAddBackslashW (szDest);
if (ptr)
lstrcpynW(ptr, lpName, MAX_PATH + 1 - (ptr - szDest));
} else
lstrcpynW(szDest, lpName, MAX_PATH);
if(!(dwFlags & SHGDN_FORPARSING) && SHELL_FS_HideExtension(szSrc)) {
WCHAR *ext = PathFindExtensionW(szSrc);
if(*ext != '\0') {
INT len = wcslen(szDest);
lstrcpynW(szDest + len, ext, MAX_PATH - len);
}
}
if (!memcmp(szSrc, szDest, (wcslen(szDest)+1) * sizeof(WCHAR)))
{
/* src and destination is the same */
hr = S_OK;
if (pPidlOut)
hr = _ILCreateFromPathW(szDest, pPidlOut);
return hr;
}
TRACE ("src=%s dest=%s\n", debugstr_w(szSrc), debugstr_w(szDest));
if (MoveFileW (szSrc, szDest))
{
hr = S_OK;
if (pPidlOut)
hr = _ILCreateFromPathW(szDest, pPidlOut);
SHChangeNotify (bIsFolder ? SHCNE_RENAMEFOLDER : SHCNE_RENAMEITEM,
SHCNF_PATHW, szSrc, szDest);
return hr;
}
return E_FAIL;
}
VOID
CFileDefExt::InitOpensWithField(HWND hwndDlg)
{
WCHAR wszBuf[MAX_PATH] = L"";
WCHAR wszPath[MAX_PATH] = L"";
DWORD dwSize = sizeof(wszBuf);
BOOL bUnknownApp = TRUE;
LPCWSTR pwszExt = PathFindExtensionW(m_wszPath);
if (RegGetValueW(HKEY_CLASSES_ROOT, pwszExt, L"", RRF_RT_REG_SZ, NULL, wszBuf, &dwSize) == ERROR_SUCCESS)
{
bUnknownApp = FALSE;
StringCbCatW(wszBuf, sizeof(wszBuf), L"\\shell\\open\\command");
dwSize = sizeof(wszPath);
if (RegGetValueW(HKEY_CLASSES_ROOT, wszBuf, L"", RRF_RT_REG_SZ, NULL, wszPath, &dwSize) == ERROR_SUCCESS)
{
/* Get path from command line */
ExpandEnvironmentStringsW(wszPath, wszBuf, _countof(wszBuf));
PathRemoveArgs(wszBuf);
PathUnquoteSpacesW(wszBuf);
PathSearchAndQualify(wszBuf, wszPath, _countof(wszPath));
HICON hIcon;
if (ExtractIconExW(wszPath, 0, NULL, &hIcon, 1))
{
HWND hIconCtrl = GetDlgItem(hwndDlg, 14025);
HWND hDescrCtrl = GetDlgItem(hwndDlg, 14007);
ShowWindow(hIconCtrl, SW_SHOW);
RECT rcIcon, rcDescr;
GetWindowRect(hIconCtrl, &rcIcon);
if (rcIcon.left == rcIcon.right)
ERR("Icon control has invalid width: %d-%d\n", rcIcon.left, rcIcon.right);
MapWindowPoints(NULL, hwndDlg, (LPPOINT)&rcIcon, 2);
GetWindowRect(hDescrCtrl, &rcDescr);
MapWindowPoints(NULL, hwndDlg, (LPPOINT)&rcDescr, 2);
INT cxOffset = rcIcon.right + 2 - rcDescr.left;
SetWindowPos(hDescrCtrl, NULL,
rcDescr.left + cxOffset, rcDescr.top,
rcDescr.right - rcDescr.left - cxOffset, rcDescr.bottom - rcDescr.top,
SWP_NOZORDER);
SendMessageW(hIconCtrl, STM_SETICON, (WPARAM)hIcon, 0);
} else
ERR("Failed to extract icon\n");
if (PathFileExistsW(wszPath))
{
/* Get file description */
CFileVersionInfo VerInfo;
VerInfo.Load(wszPath);
LPCWSTR pwszDescr = VerInfo.GetString(L"FileDescription");
if (pwszDescr)
SetDlgItemTextW(hwndDlg, 14007, pwszDescr);
else
{
/* File has no description - display filename */
LPWSTR pwszFilename = PathFindFileNameW(wszPath);
PathRemoveExtension(pwszFilename);
pwszFilename[0] = towupper(pwszFilename[0]);
SetDlgItemTextW(hwndDlg, 14007, pwszFilename);
}
}
else
bUnknownApp = TRUE;
} else
WARN("RegGetValueW %ls failed\n", wszBuf);
} else
WARN("RegGetValueW %ls failed\n", pwszExt);
if (bUnknownApp)
{
/* Unknown application */
LoadStringW(shell32_hInstance, IDS_UNKNOWN_APP, wszBuf, _countof(wszBuf));
SetDlgItemTextW(hwndDlg, 14007, wszBuf);
}
}
static void on_theme_install(HWND dialog)
{
static const WCHAR filterMask[] = {0,'*','.','m','s','s','t','y','l','e','s',';',
'*','.','t','h','e','m','e',0,0};
static const WCHAR themeExt[] = {'.','T','h','e','m','e',0};
const int filterMaskLen = sizeof(filterMask)/sizeof(filterMask[0]);
OPENFILENAMEW ofn;
WCHAR filetitle[MAX_PATH];
WCHAR file[MAX_PATH];
WCHAR filter[100];
WCHAR title[100];
LoadStringW (GetModuleHandleW(NULL), IDS_THEMEFILE,
filter, sizeof (filter) / sizeof (filter[0]) - filterMaskLen);
memcpy (filter + lstrlenW (filter), filterMask,
filterMaskLen * sizeof (WCHAR));
LoadStringW (GetModuleHandleW(NULL), IDS_THEMEFILE_SELECT,
title, sizeof (title) / sizeof (title[0]));
ofn.lStructSize = sizeof(OPENFILENAMEW);
ofn.hwndOwner = dialog;
ofn.hInstance = 0;
ofn.lpstrFilter = filter;
ofn.lpstrCustomFilter = NULL;
ofn.nMaxCustFilter = 0;
ofn.nFilterIndex = 0;
ofn.lpstrFile = file;
ofn.lpstrFile[0] = '\0';
ofn.nMaxFile = sizeof(file)/sizeof(filetitle[0]);
ofn.lpstrFileTitle = filetitle;
ofn.lpstrFileTitle[0] = '\0';
ofn.nMaxFileTitle = sizeof(filetitle)/sizeof(filetitle[0]);
ofn.lpstrInitialDir = NULL;
ofn.lpstrTitle = title;
ofn.Flags = OFN_FILEMUSTEXIST | OFN_PATHMUSTEXIST | OFN_HIDEREADONLY | OFN_ENABLESIZING;
ofn.nFileOffset = 0;
ofn.nFileExtension = 0;
ofn.lpstrDefExt = NULL;
ofn.lCustData = 0;
ofn.lpfnHook = NULL;
ofn.lpTemplateName = NULL;
if (GetOpenFileNameW(&ofn))
{
static const WCHAR themesSubdir[] = { '\\','T','h','e','m','e','s',0 };
static const WCHAR backslash[] = { '\\',0 };
WCHAR themeFilePath[MAX_PATH];
SHFILEOPSTRUCTW shfop;
if (FAILED (SHGetFolderPathW (NULL, CSIDL_RESOURCES|CSIDL_FLAG_CREATE, NULL,
SHGFP_TYPE_CURRENT, themeFilePath))) return;
if (lstrcmpiW(PathFindExtensionW(filetitle), themeExt)==0)
{
do_parse_theme(file);
SendMessageW(GetParent(dialog), PSM_CHANGED, 0, 0);
return;
}
PathRemoveExtensionW (filetitle);
/* Construct path into which the theme file goes */
lstrcatW (themeFilePath, themesSubdir);
lstrcatW (themeFilePath, backslash);
lstrcatW (themeFilePath, filetitle);
/* Create the directory */
SHCreateDirectoryExW (dialog, themeFilePath, NULL);
/* Append theme file name itself */
lstrcatW (themeFilePath, backslash);
lstrcatW (themeFilePath, PathFindFileNameW (file));
/* SHFileOperation() takes lists as input, so double-nullterminate */
themeFilePath[lstrlenW (themeFilePath)+1] = 0;
file[lstrlenW (file)+1] = 0;
/* Do the copying */
WINE_TRACE("copying: %s -> %s\n", wine_dbgstr_w (file),
wine_dbgstr_w (themeFilePath));
shfop.hwnd = dialog;
shfop.wFunc = FO_COPY;
shfop.pFrom = file;
shfop.pTo = themeFilePath;
shfop.fFlags = FOF_NOCONFIRMMKDIR;
if (SHFileOperationW (&shfop) == 0)
{
scan_theme_files();
if (!fill_theme_list (GetDlgItem (dialog, IDC_THEME_THEMECOMBO),
GetDlgItem (dialog, IDC_THEME_COLORCOMBO),
GetDlgItem (dialog, IDC_THEME_SIZECOMBO)))
{
SendMessageW (GetDlgItem (dialog, IDC_THEME_COLORCOMBO), CB_SETCURSEL, -1, 0);
SendMessageW (GetDlgItem (dialog, IDC_THEME_SIZECOMBO), CB_SETCURSEL, -1, 0);
enable_size_and_color_controls (dialog, FALSE);
}
else
{
enable_size_and_color_controls (dialog, TRUE);
}
}
else
WINE_TRACE("copy operation failed\n");
}
else WINE_TRACE("user cancelled\n");
}
// Loads the IShellLibrary interface for the specified item, calls the derived class to perform an operation on
// the library, and commits/saves any changes as needed.
HRESULT v_ExecuteCommand()
{
HRESULT hr;
if (_fCreate)
{
// If we're in 'create' mode, instantiate a new IShellLibrary in memory.
hr = SHCreateLibrary(IID_PPV_ARGS(&_plib));
}
else
{
// Otherwise, load it from the specified IShellItem.
const DWORD grfMode = _fReadOnly ? (STGM_READ | STGM_SHARE_DENY_WRITE) : (STGM_READWRITE | STGM_SHARE_EXCLUSIVE);
hr = SHLoadLibraryFromItem(_psiLibrary, grfMode, IID_PPV_ARGS(&_plib));
}
if (SUCCEEDED(hr))
{
// Call the derived class to execute the operation on the library.
hr = v_ExecuteLibCommand();
if (SUCCEEDED(hr) && !_fReadOnly)
{
if (_fCreate)
{
// We created a new library in memory; now save it to disk.
// The IShellLibrary::Save API takes the destination in the form of the parent folder, and the name
// of the library (without any file extension). However, the argument is in the form of a full file
// system path, possibly including the extension. So, we need to parse it into that form. For example:
// "C:\some\folder\stuff.library-ms" => "C:\some\folder", "stuff"
PWSTR pszName = PathFindFileNameW(_pszSavePath);
if (StrCmpICW(PathFindExtensionW(pszName), L".library-ms") == 0)
{
PathRemoveExtensionW(pszName);
}
PathRemoveFileSpec(_pszSavePath);
// Save the library with the specified name in the specified folder.
PWSTR pszSavedToPath;
hr = SHSaveLibraryInFolderPath(_plib, _pszSavePath, pszName, _lsfSaveOptions, &pszSavedToPath);
if (SUCCEEDED(hr))
{
// The API returns the full file system path that the library was saved to.
// (This may or may not match the original argument, depending on whether LSF_MAKEUNIQUENAME was specified.)
Output(L"Library saved to path: %s\n", pszSavedToPath);
CoTaskMemFree(pszSavedToPath);
}
else
{
RuntimeError(L"Error %#08x saving library to path: %s\\%s.library-ms\n", hr, _pszSavePath, pszName);
}
}
else
{
// We're operating on an existing library; commit the changes to disk.
hr = _plib->Commit();
if (SUCCEEDED(hr))
{
Output(L"Changes successfully committed.\n");
}
}
}
}
else
{
RuntimeError(L"Error %#08x loading library from path: %s\n", hr, _pszSavePath);
}
return hr;
}
