WebSVN – DevTools – Diff – /EA_DocGen/trunk/EA_DocGen/createWordDoc.cs

 using System;
 using System.Drawing;
 using System.Collections;
+using System.Text;
 using System.ComponentModel;
 using System.Windows.Forms;
 using Word;
 using Microsoft.Office.Core;
+   {
       // Enterprise Architect Model related data
       private EA.Repository EA_Repository = null;
       private EA.Package EA_ParentPackage = null;
       private EA.Project EA_Project;
       private EA_Utilities EA_Utils = null;
+      private TabularContent TableUtils = null;
+      private TextualContent TextUtils = null;
+      private StyleContent   StyleUtils = null;
       private bool oneShot_skipRootPackage = false;
+      private bool oneShot_skipRootElementHeading = false;
+      // This data is designed to support unit test traceability. As such, it is only of real use
+      // when making s/w design documents. It allows all non-private classes to be collected into
+      // a list in order to generate a design-to-unit-test traceability table.
+      private bool recordingNonPrivateClasses = false;
+      private ArrayList nonPrivateClasses = null;
+      private ArrayList classesWithUnitTests = null;
+      private Word.Table utTraceabilityTable = null;
       // MS-Office Word related data
       private Word.Application WordApp = null;
       private Word.Document WordDocument = null;
-      private Word.Range WordRange;
-      private object startLocation;
-      private object endLocation;
       private int[] DocSection = null;
       private int   iDocSection = 0;
-      // Some style names used in EA_DocGen - most are expected to exist in the input template/doc
-      // but the Requirement formatting styles are programmatcally generated if they are found to not
-      // exist. The reason for this is that as of writing this add-in, they do not exist in the ERG
-      // standard template.
-      private const string styleName_ReqAppBody  = "Requirements Approved Body";
-      private const string styleName_ReqAppHdr   = "Requirements Approved Heading";
-      private const string styleName_ReqPropBody = "Requirements Proposed Body";
-      private const string styleName_ReqPropHdr  = "Requirements Proposed Heading";
-      private const string styleName_ReqRejBody  = "Requirements Rejected Body";
-      private const string styleName_ReqRejHdr   = "Requirements Rejected Heading";
-      private const string styleName_ReqName     = "Requirements Name";
-      private const string styleName_Body1       = "Body 1";
-      private const string styleName_Heading1    = "Heading 1";
-      private const string styleName_Heading2    = "Heading 2";
-      private const string styleName_Heading3    = "Heading 3";
-      private const string styleName_Heading4    = "Heading 4";
-      private const string styleName_Heading5    = "Heading 5";
-      private const string styleName_Heading6    = "Heading 6";
-      private const string styleName_Heading7    = "Heading 7";
-      private const string styleName_Heading8    = "Heading 8";
-      private const string styleName_Heading9    = "Heading 9";
-      private const string styleName_NumPara1    = "NumPara 1";
-      private const string styleName_NumPara2    = "NumPara 2";
-      private const string styleName_NumPara3    = "NumPara 3";
-      private const string styleName_NumPara4    = "NumPara 4";
-      private const string styleName_NumPara5    = "NumPara 5";
-      private const string styleName_NumPara6    = "NumPara 6";
-      private const string styleName_NumPara7    = "NumPara 7";
-      private const string styleName_NumPara8    = "NumPara 8";
-      private const string styleName_NumPara9    = "NumPara 9";
-      private const string styleName_TableText   = "Table Text";
-      private const string styleName_RefListNum  = "Reference List Number";
-      private const string styleName_RefListText = "Reference List Text";
-      private const string styleName_Normal      = "Normal";
       private System.Windows.Forms.TextBox textBox_template;
       private System.Windows.Forms.Button button_browse_template;
       private System.Windows.Forms.TextBox textBox_output_file;
       private System.Windows.Forms.Button button_browse_output_file;
       private System.Windows.Forms.Button button_cancel;
          EA_ParentPackage = theParentPackage;
          EA_Project       = EA_Repository.GetProjectInterface();
          EA_Utils         = theEA_Utils;
+         TableUtils       = new TabularContent(WordApp, WordDocument);
+         TextUtils        = new TextualContent(WordApp, WordDocument);
+         StyleUtils       = new StyleContent(WordApp, WordDocument);
          DocSection = new int[12];
          for (int i=0; i<DocSection.Length; i++)
+         {
             DocSection[i] = 0;
+         }
          WordApp = new Word.Application();
+      }
       /// <summary>
       /// Clean up any resources being used.
       /// </summary>
       protected override void Dispose( bool disposing )
+      {
+      {
          if (WordApp != null)
+         {
             WordApp.Visible = true;
+         }
+         button_view_output.Enabled = false;
+      }
+      {
          if (this.textBox_template.Text.Length > 0)
+         {
             if (this.textBox_output_file.Text.Length > 0)
+            {
+               button_generate.Enabled = false;
                createTheWordDoc();
+            }
             else
+            {
                MessageBox.Show("Error - must specify an output file");
+      {
          public ArrayList Elements = null;
          private ArrayList validElementTypes = null;
+         private EA_Utilities EA_Utils = null;
-         public ElementAccumulator(ArrayList elementTypeList): base()
+         public ElementAccumulator(ArrayList elementTypeList, EA_Utilities theEA_Utils): base()
+         {
             validElementTypes = elementTypeList;
+            EA_Utils = theEA_Utils;
             Elements = new ArrayList();
+         }
          public override void processElement( EA.Element theElement )
+         {
             if (validElementTypes.Contains( theElement.Type ))
+            {
-               if ( (theElement.Type == "Requirement") && (theElement.Status == "Rejected") )
+               //if ( (theElement.Type == "Requirement") && (theElement.Status == "Rejected") )
-                  return;
+               //   return;
+               if (   0 == theElement.Type.CompareTo("Class")
+                  && true == EA_Utils.options.opt_SuppressPrivateClasses
+                  && true == theElement.Visibility.StartsWith("Private") )
+               {
+                  // do nothing
+               }
+               else
-               Elements.Add( theElement );
+                  Elements.Add( theElement );
+            }
+         }
+      }
       private void displayProgress(string prefix, string EA_string)
+      {
          textBox_progress.AppendText( prefix + EA_string + "\r\n" );
          // Display to the output tab as well - as a longer term record of what happened
-         string s = "";
+         StringBuilder sb = new StringBuilder("");
          for (int i = 1; i<=iDocSection; i++)
+         {
             if (i!=1)
-               s = s + ".";
+               sb.Append(".");
-            s = s + DocSection[i].ToString();
+            sb.Append(DocSection[i].ToString());
+         }
-         while (s.Length < 30)
+         while (sb.Length < 30)
-            s += " ";
+            sb.Append(" ");
+         sb.Append(prefix);
+         sb.Append(EA_string);
-         EA_Repository.WriteOutput( Main.GUI_OUTPUT_TAB_NAME, s + prefix + EA_string, 0);
+         EA_Repository.WriteOutput( Main.GUI_OUTPUT_TAB_NAME, sb.ToString(), 0);
+      }
       /// <summary>
       /// This method takes the specified EA diagram element and puts the diagram image
       private void appendAndSelectDiagramViaClipboard(EA.Diagram theDiagram)
+      {
          // open the diagram in EA and copy it's image to the clipboard
          if (EA_Project.PutDiagramImageOnClipboard(theDiagram.DiagramGUID,0))
+         {
+            object startLocation;
+            object endLocation;
             // create a range at the end of the document
             startLocation = WordDocument.Content.End;
             WordDocument.Content.InsertParagraphAfter();
             endLocation = WordDocument.Content.End;
-            WordRange = WordDocument.Range(ref startLocation, ref endLocation);
+            Word.Range WordRange = WordDocument.Range(ref startLocation, ref endLocation);
             object direction = Word.WdCollapseDirection.wdCollapseEnd;
             WordRange.Collapse(ref direction);  // collapse prevents existing content being replaced
             // Get ready for the diagram paste and the formatting we want to do on it with the
             // selection object.
-            SelectInsertionPointAtEndOfDocument();
+            TextUtils.SelectInsertionPointAtEndOfDocument();
             // Paste the diagram into the document
             WordRange.Paste();
             // Set style of the diagram to "Normal" so that it can occupy space all the way to the left margin
-            object l_style = styleName_Normal;
+            object l_style = EA_Constants.styleName_Normal;
             endLocation = WordDocument.Content.End;
             WordRange = WordDocument.Range(ref startLocation, ref endLocation);
             WordRange.set_Style(ref l_style);
             // Center the diagram on the page
             WordApp.Selection.MoveDown( ref unit, ref count, ref missing);
             WordApp.Selection.ParagraphFormat.Alignment = Word.WdParagraphAlignment.wdAlignParagraphCenter;
             // Add a caption
             WordDocument.Content.InsertParagraphAfter();
-            SelectInsertionPointAtEndOfDocument();
+            TextUtils.SelectInsertionPointAtEndOfDocument();
             object Label = "Figure";
             object Title = Type.Missing;
             object TitleAutoText = Type.Missing;
             object Position = Word.WdCaptionPosition.wdCaptionPositionAbove;
             object ExcludeLabel = 0;
             // Close the diagram in EA
             EA_Repository.CloseDiagram(theDiagram.DiagramID);
+         }
+      }
-      /// <summary>
-      /// Appends a specified text string to the word document, selects the new text, and applies
-      /// the specified style formatting to it.
-      /// </summary>
-      /// <param name="wordText"></param>
-      /// <param name="styleText"></param>
-      /// <param name="continuation"></param>
-      private void appendAndSelectText(string wordText, string styleText)
-      {
-         appendAndSelectText(wordText, styleText, false );
-      }
-      private void appendAndSelectText(string wordText, string styleText, bool continuation )
-      {
-         if (wordText.Length > 0)
-         {
-            object style = styleText;
-            int i;
-            startLocation = 0;
-            endLocation = i = WordDocument.Content.End;
-            WordRange = WordDocument.Range(ref startLocation, ref endLocation);
-            if (!continuation)
-               WordRange.InsertAfter( "\n" );
-            WordRange.InsertAfter( wordText );
-            // Make a range out of the pasted text
-            startLocation = i;
-            endLocation = WordDocument.Content.End;
-            WordRange = WordDocument.Range(ref startLocation, ref endLocation);
-            // and set the pasted text style
-            WordRange.set_Style(ref style);
-         }
-      }
-      /// <summary>
-      /// Appends a specified text string to the word document, selects the new text, and applies
-      /// a heading level style to it.
-      /// </summary>
-      /// <param name="wordText"></param>
-      /// <param name="level"></param>
-      private void appendAndSelectHeadingText(string wordText, int level)
-      {
-         // Convert level to heading style
-         string styleText;
-         switch(level)
-         {
-            case 1: styleText = styleName_Heading1; break;
-            case 2: styleText = styleName_Heading2; break;
-            case 3: styleText = styleName_Heading3; break;
-            case 4: styleText = styleName_Heading4; break;
-            case 5: styleText = styleName_Heading5; break;
-            case 6: styleText = styleName_Heading6; break;
-            case 7: styleText = styleName_Heading7; break;
-            case 8: styleText = styleName_Heading8; break;
-            case 9: styleText = styleName_Heading9; break;
-            default: styleText = styleName_Heading9; break;
-         }
-         // append the text as a heading
-         appendAndSelectText(wordText, styleText);
-      }
-      /// <summary>
-      /// Appends a specified text string to the word document, selects the new text, and applies
+      #region special element processing functions (link elements, table and text elements, etc)
-      /// a num para heading level style to it.
-      /// </summary>
-      /// <param name="wordText"></param>
-      /// <param name="level"></param>
-      private void appendAndSelectNumParaText(string wordText, int level)
-      {
-         // Convert level to heading style
-         string styleText;
-         switch(level)
-         {
-            case 1: styleText = styleName_NumPara1; break;
-            case 2: styleText = styleName_NumPara2; break;
-            case 3: styleText = styleName_NumPara3; break;
-            case 4: styleText = styleName_NumPara4; break;
-            case 5: styleText = styleName_NumPara5; break;
-            case 6: styleText = styleName_NumPara6; break;
-            case 7: styleText = styleName_NumPara7; break;
-            case 8: styleText = styleName_NumPara8; break;
-            case 9: styleText = styleName_NumPara9; break;
-            default: styleText = styleName_NumPara9; break;
-         }
-         // append the text as a heading
-         appendAndSelectText(wordText, styleText);
-      }
-      private void SelectInsertionPointAtEndOfDocument()
-      {
-         object unit;
-         object extend;
-         unit = Word.WdUnits.wdStory;
-         extend = Word.WdMovementType.wdMove;
-         WordApp.Selection.EndKey(ref unit, ref extend);
-      }
       /// <summary>
       /// This is an attempt to create a table similar in style to those made by the ERG doc template macros.
       /// It is not exaclty that same though, and further work could be done to align it more precisely.
       /// </summary>
       /// <param name="tableTitle"></param>
       /// <param name="numRows"></param>
       /// <param name="numCols"></param>
       /// <returns></returns>
-      private int createTable(string tableTitle, int numRows, int numCols)
-      {
-         WordDocument.Content.InsertParagraphAfter();
-         SelectInsertionPointAtEndOfDocument();
-         object Label = "Table";
-         object Title = Type.Missing;
-         object TitleAutoText = Type.Missing;
-         object Position = Word.WdCaptionPosition.wdCaptionPositionAbove;
-         object ExcludeLabel = 0;
-         WordApp.Selection.InsertCaption( ref Label, ref Title, ref TitleAutoText, ref Position, ref ExcludeLabel);
-         WordApp.Selection.TypeText( ": " + tableTitle);
-         WordApp.Selection.ParagraphFormat.Alignment = Word.WdParagraphAlignment.wdAlignParagraphCenter;
-         startLocation = WordDocument.Content.End;
-         WordDocument.Content.InsertParagraphAfter();
-         endLocation = WordDocument.Content.End;
-         WordRange = WordDocument.Range(ref startLocation, ref endLocation);
-         object defaultTableBehaviour = Type.Missing;
-         object autofitBehaviour = Type.Missing;
-         Word.Table Table = WordDocument.Tables.Add( WordRange, numRows, numCols, ref defaultTableBehaviour, ref autofitBehaviour );
-         Table.Rows[1].Shading.BackgroundPatternColor = Word.WdColor.wdColorGray10;
-         Table.Borders.OutsideLineStyle = Word.WdLineStyle.wdLineStyleSingle;
-         Table.Borders.InsideLineStyle = Word.WdLineStyle.wdLineStyleSingle;
-         Table.Select();
-         object tableTextStyle = styleName_TableText;
-         Table.Range.set_Style( ref tableTextStyle );
-         return WordDocument.Tables.Count;
-      }
       /// <summary>
       /// This function process a package link element, parsing each linked package by the
       /// parse_package() recursive function.
       /// </summary>
       /// <param name="theElement"></param>
          foreach(string s in EA_DocGenEleLnk)
+         {
             if (s.Length > 0 && s != "\n" && s != "\r")
+            {
+               if (s == "skiproot")
+               {
+                  oneShot_skipRootElementHeading = true;
+               }
-               if ( s[0] == '{')
+               else if ( s[0] == '{')
+               {
                   EA.Element theFoundElement = EA_Utils.EA_Finder.findElementInRepositoryByGUID(s);
                   if (theFoundElement != null)
+                  {
                      parse_element( theFoundElement, recurse_level );
                MessageBox.Show( "Table Element Serialisation Failed - Insufficient Rows" );
+            }
             else
+            {
                // create the table in the word doc
-               int tableNum = createTable( tableTitle, rowCount, columnCount );
+               int tableNum = TableUtils.Table_Create( tableTitle, rowCount, columnCount );
                Word.Table table = WordDocument.Tables[tableNum];
                object center = Word.WdParagraphAlignment.wdAlignParagraphCenter;
                // scan the element notes again to extract the cell content and add it to the
                // table we just created.
             MessageBox.Show( "Table Element Serialisation Failed - Table Parameters Incomplete" );
+         }
+      }
+      /// <summary>
+      /// This function processes a test link element
+      /// </summary>
+      /// <param name="theElement"></param>
+      /// <param name="recurse_level"></param>
+      private void processTestLink(EA.Element theElement, int recurse_level )
+      {
+         string [] EA_DocGenEleLnk = null;
+         string delimStr = "\r\n";
+         char [] delim = delimStr.ToCharArray();
+         EA_DocGenEleLnk = theElement.Notes.ToString().Split(delim,100);
+         string linkedName = "";
+         foreach(string s in EA_DocGenEleLnk)
+         {
+            if (s.Length > 0 && s != "\n" && s != "\r")
+            {
+               if ( s[0] == '{')
+               {
+                  try
+                  {
+                     // try to find the GUID as a package
+                     EA.Package theFoundPackage = EA_Utils.EA_Finder.findPackageInRepositoryByGUID(s);
+                     if (theFoundPackage != null)
+                        TextUtils.appendUnitTestSuite(theFoundPackage, recurse_level, ref classesWithUnitTests);
+                     else
+                     {
+                        // try to find the GUID as an element
+                        EA.Element theFoundElement = EA_Utils.EA_Finder.findElementInRepositoryByGUID(s);
+                        if (theFoundElement != null)
+                           TextUtils.appendUnitTestSuite(theFoundElement, recurse_level, ref classesWithUnitTests);
+                        else
+                           MessageBox.Show("WARNING - Could not find linked element : " + linkedName );
+                     }
+                  }
+                  catch
+                  {
+                     // try to find the GUID as an element
+                     EA.Element theFoundElement = EA_Utils.EA_Finder.findElementInRepositoryByGUID(s);
+                     if (theFoundElement != null)
+                        TextUtils.appendUnitTestSuite(theFoundElement, recurse_level, ref classesWithUnitTests);
+                     else
+                        MessageBox.Show("WARNING - Could not find linked element : " + linkedName );
+                  }
+               }
+               else
+               {
+                  linkedName = s;
+               }
+            }
+         }
+      }
       /// <summary>
       /// This function process a text element. It is a simple wrapper for the
       /// appendAndSelectText()function.
       /// </summary>
       /// <param name="theElement"></param>
       /// <param name="recurse_level"></param>
       private void processTextElement(EA.Element theElement, int recurse_level )
+      {
-         appendAndSelectText( theElement.Notes.ToString(), styleName_Body1 );
+         TextUtils.appendAndSelectText( theElement.Notes.ToString(), EA_Constants.styleName_Body1 );
+      }
+      /// <summary>
+      /// This function will insert a relationship matrix table into the document, built from content
+      /// specified in options that are provided in the notes section of the special element that
+      /// has led to this function being called.
+      /// </summary>
+      /// <param name="theElement"></param>
+      /// <param name="recurse_level"></param>
+      private void processRelationshipMatrixElement( EA.Element theElement, int recurse_level )
+      {
+         int tableNum = 0;
+         Word.Table table = null;
+         // process the options for the relationship matrix
+         EA_RelationshipMatrix EA_RelMatrix = new EA_RelationshipMatrix(EA_Utils);
+         if (!EA_RelMatrix.processRelationshipMatrixOptions( theElement ))
+         {
+            return;  // must have been an error
+         }
+         // Scan the fromPackage to find all the "from elements".
+         ElementAccumulator fromLister = new ElementAccumulator(EA_RelMatrix.fromElementTypes, EA_Utils);
+         EA_Utils.findAndProcessPackageElements( EA_RelMatrix.fromPackage, fromLister, EA_RelMatrix.fromPackageRecursion );
+         // Sort the "from elements"
+         elementSortByName sorter = new elementSortByName();
+         fromLister.Elements.Sort( sorter );
+         // dictionary to support from-to table construction.
+         ArrayList fromToDictionary = new ArrayList();
+         // dictionary to support to-from table construction.
+         ArrayList toFromDictionary = new ArrayList();
+         bool needFromToTable = false;
+         if (EA_RelMatrix.fromToTableTitle != null && EA_RelMatrix.fromToTableTitle.Length > 0)
+            needFromToTable = true;
+         bool needToFromTable = false;
+         if (EA_RelMatrix.toFromTableTitle != null && EA_RelMatrix.toFromTableTitle.Length > 0)
+            needToFromTable = true;
+         // NOTE: this code has to execute even if no from-to table is needed, in order to support the
+         // generation of a to-from table, assuming the user has requested one.
+         int numberOfFromToRows = 0;
+         foreach(EA.Element fromElement in fromLister.Elements)
+         {
+            // look at the elements connection collection to find references to the
+            // destination elements
+            bool foundToElement = false;
+            EA.Collection conCollection = fromElement.Connectors;
+            foreach (EA.Connector thisCon in conCollection)
+            {
+               EA.Element destE = EA_Repository.GetElementByID( thisCon.SupplierID );
+               if (destE == null)
+                  continue;
+               // ignore self-referential connections
+               if (fromElement.ElementID == thisCon.SupplierID)
+                  continue;
+               // if the destination element is of a type that the user has requested to include...
+               if (!EA_RelMatrix.toElementTypes.Contains( destE.Type ))
+                  continue;
+               // Capture the from-to relationship in a dictionary where the key is the
+               // "from element", and the value is the "to element".
+               DictionaryEntry newFromToEntry = new DictionaryEntry(fromElement, destE);
+               fromToDictionary.Add( newFromToEntry );
+               foundToElement = true;
+               // Capture the from-to relationship in a dictionary where the key is the
+               // ID of the destination element, and the value is the from element name.
+               // This dictionary will enable rapid construction of the to-from table if
+               // the user has requested it, from the exact same relationship info used
+               // to construct the from-to table.
+               if (needToFromTable)
+               {
+                  DictionaryEntry newToFromEntry = new DictionaryEntry(destE.ElementID, fromElement.Name);
+                  toFromDictionary.Add( newToFromEntry );
+               }
+            }
+            // If we found a from-to relationship that table needs a new row.
+            if (foundToElement)
+            {
+               numberOfFromToRows++;
+            }
+               // If we did not find a from-to relationship that table still needs a new row
+               // if the user wants all "from elements", even if some have no "to elements".
+            else if (EA_RelMatrix.fromPackageTrimming == false)
+            {
+               DictionaryEntry newFromToEntry = new DictionaryEntry(fromElement, null);
+               fromToDictionary.Add( newFromToEntry );
+               numberOfFromToRows++;
+            }
+         }
+         if (needFromToTable)
+         {
+            // Now we can actually serialise the table
+            if (EA_RelMatrix.fromIntroText != null && EA_RelMatrix.fromIntroText.Length > 0)
+            {
+               TextUtils.appendAndSelectText( EA_RelMatrix.fromIntroText, EA_Constants.styleName_Body1 );
+            }
+            // create the from-to table in the word doc
+            tableNum = TableUtils.Table_Create( EA_RelMatrix.fromToTableTitle, numberOfFromToRows + 1, 2 );
+            table = WordDocument.Tables[tableNum];
+            TableUtils.Table_SetTableColumnTitle(table, EA_RelMatrix.fromColumnTitle, 1);
+            TableUtils.Table_SetTableColumnTitle(table, EA_RelMatrix.toColumnTitle, 2);
+            int row = 1;
+            int lastFromElementId = -1;
+            bool firstFromToCon = true;
+            foreach (DictionaryEntry de in fromToDictionary)
+            {
+               if ( ((EA.Element)de.Key).ElementID != lastFromElementId )
+               {
+                  lastFromElementId = ((EA.Element)de.Key).ElementID;
+                  row++;
+                  table.Cell(row,1).Range.Text = ((EA.Element)de.Key).Name;
+                  firstFromToCon = true;
+               }
+               if (((EA.Element)de.Value) != null)
+               {
+                  if (firstFromToCon)
+                  {
+                     firstFromToCon = false;
+                     table.Cell(row,2).Range.Text = ((EA.Element)de.Value).Name;
+                  }
+                  else
+                  {
+                     table.Cell(row,2).Range.Text += ((EA.Element)de.Value).Name;
+                  }
+               }
+               else
+               {
+                  table.Cell(row,2).Range.Text = "Un-allocated relationship!";
+                  table.Cell(row,2).Range.Font.Color = Word.WdColor.wdColorRed;
+               }
+            }
+         }
+         // Does user want a to-from table ?
+         if (needToFromTable)
+         {
+            // re-use the fromToDictionary to prepare the to-from table content
+            fromToDictionary.Clear();
+            // find all elements for the left hand column of the to-from table.
+            ElementAccumulator toLister = new ElementAccumulator(EA_RelMatrix.toElementTypes, EA_Utils);
+            EA_Utils.findAndProcessPackageElements( EA_RelMatrix.toPackage, toLister, EA_RelMatrix.toPackageRecursion );
+            // Sort the "to" elements
+            toLister.Elements.Sort( sorter );
+            // To make the to-from table, we use the dictionary that was built when making the from-to
+            // table. The dictionary will allow rapid determination of what "from" items belong to each
+            // "to" item, without us having to go back to EA and enquire on the database.
+            // We build a new fromToDictionary from the toFromDictionary, in advance of actually making
+            // the table so that we can figure out how many rows the table needs to have.
+            numberOfFromToRows = 0;
+            foreach(EA.Element toElement in toLister.Elements)
+            {
+               bool foundToElement = false;
+               // right-column cell content
+               foreach (DictionaryEntry de in toFromDictionary)
+               {
+                  if ((int)de.Key == toElement.ElementID)
+                  {
+                     DictionaryEntry newFromToEntry = new DictionaryEntry(toElement, (string)de.Value);
+                     fromToDictionary.Add( newFromToEntry );
+                     foundToElement = true;
+                  }
+               }
+               // If we found a from-to relationship that table needs a new row.
+               if (foundToElement)
+               {
+                  numberOfFromToRows++;
+               }
+                  // if user wants all "from elements", even if some have no "to elements", then add a dictionary
+                  // entry and bump row count.
+               else if (EA_RelMatrix.toPackageTrimming == false)
+               {
+                  DictionaryEntry newFromToEntry = new DictionaryEntry(toElement, "");
+                  fromToDictionary.Add( newFromToEntry );
+                  numberOfFromToRows++;
+               }
+            }
+            // Now begin to add the to-from table to the word document
+            if (EA_RelMatrix.toIntroText != null && EA_RelMatrix.toIntroText.Length > 0)
+            {
+               TextUtils.appendAndSelectText( EA_RelMatrix.toIntroText, EA_Constants.styleName_Body1 );
+            }
+            // create the table in the word doc
+            tableNum = TableUtils.Table_Create( EA_RelMatrix.toFromTableTitle, numberOfFromToRows + 1, 2 );
+            table = WordDocument.Tables[tableNum];
+            TableUtils.Table_SetTableColumnTitle(table, EA_RelMatrix.toColumnTitle, 1);
+            TableUtils.Table_SetTableColumnTitle(table, EA_RelMatrix.fromColumnTitle, 2);
+            int lastFromElementId = -1;
+            bool firstToFromCon = true;
+            int row = 1;
+            foreach (DictionaryEntry de in fromToDictionary)
+            {
+               if ( ((EA.Element)de.Key).ElementID != lastFromElementId )
+               {
+                  lastFromElementId = ((EA.Element)de.Key).ElementID;
+                  row++;
+                  table.Cell(row,1).Range.Text = ((EA.Element)de.Key).Name;
+                  firstToFromCon = true;
+               }
+               if (((string)de.Value).Length > 0)
+               {
+                  if (firstToFromCon)
+                  {
+                     firstToFromCon = false;
+                     table.Cell(row,2).Range.Text = (string)de.Value;
+                  }
+                  else
+                  {
+                     table.Cell(row,2).Range.Text += (string)de.Value;
+                  }
+               }
+               else
+               {
+                  table.Cell(row,2).Range.Text = "Un-allocated relationship!";
+                  table.Cell(row,2).Range.Font.Color = Word.WdColor.wdColorRed;
+               }
+            }
+         }
+      }
+      private void processTestTraceability( EA.Element theElement, int recurse_level )
+      {
+         if (nonPrivateClasses.Count > 0)
+         {
+            if (theElement.Notes.Length > 0)
+            {
+               TextUtils.appendAndSelectText( theElement.Notes, EA_Constants.styleName_Body1);
+            }
+            int tableNum = TableUtils.Table_Create("Design Element to Unit Test Suite Traceability", 2, 2);
+            utTraceabilityTable = WordDocument.Tables[tableNum];
+            TableUtils.Table_SetTableColumnTitle(utTraceabilityTable, "Design Element (class)", 1);
+            TableUtils.Table_SetTableColumnTitle(utTraceabilityTable, "Test Suite", 2);
+         }
+      }
+      private void completeTestTraceability()
+      {
+         if (utTraceabilityTable != null)
+         {
+            int numClassesRemaining = nonPrivateClasses.Count;
+            int row = 2;
+            foreach(int elementId in nonPrivateClasses)
+            {
+               EA.Element theElement = EA_Repository.GetElementByID( elementId );
+               if (theElement != null)
+               {
+                  utTraceabilityTable.Cell(row,1).Range.Text = theElement.Name;
+                  if (classesWithUnitTests.Contains( elementId ))
+                  {
+                     utTraceabilityTable.Cell(row,2).Range.Text = TextUtils.testSuiteName(theElement);
+                  }
+                  else
+                  {
+                     utTraceabilityTable.Cell(row,2).Range.Text = "Missing tests!";
+                     utTraceabilityTable.Cell(row,2).Range.Font.Color = Word.WdColor.wdColorRed;
+                  }
+               }
+               numClassesRemaining--;
+               if (numClassesRemaining > 0)
+               {
+                  TableUtils.Table_InsertNewRowAfterThisRow(utTraceabilityTable, row);
+                  row++;
+               }
+            }
+         }
+      }
+      #endregion
+      #region special section processing functions (references, terminology, etc)
       /// <summary>
       /// This function processes elements as if they represented document references for
       /// the References section of a document.
       /// </summary>
       /// <param name="thePackage"></param>
+      {
          foreach(EA.Element theElement in thePackage.Elements)
+         {
             // Here we want to apply the special ERG template styles for each reference
             // item.
-            appendAndSelectText( theElement.Name.ToString(), styleName_RefListNum );
+            TextUtils.appendAndSelectText( theElement.Name.ToString(), EA_Constants.styleName_RefListNum );
-            appendAndSelectText( theElement.Notes.ToString(), styleName_RefListText );
+            TextUtils.appendAndSelectText( theElement.Notes.ToString(), EA_Constants.styleName_RefListText );
+         }
+      }
       private void createTerminologySection(EA.Package thePackage)
+         }
          if (numItems > 0)
+         {
             // Create a table
-            int tableNum = createTable("Terminology", numItems+1, 2);
+            int tableNum = TableUtils.Table_Create("Terminology", numItems+1, 2);
             Word.Table table = WordDocument.Tables[tableNum];
             object center = Word.WdParagraphAlignment.wdAlignParagraphCenter;
-            table.Cell(1,1).Range.Text = "Term";
+            TableUtils.Table_SetTableColumnTitle(table, "Term", 1);
-            table.Cell(1,1).Range.ParagraphFormat.Alignment = Word.WdParagraphAlignment.wdAlignParagraphCenter;
-            table.Cell(1,1).Range.Font.Bold = 1;
-            table.Cell(1,2).Range.Text = "Definition";
+            TableUtils.Table_SetTableColumnTitle(table, "Definition", 2);
-            table.Cell(1,2).Range.ParagraphFormat.Alignment = Word.WdParagraphAlignment.wdAlignParagraphCenter;
-            table.Cell(1,2).Range.Font.Bold = 1;
             table.Columns[1].SetWidth(100, Word.WdRulerStyle.wdAdjustSameWidth );
             int row = 2;
             if (thePackage.Elements.Count > 0)
+            {
+               }
+            }
+         }
+      }
+      #endregion
       private bool generatePackageHeadingAndDescription( EA.Package thePackage, int recurse_level )
+      {
          // disarm the one-shot package skipping feature if it was armed, and exit the function.
          if (oneShot_skipRootPackage == true)
          // The package name is a heading, and the package notes are paragraphs
          // directly under that heading
          displayProgress( "PACKAGE: ", thePackage.Name.ToString() );
-         appendAndSelectHeadingText( thePackage.Name.ToString(), recurse_level );
+         TextUtils.appendAndSelectHeadingText( thePackage.Name.ToString(), recurse_level );
          // Special handling for package called "Terminology"
          if (thePackage.Name == "Terminology")
+         {
-            appendAndSelectText( thePackage.Notes.ToString(), styleName_Body1 );
+            TextUtils.appendAndSelectText( thePackage.Notes.ToString(), EA_Constants.styleName_Body1 );
             createTerminologySection(thePackage);
             return true;
+         }
          if (thePackage.Name == "References")
+         {
-            appendAndSelectText( thePackage.Notes.ToString(), styleName_Body1 );
+            TextUtils.appendAndSelectText( thePackage.Notes.ToString(), EA_Constants.styleName_Body1 );
             createReferencesSection(thePackage);
             return true;
+         }
          // use the package notes as body text and indicate to caller that package elements
          // have not been consumed
-         appendAndSelectText( thePackage.Notes.ToString(), styleName_Body1 );
+         TextUtils.appendAndSelectText( thePackage.Notes.ToString(), EA_Constants.styleName_Body1 );
          return false;
+      }
       private void generatePackageDiagrams( EA.Package thePackage )
             appendAndSelectDiagramViaClipboard( theDiagram );
+         }
+      }
-      private void generateElementContent( EA.Element theElement, int recurse_level )
+      private void generateMethodContent( EA.Element theElement, int recurse_level )
+      {
+         recurse_level++;
+         if (recurse_level > 8)  // 8 instead of 9 because this function generates two heading levels
+         {
+            throw new System.StackOverflowException("Max Recursion Depth (9) Exceeded" );
+         }
+         // Get all the methods into an array list and sort them by their position in the class's
+         // method list (ie. sort order is determined by the Pos value in each method).
+         ArrayList theMethods = new ArrayList();
+         foreach(EA.Method theMethod in theElement.Methods)
+            theMethods.Add( theMethod );
+         methodSortByPos sorter = new methodSortByPos();
+         theMethods.Sort( sorter );
+         // filter out methods with certain characteristics?
+         // eg. Users may only want to document public and protected methods.
+         int numMethodsRemaining = 0;
+         foreach(EA.Method theMethod in theMethods)
+         {
+            if (EA_Utils.options.opt_SuppressPrivateMethods == false
+               || !theMethod.Visibility.StartsWith("Private"))
+               numMethodsRemaining++;
+         }
+         Word.Range wr;
+         StringBuilder sb;
+         if (numMethodsRemaining > 0)
+         {
+            // Print the "<Class Name> Operations" headings
+            sb = new StringBuilder();
+            sb.Append( theElement.Name );
+            sb.Append( " Operations" );
+            TextUtils.appendAndSelectHeadingText(sb.ToString(), recurse_level);
+            // Iterate through the class's methods
+            foreach(EA.Method theMethod in theMethods)
+            {
+               sb = new StringBuilder();
+               if (EA_Utils.options.opt_SuppressPrivateMethods == false
+                  || !theMethod.Visibility.StartsWith("Private"))
+               {
+                  // Print the Method name as a sub heading, and its description
+                  TextUtils.appendAndSelectHeadingText(theMethod.Name , recurse_level + 1);
+                  TextUtils.appendDescription(theMethod.Notes, EA_Utils);
+                  // Get a list of the method's parameters and sort them by the position field setup
+                  // in EA by the designer
+                  ArrayList theParams = new ArrayList();
+                  foreach(EA.Parameter theParam in theMethod.Parameters)
+                     theParams.Add( theParam );
+                  parameterSortByPos paramSorter = new parameterSortByPos();
+                  theParams.Sort( paramSorter );
+                  // Print the prototype heading
+                  wr = TextUtils.appendAndSelectText("\nPrototype:", EA_Constants.styleName_Body1);
+                  wr.ParagraphFormat.LeftIndent = WordApp.CentimetersToPoints((float)2.5);
+                  wr.Font.Italic = 1;
+                  // begin to build the prototype string
+                  sb = new StringBuilder();
+                  sb.Append( theMethod.ReturnType );
+                  sb.Append( " " );
+                  sb.Append( theMethod.Name );
+                  sb.Append( "(" );
+                  if (theParams.Count > 0)
+                  {
+                     int numParamsRemaining = theParams.Count;
+                     // print what we have so far constructed for the prototype
+                     wr = TextUtils.appendAndSelectText(sb.ToString(), EA_Constants.styleName_Body1);
+                     wr.ParagraphFormat.LeftIndent = WordApp.CentimetersToPoints((float)3.5);
+                     // Now form a new string for the params
+                     sb = new StringBuilder();
+                     foreach(EA.Parameter theParam in theParams)
+                     {
+                        // each parameter is   "[in|out|inout] type name [= default-value]"
+                        // where the default value is optional
+                        sb.Append( "[" );
+                        sb.Append( theParam.Kind );
+                        sb.Append( "] " );
+                        sb.Append( theParam.Type );
+                        sb.Append( " " );
+                        sb.Append( theParam.Name );
+                        if (theParam.Default.Length > 0)
+                        {
+                           sb.Append( " = " );
+                           sb.Append( theParam.Default );
+                        }
+                        // if there are more parameters after this one, add a comma and newline
+                        if (numParamsRemaining > 1)
+                           sb.Append( ",\n" );
+                        numParamsRemaining--;
+                     }
+                     // complete the prototype and print it.
+                     sb.Append( ")" );
+                     wr = TextUtils.appendAndSelectText(sb.ToString(), EA_Constants.styleName_Body1);
+                     wr.ParagraphFormat.LeftIndent = WordApp.CentimetersToPoints((float)4.5);
+                  }
+                  else
+                  {
+                     // complete the prototype and print it.
+                     sb.Append( ")" );
+                     wr = TextUtils.appendAndSelectText(sb.ToString(), EA_Constants.styleName_Body1);
+                     wr.ParagraphFormat.LeftIndent = WordApp.CentimetersToPoints((float)3.5);
+                  }
+                  // Prototype Attributes/Characteristics
+                  sb = new StringBuilder();
+                  sb.Append( theMethod.Visibility );
+                  if (theMethod.IsStatic)
+                     sb.Append("\nStatic");
+                  if (theMethod.Abstract)
+                     sb.Append("\nAbstract");
+                  if (theMethod.IsPure)
+                     sb.Append("\nPure (c++)");
+                  if (theMethod.IsSynchronized)
+                     sb.Append("\nSynchronised");
+                  if (theMethod.Concurrency != null && theMethod.Concurrency.Length > 0 && !theMethod.Concurrency.StartsWith("Sequential") )
+                  {
+                     sb.Append("\n");
+                     sb.Append(theMethod.Concurrency);
+                  }
+                  if (theMethod.IsConst)
+                     sb.Append("\nConst");
+                  if (theMethod.IsQuery)
+                     sb.Append("\nIs Querry (does not alter class variables)");
+                  if (theMethod.IsLeaf)
+                     sb.Append("\nIs Leaf (cannot be overriden)");
+                  if (theMethod.ReturnIsArray)
+                     sb.Append( "\nReturn value is an array" );
+                  if (theMethod.Throws != null && theMethod.Throws.Length > 0)
+                  {
+                     sb.Append("\n");
+                     sb.Append( theMethod.Throws );
+                  }
+                  if (sb.Length > 0)
+                  {
+                     wr = TextUtils.appendAndSelectText("Characteristics:", EA_Constants.styleName_Body1);
+                     wr.ParagraphFormat.LeftIndent = WordApp.CentimetersToPoints((float)2.5);
+                     wr.Font.Italic = 1;
+                     wr = TextUtils.appendAndSelectText(sb.ToString(), EA_Constants.styleName_Body1);
+                     wr.ParagraphFormat.LeftIndent = WordApp.CentimetersToPoints((float)3.5);
+                  }
+                  // Parameter Descriptions
+                  if (theParams.Count > 0)
+                  {
+                     wr = TextUtils.appendAndSelectText("Parameters:", EA_Constants.styleName_Body1);
+                     wr.ParagraphFormat.LeftIndent = WordApp.CentimetersToPoints((float)2.5);
+                     wr.Font.Italic = 1;
+                     foreach(EA.Parameter theParam in theParams)
+                     {
+                        wr = TextUtils.appendAndSelectText( theParam.Name, EA_Constants.styleName_Body1);
+                        wr.ParagraphFormat.LeftIndent = WordApp.CentimetersToPoints((float)3.5);
+                        wr = TextUtils.appendDescription(theParam.Notes, EA_Utils);
+                        wr.ParagraphFormat.LeftIndent = WordApp.CentimetersToPoints((float)4.5);
+                     }
+                  }
+               }
+            }
+         }
+      }
+      /// <summary>
+      /// This method serialises a class's attributes to the document.
+      /// </summary>
+      /// <param name="theElement"></param>
+      /// <param name="recurse_level"></param>
+      private void generateAttributeContent( EA.Element theElement, int recurse_level )
+      {
          recurse_level++;
          if (recurse_level > 9)
+         {
             throw new System.StackOverflowException("Max Recursion Depth (9) Exceeded" );
+         }
+         // Get all the attributes into an array list and sort them by their position in the class's
+         // attribute list (ie. sort order is determined by the Pos value in each attribute).
+         ArrayList theAttrs = new ArrayList();
+         foreach(EA.Attribute theAttr in theElement.Attributes)
+            theAttrs.Add( theAttr );
+         attributeSortByPos sorter = new attributeSortByPos();
-         trackDocSection(recurse_level);
+         theAttrs.Sort( sorter );
+         // TODO
+         // filter out attributes with certain characteristics?
-         if (EA_Utils.options.elementTypeFoundInEA_DocGen( theElement.Type ))
+         // eg. Users may only want to document public and protected attributes.
+         int numAttrsRemaining = 0;
+         foreach(EA.Attribute theAttr in theAttrs)
+         {
+            if (EA_Utils.options.opt_SuppressPrivateAttributes == false
+               || !theAttr.Visibility.StartsWith("Private"))
+               numAttrsRemaining++;
+         }
+         if (numAttrsRemaining > 0)
+         {
-            displayProgress( "ELEMENT: ", theElement.Name.ToString() );
+            StringBuilder sb = new StringBuilder();
+            sb.Append( theElement.Name );
+            sb.Append( " Attributes" );
+            TextUtils.appendAndSelectHeadingText(sb.ToString(), recurse_level);
-            if ( theElement.Type.StartsWith("Requirement")
+            // serialise the attributes to the document.
-               && EA_Utils.options.opt_DisplayRequirementsWithStatus == true )
+            foreach(EA.Attribute theAttr in theAttrs)
+            {
+               if (EA_Utils.options.opt_SuppressPrivateAttributes == false
+                  || !theAttr.Visibility.StartsWith("Private"))
+               {
+                  // Begin to build content string for the "Attribute" table column
+                  sb = new StringBuilder();
+                  // <type> <name>
+                  sb.Append("\n");
+                  sb.Append(theAttr.Type);
+                  sb.Append(" ");
+                  sb.Append(theAttr.Name);
+                  Word.Range wr = TextUtils.appendAndSelectText(sb.ToString(), EA_Constants.styleName_Body1);
+                  wr.Font.Bold = 1;
+                  wr = TextUtils.appendDescription(theAttr.Notes, EA_Utils);
+                  wr.ParagraphFormat.LeftIndent = WordApp.CentimetersToPoints((float)3.5);
+                  // The approach here is to display as much of the attribute as we can but try to keep the output
+                  // uncluttered by omitting items the user has not set via the EA GUI.
+                  // Begin to build content string for the "Other Information" table cell
+                  sb = new StringBuilder();
+                  sb.Append(theAttr.Visibility);
+                  sb.Append("\n");
+                  if (theAttr.IsConst)
+                     sb.Append("Constant\n");
+                  if (theAttr.IsStatic)
+                     sb.Append("Static\n");
+                  if (theAttr.IsDerived)
+                     sb.Append("Derived\n");
+                  if (theAttr.IsOrdered)
+                  {
+                     sb.Append("Is Ordered\n");
+                  }
+                  if (theAttr.IsCollection)
+                  {
+                     sb.Append("Is A Collection\n");
+                  }
+                  if (theAttr.Length.Length > 0 && System.Convert.ToInt32(theAttr.Length) > 0)
+                  {
+                     sb.Append("Length = ");
+                     sb.Append(theAttr.Length);
+                     sb.Append("\n");
+                  }
+                  if (!theAttr.Containment.StartsWith("Not Specified"))
+                  {
+                     sb.Append("Containment =");
+                     sb.Append(theAttr.Containment);
+                     sb.Append("\n");
+                  }
+                  if (theAttr.Container.Length > 0)
+                  {
+                     sb.Append("Container Type = ");
+                     sb.Append(theAttr.Container);
+                     sb.Append("\n");
+                  }
+                  if (theAttr.Style.Length > 0)
+                  {
+                     sb.Append("Style = ");
+                     sb.Append(theAttr.Style);
+                     sb.Append("\n");
+                  }
+                  if (  System.Convert.ToInt32(theAttr.LowerBound) > 1
+                     || System.Convert.ToInt32(theAttr.UpperBound) > 1)
+                  {
+                     sb.Append("Multiplicity [");
+                     sb.Append(theAttr.LowerBound);
+                     sb.Append("..");
+                     sb.Append(theAttr.UpperBound);
+                     sb.Append("]\n");
+                  }
+                  if (theAttr.Scale.Length > 0 && System.Convert.ToInt32(theAttr.Scale) > 0)
+                  {
+                     sb.Append("Scale = ");
+                     sb.Append(theAttr.Scale);
+                     sb.Append( "\n" );
+                  }
+                  if (theAttr.Precision.Length > 0 && System.Convert.ToInt32(theAttr.Precision) > 0)
+                  {
+                     sb.Append("Precision = ");
+                     sb.Append(theAttr.Precision);
+                     sb.Append( "\n" );
+                  }
+                  if (theAttr.Default.Length > 0)
+                  {
+                     sb.Append("Default Value = ");
+                     sb.Append(theAttr.Default);
+                     sb.Append( "\n" );
+                  }
+                  // Now look at the constraint and tagged value collections and add any found info to the
+                  // right hand column
+                  short i;
+                  for(i=0; i<theAttr.Constraints.Count; i++)
+                  {
+                     EA.AttributeConstraint theCons = (EA.AttributeConstraint)theAttr.Constraints.GetAt(i);
+                     sb.Append( theCons.Type );
+                     sb.Append( ": {" );
+                     sb.Append( theCons.Name );
+                     sb.Append( "}\n" );
+                     //sb.Append( theCons.Notes  );
+                     //sb.Append( "\n" );
+                  }
+                  for(i=0; i<theAttr.TaggedValues.Count; i++)
+                  {
+                     EA.AttributeTag theTag = (EA.AttributeTag)theAttr.TaggedValues.GetAt(i);
+                     sb.Append( "[" );
+                     sb.Append( theTag.Name );
+                     sb.Append( "="  );
+                     sb.Append( theTag.Value );
+                     sb.Append( "]\n" );
-               generateRequirementText( theElement );
+                     //sb.Append( theTag.Notes );
+                     //sb.Append( "\n" );
+                  }
+                  if (sb.Length > 0)
+                  {
+                     // remove the trailing "\n"
+                     sb.Remove( sb.ToString().Length - 1, 1);
+                     wr = TextUtils.appendAndSelectText("Characteristics:", EA_Constants.styleName_Body1);
+                     wr.ParagraphFormat.LeftIndent = WordApp.CentimetersToPoints((float)3.5);
+                     wr.Font.Italic = 1;
+                     wr = TextUtils.appendAndSelectText(sb.ToString(), EA_Constants.styleName_Body1);
+                     wr.ParagraphFormat.LeftIndent = WordApp.CentimetersToPoints((float)4.5);
+                  }
+                  numAttrsRemaining--;
+               }
+            }
+         }
+      }
+      private void generateClassCharacteristics( EA.Element theElement, int recurse_level )
+      {
+         StringBuilder sb = new StringBuilder();
+         sb.Append( "Characteristics:" );
+         Word.Range wr = TextUtils.appendAndSelectText(sb.ToString(), EA_Constants.styleName_Body1);
+         wr.Font.Italic = 1;
+         sb = new StringBuilder();
+         sb.Append( theElement.Visibility );
+         if (System.Convert.ToInt32(theElement.Abstract) == 1)
+            sb.Append( "\nAbstract" );
+         wr = TextUtils.appendAndSelectText(sb.ToString(), EA_Constants.styleName_Body1);
+         wr.ParagraphFormat.LeftIndent = WordApp.CentimetersToPoints((float)3.5);
+         sb = new StringBuilder();
+         foreach(EA.Element baseClass in theElement.BaseClasses)
+         {
+            sb.Append( baseClass.Name);
+         }
+         if (sb.Length > 0)
+         {
+            wr = TextUtils.appendAndSelectText("Base Class(es):", EA_Constants.styleName_Body1);
+            wr.Font.Italic = 1;
+            wr = TextUtils.appendAndSelectText(sb.ToString(), EA_Constants.styleName_Body1);
+            wr.ParagraphFormat.LeftIndent = WordApp.CentimetersToPoints((float)3.5);
+         }
+         sb = new StringBuilder();
+         foreach(EA.Element intf in theElement.Realizes)
+         {
+            sb.Append( intf.Name);
+         }
+         if (sb.Length > 0)
+         {
+            wr = TextUtils.appendAndSelectText("Realises:", EA_Constants.styleName_Body1);
+            wr.Font.Italic = 1;
+            wr = TextUtils.appendAndSelectText(sb.ToString(), EA_Constants.styleName_Body1);
+            wr.ParagraphFormat.LeftIndent = WordApp.CentimetersToPoints((float)3.5);
+         }
+      }
+      private void generateClassRequirements( EA.Element theElement, int recurse_level )
+      {
+         StringBuilder sb = new StringBuilder();
+         sb.Append( "Requirements:" );
+         Word.Range wr = TextUtils.appendAndSelectText(sb.ToString(), EA_Constants.styleName_Body1);
+         wr.Font.Italic = 1;
+         foreach(EA.Requirement theReq in theElement.Requirements)
-            else
+         {
+            sb = new StringBuilder();
+            sb.Append( theReq.Name );
+            wr = TextUtils.appendAndSelectText(sb.ToString(), EA_Constants.styleName_Body1);
+            wr.ParagraphFormat.LeftIndent = WordApp.CentimetersToPoints((float)3.5);
+            sb = new StringBuilder();
+            sb.Append( theReq.Notes );
+            if (sb.Length > 0)
+            {
+               wr = TextUtils.appendAndSelectText(sb.ToString(), EA_Constants.styleName_Body1);
+               wr.ParagraphFormat.LeftIndent = WordApp.CentimetersToPoints((float)4.5);
+            }
+         }
+      }
+      private void generateClassConstraints( EA.Element theElement, int recurse_level )
+      {
+         StringBuilder sb = new StringBuilder();
+         sb.Append( "Constraints:" );
+         Word.Range wr = TextUtils.appendAndSelectText(sb.ToString(), EA_Constants.styleName_Body1);
+         wr.Font.Italic = 1;
+         foreach(EA.Constraint theCons in theElement.Constraints)
+         {
+            sb = new StringBuilder();
+            sb.Append( theCons.Type );
+            sb.Append( ": {" );
+            sb.Append( theCons.Name );
+            sb.Append( "}" );
+            wr = TextUtils.appendAndSelectText(sb.ToString(), EA_Constants.styleName_Body1);
+            wr.ParagraphFormat.LeftIndent = WordApp.CentimetersToPoints((float)3.5);
+            if (theCons.Notes.Length > 0)
+            {
+               sb = new StringBuilder();
+               sb.Append( theCons.Notes );
+               wr = TextUtils.appendAndSelectText(sb.ToString(), EA_Constants.styleName_Body1);
+               wr.ParagraphFormat.LeftIndent = WordApp.CentimetersToPoints((float)4.5);
+            }
+         }
+      }
+      private void generateElementContent( EA.Element theElement, int recurse_level )
+      {
+         // track recursion level to control heading style formatting requirements
+         if (oneShot_skipRootElementHeading == false)
+            recurse_level++;
+         if (recurse_level > 9)
+         {
+            throw new System.StackOverflowException("Max Recursion Depth (9) Exceeded" );
+         }
+         if (EA_Utils.options.elementTypeFoundInEA_DocGen( theElement.Type ))
+         {
+            // pass the element to the requirement element serialisation function. It
+            // will tell us if it did anything with it. If not, then carry out the default
+            // element serialisation.
+            if (false == TextUtils.generateRequirementText(theElement, EA_Utils))
+            {
-               if (theElement.Type.StartsWith("Requirement")
+               bool isClass = theElement.Type.StartsWith("Class");
+               if (  true == isClass
-                  && EA_Utils.options.opt_DisplayRequirementElementsAsSections == false )
+                  && true == EA_Utils.options.opt_SuppressPrivateClasses
+                  && true == theElement.Visibility.StartsWith("Private") )
+               {
-                  string s;
+                  // do nothing
-                  s = EA_Utils.options.opt_RequirementElementDisplayFormat;
-                  s = s.Replace(@"%s",@"{0}");
-                  appendAndSelectText( String.Format( s, theElement.Name ), styleName_Body1);
-                  WordRange.Font.Bold = 1;
                }
-               else if ( EA_Utils.options.opt_ElementHeadingTransitionLevel > 0
-                  && EA_Utils.options.opt_ElementHeadingTransitionLevel <= recurse_level )
-                  appendAndSelectNumParaText( theElement.Name.ToString(), recurse_level );
                else
+               {
+                  trackDocSection(recurse_level);
+                  displayProgress( "ELEMENT: ", theElement.Name );
+                  // disarm the one-shot element (heading) skipping feature if it was armed, and
+                  // by-pass the code to generate a new heading level for the element
+                  if (oneShot_skipRootElementHeading == false)
+                  {
+                     // Default element serialisation
+                     if (  EA_Utils.options.opt_ElementHeadingTransitionLevel > 0
+                        && EA_Utils.options.opt_ElementHeadingTransitionLevel <= recurse_level )
+                        TextUtils.appendAndSelectNumParaText( theElement.Name, recurse_level );
+                     else
-                  appendAndSelectHeadingText( theElement.Name.ToString(), recurse_level );
+                        TextUtils.appendAndSelectHeadingText( theElement.Name, recurse_level );
+                  }
+                  else
+                  {
+                     oneShot_skipRootElementHeading = false;
+                  }
-               appendAndSelectText( theElement.Notes.ToString(), styleName_Body1 );
+                  TextUtils.appendDescription( theElement.Notes, EA_Utils );
+                  if (true == isClass)
+                  {
+                     // If accumulation of non-private classes is enabled, then do so.
+                     if (recordingNonPrivateClasses)
+                     {
+                        if (!theElement.Visibility.StartsWith("Private"))
+                        {
+                           nonPrivateClasses.Add( theElement.ElementID );
+                        }
+                     }
+                     generateClassCharacteristics(theElement, recurse_level);
+                  }
+                  // Requirement collection
+                  if (theElement.Requirements.Count > 0)
+                  {
+                     generateClassRequirements(theElement, recurse_level);
+                  }
+                  // Constraint collection
+                  if (theElement.Constraints.Count > 0)
+                  {
+                     generateClassConstraints(theElement, recurse_level);
+                  }
+                  if (theElement.Issues.Count > 0)
+                  {
+                  }
+                  // Attribute collection
+                  if (theElement.Attributes.Count > 0)
+                  {
+                     generateAttributeContent(theElement, recurse_level);
+                  }
+                  // Method collection
+                  if (theElement.Methods.Count > 0)
+                  {
+                     generateMethodContent(theElement, recurse_level);
+                  }
+               }
+            }
+            else
+            {
+               trackDocSection(recurse_level);
+               displayProgress( "ELEMENT: ", theElement.Name );
+            }
+         }
          else
+         {
             displayProgress( "FILTERED: ", theElement.Type );
+         }
          // TODO
          // We will probably have to put special code in here at some point for attributes
          // of, and collections of things within elements. This will become apparent once
          // someone tries to produce a design document where such things need to be included
          // in the generated document. Lots of work needed here eventually.
+         // disarm element heading skip control
+         oneShot_skipRootElementHeading = false;
+      }
-      /// <summary>
-      /// This function was the only way I could figure out how to obtain a style object for
-      /// the style name given. Everything else I tried, didn't work, even code from Visual Basic
-      /// examples failed to work or even compile (once converted) in C#.
-      /// </summary>
-      /// <param name="styleText"></param>
-      /// <returns></returns>
-      private Word.Style getStyle(string styleText)
-      {
-         foreach(Word.Style aStyle in WordDocument.Styles)
-         {
-            //MessageBox.Show( aStyle.NameLocal );
-            if (aStyle.NameLocal.StartsWith(styleText))
-            {
-               return aStyle;
-            }
-         }
-         return null;
-      }
       /// <summary>
       /// This function searches for the old content in the document in order to remove it
       /// prior to adding in the new content from the latest EA model data.
       /// </summary>
       private void removeExistingDocumentContent()
+      {
          //WordApp.Visible = true;  // enable this when debugging this horrible function
          Word.Selection aSelection;
-         object findStyle = getStyle( styleName_Heading1 );
+         object findStyle = StyleUtils.getStyle( EA_Constants.styleName_Heading1 );
          WordApp.Selection.WholeStory();
          aSelection = WordApp.Selection;
          aSelection.Find.ClearFormatting();
             // old content.
             Word.Range range = aSelection.Range;
             range.End = WordDocument.Content.End;
             range.Cut();
             // try and ensure that no heading style is left in place following the removal
-            object style = styleName_Body1;
+            object style = EA_Constants.styleName_Body1;
             range.set_Style(ref style);
+         }
+      }
          // The EA_DocGenPackageLink can contain a list of GUIDs in its notes section
          // that point to model structure outside of the localised structure forming the
          // document. This enables a document to grab content from other external models
          // as long as they are loaded into the repository.
-         if (theElement.Name.StartsWith("EA_DocGenPackageLink"))
+         if (theElement.Name.StartsWith(EA_Constants.EA_DocGenPackageLink))
+         {
             processPackageLink( theElement, recurse_level );
+         }
             // The EA_DocGenDiagramLink can contain a list of GUIDs in its notes section
             // that point to diagram elements anywhere in the repository.
-         else if (theElement.Name.StartsWith("EA_DocGenDiagramLink"))
+         else if (theElement.Name.StartsWith(EA_Constants.EA_DocGenDiagramLink))
+         {
             processDiagramLink( theElement );
+         }
             // The EA_DocGenDiagramLink can contain a list of GUIDs in its notes section
             // that point to diagram elements anywhere in the repository.
-         else if (theElement.Name.StartsWith("EA_DocGenElementLink"))
+         else if (theElement.Name.StartsWith(EA_Constants.EA_DocGenElementLink))
+         {
             processElementLink( theElement, recurse_level );
+         }
             // The EA_DocGenTable element can contain table content in its notes section
             // and must be dealt with in a special way.
-         else if (theElement.Name.StartsWith("EA_DocGenTable"))
+         else if (theElement.Name.StartsWith(EA_Constants.EA_DocGenTable))
+         {
             processTableElement( theElement, recurse_level );
+         }
             // The EA_DocGenText element can contain text content in its notes section
             // that must be appended to the doc in Body 1 style within the current
             // section.
-         else if (theElement.Name.StartsWith("EA_DocGenText"))
+         else if (theElement.Name.StartsWith(EA_Constants.EA_DocGenText))
+         {
             processTextElement( theElement, recurse_level );
+         }
-         else if (theElement.Name.StartsWith("EA_DocGenRelationshipMatrix"))
+         else if (theElement.Name.StartsWith(EA_Constants.EA_DocGenRelationshipMatrix))
+         {
             processRelationshipMatrixElement( theElement, recurse_level );
+         }
+         else if (theElement.Name.StartsWith(EA_Constants.EA_DocGenTestLink))
+         {
+            processTestLink( theElement, recurse_level );
-         else
+         }
+         else if (theElement.Name.StartsWith(EA_Constants.EA_DocGenTestTraceability))
+         {
+            processTestTraceability( theElement, recurse_level );
+         }
+            // we are aware of the other ERG EA add-in, EA_ReqPro! That other add-in creates
+            // ReqProDB stereotyped elements. Never consume them in the document generation process.
+         else if ( theElement.Stereotype != EA_Constants.stereotype_ReqProDB )
+         {
             generateElementContent( theElement, recurse_level );
+         }
+      }
          if (recurse_level > 9)
+         {
             throw new System.StackOverflowException("Max Recursion Depth (9) Exceeded" );
+         }
+         // If we have reached a "Detailed Design" section, we should begin to capture in a list, all public
+         // classes so that we know later on what classes need to be considered in the unit testing section
+         // of the document, assuming that this is a s/w design document being generated ofcoarse.
+         bool nameStartedWithDetailedDesign = false;
+         if (recordingNonPrivateClasses == false && thePackage.Name.StartsWith("Detailed Design"))
+         {
+            recordingNonPrivateClasses = true;
+            nameStartedWithDetailedDesign = true;
+         }
          // generate package heading and description. This may, depending on the package name,
          // consume the elements in the package. If it does not, then consume them (and any diagrams)
          // locally here.
          if (false == generatePackageHeadingAndDescription( thePackage, recurse_level ))
+         {
          foreach(EA.Package lowerLevelPackage in thePackage.Packages)
+         {
             // recurse
             parse_package(lowerLevelPackage, recurse_level);
+         }
+         // If appropriate, turn off non-private class accumulation.
-         if (rootPackageWasSkipped == false)
+         if (nameStartedWithDetailedDesign)
-            recurse_level--;
+            recordingNonPrivateClasses = false;
+      }
       /// <summary>
       /// This is the overall generate document method. It creates a word document from
             WordApp.DisplayAlerts = Word.WdAlertLevel.wdAlertsNone;
             // Create a document from the input template
             WordDocument = WordApp.Documents.Add(ref template, ref newTemplate, ref docType, ref visible);
+            TableUtils.AcceptWordAppAndDoc(WordApp, WordDocument);
+            TextUtils.AcceptWordAppAndDoc(WordApp, WordDocument);
+            StyleUtils.AcceptWordAppAndDoc(WordApp, WordDocument);
             // Remove all old content from the input document/template. Note that this assumes
             // that content will begin at section 1 with the title "Introduction" and it will have
             // "Heading 1" style.
             removeExistingDocumentContent();
             // turn off grammar and spell checking
             WordDocument.GrammarChecked = false;
             WordDocument.SpellingChecked = false;
+            // arm the public class list accumulator.
+            recordingNonPrivateClasses = false;
+            nonPrivateClasses = new ArrayList();
+            classesWithUnitTests = new ArrayList();
             // If the input template does not contain the styles needed for requirement documents,
             // programmatically create them just in case.
-            createRequirementStylesIfNecessary();
+            StyleUtils.createRequirementStylesIfNecessary();
             // Parse EA_DocGen Document Model. The parent package is the document model itself
             // and the packages within it are the top level packages only.
             // Question: do we have to parse diagrams and elements at this top level? So far,
             // this has been found to be unecessary, but you never know. For now, dont do it.
             foreach(EA.Package thePackage in EA_ParentPackage.Packages)
+            {
                parse_package(thePackage, 0);
+            }
+            // for design docs, a user may have used the test traceability element in their document model,
+            // which means that now we are finished with parse 1 of the document, we can complete the traceability
+            // table (if any) that was begun when that special element was first encountered.
+            completeTestTraceability();
+            // Save the document to the output file before we try and update the fields. This is because
+            // I have seen Fields.Update() fail on a few occasions and it is very annoying
+            // to lose what has thus far been generated.
+            WordDocument.SaveAs( ref outputFilename,
+               ref nothing, ref nothing, ref nothing, ref nothing,
+               ref nothing, ref nothing, ref nothing, ref nothing,
+               ref nothing, ref nothing, ref nothing, ref nothing,
+               ref nothing, ref nothing, ref nothing);
-            // Select the entire document, and Update all fields, including Table of Contents
+            object noSave = Word.WdSaveOptions.wdDoNotSaveChanges;
-            // and then collapse the selection in case user wants to view the document, because
+            object format = Word.WdOriginalFormat.wdWordDocument;
-            // they wont want to see the inverse video of the selection.
+            WordDocument.Close(ref noSave, ref format, ref nothing);
-            WordApp.Selection.WholeStory();
+            // Re-load the document to update the fields. For some as yet unknown reason, doing this
-            WordApp.Selection.Fields.Update();
+            // sometimes fails, but by doing it in a re-loaded instance of the word document
-            object direction = Word.WdCollapseDirection.wdCollapseEnd;
+            // the failures seem to be reduced.
-            WordApp.Selection.Collapse(ref direction);
+            WordDocument = WordApp.Documents.Add(ref outputFilename, ref newTemplate, ref docType, ref visible);
-            // Save the document to the output file
+            WordDocument.Fields.Update();
             WordDocument.SaveAs( ref outputFilename,
                ref nothing, ref nothing, ref nothing, ref nothing,
                ref nothing, ref nothing, ref nothing, ref nothing,
                ref nothing, ref nothing, ref nothing, ref nothing,
                ref nothing, ref nothing, ref nothing);
             // Tell user the process completed ok
             textBox_progress.AppendText( "---Completed---" );
             MessageBox.Show("Document Generation Complete");
+         }
          catch (Exception createTheWordDoc_exception)
+         {
             MessageBox.Show("Document Generation Failed\n\n" + createTheWordDoc_exception.Message);
+         }
          // restore security settings
          WordApp.AutomationSecurity = securityBefore;
+      }
-      /// <summary>
-      /// Creates a wdStyleTypeParagraph based style
-      /// </summary>
-      /// <param name="newStyleName"></param>
-      /// <param name="followingStyleName"></param>
-      /// <param name="baseStyle"></param>
-      /// <returns></returns>
-      private Word.Style createParagrapghStyle(string newStyleName,
-                                               string followingStyleName,
-                                               Word.Style baseStyle)
-      {
-         Word.Style s = getStyle(newStyleName);
-         if (s == null)
-         {
-            object o_styleType = Word.WdStyleType.wdStyleTypeParagraph;
-            s = WordDocument.Styles.Add(newStyleName, ref o_styleType);
-            object o_baseStyle = baseStyle.NameLocal;
-            object o_followingStyle = followingStyleName;
-            s.set_BaseStyle(ref o_baseStyle);
-            s.set_NextParagraphStyle(ref o_followingStyle);
-            s.Font = baseStyle.Font;
-            s.ParagraphFormat = baseStyle.ParagraphFormat;
-            s.LanguageID = Word.WdLanguageID.wdEnglishAUS;
-            s.NoProofing = 0;
-            s.Frame.Delete();
-            s.NoSpaceBetweenParagraphsOfSameStyle = false;
-         }
-         return s;
-      }
-      /// <summary>
-      /// Creates a wdStyleTypeCharacter based style
-      /// </summary>
-      /// <param name="newStyleName"></param>
-      /// <param name="baseStyle"></param>
-      /// <returns></returns>
-      private Word.Style createCharacterStyle(string newStyleName, Word.Style baseStyle)
-      {
-         Word.Style s = getStyle(newStyleName);
-         if (s == null)
-         {
-            object o_styleType = Word.WdStyleType.wdStyleTypeCharacter;
-            s = WordDocument.Styles.Add(newStyleName, ref o_styleType);
-            object o_baseStyle = baseStyle.NameLocal;
-            s.set_BaseStyle(ref o_baseStyle);
-            s.Font = baseStyle.Font;
-            s.LanguageID = Word.WdLanguageID.wdEnglishAUS;
-            s.NoProofing = 0;
-         }
-         return s;
-      }
-      /// <summary>
-      /// Creates the styles needed for generating requirement documentation, if they do not
-      /// already exist.
-      /// </summary>
-      private void createRequirementStylesIfNecessary()
-      {
-         Word.Style s_Body1 = getStyle(styleName_Body1);
-         if (s_Body1 != null)
-         {
-            // APPROVED ///////////////////////////////////////////////////////////////////////////////////////////////
-            Word.Style s_ReqAppBody = createParagrapghStyle(styleName_ReqAppBody, styleName_ReqAppBody, s_Body1);
-            if (s_ReqAppBody != null)
-            {
-               // No changes needed - this is just a copy of Body 1
-            }
-            Word.Style s_ReqAppHdr = null;
-            if (s_ReqAppBody != null)
-            {
-               s_ReqAppHdr = createParagrapghStyle(styleName_ReqAppHdr, styleName_ReqAppBody, s_Body1);
-               if (s_ReqAppHdr != null)
-               {
-                  // Indent:Hanging: 2.5cm, Space After: 3pt, Keep with next, Tabs: 16.5cm, Right
-                  s_ReqAppHdr.ParagraphFormat.FirstLineIndent = WordApp.CentimetersToPoints((float)-2.5);
-                  s_ReqAppHdr.ParagraphFormat.SpaceAfter = 3;
-                  s_ReqAppHdr.ParagraphFormat.KeepWithNext = (int)MsoTriState.msoTrue;
-                  s_ReqAppHdr.ParagraphFormat.TabStops.ClearAll();
-                  object alignment = Word.WdTabAlignment.wdAlignTabRight;
-                  object leader = Word.WdTabLeader.wdTabLeaderSpaces;
-                  s_ReqAppHdr.ParagraphFormat.TabStops.Add( WordApp.CentimetersToPoints((float)16.5), ref alignment, ref leader );
-               }
-            }
-            // PROPOSED ///////////////////////////////////////////////////////////////////////////////////////////////
-            Word.Style s_ReqPropBody = null;
-            if (s_ReqAppBody != null)
-            {
-               s_ReqPropBody = createParagrapghStyle(styleName_ReqPropBody, styleName_ReqPropBody, s_ReqAppBody );
-               if (s_ReqPropBody != null)
-               {
-                  // Font: Italic
-                  s_ReqPropBody.Font.Italic = (int)MsoTriState.msoTrue;
-               }
-            }
-            if (s_ReqAppHdr != null && s_ReqPropBody != null)
-            {
-               Word.Style s_ReqPropHdr = createParagrapghStyle(styleName_ReqPropHdr, styleName_ReqPropBody, s_ReqAppHdr );
-               if (s_ReqPropHdr != null)
-               {
-                  // Font: Italic
-                  s_ReqPropHdr.Font.Italic = (int)MsoTriState.msoTrue;
-               }
-            }
-            // REJECTED ///////////////////////////////////////////////////////////////////////////////////////////////
-            Word.Style s_ReqRejBody = null;
-            if (s_ReqAppBody != null)
-            {
-               s_ReqRejBody = createParagrapghStyle(styleName_ReqRejBody, styleName_ReqRejBody, s_ReqAppBody );
-               if (s_ReqRejBody != null)
-               {
-                  // Font: Italic
-                  s_ReqRejBody.Font.StrikeThrough = (int)MsoTriState.msoTrue;
-               }
-            }
-            if (s_ReqAppHdr != null && s_ReqRejBody != null)
-            {
-               Word.Style s_ReqRejHdr = createParagrapghStyle(styleName_ReqRejHdr, styleName_ReqRejBody, s_ReqAppHdr );
-               if (s_ReqRejHdr != null)
-               {
-                  // Font: Italic
-                  s_ReqRejHdr.Font.StrikeThrough = (int)MsoTriState.msoTrue;
-               }
-            }
-            // REQUIREMENT NAME ///////////////////////////////////////////////////////////////////////////////////////////////
-            Word.Style s_DefParaFont = getStyle("Default Paragraph Font");
-            if (s_DefParaFont != null)
-            {
-               Word.Style s_ReqName = createCharacterStyle(styleName_ReqName, s_DefParaFont );
-               if (s_ReqName != null)
-               {
-                  s_ReqName.Font.Bold = (int)MsoTriState.msoTrue;
-               }
-            }
-         }
-      }
-      /// <summary>
-      /// Generates the text for requirements.  This uses custom styles to format the text
-      /// rather than formatting it in code.
-      /// </summary>
-      private void generateRequirementText( EA.Element theElement )
-      {
-         string reqID = "";
-         string reqShortDesc = "";
-         string reqNotes = "";
-         string reqStatusText = "";
-         string reqHeadingStyle ="";
-         string reqParaStyle = "";
-         object reqNameStyle = styleName_ReqName;
-         Word.Range shortDescRange;
-         // Set the style depending on the status
-         switch ( theElement.Status )
-         {
-            case "Proposed":
-               reqStatusText = "(Proposed)";
-               reqHeadingStyle = styleName_ReqPropHdr;
-               reqParaStyle    = styleName_ReqPropBody;
-               break;
-            case "Rejected":
-               reqHeadingStyle = styleName_ReqRejHdr;
-               reqParaStyle    = styleName_ReqRejBody;
-               break;
-            case "Approved":
-               reqStatusText = "(Phase " + theElement.Phase + ")";
-               reqHeadingStyle = styleName_ReqAppHdr;
-               reqParaStyle    = styleName_ReqAppBody;
-               break;
-            default:
-               reqStatusText = "(" + theElement.Status + ")(Phase " + theElement.Phase + ")";
-               reqHeadingStyle = styleName_ReqAppHdr;
-               reqParaStyle    = styleName_ReqAppBody;
-               break;
-         }
-         // Pull out the ID from the name
-         int pos = theElement.Name.IndexOf( " ", 0, theElement.Name.Length );
-         reqID = theElement.Name.Substring( 0, pos );
-         // Pull out the short description from the rest of the name
-         reqShortDesc = theElement.Name.Substring( pos, theElement.Name.Length-pos );
-         reqShortDesc = reqShortDesc.Trim();
-         // Pull out the notes
-         reqNotes = theElement.Notes.ToString();
-         // Add the text
-         appendAndSelectText( reqID + '\t', reqHeadingStyle );
-         appendAndSelectText( reqShortDesc, reqHeadingStyle, true );
-         shortDescRange = WordRange;
-         appendAndSelectText( '\t' + reqStatusText, reqHeadingStyle, true );
-         //reapply the name char style to the short desc.
-         shortDescRange.Start = shortDescRange.Start-1;
-         shortDescRange.End = WordRange.Start-1;
-         shortDescRange.set_Style( ref reqNameStyle );
-         appendAndSelectText( reqNotes, reqParaStyle );
-      }
       /// <summary>
       /// Class to sort EA elements alphabetically, in a case insensitive way.
       /// This is used by the processRelationshipMatrixElement method.
       /// </summary>
             else
                return 0;
+         }
+      }
-      /// <summary>
-      /// This function will insert a relationship matrix table into the document, built from content
-      /// specified in options that are provided in the notes section of the special element that
-      /// has led to this function being called.
+      public class attributeSortByPos : IComparer
-      /// </summary>
-      /// <param name="theElement"></param>
-      /// <param name="recurse_level"></param>
-      private void processRelationshipMatrixElement( EA.Element theElement, int recurse_level )
+      {
-         int tableNum = 0;
-         Word.Table table = null;
-         // process the options for the relationship matrix
+         int IComparer.Compare( object x, object y)
-         EA_RelationshipMatrix EA_RelMatrix = new EA_RelationshipMatrix(EA_Utils);
-         if (!EA_RelMatrix.processRelationshipMatrixOptions( theElement ))
+         {
-            return;  // must have been an error
+            if (x!=null & y!= null)
+               return ((EA.Attribute)x).Pos - ((EA.Attribute)y).Pos;
+            else
+               return 0;
+         }
+      }
-         // Scan the fromPackage to find out how many elements are present and so how many
-         // rows the matrix table will need
-         ElementAccumulator fromLister = new ElementAccumulator(EA_RelMatrix.fromElementTypes);
-         EA_Utils.findAndProcessPackageElements( EA_RelMatrix.fromPackage, fromLister, EA_RelMatrix.fromPackageRecursion );
-         // Sort the "from" elements
-         elementSortByName sorter = new elementSortByName();
-         fromLister.Elements.Sort( sorter );
-         // dictionary to support to-from table construction.
-         ArrayList fromToDictionary = new ArrayList();
-         bool needFromToTable = false;
-         if (EA_RelMatrix.fromToTableTitle != null && EA_RelMatrix.fromToTableTitle.Length > 0)
-            needFromToTable = true;
-         bool needToFromTable = false;
-         if (EA_RelMatrix.toFromTableTitle != null && EA_RelMatrix.toFromTableTitle.Length > 0)
-            needToFromTable = true;
-         if (needFromToTable)
-         {
-            if (EA_RelMatrix.fromIntroText != null && EA_RelMatrix.fromIntroText.Length > 0)
-            {
-               appendAndSelectText( EA_RelMatrix.fromIntroText, styleName_Body1 );
-            }
-            // create the from-to table in the word doc
-            tableNum = createTable( EA_RelMatrix.fromToTableTitle, fromLister.Elements.Count + 1, 2 );
-            table = WordDocument.Tables[tableNum];
-            table.Cell(1,1).Range.Text = EA_RelMatrix.fromColumnTitle;
-            table.Cell(1,1).Range.ParagraphFormat.Alignment = Word.WdParagraphAlignment.wdAlignParagraphCenter;
-            table.Cell(1,1).Range.Font.Bold = 1;
-            table.Cell(1,2).Range.Text = EA_RelMatrix.toColumnTitle;
-            table.Cell(1,2).Range.ParagraphFormat.Alignment = Word.WdParagraphAlignment.wdAlignParagraphCenter;
-            table.Cell(1,2).Range.Font.Bold = 1;
-         }
-         // Add from-to content to the from-to table.
+      public class methodSortByPos : IComparer
-         // NOTE: this code has to execute even if no from-to table is needed, in order to support the
-         // generation of a to-from table, assuming the user has requested one.
-         int row = 2;
+      {
-         foreach(EA.Element fromElement in fromLister.Elements)
+         int IComparer.Compare( object x, object y)
+         {
-            // Output the left hand column text to the from-to table, if one has been requested
-            if (needFromToTable)
-               table.Cell(row,1).Range.Text = fromElement.Name;
-            // look at the elements connection collection to find references to the
-            // destination elements
-            EA.Collection conCollection = fromElement.Connectors;
-            bool firstCon = true;
-            foreach (EA.Connector thisCon in conCollection)
-            {
-               EA.Element destE = EA_Repository.GetElementByID( thisCon.SupplierID );
-               if (destE == null)
+            if (x!=null & y!= null)
-                  continue;
-               // ignore self-referential connections
-               if (fromElement.ElementID == thisCon.SupplierID)
+               return ((EA.Method)x).Pos - ((EA.Method)y).Pos;
-                  continue;
-               // if the destination element is of a type that the user has requested to include...
-               if (!EA_RelMatrix.toElementTypes.Contains( destE.Type ))
-                  continue;
-               // Output the right hand column text to the from-to table, if one has been requested
-               if (needFromToTable)
-               {
+            else
-                  if (firstCon)
-                  {
-                     firstCon = false;
-                     table.Cell(row,2).Range.Text = destE.Name;
-                  }
-                  else
-                  {
-                     table.Cell(row,2).Range.Text += destE.Name;
-                  }
+               return 0;
-               }
-               // Capture the from-to relationship in a dictionary where the key is the
-               // ID of the destination element, and the value is the from element name.
-               // This dictionary will enable rapid construction of the to-from table if
-               // the user has requested it, from the exact same relationship info used
-               // to construct the from-to table.
-               if (needToFromTable)
-               {
-                  DictionaryEntry newEntry = new DictionaryEntry(destE.ElementID, fromElement.Name);
-                  fromToDictionary.Add( newEntry );
-               }
-            }
-            row++;
+         }
+      }
-         // Does user want a to-from table ?
+      public class parameterSortByPos : IComparer
+      {
-         if (needToFromTable)
+         int IComparer.Compare( object x, object y)
+         {
-            ElementAccumulator toLister = new ElementAccumulator(EA_RelMatrix.toElementTypes);
-            EA_Utils.findAndProcessPackageElements( EA_RelMatrix.toPackage, toLister, EA_RelMatrix.toPackageRecursion );
-            // Sort the "to" elements
-            toLister.Elements.Sort( sorter );
-            if (EA_RelMatrix.toIntroText != null && EA_RelMatrix.toIntroText.Length > 0)
-            {
-               appendAndSelectText( EA_RelMatrix.toIntroText, styleName_Body1 );
-            }
-            // create the table in the word doc
-            tableNum = createTable( EA_RelMatrix.toFromTableTitle, toLister.Elements.Count + 1, 2 );
-            table = WordDocument.Tables[tableNum];
-            table.Cell(1,1).Range.Text = EA_RelMatrix.toColumnTitle;
-            table.Cell(1,1).Range.ParagraphFormat.Alignment = Word.WdParagraphAlignment.wdAlignParagraphCenter;
-            table.Cell(1,1).Range.Font.Bold = 1;
-            table.Cell(1,2).Range.Text = EA_RelMatrix.fromColumnTitle;
-            table.Cell(1,2).Range.ParagraphFormat.Alignment = Word.WdParagraphAlignment.wdAlignParagraphCenter;
-            table.Cell(1,2).Range.Font.Bold = 1;
-            // To make the to-from table, we use the dictionary that was built when making the from-to
-            // table. The dictionary will allow rapid determination of what "from" items belong to each
-            // "to" item, without us having to go back to EA and enquire on the database.
-            row = 2;
-            foreach(EA.Element toElement in toLister.Elements)
-            {
-               // left-column cell content
-               table.Cell(row,1).Range.Text = toElement.Name;
-               // right-column cell content
-               bool firstCon = true;
-               foreach (DictionaryEntry de in fromToDictionary)
-               {
-                  if ((int)de.Key == toElement.ElementID)
-                  {
-                     if (firstCon)
+            if (x!=null & y!= null)
-                     {
-                        firstCon = false;
-                        table.Cell(row,2).Range.Text = (string)de.Value;
-                     }
-                     else
-                     {
-                        table.Cell(row,2).Range.Text += (string)de.Value;
+               return ((EA.Parameter)x).Position - ((EA.Parameter)y).Position;
-                     }
-                  }
-               }
+            else
-               row++;
+               return 0;
-            }
+         }
+      }
       #endregion
+   }
+}

Subversion Repositories DevTools

(root)/EA_DocGen/trunk/EA_DocGen/createWordDoc.cs – Rev 2092 → 2094