public static void addTaggedValue(string name, string value, EA.Attribute attr)
 {
     EA.AttributeTag at = (EA.AttributeTag)attr.TaggedValues.AddNew(name, "string");
     at.Value = value;
     at.Update();
     attr.TaggedValues.Refresh();
 }

 /// <summary>
 /// method handles item creations during synchronization
 /// </summary>
 /// <param name="itemCreation">instance of item creation carrying information about item creation</param>
 /// <param name="repository">EA repository</param>
 /// <returns>GUID of new item</returns>
 public string handleSynchronizationAdditions(ItemCreation itemCreation, EA.Repository repository)
 {
     string GUID = "";
     if (itemCreation.elementType == 3)
     {
         GUID = synchronizationAdditions.addPackage(repository, itemCreation.packageGUID, itemCreation.name, itemCreation.author);
     }
     else if (itemCreation.elementType >= 50 && itemCreation.elementType < 70)
     {
         GUID = synchronizationAdditions.addDiagram(repository, itemCreation.parentGUID, itemCreation.packageGUID,
             itemCreation.elementType, itemCreation.name, itemCreation.author);
     }
     else if (itemCreation.elementType < 50)
     {
         GUID = synchronizationAdditions.addElement(repository, itemCreation.parentGUID, itemCreation.packageGUID,
             itemCreation.coordinates, itemCreation.elementType, itemCreation.name, itemCreation.author);
     }
     else if (itemCreation.elementType >= 70 && itemCreation.elementType <= 79)
     {
         GUID = synchronizationAdditions.addConnector(repository, itemCreation.srcGUID, itemCreation.targetGUID, itemCreation.name, itemCreation.elementType);
     }
     else if (itemCreation.elementType == 90)
     {
         GUID = synchronizationAdditions.addAttribute(repository, itemCreation.parentGUID, itemCreation.name, itemCreation.coordinates);
     }
     else if (itemCreation.elementType == 700)
     {
         synchronizationAdditions.addDiagramObject(repository, itemCreation.itemGUID, itemCreation.diagramGUID, itemCreation.coordinates);
         GUID = "";
     }
     return GUID;
 }

        public void LoadFromRepository(EA.Repository repository)
        {
            element = EAHelper.GetCurrentElement(repository);

            if (element != null)
            {
                field = element.TaggedValuesEx.GetByName("Markdown");

                if(field == null)
                {
                    field = element.TaggedValuesEx.AddNew("Markdown", "TaggedValue");
                    field.Value = "<memo>";
                    field.Update();
                }

                style = element.TaggedValuesEx.GetByName("MarkdownStyle");
                if(style == null)
                {
                    style = element.TaggedValuesEx.AddNew("MarkdownStyle", "TaggedValue");
                    style.Value = ((MarkdownStyle)this.toolstripStyleBox.SelectedItem).CSSLink;
                    style.Update();
                }

                skin = element.TaggedValuesEx.GetByName("PrettifySkin");
                if (skin == null)
                {
                    skin = element.TaggedValuesEx.AddNew("PrettifySkin", "TaggedValue");
                    skin.Value = this.toolStripSkinBox.SelectedItem.ToString();
                    skin.Update();
                }
            }

            this.markdownTextBox.Text = field.Notes;
            //UpdateWebBrowser();
        }

 public override void EA_FileOpen(EA.Repository Repository)
 {
     // initialize the model
     this.model = new TSF_EA.Model(Repository);
     // indicate that we are now fully loaded
     this.fullyLoaded = true;
 }

 /// <summary>
 /// Get element from Context element. Possible inputs are: Attribute, Operation, Element, Package
 /// </summary>
 /// <param name="rep"></param>
 /// <returns></returns>
 public static EA.Element GetElementFromContextObject(EA.Repository rep)  {
     EA.Element el = null;
     EA.ObjectType objectType = rep.GetContextItemType();
     switch (objectType)
     {
         case ObjectType.otAttribute:
             var a = (EA.Attribute)rep.GetContextObject();
             el = rep.GetElementByID(a.ParentID);
             break;
         case ObjectType.otMethod:
             var m = (Method)rep.GetContextObject();
             el = rep.GetElementByID(m.ParentID);
             break;
         case ObjectType.otElement:
             el = (EA.Element)rep.GetContextObject();
             break;
         case ObjectType.otPackage:
             EA.Package pkg  = rep.GetContextObject();
             el = rep.GetElementByGuid(pkg.PackageGUID);
             break;
         case ObjectType.otNone:
             EA.Diagram dia = rep.GetCurrentDiagram();
             if (dia?.SelectedObjects.Count == 1)
             {
                 var objSelected = (EA.DiagramObject)dia.SelectedObjects.GetAt(0);
                 el = rep.GetElementByID(objSelected.ElementID);
             }
             break;
         default:
             MessageBox.Show(@"No Element, Attribute, Operation, Package selected");
             break;
      }
     return el;
 }

        public void EA_MenuClick(EA.Repository Repository, string Location, string MenuName, string ItemName)
        {
            EAQueryServiceForm eaq;
            //DataElementCreationForm der;
            switch (ItemName)
            {
                case ROOT_MENU:
                //case "&Open Query Service Panel":

                    eaq = new EAQueryServiceForm();
                    eaq.eaQueryServiceControl.m_Repository = Repository;
                    eaq.eaQueryServiceControl.m_IncludeElements = false;
                    eaq.Show();
                    break;
                    /*
                case "&Create CDE":
                    der = new DataElementCreationForm();
                    der.m_Repository = Repository;
                    der.Show();
                    break;
                    */
                /*
                case "&View Selected Element Details":
                    ShowElementDetails(Repository);
                    break;
                 */
            }
        }

        /// <summary>
        /// method adds a new connector between source and target element
        /// </summary>
        /// <param name="Repository">EA repository</param>
        /// <param name="srcGUID">GUID of source element</param>
        /// <param name="targetGUID">GUID of target element</param>
        /// <param name="name">name of new connector</param>
        /// <param name="elementType">type of new connector</param>
        /// <returns>GUID of new connector</returns>
        public string addConnector(EA.Repository Repository, string srcGUID, string targetGUID, string name, int elementType)
        {
            EA.Element source = (EA.Element)Repository.GetElementByGuid(srcGUID);
            EA.Element target = (EA.Element)Repository.GetElementByGuid(targetGUID);

            EA.Connector newConnector = (EA.Connector)source.Connectors.AddNew(name, getConnectorType(elementType));

            if (elementType == 73)
            {
                newConnector.Subtype = "Includes";
                newConnector.Stereotype = "include";
            }
            else if (elementType == 74)
            {
                newConnector.Subtype = "Extends";
                newConnector.Stereotype = "extend";
            }

            newConnector.SupplierID = target.ElementID;
            newConnector.Update();
            source.Connectors.Refresh();

            BPAddIn.synchronizationWindow.addToList("Addition of " + itemTypes.getElementTypeInEnglish(elementType) + " '" + name +
                   "' between element '" + source.Name + "' and element '" + target.Name + "'");

            return newConnector.ConnectorGUID;
        }

 /// <summary>
 /// Called once Menu has been opened to see what menu items should active.
 /// </summary>
 /// <param name="Repository">the repository</param>
 /// <param name="Location">the location of the menu</param>
 /// <param name="MenuName">the name of the menu</param>
 /// <param name="ItemName">the name of the menu item</param>
 /// <param name="IsEnabled">boolean indicating whethe the menu item is enabled</param>
 /// <param name="IsChecked">boolean indicating whether the menu is checked</param>
 public override void EA_GetMenuState(EA.Repository Repository, string Location, string MenuName, string ItemName, ref bool IsEnabled, ref bool IsChecked)
 {
     if (IsProjectOpen(Repository))
     {
         switch (ItemName)
         {
             // define the state of the hello menu option
             case menuHello:
                 IsEnabled = shouldWeSayHello;
                 break;
             // define the state of the goodbye menu option
             case menuGoodbye:
                 IsEnabled = !shouldWeSayHello;
                 break;
             // there shouldn't be any other, but just in case disable it.
             default:
                 IsEnabled = false;
                 break;
         }
     }
     else
     {
         // If no open project, disable all menu options
         IsEnabled = false;
     }
 }

 public XisListItem(EA.Repository repository, EA.Diagram diagram,
     XisList parent, string name, string onTap = null, string onLongTap = null)
     : base(repository, parent)
 {
     Element = XISMobileHelper.CreateXisListItem(parent.Element, name, onTap, onLongTap);
     parent.Items.Add(this);
 }

 public XisMenuGroup(EA.Repository repository, EA.Diagram diagram, XisMenu parent, string name)
     : base(repository, parent)
 {
     Element = XISMobileHelper.CreateXisMenuGroup(parent.Element, name);
     Items = new List<XisMenuItem>();
     parent.Groups.Add(this);
 }

 public XisList(EA.Repository repository, EA.Diagram diagram,
     XisInteractionSpace parent, string name, string searchBy = null, string orderBy = null)
     : base(repository, parent)
 {
     Element = XISMobileHelper.CreateXisList(parent.Element, name, searchBy, orderBy);
     Items = new List<XisListItem>();
 }

        //public static bool updateActionPin(EA.Repository rep, EA.Element el) {
        //    // get classifier (operation)
        //    EA.Method m = Util.getOperationFromCallAction(rep, el);

        //    // update action pins
        //    if (m != null)
        //    {
        //        foreach (EA.Parameter par in m.Parameters)
        //        {
        //            updateActionPinParameter(rep, m, el, par);
        //        }
        //    }
        //    return true;
        //}

        public static bool UpdateActionPinForElement(EA.Repository rep, EA.Element el1)
        {
            if (el1.Type == "Action")
            {
                UpdateActionPinParameter(rep, el1);
                return true;
            }
            if (el1.Type == "Class" | el1.Type == "Interface")
            {
                return true;
            }
            foreach (EA.Element el in el1.Elements)
            {   // update parameter
                if (el.Type == "Action")
                {
                    UpdateActionPinParameter(rep, el);

                }
                if (el.Type == "Activity")
                {
                    UpdateActionPinForElement(rep, el);
                }
            }

            return true;
        }

        public FindAndReplaceItem( EA.Repository rep, string GUID)
        {
            _GUID = GUID;
            _countChanges = 0;
            _isUpdated = false;

        }

 public override void load(EA.Repository rep)
 {
     _Name = _dia.Name;
     _Description = _dia.Notes;
     _Stereotype = _dia.StereotypeEx;
  
 }

 public ReportException(String message, int code, EA.Repository r, byte b)
 {
     this.message = message;
     this.code = code;
     this.r = r;
     this.p = b;
 }

 public XisList(EA.Repository repository, EA.Diagram diagram,
     XisWidget parent, string name, string searchBy = null, string orderBy = null)
     : base(repository, parent)
 {
     Element = XisWebHelper.CreateXisList(parent.Element, name, searchBy, orderBy);
     Items = new List<XisListItem>();
 }

 public override void EA_MenuClick(EA.Repository Repository, string Location, string MenuName, string ItemName)
 {
     switch (ItemName)
     {
         case NEWLINE_MENU_ITEM:
             NotesCleaner cleaner = new NotesCleaner(Repository);
             cleaner.CleanUpNotesAndSave();
             break;
         case TRACE_MENU_ITEM:
             TraceabilityRunner runner = new TraceabilityRunner(Repository);
             runner.RunReportOnSelectedPBItem();
             break;
         case MARKDOWN_EDITOR:
             mdownControl = (MarkdownNotesControl)Repository.AddTab("Markdown Editor", "EAPowerTools.MarkdownNotesControl");
             mdownControl.LoadFromRepository(Repository);
             break;
         case MARKDOWN_DOCKED:
             mdownDocked = (MarkdownDockedViewer)Repository.AddWindow("Markdown Notes", "EAPowerTools.MarkdownDockedViewer");
             mdownDocked.SetRepo(Repository);
             break;
         case POWER_EDITOR:
             control = (PowerEditorControl) Repository.AddTab("Power Editor", "EAPowerTools.PowerEditorControl");
             control.LoadNotes(Repository);
             break;
     }
 }

 /// <summary>
 /// Initialize the EaItem
 /// </summary>
 /// <param name="guid"></param>
 /// <param name="sqlObjType"></param>
 /// <param name="objType"></param>
 /// <param name="eaObject"></param>
 private void Init(string guid, string sqlObjType, EA.ObjectType objType, object eaObject)
 {
     Guid = guid;
     SqlObjectType = sqlObjType;
     EaObjectType = objType;
     EaObject = eaObject;
 }

        string _properties = "";    // the properties
        public Param(EA.Repository rep, EA.Element parTrgt) {
            _rep = rep;
            _parTrgt = parTrgt;

            // check if t_xref element is already present
            string query = @"SELECT XrefID As XREF_ID, description As DESCR
                            FROM  t_object  o inner JOIN t_xref x on (o.ea_guid = x.client)
                            where x.Name = 'CustomProperties' AND
                                  x.Type = 'element property' AND
                                  o.object_ID = " + _parTrgt.ElementID;
                        
                            
            string str = _rep.SQLQuery(query);
            var xmlDoc = new XmlDocument();
            xmlDoc.LoadXml(str);

            // get existing t_xref and remember GUID/XrefID
            XmlNode xrefGuid = xmlDoc.SelectSingleNode("//XREF_ID");
            if (xrefGuid != null)
            {
                _xrefid = xrefGuid.InnerText;// GUID of xref

                // get description
                XmlNode xrefDesc = xmlDoc.SelectSingleNode("//DESCR");
                _properties = null;
                if (xrefDesc != null) _properties = xrefDesc.InnerText;
            }
        }

 public Synchronization(EA.Repository repository)
 {
     this.synchronizationMovements = new SynchronizationMovements(repository);
     this.synchronizationDeletions = new SynchronizationDeletions(repository);
     this.synchronizationAdditions = new SynchronizationAdditions(repository);
     this.synchronizationChanges = new SynchronizationChanges(repository);
 }