Code:
/ DotNET / DotNET / 8.0 / untmp / WIN_WINDOWS / lh_tools_devdiv_wpf / Windows / wcp / Framework / System / Windows / Documents / TextStore.cs / 7 / TextStore.cs
//----------------------------------------------------------------------------
//
//
// Copyright (C) Microsoft Corporation. All rights reserved.
//
//
//
// Description: ITextStoreACP implementation.
//
// History:
// 07/17/2003 : [....] - Ported from dotnet tree.
//
//---------------------------------------------------------------------------
using System;
using System.Runtime.InteropServices;
using System.Runtime.InteropServices.ComTypes;
using System.Windows.Threading;
using System.Threading;
using System.Globalization;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using MS.Internal;
using MS.Internal.PresentationFramework; // SecurityHelper
using System.Windows.Controls;
using System.Windows.Markup; // for XmlLanguage
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Input;
using System.Windows.Interop;
using System.Windows.Documents;
using MS.Internal.Documents;
using System.Security;
using System.Security.Permissions;
using MS.Win32;
using IComDataObject = System.Runtime.InteropServices.ComTypes.IDataObject;
namespace System.Windows.Documents
{
// The TextStore class is a managed implementation of a Text Services
// Framework ITextStoreACP. TextStores represent documents for TSF,
// which enables things like IME input, speech dictation, or ink-to-text
// handwriting.
//
// The TextEditor class instantiates TextStore's when it detects available
// Text Services on the desktop.
internal class TextStore : UnsafeNativeMethods.ITextStoreACP,
UnsafeNativeMethods.ITfThreadFocusSink,
UnsafeNativeMethods.ITfContextOwnerCompositionSink,
UnsafeNativeMethods.ITfTextEditSink,
UnsafeNativeMethods.ITfTransitoryExtensionSink,
UnsafeNativeMethods.ITfMouseTrackerACP
{
//-----------------------------------------------------
//
// Constructors
//
//-----------------------------------------------------
#region Constructors
// Creates a new TextStore instance.
// The interesting initialization is in Attach/Detach.
internal TextStore(TextEditor textEditor)
{
// We have only weak reference to TextEditor so it is free to be GCed.
_weakTextEditor = new ScopeWeakReference(textEditor);
// initialize Cookies.
_threadFocusCookie = UnsafeNativeMethods.TF_INVALID_COOKIE;
_editSinkCookie = UnsafeNativeMethods.TF_INVALID_COOKIE;
_editCookie = UnsafeNativeMethods.TF_INVALID_COOKIE;
_transitoryExtensionSinkCookie = UnsafeNativeMethods.TF_INVALID_COOKIE;
}
#endregion Constructors
//------------------------------------------------------
//
// Methods - ITextStoreACP
//
//-----------------------------------------------------
#region ITextStoreACP
// See msdn's ITextStoreACP documentation for a full description.
///
/// Critical: calls Marshal.ReleaseComObject which LinkDemands
/// TreatAsSafe: Can only release an existing sink, and only if a vaild new one is passed in
///
[SecurityCritical, SecurityTreatAsSafe]
public void AdviseSink(ref Guid riid, object obj, UnsafeNativeMethods.AdviseFlags flags)
{
UnsafeNativeMethods.ITextStoreACPSink sink;
if (riid != UnsafeNativeMethods.IID_ITextStoreACPSink)
{
throw new COMException(SR.Get(SRID.TextStore_CONNECT_E_CANNOTCONNECT), unchecked((int)0x80040202));
}
sink = obj as UnsafeNativeMethods.ITextStoreACPSink;
if (sink == null)
{
throw new COMException(SR.Get(SRID.TextStore_E_NOINTERFACE), unchecked((int)0x80004002));
}
// It's legal to replace existing sink.
if (_sink != null)
{
Marshal.ReleaseComObject(_sink);
}
else
{
// Start tracking window movement for _sink.
_textservicesHost.RegisterWinEventSink(this);
}
_sink = sink;
}
// See msdn's ITextStoreACP documentation for a full description.
///
/// Critical - as this satisfies the LinkDemand from Marshal.ReleaseComObject().
/// TreatAsSafe - as the worst that would happen is NullReference exception when _sink is accessed.
///
[SecurityCritical, SecurityTreatAsSafe]
public void UnadviseSink(object obj)
{
if (obj != _sink)
{
throw new COMException(SR.Get(SRID.TextStore_CONNECT_E_NOCONNECTION), unchecked((int)0x80040200));
}
Marshal.ReleaseComObject(_sink);
_sink = null;
// We don't need to track window movement for this textstore any more.
// _sink was the only consumer.
_textservicesHost.UnregisterWinEventSink(this);
}
// See msdn's ITextStoreACP documentation for a full description.
public void RequestLock(UnsafeNativeMethods.LockFlags flags, out int hrSession)
{
if (_sink == null)
throw new COMException(SR.Get(SRID.TextStore_NoSink));
if (flags == 0)
throw new COMException(SR.Get(SRID.TextStore_BadLockFlags));
if (_lockFlags != 0)
{
// Normally, we disallow reentrant lock requests.
// However, there is one legal case. If the caller already
// holds a read lock, and is asking for a write lock, then
// we will grant that asynchronously as soon as they walk
// back up the stack to the original RequestLock call.
if (((_lockFlags & UnsafeNativeMethods.LockFlags.TS_LF_WRITE) == UnsafeNativeMethods.LockFlags.TS_LF_WRITE) ||
((flags & UnsafeNativeMethods.LockFlags.TS_LF_WRITE) == 0) ||
((flags & UnsafeNativeMethods.LockFlags.TS_LF_SYNC) == UnsafeNativeMethods.LockFlags.TS_LF_SYNC))
{
throw new COMException(SR.Get(SRID.TextStore_ReentrantRequestLock));
}
_pendingWriteReq = true;
hrSession = UnsafeNativeMethods.TS_S_ASYNC;
}
else
{
if (_textChangeReentrencyCount == 0)
{
// We can grant a synchronous lock.
hrSession = GrantLockWorker(flags);
}
else
{
// We can't grant a synchornous lock -- we're inside a OnTextChanged notification.
// We don't want to allow even read-only locks, because that might
// trigger a layout update.
if ((flags & UnsafeNativeMethods.LockFlags.TS_LF_SYNC) == 0)
{
if (_pendingAsyncLockFlags == 0)
{
// No pending lock item in the queue, post one.
_pendingAsyncLockFlags = flags;
Dispatcher.CurrentDispatcher.BeginInvoke(DispatcherPriority.Normal, new DispatcherOperationCallback(GrantLockHandler), null);
}
else if (((flags & UnsafeNativeMethods.LockFlags.TS_LF_READWRITE) & _pendingAsyncLockFlags) !=
(flags & UnsafeNativeMethods.LockFlags.TS_LF_READWRITE))
{
// There's a pending item in the queue, but we need to bump up
// the privilege from read-only to write.
_pendingAsyncLockFlags = flags;
}
else
{
// There's already a pending queue item of sufficient privilege --
// nothing to do.
}
hrSession = UnsafeNativeMethods.TS_S_ASYNC;
}
else
{
// Caller insists on a sync lock -- give up.
hrSession = UnsafeNativeMethods.TS_E_SYNCHRONOUS;
}
}
}
}
// See msdn's ITextStoreACP documentation for a full description.
public void GetStatus(out UnsafeNativeMethods.TS_STATUS status)
{
if (IsTextEditorValid && IsReadOnly)
{
// ITfContext::GetStatus() does not take edit cookie. So this could be called
// out of EditSession. We need to get an access to Dispatcher to check ReadOnly.
status.dynamicFlags = UnsafeNativeMethods.DynamicStatusFlags.TS_SD_READONLY;
}
else
{
status.dynamicFlags = 0;
}
// This textstore supports Regions.
status.staticFlags = UnsafeNativeMethods.StaticStatusFlags.TS_SS_REGIONS;
}
// See msdn's ITextStoreACP documentation for a full description.
public void QueryInsert(int startIndex, int endIndex, int cch, out int startResultIndex, out int endResultIndex)
{
// For now, always ok to insert.
startResultIndex = startIndex;
endResultIndex = endIndex;
}
// See msdn's ITextStoreACP documentation for a full description.
public void GetSelection(int index, int count, UnsafeNativeMethods.TS_SELECTION_ACP[] selection, out int fetched)
{
fetched = 0;
if (count > 0 && (index == 0 || index == UnsafeNativeMethods.TS_DEFAULT_SELECTION))
{
selection[0].start = this.TextSelection.Start.CharOffset;
selection[0].end = this.TextSelection.End.CharOffset;
selection[0].style.ase = (this.TextSelection.MovingPosition.CompareTo(this.TextSelection.Start) == 0) ? UnsafeNativeMethods.TsActiveSelEnd.TS_AE_START : UnsafeNativeMethods.TsActiveSelEnd.TS_AE_END;
selection[0].style.interimChar = _interimSelection;
fetched = 1;
}
}
// See msdn's ITextStoreACP documentation for a full description.
public void SetSelection(int count, UnsafeNativeMethods.TS_SELECTION_ACP[] selection)
{
ITextPointer start;
ITextPointer end;
if (count == 1)
{
GetNormalizedRange(selection[0].start, selection[0].end, out start, out end);
if (selection[0].start == selection[0].end)
{
// Setting a caret. Make sure we set Backward direction to
// keep the caret tight with the composition text.
this.TextSelection.SetCaretToPosition(start, LogicalDirection.Backward, /*allowStopAtLineEnd:*/true, /*allowStopNearSpace:*/true);
}
else if (selection[0].style.ase == UnsafeNativeMethods.TsActiveSelEnd.TS_AE_START)
{
this.TextSelection.Select(end, start);
}
else
{
this.TextSelection.Select(start, end);
}
// Update the selection style of InterimSelection.
bool previousInterimSelection = _interimSelection;
_interimSelection = selection[0].style.interimChar;
if (previousInterimSelection != _interimSelection)
{
// Call TextSelection to start/stop the block caret.
this.TextSelection.OnInterimSelectionChanged(_interimSelection);
}
}
}
// See msdn's ITextStoreACP documentation for a full description.
public void GetText(int startIndex, int endIndex, char[] text, int cchReq, out int charsCopied,
UnsafeNativeMethods.TS_RUNINFO[] runInfo, int cRunInfoReq, out int cRunInfoRcv, out int nextIndex)
{
ITextPointer navigator;
ITextPointer limit;
bool hitLimit;
charsCopied = 0;
cRunInfoRcv = 0;
nextIndex = startIndex;
if (cchReq == 0 && cRunInfoReq == 0)
return;
if (startIndex == endIndex)
return;
navigator = CreatePointerAtCharOffset(startIndex, LogicalDirection.Forward);
limit = (endIndex >= 0) ? CreatePointerAtCharOffset(endIndex, LogicalDirection.Forward) : null;
hitLimit = false;
// Loop until we hit something that blocks the get, or until we run
// out of buffer space.
while (!hitLimit && (cchReq == 0 || cchReq > charsCopied) && (cRunInfoReq == 0 || cRunInfoReq > cRunInfoRcv))
{
TextPointerContext context = navigator.GetPointerContext(LogicalDirection.Forward);
switch (context)
{
case TextPointerContext.Text:
hitLimit = WalkTextRun(navigator, limit, text, cchReq, ref charsCopied, runInfo, cRunInfoReq, ref cRunInfoRcv);
break;
case TextPointerContext.EmbeddedElement:
hitLimit = WalkObjectRun(navigator, limit, text, cchReq, ref charsCopied, runInfo, cRunInfoReq, ref cRunInfoRcv);
break;
case TextPointerContext.ElementStart:
Invariant.Assert(navigator is TextPointer);
TextElement element = (TextElement)((TextPointer)navigator).GetAdjacentElement(LogicalDirection.Forward);
if (element.IMELeftEdgeCharCount > 0)
{
Invariant.Assert(element.IMELeftEdgeCharCount == 1);
hitLimit = WalkRegionBoundary(navigator, limit, text, cchReq, ref charsCopied, runInfo, cRunInfoReq, ref cRunInfoRcv);
}
else
{
navigator.MoveToNextContextPosition(LogicalDirection.Forward);
hitLimit = (limit != null && navigator.CompareTo(limit) >= 0);
}
break;
case TextPointerContext.ElementEnd:
navigator.MoveToNextContextPosition(LogicalDirection.Forward);
hitLimit = (limit != null && navigator.CompareTo(limit) >= 0);
break;
case TextPointerContext.None:
// Hit the begin/end-of-doc.
hitLimit = true;
break;
default:
Invariant.Assert(false, "Bogus TextPointerContext!");
break;
}
}
nextIndex = navigator.CharOffset;
}
// See msdn's ITextStoreACP documentation for a full description.
public void SetText(UnsafeNativeMethods.SetTextFlags flags, int startIndex, int endIndex, char[] text, int cch, out UnsafeNativeMethods.TS_TEXTCHANGE change)
{
if (this.IsReadOnly)
{
throw new COMException(SR.Get(SRID.TextStore_TS_E_READONLY), UnsafeNativeMethods.TS_E_READONLY);
}
ITextPointer start;
ITextPointer end;
GetNormalizedRange(startIndex, endIndex, out start, out end);
while (start != null && TextPointerBase.IsBeforeFirstTable(start))
{
start = start.GetNextInsertionPosition(LogicalDirection.Forward);
}
if (start == null)
{
throw new COMException(SR.Get(SRID.TextStore_CompositionRejected), NativeMethods.E_FAIL);
}
if (start.CompareTo(end) > 0)
{
end = start;
}
string filteredText = new string(text);
if (!this.TextEditor.AcceptsRichContent)
{
filteredText = FilterCompositionString(filteredText, start.GetOffsetToPosition(end));
if (filteredText == null)
{
throw new COMException(SR.Get(SRID.TextStore_CompositionRejected), NativeMethods.E_FAIL);
}
}
// Openes a composition undo unit for the composition undo.
CompositionParentUndoUnit unit = OpenCompositionUndoUnit();
UndoCloseAction undoCloseAction = UndoCloseAction.Rollback;
try
{
ITextRange range = new TextRange(start, end, true /* ignoreTextUnitBoundaries */);
this.TextEditor.SetText(range, filteredText, InputLanguageManager.Current.CurrentInputLanguage);
change.start = startIndex;
change.oldEnd = endIndex;
change.newEnd = endIndex + text.Length - (endIndex - startIndex);
ValidateChange(change);
VerifyTextStoreConsistency();
undoCloseAction = UndoCloseAction.Commit;
}
finally
{
// Closes compsotion undo unit with commit to add the composition undo unit into the undo stack.
CloseTextParentUndoUnit(unit, undoCloseAction);
}
}
// See msdn's ITextStoreACP documentation for a full description.
public void GetFormattedText(int startIndex, int endIndex, out object obj)
{
obj = null;
throw new COMException(SR.Get(SRID.TextStore_E_NOTIMPL), unchecked((int)0x80004001));
}
// See msdn's ITextStoreACP documentation for a full description.
public void GetEmbedded(int index, ref Guid guidService, ref Guid riid, out object obj)
{
obj = null;
#if ENABLE_INK_EMBEDDING
ITextPointer textPosition;
if (index < this.TextContainer.IMECharCount)
{
// Create a position just following the index and look backward.
// CreatePointerAtCharOffset always returns a pointer adjacent
// to the lowest symbol offset matching a given char offset.
textPosition = CreatePointerAtCharOffset(index + 1, LogicalDirection.Forward);
if (textPosition.GetPointerContext(LogicalDirection.Backward) == TextPointerContext.EmbeddedElement)
{
object rawobj = textPosition.GetAdjacentElement(LogicalDirection.Forward);
InkInteropObject inkobject = rawobj as InkInteropObject;
if (inkobject != null)
{
obj = inkobject.OleDataObject;
}
}
}
#endif
}
// See msdn's ITextStoreACP documentation for a full description.
public void QueryInsertEmbedded(ref Guid guidService, int formatEtc, out bool insertable)
{
#if true
//
// Disable embedded object temporarily because...
// - There is no persistency supported including cut and past (Bug 985589).
// - It is GDI metadata that is rendered so there is no relation with Avalon ink editing at all.
// - This was one of major feature in Cicero on Office XP timeframe however the latest Tablet
// Input Panel does not have this feature anymore. (Does it?)
//
insertable = false;
#else
if (TextEditor.AcceptsRichContent)
{
//
insertable = this.TextSelection.HasConcreteTextContainer;
}
else
{
insertable = false;
}
#endif
}
// See msdn's ITextStoreACP documentation for a full description.
public void InsertEmbedded(UnsafeNativeMethods.InsertEmbeddedFlags flags, int startIndex, int endIndex, object obj, out UnsafeNativeMethods.TS_TEXTCHANGE change)
{
if (IsReadOnly)
{
throw new COMException(SR.Get(SRID.TextStore_TS_E_READONLY), UnsafeNativeMethods.TS_E_READONLY);
}
// Disable embedded object temporarily.
#if ENABLE_INK_EMBEDDING
if (!TextSelection.HasConcreteTextContainer)
{
throw new COMException(SR.Get(SRID.TextStore_TS_E_FORMAT), UnsafeNativeMethods.TS_E_FORMAT);
}
TextContainer container;
TextPointer startPosition;
TextPointer endPosition;
IComDataObject data;
// The object must have IOldDataObject internface.
// The obj param of InsertEmbedded is IDataObject in Win32 definition.
data = obj as IComDataObject;
if (data == null)
{
throw new COMException(SR.Get(SRID.TextStore_BadObject), NativeMethods.E_INVALIDARG);
}
container = (TextContainer)this.TextContainer;
startPosition = container.CreatePointerAtOffset(startIndex, LogicalDirection.Backward);
endPosition = container.CreatePointerAtOffset(endIndex, LogicalDirection.Forward);
InsertEmbeddedAtRange(startPosition, endPosition, data, out change);
#else
throw new COMException(SR.Get(SRID.TextStore_TS_E_FORMAT), UnsafeNativeMethods.TS_E_FORMAT);
#endif
}
// See msdn's ITextStoreACP documentation for a full description.
public void InsertTextAtSelection(UnsafeNativeMethods.InsertAtSelectionFlags flags, char[] text, int cch, out int startIndex, out int endIndex, out UnsafeNativeMethods.TS_TEXTCHANGE change)
{
ITextPointer startNavigator;
ITextPointer endNavigator;
int selectionStartIndex;
int selectionEndIndex;
startIndex = -1;
endIndex = -1;
change.start = 0;
change.oldEnd = 0;
change.newEnd = 0;
if (IsReadOnly)
{
throw new COMException(SR.Get(SRID.TextStore_TS_E_READONLY), UnsafeNativeMethods.TS_E_READONLY);
}
//
//
ITextRange range = new TextRange(this.TextSelection.AnchorPosition, this.TextSelection.MovingPosition);
range.ApplyTypingHeuristics(false /* overType */);
ITextPointer start;
ITextPointer end;
GetAdjustedSelection(range.Start, range.End, out start, out end);
// Someone might change the default selection gravity, so use our
// own TextPositions to track the insert.
startNavigator = start.CreatePointer();
startNavigator.SetLogicalDirection(LogicalDirection.Backward);
endNavigator = end.CreatePointer();
endNavigator.SetLogicalDirection(LogicalDirection.Forward);
selectionStartIndex = startNavigator.CharOffset;
selectionEndIndex = endNavigator.CharOffset;
// Do the insert.
if ((flags & UnsafeNativeMethods.InsertAtSelectionFlags.TS_IAS_QUERYONLY) == 0)
{
// Opene a composition undo unit for the composition undo.
CompositionParentUndoUnit unit = OpenCompositionUndoUnit();
UndoCloseAction undoCloseAction = UndoCloseAction.Rollback;
try
{
VerifyTextStoreConsistency();
change.oldEnd = selectionEndIndex;
string filteredText = FilterCompositionString(new string(text), range.Start.GetOffsetToPosition(range.End));
if (filteredText == null)
{
throw new COMException(SR.Get(SRID.TextStore_CompositionRejected), NativeMethods.E_FAIL);
}
// We still need to call ApplyTypingHeuristics, even though
// we already did the work above, because it might need
// to spring load formatting.
this.TextSelection.ApplyTypingHeuristics(false /* overType */);
//Invariant.Assert(this.TextSelection.Start.CompareTo(range.Start) == 0 && this.TextSelection.End.CompareTo(range.End) == 0);
// We cannot make this Assertion because TextRange will normalize
// differently around Floater/Inline edges. This is probably
// not desired behavior. To repro,
//
//
//
//
//
// para
//
// Floater
//
//
//
//
//
//
// 1. Put the caret before the Floater.
// 2. Shift-right to select the entire Floater.
// 3. Activate the chinese pinyin IME, and press 'a'.
// Avoid calling Select when the selection doesn't need a
// final reposition to preserve any spring loaded formatting
// from ApplyTypingHeuristics.
if (start.CompareTo(this.TextSelection.Start) != 0 ||
end.CompareTo(this.TextSelection.End) != 0)
{
this.TextSelection.Select(start, end);
}
if (!_isComposing && _previousCompositionStartOffset == -1)
{
// IMEs have the option (TF_IAS_NO_DEFAULT_COMPOSITION)
// of inserting text (via this method only) without first
// starting a composition. If that happens, we need
// to remember where the composition started, from the
// point of view of the application listening to events
// we will raise in the future.
_previousCompositionStartOffset = this.TextSelection.Start.Offset;
_previousCompositionEndOffset = this.TextSelection.End.Offset;
}
this.TextEditor.SetSelectedText(filteredText, InputLanguageManager.Current.CurrentInputLanguage);
change.start = startNavigator.CharOffset;
change.newEnd = endNavigator.CharOffset;
ValidateChange(change);
VerifyTextStoreConsistency();
undoCloseAction = UndoCloseAction.Commit;
}
finally
{
// Close a composition undo unit with commit to add the composition undo unit into the undo stack.
CloseTextParentUndoUnit(unit, undoCloseAction);
}
}
// Report the location of the new text.
if ((flags & UnsafeNativeMethods.InsertAtSelectionFlags.TS_IAS_NOQUERY) == 0)
{
startIndex = selectionStartIndex;
endIndex = endNavigator.CharOffset;
}
}
// See msdn's ITextStoreACP documentation for a full description.
public void InsertEmbeddedAtSelection(UnsafeNativeMethods.InsertAtSelectionFlags flags, object obj, out int startIndex, out int endIndex, out UnsafeNativeMethods.TS_TEXTCHANGE change)
{
startIndex = -1;
endIndex = -1;
change.start = 0;
change.oldEnd = 0;
change.newEnd = 0;
if (IsReadOnly)
{
throw new COMException(SR.Get(SRID.TextStore_TS_E_READONLY), UnsafeNativeMethods.TS_E_READONLY);
}
#if ENABLE_INK_EMBEDDING
IComDataObject data;
if (IsReadOnly)
{
throw new COMException(SR.Get(SRID.TextStore_TS_E_READONLY), UnsafeNativeMethods.TS_E_READONLY);
}
if (!TextSelection.HasConcreteTextContainer)
{
throw new COMException(SR.Get(SRID.TextStore_TS_E_FORMAT), UnsafeNativeMethods.TS_E_FORMAT);
}
// The object must have IOldDataObject internface.
// The obj param of InsertEmbedded is IDataObject in Win32 definition.
data = obj as IComDataObject;
if (data == null)
{
throw new COMException(SR.Get(SRID.TextStore_BadObject), NativeMethods.E_INVALIDARG);
}
// Do the insert.
if ((flags & UnsafeNativeMethods.InsertAtSelectionFlags.TS_IAS_QUERYONLY) == 0)
{
InsertEmbeddedAtRange((TextPointer)this.TextSelection.Start, (TextPointer)this.TextSelection.End, data, out change);
}
if ((flags & UnsafeNativeMethods.InsertAtSelectionFlags.TS_IAS_NOQUERY) == 0)
{
startIndex = this.TextSelection.Start.Offset;
endIndex = this.TextSelection.End.Offset;
}
#else
throw new COMException(SR.Get(SRID.TextStore_TS_E_FORMAT), UnsafeNativeMethods.TS_E_FORMAT);
#endif
}
// See msdn's ITextStoreACP documentation for a full description.
public int RequestSupportedAttrs(UnsafeNativeMethods.AttributeFlags flags, int count, Guid[] filterAttributes)
{
// return the default app property value, which target is Scope.
PrepareAttributes((InputScope)UiScope.GetValue(InputMethod.InputScopeProperty),
(double)UiScope.GetValue(TextElement.FontSizeProperty),
(FontFamily)UiScope.GetValue(TextElement.FontFamilyProperty),
(XmlLanguage)UiScope.GetValue(FrameworkContentElement.LanguageProperty),
UiScope as Visual,
count, filterAttributes);
if (_preparedattributes.Count == 0)
return NativeMethods.S_FALSE;
return NativeMethods.S_OK;
}
// See msdn's ITextStoreACP documentation for a full description.
public int RequestAttrsAtPosition(int index, int count, Guid[] filterAttributes, UnsafeNativeMethods.AttributeFlags flags)
{
ITextPointer position;
position = CreatePointerAtCharOffset(index, LogicalDirection.Forward);
PrepareAttributes((InputScope)position.GetValue(InputMethod.InputScopeProperty),
(double)position.GetValue(TextElement.FontSizeProperty),
(FontFamily)position.GetValue(TextElement.FontFamilyProperty),
(XmlLanguage)position.GetValue(FrameworkContentElement.LanguageProperty),
null,
count, filterAttributes);
if (_preparedattributes.Count == 0)
return NativeMethods.S_FALSE;
return NativeMethods.S_OK;
}
// See msdn's ITextStoreACP documentation for a full description.
public void RequestAttrsTransitioningAtPosition(int position, int count, Guid[] filterAttributes, UnsafeNativeMethods.AttributeFlags flags)
{
throw new COMException(SR.Get(SRID.TextStore_E_NOTIMPL), unchecked((int)0x80004001));
}
// See msdn's ITextStoreACP documentation for a full description.
public void FindNextAttrTransition(int startIndex, int haltIndex, int count, Guid[] filterAttributes, UnsafeNativeMethods.AttributeFlags flags, out int acpNext, out bool found, out int foundOffset)
{
acpNext = 0;
found = false;
foundOffset = 0;
}
// See msdn's ITextStoreACP documentation for a full description.
public void RetrieveRequestedAttrs(int count, UnsafeNativeMethods.TS_ATTRVAL[] attributeVals, out int fetched)
{
fetched = 0;
int i;
for (i = 0; i < count; i++)
{
if (i >= _preparedattributes.Count)
break;
attributeVals[i] = ((UnsafeNativeMethods.TS_ATTRVAL)_preparedattributes[i]);
fetched++;
}
// clear _preparedattributes now so we can keep the ref count of val if it is VT_UNKNOWN.
_preparedattributes.Clear();
_preparedattributes = null;
}
// See msdn's ITextStoreACP documentation for a full description.
public void GetEnd(out int end)
{
end = this.TextContainer.IMECharCount;
}
// See msdn's ITextStoreACP documentation for a full description.
public void GetActiveView(out int viewCookie)
{
viewCookie = _viewCookie;
}
// See msdn's ITextStoreACP documentation for a full description.
///
/// SecurityCritical: This code causes an elevation by calling into ScreentoClient
/// TreatAsSafe: Demand for unmanaged code permission
///
[SecurityCritical,SecurityTreatAsSafe]
public void GetACPFromPoint(int viewCookie, ref UnsafeNativeMethods.POINT tsfPoint, UnsafeNativeMethods.GetPositionFromPointFlags flags, out int positionCP)
{
SecurityHelper.DemandUnmanagedCode();
PresentationSource source;
IWin32Window win32Window;
CompositionTarget compositionTarget;
ITextView view;
Point milPoint;
ITextPointer position;
NativeMethods.POINT point;
point = new NativeMethods.POINT(tsfPoint.x, tsfPoint.y);
GetVisualInfo(out source, out win32Window, out view);
compositionTarget = source.CompositionTarget;
// Convert to client coordinates.
SafeNativeMethods.ScreenToClient(new HandleRef(null,win32Window.Handle), point);
// Convert to mil measure units.
milPoint = new Point(point.x, point.y);
milPoint = compositionTarget.TransformFromDevice.Transform(milPoint);
// Convert to local coordinates.
GeneralTransform transform = compositionTarget.RootVisual.TransformToDescendant(RenderScope);
if (transform != null)
{
//
transform.TryTransform(milPoint, out milPoint);
}
// Validate layout information on TextView
if (!view.Validate(milPoint))
{
throw new COMException(SR.Get(SRID.TextStore_TS_E_NOLAYOUT), UnsafeNativeMethods.TS_E_NOLAYOUT);
}
// Do the hittest.
position = view.GetTextPositionFromPoint(milPoint, (flags & UnsafeNativeMethods.GetPositionFromPointFlags.GXFPF_NEAREST) != 0 /* snapToText */);
if (position == null)
{
// GXFPF_ROUND_NEAREST was clear and we didn't hit a char.
throw new COMException(SR.Get(SRID.TextStore_TS_E_INVALIDPOINT), UnsafeNativeMethods.TS_E_INVALIDPOINT);
}
positionCP = position.CharOffset;
if ((flags & UnsafeNativeMethods.GetPositionFromPointFlags.GXFPF_ROUND_NEAREST) == 0)
{
// Check if the point is on the backward position of the TextPosition.
Rect rectCur;
Rect rectPrev;
Point milPointTopLeft;
Point milPointBottomRight;
ITextPointer positionCur = position.CreatePointer(LogicalDirection.Backward);
ITextPointer positionPrev = position.CreatePointer(LogicalDirection.Forward);
positionPrev.MoveToNextInsertionPosition(LogicalDirection.Backward);
rectCur = view.GetRectangleFromTextPosition(positionCur);
rectPrev = view.GetRectangleFromTextPosition(positionPrev);
// Take the "extended" union of the previous char's bounding box.
milPointTopLeft = new Point(Math.Min(rectPrev.Left, rectCur.Left), Math.Min(rectPrev.Top, rectCur.Top));
milPointBottomRight = new Point(Math.Max(rectPrev.Left, rectCur.Left), Math.Max(rectPrev.Bottom, rectCur.Bottom));
// The rect of the previous char.
Rect rectTest = new Rect(milPointTopLeft, milPointBottomRight);
if (rectTest.Contains(milPoint))
positionCP--;
}
}
// See msdn's ITextStoreACP documentation for a full description.
///
/// Critical - elevates to query visual information
/// TreatAsSafe - only exposes coordinates, which are safe
///
[SecurityCritical, SecurityTreatAsSafe]
void UnsafeNativeMethods.ITextStoreACP.GetTextExt(int viewCookie, int startIndex, int endIndex, out UnsafeNativeMethods.RECT rect, out bool clipped)
{
PresentationSource source;
IWin32Window win32Window;
CompositionTarget compositionTarget;
ITextView view;
ITextPointer startPointer;
ITextPointer endPointer;
GeneralTransform transform;
Point milPointTopLeft;
Point milPointBottomRight;
// We need to update the layout before getting rect. It could be dirty by SetText call of TIP.
UiScope.UpdateLayout();
rect = new UnsafeNativeMethods.RECT();
clipped = false;
GetVisualInfo(out source, out win32Window, out view);
compositionTarget = source.CompositionTarget;
// We use local coordinates.
startPointer = CreatePointerAtCharOffset(startIndex, LogicalDirection.Forward);
startPointer.MoveToInsertionPosition(LogicalDirection.Forward);
if (!this.TextView.IsValid)
{
// We can not get the visual. Return TS_R_NOLAYOUT to the caller.
throw new COMException(SR.Get(SRID.TextStore_TS_E_NOLAYOUT), UnsafeNativeMethods.TS_E_NOLAYOUT);
}
if (startIndex == endIndex)
{
Rect rectStart = startPointer.GetCharacterRect(LogicalDirection.Forward);
milPointTopLeft = rectStart.TopLeft;
milPointBottomRight = rectStart.BottomRight;
}
else
{
Rect rectBound = new Rect(Size.Empty);
ITextPointer navigator = startPointer.CreatePointer();
endPointer = CreatePointerAtCharOffset(endIndex, LogicalDirection.Backward);
endPointer.MoveToInsertionPosition(LogicalDirection.Backward);
bool moved;
do
{
// Compute the textSegment bounds line by line.
TextSegment lineRange = this.TextView.GetLineRange(navigator);
ITextPointer end;
Rect lineRect;
// Skip any BlockUIContainer or any other content that is not treated as a line by TextView.
if (!lineRange.IsNull)
{
ITextPointer start = (lineRange.Start.CompareTo(startPointer) <= 0) ? startPointer : lineRange.Start;
end = (lineRange.End.CompareTo(endPointer) >= 0) ? endPointer : lineRange.End;
lineRect = GetLineBounds(start, end);
moved = (navigator.MoveToLineBoundary(1) != 0) ? true : false;
}
else
{
lineRect = navigator.GetCharacterRect(LogicalDirection.Forward);
moved = navigator.MoveToNextInsertionPosition(LogicalDirection.Forward);
end = navigator;
}
if (lineRect.IsEmpty == false)
{
rectBound.Union(lineRect);
}
if (end.CompareTo(endPointer) == 0)
{
break;
}
}
while (moved);
// Invariant.Assert(rectBound.IsEmpty == false);
milPointTopLeft = rectBound.TopLeft;
milPointBottomRight = rectBound.BottomRight;
}
// Transform to root visual coordinates.
transform = UiScope.TransformToAncestor(compositionTarget.RootVisual);
//
transform.TryTransform(milPointTopLeft, out milPointTopLeft);
transform.TryTransform(milPointBottomRight, out milPointBottomRight);
rect = TransformRootRectToScreenCoordinates(milPointTopLeft, milPointBottomRight, win32Window, source);
}
// See msdn's ITextStoreACP documentation for a full description.
///
/// Critical: This code accceses PresentationSource to retrieve CompositionTarget
/// TreatAsSafe: Both of the types are not exposed and the rect is ok to give out
///
[SecurityCritical, SecurityTreatAsSafe]
public void GetScreenExt(int viewCookie, out UnsafeNativeMethods.RECT rect)
{
PresentationSource source;
IWin32Window win32Window;
ITextView view;
CompositionTarget compositionTarget;
Rect rectUi;
Rect rectDescendant;
Point milPointTopLeft;
Point milPointBottomRight;
GeneralTransform transform;
rectUi = UiScope.VisualContentBounds;
rectDescendant = UiScope.VisualDescendantBounds;
rectUi.Union(rectDescendant);
//
//
GetVisualInfo(out source, out win32Window, out view);
compositionTarget = source.CompositionTarget;
// Take the points of the renderScope.
milPointTopLeft = new Point(rectUi.Left, rectUi.Top);
milPointBottomRight = new Point(rectUi.Right, rectUi.Bottom);
// Transform to root visual coordinates.
transform = UiScope.TransformToAncestor(compositionTarget.RootVisual);
//
transform.TryTransform(milPointTopLeft, out milPointTopLeft);
transform.TryTransform(milPointBottomRight, out milPointBottomRight);
rect = TransformRootRectToScreenCoordinates(milPointTopLeft, milPointBottomRight, win32Window, source);
}
// See msdn's ITextStoreACP documentation for a full description.
///
/// Critical - elevates and access protected information (hwnd and
/// source), then hands it out (hwnd)!
///
[SecurityCritical]
void UnsafeNativeMethods.ITextStoreACP.GetWnd(int viewCookie, out IntPtr hwnd)
{
hwnd = IntPtr.Zero;
hwnd = CriticalSourceWnd;
}
#endregion ITextStoreACP
//------------------------------------------------------
//
// Methods - ITfThreadFocusSink
//
//------------------------------------------------------
#region ITfThreadFocusSink
// See msdn's ITextStoreACP documentation for a full description.
///
/// Critical - manipulates focus
///
[SecurityCritical]
void UnsafeNativeMethods.ITfThreadFocusSink.OnSetThreadFocus()
{
if (!IsTextEditorValid)
{
return;
}
// Reset the focus, cicero won't do it for us.
if (Keyboard.FocusedElement == UiScope)
{
OnGotFocus();
}
}
// See msdn's ITextStoreACP documentation for a full description.
public void OnKillThreadFocus()
{
}
#endregion ITfThreadFocusSink
//-----------------------------------------------------
//
// Methods - ITfContextOwnerCompositionSink
//
//------------------------------------------------------
#region ITfContextOwnerCompositionSink
// See msdn's ITextStoreACP documentation for a full description.
///
/// Critical - calls unmanaged code. This starts a text composition
/// and in doing so extracts the inputmanager which is a critical resource.
/// It gets this from the Inputmanager.UnsecureCurrent call.
/// TreatAsSafe - doesn't return critical information, all parameters are typesafe.
/// The location where the input manager is stored is critical and its
/// usage is tracked
///
[SecurityCritical, SecurityTreatAsSafe]
public void OnStartComposition(UnsafeNativeMethods.ITfCompositionView view, out bool ok)
{
// Disallow multiple compositions.
if (_isComposing)
{
ok = false;
return;
}
ITextPointer start;
ITextPointer end;
GetCompositionPositions(view, out start, out end);
int startOffsetBefore;
int endOffsetBefore;
if (_previousCompositionStartOffset != -1)
{
startOffsetBefore = _previousCompositionStartOffset;
endOffsetBefore = _previousCompositionEndOffset;
}
else
{
startOffsetBefore = start.Offset;
endOffsetBefore = end.Offset;
}
// Add the composition message into the composition message list.
// This composition message list will be handled all together after release the lock.
_lastCompositionText = TextRangeBase.GetTextInternal(start, end);
this.CompositionEventList.Add(new CompositionEventRecord(CompositionStage.StartComposition, startOffsetBefore, endOffsetBefore, _lastCompositionText));
_previousCompositionStartOffset = start.Offset;
_previousCompositionEndOffset = end.Offset;
_isComposing = true;
// Composition event is completed, so new composition undo unit will be opened.
BreakTypingSequence(end);
ok = true;
}
// See msdn's ITextStoreACP documentation for a full description.
///
/// Critical - calls unmanaged code (GetRange)
///
[SecurityCritical]
public void OnUpdateComposition(UnsafeNativeMethods.ITfCompositionView view, UnsafeNativeMethods.ITfRange rangeNew)
{
// If UiScope has a ToolTip and it is open, any keyboard/mouse activity should close the tooltip.
this.TextEditor.CloseToolTip();
Invariant.Assert(_isComposing);
Invariant.Assert(_previousCompositionStartOffset != -1);
ITextPointer oldStart;
ITextPointer oldEnd;
GetCompositionPositions(view, out oldStart, out oldEnd);
ITextPointer newStart = null;
ITextPointer newEnd = null;
bool compositionRangeShifted = false;
if (rangeNew != null)
{
TextPositionsFromITfRange(rangeNew, out newStart, out newEnd);
compositionRangeShifted = (newStart.Offset != oldStart.Offset || newEnd.Offset != oldEnd.Offset);
}
if (compositionRangeShifted)
{
_previousCompositionStartOffset = newStart.Offset;
_previousCompositionEndOffset = newEnd.Offset;
_lastCompositionText = null;
}
else
{
// Add the composition message into the composition message list.
// This composition message list will be handled all together after release the lock.
string compositionText = TextRangeBase.GetTextInternal(oldStart, oldEnd);
CompositionEventRecord record = new CompositionEventRecord(CompositionStage.UpdateComposition, _previousCompositionStartOffset, _previousCompositionEndOffset, compositionText);
CompositionEventRecord previousRecord = (this.CompositionEventList.Count == 0) ? null : this.CompositionEventList[this.CompositionEventList.Count - 1];
if (_lastCompositionText == null ||
String.CompareOrdinal(compositionText, _lastCompositionText) != 0)
{
// Add the new update event.
this.CompositionEventList.Add(record);
}
_previousCompositionStartOffset = oldStart.Offset;
_previousCompositionEndOffset = oldEnd.Offset;
_lastCompositionText = compositionText;
}
// Composition event is completed, so new composition undo unit will be opened.
BreakTypingSequence(oldEnd);
}
// See msdn's ITextStoreACP documentation for a full description.
///
/// Critical - calls unmanaged code (GetRange)
///
[SecurityCritical]
public void OnEndComposition(UnsafeNativeMethods.ITfCompositionView view)
{
Invariant.Assert(_isComposing);
Invariant.Assert(_previousCompositionStartOffset != -1);
ITextPointer start;
ITextPointer end;
GetCompositionPositions(view, out start, out end);
// If we're called from inside the scope of HandleCompositionEvents
// we won't be raising any events.
if (_compositionEventState == CompositionEventState.NotRaisingEvents)
{
// Add the composition message into the composition message list.
// This composition message list will be handled all together after release the lock.
this.CompositionEventList.Add(new CompositionEventRecord(CompositionStage.EndComposition, start.Offset, end.Offset, TextRangeBase.GetTextInternal(start, end)));
// Composition event is completed, so new composition undo unit will be opened.
CompositionParentUndoUnit unit = PeekCompositionParentUndoUnit();
if (unit != null)
{
unit.IsLastCompositionUnit = true;
}
}
_nextUndoUnitIsFirstCompositionUnit = true;
_isComposing = false;
_previousCompositionStartOffset = -1;
_previousCompositionEndOffset = -1;
// The composition no longer exist. We should stop the interim block caret.
if (_interimSelection)
{
_interimSelection = false;
TextSelection.OnInterimSelectionChanged(_interimSelection);
}
BreakTypingSequence(end);
}
#endregion ITfContextOwnerCompositionSink
//-----------------------------------------------------
//
// Methods - ITfTextEditSink
//
//-----------------------------------------------------
#region ITfTextEditSink
// See msdn's ITextStoreACP documentation for a full description.
///
/// Critical - calls unmanaged code, exposes raw input
///
[SecurityCritical]
void UnsafeNativeMethods.ITfTextEditSink.OnEndEdit(UnsafeNativeMethods.ITfContext context, int ecReadOnly, UnsafeNativeMethods.ITfEditRecord editRecord)
{
// Call text service's property OnEndEdit.
_textservicesproperty.OnEndEdit(context, ecReadOnly, editRecord);
// Release editRecord so Finalizer won't do Release() to Cicero's object in GC thread.
Marshal.ReleaseComObject(editRecord);
}
#endregion ITfTextEditSink
//-----------------------------------------------------
//
// Public Methods - ITfTransitoryExtensionSink
//
//------------------------------------------------------
#region ITfTransitoryExtensionSink
// Transitory Document has been updated.
// This is the notification of the changes of the result string and the composition string.
///
/// Critical - Calls critical method (StringFromITfRange), commits that range to the document
/// TreatAsSafe - all parameters are typesafe and are validated, elevated data (the string)
/// is passed from one highly trusted entity to another.
///
[SecurityCritical, SecurityTreatAsSafe]
public void OnTransitoryExtensionUpdated(UnsafeNativeMethods.ITfContext context, int ecReadOnly, UnsafeNativeMethods.ITfRange rangeResult, UnsafeNativeMethods.ITfRange rangeComposition, out bool fDeleteResultRange)
{
fDeleteResultRange = true;
if (rangeResult != null)
{
string result = StringFromITfRange(rangeResult, ecReadOnly);
if (result.Length > 0)
{
if (TextEditor.AllowOvertype && TextEditor._OvertypeMode && TextSelection.IsEmpty)
{
// Extend selection forward to innclude next character within this paragraph
ITextPointer navigator;
navigator = TextSelection.End.CreatePointer();
navigator.MoveToInsertionPosition(LogicalDirection.Forward);
//
if (navigator.GetPointerContext(LogicalDirection.Forward) == TextPointerContext.Text)
{
Char[] nextChars;
nextChars = new Char[2];
// Check if the caret stands before newline - we should not eat it in overtype mode.
navigator.GetTextInRun(LogicalDirection.Forward, nextChars, 0, nextChars.Length);
if (!(nextChars[0] == Environment.NewLine[0] && nextChars[1] == Environment.NewLine[1]))
{
int cnt = result.Length;
while (cnt-- > 0)
{
TextSelection.ExtendToNextInsertionPosition(LogicalDirection.Forward);
}
}
}
}
this.TextEditor.SetText(TextSelection, this.TextEditor._FilterText(result, TextSelection), InputLanguageManager.Current.CurrentInputLanguage);
TextSelection.Select(TextSelection.End, TextSelection.End);
}
}
}
#endregion ITfTransitoryExtensionSink
//-----------------------------------------------------
//
// Public Methods - ITfMouseTrackerACP
//
//------------------------------------------------------
#region ITfMouseTrackerACP
// new mouse sink is registered.
public int AdviceMouseSink(UnsafeNativeMethods.ITfRangeACP range, UnsafeNativeMethods.ITfMouseSink sink, out int dwCookie)
{
if (_mouseSinks == null)
{
_mouseSinks = new ArrayList(1);
}
// Find sinks.
_mouseSinks.Sort();
for (dwCookie = 0; dwCookie < _mouseSinks.Count; dwCookie++)
{
if (((MouseSink)_mouseSinks[dwCookie]).Cookie != dwCookie)
{
break;
}
}
// -1 is an invalid cookie value. This should not happen.
Invariant.Assert(dwCookie != UnsafeNativeMethods.TF_INVALID_COOKIE);
_mouseSinks.Add(new MouseSink(range, sink, dwCookie));
if (_mouseSinks.Count == 1)
{
// If this is the first sink, start listening mouse event for MSIME mouse operation.
UiScope.PreviewMouseLeftButtonDown += new MouseButtonEventHandler(OnMouseButtonEvent);
UiScope.PreviewMouseLeftButtonUp += new MouseButtonEventHandler(OnMouseButtonEvent);
UiScope.PreviewMouseRightButtonDown += new MouseButtonEventHandler(OnMouseButtonEvent);
UiScope.PreviewMouseRightButtonUp += new MouseButtonEventHandler(OnMouseButtonEvent);
UiScope.PreviewMouseMove += new MouseEventHandler(OnMouseEvent);
}
return NativeMethods.S_OK;
}
// existing mouse sink is unadviced.
public int UnadviceMouseSink(int dwCookie)
{
int ret = NativeMethods.E_INVALIDARG;
int i;
for (i = 0; i < _mouseSinks.Count; i++)
{
MouseSink mSink = (MouseSink)_mouseSinks[i];
if (mSink.Cookie == dwCookie)
{
_mouseSinks.RemoveAt(i);
if (_mouseSinks.Count == 0)
{
// If there is no registerd sink, stop listening mouse event for MSIME mouse operation.
UiScope.PreviewMouseLeftButtonDown -= new MouseButtonEventHandler(OnMouseButtonEvent);
UiScope.PreviewMouseLeftButtonUp -= new MouseButtonEventHandler(OnMouseButtonEvent);
UiScope.PreviewMouseRightButtonDown -= new MouseButtonEventHandler(OnMouseButtonEvent);
UiScope.PreviewMouseRightButtonUp -= new MouseButtonEventHandler(OnMouseButtonEvent);
UiScope.PreviewMouseMove -= new MouseEventHandler(OnMouseEvent);
}
// Dispose sink and range.
if (mSink.Locked)
{
mSink.PendingDispose = true;
}
else
{
mSink.Dispose();
}
ret = NativeMethods.S_OK;
break;
}
}
return ret;
}
#endregion ITfMouseTrackerACP
//------------------------------------------------------
//
// Internal Methods
//
//-----------------------------------------------------
#region Internal Methods
// Called by the TextEditor when the document should go live.
///
/// Critical - calls critical code (RegisterTextStore)
/// TreatAsSafe - adds this textstore to the list of textstores, a safe operation
///
[SecurityCritical, SecurityTreatAsSafe]
internal void OnAttach()
{
_netCharCount = this.TextContainer.IMECharCount;
// keep _textservicesHost because we may not be in Dispatcher when GC Finalizer calls OnDetach().
_textservicesHost = TextServicesHost.Current;
_textservicesHost.RegisterTextStore(this);
this.TextContainer.Change += new TextContainerChangeEventHandler(OnTextContainerChange);
_textservicesproperty = new TextServicesProperty(this);
}
// Called by the TextEditor when the document should shut down.
///
/// Critical - calls critical code (UnregisterTextStore)
/// TreatAsSafe - removes this textstore from the list of textstores, a safe operation
///
[SecurityCritical, SecurityTreatAsSafe]
internal void OnDetach(bool finalizer)
{
// TextEditor could be GCed before.
if (this.IsTextEditorValid)
{
this.TextContainer.Change -= new TextContainerChangeEventHandler(OnTextContainerChange);
}
// Relase the naitive resources. Unregister ThreadFocusSink and EditSink and release DocumentManager.
_textservicesHost.UnregisterTextStore(this, finalizer);
_textservicesproperty = null;
}
// Called when our TextEditor.TextContainer gets keyboard focus.
///
/// Critical: This code calls into SetFocus which is critical since it elevates
///
[SecurityCritical]
internal void OnGotFocus()
{
//
// We don't set focus to the DocumentManager if InputMethod is disabled in this element.
// InputMethod already called ThreadMgr.SetFocus(EmptyDIM) if IsInputMethodEnabledProperty is false.
if ((bool)UiScope.GetValue(InputMethod.IsInputMethodEnabledProperty))
{
// ThreadMgr Method call will be marshalled to the dispatcher thread since Ciecro is STA.
_textservicesHost.ThreadManager.SetFocus(DocumentManager);
}
if (_makeLayoutChangeOnGotFocus)
{
OnLayoutUpdated();
_makeLayoutChangeOnGotFocus = false;
}
}
// Called when losing keyboard focus.
// Finalizes the current composition.
internal void OnLostFocus()
{
CompleteComposition();
}
// Called when the layout of the rendered TextContainer changes.
// Called explicitly by the TextEditor.
///
/// Critical - calls unmanaged code
/// TreatAsSafe - notifies IME that the layout changed, this is a safe notification
///
[SecurityCritical, SecurityTreatAsSafe]
internal void OnLayoutUpdated()
{
if (_sink != null)
{
// Sink Method call will be marshalled to the dispatcher thread since Ciecro is STA.
_sink.OnLayoutChange(UnsafeNativeMethods.TsLayoutCode.TS_LC_CHANGE, _viewCookie);
}
if (_textservicesproperty != null)
{
_textservicesproperty.OnLayoutUpdated();
}
}
// Called as the selection changes.
// We can't modify document state here in any way.
internal void OnSelectionChange()
{
_compositionModifiedByApp = true;
}
// Called when the selection changes position.
// Called explicitly by the TextEditor.
///
/// Critical - calls unmanaged code (_sink)
/// TreatAsSafe - notifies of selection change, no potential data leak, this is safe
///
[SecurityCritical, SecurityTreatAsSafe]
internal void OnSelectionChanged()
{
if (_compositionEventState == CompositionEventState.RaisingEvents)
{
return;
}
if (_ignoreNextSelectionChange)
{
// If this change originated from a TIP, ignore it.
// Note if there's a reentrant 2nd selection change
// inside the current change block notification, we won't
// ignore the selection change event, which is what we want
// (and why we have to clear the flag right now).
_ignoreNextSelectionChange = false;
}
else if (_sink != null)
{
// Sink Method call will be marshalled to the dispatcher thread since Ciecro is STA.
_sink.OnSelectionChange();
}
}
// Query or do reconvert for the current selection.
///
/// Critical - calls unmanaged code
/// TreatAsSafe - all input comes from trusted sources (DocumentManager)
///
[SecurityCritical, SecurityTreatAsSafe]
internal bool QueryRangeOrReconvertSelection(bool fDoReconvert)
{
// If there is a composition that covers the current selection,
// we can return it is reconvertable.
// Some TIP may finalize and cancel the current candidate list (Bug 1291712).
if (_isComposing && !fDoReconvert)
{
ITextPointer compositionStart;
ITextPointer compositionEnd;
GetCompositionPositions(out compositionStart, out compositionEnd);
if ((compositionStart != null) &&
(compositionEnd != null))
{
if ((compositionStart.CompareTo(TextSelection.Start) <= 0) &&
(compositionStart.CompareTo(TextSelection.End) <= 0) &&
(compositionEnd.CompareTo(TextSelection.Start) >= 0) &&
(compositionEnd.CompareTo(TextSelection.End) >= 0))
{
return true;
}
}
}
bool fReconvertable = false;
UnsafeNativeMethods.ITfFnReconversion funcReconv;
UnsafeNativeMethods.ITfRange range;
fReconvertable = GetFnReconv(TextSelection.Start, TextSelection.End, out funcReconv, out range);
if (funcReconv != null)
{
if (fDoReconvert)
funcReconv.Reconvert(range);
Marshal.ReleaseComObject(funcReconv);
}
if (range != null)
{
Marshal.ReleaseComObject(range);
}
return fReconvertable;
}
// Query or do reconvert for the current selection.
///
/// Critical - calls unmanaged code and return critical ITfCandidateList
///
[SecurityCritical]
internal UnsafeNativeMethods.ITfCandidateList GetReconversionCandidateList()
{
bool fReconvertable = false;
UnsafeNativeMethods.ITfFnReconversion funcReconv;
UnsafeNativeMethods.ITfRange range;
UnsafeNativeMethods.ITfCandidateList candidateList = null;
fReconvertable = GetFnReconv(TextSelection.Start, TextSelection.End, out funcReconv, out range);
if (funcReconv != null)
{
funcReconv.GetReconversion(range, out candidateList);
Marshal.ReleaseComObject(funcReconv);
}
if (range != null)
{
Marshal.ReleaseComObject(range);
}
return candidateList;
}
// Query or do reconvert for the current selection.
///
/// Critical - calls unmanaged code and return ITfFnReconversion
///
[SecurityCritical]
private bool GetFnReconv(ITextPointer textStart, ITextPointer textEnd, out UnsafeNativeMethods.ITfFnReconversion funcReconv, out UnsafeNativeMethods.ITfRange rangeNew)
{
UnsafeNativeMethods.ITfContext context;
UnsafeNativeMethods.ITfRange range;
UnsafeNativeMethods.ITfRangeACP rangeACP;
bool fReconvertable = false;
funcReconv = null;
rangeNew = null;
// Create ITfRangeACP for the current selection.
// 1. Get the context from the document manager and call GetStart to get the instance of
// ITfRange.
// 2. QI the ITfRange to get ITfRangeACP.
// 3. Get start and end of the current selection from TextContainer.
// 4. Set extent of the ITfRangeACP.
DocumentManager.GetBase(out context);
context.GetStart(EditCookie, out range);
rangeACP = range as UnsafeNativeMethods.ITfRangeACP;
int start = textStart.CharOffset;
int end = textEnd.CharOffset;
rangeACP.SetExtent(start, end - start);
// Readonly fields can not be passed ref to the interface methods.
// Create pads for them.
Guid guidSysFunc = UnsafeNativeMethods.GUID_SYSTEM_FUNCTIONPROVIDER;
Guid guidNull = UnsafeNativeMethods.Guid_Null;
Guid iidFnReconv = UnsafeNativeMethods.IID_ITfFnReconversion;
UnsafeNativeMethods.ITfFunctionProvider functionPrv;
// ThreadMgr Method call will be marshalled to the dispatcher thread since Ciecro is STA.
_textservicesHost.ThreadManager.GetFunctionProvider(ref guidSysFunc, out functionPrv);
object obj;
// ITfFnReconversion is always available in SystemFunctionProvider.
functionPrv.GetFunction(ref guidNull, ref iidFnReconv, out obj);
funcReconv = obj as UnsafeNativeMethods.ITfFnReconversion;
funcReconv.QueryRange(range, out rangeNew, out fReconvertable);
// release objects.
Marshal.ReleaseComObject(functionPrv);
if (!fReconvertable)
{
Marshal.ReleaseComObject(funcReconv);
funcReconv = null;
}
Marshal.ReleaseComObject(range);
Marshal.ReleaseComObject(context);
return fReconvertable;
}
// Completes the current composition, if any, asynchronously.
internal void CompleteCompositionAsync()
{
Dispatcher.CurrentDispatcher.BeginInvoke(DispatcherPriority.Normal, new DispatcherOperationCallback(CompleteCompositionHandler), null);
}
// Completes the current composition, if any.
///
/// Critical:Calls CompleteCurrentComposition which has a link demand
/// TreatAsSafe: Exposes no data, calls trusted code.
///
[SecurityCritical, SecurityTreatAsSafe]
internal void CompleteComposition()
{
if (_isComposing)
{
FrameworkTextComposition.CompleteCurrentComposition(this.DocumentManager);
}
_previousCompositionStartOffset = -1;
_previousCompositionEndOffset = -1;
_previousCompositionStart = null;
_previousCompositionEnd = null;
}
// Creates an ITextPointer at a specific character offset.
internal ITextPointer CreatePointerAtCharOffset(int charOffset, LogicalDirection direction)
{
ValidateCharOffset(charOffset);
ITextPointer pointer = this.TextContainer.CreatePointerAtCharOffset(charOffset, direction);
if (pointer == null)
{
// A null pointer means that the ITextContainer has no character offsets.
// This happens in an empty TextBox, or in a mal-formed RichTextBox.
// In either case, use the selection start.
pointer = this.TextSelection.Start.CreatePointer(direction);
}
return pointer;
}
internal void MakeLayoutChangeOnGotFocus()
{
if (_isComposing)
{
_makeLayoutChangeOnGotFocus = true;
}
}
// Inserts composition text into the document.
// Raises public text, selection changed events.
// Called by default editor TextInputEvent handler.
internal void UpdateCompositionText(FrameworkTextComposition composition)
{
if (_compositionModifiedByApp)
{
// If the app has modified the document since this event was raised
// (by hooking a TextInput event), then we don't know what to do,
// so do nothing.
return;
}
_handledByTextStoreListener = true;
this.TextSelection.BeginChange();
try
{
ITextRange range;
string text;
if (composition._ResultStart != null)
{
range = new TextRange(composition._ResultStart, composition._ResultEnd, true /* ignoreTextUnitBoundaries */);
text = composition.Text;
}
else
{
range = new TextRange(composition._CompositionStart, composition._CompositionEnd, true /* ignoreTextUnitBoundaries */);
text = composition.CompositionText;
}
this.TextEditor.SetText(range, text, InputLanguageManager.Current.CurrentInputLanguage);
//
if (_interimSelection)
{
this.TextSelection.Select(range.Start, range.End);
}
else
{
this.TextSelection.SetCaretToPosition(range.End, LogicalDirection.Backward, /*allowStopAtLineEnd:*/true, /*allowStopNearSpace:*/true);
}
}
finally
{
// We're about to raise the public event.
// Set a flag so we can detect app changes.
_compositionModifiedByApp = false;
// PUBLIC EVENT:
this.TextSelection.EndChange();
}
}
///
/// Critical - calls SecurityCritical InputManager.Current and InputManager.UnsecureCurrent.
/// TreatAsSafe - It doesn't return critical information, all parameters are typesafe.
/// The location where the input manager is stored is critical and the usage is tracked.
///
[SecurityCritical, SecurityTreatAsSafe]
internal static FrameworkTextComposition CreateComposition(TextEditor editor, object owner)
{
FrameworkTextComposition composition;
// FrameworkRichTextComposition should be used for RichContent so TextRange is exposed for the application
// to track the composition range.
// FrameworkTextComposition should be used for non-RichContent and TextRange is not exposed.
if (editor.AcceptsRichContent)
{
composition = new FrameworkRichTextComposition(InputManager.UnsecureCurrent, editor.UiScope, owner);
}
else
{
composition = new FrameworkTextComposition(InputManager.Current, editor.UiScope, owner);
}
return composition;
}
#endregion Internal Methods
//------------------------------------------------------
//
// Internal Properties
//
//-----------------------------------------------------
#region Internal Properties
internal UIElement RenderScope
{
get
{
if (this.TextEditor == null)
return null;
if (this.TextEditor.TextView == null)
return null;
return this.TextEditor.TextView.RenderScope;
}
}
internal FrameworkElement UiScope
{
get { return this.TextEditor.UiScope; }
}
internal ITextContainer TextContainer
{
get { return this.TextEditor.TextContainer; }
}
internal ITextView TextView
{
get { return TextEditor.TextView; }
}
// The pointer to ITfDocumentMgr.
///
/// Critical: UnsafeNativeMethods.ITfDocumentMgr has methods with SuppressUnmanagedCodeSecurity.
///
internal UnsafeNativeMethods.ITfDocumentMgr DocumentManager
{
[SecurityCritical]
get
{
if (_documentmanager == null)
{
return null;
}
return _documentmanager.Value;
}
set { _documentmanager = new SecurityCriticalDataClass(value); }
}
// Cookie for ITfThreadFocusSink.
internal int ThreadFocusCookie
{
get { return _threadFocusCookie; }
set { _threadFocusCookie = value; }
}
// Cookie for ITfTextEditSink.
internal int EditSinkCookie
{
get { return _editSinkCookie; }
set { _editSinkCookie = value; }
}
// Cookie for ITfContext.
internal int EditCookie
{
get { return _editCookie; }
set { _editCookie = value; }
}
// True if the current selection is for interim character.
internal bool IsInterimSelection
{
get { return _interimSelection; }
}
// true if we're in the middle of an ongoing composition.
internal bool IsComposing
{
get { return _isComposing; }
}
internal int TransitoryExtensionSinkCookie
{
get { return _transitoryExtensionSinkCookie; }
set { _transitoryExtensionSinkCookie = value; }
}
///
/// Critical - get: It calls GetSourceWnd, which is Critical. Since it specifies/ that the caller is trusted, NO underlying demands will be performed.
///
internal IntPtr CriticalSourceWnd
{
[SecurityCritical]
get
{
bool callerIsTrusted = true;
return( GetSourceWnd(callerIsTrusted) );
}
}
#endregion Internal Properties
//-----------------------------------------------------
//
// Private Methods
//
//-----------------------------------------------------
#region Private Methods
// Tree change listener. We need to forward any tree change events
// to TSF. But we must never forward any events that occur while
// TSF holds a document lock.
///
/// Critical - calls unmanaged code
/// TreatAsSafe - notifies the IME of text change within range, only potential
/// attack here would be to get the IME to update more UI than
/// needed
///
[SecurityCritical, SecurityTreatAsSafe]
private void OnTextContainerChange(object sender, TextContainerChangeEventArgs args)
{
if (args.IMECharCount > 0 && (args.TextChange == TextChangeType.ContentAdded || args.TextChange == TextChangeType.ContentRemoved))
{
_compositionModifiedByApp = true;
}
if (_compositionEventState == CompositionEventState.RaisingEvents)
{
return;
}
Invariant.Assert(sender == this.TextContainer);
#if ENABLE_INK_EMBEDDING
// Record the offset of the first symbol in the document
// affected by this edit.
// Used by RemoveContent to track the effects of an edit.
if (args.TextChange == TextChangeType.ContentRemoved &&
_minSymbolsRemovedIndex > args.TextPosition.Offset)
{
_minSymbolsRemovedIndex = args.TextPosition.Offset;
}
#endif
// Don't send TSF events that it initiated (ie, while it holds a lock).
if (_lockFlags == 0 && _sink != null)
{
int charsAdded = 0;
int charsRemoved = 0;
if (args.TextChange == TextChangeType.ContentAdded)
{
charsAdded = args.IMECharCount;
}
else if (args.TextChange == TextChangeType.ContentRemoved)
{
charsRemoved = args.IMECharCount;
}
else
{
// This is a TextChange.ContentAffected change, which we
// don't want to pass on to cicero. Cicero doesn't care
// about DependencyProperty values, and we don't want it
// to invalidate cicero properties unless symbols were
// added or removed.
}
if (charsAdded > 0 || charsRemoved > 0)
{
UnsafeNativeMethods.TS_TEXTCHANGE change;
change.start = args.ITextPosition.CharOffset;
change.oldEnd = change.start + charsRemoved;
change.newEnd = change.start + charsAdded;
ValidateChange(change);
// We can't call VerifyTextStoreConsistency() yet because more changes may be pending.
//
try
{
_textChangeReentrencyCount++;
_sink.OnTextChange(0 /* flags */, ref change);
}
finally
{
_textChangeReentrencyCount--;
}
}
}
}
// DispatcherOperationCallback callback. Async lock requests are dequeued to
// this callback, which grants the pending lock.
private object GrantLockHandler(object o)
{
// _textservicesHost or _sink may have been released (set null) if cicero already shut down
// before we got this callback. In which case, there's no one
// to talk to.
if ((_textservicesHost != null) && (_sink != null))
{
GrantLockWorker(_pendingAsyncLockFlags);
}
_pendingAsyncLockFlags = 0;
return null;
}
// Makes an OnLockGranted callback to cicero.
private int GrantLockWorker(UnsafeNativeMethods.LockFlags flags)
{
int hrSession;
TextEditor textEditor = this.TextEditor;
if (textEditor == null)
{
// The app shutdown before we got an async callback.
hrSession = NativeMethods.E_FAIL;
}
else
{
_lockFlags = flags;
UndoManager undoManager = UndoManager.GetUndoManager(textEditor.TextContainer.Parent);
int initialUndoCount = 0;
// undoManager will be null for readonly documents like FlowDocumentReader.
//
if (undoManager != null)
{
initialUndoCount = undoManager.UndoCount;
undoManager.IsImeSupportModeEnabled = true;
}
// Reset the composition offsets. Sometimes an IME will
// allow the editor handle a keystroke during an active composition.
// See bug 118934. When this happens, we need to update the composition
// here. Where the IME holds a lock, no one else can modify
// the text, and int offsets allow us to use the undo stack internally.
_previousCompositionStartOffset = (_previousCompositionStart == null) ? -1 : _previousCompositionStart.Offset;
_previousCompositionEndOffset = (_previousCompositionEnd == null) ? -1 : _previousCompositionEnd.Offset;
try
{
textEditor.Selection.BeginChangeNoUndo();
try
{
hrSession = GrantLock();
if (_pendingWriteReq)
{
_lockFlags = UnsafeNativeMethods.LockFlags.TS_LF_READWRITE;
GrantLock();
}
}
finally
{
_pendingWriteReq = false;
_lockFlags = 0;
// Set a flag to ignore the first selection change event during
// this change block -- we must not report any changes made to
// the selection by the IME that just released the cicero lock.
_ignoreNextSelectionChange = textEditor.Selection._IsChanged;
try
{
// Skip the public events for the changing of the composition
// by Cicero, but the below HandleCompositionEvents will raise
// the public events about the composition and text change.
textEditor.Selection.EndChange(false /* disableScroll */, true /* skipEvents */);
}
finally
{
// Note we also clear the flag in our OnSelectionChanged listener,
// but we have to clear it here in case the change block we just
// closed wasn't the outermost change block.
_ignoreNextSelectionChange = false;
}
}
if (undoManager != null)
{
// Finally raise the recorded composition events publicly.
HandleCompositionEvents(initialUndoCount);
}
}
finally
{
if (undoManager != null)
{
undoManager.IsImeSupportModeEnabled = false;
}
_previousCompositionStart = (_previousCompositionStartOffset == -1) ? null : textEditor.TextContainer.CreatePointerAtOffset(_previousCompositionStartOffset, LogicalDirection.Backward);
_previousCompositionEnd = (_previousCompositionEndOffset == -1) ? null : textEditor.TextContainer.CreatePointerAtOffset(_previousCompositionEndOffset, LogicalDirection.Forward);
}
}
return hrSession;
}
// Grant cicero a lock, and do any house keeping around it.
// Note cicero won't get tree change events from within the scope of this method.
///
/// Critical - calls unmanaged code
/// TreatAsSafe - notifies the sink of a lock grant, no other data is transfered.
///
[SecurityCritical, SecurityTreatAsSafe]
private int GrantLock()
{
int hr;
// GrantLock should be called from only RequestLock. So it must be in the dispatcher thread.
Invariant.Assert(Thread.CurrentThread == _textservicesHost.Dispatcher.Thread, "GrantLock called on bad thread!");
VerifyTextStoreConsistency();
hr = _sink.OnLockGranted(_lockFlags);
VerifyTextStoreConsistency();
return hr;
}
// GetText handler for text runs.
private static bool WalkTextRun(ITextPointer navigator, ITextPointer limit, char[] text, int cchReq, ref int charsCopied, UnsafeNativeMethods.TS_RUNINFO[] runInfo, int cRunInfoReq, ref int cRunInfoRcv)
{
int runCount;
int offset;
bool hitLimit;
Invariant.Assert(navigator.GetPointerContext(LogicalDirection.Forward) == TextPointerContext.Text);
Invariant.Assert(limit == null || navigator.CompareTo(limit) <= 0);
hitLimit = false;
if (cchReq > 0)
{
runCount = TextPointerBase.GetTextWithLimit(navigator, LogicalDirection.Forward, text, charsCopied, Math.Min(cchReq, text.Length - charsCopied), limit);
navigator.MoveByOffset(runCount);
charsCopied += runCount;
hitLimit = (text.Length == charsCopied) || (limit != null && navigator.CompareTo(limit) == 0);
}
else
{
// Caller doesn't want text, just run info.
// Advance the navigator.
runCount = navigator.GetTextRunLength(LogicalDirection.Forward);
navigator.MoveToNextContextPosition(LogicalDirection.Forward);
// If the caller passed in a non-null limit, backup to the limit if
// we've passed it.
if (limit != null)
{
if (navigator.CompareTo(limit) >= 0)
{
offset = limit.GetOffsetToPosition(navigator);
Invariant.Assert(offset >= 0 && offset <= runCount, "Bogus offset -- extends past run!");
runCount -= offset;
navigator.MoveToPosition(limit);
hitLimit = true;
}
}
}
if (cRunInfoReq > 0 && runCount > 0)
{
// Be sure to merge this text run with the previous run, if they are both text runs.
// (A good robustness fix would be to make cicero handle this, if we ever get the chance.)
if (cRunInfoRcv > 0 && runInfo[cRunInfoRcv - 1].type == UnsafeNativeMethods.TsRunType.TS_RT_PLAIN)
{
runInfo[cRunInfoRcv - 1].count += runCount;
}
else
{
runInfo[cRunInfoRcv].count = runCount;
runInfo[cRunInfoRcv].type = UnsafeNativeMethods.TsRunType.TS_RT_PLAIN;
cRunInfoRcv++;
}
}
return hitLimit;
}
// GetText handler for object runs.
private static bool WalkObjectRun(ITextPointer navigator, ITextPointer limit, char[] text, int cchReq, ref int charsCopied, UnsafeNativeMethods.TS_RUNINFO[] runInfo, int cRunInfoReq, ref int cRunInfoRcv)
{
bool hitLimit;
Invariant.Assert(navigator.GetPointerContext(LogicalDirection.Forward) == TextPointerContext.EmbeddedElement);
Invariant.Assert(limit == null || navigator.CompareTo(limit) <= 0);
if (limit != null && navigator.CompareTo(limit) == 0)
{
return true;
}
hitLimit = false;
navigator.MoveToNextContextPosition(LogicalDirection.Forward);
if (cchReq >= 1)
{
text[charsCopied] = UnsafeNativeMethods.TS_CHAR_EMBEDDED;
charsCopied++;
}
if (cRunInfoReq > 0)
{
// Be sure to merge this text run with the previous run, if they are both text runs.
// (A good robustness fix would be to make cicero handle this, if we ever get the chance.)
if (cRunInfoRcv > 0 && runInfo[cRunInfoRcv - 1].type == UnsafeNativeMethods.TsRunType.TS_RT_PLAIN)
{
runInfo[cRunInfoRcv - 1].count++;
}
else
{
runInfo[cRunInfoRcv].count = 1;
runInfo[cRunInfoRcv].type = UnsafeNativeMethods.TsRunType.TS_RT_PLAIN;
cRunInfoRcv++;
}
}
return hitLimit;
}
// GetText handler for Blocks and TableCell to add '\n' or TS_CHAR_REGION.
private static bool WalkRegionBoundary(ITextPointer navigator, ITextPointer limit, char[] text, int cchReq, ref int charsCopied, UnsafeNativeMethods.TS_RUNINFO[] runInfo, int cRunInfoReq, ref int cRunInfoRcv)
{
bool hitLimit;
Invariant.Assert(navigator.GetPointerContext(LogicalDirection.Forward) == TextPointerContext.ElementStart || navigator.GetPointerContext(LogicalDirection.Forward) == TextPointerContext.ElementEnd);
Invariant.Assert(limit == null || navigator.CompareTo(limit) <= 0);
// If the caller passed in a non-null limit, we don't do anything and just return true.
// we've passed it.
if (limit != null)
{
if (navigator.CompareTo(limit) >= 0)
{
return true;
}
}
hitLimit = false;
if (cchReq > 0)
{
// Add one TS_CHAR_REGION (TableCell) or '\n' (everything else) char.
char ch = (navigator.GetAdjacentElement(LogicalDirection.Forward) is TableCell) ? UnsafeNativeMethods.TS_CHAR_REGION : '\n';
text[charsCopied] = ch;
navigator.MoveByOffset(1);
charsCopied += 1;
hitLimit = (text.Length == charsCopied) || (limit != null && navigator.CompareTo(limit) == 0);
}
else
{
// Caller doesn't want text, just run info.
// Advance the navigator.
// Add one TS_CHAR_REGION char.
navigator.MoveByOffset(1);
}
if (cRunInfoReq > 0)
{
// Be sure to merge this text run with the previous run, if they are both text runs.
// (A good robustness fix would be to make cicero handle this, if we ever get the chance.)
if (cRunInfoRcv > 0 && runInfo[cRunInfoRcv - 1].type == UnsafeNativeMethods.TsRunType.TS_RT_PLAIN)
{
runInfo[cRunInfoRcv - 1].count += 1;
}
else
{
runInfo[cRunInfoRcv].count = 1;
runInfo[cRunInfoRcv].type = UnsafeNativeMethods.TsRunType.TS_RT_PLAIN;
cRunInfoRcv++;
}
}
return hitLimit;
}
// Returns objects useful for talking to the underlying HWND.
// Throws TS_E_NOLAYOUT if they are not available.
///
/// Critical: This code calls into PresentationSource.FromVisual to retrieve Source
/// The source is also handed out to the callers
///
[SecurityCritical]
private void GetVisualInfo(out PresentationSource source, out IWin32Window win32Window, out ITextView view)
{
source = PresentationSource.CriticalFromVisual(RenderScope);
win32Window = source as IWin32Window;
if (win32Window == null)
{
throw new COMException(SR.Get(SRID.TextStore_TS_E_NOLAYOUT), UnsafeNativeMethods.TS_E_NOLAYOUT);
}
view = this.TextView;
}
// Transforms mil measure unit points to screen pixels.
///
/// Critical - calls UnsafeNativeMethods.ClientToScreen and asserts to get HWND
/// TreatAsSafe - safe to expose screen coordinates
///
[SecurityCritical, SecurityTreatAsSafe]
private static UnsafeNativeMethods.RECT TransformRootRectToScreenCoordinates(Point milPointTopLeft, Point milPointBottomRight, IWin32Window win32Window, PresentationSource source)
{
UnsafeNativeMethods.RECT rect;
NativeMethods.POINT clientPoint;
CompositionTarget compositionTarget;
rect = new UnsafeNativeMethods.RECT();
// Transform to device units.
compositionTarget = source.CompositionTarget;
milPointTopLeft = compositionTarget.TransformToDevice.Transform(milPointTopLeft);
milPointBottomRight = compositionTarget.TransformToDevice.Transform(milPointBottomRight);
IntPtr hwnd = IntPtr.Zero;
new UIPermission(UIPermissionWindow.AllWindows).Assert(); // BlessedAssert
try
{
hwnd = win32Window.Handle;
}
finally
{
CodeAccessPermission.RevertAssert();
}
// Transform to screen coords.
clientPoint = new NativeMethods.POINT();
UnsafeNativeMethods.ClientToScreen(new HandleRef(null, hwnd), /* ref by interop */ clientPoint);
rect.left = (int)(clientPoint.x + milPointTopLeft.X);
rect.right = (int)(clientPoint.x + milPointBottomRight.X);
rect.top = (int)(clientPoint.y + milPointTopLeft.Y);
rect.bottom = (int)(clientPoint.y + milPointBottomRight.Y);
return rect;
}
#if ENABLE_INK_EMBEDDING
// Insert InkInteropObject at the position.
///
/// Critical - calls unmanaged code to access the OLE data object
/// TreatAsSafe - has demand for unmanaged code
///
[SecurityCritical, SecurityTreatAsSafe]
private void InsertEmbeddedAtPosition(TextPointer position, IComDataObject data, out UnsafeNativeMethods.TS_TEXTCHANGE change)
{
SecurityHelper.DemandUnmanagedCode();
ITextContainer container;
// Get enhanced metafile handle from IOleDataObject.
FORMATETC formatetc = new FORMATETC();
STGMEDIUM stgmedium = new STGMEDIUM();
formatetc.cfFormat = NativeMethods.CF_ENHMETAFILE;
formatetc.ptd = IntPtr.Zero;
formatetc.dwAspect = DVASPECT.DVASPECT_CONTENT;
formatetc.lindex = -1;
formatetc.tymed = TYMED.TYMED_ENHMF;
stgmedium.tymed = TYMED.TYMED_ENHMF;
data.GetData(ref formatetc, out stgmedium);
if (stgmedium.unionmember == IntPtr.Zero)
{
throw new COMException(SR.Get(SRID.TextStore_BadObjectData), NativeMethods.E_INVALIDARG);
}
// Convert metafile to bitmap. BitmapImage does not support the metafile.
System.Drawing.Imaging.Metafile metafile = new System.Drawing.Imaging.Metafile(stgmedium.unionmember, false);
// Initialize the bitmap size to render the metafile.
int bitmapheight = metafile.Size.Height;
int bitmapwidth = metafile.Size.Width;
// We use System.Drawing to render metafile into the bitmap.
System.Drawing.Bitmap bmp = new System.Drawing.Bitmap(bitmapwidth, bitmapheight);
System.Drawing.Graphics graphics = System.Drawing.Graphics.FromImage(bmp);
// graphics.FillRectangle(new System.Drawing.SolidBrush(System.Drawing.Color.White), 0, 0, bitmapwidth, bitmapheight);
graphics.DrawImage(metafile, 0, 0, bitmapwidth, bitmapheight);
// create a InkInteropObject framework element.
InkInteropObject inkobject = new InkInteropObject(data);
inkobject.Source = Imaging.CreateBitmapSourceFromHBitmap(bmp.GetHbitmap(), IntPtr.Zero, Int32Rect.Empty, null);
position = InsertInkAtPosition(position, inkobject, out change);
// Move the selection.
container = this.TextContainer;
TextSelection.SetCaretToPosition(position, LogicalDirection.Backward, /*allowStopAtLineEnd:*/false, /*allowStopNearSpace:*/false);
}
// Inserts an InkInteropObject at a specified position.
private TextPointer InsertInkAtPosition(TextPointer insertionPosition, InkInteropObject inkobject, out UnsafeNativeMethods.TS_TEXTCHANGE change)
{
int symbolsAddedBefore = 0;
int symbolsAddedAfter = 0;
// Prepare an insertion position for InlineUIContainer.
// As an optimization, shift outside of any formatting tags to avoid
// splitting tags below.
while (insertionPosition.GetPointerContext(LogicalDirection.Backward) == TextPointerContext.ElementStart &&
TextSchema.IsFormattingType(insertionPosition.Parent.GetType()))
{
insertionPosition = insertionPosition.GetNextContextPosition(LogicalDirection.Backward);
}
while (insertionPosition.GetPointerContext(LogicalDirection.Forward) == TextPointerContext.ElementEnd &&
TextSchema.IsFormattingType(insertionPosition.Parent.GetType()))
{
insertionPosition = insertionPosition.GetNextContextPosition(LogicalDirection.Forward);
}
// If we need to, split the current parent TextElement and prepare
// a suitable home for an InlineUIContainer.
if (!TextSchema.IsValidParent(insertionPosition.Parent.GetType(), typeof(InlineUIContainer)))
{
insertionPosition = TextRangeEditTables.EnsureInsertionPosition(insertionPosition, out symbolsAddedBefore, out symbolsAddedAfter);
Invariant.Assert(insertionPosition.Parent is Run, "position must be in Run scope");
insertionPosition = TextRangeEdit.SplitElement(insertionPosition);
// We need to remember how many symbols were added into addition
// to the InlineUIContainer itself.
// Account for the two element edges just added.
symbolsAddedBefore += 1;
symbolsAddedAfter += 1;
}
// Create an InlineUIContainer.
InlineUIContainer inlineUIContainer = new InlineUIContainer(inkobject);
change.start = ((ITextPointer)insertionPosition).Offset - symbolsAddedBefore;
change.oldEnd = change.start;
// Insert it into the insertionPosition. This adds 3 symbols.
insertionPosition.InsertTextElement(inlineUIContainer);
change.newEnd = change.start + symbolsAddedBefore + inlineUIContainer.SymbolCount + symbolsAddedAfter;
// Return a position after the inserted object.
return inlineUIContainer.ElementEnd.GetInsertionPosition(LogicalDirection.Forward);
}
#endif // ENABLE_INK_EMBEDDING
// determine a family name from a FontFamily and XmlLanguage
private static string GetFontFamilyName(FontFamily fontFamily, XmlLanguage language)
{
if (fontFamily == null)
return null;
// If the font family was constructed from a font name or URI, return that value.
if (fontFamily.Source != null)
return fontFamily.Source;
// Use the dictionary of names provided by the font.
LanguageSpecificStringDictionary names = fontFamily.FamilyNames;
if (names == null)
return null;
// try every matching language to most-specific to least specific, including ""
foreach (XmlLanguage matchingLanguage in language.MatchingLanguages)
{
string name = names[matchingLanguage];
if (name != null)
return name;
}
// give up!
return null;
}
// Prepare the app property values and store them into _preparedatribute.
///
/// Critical - accesses presentationsource query visual information
/// TreatAsSafe - only exposes transformation information, which is safe
///
[SecurityCritical, SecurityTreatAsSafe]
private void PrepareAttributes(InputScope inputScope, double fontSize, FontFamily fontFamily, XmlLanguage language, Visual visual, int count, Guid[] filterAttributes)
{
if (_preparedattributes == null)
{
_preparedattributes = new ArrayList(count);
}
else
{
_preparedattributes.Clear();
}
int i;
for (i = 0; i < _supportingattributes.Length; i++)
{
if (count != 0)
{
int j;
bool found = false;
for (j = 0; j < count; j++)
{
if (_supportingattributes[i].Guid.Equals(filterAttributes[j]))
found = true;
}
if (!found)
continue;
}
UnsafeNativeMethods.TS_ATTRVAL attrval = new UnsafeNativeMethods.TS_ATTRVAL();
attrval.attributeId = _supportingattributes[i].Guid;
attrval.overlappedId = (int)_supportingattributes[i].Style;
attrval.val = new NativeMethods.VARIANT();
// This VARIANT is returned to the caller, which supposed to call VariantClear().
// GC does not have to clear it.
attrval.val.SuppressFinalize();
switch (_supportingattributes[i].Style)
{
case AttributeStyle.InputScope:
object obj = new InputScopeAttribute(inputScope);
attrval.val.vt = (short)NativeMethods.tagVT.VT_UNKNOWN;
attrval.val.data1.Value = Marshal.GetIUnknownForObject(obj);
break;
case AttributeStyle.Font_Style_Height:
// We always evaluate the font size and returns a value.
attrval.val.vt = (short)NativeMethods.tagVT.VT_I4;
attrval.val.data1.Value = (IntPtr)(int)fontSize;
break;
case AttributeStyle.Font_FaceName:
{
string familyName = GetFontFamilyName(fontFamily, language);
if (familyName != null)
{
attrval.val.vt = (short)NativeMethods.tagVT.VT_BSTR;
attrval.val.data1.Value = Marshal.StringToBSTR(familyName);
}
}
break;
case AttributeStyle.Font_SizePts:
attrval.val.vt = (short)NativeMethods.tagVT.VT_I4;
attrval.val.data1.Value = (IntPtr)(int)(fontSize / 96.0 * 72.0);
break;
case AttributeStyle.Text_ReadOnly:
attrval.val.vt = (short)NativeMethods.tagVT.VT_BOOL;
attrval.val.data1.Value = IsReadOnly ? (IntPtr)1 : (IntPtr)0;
break;
case AttributeStyle.Text_Orientation:
attrval.val.vt = (short)NativeMethods.tagVT.VT_I4;
attrval.val.data1.Value = (IntPtr)0;
// Get the transformation that is relative from source.
PresentationSource source = null;
source = PresentationSource.CriticalFromVisual((Visual)RenderScope);
if (source != null)
{
Visual root = source.RootVisual;
if ((root != null) && (visual != null))
{
//
// Calc radian from Matirix. This is approximate calculation from the first row.
// If tf.M12 is 0, angle will be 0. So we don't have to calc it.
//
GeneralTransform transform = visual.TransformToAncestor(root);
Transform t = transform.AffineTransform;
//
if (t != null)
{
Matrix tf = t.Value;
if ((tf.M11 != 0) || (tf.M12 != 0))
{
double radSin = Math.Asin(tf.M12 / Math.Sqrt((tf.M11 * tf.M11) + (tf.M12 * tf.M12)));
double radCos = Math.Acos(tf.M11 / Math.Sqrt((tf.M11 * tf.M11) + (tf.M12 * tf.M12)));
// double angleSin = Math.Round((radSin * 180) / Math.PI, 0);
double angleCos = Math.Round((radCos * 180) / Math.PI, 0);
double angle;
// determine angle from the sign of radSin;
if (radSin <= 0)
angle = angleCos;
else
angle = 360 - angleCos;
attrval.val.data1.Value = (IntPtr)((int)angle * 10);
}
}
}
}
break;
case AttributeStyle.Text_VerticalWriting:
//
//
attrval.val.vt = (short)NativeMethods.tagVT.VT_BOOL;
attrval.val.data1.Value = (IntPtr)0;
break;
}
_preparedattributes.Add(attrval);
}
}
// retrieve the TextPositions from ITfRange.
///
/// Critical - calls unmanaged code
///
[SecurityCritical]
private void TextPositionsFromITfRange(UnsafeNativeMethods.ITfRange range, out ITextPointer start, out ITextPointer end)
{
UnsafeNativeMethods.ITfRangeACP rangeACP;
int startIndex;
int length;
rangeACP = range as UnsafeNativeMethods.ITfRangeACP;
rangeACP.GetExtent(out startIndex, out length);
start = CreatePointerAtCharOffset(startIndex, LogicalDirection.Backward);
end = CreatePointerAtCharOffset(startIndex + length, LogicalDirection.Forward);
while (start.CompareTo(end) < 0 && start.GetPointerContext(LogicalDirection.Forward) != TextPointerContext.Text)
{
start.MoveToNextContextPosition(LogicalDirection.Forward);
}
}
// Returns the start and end positions of the current composition, or
// null if there is no current composition.
///
/// Critical - calls critical methods.
/// TreatAsSafe - takes no input and reveals no sensitive information.
///
[SecurityCritical, SecurityTreatAsSafe]
private void GetCompositionPositions(out ITextPointer start, out ITextPointer end)
{
start = null;
end = null;
if (_isComposing)
{
UnsafeNativeMethods.ITfCompositionView view = FrameworkTextComposition.GetCurrentCompositionView(this.DocumentManager);
if (view != null)
{
GetCompositionPositions(view, out start, out end);
}
}
}
///
/// Critical - calls unmanaged code
///
[SecurityCritical]
private void GetCompositionPositions(UnsafeNativeMethods.ITfCompositionView view, out ITextPointer start, out ITextPointer end)
{
UnsafeNativeMethods.ITfRange range;
view.GetRange(out range);
TextPositionsFromITfRange(range, out start, out end);
Marshal.ReleaseComObject(range);
Marshal.ReleaseComObject(view);
}
// get the text from ITfRange.
///
/// Critical - calls unmanaged code (GetExtent)
///
[SecurityCritical]
private static string StringFromITfRange(UnsafeNativeMethods.ITfRange range, int ecReadOnly)
{
// Transitory Document uses ther TextStore, which is ACP base.
UnsafeNativeMethods.ITfRangeACP rangeacp = (UnsafeNativeMethods.ITfRangeACP)range;
int start;
int count;
int countRet;
rangeacp.GetExtent(out start, out count);
char[] text = new char[count];
rangeacp.GetText(ecReadOnly, 0, text, count, out countRet);
return new string(text);
}
//
// Mouse Button state was changed.
//
private void OnMouseButtonEvent(object sender, MouseButtonEventArgs e)
{
e.Handled = InternalMouseEventHandler();
}
//
// Mouse was moved.
//
private void OnMouseEvent(object sender, MouseEventArgs e)
{
e.Handled = InternalMouseEventHandler();
}
//
// The mouse event handler to generate MSIME message to IME listeners.
//
///
/// Critical - calls unmanaged code (IME listener) and simulates a mouse event
/// TreatAsSafe - only sends mouse event to IME listeners, only uses current state of
/// text as input. Can't use this to spoof messages to non-IME contexts.
///
[SecurityCritical, SecurityTreatAsSafe]
private bool InternalMouseEventHandler()
{
int btnState = 0;
if (Mouse.LeftButton == MouseButtonState.Pressed)
{
btnState |= NativeMethods.MK_LBUTTON;
}
if (Mouse.RightButton == MouseButtonState.Pressed)
{
btnState |= NativeMethods.MK_RBUTTON;
}
if ((Keyboard.Modifiers & ModifierKeys.Shift) != 0)
{
btnState |= NativeMethods.MK_SHIFT;
}
if ((Keyboard.Modifiers & ModifierKeys.Control) != 0)
{
btnState |= NativeMethods.MK_CONTROL;
}
Point point = Mouse.GetPosition(RenderScope);
ITextView view;
ITextPointer positionCurrent;
ITextPointer positionNext;
Rect rectCurrent;
Rect rectNext;
view = TextView;
// Check if view is available.
if (view == null)
{
return false;
}
// Validate layout information on TextView
if (!view.Validate(point))
{
return false;
}
// Do the hittest.
positionCurrent = view.GetTextPositionFromPoint(point, false);
if (positionCurrent == null)
{
return false;
}
rectCurrent = view.GetRectangleFromTextPosition(positionCurrent);
positionNext = positionCurrent.CreatePointer();
if (positionNext == null)
{
return false;
}
if (point.X - rectCurrent.Left >= 0)
{
positionNext.MoveToNextInsertionPosition(LogicalDirection.Forward);
}
else
{
positionNext.MoveToNextInsertionPosition(LogicalDirection.Backward);
}
rectNext = view.GetRectangleFromTextPosition(positionNext);
int edge;
int quadrant;
edge = positionCurrent.CharOffset;
if (point.X - rectCurrent.Left >= 0)
{
if ((((point.X - rectCurrent.Left) * 4) / (rectNext.Left - rectCurrent.Left)) <= 1)
quadrant = 2;
else
quadrant = 3;
}
else
{
if (((point.X - rectNext.Left) * 4) / (rectCurrent.Left - rectNext.Left) <= 3)
quadrant = 0;
else
quadrant = 1;
}
int i;
bool eaten = false;
for (i = 0; (i < _mouseSinks.Count) && (eaten == false); i++)
{
MouseSink mSink = (MouseSink)_mouseSinks[i];
//
// TIPs care about only the range.
// If the quadrant is outside of the range, we don't do SendMessage.
//
int start;
int count;
mSink.Range.GetExtent(out start, out count);
if (edge < start)
continue;
if (edge > start + count)
continue;
if ((edge == start) && (quadrant <= 1))
continue;
if ((edge == start + count) && (quadrant >= 2))
continue;
mSink.Locked = true;
try
{
mSink.Sink.OnMouseEvent(edge - start, quadrant, btnState, out eaten);
}
finally
{
mSink.Locked = false;
}
}
return eaten;
}
// Opens the composition undo unit if it exists on the top
// of the stack. Otherwise, create a new composition undo unit
// and add it to the undo stack.
private CompositionParentUndoUnit OpenCompositionUndoUnit()
{
UndoManager undoManager = UndoManager.GetUndoManager(this.TextContainer.Parent);
if (undoManager == null || !undoManager.IsEnabled)
{
return null;
}
// The start position is where we'll put the caret if this composition is later
// undone by a user.
//
// At this point some IMEs will not have updated the selection to a
// position within the composition, suggesting that we always want to
// use selection start. However, some IMEs will expand the composition backward on input
// so the composition covers unmodified text. (E.g.: chinese prc pinyin IME
// will expand to cover previously finalized text on input.)
//
// So we use a hueristic: take the rightmost of the selection start or composition
// start.
ITextPointer start;
ITextPointer compositionStart;
ITextPointer compositionEnd;
GetCompositionPositions(out compositionStart, out compositionEnd);
if (compositionStart != null && compositionStart.CompareTo(this.TextSelection.Start) > 0)
{
start = compositionStart;
}
else
{
start = this.TextSelection.Start;
}
CompositionParentUndoUnit unit = new CompositionParentUndoUnit(this.TextSelection, start, start, _nextUndoUnitIsFirstCompositionUnit);
_nextUndoUnitIsFirstCompositionUnit = false;
// Add the given composition undo unit to the undo manager and making it
// as the opened undo unit.
undoManager.Open(unit);
return unit;
}
///
/// Computes the bounds for a given text segment, provided that the entire segment
/// is located on a single text line.
///
private static Rect GetLineBounds(ITextPointer start, ITextPointer end)
{
// Get the line range.
if (!start.HasValidLayout || !end.HasValidLayout)
{
return Rect.Empty;
}
// Get the left and the width of the range bounds.
Rect lineBounds = start.GetCharacterRect(LogicalDirection.Forward);
lineBounds.Union(end.GetCharacterRect(LogicalDirection.Backward));
// Scan the line range and compute the top and the height of the bounding rectangle.
ITextPointer navigator = start.CreatePointer(LogicalDirection.Forward);
while (navigator.MoveToNextContextPosition(LogicalDirection.Forward) == true && navigator.CompareTo(end) < 0)
{
TextPointerContext context = navigator.GetPointerContext(LogicalDirection.Backward);
switch (context)
{
case TextPointerContext.ElementStart:
lineBounds.Union(navigator.GetCharacterRect(LogicalDirection.Backward));
navigator.MoveToElementEdge(ElementEdge.AfterEnd);
break;
case TextPointerContext.ElementEnd:
case TextPointerContext.EmbeddedElement:
lineBounds.Union(navigator.GetCharacterRect(LogicalDirection.Backward));
break;
case TextPointerContext.Text:
break;
default:
// Unexpected
Invariant.Assert(context != TextPointerContext.None);
break;
}
}
return lineBounds;
}
#if ENABLE_INK_EMBEDDING
// Inserts an embedded object into the document, replacing a range of text.
private void InsertEmbeddedAtRange(TextPointer startPosition, TextPointer endPosition, IComDataObject data, out UnsafeNativeMethods.TS_TEXTCHANGE change)
{
int symbolsRemoved;
int removeStartIndex;
int startIndex;
// Remove the existing range content.
// See the comments on RemoveContent for an explanation of the
// out params.
startIndex = startPosition.Offset;
RemoveContent(startPosition, endPosition, out symbolsRemoved, out removeStartIndex);
Invariant.Assert(startIndex >= removeStartIndex);
// Remember where we're actually going to do the insert.
startIndex = startPosition.Offset;
Invariant.Assert(startIndex >= removeStartIndex);
// Do the insert.
// The TS_TEXTCHANGE reflects on the insert, we have to update it
// for any content we may have removed above.
InsertEmbeddedAtPosition(startPosition, data, out change);
// Update change for the remove content step above.
change.start = removeStartIndex;
change.oldEnd += symbolsRemoved;
}
// Deletes a specified run of content.
//
// On exit,
// symbolsRemoved <== count of symbols actually removed.
// removeStartIndex <== offset of first symbol affected by the edit.
//
// removeStartIndex is always <= endPosition.Offset, but it does not necessarily
// match the position of the logically removed content. In some rare cases
// a scoping element may be removed, meaning we have two or more runs of
// removed content, and removeStartIndex + symbolsRemoved < the offset of
// the last position affected by the operation.
private void RemoveContent(ITextPointer startPosition, ITextPointer endPosition, out int symbolsRemoved, out int removeStartIndex)
{
symbolsRemoved = 0;
removeStartIndex = startPosition.Offset;
if (startPosition.CompareTo(endPosition) == 0)
return;
TextContainer container = (TextContainer)startPosition.TextContainer;
symbolsRemoved = container.SymbolCount;
if (startPosition is TextPointer)
{
_minSymbolsRemovedIndex = Int32.MaxValue;
}
startPosition.DeleteContentToPosition(endPosition);
if (startPosition is TextPointer)
{
removeStartIndex = _minSymbolsRemovedIndex;
}
symbolsRemoved = symbolsRemoved - container.SymbolCount;
}
#endif // ENABLE_INK_EMBEDDING
// Filter the composition string.
private string FilterCompositionString(string text, int charsToReplaceCount)
{
string newText = this.TextEditor._FilterText(text, charsToReplaceCount);
// if the length has been changed, there is no way to recover and we finalize the composition string.
if (newText.Length != text.Length)
{
CompleteCompositionAsync();
return null;
}
return newText;
}
// Handler to complete the composition string.
private object CompleteCompositionHandler(object o)
{
CompleteComposition();
return null;
}
///
/// Critical - if called from a trusted method (callerIsTrusted == true), calls CriticalFromVisual, which is Critical,
/// and then returns the information returned by that call.
///
[SecurityCritical]
private IntPtr GetSourceWnd(bool callerIsTrusted)
{
IntPtr hwnd = IntPtr.Zero;
if (RenderScope != null)
{
IWin32Window win32Window;
if (callerIsTrusted)
{
win32Window = PresentationSource.CriticalFromVisual(RenderScope) as IWin32Window;
}
else
{
win32Window = PresentationSource.FromVisual(RenderScope) as IWin32Window;
}
if (win32Window != null)
{
(new UIPermission(UIPermissionWindow.AllWindows)).Assert();//BlessedAssert
try
{
hwnd = win32Window.Handle;
}
finally
{
UIPermission.RevertAssert();
}
}
}
return hwnd;
}
// Detects errors in the change notifications we send TSF.
private void ValidateChange(UnsafeNativeMethods.TS_TEXTCHANGE change)
{
Invariant.Assert(change.start >= 0, "Bad StartIndex");
Invariant.Assert(change.start <= change.oldEnd, "Bad oldEnd index");
Invariant.Assert(change.start <= change.newEnd, "Bad newEnd index");
_netCharCount += (change.newEnd - change.oldEnd);
Invariant.Assert(_netCharCount >= 0, "Negative _netCharCount!");
}
// Asserts that this TextStore is sending TS_TEXTCHANGE structs
// in sync with the actual TextContainer.
private void VerifyTextStoreConsistency()
{
if (_netCharCount != this.TextContainer.IMECharCount)
{
Invariant.Assert(false, "TextContainer/TextStore have inconsistent char counts!");
}
}
// Validates the character offset supplied by cicero.
// See bug 1395082. Sometimes cicero gives us offsets that are
// too large for the document.
private void ValidateCharOffset(int offset)
{
if (offset < 0 || offset > this.TextContainer.IMECharCount)
{
throw new ArgumentException(SR.Get(SRID.TextStore_BadIMECharOffset, offset, this.TextContainer.IMECharCount));
}
}
/// Discards previous composition undo unit, to prevent
/// from merging it with the subsequent typing.
private void BreakTypingSequence(ITextPointer caretPosition)
{
CompositionParentUndoUnit unit = PeekCompositionParentUndoUnit();
if (unit != null)
{
// We also put the caret at the end of the composition after
// redoing a composition undo. So update the end position now.
unit.RecordRedoSelectionState(caretPosition, caretPosition);
}
}
// Repositions an ITextRange to comply with limitations on IME input.
// We cannot modify Table structure, or insert content
// before or after Tables or BlockUIContainers while maintaing our
// contract with the cicero interfaces (without major refactoring of
// our code).
private static void GetAdjustedSelection(ITextPointer startIn, ITextPointer endIn, out ITextPointer startOut, out ITextPointer endOut)
{
startOut = startIn;
endOut = endIn;
TextPointer start = startOut as TextPointer;
// Tables and BlockUIContainers only exist in TextContainers, if
// we're in some other kind of document no adjustments are needed.
if (start == null)
{
return;
}
TextPointer end = (TextPointer)endOut;
if (startIn.CompareTo(endIn) != 0)
{
bool scopingBlockUIContainer = TextPointerBase.IsInBlockUIContainer(start) || TextPointerBase.IsInBlockUIContainer(end);
TableCell startCell = TextRangeEditTables.GetTableCellFromPosition(start);
TableCell endCell = TextRangeEditTables.GetTableCellFromPosition(end);
bool singleScopingTableCell = (startCell != null && startCell == endCell);
bool scopingTable = TextRangeEditTables.GetTableFromPosition(start) != null || TextRangeEditTables.GetTableFromPosition(end) != null;
// With a non-empty selection, if neither end of the selection is inside a Table or BlockUIContainer,
// there's nothing to adjust.
if (!scopingBlockUIContainer &&
(singleScopingTableCell || !scopingTable))
{
return;
}
}
// From this point forward, we know selection will collapse to
// a single insertion point, so we ignore end.
if (start.IsAtRowEnd)
{
TextPointer previousPosition = start.GetNextInsertionPosition(LogicalDirection.Backward);
Table currentTable = TextRangeEditTables.GetTableFromPosition(start);
start = TextRangeEditTables.GetAdjustedRowEndPosition(currentTable, start);
if (!start.IsAtInsertionPosition)
{
// The document ends with a Table, and position is just past that.
// Back up to the previous TableCell proceding.
start = previousPosition;
}
}
else if (TextPointerBase.IsInBlockUIContainer(start))
{
if (start.GetPointerContext(LogicalDirection.Backward) == TextPointerContext.ElementStart)
{
start = start.GetNextInsertionPosition(LogicalDirection.Backward);
}
else
{
start = start.GetNextInsertionPosition(LogicalDirection.Forward);
}
}
while (start != null && TextPointerBase.IsBeforeFirstTable(start))
{
// Note that the symmetrical case, AfterLastTable, is handled by
// the IsAtRowEnd test above.
start = start.GetNextInsertionPosition(LogicalDirection.Forward);
}
// If we have non-canonical format, give up.
if (start == null || start.IsAtRowEnd || TextPointerBase.IsInBlockUIContainer(start))
{
throw new COMException(SR.Get(SRID.TextStore_CompositionRejected), NativeMethods.E_FAIL);
}
startOut = start;
endOut = start;
}
// Normalizes a range:
//
// -The start position is advanced over all element edges not visible
// to the IMEs.
// -Start and end positions are moved to insertion positions.
private void GetNormalizedRange(int startCharOffset, int endCharOffset, out ITextPointer start, out ITextPointer end)
{
start = CreatePointerAtCharOffset(startCharOffset, LogicalDirection.Forward);
end = (startCharOffset == endCharOffset) ? start : CreatePointerAtCharOffset(endCharOffset, LogicalDirection.Backward);
// Skip over hidden element edges.
while (start.CompareTo(end) < 0)
{
TextPointerContext forwardContext = start.GetPointerContext(LogicalDirection.Forward);
if (forwardContext == TextPointerContext.ElementStart)
{
TextElement element = start.GetAdjacentElement(LogicalDirection.Forward) as TextElement;
if (element == null)
break;
if (element.IMELeftEdgeCharCount != 0)
break;
}
else if (forwardContext != TextPointerContext.ElementEnd)
{
break;
}
start.MoveToNextContextPosition(LogicalDirection.Forward);
}
// Move to insertion positions.
// If the positions are already adjacent to text, we must respect
// the IME's decision in regards to exact placement.
// MoveToInsertionPosition will skip over surrogates and combining
// marks, but the IME needs fine-grained control over these positions.
if (start.CompareTo(end) == 0)
{
start = start.GetFormatNormalizedPosition(LogicalDirection.Backward);
end = start;
}
else
{
start = start.GetFormatNormalizedPosition(LogicalDirection.Backward);
end = end.GetFormatNormalizedPosition(LogicalDirection.Backward);
}
}
// Raises public events corresponding to internal callbacks from
// Cicero. Specifically, here we raise
// TextInputStart, TextInputUpdate, and TextInput events.
//
// The Cicero contract disallows any reentrancy while calling IMEs hold
// the document lock. By this point, the lock has just been released,
// and we are free to "play back" the record we stored in _compositionEventList.
//
// However, we may have several events queued up. We use the undo stack
// to roll document state back before the first event was received and
// then restore state forward incrementally with each public event.
private void HandleCompositionEvents(int previousUndoCount)
{
if (this.CompositionEventList.Count == 0 ||
_compositionEventState != CompositionEventState.NotRaisingEvents)
{
// No work to do.
return;
}
// Set a flag that informs the event listeners that they must hide
// events from the IMEs. We don't want the IMEs to know about
// the view of the document we're about to present the application.
_compositionEventState = CompositionEventState.RaisingEvents;
try
{
// Remember our original selection positions.
int imeSelectionAnchorOffset = this.TextSelection.AnchorPosition.Offset;
int imeSelectionMovingOffset = this.TextSelection.MovingPosition.Offset;
UndoManager undoManager = UndoManager.GetUndoManager(this.TextContainer.Parent);
//
// Undo the last set of IME changes, saving the current state
// on the undo stack.
//
undoManager.SetRedoStack(null); // Clear the redo stack in case undoManager.UndoCount - previousUndoCount == 0.
UndoQuietly(undoManager.UndoCount - previousUndoCount);
Stack imeChangeStack = undoManager.SetRedoStack(null);
int initialUndoCount = undoManager.UndoCount;
//
// Play back IME changes, raising public events as we go along.
//
int appSelectionAnchorOffset;
int appSelectionMovingOffset;
RaiseCompositionEvents(out appSelectionAnchorOffset, out appSelectionMovingOffset);
//
// Restore text composition with undo or redo
//
SetFinalDocumentState(undoManager, imeChangeStack, undoManager.UndoCount - initialUndoCount, imeSelectionAnchorOffset, imeSelectionMovingOffset, appSelectionAnchorOffset, appSelectionMovingOffset);
}
finally
{
// Clear the composition message list
this.CompositionEventList.Clear();
// Reset the rasising composition events flag
_compositionEventState = CompositionEventState.NotRaisingEvents;
}
}
// Open the text parent undo unit
private TextParentUndoUnit OpenTextParentUndoUnit()
{
UndoManager undoManager = UndoManager.GetUndoManager(this.TextContainer.Parent);
// Create the text parent undo unit
TextParentUndoUnit textParentUndoUnit = new TextParentUndoUnit(this.TextSelection, this.TextSelection.Start, this.TextSelection.Start);
// Open the text parent undo unit
undoManager.Open(textParentUndoUnit);
return textParentUndoUnit;
}
// Close the text parent undo unit
private void CloseTextParentUndoUnit(TextParentUndoUnit textParentUndoUnit, UndoCloseAction undoCloseAction)
{
if (textParentUndoUnit != null)
{
UndoManager undoManager = UndoManager.GetUndoManager(this.TextContainer.Parent);
// Close the text parent undo unit
undoManager.Close(textParentUndoUnit, undoCloseAction);
}
}
// Raise the each composition events(Start, Update and End).
// At this point, hte document has been "rolled back" to its original
// state before the last IME edit. We'll play back each IME edit
// (StartComposition/UpdateComposition/EndComposition) now, raising
// public events at each iteration.
///
/// Critical - calls critical (TextCompositionManager) code.
/// TreatAsSafe - doesn't accept or return critical information.
///
[SecurityCritical, SecurityTreatAsSafe]
private void RaiseCompositionEvents(out int appSelectionAnchorOffset, out int appSelectionMovingOffset)
{
appSelectionAnchorOffset = -1;
appSelectionMovingOffset = -1;
UndoManager undoManager = UndoManager.GetUndoManager(this.TextContainer.Parent);
// Raise the each composition events
for (int i = 0; i < this.CompositionEventList.Count; i++)
{
CompositionEventRecord record = this.CompositionEventList[i];
FrameworkTextComposition composition = CreateComposition(this.TextEditor, this);
ITextPointer start = this.TextContainer.CreatePointerAtOffset(record.StartOffsetBefore, LogicalDirection.Backward);
ITextPointer end = this.TextContainer.CreatePointerAtOffset(record.EndOffsetBefore, LogicalDirection.Forward);
bool handled = false;
_handledByTextStoreListener = false;
_compositionModifiedByApp = false;
switch (record.Stage)
{
case CompositionStage.StartComposition:
composition.Stage = TextCompositionStage.None;
composition.SetCompositionPositions(start, end, record.Text);
undoManager.MinUndoStackCount = undoManager.UndoCount;
try
{
// PUBLIC event:
handled = TextCompositionManager.StartComposition(composition);
}
finally
{
undoManager.MinUndoStackCount = 0;
}
break;
case CompositionStage.UpdateComposition:
composition.Stage = TextCompositionStage.Started;
composition.SetCompositionPositions(start, end, record.Text);
undoManager.MinUndoStackCount = undoManager.UndoCount;
try
{
// PUBLIC event:
handled = TextCompositionManager.UpdateComposition(composition);
}
finally
{
undoManager.MinUndoStackCount = 0;
}
break;
case CompositionStage.EndComposition:
composition.Stage = TextCompositionStage.Started;
composition.SetResultPositions(start, end, record.Text);
undoManager.MinUndoStackCount = undoManager.UndoCount;
try
{
// PUBLIC event:
handled = TextCompositionManager.CompleteComposition(composition);
}
finally
{
undoManager.MinUndoStackCount = 0;
}
break;
default:
Invariant.Assert(false, "Invalid composition stage!");
break;
}
// If composition events is handled by application, we immediately complete the
// composition and keep the application's change.
if ((record.Stage == CompositionStage.EndComposition && !_handledByTextStoreListener) ||
(record.Stage != CompositionStage.EndComposition && handled) ||
composition.PendingComplete)
{
_compositionModifiedByApp = true;
}
if (_compositionModifiedByApp)
{
// Stop rasing the composition by application's text change or handled events
appSelectionAnchorOffset = this.TextSelection.AnchorPosition.Offset;
appSelectionMovingOffset = this.TextSelection.MovingPosition.Offset;
break;
}
// We're clear to update the composition.
// For EndComposition, this has already happened in the default
// TextEditor TextInputEvent listener. (We don't have default
// control/editor listeners for TextInputStart or TextInputUpdate
// event because there are no public virtuals for those events
// on UIElement.)
if (record.Stage != CompositionStage.EndComposition)
{
// UpdateCompositionText raises a PUBLIC EVENT....
UpdateCompositionText(composition);
}
if (record.Stage == CompositionStage.EndComposition)
{
// Move the start position of the next complete composition text
start = end.GetFrozenPointer(LogicalDirection.Backward);
}
// Because we just raised an event, we may need to complete the composition.
if (_compositionModifiedByApp)
{
// Stop rasing the composition by application's text change or handled events
appSelectionAnchorOffset = this.TextSelection.AnchorPosition.Offset;
appSelectionMovingOffset = this.TextSelection.MovingPosition.Offset;
break;
}
}
}
// Called after raising public events.
//
// If the application interrupted events, this method will temporarily rollback
// the application changes to safely finalize the composition, then restore
// the application changes.
//
// If the application did not interrupt events, restores the original view
// of the document last seen by IMEs.
private void SetFinalDocumentState(UndoManager undoManager, Stack imeChangeStack, int appChangeCount,
int imeSelectionAnchorOffset, int imeSelectionMovingOffset, int appSelectionAnchorOffset, int appSelectionMovingOffset)
{
this.TextSelection.BeginChangeNoUndo();
try
{
bool textChanged = _compositionModifiedByApp;
//
// Undo app changes.
//
UndoQuietly(appChangeCount);
//
// Redo IME changes.
//
Stack appRedoStack = undoManager.SetRedoStack(imeChangeStack);
int imeChangeCount = imeChangeStack.Count;
RedoQuietly(imeChangeCount);
// At this point the document should be exactly where the IME left it.
Invariant.Assert(_netCharCount == this.TextContainer.IMECharCount);
if (textChanged)
{
//
// We need to complete the composition before continuing.
//
int completeUnitCount = undoManager.UndoCount;
if (_isComposing)
{
TextParentUndoUnit completeUndoUnit = OpenTextParentUndoUnit();
try
{
CompleteComposition();
}
finally
{
CloseTextParentUndoUnit(completeUndoUnit, (completeUndoUnit.LastUnit != null) ? UndoCloseAction.Commit : UndoCloseAction.Discard);
}
}
completeUnitCount = (undoManager.UndoCount - completeUnitCount);
// Set a flag that informs the event listeners they need
// to pass along change notifications to the IMEs.
_compositionEventState = CompositionEventState.ApplyingApplicationChange;
try
{
//
// Undo the composition complete, if any.
//
UndoQuietly(completeUnitCount);
//
// Undo the remaining IME changes.
//
UndoQuietly(imeChangeCount);
//
// Restore application changes.
//
undoManager.SetRedoStack(appRedoStack);
RedoQuietly(appChangeCount);
// The IME should have received the app change events from preceeding RedoQuietly.
Invariant.Assert(_netCharCount == this.TextContainer.IMECharCount);
// we can't rely on Redo fixing up the selection.
// If the app only modified the selection appChangeCount == 0.
ITextPointer anchor = this.TextContainer.CreatePointerAtOffset(appSelectionAnchorOffset, LogicalDirection.Forward);
ITextPointer moving = this.TextContainer.CreatePointerAtOffset(appSelectionMovingOffset, LogicalDirection.Forward);
this.TextSelection.Select(anchor, moving);
}
finally
{
// Reset CompositionEventState after Redo operation
_compositionEventState = CompositionEventState.RaisingEvents;
}
}
else
{
// Restore the selection.
ITextPointer anchor = this.TextContainer.CreatePointerAtOffset(imeSelectionAnchorOffset, LogicalDirection.Backward);
ITextPointer moving = this.TextContainer.CreatePointerAtOffset(imeSelectionMovingOffset, LogicalDirection.Backward);
this.TextSelection.Select(anchor, moving);
// Since we just had a composition accepted, we need to merge all
// of its individual units now.
MergeCompositionUndoUnits();
}
}
finally
{
this.TextSelection.EndChange(false /* disableScroll */, true /* skipEvents */);
}
}
// Pops a unit off the undo stack without raising any public events.
private void UndoQuietly(int count)
{
if (count > 0)
{
UndoManager undoManager = UndoManager.GetUndoManager(this.TextContainer.Parent);
this.TextSelection.BeginChangeNoUndo();
try
{
undoManager.Undo(count);
}
finally
{
this.TextSelection.EndChange(false /* disableScroll */, true /* skipEvents */);
}
}
}
// Pops a unit off the redo stack without raising any public events.
private void RedoQuietly(int count)
{
if (count > 0)
{
UndoManager undoManager = UndoManager.GetUndoManager(this.TextContainer.Parent);
this.TextSelection.BeginChangeNoUndo();
try
{
undoManager.Redo(count);
}
finally
{
this.TextSelection.EndChange(false /* disableScroll */, true /* skipEvents */);
}
}
}
// Merges individual undo units that are part of a single composition into
// single undo units.
private void MergeCompositionUndoUnits()
{
UndoManager undoManager = UndoManager.GetUndoManager(this.TextContainer.Parent);
if (undoManager == null || !undoManager.IsEnabled)
{
return;
}
// Walk backwards through the undo stack, looking for units originating
// from a single composition to merge.
int i = undoManager.UndoCount - 1;
int j = undoManager.UndoCount - 1;
while (i >= 0)
{
CompositionParentUndoUnit unit = undoManager.GetUndoUnit(i) as CompositionParentUndoUnit;
if (unit == null || (unit.IsFirstCompositionUnit && unit.IsLastCompositionUnit)) //
break;
if (!unit.IsFirstCompositionUnit)
{
i--;
continue;
}
// We're ready to merge.
int mergeCount = j - i;
for (int k = i+1; k <= i + mergeCount; k++)
{
CompositionParentUndoUnit mergeSource = (CompositionParentUndoUnit)undoManager.GetUndoUnit(k);
unit.MergeCompositionUnit(mergeSource);
}
undoManager.RemoveUndoRange(i + 1, mergeCount);
i--;
j = i;
}
}
// Returns the top CompositionParentUndoUnit on the undo stack,
// if any. Does not actually pop the unit.
private CompositionParentUndoUnit PeekCompositionParentUndoUnit()
{
UndoManager undoManager = UndoManager.GetUndoManager(this.TextContainer.Parent);
if (undoManager == null || !undoManager.IsEnabled)
return null;
return undoManager.PeekUndoStack() as CompositionParentUndoUnit;
}
#endregion Private Methods
//------------------------------------------------------
//
// Private Properties
//
//-----------------------------------------------------
#region Private Properties
private bool IsTextEditorValid
{
get { return _weakTextEditor.IsValid; }
}
private TextEditor TextEditor
{
get { return _weakTextEditor.TextEditor; }
}
private ITextSelection TextSelection
{
get { return this.TextEditor.Selection; }
}
private bool IsReadOnly
{
get
{
return ((bool)this.UiScope.GetValue(TextEditor.IsReadOnlyProperty) || TextEditor.IsReadOnly);
}
}
// Lazy allocated _compositionEventList accessor.
private List CompositionEventList
{
get
{
if (_compositionEventList == null)
{
_compositionEventList = new List();
}
return _compositionEventList;
}
}
#endregion Private Properties
//------------------------------------------------------
//
// Private Types
//
//------------------------------------------------------
#region Private Types
// This is an enumrator of AppProperty types.
private enum AttributeStyle
{
InputScope = 0,
Font_Style_Height = 1,
Font_FaceName = 2,
Font_SizePts = 3,
Text_ReadOnly = 4,
Text_Orientation = 5,
Text_VerticalWriting = 6,
}
// This structure maps TS_ATTR (GUID) to AttributeStyle.
private struct TextServicesAttribute
{
internal TextServicesAttribute(Guid guid, AttributeStyle style)
{
_guid = guid;
_style = style;
}
internal Guid Guid
{
get { return _guid; }
}
internal AttributeStyle Style
{
get { return _style; }
}
private Guid _guid;
private AttributeStyle _style;
}
// Scope WeakReference wrapper to detect whether the target object is invalid.
private class ScopeWeakReference : WeakReference
{
internal ScopeWeakReference(object obj) : base(obj)
{
}
internal bool IsValid
{
get
{
try
{
return IsAlive;
}
catch (InvalidOperationException)
{
return false;
}
}
}
internal TextEditor TextEditor
{
get
{
try
{
return (TextEditor)this.Target;
}
catch (InvalidOperationException)
{
return null;
}
}
}
}
// This structure maps TS_ATTR (GUID) to AttributeStyle.
private class MouseSink : IDisposable, IComparer
{
internal MouseSink(UnsafeNativeMethods.ITfRangeACP range, UnsafeNativeMethods.ITfMouseSink sink, int cookie)
{
_range = new SecurityCriticalDataClass(range);
_sink = new SecurityCriticalDataClass(sink);
_cookie = cookie;
}
///
/// Critical: UnsafeNativeMethods.ITfRangeACP has methods with SuppressUnmanagedCodeSecurity.
/// TreatAsSafe: Only disposing objects.
///
[SecurityCritical, SecurityTreatAsSafe]
public void Dispose()
{
Invariant.Assert(!_locked);
// In case Dispose comes twice.
if (_range != null)
{
Marshal.ReleaseComObject(_range.Value);
_range = null;
}
if (_sink != null)
{
Marshal.ReleaseComObject(_sink.Value);
_sink = null;
}
_cookie = UnsafeNativeMethods.TF_INVALID_COOKIE;
}
public int Compare( Object x, Object y )
{
return (((MouseSink)x)._cookie - ((MouseSink)y)._cookie);
}
// While Locked == false, UnadviseSink will not immediately
// dispose of this object. Locked is a poor man's AddRef/Release,
// necessary because (1) we can't let the gc Dispose this object on
// the finalizer thread, and (2) cicero will sometimes unadvise
// this object from within a callback.
internal bool Locked
{
get
{
return _locked;
}
set
{
_locked = value;
if (!_locked && _pendingDispose)
{
Dispose();
}
}
}
// Set true when this object has been released via UnadviseSink.
internal bool PendingDispose
{
set
{
_pendingDispose = value;
}
}
///
/// Critical: UnsafeNativeMethods.ITfRangeACP has methods with SuppressUnmanagedCodeSecurity.
///
internal UnsafeNativeMethods.ITfRangeACP Range
{
[SecurityCritical]
get {return _range.Value;}
}
///
/// Critical: UnsafeNativeMethods.ITFMouseSink has methods with SuppressUnmanagedCodeSecurity.
///
internal UnsafeNativeMethods.ITfMouseSink Sink
{
[SecurityCritical]
get {return _sink.Value;}
}
internal int Cookie {get{return _cookie;}}
///
/// Critical: UnsafeNativeMethods.ITfRangeACP has methods with SuppressUnmanagedCodeSecurity.
///
private SecurityCriticalDataClass _range;
///
/// Critical: UnsafeNativeMethods.ITfMouseSink has methods with SuppressUnmanagedCodeSecurity.
///
private SecurityCriticalDataClass _sink;
private int _cookie;
// Set true during a sink callback.
private bool _locked;
// Set true when this object has been released via UnadviseSink.
private bool _pendingDispose;
}
// Custom parent undo unit used to hold composition updates.
private class CompositionParentUndoUnit : TextParentUndoUnit
{
internal CompositionParentUndoUnit(ITextSelection selection, ITextPointer anchorPosition, ITextPointer movingPosition, bool isFirstCompositionUnit)
: base(selection, anchorPosition, movingPosition)
{
_isFirstCompositionUnit = isFirstCompositionUnit;
}
// Creates a redo unit from an undo unit.
private CompositionParentUndoUnit(CompositionParentUndoUnit undoUnit)
: base(undoUnit)
{
_isFirstCompositionUnit = undoUnit._isFirstCompositionUnit;
_isLastCompositionUnit = undoUnit._isLastCompositionUnit;
}
protected override TextParentUndoUnit CreateRedoUnit()
{
return new CompositionParentUndoUnit(this);
}
// Merges another unit into this unit.
internal void MergeCompositionUnit(CompositionParentUndoUnit unit)
{
object[] units = unit.CopyUnits();
Invariant.Assert(this.Locked); // If this fails, then the Locked = true below is invalid.
this.Locked = false;
for (int i = units.Length - 1; i >= 0; i--)
{
Add((IUndoUnit)units[i]);
}
this.Locked = true;
MergeRedoSelectionState(unit);
_isLastCompositionUnit |= unit.IsLastCompositionUnit;
}
// True if this unit is the first unit of a composition.
internal bool IsFirstCompositionUnit
{
get
{
return _isFirstCompositionUnit;
}
}
// True if this unit is the last unit of a composition.
internal bool IsLastCompositionUnit
{
get
{
return _isLastCompositionUnit;
}
set
{
_isLastCompositionUnit = value;
}
}
// Returns a shallow copy of this units children.
private object[] CopyUnits()
{
return this.Units.ToArray();
}
private readonly bool _isFirstCompositionUnit;
private bool _isLastCompositionUnit;
}
// Tristate used to filter TextContainer change events.
private enum CompositionEventState
{
// Not currently raising composition events.
// Events received in this state are application changes.
NotRaisingEvents = 0,
// Raising public events. Events should be hidden from IMEs.
RaisingEvents = 1,
// Raising public event, but events should not be hidden from IMEs.
ApplyingApplicationChange = 2,
}
// Context associated with a FrameworkTextComposition.
private enum CompositionStage
{
///
/// The StartComposition has set.
///
StartComposition = 1,
///
/// The UpdateComposition has set.
///
UpdateComposition = 2,
///
/// The EndComposition has set.
///
EndComposition = 3,
}
// Package for state saved during a composition start/update/end event.
private class CompositionEventRecord
{
internal CompositionEventRecord(CompositionStage stage, int startOffsetBefore, int endOffsetBefore, string text)
{
_stage = stage;
_startOffsetBefore = startOffsetBefore;
_endOffsetBefore = endOffsetBefore;
_text = text;
}
internal CompositionStage Stage
{
get { return _stage; }
}
internal int StartOffsetBefore
{
get { return _startOffsetBefore; }
}
internal int EndOffsetBefore
{
get { return _endOffsetBefore; }
}
internal string Text
{
get { return _text; }
}
private readonly CompositionStage _stage;
private readonly int _startOffsetBefore;
private readonly int _endOffsetBefore;
private readonly string _text;
}
#endregion Private Types
//-----------------------------------------------------
//
// Private Fields
//
//------------------------------------------------------
#region Private Fields
// An element to which the TextEditor instance is attached
private readonly ScopeWeakReference _weakTextEditor;
private TextServicesHost _textservicesHost;
// A TSF sink used to notify TSF after selection, document, or layout changes.
private UnsafeNativeMethods.ITextStoreACPSink _sink;
// true if TSF has a pending lock upgrade request.
private bool _pendingWriteReq;
// The current document lock status.
private UnsafeNativeMethods.LockFlags _lockFlags;
// If we're waiting for an async lock request to be dispatched,
// this field will be non-zero with the requested lock privilege level.
private UnsafeNativeMethods.LockFlags _pendingAsyncLockFlags;
// Counter set non-zero during OnTextChange callbacks.
// Used to prevent reentrant locks.
private int _textChangeReentrencyCount;
// true if we're in the middle of an ongoing composition.
private bool _isComposing;
private int _previousCompositionStartOffset = -1;
private int _previousCompositionEndOffset = -1;
// Position of the composition start as of the last update.
// We can't simply store int offsets because under some circumstances
// IMEs will ignore text input during a composition, letting the editor
// handle the event, in which case we need live pointers to react
// to the changes. See bug 118934.
private ITextPointer _previousCompositionStart;
// Position of the composition end as of the last update.
private ITextPointer _previousCompositionEnd;
// Manages display attributes for active compositions.
private TextServicesProperty _textservicesproperty;
// We only ever expose one view, so we can use a constant identifier
// when talking to TSF.
private const int _viewCookie = 0;
// The TSF document object. This is a native resource.
///
/// Critical: UnsafeNativeMethods.ITfDocumentMgr has methods with SuppressUnmanagedCodeSecurity.
///
private SecurityCriticalDataClass _documentmanager;
// The ITfThreadFocusSink cookie.
private int _threadFocusCookie;
// The ITfEditSink cookie.
private int _editSinkCookie;
// The readonly edit cookie TSF returns from CreateContext.
private int _editCookie;
// The transitory extension sink cookie.
private int _transitoryExtensionSinkCookie;
// This is the temp array for TS_ATTRVAL for RetrieveRequestedAttr.
private ArrayList _preparedattributes;
// This is the array for mouse sinks.
private ArrayList _mouseSinks;
// We keep the mapping data from TS_ATTR (GUID) to AttributeStyle.
private static readonly TextServicesAttribute[] _supportingattributes = new TextServicesAttribute[] {
new TextServicesAttribute(UnsafeNativeMethods.GUID_PROP_INPUTSCOPE, AttributeStyle.InputScope),
new TextServicesAttribute(UnsafeNativeMethods.TSATTRID_Font_Style_Height, AttributeStyle.Font_Style_Height),
new TextServicesAttribute(UnsafeNativeMethods.TSATTRID_Font_FaceName, AttributeStyle.Font_FaceName),
new TextServicesAttribute(UnsafeNativeMethods.TSATTRID_Font_SizePts, AttributeStyle.Font_SizePts),
new TextServicesAttribute(UnsafeNativeMethods.TSATTRID_Text_ReadOnly, AttributeStyle.Text_ReadOnly),
new TextServicesAttribute(UnsafeNativeMethods.TSATTRID_Text_Orientation, AttributeStyle.Text_Orientation),
new TextServicesAttribute(UnsafeNativeMethods.TSATTRID_Text_VerticalWriting, AttributeStyle.Text_VerticalWriting),
};
// This is true if the current selection is for an interim character. Koream Interim Support.
private bool _interimSelection;
#if ENABLE_INK_EMBEDDING
// Buffer used by RemoveContent/OnTextContainerChangeAdded to record
// the first symbol offset affected by a content remove edit.
private int _minSymbolsRemovedIndex;
#endif // #if ENABLE_INK_EMBEDDING
// Set true if a TIP modifies the selection.
// Used to avoid reporting non-external selection changes when the
// OnLockGranted change block closes.
private bool _ignoreNextSelectionChange;
// The sum of all character added/removed events.
// Should never be negative.
// Should always equal this.TextContainer.IMECharCount.
// This field is only used for reliabilty reasons, in calls to Invariant.Assert.
private int _netCharCount;
// The element might be disconnected from tree when the parent window is moved.
// We need to make a LayoutChange notification when it gets focus back.
private bool _makeLayoutChangeOnGotFocus;
// Flag that indicate the rasising composition events
private CompositionEventState _compositionEventState;
// Flag that indicate the composition text changed by
// someone other than the editor or an IME (ie, during
// a public event).
private bool _compositionModifiedByApp;
// Composition event list.
private List _compositionEventList;
// Used to identify the start of a new composition on the undo stack.
private bool _nextUndoUnitIsFirstCompositionUnit = true;
// A record of the last text inserted by a composition update.
private string _lastCompositionText;
// Set true when TextEditor.OnTextInput handles a TextInput event (no app override).
private bool _handledByTextStoreListener;
#endregion Private Fields
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- EventLogEntryCollection.cs
- NavigationProperty.cs
- FrugalMap.cs
- SynthesizerStateChangedEventArgs.cs
- SafeNativeMethods.cs
- HttpModule.cs
- SQLRoleProvider.cs
- ObjectDataSourceDisposingEventArgs.cs
- XmlBufferReader.cs
- ContextStaticAttribute.cs
- cache.cs
- SortQuery.cs
- XmlObjectSerializerWriteContext.cs
- StatusBar.cs
- Int64KeyFrameCollection.cs
- SqlBuilder.cs
- ProcessHostServerConfig.cs
- MultitargetingHelpers.cs
- EnumType.cs
- QueryContinueDragEventArgs.cs
- CloudCollection.cs
- SqlErrorCollection.cs
- ManagementOptions.cs
- CompressStream.cs
- ElementHost.cs
- GenerateTemporaryTargetAssembly.cs
- SoapElementAttribute.cs
- TreeChangeInfo.cs
- TextDecorations.cs
- TransformDescriptor.cs
- OLEDB_Enum.cs
- SocketElement.cs
- TemplateBindingExpressionConverter.cs
- NetworkCredential.cs
- AdRotator.cs
- TemplateControl.cs
- AdapterSwitches.cs
- OperationFormatUse.cs
- AliasExpr.cs
- KeyedQueue.cs
- ExtendedProperty.cs
- ParentQuery.cs
- HttpVersion.cs
- FileDialog.cs
- ToolboxService.cs
- DataKeyArray.cs
- PageClientProxyGenerator.cs
- XmlDataProvider.cs
- MultilineStringConverter.cs
- RSAProtectedConfigurationProvider.cs
- SiteMapSection.cs
- StorageRoot.cs
- SourceFilter.cs
- DetailsViewPageEventArgs.cs
- DrawingContextWalker.cs
- BasicHttpSecurityElement.cs
- recordstate.cs
- XmlMapping.cs
- RepeaterItem.cs
- DataGridViewTextBoxColumn.cs
- UnauthorizedAccessException.cs
- PolicyValidationException.cs
- OleDbConnectionFactory.cs
- PtsHost.cs
- RequestQueryParser.cs
- BaseTreeIterator.cs
- BitmapMetadata.cs
- RowToParametersTransformer.cs
- CircleHotSpot.cs
- ArgumentDesigner.xaml.cs
- PreservationFileReader.cs
- WindowsSolidBrush.cs
- ValuePattern.cs
- FlowNode.cs
- WebConfigurationHost.cs
- DLinqDataModelProvider.cs
- AsyncDataRequest.cs
- HttpHeaderCollection.cs
- File.cs
- SqlEnums.cs
- ExpressionBuilder.cs
- RegisteredScript.cs
- XmlEventCache.cs
- MouseActionConverter.cs
- StatusBarDrawItemEvent.cs
- X509ChainPolicy.cs
- PermissionListSet.cs
- TypeContext.cs
- log.cs
- NamespaceImport.cs
- ProgressPage.cs
- TableParagraph.cs
- WebGetAttribute.cs
- SystemResourceHost.cs
- EnumBuilder.cs
- FastEncoder.cs
- NativeMethods.cs
- HMACMD5.cs
- DocumentApplicationJournalEntry.cs
- ColumnMapVisitor.cs