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; }
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; }
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); }
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; } } }
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; } } }
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; } } }
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に未知の値が指定されました"); }
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)); }
public void MoveEndpointByRange(TextPatternRangeEndpoint endpoint, ITextRangeProvider targetRange, TextPatternRangeEndpoint targetEndpoint) { }
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; } }
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; } } }
public void MoveEndpointByRange(TextPatternRangeEndpoint srcEndPoint, TextRange tr, TextPatternRangeEndpoint targetEndPoint) { this.UIATextRange.MoveEndpointByRange(srcEndPoint, tr.UIATextRange, targetEndPoint); }
public int MoveEndpointByUnit(TextPatternRangeEndpoint endpoint, TextUnit unit, int count) { return(this.UIATextRange.MoveEndpointByUnit(endpoint, unit, count)); }
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))); }
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); } }
public void MoveEndpointByRange(TextPatternRangeEndpoint srcEndPoint, ITextRange targetRange, TextPatternRangeEndpoint targetEndPoint) { var nativeRange = ToNativeRange(targetRange); NativeRange.MoveEndpointByRange((UIA.Text.TextPatternRangeEndpoint)srcEndPoint, nativeRange, (UIA.Text.TextPatternRangeEndpoint)targetEndPoint); }
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に未知の値が指定されました"); }
//--------------------------------------------------------------------------- // 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++; }
//--------------------------------------------------------------------------- // 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); } } }
//--------------------------------------------------------------------------- // 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++; }
//--------------------------------------------------------------------------- // 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++; }
public int MoveEndpointByUnit(TextPatternRangeEndpoint endpoint, TextUnit unit, int count) { return(NativeRange.MoveEndpointByUnit((UIA.Text.TextPatternRangeEndpoint)endpoint, (UIA.Text.TextUnit)unit, count)); }
/// <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 <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 >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)); }
public void MoveEndpointByRange(TextPatternRangeEndpoint srcEndPoint, ITextRange targetRange, TextPatternRangeEndpoint targetEndPoint) { var nativeRange = ToNativeRange(targetRange); ComCallWrapper.Call(() => NativeRange.MoveEndpointByRange((UIA.TextPatternRangeEndpoint)srcEndPoint, nativeRange, (UIA.TextPatternRangeEndpoint)targetEndPoint)); }
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); }
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; }
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)); }
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); }
public int CompareEndpoints(TextPatternRangeEndpoint srcEndPoint, TextRange tr, TextPatternRangeEndpoint targetEndPoint) { return(this.UIATextRange.CompareEndpoints(srcEndPoint, tr.UIATextRange, targetEndPoint)); }
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; } }
public int CompareEndpoints(TextPatternRangeEndpoint endpoint, ITextRangeProvider targetRange, TextPatternRangeEndpoint targetEndpoint) { return(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); }
public int MoveEndpointByUnit(TextPatternRangeEndpoint endpoint, TextUnit unit, int count) { return(0); }
public void MoveEndpointByRange (TextPatternRangeEndpoint endpoint, string targetRangePath, TextPatternRangeEndpoint targetEndpoint) { ITextRangeProvider target = parent.GetTextRangeFromPath (targetRangePath).Provider; provider.MoveEndpointByRange (endpoint, target, targetEndpoint); }
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)); }
public int MoveEndpointByUnit (TextPatternRangeEndpoint endpoint, TextUnit unit, int count) { return provider.MoveEndpointByUnit (endpoint, unit, count); }
public void MoveEndpointByRange(TextPatternRangeEndpoint srcEndPoint, TextRange tr, TextPatternRangeEndpoint targetEndPoint) { if (tr == null) { throw new ArgumentNullException(nameof(tr)); } this.UIATextRange.MoveEndpointByRange(srcEndPoint, tr.UIATextRange, targetEndPoint); }
public int CompareEndpoints (TextPatternRangeEndpoint endpoint, string targetRangePath, TextPatternRangeEndpoint targetEndpoint) { ITextRangeProvider target = parent.GetTextRangeFromPath (targetRangePath).Provider; return provider.CompareEndpoints (endpoint, target, targetEndpoint); }
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; }
public int CompareEndpoints(TextPatternRangeEndpoint endpoint, ITextRangeProvider targetRange, TextPatternRangeEndpoint targetEndpoint) { throw new NotImplementedException(); }
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; } }
public int MoveEndpointByUnit(TextPatternRangeEndpoint endpoint, TextUnit unit, int count) { throw new NotImplementedException(); }
public int CompareEndpoints(TextPatternRangeEndpoint endpoint, ITextRangeProvider targetRange, TextPatternRangeEndpoint targetEndpoint) { return 0; }
public void MoveEndpointByRange(TextPatternRangeEndpoint endpoint, ITextRangeProvider targetRange, TextPatternRangeEndpoint targetEndpoint) { throw new NotImplementedException(); }
public int MoveEndpointByUnit(TextPatternRangeEndpoint endpoint, TextUnit unit, int count) { return 0; }
// ------------------------------------------------------------------- // 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()); }
/// <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); }
// ------------------------------------------------------------------- // 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()); }
public int MoveEndpointByUnit(TextPatternRangeEndpoint endpoint, TextUnit unit, int count) { return(ComCallWrapper.Call(() => NativeRange.MoveEndpointByUnit((UIA.TextPatternRangeEndpoint)endpoint, (UIA.TextUnit)unit, count))); }
/// <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 <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 >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); }
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)); }
/// <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<=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; }
int GetEndpoint(TextPatternRangeEndpoint endpoint) { switch (endpoint) { case TextPatternRangeEndpoint.Start: return segment.Offset; case TextPatternRangeEndpoint.End: return segment.EndOffset; default: throw new ArgumentOutOfRangeException("endpoint"); } }
/// <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(); } } }
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; }
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; } } }
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); }
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; }