public static TextTag GetAssociatedTextTag(TextBuffer buffer, TextTag tag) { DocumentTagTable tagTable = (DocumentTagTable)buffer.TagTable; DocumentTag elementTag = (DocumentTag)tag; string elementName = elementTag.Name; string suffix, tagName; // Check if element is dynamic: // True: We create a tagname with suffix :Text#[0-9]* so its unique. // False: We create a tagname with a standard suffix :Text if (elementTag.IsDynamic) { suffix = "#" + elementName.Split('#') [1]; tagName = elementName.Split('#')[0] + ":Text" + suffix; } else { suffix = String.Empty; tagName = elementName + ":Text"; } TextTag textTag = tagTable.Lookup(tagName); if (textTag == null) { textTag = tagTable.CreateDynamicTag(tagName); } return(textTag); }
private static void DeserializeAttributesType(TextBuffer buffer, ref TextIter insertAt, XmlTextReader xmlReader, string tagSuffix) { string tagName = String.Empty; string tagPrefix = xmlReader.Name + ":"; DocumentTagTable tagTable = (DocumentTagTable)buffer.TagTable; while (xmlReader.MoveToNextAttribute()) { tagName = tagPrefix + xmlReader.Name + tagSuffix; TextTag tag = tagTable.Lookup(tagName); if (tag == null) { tag = tagTable.CreateDynamicTag(tagName); } buffer.InsertWithTags(ref insertAt, xmlReader.Value, tag); #if DEBUG Console.WriteLine("Attribute: {0} End: {1}", tagName, insertAt.Offset); #endif } DocumentUtils.AddNewLine(buffer, ref insertAt, tagSuffix); }
public static void AddText(TextBuffer buffer, ref TextIter insertAt, string data, TextTag tag) { DocumentTagTable tagTable = (DocumentTagTable)buffer.TagTable; TextTag textTag = tagTable.Lookup("significant-whitespace" + "#" + tag.Name); if (textTag == null) { textTag = tagTable.CreateDynamicTag("significant-whitespace" + "#" + tag.Name); } string trimData = data.Trim(); int index = data.IndexOf(trimData); string startSpace = data.Substring(0, index); string prefixSpace = String.Empty; if (!startSpace.Equals(String.Empty)) { if (startSpace.Length == 1) { prefixSpace = startSpace; startSpace = String.Empty; } else { prefixSpace = startSpace.Substring(startSpace.Length - 1); startSpace = startSpace.Substring(0, startSpace.Length - 1); } } string endSpace = data.Substring(index + trimData.Length); string postSpace = String.Empty; if (!endSpace.Equals(String.Empty)) { if (endSpace.Length == 1) { if (endSpace.Equals(" ")) { postSpace = endSpace; endSpace = String.Empty; } } else { if (endSpace.Substring(0, 1).Equals(" ")) { postSpace = endSpace.Substring(0, 1); endSpace = endSpace.Substring(1); } } } buffer.InsertWithTags(ref insertAt, Escape(startSpace), textTag); buffer.InsertWithTags(ref insertAt, prefixSpace + trimData + postSpace, tag); buffer.InsertWithTags(ref insertAt, Escape(endSpace), textTag); }
public static void AddString(TextBuffer buffer, ref TextIter insertAt, string data, string suffix) { DocumentTagTable tagTable = (DocumentTagTable)buffer.TagTable; TextTag tag = tagTable.Lookup("format" + suffix); if (tag == null) { tag = tagTable.CreateDynamicTag("format" + suffix); } buffer.InsertWithTags(ref insertAt, data, tag); tag = tagTable.Lookup("format-end" + suffix); if (tag == null) { tag = tagTable.CreateDynamicTag("format-end" + suffix); } buffer.InsertWithTags(ref insertAt, " ", tag); }
public void TestCreateDynamicTag () { DocumentTagTable tagTable = new DocumentTagTable (); TextTag expectedTag = tagTable.Lookup ("format#0"); Assert.IsNull (expectedTag, "CDT01"); TextTag actualTag = tagTable.CreateDynamicTag ("format#0"); expectedTag = tagTable.Lookup ("format#0"); Assert.AreEqual (expectedTag, actualTag, "CDT02"); }
public static void AddPaddingEmpty(TextBuffer buffer, ref TextIter insertAt, string suffix) { DocumentTagTable tagTable = (DocumentTagTable)buffer.TagTable; TextTag tag = tagTable.Lookup("padding-empty" + suffix); if (tag == null) { tag = tagTable.CreateDynamicTag("padding-empty" + suffix); } buffer.InsertWithTags(ref insertAt, " ", tag); }
public static void AddNewLine(TextBuffer buffer, ref TextIter insertAt, string suffix) { DocumentTagTable tagTable = (DocumentTagTable)buffer.TagTable; TextTag tag = tagTable.Lookup("newline" + suffix); if (tag == null) { tag = tagTable.CreateDynamicTag("newline" + suffix); } buffer.InsertWithTags(ref insertAt, "\n", tag); }
private static int DeserializeAttributes(TextBuffer buffer, int offset, XmlTextReader xmlReader, string tagSuffix) { string elementName, tagName; elementName = tagName = xmlReader.Name; DocumentTagTable tagTable = (DocumentTagTable)buffer.TagTable; TextIter insertAt, applyStart, applyEnd; insertAt = buffer.GetIterAtOffset(offset); TextTag tagAttributes; // Lookup Attributes tag in table, if it is not present we create one. tagName += ":Attributes" + tagSuffix; tagAttributes = tagTable.Lookup(tagName); if (tagAttributes == null) { tagAttributes = tagTable.CreateDynamicTag(tagName); } switch (elementName) { case "Type": DeserializeAttributesType(buffer, ref insertAt, xmlReader, tagSuffix); break; case "TypeSignature": DeserializeAttributesTypeSignature(buffer, ref insertAt, xmlReader, tagSuffix); break; case "Member": DeserializeAttributesMember(buffer, ref insertAt, xmlReader, tagSuffix); break; case "MemberSignature": DeserializeAttributesMemberSignature(buffer, ref insertAt, xmlReader, tagSuffix); break; default: DeserializeAttributesNone(buffer, ref insertAt, xmlReader, tagSuffix); break; } applyStart = buffer.GetIterAtOffset(offset); applyEnd = buffer.GetIterAtOffset(insertAt.Offset); buffer.ApplyTag(tagAttributes, applyStart, applyEnd); #if DEBUG Console.WriteLine("Attributes: {0} Start: {1} End: {2}", tagName, offset, insertAt.Offset); #endif return(insertAt.Offset); }
public void TestCreateDynamicTagInvalid () { DocumentTagTable tagTable = new DocumentTagTable (); TextTag tag = null; try { tag = tagTable.CreateDynamicTag ("foo-tag"); } catch (ArgumentException exception) { Assert.AreEqual ("Error -> The tag \"foo-tag\" is not a Dynamic Tag", exception.Message, "TCDTI01"); } Assert.IsNull (tag); }
public void TestCreateDynamicTagInvalid() { DocumentTagTable tagTable = new DocumentTagTable(); TextTag tag = null; try { tag = tagTable.CreateDynamicTag("foo-tag"); } catch (ArgumentException exception) { Assert.AreEqual("Error -> The tag \"foo-tag\" is not a Dynamic Tag", exception.Message, "TCDTI01"); } Assert.IsNull(tag); }
public void TestCreateDynamicTag() { DocumentTagTable tagTable = new DocumentTagTable(); TextTag expectedTag = tagTable.Lookup("format#0"); Assert.IsNull(expectedTag, "CDT01"); TextTag actualTag = tagTable.CreateDynamicTag("format#0"); expectedTag = tagTable.Lookup("format#0"); Assert.AreEqual(expectedTag, actualTag, "CDT02"); }
public static void AddStub(TextBuffer buffer, ref TextIter insertAt, string data, string suffix) { DocumentTagTable tagTable = (DocumentTagTable)buffer.TagTable; TextTag textTag = tagTable.Lookup("stub" + suffix + "#" + counter); if (textTag == null) { textTag = tagTable.CreateDynamicTag("stub" + suffix + "#" + counter); } counter++; buffer.InsertWithTags(ref insertAt, data, textTag); }
private static int InsertStartElement(TextBuffer buffer, int offset, XmlTextReader xmlReader, Stack stack, ref int depth, ref int count) { string elementName = xmlReader.Name; string suffix = String.Empty; DocumentTagTable tagTable = (DocumentTagTable)buffer.TagTable; bool emptyElement = xmlReader.IsEmptyElement; bool isDynamic = DocumentTagTable.IsDynamic(elementName); TextIter insertAt, applyStart, applyEnd; depth++; // We define a suffix so each dynamic tag has an unique name. // Suffix has format: #{depth level} if (isDynamic) { suffix = "#" + depth; } // We add any needed string to give format to the document. offset = FormatStart(buffer, offset, suffix, elementName); TagStart tagStart = new TagStart(); tagStart.Start = offset; tagStart.Name = elementName; // We first lookup the tag name, if the element is dynamic, we can // have three scenarios. // 1) The tag is not in the table: So we create it in the spot. // 2) Tag is in table but it priority is wrong: We created a new // dynamic tag with an extra suffix. Format #{depth level}.{count} // 3) Tag is in table with right priority: We reuse it and we don't // create a new dymamic tag. tagStart.Tag = tagTable.Lookup(elementName + suffix); if (isDynamic && tagStart.Tag == null) { tagStart.Tag = tagTable.CreateDynamicTag(elementName + suffix); } else if (isDynamic && tagStart.Tag != null && tagStart.Tag.Priority < ((TagStart)stack.Peek()).Tag.Priority) { suffix += "." + count; tagStart.Tag = tagTable.CreateDynamicTag(elementName + suffix); count++; } #if DEBUG try { Console.WriteLine("Element: {0} Start: {1}", tagStart.Tag.Name, tagStart.Start); } catch (NullReferenceException) { Console.WriteLine("Error: Missing {0} element", xmlReader.Name); Environment.Exit(1); } #endif // If element has attributes we have to get them and deserialize them. if (xmlReader.HasAttributes) { offset = DeserializeAttributes(buffer, offset, xmlReader, suffix); } // Special case when an elment is empty. // Case A: If element is editable a string stub is inserted to allow edition. // Case B: If element is not editable then a padding is inserted to handle // TextTag behaviour in which zero length ranges are lost. if (emptyElement) { if (((DocumentTag)tagStart.Tag).IsEditable) { insertAt = buffer.GetIterAtOffset(offset); buffer.Insert(ref insertAt, "["); offset += 1; offset = DocumentUtils.AddStub(buffer, offset, "Click to Add Documentation", suffix); insertAt = buffer.GetIterAtOffset(offset); buffer.Insert(ref insertAt, "]"); offset += 1; } else { offset = DocumentUtils.AddPaddingEmpty(buffer, offset, suffix); } applyStart = buffer.GetIterAtOffset(tagStart.Start); applyEnd = buffer.GetIterAtOffset(offset); buffer.ApplyTag(tagStart.Tag, applyStart, applyEnd); offset = FormatEnd(buffer, offset, suffix, elementName); // Padding between tag regions offset = DocumentUtils.AddPadding(buffer, offset, suffix); depth--; #if DEBUG Console.WriteLine("Empty Element: {0}, Start: {1}, End: {2}", tagStart.Tag.Name, tagStart.Start, offset); #endif } else { stack.Push(tagStart); if (((DocumentTag)tagStart.Tag).IsEditable) { insertAt = buffer.GetIterAtOffset(offset); buffer.Insert(ref insertAt, "["); offset += 1; } } return(offset); }