Merge branch 'fix/folders'

Author: planetchili

IntelPresentMon/AppCef/ipm-ui-vue/src/stores/preferences.ts

@@ -159,8 +159,8 @@ export const usePreferencesStore = defineStore('preferences', () => {
       await hotkeys.bindDefaults();
       resetPreferences();
       preferences.value.selectedPreset = Preset.Slot1;
-      console.warn('Preferences reset due to load failure: ' + e)
-      notes.notify({ text: `Preferences reset due to load failure: ${e}` })
+      serialize();
+      console.info('Preferences reset due to load failure: ' + e);
     }
   }
 

IntelPresentMon/AppCef/source/util/async/BrowseStoreSpec.h

@@ -18,8 +18,8 @@ namespace p2c::client::util::async
         // {payload: string} => {written: bool}
 		void ExecuteOnBrowser(uint64_t uid, CefRefPtr<CefValue> pArgObj, CefRefPtr<CefBrowser> pBrowser) const override
 		{
-            using infra::util::FolderResolver;
-            std::wstring startPath = FolderResolver::Get().Resolve(FolderResolver::Folder::Documents, L"Loadouts\\");
+            using FR = infra::util::FolderResolver;
+            std::wstring startPath = FR::Get().Resolve(FR::Folder::Documents, FR::loadoutsSubdirectory);
 
             wchar_t pathBuffer[MAX_PATH] = { 0 };
             OPENFILENAMEW ofn{

IntelPresentMon/AppCef/source/util/async/LoadFile.h

@@ -29,7 +29,7 @@ namespace p2c::client::util::async
             }
             else {
                 auto s = std::format("Unable to open file path: {}", filePath.string());
-                pmlog_error(s);
+                pmlog_warn(s);
                 throw std::runtime_error{ s };
             }
         }

IntelPresentMon/Core/source/infra/util/FolderResolver.cpp

@@ -25,16 +25,14 @@ namespace p2c::infra::util
 
 	FolderResolver::FolderResolver(std::wstring appPathSubdir, std::wstring docPathSubdir, bool createSubdirectories)
 	{
-		if (!appPathSubdir.empty())
-		{
+		if (!appPathSubdir.empty()) {
 			wchar_t* pPath = nullptr;
-			if (auto hr = SHGetKnownFolderPath(FOLDERID_LocalAppData, 0, nullptr, &pPath); FAILED(hr))
-			{
+			if (auto hr = SHGetKnownFolderPath(FOLDERID_LocalAppData, 0, nullptr, &pPath); FAILED(hr)) {
 				CoTaskMemFree(pPath);
 				pPath = nullptr;
 				pmlog_error("Failed getting local app data path");
 				throw Except<Exception>();
-							}
+			}
 			const auto dir = std::format(L"{}\\{}", pPath, appPathSubdir);
 			try {
 				std::filesystem::create_directories(dir);
@@ -46,26 +44,22 @@ namespace p2c::infra::util
 				pmlog_error("Failed creating directory: " + str::ToNarrow(dir));
 				throw Except<Exception>();
 			}
-			if (pPath)
-			{
+			if (pPath) {
 				CoTaskMemFree(pPath);
 			}
 		}
-		else
-		{
+		else {
 			appPath = std::filesystem::current_path().wstring();
 		}
 
-		if (!docPathSubdir.empty())
-		{
+		if (!docPathSubdir.empty()) {
 			wchar_t* pPath = nullptr;
-			if (auto hr = SHGetKnownFolderPath(FOLDERID_Documents, 0, nullptr, &pPath); FAILED(hr))
-			{
+			if (auto hr = SHGetKnownFolderPath(FOLDERID_Documents, 0, nullptr, &pPath); FAILED(hr)) {
 				CoTaskMemFree(pPath);
 				pPath = nullptr;
 				pmlog_error("Failed getting user documents path");
 				throw Except<Exception>();
-							}
+			}
 			const auto dir = std::format(L"{}\\{}", pPath, docPathSubdir);
 			try {
 				std::filesystem::create_directories(dir);
@@ -77,13 +71,11 @@ namespace p2c::infra::util
 				pmlog_error("Failed creating directory: " + str::ToNarrow(dir));
 				throw Except<Exception>();
 			}
-			if (pPath)
-			{
+			if (pPath) {
 				CoTaskMemFree(pPath);
 			}
 		}
-		else
-		{
+		else {
 			docPath = std::filesystem::current_path().wstring();
 		}
 
@@ -97,50 +89,39 @@ namespace p2c::infra::util
 
 	std::wstring FolderResolver::Resolve(Folder f, std::wstring path) const
 	{
-		switch (f)
-		{
+		switch (f) {
 		case Folder::App:
-			if (appPath.empty())
-			{
+			if (appPath.empty()) {
 				pmlog_error("Failed to resolve app path: not initialized");
 				throw Except<Exception>();
 			}
-			if (path.empty())
-			{
+			if (path.empty()) {
 				return appPath;
 			}
-			else
-			{
+			else {
 				return std::format(L"{}\\{}", appPath, path);
 			}
-		case Folder::Documents:
-		{
-			if (docPath.empty())
-			{
+		case Folder::Documents: {
+			if (docPath.empty()) {
 				pmlog_error("Failed to resolve documents path: not initialized");
 				throw Except<Exception>();
 			}
-			if (path.empty())
-			{
+			if (path.empty()) {
 				return docPath;
 			}
-			else
-			{
+			else {
 				return std::format(L"{}\\{}", docPath, path);
 			}
 		}
-		case Folder::Temp:
-		{
+		case Folder::Temp: {
 			wchar_t tempPath[MAX_PATH + 1];
-			if (!GetTempPathW(MAX_PATH, tempPath))
-			{
+			if (!GetTempPathW(MAX_PATH, tempPath)) {
 				pmlog_error("failed resolving temp dir").hr();
 				throw Except<Exception>();
 			}
 			return std::format(L"{}{}", tempPath, path);
 		}
-		case Folder::Install:
-		{
+		case Folder::Install: {
 			wchar_t modulePath[MAX_PATH];
 			::GetModuleFileNameW(nullptr, modulePath, (DWORD)std::size(modulePath));
 			const auto dir = std::filesystem::path{ modulePath }.remove_filename().wstring();

IntelPresentMon/Core/source/kernel/Overlay.cpp

@@ -436,14 +436,14 @@ namespace p2c::kern
             }
             else {
                 const auto folder = FR::Get().Resolve(FR::Folder::Documents, FR::capturesSubdirectory);
-                fullPath = std::format(L"{0}{1}-{3}-{2:%y}{2:%m}{2:%d}-{2:%H}{2:%M}{2:%OS}.csv",
+                fullPath = std::format(L"{0}\\{1}-{3}-{2:%y}{2:%m}{2:%d}-{2:%H}{2:%M}{2:%OS}.csv",
                     folder, pSpec->captureName, now, proc.name);
             }
             // create optional path for stats file
             auto fullStatsPath = [&]() -> std::optional<std::wstring> {
                 if (pSpec->generateStats) {
                     const auto folder = FR::Get().Resolve(FR::Folder::Documents, FR::capturesSubdirectory);
-                    return std::format(L"{0}{1}-{3}-{2:%y}{2:%m}{2:%d}-{2:%H}{2:%M}{2:%OS}-stats.csv",
+                    return std::format(L"{0}\\{1}-{3}-{2:%y}{2:%m}{2:%d}-{2:%H}{2:%M}{2:%OS}-stats.csv",
                         folder, pSpec->captureName, now, proc.name);
                 }
                 else {