/* ANT_DIRECTORY_ITERATOR_RECURSIVE::NEXT_MATCH_WILDCARD() ------------------------------------------------------- */ char *ANT_directory_iterator_recursive::next_match_wildcard(void) { #ifdef _MSC_VER ANT_disk_directory *current_file_list; size_t path_length; while (get_next_candidate()) { if (internals->file_data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) { if (!(strcmp(internals->file_data.cFileName, ".") == 0 || strcmp(internals->file_data.cFileName, "..") == 0)) { current_file_list = file_list; push_directory(); path_length = strlen(current_file_list->path) - 4; sprintf(file_list->path, "%*.*s/%s/*.*", (int)path_length, (int)path_length, current_file_list->path, internals->file_data.cFileName); } } else if (PathMatchSpec(internals->file_data.cFileName, wildcard)) return internals->file_data.cFileName; } return NULL; #else char *file; long match = FALSE, at_end = 1; while (!match) { if (at_end == 0 || file_list->glob_index >= file_list->matching_files.gl_pathc) { globfree(&file_list->matching_files); if (pop_directory()) { file_list->glob_index++; return next_match_wildcard(); } else return NULL; } // check if the matching path is a directory else if (file_list->matching_files.gl_pathv[file_list->glob_index][strlen(file_list->matching_files.gl_pathv[file_list->glob_index]) - 1] == '/') { if (true) { /* tmp is here as push_directory() will trash current file_list*/ char *tmp=file_list->matching_files.gl_pathv[file_list->glob_index]; push_directory(); if ((file = first_match_wildcard(tmp)) != NULL) return file; } } else if ((match = PathMatchSpec(file_list->matching_files.gl_pathv[file_list->glob_index], wildcard)) != 0) break; at_end = !(file_list->glob_index++ == file_list->matching_files.gl_pathc); } return file_list->matching_files.gl_pathv[file_list->glob_index++]; #endif }
__inline void CFileBase::FileBackup(const SYSTEMTIME &Time) { if (NULL == m_pFileHandle) return; if (m_sLastTime.wDay != Time.wDay) { CString strValue[2]; if (!GetFileName(Time, 1, strValue[0], strValue[1])) return; CString strFileName = GetFileName(); ATLASSERT(strFileName.GetLength() != 0); CString strMatchName = strValue[0] + strValue[1]; if (!PathMatchSpec(strFileName, strMatchName)) { m_iBkCount = -1; CloseFile(); } } else if (m_iFileSize > m_iMaxFileSize) { CloseFile(); AdjustFileName(Time); } }
__inline BOOL CFileBase::GetFileName(const SYSTEMTIME &Time, CString &strFileName) { CString strName[2]; if (m_strFileName.GetLength() != 0) { GetFileName(Time, 1, strName[0], strName[1]); if (PathMatchSpec(m_strFileName, strName[0] + strName[1])) { strFileName = m_strFileName; return TRUE; } } CFileSearcher Searcher; if (Searcher.Search(this, Time, strFileName)) return TRUE; GetFileName(Time, 0, strName[0], strName[1]); if (CreateFolder(strName[0])) { strFileName = strName[0] + strName[1]; return TRUE; } return FALSE; }
bool Directory::read(std::string& name, bool& isDir) { if(!dp) return false; for(;;) { struct dirent* dent = readdir((DIR*)dp); if(!dent) { closedir((DIR*)dp); dp = 0; return false; } #ifdef WINDOWS if(PathMatchSpec(dent->d_name, filepattern.c_str())) #else if(fnmatch(filepattern.c_str(), dent->d_name, 0) == 0) #endif { name = dirname + "/" + dent->d_name; isDir = false; struct stat buff; if(stat(name.c_str(), &buff) == 0) if(S_ISDIR(buff.st_mode)) isDir = true; return true; } } return false; // unreachable }
bool PatchFilesResourceSource::ReadNextEntry(ResourceTypeFlags typeFlags, IteratorState &state, ResourceMapEntryAgnostic &entry, std::vector<uint8_t> *optionalRawData) { if (_stillMore && (_hFind == INVALID_HANDLE_VALUE)) { _hFind = FindFirstFile(_gameFolderSpec.c_str(), &_findData); } _stillMore = _stillMore && (_hFind != INVALID_HANDLE_VALUE); bool foundOne = false; while (_stillMore && !foundOne) { if (PathMatchSpec(_findData.cFileName, g_szResourceSpec)) { int number = ResourceNumberFromFileName(_findData.cFileName); if (number != -1) { // We need a valid number. // We do need to peek open the file right now. ScopedHandle patchFile; std::string fullPath = _gameFolder + "\\" + _findData.cFileName; patchFile.hFile = CreateFile(fullPath.c_str(), GENERIC_READ, FILE_SHARE_READ, nullptr, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, nullptr); if (patchFile.hFile != INVALID_HANDLE_VALUE) { // Read the first two bytes. The first is the type, the next is the offset. uint8_t word[2]; DWORD cbRead; if (ReadFile(patchFile.hFile, &word, sizeof(word), &cbRead, nullptr) && (cbRead == sizeof(word))) { ResourceType type = (ResourceType)(word[0] & 0x7f); if (IsFlagSet(typeFlags, ResourceTypeToFlag(type))) { entry.Number = number; entry.Offset = GetResourceOffsetInFile(word[1]) + 2; // For the word we just read. entry.Type = type; entry.ExtraData = _nextIndex; entry.PackageNumber = 0; // This is hokey, but we need a way to know the filename for an item _indexToFilename[_nextIndex] = _findData.cFileName; _nextIndex++; foundOne = true; } } } } } _stillMore = !!FindNextFile(_hFind, &_findData); } if (!_stillMore) { FindClose(_hFind); _hFind = INVALID_HANDLE_VALUE; } return _stillMore || foundOne; }
bool matchInList(const TCHAR *fileName, const std::vector<generic_string> & patterns) { for (size_t i = 0, len = patterns.size(); i < len; ++i) { if (PathMatchSpec(fileName, patterns[i].c_str())) return true; } return false; }
__declspec(dllexport) int fnmatch(const char *pattern, const char *string, int flags) { if (((flags & FNM_PATHNAME) != FNM_PATHNAME) || (flags & FNM_CASEFOLD) || (flags & FNM_EXTMATCH)) { printf("FIXME implement workaround for missing features in PathMatchSpec!\n"); abort(); } if (PathMatchSpec(string, pattern)) return 0; return -1; }
wstring ConnectedShortcut::disconnectFileName(const wstring& shortcutName) { const wstring suffix = L" + " SHORT_APP_NAME L".lnk"; if (PathMatchSpec(shortcutName.data(), (L"*" + suffix).data()) == FALSE) return shortcutName; wstring newName = shortcutName; newName.erase(newName.length() - suffix.length()); newName.append(L".lnk"); return newName; }
STDMETHODIMP CBmpCtxMenuExt::Initialize ( LPCITEMIDLIST pidlFolder, LPDATAOBJECT pDO, HKEY hkeyProgID ) { AFX_MANAGE_STATE(AfxGetStaticModuleState()); COleDataObject dataobj; HGLOBAL hglobal; HDROP hdrop; bool bOK = false; dataobj.Attach ( pDO, FALSE ); // FALSE = don't release IDataObject interface when destroyed // Get the first selected file name. I'll keep this simple and just check // the first name to see if it's a .BMP. hglobal = dataobj.GetGlobalData ( CF_HDROP ); if ( NULL == hglobal ) return E_INVALIDARG; hdrop = (HDROP) GlobalLock ( hglobal ); if ( NULL == hdrop ) return E_INVALIDARG; // Get the name of the first selected file. if ( DragQueryFile ( hdrop, 0, m_szFile, MAX_PATH )) { // Is its extension .BMP? if ( PathMatchSpec ( m_szFile, _T("*.bmp") )) { // Load the bitmap and attach our CBitmap object to it. HBITMAP hbm = (HBITMAP) LoadImage ( NULL, m_szFile, IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE ); if ( NULL != hbm ) { // We loaded the bitmap, so attach the CBitmap to it. VERIFY( m_bmp.Attach ( hbm ) ); bOK = true; } } } GlobalUnlock ( hglobal ); return bOK ? S_OK : E_FAIL; }
bool ConnectedShortcut::isConnected(const wstring& filePath) { // Shortcut: Don't try non-link files. if (PathMatchSpec(filePath.data(), L"*.lnk") == FALSE) return false; try { ConnectedShortcut csc; csc.load(filePath, STGM_READ); return csc.isConnected(); } catch (std::exception&) { return false; } }
int csync_fnmatch(__const char *__pattern, __const char *__name, int __flags) { wchar_t *pat = NULL; wchar_t *name = NULL; BOOL match; (void) __flags; name = c_utf8_to_locale(__name); pat = c_utf8_to_locale(__pattern); match = PathMatchSpec(name, pat); c_free_locale_string(pat); c_free_locale_string(name); if(match) return 0; else return 1; }
void ScanFolder(std::vector<std::wstring>& files, std::vector<std::wstring>& filters, bool bSubfolders, const std::wstring& path) { // Get folder listing WIN32_FIND_DATA fileData; // Data structure describes the file found HANDLE hSearch; // Search handle returned by FindFirstFile std::wstring searchPath = path + L"*"; hSearch = FindFirstFile(searchPath.c_str(), &fileData); do { if (hSearch == INVALID_HANDLE_VALUE) break; // No more files found if (fileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) { if (bSubfolders && wcscmp(fileData.cFileName, L".") != 0 && wcscmp(fileData.cFileName, L"..") != 0) { ScanFolder(files, filters, bSubfolders, path + fileData.cFileName + L"\\"); } } else { if (!filters.empty()) { for (int i = 0; i < filters.size(); ++i) { if (!filters[i].empty() && PathMatchSpec(fileData.cFileName, filters[i].c_str())) { files.push_back(path + fileData.cFileName); break; } } } else { files.push_back(path + fileData.cFileName); } } } while (FindNextFile(hSearch, &fileData)); }
BOOL IsDeleteFile(LPCTSTR lpszFilePath, LPCTSTR lpszExtList) { DWORD dwSize = lstrlen(lpszExtList); LPTSTR lpszExtList2 = (LPTSTR)GlobalAlloc(0, (dwSize + 1) * sizeof(TCHAR)); lstrcpy(lpszExtList2, lpszExtList); LPCTSTR seps = TEXT(";"); TCHAR *next; LPTSTR token = wcstok_s(lpszExtList2, seps, &next); while (token != NULL) { if (PathMatchSpec(lpszFilePath, token)) { GlobalFree(lpszExtList2); return TRUE; } token = wcstok_s(0, seps, &next); } GlobalFree(lpszExtList2); return FALSE; }
CString GetAlbumGUID(CString csAlbum,int PLAYER_TYPE, TContentMap* inMap,bool* bAdded) { CString csContentID = _T(""); TContentMap::iterator p; // Show key for(p = inMap->begin(); p!=inMap->end(); ++p) { if(p->second->Source == PLAYER_TYPE && PathMatchSpec(p->second->Album,csAlbum)) { csContentID = p->second->UID; *bAdded = true; break; } } if(!*bAdded) { csContentID = CreateGUID(); } return csContentID; }
//============================================================================= // // DirList_MatchFilter() // // Check if a specified item matches a given filter // BOOL DirList_MatchFilter(LPSHELLFOLDER lpsf,LPCITEMIDLIST pidl,PDL_FILTER pdlf) { int i; WIN32_FIND_DATA fd; BOOL bMatchSpec; // Immediately return true if lpszFileSpec is *.* or NULL if (pdlf->nCount == 0 && !pdlf->bExcludeFilter) return TRUE; SHGetDataFromIDList(lpsf,pidl,SHGDFIL_FINDDATA,&fd,sizeof(WIN32_FIND_DATA)); // All the directories are added if (fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) return(TRUE); // Check if exclude *.* after directories have been added if (pdlf->nCount == 0 && pdlf->bExcludeFilter) return FALSE; for (i = 0; i < pdlf->nCount; i++) { if (*pdlf->pFilter[i]) // Filters like L"\0" are ignored { bMatchSpec = PathMatchSpec(fd.cFileName,pdlf->pFilter[i]); if (bMatchSpec) { if (!pdlf->bExcludeFilter) return(TRUE); else return(FALSE); } } } // No matching return(pdlf->bExcludeFilter)?TRUE:FALSE; }
// // HBITMAP LoadLSImage(LPCSTR pszImage, LPCSTR pszFile) // // Takes strings of the form: // File.bmp // .extract // .extract=file.exe[,3] HBITMAP LoadLSImage(LPCSTR pszImage, LPCSTR pszFile) { HBITMAP hbmReturn = NULL; if (pszImage != NULL) { if (_stricmp(pszImage, ".none") != 0) { char szImage[MAX_PATH]; StringCchCopy(szImage, MAX_PATH, pszImage); // Bitmap merging by Thedd // Thedd - pic1.bmp|pic2.bmp merges the images. Works recursively, // so pic1.bmp|.extract=whatever.dll,3|pic2.bmp also works etc... // bitmap merging by grd LPSTR pszSecondImage = strchr(szImage, '|'); if (pszSecondImage) { HDC hdcFirst, hdcSecond, hdcResult; HBITMAP hbmFirst, hbmFirstOld; HBITMAP hbmSecond, hbmSecondOld; HBITMAP hbmResult, hbmResultOld; HBRUSH hbrTransparent; RECT rc; int wdtFirst, hgtFirst; int wdtSecond, hgtSecond; int wdtResult, hgtResult; // get the position after the [|] character *pszSecondImage = '\0'; ++pszSecondImage; // load the two bitmaps hbmFirst = LoadLSImage(szImage, pszFile); hbmSecond = LoadLSImage(pszSecondImage, pszFile); // if the second one is NULL, then there's no merging to do and if (hbmSecond != NULL) { // create mem dcs for the bitmaps hdcFirst = CreateCompatibleDC(NULL); hdcSecond = CreateCompatibleDC(NULL); // select the bitmaps hbmFirstOld = (HBITMAP)SelectObject(hdcFirst, hbmFirst); hbmSecondOld = (HBITMAP)SelectObject(hdcSecond, hbmSecond); // get the bitmap sizes.. GetLSBitmapSize(hbmFirst, &wdtFirst, &hgtFirst); GetLSBitmapSize(hbmSecond, &wdtSecond, &hgtSecond); // in earlier version of bitmap merge, those were painted on // to each other now let's paint both images to a new one // and we support different sized images!! therefore: wdtResult = std::max(wdtFirst, wdtSecond); hgtResult = std::max(hgtFirst, hgtSecond); // create another dc, compatible with second dc hdcResult = CreateCompatibleDC(hdcSecond); // create a new bitmap for the new dc and select it hbmResult = CreateCompatibleBitmap(hdcSecond, wdtResult, hgtResult); hbmResultOld = (HBITMAP)SelectObject(hdcResult, hbmResult); rc.top = 0; rc.left = 0; rc.right = wdtResult; rc.bottom = hgtResult; // paint the background in transparent color... hbrTransparent = CreateSolidBrush(RGB(255, 0, 255)); FillRect(hdcResult, &rc, hbrTransparent); DeleteObject(hbrTransparent); // first "standard blit" the second image into the new one: BitBlt(hdcResult, (wdtResult - wdtSecond) / 2, (hgtResult - hgtSecond) / 2, wdtSecond, hgtSecond, hdcSecond, 0, 0, SRCCOPY); // Secondly "tranparent blit" the first image over the // second one Since TransparentBltLS double buffers the // painting to reduce flicker and we are using only memory // DC's in this function, we will just call // TransparentBltLSWorker and shave off a few BitBlt calls TransparentBltLSWorker(hdcResult, wdtFirst, hgtFirst, hdcFirst, 0, 0, RGB(255, 0, 255)); // deselect the bitmap from the dc and delete the dc to get // the image SelectObject(hdcResult, hbmResultOld); DeleteDC(hdcResult); // delete all used objects SelectObject(hdcFirst, hbmFirstOld); DeleteObject(hbmFirst); DeleteDC(hdcFirst); SelectObject(hdcSecond, hbmSecondOld); DeleteObject(hbmSecond); DeleteDC(hdcSecond); hbmReturn = hbmResult; } else { hbmReturn = hbmFirst; } } else { if (!_strnicmp(szImage, ".extract", 8 /*strlen(".extract")*/)) { HICON hIcon = NULL; hIcon = LoadLSIcon(szImage, pszFile); if (hIcon) { hbmReturn = BitmapFromIcon(hIcon); DestroyIcon(hIcon); } } else { // Append the image name to the LiteStep image path and // attempt to load the image. char szExpandedImage[MAX_PATH]; VarExpansionEx(szExpandedImage, szImage, MAX_PATH); LSGetImagePath(szImage, MAX_PATH); PathAppend(szImage, szExpandedImage); if (PathMatchSpec(szImage, "*.png")) { hbmReturn = LoadFromPNG(szImage); } else { hbmReturn = (HBITMAP)LoadImage( NULL, szImage, IMAGE_BITMAP, 0, 0, LR_DEFAULTCOLOR | LR_LOADFROMFILE); } // If that fails, treat the image as a fully qualified path // and try loading it if (hbmReturn == NULL) { if (PathMatchSpec(szExpandedImage, "*.png")) { hbmReturn = LoadFromPNG(szExpandedImage); } else { hbmReturn = (HBITMAP)LoadImage( NULL, szExpandedImage, IMAGE_BITMAP, 0, 0, LR_DEFAULTCOLOR | LR_LOADFROMFILE); } } } } } } return hbmReturn; }
bool PathMatchesWildcard(const string& path, const string& wildcard) { return !!PathMatchSpec(path.c_str(), wildcard.c_str()); }
BOOL CFilePath::MatchSpec(LPCTSTR psSpec) { return PathMatchSpec(msPath, psSpec) != 0; }
/** Iterate to next file object * * @returns TRUE if a next file was found, otherwise FALSE */ BOOL CFileIterator::Next(void) { // just return if there's no more files or we weren't successfully initialized if (m_bNoMoreFiles) { m_bFoundFile = FALSE; return FALSE; } BOOL bFound = FALSE; BOOL bMoreFiles; do { bMoreFiles = (0 != m_ff.FindNextFile()); if (m_ff.IsDots()) continue; // if we know this isn't a shortcut, or we're not following shortcuts, then // see if we have a filespec match if (!m_bFollowShortcuts || m_ff.IsDirectory() || !PathMatchSpec(m_ff.GetFileName(), _T("*.lnk")) ) { if (m_bFollowNetworkPaths || !PathIsNetworkPath(m_ff.GetFilePath())) { if (PathMatchSpec(m_ff.GetFileName(), m_strFilespec)) { bFound = TRUE; m_bIsShortcut = FALSE; } } } else { // this may be shortcut. Try following it... WIN32_FIND_DATA fd; CString strTargetPath; if (SUCCEEDED(GetShortcutInfo(m_ff.GetFilePath(), strTargetPath.GetBuffer(MAX_SHORTCUT_PATH), MAX_SHORTCUT_PATH, &fd))) { // this is a shortcut. If we're ignoring shortcuts to remote // files/folders, then verify it's not a network path. if (m_bFollowNetworkPaths || !PathIsNetworkPath(strTargetPath)) { // okay, try to match the filespec to it if (PathMatchSpec(fd.cFileName, m_strFilespec)) { bFound = TRUE; m_bIsShortcut = TRUE; m_strPath = strTargetPath; m_sFd = fd; } } } m_strPath.ReleaseBuffer(); } } while (bFound == FALSE && bMoreFiles == TRUE); m_bFoundFile = bFound; m_bNoMoreFiles = !bMoreFiles; return bFound; }
// // LoadLSIcon(LPCSTR pszIconPath, LPCSTR pszFile) // // Takes strings of the form: // File.ico // libary.icl,3 <- libary extraction in imagesfolder // c:\path\ <- icon extraction for path out of desktop.ini // .extract // .extract=file.exe[,3] ... and returns an icon HICON LoadLSIcon(LPCSTR pszIconPath, LPCSTR pszFile) { HICON hIcon = NULL; if (pszIconPath != NULL) { if (_stricmp(pszIconPath, ".none") != 0) { char szIconPath[MAX_PATH]; char szIconLSImagePath[MAX_PATH]; LPSTR pszIconFile = (LPSTR)pszIconPath; int nIcon = 0; // here comes a large block which does nothing but turning it into // the form <absolute path>[,<iconIndex>] // if .extract but nothing else is there... // then take the file specified as an icon (could probably be done // earlier, but anyhow) if (_stricmp(pszIconPath, ".extract") == 0) { pszIconFile = (LPSTR)pszFile; } else if (_strnicmp(pszIconPath, ".extract=", 9) == 0) { // remove ".extract=" (as we won't use it anyway) pszIconFile = (LPSTR)pszIconPath + 9; } VarExpansionEx(szIconPath, pszIconFile, MAX_PATH); if (PathIsRelative(szIconPath)) { LSGetImagePath(szIconLSImagePath, MAX_PATH); PathAppend(szIconLSImagePath, szIconPath); pszIconFile = szIconLSImagePath; } else { pszIconFile = szIconPath; } // large block ends here, now time to separate path and index (if we // have an index) nIcon = PathParseIconLocation(pszIconFile); // now we have the two vars we would like, and the loading can begin // well not really, if it's a path, where we're going to get the // icon form desktop.ini there is just a little bit more we have to // do before we can start loading if (PathIsDirectory(pszIconFile)) { char szTemp[MAX_PATH]; PathAppend(pszIconFile, "desktop.ini"); nIcon = GetPrivateProfileInt(".ShellClassInfo", "IconIndex", 0, pszIconFile); GetPrivateProfileString(".ShellClassInfo", "IconFile", "", szTemp, MAX_PATH, pszIconFile); StringCchCopy(pszIconFile, MAX_PATH, szTemp); } // okay, now it's really time to load the icon... if it's an .ico // file we want to do an LoadImage() thing, otherwise it's // extracticon so lets find out the extension if (PathMatchSpec(pszIconFile, "*.ico")) { hIcon = (HICON)LoadImage( NULL, pszIconFile, IMAGE_ICON, 0, 0, LR_LOADFROMFILE); } else { hIcon = ExtractIcon(GetModuleHandle(NULL), pszIconFile, nIcon); if (hIcon == (HICON)1) { hIcon = NULL; } } } } return hIcon; }
int csync_fnmatch(__const char *__pattern, __const char *__name, int __flags) { if(PathMatchSpec(__name, __pattern)) return 0; else return 1; }
BOOL GetFileInfo(CLOUD_MEIDA_METADATA_STRUCT* instruct,const CString filepath,bool* bIsAudio,bool* bIsPhoto,bool* bIsVideo) { CString fileDir ,fileName; fileDir.Append(filepath); PathRemoveFileSpec((LPWSTR)(LPCTSTR)fileDir);//Get dir Name fileName.Append(PathFindFileName(filepath));//Get file name IShellDispatch* pShellDisp = NULL; Folder *pFolder; FolderItem *pFolderItem; CComBSTR stitle,str; HRESULT hr = S_OK; CoInitialize(NULL); hr = ::CoCreateInstance( CLSID_Shell, NULL,CLSCTX_SERVER, IID_IShellDispatch, (LPVOID*)&pShellDisp ); if( hr == S_OK ) { hr = pShellDisp->NameSpace(CComVariant(fileDir),&pFolder); hr = pFolder->ParseName(CComBSTR(fileName),&pFolderItem); CComVariant vItem(pFolderItem); //CComVariant vEmpty; //int i = 0; // for (int i = 0 ;i < 100;i++) // { // hr = pFolder->GetDetailsOf(vEmpty,i,&stitle); // hr = pFolder->GetDetailsOf(vItem,i,&str); //COLE2T lpszTitle(stitle); //COLE2T lpszInfo(str); //TCHAR buf[300]; //afxDump <<i <<": "<< lpszTitle.m_psz<<" "<<lpszInfo.m_psz<<"\n"; // int a = 1; // } CString csPerceivedType; csPerceivedType = GetDetailsOf(pFolder,vItem,COLUMN_SORTING_TYPE_PerceivedType); *bIsAudio = PathMatchSpec(csPerceivedType,_T("audio")); *bIsPhoto = PathMatchSpec(csPerceivedType,_T("image")); *bIsVideo = PathMatchSpec(csPerceivedType,_T("video")); instruct->Duration = GetDurection(GetDetailsOf(pFolder,vItem,COLUMN_SORTING_TYPE_Duration)); if(!*bIsAudio && !*bIsPhoto && !*bIsVideo) return FALSE; if(*bIsAudio) { instruct->Album = GetDetailsOf(pFolder,vItem,COLUMN_SORTING_TYPE_Album); } else { instruct->Album = fileDir; instruct->Date = GetTime(GetDetailsOf(pFolder,vItem,COLUMN_SORTING_TYPE_CreatedDate)); } instruct->Size = GetDetailsOf(pFolder,vItem,COLUMN_SORTING_TYPE_Size); instruct->Title = GetDetailsOf(pFolder,vItem,COLUMN_SORTING_TYPE_Title); if(instruct->Title.IsEmpty()) { CString csFileNameWithOutExtension; csFileNameWithOutExtension.Append(fileName); PathRemoveExtension((LPWSTR)(LPCTSTR)csFileNameWithOutExtension); instruct->Title = csFileNameWithOutExtension; } instruct->Genre = GetDetailsOf(pFolder,vItem,COLUMN_SORTING_TYPE_Genre); hr = pShellDisp->Release(); pShellDisp = NULL; } CoUninitialize(); return TRUE; }