Example #1
0
        private void OnUpdateNodeMetadataCompletedNodeArgs(object sender, ReturnedNodesEventArgs e)
        {
            NodesEventArgs nodesEventArgs = new NodesEventArgs(null, e.SearchedNode, e.Nodes);

            if (UpdateNodeMetadataCompleted != null)
            {
                UpdateNodeMetadataCompleted.Invoke(this, nodesEventArgs);
            }
        }
        //private void OnGetNodesWithConditionsCompleted(object sender, GetNodesWithConditionsCompletedEventArgs e)
        //{
        //    if (e.Error == null)
        //    {
        //        List<INodeProxy> nodes = BuildNodeList(e.Result);

        //        ReturnedNodesEventArgs eventArgs = new ReturnedNodesEventArgs(e.Result.SearchedNode, nodes.ToArray());

        //        if (GetNodesWithConditionsCompleted != null)
        //        {
        //            GetNodesWithConditionsCompleted.Invoke(this, eventArgs);
        //        }
        //    }
        //}

        private void OnGetRelatedNodesByIdAsyncCompleted(object sender, GetRelatedNodesCompletedEventArgs e)
        {
            if (e.Error == null)
            {
                List <INodeProxy> nodes = BuildNodeList(e.Result);

                ReturnedNodesEventArgs eventArgs = new ReturnedNodesEventArgs(e.Result.SearchedNode, nodes.ToArray());

                if (GetRelatedNodesByIdCompleted != null)
                {
                    GetRelatedNodesByIdCompleted.Invoke(this, eventArgs);
                }
            }
        }
        private void OnCreateNewDomainCompleted(object sender, CreateNewDomainCompletedEventArgs e)
        {
            if (e.Error == null)
            {
                SoapNode domainNode = e.Result;

                ReturnedNodesEventArgs eventArgs = new ReturnedNodesEventArgs();
                eventArgs.SearchedNode = e.Result.Domain;
                eventArgs.Nodes        = new INodeProxy[] { new NodeProxy(e.Result) };

                if (CreateNewDomainCompleted != null)
                {
                    CreateNewDomainCompleted.Invoke(this, eventArgs);
                }
            }
        }
        private void GetNodeByIdAsyncCompleted(object sender, GetNodesCompletedEventArgs e)
        {
            List<INodeProxy> nodes = new List<INodeProxy>();
            
            foreach (SoapNode soapNode in e.Result.Values)
            {
                NodeProxy node = new NodeProxy(soapNode);

                nodes.Add(node);
                _cachedNodes.Add(node.Id, node);
            }

            ReturnedNodesEventArgs eventArgs = new ReturnedNodesEventArgs(null, nodes.ToArray());

            if (GetNodeByIdCompleted != null)
            {
                GetNodeByIdCompleted.Invoke(this, eventArgs);
            }
        }
Example #5
0
        private void GetNodeByIdAsyncCompleted(object sender, GetNodesCompletedEventArgs e)
        {
            List <INodeProxy> nodes = new List <INodeProxy>();

            foreach (SoapNode soapNode in e.Result.Values)
            {
                NodeProxy node = new NodeProxy(soapNode);

                nodes.Add(node);
                _cachedNodes.Add(node.Id, node);
            }

            ReturnedNodesEventArgs eventArgs = new ReturnedNodesEventArgs(null, nodes.ToArray());

            if (GetNodeByIdCompleted != null)
            {
                GetNodeByIdCompleted.Invoke(this, eventArgs);
            }
        }
        private void OnUpdateNodeMetadataCompleted(object sender, UpdateNodeMetadataCompletedEventArgs e)
        {
            if (e.Error == null)
            {
                if (_cachedNodes.ContainsKey(e.Result.Id))
                {
                    _cachedNodes.Remove(e.Result.Id);
                }

                NodeProxy node = new NodeProxy(e.Result);
                _cachedNodes.Add(e.Result.Id, node);

                ReturnedNodesEventArgs returnedNodesEventArgs = new ReturnedNodesEventArgs();
                returnedNodesEventArgs.Nodes = new INodeProxy[] { node };

                if (UpdateNodeMetadataCompleted != null)
                {
                    UpdateNodeMetadataCompleted.Invoke(this, returnedNodesEventArgs);
                }
            }
        }
        public void GetNodeByIdAsync(Guid nodeId, Guid mapId)
        {
            if (_cachedNodes.ContainsKey(nodeId))
            {
                ReturnedNodesEventArgs returnedNodesEventArgs = new ReturnedNodesEventArgs();
                List <INodeProxy>      returnedNodes          = new List <INodeProxy>();
                returnedNodes.Add(_cachedNodes[nodeId]);
                returnedNodesEventArgs.Nodes = returnedNodes.ToArray();

                if (GetNodeByIdCompleted != null)
                {
                    GetNodeByIdCompleted.Invoke(this, returnedNodesEventArgs);
                }
            }
            else
            {
                Dictionary <Guid, Guid> nodes = new Dictionary <Guid, Guid>();
                nodes.Add(nodeId, mapId);

                Client.GetNodesAsync(nodes);
            }
        }
Example #8
0
        public void GetRelatedNodesByIdAsync(string mapId, string nodeId, int depth)
        {
            if (_localNewNodes.ContainsKey(nodeId))
            {
                ReturnedNodesEventArgs returnedNodesEventArgs = new ReturnedNodesEventArgs();
                List <INodeProxy>      returnedNodes          = new List <INodeProxy>();
                returnedNodes.Add(_localNewNodes[nodeId]);
                returnedNodes.AddRange(_localNewNodes[nodeId].ParentNodes);
                returnedNodes.AddRange(_localNewNodes[nodeId].ChildNodes);
                returnedNodesEventArgs.SearchedNode = _localNewNodes[nodeId];
                returnedNodesEventArgs.Nodes        = returnedNodes.ToArray();

                if (GetRelatedNodesByIdCompleted != null)
                {
                    GetRelatedNodesByIdCompleted.Invoke(this, returnedNodesEventArgs);
                }
            }
            else
            {
                _client = Client;
                _client.GetRelatedNodesAsync(mapId, nodeId, depth);
            }
        }
Example #9
0
        private void OnGetMapsNodesCompletedNodeArgs(object sender, ReturnedNodesEventArgs e)
        {
            INodeProxy        focalNode     = FocalNode;
            List <INodeProxy> filteredNodes = FiltersResults(e.Nodes);

            CompleteRelationshipLinks(filteredNodes);
            List <INodeProxy> nodes = new List <INodeProxy>();

            foreach (INodeProxy nodeProxy in filteredNodes)
            {
                if (nodeProxy.Id == FocalNodeId)
                {
                    //Set the focal node if this is the main node in focus
                    FocalNode = nodeProxy;
                    focalNode = FocalNode;
                }
                else
                {
                    nodes.Add(nodeProxy);
                }
                if (nodeProxy.ParentMapNodeUid != FocalNodeId)
                {
                    nodeProxy.IsTransclusion = true;
                }
                else
                {
                    nodeProxy.IsTransclusion = false;
                }
            }

            NodesEventArgs nodesEventArgs = new NodesEventArgs(null, focalNode, nodes.ToArray());

            if (GetCurrentNodesCompleted != null)
            {
                GetCurrentNodesCompleted.Invoke(this, nodesEventArgs);
            }
        }
        public void GetNodeByIdAsync(Guid nodeId, Guid mapId)
        {
            if (_cachedNodes.ContainsKey(nodeId))
            {
                ReturnedNodesEventArgs returnedNodesEventArgs = new ReturnedNodesEventArgs();
                List<INodeProxy> returnedNodes = new List<INodeProxy>();
                returnedNodes.Add(_cachedNodes[nodeId]);
                returnedNodesEventArgs.Nodes = returnedNodes.ToArray();

                if (GetNodeByIdCompleted != null)
                {
                    GetNodeByIdCompleted.Invoke(this, returnedNodesEventArgs);
                }
            }
            else
            {
                Dictionary<Guid, Guid> nodes = new Dictionary<Guid, Guid>();
                nodes.Add(nodeId, mapId);

                Client.GetNodesAsync(nodes);
            }
        }
Example #11
0
        private void OnGetMapsNodesCompletedNodeArgs(object sender, ReturnedNodesEventArgs e)
        {
            INodeProxy focalNode = FocalNode;
            List<INodeProxy> filteredNodes = FiltersResults(e.Nodes);
            CompleteRelationshipLinks(filteredNodes);
            List<INodeProxy> nodes = new List<INodeProxy>();

            foreach (INodeProxy nodeProxy in filteredNodes)
            {
                if (nodeProxy.Id == FocalNodeId)
                {
                    //Set the focal node if this is the main node in focus
                    FocalNode = nodeProxy;
                    focalNode = FocalNode;
                }
                else
                {
                    nodes.Add(nodeProxy);
                }
                if (nodeProxy.ParentMapNodeUid != FocalNodeId)
                {
                    nodeProxy.IsTransclusion = true;
                }
                else
                {
                    nodeProxy.IsTransclusion = false;
                }
            }

            NodesEventArgs nodesEventArgs = new NodesEventArgs(null, focalNode, nodes.ToArray());

            if (GetCurrentNodesCompleted != null)
            {
                GetCurrentNodesCompleted.Invoke(this, nodesEventArgs);
            }
        }
        private void OnCreateNewDomainCompleted(object sender, CreateNewDomainCompletedEventArgs e)
        {
            if (e.Error == null)
            {
                SoapNode domainNode = e.Result;

                ReturnedNodesEventArgs eventArgs = new ReturnedNodesEventArgs();
                eventArgs.SearchedNode = e.Result.Domain;
                eventArgs.Nodes = new INodeProxy[] { new NodeProxy(e.Result) };

                if (CreateNewDomainCompleted != null)
                {
                    CreateNewDomainCompleted.Invoke(this, eventArgs);
                }
            }
        }
        private void OnGetRelatedNodesByIdCompleted(object sender, ReturnedNodesEventArgs e)
        {
            int count  = 0;
            int length = e.Nodes.Length - 1;

            if (Views.ContainsKey(FocalNodeId))
            {
                CurrentView = Views[FocalNodeId];
            }
            else
            {
                CurrentView = new NavigatorView();

                Views.Add(FocalNodeId, CurrentView);

                SingleDepthNodeRenderer focalNodeRenderer = null;

                foreach (INodeProxy nodeProxy in e.Nodes)
                {
                    if (nodeProxy.Id == FocalNodeId)
                    {
                        if (FocalNode == null)
                        {
                            FocalNode = nodeProxy;

                            focalNodeRenderer = new SingleDepthNodeRenderer(CurrentView, FocalNode, ThemeManagementObject, "Focal");

                            CurrentView.NodeRenderers.Add(focalNodeRenderer.Node.Id, focalNodeRenderer);

                            focalNodeRenderer.NodePositionUpdating += new EventHandler(OnNodePositionUpdating);
                            focalNodeRenderer.NodeDoubleClicked    += new EventHandler <NodeClickedArgs>(OnNodeDoubleClicked);
                        }
                    }
                    else
                    {
                        SingleDepthNodeRenderer nodeRenderer = new SingleDepthNodeRenderer(CurrentView, nodeProxy, ThemeManagementObject, "Default");

                        nodeRenderer.NodeIndex = count;
                        nodeRenderer.NodeCount = length;

                        CurrentView.NodeRenderers.Add(nodeRenderer.Node.Id, nodeRenderer);

                        nodeRenderer.NodePositionUpdating += new EventHandler(OnNodePositionUpdating);
                        nodeRenderer.NodeDoubleClicked    += new EventHandler <NodeClickedArgs>(OnNodeDoubleClicked);

                        count++;
                    }
                }

                if (focalNodeRenderer == null)
                {
                    return;
                }

                foreach (INodeRenderer nodeRenderer in CurrentView.NodeRenderers.Values)
                {
                    foreach (IDescriptorProxy descriptor in nodeRenderer.Node.Descriptors)
                    {
                        if (!CurrentView.RelationshipRenderers.ContainsKey(descriptor.Relationship.Id))
                        {
                            bool relationshipIsPresent = true;

                            foreach (IDescriptorProxy alternateDescriptor in descriptor.Relationship.Descriptors)
                            {
                                if (!CurrentView.NodeRenderers.ContainsKey(alternateDescriptor.Node.Id))
                                {
                                    relationshipIsPresent = false;
                                    break;
                                }
                            }

                            if (relationshipIsPresent)
                            {
                                ImprovedArrow arrow = new ImprovedArrow(CurrentView, descriptor.Relationship);

                                CurrentView.RelationshipRenderers.Add(descriptor.Relationship.Id, arrow);
                            }
                        }
                    }
                }
            }

            RendererNodesEventArgs rendererNodesEventArgs = new RendererNodesEventArgs(CurrentView);

            if (GetCurrentNodesCompleted != null)
            {
                GetCurrentNodesCompleted.Invoke(sender, rendererNodesEventArgs);
            }
        }
        private void GetRelatedNodesByIdAsyncCompleted(object sender, GetRelatedNodesCompletedEventArgs e)
        {
            if (e.Error == null)
            {
                List<INodeProxy> nodes = new List<INodeProxy>();
                
                foreach (SoapNode soapNode in e.Result.RelatedNodes.Values)
                {
                    if (!_cachedNodes.ContainsKey(soapNode.Id))
                    {
                        NodeProxy node = new NodeProxy(soapNode);
                        _cachedNodes.Add(soapNode.Id, node);
                    }
                }

                foreach (SoapNode soapNode in e.Result.RelatedNodes.Values)
                {
                    INodeProxy node = _cachedNodes[soapNode.Id];

                    foreach (SoapRelationship relationship in soapNode.Relationships)
                    {
                        RelationshipProxy relationshipProxy = new RelationshipProxy(relationship);

                        foreach (DescriptorProxy descriptor in relationshipProxy.Descriptors)
                        {
                            if (_cachedNodes.ContainsKey(descriptor.NodeId))
                            {
                                INodeProxy connectedNode = _cachedNodes[descriptor.NodeId];

                                if (!connectedNode.Descriptors.Contains(descriptor))
                                {
                                    descriptor.Node = connectedNode;

                                    connectedNode.Descriptors.Add(descriptor);
                                }
                            }
                        }
                    }
                }

                INodeProxy nodeProxy = _cachedNodes[e.Result.SearchedNode.Id];
                nodes.Add(nodeProxy);

                foreach (INodeProxy np in _localNewNodes.Values)
                {
                    nodes.Add(np);
                }

                foreach (IDescriptorProxy descriptor in nodeProxy.Descriptors)
                {
                    foreach (IDescriptorProxy alternateDescriptor in descriptor.Relationship.Descriptors)
                    {
                        if (!nodes.Contains(alternateDescriptor.Node))
                        {
                            nodes.Add(alternateDescriptor.Node);
                        }
                    }
                }

                INodeProxy searchedNode = new NodeProxy(e.Result.SearchedNode);

                ReturnedNodesEventArgs eventArgs = new ReturnedNodesEventArgs(searchedNode, nodes.ToArray());

                if (GetRelatedNodesByIdCompleted != null)
                {
                    GetRelatedNodesByIdCompleted.Invoke(this, eventArgs);
                }
            }
        }
        public void GetRelatedNodesByIdAsync(string mapId, string nodeId, int depth)
        {
            if (_localNewNodes.ContainsKey(nodeId))
            {
                ReturnedNodesEventArgs returnedNodesEventArgs = new ReturnedNodesEventArgs();
                List<INodeProxy> returnedNodes = new List<INodeProxy>();
                returnedNodes.Add(_localNewNodes[nodeId]);
                returnedNodes.AddRange(_localNewNodes[nodeId].ParentNodes);
                returnedNodes.AddRange(_localNewNodes[nodeId].ChildNodes);
                returnedNodesEventArgs.SearchedNode = _localNewNodes[nodeId];
                returnedNodesEventArgs.Nodes = returnedNodes.ToArray();

                if (GetRelatedNodesByIdCompleted != null)
                {
                    GetRelatedNodesByIdCompleted.Invoke(this, returnedNodesEventArgs);
                }
            }
            else
            {
                _client = Client;
                _client.GetRelatedNodesAsync(mapId, nodeId, depth);
            }
        }
Example #16
0
        private void GetRelatedNodesByIdAsyncCompleted(object sender, GetRelatedNodesCompletedEventArgs e)
        {
            if (e.Error == null)
            {
                List <INodeProxy> nodes = new List <INodeProxy>();

                foreach (SoapNode soapNode in e.Result.RelatedNodes.Values)
                {
                    if (!_cachedNodes.ContainsKey(soapNode.Id))
                    {
                        NodeProxy node = new NodeProxy(soapNode);
                        _cachedNodes.Add(soapNode.Id, node);
                    }
                }

                foreach (SoapNode soapNode in e.Result.RelatedNodes.Values)
                {
                    INodeProxy node = _cachedNodes[soapNode.Id];

                    foreach (SoapRelationship relationship in soapNode.Relationships)
                    {
                        RelationshipProxy relationshipProxy = new RelationshipProxy(relationship);

                        foreach (DescriptorProxy descriptor in relationshipProxy.Descriptors)
                        {
                            if (_cachedNodes.ContainsKey(descriptor.NodeId))
                            {
                                INodeProxy connectedNode = _cachedNodes[descriptor.NodeId];

                                if (!connectedNode.Descriptors.Contains(descriptor))
                                {
                                    descriptor.Node = connectedNode;

                                    connectedNode.Descriptors.Add(descriptor);
                                }
                            }
                        }
                    }
                }

                INodeProxy nodeProxy = _cachedNodes[e.Result.SearchedNode.Id];
                nodes.Add(nodeProxy);

                foreach (INodeProxy np in _localNewNodes.Values)
                {
                    nodes.Add(np);
                }

                foreach (IDescriptorProxy descriptor in nodeProxy.Descriptors)
                {
                    foreach (IDescriptorProxy alternateDescriptor in descriptor.Relationship.Descriptors)
                    {
                        if (!nodes.Contains(alternateDescriptor.Node))
                        {
                            nodes.Add(alternateDescriptor.Node);
                        }
                    }
                }

                INodeProxy searchedNode = new NodeProxy(e.Result.SearchedNode);

                ReturnedNodesEventArgs eventArgs = new ReturnedNodesEventArgs(searchedNode, nodes.ToArray());

                if (GetRelatedNodesByIdCompleted != null)
                {
                    GetRelatedNodesByIdCompleted.Invoke(this, eventArgs);
                }
            }
        }
        //private void OnGetNodesWithConditionsCompleted(object sender, GetNodesWithConditionsCompletedEventArgs e)
        //{
        //    if (e.Error == null)
        //    {
        //        List<INodeProxy> nodes = BuildNodeList(e.Result);

        //        ReturnedNodesEventArgs eventArgs = new ReturnedNodesEventArgs(e.Result.SearchedNode, nodes.ToArray());

        //        if (GetNodesWithConditionsCompleted != null)
        //        {
        //            GetNodesWithConditionsCompleted.Invoke(this, eventArgs);
        //        }
        //    }
        //}

        private void OnGetRelatedNodesByIdAsyncCompleted(object sender, GetRelatedNodesCompletedEventArgs e)
        {
            if (e.Error == null)
            {
                List<INodeProxy> nodes = BuildNodeList(e.Result);

                ReturnedNodesEventArgs eventArgs = new ReturnedNodesEventArgs(e.Result.SearchedNode, nodes.ToArray());

                if (GetRelatedNodesByIdCompleted != null)
                {
                    GetRelatedNodesByIdCompleted.Invoke(this, eventArgs);
                }
            }
        }
        private void OnUpdateNodeMetadataCompleted(object sender, UpdateNodeMetadataCompletedEventArgs e)
        {
            if (e.Error == null)
            {
                if (_cachedNodes.ContainsKey(e.Result.Id))
                {
                    _cachedNodes.Remove(e.Result.Id);
                }

                NodeProxy node = new NodeProxy(e.Result);
                _cachedNodes.Add(e.Result.Id, node);

                ReturnedNodesEventArgs returnedNodesEventArgs = new ReturnedNodesEventArgs();
                returnedNodesEventArgs.Nodes = new INodeProxy[] { node };

                if (UpdateNodeMetadataCompleted != null)
                {
                    UpdateNodeMetadataCompleted.Invoke(this, returnedNodesEventArgs);
                }
            }
        }
Example #19
0
        private void OnUpdateNodeMetadataCompletedNodeArgs(object sender, ReturnedNodesEventArgs e)
        {
            NodesEventArgs nodesEventArgs = new NodesEventArgs(null, e.SearchedNode, e.Nodes);

            if (UpdateNodeMetadataCompleted != null)
            {
                UpdateNodeMetadataCompleted.Invoke(this, nodesEventArgs);
            }
        }
        private void OnGetRelatedNodesByIdCompleted(object sender, ReturnedNodesEventArgs e)
        {
            int count = 0;
            int length = e.Nodes.Length - 1;

            if (Views.ContainsKey(FocalNodeId))
            {
                CurrentView = Views[FocalNodeId];
            }
            else
            {
                CurrentView = new NavigatorView();

                Views.Add(FocalNodeId, CurrentView);

                SingleDepthNodeRenderer focalNodeRenderer = null;

                foreach (INodeProxy nodeProxy in e.Nodes)
                {
                    if (nodeProxy.Id == FocalNodeId)
                    {
                        if (FocalNode == null)
                        {
                            FocalNode = nodeProxy;

                            focalNodeRenderer = new SingleDepthNodeRenderer(CurrentView, FocalNode, ThemeManagementObject, "Focal");

                            CurrentView.NodeRenderers.Add(focalNodeRenderer.Node.Id, focalNodeRenderer);

                            focalNodeRenderer.NodePositionUpdating += new EventHandler(OnNodePositionUpdating);
                            focalNodeRenderer.NodeDoubleClicked += new EventHandler<NodeClickedArgs>(OnNodeDoubleClicked);
                        }
                    }
                    else
                    {
                        SingleDepthNodeRenderer nodeRenderer = new SingleDepthNodeRenderer(CurrentView, nodeProxy, ThemeManagementObject, "Default");

                            nodeRenderer.NodeIndex = count;
                            nodeRenderer.NodeCount = length;

                            CurrentView.NodeRenderers.Add(nodeRenderer.Node.Id, nodeRenderer);

                            nodeRenderer.NodePositionUpdating += new EventHandler(OnNodePositionUpdating);
                            nodeRenderer.NodeDoubleClicked += new EventHandler<NodeClickedArgs>(OnNodeDoubleClicked);

                            count++;
                    }
                }

                if (focalNodeRenderer == null)
                {
                    return;
                }

                foreach (INodeRenderer nodeRenderer in CurrentView.NodeRenderers.Values)
                {
                    foreach (IDescriptorProxy descriptor in nodeRenderer.Node.Descriptors)
                    {
                        if (!CurrentView.RelationshipRenderers.ContainsKey(descriptor.Relationship.Id))
                        {
                            bool relationshipIsPresent = true;

                            foreach (IDescriptorProxy alternateDescriptor in descriptor.Relationship.Descriptors)
                            {
                                if (!CurrentView.NodeRenderers.ContainsKey(alternateDescriptor.Node.Id))
                                {
                                    relationshipIsPresent = false;
                                    break;
                                }
                            }

                            if (relationshipIsPresent)
                            {
                                ImprovedArrow arrow = new ImprovedArrow(CurrentView, descriptor.Relationship);

                                CurrentView.RelationshipRenderers.Add(descriptor.Relationship.Id, arrow);
                            }
                        }
                    }
                }
            }

            RendererNodesEventArgs rendererNodesEventArgs = new RendererNodesEventArgs(CurrentView);

            if (GetCurrentNodesCompleted != null)
            {
                GetCurrentNodesCompleted.Invoke(sender, rendererNodesEventArgs);
            }
        }