public void ParsePartialNVReferenceWithDollarIdentDotIdentLParen() { ScannerOptions scannerOptions = new ScannerOptions(); scannerOptions.EnableIntelliSenseTriggerTokens = true; Parser parser = GetNewParser(scannerOptions, "$Ajax.LinkToRemote("); TemplateNode template = parser.ParseTemplate(); // Check errors Assert.AreEqual(2, parser.Errors.Count); AssertError("Expected expression, was 'Error'", new Position(1, 20, 1, 20), parser.Errors[0]); AssertError("Expected 'NVRParen' but was 'Error'", new Position(1, 20, 1, 20), parser.Errors[1]); // Check the TemplateNode Assert.AreEqual(1, template.Content.Count); NVReference nvReference = (NVReference)template.Content[0]; Assert.AreEqual("Ajax", nvReference.Designator.Name); Assert.AreEqual(1, nvReference.Designator.Selectors.Count); NVSelector selector = nvReference.Designator.Selectors[0]; Assert.AreEqual("LinkToRemote", selector.Name); Assert.AreEqual(0, selector.Actuals.Count); }
private DynamicTemplate(JinjaEnvironment environment, TemplateNode templateNode, string?templateName, string?templatePath) { TemplateNode = templateNode; Environment = environment; TemplateName = templateName; TemplatePath = templatePath; }
private void AddItemsFromScope(TemplateNode templateNode, int cursorLine, int cursorCol) { Scope scope = templateNode.GetScopeAt(cursorLine, cursorCol); while (scope != null) { foreach (KeyValuePair<string, NVIdNode> identifier in scope.GetIdentifiers()) { ListViewItem item = new ListViewItem(identifier.Value.Name); if (identifier.Value.Type != null) item.SubItems.Add(identifier.Value.Type.Name); if (identifier.Value is NVClassNode) item.ImageKey = TypeImage.Class.ToString(); else if (identifier.Value is NVLocalNode) item.ImageKey = TypeImage.Variable.ToString(); else item.ImageKey = TypeImage.Error.ToString(); scopeListView.Items.Add(item); } scope = scope.OuterScope; if (scope != null) { scopeListView.Items.Add("--- Parent Scope ---"); } } }
public TemplateNode GetTemplateNode(string alias) { //first get all template objects var allTemplates = GetAll().ToArray(); var selfTemplate = allTemplates.SingleOrDefault(x => x.Alias == alias); if (selfTemplate == null) { return(null); } var top = selfTemplate; while (top.MasterTemplateAlias.IsNullOrWhiteSpace() == false) { top = allTemplates.Single(x => x.Alias == top.MasterTemplateAlias); } var topNode = new TemplateNode(allTemplates.Single(x => x.Id == top.Id)); var childTemplates = allTemplates.Where(x => x.MasterTemplateAlias == top.Alias); //This now creates the hierarchy recursively topNode.Children = CreateChildren(topNode, childTemplates, allTemplates); //now we'll return the TemplateNode requested return(FindTemplateInTree(topNode, alias)); }
public TemplateNode ParseTemplate() { // Template -> XmlProlog { Content } EOF. TemplateNode templateNode = new TemplateNode(); ParseXmlProlog(); while (!_scanner.EOF) { List <AstNode> content = ParseContent(); templateNode.AddRange(content); // This check ensures that if the parse isn't returning at nodes them the parser is stuck so terminate if (content.Count == 0) { if (!_scanner.EOF) { AddError("The parser has been pre-emptively terminated because it appears as if the parser is stuck. [In ParseTemplate()]"); } break; } } return(templateNode); }
public void ParseXmlElementWithSingleQuotesAroundAttribute() { ScannerOptions scannerOptions = new ScannerOptions(); scannerOptions.EnableIntelliSenseTriggerTokens = true; Parser parser = GetNewParser(scannerOptions, "<tag attr='value'/>"); TemplateNode template = parser.ParseTemplate(); // Template has 1 XML Element XmlElement xmlElement = (XmlElement)template.Content[0]; // Element has 1 Attribute Assert.AreEqual(1, xmlElement.Attributes.Count); XmlAttribute xmlAttribute = (XmlAttribute)xmlElement.Attributes[0]; Assert.AreEqual("attr", xmlAttribute.Name); // Element has 1 XML text node Assert.AreEqual(1, xmlAttribute.Content.Count); XmlTextNode xmlTextNode = (XmlTextNode)xmlAttribute.Content[0]; Assert.AreEqual("value", xmlTextNode.Text); AssertNoErrors(parser); }
public void ParsePartialNVReferenceWithDollarIdentDotInXmlElement() { ScannerOptions scannerOptions = new ScannerOptions(); scannerOptions.EnableIntelliSenseTriggerTokens = true; Parser parser = GetNewParser( "<tag>\n" + " $Ajax.\n" + "</tag>"); TemplateNode templateNode = parser.ParseTemplate(); // Check the TemplateNode Assert.AreEqual(1, templateNode.Content.Count); XmlElement xmlElement = (XmlElement)templateNode.Content[0]; NVReference nvReference = (NVReference)xmlElement.Content[1]; Assert.AreEqual("Ajax", nvReference.Designator.Name); Assert.AreEqual(1, nvReference.Designator.Selectors.Count); AssertPosition(new Position(1, 1, 3, 7), xmlElement.Position); AssertPosition(new Position(2, 3, 2, 9), nvReference.Position); AssertPosition(new Position(2, 3, 2, 9), nvReference.Designator.Position); AssertPosition(new Position(2, 8, 2, 9), nvReference.Designator.Selectors[0].Position); }
public void XmlAttributeIsNotCompleteWhenSyntaxicallyIncomplete() { Parser parser = GetNewParser("<tag attr="); TemplateNode templateNode = parser.ParseTemplate(); Assert.IsFalse(((XmlElement)templateNode.Content[0]).IsComplete); }
public void Build(string xml) { using (StringReader stringReader = new StringReader(xml)) { XmlReaderSettings settings = new XmlReaderSettings { NameTable = new NameTable(), IgnoreComments = true }; XmlNamespaceManager xmlns = new XmlNamespaceManager(settings.NameTable); xmlns.AddNamespace(BindELAttributePrefix, "Rockyfi.ShadowPlay"); XmlParserContext context = new XmlParserContext(null, xmlns, "", XmlSpace.Default); XmlReader reader = XmlReader.Create(stringReader, settings, context); xmlDocument = new XmlDocument(); xmlDocument.Load(reader); var rootElement = xmlDocument.FirstChild; if (rootElement.Attributes != null) { if (rootElement.Attributes.GetNamedItem(ForELAttributeName) != null) { throw new Exception("root element should not contains 'el-for' attribute !"); } if (rootElement.Attributes.GetNamedItem(ForELAttributeName) != null) { throw new Exception("root element should not contains 'el-if' attribute !"); } } // convert to tree templateRoot = ConvertXmlToTemplate(rootElement); } }
public TemplateNode ParseTemplate() { // Template -> XmlProlog { Content } EOF. TemplateNode templateNode = new TemplateNode(); ParseXmlProlog(); while (!_scanner.EOF) { List<AstNode> content = ParseContent(); templateNode.AddRange(content); // This check ensures that if the parse isn't returning at nodes them the parser is stuck so terminate if (content.Count == 0) { if (!_scanner.EOF) { AddError("The parser has been pre-emptively terminated because it appears as if the parser is stuck. [In ParseTemplate()]"); } break; } } return templateNode; }
public void ParseForeachDirective() { Parser parser = GetNewParser( "#foreach($item in $collection)text here#end text"); TemplateNode templateNode = parser.ParseTemplate(); // Do semantic checks so the scope is populated templateNode.DoSemanticChecks(new ErrorHandler()); // Check Template Assert.AreEqual(2, templateNode.Content.Count); Assert.AreEqual(" text", ((XmlTextNode)templateNode.Content[1]).Text); // Check NVForeachDirective NVForeachDirective foreachDirective = (NVForeachDirective)templateNode.Content[0]; AssertPosition(new Position(1, 1, 1, 44), foreachDirective.Position); Assert.AreEqual("item", foreachDirective.Iterator); //TODO: Assert.AreEqual("collection", ((NVDesignatorExpression)foreachDirective.Collection).Designator.Name); // Check directive content Assert.AreEqual(1, foreachDirective.Content.Count); Assert.AreEqual("text here", ((XmlTextNode)foreachDirective.Content[0]).Text); // Check iterator variable is only in the foreach scope Assert.IsFalse(templateNode.Scope.Exists("item")); Assert.IsTrue(foreachDirective.Scope.Exists("item")); AssertNoErrors(parser); }
/// <summary> /// Given a template node in a tree, this will find the template node with the given alias if it is found in the hierarchy, otherwise null /// </summary> /// <param name="anyNode"></param> /// <param name="alias"></param> /// <returns></returns> public TemplateNode FindTemplateInTree(TemplateNode anyNode, string alias) { using (var repository = _repositoryFactory.CreateTemplateRepository(_dataUowProvider.GetUnitOfWork())) { return repository.FindTemplateInTree(anyNode, alias); } }
public bool TryMatch(string path, out ParamCollection @params) { @params = new ParamCollection(); var breaked = path.Split('/').Where(n => !string.IsNullOrWhiteSpace(n)); int i = 0; if (breaked.Count() != template_breaked.Count) { @params = null; return(false); } foreach (var b in breaked) { TemplateNode template = template_breaked[i]; if (template.IsTemplate) { string key = template.Key; string value = b; @params.Add(key, b); } else { if (template.Key != b) { @params = null; return(false); } } i++; } return(true); }
public void Transform(TemplateNode item) { foreach (var child in item.Children) { child.Transform(this); } }
RuntimeAttribute CreateRuntimeNodeAttribute(Node node, TemplateNode tnode) { var ra = new RuntimeAttribute(node, tnode); node.Context = ra; return(ra); }
///-------------------------------------------------------------------------------- /// <summary>Create the instance with the designer view and other data.</summary> /// /// <param name="templateName">The template name.</param> /// <param name="templateType">The template type.</param> /// <param name="ast">The abstract syntax tree reults.</param> /// <param name="sampleCode">Sample code from interpreter.</param> ///-------------------------------------------------------------------------------- public CodeTemplateResultsViewModel(string templateName, InterpreterTypeCode templateType, TemplateNode ast, string sampleCode) { Name = templateName; TemplateType = templateType; ResultsAST = ast; SampleCode = sampleCode; WorkspaceID = Guid.NewGuid(); }
public TemplateNode FindTemplateInTree(TemplateNode anyNode, string alias) { using (var uow = UowProvider.GetUnitOfWork(readOnly: true)) { var repository = RepositoryFactory.CreateTemplateRepository(uow); return(repository.FindTemplateInTree(anyNode, alias)); } }
public IEnumerable <ASTNode> Transform(TemplateNode item) { yield return(item); foreach (var child in TransformAll(item.Children)) { yield return(child); } }
public void XmlElementIsCompleteWhenSyntaxicallyCorrect() { Parser parser = GetNewParser("<tag></tag>"); TemplateNode templateNode = parser.ParseTemplate(); Assert.IsTrue(((XmlElement)templateNode.Content[0]).IsComplete); AssertNoErrors(parser); }
TemplateNode ConvertXmlToTemplate(XmlNode element) { TemplateNode renderTreeNode = new TemplateNode(element.Name); foreach (XmlAttribute attr in element.Attributes) { if (ForELAttributeName.Equals(attr.Name)) // process el-for { renderTreeNode.forExpress = ForDataBindExpress.Parse(attr.Value); } else if (IfELAttributeName.Equals(attr.Name)) // process el-if { renderTreeNode.ifExpress = IfDataBindExpress.Parse(attr.Value); } //else if (OnceELAttributeName.Equals(attr.Name)) // process el-once //{ // var onceExpress = OnceDataBindExpress.Parse(attr.Value); // if (onceExpress != null) // { // renderTreeNode.onceExpressList.AddLast(onceExpress); // } //} else if (BindELAttributePrefix.Equals(attr.Prefix)) // process el-bind:width="item.width" { var attrExpress = AttributeDataBindExpress.Parse(attr.Value, attr.LocalName); if (attrExpress != null) { renderTreeNode.attributeDataBindExpressList.AddLast(attrExpress); } } else { // try process style ProcessTemplateStyle(renderTreeNode.nodeStyle, attr.Name, attr.Value); } renderTreeNode.attributes[attr.Name] = attr.Value; } // process children // render children foreach (XmlNode ele in element.ChildNodes) { if (XmlNodeType.Element == ele.NodeType) { var trn = ConvertXmlToTemplate(ele); renderTreeNode.Children.Add(trn); } else if (XmlNodeType.Text == ele.NodeType) { renderTreeNode.textDataBindExpress = TextDataBindExpress.Parse(ele.Value); } } return(renderTreeNode); }
public void XmlTextNodePosition() { Parser parser = GetNewParser("this is some text"); TemplateNode templateNode = parser.ParseTemplate(); // Check XmlTextNode position XmlTextNode xmlTextNode = (XmlTextNode)templateNode.Content[0]; AssertPosition(new Position(1, 1, 1, 18), xmlTextNode.Position); }
public void ParseXmlTagOpenAsElement() { Parser parser = GetNewParser("<"); TemplateNode templateNode = parser.ParseTemplate(); // Template has 1 element Assert.AreEqual(1, templateNode.Content.Count); Assert.AreEqual("", ((XmlElement)templateNode.Content[0]).Name); AssertPosition(new Position(1, 1, 1, 2), templateNode.Content[0].Position); }
public void ParseEmptyDocument() { Parser parser = GetNewParser(""); TemplateNode template = parser.ParseTemplate(); // Template has no children Assert.AreEqual(0, template.Content.Count); AssertNoErrors(parser); }
public void Load(IEnumerable<TemplateFile> openedFiles) { var dir = Settings.Default.GetTemplateFolder(); TemplateNode root = new TemplateNode(new TemplateFolder(dir)); root.ToolTipText = dir.FullName; Nodes.Clear(); Nodes.Add(root); LoadFiles(root, dir, openedFiles); ExpandAll(); }
public void XmlElementSelfClosingPosition() { Parser parser = GetNewParser("<element />"); TemplateNode templateNode = parser.ParseTemplate(); // Check XmlElement position XmlElement xmlElement = (XmlElement)templateNode.Content[0]; AssertPosition(new Position(1, 1, 1, 12), xmlElement.Position); }
public void SingleLineCommentIsSkipped() { Parser parser = GetNewParser( "## comment"); TemplateNode template = parser.ParseTemplate(); Assert.AreEqual(0, template.Content.Count); AssertNoErrors(parser); }
Node RenderTemplateTree(TemplateNode tnode, ContextStack contextStack, object forContext) { Node node = Flex.CreateDefaultNode(); var ra = CreateRuntimeNodeAttribute(node, tnode); // set el-for value ra.forExpressItemCurrentValue = forContext; // copy style Style.Copy(node.nodeStyle, tnode.nodeStyle); // process node el-bind var originalAttrs = ra.attributes; foreach (var attr in tnode.attributeDataBindExpressList) { if (attr.TryEvaluate(contextStack, out var attrValue)) { if (originalAttrs.TryGetValue(attr, out var oldValue) && oldValue == attrValue) { // equal and not // Console.WriteLine("no need to process style"); } else { ra.attributes[attr] = attrValue; ProcessNodeStyle(node, attr.TargetName, attrValue != null ? attrValue.ToString() : ""); } } else { ra.attributes.Remove(attr); } } // process innerText if (tnode.textDataBindExpress != null) { ra.textDataBindExpressCurrentValue = tnode.textDataBindExpress.Evaluate(contextStack); } // render children ra.ResetChildren((appendChild) => { foreach (var vchild in tnode.Children) { foreach (var child in RenderTemplateTreeExpand(vchild, contextStack)) { node.AddChild(child); appendChild(vchild, child); } } }); return(node); }
public static Expression GetTemplateExpression(this TemplateNode tn, Context ctx) { return(new Instantiate( TypeName.Parse(typeof(UxTemplate).FullName), tn.GenerateScopeConstructor( simulatedType: tn.ProducedType.GetTypeName(), producedType: tn.ProducedType.GetTypeName(), ctx: ctx), new StringLiteral(tn.Case), new BooleanLiteral(tn.IsDefaultCase))); }
public TemplateNode FindTemplateInTree(TemplateNode anyNode, string alias) { //first get the root var top = anyNode; while (top.Parent != null) { top = top.Parent; } return(WalkTree(top, alias)); }
public void ParseSetDirectiveSimpleNumExpression() { Parser parser = GetNewParser("#set($x = 10)"); TemplateNode templateNode = parser.ParseTemplate(); // Check NVDirective NVDirective nvDirective = (NVDirective)templateNode.Content[0]; Assert.AreEqual("set", nvDirective.Name); AssertNoErrors(parser); }
Node RenderTemplateTreeRoot(TemplateNode tnode) { if (tnode.forExpress != null) { throw new Exception("root element should not contains 'el-for' attribute !"); } if (tnode.ifExpress != null) { throw new Exception("root element should not contains 'el-if' attribute !"); } return(RenderTemplateTree(templateRoot, GenerateContextStack(), null)); }
public void ParseReferenceWithMultipleActualParams() { Parser parser = GetNewParser("$first.second(100, 200, 300)"); TemplateNode templateNode = parser.ParseTemplate(); // NVReference with 1 selector and 1 actual param NVSelector nvSelector = ((NVReference)templateNode.Content[0]).Designator.Selectors[0]; Assert.AreEqual(3, nvSelector.Actuals.Count); Assert.AreEqual(100, ((NVNumExpression)nvSelector.Actuals[0]).Value); Assert.AreEqual(200, ((NVNumExpression)nvSelector.Actuals[1]).Value); Assert.AreEqual(300, ((NVNumExpression)nvSelector.Actuals[2]).Value); }
public void ParseReferenceWithEmptyActualParams() { Parser parser = GetNewParser("$first.second()"); TemplateNode templateNode = parser.ParseTemplate(); // NVReference with 1 selector and no actual params Assert.AreEqual(1, templateNode.Content.Count); NVReference nvReference = (NVReference)templateNode.Content[0]; Assert.AreEqual("first", nvReference.Designator.Name); Assert.AreEqual(1, nvReference.Designator.Selectors.Count); Assert.AreEqual(0, nvReference.Designator.Selectors[0].Actuals.Count); }
private void LoadAvailableColumnsTree() { if (this.currentDataSource != null) { this.selectedDataSourceNode = new DataSourceNode(); this.availableColumnsTree.Nodes.Add(this.selectedDataSourceNode); } ButtonNode node = new ButtonNode(); this.availableColumnsTree.Nodes.Add(node); ButtonNode node2 = new ButtonNode("Select", System.Design.SR.GetString("DGCol_SelectButton"), System.Design.SR.GetString("DGCol_Node_Select")); node.Nodes.Add(node2); EditCommandNode node3 = new EditCommandNode(); node.Nodes.Add(node3); ButtonNode node4 = new ButtonNode("Delete", System.Design.SR.GetString("DGCol_DeleteButton"), System.Design.SR.GetString("DGCol_Node_Delete")); node.Nodes.Add(node4); HyperLinkNode node5 = new HyperLinkNode(); this.availableColumnsTree.Nodes.Add(node5); TemplateNode node6 = new TemplateNode(); this.availableColumnsTree.Nodes.Add(node6); }
public override AuthoringScope ParseSource(ParseRequest req) { if (req == null) { throw new ArgumentNullException("req"); } Trace.WriteLine(string.Format("NVelocityLanguage.ParseSource(). Reason:{0}", req.Reason)); // Parse the input if required if (req.Reason == ParseReason.Check || req.Reason == ParseReason.DisplayMemberList || req.Reason == ParseReason.MemberSelect || req.Reason == ParseReason.MethodTip) { ErrorHandler errors = new ErrorHandler(); try { Scanner scanner = new Scanner(errors); scanner.Options.EnableIntelliSenseTriggerTokens = true; scanner.SetSource(req.Text); Parser parser = new Parser(scanner, errors); _templateNode = parser.ParseTemplate(); // Prepare the template node so that all the helpers are available PrepareTemplateNode(req.FileName); _templateNode.DoSemanticChecks(errors); } catch (ScannerError se) { req.Sink.AddError(req.FileName, "Scanner Error: " + se.Message, new TextSpan(), Severity.Error); } catch (Exception ex) { req.Sink.AddError(req.FileName, "FATAL: " + ex, new TextSpan(), Severity.Error); } finally { for (int i = 0; i < errors.Count; i++) { Error error = errors[i]; TextSpan textSpan = new TextSpan(); textSpan.iStartLine = error.Position.StartLine - 1; textSpan.iStartIndex = error.Position.StartPos - 1; textSpan.iEndLine = error.Position.EndLine - 1; textSpan.iEndIndex = error.Position.EndPos - 1; Severity severity = Severity.Fatal; if (error.Severity == ErrorSeverity.Error) severity = Severity.Error; else if (error.Severity == ErrorSeverity.Warning) severity = Severity.Warning; else if (error.Severity == ErrorSeverity.Message) severity = Severity.Hint; req.Sink.AddError(req.FileName, error.Description, textSpan, severity); } } #if DEBUG int line; int column; req.View.GetCaretPos(out line, out column); _debugForm.UpdateUI(line + 1, column + 1, _templateNode); #endif } else { //MessageBox.Show("Unparsed ParseReason: " + req.Reason); } // Perform other operations if (req.Reason == ParseReason.MethodTip) { TextSpan textSpan = new TextSpan(); textSpan.iStartLine = req.Line; textSpan.iStartIndex = req.Col - 1; textSpan.iEndLine = req.Line; textSpan.iEndIndex = req.Col; req.Sink.StartName(textSpan, ""); req.Sink.StartParameters(textSpan); Trace.WriteLine("MethodTip at line " + req.Line + " col " + req.Col); } if (req.Sink.HiddenRegions) { AddHiddenRegions(req.Sink, _templateNode.Content); req.Sink.ProcessHiddenRegions = true; } NVelocityAuthoringScope scope = new NVelocityAuthoringScope(_templateNode, req.FileName); //if (req.Sink.BraceMatching && req.Col > 30) //{ // TextSpan startBrace = new TextSpan(); // startBrace.iStartLine = req.Line; // startBrace.iStartIndex = 20; // startBrace.iEndLine = req.Line; // startBrace.iEndIndex = 21; // TextSpan endBrace = new TextSpan(); // endBrace.iStartLine = req.Line; // endBrace.iStartIndex = req.Col - 1; // endBrace.iEndLine = req.Line; // endBrace.iEndIndex = req.Col; // req.Sink.MatchPair(startBrace, endBrace, 0); //} return scope; }
private void BuildTreeViewFromAst(TemplateNode templateNode) { astTreeView.BeginUpdate(); astTreeView.Nodes.Clear(); TreeNode templateTreeNode = new TreeNode("Template"); templateTreeNode.Tag = templateNode; astTreeView.Nodes.Add(templateTreeNode); AddNodesToTree(templateNode, templateTreeNode); templateTreeNode.ExpandAll(); astTreeView.EndUpdate(); }
private void UpdateUIInUIThread(int cursorLine, int cursorCol, TemplateNode templateNode) { // Current Position currentPositionLabel.Text = string.Format("Line: {0}, Pos: {1}", cursorLine, cursorCol); // Current Node AstNode astNode = templateNode.GetNodeAt(cursorLine, cursorCol); currentNodeLabel.Text = string.Format("{0}, Pos: {1}", astNode != null ? astNode.GetType().Name : "null astNode", astNode != null ? astNode.Position.ToString() : "null astNode"); // Abstract Syntax Tree BuildTreeViewFromAst(templateNode); ApplyFormattingToTreeNodes(astTreeView.Nodes, cursorLine, cursorCol); // Current Scope scopeListView.BeginUpdate(); scopeListView.Items.Clear(); AddItemsFromScope(templateNode, cursorLine, cursorCol); scopeListView.EndUpdate(); }
public void UpdateUI(int cursorLine, int cursorCol, TemplateNode templateNode) { Invoke(_updateUIDelegate, cursorLine, cursorCol, templateNode); }
public NVelocityAuthoringScope(TemplateNode templateNode, string fileName) { _templateNode = templateNode; _fileName = fileName; }
private void LoadAvailableFieldsTree() { IDataSourceFieldSchema[] fieldSchemas = this.GetFieldSchemas(); if ((fieldSchemas != null) && (fieldSchemas.Length > 0)) { this._selectedDataSourceNode = new DataSourceNode(); this._availableFieldsTree.Nodes.Add(this._selectedDataSourceNode); this._selectedCheckBoxDataSourceNode = new BoolDataSourceNode(); this._availableFieldsTree.Nodes.Add(this._selectedCheckBoxDataSourceNode); } HyperLinkNode node = new HyperLinkNode(this); this._availableFieldsTree.Nodes.Add(node); ImageNode node2 = new ImageNode(this); this._availableFieldsTree.Nodes.Add(node2); ButtonNode node3 = new ButtonNode(this); this._availableFieldsTree.Nodes.Add(node3); CommandNode node4 = new CommandNode(this); this._availableFieldsTree.Nodes.Add(node4); CommandNode node5 = new CommandNode(this, 0, System.Design.SR.GetString("DCFEditor_Node_Edit"), 6); node4.Nodes.Add(node5); if (this.Control is GridView) { CommandNode node6 = new CommandNode(this, 2, System.Design.SR.GetString("DCFEditor_Node_Select"), 5); node4.Nodes.Add(node6); } CommandNode node7 = new CommandNode(this, 3, System.Design.SR.GetString("DCFEditor_Node_Delete"), 7); node4.Nodes.Add(node7); if (this.Control is DetailsView) { CommandNode node8 = new CommandNode(this, 1, System.Design.SR.GetString("DCFEditor_Node_Insert"), 11); node4.Nodes.Add(node8); } TemplateNode node9 = new TemplateNode(this); this._availableFieldsTree.Nodes.Add(node9); }