bool CFSFolder::SaveComments() { AString utf; { UString unicode; _comments.SaveToString(unicode); ConvertUnicodeToUTF8(unicode, utf); } if (!utf.IsAscii()) utf.Insert(0, "\xEF\xBB\xBF" "\r\n"); FString path = _path + kDescriptionFileName; // We must set same attrib. COutFile::CreateAlways can fail, if file has another attrib. DWORD attrib = FILE_ATTRIBUTE_NORMAL; { CFileInfo fi; if (fi.Find(path)) attrib = fi.Attrib; } NIO::COutFile file; if (!file.CreateAlways(path, attrib)) return false; UInt32 processed; file.Write(utf, utf.Len(), processed); _commentsAreLoaded = false; return true; }
void CFileEvent::RemoveFile (LPCTSTR pszPathName) { CFileInfo *pFileInfo; if (!m_mapFileInfo.Lookup (pszPathName, pFileInfo)) return; ASSERT (pFileInfo); POSITION pos = m_lstFilePath.GetHeadPosition (), posOld; CFilePath *pFilePath; while (pos) { posOld = pos; pFilePath = m_lstFilePath.GetNext (pos); ASSERT (pFilePath); if (!_tcscmp (pFilePath->GetPath (), pFileInfo->GetPath ())) { if (pFilePath->GetCount () == 1) { delete pFilePath; delete pFileInfo; m_lstFilePath.RemoveAt (posOld); m_mapFileInfo.RemoveKey (pszPathName); } else pFilePath->Dec (); return; } } }
void CFileEvent::AddFile (LPCTSTR pszPathName) { CFileInfo *pFileInfo; if (m_mapFileInfo.Lookup (pszPathName, pFileInfo)) return; pFileInfo = new CFileInfo (pszPathName); m_mapFileInfo.SetAt (pszPathName, pFileInfo); POSITION pos = m_lstFilePath.GetHeadPosition (); CFilePath *pFilePath; while (pos) { pFilePath = m_lstFilePath.GetNext (pos); ASSERT (pFilePath); if (!_tcscmp (pFilePath->GetPath (), pFileInfo->GetPath ())) { pFilePath->Inc (); return; } } m_lstFilePath.AddTail (new CFilePath (pFileInfo->GetPath ())); if (m_bEvent) { StopWatching (); StartWatching (); } }
HRESULT CFsFolderStat::Enumerate() { if (Progress) { RINOK(Progress->SetCompleted(NULL)); } Path.Add_PathSepar(); const unsigned len = Path.Len(); CEnumerator enumerator; enumerator.SetDirPrefix(Path); CFileInfo fi; while (enumerator.Next(fi)) { if (fi.IsDir()) { Path.DeleteFrom(len); Path += fi.Name; RINOK(Enumerate()); NumFolders++; } else { NumFiles++; Size += fi.Size; } } return S_OK; }
// Return current size of file. // // size = getFileSize(filename); // filename: VFS filename (may include path) unsigned int JSI_VFS::GetFileSize(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), std::wstring filename) { CFileInfo fileInfo; Status err = g_VFS->GetFileInfo(filename, &fileInfo); JS_CHECK_FILE_ERR(err); return (unsigned int)fileInfo.Size(); }
// Return time [seconds since 1970] of the last modification to the specified file. // // mtime = getFileMTime(filename); // filename: VFS filename (may include path) double JSI_VFS::GetFileMTime(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), std::wstring filename) { CFileInfo fileInfo; Status err = g_VFS->GetFileInfo(filename, &fileInfo); JS_CHECK_FILE_ERR(err); return (double)fileInfo.MTime(); }
int CFileBrowserListCtrl::CalcMinColumnWidth(int Col) { enum { BORDER = 6, // minimal spacing; less causes abbreviated text SLACK = 3 // prevents widest item from touching right edge }; CWaitCursor wc; // iterating all items can be slow, especially for file type CClientDC dc(this); HGDIOBJ PrevFont = dc.SelectObject(GetFont()); // must use list control's font int width = 0; CSize sz; CFileInfo FileInfo; CString str; int items = m_DirList.GetCount(); for (int i = 0; i < items; i++) { const CDirItem& item = m_DirList.GetItem(i); switch (Col) { case COL_NAME: str = item.GetName(); break; case COL_SIZE: if (item.IsDir()) continue; FormatSize(item.GetLength(), str); break; case COL_TYPE: // slow if we have many unique file types that aren't cached m_FileInfoCache.GetFileInfo(GetFolder(), item, FileInfo); str = FileInfo.GetTypeName(); break; case COL_MODIFIED: if (item.GetLastWrite() == 0) continue; FormatTime(item.GetLastWrite(), str); break; default: ASSERT(0); } GetTextExtentPoint32(dc.m_hDC, str, str.GetLength(), &sz); if (sz.cx > width) width = sz.cx; } dc.SelectObject(PrevFont); // restore DC's previous font // 25feb09: GetItemRect can fail e.g. if list is empty, in which case we // must avoid adding garbage to column width CRect IconRect; if (GetItemRect(0, IconRect, LVIR_ICON)) width += IconRect.Width(); else // can't get item rect, fall back to system metrics width += GetSystemMetrics(m_ViewType == VTP_ICON ? SM_CXICON : SM_CXSMICON); width += BORDER + SLACK; return(width); }
/** * Creates MD5 hash key from skeletons.xml info and COLLADA converter version, * used to invalidate cached .pmd/psas * * @param[out] hash resulting MD5 hash * @param[out] version version passed to CCacheLoader, used if code change should force * cache invalidation */ void PrepareCacheKey(MD5& hash, u32& version) { // Add converter version to the hash version = COLLADA_CONVERTER_VERSION; // Cache the skeleton files hash data if (m_skeletonHashInvalidated) { VfsPaths paths; if (vfs::GetPathnames(m_VFS, L"art/skeletons/", L"*.xml", paths) != INFO::OK) { LOGWARNING("Failed to load skeleton definitions"); return; } // Sort the paths to not invalidate the cache if mods are mounted in different order // (No need to stable_sort as the VFS gurantees that we have no duplicates) std::sort(paths.begin(), paths.end()); // We need two u64s per file m_skeletonHashes.clear(); m_skeletonHashes.reserve(paths.size()*2); CFileInfo fileInfo; for (const VfsPath& path : paths) { // This will cause an assertion failure if *it doesn't exist, // because fileinfo is not a NULL pointer, which is annoying but that // should never happen, unless there really is a problem if (m_VFS->GetFileInfo(path, &fileInfo) != INFO::OK) { LOGERROR("Failed to stat '%s' for DAE caching", path.string8()); } else { m_skeletonHashes.push_back((u64)fileInfo.MTime() & ~1); //skip lowest bit, since zip and FAT don't preserve it m_skeletonHashes.push_back((u64)fileInfo.Size()); } } // Check if we were able to load any skeleton files if (m_skeletonHashes.empty()) LOGERROR("Failed to stat any skeleton definitions for DAE caching"); // We can continue, something else will break if we try loading a skeletal model m_skeletonHashInvalidated = false; } for (const u64& h : m_skeletonHashes) hash.Update((const u8*)&h, sizeof(h)); }
void CFileManager::FindAllFile(const wstring& strPath, vector<CFileInfo>& vecFiles) { if(strPath.length() < 1) return; CString cstrFind = strPath.c_str(); cstrFind += _T("\\*.*"); WIN32_FIND_DATA wfd; HANDLE hFind = ::FindFirstFile(cstrFind, &wfd); if(hFind==INVALID_HANDLE_VALUE) return ; string str; TCHAR tcharFile[MAX_PATH]; CFileInfo entry; bool ifok = false; const wstring wstrRoot = CConfig::GetInstance().GetRootPath(); do { if(m_fHasNewSearch) goto End; //如果你所在的不是根目录,你将会看到“.”与“..”这两个目录——这是在资源管理器中看不到的。 //dos下一个点代表的是当前目录,两个点代表的是上一级目录。若查找的到的是当前文件夹和上一级文件夹,则忽略。 if(wfd.cFileName[0]=='.') continue; if(wfd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) { //dir wsprintf(tcharFile,_T("%s\\%s"), strPath.c_str(), wfd.cFileName); FindAllFile(tcharFile, vecFiles); //recursive call } else { //file wsprintf(tcharFile,_T("%s\\%s"), strPath.c_str() , wfd.cFileName); entry.Clear(); entry.m_strFullPathName = tcharFile; ifok = entry.ReadAllInfo(wstrRoot); vecFiles.push_back(entry); //m_vecFileData.push_back(""); } }while(::FindNextFile(hFind,&wfd)); End: ::FindClose(hFind); }
void CPanel::LoadFullPathAndShow() { LoadFullPath(); _appState->FolderHistory.AddString(_currentFolderPrefix); _headerComboBox.SetText(_currentFolderPrefix); #ifndef UNDER_CE COMBOBOXEXITEM item; item.mask = 0; UString path = _currentFolderPrefix; if (path.Len() > #ifdef _WIN32 3 #else 1 #endif && path.Back() == WCHAR_PATH_SEPARATOR) path.DeleteBack(); DWORD attrib = FILE_ATTRIBUTE_DIRECTORY; // GetRealIconIndex is slow for direct DVD/UDF path. So we use dummy path if (path.IsPrefixedBy(L"\\\\.\\")) path = L"_TestFolder_"; else { CFileInfo fi; if (fi.Find(us2fs(path))) attrib = fi.Attrib; } item.iImage = GetRealIconIndex(us2fs(path), attrib); if (item.iImage >= 0) { item.iSelectedImage = item.iImage; item.mask |= (CBEIF_IMAGE | CBEIF_SELECTEDIMAGE); } item.iItem = -1; _headerComboBox.SetItem(&item); #endif RefreshTitle(); }
bool CEnumerator::Next(CFileInfo &fi) { for (;;) { if (!NextAny(fi)) return false; if (!fi.IsDots()) return true; } }
bool CEnumerator::Next(CFileInfo &fileInfo) { while(true) { if(!NextAny(fileInfo)) return false; if(!fileInfo.IsDots()) return true; } }
int CDirectoryInfo::_SortAllFileInPathByTime(LstFileSystemItemsInPathT& lstFileSystemItemsInPath, MapTimeFileSystemItemT& mapTimeFileSystemItem) { BOOST_LOG_FUNCTION(); int nFunRes = 0; LstFileSystemItemsInPathIterT iterLst; CFileInfo* pFileSystemItem = NULL; time_t nFileNameTImeValue = 0; iterLst = lstFileSystemItemsInPath.begin(); while (iterLst != lstFileSystemItemsInPath.end()) { pFileSystemItem = (*iterLst); nFileNameTImeValue = pFileSystemItem->getFileNameTime(); mapTimeFileSystemItem.insert(MapTimeFileSystemItemValueTypeT(nFileNameTImeValue, pFileSystemItem));//auto sort iterLst++; }//while lstFileSystemItemsInPath.clear(); return nFunRes; }
VfsPath CCacheLoader::LooseCachePath(const VfsPath& sourcePath, const MD5& initialHash, u32 version) { CFileInfo fileInfo; if (m_VFS->GetFileInfo(sourcePath, &fileInfo) < 0) { debug_warn(L"source file disappeared"); // this should never happen return VfsPath(); } u64 mtime = (u64)fileInfo.MTime() & ~1; // skip lowest bit, since zip and FAT don't preserve it u64 size = (u64)fileInfo.Size(); // Construct a hash of the file data and settings. MD5 hash = initialHash; hash.Update((const u8*)&mtime, sizeof(mtime)); hash.Update((const u8*)&size, sizeof(size)); hash.Update((const u8*)&version, sizeof(version)); // these are local cached files, so we don't care about endianness etc // Use a short prefix of the full hash (we don't need high collision-resistance), // converted to hex u8 digest[MD5::DIGESTSIZE]; hash.Final(digest); std::wstringstream digestPrefix; digestPrefix << std::hex; for (size_t i = 0; i < 8; ++i) digestPrefix << std::setfill(L'0') << std::setw(2) << (int)digest[i]; // Get the mod path OsPath path; m_VFS->GetRealPath(sourcePath, path); // Construct the final path return VfsPath("cache") / path_name_only(path.BeforeCommon(sourcePath).Parent().string().c_str()) / sourcePath.ChangeExtension(sourcePath.Extension().string() + L"." + digestPrefix.str() + m_FileExtension); }
static HRESULT UpdateFile(NFsFolder::CCopyStateIO &state, CFSTR inPath, CFSTR outPath, IFolderArchiveUpdateCallback *callback) { if (NFind::DoesFileOrDirExist(outPath)) { RINOK(SendMessageError(callback, NError::MyFormatMessage(ERROR_ALREADY_EXISTS), outPath)); CFileInfo fi; if (fi.Find(inPath)) { if (state.TotalSize >= fi.Size) state.TotalSize -= fi.Size; } return S_OK; } { if (callback) RINOK(callback->CompressOperation(fs2us(inPath))); RINOK(state.MyCopyFile(inPath, outPath)); if (state.ErrorFileIndex >= 0) { if (state.ErrorMessage.IsEmpty()) state.ErrorMessage = GetLastErrorMessage(); FString errorName; if (state.ErrorFileIndex == 0) errorName = inPath; else errorName = outPath; if (callback) RINOK(SendMessageError(callback, state.ErrorMessage, errorName)); } if (callback) RINOK(callback->OperationResult(0)); } return S_OK; }
Status ForEachFile(const PIVFS& fs, const VfsPath& startPath, FileCallback cb, uintptr_t cbData, const wchar_t* pattern, size_t flags) { // (declare here to avoid reallocations) CFileInfos files; DirectoryNames subdirectoryNames; // (a FIFO queue is more efficient than recursion because it uses less // stack space and avoids seeks due to breadth-first traversal.) std::queue<VfsPath> pendingDirectories; pendingDirectories.push(startPath/""); while(!pendingDirectories.empty()) { const VfsPath& path = pendingDirectories.front(); RETURN_STATUS_IF_ERR(fs->GetDirectoryEntries(path, &files, &subdirectoryNames)); for(size_t i = 0; i < files.size(); i++) { const CFileInfo fileInfo = files[i]; if(!match_wildcard(fileInfo.Name().string().c_str(), pattern)) continue; const VfsPath pathname(path / fileInfo.Name()); // (CFileInfo only stores the name) RETURN_STATUS_IF_ERR(cb(pathname, fileInfo, cbData)); } if(!(flags & DIR_RECURSIVE)) break; for(size_t i = 0; i < subdirectoryNames.size(); i++) pendingDirectories.push(path / subdirectoryNames[i]/""); pendingDirectories.pop(); } return INFO::OK; }
IFilePtr CZipFileSystem::OpenFile(const CFileInfo& filePath, int mode) { CFileInfo fileInfo(BasePath(), filePath.AbsolutePath(), false); IFilePtr file = FindFile(fileInfo); bool isExists = (file != nullptr); if (!isExists) { file.reset(new CZipFile(fileInfo, m_Zip)); } file->Open(mode); if (!isExists && file->IsOpened()) { m_FileList.insert(file); } return file; }
bool DoesDirExist(CFSTR name) { CFileInfo fi; return fi.Find(name) && fi.IsDir(); }
bool CPanel::OnComboBoxCommand(UINT code, LPARAM /* param */, LRESULT &result) { result = FALSE; switch (code) { case CBN_DROPDOWN: { ComboBoxPaths.Clear(); _headerComboBox.ResetContent(); unsigned i; UStringVector pathParts; SplitPathToParts(_currentFolderPrefix, pathParts); UString sumPass; if (!pathParts.IsEmpty()) pathParts.DeleteBack(); for (i = 0; i < pathParts.Size(); i++) { UString name = pathParts[i]; sumPass += name; sumPass.Add_PathSepar(); CFileInfo info; DWORD attrib = FILE_ATTRIBUTE_DIRECTORY; if (info.Find(us2fs(sumPass))) attrib = info.Attrib; AddComboBoxItem(name.IsEmpty() ? L"\\" : name, GetRealIconIndex(us2fs(sumPass), attrib), i, false); ComboBoxPaths.Add(sumPass); } #ifndef UNDER_CE int iconIndex; UString name; name = RootFolder_GetName_Documents(iconIndex); AddComboBoxItem(name, iconIndex, 0, true); name = RootFolder_GetName_Computer(iconIndex); AddComboBoxItem(name, iconIndex, 0, true); FStringVector driveStrings; MyGetLogicalDriveStrings(driveStrings); for (i = 0; i < driveStrings.Size(); i++) { FString s = driveStrings[i]; ComboBoxPaths.Add(fs2us(s)); int iconIndex = GetRealIconIndex(s, 0); if (s.Len() > 0 && s.Back() == FCHAR_PATH_SEPARATOR) s.DeleteBack(); AddComboBoxItem(fs2us(s), iconIndex, 1, false); } name = RootFolder_GetName_Network(iconIndex); AddComboBoxItem(name, iconIndex, 0, true); #endif return false; } case CBN_SELENDOK: { code = code; int index = _headerComboBox.GetCurSel(); if (index >= 0) { UString pass = ComboBoxPaths[index]; _headerComboBox.SetCurSel(-1); // _headerComboBox.SetText(pass); // it's fix for seclecting by mouse. if (BindToPathAndRefresh(pass) == S_OK) { PostMsg(kSetFocusToListView); #ifdef UNDER_CE PostMsg(kRefresh_HeaderComboBox); #endif return true; } } return false; } /* case CBN_CLOSEUP: { LoadFullPathAndShow(); true; } case CBN_SELCHANGE: { // LoadFullPathAndShow(); return true; } */ } return false; }
HRESULT CPanel::BindToPath(const UString &fullPath, const UString &arcFormat, bool &archiveIsOpened, bool &encrypted) { UString path = fullPath; #ifdef _WIN32 path.Replace(L'/', WCHAR_PATH_SEPARATOR); #endif archiveIsOpened = false; encrypted = false; CDisableTimerProcessing disableTimerProcessing(*this); CDisableNotify disableNotify(*this); for (; !_parentFolders.IsEmpty(); CloseOneLevel()) { // ---------- we try to use open archive ---------- const CFolderLink &link = _parentFolders.Back(); const UString &virtPath = link.VirtualPath; if (!path.IsPrefixedBy(virtPath)) continue; UString relatPath = path.Ptr(virtPath.Len()); if (!relatPath.IsEmpty()) { if (!IS_PATH_SEPAR(relatPath[0])) continue; else relatPath.Delete(0); } UString relatPath2 = relatPath; if (!relatPath2.IsEmpty() && !IS_PATH_SEPAR(relatPath2.Back())) relatPath2.Add_PathSepar(); for (;;) { const UString foldPath = GetFolderPath(_folder); if (relatPath2 == foldPath) break; if (relatPath.IsPrefixedBy(foldPath)) { path = relatPath.Ptr(foldPath.Len()); break; } CMyComPtr<IFolderFolder> newFolder; if (_folder->BindToParentFolder(&newFolder) != S_OK) throw 20140918; if (!newFolder) // we exit from loop above if (relatPath.IsPrefixedBy(empty path for root folder) throw 20140918; SetNewFolder(newFolder); } break; } if (_parentFolders.IsEmpty()) { // ---------- we open file or folder from file system ---------- CloseOpenFolders(); UString sysPath = path; unsigned prefixSize = NName::GetRootPrefixSize(sysPath); if (prefixSize == 0 || sysPath[prefixSize] == 0) sysPath.Empty(); #if defined(_WIN32) && !defined(UNDER_CE) if (!sysPath.IsEmpty() && sysPath.Back() == ':' && (sysPath.Len() != 2 || !NName::IsDrivePath2(sysPath))) { UString baseFile = sysPath; baseFile.DeleteBack(); if (NFind::DoesFileOrDirExist(us2fs(baseFile))) sysPath.Empty(); } #endif CFileInfo fileInfo; while (!sysPath.IsEmpty()) { if (fileInfo.Find(us2fs(sysPath))) break; int pos = sysPath.ReverseFind_PathSepar(); if (pos < 0) sysPath.Empty(); else { /* if (reducedParts.Size() > 0 || pos < (int)sysPath.Len() - 1) reducedParts.Add(sysPath.Ptr(pos + 1)); */ #if defined(_WIN32) && !defined(UNDER_CE) if (pos == 2 && NName::IsDrivePath2(sysPath) && sysPath.Len() > 3) pos++; #endif sysPath.DeleteFrom(pos); } } SetToRootFolder(); CMyComPtr<IFolderFolder> newFolder; if (sysPath.IsEmpty()) { _folder->BindToFolder(path, &newFolder); } else if (fileInfo.IsDir()) { NName::NormalizeDirPathPrefix(sysPath); _folder->BindToFolder(sysPath, &newFolder); } else { FString dirPrefix, fileName; NDir::GetFullPathAndSplit(us2fs(sysPath), dirPrefix, fileName); HRESULT res; // = OpenAsArc(fs2us(fileName), arcFormat, encrypted); { CTempFileInfo tfi; tfi.RelPath = fs2us(fileName); tfi.FolderPath = dirPrefix; tfi.FilePath = us2fs(sysPath); res = OpenAsArc(NULL, tfi, sysPath, arcFormat, encrypted); } if (res == S_FALSE) _folder->BindToFolder(fs2us(dirPrefix), &newFolder); else { RINOK(res); archiveIsOpened = true; _parentFolders.Back().ParentFolderPath = fs2us(dirPrefix); path.DeleteFrontal(sysPath.Len()); if (!path.IsEmpty() && IS_PATH_SEPAR(path[0])) path.Delete(0); } } if (newFolder) { SetNewFolder(newFolder); // LoadFullPath(); return S_OK; } } { // ---------- we open folder remPath in archive and sub archives ---------- for (unsigned curPos = 0; curPos != path.Len();) { UString s = path.Ptr(curPos); int slashPos = NName::FindSepar(s); unsigned skipLen = s.Len(); if (slashPos >= 0) { s.DeleteFrom(slashPos); skipLen = slashPos + 1; } CMyComPtr<IFolderFolder> newFolder; _folder->BindToFolder(s, &newFolder); if (newFolder) curPos += skipLen; else if (_folderAltStreams) { int pos = s.Find(L':'); if (pos >= 0) { UString baseName = s; baseName.DeleteFrom(pos); if (_folderAltStreams->BindToAltStreams(baseName, &newFolder) == S_OK && newFolder) curPos += pos + 1; } } if (!newFolder) break; SetNewFolder(newFolder); } } return S_OK; }
HRESULT CPanel::BindToPath(const UString &fullPath, const UString &arcFormat, bool &archiveIsOpened, bool &encrypted) { archiveIsOpened = false; encrypted = false; CDisableTimerProcessing disableTimerProcessing(*this); CDisableNotify disableNotify(*this); if (_parentFolders.Size() > 0) { const UString &virtPath = _parentFolders.Back().VirtualPath; if (fullPath.IsPrefixedBy(virtPath)) { for (;;) { CMyComPtr<IFolderFolder> newFolder; HRESULT res = _folder->BindToParentFolder(&newFolder); if (!newFolder || res != S_OK) break; SetNewFolder(newFolder); } UStringVector parts; SplitPathToParts(fullPath.Ptr(virtPath.Len()), parts); FOR_VECTOR (i, parts) { const UString &s = parts[i]; if ((i == 0 || i == parts.Size() - 1) && s.IsEmpty()) continue; CMyComPtr<IFolderFolder> newFolder; HRESULT res = _folder->BindToFolder(s, &newFolder); if (!newFolder || res != S_OK) break; SetNewFolder(newFolder); } return S_OK; } } CloseOpenFolders(); UString sysPath = fullPath; CFileInfo fileInfo; UStringVector reducedParts; while (!sysPath.IsEmpty()) { if (fileInfo.Find(us2fs(sysPath))) break; int pos = sysPath.ReverseFind(WCHAR_PATH_SEPARATOR); if (pos < 0) sysPath.Empty(); else { if (reducedParts.Size() > 0 || pos < (int)sysPath.Len() - 1) reducedParts.Add(sysPath.Ptr(pos + 1)); sysPath.DeleteFrom(pos); } } SetToRootFolder(); CMyComPtr<IFolderFolder> newFolder; if (sysPath.IsEmpty()) { if (_folder->BindToFolder(fullPath, &newFolder) == S_OK) SetNewFolder(newFolder); } else if (fileInfo.IsDir()) { NName::NormalizeDirPathPrefix(sysPath); if (_folder->BindToFolder(sysPath, &newFolder) == S_OK) SetNewFolder(newFolder); } else { FString dirPrefix, fileName; NDir::GetFullPathAndSplit(us2fs(sysPath), dirPrefix, fileName); if (_folder->BindToFolder(fs2us(dirPrefix), &newFolder) == S_OK) { SetNewFolder(newFolder); LoadFullPath(); { HRESULT res = OpenItemAsArchive(fs2us(fileName), arcFormat, encrypted); if (res != S_FALSE) { RINOK(res); } /* if (res == E_ABORT) return res; */ if (res == S_OK) { archiveIsOpened = true; for (int i = reducedParts.Size() - 1; i >= 0; i--) { CMyComPtr<IFolderFolder> newFolder; _folder->BindToFolder(reducedParts[i], &newFolder); if (!newFolder) break; SetNewFolder(newFolder); } } } } } return S_OK; }
// speed optimized and made unicode-compatible inline bool CFilenameLayer::FilesEqual( CFileInfo & FileInfo1, CFileInfo & FileInfo2) const { switch ( m_FilenameMatchMode ) { case IDC_MATCH_FILENAMES: if ( m_CaseSensitive ) return _tcscmp( FileInfo1.GetName() , FileInfo2.GetName() ) == 0; else return _tcsicmp( FileInfo1.GetName() , FileInfo2.GetName() ) == 0; break; case IDC_MATCH_EXTENSIONS: { LPCTSTR pExtension1, pExtension2; pExtension1 = FileInfo1.GetExtension(); pExtension2 = FileInfo2.GetExtension(); if ( pExtension1 == NULL || pExtension2 == NULL ) { return ( pExtension1 == pExtension2 ); } else { if ( m_CaseSensitive ) return _tcscmp( pExtension1 , pExtension2 ) == 0; else return _tcsicmp( pExtension1 , pExtension2 ) == 0; } } break; case IDC_MATCH_NOT_FILENAME: if ( m_CaseSensitive ) return _tcscmp( FileInfo1.GetName() , FileInfo2.GetName() ) != 0; else return _tcsicmp( FileInfo1.GetName() , FileInfo2.GetName() ) != 0; break; case IDC_MATCH_NOT_EXTENSIONS: { LPCTSTR pExtension1, pExtension2; pExtension1 = FileInfo1.GetExtension(); pExtension2 = FileInfo2.GetExtension(); if ( pExtension1 == NULL || pExtension2 == NULL ) { return ( pExtension1 == pExtension2 ); } else { if ( m_CaseSensitive ) return _tcscmp( pExtension1 , pExtension2 ) != 0; else return _tcsicmp( pExtension1 , pExtension2 ) != 0; } } break; case IDC_MATCH_WORDS: { CArray <CString, CString&> Words1; CArray <CString, CString&> Words2; CArray <CString, CString> IgnoreWords; CString strMask; CString TempStr = FileInfo1.GetBaseName(); int nPos = 0; int nNextPos = 0; int x, y; nPos = 0; nNextPos = 0; // add file masks while (nPos < TempStr.GetLength()) { nNextPos = TempStr.Find( _T(" ") ,nPos); if (nNextPos == -1) nNextPos = TempStr.GetLength(); strMask = TempStr.Mid(nPos, nNextPos-nPos); strMask.TrimLeft(); strMask.TrimRight(); if ( !m_CaseSensitive ) strMask.MakeUpper(); if (strMask != "") Words1.Add(strMask); nPos = nNextPos + 1; } // TempStr = FileInfo2.GetBaseName(); nPos = 0; nNextPos = 0; // add file masks while (nPos < TempStr.GetLength()) { nNextPos = TempStr.Find( _T(" ") ,nPos); if (nNextPos == -1) nNextPos = TempStr.GetLength(); strMask = TempStr.Mid(nPos, nNextPos-nPos); strMask.TrimLeft(); strMask.TrimRight(); if ( !m_CaseSensitive ) strMask.MakeUpper(); if (strMask != "") Words2.Add(strMask); nPos = nNextPos + 1; } // // remove duplicate words for (x = Words1.GetSize()-1; x > 0 ; x--) { for (y = x-1; y >= 0; y--) { if ( Words1.ElementAt(x) == Words1.ElementAt(y) ) { Words1.RemoveAt(x); break; } } } // // remove duplicate words for (x = Words2.GetSize()-1; x > 0 ; x--) { for (y = x-1; y >= 0; y--) { if ( Words2.ElementAt(x) == Words2.ElementAt(y) ) { Words2.RemoveAt(x); break; } } } // IgnoreWords.Add("-"); IgnoreWords.Add("A"); IgnoreWords.Add("THE"); IgnoreWords.Add("I"); IgnoreWords.Add("AT"); IgnoreWords.Add("OF"); IgnoreWords.Add("ON"); bool deleted; // remove ignored words for (x = Words1.GetSize()-1; x>=0; x--) { deleted = false; y = 0; //for (y = 0; y < IgnoreWords.GetSize(); y++) while ( !deleted && y < IgnoreWords.GetSize() ) { if ( Words1.ElementAt(x) == IgnoreWords.ElementAt(y) ) { Words1.RemoveAt(x); deleted = true; } y++; } } // remove ignored words for (x = Words2.GetSize()-1; x>=0; x--) { deleted = false; y = 0; //for (y = 0; y < IgnoreWords.GetSize(); y++) while ( !deleted && y < IgnoreWords.GetSize() ) { if ( Words2.ElementAt(x) == IgnoreWords.ElementAt(y) ) { Words2.RemoveAt(x); deleted = true; } y++; } } UINT CommonCount = 0; // calculate the number of common words for (x = 0; x < Words1.GetSize(); x++) { for (y = 0; y < Words2.GetSize(); y++) { if ( Words1.ElementAt(x) == Words2.ElementAt(y) ) CommonCount++; } } return ( CommonCount >= m_WordCount ); } break; default: AfxMessageBox( _T("FMM_ERROR") ); return true; break; } /* // not optimized CString File1, File2; File1 = FileInfo1.Filename.Right( FileInfo1.Filename.GetLength() - FileInfo1.Filename.ReverseFind('\\') - 1 ); File2 = FileInfo2.Filename.Right( FileInfo2.Filename.GetLength() - FileInfo2.Filename.ReverseFind('\\') - 1 ); if ( !m_FilenameLayerForm.m_CaseSensitive ) { File1.MakeUpper(); File2.MakeUpper(); } switch ( m_FilenameMatchMode ) { case IDC_MATCH_FILENAMES: return File1 == File2; break; case IDC_MATCH_EXTENSIONS: return File1.Right( File1.GetLength() - File1.ReverseFind('.') - 1 ) == File2.Right( File2.GetLength() - File2.ReverseFind('.') - 1); break; case IDC_MATCH_NOTHING: return true; break; case IDC_MATCH_NOT_FILENAME: return File1 != File2; break; case IDC_MATCH_NOT_EXTENSIONS: return File1.Right( File1.GetLength() - File1.ReverseFind('.') - 1 ) != File2.Right( File2.GetLength() - File2.ReverseFind('.') - 1); break; default: AfxMessageBox("FMM_ERROR"); return true; break; } */ }
UINT CFileEvent::FileEventProc (LPVOID lpParam) { CFileEvent *pFileEvent = (CFileEvent*) lpParam; int nFilePathCount = pFileEvent->m_lstFilePath.GetCount (); HANDLE *phChanges = new HANDLE[nFilePathCount + 1]; for (int i;;) { *phChanges = pFileEvent->m_evWatching; POSITION pos = pos = pFileEvent->m_lstFilePath.GetHeadPosition (); CFilePath *pFilePath; int j = 0; for (i = 0; i < nFilePathCount; i++) { if (!pos) { nFilePathCount = i; break; } pFilePath = pFileEvent->m_lstFilePath.GetNext (pos); ASSERT (pFilePath); HANDLE hFC = FindFirstChangeNotification (pFilePath->GetPath(), FALSE, FILE_NOTIFY_CHANGE_LAST_WRITE|FILE_NOTIFY_CHANGE_SIZE|FILE_NOTIFY_CHANGE_FILE_NAME); if (hFC != INVALID_HANDLE_VALUE) // if i can gen a notification -- phChanges[++j] = hFC; } DWORD dwResult = WaitForMultipleObjects (j + 1, phChanges, FALSE, INFINITE); for (i = 1; i < j; i++) VERIFY (FindCloseChangeNotification (phChanges[i + 1])); if (dwResult == WAIT_OBJECT_0) break; int nPath = dwResult - WAIT_OBJECT_0 - 1; pos = pFileEvent->m_lstFilePath.FindIndex (nPath); //ASSERT (pos); if(pos == 0) { break; } pFilePath = pFileEvent->m_lstFilePath.GetAt (pos); //ASSERT (pFilePath); if(pFilePath == NULL) { break; } CString sPathName; CFileInfo *pFileInfo; for (pos = pFileEvent->m_mapFileInfo.GetStartPosition (); pos;) { pFileEvent->m_mapFileInfo.GetNextAssoc (pos, sPathName, pFileInfo); ASSERT (pFileInfo); if (!_tcscmp (pFilePath->GetPath (), pFileInfo->GetPath ())) { HANDLE hFile = CreateFile (sPathName, GENERIC_READ, FILE_SHARE_READ /*|FILE_SHARE_WRITE|FILE_SHARE_DELETE*/, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); // add at 2006-05-06 by blueant if (hFile == INVALID_HANDLE_VALUE) { // 文件保存过程中很大情况下返回的是无效句柄,需要延迟一段时间等保存完毕再打开 Sleep(50); hFile = CreateFile (sPathName, GENERIC_READ, FILE_SHARE_READ /*|FILE_SHARE_WRITE|FILE_SHARE_DELETE*/, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); } if (hFile != INVALID_HANDLE_VALUE) { FILETIME ftModified; VERIFY (GetFileTime (hFile, NULL, NULL, &ftModified)); DWORD dwSize; // ->HE dwSize= GetFileSize (hFile, NULL); ASSERT(dwSize != (DWORD)-1); // <-HE CloseHandle (hFile); WPARAM wEvent = FE_NONE; if (CompareFileTime (&pFileInfo->GetModified (), &ftModified) < 0) { pFileInfo->SetModified (ftModified); wEvent |= FE_CHANGED_TIME; } if (pFileInfo->GetSize () != dwSize) { pFileInfo->SetSize (dwSize); wEvent |= FE_CHANGED_SIZE; } if (wEvent) pFileEvent->OnFileEvent (wEvent, sPathName); } else { pFileEvent->OnFileEvent (FE_DELETED, sPathName); pFileEvent->RemoveFile (sPathName); } } } } delete [] phChanges; return 0; }
void CFileMoveProcess::ProcessFiles ( CList<CFileInfo *, CFileInfo *> & FileList) { CString Msg; SHFILEOPSTRUCT fos; TCHAR pDirBuffer[MAX_PATH]; TCHAR pFilenameBuffer[MAX_PATH]; CFileInfo * pFileInfo; POSITION ListPos; // setup to directory buffer // pDirBuffer = new TCHAR[m_Dir.GetLength()+2]; strcpy( pDirBuffer, (LPCSTR) m_Dir); pDirBuffer[m_Dir.GetLength()] = '\0'; pDirBuffer[m_Dir.GetLength()+1] = '\0'; // // setup struct fos.hwnd = AfxGetMainWnd()->m_hWnd; fos.wFunc= FO_MOVE; fos.pTo = pDirBuffer; fos.fFlags = FOF_ALLOWUNDO | FOF_NOERRORUI; fos.lpszProgressTitle = "NULL"; // // set confirmation flag if ( m_YesToAll ) fos.fFlags |= FOF_NOCONFIRMATION; // /* for ( int i = 0; i < FileList.GetSize(); i++) { //if ( ((CDuffDlg*)GetParent()->GetParent())->m_DuplicatePage.m_DupeList.GetCheck(i) == BST_CHECKED ) //{ Temp = FileList.ElementAt(i).m_Filename; //TotalLength += Temp.GetLength() +1; FilesToDelete.Add(Temp); //} } */ // update progress information pDuffStatus->Lock(); pDuffStatus->CurrentTaskStr = "Moving selected duplicate files..."; pDuffStatus->CurrentTaskInfo = ""; pDuffStatus->SubProgress1.Min = 0; pDuffStatus->SubProgress1.Pos = 0; pDuffStatus->SubProgress1.Max = FileList.GetCount(); pDuffStatus->Unlock(); // ListPos = FileList.GetHeadPosition(); while (ListPos) { pFileInfo = FileList.GetAt(ListPos); // process only the selected files if ( pFileInfo->Selected) { if ( ! (pFileInfo->Attributes & FILE_ATTRIBUTE_READONLY) || m_MoveReadOnly ) { /* // remove read-only attribute if ( FileList.ElementAt(i)->ReadOnly ) { DWORD FileAttributes; FileAttributes = GetFileAttributes( FileList.ElementAt(i)->Filename ) FileAttributes ^= FILE_ATTRIBUTE_READONLY; SetFileAttributes(FileList.ElementAt(i)->Filename,FileAttributes ); }*/ _tcscpy(pFilenameBuffer, pFileInfo->GetFullName() ); UINT Length = _tcslen( pFilenameBuffer ); // for (int x = 0; x < FileList.ElementAt(i)->Filename.GetLength(); x++) // { // pFilenameBuffer[x] = FileList.ElementAt(i)->Filename.GetAt(x); // } pFilenameBuffer[Length] = 0; pFilenameBuffer[Length+1] = 0; fos.pFrom = pFilenameBuffer; // g_DupeFileFind.GetDuffDlg()->m_CurrentTaskInfoText.SetWindowText(FileList.ElementAt(i)->GetFullName()); // g_DupeFileFind.GetDuffDlg()->m_CurrentTaskInfoText.RedrawWindow(); // update progress information pDuffStatus->Lock(); pDuffStatus->CurrentTaskInfo = pFileInfo->GetFullName(); pDuffStatus->SubProgress1.Pos++; pDuffStatus->Unlock(); // /* Msg.Format("Moving:\n%s\nto:\n%s",FileList.ElementAt(i)->m_Filename,fos.pTo); MessageBox(NULL,Msg,"FYI",MB_OK); */ if ( SHFileOperation(&fos) ) { Msg.Format("ERROR moving file: %s to %s",pFileInfo->GetFullName(),m_Dir); // g_DupeFileFind.GetDuffDlg()->Log(Msg); } else { Msg.Format("Moved file: %s to %s",pFileInfo->GetFullName(),m_Dir); // g_DupeFileFind.GetDuffDlg()->Log(Msg); } // g_DupeFileFind.GetDuffDlg()->m_ProgressEntire.StepIt(); // delete []pFilenameBuffer; } } FileList.GetNext(ListPos); } // delete[] pDirBuffer; }
bool CZipFileSystem::IsFileExists(const CFileInfo& filePath) const { return (FindFile(BasePath() + filePath.AbsolutePath()) != nullptr); }
bool DoesFileExist(LPCTSTR name) { CFileInfo fi; return fi.Find(name) && !fi.IsDir(); }
void CLodArchiveLoader::open(const CFileInfo & archive) { open(archive.getName()); }
bool DoesFileOrDirExist(CFSTR name) { CFileInfo fi; return fi.Find(name); }
STDMETHODIMP CAltStreamsFolder::CopyTo(Int32 moveMode, const UInt32 *indices, UInt32 numItems, Int32 /* includeAltStreams */, Int32 /* replaceAltStreamColon */, const wchar_t *path, IFolderOperationsExtractCallback *callback) { if (numItems == 0) return S_OK; /* CMyComPtr<IFolderExtractToStreamCallback> ExtractToStreamCallback; RINOK(callback->QueryInterface(IID_IFolderExtractToStreamCallback, (void **)&ExtractToStreamCallback)); if (ExtractToStreamCallback) { Int32 useStreams = 0; if (ExtractToStreamCallback->UseExtractToStream(&useStreams) != S_OK) useStreams = 0; if (useStreams == 0) ExtractToStreamCallback.Release(); } */ UInt64 totalSize = 0; { UInt32 i; for (i = 0; i < numItems; i++) { totalSize += Streams[indices[i]].Size; } RINOK(callback->SetTotal(totalSize)); RINOK(callback->SetNumFiles(numItems)); } /* if (ExtractToStreamCallback) { CGetProp *GetProp_Spec = new CGetProp; CMyComPtr<IGetProp> GetProp= GetProp_Spec; for (UInt32 i = 0; i < numItems; i++) { UInt32 index = indices[i]; const CAltStream &ss = Streams[index]; GetProp_Spec->Name = ss.Name; GetProp_Spec->Size = ss.Size; CMyComPtr<ISequentialOutStream> outStream; RINOK(ExtractToStreamCallback->GetStream7(GetProp_Spec->Name, BoolToInt(false), &outStream, NArchive::NExtract::NAskMode::kExtract, GetProp)); // isDir FString srcPath; GetFullPath(ss, srcPath); RINOK(ExtractToStreamCallback->PrepareOperation7(NArchive::NExtract::NAskMode::kExtract)); RINOK(ExtractToStreamCallback->SetOperationResult7(NArchive::NExtract::NOperationResult::kOK, BoolToInt(false))); // _encrypted // RINOK(CopyStream(state, srcPath, fi, ss, destPath2, callback, completedSize)); } return S_OK; } */ FString destPath = us2fs(path); if (destPath.IsEmpty() /* && !ExtractToStreamCallback */) return E_INVALIDARG; bool isAltDest = NName::IsAltPathPrefix(destPath);; bool isDirectPath = (!isAltDest && !IsPathSepar(destPath.Back())); if (isDirectPath) { if (numItems > 1) return E_INVALIDARG; } CFileInfo fi; if (!fi.Find(_pathBaseFile)) return GetLastError(); NFsFolder::CCopyStateIO state; state.Progress = callback; state.DeleteSrcFile = IntToBool(moveMode); state.TotalSize = totalSize; for (UInt32 i = 0; i < numItems; i++) { UInt32 index = indices[i]; const CAltStream &ss = Streams[index]; FString destPath2 = destPath; if (!isDirectPath) destPath2 += us2fs(Get_Correct_FsFile_Name(ss.Name)); FString srcPath; GetFullPath(ss, srcPath); RINOK(CopyStream(state, srcPath, fi, ss, destPath2, callback)); } return S_OK; }