1 files changed, 225 insertions, 0 deletions

diff --git a/src/dtf/WixToolset.Dtf.Resources/Resource.cs b/src/dtf/WixToolset.Dtf.Resources/Resource.cs
new file mode 100644
index 00000000..23b4621f
--- /dev/null
+++ b/src/dtf/WixToolset.Dtf.Resources/Resource.cs
@@ -0,0 +1,225 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolset.Dtf.Resources
+{
+    using System;
+    using System.IO;
+    using System.Text;
+    using System.Reflection;
+    using System.Collections;
+    using System.Globalization;
+    using System.Runtime.InteropServices;
+    using System.Diagnostics.CodeAnalysis;
+
+    /// <summary>
+    /// Represents a Win32 resource which can be loaded from and saved to a PE file.
+    /// </summary>
+    public class Resource
+    {
+        private ResourceType type;
+        private string name;
+        private int locale;
+        private byte[] data;
+
+        /// <summary>
+        /// Creates a new Resource object without any data. The data can be later loaded from a file.
+        /// </summary>
+        /// <param name="type">Type of the resource; may be one of the ResourceType constants or a user-defined type.</param>
+        /// <param name="name">Name of the resource. For a numeric resource identifier, prefix the decimal number with a "#".</param>
+        /// <param name="locale">Locale of the resource</param>
+        public Resource(ResourceType type, string name, int locale)
+            : this(type, name, locale, null)
+        {
+        }
+
+        /// <summary>
+        /// Creates a new Resource object with data. The data can be later saved to a file.
+        /// </summary>
+        /// <param name="type">Type of the resource; may be one of the ResourceType constants or a user-defined type.</param>
+        /// <param name="name">Name of the resource. For a numeric resource identifier, prefix the decimal number with a "#".</param>
+        /// <param name="locale">Locale of the resource</param>
+        /// <param name="data">Raw resource data</param>
+        public Resource(ResourceType type, string name, int locale, byte[] data)
+        {
+            if (name == null)
+            {
+                throw new ArgumentNullException("name");
+            }
+
+            this.type = type;
+            this.name = name;
+            this.locale = locale;
+            this.data = data;
+        }
+
+        /// <summary>
+        /// Gets or sets the type of the resource.  This may be one of the ResourceType constants
+        /// or a user-defined type name.
+        /// </summary>
+        public ResourceType ResourceType
+        {
+            get { return this.type; }
+            set { this.type = value; }
+        }
+
+        /// <summary>
+        /// Gets or sets the name of the resource.  For a numeric resource identifier, the decimal number is prefixed with a "#".
+        /// </summary>
+        public string Name
+        {
+            get
+            {
+                return this.name;
+            }
+
+            set
+            {
+                if (value == null)
+                {
+                    throw new ArgumentNullException("value");
+                }
+
+                this.name = value;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets the locale of the resource.
+        /// </summary>
+        public int Locale
+        {
+            get { return this.locale; }
+            set { this.locale = value; }
+        }
+
+        /// <summary>
+        /// Gets or sets the raw data of the resource.
+        /// </summary>
+        [SuppressMessage("Microsoft.Performance", "CA1819:PropertiesShouldNotReturnArrays")]
+        public virtual byte[] Data
+        {
+            get { return this.data; }
+            set { this.data = value; }
+        }
+
+        /// <summary>
+        /// Loads the resource data from a file.  The file is searched for a resource with matching type, name, and locale.
+        /// </summary>
+        /// <param name="file">Win32 PE file containing the resource</param>
+        public void Load(string file)
+        {
+            IntPtr module = NativeMethods.LoadLibraryEx(file, IntPtr.Zero, NativeMethods.LOAD_LIBRARY_AS_DATAFILE);
+            try
+            {
+                this.Load(module);
+            }
+            finally
+            {
+                NativeMethods.FreeLibrary(module);
+            }
+        }
+
+        internal void Load(IntPtr module)
+        {
+            IntPtr resourceInfo = NativeMethods.FindResourceEx(module, (string) this.ResourceType, this.Name, (ushort) this.Locale);
+            if (resourceInfo != IntPtr.Zero)
+            {
+                uint resourceLength = NativeMethods.SizeofResource(module, resourceInfo);
+                IntPtr resourceData = NativeMethods.LoadResource(module, resourceInfo);
+                IntPtr resourcePtr = NativeMethods.LockResource(resourceData);
+                byte[] resourceBytes = new byte[resourceLength];
+                Marshal.Copy(resourcePtr, resourceBytes, 0, resourceBytes.Length);
+                this.Data = resourceBytes;
+            }
+            else
+            {
+                this.Data = null;
+            }
+        }
+
+        /// <summary>
+        /// Saves the resource to a file.  Any existing resource data with matching type, name, and locale is overwritten.
+        /// </summary>
+        /// <param name="file">Win32 PE file to contain the resource</param>
+        public void Save(string file)
+        {
+            IntPtr updateHandle = IntPtr.Zero;
+            try
+            {
+                updateHandle = NativeMethods.BeginUpdateResource(file, false);
+                this.Save(updateHandle);
+                if (!NativeMethods.EndUpdateResource(updateHandle, false))
+                {
+                    int err = Marshal.GetLastWin32Error();
+                    throw new IOException(String.Format(CultureInfo.InvariantCulture, "Failed to save resource. Error code: {0}", err));
+                }
+                updateHandle = IntPtr.Zero;
+            }
+            finally
+            {
+                if (updateHandle != IntPtr.Zero)
+                {
+                    NativeMethods.EndUpdateResource(updateHandle, true);
+                }
+            }
+        }
+
+        internal void Save(IntPtr updateHandle)
+        {
+            IntPtr dataPtr = IntPtr.Zero;
+            try
+            {
+                int dataLength = 0;
+                if (this.Data != null)
+                {
+                    dataLength = this.Data.Length;
+                    dataPtr = Marshal.AllocHGlobal(dataLength);
+                    Marshal.Copy(this.Data, 0, dataPtr, dataLength);
+                }
+                bool updateSuccess;
+                if (this.Name.StartsWith("#", StringComparison.Ordinal))
+                {
+                    // A numeric-named resource must be saved via the integer version of UpdateResource.
+                    IntPtr intName = new IntPtr(Int32.Parse(this.Name.Substring(1), CultureInfo.InvariantCulture));
+                    updateSuccess = NativeMethods.UpdateResource(updateHandle, new IntPtr(this.ResourceType.IntegerValue), intName, (ushort) this.Locale, dataPtr, (uint) dataLength);
+                }
+                else
+                {
+                    updateSuccess = NativeMethods.UpdateResource(updateHandle, (string) this.ResourceType, this.Name, (ushort) this.Locale, dataPtr, (uint) dataLength);
+                }
+                if (!updateSuccess)
+                {
+                    throw new IOException("Failed to save resource. Error: " + Marshal.GetLastWin32Error());
+                }
+            }
+            finally
+            {
+                if (dataPtr != IntPtr.Zero)
+                {
+                    Marshal.FreeHGlobal(dataPtr);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Tests if type, name, and locale of this Resource object match another Resource object.
+        /// </summary>
+        /// <param name="obj">Resource object to be compared</param>
+        /// <returns>True if the objects represent the same resource; false otherwise.</returns>
+        public override bool Equals(object obj)
+        {
+            Resource res = obj as Resource;
+            if (res == null) return false;
+            return this.ResourceType == res.ResourceType && this.Name == res.Name && this.Locale == res.Locale;
+        }
+
+        /// <summary>
+        /// Gets a hash code for this Resource object.
+        /// </summary>
+        /// <returns>Hash code generated from the resource type, name, and locale.</returns>
+        public override int GetHashCode()
+        {
+            return this.ResourceType.GetHashCode() ^ this.Name.GetHashCode() ^ this.Locale.GetHashCode();
+        }
+    }
+}