/// <summary>
        /// displays the database
        /// </summary>
        /// <param name="db"></param>
        /// <param name="curves"></param>
        static public void ShowDataBase(Database db, params Splines.ICurve[] curves)
        {
            Microsoft.Msagl.Drawing.Graph g = new Microsoft.Msagl.Drawing.Graph("");
            AllocateDebugCurves(g);

            Microsoft.Msagl.Splines.Rectangle graphBox = new Microsoft.Msagl.Splines.Rectangle(db.Anchors[0].LeftTop);

            List <ICurve> cl = new List <ICurve>(curves);

            foreach (Anchor a in db.Anchors)
            {
                graphBox.Add(a.LeftTop);
                graphBox.Add(a.RightBottom);
                cl.Add(a.PolygonalBoundary);
            }

            AddCurvesToGraph(cl, g);

            Microsoft.Msagl.Point del = (graphBox.LeftBottom - graphBox.RightTop) / 10;
            graphBox.Add(graphBox.LeftBottom + del);
            graphBox.Add(graphBox.RightTop - del);
            GeometryGraph gg = new GeometryGraph();

            gg.BoundingBox  = graphBox;
            g.DataBase      = db;
            g.GeometryGraph = gg;
            DisplayGraph(g);
            db.nodesToShow = null;
        }
Exemple #2
0
        private void ProcessRightClickOnSelectedEdge(MsaglMouseEventArgs e)
        {
            mouseRightButtonDownPoint = viewer.ScreenToSource(e);

            cornerInfo = AnalyzeInsertOrDeletePolylineCorner(mouseRightButtonDownPoint, this.SelectedEdge.RadiusOfPolylineCorner);

            if (cornerInfo == null)
            {
                return;
            }

            e.Handled = true;

            Couple <string, DelegateReturningVoid> edgeRemoveCouple = new Couple <string, DelegateReturningVoid>("Remove edge",
                                                                                                                 delegate() { this.viewer.RemoveEdge(this.SelectedEdge, true); });

            if (cornerInfo.Second == Microsoft.Msagl.Drawing.PolylineCornerType.PreviousCornerForInsertion)
            {
                viewer.PopupMenus(new Couple <string, DelegateReturningVoid>("Insert polyline corner", new DelegateReturningVoid(this.InsertPolylineCorner)), edgeRemoveCouple);
            }
            else if (cornerInfo.Second == Microsoft.Msagl.Drawing.PolylineCornerType.CornerToDelete)
            {
                viewer.PopupMenus(new Couple <string, DelegateReturningVoid>("Delete polyline corner", new DelegateReturningVoid(this.DeleteCorner)), edgeRemoveCouple);
            }
        }
Exemple #3
0
        static bool WithinEpsilon(Microsoft.Msagl.Splines.ICurve bc, double start, double end)
        {
            int    n = 3; //hack !!!!
            double d = (end - start) / n;
            P2     s = bc[start];
            P2     e = bc[end];

            return(DistToSegm(bc[start + d], s, e) < epsilon
                   &&
                   DistToSegm(bc[start + d * (n - 1)], s, e) < epsilon);
        }
Exemple #4
0
        internal static double DistToSegm(P2 p, P2 s, P2 e)
        {
            P2     l   = e - s;
            double len = l.Length;

            if (len < Tessellator.epsilon)
            {
                return((p - (0.5f * (s + e))).Length);
            }
            P2 perp = new P2(-l.Y, l.X);

            perp /= len;
            return(Math.Abs((p - s) * perp));
        }
Exemple #5
0
        //when we check for inclusion we expand the box by slack
        internal Geometry Hit(P2 p, double slack)
        {
            if (l == null)
            {
                if (Box.Contains(p, slack))
                {
                    Line line = geometry as Line;

                    if (line != null)
                    {
                        if (Tessellator.DistToSegm(p, line.start, line.end) < slack + line.LineWidth / 2)
                        {
                            return(line);
                        }
                        return(null);
                    }
                    else if (Box.Contains(p))
                    {
                        return(geometry);
                    }

                    return(null);
                }
                else
                {
                    return(null);
                }
            }

            if (l.Box.Contains(p, slack))
            {
                Geometry g = l.Hit(p, slack);
                if (g != null)
                {
                    return(g);
                }
            }

            if (r.Box.Contains(p, slack))
            {
                Geometry g = r.Hit(p, slack);
                if (g != null)
                {
                    return(g);
                }
            }

            return(null);
        }
Exemple #6
0
        private static void AddUnderlyingPolylineTessellation(List <ObjectWithBox> list, DEdge edge, double radiusForUnderlyingPolylineCorners)
        {
            P2 rad = new P2(radiusForUnderlyingPolylineCorners, radiusForUnderlyingPolylineCorners);
            IEnumerator <P2> en = edge.DrawingEdge.Attr.GeometryEdge.UnderlyingPolyline.GetEnumerator();

            en.MoveNext();
            P2 p = en.Current;

            list.Add(new Geometry(edge, new BBox(p + rad, p - rad)));
            while (en.MoveNext())
            {
                list.Add(new Line(edge, p, p = en.Current, edge.DrawingEdge.Attr.LineWidth));
                list.Add(new Geometry(edge, new BBox(p + rad, p - rad)));
            }
        }
Exemple #7
0
        const double arrowAngle = 25.0;//degrees
        static internal void DrawArrow(Graphics g, Brush brush, P2 start, P2 end, int lineWidth, ArrowStyle arrowStyle)
        {
            switch (arrowStyle)
            {
            case ArrowStyle.NonSpecified:
            case ArrowStyle.Normal:

                DrawNormalArrow(g, brush, ref start, ref end, lineWidth);
                break;

            case ArrowStyle.Tee:
                DrawTeeArrow(g, brush, ref start, ref end, lineWidth);
                break;

            default:
                throw new InvalidOperationException();
            }
        }
Exemple #8
0
        private static void DrawTeeArrow(Graphics g, Brush brush, ref P2 start, ref P2 end, int lineWidth)
        {
            double lw = lineWidth == -1 ? 1 : lineWidth;

            using (Pen p = new Pen(brush, (float)lw)) {
                g.DrawLine(p, P2ToPointF(start), P2ToPointF(end));
                P2 dir = end - start;
                P2 h   = dir;
                dir /= dir.Length;

                P2 s = new P2(-dir.Y, dir.X);

                s *= 2 * h.Length * ((float)Math.Tan(arrowAngle * 0.5f * (Math.PI / 180.0)));
                s += (1 + lw) * s.Normalize();

                g.DrawLine(p, P2ToPointF(start + s), P2ToPointF(start - s));
            }
        }
Exemple #9
0
        protected override void OnMouseUp(MouseEventArgs args)
        {
            base.OnMouseUp(args);
            MsaglMouseEventArgs iArgs = CreateMouseEventArgs(args);

            gViewer.RaiseMouseUpEvent(iArgs);
            if (NeedToEraseRubber)
            {
                DrawXORFrame();
            }

            if (!iArgs.Handled)
            {
                if (gViewer.OriginalGraph != null && MouseDraggingMode == DraggingMode.WindowZoom)
                {
                    System.Drawing.Point p = mouseDownPoint;
                    double f = Math.Max(Math.Abs(p.X - args.X), Math.Abs(p.Y - args.Y)) / GViewer.dpi;
                    if (f > gViewer.ZoomWindowThreshold && zoomWindow)
                    {
                        mouseUpPoint = new System.Drawing.Point(args.X, args.Y);
                        if (ClientRectangle.Contains(mouseUpPoint))
                        {
                            System.Drawing.Rectangle r = GViewer.RectFromPoints(mouseDownPoint, mouseUpPoint);
                            r.Intersect(gViewer.DestRect);
                            if (GViewer.ModifierKeyWasPressed() == false)
                            {
                                mouseDownPoint.X = r.Left;
                                mouseDownPoint.Y = r.Top;
                                mouseUpPoint.X   = r.Right;
                                mouseUpPoint.Y   = r.Bottom;
                                P2     p1 = gViewer.ScreenToSource(mouseDownPoint);
                                P2     p2 = gViewer.ScreenToSource(mouseUpPoint);
                                double sc = Math.Min((double)ClientRectangle.Width / r.Width,
                                                     (double)ClientRectangle.Height / (double)r.Height);
                                P2 center = 0.5f * (p1 + p2);
                                gViewer.Zoom(center.X, center.Y, sc * gViewer.ZoomF);
                            }
                        }
                    }
                }
            }
            zoomWindow = false;
        }
Exemple #10
0
        internal Line(DObject tag, P2 start, P2 end, double lw)
            : base(tag)
        {
            lineWidth = lw;
            P2 dir = end - start;

            if (lineWidth < 0)
            {
                lineWidth = 1;
            }

            double len = dir.Length;

            if (len > Microsoft.Msagl.Splines.Curve.IntersectionEpsilon)
            {
                dir /= (len / (lineWidth / 2));
                dir  = dir.Rotate(Math.PI / 2);
            }
            else
            {
                dir.X = 0;
                dir.Y = 0;
            }

            this.bBox = new Microsoft.Msagl.Splines.Rectangle(start + dir);
            this.bBox.Add(start - dir);
            this.bBox.Add(end + dir);
            this.bBox.Add(end - dir);
            this.start = start;
            this.end   = end;

            if (this.bBox.LeftTop.X == this.bBox.RightBottom.X)
            {
                bBox.LeftTop     = bBox.LeftTop + new P2(-0.05f, 0);
                bBox.RightBottom = bBox.RightBottom + new P2(0.05f, 0);
            }
            if (this.bBox.LeftTop.Y == this.bBox.RightBottom.Y)
            {
                bBox.LeftTop     = bBox.LeftTop + new P2(0, -0.05f);
                bBox.RightBottom = bBox.RightBottom + new P2(0, 0.05f);
            }
        }
        private static void ShowCurvesWithColorsSet(IEnumerable <Microsoft.Msagl.Splines.ICurve> curves,
                                                    Microsoft.Msagl.Drawing.Graph g)
        {
            AllocateDebugCurves(g);
            //   g.ShowControlPoints = true;

            Microsoft.Msagl.Splines.Rectangle graphBox = new Microsoft.Msagl.Splines.Rectangle();

            AddCurvesToGraph(curves, g);
            bool firstTime = true;

            foreach (Microsoft.Msagl.Splines.ICurve c0 in curves)
            {
                if (c0 != null)
                {
                    Microsoft.Msagl.Splines.Parallelogram b = c0.ParallelogramNodeOverICurve.Parallelogram;

                    for (int i = 0; i < 4; i++)
                    {
                        if (firstTime)
                        {
                            firstTime = false;
                            graphBox  = new Rectangle(b.Vertex((VertexId)i));
                        }
                        graphBox.Add(b.Vertex((VertexId)i));
                    }
                }
            }

            Microsoft.Msagl.Point del = (graphBox.LeftBottom - graphBox.RightTop) / 10;
            graphBox.Add(graphBox.LeftBottom + del);
            graphBox.Add(graphBox.RightTop - del);
            GeometryGraph gg = new GeometryGraph();

            gg.BoundingBox  = graphBox;
            g.GeometryGraph = gg;
            try {
                DisplayGraph(g);
            } catch (Exception e) {
                Console.WriteLine(e);
            }
        }
Exemple #12
0
        private static void DrawNormalArrow(Graphics g, Brush brush, ref P2 start, ref P2 end, int lineWidth)
        {
            PointF[] points;

            if (lineWidth == 1)
            {
                P2 dir = end - start;
                P2 h   = dir;
                dir /= dir.Length;

                P2 s = new P2(-dir.Y, dir.X);

                s *= h.Length * ((float)Math.Tan(arrowAngle * 0.5f * (Math.PI / 180.0)));

                points = new PointF[] { P2ToPointF(start + s), P2ToPointF(end), P2ToPointF(start - s) };
            }
            else
            {
                P2 dir = end - start;
                P2 h   = dir;
                dir /= dir.Length;
                P2     s  = new P2(-dir.Y, dir.X);
                float  w  = (float)(0.5f * lineWidth);
                P2     s0 = w * s;
                double al = arrowAngle * 0.5f * (double)(Math.PI / 180.0);
                s *= h.Length * ((float)Math.Tan(al));
                s += s0;

                points = new PointF[] { P2ToPointF(start + s), P2ToPointF(start - s), P2ToPointF(end - s0), P2ToPointF(end + s0) };
                P2     center = end - dir * w * (float)Math.Tan(al);
                double rad    = w / (double)Math.Cos(al);
                g.FillEllipse(brush,
                              (float)center.X - (float)rad,
                              (float)center.Y - (float)rad,
                              2.0f * (float)rad,
                              2.0f * (float)rad);
            }


            g.FillPolygon(brush, points);
        }
Exemple #13
0
 void viewer_MouseDown(object sender, MsaglMouseEventArgs e)
 {
     if (viewer.LayoutIsEditable)
     {
         PressedMouseButtons  = GetPressedButtons(e);
         mouseDownSourcePoint = viewer.ScreenToSource(e);
         mouseDownScreenPoint = new Point(e.X, e.Y);
         if (e.LeftButtonIsPressed)
         {
             LeftMouseButtonWasPressed = true;
             if (!(viewer.ObjectUnderMouseCursor is IViewerEdge))
             {
                 ActiveDraggedObject = viewer.ObjectUnderMouseCursor;
             }
             if (ActiveDraggedObject != null)
             {
                 e.Handled = true;
             }
             if (this.SelectedEdge != null)
             {
                 this.CheckIfDraggingPolylineVertex(e);
             }
         }
         else if (e.RightButtonIsPressed)
         {
             if (this.SelectedEdge != null)
             {
                 ProcessRightClickOnSelectedEdge(e);
             }
         }
         else if (e.MiddleButtonIsPressed && viewer.ObjectUnderMouseCursor is IViewerNode)
         {
             SourceOfInsertedEdge = viewer.ObjectUnderMouseCursor as IViewerNode;
             UnselectEverything();
             MiddleMouseButtonWasPressed = true;
             viewer.StartDrawingRubberLine(e);
         }
     }
 }
Exemple #14
0
        public Couple <Site, PolylineCornerType> AnalyzeInsertOrDeletePolylineCorner(Point point, double tolerance)
        {
            if (this.SelectedEdge == null)
            {
                return(null);
            }

            tolerance += this.SelectedEdge.Edge.Attr.LineWidth;

            Site corner = GeometryGraphEditor.GetPreviousSite(SelectedEdge.Edge.Attr.GeometryEdge, point);

            if (corner != null)
            {
                return(new Couple <Site, PolylineCornerType>(corner, PolylineCornerType.PreviousCornerForInsertion));
            }

            corner = GeometryGraphEditor.FindCornerForEdit(this.SelectedEdge.Edge.Attr.GeometryEdge.UnderlyingPolyline, point, tolerance);
            if (corner != null)
            {
                return(new Couple <Site, PolylineCornerType>(corner, PolylineCornerType.CornerToDelete));
            }

            return(null);
        }
 internal PointF PointF(P2 p)
 {
     return(new PointF((float)p.X, (float)p.Y));
 }
Exemple #16
0
 static internal void DrawLine(Graphics g, Pen pen, P2 start, P2 end)
 {
     g.DrawLine(pen, P2ToPointF(start), P2ToPointF(end));
 }
Exemple #17
0
        private void selectNode(direction direction)
        {
            if (this._selectedNode != null)
            {
                Microsoft.Msagl.Point selectedNodePosition = default(Microsoft.Msagl.Point);
                selectedNodePosition = _selectedNode.Attr.Pos;

                Node   nearestNode   = null;
                double nearestRange  = 0;
                double checkingRange = 0;

                //check each node
                foreach (Node checkingNode in _gViewer.Graph.NodeMap.Values)
                {
                    //except the selected one ;)
                    if (!ReferenceEquals(checkingNode, _selectedNode))
                    {
                        switch (direction)
                        {
                        case direction.up:
                        case direction.down:
                            //check for Y-axis
                            //check if the direction is up and the node which should be checked is upper
                            //or the direction is down and the node is lower
                            if ((direction == direction.up && checkingNode.Attr.Pos.Y > selectedNodePosition.Y) || (direction == direction.down && checkingNode.Attr.Pos.Y < selectedNodePosition.Y))
                            {
                                //if the node is valid check fi there is allready a "nearest node"
                                if (nearestNode == null)
                                {
                                    //if not save the node and the range between the selected node and the checked node
                                    nearestNode  = checkingNode;
                                    nearestRange = getRange(checkingNode.Attr.Pos, selectedNodePosition);
                                }
                                else
                                {
                                    checkingRange = getRange(checkingNode.Attr.Pos, selectedNodePosition);
                                    //check if the selected node is nearer then the nearest node
                                    if (checkingRange < nearestRange)
                                    {
                                        nearestNode  = checkingNode;
                                        nearestRange = checkingRange;
                                    }
                                }
                            }
                            break;

                        case direction.right:
                        case direction.left:
                            //check X-axis same way
                            if ((direction == direction.right && checkingNode.Attr.Pos.X > selectedNodePosition.X) || (direction == direction.left && checkingNode.Attr.Pos.X < selectedNodePosition.X))
                            {
                                if (nearestNode == null)
                                {
                                    nearestNode  = checkingNode;
                                    nearestRange = getRange(checkingNode.Attr.Pos, selectedNodePosition);
                                }
                                else
                                {
                                    checkingRange = getRange(checkingNode.Attr.Pos, selectedNodePosition);
                                    if (checkingRange < nearestRange)
                                    {
                                        nearestNode  = checkingNode;
                                        nearestRange = checkingRange;
                                    }
                                }
                            }
                            break;
                        }
                    }
                }

                //if there is a nearest node
                if (nearestNode != null)
                {
                    selectNode(nearestNode.Id);
                    //select it
                }
            }
        }
Exemple #18
0
 static PointF P2ToPointF(P2 p)
 {
     return(new PointF((float)p.X, (float)p.Y));
 }
Exemple #19
0
 private bool MouseScreenPointIsCloseEnoughToVertex(Point point, double radius)
 {
     return((point - this.mouseDownSourcePoint).Length < radius);
 }
Exemple #20
0
 private double getRange(Microsoft.Msagl.Point position1, Microsoft.Msagl.Point position2)
 {
     return(Math.Max(position1.X, position2.X) - Math.Min(position1.X, position2.X) + Math.Max(position1.Y, position2.Y) - Math.Min(position1.Y, position2.Y));
 }
Exemple #21
0
 public void InsertPolylineCorner(Point point, Site previousCorner)
 {
     this.viewer.InvalidateBeforeTheChange(SelectedEdge);
     this.geomGraphEditor.InsertSite(this.SelectedEdge.Edge.Attr.GeometryEdge, point, previousCorner, SelectedEdge);
     this.viewer.Invalidate(SelectedEdge);
 }