示例#1
0
 public virtual void FireChange(VertexChangeEventArgs e)
 {
     if (Change != null && CanFireChangeEvent)
     {
         Change(this, e);
     }
 }
示例#2
0
 public void VertexChange(object sender, VertexChangeEventArgs e)
 {
     if (e.Type != VertexChangeType.ValueChanged && ParentVisualiser.IsPaiting == false) //ValueChanged is handled by FastMode
     {
         ParentVisualiser.PaintGraph();
     }
 }
示例#3
0
 private void QueriesVertexChange(object sender, VertexChangeEventArgs e)
 {
     if (sender == Queries.Vertex.Get(@"SelectedEdges:\") && e.Type == VertexChangeType.EdgeAdded && GeneralUtil.CompareStrings(e.Edge.Meta.Value, "To"))
     {
         Content.Text = Queries.Vertex.Get(@"SelectedEdges:\\To:").Value.ToString();
     }
 }
示例#4
0
        private void VertexChange(object sender, VertexChangeEventArgs e)
        {
            if ((sender == Vertex.Get(@"BaseEdge:\To:") || sender == Vertex.Get(@"BaseEdge:\Meta:")) &&
                e.Type == VertexChangeType.ValueChanged)
            {
                VertexUpdated();
            }

            if ((e.Type == VertexChangeType.EdgeAdded && (GeneralUtil.CompareStrings(e.Edge.Meta.Value, "IsDashed") || GeneralUtil.CompareStrings(e.Edge.Meta.Value, "LineWidth"))) ||
                (e.Type == VertexChangeType.ValueChanged && (sender == Vertex.Get(@"IsDashed:") || sender == Vertex.Get(@"LineWidth:"))))
            {
                UpdateLine();
            }

            if ((e.Type == VertexChangeType.EdgeAdded && (GeneralUtil.CompareStrings(e.Edge.Meta.Value, "StartAnchor") || GeneralUtil.CompareStrings(e.Edge.Meta.Value, "EndAnchor"))) ||
                (e.Type == VertexChangeType.ValueChanged && (sender == Vertex.Get(@"StartAnchor:") || sender == Vertex.Get(@"EndAnchor:"))))
            {
                UpdateLineEnds();
            }

            if ((e.Type == VertexChangeType.EdgeAdded && (GeneralUtil.CompareStrings(e.Edge.Meta.Value, "BackgroundColor") || GeneralUtil.CompareStrings(e.Edge.Meta.Value, "ForegroundColor"))) ||
                (e.Type == VertexChangeType.ValueChanged && (
                     sender == Vertex.Get(@"BackgroundColor:") || sender == Vertex.Get(@"BackgroundColor:\Red:") || sender == Vertex.Get(@"BackgroundColor:\Green:") || sender == Vertex.Get(@"BackgroundColor:\Blue:") || sender == Vertex.Get(@"BackgroundColor:\Opacity:") ||
                     sender == Vertex.Get(@"ForegroundColor:") || sender == Vertex.Get(@"ForegroundColor:\Red:") || sender == Vertex.Get(@"ForegroundColor:\Green:") || sender == Vertex.Get(@"ForegroundColor:\Blue:") || sender == Vertex.Get(@"ForegroundColor:\Opacity:")
                     )))
            {
                UpdateLineEnds();
            }
        }
示例#5
0
        protected void VertexChange(object sender, VertexChangeEventArgs e)
        {
            if ((sender == Vertex) && (e.Type == VertexChangeType.EdgeAdded) && (GeneralUtil.CompareStrings(e.Edge.Meta.Value, "BaseEdge")))
            {
                UpdateBaseEdge();
            }

            if ((sender == Vertex.Get("BaseEdge:")) && (e.Type == VertexChangeType.EdgeAdded) && (GeneralUtil.CompareStrings(e.Edge.Meta.Value, "To")) ||
                (sender == Vertex.Get(@"BaseEdge:\To:") && e.Type == VertexChangeType.ValueChanged))
            {
                UpdateBaseEdge();
            }

            if (sender == Vertex.Get("ZoomVisualiserContent:") && e.Type == VertexChangeType.ValueChanged)
            {
                ChangeZoomVisualiserContent();
            }

            if (sender == Vertex.Get("ShowWhiteSpace:") && e.Type == VertexChangeType.ValueChanged)
            {
                UpdateEditView();
            }

            if (sender == Vertex.Get("HighlightedLine:") && e.Type == VertexChangeType.ValueChanged)
            {
                UpdateEditView();
            }
        }
示例#6
0
        public void VertexChange(object sender, VertexChangeEventArgs e)
        {
            if ((sender == Vertex) && (e.Type == VertexChangeType.EdgeAdded) && (GeneralUtil.CompareStrings(e.Edge.Meta.Value, "BaseEdge")) ||
                (sender == Vertex.Get("BaseEdge:") && e.Type == VertexChangeType.ValueChanged) ||
                ((sender == Vertex.Get("BaseEdge:")) && (e.Type == VertexChangeType.EdgeAdded) && ((GeneralUtil.CompareStrings(e.Edge.Meta.Value, "To")))))
            {
                UpdateBaseEdge(); return;
            }

            if (sender == Vertex.Get(@"BaseEdge:\To:") && (e.Type == VertexChangeType.EdgeAdded || e.Type == VertexChangeType.EdgeRemoved))
            {
                UpdateBaseEdge(); return;
            }

            if ((sender == Vertex) && (e.Type == VertexChangeType.EdgeAdded) && (GeneralUtil.CompareStrings(e.Edge.Meta.Value, "SelectedEdges")))
            {
                SelectedVertexesUpdated(); return;
            }

            if ((sender == Vertex.Get("SelectedEdges:")) && ((e.Type == VertexChangeType.EdgeAdded) || (e.Type == VertexChangeType.EdgeRemoved)))
            {
                SelectedVertexesUpdated(); return;
            }

            if (sender is IVertex && GraphUtil.FindEdgeByToVertex(Vertex.GetAll(@"SelectedEdges:\"), (IVertex)sender) != null)
            {
                SelectedVertexesUpdated(); return;
            }

            if (sender == Vertex.Get("ZoomVisualiserContent:") && e.Type == VertexChangeType.ValueChanged)
            {
                ChangeZoomVisualiserContent(); return;
            }

            if (sender == Vertex.Get("VisualiserCircleSize:") && e.Type == VertexChangeType.ValueChanged)
            {
                PaintGraph(); return;
            }

            if (sender == Vertex.Get("NumberOfCircles:") && e.Type == VertexChangeType.ValueChanged)
            {
                PaintGraph(); return;
            }

            if (sender == Vertex.Get("FastMode:") && e.Type == VertexChangeType.ValueChanged)
            {
                PaintGraph(); return;
            }

            if (sender == Vertex.Get("MetaLabels:") && e.Type == VertexChangeType.ValueChanged)
            {
                PaintGraph(); return;
            }

            if (sender == Vertex.Get("ShowInEdges:") && e.Type == VertexChangeType.ValueChanged)
            {
                PaintGraph(); return;
            }
        }
示例#7
0
        private void EdgeAdded(VertexChangeEventArgs e)
        {
            if (!IsFilled)
            {
                TreeVisualiser.ClearAllItems_Reccurent(this);
            }

            Items.Add(TreeParent.GetTreeViewItem(e.Edge, true));
        }
        public override void VertexChange(object sender, VertexChangeEventArgs e)
        {
            if (sender == Vertex.Get(@"RoundEdgeSize:"))
            {
                VisualiserUpdate();
            }

            base.VertexChange(sender, e);
        }
示例#9
0
 protected void VertexChange(object sender, VertexChangeEventArgs e)
 {
     if ((sender == Vertex) && (e.Type == VertexChangeType.EdgeAdded) && (GeneralUtil.CompareStrings(e.Edge.Meta.Value, "BaseEdge")) ||
         (sender == Vertex.Get("BaseEdge:") && e.Type == VertexChangeType.ValueChanged) ||
         ((sender == Vertex.Get("BaseEdge:")) && (e.Type == VertexChangeType.EdgeAdded) && ((GeneralUtil.CompareStrings(e.Edge.Meta.Value, "To")))) ||
         (sender == Vertex.Get(@"BaseEdge:\To:") && e.Type == VertexChangeType.ValueChanged))
     {
         UpdateBaseEdge();
     }
 }
示例#10
0
        private void EdgeRemoved(VertexChangeEventArgs e)
        {
            IList l = GeneralUtil.CreateAndCopyList(Items);

            foreach (TreeVisualiserViewItem i in l)
            {
                if (((IEdge)i.Tag) == e.Edge)
                {
                    Items.Remove(i);
                }
            }
        }
示例#11
0
        protected void VertexChange(object sender, VertexChangeEventArgs e)
        {
            if ((sender == Vertex) && (e.Type == VertexChangeType.EdgeAdded) && (GeneralUtil.CompareStrings(e.Edge.Meta.Value, "BaseVertex")))
            {
                ItemsSource = e.Edge.To.ToList();  // if there is no .ToList DataGrid can not edit
            }

            if ((sender == Vertex) && (e.Type == VertexChangeType.EdgeAdded) && (GeneralUtil.CompareStrings(e.Edge.Meta.Value, "SelectedVertexes")))
            {
                SelectedVertexesUpdated();
            }

            if ((sender == Vertex.Get("SelectedVertexes:")) && ((e.Type == VertexChangeType.EdgeAdded) || (e.Type == VertexChangeType.EdgeRemoved)))
            {
                SelectedVertexesUpdated();
            }
        }
示例#12
0
        protected void VertexChange(object sender, VertexChangeEventArgs e)
        {
            if ((sender == Vertex) && (e.Type == VertexChangeType.EdgeAdded) && (GeneralUtil.CompareStrings(e.Edge.Meta.Value, "BaseVertex")))
            {
                UpdateBaseVertex();
            }

            if ((sender == Vertex) && (e.Type == VertexChangeType.EdgeAdded) && (GeneralUtil.CompareStrings(e.Edge.Meta.Value, "SelectedVertexes")))
            {
                SelectedVertexesUpdated();
            }

            if ((sender == Vertex.Get("SelectedVertexes:")) && ((e.Type == VertexChangeType.EdgeAdded) || (e.Type == VertexChangeType.EdgeRemoved)))
            {
                SelectedVertexesUpdated();
            }
        }
示例#13
0
        protected void VertexChange(object sender, VertexChangeEventArgs e)
        {
            if ((sender == Vertex) && (e.Type == VertexChangeType.EdgeAdded) && (GeneralUtil.CompareStrings(e.Edge.Meta.Value, "BaseEdge")) ||
                ((sender == Vertex.Get("BaseEdge:")) && (e.Type == VertexChangeType.EdgeAdded) && ((GeneralUtil.CompareStrings(e.Edge.Meta.Value, "To")))))
            {
                UpdateBaseEdge();
            }

            if ((sender == Vertex) && (e.Type == VertexChangeType.EdgeAdded) && (GeneralUtil.CompareStrings(e.Edge.Meta.Value, "BaseEdge")))
            {
                UpdateBaseEdge();
            }

            if (sender == Vertex.Get(@"BaseEdge:\To:") && (e.Type == VertexChangeType.EdgeAdded || e.Type == VertexChangeType.EdgeRemoved))
            {
                UpdateBaseEdge();
            }

            if (sender == Vertex.Get(@"ColumnNumber:") && (e.Type == VertexChangeType.ValueChanged))
            {
                UpdateBaseEdge();
            }

            if (sender == Vertex.Get(@"SectionsAsTabs:") && (e.Type == VertexChangeType.ValueChanged))
            {
                UpdateBaseEdge();
            }

            if (sender == Vertex.Get(@"MetaOnLeft:") && (e.Type == VertexChangeType.ValueChanged))
            {
                UpdateBaseEdge();
            }

            if (sender == Vertex.Get(@"ExpertMode:") && (e.Type == VertexChangeType.ValueChanged))
            {
                UpdateBaseEdge();
            }

            if (sender == Vertex.Get("ZoomVisualiserContent:") && e.Type == VertexChangeType.ValueChanged)
            {
                ChangeZoomVisualiserContent();
            }
        }
示例#14
0
        public virtual void VertexChange(object sender, VertexChangeEventArgs e)
        {
            if (sender == Vertex.Get(@"BaseEdge:\To:") && e.Type == VertexChangeType.EdgeRemoved)
            {
                DiagramLineBase toRemove = null;

                foreach (DiagramLineBase l in DiagramLines)
                {
                    if (l.Vertex.Get(@"BaseEdge:\Meta:") == e.Edge.Meta &&
                        l.Vertex.Get(@"BaseEdge:\To:") == e.Edge.To)
                    {
                        toRemove = l;
                    }
                }

                if (toRemove != null)
                {
                    RemoveDiagramLine(toRemove);
                }
            }

            if (sender == Vertex.Get(@"BaseEdge:\To:") && e.Type == VertexChangeType.ValueChanged)
            {
                VertexContentChange();
            }

            if (sender == Vertex.Get(@"BaseEdge:\To:") && e.Type == VertexChangeType.EdgeAdded && CanAutomaticallyAddEdges)
            {
                Diagram.CheckAndUpdateDiagramLinesForItem(this);
            }

            if (sender == Vertex.Get(@"LineWidth:") ||
                sender == Vertex.Get(@"BackgroundColor:") || sender == Vertex.Get(@"BackgroundColor:\Red:") || sender == Vertex.Get(@"BackgroundColor:\Green:") || sender == Vertex.Get(@"BackgroundColor:\Blue:") || sender == Vertex.Get(@"BackgroundColor:\Opacity:") ||
                sender == Vertex.Get(@"ForegroundColor:") || sender == Vertex.Get(@"ForegroundColor:\Red:") || sender == Vertex.Get(@"ForegroundColor:\Green:") || sender == Vertex.Get(@"ForegroundColor:\Blue:") || sender == Vertex.Get(@"ForegroundColor:\Opacity:"))
            {
                VisualiserUpdate();
            }

            if (sender == Vertex || e.Type == VertexChangeType.EdgeAdded)
            {
                VisualiserUpdate();
            }
        }
示例#15
0
        protected void VertexChange(object sender, VertexChangeEventArgs e)
        {
            if ((sender == Vertex) && (e.Type == VertexChangeType.EdgeAdded) && (GeneralUtil.CompareStrings(e.Edge.Meta.Value, "BaseEdge")))
            {
                UpdateBaseEdge();
            }

            if ((sender == Vertex.Get("BaseEdge:")) && (e.Type == VertexChangeType.EdgeAdded) && (GeneralUtil.CompareStrings(e.Edge.Meta.Value, "To")) ||
                (sender == Vertex.Get(@"BaseEdge:\To:") && e.Type == VertexChangeType.ValueChanged))
            {
                UpdateBaseEdge();
            }

            if (sender == Vertex.Get(@"BaseEdge:\To:") && e.Type == VertexChangeType.EdgeAdded)
            {
                e.Edge.To.Change += new VertexChange(VertexChange);

                manuallyAddedVertexChangeListeners.Add(e.Edge.To);

                UpdateBaseEdge();
            }

            if (sender == Vertex.Get(@"BaseEdge:\To:") && e.Type == VertexChangeType.EdgeRemoved)
            {
                e.Edge.To.Change -= new VertexChange(VertexChange);

                manuallyAddedVertexChangeListeners.Remove(e.Edge.To);

                UpdateBaseEdge();
            }

            foreach (IEdge ee in Vertex.GetAll(@"BaseEdge:\To:\"))
            {
                if (sender == ee.To) // all events
                {
                    UpdateBaseEdge();
                }
            }
        }
示例#16
0
        public void VertexChange(object sender, VertexChangeEventArgs e)
        {
            if (sender != ((IEdge)this.Tag).To)
            {
                throw new Exception("TreeVisualiserViewItem attached to some other Vertex Change");
            }

            if (e.Type == VertexChangeType.ValueChanged)
            {
                UpdateHeader();
            }

            if (e.Type == VertexChangeType.EdgeAdded)
            {
                EdgeAdded(e);
            }

            if (e.Type == VertexChangeType.EdgeRemoved)
            {
                EdgeRemoved(e);
            }
        }
示例#17
0
        protected void VertexChange(object sender, VertexChangeEventArgs e)
        {
            if ((sender == Vertex) && (e.Type == VertexChangeType.EdgeAdded) && (GeneralUtil.CompareStrings(e.Edge.Meta.Value, "BaseEdge")) ||
                ((sender == Vertex.Get("BaseEdge:")) && (e.Type == VertexChangeType.EdgeAdded) && ((GeneralUtil.CompareStrings(e.Edge.Meta.Value, "To")))))
            {
                UpdateBaseEdge();
            }

            if (sender == Vertex.Get(@"BaseEdge:\To:") && (e.Type == VertexChangeType.EdgeAdded))
            {
                EdgeAdded(e);
            }

            if (sender == Vertex.Get(@"BaseEdge:\To:") && (e.Type == VertexChangeType.EdgeRemoved))
            {
                EdgeRemoved(e);
            }

            if ((sender == Vertex) && (e.Type == VertexChangeType.EdgeAdded) && (GeneralUtil.CompareStrings(e.Edge.Meta.Value, "SelectedEdges")))
            {
                SelectedVertexesUpdated();
            }

            if ((sender == Vertex.Get("SelectedEdges:")) && ((e.Type == VertexChangeType.EdgeAdded) || (e.Type == VertexChangeType.EdgeRemoved)))
            {
                SelectedVertexesUpdated();
            }

            if (sender is IVertex && GraphUtil.FindEdgeByToVertex(Vertex.GetAll(@"SelectedEdges:\"), (IVertex)sender) != null)
            {
                SelectedVertexesUpdated();
            }

            if (sender == Vertex.Get("ZoomVisualiserContent:") && e.Type == VertexChangeType.ValueChanged)
            {
                ChangeZoomVisualiserContent();
            }
        }
示例#18
0
        public void SynchronisedVisualiserChange(object sender, VertexChangeEventArgs e)
        {
            if (
                ((sender == selectSynchronisedVisualiser) && (e.Type == VertexChangeType.EdgeAdded) && (GeneralUtil.CompareStrings(e.Edge.Meta.Value, "SelectedEdges")))
                ||
                (sender is IVertex && GraphUtil.FindEdgeByToVertex(selectSynchronisedVisualiser.GetAll(@"SelectedEdges:\"), (IVertex)sender) != null && ((e.Type == VertexChangeType.EdgeAdded) || (e.Type == VertexChangeType.EdgeRemoved)))
                ||
                (sender is IVertex && selectSynchronisedVisualiser.Get(@"SelectedEdges:") == (IVertex)sender && ((e.Type == VertexChangeType.EdgeAdded) || (e.Type == VertexChangeType.EdgeRemoved)))
                )
            {
                if (baseSynchronisedVertex.Get(@"BaseEdge:\To:") == null)     // if Disposed
                {
                    PlatformClass.RemoveVertexChangeListeners(selectSynchronisedVisualiser, new VertexChange(this.SynchronisedVisualiserChange));
                }
                else
                {
                    IVertex selEdgesFirst = selectSynchronisedVisualiser.Get(@"SelectedEdges:\");

                    if (selEdgesFirst != null)
                    {
                        IVertex firstSelectedVertexEdgeTo = selEdgesFirst.Get("To:");

                        if (firstSelectedVertexEdgeTo != null)
                        {
                            GraphUtil.ReplaceEdge(baseSynchronisedVertex.Get("BaseEdge:"), "To", firstSelectedVertexEdgeTo);
                        }

                        IVertex firstSelectedVertexEdgeMeta = selEdgesFirst.Get("Meta:");

                        if (firstSelectedVertexEdgeMeta != null)
                        {
                            GraphUtil.ReplaceEdge(baseSynchronisedVertex.Get("BaseEdge:"), "Meta", firstSelectedVertexEdgeMeta);
                        }
                    }
                }
            }
        }
示例#19
0
        protected virtual void VertexChange(object sender, VertexChangeEventArgs e)
        {
            if ((sender == Vertex) && (e.Type == VertexChangeType.EdgeAdded) && (GeneralUtil.CompareStrings(e.Edge.Meta.Value, "BaseEdge")) ||
                (sender == Vertex.Get("BaseEdge:") && e.Type == VertexChangeType.ValueChanged) ||
                ((sender == Vertex.Get("BaseEdge:")) && (e.Type == VertexChangeType.EdgeAdded) && ((GeneralUtil.CompareStrings(e.Edge.Meta.Value, "To")))))
            {
                UpdateBaseEdge();
            }

            if (sender == Vertex.Get(@"BaseEdge:\To:") && (e.Type == VertexChangeType.EdgeAdded || e.Type == VertexChangeType.EdgeRemoved))
            {
                UpdateBaseEdge();
            }

            if ((sender == Vertex) && (e.Type == VertexChangeType.EdgeAdded) && (GeneralUtil.CompareStrings(e.Edge.Meta.Value, "SelectedEdges")))
            {
                SelectedVertexesUpdated();
            }

            if ((sender == Vertex.Get("SelectedEdges:")) && ((e.Type == VertexChangeType.EdgeAdded) || (e.Type == VertexChangeType.EdgeRemoved)))
            {
                SelectedVertexesUpdated();
            }

            if (sender is IVertex && GraphUtil.FindEdgeByToVertex(Vertex.GetAll(@"SelectedEdges:\"), (IVertex)sender) != null)
            {
                SelectedVertexesUpdated();
            }

            if (sender == Vertex.Get("IsMetaRightAlign:") && e.Type == VertexChangeType.ValueChanged)
            {
                ResetView();
            }

            if (sender == Vertex.Get("IsAllVisualisersEdit:") && e.Type == VertexChangeType.ValueChanged)
            {
                ResetView();
            }

            if (sender == Vertex.Get("ZoomVisualiserContent:") && e.Type == VertexChangeType.ValueChanged)
            {
                ChangeZoomVisualiserContent();
            }

            if (sender == Vertex.Get("FilterQuery:") && e.Type == VertexChangeType.ValueChanged)
            {
                UpdateBaseEdge();
            }

            if ((sender == Vertex) && (e.Type == VertexChangeType.EdgeAdded) && (GeneralUtil.CompareStrings(e.Edge.Meta.Value, "FilterQuery")))
            {
                UpdateBaseEdge();
            }

            if (sender == Vertex.Get("ShowMeta:") && e.Type == VertexChangeType.ValueChanged)
            {
                ResetView();
            }

            if ((sender == Vertex) && (e.Type == VertexChangeType.EdgeAdded) && (GeneralUtil.CompareStrings(e.Edge.Meta.Value, "ShowMeta")))
            {
                ResetView();
            }

            if (sender == Vertex.Get("ShowHeader:") && e.Type == VertexChangeType.ValueChanged)
            {
                ResetView();
            }

            if ((sender == Vertex) && (e.Type == VertexChangeType.EdgeAdded) && (GeneralUtil.CompareStrings(e.Edge.Meta.Value, "ShowHeader")))
            {
                ResetView();
            }

            if ((sender == Vertex) && (e.Type == VertexChangeType.EdgeAdded) && (GeneralUtil.CompareStrings(e.Edge.Meta.Value, "GridStyle")))
            {
                ResetView();
            }
        }
示例#20
0
 private void EdgeAdded(VertexChangeEventArgs e)
 {
     Items.Add(GetTreeViewItem(e.Edge, true));
 }
示例#21
0
        protected override void VertexChange(object sender, VertexChangeEventArgs e)
        {
            if ((sender == Vertex) && (e.Type == VertexChangeType.EdgeAdded) && (GeneralUtil.CompareStrings(e.Edge.Meta.Value, "BaseEdge")) ||
                (sender == Vertex.Get("BaseEdge:") && e.Type == VertexChangeType.ValueChanged) ||
                ((sender == Vertex.Get("BaseEdge:")) && (e.Type == VertexChangeType.EdgeAdded) && ((GeneralUtil.CompareStrings(e.Edge.Meta.Value, "To")))))
            {
                UpdateBaseEdge();
            }

            if (sender == Vertex.Get(@"BaseEdge:\To:") && (e.Type == VertexChangeType.EdgeAdded || e.Type == VertexChangeType.EdgeRemoved))
            {
                UpdateBaseEdge();
            }

            if ((sender == Vertex) && (e.Type == VertexChangeType.EdgeAdded) && (GeneralUtil.CompareStrings(e.Edge.Meta.Value, "ToShowEdgesMeta")))
            {
                UpdateBaseEdge();
            }

            //if (sender == Vertex.Get(@"ToShowEdgesMeta:") && (e.Type == VertexChangeType.EdgeAdded || e.Type == VertexChangeType.EdgeRemoved))
            //  UpdateBaseEdge();
            // there is update loop with this, so commenting out and leaving only what is above

            if ((sender == Vertex) && (e.Type == VertexChangeType.EdgeAdded) && (GeneralUtil.CompareStrings(e.Edge.Meta.Value, "SelectedEdges")))
            {
                SelectedVertexesUpdated();
            }

            if ((sender == Vertex.Get("SelectedEdges:")) && ((e.Type == VertexChangeType.EdgeAdded) || (e.Type == VertexChangeType.EdgeRemoved)))
            {
                SelectedVertexesUpdated();
            }

            if (sender is IVertex && GraphUtil.FindEdgeByToVertex(Vertex.GetAll(@"SelectedEdges:\"), (IVertex)sender) != null)
            {
                SelectedVertexesUpdated();
            }

            if (sender == Vertex.Get("IsMetaRightAlign:") && e.Type == VertexChangeType.ValueChanged)
            {
                ResetView();
            }

            if (sender == Vertex.Get("IsAllVisualisersEdit:") && e.Type == VertexChangeType.ValueChanged)
            {
                ResetView();
            }

            if (sender == Vertex.Get("ZoomVisualiserContent:") && e.Type == VertexChangeType.ValueChanged)
            {
                ChangeZoomVisualiserContent();
            }

            if (sender == Vertex.Get("FilterQuery:") && e.Type == VertexChangeType.ValueChanged)
            {
                UpdateBaseEdge();
            }

            if (sender == Vertex.Get("ExpertMode:") && e.Type == VertexChangeType.ValueChanged)
            {
                UpdateBaseEdge();
            }

            if ((sender == Vertex) && (e.Type == VertexChangeType.EdgeAdded) && (GeneralUtil.CompareStrings(e.Edge.Meta.Value, "FilterQuery")))
            {
                UpdateBaseEdge();
            }

            if (sender == Vertex.Get("ShowHeader:") && e.Type == VertexChangeType.ValueChanged)
            {
                ResetView();
            }

            if (sender == Vertex.Get("AlternatingRows:") && e.Type == VertexChangeType.ValueChanged)
            {
                ResetView();
            }

            if ((sender == Vertex) && (e.Type == VertexChangeType.EdgeAdded) && (GeneralUtil.CompareStrings(e.Edge.Meta.Value, "ShowHeader")))
            {
                ResetView();
            }
        }
示例#22
0
        public void Listener(object sender, VertexChangeEventArgs e)
        {
            if (CheckSender(sender) && (e.Type == VertexChangeType.EdgeAdded) && (!GeneralUtil.CompareStrings(e.Edge.Meta.Value, "$Is")))
            {
                IVertex AttributeVertexes = ((IVertex)sender).GetAll(@"$Is:\Selector:");
                //IVertex AttributeVertexes = ((IVertex)sender).GetAll(@"$Is:{$Inherits:$PlatformClass}\Selector:");

                foreach (IEdge ed in AttributeVertexes)
                {
                    if (e.Edge.Meta == ed.To)
                    {
                        GraphUtil.AddHandlerIfDelegateListDoesNotContainsIt(e.Edge.To, this.Listener);
                    }
                }

                foreach (string metaFromWatchList in WatchList)
                {
                    if (((string)e.Edge.Meta.Value) == metaFromWatchList)
                    {
                        GraphUtil.AddHandlerIfDelegateListDoesNotContainsIt(e.Edge.To, this.Listener);

                        foreach (IEdge ee in e.Edge.To)
                        {
                            GraphUtil.AddHandlerIfDelegateListDoesNotContainsIt(ee.To, this.Listener);
                        }
                    }
                }
            }

            foreach (string metaFromWatchList in WatchList)
            {
                if ((sender == PlatformClassVertex.Get(metaFromWatchList + ":")) && (e.Type == VertexChangeType.EdgeAdded) && (!GeneralUtil.CompareStrings(e.Edge.Meta.Value, "$Is")))
                {
                    GraphUtil.AddHandlerIfDelegateListDoesNotContainsIt(e.Edge.To, this.Listener);
                }
            }

            if (CheckSender(sender) && (e.Type == VertexChangeType.EdgeRemoved) && (!GeneralUtil.CompareStrings(e.Edge.Meta.Value, "$Is")))
            {
                IVertex AttributeVertexes = ((IVertex)sender).GetAll(@"$Is:\Selector:");
                //IVertex AttributeVertexes = ((IVertex)sender).GetAll(@"$Is:{$Inherits:$PlatformClass}\Selector:");

                foreach (IEdge ed in AttributeVertexes)
                {
                    if (e.Edge.Meta == ed.To)
                    {
                        e.Edge.To.Change -= new VertexChange(this.Listener);
                    }
                }

                foreach (string metaFromWatchList in WatchList)
                {
                    if (((string)e.Edge.Meta.Value) == metaFromWatchList)
                    {
                        e.Edge.To.Change -= new VertexChange(this.Listener);

                        foreach (IEdge ee in e.Edge.To)
                        {
                            ee.To.Change -= new VertexChange(this.Listener);
                        }
                    }
                }
            }


            foreach (string metaFromWatchList in WatchList)
            {
                if ((sender == PlatformClassVertex.Get(metaFromWatchList + ":")) && (e.Type == VertexChangeType.EdgeRemoved) && (!GeneralUtil.CompareStrings(e.Edge.Meta.Value, "$Is")))
                {
                    e.Edge.To.Change -= new VertexChange(this.Listener);
                }
            }

            if (Change != null)
            {
                Change(sender, e);
            }
        }