Open items in FIles

Author: 0x5bfa

src/Files.App.CsWin32/ComHeapPtr`1.cs

@@ -7,14 +7,17 @@
 namespace Windows.Win32
 {
 	/// <summary>
-	/// Contains a heap pointer allocated via CoTaskMemAlloc and a set of methods to work with the pointer safely.
+	/// Contains a heap pointer allocated via <see cref="PInvoke.CoTaskMemAlloc"/> and a set of methods to work with the pointer safely.
 	/// </summary>
 	public unsafe struct ComHeapPtr<T> : IDisposable where T : unmanaged
 	{
 		private T* _ptr;
 
-		public bool IsNull
-			=> _ptr == null;
+		public readonly bool IsNull
+		{
+			[MethodImpl(MethodImplOptions.AggressiveInlining)]
+			get => _ptr is null;
+		}
 
 		public ComHeapPtr(T* ptr)
 		{
@@ -33,15 +36,44 @@ public ComHeapPtr(T* ptr)
 			return (T**)Unsafe.AsPointer(ref Unsafe.AsRef(in this));
 		}
 
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		public void Attach(T* ptr)
+		{
+			Dispose();
+			_ptr = ptr;
+		}
+
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		public T* Detach()
+		{
+			T* ptr = _ptr;
+			_ptr = null;
+			return ptr;
+		}
+
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		public bool Allocate(nuint cch)
+		{
+			_ptr = (T*)PInvoke.CoTaskMemAlloc(cch);
+			return _ptr is not null;
+		}
+
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		public bool Reallocate(nuint cch)
+		{
+			T* ptr = (T*)PInvoke.CoTaskMemRealloc(_ptr, cch);
+			if (ptr is null) return false;
+			_ptr = ptr;
+			return true;
+		}
+
 		[MethodImpl(MethodImplOptions.AggressiveInlining)]
 		public void Dispose()
 		{
 			T* ptr = _ptr;
-			if (ptr is not null)
-			{
-				_ptr = null;
-				PInvoke.CoTaskMemFree((void*)ptr);
-			}
+			if (ptr is null) return;
+			_ptr = null;
+			PInvoke.CoTaskMemFree(ptr);
 		}
 	}
 }

src/Files.App.CsWin32/HeapPtr.cs

@@ -0,0 +1,80 @@
+// Copyright (c) Files Community
+// Licensed under the MIT License.
+
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace Windows.Win32
+{
+	/// <summary>
+	/// Contains a heap pointer allocated via <see cref="NativeMemory.Alloc"/> and a set of methods to work with the pointer safely.
+	/// </summary>
+	public unsafe struct HeapPtr<T> : IDisposable where T : unmanaged
+	{
+		private T* _ptr;
+
+		public readonly bool IsNull
+		{
+			[MethodImpl(MethodImplOptions.AggressiveInlining)]
+			get => _ptr is null;
+		}
+
+		public HeapPtr(T* ptr)
+		{
+			_ptr = ptr;
+		}
+
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		public readonly T* Get()
+		{
+			return _ptr;
+		}
+
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		public readonly T** GetAddressOf()
+		{
+			return (T**)Unsafe.AsPointer(ref Unsafe.AsRef(in this));
+		}
+
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		public void Attach(T* ptr)
+		{
+			Dispose();
+			_ptr = ptr;
+		}
+
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		public T* Detach()
+		{
+			T* ptr = _ptr;
+			_ptr = null;
+			return ptr;
+		}
+
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		public bool Allocate(nuint cch)
+		{
+			_ptr = (T*)NativeMemory.Alloc(cch); // malloc()
+			return _ptr is not null;
+		}
+
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		public bool Reallocate(nuint cch)
+		{
+			T* ptr = (T*)PInvoke.CoTaskMemRealloc(_ptr, cch);
+			if (ptr is null) return false;
+			_ptr = ptr;
+			return true;
+		}
+
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		public void Dispose()
+		{
+			T* ptr = _ptr;
+			if (ptr is null) return;
+			_ptr = null;
+			NativeMemory.Free(ptr); // free()
+		}
+	}
+}

src/Files.App.CsWin32/ManualPInvokes.cs

@@ -36,6 +36,13 @@ public static HRESULT InitPropVariantFromString(char* psz, PROPVARIANT* ppropvar
 			return hr;
 		}
 
+		public static HRESULT InitPropVariantFromBoolean(BOOL fVal, PROPVARIANT* ppropvar)
+		{
+			ppropvar->Anonymous.Anonymous.vt = VARENUM.VT_BOOL;
+			ppropvar->Anonymous.Anonymous.Anonymous.boolVal = (VARIANT_BOOL)(bool)fVal;
+			return HRESULT.S_OK;
+		}
+
 		public static void PropVariantInit(PROPVARIANT* pvar)
 		{
 			NativeMemory.Fill(pvar, (uint)(sizeof(PROPVARIANT)), 0);

src/Files.App.CsWin32/NativeMethods.txt

@@ -285,3 +285,6 @@ PropVariantClear
 IExtractIconW
 GIL_FORSHELL
 MAX_PATH
+GetEnvironmentVariable
+CoTaskMemRealloc
+PKEY_AppUserModel_IsDestListSeparator

src/Files.App.Storage/Windows/Helpers/WindowsStorageHelpers.System.cs

@@ -0,0 +1,34 @@
+// Copyright (c) Files Community
+// Licensed under the MIT License.
+
+using System.Runtime.CompilerServices;
+using System.Xml.Linq;
+using Windows.Win32;
+using Windows.Win32.Foundation;
+using static Windows.Win32.ManualMacros;
+
+namespace Files.App.Storage
+{
+	public static partial class WindowsStorableHelpers
+	{
+		public static unsafe string? GetEnvironmentVariable(string name)
+		{
+			using HeapPtr<char> pszBuffer = default;
+			bool fRes = pszBuffer.Allocate(1024U);
+			if (!fRes) return null;
+
+			uint cchBuffer = PInvoke.GetEnvironmentVariable((PCWSTR)Unsafe.AsPointer(ref Unsafe.AsRef(in name.GetPinnableReference())), pszBuffer.Get(), (uint)name.Length + 1);
+			return cchBuffer is 0U ? null : new(pszBuffer.Get());
+		}
+
+		public static unsafe string? ResolveIndirectString(string source)
+		{
+			using HeapPtr<char> pszBuffer = default;
+			bool fRes = pszBuffer.Allocate(1024U);
+			if (!fRes) return null;
+
+			HRESULT hr = PInvoke.SHLoadIndirectString((PCWSTR)Unsafe.AsPointer(ref Unsafe.AsRef(in source.GetPinnableReference())), pszBuffer.Get(), (uint)source.Length + 1, null);
+			return FAILED(hr) ? null : new(pszBuffer.Get());
+		}
+	}
+}