Ignore:
Timestamp:
Oct 19, 2010, 11:07:42 AM (11 years ago)
Author:
matkovic
Message:

-fixed pathfinding
-fixed line drawing
-added Colorpicker
-fixed lock/unlock at TextInputWrapper
-feature: Background and TextForeground in TextInputWrapper added
-fixed a issue With loading and such
-WorkspaceModel doesn't throw exception anymore (Samples functional again)
-fixed some Styles
-Startable implemented and loaded right
-Startable Logo moved

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/CrypPlugins/WorkspaceManager/View/VisualComponents/CryptoLineView/CryptoLineView.cs

    r1970 r1991  
    4141        public static readonly DependencyProperty StartPointProperty = DependencyProperty.Register("StartPoint", typeof(Point), typeof(CryptoLineView), new FrameworkPropertyMetadata(new Point(0, 0), FrameworkPropertyMetadataOptions.AffectsRender | FrameworkPropertyMetadataOptions.AffectsMeasure));
    4242        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;
    4346
    4447                #endregion
     
    103106            Stroke = new SolidColorBrush(color);
    104107            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;
    105116        }
    106117
     
    244255                                else if (interPoint.Mode == IntersectPointMode.InnerIntersect)
    245256                                {
    246                                     context.LineTo(new Point(interPoint.Point.X - 4, interPoint.Point.Y), true, true);
    247                                     context.QuadraticBezierTo(new Point(interPoint.Point.X, interPoint.Point.Y - 5), new Point(interPoint.Point.X + 4, interPoint.Point.Y), true, true);
    248                                     context.QuadraticBezierTo(new Point(interPoint.Point.X, interPoint.Point.Y + 5), new Point(interPoint.Point.X - 4, interPoint.Point.Y), true, true);
     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);
    249260                                }
    250261                                break;
     
    257268                                else if (interPoint.Mode == IntersectPointMode.InnerIntersect)
    258269                                {
    259                                     context.LineTo(new Point(interPoint.Point.X + 4, interPoint.Point.Y), true, true);
    260                                     context.QuadraticBezierTo(new Point(interPoint.Point.X, interPoint.Point.Y - 5), new Point(interPoint.Point.X - 4, interPoint.Point.Y), true, true);
    261                                     context.QuadraticBezierTo(new Point(interPoint.Point.X, interPoint.Point.Y + 5), new Point(interPoint.Point.X + 4, interPoint.Point.Y), true, true);
     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);
    262273                                }
    263274                                break;
     
    408419        private void makeOrthogonalPoints()
    409420        {
    410             List<Node> nodeList = new List<Node>();
    411             Panel parent = (Parent as Panel);
    412 
    413             // add start and end. Index will be 0 and 1
    414             Node startNode = new Node() { Point = StartPoint },
    415                 endNode = new Node() { Point = EndPoint };
    416             nodeList.Add(startNode);
    417             nodeList.Add(endNode);
    418 
    419             float actualWidth =(float) parent.ActualWidth, actualHeight =(float) parent.ActualWidth;
    420             //Consider zoom factor
    421             QuadTreeLib.QuadTree<FakeNode> quadTree = new QuadTreeLib.QuadTree<FakeNode>
    422                 (new System.Drawing.RectangleF(-actualWidth, -actualHeight, actualWidth*5, actualHeight*5));
    423 
    424             //foreach (var element in parent.Children)
    425             //{
    426             //    if (element is PluginContainerView)
    427             //    {
    428             //        PluginContainerView p1 = element as PluginContainerView;
    429             //        foreach (var routPoint in p1.RoutingPoints)
    430             //        {
    431             //            nodeList.Add(new Node() { Point = routPoint });
    432             //        }
    433             //        quadTree.Insert(new FakeNode() { Rectangle = new System.Drawing.RectangleF((float)(p1.RenderTransform as TranslateTransform).X,
    434             //                                                                                    (float)(p1.RenderTransform as TranslateTransform).Y,
    435             //                                                                                    (float)p1.ActualWidth,
    436             //                                                                                    (float)p1.ActualHeight)});
    437             //    }
    438             //}
    439             for (int routPoint = 0; routPoint < 4; ++routPoint)
    440             {
    441                 foreach (var element in parent.Children)
    442                 {
    443                     if (element is PluginContainerView)
    444                     {
    445                         PluginContainerView p1 = element as PluginContainerView;
    446                         nodeList.Add(new Node() { Point = p1.GetRoutingPoint(routPoint) });
    447                         if (routPoint == 0)
     421            if (StartPointSource != null && EndPointSource != null)
     422            {
     423                List<Node> nodeList = new List<Node>();
     424                Panel parent = (Parent as Panel);
     425
     426                // add start and end. Index will be 0 and 1
     427                Node startNode = new Node() { Point = cheat42(StartPoint , StartPointSource, 1)},
     428                    endNode = new Node() { Point = cheat42(EndPoint, EndPointSource, -1) };
     429                nodeList.Add(startNode);
     430                nodeList.Add(endNode);
     431
     432                float actualWidth = (float)parent.ActualWidth, actualHeight = (float)parent.ActualWidth;
     433                //Consider zoom factor
     434                QuadTreeLib.QuadTree<FakeNode> quadTree = new QuadTreeLib.QuadTree<FakeNode>
     435                    (new System.Drawing.RectangleF(-actualWidth, -actualHeight, actualWidth * 5, actualHeight * 5));
     436
     437                //foreach (var element in parent.Children)
     438                //{
     439                //    if (element is PluginContainerView)
     440                //    {
     441                //        PluginContainerView p1 = element as PluginContainerView;
     442                //        foreach (var routPoint in p1.RoutingPoints)
     443                //        {
     444                //            nodeList.Add(new Node() { Point = routPoint });
     445                //        }
     446                //        quadTree.Insert(new FakeNode() { Rectangle = new System.Drawing.RectangleF((float)(p1.RenderTransform as TranslateTransform).X,
     447                //                                                                                    (float)(p1.RenderTransform as TranslateTransform).Y,
     448                //                                                                                    (float)p1.ActualWidth,
     449                //                                                                                    (float)p1.ActualHeight)});
     450                //    }
     451                //}
     452                for (int routPoint = 0; routPoint < 4; ++routPoint)
     453                {
     454                    foreach (var element in parent.Children)
     455                    {
     456                        if (element is PluginContainerView)
    448457                        {
    449                             quadTree.Insert(new FakeNode()
     458                            PluginContainerView p1 = element as PluginContainerView;
     459                            nodeList.Add(new Node() { Point = p1.GetRoutingPoint(routPoint) });
     460                            if (routPoint == 0)
    450461                            {
    451                                 Rectangle = new System.Drawing.RectangleF((float)(p1.RenderTransform as TranslateTransform).X,
    452                                                                            (float)(p1.RenderTransform as TranslateTransform).Y,
    453                                                                            (float)p1.ActualWidth,
    454                                                                            (float)p1.ActualHeight)
    455                             });
     462                                quadTree.Insert(new FakeNode()
     463                                {
     464                                    Rectangle = new System.Drawing.RectangleF((float)(p1.RenderTransform as TranslateTransform).X,
     465                                                                               (float)(p1.RenderTransform as TranslateTransform).Y + (float)p1.ControlPanel.ActualHeight,
     466                                                                               (float)p1.ActualWidth,
     467                                                                               (float)p1.ActualHeight - (float)p1.ControlPanel.ActualHeight)
     468                                });
     469                            }
    456470                        }
    457471                    }
    458472                }
    459             }
    460 
    461             // connect points
    462             int loopCount = nodeList.Count;
    463             const int performanceTradeoffAt = 10;
    464 
    465             LinkedList<Node> path = null;
    466 
    467             for(int i=0; i<loopCount; ++i)
    468             {
    469                 if (performanceTradeoffAt != 0 &&
    470                        i == performanceTradeoffAt)
     473
     474                // connect points
     475                int loopCount = nodeList.Count;
     476                const int performanceTradeoffAt = 10;
     477
     478                LinkedList<Node> path = null;
     479
     480                for (int i = 0; i < loopCount; ++i)
     481                {
     482                    if (performanceTradeoffAt != 0 &&
     483                           i == performanceTradeoffAt)
     484                    {
     485                        StackFrameDijkstra.Dijkstra<Node> dijkstra = new StackFrameDijkstra.Dijkstra<Node>();
     486                        path = dijkstra.findPath(nodeList, startNode, endNode);
     487                        if (path != null)
     488                        {
     489                            break;
     490                        }
     491                    }
     492
     493                    var p1 = nodeList[i];
     494                    // TODO: inner loop restriction! n²-n!
     495                    // is k=i instead of k=0 correct?
     496                    for (int k = i; k < loopCount; ++k)
     497                    {
     498
     499
     500                        var p2 = nodeList[k];
     501                        if (p1 == p2)
     502                            continue;
     503                        if (p1.Vertices.Contains(p2))
     504                            continue;
     505
     506                        // no helping point required?
     507                        if (p1.Point.X == p2.Point.X ||
     508                            p1.Point.Y == p2.Point.Y)
     509                        {
     510                            performOrthogonalPointConnection(p1, p2, quadTree);
     511                        }
     512                        else
     513                        {
     514                            Point help = new Point(p1.Point.X, p2.Point.Y);
     515
     516                            if (!performOrthogonalPointConnection(p1, help, p2, nodeList, quadTree))
     517                            {
     518                                help = new Point(p2.Point.X, p1.Point.Y);
     519                                if (!performOrthogonalPointConnection(p1, help, p2, nodeList, quadTree))
     520                                {
     521                                    // optional todo: double edge helping routes
     522                                }
     523                            }
     524
     525                        }
     526                    }
     527                }
     528
     529                if (path == null)
    471530                {
    472531                    StackFrameDijkstra.Dijkstra<Node> dijkstra = new StackFrameDijkstra.Dijkstra<Node>();
    473532                    path = dijkstra.findPath(nodeList, startNode, endNode);
    474                     if (path != null)
    475                     {
    476                         break;
    477                     }
    478                 }
    479 
    480                 var p1 = nodeList[i];
    481                 // TODO: inner loop restriction! n²-n!
    482                 // is k=i instead of k=0 correct?
    483                 for(int k=i; k<loopCount; ++k)
    484                 {
    485                    
    486 
    487                     var p2 = nodeList[k];
    488                     if (p1 == p2)
    489                         continue;
    490                     if (p1.Vertices.Contains(p2))
    491                         continue;
    492 
    493                     // no helping point required?
    494                     if (p1.Point.X == p2.Point.X ||
    495                         p1.Point.Y == p2.Point.Y)
    496                     {
    497                         performOrthogonalPointConnection(p1, p2, quadTree);
    498                     }
    499                     else
    500                     {
    501                         Point help = new Point(p1.Point.X, p2.Point.Y);
    502 
    503                         if (!performOrthogonalPointConnection(p1, help, p2, nodeList, quadTree ))
    504                         {
    505                             help = new Point(p2.Point.X, p1.Point.Y);
    506                             if (!performOrthogonalPointConnection(p1, help, p2, nodeList, quadTree))
    507                             {
    508                                 // optional todo: double edge helping routes
    509                             }
    510                         }
    511                        
    512                     }
    513                 }
    514             }
    515 
    516             if (path == null)
    517             {
    518                 StackFrameDijkstra.Dijkstra<Node> dijkstra = new StackFrameDijkstra.Dijkstra<Node>();
    519                 path = dijkstra.findPath(nodeList, startNode, endNode);
    520             }
    521 
    522             if (path != null)
    523             {
    524                 pointList.Clear();
    525                 Point prevPoint = StartPoint;
    526 
    527                 foreach (var i in path)
    528                 {
    529                     Point thisPoint = i.Point;
    530                     this.pointList.Add(new FromTo(prevPoint, thisPoint));
    531                     prevPoint = thisPoint;
    532                 }
    533             }
    534                 //Failsafe
    535             else if (StartPoint.X < EndPoint.X)
     533                }
     534
     535                if (path != null)
     536                {
     537                    pointList.Clear();
     538                    Point prevPoint = StartPoint;
     539
     540                    foreach (var i in path)
     541                    {
     542                        Point thisPoint = i.Point;
     543                        this.pointList.Add(new FromTo(prevPoint, thisPoint));
     544                        prevPoint = thisPoint;
     545                    }
     546                    this.pointList.Add(new FromTo(prevPoint, EndPoint));
     547                    return;
     548                }
     549            }
     550            //Failsafe
     551            if (StartPoint.X < EndPoint.X)
    536552            {
    537553                pointList.Clear();
     
    551567            }
    552568        }
     569
     570        private static Point cheat42(Point EndPoint, ConnectorView EndPointSource, int flipper)
     571        {
     572            double xoffset = 0;
     573            double yoffset = 0;
     574            double baseoffset = 15;
     575            switch (EndPointSource.Orientation)
     576            {
     577                case ConnectorOrientation.East:
     578                    xoffset = baseoffset;
     579                    break;
     580                case ConnectorOrientation.West:
     581                    xoffset = -baseoffset;
     582                    break;
     583                case ConnectorOrientation.North:
     584                    yoffset = -baseoffset;
     585                    break;
     586                case ConnectorOrientation.South:
     587                    yoffset = baseoffset;
     588                    break;
     589            }
     590            //xoffset *= flipper;
     591            //yoffset *= flipper;
     592            return new Point(EndPoint.X + xoffset, EndPoint.Y + yoffset);
     593        }
    553594               
    554595                #endregion
     
    568609            Stroke = new SolidColorBrush(color);
    569610        }
     611
     612        public ConnectorView StartPointSource { get; set; }
     613
     614        public ConnectorView EndPointSource { get; set; }
    570615    }
    571616}
Note: See TracChangeset for help on using the changeset viewer.