コード例 #1
0
 int ITextRangeProvider.CompareEndpoints(TextPatternRangeEndpoint endpoint, ITextRangeProvider targetRange, TextPatternRangeEndpoint targetEndpoint)
 {
     // TextPatternRange already verifies the other range comes from the same element before forwarding so we only need to worry about
     // comparing the endpoints.
     WindowsEditBoxRange editRange = (WindowsEditBoxRange)targetRange;
     int e1 = (endpoint == TextPatternRangeEndpoint.Start) ? Start : End;
     int e2 = (targetEndpoint == TextPatternRangeEndpoint.Start) ? editRange.Start : editRange.End;
     return e1 - e2;
 }
コード例 #2
0
ファイル: WindowsRichEditRange.cs プロジェクト: JianwenSun/cc
 int ITextRangeProvider.CompareEndpoints(TextPatternRangeEndpoint endpoint, ITextRangeProvider targetRange, TextPatternRangeEndpoint targetEndpoint)
 {
     // Get the endpoint character positions using ITextRange::GetStart && ITextRange::GetEnd.
     // Subtract the character positions to get the return value.
     WindowsRichEditRange otherRange = (WindowsRichEditRange)targetRange;
     int e1 = (endpoint == TextPatternRangeEndpoint.Start) ? _range.Start : _range.End;
     int e2 = (targetEndpoint == TextPatternRangeEndpoint.Start) ? otherRange._range.Start : otherRange._range.End;
     return e1 - e2;
 }
コード例 #3
0
        public int CompareEndpoints(TextPatternRangeEndpoint endpoint, ITextRangeProvider targetRange, TextPatternRangeEndpoint targetEndpoint)
        {
            if (!(targetRange is TextRangeProviderWrapper))
            {
                throw new ArgumentException(SR.Get(SRID.TextRangeProvider_InvalidRangeProvider, "targetRange"));
            }

            object[] args = new object[] { endpoint, targetRange, targetEndpoint };
            return (int)ElementUtil.Invoke(_peer, new DispatcherOperationCallback(CompareEndpoints), args);
        }
コード例 #4
0
ファイル: TextRange.cs プロジェクト: apetrovskiy/STUPS
 public int CompareEndpoints(TextPatternRangeEndpoint endpoint, TextPatternRange targetRange, TextPatternRangeEndpoint targetEndpoint)
 {
     try
     {
         return this._range.CompareEndpoints(
             (UIAutomationClient.TextPatternRangeEndpoint)endpoint,
             targetRange.NativeRange,
             (UIAutomationClient.TextPatternRangeEndpoint)targetEndpoint);
     }
     catch (System.Runtime.InteropServices.COMException e)
     {
         Exception newEx; if (Utility.ConvertException(e, out newEx)) { throw newEx; } else { throw; }
     }
 }
コード例 #5
0
 public void MoveEndpointByRange(TextPatternRangeEndpoint endpoint, TextPatternRange targetRange, TextPatternRangeEndpoint targetEndpoint)
 {
     try
     {
         this._range.MoveEndpointByRange(
             (UIAutomationClient.TextPatternRangeEndpoint)endpoint,
             targetRange.NativeRange,
             (UIAutomationClient.TextPatternRangeEndpoint)targetEndpoint);
     }
     catch (System.Runtime.InteropServices.COMException e)
     {
         Exception newEx; if (Utility.ConvertException(e, out newEx))
         {
             throw newEx;
         }
         else
         {
             throw;
         }
     }
 }
コード例 #6
0
ファイル: TextRange.cs プロジェクト: Ginger-Automation/Ginger
 public int MoveEndpointByUnit(TextPatternRangeEndpoint endpoint, TextUnit unit, int count)
 {
     try
     {
         return(this._range.MoveEndpointByUnit(
                    (UIAutomationClient.TextPatternRangeEndpoint)endpoint,
                    (UIAutomationClient.TextUnit)unit,
                    count));
     }
     catch (System.Runtime.InteropServices.COMException e)
     {
         Exception newEx; if (Utility.ConvertException(e, out newEx))
         {
             throw newEx;
         }
         else
         {
             throw;
         }
     }
 }
コード例 #7
0
        public void MoveEndpointByRange(TextPatternRangeEndpoint endpoint, ITextRangeProvider targetRange, TextPatternRangeEndpoint targetEndpoint)
        {
            FooTextBoxRangeProvider other = targetRange as FooTextBoxRangeProvider;

            if (other == null)
            {
                throw new ArgumentException("");
            }

            if (endpoint == TextPatternRangeEndpoint.Start)
            {
                if (targetEndpoint == TextPatternRangeEndpoint.Start)
                {
                    this.start = other.start;
                }
                if (targetEndpoint == TextPatternRangeEndpoint.End)
                {
                    this.start = other.end;
                }
                if (this.start > this.end)
                {
                    this.end = this.start;
                }
                return;
            }
            if (endpoint == TextPatternRangeEndpoint.End)
            {
                if (targetEndpoint == TextPatternRangeEndpoint.Start)
                {
                    this.end = other.start;
                }
                if (targetEndpoint == TextPatternRangeEndpoint.End)
                {
                    this.end = other.end;
                }
                return;
            }
            throw new ArgumentException("endpointに未知の値が指定されました");
        }
コード例 #8
0
        public int CompareEndpoints(TextPatternRangeEndpoint endpoint,
                                    ITextRangeProvider targetRange,
                                    TextPatternRangeEndpoint targetEndpoint)
        {
            TextRangeProvider targetRangeProvider = targetRange as TextRangeProvider;

            if (targetRangeProvider == null)
            {
                throw new ArgumentNullException();
            }

            if (targetRangeProvider.TextProvider != provider)
            {
                throw new ArgumentException();
            }

            int point      = endpoint == TextPatternRangeEndpoint.End ? EndPoint : StartPoint;
            int targePoint = (targetEndpoint == TextPatternRangeEndpoint.End)
                                ? targetRangeProvider.EndPoint : targetRangeProvider.StartPoint;

            return(point.CompareTo(targePoint));
        }
コード例 #9
0
        public void MoveEndpointByRange(TextPatternRangeEndpoint endpoint, ITextRangeProvider targetRange, TextPatternRangeEndpoint targetEndpoint)
        {

        }
コード例 #10
0
ファイル: TextSource.cs プロジェクト: mono/uia2atk
		public void MoveEndpointByRange (TextPatternRangeEndpoint endpoint, ITextPatternRange targetRange, TextPatternRangeEndpoint targetEndpoint)
		{
			TextRangePattern target = targetRange as TextRangePattern;
			if (target == null || target.accessible != accessible)
				throw new ArgumentException ();

			int offset =
				(targetEndpoint == TextPatternRangeEndpoint.Start
					? target.startOffset
					: target.endOffset);

			if (endpoint == TextPatternRangeEndpoint.Start) {
				startOffset = offset;
				if (endOffset < startOffset)
					endOffset = startOffset;
			} else {
				endOffset = offset;
				if (startOffset > endOffset)
					startOffset = endOffset;
			}
		}
コード例 #11
0
 public int CompareEndpoints(TextPatternRangeEndpoint endpoint, TextPatternRange targetRange, TextPatternRangeEndpoint targetEndpoint)
 {
     try
     {
         return(this._range.CompareEndpoints(
                    (TextPatternRangeEndpoint)endpoint,
                    targetRange.NativeRange,
                    (TextPatternRangeEndpoint)targetEndpoint));
     }
     catch (System.Runtime.InteropServices.COMException e)
     {
         Exception newEx; if (Utility.ConvertException(e, out newEx))
         {
             throw newEx;
         }
         else
         {
             throw;
         }
     }
 }
コード例 #12
0
 public void MoveEndpointByRange(TextPatternRangeEndpoint srcEndPoint, TextRange tr, TextPatternRangeEndpoint targetEndPoint)
 {
     this.UIATextRange.MoveEndpointByRange(srcEndPoint, tr.UIATextRange, targetEndPoint);
 }
コード例 #13
0
 public int MoveEndpointByUnit(TextPatternRangeEndpoint endpoint, TextUnit unit, int count)
 {
     return(this.UIATextRange.MoveEndpointByUnit(endpoint, unit, count));
 }
コード例 #14
0
ファイル: UIA3TextRange.cs プロジェクト: windygu/FlaUI
        public int CompareEndpoints(TextPatternRangeEndpoint srcEndPoint, ITextRange targetRange, TextPatternRangeEndpoint targetEndPoint)
        {
            var nativeRange = ToNativeRange(targetRange);

            return(ComCallWrapper.Call(() => NativeRange.CompareEndpoints((UIA.TextPatternRangeEndpoint)srcEndPoint, nativeRange, (UIA.TextPatternRangeEndpoint)targetEndPoint)));
        }
コード例 #15
0
 void SetEndpoint(TextPatternRangeEndpoint endpoint, int targetOffset)
 {
     if (endpoint == TextPatternRangeEndpoint.Start) {
         // set start of this range to targetOffset
         segment = new AnchorSegment(doc, targetOffset, Math.Max(0, segment.EndOffset - targetOffset));
     } else {
         // set end of this range to targetOffset
         int newStart = Math.Min(segment.Offset, targetOffset);
         segment = new AnchorSegment(doc, newStart, targetOffset - newStart);
     }
 }
コード例 #16
0
ファイル: UIA2TextRange.cs プロジェクト: yougayuki/FlaUI
        public void MoveEndpointByRange(TextPatternRangeEndpoint srcEndPoint, ITextRange targetRange, TextPatternRangeEndpoint targetEndPoint)
        {
            var nativeRange = ToNativeRange(targetRange);

            NativeRange.MoveEndpointByRange((UIA.Text.TextPatternRangeEndpoint)srcEndPoint, nativeRange, (UIA.Text.TextPatternRangeEndpoint)targetEndPoint);
        }
コード例 #17
0
        public int CompareEndpoints(TextPatternRangeEndpoint endpoint, ITextRangeProvider targetRange, TextPatternRangeEndpoint targetEndpoint)
        {
            FooTextBoxRangeProvider other = targetRange as FooTextBoxRangeProvider;

            if (other == null)
            {
                throw new ArgumentException("");
            }

            if (endpoint == TextPatternRangeEndpoint.Start)
            {
                if (targetEndpoint == TextPatternRangeEndpoint.Start)
                {
                    return(this.Compare(this.start, other.start));
                }
                if (targetEndpoint == TextPatternRangeEndpoint.End)
                {
                    return(this.Compare(this.start, other.end));
                }
            }
            if (endpoint == TextPatternRangeEndpoint.End)
            {
                if (targetEndpoint == TextPatternRangeEndpoint.Start)
                {
                    return(this.Compare(this.start, other.end));
                }
                if (targetEndpoint == TextPatternRangeEndpoint.End)
                {
                    return(this.Compare(this.end, other.end));
                }
            }
            throw new ArgumentException("endpointに未知の値が指定されました");
        }
コード例 #18
0
        //---------------------------------------------------------------------------
        // Calls MOveEndPointByUnit2(range,TextUnit,count) and validates expected / actual return value
        //---------------------------------------------------------------------------
        internal void TS_MoveEndpointByUnitAndValidate2(TextPatternRange callingRange, TextPatternRangeEndpoint endPoint, Count requestedCountEnum, Count expectedCountEnum, int[] countOfTextUnits, int richEditOffset, CheckType checkType)
        {
            int requestedCount = 0;
            int expectedCount  = 0;
            int actualCount    = 0;
            int errorCount = 0;
            TextPatternRange rangeToMove = null;

            for( TextUnit unit = TextUnit.Character; unit <= TextUnit.Document; unit ++ )
            {
                requestedCount =  CountConvert(requestedCountEnum, countOfTextUnits[(int) unit]);
                expectedCount  =  CountConvert(expectedCountEnum,  countOfTextUnits[(int) unit]);

                // Clone range
                Range_Clone(callingRange, ref rangeToMove, null, checkType);

                Range_MoveEndpointByUnit(rangeToMove, endPoint, unit, requestedCount, ref actualCount, null, checkType);

                if (actualCount == expectedCount)
                    Comment("MoveEndpointByUnit(" + endPoint + "," + unit + "," + requestedCount + ") moved the range by " + actualCount + ", as expected");
                else if ((richEditOffset != 0)
                      && ((actualCount + richEditOffset) == expectedCount))
                {
                    Comment("MoveEndpointByUnit(" + endPoint + "," + unit + "," + requestedCount + ") moved the range by " + actualCount + ", as expected taking into account extra characters added by RichEdit");
                }
                else
                {
                    Comment(KNOWNISSUE + " MoveEndpointByUnit(" + endPoint + "," + unit + "," + requestedCount + ") moved the range by " + actualCount + ", expected " + expectedCount);
                    errorCount++;
                }
            }
            if (errorCount > 0)
                ThrowMe(checkType, errorCount + " errors while calling MoveEndpointByUnit() method");

            m_TestStep++;
        }
コード例 #19
0
        //---------------------------------------------------------------------------
        // Expands range by a given # of units, and optionally then 
        // validates if # of units moved actual == expected
        //---------------------------------------------------------------------------
        internal void ExpandRange(TextPatternRange range, TextPatternRangeEndpoint endPoint, TextUnit unit, int expectedCount, out int actualCount, bool mustMatchExpected, CheckType checkType)
        {
            actualCount = 0;

            Range_MoveEndpointByUnit(range, endPoint, unit, expectedCount, ref actualCount, null, checkType);

            if (mustMatchExpected == true)
            {
                if (actualCount != expectedCount)
                {
                    ThrowMe(
                            checkType, "Unable to modify range " + endPoint + " endPoint by expected " +
                            expectedCount + " " + unit + " units. Actual = " + actualCount);
                }
            }
        }
コード例 #20
0
        //---------------------------------------------------------------------------
        // Move a range's endpoint(s) relative to position of endpoint in another range
        //---------------------------------------------------------------------------
        internal void TS_MoveEndpointByRange(TextPatternRange callingRange, TextPatternRangeEndpoint endPoint, TextPatternRange targetRange, TextPatternRangeEndpoint targetEndPoint, MoveEPResults expectedResult, Type expectedException, CheckType checkType)
        {
            string msg = "MoveEndpointByRange(" + endPoint + ",targetRange," + targetEndPoint + ") returned ";
            int moveCount = 0;
            int actualResult = 0;
            TextPatternRange cloneOfRange = null;

            Comment("Validating expected result is " + Parse(expectedResult, expectedException));

            if (callingRange != null)
                Range_Clone(callingRange, ref cloneOfRange, null, checkType);

            // Move endPoint
            Range_MoveEndpointByRange(cloneOfRange, endPoint, targetRange, targetEndPoint, expectedException, checkType);

            if (expectedException != null)
                return; // we're done

            // verify location of end point that we moved...
            Range_CompareEndpoints(cloneOfRange, endPoint, targetRange, targetEndPoint, ref moveCount, null, checkType);

            // Evaluate the state of the callingRange
            if (expectedException != null)
                actualResult += (int)MoveEPResults.Exception;
            else
            {
                if (IsEmptyRange(cloneOfRange, checkType) == true)
                    actualResult += (int)MoveEPResults.EmptyRange;
                else
                    actualResult += (int)MoveEPResults.NonemptyRange;
            }

            // Were we a success? expected result and correct endpoint location
            if (((actualResult & ((int)expectedResult)) > 0) && (moveCount == 0))
                Comment(msg + Parse(expectedResult, expectedException) + " as expected");
            else
                ThrowMe(
                        checkType, msg + Parse(expectedResult, null) + ", expected " + Parse(expectedResult, expectedException));

            m_TestStep++;
        }
コード例 #21
0
        //---------------------------------------------------------------------------
        // Moves the end point of a range by a specified # of units/count
        //---------------------------------------------------------------------------
        internal void TS_ExpandRange(ref TextPatternRange callingRange, TextPatternRangeEndpoint endPoint, TextUnit unit, int expectedCount, bool mustMatch, CheckType checkType)
        {
            int actualCount;

            ExpandRange(callingRange, endPoint, unit, expectedCount, out actualCount, mustMatch, checkType);

            Comment("Successfully expanded range by " + actualCount + " " + Parse(unit) + " units");
            m_TestStep++;
        }
コード例 #22
0
ファイル: UIA2TextRange.cs プロジェクト: yougayuki/FlaUI
 public int MoveEndpointByUnit(TextPatternRangeEndpoint endpoint, TextUnit unit, int count)
 {
     return(NativeRange.MoveEndpointByUnit((UIA.Text.TextPatternRangeEndpoint)endpoint, (UIA.Text.TextUnit)unit, count));
 }
コード例 #23
0
        /// <summary>
        /// Compares the endpoint of this range with the endpoint of another range.
        /// </summary>
        /// <param name="endpoint">The endpoint of this range to compare.</param>
        /// <param name="targetRange">The range with the other endpoint to compare.
        /// The range must have come from the same text provider or an InvalidArgumentException will be thrown.</param>
        /// <param name="targetEndpoint">The endpoint on the other range to compare.</param>
        /// <returns>Returns &lt;0 if this endpoint occurs earlier in the text than the target endpoint.
        /// Returns 0 if this endpoint is at the same location as the target endpoint.
        /// Returns &gt;0 if this endpoint occurs later in the text than the target endpoint.</returns>
        public int CompareEndpoints(TextPatternRangeEndpoint endpoint, TextPatternRange targetRange, TextPatternRangeEndpoint targetEndpoint)
        {
            ValidateEndpointArgument(endpoint, "endpoint");
            ValidateRangeArgument(targetRange, "targetRange");
            ValidateEndpointArgument(targetEndpoint, "targetEndpoint");

            return(UiaCoreApi.TextRange_CompareEndpoints(_hTextRange, endpoint, targetRange._hTextRange, targetEndpoint));
        }
コード例 #24
0
 public void MoveEndpointByRange(TextPatternRangeEndpoint endpoint, ITextRangeProvider targetRange, TextPatternRangeEndpoint targetEndpoint)
 {
 }
コード例 #25
0
ファイル: UIA3TextRange.cs プロジェクト: windygu/FlaUI
        public void MoveEndpointByRange(TextPatternRangeEndpoint srcEndPoint, ITextRange targetRange, TextPatternRangeEndpoint targetEndPoint)
        {
            var nativeRange = ToNativeRange(targetRange);

            ComCallWrapper.Call(() => NativeRange.MoveEndpointByRange((UIA.TextPatternRangeEndpoint)srcEndPoint, nativeRange, (UIA.TextPatternRangeEndpoint)targetEndPoint));
        }
コード例 #26
0
        public int CompareEndpoints(TextPatternRangeEndpoint endpoint, ITextRangeProvider targetRange, TextPatternRangeEndpoint targetEndpoint)
        {
            TextRangeProvider other = (TextRangeProvider)targetRange;
            int result = GetEndpoint(endpoint).CompareTo(other.GetEndpoint(targetEndpoint));

            Log("{0}.CompareEndpoints({1}, {2}, {3}) = {4}", ID, endpoint, other.ID, targetEndpoint, result);
            return(result);
        }
コード例 #27
0
 public int MoveEndpointByUnit(TextPatternRangeEndpoint endpoint, TextUnit unit, int count)
 {
     Log("{0}.MoveEndpointByUnit({1}, {2}, {3})", ID, endpoint, unit, count);
     int offset = GetEndpoint(endpoint);
     switch (unit) {
         case TextUnit.Character:
             offset = MoveOffset(offset, CaretPositioningMode.Normal, count);
             break;
         case TextUnit.Format:
         case TextUnit.Word:
             offset = MoveOffset(offset, CaretPositioningMode.WordStart, count);
             break;
         case TextUnit.Line:
         case TextUnit.Paragraph:
             int line = doc.GetLineByOffset(offset).LineNumber;
             int newLine = Math.Max(1, Math.Min(doc.LineCount, line + count));
             offset = doc.GetLineByNumber(newLine).Offset;
             break;
         case TextUnit.Document:
             offset = count < 0 ? 0 : doc.TextLength;
             break;
     }
     SetEndpoint(endpoint, offset);
     return count;
 }
コード例 #28
0
        public int CompareEndpoints(TextPatternRangeEndpoint srcEndPoint, TextRange tr, TextPatternRangeEndpoint targetEndPoint)
        {
            if (tr == null)
            {
                throw new ArgumentNullException(nameof(tr));
            }

            return(this.UIATextRange.CompareEndpoints(srcEndPoint, tr.UIATextRange, targetEndPoint));
        }
コード例 #29
0
        int ITextRangeProvider.MoveEndpointByUnit(TextPatternRangeEndpoint endpoint, TextUnit unit, int count)
        {
            Misc.SetFocus(_provider._hwnd);

            // positive count means move forward.  negative count means move backwards.
            int  moved     = 0;
            bool moveStart = endpoint == TextPatternRangeEndpoint.Start;
            int  start     = Start;
            int  end       = End;

            if (count > 0)
            {
                if (moveStart)
                {
                    Start = MoveEndpointForward(Start, unit, count, out moved);

                    // if the start did not change then no move was done.
                    if (start == Start)
                    {
                        moved = 0;
                    }
                }
                else
                {
                    End = MoveEndpointForward(End, unit, count, out moved);

                    // if the end did not change then no move was done.
                    if (end == End)
                    {
                        moved = 0;
                    }
                }
            }
            else if (count < 0)
            {
                if (moveStart)
                {
                    Start = MoveEndpointBackward(Start, unit, count, out moved);

                    // if the start did not change then no move was done.
                    if (start == Start)
                    {
                        moved = 0;
                    }
                }
                else
                {
                    End = MoveEndpointBackward(End, unit, count, out moved);

                    // if the end did not change then no move was done.
                    if (end == End)
                    {
                        moved = 0;
                    }
                }
            }
            else
            {
                // moving zero of any unit has no effect.
                moved = 0;
            }

            return(moved);
        }
コード例 #30
0
 public int CompareEndpoints(TextPatternRangeEndpoint srcEndPoint, TextRange tr, TextPatternRangeEndpoint targetEndPoint)
 {
     return(this.UIATextRange.CompareEndpoints(srcEndPoint, tr.UIATextRange, targetEndPoint));
 }
コード例 #31
0
        void ITextRangeProvider.MoveEndpointByRange(TextPatternRangeEndpoint endpoint, ITextRangeProvider targetRange, TextPatternRangeEndpoint targetEndpoint)
        {
            Misc.SetFocus(_provider._hwnd);

            // TextPatternRange already verifies the other range comes from the same element before forwarding so we only need to worry
            // about the endpoints.
            WindowsEditBoxRange editRange = (WindowsEditBoxRange)targetRange;
            int e = (targetEndpoint == TextPatternRangeEndpoint.Start) ? editRange.Start : editRange.End;

            if (endpoint == TextPatternRangeEndpoint.Start)
            {
                Start = e;
            }
            else
            {
                End = e;
            }
        }
コード例 #32
0
        void ITextRangeProvider.MoveEndpointByRange(TextPatternRangeEndpoint endpoint, ITextRangeProvider targetRange, TextPatternRangeEndpoint targetEndpoint)
        {
            Misc.SetFocus(_provider._hwnd);

            // TextPatternRange already verifies the other range comes from the same element before forwarding so we only need to worry
            // about the endpoints.
            WindowsEditBoxRange editRange = (WindowsEditBoxRange)targetRange;
            int e = (targetEndpoint == TextPatternRangeEndpoint.Start) ? editRange.Start : editRange.End;

            if (endpoint == TextPatternRangeEndpoint.Start)
            {
                Start = e;
            }
            else
            {
                End = e;
            }
        }
コード例 #33
0
 public int CompareEndpoints(TextPatternRangeEndpoint endpoint, ITextRangeProvider targetRange, TextPatternRangeEndpoint targetEndpoint)
 {
     return(0);
 }
コード例 #34
0
        int ITextRangeProvider.CompareEndpoints(TextPatternRangeEndpoint endpoint, ITextRangeProvider targetRange, TextPatternRangeEndpoint targetEndpoint)
        {
            // TextPatternRange already verifies the other range comes from the same element before forwarding so we only need to worry about
            // comparing the endpoints.
            WindowsEditBoxRange editRange = (WindowsEditBoxRange)targetRange;
            int e1 = (endpoint == TextPatternRangeEndpoint.Start) ? Start : End;
            int e2 = (targetEndpoint == TextPatternRangeEndpoint.Start) ? editRange.Start : editRange.End;

            return(e1 - e2);
        }
コード例 #35
0
 public int MoveEndpointByUnit(TextPatternRangeEndpoint endpoint, TextUnit unit, int count)
 {
     return(0);
 }
コード例 #36
0
		public void MoveEndpointByRange (TextPatternRangeEndpoint endpoint, string targetRangePath, TextPatternRangeEndpoint targetEndpoint)
		{
			ITextRangeProvider target = parent.GetTextRangeFromPath (targetRangePath).Provider;
			provider.MoveEndpointByRange (endpoint, target, targetEndpoint);
		}
コード例 #37
0
        public void MoveEndpointByRange(TextPatternRangeEndpoint endpoint, ITextRangeProvider targetRange, TextPatternRangeEndpoint targetEndpoint)
        {
            TextRangeProvider other = (TextRangeProvider)targetRange;

            Log("{0}.MoveEndpointByRange({1}, {2}, {3})", ID, endpoint, other.ID, targetEndpoint);
            SetEndpoint(endpoint, other.GetEndpoint(targetEndpoint));
        }
コード例 #38
0
		public int MoveEndpointByUnit (TextPatternRangeEndpoint endpoint, TextUnit unit, int count)
		{
			return provider.MoveEndpointByUnit (endpoint, unit, count);
		}
コード例 #39
0
        public void MoveEndpointByRange(TextPatternRangeEndpoint srcEndPoint, TextRange tr, TextPatternRangeEndpoint targetEndPoint)
        {
            if (tr == null)
            {
                throw new ArgumentNullException(nameof(tr));
            }

            this.UIATextRange.MoveEndpointByRange(srcEndPoint, tr.UIATextRange, targetEndPoint);
        }
コード例 #40
0
		public int CompareEndpoints (TextPatternRangeEndpoint endpoint, string targetRangePath, TextPatternRangeEndpoint targetEndpoint)
		{
			ITextRangeProvider target = parent.GetTextRangeFromPath (targetRangePath).Provider;
			return provider.CompareEndpoints (endpoint, target, targetEndpoint);
		}
コード例 #41
0
ファイル: TextSource.cs プロジェクト: mono/uia2atk
		public int CompareEndpoints (TextPatternRangeEndpoint endpoint, ITextPatternRange targetRange, TextPatternRangeEndpoint targetEndpoint)
		{
			TextRangePattern targetRangePattern = targetRange as TextRangePattern;
			if (targetRangePattern == null)
				throw new ArgumentNullException ();

			if (targetRangePattern.accessible != accessible)
				throw new ArgumentException ();

			int point = (endpoint == TextPatternRangeEndpoint.End
				? endOffset : startOffset);
			int targetPoint = (targetEndpoint ==
				TextPatternRangeEndpoint.End)
				? targetRangePattern.endOffset
				: targetRangePattern.startOffset;

			if (point < targetPoint)
				return -1;
			if (point > targetPoint)
				return 1;
			return 0;
		}
コード例 #42
0
 public int CompareEndpoints(TextPatternRangeEndpoint endpoint, ITextRangeProvider targetRange, TextPatternRangeEndpoint targetEndpoint)
 {
     throw new NotImplementedException();
 }
コード例 #43
0
ファイル: TextSource.cs プロジェクト: mono/uia2atk
		public int MoveEndpointByUnit (TextPatternRangeEndpoint endpoint, TextUnit unit, int count)
		{
			if (count == 0)
				return 0;
			switch (unit) {
			case TextUnit.Format:
				Log.Debug ("AtspiUiaSource: Moving by unit "
					+ unit + " not supported.");
				return 0;
			case TextUnit.Word:
				if (endpoint == TextPatternRangeEndpoint.Start)
					return WordMoveStartPoint (count);
				else
					return WordMoveEndPoint (count);
			case TextUnit.Page:
			case TextUnit.Document:
				if (endpoint == TextPatternRangeEndpoint.Start) {
					if (count < 0) {
						if (startOffset <= 0)
							return 0;
						StartOffset = 0;
						return -1;
					} else {
						int characterCount = text.CharacterCount;
						if (startOffset >= characterCount)
							return 0;
						StartOffset = characterCount;
						return 1;
					}
				} else {
					if (count < 0) {
						if (endOffset <= 0)
							return 0;
						EndOffset = 0;
						return -1;
					} else {
						int characterCount = text.CharacterCount;
						if (endOffset >= characterCount)
							return 0;
						EndOffset = characterCount;
						return 1;
					}
				}
			case TextUnit.Paragraph:
				if (endpoint == TextPatternRangeEndpoint.Start)
					return ParagraphMoveStartPoint (count);
				else
					return ParagraphMoveEndPoint (count);
			default:
				int offset = (endpoint == TextPatternRangeEndpoint.Start
					? startOffset
					: endOffset - 1);
				int newStartOffset = offset;
				int newEndOffset = offset;
				int ret = 0;
				BoundaryType boundary = GetAtkBoundaryType (unit, count > 0);
				while (count != 0) {
					int oldStartOffset = newStartOffset;
					int oldEndOffset = newEndOffset;
					if (count < 0) {
						text.GetTextBeforeOffset (oldStartOffset, boundary, out newStartOffset, out newEndOffset);
						if (newStartOffset == oldStartOffset &&
							newEndOffset == oldEndOffset)
							break;
						count++;
						ret--;
					} else {
						text.GetTextAfterOffset (oldStartOffset, boundary, out newStartOffset, out newEndOffset);
						if (newStartOffset == oldStartOffset &&
							newEndOffset == oldEndOffset)
							break;
						count--;
						ret++;
					}
				}
				if (endpoint == TextPatternRangeEndpoint.Start)
					StartOffset = newStartOffset;
				else
					EndOffset = newEndOffset;
				return ret;
			}
		}
コード例 #44
0
 public int MoveEndpointByUnit(TextPatternRangeEndpoint endpoint, TextUnit unit, int count)
 {
     throw new NotImplementedException();
 }
コード例 #45
0
 public int CompareEndpoints(TextPatternRangeEndpoint endpoint, ITextRangeProvider targetRange, TextPatternRangeEndpoint targetEndpoint)
 {
     return 0;
 }
コード例 #46
0
 public void MoveEndpointByRange(TextPatternRangeEndpoint endpoint, ITextRangeProvider targetRange, TextPatternRangeEndpoint targetEndpoint)
 {
     throw new NotImplementedException();
 }
コード例 #47
0
 public int MoveEndpointByUnit(TextPatternRangeEndpoint endpoint, TextUnit unit, int count)
 {
     return 0;
 }
コード例 #48
0
ファイル: Text.cs プロジェクト: geeksree/cSharpGeeks
        // -------------------------------------------------------------------
        // Call Move method to iterate through document by TextUnit
        // -------------------------------------------------------------------
        internal void MoveCount_Move(TextPatternRangeEndpoint endPoint, int countAmt, int[] textCounts, ref StringBuilder errors, CheckType checkType)
        {
            string call = "";
            StringBuilder results = new StringBuilder();

            if (endPoint == TextPatternRangeEndpoint.Start)
                call = "[email protected](TextUnit.*,";
            else
                call = "[email protected](TextUnit.*,";

            if (countAmt > 0)
                call += "MaxInt)";
            else
                call += "MinInt)";

            if (textCounts[0] == 0)
                results.Append("***" + call.PadLeft(52, ' '));  // Expect 0
            else
                results.Append(call.PadLeft(55, ' '));          // expect non-zero

            for (TextUnit tu = TextUnit.Character; tu <= TextUnit.Document; tu++)
            {
                TextPatternRange range = _pattern.DocumentRange.Clone();

                if (endPoint == TextPatternRangeEndpoint.Start)
                {
                    string text = range.GetText(-1);
                    int textLength = text.Length;

                    // Based on length, what is our expected move value?
                    // 0 for empty string, -1 for non-empty
                    int moveExpected = (textLength > 0 ? -1 : 0);

                    int moveActual = range.MoveEndpointByUnit(TextPatternRangeEndpoint.End,
                                            TextUnit.Document, -1);
                    if (moveActual != moveExpected)
                    {
                        ThrowMe(checkType, "MoveEndpointByUnit(End,Document,-1) failed to return " +
                                moveExpected);
                    }
                    if (range.CompareEndpoints(endPoint, _pattern.DocumentRange, endPoint) != 0)
                    {
                        ThrowMe(checkType, "Unable to create empty range at Start of Document");
                    }
                }
                else
                {
                    string text = range.GetText(-1);
                    TextTestsHelper.TrimTrailingCRLF(m_le, ref text);
                    int textLength = text.Length;

                    // Based on length, what is our expected move value?
                    // 0 for empty string, -1 for non-empty
                    int moveExpected = (textLength > 0 ? 1 : 0);

                    int moveActual = range.MoveEndpointByUnit(TextPatternRangeEndpoint.Start,
                                            TextUnit.Document, 1);
                    if (moveActual != moveExpected)
                    {
                        ThrowMe(checkType, "MoveEndpointByUnit(End,Document,1) failed to return " +
                                moveExpected);
                    }
                    if (range.CompareEndpoints(endPoint, _pattern.DocumentRange, endPoint) != 0)
                    {
                        ThrowMe(checkType, "Unable to create empty range at End of Document");
                    }
                }

                int count = range.Move(tu, countAmt);
                int correctCount = textCounts[(int)tu];

                if (countAmt < 0)  // are we moving backwards???
                {
                    correctCount *= -1; // if so, adjust correct count accordingly
                }

                if (count != correctCount)
                {
                    errors.Append(call + " for " + tu + " actual count = " +
                            count + ", expected = " + textCounts[(int)tu] + "\n");
                }

                results.Append('|' + count.ToString(CultureInfo.InvariantCulture).PadLeft(tu.ToString().Length, ' '));
            }
            Comment(results.ToString());
        }
コード例 #49
0
        /// <summary>
        /// Moves an endpoint of this range to coincide with the endpoint of another range.
        /// </summary>
        /// <param name="endpoint">The endpoint to move.</param>
        /// <param name="targetRange">Another range from the same text provider.</param>
        /// <param name="targetEndpoint">An endpoint on the other range.</param>
        public void MoveEndpointByRange(TextPatternRangeEndpoint endpoint, TextPatternRange targetRange, TextPatternRangeEndpoint targetEndpoint)
        {
            ValidateEndpointArgument(endpoint, "endpoint");
            ValidateRangeArgument(targetRange, "targetRange");
            ValidateEndpointArgument(targetEndpoint, "targetEndpoint");

            UiaCoreApi.TextRange_MoveEndpointByRange(_hTextRange, endpoint, targetRange._hTextRange, targetEndpoint);
        }
コード例 #50
0
ファイル: Text.cs プロジェクト: geeksree/cSharpGeeks
        // -------------------------------------------------------------------
        // Call MoveEndpointByUnit method to iterate through document by TextUnit
        // -------------------------------------------------------------------
        internal void MoveCount_MoveEPBU(TextPatternRangeEndpoint endPoint, int countAmt, int[] textCounts, ref StringBuilder errors)
        {
            string call = "MoveEndpointByUnit";
            StringBuilder results = new StringBuilder();

            if (endPoint == TextPatternRangeEndpoint.Start)
                call += "(Start,TextUnit.*,";
            else
                call += "(End,TextUnit.*,";

            if (countAmt > 0)
                call += "MaxInt)";
            else
                call += "MinInt)";

            if (textCounts[0] == 0)
                results.Append("***" + call.PadLeft(52, ' '));  // Expect 0
            else
                results.Append(call.PadLeft(55, ' '));          // expect non-zero

            for (TextUnit tu = TextUnit.Character; tu <= TextUnit.Document; tu++)
            {
                TextPatternRange range = _pattern.DocumentRange.Clone();

                int count = range.MoveEndpointByUnit(endPoint, tu, countAmt);
                int correctCount = textCounts[(int)tu];

                if (countAmt < 0)  // are we moving backwards???
                {
                    correctCount *= -1; // if so, adjust correct count accordingly
                }

                if (count != correctCount)
                {
                    errors.Append(call + " for " + tu + " actual count = " +
                            count + ", expected = " + textCounts[(int)tu] + "\n");
                }

                results.Append('|' + count.ToString(CultureInfo.InvariantCulture).PadLeft(tu.ToString().Length, ' '));
            }
            Comment(results.ToString());
        }
コード例 #51
0
ファイル: UIA3TextRange.cs プロジェクト: windygu/FlaUI
 public int MoveEndpointByUnit(TextPatternRangeEndpoint endpoint, TextUnit unit, int count)
 {
     return(ComCallWrapper.Call(() => NativeRange.MoveEndpointByUnit((UIA.TextPatternRangeEndpoint)endpoint, (UIA.TextUnit)unit, count)));
 }
コード例 #52
0
ファイル: TextRangeAdaptor.cs プロジェクト: JianwenSun/cc
        /// <summary>
        /// Compares the endpoint of this range with the endpoint of another range.
        /// </summary>
        /// <param name="endpoint">The endpoint of this range to compare.</param>
        /// <param name="targetRange">The range with the other endpoint to compare.
        /// The range must have come from the same text provider or an InvalidArgumentException will be thrown.</param>
        /// <param name="targetEndpoint">The endpoint on the other range to compare.</param>
        /// <returns>Returns &lt;0 if this endpoint occurs earlier in the text than the target endpoint. 
        /// Returns 0 if this endpoint is at the same location as the target endpoint. 
        /// Returns &gt;0 if this endpoint occurs later in the text than the target endpoint.</returns>
        int ITextRangeProvider.CompareEndpoints(TextPatternRangeEndpoint endpoint, ITextRangeProvider targetRange, TextPatternRangeEndpoint targetEndpoint)
        {
            if (targetRange == null)
            {
                throw new ArgumentNullException("targetRange");
            }

            TextRangeAdaptor rangeAdaptor = ValidateAndThrow(targetRange);

            Normalize();
            rangeAdaptor.Normalize();

            ITextPointer position = (endpoint == TextPatternRangeEndpoint.Start) ? _start : _end;
            ITextPointer targetPosition = (targetEndpoint == TextPatternRangeEndpoint.Start) ? rangeAdaptor._start : rangeAdaptor._end;
            return position.CompareTo(targetPosition);
        }
コード例 #53
0
 public void MoveEndpointByRange(TextPatternRangeEndpoint endpoint, ITextRangeProvider targetRange, TextPatternRangeEndpoint targetEndpoint)
 {
     TextRangeProvider other = (TextRangeProvider)targetRange;
     Log("{0}.MoveEndpointByRange({1}, {2})", ID, endpoint, other.ID, targetEndpoint);
     SetEndpoint(endpoint, other.GetEndpoint(targetEndpoint));
 }
コード例 #54
0
ファイル: TextRangeAdaptor.cs プロジェクト: JianwenSun/cc
        /// <summary>
        /// Moves one endpoint of the range the specified number of units in the text.
        /// If the endpoint being moved crosses the other endpoint then the other endpoint
        /// is moved along too resulting in a degenerate range and ensuring the correct ordering
        /// of the endpoints. (i.e. always Start&lt;=End)
        /// </summary>
        /// <param name="endpoint">The endpoint to move.</param>
        /// <param name="unit">The textual unit for moving.</param>
        /// <param name="count">The number of units to move.  A positive count moves the endpoint forward.  
        /// A negative count moves backward. A count of 0 has no effect.</param>
        /// <returns>The number of units actually moved, which can be less than the number requested if 
        /// moving the endpoint runs into the beginning or end of the document.</returns>
        int ITextRangeProvider.MoveEndpointByUnit(TextPatternRangeEndpoint endpoint, TextUnit unit, int count)
        {
            Normalize();

            int movedCount = 0;
            if (count != 0)
            {
                // Move endpoint by number of units.
                bool start = (endpoint == TextPatternRangeEndpoint.Start);
                ITextPointer positionRef = start ? _start : _end;
                ITextPointer position = positionRef.CreatePointer();
                if (MoveToUnitBoundary(position, start, count < 0 ? LogicalDirection.Backward : LogicalDirection.Forward, unit))
                {
                    movedCount = (count > 0) ? 1 : -1;
                }
                if (count != movedCount)
                {
                    movedCount += MovePositionByUnits(position, unit, count - movedCount);
                }

                // If endpoint has been moved at least by one unit, snap it to TextUnit boundary,
                // because movement done by MovePositionByUnits does not guarantee position snapping.
                if ((count > 0 && position.CompareTo(positionRef) > 0) || 
                    (count < 0 && position.CompareTo(positionRef) < 0) ||
                    (position.CompareTo(positionRef) == 0 && position.LogicalDirection != positionRef.LogicalDirection))
                {
                    if (start)
                    {
                        _start = position;
                    }
                    else
                    {
                        _end = position;
                    }
                    if (unit != TextUnit.Page)
                    {
                        ExpandToEnclosingUnit(unit, start, !start);
                    }
                    // If endpoint has been moved, but 'movedCount' is 0, it means that we snapped to neariest
                    // unit boundary. Treat this situation as actual move.
                    if (movedCount == 0)
                    {
                        movedCount = (count > 0) ? 1 : -1;
                    }
                }
                // Ensure the correct ordering of the endpoint.
                if (_start.CompareTo(_end) > 0)
                {
                    if (start)
                    {
                        _end = _start.CreatePointer();
                    }
                    else
                    {
                        _start = _end.CreatePointer();
                    }
                }
            }
            return movedCount;
        }
コード例 #55
0
 int GetEndpoint(TextPatternRangeEndpoint endpoint)
 {
     switch (endpoint) {
         case TextPatternRangeEndpoint.Start:
             return segment.Offset;
         case TextPatternRangeEndpoint.End:
             return segment.EndOffset;
         default:
             throw new ArgumentOutOfRangeException("endpoint");
     }
 }
コード例 #56
0
ファイル: TextRangeAdaptor.cs プロジェクト: JianwenSun/cc
        /// <summary>
        /// Moves an endpoint of this range to coincide with the endpoint of another range.
        /// </summary>
        /// <param name="endpoint">The endpoint to move.</param>
        /// <param name="targetRange">Another range from the same text provider.</param>
        /// <param name="targetEndpoint">An endpoint on the other range.</param>
        void ITextRangeProvider.MoveEndpointByRange(TextPatternRangeEndpoint endpoint, ITextRangeProvider targetRange, TextPatternRangeEndpoint targetEndpoint)
        {
            if (targetRange == null)
            {
                throw new ArgumentNullException("targetRange");
            }
            TextRangeAdaptor rangeAdaptor = ValidateAndThrow(targetRange);
            ITextPointer targetPointer = (targetEndpoint == TextPatternRangeEndpoint.Start) ? rangeAdaptor._start : rangeAdaptor._end;
            if (endpoint == TextPatternRangeEndpoint.Start)
            {
                _start = targetPointer.CreatePointer();
                // Ensure the correct ordering of the endpoint.
                if (_start.CompareTo(_end) > 0)
                {
                    _end = _start.CreatePointer();
                }
            }
            else
            {
                _end = targetPointer.CreatePointer();
                // Ensure the correct ordering of the endpoint.
                if (_start.CompareTo(_end) > 0)
                {
                    _start = _end.CreatePointer();
                }
            }

        }
コード例 #57
0
 public int CompareEndpoints(TextPatternRangeEndpoint endpoint, ITextRangeProvider targetRange, TextPatternRangeEndpoint targetEndpoint)
 {
     TextRangeProvider other = (TextRangeProvider) targetRange;
     int result = GetEndpoint(endpoint).CompareTo(other.GetEndpoint(targetEndpoint));
     Log("{0}.CompareEndpoints({1}, {2}, {3}) = {4}", ID, endpoint, other.ID, targetEndpoint, result);
     return result;
 }
コード例 #58
0
ファイル: TextRange.cs プロジェクト: van800/UIAComWrapper
 public int MoveEndpointByUnit(TextPatternRangeEndpoint endpoint, TextUnit unit, int count)
 {
     try
     {
         return this._range.MoveEndpointByUnit(
             (UIAutomationClient.TextPatternRangeEndpoint)endpoint,
             (UIAutomationClient.TextUnit)unit,
             count);
     }
     catch (System.Runtime.InteropServices.COMException e)
     {
         Exception newEx; if (Utility.ConvertException(e, out newEx)) { throw newEx; } else { throw; }
     }
 }
コード例 #59
0
        public int MoveEndpointByUnit(TextPatternRangeEndpoint endpoint,
                                      TextUnit unit, int count)
        {
            // NOTE: The order of these cases is crucial
            switch (unit)
            {
            case TextUnit.Character:
                if (endpoint == TextPatternRangeEndpoint.Start)
                {
                    return(normalizer.CharacterMoveStartPoint(count));
                }
                else
                {
                    return(normalizer.CharacterMoveEndPoint(count));
                }

            case TextUnit.Word:
                if (endpoint == TextPatternRangeEndpoint.Start)
                {
                    return(normalizer.WordMoveStartPoint(count));
                }
                else
                {
                    return(normalizer.WordMoveEndPoint(count));
                }

            case TextUnit.Line:
                if (endpoint == TextPatternRangeEndpoint.Start)
                {
                    return(normalizer.LineMoveStartPoint(count));
                }
                else
                {
                    return(normalizer.LineMoveEndPoint(count));
                }

            case TextUnit.Paragraph:
                if (endpoint == TextPatternRangeEndpoint.Start)
                {
                    return(normalizer.ParagraphMoveStartPoint(count));
                }
                else
                {
                    return(normalizer.ParagraphMoveEndPoint(count));
                }
            // LAMESPEC: this should fall back on TextUnit.Word
            // according to MSDN, but for TextBox, this resembles
            // TextUnit.Page.

            // TextBox doesn't support Page or Format
            case TextUnit.Format:
            case TextUnit.Page:
            case TextUnit.Document:
                if (endpoint == TextPatternRangeEndpoint.Start)
                {
                    return(normalizer.DocumentMoveStartPoint(count));
                }
                else
                {
                    return(normalizer.DocumentMoveEndPoint(count));
                }
            }

            return(0);
        }
コード例 #60
0
        int ITextRangeProvider.MoveEndpointByUnit(TextPatternRangeEndpoint endpoint, TextUnit unit, int count)
        {
            Misc.SetFocus(_provider._hwnd);

            // positive count means move forward.  negative count means move backwards.
            int moved = 0;
            bool moveStart = endpoint == TextPatternRangeEndpoint.Start;
            int start = Start;
            int end = End;
            if (count > 0)
            {
                if (moveStart)
                {
                    Start = MoveEndpointForward(Start, unit, count, out moved);

                    // if the start did not change then no move was done.
                    if (start == Start)
                    {
                        moved = 0;
                    }
                }
                else
                {
                    End = MoveEndpointForward(End, unit, count, out moved);

                    // if the end did not change then no move was done.
                    if (end == End)
                    {
                        moved = 0;
                    }
                }
            }
            else if (count < 0)
            {
                if (moveStart)
                {
                    Start = MoveEndpointBackward(Start, unit, count, out moved);

                    // if the start did not change then no move was done.
                    if (start == Start)
                    {
                        moved = 0;
                    }
                }
                else
                {
                    End = MoveEndpointBackward(End, unit, count, out moved);

                    // if the end did not change then no move was done.
                    if (end == End)
                    {
                        moved = 0;
                    }
                }
            }
            else
            {
                // moving zero of any unit has no effect.
                moved = 0;
            }

            return moved;
        }