private void CoupleTargetAndRootElements(MacroElement element) { FrameworkElement rootElement = element.rootElement; Panel targetElement = element.targetElement; if (rootElement != null) { if (element.applicationMode != Mode.Output) { rootElement.Visibility = Visibility.Collapsed; } else { rootElement.Visibility = Visibility.Visible; } } else { postErrorMessage("Macro element " + element + " has an invalid root element."); return; } if (targetElement != null) { targetElement.Children.Add(rootElement); } else { postErrorMessage("Macro element " + element + " has an invalid target element."); return; } }
public MacroElement AddMacroElement(AddMacroElementBindingModel model) { var newMacroElement = new MacroElement { Name = model.Name, Description = model.Description, CaloricContentPerGram = model.CaloricContentPerGram }; this.context.MacroElements.Add(newMacroElement); context.SaveChanges(); if (model.Image != null) { var macroElementId = this.context.MacroElements.First(mi => mi.Name == model.Name).Id; var imageLocation = this.imagesService.CreateImage(model.Image, this.GetType().Name.Replace("Service", string.Empty), macroElementId); this.context.MacroElements.First(mi => mi.Id == macroElementId).ImageLocation = imageLocation; newMacroElement.ImageLocation = imageLocation; context.SaveChanges(); } return(newMacroElement); }
/// <summary> /// Handles autocomplete action. /// </summary> /// <param name="macro">Macro expression</param> /// <param name="position">Caret position</param> /// <param name="isShowContext">If true, method context should be returned, otherwise hints are returned</param> /// <param name="previousLines">Text of previous lines</param> private string AutoComplete(string macro, int position, bool isShowContext, string previousLines) { // Do lexical analysis, supress errors List <MacroElement> tokens = MacroElement.ParseExpression(macro, true); // Variables declared on actual line; List <string> inlineVariables = new List <string>(); // Locate current element, find all created variables MacroElement currentElement = null; int currentElementIndex = -1; for (int i = 0; i < tokens.Count; i++) { MacroElement el = tokens[i]; MacroElement elNext = (i < tokens.Count - 1 ? tokens[i + 1] : null); if (elNext == null || ((el.StartIndex <= position) && (elNext.StartIndex > position))) { currentElement = el; currentElementIndex = i; break; } if ((el.Type == ElementType.Operator) && (el.Expression == "=") && (i > 0)) { // Add variable declaration to special fields MacroElement elPrev = tokens[i - 1]; if (elPrev.Type == ElementType.Identifier) { inlineVariables.Add(elPrev.Expression); } } } if (isShowContext) { return(GetContext(tokens, currentElement, currentElementIndex)); } else { // If we are in the middle of the comment or a constant, do not show any help if ((currentElement != null) && ((currentElement.Type == ElementType.Boolean) || (currentElement.Type == ElementType.Double) || (currentElement.Type == ElementType.Integer) || (currentElement.Type == ElementType.String))) { return(""); } else { return(GetHints(tokens, currentElement, currentElementIndex, previousLines, inlineVariables)); } } }
/// <summary> /// Fills the autoCompletionList with strings formated for AutoCompletion. /// </summary> /// <param name="autoCompletionList">Target string list</param> /// <param name="methodList">Source MacroMethod list</param> private static void FillFromMethodList(List <string> autoCompletionList, List <MacroMethod> methodList) { foreach (MacroMethod method in methodList) { string m = method.Name.Trim().ToLower(); if (!MacroElement.IsValidOperator(m) && !MacroElement.IsWordOperator(m)) { if ((m != "logtodebug") || CMSContext.CurrentUser.IsGlobalAdministrator) { // At sign at the end is to distinguish between method and property in the script afterwards if (string.IsNullOrEmpty(method.Snippet)) { autoCompletionList.Add(method.Name + "\n"); } else { autoCompletionList.Add(method.Name + "\n" + method.Snippet); } } } } }
/// <summary> /// Creates new <see cref="FieldMacroRule"/> object based on inputs. /// </summary> private FieldMacroRule CreateMacroRule() { if (!IsValid()) { return(null); } MacroRuleTree main = null; FieldMacroRule fmr = null; MacroRuleInfo mri = MacroRuleInfoProvider.GetMacroRuleInfo(mSelectedRuleName); if (mri != null) { main = new MacroRuleTree(); MacroRuleTree childern = new MacroRuleTree() { RuleText = mri.MacroRuleText, RuleName = mri.MacroRuleName, RuleCondition = mri.MacroRuleCondition, Parent = main }; main.Children.Add(childern); foreach (string paramName in formProperties.Fields) { // Load value from the form control FormEngineUserControl ctrl = formProperties.FieldControls[paramName]; if (ctrl != null) { // Convert value to EN culture var dataType = ctrl.FieldInfo.DataType; var convertedValue = DataTypeManager.ConvertToSystemType(TypeEnum.Field, dataType, ctrl.Value); string value = ValidationHelper.GetString(convertedValue, "", CultureHelper.EnglishCulture); string displayName = ctrl.ValueDisplayName; if (String.IsNullOrEmpty(displayName)) { displayName = value; } MacroRuleParameter param = new MacroRuleParameter { Value = value, Text = displayName, ValueType = dataType }; childern.Parameters.Add(paramName, param); } } string macroRule = string.Format("Rule(\"{0}\", \"{1}\")", MacroElement.EscapeSpecialChars(main.GetCondition()), MacroElement.EscapeSpecialChars(main.GetXML())); if (!MacroSecurityProcessor.IsSimpleMacro(macroRule)) { // Sign complex macros macroRule = MacroSecurityProcessor.AddMacroSecurityParams(macroRule, MacroIdentityOption.FromUserInfo(MembershipContext.AuthenticatedUser)); } fmr = new FieldMacroRule(); fmr.MacroRule = string.Format("{{%{0}%}}", macroRule); fmr.ErrorMessage = txtErrorMsg.Text; } return(fmr); }
/// <summary> /// Returns list of possible hints. /// </summary> /// <param name="tokens">Lexems from lexical analysis</param> /// <param name="currentElement">Current lexem</param> /// <param name="currentElementIndex">Index of the current lexem</param> /// <param name="previousLines">Previous lines to get previous variable declarations</param> private string GetHints(List<MacroElement> tokens, MacroElement currentElement, int currentElementIndex, string previousLines, IEnumerable<string> inlineVariables) { // Get lists with methods and properties List<string> members = new List<string>(); string dataMemeberContext = ""; object obj = null; List<string> dataProperties = new List<string>(); if (currentElement == null) { GetPropertiesFromContext(members, null, ""); } else { // Properties autocomplete bool showAllProperties = (currentElement.Type == ElementType.LeftBracket) || (currentElement.Type == ElementType.LeftIndexer) || (currentElement.Type == ElementType.BlockStart) || (currentElement.Type == ElementType.BlockEnd) || (currentElement.Type == ElementType.Comma) || MacroElement.IsValidOperator(currentElement.Expression); if (!showAllProperties) { // We need to find current datamember context int brackets = 0; for (int i = currentElementIndex - 1; i >= 0; i--) { ElementType type = tokens[i].Type; if (brackets == 0) { // We need to take context to the left side of current lexem // It needs to preserve the structure (deepnes withing the brackets) if ((type == ElementType.Comma) || (type == ElementType.Operator) || (type == ElementType.LeftBracket) || (type == ElementType.LeftIndexer)) { break; } } // Append this part dataMemeberContext = tokens[i].Expression + dataMemeberContext; // Ensure correct deepnes within the brackets if ((type == ElementType.RightBracket) || (type == ElementType.RightIndexer)) { brackets++; } else if ((type == ElementType.LeftBracket) || (type == ElementType.LeftIndexer)) { brackets--; } } dataMemeberContext = dataMemeberContext.TrimEnd('.'); } // Analyze code before current line to find variable declarations (makes sense only for root hints - i.e. datamember context is empty) if (string.IsNullOrEmpty(dataMemeberContext)) { List<MacroElement> vartokens = MacroElement.ParseExpression(previousLines, true); List<string> variables = new List<string>(); for (int i = 0; i < vartokens.Count; i++) { MacroElement el = vartokens[i]; if ((el.Type == ElementType.Operator) && (el.Expression == "=") && (i > 0)) { // Add variable declaration to special fields MacroElement elPrev = vartokens[i - 1]; if (elPrev.Type == ElementType.Identifier) { variables.Add(elPrev.Expression); } } } // Add variables members.AddRange(variables); members.AddRange(inlineVariables); } obj = GetPropertiesFromContext(members, dataProperties, dataMemeberContext); } // Do not process further if only prioritized properties should be handled if (string.IsNullOrEmpty(dataMemeberContext) && Resolver.ShowOnlyPrioritized) { members.AddRange(Resolver.NamedSourceDataPriority); members.Sort(); return MakeFinalList(members); } // Add proper methods if (string.IsNullOrEmpty(dataMemeberContext)) { // Add commands only for empty contexts members.AddRange(CommandsList); members.Add("Math"); // Add namespaces objects if (!ShowOnlyInnerSources) { members.Add("Transformation"); members.Add("Countries"); members.Add("Visitor"); } // List of methods for any type FillFromMethodList(members, MacroMethods.GetMethodsForObject(null)); } else { if (obj == null) { // If the object is null we will offer string methods because these are the most common methods obj = ""; } // Get the list of suitable methods for resulting type FillFromMethodList(members, MacroMethods.GetMethodsForObject(obj)); } // Add methods which belongs to permanently registered namespaces members.AddRange(UsingList); // Remove items which should not be displayed if (Resolver.Context.DisablePageContextMacros) { if (members.Contains("CurrentDocument")) { members.Remove("CurrentDocument"); } if (members.Contains("CurrentPageInfo")) { members.Remove("CurrentPageInfo"); } } // Remove context objects if not needed if (Resolver.Context.DisableContextObjectMacros) { for (int i = members.Count - 1; i >= 0; i--) { if (members[i].EndsWithCSafe("context", true)) { members.RemoveAt(i); } } } // Sort everything members.Sort(); // Insert prioritized items at the beginning if (string.IsNullOrEmpty(dataMemeberContext) && (Resolver.NamedSourceDataPriority.Count > 0)) { List<string> priorities = Resolver.NamedSourceDataPriority; priorities.Sort(); members.Insert(0, "----"); members.InsertRange(0, priorities); } // Add data properties at the end if (dataProperties.Count > 0) { members.Add("----"); members.AddRange(dataProperties); } // Remove duplicities return MakeFinalList(members); }
/// <summary> /// Returns context help (current method parameters). /// </summary> /// <param name="tokens">Lexems from lexical analysis</param> /// <param name="currentElement">Current lexem</param> /// <param name="currentElementIndex">Index of the current lexem</param> private string GetContext(List<MacroElement> tokens, MacroElement currentElement, int currentElementIndex) { string methodName = ""; int paramNumber = 0; int brackets = 0; bool withoutFirstParam = false; for (int i = currentElementIndex; i >= 0; i--) { ElementType type = tokens[i].Type; if (brackets == 0) { // Count number of commas before current element (it's the current number of parameter) if (type == ElementType.Comma) { paramNumber++; } // We need to take context to the left side of current lexem // It needs to preserve the structure (deepnes withing the brackets) if (type == ElementType.LeftBracket) { if ((i > 0) && (tokens[i - 1].Type == ElementType.Identifier)) { methodName = tokens[i - 1].Expression; if (i > 2) { bool isNamespaceCall = false; if (tokens[i - 3].Type == ElementType.Identifier) { string exprToCheck = tokens[i - 3].Expression; foreach (string item in NamespacesInUse) { if (item.EqualsCSafe(exprToCheck)) { isNamespaceCall = true; break; } } } withoutFirstParam = (tokens[i - 2].Type == ElementType.Dot) && !isNamespaceCall; } } break; } else if (type == ElementType.LeftIndexer) { return "Indexer: Type number or name of the element."; } } // Ensure correct deepnes within the brackets if ((type == ElementType.RightBracket) || (type == ElementType.RightIndexer)) { brackets++; } else if ((type == ElementType.LeftBracket) || (type == ElementType.LeftIndexer)) { brackets--; } } MacroMethod method = MacroMethods.GetMethod(methodName); if (method != null) { return GetMethodString(method, paramNumber, withoutFirstParam); } // Method not known or there is syntax error in the expression return ""; }
/// <summary> /// Returns list of possible hints. /// </summary> /// <param name="tokens">Lexems from lexical analysis</param> /// <param name="currentElement">Current lexem</param> /// <param name="currentElementIndex">Index of the current lexem</param> /// <param name="previousLines">Previous lines to get previous variable declarations</param> private string GetHints(List <MacroElement> tokens, MacroElement currentElement, int currentElementIndex, string previousLines, List <string> inlineVariables) { // Get lists with methods and properties List <string> members = new List <string>(); string dataMemeberContext = ""; object obj = null; List <string> dataProperties = new List <string>(); if (currentElement == null) { GetPropertiesFromContext(members, null, ""); } else { // Properties autocomplete bool showAllProperties = false; if ((currentElement.Type == ElementType.LeftBracket) || (currentElement.Type == ElementType.LeftIndexer) || (currentElement.Type == ElementType.BlockStart) || (currentElement.Type == ElementType.BlockEnd) || (currentElement.Type == ElementType.Comma)) { showAllProperties = true; } if (!showAllProperties) { // We need to find current datamember context int brackets = 0; for (int i = currentElementIndex - 1; i >= 0; i--) { ElementType type = tokens[i].Type; if (brackets == 0) { // We need to take context to the left side of current lexem // It needs to preserve the structure (deepnes withing the brackets) if ((type == ElementType.Comma) || (type == ElementType.Operator) || (type == ElementType.LeftBracket) || (type == ElementType.LeftIndexer)) { break; } } // Append this part dataMemeberContext = tokens[i].Expression + dataMemeberContext; // Ensure correct deepnes within the brackets if ((type == ElementType.RightBracket) || (type == ElementType.RightIndexer)) { brackets++; } else if ((type == ElementType.LeftBracket) || (type == ElementType.LeftIndexer)) { brackets--; } } dataMemeberContext = dataMemeberContext.TrimEnd('.'); } // Analyze code before current line to find variable declarations (makes sense only for root hints - i.e. datamember context is empty) if (string.IsNullOrEmpty(dataMemeberContext)) { List <MacroElement> vartokens = MacroElement.ParseExpression(previousLines, true); List <string> variables = new List <string>(); for (int i = 0; i < vartokens.Count; i++) { MacroElement el = vartokens[i]; if ((el.Type == ElementType.Operator) && (el.Expression == "=") && (i > 0)) { // Add variable declaration to special fields MacroElement elPrev = vartokens[i - 1]; if (elPrev.Type == ElementType.Identifier) { variables.Add(elPrev.Expression); } } } // Add variables members.AddRange(variables); members.AddRange(inlineVariables); } obj = GetPropertiesFromContext(members, dataProperties, dataMemeberContext); } // Add proper methods if (string.IsNullOrEmpty(dataMemeberContext)) { // Add commands only for empty contexts members.AddRange(CommandsList); // Add namespaces objects members.Add("Math"); members.Add("Transformation"); members.Add("Countries"); // List of methods for any type FillFromMethodList(members, MacroMethods.GetMethodsForObject(null)); } else { if (obj == null) { // If the object is null we will offer string methods because these are the most common methods obj = ""; } // Get the list of suitable methods for resulting type FillFromMethodList(members, MacroMethods.GetMethodsForObject(obj)); } // Add methods which belongs to permanently registered namespaces members.AddRange(UsingList); // Sort everything members.Sort(); // Add data properties at the end if (dataProperties.Count > 0) { members.Add("----"); members.AddRange(dataProperties); } // Remove duplicities List <string> finalList = new List <string>(); foreach (string member in members) { if (!finalList.Contains(member)) { finalList.Add(member); } } StringBuilder sb = new StringBuilder(); foreach (string member in finalList) { sb.Append("$" + member); } return(sb.ToString().TrimStart('$')); }
/// <summary> /// Returns context help (current method parameters). /// </summary> /// <param name="tokens">Lexems from lexical analysis</param> /// <param name="currentElement">Current lexem</param> /// <param name="currentElementIndex">Index of the current lexem</param> private string GetContext(List <MacroElement> tokens, MacroElement currentElement, int currentElementIndex) { string methodName = ""; int paramNumber = 0; int brackets = 0; bool withoutFirstParam = false; for (int i = currentElementIndex; i >= 0; i--) { ElementType type = tokens[i].Type; if (brackets == 0) { // Count number of commas before current element (it's the current number of parameter) if (type == ElementType.Comma) { paramNumber++; } // We need to take context to the left side of current lexem // It needs to preserve the structure (deepnes withing the brackets) if (type == ElementType.LeftBracket) { if ((i > 0) && (tokens[i - 1].Type == ElementType.Identifier)) { methodName = tokens[i - 1].Expression; if (i > 2) { bool isNamespaceCall = false; if (tokens[i - 3].Type == ElementType.Identifier) { string exprToCheck = tokens[i - 3].Expression; foreach (string item in NamespacesInUse) { if (item.ToLower() == exprToCheck.ToLower()) { isNamespaceCall = true; break; } } } withoutFirstParam = (tokens[i - 2].Type == ElementType.Dot) && !isNamespaceCall; } } break; } else if (type == ElementType.LeftIndexer) { return("Indexer: Type number or name of the element."); } } // Ensure correct deepnes within the brackets if ((type == ElementType.RightBracket) || (type == ElementType.RightIndexer)) { brackets++; } else if ((type == ElementType.LeftBracket) || (type == ElementType.LeftIndexer)) { brackets--; } } MacroMethod method = MacroMethods.GetMethod(methodName); if (method != null) { return(GetMethodString(method, paramNumber, withoutFirstParam)); } // Method not known or there is syntax error in the expression return(""); }
private static IReadOnlyList <CToken> ExpandElement( IReadOnlyDictionary <string, IReadOnlyList <CToken> > args, MacroElement element) => element switch {
/// <summary> /// Returns list of possible hints. /// </summary> /// <param name="tokens">Lexems from lexical analysis</param> /// <param name="currentElement">Current lexem</param> /// <param name="currentElementIndex">Index of the current lexem</param> /// <param name="previousLines">Previous lines to get previous variable declarations</param> private string GetHints(List<MacroElement> tokens, MacroElement currentElement, int currentElementIndex, string previousLines, List<string> inlineVariables) { // Get lists with methods and properties List<string> members = new List<string>(); string dataMemeberContext = ""; object obj = null; List<string> dataProperties = new List<string>(); if (currentElement == null) { GetPropertiesFromContext(members, null, ""); } else { // Properties autocomplete bool showAllProperties = false; if ((currentElement.Type == ElementType.LeftBracket) || (currentElement.Type == ElementType.LeftIndexer) || (currentElement.Type == ElementType.BlockStart) || (currentElement.Type == ElementType.BlockEnd) || (currentElement.Type == ElementType.Comma)) { showAllProperties = true; } if (!showAllProperties) { // We need to find current datamember context int brackets = 0; for (int i = currentElementIndex - 1; i >= 0; i--) { ElementType type = tokens[i].Type; if (brackets == 0) { // We need to take context to the left side of current lexem // It needs to preserve the structure (deepnes withing the brackets) if ((type == ElementType.Comma) || (type == ElementType.Operator) || (type == ElementType.LeftBracket) || (type == ElementType.LeftIndexer)) { break; } } // Append this part dataMemeberContext = tokens[i].Expression + dataMemeberContext; // Ensure correct deepnes within the brackets if ((type == ElementType.RightBracket) || (type == ElementType.RightIndexer)) { brackets++; } else if ((type == ElementType.LeftBracket) || (type == ElementType.LeftIndexer)) { brackets--; } } dataMemeberContext = dataMemeberContext.TrimEnd('.'); } // Analyze code before current line to find variable declarations (makes sense only for root hints - i.e. datamember context is empty) if (string.IsNullOrEmpty(dataMemeberContext)) { List<MacroElement> vartokens = MacroElement.ParseExpression(previousLines, true); List<string> variables = new List<string>(); for (int i = 0; i < vartokens.Count; i++) { MacroElement el = vartokens[i]; if ((el.Type == ElementType.Operator) && (el.Expression == "=") && (i > 0)) { // Add variable declaration to special fields MacroElement elPrev = vartokens[i - 1]; if (elPrev.Type == ElementType.Identifier) { variables.Add(elPrev.Expression); } } } // Add variables members.AddRange(variables); members.AddRange(inlineVariables); } obj = GetPropertiesFromContext(members, dataProperties, dataMemeberContext); } // Add proper methods if (string.IsNullOrEmpty(dataMemeberContext)) { // Add commands only for empty contexts members.AddRange(CommandsList); // Add namespaces objects members.Add("Math"); members.Add("Transformation"); members.Add("Countries"); // List of methods for any type FillFromMethodList(members, MacroMethods.GetMethodsForObject(null)); } else { if (obj == null) { // If the object is null we will offer string methods because these are the most common methods obj = ""; } // Get the list of suitable methods for resulting type FillFromMethodList(members, MacroMethods.GetMethodsForObject(obj)); } // Add methods which belongs to permanently registered namespaces members.AddRange(UsingList); // Sort everything members.Sort(); // Add data properties at the end if (dataProperties.Count > 0) { members.Add("----"); members.AddRange(dataProperties); } StringBuilder sb = new StringBuilder(); foreach (string member in members) { sb.Append("$" + member); } return sb.ToString().TrimStart('$'); }
/// <summary> /// Initializes a new instance of the <see cref="Paste"/> class. /// </summary> /// <param name="left">The first element to paste.</param> /// <param name="right">The second element to paste.</param> public Paste(MacroElement left, MacroElement right) { this.Left = left; this.Right = right; }
/// <summary> /// Returns list of possible hints. /// </summary> /// <param name="tokens">Lexems from lexical analysis</param> /// <param name="currentElement">Current lexem</param> /// <param name="currentElementIndex">Index of the current lexem</param> /// <param name="previousLines">Previous lines to get previous variable declarations</param> private string GetHints(List <MacroElement> tokens, MacroElement currentElement, int currentElementIndex, string previousLines, IEnumerable <string> inlineVariables) { // Get lists with methods and properties List <string> members = new List <string>(); string dataMemeberContext = ""; object obj = null; List <string> dataProperties = new List <string>(); if (currentElement == null) { GetPropertiesFromContext(members, null, ""); } else { // Properties autocomplete bool showAllProperties = (currentElement.Type == ElementType.LeftBracket) || (currentElement.Type == ElementType.LeftIndexer) || (currentElement.Type == ElementType.BlockStart) || (currentElement.Type == ElementType.BlockEnd) || (currentElement.Type == ElementType.Comma) || MacroElement.IsValidOperator(currentElement.Expression); if (!showAllProperties) { // We need to find current datamember context int brackets = 0; for (int i = currentElementIndex - 1; i >= 0; i--) { ElementType type = tokens[i].Type; if (brackets == 0) { // We need to take context to the left side of current lexem // It needs to preserve the structure (deepnes withing the brackets) if ((type == ElementType.Comma) || (type == ElementType.Operator) || (type == ElementType.LeftBracket) || (type == ElementType.LeftIndexer)) { break; } } // Append this part dataMemeberContext = tokens[i].Expression + dataMemeberContext; // Ensure correct deepnes within the brackets if ((type == ElementType.RightBracket) || (type == ElementType.RightIndexer)) { brackets++; } else if ((type == ElementType.LeftBracket) || (type == ElementType.LeftIndexer)) { brackets--; } } dataMemeberContext = dataMemeberContext.TrimEnd('.'); } // Analyze code before current line to find variable declarations (makes sense only for root hints - i.e. datamember context is empty) if (string.IsNullOrEmpty(dataMemeberContext)) { List <MacroElement> vartokens = MacroElement.ParseExpression(previousLines, true); List <string> variables = new List <string>(); for (int i = 0; i < vartokens.Count; i++) { MacroElement el = vartokens[i]; if ((el.Type == ElementType.Operator) && (el.Expression == "=") && (i > 0)) { // Add variable declaration to special fields MacroElement elPrev = vartokens[i - 1]; if (elPrev.Type == ElementType.Identifier) { variables.Add(elPrev.Expression); } } } // Add variables members.AddRange(variables); members.AddRange(inlineVariables); } obj = GetPropertiesFromContext(members, dataProperties, dataMemeberContext); } // Do not process further if only prioritized properties should be handled if (string.IsNullOrEmpty(dataMemeberContext) && Resolver.ShowOnlyPrioritized) { members.AddRange(Resolver.NamedSourceDataPriority); members.Sort(); return(MakeFinalList(members)); } // Add proper methods if (string.IsNullOrEmpty(dataMemeberContext)) { // Add commands only for empty contexts members.AddRange(CommandsList); members.Add("Math"); // Add namespaces objects if (!ShowOnlyInnerSources) { members.Add("Transformation"); members.Add("Countries"); members.Add("Visitor"); } // List of methods for any type FillFromMethodList(members, MacroMethods.GetMethodsForObject(null)); } else { if (obj == null) { // If the object is null we will offer string methods because these are the most common methods obj = ""; } // Get the list of suitable methods for resulting type FillFromMethodList(members, MacroMethods.GetMethodsForObject(obj)); } // Add methods which belongs to permanently registered namespaces members.AddRange(UsingList); // Remove items which should not be displayed if (Resolver.Context.DisablePageContextMacros) { if (members.Contains("CurrentDocument")) { members.Remove("CurrentDocument"); } if (members.Contains("CurrentPageInfo")) { members.Remove("CurrentPageInfo"); } } // Remove context objects if not needed if (Resolver.Context.DisableContextObjectMacros) { for (int i = members.Count - 1; i >= 0; i--) { if (members[i].EndsWithCSafe("context", true)) { members.RemoveAt(i); } } } // Sort everything members.Sort(); // Insert prioritized items at the beginning if (string.IsNullOrEmpty(dataMemeberContext) && (Resolver.NamedSourceDataPriority.Count > 0)) { List <string> priorities = Resolver.NamedSourceDataPriority; priorities.Sort(); members.Insert(0, "----"); members.InsertRange(0, priorities); } // Add data properties at the end if (dataProperties.Count > 0) { members.Add("----"); members.AddRange(dataProperties); } // Remove duplicities return(MakeFinalList(members)); }