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 bool mustAbort = false;

      /// <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);
               repository.ShowInProjectView(element);
            }
            catch
            {
               try
               {
                  EA.Package package = repository.GetPackageByID(identifier);
                  repository.ShowInProjectView(package);
               }
               catch
               {
               }
            }
         }
      }


      public object EA_GetMenuItems(EA.Repository repository, string location, string menu)
      {
         string[] ar;

         switch( menu )
         {
            case "":
               return "-&EA_ReqPro";

            case "-&EA_ReqPro":
               if (ourThread != null && ourThread.IsAlive == true)
               {
                  ar = new string[] {"&Abort Import"};
                  return ar;
               }
               else
               {
                  ar = new string[]{
                                   "&Import for Traceability Use",
                                   "&Display Change Log",
                                   "&Import for Document Model Use",
                                   "&Export to ReqPro Compatible CSV File",
                                   "&Create Requirement Diagram",
                  };
                  return ar;
               }
         }

         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 "&Abort Import":
               case "&Import for Document Model Use":
               case "&Export to ReqPro Compatible CSV File":
               case "&Create Requirement Diagram":
               case "&Import for Traceability Use":
                  isEnabled = true;
                  break;

               case "&Display Change Log":
                  type = repository.GetTreeSelectedItem(out o);
                  if ( (type == EA.ObjectType.otElement) && (((EA.Element)o).Name == "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 )
         {
            case "&Abort Import":
               if (ourThread != null && ourThread.IsAlive == true)
               {
                  mustAbort = true;
               }
               break;

            case "&Import for Traceability Use":
               if (ourThread == null || ourThread.IsAlive == false)
               {
                  ourThread = new Thread(new ThreadStart(ImportReqProDatabase_Thread));
                  ourThread.ApartmentState = ApartmentState.STA;
                  ourThread.Start();
               }
               break;

            case "&Import for Document Model Use":
               if (ourThread == null || ourThread.IsAlive == false)
               {
                  ourThread = new Thread(new ThreadStart(CopyReqProDatabase_Thread));
                  ourThread.ApartmentState = ApartmentState.STA;
                  ourThread.Start();
               }
               break;

            case "&Export to ReqPro Compatible CSV File":
               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 "&Display Change Log":
            {
               ImportReqProDatabase import_parser = new ImportReqProDatabase();
               EA.Element changeLog = (EA.Element)repository.GetTreeSelectedObject();
               repository.EnsureOutputVisible(GUI_OUTPUT_TAB_NAME);
               import_parser.displayChangeLog(changeLog);
               break;
            }

            case "&Create Requirement Diagram":
            {
               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 );
               EA.Diagram newDiagram = (EA.Diagram)thePackage.Diagrams.AddNew("Requirements","Logical");
               newDiagram.Update();
               thePackage.Update();

               foreach (EA.Element element in reqLister.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();
               thePackage.Update();
               repository.GetProjectInterface().LayoutDiagramEx( newDiagram.DiagramGUID, 
                  EA.ConstLayoutStyles.lsDiagramDefault, 4, 20, 20, false);
               break;

            }

         }
      }

      private static void ImportReqProDatabase_Thread()
      {
         mustAbort = false;
         ImportReqProDatabase import_parser = new ImportReqProDatabase();
         EA_Repository.EnsureOutputVisible(GUI_OUTPUT_TAB_NAME);
         EA_Repository.WriteOutput(GUI_OUTPUT_TAB_NAME,"",-1);
         import_parser.prompt_and_parse(ReqProDB_Artifact.MODE.TRACEABILITY); 
         if (mustAbort)
            MessageBoxEx.Show("Import Aborted", "Progress");
      }

      private static void CopyReqProDatabase_Thread()
      {
         mustAbort = false;
         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);
         if (mustAbort)
            MessageBoxEx.Show("Import Aborted", "Progress");
      }

      public static void MessageBoxException(Exception exc)
      {
         MessageBoxException(exc, "Exception");
      }

      public static void MessageBoxException(Exception exc, string caption)
      {
         MessageBoxEx.Show(exc.ToString(), caption);
      }
   }
}