public static DomAttribute ReadAttribute(BinaryReader reader, INameDecoder nameTable) { DomAttribute attr = new DomAttribute(); attr.Name = ReadString(reader, nameTable); attr.Region = ReadRegion(reader, nameTable); attr.AttributeTarget = (AttributeTarget)reader.ReadInt32(); attr.AttributeType = ReadReturnType(reader, nameTable); // Named argument count uint num = ReadUInt(reader, 500); string[] names = new string[num]; for (int n = 0; n < num; n++) { names [n] = ReadString(reader, nameTable); } CodeExpression[] exps = ReadExpressionArray(reader, nameTable); int i; for (i = 0; i < num; i++) { attr.AddNamedArgument(names[i], exps [i]); } for (; i < exps.Length; i++) { attr.AddPositionalArgument(exps [i]); } return(attr); }
private DomAttributeWithInitializers CreateServerDomAttribute(DomAttribute m, string property) { var result = new DomAttributeWithInitializers(); try { result.Attribute = Document.CreateAttribute(m.Name); } catch (Exception ex) { if (Failure.IsCriticalException(ex)) { throw; } else { throw HxlFailure.CannotCreateAttributeOnConversion(m.Name, ex); } } if (result.Attribute == null) { throw HxlFailure.ServerAttributeCannotBeCreated(m.Name, -1, -1); } _current.Attributes.Add(result.Attribute); AddImplicitType(result.Attribute.GetType()); return(result); }
private static void AttributeAppend(DomAttribute left, DomAttribute append) { var toElement = left.OwnerElement; var appendThunkFrag = append as HxlAttribute.ThunkFragment; if (appendThunkFrag == null) { AttributeAppend(left, append.Value); } else { toElement.Attributes.Remove(append.Name); Func <dynamic, HxlAttribute, string> thunkLeft; var leftThunkFrag = left as HxlAttribute.ThunkFragment; if (leftThunkFrag == null) { // No need to create a closure on the whole attribute string leftValue = left.Value; thunkLeft = (x, y) => leftValue; } else { thunkLeft = leftThunkFrag._action; } var attr = HxlAttribute.Combine(left.Name, thunkLeft, appendThunkFrag._action); toElement.Append(attr); } }
protected void ImplSetAttribute(DomAttribute attr) { //handle some attribute //special for some attributes switch ((WellknownName)attr.LocalNameIndex) { case WellknownName.Style: { //TODO: parse and evaluate style here //**** WebDom.Parser.CssParser miniCssParser = CssParserPool.GetFreeParser(); //parse and evaluate the ruleset CssRuleSet parsedRuleSet = miniCssParser.ParseCssPropertyDeclarationList(attr.Value.ToCharArray()); Css.BoxSpec spec = null; if (this.ParentNode != null) { spec = ((HtmlElement)this.ParentNode).Spec; } foreach (WebDom.CssPropertyDeclaration propDecl in parsedRuleSet.GetAssignmentIter()) { SpecSetter.AssignPropertyValue( _boxSpec, spec, propDecl); } CssParserPool.ReleaseParser(ref miniCssParser); } break; } }
// Appends the given value to the attribute which uses a // merging semantic like "class" private static void AttributeAppend(DomAttribute left, string appendValue) { var toElement = left.OwnerElement; var thunkFragment = left as HxlAttribute.ThunkFragment; if (thunkFragment != null) { toElement.RemoveAttribute(left.Name); var combo = HxlAttribute.Combine( left.Name, thunkFragment._action, (x, y) => appendValue); toElement.Append(combo); } else if (!string.IsNullOrWhiteSpace(left.Value)) { left.Value += " " + appendValue; } else { left.Value = appendValue; } }
public void TestDomReadWriteResourceCreateWithPersonResource() { // Arrange var serviceModel = ClrSampleData.ServiceModelWithBlogResourceTypes; var personResourceType = serviceModel.GetResourceType <Person>(); var personResourceIdentity = personResourceType.ResourceIdentityInfo; var personFirstNameAttribute = personResourceType.GetClrAttributeInfo(StaticReflection.GetMemberName <Person>(x => x.FirstName)); var personLastNameAttribute = personResourceType.GetClrAttributeInfo(StaticReflection.GetMemberName <Person>(x => x.LastName)); var personTwitterAttribute = personResourceType.GetClrAttributeInfo(StaticReflection.GetMemberName <Person>(x => x.Twitter)); var expected = ApiSampleData.PersonResource; // Act var actual = DomReadWriteResource.Create( DomType.CreateFromResourceType(personResourceType), DomId.CreateFromApiResourceIdentity(personResourceType, expected), DomAttributes.Create( DomAttribute.CreateFromApiResource(personFirstNameAttribute, expected), DomAttribute.CreateFromApiResource(personLastNameAttribute, expected), DomAttribute.CreateFromApiResource(personTwitterAttribute, expected)), DomReadWriteRelationships.Create( DomReadWriteRelationship.Create(ApiSampleData.PersonToCommentsRel, DomReadWriteLinks.Create( DomReadWriteLink.Create(Keywords.Self, DomHRef.Create(ApiSampleData.PersonToRelationshipsToCommentsHRef)), DomReadWriteLink.Create(Keywords.Related, DomHRef.Create(ApiSampleData.PersonToCommentsHRef))))), DomReadWriteLinks.Create( DomReadWriteLink.Create(Keywords.Self, DomHRef.Create(ApiSampleData.PersonHRef))), DomReadOnlyMeta.Create(ApiSampleData.ResourceMeta)); this.OutputDomTree(actual); // Assert DomReadWriteResourceAssert.Equal(expected, actual); }
public void TestDomReadWriteResourceCreateWithCommentResource() { // Arrange var serviceModel = ClrSampleData.ServiceModelWithBlogResourceTypes; var commentResourceType = serviceModel.GetResourceType <Comment>(); var commentResourceIdentity = commentResourceType.ResourceIdentityInfo; var commentBodyAttribute = commentResourceType.GetClrAttributeInfo(StaticReflection.GetMemberName <Comment>(x => x.Body)); var expected = ApiSampleData.CommentResource; // Act var actual = DomReadWriteResource.Create( DomType.CreateFromResourceType(commentResourceType), DomId.CreateFromApiResourceIdentity(commentResourceType, expected), DomAttributes.Create( DomAttribute.CreateFromApiResource(commentBodyAttribute, expected)), DomReadWriteRelationships.Create( DomReadWriteRelationship.Create(ApiSampleData.CommentToAuthorRel, DomReadWriteLinks.Create( DomReadWriteLink.Create(Keywords.Self, DomHRef.Create(ApiSampleData.CommentToRelationshipsToAuthorHRef)), DomReadWriteLink.Create(Keywords.Related, DomHRef.Create(ApiSampleData.CommentToAuthorHRef))))), DomReadWriteLinks.Create( DomReadWriteLink.Create(Keywords.Self, DomHRef.Create(ApiSampleData.CommentHRef))), DomReadOnlyMeta.Create(ApiSampleData.ResourceMeta)); this.OutputDomTree(actual); // Assert DomReadWriteResourceAssert.Equal(expected, actual); }
public void TestDomReadWriteResourceCreateWithBlogResource() { // Arrange var serviceModel = ClrSampleData.ServiceModelWithBlogResourceTypes; var blogResourceType = serviceModel.GetResourceType <Blog>(); var blogResourceIdentity = blogResourceType.ResourceIdentityInfo; var blogNameAttribute = blogResourceType.GetClrAttributeInfo(StaticReflection.GetMemberName <Blog>(x => x.Name)); var expectedBlog = ApiSampleData.BlogResource; // Act var actual = DomReadWriteResource.Create( DomType.CreateFromResourceType(blogResourceType), DomId.CreateFromApiResourceIdentity(blogResourceType, expectedBlog), DomAttributes.Create( DomAttribute.CreateFromApiResource(blogNameAttribute, expectedBlog)), DomReadWriteRelationships.Create( DomReadWriteRelationship.Create(ApiSampleData.BlogToArticlesRel, DomReadWriteLinks.Create( DomReadWriteLink.Create(Keywords.Self, DomHRef.Create(ApiSampleData.BlogToRelationshipsToArticlesHRef)), DomReadWriteLink.Create(Keywords.Related, DomHRef.Create(ApiSampleData.BlogToArticlesHRef))))), DomReadWriteLinks.Create( DomReadWriteLink.Create(Keywords.Self, DomHRef.Create(ApiSampleData.BlogHRef))), DomReadOnlyMeta.Create(ApiSampleData.ResourceMeta)); this.OutputDomTree(actual); // Assert DomReadWriteResourceAssert.Equal(expectedBlog, actual); }
protected override DomObject Convert(DomDocument document, DomAttribute attribute) { var buffer = new CodeBuffer(); RewriteExpressionSyntax.MatchVariablesAndEmit(buffer, attribute.Value); return(new HxlExpressionAttribute(attribute.Name, buffer.ToString())); }
protected override void VisitAttribute(DomAttribute attribute) { _sb.Write(attribute.Name); _sb.Write("="); _sb.Write("\""); _sb.Write(attribute.Value); _sb.Write("\""); }
protected override void VisitAttribute(DomAttribute attribute) { string parent = stack.Peek(); CurrentOutput.WriteLine("{0}.Attribute(\"{1}\", \"{2}\");", parent, CodeUtility.Escape(attribute.Name), CodeUtility.Escape(attribute.Value)); }
public static HtmlDocument ParseDocument(LayoutFarm.HtmlBoxes.HtmlHost htmlHost, ExternalHtmlTreeWalker externalTreeWalker) { HtmlDocument newdoc = new HtmlDocument(htmlHost); //start from HtmlElement domElem = (HtmlElement)newdoc.RootNode; Stack <HtmlElement> elemStack = new Stack <HtmlElement>(); HtmlElement newDomElem = null; foreach (ExternalHtmlNode node in externalTreeWalker.GetHtmlNodeIter()) { switch (node.HtmlNodeKind) { case ExternalHtmlNodeKind.EnterChildContext: { elemStack.Push(domElem); if (newDomElem != null) { domElem = newDomElem; } } break; case ExternalHtmlNodeKind.ExitChildContext: { domElem = elemStack.Pop(); } break; case ExternalHtmlNodeKind.Attribute: { node.GetAttributeNameAndValue(out string attrName, out string attrValue); DomAttribute attr = newdoc.CreateAttribute(attrName, attrValue); newDomElem.SetAttribute(attr); } break; case ExternalHtmlNodeKind.Element: newDomElem = (HtmlElement)newdoc.CreateElement(node.HtmlElementName); domElem.AddChild(newDomElem); //System.Diagnostics.Debug.WriteLine(new string(' ', node.Level) + node.HtmlElementName); break; case ExternalHtmlNodeKind.TextNode: DomTextNode textnode = newdoc.CreateTextNode(node.CurrentTextNodeContent.ToCharArray()); domElem.AddChild(textnode); //System.Diagnostics.Debug.WriteLine(new string(' ', node.Level) + node.CurrentTextNodeContent); break; case ExternalHtmlNodeKind.Document: //System.Diagnostics.Debug.WriteLine("Root"); break; } } return(newdoc); }
protected override void VisitAttribute(DomAttribute attribute) { if (attribute == null) throw new ArgumentNullException("attribute"); writer.WriteStartAttribute(attribute.Name, attribute.NamespaceUri); writer.WriteValue(attribute.Value); writer.WriteEndAttribute(); }
public override void ResetParser() { this._resultHtmlDoc = null; this.openEltStack.Clear(); this.curHtmlNode = null; this.curAttr = null; this.curTextNode = null; this.parseState = 0; this.textSnapshot = null; }
public override void ResetParser() { _resultHtmlDoc = null; _openEltStack.Clear(); _curHtmlNode = null; _curAttr = null; _curTextNode = null; _parseState = 0; _textSnapshot = null; }
public void ReadWriteAttributeTest() { DomAttribute attr = new DomAttribute(); CodePropertyReferenceExpression exp1 = new CodePropertyReferenceExpression(); exp1.TargetObject = new CodeTypeReferenceExpression("SomeType"); exp1.PropertyName = "SomeProperty"; CodeTypeOfExpression exp2 = new CodeTypeOfExpression("SomeTypeOf"); CodeBinaryOperatorExpression exp3 = new CodeBinaryOperatorExpression(); exp3.Left = new CodePrimitiveExpression("one"); exp3.Right = new CodePrimitiveExpression("two"); exp3.Operator = CodeBinaryOperatorType.Add; CodePrimitiveExpression exp4 = new CodePrimitiveExpression(37); attr.AddPositionalArgument(exp1); attr.AddPositionalArgument(exp2); attr.AddPositionalArgument(exp3); attr.AddPositionalArgument(exp4); MemoryStream ms = new MemoryStream(); BinaryWriter writer = new BinaryWriter(ms); DomPersistence.Write(writer, DefaultNameEncoder, attr); byte[] bytes = ms.ToArray(); DomAttribute result = DomPersistence.ReadAttribute(CreateReader(bytes), DefaultNameDecoder, null); Assert.AreEqual(4, result.PositionalArguments.Count); Assert.AreEqual(typeof(CodePropertyReferenceExpression), result.PositionalArguments [0].GetType()); CodePropertyReferenceExpression rexp1 = (CodePropertyReferenceExpression)result.PositionalArguments [0]; Assert.AreEqual(typeof(CodeTypeReferenceExpression), rexp1.TargetObject.GetType()); Assert.AreEqual("SomeType", ((CodeTypeReferenceExpression)rexp1.TargetObject).Type.BaseType); Assert.AreEqual("SomeProperty", rexp1.PropertyName); Assert.AreEqual(typeof(CodeTypeOfExpression), result.PositionalArguments [1].GetType()); Assert.AreEqual("SomeTypeOf", ((CodeTypeOfExpression)result.PositionalArguments [1]).Type.BaseType); Assert.AreEqual(typeof(CodeBinaryOperatorExpression), result.PositionalArguments [2].GetType()); CodeBinaryOperatorExpression rexp3 = (CodeBinaryOperatorExpression)result.PositionalArguments [2]; Assert.AreEqual(typeof(CodePrimitiveExpression), rexp3.Left.GetType()); Assert.AreEqual("one", ((CodePrimitiveExpression)rexp3.Left).Value); Assert.AreEqual(typeof(CodePrimitiveExpression), rexp3.Right.GetType()); Assert.AreEqual("two", ((CodePrimitiveExpression)rexp3.Right).Value); Assert.AreEqual(typeof(CodePrimitiveExpression), result.PositionalArguments [3].GetType()); Assert.AreEqual(37, ((CodePrimitiveExpression)result.PositionalArguments [3]).Value); }
public void SetImageSource(ImageBinder imgBinder) { DomAttribute attr = this.OwnerDocument.CreateAttribute("src", imgBinder.ImageSource); SetDomAttribute(attr); //---- if (_principalBox != null) { InternalSetImageBinder(_owner.GetImageBinder(attr.Value)); } }
protected override void VisitAttribute(DomAttribute attribute) { if (attribute == null) throw new ArgumentNullException("attribute"); sb.Append(attribute.Name); sb.Append("="); sb.Append("\""); sb.Append(attribute.Value); sb.Append("\""); }
public bool TryGetAttribute(string attrName, out DomAttribute result) { int foundIndex = this.OwnerDocument.FindStringIndex(attrName); if (foundIndex < 1) { result = null; return(false); } return((result = FindAttribute(foundIndex)) != null); }
public override void SetAttribute(DomAttribute attr) { base.SetAttribute(attr); switch ((WellknownName)attr.LocalNameIndex) { case WellknownName.Style: { //TODO: parse and evaluate style here //**** } break; } }
public void SetImageSource(string imgsrc) { //set image source DomAttribute attr = this.OwnerDocument.CreateAttribute("src", imgsrc); SetDomAttribute(attr); //---- if (_principalBox != null) { InternalSetImageBinder(_owner.GetImageBinder(attr.Value)); } }
public void NextAttribute_and_PreviousAttribute_adjacent_singleton() { DomDocument doc = new DomDocument(); var html = doc.AppendElement("html"); html.Attribute("lang", "en"); DomAttribute attr = html.Attributes[0]; Assert.Null(attr.NextAttribute); Assert.Null(attr.PreviousAttribute); }
private void InitProperty(string property, string value, DomAttributeWithInitializers withInit) { PropertyInfo prop; DomAttribute attr = withInit.Attribute; if (property == null) { var valueProp = HxlAttributeFragmentDefinition.ForComponent(attr).ValueProperty; if (valueProp == null) { valueProp = Utility.ReflectGetProperty(attr.GetType(), "Value"); } // TODO Might not have a value property (should implement an expression around the Value property) prop = valueProp; } else { // TODO Obtain line numbers prop = Utility.ReflectGetProperty(attr.GetType(), property); if (prop == null) { throw HxlFailure.ServerAttributePropertyNotFound(attr.GetType(), property, -1, -1); } } if (!HxlAttributeConverter.IsExpr(value)) { if (property == null) { withInit.Attribute.Value = value; } withInit.Initializers.Add(prop.Name, value); return; } var buffer = new ExpressionBuffer(); RewriteExpressionSyntax.MatchVariablesAndEmit(buffer, value); // TODO Could allow multiple exprs if (buffer.Parts.Count == 1) { } else { throw new NotImplementedException("ex"); } attr.AddAnnotation(new ExpressionInitializers(prop, buffer.Parts[0])); }
CssBox CreateSelectBox(DomElement domE, CssBox parentBox, BoxSpec spec, LayoutFarm.RootGraphic rootgfx, HtmlHost host) { //https://www.w3schools.com/html/html_form_elements.asp //1. as drop-down list //2. as list-box WebDom.Impl.HtmlElement htmlElem = ((WebDom.Impl.HtmlElement)domE); htmlElem.HasSpecialPresentation = true; // LayoutFarm.HtmlWidgets.HingeBox hingeBox = new LayoutFarm.HtmlWidgets.HingeBox(100, 30); //actual controller foreach (DomNode childNode in domE.GetChildNodeIterForward()) { WebDom.Impl.HtmlElement childElem = childNode as WebDom.Impl.HtmlElement; if (childElem != null) { //find a value if (childElem.WellknownElementName == WellKnownDomNodeName.option) { DomAttribute domAttr = childElem.FindAttribute("value"); if (domAttr != null) { childElem.Tag = domAttr.Value; } } hingeBox.AddItem(childElem); } } LayoutFarm.WebDom.Impl.HtmlElement hingeBoxDom = (LayoutFarm.WebDom.Impl.HtmlElement)hingeBox.GetPresentationDomNode((WebDom.Impl.HtmlDocument)domE.OwnerDocument); CssBox cssHingeBox = host.CreateBox(parentBox, hingeBoxDom, true); //create and append to the parentBox // hingeBoxDom.SetSubParentNode(domE); cssHingeBox.IsReplacement = true; htmlElem.SpecialPresentationUpdate = (o) => { if (hingeBox.NeedUpdateDom) { cssHingeBox.Clear(); host.UpdateChildBoxes(hingeBoxDom, false); } }; #if DEBUG //cssHingeBox.dbugMark1 = 1; #endif return(cssHingeBox); }
public void TestDomReadWriteResourceCreateWithArticleResourceWithResourceLinkage() { // Arrange var serviceModel = ClrSampleData.ServiceModelWithBlogResourceTypes; var articleResourceType = serviceModel.GetResourceType <Article>(); var articleTitleAttribute = articleResourceType.GetClrAttributeInfo(StaticReflection.GetMemberName <Article>(x => x.Title)); var commentResourceType = serviceModel.GetResourceType <Comment>(); var personResourceType = serviceModel.GetResourceType <Person>(); var expectedArticle = ApiSampleData.ArticleResourceWithResourceLinkage; var expectedAuthor = ApiSampleData.PersonResource; var expectedComment1 = ApiSampleData.CommentResource1; var expectedComment2 = ApiSampleData.CommentResource2; // Act var actual = DomReadWriteResource.Create( DomType.CreateFromResourceType(articleResourceType), DomId.CreateFromApiResourceIdentity(articleResourceType, expectedArticle), DomAttributes.Create( DomAttribute.CreateFromApiResource(articleTitleAttribute, expectedArticle)), DomReadWriteRelationships.Create( DomReadWriteRelationship.Create(ApiSampleData.ArticleToAuthorRel, DomReadWriteLinks.Create( DomReadWriteLink.Create(Keywords.Self, DomHRef.Create(ApiSampleData.ArticleToRelationshipsToAuthorHRef)), DomReadWriteLink.Create(Keywords.Related, DomHRef.Create(ApiSampleData.ArticleToAuthorHRef))), DomData.CreateFromResourceIdentifier( DomReadWriteResourceIdentifier.Create( DomType.CreateFromResourceType(personResourceType), DomId.CreateFromApiResourceIdentity(personResourceType, expectedAuthor)))), DomReadWriteRelationship.Create(ApiSampleData.ArticleToCommentsRel, DomReadWriteLinks.Create( DomReadWriteLink.Create(Keywords.Self, DomHRef.Create(ApiSampleData.ArticleToRelationshipsToCommentsHRef)), DomReadWriteLink.Create(Keywords.Related, DomHRef.Create(ApiSampleData.ArticleToCommentsHRef))), DomDataCollection.CreateFromResourceIdentifiers( DomReadWriteResourceIdentifier.Create( DomType.CreateFromResourceType(commentResourceType), DomId.CreateFromApiResourceIdentity(commentResourceType, expectedComment1)), DomReadWriteResourceIdentifier.Create( DomType.CreateFromResourceType(commentResourceType), DomId.CreateFromApiResourceIdentity(commentResourceType, expectedComment2))))), DomReadWriteLinks.Create( DomReadWriteLink.Create(Keywords.Canonical, DomHRef.Create(ApiSampleData.ArticleHRef)), DomReadWriteLink.Create(Keywords.Self, DomHRef.Create(ApiSampleData.ArticleHRef))), DomReadOnlyMeta.Create(ApiSampleData.ResourceMeta)); this.OutputDomTree(actual); // Assert DomReadWriteResourceAssert.Equal(expectedArticle, actual); }
public void Attribute_implies_parent_and_owner() { DomDocument doc = new DomDocument(); var html = doc.AppendElement("html"); html.Attribute("lang", "en"); DomAttribute attr = html.Attributes[0]; Assert.Same(doc, attr.OwnerDocument); Assert.Same(html, attr.OwnerElement); Assert.False(doc.UnlinkedNodes.Contains(attr)); }
private DomAttribute CreateDomAttribute(DomAttribute m) { DomAttribute attr = Document.CreateAttribute(m.Name, m.Value); if (attr == null) { throw new NotImplementedException(); } AddImplicitType(attr.GetType()); _current.Attributes.Add(attr); return(attr); }
public void RemoveSelf_implies_parent_and_owner() { DomDocument doc = new DomDocument(); var html = doc.AppendElement("html"); html.Attribute("lang", "en"); DomAttribute attr = html.Attributes[0].RemoveSelf(); Assert.Equal(0, html.Attributes.Count); Assert.Same(doc, attr.OwnerDocument); Assert.Null(attr.ParentNode); }
public override void SetAttribute(DomAttribute attr) { base.SetAttribute(attr); //to base //---------------------- switch ((WellknownName)attr.LocalNameIndex) { case WellknownName.Src: { switch (this.WellknownElementName) { case WellKnownDomNodeName.img: { if (_principalBox != null) { CssBoxImage boxImg = (CssBoxImage)_principalBox; boxImg.ImageBinder = new ImageBinder(attr.Value); boxImg.InvalidateGraphics(); } } break; } } break; case WellknownName.Style: { //TODO: parse and evaluate style here //**** WebDom.Parser.CssParser miniCssParser = CssParserPool.GetFreeParser(); //parse and evaluate the ruleset CssRuleSet parsedRuleSet = miniCssParser.ParseCssPropertyDeclarationList(attr.Value.ToCharArray()); Css.BoxSpec spec = null; if (this.ParentNode != null) { spec = ((HtmlElement)this.ParentNode).Spec; } foreach (WebDom.CssPropertyDeclaration propDecl in parsedRuleSet.GetAssignmentIter()) { SpecSetter.AssignPropertyValue( _boxSpec, spec, propDecl); } CssParserPool.ReleaseParser(ref miniCssParser); } break; } }
public bool TryGetAttribute(WellknownName wellknownHtmlName, out DomAttribute result) { var found = base.FindAttribute((int)wellknownHtmlName); if (found != null) { result = found; return true; } else { result = null; return false; } }
static bool ProcessAttribute(DomAttribute item) { // TODO Could be escaped expression (performance) if (item is HxlAttribute || (item.Value ?? string.Empty).Contains("$")) { item.Retain(); return(true); } else { return(false); } }
public bool TryGetAttribute(WellknownName wellknownHtmlName, out DomAttribute result) { var found = base.FindAttribute((int)wellknownHtmlName); if (found != null) { result = found; return(true); } else { result = null; return(false); } }
private void btnOK_Click(object sender, EventArgs e) { _InputAttributes.Clear(); foreach (DataGridViewRow row in dgvAttributes.Rows) { if (row.Index != dgvAttributes.NewRowIndex) { DomAttribute item = new DomAttribute(); item.Name = Convert.ToString(row.Cells[0].Value); item.Value = Convert.ToString(row.Cells[1].Value); _InputAttributes.Add(item); } }//foreach this.DialogResult = System.Windows.Forms.DialogResult.OK; this.Close(); }
protected virtual void VisitAttribute(DomAttribute attribute) { if (attribute == null) throw new ArgumentNullException("attribute"); DefaultVisit(attribute); }
void IDomNodeVisitor.Visit(DomAttribute attribute) { VisitAttribute(attribute); }
public void AddAttributes (MonoDevelop.Projects.Dom.AbstractMember member, Attributes optAttributes) { if (optAttributes == null || optAttributes.Attrs == null) return; foreach (var attr in optAttributes.Attrs) { DomAttribute domAttribute = new DomAttribute (); domAttribute.Name = attr.Name; domAttribute.Region = ConvertRegion (attr.Location, attr.Location); domAttribute.AttributeType = new DomReturnType (attr.Name); if (attr.PosArguments != null) { for (int i = 0; i < attr.PosArguments.Count; i++) { var val = attr.PosArguments[i].Expr as Constant; if (val == null) { continue; } domAttribute.AddPositionalArgument (new CodePrimitiveExpression (val.GetValue ())); } } if (attr.NamedArguments != null) { for (int i = 0; i < attr.NamedArguments.Count; i++) { var val = attr.NamedArguments[i].Expr as Constant; if (val == null) continue; domAttribute.AddNamedArgument (((NamedArgument)attr.NamedArguments[i]).Name, new CodePrimitiveExpression (val.GetValue ())); } } member.Add (domAttribute); } }
public void AddAttributes (MonoDevelop.Projects.Dom.AbstractMember member, Attributes optAttributes) { if (optAttributes == null || optAttributes.Attrs == null) return; foreach (var attr in optAttributes.Attrs) { DomAttribute domAttribute = new DomAttribute (); domAttribute.Name = attr.Name; domAttribute.Region = ConvertRegion (attr.Location, attr.Location); domAttribute.AttributeType = new DomReturnType (attr.Name); member.Add (domAttribute); } }
static void AddAttributes (AbstractMember member, IEnumerable<ICSharpCode.NRefactory.Ast.AttributeSection> attributes) { CodeDomVisitor domVisitor = new CodeDomVisitor (); foreach (ICSharpCode.NRefactory.Ast.AttributeSection attributeSection in attributes) { foreach (ICSharpCode.NRefactory.Ast.Attribute attribute in attributeSection.Attributes) { DomAttribute domAttribute = new DomAttribute (); domAttribute.Name = attribute.Name; domAttribute.Region = ConvertRegion (attribute.StartLocation, attribute.EndLocation); domAttribute.AttributeType = new DomReturnType (attribute.Name); member.Add (domAttribute); foreach (ICSharpCode.NRefactory.Ast.Expression exp in attribute.PositionalArguments) domAttribute.AddPositionalArgument ((CodeExpression)exp.AcceptVisitor (domVisitor, null)); foreach (ICSharpCode.NRefactory.Ast.NamedArgumentExpression nexp in attribute.NamedArguments) domAttribute.AddNamedArgument (nexp.Name, (CodeExpression)nexp.Expression.AcceptVisitor (domVisitor, null)); } } }
void LexStateChanged(HtmlLexerEvent lexEvent, int startIndex, int len) { switch (lexEvent) { case HtmlLexerEvent.CommentContent: { //var commentContent = this.textSnapshot.Copy(startIndex, len); } break; case HtmlLexerEvent.FromContentPart: { if (curTextNode == null) { curTextNode = _resultHtmlDoc.CreateTextNode( HtmlDecodeHelper.DecodeHtml(this.textSnapshot, startIndex, len)); if (curHtmlNode != null) { curHtmlNode.AddChild(curTextNode); } } else { curTextNode.AppendTextContent(HtmlDecodeHelper.DecodeHtml(this.textSnapshot, startIndex, len)); } } break; case HtmlLexerEvent.AttributeValueAsLiteralString: { //assign value and add to parent curAttr.Value = textSnapshot.Substring(startIndex, len); curHtmlNode.AddAttribute(curAttr); } break; case HtmlLexerEvent.Attribute: { string nodename = textSnapshot.Substring(startIndex, len); curAttr = this._resultHtmlDoc.CreateAttribute(null, nodename); } break; case HtmlLexerEvent.NodeNameOrAttribute: { string name = textSnapshot.Substring(startIndex, len); switch (parseState) { case 0: { //create element DomElement elem = this._resultHtmlDoc.CreateElement(null, name); if (curHtmlNode != null) { curHtmlNode.AddChild(elem); openEltStack.Push(curHtmlNode); } curHtmlNode = elem; parseState = 1;//attribute curTextNode = null; curAttr = null; waitingAttrName = null; } break; case 1: { //wait for attr value if (waitingAttrName != null) { //push waiting attr curAttr = this._resultHtmlDoc.CreateAttribute(null, waitingAttrName); curAttr.Value = ""; curHtmlNode.AddAttribute(curAttr); curAttr = null; } waitingAttrName = name; } break; case 2: { //**** //node name after open slash //TODO: review here,avoid direct string comparison if (curHtmlNode.LocalName == name) { if (openEltStack.Count > 0) { waitingAttrName = null; curTextNode = null; curAttr = null; curHtmlNode = openEltStack.Pop(); } parseState = 3; } else { //if not equal then check if current node need close tag or not if (HtmlDecodeHelper.IsSingleTag(curHtmlNode.LocalNameIndex)) { if (openEltStack.Count > 0) { waitingAttrName = null; curHtmlNode = openEltStack.Pop(); curAttr = null; curTextNode = null; } if (curHtmlNode.LocalName == name) { if (openEltStack.Count > 0) { curTextNode = null; curAttr = null; curHtmlNode = openEltStack.Pop(); waitingAttrName = null; } parseState = 3; } else { //implement err handling here! throw new NotSupportedException(); } } else { //implement err handling here! throw new NotSupportedException(); } } } break; case 4: { //attribute value as id if (curAttr != null) { curAttr.Value = name; curAttr = null; parseState = 0; waitingAttrName = null; } else { } } break; case 10: { //document node parseState = 11; //after docnodename , this may be attr of the document node this.domDocNode = (DomDocumentNode)this._resultHtmlDoc.CreateDocumentNodeElement(); domDocNode.DocNodeName = name; } break; case 11: { //doc domDocNode.AddParameter(name); } break; default: { } break; } } break; case HtmlLexerEvent.VisitCloseAngle: { //close angle of current new node //enter into its content if (parseState == 11) { //add doctype to html this._resultHtmlDoc.RootNode.AddChild(this.domDocNode); domDocNode = null; } if (waitingAttrName != null) { curAttr = this._resultHtmlDoc.CreateAttribute(null, waitingAttrName); curAttr.Value = ""; curHtmlNode.AddAttribute(curAttr); curAttr = null; } waitingAttrName = null; parseState = 0; curTextNode = null; curAttr = null; } break; case HtmlLexerEvent.VisitAttrAssign: { parseState = 4; } break; case HtmlLexerEvent.VisitOpenSlashAngle: { parseState = 2; } break; case HtmlLexerEvent.VisitCloseSlashAngle: { if (openEltStack.Count > 0) { curTextNode = null; curAttr = null; waitingAttrName = null; curHtmlNode = openEltStack.Pop(); } parseState = 0; } break; case HtmlLexerEvent.VisitOpenAngleExclimation: { parseState = 10; } break; default: { //1. visit open angle } break; } }
public void ResetParser() { this._resultHtmlDoc = null; this.openEltStack.Clear(); this.curHtmlNode = null; this.curAttr = null; this.curTextNode = null; this.parseState = 0; this.textSnapshot = null; }
void IDomValue.Initialize(DomAttribute attribute) { this.attribute = attribute; }
IEnumerable<IAttribute> ConvertAttributes (Attributes optAttributes, IMemberContext mc) { List<IAttribute> atts = new List<IAttribute> (); if (optAttributes == null || optAttributes.Attrs == null) return atts; ResolveContext ctx = new ResolveContext (mc); foreach (var section in optAttributes.Sections) { foreach (var attr in section) { DomAttribute domAttribute = new DomAttribute (); domAttribute.Name = ConvertQuoted (attr.Name); domAttribute.Region = ConvertRegion (attr.Location, attr.Location); domAttribute.AttributeType = ConvertReturnType (attr.TypeNameExpression); if (attr.PosArguments != null) { for (int i = 0; i < attr.PosArguments.Count; i++) { CodeExpression domExp; var exp = attr.PosArguments [i].Expr; if (exp is TypeOf) { TypeOf tof = (TypeOf)exp; IReturnType rt = ConvertReturnType (tof.TypeExpression); domExp = new CodeTypeOfExpression (rt.FullName); } else if (exp is Binary) { // Currently unsupported in the old dom (will be in the new dom) continue; } else if (exp is Constant) { try { var res = exp.Resolve (ctx); var val = res as Constant; if (val == null) continue; domExp = new CodePrimitiveExpression (val.GetValue ()); } catch { continue; } } else { try { domExp = ResolveMemberAccessExpression (exp); } catch { continue; } } if (domExp != null) domAttribute.AddPositionalArgument (domExp); } } if (attr.NamedArguments != null) { for (int i = 0; i < attr.NamedArguments.Count; i++) { var val = attr.NamedArguments [i].Expr as Constant; if (val == null) continue; domAttribute.AddNamedArgument (((NamedArgument)attr.NamedArguments [i]).Name, new CodePrimitiveExpression (val.GetValue ())); } } atts.Add (domAttribute); } } return atts; }
public static DomAttribute ReadAttribute (BinaryReader reader, INameDecoder nameTable, IDomObjectTable objectTable) { DomAttribute attr = new DomAttribute (); attr.Name = ReadString (reader, nameTable); attr.Region = ReadRegion (reader, nameTable); attr.AttributeTarget = (AttributeTarget)reader.ReadInt32 (); attr.AttributeType = ReadReturnType (reader, nameTable, objectTable); // Named argument count uint num = ReadUInt (reader, 500); string[] names = new string[num]; for (int n=0; n<num; n++) names [n] = ReadString (reader, nameTable); CodeExpression[] exps = ReadExpressionArray (reader, nameTable); int i; for (i=0; i<num; i++) attr.AddNamedArgument (names [i], exps [i]); for (; i<exps.Length; i++) attr.AddPositionalArgument (exps [i]); return attr; }
public void ReadWriteAttributeTest () { DomAttribute attr = new DomAttribute (); CodePropertyReferenceExpression exp1 = new CodePropertyReferenceExpression (); exp1.TargetObject = new CodeTypeReferenceExpression ("SomeType"); exp1.PropertyName = "SomeProperty"; CodeTypeOfExpression exp2 = new CodeTypeOfExpression ("SomeTypeOf"); CodeBinaryOperatorExpression exp3 = new CodeBinaryOperatorExpression (); exp3.Left = new CodePrimitiveExpression ("one"); exp3.Right = new CodePrimitiveExpression ("two"); exp3.Operator = CodeBinaryOperatorType.Add; CodePrimitiveExpression exp4 = new CodePrimitiveExpression (37); attr.AddPositionalArgument (exp1); attr.AddPositionalArgument (exp2); attr.AddPositionalArgument (exp3); attr.AddPositionalArgument (exp4); MemoryStream ms = new MemoryStream (); BinaryWriter writer = new BinaryWriter (ms); DomPersistence.Write (writer, DefaultNameEncoder, attr); byte[] bytes = ms.ToArray (); DomAttribute result = DomPersistence.ReadAttribute (CreateReader (bytes), DefaultNameDecoder); Assert.AreEqual (4, result.PositionalArguments.Count); Assert.AreEqual (typeof(CodePropertyReferenceExpression), result.PositionalArguments [0].GetType ()); CodePropertyReferenceExpression rexp1 = (CodePropertyReferenceExpression) result.PositionalArguments [0]; Assert.AreEqual (typeof(CodeTypeReferenceExpression), rexp1.TargetObject.GetType ()); Assert.AreEqual ("SomeType", ((CodeTypeReferenceExpression)rexp1.TargetObject).Type.BaseType); Assert.AreEqual ("SomeProperty", rexp1.PropertyName); Assert.AreEqual (typeof(CodeTypeOfExpression), result.PositionalArguments [1].GetType ()); Assert.AreEqual ("SomeTypeOf", ((CodeTypeOfExpression)result.PositionalArguments [1]).Type.BaseType); Assert.AreEqual (typeof(CodeBinaryOperatorExpression), result.PositionalArguments [2].GetType ()); CodeBinaryOperatorExpression rexp3 = (CodeBinaryOperatorExpression) result.PositionalArguments [2]; Assert.AreEqual (typeof(CodePrimitiveExpression), rexp3.Left.GetType ()); Assert.AreEqual ("one", ((CodePrimitiveExpression)rexp3.Left).Value); Assert.AreEqual (typeof(CodePrimitiveExpression), rexp3.Right.GetType ()); Assert.AreEqual ("two", ((CodePrimitiveExpression)rexp3.Right).Value); Assert.AreEqual (typeof(CodePrimitiveExpression), result.PositionalArguments [3].GetType ()); Assert.AreEqual (37, ((CodePrimitiveExpression)result.PositionalArguments [3]).Value); }