Beispiel #1
0
        private static IconNodeMapData DataToNode(Data data)
        {
            IconNodeMapData node = new IconNodeMapData(data.address);

            if (data.attr0 != null)
            {
                AttributeMapData objAttribute = new AttributeMapData("attr0", data.attr0);
                node.Attributes.Add("attr0", objAttribute);
            }

            if (data.attr1 != null)
            {
                AttributeMapData objAttribute = new AttributeMapData("attr1", data.attr1);
                node.Attributes.Add("attr1", objAttribute);
            }

            if (data.attr2 != null)
            {
                AttributeMapData objAttribute = new AttributeMapData("attr2", data.attr2);
                node.Attributes.Add("attr2", objAttribute);
            }

            if (data.attr3 != null)
            {
                AttributeMapData objAttribute = new AttributeMapData("attr3", data.attr3);
                node.Attributes.Add("attr3", objAttribute);
            }

            if (data.attr4 != null)
            {
                AttributeMapData objAttribute = new AttributeMapData("attr4", data.attr4);
                node.Attributes.Add("attr4", objAttribute);
            }

            if (data.attr5 != null)
            {
                AttributeMapData objAttribute = new AttributeMapData("attr5", data.attr5);
                node.Attributes.Add("attr5", objAttribute);
            }

            if (data.attr6 != null)
            {
                AttributeMapData objAttribute = new AttributeMapData("attr6", data.attr6);
                node.Attributes.Add("attr6", objAttribute);
            }

            if (data.attr7 != null)
            {
                AttributeMapData objAttribute = new AttributeMapData("attr7", data.attr7);
                node.Attributes.Add("attr7", objAttribute);
            }

            if (data.attr8 != null)
            {
                AttributeMapData objAttribute = new AttributeMapData("attr8", data.attr8);
                node.Attributes.Add("attr8", objAttribute);
            }

            return(node);
        }
Beispiel #2
0
        private static IconNodeMapData SeedToNode(string seed)
        {
            string[] splitSeed   = SplitOnFirstColon(seed);
            string   seedType    = splitSeed[0];
            string   seedAddress = splitSeed[1];

            IconNodeMapData seedNode = new IconNodeMapData(seedAddress);

            return(seedNode);
        }
Beispiel #3
0
        public static GraphMapData JsonToGraph(TracWrapper tracWrapper)
        {
            if (tracWrapper == null)
            {
                throw new ArgumentNullException();
            }

            GraphMapData graph = new GraphMapData();

            IconNodeMapData seedNode = SeedToNode(tracWrapper.trac.result.seed);

            graph.Add(seedNode);

            // by definition Data are guaranteed to not have been seen yet
            foreach (Data data in tracWrapper.trac.result.datas)
            {
                IconNodeMapData dataNode = DataToNode(data);
                graph.Add(dataNode);

                EdgeMapData edgeToSeed = new EdgeMapData(seedNode.Id, dataNode.Id);
                graph.Add(edgeToSeed);

                // by definition Contact may have already been seen
                if (data.contacts != null)
                {
                    foreach (Data contact in data.contacts)
                    {
                        if (!contact.address.Equals(seedNode.Id))
                        {
                            NodeMapData contactNode;
                            bool        nodeAlreadyExists = graph.TryGetNode(contact.address, out contactNode);
                            if (!nodeAlreadyExists)
                            {
                                contactNode = DataToNode(contact);
                                graph.Add(contactNode);
                            }

                            EdgeMapData edgeToData = new EdgeMapData(dataNode.Id, contactNode.Id);
                            graph.Add(edgeToData);
                        }
                    }
                }
            }

            return(graph);
        }
Beispiel #4
0
        public static NodeMapData GetNode(NodeViewModelBase uiNodeVM)
        {
            NodeMapData objNode;

            if (uiNodeVM.GetType().Equals(typeof(IconNodeViewModel)))
            {
                objNode = new IconNodeMapData(uiNodeVM.ParentNode.ID);

                // Property
                IconNodeViewModel iconNodeVM = (IconNodeViewModel)uiNodeVM;
                if (iconNodeVM.ImageSource != null)
                {
                    ((IconNodeMapData)objNode).ImageSource = new System.Uri(iconNodeVM.ImageSource, UriKind.Relative);
                }
            }
            else
            {
                objNode = new TextNodeMapData(uiNodeVM.ParentNode.ID);
            }

            // Properties
            objNode.Description = uiNodeVM.Description;
            objNode.Label       = uiNodeVM.DisplayValue;
            Size dimension = new Size(uiNodeVM.Width, uiNodeVM.Height);

            objNode.Dimension       = dimension;
            objNode.Position        = uiNodeVM.Position;
            objNode.IsHidden        = uiNodeVM.IsHidden;
            objNode.BackgroundColor = uiNodeVM.BackgroundColor.Color;
            objNode.SelectionColor  = uiNodeVM.SelectionColor.Color;

            // Attributes
            foreach (KeyValuePair <string, AttributeValue> uiNodeVMAttrKVP in uiNodeVM.ParentNode.Attributes)
            {
                Attributes.Attribute uiNodeVMAttribute = GlobalAttributeCollection.GetInstance(uiNodeVM.Scope).GetAttribute(uiNodeVMAttrKVP.Key);

                AttributeMapData objNodeAttribute = new AttributeMapData(uiNodeVMAttrKVP.Key, uiNodeVMAttrKVP.Value.Value);
                objNode.Attributes.Add(objNodeAttribute.Name, objNodeAttribute);

                objNodeAttribute.SemanticType      = uiNodeVMAttribute.SemanticType;
                objNodeAttribute.SimilarityMeasure = uiNodeVMAttribute.PreferredSimilarityMeasure;
                objNodeAttribute.IsHidden          = !uiNodeVMAttribute.Visible;
            }

            return(objNode);
        }
Beispiel #5
0
        public static GraphMapData AnbToGraph(Chart chart)
        {
            if (chart == null)
            {
                throw new ArgumentNullException();
            }

            GraphMapData graph = new GraphMapData();

            foreach (ChartItem chartItem in chart.chartItemCollection.chartItems)
            {
                if (chartItem.end != null)
                {
                    IconNodeMapData node = new IconNodeMapData(chartItem.end.entity.attrEntityId);
                    graph.Add(node);

                    node.Label = chartItem.attrLabel;

                    SolidColorBrush backgroundColor = Conversion.HexColorToBrush(chartItem.ciStyle.font.attrBackColour);
                    node.BackgroundColor = backgroundColor.Color;

                    foreach (Anb.Attribute attribute in chartItem.attributeCollection.attributes)
                    {
                        AttributeMapData objAttribute = new AttributeMapData(attribute.attrAttributeClass, attribute.attrValue);
                        node.Attributes.Add(objAttribute.Name, objAttribute);
                    }
                }
                else
                {
                    EdgeMapData edge = new EdgeMapData(chartItem.link.attrEnd1Id, chartItem.link.attrEnd2Id);
                    graph.Add(edge);

                    edge.Label = chartItem.link.linkStyle.attrType;
                }
            }

            return(graph);
        }
Beispiel #6
0
        /// <summary>
        /// Adds the specificed node
        /// </summary>
        /// <param name="graphComponents">The Graph that data is being imported into</param>
        /// <param name="creationType">The specified CreationType</param>
        /// <param name="objNode">Node to be added</param>
        public static void AddNode(GraphComponents graphComponents, CreationType creationType, NodeMapData objNode)
        {
            // Create new node
            Node uiNode = new Node(objNode.Id);

            uiNode.SourceMechanism = creationType;

            // TODO as NodeMapData types expands, this needs to be adjusted
            NodeTypes uiNodeType = NodeTypes.Simple;

            if (objNode is IconNodeMapData)
            {
                uiNodeType = NodeTypes.Icon;
            }
            else if (objNode is TextNodeMapData)
            {
                uiNodeType = NodeTypes.Text;
            }

            NodeViewModelBase uiNodeVM = NodeViewModelBase.GetNodeViewModel(uiNodeType, uiNode, graphComponents.Scope);

            // Properties
            if (uiNodeType == NodeTypes.Icon)
            {
                IconNodeMapData objIconNode = (IconNodeMapData)objNode;
                if (objIconNode.ImageSource != null)
                {
                    ((IconNodeViewModel)uiNodeVM).ImageSource = objIconNode.ImageSource.ToString();
                }
            }

            uiNodeVM.Description  = objNode.Description;
            uiNodeVM.DisplayValue = objNode.Label;
            uiNodeVM.Width        = objNode.Dimension.Width;
            uiNodeVM.Height       = objNode.Dimension.Height;
            uiNodeVM.Position     = objNode.Position;
            uiNodeVM.IsHidden     = objNode.IsHidden;

            SolidColorBrush uiBackgroundColorBrush = new SolidColorBrush(objNode.BackgroundColor);

            uiNodeVM.BackgroundColor = uiBackgroundColorBrush;

            SolidColorBrush uiSelectionColorBrush = new SolidColorBrush(objNode.SelectionColor);

            uiNodeVM.SelectionColor = uiSelectionColorBrush;

            if (uiNodeVM.Height == 0)
            {
                uiNodeVM.Height = 45;
            }

            if (uiNodeVM.Width == 0)
            {
                uiNodeVM.Width = 45;
            }

            // Add the node to the graph
            graphComponents.AddNodeViewModel(uiNodeVM);

            // Attributes
            foreach (KeyValuePair <string, AttributeMapData> objNodeAttrKVP in objNode.Attributes)
            {
                Attributes.Attribute uiNodeAttribute      = new Attributes.Attribute(objNodeAttrKVP.Value.Name);
                AttributeValue       uiNodeAttributeValue = new AttributeValue(objNodeAttrKVP.Value.Value);

                uiNode.Attributes.Add(uiNodeAttribute.Name, uiNodeAttributeValue);
                GlobalAttributeCollection.GetInstance(graphComponents.Scope).Add(uiNodeAttribute, uiNodeAttributeValue);

                uiNodeAttribute.SemanticType = objNodeAttrKVP.Value.SemanticType;
                uiNodeAttribute.PreferredSimilarityMeasure = objNodeAttrKVP.Value.SimilarityMeasure;
                uiNodeAttribute.Visible = !objNodeAttrKVP.Value.IsHidden;
            }
        }
Beispiel #7
0
        /*/// <summary>
         * /// Gets the default edge type (direction) to be used in the
         * /// event that the 'directed' attribute of an edge is not included
         * /// </summary>
         * /// <param name="defaultEdgeType">The value of the edgedefault attribute</param>
         * private static GraphType GetDefaultEdgeType(string defaultEdgeType)
         * {
         *  GraphType determinedEdgeType = GraphType.Undirected;
         *
         *  if (defaultEdgeType != null && defaultEdgeType.ToLower().Equals("directed"))
         *  {
         *      determinedEdgeType = GraphType.Directed;
         *  }
         *
         *  return determinedEdgeType;
         * }*/

        /// <summary>
        /// Reads an XML node from the specified XmlReader
        /// </summary>
        /// <param name="reader">Reader from which to read the node from</param>
        private NodeMapData ReadNode(XmlReader reader, NodeTypes defaultNodeType)
        {
            NodeMapData objNode;

            string nodeId = reader.GetAttribute("id");

            if (defaultNodeType == NodeTypes.Icon)
            {
                objNode = new IconNodeMapData(nodeId);
            }
            else
            {
                objNode = new TextNodeMapData(nodeId);
            }

            if (reader.ReadToDescendant("data"))
            {
                Attributes.Attribute newAttribute      = null;
                AttributeValue       newAttributeValue = null;

                // Loop over all data elements.  These are the attributes
                do
                {
                    // Record the attributes
                    string dataKey   = reader.GetAttribute("key");
                    string dataValue = reader.ReadElementContentAsString();

                    // Determine if we are dealing with a node property
                    if (dataKey.StartsWith(NODE_PROPERTY_PREFIX))
                    {
                        string propName = dataKey.Substring(NODE_PROPERTY_PREFIX.Length);
                        switch (propName)
                        {
                        case "Description":
                            objNode.Description = dataValue;
                            break;

                        case "DisplayValue":
                            objNode.Label = dataValue;
                            break;

                        case "SelectionColor":
                            SolidColorBrush selectionColor = Conversion.HexColorToBrush(dataValue);
                            objNode.SelectionColor = selectionColor.Color;
                            break;

                        case "ImageSource":
                            ((IconNodeMapData)objNode).ImageSource = new Uri(dataValue, UriKind.RelativeOrAbsolute);
                            break;

                        case "Height":
                            double height = double.Parse(dataValue);
                            objNode.Dimension = new Size(objNode.Dimension.Width, height);
                            break;

                        case "Width":
                            double width = double.Parse(dataValue);
                            objNode.Dimension = new Size(width, objNode.Dimension.Height);
                            break;

                        case "Position":
                            string[] splitPosition = dataValue.Split(',');
                            objNode.Position = new Point(double.Parse(splitPosition[0]), double.Parse(splitPosition[1]));
                            break;

                        case "IsHidden":
                            objNode.IsHidden = bool.Parse(dataValue);
                            break;

                        case "BackgroundColor":
                            SolidColorBrush backgroundColor = Conversion.HexColorToBrush(dataValue);
                            objNode.BackgroundColor = backgroundColor.Color;
                            break;

                        default:
                            // TODO prop is for a different version of SnagL
                            break;
                        }

                        // TODO do we only want to do whats above when what is commented out below fails?

                        /*// Attempt to set the node propety
                         * if ((SetExportablePropertyValue(dataKey, objNode, dataValue)))
                         *  _logger.WriteLogEntry(LogLevel.INFO, string.Format("The Node property [{0}] was set to '{1}'", dataKey, dataValue), null, null);
                         * else
                         * {
                         *  // The property might be for the view model so try
                         *  // and set the view model
                         *  if ((SetExportablePropertyValue(dataKey, objNode, dataValue)))
                         *      _logger.WriteLogEntry(LogLevel.INFO, string.Format("The NodeVM property [{0}] was set to '{1}'", dataKey, dataValue), null, null);
                         *  else
                         *      _logger.WriteLogEntry(LogLevel.ERROR, string.Format("Unable to set the property [{0}] to the specified value [{1}]", dataKey, dataValue), null, null);
                         * }*/
                    }
                    else // Determine if we are dealing with an attribute
                    {
                        if (dataKey.StartsWith(NODE_ATTRIBUTE_PREFIX))
                        {
                            // Determine if we are dealing with a descriptor or a value
                            if (dataKey.EndsWith(ATTRIBUTE_DESCRIPTOR_SUFFIX))
                            {
                                newAttribute = CreateAttribute(dataValue);
                            }
                            else if (dataKey.EndsWith(ATTRIBUTE_VALUE_SUFFIX))
                            {
                                newAttributeValue = new AttributeValue(dataValue);
                            }
                        }
                        else // If we are here, we are not dealing with SnagL formatted GraphML
                        {
                            // We are dealing with an unknown data element so we
                            // are going to treat it like a new attribute
                            // Determine if we are dealing with a descriptor or a value
                            newAttribute      = new Attributes.Attribute(dataKey);
                            newAttributeValue = new AttributeValue(dataValue);
                        }

                        // Check if we have a valid Attribute and AttributeValue class
                        if (newAttribute != null && newAttributeValue != null)
                        {
                            AttributeMapData objAttribute = new AttributeMapData(newAttribute.Name, newAttributeValue.Value);
                            objNode.Attributes.Add(objAttribute.Name, objAttribute);

                            objAttribute.SemanticType      = newAttribute.SemanticType;
                            objAttribute.SimilarityMeasure = newAttribute.PreferredSimilarityMeasure;
                            objAttribute.IsHidden          = !newAttribute.Visible;

                            newAttribute      = null;
                            newAttributeValue = null;
                        }
                    }
                } while (reader.LocalName == "data" || (string.IsNullOrEmpty(reader.LocalName) && reader.ReadToNextSibling("data")));
            }

            return(objNode);
        }