From 10b0690064d018b02ac9aaaef2e58da047cf127a Mon Sep 17 00:00:00 2001 From: Marco Gavelli Date: Wed, 17 Apr 2024 22:09:06 +0200 Subject: [PATCH] Code Quality: Added Save dialog project (#15208) --- Files.sln | 93 ++ .../Files.App.OpenDialog.Win32.vcxproj | 475 +++++++ src/Files.App.OpenDialog/FilesOpenDialog.cpp | 42 +- src/Files.App.OpenDialog/FilesOpenDialog.h | 2 +- src/Files.App.SaveDialog/CustomSaveDialog.cpp | 74 ++ src/Files.App.SaveDialog/CustomSaveDialog.def | 10 + src/Files.App.SaveDialog/CustomSaveDialog.idl | 32 + src/Files.App.SaveDialog/CustomSaveDialog.rc | Bin 0 -> 6120 bytes src/Files.App.SaveDialog/CustomSaveDialog.rgs | 3 + .../CustomSaveDialogps.def | 8 + .../Files.App.SaveDialog.Win32.vcxproj | 475 +++++++ .../Files.App.SaveDialog.vcxproj | 475 +++++++ .../Files.App.SaveDialog.vcxproj.filters | 91 ++ .../FilesDialogEvents.cpp | 84 ++ src/Files.App.SaveDialog/FilesDialogEvents.h | 27 + src/Files.App.SaveDialog/FilesSaveDialog.cpp | 1106 +++++++++++++++++ src/Files.App.SaveDialog/FilesSaveDialog.h | 273 ++++ src/Files.App.SaveDialog/FilesSaveDialog.rgs | 16 + src/Files.App.SaveDialog/UndefInterfaces.h | 89 ++ src/Files.App.SaveDialog/dllmain.cpp | 16 + src/Files.App.SaveDialog/dllmain.h | 10 + src/Files.App.SaveDialog/framework.h | 21 + src/Files.App.SaveDialog/pch.cpp | 5 + src/Files.App.SaveDialog/pch.h | 13 + src/Files.App.SaveDialog/resource.h | 18 + src/Files.App.SaveDialog/targetver.h | 8 + src/Files.App/App.xaml.cs | 35 +- .../FilesOpenDialog/CustomOpenDialog64.dll | Bin 474112 -> 0 bytes src/Files.App/Program.cs | 16 +- .../ViewModels/Settings/AdvancedViewModel.cs | 31 +- .../Views/Settings/AdvancedPage.xaml | 2 +- 31 files changed, 3508 insertions(+), 42 deletions(-) create mode 100644 src/Files.App.OpenDialog/Files.App.OpenDialog.Win32.vcxproj create mode 100644 src/Files.App.SaveDialog/CustomSaveDialog.cpp create mode 100644 src/Files.App.SaveDialog/CustomSaveDialog.def create mode 100644 src/Files.App.SaveDialog/CustomSaveDialog.idl create mode 100644 src/Files.App.SaveDialog/CustomSaveDialog.rc create mode 100644 src/Files.App.SaveDialog/CustomSaveDialog.rgs create mode 100644 src/Files.App.SaveDialog/CustomSaveDialogps.def create mode 100644 src/Files.App.SaveDialog/Files.App.SaveDialog.Win32.vcxproj create mode 100644 src/Files.App.SaveDialog/Files.App.SaveDialog.vcxproj create mode 100644 src/Files.App.SaveDialog/Files.App.SaveDialog.vcxproj.filters create mode 100644 src/Files.App.SaveDialog/FilesDialogEvents.cpp create mode 100644 src/Files.App.SaveDialog/FilesDialogEvents.h create mode 100644 src/Files.App.SaveDialog/FilesSaveDialog.cpp create mode 100644 src/Files.App.SaveDialog/FilesSaveDialog.h create mode 100644 src/Files.App.SaveDialog/FilesSaveDialog.rgs create mode 100644 src/Files.App.SaveDialog/UndefInterfaces.h create mode 100644 src/Files.App.SaveDialog/dllmain.cpp create mode 100644 src/Files.App.SaveDialog/dllmain.h create mode 100644 src/Files.App.SaveDialog/framework.h create mode 100644 src/Files.App.SaveDialog/pch.cpp create mode 100644 src/Files.App.SaveDialog/pch.h create mode 100644 src/Files.App.SaveDialog/resource.h create mode 100644 src/Files.App.SaveDialog/targetver.h delete mode 100644 src/Files.App/Assets/FilesOpenDialog/CustomOpenDialog64.dll diff --git a/Files.sln b/Files.sln index 9ee97dfae037..e6ffde265833 100644 --- a/Files.sln +++ b/Files.sln @@ -27,6 +27,10 @@ EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Files.App", "src\Files.App\Files.App.csproj", "{6F431D82-A5FF-4833-B5E4-702E1E523126}" ProjectSection(ProjectDependencies) = postProject {1EE996D6-885E-4403-A461-26C7A4E14D26} = {1EE996D6-885E-4403-A461-26C7A4E14D26} + {A2FF3F3B-8EBC-4108-B99D-1476B7876656} = {A2FF3F3B-8EBC-4108-B99D-1476B7876656} + {EBFA367F-CBDB-4CD0-B838-D6B95F61D1F6} = {EBFA367F-CBDB-4CD0-B838-D6B95F61D1F6} + {7756A1A4-17B5-4E6B-9B12-F19AA868A225} = {7756A1A4-17B5-4E6B-9B12-F19AA868A225} + {B3FE3F3B-CECC-4918-B72B-5488C3774125} = {B3FE3F3B-CECC-4918-B72B-5488C3774125} EndProjectSection EndProject Project("{C7167F0D-BC9F-4E6E-AFE1-012C56B48DB5}") = "Files.Package", "src\Files.App (Package)\Files.Package.wapproj", "{8F60FD8E-1921-47D6-97B0-D26D7B3A4999}" @@ -35,6 +39,12 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Files.Core.SourceGenerator" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Files.App.Server", "src\Files.App.Server\Files.App.Server.csproj", "{1EE996D6-885E-4403-A461-26C7A4E14D26}" EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Files.App.SaveDialog", "src\Files.App.SaveDialog\Files.App.SaveDialog.vcxproj", "{EBFA367F-CBDB-4CD0-B838-D6B95F61D1F6}" +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Files.App.SaveDialog.Win32", "src\Files.App.SaveDialog\Files.App.SaveDialog.Win32.vcxproj", "{7756A1A4-17B5-4E6B-9B12-F19AA868A225}" +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Files.App.OpenDialog.Win32", "src\Files.App.OpenDialog\Files.App.OpenDialog.Win32.vcxproj", "{B3FE3F3B-CECC-4918-B72B-5488C3774125}" +EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|arm64 = Debug|arm64 @@ -411,6 +421,86 @@ Global {1EE996D6-885E-4403-A461-26C7A4E14D26}.Store|x64.Build.0 = Store|x64 {1EE996D6-885E-4403-A461-26C7A4E14D26}.Store|x86.ActiveCfg = Store|x86 {1EE996D6-885E-4403-A461-26C7A4E14D26}.Store|x86.Build.0 = Store|x86 + {EBFA367F-CBDB-4CD0-B838-D6B95F61D1F6}.Debug|arm64.ActiveCfg = Debug|x64 + {EBFA367F-CBDB-4CD0-B838-D6B95F61D1F6}.Debug|arm64.Build.0 = Debug|x64 + {EBFA367F-CBDB-4CD0-B838-D6B95F61D1F6}.Debug|x64.ActiveCfg = Debug|x64 + {EBFA367F-CBDB-4CD0-B838-D6B95F61D1F6}.Debug|x64.Build.0 = Debug|x64 + {EBFA367F-CBDB-4CD0-B838-D6B95F61D1F6}.Debug|x86.ActiveCfg = Debug|Win32 + {EBFA367F-CBDB-4CD0-B838-D6B95F61D1F6}.Debug|x86.Build.0 = Debug|Win32 + {EBFA367F-CBDB-4CD0-B838-D6B95F61D1F6}.Preview|arm64.ActiveCfg = Debug|x64 + {EBFA367F-CBDB-4CD0-B838-D6B95F61D1F6}.Preview|arm64.Build.0 = Debug|x64 + {EBFA367F-CBDB-4CD0-B838-D6B95F61D1F6}.Preview|x64.ActiveCfg = Debug|x64 + {EBFA367F-CBDB-4CD0-B838-D6B95F61D1F6}.Preview|x64.Build.0 = Debug|x64 + {EBFA367F-CBDB-4CD0-B838-D6B95F61D1F6}.Preview|x86.ActiveCfg = Debug|Win32 + {EBFA367F-CBDB-4CD0-B838-D6B95F61D1F6}.Preview|x86.Build.0 = Debug|Win32 + {EBFA367F-CBDB-4CD0-B838-D6B95F61D1F6}.Release|arm64.ActiveCfg = Release|x64 + {EBFA367F-CBDB-4CD0-B838-D6B95F61D1F6}.Release|arm64.Build.0 = Release|x64 + {EBFA367F-CBDB-4CD0-B838-D6B95F61D1F6}.Release|x64.ActiveCfg = Release|x64 + {EBFA367F-CBDB-4CD0-B838-D6B95F61D1F6}.Release|x64.Build.0 = Release|x64 + {EBFA367F-CBDB-4CD0-B838-D6B95F61D1F6}.Release|x86.ActiveCfg = Release|Win32 + {EBFA367F-CBDB-4CD0-B838-D6B95F61D1F6}.Release|x86.Build.0 = Release|Win32 + {EBFA367F-CBDB-4CD0-B838-D6B95F61D1F6}.Stable|arm64.ActiveCfg = Debug|x64 + {EBFA367F-CBDB-4CD0-B838-D6B95F61D1F6}.Stable|arm64.Build.0 = Debug|x64 + {EBFA367F-CBDB-4CD0-B838-D6B95F61D1F6}.Stable|x64.ActiveCfg = Debug|x64 + {EBFA367F-CBDB-4CD0-B838-D6B95F61D1F6}.Stable|x64.Build.0 = Debug|x64 + {EBFA367F-CBDB-4CD0-B838-D6B95F61D1F6}.Stable|x86.ActiveCfg = Debug|Win32 + {EBFA367F-CBDB-4CD0-B838-D6B95F61D1F6}.Stable|x86.Build.0 = Debug|Win32 + {EBFA367F-CBDB-4CD0-B838-D6B95F61D1F6}.Store|arm64.ActiveCfg = Debug|x64 + {EBFA367F-CBDB-4CD0-B838-D6B95F61D1F6}.Store|arm64.Build.0 = Debug|x64 + {EBFA367F-CBDB-4CD0-B838-D6B95F61D1F6}.Store|x64.ActiveCfg = Debug|x64 + {EBFA367F-CBDB-4CD0-B838-D6B95F61D1F6}.Store|x64.Build.0 = Debug|x64 + {EBFA367F-CBDB-4CD0-B838-D6B95F61D1F6}.Store|x86.ActiveCfg = Debug|Win32 + {EBFA367F-CBDB-4CD0-B838-D6B95F61D1F6}.Store|x86.Build.0 = Debug|Win32 + {7756A1A4-17B5-4E6B-9B12-F19AA868A225}.Debug|arm64.ActiveCfg = Debug|Win32 + {7756A1A4-17B5-4E6B-9B12-F19AA868A225}.Debug|arm64.Build.0 = Debug|Win32 + {7756A1A4-17B5-4E6B-9B12-F19AA868A225}.Debug|x64.ActiveCfg = Debug|Win32 + {7756A1A4-17B5-4E6B-9B12-F19AA868A225}.Debug|x64.Build.0 = Debug|Win32 + {7756A1A4-17B5-4E6B-9B12-F19AA868A225}.Preview|arm64.ActiveCfg = Debug|Win32 + {7756A1A4-17B5-4E6B-9B12-F19AA868A225}.Preview|arm64.Build.0 = Debug|Win32 + {7756A1A4-17B5-4E6B-9B12-F19AA868A225}.Preview|x64.ActiveCfg = Debug|Win32 + {7756A1A4-17B5-4E6B-9B12-F19AA868A225}.Preview|x64.Build.0 = Debug|Win32 + {7756A1A4-17B5-4E6B-9B12-F19AA868A225}.Release|arm64.ActiveCfg = Release|Win32 + {7756A1A4-17B5-4E6B-9B12-F19AA868A225}.Release|arm64.Build.0 = Release|Win32 + {7756A1A4-17B5-4E6B-9B12-F19AA868A225}.Release|x64.ActiveCfg = Release|Win32 + {7756A1A4-17B5-4E6B-9B12-F19AA868A225}.Release|x64.Build.0 = Release|Win32 + {7756A1A4-17B5-4E6B-9B12-F19AA868A225}.Stable|arm64.ActiveCfg = Debug|Win32 + {7756A1A4-17B5-4E6B-9B12-F19AA868A225}.Stable|arm64.Build.0 = Debug|Win32 + {7756A1A4-17B5-4E6B-9B12-F19AA868A225}.Stable|x64.ActiveCfg = Debug|Win32 + {7756A1A4-17B5-4E6B-9B12-F19AA868A225}.Stable|x64.Build.0 = Debug|Win32 + {7756A1A4-17B5-4E6B-9B12-F19AA868A225}.Store|arm64.ActiveCfg = Debug|Win32 + {7756A1A4-17B5-4E6B-9B12-F19AA868A225}.Store|arm64.Build.0 = Debug|Win32 + {7756A1A4-17B5-4E6B-9B12-F19AA868A225}.Store|x64.ActiveCfg = Debug|Win32 + {7756A1A4-17B5-4E6B-9B12-F19AA868A225}.Store|x64.Build.0 = Debug|Win32 + {7756A1A4-17B5-4E6B-9B12-F19AA868A225}.Store|x86.ActiveCfg = Debug|Win32 + {7756A1A4-17B5-4E6B-9B12-F19AA868A225}.Debug|x86.ActiveCfg = Debug|Win32 + {7756A1A4-17B5-4E6B-9B12-F19AA868A225}.Preview|x86.ActiveCfg = Debug|Win32 + {7756A1A4-17B5-4E6B-9B12-F19AA868A225}.Release|x86.ActiveCfg = Release|Win32 + {7756A1A4-17B5-4E6B-9B12-F19AA868A225}.Stable|x86.ActiveCfg = Debug|Win32 + {B3FE3F3B-CECC-4918-B72B-5488C3774125}.Debug|arm64.ActiveCfg = Debug|Win32 + {B3FE3F3B-CECC-4918-B72B-5488C3774125}.Debug|arm64.Build.0 = Debug|Win32 + {B3FE3F3B-CECC-4918-B72B-5488C3774125}.Debug|x64.ActiveCfg = Debug|Win32 + {B3FE3F3B-CECC-4918-B72B-5488C3774125}.Debug|x64.Build.0 = Debug|Win32 + {B3FE3F3B-CECC-4918-B72B-5488C3774125}.Preview|arm64.ActiveCfg = Debug|Win32 + {B3FE3F3B-CECC-4918-B72B-5488C3774125}.Preview|arm64.Build.0 = Debug|Win32 + {B3FE3F3B-CECC-4918-B72B-5488C3774125}.Preview|x64.ActiveCfg = Debug|Win32 + {B3FE3F3B-CECC-4918-B72B-5488C3774125}.Preview|x64.Build.0 = Debug|Win32 + {B3FE3F3B-CECC-4918-B72B-5488C3774125}.Release|arm64.ActiveCfg = Release|Win32 + {B3FE3F3B-CECC-4918-B72B-5488C3774125}.Release|arm64.Build.0 = Release|Win32 + {B3FE3F3B-CECC-4918-B72B-5488C3774125}.Release|x64.ActiveCfg = Release|Win32 + {B3FE3F3B-CECC-4918-B72B-5488C3774125}.Release|x64.Build.0 = Release|Win32 + {B3FE3F3B-CECC-4918-B72B-5488C3774125}.Stable|arm64.ActiveCfg = Debug|Win32 + {B3FE3F3B-CECC-4918-B72B-5488C3774125}.Stable|arm64.Build.0 = Debug|Win32 + {B3FE3F3B-CECC-4918-B72B-5488C3774125}.Stable|x64.ActiveCfg = Debug|Win32 + {B3FE3F3B-CECC-4918-B72B-5488C3774125}.Stable|x64.Build.0 = Debug|Win32 + {B3FE3F3B-CECC-4918-B72B-5488C3774125}.Store|arm64.ActiveCfg = Debug|Win32 + {B3FE3F3B-CECC-4918-B72B-5488C3774125}.Store|arm64.Build.0 = Debug|Win32 + {B3FE3F3B-CECC-4918-B72B-5488C3774125}.Store|x64.ActiveCfg = Debug|Win32 + {B3FE3F3B-CECC-4918-B72B-5488C3774125}.Store|x64.Build.0 = Debug|Win32 + {B3FE3F3B-CECC-4918-B72B-5488C3774125}.Store|x86.ActiveCfg = Debug|Win32 + {B3FE3F3B-CECC-4918-B72B-5488C3774125}.Debug|x86.ActiveCfg = Debug|Win32 + {B3FE3F3B-CECC-4918-B72B-5488C3774125}.Preview|x86.ActiveCfg = Debug|Win32 + {B3FE3F3B-CECC-4918-B72B-5488C3774125}.Release|x86.ActiveCfg = Release|Win32 + {B3FE3F3B-CECC-4918-B72B-5488C3774125}.Stable|x86.ActiveCfg = Debug|Win32 EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE @@ -429,6 +519,9 @@ Global {8F60FD8E-1921-47D6-97B0-D26D7B3A4999} = {A188C26B-E731-4E0B-9D17-D21CEBD9B43F} {6FA07816-DE0A-4D49-84E8-38E953A33C87} = {9F36C2AD-005D-4EA5-A1F1-6BC42773FC85} {1EE996D6-885E-4403-A461-26C7A4E14D26} = {A188C26B-E731-4E0B-9D17-D21CEBD9B43F} + {EBFA367F-CBDB-4CD0-B838-D6B95F61D1F6} = {A188C26B-E731-4E0B-9D17-D21CEBD9B43F} + {7756A1A4-17B5-4E6B-9B12-F19AA868A225} = {A188C26B-E731-4E0B-9D17-D21CEBD9B43F} + {B3FE3F3B-CECC-4918-B72B-5488C3774125} = {A188C26B-E731-4E0B-9D17-D21CEBD9B43F} EndGlobalSection GlobalSection(ExtensibilityGlobals) = postSolution SolutionGuid = {0E62043C-A7A1-4982-9EC9-4CDB2939B776} diff --git a/src/Files.App.OpenDialog/Files.App.OpenDialog.Win32.vcxproj b/src/Files.App.OpenDialog/Files.App.OpenDialog.Win32.vcxproj new file mode 100644 index 000000000000..ee88f5b2972c --- /dev/null +++ b/src/Files.App.OpenDialog/Files.App.OpenDialog.Win32.vcxproj @@ -0,0 +1,475 @@ + + + + + + + Debug + arm64 + + + Debug + Win32 + + + Preview + arm64 + + + Preview + Win32 + + + Preview + x64 + + + Release + arm64 + + + Release + Win32 + + + Debug + x64 + + + Release + x64 + + + Sideload + arm64 + + + Sideload + Win32 + + + Sideload + x64 + + + Stable + arm64 + + + Stable + Win32 + + + Stable + x64 + + + Store + arm64 + + + Store + Win32 + + + Store + x64 + + + + + 16.0 + {B3FE3F3B-CECC-4918-B72B-5488C3774125} + AtlProj + 10.0 + DynamicLibrary + true + v143 + Unicode + + + + + + + + true + true + ..\..\artifacts\$(Configuration)\$(Platform)\$(MSBuildProjectName)\ + ..\..\artifacts\intermediates\$(Platform)\$(MSBuildProjectName)\ + Files.App.OpenDialog$(PlatformArchitecture) + + + + true + false + false + ..\..\artifacts\$(Configuration)\$(Platform)\$(MSBuildProjectName)\ + ..\..\artifacts\intermediates\$(Platform)\$(MSBuildProjectName)\ + Files.App.OpenDialog$(PlatformArchitecture) + + + + + Use + Level3 + pch.h + true + + + false + CustomOpenDialog_i.h + CustomOpenDialog_i.c + CustomOpenDialog_p.c + true + $(IntDir)CustomOpenDialog.tlb + true + + + 0x0410 + $(IntDir);%(AdditionalIncludeDirectories) + + + Windows + .\CustomOpenDialog.def + false + true + $(OutDir)Files.App.OpenDialog$(PlatformArchitecture)$(TargetExt) + + + xcopy /s /y "$(ProjectDir)$(OutDir)*.dll" "$(ProjectDir)..\..\src\Files.App\Assets\FilesOpenDialog" + + + + + + Disabled + WIN32;_WINDOWS;_DEBUG;_USRDLL;%(PreprocessorDefinitions) + + + Win32 + _DEBUG;%(PreprocessorDefinitions) + + + _DEBUG;%(PreprocessorDefinitions) + + + + + + Disabled + _WINDOWS;_DEBUG;_USRDLL;%(PreprocessorDefinitions) + + + _DEBUG;%(PreprocessorDefinitions) + + + _DEBUG;%(PreprocessorDefinitions) + + + + + + Disabled + _WINDOWS;_DEBUG;_USRDLL;%(PreprocessorDefinitions) + + + _DEBUG;%(PreprocessorDefinitions) + + + _DEBUG;%(PreprocessorDefinitions) + + + + + + MaxSpeed + WIN32;_WINDOWS;NDEBUG;_USRDLL;%(PreprocessorDefinitions) + + + Win32 + NDEBUG;%(PreprocessorDefinitions) + + + NDEBUG;%(PreprocessorDefinitions) + + + true + true + + + + + + MaxSpeed + WIN32;_WINDOWS;NDEBUG;_USRDLL;%(PreprocessorDefinitions) + + + Win32 + NDEBUG;%(PreprocessorDefinitions) + + + NDEBUG;%(PreprocessorDefinitions) + + + true + true + + + + + + MaxSpeed + WIN32;_WINDOWS;NDEBUG;_USRDLL;%(PreprocessorDefinitions) + + + Win32 + NDEBUG;%(PreprocessorDefinitions) + + + NDEBUG;%(PreprocessorDefinitions) + + + true + true + + + + + + MaxSpeed + WIN32;_WINDOWS;NDEBUG;_USRDLL;%(PreprocessorDefinitions) + + + Win32 + NDEBUG;%(PreprocessorDefinitions) + + + NDEBUG;%(PreprocessorDefinitions) + + + true + true + + + + + + MaxSpeed + WIN32;_WINDOWS;NDEBUG;_USRDLL;%(PreprocessorDefinitions) + + + Win32 + NDEBUG;%(PreprocessorDefinitions) + + + NDEBUG;%(PreprocessorDefinitions) + + + true + true + + + + + + MaxSpeed + _WINDOWS;NDEBUG;_USRDLL;%(PreprocessorDefinitions) + + + NDEBUG;%(PreprocessorDefinitions) + + + NDEBUG;%(PreprocessorDefinitions) + + + true + true + + + + + + MaxSpeed + _WINDOWS;NDEBUG;_USRDLL;%(PreprocessorDefinitions) + + + NDEBUG;%(PreprocessorDefinitions) + + + NDEBUG;%(PreprocessorDefinitions) + + + true + true + + + + + + MaxSpeed + _WINDOWS;NDEBUG;_USRDLL;%(PreprocessorDefinitions) + + + NDEBUG;%(PreprocessorDefinitions) + + + NDEBUG;%(PreprocessorDefinitions) + + + true + true + + + + + + MaxSpeed + _WINDOWS;NDEBUG;_USRDLL;%(PreprocessorDefinitions) + + + NDEBUG;%(PreprocessorDefinitions) + + + NDEBUG;%(PreprocessorDefinitions) + + + true + true + + + + + + MaxSpeed + _WINDOWS;NDEBUG;_USRDLL;%(PreprocessorDefinitions) + + + NDEBUG;%(PreprocessorDefinitions) + + + NDEBUG;%(PreprocessorDefinitions) + + + true + true + + + + + + MaxSpeed + _WINDOWS;NDEBUG;_USRDLL;%(PreprocessorDefinitions) + + + NDEBUG;%(PreprocessorDefinitions) + + + NDEBUG;%(PreprocessorDefinitions) + + + true + true + + + + + + MaxSpeed + _WINDOWS;NDEBUG;_USRDLL;%(PreprocessorDefinitions) + + + NDEBUG;%(PreprocessorDefinitions) + + + NDEBUG;%(PreprocessorDefinitions) + + + true + true + + + + + + MaxSpeed + _WINDOWS;NDEBUG;_USRDLL;%(PreprocessorDefinitions) + + + NDEBUG;%(PreprocessorDefinitions) + + + NDEBUG;%(PreprocessorDefinitions) + + + true + true + + + + + + MaxSpeed + _WINDOWS;NDEBUG;_USRDLL;%(PreprocessorDefinitions) + + + NDEBUG;%(PreprocessorDefinitions) + + + NDEBUG;%(PreprocessorDefinitions) + + + true + true + + + + + + MaxSpeed + _WINDOWS;NDEBUG;_USRDLL;%(PreprocessorDefinitions) + + + NDEBUG;%(PreprocessorDefinitions) + + + NDEBUG;%(PreprocessorDefinitions) + + + true + true + + + + + + + + + + + + + + + false + + + + false + + + + + Create + + + + + + + + + + + diff --git a/src/Files.App.OpenDialog/FilesOpenDialog.cpp b/src/Files.App.OpenDialog/FilesOpenDialog.cpp index 5f6c79993f47..23bb55567fa7 100644 --- a/src/Files.App.OpenDialog/FilesOpenDialog.cpp +++ b/src/Files.App.OpenDialog/FilesOpenDialog.cpp @@ -22,16 +22,13 @@ using std::endl; CComPtr GetSystemDialog() { HINSTANCE lib = CoLoadLibrary(L"C:\\Windows\\System32\\comdlg32.dll", false); - - BOOL(WINAPI *dllGetClassObject)(REFCLSID, REFIID, LPVOID*) = (BOOL(WINAPI*)(REFCLSID, REFIID, LPVOID*))GetProcAddress(lib, "DllGetClassObject"); - + BOOL(WINAPI* dllGetClassObject)(REFCLSID, REFIID, LPVOID*) = + (BOOL(WINAPI*)(REFCLSID, REFIID, LPVOID*))GetProcAddress(lib, "DllGetClassObject"); CComPtr pClassFactory; dllGetClassObject(CLSID_FileOpenDialog, IID_IClassFactory, (void**)&pClassFactory); - CComPtr systemDialog; pClassFactory->CreateInstance(NULL, IID_IFileOpenDialog, (void**)&systemDialog); //CoFreeLibrary(lib); - return systemDialog; } @@ -124,6 +121,8 @@ STDAPICALL CFilesOpenDialog::Show(HWND hwndOwner) ShExecInfo.lpFile = L"files.exe"; PWSTR pszPath = NULL; + HANDLE closeEvent = CreateEvent(NULL, FALSE, FALSE, TEXT("FILEDIALOG")); + if (_initFolder && SUCCEEDED(_initFolder->GetDisplayName(SIGDN_DESKTOPABSOLUTEPARSING, &pszPath))) { TCHAR args[1024]; @@ -132,17 +131,40 @@ STDAPICALL CFilesOpenDialog::Show(HWND hwndOwner) ShExecInfo.lpParameters = args; CoTaskMemFree(pszPath); } - ShExecInfo.nShow = SW_SHOW; ShellExecuteEx(&ShExecInfo); - if (ShExecInfo.hProcess) + + if (hwndOwner) + EnableWindow(hwndOwner, FALSE); + + MSG msg; + while (ShExecInfo.hProcess) { - WaitForSingleObject(ShExecInfo.hProcess, INFINITE); - CloseHandle(ShExecInfo.hProcess); + switch (MsgWaitForMultipleObjectsEx(1, &closeEvent, INFINITE, QS_ALLINPUT, 0)) + { + case WAIT_OBJECT_0: + CloseHandle(ShExecInfo.hProcess); + ShExecInfo.hProcess = NULL; + break; + case WAIT_OBJECT_0 + 1: + while (PeekMessage(&msg, 0, 0, 0, PM_REMOVE)) + { + TranslateMessage(&msg); + DispatchMessage(&msg); + } + continue; + default: __debugbreak(); + } } + if (closeEvent) + CloseHandle(closeEvent); + if (hwndOwner) + { + EnableWindow(hwndOwner, TRUE); SetForegroundWindow(hwndOwner); + } std::ifstream file(_outputPath); if (file.good()) @@ -203,7 +225,7 @@ STDAPICALL CFilesOpenDialog::Advise(IFileDialogEvents* pfde, DWORD* pdwCookie) return _systemDialog->Advise(pfde, pdwCookie); #endif _dialogEvents = pfde; - * pdwCookie = 0; + *pdwCookie = 0; return S_OK; } diff --git a/src/Files.App.OpenDialog/FilesOpenDialog.h b/src/Files.App.OpenDialog/FilesOpenDialog.h index 2934e70ccf56..52843c7e6f2d 100644 --- a/src/Files.App.OpenDialog/FilesOpenDialog.h +++ b/src/Files.App.OpenDialog/FilesOpenDialog.h @@ -6,7 +6,7 @@ #pragma once -//#define DEBUGLOG +#define DEBUGLOG #include #include diff --git a/src/Files.App.SaveDialog/CustomSaveDialog.cpp b/src/Files.App.SaveDialog/CustomSaveDialog.cpp new file mode 100644 index 000000000000..2f9ccaf5f861 --- /dev/null +++ b/src/Files.App.SaveDialog/CustomSaveDialog.cpp @@ -0,0 +1,74 @@ +// CustomSaveDialog.cpp: implementazione delle esportazioni DLL. + + +#include "pch.h" +#include "framework.h" +#include "resource.h" +#include "CustomSaveDialog_i.h" +#include "dllmain.h" + + +using namespace ATL; + +// Utilizzato per determinare se la DLL può essere scaricata da OLE. +_Use_decl_annotations_ +STDAPI DllCanUnloadNow(void) +{ + return _AtlModule.DllCanUnloadNow(); +} + +// Restituisce una class factory per creare un oggetto del tipo richiesto. +_Use_decl_annotations_ +STDAPI DllGetClassObject(_In_ REFCLSID rclsid, _In_ REFIID riid, _Outptr_ LPVOID* ppv) +{ + return _AtlModule.DllGetClassObject(rclsid, riid, ppv); +} + +// DllRegisterServer: aggiunge voci al Registro di sistema. +_Use_decl_annotations_ +STDAPI DllRegisterServer(void) +{ + // registra gli oggetti, le librerie dei tipi e tutte le interfacce della libreria dei tipi + HRESULT hr = _AtlModule.DllRegisterServer(); + return hr; +} + +// DllUnregisterServer: rimuove voci dal Registro di sistema. +_Use_decl_annotations_ +STDAPI DllUnregisterServer(void) +{ + HRESULT hr = _AtlModule.DllUnregisterServer(); + return hr; +} + +// DllInstall: aggiunge/rimuove voci nel Registro di sistema per ogni utente di ciascun computer. +STDAPI DllInstall(BOOL bInstall, _In_opt_ LPCWSTR pszCmdLine) +{ + HRESULT hr = E_FAIL; + static const wchar_t szUserSwitch[] = L"user"; + + if (pszCmdLine != nullptr) + { + if (_wcsnicmp(pszCmdLine, szUserSwitch, _countof(szUserSwitch)) == 0) + { + ATL::AtlSetPerUserRegistration(true); + } + } + + if (bInstall) + { + hr = DllRegisterServer(); + if (FAILED(hr)) + { + DllUnregisterServer(); + } + } + else + { + hr = DllUnregisterServer(); + } + + return hr; +} + + diff --git a/src/Files.App.SaveDialog/CustomSaveDialog.def b/src/Files.App.SaveDialog/CustomSaveDialog.def new file mode 100644 index 000000000000..127dec0267e2 --- /dev/null +++ b/src/Files.App.SaveDialog/CustomSaveDialog.def @@ -0,0 +1,10 @@ +; CustomSaveDialog.def: dichiara i parametri del modulo. + +LIBRARY + +EXPORTS + DllCanUnloadNow PRIVATE + DllGetClassObject PRIVATE + DllRegisterServer PRIVATE + DllUnregisterServer PRIVATE + DllInstall PRIVATE diff --git a/src/Files.App.SaveDialog/CustomSaveDialog.idl b/src/Files.App.SaveDialog/CustomSaveDialog.idl new file mode 100644 index 000000000000..d2b45059fdfa --- /dev/null +++ b/src/Files.App.SaveDialog/CustomSaveDialog.idl @@ -0,0 +1,32 @@ +// CustomSaveDialog.idl: origine IDL per CustomSaveDialog +// + +// Questo file verrà elaborato dallo strumento MIDL per +// produce la libreria dei tipi (CustomSaveDialog.tlb) e il codice di marshalling. + +import "oaidl.idl"; +import "ocidl.idl"; + +[ + uuid(21533617-c1cd-4d33-a190-21fb069b55f4), + version(1.0), +] +library CustomSaveDialogLib +{ + importlib("stdole2.tlb"); + [ + uuid(C0B4E2F3-BA21-4773-8DBA-335EC946EB8B) + ] + coclass FilesSaveDialog + { + [default] interface IFileSaveDialog; + interface IFileDialog; + interface IFileDialogCustomize; + interface IFileDialog2; + interface IObjectWithSite; + //interface IFileDialogPrivate; + interface IOleWindow; + }; +}; + +import "shobjidl.idl"; diff --git a/src/Files.App.SaveDialog/CustomSaveDialog.rc b/src/Files.App.SaveDialog/CustomSaveDialog.rc new file mode 100644 index 0000000000000000000000000000000000000000..deda272e17a113d5dbb95b9d7a84772332b4526e GIT binary patch literal 6120 zcmdUz+ioI95QghIQr=;LZ+4Z)HoJQjMUia7A`)yYb5K^YWI5&#OT<_(-ejXZY@Q^^ z_jgl+sj1=byii?8p*3w|l#@iH&W_J+PFyE^||RvRfPR@65jD zN^EF-d*GfhpECBCn=oqK6Hj+MC;St)dwYcD(7v=U*ySjU2h2Y3b_8`V(3V!#AKEWg z3e;M85a@c=80?N{_qv5xG}M(dyWt)ulBddePE=HGBHdt}uI19p)82T-qCR6M&_??*UR z3jLOXfk{9_Y9HY>!PoA&gP=nXuMG;<{}y~2WnEmkijc^C04Mn~V=csv&p2HJdeM9X?-q2Y>=xH7 zQ%Hlk7TZMDeqz`0yEqo*9LJ~Ipp3POvXf{|v2_j0UIdFJQ0vOC1J`yus|8i)V=fX8 zWw~AUQ2p5^_g#~5u0eCGM{`;8>R2h@KQAMe;8Da!xjyE}Vw%;AShCgZxo(#{4tZI% zm`9N(-tOp$h>{Of^D0qQ2Nl9ViO7B;&!?fJm+2WwPb*>@LqD{1X06yx76J?TuDA_xB;=){yR;%-fynv`c6oib)Q z&DZ4Rb${z)7eA_7l?@c_>S`ZD$M6Z<-SV%`yee)9tOzwt`<8#-@m93zeRbNnL%TlO z{$<}6$dkXLTcyJ4#dAuGko=t&Y5$nTlH|~-L>Asnf^2O1&Sf&(@$4>drC9?>hFEYE ztomr50uqMwd8CU)C(riXB`;;OM;mTBYfSN4M4NCJBS}>vW-aBC zG99Bb@?r*@OFMtkd)=Q?jn^4c{j|P{Tv1 z+=PRBahadb7mb_rZ0d@qv#69@E|b^!)>?@Y4Z1b6yv@ERkDnKRxf# z`Ka^gywWQ}-_jGS7CD7R-4PY)-D*&sgfnb4yvgqXl=ARv3uFrmQbU*B;JsmN{ OF``~e-{?0zwf+m!jO6|R literal 0 HcmV?d00001 diff --git a/src/Files.App.SaveDialog/CustomSaveDialog.rgs b/src/Files.App.SaveDialog/CustomSaveDialog.rgs new file mode 100644 index 000000000000..e7d37400e19a --- /dev/null +++ b/src/Files.App.SaveDialog/CustomSaveDialog.rgs @@ -0,0 +1,3 @@ +HKCR +{ +} diff --git a/src/Files.App.SaveDialog/CustomSaveDialogps.def b/src/Files.App.SaveDialog/CustomSaveDialogps.def new file mode 100644 index 000000000000..2a4265afa9fb --- /dev/null +++ b/src/Files.App.SaveDialog/CustomSaveDialogps.def @@ -0,0 +1,8 @@ + +LIBRARY + +EXPORTS + DllGetClassObject PRIVATE + DllCanUnloadNow PRIVATE + DllRegisterServer PRIVATE + DllUnregisterServer PRIVATE diff --git a/src/Files.App.SaveDialog/Files.App.SaveDialog.Win32.vcxproj b/src/Files.App.SaveDialog/Files.App.SaveDialog.Win32.vcxproj new file mode 100644 index 000000000000..81db2ee5f38c --- /dev/null +++ b/src/Files.App.SaveDialog/Files.App.SaveDialog.Win32.vcxproj @@ -0,0 +1,475 @@ + + + + + Debug + arm64 + + + Debug + Win32 + + + Preview + arm64 + + + Preview + Win32 + + + Preview + x64 + + + Release + arm64 + + + Release + Win32 + + + Debug + x64 + + + Release + x64 + + + Sideload + arm64 + + + Sideload + Win32 + + + Sideload + x64 + + + Stable + arm64 + + + Stable + Win32 + + + Stable + x64 + + + Store + arm64 + + + Store + Win32 + + + Store + x64 + + + + + 16.0 + {7756A1A4-17B5-4E6B-9B12-F19AA868A225} + AtlProj + 10.0 + DynamicLibrary + true + v143 + Unicode + + + + + + + + true + true + ..\..\artifacts\$(Configuration)\$(Platform)\$(MSBuildProjectName)\ + ..\..\artifacts\intermediates\$(Platform)\$(MSBuildProjectName)\ + Files.App.SaveDialog$(PlatformArchitecture) + + + + true + false + false + ..\..\artifacts\$(Configuration)\$(Platform)\$(MSBuildProjectName)\ + ..\..\artifacts\intermediates\$(Platform)\$(MSBuildProjectName)\ + Files.App.SaveDialog$(PlatformArchitecture) + + + + + Use + Level3 + pch.h + true + + + false + CustomSaveDialog_i.h + CustomSaveDialog_i.c + CustomSaveDialog_p.c + true + $(IntDir)CustomSaveDialog.tlb + true + + + 0x0410 + $(IntDir);%(AdditionalIncludeDirectories) + + + Windows + .\CustomSaveDialog.def + false + true + $(OutDir)Files.App.SaveDialog$(PlatformArchitecture)$(TargetExt) + + + xcopy /s /y "$(ProjectDir)$(OutDir)*.dll" "$(ProjectDir)..\..\src\Files.App\Assets\FilesOpenDialog" + + + + + + Disabled + WIN32;_WINDOWS;_DEBUG;_USRDLL;%(PreprocessorDefinitions) + + + Win32 + _DEBUG;%(PreprocessorDefinitions) + + + _DEBUG;%(PreprocessorDefinitions) + + + + + + Disabled + _WINDOWS;_DEBUG;_USRDLL;%(PreprocessorDefinitions) + + + _DEBUG;%(PreprocessorDefinitions) + + + _DEBUG;%(PreprocessorDefinitions) + + + + + + Disabled + _WINDOWS;_DEBUG;_USRDLL;%(PreprocessorDefinitions) + + + _DEBUG;%(PreprocessorDefinitions) + + + _DEBUG;%(PreprocessorDefinitions) + + + + + + MaxSpeed + WIN32;_WINDOWS;NDEBUG;_USRDLL;%(PreprocessorDefinitions) + + + Win32 + NDEBUG;%(PreprocessorDefinitions) + + + NDEBUG;%(PreprocessorDefinitions) + + + true + true + + + + + + MaxSpeed + WIN32;_WINDOWS;NDEBUG;_USRDLL;%(PreprocessorDefinitions) + + + Win32 + NDEBUG;%(PreprocessorDefinitions) + + + NDEBUG;%(PreprocessorDefinitions) + + + true + true + + + + + + MaxSpeed + WIN32;_WINDOWS;NDEBUG;_USRDLL;%(PreprocessorDefinitions) + + + Win32 + NDEBUG;%(PreprocessorDefinitions) + + + NDEBUG;%(PreprocessorDefinitions) + + + true + true + + + + + + MaxSpeed + WIN32;_WINDOWS;NDEBUG;_USRDLL;%(PreprocessorDefinitions) + + + Win32 + NDEBUG;%(PreprocessorDefinitions) + + + NDEBUG;%(PreprocessorDefinitions) + + + true + true + + + + + + MaxSpeed + WIN32;_WINDOWS;NDEBUG;_USRDLL;%(PreprocessorDefinitions) + + + Win32 + NDEBUG;%(PreprocessorDefinitions) + + + NDEBUG;%(PreprocessorDefinitions) + + + true + true + + + + + + MaxSpeed + _WINDOWS;NDEBUG;_USRDLL;%(PreprocessorDefinitions) + + + NDEBUG;%(PreprocessorDefinitions) + + + NDEBUG;%(PreprocessorDefinitions) + + + true + true + + + + + + MaxSpeed + _WINDOWS;NDEBUG;_USRDLL;%(PreprocessorDefinitions) + + + NDEBUG;%(PreprocessorDefinitions) + + + NDEBUG;%(PreprocessorDefinitions) + + + true + true + + + + + + MaxSpeed + _WINDOWS;NDEBUG;_USRDLL;%(PreprocessorDefinitions) + + + NDEBUG;%(PreprocessorDefinitions) + + + NDEBUG;%(PreprocessorDefinitions) + + + true + true + + + + + + MaxSpeed + _WINDOWS;NDEBUG;_USRDLL;%(PreprocessorDefinitions) + + + NDEBUG;%(PreprocessorDefinitions) + + + NDEBUG;%(PreprocessorDefinitions) + + + true + true + + + + + + MaxSpeed + _WINDOWS;NDEBUG;_USRDLL;%(PreprocessorDefinitions) + + + NDEBUG;%(PreprocessorDefinitions) + + + NDEBUG;%(PreprocessorDefinitions) + + + true + true + + + + + + MaxSpeed + _WINDOWS;NDEBUG;_USRDLL;%(PreprocessorDefinitions) + + + NDEBUG;%(PreprocessorDefinitions) + + + NDEBUG;%(PreprocessorDefinitions) + + + true + true + + + + + + MaxSpeed + _WINDOWS;NDEBUG;_USRDLL;%(PreprocessorDefinitions) + + + NDEBUG;%(PreprocessorDefinitions) + + + NDEBUG;%(PreprocessorDefinitions) + + + true + true + + + + + + MaxSpeed + _WINDOWS;NDEBUG;_USRDLL;%(PreprocessorDefinitions) + + + NDEBUG;%(PreprocessorDefinitions) + + + NDEBUG;%(PreprocessorDefinitions) + + + true + true + + + + + + MaxSpeed + _WINDOWS;NDEBUG;_USRDLL;%(PreprocessorDefinitions) + + + NDEBUG;%(PreprocessorDefinitions) + + + NDEBUG;%(PreprocessorDefinitions) + + + true + true + + + + + + MaxSpeed + _WINDOWS;NDEBUG;_USRDLL;%(PreprocessorDefinitions) + + + NDEBUG;%(PreprocessorDefinitions) + + + NDEBUG;%(PreprocessorDefinitions) + + + true + true + + + + + + + + + + + + + + + + false + + + + false + + + + + + Create + + + + + + + + + + + \ No newline at end of file diff --git a/src/Files.App.SaveDialog/Files.App.SaveDialog.vcxproj b/src/Files.App.SaveDialog/Files.App.SaveDialog.vcxproj new file mode 100644 index 000000000000..9e0232aa2b88 --- /dev/null +++ b/src/Files.App.SaveDialog/Files.App.SaveDialog.vcxproj @@ -0,0 +1,475 @@ + + + + + Debug + arm64 + + + Debug + Win32 + + + Preview + arm64 + + + Preview + Win32 + + + Preview + x64 + + + Release + arm64 + + + Release + Win32 + + + Debug + x64 + + + Release + x64 + + + Sideload + arm64 + + + Sideload + Win32 + + + Sideload + x64 + + + Stable + arm64 + + + Stable + Win32 + + + Stable + x64 + + + Store + arm64 + + + Store + Win32 + + + Store + x64 + + + + + 16.0 + {EBFA367F-CBDB-4CD0-B838-D6B95F61D1F6} + AtlProj + 10.0 + DynamicLibrary + true + v143 + Unicode + + + + + + + + true + true + ..\..\artifacts\$(Configuration)\$(Platform)\$(MSBuildProjectName)\ + ..\..\artifacts\intermediates\$(Platform)\$(MSBuildProjectName)\ + Files.App.SaveDialog$(PlatformArchitecture) + + + + true + false + false + ..\..\artifacts\$(Configuration)\$(Platform)\$(MSBuildProjectName)\ + ..\..\artifacts\intermediates\$(Platform)\$(MSBuildProjectName)\ + Files.App.SaveDialog$(PlatformArchitecture) + + + + + Use + Level3 + pch.h + true + + + false + CustomSaveDialog_i.h + CustomSaveDialog_i.c + CustomSaveDialog_p.c + true + $(IntDir)CustomSaveDialog.tlb + true + + + 0x0410 + $(IntDir);%(AdditionalIncludeDirectories) + + + Windows + .\CustomSaveDialog.def + false + true + $(OutDir)Files.App.SaveDialog$(PlatformArchitecture)$(TargetExt) + + + xcopy /s /y "$(ProjectDir)$(OutDir)*.dll" "$(ProjectDir)..\..\src\Files.App\Assets\FilesOpenDialog" + + + + + + Disabled + WIN32;_WINDOWS;_DEBUG;_USRDLL;%(PreprocessorDefinitions) + + + Win32 + _DEBUG;%(PreprocessorDefinitions) + + + _DEBUG;%(PreprocessorDefinitions) + + + + + + Disabled + _WINDOWS;_DEBUG;_USRDLL;%(PreprocessorDefinitions) + + + _DEBUG;%(PreprocessorDefinitions) + + + _DEBUG;%(PreprocessorDefinitions) + + + + + + Disabled + _WINDOWS;_DEBUG;_USRDLL;%(PreprocessorDefinitions) + + + _DEBUG;%(PreprocessorDefinitions) + + + _DEBUG;%(PreprocessorDefinitions) + + + + + + MaxSpeed + WIN32;_WINDOWS;NDEBUG;_USRDLL;%(PreprocessorDefinitions) + + + Win32 + NDEBUG;%(PreprocessorDefinitions) + + + NDEBUG;%(PreprocessorDefinitions) + + + true + true + + + + + + MaxSpeed + WIN32;_WINDOWS;NDEBUG;_USRDLL;%(PreprocessorDefinitions) + + + Win32 + NDEBUG;%(PreprocessorDefinitions) + + + NDEBUG;%(PreprocessorDefinitions) + + + true + true + + + + + + MaxSpeed + WIN32;_WINDOWS;NDEBUG;_USRDLL;%(PreprocessorDefinitions) + + + Win32 + NDEBUG;%(PreprocessorDefinitions) + + + NDEBUG;%(PreprocessorDefinitions) + + + true + true + + + + + + MaxSpeed + WIN32;_WINDOWS;NDEBUG;_USRDLL;%(PreprocessorDefinitions) + + + Win32 + NDEBUG;%(PreprocessorDefinitions) + + + NDEBUG;%(PreprocessorDefinitions) + + + true + true + + + + + + MaxSpeed + WIN32;_WINDOWS;NDEBUG;_USRDLL;%(PreprocessorDefinitions) + + + Win32 + NDEBUG;%(PreprocessorDefinitions) + + + NDEBUG;%(PreprocessorDefinitions) + + + true + true + + + + + + MaxSpeed + _WINDOWS;NDEBUG;_USRDLL;%(PreprocessorDefinitions) + + + NDEBUG;%(PreprocessorDefinitions) + + + NDEBUG;%(PreprocessorDefinitions) + + + true + true + + + + + + MaxSpeed + _WINDOWS;NDEBUG;_USRDLL;%(PreprocessorDefinitions) + + + NDEBUG;%(PreprocessorDefinitions) + + + NDEBUG;%(PreprocessorDefinitions) + + + true + true + + + + + + MaxSpeed + _WINDOWS;NDEBUG;_USRDLL;%(PreprocessorDefinitions) + + + NDEBUG;%(PreprocessorDefinitions) + + + NDEBUG;%(PreprocessorDefinitions) + + + true + true + + + + + + MaxSpeed + _WINDOWS;NDEBUG;_USRDLL;%(PreprocessorDefinitions) + + + NDEBUG;%(PreprocessorDefinitions) + + + NDEBUG;%(PreprocessorDefinitions) + + + true + true + + + + + + MaxSpeed + _WINDOWS;NDEBUG;_USRDLL;%(PreprocessorDefinitions) + + + NDEBUG;%(PreprocessorDefinitions) + + + NDEBUG;%(PreprocessorDefinitions) + + + true + true + + + + + + MaxSpeed + _WINDOWS;NDEBUG;_USRDLL;%(PreprocessorDefinitions) + + + NDEBUG;%(PreprocessorDefinitions) + + + NDEBUG;%(PreprocessorDefinitions) + + + true + true + + + + + + MaxSpeed + _WINDOWS;NDEBUG;_USRDLL;%(PreprocessorDefinitions) + + + NDEBUG;%(PreprocessorDefinitions) + + + NDEBUG;%(PreprocessorDefinitions) + + + true + true + + + + + + MaxSpeed + _WINDOWS;NDEBUG;_USRDLL;%(PreprocessorDefinitions) + + + NDEBUG;%(PreprocessorDefinitions) + + + NDEBUG;%(PreprocessorDefinitions) + + + true + true + + + + + + MaxSpeed + _WINDOWS;NDEBUG;_USRDLL;%(PreprocessorDefinitions) + + + NDEBUG;%(PreprocessorDefinitions) + + + NDEBUG;%(PreprocessorDefinitions) + + + true + true + + + + + + MaxSpeed + _WINDOWS;NDEBUG;_USRDLL;%(PreprocessorDefinitions) + + + NDEBUG;%(PreprocessorDefinitions) + + + NDEBUG;%(PreprocessorDefinitions) + + + true + true + + + + + + + + + + + + + + + + false + + + + false + + + + + + Create + + + + + + + + + + + \ No newline at end of file diff --git a/src/Files.App.SaveDialog/Files.App.SaveDialog.vcxproj.filters b/src/Files.App.SaveDialog/Files.App.SaveDialog.vcxproj.filters new file mode 100644 index 000000000000..a3c5c5a147aa --- /dev/null +++ b/src/Files.App.SaveDialog/Files.App.SaveDialog.vcxproj.filters @@ -0,0 +1,91 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;c++;cppm;ixx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hh;hpp;hxx;h++;hm;inl;inc;ipp;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + {487d0712-ae0c-468f-9ef2-12da6ffc5361} + False + + + + + File di intestazione + + + File di intestazione + + + File di intestazione + + + File di intestazione + + + File di intestazione + + + File di intestazione + + + File di intestazione + + + File generati + + + File di intestazione + + + + + File di origine + + + File di origine + + + File di origine + + + File di origine + + + File generati + + + File di origine + + + + + File di risorse + + + + + File di risorse + + + File di origine + + + File di risorse + + + + + File di origine + + + \ No newline at end of file diff --git a/src/Files.App.SaveDialog/FilesDialogEvents.cpp b/src/Files.App.SaveDialog/FilesDialogEvents.cpp new file mode 100644 index 000000000000..527c45efe244 --- /dev/null +++ b/src/Files.App.SaveDialog/FilesDialogEvents.cpp @@ -0,0 +1,84 @@ +#include "pch.h" +#include "FilesDialogEvents.h" +#include + +using std::cout; +using std::wcout; +using std::endl; + +FilesDialogEvents::FilesDialogEvents(IFileDialogEvents* evt, IFileDialog* cust) +{ + _evt = evt; + _cust = cust; +} + +HRESULT __stdcall FilesDialogEvents::QueryInterface(REFIID riid, void** ppvObject) +{ + HRESULT res = _evt->QueryInterface(riid, ppvObject); + OLECHAR* guidString; + (void)StringFromCLSID(riid, &guidString); + std::wcout << L"Event: QueryInterface: " << guidString << L" = " << res << std::endl; + ::CoTaskMemFree(guidString); + return res; +} + +ULONG __stdcall FilesDialogEvents::AddRef(void) +{ + cout << "Event: AddRef" << endl; + return _evt->AddRef(); +} + +ULONG __stdcall FilesDialogEvents::Release(void) +{ + cout << "Event: Release" << endl; + return _evt->Release(); +} + +HRESULT __stdcall FilesDialogEvents::OnFileOk(IFileDialog* pfd) +{ + cout << "Event: PRE OnFileOk" << endl; + HRESULT res = _evt->OnFileOk(_cust); + cout << "Event: OnFileOk = " << res << endl; + return res; +} + +HRESULT __stdcall FilesDialogEvents::OnFolderChanging(IFileDialog* pfd, IShellItem* psiFolder) +{ + HRESULT res = _evt->OnFolderChanging(_cust, psiFolder); + cout << "Event: OnFolderChanging = " << res << endl; + return res; +} + +HRESULT __stdcall FilesDialogEvents::OnFolderChange(IFileDialog* pfd) +{ + HRESULT res = _evt->OnFolderChange(_cust); + cout << "Event: OnFolderChange = " << res << endl; + return res; +} + +HRESULT __stdcall FilesDialogEvents::OnSelectionChange(IFileDialog* pfd) +{ + HRESULT res = _evt->OnSelectionChange(_cust); + cout << "Event: OnSelectionChange = " << res << endl; + return res; +} + +HRESULT __stdcall FilesDialogEvents::OnShareViolation(IFileDialog* pfd, IShellItem* psi, FDE_SHAREVIOLATION_RESPONSE* pResponse) +{ + cout << "Event: OnShareViolation" << endl; + return E_NOTIMPL; +} + +HRESULT __stdcall FilesDialogEvents::OnTypeChange(IFileDialog* pfd) +{ + HRESULT res = _evt->OnTypeChange(_cust); + cout << "Event: OnTypeChange = " << res << endl; + return res; +} + +HRESULT __stdcall FilesDialogEvents::OnOverwrite(IFileDialog* pfd, IShellItem* psi, FDE_OVERWRITE_RESPONSE* pResponse) +{ + HRESULT res = _evt->OnOverwrite(_cust, psi, pResponse); + cout << "Event: OnOverwrite = " << res << ", " << *pResponse << endl; + return res; +} diff --git a/src/Files.App.SaveDialog/FilesDialogEvents.h b/src/Files.App.SaveDialog/FilesDialogEvents.h new file mode 100644 index 000000000000..26a4a72208ef --- /dev/null +++ b/src/Files.App.SaveDialog/FilesDialogEvents.h @@ -0,0 +1,27 @@ +#pragma once +#include "resource.h" // simboli principali + +#include "oaidl.h" +#include "ocidl.h" +#include "shobjidl.h" + +class FilesDialogEvents : public IFileDialogEvents +{ + IFileDialogEvents* _evt; + IFileDialog* _cust; + +public: + FilesDialogEvents(IFileDialogEvents* evt, IFileDialog *cust); + + // Ereditato tramite IFileDialogEvents + HRESULT __stdcall QueryInterface(REFIID riid, void** ppvObject) override; + ULONG __stdcall AddRef(void) override; + ULONG __stdcall Release(void) override; + HRESULT __stdcall OnFileOk(IFileDialog* pfd) override; + HRESULT __stdcall OnFolderChanging(IFileDialog* pfd, IShellItem* psiFolder) override; + HRESULT __stdcall OnFolderChange(IFileDialog* pfd) override; + HRESULT __stdcall OnSelectionChange(IFileDialog* pfd) override; + HRESULT __stdcall OnShareViolation(IFileDialog* pfd, IShellItem* psi, FDE_SHAREVIOLATION_RESPONSE* pResponse) override; + HRESULT __stdcall OnTypeChange(IFileDialog* pfd) override; + HRESULT __stdcall OnOverwrite(IFileDialog* pfd, IShellItem* psi, FDE_OVERWRITE_RESPONSE* pResponse) override; +}; diff --git a/src/Files.App.SaveDialog/FilesSaveDialog.cpp b/src/Files.App.SaveDialog/FilesSaveDialog.cpp new file mode 100644 index 000000000000..f06b5401b5a3 --- /dev/null +++ b/src/Files.App.SaveDialog/FilesSaveDialog.cpp @@ -0,0 +1,1106 @@ +// FilesSaveDialog.cpp: implementazione di CFilesSaveDialog + +#include "pch.h" +#include "FilesDialogEvents.h" +#include "FilesSaveDialog.h" +#include +#include +#include +#include +#include +#include + +//#define SYSTEMDIALOG + +using std::cout; +using std::wcout; +using std::endl; + +// CFilesSaveDialog + +CComPtr GetSystemDialog() +{ + HINSTANCE lib = CoLoadLibrary(L"C:\\Windows\\System32\\comdlg32.dll", false); + BOOL(WINAPI* dllGetClassObject)(REFCLSID, REFIID, LPVOID*) = + (BOOL(WINAPI*)(REFCLSID, REFIID, LPVOID*))GetProcAddress(lib, "DllGetClassObject"); + CComPtr pClassFactory; + dllGetClassObject(CLSID_FileSaveDialog, IID_IClassFactory, (void**)&pClassFactory); + CComPtr systemDialog; + pClassFactory->CreateInstance(NULL, IID_IFileSaveDialog, (void**)&systemDialog); + //CoFreeLibrary(lib); + return systemDialog; +} + +IShellItem* CloneShellItem(IShellItem* psi) +{ + IShellItem* item = NULL; + if (psi) + { + PIDLIST_ABSOLUTE pidl; + if (SUCCEEDED(SHGetIDListFromObject(psi, &pidl))) + { + SHCreateItemFromIDList(pidl, IID_IShellItem, (void**)&item); + CoTaskMemFree(pidl); + } + } + return item; +} + +template +CComPtr AsInterface(CComPtr dialog) +{ + CComPtr dialogInterface; + dialog->QueryInterface(&dialogInterface); + return dialogInterface; +} + +CFilesSaveDialog::CFilesSaveDialog() +{ + _fos = FOS_PATHMUSTEXIST; + _systemDialog = nullptr; + _debugStream = NULL; + _dialogEvents = NULL; + + PWSTR pszPath = NULL; + HRESULT hr = SHGetKnownFolderPath(FOLDERID_Desktop, 0, NULL, &pszPath); + if (SUCCEEDED(hr)) + { + TCHAR debugPath[MAX_PATH]; + wsprintf(debugPath, L"%s\\%s", pszPath, L"save_dialog.txt"); +#ifdef DEBUGLOG + _wfreopen_s(&_debugStream, debugPath, L"w", stdout); +#endif + CoTaskMemFree(pszPath); + } + cout << "Create" << endl; + + TCHAR tempPath[MAX_PATH]; + GetTempPath(MAX_PATH, tempPath); + TCHAR tempName[MAX_PATH]; + GetTempFileName(tempPath, L"fsd", 0, tempName); + _outputPath = tempName; + + (void)SHGetKnownFolderItem(FOLDERID_Documents, KF_FLAG_DEFAULT_PATH, NULL, IID_IShellItem, (void**)&_initFolder); + hr = _initFolder->GetDisplayName(SIGDN_NORMALDISPLAY, &pszPath); + if (SUCCEEDED(hr)) + { + wcout << L"_outputPath: " << _outputPath << L", _initFolder: " << pszPath << endl; + } + +#ifdef SYSTEMDIALOG + _systemDialog = GetSystemDialog(); +#endif +} + +void CFilesSaveDialog::FinalRelease() +{ + if (_systemDialog) + { + _systemDialog.Release(); + } + if (_initFolder) + { + _initFolder->Release(); + } + if (_debugStream) + { + fclose(_debugStream); + } +} + +HRESULT __stdcall CFilesSaveDialog::SetSite(IUnknown* pUnkSite) +{ + cout << "SetSite" << endl; +#ifdef SYSTEMDIALOG + return AsInterface(_systemDialog)->SetSite(pUnkSite); +#endif + return S_OK; +} + +HRESULT __stdcall CFilesSaveDialog::GetSite(REFIID riid, void** ppvSite) +{ + cout << "GetSite" << endl; +#ifdef SYSTEMDIALOG + return AsInterface(_systemDialog)->GetSite(riid, ppvSite); +#endif + return E_NOTIMPL; +} + +HRESULT __stdcall CFilesSaveDialog::EnableOpenDropDown(DWORD dwIDCtl) +{ + cout << "EnableOpenDropDown" << endl; +#ifdef SYSTEMDIALOG + return AsInterface(_systemDialog)->EnableOpenDropDown(dwIDCtl); +#endif + return S_OK; +} + +HRESULT __stdcall CFilesSaveDialog::AddMenu(DWORD dwIDCtl, LPCWSTR pszLabel) +{ + cout << "AddMenu" << endl; +#ifdef SYSTEMDIALOG + return AsInterface(_systemDialog)->AddMenu(dwIDCtl, pszLabel); +#endif + return S_OK; +} + +HRESULT __stdcall CFilesSaveDialog::AddPushButton(DWORD dwIDCtl, LPCWSTR pszLabel) +{ + cout << "AddPushButton" << endl; +#ifdef SYSTEMDIALOG + return AsInterface(_systemDialog)->AddPushButton(dwIDCtl, pszLabel); +#endif + return S_OK; +} + +HRESULT __stdcall CFilesSaveDialog::AddComboBox(DWORD dwIDCtl) +{ + cout << "AddComboBox" << endl; +#ifdef SYSTEMDIALOG + return AsInterface(_systemDialog)->AddComboBox(dwIDCtl); +#endif + return S_OK; +} + +HRESULT __stdcall CFilesSaveDialog::AddRadioButtonList(DWORD dwIDCtl) +{ + cout << "AddRadioButtonList" << endl; +#ifdef SYSTEMDIALOG + return AsInterface(_systemDialog)->AddRadioButtonList(dwIDCtl); +#endif + return S_OK; +} + +HRESULT __stdcall CFilesSaveDialog::AddCheckButton(DWORD dwIDCtl, LPCWSTR pszLabel, BOOL bChecked) +{ + cout << "AddCheckButton" << endl; +#ifdef SYSTEMDIALOG + return AsInterface(_systemDialog)->AddCheckButton(dwIDCtl, pszLabel, bChecked); +#endif + return S_OK; +} + +HRESULT __stdcall CFilesSaveDialog::AddEditBox(DWORD dwIDCtl, LPCWSTR pszText) +{ + cout << "AddEditBox" << endl; +#ifdef SYSTEMDIALOG + return AsInterface(_systemDialog)->AddEditBox(dwIDCtl, pszText); +#endif + return S_OK; +} + +HRESULT __stdcall CFilesSaveDialog::AddSeparator(DWORD dwIDCtl) +{ + cout << "AddSeparator" << endl; +#ifdef SYSTEMDIALOG + return AsInterface(_systemDialog)->AddSeparator(dwIDCtl); +#endif + return S_OK; +} + +HRESULT __stdcall CFilesSaveDialog::AddText(DWORD dwIDCtl, LPCWSTR pszText) +{ + cout << "AddText" << endl; +#ifdef SYSTEMDIALOG + return AsInterface(_systemDialog)->AddText(dwIDCtl, pszText); +#endif + return S_OK; +} + +HRESULT __stdcall CFilesSaveDialog::SetControlLabel(DWORD dwIDCtl, LPCWSTR pszLabel) +{ + cout << "SetControlLabel" << endl; +#ifdef SYSTEMDIALOG + return AsInterface(_systemDialog)->SetControlLabel(dwIDCtl, pszLabel); +#endif + return S_OK; +} + +HRESULT __stdcall CFilesSaveDialog::GetControlState(DWORD dwIDCtl, CDCONTROLSTATEF* pdwState) +{ + cout << "GetControlState" << endl; +#ifdef SYSTEMDIALOG + return AsInterface(_systemDialog)->GetControlState(dwIDCtl, pdwState); +#endif + * pdwState = CDCS_ENABLEDVISIBLE; + return S_OK; +} + +HRESULT __stdcall CFilesSaveDialog::SetControlState(DWORD dwIDCtl, CDCONTROLSTATEF dwState) +{ + cout << "SetControlState" << endl; +#ifdef SYSTEMDIALOG + return AsInterface(_systemDialog)->SetControlState(dwIDCtl, dwState); +#endif + return S_OK; +} + +HRESULT __stdcall CFilesSaveDialog::GetEditBoxText(DWORD dwIDCtl, WCHAR** ppszText) +{ + cout << "GetEditBoxText" << endl; +#ifdef SYSTEMDIALOG + return AsInterface(_systemDialog)->GetEditBoxText(dwIDCtl, ppszText); +#endif + SHStrDupW(L"", ppszText); + return S_OK; +} + +HRESULT __stdcall CFilesSaveDialog::SetEditBoxText(DWORD dwIDCtl, LPCWSTR pszText) +{ + cout << "SetEditBoxText" << endl; +#ifdef SYSTEMDIALOG + return AsInterface(_systemDialog)->SetEditBoxText(dwIDCtl, pszText); +#endif + return S_OK; +} + +HRESULT __stdcall CFilesSaveDialog::GetCheckButtonState(DWORD dwIDCtl, BOOL* pbChecked) +{ + cout << "GetCheckButtonState" << endl; +#ifdef SYSTEMDIALOG + return AsInterface(_systemDialog)->GetCheckButtonState(dwIDCtl, pbChecked); +#endif + * pbChecked = false; + return S_OK; +} + +HRESULT __stdcall CFilesSaveDialog::SetCheckButtonState(DWORD dwIDCtl, BOOL bChecked) +{ + cout << "SetCheckButtonState" << endl; +#ifdef SYSTEMDIALOG + return AsInterface(_systemDialog)->SetCheckButtonState(dwIDCtl, bChecked); +#endif + return S_OK; +} + +HRESULT __stdcall CFilesSaveDialog::AddControlItem(DWORD dwIDCtl, DWORD dwIDItem, LPCWSTR pszLabel) +{ + cout << "AddControlItem" << endl; +#ifdef SYSTEMDIALOG + return AsInterface(_systemDialog)->AddControlItem(dwIDCtl, dwIDItem, pszLabel); +#endif + _ctrlItems.push_back(dwIDItem); + return S_OK; +} + +HRESULT __stdcall CFilesSaveDialog::RemoveControlItem(DWORD dwIDCtl, DWORD dwIDItem) +{ + cout << "RemoveControlItem" << endl; +#ifdef SYSTEMDIALOG + return AsInterface(_systemDialog)->RemoveControlItem(dwIDCtl, dwIDItem); +#endif + return S_OK; +} + +HRESULT __stdcall CFilesSaveDialog::RemoveAllControlItems(DWORD dwIDCtl) +{ + cout << "RemoveAllControlItems" << endl; +#ifdef SYSTEMDIALOG + return AsInterface(_systemDialog)->RemoveAllControlItems(dwIDCtl); +#endif + return S_OK; +} + +HRESULT __stdcall CFilesSaveDialog::GetControlItemState(DWORD dwIDCtl, DWORD dwIDItem, CDCONTROLSTATEF* pdwState) +{ + cout << "GetControlItemState" << endl; +#ifdef SYSTEMDIALOG + return AsInterface(_systemDialog)->GetControlItemState(dwIDCtl, dwIDItem, pdwState); +#endif + * pdwState = CDCS_ENABLEDVISIBLE; + return S_OK; +} + +HRESULT __stdcall CFilesSaveDialog::SetControlItemState(DWORD dwIDCtl, DWORD dwIDItem, CDCONTROLSTATEF dwState) +{ + cout << "SetControlItemState" << endl; +#ifdef SYSTEMDIALOG + return AsInterface(_systemDialog)->SetControlItemState(dwIDCtl, dwIDItem, dwState); +#endif + return S_OK; +} + +HRESULT __stdcall CFilesSaveDialog::GetSelectedControlItem(DWORD dwIDCtl, DWORD* pdwIDItem) +{ + cout << "GetSelectedControlItem" << endl; +#ifdef SYSTEMDIALOG + return AsInterface(_systemDialog)->GetSelectedControlItem(dwIDCtl, pdwIDItem); +#endif + if (!_ctrlItems.empty()) { + *pdwIDItem = _ctrlItems.back(); + return S_OK; + } + return E_NOTIMPL; +} + +HRESULT __stdcall CFilesSaveDialog::SetSelectedControlItem(DWORD dwIDCtl, DWORD dwIDItem) +{ + cout << "SetSelectedControlItem" << endl; +#ifdef SYSTEMDIALOG + return AsInterface(_systemDialog)->SetSelectedControlItem(dwIDCtl, dwIDItem); +#endif + _ctrlItems.push_back(dwIDItem); + return S_OK; +} + +HRESULT __stdcall CFilesSaveDialog::StartVisualGroup(DWORD dwIDCtl, LPCWSTR pszLabel) +{ + cout << "StartVisualGroup" << endl; +#ifdef SYSTEMDIALOG + return AsInterface(_systemDialog)->StartVisualGroup(dwIDCtl, pszLabel); +#endif + return S_OK; +} + +HRESULT __stdcall CFilesSaveDialog::EndVisualGroup(void) +{ + cout << "EndVisualGroup" << endl; +#ifdef SYSTEMDIALOG + return AsInterface(_systemDialog)->EndVisualGroup(); +#endif + return S_OK; +} + +HRESULT __stdcall CFilesSaveDialog::MakeProminent(DWORD dwIDCtl) +{ + cout << "MakeProminent" << endl; +#ifdef SYSTEMDIALOG + return AsInterface(_systemDialog)->MakeProminent(dwIDCtl); +#endif + return S_OK; +} + +HRESULT __stdcall CFilesSaveDialog::SetControlItemText(DWORD dwIDCtl, DWORD dwIDItem, LPCWSTR pszLabel) +{ + cout << "SetControlItemText" << endl; +#ifdef SYSTEMDIALOG + return AsInterface(_systemDialog)->SetControlItemText(dwIDCtl, dwIDItem, pszLabel); +#endif + return S_OK; +} + +HRESULT __stdcall CFilesSaveDialog::Show(HWND hwndOwner) +{ + wchar_t wnd_title[1024]; + GetWindowText(hwndOwner, wnd_title, 1024); + wcout << L"Show, ID: " << GetCurrentProcessId() << endl; + +#ifdef SYSTEMDIALOG + HRESULT res = _systemDialog->Show(NULL); + cout << "Show, DONE: " << res << endl; + return res; +#endif + + SHELLEXECUTEINFO ShExecInfo = { 0 }; + ShExecInfo.cbSize = sizeof(SHELLEXECUTEINFO); + ShExecInfo.fMask = SEE_MASK_NOCLOSEPROCESS; + ShExecInfo.lpFile = L"files.exe"; + PWSTR pszPath = NULL; + + HANDLE closeEvent = CreateEvent(NULL, FALSE, FALSE, TEXT("FILEDIALOG")); + + if (_initFolder && SUCCEEDED(_initFolder->GetDisplayName(SIGDN_DESKTOPABSOLUTEPARSING, &pszPath))) + { + TCHAR args[1024]; + if (!_initName.empty()) + { + wsprintf(args, L"-directory \"%s\" -outputpath \"%s\" -select \"%s\"", pszPath, _outputPath.c_str(), _initName.c_str()); + } + else + { + wsprintf(args, L"-directory \"%s\" -outputpath \"%s\"", pszPath, _outputPath.c_str()); + } + wcout << L"Invoking: " << args << endl; + ShExecInfo.lpParameters = args; + CoTaskMemFree(pszPath); + } + ShExecInfo.nShow = SW_SHOW; + ShellExecuteEx(&ShExecInfo); + + if (hwndOwner) + EnableWindow(hwndOwner, FALSE); + + MSG msg; + while (ShExecInfo.hProcess) + { + switch (MsgWaitForMultipleObjectsEx(1, &closeEvent, INFINITE, QS_ALLINPUT, 0)) + { + case WAIT_OBJECT_0: + CloseHandle(ShExecInfo.hProcess); + ShExecInfo.hProcess = NULL; + break; + case WAIT_OBJECT_0 + 1: + while (PeekMessage(&msg, 0, 0, 0, PM_REMOVE)) + { + TranslateMessage(&msg); + DispatchMessage(&msg); + } + continue; + default: __debugbreak(); + } + } + + if (closeEvent) + CloseHandle(closeEvent); + + if (hwndOwner) + { + EnableWindow(hwndOwner, TRUE); + SetForegroundWindow(hwndOwner); + } + + std::ifstream file(_outputPath); + if (file.good()) + { + std::string str; + std::wstring_convert> converter; + while (std::getline(file, str)) + { + std::wstring wide = converter.from_bytes(str); + _selectedItem = wide; + } + } + DeleteFile(_outputPath.c_str()); + + if (!_selectedItem.empty()) + { + // Create destination file if not existing + HANDLE hFile = CreateFile(_selectedItem.c_str(), GENERIC_WRITE, 0, 0, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, 0); + if (hFile != INVALID_HANDLE_VALUE) + { + CloseHandle(hFile); + } + else + { + _selectedItem = L""; + } + } + if (!_selectedItem.empty()) + { + if (_dialogEvents) + { + _dialogEvents->OnFileOk(this); + } + } + + return !_selectedItem.empty() ? S_OK : HRESULT_FROM_WIN32(ERROR_CANCELLED); +} + +HRESULT __stdcall CFilesSaveDialog::SetFileTypes(UINT cFileTypes, const COMDLG_FILTERSPEC* rgFilterSpec) +{ + cout << "SetFileTypes, cFileTypes: " << cFileTypes << endl; +#ifdef SYSTEMDIALOG + return _systemDialog->SetFileTypes(cFileTypes, rgFilterSpec); +#endif + return S_OK; +} + +HRESULT __stdcall CFilesSaveDialog::SetFileTypeIndex(UINT iFileType) +{ + cout << "SetFileTypeIndex, iFileType: " << iFileType << endl; +#ifdef SYSTEMDIALOG + return _systemDialog->SetFileTypeIndex(iFileType); +#endif + return S_OK; +} + +HRESULT __stdcall CFilesSaveDialog::GetFileTypeIndex(UINT* piFileType) +{ + cout << "GetFileTypeIndex" << endl; +#ifdef SYSTEMDIALOG + return _systemDialog->GetFileTypeIndex(piFileType); +#endif + * piFileType = 1; + return S_OK; +} + +HRESULT __stdcall CFilesSaveDialog::Advise(IFileDialogEvents* pfde, DWORD* pdwCookie) +{ + cout << "Advise" << endl; +#ifdef DEBUGLOG + pfde = new FilesDialogEvents(pfde, this); +#endif +#ifdef SYSTEMDIALOG + return _systemDialog->Advise(pfde, pdwCookie); +#endif + _dialogEvents = pfde; + _dialogEvents->AddRef(); + *pdwCookie = 4; + return S_OK; +} + +HRESULT __stdcall CFilesSaveDialog::Unadvise(DWORD dwCookie) +{ + cout << "Unadvise, dwCookie: " << dwCookie << endl; +#ifdef SYSTEMDIALOG + return _systemDialog->Unadvise(dwCookie); +#endif + _dialogEvents->Release(); + _dialogEvents = NULL; + return S_OK; +} + +HRESULT __stdcall CFilesSaveDialog::SetOptions(FILEOPENDIALOGOPTIONS fos) +{ + cout << "SetOptions, fos: " << fos << endl; +#ifdef SYSTEMDIALOG + return _systemDialog->SetOptions(fos); +#endif + _fos = fos; + return S_OK; +} + +HRESULT __stdcall CFilesSaveDialog::GetOptions(FILEOPENDIALOGOPTIONS* pfos) +{ + cout << "GetOptions, fos: " << _fos << endl; +#ifdef SYSTEMDIALOG + return _systemDialog->GetOptions(pfos); +#endif + * pfos = _fos; + return S_OK; +} + +HRESULT __stdcall CFilesSaveDialog::SetDefaultFolder(IShellItem* psi) +{ + PWSTR pszPath = NULL; + if (SUCCEEDED(psi->GetDisplayName(SIGDN_DESKTOPABSOLUTEPARSING, &pszPath))) + { + wcout << L"SetDefaultFolder, psi: " << pszPath << endl; + CoTaskMemFree(pszPath); + } +#ifdef SYSTEMDIALOG + return _systemDialog->SetDefaultFolder(psi); +#endif + if (_initFolder) + { + _initFolder->Release(); + } + _initFolder = CloneShellItem(psi); + return S_OK; +} + +HRESULT __stdcall CFilesSaveDialog::SetFolder(IShellItem* psi) +{ + PWSTR pszPath = NULL; + if (SUCCEEDED(psi->GetDisplayName(SIGDN_DESKTOPABSOLUTEPARSING, &pszPath))) + { + wcout << L"SetFolder, psi: " << pszPath << endl; + CoTaskMemFree(pszPath); + } +#ifdef SYSTEMDIALOG + return _systemDialog->SetFolder(psi); +#endif + if (_initFolder) + { + _initFolder->Release(); + } + _initFolder = CloneShellItem(psi); + return S_OK; +} + +HRESULT __stdcall CFilesSaveDialog::GetFolder(IShellItem** ppsi) +{ + cout << "GetFolder" << endl; +#ifdef SYSTEMDIALOG + return _systemDialog->GetFolder(ppsi); +#endif + * ppsi = NULL; + return E_NOTIMPL; +} + +HRESULT __stdcall CFilesSaveDialog::GetCurrentSelection(IShellItem** ppsi) +{ + cout << "GetCurrentSelection" << endl; +#ifdef SYSTEMDIALOG + return _systemDialog->GetCurrentSelection(ppsi); +#endif + return GetResult(ppsi); +} + +HRESULT __stdcall CFilesSaveDialog::SetFileName(LPCWSTR pszName) +{ + wcout << L"SetFileName, pszName: " << pszName << endl; +#ifdef SYSTEMDIALOG + return _systemDialog->SetFileName(pszName); +#endif + std::wstring absPath = std::wstring(pszName); + _initName = absPath.substr(absPath.find_last_of(L"/\\") + 1); + return S_OK; +} + +HRESULT __stdcall CFilesSaveDialog::GetFileName(LPWSTR* pszName) +{ + cout << "GetFileName" << endl; +#ifdef SYSTEMDIALOG + return _systemDialog->GetFileName(pszName); +#endif + SHStrDupW(L"", pszName); + if (!_selectedItem.empty()) + { + SHStrDupW(_selectedItem.c_str(), pszName); + } + return S_OK; +} + +HRESULT __stdcall CFilesSaveDialog::SetTitle(LPCWSTR pszTitle) +{ + wcout << L"SetTitle, title: " << pszTitle << endl; +#ifdef SYSTEMDIALOG + return _systemDialog->SetTitle(pszTitle); +#endif + return S_OK; +} + +HRESULT __stdcall CFilesSaveDialog::SetOkButtonLabel(LPCWSTR pszText) +{ + wcout << L"SetOkButtonLabel, pszText: " << pszText << endl; +#ifdef SYSTEMDIALOG + return _systemDialog->SetOkButtonLabel(pszText); +#endif + return S_OK; +} + +HRESULT __stdcall CFilesSaveDialog::SetFileNameLabel(LPCWSTR pszLabel) +{ + wcout << L"SetFileNameLabel, pszLabel: " << pszLabel << endl; +#ifdef SYSTEMDIALOG + return _systemDialog->SetFileNameLabel(pszLabel); +#endif + return S_OK; +} + +HRESULT __stdcall CFilesSaveDialog::GetResult(IShellItem** ppsi) +{ + cout << "GetResult" << endl; +#ifdef SYSTEMDIALOG + return _systemDialog->GetResult(ppsi); +#endif + if (!_selectedItem.empty()) + { + SHCreateItemFromParsingName(_selectedItem.c_str(), NULL, IID_IShellItem, (void**)ppsi); + return S_OK; + } + return E_NOTIMPL; +} + +HRESULT __stdcall CFilesSaveDialog::AddPlace(IShellItem* psi, FDAP fdap) +{ + PWSTR pszPath = NULL; + if (SUCCEEDED(psi->GetDisplayName(SIGDN_DESKTOPABSOLUTEPARSING, &pszPath))) + { + wcout << L"AddPlace, psi: " << pszPath << endl; + CoTaskMemFree(pszPath); + } +#ifdef SYSTEMDIALOG + return _systemDialog->AddPlace(psi, fdap); +#endif + return S_OK; +} + +HRESULT __stdcall CFilesSaveDialog::SetDefaultExtension(LPCWSTR pszDefaultExtension) +{ + wcout << L"SetDefaultExtension, pszDefaultExtension: " << pszDefaultExtension << endl; +#ifdef SYSTEMDIALOG + return _systemDialog->SetDefaultExtension(pszDefaultExtension); +#endif + return S_OK; +} + +HRESULT __stdcall CFilesSaveDialog::Close(HRESULT hr) +{ + cout << "Close, hr: " << hr << endl; +#ifdef SYSTEMDIALOG + return _systemDialog->Close(hr); +#endif + return E_NOTIMPL; +} + +HRESULT __stdcall CFilesSaveDialog::SetClientGuid(REFGUID guid) +{ + cout << "SetClientGuid" << endl; +#ifdef SYSTEMDIALOG + return _systemDialog->SetClientGuid(guid); +#endif + return S_OK; +} + +HRESULT __stdcall CFilesSaveDialog::ClearClientData(void) +{ + cout << "ClearClientData" << endl; +#ifdef SYSTEMDIALOG + return _systemDialog->ClearClientData(); +#endif + return S_OK; +} + +HRESULT __stdcall CFilesSaveDialog::SetFilter(IShellItemFilter* pFilter) +{ + cout << "SetFilter" << endl; +#ifdef SYSTEMDIALOG + return _systemDialog->SetFilter(pFilter); +#endif + return S_OK; +} + +HRESULT __stdcall CFilesSaveDialog::SetCancelButtonLabel(LPCWSTR pszLabel) +{ + cout << "SetCancelButtonLabel" << endl; +#ifdef SYSTEMDIALOG + return AsInterface(_systemDialog)->SetCancelButtonLabel(pszLabel); +#endif + return S_OK; +} + +HRESULT __stdcall CFilesSaveDialog::SetNavigationRoot(IShellItem* psi) +{ + cout << "SetNavigationRoot" << endl; +#ifdef SYSTEMDIALOG + return AsInterface(_systemDialog)->SetNavigationRoot(psi); +#endif + return S_OK; +} + +HRESULT __stdcall CFilesSaveDialog::HideControlsForHostedPickerProviderApp(void) +{ + cout << "HideControlsForHostedPickerProviderApp" << endl; +#ifdef SYSTEMDIALOG + return AsInterface(_systemDialog)->HideControlsForHostedPickerProviderApp(); +#endif + return E_NOTIMPL; +} + +HRESULT __stdcall CFilesSaveDialog::EnableControlsForHostedPickerProviderApp(void) +{ + cout << "EnableControlsForHostedPickerProviderApp" << endl; +#ifdef SYSTEMDIALOG + return AsInterface(_systemDialog)->EnableControlsForHostedPickerProviderApp(); +#endif + return E_NOTIMPL; +} + +HRESULT __stdcall CFilesSaveDialog::GetPrivateOptions(unsigned long* pfos) +{ + cout << "GetPrivateOptions" << endl; +#ifdef SYSTEMDIALOG + return AsInterface(_systemDialog)->GetPrivateOptions(pfos); +#endif + * pfos = 0; + return S_OK; +} + +HRESULT __stdcall CFilesSaveDialog::SetPrivateOptions(unsigned long fos) +{ + cout << "SetPrivateOptions" << endl; +#ifdef SYSTEMDIALOG + return AsInterface(_systemDialog)->SetPrivateOptions(fos); +#endif + return S_OK; +} + +HRESULT __stdcall CFilesSaveDialog::SetPersistenceKey(unsigned short const* pkey) +{ + cout << "SetPersistenceKey" << endl; +#ifdef SYSTEMDIALOG + return AsInterface(_systemDialog)->SetPersistenceKey(pkey); +#endif + return E_NOTIMPL; +} + +HRESULT __stdcall CFilesSaveDialog::HasPlaces(void) +{ + cout << "HasPlaces" << endl; +#ifdef SYSTEMDIALOG + return AsInterface(_systemDialog)->HasPlaces(); +#endif + return E_NOTIMPL; +} + +HRESULT __stdcall CFilesSaveDialog::EnumPlaces(int plc, _GUID const& riid, void** ppv) +{ + cout << "EnumPlaces" << endl; +#ifdef SYSTEMDIALOG + return AsInterface(_systemDialog)->EnumPlaces(plc, riid, ppv); +#endif + return E_NOTIMPL; +} + +HRESULT __stdcall CFilesSaveDialog::EnumControls(void** ppv) +{ + cout << "EnumControls" << endl; +#ifdef SYSTEMDIALOG + return AsInterface(_systemDialog)->EnumControls(ppv); +#endif + return E_NOTIMPL; +} + +HRESULT __stdcall CFilesSaveDialog::GetPersistRegkey(unsigned short** preg) +{ + cout << "GetPersistRegkey" << endl; +#ifdef SYSTEMDIALOG + return AsInterface(_systemDialog)->GetPersistRegkey(preg); +#endif + return E_NOTIMPL; +} + +HRESULT __stdcall CFilesSaveDialog::GetSavePropertyStore(IPropertyStore** ppstore, IPropertyDescriptionList** ppdesclist) +{ + cout << "GetSavePropertyStore" << endl; +#ifdef SYSTEMDIALOG + return AsInterface(_systemDialog)->GetSavePropertyStore(ppstore, ppdesclist); +#endif + return E_NOTIMPL; +} + +HRESULT __stdcall CFilesSaveDialog::GetSaveExtension(unsigned short** pext) +{ + cout << "GetSaveExtension" << endl; +#ifdef SYSTEMDIALOG + return AsInterface(_systemDialog)->GetSaveExtension(pext); +#endif + return E_NOTIMPL; +} + +HRESULT __stdcall CFilesSaveDialog::GetFileTypeControl(void** ftp) +{ + cout << "GetFileTypeControl" << endl; +#ifdef SYSTEMDIALOG + return AsInterface(_systemDialog)->GetFileTypeControl(ftp); +#endif + return E_NOTIMPL; +} + +HRESULT __stdcall CFilesSaveDialog::GetFileNameControl(void** pctrl) +{ + cout << "GetFileNameControl" << endl; +#ifdef SYSTEMDIALOG + return AsInterface(_systemDialog)->GetFileNameControl(pctrl); +#endif + return E_NOTIMPL; +} + +HRESULT __stdcall CFilesSaveDialog::GetFileProtectionControl(void** pfctrl) +{ + cout << "GetFileProtectionControl" << endl; +#ifdef SYSTEMDIALOG + return AsInterface(_systemDialog)->GetFileProtectionControl(pfctrl); +#endif + return E_NOTIMPL; +} + +HRESULT __stdcall CFilesSaveDialog::SetFolderPrivate(IShellItem* psi, int arg) +{ + cout << "SetFolderPrivate" << endl; +#ifdef SYSTEMDIALOG + return AsInterface(_systemDialog)->SetFolderPrivate(psi, arg); +#endif + return E_NOTIMPL; +} + +HRESULT __stdcall CFilesSaveDialog::SetCustomControlAreaHeight(unsigned int height) +{ + cout << "SetCustomControlAreaHeight" << endl; +#ifdef SYSTEMDIALOG + return AsInterface(_systemDialog)->SetCustomControlAreaHeight(height); +#endif + return E_NOTIMPL; +} + +HRESULT __stdcall CFilesSaveDialog::GetDialogState(unsigned long arg, unsigned long* pstate) +{ + cout << "GetDialogState" << endl; +#ifdef SYSTEMDIALOG + return AsInterface(_systemDialog)->GetDialogState(arg, pstate); +#endif + return E_NOTIMPL; +} + +HRESULT __stdcall CFilesSaveDialog::SetAppControlsModule(void* papp) +{ + cout << "SetAppControlsModule" << endl; +#ifdef SYSTEMDIALOG + return AsInterface(_systemDialog)->SetAppControlsModule(papp); +#endif + return E_NOTIMPL; +} + +HRESULT __stdcall CFilesSaveDialog::SetUserEditedSaveProperties(void) +{ + cout << "SetUserEditedSaveProperties" << endl; +#ifdef SYSTEMDIALOG + return AsInterface(_systemDialog)->SetUserEditedSaveProperties(); +#endif + return E_NOTIMPL; +} + +HRESULT __stdcall CFilesSaveDialog::ShouldShowStandardNavigationRoots(void) +{ + cout << "ShouldShowStandardNavigationRoots" << endl; +#ifdef SYSTEMDIALOG + return AsInterface(_systemDialog)->ShouldShowStandardNavigationRoots(); +#endif + return E_NOTIMPL; +} + +HRESULT __stdcall CFilesSaveDialog::GetNavigationRoot(_GUID const& riid, void** ppv) +{ + cout << "GetNavigationRoot" << endl; +#ifdef SYSTEMDIALOG + return AsInterface(_systemDialog)->GetNavigationRoot(riid, ppv); +#endif + return E_NOTIMPL; +} + +HRESULT __stdcall CFilesSaveDialog::ShouldShowFileProtectionControl(int* pfpc) +{ + cout << "ShouldShowFileProtectionControl" << endl; +#ifdef SYSTEMDIALOG + return AsInterface(_systemDialog)->ShouldShowFileProtectionControl(pfpc); +#endif + return E_NOTIMPL; +} + +HRESULT __stdcall CFilesSaveDialog::GetCurrentDialogView(_GUID const& riid, void** ppv) +{ + cout << "GetCurrentDialogView" << endl; +#ifdef SYSTEMDIALOG + return AsInterface(_systemDialog)->GetCurrentDialogView(riid, ppv); +#endif + return E_NOTIMPL; +} + +HRESULT __stdcall CFilesSaveDialog::SetSaveDialogEditBoxTextAndFileType(int arg, unsigned short const* pargb) +{ + cout << "SetSaveDialogEditBoxTextAndFileType" << endl; +#ifdef SYSTEMDIALOG + return AsInterface(_systemDialog)->SetSaveDialogEditBoxTextAndFileType(arg, pargb); +#endif + return E_NOTIMPL; +} + +HRESULT __stdcall CFilesSaveDialog::MoveFocusFromBrowser(int arg) +{ + cout << "MoveFocusFromBrowser" << endl; +#ifdef SYSTEMDIALOG + return AsInterface(_systemDialog)->MoveFocusFromBrowser(arg); +#endif + return E_NOTIMPL; +} + +HRESULT __stdcall CFilesSaveDialog::EnableOkButton(int enbl) +{ + cout << "EnableOkButton" << endl; +#ifdef SYSTEMDIALOG + return AsInterface(_systemDialog)->EnableOkButton(enbl); +#endif + return E_NOTIMPL; +} + +HRESULT __stdcall CFilesSaveDialog::InitEnterpriseId(unsigned short const* pid) +{ + cout << "InitEnterpriseId" << endl; +#ifdef SYSTEMDIALOG + return AsInterface(_systemDialog)->InitEnterpriseId(pid); +#endif + return E_NOTIMPL; +} + +HRESULT __stdcall CFilesSaveDialog::AdviseFirst(IFileDialogEvents* pfde, unsigned long* pdwCookie) +{ + cout << "AdviseFirst" << endl; +#ifdef SYSTEMDIALOG + return AsInterface(_systemDialog)->AdviseFirst(pfde, pdwCookie); +#endif + return E_NOTIMPL; +} + +HRESULT __stdcall CFilesSaveDialog::HandleTab(void) +{ + cout << "HandleTab" << endl; +#ifdef SYSTEMDIALOG + return AsInterface(_systemDialog)->HandleTab(); +#endif + return E_NOTIMPL; +} + +HRESULT __stdcall CFilesSaveDialog::SetSaveAsItem(IShellItem* psi) +{ + PWSTR pszPath = NULL; + if (SUCCEEDED(psi->GetDisplayName(SIGDN_DESKTOPABSOLUTEPARSING, &pszPath))) + { + wcout << L"SetSaveAsItem, psi: " << pszPath << endl; + CoTaskMemFree(pszPath); + } +#ifdef SYSTEMDIALOG + return _systemDialog->SetSaveAsItem(psi); +#endif + if (_initFolder) + { + _initFolder->Release(); + } + psi->GetParent(&_initFolder); + if (SUCCEEDED(psi->GetDisplayName(SIGDN_NORMALDISPLAY, &pszPath))) + { + _initName = pszPath; + } + return S_OK; +} + +HRESULT __stdcall CFilesSaveDialog::SetProperties(IPropertyStore* pStore) +{ + cout << "SetProperties" << endl; +#ifdef SYSTEMDIALOG + return _systemDialog->SetProperties(pStore); +#endif + return S_OK; +} + +HRESULT __stdcall CFilesSaveDialog::SetCollectedProperties(IPropertyDescriptionList* pList, BOOL fAppendDefault) +{ + cout << "SetCollectedProperties" << endl; +#ifdef SYSTEMDIALOG + return _systemDialog->SetCollectedProperties(pList, fAppendDefault); +#endif + return S_OK; +} + +HRESULT __stdcall CFilesSaveDialog::GetProperties(IPropertyStore** ppStore) +{ + cout << "GetProperties" << endl; +#ifdef SYSTEMDIALOG + return _systemDialog->GetProperties(ppStore); +#endif + if (!_selectedItem.empty()) + { + return SHGetPropertyStoreFromParsingName(_selectedItem.c_str(), + NULL, GPS_DEFAULT, __uuidof(IPropertyStore), (void**)ppStore); + } + return E_NOTIMPL; +} + +HRESULT __stdcall CFilesSaveDialog::ApplyProperties(IShellItem* psi, IPropertyStore* pStore, HWND hwnd, IFileOperationProgressSink* pSink) +{ + cout << "ApplyProperties" << endl; +#ifdef SYSTEMDIALOG + return _systemDialog->ApplyProperties(psi, pStore, hwnd, pSink); +#endif + return S_OK; +} + +HRESULT __stdcall CFilesSaveDialog::GetWindow(HWND* phwnd) +{ + cout << "GetWindow" << endl; +#ifdef SYSTEMDIALOG + return AsInterface(_systemDialog)->GetWindow(phwnd); +#endif + * phwnd = NULL; + return S_OK; +} + +HRESULT __stdcall CFilesSaveDialog::ContextSensitiveHelp(BOOL fEnterMode) +{ + cout << "ContextSensitiveHelp" << endl; +#ifdef SYSTEMDIALOG + return AsInterface(_systemDialog)->ContextSensitiveHelp(fEnterMode); +#endif + return S_OK; +} diff --git a/src/Files.App.SaveDialog/FilesSaveDialog.h b/src/Files.App.SaveDialog/FilesSaveDialog.h new file mode 100644 index 000000000000..85908dd50882 --- /dev/null +++ b/src/Files.App.SaveDialog/FilesSaveDialog.h @@ -0,0 +1,273 @@ +// FilesSaveDialog.h: dichiarazione di CFilesSaveDialog + +#pragma once +#include "resource.h" // simboli principali + + +#define DEBUGLOG + + +#include "CustomSaveDialog_i.h" +#include "UndefInterfaces.h" +#include +#include +#include + + +#if defined(_WIN32_WCE) && !defined(_CE_DCOM) && !defined(_CE_ALLOW_SINGLE_THREADED_OBJECTS_IN_MTA) +#error "Gli oggetti COM a thread singolo non sono supportati correttamente sulla piattaforma Windows CE, ad esempio le piattaforme Windows Mobile non includono un supporto DCOM completo. Definire _CE_ALLOW_SINGLE_THREADED_OBJECTS_IN_MTA per fare in modo che ATL supporti la creazione di oggetti COM a thread singolo e consenta l'utilizzo di implementazioni con oggetti COM a thread singolo. Il modello di threading nel file RGS è stato impostato su 'Free' poiché è l'unico modello di threading supportato sulle piattaforme Windows CE non DCOM." +#endif + +using namespace ATL; + + +// CFilesSaveDialog + +class ATL_NO_VTABLE CFilesSaveDialog : + public CComObjectRootEx, + public CComCoClass, + public IFileDialog, + public IFileDialog2, + public IFileSaveDialog, + public IFileDialogCustomize, + public IObjectWithSite, + public IFileDialogPrivate, + public IOleWindow +{ +public: + CFilesSaveDialog(); + +DECLARE_REGISTRY_RESOURCEID(106) + +CUSTOM_BEGIN_COM_MAP(CFilesSaveDialog) + COM_INTERFACE_ENTRY(IFileDialog) + COM_INTERFACE_ENTRY(IFileDialog2) + COM_INTERFACE_ENTRY(IFileSaveDialog) + COM_INTERFACE_ENTRY(IFileDialogCustomize) + COM_INTERFACE_ENTRY(IObjectWithSite) + COM_INTERFACE_ENTRY(IFileDialogPrivate) + COM_INTERFACE_ENTRY(IOleWindow) +END_COM_MAP() + + DECLARE_PROTECT_FINAL_CONSTRUCT() + + HRESULT FinalConstruct() + { + return S_OK; + } + + void FinalRelease(); + + CComPtr _systemDialog; + + FILEOPENDIALOGOPTIONS _fos; + + std::vector _ctrlItems; + + std::wstring _selectedItem; + std::wstring _outputPath; + std::wstring _initName; + IShellItem* _initFolder; + IFileDialogEvents* _dialogEvents; + + FILE* _debugStream; + +public: + // Ereditato tramite IObjectWithSite + HRESULT __stdcall SetSite(IUnknown* pUnkSite) override; + + HRESULT __stdcall GetSite(REFIID riid, void** ppvSite) override; + + + // Ereditato tramite IFileDialogCustomize + HRESULT __stdcall EnableOpenDropDown(DWORD dwIDCtl) override; + + HRESULT __stdcall AddMenu(DWORD dwIDCtl, LPCWSTR pszLabel) override; + + HRESULT __stdcall AddPushButton(DWORD dwIDCtl, LPCWSTR pszLabel) override; + + HRESULT __stdcall AddComboBox(DWORD dwIDCtl) override; + + HRESULT __stdcall AddRadioButtonList(DWORD dwIDCtl) override; + + HRESULT __stdcall AddCheckButton(DWORD dwIDCtl, LPCWSTR pszLabel, BOOL bChecked) override; + + HRESULT __stdcall AddEditBox(DWORD dwIDCtl, LPCWSTR pszText) override; + + HRESULT __stdcall AddSeparator(DWORD dwIDCtl) override; + + HRESULT __stdcall AddText(DWORD dwIDCtl, LPCWSTR pszText) override; + + HRESULT __stdcall SetControlLabel(DWORD dwIDCtl, LPCWSTR pszLabel) override; + + HRESULT __stdcall GetControlState(DWORD dwIDCtl, CDCONTROLSTATEF* pdwState) override; + + HRESULT __stdcall SetControlState(DWORD dwIDCtl, CDCONTROLSTATEF dwState) override; + + HRESULT __stdcall GetEditBoxText(DWORD dwIDCtl, WCHAR** ppszText) override; + + HRESULT __stdcall SetEditBoxText(DWORD dwIDCtl, LPCWSTR pszText) override; + + HRESULT __stdcall GetCheckButtonState(DWORD dwIDCtl, BOOL* pbChecked) override; + + HRESULT __stdcall SetCheckButtonState(DWORD dwIDCtl, BOOL bChecked) override; + + HRESULT __stdcall AddControlItem(DWORD dwIDCtl, DWORD dwIDItem, LPCWSTR pszLabel) override; + + HRESULT __stdcall RemoveControlItem(DWORD dwIDCtl, DWORD dwIDItem) override; + + HRESULT __stdcall RemoveAllControlItems(DWORD dwIDCtl) override; + + HRESULT __stdcall GetControlItemState(DWORD dwIDCtl, DWORD dwIDItem, CDCONTROLSTATEF* pdwState) override; + + HRESULT __stdcall SetControlItemState(DWORD dwIDCtl, DWORD dwIDItem, CDCONTROLSTATEF dwState) override; + + HRESULT __stdcall GetSelectedControlItem(DWORD dwIDCtl, DWORD* pdwIDItem) override; + + HRESULT __stdcall SetSelectedControlItem(DWORD dwIDCtl, DWORD dwIDItem) override; + + HRESULT __stdcall StartVisualGroup(DWORD dwIDCtl, LPCWSTR pszLabel) override; + + HRESULT __stdcall EndVisualGroup(void) override; + + HRESULT __stdcall MakeProminent(DWORD dwIDCtl) override; + + HRESULT __stdcall SetControlItemText(DWORD dwIDCtl, DWORD dwIDItem, LPCWSTR pszLabel) override; + + + // Ereditato tramite IFileDialog + HRESULT __stdcall Show(HWND hwndOwner) override; + + HRESULT __stdcall SetFileTypes(UINT cFileTypes, const COMDLG_FILTERSPEC* rgFilterSpec) override; + + HRESULT __stdcall SetFileTypeIndex(UINT iFileType) override; + + HRESULT __stdcall GetFileTypeIndex(UINT* piFileType) override; + + HRESULT __stdcall Advise(IFileDialogEvents* pfde, DWORD* pdwCookie) override; + + HRESULT __stdcall Unadvise(DWORD dwCookie) override; + + HRESULT __stdcall SetOptions(FILEOPENDIALOGOPTIONS fos) override; + + HRESULT __stdcall GetOptions(FILEOPENDIALOGOPTIONS* pfos) override; + + HRESULT __stdcall SetDefaultFolder(IShellItem* psi) override; + + HRESULT __stdcall SetFolder(IShellItem* psi) override; + + HRESULT __stdcall GetFolder(IShellItem** ppsi) override; + + HRESULT __stdcall GetCurrentSelection(IShellItem** ppsi) override; + + HRESULT __stdcall SetFileName(LPCWSTR pszName) override; + + HRESULT __stdcall GetFileName(LPWSTR* pszName) override; + + HRESULT __stdcall SetTitle(LPCWSTR pszTitle) override; + + HRESULT __stdcall SetOkButtonLabel(LPCWSTR pszText) override; + + HRESULT __stdcall SetFileNameLabel(LPCWSTR pszLabel) override; + + HRESULT __stdcall GetResult(IShellItem** ppsi) override; + + HRESULT __stdcall AddPlace(IShellItem* psi, FDAP fdap) override; + + HRESULT __stdcall SetDefaultExtension(LPCWSTR pszDefaultExtension) override; + + HRESULT __stdcall Close(HRESULT hr) override; + + HRESULT __stdcall SetClientGuid(REFGUID guid) override; + + HRESULT __stdcall ClearClientData(void) override; + + HRESULT __stdcall SetFilter(IShellItemFilter* pFilter) override; + + + // Ereditato tramite IFileDialog2 + HRESULT __stdcall SetCancelButtonLabel(LPCWSTR pszLabel) override; + + HRESULT __stdcall SetNavigationRoot(IShellItem* psi) override; + + + // Ereditato tramite IFileDialogPrivate + HRESULT __stdcall HideControlsForHostedPickerProviderApp(void) override; + + HRESULT __stdcall EnableControlsForHostedPickerProviderApp(void) override; + + HRESULT __stdcall GetPrivateOptions(unsigned long*) override; + + HRESULT __stdcall SetPrivateOptions(unsigned long) override; + + HRESULT __stdcall SetPersistenceKey(unsigned short const*) override; + + HRESULT __stdcall HasPlaces(void) override; + + HRESULT __stdcall EnumPlaces(int, _GUID const&, void**) override; + + HRESULT __stdcall EnumControls(void**) override; + + HRESULT __stdcall GetPersistRegkey(unsigned short**) override; + + HRESULT __stdcall GetSavePropertyStore(IPropertyStore**, IPropertyDescriptionList**) override; + + HRESULT __stdcall GetSaveExtension(unsigned short**) override; + + HRESULT __stdcall GetFileTypeControl(void**) override; + + HRESULT __stdcall GetFileNameControl(void**) override; + + HRESULT __stdcall GetFileProtectionControl(void**) override; + + HRESULT __stdcall SetFolderPrivate(IShellItem*, int) override; + + HRESULT __stdcall SetCustomControlAreaHeight(unsigned int) override; + + HRESULT __stdcall GetDialogState(unsigned long, unsigned long*) override; + + HRESULT __stdcall SetAppControlsModule(void*) override; + + HRESULT __stdcall SetUserEditedSaveProperties(void) override; + + HRESULT __stdcall ShouldShowStandardNavigationRoots(void) override; + + HRESULT __stdcall GetNavigationRoot(_GUID const&, void**) override; + + HRESULT __stdcall ShouldShowFileProtectionControl(int*) override; + + HRESULT __stdcall GetCurrentDialogView(_GUID const&, void**) override; + + HRESULT __stdcall SetSaveDialogEditBoxTextAndFileType(int, unsigned short const*) override; + + HRESULT __stdcall MoveFocusFromBrowser(int) override; + + HRESULT __stdcall EnableOkButton(int) override; + + HRESULT __stdcall InitEnterpriseId(unsigned short const*) override; + + HRESULT __stdcall AdviseFirst(IFileDialogEvents*, unsigned long*) override; + + HRESULT __stdcall HandleTab(void) override; + + + // Ereditato tramite IFileSaveDialog + HRESULT __stdcall SetSaveAsItem(IShellItem* psi) override; + + HRESULT __stdcall SetProperties(IPropertyStore* pStore) override; + + HRESULT __stdcall SetCollectedProperties(IPropertyDescriptionList* pList, BOOL fAppendDefault) override; + + HRESULT __stdcall GetProperties(IPropertyStore** ppStore) override; + + HRESULT __stdcall ApplyProperties(IShellItem* psi, IPropertyStore* pStore, HWND hwnd, IFileOperationProgressSink* pSink) override; + + + // Ereditato tramite IOleWindow + virtual HRESULT __stdcall GetWindow(HWND* phwnd) override; + + virtual HRESULT __stdcall ContextSensitiveHelp(BOOL fEnterMode) override; + +}; + +OBJECT_ENTRY_AUTO(__uuidof(FilesSaveDialog), CFilesSaveDialog) diff --git a/src/Files.App.SaveDialog/FilesSaveDialog.rgs b/src/Files.App.SaveDialog/FilesSaveDialog.rgs new file mode 100644 index 000000000000..fc0a4b6e4351 --- /dev/null +++ b/src/Files.App.SaveDialog/FilesSaveDialog.rgs @@ -0,0 +1,16 @@ +HKCR +{ + NoRemove CLSID + { + ForceRemove {C0B4E2F3-BA21-4773-8DBA-335EC946EB8B} = s 'FilesSaveDialog class' + { + ForceRemove Programmable + InprocServer32 = s '%MODULE%' + { + val ThreadingModel = s 'Apartment' + } + TypeLib = s '{21533617-c1cd-4d33-a190-21fb069b55f4}' + Version = s '1.0' + } + } +} diff --git a/src/Files.App.SaveDialog/UndefInterfaces.h b/src/Files.App.SaveDialog/UndefInterfaces.h new file mode 100644 index 000000000000..75dba8b174cd --- /dev/null +++ b/src/Files.App.SaveDialog/UndefInterfaces.h @@ -0,0 +1,89 @@ +// UndefInterfaces.h: undocumented interfaces declarations & helpers + +#pragma once + + +#include "framework.h" +#include "shobjidl.h" + + +using namespace ATL; + + +#ifdef DEBUGLOG + +#define CUSTOM_BEGIN_COM_MAP(x) public: \ + typedef x _ComMapClass; \ + static HRESULT WINAPI _Cache(_In_ void* pv, _In_ REFIID iid, _COM_Outptr_result_maybenull_ void** ppvObject, _In_ DWORD_PTR dw) throw()\ + {\ + _ComMapClass* p = (_ComMapClass*)pv;\ + p->Lock();\ + HRESULT hRes = E_FAIL; \ + __try \ + { \ + hRes = ATL::CComObjectRootBase::_Cache(pv, iid, ppvObject, dw);\ + } \ + __finally \ + { \ + p->Unlock();\ + } \ + return hRes;\ + }\ + IUnknown* _GetRawUnknown() throw() \ + { ATLASSERT(_GetEntries()[0].pFunc == _ATL_SIMPLEMAPENTRY); return (IUnknown*)((INT_PTR)this+_GetEntries()->dw); } \ + _ATL_DECLARE_GET_UNKNOWN(x)\ + HRESULT _InternalQueryInterface( \ + _In_ REFIID iid, \ + _COM_Outptr_ void** ppvObject) throw() \ + { \ + HRESULT res = this->InternalQueryInterface(this, _GetEntries(), iid, ppvObject); \ + OLECHAR* guidString; \ + (void)StringFromCLSID(iid, &guidString); \ + std::wcout << L"QueryInterface: " << guidString << L" = " << res << std::endl; \ + ::CoTaskMemFree(guidString); \ + return res; \ + } \ + const static ATL::_ATL_INTMAP_ENTRY* WINAPI _GetEntries() throw() { \ + static const ATL::_ATL_INTMAP_ENTRY _entries[] = { DEBUG_QI_ENTRY(x) + +#else + +#define CUSTOM_BEGIN_COM_MAP(x) BEGIN_COM_MAP(x) + +#endif // DEBUGLOG + + +MIDL_INTERFACE("9EA5491C-89C8-4BEF-93D3-7F665FB82A33") +IFileDialogPrivate : public IUnknown +{ +public: + virtual HRESULT STDMETHODCALLTYPE HideControlsForHostedPickerProviderApp(void) = 0; + virtual HRESULT STDMETHODCALLTYPE EnableControlsForHostedPickerProviderApp(void) = 0; + virtual HRESULT STDMETHODCALLTYPE GetPrivateOptions(unsigned long*) = 0; + virtual HRESULT STDMETHODCALLTYPE SetPrivateOptions(unsigned long) = 0; + virtual HRESULT STDMETHODCALLTYPE SetPersistenceKey(unsigned short const*) = 0; + virtual HRESULT STDMETHODCALLTYPE HasPlaces(void) = 0; + virtual HRESULT STDMETHODCALLTYPE EnumPlaces(int, _GUID const&, void**) = 0;//tagFDPEPLACES + virtual HRESULT STDMETHODCALLTYPE EnumControls(void**) = 0;//IEnumAppControl + virtual HRESULT STDMETHODCALLTYPE GetPersistRegkey(unsigned short**) = 0; + virtual HRESULT STDMETHODCALLTYPE GetSavePropertyStore(IPropertyStore**, IPropertyDescriptionList**) = 0; + virtual HRESULT STDMETHODCALLTYPE GetSaveExtension(unsigned short**) = 0; + virtual HRESULT STDMETHODCALLTYPE GetFileTypeControl(void**) = 0;//IAppControl + virtual HRESULT STDMETHODCALLTYPE GetFileNameControl(void**) = 0;//IAppControl + virtual HRESULT STDMETHODCALLTYPE GetFileProtectionControl(void**) = 0;//IAppControl + virtual HRESULT STDMETHODCALLTYPE SetFolderPrivate(IShellItem*, int) = 0; + virtual HRESULT STDMETHODCALLTYPE SetCustomControlAreaHeight(unsigned int) = 0; + virtual HRESULT STDMETHODCALLTYPE GetDialogState(unsigned long, unsigned long*) = 0; + virtual HRESULT STDMETHODCALLTYPE SetAppControlsModule(void*) = 0;//IAppControlsModule + virtual HRESULT STDMETHODCALLTYPE SetUserEditedSaveProperties(void) = 0; + virtual HRESULT STDMETHODCALLTYPE ShouldShowStandardNavigationRoots(void) = 0; + virtual HRESULT STDMETHODCALLTYPE GetNavigationRoot(_GUID const&, void**) = 0; + virtual HRESULT STDMETHODCALLTYPE ShouldShowFileProtectionControl(int*) = 0; + virtual HRESULT STDMETHODCALLTYPE GetCurrentDialogView(_GUID const&, void**) = 0; + virtual HRESULT STDMETHODCALLTYPE SetSaveDialogEditBoxTextAndFileType(int, unsigned short const*) = 0; + virtual HRESULT STDMETHODCALLTYPE MoveFocusFromBrowser(int) = 0; + virtual HRESULT STDMETHODCALLTYPE EnableOkButton(int) = 0; + virtual HRESULT STDMETHODCALLTYPE InitEnterpriseId(unsigned short const*) = 0; + virtual HRESULT STDMETHODCALLTYPE AdviseFirst(IFileDialogEvents*, unsigned long*) = 0; + virtual HRESULT STDMETHODCALLTYPE HandleTab(void) = 0; +}; diff --git a/src/Files.App.SaveDialog/dllmain.cpp b/src/Files.App.SaveDialog/dllmain.cpp new file mode 100644 index 000000000000..e3b584168b34 --- /dev/null +++ b/src/Files.App.SaveDialog/dllmain.cpp @@ -0,0 +1,16 @@ +// dllmain.cpp: implementazione di DllMain. + +#include "pch.h" +#include "framework.h" +#include "resource.h" +#include "CustomSaveDialog_i.h" +#include "dllmain.h" + +CCustomSaveDialogModule _AtlModule; + +// Punto di ingresso DLL +extern "C" BOOL WINAPI DllMain(HINSTANCE hInstance, DWORD dwReason, LPVOID lpReserved) +{ + hInstance; + return _AtlModule.DllMain(dwReason, lpReserved); +} diff --git a/src/Files.App.SaveDialog/dllmain.h b/src/Files.App.SaveDialog/dllmain.h new file mode 100644 index 000000000000..284a990fe6d1 --- /dev/null +++ b/src/Files.App.SaveDialog/dllmain.h @@ -0,0 +1,10 @@ +// dllmain.h: dichiarazione della classe del modulo. + +class CCustomSaveDialogModule : public ATL::CAtlDllModuleT< CCustomSaveDialogModule > +{ +public : + DECLARE_LIBID(LIBID_CustomSaveDialogLib) + DECLARE_REGISTRY_APPID_RESOURCEID(IDR_CUSTOMSAVEDIALOG, "{21533617-c1cd-4d33-a190-21fb069b55f4}") +}; + +extern class CCustomSaveDialogModule _AtlModule; diff --git a/src/Files.App.SaveDialog/framework.h b/src/Files.App.SaveDialog/framework.h new file mode 100644 index 000000000000..9ac7cffd8ddd --- /dev/null +++ b/src/Files.App.SaveDialog/framework.h @@ -0,0 +1,21 @@ +#pragma once + +#ifndef STRICT +#define STRICT +#endif + +#include "targetver.h" + +#define _ATL_APARTMENT_THREADED + +#define _ATL_NO_AUTOMATIC_NAMESPACE + +#define _ATL_CSTRING_EXPLICIT_CONSTRUCTORS // alcuni costruttori CString saranno espliciti + + +#define ATL_NO_ASSERT_ON_DESTROY_NONEXISTENT_WINDOW + +#include "resource.h" +#include +#include +#include diff --git a/src/Files.App.SaveDialog/pch.cpp b/src/Files.App.SaveDialog/pch.cpp new file mode 100644 index 000000000000..69046d3e1dc0 --- /dev/null +++ b/src/Files.App.SaveDialog/pch.cpp @@ -0,0 +1,5 @@ +// pch.cpp: file di origine corrispondente all'intestazione precompilata + +#include "pch.h" + +// Quando si usano intestazioni precompilate, questo file è necessario per la riuscita della compilazione. diff --git a/src/Files.App.SaveDialog/pch.h b/src/Files.App.SaveDialog/pch.h new file mode 100644 index 000000000000..aa5d1c5a0950 --- /dev/null +++ b/src/Files.App.SaveDialog/pch.h @@ -0,0 +1,13 @@ +// pch.h: questo è un file di intestazione precompilata. +// I file elencati di seguito vengono compilati una sola volta, in modo da migliorare le prestazioni per le compilazioni successive. +// Questa impostazione influisce anche sulle prestazioni di IntelliSense, incluso il completamento codice e molte altre funzionalità di esplorazione del codice. +// I file elencati qui vengono però TUTTI ricompilati se uno di essi viene aggiornato da una compilazione all'altra. +// Non aggiungere qui file soggetti a frequenti aggiornamenti; in caso contrario si perderanno i vantaggi offerti in termini di prestazioni. + +#ifndef PCH_H +#define PCH_H + +// aggiungere qui le intestazioni da precompilare +#include "framework.h" + +#endif //PCH_H diff --git a/src/Files.App.SaveDialog/resource.h b/src/Files.App.SaveDialog/resource.h new file mode 100644 index 000000000000..fbb30dbffe4e --- /dev/null +++ b/src/Files.App.SaveDialog/resource.h @@ -0,0 +1,18 @@ +//{{NO_DEPENDENCIES}} +// File di inclusione generato con Microsoft Visual C++. +// Utilizzato da CustomSaveDialog.rc +// +#define IDS_PROJNAME 100 +#define IDR_CUSTOMSAVEDIALOG 101 +#define IDR_FILESSAVEDIALOG 106 + +// Next default values for new objects +// +#ifdef APSTUDIO_INVOKED +#ifndef APSTUDIO_READONLY_SYMBOLS +#define _APS_NEXT_RESOURCE_VALUE 201 +#define _APS_NEXT_COMMAND_VALUE 32768 +#define _APS_NEXT_CONTROL_VALUE 201 +#define _APS_NEXT_SYMED_VALUE 107 +#endif +#endif diff --git a/src/Files.App.SaveDialog/targetver.h b/src/Files.App.SaveDialog/targetver.h new file mode 100644 index 000000000000..7672c2eee3bc --- /dev/null +++ b/src/Files.App.SaveDialog/targetver.h @@ -0,0 +1,8 @@ +#pragma once + +// L'inclusione di SDKDDKVer.h definisce la piattaforma Windows più recente disponibile. + +// Se si desidera compilare l'applicazione per una piattaforma Windows precedente, includere WinSDKVer.h e +// impostare la macro _WIN32_WINNT sulla piattaforma da supportare prima di includere SDKDDKVer.h. + +#include diff --git a/src/Files.App/App.xaml.cs b/src/Files.App/App.xaml.cs index 5895b10b0fb3..7e4c0eb63ffe 100644 --- a/src/Files.App/App.xaml.cs +++ b/src/Files.App/App.xaml.cs @@ -211,6 +211,24 @@ private async void Window_Closed(object sender, WindowEventArgs args) // Save the current tab list in case it was overwriten by another instance AppLifecycleHelper.SaveSessionTabs(); + if (OutputPath is not null) + { + var instance = MainPageViewModel.AppInstances.FirstOrDefault(x => x.TabItemContent.IsCurrentInstance); + if (instance is null) + return; + + var items = (instance.TabItemContent as PaneHolderPage)?.ActivePane?.SlimContentPage?.SelectedItems; + if (items is null) + return; + + var results = items.Select(x => x.ItemPath).ToList(); + System.IO.File.WriteAllLines(OutputPath, results); + + IntPtr eventHandle = Win32PInvoke.CreateEvent(IntPtr.Zero, false, false, "FILEDIALOG"); + Win32PInvoke.SetEvent(eventHandle); + Win32PInvoke.CloseHandle(eventHandle); + } + // Continue running the app on the background if (userSettingsService.GeneralSettingsService.LeaveAppRunning && !AppModel.ForceProcessTermination && @@ -292,23 +310,6 @@ private async void Window_Closed(object sender, WindowEventArgs args) // Method can take a long time, make sure the window is hidden await Task.Yield(); - if (OutputPath is not null) - { - await SafetyExtensions.IgnoreExceptions(async () => - { - var instance = MainPageViewModel.AppInstances.FirstOrDefault(x => x.TabItemContent.IsCurrentInstance); - if (instance is null) - return; - - var items = (instance.TabItemContent as PaneHolderPage)?.ActivePane?.SlimContentPage?.SelectedItems; - if (items is null) - return; - - await FileIO.WriteLinesAsync(await StorageFile.GetFileFromPathAsync(OutputPath), items.Select(x => x.ItemPath)); - }, - Logger); - } - // Try to maintain clipboard data after app close SafetyExtensions.IgnoreExceptions(() => { diff --git a/src/Files.App/Assets/FilesOpenDialog/CustomOpenDialog64.dll b/src/Files.App/Assets/FilesOpenDialog/CustomOpenDialog64.dll deleted file mode 100644 index d860dba43d3f805eeeed0a3c72f04e3dba4ce53e..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 474112 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 SetProperty(ref isSetAsOpenFileDialog, value); } + public bool CanShowSetAsOpenFileDialog + { + get => AppLifecycleHelper.AppEnvironment is AppEnvironment.Dev; + } + private FileSavePicker InitializeWithWindow(FileSavePicker obj) { WinRT.Interop.InitializeWithWindow.Initialize(obj, MainWindow.Instance.WindowHandle); diff --git a/src/Files.App/Views/Settings/AdvancedPage.xaml b/src/Files.App/Views/Settings/AdvancedPage.xaml index 27717da5b219..7fae282bf0dd 100644 --- a/src/Files.App/Views/Settings/AdvancedPage.xaml +++ b/src/Files.App/Views/Settings/AdvancedPage.xaml @@ -163,7 +163,7 @@ x:Name="ReplaceOpenFileDialogSetting" Title="{helpers:ResourceString Name=SettingsSetAsOpenDialog}" HorizontalAlignment="Stretch" - x:Load="False"> + x:Load="{x:Bind ViewModel.CanShowSetAsOpenFileDialog}">