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