public XslSortEvaluator (XPathExpression select, Sort [] sorterTemplates)
{
this.select = select;
this.sorterTemplates = sorterTemplates;
PopulateConstantSorters ();
sortRunner = new XPathSorters ();
}
/// <summary>
/// Override method that performs the actual property setting from a boolean result.
/// </summary>
/// <param name="component"></param>
/// <param name="data"></param>
/// <param name="context"></param>
protected override void DoBindComponent(object component, object data, PDFDataContext context)
{
System.Xml.XPath.XPathExpression expr = this.GetExpression(data, context);
System.Xml.XPath.XPathNavigator nav;
System.Xml.XPath.XPathNodeIterator itter;
if (data is System.Xml.XPath.XPathNodeIterator)
{
itter = ((System.Xml.XPath.XPathNodeIterator)data);
nav = itter.Current;
}
else
{
nav = (System.Xml.XPath.XPathNavigator)data;
itter = context.DataStack.HasData ? context.DataStack.Current as System.Xml.XPath.XPathNodeIterator : null;
}
bool value = (bool)nav.Evaluate(expr, itter);
if (context.ShouldLogVerbose)
{
context.TraceLog.Add(TraceLevel.Verbose, "Item Binding", "Setting property '" + this.Property.Name + "' with the XPath binding expression '" + expr.Expression + "' to value '" + value + "'");
}
this.Property.SetValue(component, value, null);
}
//=====================================================================
/// <inheritdoc />
public override void Initialize(XPathNavigator configuration)
{
// Get the condition
XPathNavigator if_node = configuration.SelectSingleNode("if");
if(if_node == null)
throw new ConfigurationErrorsException("You must specify a condition using the <if> element.");
string condition_xpath = if_node.GetAttribute("condition", String.Empty);
if(String.IsNullOrEmpty(condition_xpath))
throw new ConfigurationErrorsException("You must define a condition attribute on the <if> element");
condition = XPathExpression.Compile(condition_xpath);
// Construct the true branch
XPathNavigator then_node = configuration.SelectSingleNode("then");
if(then_node != null)
true_branch = BuildAssembler.LoadComponents(then_node);
// Construct the false branch
XPathNavigator else_node = configuration.SelectSingleNode("else");
if(else_node != null)
false_branch = BuildAssembler.LoadComponents(else_node);
// Keep a pointer to the context for future use
context = this.BuildAssembler.Context;
}
public SaveComponent (BuildAssembler assembler, XPathNavigator configuration) : base(assembler, configuration) {
// load the target path format
XPathNavigator save_node = configuration.SelectSingleNode("save");
if (save_node == null) throw new ConfigurationErrorsException("When instantiating a save component, you must specify a the target file using the <save> element.");
string base_value = save_node.GetAttribute("base", String.Empty);
if (!String.IsNullOrEmpty(base_value)) {
basePath = Path.GetFullPath(Environment.ExpandEnvironmentVariables(base_value));
}
string path_value = save_node.GetAttribute("path", String.Empty);
if (String.IsNullOrEmpty(path_value)) WriteMessage(MessageLevel.Error, "Each save element must have a path attribute specifying an XPath that evaluates to the location to save the file.");
path_expression = XPathExpression.Compile(path_value);
string select_value = save_node.GetAttribute("select", String.Empty);
if (!String.IsNullOrEmpty(select_value))
select_expression = XPathExpression.Compile(select_value);
settings.Encoding = Encoding.UTF8;
string indent_value = save_node.GetAttribute("indent", String.Empty);
if (!String.IsNullOrEmpty(indent_value)) settings.Indent = Convert.ToBoolean(indent_value);
string omit_value = save_node.GetAttribute("omit-xml-declaration", String.Empty);
if (!String.IsNullOrEmpty(omit_value)) settings.OmitXmlDeclaration = Convert.ToBoolean(omit_value);
linkPath = save_node.GetAttribute("link", String.Empty);
if (String.IsNullOrEmpty(linkPath)) linkPath = "../html";
// encoding
settings.CloseOutput = true;
}
protected override void Compile (Compiler c)
{
if (c.Debugger != null)
c.Debugger.DebugCompile (this.DebugInput);
c.CheckExtraAttributes ("value-of", "select", "disable-output-escaping");
c.AssertAttribute ("select");
select = c.CompileExpression (c.GetAttribute ("select"));
disableOutputEscaping = c.ParseYesNoAttribute ("disable-output-escaping", false);
if (c.Input.MoveToFirstChild ()) {
do {
switch (c.Input.NodeType) {
case XPathNodeType.Element:
if (c.Input.NamespaceURI == XsltNamespace)
goto case XPathNodeType.SignificantWhitespace;
// otherwise element in external namespace -> ignore
break;
case XPathNodeType.Text:
case XPathNodeType.SignificantWhitespace:
throw new XsltCompileException ("XSLT value-of element cannot contain any child.", null, c.Input);
}
} while (c.Input.MoveToNext ());
}
}
//=====================================================================
/// <inheritdoc />
public override void Initialize(XPathNavigator configuration)
{
// get the condition
XPathNavigator condition_element = configuration.SelectSingleNode("switch");
if(condition_element == null)
throw new ConfigurationErrorsException("You must specify a condition using the <switch> statement with a 'value' attribute.");
string condition_value = condition_element.GetAttribute("value", String.Empty);
if(String.IsNullOrEmpty(condition_value))
throw new ConfigurationErrorsException("The switch statement must have a 'value' attribute, which is an xpath expression.");
condition = XPathExpression.Compile(condition_value);
// load the component stacks for each case
XPathNodeIterator case_elements = configuration.Select("case");
foreach(XPathNavigator case_element in case_elements)
{
string case_value = case_element.GetAttribute("value", String.Empty);
cases.Add(case_value, BuildAssembler.LoadComponents(case_element));
}
}
/// <summary>
/// Implements the following function
/// node-set exsl:node-set(object)
/// </summary>
/// <param name="o"></param>
/// <returns></returns>
public XPathNodeIterator nodeSet(object o)
{
if (o is XPathNavigator)
{
XPathNavigator nav = (XPathNavigator)o;
if (selectItself == null)
selectItself = nav.Compile(".");
return nav.Select(selectItself.Clone());
}
else if (o is XPathNodeIterator)
return o as XPathNodeIterator;
else
{
string s;
if (o is string)
s = o as string;
else if (o is bool)
s = ((bool)o)? "true" : "false";
else if (o is Double || o is Int16 || o is UInt16 || o is Int32
|| o is UInt32 || o is Int64 || o is UInt64 || o is Single || o is Decimal)
s = o.ToString();
else
return null;
//Now convert it to text node
XmlParserContext context = new XmlParserContext(null, null, null, XmlSpace.None);
XPathDocument doc = new XPathDocument(
new XmlTextReader("<d>"+s+"</d>", XmlNodeType.Element, context));
XPathNavigator nav = doc.CreateNavigator();
if (selectText == null)
selectText = nav.Compile("/d/text()");
return nav.Select(selectText.Clone());
}
}
private void AddTargets (string map, string input, string baseOutputPath, XPathExpression outputXPath, string link, XPathExpression formatXPath, XPathExpression relativeToXPath) {
XPathDocument document = new XPathDocument(map);
XPathNodeIterator items = document.CreateNavigator().Select("/*/item");
foreach (XPathNavigator item in items) {
string id = (string) item.Evaluate(artIdExpression);
string file = (string) item.Evaluate(artFileExpression);
string text = (string) item.Evaluate(artTextExpression);
id = id.ToLower();
string name = Path.GetFileName(file);
ArtTarget target = new ArtTarget();
target.Id = id;
target.InputPath = Path.Combine(input, file);
target.baseOutputPath = baseOutputPath;
target.OutputXPath = outputXPath;
if (string.IsNullOrEmpty(name)) target.LinkPath = link;
else target.LinkPath = string.Format("{0}/{1}", link, name);
target.Text = text;
target.Name = name;
target.FormatXPath = formatXPath;
target.RelativeToXPath = relativeToXPath;
targets[id] = target;
// targets.Add(id, target);
}
}
public override XPathNodeIterator Select(XPathExpression expr)
{
if (Queryables.ContainsKey(expr.Expression))
return new XPathQueryableIterator(Queryables[expr.Expression]);
return base.Select(expr);
}
//=====================================================================
/// <summary>
/// Constructor
/// </summary>
/// <param name="path">The path expression</param>
/// <param name="item">The item name expression</param>
/// <param name="parameters">The parameters expression</param>
/// <param name="attribute">The attribute name expression</param>
/// <param name="context">The context to use for the XPath expressions</param>
public SharedContentElement(string path, string item, string parameters, string attribute,
IXmlNamespaceResolver context)
{
this.Path = XPathExpression.Compile(path, context);
this.Item = XPathExpression.Compile(item, context);
this.Parameters = XPathExpression.Compile(parameters, context);
this.Attribute = XPathExpression.Compile(attribute, context);
}
static CfgXmlHelper()
{
NameTable nt = new NameTable();
nsMgr = new XmlNamespaceManager(nt);
nsMgr.AddNamespace(CfgNamespacePrefix, CfgSchemaXMLNS);
SearchFactoryExpression = XPathExpression.Compile(RootPrefixPath + ":search-factory", nsMgr);
}
public XPathSelectionIterator(XPathNavigator nav, XPathExpression expr) {
this.nav = nav.Clone();
query = ((CompiledXpathExpr) expr).QueryTree;
if (query.ReturnType() != XPathResultType.NodeSet) {
throw new XPathException(Res.Xp_NodeSetExpected);
}
query.setContext(nav.Clone());
}
public static System.Xml.XPath.XPathNodeIterator EvaluateSelectExpression(System.Xml.XPath.XPathExpression expr, PDFDataContext context)
{
throw new NotSupportedException("No Longer using the XPathDataHelper");
//if (null == expr)
// throw new ArgumentNullException("expr");
//if (null == context)
// throw new ArgumentNullException("context");
//if (false == context.DataStack.HasData)
// throw new ArgumentOutOfRangeException("context.DataStack.Current");
//if (null == context.DataStack.Current)
// throw new ArgumentNullException("context.DataStack.Current");
//object currentData = context.DataStack.Pop();
//System.Xml.XPath.XPathNodeIterator itter;
//try
//{
// //Need the current data to be an XPathNavigator
// System.Xml.XPath.XPathNavigator navigator;
// if (currentData is System.Xml.XPath.XPathNavigator)
// {
// navigator = currentData as System.Xml.XPath.XPathNavigator;
// }
// else if (currentData is System.Xml.XPath.IXPathNavigable)
// {
// System.Xml.XPath.IXPathNavigable nav = (System.Xml.XPath.IXPathNavigable)currentData;
// navigator = nav.CreateNavigator();
// }
// else
// throw new InvalidCastException(Errors.DatabindingSourceNotXPath);
// // For position() and data context relative functions we also need to provide the
// // iterator the current XPathNavigator we extracted from if available.
// System.Xml.XPath.XPathNodeIterator parentItterator;
// if (context.DataStack.HasData && context.DataStack.Current is System.Xml.XPath.XPathNodeIterator)
// parentItterator = context.DataStack.Current as System.Xml.XPath.XPathNodeIterator;
// else
// parentItterator = null;
// if (null != context.NamespaceResolver)
// expr.SetContext(context.NamespaceResolver);
// itter = navigator.Select(expr);
//}
//finally
//{
// //make sure we put the stack back to the original state.
// context.DataStack.Push(currentData, null);
//}
//return itter;
}
static XmlHelper()
{
NameTable nt = new NameTable();
XmlNamespaceManager nsMgr = new XmlNamespaceManager(nt);
nsMgr.AddNamespace(NamespacePrefix, SchemaXmlns);
PropertiesExpression = XPathExpression.Compile(RootPrefixPath + "properties", nsMgr);
PropertiesPropertyExpression = XPathExpression.Compile(RootPrefixPath + "properties/" + ChildPrefixPath + "property", nsMgr);
}
static CfgXmlHelper()
{
NameTable nt = new NameTable();
nsMgr = new XmlNamespaceManager(nt);
nsMgr.AddNamespace(CfgNamespacePrefix, CfgSchemaXMLNS);
SharedEngineClassExpression = XPathExpression.Compile(RootPrefixPath + Environment.SharedEngineClass, nsMgr);
PropertiesExpression = XPathExpression.Compile(RootPrefixPath + "property", nsMgr);
MappingsExpression = XPathExpression.Compile(RootPrefixPath + "mapping", nsMgr);
}
public override object Invoke(XsltContext xsltContext, object[] args, XPathNavigator docContext)
{
if (this.expr == null)
{
XPathExpression expression = docContext.Compile("(/s11:Envelope/s11:Body | /s12:Envelope/s12:Body)[1]");
expression.SetContext(XPathMessageFunction.Namespaces);
this.expr = expression;
}
return docContext.Evaluate(this.expr);
}
protected override void Compile (Compiler c)
{
if (c.Debugger != null)
c.Debugger.DebugCompile (c.Input);
c.CheckExtraAttributes ("copy-of", "select");
c.AssertAttribute ("select");
select = c.CompileExpression (c.GetAttribute ("select"));
}
public override object Invoke(XsltContext xsltContext, object[] args, XPathNavigator docContext)
{
if (this.expr == null)
{
XPathExpression expression = docContext.Compile("(sm:header()/wsa10:FaultTo | sm:header()/wsaAugust2004:FaultTo)[1]");
expression.SetContext((XmlNamespaceManager) new XPathMessageContext());
this.expr = expression;
}
return docContext.Evaluate(this.expr);
}
/// <summary>
/// This method returns an instance of <see cref="XPathQueryManagerCompiledExpressionsDecorator"/>
/// in the context of the first node the XPath expression addresses.
/// </summary>
/// <param name="xPath">The compiled XPath expression</param>
/// <param name="queryParameters">Parameters for the compiled XPath expression</param>
public override IXPathQueryManager GetXPathQueryManagerInContext(XPathExpression xPath,
DictionaryEntry[] queryParameters = null)
{
IXPathQueryManager xPathQueryManager = (queryParameters == null)
? XPathQueryManager.GetXPathQueryManagerInContext(xPath)
: XPathQueryManager.GetXPathQueryManagerInContext(xPath,
queryParameters);
if (xPathQueryManager == null) return null;
return new XPathQueryManagerCompiledExpressionsDecorator(xPathQueryManager);
}
public void CoreFunctionNodeSetLast ()
{
expression = navigator.Compile("last()");
iterator = navigator.Select("/foo");
AssertEquals ("0", navigator.Evaluate ("last()").ToString());
AssertEquals ("0", navigator.Evaluate (expression, null).ToString ());
AssertEquals ("1", navigator.Evaluate (expression, iterator).ToString ());
iterator = navigator.Select("/foo/*");
AssertEquals ("4", navigator.Evaluate (expression, iterator).ToString ());
AssertEquals("3", navigator2.Evaluate ("string(//bar[last()]/@baz)"));
}
static XmlSchemaParser()
{
XPathNavigator nav = new XmlDocument().CreateNavigator();
// Select all extension types.
Extensions = nav.Compile( "/xs:schema/xs:annotation/xs:appinfo/kzu:Code/kzu:Extension/@Type" );
// Create and set namespace resolution context.
XmlNamespaceManager nsmgr = new XmlNamespaceManager( nav.NameTable );
nsmgr.AddNamespace( "xs", XmlSchema.Namespace );
nsmgr.AddNamespace( "kzu", ExtensionNamespace );
Extensions.SetContext( nsmgr );
}
static Processor()
{
XPathNavigator nav = new XmlDocument().CreateNavigator();
// Select all extension types.
Extensions = nav.Compile("/processing-instruction('extension')");
PostExts = nav.Compile("/processing-instruction('post-process')");
// Create and set namespace resolution context.
XmlNamespaceManager nsmgr = new XmlNamespaceManager(nav.NameTable);
nsmgr.AddNamespace("xs", XmlSchema.Namespace);
nsmgr.AddNamespace("kzu", ExtensionNamespace);
Extensions.SetContext(nsmgr);
}
/// <summary>
/// Selects a node set, using the specified XPath expression.
/// </summary>
/// <param name="navigator">A source XPathNavigator.</param>
/// <param name="expression">An XPath expression.</param>
/// <param name="variables">A set of XPathVariables.</param>
/// <returns>An iterator over the nodes matching the specified expression.</returns>
public static XPathNodeIterator Select(this XPathNavigator navigator, XPathExpression expression, params XPathVariable[] variables)
{
if (variables == null || variables.Length == 0 || variables[0] == null)
return navigator.Select(expression);
var compiled = expression.Clone(); // clone for thread-safety
var context = new DynamicContext();
foreach (var variable in variables)
context.AddVariable(variable.Name, variable.Value);
compiled.SetContext(context);
return navigator.Select(compiled);
}
public override bool Match(MessageBuffer buffer)
{
if (_filterExpression == null)
{
_filterExpression = XPathExpression.Compile($"////value == {_filterParam}");
}
XPathNavigator navigator = buffer.CreateNavigator();
return navigator.Matches(_filterExpression);
//XDocument doc = await GetMessageEnvelope(buffer);
//return Match(doc);
}
protected override void Compile (Compiler c)
{
if (c.Debugger != null)
c.Debugger.DebugCompile (c.Input);
c.CheckExtraAttributes ("apply-templates", "select", "mode");
select = c.CompileExpression (c.GetAttribute ("select"));
mode = c.ParseQNameAttribute ("mode");
ArrayList sorterList = null;
if (c.Input.MoveToFirstChild ()) {
do {
switch (c.Input.NodeType) {
case XPathNodeType.Comment:
case XPathNodeType.ProcessingInstruction:
case XPathNodeType.Whitespace:
case XPathNodeType.SignificantWhitespace:
continue;
case XPathNodeType.Element:
if (c.Input.NamespaceURI != XsltNamespace)
throw new XsltCompileException ("Unexpected element", null, c.Input); // TODO: fwd compat
switch (c.Input.LocalName)
{
case "with-param":
if (withParams == null)
withParams = new ArrayList ();
withParams.Add (new XslVariableInformation (c));
break;
case "sort":
if (sorterList == null)
sorterList = new ArrayList ();
if (select == null)
select = c.CompileExpression ("*");
sorterList.Add (new Sort (c));
//c.AddSort (select, new Sort (c));
break;
default:
throw new XsltCompileException ("Unexpected element", null, c.Input); // todo forwards compat
}
break;
default:
throw new XsltCompileException ("Unexpected node type " + c.Input.NodeType, null, c.Input); // todo forwards compat
}
} while (c.Input.MoveToNext ());
c.Input.MoveToParent ();
}
if (sorterList != null)
sortEvaluator = new XslSortEvaluator (select,
(Sort []) sorterList.ToArray (typeof (Sort)));
}
//
// support methods
//
#region protected System.Xml.XPath.XPathExpression GetExpression(object data, PDFDataContext context)
/// <summary>
/// Converts the string expression on this instance to an actual XPathExpression with the current context
/// </summary>
/// <param name="data">The current data object on the stack</param>
/// <param name="context">The current data context</param>
/// <returns>A prepared XPath expression</returns>
protected System.Xml.XPath.XPathExpression GetExpression(object data, PDFDataContext context)
{
if (null == _compiled)
{
_compiled = System.Xml.XPath.XPathExpression.Compile(this._expr, context.NamespaceResolver);
}
else
{
_compiled.SetContext(context.NamespaceResolver);
}
return(_compiled);
}
public static bool EvaluateTestExpression(System.Xml.XPath.XPathExpression expr, PDFDataContext context)
{
throw new NotSupportedException("No Longer using the XPathDataHelper");
//object value = EvaluateValueExpression(expr, context);
//if (null == value)
// return false;
//else if (value is bool)
// return (bool)value;
//else
// return false;
}
private static void SelectIndexedNodes(XPathNavigator nav, int repeat, PerfTest perf, XPathExpression expr)
{
int counter = 0;
perf.Start();
for (int i=0; i<repeat; i++)
{
XPathNodeIterator ni = nav.Select(expr);
while (ni.MoveNext())
counter++;
}
Console.WriteLine("Indexed selection: {0} times, total time {1, 6:f2} ms, {2} nodes selected", repeat,
perf.Stop(), counter);
}
/// <summary>
/// Initializes a new instance.
/// </summary>
/// <param name="xml"></param>
/// <param name="context"></param>
/// <param name="xpath"></param>
internal Binding(XObject xml, EvaluationContext context, XPathExpression xpath)
{
Contract.Requires<ArgumentNullException>(xml != null);
Contract.Requires<ArgumentNullException>(context != null);
Contract.Requires<ArgumentNullException>(xpath != null);
this.xml = xml;
this.context = context;
this.xpath = xpath;
// initial load of values
Recalculate();
}
/// <summary>
/// Override method that performs the actual property setting from a nodeset result.
/// </summary>
/// <param name="component"></param>
/// <param name="data"></param>
/// <param name="context"></param>
protected override void DoBindComponent(object component, object data, PDFDataContext context)
{
System.Xml.XPath.XPathExpression expr = this.GetExpression(data, context);
if (data is System.Xml.XPath.XPathNodeIterator)
{
data = ((System.Xml.XPath.XPathNodeIterator)data).Current;
}
XPathNavigator nav = (System.Xml.XPath.XPathNavigator)data;
if (null == this.Converter)
{
var iterator = nav.Select(expr);
if (this.Property.PropertyType == typeof(XPathNavigator))
{
this.Property.SetValue(component, iterator.Current);
}
else
{
this.Property.SetValue(component, iterator);
}
}
else
{
nav = nav.SelectSingleNode(expr);
if (null != nav)
{
string result = nav.Value;
if (context.ShouldLogVerbose)
{
context.TraceLog.Add(TraceLevel.Verbose, "Item Binding", "Setting property '" + this.Property.Name + "' with the XPath binding expression '" + expr.Expression + "' to value '" + result + "'");
}
SetToConvertedValue(component, result, context);
}
else
{
if (context.ShouldLogVerbose)
{
context.TraceLog.Add(TraceLevel.Verbose, "Item Binding", "NULL value returned for expression '" + expr.Expression + "' so clearing property value '" + this.Property.Name + "'");
}
SetToEmptyValue(component, context);
}
}
}
public PluginUI(PluginMain pluginMain)
{
this.InitializeComponent();
this.imagelist = new ImageList();
this.imagelist.Images.Add(GetResource("Icons.ActionClosed.png"));
this.imagelist.Images.Add(GetResource("Icons.ActionOpened.png"));
this.imagelist.Images.Add(GetResource("Icons.ActionFunction.png"));
this.Documents = null;
this.treeView1.ImageList = this.imagelist;
this.pluginMain = pluginMain;
xpathExpression_1 = XPathExpression.Compile("folder|ifdef/folder|ifmode/folder");
xpathExpression_2 = XPathExpression.Compile("string|ifdef/string|ifmode/string|action|ifmode/action|ifdef/action");
}
private static void SelectNodes(XPathNavigator nav, int repeat, Stopwatch stopWatch, XPathExpression expr)
{
int counter = 0;
stopWatch.Start();
for (int i=0; i<repeat; i++)
{
XPathNodeIterator ni = nav.Select(expr);
while (ni.MoveNext())
counter++;
}
stopWatch.Stop();
Console.WriteLine("Regular selection: {0} times, total time {1, 6:f2} ms, {2} nodes selected", repeat,
stopWatch.ElapsedMilliseconds, counter);
stopWatch.Reset();
}
//
// factory methods
//
#region public static BindingXPathExpression Create(string expr, PDFValueConverter convert, System.Reflection.PropertyInfo property)
/// <summary>
/// Returns a new concrete instance of a BindingXPathExpression that can be called from a components
/// DataBinding event and set the value of the property.
/// </summary>
/// <param name="expr">The binding XPath expression to use</param>
/// <param name="convert">A value converter to change the string result into the required type.</param>
/// <param name="property">The property this expression is bound to.</param>
/// <returns>The expression that ban be attached to an event</returns>
public static BindingXPathExpression Create(string expr, PDFValueConverter convert, System.Reflection.PropertyInfo property)
{
if (null == property)
{
throw new ArgumentNullException("property");
}
if (string.IsNullOrEmpty(expr))
{
throw new ArgumentNullException("expr");
}
//Run a quick compile to validat the return type
System.Xml.XPath.XPathExpression compiled = System.Xml.XPath.XPathExpression.Compile(expr);
BindingXPathExpression binding = null;
switch (compiled.ReturnType)
{
case System.Xml.XPath.XPathResultType.Boolean:
binding = new BindingXPathBoolExpression();
break;
case System.Xml.XPath.XPathResultType.NodeSet:
binding = new BindingXPathNodeSetExpression();
break;
case System.Xml.XPath.XPathResultType.Number:
case System.Xml.XPath.XPathResultType.String:
binding = new BindingXPathValueExpression();
break;
case System.Xml.XPath.XPathResultType.Error:
throw new PDFParserException(String.Format(Errors.InvalidXPathExpression, expr));
case System.Xml.XPath.XPathResultType.Any:
default:
throw new PDFParserException(String.Format(Errors.ReturnTypeOfXPathExpressionCouldNotBeDetermined, expr));
}
binding._converter = convert;
binding._expr = expr;
binding._compiled = compiled;
binding._property = property;
return(binding);
}
/// <summary>
/// Override method that performs the actual property setting from a Navigator result.
/// </summary>
/// <param name="component"></param>
/// <param name="data"></param>
/// <param name="context"></param>
protected override void DoBindComponent(object component, object data, PDFDataContext context)
{
System.Xml.XPath.XPathExpression expr = this.GetExpression(data, context);
if (data is System.Xml.XPath.XPathNodeIterator)
{
data = ((System.Xml.XPath.XPathNodeIterator)data).Current;
}
System.Xml.XPath.XPathNavigator nav = (System.Xml.XPath.XPathNavigator)data;
if (null == this.Converter)
{
var iterator = nav.Select(expr);
if (this.Property.PropertyType == typeof(XPathNavigator))
{
this.Property.SetValue(component, iterator.Current);
}
else
{
this.Property.SetValue(component, iterator);
}
}
else
{
System.Xml.XPath.XPathNodeIterator itter = nav.Select(expr);
if (itter.CurrentPosition < 0)
{
itter.MoveNext();
}
string value = itter.Current.Value;
object converted = this.Converter(value, this.Property.PropertyType, System.Globalization.CultureInfo.CurrentCulture);
if (context.ShouldLogVerbose)
{
context.TraceLog.Add(TraceLevel.Verbose, "Item Binding", "Setting property '" + this.Property.Name + "' with the XPath binding expression '" + expr.Expression + "' to value '" + ((null == value) ? "NULL" : value) + "'");
}
this.Property.SetValue(component, converted, null);
}
}
/// <summary>
/// Override method that performs the actual property setting from a value result.
/// </summary>
/// <param name="component"></param>
/// <param name="data"></param>
/// <param name="context"></param>
protected override void DoBindComponent(object component, object data, PDFDataContext context)
{
System.Xml.XPath.XPathExpression expr = this.GetExpression(data, context);
System.Xml.XPath.XPathNavigator nav;
System.Xml.XPath.XPathNodeIterator itter;
if (data is System.Xml.XPath.XPathNodeIterator)
{
itter = ((System.Xml.XPath.XPathNodeIterator)data);
nav = itter.Current;
}
else
{
nav = (System.Xml.XPath.XPathNavigator)data;
itter = context.DataStack.HasData ? context.DataStack.Current as System.Xml.XPath.XPathNodeIterator : null;
}
object value = nav.Evaluate(expr, itter);
if (null != value)
{
string result = value.ToString();
if (context.ShouldLogVerbose)
{
context.TraceLog.Add(TraceLevel.Verbose, "Item Binding", "Setting property '" + this.Property.Name + "' with the XPath binding expression '" + expr.Expression + "' to value '" + result + "'");
}
SetToConvertedValue(component, result, context);
}
else
{
if (context.ShouldLogVerbose)
{
context.TraceLog.Add(TraceLevel.Verbose, "Item Binding", "NULL value returned for expression '" + expr.Expression + "' so clearing value '" + this.Property.Name + "'");
}
SetToEmptyValue(component, context);
}
}
/// <include file='doc\XPathNavigator.uex' path='docs/doc[@for="XPathNavigator.Evaluate"]/*' />
public virtual object Evaluate(XPathExpression expr)
{
return(Evaluate(expr, null));
}
/// <include file='doc\XPathNavigator.uex' path='docs/doc[@for="XPathNavigator.Select"]/*' />
public virtual XPathNodeIterator Select(XPathExpression expr)
{
return(new XPathSelectionIterator(this, expr));
}
public static void Init()
{
NameTable nt = new NameTable();
XmlNamespaceManager NsMgr = new XmlNamespaceManager(nt);
NsMgr.AddNamespace(XmlConstants.Namespace, XmlConstants.SchemaXMLNS);
ConfigExpression = XPathExpression.Compile("//" + XmlConstants.Namespace + ":" + XmlConstants.Setting, NsMgr);
}
public LiveExampleComponent(BuildAssembler assembler, XPathNavigator configuration)
: base(assembler, configuration) {
XPathNavigator parsnip_node = configuration.SelectSingleNode("parsnip");
string approvedFile = null;
if (parsnip_node != null) {
approvedFile = parsnip_node.GetAttribute("approved-file", String.Empty);
string omitBadExamplesValue = parsnip_node.GetAttribute("omit-bad-examples", String.Empty);
if (!string.IsNullOrEmpty(omitBadExamplesValue))
omitBadExamples = Boolean.Parse(omitBadExamplesValue);
//string runBadExamplesValue = parsnip_node.GetAttribute("run-bad-examples", String.Empty);
//if (!string.IsNullOrEmpty(runBadExamplesValue))
// runBadExamples = Boolean.Parse(runBadExamplesValue);
}
if (string.IsNullOrEmpty(approvedFile))
WriteMessage(MessageLevel.Warn, "No approved samples file specified; all available samples will be included.");
else
LoadApprovedFile(approvedFile);
context = new CustomContext();
context.AddNamespace("ddue", "http://ddue.schemas.microsoft.com/authoring/2003/5");
selector = XPathExpression.Compile("//ddue:codeReference");
selector.SetContext(context);
}
private void EditCand_Load(object sender, EventArgs e)
{
doc = new XPathDocument(FILE_NAME);
nav = doc.CreateNavigator();
// Compile a standard XPath expression
expr = nav.Compile("/config/voto/@puesto");
iterator = nav.Select(expr);
// Iterate on the node set
comboBox1.Items.Clear();
try
{
while (iterator.MoveNext())
{
XPathNavigator nav2 = iterator.Current.Clone();
comboBox1.Items.Add(nav2.Value);
comboBox1.SelectedIndex = 0;
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
//save old title
oldTitle = comboBox1.Text;
}
