C# EA.GetDiagramByGuid方法代码示例

        /// <summary>
        /// method moves diagram into target package
        /// </summary>
        /// <param name="Repository">EA repository</param>
        /// <param name="diagramGUID">GUID of diagram that should be moved</param>
        /// <param name="packageGUID">GUID of target package</param>
        public void moveDiagramToPackage(EA.Repository Repository, string diagramGUID, string packageGUID)
        {
            EA.Package package = (EA.Package)Repository.GetPackageByGuid(packageGUID);
            EA.Diagram diagram = (EA.Diagram)Repository.GetDiagramByGuid(diagramGUID);
            diagram.PackageID = package.PackageID;
            diagram.Update();
            package.Diagrams.Refresh();

            BPAddIn.synchronizationWindow.addToList("Movement of diagram '" + diagram.Name + "' to package '" +
               package.Name + "'");
        }

        /// <summary>
        /// method moves diagram into target element
        /// </summary>
        /// <param name="Repository">EA repository</param>
        /// <param name="diagramGUID">GUID of diagram that should be moved</param>
        /// <param name="elementGUID">GUID of target element</param>
        public void moveDiagramToElement(EA.Repository Repository, string diagramGUID, string elementGUID)
        {
            EA.Element element = (EA.Element)Repository.GetElementByGuid(elementGUID);
            EA.Diagram diagram = (EA.Diagram)Repository.GetDiagramByGuid(diagramGUID);
            diagram.ParentID = element.ElementID;
            diagram.Update();
            element.Diagrams.Refresh();

            BPAddIn.synchronizationWindow.addToList("Movement of diagram '" + diagram.Name + "' to element '" +
                    element.Name + "'");
        }

 public override void save(EA.Repository rep, FindAndReplaceItem.FieldType fieldType)
 {
     EA.Diagram dia = rep.GetDiagramByGuid(GUID);
     if ((fieldType & FindAndReplaceItem.FieldType.Description) > 0)
     { dia.Notes = _Description; }
     if ((fieldType & FindAndReplaceItem.FieldType.Name) > 0)
     {   dia.Name = _Name; }
     if ((fieldType & FindAndReplaceItem.FieldType.Stereotype) > 0)
     { dia.StereotypeEx = _Stereotype; }
     _isUpdated = true;            
     dia.Update();
 }

 public  FindAndReplaceItemDiagram(EA.Repository rep, string GUID)  :base( rep, GUID)
 {
     this._dia = rep.GetDiagramByGuid(GUID);
     this.load(rep);
 }

        /// <summary>
        /// method moves diagram object of element in diagram
        /// </summary>
        /// <param name="Repository">EA repository</param>
        /// <param name="elementGUID">GUID of element which diagram object that should be moved belongs to</param>
        /// <param name="diagramGUID">GUID of diagram</param>
        /// <param name="coordinates">new coordinates of diagram object that should be moved</param>
        public void moveElementInDiagram(EA.Repository Repository, string elementGUID, string diagramGUID, string coordinates)
        {
            EA.Element element = (EA.Element)Repository.GetElementByGuid(elementGUID);
            EA.Diagram diagram = (EA.Diagram)Repository.GetDiagramByGuid(diagramGUID);

            int left, right, top, bottom, pocet = 0;

            Wrapper.Diagram diagramWrapper = new Wrapper.Diagram(model, diagram);
            Wrapper.ElementWrapper elWrapper = new Wrapper.ElementWrapper(model, element);
            EA.DiagramObject diagramObject = diagramWrapper.getdiagramObjectForElement(elWrapper);

            string[] coordinate;
            string str;
            string[] parts = coordinates.Split(';');

            str = parts[0];
            coordinate = str.Split('=');
            diagramObject.left = Convert.ToInt32(coordinate[1]);
            left = Convert.ToInt32(coordinate[1]);

            str = parts[1];
            coordinate = str.Split('=');
            diagramObject.right = Convert.ToInt32(coordinate[1]);
            right = Convert.ToInt32(coordinate[1]);

            str = parts[2];
            coordinate = str.Split('=');
            diagramObject.top = Convert.ToInt32(coordinate[1]);
            top = Convert.ToInt32(coordinate[1]);

            str = parts[3];
            coordinate = str.Split('=');
            diagramObject.bottom = Convert.ToInt32(coordinate[1]);
            bottom = Convert.ToInt32(coordinate[1]);

            for (short i = 0; i < diagram.DiagramObjects.Count; i++)
            {
                EA.DiagramObject diagramObj = (EA.DiagramObject)diagram.DiagramObjects.GetAt(i);
                EA.Element el = (EA.Element)Repository.GetElementByID(diagramObj.ElementID);
                if (diagramObj.left >= left && diagramObj.right <= right && diagramObj.top <= top && diagramObj.bottom >= bottom)
                {
                    if (diagramObj.ElementID != diagramObject.ElementID)
                    {
                        pocet++;
                    }
                }
            }

            diagramObject.Sequence = 1 + pocet;
            diagramObject.Update();

            for (short i = 0; i < diagram.DiagramObjects.Count; i++)
            {
                EA.DiagramObject diagramObj = (EA.DiagramObject)diagram.DiagramObjects.GetAt(i);
                EA.Element el = (EA.Element)Repository.GetElementByID(diagramObj.ElementID);
                if (diagramObj.left <= left && diagramObj.right >= right && diagramObj.top >= top && diagramObj.bottom <= bottom)
                {
                    if (diagramObj.ElementID != diagramObject.ElementID)
                    {
                        diagramObj.Sequence += 1;
                        diagramObj.Update();
                    }
                }
            }

            int parentID = diagram.ParentID;
            EA.Package package = (EA.Package)Repository.GetPackageByID(diagram.PackageID);
            if (parentID == 0)
            {
                BPAddIn.synchronizationWindow.addToList("Change of coordinates of element '" + element.Name + "' in diagram '" +
                    diagram.Name + "' (Location of diagram: package '" + package.Name + "')");
            }
            else {
                EA.Element parent = (EA.Element)Repository.GetElementByID(parentID);
                BPAddIn.synchronizationWindow.addToList("Change of coordinates of element '" + element.Name + "' in diagram '" +
                    diagram.Name + "' (Location of diagram: element '" + parent.Name + "' in package '" + package.Name + "')");
            }

            diagram.DiagramObjects.Refresh();
        }

        public void handleContextItemChange(EA.Repository repository, string GUID, ObjectType ot)
        {
            try
            {
                switch (ot)
                {
                    case ObjectType.otElement:
                        this.currentItem = repository.GetElementByGuid(GUID);

                        if (currentItem.Type == "Class")
                        {
                            currentAttributes = new Dictionary<string, EA.Attribute>();
                            foreach (EA.Attribute attr in currentItem.Attributes)
                            {
                                currentAttributes.Add(attr.AttributeGUID, attr);
                            }
                        }

                        if (currentItem.Type == "UseCase")
                        {
                            // CONSTRAINTS
                            currentConstraintsList = new List<ConstraintWrapper>();
                            foreach (EA.Constraint constraint in currentItem.Constraints)
                            {
                                currentConstraintsList.Add(new ConstraintWrapper(constraint));
                            }

                            // SCENARIOS
                            currentScenarioList = new List<ScenarioWrapper>();
                            currentScenarioStepList = new Dictionary<string, List<EA.ScenarioStep>>();
                            foreach (EA.Scenario scenario in currentItem.Scenarios)
                            {
                                currentScenarioList.Add(new ScenarioWrapper(scenario));
                                if (!currentScenarioStepList.ContainsKey(scenario.ScenarioGUID))
                                {
                                    currentScenarioStepList.Add(scenario.ScenarioGUID, new List<ScenarioStep>());
                                }

                                foreach (ScenarioStep step in scenario.Steps)
                                {
                                    currentScenarioStepList[scenario.ScenarioGUID].Add(step);
                                }
                            }
                        }

                        this.currentConnector = null;
                        this.currentDiagram = null;
                        changed = false;
                        currentAuthor = repository.GetElementByGuid(GUID).Author;
                        break;
                    case ObjectType.otPackage:
                        this.currentItem = repository.GetElementByGuid(GUID);
                        this.currentConnector = null;
                        this.currentDiagram = null;
                        changed = false;
                        currentAuthor = repository.GetElementByGuid(GUID).Author;
                        break;
                    case ObjectType.otConnector:
                        this.currentConnector = repository.GetConnectorByGuid(GUID);
                        this.currentItem = null;
                        this.currentDiagram = null;
                        changed = false;
                        break;
                    case ObjectType.otDiagram:
                        this.currentDiagram = (EA.Diagram)repository.GetDiagramByGuid(GUID);
                        this.currentConnector = null;
                        this.currentItem = null;
                        changed = false;
                        currentAuthor = ((EA.Diagram)repository.GetDiagramByGuid(GUID)).Author;
                        currentParent = currentDiagram.ParentID.ToString();

                        currentExtensionPoints = new Dictionary<string, string>();
                        currentDiagramObjectPositions = new Dictionary<int, string>();
                        foreach (EA.DiagramObject diagramObject in currentDiagram.DiagramObjects)
                        {
                            try
                            {
                                EA.Collection col = repository.GetElementSet("" + diagramObject.ElementID, 1);
                                EA.Element element = (EA.Element)col.GetAt(0);

                                if (element.Type == "UseCase")
                                {
                                    currentExtensionPoints.Add(element.ElementGUID, element.ExtensionPoints);
                                }
                            }
                            catch (Exception ex)
                            {
                            }

                            string coordinates = "";
                            coordinates += "l=" + diagramObject.left + ";";
                            coordinates += "r=" + diagramObject.right + ";";
                            coordinates += "t=" + diagramObject.top + ";";
                            coordinates += "b=" + diagramObject.bottom + ";";
                            currentDiagramObjectPositions.Add(diagramObject.ElementID, coordinates);

                        }
                        break;
                    default:
                        return;
//.........这里部分代码省略.........

//.........这里部分代码省略.........
                    {
                        if (!active.ContainsKey(GUID) || active[GUID].Find(x => x.rule == registeredRule) == null)
                        {
                            RuleEntry ruleEntry = createRuleEntry(model, rslt, connector, registeredRule);

                            if (active.ContainsKey(GUID))
                            {
                                active[GUID].Add(ruleEntry);
                            }
                            else
                            {
                                List<RuleEntry> ruleEntryList = new List<RuleEntry>();
                                ruleEntryList.Add(ruleEntry);
                                active.Add(GUID, ruleEntryList);
                            }

                            showErrorWindow(Repository);
                            addToDefectsList(rslt, ruleEntry);
                        }
                        else
                        {
                            foreach (RuleEntry ruleEntry in active[GUID])
                            {
                                if (ruleEntry.rule == registeredRule)
                                {
                                    addToDefectsList(rslt, ruleEntry);
                                }
                            }
                        }
                    }
                    else
                    {
                        if (active.ContainsKey(GUID))
                        {
                            RuleEntry ruleEntry = active[GUID].Find(x => x.rule == registeredRule);

                            if (ruleEntry != null)
                            {
                                BPAddIn.BPAddIn.defectsWindow.removeFromList(ruleEntry.listBoxObject);
                                BPAddIn.BPAddIn.defectsWindow.removeFromHiddenList(ruleEntry.listBoxObject);
                                active.Remove(GUID);
                            }
                        }
                    }
                }
            }
            else if (ot == EA.ObjectType.otDiagram)
            {
                object diagram = Repository.GetDiagramByGuid(GUID);
                foreach (Rule registeredRule in eventWatchers[((EA.Diagram)diagram).Type])
                {
                    string rslt = registeredRule.activate(diagram, model);
                    if (rslt != "")
                    {
                        if (!active.ContainsKey(GUID) || active[GUID].Find(x => x.rule == registeredRule) == null)
                        {
                            RuleEntry ruleEntry = createRuleEntry(model, rslt, diagram, registeredRule);

                            if (active.ContainsKey(GUID))
                            {
                                active[GUID].Add(ruleEntry);
                            }
                            else
                            {
                                List<RuleEntry> ruleEntryList = new List<RuleEntry>();
                                ruleEntryList.Add(ruleEntry);
                                active.Add(GUID, ruleEntryList);
                            }

                            showErrorWindow(Repository);
                            addToDefectsList(rslt, ruleEntry);
                        }
                        else
                        {
                            foreach (RuleEntry ruleEntry in active[GUID])
                            {
                                if (ruleEntry.rule == registeredRule)
                                {
                                    addToDefectsList(rslt, ruleEntry);
                                }
                            }
                        }
                    }
                    else
                    {
                        if (active.ContainsKey(GUID))
                        {
                            RuleEntry ruleEntry = active[GUID].Find(x => x.rule == registeredRule);

                            if (ruleEntry != null)
                            {
                                BPAddIn.BPAddIn.defectsWindow.removeFromList(ruleEntry.listBoxObject);
                                BPAddIn.BPAddIn.defectsWindow.removeFromHiddenList(ruleEntry.listBoxObject);
                                active.Remove(GUID);
                            }
                        }
                    }
                }
            }
        }

        /// <summary>
        /// method adds a new diagram object into diagram
        /// </summary>
        /// <param name="Repository">EA repository</param>
        /// <param name="elementGUID">GUID of element</param>
        /// <param name="diagramGUID">GUID of diagram</param>
        /// <param name="coordinates">coordinates of new diagram object</param>
        public void addDiagramObject(EA.Repository Repository, string elementGUID, string diagramGUID, string coordinates)
        {
            int left, right, top, bottom;

            string[] coordinate;
            string str;
            string[] parts = coordinates.Split(';');

            str = parts[0];
            coordinate = str.Split('=');
            left = Convert.ToInt32(coordinate[1]);

            str = parts[1];
            coordinate = str.Split('=');
            right = Convert.ToInt32(coordinate[1]);

            str = parts[2];
            coordinate = str.Split('=');
            top = Convert.ToInt32(coordinate[1]);

            str = parts[3];
            coordinate = str.Split('=');
            bottom = Convert.ToInt32(coordinate[1]);

            EA.Diagram diagram = (EA.Diagram)Repository.GetDiagramByGuid(diagramGUID);

            for (short i = 0; i < diagram.DiagramObjects.Count; i++)
            {
                EA.DiagramObject diagramObj = (EA.DiagramObject)diagram.DiagramObjects.GetAt(i);
                EA.Element el = (EA.Element)Repository.GetElementByID(diagramObj.ElementID);
                if (diagramObj.left <= left && diagramObj.right >= right && diagramObj.top >= top && diagramObj.bottom <= bottom)
                {
                    diagramObj.Sequence += 1;
                    diagramObj.Update();
                }
            }
            diagram.DiagramObjects.Refresh();

            EA.Element element = (EA.Element)Repository.GetElementByGuid(elementGUID);
            EA.DiagramObject displayElement = (EA.DiagramObject)diagram.DiagramObjects.AddNew(coordinates, "");

            displayElement.ElementID = element.ElementID;
            displayElement.Sequence = 1;
            displayElement.Update();
            diagram.DiagramObjects.Refresh();

            EA.Package parentPackage = (EA.Package)Repository.GetPackageByID(diagram.PackageID);
            if (diagram.ParentID == 0)
            {
                BPAddIn.synchronizationWindow.addToList("Addition of element '" + element.Name + "' to diagram '"
                    + diagram.Name + "' (Location of diagram: package '" + parentPackage.Name + "')");
            }
            else
            {
                EA.Element parentElement = (EA.Element)Repository.GetElementByID(diagram.ParentID);
                BPAddIn.synchronizationWindow.addToList("Addition of element '" + element.Name + "' to diagram '"
                   + diagram.Name + "' (Location of diagram: element '" + parentElement.Name
                   + "' in package '" + parentPackage.Name + "')");
            }
        }

        /// <summary>
        /// method deletes diagram object from diagram
        /// </summary>
        /// <param name="Repository"></param>
        /// <param name="elementGUID">GUID of element which diagram object that should be deleted belongs to</param>
        /// <param name="diagramGUID">GUID of diagram owning diagram object that should be deleted</param>
        public void deleteDiagramObject(EA.Repository Repository, string elementGUID, string diagramGUID)
        {
            EA.Diagram diagram = (EA.Diagram)Repository.GetDiagramByGuid(diagramGUID);
            EA.Element element = (EA.Element)Repository.GetElementByGuid(elementGUID);

            for (short i = 0; i < diagram.DiagramObjects.Count; i++)
            {
                EA.DiagramObject diagramObject = (EA.DiagramObject)diagram.DiagramObjects.GetAt(i);
                if (diagramObject.ElementID == element.ElementID)
                {
                    diagram.DiagramObjects.DeleteAt(i, false);
                    break;
                }
            }
            diagram.DiagramObjects.Refresh();

            BPAddIn.synchronizationWindow.addToList("Deletion of element '" + element.Name + "' from diagram '" + diagram.Name +
                "' (Location of diagram: " + itemTypes.getLocationOfItem(Repository, diagram.PackageID, diagram.ParentID));
        }

        /// <summary>
        /// method deletes diagram
        /// </summary>
        /// <param name="Repository">EA repository</param>
        /// <param name="diagramGUID">GUID of diagram that should be deleted</param>
        /// <param name="elementType">type of diagram that should be deleted</param>
        public void deleteDiagram(EA.Repository Repository, string diagramGUID, int elementType)
        {
            EA.Diagram diagramToDelete = (EA.Diagram)Repository.GetDiagramByGuid(diagramGUID);
            string name = diagramToDelete.Name;
            int packageID = diagramToDelete.PackageID;
            int parentID = diagramToDelete.ParentID;

            EA.Collection diagrams;
            if (diagramToDelete.ParentID == 0)
            {
                diagrams = (EA.Collection)Repository.GetPackageByID(diagramToDelete.PackageID).Diagrams;
            }
            else
            {
                diagrams = (EA.Collection)Repository.GetElementByID(diagramToDelete.ParentID).Diagrams;
            }

            for (short i = 0; i < diagrams.Count; i++)
            {
                EA.Diagram actualDiagram = (EA.Diagram)diagrams.GetAt(i);
                if (actualDiagram.DiagramGUID == diagramGUID)
                {
                    diagrams.DeleteAt(i, false);
                    break;
                }
            }
            diagrams.Refresh();

            BPAddIn.synchronizationWindow.addToList("Deletion of " + itemTypes.getElementTypeInEnglish(elementType) + " '" +
                name + "' (Previous location of diagram: " +
                itemTypes.getLocationOfItem(Repository, packageID, parentID));
        }

        /// <summary>
        /// method changes stereotype of diagram
        /// </summary>
        /// <param name="Repository">EA repository</param>
        /// <param name="diagramGUID">GUID of changed diagram</param>
        /// <param name="stereotype">new stereotype of changed diagram</param>
        /// <param name="oldStereotype">previous stereotype of changed diagram</param>
        /// <param name="elementType">type of changed diagram</param>
        public void changeDiagramStereotype(EA.Repository Repository, string diagramGUID, string stereotype, string oldStereotype, int elementType)
        {
            EA.Diagram diagram = (EA.Diagram)Repository.GetDiagramByGuid(diagramGUID);
            diagram.Stereotype = stereotype;
            diagram.Update();

            BPAddIn.synchronizationWindow.addToList("Change of stereotype of " + itemTypes.getElementTypeInEnglish(elementType) + " '" + diagram.Name
                + "' - previous stereotype: '" + oldStereotype + "', current stereotype: '" + stereotype +
                 "' (Location of diagram: " + itemTypes.getLocationOfItem(Repository, diagram.PackageID, diagram.ParentID));
        }

        /// <summary>
        /// method changes notes of diagram
        /// </summary>
        /// <param name="Repository">EA repository</param>
        /// <param name="diagramGUID">GUID of changed diagram</param>
        /// <param name="notes">new notes of changed diagram</param>
        /// <param name="elementType">type of changed diagram</param>
        public void changeDiagramNotes(EA.Repository Repository, string diagramGUID, string notes, int elementType)
        {
            EA.Diagram diagram = (EA.Diagram)Repository.GetDiagramByGuid(diagramGUID);
            diagram.Notes = notes;
            diagram.Update();

            BPAddIn.synchronizationWindow.addToList("Change of notes of " + itemTypes.getElementTypeInEnglish(elementType) + " '" + diagram.Name +
                 "' (Location of diagram: " + itemTypes.getLocationOfItem(Repository, diagram.PackageID, diagram.ParentID));
        }

        /// <summary>
        /// method changes author of diagram
        /// </summary>
        /// <param name="Repository">EA repository</param>
        /// <param name="diagramGUID">GUID of changed diagram</param>
        /// <param name="author">new author of changed diagram</param>
        /// <param name="oldAuthor">previous author of changed diagram</param>
        /// <param name="elementType">type of changed diagram</param>
        public void changeDiagramAuthor(EA.Repository Repository, string diagramGUID, string author, string oldAuthor, int elementType)
        {
            EA.Diagram diagram = (EA.Diagram)Repository.GetDiagramByGuid(diagramGUID);
            diagram.Author = author;
            diagram.Update();

            BPAddIn.synchronizationWindow.addToList("Change of author " + itemTypes.getElementTypeInEnglish(elementType) + " '" +
              diagram.Name + "' - previous author: '" + oldAuthor + "', current autor: '" + author +
              "' (Location of diagram: " + itemTypes.getLocationOfItem(Repository, diagram.PackageID, diagram.ParentID));
        }