Subversion Repositories DevTools

using System.Text;

      private EA.Repository EA_Repository = null;

      private TextualContent TextUtils = null;

      private TabularContent TableUtils = null;

      private Word.Document WordDocument = null;

      private ArrayList processedElements = null;

      private int style = 1;

         EA.Repository  EA_RepRef, 

         TabularContent TableUtilsRef,

         TextualContent TextUtilsRef,

         EA_Utilities   EA_UtilsRef,

         Word.Document  WordDocumentRef,

         ArrayList      processedElementsRef)

         EA_Repository     = EA_RepRef;

         TableUtils        = TableUtilsRef;

         TextUtils         = TextUtilsRef;

         WordDocument      = WordDocumentRef;

         processedElements = processedElementsRef;

         style = 1;

               if (s.StartsWith("style="))

               {

                  style = EA_Utils.options.getOptionValue(s, style);

               }

      {

         switch (style)

         {

            case 1:

               return

               "style=1\r\n"

               + "fromToTableTitle=\r\n"

               + "fromIntroText=\r\n"

               + "fromColumnTitle=\r\n"

               + "fromPackage=\r\n"

               + "fromElementType=\r\n"

               + "fromElementType=\r\n"

               + "fromPackageRecursion=true\r\n"

               + "fromPackageTrimming=false\r\n"

               + "toFromTableTitle=\r\n"

               + "toIntroText=\r\n"

               + "toColumnTitle=\r\n"

               + "toPackage=\r\n"

               + "toElementType=\r\n"

               + "toPackageRecursion=true\r\n"

               + "toPackageTrimming=false\r\n";

            case 2:

               return

               "style=2\r\n"

               + "fromToTableTitle=Requirement Dependencies\r\n"

               + "fromIntroText=The following table identifies the source requirements (if any) for each requirement stated in this document.\r\n"

               + "fromColumnTitle=Requirement\r\n"

               + "fromPackage=\r\n"

               + "fromElementType=Requirement\r\n"

               + "fromPackageRecursion=true\r\n"

               + "fromPackageTrimming=false\r\n"

               + "toPackageRecursion=true\r\n"

               + "toPackage=\r\n"

               + "toColumnTitle=Source Requirements\r\n"

               + "toElementType=Requirement\r\n";

            default:

               return "";

         }

      }

      /// <summary>

      /// This function will insert one or more relationship matrix tables 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>

      public void processRelationshipMatrixElement( EA.Element theElement, int recurse_level )

      {

         switch (style)

         {

            case 1:

               processRelationshipMatrixElementStyle1();

               break;

            case 2:

               processRelationshipMatrixElementStyle2();

               break;

         }

      }

      /// <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.

      /// 

      /// The style of these tables is that required for requirement to design traceability.

      /// </summary>

      /// <param name="EA_RelMatrix"></param>

      private void processRelationshipMatrixElementStyle1()

      {

         int tableNum = 0;

         Word.Table table = null;

         // Scan the fromPackage to find all the "from elements".

         ElementAccumulator fromLister = new ElementAccumulator(fromElementTypes, EA_Utils);

         EA_Utils.findAndProcessPackageElements( fromPackage, fromLister, 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 (fromToTableTitle != null && fromToTableTitle.Length > 0)

            needFromToTable = true;

         bool needToFromTable = false;

         if (toFromTableTitle != null && 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 (!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 (fromPackageTrimming == false)

            {

               DictionaryEntry newFromToEntry = new DictionaryEntry(fromElement, null);

               fromToDictionary.Add( newFromToEntry );

               numberOfFromToRows++;

            }

         }

         if (needFromToTable)

         {

            // Now we can actually serialise the table

            if (fromIntroText != null && fromIntroText.Length > 0)

            {

               TextUtils.appendAndSelectText( fromIntroText, EA_Constants.styleName_Body1 );

            }

            // create the from-to table in the word doc

            tableNum = TableUtils.Table_Create( fromToTableTitle, numberOfFromToRows + 1, 2 );

            table = WordDocument.Tables[tableNum];

            TableUtils.Table_SetTableColumnTitle(table, fromColumnTitle, 1);

            TableUtils.Table_SetTableColumnTitle(table, toColumnTitle, 2);

            fillInTable(fromToDictionary, table);

         }

         // 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(toElementTypes, EA_Utils);

            EA_Utils.findAndProcessPackageElements( toPackage, toLister, 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 (toPackageTrimming == false)

               {

                  DictionaryEntry newFromToEntry = new DictionaryEntry(toElement, "");

                  fromToDictionary.Add( newFromToEntry );

                  numberOfFromToRows++;

               }

            }

            // Now begin to add the to-from table to the word document

            if (toIntroText != null && toIntroText.Length > 0)

            {

               TextUtils.appendAndSelectText( toIntroText, EA_Constants.styleName_Body1 );

            }

            // create the table in the word doc

            tableNum = TableUtils.Table_Create( toFromTableTitle, numberOfFromToRows + 1, 2 );

            table = WordDocument.Tables[tableNum];

            TableUtils.Table_SetTableColumnTitle(table, toColumnTitle, 1);

            TableUtils.Table_SetTableColumnTitle(table, fromColumnTitle, 2);

            fillInTable(fromToDictionary, table);

         }

      }

      private void fillInTable(ArrayList fromToDictionary, Word.Table table )

         int lastFromElementId = -1;

         bool firstToFromCon = true;

         int row = 1;

         foreach (DictionaryEntry de in fromToDictionary)

         {

            if ( ((EA.Element)de.Key).ElementID != lastFromElementId )

               table.Cell(row,1).Range.Text = ((EA.Element)de.Key).Name;

            }

            {

               {

                  table.Cell(row,2).Range.Text += (string)de.Value;

            }

            {

               if (EA_Utils.options.opt_SuppressUnAllocatedRelationshipWarnings == false)

                  table.Cell(row,2).Range.Font.Color = Word.WdColor.wdColorRed;

               }

            }

         }

      /// <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.

      /// 

      /// The style of this single table is that required for requirement to requirement traceability.

      /// Here, only a single table is generated, and the only elements in the left hand column will

      /// be those serialised to the document earlier on, and the content of the right hand column

      /// will be the parental requirements (all the way up to root requirements).

      /// </summary>

      /// <param name="EA_RelMatrix"></param>

      private void processRelationshipMatrixElementStyle2()

      {

         int i;

         int tableNum = 0;

         Word.Table table = null;

         // Scan the fromPackage to find all the "from elements".

         ElementAccumulator fromLister = new ElementAccumulator(fromElementTypes, EA_Utils);

         EA_Utils.findAndProcessPackageElements( fromPackage, fromLister, fromPackageRecursion );

         // Remove all elements from the list that did not go to form content in the document

         // prior to this point in the document generation process.

         for (i=0; i<fromLister.Elements.Count; )

         {

            if ( !processedElements.Contains( ((EA.Element)fromLister.Elements[i]).ElementID ) )

            {

               fromLister.Elements.RemoveAt(i);

               continue;

            }

            i++;

         }

         // Sort the remaining "from elements"

         elementSortByName sorter = new elementSortByName();

         fromLister.Elements.Sort( sorter );

         // Scan the toPackage to find all the "to elements".

         // Extract their element IDs into a new list.

         ElementAccumulator toLister = new ElementAccumulator(toElementTypes, EA_Utils);

         EA_Utils.findAndProcessPackageElements( toPackage, toLister, toPackageRecursion );

         ArrayList acceptableParents = new ArrayList();

         foreach(EA.Element ele in toLister.Elements)

         {

            acceptableParents.Add( ele.ElementID);

         }

         // The list of from elements dictates the number of rows in our table.

         int numberOfFromToRows = fromLister.Elements.Count;

         if (fromIntroText != null && fromIntroText.Length > 0)

         {

            TextUtils.appendAndSelectText( fromIntroText, EA_Constants.styleName_Body1 );

         }

         // create the from-to table in the word doc

         tableNum = TableUtils.Table_Create( fromToTableTitle, numberOfFromToRows + 1, 2 );

         table = WordDocument.Tables[tableNum];

         TableUtils.Table_SetTableColumnTitle(table, fromColumnTitle, 1);

         TableUtils.Table_SetTableColumnTitle(table, toColumnTitle, 2);

         int row = 2;

         foreach(EA.Element ele in fromLister.Elements)

         {

            table.Cell(row,1).Range.Text = ele.Name;

            StringBuilder sb = new StringBuilder();

            ArrayList parentsDiscovered = new ArrayList();

            // Find this requirement's parent (source) requirements

            elementParenthood(ele, ref acceptableParents, ref parentsDiscovered, ref sb);

            // if no source requirements found and user has opted for trimming, delete the table row

            if (fromPackageTrimming == true && sb.Length == 0)

            {

               TableUtils.Table_DeleteThisRow(table, row);

               continue;

            }

            // fill in the right hand cell on this row of the table with the source requirement list

            table.Cell(row,2).Range.Text = sb.ToString();

            row++;

         }

      }

      private void elementParenthood(EA.Element ele, ref ArrayList acceptableParents, ref ArrayList parentsDiscovered, ref StringBuilder sb)

      {

         foreach(EA.Connector con in ele.Connectors)

         {

            // ignore downwards direction, indicated by the client ID being equal to the element ID

            if (con.ClientID != ele.ElementID)

            {

               // if we have not already come across this upward path before...

               if (!parentsDiscovered.Contains(con.ClientID))

               {

                  parentsDiscovered.Add(con.ClientID);

                  // is this parent is in the list of acceptable parents...

                  if (acceptableParents.Contains(con.ClientID))

                  {

                     // get the parent element, add its name to our list, and ascend through the element

                     // using recursion.

                     EA.Element client = EA_Repository.GetElementByID(con.ClientID);

                     if (client != null)

                     {

                        if (sb.Length > 0)

                           sb.Append("\n");

                        sb.Append(client.Name);

                        elementParenthood(client, ref acceptableParents, ref parentsDiscovered, ref sb);

                     }

                  }

               }

            }

         }

      }