///-------------------------------------------------------------------------------- /// <summary>This method updates the view model data and sends update command back /// to the solution builder.</summary> ///-------------------------------------------------------------------------------- protected override void OnUpdate() { // send update for any updated children foreach (DiagramViewModel item in Diagrams) { if (item.IsEdited == true) { item.Update(); } } // send update for any new children foreach (DiagramViewModel item in ItemsToAdd.OfType <DiagramViewModel>()) { item.Update(); Diagrams.Add(item); } ItemsToAdd.Clear(); // send delete for any deleted children foreach (DiagramViewModel item in ItemsToDelete.OfType <DiagramViewModel>()) { item.Delete(); Diagrams.Remove(item); } ItemsToDelete.Clear(); // reset modified for children foreach (DiagramViewModel item in Diagrams) { item.ResetModified(false); } }
private Action <bool> GetDiagramPostEditCallback(ObservableDiagram od) { ObservableDiagram originalObservableDiagram = od; Diagram originalDiagram = od.Diagram; return((changed) => { if (changed) { if (Collection.Contains(originalDiagram)) { // We edited an existing diagram, so we need to replace the pre-edited Diagram still in the library // with the newly minted Diagram from the editor Collection.Replace(originalDiagram, originalObservableDiagram.Diagram); } else { // This was a new diagram, so we need to add it to the library collection Collection.Add(originalObservableDiagram.Diagram); // Then add it to the list of visible diagrams Diagrams.Add(originalObservableDiagram); } // Now we need to refresh the individual image originalObservableDiagram.Refresh(); // Now that the internal Diagram has changed, we need to rebuild the callback so that the new Diagram is // cached correctly for any future calls to edit this od originalObservableDiagram.PostEditCallback = GetDiagramPostEditCallback(originalObservableDiagram); } }); }
protected override void OnChildDeleted(EFContainer efContainer) { var child2 = efContainer as DesignerInfo; if (child2 != null) { var infoEnum = _designerInfos.GetEnumerator(); while (infoEnum.MoveNext()) { if (infoEnum.Current.Value == child2) { _designerInfos.Remove(infoEnum.Current.Key); break; } } return; } if (efContainer.Equals(_diagrams)) { _diagrams = null; } base.OnChildDeleted(efContainer); }
internal override bool ParseSingleElement(ICollection <XName> unprocessedElements, XElement element) { if (element.Name.LocalName == "Connection") { DesignerInfo connectionDesignerInfo = new ConnectionDesignerInfo(this, element); connectionDesignerInfo.Parse(unprocessedElements); _designerInfos.Add(element.Name.LocalName, connectionDesignerInfo); } else if (element.Name.LocalName == OptionsDesignerInfo.ElementName) { DesignerInfo optionsDesignerInfo = new OptionsDesignerInfo(this, element); optionsDesignerInfo.Parse(unprocessedElements); _designerInfos.Add(element.Name.LocalName, optionsDesignerInfo); } else if (_diagramArtifact == null && element.Name.LocalName == Diagrams.ElementName) // only parse Diagrams element if DiagramArtifact is not available. { _diagrams = new Diagrams(this, element); _diagrams.Parse(unprocessedElements); } else { return(base.ParseSingleElement(unprocessedElements, element)); } return(true); }
/// <summary> /// Clears this instance. /// </summary> public void Clear() { Interlocked.Exchange(ref _initTimeInSeconds, -1); _marbleDiagrams.Clear(); Diagrams.Clear(); FlatItems.Clear(); DiagramWidth = RESET_WIDTH; }
internal CreateDiagramCommand(string name, Diagrams diagrams) { ValidateString(name); Debug.Assert(diagrams != null, "diagrams is null"); _name = name; _diagrams = diagrams; }
private void BindDiagram() { DiagramService diagramService = (DiagramService) new ServiceLocator <Attachment>().locate(); List <UserStoryAttachment> attachments = diagramService.ListAll(); Diagrams.DataSource = attachments; Diagrams.DataBind(); }
/// <summary> /// Removes a diagram from the project. /// </summary> /// <param name="diagram">The diagram to remove.</param> public virtual void RemoveDiagram(DiagramModel diagram) { if (!Diagrams.Contains(diagram)) { return; } Diagrams.Remove(diagram); }
/// <summary> /// Adds a diagram to the project. /// </summary> /// <param name="diagram">The diagram to add.</param> public virtual void AddDiagram(DiagramModel diagram) { if (Diagrams.Contains(diagram)) { return; } Diagrams.Add(diagram); }
internal void RedrawDiagrams() { if (!_firstLoad) { Diagrams.Clear(); _firstLoad = true; RaisePropertyChanged(nameof(Diagrams)); } }
public ExplorerDiagrams(EditingContext context, Diagrams diagrams, ExplorerEFElement parent) : base(context, diagrams, parent) { var name = Resources.DiagramTypesGhostNodeName; base.Name = name; _typesGhostNode = new ExplorerTypes(name, context, this); }
protected void gvResult_RowCommand(object sender, GridViewCommandEventArgs e) { string Id = gvResult.DataKeys[Convert.ToInt32(e.CommandArgument)].Values[0].ToString(); DiagramService dService = (DiagramService) new ServiceLocator <Engineer.EMF.Attachment>().locate(); var diagrams = dService.FindByStoryID(int.Parse(Id)); Diagrams.DataSource = diagrams != null ? diagrams : new List <Engineer.EMF.UserStoryAttachment>(); Diagrams.DataBind(); Diagrams.Visible = true; }
public virtual void AddDiagram(DiagramModel diagram) { if (Diagrams.Contains(diagram)) { return; } Diagrams.Add(diagram); ProjectChanged(); TriggerProjectChangeWhenDiagramChanges(diagram); }
public virtual void RemoveDiagram(DiagramModel diagram) { if (!Diagrams.Contains(diagram)) { return; } Diagrams.Remove(diagram); ProjectChanged(); RemoveTriggerProjectChangeWhenDiagramChanges(diagram); }
public async void LoadDiagram() { try { installedLocation = await installedLocation.CreateFolderAsync("Syncfusion", CreationCollisionOption.OpenIfExists); //IReadOnlyList<StorageFile> files = await installedLocation.GetFilesAsync(); StorageFile indexFile = null; IReadOnlyList <StorageFile> files = await installedLocation.GetFilesAsync(); indexFile = files.Where(f => f.Name == "index.xml").FirstOrDefault(); if (indexFile != null) { XmlSerializer deSerializer = new XmlSerializer(typeof(List <FileInfo>), new Type[] { typeof(FileInfo) }); List <FileInfo> fileIndex = null; using (Stream stream = await indexFile.OpenStreamForReadAsync()) { fileIndex = deSerializer.Deserialize(stream) as List <FileInfo>; } foreach (FileInfo fileInfo in fileIndex.OrderBy(e => e.Index)) { if (!files.Any(f => f.Name == fileInfo.FileName)) { continue; } StorageFile file = await installedLocation.GetFileAsync(fileInfo.FileName); DiagramVM newdiagram = GetNewDiagramVM(file, true); newdiagram.IsSelected = fileInfo.Selected; newdiagram.Title = fileInfo.Title; Diagrams.Add(newdiagram); //FileItem item = new FileItem(); //item.Name = file.DisplayName; //item.Load = this.Load; //BasicProperties properties = await file.GetBasicPropertiesAsync(); //item.LastUpdated = properties.DateModified; //items.Add(item); } } } catch { } if (Diagrams.Count == 0) { OnNewCommand(null); } //else //{ // SelectedDiagram = Diagrams[0]; //} }
public string GeneratePublicId() { while (true) { var intValue = new Random().Next(int.MaxValue); var result = Base32.ToBase32String(new Int32Converter(intValue).ToBytes()); if (!Diagrams.Any(d => d.PublicId == result)) { return(result); } } }
///-------------------------------------------------------------------------------- /// <summary>This method applies diagram deletes.</summary> ///-------------------------------------------------------------------------------- public void ProcessDeleteDiagramPerformed(DiagramEventArgs data) { try { bool isItemMatch = false; if (data != null && data.Diagram != null) { foreach (DiagramViewModel item in Diagrams.ToList <DiagramViewModel>()) { if (item.Diagram.DiagramID == data.Diagram.DiagramID) { // remove item from tabs, if present WorkspaceEventArgs message = new WorkspaceEventArgs(); message.ItemID = item.Diagram.DiagramID; Mediator.NotifyColleagues <WorkspaceEventArgs>(MediatorMessages.Command_CloseItemRequested, message); // delete children for (int i = item.Items.Count - 1; i >= 0; i--) { if (item.Items[i] is DiagramEntityViewModel) { DiagramEntityViewModel child = item.Items[i] as DiagramEntityViewModel; DiagramEntityEventArgs childMessage = new DiagramEntityEventArgs(); childMessage.DiagramEntity = child.DiagramEntity; childMessage.DiagramID = item.Diagram.DiagramID; childMessage.Solution = Solution; childMessage.WorkspaceID = child.WorkspaceID; item.ProcessDeleteDiagramEntityPerformed(childMessage); } } // delete item isItemMatch = true; Diagrams.Remove(item); Solution.DiagramList.Remove(item.Diagram); Items.Remove(item); Solution.ResetModified(true); OnUpdated(this, null); break; } } if (isItemMatch == false) { ShowIssue(DisplayValues.Issue_DeleteItemNotFound); } } } catch (Exception ex) { ShowIssue(ex.Message + ex.StackTrace); } }
private void CreateSolutionDiagrams(ModelEntityRepository repo, IEnumerable <ElementInstantiation> instantiations) { PackageInstance.Do(solutionPackage => { Diagrams.ForEach(problemDiagram => { var solutionDiagram = repo.Create(problemDiagram.Name, DiagramTypes.SolutionOverview, solutionPackage, ADTechnology.Technologies.AD.ID); CopyDiagramObjects(problemDiagram, solutionDiagram, instantiations); }); }); Children.ForEach(c => c.CreateSolutionDiagrams(repo, instantiations)); }
public void Button6_Click(object sender, EventArgs e) { databaseService = new DatabaseService(); databaseService.UpdateDatabaseServiceDbConnectionData(textBox1.Text, textBox2.Text, textBox3.Text, textBox4.Text); bool dbStatus = databaseService.IsDbConnected(); History.UpdateDatabaseConnectionData(textBox1.Text, textBox2.Text, textBox3.Text, textBox4.Text); Diagrams.UpdateDatabaseConnectionData(textBox1.Text, textBox2.Text, textBox3.Text, textBox4.Text); Dashboard.UpdateDatabaseServiceDbConnectionData(textBox1.Text, textBox2.Text, textBox3.Text, textBox4.Text); Dashboard.UpdateDatabaseConnectedStatus(dbStatus); }
private void Button1_Click(object sender, EventArgs e) { if (databaseService.IsDbConnected()) { databaseService.CloseConnection(); History.UpdateDatabaseConnectionData("", "", "", ""); Diagrams.UpdateDatabaseConnectionData("", "", "", ""); Dashboard.UpdateDatabaseConnectedStatus(false); } else { MessageBox.Show("Nie mozesz rozłączyć się, ponieważ nie jesteś połączony z żadną bazą danych"); } }
public async void OnNewCommand(object param) { StorageFile s = null; string parameter = Guid.NewGuid().ToString("N"); //if (EnsureUnsnapped()) { s = await installedLocation.CreateFileAsync(parameter + ".xml", CreationCollisionOption.FailIfExists); } if (s != null) { DiagramVM newDiagram = GetNewDiagramVM(s, false); Diagrams.Add(newDiagram); SelectedDiagram = newDiagram; } await SaveFileIndex(); }
public async void OnDuplicateCommand(object param) { StorageFile s = null; DiagramVM newDiagram = null; //Task task = null; string parameter = Guid.NewGuid().ToString("N"); //if (EnsureUnsnapped()) { s = await installedLocation.CreateFileAsync(parameter + ".mock", CreationCollisionOption.FailIfExists); } if (s != null) { IGraphInfo graph = SelectedDiagram.Info as IGraphInfo; PageVM page = SelectedDiagram.PageSettings as PageVM; if (graph != null && SelectedDiagram.ScrollSettings.ScrollInfo != null) { page.HOffset = SelectedDiagram.ScrollSettings.ScrollInfo.HorizontalOffset; page.VOffset = SelectedDiagram.ScrollSettings.ScrollInfo.VerticalOffset; page.Scale = SelectedDiagram.ScrollSettings.ScrollInfo.CurrentZoom; using (Stream stream = await s.OpenStreamForWriteAsync()) { graph.Save(stream); } newDiagram = new DiagramVM(s, true); Diagrams.Add(newDiagram); SelectedDiagram = newDiagram; newDiagram.EditTile = true; newDiagram.PropertyChanged += (diagram, e) => { DiagramVM sender = diagram as DiagramVM; if (e.PropertyName == "IsSelected") { if (sender.IsSelected == true) { this.SelectedDiagram = sender; } } }; await SaveFileIndex(); } } }
/// <summary> /// Appends the marble. /// </summary> /// <param name="itemWrapper">The item wrapper.</param> public void AppendMarble(MarbleItemViewModel itemWrapper) { #region Validation if (itemWrapper == null) { throw new NullReferenceException("itemWrapper"); } #endregion Validation MarbleBase item = itemWrapper.Item; if (TabKind == TabKind.Flat) { FlatItems.AddAsync(item); return; } itemWrapper.MainContext = this; #region Diagrams.AddAsync(diagram) MarbleDiagramModel diagram; if (!_marbleDiagrams.TryGetValue(item.Name, out diagram)) { diagram = new MarbleDiagramModel(item.Name, item.IndexOrder, this); if (_marbleDiagrams.TryAdd(item.Name, diagram)) { Diagrams.AddAsync(diagram); } else { diagram.Dispose(); diagram = _marbleDiagrams[item.Name]; } } #endregion // Diagrams.AddAsync(diagram) itemWrapper = itemWrapper.Clone(diagram); diagram.AppendMarble(itemWrapper); }
///-------------------------------------------------------------------------------- /// <summary>This method loads Diagrams into the view model.</summary> /// /// <param name="entities">The solution entities that could be added to the diagram.</param> /// <param name="solution">The associated solution.</param> /// <param name="loadChildren">Flag indicating whether to perform a deeper load.</param> ///-------------------------------------------------------------------------------- public void LoadDiagrams(EnterpriseDataObjectList <EntityViewModel> entities, Solution solution, bool loadChildren = true) { // attach the items Items.Clear(); if (Diagrams == null) { Diagrams = new EnterpriseDataObjectList <DiagramViewModel>(); } if (loadChildren == true) { foreach (Diagram item in solution.DiagramList) { DiagramViewModel itemView = new DiagramViewModel(item, entities, solution); itemView.Updated += new EventHandler(Children_Updated); Diagrams.Add(itemView); Items.Add(itemView); } } }
///-------------------------------------------------------------------------------- /// <summary>This method applies diagram updates.</summary> ///-------------------------------------------------------------------------------- public void ProcessEditDiagramPerformed(DiagramEventArgs data) { try { bool isItemMatch = false; if (data != null && data.Diagram != null) { foreach (DiagramViewModel item in Diagrams) { if (item.Diagram.DiagramID == data.Diagram.DiagramID) { isItemMatch = true; item.Diagram.TransformDataFromObject(data.Diagram, null, false); item.OnUpdated(item, null); item.ShowInTreeView(); break; } } if (isItemMatch == false) { // add new Diagram data.Diagram.Solution = Solution; #region protected DiagramViewModel newItem = new DiagramViewModel(data.Diagram, Entities, Solution); #endregion protected newItem.Updated += new EventHandler(Children_Updated); Diagrams.Add(newItem); Solution.DiagramList.Add(newItem.Diagram); Items.Add(newItem); OnUpdated(this, null); newItem.ShowInTreeView(); } } } catch (Exception ex) { ShowIssue(ex.Message + ex.StackTrace); } }
protected override void PreParse() { Debug.Assert(State != EFElementState.Parsed, "this object should not already be in the parsed state"); if (_designerInfos != null) { if (_designerInfos.Values.Count > 0) { foreach (var info in _designerInfos.Values) { info.Dispose(); } } _designerInfos.Clear(); } ClearEFObject(_diagrams); _diagrams = null; base.PreParse(); }
public void OnDeleteWithoutSaveCommand(object param) { DiagramVM diag = param as DiagramVM; int index = Diagrams.IndexOf(diag); Diagrams.Remove(diag); if (diag.IsSelected && Diagrams.Count > 0) { if (Diagrams.Count == index) { Diagrams[index - 1].IsSelected = true; } else if (Diagrams.Count > index) { Diagrams[index].IsSelected = true; } } if (Diagrams.Count == 0) { Exit.Execute(null); } }
private void DrawDiagrams() // Построение и отрисовка диаграм { Diagrams.Clear(); var Xdiagrams = SelectedTask .Element("diagrams"); if (Xdiagrams == null) { ButtonDiagramsVisibility = Visibility.Collapsed; return; } var diagrams = Xdiagrams. Descendants("diagram") .Select(i => new { x = int.Parse(i.Element("x").Attribute("column").Value), y = int.Parse(i.Element("y").Attribute("column").Value), }) .ToArray(); foreach (var diagram in diagrams) { if (diagram.x > DataTable.First().Count || diagram.y > DataTable.First().Count || diagram.x < 0 || diagram.y < 0) { throw new XMLValidationException("Diagram value is bigger than length if the table or less than 0"); } StackPanel spA = ParseToStackPanel(DataTable[0][diagram.x].Text); StackPanel spB = ParseToStackPanel(DataTable[0][diagram.y].Text); Diagram d = new Diagram(diagram.x, diagram.y, spA, spB); Diagrams.Add(d); } ButtonDiagramsVisibility = Diagrams.Count > 0 ? Visibility.Visible : Visibility.Collapsed; UpdateDiagrams(); }
/// <typeparam name="T"></typeparam> /// <param name="diagram">Тип диаграммы.</param> /// <param name="dataLine">Список данных.</param> /// <param name="diagramName">Название диаграммы.</param> /// <param name="nameFirstProjection">Название свойства оси ординат.</param> /// <param name="nameSecondProjection">Название свойства оси абсцисс (обязательно численное значение).</param> /// <param name="path">Строка вида @"D:\path\to\diagram.docx".</param> public void CreateDiagram <T>(Diagrams diagram, List <T> dataLine, string diagramName, string nameFirstProjection, string nameSecondProjection, string path) { DocX document = DocX.Create(path); Series series = GetSeries <T>(dataLine, diagramName, nameFirstProjection, nameSecondProjection); switch (diagram) { case Diagrams.LineChart: document.InsertChart(CreateLineChart(series)); break; case Diagrams.PieChart: document.InsertChart(CreatePieChart(series)); break; case Diagrams.BarChart: document.InsertChart(CreateBarChart(series)); break; } document.Save(); }
private void TypesCollectionChanged(object sender, NotifyCollectionChangedEventArgs e) { foreach (var newItem in e.NewItems) { Type type = newItem as Type; if (type.GetInterface(typeof(IDiagram).FullName, false) != null) { IDiagram diagram = (IDiagram)Activator.CreateInstance(type); if (!Diagrams.Any(item => item.GetType() == type)) { Diagrams.Add(diagram); if (SelectedDiagram == null) { SelectedDiagram = diagram; } } } else if (type.IsSubclassOf(typeof(ObjectType))) { AddSelectedDiagramType(type); } } }