bool ITextRangeProvider.Compare(ITextRangeProvider range)
{
// TextPatternRange already verifies the other range comes from the same element before forwarding so we only need to worry about
// whether the endpoints are identical.
WindowsEditBoxRange editRange = (WindowsEditBoxRange)range;
return editRange.Start == Start && editRange.End == End;
}
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 bool Compare(ITextRangeProvider range)
{
if (!(range is TextRangeProviderWrapper))
{
throw new ArgumentException(SR.Get(SRID.TextRangeProvider_InvalidRangeProvider, "range"));
}
return (bool)ElementUtil.Invoke(_peer, new DispatcherOperationCallback(Compare), range);
}
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 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 bool Compare(ITextRangeProvider range)
{
TextRangeProvider other = (TextRangeProvider)range;
bool result = doc == other.doc &&
segment.Offset == other.segment.Offset &&
segment.EndOffset == other.segment.EndOffset;
Log("{0}.Compare({1}) = {2}", ID, other.ID, result);
return(result);
}
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));
}
private object MoveEndpointByRange(object arg)
{
object[] args = (object[])arg;
TextPatternRangeEndpoint endpoint = (TextPatternRangeEndpoint)args[0];
ITextRangeProvider targetRange = (ITextRangeProvider)args[1];
TextPatternRangeEndpoint targetEndpoint = (TextPatternRangeEndpoint)args[2];
_iface.MoveEndpointByRange(endpoint, TextRangeProviderWrapper.UnwrapArgument(targetRange), targetEndpoint);
return(null);
}
public bool Compare(ITextRangeProvider range)
{
var that = range as TextEditorTextRangeProvider;
if (that != null)
{
return(this.editor == that.editor && this.range.Start == that.range.Start && this.range.End == that.range.End);
}
return(false);
}
public int CompareEndpoints(TextPatternRangeEndpoint endpoint, ITextRangeProvider targetRange, TextPatternRangeEndpoint targetEndpoint)
{
if (!(targetRange is TextRangeProvider provider))
{
return(0);
}
var position = endpoint == TextPatternRangeEndpoint.Start ? this.Position : this.EndPosition;
var targetPosition = targetEndpoint == TextPatternRangeEndpoint.Start ? provider.Position : provider.EndPosition;
return(position - targetPosition);
}
/// <summary>
/// Retrieves the visible ranges of text.
/// </summary>
/// <returns>The ranges of text that are visible, or possibly an empty array if there is
/// no visible text whatsoever. Text in the range may still be obscured by an overlapping
/// window. Also, portions
/// of the range at the beginning, in the middle, or at the end may not be visible
/// because they are scrolled off to the side.
/// Providers should ensure they return at most a range from the beginning of the first
/// line with portions visible through the end of the last line with portions visible.</returns>
ITextRangeProvider[] ITextProvider.GetVisibleRanges()
{
ITextRangeProvider[] ranges = null;
ITextView textView = GetUpdatedTextView();
if (textView != null)
{
List <TextSegment> visibleTextSegments = new List <TextSegment>();
// Get visible portion of the document.
// FUTURE-2005/01/12-vsmirnov - Narrow the range by skipping partially visible
// rows (columns, pages) on each end. For this, we need to know the limit values
// (percents of row_width/column_height, I guess) to decide on row/column/page visibility.
// Also, need to define what to do with margin cases, like 2 rows (columns, pages) are
// in the view but none of them is visible enough.
if (textView is MultiPageTextView)
{
// For MultiPageTextView assume that all current pages are entirely visible.
visibleTextSegments.AddRange(textView.TextSegments);
}
else
{
// For all others TextViews get visible rectangle and hittest TopLeft and
// BottomRight points to retrieve visible range.
// Find out the bounds of the area visible through all nested scroll areas
Rect visibleRect = GetVisibleRectangle(textView);
if (!visibleRect.IsEmpty)
{
ITextPointer visibleStart = textView.GetTextPositionFromPoint(visibleRect.TopLeft, true);
ITextPointer visibleEnd = textView.GetTextPositionFromPoint(visibleRect.BottomRight, true);
visibleTextSegments.Add(new TextSegment(visibleStart, visibleEnd, true));
}
}
// Create collection of TextRangeProviders for visible ranges.
if (visibleTextSegments.Count > 0)
{
ranges = new ITextRangeProvider[visibleTextSegments.Count];
for (int i = 0; i < visibleTextSegments.Count; i++)
{
ranges[i] = new TextRangeAdaptor(this, visibleTextSegments[i].Start, visibleTextSegments[i].End, _textPeer);
}
}
}
// If no text is visible in the control, return the degenerate text range
// (empty range) at the beginning of the document.
if (ranges == null)
{
ranges = new ITextRangeProvider[] { new TextRangeAdaptor(this, _textContainer.Start, _textContainer.Start, _textPeer) };
}
return(ranges);
}
public ITextRangeProvider[] GetVisibleRanges()
{
int start_line = -1, end_line = -1;
Document.GetVisibleLineIndexes(TextBoxBase.Bounds, out start_line, out end_line);
ITextRangeProvider range = DocumentRange.Clone();
range.MoveEndpointByUnit(TextPatternRangeEndpoint.Start, TextUnit.Line, start_line);
range.MoveEndpointByUnit(TextPatternRangeEndpoint.End, TextUnit.Line, end_line - start_line);
return(new ITextRangeProvider[] { range });
}
ITextRangeProvider[] ITextProvider.GetSelection()
{
var selectionManager = Control.ActiveTextAreaControl.SelectionManager;
var result = new ITextRangeProvider[selectionManager.SelectionCollection.Count];
for (int i = 0; i < result.Length; i++)
{
result[i] = new TextRangeProvider(Control, selectionManager.SelectionCollection[0]);
}
return(result);
}
/// <summary>
/// Retrieves the visible ranges of text.
/// </summary>
/// <returns>The ranges of text that are visible, or possibly an empty array if there is
/// no visible text whatsoever. Text in the range may still be obscured by an overlapping
/// window. Also, portions
/// of the range at the beginning, in the middle, or at the end may not be visible
/// because they are scrolled off to the side.
/// Providers should ensure they return at most a range from the beginning of the first
/// line with portions visible through the end of the last line with portions visible.</returns>
ITextRangeProvider[] ITextProvider.GetVisibleRanges()
{
ITextRangeProvider[] ranges = null;
ITextView textView = GetUpdatedTextView();
if (textView != null)
{
List <TextSegment> visibleTextSegments = new List <TextSegment>();
// Get visible portion of the document.
//
if (textView is MultiPageTextView)
{
// For MultiPageTextView assume that all current pages are entirely visible.
visibleTextSegments.AddRange(textView.TextSegments);
}
else
{
// For all others TextViews get visible rectangle and hittest TopLeft and
// BottomRight points to retrieve visible range.
// Find out the bounds of the area visible through all nested scroll areas
Rect visibleRect = GetVisibleRectangle(textView);
if (!visibleRect.IsEmpty)
{
ITextPointer visibleStart = textView.GetTextPositionFromPoint(visibleRect.TopLeft, true);
ITextPointer visibleEnd = textView.GetTextPositionFromPoint(visibleRect.BottomRight, true);
visibleTextSegments.Add(new TextSegment(visibleStart, visibleEnd, true));
}
}
// Create collection of TextRangeProviders for visible ranges.
if (visibleTextSegments.Count > 0)
{
ranges = new ITextRangeProvider[visibleTextSegments.Count];
for (int i = 0; i < visibleTextSegments.Count; i++)
{
ranges[i] = new TextRangeAdaptor(this, visibleTextSegments[i].Start, visibleTextSegments[i].End, _textPeer);
}
}
}
// If no text is visible in the control, return the degenerate text range
// (empty range) at the beginning of the document.
if (ranges == null)
{
ranges = new ITextRangeProvider[] { new TextRangeAdaptor(this, _textContainer.Start, _textContainer.Start, _textPeer) };
}
return(ranges);
}
public bool Compare(ITextRangeProvider range)
{
if (range == null)
{
throw new ArgumentNullException("range");
}
var textRange = range as TextRangeProvider;
return
(textRange != null &&
_selection.StartPosition == textRange._selection.StartPosition &&
_selection.EndOffset == textRange._selection.EndOffset);
}
ITextRangeProvider[] ITextProvider.GetVisibleRanges()
{
var document = Control.Document;
var textView = Control.ActiveTextAreaControl.TextArea.TextView;
var result = new ITextRangeProvider[textView.VisibleLineCount];
for (int line = 0; line < textView.VisibleLineCount; line++)
{
result[line] = RangeFromLine(document, textView.FirstVisibleLine + line);
}
return(result);
}
//------------------------------------------------------
//
// Internal Methods
//
//------------------------------------------------------
#region Internal Methods
// Wrap arguments that are being returned, assuming they're not null or already wrapped.
static internal ITextRangeProvider WrapArgument(ITextRangeProvider argument, AutomationPeer peer)
{
if (argument == null)
{
return(null);
}
if (argument is TextRangeProviderWrapper)
{
return(argument);
}
return(new TextRangeProviderWrapper(peer, argument));
}
private ITextRangeProvider GetTextRange(int start, int end)
{
ITextRangeProvider textRange = textProvider.DocumentRange;
if (start >= 0 && end > 0)
{
textRange.MoveEndpointByUnit(TextPatternRangeEndpoint.Start,
TextUnit.Character, start);
textRange.MoveEndpointByRange(TextPatternRangeEndpoint.End,
textRange, TextPatternRangeEndpoint.Start);
textRange.MoveEndpointByUnit(TextPatternRangeEndpoint.End,
TextUnit.Character, end - start);
}
return(textRange);
}
public int CompareEndpoints(TextPatternRangeEndpoint endpoint, ITextRangeProvider targetRange, TextPatternRangeEndpoint targetEndpoint)
{
var range = targetRange as TextRangeProvider;
if (range == null)
{
return(-1);
}
var a = endpoint == TextPatternRangeEndpoint.Start ? range._selection.StartPosition : range._selection.EndPosition;
var b = targetEndpoint == TextPatternRangeEndpoint.Start ? range._selection.StartPosition : range._selection.EndPosition;
var document = _control.Document;
return(document.PositionToOffset(a).CompareTo(document.PositionToOffset(b)));
}
public ITextRangeProvider[] GetVisibleRanges()
{
ITextRangeProvider[] ret = new ITextRangeProvider[1];
if (this.fooTextBox.LayoutLineCollection.Count == 0)
{
ret[0] = new FooTextBoxRangeProvider(this.fooTextBox, 0, 0, this);
}
else
{
EditView view = this.fooTextBox.View;
int startIndex = view.GetIndexFromLayoutLine(new TextPoint(view.Src.Row, 0));
int endIndex = view.GetIndexFromLayoutLine(new TextPoint(view.Src.Row + view.LineCountOnScreen, 0));
ret[0] = new FooTextBoxRangeProvider(this.fooTextBox, startIndex, endIndex - startIndex, this);
}
return(ret);
}
public bool Compare(ITextRangeProvider range)
{
TextRangeProvider rangeProvider = range as TextRangeProvider;
if (rangeProvider == null)
{
return(false);
}
if (rangeProvider.TextProvider != provider)
{
throw new ArgumentException();
}
return((rangeProvider.StartPoint == StartPoint) &&
(rangeProvider.EndPoint == EndPoint));
}
public bool Compare(ITextRangeProvider o)
{
FooTextBoxRangeProvider other = o as FooTextBoxRangeProvider;
if (other == null)
{
throw new ArgumentNullException("null以外の値を指定してください");
}
if (this.start == other.start && this.end == other.end)
{
return(true);
}
else
{
return(false);
}
}
public override bool AddSelection(int startOffset, int endOffset)
{
ITextRangeProvider textRange = GetTextRange(startOffset, endOffset);
if (NSelections == 0)
{
textRange.Select();
return(true);
}
try {
textRange.AddToSelection();
} catch (InvalidOperationException e) {
Log.Debug(e);
return(false);
}
return(true);
}
public void MoveEndpointByRange(TextPatternRangeEndpoint endpoint,
ITextRangeProvider targetRange,
TextPatternRangeEndpoint targetEndpoint)
{
TextRangeProvider prov = (TextRangeProvider)targetRange;
int val = (targetEndpoint == TextPatternRangeEndpoint.Start)
? prov.StartPoint : prov.EndPoint;
if (endpoint == TextPatternRangeEndpoint.Start)
{
normalizer.StartPoint = val;
}
else if (endpoint == TextPatternRangeEndpoint.End)
{
normalizer.EndPoint = val;
}
}
public override bool SetSelection(int selectionNum, int startOffset, int endOffset)
{
if (textProvider.SupportedTextSelection == SupportedTextSelection.Single)
{
if (selectionNum != 0 || NSelections != 1)
{
return(false);
}
ITextRangeProvider textRange = GetTextRange(startOffset, endOffset);
textRange.Select();
return(true);
}
if (!RemoveSelection(selectionNum))
{
return(false);
}
return(AddSelection(startOffset, endOffset));
}
static internal ITextRangeProvider [] WrapArgument(ITextRangeProvider [] argument, AutomationPeer peer)
{
if (argument == null)
{
return(null);
}
if (argument is TextRangeProviderWrapper [])
{
return(argument);
}
ITextRangeProvider[] outArray = new ITextRangeProvider[argument.Length];
for (int i = 0; i < argument.Length; i++)
{
outArray[i] = WrapArgument(argument[i], peer);
}
return(outArray);
}
internal string GetOrCreateTextRange (ITextRangeProvider rangeProvider)
{
if (rangeProvider == null)
return string.Empty;
foreach (var entry in textRangeMapping) {
if (entry.Value.Provider == rangeProvider)
return entry.Key;
}
TextPatternRangeWrapper tpw = new TextPatternRangeWrapper (rangeProvider, this);
string path = string.Format ("{0}/Range{1}", patternPath, textRangeIdCount);
bus.Register (new ObjectPath (path), tpw);
textRangeIdCount++;
TextPatternRangeInfo newInfo = new TextPatternRangeInfo {
Provider = rangeProvider,
ProviderWrapper = tpw
};
textRangeMapping.Add (path, newInfo);
return path;
}
private static void HandleTextSelectionChangedEvent(ProxySimple el, IntPtr hwnd, int eventId)
{
ITextProvider textProvider = el.GetPatternProvider(TextPattern.Pattern) as ITextProvider;
if (textProvider == null)
{
return;
}
if (eventId == NativeMethods.EventObjectLocationChange)
{
// We do not want to raise the EventObjectLocationChange when it is caused by a scroll. To do this
// store the previous range and compare it to the current range. The range will not change when scrolling.
ITextRangeProvider[] currentRanges = textProvider.GetSelection();
ITextRangeProvider currentRange = null;
if (currentRanges != null && currentRanges.Length > 0)
{
currentRange = currentRanges[0];
}
if (hwnd == _hwndLast && currentRange != null)
{
if (_lastSelection != null && !currentRange.Compare(_lastSelection))
{
AutomationInteropProvider.RaiseAutomationEvent(TextPattern.TextSelectionChangedEvent, el, new AutomationEventArgs(TextPattern.TextSelectionChangedEvent));
}
}
else
{
AutomationInteropProvider.RaiseAutomationEvent(TextPattern.TextSelectionChangedEvent, el, new AutomationEventArgs(TextPattern.TextSelectionChangedEvent));
}
//store the current range and window handle.
_hwndLast = hwnd;
_lastSelection = currentRange;
}
else if (eventId == NativeMethods.EventObjectTextSelectionChanged)
{
AutomationInteropProvider.RaiseAutomationEvent(
TextPattern.TextSelectionChangedEvent, el,
new AutomationEventArgs(TextPattern.TextSelectionChangedEvent));
}
}
// Token: 0x060065D0 RID: 26064 RVA: 0x001C8810 File Offset: 0x001C6A10
ITextRangeProvider[] ITextProvider.GetVisibleRanges()
{
ITextRangeProvider[] array = null;
ITextView updatedTextView = this.GetUpdatedTextView();
if (updatedTextView != null)
{
List <TextSegment> list = new List <TextSegment>();
if (updatedTextView is MultiPageTextView)
{
list.AddRange(updatedTextView.TextSegments);
}
else
{
Rect visibleRectangle = this.GetVisibleRectangle(updatedTextView);
if (!visibleRectangle.IsEmpty)
{
ITextPointer textPositionFromPoint = updatedTextView.GetTextPositionFromPoint(visibleRectangle.TopLeft, true);
ITextPointer textPositionFromPoint2 = updatedTextView.GetTextPositionFromPoint(visibleRectangle.BottomRight, true);
list.Add(new TextSegment(textPositionFromPoint, textPositionFromPoint2, true));
}
}
if (list.Count > 0)
{
array = new ITextRangeProvider[list.Count];
for (int i = 0; i < list.Count; i++)
{
array[i] = new TextRangeAdaptor(this, list[i].Start, list[i].End, this._textPeer);
}
}
}
if (array == null)
{
array = new ITextRangeProvider[]
{
new TextRangeAdaptor(this, this._textContainer.Start, this._textContainer.Start, this._textPeer)
};
}
return(array);
}
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)
{
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に未知の値が指定されました");
}
ITextRangeProvider[] ITextProvider.GetSelection()
{
var selectionManager = Control.ActiveTextAreaControl.SelectionManager;
var result = new ITextRangeProvider[selectionManager.SelectionCollection.Count];
for (int i = 0; i < result.Length; i++)
{
result[i] = new TextRangeProvider(Control, selectionManager.SelectionCollection[0]);
}
return result;
}
/// <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();
}
}
}
/// <summary>
/// Moves one endpoint of a text range to the specified endpoint of a second text 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(System.Windows.Automation.Text.TextPatternRangeEndpoint endpoint, ITextRangeProvider targetRange, System.Windows.Automation.Text.TextPatternRangeEndpoint targetEndpoint)
{
throw new NotImplementedException();
}
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));
}
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;
}
ITextRangeProvider[] ITextProvider.GetVisibleRanges()
{
ITextRangeProvider[] ret = new ITextRangeProvider[1];
//ret[0] = new ScreenDisplayRangeProvider(terminal.ContentText, this);
ret[0] = new ScreenDisplayRangeProvider(string.Empty, this);
return ret;
}
public int CompareEndpoints(TextPatternRangeEndpoint endpoint, ITextRangeProvider targetRange, TextPatternRangeEndpoint targetEndpoint)
{
return 0;
}
public int CompareEndpoints(TextPatternRangeEndpoint endpoint, ITextRangeProvider targetRange, TextPatternRangeEndpoint targetEndpoint)
{
return(0);
}
public bool Compare(ITextRangeProvider range)
{
if (range == null)
throw new ArgumentNullException("range");
var textRange = range as TextRangeProvider;
return
textRange != null &&
_selection.StartPosition == textRange._selection.StartPosition &&
_selection.EndOffset == textRange._selection.EndOffset;
}
public void MoveEndpointByRange(TextPatternRangeEndpoint endpoint, ITextRangeProvider targetRange, TextPatternRangeEndpoint targetEndpoint)
{
throw new NotImplementedException();
}
public int CompareEndpoints(TextPatternRangeEndpoint endpoint, ITextRangeProvider targetRange, TextPatternRangeEndpoint targetEndpoint)
{
var range = targetRange as TextRangeProvider;
if (range == null)
return -1;
var a = endpoint == TextPatternRangeEndpoint.Start ? range._selection.StartPosition : range._selection.EndPosition;
var b = targetEndpoint == TextPatternRangeEndpoint.Start ? range._selection.StartPosition : range._selection.EndPosition;
var document = _control.Document;
return document.PositionToOffset(a).CompareTo(document.PositionToOffset(b));
}
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;
}
}
/// <summary>
/// Compares this range with another range.
/// </summary>
/// <param name="range">A range to compare.
/// The range must have come from the same text provider or an InvalidArgumentException will be thrown.</param>
/// <returns>true if both ranges span the same text.</returns>
bool ITextRangeProvider.Compare(ITextRangeProvider range)
{
if (range == null)
{
throw new ArgumentNullException("range");
}
TextRangeAdaptor rangeAdaptor = ValidateAndThrow(range);
Normalize();
rangeAdaptor.Normalize();
return (rangeAdaptor._start.CompareTo(_start) == 0 && rangeAdaptor._end.CompareTo(_end) == 0);
}
//-------------------------------------------------------------------
//
// Private Methods
//
//-------------------------------------------------------------------
#region Private Methods
/// <summary>
/// Verifies that the given range points to the same text container as this one.
/// </summary>
/// <returns>The validated range casted to TextRangeAdaptor</returns>
private TextRangeAdaptor ValidateAndThrow(ITextRangeProvider range)
{
TextRangeAdaptor rangeAdaptor = range as TextRangeAdaptor;
if (rangeAdaptor == null || rangeAdaptor._start.TextContainer != _start.TextContainer)
{
throw new ArgumentException(SR.Get(SRID.TextRangeProvider_WrongTextRange));
}
return rangeAdaptor;
}
/// <summary>
/// Retrieves the visible ranges of text.
/// </summary>
/// <returns>The ranges of text that are visible, or possibly an empty array if there is
/// no visible text whatsoever. Text in the range may still be obscured by an overlapping
/// window. Also, portions
/// of the range at the beginning, in the middle, or at the end may not be visible
/// because they are scrolled off to the side.
/// Providers should ensure they return at most a range from the beginning of the first
/// line with portions visible through the end of the last line with portions visible.</returns>
ITextRangeProvider[] ITextProvider.GetVisibleRanges()
{
ITextRangeProvider[] ranges = null;
ITextView textView = GetUpdatedTextView();
if (textView != null)
{
List<TextSegment> visibleTextSegments = new List<TextSegment>();
// Get visible portion of the document.
//
if (textView is MultiPageTextView)
{
// For MultiPageTextView assume that all current pages are entirely visible.
visibleTextSegments.AddRange(textView.TextSegments);
}
else
{
// For all others TextViews get visible rectangle and hittest TopLeft and
// BottomRight points to retrieve visible range.
// Find out the bounds of the area visible through all nested scroll areas
Rect visibleRect = GetVisibleRectangle(textView);
if (!visibleRect.IsEmpty)
{
ITextPointer visibleStart = textView.GetTextPositionFromPoint(visibleRect.TopLeft, true);
ITextPointer visibleEnd = textView.GetTextPositionFromPoint(visibleRect.BottomRight, true);
visibleTextSegments.Add(new TextSegment(visibleStart, visibleEnd, true));
}
}
// Create collection of TextRangeProviders for visible ranges.
if (visibleTextSegments.Count > 0)
{
ranges = new ITextRangeProvider[visibleTextSegments.Count];
for (int i = 0; i < visibleTextSegments.Count; i++)
{
ranges[i] = new TextRangeAdaptor(this, visibleTextSegments[i].Start, visibleTextSegments[i].End, _textPeer);
}
}
}
// If no text is visible in the control, return the degenerate text range
// (empty range) at the beginning of the document.
if (ranges == null)
{
ranges = new ITextRangeProvider[] { new TextRangeAdaptor(this, _textContainer.Start, _textContainer.Start, _textPeer) };
}
return ranges;
}
ITextRangeProvider[] ITextProvider.GetVisibleRanges()
{
var document = Control.Document;
var textView = Control.ActiveTextAreaControl.TextArea.TextView;
var result = new ITextRangeProvider[textView.VisibleLineCount];
for (int line = 0; line < textView.VisibleLineCount; line++)
{
result[line] = RangeFromLine(document, textView.FirstVisibleLine + line);
}
return result;
}
ITextRangeProvider[] ITextProvider.GetVisibleRanges()
{
ITextRangeProvider[] ret = new ITextRangeProvider[1];
ret[0] = new CustomControl2RangeProvider(customInputBox.ContentText, this);
return ret;
}
private bool IsAttrNotNullOrMultiValued (int providerAttrId,
ITextRangeProvider prov,
out object val)
{
val = prov.GetAttributeValue (providerAttrId);
return !((val == null) || (val == TextPattern.MixedAttributeValue));
}
public bool Compare(ITextRangeProvider other)
{
return true;
}
private static extern int RawUiaRaiseActiveTextPositionChangedEvent(IRawElementProviderSimple provider, ITextRangeProvider textRange);
public void MoveEndpointByRange(TextPatternRangeEndpoint endpoint, ITextRangeProvider targetRange, TextPatternRangeEndpoint targetEndpoint)
{
}
internal static void UiaRaiseActiveTextPositionChangedEvent(IRawElementProviderSimple provider, ITextRangeProvider textRange)
{
CheckError(RawUiaRaiseActiveTextPositionChangedEvent(provider, textRange));
}
public bool Compare(ITextRangeProvider range)
{
TextRangeProvider other = (TextRangeProvider) range;
bool result = doc == other.doc
&& segment.Offset == other.segment.Offset
&& segment.EndOffset == other.segment.EndOffset;
Log("{0}.Compare({1}) = {2}", ID, other.ID, result);
return result;
}
/// <summary>
/// Returns a value that indicates whether the span (the <see cref="F:System.Windows.Automation.Text.TextPatternRangeEndpoint.Start"/> endpoint to the <see cref="F:System.Windows.Automation.Text.TextPatternRangeEndpoint.End"/> endpoint) of a text range is the same as another text range.
/// </summary>
/// <param name="range">A text range to compare</param>
/// <returns>
/// true if the span of both text ranges is identical; otherwise false.
/// </returns>
/// <exception cref="T:System.ArgumentException">
/// If the range being compared does not come from the same text provider.
/// </exception>
public bool Compare(ITextRangeProvider range)
{
throw new NotImplementedException();
}
public void MoveEndpointByRange(TextPatternRangeEndpoint endpoint, ITextRangeProvider targetRange, TextPatternRangeEndpoint targetEndpoint)
{
}
/// <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 TextPatternRangeWrapper (ITextRangeProvider provider,
TextPatternWrapper parent)
{
this.provider = provider;
this.parent = parent;
}
private void AddTextAttribute (CG.List<Atk.Attribute> attrs,
Atk.TextAttribute atkAttr,
ITextRangeProvider textRange)
{
if (textRange == null) {
return;
}
string name = Atk.TextAdapter.AttributeGetName (atkAttr);
string val = null;
object tmp;
switch (atkAttr) {
case Atk.TextAttribute.Style:
if (IsAttrNotNullOrMultiValued (TextPattern.IsItalicAttribute.Id,
textRange, out tmp))
val = ((bool) tmp) ? "italic" : "normal";
break;
case Atk.TextAttribute.Justification:
if (!IsAttrNotNullOrMultiValued (TextPattern.HorizontalTextAlignmentAttribute.Id,
textRange, out tmp))
break;
HorizontalTextAlignment align = (HorizontalTextAlignment) tmp;
if (align == HorizontalTextAlignment.Left)
val = "left";
else if (align == HorizontalTextAlignment.Right)
val = "right";
else if (align == HorizontalTextAlignment.Centered)
val = "center";
else if (align == HorizontalTextAlignment.Justified)
val = "fill";
break;
case Atk.TextAttribute.FgColor:
if (IsAttrNotNullOrMultiValued (TextPattern.ForegroundColorAttribute.Id,
textRange, out tmp)) {
Color fgColor = Color.FromArgb ((int) tmp);
val = String.Format ("{0},{1},{2}", fgColor.R, fgColor.G, fgColor.B);
}
break;
case Atk.TextAttribute.BgColor:
if (IsAttrNotNullOrMultiValued (TextPattern.BackgroundColorAttribute.Id,
textRange, out tmp)) {
Color fgColor = Color.FromArgb ((int) tmp);
val = String.Format ("{0},{1},{2}", fgColor.R, fgColor.G, fgColor.B);
}
break;
case Atk.TextAttribute.FamilyName:
if (IsAttrNotNullOrMultiValued (TextPattern.FontNameAttribute.Id,
textRange, out tmp))
val = (string) tmp;
break;
case Atk.TextAttribute.Weight:
if (IsAttrNotNullOrMultiValued (TextPattern.FontWeightAttribute.Id,
textRange, out tmp))
val = ((int) tmp).ToString ();
break;
case Atk.TextAttribute.Strikethrough:
if (IsAttrNotNullOrMultiValued (TextPattern.StrikethroughStyleAttribute.Id,
textRange, out tmp)) {
TextDecorationLineStyle strikeStyle = (TextDecorationLineStyle) tmp;
val = strikeStyle == TextDecorationLineStyle.None ? "false" : "true";
}
break;
case Atk.TextAttribute.Underline:
if (!IsAttrNotNullOrMultiValued (TextPattern.UnderlineStyleAttribute.Id,
textRange, out tmp))
break;
TextDecorationLineStyle underlineStyle = (TextDecorationLineStyle) tmp;
if (underlineStyle == TextDecorationLineStyle.None)
val = "none";
else if (underlineStyle == TextDecorationLineStyle.Double
|| underlineStyle == TextDecorationLineStyle.DoubleWavy)
val = "double";
else
val = "single";
break;
case Atk.TextAttribute.PixelsBelowLines:
if (IsAttrNotNullOrMultiValued (TextPattern.IndentationTrailingAttribute.Id,
textRange, out tmp))
val = ((int) tmp).ToString ();
break;
case Atk.TextAttribute.PixelsAboveLines:
if (IsAttrNotNullOrMultiValued (TextPattern.IndentationLeadingAttribute.Id,
textRange, out tmp))
val = ((int) tmp).ToString ();
break;
case Atk.TextAttribute.Editable:
if (IsAttrNotNullOrMultiValued (TextPattern.IsReadOnlyAttribute.Id,
textRange, out tmp))
val = !((bool) tmp) ? "true" : "false";
break;
case Atk.TextAttribute.Invisible:
if (IsAttrNotNullOrMultiValued (TextPattern.IsHiddenAttribute.Id,
textRange, out tmp))
val = ((bool) tmp) ? "true" : "false";
break;
case Atk.TextAttribute.Indent:
if (IsAttrNotNullOrMultiValued (TextPattern.IndentationFirstLineAttribute.Id,
textRange, out tmp))
val = ((int) tmp).ToString ();
break;
}
if (val != null) {
attrs.Add (new Atk.Attribute {Name = name, Value = val});
}
}
