public IEnumerable<NetworkNode> this[NetworkEdgeType edgeType] { get { return GetNetworkNodes(edgeType); } }
public IEnumerable<NetworkNode> this[NetworkEdgeType edgeType] { get { return _networkNode.OutgoingEdges.GetEdges(edgeType, true).Select(edge => edge.EndNode); } }
private List<NetworkNode> GetNetworkNodes(NetworkEdgeType edgeType) { List<NetworkNode> networkNodes; if (!_dictionary.TryGetValue(edgeType, out networkNodes)) { networkNodes = new List<NetworkNode>(); _dictionary[edgeType] = networkNodes; } return networkNodes; }
public void Add(NetworkEdgeType edgeType, IEnumerable<NetworkNode> networkNodes) { Contract.Requires<ArgumentNullException>(networkNodes != null); List<NetworkNode> dictionaryList = GetNetworkNodes(edgeType); foreach (NetworkNode node in networkNodes) { if (!dictionaryList.Contains(node)) { dictionaryList.Add(node); } } }
public static NetworkEdge GetEdge(this IEnumerable<NetworkEdge> networkEdges, NetworkEdgeType edgeType, bool recursively) { NetworkEdge foundEdge = GetEdge(networkEdges, edgeType); if (foundEdge == null && recursively) { List<NetworkEdge> result = new List<NetworkEdge>(); GetParentEdges(networkEdges, (edge) => edge.Type == edgeType, false, result); foundEdge = result.FirstOrDefault(); } return foundEdge; }
public static IEnumerable<NetworkEdge> GetEdges(this IEnumerable<NetworkEdge> networkEdges, NetworkEdgeType edgeType, bool recursively) { var foundEdges = GetEdges(networkEdges, edgeType); if (!foundEdges.Any() && recursively) { List<NetworkEdge> result = new List<NetworkEdge>(); GetParentEdges(networkEdges, (edge) => edge.Type == edgeType, true, result); foundEdges = result; } return foundEdges; }
public MainWindow() { InitializeComponent(); _project = new Project(); _project.Diagram = DiagramNetwork; _project.PropertyChanged += new System.ComponentModel.PropertyChangedEventHandler(_project_PropertyChanged); DiagramNetwork.IsEnabled = _project.Network != null; //ButtonViewShowPropsPanel.IsChecked = this.PanelProps.Visibility == Visibility.Visible; //DispatcherPanelButton.IsChecked = this.DispatcherPanel.Visibility == System.Windows.Visibility.Visible; DispatcherPanel.SelectionChanged += new OnSelectionChanged(DispatcherPanel_SelectionChanged); _updatingDiagramSelection = false; _currentType = NetworkEdgeType.IsA; AssignNetwork(); }
/// <summary> /// Создает новую дугу сети. /// </summary> /// <param name="parent">Сеть, которой должна принадлежать дуга.</param> /// <param name="startNode">Вершина, из которой должна исходить данная дуга.</param> /// <param name="endNode">Вершина, в которую должна входить данная дуга.</param> /// <param name="edgeType">Тип дуги.</param> protected internal NetworkEdge(Network parent, NetworkNode startNode, NetworkNode endNode, NetworkEdgeType edgeType) : base(parent) { if (startNode == null) { throw new ArgumentNullException("startNode"); } if (endNode == null) { throw new ArgumentNullException("endNode"); } if (startNode == null) { throw new ArgumentNullException("startNode"); } _startNode = startNode; _endNode = endNode; _edgeType = edgeType; }
public static string ConvertToResourcesType(NetworkEdgeType type) { string res = ""; switch (type) { case NetworkEdgeType.IsA: res = Properties.Resources.IsAResourceLabel; break; case NetworkEdgeType.Agent: res = Properties.Resources.AgentResourceLabel; break; case NetworkEdgeType.Recipient: res = Properties.Resources.RecipientResourceLabel; break; case NetworkEdgeType.Locative: res = Properties.Resources.LocativeResourceLabel; break; case NetworkEdgeType.Follow: res = Properties.Resources.FollowResourceLabel; break; case NetworkEdgeType.Goal: res = Properties.Resources.GoalResourceLabel; break; case NetworkEdgeType.IsInstance: res = Properties.Resources.IsInstanceResourceLabel; break; case NetworkEdgeType.Template: res = Properties.Resources.TemlateResourceLabel; break; case NetworkEdgeType.PartOf: res = Properties.Resources.PartOfResourceLabell; break; } return res; }
public IEnumerable<NetworkEdge> GetTypedIncomingEdges(NetworkEdgeType type) { return GetTypedEdges(type, IncomingEdges); }
public NetworkEdge GetTypedIncomingEdge(NetworkEdgeType type) { return GetTypedEdge(type, IncomingEdges); }
private void MenuItemType_Click(object sender, RoutedEventArgs e) { MenuItem source = e.Source as MenuItem; if (source == null) return; MenuItem category = source.Parent as MenuItem; foreach (MenuItem item in category.Items) { item.IsChecked = false; } source.IsChecked = true; NetworkEdgeType type = Utils.ConvertType(source.Header.ToString()); NetworkEdge edge = GetNetworkObjectFromMenuItem(source) as NetworkEdge; if (edge != null) { try { edge.Type = type; _currentType = type; } catch (Exception ex) { ShowErrorMessage(ex.Message); } } }
public void Add(NetworkEdgeType edgeType, params NetworkNode[] networkNodes) { Add(edgeType, (IEnumerable<NetworkNode>)networkNodes); }
internal static IEnumerable<NetworkEdge> GetTypedEdges(NetworkEdgeType type, IEnumerable<NetworkEdge> edges) { List<NetworkEdge> result = new List<NetworkEdge>(); foreach (NetworkEdge edge in edges) { if (edge.Type == type) result.Add(edge); } return result; }
internal static bool HasTypedEdges(NetworkEdgeType type, IEnumerable<NetworkEdge> collection) { bool result = false; foreach (NetworkEdge edge in collection) { if (edge.Type == type) result = true; } return result; }
public bool HasTypedOutgoingEdges(NetworkEdgeType type) { return HasTypedEdges(type, OutgoingEdges); }
public IEnumerable<NetworkNode> GetTypedOutgoingLinkedNodes(NetworkEdgeType type) { return GetTypedLinkedNodes(type, OutgoingEdges); }
public NetworkEdge GetTypedOutgoingEdge(NetworkEdgeType type) { return GetTypedEdge(type, OutgoingEdges); }
public static IEnumerable<NetworkEdge> GetEdges(this IEnumerable<NetworkEdge> networkEdges, NetworkEdgeType edgeType) { return networkEdges.Where(edge => edge.Type == edgeType); }
public static NetworkEdge GetEdge(this IEnumerable<NetworkEdge> networkEdges, NetworkEdgeType edgeType) { return networkEdges.FirstOrDefault(edge => edge.Type == edgeType); }
public IEnumerable<NetworkEdge> GetTypedOutGoingEdges(NetworkEdgeType type) { return GetTypedEdges(type, OutgoingEdges); }
public override void LoadFromXml(XElement xNetworkEdge) { if (xNetworkEdge == null) { throw new ArgumentNullException("xNetworkEdge"); } base.LoadFromXml(xNetworkEdge); XAttribute xEdgeTypeAttribute = xNetworkEdge.Attribute("type"); XAttribute xStartNodeIdAttribute = xNetworkEdge.Attribute("startNodeId"); XAttribute xEndNodeIdAttribute = xNetworkEdge.Attribute("endNodeId"); if (xEdgeTypeAttribute == null || xStartNodeIdAttribute == null || xEndNodeIdAttribute == null) { throw new SerializationException(); } NetworkEdgeType edgeType; int startNodeId; int endNodeId; if (!Enum.TryParse<NetworkEdgeType>(xEdgeTypeAttribute.Value, out edgeType) || !Int32.TryParse(xStartNodeIdAttribute.Value, out startNodeId) || !Int32.TryParse(xEndNodeIdAttribute.Value, NumberStyles.Integer, CultureInfo.InvariantCulture, out endNodeId)) { throw new SerializationException(); } _startNode = Network.Nodes.SingleOrDefault(node => node.Id == startNodeId); _endNode= Network.Nodes.SingleOrDefault(node => node.Id == endNodeId); _edgeType = edgeType; if (_startNode == null || _endNode == null) { throw new SerializationException(); } }
public bool HasTypedIncomingEdges(NetworkEdgeType type) { return HasTypedEdges(type, IncomingEdges); }
private void GetChildContextNode( IDictionary<FunctionNode, TemplateParserResult> parserResults, TaleNode currentTaleNode, FunctionNode baseFunctionNode, NetworkEdgeType edgeType, TemplateParserDictionaryContext newParserContext) { TemplateParserResult baseFunctionNodeParserResult = parserResults[baseFunctionNode]; var currentTaleContextNodes = new List<NetworkNode>(); var baseTaleContextNodes = baseFunctionNode.OutgoingEdges.GetEdges(edgeType).Select(edge => edge.EndNode); bool found = false; foreach (FunctionNode functionNode in currentTaleNode.Functions) { currentTaleContextNodes.AddRange(functionNode.OutgoingEdges.GetEdges(edgeType).Select(edge => edge.EndNode)); } foreach (NetworkNode baseTaleContextNode in baseTaleContextNodes) { if (currentTaleContextNodes.Any(node => node.IsInherit(baseTaleContextNode, false))) { NetworkNode currentNode = null; while (true) { NetworkEdge isAEdge = baseTaleContextNode.OutgoingEdges.GetEdge(NetworkEdgeType.IsA); if (isAEdge != null) { currentNode = isAEdge.StartNode; NetworkNode childNode = currentTaleContextNodes.FirstOrDefault(node => node == currentNode || node.BaseNode == currentNode); if (childNode != null) { found = true; newParserContext.Add(edgeType, childNode); break; } } if (isAEdge == null && currentNode != null) { found = true; newParserContext.Add(edgeType, currentNode); break; } } } } if (!found) { newParserContext.Add(edgeType, baseTaleContextNodes); } }
internal static NetworkEdge GetTypedEdge(NetworkEdgeType type, IEnumerable<NetworkEdge> edges) { NetworkEdge result = null; foreach(NetworkEdge edge in edges) { if (type == edge.Type) { result = edge; break; } } return result; }
private void ChooseLinkType_Executed(object sender, ExecutedRoutedEventArgs e) { if (e.Parameter != null) { NetworkEdgeType type = Utils.ConvertType(e.Parameter as string); if (DiagramNetwork.Selection.Items.Count == 1 && (DiagramNetwork.Selection.Items[0] as DiagramLink != null)) { DiagramLink link = DiagramNetwork.Selection.Items[0] as DiagramLink; NetworkEdge edge = _project.Network.Edges.FindById(Convert.ToInt32(link.Uid)); try { edge.Type = type; } catch (Exception ex) { ShowErrorMessage(ex.Message); } } _currentType = type; } }
internal static IEnumerable<NetworkNode> GetTypedLinkedNodes(NetworkEdgeType type, IEnumerable<NetworkEdge> colletion) { List<NetworkNode> result = new List<NetworkNode>(); foreach (NetworkEdge edge in colletion) { if (edge.Type == type) result.Add(edge.StartNode); } return result; }
private void DiagramNetwork_LinkSelected(object sender, LinkEventArgs e) { if (DiagramNetwork.Selection.Items.Count > 1) return; DiagramLink link = e.Link; if (link == null) return; Network network = _project.Network; if (network == null) return; NetworkEdge edge = network.Edges.FindById(Int32.Parse(link.Uid)); //PanelProps.Edge = edge; if (edge == null) return; _currentType = edge.Type; //edge.PropertyChanged += new System.ComponentModel.PropertyChangedEventHandler(edge_PropertyChanged); }
private void UpdateContextNode(NetworkEdgeType edgeType, string value) { NetworkEdge networkEdge = OutgoingEdges.GetEdge(edgeType); if (networkEdge == null) { if (value != null) { TaleItemNode node = new TaleItemNode((TalesNetwork)Network, value); Network.Nodes.Add(node); Network.Edges.Add(this, node, edgeType); NetworkNode baseNode = null; switch (edgeType) { case NetworkEdgeType.Action: baseNode = ((TalesNetwork)Network).BaseAction; break; case NetworkEdgeType.Template: baseNode = ((TalesNetwork)Network).BaseTemplate; break; } Network.Edges.Add(node, baseNode, NetworkEdgeType.IsA); } } else { if (value == null) { Network.Nodes.Remove(networkEdge.EndNode); Network.Edges.Remove(networkEdge); } else { networkEdge.EndNode.Name = value; } } }
public static void UpdateEdgeStyleFromType(DiagramEdge edge, NetworkEdgeType type) { if (edge != null) { edge.Label.Text = Utils.ConvertType(type); edge.Label.AllowInPlaceEdit = false; Style style = new Style(); Setter setter = new Setter(); string str; switch (type) { case NetworkEdgeType.Agent: str = "Agent"; break; case NetworkEdgeType.Recipient: str = "Recipient"; break; case NetworkEdgeType.Goal: str = "Goal"; break; case NetworkEdgeType.Locative: str = "Locative"; break; case NetworkEdgeType.Follow: str = "Follow"; break; case NetworkEdgeType.IsInstance: str = "IsInstance"; break; case NetworkEdgeType.Template: str = "Template"; break; case NetworkEdgeType.PartOf: str = "PartOf"; break; default: str = "IsA"; break; } SolidColorBrush brush = App.Current.TryFindResource(str + "Brush") as SolidColorBrush; Pen pen = App.Current.FindResource(str + "Pen") as Pen; edge.BorderPen = pen; edge.Background = brush; edge.Label.Foreground = brush; edge.Label.FontWeight = FontWeights.Bold; } }