diff --git a/src/Files.App.CsWin32/NativeMethods.txt b/src/Files.App.CsWin32/NativeMethods.txt
index 9d7c337d7c4d..2cd8c6234c8c 100644
--- a/src/Files.App.CsWin32/NativeMethods.txt
+++ b/src/Files.App.CsWin32/NativeMethods.txt
@@ -133,3 +133,25 @@ IFileOperation
IShellItem2
PSGetPropertyKeyFromName
ShellExecuteEx
+E_FAIL
+S_OK
+S_FALSE
+MSG
+E_NOTIMPL
+LOGFONTW
+AssocCreate
+IQueryAssociations
+UnregisterClass
+SetWindowLong
+GetModuleHandle
+RegisterClassEx
+CREATESTRUCTW
+AssocQueryString
+IPreviewHandlerFrame
+IPreviewHandlerVisuals
+IObjectWithSite
+IInitializeWithStream
+IInitializeWithStreamNative
+IInitializeWithFile
+IInitializeWithItem
+SHCreateStreamOnFileEx
diff --git a/src/Files.App/UserControls/FilePreviews/ShellPreview.xaml.cs b/src/Files.App/UserControls/FilePreviews/ShellPreview.xaml.cs
index d0f09e7aed50..935227a1cc07 100644
--- a/src/Files.App/UserControls/FilePreviews/ShellPreview.xaml.cs
+++ b/src/Files.App/UserControls/FilePreviews/ShellPreview.xaml.cs
@@ -1,8 +1,11 @@
+// Copyright (c) 2024 Files Community
+// Licensed under the MIT License. See the LICENSE.
+
using Files.App.ViewModels.Previews;
using Microsoft.UI.Xaml;
using Microsoft.UI.Xaml.Controls;
-using Vanara.PInvoke;
using Windows.Foundation;
+using Windows.Win32.Foundation;
namespace Files.App.UserControls.FilePreviews
{
@@ -13,13 +16,15 @@ public sealed partial class ShellPreview : UserControl
public ShellPreview(ShellPreviewViewModel model)
{
ViewModel = model;
- this.InitializeComponent();
+
+ InitializeComponent();
}
private void PreviewHost_Loaded(object sender, RoutedEventArgs e)
{
ViewModel.LoadPreview(contentPresenter);
ViewModel.SizeChanged(GetPreviewSize());
+
if (XamlRoot.Content is FrameworkElement element)
{
element.SizeChanged += PreviewHost_SizeChanged;
@@ -38,11 +43,13 @@ private RECT GetPreviewSize()
var physicalSize = contentPresenter.RenderSize;
var physicalPos = source.TransformPoint(new Point(0, 0));
var scale = XamlRoot.RasterizationScale;
- var result = new RECT();
- result.Left = (int)(physicalPos.X * scale + 0.5);
- result.Top = (int)(physicalPos.Y * scale + 0.5);
- result.Width = (int)(physicalSize.Width * scale + 0.5);
- result.Height = (int)(physicalSize.Height * scale + 0.5);
+
+ var result = RECT.FromXYWH(
+ (int)(physicalPos.X * scale + 0.5),
+ (int)(physicalPos.Y * scale + 0.5),
+ (int)(physicalSize.Width * scale + 0.5),
+ (int)(physicalSize.Height * scale + 0.5));
+
return result;
}
@@ -53,6 +60,7 @@ private void PreviewHost_Unloaded(object sender, RoutedEventArgs e)
element.SizeChanged -= PreviewHost_SizeChanged;
element.PointerEntered -= PreviewHost_PointerEntered;
}
+
ViewModel.UnloadPreview();
}
diff --git a/src/Files.App/Utils/Shell/ItemStreamHelper.cs b/src/Files.App/Utils/Shell/ItemStreamHelper.cs
deleted file mode 100644
index 523845e21d8c..000000000000
--- a/src/Files.App/Utils/Shell/ItemStreamHelper.cs
+++ /dev/null
@@ -1,37 +0,0 @@
-using System;
-using System.Runtime.InteropServices;
-using Vanara.PInvoke;
-
-namespace Files.App.Utils.Shell
-{
- public static class ItemStreamHelper
- {
- static readonly Guid IShellItemIid = Guid.ParseExact("43826d1e-e718-42ee-bc55-a1e261c37bfe", "d");
-
- public static IntPtr IShellItemFromPath(string path)
- {
- IntPtr psi;
- Guid iid = IShellItemIid;
- var hr = Win32PInvoke.SHCreateItemFromParsingName(path, IntPtr.Zero, ref iid, out psi);
- if ((int)hr < 0)
- return IntPtr.Zero;
- return psi;
- }
-
- public static IntPtr IStreamFromPath(string path)
- {
- IntPtr pstm;
- var hr = Win32PInvoke.SHCreateStreamOnFileEx(path,
- STGM.STGM_READ | STGM.STGM_FAILIFTHERE | STGM.STGM_SHARE_DENY_NONE,
- 0, 0, IntPtr.Zero, out pstm);
- if ((int)hr < 0)
- return IntPtr.Zero;
- return pstm;
- }
-
- public static void ReleaseObject(IntPtr obj)
- {
- Marshal.Release(obj);
- }
- }
-}
diff --git a/src/Files.App/Utils/Shell/PreviewHandler.cs b/src/Files.App/Utils/Shell/PreviewHandler.cs
index 6cb5f4001798..18e7978a11ee 100644
--- a/src/Files.App/Utils/Shell/PreviewHandler.cs
+++ b/src/Files.App/Utils/Shell/PreviewHandler.cs
@@ -1,407 +1,276 @@
-using System;
-using System.Collections.Generic;
+// Copyright (c) 2024 Files Community
+// Licensed under the MIT License. See the LICENSE.
+
+using LibGit2Sharp;
using System.Runtime.InteropServices;
-using System.Runtime.InteropServices.ComTypes;
-using Vanara.PInvoke;
using Windows.UI;
+using Windows.Win32;
+using Windows.Win32.Foundation;
+using Windows.Win32.Graphics.Gdi;
+using Windows.Win32.System.Com;
+using Windows.Win32.System.Ole;
+using Windows.Win32.UI.Shell;
+using Windows.Win32.UI.Shell.PropertiesSystem;
+using Windows.Win32.UI.WindowsAndMessaging;
namespace Files.App.Utils.Shell
{
/// <summary>
- /// Credits: https://github.com/GeeLaw/PreviewHost/
+ /// Provides a set of functionalities to interact with Windows preview handlers.
/// </summary>
- public sealed class PreviewHandler : IDisposable
+ /// <remarks>
+ /// Credit: <a href="https://github.com/GeeLaw/PreviewHost"/>
+ /// </remarks>
+ public unsafe sealed class PreviewHandler : IDisposable
{
- #region IPreviewHandlerFrame support
+ // Fields
- [StructLayout(LayoutKind.Sequential)]
- public struct PreviewHandlerFrameInfo
- {
- public IntPtr AcceleratorTableHandle;
- public uint AcceleratorEntryCount;
- }
+ private readonly IPreviewHandlerFrame.Interface _previewHandlerFrame;
+ private readonly IPreviewHandler* _pPreviewHandler;
+ private readonly IPreviewHandlerVisuals* _previewHandlerVisuals;
+ private readonly HWND _hWnd;
+ private bool _disposed;
+ private bool _initialized;
+ private bool _shown;
- [ComImport, Guid("fec87aaf-35f9-447a-adb7-20234491401a"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
- public interface IPreviewHandlerFrame
- {
- [PreserveSig]
- HRESULT GetWindowContext(out PreviewHandlerFrameInfo pinfo);
- [PreserveSig]
- HRESULT TranslateAccelerator(ref MSG pmsg);
- }
+ // Initializer
- public sealed class PreviewHandlerFrame : IPreviewHandlerFrame, IDisposable
+ /// <summary>
+ /// Initializes an instance of <see cref="PreviewHandler"/> class.
+ /// </summary>
+ /// <param name="clsid"></param>
+ /// <param name="frame"></param>
+ public PreviewHandler(Guid clsid, HWND frame)
{
- bool disposed;
- nint hwnd;
+ _disposed = true;
+ _initialized = false;
+ _shown = false;
+ _hWnd = frame;
- public PreviewHandlerFrame(nint frame)
- {
- disposed = true;
- disposed = false;
- hwnd = frame;
- }
-
- public void Dispose()
- {
- disposed = true;
- }
+ // Initialize preview handler's frame
+ _previewHandlerFrame = new CPreviewHandlerFrame(frame);
- public HRESULT GetWindowContext(out PreviewHandlerFrameInfo pinfo)
- {
- pinfo.AcceleratorTableHandle = IntPtr.Zero;
- pinfo.AcceleratorEntryCount = 0;
- if (disposed)
- return HRESULT.E_FAIL;
- return HRESULT.S_OK;
- }
-
- public HRESULT TranslateAccelerator(ref MSG pmsg)
+ try
{
- if (disposed)
- return HRESULT.E_FAIL;
- return HRESULT.S_FALSE;
- }
- }
+ HRESULT hr = PInvoke.CoCreateInstance(clsid, null, CLSCTX.CLSCTX_LOCAL_SERVER, out IPreviewHandler* pPreviewHandler);
+ if (hr.Value < 0)
+ throw new COMException("Cannot create class " + clsid.ToString() + " as IPreviewHandler.", hr.Value);
+ else if (pPreviewHandler is null)
+ throw new COMException("Cannot create class " + clsid.ToString() + " as IPreviewHandler.");
- #endregion IPreviewHandlerFrame support
+ _pPreviewHandler = pPreviewHandler;
- #region IPreviewHandler major interfaces
+ Debug.WriteLine($"IPreviewHandler was successfully initialized from {clsid:B}.");
- [ComImport, Guid("8895b1c6-b41f-4c1c-a562-0d564250836f"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
- interface IPreviewHandler
- {
- [PreserveSig]
- HRESULT SetWindow(IntPtr hwnd, ref RECT prc);
- [PreserveSig]
- HRESULT SetRect(ref RECT prc);
- [PreserveSig]
- HRESULT DoPreview();
- [PreserveSig]
- HRESULT Unload();
- [PreserveSig]
- HRESULT SetFocus();
- [PreserveSig]
- HRESULT QueryFocus(out IntPtr phwnd);
- // TranslateAccelerator is not used here.
- }
+ // Get IObjectWithSite
+ ComPtr<IObjectWithSite> pObjectWithSite = default;
+ _pPreviewHandler->QueryInterface(typeof(IObjectWithSite).GUID, out *(void**)pObjectWithSite.GetAddressOf());
+ if (pObjectWithSite.IsNull)
+ throw new COMException("Cannot cast class " + clsid.ToString() + " as IObjectWithSite.");
- [ComImport, Guid("196bf9a5-b346-4ef0-aa1e-5dcdb76768b1"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
- interface IPreviewHandlerVisuals
- {
- [PreserveSig]
- HRESULT SetBackgroundColor(uint color);
- [PreserveSig]
- HRESULT SetFont(ref LOGFONT plf);
- [PreserveSig]
- HRESULT SetTextColor(uint color);
- }
+ // Set site
+ var pPreviewHandlerFrame = Marshal.GetIUnknownForObject(_previewHandlerFrame);
+ hr = pObjectWithSite.Get()->SetSite((IUnknown*)pPreviewHandlerFrame);
+ if (hr.Value < 0)
+ throw new COMException("Cannot set site to the preview handler object.", hr.Value);
- static uint ColorRefFromColor(Color color)
- {
- return (((uint)color.B) << 16) | (((uint)color.G) << 8) | ((uint)color.R);
- }
+ Debug.WriteLine($"Site IPreviewHandlerFrame was successfully set to IPreviewHandler.");
- [ComImport, Guid("fc4801a3-2ba9-11cf-a229-00aa003d7352"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
- interface IObjectWithSite
- {
- [PreserveSig]
- HRESULT SetSite([In, MarshalAs(UnmanagedType.IUnknown)] object pUnkSite);
- // GetSite is not used.
- }
+ // Get IPreviewHandlerVisuals
+ IPreviewHandlerVisuals* previewHandlerVisuals = default;
+ _pPreviewHandler->QueryInterface(typeof(IPreviewHandlerVisuals).GUID, out *(void**)&previewHandlerVisuals);
+ if (previewHandlerVisuals == null)
+ throw new COMException("Cannot cast class " + clsid.ToString() + " as IPreviewHandlerVisuals.");
- #endregion IPreviewHandler major interfaces
+ _previewHandlerVisuals = previewHandlerVisuals;
- bool disposed;
- bool init;
- bool shown;
- PreviewHandlerFrame comSite;
- nint hwnd;
- IPreviewHandler previewHandler;
- IPreviewHandlerVisuals visuals;
- IntPtr pPreviewHandler;
+ Debug.WriteLine($"IPreviewHandlerVisuals was successfully queried from IPreviewHandler.");
- public PreviewHandler(Guid clsid, nint frame)
- {
- disposed = true;
- init = false;
- shown = false;
- comSite = new PreviewHandlerFrame(frame);
- hwnd = frame;
- try
- {
- SetupHandler(clsid);
- disposed = false;
+ _disposed = false;
}
catch
{
- if (previewHandler != null)
- Marshal.ReleaseComObject(previewHandler);
- previewHandler = null;
- if (pPreviewHandler != IntPtr.Zero)
- Marshal.Release(pPreviewHandler);
- pPreviewHandler = IntPtr.Zero;
- comSite.Dispose();
- comSite = null;
- throw;
- }
- }
-
- static readonly Guid IPreviewHandlerIid = Guid.ParseExact("8895b1c6-b41f-4c1c-a562-0d564250836f", "d");
+ if (_pPreviewHandler is not null)
+ {
+ _pPreviewHandler->Release();
+ _pPreviewHandler = null;
+ }
- void SetupHandler(Guid clsid)
- {
- IntPtr pph;
- var iid = IPreviewHandlerIid;
- var cannotCreate = "Cannot create class " + clsid.ToString() + " as IPreviewHandler.";
- var cannotCast = "Cannot cast class " + clsid.ToString() + " as IObjectWithSite.";
- var cannotSetSite = "Cannot set site to the preview handler object.";
- // Important: manully calling CoCreateInstance is necessary.
- // If we use Activator.CreateInstance(Type.GetTypeFromCLSID(...)),
- // CLR will allow in-process server, which defeats isolation and
- // creates strange bugs.
- HRESULT hr = Win32PInvoke.CoCreateInstance(ref clsid, IntPtr.Zero, Win32PInvoke.ClassContext.LocalServer, ref iid, out pph);
- // See https://blogs.msdn.microsoft.com/adioltean/2005/06/24/when-cocreateinstance-returns-0x80080005-co_e_server_exec_failure/
- // CO_E_SERVER_EXEC_FAILURE also tends to happen when debugging in Visual Studio.
- // Moreover, to create the instance in a server at low integrity level, we need
- // to use another thread with low mandatory label. We keep it simple by creating
- // a same-integrity object.
- //if (hr == HRESULT.CO_E_SERVER_EXEC_FAILURE)
- // hr = CoCreateInstance(ref clsid, IntPtr.Zero, ClassContext.LocalServer, ref iid, out pph);
- if ((int)hr < 0)
- throw new COMException(cannotCreate, (int)hr);
- pPreviewHandler = pph;
- var previewHandlerObject = Marshal.GetUniqueObjectForIUnknown(pph);
- previewHandler = previewHandlerObject as IPreviewHandler;
- if (previewHandler == null)
- {
- Marshal.ReleaseComObject(previewHandlerObject);
- throw new COMException(cannotCreate);
+ throw;
}
- var objectWithSite = previewHandlerObject as IObjectWithSite;
- if (objectWithSite == null)
- throw new COMException(cannotCast);
- hr = objectWithSite.SetSite(comSite);
- if ((int)hr < 0)
- throw new COMException(cannotSetSite, (int)hr);
- visuals = previewHandlerObject as IPreviewHandlerVisuals;
- }
-
- #region Initialization interfaces
-
- [ComImport, Guid("b824b49d-22ac-4161-ac8a-9916e8fa3f7f"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
- interface IInitializeWithStream
- {
- [PreserveSig]
- HRESULT Initialize(IStream psi, STGM grfMode);
}
- [ComImport, Guid("b824b49d-22ac-4161-ac8a-9916e8fa3f7f"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
- interface IInitializeWithStreamNative
- {
- [PreserveSig]
- HRESULT Initialize(IntPtr psi, STGM grfMode);
- }
-
- static readonly Guid IInitializeWithStreamIid = Guid.ParseExact("b824b49d-22ac-4161-ac8a-9916e8fa3f7f", "d");
+ // Methods
- [ComImport, Guid("b7d14566-0509-4cce-a71f-0a554233bd9b"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
- interface IInitializeWithFile
+ /// <summary>
+ /// Initializes the preview handler with file.
+ /// </summary>
+ /// <param name="path">The file name to use to initialize the preview handler.</param>
+ /// <returns>True If succeeded, otherwise, false.</returns>
+ public bool Initialize(string path)
{
- [PreserveSig]
- HRESULT Initialize([MarshalAs(UnmanagedType.LPWStr)] string pszFilePath, STGM grfMode);
- }
+ List<Exception> exceptions = [];
- static readonly Guid IInitializeWithFileIid = Guid.ParseExact("b7d14566-0509-4cce-a71f-0a554233bd9b", "d");
+ // We try IStream first because this gives us the best security.
+ // If we initialize with string or IShellItem, we have no control over
+ // how the preview handler opens the file, which might decide to open the file for read/write exclusively.
+ try
+ {
+ using ComPtr<IStream> pStream = default;
+ HRESULT hr = PInvoke.SHCreateStreamOnFileEx(path, (uint)(STGM.STGM_READ | STGM.STGM_FAILIFTHERE | STGM.STGM_SHARE_DENY_NONE), 0, false, null, pStream.GetAddressOf());
+ if (hr.Value < 0)
+ throw new InvalidComObjectException($"SHCreateItemFromParsingName failed to get IShellItem for preview handling with the error {hr.Value:X}.");
- [ComImport, Guid("7f73be3f-fb79-493c-a6c7-7ee14e245841"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
- interface IInitializeWithItem
- {
- [PreserveSig]
- HRESULT Initialize(IntPtr psi, STGM grfMode);
- }
+ if (!pStream.IsNull)
+ {
+ ObjectDisposedException.ThrowIf(_disposed, this);
- static readonly Guid IInitializeWithItemIid = Guid.ParseExact("7f73be3f-fb79-493c-a6c7-7ee14e245841", "d");
+ if (_initialized)
+ throw new InvalidOperationException("Preview handler is already initialized and cannot be initialized again.");
- #endregion
+ using ComPtr<IInitializeWithStream> pInitializeWithStream = default;
+ _pPreviewHandler->QueryInterface(typeof(IInitializeWithStream).GUID, out *(void**)pInitializeWithStream.GetAddressOf());
+ if (pInitializeWithStream.IsNull)
+ throw new COMException($"{nameof(IInitializeWithStream)} could not queried from IPreviewHandler.");
- /// <summary>
- /// Tries to initialize the preview handler with an IStream.
- /// </summary>
- /// <exception cref="COMException">This exception is thrown if IInitializeWithStream.Initialize fails for reason other than E_NOTIMPL.</exception>
- /// <exception cref="ArgumentOutOfRangeException">Thrown if mode is neither Read nor ReadWrite.</exception>
- /// <param name="stream">The IStream interface used to initialize the preview handler.</param>
- /// <param name="mode">The storage mode, must be Read or ReadWrite.</param>
- /// <returns>If the handler supports initialization with IStream, true; otherwise, false.</returns>
- public bool InitWithStream(IStream stream, STGM mode)
- {
- if (mode != STGM.STGM_READ && mode != STGM.STGM_READWRITE)
- throw new ArgumentOutOfRangeException("mode", mode, "The argument mode must be Read or ReadWrite.");
- var iws = previewHandler as IInitializeWithStream;
- if (iws == null)
- return false;
- var hr = iws.Initialize(stream, mode);
- if (hr == HRESULT.E_NOTIMPL)
- return false;
- if ((int)hr < 0)
- throw new COMException("IInitializeWithStream.Initialize failed.", (int)hr);
- init = true;
- return true;
- }
+ hr = pInitializeWithStream.Get()->Initialize(pStream.Get(), (uint)STGM.STGM_READ);
+ if (hr == HRESULT.E_NOTIMPL)
+ throw new NotImplementedException($"{nameof(IInitializeWithStream)}.Initialize() is not implemented.");
+ else if ((int)hr < 0)
+ throw new COMException($"{nameof(IInitializeWithStream)}.Initialize() failed.", (int)hr);
- /// <summary>
- /// Same as InitWithStream(IStream, STGM).
- /// </summary>
- /// <exception cref="COMException">See InitWithStream(IStream, STGM).</exception>
- /// <exception cref="ArgumentOutOfRangeException">See InitWithStream(IStream, STGM).</exception>
- /// <param name="pStream">The native pointer to the IStream interface.</param>
- /// <param name="mode">The storage mode.</param>
- /// <returns>True or false, see InitWithStream(IStream, STGM).</returns>
- public bool InitWithStream(IntPtr pStream, STGM mode)
- {
- EnsureNotDisposed();
- EnsureNotInitialized();
- if (mode != STGM.STGM_READ && mode != STGM.STGM_READWRITE)
- throw new ArgumentOutOfRangeException("mode", mode, "The argument mode must be Read or ReadWrite.");
- var iws = previewHandler as IInitializeWithStreamNative;
- if (iws == null)
- return false;
- var hr = iws.Initialize(pStream, mode);
- if (hr == HRESULT.E_NOTIMPL)
- return false;
- if ((int)hr < 0)
- throw new COMException("IInitializeWithStream.Initialize failed.", (int)hr);
- init = true;
- return true;
- }
-
- /// <summary>
- /// Same as InitWithStream(IStream, STGM).
- /// </summary>
- /// <exception cref="COMException">See InitWithStream(IStream, STGM).</exception>
- /// <exception cref="ArgumentOutOfRangeException">See InitWithStream(IStream, STGM).</exception>
- /// <param name="psi">The native pointer to the IShellItem interface.</param>
- /// <param name="mode">The storage mode.</param>
- /// <returns>True or false, see InitWithStream(IStream, STGM).</returns>
- public bool InitWithItem(IntPtr psi, STGM mode)
- {
- EnsureNotDisposed();
- EnsureNotInitialized();
- if (mode != STGM.STGM_READ && mode != STGM.STGM_READWRITE)
- throw new ArgumentOutOfRangeException("mode", mode, "The argument mode must be Read or ReadWrite.");
- var iwi = previewHandler as IInitializeWithItem;
- if (iwi == null)
- return false;
- var hr = iwi.Initialize(psi, mode);
- if (hr == HRESULT.E_NOTIMPL)
- return false;
- if ((int)hr < 0)
- throw new COMException("IInitializeWithItem.Initialize failed.", (int)hr);
- init = true;
- return true;
- }
+ _initialized = true;
- /// <summary>
- /// Same as InitWithStream(IStream, STGM).
- /// </summary>
- /// <exception cref="COMException">See InitWithStream(IStream, STGM).</exception>
- /// <exception cref="ArgumentOutOfRangeException">See InitWithStream(IStream, STGM).</exception>
- /// <param name="path">The path to the file.</param>
- /// <param name="mode">The storage mode.</param>
- /// <returns>True or false, see InitWithStream(IStream, STGM).</returns>
- public bool InitWithFile(string path, STGM mode)
- {
- EnsureNotDisposed();
- EnsureNotInitialized();
- if (mode != STGM.STGM_READ && mode != STGM.STGM_READWRITE)
- throw new ArgumentOutOfRangeException("mode", mode, "The argument mode must be Read or ReadWrite.");
- var iwf = previewHandler as IInitializeWithFile;
- if (iwf == null)
- return false;
- var hr = iwf.Initialize(path, mode);
- if (hr == HRESULT.E_NOTIMPL)
- return false;
- if ((int)hr < 0)
- throw new COMException("IInitializeWithFile.Initialize failed.", (int)hr);
- init = true;
- return true;
- }
+ Debug.WriteLine($"Preview handler was successfully initialized with {nameof(IInitializeWithStream)}.");
- /// <summary>
- /// Tries each way to initialize the object with a file.
- /// </summary>
- /// <param name="path">The file name.</param>
- /// <returns>If initialization was successful, true; otherwise, an exception is thrown.</returns>
- public bool InitWithFileWithEveryWay(string path)
- {
- var exceptions = new List<Exception>();
- var pobj = IntPtr.Zero;
- // Why should we try IStream first?
- // Because that gives us the best security.
- // If we initialize with string or IShellItem,
- // we have no control over how the preview handler
- // opens the file, which might decide to open the
- // file for read/write exclusively.
- try
- {
- pobj = ItemStreamHelper.IStreamFromPath(path);
- if (pobj != IntPtr.Zero
- && InitWithStream(pobj, STGM.STGM_READ))
return true;
+ }
}
catch (Exception ex)
{
exceptions.Add(ex);
}
- finally
- {
- if (pobj != IntPtr.Zero)
- ItemStreamHelper.ReleaseObject(pobj);
- pobj = IntPtr.Zero;
- }
- // Next try file because that could save us some P/Invokes.
+
try
{
- if (InitWithFile(path, STGM.STGM_READ))
- return true;
+ ObjectDisposedException.ThrowIf(_disposed, this);
+
+ if (_initialized)
+ throw new InvalidOperationException("Preview handler is already initialized and cannot be initialized again.");
+
+ using ComPtr<IInitializeWithFile> pInitializeWithFile = default;
+ _pPreviewHandler->QueryInterface(typeof(IInitializeWithFile).GUID, out *(void**)pInitializeWithFile.GetAddressOf());
+ if (pInitializeWithFile.IsNull)
+ throw new COMException($"{nameof(IInitializeWithFile)} could not queried from IPreviewHandler.");
+
+ HRESULT hr = pInitializeWithFile.Get()->Initialize(path, (uint)STGM.STGM_READ);
+ if (hr == HRESULT.E_NOTIMPL)
+ throw new NotImplementedException($"{nameof(IInitializeWithFile)}.Initialize() is not implemented.");
+ else if ((int)hr < 0)
+ throw new COMException($"{nameof(IInitializeWithFile)}.Initialize() failed.", (int)hr);
+
+ _initialized = true;
+
+ Debug.WriteLine($"Preview handler was successfully initialized with {nameof(IInitializeWithFile)}.");
+
+ return true;
}
catch (Exception ex)
{
exceptions.Add(ex);
}
+
try
{
- pobj = ItemStreamHelper.IShellItemFromPath(path);
- if (pobj != IntPtr.Zero
- && InitWithItem(pobj, STGM.STGM_READ))
+ using ComPtr<IShellItem> pShellItem = default;
+ HRESULT hr = PInvoke.SHCreateItemFromParsingName(path, null, typeof(IShellItem).GUID, out *(void**)&pShellItem);
+ if (hr.Value < 0)
+ throw new InvalidComObjectException($"SHCreateItemFromParsingName failed to get IShellItem for preview handling with the error {hr.Value:X}.");
+
+ if (!pShellItem.IsNull)
+ {
+ ObjectDisposedException.ThrowIf(_disposed, this);
+
+ if (_initialized)
+ throw new InvalidOperationException("Preview handler is already initialized and cannot be initialized again.");
+
+ using ComPtr<IInitializeWithItem> pInitializeWithItem = default;
+ _pPreviewHandler->QueryInterface(typeof(IInitializeWithItem).GUID, out *(void**)pInitializeWithItem.GetAddressOf());
+ if (pInitializeWithItem.IsNull)
+ throw new COMException($"{nameof(IInitializeWithItem)} could not queried from IPreviewHandler.");
+
+ hr = pInitializeWithItem.Get()->Initialize(pShellItem.Get(), (uint)STGM.STGM_READ);
+ if (hr == HRESULT.E_NOTIMPL)
+ throw new NotImplementedException($"{nameof(IInitializeWithItem)}.Initialize() is not implemented.");
+ else if ((int)hr < 0)
+ throw new COMException($"{nameof(IInitializeWithItem)}.Initialize() failed.", (int)hr);
+
+ _initialized = true;
+
+ Debug.WriteLine($"Preview handler was successfully initialized with {nameof(IInitializeWithItem)}.");
+
return true;
- if (exceptions.Count == 0)
- throw new NotSupportedException("The object cannot be initialized at all.");
+ }
+
+ if (exceptions.Count is 0)
+ throw new NotSupportedException("Preview handler could not be initialized at all.");
}
catch (Exception ex)
{
exceptions.Add(ex);
}
- finally
- {
- if (pobj != IntPtr.Zero)
- ItemStreamHelper.ReleaseObject(pobj);
- pobj = IntPtr.Zero;
- }
+
+ Debug.WriteLine($"Preview handler could not be initialized at all.");
+
throw new AggregateException(exceptions);
}
+ /// <summary>
+ /// Loads the preview data and renders the preview.
+ /// </summary>
+ public void DoPreview()
+ {
+ ObjectDisposedException.ThrowIf(_disposed, this);
+
+ if (!_initialized)
+ // throw new InvalidOperationException("Object must be initialized before calling this method.");
+ return;
+
+ if (_shown)
+ throw new InvalidOperationException("The preview handler must not be shown to call this method.");
+
+ bool res = ResetWindow();
+
+ Debug.WriteLine($"Window of the preview handler" + (res ? "was successfully reset." : "failed to be reset."));
+
+ _pPreviewHandler->DoPreview();
+
+ _shown = true;
+
+ Debug.WriteLine($"IPreviewHandler.DoPreview was successfully done.");
+ }
+
+ /// <summary>
+ /// Unloads the preview handler and disposes this instance.
+ /// </summary>
+ public void UnloadPreview()
+ {
+ Dispose(true);
+ }
+
/// <summary>
/// Calls IPreviewHandler.SetWindow.
/// </summary>
public bool ResetWindow()
{
- EnsureNotDisposed();
- //EnsureInitialized();
- if (!init)
+ ObjectDisposedException.ThrowIf(_disposed, this);
+
+ if (!_initialized)
+ // throw new InvalidOperationException("Object must be initialized before calling this method.");
return false;
- var hr = previewHandler.SetWindow(hwnd, new());
- return (int)hr >= 0;
+
+ HRESULT hr = _pPreviewHandler->SetWindow(_hWnd, new RECT());
+ return hr.Value >= 0;
}
/// <summary>
@@ -409,11 +278,15 @@ public bool ResetWindow()
/// </summary>
public bool ResetBounds(RECT previewerBounds)
{
- EnsureNotDisposed();
- //EnsureInitialized();
- if (!init)
+ ObjectDisposedException.ThrowIf(_disposed, this);
+
+ //if (!_initialized)
+ // throw new InvalidOperationException("Object must be initialized before calling this method.");
+
+ if (!_initialized)
return false;
- var hr = previewHandler.SetRect(previewerBounds);
+
+ HRESULT hr = _pPreviewHandler->SetRect(previewerBounds);
return (int)hr >= 0;
}
@@ -424,8 +297,8 @@ public bool ResetBounds(RECT previewerBounds)
/// <returns>Whether the call succeeds.</returns>
public bool SetBackground(Color color)
{
- var hr = visuals?.SetBackgroundColor(ColorRefFromColor(color));
- return hr.HasValue && (int)hr.Value >= 0;
+ HRESULT hr = _previewHandlerVisuals->SetBackgroundColor(new(ConvertColorToColorRef(color)));
+ return hr.Value >= 0;
}
/// <summary>
@@ -435,8 +308,8 @@ public bool SetBackground(Color color)
/// <returns>Whether the call succeeds.</returns>
public bool SetForeground(Color color)
{
- var hr = visuals?.SetTextColor(ColorRefFromColor(color));
- return hr.HasValue && (int)hr.Value >= 0;
+ HRESULT hr = _previewHandlerVisuals->SetTextColor(new(ConvertColorToColorRef(color)));
+ return hr.Value >= 0;
}
/// <summary>
@@ -444,25 +317,10 @@ public bool SetForeground(Color color)
/// </summary>
/// <param name="font">The LogFontW reference.</param>
/// <returns>Whether the call succeeds.</returns>
- public bool SetFont(ref LOGFONT font)
+ public bool SetFont(ref LOGFONTW font)
{
- var hr = visuals?.SetFont(ref font);
- return hr.HasValue && (int)hr.Value >= 0;
- }
-
- /// <summary>
- /// Shows the preview if the object has been successfully initialized.
- /// </summary>
- public void DoPreview()
- {
- EnsureNotDisposed();
- //EnsureInitialized();
- if (!init)
- return;
- EnsureNotShown();
- ResetWindow();
- previewHandler.DoPreview();
- shown = true;
+ HRESULT hr = _previewHandlerVisuals->SetFont(font);
+ return hr.Value >= 0;
}
/// <summary>
@@ -470,110 +328,125 @@ public void DoPreview()
/// </summary>
public void Focus()
{
- EnsureNotDisposed();
- //EnsureInitialized();
- if (!init)
+ ObjectDisposedException.ThrowIf(_disposed, this);
+
+ if (!_initialized)
+ // throw new InvalidOperationException("Object must be initialized before calling this method.");
return;
- EnsureShown();
- previewHandler.SetFocus();
+
+ if (!_shown)
+ throw new InvalidOperationException("The preview handler must be shown to call this method.");
+
+ _pPreviewHandler->SetFocus();
}
/// <summary>
/// Tells the preview handler to query focus.
/// </summary>
/// <returns>The focused window.</returns>
- public IntPtr QueryFocus()
+ public nint QueryFocus()
{
- EnsureNotDisposed();
- //EnsureInitialized();
- if (!init)
- return IntPtr.Zero;
- EnsureShown();
- IntPtr result;
- var hr = previewHandler.QueryFocus(out result);
- if ((int)hr < 0)
- return IntPtr.Zero;
- return result;
- }
+ ObjectDisposedException.ThrowIf(_disposed, this);
- /// <summary>
- /// Unloads the preview and disposes the object. This method is idempotent.
- /// </summary>
- public void UnloadPreview()
- {
- Dispose(true);
- }
+ if (!_initialized)
+ // throw new InvalidOperationException("Object must be initialized before calling this method.");
+ return nint.Zero;
- void EnsureNotDisposed()
- {
- if (disposed)
- throw new ObjectDisposedException("PreviewHandler");
- }
+ if (!_shown)
+ throw new InvalidOperationException("The preview handler must be shown to call this method.");
- void EnsureInitialized()
- {
- if (!init)
- throw new InvalidOperationException("Object must be initialized before calling this method.");
+ HRESULT hr = _pPreviewHandler->QueryFocus(out HWND hWnd);
+ if (hr.Value < 0)
+ return nint.Zero;
+
+ return hWnd.Value;
}
- void EnsureNotInitialized()
+ private uint ConvertColorToColorRef(Color color)
{
- if (init)
- throw new InvalidOperationException("Object is already initialized and cannot be initialized again.");
+ return (((uint)color.B) << 16) | (((uint)color.G) << 8) | ((uint)color.R);
}
- void EnsureShown()
+ // Disposers
+
+ ~PreviewHandler()
{
- if (!shown)
- throw new InvalidOperationException("The preview handler must be shown to call this method.");
+ Dispose(false);
}
- void EnsureNotShown()
+ void IDisposable.Dispose()
{
- if (shown)
- throw new InvalidOperationException("The preview handler must not be shown to call this method.");
+ Dispose(true);
+ GC.SuppressFinalize(this);
}
- #region IDisposable pattern
-
void Dispose(bool disposing)
{
- if (disposed)
+ if (_disposed)
return;
- disposed = true;
- init = false;
+
+ _disposed = true;
+ _initialized = false;
+
if (disposing)
{
- previewHandler.Unload();
- comSite.Dispose();
- Marshal.ReleaseComObject(previewHandler);
+ _pPreviewHandler->Unload();
+ _pPreviewHandler->Release();
}
else
{
// We're in the finalizer.
// Field previewHandler might have been finalized at this point.
// Get a new RCW.
- var phObject = Marshal.GetUniqueObjectForIUnknown(pPreviewHandler);
- var ph = phObject as IPreviewHandler;
- if (ph != null)
- ph.Unload();
- Marshal.ReleaseComObject(phObject);
+
+ //var phObject = Marshal.GetUniqueObjectForIUnknown(_pPreviewHandler);
+ //var ph = phObject as IPreviewHandler;
+ //if (ph != null)
+ // ph.Unload();
+
+ //Marshal.ReleaseComObject(phObject);
}
- Marshal.Release(pPreviewHandler);
- }
- ~PreviewHandler()
- {
- Dispose(false);
+ _pPreviewHandler->Release();
+
+ Debug.WriteLine($"Preview handler was successfully disposed.");
}
- void IDisposable.Dispose()
+ // Private class
+
+ private unsafe class CPreviewHandlerFrame : IPreviewHandlerFrame.Interface
{
- Dispose(true);
- GC.SuppressFinalize(this);
- }
+ private bool _disposed = false;
+ private readonly HWND _hWnd = default;
+
+ public CPreviewHandlerFrame(HWND frame)
+ {
+ _hWnd = frame;
+ }
+
+ public void Dispose()
+ {
+ _disposed = true;
+ }
+
+ public HRESULT GetWindowContext(PREVIEWHANDLERFRAMEINFO* pInfo)
+ {
+ pInfo->haccel = HACCEL.Null;
+ pInfo->cAccelEntries = 0u;
+
+ if (_disposed)
+ return HRESULT.E_FAIL; // Disposed already
+
+ return HRESULT.S_OK;
+ }
- #endregion
+ public HRESULT TranslateAccelerator(MSG* pMsg)
+ {
+ if (_disposed)
+ return HRESULT.E_FAIL; // Disposed already
+ return HRESULT.S_FALSE;
+ }
+ }
}
}
diff --git a/src/Files.App/ViewModels/UserControls/Previews/ShellPreviewViewModel.cs b/src/Files.App/ViewModels/UserControls/Previews/ShellPreviewViewModel.cs
index 1dd27cb8ad03..46cc16c22a8e 100644
--- a/src/Files.App/ViewModels/UserControls/Previews/ShellPreviewViewModel.cs
+++ b/src/Files.App/ViewModels/UserControls/Previews/ShellPreviewViewModel.cs
@@ -6,18 +6,17 @@
using Microsoft.UI.Xaml;
using Microsoft.UI.Xaml.Hosting;
using System.Runtime.InteropServices;
-using System.Text;
-using Vanara.PInvoke;
using Windows.Win32;
-using Windows.Win32.System.Com;
+using Windows.Win32.Foundation;
using Windows.Win32.Graphics.Direct3D;
using Windows.Win32.Graphics.Direct3D11;
using Windows.Win32.Graphics.DirectComposition;
using Windows.Win32.Graphics.Dwm;
using Windows.Win32.Graphics.Dxgi;
+using Windows.Win32.System.Com;
+using Windows.Win32.UI.Shell;
+using Windows.Win32.UI.WindowsAndMessaging;
using WinRT;
-using static Vanara.PInvoke.ShlwApi;
-using static Vanara.PInvoke.User32;
#pragma warning disable CS8305 // Type is for evaluation purposes only and is subject to change or removal in future updates.
@@ -25,75 +24,74 @@ namespace Files.App.ViewModels.Previews
{
public sealed class ShellPreviewViewModel : BasePreviewModel
{
- private const string IPreviewHandlerIid = "{8895b1c6-b41f-4c1c-a562-0d564250836f}";
- private static readonly Guid QueryAssociationsClsid = new Guid(0xa07034fd, 0x6caa, 0x4954, 0xac, 0x3f, 0x97, 0xa2, 0x72, 0x16, 0xf9, 0x8a);
- private static readonly Guid IQueryAssociationsIid = Guid.ParseExact("c46ca590-3c3f-11d2-bee6-0000f805ca57", "d");
+ // Fields
+
+ PreviewHandler? _currentPreviewHandler;
+ ContentExternalOutputLink? _contentExternalOutputLink;
+ WNDCLASSEXW _windowClass;
+ WNDPROC _windProc = null!;
+ HWND _hWnd = HWND.Null;
+ bool _isOfficePreview = false;
- PreviewHandler? currentHandler;
- ContentExternalOutputLink? outputLink;
- WindowClass? wCls;
- HWND hwnd = HWND.NULL;
- bool isOfficePreview = false;
+ // Initializer
public ShellPreviewViewModel(ListedItem item) : base(item)
{
}
+ // Methods
+
public async override Task<List<FileProperty>> LoadPreviewAndDetailsAsync()
=> [];
- public static Guid? FindPreviewHandlerFor(string extension, nint hwnd)
+ public static unsafe Guid? FindPreviewHandlerFor(string extension, nint hwnd)
{
if (string.IsNullOrEmpty(extension))
return null;
- var hr = AssocCreate(QueryAssociationsClsid, IQueryAssociationsIid, out var queryAssoc);
- if (!hr.Succeeded)
- return null;
-
try
{
- if (queryAssoc == null)
- return null;
-
- queryAssoc.Init(ASSOCF.ASSOCF_INIT_DEFAULTTOSTAR, extension, nint.Zero, hwnd);
-
- var sb = new StringBuilder(128);
- uint cch = 64;
-
- queryAssoc.GetString(ASSOCF.ASSOCF_NOTRUNCATE, ASSOCSTR.ASSOCSTR_SHELLEXTENSION, IPreviewHandlerIid, sb, ref cch);
-
- Debug.WriteLine($"Preview handler for {extension}: {sb}");
- return Guid.Parse(sb.ToString());
+ fixed (char* pszOutput = new char[1024])
+ {
+ PWSTR pwszOutput = new(pszOutput);
+ uint cchOutput = 512u;
+
+ // Try to find registered preview handler associated with specified extension name
+ var res = PInvoke.AssocQueryString(
+ ASSOCF.ASSOCF_NOTRUNCATE,
+ ASSOCSTR.ASSOCSTR_SHELLEXTENSION,
+ extension,
+ "{8895b1c6-b41f-4c1c-a562-0d564250836f}",
+ pszOutput,
+ ref cchOutput);
+
+ return Guid.Parse(pwszOutput.ToString());
+ }
}
catch
{
return null;
}
- finally
- {
- Marshal.ReleaseComObject(queryAssoc);
- }
}
public void SizeChanged(RECT size)
{
- if (hwnd != HWND.NULL)
- SetWindowPos(hwnd, HWND.HWND_TOP, size.Left, size.Top, size.Width, size.Height, SetWindowPosFlags.SWP_NOACTIVATE);
+ if (_hWnd != HWND.Null)
+ PInvoke.SetWindowPos(_hWnd, (HWND)0, size.left, size.top, size.Width, size.Height, SET_WINDOW_POS_FLAGS.SWP_NOACTIVATE);
- currentHandler?.ResetBounds(new(0, 0, size.Width, size.Height));
+ _currentPreviewHandler?.ResetBounds(new(0, 0, size.Width, size.Height));
- if (outputLink is not null)
- outputLink.PlacementVisual.Size = new(size.Width, size.Height);
+ if (_contentExternalOutputLink is not null)
+ _contentExternalOutputLink.PlacementVisual.Size = new(size.Width, size.Height);
}
- private nint WndProc(HWND hwnd, uint msg, nint wParam, nint lParam)
+ private unsafe LRESULT WndProc(HWND hwnd, uint msg, WPARAM wParam, LPARAM lParam)
{
- if (msg == (uint)WindowMessage.WM_CREATE)
+ if (msg == 0x0001 /*WM_CREATE*/)
{
- var clsid = FindPreviewHandlerFor(Item.FileExtension, hwnd.DangerousGetHandle());
+ var clsid = FindPreviewHandlerFor(Item.FileExtension, hwnd);
- isOfficePreview = new Guid?[]
+ _isOfficePreview = new Guid?[]
{
Guid.Parse("84F66100-FF7C-4fb4-B0C0-02CD7FB668FE"), // preview handler for Word files
Guid.Parse("65235197-874B-4A07-BDC5-E65EA825B718"), // preview handler for PowerPoint files
@@ -102,43 +100,71 @@ private nint WndProc(HWND hwnd, uint msg, nint wParam, nint lParam)
try
{
- currentHandler = new PreviewHandler(clsid.Value, hwnd.DangerousGetHandle());
- currentHandler.InitWithFileWithEveryWay(Item.ItemPath);
- currentHandler.DoPreview();
+ _currentPreviewHandler = new PreviewHandler(clsid.Value, hwnd);
+ _currentPreviewHandler.Initialize(Item.ItemPath);
+ _currentPreviewHandler.DoPreview();
}
catch
{
UnloadPreview();
}
}
- else if (msg == (uint)WindowMessage.WM_DESTROY)
+ else if (msg == 0x0002 /*WM_DESTROY*/)
{
- if (currentHandler is not null)
+ if (_currentPreviewHandler is not null)
{
- currentHandler.UnloadPreview();
- currentHandler = null;
+ _currentPreviewHandler.UnloadPreview();
+ _currentPreviewHandler = null;
}
}
- return DefWindowProc(hwnd, msg, wParam, lParam);
+ return PInvoke.DefWindowProc(hwnd, msg, wParam, lParam);
}
- public void LoadPreview(UIElement presenter)
+ public unsafe void LoadPreview(UIElement presenter)
{
var parent = MainWindow.Instance.WindowHandle;
+ var hInst = PInvoke.GetModuleHandle(default(PWSTR));
+ var szClassName = $"{GetType().Name}-{Guid.NewGuid()}";
+ var szWindowName = $"Preview";
- HINSTANCE hInst = Kernel32.GetModuleHandle();
-
- wCls = new WindowClass($"{GetType().Name}{Guid.NewGuid()}", hInst, WndProc);
+ fixed (char* pszClassName = szClassName)
+ {
+ _windProc = new(WndProc);
+ var pWindProc = Marshal.GetFunctionPointerForDelegate(_windProc);
+ var pfnWndProc = (delegate* unmanaged[Stdcall]<HWND, uint, WPARAM, LPARAM, LRESULT>)pWindProc;
- hwnd = CreateWindowEx(
- WindowStylesEx.WS_EX_LAYERED | WindowStylesEx.WS_EX_COMPOSITED,
- wCls.ClassName,
- "Preview",
- WindowStyles.WS_CHILD | WindowStyles.WS_CLIPSIBLINGS | WindowStyles.WS_VISIBLE,
- 0, 0, 0, 0,
- hWndParent: parent,
- hInstance: hInst);
+ _windowClass = new WNDCLASSEXW()
+ {
+ cbSize = (uint)Marshal.SizeOf(typeof(WNDCLASSEXW)),
+ lpfnWndProc = pfnWndProc,
+ hInstance = hInst,
+ lpszClassName = pszClassName,
+ style = 0,
+ hIcon = default,
+ hIconSm = default,
+ hCursor = default,
+ hbrBackground = default,
+ lpszMenuName = null,
+ cbClsExtra = 0,
+ cbWndExtra = 0,
+ };
+
+ PInvoke.RegisterClassEx(_windowClass);
+
+ fixed (char* pszWindowName = szWindowName)
+ {
+ _hWnd = PInvoke.CreateWindowEx(
+ WINDOW_EX_STYLE.WS_EX_LAYERED | WINDOW_EX_STYLE.WS_EX_COMPOSITED,
+ pszClassName,
+ pszWindowName,
+ WINDOW_STYLE.WS_CHILD | WINDOW_STYLE.WS_CLIPSIBLINGS | WINDOW_STYLE.WS_VISIBLE,
+ 0, 0, 0, 0,
+ new(parent),
+ HMENU.Null,
+ hInst);
+ }
+ }
_ = ChildWindowToXaml(parent, presenter);
}
@@ -184,20 +210,20 @@ private unsafe bool ChildWindowToXaml(nint parent, UIElement presenter)
IUnknown* pControlSurface = default;
pDCompositionDevice->CreateVisual(&pChildVisual);
- pDCompositionDevice->CreateSurfaceFromHwnd(new(hwnd.DangerousGetHandle()), &pControlSurface);
+ pDCompositionDevice->CreateSurfaceFromHwnd(new(_hWnd), &pControlSurface);
pChildVisual->SetContent(pControlSurface);
if (pChildVisual is null || pControlSurface is null)
return false;
var compositor = ElementCompositionPreview.GetElementVisual(presenter).Compositor;
- outputLink = ContentExternalOutputLink.Create(compositor);
+ _contentExternalOutputLink = ContentExternalOutputLink.Create(compositor);
- var target = outputLink.As<IDCompositionTarget.Interface>();
+ var target = _contentExternalOutputLink.As<IDCompositionTarget.Interface>();
target.SetRoot(pChildVisual);
- outputLink.PlacementVisual.Size = new(0, 0);
- outputLink.PlacementVisual.Scale = new(1/(float)presenter.XamlRoot.RasterizationScale);
- ElementCompositionPreview.SetElementChildVisual(presenter, outputLink.PlacementVisual);
+ _contentExternalOutputLink.PlacementVisual.Size = new(0, 0);
+ _contentExternalOutputLink.PlacementVisual.Scale = new(1 / (float)presenter.XamlRoot.RasterizationScale);
+ ElementCompositionPreview.SetElementChildVisual(presenter, _contentExternalOutputLink.PlacementVisual);
pDCompositionDevice->Commit();
@@ -213,25 +239,13 @@ private unsafe bool ChildWindowToXaml(nint parent, UIElement presenter)
return
PInvoke.DwmSetWindowAttribute(
- new((nint)hwnd),
+ new((nint)_hWnd),
DWMWINDOWATTRIBUTE.DWMWA_CLOAK,
&dwAttrib,
(uint)Marshal.SizeOf(dwAttrib))
.Succeeded;
}
- public void UnloadPreview()
- {
- if (hwnd != HWND.NULL)
- DestroyWindow(hwnd);
-
- //outputLink?.Dispose();
- outputLink = null;
-
- if (wCls is not null)
- UnregisterClass(wCls.ClassName, Kernel32.GetModuleHandle());
- }
-
public unsafe void PointerEntered(bool onPreview)
{
if (onPreview)
@@ -239,30 +253,51 @@ public unsafe void PointerEntered(bool onPreview)
var dwAttrib = Convert.ToUInt32(false);
PInvoke.DwmSetWindowAttribute(
- new((nint)hwnd),
+ new((nint)_hWnd),
DWMWINDOWATTRIBUTE.DWMWA_CLOAK,
&dwAttrib,
(uint)Marshal.SizeOf(dwAttrib));
- if (isOfficePreview)
- Win32Helper.SetWindowLong(hwnd, WindowLongFlags.GWL_EXSTYLE, 0);
+ if (_isOfficePreview)
+ PInvoke.SetWindowLong(_hWnd, WINDOW_LONG_PTR_INDEX.GWL_EXSTYLE, 0);
}
else
{
- Win32Helper.SetWindowLong(
- hwnd,
- WindowLongFlags.GWL_EXSTYLE,
- (nint)(WindowStylesEx.WS_EX_LAYERED | WindowStylesEx.WS_EX_COMPOSITED));
+ PInvoke.SetWindowLong(
+ _hWnd,
+ WINDOW_LONG_PTR_INDEX.GWL_EXSTYLE,
+ (int)(WINDOW_EX_STYLE.WS_EX_LAYERED | WINDOW_EX_STYLE.WS_EX_COMPOSITED));
var dwAttrib = Convert.ToUInt32(true);
PInvoke.DwmSetWindowAttribute(
- new((nint)hwnd),
+ new((nint)_hWnd),
DWMWINDOWATTRIBUTE.DWMWA_CLOAK,
&dwAttrib,
(uint)Marshal.SizeOf(dwAttrib));
}
}
+
+ // Disposer
+
+ public void UnloadPreview()
+ {
+ if (_hWnd != HWND.Null)
+ PInvoke.DestroyWindow(_hWnd);
+
+ try
+ {
+ var target = _contentExternalOutputLink.As<IDCompositionTarget.Interface>();
+ Marshal.ReleaseComObject(target);
+ _contentExternalOutputLink?.Dispose();
+ }
+ finally
+ {
+ _contentExternalOutputLink = null;
+ }
+
+ PInvoke.UnregisterClass(_windowClass.lpszClassName, PInvoke.GetModuleHandle(default(PWSTR)));
+ }
}
}