Subversion Repositories DevTools

using System;

using System.Windows.Forms;

using System.IO;

using System.Collections;

namespace EA_DocGen

{

   /// <summary>

   /// Summary description for EA_DocGenOptions.

   /// </summary>

   public class EA_DocGenOptions

   {

      private string [] options_string = null;

      private bool options_found = false;

      // General options

      public  int opt_ElementHeadingTransitionLevel;

      public bool opt_DisplayRequirementElementsAsSections;

      public string opt_RequirementElementDisplayFormat;

      public bool opt_DisplayRequirementsWithStatus;

      // Element Types list

      private ArrayList opt_ElementTypes = null;

      private EA_Utilities EA_Utils = null;

      public EA_DocGenOptions(EA_Utilities EA_UtilsRef)

      {

         EA_Utils = EA_UtilsRef;

         opt_ElementTypes = new ArrayList();

         setDefaults();

      }

      private void setDefaults()

      {

         opt_ElementHeadingTransitionLevel = 0;

         opt_DisplayRequirementElementsAsSections = false;

         opt_RequirementElementDisplayFormat = "[REQUIREMENT: %s]";

         opt_DisplayRequirementsWithStatus = true;

      }

      /// <summary>

      /// Looks for the EA_DocGen element in the selected package. To generate a document

      /// on a package, the package must contain the EA_DocGen element, even if that elements

      /// notes are empty. It serves to denote a package as a document model that is allowed

      /// to be processed by this add-in.

      /// </summary>

      /// <param name="parentPackage"></param>

      /// <returns></returns>

      public bool lookForAndProcess_EA_DocGen_Element( EA.Package parentPackage )

      {

         options_string = null;

         options_found  = false;

         setDefaults();

         // Look for an EA_DocGen element in this package

         foreach(EA.Element theElement in parentPackage.Elements)

         {

            // Special handling for the EA_DocGen element designed to control this document

            // generator

            if (theElement.Name.ToString() == "EA_DocGen")

            {

               options_found = true;

               // Extract the content of the EA_DocGen element notes section, into a list of

               // strings.

               string delimStr = "\n";

               char [] delim = delimStr.ToCharArray();

               options_string = theElement.Notes.ToString().Split(delim,200);

               int i = 0;

               foreach(string s in options_string)

               {

                  options_string[i] = s.Trim();

                  i++;

               }

               // Extract general options from the list of strings

               extractGeneralOptions();

               // Extract element types list from the list of strings

               extractElementTypes();

               break;

            }

         }            

         return options_found;

      }

      private string getOptionValueString(string optionLine)

      {

         string delimStr = "=";

         char [] delim = delimStr.ToCharArray();

         string [] optionLineParts = optionLine.Split(delim,2);

         if (optionLineParts.GetLength(0) == 2)

         {

            return optionLineParts[1];

         }

         else

         {

            MessageBox.Show( "Error in EA_DocGen option\n\n" + optionLine + "\n\n" + "Missing value" );

         }

         return null;

      }

      // Overloaded "get option value" methods

      public int getOptionValue(string s, int defaultReturnValue)

      {

         int returnVal = defaultReturnValue;

         string optionValue = getOptionValueString(s);

         if (optionValue != null)

         {

            try

            {

               returnVal = Convert.ToInt32(optionValue);

            }

            catch(Exception)

            {

               MessageBox.Show( "Error in EA_DocGen option\n\n" + s + "\n\n" + "Expected valid integer" );

            }

         }   

         return returnVal;

      }

      public bool getOptionValue(string s, bool defaultReturnValue)

      {

         bool returnVal = defaultReturnValue;

         string optionValue = getOptionValueString(s);

         if (optionValue != null)

         {

            try

            {

               returnVal = Convert.ToBoolean(optionValue);

            }

            catch(Exception)

            {

               MessageBox.Show( "Error in EA_DocGen option\n\n" + s + "\n\n" + "Expected valid boolean" );

            }

         }   

         return returnVal;

      }

      public string getOptionValue(string s, string defaultReturnValue)

      {

         string returnVal = defaultReturnValue;

         string optionValue = getOptionValueString(s);

         if (optionValue != null)

         {

            returnVal = optionValue;

         }   

         return returnVal;

      }

      public char getOptionValue(string s, char defaultReturnValue)

      {

         char returnVal = defaultReturnValue;

         string optionValue = getOptionValueString(s);

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

         {

            returnVal = optionValue[0];

         }   

         return returnVal;

      }

      /// <summary>

      /// Method to extract all the general options from the string array obtained from

      /// the EA_DocGen element

      /// </summary>

      private void extractGeneralOptions()

      {

         bool parsingGenOpts = false;

         if (options_string != null)

         {

            // iterate through the string array obtained from the EA_DocGen element

            foreach(string s in options_string)

            {

               if (s.StartsWith("[GeneralOptions]"))

               {

                  parsingGenOpts = true;

                  continue;

               }

               else if (   (parsingGenOpts == true) 

                        && (s.Length >= 1)

                        && (s.Substring(0,1) == "[") )

               {

                  // we have gone past the general options and reached another section in EA_DocGen

                  // so there is no point in continuing. Exit the loop

                  break;

               }

               if (parsingGenOpts == true)

               {

                  if (s.StartsWith("ElementHeadingStyleTransitionsToNumParaAtLevel"))

                  {

                     opt_ElementHeadingTransitionLevel = getOptionValue(s, opt_ElementHeadingTransitionLevel);

                  }

                  else if (s.StartsWith("DisplayRequirementElementsAsSections"))

                  {

                     opt_DisplayRequirementElementsAsSections = getOptionValue(s, opt_DisplayRequirementElementsAsSections);

                  }

                  else if (s.StartsWith("RequirementElementDisplayFormat"))

                  {

                     opt_RequirementElementDisplayFormat = getOptionValue(s, opt_RequirementElementDisplayFormat);

                  }

                  else if (s.StartsWith("DisplayRequirementsWithStatus"))

                  {

                     opt_DisplayRequirementsWithStatus = getOptionValue(s, opt_DisplayRequirementsWithStatus);

                  }

                  // add others here

               }

            }         

         }

      }

      private void extractElementTypes()

      {

         bool parsingElementTypes = false;

         opt_ElementTypes.Clear();

         if (options_string != null)

         {

            // iterate through the string array obtained from the EA_DocGen element

            foreach(string s in options_string)

            {

               if (s.StartsWith("[ElementTypes]"))

               {

                  parsingElementTypes = true;

                  continue;

               }

               else if (   (parsingElementTypes == true) 

                        && (s.Length >= 1)

                        && (s.Substring(0,1) == "[") )

               {

                  // we have gone past the element types and reached another section in EA_DocGen

                  // so there is no point in continuing. Exit the loop

                  break;

               }

               if (parsingElementTypes == true)

               {

                  string trimmed_s = s.Trim();

                  if (trimmed_s.Length > 0)

                  {

                     opt_ElementTypes.Add( s );

                  }

               }

            }

         }

      }

      /// <summary>

      /// This method searches the EA_DocGen string list to find the element types the user

      /// has specified that must be included in the document. If the element type given to

      /// the function is not in that list then it is excluded from the generated document.

      /// The notes of the EA_DocGen element are formed like a .ini file and contain sections 

      /// and section content along the lines of:

      /// 

      /// [sectionName]

      /// value

      /// value

      /// etc

      /// [anotherSectionName]

      /// value

      /// value

      /// etc

      /// 

      /// The [ElementTypes] section is the one this function is interested in

      /// 

      /// </summary>

      /// <param name="elementName"></param>

      /// <returns></returns>

      public bool elementTypeFoundInEA_DocGen(string elementType)

      {

         if (opt_ElementTypes != null && opt_ElementTypes.Count > 0)

         {

            foreach(string s in opt_ElementTypes)

            {

               if (s.StartsWith(elementType))

               {

                  return true;

               }

            } 

            // elementType is not in the opt_ElementTypes list, so element is filtered out

            return false;

         }

         else

         {

            // opt_ElementTypes is empty so no filtering, return true 

            return true;

         }

      }

   } // end of class

} // end of namespace