|
#pragma warning disable 1634, 1691 // To enable presharp warning disables (#pragma suppress) below.
// --------------------------------------------------------------------------
//
// File: TextEditor.cs
//
// Copyright (C) Microsoft Corporation. All rights reserved.
//
// Description: Text editing service for controls.
//
//---------------------------------------------------------------------------
namespace System.Windows.Documents
{
using MS.Internal;
using System.Globalization;
using System.Threading;
using System.ComponentModel;
using System.Text;
using System.Collections; // ArrayList
using System.Runtime.InteropServices;
using System.Security;
using System.Security.Permissions;
using System.Windows.Threading;
using System.Windows.Input;
using System.Windows.Controls; // ScrollChangedEventArgs
using System.Windows.Controls.Primitives; // CharacterCasing, TextBoxBase
using System.Windows.Media;
using System.Windows.Markup;
using MS.Utility;
using MS.Win32;
using MS.Internal.Documents;
using MS.Internal.Commands; // CommandHelpers
/// <summary>
/// Text editing service for controls.
/// </summary>
internal class TextEditor
{
//------------------------------------------------------
//
// Constructors
//
//------------------------------------------------------
#region Constructors
/// <summary>
/// Initialize the TextEditor
/// </summary>
/// <param name="textContainer">
/// TextContainer representing a content to edit.
/// </param>
/// <param name="uiScope">
/// FrameworkElement on which all events for the user interaction will be
/// processed.
/// </param>
/// <param name="isUndoEnabled">
/// If true the TextEditor will enable undo support
/// </param>
internal TextEditor(ITextContainer textContainer, FrameworkElement uiScope, bool isUndoEnabled)
{
// Validate parameters
Invariant.Assert(uiScope != null);
// Set non-zero property defaults.
_acceptsRichContent = true;
// Attach the editor instance to the scope
_textContainer = textContainer;
_uiScope = uiScope;
// Enable undo manager for this uiScope
if (isUndoEnabled && _textContainer is TextContainer)
{
((TextContainer)_textContainer).EnableUndo(_uiScope);
}
// Create TextSelection and link it to text container
_selection = new TextSelection(this);
textContainer.TextSelection = _selection;
// Create DragDropProcess
//
_dragDropProcess = new TextEditorDragDrop._DragDropProcess(this);
// By default we use IBeam cursor
_cursor = Cursors.IBeam;
// Add InputLanguageChanged event handler
TextEditorTyping._AddInputLanguageChangedEventHandler(this);
// Listen to both TextContainer.EndChanging and TextContainer.Changed events
TextContainer.Changed += new TextContainerChangedEventHandler(OnTextContainerChanged);
// Add IsEnabled event handler for cleaning the caret element when uiScope is disabled
_uiScope.IsEnabledChanged += new DependencyPropertyChangedEventHandler(OnIsEnabledChanged);
// Attach this instance of text editor to its uiScope
_uiScope.SetValue(TextEditor.InstanceProperty, this);
// The IsSpellerEnabled property might have been set before this
// TextEditor was instantiated -- check if we need to rev
// up speller support.
if ((bool)_uiScope.GetValue(SpellCheck.IsEnabledProperty))
{
SetSpellCheckEnabled(true);
SetCustomDictionaries(true);
}
// If no IME/TextServices are installed, we have no native reasources
// to clean up at Finalizer.
if (!TextServicesLoader.ServicesInstalled)
{
GC.SuppressFinalize(this);
}
}
#endregion Constructors
//------------------------------------------------------
//
// Finalizer
//
//------------------------------------------------------
#region Finalizer
/// <summary>
/// The Finalizer will release the resources that were not released earlier.
/// </summary>
~TextEditor()
{
// Detach TextStore that TextStore will be unregisted from Cicero.
// And clean all reference of the native resources.
DetachTextStore(true /* finalizer */);
}
#endregion Finalizer
//------------------------------------------------------
//
// Internal Methods
//
//------------------------------------------------------
#region Internal Methods
/// <summary>
/// Notification that the EditBehavior is being removed from the
/// scope to which it was attached.
/// </summary>
/// <remarks>
/// innternal - ta make it accessible from TextEditor class.
/// </remarks>
/// <SecurityNote>
/// Critical - as this calls Critical method ImmComposition.GetImmComposition().
/// Safe - as this just gets the ImmComposition for the current element and invokes
/// the OnDetach event.
/// </SecurityNote>
[SecurityCritical, SecurityTreatAsSafe]
internal void OnDetach()
{
Invariant.Assert(_textContainer != null);
// Make sure the speller is shut down.
SetSpellCheckEnabled(false);
// Delete UndoManager
UndoManager undoManager = UndoManager.GetUndoManager(_uiScope);
if(undoManager != null)
{
if (_textContainer is TextContainer)
{
((TextContainer)_textContainer).DisableUndo(_uiScope);
}
else
{
UndoManager.DetachUndoManager(_uiScope);
}
}
// Release TextContainer
_textContainer.TextSelection = null;
// Remove InputLanguageChanged event handler
TextEditorTyping._RemoveInputLanguageChangedEventHandler(this);
// Remove both TextContainer.Changed event handlers
_textContainer.Changed -= new TextContainerChangedEventHandler(OnTextContainerChanged);
// Remove IsEnabled event handler that use for cleaning the caret element when uiScope is disabled
_uiScope.IsEnabledChanged -= new DependencyPropertyChangedEventHandler(OnIsEnabledChanged);
// Cancel any pending InitTextStore callback that might still
// be in the queue.
_pendingTextStoreInit = false;
// Shut down the Cicero.
DetachTextStore(false /* finalizer */);
// Shut down IMM32.
if (_immCompositionForDetach != null)
{
ImmComposition immComposition;
if (_immCompositionForDetach.TryGetTarget(out immComposition))
{
// _immComposition comes from getting of the focus on the editor with the enabled IMM.
// _immComposition.OnDetach will remove the events handler and then detach editor.
immComposition.OnDetach(this);
}
_immComposition = null;
_immCompositionForDetach = null;
}
// detach fromm textview
this.TextView = null;
// Delete selection object, caret and highlight
_selection.OnDetach();
_selection = null;
_uiScope.ClearValue(TextEditor.InstanceProperty);
_uiScope = null;
_textContainer = null;
}
/// <summary>
/// We don't need TextStore after Dispatcher is disposed.
/// DetachTextStore is called from Finalizer or UICntext.Dispose event callback.
/// Finalizer calls this to release Cicero's resources. Then we don't need
/// a call back from UIContex.Dispose any more. And we can release _weakThis.
/// </summary>
private void DetachTextStore(bool finalizer)
{
// We don't need this TextStore any more.
// TextStore needs to be unregisted from Cicero so clean all reference
// of the native resources.
if (_textstore != null)
{
_textstore.OnDetach(finalizer);
_textstore = null;
}
if (_weakThis != null)
{
_weakThis.StopListening();
_weakThis = null;
}
if (!finalizer)
{
// Cicero's resources have been released.
// We don't have to get Finalizer called now.
GC.SuppressFinalize(this);
}
}
// Worker method for set_IsSpellCheckEnabled.
// Note that enabling the spell checker is also gated on the IsReadOnly
// and IsEnabled properties of the current UiScope.
internal void SetSpellCheckEnabled(bool value)
{
value = value && !this.IsReadOnly && this._IsEnabled;
if (value && _speller == null)
{
// Start up the speller.
_speller = new Speller(this);
}
else if (!value && _speller != null)
{
// Shut down the speller.
_speller.Detach();
_speller = null;
}
}
/// <summary>
/// Loads custom dictionaries
/// </summary>
/// <param name="dictionaryLocations"></param>
/// <returns></returns>
internal void SetCustomDictionaries(bool add)
{
TextBoxBase textBoxBase = _uiScope as TextBoxBase;
// We want CustomDictionaries to take effect only on TextBoxBase derived classes.
if (textBoxBase == null)
{
return;
}
if (_speller != null)
{
CustomDictionarySources dictionarySources = (CustomDictionarySources)SpellCheck.GetCustomDictionaries(textBoxBase);
_speller.SetCustomDictionaries(dictionarySources, add);
}
}
// Forwards a spelling reform property change off to the speller.
internal void SetSpellingReform(SpellingReform spellingReform)
{
if (_speller != null)
{
_speller.SetSpellingReform(spellingReform);
}
}
// Queries a FrameworkElement for its TextView
internal static ITextView GetTextView(UIElement scope)
{
IServiceProvider serviceProvider = scope as IServiceProvider;
return (serviceProvider != null) ? serviceProvider.GetService(typeof(ITextView)) as ITextView : null;
}
// Maps a FrameworkElement to its TextSelection, if any.
internal static ITextSelection GetTextSelection(FrameworkElement frameworkElement)
{
TextEditor textEditor = TextEditor._GetTextEditor(frameworkElement);
return (textEditor == null) ? null : textEditor.Selection;
}
// Registers all text editing command handlers for a given control type
//
// If registerEventListeners is false, caller is responsible for calling OnXXXEvent methods on TextEditor from
// UIElement and FrameworkElement virtual overrides (piggy backing on the
// UIElement/FrameworkElement class listeners). If true, TextEditor will register
// its own class listener for events it needs.
//
// This method will always register private command listeners.
/// <SecurityNote>
/// Critical:This code register command handlers for texteditor related events and commands (OnGotFocus)
/// TreatAsSafe: This just hooks up methods that are internal to this class
/// </SecurityNote>
[SecurityCritical, SecurityTreatAsSafe]
internal static void RegisterCommandHandlers(Type controlType, bool acceptsRichContent, bool readOnly, bool registerEventListeners)
{
// Check if we already registered handlers for this type
Invariant.Assert(_registeredEditingTypes != null);
lock (_registeredEditingTypes)
{
for (int i = 0; i < _registeredEditingTypes.Count; i++)
{
// If controlType is or derives from some already registered class - we are done
if (((Type)_registeredEditingTypes[i]).IsAssignableFrom(controlType))
{
return;
}
// Check if controlType is not a superclass of some registered class.
// This is erroneus condition, which must be avoided.
// Otherwise the same handlers will be attached to some class twice.
if (controlType.IsAssignableFrom((Type)_registeredEditingTypes[i]))
{
throw new InvalidOperationException(
SR.Get(SRID.TextEditorCanNotRegisterCommandHandler, ((Type)_registeredEditingTypes[i]).Name, controlType.Name));
}
}
// The class was not yet registered. Add it to the list before starting registering handlers.
_registeredEditingTypes.Add(controlType);
}
// Mouse
TextEditorMouse._RegisterClassHandlers(controlType, registerEventListeners);
if (!readOnly)
{
// Typing
TextEditorTyping._RegisterClassHandlers(controlType, registerEventListeners);
}
// Drag-and-drop
TextEditorDragDrop._RegisterClassHandlers(controlType, readOnly, registerEventListeners);
// Cut-Copy-Paste
TextEditorCopyPaste._RegisterClassHandlers(controlType, acceptsRichContent, readOnly, registerEventListeners);
// Selection Commands
TextEditorSelection._RegisterClassHandlers(controlType, registerEventListeners);
if (!readOnly)
{
// Paragraph Formatting
TextEditorParagraphs._RegisterClassHandlers(controlType, acceptsRichContent, registerEventListeners);
}
// ContextMenu
TextEditorContextMenu._RegisterClassHandlers(controlType, registerEventListeners);
if (!readOnly)
{
// Spelling
TextEditorSpelling._RegisterClassHandlers(controlType, registerEventListeners);
}
if (acceptsRichContent && !readOnly)
{
// Character Formatting
TextEditorCharacters._RegisterClassHandlers(controlType, registerEventListeners);
// Editing Commands: List Editing
TextEditorLists._RegisterClassHandlers(controlType, registerEventListeners);
// Editing Commands: Table Editing
if (_isTableEditingEnabled)
{
TextEditorTables._RegisterClassHandlers(controlType, registerEventListeners);
}
}
// Focus
// -----
if (registerEventListeners)
{
EventManager.RegisterClassHandler(controlType, Keyboard.GotKeyboardFocusEvent, new KeyboardFocusChangedEventHandler(OnGotKeyboardFocus));
EventManager.RegisterClassHandler(controlType, Keyboard.LostKeyboardFocusEvent, new KeyboardFocusChangedEventHandler(OnLostKeyboardFocus));
EventManager.RegisterClassHandler(controlType, UIElement.LostFocusEvent, new RoutedEventHandler(OnLostFocus));
}
// Undo-Redo
// ---------
if (!readOnly)
{
CommandHelpers.RegisterCommandHandler(controlType, ApplicationCommands.Undo, new ExecutedRoutedEventHandler(OnUndo), new CanExecuteRoutedEventHandler(OnQueryStatusUndo), KeyGesture.CreateFromResourceStrings(SR.Get(SRID.KeyUndo), SR.Get(SRID.KeyUndoDisplayString)), KeyGesture.CreateFromResourceStrings(SR.Get(SRID.KeyAltUndo), SR.Get(SRID.KeyAltUndoDisplayString)));
CommandHelpers.RegisterCommandHandler(controlType, ApplicationCommands.Redo, new ExecutedRoutedEventHandler(OnRedo), new CanExecuteRoutedEventHandler(OnQueryStatusRedo), SRID.KeyRedo, SRID.KeyRedoDisplayString);
}
}
// Worker for TextBox/RichTextBox.GetSpellingErrorAtPosition.
internal SpellingError GetSpellingErrorAtPosition(ITextPointer position, LogicalDirection direction)
{
return TextEditorSpelling.GetSpellingErrorAtPosition(this, position, direction);
}
// Returns the error (if any) at the current selection.
internal SpellingError GetSpellingErrorAtSelection()
{
return TextEditorSpelling.GetSpellingErrorAtSelection(this);
}
// Worker for TextBox/RichTextBox.GetNextSpellingErrorPosition.
internal ITextPointer GetNextSpellingErrorPosition(ITextPointer position, LogicalDirection direction)
{
return TextEditorSpelling.GetNextSpellingErrorPosition(this, position, direction);
}
// Replaces a TextRange's content with a string.
// Applies LanguageProperty based on current input language.
//
internal void SetText(ITextRange range, string text, CultureInfo cultureInfo)
{
// Input text
range.Text = text;
// mark the range with the current input language on the start position.
if (range is TextRange)
{
MarkCultureProperty((TextRange)range, cultureInfo);
}
}
// Replaces the current selection with a string.
// Applies any springloaded properties to the text.
// Applies LanguageProperty based on current input language.
// Clears the cached caret X offset.
//
internal void SetSelectedText(string text, CultureInfo cultureInfo)
{
// Insert the text and tag it with culture property.
SetText(this.Selection, text, cultureInfo);
// Apply springload formatting
((TextSelection)this.Selection).ApplySpringloadFormatting();
// Forget previously suggested caret horizontal position.
TextEditorSelection._ClearSuggestedX(this);
}
/// <summary>
/// Used for marking the span of incoming text with input language
/// based on the current input language. The default input language is
/// designated in FrameworkElement.LanguageProperty which has the
/// default value of "en-US" but this can be changed at any tree node
/// by xml:lang attribute
/// </summary>
internal void MarkCultureProperty(TextRange range, CultureInfo inputCultureInfo)
{
//
Invariant.Assert(this.UiScope != null);
if (!this.AcceptsRichContent)
{
return;
}
// Get the current culture infomation to mark the input culture information
XmlLanguage language = (XmlLanguage)((ITextPointer)range.Start).GetValue(FrameworkElement.LanguageProperty);
Invariant.Assert(language != null);
// Compare the culture info between the current position and the input culture.
// Set the input culture info if the current has the different culture info with input.
if (!String.Equals(inputCultureInfo.IetfLanguageTag, language.IetfLanguageTag, StringComparison.OrdinalIgnoreCase))
{
range.ApplyPropertyValue(FrameworkElement.LanguageProperty, XmlLanguage.GetLanguage(inputCultureInfo.IetfLanguageTag));
}
// Get the input language's flow direction
FlowDirection inputFlowDirection;
if (inputCultureInfo.TextInfo.IsRightToLeft)
{
inputFlowDirection = FlowDirection.RightToLeft;
}
else
{
inputFlowDirection = FlowDirection.LeftToRight;
}
// Get the current flow direction
FlowDirection currentFlowDirection = (FlowDirection)((ITextPointer)range.Start).GetValue(FrameworkElement.FlowDirectionProperty);
// Set the FlowDirection property properly if the input language's flow direction
// doesn't match with the current flow direction.
if (currentFlowDirection != inputFlowDirection)
{
range.ApplyPropertyValue(FrameworkElement.FlowDirectionProperty, inputFlowDirection);
}
}
internal void RequestExtendSelection(Point point)
{
if (_mouseSelectionState == null)
{
_mouseSelectionState = new MouseSelectionState();
_mouseSelectionState.Timer = new DispatcherTimer(DispatcherPriority.Normal);
_mouseSelectionState.Timer.Tick += new EventHandler(HandleMouseSelectionTick);
// 400ms is the default value for MenuShowDelay. Creating timer with smaller value may
// cause Dispatcher queue starvation.
_mouseSelectionState.Timer.Interval = TimeSpan.FromMilliseconds(Math.Max(SystemParameters.MenuShowDelay, 200));
_mouseSelectionState.Timer.Start();
_mouseSelectionState.Point = point;
// Simulate the first Tick
HandleMouseSelectionTick(_mouseSelectionState.Timer, EventArgs.Empty);
}
else
{
_mouseSelectionState.Point = point;
}
}
internal void CancelExtendSelection()
{
if (_mouseSelectionState != null)
{
_mouseSelectionState.Timer.Stop();
_mouseSelectionState.Timer.Tick -= new EventHandler(HandleMouseSelectionTick);
_mouseSelectionState = null;
}
}
/// <summary>
/// Helper used to check if UiScope has a ToolTip which is open. If so, this method closes the tool tip.
/// KeyDown and MouseDown event handlers use this helper to check for this condition.
/// </summary>
internal void CloseToolTip()
{
PopupControlService popupControlService = PopupControlService.Current;
if (popupControlService.CurrentToolTip != null &&
popupControlService.CurrentToolTip.IsOpen &&
popupControlService.CurrentToolTip.PlacementTarget == _uiScope)
{
popupControlService.CurrentToolTip.IsOpen = false;
}
}
/// <summary>
/// Undo worker.
/// </summary>
/// <SecurityNote>
/// Critical:Calls Composition.Complete which has a link demand
/// TreatAsSafe: Does not expose the call
/// </SecurityNote>
[SecurityCritical, SecurityTreatAsSafe]
internal void Undo()
{
TextEditorTyping._FlushPendingInputItems(this);
// Complete the composition string before undo
CompleteComposition();
_undoState = UndoState.Undo;
bool forceLayoutUpdate = this.Selection.CoversEntireContent;
try
{
//
_selection.BeginChangeNoUndo();
try
{
UndoManager undoManager = _GetUndoManager();
if (undoManager != null && undoManager.UndoCount > undoManager.MinUndoStackCount)
{
undoManager.Undo(1);
}
// Forget previously suggested horizontal position
//
TextEditorSelection._ClearSuggestedX(this);
// Break typing merge for undo
TextEditorTyping._BreakTypingSequence(this);
// Clear springload formatting
if (_selection is TextSelection)
{
((TextSelection)_selection).ClearSpringloadFormatting();
}
}
finally
{
_selection.EndChange();
}
}
finally
{
_undoState = UndoState.Normal;
}
// If we replaced the entire document content, background layout will
// kick in. Force it to complete now.
if (forceLayoutUpdate)
{
this.Selection.ValidateLayout();
}
}
/// <summary>
/// Redo worker.
/// </summary>
internal void Redo()
{
TextEditorTyping._FlushPendingInputItems(this);
_undoState = UndoState.Redo;
bool forceLayoutUpdate = this.Selection.CoversEntireContent;
try
{
_selection.BeginChangeNoUndo();
try
{
UndoManager undoManager = _GetUndoManager();
if (undoManager != null && undoManager.RedoCount > 0)
{
undoManager.Redo(1);
}
// Forget previously suggested horizontal position
//
TextEditorSelection._ClearSuggestedX(this);
// Break typing merge for undo
TextEditorTyping._BreakTypingSequence(this);
// Clear springload formatting
if (_selection is TextSelection)
{
((TextSelection)_selection).ClearSpringloadFormatting();
}
}
finally
{
_selection.EndChange();
}
}
finally
{
_undoState = UndoState.Normal;
}
// If we replaced the entire document content, background layout will
// kick in. Force it to complete now.
if (forceLayoutUpdate)
{
this.Selection.ValidateLayout();
}
}
internal void OnPreviewKeyDown(KeyEventArgs e)
{
TextEditorTyping.OnPreviewKeyDown(_uiScope, e);
}
internal void OnKeyDown(KeyEventArgs e)
{
TextEditorTyping.OnKeyDown(_uiScope, e);
}
internal void OnKeyUp(KeyEventArgs e)
{
TextEditorTyping.OnKeyUp(_uiScope, e);
}
internal void OnTextInput(TextCompositionEventArgs e)
{
TextEditorTyping.OnTextInput(_uiScope, e);
}
internal void OnMouseDown(MouseButtonEventArgs e)
{
TextEditorMouse.OnMouseDown(_uiScope, e);
}
internal void OnMouseMove(MouseEventArgs e)
{
TextEditorMouse.OnMouseMove(_uiScope, e);
}
internal void OnMouseUp(MouseButtonEventArgs e)
{
TextEditorMouse.OnMouseUp(_uiScope, e);
}
internal void OnQueryCursor(QueryCursorEventArgs e)
{
TextEditorMouse.OnQueryCursor(_uiScope, e);
}
internal void OnQueryContinueDrag(QueryContinueDragEventArgs e)
{
TextEditorDragDrop.OnQueryContinueDrag(_uiScope, e);
}
internal void OnGiveFeedback(GiveFeedbackEventArgs e)
{
TextEditorDragDrop.OnGiveFeedback(_uiScope, e);
}
internal void OnDragEnter(DragEventArgs e)
{
TextEditorDragDrop.OnDragEnter(_uiScope, e);
}
internal void OnDragOver(DragEventArgs e)
{
TextEditorDragDrop.OnDragOver(_uiScope, e);
}
internal void OnDragLeave(DragEventArgs e)
{
TextEditorDragDrop.OnDragLeave(_uiScope, e);
}
internal void OnDrop(DragEventArgs e)
{
TextEditorDragDrop.OnDrop(_uiScope, e);
}
internal void OnContextMenuOpening(ContextMenuEventArgs e)
{
TextEditorContextMenu.OnContextMenuOpening(_uiScope, e);
}
internal void OnGotKeyboardFocus(KeyboardFocusChangedEventArgs e)
{
OnGotKeyboardFocus(_uiScope, e);
}
internal void OnLostKeyboardFocus(KeyboardFocusChangedEventArgs e)
{
OnLostKeyboardFocus(_uiScope, e);
}
internal void OnLostFocus(RoutedEventArgs e)
{
OnLostFocus(_uiScope, e);
}
#endregion Internal Methods
//------------------------------------------------------
//
// Internal Properties
//
//------------------------------------------------------
#region Internal Properties
//......................................................
//
// Dependency Properties
//
//......................................................
#region Dependency Properties
/// <summary>
/// IsReadOnly attached property speficies if the content within a scope
/// of some FrameworkElement is editable.
/// </summary>
internal static readonly DependencyProperty IsReadOnlyProperty =
DependencyProperty.RegisterAttached(
"IsReadOnly",
typeof(bool),
typeof(TextEditor),
new FrameworkPropertyMetadata(
false,
FrameworkPropertyMetadataOptions.Inherits,
new PropertyChangedCallback(OnIsReadOnlyChanged)));
/// <summary>
/// TextEditor.AllowOvertype property controls how TextEditor treats INS key.
/// When set to true INS key toggles overtype mode.
/// Otherwise it is ignored.
/// </summary>
/// <remarks>
///
internal static readonly DependencyProperty AllowOvertypeProperty =
DependencyProperty.RegisterAttached(
"AllowOvertype",
typeof(bool),
typeof(TextEditor),
new FrameworkPropertyMetadata(true));
/// <summary>
/// TextEditor.PageHeight attached property for pageup/down
/// </summary>
internal static readonly DependencyProperty PageHeightProperty =
DependencyProperty.RegisterAttached(
"PageHeight",
typeof(double),
typeof(TextEditor),
new FrameworkPropertyMetadata(0d));
#endregion Dependency Properties
//......................................................
//
// Properties - Relations With Other Components
//
//......................................................
#region Properties - Relations With Other Components
// The content TextContainer.
internal ITextContainer TextContainer
{
get
{
return _textContainer;
}
}
/// <summary>
/// A FrameworkElement to which this instance on TextEditor
/// is attached.
/// </summary>
/// <value></value>
internal FrameworkElement UiScope
{
get { return _uiScope; }
}
/// <summary>
/// A FrameworkElement to which this instance on TextEditor
/// is attached.
/// </summary>
/// <value></value>
internal ITextView TextView
{
get
{
return _textView;
}
set
{
if (value != _textView)
{
if (_textView != null)
{
// Remove layout updated handler.
_textView.Updated -= new EventHandler(OnTextViewUpdated);
_textView = null;
// Make sure that caret is destroyed for this text view (if any)
// This must be called after clearing _textView
_selection.UpdateCaretAndHighlight();
}
if (value != null)
{
_textView = value;
// Init a layout invalidation listener.
_textView.Updated += new EventHandler(OnTextViewUpdated);
// Make sure that caret is present for this text view
_selection.UpdateCaretAndHighlight();
}
}
}
}
/// <summary>
/// The TextSelection associated with this TextEditor.
/// </summary>
internal ITextSelection Selection
{
get { return _selection; }
}
// TextStore - needed in TextSelection to notify it about movements
//
internal TextStore TextStore
{
get { return _textstore; }
}
/// <summary>
/// ImmComposition implementation, used when _immEnabled.
/// </summary>
internal ImmComposition ImmComposition
{
get
{
return _immEnabled ? _immComposition : null;
}
}
#endregion Properties - Rlations With Other Components
//......................................................
//
// Properties - Text Editor Behavior Parameterization
//
//......................................................
#region Properties - Text Editor Behavior Parameterization
/// <summary>
/// If true, the TextEditor will accept the return/enter key,
/// otherwise it will be ignored. Default is true.
/// </summary>
internal bool AcceptsReturn
{
get
{
return _uiScope == null ? true : (bool)_uiScope.GetValue(KeyboardNavigation.AcceptsReturnProperty);
}
}
/// <summary>
/// If true, the TextEditor will accept the tab key, otherwise
/// it will be ignored. Default is true.
/// </summary>
internal bool AcceptsTab
{
get
{
return _uiScope == null ? true : (bool)_uiScope.GetValue(TextBoxBase.AcceptsTabProperty);
}
set
{
Invariant.Assert(_uiScope != null);
if (AcceptsTab != value)
{
_uiScope.SetValue(TextBoxBase.AcceptsTabProperty, value);
}
}
}
/// <summary>
/// If true, text selection will be enabled but the TextEditor will
/// not modify content. Default is false.
/// </summary>
/// <remarks>
/// Use TextSelection.HideCaret to stop the caret from rendering.
/// </remarks>
internal bool IsReadOnly
{
get
{
// We use local flag _isReadOnly for masking inheritable setting of IsReadOnly
if (_isReadOnly)
{
return true;
}
else
{
return _uiScope == null ? false : (bool)_uiScope.GetValue(TextEditor.IsReadOnlyProperty);
}
}
set
{
// This setting does not affect logical tree setting;
// it only applies to this particular editor.
// Nested editors be in editable or non-editable state
// independently on this flag.
_isReadOnly = value;
}
}
/// <summary>
/// Enables and disables spell checking on the document.
/// </summary>
/// <remarks>
/// Defaults to false.
/// </remarks>
internal bool IsSpellCheckEnabled
{
get
{
return _uiScope == null ? false : (bool)_uiScope.GetValue(SpellCheck.IsEnabledProperty);
}
set
{
Invariant.Assert(_uiScope != null);
_uiScope.SetValue(SpellCheck.IsEnabledProperty, value);
}
}
/// <summary>
/// If true, the TextEditor will accept xml markup for paragraphs and inline formatting.
/// Default is true.
/// </summary>
internal bool AcceptsRichContent
{
get
{
return _acceptsRichContent;
}
set
{
_acceptsRichContent = value;
}
}
/// <summary>
/// Clr accessor to AllowOvertypeProperty.
/// </summary>
internal bool AllowOvertype
{
get
{
return _uiScope == null ? true : (bool)_uiScope.GetValue(TextEditor.AllowOvertypeProperty);
}
}
/// <summary>
/// Maximum length of text being edited (_selection.Text). More precisely, the
/// user is not allowed to input text beyond this length.
/// Default is 0, which means unlimited.
/// </summary>
internal int MaxLength
{
get
{
return _uiScope == null ? 0 : (int)_uiScope.GetValue(TextBox.MaxLengthProperty);
}
}
/// <summary>
/// Controls whether input text is converted to upper or lower case.
/// Default is CharacterCasing.Normal, which causes no conversion.
/// </summary>
internal CharacterCasing CharacterCasing
{
get
{
return _uiScope == null ? CharacterCasing.Normal : (CharacterCasing)_uiScope.GetValue(TextBox.CharacterCasingProperty);
}
}
/// <summary>
/// Controls whether heuristics for selecting whole words on mouse drag are active
/// Default is false.
/// </summary>
internal bool AutoWordSelection
{
get
{
return _uiScope == null ? false : (bool)_uiScope.GetValue(RichTextBox.AutoWordSelectionProperty);
}
}
/// <summary>
/// Controls whether or not the caret is visible when the text editor is read-only.
/// Default is false.
/// </summary>
internal bool IsReadOnlyCaretVisible
{
get
{
return _uiScope == null ? false : (bool)_uiScope.GetValue(TextBoxBase.IsReadOnlyCaretVisibleProperty);
}
}
#endregion Properties - Text Editor Behavior Parameterization
// A property exposing our current undo context.
//
// UndoState.Undo while inside OnUndo or
// UndoState.Redo while inside OnRedo or
// UndoState.Normal otherwise.
internal UndoState UndoState
{
get
{
return _undoState;
}
}
// Flag that indicates whether the UiScope has a context menu open.
internal bool IsContextMenuOpen
{
get
{
return _isContextMenuOpen;
}
set
{
_isContextMenuOpen = value;
}
}
// Speller instance for TextEditorSpelling.
internal Speller Speller
{
get
{
return _speller;
}
}
#endregion Internal Properties
//------------------------------------------------------
//
// Class Internal Methods
//
//------------------------------------------------------
#region Class Internal Methods
// Maps a FrameworkElement to its TextEditor, if any.
internal static TextEditor _GetTextEditor(object element)
{
return (element is DependencyObject) ? (((DependencyObject)element).ReadLocalValue(InstanceProperty) as TextEditor) : null;
}
/// <summary>
/// Returns the UndoManager, if any, associated with this editor instance.
/// </summary>
internal UndoManager _GetUndoManager()
{
UndoManager undoManager = null;
if (this.TextContainer is TextContainer)
{
undoManager = ((TextContainer)this.TextContainer).UndoManager;
}
return undoManager;
}
/// <summary>
/// Filter input text based on MaxLength, and CharacterCasing.
/// </summary>
/// <param name="textData">
/// text to filter
/// </param>
/// <param name="range">
/// target range to be inserted or replaced
/// </param>
/// <returns>
/// filtered text
/// </returns>
internal string _FilterText(string textData, ITextRange range)
{
return _FilterText(textData, range.Start.GetOffsetToPosition(range.End));
}
internal string _FilterText(string textData, int charsToReplaceCount)
{
return _FilterText(textData, charsToReplaceCount, true);
}
internal string _FilterText(string textData, ITextRange range, bool filterMaxLength)
{
return _FilterText(textData, range.Start.GetOffsetToPosition(range.End), filterMaxLength);
}
internal string _FilterText(string textData, int charsToReplaceCount, bool filterMaxLength)
{
// We only filter text for plain text content
if (!this.AcceptsRichContent)
{
if (filterMaxLength && this.MaxLength > 0)
{
ITextContainer textContainer = this.TextContainer;
int currentLength = textContainer.SymbolCount - charsToReplaceCount;
int extraCharsAllowed = Math.Max(0, this.MaxLength - currentLength);
// Is there room to insert text?
if (extraCharsAllowed == 0)
{
return string.Empty;
}
// Does textData length exceed allowed char length?
if (textData.Length > extraCharsAllowed)
{
int splitPosition = extraCharsAllowed;
if (IsBadSplitPosition(textData, splitPosition))
{
splitPosition--;
}
textData = textData.Substring(0, splitPosition);
}
// Is there room for low surrogate?
if (textData.Length == extraCharsAllowed && Char.IsHighSurrogate(textData, extraCharsAllowed - 1))
{
textData = textData.Substring(0, extraCharsAllowed-1);
}
// Does the starting low surrogate have a matching high surrogate in the previously inserted content?
if (!string.IsNullOrEmpty(textData) && Char.IsLowSurrogate(textData, 0))
{
string textAdjacent = textContainer.TextSelection.AnchorPosition.GetTextInRun(LogicalDirection.Backward);
if (string.IsNullOrEmpty(textAdjacent) || !Char.IsHighSurrogate(textAdjacent, textAdjacent.Length - 1))
{
return string.Empty;
}
}
}
if (string.IsNullOrEmpty(textData))
{
return textData;
}
if (this.CharacterCasing == CharacterCasing.Upper)
{
// Get CultureInfo from the current input language for ToUpper/ToLower.
textData = textData.ToUpper(InputLanguageManager.Current.CurrentInputLanguage);
}
else if (this.CharacterCasing == CharacterCasing.Lower)
{
// Get CultureInfo from the current input language for ToUpper/ToLower.
textData = textData.ToLower(InputLanguageManager.Current.CurrentInputLanguage);
}
if (!this.AcceptsReturn)
{
int endOfFirstLine = textData.IndexOf(Environment.NewLine, StringComparison.Ordinal);
if (endOfFirstLine >= 0)
{
textData = textData.Substring(0, endOfFirstLine);
}
endOfFirstLine = textData.IndexOfAny(TextPointerBase.NextLineCharacters);
if (endOfFirstLine >= 0)
{
textData = textData.Substring(0, endOfFirstLine);
}
}
if (!this.AcceptsTab)
{
textData = textData.Replace('\t', ' ');
}
}
return textData;
}
// This checks if the source is in UiScope or its style.
// The key events or text input events should not be handled if the source is out side of
// element (or style).
// For example, when focus elment is UiScope's context menu,
// TextEditor should ignore those events.
internal bool _IsSourceInScope(object source)
{
if (source == this.UiScope)
{
return true;
}
if ((source is FrameworkElement) && ((FrameworkElement)source).TemplatedParent == this.UiScope)
{
return true;
}
return false;
}
/// <summary>
/// Complete the composition string.
/// </summary>
internal void CompleteComposition()
{
if (TextStore != null)
{
TextStore.CompleteComposition();
}
if (ImmComposition != null)
{
ImmComposition.CompleteComposition();
}
}
#endregion Class Internal Methods
//------------------------------------------------------
//
// Class Internal Properties
//
//------------------------------------------------------
#region Class Internal Properties
/// <summary>
/// Returns true if the IsEnabled ptorperty is set to true for ui scope of the editor.
/// </summary>
internal bool _IsEnabled
{
get
{
return _uiScope == null ? false : _uiScope.IsEnabled;
}
}
internal bool _OvertypeMode
{
get
{
return _overtypeMode;
}
set
{
_overtypeMode = value;
}
}
// Find the scroller from the render scope of TextEdior
internal FrameworkElement _Scroller
{
get
{
FrameworkElement scroller = this.TextView == null ? null : (this.TextView.RenderScope as FrameworkElement);
while (scroller != null && scroller != this.UiScope)
{
scroller = FrameworkElement.GetFrameworkParent(scroller) as FrameworkElement;
if (scroller is ScrollViewer || scroller is ScrollContentPresenter)
{
return scroller;
}
}
return null;
}
}
// TLS for TextEditor and dependent classes.
//
// Note we demand allocate, but then never clear the TLS slot.
// This means we will leak one TextEditorThreadLocalStore per
// thread if TextEditors are allocated then freed on the thread.
// The alternative, ref counting the TLS, would require a finalizer
// which is at least as expensive as one object per thread, and
// much more complicated.
internal static TextEditorThreadLocalStore _ThreadLocalStore
{
get
{
TextEditorThreadLocalStore store;
store = (TextEditorThreadLocalStore)Thread.GetData(_threadLocalStoreSlot);
if (store == null)
{
store = new TextEditorThreadLocalStore();
Thread.SetData(_threadLocalStoreSlot, store);
}
return store;
}
}
// Content change counter
internal long _ContentChangeCounter
{
get
{
return _contentChangeCounter;
}
}
// Enables or disables table editing commands.
// False by default, only enabled via reflection for lexicon.exe in V1.
internal static bool IsTableEditingEnabled
{
get
{
return _isTableEditingEnabled;
}
set
{
_isTableEditingEnabled = value;
}
}
// Cached position used to restore selection moving position
// after colliding with document start or end handling
// SelectUp/DownByLine commands.
internal ITextPointer _NextLineAdvanceMovingPosition
{
get
{
return _nextLineAdvanceMovingPosition;
}
set
{
_nextLineAdvanceMovingPosition = value;
}
}
// If true _nextLineAdvanceMovingPosition represents a position at the head
// of the document (stored in response to a OnSelectUpByLineCommand). Otherwise,
// _nextLineAdvanceMovingPosition represents a position at the tail
// of the document (stored in response to a OnSelectDownByLineCommand).
internal bool _IsNextLineAdvanceMovingPositionAtDocumentHead
{
get
{
return _isNextLineAdvanceMovingPositionAtDocumentHead;
}
set
{
_isNextLineAdvanceMovingPositionAtDocumentHead = value;
}
}
#endregion Class Internal Properties
//------------------------------------------------------
//
// Private Methods
//
//------------------------------------------------------
#region Private Methods
//......................................................
//
// Misceleneous
//
//......................................................
/// <summary>
/// Helper for _FilterText().
/// Inspects if text[position-1] and text[position] form a surrogate pair or Environment.NewLine.
/// <param name="text">Input string to inspect.</param>
/// <param name="position">Split position.</param>
/// <returns>True if bad split position, false otherwise.</returns>
/// </summary>
private bool IsBadSplitPosition(string text, int position)
{
//
if ((text[position - 1] == '\r' && text[position] == '\n')
||
(Char.IsHighSurrogate(text, position - 1) && Char.IsLowSurrogate(text, position)))
{
return true;
}
return false;
}
private void HandleMouseSelectionTick(object sender, EventArgs e)
{
if (_mouseSelectionState != null && !_mouseSelectionState.BringIntoViewInProgress &&
this.TextView != null && this.TextView.IsValid && TextEditorSelection.IsPaginated(this.TextView))
{
_mouseSelectionState.BringIntoViewInProgress = true;
this.TextView.BringPointIntoViewCompleted += new BringPointIntoViewCompletedEventHandler(HandleBringPointIntoViewCompleted);
this.TextView.BringPointIntoViewAsync(_mouseSelectionState.Point, this);
}
}
/// <summary>
/// Handler for ITextView.BringPointIntoViewCompleted event.
/// </summary>
private void HandleBringPointIntoViewCompleted(object sender, BringPointIntoViewCompletedEventArgs e)
{
ITextPointer cursorPosition;
Rect lastCharacterRect;
Invariant.Assert(sender is ITextView);
((ITextView)sender).BringPointIntoViewCompleted -= new BringPointIntoViewCompletedEventHandler(HandleBringPointIntoViewCompleted);
// If the mouse selection state is not available, it means that the mouse was
// already released. It may happen when there is delay in view transitions
// (i.e. page transition in DocumentViewerBase).
// In such case ignore this event.
if (_mouseSelectionState == null)
{
return;
}
_mouseSelectionState.BringIntoViewInProgress = false;
if (e != null && !e.Cancelled && e.Error == null)
{
Invariant.Assert(e.UserState == this && this.TextView == sender);
cursorPosition = e.Position;
if (cursorPosition != null)
{
// Check end-of-container condition
if (cursorPosition.GetNextInsertionPosition(LogicalDirection.Forward) == null &&
cursorPosition.ParentType != null) //
{
// We are at the end of text container. Check whether mouse is farther than a last character
lastCharacterRect = cursorPosition.GetCharacterRect(LogicalDirection.Backward);
if (e.Point.X > lastCharacterRect.X + lastCharacterRect.Width)
{
cursorPosition = this.TextContainer.End;
}
}
// Move the caret/selection to match the cursor position.
this.Selection.ExtendSelectionByMouse(cursorPosition, _forceWordSelection, _forceParagraphSelection);
}
else
{
CancelExtendSelection();
}
}
else
{
CancelExtendSelection();
}
}
// This method is called asynchronously after the first layout update.
/// <SecurityNote>
/// Critical: Calls critical code (TextServicesLoader.Load)
/// TreatAsSafe: Queries for the TSF thread manager, a safe operation
/// </SecurityNote>
[SecurityCritical, SecurityTreatAsSafe]
private object InitTextStore(object o)
{
// We might have been detached before this callback got dispatched.
if (!_pendingTextStoreInit)
{
return null;
}
// Init a TSF TextStore if any TIPs/IMEs are installed.
if (_textContainer is TextContainer && TextServicesHost.Current != null)
{
// We need to make sure we get back a valid thread manager first since it's possible for
// TextServicesLoader.ServicesInstalled to return true without TSF being usable.
UnsafeNativeMethods.ITfThreadMgr threadManager = TextServicesLoader.Load();
if (threadManager != null)
{
// Demand create the TextStore.
if (_textstore == null)
{
_textstore = new TextStore(this);
_weakThis = new TextEditorShutDownListener(this);
}
_textstore.OnAttach();
Marshal.ReleaseComObject(threadManager);
}
}
_pendingTextStoreInit = false;
return null;
}
// ................................................................
//
// Event Handlers: Internal Events
//
// ................................................................
/// <summary>
/// Handler for TextContainer.Changed event.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void OnTextContainerChanged(object sender, TextContainerChangedEventArgs e)
{
// Set short short-term dirty indicator to true.
// The indicator is used in TextEditorMouse.MoveFocusToUiScope to check
// that there is no side effects happened in content during focus movement
this._contentChangeCounter++;
}
// TextView.Updated event handler.
private void OnTextViewUpdated(object sender, EventArgs e)
{
// The TextSelection needs to know about the change now.
_selection.OnTextViewUpdated();
// The TextView calls this method synchronously, before it finishes its Arrange
// pass, so defer the remaining work until the TextView is valid.
this.UiScope.Dispatcher.BeginInvoke(DispatcherPriority.Normal, new DispatcherOperationCallback(OnTextViewUpdatedWorker), EventArgs.Empty);
if (!_textStoreInitStarted)
{
Dispatcher.CurrentDispatcher.BeginInvoke(DispatcherPriority.Background, new DispatcherOperationCallback(InitTextStore), null);
_pendingTextStoreInit = true;
_textStoreInitStarted = true;
}
}
// Responds to OnTextViewUpdated calls.
private object OnTextViewUpdatedWorker(object o)
{
// Ignore the event if the editor has been detached from its scope
if (this.TextView == null)
{
return null;
}
if (_textstore != null)
{
_textstore.OnLayoutUpdated();
}
// IMM32's OnLostFocus handler. Clean the composition string if it exists.
if (_immEnabled)
{
if (_immComposition != null)
{
_immComposition.OnLayoutUpdated();
}
}
return null;
}
// IsEnabledChanged event handler for cleaning the caret element when uiScope is disabled.
private static void OnIsEnabledChanged(object sender, DependencyPropertyChangedEventArgs e)
{
TextEditor This = TextEditor._GetTextEditor((FrameworkElement)sender);
if (This == null)
{
return;
}
This._selection.UpdateCaretAndHighlight();
// Update the speller checker status.
This.SetSpellCheckEnabled(This.IsSpellCheckEnabled);
This.SetCustomDictionaries(This.IsSpellCheckEnabled);
}
// Callback for chagnes to the IsReadOnly property.
private static void OnIsReadOnlyChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
{
FrameworkElement frameworkElement = sender as FrameworkElement;
if (frameworkElement == null)
{
return;
}
TextEditor This = TextEditor._GetTextEditor(frameworkElement);
if (This == null)
{
return;
}
// Update the spell check status.
This.SetSpellCheckEnabled(This.IsSpellCheckEnabled);
// Finalize any active IME composition when transitioning to true.
if ((bool)e.NewValue == true && This._textstore != null)
{
This._textstore.CompleteCompositionAsync();
}
}
// ................................................................
//
// Focus
//
// ................................................................
// GotKeyboardFocusEvent handler.
/// <SecurityNote>
/// Critical - adjusts internal state dealing with focus (including notifying
/// unmanaged IME about this)
/// Safe - exposes no state, passes no state to the IME.
/// </SecurityNote>
[SecurityCritical, SecurityTreatAsSafe]
private static void OnGotKeyboardFocus(object sender, KeyboardFocusChangedEventArgs e)
{
// Ignore the event if the sender is not new focus element.
if (sender != e.NewFocus)
{
return;
}
TextEditor This = TextEditor._GetTextEditor((FrameworkElement)sender);
if (This == null)
{
return;
}
// Ignore the event if the editor has been detached from its scope
// or if the element getting focus isn't our uiScope (in which case, it's our child)
if (!This._IsEnabled)
{
return;
}
// Cicero's OnGotKeyboardFocus handler. It updates the focus DIM.
if (This._textstore != null)
{
This._textstore.OnGotFocus();
}
// IMM32's OnGotFocus handler. Ready for the composition string.
if (_immEnabled)
{
This._immComposition = ImmComposition.GetImmComposition(This._uiScope);
if (This._immComposition != null)
{
This._immCompositionForDetach = new WeakReference<ImmComposition>(This._immComposition);
This._immComposition.OnGotFocus(This);
}
else
{
This._immCompositionForDetach = null;
}
}
// Redraw the caret to show the BiDi/normal caret.
This._selection.RefreshCaret();
// Make selection visible
// Note: Do not scroll to bring caret into view upon GotKeyboardFocus.
This._selection.UpdateCaretAndHighlight();
}
// LostKeyboardFocusEvent handler
//
// Stop the caret from blinking
/// <SecurityNote>
/// Critical - manipulates focus, including calling critical method (GetImmComposition)
/// Safe - exposes no state, passes no state to the IME.
/// </SecurityNote>
[SecurityCritical, SecurityTreatAsSafe]
private static void OnLostKeyboardFocus(object sender, KeyboardFocusChangedEventArgs e)
{
// Ignore the event if the sender is not old focus element.
if (sender != e.OldFocus)
{
return;
}
TextEditor This = TextEditor._GetTextEditor((FrameworkElement)sender);
if (This == null)
{
return;
}
// Ignore the event if the editor has been detached from its scope
// or the element losing focus isn't our uiScope (in which case, it's our child)
if (!This._IsEnabled)
{
return;
}
// Note: Do not scroll to bring caret into view upon LostKeyboardFocus.
This._selection.UpdateCaretAndHighlight();
// Call the TextStore's OnLostfocus handler. Finalizes the curernt composition, if any.
if (This._textstore != null)
{
This._textstore.OnLostFocus();
}
// IMM32's OnLostFocus handler. Clean the composition string if it exists.
if (_immEnabled)
{
if (This._immComposition != null)
{
// Call ImmComposition OnLostFocus to clean up the event handler(SelectionChanged).
This._immComposition.OnLostFocus();
// Set _immComposition as null not to access it until get new from the getting focus.
This._immComposition = null;
}
}
}
// LostFocusedElementEvent handler.
private static void OnLostFocus(object sender, RoutedEventArgs e)
{
TextEditor This = TextEditor._GetTextEditor((FrameworkElement)sender);
if (This == null)
{
return;
}
// Un-vanish the cursor.
TextEditorTyping._ShowCursor();
// Ignore the event if the editor has been detached from its scope
// or the element losing focus isn't our uiScope (in which case, it's our child)
if (!This._IsEnabled)
{
return;
}
// Flush input queue and complete typing undo unit
TextEditorTyping._FlushPendingInputItems(This);
TextEditorTyping._BreakTypingSequence(This);
// Release column resizing adorner, and interrupt table resising process (if any)
if (This._tableColResizeInfo != null)
{
This._tableColResizeInfo.DisposeAdorner();
This._tableColResizeInfo = null;
}
// Hide selection
This._selection.UpdateCaretAndHighlight();
}
// ................................................................
//
// Undo-Redo
//
// ................................................................
/// <summary>
/// Undo command event handler.
/// </summary>
private static void OnUndo(object target, ExecutedRoutedEventArgs args)
{
TextEditor This = TextEditor._GetTextEditor((FrameworkElement)target);
if (This == null)
{
return;
}
// Ignore the event if the editor has been detached from its scope
if (!This._IsEnabled)
{
return;
}
if (This.IsReadOnly)
{
return;
}
This.Undo();
}
/// <summary>
/// Redo command event handler.
/// </summary>
private static void OnRedo(object target, ExecutedRoutedEventArgs args)
{
TextEditor This = TextEditor._GetTextEditor((FrameworkElement)target);
if (This == null)
{
return;
}
// Ignore the event if the editor has been detached from its scope
if (!This._IsEnabled)
{
return;
}
if (This.IsReadOnly)
{
return;
}
This.Redo();
}
/// <summary>
/// Undo command QueryStatus handler.
/// </summary>
private static void OnQueryStatusUndo(object sender, CanExecuteRoutedEventArgs args)
{
TextEditor This = TextEditor._GetTextEditor((FrameworkElement)sender);
if (This == null)
{
return;
}
UndoManager undoManager = This._GetUndoManager();
if (undoManager != null && undoManager.UndoCount > undoManager.MinUndoStackCount)
{
args.CanExecute = true;
}
}
/// <summary>
/// Redo command QueryStatus handler.
/// </summary>
private static void OnQueryStatusRedo(object sender, CanExecuteRoutedEventArgs args)
{
TextEditor This = TextEditor._GetTextEditor((FrameworkElement)sender);
if (This == null)
{
return;
}
UndoManager undoManager = This._GetUndoManager();
if (undoManager != null && undoManager.RedoCount > 0)
{
args.CanExecute = true;
}
}
#endregion Private methods
//------------------------------------------------------
//
// Private Types
//
//------------------------------------------------------
#region Private Types
// We need to an event handler for Dispatcher's Dispose but we don't want to have
// a strong referrence fromDispatcher. So TextEditorShutDownListener wraps this.
private sealed class TextEditorShutDownListener : ShutDownListener
{
/// <SecurityNote>
/// Critical: accesses AppDomain.DomainUnload event
/// TreatAsSafe: This code does not take any parameter or return state.
/// It simply attaches private callbacks.
/// </SecurityNote>
[SecurityCritical,SecurityTreatAsSafe]
public TextEditorShutDownListener(TextEditor target)
: base(target, ShutDownEvents.DomainUnload | ShutDownEvents.DispatcherShutdown)
{
}
internal override void OnShutDown(object target, object sender, EventArgs e)
{
TextEditor editor = (TextEditor)target;
editor.DetachTextStore(false /* finalizer */);
}
}
private class MouseSelectionState
{
internal DispatcherTimer Timer;
internal Point Point;
internal bool BringIntoViewInProgress;
}
#endregion Private Types
//------------------------------------------------------
//
// Private Fields
//
//------------------------------------------------------
#region Private Fields
// Attached property used to map FrameworkElement arguments
// to command handlers back to TextEditor instances.
private static readonly DependencyProperty InstanceProperty = DependencyProperty.RegisterAttached( //
"Instance", typeof(TextEditor), typeof(TextEditor), //
new FrameworkPropertyMetadata((object)null));
//
internal Dispatcher _dispatcher;
// Read-only setting for this level of an editor.
// This flag is supposed to mask inheritable IsReadOnly property when set to true.
// When the flag is false we are supposed to get IsReadOnly from UIScope
private bool _isReadOnly;
// Register for classes to which we already added static command handlers
private static ArrayList _registeredEditingTypes = new ArrayList(4);
// TextConatiner representing a text subject to editing
private ITextContainer _textContainer;
// Content change counter is supposed to be used in various
// dirty-condition detection scenarios.
// In particular, it is used in TextEditorMouse.MoveFocusToUiScope to check
// that there is no side effects happened in content during focus movement
private long _contentChangeCounter;
// Control to which this editor is attached
private FrameworkElement _uiScope;
private ITextView _textView;
// TextSelection maintained within this _uiScope
private ITextSelection _selection;
// Flag turned true to indicate overtype mode
private bool _overtypeMode;
// Preserved horizontal position for verical caret movement
internal Double _suggestedX;
// ITextStoreACP implementation, used when text services (IMEs, etc.)
// are available.
private TextStore _textstore;
// We need to an event handler for Dispatcher's Dispose but we don't want to have
// a strong referrence fromDispatcher. So TextEditorShutDownListener wraps this.
private TextEditorShutDownListener _weakThis;
// The speller. If null, spell check is not enabled.
private Speller _speller;
// Flag set true after scheduling a callback to InitTextStore.
private bool _textStoreInitStarted;
// If true, we're waiting for the Dispatcher to dispatch a callback
// to InitTextStore.
private bool _pendingTextStoreInit;
// Mouse cursor defined in MouseMove handler to be used in OnQueryCursor method
internal Cursor _cursor;
// Merged typing undo unit.
// Undo unit creation is nontrivial here:
// It requires a logic for merging consequtive typing.
// For that purpose we store a unit created by typing and reopen it
// when next typing occurs.
// We should however discard this unit each time when selection
// moves to another position.
//
internal IParentUndoUnit _typingUndoUnit;
// An object for storing dragdrop state during dragging
internal TextEditorDragDrop._DragDropProcess _dragDropProcess;
internal bool _forceWordSelection;
internal bool _forceParagraphSelection;
// Resizing operation information for table column
internal TextRangeEditTables.TableColumnResizeInfo _tableColResizeInfo;
// Tracking whether or not a given change is part of an undo or redo
private UndoState _undoState = UndoState.Normal;
// If true, the TextEditor will accept xml markup for paragraphs and inline formatting.
// Default is true.
private bool _acceptsRichContent;
// If the system is IMM enabled, this is true.
private static bool _immEnabled = SafeSystemMetrics.IsImmEnabled ;
// ImmComposition implementation, used when _immEnabled.
private ImmComposition _immComposition;
// Weak-ref to the most recent ImmComposition - used when detaching
private WeakReference<ImmComposition> _immCompositionForDetach;
// Thread local storage for TextEditor and dependent classes.
private static LocalDataStoreSlot _threadLocalStoreSlot = Thread.AllocateDataSlot();
// Flag indicating that MouseDown handler is in progress,
// to ignore all MouseMoves caused by CaptureMouse call.
internal bool _mouseCapturingInProgress;
// Mouse selection support.
private MouseSelectionState _mouseSelectionState;
// Flag that indicates whether the UiScope has a context menu open.
// This flag is set/reset in ContextMenuOpening/ContextMenuClosing event handlers
// respectively in TextEditorContextMenu.cs.
// TextSelection.UpdateCaretAndHighlight() uses this flag to detect the case
// when the UiScope has a context menu open.
private bool _isContextMenuOpen;
// Enables or disables table editing commands.
// False by default, only enabled via reflection for lexicon.exe in V1.
private static bool _isTableEditingEnabled;
// Cached position used to restore selection moving position
// after colliding with document start or end handling
// SelectUp/DownByLine commands.
private ITextPointer _nextLineAdvanceMovingPosition;
// If true _nextLineAdvanceMovingPosition represents a position at the head
// of the document (stored in response to a OnSelectUpByLineCommand). Otherwise,
// _nextLineAdvanceMovingPosition represents a position at the tail
// of the document (stored in response to a OnSelectDownByLineCommand).
internal bool _isNextLineAdvanceMovingPositionAtDocumentHead;
#endregion Private Fields
}
}
|