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)); }