public static uint SRCocoaToCarbonFlags(NSEventModifierMask aCocoaFlags)
{
uint carbonFlags = 0;
if ((aCocoaFlags & NSEventModifierMask.CommandKeyMask) == NSEventModifierMask.CommandKeyMask)
{
carbonFlags |= Constants.cmdKey;
}
if ((aCocoaFlags & NSEventModifierMask.AlternateKeyMask) == NSEventModifierMask.AlternateKeyMask)
{
carbonFlags |= Constants.optionKey;
}
if ((aCocoaFlags & NSEventModifierMask.ControlKeyMask) == NSEventModifierMask.ControlKeyMask)
{
carbonFlags |= Constants.controlKey;
}
if ((aCocoaFlags & NSEventModifierMask.ShiftKeyMask) == NSEventModifierMask.ShiftKeyMask)
{
carbonFlags |= Constants.shiftKey;
}
return(carbonFlags);
}
void ProcessModifiers(NSEventModifierMask flags)
{
// we get notified when modifiers change, but not specifically what changed
NSEventModifierMask diff = flags ^ XplatUICocoa.key_modifiers;
XplatUICocoa.key_modifiers = flags;
shiftDown = 0 != (flags & NSEventModifierMask.ShiftKeyMask);
ctrlDown = 0 != (flags & NSEventModifierMask.ControlKeyMask);
altDown = 0 != (flags & NSEventModifierMask.AlternateKeyMask);
cmdDown = 0 != (flags & NSEventModifierMask.CommandKeyMask);
if ((NSEventModifierMask.ShiftKeyMask & diff) != 0)
{
driver.SendMessage(view.Handle, (NSEventModifierMask.ShiftKeyMask & flags) != 0 ? Msg.WM_KEYDOWN : Msg.WM_KEYUP, (IntPtr)VirtualKeys.VK_SHIFT, IntPtr.Zero);
}
if ((NSEventModifierMask.ControlKeyMask & diff) != 0)
{
driver.SendMessage(view.Handle, (NSEventModifierMask.ControlKeyMask & flags) != 0 ? Msg.WM_KEYDOWN : Msg.WM_KEYUP, (IntPtr)VirtualKeys.VK_CONTROL, IntPtr.Zero);
}
if ((NSEventModifierMask.AlternateKeyMask & diff) != 0)
{
driver.SendMessage(view.Handle, (NSEventModifierMask.AlternateKeyMask & flags) != 0 ? Msg.WM_KEYDOWN : Msg.WM_KEYUP, (IntPtr)VirtualKeys.VK_MENU, IntPtr.Zero);
}
if ((NSEventModifierMask.CommandKeyMask & diff) != 0)
{
driver.SendMessage(view.Handle, (NSEventModifierMask.CommandKeyMask & flags) != 0 ? Msg.WM_KEYDOWN : Msg.WM_KEYUP, (IntPtr)VirtualKeys.VK_LWIN, IntPtr.Zero);
}
}
public static KeyDescriptor FromMac(char ch, NSEventModifierMask state)
{
var specialKey = ConvertKey(ref ch);
var keyDescriptor = new KeyDescriptor(specialKey, ch, ConvertModifiers(state), state);
return(keyDescriptor);
}
public static string GetCharactersForKeyPress(ushort keyCode, NSEventModifierMask modifierFlags, ref uint deadKeyState, IntPtr keyboard)
{
var layoutData = TISGetInputSourceProperty(keyboard, __CFStringMakeConstantString("TISPropertyUnicodeKeyLayoutData"));
var keyboardLayout = CFDataGetBytePtr(layoutData);
var flags = (uint)modifierFlags;
var modifierKeyState = (flags >> 16) & 0xFF;
var chars = new char[4];
UInt32 realLength = 0;
int size = sizeof(UInt16) * chars.Length;
IntPtr buffer = IntPtr.Zero;
try
{
buffer = Marshal.AllocCoTaskMem(size);
UCKeyTranslate(keyboardLayout, keyCode, kUCKeyActionDown, modifierKeyState, LMGetKbdType(), 0,
ref deadKeyState, (uint)chars.Length, ref realLength, buffer);
if (realLength != 0)
{
Marshal.Copy(buffer, chars, 0, chars.Length);
}
//Debug.WriteLine("DeadKeyState = {0:X8}", deadKeyState);
return(new string(chars, 0, (int)realLength));
}
finally
{
if (buffer != IntPtr.Zero)
{
Marshal.FreeCoTaskMem(buffer);
}
}
}
public bool ShortcutValidator(SRValidator aValidator, ushort aKeyCode, NSEventModifierMask aFlags, out string outReason)
{
outReason = string.Empty;
var recorder = View.Window.FirstResponder as SRRecorderControl;
if (recorder == null)
{
return(false);
}
var shortcut = CFunctions.SRShortcutWithCocoaModifierFlagsAndKeyCode(aFlags, aKeyCode);
if (IsTaken(pingShortcutRecorder, shortcut) ||
IsTaken(globalPingShortcutRecorder, shortcut) ||
IsTaken(pingItemShortcutRecorder, shortcut))
{
outReason = "it's already used. To use this shortcut, first remove or change the other shortcut";
return(true);
}
else
{
return(false);
}
}
public static OxyModifierKeys ToModifierKeys(this NSEventModifierMask theMask)
{
var keys = OxyModifierKeys.None;
if ((theMask & NSEventModifierMask.ShiftKeyMask) == NSEventModifierMask.ShiftKeyMask)
{
keys |= OxyModifierKeys.Shift;
}
if ((theMask & NSEventModifierMask.ControlKeyMask) == NSEventModifierMask.ControlKeyMask)
{
keys |= OxyModifierKeys.Control;
}
if ((theMask & NSEventModifierMask.AlternateKeyMask) == NSEventModifierMask.AlternateKeyMask)
{
keys |= OxyModifierKeys.Alt;
}
// TODO
if ((theMask & NSEventModifierMask.CommandKeyMask) == NSEventModifierMask.CommandKeyMask)
{
keys |= OxyModifierKeys.Control;
}
return(keys);
}
InputModifiers GetModifiers(NSEventModifierMask mod)
{
var rv = new InputModifiers();
if (mod.HasFlag(NSEventModifierMask.ControlKeyMask))
{
rv |= InputModifiers.Control;
}
if (mod.HasFlag(NSEventModifierMask.ShiftKeyMask))
{
rv |= InputModifiers.Shift;
}
if (mod.HasFlag(NSEventModifierMask.AlternateKeyMask))
{
rv |= InputModifiers.Alt;
}
if (mod.HasFlag(NSEventModifierMask.CommandKeyMask))
{
rv |= InputModifiers.Windows;
}
if (_isLeftPressed)
{
rv |= InputModifiers.LeftMouseButton;
}
if (_isMiddlePressed)
{
rv |= InputModifiers.MiddleMouseButton;
}
if (_isRightPressed)
{
rv |= InputModifiers.RightMouseButton;
}
return(rv);
}
public override void KeyDown(NSEvent theEvent)
{
ModifierFlags = theEvent.ModifierFlags;
Key key;
if (MonoMacEnums.TryGetUnoKey((NSKey)theEvent.KeyCode, out key))
{
Bootstrapper.OnKeyDown(_unoWindow, key);
}
else
{
Debug.Log("Unsupported key code: " + theEvent.KeyCode, DebugMessageType.Error);
}
if (EnableText && IsTextInputEvent(ModifierFlags))
{
var characters = theEvent.Characters.Where(CharacterIsNotSpecial).ToArray();
if (characters.Length == 0)
{
return;
}
Bootstrapper.OnTextInput(_unoWindow, new string (characters));
}
}
public static Keys ToKeys(this NSEventModifierMask mask)
{
switch (mask)
{
//case NSEventModifierMask.AlphaShiftKeyMask:
// return Keys.None;
case NSEventModifierMask.AlternateKeyMask:
return(Keys.Alt);
case NSEventModifierMask.CommandKeyMask:
return(Keys.LWin | Keys.RWin);
case NSEventModifierMask.ControlKeyMask:
return(Keys.Control);
//case NSEventModifierMask.FunctionKeyMask:
// return Keys.None;
case NSEventModifierMask.HelpKeyMask:
return(Keys.Help);
case NSEventModifierMask.ShiftKeyMask:
return(Keys.Shift);
}
return(Keys.None);
}
public static NSEventModifierMask SRCarbonToCocoaFlags(uint aCarbonFlags)
{
NSEventModifierMask cocoaFlags = 0;
if ((aCarbonFlags & Constants.cmdKey) == Constants.cmdKey)
{
cocoaFlags |= NSEventModifierMask.CommandKeyMask;
}
if ((aCarbonFlags & Constants.optionKey) == Constants.optionKey)
{
cocoaFlags |= NSEventModifierMask.AlternateKeyMask;
}
if ((aCarbonFlags & Constants.controlKey) == Constants.controlKey)
{
cocoaFlags |= NSEventModifierMask.ControlKeyMask;
}
if ((aCarbonFlags & Constants.shiftKey) == Constants.shiftKey)
{
cocoaFlags |= NSEventModifierMask.ShiftKeyMask;
}
return(cocoaFlags);
}
public override void MouseEntered(NSEvent a)
{
_modifierFlags = a.ModifierFlags;
//var pos = GetPosition(a);
//Log.Try(() => Bootstrapper.OnMouseEnter(_unoWindow, (int)pos.X, (int)pos.Y), false);
}
public override void KeyUp(NSEvent theEvent)
{
_modifierFlags = theEvent.ModifierFlags;
theEvent.InterpretAsKeyEvent().Do(
key => _log.Try(() => Bootstrapper.OnKeyUp(_unoWindow, (Uno.Platform.Key)key), false),
() => { });
}
public static NSDictionary SRShortcutWithCocoaModifierFlagsAndKeyCode(NSEventModifierMask aModifierFlags, ushort aKeyCode)
{
var dict = new NSMutableDictionary();
dict.SetValueForKey(NSObject.FromObject(aKeyCode), Constants.SRShortcutKeyCode);
dict.SetValueForKey(NSObject.FromObject(aModifierFlags), Constants.SRShortcutModifierFlagsKey);
return(dict);
}
public override void ScrollWheel(NSEvent a)
{
_modifierFlags = a.ModifierFlags;
var deltaMode = a.HasPreciseScrollingDeltas ? WheelDeltaMode.DeltaPixel : WheelDeltaMode.DeltaLine;
_modifierFlags = a.ModifierFlags;
_log.Try(() => Bootstrapper.OnMouseWheel(_unoWindow, (float)a.ScrollingDeltaX, (float)a.ScrollingDeltaY, (int)deltaMode), false);
}
public static string GetCharactersForKeyPress(ushort keyCode, NSEventModifierMask modifierFlags, ref uint deadKeyState)
{
var keyboard = TISCopyCurrentKeyboardLayoutInputSource();
var characters = GetCharactersForKeyPress(keyCode, modifierFlags, ref deadKeyState, keyboard);
CFRelease(keyboard);
return(characters);
}
void MouseUpInternal(NSEvent a, Uno.Platform.MouseButton button)
{
_modifierFlags = a.ModifierFlags;
var pos = GetPosition(a);
_log.Try(() => Bootstrapper.OnMouseUp(_unoWindow, (int)pos.X, (int)pos.Y, button), false);
}
/// <summary>
/// Initializes a new instance of <see cref="DragDropInfo"/> with the specified settings.
/// </summary>
/// <param name="location">The location of the cursor relative to the left top corner of the text view.</param>
/// <param name="keyStates">The state of the keyboard during the operation.</param>
/// <param name="data">The <see cref="NSPasteboard"/> of the drag and drop operation.</param>
/// <param name="isInternal"><c>true</c> if the drag has been initiated from within the editor, otherwise <c>false</c>.</param>
/// <param name="source">The object that initiated the drag and drop operation.</param>
/// <param name="allowedEffects">The drag and drop effects allowed by the source.</param>
/// <param name="bufferPosition">The buffer position of the cursor during the drag and drop operation.</param>
public DragDropInfo(CGPoint location, NSEventModifierMask keyStates, NSPasteboard data, bool isInternal, object source, NSDragOperation allowedEffects, VirtualSnapshotPoint bufferPosition)
{
Location = location;
KeyStates = keyStates;
Data = data;
IsInternal = isInternal;
Source = source;
AllowedEffects = allowedEffects;
VirtualBufferPosition = bufferPosition;
}
private bool GetKeyInputFromKey(NSEvent theEvent, NSEventModifierMask modifierKeys, out KeyInput keyInput)
{
if (!string.IsNullOrEmpty(theEvent.CharactersIgnoringModifiers))
{
var keyModifiers = ConvertToKeyModifiers(modifierKeys);
keyInput = KeyInputUtil.ApplyKeyModifiersToChar(theEvent.CharactersIgnoringModifiers[0], keyModifiers);
return(true);
}
keyInput = null;
return(false);
}
void MouseMovedInternal(NSEvent a)
{
_modifierFlags = a.ModifierFlags;
// Only send one mouse moved event per frame (ignore the rest)
// Issue: https://github.com/fusetools/Fuse/issues/2479
if (_currentFrame != _lastMouseMovedFrame)
{
var pos = GetPosition(a);
_log.Try(() => Bootstrapper.OnMouseMove(_unoWindow, (int)pos.X, (int)pos.Y), false);
_lastMouseMovedFrame = _currentFrame;
}
}
public override void KeyDown(NSEvent theEvent)
{
_modifierFlags = theEvent.ModifierFlags;
if (_unoWindow.IsTextInputActive())
{
theEvent.InterpretAsTextEvent().Do(
text => _log.Try(() => Bootstrapper.OnTextInput(_unoWindow, text), false),
() => { });
}
theEvent.InterpretAsKeyEvent().Do(
key => _log.Try(() => Bootstrapper.OnKeyDown(_unoWindow, (Uno.Platform.Key)key), false),
() => { });
}
static void SetAccel (NSMenuItem item, string accelKey)
{
uint modeKey;
Gdk.ModifierType modeMod;
uint key;
Gdk.ModifierType mod;
if (!KeyBindingManager.BindingToKeys (accelKey, out modeKey, out modeMod, out key, out mod)) {
item.KeyEquivalent = "";
item.KeyEquivalentModifierMask = (NSEventModifierMask) 0;
return;
}
if (modeKey != 0) {
LoggingService.LogWarning ("Mac menu cannot display accelerators with mode keys ({0})", accelKey);
item.KeyEquivalent = "";
item.KeyEquivalentModifierMask = (NSEventModifierMask) 0;
return;
}
var keyEq = GetKeyEquivalent ((Gdk.Key) key);
item.KeyEquivalent = keyEq;
if (keyEq.Length == 0) {
item.KeyEquivalentModifierMask = 0;
}
NSEventModifierMask outMod = 0;
if ((mod & Gdk.ModifierType.Mod1Mask) != 0) {
outMod |= NSEventModifierMask.AlternateKeyMask;
mod ^= Gdk.ModifierType.Mod1Mask;
}
if ((mod & Gdk.ModifierType.ShiftMask) != 0) {
outMod |= NSEventModifierMask.ShiftKeyMask;
mod ^= Gdk.ModifierType.ShiftMask;
}
if ((mod & Gdk.ModifierType.ControlMask) != 0) {
outMod |= NSEventModifierMask.ControlKeyMask;
mod ^= Gdk.ModifierType.ControlMask;
}
if ((mod & Gdk.ModifierType.MetaMask) != 0) {
outMod |= NSEventModifierMask.CommandKeyMask;
mod ^= Gdk.ModifierType.MetaMask;
}
if (mod != 0) {
LoggingService.LogWarning ("Mac menu cannot display accelerators with modifiers {0}", mod);
}
item.KeyEquivalentModifierMask = outMod;
}
public static uint ToWParam(this NSEventModifierMask mask)
{
uint wParam = 0;
if ((mask & NSEventModifierMask.ControlKeyMask) != 0)
{
wParam |= (int)MsgButtons.MK_CONTROL;
}
if ((mask & NSEventModifierMask.ShiftKeyMask) != 0)
{
wParam |= (int)MsgButtons.MK_SHIFT;
}
return(wParam);
}
public override void FlagsChanged(NSEvent theEvent)
{
foreach (var item in modifiersToKeys)
{
if (IsMaskHasFlag(theEvent.ModifierFlags, item.Key))
{
input.SetKeyState(item.Value, true);
}
else if (IsMaskHasFlag(prevMask, item.Key))
{
input.SetKeyState(item.Value, false);
}
}
prevMask = theEvent.ModifierFlags;
}
static uint ModifiersToWParam(NSEventModifierMask modifierFlags)
{
uint wParam = 0;
if ((modifierFlags & NSEventModifierMask.ControlKeyMask) != 0)
{
wParam |= (int)MsgButtons.MK_CONTROL;
}
if ((modifierFlags & NSEventModifierMask.ShiftKeyMask) != 0)
{
wParam |= (int)MsgButtons.MK_SHIFT;
}
return(wParam);
}
public override void KeyUp(NSEvent theEvent)
{
ModifierFlags = theEvent.ModifierFlags;
Key key;
if (MonoMacEnums.TryGetUnoKey((NSKey)theEvent.KeyCode, out key))
{
Bootstrapper.OnKeyUp(_unoWindow, key);
}
else
{
Debug.Log("Unsupported key code: " + theEvent.KeyCode, DebugMessageType.Error);
}
}
public static Keys MapKey(ushort key, NSEventModifierMask modifiers)
{
Keys value;
if (Map.TryGetValue(key, out value))
{
// special case, fn+return is usually interpreted as insert key on macOS, even though it is actually enter.
if (value == Keys.Enter && modifiers.HasFlag(NSEventModifierMask.FunctionKeyMask))
{
return(Keys.Insert);
}
return(value);
}
Debug.WriteLine($"Unknown key '{key}'");
return(Keys.None);
}
private KeyModifiers GetModifiers(NSEventModifierMask mask)
{
OpenTK.Input.KeyModifiers modifiers = 0;
if ((mask & NSEventModifierMask.ControlKeyMask) != 0)
{
modifiers |= OpenTK.Input.KeyModifiers.Control;
}
if ((mask & NSEventModifierMask.ShiftKeyMask) != 0)
{
modifiers |= OpenTK.Input.KeyModifiers.Shift;
}
if ((mask & NSEventModifierMask.AlternateKeyMask) != 0)
{
modifiers |= OpenTK.Input.KeyModifiers.Alt;
}
return(modifiers);
}
void SendCmdKey(IntPtr hwnd, VirtualKeys key, NSEventModifierMask moreModifiers = 0)
{
// Emulate (and then restore) only modifiers of not currently pressed keys
var affected = XplatUICocoa.SetModifiers(NSEventModifierMask.CommandKeyMask | moreModifiers, true);
if (affected != 0)
{
ProcessModifiers(XplatUICocoa.key_modifiers);
}
SendKey(hwnd, (IntPtr)key, (IntPtr)0x1080000);
if (affected != 0)
{
XplatUICocoa.SetModifiers(affected, false);
ProcessModifiers(XplatUICocoa.key_modifiers);
}
}
public bool ShortcutValidator(SRValidator aValidator, ushort aKeyCode, NSEventModifierMask aFlags, out string outReason)
{
outReason = string.Empty;
if (!(FirstResponder is SRRecorderControl recorder))
{
return(false);
}
var shortcut = CFunctions.SRShortcutWithCocoaModifierFlagsAndKeyCode(aFlags, aKeyCode);
if (IsTaken(WdgRecorderScanSelect, shortcut) ||
IsTaken(WdgRecorderScanClick, shortcut))
{
outReason = "it's already used. To use this shortcut, first remove or change the other shortcut";
return(true);
}
return(false);
}
void ProcessModifiers(NSEventModifierMask flags)
{
var diff = XplatUICocoa.key_modifiers_mask;
if ((NSEventModifierMask.ShiftKeyMask & diff) != 0)
{
driver.SendMessage(view.Handle, (NSEventModifierMask.ShiftKeyMask & flags) != 0 ? Msg.WM_KEYDOWN : Msg.WM_KEYUP, (IntPtr)VirtualKeys.VK_SHIFT, IntPtr.Zero);
}
if ((NSEventModifierMask.ControlKeyMask & diff) != 0)
{
driver.SendMessage(view.Handle, (NSEventModifierMask.ControlKeyMask & flags) != 0 ? Msg.WM_KEYDOWN : Msg.WM_KEYUP, (IntPtr)VirtualKeys.VK_CONTROL, IntPtr.Zero);
}
if ((NSEventModifierMask.AlternateKeyMask & diff) != 0)
{
driver.SendMessage(view.Handle, (NSEventModifierMask.AlternateKeyMask & flags) != 0 ? Msg.WM_KEYDOWN : Msg.WM_KEYUP, (IntPtr)VirtualKeys.VK_MENU, IntPtr.Zero);
}
if ((NSEventModifierMask.CommandKeyMask & diff) != 0)
{
driver.SendMessage(view.Handle, (NSEventModifierMask.CommandKeyMask & flags) != 0 ? Msg.WM_KEYDOWN : Msg.WM_KEYUP, (IntPtr)VirtualKeys.VK_LWIN, IntPtr.Zero);
}
}
public static KeyDescriptor FromMac (char ch, NSEventModifierMask state)
{
var specialKey = ConvertKey (ref ch);
var keyDescriptor = new KeyDescriptor (specialKey, ch, ConvertModifiers (state), state);
return keyDescriptor;
}
static ModifierKeys ConvertModifiers (NSEventModifierMask e)
{
var m = ModifierKeys.None;
if ((e & NSEventModifierMask.ControlKeyMask) != 0)
m |= ModifierKeys.Control;
if ((e & NSEventModifierMask.AlternateKeyMask) != 0)
m |= ModifierKeys.Alt;
if ((e & NSEventModifierMask.CommandKeyMask) != 0)
m |= ModifierKeys.Command;
if ((e & NSEventModifierMask.ShiftKeyMask) != 0)
m |= ModifierKeys.Shift;
return m;
}
public static Keys Convert(string keyEquivalent, NSEventModifierMask modifier)
{
return Keys.None;
}
private KeyModifiers GetModifiers(NSEventModifierMask mask)
{
OpenTK.Input.KeyModifiers modifiers = 0;
if ((mask & NSEventModifierMask.ControlKeyMask) != 0) modifiers |= OpenTK.Input.KeyModifiers.Control;
if ((mask & NSEventModifierMask.ShiftKeyMask) != 0) modifiers |= OpenTK.Input.KeyModifiers.Shift;
if ((mask & NSEventModifierMask.AlternateKeyMask) != 0) modifiers |= OpenTK.Input.KeyModifiers.Alt;
return modifiers;
}
