internal void OnEndEdit(
UnsafeNativeMethods.ITfContext context,
int ecReadOnly,
UnsafeNativeMethods.ITfEditRecord editRecord)
{
if (_propertyRanges == null)
{
_propertyRanges = new TextServicesDisplayAttributePropertyRanges(_textstore);
}
_propertyRanges.OnEndEdit(context, ecReadOnly, editRecord);
}
internal DynamicScriptObject(UnsafeNativeMethods.IDispatch scriptObject)
{
if (scriptObject == null)
{
throw new ArgumentNullException("scriptObject");
}
_scriptObject = scriptObject;
// In the case of IE, we use IDispatchEx for enhanced security (see InvokeOnScriptObject).
_scriptObjectEx = _scriptObject as UnsafeNativeMethods.IDispatchEx;
}
internal virtual void OnEndEdit(UnsafeNativeMethods.ITfContext context,
int ecReadOnly,
UnsafeNativeMethods.ITfEditRecord editRecord)
{
int fetched;
UnsafeNativeMethods.IEnumTfRanges ranges;
UnsafeNativeMethods.ITfProperty prop = null;
ranges = GetPropertyUpdate(editRecord);
UnsafeNativeMethods.ITfRange [] outRanges;
outRanges = new UnsafeNativeMethods.ITfRange[1];
while (ranges.Next(1, outRanges, out fetched) == 0)
{
//
// check the element has enabled dynamic property.
//
ITextPointer start;
ITextPointer end;
ConvertToTextPosition(outRanges[0], out start, out end);
if (prop == null)
context.GetProperty(ref _guid, out prop);
UnsafeNativeMethods.IEnumTfRanges rangesProp;
if (prop.EnumRanges(ecReadOnly, out rangesProp, outRanges[0]) == 0)
{
UnsafeNativeMethods.ITfRange [] outRangesProp;
outRangesProp = new UnsafeNativeMethods.ITfRange[1];
while (rangesProp.Next(1, outRangesProp, out fetched) == 0)
{
OnRange(prop, ecReadOnly, outRangesProp[0]);
Marshal.ReleaseComObject(outRangesProp[0]);
}
Marshal.ReleaseComObject(rangesProp);
}
Marshal.ReleaseComObject(outRanges[0]);
}
Marshal.ReleaseComObject(ranges);
if (prop != null)
Marshal.ReleaseComObject(prop);
}
internal override void OnRange(
UnsafeNativeMethods.ITfProperty property,
int ecReadOnly,
UnsafeNativeMethods.ITfRange range)
{
Int32 guidatom = GetInt32Value(ecReadOnly, property, range);
if (guidatom != 0)
{
TextServicesDisplayAttribute attr;
attr = GetDisplayAttribute(guidatom);
if (attr != null)
{
ITextPointer start;
ITextPointer end;
ConvertToTextPosition(range, out start, out end);
attr.Apply(start, end);
}
}
}
internal void OpenColorProfile(ref UnsafeNativeMethods.PROFILE profile)
{
// No need to get rid of the old handle as it will get GC'ed
_profileHandle = UnsafeNativeMethodsMilCoreApi.Mscms.OpenColorProfile(
ref profile,
NativeMethods.PROFILE_READ, // DesiredAccess
NativeMethods.FILE_SHARE_READ, // ShareMode
NativeMethods.OPEN_EXISTING // CreationMode
);
}
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 (HasSink)
{
Marshal.ReleaseComObject(_sink);
}
else
{
// Start tracking window movement for _sink.
_textservicesHost.RegisterWinEventSink(this);
}
_sink = sink;
}
internal bool GetColorProfileHeader(out UnsafeNativeMethods.PROFILEHEADER header)
{
if (IsInvalid)
{
throw new InvalidOperationException(SR.Get(SRID.Image_ColorContextInvalid));
}
return UnsafeNativeMethodsMilCoreApi.Mscms.GetColorProfileHeader(_profileHandle, out header);
}
private Int32 GetInt32Value(int ecReadOnly, UnsafeNativeMethods.ITfProperty property, UnsafeNativeMethods.ITfRange range)
{
Object obj = GetValue(ecReadOnly, property, range);
if (obj == null)
return 0;
return (Int32)obj;
}
// 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 = FilterCompositionString(new string(text), start.GetOffsetToPosition(end)); // does NOT filter MaxLength.
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);
}
}
int UnsafeNativeMethods.IDocHostUIHandler.GetDropTarget(UnsafeNativeMethods.IOleDropTarget pDropTarget, out UnsafeNativeMethods.IOleDropTarget ppDropTarget)
{
//
// Set to null no matter what we return, to prevent the marshaller
// from going crazy if the pointer points to random stuff.
ppDropTarget = null;
return NativeMethods.E_NOTIMPL;
}
public static extern void DoDragDrop(IComDataObject dataObject, UnsafeNativeMethods.IOleDropSource dropSource, int allowedEffects, int[] finalEffect);
// 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 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 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)); // does NOT filter MaxLength.
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,
//
// <StackPanel xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:sys="clr-namespace:System;assembly=mscorlib" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" >
// <RichTextBox FontSize="24" Height="150">
// <FlowDocument>
// <Paragraph>
// <Run>para</Run>
// <Floater HorizontalAlignment="Right" Width="100" Background="#FFFF0000">
// <Paragraph><Run>Floater</Run></Paragraph>
// </Floater>
// <Run> </Run>
// </Paragraph>
// </FlowDocument>
// </RichTextBox>
// </StackPanel>
//
// 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 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
}
internal MouseSink(UnsafeNativeMethods.ITfRangeACP range, UnsafeNativeMethods.ITfMouseSink sink, int cookie)
{
_range = new SecurityCriticalDataClass<UnsafeNativeMethods.ITfRangeACP>(range);
_sink = new SecurityCriticalDataClass<UnsafeNativeMethods.ITfMouseSink>(sink);
_cookie = cookie;
}
int UnsafeNativeMethods.IDocHostUIHandler.ShowUI(int dwID, UnsafeNativeMethods.IOleInPlaceActiveObject activeObject,
NativeMethods.IOleCommandTarget commandTarget, UnsafeNativeMethods.IOleInPlaceFrame frame,
UnsafeNativeMethods.IOleInPlaceUIWindow doc)
{
return NativeMethods.E_NOTIMPL;
}
// 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;
}
int UnsafeNativeMethods.IDocHostUIHandler.ResizeBorder(NativeMethods.COMRECT rect, UnsafeNativeMethods.IOleInPlaceUIWindow doc, bool fFrameWindow)
{
return NativeMethods.E_NOTIMPL;
}
// wrapper for GetTitleBarInfo
internal static bool ProxyGetTitleBarInfo(IntPtr hwnd, out UnsafeNativeMethods.TITLEBARINFO ti)
{
ti = new UnsafeNativeMethods.TITLEBARINFO();
ti.cbSize = Marshal.SizeOf(ti.GetType());
bool result = UnsafeNativeMethods.GetTitleBarInfo(hwnd, ref ti);
int lastWin32Error = Marshal.GetLastWin32Error();
if (!result)
{
ThrowWin32ExceptionsIfError(lastWin32Error);
return false;
}
return true;
}
public static extern int RegisterDragDrop(HandleRef hwnd, UnsafeNativeMethods.IOleDropTarget target);
// ------------------------------------------------------
//
// Private Methods
//
// ------------------------------------------------------
#region Private Methods
private static bool EnumToolTipWindows(IntPtr hwnd, ref UnsafeNativeMethods.ENUMTOOLTIPWINDOWINFO lParam)
{
// Use ProxyGetClassName here instead of GetClassName(),
// since for a [....] tooltip the latter will return
// "WindowsForms10.tooltips_class32.app.0.b7ab7b".
// Instead, ProxyGetClassName uses WM_GETOBJECT with
// OBJID_QUERYCLASSNAMEIDX, which will return the correct answer.
if (!ProxyGetClassName(hwnd).Equals("tooltips_class32"))
{
return true;
}
NativeMethods.TOOLINFO tool = new NativeMethods.TOOLINFO();
tool.Init(Marshal.SizeOf(typeof(NativeMethods.TOOLINFO)));
// For tooltips with ids of 0, MFC will create the tooltip with the flag of TTF_IDISHWND.
// TTF_IDISHWND indicates that the uId member is the window handle to the tool.
if (lParam.id == 0)
{
tool.hwnd = Misc.GetParent(lParam.hwnd);
tool.uId = unchecked((int)lParam.hwnd);
tool.uFlags = NativeMethods.TTF_IDISHWND;
}
else
{
tool.hwnd = lParam.hwnd;
tool.uId = lParam.id;
}
string name = XSendMessage.GetItemText(hwnd, tool);
// Didn't get anything - continue looking...
if (string.IsNullOrEmpty(name))
{
return true;
}
lParam.name = name;
// Got it - can stop iterating now.
return false;
}
internal override void OnEndEdit(UnsafeNativeMethods.ITfContext context,
int ecReadOnly,
UnsafeNativeMethods.ITfEditRecord editRecord)
{
Guid displayAttributeGuid;
UnsafeNativeMethods.ITfProperty displayAttributeProperty;
UnsafeNativeMethods.IEnumTfRanges attributeRangeEnumerator;
UnsafeNativeMethods.ITfRange[] attributeRanges;
int fetched;
int guidAtom;
TextServicesDisplayAttribute displayAttribute;
ITextPointer start;
ITextPointer end;
//
// Remove any existing display attribute highlights.
//
#if UNUSED_IME_HIGHLIGHT_LAYER
if (_highlightLayer != null)
{
this.TextStore.TextContainer.Highlights.RemoveLayer(_highlightLayer);
_highlightLayer = null;
}
#endif
//
// Remove any existing composition adorner for display attribute.
//
if (_compositionAdorner != null)
{
_compositionAdorner.Uninitialize();
_compositionAdorner = null;
}
//
// Look for new ones.
//
// Get the DisplayAttributeProperty.
displayAttributeGuid = Guid;
context.GetProperty(ref displayAttributeGuid, out displayAttributeProperty);
// Get a range enumerator for the property.
if (displayAttributeProperty.EnumRanges(ecReadOnly, out attributeRangeEnumerator, null) == NativeMethods.S_OK)
{
attributeRanges = new UnsafeNativeMethods.ITfRange[1];
// Walk each range.
while (attributeRangeEnumerator.Next(1, attributeRanges, out fetched) == NativeMethods.S_OK)
{
// Get a DisplayAttribute for this range.
guidAtom = GetInt32Value(ecReadOnly, displayAttributeProperty, attributeRanges[0]);
displayAttribute = GetDisplayAttribute(guidAtom);
if (displayAttribute != null && !displayAttribute.IsEmptyAttribute())
{
// Set a matching highlight for the attribute range.
ConvertToTextPosition(attributeRanges[0], out start, out end);
if (start != null)
{
#if UNUSED_IME_HIGHLIGHT_LAYER
// Demand create the highlight layer.
if (_highlightLayer == null)
{
_highlightLayer = new DisplayAttributeHighlightLayer();
}
#endif
if (_compositionAdorner == null)
{
_compositionAdorner = new CompositionAdorner(this.TextStore.TextView);
_compositionAdorner.Initialize(this.TextStore.TextView);
}
#if UNUSED_IME_HIGHLIGHT_LAYER
// ToDo: Need to pass the foreground and background color of the composition
_highlightLayer.Add(start, end, /*TextDecorationCollection:*/null);
#endif
// Add the attribute range into CompositionAdorner.
_compositionAdorner.AddAttributeRange(start, end, displayAttribute);
}
}
Marshal.ReleaseComObject(attributeRanges[0]);
}
#if UNUSED_IME_HIGHLIGHT_LAYER
if (_highlightLayer != null)
{
this.TextStore.TextContainer.Highlights.AddLayer(_highlightLayer);
}
#endif
if (_compositionAdorner != null)
{
// Update the layout to get the acurated rectangle from calling GetRectangleFromTextPosition
this.TextStore.RenderScope.UpdateLayout();
// Invalidate the composition adorner to render the composition attribute ranges.
_compositionAdorner.InvalidateAdorner();
}
Marshal.ReleaseComObject(attributeRangeEnumerator);
}
Marshal.ReleaseComObject(displayAttributeProperty);
}
public HwndWrapper(
int classStyle,
int style,
int exStyle,
int x,
int y,
int width,
int height,
string name,
IntPtr parent,
HwndWrapperHook[] hooks)
{
_ownerThreadID = new SecurityCriticalDataForSet <int>(Thread.CurrentThread.ManagedThreadId);
// First, add the set of hooks. This allows the hooks to receive the
// messages sent to the window very early in the process.
if (hooks != null)
{
for (int i = 0, iEnd = hooks.Length; i < iEnd; i++)
{
if (null != hooks[i])
{
AddHook(hooks[i]);
}
}
}
_wndProc = new SecurityCriticalData <HwndWrapperHook>(new HwndWrapperHook(WndProc));
// We create the HwndSubclass object so that we can use its
// window proc directly. We will not be "subclassing" the
// window we create.
HwndSubclass hwndSubclass = new HwndSubclass(_wndProc.Value);
// Register a unique window class for this instance.
NativeMethods.WNDCLASSEX_D wc_d = new NativeMethods.WNDCLASSEX_D();
IntPtr hNullBrush = UnsafeNativeMethods.CriticalGetStockObject(NativeMethods.NULL_BRUSH);
if (hNullBrush == IntPtr.Zero)
{
throw new System.ComponentModel.Win32Exception(Marshal.GetLastWin32Error());
}
IntPtr hInstance = UnsafeNativeMethods.GetModuleHandle(null);
// We need to keep the Delegate object alive through the call to CreateWindowEx().
// Subclass.WndProc will install a better delegate (to the same function) when it
// processes the first message.
// But this first delegate needs be held alive until then.
NativeMethods.WndProc initialWndProc = new NativeMethods.WndProc(hwndSubclass.SubclassWndProc);
// The class name is a concat of AppName, ThreadName, and RandomNumber.
// Register will fail if the string gets over 255 in length.
// So limit each part to a reasonable amount.
string appName;
if (null != AppDomain.CurrentDomain.FriendlyName && 128 <= AppDomain.CurrentDomain.FriendlyName.Length)
{
appName = AppDomain.CurrentDomain.FriendlyName.Substring(0, 128);
}
else
{
appName = AppDomain.CurrentDomain.FriendlyName;
}
string threadName;
if (null != Thread.CurrentThread.Name && 64 <= Thread.CurrentThread.Name.Length)
{
threadName = Thread.CurrentThread.Name.Substring(0, 64);
}
else
{
threadName = Thread.CurrentThread.Name;
}
// Create a suitable unique class name.
_classAtom = 0;
string randomName = Guid.NewGuid().ToString();
string className = String.Format(CultureInfo.InvariantCulture, "HwndWrapper[{0};{1};{2}]", appName, threadName, randomName);
wc_d.cbSize = Marshal.SizeOf(typeof(NativeMethods.WNDCLASSEX_D));
wc_d.style = classStyle;
wc_d.lpfnWndProc = initialWndProc;
wc_d.cbClsExtra = 0;
wc_d.cbWndExtra = 0;
wc_d.hInstance = hInstance;
wc_d.hIcon = IntPtr.Zero;
wc_d.hCursor = IntPtr.Zero;
wc_d.hbrBackground = hNullBrush;
wc_d.lpszMenuName = "";
wc_d.lpszClassName = className;
wc_d.hIconSm = IntPtr.Zero;
// Register the unique class for this instance.
// Note we use a GUID in the name so we are confident that
// the class name should be unique. And RegisterClassEx won't
// fail (for that reason).
_classAtom = UnsafeNativeMethods.RegisterClassEx(wc_d);
// call CreateWindow
_isInCreateWindow = true;
try {
_handle = new SecurityCriticalDataClass <IntPtr>(UnsafeNativeMethods.CreateWindowEx(exStyle,
className,
name,
style,
x,
y,
width,
height,
new HandleRef(null, parent),
new HandleRef(null, IntPtr.Zero),
new HandleRef(null, IntPtr.Zero),
null));
}
finally
{
_isInCreateWindow = false;
if (_handle == null || _handle.Value == IntPtr.Zero)
{
new UIPermission(UIPermissionWindow.AllWindows).Assert(); //BlessedAssert to call Dispose
try
{
// Because the HwndSubclass is pinned, but the HWND creation failed,
// we need to manually clean it up.
hwndSubclass.Dispose();
}
finally
{
CodeAccessPermission.RevertAssert();
}
}
}
GC.KeepAlive(initialWndProc);
}
// 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;
}
// 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!");
}
internal static bool ProxyGetTitleBarInfoEx(IntPtr hwnd, out UnsafeNativeMethods.TITLEBARINFOEX ti)
{
ti = new UnsafeNativeMethods.TITLEBARINFOEX();
ti.cbSize = Marshal.SizeOf(ti.GetType());
IntPtr result;
IntPtr resultSendMessage = UnsafeNativeMethods.SendMessageTimeout(hwnd, NativeMethods.WM_GETTITLEBARINFOEX, IntPtr.Zero, ref ti, _sendMessageFlags, _sendMessageTimeoutValue, out result);
int lastWin32Error = Marshal.GetLastWin32Error();
if (resultSendMessage == IntPtr.Zero)
{
//Window owner failed to process the message WM_GETTITLEBARINFOEX
EvaluateSendMessageTimeoutError(lastWin32Error);
}
return true;
}
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--;
}
}
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.
_isInUpdateLayout = true;
UiScope.UpdateLayout();
_isInUpdateLayout = false;
// (Dev11 721274) if UpdateLayout caused a text change, startIndex
// and endIndex are no longer valid. Handling this correctly is quite
// difficult - Cicero assumes that the text can't change while it
// owns the lock. Instead, we artificially reset the char count (to
// keep VerifyTextStoreConsistency happy), and return TS_R_NOLAYOUT
// to the caller; this seems to be good enough (i.e. avoids crashes)
// in practice.
if (_hasTextChangedInUpdateLayout)
{
_netCharCount = this.TextContainer.IMECharCount;
throw new COMException(SR.Get(SRID.TextStore_TS_E_NOLAYOUT), UnsafeNativeMethods.TS_E_NOLAYOUT);
}
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);
}
static HwndWrapper()
{
s_msgGCMemory = UnsafeNativeMethods.RegisterWindowMessage("HwndWrapper.GetGCMemMessage");
}