Opentk/Source/Bind/Structures/Delegate.cs

#region --- License ---
/* Copyright (c) 2006, 2007 Stefanos Apostolopoulos
 * See license.txt for license info
 */
#endregion

using System;
using System.Collections.Generic;
using System.Text;
using System.Runtime.InteropServices;
using System.Diagnostics;
using System.IO;

namespace Bind.Structures
{
    /// <summary>
    /// Represents an opengl function.
    /// The return value, function name, function parameters and opengl version can be retrieved or set.
    /// </summary>
    public class Delegate
    {
        internal static DelegateCollection Delegates;

        private static bool delegatesLoaded;
        
        #region internal static void Initialize(string glSpec, string glSpecExt)
        
        internal static void Initialize(string glSpec, string glSpecExt)
        {
            if (!delegatesLoaded)
            {
                using (StreamReader sr = Utilities.OpenSpecFile(Settings.InputPath, glSpec))
                {
                    Delegates = Bind.MainClass.Generator.ReadDelegates(sr);
                }

                if (!String.IsNullOrEmpty(glSpecExt))
                {
                    using (StreamReader sr = Utilities.OpenSpecFile(Settings.InputPath, glSpecExt))
                    {
                        foreach (Delegate d in Bind.MainClass.Generator.ReadDelegates(sr).Values)
                        {
                            Utilities.Merge(Delegates, d);
                        }
                    }
                }
                delegatesLoaded = true;
            }
        }

        #endregion
        
        #region --- Constructors ---

        public Delegate()
        {
            Parameters = new ParameterCollection();
        }

        public Delegate(Delegate d)
        {
            this.Category = !String.IsNullOrEmpty(d.Category) ? new string(d.Category.ToCharArray()) : "";
            //this.Extension = !String.IsNullOrEmpty(d.Extension) ? new string(d.Extension.ToCharArray()) : "";
            this.Name = new string(d.Name.ToCharArray());
            //this.NeedsWrapper = d.NeedsWrapper;
            this.Parameters = new ParameterCollection(d.Parameters);
            this.ReturnType = new Type(d.ReturnType);
            this.Version = !String.IsNullOrEmpty(d.Version) ? new string(d.Version.ToCharArray()) : "";
            //this.Unsafe = d.Unsafe;
        }

        #endregion

        #region --- Properties ---

        #region public bool CLSCompliant

        /// <summary>
        ///  Gets the CLSCompliant property. True if the delegate is not CLSCompliant.
        /// </summary>
        public bool CLSCompliant
        {
            get
            {
                if (Unsafe)
                    return false;

                if (!ReturnType.CLSCompliant)
                    return false;

                foreach (Parameter p in Parameters)
                {
                    if (!p.CLSCompliant)
                        return false;
                }
                return true;
            }
        }

        #endregion

        #region public string Category

        private string _category;

        public string Category
        {
            get { return _category; }
            set { _category = value; }
        }

        #endregion

        #region public bool NeedsWrapper

        /// <summary>
        /// Indicates whether this function needs to be wrapped with a Marshaling function.
        /// This flag is set if a function contains an Array parameter, or returns
        /// an Array or string.
        /// </summary>
        public bool NeedsWrapper
        {
            //get { return _needs_wrapper; }
            //set { _needs_wrapper = value; }

            get
            {
                // TODO: Add special cases for (Get)ShaderSource.

                if (ReturnType.WrapperType != WrapperTypes.None)
                    return true;

                foreach (Parameter p in Parameters)
                {
                    if (p.WrapperType != WrapperTypes.None)
                        return true;
                }

                return false;
            }
        }

        #endregion

        #region public virtual bool Unsafe

        /// <summary>
        /// True if the delegate must be declared as 'unsafe'.
        /// </summary>
        public virtual bool Unsafe
        {
            //get { return @unsafe; }
            //set { @unsafe = value; }
            get
            {
                if (ReturnType.Pointer)
                    return true;

                foreach (Parameter p in Parameters)
                {
                    if (p.Pointer)
                    {
                        return true;
                    }
                }

                return false;
            }
        }

        #endregion

        #region public Parameter ReturnType

        Type _return_type = new Type();
        /// <summary>
        /// Gets or sets the return value of the opengl function.
        /// </summary>
        public Type ReturnType
        {
            get { return _return_type; }
            set
            {
                _return_type = Type.Translate(value);
            }
        }

        #endregion

        #region public virtual string Name

        string _name;
        /// <summary>
        /// Gets or sets the name of the opengl function.
        /// </summary>
        public virtual string Name
        {
            get { return _name; }
            set
            {
                if (!String.IsNullOrEmpty(value))
                    _name = value.Trim();
            }
        }

        #endregion

        #region public ParameterCollection Parameters

        ParameterCollection _parameters;

        public ParameterCollection Parameters
        {
            get { return _parameters; }
            protected set { _parameters = value; }
        }

        #endregion

        #region public string Version

        string _version;

        /// <summary>
        /// Defines the opengl version that introduced this function.
        /// </summary>
        public string Version
        {
            get { return _version; }
            set { _version = value; }
        }

        #endregion

        #region public bool Extension

        string _extension;

        public string Extension
        {
            //get { return _extension; }
            //set { _extension = value; }
            get
            {
                if (!String.IsNullOrEmpty(Name))
                {
                    _extension = Utilities.GetGL2Extension(Name);
                    return String.IsNullOrEmpty(_extension) ? "Core" : _extension;
                }
                else
                {
                    return null;
                }
            }
        }

        #endregion

        #endregion

        #region --- Strings ---

        #region public string CallString()

        public string CallString()
        {
            StringBuilder sb = new StringBuilder();

            sb.Append(Settings.DelegatesClass);
            sb.Append(".gl");
            sb.Append(Name);
            sb.Append(Parameters.CallString());

            return sb.ToString();
        }

        #endregion

        #region public string DeclarationString()

        public string DeclarationString()
        {
            StringBuilder sb = new StringBuilder();

            sb.Append(Unsafe ? "unsafe " : "");
            sb.Append(ReturnType);
            sb.Append(" ");
            sb.Append(Name);
            sb.Append(Parameters.ToString());

            return sb.ToString();
        }

        #endregion

        #region override public string ToString()

        /// <summary>
        /// Gets the string representing the full function declaration without decorations
        /// (ie "void glClearColor(float red, float green, float blue, float alpha)"
        /// </summary>
        override public string ToString()
        {
            StringBuilder sb = new StringBuilder();

            sb.Append(Unsafe ? "unsafe " : "");
            sb.Append("delegate ");
            sb.Append(ReturnType);
            sb.Append(" ");
            sb.Append(Name);
            sb.Append(Parameters.ToString());

            return sb.ToString();
        }

        #endregion

        public Delegate GetCLSCompliantDelegate()
        {
            Delegate f = new Delegate(this);

            for (int i = 0; i < f.Parameters.Count; i++)
            {
                f.Parameters[i].CurrentType = f.Parameters[i].GetCLSCompliantType();
            }

            f.ReturnType.CurrentType = f.ReturnType.GetCLSCompliantType();

            return f;
        }

        #endregion

        #region --- Wrapper Creation ---

        #region public IEnumerable<Function> CreateWrappers()

        public IEnumerable<Function> CreateWrappers()
        {
            if (this.Name.Contains("GetString"))
            {
            }

            List<Function> wrappers = new List<Function>();
            if (!NeedsWrapper)
            {
                // No special wrapper needed - just call this delegate:
                Function f = new Function(this);

                if (f.ReturnType.CurrentType.ToLower().Contains("void"))
                    f.Body.Add(String.Format("{0};", f.CallString()));
                else
                    f.Body.Add(String.Format("return {0};", f.CallString()));

                wrappers.Add(f);
            }
            else
            {
                Function f = WrapReturnType();


                WrapParameters(new Function((Function)f ?? this), wrappers);
            }

            return wrappers;
        }

        #endregion

        #region protected Function WrapReturnType()

        protected Function WrapReturnType()
        {
            // We have to add wrappers for all possible WrapperTypes.
            Function f;

            // First, check if the return type needs wrapping:
            switch (this.ReturnType.WrapperType)
            {
                // If the function returns a string (glGetString) we must manually marshal it
                // using Marshal.PtrToStringXXX. Otherwise, the GC will try to free the memory
                // used by the string, resulting in corruption (the memory belongs to the
                // unmanaged boundary).
                case WrapperTypes.StringReturnType:
                    f = new Function(this);
                    f.ReturnType.CurrentType = "System.String";

                    f.Body.Add(
                        String.Format(
                            "return System.Runtime.InteropServices.Marshal.PtrToStringAnsi({0});",
                            this.CallString()
                        )
                    );

                    return f;         // Only occurs in glGetString, there's no need to check parameters.

                // If the function returns a void* (GenericReturnValue), we'll have to return an IntPtr.
                // The user will unfortunately need to marshal this IntPtr to a data type manually.
                case WrapperTypes.GenericReturnType:
                    ReturnType.CurrentType = "IntPtr";
                    ReturnType.Pointer = false;

                    break;

                case WrapperTypes.None:
                default:
                    // No return wrapper needed
                    break;
            }

            return null;
        }
        
        #endregion

        #region protected void WrapParameters(Function function, List<Function> wrappers)

        protected static int index = 0;

        /// <summary>
        /// This function needs some heavy refactoring. I'm ashamed I ever wrote it, but it works...
        /// What it does is this: it adds to the wrapper list all possible wrapper permutations
        /// for functions that have more than one IntPtr parameter. Example:
        /// "void Delegates.f(IntPtr p, IntPtr q)" where p and q are pointers to void arrays needs the following wrappers:
        /// "void f(IntPtr p, IntPtr q)"
        /// "void f(IntPtr p, object q)"
        /// "void f(object p, IntPtr q)"
        /// "void f(object p, object q)"
        /// </summary>
        protected void WrapParameters(Function function, List<Function> wrappers)
        {
            if (function.Name == "GetString")
            {
            }

            if (index == 0)
            {
                bool containsPointerParameters = false;
                // Check if there are any IntPtr parameters (we may have come here from a ReturnType wrapper
                // such as glGetString, which contains no IntPtr parameters)
                foreach (Parameter p in function.Parameters)
                {
                    if (p.Pointer)
                    {
                        containsPointerParameters = true;
                        break;
                    }
                }

                if (containsPointerParameters)
                {
                    wrappers.Add(DefaultWrapper(function));
                }
                else
                {
                    if (function.Body.Count == 0)
                        wrappers.Add(DefaultWrapper(function));
                    else
                        wrappers.Add(function);
                    return;
                }
            }

            if (index >= 0 && index < function.Parameters.Count)
            {
                Function f;

                if (function.Parameters[index].WrapperType == WrapperTypes.None)
                {
                    // No wrapper needed, visit the next parameter
                    ++index;
                    WrapParameters(function, wrappers);
                    --index;
                }
                else
                {
                    switch (function.Parameters[index].WrapperType)
                    {
                        case WrapperTypes.ArrayParameter:
                            // Recurse to the last parameter
                            ++index;
                            WrapParameters(function, wrappers);
                            --index;

                            // On stack rewind, create array wrappers
                            f = ArrayWrapper(new Function(function), index);
                            wrappers.Add(f);

                            // Recurse to the last parameter again, keeping the Array wrappers
                            ++index;
                            WrapParameters(f, wrappers);
                            --index;

                            // On stack rewind, create Ref wrappers.
                            f = ReferenceWrapper(new Function(function), index);
                            wrappers.Add(f);

                            // Keeping the current Ref wrapper, visit all other parameters once more
                            ++index;
                            WrapParameters(f, wrappers);
                            --index;

                            break;

                        case WrapperTypes.GenericParameter:
                            // Recurse to the last parameter
                            ++index;
                            WrapParameters(function, wrappers);
                            --index;

                            // On stack rewind, create array wrappers
                            f = GenericWrapper(new Function(function), index);
                            wrappers.Add(f);

                            // Keeping the current Object wrapper, visit all other parameters once more
                            ++index;
                            WrapParameters(f, wrappers);
                            --index;

                            break;
                    }
                }
            }
        }

        #endregion

        #region protected Function GenericWrapper(Function function, int index)

        protected Function GenericWrapper(Function function, int index)
        {
            // Search and replace IntPtr parameters with the known parameter types:
            function.Parameters[index].Reference = false;
            function.Parameters[index].Array = 0;
            function.Parameters[index].Pointer = false;
            function.Parameters[index].CurrentType = "object";
            function.Parameters[index].Flow = Parameter.FlowDirection.Undefined;

            // In the function body we should pin all objects in memory before calling the
            // low-level function.
            function.Body.Clear();
            //function.Body.AddRange(GetBodyWithFixedPins(function));
            function.Body.AddRange(function.GetBodyWithPins(false));

            return function;
        }

        #endregion

        #region protected Function ReferenceWrapper(Function function, int index)

        protected Function ReferenceWrapper(Function function, int index)
        {
            // Search and replace IntPtr parameters with the known parameter types:
            function.Parameters[index].Reference = true;
            function.Parameters[index].Array = 0;
            function.Parameters[index].Pointer = false;

            // In the function body we should pin all objects in memory before calling the
            // low-level function.
            function.Body.Clear();
            function.Body.AddRange(function.GetBodyWithPins(false));

            return function;
        }

        #endregion

        #region protected Function ArrayWrapper(Function function, int index)

        protected Function ArrayWrapper(Function function, int index)
        {
            // Search and replace IntPtr parameters with the known parameter types:
            function.Parameters[index].Array = 1;
            function.Parameters[index].Pointer = false;
            function.Parameters[index].Flow = Parameter.FlowDirection.Undefined;

            // In the function body we should pin all objects in memory before calling the
            // low-level function.
            function.Body.Clear();
            function.Body.AddRange(function.GetBodyWithPins(false));

            return function;
        }

        #endregion

        #region protected Function DefaultWrapper(Function f)

        protected Function DefaultWrapper(Function f)
        {
            bool returns = f.ReturnType.CurrentType.ToLower().Contains("void") && !f.ReturnType.Pointer;
            string callString = String.Format(
                "{0} {1}{2}; {3}",
                Unsafe ? "unsafe {" : "",
                returns ? "" : "return ",
                this.CallString(),
                Unsafe ? "}" : "");

            f.Body.Add(callString);

            return f;
        }

        #endregion

        #region protected FunctionBody GetBodyWithPins(bool wantCLSCompliance)

        /// <summary>
        /// Generates a body which calls the specified function, pinning all needed parameters.
        /// </summary>
        /// <param name="function"></param>
        protected FunctionBody GetBodyWithPins(bool wantCLSCompliance)
        {
            // We'll make changes, but we want the original intact.
            //Function function = this as Function ?? new Function(this);
            //Function f = new Function(function);
            Function f = new Function(this);
            f.Body.Clear();
            // Unsafe only if 
            //function.Unsafe = false;

            // Add default initliazers for out parameters:
            foreach (Parameter p in this.Parameters)
            {
                if (p.Flow == Parameter.FlowDirection.Out)
                {
                    f.Body.Add(
                        String.Format(
                            "{0} = default({1});",
                            p.Name,
                            p.GetFullType(Bind.Structures.Type.CSTypes, wantCLSCompliance)
                        )
                    );
                }
            }
            // All GCHandles statements will go here. This will allow to place only one opening '{'
            // on fixed statements.
            int handleStart = f.Body.Count;

            // Indicates the index where the last GCHandle statement is. Used to add an unsafe stamement
            // (if needed) at exactl that spot, i.e. after the GCHandles but before the fixed statements.
            int handleEnd = f.Body.Count;

            // True if at least on GCHandle is allocated. Used to remove the try { } finally { }
            // block if no handle has been allocated.
            bool handleAllocated = false;

            // True if function body contains at least one fixed statement. Add a statement-level
            // unsafe block if true (and the function is not unsafe at the function-level).
            bool fixedAllocated = false;

            // Obtain pointers by pinning the parameters
            foreach (Parameter p in f.Parameters)
            {
                if (p.NeedsPin)
                {
                    // Use GCHandle to obtain pointer to generic parameters and 'fixed' for arrays.
                    // This is because fixed can only take the address of fields, not managed objects.
                    if (p.WrapperType == WrapperTypes.GenericParameter)
                    {
                        f.Body.Insert(
                            handleStart,
                            String.Format(
                                "{0} {1} = {0}.Alloc({2}, System.Runtime.InteropServices.GCHandleType.Pinned);",
                                "System.Runtime.InteropServices.GCHandle",
                                p.Name + "_ptr",
                                p.Name
                            )
                        );
                        // Note! The following line modifies f.Parameters, *not* function.Parameters
                        p.Name = "(void*)" + p.Name + "_ptr.AddrOfPinnedObject()";

                        handleAllocated = true;

                        handleEnd++;
                    }
                    else
                    {
                        f.Body.Add(
                            String.Format(
                                "    fixed ({0}* {1} = {2})",
                                wantCLSCompliance && !p.CLSCompliant ?
                                    p.GetCLSCompliantType() :
                                    p.CurrentType,
                                p.Name + "_ptr",
                                p.Array > 0 ? p.Name : "&" + p.Name
                            )
                        );
                        p.Name = p.Name + "_ptr";

                        fixedAllocated = true;
                    }
                }
            }

            if (!this.Unsafe)
            {
                f.Body.Insert(handleEnd, "unsafe");
                f.Body.Insert(handleEnd + 1, "{");
            }

            if (handleAllocated)
            {
                f.Body.Add("    try");
            }

            f.Body.Add("    {");
            // Add delegate call:
            if (f.ReturnType.CurrentType.ToLower().Contains("void"))
                f.Body.Add(String.Format("        {0};", f.CallString()));
            else
                f.Body.Add(String.Format("        {0} {1} = {2};", f.ReturnType.CurrentType, "retval", f.CallString()));

            // Assign out parameters:
            foreach (Parameter p in this.Parameters)
            {
                if (p.Flow == Parameter.FlowDirection.Out)
                {
                    // Check each out parameter. If it has been pinned, get the Target of the GCHandle.
                    // Otherwise, nothing needs be done.
                    if (p.NeedsPin)
                    {
                        if (p.WrapperType == WrapperTypes.GenericParameter)
                        {
                            f.Body.Add(
                                String.Format(
                                    "        {0} = ({1}){2}.Target;",
                                    p.Name,
                                    p.CurrentType,
                                    p.Name + "_ptr"
                                )
                            );
                        }
                        else
                        {
                            f.Body.Add(
                                String.Format(
                                    "        {0} = *{0}_ptr;",
                                    p.Name
                                )
                            );
                        }
                    }
                }
            }

            // Return:
            if (!f.ReturnType.CurrentType.ToLower().Contains("void"))
            {
                f.Body.Add("        return retval;");
            }

            if (handleAllocated)
            {
                f.Body.Add("    }");
                f.Body.Add("    finally");
                f.Body.Add("    {");
                foreach (Parameter p in this.Parameters)
                {
                    // Free all allocated GCHandles
                    if (p.NeedsPin)
                    {
                        if (p.WrapperType == WrapperTypes.GenericParameter)
                            f.Body.Add(String.Format("        {0}_ptr.Free();", p.Name));
                        //else
                        //    f.Body.Add("}");
                    }
                }
            }
            f.Body.Add("    }");

            if (!this.Unsafe)
            {
                f.Body.Add("}");
            }

            return f.Body;
        }

        #endregion

        #endregion

        /// <summary>
        /// Translates the opengl return type to the equivalent C# type.
        /// </summary>
        /// <param name="d">The opengl function to translate.</param>
        /// <remarks>
        /// First, we use the official typemap (gl.tm) to get the correct type.
        /// Then we override this, when it is:
        /// 1) A string (we have to use Marshal.PtrToStringAnsi, to avoid heap corruption)
        /// 2) An array (translates to IntPtr)
        /// 3) A generic object or void* (translates to IntPtr)
        /// 4) A GLenum (translates to int on Legacy.Tao or GL.Enums.GLenum otherwise).
        /// Return types must always be CLS-compliant, because .Net does not support overloading on return types.
        /// </remarks>
        protected virtual void TranslateReturnType()
        {
            if (Bind.Structures.Type.GLTypes.ContainsKey(ReturnType.CurrentType))
                ReturnType.CurrentType = Bind.Structures.Type.GLTypes[ReturnType.CurrentType];

            if (Bind.Structures.Type.CSTypes.ContainsKey(ReturnType.CurrentType))
                ReturnType.CurrentType = Bind.Structures.Type.CSTypes[ReturnType.CurrentType];

            if (ReturnType.CurrentType.ToLower().Contains("void") && ReturnType.Pointer)
            {
                ReturnType.WrapperType = WrapperTypes.GenericReturnType;
            }

            if (ReturnType.CurrentType.ToLower().Contains("string"))
            {
                ReturnType.CurrentType = "IntPtr";
                ReturnType.WrapperType = WrapperTypes.StringReturnType;
            }

            if (ReturnType.CurrentType.ToLower().Contains("object"))
            {
                ReturnType.CurrentType = "IntPtr";
                ReturnType.WrapperType |= WrapperTypes.GenericReturnType;
            }

            if (ReturnType.CurrentType.Contains("GLenum"))
            {
                if (Settings.Compatibility == Settings.Legacy.None)
                    ReturnType.CurrentType =
                        String.Format("{0}.{1}",
                            Settings.GLEnumsClass,
                            Settings.CompleteEnumName);
                else
                    ReturnType.CurrentType = "int";
            }

            if (ReturnType.CurrentType.ToLower().Contains("bool"))
            {
                if (Settings.Compatibility == Settings.Legacy.Tao)
                    ReturnType.CurrentType = "int";
                else
                {
                }

                //ReturnType.WrapperType = WrapperTypes.ReturnsBool;
            }

            ReturnType.CurrentType = ReturnType.GetCLSCompliantType();
        }

        protected virtual void TranslateParameters()
        {
            if (this.Name.Contains("SetLayerPaletteEntries"))
            {
            //	Console.WriteLine();
            }
            for (int i = 0; i < Parameters.Count; i++)
            {
                Parameters[i] = Parameter.Translate(Parameters[i], this.Category);

                // Special cases: glLineStipple and gl(Get)ShaderSource:
                // Check for LineStipple (should be unchecked)
                if (Parameters[i].CurrentType == "UInt16" && Name.Contains("LineStipple"))
                {
                    Parameters[i].WrapperType = WrapperTypes.UncheckedParameter;
                }

                if (Name.Contains("ShaderSource") && Parameters[i].CurrentType.ToLower().Contains("string"))
                {
                    // Special case: these functions take a string[]
                    //IsPointer = true;
                    Parameters[i].Array = 1;
                }
                
                if (Parameters[i].CurrentType == "PIXELFORMATDESCRIPTOR")
                {
                	Parameters[i].CurrentType = Settings.WindowsPlatform + ".PixelFormatDescriptor";
                }
                else if (Parameters[i].CurrentType == "LAYERPLANEDESCRIPTOR")
                {
                	Parameters[i].CurrentType = Settings.WindowsPlatform + ".LayerPlaneDescriptor";
                }
                else if (Parameters[i].CurrentType == "LPCSTR")
                {
                	// TODO: Why doesn't the cs typemap work for LPCSTR and COLORREF?
                	Parameters[i].CurrentType = "String";
                }
                else if (Parameters[i].CurrentType == "COLORREF")
                {
                	Parameters[i].CurrentType = "Int32";
                }
            }
        }

        internal void Translate()
        {
            TranslateReturnType();
            TranslateParameters();

            List<Function> wrappers = (List<Function>)CreateWrappers();

            // If the function is not CLS-compliant (e.g. it contains unsigned parameters)
            // we need to create a CLS-Compliant overload. However, we should only do this
            // iff the opengl function does not contain unsigned/signed overloads itself
            // to avoid redefinitions.
            foreach (Function f in wrappers)
            {
                Bind.Structures.Function.Wrappers.AddChecked(f);

                if (this.Name.Contains("Bitmap"))
                {
                }

                bool createCLS = !f.CLSCompliant;

                /*string nameWithoutExtension = Utilities.StripGL2Extension(f.Name).TrimEnd('v');
                createCLS &=
                    String.IsNullOrEmpty(f.TrimmedName) ||
                    nameWithoutExtension.Substring(nameWithoutExtension.Length - 3).Contains("u") &&
                    !nameWithoutExtension.Substring(nameWithoutExtension.Length - 3).Contains("b");*/

                if (createCLS)
                {
                    Function clsFunction = f.GetCLSCompliantFunction();
                    if (clsFunction != null)
                        Bind.Structures.Function.Wrappers.AddChecked(clsFunction);
                }
            }
        }
    }

    #region class DelegateCollection : Dictionary<string, Delegate>

    class DelegateCollection : Dictionary<string, Delegate>
    {
        public void Add(Delegate d)
        {
            if (!this.ContainsKey(d.Name))
            {
                this.Add(d.Name, d);
            }
            else
            {
                Trace.WriteLine(String.Format(
                    "Spec error: function {0} redefined, ignoring second definition.",
                    d.Name));
            }
        }
    }

    #endregion
}