/// <summary>
        /// btnFind_Click
        /// Find all matching items in recursive elements
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btnFind_Click(object sender, EventArgs e)
        {
            if (txtFindString.Text.Length < 3)
            {
                DialogResult result = MessageBox.Show("Yes=Continue",
                                            "Short find string (<3 characters)", MessageBoxButtons.OKCancel);
                if (result == DialogResult.Cancel) return;
            }
            EA.Package pkg = Repository.GetTreeSelectedPackage();
            _fr = new FindAndReplace(Repository, pkg,
                txtFindString.Text,
                txtReplaceString.Text,
                chkCaseSensetive.Checked, chkRegularExpression.Checked, chkIgnoreWhiteSpaces.Checked,
                chkName.Checked, chkDescription.Checked, chkStereotype.Checked, chkTaggedValue.Checked,
                txtTaggedValue.Text,
                chkPackage.Checked, chkElement.Checked, chkDiagram.Checked,
                chkAttribute.Checked, chkOperation.Checked);

            _fr.FindInPackageRecursive();
            _fr.LocateCurrentElement();
            if (_fr.Index >= 0)
            {
                txtStatus.Text = _fr.ItemShortDescription();
                activateFindChangeParameters(false);
            }

        }
        /// <summary>
        /// btnFind_Click
        /// Find all matching items in recursive elements
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btnFind_Click(object sender, EventArgs e)
        {
            if (txtFindString.Text.Length < 3)
            {
                DialogResult result = MessageBox.Show("Yes=Continue",
                                                      "Short find string (<3 characters)", MessageBoxButtons.OKCancel);
                if (result == DialogResult.Cancel)
                {
                    return;
                }
            }
            EA.Package pkg = Repository.GetTreeSelectedPackage();
            _fr = new FindAndReplace(Repository, pkg,
                                     txtFindString.Text,
                                     txtReplaceString.Text,
                                     chkCaseSensetive.Checked, chkRegularExpression.Checked, chkIgnoreWhiteSpaces.Checked,
                                     chkName.Checked, chkDescription.Checked, chkStereotype.Checked, chkTaggedValue.Checked,
                                     txtTaggedValue.Text,
                                     chkPackage.Checked, chkElement.Checked, chkDiagram.Checked,
                                     chkAttribute.Checked, chkOperation.Checked);

            _fr.FindInPackageRecursive();
            _fr.LocateCurrentElement();
            if (_fr.Index >= 0)
            {
                txtStatus.Text = _fr.ItemShortDescription();
                activateFindChangeParameters(false);
            }
        }
        public static void doRecursiveEl(EA.Repository rep, EA.Element el, FindAndReplace fr)
        {
            // perform element
            if (fr.isElementSearch)
            {
                fr.FindStringInItem(EA.ObjectType.otElement, el.ElementGUID);
                if (fr.isTagSearch)
                {
                    FindMatchingElementTaggedValue(rep, el, fr);
                }
            }

            if (fr.isAttributeSearch)
            {
                foreach (EA.Attribute a in el.Attributes)
                {
                    fr.FindStringInItem(EA.ObjectType.otAttribute, a.AttributeGUID);
                    if (fr.isTagSearch)
                    {
                        FindMatchingAttributeTaggedValue(rep, a, fr);
                    }
                }
            }
            if (fr.isOperationSearch)
            {
                foreach (EA.Method m in el.Methods)
                {
                    fr.FindStringInItem(EA.ObjectType.otMethod, m.MethodGUID);
                    if (fr.isTagSearch)
                    {
                        FindMatchingMethodTaggedValue(rep, m, fr);
                    }
                }
            }

            // perform diagrams of package
            if (fr.isDiagramSearch)
            {
                foreach (EA.Diagram dia in el.Diagrams)
                {
                    if (dia != null)
                    {
                        fr.FindStringInItem(EA.ObjectType.otDiagram, dia.DiagramGUID);
                    }
                }
            }
            //run all elements
            foreach (EA.Element elTrgt in el.Elements)
            {
                doRecursiveEl(rep, elTrgt, fr);
            }

            return;
        }
        public ShowAndChangeItemGUI(FindAndReplace fr)
        {
            InitializeComponent();
            _fr = fr;
            _fr.LocateCurrentElement();
            ShowItem();
            ShowItem(); // I don't know why, matching at start don't lead to mark gold
            // Element with tags


            txtState.Text = StateCurrentItem() + " found.";
        }
        public ShowAndChangeItemGUI(FindAndReplace fr)
        {
            InitializeComponent();
            _fr = fr;
            _fr.LocateCurrentElement();
            ShowItem();
            ShowItem(); // I don't know why, matching at start don't lead to mark gold 
            // Element with tags
            

            txtState.Text = StateCurrentItem() + " found.";
        }
        public static void doRecursiveEl(EA.Repository rep, EA.Element el, FindAndReplace fr)
        {
            // perform element
            if (fr.isElementSearch)
            {
                fr.FindStringInItem(EA.ObjectType.otElement, el.ElementGUID);
                if (fr.isTagSearch)   FindMatchingElementTaggedValue(rep, el, fr);
            }

            if (fr.isAttributeSearch)
            {
                foreach (EA.Attribute a in el.Attributes)
                {
                    fr.FindStringInItem(EA.ObjectType.otAttribute, a.AttributeGUID);
                    if (fr.isTagSearch) FindMatchingAttributeTaggedValue(rep, a, fr);
                }
            }
            if (fr.isOperationSearch)
            {
                foreach (EA.Method m in el.Methods)
                {
                    fr.FindStringInItem(EA.ObjectType.otMethod, m.MethodGUID);
                    if (fr.isTagSearch) FindMatchingMethodTaggedValue(rep, m, fr);
                }
            }
            
            // perform diagrams of package
            if (fr.isDiagramSearch)
            {
                foreach (EA.Diagram dia in el.Diagrams)
                {
                    if (dia != null) fr.FindStringInItem(EA.ObjectType.otDiagram, dia.DiagramGUID);
                }
            }
            //run all elements
            foreach (EA.Element elTrgt in el.Elements)
            {
                doRecursiveEl(rep, elTrgt, fr);
            }
            
            return;
        }
        public static void doRecursivePkg(EA.Repository rep, EA.Package pkg, FindAndReplace fr)
        {
            // perform package
            if (fr.isPackageSearch)
            {
                fr.FindStringInItem(EA.ObjectType.otPackage, pkg.PackageGUID);
                if (fr.isTagSearch)
                {
                    // tagged values are beneath element with the same Id
                    EA.Element el = rep.GetElementByGuid(pkg.PackageGUID);
                    if (el != null)
                    {
                        FindMatchingPackageTaggedValue(rep, pkg, fr);
                    }
                }
            }

            // perform diagrams of package
            if (fr.isDiagramSearch)
            {
                foreach (EA.Diagram dia in pkg.Diagrams)
                {
                    if (dia != null)
                    {
                        fr.FindStringInItem(EA.ObjectType.otDiagram, dia.DiagramGUID);
                    }
                }
            }
            // run elements of package
            foreach (EA.Element el in pkg.Elements)
            {
                doRecursiveEl(rep, el, fr);
            }

            // run packages of package
            foreach (EA.Package pkgTrgt in pkg.Packages)
            {
                doRecursivePkg(rep, pkgTrgt, fr);
            }
            return;
        }
        public static void doRecursivePkg(EA.Repository rep, EA.Package pkg, FindAndReplace fr)
        {
            // perform package
            if (fr.isPackageSearch)
            {
                fr.FindStringInItem(EA.ObjectType.otPackage, pkg.PackageGUID);
                if (fr.isTagSearch)
                {
                    // tagged values are beneath element with the same Id
                    EA.Element el = rep.GetElementByGuid(pkg.PackageGUID);
                    if (el != null)   FindMatchingPackageTaggedValue(rep, pkg, fr);
                }

            }

            // perform diagrams of package
            if (fr.isDiagramSearch)
            {
                foreach (EA.Diagram dia in pkg.Diagrams)
                {
                    if (dia != null) fr.FindStringInItem(EA.ObjectType.otDiagram, dia.DiagramGUID);
                }
            }
            // run elements of package
            foreach (EA.Element el in pkg.Elements)
            {
                doRecursiveEl(rep, el, fr);
            }
            
            // run packages of package
            foreach (EA.Package pkgTrgt in pkg.Packages)
            {
                doRecursivePkg(rep, pkgTrgt, fr);
            }
            return;
        }
        /// <summary>
        /// Find matching tagged values for element 
        /// </summary>
        /// <param name="rep"></param>
        /// <param name="el"></param>
        /// <param name="fr"></param>
        private static void FindMatchingPackageTaggedValue(EA.Repository rep, EA.Package pkg, FindAndReplace fr)
        {
            EA.Element el = rep.GetElementByGuid(pkg.PackageGUID);
            foreach (EA.TaggedValue tag in el.TaggedValues)
            {
                if ((fr.tagValueNames.Length == 0) || (fr.tagValueNames.Contains(tag.Name)))
                {
                    int count = FindAndReplaceItem.findCountForType(fr.regexPattern, tag.Value);
                    if (count > 0)
                    {
                        FindAndReplaceItem frItem = fr.lastItem();
                        if ((frItem == null) || (frItem.GUID != el.ElementGUID))
                        {
                            frItem = FindAndReplaceItem.Factory(rep, EA.ObjectType.otPackage, el.ElementGUID);
                            fr.l_items.Add(frItem);


                        }
                        var frItemPkg = (FindAndReplaceItemPackage)frItem;
                        frItemPkg.l_itemTag.Add(new FindAndReplaceItemTagPackage(tag));
                        frItemPkg.CountChanges = frItemPkg.CountChanges + count;


                    }
                }

            }
        }
Esempio n. 10
0
        /// <summary>
        /// Find matching tagged values for element
        /// </summary>
        /// <param name="rep"></param>
        /// <param name="method"></param>
        /// <param name="fr"></param>
        private static void FindMatchingMethodTaggedValue(EA.Repository rep, EA.Method method, FindAndReplace fr)
        {
            foreach (EA.MethodTag tag in method.TaggedValues)
            {
                if ((fr.TagValueNames.Length == 0) || (fr.TagValueNames.Contains(tag.Name)))
                {
                    int count = FindAndReplaceItem.FindCountForType(fr.RegexPattern, Utils.TaggedValue.GetTaggedValue(method, tag.Name));
                    if (count > 0)
                    {
                        FindAndReplaceItem frItem = fr.LastItem();
                        if ((frItem == null) || (frItem.Guid != method.MethodGUID))
                        {
                            frItem = FindAndReplaceItem.Factory(rep, EA.ObjectType.otMethod, method.MethodGUID);
                            fr.LItems.Add(frItem);
                        }

                        var frItemMeth = (FindAndReplaceItemMethod)frItem;
                        frItemMeth.LItemTag.Add(new FindAndReplaceItemTagMethod(tag));
                        frItemMeth.CountChanges = frItemMeth.CountChanges + count;
                    }
                }
            }
        }
Esempio n. 11
0
 /// <summary>
 /// Find matching tagged values for element
 /// </summary>
 /// <param name="rep"></param>
 /// <param name="attr"></param>
 /// <param name="fr"></param>
 private static void FindMatchingAttributeTaggedValue(EA.Repository rep, EA.Attribute attr, FindAndReplace fr)
 {
     foreach (EA.AttributeTag tag in attr.TaggedValues)
     {
         if ((fr.TagValueNames.Length == 0) || (fr.TagValueNames.Contains(tag.Name)))
         {
             int count = FindAndReplaceItem.FindCountForType(fr.RegexPattern, Utils.TaggedValue.GetTaggedValue(attr, tag.Name));
             if (count > 0)
             {
                 FindAndReplaceItem frItem = fr.LastItem();
                 if ((frItem == null) || (frItem.Guid != attr.AttributeGUID))
                 {
                     frItem = FindAndReplaceItem.Factory(rep, EA.ObjectType.otAttribute, attr.AttributeGUID);
                     fr.LItems.Add(frItem);
                 }
                 // find tagged value
                 var frItemAttr = (FindAndReplaceItemAttribute)frItem;
                 frItemAttr.LItemTag.Add(new FindAndReplaceItemTagAttribute(tag));
                 frItemAttr.CountChanges = frItemAttr.CountChanges + count;
             }
         }
     }
 }
Esempio n. 12
0
 /// <summary>
 /// Find matching tagged values for element
 /// </summary>
 /// <param name="rep"></param>
 /// <param name="pkg"></param>
 /// <param name="fr"></param>
 private static void FindMatchingPackageTaggedValue(EA.Repository rep, EA.Package pkg, FindAndReplace fr)
 {
     EA.Element el = rep.GetElementByGuid(pkg.PackageGUID);
     foreach (EA.TaggedValue tag in el.TaggedValues)
     {
         if ((fr.TagValueNames.Length == 0) || (fr.TagValueNames.Contains(tag.Name)))
         {
             int count = FindAndReplaceItem.FindCountForType(fr.RegexPattern, Utils.TaggedValue.GetTaggedValue(el, tag.Name));
             if (count > 0)
             {
                 // Create the searchers
                 FindAndReplaceItem frItem = fr.LastItem();
                 if ((frItem == null) || (frItem.Guid != el.ElementGUID))
                 {
                     frItem = FindAndReplaceItem.Factory(rep, EA.ObjectType.otPackage, el.ElementGUID);
                     fr.LItems.Add(frItem);
                 }
                 // Search
                 var frItemPkg = (FindAndReplaceItemPackage)frItem;
                 frItemPkg.LItemTag.Add(new FindAndReplaceItemTagPackage(tag));
                 frItemPkg.CountChanges = frItemPkg.CountChanges + count;
             }
         }
     }
 }
Esempio n. 13
0
 /// <summary>
 /// Find matching tagged values for element
 /// </summary>
 /// <param name="rep"></param>
 /// <param name="el"></param>
 /// <param name="fr"></param>
 private static void FindMatchingElementTaggedValue(EA.Repository rep, EA.Element el, FindAndReplace fr)
 {
     foreach (EA.TaggedValue tag in el.TaggedValues)
     {
         if ((fr.TagValueNames.Length == 0) || (fr.TagValueNames.Contains(tag.Name)))
         {
             int count = FindAndReplaceItem.FindCountForType(fr.RegexPattern, Utils.TaggedValue.GetTaggedValue(el, tag.Name));
             if (count > 0)
             {
                 FindAndReplaceItem frItem = fr.LastItem();
                 if ((frItem == null) || (frItem.Guid != el.ElementGUID))
                 {
                     frItem = FindAndReplaceItem.Factory(rep, EA.ObjectType.otElement, el.ElementGUID);
                     fr.LItems.Add(frItem);
                 }
                 // find tagged value
                 var frItemEl = (FindAndReplaceItemElement)frItem;
                 frItemEl.LItemTag.Add(new FindAndReplaceItemTagElement(tag));
                 frItemEl.CountChanges = frItemEl.CountChanges + count;
             }
         }
     }
 }
        /// <summary>
        /// Find matching tagged values for element 
        /// </summary>
        /// <param name="rep"></param>
        /// <param name="el"></param>
        /// <param name="fr"></param>
        private static void FindMatchingAttributeTaggedValue(EA.Repository rep, EA.Attribute a, FindAndReplace fr)
        {
            foreach (EA.AttributeTag tag in a.TaggedValues)
            {
                if ((fr.tagValueNames.Length == 0) || (fr.tagValueNames.Contains(tag.Name)))
                {
                    int count = FindAndReplaceItem.findCountForType(fr.regexPattern, tag.Value);
                    if (count > 0)
                    {
                        FindAndReplaceItem frItem = fr.lastItem();
                        if ((frItem == null) || (frItem.GUID != a.AttributeGUID))
                        {
                            frItem = FindAndReplaceItem.Factory(rep, EA.ObjectType.otAttribute, a.AttributeGUID);
                            fr.l_items.Add(frItem);


                        }

                        var frItemAttr = (FindAndReplaceItemAttribute)frItem;
                        frItemAttr.l_itemTag.Add(new FindAndReplaceItemTagAttribute(tag));
                        frItemAttr.CountChanges = frItemAttr.CountChanges + count;

                    }
                }

            }
        }
 private void btnCancel_Click(object sender, EventArgs e)
 {
     _fr            = null;
     txtStatus.Text = "";
     activateFindChangeParameters(true);
 }
        /// <summary>
        /// Find matching tagged values for element
        /// </summary>
        /// <param name="rep"></param>
        /// <param name="el"></param>
        /// <param name="fr"></param>
        private static void FindMatchingAttributeTaggedValue(EA.Repository rep, EA.Attribute a, FindAndReplace fr)
        {
            foreach (EA.AttributeTag tag in a.TaggedValues)
            {
                if ((fr.tagValueNames.Length == 0) || (fr.tagValueNames.Contains(tag.Name)))
                {
                    int count = FindAndReplaceItem.findCountForType(fr.regexPattern, tag.Value);
                    if (count > 0)
                    {
                        FindAndReplaceItem frItem = fr.lastItem();
                        if ((frItem == null) || (frItem.GUID != a.AttributeGUID))
                        {
                            frItem = FindAndReplaceItem.Factory(rep, EA.ObjectType.otAttribute, a.AttributeGUID);
                            fr.l_items.Add(frItem);
                        }

                        var frItemAttr = (FindAndReplaceItemAttribute)frItem;
                        frItemAttr.l_itemTag.Add(new FindAndReplaceItemTagAttribute(tag));
                        frItemAttr.CountChanges = frItemAttr.CountChanges + count;
                    }
                }
            }
        }
        /// <summary>
        /// Find matching tagged values for element 
        /// </summary>
        /// <param name="rep"></param>
        /// <param name="el"></param>
        /// <param name="fr"></param>
        private static void FindMatchingMethodTaggedValue(EA.Repository rep, EA.Method m, FindAndReplace fr)
        {
            foreach (EA.MethodTag tag in m.TaggedValues)
            {
                if ((fr.tagValueNames.Length == 0) || (fr.tagValueNames.Contains(tag.Name)))
                {
                    int count = FindAndReplaceItem.findCountForType(fr.regexPattern, tag.Value);
                    if (count > 0)
                    {
                        FindAndReplaceItem frItem = fr.lastItem();
                        if ((frItem == null) || (frItem.GUID != m.MethodGUID))
                        {
                            frItem = FindAndReplaceItem.Factory(rep, EA.ObjectType.otMethod, m.MethodGUID);
                            fr.l_items.Add(frItem);


                        }

                        var frItemMeth = (FindAndReplaceItemMethod)frItem;
                        frItemMeth.l_itemTag.Add(new FindAndReplaceItemTagMethod(tag));
                        frItemMeth.CountChanges = frItemMeth.CountChanges + count;

                    }
                }

            }
        }
 private void btnCancel_Click(object sender, EventArgs e)
 {
     _fr = null;
     txtStatus.Text = "";
     activateFindChangeParameters(true);
 }