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