private void LoadTreeView(List listLoad)
{
List list = UMLProject.GetInstance().GetUMLElements <Item, List>();
foreach (Item i in list)
{
TreeNode node = new TreeNode();
IUMLElement model = (IUMLElement)i;
node.Text = model.Name;
node.Tag = i;
if (listLoad != null)
{
foreach (Item iLoad in listLoad)
{
if (i.Guid == iLoad.Guid)
{
node.Checked = true;
//listLoad.Remove(iLoad);
break;
}
}
}
treeViewItems.Nodes.Add(node);
}
treeViewItems.ExpandAll();
}
public static IUMLElement GetCurrent()
{
Assembly assembly = Assembly.GetExecutingAssembly();
foreach (Type type in assembly.GetTypes())
{
if (!type.ContainsGenericParameters && !type.IsAbstract)
{
ConstructorInfo consInfo = type.GetConstructor(Type.EmptyTypes);
if (consInfo != null)
{
object obj1 = Activator.CreateInstance(type);
if (obj1 is IUMLElement)
{
IUMLElement element = (IUMLElement)obj1;
element.LoadCurrent();
if (element.State == RecordState.Loaded)
{
return(element);
}
}
}
}
}
return(null);
}
/// <summary>
/// Gets previus element associated to this element, by association type "dependency"
/// </summary>
/// <param name="element">Element</param>
/// <param name="stereoTypeDependency">Stereotype</param>
/// <returns>Previus element</returns>
public static T GetPrev <T>(IUMLElement element, string stereoTypeDependency)
where T : ActiveRecord <T>, new()
{
T item = new T();
TUPUX.Access.DataAccess dataAccess = new TUPUX.Access.DataAccess();
string key = element.Guid;
StarUML.IUMLModelElement model = dataAccess.FindModel(key);
try
{
if (model is StarUML.IUMLClassifier && model.GetSupplierDependencyCount() > 0)
{
for (int i = 0; i < model.GetSupplierDependencyCount(); i++)
{
StarUML.IUMLDependency depencency = model.GetSupplierDependencyAt(i);
StarUML.IUMLClassifier prevModel = (StarUML.IUMLClassifier)depencency.Client;
if (stereoTypeDependency.Equals(depencency.StereotypeName) &&
item.IsKindOf(prevModel.GetClassName(), prevModel.StereotypeName))
{
item.Load(prevModel);
return(item);
}
}
}
}
catch (Exception ex)
{
log.Error("", ex);
}
return(null);
}
public static FormEdit GetCurrent()
{
IUMLElement element = SelectionManager.GetCurrent();
if (element == null)
{
return(null);
}
return(GetFormEdit(element));
}
private void NewFormEdit(IUMLElement element)
{
element.Owner = (IUMLElement)_selectedNode.Tag;
FormEdit form = FormsFactory.GetFormEdit(element);
form.FormSaved += new EventHandler(form_FormSaved);
form.Show(this.DockPanel);
}
public static FormEdit GetFormEdit(IUMLElement element)
{
element.Load();
FormEdit form = null;
if (dictionary.ContainsKey(element.Guid))
{
form = dictionary[element.Guid] as FormEdit;
}
else
{
#region Create the form
if (element is UMLUseCase)
{
form = new UseCaseEdit(element as UMLUseCase);
}
else if (element is UMLFlow)
{
form = new FlowEdit(element as UMLFlow);
}
else if (element is UMLIteration)
{
form = new IterationEdit(element as UMLIteration);
}
else if (element is UMLPhase)
{
form = new PhaseEdit(element as UMLPhase);
}
else if (element is UMLCollaboration)
{
form = new CollaborationEdit(element as UMLCollaboration);
}
else if (element is UMLFile)
{
form = new FileEdit(element as UMLFile);
}
#endregion
#region Add to the dictionary
if (form != null)
{
if (String.IsNullOrEmpty(element.Guid))
{
dictionary.Add(Guid.NewGuid().ToString(), form);
}
else
{
dictionary.Add(element.Guid, form);
}
}
#endregion
}
return form;
}
public static FormEdit GetFormEdit(IUMLElement element)
{
element.Load();
FormEdit form = null;
if (dictionary.ContainsKey(element.Guid))
{
form = dictionary[element.Guid] as FormEdit;
}
else
{
#region Create the form
if (element is UMLUseCase)
{
form = new UseCaseEdit(element as UMLUseCase);
}
else if (element is UMLFlow)
{
form = new FlowEdit(element as UMLFlow);
}
else if (element is UMLIteration)
{
form = new IterationEdit(element as UMLIteration);
}
else if (element is UMLPhase)
{
form = new PhaseEdit(element as UMLPhase);
}
else if (element is UMLCollaboration)
{
form = new CollaborationEdit(element as UMLCollaboration);
}
else if (element is UMLFile)
{
form = new FileEdit(element as UMLFile);
}
#endregion
#region Add to the dictionary
if (form != null)
{
if (String.IsNullOrEmpty(element.Guid))
{
dictionary.Add(Guid.NewGuid().ToString(), form);
}
else
{
dictionary.Add(element.Guid, form);
}
}
#endregion
}
return(form);
}
private bool FindPackage(IUMLElement package)
{
if (package.Name.Equals(this._packageName) && package is UMLPackage)
{
return(true);
}
else
{
return(false);
}
}
private bool RemoveFiles(IUMLElement element)
{
if (element is UMLFile)
{
(element as UMLFile).Delete();
return(true);
}
else
{
return(false);
}
}
/// <summary>
/// Create the association between two elements
/// </summary>
/// <typeparam name="T">Type for the first element</typeparam>
/// <typeparam name="T2">Type for second element</typeparam>
/// <param name="element1">First element</param>
/// <param name="element2">Second element</param>
/// <param name="ownerElement">Owner of the association</param>
public static void CreateAssociation <T, T2>(T element1, T2 element2, IUMLElement ownerElement)
where T : ActiveRecord <T>, new()
where T2 : ActiveRecord <T2>, new()
{
try
{
StarUML.IUMLNamespace owner = dataAccess.FindModel(ownerElement.Guid) as StarUML.IUMLNamespace;
StarUML.IUMLClassifier elementStarUML1 = dataAccess.FindModel(element1.Guid) as StarUML.IUMLClassifier;
StarUML.IUMLClassifier elementStarUML2 = dataAccess.FindModel(element2.Guid) as StarUML.IUMLClassifier;
dataAccess.Factory.CreateAssociation(owner, elementStarUML1, elementStarUML2);
}
catch (Exception ex)
{
log.Error("CreateAssociation", ex);
}
}
/// <summary>
/// Gets owner for this element
/// </summary>
/// <typeparam name="T">Owner Type</typeparam>
/// <param name="element">Element</param>
/// <returns>owner</returns>
public static T GetOwner <T>(IUMLElement element)
where T : ActiveRecord <T>, new()
{
//string path = element.PathName.Replace(element.Name, "");
//path = path.Substring(0, path.Length - 2);
string path = element.PathName.Substring(0, element.PathName.LastIndexOf(element.Name) - 2);
StarUML.IUMLModelElement elem = dataAccess.FindModelByPathName(path);
T e = new T();
if (e.IsKindOf(elem.GetClassName(), elem.StereotypeName))
{
e.Load(elem);
return(e);
}
return(null);
}
private void LoadTreeView(TreeNodeCollection nodes, IUMLElement root)
{
List <IUMLElement> list = root.GetOwnedElements();
foreach (IUMLElement element in list)
{
TreeNode node;
if (element is UMLUseCase)
{
node = nodes.Add(element.Guid, element.Name, "useCase", "useCase");
}
else if (element is UMLPhase)
{
node = nodes.Add(element.Guid, element.Name, "phase", "phase");
}
else if (element is UMLIteration)
{
node = nodes.Add(element.Guid, element.Name, "iteration", "iteration");
}
else if (element is UMLFile)
{
node = nodes.Add(element.Guid, element.Name, "file", "file");
}
else if ((element is UMLModel) || (element is UMLPackage) || (element is UMLSubsystem))
{
node = nodes.Add(element.Guid, element.Name);
node.ContextMenuStrip = this.contextMenuStrip1;
}
else
{
node = nodes.Add(element.Guid, element.Name);
}
node.Tag = element;
_treeNodes.Add(element.Guid, node);
this.LoadTreeView(node.Nodes, element);
}
}
private void LoadTreeView(TreeNodeCollection nodes, IUMLElement root)
{
List<IUMLElement> list = root.GetOwnedElements();
foreach (IUMLElement element in list)
{
TreeNode node;
if (element is UMLUseCase)
{
node = nodes.Add(element.Guid, element.Name, "useCase", "useCase");
}
else if (element is UMLPhase)
{
node = nodes.Add(element.Guid, element.Name, "phase", "phase");
}
else if (element is UMLIteration)
{
node = nodes.Add(element.Guid, element.Name, "iteration", "iteration");
}
else if (element is UMLFile)
{
node = nodes.Add(element.Guid, element.Name, "file", "file");
}
else if ((element is UMLModel) || (element is UMLPackage) || (element is UMLSubsystem))
{
node = nodes.Add(element.Guid, element.Name);
node.ContextMenuStrip = this.contextMenuStrip1;
}
else
{
node = nodes.Add(element.Guid, element.Name);
}
node.Tag = element;
_treeNodes.Add(element.Guid, node);
this.LoadTreeView(node.Nodes, element);
}
}
/// <summary>
/// Create the dependency between two elements
/// </summary>
/// <typeparam name="T">Type for the first element</typeparam>
/// <typeparam name="T2">Type for second element</typeparam>
/// <param name="client">Client for the dependency</param>
/// <param name="supplier">Supplier for the dependency</param>
/// <param name="stereoTypeName">Stereotype</param>
/// <param name="ownerElement">Owner of the dependency</param>
public static void CreateDependency <T, T2>(T client, T2 supplier, string stereoTypeName, IUMLElement ownerElement)
where T : ActiveRecord <T>, new()
where T2 : ActiveRecord <T2>, new()
{
try
{
StarUML.IUMLNamespace owner = dataAccess.FindModel(ownerElement.Guid) as StarUML.IUMLNamespace;
StarUML.IUMLModelElement elementStarUML1 = dataAccess.FindModel(client.Guid) as StarUML.IUMLModelElement;
StarUML.IUMLModelElement elementStarUML2 = dataAccess.FindModel(supplier.Guid) as StarUML.IUMLModelElement;
StarUML.IUMLDependency dependency = dataAccess.Factory.CreateDependency(owner, elementStarUML1, elementStarUML2);
dependency.SetStereotype(stereoTypeName);
}
catch (Exception ex)
{
log.Error("CreateDependency", ex);
}
}
public static void OpenSolution(object sender, DoWorkEventArgs e)
{
bwAsync = sender as BackgroundWorker;
EnvDTE80.DTE2 dte = null;
Dictionary <string, IUMLElement> listElements = new Dictionary <string, IUMLElement>();
try
{
dte = (EnvDTE80.DTE2)Microsoft.VisualBasic.Interaction.CreateObject("VisualStudio.DTE.8.0", "");
Solution2 soln = (Solution2)dte.Solution;
soln.Open(File);
SolutionBuild2 build = (SolutionBuild2)soln.SolutionBuild;
addMessageBackgroundWorker(0, "Building Solution...");
build.SolutionConfigurations.Item("Debug").Activate();
build.Clean(true);
build.Build(true);
UMLModel model = Helper.GetCurrentElement <UMLModel>();
if (build.LastBuildInfo == 0 && model != null)
{
IUMLElement solutionUML = new UMLPackage();
solutionUML.Name = Path.GetFileName(soln.FileName);
solutionUML.Owner = model;
listElements.Add(solutionUML.Name, solutionUML);
for (int i = 1; i <= soln.Projects.Count; i++)
{
Project project = soln.Projects.Item(i);
if (project.Properties != null)
{
string fullPath = (string)project.Properties.Item("FullPath").Value;
string outputfileName = (string)project.Properties.Item("OutputFileName").Value;
Assembly assembly = Assembly.LoadFile(fullPath + @"Bin\Debug\" + outputfileName);
IUMLElement projectUML = new UMLPackage();
projectUML.Name = project.Name;
listElements.Add(project.Name, projectUML);
projectUML.Owner = solutionUML;
addMessageBackgroundWorker(0, "Processing Types: \n" + project.Name);
foreach (Type type in assembly.GetTypes())
{
if (type.MemberType == MemberTypes.TypeInfo)
{
IUMLElement element = null;
if (type.IsEnum && IncludeEnumeration)
{
element = new UMLEnumeration();
element.Name = type.Name;
((UMLEnumeration)element).Literals = GetLiterals(type);
}
else
{
if (type.IsClass && IncludeClass)
{
element = new UMLClass();
element.Name = type.Name;
((UMLClass)element).Attributes = GetProperties(type);
((UMLClass)element).Attributes.AddRange(GetStaticAndConstants(type));
((UMLClass)element).Methods = GetMethods(type);
if (type.IsGenericType)
{
element.Name = element.Name.Substring(0, element.Name.IndexOf("`"));
element.Name += "<";
foreach (Type t in type.GetGenericArguments())
{
element.Name += t.Name + ",";
}
element.Name = element.Name.TrimEnd(',');
element.Name += ">";
}
}
else if (type.IsInterface && IncludeInterface)
{
element = new UMLInterface();
element.Name = type.Name;
((UMLInterface)element).Attributes = GetProperties(type);
}
}
if (element != null)
{
IUMLElement owner = null;
if (type.Namespace == null)
{
owner = projectUML;
}
else if (listElements.ContainsKey(type.Namespace))
{
owner = listElements[type.Namespace];
}
else
{
owner = new UMLPackage();
//if(type.Namespace.Contains(projectUML.Name))
//{
// owner.Name = type.Namespace.Replace(projectUML.Name, "");
//}
owner.Stereotype = "ClassPackage";
owner.Name = type.Namespace;
owner.Owner = projectUML;
listElements.Add(type.Namespace, owner);
}
element.Owner = owner;
if ((type.Attributes & TypeAttributes.Public) == TypeAttributes.Public)
{
element.Visibility = Visibility.Public;
}
else
{
element.Visibility = Visibility.Private;
}
XmlNode node = DocsByReflection.XMLFromType(type);
if (node != null)
{
element.Documentation = node.InnerXml.Trim();
}
if (!listElements.ContainsKey(type.Namespace + "." + type.Name))
{
listElements.Add(type.Namespace + "." + type.Name, element);
}
}
}
}
}
}
}
else
{
// Error Build
}
soln.Close(true);
}
catch (SystemException ex)
{
//MessageBox.Show("ERROR: " + ex);
}
finally
{
if (dte != null)
{
dte.Quit();
}
}
Helper.BeginUpdate();
addMessageBackgroundWorker(0, "Init import...");
int pos = 0;
foreach (IUMLElement element in listElements.Values)
{
pos++;
addMessageBackgroundWorker((pos * 100) / listElements.Count, "Creating: \n" + element.Name);
element.GetType().InvokeMember("Save", BindingFlags.Default | BindingFlags.InvokeMethod, null, element, new object[] { });
}
addMessageBackgroundWorker(100, "End import");
Helper.EndUpdate();
}
public static void Remove(IUMLElement element)
{
dictionary.Remove(element.Guid);
}
/// <summary>
/// Create a diagram using list of the phases and iterations
/// </summary>
/// <typeparam name="List">Type for the first list</typeparam>
/// <typeparam name="T">Type for the first element</typeparam>
/// <typeparam name="List2">Type second list</typeparam>
/// <typeparam name="T2">Type for second element</typeparam>
/// <param name="owner">Owner of the diagram</param>
/// <param name="listPhases">Phases</param>
/// <param name="listIterations">Iterations</param>
/// <param name="fragmentName">File Name (ModelFragment)</param>
/// <param name="diagramName">Diagram name included in the ModelFragment</param>
public static void CreateDiagramPhaseIteration <List, T, List2, T2>(IUMLElement owner, List listPhases, List2 listIterations, string fragmentName, string diagramName)
where T : ActiveRecord <T>, new()
where T2 : ActiveRecord <T2>, new()
where List : ActiveList <T, List>, new()
where List2 : ActiveList <T2, List2>, new()
{
try
{
Dictionary <string, StarUML.IView> diagramElements = new Dictionary <string, StarUML.IView>();
StarUML.IUMLPackage folder = dataAccess.FindModel(owner.Guid) as StarUML.IUMLPackage;
StarUML.IDiagram diagram = dataAccess.ImportModelFragment(fragmentName, folder, diagramName);
if (diagram != null)
{
StarUML.IDiagramView diagramClassView = diagram.DiagramView;
foreach (IUMLElement item in listPhases)
{
StarUML.IUMLPackage phase = dataAccess.FindModel(item.Guid) as StarUML.IUMLPackage;
StarUML.IUMLPackageView view = dataAccess.Factory.CreatePackageView(diagramClassView, phase as StarUML.IUMLPackage);
view.StereotypeDisplay = StarUML.UMLStereotypeDisplayKind.sdkIcon;
diagramElements.Add(item.Guid, view);
for (int i = 0; i < phase.GetAssociationCount(); i++)
{
StarUML.IUMLAssociationEnd end = phase.GetAssociationAt(i);
StarUML.IUMLClass iteration = end.GetOtherSide().Participant as StarUML.IUMLClass;
StarUML.IUMLClassView viewClass = null;
if (diagramElements.ContainsKey(iteration.GetGuid()))
{
viewClass = (StarUML.IUMLClassView)diagramElements[iteration.GetGuid()];
}
if (viewClass == null)
{
viewClass = dataAccess.Factory.CreateClassView(diagramClassView, iteration);
viewClass.SuppressOperations = true;
viewClass.SuppressAttributes = true;
viewClass.StereotypeDisplay = StarUML.UMLStereotypeDisplayKind.sdkIcon;
}
if (!diagramElements.ContainsKey(iteration.GetGuid()))
{
diagramElements.Add(iteration.GetGuid(), viewClass);
}
dataAccess.Factory.CreateAssociationView(diagramClassView, end.Association, view, viewClass);
}
}
foreach (IUMLElement item in listIterations)
{
StarUML.IUMLModelElement iteration = dataAccess.FindModel(item.Guid) as StarUML.IUMLModelElement;
if (!diagramElements.ContainsKey(iteration.GetGuid()))
{
StarUML.IUMLClassView viewClass = dataAccess.Factory.CreateClassView(diagramClassView, iteration as StarUML.IUMLClass);
viewClass.SuppressOperations = true;
viewClass.SuppressAttributes = true;
viewClass.StereotypeDisplay = StarUML.UMLStereotypeDisplayKind.sdkIcon;
}
for (int i = 0; i < iteration.GetClientDependencyCount(); i++)
{
StarUML.IUMLDependency dep = iteration.GetClientDependencyAt(i);
StarUML.IUMLClass classAux = dep.Supplier as StarUML.IUMLClass;
StarUML.IUMLClassView viewClass = null;
if (diagramElements.ContainsKey(classAux.GetGuid()))
{
viewClass = (StarUML.IUMLClassView)diagramElements[classAux.GetGuid()];
}
if (viewClass == null)
{
viewClass = dataAccess.Factory.CreateClassView(diagramClassView, classAux);
viewClass.SuppressOperations = true;
}
if (!diagramElements.ContainsKey(classAux.GetGuid()))
{
diagramElements.Add(classAux.GetGuid(), viewClass);
}
dataAccess.Factory.CreateDependencyView(diagramClassView, dep, diagramElements[iteration.GetGuid()], viewClass);
}
}
diagramClassView.LayoutDiagram();
}
}
catch (Exception ex)
{
log.Error("CreateDiagramPhaseIteration", ex);
}
}
public static void Remove(IUMLElement element)
{
dictionary.Remove(element.Guid);
}
private bool RemoveFiles(IUMLElement element)
{
if (element is UMLFile)
{
(element as UMLFile).Delete();
return true;
}
else
{
return false;
}
}
private bool FindPackage(IUMLElement package)
{
if (package.Name.Equals(this._packageName) && package is UMLPackage)
{
return true;
}
else
{
return false;
}
}
private void NewFormEdit(IUMLElement element)
{
element.Owner = (IUMLElement)_selectedNode.Tag;
FormEdit form = FormsFactory.GetFormEdit(element);
form.FormSaved += new EventHandler(form_FormSaved);
form.Show(this.DockPanel);
}
/// <summary>
/// Create a diagram using list of the collaborations and files
/// </summary>
/// <typeparam name="List">Type for the first list</typeparam>
/// <typeparam name="T">Type for the first element</typeparam>
/// <typeparam name="List2">Type for second list</typeparam>
/// <typeparam name="T2">Type for second element</typeparam>
/// <param name="owner">Owner of the diagram</param>
/// <param name="listCollaboration">Collaboration</param>
/// <param name="listFile">Files</param>
/// <param name="fragmentName">File Name (ModelFragment)</param>
/// <param name="diagramName">Diagram name included in the ModelFragment</param>
public static void CreateDiagramCollaborationFiles <List, T, List2, T2>(IUMLElement owner, List listCollaboration, List2 listFile, string fragmentName, string diagramName)
where T : ActiveRecord <T>, new()
where T2 : ActiveRecord <T2>, new()
where List : ActiveList <T, List>, new()
where List2 : ActiveList <T2, List2>, new()
{
try
{
Dictionary <string, StarUML.IView> diagramElements = new Dictionary <string, StarUML.IView>();
StarUML.IUMLPackage folder = dataAccess.FindModel(owner.Guid) as StarUML.IUMLPackage;
StarUML.IDiagram diagram = dataAccess.ImportModelFragment(fragmentName, folder, diagramName);
if (diagram != null)
{
StarUML.IDiagramView diagramUseView = diagram.DiagramView;
foreach (IUMLElement item in listCollaboration)
{
StarUML.IUMLCollaboration collaboration = dataAccess.FindModel(item.Guid) as StarUML.IUMLCollaboration;
if (collaboration != null)
{
StarUML.IUMLCollaborationView view = dataAccess.Factory.CreateCollaborationView(diagramUseView, collaboration);
diagramElements.Add(item.Guid, view);
for (int i = 0; i < collaboration.GetClientDependencyCount(); i++)
{
StarUML.IUMLDependency dep = collaboration.GetClientDependencyAt(i);
StarUML.IUMLClass classAux = dep.Supplier as StarUML.IUMLClass;
StarUML.IUMLClassView viewClass = null;
if (diagramElements.ContainsKey(classAux.GetGuid()))
{
viewClass = (StarUML.IUMLClassView)diagramElements[classAux.GetGuid()];
}
if (viewClass == null)
{
viewClass = dataAccess.Factory.CreateClassView(diagramUseView, classAux);
viewClass.SuppressOperations = true;
}
if (!diagramElements.ContainsKey(classAux.GetGuid()))
{
diagramElements.Add(classAux.GetGuid(), viewClass);
}
dataAccess.Factory.CreateDependencyView(diagramUseView, dep, view, viewClass);
}
}
}
foreach (IUMLElement item in listFile)
{
StarUML.IUMLModelElement file = dataAccess.FindModel(item.Guid) as StarUML.IUMLModelElement;
if (!diagramElements.ContainsKey(file.GetGuid()))
{
StarUML.IUMLClassView viewClass = dataAccess.Factory.CreateClassView(diagramUseView, file as StarUML.IUMLClass);
viewClass.SuppressOperations = true;
}
}
diagramUseView.LayoutDiagram();
}
}
catch (Exception ex)
{
log.Error("CreateDiagramCollaborationFiles", ex);
}
}
