source: trunk/CrypPlugins/WorkspaceManager/View/VisualComponents/CryptoLineView/CryptoLineView.cs @ 2067

Last change on this file since 2067 was 2067, checked in by matkovic, 11 years ago

-Major Style changes
-Fit to Screen added

File size: 30.3 KB
Line 
1using System;
2using System.ComponentModel;
3using System.Windows;
4using System.Windows.Media;
5using System.Windows.Input;
6using System.Windows.Controls;
7using System.Windows.Shapes;
8using System.Reflection;
9using System.Windows.Threading;
10using WorkspaceManager.View.Interface;
11using WorkspaceManager.Model;
12using System.Windows.Documents;
13using System.Collections.Generic;
14using System.Threading;
15using WorkspaceManager.View.Container;
16using System.Collections;
17using WorkspaceManager.View.VisualComponents.StackFrameDijkstra;
18
19namespace WorkspaceManager.View.VisualComponents
20{
21        public sealed class CryptoLineView : Shape, IConnection, IUpdateableView
22    {
23        #region Variables
24
25        private IntersectPoint intersectPoint;
26        private List<FromTo> pointList = new List<FromTo>();
27        public HashSet<CryptoLineView> UpdateList = new HashSet<CryptoLineView>();
28
29        private ConnectionModel model;
30        public ConnectionModel Model
31        {
32            get { return model; }
33            private set { model = value; }
34        }
35        private static double offset = 6;
36
37        #endregion
38
39        #region Dependency Properties
40
41        public static readonly DependencyProperty StartPointProperty = DependencyProperty.Register("StartPoint", typeof(Point), typeof(CryptoLineView), new FrameworkPropertyMetadata(new Point(0, 0), FrameworkPropertyMetadataOptions.AffectsRender | FrameworkPropertyMetadataOptions.AffectsMeasure));
42        public static readonly DependencyProperty EndPointProperty = DependencyProperty.Register("EndPoint", typeof(Point), typeof(CryptoLineView), new FrameworkPropertyMetadata(new Point(0, 0), FrameworkPropertyMetadataOptions.AffectsRender | FrameworkPropertyMetadataOptions.AffectsMeasure));
43        private ConnectionModel connectionModel;
44        private ConnectorView source;
45        private ConnectorView target;
46
47                #endregion
48
49                #region CLR Properties
50
51        public Point StartPoint
52        {
53            get { return (Point)GetValue(StartPointProperty); }
54            set 
55            {
56                SetValue(StartPointProperty, value);
57            }
58        }
59
60        public Point EndPoint
61        {
62            get { return (Point)GetValue(EndPointProperty); }
63            set 
64            {
65                SetValue(EndPointProperty, value);
66            }
67        }
68
69                #endregion
70
71        public CryptoLineView()
72        {
73            Stroke = Brushes.Black;
74            StrokeThickness = 2;
75        }
76
77        protected override void OnPropertyChanged(DependencyPropertyChangedEventArgs e)
78        {
79            base.OnPropertyChanged(e);
80
81            Panel p = (this.Parent as Panel);
82            if (p == null)
83                return;
84            foreach (UIElement shape in p.Children)
85            {
86                if (shape is CryptoLineView)
87                    shape.InvalidateVisual();
88            }
89        }
90
91        protected override void OnMouseDown(MouseButtonEventArgs args)
92        {
93            if (args.RightButton == MouseButtonState.Pressed)
94            {
95                if (this.model != null && !this.model.WorkspaceModel.WorkspaceManagerEditor.isExecuting())
96                {
97                    this.model.WorkspaceModel.deleteConnectionModel(this.model);
98                }
99            }           
100        }
101
102        public CryptoLineView(ConnectionModel connectionModel) : this()
103        {
104            this.Model = connectionModel;
105            Color color = ColorHelper.GetLineColor(connectionModel.ConnectionType);
106            Stroke = new SolidColorBrush(color);
107            StrokeThickness = 2;
108        }
109
110        public CryptoLineView(ConnectionModel connectionModel, ConnectorView source, ConnectorView target)
111        {
112            // TODO: Complete member initialization
113            this.connectionModel = connectionModel;
114            this.source = source;
115            this.target = target;
116        }
117
118                #region Overrides
119
120                protected override Geometry DefiningGeometry
121                {
122                        get
123                        {
124                                StreamGeometry geometry = new StreamGeometry();
125                                geometry.FillRule = FillRule.EvenOdd;
126
127                                using (StreamGeometryContext context = geometry.Open())
128                                {
129                    internalGeometryDraw(context);
130                                }
131
132                                geometry.Freeze();
133                                return geometry;
134                        }
135                }               
136
137                #endregion
138
139                #region Privates
140        private bool isBetween(double min, double max, double between)
141        {
142            return min <= between && between <= max;
143        }
144
145        private bool findIntersection(Point StartPoint, Point EndPoint, Point StartPointSec, Point EndPointSec)
146        {
147            if (StartPoint.X != EndPoint.X &&
148                StartPoint.Y != EndPoint.Y)
149            {
150                return false;
151            }
152            if (StartPointSec.X != EndPointSec.X &&
153                StartPointSec.Y != EndPointSec.Y)
154            {
155                return false;
156            }
157
158            // parallel, also overlapping case
159            if (StartPoint.X == EndPoint.X && StartPointSec.X == EndPointSec.X ||
160                StartPoint.Y == EndPoint.Y && StartPointSec.Y == EndPointSec.Y)
161            {
162                return false;
163            }
164            else
165            {
166                // orthogonal but maybe not intersected
167                Point up, down, left, right;
168                if (StartPoint.X == EndPoint.X)
169                {
170                    up = StartPoint;
171                    down = EndPoint;
172                    left = StartPointSec;
173                    right = EndPointSec;
174                }
175                else
176                {
177                    up = StartPointSec;
178                    down = EndPointSec;
179                    left = StartPoint;
180                    right = EndPoint;
181                }
182
183                if (up.Y < down.Y)
184                {
185                    double swap = up.Y;
186                    up.Y = down.Y;
187                    down.Y = swap;
188                }
189
190                if (left.X > right.X)
191                {
192                    double swap = left.X;
193                    left.X = right.X;
194                    right.X = swap;
195                }
196                 //check if is intersected at all
197                if(isBetween(down.Y, up.Y, left.Y) && isBetween(left.X, right.X, up.X))
198                {
199                    if (up.Y == left.Y ||
200                        down.Y == left.Y ||
201                        left.X == up.X || right.X == up.X)
202                    {
203                        intersectPoint = new IntersectPoint(new Point(up.X, left.Y), IntersectPointMode.InnerIntersect);
204                    }
205                    else
206                    {
207                        intersectPoint = new IntersectPoint(new Point(up.X, left.Y), IntersectPointMode.NormalIntersect);
208                    }
209                    return true;
210                }
211                return false;
212            }
213        }
214
215                private void internalGeometryDraw(StreamGeometryContext context)
216                {
217            makeOrthogonalPoints();
218            foreach (var element in (Parent as Panel).Children)
219            {
220                if (element is CryptoLineView && !element.Equals(this))
221                {
222                    CryptoLineView result = element as CryptoLineView;
223                    foreach (FromTo fromTo in pointList)
224                    {
225                        foreach (FromTo resultFromTo in result.pointList)
226                        {
227                            if (findIntersection(fromTo.From, fromTo.To, resultFromTo.From, resultFromTo.To))
228                            {
229                                fromTo.Intersection.Add(intersectPoint);
230
231                                if (fromTo.DirSort == DirSort.Y_ASC || fromTo.DirSort == DirSort.Y_DESC)
232                                    this.UpdateList.Add(result);
233                            }
234                        }
235                    }
236                }
237            }
238
239            context.BeginFigure(StartPoint, true, false);
240
241            foreach (FromTo fromTo in pointList)
242            {
243                if (fromTo.Intersection.Count > 0)
244                {
245                    foreach (IntersectPoint interPoint in fromTo.Intersection)
246                    {
247                        switch (fromTo.DirSort)
248                        {
249                            case DirSort.X_ASC:
250                                if (interPoint.Mode == IntersectPointMode.NormalIntersect)
251                                {
252                                    context.LineTo(new Point(interPoint.Point.X - offset, interPoint.Point.Y), true, true);
253                                    context.QuadraticBezierTo(new Point(interPoint.Point.X, interPoint.Point.Y - offset), new Point(interPoint.Point.X + offset, interPoint.Point.Y), true, true);
254                                }
255                                else if (interPoint.Mode == IntersectPointMode.InnerIntersect)
256                                {
257                                    context.LineTo(new Point(interPoint.Point.X - 2.5, interPoint.Point.Y), true, true);
258                                    context.QuadraticBezierTo(new Point(interPoint.Point.X, interPoint.Point.Y - 3.5), new Point(interPoint.Point.X + 2.5, interPoint.Point.Y), true, true);
259                                    context.QuadraticBezierTo(new Point(interPoint.Point.X, interPoint.Point.Y + 3.5), new Point(interPoint.Point.X - 2.5, interPoint.Point.Y), true, true);
260                                }
261                                break;
262                            case DirSort.X_DESC:
263                                if (interPoint.Mode == IntersectPointMode.NormalIntersect)
264                                {
265                                    context.LineTo(new Point(interPoint.Point.X + offset, interPoint.Point.Y), true, true);
266                                    context.QuadraticBezierTo(new Point(interPoint.Point.X, interPoint.Point.Y - offset), new Point(interPoint.Point.X - offset, interPoint.Point.Y), true, true);
267                                }
268                                else if (interPoint.Mode == IntersectPointMode.InnerIntersect)
269                                {
270                                    context.LineTo(new Point(interPoint.Point.X + 2.5, interPoint.Point.Y), true, true);
271                                    context.QuadraticBezierTo(new Point(interPoint.Point.X, interPoint.Point.Y - 3.5), new Point(interPoint.Point.X - 2.5, interPoint.Point.Y), true, true);
272                                    context.QuadraticBezierTo(new Point(interPoint.Point.X, interPoint.Point.Y + 3.5), new Point(interPoint.Point.X + 2.5, interPoint.Point.Y), true, true);
273                                }
274                                break;
275                            //case DirSort.Y_ASC:
276                            //    context.LineTo(new Point(interPoint.X, interPoint.Y - offset), true, true);
277                            //    context.QuadraticBezierTo(new Point(interPoint.X + offset, interPoint.Y), new Point(interPoint.X, interPoint.Y + offset), true, true);
278                            //    break;
279                            //case DirSort.Y_DESC:
280                            //    context.LineTo(new Point(interPoint.X, interPoint.Y + offset), true, true);
281                            //    context.QuadraticBezierTo(new Point(interPoint.X + offset, interPoint.Y), new Point(interPoint.X, interPoint.Y - offset), true, true);
282                            //    break;
283                        }
284                    }
285                    context.LineTo(fromTo.To, true, true);
286                }
287                else
288                {
289                    context.LineTo(fromTo.To, true, true);
290                }
291            }
292        }
293
294
295
296        //private bool isConnectionPossible(Point p1, Point p2, QuadTreeLib.QuadTree<FakeNode> quad)
297        //{
298        //    if (p1.X != p2.X && p1.Y != p2.Y)
299        //        throw new ArgumentException("only 90° allowed");
300
301        //    if (p1.Y != p2.Y)
302        //    {
303        //        Point up = p2.Y < p1.Y ? p2 : p1;
304        //        Point down = p2.Y < p1.Y ? p1 : p2;
305
306        //        Panel parent = (Parent as Panel);
307        //        foreach (var element in parent.Children)
308        //        {
309        //            PluginContainerView plug1 = element as PluginContainerView;
310        //            if (plug1 == null)
311        //                continue;
312        //            Point pos = new Point((plug1.RenderTransform as TranslateTransform).X, (plug1.RenderTransform as TranslateTransform).Y);
313
314        //            if (!isBetween(pos.X, pos.X + plug1.ActualWidth, up.X))
315        //                continue;
316
317        //            // case 1: one point is inside the plugin
318        //            if (isBetween(pos.Y, pos.Y + plug1.ActualHeight, up.Y) ||
319        //                isBetween(pos.Y, pos.Y + plug1.ActualHeight, down.Y))
320        //            {
321        //                return false;
322        //            }
323
324        //            // case 2: goes through
325        //            if (pos.Y > up.Y && pos.Y + plug1.ActualHeight < down.Y)
326        //            {
327        //                return false;
328        //            }
329        //        }
330        //    }
331        //    else
332        //    {
333        //        Point left = p2.X < p1.X ? p2 : p1;
334        //        Point right = p2.X < p1.X ? p1 : p2;
335
336        //        Panel parent = (Parent as Panel);
337        //        foreach (var element in parent.Children)
338        //        {
339        //            PluginContainerView plug1 = element as PluginContainerView;
340        //            if (plug1 == null)
341        //                continue;
342        //            Point pos = new Point((plug1.RenderTransform as TranslateTransform).X, (plug1.RenderTransform as TranslateTransform).Y);
343        //            if (!isBetween(pos.Y, pos.Y + plug1.ActualHeight, left.Y))
344        //                continue;
345        //            // case 1: one point is inside the plugin
346        //            if (isBetween(pos.X, pos.X + plug1.ActualWidth, left.X) ||
347        //                isBetween(pos.X, pos.X + plug1.ActualWidth, right.X))
348        //            {
349        //                return false;
350        //            }
351        //            // case 2: goes through
352        //            if (pos.X > left.X && pos.X + plug1.ActualWidth < right.X)
353        //            {
354        //                return false;
355        //            }
356        //        }
357        //    }
358        //    return true;
359        //}
360
361        private bool isConnectionPossible(Point p1, Point p2, QuadTreeLib.QuadTree<FakeNode> quadTree)
362        {
363            if (p1.X != p2.X && p1.Y != p2.Y)
364                throw new ArgumentException("only 90° allowed");
365
366            System.Drawing.RectangleF queryRect;
367            if (p1.Y != p2.Y)
368            {
369                Point up = p2.Y < p1.Y ? p2 : p1;
370                Point down = p2.Y < p1.Y ? p1 : p2;
371
372                queryRect = new System.Drawing.RectangleF((float)up.X, (float)up.Y, 1, (float)(down.Y - up.Y));
373            }
374            else
375            {
376                Point left = p2.X < p1.X ? p2 : p1;
377                Point right = p2.X < p1.X ? p1 : p2;
378
379                queryRect = new System.Drawing.RectangleF((float)left.X, (float)left.Y, (float)(right.X - left.X), 1);
380            }
381            return !quadTree.QueryAny(queryRect);
382        }
383
384        private bool performOrthogonalPointConnection(Node n1, Point p2, Node n3, List<Node> nodeList, QuadTreeLib.QuadTree<FakeNode> quadTreePlugins, QuadTreeLib.QuadTree<FakeNode> quadTreeLines)
385        {
386            //bool isHorizontal;
387            //Point help1, help2;
388            //foreach (FakeNode FKNode in getQueriesFromLine(n1.Point, p2, quadTreeLines, out isHorizontal))
389            //{
390            //    if (isHorizontal)
391            //    {
392            //        if (FKNode.Source != this.source)
393            //            continue;
394
395            //        help1 = new Point(n1.Point.X, 2);
396            //        help2 = new Point(p
397            //    }
398            //    else
399            //    {
400            //        if (FKNode.Source != this.source)
401            //            continue;
402            //    }
403            //}
404
405            //foreach (FakeNode FKNode in getQueriesFromLine(p2, n3.Point, quadTreeLines, out isHorizontal))
406            //{
407            //    if (isHorizontal)
408            //    {
409
410            //    }
411            //    else
412            //    {
413
414            //    }
415            //}
416
417            if (isConnectionPossible(n1.Point, p2, quadTreePlugins) && isConnectionPossible(p2, n3.Point, quadTreePlugins))
418            {
419                Node n2 = new Node() { Point = p2 };
420                n1.Vertices.Add(n2);
421
422                n2.Vertices.Add(n1);
423                n2.Vertices.Add(n3);
424
425                n3.Vertices.Add(n2);
426
427                nodeList.Add(n2);
428                return true;
429            }
430
431            return false;
432        }
433
434        private List<FakeNode> getQueriesFromLine(Point p1,Point p2,QuadTreeLib.QuadTree<FakeNode> quadTreeLines, out bool isHorizontal)
435        {
436            if (p1.X != p2.X && p1.Y != p2.Y)
437                throw new ArgumentException("only 90° allowed");
438
439            System.Drawing.RectangleF queryRect;
440
441            if (p1.Y != p2.Y)
442            {
443                Point up = p2.Y < p1.Y ? p2 : p1;
444                Point down = p2.Y < p1.Y ? p1 : p2;
445                isHorizontal = false;
446
447                queryRect = new System.Drawing.RectangleF((float)up.X, (float)up.Y, 1, (float)(down.Y - up.Y));
448            }
449            else
450            {
451                Point left = p2.X < p1.X ? p2 : p1;
452                Point right = p2.X < p1.X ? p1 : p2;
453                isHorizontal = true;
454
455                queryRect = new System.Drawing.RectangleF((float)left.X, (float)left.Y, (float)(right.X - left.X), 1);
456            }
457
458            return quadTreeLines.Query(queryRect);
459        }
460
461        //private bool isSimpleOrthogonalConnectionPossible(Point p1, Point p2, QuadTreeLib.QuadTree<FakeNode> quadTree)
462        //{
463        //    if (p1.X != p2.X && p1.Y != p2.Y)
464        //        throw new ArgumentException("only 90° allowed");
465
466        //    List<FakeNode> list;
467        //    System.Drawing.RectangleF queryRect;
468        //    if (p1.Y != p2.Y)
469        //    {
470        //        Point up = p2.Y < p1.Y ? p2 : p1;
471        //        Point down = p2.Y < p1.Y ? p1 : p2;
472
473        //        queryRect = new System.Drawing.RectangleF((float)up.X, (float)up.Y, (float)5, (float)(down.Y - up.Y));
474        //    }
475        //    else
476        //    {
477        //        Point left = p2.X < p1.X ? p2 : p1;
478        //        Point right = p2.X < p1.X ? p1 : p2;
479
480        //        queryRect = new System.Drawing.RectangleF((float)left.X, (float)left.Y, (float)(right.X - left.X), (float)5);
481        //    }
482
483        //    list = quadTree.Query(queryRect);
484
485        //    return !quadTree.Query(queryRect);
486        //}
487
488        private void performOrthogonalPointConnection(Node p1, Node p2, QuadTreeLib.QuadTree<FakeNode> quadTree)
489        {
490            if (isConnectionPossible(p1.Point, p2.Point, quadTree))
491            {
492                p1.Vertices.Add(p2);
493                p2.Vertices.Add(p1);
494            }
495        }
496
497        internal class FakeNode : QuadTreeLib.IHasRect
498        {
499            public System.Drawing.RectangleF Rectangle { get; set; }
500            public ConnectorView Source { get; set; }
501            public ConnectorView Target { get; set; }
502        }
503
504        private void makeOrthogonalPoints()
505        {
506            if (StartPointSource != null && EndPointSource != null)
507            {
508                List<Node> nodeList = new List<Node>();
509                Panel parent = (Parent as Panel);
510
511                // add start and end. Index will be 0 and 1
512                Node startNode = new Node() { Point = cheat42(StartPoint , StartPointSource, 1)},
513                    endNode = new Node() { Point = cheat42(EndPoint, EndPointSource, -1) };
514                nodeList.Add(startNode);
515                nodeList.Add(endNode);
516
517                float actualWidth = (float)parent.ActualWidth, actualHeight = (float)parent.ActualWidth;
518                //Consider zoom factor
519                QuadTreeLib.QuadTree<FakeNode> quadTreePlugins = new QuadTreeLib.QuadTree<FakeNode>
520                    (new System.Drawing.RectangleF(-actualWidth, -actualHeight, actualWidth * 5, actualHeight * 5));
521
522                QuadTreeLib.QuadTree<FakeNode> quadTreeLines = new QuadTreeLib.QuadTree<FakeNode>
523                    (new System.Drawing.RectangleF(-actualWidth, -actualHeight, actualWidth * 5, actualHeight * 5));
524
525
526
527                //foreach (var element in parent.Children)
528                //{
529                //    if (element is PluginContainerView)
530                //    {
531                //        PluginContainerView p1 = element as PluginContainerView;
532                //        foreach (var routPoint in p1.RoutingPoints)
533                //        {
534                //            nodeList.Add(new Node() { Point = routPoint });
535                //        }
536                //        quadTree.Insert(new FakeNode() { Rectangle = new System.Drawing.RectangleF((float)(p1.RenderTransform as TranslateTransform).X,
537                //                                                                                    (float)(p1.RenderTransform as TranslateTransform).Y,
538                //                                                                                    (float)p1.ActualWidth,
539                //                                                                                    (float)p1.ActualHeight)});
540                //    }
541                //}
542                for (int routPoint = 0; routPoint < 4; ++routPoint)
543                {
544                    foreach (var element in parent.Children)
545                    {
546                        if (element is PluginContainerView)
547                        {
548                            PluginContainerView p1 = element as PluginContainerView;
549                            nodeList.Add(new Node() { Point = p1.GetRoutingPoint(routPoint) });
550                            if (routPoint == 0)
551                            {
552                                quadTreePlugins.Insert(new FakeNode()
553                                {
554                                    Rectangle = new System.Drawing.RectangleF((float)p1.GetPosition().X,
555                                                                               (float)p1.GetPosition().Y + (float)p1.ControlPanel.ActualHeight,
556                                                                               (float)p1.PluginBase.ActualWidth,
557                                                                               (float)p1.PluginBase.ActualHeight - (float)p1.ControlPanel.ActualHeight)
558                                });
559                            }
560                        }
561
562                        if (routPoint != 0)
563                            continue;
564
565                        if (element is CryptoLineView)
566                        {
567                            CryptoLineView l1 = element as CryptoLineView;
568                            foreach (FromTo fromto in l1.pointList)
569                            {
570                                Point p1 = fromto.From, p2 = fromto.To;
571                                if (p1.Y != p2.Y)
572                                {
573                                    Point up = p2.Y < p1.Y ? p2 : p1;
574                                    Point down = p2.Y < p1.Y ? p1 : p2;
575
576                                    quadTreeLines.Insert(new FakeNode()
577                                    {
578                                        Source = l1.source,
579                                        Target = l1.target,
580                                        Rectangle = new System.Drawing.RectangleF((float)up.X, (float)up.Y, 1, (float)(down.Y - up.Y))
581                                    });
582                                }
583                                else
584                                {
585                                    Point left = p2.X < p1.X ? p2 : p1;
586                                    Point right = p2.X < p1.X ? p1 : p2;
587
588                                    quadTreeLines.Insert(new FakeNode()
589                                    {
590                                        Source = l1.source,
591                                        Target = l1.target,
592                                        Rectangle = new System.Drawing.RectangleF((float)left.X, (float)left.Y, (float)(right.X - left.X), 1)
593                                    });
594                                }
595                            }
596
597                        }
598                    }
599                }
600
601                // connect points
602                int loopCount = nodeList.Count;
603                const int performanceTradeoffAt = 10;
604
605                LinkedList<Node> path = null;
606
607                for (int i = 0; i < loopCount; ++i)
608                {
609                    if (performanceTradeoffAt != 0 &&
610                           i == performanceTradeoffAt)
611                    {
612                        StackFrameDijkstra.Dijkstra<Node> dijkstra = new StackFrameDijkstra.Dijkstra<Node>();
613                        path = dijkstra.findPath(nodeList, startNode, endNode);
614                        if (path != null)
615                        {
616                            break;
617                        }
618                    }
619
620                    var p1 = nodeList[i];
621                    // TODO: inner loop restriction! n²-n!
622                    // is k=i instead of k=0 correct?
623                    for (int k = i; k < loopCount; ++k)
624                    {
625
626
627                        var p2 = nodeList[k];
628                        if (p1 == p2)
629                            continue;
630                        if (p1.Vertices.Contains(p2))
631                            continue;
632
633                        // no helping point required?
634                        if (p1.Point.X == p2.Point.X ||
635                            p1.Point.Y == p2.Point.Y)
636                        {
637                            performOrthogonalPointConnection(p1, p2, quadTreePlugins);
638                        }
639                        else
640                        {
641                            Point help = new Point(p1.Point.X, p2.Point.Y);
642
643                            if (!performOrthogonalPointConnection(p1, help, p2, nodeList, quadTreePlugins, quadTreeLines))
644                            {
645                                help = new Point(p2.Point.X, p1.Point.Y);
646                                if (!performOrthogonalPointConnection(p1, help, p2, nodeList, quadTreePlugins, quadTreeLines))
647                                {
648                                    // optional todo: double edge helping routes
649                                }
650                            }
651
652                        }
653                    }
654                }
655
656                if (path == null)
657                {
658                    StackFrameDijkstra.Dijkstra<Node> dijkstra = new StackFrameDijkstra.Dijkstra<Node>();
659                    path = dijkstra.findPath(nodeList, startNode, endNode);
660                }
661
662                if (path != null)
663                {
664                    pointList.Clear();
665                    Point prevPoint = StartPoint;
666
667                    foreach (var i in path)
668                    {
669                        Point thisPoint = i.Point;
670                        this.pointList.Add(new FromTo(prevPoint, thisPoint));
671                        prevPoint = thisPoint;
672                    }
673                    this.pointList.Add(new FromTo(prevPoint, EndPoint));
674                    return;
675                }
676            }
677            //Failsafe
678            if (StartPoint.X < EndPoint.X)
679            {
680                pointList.Clear();
681                pointList.Add(new FromTo(StartPoint, new Point((EndPoint.X + StartPoint.X) / 2, StartPoint.Y)));
682                pointList.Add(new FromTo(new Point((EndPoint.X + StartPoint.X) / 2, StartPoint.Y), new Point((EndPoint.X + StartPoint.X) / 2, EndPoint.Y)));
683                pointList.Add(new FromTo(new Point((EndPoint.X + StartPoint.X) / 2, EndPoint.Y), EndPoint));
684            }
685            else
686            {
687                if (StartPoint.X > EndPoint.X)
688                {
689                    pointList.Clear();
690                    pointList.Add(new FromTo(StartPoint, new Point((StartPoint.X + EndPoint.X) / 2, StartPoint.Y)));
691                    pointList.Add(new FromTo(new Point((StartPoint.X + EndPoint.X) / 2, StartPoint.Y), new Point((StartPoint.X + EndPoint.X) / 2, EndPoint.Y)));
692                    pointList.Add(new FromTo(new Point((StartPoint.X + EndPoint.X) / 2, EndPoint.Y), EndPoint));
693                }
694            }
695        }
696
697        private static Point cheat42(Point EndPoint, ConnectorView EndPointSource, int flipper)
698        {
699            double xoffset = 0;
700            double yoffset = 0;
701            double baseoffset = 15;
702            switch (EndPointSource.Orientation)
703            {
704                case ConnectorOrientation.East:
705                    xoffset = baseoffset;
706                    break;
707                case ConnectorOrientation.West:
708                    xoffset = -baseoffset;
709                    break;
710                case ConnectorOrientation.North:
711                    yoffset = -baseoffset;
712                    break;
713                case ConnectorOrientation.South:
714                    yoffset = baseoffset;
715                    break;
716            }
717            //xoffset *= flipper;
718            //yoffset *= flipper;
719            return new Point(EndPoint.X + xoffset, EndPoint.Y + yoffset);
720        }
721               
722                #endregion
723
724        #region IUpdateableView Members
725
726        public void update()
727        {
728            Stroke = Brushes.Green;
729        }
730
731        #endregion
732
733        internal void Reset()
734        {
735            Color color = ColorHelper.GetColor(Model.ConnectionType);
736            Stroke = new SolidColorBrush(color);
737        }
738
739        public ConnectorView StartPointSource { get; set; }
740
741        public ConnectorView EndPointSource { get; set; }
742    }
743}
Note: See TracBrowser for help on using the repository browser.