internal void CalculatePanelSizes() { int count = 0; if (MatrixModel?.Hierarchy != null) { TreeIterator <Element> iterator = new TreeIterator <Element>(MatrixModel.Hierarchy); TreeNode <Element> treeNode = iterator.Next(); while (treeNode != null) { if (treeNode.IsCollapsed) { count++; treeNode = iterator.Skip(); } else { treeNode = iterator.Next(); } } } _selector.Size = new Size(_selector.Width, count * _displayOptions.CellHeight + _displayOptions.RootHeight); _matrix.Size = new Size(count * _displayOptions.CellHeight, count * _displayOptions.CellHeight + _displayOptions.RootHeight); }
private void AllocateIds() { int i = 1; TreeIterator <Element> it = new TreeIterator <Element>(Hierarchy); TreeNode <Element> treeNode = it.Next(); while (treeNode != null) { treeNode.NodeValue.Id = i; i++; treeNode = it.Next(); } }
private void CalculateParentWeights() { _directRelationCount = 0; TreeIterator <Element> it1 = new TreeIterator <Element>(Hierarchy); TreeNode <Element> providerNode = it1.Next(); while (providerNode != null) { Relation[] relations = GetProviderRelations(providerNode.NodeValue).ToArray(); foreach (Relation rel in relations) { _directRelationCount++; TreeNode <Element> consumerNode = FindNode(rel.Consumer.FullName); if (consumerNode != null) { TreeNode <Element> currentConsumer = consumerNode; while (currentConsumer != null) { TreeNode <Element> currentProvider = providerNode; while (currentProvider != null) { if ((providerNode.NodeValue != null) && (currentProvider.NodeValue != null) && (consumerNode.NodeValue != null) && (currentConsumer.NodeValue != null)) { if ((currentConsumer.NodeValue.Id != consumerNode.NodeValue.Id) || (currentProvider.NodeValue.Id != providerNode.NodeValue.Id)) { AddRelation(currentConsumer.NodeValue, currentProvider.NodeValue, "", rel.Weight, false, true); } } else { Logger.LogError($"Node value null consumer={rel.Consumer.FullName} provider={rel.Provider.FullName}"); } currentProvider = currentProvider.Parent; } currentConsumer = currentConsumer.Parent; } } } providerNode = it1.Next(); } }
void Draw(Graphics g) { int y = -Controller.OffsetY + Controller.DisplayOptions.RootHeight; TreeIterator <Element> iterator = new TreeIterator <Element>(Controller.MatrixModel.Hierarchy); TreeNode <Element> treeNode = iterator.Next(); // // RootTree has priority - so it is painted last but its panel is saved first in the hList if (treeNode != null) { Rectangle rootBounds = new Rectangle( -Controller.OffsetX, 0, Size.Width, Controller.DisplayOptions.RootHeight); // note for root hpanel treeNode of nodepanel is null _hLayout.Add(new NodePanel(null, rootBounds)); } while (treeNode != null) { if (treeNode.IsCollapsed == false || treeNode.IsHidden) { treeNode = iterator.Next(); } else { DrawPanel(g, treeNode, y); y += Controller.DisplayOptions.CellHeight; treeNode = iterator.Skip(); } } Size = new Size(y + Controller.OffsetY - Controller.DisplayOptions.RootHeight + 1, y + Controller.OffsetY + 1); DrawGroupingSquares(g); DrawRootPanel(g); }
private void AnalyseCyclicDependencies() { _directRelationCount = 0; _directCycles = 0; TreeIterator <Element> it1 = new TreeIterator <Element>(Hierarchy); TreeNode <Element> node1 = it1.Next(); while (node1 != null) { Element provider = node1.NodeValue; foreach (Relation relation in GetProviderRelations(provider)) { if (!relation.IsDerived) { _directRelationCount++; } Element consumer = relation.Consumer; Relation inverseRelation = GetRelation(provider, consumer); if ((provider.Id != consumer.Id) && (inverseRelation != null) && (relation.Weight > 0) && (inverseRelation.Weight > 0)) { relation.IsCyclic = true; inverseRelation.IsCyclic = true; if (!relation.IsDerived && !inverseRelation.IsDerived) { _directCycles++; } } } node1 = it1.Next(); } }
void DrawGroupingSquares(Graphics g) { TreeIterator <Element> iterator = new TreeIterator <Element>(Controller.MatrixModel.Hierarchy); TreeNode <Element> treeNode = iterator.Next(); int xPos = -Controller.OffsetX + 1; int yPos = -Controller.OffsetY + Controller.DisplayOptions.RootHeight + 1; while (treeNode != null) { if (treeNode.IsHidden == false) { if (treeNode.IsCollapsed == false) { int width = Controller.CountNbDisplayableNested(treeNode) * Controller.DisplayOptions.CellHeight; Rectangle rect = new Rectangle(xPos, yPos, width - 1, width - 1); if (g.Clip.IsVisible(rect)) { g.DrawRectangle(new Pen(Brushes.DarkGray, 2), rect); } treeNode = iterator.Next(); } else { xPos += Controller.DisplayOptions.CellHeight; yPos += Controller.DisplayOptions.CellHeight; treeNode = iterator.Skip(); } } else { treeNode = iterator.Next(); } } }
void Draw(Graphics g) { int y = -Controller.OffsetY + Controller.DisplayOptions.RootHeight; TreeIterator <Element> iterator = new TreeIterator <Element>(Controller.MatrixModel.Hierarchy); TreeNode <Element> treeNode = iterator.Next(); while (treeNode != null) { if (treeNode.IsHidden == false) { if (treeNode.IsCollapsed == false) { Rectangle bounds = new Rectangle( treeNode.Depth * Controller.DisplayOptions.CellHeight, y, Controller.DisplayOptions.CellHeight, Controller.CountNbDisplayableNested(treeNode) * Controller.DisplayOptions.CellHeight); if (g.Clip.IsVisible(bounds)) { DrawPanel(g, bounds, treeNode); _layout.Add(new NodePanel(treeNode, bounds)); } // y position does not change for next treeNode treeNode = iterator.Next(); } else { // treeNode is collapsed - draw the module at position // if the treeNode has childrenskip them int x = treeNode.Depth * Controller.DisplayOptions.CellHeight; Rectangle bounds = new Rectangle(x, y, Size.Width - x, Controller.DisplayOptions.CellHeight); if (g.Clip.IsVisible(bounds)) { DrawPanel(g, bounds, treeNode); _layout.Add(new NodePanel(treeNode, bounds)); } // position for next panel y += Controller.DisplayOptions.CellHeight; treeNode = iterator.Skip(); } } else { treeNode = iterator.Next(); } } Size = new Size(Size.Width, y + Controller.OffsetY); g.DrawRectangle(_borderPen, new Rectangle(0, 0, Width - 1, Height - 1)); Rectangle rootBounds = new Rectangle(0, 0, Size.Width - 1, Controller.DisplayOptions.RootHeight - 2); DrawRootPanel(g, rootBounds); }
private void WriteDsmXml(Stream stream) { XmlWriterSettings settings = new XmlWriterSettings { Indent = true, IndentChars = (" ") }; using (XmlWriter writer = XmlWriter.Create(stream, settings)) { writer.WriteStartDocument(); writer.WriteStartElement("model"); foreach (KeyValuePair <string, List <KeyValuePair <string, string> > > metaDataGroup in _metaData) { writer.WriteStartElement("metadatagroup"); writer.WriteAttributeString("name", metaDataGroup.Key); foreach (KeyValuePair <string, string> metaData in metaDataGroup.Value) { writer.WriteStartElement("metadata"); writer.WriteAttributeString("name", metaData.Key); writer.WriteAttributeString("value", metaData.Value); writer.WriteEndElement(); } writer.WriteEndElement(); } writer.WriteStartElement("elements"); TreeIterator <Element> it1 = new TreeIterator <Element>(Hierarchy); TreeNode <Element> treeNode1 = it1.Next(); while (treeNode1 != null) { Element module = treeNode1.NodeValue; writer.WriteStartElement("element"); writer.WriteAttributeString("idref", module.Id.ToString()); writer.WriteAttributeString("name", module.Name); writer.WriteAttributeString("type", module.Type); writer.WriteAttributeString("parent", treeNode1.Parent.NodeValue?.Id.ToString() ?? ""); writer.WriteAttributeString("namespace", module.Namespace); writer.WriteEndElement(); treeNode1 = it1.Next(); } writer.WriteEndElement(); writer.WriteStartElement("relations"); TreeIterator <Element> it2 = new TreeIterator <Element>(Hierarchy); TreeNode <Element> treeNode2 = it2.Next(); while (treeNode2 != null) { Element module = treeNode2.NodeValue; foreach (Relation rel in GetProviderRelations(module)) { writer.WriteStartElement("relation"); writer.WriteAttributeString("from", rel.Consumer.Id.ToString()); writer.WriteAttributeString("to", rel.Provider.Id.ToString()); writer.WriteAttributeString("type", rel.Type); writer.WriteAttributeString("weight", rel.Weight.ToString()); writer.WriteAttributeString("cyclic", rel.IsCyclic.ToString()); writer.WriteAttributeString("derived", rel.IsDerived.ToString()); writer.WriteEndElement(); } treeNode2 = it2.Next(); } writer.WriteEndElement(); writer.WriteEndElement(); writer.WriteEndDocument(); } }
void DrawPanel(Graphics g, TreeNode <Element> rowTreeNode, int y) { Rectangle rowBounds = new Rectangle(0, y, Size.Width, Controller.DisplayOptions.CellHeight); if (g.Clip.IsVisible(rowBounds)) { _hLayout.Add(new NodePanel(rowTreeNode, rowBounds)); // can draw some of the row int x = -Controller.OffsetX; TreeIterator <Element> iterator = new TreeIterator <Element>(Controller.MatrixModel.Hierarchy); TreeNode <Element> treeNode = iterator.Next(); Element rowModule = rowTreeNode.NodeValue; int stateDisplay = 0; // trisstate optimisation 0 not started dispaying, 1 currently displaying // 2 finished displaying and can therefore break out of the loop while (treeNode != null && stateDisplay != 2) { Element module = treeNode.NodeValue; if (treeNode.IsCollapsed == false || treeNode.IsHidden) { treeNode = iterator.Next(); } else { Rectangle cell = new Rectangle( x, y, Controller.DisplayOptions.CellHeight, Controller.DisplayOptions.CellHeight); if (g.Clip.IsVisible(cell)) { if (treeNode == rowTreeNode) // the diagonal { g.FillRectangle(Controller.GetBackgroundColour(rowTreeNode, treeNode), cell); // TODO - OK } else { if (Controller.DisplayOptions.ShowCyclicRelations && Controller.MatrixModel.HasCyclicRelation(module, rowModule)) { g.FillRectangle(Brushes.Yellow, cell); } //else if ( (_hPanel != null && _hPanel.TreeNode == rowTreeNode ) || // (_vPanel != null && _vPanel.TreeNode == treeNode ) ) else if (Controller.ProviderTreeNode == rowTreeNode || Controller.ConsumerTreeNode == treeNode) { g.FillRectangle(Brushes.White, cell); } else { g.FillRectangle(Controller.GetBackgroundColour(rowTreeNode, treeNode), cell); //if (rowTreeNode.Parent == treeNode.Parent ) //{ // g.FillRectangle( // Controller.GetBackgroundColour(rowTreeNode.Parent), cell); // TODO - OK //} //else //{ // //g.FillRectangle(Brushes.AliceBlue, cell); // g.FillRectangle( // Controller.GetBackgroundColour( treeNode ), cell ); //} } DrawWeight(g, rowModule, module, cell); } g.DrawRectangle(_borderPen, cell); if (stateDisplay == 0) { stateDisplay++; } } else if (stateDisplay == 1) { stateDisplay++; } x += Controller.DisplayOptions.CellHeight; treeNode = iterator.Skip(); } } } }
private void DrawRootPanel(Graphics g) { int stateDisplay = 0; // tri-state optimisation 0 not started dispaying, 1 currently displaying // 2 finished displaying and can therefore break out of the loop int x = -Controller.OffsetX; TreeIterator <Element> iterator = new TreeIterator <Element>(Controller.MatrixModel.Hierarchy); TreeNode <Element> treeNode = iterator.Next(); while (treeNode != null && stateDisplay != 2) { Element module = treeNode.NodeValue; if (treeNode.IsCollapsed == false || treeNode.IsHidden) { treeNode = iterator.Next(); } else { Rectangle cell = new Rectangle(x, 0, Controller.DisplayOptions.CellHeight, Controller.DisplayOptions.RootHeight - 2); if (g.Clip.IsVisible(cell)) { // for each visible cell we create a vertical panel in vLayout of // height of _matrix Rectangle vPanelRec = new Rectangle(x, 0, Controller.DisplayOptions.CellHeight, Size.Height); _vLayout.Add(new NodePanel(treeNode, vPanelRec)); g.FillRectangle( Controller.ConsumerTreeNode == treeNode ? Brushes.White : Controller.GetBackgroundColour(treeNode, null), cell); if (treeNode.HasChildren) { g.DrawImage(_imgCollapsed, cell.Left + (cell.Width / 2.0f) - 4, cell.Top + 2); } g.DrawString(module.Id.ToString(), Controller.DisplayOptions.TextFont, _fcBrush, x, 10, _vStringFormat); g.DrawRectangle(_borderPen, cell); g.DrawLine(new Pen(Brushes.White, 1), cell.Left, cell.Bottom + 1, cell.Right, cell.Bottom + 1); if (stateDisplay == 0) { stateDisplay++; } } else if (stateDisplay == 1) { stateDisplay++; // finished displaying } x += Controller.DisplayOptions.CellHeight; treeNode = iterator.Skip(); } } }
/// <exception cref="System.IO.IOException"></exception> private void Walk(Tree tree, Tree auxTree) { TreeIterator mi = new TreeIterator(tree, TreeIterator.Order.POSTORDER); TreeIterator ai = new TreeIterator(auxTree, TreeIterator.Order.POSTORDER); TreeEntry m = mi.HasNext() ? mi.Next() : null; TreeEntry a = ai.HasNext() ? ai.Next() : null; int curIndexPos = indexCounter; GitIndex.Entry i = indexCounter < indexMembers.Length ? indexMembers[indexCounter ++] : null; while (m != null || a != null || i != null) { int cmpma = Compare(m, a); int cmpmi = Compare(m, i); int cmpai = Compare(a, i); TreeEntry pm = cmpma <= 0 && cmpmi <= 0 ? m : null; TreeEntry pa = cmpma >= 0 && cmpai <= 0 ? a : null; GitIndex.Entry pi = cmpmi >= 0 && cmpai >= 0 ? i : null; if (pi != null) { VisitEntry(pm, pa, pi); } else { FinishVisitTree(pm, pa, curIndexPos); } if (pm != null) { m = mi.HasNext() ? mi.Next() : null; } if (pa != null) { a = ai.HasNext() ? ai.Next() : null; } if (pi != null) { i = indexCounter < indexMembers.Length ? indexMembers[indexCounter++] : null; } } }