public DiagramLinkWrapper(Model model, ConnectorWrapper relation,
                           Diagram diagram){
   this.model = model;
   this.relation = relation;
   this.diagram = diagram;
   this.wrappedDiagramLink = diagram.getDiagramLinkForRelation(relation);
 }

 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;
 }

 public ContextWrapper(EA.Repository repository)
 {
     this.model = new Wrapper.Model(repository);
     this.changeService = new ChangeService();
     this.ruleService = new RuleService();
     this.itemTypes = new ItemTypes(repository);
     changesDispatcherThread = new Thread(new ThreadStart(this.changeService.startActivityDispatcher));
     changesDispatcherThread.Start();
 }

 static EAOutputLogger getOutputLogger(Model model, string outputName)
 {
     var logKey = model.projectGUID+outputName;
     if (!outputLogs.ContainsKey(logKey))
     {
         outputLogs.Add(logKey,new EAOutputLogger(model, outputName));
     }
     return outputLogs[logKey];
 }

 /// <summary>
 /// private constructor
 /// </summary>
 /// <param name="model">the model this output applies to</param>
 /// <param name="outputName"></param>
 private EAOutputLogger(Model model, string outputName)
 {
     this.model = model;
     this.name = outputName;
     //make sure the log exists and is visible and cleared
     this.model.wrappedModel.CreateOutputTab(this.name);
     this.model.wrappedModel.EnsureOutputVisible(this.name);
     this.model.wrappedModel.ClearOutput(this.name);
 }

 public EAImvertorException(UTF_EA.Model model, string exceptionType, string guid, string step, string construct, string message)
 {
     this._model = model;
     this.exceptionType = exceptionType;
     this.guid = guid;
     this.step = step;
     this.construct = construct;
     this.message = message;
 }

 public EnumerationLiteral(Model model, global::EA.Attribute wrappedAttribute)
     : base(model, wrappedAttribute)
 {
     if (!this.wrappedAttribute.StyleEx.Contains("IsLiteral="))
     {
         this.wrappedAttribute.StyleEx = "IsLiteral=1;" + this.wrappedAttribute.StyleEx;
     }else
     {
         this.wrappedAttribute.StyleEx = this.wrappedAttribute.StyleEx.Replace("IsLiteral=0;","IsLiteral=1;");
     }
 }

	public override void EA_FileOpen(EA.Repository Repository)
	{
		// initialize the model
        this.model = new UTF_EA.Model(Repository);
		// clear the control
		if (this.navigatorControl != null)
        {
        	this.navigatorControl.clear();
        }
        this.fullyLoaded = true;
	}

 public TFSConnectorSettingsForm(EATFSConnectorSettings settings, TSF_EA.Model model )
 {
     //
     // The InitializeComponent() call is required for Windows Forms designer support.
     //
     InitializeComponent();
     this.settings = settings;
     this.model = model;
     this.loadData();
     this.enableDisable();
 }

 public EASearchOutput(string name,List<string> fields,List<UML.Extended.UMLModelOutPutItem> output, UTF_EA.Model model)
 {
     this.name = name;
     //add the default fields for EA Searches
     this.fields = new List<string> { "CLASSGUID", "CLASSTYPE" };
     this.fields.AddRange(fields);
     this.output = output;
     if (this.output == null)
     {
         this.output = new List<UML.Extended.UMLModelOutPutItem>();
     }
     this._model = model;
 }

        /// <summary>
        /// EA_MenuClick events are received by an Add-In in response to user selection of a menu option.
        /// The event is raised when the user clicks on a particular menu option. When a user clicks on one of your non-parent menu options, your Add-In receives a MenuClick event, defined as follows:
        /// Sub EA_MenuClick(Repository As EA.Repository, ByVal MenuName As String, ByVal ItemName As String)
        /// Notice that your code can directly access Enterprise Architect data and UI elements using Repository methods.
        /// Also look at EA_GetMenuItems.
        /// </summary>
        /// <param name="Repository">An EA.Repository object representing the currently open Enterprise Architect model.
        /// Poll its members to retrieve model data and user interface status information.</param>
		/// <param name="MenuLocation">String representing the part of the user interface that brought up the menu. 
        /// Can be TreeView, MainMenu or Diagram.</param>
        /// <param name="MenuName">The name of the parent menu for which sub-items must be defined. In the case of the top-level menu it is an empty string.</param>
        /// <param name="ItemName">The name of the option actually clicked, for example, Create a New Invoice.</param>
		public override void EA_MenuClick(EA.Repository Repository, string MenuLocation, string MenuName, string ItemName)
		{
			//initialize model
			this.model = new UTF_EA.Model(Repository);
			//get all users
			List<User> allUsers = this.model.users;
			//get current user
			User currentUser = this.model.currentUser;
			//debug
			//currentUser = new User(this.model,"login1","firstname1","lastname1");
			//get all workingsets
			List<WorkingSet> allWorkingSets = this.model.workingSets;
			//open window
			WorkingSetSharingWindow window	= new WorkingSetSharingWindow(allWorkingSets,allUsers,currentUser);
			window.Show();
		}

 /// <summary>
 /// log a message to the EA output window. If requested the message will also be logged to the logfile
 /// </summary>
 /// <param name="model">the model on which to show the output</param>
 /// <param name="outputName">the name of the output window</param>
 /// <param name="message">the message to show</param>
 /// <param name="elementID">the element ID to associate with the message. Can be used by add-ins when they implement EA_OnOutput...</param>
 /// <param name="logType">the type of logging to the logfile</param>
 public static void log(Model model,string outputName, string message, int elementID = 0,LogTypeEnum logType = LogTypeEnum.none)
 {
     var logger = getOutputLogger(model, outputName);
     logger.logToOutput(message,elementID);
     //log to logfile if needed
     switch (logType)
     {
         case LogTypeEnum.log:
             Logger.log(message);
             break;
         case LogTypeEnum.warning:
             Logger.logWarning(message);
             break;
         case LogTypeEnum.error:
             Logger.logError(message);
             break;
     }
 }

 public EADatabaseTransformer(DatabaseFactory factory, UTF_EA.Model model,NameTranslator nameTranslator)
     : base(nameTranslator)
 {
     this._factory = factory;
     this._model = model;
 }

 internal TaggedValue(Model model)
 {
     this.model = model;
 }

 public DiagramObjectWrapper(Model model, ElementWrapper element,
                             Diagram diagram) 
   : this(model, diagram.getdiagramObjectForElement(element)) 
 {}

	internal OperationTag(Model model, global::EA.MethodTag eaTag):base(model)
    {
      this.wrappedTaggedValue = eaTag;
    }

 public Attribute(Model model, global::EA.Attribute wrappedAttribute) 
   : base(model)
 {
   this.wrappedAttribute = wrappedAttribute;
 }

 public Enumeration(Model model, global::EA.Element elementToWrap)
     : base(model, elementToWrap)
 {
 }

 public RootPackage(Model model,global::EA.Package package)
     : base(model,package)
 {
     this.wrappedPackage = package;
 }

		public ObjectDiagram(Model model, global::EA.Diagram wrappedDiagram ):base(model,wrappedDiagram)
		{
		}