コード例 #1
0
ファイル: EditorState.cs プロジェクト: qipa/SpiroNet
        public EditorState()
        {
            _tool = EditorTool.Spiro;
            _mode = EditorMode.Create;

            _displayKnots  = true;
            _displayGuides = true;

            _snapX      = 15.0;
            _snapY      = 15.0;
            _enableSnap = true;

            _shape              = null;
            _hitTreshold        = 7;
            _hitTresholdSquared = 49;
            _hitSetShapes       = new HashSet <SpiroShape>();
            _hitSetPoints       = new HashSet <int>();
            _hitListShapes      = new ObservableCollection <SpiroShape>();
            _hitListPoints      = new ObservableCollection <int>();
            _isStroked          = true;
            _isFilled           = false;
            _isClosed           = true;
            _isTagged           = false;
            _pointType          = SpiroPointType.G4;

            _isCaptured      = false;
            _snapTreshold    = 10.0;
            _snapMode        = GuideSnapMode.Point | GuideSnapMode.Middle | GuideSnapMode.Intersection | GuideSnapMode.Horizontal | GuideSnapMode.Vertical;
            _snapPointRadius = 3.5;
            _snapPoint       = default(GuidePoint);
            _haveSnapPoint   = false;
        }
コード例 #2
0
ファイル: EditorState.cs プロジェクト: wieslawsoltes/SpiroNet
        public EditorState()
        {
            _tool = EditorTool.Spiro;
            _mode = EditorMode.Create;

            _displayKnots = true;
            _displayGuides = true;

            _snapX = 15.0;
            _snapY = 15.0;
            _enableSnap = true;

            _shape = null;
            _hitTreshold = 7;
            _hitTresholdSquared = 49;
            _hitSetShapes = new HashSet<SpiroShape>();
            _hitSetPoints = new HashSet<int>();
            _hitListShapes = new ObservableCollection<SpiroShape>();
            _hitListPoints = new ObservableCollection<int>();
            _isStroked = true;
            _isFilled = false;
            _isClosed = true;
            _isTagged = false;
            _pointType = SpiroPointType.G4;

            _isCaptured = false;
            _snapTreshold = 10.0;
            _snapMode = GuideSnapMode.Point | GuideSnapMode.Middle | GuideSnapMode.Intersection | GuideSnapMode.Horizontal | GuideSnapMode.Vertical;
            _snapPointRadius = 3.5;
            _snapPoint = default(GuidePoint);
            _haveSnapPoint = false;
        }
コード例 #3
0
ファイル: SpiroEditor.cs プロジェクト: wieslawsoltes/SpiroNet
        public static bool TryToSnapToGuideLine(IList<GuideLine> guides, GuideSnapMode mode, double treshold, GuidePoint point, out GuidePoint snap, out GuideSnapMode result)
        {
            snap = default(GuidePoint);
            result = default(GuideSnapMode);

            if (guides.Count == 0 || mode == GuideSnapMode.None)
            {
                return false;
            }

            if (mode.HasFlag(GuideSnapMode.Point))
            {
                foreach (var guide in guides)
                {
                    var distance0 = GuideHelpers.Distance(guide.Point0, point);
                    if (distance0 < treshold)
                    {
                        snap = new GuidePoint(guide.Point0.X, guide.Point0.Y);
                        result = GuideSnapMode.Point;
                        return true;
                    }

                    var distance1 = GuideHelpers.Distance(guide.Point1, point);
                    if (distance1 < treshold)
                    {
                        snap = new GuidePoint(guide.Point1.X, guide.Point1.Y);
                        result = GuideSnapMode.Point;
                        return true;
                    }
                }
            }

            if (mode.HasFlag(GuideSnapMode.Middle))
            {
                foreach (var guide in guides)
                {
                    var middle = GuideHelpers.Middle(guide.Point0, guide.Point1);
                    var distance = GuideHelpers.Distance(middle, point);
                    if (distance < treshold)
                    {
                        snap = middle;
                        result = GuideSnapMode.Middle;
                        return true;
                    }
                }
            }

            if (mode.HasFlag(GuideSnapMode.Nearest))
            {
                foreach (var guide in guides)
                {
                    var nearest = GuideHelpers.NearestPointOnLine(guide.Point0, guide.Point1, point);
                    var distance = GuideHelpers.Distance(nearest, point);
                    if (distance < treshold)
                    {
                        snap = nearest;
                        result = GuideSnapMode.Nearest;
                        return true;
                    }
                }
            }

            if (mode.HasFlag(GuideSnapMode.Intersection))
            {
                foreach (var guide0 in guides)
                {
                    foreach (var guide1 in guides)
                    {
                        if (guide0 == guide1)
                            continue;

                        GuidePoint intersection;
                        if (GuideHelpers.LineLineIntersection(guide0.Point0, guide0.Point1, guide1.Point0, guide1.Point1, out intersection))
                        {
                            var distance = GuideHelpers.Distance(intersection, point);
                            if (distance < treshold)
                            {
                                snap = intersection;
                                result = GuideSnapMode.Intersection;
                                return true;
                            }
                        }
                    }
                }
            }

            double horizontal = default(double);
            double vertical = default(double);

            if (mode.HasFlag(GuideSnapMode.Horizontal))
            {
                foreach (var guide in guides)
                {
                    if (point.Y >= guide.Point0.Y - treshold && point.Y <= guide.Point0.Y + treshold)
                    {
                        snap = new GuidePoint(point.X, guide.Point0.Y);
                        result |= GuideSnapMode.Horizontal;
                        horizontal = guide.Point0.Y;
                        break;
                    }

                    if (point.Y >= guide.Point1.Y - treshold && point.Y <= guide.Point1.Y + treshold)
                    {
                        snap = new GuidePoint(point.X, guide.Point1.Y);
                        result |= GuideSnapMode.Horizontal;
                        horizontal = guide.Point1.Y;
                        break;
                    }
                }
            }

            if (mode.HasFlag(GuideSnapMode.Vertical))
            {
                foreach (var guide in guides)
                {
                    if (point.X >= guide.Point0.X - treshold && point.X <= guide.Point0.X + treshold)
                    {
                        snap = new GuidePoint(guide.Point0.X, point.Y);
                        result |= GuideSnapMode.Vertical;
                        vertical = guide.Point0.X;
                        break;
                    }

                    if (point.X >= guide.Point1.X - treshold && point.X <= guide.Point1.X + treshold)
                    {
                        snap = new GuidePoint(guide.Point1.X, point.Y);
                        result |= GuideSnapMode.Vertical;
                        vertical = guide.Point1.X;
                        break;
                    }
                }
            }

            if (result.HasFlag(GuideSnapMode.Horizontal) || result.HasFlag(GuideSnapMode.Vertical))
            {
                snap = new GuidePoint(
                    result.HasFlag(GuideSnapMode.Vertical) ? vertical : point.X,
                    result.HasFlag(GuideSnapMode.Horizontal) ? horizontal : point.Y);
                return true;
            }

            return false;
        }
コード例 #4
0
ファイル: SpiroEditor.cs プロジェクト: nagyistge/SpiroNet
        public static bool TryToSnapToGuideLine(IList <GuideLine> guides, GuideSnapMode mode, double treshold, GuidePoint point, out GuidePoint snap, out GuideSnapMode result)
        {
            snap   = default(GuidePoint);
            result = default(GuideSnapMode);

            if (guides.Count == 0 || mode == GuideSnapMode.None)
            {
                return(false);
            }

            if (mode.HasFlag(GuideSnapMode.Point))
            {
                foreach (var guide in guides)
                {
                    var distance0 = GuideHelpers.Distance(guide.Point0, point);
                    if (distance0 < treshold)
                    {
                        snap   = new GuidePoint(guide.Point0.X, guide.Point0.Y);
                        result = GuideSnapMode.Point;
                        return(true);
                    }

                    var distance1 = GuideHelpers.Distance(guide.Point1, point);
                    if (distance1 < treshold)
                    {
                        snap   = new GuidePoint(guide.Point1.X, guide.Point1.Y);
                        result = GuideSnapMode.Point;
                        return(true);
                    }
                }
            }

            if (mode.HasFlag(GuideSnapMode.Middle))
            {
                foreach (var guide in guides)
                {
                    var middle   = GuideHelpers.Middle(guide.Point0, guide.Point1);
                    var distance = GuideHelpers.Distance(middle, point);
                    if (distance < treshold)
                    {
                        snap   = middle;
                        result = GuideSnapMode.Middle;
                        return(true);
                    }
                }
            }

            if (mode.HasFlag(GuideSnapMode.Nearest))
            {
                foreach (var guide in guides)
                {
                    var nearest  = GuideHelpers.NearestPointOnLine(guide.Point0, guide.Point1, point);
                    var distance = GuideHelpers.Distance(nearest, point);
                    if (distance < treshold)
                    {
                        snap   = nearest;
                        result = GuideSnapMode.Nearest;
                        return(true);
                    }
                }
            }

            if (mode.HasFlag(GuideSnapMode.Intersection))
            {
                foreach (var guide0 in guides)
                {
                    foreach (var guide1 in guides)
                    {
                        if (guide0 == guide1)
                        {
                            continue;
                        }

                        GuidePoint intersection;
                        if (GuideHelpers.LineLineIntersection(guide0.Point0, guide0.Point1, guide1.Point0, guide1.Point1, out intersection))
                        {
                            var distance = GuideHelpers.Distance(intersection, point);
                            if (distance < treshold)
                            {
                                snap   = intersection;
                                result = GuideSnapMode.Intersection;
                                return(true);
                            }
                        }
                    }
                }
            }

            double horizontal = default(double);
            double vertical   = default(double);

            if (mode.HasFlag(GuideSnapMode.Horizontal))
            {
                foreach (var guide in guides)
                {
                    if (point.Y >= guide.Point0.Y - treshold && point.Y <= guide.Point0.Y + treshold)
                    {
                        snap       = new GuidePoint(point.X, guide.Point0.Y);
                        result    |= GuideSnapMode.Horizontal;
                        horizontal = guide.Point0.Y;
                        break;
                    }

                    if (point.Y >= guide.Point1.Y - treshold && point.Y <= guide.Point1.Y + treshold)
                    {
                        snap       = new GuidePoint(point.X, guide.Point1.Y);
                        result    |= GuideSnapMode.Horizontal;
                        horizontal = guide.Point1.Y;
                        break;
                    }
                }
            }

            if (mode.HasFlag(GuideSnapMode.Vertical))
            {
                foreach (var guide in guides)
                {
                    if (point.X >= guide.Point0.X - treshold && point.X <= guide.Point0.X + treshold)
                    {
                        snap     = new GuidePoint(guide.Point0.X, point.Y);
                        result  |= GuideSnapMode.Vertical;
                        vertical = guide.Point0.X;
                        break;
                    }

                    if (point.X >= guide.Point1.X - treshold && point.X <= guide.Point1.X + treshold)
                    {
                        snap     = new GuidePoint(guide.Point1.X, point.Y);
                        result  |= GuideSnapMode.Vertical;
                        vertical = guide.Point1.X;
                        break;
                    }
                }
            }

            if (result.HasFlag(GuideSnapMode.Horizontal) || result.HasFlag(GuideSnapMode.Vertical))
            {
                snap = new GuidePoint(
                    result.HasFlag(GuideSnapMode.Vertical) ? vertical : point.X,
                    result.HasFlag(GuideSnapMode.Horizontal) ? horizontal : point.Y);
                return(true);
            }

            return(false);
        }