// ======================================================================== // Con- / Destruction #region === Con- / Destruction /// <summary> /// Initializes a new instance of <see cref="NETImport"/>. /// </summary> public NETImport(ClassDiagram diagram, ImportSettings settings) { this.diagram = diagram; this.settings = settings; types = new Dictionary<NRTypeBase, TypeBase>(); }
// ======================================================================== // Methods #region === Methods /// <summary> /// Starts the functionality of the plugin. /// </summary> protected void Launch() { if (Workspace.HasActiveProject) { string fileName; using (OpenFileDialog dialog = new OpenFileDialog()) { dialog.Filter = Strings.OpenFileDialog_Filter; if (dialog.ShowDialog() == DialogResult.Cancel) { return; } fileName = dialog.FileName; } ImportSettings settings = new ImportSettings(); using (ImportSettingsForm settingsForm = new ImportSettingsForm(settings)) { if (settingsForm.ShowDialog() == DialogResult.OK) { ClassDiagram diagram = new ClassDiagram(CSharpLanguage.Instance); if (ImportAssembly(fileName, diagram, settings)) { Workspace.ActiveProject.Add(diagram); } } } } }
public void Persist(ClassDiagram classDiagram, CreateClassDiagramCommand command) { foreach (var contentItem in command.Contents) { var classDiagramContent = new ClassDiagramContent(); classDiagramContent.Id = Guid.NewGuid(); classDiagramContent.Locale = contentItem.Locale; classDiagramContent.Name = contentItem.Name; classDiagram.Contents.Add(classDiagramContent); _classDiagramContentRepository.Add(classDiagramContent); } foreach (var classData in command.Classes) { PersistClass(classDiagram, classData); } foreach (var relationData in command.Relations) { var classRelation = new ClassRelationship(); classRelation.Id = Guid.NewGuid(); classRelation.SourceId = relationData.SourceId.Value; classRelation.SourceMultiplicity = relationData.SourceMultiplicity; classRelation.TargetId = relationData.TargetId.Value; classRelation.TargetMultiplicity = relationData.TargetMultiplicity; classRelation.Type = relationData.Type.Value; classDiagram.Relationships.Add(classRelation); _classRelationRepository.Add(classRelation); } }
// assoc [ "," assoc ]* public IClassDiagram ParseClassDiagram() { var cd = new ClassDiagram(); while (_genericTokens.Count > 0) { if (!ParseClassOrAssociation(cd)) { return(null); } // either no more genericTokens OR comma, otherwise error if (!_genericTokens.TryConsume(TokenType.Comma)) { break; } } if (_genericTokens.Count > 0) { FireUnexpectedError(TokenType.Unknown); return(null); } return(cd); }
private void ParseFields(ClassDiagram classDiagram, IEnumerable <SDField> fields) { foreach (var field in fields.OrderBy(o => o.Name)) { classDiagram.FieldRows.Add(new ClassDiagramRow(field.Identifier, "Field", field.Accessibility, field.Name)); } }
private void ParseMethods(ClassDiagram classDiagram, IEnumerable <SDMethod> methods) { foreach (var method in methods.OrderBy(o => o.Name)) { classDiagram.MethodRows.Add(new ClassDiagramRow(method.Identifier, "Method", method.Accessibility, method.Name)); } }
private void ParseConstructors(ClassDiagram classDiagram, IEnumerable <SDMethod> constructors) { foreach (var constructor in constructors.OrderBy(o => o.Name)) { classDiagram.ConstructorRows.Add(new ClassDiagramRow(constructor.Identifier, "Method", constructor.Accessibility, constructor.Name)); } }
private void ParseEvents(ClassDiagram classDiagram, IEnumerable <SDEvent> events) { foreach (var ev in events.OrderBy(o => o.Name)) { classDiagram.EventRows.Add(new ClassDiagramRow(ev.Identifier, "Event", ev.Accessibility, ev.Name)); } }
public ClassDiagramControl(ClassDiagram diagram) { this.currentDiagram = diagram; this.Text = currentDiagram.GetName(); this.Name = currentDiagram.GetName(); this.AccessibleName = currentDiagram.GetName(); this.menuManager = new ClassDiagramViewMenuManager(this); this.menuManager.AddMenu(); this.BackColor = Color.White; this.Dock = DockStyle.Fill; this.AutoSize = true; diagramWriter = new ClassDiagramDao(); txtDiagramBodi = new TextBox(); txtDiagramBodi.Multiline = true; txtDiagramBodi.Text = currentDiagram.bodi; txtDiagramBodi.WordWrap = false; txtDiagramBodi.ScrollBars = ScrollBars.Vertical; txtDiagramBodi.Dock = DockStyle.Fill; txtDiagramBodi.AutoSize = true; txtDiagramBodi.Name = currentDiagram.GetName(); txtDiagramBodi.KeyUp += new KeyEventHandler(ManageKeyCombinations); this.Controls.Add(txtDiagramBodi); this.Focus(); }
// ======================================================================== // Con- / Destruction #region === Con- / Destruction /// <summary> /// Initializes a new instance of <see cref="NETImport"/>. /// </summary> public NETImport(ClassDiagram diagram, ImportSettings settings) { this.diagram = diagram; this.settings = settings; types = new Dictionary <NRTypeBase, TypeBase>(); }
private void ClassSelectionChanged(object sender, SelectionChangedEventArgs e) { ListInit(); opList = new List <Operation>(); ClassDiagram cd = XMLUtil.GetClassDiagramByName(this.cdList, (String)this.list_class.SelectedItem); if (cd != null) { this.list_ck.Items.Add("Dit: " + cd.Dit); this.list_ck.Items.Add("Cbo: " + cd.Cbo); this.list_ck.Items.Add("Noc: " + cd.Noc); foreach (String attribute in cd.Attributes) { this.list_attribute.Items.Add(attribute); } foreach (Operation operation in cd.Operations) { this.list_operation.Items.Add(operation.Name); opList.Add(operation); } } }
private double CalculateDiagramWidth(ClassDiagram classDiagram) { var allRows = GetAllRows(classDiagram); var headerWidth = (int)Math.Max(classDiagram.Name.GetWidth(14, Fonts.FontLight), classDiagram.Accessibility.GetWidth(11, Fonts.FontItalic)); var maxWidthRows = allRows.Count > 0 ? allRows.Max(o => (int)o.Text.GetWidth(14, Fonts.FontLight)) : 0; return(Math.Max(headerWidth, maxWidthRows) + 65); }
public override void ToolMouseDown(object sender, MouseEventArgs e) { if (e.Button == MouseButtons.Left) { this.classDiagram = new ClassDiagram(e.X, e.Y); Create(this.classDiagram); } }
public static string GetDiagramText(ClassDiagram diagram) { var buffer = new StringBuilder(); var generator = new BufferedClassDiagramGenerator(diagram, buffer); generator.Generate(); return buffer.ToString(); }
public static string GetDiagramText(ClassDiagram diagram) { var buffer = new StringBuilder(); var generator = new BufferedClassDiagramGenerator(diagram, buffer); generator.Generate(); return(buffer.ToString()); }
private List <ClassDiagramRow> GetAllRows(ClassDiagram classDiagram) { var allRows = new List <ClassDiagramRow>(); allRows.AddRange(classDiagram.FieldRows); allRows.AddRange(classDiagram.PropertyRows); allRows.AddRange(classDiagram.MethodRows); allRows.AddRange(classDiagram.EventRows); return(allRows); }
private static void newJavaDiagram_Click(object sender, EventArgs e) { ToolStripItem menuItem = (ToolStripItem)sender; Project project = ((ProjectNode)menuItem.OwnerItem.Owner.Tag).Project; IDiagram diagram = new ClassDiagram(JavaLanguage.Instance); Settings.Default.DefaultLanguageName = JavaLanguage.Instance.AssemblyName; project.Add(diagram); }
public void ImportFromSource(string fileName) { var assembly = AssemblyGenerator.Generate(fileName); var settings = GetDefaultSettings(); var diagram = new ClassDiagram(CSharpLanguage.Instance); var importer = new NETImport(diagram, settings); importer.ImportAssembly(assembly.Location, useNewAppDomain: false).ShouldBeTrue(); diagram.ToXml().ShouldMatchApproved(config => config.WithDescriminator(fileName)); }
protected internal ClassDiagramVisitorContext(ClassDiagram diagram) { this.TypeMetaModelSet = diagram.Types; this.Diagram = diagram; this.ScanMode = this.Diagram.ScanMode; this.ShowMembers = this.Diagram.ShowMembers; this.ShowMembersBindingFlags = this.Diagram.ShowMembersBindingFlags; this.ShowMethods = this.Diagram.ShowMethods; this.ShowMethodsBindingFlags = this.Diagram.ShowMethodsBindingFlags; }
private void mnuNewJavaDiagram_Click(object sender, EventArgs e) { if (Workspace.Default.HasActiveProject) { ShowModelExplorer = true; var diagram = new ClassDiagram(JavaLanguage.Instance); Workspace.Default.ActiveProject.Add(diagram); Settings.Default.DefaultLanguageName = JavaLanguage.Instance.AssemblyName; } }
public static ClassDiagramViewModel FromModel(ClassDiagram model) { return(new ClassDiagramViewModel { Id = model.Id, Identifier = model.Identifier, PackageIdentifier = model.SpecificationItem.Package.Identifier, Version = model.Version, Contents = model.Contents.Select(ClassDiagramContentViewModel.FromModel) }); }
public Diagram CreateDiagram(String path, string name) { string pathDiagram = fileSistem.ConbinePaths(path, name) + ".cd"; ClassDiagram cd = new ClassDiagram(); cd.name = name; cd.path = pathDiagram; cd.bodi = ""; diagramDao.WriteDiagram(cd); return(cd); }
private void AddEmptyDiagram() { TreeNode parent = Parent; this.Delete(); // TODO: in the settings there should be a default diagram. This should check // for the default first and then only if it is a class diagram for the // default language IDiagram diagram = new ClassDiagram(Settings.Default.GetDefaultLanguage()); project.Add(diagram); }
public static ClassDiagramDetailedViewModel FromModel(ClassDiagram model) { return(new ClassDiagramDetailedViewModel { Id = model.Id, Identifier = model.Identifier, Version = model.Version, PackageId = model.SpecificationItem.PackageId, Contents = model.Contents.Select(ClassDiagramContentViewModel.FromModel), Classes = model.Classes.Select(ClassViewModel.FromModel), Relations = model.Relationships.Select(ClassRelationshipViewModel.FromModel) }); }
private Size CalculateDiagramSize(ClassDiagram classDiagram) { var allRows = GetAllRows(classDiagram); var headerWidth = (int)Math.Max(classDiagram.Name.GetWidth(12, Fonts.FontLight), classDiagram.Accessibility.GetWidth(10, Fonts.FontItalic)); var maxWidthRows = allRows.Count > 0 ? allRows.Max(o => (int)o.Text.GetWidth(12, Fonts.FontLight)) : 0; var horizontalLineCount = CountSections(classDiagram); var size = new Size(); size.Width = Math.Max(headerWidth, maxWidthRows) + 65; size.Height = (3 * 20) + (10 * (horizontalLineCount > 0 ? horizontalLineCount - 1 : 0)) + allRows.Count * 20; return(size); }
public void TestClassDiagram1() { var document = TestHelper.SetupDocument(@"C:\temp\commontext.cs", Host); var w = new Window(); var diagram = new ClassDiagram { Document = document }; var grid = new Grid(); grid.Children.Add(diagram); w.Content = grid; w.ShowDialog(); }
public void createObjectTest() { List <AppLayer.Object> myObjects = new List <AppLayer.Object>(); ClassDiagram myObject = new ClassDiagram(0, 0, 100, 100); CreateObjectCommand myCommand = new CreateObjectCommand(myObject, ref myObjects); myCommand.execute(); if (myObjects.Count != 1) { Assert.Fail(); } }
public SvgRoot RenderConnectedDiagram(ClassDiagram classDiagram) { _classDiagram = classDiagram; _mainDiagram = _classDiagramSvgRenderer.RenderDiagram(_classDiagram); CalculateMainMarginsAndSize(); PositionMainDiagram(); DrawBaseTypes(); DrawImplementedInterfaces(); DrawUsedBy(); DrawUses(); return(_mainDiagram); }
public override void ToolMouseDown(object sender, MouseEventArgs e) { if (e.Button == MouseButtons.Left && canvas != null) { canvas.DeselectAllObjects(); selectedObject = canvas.SelectObjectAt(e.X, e.Y); if (selectedObject is ClassDiagram) { ClassDiagram classDiagram = (selectedObject as ClassDiagram); string value = PopUpForm("Property Name"); classDiagram.AddPropertyText(value); } } }
private int RenderHeader(ClassDiagram classDiagram, int position) { var formattedAccessibility = new FormattedText(classDiagram.Accessibility, CultureInfo.CurrentCulture, FlowDirection.LeftToRight, Fonts.FontItalic, 10, Brushes.Black); _context.DrawText(formattedAccessibility, new Point((_diagramSize.Width - classDiagram.Accessibility.GetWidth(10, Fonts.FontItalic)) / 2, position)); var formattedName = new FormattedText(classDiagram.Name, CultureInfo.CurrentCulture, FlowDirection.LeftToRight, Fonts.FontLight, 12, Brushes.Black); _context.DrawText(formattedName, new Point((_diagramSize.Width - classDiagram.Name.GetWidth(12, Fonts.FontLight)) / 2, position += 15)); position += 20; _context.DrawLine(new Pen(Brushes.Black, 1), new Point(1, position), new Point(_diagramSize.Width - 1, position)); position += 10; return(position); }
private void RenderAllRowSections(ClassDiagram classDiagram, int position) { var renderLine = FollowingSectionsNotEmpty(classDiagram, "Fields"); position = RenderRowSection(classDiagram.FieldRows, position, _diagramSize, renderLine); renderLine = FollowingSectionsNotEmpty(classDiagram, "Events"); position = RenderRowSection(classDiagram.EventRows, position, _diagramSize, renderLine); renderLine = FollowingSectionsNotEmpty(classDiagram, "Methods"); position = RenderRowSection(classDiagram.ConstructorRows, position, _diagramSize, false); position = RenderRowSection(classDiagram.MethodRows, position, _diagramSize, renderLine); RenderRowSection(classDiagram.PropertyRows, position, _diagramSize, false); }
public double CalculateDiagramHeight(ClassDiagram classDiagram) { var allRows = GetAllRows(classDiagram); var notEmptySections = (classDiagram.FieldRows.Count != 0 ? 1 : 0) + (classDiagram.PropertyRows.Count != 0 ? 1 : 0) + (classDiagram.MethodRows.Count != 0 || classDiagram.ConstructorRows.Count != 0 ? 1 : 0) + (classDiagram.EventRows.Count != 0 ? 1 : 0); var allRowsHeight = allRows.Count * 25 + (notEmptySections > 0 ? (notEmptySections - 1) * 10 : 0); //Das Firstrowoffset gibt den y wert der unterkante der ersten row an //damit der wert korrekt ist muss eine row (ohne margin) von der berechnung abgezogen werden return((FIRSTROW_OFFSET_Y - 15) + allRowsHeight); }
public static string Save(string outputDirectory, ClassDiagram diagram, IRunnerRecorder recorder) { var filePath = Path.Combine(outputDirectory, "{0}.nplant".FormatWith(diagram.Name.ReplaceIllegalPathCharacters('_'))); if (File.Exists(filePath)) File.Delete(filePath); using (var file = File.CreateText(filePath)) { var generator = new FileClassDiagramGenerator(diagram, file); generator.Generate(); recorder.Log("Diagram '{0}' written...".FormatWith(diagram.GetType().FullName)); recorder.Record(filePath); } return filePath; }
public SimulatedClassDiagramGenerator(ClassDiagram diagram) : base(diagram) { _definition = diagram; }
public ClassDiagramGenerator(ClassDiagram definition) { _definition = definition.CheckForNullArg("definition"); }
public BufferedClassDiagramGenerator(ClassDiagram definition, StringBuilder buffer) : base(definition) { _buffer = buffer; }
public LoadedDiagram(ClassDiagram diagram) { _diagram = diagram; _name = _diagram.Name; }
private static void newJavaDiagram_Click(object sender, EventArgs e) { ToolStripItem menuItem = (ToolStripItem) sender; Project project = ((ProjectNode) menuItem.OwnerItem.Owner.Tag).Project; IDiagram diagram = new ClassDiagram(JavaLanguage.Instance); Settings.Default.DefaultLanguageName = JavaLanguage.Instance.AssemblyName; project.Add(diagram); }
public ClassDiagramGeneration(ClassDiagram diagram) : this(new ClassDiagramVisitorContext(diagram)) { }
public ClassDiagramSimulation(ClassDiagram diagram) { _definition = diagram; _context = _definition.CreateGenerationContext(); }
public ConnectionCreator(ClassDiagram diagram, RelationshipType type) { this.diagram = diagram; this.type = type; }
public virtual void SaveDiagram(DslModeling::SerializationResult serializationResult, ClassDiagram diagram, string diagramFileName, global::System.Text.Encoding encoding, bool writeOptionalPropertiesWithDefaultValue) { #region Check Parameters if (serializationResult == null) throw new global::System.ArgumentNullException("serializationResult"); if (diagram == null) throw new global::System.ArgumentNullException("diagram"); if (string.IsNullOrEmpty(diagramFileName)) throw new global::System.ArgumentNullException("diagramFileName"); #endregion if (serializationResult.Failed) return; using (global::System.IO.MemoryStream diagramFileContent = this.InternalSaveDiagram(serializationResult, diagram, diagramFileName, encoding, writeOptionalPropertiesWithDefaultValue)) { if (!serializationResult.Failed) { // Only write the contents if there's no error encountered during serialization. if (diagramFileContent != null) { using (global::System.IO.FileStream fileStream = new global::System.IO.FileStream(diagramFileName, global::System.IO.FileMode.Create, global::System.IO.FileAccess.Write, global::System.IO.FileShare.None)) { using (global::System.IO.BinaryWriter writer = new global::System.IO.BinaryWriter(fileStream, encoding)) { writer.Write(diagramFileContent.ToArray()); } } } } } }
// ======================================================================== // Methods #region === Methods /// <summary> /// Starts the functionality of the plugin. /// </summary> protected void Launch() { if(Workspace.HasActiveProject) { string fileName; using (OpenFileDialog dialog = new OpenFileDialog()) { dialog.Filter = Strings.OpenFileDialog_Filter; if (dialog.ShowDialog() == DialogResult.Cancel) return; fileName = dialog.FileName; } ImportSettings settings = new ImportSettings(); using(ImportSettingsForm settingsForm = new ImportSettingsForm(settings)) { if(settingsForm.ShowDialog() == DialogResult.OK) { ClassDiagram diagram = new ClassDiagram(CSharpLanguage.Instance); NETImport importer = new NETImport(diagram, settings); if(importer.ImportAssembly(fileName)) { Workspace.ActiveProject.Add(diagram); } } } } }
/// <summary> /// Saves the given diagram to the given file, with default encoding (UTF-8). /// </summary> /// <param name="serializationResult">Stores serialization result from the save operation.</param> /// <param name="diagram">ClassDiagram to be saved.</param> /// <param name="diagramFileName">Name of the file in which the diagram will be saved.</param> /// <param name="writeOptionalPropertiesWithDefaultValue">Whether optional properties with default value will be saved.</param> public virtual void SaveDiagram(DslModeling::SerializationResult serializationResult, ClassDiagram diagram, string diagramFileName, bool writeOptionalPropertiesWithDefaultValue) { this.SaveDiagram(serializationResult, diagram, diagramFileName, global::System.Text.Encoding.UTF8, writeOptionalPropertiesWithDefaultValue); }
/// <summary> /// Saves the given diagram to the given file, with default encoding (UTF-8), and optional properties with default value will not /// be written out. /// </summary> /// <param name="serializationResult">Stores serialization result from the save operation.</param> /// <param name="diagram">ClassDiagram to be saved.</param> /// <param name="diagramFileName">Name of the file in which the diagram will be saved.</param> public virtual void SaveDiagram(DslModeling::SerializationResult serializationResult, ClassDiagram diagram, string diagramFileName) { this.SaveDiagram(serializationResult, diagram, diagramFileName, global::System.Text.Encoding.UTF8, false); }
internal protected virtual ClassDiagram CreateDiagramHelper(DslModeling::Partition diagramPartition, DslModeling::ModelElement modelRoot) { ClassDiagram diagram = new ClassDiagram(diagramPartition); return diagram; }
private global::System.IO.MemoryStream InternalSaveDiagram(DslModeling::SerializationResult serializationResult, ClassDiagram diagram, string diagramFileName, global::System.Text.Encoding encoding, bool writeOptionalPropertiesWithDefaultValue) { #region Check Parameters global::System.Diagnostics.Debug.Assert(serializationResult != null); global::System.Diagnostics.Debug.Assert(diagram != null); global::System.Diagnostics.Debug.Assert(!serializationResult.Failed); #endregion DslModeling::DomainXmlSerializerDirectory directory = this.GetDirectory(diagram.Store); global::System.IO.MemoryStream newFileContent = new global::System.IO.MemoryStream(); DslModeling::SerializationContext serializationContext = new DslModeling::SerializationContext(directory, diagramFileName, serializationResult); this.InitializeSerializationContext(diagram.Partition, serializationContext, false); // MonikerResolver shouldn't be required in Save operation, so not calling SetupMonikerResolver() here. serializationContext.WriteOptionalPropertiesWithDefaultValue = writeOptionalPropertiesWithDefaultValue; global::System.Xml.XmlWriterSettings settings = AgileModelerSerializationHelper.Instance.CreateXmlWriterSettings(serializationContext, true, encoding); using (global::System.Xml.XmlWriter writer = global::System.Xml.XmlWriter.Create(newFileContent, settings)) { this.WriteRootElement(serializationContext, diagram, writer); } return newFileContent; }
public ClassDiagramFormatter(ClassDiagram diagram, ClassDiagramVisitorContext context) { _diagram = diagram; _context = context; }
public ClassDiagramVisitorContext(ClassDiagram diagram, TypeMetaModelSet metaModelSet) { this.TypeMetaModelSet = metaModelSet; this.Diagram = diagram; }
public override IDescriptorWriter GetWriter(ClassDiagram diagram) { return new ClassWriter(diagram, this); }
public DiscoveredDiagram(string @namespace, ClassDiagram diagram) { Namespace = @namespace; Diagram = diagram; }
public override IDescriptorWriter GetWriter(ClassDiagram diagram) { return new EnumWriter(this.ReflectedType); }
internal ClassDiagramPackage(string name, ClassDiagram diagram) { _diagram = diagram; _name = name; }
public ClassWriter(ClassDiagram diagram, ClassDescriptor @class) { _diagram = diagram; this._class = @class; }
public abstract IDescriptorWriter GetWriter(ClassDiagram diagram);
public FileClassDiagramGenerator(ClassDiagram definition, StreamWriter file) : base(definition) { _file = file; }
protected ClassDiagramGenerator(ClassDiagram definition) { Definition = definition.CheckForNullArg("definition"); }