private void ColourizeVariablesAndTypes(
            QuickSharp.Editor.ScintillaEditForm document)
        {
            string source = document.GetContent() as string;

            source = CSharpFormattingTools.RemoveUnwantedText(source);
            source = CSharpFormattingTools.RemoveUnwantedBracketText(source);

            List <string> namespaces = GetNamespaceList(source);

            if (settingsManager.ColorizeTypes)
            {
                // Lexer WORD2 - types

                List <string> assemblies = new List <string>();

                foreach (string ns in namespaces)
                {
                    List <string> names =
                        referenceManager.GetNamespaceAssemblies(ns);

                    foreach (string name in names)
                    {
                        if (!assemblies.Contains(name))
                        {
                            assemblies.Add(name);
                        }
                    }
                }

                assemblies.AddRange(workspaceAssemblyList);

                document.Editor.Lexing.Keywords[1] =
                    "Array Boolean Date Enumerator Error Function Number Object RegExp String VBArray " +
                    CodeAssistTools.GetNamespaceTypesAsString(
                        namespaces, assemblies);
            }

            if (settingsManager.ColorizeVariables)
            {
                // Lexer GLOBALCLASS - variables
                DeclaredVariables declaredVariables =
                    new DeclaredVariables(source, fullNamespaceList, false);

                StringBuilder sb = new StringBuilder();

                foreach (Variable v in declaredVariables.Items)
                {
                    sb.Append(v.Name);
                    sb.Append(" ");
                }

                document.Editor.Lexing.Keywords[3] = sb.ToString();
            }

            document.Editor.Lexing.Colorize();
        }
        protected List <LookupListItem> GetVisibleTypes(
            string source,
            DeclaredVariables variables,
            bool includeNamespaces,
            bool includeVariables)
        {
            List <LookupListItem> list = new List <LookupListItem>();

            if (includeNamespaces)
            {
                /*
                 * Add all members of declared namespaces.
                 */

                List <LookupListItem> itemList =
                    FindNamespaceTypeLookupItems(
                        GetNamespaceList(source));

                if (itemList != null)
                {
                    list.AddRange(itemList);
                }
            }

            if (includeVariables)
            {
                /*
                 * Add visible declared variables.
                 */

                foreach (Variable v in variables.Items)
                {
                    LookupListItem item = new LookupListItem();
                    item.DisplayText = v.Name;
                    item.InsertText  = v.Name;
                    item.Category    = QuickSharp.CodeAssist.Constants.FIELD;
                    item.ToolTipText = String.Format("{0} {1}",
                                                     v.GetVariableType(), v.Name);

                    list.Add(item);
                }
            }

            return(list);
        }
        private LookupList GetJScriptLookupList(
            QuickSharp.Editor.ScintillaEditForm document)
        {
            UpdateLists();

            if ((settingsManager.ColorizeTypes ||
                 settingsManager.ColorizeVariables) &&
                settingsManager.ColorizeOnLookup)
            {
                ColourizeVariablesAndTypes(document);
            }

            /*
             * Get the search target from the current line.
             */

            Line line = document.Editor.Lines.Current;

            string text = line.Text.Substring(0,
                                              line.SelectionStartPosition -
                                              line.StartPosition).TrimStart();

            /*
             * Check for embedded option or empty comment.
             */

            if (text.StartsWith("//"))
            {
                if (text.Length > 2 && "$?&".IndexOf(text[2]) != -1)
                {
                    return(EmbeddedOptionHelper.GetEmbbededOptionFileList(text));
                }
                else
                {
                    return(null);
                }
            }

            /*
             * Cleanup the source.
             */

            text = JScriptFormattingTools.RemoveUnwantedText(text);
            text = JScriptFormattingTools.RemoveUnwantedBracketText(text);
            text = JScriptFormattingTools.RemoveUnwantedParentheses(text);

            LookupTarget          target = new LookupTarget(text);
            List <LookupListItem> lookupItemList;

            string source = document.GetContent() as string;

            source = source.Substring(0, document.Editor.CurrentPos);
            source = JScriptFormattingTools.RemoveUnwantedText(source);
            source = JScriptFormattingTools.RemoveUnwantedBracketText(source);

            /*
             * Looking for namespaces as part of an 'import'
             * declaration...
             */

            lookupItemList = GetChildNamespaces(target, text);

            if (lookupItemList != null)
            {
                return(new LookupList(target.LookAhead, lookupItemList));
            }

            /*
             * Looking for members of a namespace...
             */

            if (target.Entity != String.Empty)
            {
                List <LookupListItem> types =
                    FindNamespaceTypeLookupItems(target.Entity);

                List <LookupListItem> namespaces =
                    FindNamespaceChildLookupItems(target.Entity);

                if (types != null || namespaces != null)
                {
                    lookupItemList = new List <LookupListItem>();
                    if (types != null)
                    {
                        lookupItemList.AddRange(types);
                    }
                    if (namespaces != null)
                    {
                        lookupItemList.AddRange(namespaces);
                    }
                }
            }

            if (lookupItemList != null)
            {
                return(new LookupList(target.LookAhead, lookupItemList));
            }

            /*
             * Get the local variables declared within the scope visible
             * from the lookup location (the caret)...
             */

            DeclaredVariables declaredVariables =
                new DeclaredVariables(source, fullNamespaceList, true);

            /*
             * Looking for anything in scope...
             */

            if (String.IsNullOrEmpty(target.Entity))
            {
                lookupItemList = GetVisibleTypes(
                    source, declaredVariables, true, true);

                if (lookupItemList != null)
                {
                    // Add the root namespaces
                    foreach (string ns in rootNamespaceList)
                    {
                        LookupListItem item = new LookupListItem();
                        item.DisplayText = ns;
                        item.InsertText  = ns;
                        item.Category    = QuickSharp.CodeAssist.Constants.NAMESPACE;
                        item.ToolTipText = String.Format("namespace {0}", ns);
                        lookupItemList.Add(item);
                    }

                    return(new LookupList(target.LookAhead, lookupItemList));
                }
            }

            /*
             * The target cannot be blank after this point; if we haven't found
             * anything using a blank target then there's nothing to find.
             */

            if (String.IsNullOrEmpty(target.Entity))
            {
                return(null);
            }

            /*
             * Looking for members of a variable...
             */

            Variable variable = declaredVariables.GetVariable(target.Entity);

            if (variable != null)
            {
                String[] split = target.Entity.Split('.');

                if (target.IsIndexed)
                {
                    target.Entity = variable.GetVariableCollectionType(target.Entity);
                }
                else
                {
                    split[0]      = variable.Type;
                    target.Entity = String.Join(".", split);
                }

                lookupItemList = GetTypeMembers(
                    source, target, false, false);

                if (lookupItemList != null)
                {
                    return(new LookupList(target.LookAhead, lookupItemList));
                }
            }

            /*
             * Looking for members of a class...
             */

            lookupItemList = GetTypeMembers(source, target, true, false);

            return(new LookupList(target.LookAhead, lookupItemList));
        }