WPF - Auto Line Number for FlowDocument?

Question

I'm just starting on a contract generation routine for my current project and one of the requirements is that each of the lines in the contract must be numbered. The number should be located in the left margin with a vertical rule separating the numbering from the rest of the document content.

I'm pretty sure I can tackle this requirement with a FixedDocument, but it won't be fun. Is there anyway I can do this with a FlowDocument instead?

Gunther

I'm interested in the answer as well. You'll have to make a clarification though what do you mean by "line" - if it depends on how the document was rendered or not. Line can be a part of FlowDocument content that doesn't contain block boundaries or "new line" symbols inside or, alternatively, it can be an actual line of text that user will see after FlowDocument is rendered inside e.g. a specific FlowDocumentViewer. – Carolecarolee

As the document is a contract, I need a line number for every line break. For instance, if a long paragraph is included into the document and the FlowDocument automatically wraps the text onto 7 lines, I need 7 line numbers; one representing each line. – Gunther

It's actually quite easy to do contract generation with a FixedDocument. Your question is about FlowDocument so I won't post code as an answer, but if you want to amend your question to ask how to do this with a FixedDocument, I'd be happy to post some code for you. – Hannie

Thanks, Ares. I'm pretty sure I could tackle this with a FixedDocument as well, I was just hoping to avoid that route as it may be a lot more work than a FlowDocument. – Gunther

Nah, it's actually quite easy. You make a canvas for each page, and keep track of your X and Y position. Whenever you want to add more text or whatever else, you use Measure to get its size, then if it would go off the page, start a new page and add it to the new page. Like I said, if you want I can post some code that would make implementing it a snap. – Hannie

Please do. More knowledge and information is always a good thing. :) – Gunther

OK, I've added some "ready to go" code for you to use. If you like it, please accept my answer. Thanks. – Hannie

@Ares - Looks good, man. Thanks. I gave +1 but I'll leave the question open to see if we can get any more answers to the FlowDocument option. – Gunther

Answer 1

You can do this with a FixedDocument quite easily with my WpfPrint helper class, posted below. To use it for XPS creation just use the constructor for XPS:

WpfPrint printer = new WpfPrint(new Size(1024, 768));
printer.CurrentElementMargin = new Thickness(2, 2, 2, 2);
printer.CurrentFontFamily = new FontFamily("Arial");
printer.CurrentFontSize = BaseFontSize;
printer.MarginX = 24;
printer.MarginY = 24;

You can now loop through and add whatever you want; TextBlocks would most likely be what you were looking for:

printer.AddTextBlock("Basics", printer.PageSizeUsed.Width, 0, WpfPrint.ElementFlags.NewLine | WpfPrint.ElementFlags.BottomCheck2);

They'll wrap themselves if you create them wrapped; each item, as it is added, is measured. If it doesn't fit on the page, the helper class adds a new page and flows it onto the new page, so you get what you wanted from FlowDocument. You can change CurX and CurY at any time to skip horizontal or vertical space when placing items. When you are done, you can print to a printer like this:

// Print final document
XpsDocumentWriter xpsDocumentWriter = PrintQueue.CreateXpsDocumentWriter(dlg.PrintQueue);
xpsDocumentWriter.Write(printer.CurrentFixedDocument);

Or you can save as an XPS file:

using (XpsDocument doc = new XpsDocument(filename, FileAccess.Write))
{
    XpsDocumentWriter xpsDocumentWriter = XpsDocument.CreateXpsDocumentWriter(doc);
    xpsDocumentWriter.Write(printer.CurrentFixedDocument);
}

Here is the helper class. Enjoy! You'll never want to use a FlowDocument again :-)

//****************************************************************************************
// WpfPrint
//
// Various helpers for printing WPF UI to a printer
//****************************************************************************************

using System;
using System.Collections.Generic;
using System.Text;
using System.Windows.Documents;
using System.Windows.Markup;
using System.Windows.Controls;
using System.Windows.Xps;
using System.Windows;
using System.Printing;
using System.Windows.Media;


namespace csheet
{
    /// <summary>
    /// Various helpers for printing WPF UI to a printer
    /// </summary>
    public class WpfPrint
    {
        #region Supporting Types
        //****************************************************************************************
        // Suporting Types
        //****************************************************************************************

        /// <summary>
        /// Element flags define the way the elements print; OR them for multiple effects
        /// </summary>
        [Flags]
        public enum ElementFlags
        {
            /// <summary>No special flags</summary>
            None = 0,

            /// <summary>Move to the next line after output</summary>
            NewLine = 1,

            /// <summary>if there isn't 2x room, then do new page first</summary>
            BottomCheck2 = 2,

            /// <summary>Center the item horizontally</summary>
            HorzCenter = 4,

            /// <summary>Right align the item (center overrides)</summary>
            HorzRight = 8
        }

        #endregion Supporting Types

        #region Data
        //****************************************************************************************
        // Data
        //****************************************************************************************

        FixedDocument _fixedDocument;
        FixedPage _curFixedPage;
        Canvas _curCanvas;
        double _marginX;
        double _marginY;
        Size _infiniteSize = new Size(double.PositiveInfinity, double.PositiveInfinity);

        #endregion Data

        #region Properties
        //****************************************************************************************
        // Properties
        //****************************************************************************************

        /// <summary>Current font family used for known objects</summary>
        public FontFamily CurrentFontFamily { get; set; }


        /// <summary>Current font size used for known objects</summary>
        public double CurrentFontSize { get; set; }


        /// <summary>Current font weight used for known objects</summary>
        public FontWeight CurrentFontWeight { get; set; }


        /// <summary>Current font style used for known objects</summary>
        public FontStyle CurrentFontStyle { get; set; }


        /// <summary>Current margin for known objects</summary>
        public Thickness CurrentElementMargin { get; set; }


        /// <summary>Current background for known objects</summary>
        public Brush CurrentElementBackground { get; set; }


        /// <summary>Current foreground for known objects</summary>
        public Brush CurrentElementForeground { get; set; }


        /// <summary>Gets the current fixed document being worked on</summary>
        public FixedDocument CurrentFixedDocument
        {
            get { return _fixedDocument; }
        }


        /// <summary>The current horizontal position</summary>
        public double CurX { get; set; }


        /// <summary>The current vertical position</summary>
        public double CurY { get; set; }


        /// <summary>The starting and ending X margins on the page</summary>
        public double MarginX
        {
            get { return _marginX; }
            set
            {
                if (value < 0)
                    value = 0;
                _marginX = value;
                if (CurX < _marginX)
                    CurX = _marginX;
            }
        }


        /// <summary>The starting and ending Y margins on the page</summary>
        public double MarginY
        {
            get { return _marginY; }
            set
            {
                if (value < 0)
                    value = 0;
                _marginY = value;
                if (CurY < _marginY)
                    CurY = _marginY;
            }
        }


        /// <summary>Gets the page size for the document minus the margins</summary>
        public Size PageSizeUsed
        {
            get
            {
                Size sz = CurrentFixedDocument.DocumentPaginator.PageSize;
                sz.Width -= 2 * _marginX;
                sz.Height -= 2 * _marginY;
                return sz;
            }
        }

        #endregion Properties

        #region Construction
        //****************************************************************************************
        // Construction
        //****************************************************************************************

        /// <summary>
        /// Constructor for printing
        /// </summary>
        /// <param name="printQueue"></param>
        /// <param name="printTicket"></param>
        public WpfPrint(PrintQueue printQueue, PrintTicket printTicket)
        {
            PrintCapabilities capabilities = printQueue.GetPrintCapabilities(printTicket);

            Size sz = new Size(capabilities.PageImageableArea.ExtentWidth, capabilities.PageImageableArea.ExtentHeight);
            _fixedDocument = new FixedDocument();
            _fixedDocument.DocumentPaginator.PageSize = sz;

            StartPage();
        }


        /// <summary>
        /// Constructor for XPS creation
        /// </summary>
        /// <param name="sz"></param>
        public WpfPrint(Size sz)
        {
            _fixedDocument = new FixedDocument();
            _fixedDocument.DocumentPaginator.PageSize = sz;

            StartPage();
        }

        #endregion Construction

        #region Interfaces
        //****************************************************************************************
        // Interfaces
        //****************************************************************************************

        /// <summary>
        /// Add a new page to the document (start a new page)
        /// </summary>
        public void StartPage()
        {
            // Create a new page content and fixed page
            PageContent content = new PageContent();
            _fixedDocument.Pages.Add(content);
            _curFixedPage = new FixedPage();
            ((IAddChild)content).AddChild(_curFixedPage);

            // Create a new drawing canvas for the page
            _curCanvas = new Canvas();
            _curCanvas.Width = _fixedDocument.DocumentPaginator.PageSize.Width;
            _curCanvas.Height = _fixedDocument.DocumentPaginator.PageSize.Height;
            _curFixedPage.Children.Add(_curCanvas);

            // Reset the current position
            CurX = MarginX;
            CurY = MarginY;
        }


        /// <summary>
        /// Adds a new element at the current position, and updates the current position
        /// </summary>
        /// <param name="element">New element to add</param>
        /// <param name="flags">Print options</param>
        public void AddUIElement(UIElement element, ElementFlags flags)
        {
            element.Measure(_infiniteSize);
            if (CurX > _fixedDocument.DocumentPaginator.PageSize.Width - MarginX)
            {
                CurY += element.DesiredSize.Height;
                CurX = MarginX;
            }
            double extraCheck = 0;
            if ((flags & ElementFlags.BottomCheck2) == ElementFlags.BottomCheck2)
                extraCheck = element.DesiredSize.Height;
            if (CurY > _fixedDocument.DocumentPaginator.PageSize.Height - MarginY - extraCheck)
                StartPage();

            _curCanvas.Children.Add(element);
            element.SetValue(Canvas.LeftProperty, CurX);
            element.SetValue(Canvas.TopProperty, CurY);

            CurX += element.DesiredSize.Width;
            if ((flags & ElementFlags.NewLine) == ElementFlags.NewLine)
            {
                CurX = MarginX;
                CurY += element.DesiredSize.Height;
            }
        }


        /// <summary>
        /// Add a current style TextBlock element at the current position
        /// </summary>
        /// <param name="text">Text to add</param>
        /// <param name="width">Width of element</param>
        /// <param name="height">Height of element</param>
        /// <param name="flags">Print options</param>
        public void AddTextBlock(string text, double width, double height, ElementFlags flags)
        {
            TextBlock tb = new TextBlock();
            tb.Text = text;
            tb.FontFamily = CurrentFontFamily;
            tb.FontSize = CurrentFontSize;
            tb.FontWeight = CurrentFontWeight;
            tb.FontStyle = CurrentFontStyle;
            tb.VerticalAlignment = VerticalAlignment.Center;
            if ((flags & ElementFlags.HorzCenter) == ElementFlags.HorzCenter)
                tb.HorizontalAlignment = HorizontalAlignment.Center;
            else if ((flags & ElementFlags.HorzRight) == ElementFlags.HorzRight)
                tb.HorizontalAlignment = HorizontalAlignment.Right;
            tb.Margin = CurrentElementMargin;
            if (CurrentElementForeground != null)
                tb.Foreground = CurrentElementForeground;
            if (CurrentElementBackground != null)
                tb.Background = CurrentElementBackground;

            Grid grid = new Grid();
            if (CurrentElementBackground != null)
                grid.Background = CurrentElementBackground;
            if (width != 0)
                grid.Width = width;
            if (height != 0)
                grid.Height = height;
            grid.Children.Add(tb);

            AddUIElement(grid, flags);
        }


        /// <summary>
        /// Adds a current style TextBox element at the current position
        /// </summary>
        /// <param name="text">Text to add</param>
        /// <param name="width">Width of element</param>
        /// <param name="height">Height of element</param>
        /// <param name="flags">Print options</param>
        public void AddTextBox(string text, double width, double height, ElementFlags flags)
        {
            TextBox tb = new TextBox();
            tb.Text = text;
            tb.FontFamily = CurrentFontFamily;
            tb.FontSize = CurrentFontSize;
            tb.FontWeight = CurrentFontWeight;
            tb.FontStyle = CurrentFontStyle;
            tb.VerticalAlignment = VerticalAlignment.Center;
            tb.VerticalContentAlignment = VerticalAlignment.Center;
            if ((flags & ElementFlags.HorzCenter) == ElementFlags.HorzCenter)
                tb.HorizontalContentAlignment = HorizontalAlignment.Center;
            else if ((flags & ElementFlags.HorzRight) == ElementFlags.HorzRight)
                tb.HorizontalContentAlignment = HorizontalAlignment.Right;
            tb.Margin = CurrentElementMargin;
            if (CurrentElementBackground != null)
                tb.Background = CurrentElementBackground;
            if (CurrentElementForeground != null)
                tb.Foreground = CurrentElementForeground;

            Grid grid = new Grid();
            if (CurrentElementBackground != null)
                grid.Background = CurrentElementBackground;
            if (width != 0)
                grid.Width = width;
            if (height != 0)
                grid.Height = height;
            grid.Children.Add(tb);

            AddUIElement(grid, flags);
        }


        /// <summary>
        /// Add a current style CheckBox element at the current position
        /// </summary>
        /// <param name="value">Checkbox value to add</param>
        /// <param name="width">Width of element</param>
        /// <param name="height">Height of element</param>
        /// <param name="flags">Print options</param>
        public void AddCheckBox(bool value, double width, double height, ElementFlags flags)
        {
            CheckBox cb = new CheckBox();
            cb.IsChecked = value;
            cb.VerticalAlignment = VerticalAlignment.Center;
            if ((flags & ElementFlags.HorzCenter) == ElementFlags.HorzCenter)
                cb.HorizontalAlignment = HorizontalAlignment.Center;
            else if ((flags & ElementFlags.HorzRight) == ElementFlags.HorzRight)
                cb.HorizontalAlignment = HorizontalAlignment.Right;
            if (CurrentElementForeground != null)
                cb.Foreground = CurrentElementForeground;
            if (CurrentElementBackground != null)
                cb.Background = CurrentElementBackground;

            Grid grid = new Grid();
            if (CurrentElementBackground != null)
                grid.Background = CurrentElementBackground;
            if (width != 0)
                grid.Width = width;
            if (height != 0)
                grid.Height = height;
            grid.Children.Add(cb);

            AddUIElement(grid, flags);
        }

        #endregion Interfaces
    }
}

Hannie