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