void _handleKeyEvent(RawKeyEvent keyEvent)
{
//only allow KCommand.copy
if (keyEvent is RawKeyUpEvent)
{
return;
}
if (this.selection.isCollapsed)
{
return;
}
KeyCode pressedKeyCode = keyEvent.data.unityEvent.keyCode;
int modifiers = (int)keyEvent.data.unityEvent.modifiers;
bool ctrl = (modifiers & (int)EventModifiers.Control) > 0;
bool cmd = (modifiers & (int)EventModifiers.Command) > 0;
bool cKey = pressedKeyCode == KeyCode.C;
bool isMac = SystemInfo.operatingSystemFamily == OperatingSystemFamily.MacOSX;
KeyCommand?kcmd = keyEvent is RawKeyCommandEvent
? ((RawKeyCommandEvent)keyEvent).command
: ((ctrl || (isMac && cmd)) && cKey)
? KeyCommand.Copy
: (KeyCommand?)null;
if (kcmd == KeyCommand.Copy)
{
Clipboard.setData(
new ClipboardData(text: this.selection.textInside(this.text.toPlainText()))
);
}
}
void _handleKeyEvent(RawKeyEvent keyEvent)
{
if (keyEvent is RawKeyUpEvent)
{
return;
}
if (this.selection.isCollapsed)
{
this._extentOffset = this.selection.extentOffset;
this._baseOffset = this.selection.baseOffset;
}
KeyCode pressedKeyCode = keyEvent.data.unityEvent.keyCode;
int modifiers = (int)keyEvent.data.unityEvent.modifiers;
bool shift = (modifiers & (int)EventModifiers.Shift) > 0;
bool ctrl = (modifiers & (int)EventModifiers.Control) > 0;
bool alt = (modifiers & (int)EventModifiers.Alt) > 0;
bool cmd = (modifiers & (int)EventModifiers.Command) > 0;
bool rightArrow = pressedKeyCode == KeyCode.RightArrow;
bool leftArrow = pressedKeyCode == KeyCode.LeftArrow;
bool upArrow = pressedKeyCode == KeyCode.UpArrow;
bool downArrow = pressedKeyCode == KeyCode.DownArrow;
bool arrow = leftArrow || rightArrow || upArrow || downArrow;
bool aKey = pressedKeyCode == KeyCode.A;
bool xKey = pressedKeyCode == KeyCode.X;
bool vKey = pressedKeyCode == KeyCode.V;
bool cKey = pressedKeyCode == KeyCode.C;
bool del = pressedKeyCode == KeyCode.Delete;
bool backDel = pressedKeyCode == KeyCode.Backspace;
bool isMac = SystemInfo.operatingSystemFamily == OperatingSystemFamily.MacOSX;
if (arrow)
{
int newOffset = this._extentOffset;
var word = (isMac && alt) || ctrl;
if (word)
{
newOffset = this._handleControl(rightArrow, leftArrow, word, newOffset);
}
newOffset = this._handleHorizontalArrows(rightArrow, leftArrow, shift, newOffset);
if (downArrow || upArrow)
{
newOffset = this._handleVerticalArrows(upArrow, downArrow, shift, newOffset);
}
newOffset = this._handleShift(rightArrow, leftArrow, shift, newOffset);
this._extentOffset = newOffset;
}
else if ((ctrl || (isMac && cmd)) && (xKey || vKey || cKey || aKey))
{
this._handleShortcuts(pressedKeyCode);
}
if (del || backDel)
{
this._handleDelete(backDel);
}
}
private RawInputKeyResponse GlobalKeyEventHandler(
RawKeyEvent rawKeyEvent,
bool enableCustomAction)
{
var keyCode = rawKeyEvent.data.unityEvent.keyCode;
if (keyCode == KeyCode.UpArrow)
{
if (enableCustomAction)
{
MentionPopup.currentState.SelectPrev();
}
return(RawInputKeyResponse.swallowResponse);
}
if (keyCode == KeyCode.DownArrow)
{
if (enableCustomAction)
{
MentionPopup.currentState.SelectNext();
}
return(RawInputKeyResponse.swallowResponse);
}
if (rawKeyEvent.data.unityEvent.character == '\n' ||
rawKeyEvent.data.unityEvent.character == '\r' ||
rawKeyEvent.data.unityEvent.character == 3 ||
rawKeyEvent.data.unityEvent.character == 10)
{
if (MentionPopup.currentState.selectedIndex == -1 ||
!MentionPopup.currentState.isMentioning)
{
if (rawKeyEvent.data.unityEvent.shift)
{
return(new RawInputKeyResponse(true, '\n', TextInputAction.newline));
}
else
{
if (enableCustomAction)
{
OnSubmitted(m_TextEditingController.text);
return(RawInputKeyResponse.swallowResponse);
}
}
}
else
{
if (enableCustomAction)
{
MentionPopup.currentState.Select();
}
return(RawInputKeyResponse.swallowResponse);
}
}
return(RawInputKeyResponse.convert(rawKeyEvent));
}
void _handleRawKeyEvent(RawKeyEvent evt)
{
if (widget.onKey != null)
{
widget.onKey(evt);
}
}
void OnKey(RawKeyEvent @event)
{
if (@event is RawKeyUpEvent)
{
return;
}
var keyCode = @event.data.unityEvent.keyCode;
if (keyCode == KeyCode.W || keyCode == KeyCode.UpArrow)
{
Game.of(context).Drop();
}
else if (keyCode == KeyCode.A || keyCode == KeyCode.LeftArrow)
{
Game.of(context).Left();
}
else if (keyCode == KeyCode.S || keyCode == KeyCode.DownArrow)
{
Game.of(context).Down();
}
else if (keyCode == KeyCode.D || keyCode == KeyCode.RightArrow)
{
Game.of(context).Right();
}
else if (keyCode == KeyCode.K || keyCode == KeyCode.Space)
{
Game.of(context).Rotate();
}
}
void _handleRawKeyEvent(RawKeyEvent Event)
{
if (_lastInteractionWasTouch)
{
_lastInteractionWasTouch = false;
_updateHighlightMode();
}
//D.assert(FocusManagerUtils._focusDebug($"Received key event {Event.logicalKey}"));
if (_primaryFocus == null)
{
D.assert(FocusManagerUtils._focusDebug($"No primary focus for key event, ignored: {Event}"));
return;
}
bool handled = false;
List <FocusNode> nodes = new List <FocusNode>();
nodes.Add(_primaryFocus);
foreach (var node in _primaryFocus.ancestors)
{
nodes.Add(node);
}
foreach (FocusNode node in nodes)
{
if (node.onKey != null && node.onKey(node, Event))
{
D.assert(FocusManagerUtils._focusDebug($"Node {node} handled key event {Event}."));
handled = true;
break;
}
}
if (!handled)
{
D.assert(FocusManagerUtils._focusDebug($"Key event not handled by anyone: {Event}."));
}
}
