Subversion Repositories DevTools

//-----------------------------------------------------------------------

// This is open source licensed under GPL

//

//

using System;

using System.Text;

using System.Globalization;

using System.Collections;

using System.Windows.Forms;

using ReqPro40;

using System.Threading;

namespace EA_ReqPro

{

   public class Main

   {

      public String EA_Connect(EA.Repository Repository)

      {

         return "a string";

      }

      private Thread ourThread = null;

      public readonly static String GUI_OUTPUT_TAB_NAME = "EA_ReqPro";

      public static EA.Repository EA_Repository = null;

      public static int abortRequests = 0;

      public static bool mustAbort = false;

      // EA_ReqPro Menu strings

      private const string MI_Root            = "-&EA ReqPro";

      private const string MI_Separator                  = "-";

      private const string MI_ImportForTraceabilityUse   = "&Import for Traceability Use";

      private const string MI_DisplayChangeLog           = "&Display Change Log";

      private const string MI_ImportForDocModelUse       = "&Import for Document Model Use";

      private const string MI_ExportToReqPro             = "&Export to ReqPro";

      private const string MI_ExportToReqProCSV          = "&Export to ReqPro Compatible CSV File";

      private const string MI_CreateReqDiagram           = "&Create Requirement Diagram";

      private const string MI_CreateReqDiagramUsingSrch  = "&Create Requirement Diagram Using Model Search";

      private const string MI_About                      = "&About...";

      private const string MI_Abort                      = "&Abort Import/Export";

      private string[] MI_RootMenu = new string[] { MI_ImportForTraceabilityUse, 

                                                    MI_DisplayChangeLog,

                                                    MI_Separator,

                                                    MI_ImportForDocModelUse,

                                                    MI_Separator,

                                                    MI_ExportToReqPro,

                                                    MI_ExportToReqProCSV,

                                                    MI_Separator,

                                                    MI_CreateReqDiagram,

                                                    MI_CreateReqDiagramUsingSrch,

                                                    MI_Separator,

                                                    MI_About };

      private string[] MI_AbortMenu = new string[] { MI_Abort };

      /// <summary>

      /// Called when EA initialised. Creates an output tab for the add in.

      /// </summary>

      /// <param name="repository"></param>

      public void EA_OnPostInitialized(EA.Repository repository)

      {

         repository.CreateOutputTab(GUI_OUTPUT_TAB_NAME);

         repository.EnsureOutputVisible(GUI_OUTPUT_TAB_NAME);

      }

      public void EA_Disconnect()

      {

         GC.Collect();

         GC.WaitForPendingFinalizers();

      }

      /// <summary>

      /// Event called when user clicks on an entry in the output

      /// window. If an element has been associated with the message, it will

      /// be automatically selected in the project browser.

      /// </summary>

      /// <param name="repository"></param>

      /// <param name="outputTabNea"></param>

      /// <param name="lineText"></param>

      /// <param name="lineIdentifier"></param>

      public void EA_OnOutputItemClicked( EA.Repository repository,

                                          String outputTabName,

                                          String lineText,

                                          Int32 identifier)

      {

         if ((outputTabName == GUI_OUTPUT_TAB_NAME) && (identifier > 0))

         {

            try

            {

               EA.Element element = repository.GetElementByID(identifier);

               if (element.MetaType == "Package")

               {

                  EA.Package package = repository.GetPackageByID(element.PackageID);

                  repository.ShowInProjectView(package);

               }

               else

               {

                  repository.ShowInProjectView(element);

               }

            }

            catch

            {

               try

               {

                  EA.Package package = repository.GetPackageByID(identifier);

                  repository.ShowInProjectView(package);

               }

               catch

               {

                  try

                  {

                     EA.Diagram diagram = repository.GetDiagramByID(identifier);

                     repository.ShowInProjectView(diagram);

                  }

                  catch

                  {

                  }

               }

            }

         }

      }

      public object EA_GetMenuItems(EA.Repository repository, string location, string menu)

      {

         switch( menu )

         {

            case "":

               return MI_Root;

            case MI_Root:

               if (ourThread != null && ourThread.IsAlive == true)

               {

                  return MI_AbortMenu;

               }

               else

               {

                  return MI_RootMenu;

               }

         }

         return "";

      }

      bool IsProjectOpen(EA.Repository Repository)

      {

         try

         {

            EA.Collection collection = Repository.Models;

            return true;

         }

         catch

         {

            return false;

         }

      }

      public void EA_GetMenuState(EA.Repository repository, string location, string menuName, string itemName, ref bool isEnabled, ref bool isChecked)

      {

         EA_Repository = repository;

         object o;

         EA.ObjectType type;

         isChecked = false;

         if (IsProjectOpen(repository))

         {

            switch (itemName)

            {

               case MI_Abort:

               case MI_ImportForDocModelUse:

               case MI_ExportToReqPro:

               case MI_ExportToReqProCSV:

               case MI_CreateReqDiagram:

               case MI_CreateReqDiagramUsingSrch:

               case MI_ImportForTraceabilityUse:

                  isEnabled = true;

                  break;

               case MI_DisplayChangeLog:

                  type = repository.GetTreeSelectedItem(out o);

                  if ( (type == EA.ObjectType.otElement) && (((EA.Element)o).Name.StartsWith("Change Log")))

                  {

                     isEnabled = true;

                  }

                  else

                  {

                     isEnabled = false;

                  }

                  break;

            }

         }

         else

         {

            isEnabled = false;

         }

      }

      public void EA_MenuClick(EA.Repository repository, string location, string menu, string itemName)

      {

         EA_Repository = repository;

         switch( itemName )

         {

            // This menu option appears only when a thread is active. It allows the user to initiate

            // an abort of the thread.

            case MI_Abort:

               if (ourThread != null && ourThread.IsAlive == true)

               {

                  if (abortRequests > 0)

                  {

                     // if user has made a second abort request, it is probably because the thread does not

                     // appear to be aborting. This can happen sometimes. I have noticed occasional lockups,

                     // and every time this happens, the thread seems to be locked up in a call to an EA

                     // automation interface function, so perhaps there is some wierd interaction between

                     // the thread and the use of the menu in the main EA process? Anyway, lets try to abort

                     // the thread now because it does not appear as if it is going to quit gracefully.

                     ourThread.Abort();

                     ReqProDatabase.close();

                     break;

                  }

                  else

                  {

                     // try to quit gracefully.

                     mustAbort = true;

                     abortRequests++;

                  }

               }

               break;

            case MI_ImportForTraceabilityUse:

               if (ourThread == null || ourThread.IsAlive == false)

               {

                  ourThread = new Thread(new ThreadStart(ImportReqProDatabase_Thread));

                  ourThread.SetApartmentState(ApartmentState.STA);

                  ourThread.Start();

               }

               break;

            case MI_ImportForDocModelUse:

               if (ourThread == null || ourThread.IsAlive == false)

               {

                  ourThread = new Thread(new ThreadStart(CopyReqProDatabase_Thread));

                  ourThread.SetApartmentState(ApartmentState.STA);

                  ourThread.Start();

               }

               break;

            case MI_ExportToReqPro:

               if (ourThread == null || ourThread.IsAlive == false)

               {

                  ourThread = new Thread(new ThreadStart(ExportToReqPro_Thread));

                  ourThread.SetApartmentState(ApartmentState.STA);

                  ourThread.Start();

               }

               break;

            case MI_ExportToReqProCSV:

               repository.EnsureOutputVisible(GUI_OUTPUT_TAB_NAME);

               repository.WriteOutput(GUI_OUTPUT_TAB_NAME,"",-1);

               ExportToReqProCSVForm export_dlg = new ExportToReqProCSVForm();

               DialogResult dlgRes = export_dlg.ShowDialog();

               if (dlgRes == DialogResult.OK)

               {

                  export_dlg.Export();

               }

               break;

            case MI_DisplayChangeLog:

            {

               ImportReqProDatabase import_parser = new ImportReqProDatabase();

               EA.Element changeLog = (EA.Element)repository.GetTreeSelectedObject();

               repository.EnsureOutputVisible(GUI_OUTPUT_TAB_NAME);

               import_parser.displayChangeLog(changeLog);

               break;

            }

            case MI_CreateReqDiagram:

            {

               ArrayList allowedElementTypes = new ArrayList();

               allowedElementTypes.Add("Requirement");

               //allowedElementTypes.Add("UseCase");

               EA_ElementAccumulator reqLister = new EA_ElementAccumulator(allowedElementTypes);

               EA.Package thePackage = (EA.Package)repository.GetTreeSelectedObject();

               EA_Parsing.findAndProcessPackageElements( thePackage, reqLister, true );

               createRequirementDiagram(thePackage, reqLister.Elements);

               break;

            }

            case MI_CreateReqDiagramUsingSrch:

            {

               QueryForm qf = new QueryForm();

               DialogResult qf_dlgRes = qf.ShowDialog();

               if (qf_dlgRes == DialogResult.OK)

               {

                  EA.Package thePackage = (EA.Package)repository.GetTreeSelectedObject();

                  EA.Collection c = EA_Repository.GetElementsByQuery(qf.textBox_query_name.Text, qf.textBox_search_term.Text);

                  createRequirementDiagram(thePackage, c);

               }

               break;

            }

            case MI_About:

               AboutForm anAbout = new AboutForm();

               anAbout.ShowDialog();

               break;

         }

      }

      private void createRequirementDiagram(EA.Package containerPackage, EA.Collection c)

      {

         EA.Diagram newDiagram = (EA.Diagram)containerPackage.Diagrams.AddNew("Requirements","Logical");

         newDiagram.Update();

         containerPackage.Update();

         foreach (EA.Element element in c)

         {

            EA.DiagramObject newDiagramObject = (EA.DiagramObject)newDiagram.DiagramObjects.AddNew("l=1;r=10;t=1;b=1", "");

            newDiagramObject.ElementID = element.ElementID;

            newDiagramObject.Update();

         }

         newDiagram.DiagramObjects.Refresh();

         containerPackage.Update();

         EA_Repository.GetProjectInterface().LayoutDiagramEx( newDiagram.DiagramGUID,

            EA.ConstLayoutStyles.lsDiagramDefault, 4, 20, 20, false);

      }

      private void createRequirementDiagram(EA.Package containerPackage, ArrayList elements)

      {

         EA.Diagram newDiagram = (EA.Diagram)containerPackage.Diagrams.AddNew("Requirements","Logical");

         newDiagram.Update();

         containerPackage.Update();

         foreach (EA.Element element in elements)

         {

            EA.DiagramObject newDiagramObject = (EA.DiagramObject)newDiagram.DiagramObjects.AddNew("l=1;r=10;t=1;b=1", "");

            newDiagramObject.ElementID = element.ElementID;

            newDiagramObject.Update();

         }

         newDiagram.DiagramObjects.Refresh();

         containerPackage.Update();

         EA_Repository.GetProjectInterface().LayoutDiagramEx( newDiagram.DiagramGUID,

            EA.ConstLayoutStyles.lsDiagramDefault, 4, 20, 20, false);

      }

      /// <summary>

      /// Thread function for import for traceability use operation

      /// </summary>

      private static void ImportReqProDatabase_Thread()

      {

         bool cancelled = false;

         mustAbort = false;

         abortRequests = 0;

         EA_Repository.EnsureOutputVisible(GUI_OUTPUT_TAB_NAME);

         EA_Repository.WriteOutput(GUI_OUTPUT_TAB_NAME,"",-1);

         ImportReqProDatabase import_parser = new ImportReqProDatabase();

         import_parser.prompt_and_parse(ReqProDB_Artifact.MODE.TRACEABILITY, out cancelled);

         if (mustAbort)

         {

            EA_Repository.WriteOutput(GUI_OUTPUT_TAB_NAME, "Import Aborted", -1);

            MessageBoxEx.Show("Import Aborted", "Progress");

         }

         else if (cancelled)

         {

            Main.WriteOutput("Import Cancelled",-1);

         }

         abortRequests = 0;

         ReqProDatabase.close();

      }

      /// <summary>

      /// Thread function for import for document model use operation

      /// </summary>

      private static void CopyReqProDatabase_Thread()

      {

         bool cancelled = false;

         mustAbort = false;

         abortRequests = 0;

         EA_Repository.EnsureOutputVisible(GUI_OUTPUT_TAB_NAME);

         EA_Repository.WriteOutput(GUI_OUTPUT_TAB_NAME,"",-1);

         CopyReqProDatabase copy_parser = new CopyReqProDatabase();

         copy_parser.prompt_and_parse(ReqProDB_Artifact.MODE.DOC_MODEL, out cancelled);

         if (mustAbort)

         {

            EA_Repository.WriteOutput(GUI_OUTPUT_TAB_NAME, "Import Aborted", -1);

            MessageBoxEx.Show("Import Aborted", "Progress");

         }

         else if (cancelled)

         {

            Main.WriteOutput("Import Cancelled",-1);

         }

         abortRequests = 0;

         ReqProDatabase.close();

      }

      /// <summary>

      /// Thread function for export to reqpro database operation

      /// </summary>

      private static void ExportToReqPro_Thread()

      {

         bool cancelled = false;

         mustAbort = false;

         abortRequests = 0;

         EA_Repository.EnsureOutputVisible(GUI_OUTPUT_TAB_NAME);

         EA_Repository.WriteOutput(GUI_OUTPUT_TAB_NAME,"",-1);

         ExportToReqProDatabase export_parser = new ExportToReqProDatabase();

         export_parser.prompt_and_parse(ReqProDB_Artifact.MODE.EXPORT, out cancelled);

         if (mustAbort)

         {

            EA_Repository.WriteOutput(GUI_OUTPUT_TAB_NAME, "Export Aborted", -1);

            MessageBoxEx.Show("Export Aborted", "Progress");

         }

         else if (cancelled)

         {

            Main.WriteOutput("Export Cancelled",-1);

         }

         abortRequests = 0;

         ReqProDatabase.close();

      }

      public static void MessageBoxException(Exception exc)

      {

         MessageBoxException(exc, "Exception");

      }

      public static void MessageBoxException(Exception exc, string caption)

      {

         MessageBoxEx.Show(exc.ToString(), caption, MessageBoxIcon.Error);

      }

      public static void WriteOutput(string s, int id)

      {

         EA_Repository.WriteOutput( GUI_OUTPUT_TAB_NAME, s, id);

      }

      public static void ClearOutput()

      {

         EA_Repository.ClearOutput(GUI_OUTPUT_TAB_NAME);

      }

      public static void WriteSeperator()

      {

         EA_Repository.WriteOutput( GUI_OUTPUT_TAB_NAME, "----------------------------------------------------------------------------------------------------------------------", -1);

      }

   }

}