public IGraph Generate()
{
IGraph g = new DefaultGraph();
Generate(g);
return(g);
}
/// <summary>
/// Fill the node list that acts as a source for nodes.
/// </summary>
private void PopulateNodesList()
{
var graph = new DefaultGraph
{
NodeDefaults = { Size = new SizeD(50, 30), Style = defaultStyle }
};
// Create some nodes
CreateNode(graph, PointD.Origin, LogicGateType.And);
CreateNode(graph, PointD.Origin, LogicGateType.Nand);
CreateNode(graph, PointD.Origin, LogicGateType.Or);
CreateNode(graph, PointD.Origin, LogicGateType.Nor);
CreateNode(graph, PointD.Origin, LogicGateType.Not);
// Create an IC
CreateNode(graph, PointD.Origin, LogicGateType.Timer, "555", new SizeD(70, 120));
CreateNode(graph, PointD.Origin, LogicGateType.ADConverter, "2-bit A/D\nConverter", new SizeD(70, 120));
foreach (var node in graph.Nodes)
{
nodeStyleListBox.Items.Add(node);
}
nodeStyleListBox.ItemHeight = 65;
//Handle list item drawing
nodeStyleListBox.DrawItem += nodeStyleListBox_DrawItem;
// enable drag and drop
nodeStyleListBox.MouseDown += nodeStyleListBox_MouseDown;
}
/// <summary>
/// Copies a single page into the given view graph.
/// </summary>
/// <param name="pageNo">The page number.</param>
/// <param name="mapper">The mapper that is used to store the <see cref="NodeData"/></param>
/// <returns>The view graph where the page was created in.</returns>
public IGraph CreatePageView(int pageNo, IMapper <INode, NodeData> mapper)
{
LayoutGraph pageLayoutGraph = result.GetPage(pageNo);
IGraph pageView = new DefaultGraph();
pageView.MapperRegistry.AddMapper(MapperKeyNodeData, mapper);
CopyPage(pageLayoutGraph, pageView, pageNo, mapper);
return(pageView);
}
/// <summary>
/// Initializes the style panel of this demo.
/// </summary>
private void InitializeStylesList()
{
//Handle list item drawing
styleListBox.DrawItem += styleListBox_DrawItem;
// register for the mouse down event to initiate the drag operation
styleListBox.MouseDown += styleListBox_MouseDown;
int nodeSize = 30;
// Create a new Graph in which the palette nodes live
DefaultGraph nodeContainer = new DefaultGraph();
// Create some nodes
nodeContainer.CreateNode(new RectD(20, 20, nodeSize, nodeSize), new ShapeNodeStyle {
Shape = ShapeNodeShape.Rectangle, Pen = Pens.Black, Brush = Brushes.DarkOrange
});
nodeContainer.CreateNode(new RectD(20, 20, nodeSize, nodeSize), new ShapeNodeStyle {
Shape = ShapeNodeShape.RoundRectangle, Pen = Pens.Black, Brush = Brushes.DarkOrange
});
nodeContainer.CreateNode(new RectD(20, 20, nodeSize, nodeSize), new BevelNodeStyle {
Color = Color.DarkOrange
});
nodeContainer.CreateNode(new RectD(20, 20, nodeSize, nodeSize), new ShinyPlateNodeStyle {
Brush = Brushes.DarkOrange
});
INode node = nodeContainer.CreateNode(new RectD(0, 0, 70, 70), new PanelNodeStyle {
Color = Color.LightBlue, Insets = new InsetsD(0, 15, 0, 0)
});
nodeContainer.AddLabel(node, "Group Node", InteriorStretchLabelModel.North);
var nodeLabelContainer = nodeContainer.CreateNode(new RectD(0, 0, 70, 70), VoidNodeStyle.Instance, "Node Label Container");
var nodeLabel = nodeContainer.AddLabel(nodeLabelContainer, "Node Label", InteriorLabelModel.Center);
var edgeLabelContainer = nodeContainer.CreateNode(new RectD(0, 0, 70, 70), VoidNodeStyle.Instance, "Edge Label Container");
var edgeLabelTemplate = nodeContainer.AddLabel(edgeLabelContainer, "Edge Label", FreeNodeLabelModel.Instance.CreateDefaultParameter());
var portContainer = nodeContainer.CreateNode(new RectD(0, 0, 70, 70), VoidNodeStyle.Instance, "Port Container");
nodeContainer.AddPort(portContainer, FreeNodePortLocationModel.NodeCenterAnchored, new NodeStylePortStyleAdapter(new ShapeNodeStyle {
Brush = Brushes.Red, Pen = Pens.Black, Shape = ShapeNodeShape.Ellipse
})
{
RenderSize = new SizeD(10, 10)
});
// Add nodes to listview
foreach (INode n in nodeContainer.Nodes)
{
styleListBox.Items.Add(n);
}
}
/// <summary>
/// Asynchronously loads a compressed graphmlz file.
/// </summary>
private static async Task <IGraph> LoadGraphMlz(string filepath)
{
return(await Task.Run(() => {
var graph = new DefaultGraph();
var ioh = new GraphMLIOHandler();
using (var stream = new GZipStream(File.OpenRead(filepath), CompressionMode.Decompress)) {
ioh.Read(graph, stream);
}
return graph;
}));
}
/// <summary>
/// Populates the palette with the graphs stored in the resources folder.
/// </summary>
private void PopulatePalette()
{
var ioHandler = new GraphMLIOHandler();
foreach (var file in Directory.GetFiles("Resources"))
{
var graph = new DefaultGraph();
ioHandler.Read(graph, file);
PaletteListBox.Items.Add(graph);
}
}
/// <summary>
/// Initializes the graph instance setting default styles
/// and creating a small sample graph.
/// </summary>
protected virtual void InitializeGraph()
{
DefaultGraph defaultGraph = Graph.Lookup <DefaultGraph>();
if (defaultGraph != null)
{
defaultGraph.UndoEngineEnabled = true;
}
//Read initial graph from embedded resource
graphmlIoHandler.Read(GraphControl.Graph, "Resources\\styles.graphml");
GraphControl.FitGraphBounds();
}
public IGraph CreateSampleGraph()
{
var graph = new DefaultGraph();
// Create a few nodes of different height. Some of them show disabled buttons.
var expandStyle = new GrowShrinkButtonNodeStyleDecorator(new ShinyPlateNodeStyle {
Brush = Brushes.DarkOrange
});
graph.CreateNode(new RectD(0, 0, 80, 40), expandStyle);
graph.CreateNode(new RectD(120, 0, 80, 100), expandStyle);
graph.CreateNode(new RectD(240, 0, 80, 150), expandStyle);
return(graph);
}
/// <summary>
/// Populates the palette with the graphs stored in the resources folder.
/// </summary>
private void InitializePalette()
{
//Handle list item drawing
paletteListBox.DrawItem += OnDrawItem;
// register for the mouse down event to initiate the drag operation
paletteListBox.MouseDown += OnMouseDown;
// populate the palette
var ioHandler = new GraphMLIOHandler();
foreach (var file in Directory.GetFiles("Resources").Where(f => f.EndsWith("graphml")))
{
var graph = new DefaultGraph();
ioHandler.Read(graph, file);
paletteListBox.Items.Add(graph);
}
}
/// <summary>
/// Fill the node list that acts as a source for nodes.
/// </summary>
private void PopulateNodesList()
{
var graph = new DefaultGraph();
// Create some nodes
CreateNode(graph, PointD.Origin, FlowChartType.Start);
CreateNode(graph, PointD.Origin, FlowChartType.Operation);
CreateNode(graph, PointD.Origin, FlowChartType.Branch);
CreateNode(graph, PointD.Origin, FlowChartType.End);
foreach (var node in graph.Nodes)
{
nodeStyleListBox.Items.Add(node);
}
nodeStyleListBox.ItemHeight = 65;
//Handle list item drawing
nodeStyleListBox.DrawItem += nodeStyleListBox_DrawItem;
// enable drag and drop
nodeStyleListBox.MouseDown += nodeStyleListBox_MouseDown;
}
/// <summary>
/// Initializes the style panel of this demo.
/// </summary>
private void InitializeStylesList()
{
int nodeSize = 30;
// Create a new Graph in which the palette nodes live
IGraph nodeContainer = new DefaultGraph();
// Create some nodes
nodeContainer.CreateNode(new RectD(0, 0, nodeSize, nodeSize), new ShapeNodeStyle {
Shape = ShapeNodeShape.Rectangle, Pen = Pens.Black, Brush = Brushes.DarkOrange
});
nodeContainer.CreateNode(new RectD(0, 0, nodeSize, nodeSize), new ShapeNodeStyle {
Shape = ShapeNodeShape.RoundRectangle, Pen = Pens.Black, Brush = Brushes.DarkOrange
});
nodeContainer.CreateNode(new RectD(0, 0, nodeSize, nodeSize), new BevelNodeStyle {
Color = Colors.DarkOrange
});
nodeContainer.CreateNode(new RectD(0, 0, nodeSize, nodeSize), new ShinyPlateNodeStyle {
Brush = Brushes.DarkOrange
});
INode node = nodeContainer.CreateNode(new RectD(0, 0, 70, 70), new PanelNodeStyle {
Color = Colors.LightBlue, Insets = new InsetsD(0, 15, 0, 0)
});
nodeContainer.AddLabel(node, "Group Node", InteriorStretchLabelModel.North);
var nodeLabelContainer = nodeContainer.CreateNode(new RectD(0, 0, 70, 70), VoidNodeStyle.Instance, "Node Label Container");
var nodeLabel = nodeContainer.AddLabel(nodeLabelContainer, "Node Label", InteriorLabelModel.Center);
var edgeLabelContainer = nodeContainer.CreateNode(new RectD(0, 0, 70, 70), VoidNodeStyle.Instance, "Edge Label Container");
var edgeLabelTemplate = nodeContainer.AddLabel(edgeLabelContainer, "Edge Label", FreeNodeLabelModel.Instance.CreateDefaultParameter());
// Add nodes to listview
foreach (INode n in nodeContainer.Nodes)
{
styleListBox.Items.Add(n);
}
}
/// <summary>
/// Fill the node list that acts as a source for nodes.
/// </summary>
private void PopulateNodesList()
{
// Create a new Graph in which the palette nodes live
// Copy all relevant settings
IGraph nodeContainer = new DefaultGraph();
nodeContainer.NodeDefaults.Style = defaultStyle;
// Create some nodes
CreateNode(nodeContainer, PointD.Origin, FlowChartType.Start);
CreateNode(nodeContainer, PointD.Origin, FlowChartType.Operation);
CreateNode(nodeContainer, PointD.Origin, FlowChartType.Branch);
CreateNode(nodeContainer, PointD.Origin, FlowChartType.End);
// Add nodes to listview
foreach (INode n in nodeContainer.Nodes)
{
var type = ((FlowChartNodeStyle)n.Style).FlowChartType;
nodeContainer.AddLabel(n, type.ToString(), ExteriorLabelModel.South);
styleListBox.Items.Add(n);
}
}
public virtual void Validate()
{
if (Endpoints == null || Endpoints[0] == null || Endpoints[0] == "")
{
throw new BrowserException("You must set at least one endpoint IRI!");
}
List <string> newEndpoints = new List <string>();
foreach (var endpoint in Endpoints)
{
if (endpoint != null)
{
Config.AssertAbsoluteUri(endpoint);
newEndpoints.Add(endpoint);
}
}
Endpoints = newEndpoints.ToArray();
DefaultGraph = (DefaultGraph != null) ? DefaultGraph.Trim() : "";
//TODO: somehow replace by Config.Assert
if (DefaultGraph != "" &&
!Uri.IsWellFormedUriString(DefaultGraph, UriKind.Absolute))
{
throw new BrowserException("Invalid default graph URI!");
}
if (Timeout < Config.MIN_SEARCH_TIME)
{
Timeout = Config.MIN_SEARCH_TIME;
}
if (ResultsOnPage < Config.MIN_RESULTS_ON_PAGE)
{
ResultsOnPage = Config.MIN_RESULTS_ON_PAGE;
}
validUris = true;
}
/// <summary>
/// Fill the node list that acts as a source for nodes.
/// </summary>
private void PopulateNodesList()
{
// Create a new Graph in which the palette nodes live and copy all relevant settings
IGraph nodeContainer = new DefaultGraph();
nodeContainer.NodeDefaults.Style = defaultStyle;
nodeContainer.NodeDefaults.Size = new SizeD(50, 30);
// Create some nodes
CreateNode(nodeContainer, PointD.Origin, LogicGateType.And, "AND");
CreateNode(nodeContainer, PointD.Origin, LogicGateType.Nand, "NAND");
CreateNode(nodeContainer, PointD.Origin, LogicGateType.Or, "OR");
CreateNode(nodeContainer, PointD.Origin, LogicGateType.Nor, "NOR");
CreateNode(nodeContainer, PointD.Origin, LogicGateType.Not, "NOT");
// Create an IC
CreateNode(nodeContainer, PointD.Origin, LogicGateType.Timer, "555", new SizeD(70, 120));
CreateNode(nodeContainer, PointD.Origin, LogicGateType.ADConverter, "2-bit A/D\nConverter", new SizeD(70, 120));
// Add nodes to listview
foreach (var n in nodeContainer.Nodes)
{
styleListBox.Items.Add(n);
}
}
/// <summary>
/// Initializes the graph from the supplied GraphML file and creates the model from it.
/// </summary>
/// <remarks>
/// While this reads the graph from a GraphML file and constructs the model from an already-finished graph, a
/// real-world application would likely create the model from whichever data source is available and then create
/// the graph from it.
/// </remarks>
private void InitGraphAndModel()
{
var graph = new DefaultGraph
{
NodeDefaults = { Style = new NodeControlNodeStyle("NodeStyle")
{
OutlineShape = new Ellipse()
} },
EdgeDefaults = { Style = new EdgeSegmentControlEdgeStyle("EdgeStyle") }
};
var ioh = new GraphMLIOHandler();
// Parse node kinds and other info
IMapper <INode, NodeKind> nodeKinds = new DictionaryMapper <INode, NodeKind>();
IMapper <INode, NodeInfo> nodeInfos = new DictionaryMapper <INode, NodeInfo>();
ioh.AddInputMapper("NetworkMonitoring.NodeKind", nodeKinds);
ioh.AddInputMapper("NetworkMonitoring.NodeInfo", nodeInfos);
ioh.Read(graph, @"Resources\network.graphml");
foreach (var node in graph.Nodes)
{
// Create and attach the model node to the graph node.
var modelNode = new ModelNode
{
Name = nodeInfos[node].Name,
Ip = nodeInfos[node].Ip,
Enabled = true,
Kind = nodeKinds[node]
};
node.Tag = modelNode;
// Add the label
var label = graph.AddLabel(node, "", FreeLabelModel.Instance.CreateDefaultParameter(), nodeLabelStyle, tag: modelNode);
// Attach event handler for changing label visibility, so that the graph redraws accordingly.
// Since visibility can change via clicking on the node *and* from within the label, we have to use an event
// handler on the model node here.
modelNode.PropertyChanged += delegate(object sender, PropertyChangedEventArgs args) {
if (args.PropertyName == "LabelVisible")
{
GraphControl.Invalidate();
}
};
}
foreach (var edge in graph.Edges)
{
// Create and attach the model edge to the graph edge
var modelEdge = new ModelEdge
{
Source = (ModelNode)edge.GetSourceNode().Tag,
Target = (ModelNode)edge.GetTargetNode().Tag
};
edge.Tag = modelEdge;
// Add the edge label
var label = graph.AddLabel(edge, "", NinePositionsEdgeLabelModel.CenterCentered, edgeLabelStyle, tag: modelEdge);
}
// Create the mappings from model items to graph elements.
modelNodeToINode = graph.Nodes.ToDictionary(node => (ModelNode)node.Tag);
modelEdgeToIEdge = graph.Edges.ToDictionary(edge => (ModelEdge)edge.Tag);
model = new NetworkModel(modelNodeToINode.Keys, modelEdgeToIEdge.Keys);
GraphControl.Graph = graph;
}
private void LoadDefaults(string uri)
{
Style accordionStyle = (Style)Application.Current.Resources["AccordionItemStyle"];
IMapper <string, HeaderedContentControl> accordionItems = new DictionaryMapper <string, HeaderedContentControl>();
{
var graph = new DefaultGraph();
try {
new GraphMLIOHandler().Read(graph, uri);
} catch (Exception) {
return;
}
List <StyleChooser> nodeChoosers = new List <StyleChooser>();
foreach (var node in graph.Nodes)
{
string tag = (string)(node.Tag ?? "Other");
if ("Dummy" == tag)
{
continue;
}
HeaderedContentControl accordionItem = accordionItems[tag];
if (null == accordionItem)
{
accordionItem = new Expander()
{
Style = accordionStyle
};
accordionItem.Header = tag;
accordionItems[tag] = accordionItem;
StyleChooserAccordion.Items.Add(accordionItem);
var styleChooser = new StyleChooser();
styleChooser.ItemType = typeof(INodeStyle);
styleChooser.ItemsSource = new ObservableCollection <INode>();
styleChooser.SelectionChanged += delegate(object sender, SelectionChangedEventArgs args) {
if (args.AddedItems.Count > 0)
{
foreach (var n in nodeChoosers)
{
if (n != sender)
{
n.Deselect();
}
}
}
};
styleChooser.SelectionChanged += OnSelectionChanged;
nodeChoosers.Add(styleChooser);
accordionItem.Content = styleChooser;
styleChooser.HorizontalAlignment = HorizontalAlignment.Stretch;
}
StyleChooser chooser = (StyleChooser)accordionItem.Content;
ObservableCollection <INode> itemSource = (ObservableCollection <INode>)chooser.ItemsSource;
itemSource.Add(node);
}
var nodeChooser = nodeChoosers.FirstOrDefault();
if (nodeChooser != null)
{
nodeChooser.SelectFirst();
}
HeaderedContentControl edgeTypesAccordionItem = new Expander()
{
Style = accordionStyle
};
edgeTypesAccordionItem.Header = "Edge Types";
StyleChooserAccordion.Items.Add(edgeTypesAccordionItem);
var edgeStyleChooser = new StyleChooser();
edgeStyleChooser.ItemType = typeof(IEdgeStyle);
var edgeStyles = new ObservableCollection <IEdgeStyle>();
edgeStyleChooser.ItemsSource = edgeStyles;
edgeStyleChooser.SelectionChanged += OnSelectionChanged;
edgeTypesAccordionItem.Content = edgeStyleChooser;
foreach (var edge in graph.Edges)
{
edgeStyles.Add(edge.Style);
}
edgeStyleChooser.SelectFirst();
var labelTypesAccordionItem = new Expander()
{
Style = accordionStyle
};
labelTypesAccordionItem.Header = "Label Types";
StyleChooserAccordion.Items.Add(labelTypesAccordionItem);
var labelStyleChooser = new StyleChooser();
labelStyleChooser.ItemType = typeof(ILabelStyle);
var labelStyles = new ObservableCollection <ILabelStyle>();
labelStyleChooser.ItemsSource = labelStyles;
labelTypesAccordionItem.Content = labelStyleChooser;
labelStyleChooser.SelectionChanged += OnSelectionChanged;
foreach (var label in graph.Labels)
{
if (label.Owner is INode && Equals("Dummy", label.Owner.Tag))
{
var style = label.Style;
if (style is NodeStyleLabelStyleAdapter)
{
// unwrap from NodeStyleLabelStyleAdapter
style = ((NodeStyleLabelStyleAdapter)style).LabelStyle;
}
// adjust the default flow direction of SimpleLabelStyles to the flowdirection of the current application.
if (style is DefaultLabelStyle)
{
((DefaultLabelStyle)style).FlowDirection = this.FlowDirection;
}
if (style is LabelStyle)
{
((LabelStyle)style).FlowDirection = this.FlowDirection;
}
labelStyles.Add(label.Style);
}
}
labelStyleChooser.SelectFirst();
var portTypesAccordionItem = new Expander()
{
Style = accordionStyle
};
portTypesAccordionItem.Header = "Port Types";
StyleChooserAccordion.Items.Add(portTypesAccordionItem);
var portStyleChooser = new StyleChooser();
portStyleChooser.ItemType = typeof(IPortStyle);
var portStyles = new ObservableCollection <IPortStyle>();
portStyleChooser.ItemsSource = portStyles;
portTypesAccordionItem.Content = portStyleChooser;
portStyleChooser.SelectionChanged += OnSelectionChanged;
foreach (var port in graph.Ports)
{
if (Equals("Dummy", port.Owner.Tag) && port.Tag != null)
{
portStyles.Add(port.Style);
}
}
// clear tags except for group nodes - no one needs them....
foreach (var node in graph.Nodes)
{
if (!Equals("Group Nodes", node.Tag))
{
node.Tag = null;
}
}
foreach (var edge in graph.Edges)
{
edge.Tag = null;
}
}
}
