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

       private EA_Utilities EA_Utils = null;
       private TabularContent TableUtils = null;
       private TextualContent TextUtils = null;
       private StyleContent   StyleUtils = null;
+      private DocSectionTracking DocSectionTracker = null;
       private bool oneShot_skipRootPackage = false;
       private bool oneShot_skipRootElementHeading = false;
+      private int processingLink = 0;
+      private ArrayList processedElements = null;
       // 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 classesNeedingUnitTests = 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 int[] DocSection = null;
-      private int   iDocSection = 0;
       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);
+         DocSectionTracker = new DocSectionTracking();
+         TableUtils        = new TabularContent(WordApp, WordDocument, EA_Utils);
+         TextUtils         = new TextualContent(WordApp, WordDocument, DocSectionTracker);
+         StyleUtils        = new StyleContent(WordApp, WordDocument);
-         DocSection = new int[12];
-         for (int i=0; i<DocSection.Length; i++)
-         {
-            DocSection[i] = 0;
-         }
          WordApp = new Word.Application();
+      }
       #endregion
       #region word document generation code
-      /// <summary>
-      /// This class is one derived from the EA_UtilitiesRecursionWorker base class so that
-      /// an instance of it can be used as a parameter in the EA_Utilities.findAndProcessPackageElements
-      /// method which recursively parses a given package. Thus, clients can parse EA model structure but
-      /// specify their own functionality to be carried out on packages and elements found in the
-      /// parsing.
-      /// This particular derived class is designed to collect a list of element names from the
-      /// package, from elements that have a type that is acceptable.
-      /// </summary>
-      public class ElementAccumulator : EA_UtilitiesRecursionWorker
-      {
-         public ArrayList Elements = null;
-         private ArrayList validElementTypes = null;
-         private EA_Utilities EA_Utils = null;
-         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") )
-               //   return;
-               if (   0 == theElement.Type.CompareTo("Class")
-                  && true == EA_Utils.options.opt_SuppressPrivateClasses
-                  && true == theElement.Visibility.StartsWith("Private") )
-               {
-                  // do nothing
-               }
-               else
-               {
-                  Elements.Add( theElement );
-               }
-            }
-         }
-      }
-      private void trackDocSection(int recurse_level)
-      {
-         iDocSection = recurse_level;
-         DocSection[iDocSection]++;
-         for (int i=iDocSection+1; i<DocSection.Length; i++)
-            DocSection[i] = 0;
-      }
       /// <summary>
       /// Displays progress of the document generation in the createWordDocument dialog
       /// </summary>
+      {
          textBox_progress.AppendText( prefix + EA_string + "\r\n" );
          // Display to the output tab as well - as a longer term record of what happened
          StringBuilder sb = new StringBuilder("");
-         for (int i = 1; i<=iDocSection; i++)
-         {
-            if (i!=1)
-               sb.Append(".");
-            sb.Append(DocSection[i].ToString());
+         DocSectionTracker.appendHeadingNumber(ref sb);
-         }
          while (sb.Length < 30)
             sb.Append(" ");
          sb.Append(prefix);
          sb.Append(EA_string);
       /// pasting it into the document, it sets the style and other aspects of the image.
       /// </summary>
       /// <param name="theDiagram"></param>
       private void appendAndSelectDiagramViaClipboard(EA.Diagram theDiagram)
+      {
+         // NOTE: diagrams only use one stereotype, not a list of them, so dont use StereotypeEx field
+         if (  EA_Utils.options.opt_ConsiderAPIDiagramsOnly
+            && !theDiagram.Stereotype.Equals("API") )
+         {
+            displayProgress( "SKIPPED DIAGRAM: ", theDiagram.Name.ToString() );
+         }
          // open the diagram in EA and copy it's image to the clipboard
-         if (EA_Project.PutDiagramImageOnClipboard(theDiagram.DiagramGUID,0))
+         else if (EA_Project.PutDiagramImageOnClipboard(theDiagram.DiagramGUID,0))
+         {
             object startLocation;
             object endLocation;
             TextUtils.appendDescription( theDiagram.Notes, EA_Utils );
             //bookmarkName = bookmarkName.Replace(' ', '_');
             //WordDocument.Bookmarks.Add( bookmarkName, ref lastParaRange );
             // Close the diagram in EA
             EA_Repository.CloseDiagram(theDiagram.DiagramID);
+            displayProgress( "DIAGRAM: ", theDiagram.Name.ToString() );
+         }
+      }
       #region special element processing functions (link elements, table and text elements, etc)
                if (s[0] == '{')
+               {
                   EA.Diagram theFoundDiagram = EA_Utils.EA_Finder.findDiagramInRepositoryByGUID(s);
                   if (theFoundDiagram != null)
+                  {
-                     displayProgress( "DIAGRAM: ", theFoundDiagram.Name.ToString() );
                      appendAndSelectDiagramViaClipboard( theFoundDiagram );
+                  }
                   else
+                  {
                      MessageBox.Show("WARNING - Could not find linked diagram : " + linkedName );
+         }
+      }
       /// <summary>
-      /// This method creates a table from the content of an EA_DocGenTable element in the model.
+      /// This method is recursive and searches a model structure to find a match to any
-      /// The elements notes section contains the table parameters and cell content.
+      /// of the names given in a list. Matched package structure is then parsed for
-      /// See the EA_Utilities::AddTableElement() method for the layout of this content.
+      /// document content generation.
       /// </summary>
+      /// <param name="parentPackage"></param>
-      /// <param name="theElement"></param>
+      /// <param name="thePackage"></param>
       /// <param name="recurse_level"></param>
+      /// <param name="skipRoots"></param>
+      /// <param name="names"></param>
-      private void processTableElement(EA.Element theElement, int recurse_level )
+      private void processNameLinkPackage(EA.Package parentPackage, EA.Package thePackage, int recurse_level, bool skipRoots, ref ArrayList names)
+      {
-         string [] EA_DocGenTable = null;
-         string [] cells = null;
-         string delimStr = "\r\n";
-         char [] delim = delimStr.ToCharArray();
-         string trimStr = " ";
-         char [] trimChars = trimStr.ToCharArray();
+         // search for the package name in the names[] list
-         EA_DocGenTable = theElement.Notes.ToString().Split(delim,200);
-         int columnCount = 0;
-         int rowCount = 0;
+         int i = 0;
-         char seperator = ',';
-         string tableTitle = "";
-         bool gotSeperator = false;
-         bool gotTitle = false;
+         bool found = false;
-         ArrayList colWidths = new ArrayList();
-         int indent = 0;
-         // Scan the notes content line by line looking for table parameters and counting
-         // the number of table rows (which is not specified as an explicit table parameter).
-         int s_ElementsConsumedByTableParams = 0;
-         foreach(string s in EA_DocGenTable)
+         foreach (string name in names)
+         {
+            // users can specify parent\child in a name to help narrow down exactly what package they
+            // are looking for so deal with that, but the parent\ part is optional.
-            if (s.Length > 0 && s != "\n" && s != "\r" )
+            int splitpos = name.IndexOf('\\',0);
+            if (splitpos >= 0)
+            {
-               if (gotTitle == false && s.StartsWith("title"))
+               if (parentPackage != null)
+               {
-                  s_ElementsConsumedByTableParams++;
-                  tableTitle = EA_Utils.options.getOptionValue(s, tableTitle);
+                  if (name.Substring(0,splitpos).Equals(parentPackage.Name))
-                  gotTitle = true;
-                  if (tableTitle == "")
+                  {
-                     MessageBox.Show( "Table Element Serialisation Failed - Bad Title" );
+                     if (name.Substring(splitpos+1).Equals(thePackage.Name))
+                     {
+                        found = true;
-                     break;
+                        break;
+                     }
+                  }
+               }
+               else
-               else if (columnCount == 0 && s.StartsWith("columns"))
+               {
-                  s_ElementsConsumedByTableParams++;
-                  columnCount = EA_Utils.options.getOptionValue(s, columnCount);
+                  if (name.Substring(splitpos+1).Equals(thePackage.Name))
-                  if (columnCount == 0)
+                  {
-                     MessageBox.Show( "Table Element Serialisation Failed - bad column count" );
+                     found = true;
                      break;
+                  }
+               }
+            }
+            else
+            {
-               else if (gotSeperator == false && s.StartsWith("seperator"))
+               if (name.Equals(thePackage.Name))
+               {
-                  s_ElementsConsumedByTableParams++;
+                  found = true;
-                  seperator = EA_Utils.options.getOptionValue(s, seperator);
-                  gotSeperator = true;
+                  break;
+               }
+            }
+            i++;
+         }
+         if (found)
+         {
+            // remove the found name, arm the skiproot mechanism if needed, and parse the package
+            names.RemoveAt(i);
+            if (skipRoots == true)
-               else if (s.StartsWith("widths"))
+               oneShot_skipRootPackage = true;
+            parse_package(thePackage, recurse_level);
+         }
+         else if (names.Count > 0)  // any names left to process?
-               {
+         {
-                  s_ElementsConsumedByTableParams++;
+            // recurse for each of this packages sub-packages
-                  string optValStr = EA_Utils.options.getOptionValue(s, "");
+            foreach(EA.Package subPackage in thePackage.Packages)
+            {
+               processNameLinkPackage(thePackage, subPackage, recurse_level, skipRoots, ref names);
+            }
+         }
+      }
+      private void processNameLink(EA.Element theElement, int recurse_level )
+      {
-                  string width_delimStr = ",";
+         string delimStr = "\r\n";
-                  char [] width_delim = width_delimStr.ToCharArray();
+         char [] delim = delimStr.ToCharArray();
+         string [] EA_DocGenNameLnk = theElement.Notes.ToString().Split(delim,100);
+         string linkedName = "";
-                  string [] width_strings = optValStr.Split(width_delim, 50);
+         bool gotLinkedName = false;
-                  foreach (string ws in width_strings)
-                  {
-                     if (ws.Length > 0 && ws != "\n" && ws != "\r" )
-                     {
-                        colWidths.Add( System.Convert.ToDouble(ws) );
-                     }
-                  }
-               }
-               else if (s.StartsWith("indent"))
+         ArrayList names = new ArrayList();
-               {
-                  s_ElementsConsumedByTableParams++;
-                  indent = EA_Utils.options.getOptionValue(s, 0);
-               }
-               else
-               {
-                  rowCount++;
-               }
-            }
-         }
+         EA.Package theFoundPackage = null;
+         bool skipRoots = false;
-         if (gotTitle == true && gotSeperator == true && columnCount != 0)
+         // search through the option strings
+         foreach(string s in EA_DocGenNameLnk)
+         {
-            if (rowCount < 2)
+            if (s.Length > 0 && s != "\n" && s != "\r")
-            {
-               MessageBox.Show( "Table Element Serialisation Failed - Insufficient Rows" );
-            }
-            else
+            {
-               // create the table in the word doc
-               int tableNum = TableUtils.Table_Create( tableTitle, rowCount, columnCount );
-               Word.Table table = WordDocument.Tables[tableNum];
-               object center = Word.WdParagraphAlignment.wdAlignParagraphCenter;
-               int col = 1;
+               if (s == "skiproot")
-               foreach (double d in colWidths)
+               {
-                  if (col <= columnCount)
-                     table.Columns[col].SetWidth( WordApp.CentimetersToPoints((float)d), Word.WdRulerStyle.wdAdjustNone );
-                  col++;
+                  skipRoots = true;
+               }
-               if (indent > 0)
+               else if (s[0] == '{')  // is it a GUID?
+               {
-                  table.Select();
-                  while (indent > 0)
+                  // find the package by its GUID
-                  {
-                     WordApp.Selection.Paragraphs.Indent();
+                  theFoundPackage = EA_Utils.EA_Finder.findPackageInRepositoryByGUID(s);
-                     indent--;
-                  }
+               }
-               // scan the element notes again to extract the cell content and add it to the
-               // table we just created.
-               int row = 1;
-               col = 0;
-               foreach(string s in EA_DocGenTable)
+               else if (s.StartsWith("package="))
+               {
+                  // add the users named package to our list of names
-                  if (s.Length > 0 && s != "\n" && s != "\r" )
+                  names.Add( s.Substring(8, s.Length - 8) );
-                  {
+               }
-                     if (s_ElementsConsumedByTableParams > 0)
+               else if (gotLinkedName == false)
-                     {
+               {
+                  // capture name of package refered to by the GUID - this is only for diagnostic purposes
-                        s_ElementsConsumedByTableParams--;
+                  gotLinkedName = true;
-                     }
+                  linkedName = s;
-                     else
+               }
-                     {
+            }
+         }
-                        delimStr = seperator.ToString();
+         // If the GUID was resolved...
-                        delim = delimStr.ToCharArray();
+         if (theFoundPackage != null)
+         {
-                        cells = s.Split(delim,columnCount);
+            processNameLinkPackage(null, theFoundPackage, recurse_level, skipRoots, ref names);
-                        if (cells.Length != columnCount)
-                        {
-                           MessageBox.Show( "Table Element Serialisation Failed - Bad Row" );
-                           break;
-                        }
+            if (names.Count > 0)
-                        else
-                        {
+            {
-                           // serialise table row
+               StringBuilder sb = new StringBuilder();
-                           for(col=1; col<=columnCount; col++)
-                           {
-                              cells[col-1].TrimStart( trimChars );
+               sb.Append("WARNING - Could not find named package(s)\n");
-                              cells[col-1].TrimEnd( trimChars );
-                              table.Cell(row,col).Range.Text = cells[col-1];
-                              // special handling for heading row
-                              if (row == 1)
+               sb.Append("within name link: ");
-                              {
+               sb.Append(linkedName);
-                                 table.Cell(row,col).Range.ParagraphFormat.Alignment = Word.WdParagraphAlignment.wdAlignParagraphCenter;
-                                 table.Cell(row,col).Range.Font.Bold = 1;
+               sb.Append("\n\nProblem package= directives are:\n");
-                              }
+               foreach(String s in names)
-                           }
+               {
-                           row++;
+                  sb.Append("\n");
-                        }
-                     }
+                  sb.Append(s);
-                  }
+               }
+               MessageBox.Show(sb.ToString());
+            }
+         }
          else
+         {
-            MessageBox.Show( "Table Element Serialisation Failed - Table Parameters Incomplete" );
+            MessageBox.Show("WARNING - Could not find linked package : " + linkedName );
+         }
+      }
       /// <summary>
-      /// This function processes a test link element
+      /// This function processes a name link element. These are elements that point
+      /// (using a GUID) to a package, and the user has specified text names of sub-packages
+      /// within the package that they wish to have processed for document generation.
+      /// This is a useful way of getting content when you cannot be sure that the GUIDs
+      /// of the packages you want will remain constant (eg. when re-using content from
+      /// a reqpro import (for doc gen purposes)).
       /// </summary>
       /// <param name="theElement"></param>
       /// <param name="recurse_level"></param>
       private void processTestLink(EA.Element theElement, int recurse_level )
+      {
                   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);
+                        TextUtils.appendUnitTestSuite(theFoundPackage, recurse_level, ref classesWithUnitTests, ref EA_Utils);
                      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);
+                           TextUtils.appendUnitTestSuite(theFoundElement, recurse_level, ref classesWithUnitTests, ref EA_Utils);
                         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);
+                        TextUtils.appendUnitTestSuite(theFoundElement, recurse_level, ref classesWithUnitTests, ref EA_Utils);
                      else
                         MessageBox.Show("WARNING - Could not find linked element : " + linkedName );
+                  }
+               }
                else
+            }
+         }
+      }
-      /// <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 )
-      {
-         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 (classesNeedingUnitTests.Count > 0)
+         {
             if (theElement.Notes.Length > 0)
+            {
                TextUtils.appendAndSelectText( theElement.Notes, EA_Constants.styleName_Body1);
+            }
       private void completeTestTraceability()
+      {
          if (utTraceabilityTable != null)
+         {
-            int numClassesRemaining = nonPrivateClasses.Count;
+            int numClassesRemaining = classesNeedingUnitTests.Count;
             int row = 2;
-            foreach(int elementId in nonPrivateClasses)
+            foreach(int elementId in classesNeedingUnitTests)
+            {
                EA.Element theElement = EA_Repository.GetElementByID( elementId );
                if (theElement != null)
+               {
                   utTraceabilityTable.Cell(row,1).Range.Text = theElement.Name;
             TextUtils.appendAndSelectText( theElement.Notes.ToString(), EA_Constants.styleName_RefListText );
+         }
+      }
-      private void createTerminologySection(EA.Package thePackage)
+      private void createTerminologySection(EA.Package thePackage, int recurse_level)
+      {
          // Use local package elements as source of glossary, but if none are present, resort to using
          // the project glossary in the repository
          int numItems = thePackage.Elements.Count;
          if (numItems == 0)
+         {
             numItems = EA_Repository.Terms.Count;
-         }
-         if (numItems > 0)
-         {
             // Create a table
             int tableNum = TableUtils.Table_Create("Terminology", numItems+1, 2);
             Word.Table table = WordDocument.Tables[tableNum];
             object center = Word.WdParagraphAlignment.wdAlignParagraphCenter;
             TableUtils.Table_SetTableColumnTitle(table, "Term", 1);
             TableUtils.Table_SetTableColumnTitle(table, "Definition", 2);
             table.Columns[1].SetWidth(100, Word.WdRulerStyle.wdAdjustSameWidth );
             int row = 2;
+            // inject the glossary into the table
+            foreach(EA.Term theTerm in EA_Repository.Terms)
+            {
+               table.Cell(row,1).Range.Text = theTerm.Term;
+               table.Cell(row,2).Range.Text = theTerm.Meaning;
+               row++;
+            }
+         }
+         else
+         {
+            // scan content of terminology package - allow user to specify tables, text, package links,
-            if (thePackage.Elements.Count > 0)
+            // and diagram links.
+            ArrayList infoItems = new ArrayList();
+            foreach(EA.Element theElement in thePackage.Elements)
+            {
-               // The advantage of using the package content is that the elements come out alphabetically
-               // sorted already (assuming user has not over-riden the sort order in the project browser).
-               // Also, the glossary content can be exactly tailored to what the document requires.
-               foreach(EA.Element theElement in thePackage.Elements)
+               if (theElement.Name.StartsWith(EA_Constants.EA_DocGenTable))
+               {
-                  table.Cell(row,1).Range.Text = theElement.Name.ToString();
+                  TableUtils.processTableElement( theElement, recurse_level);
+               }
+               else if (theElement.Name.StartsWith(EA_Constants.EA_DocGenPackageLink))
+               {
+                  processingLink++;
-                  table.Cell(row,2).Range.Text = theElement.Notes.ToString();
+                  processPackageLink( theElement, recurse_level );
+                  processingLink--;
+               }
+               else if (theElement.Name.StartsWith(EA_Constants.EA_DocGenText))
+               {
+                  TextUtils.appendAndSelectText( theElement.Notes.ToString(), EA_Constants.styleName_Body1 );
+               }
+               else if (theElement.Name.StartsWith(EA_Constants.EA_DocGenDiagramLink))
+               {
+                  processingLink++;
+                  processDiagramLink( theElement );
+                  processingLink--;
+               }
+               else if (theElement.Name.StartsWith(EA_Constants.EA_DocGenElementLink))
+               {
-                  row++;
+                  processingLink++;
+                  processElementLink( theElement, recurse_level );
+                  processingLink--;
+               }
+               else if (!theElement.Name.StartsWith(EA_Constants.EA_DocGenBaseName)   // ignore all other special EA_DocGen elements
+                  || theElement.Name.Length == EA_Constants.EA_DocGenBaseName.Length) // allow EA_DocGen to be used as a term/acronym
+               {
+                  infoItems.Add( theElement );
+               }
+            }
-            else // default to using the project glossary in the repository
+            if (infoItems.Count > 0)
+            {
-               // TODO
+               // Create a table
-               // 1. Alphabetically Sort the glossary terms before adding them to the table
+               int tableNum = TableUtils.Table_Create("Terminology", infoItems.Count+1, 2);
+               Word.Table table = WordDocument.Tables[tableNum];
-               //    The Repository glossary seems to be provided in non-sorted order unfortunately.
+               object center = Word.WdParagraphAlignment.wdAlignParagraphCenter;
+               TableUtils.Table_SetTableColumnTitle(table, "Term", 1);
+               TableUtils.Table_SetTableColumnTitle(table, "Definition", 2);
+               table.Columns[1].SetWidth(100, Word.WdRulerStyle.wdAdjustSameWidth );
-               // inject the glossary into the table
+               int row = 2;
-               foreach(EA.Term theTerm in EA_Repository.Terms)
+               foreach(EA.Element theElement in infoItems)
+               {
-                  table.Cell(row,1).Range.Text = theTerm.Term;
+                  table.Cell(row,1).Range.Text = theElement.Name.ToString();
-                  table.Cell(row,2).Range.Text = theTerm.Meaning;
+                  table.Cell(row,2).Range.Text = theElement.Notes.ToString();
                   row++;
+               }
+            }
+         }
+      }
       #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.
+         bool processLowerLevelContent = true;  // return value for this function
-         if (oneShot_skipRootPackage == true)
-         {
-            oneShot_skipRootPackage = false;
-            return false;
-         }
          // The package name is a heading, and the package notes are paragraphs
          // directly under that heading
-         displayProgress( "PACKAGE: ", thePackage.Name.ToString() );
          TextUtils.appendAndSelectHeadingText( thePackage.Name.ToString(), recurse_level );
+         displayProgress( "PACKAGE: ", thePackage.Name.ToString() );
          // Special handling for package called "Terminology"
          if (thePackage.Name == "Terminology")
+         {
             TextUtils.appendAndSelectText( thePackage.Notes.ToString(), EA_Constants.styleName_Body1 );
-            createTerminologySection(thePackage);
+            createTerminologySection(thePackage, recurse_level);
-            return true;
+            processLowerLevelContent = false;
+         }
-         if (thePackage.Name == "References")
+         else if (thePackage.Name == "References")
+         {
             TextUtils.appendAndSelectText( thePackage.Notes.ToString(), EA_Constants.styleName_Body1 );
             createReferencesSection(thePackage);
-            return true;
+            processLowerLevelContent = false;
+         }
+         else
+         {
-         // use the package notes as body text and indicate to caller that package elements
+            // use the package notes as body text and indicate to caller that package elements
-         // have not been consumed
+            // have not been consumed
-         TextUtils.appendAndSelectText( thePackage.Notes.ToString(), EA_Constants.styleName_Body1 );
+            TextUtils.appendAndSelectText( thePackage.Notes.ToString(), EA_Constants.styleName_Body1 );
+         }
-         return false;
+         return processLowerLevelContent;
+      }
       private void generatePackageDiagrams( EA.Package thePackage )
+      {
          // default handling of diagrams
          foreach(EA.Diagram theDiagram in thePackage.Diagrams)
+         {
             if (theDiagram.ParentID == 0 || thePackage.PackageID == theDiagram.ParentID)
+            {
-               displayProgress( "DIAGRAM: ", theDiagram.Name.ToString() );
                appendAndSelectDiagramViaClipboard( theDiagram );
+            }
+         }
+      }
       private void generateElementDiagrams( EA.Element theElement )
+      {
          // default handling of diagrams
          foreach(EA.Diagram theDiagram in theElement.Diagrams)
+         {
             if (theDiagram.ParentID == 0 || theElement.ElementID == theDiagram.ParentID)
+            {
-               displayProgress( "DIAGRAM: ", theDiagram.Name.ToString() );
                appendAndSelectDiagramViaClipboard( theDiagram );
+            }
+         }
+      }
       private void generateMethodContent( EA.Element theElement, int recurse_level )
+      {
          recurse_level++;
-         if (recurse_level > EA_Constants.MAX_HEADING_LEVEL - 1)  // -1 because this function generates two heading levels
-         {
-            throw new System.StackOverflowException(EA_Constants.maxRecursionDepthException );
-         }
          // 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)
       /// <param name="theElement"></param>
       /// <param name="recurse_level"></param>
       private void generateAttributeContent( EA.Element theElement, int recurse_level )
+      {
          recurse_level++;
-         if (recurse_level > EA_Constants.MAX_HEADING_LEVEL)
-         {
-            throw new System.StackOverflowException(EA_Constants.maxRecursionDepthException );
-         }
          // 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)
       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_Left_2_5cm_Italic);
          sb = new StringBuilder();
+         // VISIBILITY
          sb.Append( theElement.Visibility );
+         // ABSTRACT
          if (System.Convert.ToInt32(theElement.Abstract) == 1)
             sb.Append( "\nAbstract" );
+         // STEREOTYPES
+         if (theElement.StereotypeEx.Length > 0)
+         {
+            sb.Append("\nStereotypes: ");
+            sb.Append(theElement.StereotypeEx);
+         }
+         // MULTIPLICITY
+         if (theElement.Multiplicity.Length > 0)
+         {
+            sb.Append("\nMultiplicity: ");
+            sb.Append(theElement.Multiplicity);
+         }
+         // IS ACTIVE
+         if (theElement.IsActive)
+            sb.Append("\nClass is active (has its own thread of control)\n");
+         // IS SPEC
+         if (theElement.IsSpec)
+            sb.Append("\nClass is a specification\n");
          wr = TextUtils.appendAndSelectText(sb.ToString(), EA_Constants.styleName_Body1_Left_3_5cm);
+         ////////////////////////////////////////////////////////////////////////////////////////////////
          sb = new StringBuilder();
          foreach(EA.Element baseClass in theElement.BaseClasses)
+         {
             sb.Append( baseClass.Name);
+         }
             wr = TextUtils.appendAndSelectText("Base Class(es):", EA_Constants.styleName_Body1_Left_2_5cm_Italic);
             wr = TextUtils.appendAndSelectText(sb.ToString(), EA_Constants.styleName_Body1_Left_3_5cm);
+         }
+         ////////////////////////////////////////////////////////////////////////////////////////////////
          sb = new StringBuilder();
          foreach(EA.Element intf in theElement.Realizes)
+         {
             sb.Append( intf.Name);
+         }
+            }
+         }
+      }
-      private void generateElementContent( EA.Element theElement, int recurse_level )
+      private bool generateElementContent( EA.Element theElement, int recurse_level )
+      {
+         bool allowSubElementParsing = true;  // return value for the function
          // track recursion level to control heading style formatting requirements
          if (oneShot_skipRootElementHeading == false)
             recurse_level++;
          if (EA_Utils.options.elementTypeFoundInEA_DocGen( theElement.Type ))
             // element serialisation.
             if (false == TextUtils.generateRequirementText(theElement, EA_Utils))
+            {
                bool isClass = theElement.Type.StartsWith("Class");
-               if (  true == isClass
+               if (   (   true == isClass
-                  && true == EA_Utils.options.opt_SuppressPrivateClasses
+                       && true == EA_Utils.options.opt_SuppressPrivateClasses
-                  && true == theElement.Visibility.StartsWith("Private") )
+                       && true == theElement.Visibility.StartsWith("Private"))
+                   || (   true == EA_Utils.options.opt_ConsiderAPIElementsOnly
+                       && 0 > theElement.StereotypeEx.IndexOf("API"))
+                  )
+               {
                   // do nothing
+                  DocSectionTracker.trackDocSection(recurse_level);
+                  displayProgress( "SKIPPED: ", theElement.Name );
+                  allowSubElementParsing = false;
+               }
                else
+               {
-                  if (recurse_level > EA_Constants.MAX_HEADING_LEVEL)
-                  {
-                     throw new System.StackOverflowException(EA_Constants.maxRecursionDepthException);
-                  }
-                  trackDocSection(recurse_level);
-                  displayProgress( "ELEMENT: ", theElement.Name );
-                  // Determine if element is filtered out by a NO_DOC tagged value
-                  // Having written this code, I realised it might be a bad idea to let users filter out
-                  // elements by tagged values. The reason is, if that content is not in a document model
-                  // but in a design model, then it might be used by >1 document model made by different
-                  // users, so one users choice of filtering might not suit another users. The only way we
-                  // could get this to work is if the tagged values were somehow made specific to a document
-                  // model, but how do you do this? GUIDs are the only safe way to key to something but we
-                  // dont want every tagged value key to contain a GUID do we?
-//                  bool noDocGen = false;
-//                  string str_noDocGen = EA_Utils.ReadTag(theElement, "NO_DOC");
-//                  if (str_noDocGen.Length > 0)
-//                  {
-//                     str_noDocGen = str_noDocGen.ToLower();
-//                     if (str_noDocGen.CompareTo("true"))
-//                     {
-//                        noDocGen = true;
-//                        displayProgress( "FILTERED: ", theElement.Type );
-//                        oneShot_skipRootElementHeading = false;
-//                        return;
-//                     }
-//                  }
                   // 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
-                        TextUtils.appendAndSelectHeadingText( theElement.Name, recurse_level );
+                     TextUtils.appendAndSelectHeadingText( theElement.Name, recurse_level );
+                  }
                   else
+                  {
                      oneShot_skipRootElementHeading = false;
+                  }
+                  processedElements.Add(theElement.ElementID);
+                  displayProgress( "ELEMENT: ", theElement.Name );
                   TextUtils.appendDescription( theElement.Notes, EA_Utils );
                   generateElementDiagrams(theElement);
                   if (true == isClass)
+                  {
-                     // If accumulation of non-private classes is enabled, then do so.
+                     // accumulate unit testable classes.
-                     if (recordingNonPrivateClasses)
+                     if (   theElement.StereotypeEx.IndexOf("API") >= 0
+                         && !theElement.Visibility.StartsWith("Private"))
+                     {
-                        if (!theElement.Visibility.StartsWith("Private"))
-                        {
-                           nonPrivateClasses.Add( theElement.ElementID );
+                        classesNeedingUnitTests.Add( theElement.ElementID );
-                        }
+                     }
                      generateClassCharacteristics(theElement, recurse_level);
+                  }
+                  }
+               }
+            }
             else
+            {
+               processedElements.Add(theElement.ElementID);
-               trackDocSection(recurse_level);
+               DocSectionTracker.trackDocSection(recurse_level);
                displayProgress( "ELEMENT: ", theElement.Name );
+            }
+         }
          else
+         {
+            DocSectionTracker.trackDocSection(recurse_level);
             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;
+         return allowSubElementParsing;
+      }
       /// <summary>
       /// This function searches for the old content in the document in order to remove it
       /// </summary>
       /// <param name="theElement"></param>
       /// <param name="recurse_level"></param>
       private void parse_element(EA.Element theElement, int recurse_level)
+      {
          // First look for and handle special elements that control the doc-gen process
          // 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_Constants.EA_DocGenPackageLink))
+         {
+            processingLink++;
             processPackageLink( theElement, recurse_level );
+            processingLink--;
+         }
             // 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_Constants.EA_DocGenDiagramLink))
+         {
+            processingLink++;
             processDiagramLink( theElement );
+            processingLink--;
+         }
             // 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_Constants.EA_DocGenElementLink))
+         {
+            processingLink++;
             processElementLink( theElement, recurse_level );
+            processingLink--;
+         }
             // 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_Constants.EA_DocGenTable))
+         {
-            processTableElement( theElement, recurse_level );
+            TableUtils.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_Constants.EA_DocGenText))
+         {
-            processTextElement( theElement, recurse_level );
+            TextUtils.appendAndSelectText( theElement.Notes.ToString(), EA_Constants.styleName_Body1 );
+         }
          else if (theElement.Name.StartsWith(EA_Constants.EA_DocGenRelationshipMatrix))
+         {
+            EA_RelationshipMatrix EA_RelMatrix = new EA_RelationshipMatrix(EA_Repository, TableUtils, TextUtils, EA_Utils, WordDocument, processedElements);
+            if (EA_RelMatrix.processRelationshipMatrixOptions( theElement ))
+            {
-            processRelationshipMatrixElement( theElement, recurse_level );
+               EA_RelMatrix.processRelationshipMatrixElement( theElement, recurse_level );
+            }
+         }
          else if (theElement.Name.StartsWith(EA_Constants.EA_DocGenTestLink))
+         {
+            processingLink++;
             processTestLink( theElement, recurse_level );
+            processingLink--;
+         }
          else if (theElement.Name.StartsWith(EA_Constants.EA_DocGenTestTraceability))
+         {
             processTestTraceability( theElement, recurse_level );
+         }
+         else if (theElement.Name.StartsWith(EA_Constants.EA_DocGenNameLink))
+         {
+            processingLink++;
+            processNameLink( theElement, recurse_level );
+            processingLink--;
+         }
-            // we are aware of the other ERG EA add-in, EA_ReqPro! That other add-in creates
+            // we are aware of the other ERG EA add-in, EA_ReqPro! That add-in creates
             // ReqProDB stereotyped elements. Never consume them in the document generation process.
-         else if ( theElement.Stereotype != EA_Constants.stereotype_ReqProDB )
+         else if (0 > theElement.StereotypeEx.IndexOf(EA_Constants.stereotype_ReqProDB))
+         {
+            bool allowSubElementParsing = generateElementContent( theElement, recurse_level );
+            if (allowSubElementParsing)
+            {
+               // Look at this elements sub-elements
+               foreach(EA.Element subElement in theElement.Elements)
+               {
-            generateElementContent( theElement, recurse_level );
+                  parse_element(subElement, recurse_level+1);
+               }
+            }
+         }
-         // Look at this elements sub-elements
-         foreach(EA.Element subElement in theElement.Elements)
-         {
-            parse_element(subElement, recurse_level+1);
-         }
+      }
       /// <summary>
       /// Parses the package and all of its content, extracting information as needed, and
          // here, as you can see.
          bool rootPackageWasSkipped = !oneShot_skipRootPackage;
          if (oneShot_skipRootPackage == false)
+         {
             recurse_level++;
-            trackDocSection(recurse_level);
+         }
+         // determine if the package has an API stereotype
+         bool packageHasAPIStereotype = false;
+         if (0 <= thePackage.StereotypeEx.IndexOf("API") )
+            packageHasAPIStereotype = true;
+         // only process the package if it the stereotype allows, or sensitivity to the stereotype is disabled
-         if (recurse_level > EA_Constants.MAX_HEADING_LEVEL)
+         if (  !EA_Utils.options.opt_ConsiderAPIPackagesOnly
+            || (EA_Utils.options.opt_ConsiderAPIPackagesOnly && EA_Utils.options.opt_RestrictForLinkedPackagesOnly && processingLink == 0)
+            || (EA_Utils.options.opt_ConsiderAPIPackagesOnly && packageHasAPIStereotype)
+            )
+         {
-            throw new System.StackOverflowException(EA_Constants.maxRecursionDepthException );
-         }
-         // 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;
+            bool processLowerLevelContent = 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 ))
-         {
-            // consume diagrams
-            generatePackageDiagrams( thePackage );
+            // disarm the one-shot package skipping feature if it was armed
-            foreach(EA.Element subElement in thePackage.Elements)
+            if (oneShot_skipRootPackage == true)
+            {
+               oneShot_skipRootPackage = false;
+            }
+            else
+            {
-               if (subElement.ParentID == 0 || thePackage.PackageID == subElement.ParentID)
+               // Generate heading and description for the package. This function also takes care of some
-                  parse_element(subElement, recurse_level);
+               // specially handled packages (terminology, references).
+               processLowerLevelContent = generatePackageHeadingAndDescription( thePackage, recurse_level );
+            }
-            // consume elements - we have to use a special sorting class here because of peculiarties
+            // generate package heading and description. This may, depending on the package name,
-            // in the way EA holds the elements in the collections.
-            //EA_ElementSorter elementSorter = new EA_ElementSorter(thePackage);
+            // consume the elements in the package. If it does not, then consume them (and any diagrams)
-            //EA.Element theElement = null;
+            // locally here.
-            //int theElementsRelativeLevel = 0;
+            if (true == processLowerLevelContent)
-            //if (true == elementSorter.getFirst(ref theElement, ref theElementsRelativeLevel))
-           // {
+            {
-           //    do
+               // consume diagrams
-           //    {
-           //       int theElementsRecurseLevel = recurse_level + theElementsRelativeLevel;
+               generatePackageDiagrams( thePackage );
+               foreach(EA.Element subElement in thePackage.Elements)
+               {
+                  if (subElement.ParentID == 0 || thePackage.PackageID == subElement.ParentID)
-           //       parse_element( theElement, theElementsRecurseLevel );
+                     parse_element(subElement, recurse_level);
+               }
+               // Scan through the sub-packages within this package.
+               foreach(EA.Package subPackage in thePackage.Packages)
+               {
+                  // recurse
-           //    } while (true == elementSorter.getNext(ref theElement, ref theElementsRelativeLevel));
+                  parse_package(subPackage, recurse_level);
+               }
-           // }
+            }
+         }
-         // Scan through the packages within this package.
+         else
-         foreach(EA.Package lowerLevelPackage in thePackage.Packages)
+         {
+            // disarm the one-shot package skipping feature if it was armed
+            if (oneShot_skipRootPackage == true)
-            // recurse
+            {
-            parse_package(lowerLevelPackage, recurse_level);
+               oneShot_skipRootPackage = false;
+            }
+         }
-         // If appropriate, turn off non-private class accumulation.
-         if (nameStartedWithDetailedDesign)
-            recordingNonPrivateClasses = false;
+      }
       /// <summary>
       /// This is the overall generate document method. It creates a word document from
             // turn off grammar and spell checking
             WordDocument.GrammarChecked = false;
             WordDocument.SpellingChecked = false;
             // arm the public class list accumulator.
-            recordingNonPrivateClasses = false;
-            nonPrivateClasses = new ArrayList();
+            classesNeedingUnitTests = new ArrayList();
             classesWithUnitTests = new ArrayList();
+            processingLink = 0;
+            processedElements = new ArrayList();
             // If the input template does not contain the styles needed for requirement documents,
             // programmatically create them just in case.
-            StyleUtils.createRequirementStylesIfNecessary();
+            StyleUtils.createRequirementStyles();
+            StyleUtils.createAdditionalHeadingLevelStyles();
             StyleUtils.createElementDetailsStyles();
+            StyleUtils.correctErrorsInTemplateStyles();
             // 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.
          // restore security settings
          WordApp.AutomationSecurity = securityBefore;
+      }
-      /// <summary>
-      /// Class to sort EA elements alphabetically, in a case insensitive way.
-      /// This is used by the processRelationshipMatrixElement method.
-      /// </summary>
-      public class elementSortByName : IComparer
-      {
-         int IComparer.Compare( object x, object y)
-         {
-            if (x!=null & y!= null)
-               return (new CaseInsensitiveComparer()).Compare( ((EA.Element)x).Name, ((EA.Element)y).Name );
-            else
-               return 0;
-         }
-      }
-      public class attributeSortByPos : IComparer
-      {
-         int IComparer.Compare( object x, object y)
-         {
-            if (x!=null & y!= null)
-               return ((EA.Attribute)x).Pos - ((EA.Attribute)y).Pos;
-            else
-               return 0;
-         }
-      }
-      public class methodSortByPos : IComparer
-      {
-         int IComparer.Compare( object x, object y)
-         {
-            if (x!=null & y!= null)
-               return ((EA.Method)x).Pos - ((EA.Method)y).Pos;
-            else
-               return 0;
-         }
-      }
-      public class parameterSortByPos : IComparer
-      {
-         int IComparer.Compare( object x, object y)
-         {
-            if (x!=null & y!= null)
-               return ((EA.Parameter)x).Position - ((EA.Parameter)y).Position;
-            else
-               return 0;
-         }
-      }
       #endregion
+   }
+}

Subversion Repositories DevTools

(root)/EA_DocGen/trunk/EA_DocGen/createWordDoc.cs – Rev 2102 → 2104