Merge Dtf

1 files changed, 231 insertions, 0 deletions

diff --git a/src/dtf/WixToolset.Dtf.Resources/VersionStringTable.cs b/src/dtf/WixToolset.Dtf.Resources/VersionStringTable.cs
new file mode 100644
index 00000000..6aad68c6
--- /dev/null
+++ b/src/dtf/WixToolset.Dtf.Resources/VersionStringTable.cs
@@ -0,0 +1,231 @@
+// 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.Collections.Generic;
+    using System.Globalization;
+    using System.Diagnostics.CodeAnalysis;
+
+    /// <summary>
+    /// Represents a string table of a file version resource.
+    /// </summary>
+    [SuppressMessage("Microsoft.Naming", "CA1710:IdentifiersShouldHaveCorrectSuffix")]
+    public sealed class VersionStringTable : IDictionary<string, string>
+    {
+        private VersionResource parent;
+        private VersionInfo rawStringVersionInfo;
+
+        internal VersionStringTable(VersionResource parent, VersionInfo rawStringVersionInfo)
+        {
+            this.parent = parent;
+            this.rawStringVersionInfo = rawStringVersionInfo;
+        }
+
+        /// <summary>
+        /// Gets the locale (LCID) of the string table.
+        /// </summary>
+        public int Locale
+        {
+            get
+            {
+                return UInt16.Parse(rawStringVersionInfo.Key.Substring(0, 4), NumberStyles.HexNumber, CultureInfo.InvariantCulture);
+            }
+            set
+            {
+                rawStringVersionInfo.Key = ((ushort) value).ToString("x4", CultureInfo.InvariantCulture) + rawStringVersionInfo.Key.Substring(4, 4);
+                this.parent.dirty = true;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets a string value.
+        /// </summary>
+        /// <param name="key">Name of the string.</param>
+        public string this[string key]
+        {
+            get
+            {
+                VersionInfo verValue = this.rawStringVersionInfo[key];
+                if (verValue == null)
+                {
+                    return null;
+                }
+                else
+                {
+                    return Encoding.Unicode.GetString(verValue.Data, 0, verValue.Data.Length - 2);
+                }
+            }
+            set
+            {
+                if (value == null)
+                {
+                    rawStringVersionInfo.Remove(key);
+                }
+                else
+                {
+                    VersionInfo verValue = rawStringVersionInfo[key];
+                    if (verValue == null)
+                    {
+                        verValue = new VersionInfo(key);
+                        verValue.IsString = true;
+                        rawStringVersionInfo.Add(verValue);
+                    }
+                    verValue.Data = new byte[Encoding.Unicode.GetByteCount(value) + 2];
+                    Encoding.Unicode.GetBytes(value, 0, value.Length, verValue.Data, 0);
+                }
+                this.parent.dirty = true;
+            }
+        }
+
+        bool ICollection<KeyValuePair<string, string>>.IsReadOnly
+        {
+            get
+            {
+                return false;
+            }
+        }
+
+        bool IDictionary<string, string>.TryGetValue(string key, out string value)
+        {
+            value = this[key];
+            return value != null;
+        }
+
+
+        void ICollection<KeyValuePair<string, string>>.Add(KeyValuePair<string, string> item)
+        {
+            this[item.Key] = item.Value;
+        }
+
+        bool ICollection<KeyValuePair<string, string>>.Remove(KeyValuePair<string, string> item)
+        {
+            string value = this[item.Key];
+            if (value == item.Value)
+            {
+                this[item.Key] = null;
+                return true;
+            }
+            else
+            {
+                return false;
+            }
+        }
+
+        bool ICollection<KeyValuePair<string, string>>.Contains(KeyValuePair<string, string> item)
+        {
+            string value = this[item.Key];
+            if (value == item.Value)
+            {
+                return true;
+            }
+            else
+            {
+                return false;
+            }
+        }
+
+        bool IDictionary<string, string>.ContainsKey(string key)
+        {
+            return this[key] != null;
+        }
+
+        void IDictionary<string, string>.Add(string key, string value)
+        {
+            this[key] = value;
+        }
+
+        bool IDictionary<string, string>.Remove(string key)
+        {
+            if (this[key] != null)
+            {
+                this[key] = null;
+                return true;
+            }
+            else
+            {
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// Removes all strings from the string table.
+        /// </summary>
+        public void Clear()
+        {
+            this.rawStringVersionInfo.Clear();
+        }
+
+        /// <summary>
+        /// Gets a collection of all the names of the strings in the table.
+        /// </summary>
+        public ICollection<string> Keys
+        {
+            get
+            {
+                List<string> keys = new List<string>(this.rawStringVersionInfo.Count);
+                foreach (VersionInfo verValue in this.rawStringVersionInfo)
+                {
+                    keys.Add(verValue.Key);
+                }
+                return keys;
+            }
+        }
+
+        /// <summary>
+        /// Gets a collection of all the values in the table.
+        /// </summary>
+        public ICollection<string> Values
+        {
+            get
+            {
+                List<string> values = new List<string>(this.rawStringVersionInfo.Count);
+                foreach (VersionInfo verValue in this.rawStringVersionInfo)
+                {
+                    values.Add(Encoding.Unicode.GetString(verValue.Data, 0, verValue.Data.Length - 2));
+                }
+                return values;
+            }
+        }
+
+        /// <summary>
+        /// Gets the number of strings in the table.
+        /// </summary>
+        public int Count
+        {
+            get
+            {
+                return this.rawStringVersionInfo.Count;
+            }
+        }
+
+        void ICollection<KeyValuePair<string, string>>.CopyTo(KeyValuePair<string, string>[] array, int index)
+        {
+            foreach (VersionInfo verValue in this.rawStringVersionInfo)
+            {
+                array[index++] = new KeyValuePair<string, string>(verValue.Key, Encoding.Unicode.GetString(verValue.Data, 0, verValue.Data.Length - 2));
+            }
+        }
+
+        /// <summary>
+        /// Gets an enumeration over all strings in the table.
+        /// </summary>
+        /// <returns>Enumeration of string name and value pairs</returns>
+        public IEnumerator<KeyValuePair<string, string>> GetEnumerator()
+        {
+            foreach (VersionInfo verValue in this.rawStringVersionInfo)
+            {
+                yield return new KeyValuePair<string, string>(verValue.Key, Encoding.Unicode.GetString(verValue.Data, 0, verValue.Data.Length - 2));
+            }
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return this.GetEnumerator();
+        }
+    }
+}