/// <summary>
/// Construct DateConfiguration instance from xml element.
/// </summary>
/// <param name="baseControlConfigurationElement"></param>
/// <param name="xmlParser"></param>
public DateConfiguration(XmlElement baseControlConfigurationElement, XmlParser xmlParser)
: base(baseControlConfigurationElement, xmlParser)
{
this.MaxValue = xmlParser.ParseDateTime(baseControlConfigurationElement, "@MaxLength", null);
this.MinValue = xmlParser.ParseDateTime(baseControlConfigurationElement, "@MinLength", null);
this.DefaultDate = xmlParser.ParseEnum<DefaultDateValues>(baseControlConfigurationElement, "@DefaultDate");
}
public SiteMapping(String fileName)
{
_fileName = fileName;
var parser = new XmlParser();
var content = File.Exists(fileName) ? File.ReadAllText(_fileName) : "<entries></entries>";
_xml = parser.Parse(content);
}
/// <summary>
/// Construct DecimalConfiguration instance from xml element.
/// </summary>
/// <param name="baseControlConfigurationElement"></param>
/// <param name="xmlParser"></param>
public DecimalConfiguration(XmlElement baseControlConfigurationElement, XmlParser xmlParser)
: base(baseControlConfigurationElement, xmlParser)
{
XmlElement numbericElement = baseControlConfigurationElement;
this.AllowNegative = xmlParser.ParseBoolean(numbericElement, "@AllowNegative", true);
this.DecimalPrecision = xmlParser.ParseInt(numbericElement, "@DecimalPrecision", 2);
}
public static string[] GetColumnNames(string path, string rootElementName, string rowElementName)
{
Console.Out.WriteLine("Scanning \"" + path + "\" for input field names...");
using (FileStream file = new FileStream(path, FileMode.Open))
{
XmlParser p = new XmlParser(file);
p.SkipToElement(rootElementName);
Set<string> columnNames = new Set<string>(false);
while (true)
{
p.MoveToElementNode(false);
string rowXML = p.OuterXML(rowElementName);
if (rowXML == null)
break;
XmlParser rowP = new XmlParser(rowXML);
rowP.MoveToElementNode(true);
while (rowP.MoveToElementNode(false) != null)
columnNames.Add(rowP.CurrentName);
}
return columnNames.ToArray();
}
}
/// <summary>
/// Construct RadioGroupConfiguration instance from xml element.
/// </summary>
/// <param name="baseControlConfigurationElement"></param>
/// <param name="xmlParser"></param>
public RadioGroupConfiguration(XmlElement baseControlConfigurationElement, XmlParser xmlParser)
: base(baseControlConfigurationElement, xmlParser)
{
this.Items = new Collection<RadioGroupItemConfiguration>();
XmlNodeList radioConfigurationElements = baseControlConfigurationElement.SelectNodes("p:Item", xmlParser.NamespaceManager);
foreach (XmlElement radioConfigurationElement in radioConfigurationElements.Cast<XmlElement>())
this.Items.Add(new RadioGroupItemConfiguration(radioConfigurationElement, xmlParser));
}
/// <summary>
/// Construct CheckBoxGroupConfiguration instance from xml element.
/// </summary>
/// <param name="baseControlConfigurationElement"></param>
/// <param name="xmlParser"></param>
public CheckBoxGroupConfiguration(XmlElement baseControlConfigurationElement, XmlParser xmlParser)
: base(baseControlConfigurationElement, xmlParser)
{
this.Items = new Collection<CheckBoxGroupItemConfiguration>();
XmlNodeList checkboxConfigurationElements = baseControlConfigurationElement.SelectNodes("p:Item", xmlParser.NamespaceManager);
foreach (XmlElement checkboxGroupItemConfigurationElement in checkboxConfigurationElements.Cast<XmlElement>())
this.Items.Add(new CheckBoxGroupItemConfiguration(checkboxGroupItemConfigurationElement, xmlParser));
}
/// <summary>
/// Construct BaseLayoutConfiguration instance from xml element.
/// </summary>
/// <param name="baseLayoutConfigurationElement"></param>
/// <param name="xmlParser"></param>
protected BaseLayoutConfiguration(XmlElement baseLayoutConfigurationElement, XmlParser xmlParser)
{
this.HeaderText = xmlParser.ParseString(baseLayoutConfigurationElement, "@HeaderText");
this.Collapsible = xmlParser.ParseBoolean(baseLayoutConfigurationElement, "@Collapsible", false);
this.Collapsed = xmlParser.ParseBoolean(baseLayoutConfigurationElement, "@Collapsed", false);
this.EnableBorder = xmlParser.ParseBoolean(baseLayoutConfigurationElement, "@EnableBorder", false);
this.EnableFrame = xmlParser.ParseBoolean(baseLayoutConfigurationElement, "@EnableFrame", false);
}
/// <summary>
/// Get last.fm object automatically
/// </summary>
/// <param name="method"></param>
/// <param name="parameters"></param>
/// <param name="lastfmObject"></param>
/// <param name="type"></param>
protected void AutomaticGetObject(string method, RequestParameters parameters, ref object lastfmObject, string type)
{
var request = new LastfmRequest(method, parameters);
var parser = new XmlParser(request.RequestURL);
var inner = parser.ConvertToInners().GetInnerByKey(type);
var lastfmParser = new LastfmParser();
lastfmObject = lastfmParser.SetObjectPropertiesValues(lastfmObject, inner, Session);
}
/// <summary>
/// Construct TextBoxConfiguration instance from xml element.
/// </summary>
/// <param name="baseControlConfigurationElement"></param>
/// <param name="xmlParser"></param>
public TextBoxConfiguration(XmlElement baseControlConfigurationElement, XmlParser xmlParser)
: base(baseControlConfigurationElement, xmlParser)
{
XmlElement textboxElement = baseControlConfigurationElement;
this.MaxLength = xmlParser.ParseInt(textboxElement, "@MaxLength", null);
this.MinLength = xmlParser.ParseInt(textboxElement, "@MinLength", null);
this.ValidationType = xmlParser.ParseEnum<TextBoxValidationTypes>(textboxElement, "@ValidationType");
}
public void ParseASingleEmptyProgrammerFromAnXmlFile()
{
var filename = "AcceptanceTests\\SingleEmptyProgrammer.xml";
var parser = new XmlParser(filename);
IEnumerable<Programmer> programmer = parser.Parse();
Assert.That(programmer.Single().Name, Is.EqualTo("Bill"));
}
/// <summary>
/// Overrides <see cref="XmlPacketSegment.Parse"/>,
/// parsing the current FinalListPacketSegment.
/// </summary>
/// <param name="Reader">The packet data reader.</param>
/// <param name="Container">The parent packet segment container.</param>
/// <param name="parser">The Xml packet parser.</param>
/// <returns>The parsed string.</returns>
public override string Parse(XmlParser parser, StreamHandler Reader, IXmlPacketSegmentContainer Container)
{
string content = "List of " + this.SegmentName + ":" + Environment.NewLine;
ulong i = 0;
while (Reader.BaseStream.Position < Reader.BaseStream.Length)
content += ParseList(i++, parser, Reader, this);
return content;
}
/// <summary>
/// Construct ButtonPanelConfiguration instance from xml element.
/// </summary>
/// <param name="panelElement"></param>
/// <param name="xmlParser"></param>
public ButtonPanelConfiguration(XmlElement panelElement, XmlParser xmlParser)
: base(panelElement, xmlParser)
{
this.ButtonAlignment = xmlParser.ParseEnum<HorizontalAlign>(panelElement, "@ButtonAlignment");
this.Buttons = new Collection<ButtonConfiguration>();
XmlNodeList buttonNodeList = panelElement.SelectNodes("p:Button", xmlParser.NamespaceManager);
foreach (XmlElement buttonElement in buttonNodeList.Cast<XmlElement>())
this.Buttons.Add(new ButtonConfiguration(buttonElement, xmlParser));
}
/// <summary>
/// Construct QueryPanelConfiguration instance from xml element.
/// </summary>
/// <param name="queryPanelElement"></param>
/// <param name="xmlParser"></param>
public QueryPanelConfiguration(XmlElement queryPanelElement, XmlParser xmlParser)
: base(queryPanelElement, xmlParser)
{
this.Controls = new Collection<QueryFieldConfiguration>();
foreach (XmlNode controlNode in queryPanelElement.ChildNodes)
{
XmlElement controlElement = controlNode as XmlElement;
if (controlElement != null)
this.Controls.Add(new QueryFieldConfiguration(controlElement, xmlParser));
}
}
static string GetName (XmlParser parser)
{
var namedObject = parser.Nodes.First () as INamedXObject;
Assert.NotNull (namedObject);
if (namedObject.IsNamed)
return namedObject.Name.ToString ();
var state = parser.CurrentState as XmlNameState;
Assert.NotNull (state);
return ((IXmlParserContext)parser).KeywordBuilder.ToString ();
}
public void ParseXml(XmlParser xmlparser, string nodename)
{
string rootnode = xmlparser.GetRootNode();
rootnode = rootnode + "->" + nodename + "->";
Font = LoadFont(xmlparser.GetString(rootnode + "Font"));
Text = xmlparser.GetString(rootnode + "Text");
Color = xmlparser.GetColor(rootnode + "Color");
Alpha = xmlparser.GetFloat(rootnode + "Alpha");
Scale = xmlparser.GetFloat(rootnode + "Scale");
Layer = xmlparser.GetFloat(rootnode + "Layer");
}
public void xmlParse(
string infile,
List<string> ExpectedOut
)
{
Contract.Requires(infile != null);
var x = new XmlParser();
var dictionary = new Dictionary<string, string>();
x.Add(
new String[] { "test-file", "users", "user", "name" },
dictionary,
(dict, str) => { dict["name"] = str; return null; },
(dict, str) => { return null; },
(dict, str) => { return null; }
);
x.Add(
new String[] { "test-file", "users", "user", "$name" },
dictionary,
(dict, str) => { dict["name"] = str; return null; },
(dict, str) => { return null; },
(dict, str) => { return null; }
);
x.Add(
new String[] { "test-file", "users", "user", "phone" },
dictionary,
(dict, str) => { dict["phone"] = str; return null; },
(dict, str) => { return null; },
(dict, str) => { return null; }
);
x.Add(
new String[] { "test-file", "users", "user" },
dictionary,
(dict, str) => { return null; },
(dict, str) => { dict.Clear(); return null; },
(dict, str) => {
return
(dict.ContainsKey("name") ? "name= " + dict["name"] : "") +
(dict.ContainsKey("phone") ? ", phone= " + dict["phone"] : "");
});
x.Process(infile);
if (ExpectedOut != null)
{
Assert.That(x.Error, Is.EqualTo(XmlParser<string>.Errors.None));
Assert.That(x.Output, Is.EqualTo(ExpectedOut));
}
else
{
Assert.That(x.Error, Is.EqualTo(XmlParser<string>.Errors.InvalidXml));
}
}
void createQuiz(WWW l)
{
XmlDocument quiz = new XmlDocument();
quiz.LoadXml(l.text);
//----------------QUIZ-----------------//
parseXML = new XmlParser (quiz);
quizGraph = parseXML.GetGraph();
//Start at question 1
currentNode = quizGraph.GetNodeList()[0];
quizGraph.DisplayGraph();
quizTime = true;
}
public static void Start(string configFile)
{
portals = new Dictionary<byte,Dictionary<byte, PortalInfo>>();
try { xml = new XmlParser(configFile); }
catch (Exception) { Logger.ShowError(" cannot read the portal database file.",null); return; }
XmlNodeList XMLitems = xml.Parse("portal");
Logger.ShowInfo("Portal database contains " + XMLitems.Count + " portals.",null);
for (int i = 0; i < XMLitems.Count; i++)
AddPortal(XMLitems.Item(i));
xml = null;
}
public void StateShouldBeRazorRootStateAfterCodeBlock ()
{
editor.Text =
@"@{
}
";
var parser = new XmlParser (new RazorRootState (), false);
var tracker = new DocumentStateTracker<XmlParser> (parser, editor);
editor.CaretLine = 3;
tracker.UpdateEngine ();
Assert.IsInstanceOf<RazorRootState> (tracker.Engine.CurrentState);
}
public static void Start(string configFile)
{
mobs = new Dictionary<uint, Mob>();
try { xml = new XmlParser(configFile); }
catch (Exception) { Logger.ShowError(" cannot read the Mob database file.", null); return; }
XmlNodeList XMLitems = xml.Parse("Mob");
Logger.ShowInfo("Mob database contains " + XMLitems.Count + " Mobs.", null);
for (int i = 0; i < XMLitems.Count; i++)
AddMob(XMLitems.Item(i));
xml = null;
}
/// <summary>
/// Overrides <see cref="XmlPacketSegment.Parse"/>,
/// parsing the current StaticListPacketSegment.
/// </summary>
/// <param name="Reader">The packet data reader.</param>
/// <param name="Container">The parent packet segment container.</param>
/// <param name="parser">The Xml packet parser.</param>
/// <returns>The parsed string.</returns>
public override string Parse(XmlParser parser, StreamHandler Reader, IXmlPacketSegmentContainer Container)
{
string content = "Static List (" + this.SegmentName + ": " + this.Length + ")" + Environment.NewLine;
// This looks like this:
// List (Static Count: 2) -- Header.
// 0) Member1: 1 -- These two lines are parsed
// Member2: 2 -- by the ParseList overrides.
// 1) Member1: 3
// Member2: 4
for (ulong i = 0; i < this.Length; ++i)
content += ParseList(i, parser, Reader, this);
return content;
}
/// <summary>
/// Construct CustomConfiguration instance from xml element.
/// </summary>
/// <param name="baseControlConfigurationElement"></param>
/// <param name="xmlParser"></param>
public CustomConfiguration(XmlElement baseControlConfigurationElement, XmlParser xmlParser)
: base(baseControlConfigurationElement, xmlParser)
{
string typeName = xmlParser.ParseString(baseControlConfigurationElement, "@Type");
try
{
this.Type = Kit.GetType(typeName);
}
catch (NotImplementedException exp)
{
throw new ConfigurationErrorsException(exp.Message, exp);
}
this.ResolverName = xmlParser.ParseString(baseControlConfigurationElement, "@ResolverName");
IControlValueResolverFactory controlValueResolverFactory = SpringContext.Current.GetObject<IControlValueResolverFactory>();
if(!controlValueResolverFactory.Contains(this.ResolverName))
throw new ConfigurationErrorsException(string.Format(CultureInfo.InvariantCulture, Resources.DP_ControlValueResolverUnavailable, this.ResolverName));
}
/// <summary>
/// Construct DetailPanelConfiguration instance from xml element.
/// </summary>
/// <param name="panelElement"></param>
/// <param name="xmlParser"></param>
public DetailPanelConfiguration(XmlElement panelElement, XmlParser xmlParser)
: base(panelElement, xmlParser)
{
this.typeName = xmlParser.ParseString(panelElement, "p:Type");
ValidateTypeName(this.typeName);
this.SkinPath = xmlParser.ParseString(panelElement, "p:SkinPath");
this.Width = xmlParser.ParseInt(panelElement, "@Width", 960);
this.Height = xmlParser.ParseInt(panelElement, "@Height", 600);
this.Resizable = xmlParser.ParseBoolean(panelElement, "@Resizable", false);
this.Draggable = xmlParser.ParseBoolean(panelElement, "@Draggable", false);
this.ShowMessageAfterSavedSuccessfully = xmlParser.ParseBoolean(panelElement, "@ShowMessageAfterSavedSuccessfully", true);
this.SetFocusOnFirstInputControlAutomatically = xmlParser.ParseBoolean(panelElement, "@SetFocusOnFirstInputControlAutomatically", true);
short defaultFormButtons = 0;
XmlElement saveAndAddAnotherButtonElement = panelElement.SelectSingleNode("p:SaveAndAddAnotherButton", xmlParser.NamespaceManager) as XmlElement;
if (saveAndAddAnotherButtonElement != null)
{
this.SaveAndAddAnotherButton = new FormPanelButtonConfiguration(saveAndAddAnotherButtonElement, xmlParser);
this.SaveAndAddAnotherButton.Text = this.SaveAndAddAnotherButton.Text ?? Resources.DPCtrl_SaveAndAddAnotherText;
if (this.SaveAndAddAnotherButton.IsFormDefaultButton) defaultFormButtons++;
}
XmlElement saveAndCloseButtonElement = panelElement.SelectSingleNode("p:SaveAndCloseButton", xmlParser.NamespaceManager) as XmlElement;
if (saveAndCloseButtonElement != null)
{
this.SaveAndCloseButton = new FormPanelButtonConfiguration(saveAndCloseButtonElement, xmlParser);
this.SaveAndCloseButton.Text = this.SaveAndCloseButton.Text ?? Resources.DPCtrl_SaveAndCloseText;
if (this.SaveAndCloseButton.IsFormDefaultButton) defaultFormButtons++;
}
XmlElement cancelButtonElement = panelElement.SelectSingleNode("p:CancelButton", xmlParser.NamespaceManager) as XmlElement;
if (cancelButtonElement != null)
{
this.CancelButton = new FormPanelButtonConfiguration(cancelButtonElement, xmlParser);
this.CancelButton.Text = this.CancelButton.Text ?? Resources.DPCtrl_CancelText;
if (this.CancelButton.IsFormDefaultButton) defaultFormButtons++;
}
if (defaultFormButtons > 1)
throw new ConfigurationErrorsException(@"The buttons with attribute ""IsFormDefaultButton"" equals to true should be one at maximum.");
}
/// <summary>
/// Parses one list element.
/// </summary>
/// <param name="Reader">The packet data reader.</param>
/// <param name="List">Current list.</param>
/// <param name="index">Index of the current element.</param>
/// <param name="parser">The Xml packet parser.</param>
/// <returns>The parsed string.</returns>
public string ParseList(ulong index, XmlParser parser, StreamHandler Reader, ListPacketSegment List)
{
// 1) Member1: 3
// Member2: 4
string content = index.ToString().PadLeft(3) + ") ";
bool first = true;
foreach (XmlPacketSegment segment in List.GetContainedSegments())
{
if (!first)
content += string.Empty.PadRight(5);
else
first = false;
content += segment.Parse(parser, Reader, List).PadMultiline(5) + Environment.NewLine;
}
return content;
}
public override ParsedDocument Parse (bool storeAst, string fileName, TextReader content, MonoDevelop.Projects.Project project = null)
{
var doc = new XmlParsedDocument (fileName);
doc.Flags |= ParsedDocumentFlags.NonSerializable;
try {
var xmlParser = new XmlParser (new XmlRootState (), true);
xmlParser.Parse (content);
doc.XDocument = xmlParser.Nodes.GetRoot ();
doc.Add (xmlParser.Errors);
if (doc.XDocument != null && doc.XDocument.RootElement != null) {
if (!doc.XDocument.RootElement.IsEnded)
doc.XDocument.RootElement.End (xmlParser.Location);
}
}
catch (Exception ex) {
MonoDevelop.Core.LoggingService.LogError ("Unhandled error parsing xml document", ex);
}
return doc;
}
public override System.Threading.Tasks.Task<ParsedDocument> Parse (ParseOptions parseOptions, System.Threading.CancellationToken cancellationToken)
{
var doc = new MonoDevelop.Xml.Editor.XmlParsedDocument (parseOptions.FileName);
doc.Flags = ParsedDocumentFlags.NonSerializable;
try {
var xmlParser = new XmlParser (
new XmlRootState (new HtmlTagState (), new HtmlClosingTagState (true)),
true);
xmlParser.Parse (parseOptions.Content.CreateReader ());
doc.XDocument = xmlParser.Nodes.GetRoot ();
doc.AddRange (xmlParser.Errors);
if (doc.XDocument != null)
doc.AddRange (Validate (doc.XDocument));
}
catch (Exception ex) {
MonoDevelop.Core.LoggingService.LogError ("Unhandled error parsing HTML document", ex);
}
return System.Threading.Tasks.Task.FromResult((ParsedDocument)doc);
}
public override void Initialize ()
{
base.Initialize ();
UpdateOwnerProjects ();
var parser = new XmlParser (CreateRootState (), false);
tracker = new DocumentStateTracker<XmlParser> (parser, Editor);
Document.DocumentParsed += UpdateParsedDocument;
if (Document.ParsedDocument != null) {
lastCU = Document.ParsedDocument;
OnParsedDocumentUpdated ();
}
if (IdeApp.Workspace != null) {
IdeApp.Workspace.FileAddedToProject += HandleProjectChanged;
IdeApp.Workspace.FileRemovedFromProject += HandleProjectChanged;
}
}
public override System.Threading.Tasks.Task<ParsedDocument> Parse (ParseOptions parseOptions, System.Threading.CancellationToken cancellationToken)
{
var doc = new XmlParsedDocument (parseOptions.FileName);
doc.Flags |= ParsedDocumentFlags.NonSerializable;
try {
var xmlParser = new XmlParser (new XmlRootState (), true);
xmlParser.Parse (parseOptions.Content.CreateReader ());
doc.XDocument = xmlParser.Nodes.GetRoot ();
// TODO error conversion!
//doc.Add (xmlParser.Errors);
if (doc.XDocument != null && doc.XDocument.RootElement != null) {
if (!doc.XDocument.RootElement.IsEnded)
doc.XDocument.RootElement.End (xmlParser.Location);
}
}
catch (Exception ex) {
MonoDevelop.Core.LoggingService.LogError ("Unhandled error parsing xml document", ex);
}
return System.Threading.Tasks.Task.FromResult((ParsedDocument)doc);
}
/// <summary>
/// Construct QueryFieldConfiguration instance from xml element.
/// </summary>
/// <param name="queryFieldControlElement"></param>
/// <param name="xmlParser"></param>
public QueryFieldConfiguration(XmlElement queryFieldControlElement, XmlParser xmlParser)
{
this.FieldName = xmlParser.ParseString(queryFieldControlElement, "@FieldName");
this.Operator = xmlParser.ParseEnum<QueryFieldOperators>(queryFieldControlElement, "@Operator");
this.Occupation = xmlParser.ParseInt(queryFieldControlElement, "@Occupation", -1);
string fieldValueTypeName = xmlParser.ParseString(queryFieldControlElement, "@FieldValueType");
if (!Kit.IsEmpty(fieldValueTypeName))
{
try
{
this.FieldValueType = Kit.GetType(fieldValueTypeName);
}
catch (NotImplementedException exp)
{
throw new ConfigurationErrorsException(exp.Message, exp);
}
}
this.Control = BaseControlConfiguration.Create(queryFieldControlElement, xmlParser);
this.Occupation = QueryFieldControlFactory.CalculateQueryControlOccupation(this);
}
/// <summary>
/// Construct ButtonConfiguration instance from xml element.
/// </summary>
/// <param name="buttonElement"></param>
/// <param name="xmlParser"></param>
public ButtonConfiguration(XmlElement buttonElement, XmlParser xmlParser)
{
this.Css = xmlParser.ParseString(buttonElement, "@Css");
this.Text = xmlParser.ParseString(buttonElement, "@Text");
this.ToolTip = xmlParser.ParseString(buttonElement, "@ToolTip");
this.ImageUrl = xmlParser.ParseString(buttonElement, "@ImageUrl");
this.CommandArgument = xmlParser.ParseString(buttonElement, "@CommandArgument");
if(protectedCommandArguments.Contains(this.CommandArgument.ToUpperInvariant()))
throw new ConfigurationErrorsException(@"'Delete', 'Update' and 'View' are prohibited command arguments in button configuration.");
this.ButtonRenderType = xmlParser.ParseEnum<ButtonRenderTypes>(buttonElement, "@Type");
this.OnClientClick = xmlParser.ParseString(buttonElement, "p:OnClientClick");
XmlElement gridSelectionRequiredElement = buttonElement.SelectSingleNode("p:GridSelectionRequired", xmlParser.NamespaceManager) as XmlElement;
if (gridSelectionRequiredElement != null)
{
this.GridSelectionRequired = true;
this.GridSelectionRequiredWarningMessage = xmlParser.ParseString(gridSelectionRequiredElement, "@WarningMessage");
}
}
/// <summary>
/// set openWin
/// </summary>
/// <param name="valueStr"></param>
private void setOpenWin(String valueStr)
{
_openWin = XmlParser.getBoolean(valueStr);
}
public void SuccessTest5()
{
string text = "<a foo=''";
Assert.AreEqual(String.Empty, XmlParser.GetAttributeValueAtIndex(text, text.Length - 1));
}
public void DotCharIsValidAttributeValueChar()
{
Assert.IsTrue(XmlParser.IsAttributeValueChar('.'));
}
public void SuccessTest2()
{
string text = "<a foo=\"abc\"";
Assert.AreEqual("abc", XmlParser.GetAttributeValueAtIndex(text, text.Length - 1));
}
public OpenEditorScreenMessage(string filePath, XmlParser parser)
{
FilePath = filePath;
Parser = parser;
}
public void SetValueByPath(string path, object value)
{
XmlParser.SetValueByPath(this.Configuration, path, value);
}
public object GetValueByKey(string key)
{
return(XmlParser.GetValueByKey(this.xmlHt, key));
}
public void EqualsSignTest()
{
string xml = "<foo a=";
Assert.IsFalse(XmlParser.IsInsideAttributeValue(xml, xml.Length));
}
public void DoubleQuotesTest5()
{
string xml = "<foo a=\"\"";
Assert.IsTrue(XmlParser.IsInsideAttributeValue(xml, 8));
}
public void NoXmlElementStart()
{
string xml = "foo a=\"";
Assert.IsFalse(XmlParser.IsInsideAttributeValue(xml, xml.Length));
}
public void DoubleQuotesTest3()
{
string xml = "<foo a=\"\"";
Assert.IsFalse(XmlParser.IsInsideAttributeValue(xml, xml.Length));
}
public void InvalidString()
{
Assert.IsFalse(XmlParser.IsInsideAttributeValue(String.Empty, 10));
}
public void LeftCurlyBracketIsValidAttributeValueChar()
{
Assert.IsTrue(XmlParser.IsAttributeValueChar('{'));
}
/// <summary>
/// set AllowEvents
/// </summary>
/// <param name="valueStr"></param>
public void SetAllowEvents(String valueStr)
{
_allowEvents = XmlParser.getBoolean(valueStr);
}
/// <summary>
/// set isPrg
/// </summary>
/// <param name="valueStr"></param>
private void setIsPrg(String valueStr)
{
_isPrg = XmlParser.getBoolean(valueStr);
}
public void SingleQuoteTest1()
{
string xml = "<foo a='";
Assert.IsTrue(XmlParser.IsInsideAttributeValue(xml, xml.Length));
}
public object GetValueByPath(string path)
{
return(XmlParser.GetValueByPath(this.xmlHt, path));
}
public static object XmlToObject(string xml)
{
return(XmlParser.FromXml(RemoveComment(xml), GetRuleAlias()));
}
public static IDocument ToXmlDocument(this String sourceCode, IConfiguration configuration = null)
{
var xmlParser = new XmlParser(configuration);
return(xmlParser.Parse(sourceCode));
}
public void HashCharIsValidAttributeValueChar()
{
Assert.IsTrue(XmlParser.IsAttributeValueChar('#'));
}
void SelectPath(int depth, bool contents)
{
//clone the parser and put it in tree mode
XmlParser treeParser = tracker.Engine.GetTreeParser();
//locate the node
var path = new List <XObject> (treeParser.Nodes);
//note: list is backwards, and we want ignore the root XDocument
XObject ob = path [path.Count - (depth + 2)];
var node = ob as XNode;
var el = node as XElement;
//hoist this as it may not be cheap to evaluate (P/Invoke), but won't be changing during the loop
int textLen = Editor.Length;
//run the parser until the tag's closed, or we move to its sibling or parent
if (node != null)
{
while (node.NextSibling == null &&
treeParser.Position < textLen && treeParser.Nodes.Peek() != ob.Parent)
{
char c = Editor.GetCharAt(treeParser.Position);
treeParser.Push(c);
if (el != null && el.IsClosed && el.ClosingTag.IsComplete)
{
break;
}
}
}
else
{
while (ob.Region.End < ob.Region.Begin &&
treeParser.Position < textLen && treeParser.Nodes.Peek() != ob.Parent)
{
char c = Editor.GetCharAt(treeParser.Position);
treeParser.Push(c);
}
}
if (el == null)
{
LoggingService.LogDebug("Selecting {0}", ob.Region);
EditorSelect(ob.Region);
}
else if (el.IsClosed)
{
LoggingService.LogDebug("Selecting {0}-{1}",
el.Region.Begin, el.ClosingTag.Region.End);
contents &= !el.IsSelfClosing;
//pick out the locations, with some offsets to account for the parsing model
var s = contents? el.Region.End : el.Region.Begin;
var e = contents? el.ClosingTag.Region.Begin : el.ClosingTag.Region.End;
EditorSelect(new DocumentRegion(s, e));
}
else
{
LoggingService.LogDebug("No end tag found for selection");
}
}
public void SuccessTest7()
{
string text = "<a foo='a\"b\"c'";
Assert.AreEqual("a\"b\"c", XmlParser.GetAttributeValueAtIndex(text, text.Length - 1));
}
public void RightAngleBracketIsNotValidAttributeValueChar()
{
Assert.IsFalse(XmlParser.IsAttributeValueChar('>'));
}
/// <summary>
/// get the task attributes
/// </summary>
protected virtual bool setAttribute(string attribute, string valueStr)
{
bool isTagProcessed = true;
switch (attribute)
{
case XMLConstants.MG_ATTR_APPL_GUID:
ApplicationGuid = valueStr;
break;
case XMLConstants.MG_ATTR_PROGRAM_ISN:
ProgramIsn = Int32.Parse(valueStr);
break;
case XMLConstants.MG_ATTR_TASK_ISN:
TaskIsn = Int32.Parse(valueStr);
break;
case XMLConstants.MG_ATTR_TOOLKIT_PARENT_TASK:
if (Int32.Parse(valueStr) != 0)
{
StudioParentTask = (TaskBase)Manager.MGDataTable.GetTaskByID(valueStr);
}
IsSubtask = true;
break;
case XMLConstants.MG_ATTR_TASKID:
setTaskId(valueStr);
if (Events.ShouldLog(Logger.LogLevels.Development))
{
Events.WriteDevToLog("TASK: " + _taskTag);
}
break;
case XMLConstants.MG_ATTR_CTL_IDX:
setCtlAndCompIdx(valueStr);
break;
case XMLConstants.MG_ATTR_MAINPRG:
setMainPrg(valueStr);
break;
case XMLConstants.MG_ATTR_NULL_ARITHMETIC:
setNullArithmetic(valueStr);
break;
case XMLConstants.MG_ATTR_INTERACTIVE:
setIsInteracive(valueStr);
break;
case XMLConstants.MG_ATTR_OPEN_WIN:
setOpenWin(valueStr);
break;
case XMLConstants.MG_ATTR_ALLOW_EVENTS:
SetAllowEvents(valueStr);
break;
case XMLConstants.MG_ATTR_ISPRG:
setIsPrg(valueStr);
break;
case XMLConstants.MG_ATTR_ICON_FILE_NAME:
IconFileName = valueStr;
break;
case XMLConstants.MG_ATTR_SYS_CONTEXT_MENU:
_systemContextMenu = Int32.Parse(valueStr);
break;
case XMLConstants.MG_ATTR_PARALLEL:
IsParallel = XmlParser.getBoolean(valueStr);
break;
case XMLConstants.MG_ATTR_SORT_BY_RECENTLY_USED:
#if !PocketPC
Manager.MenuManager.WindowList.SetSortByRecentlyUsed(XmlParser.getBoolean(valueStr));
#endif
break;
default:
isTagProcessed = false;
break;
}
return(isTagProcessed);
}
/// <summary>
/// To allocate and fill inner objects of the class
/// </summary>
/// <param name = "foundTagName">possible tag name , name of object, which need be allocated</param>
/// <param name="parentForm">the form of the task that called the current task (note: NOT triggering task)</param>
protected virtual bool initInnerObjects(String foundTagName, MgFormBase parentForm)
{
XmlParser parser = Manager.GetCurrentRuntimeContext().Parser;
switch (foundTagName)
{
case XMLConstants.MG_TAG_HELPTABLE:
if (_helpTab == null)
{
_helpTab = new Helps();
}
if (Events.ShouldLog(Logger.LogLevels.Development))
{
Events.WriteDevToLog(string.Format("{0} ...", foundTagName));
}
_helpTab.fillData();
break;
case XMLConstants.MG_TAG_DVHEADER:
if (Events.ShouldLog(Logger.LogLevels.Development))
{
Events.WriteDevToLog(string.Format("{0} ...", foundTagName));
}
DataView.fillHeaderData();
break;
case XMLConstants.MG_TAG_PROP:
_propTab.fillData(this, 'T');
break;
case XMLConstants.MG_TAG_FORM:
Form = FormInitData(parentForm);
break;
case XMLConstants.MG_TAG_ASSEMBLIES:
int start = parser.getCurrIndex();
int endContext = parser.getXMLdata().IndexOf('/' + XMLConstants.MG_TAG_ASSEMBLIES,
parser.getCurrIndex());
parser.setCurrIndex(endContext);
parser.setCurrIndex2EndOfTag();
String assemblyData = parser.getXMLdata().Substring(start, parser.getCurrIndex() - start);
//read assemblies data using sax parser
try
{
var mgSAXParser = new MgSAXParser(new AssembliesSaxHandler());
mgSAXParser.Parse(assemblyData);
}
catch (Exception ex)
{
Events.WriteExceptionToLog(ex);
}
break;
case XMLConstants.MG_ATTR_MENU_CONTENT:
// set current index after tag name end
parser.setCurrIndex(parser.getXMLdata().IndexOf(XMLConstants.MG_ATTR_MENU_CONTENT, parser.getCurrIndex()) +
XMLConstants.MG_ATTR_MENU_CONTENT.Length + 1);
endContext = parser.getXMLdata().IndexOf("</" + XMLConstants.MG_ATTR_MENU_CONTENT, parser.getCurrIndex());
_menusContent = Encoding.Unicode.GetBytes(parser.getXMLsubstring(endContext));
Manager.MenuManager.getApplicationMenus(this);
parser.setCurrIndex(endContext);
parser.setCurrIndex2EndOfTag();
break;
default:
return(false);
}
return(true);
}
/// <summary>
/// set isInteractive
/// </summary>
/// <param name="valueStr"></param>
private void setIsInteracive(String valueStr)
{
IsInteractive = XmlParser.getBoolean(valueStr);
}
public void MixedQuotesTest3()
{
string xml = "<foo a=\"''";
Assert.IsTrue(XmlParser.IsInsideAttributeValue(xml, xml.Length));
}
public void SuccessTest4()
{
string text = "<a foo='abc'";
Assert.AreEqual("abc", XmlParser.GetAttributeValueAtIndex(text, text.IndexOf("abc")));
}
public void FailureTest1()
{
string text = "<a foo='a";
Assert.AreEqual(String.Empty, XmlParser.GetAttributeValueAtIndex(text, text.Length - 1));
}
public void TeatUp()
{
parser = new XmlParser();
xmlDoc = new XmlDocument();
xmlDoc.Load(path);
}
