private TextNode AdjustUrlPath(TextNode textValue)
 {
     if (Importer != null)
     {
         textValue.Value = Importer.AlterUrl(textValue.Value, ImportPaths);
     }
     return textValue;
 }

 public TextButton(ButtonFrames frames, SpriteFont font, int textSize, string text)
     : base(frames)
 {
     _text = new TextNode(font, textSize)
     {
         Text = text
     };
     Icon = _text;
 }

 // Given new text node
 public void Activate(TextNode tn)
 {
     CurNode = tn;
     Active = true;
     WritingText = true;
     Chat.text = "";
     Name.text = CurNode.Name;
     WritingIndex = 0;
 }

        static void Main()
        {
			ImaginaryHost h = new ImaginaryHost();
			TextNode t = new TextNode(h);
			Node tn = (Node)t;

			MemoryStream s = new MemoryStream();
			h.SerializeTo(s);
			s.Position = 0;
			
            System.Windows.Forms.Application.Run();
        }

 public Node Read(string xmlString)
 {
     Node node = null;
     if (xmlString.Contains("?xml"))
     {
         node = new XmlDeclarationNode {Name = "Declaration", Value = xmlString};
     }
     else if (xmlString.Contains("<!--"))
     {
         node = new CommentNode {Name = "Comment", Value = xmlString.Substring(4, xmlString.Length - 7)};
     }else if (xmlString.Contains("\\"))
     {
         node = new CommentNode {Name = "ScriptComment", Value = xmlString.Substring(2, xmlString.Length - 2)};
     }
     else if (xmlString.Contains("<Item>"))
     {
         node = new TextNode {Name = "Text", Value = xmlString.Substring(6, xmlString.Length - 13)};
     }else if (xmlString.ToLower().Contains("<script>"))
     {
         node = new TextNode {Name = "script", Value = xmlString.Substring(8, xmlString.Length - 17)};
     }
     return node;
 }

        public Url(TextNode value, IEnumerable<string> paths)
        {
            // The following block is commented out, because we want to have the path verbatim,
            // not rewritten. Here's why: Say less/trilogy_base.less contains
            //
            //   background-image: url(img/sprites.png)
            //
            // and serverfault/all.less contains
            //
            //   @import "../less/trilogy_base"
            //
            // If relative paths where to be rewritten, the resulting serverfault/all.css would read
            //
            //   background-image: url(../less/img/sprites.png)
            //
            // which is obviously not what we want.

            /*if (!Regex.IsMatch(value.Value, @"^(http:\/)?\/") && paths.Any())
            {
                value.Value = paths.Concat(new[] {value.Value}).AggregatePaths();
            }*/

            Value = value;
        }

 public SvgTitleElement(string s)
 {
     TextNode tn = new TextNode(s);
     AddChild(tn);
 }

 public BlockNode(TextNode owner)
 {
     this.owner = owner;
 }

		public virtual void VisitText(TextNode textNode)
		{
			VisitChildren(textNode);
		}

		public void VisitText(TextNode textNode)
		{
			// unused
		}

        public string ConvertFromCSharp(TextNode node)
        {
            var sb = new StringBuilder();

            if (node.Text == "List")
            {
                sb.Append(ConvertFromCSharp(node.Children[0]));
                sb.Append("[]");
            }
            else if (node.Text == "Dictionary")
            {
                sb.Append("{ [index:");
                sb.Append(ConvertFromCSharp(node.Children[0]));
                sb.Append("]: ");
                sb.Append(ConvertFromCSharp(node.Children[1]));
                sb.Append("; }");
            }
            else
            {
                sb.Append(TypeAlias(node.Text));
                if (node.Children.Count > 0)
                {
                    sb.Append("<");
                    for (var i = 0; i < node.Children.Count; i++)
                    {
                        var childNode = node.Children[i];

                        if (i > 0)
                            sb.Append(",");

                        sb.Append(ConvertFromCSharp(childNode));
                    }
                    sb.Append(">");
                }
            }

            return sb.ToString();
        }

 /// <summary>
 ///     Add a string for the system to draw. Strings are drawn in a FIFO basis, so calling this method
 ///     does not guarantee the string will immediately begin drawing.
 /// </summary>
 /// <param name="str">String to draw</param>
 /// <param name="delay">Optional param, to specify delay before the message is written</param>
 public void AcceptNodePackage(TextNode.NodePackage package, bool skipCurrent = false)
 {
     if (skipCurrent) { SkipCurrentSequence(); }
     toDisplay.Enqueue(package);
     PackageAddedToQueue();
 }

 private TextNode AdjustUrlPath(TextNode textValue)
 {
     if (Importer != null && !Regex.IsMatch(textValue.Value, @"^(([a-zA-Z]+:)|(\/))"))
     {
         textValue.Value = Importer.AlterUrl(textValue.Value, ImportPaths);
     }
     return textValue;
 }

 internal override GlobNode AddChar(char c)
 {
     var node = new TextNode(this);
     nodes.Add(node);
     return node.AddChar(c);
 }

 public bool Add(TextNode textNode)
 {
     if(Contains(textNode.Text)) {
         foreach (var child in Children) {
             if (child.Add(textNode)) {
                 return true;
             }
         }
         Children.Add(textNode);
         return true;
     }
     return false;
 }

        public static void WriteWordLookUp(EpsgData data, BinaryWriter textWriter, BinaryWriter indexWriter)
        {
            var roots = new List<TextNode>();
            foreach(var text in data.WordLookUpList) {
                var containerRoot = TextNode.FindContainingRoot(roots, text);
                if(null == containerRoot) {
                    containerRoot = new TextNode(text);
                    var containedRoots = roots.Where(r => containerRoot.Contains(r.Text)).ToList();
                    foreach(var containedRoot in containedRoots) {
                        roots.Remove(containedRoot);
                        if(!containerRoot.Add(containedRoot)) {
                            throw new InvalidOperationException();
                        }
                    }
                    roots.Add(containerRoot);
                }else {
                    if(!containerRoot.Add(text)) {
                        throw new InvalidOperationException();
                    }
                }
            }

            for (int quality = Math.Min(6,roots.Select(x => x.Text.Length).Max()/2); quality >= 0; quality--) {
                for (int i = 0; i < roots.Count; i++) {
                    for (int j = i + 1; j < roots.Count; j++) {
                        int overlapAt = StringUtils.OverlapIndex(roots[i].Text, roots[j].Text);
                        if (overlapAt >= 0 && (roots[i].Text.Length - overlapAt) >= quality) {
                            var newText = roots[i].Text.Substring(0, overlapAt) + roots[j].Text;
                            var newNode = new TextNode(newText, new[]{roots[i], roots[j]});
                            roots.RemoveAt(j);
                            roots[i] = newNode;
                            i--;
                            break;
                        }
                        overlapAt = StringUtils.OverlapIndex(roots[j].Text, roots[i].Text);
                        if (overlapAt >= 0 && (roots[j].Text.Length - overlapAt) >= quality) {
                            var newText = roots[j].Text.Substring(0, overlapAt) + roots[i].Text;
                            var newNode = new TextNode(newText, new[]{roots[j], roots[i]});
                            roots.RemoveAt(j);
                            roots[i] = newNode;
                            i--;
                            break;
                        }
                    }
                }
            }

            var offsetLookUp = new Dictionary<string, int>();
            int rootOffset = 0;
            foreach(var root in roots) {
                var rootText = root.Text;
                var rootBytes = Encoding.UTF8.GetBytes(rootText);
                textWriter.Write(rootBytes);
                foreach(var text in root.GetAllString()) {
                    int startIndex = rootText.IndexOf(text, StringComparison.Ordinal);
                    var localOffset = Encoding.UTF8.GetByteCount(rootText.Substring(0, startIndex));
                    offsetLookUp.Add(text, rootOffset + localOffset);
                }
                rootOffset += rootBytes.Length;
            }

            foreach(var word in data.WordLookUpList) {
                indexWriter.Write((ushort)offsetLookUp[word]);
                indexWriter.Write((byte)(Encoding.UTF8.GetByteCount(word)));
            }
        }

 internal override GlobNode/*!*/ AddChar(char c) {
     TextNode node = new TextNode(this);
     _nodes.Add(node);
     return node.AddChar(c);
 }

 public virtual void Write(TextNode t)
 {
     if (t is DocumentNode) { Write((DocumentNode)t); return; }
     if (t is Token) { WriteToken((Token)t); return; }
 }

 public SvgTspanElement(string s, float x, float y)
 {
     TextNode tn = new TextNode(s);
     AddChild(tn);
     X=x;
     Y=y;
 }

 public virtual void VisitText(TextNode textNode)
 {
     if (this.ThrowException)
     {
         throw (Exception)this.CreateException(textNode);
     }
 }