Working on script engine.

6 files changed, 291 insertions, 211 deletions

diff --git a/Software/Visual_Studio/TEMP/Tango.Scripting/Tango.Scripting.Editors/Intellisense/CompletionItem.cs b/Software/Visual_Studio/TEMP/Tango.Scripting/Tango.Scripting.Editors/Intellisense/CompletionItem.cs
index 83ada090f..c8beebd28 100644
--- a/Software/Visual_Studio/TEMP/Tango.Scripting/Tango.Scripting.Editors/Intellisense/CompletionItem.cs
+++ b/Software/Visual_Studio/TEMP/Tango.Scripting/Tango.Scripting.Editors/Intellisense/CompletionItem.cs
@@ -27,10 +27,11 @@ namespace Tango.Scripting.Editors.Intellisense
 
         public virtual void Complete(ScriptEditor editor)
         {
+            var word = editor.GetCurrentWord();
             int index = editor.GetCurrentWordStartIndex();
             int max = editor.GetCurrentLine().EndOffset;
 
-            editor.Document.Replace(index, Math.Min(max - index, Text.Length), Text);
+            editor.Document.Replace(index, word.Length,Text);
         }
 
         public abstract BitmapSource Image { get; }
diff --git a/Software/Visual_Studio/TEMP/Tango.Scripting/Tango.Scripting.Editors/Intellisense/KnownType.cs b/Software/Visual_Studio/TEMP/Tango.Scripting/Tango.Scripting.Editors/Intellisense/KnownType.cs
index 06282e15d..7aec36a86 100644
--- a/Software/Visual_Studio/TEMP/Tango.Scripting/Tango.Scripting.Editors/Intellisense/KnownType.cs
+++ b/Software/Visual_Studio/TEMP/Tango.Scripting/Tango.Scripting.Editors/Intellisense/KnownType.cs
@@ -158,159 +158,161 @@ namespace Tango.Scripting.Editors.Intellisense
                     }
                 }
 
-                if (xmlDoc != null)
-                {
-                    Task.Factory.StartNew(() =>
-                    {
-
-                        //Load Type Summary
-                        {
-                            string path = "T:" + Type.FullName;
-                            XmlNode xmlDocuOfType = xmlDoc.SelectSingleNode("//member[starts-with(@name, '" + path + "')]");
+                xmlDoc = new XmlDocument();
 
-                            if (xmlDocuOfType != null)
-                            {
-                                XmlNode summaryNode = xmlDocuOfType.SelectSingleNode("summary");
-                                Summary = summaryNode.InnerText;
-                            }
-                        }
-
-                        //Load Constructors...
-                        {
-                            string path = "M:" + Type.FullName + ".#ctor";
+                //Load Type Summary
+                {
+                    string path = "T:" + Type.FullName;
+                    XmlNode xmlDocuOfType = xmlDoc.SelectSingleNode("//member[starts-with(@name, '" + path + "')]");
 
-                            var docNodes = xmlDoc.SelectNodes("//member[starts-with(@name, '" + path + "')]").OfType<XmlNode>().ToList();
-                            var constructors = Type.GetConstructors().Where(x => x.IsPublic).ToList();
+                    if (xmlDocuOfType != null)
+                    {
+                        XmlNode summaryNode = xmlDocuOfType.SelectSingleNode("summary");
+                        Summary = summaryNode.InnerText;
+                    }
+                }
 
-                            for (int i = 0; i < constructors.Count; i++)
-                            {
-                                var constructor = constructors[i];
-                                XmlNode cDoc = null;
+                //Load Constructors...
+                {
+                    string path = "M:" + Type.FullName + ".#ctor";
 
-                                if (i < docNodes.Count)
-                                {
-                                    cDoc = docNodes[i];
-                                }
+                    var docNodes = xmlDoc.SelectNodes("//member[starts-with(@name, '" + path + "')]").OfType<XmlNode>().ToList();
+                    var constructors = Type.GetConstructors().Where(x => x.IsPublic).ToList();
 
-                                KnownTypeConstructor c = new KnownTypeConstructor(this);
-                                c.Summary = cDoc != null ? cDoc.SelectSingleNode("summary").InnerXml : $"Initializes a new instance of {FriendlyName}.";
+                    for (int i = 0; i < constructors.Count; i++)
+                    {
+                        var constructor = constructors[i];
+                        XmlNode cDoc = null;
 
-                                var parameters = constructor.GetParameters().ToList();
-                                var parametersNodes = cDoc != null ? cDoc.SelectNodes("param").OfType<XmlNode>().ToList() : new List<XmlNode>();
+                        if (i < docNodes.Count)
+                        {
+                            cDoc = docNodes[i];
+                        }
 
-                                for (int j = 0; j < parameters.Count; j++)
-                                {
-                                    var parameter = parameters[j];
-                                    XmlNode pNode = null;
+                        KnownTypeConstructor c = new KnownTypeConstructor(this);
+                        c.Summary = cDoc != null ? cDoc.SelectSingleNode("summary").InnerXml : $"Initializes a new instance of {FriendlyName}.";
 
-                                    if (j < parametersNodes.Count)
-                                    {
-                                        pNode = parametersNodes[j];
-                                    }
+                        var parameters = constructor.GetParameters().ToList();
+                        var parametersNodes = cDoc != null ? cDoc.SelectNodes("param").OfType<XmlNode>().ToList() : new List<XmlNode>();
 
-                                    KnownTypeMethodParameter p = new KnownTypeMethodParameter();
-                                    p.Type = parameter.ParameterType.GetFriendlyName();
-                                    p.Name = parameter.Name;
-                                    p.Description = pNode != null ? pNode.InnerText : null;
+                        for (int j = 0; j < parameters.Count; j++)
+                        {
+                            var parameter = parameters[j];
+                            XmlNode pNode = null;
 
-                                    if (j == parameters.Count - 1)
-                                    {
-                                        p.IsLast = true;
-                                    }
+                            if (j < parametersNodes.Count)
+                            {
+                                pNode = parametersNodes[j];
+                            }
 
-                                    c.Parameters.Add(p);
-                                }
+                            KnownTypeMethodParameter p = new KnownTypeMethodParameter();
+                            p.Type = parameter.ParameterType.GetFriendlyName();
+                            p.Name = parameter.Name;
+                            p.Description = pNode != null ? pNode.InnerText : null;
 
-                                _constructors.Add(c);
+                            if (j == parameters.Count - 1)
+                            {
+                                p.IsLast = true;
                             }
+
+                            c.Parameters.Add(p);
                         }
 
-                        //Load Methods...
-                        {
-                            string path = "M:" + Type.FullName;
+                        _constructors.Add(c);
+                    }
+                }
 
-                            var docNodes = xmlDoc.SelectNodes("//member[starts-with(@name, '" + path + "')]").OfType<XmlNode>().ToList();
-                            var methods = Type.GetRuntimeMethods().Where(x => x.IsPublic && !x.IsSpecialName).ToList();
+                //Load Methods...
+                {
+                    string path = "M:" + Type.FullName;
 
-                            //TODO: Separate extension methods!
-                            methods.AddRange(Type.GetExtensionMethods(Type.Assembly).ToList());
+                    var docNodes = xmlDoc.SelectNodes("//member[starts-with(@name, '" + path + "')]").OfType<XmlNode>().ToList();
+                    var methods = Type.GetRuntimeMethods().Where(x => x.IsPublic && !x.IsSpecialName).ToList();
 
-                            if (typeof(IEnumerable).IsAssignableFrom(Type))
-                            {
-                                var linqMethods = typeof(System.Linq.Enumerable).GetMethods(BindingFlags.Static | BindingFlags.Public).ToList();
-                                methods.AddRange(linqMethods);
-                            }
+                    //TODO: Separate extension methods!
+                    methods.AddRange(Type.GetExtensionMethods(Type.Assembly).ToList());
 
-                            for (int i = 0; i < methods.Count; i++)
-                            {
-                                var method = methods[i];
-                                XmlNode mDoc = null;
+                    if (typeof(IEnumerable).IsAssignableFrom(Type))
+                    {
+                        var linqMethods = typeof(System.Linq.Enumerable).GetMethods(BindingFlags.Static | BindingFlags.Public).ToList();
+                        methods.AddRange(linqMethods);
+                    }
 
-                                mDoc = docNodes.FirstOrDefault(x => x.Attributes["name"].InnerText.Contains(method.DeclaringType.Name + "." + method.Name));
+                    for (int i = 0; i < methods.Count; i++)
+                    {
+                        var method = methods[i];
+                        XmlNode mDoc = null;
 
-                                KnownTypeMethod m = new KnownTypeMethod(this);
-                                m.Summary = mDoc != null ? mDoc.SelectSingleNode("summary").InnerXml : "No documentation";
-                                m.Name = method.Name;
-                                m.ReturnType = method.ReturnType;
-                                m.ReturnTypeFriendlyName = method.ReturnType.GetFriendlyName();
+                        mDoc = docNodes.FirstOrDefault(x => x.Attributes["name"].InnerText.Contains(method.DeclaringType.Name + "." + method.Name));
 
-                                var parameters = method.GetParameters().ToList();
-                                var parametersNodes = mDoc != null ? mDoc.SelectNodes("param").OfType<XmlNode>().ToList() : new List<XmlNode>();
+                        KnownTypeMethod m = new KnownTypeMethod(this);
+                        m.Summary = mDoc != null ? mDoc.SelectSingleNode("summary").InnerXml : "No documentation";
+                        m.Name = method.Name;
+                        m.ReturnType = method.ReturnType;
+                        m.ReturnTypeFriendlyName = method.ReturnType.GetFriendlyName();
 
-                                bool isLinq = method.DeclaringType == typeof(Enumerable);
+                        if (method.IsGenericMethod)
+                        {
+                            foreach (var lGenericArgument in method.GetGenericMethodDefinition().GetGenericArguments())
+                            {
+                                m.TypeArguments.Add(lGenericArgument.Name);
+                            }
+                        }
 
-                                for (int j = 0; j < parameters.Count; j++)
-                                {
-                                    var parameter = parameters[j];
+                        var parameters = method.GetParameters().ToList();
+                        var parametersNodes = mDoc != null ? mDoc.SelectNodes("param").OfType<XmlNode>().ToList() : new List<XmlNode>();
 
-                                    XmlNode pNode = null;
+                        bool isLinq = method.DeclaringType == typeof(Enumerable);
 
-                                    if (j < parametersNodes.Count)
-                                    {
-                                        pNode = parametersNodes[j];
-                                    }
+                        for (int j = 0; j < parameters.Count; j++)
+                        {
+                            var parameter = parameters[j];
 
-                                    KnownTypeMethodParameter p = new KnownTypeMethodParameter();
-                                    p.Type = parameter.ParameterType.GetFriendlyName();
-                                    p.Name = parameter.Name;
-                                    p.Description = pNode != null ? pNode.InnerText : null;
+                            XmlNode pNode = null;
 
-                                    if (j == parameters.Count - 1)
-                                    {
-                                        p.IsLast = true;
-                                    }
+                            if (j < parametersNodes.Count)
+                            {
+                                pNode = parametersNodes[j];
+                            }
 
-                                    if (j == 0 && isLinq) continue;
-                                    m.Parameters.Add(p);
-                                }
+                            KnownTypeMethodParameter p = new KnownTypeMethodParameter();
+                            p.Type = parameter.ParameterType.GetFriendlyName();
+                            p.Name = parameter.Name;
+                            p.Description = pNode != null ? pNode.InnerText : null;
 
-                                _methods.Add(m);
+                            if (j == parameters.Count - 1)
+                            {
+                                p.IsLast = true;
                             }
+
+                            if (j == 0 && isLinq) continue;
+                            m.Parameters.Add(p);
                         }
 
-                        //Load Properties
-                        {
-                            string path = "P:" + Type.FullName;
+                        _methods.Add(m);
+                    }
+                }
 
-                            var docNodes = xmlDoc.SelectNodes("//member[starts-with(@name, '" + path + "')]").OfType<XmlNode>().ToList();
-                            var properties = Type.GetProperties(BindingFlags.Public | BindingFlags.Instance).Where(x => x.PropertyType.IsPublic).ToList();
+                //Load Properties
+                {
+                    string path = "P:" + Type.FullName;
 
-                            for (int i = 0; i < properties.Count; i++)
-                            {
-                                var property = properties[i];
-                                var pDoc = docNodes.FirstOrDefault(x => x.Attributes["name"].InnerText.Contains(property.DeclaringType.Name + "." + property.Name));
+                    var docNodes = xmlDoc.SelectNodes("//member[starts-with(@name, '" + path + "')]").OfType<XmlNode>().ToList();
+                    var properties = Type.GetProperties(BindingFlags.Public | BindingFlags.Instance).Where(x => x.PropertyType.IsPublic).ToList();
 
-                                KnownTypeProperty p = new KnownTypeProperty(this);
-                                p.Summary = pDoc != null ? pDoc.SelectSingleNode("summary").InnerXml : "No documentation";
-                                p.Name = property.Name;
-                                p.ReturnType = property.PropertyType;
-                                p.ReturnTypeFriendlyName = property.PropertyType.GetFriendlyName();
+                    for (int i = 0; i < properties.Count; i++)
+                    {
+                        var property = properties[i];
+                        var pDoc = docNodes.FirstOrDefault(x => x.Attributes["name"].InnerText.Contains(property.DeclaringType.Name + "." + property.Name));
 
-                                _properties.Add(p);
-                            }
-                        }
+                        KnownTypeProperty p = new KnownTypeProperty(this);
+                        p.Summary = pDoc != null ? pDoc.SelectSingleNode("summary").InnerXml : "No documentation";
+                        p.Name = property.Name;
+                        p.ReturnType = property.PropertyType;
+                        p.ReturnTypeFriendlyName = property.PropertyType.GetFriendlyName();
 
-                    });
+                        _properties.Add(p);
+                    }
                 }
 
                 _initialized = true;
diff --git a/Software/Visual_Studio/TEMP/Tango.Scripting/Tango.Scripting.Editors/Intellisense/KnownTypeMethod.cs b/Software/Visual_Studio/TEMP/Tango.Scripting/Tango.Scripting.Editors/Intellisense/KnownTypeMethod.cs
index 0ae4b708e..767d49b7e 100644
--- a/Software/Visual_Studio/TEMP/Tango.Scripting/Tango.Scripting.Editors/Intellisense/KnownTypeMethod.cs
+++ b/Software/Visual_Studio/TEMP/Tango.Scripting/Tango.Scripting.Editors/Intellisense/KnownTypeMethod.cs
@@ -10,9 +10,27 @@ namespace Tango.Scripting.Editors.Intellisense
     {
         public List<KnownTypeMethodParameter> Parameters { get; set; }
 
+        public List<String> TypeArguments { get; set; }
+
+        public String NameWithTypeArguments
+        {
+            get
+            {
+                if (TypeArguments.Count == 0)
+                {
+                    return Name;
+                }
+                else
+                {
+                    return Name + $"<{String.Join(",", TypeArguments)}>";
+                }
+            }
+        }
+
         public KnownTypeMethod()
         {
             Parameters = new List<KnownTypeMethodParameter>();
+            TypeArguments = new List<string>();
         }
 
         public KnownTypeMethod(KnownType knownType) : this()
diff --git a/Software/Visual_Studio/TEMP/Tango.Scripting/Tango.Scripting.Editors/Intellisense/MethodCompletionItem.cs b/Software/Visual_Studio/TEMP/Tango.Scripting/Tango.Scripting.Editors/Intellisense/MethodCompletionItem.cs
index 0a0883ede..d2ee40920 100644
--- a/Software/Visual_Studio/TEMP/Tango.Scripting/Tango.Scripting.Editors/Intellisense/MethodCompletionItem.cs
+++ b/Software/Visual_Studio/TEMP/Tango.Scripting/Tango.Scripting.Editors/Intellisense/MethodCompletionItem.cs
@@ -28,6 +28,17 @@ namespace Tango.Scripting.Editors.Intellisense
 
         public List<KnownTypeMethodParameter> Parameters { get; set; }
 
+        public override void Complete(ScriptEditor editor)
+        {
+            base.Complete(editor);
+
+            if (Text.Contains("<T>"))
+            {
+                editor.CaretOffset -= 2;
+                editor.Select(editor.CaretOffset, 1);
+            }
+        }
+
         public MethodCompletionItem()
         {
             Parameters = new List<KnownTypeMethodParameter>();
diff --git a/Software/Visual_Studio/TEMP/Tango.Scripting/Tango.Scripting.Editors/ScriptEditor.cs b/Software/Visual_Studio/TEMP/Tango.Scripting/Tango.Scripting.Editors/ScriptEditor.cs
index e43322711..f6296ac5c 100644
--- a/Software/Visual_Studio/TEMP/Tango.Scripting/Tango.Scripting.Editors/ScriptEditor.cs
+++ b/Software/Visual_Studio/TEMP/Tango.Scripting/Tango.Scripting.Editors/ScriptEditor.cs
@@ -39,7 +39,7 @@ namespace Tango.Scripting.Editors
 {
     public class ScriptEditor : TextEditor
     {
-        private char[] word_separators = { ' ', '\t', '\n', '.', '(', ',', '-', '*', '/', '+', '$', '=' };
+        private char[] word_separators = { ' ', '\t', '\n', '.', '(', ',', '-', '*', '/', '+', '$', '=', '<', '>' };
         private string[] _blocking_type_words = { "class", "void" };
 
         private DispatcherTimer _update_timer;
@@ -51,6 +51,7 @@ namespace Tango.Scripting.Editors
         private List<String> _current_usings;
         private List<KnownType> _knownTypes;
         private List<ScriptType> _declaredTypes;
+        private bool _isLoadingTypes;
 
         #region Mini Classes
 
@@ -151,6 +152,7 @@ namespace Tango.Scripting.Editors
             //Add basic assemblies...
             ReferenceAssemblies.Add(new ReferenceAssembly(typeof(String))); //mscorelib
             ReferenceAssemblies.Add(new ReferenceAssembly(typeof(Enumerable))); //System.Core
+            ReferenceAssemblies.Add(new ReferenceAssembly(typeof(Tango.Core.CoreSettings))); //System.Core
 
             _knownTypes = new List<KnownType>();
             _parser = new ScriptParser();
@@ -400,7 +402,7 @@ namespace Tango.Scripting.Editors
 
             if (expression != null)
             {
-                var tree = expression.Split('.').Select(x => x.Replace("\n", "").Replace("\r", "").Replace(" ", "").Replace("\t", "").Replace("(", "").Replace(")", "").Replace("[", "").Replace("]", "")).ToList();
+                var tree = expression.Split('.').Select(x => x.Remove(@"\n|\r|\s|\t|\(|\)|\[|\]|<.*>")).ToList();
                 var variableName = tree.FirstOrDefault();
 
                 if (variableName != null && tree.Count > 1)
@@ -523,103 +525,109 @@ namespace Tango.Scripting.Editors
 
         private void InvalidateHighlighting()
         {
-            _knownTypes.Clear();
+            if (!_isLoadingTypes)
+            {
+                _isLoadingTypes = true;
+                _knownTypes.Clear();
 
-            var assemblies = ReferenceAssemblies.ToList();
-            var usings = _current_usings.ToList();
+                var assemblies = ReferenceAssemblies.ToList();
+                var usings = _current_usings.ToList();
 
-            Thread t = new Thread(() =>
-            {
-                foreach (var asm in assemblies.Select(x => x.Assembly))
+                Thread t = new Thread(() =>
                 {
-                    Parallel.ForEach(asm.GetTypes().Where(x => x.IsVisible && x.IsPublic && !x.IsPrimitive), (type) =>
+                    foreach (var asm in assemblies.Select(x => x.Assembly))
                     {
-                        if (usings.Exists(x => type.Namespace == x))
+                        Parallel.ForEach(asm.GetTypes().Where(x => x.IsVisible && x.IsPublic && !x.IsPrimitive), (type) =>
                         {
-                            lock (_knownTypes)
+                            if (usings.Exists(x => type.Namespace == x))
                             {
-                                if (!_knownTypes.Exists(x => x.Type.FullName == type.FullName))
+                                lock (_knownTypes)
                                 {
-                                    _knownTypes.Add(new KnownType(type));
+                                    if (!_knownTypes.Exists(x => x.Type.FullName == type.FullName))
+                                    {
+                                        _knownTypes.Add(new KnownType(type));
+                                    }
                                 }
                             }
-                        }
-                    });
-                }
-
-                if (_knownTypes.Count > 0 || _declaredTypes.Count > 0)
-                {
-                    String text = String.Empty;
-
-                    Stream xshd_stream = typeof(ScriptEditor).Assembly.GetManifestResourceStream("Tango.Scripting.Editors.Highlighting.Resources.CSharp-Mode.xshd");
+                        });
+                    }
 
-                    using (StreamReader reader = new StreamReader(xshd_stream))
+                    if (_knownTypes.Count > 0 || _declaredTypes.Count > 0)
                     {
-                        text = reader.ReadToEnd();
-                    }
+                        String text = String.Empty;
 
-                    List<String> referenceTypes = new List<string>();
-                    List<String> interfaceTypes = new List<string>();
+                        Stream xshd_stream = typeof(ScriptEditor).Assembly.GetManifestResourceStream("Tango.Scripting.Editors.Highlighting.Resources.CSharp-Mode.xshd");
 
-                    lock (_knownTypes)
-                    {
-                        foreach (var type in _knownTypes.ToList().Where(x => x != null))
+                        using (StreamReader reader = new StreamReader(xshd_stream))
                         {
-                            String name = type.Name;
+                            text = reader.ReadToEnd();
+                        }
+
+                        List<String> referenceTypes = new List<string>();
+                        List<String> interfaceTypes = new List<string>();
 
-                            if (type.Type.ContainsGenericParameters)
+                        lock (_knownTypes)
+                        {
+                            foreach (var type in _knownTypes.ToList().Where(x => x != null))
                             {
-                                name = new String(name.TakeWhile(x => x != '`').ToArray());
+                                String name = type.Name;
+
+                                if (type.Type.ContainsGenericParameters)
+                                {
+                                    name = new String(name.TakeWhile(x => x != '`').ToArray());
+                                }
+
+                                if (type.Type.IsInterface || type.Type.IsEnum)
+                                {
+                                    interfaceTypes.Add(String.Format("<Word>{0}</Word>", name));
+                                }
+                                else if (type.Type.IsClass)
+                                {
+                                    referenceTypes.Add(String.Format("<Word>{0}</Word>", name));
+                                }
                             }
+                        }
 
-                            if (type.Type.IsInterface || type.Type.IsEnum)
+                        foreach (var type in _declaredTypes)
+                        {
+                            if (type.Kind == TypeKind.Interface || type.Kind == TypeKind.Enum)
                             {
-                                interfaceTypes.Add(String.Format("<Word>{0}</Word>", name));
+                                interfaceTypes.Add(String.Format("<Word>{0}</Word>", type.Name));
                             }
-                            else if (type.Type.IsClass)
+                            else if (type.Kind == TypeKind.Class)
                             {
-                                referenceTypes.Add(String.Format("<Word>{0}</Word>", name));
+                                referenceTypes.Add(String.Format("<Word>{0}</Word>", type.Name));
                             }
                         }
-                    }
 
-                    foreach (var type in _declaredTypes)
-                    {
-                        if (type.Kind == TypeKind.Interface || type.Kind == TypeKind.Enum)
+                        if (referenceTypes.Count > 0)
                         {
-                            interfaceTypes.Add(String.Format("<Word>{0}</Word>", type.Name));
+                            text = text.Replace("<Word>@ReferenceTypes@</Word>", String.Join(Environment.NewLine, referenceTypes.Distinct()));
                         }
-                        else if (type.Kind == TypeKind.Class)
+
+                        if (interfaceTypes.Count > 0)
                         {
-                            referenceTypes.Add(String.Format("<Word>{0}</Word>", type.Name));
+                            text = text.Replace("<Word>@InterfaceTypes@</Word>", String.Join(Environment.NewLine, interfaceTypes.Distinct()));
                         }
-                    }
 
-                    if (referenceTypes.Count > 0)
-                    {
-                        text = text.Replace("<Word>@ReferenceTypes@</Word>", String.Join(Environment.NewLine, referenceTypes.Distinct()));
-                    }
-
-                    if (interfaceTypes.Count > 0)
-                    {
-                        text = text.Replace("<Word>@InterfaceTypes@</Word>", String.Join(Environment.NewLine, interfaceTypes.Distinct()));
-                    }
+                        MemoryStream ms = new MemoryStream(Encoding.UTF8.GetBytes(text));
 
-                    MemoryStream ms = new MemoryStream(Encoding.UTF8.GetBytes(text));
+                        XmlTextReader xshd_reader = new XmlTextReader(ms);
 
-                    XmlTextReader xshd_reader = new XmlTextReader(ms);
+                        Dispatcher.BeginInvoke(new Action(() =>
+                        {
+                            SyntaxHighlighting = HighlightingLoader.Load(xshd_reader, HighlightingManager.Instance);
+                            xshd_reader.Close();
+                            ms.Dispose();
+                        }));
 
-                    Dispatcher.BeginInvoke(new Action(() =>
-                    {
-                        SyntaxHighlighting = HighlightingLoader.Load(xshd_reader, HighlightingManager.Instance);
-                        xshd_reader.Close();
-                        ms.Dispose();
-                    }));
+                    }
 
-                }
-            });
-            t.IsBackground = true;
-            t.Start();
+                    _isLoadingTypes = false;
+                });
+                t.IsBackground = true;
+                t.Start();
+            }
         }
 
         private void InvalidateScriptTypesHighlightings()
@@ -738,6 +746,10 @@ namespace Tango.Scripting.Editors
                     CaretOffset = Document.GetLineByNumber(line.LineNumber + 1).EndOffset;
                 }
             }
+            else if (e.Key == Key.End || e.Key == Key.Home)
+            {
+                HideCompletionWindow();
+            }
         }
 
         #endregion
@@ -797,38 +809,36 @@ namespace Tango.Scripting.Editors
 
                     var typeMembers = knownType.Members.ToList();
 
-                    foreach (var methodGroup in typeMembers.GroupBy(x => x.Name))
+                    foreach (var methodGroup in typeMembers.OfType<KnownTypeMethod>().GroupBy(x => x.NameWithTypeArguments))
                     {
-                        var member = methodGroup.First();
+                        var method = methodGroup.First();
 
-                        if (member.GetType() == typeof(KnownTypeMethod))
+                        data.Add(new MethodCompletionItem()
                         {
-                            var method = member as KnownTypeMethod;
+                            Class = knownType.FriendlyName,
+                            Name = method.NameWithTypeArguments,
+                            ReturnType = method.ReturnTypeFriendlyName,
+                            Description = method.Summary,
+                            Parameters = method.Parameters,
+                            Overloads = methodGroup.Count() - 1,
+                        });
+                    }
 
-                            data.Add(new MethodCompletionItem()
-                            {
-                                Class = knownType.FriendlyName,
-                                Name = method.Name,
-                                ReturnType = method.ReturnTypeFriendlyName,
-                                Description = method.Summary,
-                                Parameters = method.Parameters,
-                                Overloads = methodGroup.Count() - 1,
-                            });
+                    foreach (var methodGroup in typeMembers.Where(x => x.GetType() != typeof(KnownTypeMethod)).GroupBy(x => x.Name))
+                    {
+                        var member = methodGroup.First();
 
-                        }
-                        else
+                        data.Add(new PropertyCompletionItem()
                         {
-                            data.Add(new PropertyCompletionItem()
-                            {
-                                Class = knownType.FriendlyName,
-                                Name = member.Name,
-                                Type = member.ReturnTypeFriendlyName,
-                                Description = member.Summary,
-                            });
-                        }
+                            Class = knownType.FriendlyName,
+                            Name = member.Name,
+                            Type = member.ReturnTypeFriendlyName,
+                            Description = member.Summary,
+                        });
+
                     }
 
-                    ShowCompletionWindow(data, GetCurrentWord());
+                    ShowCompletionWindow(data.OrderBy(x => x.Text).ToList(), GetCurrentWord());
                 }
                 else
                 {
@@ -855,7 +865,7 @@ namespace Tango.Scripting.Editors
                                     Description = member.Summary,
                                     Overloads = methodGroup.Count() - 1,
                                 };
-                                
+
 
                                 for (int i = 0; i < member.Parameters.Count; i++)
                                 {
@@ -971,7 +981,7 @@ namespace Tango.Scripting.Editors
 
                 ShowCompletionWindow(data, GetCurrentWord());
             }
-            else if (!currentWordIncludingParenthesis.Contains("."))
+            else if (!currentWordIncludingParenthesis.Contains(".") || currentWord[currentWord.Length - 2] == '<')
             {
                 if (completionWindow.IsVisible)
                 {
@@ -982,6 +992,11 @@ namespace Tango.Scripting.Editors
                 var previous_word = GetPreviousWord();
                 var word = GetCurrentWord();
 
+                if (word.Contains("<"))
+                {
+                    word = word.Last(x => x != '<').ToString();
+                }
+
                 if (previous_word != word)
                 {
                     if (_knownTypes.Exists(x => x.Name == previous_word))
@@ -1410,7 +1425,7 @@ namespace Tango.Scripting.Editors
                 MethodDescription method = new MethodDescription();
                 method.ReturnType = session.Type.Name;
                 method.Description = m.Summary;
-                method.Name = m.Name;
+                method.Name = m.NameWithTypeArguments;
                 method.Class = session.Type.FriendlyName;
 
                 //if (session.Type.Type.IsGenericType && session.TypeArguments != null)
diff --git a/Software/Visual_Studio/TEMP/Tango.Scripting/Tango.Scripting/Parsing/ScriptParser.cs b/Software/Visual_Studio/TEMP/Tango.Scripting/Tango.Scripting/Parsing/ScriptParser.cs
index 101bfdda3..508801037 100644
--- a/Software/Visual_Studio/TEMP/Tango.Scripting/Tango.Scripting/Parsing/ScriptParser.cs
+++ b/Software/Visual_Studio/TEMP/Tango.Scripting/Tango.Scripting/Parsing/ScriptParser.cs
@@ -71,6 +71,36 @@ namespace Tango.Scripting.Parsing
 
             foreach (var symbol in symbols.DistinctBy(x => x.Name))
             {
+                if (symbol.ContainingSymbol.GetType().Name == "LambdaSymbol")
+                {
+                    var invocationNode = currentNode.Ancestors().OfType<InvocationExpressionSyntax>().FirstOrDefault();
+
+                    if (invocationNode != null)
+                    {
+                        var expressionNode = invocationNode.Expression as MemberAccessExpressionSyntax;
+
+                        if (expressionNode != null && expressionNode.Name != null)
+                        {
+                            var name = expressionNode.Name as GenericNameSyntax;
+
+                            if (name != null)
+                            {
+                                var type = name.TypeArgumentList.Arguments.FirstOrDefault()?.ToString();
+
+                                vars.Add(new ScriptSymbol()
+                                {
+                                    Name = symbol.Name,
+                                    Type = ReplaceFakeScript(type),
+                                    Class = ReplaceFakeScript(symbol.ContainingType?.Name),
+                                    Kind = symbol.Kind,
+                                    Accessibility = symbol.DeclaredAccessibility,
+                                    ContainingNamespace = ReplaceFakeScript(symbol.ContainingNamespace?.Name),
+                                    Summary = GetSymbolDocumentation(symbol),
+                                });
+                            }
+                        }
+                    }
+                }
                 if (symbol.Kind == SymbolKind.Method)
                 {
                     var prop = symbol.GetType().GetProperty("ReturnType");
@@ -113,7 +143,7 @@ namespace Tango.Scripting.Parsing
                 }
             }
 
-            return vars;
+            return vars.Where(x => x.Type != "?").ToList();
         }
 
         public List<String> GetUsings(String code)
@@ -205,7 +235,10 @@ namespace Tango.Scripting.Parsing
 
                             foreach (var p in symbol.DescendantNodes().OfType<ParameterSyntax>())
                             {
-                                m.Parameters.Add(new KeyValuePair<string, string>(p.Type.ToString(), p.Identifier.ToString()));
+                                if (p.Type != null && p.Identifier != null)
+                                {
+                                    m.Parameters.Add(new KeyValuePair<string, string>(p.Type.ToString(), p.Identifier.ToString()));
+                                }
                             }
 
                             scriptType.Symbols.Add(m);