Subversion Repositories DevTools

Rev

Rev 2161 | Rev 2169 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | RSS feed 

//-----------------------------------------------------------------------
// 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.Package package = repository.GetPackageByID(identifier);
               repository.ShowInProjectView(package);
            }
            catch
            {
               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.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.ApartmentState = ApartmentState.STA;
                  ourThread.Start();
               }
               break;

            case MI_ImportForDocModelUse:
               if (ourThread == null || ourThread.IsAlive == false)
               {
                  ourThread = new Thread(new ThreadStart(CopyReqProDatabase_Thread));
                  ourThread.ApartmentState = ApartmentState.STA;
                  ourThread.Start();
               }
               break;

            case MI_ExportToReqPro:
               if (ourThread == null || ourThread.IsAlive == false)
               {
                  ourThread = new Thread(new ThreadStart(ExportToReqPro_Thread));
                  ourThread.ApartmentState = 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");
               ElementAccumulator reqLister = new ElementAccumulator(allowedElementTypes);
               EA.Package thePackage = (EA.Package)repository.GetTreeSelectedObject();
               EA_Utilities.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:
               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);
      }
   }
}