private static bool TryGetLineBreak(TextRun textRun, out LineBreak lineBreak) { lineBreak = default; if (textRun.Text.IsEmpty) { return(false); } var lineBreakEnumerator = new LineBreakEnumerator(textRun.Text); while (lineBreakEnumerator.MoveNext()) { if (!lineBreakEnumerator.Current.Required) { continue; } lineBreak = lineBreakEnumerator.Current; return(lineBreak.PositionWrap >= textRun.Text.Length || true); } return(false); }
private static IEnumerable <ExtendText> ExtractTextEmb(LineBreak br) { return(new[] { new ExtendText() { Text = "\n", StartText = br.ContentStart } }); }
public WzXmlSerializer(int indentation, LineBreak lineBreakType) { switch (lineBreakType) { case LineBreak.None: lineBreak = ""; break; case LineBreak.Windows: lineBreak = "\r\n"; break; case LineBreak.Unix: lineBreak = "\n"; break; } char[] indentArray = new char[indentation]; for (int i = 0; i < indentation; i++) { indentArray[i] = (char)0x20; } indent = new string(indentArray); }
void SkipBlockComment() { var startLocation = _pos; _pos = _pos.Increment(2); var end = _input.IndexOf("*/", _pos.Index, StringComparison.Ordinal); if (end == -1) { Raise(_pos.Increment(-2), "Unterminated comment"); } _pos = new Position(_pos.Line, _pos.Column + (end - startLocation.Index), end + 2); var lastIndex = startLocation.Index; while (true) { var match = LineBreak.Match(_input, lastIndex); if (!match.Success || match.Index >= _pos.Index) { break; } var lineStart = match.Index + match.Length; _pos = new Position(_pos.Line + 1, _pos.Index - lineStart, _pos.Index); lastIndex = lineStart; } //Options.onComment?.Invoke(true, input.Substring(startLocation.Index + 2, end - (startLocation.Index + 2)), new SourceLocation(startLocation, curPosition(), SourceFile)); }
public static LineBreak xAppendLineBreak(this Paragraph p) { LineBreak lineBreak = new LineBreak(); p.Inlines.Add(lineBreak); return(lineBreak); }
public static String getDocumentUni(FlowDocument flowDoc) { StringBuilder sb = new StringBuilder(); foreach (Block b in flowDoc.Blocks) { Paragraph p = b as Paragraph; if (p != null) { foreach (Inline i in p.Inlines) { Run r = i as Run; LineBreak lb = i as LineBreak; if (r != null) { sb.Append(r.Text); } else if (lb != null) { sb.Append(Environment.NewLine); } } } } return(sb.ToString()); }
/// <summary> /// This method creates a TextBlock with advanced format, and adds /// it to the StackPanel customizeFormatPlaceHolder. /// </summary> private void FormatText() { TextBlock formatTextBlock = new TextBlock(); Run paragraph1 = new Run() { Text = "Paragraph1" }; paragraph1.FontFamily = new FontFamily("Magnetob.ttf#Magneto"); LineBreak lineBreak = new LineBreak(); Run paragraph2 = new Run() { Text = "Paragraph2" }; LinearGradientBrush brush = new LinearGradientBrush(); brush.GradientStops.Add(new GradientStop() { Color = Colors.Blue, Offset = 0d }); brush.GradientStops.Add(new GradientStop() { Color = Colors.Red, Offset = 1d }); paragraph2.Foreground = brush; formatTextBlock.Inlines.Add(paragraph1); formatTextBlock.Inlines.Add(lineBreak); formatTextBlock.Inlines.Add(paragraph2); this.customizeFormatPlaceHolder.Children.Add(formatTextBlock); }
public Emitter(Stream stream, bool isCanonical = false, int indent = 2, int width = 80, bool allowUnicode = true, LineBreak lineBreak = LineBreak.LineFeed) { this.stream = stream; this.state = this.ExpectStreamStart; this.isCanonical = isCanonical; this.allowUnicode = allowUnicode; if (indent > 1 && indent < 10) this.bestIndent = indent; if (width > this.bestIndent * 2) this.bestWidth = width; switch (lineBreak) { case LineBreak.CarriageReturn: this.bestLineBreak = "\r"; break; case LineBreak.LineFeed: this.bestLineBreak = "\n"; break; case LineBreak.CarriageReturnLineFeed: this.bestLineBreak = "\r\n"; break; } }
public bool BraceIsBlock(TokenType prevType) { if (prevType == TT["colon"]) { var parent = CurrentContext; if (parent == TokenContext.Types["b_stat"] || parent == TokenContext.Types["b_expr"]) { return(!parent.IsExpr); } } if (prevType == TT["_return"]) { return(LineBreak.IsMatch(Input.Slice(State.LastTokenEnd, State.Start))); } if (prevType == TT["_else"] || prevType == TT["semi"] || prevType == TT["eof"] || prevType == TT["parenR"]) { return(true); } if (prevType == TT["braceL"]) { return(CurrentContext == TokenContext.Types["b_stat"]); } return(!State.ExprAllowed); }
bool BraceIsBlock(TokenType prevType) { var parent = CurContext(); if (parent == TokContext.FExpr || parent == TokContext.FStat) { return(true); } if (prevType == TokenType.Colon && (parent == TokContext.BStat || parent == TokContext.BExpr)) { return(!parent.IsExpression); } // The check for `tt.name && exprAllowed` detects whether we are // after a `yield` or `of` construct. See the `updateContext` for // `tt.name`. if (prevType == TokenType.Return || prevType == TokenType.Name && _exprAllowed) { return(LineBreak.IsMatch(_input.Substring(_lastTokEnd.Index, Start.Index - _lastTokEnd.Index))); } if (prevType == TokenType.Else || prevType == TokenType.Semi || prevType == TokenType.Eof || prevType == TokenType.ParenR || prevType == TokenType.Arrow) { return(true); } if (prevType == TokenType.BraceL) { return(parent == TokContext.BStat); } if (prevType == TokenType.Var || prevType == TokenType.Name) { return(false); } return(!_exprAllowed); }
private static Inline crtInline(HtmlNode xNode) { Inline converted = null; switch (xNode.Name) { case "hr": #if dict_dist converted = new LineBreak(); #endif break; case "a": var hb = new Hyperlink(); hb.Click += OnHyberlinkClick; hb.Inlines.Add(new Run() { Text = xNode.InnerText }); return(hb); case "i": case "#text": converted = new Run() { Text = xNode.InnerText }; break; default: break; } return(converted); }
public static int ReadInt(int?min, int?max, string optionalText = "", LineBreak lineBreak = None, TextAlign textAlign = Center) { Cc(); int res; while (true) { if (optionalText != "") { Write(optionalText, lineBreak, textAlign); } if (textAlign == Center) { var nbSpaces = (Console.WindowWidth - optionalText.Length) / 2; Console.SetCursorPosition(nbSpaces, Console.CursorTop); } if (int.TryParse(Console.ReadLine(), out res)) { ErrorColors(); if ((min == null && max == null) || (min != null && max != null && res >= min && res <= max) || (min == null && res <= max) || (max == null && res >= min)) { BaseColors(); break; } if (min != null && res < min) { Write(); Write(" Error : the input should be at least " + min + " ", Both, textAlign); BaseColors(); Pause("retry"); } else if (max != null && res > max) { Write(); Write(" Error : the input should be at most " + max + " ", Both, textAlign); BaseColors(); Pause("retry"); } else { Write(); Write(" Error : the input should be between " + min + " and " + max + " ", Both, textAlign); BaseColors(); Pause("retry"); } } else { Write(); ErrorColors(); Write(" Error : the input is empty, isn't an integer or is too big ", Both, textAlign); BaseColors(); Pause("retry"); } } return(res); }
bool FindTextPointersI(LineBreak lb, ref RangeData rd) { if (rd.Pointer1 == null) { if (rd.Remaining1 <= 0) { rd.Pointer1 = lb.ContentStart; } else { rd.Remaining1 -= EolLength; } } if (rd.Pointer2 == null) { if (rd.Remaining2 <= 0) { rd.Pointer2 = lb.ContentStart; } else { rd.Remaining2 -= EolLength; } } return(rd.Done); }
public static void Write(string text = "", LineBreak lineBreak = None, TextAlign textAlign = Center) { var length = ""; for (var i = 0; i < text.Length; i++) { length += " "; } if (lineBreak == Before || lineBreak == Both) { AlignText(length, textAlign); Console.WriteLine(length); } AlignText(text, textAlign); Console.WriteLine(text); if (lineBreak != After && lineBreak != Both) { return; } AlignText(length, textAlign); Console.WriteLine(length); }
public Dumper(Stream stream, bool isCanonical = false, int indent = 2, int width = 80, bool allowUnicode = true, LineBreak lineBreak = LineBreak.LineFeed) { this.emitter = new Emitter(stream, isCanonical, indent, width, allowUnicode, lineBreak); }
void readToken_plus_min(int code) { // '+-' var next = _input[_pos.Index + 1]; if (next == code) { if (next == 45 && !_inModule && _input.Get(_pos.Index + 2) == 62 && (_lastTokEnd.Index == 0 || LineBreak.IsMatch(_input.Substring(_lastTokEnd.Index, _pos - _lastTokEnd)))) { // A `-->` line comment SkipLineComment(3); SkipSpace(); NextToken(); return; } FinishOp(TokenType.IncDec, 2); } else if (next == 61) { FinishOp(TokenType.Assign, 2); } else { FinishOp(TokenType.PlusMin, 1); } }
public TextRenderHelper() { List <char> list = new List <char>(); list.Add(','); list.Add('.'); list.Add('。'); list.Add('、'); this.delimiters = list; // base..ctor(); //FIXME:??? this.Font = UISystem.DefaultFont; this.horizontalAlignment = HorizontalAlignment.Center; this.verticalAlignment = VerticalAlignment.Middle; this.horizontalOffset = 0f; this.verticalOffset = 0f; this.lineBreak = LineBreak.Character; this.textTrimming = TextTrimming.None; this.lineGap = 0f; Dictionary <LineBreak, TextRenderHelper.ReflectLineBreak> dictionary = new Dictionary <LineBreak, TextRenderHelper.ReflectLineBreak>(); dictionary.Add(LineBreak.Character, new TextRenderHelper.ReflectLineBreak(this.ReflectLineBreakCharacter)); dictionary.Add(LineBreak.Word, new TextRenderHelper.ReflectLineBreak(this.ReflectLineBreakWord)); dictionary.Add(LineBreak.Hyphenation, new TextRenderHelper.ReflectLineBreak(this.ReflectLineBreakHyphenation)); dictionary.Add(LineBreak.AtCode, new TextRenderHelper.ReflectLineBreak(this.ReflectLineBreakAtCode)); this.ReflectLineBreakFuncs = dictionary; Dictionary <TextTrimming, TextRenderHelper.ReflectTextTrimming> dictionary2 = new Dictionary <TextTrimming, TextRenderHelper.ReflectTextTrimming>(); dictionary2.Add(TextTrimming.None, new TextRenderHelper.ReflectTextTrimming(this.ReflectTextTrimmingNone)); dictionary2.Add(TextTrimming.Character, new TextRenderHelper.ReflectTextTrimming(this.ReflectTextTrimmingCharacter)); dictionary2.Add(TextTrimming.Word, new TextRenderHelper.ReflectTextTrimming(this.ReflectTextTrimmingWord)); dictionary2.Add(TextTrimming.EllipsisCharacter, new TextRenderHelper.ReflectTextTrimming(this.ReflectTextTrimmingEllipsisCharacter)); dictionary2.Add(TextTrimming.EllipsisWord, new TextRenderHelper.ReflectTextTrimming(this.ReflectTextTrimmingEllipsisWord)); this.ReflectTextTrimmingFuncs = dictionary2; }
public static void Emit(IEnumerable<Events.Base> events, Stream stream, bool isCanonical = false, int indent = 2, int width = 80, bool allowUnicode = true, LineBreak lineBreak = LineBreak.LineFeed) { var dumper = new Dumper(stream, isCanonical, indent, width, allowUnicode, lineBreak); Emit(events, dumper); }
private void SetCurrent(int pos, byte state) { LineBreakKind kind = state >= 0xC0 ? LineBreakKind.Hard : LineBreakKind.Soft; Current = new LineBreak(pos, kind); }
private TextElement FindTextElement(TreeNode node, LineBreak lb) { if (lb.Tag == node) { return(lb); } return(null); }
public void NullifyFontFamily() { LineBreak lb = new LineBreak(); lb.FontFamily = null; // note: Trying to readback FontFamily, after setting it to null, will crash the plugin // see Run.NullifyFontFamily for a more dramatic effect ;-) }
private void FixEmojis() { if (m_pending_change) { return; } /* This will prevent our operation from polluting the undo buffer, but it * will create an infinite undo stack... need to fix this. */ BeginChange(); m_pending_change = true; TextPointer cur = Document.ContentStart; while (cur.CompareTo(Document.ContentEnd) < 0) { TextPointer next = cur.GetNextInsertionPosition(LogicalDirection.Forward); if (next == null) { break; } TextRange word = new TextRange(cur, next); if (word.Text.Length > 0) { // Test this so as to preserve caret position bool caret_was_next = (0 == next.CompareTo(CaretPosition)); Inline inline; // FIXME: this is a hack, normally we should split into Runs and EmojiInlines if (word.Text == "\n") { inline = new LineBreak(); } else { inline = new EmojiInline() { Text = word.Text, FontSize = FontSize, FallbackBrush = Foreground } }; next = Replace(word, inline); if (caret_was_next) { CaretPosition = next; } } cur = next; } EndChange(); m_pending_change = false; }
public override object Build(FlowElementBuilderContext context, PrintElementLineBreak element, PrintElementMetadataMap elementMetadataMap) { var elementContent = new LineBreak(); FlowElementBuilderHelper.ApplyBaseStyles(elementContent, element); FlowElementBuilderHelper.ApplyInlineStyles(elementContent, element); return(elementContent); }
public void FindName() { LineBreak lb = new LineBreak(); Assert.Throws <ArgumentNullException> (delegate { lb.FindName(null); }, "null"); Assert.IsNull(lb.FindName(String.Empty), "Empty"); }
private Inline CloneInline(Inline inline) { Inline retVal = null; if (inline is LineBreak) { retVal = new LineBreak(); } else if (inline is Span) { retVal = new Span(); } else if (inline is Run) { retVal = new Run(((Run)inline).Text); } if (inline.ReadLocalValue(Inline.BackgroundProperty) != DependencyProperty.UnsetValue) { retVal.Background = inline.Background; } if (inline.ReadLocalValue(Inline.ForegroundProperty) != DependencyProperty.UnsetValue) { retVal.Foreground = inline.Foreground; } if (inline.ReadLocalValue(Inline.FontFamilyProperty) != DependencyProperty.UnsetValue) { retVal.FontFamily = inline.FontFamily; } if (inline.ReadLocalValue(Inline.FontSizeProperty) != DependencyProperty.UnsetValue) { retVal.FontSize = inline.FontSize; } if (inline.ReadLocalValue(Inline.FontStretchProperty) != DependencyProperty.UnsetValue) { retVal.FontStretch = inline.FontStretch; } if (inline.ReadLocalValue(Inline.FontStyleProperty) != DependencyProperty.UnsetValue) { retVal.FontStyle = inline.FontStyle; } if (inline.ReadLocalValue(Inline.FontWeightProperty) != DependencyProperty.UnsetValue) { retVal.FontWeight = inline.FontWeight; } if (inline.ReadLocalValue(Inline.TextEffectsProperty) != DependencyProperty.UnsetValue) { retVal.TextEffects = inline.TextEffects; } if (inline.ReadLocalValue(Inline.TextDecorationsProperty) != DependencyProperty.UnsetValue) { retVal.TextDecorations = inline.TextDecorations; } return(retVal); }
public YAMLWriter(TextWriter tw, int initialdepth, int horizontalthresh, IDictionary <Type, bool> bbd) { Depth = new string(' ', initialdepth); HorizontalThresh = horizontalthresh; Lw = new LineWriter(tw, 0); BBD = bbd; VertWriter = new LeafWriter(this, VertNeedsQuotes, s => LineBreak.IsMatch(s)); HorizontalArrWriter = new LeafWriter(this, HArrNeedsQuotes, s => false); HorizontalDicWriter = new LeafWriter(this, HDicNeedsQuotes, s => false); }
private void AddLineBreak() { _PriorLineBreaks++; // Create the LineBreak and buffer it LineBreak lineBreak = new LineBreak(); DocumentState state = _DocumentStates.Peek(); DecorateRun(lineBreak, state); _CurrentParagraph.Inlines.Add(lineBreak); }
bool FindStartIndexI(LineBreak lb, TextElement el, ref int index) { if (object.ReferenceEquals(lb, el)) { return(true); } index += EolLength; return(false); }
TextPointer FindTextPointerI(LineBreak lb, ref int remainingIndex) { if (remainingIndex <= 0) { return(lb.ElementStart); } remainingIndex -= EolLength; return(null); }
public void ExtractTextLineBreak_Test() { //Arrange var a = new LineBreak(); //Act var b = Parser.ExtractText(a); //Assert Assert.IsTrue(b.Any(x => x.Text == "\n")); }
private static void NameUpdateContext(Tokenizer tok, TokenType prevType) { tok.State.ExprAllowed = false; if (prevType == Types["_let"] || prevType == Types["_const"] || prevType == Types["_var"]) { if (LineBreak.IsMatch(tok.Input.Slice(tok.State.End))) { tok.State.ExprAllowed = true; } } }
public static string Emit(IEnumerable<Events.Base> events, bool isCanonical = false, int indent = 2, int width = 80, bool allowUnicode = true, LineBreak lineBreak = LineBreak.LineFeed) { using (var stream = new MemoryStream(1024)) { Emit(events, stream, isCanonical, indent, width, allowUnicode, lineBreak); stream.Seek(0, SeekOrigin.Begin); using (var reader = new StreamReader(stream)) return reader.ReadToEnd(); } }
AstThrow ParseThrowStatement(Position nodeStart) { Next(); if (LineBreak.IsMatch(_input.Substring(_lastTokEnd.Index, Start.Index - _lastTokEnd.Index))) { Raise(_lastTokEnd, "Illegal newline after throw"); } var argument = ParseExpression(); Semicolon(); return(new AstThrow(this, nodeStart, _lastTokEnd, argument)); }
private void btnBreakText_Click(object sender, EventArgs e) { string strInput = txtInput.Text; if (string.IsNullOrEmpty(strInput)) { return; } txtOutput.Clear(); LineBreak linebreak = new LineBreak(); LineBreakElement[] lbElements = linebreak.FindLineBreaks(strInput); StringBuilder sb = new StringBuilder(); int lineWidth = 0; int maxLineWidth = (int)nudLineWidth.Value; int ich = 0; foreach (char ch in strInput) { LineBreakCondition lbCondition = lbElements[ich].Condition; ich++; string strElem = ch.ToString(); if (lbCondition == LineBreakCondition.Allowed) { if (lineWidth >= maxLineWidth) { sb.AppendLine(string.Empty); lineWidth = 0; } sb.Append(strElem); } else if (lbCondition == LineBreakCondition.Mandatory) { sb.AppendLine(string.Empty); lineWidth = 0; //sb.Append(strElem); // sb.AppendLine(strElem); } else { sb.Append(strElem); } lineWidth++; } txtOutput.Text = sb.ToString(); }
public WzXmlSerializer(int indentation, LineBreak lineBreakType) { switch (lineBreakType) { case LineBreak.None: lineBreak = ""; break; case LineBreak.Windows: lineBreak = "\r\n"; break; case LineBreak.Unix: lineBreak = "\n"; break; } char[] indentArray = new char[indentation]; for (int i = 0; i < indentation; i++) indentArray[i] = (char)0x20; indent = new string(indentArray); }
public WzClassicXmlSerializer(int indentation, LineBreak lineBreakType, bool exportbase64) : base(indentation, lineBreakType) { ExportBase64Data = exportbase64; }
private Inline UpdateElement(HtmlTag aTag) { Inline retVal = null; switch (aTag.Name) { case "binding": case "text": if (aTag.Name == "binding") { retVal = new Bold(new Run("{Binding}")); if (aTag.Contains("path") && (textBlock.DataContext != null)) { object obj = textBlock.DataContext; PropertyInfo pi = obj.GetType().GetProperty(aTag["path"]); if (pi != null && pi.CanRead) retVal = new Run(pi.GetValue(obj, null).ToString()); } } else retVal = new Run(aTag["value"]); if (currentState.SubScript) retVal.SetValue(Typography.VariantsProperty, FontVariants.Subscript); if (currentState.SuperScript) retVal.SetValue(Typography.VariantsProperty, FontVariants.Superscript); if (currentState.Bold) retVal = new Bold(retVal); if (currentState.Italic) retVal = new Italic(retVal); if (currentState.Underline) retVal = new Underline(retVal); if (currentState.Foreground.HasValue) retVal.Foreground = new SolidColorBrush(currentState.Foreground.Value); if (currentState.Font != null) try { retVal.FontFamily = new FontFamily(currentState.Font); } catch { } //Font name not found... if (currentState.FontSize.HasValue) retVal.FontSize = currentState.FontSize.Value; break; case "br": retVal = new LineBreak(); break; default: Debug.WriteLine("UpdateElement - " + aTag.Name + " not handled."); retVal = new Run(); break; } if (currentState.HyperLink != null && currentState.HyperLink != "") { Hyperlink link = new Hyperlink(retVal); try { link.NavigateUri = new Uri(currentState.HyperLink); } catch { link.NavigateUri = null; } retVal = link; } return retVal; }
LineBreak FitString(string text, int startIndex, int width, Graphics gMeatsure) { LineBreak lineBreak = new LineBreak(); int currentIndex = FindWhitespace(text, startIndex); if (currentIndex == -1) currentIndex = text.Length; int lastIndex = startIndex; SizeF dims = new SizeF(0, 0); lineBreak.Size = new SizeF(0, 0); while (currentIndex != -1 && (dims = gMeatsure.MeasureString(text.Substring(startIndex, currentIndex - startIndex), FontFromGdi)).Width <= width) { // record the width/height while succesfully fit lineBreak.Width = dims.Width; lineBreak.Height = dims.Height; // done if (currentIndex == text.Length) { lastIndex = currentIndex; currentIndex = -1; } else if (text[currentIndex] == '\n') { lastIndex = currentIndex + 1; currentIndex = -1; } else { // get next word lastIndex = currentIndex + 1; currentIndex = FindWhitespace(text, lastIndex); // end of string if (currentIndex == -1) currentIndex = text.Length; } } if (lastIndex == startIndex) { // the string was either too long or we are at the end of the string if (currentIndex == -1) { throw new Exception("Somehow executing unreachable code while drawing text."); } currentIndex = lastIndex + 1; while ((dims = gMeatsure.MeasureString(text.Substring(startIndex, currentIndex - startIndex), FontFromGdi)).Width <= width) { lineBreak.Size = new SizeF(dims.Width, dims.Height); currentIndex++; } lineBreak.Size = new SizeF(dims.Width, dims.Height); lineBreak.Width = Math.Min(lineBreak.Width, width); lineBreak.Text = text.Substring(startIndex, currentIndex - startIndex); lineBreak.Index = currentIndex; return lineBreak; } else { // return the index we're painting to lineBreak.Text = text.Substring(startIndex, lastIndex - startIndex); lineBreak.Index = lastIndex; return lineBreak; } }
LineBreak FitString(string text, int startIndex, int width) { LineBreak lineBreak = new LineBreak(); lineBreak.Width = 0; int dims = 0; int currentIndex = FindWhitespace(text, startIndex); if (currentIndex == -1) currentIndex = text.Length; int lastIndex = startIndex; while (currentIndex != -1 && (dims = MeasureString(text.Substring(startIndex, currentIndex - startIndex))) <= width) { // record the width while succesfully fit lineBreak.Width = dims; // done if (currentIndex == text.Length) { lastIndex = currentIndex; currentIndex = -1; } else if (text[currentIndex] == '\n') { lastIndex = currentIndex + 1; currentIndex = -1; } else { // get next word lastIndex = currentIndex + 1; currentIndex = FindWhitespace(text, lastIndex); // end of string if (currentIndex == -1) currentIndex = text.Length; } } if (lastIndex == startIndex) { // the string was either too long or we are at the end of the string if (currentIndex == -1) throw new Exception("Somehow executing unreachable code while drawing text."); currentIndex = lastIndex + 1; while ((dims = MeasureString(text.Substring(startIndex, currentIndex - startIndex))) <= width) { lineBreak.Width = dims; currentIndex++; } lineBreak.Width = Math.Min(dims, width); lineBreak.Text = text.Substring(startIndex, currentIndex - startIndex); lineBreak.Index = currentIndex; return lineBreak; } else { // return the index we're painting to lineBreak.Text = text.Substring(startIndex, lastIndex - startIndex); lineBreak.Index = lastIndex; return lineBreak; } }
public WzNewXmlSerializer(int indentation, LineBreak lineBreakType) : base(indentation, lineBreakType) { }