Diploma_All
.pdfreturn parser.SpiceElements;
}
private MemoryStream PrepareFile(string fileName)
{
FileStream file = new FileStream(fileName, FileMode.Open, FileAccess.Read); StreamReader reader = new StreamReader(file, Encoding.ASCII); MemoryStream mStream = new MemoryStream();
StreamWriter writer = new StreamWriter(mStream, Encoding.ASCII); string temp = reader.ReadToEnd();
if (temp.Contains("\n\r+"))
temp = temp.Replace("\n\r+", " "); else if (temp.Contains("\r\n+"))
temp = temp.Replace("\r\n+", " ");
while (temp.Contains(" "))
{
temp = temp.Replace(" ", " ");
}
try
{
writer.Write(temp);
writer.Flush();
}
catch { writer.Close();} finally { reader.Close();}
mStream.Seek(0, SeekOrigin.Begin); return mStream;
}
public string PrintHierarchy()
{
SpiceElement[] spiceElements = GetSpiceElements(); StringBuilder output = new StringBuilder();
foreach (SpiceElement element in spiceElements) output.AppendLine(element.ToString());
return output.ToString();
}
public void SaveFile(string fileName)
{
string output = PrintHierarchy();
if (!string.IsNullOrEmpty(output)) SaveFile(fileName, output);
}
public void SaveFile(string fileName, string content)
{
StreamWriter file = new StreamWriter(fileName, false);
try
101
{
file.Write(content);
}
catch { }
finally { file.Close(); }
}
private SpiceElement[] GetSpiceElements()
{
List<SpiceElement> elements = new List<SpiceElement>(); Node node;
foreach (string path in _spiceElementsPaths)
{
foreach (Tree t in TreeBuilder.Instance.Trees)
{
if (t.Nodes.TryGetValue(path, out node) && node.Value != null) elements.Add(node.Value);
}
}
return elements.ToArray();
}
private void StoreSpiceElementsPaths(SpiceElement[] spiceElements)
{
string temp;
_spiceElementsPaths.Clear();
foreach (SpiceElement element in spiceElements)
{
temp = ElementNameAnalyzer.RemoveElementName(element.Name); temp = temp.Replace('|', '\\');
_spiceElementsPaths.Add(temp);
}
}
}
TreeBuilder. Класс построения иерархии. public class TreeBuilder : Singleton<TreeBuilder>
{
private List<Tree> _trees; private Tree _currentTree;
public List<Tree> Trees { get { return _trees; } set { _trees = value; }}
public Tree CurrentTree { get { return _currentTree; } set { _currentTree = value; }}
public TreeBuilder() { _trees = new List<Tree>(); }
public Tree CreateNewTree()
{
Tree newTree = new Tree(); _trees.Add(newTree); _currentTree = newTree; return newTree;
}
102
public Tree CreateNewTree(string[] nodeNames, SpiceElement spiceElement)
{
Tree newTree = new Tree(nodeNames, spiceElement); _trees.Add(newTree);
_currentTree = newTree; return newTree;
}
public Tree FindByNameInRoots(string name)
{
foreach (Tree tree in _trees)
{
if (tree.Name == name) return _currentTree = tree;
}
return null;
}
public void CreatePath(string[] nodeNames, SpiceElement spiceElement)
{
for (int i = 1; i < nodeNames.Length; i++)
{
// Искать i-й элемент на i-м уровне текущего дерева
Node nodeToFind = CurrentTree.CurrentNode.FindByNameInChildNodes(nodeNames[i]);
if (nodeToFind == null)
{
Node newNode;
if (i < nodeNames.Length - 1)
newNode = new Node(nodeNames[i]); else
// Add spiceElement value only for leaf-node newNode = new Node(nodeNames[i], spiceElement);
CurrentTree.CurrentNode.AddChild(newNode);
CurrentTree.AddToDic(newNode);
CurrentTree.CurrentNode = newNode;
// Достроить ветвь без проверок
string[] remainingNodeNames = new string[nodeNames.Length - i - 1];
for (int j = 0, k = i + 1; j < remainingNodeNames.Length; j++, k++)
{
remainingNodeNames[j] = nodeNames[k];
}
CreatePath(CurrentTree, newNode, remainingNodeNames, spiceElement); CurrentTree.CurrentNode = CurrentTree;
break;
}
else
CurrentTree.CurrentNode = nodeToFind;
}
}
103
public void CreatePath(Tree tree, Node parentNode, string[] nodeNames, SpiceElement spiceElement)
{
for (int i = 0; i < nodeNames.Length; i++)
{
Node newNode;
if (i < nodeNames.Length - 1)
newNode = new Node(nodeNames[i]); else
// Add spiceElement value only for leaf-node newNode = new Node(nodeNames[i], spiceElement);
parentNode.AddChild(newNode);
tree.AddToDic(newNode); parentNode = newNode;
}
}
}
Класс Node - узел
public class Node
{
public const char PATH_SEPARATOR = '\\';
private Node _parent;
private List<Node> _childNodes; private SpiceElement _value; private string _name;
public virtual Node Parent { get { return _parent; } set { _parent = value; } }
public ReadOnlyCollection<Node> ChildNodes
{
get
{
return new ReadOnlyCollection<Node>(_childNodes);
}
}
public SpiceElement Value { get { return _value; } set { _value = value; } } public string Name { get { return _name; } set { _name = value; } }
public bool HasChildren
{
get { return _childNodes.Count > 0; }
}
public int Level
{
get
{
if (_parent == null)
{
return 0;
}
return (_parent.Level + 1);
104
}
}
public string FullPath
{
get
{
if (_parent != null)
return _parent.FullPath + PATH_SEPARATOR + _name; else return _name;
}
}
public Node() { _childNodes = new List<Node>(); }
public Node(string Name)
{
_name = Name;
_childNodes = new List<Node>();
}
public Node(string Name, SpiceElement value)
{
_value = value; _name = Name;
_childNodes = new List<Node>();
}
public void AddChild(Node item)
{
item._parent = this;
_childNodes.Add(item);
}
public void RemoveChild(Node item)
{
_childNodes.Remove(item);
}
public void ClearChildren()
{
_childNodes.Clear();
}
public Node FindByNameInChildNodes(string name)
{
foreach (Node node in _childNodes)
{
if (node.Name == name)
{
return node;
}
}
return null;
}
105
}
Класс Tree - дерево
public class Tree : Node
{
private Node _currentNode; private StringBuilder _treeString;
private Dictionary<string, Node> _nodes;
public Node CurrentNode
{
get
{
if (_currentNode == null) _currentNode = this;
return _currentNode;
}
set { _currentNode = value; }
}
public override Node Parent
{
get { return null; }
}
public Dictionary<string, Node> Nodes
{
get { return _nodes; }
}
public Tree(string[] nodeNames, SpiceElement spiceElement)
{
this.Value = nodeNames.Length == 1 ? spiceElement : null; this.Name = nodeNames[0];
Node currentNode = this; _treeString = new StringBuilder();
_nodes = new Dictionary<string, Node>(nodeNames.Length);
// Add root AddToDic(this);
for (int i = 1; i < nodeNames.Length; i++)
{
Node nodeToAdd;
if (i < nodeNames.Length - 1)
nodeToAdd = new Node(nodeNames[i]); else
// Add spiceElement value only for leaf-node nodeToAdd = new Node(nodeNames[i], spiceElement);
currentNode.AddChild(nodeToAdd); _nodes.Add(nodeToAdd.FullPath, nodeToAdd);
currentNode = nodeToAdd;
}
}
106
public Tree()
{
_treeString = new StringBuilder(); _nodes = new Dictionary<string, Node>();
}
public void AddToDic(Node node)
{
_nodes.Add(node.FullPath, node);
}
public new string ToString()
{
PrintAllChildren(this);
return _treeString.ToString();
}
private void PrintAllChildren(Node parentNode)
{
_treeString.AppendLine(parentNode.ToString());
if (parentNode.HasChildren)
{
foreach (Node node in parentNode.ChildNodes)
{
PrintAllChildren(node);
}
}
}
}
Класс SpiceElement – элемент SPICE
public class SpiceElement
{
private string _name; private string _modelName; private string[] _pins; private string[] _params;
public string Name {get { return _name; }set { _name = value; }}
public string ModelName{get { return _modelName; } set { _modelName = value; }}
public string[] Pins {get { return _pins; } set { _pins = value; }}
public string[] Params { get { return _params; } set { _params = value; } }
public SpiceElement() { }
public SpiceElement(string name, string[] pins, string[] parameters)
{
_name = name; _pins = pins;
_params = parameters;
}
107
public SpiceElement(string name, string[] pins)
{
_name = name; _pins = pins;
}
public SpiceElement(string name)
{
_name = name;
}
public override string ToString()
{
return String.Format("{0} {1} {2} {3}", _name, PrintStringArray(_pins),
_modelName, PrintStringArray(_params));
}
private string PrintStringArray(string[] strArr)
{
if (strArr == null) return String.Empty;
string result = "";
foreach (string s in strArr) result += s + ' ';
while (result.Contains(" ")) result.Replace(" ", " ");
return result.Remove(result.Length - 1);
}
}
Класс Renderer -класс для отображения иерархии public class Renderer : Singleton<Renderer>
{
private List<DrawnObject> _drawnObjects; private DrawnObject _selectedGlyph; public DrawnObject SelectedGlyph
{
get { return _selectedGlyph; }
}
public void PreRenderTrees(Tree[] trees, Point location, Size containerSize)
{
//Clear previous glyphs _drawnObjects.Clear();
//Prerender roots
Rectangle[] rootRects = GetRects(trees.Length, location, containerSize);
// Prerender children
for (int i = 0; i < trees.Length; i++) PreRenderAllChildren(trees[i], rootRects[i]);
108
}
public void Render(Graphics g)
{
foreach (DrawnObject dObj in DrawnObjects) dObj.Draw(g);
}
public void FillTreeView(TreeView treeView, Tree[] trees)
{
//Clear previous nodes treeView.Nodes.Clear();
//Add roots
foreach (Tree tree in trees) treeView.Nodes.Add(CreateTreeNode(tree));
// Add children
for (int i = 0; i < trees.Length; i++) AddChildren(trees[i], treeView.Nodes[i]);
}
public void HighlightGlyph(Point point, Graphics PanelGraphics)
{
if (_selectedGlyph != null) _selectedGlyph.Reset();
_selectedGlyph = FindGlyph(point);
if (_selectedGlyph != null) HighlightSelectedGlyph();
}
private void HighlightSelectedGlyph()
{
_selectedGlyph.Pen = HIGHLIGHT_PEN; _selectedGlyph.Brush = HIGHLIGHT_BRUSH;
_selectedGlyph.Font = new Font(_selectedGlyph.Font, FontStyle.Bold);
}
private void PreRenderAllChildren(Node parentNode, Rectangle parentRect)
{
DrawnObject dObj = new DrawnObject();
dObj.Rectangle = GetRect(parentRect, !parentNode.HasChildren); dObj.Name = parentNode.Name;
dObj.Value = parentNode.FullPath; dObj.NamePosition = dObj.Rectangle.Location;
_drawnObjects.Add(dObj);
if (parentNode.HasChildren)
{
Rectangle[] innerRects = GetRects(parentNode.ChildNodes.Count, dObj.Rectangle.Location, dObj.Rectangle.Size);
109
for (int i = 0; i < parentNode.ChildNodes.Count; i++)
{
PreRenderAllChildren(parentNode.ChildNodes[i], innerRects[i]);
}
}
}
private Rectangle GetRect(Rectangle parentRect, bool isElement)
{
Point location; Size size;
if (isElement)
{
size = new Size((parentRect.Width - _paddingX * 2) * 9 / 10, (parentRect.Width - _paddingX * 2) * 9 / 10);
location = new Point(parentRect.X + (parentRect.Width / 2 - size.Width / 2), parentRect.Y +
(parentRect.Height / 2 - size.Height / 2));
}
else
{
location = new Point(parentRect.X + _paddingX, parentRect.Y + _paddingY);
size = new Size(parentRect.Width - _paddingX * 2, parentRect.Height - _paddingY * 2);
}
return new Rectangle(location, size);
}
private Rectangle[] GetRects(int count, Point offset, Size containerSize)
{
Rectangle[] rects = new Rectangle[count];
Size rectsSize = new Size(containerSize.Width / count, containerSize.Height);
for (int i = 0; i < rects.Length; i++)
{
rects[i].Size = rectsSize; rects[i].Y = offset.Y;
rects[i].X = (i == 0) ? offset.X : rects[i - 1].X + rectsSize.Width;
}
return rects;
}
private TreeNode CreateTreeNode(Node node)
{
TreeNode newNode = new TreeNode(node.Name); newNode.Name = node.FullPath;
return newNode;
}
private void AddChildren(Node parentNode, TreeNode parentTreeNode)
{
if (parentNode.HasChildren)
110