Creating Documents and Reports

To illustrate the process of creating a C1Document, we will walk through the steps required to implement a simple assembly documentation utility.

To start, create a new project and add a reference to the C1.Silverlight and C1.Silverlight.RichTextBox assemblies. Then edit the page constructor as follows:

Imports C1.Silverlight

Imports C1.Silverlight.RichTextBox

Imports C1.Silverlight.RichTextBox.Documents

Public Partial Class MainPage

Inherits UserControl

' C1RichTextBox that will display the C1Document

Private _rtb As C1RichTextBox

Public Sub New()

' Default initialization

InitializeComponent()

' Create the C1RichTextBox and add it to the page

_rtb = New C1RichTextBox()

LayoutRoot.Children.Add(_rtb)

' Create document and show it in the C1RichTextBox

_rtb.Document = DocumentAssembly(GetType(C1RichTextBox).Assembly)

_rtb.IsReadOnly = True

End Sub

End Class

using C1.Silverlight;

using C1.Silverlight.RichTextBox;

using C1.Silverlight.RichTextBox.Documents;

public partial class MainPage : UserControl

// C1RichTextBox that will display the C1Document

  C1RichTextBox _rtb;

  public MainPage()

// Default initialization

    InitializeComponent();

// Create the C1RichTextBox and add it to the page

    _rtb = new C1RichTextBox();

    LayoutRoot.Children.Add(_rtb);

// Create document and show it in the C1RichTextBox

    _rtb.Document = DocumentAssembly(typeof(C1RichTextBox).Assembly);

    _rtb.IsReadOnly = true;

The code creates the C1RichTextBox and assigns its Document property to the result of a call to the DocumentAssembly method. It then makes the control read-only so users can't change the report.

The DocumentAssembly method takes an Assembly as argument and builds a C1Document containing the assembly documentation. Here is the implementation:

C1Document DocumentAssembly(Assembly asm)

// Create document

  C1Document doc = new C1Document();

  doc.FontFamily = new FontFamily("Tahoma");

// Assembly

  doc.Blocks.Add(new Heading1("Assembly\r\n" + asm.FullName.Split(',')[0]));

// Types

  foreach (Type t in asm.GetTypes())

    DocumentType(doc, t);

// Done

  return doc;

The method starts by creating a new C1Document object and setting its FontFamily property. This will be the default value for all text elements added to the document.

Next, the method adds a Heading1 paragraph containing the assembly name to the new document's Blocks collection. Blocks are elements such as paragraphs and list items that flow down the document. They are similar to "div" elements in HTML. Some document elements contain an Inlines collection instead. These collections contain elements that flow horizontally, similar to "span" elements in HTML.

The Heading1 class inherits from C1Paragraph and adds some formatting. We will add several such classes to the project, for normal paragraphs and headings 1 through 4.

The Normal paragraph is a C1Paragraph that takes a content string in its constructor:

class Normal : C1Paragraph

  public Normal(string text)

    this.Inlines.Add(new C1Run() { Text = text });

    this.Padding = new Thickness(30, 0, 0, 0);

    this.Margin = new Thickness(0);

Heading1 through Heading4 extend Heading to specify font sizes, padding, borders, and colors:

Class Heading1

Inherits Heading

Public Sub New(text As String)

MyBase.New(text)

Me.Background = New SolidColorBrush(Colors.Yellow)

Me.FontSize = 24

Me.Padding = New Thickness(0, 10, 0, 10)

Me.BorderBrush = New SolidColorBrush(Colors.Black)

Me.BorderThickness = New Thickness(3, 1, 1, 0)

End Sub

End Class

Class Heading2

Inherits Heading

Public Sub New(text As String)

MyBase.New(text)

Me.FontSize = 18

Me.FontStyle = FontStyles.Italic

Me.Background = New SolidColorBrush(Colors.Yellow)

Me.Padding = New Thickness(10, 5, 0, 5)

Me.BorderBrush = New SolidColorBrush(Colors.Black)

Me.BorderThickness = New Thickness(3, 1, 1, 1)

End Sub

End Class

Class Heading3

Inherits Heading

Public Sub New(text As String)

MyBase.New(text)

Me.FontSize = 14

Me.Background = New SolidColorBrush(Colors.LightGray)

Me.Padding = New Thickness(20, 3, 0, 0)

End Sub

End Class

Class Heading4

Inherits Heading

Public Sub New(text As String)

MyBase.New(text)

Me.FontSize = 14

Me.Padding = New Thickness(30, 0, 0, 0)

End Sub

End Class

class Heading1 : Heading

  public Heading1(string text) : base(text)

    this.Background = new SolidColorBrush(Colors.Yellow);

    this.FontSize = 24;

    this.Padding = new Thickness(0, 10, 0, 10);

    this.BorderBrush = new SolidColorBrush(Colors.Black);

    this.BorderThickness = new Thickness(3, 1, 1, 0);

class Heading2 : Heading

  public Heading2(string text): base(text)

    this.FontSize = 18;

    this.FontStyle = FontStyles.Italic;

    this.Background = new SolidColorBrush(Colors.Yellow);

    this.Padding = new Thickness(10, 5, 0, 5);

    this.BorderBrush = new SolidColorBrush(Colors.Black);

    this.BorderThickness = new Thickness(3, 1, 1, 1);

class Heading3 : Heading

  public Heading3(string text) : base(text)

    this.FontSize = 14;

    this.Background = new SolidColorBrush(Colors.LightGray);

    this.Padding = new Thickness(20, 3, 0, 0);

class Heading4 : Heading

  public Heading4(string text): base(text)

    this.FontSize = 14;

    this.Padding = new Thickness(30, 0, 0, 0);

Now that we have classes for all paragraph types in the document, it's time to add the content. Recall that we used a DocumentType method in the first code block. Here is the implementation for that method:

Private Sub DocumentType(doc As C1Document, t As Type)

' Skip non-public/generic

If Not t.IsPublic OrElse t.ContainsGenericParameters Then

Return

End If

' Type

doc.Blocks.Add(New Heading2("Class " & Convert.ToString(t.Name)))

' Properties

doc.Blocks.Add(New Heading3("Properties"))

For Each pi As PropertyInfo In t.GetProperties()

If pi.DeclaringType = t Then

DocumentProperty(doc, pi)

End If

' Methods

doc.Blocks.Add(New Heading3("Methods"))

For Each mi As MethodInfo In t.GetMethods()

If mi.DeclaringType = t Then

DocumentMethod(doc, mi)

End If

' Events

doc.Blocks.Add(New Heading3("Events"))

For Each ei As EventInfo In t.GetEvents()

If ei.DeclaringType = t Then

DocumentEvent(doc, ei)

End If

End Sub

void DocumentType(C1Document doc, Type t)

// Skip non-public/generic

  if (!t.IsPublic || t.ContainsGenericParameters)

    return;

// Type

  doc.Blocks.Add(new Heading2("Class " + t.Name));

// Properties

  doc.Blocks.Add(new Heading3("Properties"));

  foreach (PropertyInfo pi in t.GetProperties())

    if (pi.DeclaringType == t)

      DocumentProperty(doc, pi);

// Methods

  doc.Blocks.Add(new Heading3("Methods"));

  foreach (MethodInfo mi in t.GetMethods())

    if (mi.DeclaringType == t)

      DocumentMethod(doc, mi);

// Events

  doc.Blocks.Add(new Heading3("Events"));

  foreach (EventInfo ei in t.GetEvents())

    if (ei.DeclaringType == t)

      DocumentEvent(doc, ei);

The method adds a Heading2 paragraph with the class name and then uses reflection to enumerate all the public properties, events, and methods in the type. The code for these methods is simple:

void DocumentProperty(C1Document doc, PropertyInfo pi)

  if (pi.PropertyType.ContainsGenericParameters)

    return;

  doc.Blocks.Add(new Heading4(pi.Name));

  var text = string.Format("public {0} {1} {{ {2}{3} }}",

pi.PropertyType.Name,

pi.Name,

pi.CanRead ? "get; " : string.Empty,

    pi.CanWrite ? "set; " : string.Empty);

  doc.Blocks.Add(new Normal(text));

The method adds a Heading4 paragraph containing the property name, then some Normal text containing the property type, name, and accessors.

Private Sub DocumentMethod(doc As C1Document, mi As MethodInfo)

If mi.IsSpecialName Then

Return

End If

doc.Blocks.Add(New Heading4(mi.Name))

Dim parms = New StringBuilder()

For Each parm As var In mi.GetParameters()

If parms.Length > 0 Then

parms.Append(", ")

End If

parms.AppendFormat("{0} {1}", parm.ParameterType.Name, parm.Name)

Dim text = String.Format("public {0} {1}({2})", mi.ReturnType.Name, mi.Name, parms.ToString())

doc.Blocks.Add(New Normal(text))

End Sub

Private Sub DocumentEvent(doc As C1Document, ei As EventInfo)

doc.Blocks.Add(New Heading4(ei.Name))

Dim text = String.Format("public {0} {1}", ei.EventHandlerType.Name, ei.Name)

doc.Blocks.Add(New Normal(text))

End Sub

void DocumentMethod(C1Document doc, MethodInfo mi)

  if (mi.IsSpecialName)

    return;

  doc.Blocks.Add(new Heading4(mi.Name));

  var parms = new StringBuilder();

  foreach (var parm in mi.GetParameters())

    if (parms.Length > 0)

      parms.Append(", ");

    parms.AppendFormat("{0} {1}", parm.ParameterType.Name, parm.Name);

  var text = string.Format("public {0} {1}({2})",

mi.ReturnType.Name,

mi.Name,

    parms.ToString());

  doc.Blocks.Add(new Normal(text));

void DocumentEvent(C1Document doc, EventInfo ei)

  doc.Blocks.Add(new Heading4(ei.Name));

  var text = string.Format("public {0} {1}",

ei.EventHandlerType.Name,

    ei.Name);

  doc.Blocks.Add(new Normal(text));

The resulting document can be viewed and edited in the C1RichTextBox like any other. It can also be exported to HTML using the Html property in the C1RichTextBox, or copied through the clipboard to applications such as Microsoft Word or Excel.

You could use the same technique to create reports based on data from a database. In addition to formatted text, the C1Document object model supports the following features:

• Lists
Lists are created by adding C1List objects to the document. The C1List object has a ListItems property that contains C1ListItem objects, which are also blocks.

• Hyperlinks
Hyperlinks are created by adding C1Hyperlink objects to the document. The C1Hyperlink object has an Inlines property that contains a collection of runs (typically C1Run elements that contain text), and a NavigateUrl property that determines the action to be taken when the hyperlink is clicked.

• Images
Images and other FrameworkElement objects are created by adding C1BlockUIContainer objects to the document. The C1BlockUIContainer object has a Child property that can be set to any FrameworkElement object.
Note that not all objects can be exported to HTML. Images are a special case that the HTML filter knows how to handle.