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

          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)
-         // create the table in the word doc
+            needFromToTable = true;
+         bool needToFromTable = false;
+         if (EA_RelMatrix.toFromTableTitle != null && EA_RelMatrix.toFromTableTitle.Length > 0)
+            needToFromTable = true;
-         if (EA_RelMatrix.fromToTableTitle != null)
+         if (needFromToTable)
+         {
-            if (EA_RelMatrix.fromIntroText != null)
+            if (EA_RelMatrix.fromIntroText != null && EA_RelMatrix.fromIntroText.Length > 0)
+            {
                appendAndSelectText( EA_RelMatrix.fromIntroText, "Body 1" );
+            }
+            // 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,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.
+         // 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)
+         {
+            // Output the left hand column text to the from-to table, if one has been requested
-            if (EA_RelMatrix.fromToTableTitle != null)
+            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;
+            {
                EA.Element destE = EA_Repository.GetElementByID( thisCon.SupplierID );
                if (destE == null)
                   continue;
-               // if the destination element is of a type that the user has requested to include...
+               // ignore self-referential connections
-               if (!EA_RelMatrix.toElementTypes.Contains( destE.Type ))
+               if (fromElement.ElementID == thisCon.SupplierID)
                   continue;
+               // if the destination element is of a type that the user has requested to include...
-               if ( (destE.Type == "Requirement") && (destE.Status == "Rejected") )
+               if (!EA_RelMatrix.toElementTypes.Contains( destE.Type ))
                   continue;
-               // Output the text
+               // Output the right hand column text to the from-to table, if one has been requested
-               if (firstCon)
+               if (needFromToTable)
+               {
-                  firstCon = false;
+                  if (firstCon)
+                  {
-                  if (EA_RelMatrix.fromToTableTitle != null)
+                     firstCon = false;
                      table.Cell(row,2).Range.Text = destE.Name;
-               }
+                  }
-               else
+                  else
-               {
+                  {
-                  if (EA_RelMatrix.fromToTableTitle != null)
                      table.Cell(row,2).Range.Text += destE.Name;
+                  }
+               }
                // 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
-               // for the from-to table.
+               // to construct the from-to table.
-               if (EA_RelMatrix.toFromTableTitle != null)
+               if (needToFromTable)
+               {
                   DictionaryEntry newEntry = new DictionaryEntry(destE.ElementID, fromElement.Name);
                   fromToDictionary.Add( newEntry );
+               }
+            }
             row++;
+         }
          // Does user want a to-from table ?
-         if (EA_RelMatrix.toFromTableTitle != null)
+         if (needToFromTable)
+         {
             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)
+            if (EA_RelMatrix.toIntroText != null && EA_RelMatrix.toIntroText.Length > 0)
+            {
                appendAndSelectText( EA_RelMatrix.toIntroText, "Body 1" );
+            }
             // create the table in the word doc
             // 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 fromElement in toLister.Elements)
+            foreach(EA.Element toElement in toLister.Elements)
+            {
-               // from
+               // left-column cell content
-               table.Cell(row,1).Range.Text = fromElement.Name;
+               table.Cell(row,1).Range.Text = toElement.Name;
-               // skip rejected requirements - not needed because it is done in the ElementAccumulator class
-               //if ( (fromElement.Type == "Requirement") && (fromElement.Status == "Rejected") )
-               //   continue;
-               // to's
+               // right-column cell content
                bool firstCon = true;
                foreach (DictionaryEntry de in fromToDictionary)
+               {
-                  if ((int)de.Key == fromElement.ElementID)
+                  if ((int)de.Key == toElement.ElementID)
+                  {
                      if (firstCon)
+                     {
                         firstCon = false;
                         table.Cell(row,2).Range.Text = (string)de.Value;

Subversion Repositories DevTools

(root)/EA_DocGen/trunk/EA_DocGen/createWordDoc.cs – Rev 2088 → 2090