mirror of
https://github.com/ZuneDev/ZuneShell.dll.git
synced 2026-07-27 13:11:51 -07:00
1115 lines
38 KiB
C#
1115 lines
38 KiB
C#
// Decompiled with JetBrains decompiler
|
|
// Type: Microsoft.Iris.InputHandlers.TextEditingHandler
|
|
// Assembly: UIX, Version=4.8.0.0, Culture=neutral, PublicKeyToken=ddd0da4d3e678217
|
|
// MVID: A56C6C9D-B7F6-46A9-8BDE-B3D9B8D60B11
|
|
// Assembly location: C:\Program Files\Zune\UIX.dll
|
|
|
|
using Microsoft.Iris.Drawing;
|
|
using Microsoft.Iris.Input;
|
|
using Microsoft.Iris.Layout;
|
|
using Microsoft.Iris.Markup;
|
|
using Microsoft.Iris.ModelItems;
|
|
using Microsoft.Iris.OS;
|
|
using Microsoft.Iris.Render;
|
|
using Microsoft.Iris.RenderAPI;
|
|
using Microsoft.Iris.Session;
|
|
using Microsoft.Iris.UI;
|
|
using Microsoft.Iris.ViewItems;
|
|
using System;
|
|
using Range = Microsoft.Iris.ModelItems.Range;
|
|
|
|
namespace Microsoft.Iris.InputHandlers
|
|
{
|
|
internal class TextEditingHandler :
|
|
InputHandler,
|
|
IRichTextCallbacks,
|
|
ITextScrollModelCallback,
|
|
IImeCallbacks
|
|
{
|
|
private const uint WM_LBUTTONDOWN = 513;
|
|
private const uint WM_LBUTTONUP = 514;
|
|
private TextEditingHandler.TextEditingCommand _copyCommand;
|
|
private TextEditingHandler.TextEditingCommand _cutCommand;
|
|
private TextEditingHandler.TextEditingCommand _deleteCommand;
|
|
private TextEditingHandler.TextPasteCommand _pasteCommand;
|
|
private TextEditingHandler.TextEditingCommand _selectAllCommand;
|
|
private TextEditingHandler.TextEditingCommand _undoCommand;
|
|
private uint _bits;
|
|
private Range _selection;
|
|
private Point _inputOffset;
|
|
private int _savedMouseYPositionToWorkAroundRichEditBug;
|
|
private EditableTextData _editData;
|
|
private EventHandler _maxLengthChangedHandler;
|
|
private EventHandler _readOnlyChangedHandler;
|
|
private EventHandler _valueChangedHandler;
|
|
private EventHandler _activationStateHandler;
|
|
private Form _activationStateNotifier;
|
|
private Text _textDisplay;
|
|
private CaretInfo _caretInfo;
|
|
private RichText _editControl;
|
|
private CursorID _cursor;
|
|
private TextScrollModel.State _pendingHorizontalScrollState;
|
|
private TextScrollModel.State _pendingVerticalScrollState;
|
|
private TextScrollModel _horizontalScrollModel;
|
|
private TextScrollModel _verticalScrollModel;
|
|
private SimpleCallback _updateScrollbars;
|
|
private InputInfo _pendingPointerDown;
|
|
private Color _linkColor;
|
|
private string _linkClickedParameter;
|
|
private bool _InImeMode;
|
|
private uint _ImeCallbackToken;
|
|
|
|
public TextEditingHandler()
|
|
{
|
|
_caretInfo = new CaretInfo();
|
|
_editControl = new RichText(true, this);
|
|
_maxLengthChangedHandler = new EventHandler(OnEditableTextMaxLengthChanged);
|
|
_readOnlyChangedHandler = new EventHandler(OnEditableTextReadOnlyChanged);
|
|
_valueChangedHandler = new EventHandler(OnEditableTextValueChanged);
|
|
_activationStateHandler = new EventHandler(OnActivationChanged);
|
|
SetBit(Bits.AcceptsEnter);
|
|
}
|
|
|
|
protected override void OnDispose()
|
|
{
|
|
base.OnDispose();
|
|
RemoveEditableTextEventHandlers();
|
|
UnregisterImeMessageHandler();
|
|
if (_activationStateNotifier != null)
|
|
UpdateActivationStateHandler(false);
|
|
HorizontalScrollModel = null;
|
|
VerticalScrollModel = null;
|
|
_editControl.Dispose();
|
|
}
|
|
|
|
protected override void ConfigureInteractivity()
|
|
{
|
|
base.ConfigureInteractivity();
|
|
if (!HandleDirect)
|
|
return;
|
|
UI.MouseInteractive = true;
|
|
UI.KeyInteractive = true;
|
|
}
|
|
|
|
public override void OnZoneAttached()
|
|
{
|
|
if (!UI.DirectKeyFocus)
|
|
return;
|
|
UpdateActivationStateHandler(true);
|
|
}
|
|
|
|
private void OnActivationChanged(object sender, EventArgs ea)
|
|
{
|
|
WindowIsActivated = _activationStateNotifier.ActivationState;
|
|
UpdateCaretVisibility();
|
|
}
|
|
|
|
public EditableTextData EditableTextData
|
|
{
|
|
get => _editData;
|
|
set
|
|
{
|
|
if (_editData == value)
|
|
return;
|
|
RemoveEditableTextEventHandlers();
|
|
_editData = value;
|
|
if (_editData != null)
|
|
{
|
|
AddEditableTextEventHandlers();
|
|
UpdateMaxLengthOnRichEdit();
|
|
UpdateReadOnlyOnRichEdit();
|
|
UpdateContentOnRichEdit();
|
|
}
|
|
FireThreadSafeNotification(NotificationID.EditableTextData);
|
|
}
|
|
}
|
|
|
|
private void RemoveEditableTextEventHandlers()
|
|
{
|
|
if (_editData == null)
|
|
return;
|
|
_editData.MaxLengthChanged -= _maxLengthChangedHandler;
|
|
_editData.ReadOnlyChanged -= _readOnlyChangedHandler;
|
|
_editData.ValueChanged -= _valueChangedHandler;
|
|
}
|
|
|
|
private void AddEditableTextEventHandlers()
|
|
{
|
|
_editData.MaxLengthChanged += _maxLengthChangedHandler;
|
|
_editData.ReadOnlyChanged += _readOnlyChangedHandler;
|
|
_editData.ValueChanged += _valueChangedHandler;
|
|
}
|
|
|
|
private void UnregisterImeMessageHandler() => RendererApi.IFC(NativeApi.SpUnregisterImeCallbacks(_ImeCallbackToken));
|
|
|
|
private void OnEditableTextMaxLengthChanged(object sender, EventArgs unused) => UpdateMaxLengthOnRichEdit();
|
|
|
|
private void OnEditableTextReadOnlyChanged(object sender, EventArgs unused) => UpdateReadOnlyOnRichEdit();
|
|
|
|
private void OnEditableTextValueChanged(object sender, EventArgs unused)
|
|
{
|
|
if (InsideValueChangeOnEditableTextData)
|
|
return;
|
|
UpdateContentOnRichEdit();
|
|
}
|
|
|
|
private void UpdateContentOnRichEdit()
|
|
{
|
|
if (_editData == null)
|
|
return;
|
|
InsideContentChangeOnRichEdit = true;
|
|
_editControl.Content = _editData.Value;
|
|
if (_textDisplay != null)
|
|
_textDisplay.MarkScaleDirty();
|
|
InsideContentChangeOnRichEdit = false;
|
|
}
|
|
|
|
private void UpdateReadOnlyOnRichEdit()
|
|
{
|
|
_editControl.ReadOnly = _editData.ReadOnly;
|
|
UpdateSelectionAndReadOnlyCommands();
|
|
}
|
|
|
|
private void UpdateMaxLengthOnRichEdit() => _editControl.MaxLength = _editData.MaxLength;
|
|
|
|
public Text TextDisplay
|
|
{
|
|
get => _textDisplay;
|
|
set
|
|
{
|
|
if (_textDisplay == value)
|
|
return;
|
|
LayoutCompleteEventHandler completeEventHandler = new LayoutCompleteEventHandler(TextLayoutComplete);
|
|
if (_textDisplay != null)
|
|
{
|
|
_textDisplay.ExternalRasterizer = null;
|
|
_textDisplay.ExternalEditingHandler = null;
|
|
_textDisplay.LayoutComplete -= completeEventHandler;
|
|
}
|
|
_textDisplay = value;
|
|
if (_textDisplay != null)
|
|
{
|
|
_textDisplay.ExternalRasterizer = _editControl;
|
|
_textDisplay.ExternalEditingHandler = this;
|
|
_textDisplay.OnDisplayedContentChange();
|
|
_textDisplay.LayoutComplete += completeEventHandler;
|
|
InputOffsetDirty = true;
|
|
}
|
|
FireThreadSafeNotification(NotificationID.TextDisplay);
|
|
}
|
|
}
|
|
|
|
private void TextLayoutComplete(object sender) => InputOffsetDirty = true;
|
|
|
|
private void FireTypingInputRejectedEvent() => FireThreadSafeNotification(NotificationID.TypingInputRejected);
|
|
|
|
public bool DetectUrls
|
|
{
|
|
get => GetBit(Bits.DetectUrls);
|
|
set
|
|
{
|
|
if (!ChangeBit(Bits.DetectUrls, value))
|
|
return;
|
|
_editControl.DetectUrls = value;
|
|
FireThreadSafeNotification(NotificationID.DetectUrls);
|
|
}
|
|
}
|
|
|
|
public Color LinkColor
|
|
{
|
|
get => _linkColor;
|
|
set
|
|
{
|
|
if (!(_linkColor != value))
|
|
return;
|
|
_linkColor = value;
|
|
FireThreadSafeNotification(NotificationID.LinkColor);
|
|
}
|
|
}
|
|
|
|
private void FireLinkClicked() => FireThreadSafeNotification(NotificationID.LinkClicked);
|
|
|
|
public string LinkClickedParameter
|
|
{
|
|
get => _linkClickedParameter;
|
|
private set
|
|
{
|
|
if (!(_linkClickedParameter != value))
|
|
return;
|
|
_linkClickedParameter = value;
|
|
FireThreadSafeNotification(NotificationID.LinkClickedParameter);
|
|
}
|
|
}
|
|
|
|
HRESULT IRichTextCallbacks.SetCursor(EditCursorType type)
|
|
{
|
|
CursorID cursorId = CursorID.NotSpecified;
|
|
switch (type)
|
|
{
|
|
case EditCursorType.IBeam:
|
|
cursorId = CursorID.IBeam;
|
|
break;
|
|
}
|
|
if (cursorId != _cursor)
|
|
{
|
|
_cursor = cursorId;
|
|
UpdateCursor();
|
|
}
|
|
return new HRESULT(0);
|
|
}
|
|
|
|
internal override CursorID GetCursor() => _cursor;
|
|
|
|
private bool IgnoreReadOnlyChar(char character) => character == '\r' || character == '\t';
|
|
|
|
protected override void OnKeyDown(UIClass ui, KeyStateInfo info)
|
|
{
|
|
bool flag = ForwardKeyStateChange(info);
|
|
switch (info.Key)
|
|
{
|
|
case Keys.Back:
|
|
if (_editData.ReadOnly)
|
|
FireTypingInputRejectedEvent();
|
|
info.MarkHandled();
|
|
break;
|
|
case Keys.Tab:
|
|
if (flag)
|
|
info.MarkHandled();
|
|
HandledTabKeyDown = info.Handled;
|
|
break;
|
|
case Keys.Enter:
|
|
if (!info.Handled && AcceptsEnter && (info.Modifiers == InputModifiers.None && !_editData.ReadOnly))
|
|
{
|
|
_editData.Submit();
|
|
info.MarkHandled();
|
|
}
|
|
HandledEnterKeyDown = info.Handled;
|
|
break;
|
|
}
|
|
}
|
|
|
|
protected override void OnKeyCharacter(UIClass ui, KeyCharacterInfo info)
|
|
{
|
|
if (ForwardKeyCharacter(info) && !info.Handled && (_editData.ReadOnly && !IgnoreReadOnlyChar(info.Character)))
|
|
FireTypingInputRejectedEvent();
|
|
switch (info.Character)
|
|
{
|
|
case '\b':
|
|
info.MarkHandled();
|
|
break;
|
|
case '\t':
|
|
if (!HandledTabKeyDown)
|
|
break;
|
|
info.MarkHandled();
|
|
break;
|
|
case '\r':
|
|
if (!HandledEnterKeyDown)
|
|
break;
|
|
info.MarkHandled();
|
|
break;
|
|
}
|
|
}
|
|
|
|
protected override void OnKeyUp(UIClass ui, KeyStateInfo info)
|
|
{
|
|
ForwardKeyStateChange(info);
|
|
switch (info.Key)
|
|
{
|
|
case Keys.Back:
|
|
info.MarkHandled();
|
|
break;
|
|
case Keys.Tab:
|
|
if (!HandledTabKeyDown)
|
|
break;
|
|
info.MarkHandled();
|
|
HandledTabKeyDown = false;
|
|
break;
|
|
case Keys.Enter:
|
|
if (!HandledEnterKeyDown)
|
|
break;
|
|
info.MarkHandled();
|
|
HandledEnterKeyDown = false;
|
|
break;
|
|
}
|
|
}
|
|
|
|
private bool ForwardKeyToRichEdit(KeyStateInfo info)
|
|
{
|
|
bool flag = true;
|
|
switch (info.Key)
|
|
{
|
|
case Keys.Tab:
|
|
flag = info.Action != KeyAction.Down ? HandledTabKeyDown : AcceptsTab;
|
|
break;
|
|
case Keys.Enter:
|
|
flag = info.Action != KeyAction.Down ? HandledEnterKeyDown : AcceptsEnter;
|
|
break;
|
|
}
|
|
return flag;
|
|
}
|
|
|
|
private bool ForwardKeyCharacterToRichEdit(KeyCharacterInfo info)
|
|
{
|
|
bool flag = true;
|
|
switch (info.Character)
|
|
{
|
|
case '\t':
|
|
flag = HandledTabKeyDown;
|
|
break;
|
|
case '\r':
|
|
flag = HandledEnterKeyDown;
|
|
break;
|
|
}
|
|
return flag;
|
|
}
|
|
|
|
private bool ForwardKeyStateChange(KeyStateInfo info)
|
|
{
|
|
if (!ForwardKeyToRichEdit(info))
|
|
return false;
|
|
if (_editControl.ForwardKeyStateNotification(info.NativeMessageID, (int)info.Key, info.ScanCode, (int)info.RepeatCount, (uint)info.Modifiers, info.KeyboardFlags))
|
|
info.MarkHandled();
|
|
return true;
|
|
}
|
|
|
|
private bool ForwardKeyCharacter(KeyCharacterInfo info)
|
|
{
|
|
if (!ForwardKeyCharacterToRichEdit(info))
|
|
return false;
|
|
if (_editControl.ForwardKeyCharacterNotification(info.NativeMessageID, info.Character, info.ScanCode, (int)info.RepeatCount, (uint)info.Modifiers, info.KeyboardFlags))
|
|
info.MarkHandled();
|
|
return true;
|
|
}
|
|
|
|
protected override void OnGainKeyFocus(UIClass ui, KeyFocusInfo info)
|
|
{
|
|
RendererApi.IFC(NativeApi.SpRegisterImeCallbacks(this, out _ImeCallbackToken));
|
|
_editControl.NotifyOfFocusChange(true);
|
|
if (Overtype)
|
|
SelectAll();
|
|
DeliverPendingPointerDown();
|
|
if (UI.IsZoned)
|
|
UpdateActivationStateHandler(true);
|
|
if (!_textDisplay.UsePasswordMask && !_textDisplay.DisableIme)
|
|
return;
|
|
RendererApi.IFC(NativeApi.SpPostDeferredImeMessage(1032U, new UIntPtr(_ImeCallbackToken), UIntPtr.Zero));
|
|
}
|
|
|
|
protected override void OnLoseKeyFocus(UIClass ui, KeyFocusInfo info)
|
|
{
|
|
_editControl.NotifyOfFocusChange(false);
|
|
HandledEnterKeyDown = false;
|
|
HandledTabKeyDown = false;
|
|
if (UI.IsZoned)
|
|
UpdateActivationStateHandler(false);
|
|
ClearPendingPointerDown();
|
|
RendererApi.IFC(NativeApi.SpUnregisterImeCallbacks(_ImeCallbackToken));
|
|
}
|
|
|
|
protected override void OnLoseMouseFocus(UIClass ui, MouseFocusInfo info)
|
|
{
|
|
}
|
|
|
|
private void UpdateActivationStateHandler(bool add)
|
|
{
|
|
if (add)
|
|
{
|
|
_activationStateNotifier = UI.Zone.Form;
|
|
_activationStateNotifier.ActivationChange += _activationStateHandler;
|
|
OnActivationChanged(null, EventArgs.Empty);
|
|
}
|
|
else
|
|
{
|
|
_activationStateNotifier.ActivationChange -= _activationStateHandler;
|
|
_activationStateNotifier = null;
|
|
}
|
|
}
|
|
|
|
protected override void OnMouseDoubleClick(UIClass ui, MouseButtonInfo info) => ForwardMouseInput(info);
|
|
|
|
protected override void OnMouseMove(UIClass ui, MouseMoveInfo info) => ForwardMouseInput(info);
|
|
|
|
protected override void OnMousePrimaryDown(UIClass ui, MouseButtonInfo info)
|
|
{
|
|
_pendingPointerDown = info;
|
|
info.Lock();
|
|
if (!UI.DirectKeyFocus && HandlerStage == InputHandlerStage.Direct && UI.KeyFocusOnMouseDown)
|
|
return;
|
|
DeliverPendingPointerDown();
|
|
}
|
|
|
|
private void DeliverPendingPointerDown()
|
|
{
|
|
if (_pendingPointerDown == null)
|
|
return;
|
|
MousePrimaryDown = true;
|
|
MouseButtonInfo pendingPointerDown = (MouseButtonInfo)_pendingPointerDown;
|
|
_savedMouseYPositionToWorkAroundRichEditBug = pendingPointerDown.Y;
|
|
ForwardMouseInput(pendingPointerDown);
|
|
ClearPendingPointerDown();
|
|
}
|
|
|
|
private void ClearPendingPointerDown()
|
|
{
|
|
if (_pendingPointerDown == null)
|
|
return;
|
|
_pendingPointerDown.Unlock();
|
|
_pendingPointerDown = null;
|
|
}
|
|
|
|
protected override void OnMousePrimaryUp(UIClass ui, MouseButtonInfo info)
|
|
{
|
|
MousePrimaryDown = false;
|
|
ForwardMouseInput(info);
|
|
}
|
|
|
|
protected override void OnMouseSecondaryDown(UIClass ui, MouseButtonInfo info) => ForwardMouseInput(info);
|
|
|
|
protected override void OnMouseSecondaryUp(UIClass ui, MouseButtonInfo info) => ForwardMouseInput(info);
|
|
|
|
protected override void OnMouseWheel(UIClass ui, MouseWheelInfo info)
|
|
{
|
|
if (!_textDisplay.WordWrap)
|
|
return;
|
|
ForwardMouseInput(info);
|
|
}
|
|
|
|
private bool ForwardMouseInput(
|
|
uint nativeMessageID,
|
|
InputModifiers modifiers,
|
|
MouseButtons button,
|
|
int inputX,
|
|
int inputY,
|
|
int wheelDelta)
|
|
{
|
|
if (InputOffsetDirty)
|
|
{
|
|
Vector3 parentOffsetPxlVector;
|
|
ViewItem.GetAccumulatedOffsetAndScale(_textDisplay, UI.RootItem, out parentOffsetPxlVector, out Vector3 _);
|
|
_inputOffset = new Point((int)Math.Floor(parentOffsetPxlVector.X), (int)Math.Floor(parentOffsetPxlVector.Y));
|
|
InputOffsetDirty = false;
|
|
}
|
|
int x = inputX - _inputOffset.X;
|
|
int y = inputY - _inputOffset.Y;
|
|
if (MousePrimaryDown && _textDisplay != null && !_textDisplay.WordWrap)
|
|
y = _savedMouseYPositionToWorkAroundRichEditBug - _inputOffset.Y;
|
|
return _editControl.ForwardMouseInput(nativeMessageID, (uint)modifiers, (int)button, x, y, wheelDelta);
|
|
}
|
|
|
|
private void ForwardMouseInput(MouseActionInfo info)
|
|
{
|
|
if (!ForwardMouseInput(info.NativeMessageID, info.Modifiers, info.Button, info.X, info.Y, info.WheelDelta))
|
|
return;
|
|
info.MarkHandled();
|
|
}
|
|
|
|
public bool Overtype
|
|
{
|
|
get => GetBit(Bits.Overtype);
|
|
set
|
|
{
|
|
if (!ChangeBit(Bits.Overtype, value))
|
|
return;
|
|
FireThreadSafeNotification(NotificationID.Overtype);
|
|
}
|
|
}
|
|
|
|
public bool AcceptsTab
|
|
{
|
|
get => GetBit(Bits.AcceptsTab);
|
|
set
|
|
{
|
|
if (!ChangeBit(Bits.AcceptsTab, value))
|
|
return;
|
|
FireThreadSafeNotification(NotificationID.AcceptsTab);
|
|
}
|
|
}
|
|
|
|
public bool AcceptsEnter
|
|
{
|
|
get => GetBit(Bits.AcceptsEnter);
|
|
set
|
|
{
|
|
if (!ChangeBit(Bits.AcceptsEnter, value))
|
|
return;
|
|
FireThreadSafeNotification(NotificationID.AcceptsEnter);
|
|
}
|
|
}
|
|
|
|
public bool WordWrap
|
|
{
|
|
set
|
|
{
|
|
if (!ChangeBit(Bits.WordWrap, value))
|
|
return;
|
|
_editControl.SetWordWrap(value);
|
|
if (!value)
|
|
return;
|
|
UpdateContentOnRichEdit();
|
|
}
|
|
}
|
|
|
|
public CaretInfo CaretInfo => _caretInfo;
|
|
|
|
private void CreateCommands()
|
|
{
|
|
if (GetBit(Bits.CommandsCreated))
|
|
return;
|
|
SetBit(Bits.CommandsCreated);
|
|
_undoCommand = new TextEditingHandler.TextEditingCommand(new SimpleCallback(_editControl.Undo));
|
|
_cutCommand = new TextEditingHandler.TextEditingCommand(new SimpleCallback(_editControl.Cut));
|
|
_copyCommand = new TextEditingHandler.TextEditingCommand(new SimpleCallback(_editControl.Copy));
|
|
_pasteCommand = new TextEditingHandler.TextPasteCommand(new SimpleCallback(_editControl.Paste));
|
|
_deleteCommand = new TextEditingHandler.TextEditingCommand(new SimpleCallback(_editControl.Delete));
|
|
_selectAllCommand = new TextEditingHandler.TextEditingCommand(new SimpleCallback(SelectAll));
|
|
UpdateSelectionAndReadOnlyCommands();
|
|
UpdateTextBasedCommandAvailability();
|
|
}
|
|
|
|
public IUICommand UndoCommand
|
|
{
|
|
get
|
|
{
|
|
CreateCommands();
|
|
return _undoCommand;
|
|
}
|
|
}
|
|
|
|
public void Undo() => _editControl.Undo();
|
|
|
|
public IUICommand CutCommand
|
|
{
|
|
get
|
|
{
|
|
CreateCommands();
|
|
return _cutCommand;
|
|
}
|
|
}
|
|
|
|
public void Cut() => _editControl.Cut();
|
|
|
|
public IUICommand CopyCommand
|
|
{
|
|
get
|
|
{
|
|
CreateCommands();
|
|
return _copyCommand;
|
|
}
|
|
}
|
|
|
|
public void Copy() => _editControl.Copy();
|
|
|
|
public IUICommand PasteCommand
|
|
{
|
|
get
|
|
{
|
|
CreateCommands();
|
|
return _pasteCommand;
|
|
}
|
|
}
|
|
|
|
public void Paste() => _editControl.Paste();
|
|
|
|
public IUICommand DeleteCommand
|
|
{
|
|
get
|
|
{
|
|
CreateCommands();
|
|
return _deleteCommand;
|
|
}
|
|
}
|
|
|
|
public void Delete() => _editControl.Delete();
|
|
|
|
public IUICommand SelectAllCommand
|
|
{
|
|
get
|
|
{
|
|
CreateCommands();
|
|
return _selectAllCommand;
|
|
}
|
|
}
|
|
|
|
public void SelectAll()
|
|
{
|
|
string str = _editData != null ? _editData.Value : null;
|
|
if (string.IsNullOrEmpty(str))
|
|
return;
|
|
SelectionRange = new Range(0, str.Length);
|
|
}
|
|
|
|
public Range SelectionRange
|
|
{
|
|
get => _selection;
|
|
set
|
|
{
|
|
if (_selection.IsEqual(value))
|
|
return;
|
|
_editControl.SetSelectionRange(value.Begin, value.End);
|
|
}
|
|
}
|
|
|
|
private void UpdateTextBasedCommandAvailability()
|
|
{
|
|
_undoCommand.Available = _editControl.CanUndo;
|
|
_selectAllCommand.Available = _editData != null && !string.IsNullOrEmpty(_editData.Value);
|
|
}
|
|
|
|
private void UpdateSelectionAndReadOnlyCommands()
|
|
{
|
|
if (!GetBit(Bits.CommandsCreated))
|
|
return;
|
|
bool flag1 = !_selection.IsEmpty;
|
|
bool flag2 = _editData == null || _editData.ReadOnly;
|
|
_cutCommand.Available = flag1 && !flag2;
|
|
_copyCommand.Available = flag1;
|
|
_deleteCommand.Available = flag1 && !flag2;
|
|
_pasteCommand.TextIsReadOnly = flag2;
|
|
}
|
|
|
|
HRESULT IRichTextCallbacks.TextChanged()
|
|
{
|
|
if (!Application.IsApplicationThread)
|
|
{
|
|
Application.DeferredInvoke(args => ((IRichTextCallbacks)args).TextChanged(), this, DeferredInvokePriority.Normal);
|
|
return new HRESULT(0);
|
|
}
|
|
if (GetBit(Bits.CommandsCreated))
|
|
UpdateTextBasedCommandAvailability();
|
|
if (_editData != null && !InsideContentChangeOnRichEdit)
|
|
{
|
|
InsideValueChangeOnEditableTextData = true;
|
|
_editData.Value = _editControl.SimpleContent;
|
|
InsideValueChangeOnEditableTextData = false;
|
|
}
|
|
return new HRESULT(0);
|
|
}
|
|
|
|
HRESULT IRichTextCallbacks.InvalidateContent()
|
|
{
|
|
if (!Application.IsApplicationThread)
|
|
{
|
|
Application.DeferredInvoke(args => ((IRichTextCallbacks)args).InvalidateContent(), this, DeferredInvokePriority.Normal);
|
|
return new HRESULT(0);
|
|
}
|
|
if (_textDisplay != null)
|
|
_textDisplay.OnDisplayedContentChange();
|
|
RefreshCaretPosition();
|
|
return new HRESULT(0);
|
|
}
|
|
|
|
HRESULT IRichTextCallbacks.SelectionChanged(
|
|
int selectionStart,
|
|
int selectionEnd)
|
|
{
|
|
_selection = new Range(selectionStart, selectionEnd);
|
|
FireThreadSafeNotification(NotificationID.SelectionRange);
|
|
UpdateSelectionAndReadOnlyCommands();
|
|
return new HRESULT(0);
|
|
}
|
|
|
|
HRESULT IRichTextCallbacks.MaxLengthExceeded()
|
|
{
|
|
FireTypingInputRejectedEvent();
|
|
return new HRESULT(0);
|
|
}
|
|
|
|
HRESULT IRichTextCallbacks.SetTimer(uint id, uint timeout)
|
|
{
|
|
_editControl.SetTimer(id, timeout);
|
|
return new HRESULT(0);
|
|
}
|
|
|
|
HRESULT IRichTextCallbacks.KillTimer(uint id)
|
|
{
|
|
_editControl.KillTimer(id);
|
|
return new HRESULT(0);
|
|
}
|
|
|
|
HRESULT IRichTextCallbacks.CreateCaret(int width, int height)
|
|
{
|
|
_caretInfo.CreateCaret(new Size(width, height));
|
|
return new HRESULT(0);
|
|
}
|
|
|
|
HRESULT IRichTextCallbacks.SetCaretPos(int x, int y)
|
|
{
|
|
_caretInfo.SetCaretPosition(new Point(x, y));
|
|
return new HRESULT(0);
|
|
}
|
|
|
|
HRESULT IRichTextCallbacks.ShowCaret(bool visible)
|
|
{
|
|
RichEditCaretVisible = visible;
|
|
UpdateCaretVisibility();
|
|
return new HRESULT(0);
|
|
}
|
|
|
|
HRESULT IRichTextCallbacks.ClientToWindow(Point pt, out Point ppt)
|
|
{
|
|
ppt = _textDisplay == null ? new Point(0, 0) : _textDisplay.ClientToWindow(pt);
|
|
return new HRESULT(0);
|
|
}
|
|
|
|
HRESULT IRichTextCallbacks.ClientToScreen(Point pt, out Point ppt)
|
|
{
|
|
ppt = _textDisplay.ClientToScreen(pt);
|
|
return new HRESULT(0);
|
|
}
|
|
|
|
HRESULT IRichTextCallbacks.LinkClicked(int start, int end)
|
|
{
|
|
string str = _editData != null ? _editData.Value : string.Empty;
|
|
if (string.IsNullOrEmpty(str))
|
|
{
|
|
LinkClickedParameter = string.Empty;
|
|
}
|
|
else
|
|
{
|
|
end = end >= 0 ? Math.Min(str.Length, end) : str.Length;
|
|
start = Math.Min(start, end);
|
|
LinkClickedParameter = str.Substring(start, end - start);
|
|
}
|
|
FireLinkClicked();
|
|
return new HRESULT(0);
|
|
}
|
|
|
|
HRESULT IImeCallbacks.OnImeMessageReceived(
|
|
uint message,
|
|
UIntPtr wParam,
|
|
UIntPtr lParam)
|
|
{
|
|
switch (message)
|
|
{
|
|
case 269:
|
|
InImeCompositionMode = true;
|
|
break;
|
|
case 270:
|
|
InImeCompositionMode = false;
|
|
break;
|
|
}
|
|
return _editControl.ForwardImeMessage(message, wParam, lParam);
|
|
}
|
|
|
|
public bool InImeCompositionMode
|
|
{
|
|
get => _InImeMode;
|
|
set
|
|
{
|
|
if (_InImeMode == value)
|
|
return;
|
|
CaretInfo.IgnoreIdealWidth = value;
|
|
_InImeMode = value;
|
|
FireThreadSafeNotification(NotificationID.InImeCompositionMode);
|
|
}
|
|
}
|
|
|
|
HRESULT IRichTextCallbacks.SetScrollRange(
|
|
int whichBarInt,
|
|
int minPosition,
|
|
int extent,
|
|
int viewExtent,
|
|
int scrollPosition)
|
|
{
|
|
if (whichBarInt == 1 && _verticalScrollModel != null)
|
|
{
|
|
SetScrollRange(ref _pendingVerticalScrollState, minPosition, extent, viewExtent, scrollPosition);
|
|
ScheduleScrollbarUpdate(true);
|
|
}
|
|
else if (_horizontalScrollModel != null)
|
|
{
|
|
SetScrollRange(ref _pendingHorizontalScrollState, minPosition, extent, viewExtent, scrollPosition);
|
|
ScheduleScrollbarUpdate(false);
|
|
}
|
|
return new HRESULT(0);
|
|
}
|
|
|
|
private void SetScrollRange(
|
|
ref TextScrollModel.State state,
|
|
int minPosition,
|
|
int extent,
|
|
int viewExtent,
|
|
int scrollAmount)
|
|
{
|
|
state.Min = minPosition;
|
|
state.Extent = extent;
|
|
state.ViewExtent = viewExtent;
|
|
state.ScrollAmount = scrollAmount;
|
|
}
|
|
|
|
private bool IsVerticalScrollbar(ScrollbarType whichBar) => whichBar == ScrollbarType.Vertical || whichBar == ScrollbarType.Both;
|
|
|
|
private bool IsHorizontalScrollbar(ScrollbarType whichBar) => whichBar == ScrollbarType.Horizontal || whichBar == ScrollbarType.Both;
|
|
|
|
HRESULT IRichTextCallbacks.EnableScrollbar(
|
|
int whichBarInt,
|
|
ScrollbarEnableFlags flags)
|
|
{
|
|
ScrollbarType whichBar = (ScrollbarType)whichBarInt;
|
|
if (IsVerticalScrollbar(whichBar) && _verticalScrollModel != null)
|
|
{
|
|
EnableScrollbar(ref _pendingVerticalScrollState, flags);
|
|
ScheduleScrollbarUpdate(true);
|
|
}
|
|
if (IsHorizontalScrollbar(whichBar) && _horizontalScrollModel != null)
|
|
{
|
|
EnableScrollbar(ref _pendingHorizontalScrollState, flags);
|
|
ScheduleScrollbarUpdate(false);
|
|
}
|
|
return new HRESULT(0);
|
|
}
|
|
|
|
private void EnableScrollbar(ref TextScrollModel.State state, ScrollbarEnableFlags flags)
|
|
{
|
|
switch (flags)
|
|
{
|
|
case ScrollbarEnableFlags.EnableBoth:
|
|
state.CanScrollUp = true;
|
|
state.CanScrollDown = true;
|
|
break;
|
|
case ScrollbarEnableFlags.DisableNear:
|
|
state.CanScrollUp = false;
|
|
state.CanScrollDown = true;
|
|
break;
|
|
case ScrollbarEnableFlags.DisableFar:
|
|
state.CanScrollUp = true;
|
|
state.CanScrollDown = false;
|
|
break;
|
|
case ScrollbarEnableFlags.DisableBoth:
|
|
state.CanScrollUp = false;
|
|
state.CanScrollDown = false;
|
|
break;
|
|
}
|
|
}
|
|
|
|
private void ScheduleScrollbarUpdate(bool vertical)
|
|
{
|
|
bool flag = !GetBit(Bits.PendingVerticalScrollbarUpdate) && !GetBit(Bits.PendingHorizontalScrollbarUpdate);
|
|
if (vertical)
|
|
SetBit(Bits.PendingVerticalScrollbarUpdate);
|
|
else
|
|
SetBit(Bits.PendingHorizontalScrollbarUpdate);
|
|
if (!flag)
|
|
return;
|
|
if (_updateScrollbars == null)
|
|
_updateScrollbars = new SimpleCallback(UpdateScrollbars);
|
|
DeferredCall.Post(DispatchPriority.Normal, _updateScrollbars);
|
|
}
|
|
|
|
private void UpdateScrollbars()
|
|
{
|
|
if (GetBit(Bits.PendingVerticalScrollbarUpdate))
|
|
{
|
|
ClearBit(Bits.PendingVerticalScrollbarUpdate);
|
|
_verticalScrollModel.UpdateState(_pendingVerticalScrollState);
|
|
_pendingVerticalScrollState = new TextScrollModel.State();
|
|
}
|
|
if (!GetBit(Bits.PendingHorizontalScrollbarUpdate))
|
|
return;
|
|
ClearBit(Bits.PendingHorizontalScrollbarUpdate);
|
|
_horizontalScrollModel.UpdateState(_pendingHorizontalScrollState);
|
|
_pendingHorizontalScrollState = new TextScrollModel.State();
|
|
}
|
|
|
|
public TextScrollModel HorizontalScrollModel
|
|
{
|
|
get
|
|
{
|
|
if (_horizontalScrollModel == null)
|
|
StoreScrollModel(ref _horizontalScrollModel, new TextScrollModel());
|
|
return _horizontalScrollModel;
|
|
}
|
|
set
|
|
{
|
|
if (_horizontalScrollModel == value)
|
|
return;
|
|
StoreScrollModel(ref _horizontalScrollModel, value);
|
|
FireThreadSafeNotification(NotificationID.HorizontalScrollModel);
|
|
}
|
|
}
|
|
|
|
public TextScrollModel VerticalScrollModel
|
|
{
|
|
get
|
|
{
|
|
if (_verticalScrollModel == null)
|
|
StoreScrollModel(ref _verticalScrollModel, new TextScrollModel());
|
|
return _verticalScrollModel;
|
|
}
|
|
set
|
|
{
|
|
if (_verticalScrollModel == value)
|
|
return;
|
|
StoreScrollModel(ref _verticalScrollModel, value);
|
|
FireThreadSafeNotification(NotificationID.VerticalScrollModel);
|
|
}
|
|
}
|
|
|
|
private void StoreScrollModel(ref TextScrollModel storage, TextScrollModel newDude)
|
|
{
|
|
if (storage != null)
|
|
storage.DetachCallbacks();
|
|
storage = newDude;
|
|
if (storage != null)
|
|
storage.AttachCallbacks(this);
|
|
_editControl.SetScrollbars(_horizontalScrollModel != null, _verticalScrollModel != null);
|
|
}
|
|
|
|
private ScrollbarType WhichScrollbar(TextScrollModel who) => who != _verticalScrollModel ? ScrollbarType.Horizontal : ScrollbarType.Vertical;
|
|
|
|
void ITextScrollModelCallback.ScrollUp(TextScrollModel who) => _editControl.ScrollUp(WhichScrollbar(who));
|
|
|
|
void ITextScrollModelCallback.ScrollDown(TextScrollModel who) => _editControl.ScrollDown(WhichScrollbar(who));
|
|
|
|
void ITextScrollModelCallback.PageUp(TextScrollModel who) => _editControl.PageUp(WhichScrollbar(who));
|
|
|
|
void ITextScrollModelCallback.PageDown(TextScrollModel who) => _editControl.PageDown(WhichScrollbar(who));
|
|
|
|
void ITextScrollModelCallback.ScrollToPosition(
|
|
TextScrollModel who,
|
|
int whereTo)
|
|
{
|
|
_editControl.ScrollToPosition(WhichScrollbar(who), whereTo);
|
|
}
|
|
|
|
private void UpdateCaretVisibility() => CaretInfo.SetVisible(RichEditCaretVisible && WindowIsActivated);
|
|
|
|
private void RefreshCaretPosition()
|
|
{
|
|
if (!CaretInfo.Visible || MousePrimaryDown || _editControl == null)
|
|
return;
|
|
_editControl.NotifyOfFocusChange(true);
|
|
}
|
|
|
|
private bool HandledTabKeyDown
|
|
{
|
|
get => GetBit(Bits.HandledTabKeyDown);
|
|
set => SetBit(Bits.HandledTabKeyDown, value);
|
|
}
|
|
|
|
private bool HandledEnterKeyDown
|
|
{
|
|
get => GetBit(Bits.HandledEnterKeyDown);
|
|
set => SetBit(Bits.HandledEnterKeyDown, value);
|
|
}
|
|
|
|
private bool InputOffsetDirty
|
|
{
|
|
get => GetBit(Bits.InputOffsetDirty);
|
|
set => SetBit(Bits.InputOffsetDirty, value);
|
|
}
|
|
|
|
private bool MousePrimaryDown
|
|
{
|
|
get => GetBit(Bits.MousePrimaryDown);
|
|
set => SetBit(Bits.MousePrimaryDown, value);
|
|
}
|
|
|
|
private bool InsideValueChangeOnEditableTextData
|
|
{
|
|
get => GetBit(Bits.InsideValueChangeOnEditableTextData);
|
|
set => SetBit(Bits.InsideValueChangeOnEditableTextData, value);
|
|
}
|
|
|
|
private bool InsideContentChangeOnRichEdit
|
|
{
|
|
get => GetBit(Bits.InsideContentChangeOnRichEdit);
|
|
set => SetBit(Bits.InsideContentChangeOnRichEdit, value);
|
|
}
|
|
|
|
private bool RichEditCaretVisible
|
|
{
|
|
get => GetBit(Bits.RichEditCaretVisible);
|
|
set => SetBit(Bits.RichEditCaretVisible, value);
|
|
}
|
|
|
|
private bool WindowIsActivated
|
|
{
|
|
get => GetBit(Bits.WindowIsActivated);
|
|
set => SetBit(Bits.WindowIsActivated, value);
|
|
}
|
|
|
|
private bool GetBit(TextEditingHandler.Bits lookupBit) => ((TextEditingHandler.Bits)_bits & lookupBit) != 0;
|
|
|
|
private void SetBit(TextEditingHandler.Bits changeBit)
|
|
{
|
|
TextEditingHandler textEditingHandler = this;
|
|
textEditingHandler._bits = (uint)((TextEditingHandler.Bits)textEditingHandler._bits | changeBit);
|
|
}
|
|
|
|
private void SetBit(TextEditingHandler.Bits changeBit, bool value) => _bits = value ? (uint)((TextEditingHandler.Bits)_bits | changeBit) : (uint)((TextEditingHandler.Bits)_bits & ~changeBit);
|
|
|
|
private void ClearBit(TextEditingHandler.Bits changeBit)
|
|
{
|
|
TextEditingHandler textEditingHandler = this;
|
|
textEditingHandler._bits = (uint)((TextEditingHandler.Bits)textEditingHandler._bits & ~changeBit);
|
|
}
|
|
|
|
private bool ChangeBit(TextEditingHandler.Bits changeBit, bool value)
|
|
{
|
|
uint num = value ? (uint)((TextEditingHandler.Bits)_bits | changeBit) : (uint)((TextEditingHandler.Bits)_bits & ~changeBit);
|
|
bool flag = (int)num != (int)_bits;
|
|
if (flag)
|
|
_bits = num;
|
|
return flag;
|
|
}
|
|
|
|
private enum Bits
|
|
{
|
|
AcceptsTab = 1,
|
|
AcceptsEnter = 2,
|
|
HandledTabKeyDown = 4,
|
|
HandledEnterKeyDown = 16, // 0x00000010
|
|
InputOffsetDirty = 32, // 0x00000020
|
|
MousePrimaryDown = 64, // 0x00000040
|
|
Overtype = 128, // 0x00000080
|
|
InsideValueChangeOnEditableTextData = 256, // 0x00000100
|
|
InsideContentChangeOnRichEdit = 512, // 0x00000200
|
|
RichEditCaretVisible = 1024, // 0x00000400
|
|
WindowIsActivated = 2048, // 0x00000800
|
|
WordWrap = 4096, // 0x00001000
|
|
CommandsCreated = 8192, // 0x00002000
|
|
PendingHorizontalScrollbarUpdate = 16384, // 0x00004000
|
|
PendingVerticalScrollbarUpdate = 32768, // 0x00008000
|
|
DetectUrls = 65536, // 0x00010000
|
|
}
|
|
|
|
private class TextEditingCommand : UICommand
|
|
{
|
|
private SimpleCallback _onInvoked;
|
|
|
|
public TextEditingCommand(SimpleCallback onInvoked) => _onInvoked = onInvoked;
|
|
|
|
protected override void OnInvoked()
|
|
{
|
|
base.OnInvoked();
|
|
_onInvoked();
|
|
}
|
|
}
|
|
|
|
private class TextPasteCommand : TextEditingHandler.TextEditingCommand, IUICommand
|
|
{
|
|
private bool _isReadOnly;
|
|
|
|
public TextPasteCommand(SimpleCallback onInvoked)
|
|
: base(onInvoked)
|
|
{
|
|
}
|
|
|
|
bool IUICommand.Available
|
|
{
|
|
get => Clipboard.ContainsText() && !_isReadOnly;
|
|
set
|
|
{
|
|
}
|
|
}
|
|
|
|
public bool TextIsReadOnly
|
|
{
|
|
get => _isReadOnly;
|
|
set => _isReadOnly = value;
|
|
}
|
|
}
|
|
}
|
|
}
|