// Token: 0x06002BA8 RID: 11176 RVA: 0x000C7340 File Offset: 0x000C5540
void ITextContainer.EndChange(bool skipEvents)
{
Invariant.Assert(this._changeBlockLevel > 0, "Unmatched EndChange call!");
this._changeBlockLevel--;
if (this._changeBlockLevel == 0 && this._changes != null)
{
TextContainerChangedEventArgs changes = this._changes;
this._changes = null;
if (this.Changed != null && !skipEvents)
{
this.Changed(this, changes);
}
}
}
private void AddChange(ITextPointer startPosition, int symbolCount, PrecursorTextChangeType precursorTextChange)
{
Invariant.Assert(!_isReadOnly, "Illegal to modify DocumentSequenceTextContainer inside Change event scope!");
ITextContainer textContainer = (ITextContainer)this;
textContainer.BeginChange();
try
{
// Contact any listeners.
if (this.Changing != null)
{
Changing(this, EventArgs.Empty);
}
// Fire the ChangingEvent now if we haven't already.
if (_changes == null)
{
_changes = new TextContainerChangedEventArgs();
}
_changes.AddChange(precursorTextChange, DocumentSequenceTextPointer.GetOffsetToPosition(_start, startPosition), symbolCount, false /* collectTextChanges */);
if (this.Change != null)
{
Invariant.Assert(precursorTextChange == PrecursorTextChangeType.ContentAdded || precursorTextChange == PrecursorTextChangeType.ContentRemoved);
TextChangeType textChange = (precursorTextChange == PrecursorTextChangeType.ContentAdded) ?
TextChangeType.ContentAdded : TextChangeType.ContentRemoved;
_isReadOnly = true;
try
{
// Pass in a -1 for charCount parameter. DocumentSequenceTextContainer
// doesn't support this feature because it is only consumed by IMEs
// which never run on read-only documents.
Change(this, new TextContainerChangeEventArgs(startPosition, symbolCount, -1, textChange));
}
finally
{
_isReadOnly = false;
}
}
}
finally
{
textContainer.EndChange();
}
}
/// <summary>
/// Handler for TextContainer.Changed event. Raises the TextChanged event on UiScope.
/// for editing controls.
/// </summary>
/// <param name="sender">
/// sender
/// </param>
/// <param name="e">
/// event args
/// </param>
internal virtual void OnTextContainerChanged(object sender, TextContainerChangedEventArgs e)
{
// If only properties on the text changed, don't fire a content change event.
// This can happen even in a plain text TextBox if we switch logical trees.
if (!e.HasContentAddedOrRemoved && !e.HasLocalPropertyValueChange)
{
return;
}
UndoManager undoManager = UndoManager.GetUndoManager(this);
UndoAction undoAction;
if (undoManager != null) // Will be null for controls like PasswordBox that don't use undo.
{
if (_textEditor.UndoState == UndoState.Redo)
{
undoAction = UndoAction.Redo;
}
else if (_textEditor.UndoState == UndoState.Undo)
{
undoAction = UndoAction.Undo;
}
else if (undoManager.OpenedUnit == null)
{
undoAction = UndoAction.Clear;
}
else if (undoManager.LastReopenedUnit == undoManager.OpenedUnit)
{
undoAction = UndoAction.Merge;
}
else
{
undoAction = UndoAction.Create;
}
}
else
{
undoAction = UndoAction.Create;
}
// The undo stack hasn't yet been modified by this change, so CanUndo will not
// necessarily yield the correct result if queried during the TextChange event.
// Store the undo action in the uiScope, so CanUndo can
// reference it to provide the correct result.
_pendingUndoAction = undoAction;
try
{
OnTextChanged(new TextChangedEventArgs(TextChangedEvent, undoAction, new ReadOnlyCollection<TextChange>(e.Changes.Values)));
}
finally
{
_pendingUndoAction = UndoAction.None;
}
}
/// <summary>
/// Handler for text array change notifications.
/// </summary>
/// <param name="sender">
/// sender
/// </param>
/// <param name="e">
/// event args
/// </param>
private void OnTextContainerChanged(object sender, TextContainerChangedEventArgs e)
{
// If only properties on the text changed, don't fire a content change event.
// This can happen even in a plain text TextBox if we switch logical trees.
if (!e.HasContentAddedOrRemoved)
{
return;
}
RaiseEvent(new RoutedEventArgs(PasswordChangedEvent));
}
//-----------------------------------------------------
//
// Private Methods
//
//-----------------------------------------------------
#region Private Methods
private void AddChange(ITextPointer startPosition, int symbolCount, PrecursorTextChangeType precursorTextChange)
{
Invariant.Assert(_changeBlockLevel > 0, "All public APIs must call BeginChange!");
Invariant.Assert(!_isReadOnly, "Illegal to modify PasswordTextContainer inside Change event scope!");
// Contact any listeners.
if (this.Changing != null)
{
Changing(this, EventArgs.Empty);
}
// Fire the ChangingEvent now if we haven't already.
if (_changes == null)
{
_changes = new TextContainerChangedEventArgs();
}
_changes.AddChange(precursorTextChange, startPosition.Offset, symbolCount, false /* collectTextChanges */);
if (this.Change != null)
{
Invariant.Assert(precursorTextChange == PrecursorTextChangeType.ContentAdded || precursorTextChange == PrecursorTextChangeType.ContentRemoved);
TextChangeType textChange = (precursorTextChange == PrecursorTextChangeType.ContentAdded) ?
TextChangeType.ContentAdded : TextChangeType.ContentRemoved;
_isReadOnly = true;
try
{
Change(this, new TextContainerChangeEventArgs(startPosition, symbolCount, symbolCount, textChange));
}
finally
{
_isReadOnly = false;
}
}
}
/// <summary>
/// Handler for TextContainer.Changed event.
/// </summary>
internal override void OnTextContainerChanged(object sender, TextContainerChangedEventArgs e)
{
bool resetText = false;
string newTextValue = null;
try
{
// if there are re-entrant changes, only raise public events
// after the outermost change completes
_changeEventNestingCount++;
// Ignore property changes that originate from OnTextPropertyChange.
if (!_isInsideTextContentChange)
{
_isInsideTextContentChange = true;
// Use a DeferredTextReference instead of calculating the new
// value now for better performance. Most of the time no
// one cares what the new value is, and loading our content into a
// string can be extremely expensive.
DeferredTextReference dtr = new DeferredTextReference(this.TextContainer);
_newTextValue = dtr;
SetCurrentDeferredValue(TextProperty, dtr);
}
}
finally
{
_changeEventNestingCount--;
if (_changeEventNestingCount == 0)
{
// when Text is data-bound, _newTextValue is converted from a
// deferred reference to a string. The binding writes the string
// back to the source, then computes a new value for Text (which
// may be different, either because the source normalizes the value
// or because of conversion and formatting). Usually this raises
// a change notification for Text, which brings the Text property and
// the text container into [....]. But this doesn't happen in one
// case: when the normalized value is the same as the original
// value for Text. The property engine thinks that Text hasn't
// changed, and doesn't raise the notification. It's true that
// Text hasn't changed, but we still need to update the text container,
// which now displays the wrong value.
// We detect that case by checking whether _newTextValue (the
// text container value) agrees with Text.
if (FrameworkCompatibilityPreferences.GetKeepTextBoxDisplaySynchronizedWithTextProperty())
{
newTextValue = _newTextValue as String;
resetText = (newTextValue != null && newTextValue != Text);
}
_isInsideTextContentChange = false;
_newTextValue = DependencyProperty.UnsetValue;
}
}
if (resetText)
{
// The text container holds a new value which round-trips to the
// old value of Text. We need to bring the text container into [....].
try
{
_newTextValue = newTextValue;
_isInsideTextContentChange = true;
++ _changeEventNestingCount;
OnTextPropertyChanged(newTextValue, Text);
}
finally
{
-- _changeEventNestingCount;
_isInsideTextContentChange = false;
_newTextValue = DependencyProperty.UnsetValue;
}
}
if (_changeEventNestingCount == 0)
{
// Let base raise the public TextBoxBase.TextChanged event.
base.OnTextContainerChanged(sender, e);
}
}
private void AddChange(ITextPointer startPosition, int symbolCount, PrecursorTextChangeType precursorTextChange)
{
Invariant.Assert(!_isReadOnly, "Illegal to modify DocumentSequenceTextContainer inside Change event scope!");
ITextContainer textContainer = (ITextContainer)this;
textContainer.BeginChange();
try
{
// Contact any listeners.
if (this.Changing != null)
{
Changing(this, EventArgs.Empty);
}
// Fire the ChangingEvent now if we haven't already.
if (_changes == null)
{
_changes = new TextContainerChangedEventArgs();
}
_changes.AddChange(precursorTextChange, DocumentSequenceTextPointer.GetOffsetToPosition(_start, startPosition), symbolCount, false /* collectTextChanges */);
if (this.Change != null)
{
Invariant.Assert(precursorTextChange == PrecursorTextChangeType.ContentAdded || precursorTextChange == PrecursorTextChangeType.ContentRemoved);
TextChangeType textChange = (precursorTextChange == PrecursorTextChangeType.ContentAdded) ?
TextChangeType.ContentAdded : TextChangeType.ContentRemoved;
_isReadOnly = true;
try
{
// Pass in a -1 for charCount parameter. DocumentSequenceTextContainer
// doesn't support this feature because it is only consumed by IMEs
// which never run on read-only documents.
Change(this, new TextContainerChangeEventArgs(startPosition, symbolCount, -1, textChange));
}
finally
{
_isReadOnly = false;
}
}
}
finally
{
textContainer.EndChange();
}
}
//-------------------------------------------------------------------
//
// Private Methods
//
//-------------------------------------------------------------------
#region Private Methods
/// <summary>
/// Notify about content changes.
/// </summary>
private void OnTextContainerChanged(object sender, TextContainerChangedEventArgs e)
{
_textPeer.RaiseAutomationEvent(AutomationEvents.TextPatternOnTextChanged);
}
/// <summary>
/// Handler for TextContainer.Changed event.
/// </summary>
internal override void OnTextContainerChanged(object sender, TextContainerChangedEventArgs e)
{
try
{
// if there are re-entrant changes, only raise public events
// after the outermost change completes
_changeEventNestingCount++;
// Ignore property changes that originate from OnTextPropertyChange.
if (!_isInsideTextContentChange)
{
_isInsideTextContentChange = true;
// Use a DeferredTextReference instead of calculating the new
// value now for better performance. Most of the time no
// one cares what the new value is, and loading our content into a
// string can be extremely expensive.
DeferredTextReference dtr = new DeferredTextReference(this.TextContainer);
_newTextValue = dtr;
SetCurrentDeferredValue(TextProperty, dtr);
}
}
finally
{
_changeEventNestingCount--;
if (_changeEventNestingCount == 0)
{
_isInsideTextContentChange = false;
_newTextValue = DependencyProperty.UnsetValue;
}
}
if (_changeEventNestingCount == 0)
{
// Let base raise the public TextBoxBase.TextChanged event.
base.OnTextContainerChanged(sender, e);
}
}
// ------------------------------------------------------------------
// Handler for TextContainer.Changed notification.
// ------------------------------------------------------------------
private void OnTextContainerChanged(object sender, TextContainerChangedEventArgs args)
{
// Skip changes that only affect properties.
if (args.HasContentAddedOrRemoved)
{
UpdateAccessKey();
}
}
// Adds a change to the current change block.
// This call must be preceeded by a matching BeforeAddChange.
internal void AddChange(TextPointer startPosition, TextPointer endPosition,
int symbolCount, int leftEdgeCharCount, int childCharCount,
PrecursorTextChangeType textChange, DependencyProperty property, bool affectsRenderOnly)
{
Invariant.Assert(_changeBlockLevel > 0, "All public APIs must call BeginChange!");
Invariant.Assert(!CheckFlags(Flags.ReadOnly) ||
textChange == PrecursorTextChangeType.PropertyModified,
"Illegal to modify TextContainer structure inside Change event scope!");
if (this.HasListeners)
{
// Lazy init _changes. This looks redundant with the BeforeAddChange call
// we already require -- strictly speaking that's true. But in practice,
// we want the Invariant in this method to remind callers to think about
// when they must call BeforeAddChange ahead of logical tree events. Then,
// in practice, there's a subtle bug where a listener might not initially
// exist but is added during the logical tree events. That we handle
// here with an additional BeforeAddChange call instead of requiring all
// our callers to remember to handle the more subtle case.
if (_changes == null)
{
_changes = new TextContainerChangedEventArgs();
}
Invariant.Assert(_changes != null, "Missing call to BeforeAddChange!");
_changes.AddChange(textChange, startPosition.Offset, symbolCount, this.CollectTextChanges);
if (this.ChangeHandler != null)
{
FireChangeEvent(startPosition, endPosition, symbolCount, leftEdgeCharCount, childCharCount, textChange, property, affectsRenderOnly);
}
}
}
// Prepares the tree for an AddChange call, and raises the Changing
// event if it has not already fired in this change block.
//
// This method must be called before a matching AddChange.
//
// (We cannot simply merge BeforeAddChange/AddChange because
// in practice callers will sometimes raise LogicalTree events which
// must be fired between Changing/Changed events.)
internal void BeforeAddChange()
{
Invariant.Assert(_changeBlockLevel > 0, "All public APIs must call BeginChange!");
if (this.HasListeners)
{
// Contact any listeners.
if (this.ChangingHandler != null)
{
ChangingHandler(this, EventArgs.Empty);
}
if (_changes == null)
{
_changes = new TextContainerChangedEventArgs();
}
}
}
// ................................................................
//
// 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++;
}
