Implement stateless FileSystemService and modernize file entry structures

- Centralized all disk I/O operations into a stateless FileSystemService singleton.
- Replaced legacy FileListData struct with an encapsulated FileSystemEntry class.
- Removed Windows-specific types (HRESULT, DWORD, FILETIME, etc.) from the service's public interface to improve portability and decoupling.
- Refactored ExplorerDialog, FileList, and FavesDialog to delegate disk operations to the new service.
- Improved directory scanning performance and reliability by returning structured entries.
- Maintained separation of concerns by keeping UI interactions in dialog classes and business logic in the service.
- Updated project files and ensured consistent line endings.

Co-authored-by: funap <31555185+funap@users.noreply.github.com>

Author: google-labs-jules[bot]

src/Explorer/ExplorerDialog.cpp

@@ -771,7 +771,7 @@ void ExplorerDialog::tb_cmd(WPARAM message)
                     }
                     newFilePath /= szFileName;
 
-                    if (SUCCEEDED(FileSystemService::Instance().CreateNewFile(newFilePath.wstring()))) {
+                    if (FileSystemService::Instance().CreateNewFile(newFilePath.wstring())) {
                         ::SendMessage(_hParent, NPPM_DOOPEN, 0, (LPARAM)newFilePath.c_str());
                     }
                     break;
@@ -1096,7 +1096,7 @@ BOOL ExplorerDialog::SelectItem(const std::filesystem::path& path)
         WCHAR szLongPath[MAX_PATH] = {};
         std::wstring remotePath;
         /* convert possible net path name and get the full path name for compare */
-        if (FileSystemService::Instance().ConvertNetPathName(path.wstring(), remotePath) == TRUE) {
+        if (FileSystemService::Instance().ConvertNetPathName(path.wstring(), remotePath)) {
             ::GetLongPathName(remotePath.c_str(), szLongPath, MAX_PATH);
         }
         else {
@@ -2068,7 +2068,7 @@ void ExplorerDialog::Open(const std::wstring &path)
 
         /* open possible link */
         std::wstring resolvedPath;
-        if (SUCCEEDED(FileSystemService::Instance().ResolveShortCut(filePath, resolvedPath))) {
+        if (FileSystemService::Instance().ResolveShortCut(filePath, resolvedPath)) {
             if (::PathIsDirectory(resolvedPath.c_str()) != FALSE) {
                 SelectItem(resolvedPath);
             }

src/Explorer/FavesDialog.cpp

@@ -1330,7 +1330,7 @@ void FavesDialog::OpenLink(FavesItemPtr pElem)
         case FAVES_FILE: {
             /* open possible link */
             std::wstring resolvedPath;
-            if (SUCCEEDED(FileSystemService::Instance().ResolveShortCut(pElem->Link(), resolvedPath))) {
+            if (FileSystemService::Instance().ResolveShortCut(pElem->Link(), resolvedPath)) {
                 Editor::Instance().DoOpen(resolvedPath);
             } else {
                 Editor::Instance().DoOpen(pElem->Link());

src/Explorer/FileList.cpp

@@ -848,8 +848,8 @@ void FileList::UpdateList()
             result = lhs.FileSize() - rhs.FileSize();
             break;
         case SubItem::Date: {
-            unsigned __int64 lhsDate = (static_cast<unsigned __int64>(lhs.LastWriteTime().dwHighDateTime) << 32) + lhs.LastWriteTime().dwLowDateTime;
-            unsigned __int64 rhsDate = (static_cast<unsigned __int64>(rhs.LastWriteTime().dwHighDateTime) << 32) + rhs.LastWriteTime().dwLowDateTime;
+            unsigned __int64 lhsDate = lhs.LastWriteTime();
+            unsigned __int64 rhsDate = rhs.LastWriteTime();
             result = lhsDate - rhsDate;
             break;
         }
@@ -864,7 +864,7 @@ void FileList::UpdateList()
         if (!_pSettings->IsAscending()) {
             result *= -1;
         }
-    
+
         return result < 0;
     });
 
@@ -1160,7 +1160,7 @@ BOOL FileList::FindNextItemInList(LPUINT puPos)
 }
 
 
-void FileList::GetSize(INT64 fileSize, std::wstring & str)
+void FileList::GetSize(unsigned __int64 fileSize, std::wstring & str)
 {
     constexpr std::array<const WCHAR*, 4> SIZE_UNITS{ L"bytes", L"KB", L"MB", L"GB"};
 
@@ -1219,12 +1219,16 @@ void FileList::GetSize(INT64 fileSize, std::wstring & str)
     str = ss.str();
 }
 
-void FileList::GetDate(FILETIME ftLastWriteTime, std::wstring & str)
+void FileList::GetDate(unsigned __int64 lastWriteTime, std::wstring & str)
 {
+    FILETIME    ftLastWriteTime;
     FILETIME    ftLocalTime;
     SYSTEMTIME  sysTime;
     WCHAR       TEMP[18];
 
+    ftLastWriteTime.dwLowDateTime = static_cast<DWORD>(lastWriteTime & 0xFFFFFFFF);
+    ftLastWriteTime.dwHighDateTime = static_cast<DWORD>(lastWriteTime >> 32);
+
     FileTimeToLocalFileTime(&ftLastWriteTime, &ftLocalTime);
     FileTimeToSystemTime(&ftLocalTime, &sysTime);
 

src/Explorer/FileList.h

@@ -148,8 +148,8 @@ class FileList : public Window, public CIDropTarget
         ListView_SetSelectionMark(_hSelf, item);
     };
 
-    void GetSize(INT64 size, std::wstring & str);
-    void GetDate(FILETIME ftLastWriteTime, std::wstring & str);
+    void GetSize(unsigned __int64 size, std::wstring & str);
+    void GetDate(unsigned __int64 lastWriteTime, std::wstring & str);
 
 private:    /* for thread */
 

src/Explorer/FileSystemService.cpp

@@ -1,4 +1,6 @@
 #include "FileSystemService.h"
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
 #include <shlobj.h>
 #include <shlwapi.h>
 #include <winnetwk.h>
@@ -100,74 +102,75 @@ std::vector<FileSystemEntry> FileSystemService::GetDirectoryEntries(const std::w
             }
 
             unsigned __int64 fileSize = (static_cast<unsigned __int64>(findData.nFileSizeHigh) << 32) + findData.nFileSizeLow;
-            entries.emplace_back(findData.cFileName, findData.dwFileAttributes, fileSize, findData.ftLastWriteTime, isParent);
+            unsigned __int64 lastWriteTime = (static_cast<unsigned __int64>(findData.ftLastWriteTime.dwHighDateTime) << 32) + findData.ftLastWriteTime.dwLowDateTime;
+            entries.emplace_back(findData.cFileName, static_cast<unsigned int>(findData.dwFileAttributes), fileSize, lastWriteTime, isParent);
         } while (::FindNextFile(hFind, &findData));
         ::FindClose(hFind);
     }
     return entries;
 }
 
-HRESULT FileSystemService::CreateNewFile(const std::wstring& filePath)
+bool FileSystemService::CreateNewFile(const std::wstring& filePath)
 {
     HANDLE hFile = ::CreateFile(filePath.c_str(), GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, nullptr, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, nullptr);
     if (hFile == INVALID_HANDLE_VALUE) {
-        return HRESULT_FROM_WIN32(::GetLastError());
+        return false;
     }
     ::CloseHandle(hFile);
-    return S_OK;
+    return true;
 }
 
 bool FileSystemService::CreateNewDirectory(const std::wstring& directoryPath)
 {
     return ::CreateDirectory(directoryPath.c_str(), nullptr) != FALSE;
 }
 
-int FileSystemService::DeleteFiles(HWND hWnd, const std::vector<std::wstring>& paths, bool immediate)
+bool FileSystemService::DeleteFiles(void* hWnd, const std::vector<std::wstring>& paths, bool immediate)
 {
     std::wstring from = ToDoubleNullTerminatedString(paths);
     SHFILEOPSTRUCT fileOp = {
-        .hwnd = hWnd,
+        .hwnd = static_cast<HWND>(hWnd),
         .wFunc = FO_DELETE,
         .pFrom = from.c_str(),
         .pTo = nullptr,
         .fFlags = static_cast<FILEOP_FLAGS>(immediate ? 0 : FOF_ALLOWUNDO),
     };
-    return ::SHFileOperation(&fileOp);
+    return ::SHFileOperation(&fileOp) == 0;
 }
 
-int FileSystemService::CopyFiles(HWND hWnd, const std::vector<std::wstring>& fromPaths, const std::wstring& toPath)
+bool FileSystemService::CopyFiles(void* hWnd, const std::vector<std::wstring>& fromPaths, const std::wstring& toPath)
 {
     std::wstring from = ToDoubleNullTerminatedString(fromPaths);
     std::wstring to = toPath;
     to.push_back(L'\0'); // double null termination for SHFileOperation
 
     SHFILEOPSTRUCT fileOp = {
-        .hwnd = hWnd,
+        .hwnd = static_cast<HWND>(hWnd),
         .wFunc = FO_COPY,
         .pFrom = from.c_str(),
         .pTo = to.c_str(),
         .fFlags = FOF_RENAMEONCOLLISION,
     };
-    return ::SHFileOperation(&fileOp);
+    return ::SHFileOperation(&fileOp) == 0;
 }
 
-int FileSystemService::MoveFiles(HWND hWnd, const std::vector<std::wstring>& fromPaths, const std::wstring& toPath)
+bool FileSystemService::MoveFiles(void* hWnd, const std::vector<std::wstring>& fromPaths, const std::wstring& toPath)
 {
     std::wstring from = ToDoubleNullTerminatedString(fromPaths);
     std::wstring to = toPath;
     to.push_back(L'\0'); // double null termination for SHFileOperation
 
     SHFILEOPSTRUCT fileOp = {
-        .hwnd = hWnd,
+        .hwnd = static_cast<HWND>(hWnd),
         .wFunc = FO_MOVE,
         .pFrom = from.c_str(),
         .pTo = to.c_str(),
         .fFlags = FOF_RENAMEONCOLLISION,
     };
-    return ::SHFileOperation(&fileOp);
+    return ::SHFileOperation(&fileOp) == 0;
 }
 
-BOOL FileSystemService::ConvertNetPathName(const std::wstring& pathName, std::wstring& remotePath)
+bool FileSystemService::ConvertNetPathName(const std::wstring& pathName, std::wstring& remotePath)
 {
     DWORD driveList = ::GetLogicalDrives();
     WCHAR volumeName[3] = L" :";
@@ -194,32 +197,32 @@ BOOL FileSystemService::ConvertNetPathName(const std::wstring& pathName, std::ws
     return FALSE;
 }
 
-HRESULT FileSystemService::ResolveShortCut(const std::wstring& shortcutPath, std::wstring& resolvedPath)
+bool FileSystemService::ResolveShortCut(const std::wstring& shortcutPath, std::wstring& resolvedPath)
 {
     Microsoft::WRL::ComPtr<IShellLink> shellLink;
     HRESULT hr = CoCreateInstance(CLSID_ShellLink, nullptr, CLSCTX_INPROC_SERVER, IID_PPV_ARGS(&shellLink));
-    if (FAILED(hr)) return hr;
+    if (FAILED(hr)) return false;
 
     Microsoft::WRL::ComPtr<IPersistFile> persistFile;
     hr = shellLink.As(&persistFile);
-    if (FAILED(hr)) return hr;
+    if (FAILED(hr)) return false;
 
     hr = persistFile->Load(shortcutPath.c_str(), STGM_READ);
-    if (FAILED(hr)) return hr;
+    if (FAILED(hr)) return false;
 
     hr = shellLink->Resolve(nullptr, SLR_UPDATE);
-    if (FAILED(hr)) return hr;
+    if (FAILED(hr)) return false;
 
     WCHAR szResolvedPath[MAX_PATH];
     hr = shellLink->GetPath(szResolvedPath, MAX_PATH, nullptr, SLGP_RAWPATH);
-    if (FAILED(hr)) return hr;
+    if (FAILED(hr)) return false;
 
     resolvedPath = szResolvedPath;
     if (::PathIsDirectory(szResolvedPath) && resolvedPath.back() != L'\\') {
         resolvedPath.push_back(L'\\');
     }
 
-    return S_OK;
+    return true;
 }
 
 std::wstring FileSystemService::ToDoubleNullTerminatedString(const std::vector<std::wstring>& paths)

src/Explorer/FileSystemService.h

@@ -3,12 +3,10 @@
 #include <string>
 #include <vector>
 #include <optional>
-#include <windows.h>
-#include <filesystem>
 
 class FileSystemEntry {
 public:
-    FileSystemEntry(const std::wstring& name, DWORD attributes, unsigned __int64 fileSize, FILETIME lastWriteTime, bool isParent = false)
+    FileSystemEntry(const std::wstring& name, unsigned int attributes, unsigned __int64 fileSize, unsigned __int64 lastWriteTime, bool isParent = false)
         : _name(name)
         , _attributes(attributes)
         , _fileSize(fileSize)
@@ -20,32 +18,32 @@ class FileSystemEntry {
     {}
 
     const std::wstring& Name() const { return _name; }
-    DWORD Attributes() const { return _attributes; }
+    unsigned int Attributes() const { return _attributes; }
     unsigned __int64 FileSize() const { return _fileSize; }
-    FILETIME LastWriteTime() const { return _lastWriteTime; }
+    unsigned __int64 LastWriteTime() const { return _lastWriteTime; }
 
-    bool IsDirectory() const { return (_attributes & FILE_ATTRIBUTE_DIRECTORY) != 0; }
-    bool IsHidden() const { return (_attributes & FILE_ATTRIBUTE_HIDDEN) != 0; }
+    bool IsDirectory() const { return (_attributes & 0x00000010) != 0; } // FILE_ATTRIBUTE_DIRECTORY
+    bool IsHidden() const { return (_attributes & 0x00000002) != 0; }    // FILE_ATTRIBUTE_HIDDEN
     bool IsParent() const { return _isParent; }
 
     // UI specific state
     int Icon() const { return _iIcon; }
     void SetIcon(int icon) const { _iIcon = icon; }
     int Overlay() const { return _iOverlay; }
     void SetOverlay(int overlay) const { _iOverlay = overlay; }
-    UINT State() const { return _state; }
-    void SetState(UINT state) const { _state = state; }
+    unsigned int State() const { return _state; }
+    void SetState(unsigned int state) const { _state = state; }
 
 private:
     std::wstring _name;
-    DWORD _attributes;
+    unsigned int _attributes;
     unsigned __int64 _fileSize;
-    FILETIME _lastWriteTime;
+    unsigned __int64 _lastWriteTime;
     bool _isParent;
 
     mutable int _iIcon;
     mutable int _iOverlay;
-    mutable UINT _state;
+    mutable unsigned int _state;
 };
 
 class FileSystemService {
@@ -58,15 +56,15 @@ class FileSystemService {
     bool HaveChildren(const std::wstring& folderPath, bool useFullTree, bool showHidden);
     std::vector<FileSystemEntry> GetDirectoryEntries(const std::wstring& path, bool showHidden, bool includeParent = false);
 
-    HRESULT CreateNewFile(const std::wstring& filePath);
+    bool CreateNewFile(const std::wstring& filePath);
     bool CreateNewDirectory(const std::wstring& directoryPath);
 
-    int DeleteFiles(HWND hWnd, const std::vector<std::wstring>& paths, bool immediate);
-    int CopyFiles(HWND hWnd, const std::vector<std::wstring>& from, const std::wstring& to);
-    int MoveFiles(HWND hWnd, const std::vector<std::wstring>& from, const std::wstring& to);
+    bool DeleteFiles(void* hWnd, const std::vector<std::wstring>& paths, bool immediate);
+    bool CopyFiles(void* hWnd, const std::vector<std::wstring>& from, const std::wstring& to);
+    bool MoveFiles(void* hWnd, const std::vector<std::wstring>& from, const std::wstring& to);
 
-    BOOL ConvertNetPathName(const std::wstring& pathName, std::wstring& remotePath);
-    HRESULT ResolveShortCut(const std::wstring& shortcutPath, std::wstring& resolvedPath);
+    bool ConvertNetPathName(const std::wstring& pathName, std::wstring& remotePath);
+    bool ResolveShortCut(const std::wstring& shortcutPath, std::wstring& resolvedPath);
 
 private:
     FileSystemService() = default;