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