コード例 #1
0
ファイル: Stroke.cs プロジェクト: dox0/DotNet471RS3
        /// <summary>
        /// Clip
        /// </summary>
        /// <param name="cutAt">Fragment markers for clipping</param>
        private StrokeCollection Clip(StrokeFIndices[] cutAt)
        {
            System.Diagnostics.Debug.Assert(cutAt != null);
            System.Diagnostics.Debug.Assert(cutAt.Length != 0);

#if DEBUG
            //
            // Assert there are  no overlaps between multiple StrokeFIndices
            //
            AssertSortedNoOverlap(cutAt);
#endif

            StrokeCollection leftovers = new StrokeCollection();
            if (cutAt.Length == 0)
            {
                return(leftovers);
            }

            if ((cutAt.Length == 1) && cutAt[0].IsFull)
            {
                leftovers.Add(this.Clone()); //clip and erase always return clones
                return(leftovers);
            }


            StylusPointCollection sourceStylusPoints = this.StylusPoints;
            if (this.DrawingAttributes.FitToCurve)
            {
                sourceStylusPoints = this.GetBezierStylusPoints();
            }

            //
            // Assert the findices are NOT out of range with the packets
            //
            System.Diagnostics.Debug.Assert(false == ((!DoubleUtil.AreClose(cutAt[cutAt.Length - 1].EndFIndex, StrokeFIndices.AfterLast)) &&
                                                      Math.Ceiling(cutAt[cutAt.Length - 1].EndFIndex) > sourceStylusPoints.Count - 1));

            for (int i = 0; i < cutAt.Length; i++)
            {
                StrokeFIndices fragment = cutAt[i];
                if (DoubleUtil.GreaterThanOrClose(fragment.BeginFIndex, fragment.EndFIndex))
                {
                    // ISSUE-2004/06/26-vsmirnov - temporary workaround for bugs
                    // in point erasing: drop invalid fragments
                    System.Diagnostics.Debug.Assert(DoubleUtil.LessThan(fragment.BeginFIndex, fragment.EndFIndex));
                    continue;
                }

                Stroke stroke = Copy(sourceStylusPoints, fragment.BeginFIndex, fragment.EndFIndex);

                // Add the stroke to the output collection
                leftovers.Add(stroke);
            }

            return(leftovers);
        }
コード例 #2
0
        /// <summary>
        /// Performs a deep copy of the StrokeCollection.
        /// </summary>
        public virtual StrokeCollection Clone()
        {
            StrokeCollection clone = new StrokeCollection();

            foreach (Stroke s in this)
            {
                // samgeo - Presharp issue
                // Presharp gives a warning when get methods might deref a null.  It's complaining
                // here that s could be null, but StrokeCollection never allows nulls to be added
                // so this is not possible
#pragma warning disable 1634, 1691
#pragma warning suppress 6506
                clone.Add(s.Clone());
#pragma warning restore 1634, 1691
            }

            //
            // clone epc if we have them
            //
            if (_extendedProperties != null)
            {
                clone._extendedProperties = _extendedProperties.Clone();
            }
            return(clone);
        }
コード例 #3
0
        /// <summary>
        /// Hit-testing with rectangle
        /// </summary>
        /// <param name="bounds">hitting rectangle</param>
        /// <param name="percentageWithinBounds">the percentage of the stroke that must be within
        /// the bounds to be considered hit</param>
        /// <returns>collection of strokes found inside the rectangle</returns>
        public StrokeCollection HitTest(Rect bounds, int percentageWithinBounds)
        {
            // Check the input parameters
            if ((percentageWithinBounds < 0) || (percentageWithinBounds > 100))
            {
                throw new System.ArgumentOutOfRangeException("percentageWithinBounds");
            }
            if (bounds.IsEmpty)
            {
                return(new StrokeCollection());
            }

            // Enumerate thru the strokes collect those found within the rectangle.
            StrokeCollection hits = new StrokeCollection();

            foreach (Stroke stroke in this)
            {
                // samgeo - Presharp issue
                // Presharp gives a warning when get methods might deref a null.  It's complaining
                // here that 'stroke'' could be null, but StrokeCollection never allows nulls to be added
                // so this is not possible
#pragma warning disable 1634, 1691
#pragma warning suppress 6506
                if (true == stroke.HitTest(bounds, percentageWithinBounds))
                {
                    hits.Add(stroke);
                }
#pragma warning restore 1634, 1691
            }
            return(hits);
        }
コード例 #4
0
        /// <summary>
        /// Calculates the position of an error label based upon the bounding box of the elements
        /// causing the error.
        ///
        /// Helper Function
        /// </summary>
        private System.Drawing.Point getLabelPosition(ParseError e, List <System.Windows.Ink.Stroke> iStrokes)
        {
            if (e.errors.Count == 0)
            {
                // TEMP HACK return the origin (or near it) when there are no associated elements
                return(new System.Drawing.Point(10, 10));
            }

            // Get bounding box of strokes in screen space
            System.Drawing.Point bbUpperLeft;
            System.Drawing.Point bbLowerRight;
            System.Windows.Ink.StrokeCollection strokes = new System.Windows.Ink.StrokeCollection();

            foreach (System.Windows.Ink.Stroke s in iStrokes)
            {
                strokes.Add(s);
            }

            System.Windows.Rect strokesBB = strokes.GetBounds();
            bbUpperLeft  = new System.Drawing.Point((int)strokesBB.X, (int)strokesBB.Y);
            bbLowerRight = new System.Drawing.Point((int)strokesBB.Right, (int)strokesBB.Bottom);

            // return position just to the right of the bounding box
            System.Drawing.Point returnPoint =
                new System.Drawing.Point(bbLowerRight.X + 10, bbUpperLeft.Y + 10);

            return(returnPoint);
        }
コード例 #5
0
ファイル: StrokeConverter.cs プロジェクト: aragoubi/Nine
        public static WindowsInk.StrokeCollection ToWindowsStrokes(Collection<NineInk.Stroke> nineStrokes)
        {
            var windowsStrokes = new WindowsInk.StrokeCollection();

            foreach (var stroke in nineStrokes)
                windowsStrokes.Add(ToWindowsStroke(stroke));

            return windowsStrokes;
        }
コード例 #6
0
        public static WindowsInk.StrokeCollection ToWindowsStrokes(Collection <NineInk.Stroke> nineStrokes)
        {
            var windowsStrokes = new WindowsInk.StrokeCollection();

            foreach (var stroke in nineStrokes)
            {
                windowsStrokes.Add(ToWindowsStroke(stroke));
            }

            return(windowsStrokes);
        }
コード例 #7
0
        /// <summary>
        /// Replace
        /// </summary>
        /// <param name="strokeToReplace"></param>
        /// <param name="strokesToReplaceWith"></param>
        public void Replace(Stroke strokeToReplace, StrokeCollection strokesToReplaceWith)
        {
            if (strokeToReplace == null)
            {
                throw new ArgumentNullException(SR.Get(SRID.EmptyScToReplace));
            }

            StrokeCollection strokesToReplace = new StrokeCollection();

            strokesToReplace.Add(strokeToReplace);
            this.Replace(strokesToReplace, strokesToReplaceWith);
        }
コード例 #8
0
        /// <summary>
        /// Return all hit strokes that the StylusShape intersects and returns them in a StrokeCollection
        /// </summary>
        private StrokeCollection PointHitTest(Point point, StylusShape shape)
        {
            // Create the collection to return
            StrokeCollection hits = new StrokeCollection();

            for (int i = 0; i < this.Count; i++)
            {
                Stroke stroke = this[i];
                if (stroke.HitTest(new Point[] { point }, shape))
                {
                    hits.Add(stroke);
                }
            }

            return(hits);
        }
コード例 #9
0
ファイル: Stroke2.cs プロジェクト: beda2280/wpf-1
        /// <summary>
        /// Calculate the after-erasing Strokes. Only the "out-segments" are left after this operation.
        /// </summary>
        /// <param name="cutAt">Array of intersections indicating the erasing locations</param>
        /// <returns></returns>
        internal StrokeCollection Erase(StrokeIntersection[] cutAt)
        {
            System.Diagnostics.Debug.Assert(cutAt != null);

            // Nothing needs to be erased
            if (cutAt.Length == 0)
            {
                StrokeCollection strokes = new StrokeCollection();
                strokes.Add(this.Clone()); //clip and erase always return clones for this condition
                return(strokes);
            }

            // Two assertions are deferred to the private erase function to avoid duplicate code.
            // 1. AssertSortedNoOverlap
            // 2. Check whether the insegments are out of range with the packets
            StrokeFIndices[] hitSegments = StrokeIntersection.GetHitSegments(cutAt);
            return(this.Erase(hitSegments));
        }
コード例 #10
0
        /// <summary>
        /// Issue: what's the return value
        /// </summary>
        /// <param name="path"></param>
        /// <param name="stylusShape"></param>
        /// <returns></returns>
        public StrokeCollection HitTest(IEnumerable <Point> path, StylusShape stylusShape)
        {
            // Check the input parameters
            if (stylusShape == null)
            {
                throw new System.ArgumentNullException("stylusShape");
            }
            if (path == null)
            {
                throw new System.ArgumentNullException("path");
            }
            if (IEnumerablePointHelper.GetCount(path) == 0)
            {
                return(new StrokeCollection());
            }

            // validate input
            ErasingStroke erasingStroke = new ErasingStroke(stylusShape, path);
            Rect          erasingBounds = erasingStroke.Bounds;

            if (erasingBounds.IsEmpty)
            {
                return(new StrokeCollection());
            }
            StrokeCollection hits = new StrokeCollection();

            foreach (Stroke stroke in this)
            {
                // samgeo - Presharp issue
                // Presharp gives a warning when get methods might deref a null.  It's complaining
                // here that 'stroke'' could be null, but StrokeCollection never allows nulls to be added
                // so this is not possible
#pragma warning disable 1634, 1691
#pragma warning suppress 6506
                if (erasingBounds.IntersectsWith(stroke.GetBounds()) &&
                    erasingStroke.HitTest(StrokeNodeIterator.GetIterator(stroke, stroke.DrawingAttributes)))
                {
                    hits.Add(stroke);
                }
#pragma warning restore 1634, 1691
            }

            return(hits);
        }
コード例 #11
0
        /// <summary>
        /// Hit-testing with lasso
        /// </summary>
        /// <param name="lassoPoints">points making the lasso</param>
        /// <param name="percentageWithinLasso">the margin value to tell whether a stroke
        /// is in or outside of the rect</param>
        /// <returns>collection of strokes found inside the rectangle</returns>
        public StrokeCollection HitTest(IEnumerable <Point> lassoPoints, int percentageWithinLasso)
        {
            // Check the input parameters
            if (lassoPoints == null)
            {
                throw new System.ArgumentNullException("lassoPoints");
            }
            if ((percentageWithinLasso < 0) || (percentageWithinLasso > 100))
            {
                throw new System.ArgumentOutOfRangeException("percentageWithinLasso");
            }

            if (IEnumerablePointHelper.GetCount(lassoPoints) < 3)
            {
                return(new StrokeCollection());
            }

            Lasso lasso = new SingleLoopLasso();

            lasso.AddPoints(lassoPoints);

            // Enumerate through the strokes and collect those captured by the lasso.
            StrokeCollection lassoedStrokes = new StrokeCollection();

            foreach (Stroke stroke in this)
            {
                if (percentageWithinLasso == 0)
                {
                    lassoedStrokes.Add(stroke);
                }
                else
                {
                    StrokeInfo strokeInfo = null;
                    try
                    {
                        strokeInfo = new StrokeInfo(stroke);

                        StylusPointCollection stylusPoints = strokeInfo.StylusPoints;
                        double target = strokeInfo.TotalWeight * percentageWithinLasso / 100.0f - Stroke.PercentageTolerance;

                        for (int i = 0; i < stylusPoints.Count; i++)
                        {
                            if (true == lasso.Contains((Point)stylusPoints[i]))
                            {
                                target -= strokeInfo.GetPointWeight(i);
                                if (DoubleUtil.LessThanOrClose(target, 0f))
                                {
                                    lassoedStrokes.Add(stroke);
                                    break;
                                }
                            }
                        }
                    }
                    finally
                    {
                        if (strokeInfo != null)
                        {
                            //detach from event handlers, or else we leak.
                            strokeInfo.Detach();
                        }
                    }
                }
            }

            // Return the resulting collection
            return(lassoedStrokes);
        }