public bool RawKeyEvent(AvnRawKeyEventType type, uint timeStamp, AvnInputModifiers modifiers, uint key)
{
Dispatcher.UIThread.RunJobs(DispatcherPriority.Input + 1);
var args = new RawKeyEventArgs(_keyboard, timeStamp, (RawKeyEventType)type, (Key)key, (InputModifiers)modifiers);
Input?.Invoke(args);
return(args.Handled);
}
private void KListenerKeyUp(object sender, RawKeyEventArgs args)
{
Console.WriteLine(args.Key.ToString());
if (ContainsKey(args.Key))
{
pressed[args.Key] = false;
((MainWindow)Current.MainWindow).HighlightButton(args.Key, false);
}
}
void KListener_KeyDown(object sender, RawKeyEventArgs args)
{
var text = args.Key.ToString();
var m = args;
_keysPressedIntowSecound.Add(args.Key);
if (tm == null || !tm.IsEnabled)
{
TmBind();
}
}
void KListener_KeyDown(object sender, RawKeyEventArgs args)
{
if (args.Key.ToString() == "F10")
{
WindowControl.Current.TakeScreenShot();
}
#region .Do(debug)
#if DEBUG
Console.WriteLine(args.Key.ToString());
#endif
#endregion
}
protected override bool OnKeyPressEvent(Gdk.EventKey evnt)
{
var e = new RawKeyEventArgs(
GtkKeyboardDevice.Instance,
evnt.Time,
RawKeyEventType.KeyDown,
GtkKeyboardDevice.ConvertKey(evnt.Key),
new string((char)Gdk.Keyval.ToUnicode((uint)evnt.Key), 1));
this.Input(e);
return(true);
}
private void Kb_KeyDown(object sender, RawKeyEventArgs args)
{
var keys = _settings.Get("keyList");
bool exists = false;
foreach (var key in keys)
{
if (key.Contains(args.VKCode.ToString()))
{
exists = true;
break;
}
}
BeginInvoke((MethodInvoker)(() =>
{
keyboardCounterKeyClick.Close();
keyboardCounterKeyClick.Dispose();
keyboardCounterKeyClick = null;
if (!exists)
{
//get file name to save
var filenameFrm = new ClickCounterFileName();
filenameFrm.ShowDialog();
string filename = filenameFrm.textBox_FileName.Text;
filenameFrm.Dispose();
//check if filename is valid
string invalidChars = new string(Path.GetInvalidFileNameChars());
foreach (var invalidChar in invalidChars)
{
if (filename.Contains(invalidChar))
{
return;
}
}
if (filename.Trim() != string.Empty)
{
if (!filename.EndsWith(".txt"))
{
filename += ".txt";
}
AddKey(args.VKCode, filename.Trim());
this.dataGridView1.Rows.Add(args.Key, "0", filename.Trim());
}
}
}));
}
void KeyboardListenerKeyDown(object sender, RawKeyEventArgs args)
{
_window.Dispatcher.BeginInvoke(new Action(() =>
{
if (args.Key == Key.LeftCtrl)
{
_window.Show();
}
}), null);
//_window.Activate();
}
private void OnKeyPress(object sender, RawKeyEventArgs args)
{
if (enabled && isFocused)
{
var gameKeyBinds = this.keyBinds.GetKeyBinds((IGame)gamesComboBox.SelectedItem);
if (gameKeyBinds.ContainsKey(args.Key))
{
SendKeys.SendWait(gameKeyBinds[args.Key]);
}
}
}
private void _keyboardListener_KeyUp(object sender, RawKeyEventArgs args)
{
if (_keyList.Contains(args.VKCode))
{
if (_keyPressed[args.VKCode])
{
_keyCount[args.VKCode]++;
_saver.Save(_filenames[args.VKCode], _keyCount[args.VKCode].ToString());
_keyPressed[args.VKCode] = false;
_keysPerX?.AddToKeys();
}
}
}
private void OnKeyPressed(object sender, RawKeyEventArgs e)
{
Event = e;
if (_keyboardDevices.TryGetValue(e.Device, out RawKeyboardDevice dev))
{
Device = dev;
}
if (e.Device == new IntPtr(0x1b21034f) && ShouldHandle.IsChecked == true)
{
e.Handled = true;
}
DeviceCount = _keyboardDevices.Count;
}
void KListener_KeyUp(object sender, RawKeyEventArgs args)
{
if (args.Key == Key.LeftCtrl || args.Key == Key.RightCtrl)
{
ctrl = false;
}
else if (args.Key == Key.LeftShift || args.Key == Key.RightShift)
{
shift = false;
}
else if (args.Key == Key.LeftAlt || args.Key == Key.RightAlt)
{
alt = false;
}
}
private void ProcessKeyEvent(EventKey evnt)
{
_lastKeyEventTimestamp = evnt.Time;
if (_imContext.FilterKeypress(evnt))
{
return;
}
var e = new RawKeyEventArgs(
GtkKeyboardDevice.Instance,
evnt.Time,
evnt.Type == EventType.KeyPress ? RawKeyEventType.KeyDown : RawKeyEventType.KeyUp,
GtkKeyboardDevice.ConvertKey(evnt.Key), GetModifierKeys(evnt.State));
Input(e);
}
void keyListener_KeyDown(object sender, RawKeyEventArgs args)
{
log.Debug("press key : " + args.Key.ToString());
//if (args.Key == Key.G)
//{
// InsertTopicImage();
//}
//else if (args.Key == Key.H)
//{
// InsertAnswerImage();
//}
// not need else
}
private void RawKeyDown(RawKeyEventArgs e)
{
const InputModifiers modifiers = InputModifiers.Control | InputModifiers.Shift;
if ((e.Modifiers) == modifiers)
{
var point = MouseDevice.Instance.GetPosition(Root);
var control = Root.GetVisualsAt(point).FirstOrDefault(x => !(x is AdornerLayer));
if (control != null)
{
var vm = (DevToolsViewModel)DataContext;
vm.SelectControl((IControl)control);
}
}
}
private void RawKeyDown(RawKeyEventArgs e)
{
const InputModifiers modifiers = InputModifiers.Control | InputModifiers.Shift;
if ((e.Modifiers) == modifiers)
{
var point = (Root.VisualRoot as IInputRoot)?.MouseDevice?.GetPosition(Root) ?? default(Point);
var control = Root.GetVisualsAt(point, x => (!(x is AdornerLayer) && x.IsVisible))
.FirstOrDefault();
if (control != null)
{
var vm = (DevToolsViewModel)DataContext;
vm.SelectControl((IControl)control);
}
}
}
private void _keyboardListener_KeyUp(object sender, RawKeyEventArgs args)
{
if (_keyList.Contains(args.VKCode))
{
if (_keyPressed[args.VKCode])
{
_keyCount[args.VKCode]++;
if (!disableSavingToDisk)
{
_saver.Save(_filenames[args.VKCode], _keyCount[args.VKCode].ToString());
}
_fileMapManager.Write("SC-" + _filenames[args.VKCode].Replace(".txt", ""), _keyCount[args.VKCode].ToString());
_keyPressed[args.VKCode] = false;
_keysPerX?.AddToKeys();
}
}
}
void KListener_KeyDown(object sender, RawKeyEventArgs args)
{
switch (args.Key)
{
case Key.MediaPlayPause:
Application.Current.Dispatcher.Invoke(() => MusicManager.CSCoreEngine.TogglePlayPause());
break;
case Key.MediaPreviousTrack:
Application.Current.Dispatcher.Invoke(() => MusicManager.GoBackward());
break;
case Key.MediaNextTrack:
Application.Current.Dispatcher.Invoke(() => MusicManager.GoForward());
break;
}
}
private void KListener_KeyUp(object sender, RawKeyEventArgs args)
{
if (args.Key == System.Windows.Input.Key.Y)
up = 0;
if (args.Key == System.Windows.Input.Key.H)
up = 0;
if (args.Key == System.Windows.Input.Key.A)
side = 0;
if (args.Key == System.Windows.Input.Key.D)
side = 0;
if (args.Key == System.Windows.Input.Key.S)
forward = 0;
if (args.Key == System.Windows.Input.Key.W)
forward = 0;
if (args.Key == System.Windows.Input.Key.LeftShift)
shift = 1;
}
public void WhenRightArrowKeyPressed_ShouldFireOnMoveRight()
{
// arrange
var wasCalled = false;
keyboardInputProvider.OnMoveRight += (o, e) => wasCalled = true;
bool isSysKey = false;
var keyArgs = new RawKeyEventArgs(KeyCodesHelper.RightArrow, isSysKey, "Right");
keyArgs.Key = Key.Right;
// act
keyboardListenerMock.Raise(
x => x.KeyDown += null, keyArgs);
// assert
Assert.IsTrue(wasCalled);
}
public void WhenDownArrowKeyReleased_ShouldFireOnMoveBackwardStopped()
{
// arrange
var wasCalled = false;
keyboardInputProvider.OnMoveBackwardStopped += (o, e) => wasCalled = true;
bool isSysKey = false;
var keyArgs = new RawKeyEventArgs(KeyCodesHelper.DownArrow, isSysKey, "Down");
keyArgs.Key = Key.Down;
// act
keyboardListenerMock.Raise(
x => x.KeyUp += null, keyArgs);
// assert
Assert.IsTrue(wasCalled);
}
private unsafe bool OnKeyEvent(IntPtr w, IntPtr pev, IntPtr userData)
{
var evnt = (GdkEventKey *)pev;
_lastKbdEvent = evnt->time;
if (Native.GtkImContextFilterKeypress(_imContext, pev))
{
return(true);
}
var e = new RawKeyEventArgs(
Gtk3Platform.Keyboard,
evnt->time,
evnt->type == GdkEventType.KeyPress ? RawKeyEventType.KeyDown : RawKeyEventType.KeyUp,
Avalonia.Gtk.Common.KeyTransform.ConvertKey((GdkKey)evnt->keyval), GetModifierKeys((GdkModifierType)evnt->state));
Input(e);
return(true);
}
private void HandleKeyUp(RawKeyEventArgs args)
{
if (Context.IsSendingKey)
{
return;
}
if (!IsActive)
{
return;
}
if (args.Key == Context.NextUpKeyToIgnore)
{
args.IsHandled = true;
Context.NextUpKeyToIgnore = null;
}
}
void KListener_KeyDown(object sender, RawKeyEventArgs args)
{
try
{
HandleKeyDown(args);
}
catch (Exception ex)
{
try
{
if (Container != null)
{
Container.Log(true, "Generic error during KeyDown handling: " + ex.Message);
}
}
catch { }
}
}
async ValueTask <bool> IX11InputMethodControl.HandleEventAsync(RawKeyEventArgs args, int keyVal, int keyCode)
{
try
{
return(await _queue.EnqueueAsync(async() => await HandleKeyCore(args, keyVal, keyCode)));
}
// Disconnected
catch (OperationCanceledException)
{
return(false);
}
// Error, disconnect
catch (Exception e)
{
await QueueOnError(e);
return(false);
}
}
public bool ProcessRawInput(IntPtr hdevice)
{
int size = 0;
Win32Methods.GetRawInputData(hdevice, DataCommand.RID_INPUT, IntPtr.Zero, ref size, Marshal.SizeOf(typeof(RawInputHeader)));
InputData rawBuffer;
if (Win32Methods.GetRawInputData(hdevice, DataCommand.RID_INPUT, out rawBuffer, ref size, Marshal.SizeOf(typeof(RawInputHeader))) != size)
{
Debug.WriteLine("Error getting the rawinput buffer");
return(false);
}
int vKey = rawBuffer.data.keyboard.VKey;
int makecode = rawBuffer.data.keyboard.Makecode;
int flags = rawBuffer.data.keyboard.Flags;
if (vKey == Win32Consts.KEYBOARD_OVERRUN_MAKE_CODE)
{
return(false);
}
var isE0BitSet = ((flags & Win32Consts.RI_KEY_E0) != 0);
bool isBreakBitSet = (flags & Win32Consts.RI_KEY_BREAK) != 0;
uint message = rawBuffer.data.keyboard.Message;
Key key = KeyInterop.KeyFromVirtualKey(AdjustVirtualKey(rawBuffer, vKey, isE0BitSet, makecode));
EventHandler <RawKeyEventArgs> keyPressed = KeyPressed;
if (keyPressed != null)
{
var rawInputEventArgs = new RawKeyEventArgs(rawBuffer.header.hDevice, isBreakBitSet ? KeyPressState.Up : KeyPressState.Down, message, key, vKey);
keyPressed(this, rawInputEventArgs);
if (rawInputEventArgs.Handled)
{
//Remove the message
MSG msg;
Win32Methods.PeekMessage(out msg, IntPtr.Zero, Win32Consts.WM_KEYDOWN, Win32Consts.WM_KEYUP, Win32Consts.PM_REMOVE);
}
return(rawInputEventArgs.Handled);
}
return(false);
}
/// <summary>
/// KeyDown event
/// </summary>
/// <param name="sender"></param>
/// <param name="args"></param>
void KListener_KeyDown(object sender, RawKeyEventArgs args)
{
try
{
SetKeyDown(args.Key);
// Ctrl + F11 (Action on foreground app)
if (IsKeyDown(Key.LeftCtrl) && IsKeyDown(Key.F11))
{
WindowHandler.ChangeBorderStyle(WindowLib.GetForegroundWindow());
}
// Ctrl + F12 (Adds / Removes foreground app to / from list)
else if (IsKeyDown(Key.LeftCtrl) && IsKeyDown(Key.F12))
{
ProcessInfos.AddOrRemove(this.Processes);
}
}
catch { }
}
private void KListener_KeyDown(object sender, RawKeyEventArgs args)
{
if (args.Key == System.Windows.Input.Key.Y)
up = 2;
if (args.Key == System.Windows.Input.Key.H)
up = -1;
if (args.Key == System.Windows.Input.Key.U)
glide = !glide;
if (args.Key == System.Windows.Input.Key.A)
side = -1;
if (args.Key == System.Windows.Input.Key.D)
side = 1;
if (args.Key == System.Windows.Input.Key.S)
forward = 1;
if (args.Key == System.Windows.Input.Key.W)
forward = -1;
if (args.Key == System.Windows.Input.Key.LeftShift)
shift = 2;
}
private bool?DispatchKeyEventInternal(KeyEvent e, out bool callBase)
{
var unicodeTextInput = UnicodeTextInput(e);
if (e.Action == KeyEventActions.Multiple && unicodeTextInput == null)
{
callBase = true;
return(null);
}
var rawKeyEvent = new RawKeyEventArgs(
AndroidKeyboardDevice.Instance,
Convert.ToUInt64(e.EventTime),
_view.InputRoot,
e.Action == KeyEventActions.Down ? RawKeyEventType.KeyDown : RawKeyEventType.KeyUp,
AndroidKeyboardDevice.ConvertKey(e.KeyCode), GetModifierKeys(e));
_view.Input(rawKeyEvent);
if ((e.Action == KeyEventActions.Down && e.UnicodeChar >= 32) ||
unicodeTextInput != null)
{
var rawTextEvent = new RawTextInputEventArgs(
AndroidKeyboardDevice.Instance,
Convert.ToUInt32(e.EventTime),
_view.InputRoot,
unicodeTextInput ?? Convert.ToChar(e.UnicodeChar).ToString()
);
_view.Input(rawTextEvent);
}
if (e.Action == KeyEventActions.Up)
{
//nothing to do here more call base no need of more events
callBase = true;
return(null);
}
callBase = false;
return(false);
}
private void OnKKDown(object sender, RawKeyEventArgs args)
{
switch (args.Key)
{
case Keys.Q:
_recordCursorPos = !_recordCursorPos;
break;
case Keys.R:
SetSavedColor(Cursor.Position);
break;
case Keys.Left:
if (_recordCursorPos)
{
Cursor.Position = new Point(Cursor.Position.X - 1, Cursor.Position.Y);
}
break;
case Keys.Right:
if (_recordCursorPos)
{
Cursor.Position = new Point(Cursor.Position.X + 1, Cursor.Position.Y);
}
break;
case Keys.Down:
if (_recordCursorPos)
{
Cursor.Position = new Point(Cursor.Position.X, Cursor.Position.Y + 1);
}
break;
case Keys.Up:
if (_recordCursorPos)
{
Cursor.Position = new Point(Cursor.Position.X, Cursor.Position.Y - 1);
}
break;
}
}
public void Impl_Input_Should_Pass_Input_To_InputManager()
{
using (PerspexLocator.EnterScope())
{
RegisterServices();
var impl = new Mock <ITopLevelImpl>();
impl.SetupAllProperties();
var target = new TestTopLevel(impl.Object);
var input = new RawKeyEventArgs(
new Mock <IKeyboardDevice>().Object,
0,
RawKeyEventType.KeyDown,
Key.A, InputModifiers.None);
impl.Object.Input(input);
var inputManagerMock = Mock.Get(InputManager.Instance);
inputManagerMock.Verify(x => x.Process(input));
}
}
private void ProcessKeyEvent(EventKey evnt)
{
_lastKeyEventTimestamp = evnt.Time;
if (_imContext.FilterKeypress(evnt))
return;
var e = new RawKeyEventArgs(
GtkKeyboardDevice.Instance,
evnt.Time,
evnt.Type == EventType.KeyPress ? RawKeyEventType.KeyDown : RawKeyEventType.KeyUp,
GtkKeyboardDevice.ConvertKey(evnt.Key), GetModifierKeys(evnt.State));
Input(e);
}
protected virtual IntPtr WndProc(IntPtr hWnd, uint msg, IntPtr wParam, IntPtr lParam)
{
bool unicode = UnmanagedMethods.IsWindowUnicode(hWnd);
const double wheelDelta = 120.0;
uint timestamp = unchecked((uint)UnmanagedMethods.GetMessageTime());
RawInputEventArgs e = null;
WindowsMouseDevice.Instance.CurrentWindow = this;
switch ((UnmanagedMethods.WindowsMessage)msg)
{
case UnmanagedMethods.WindowsMessage.WM_ACTIVATE:
var wa = (UnmanagedMethods.WindowActivate)((int)wParam & 0xffff);
switch (wa)
{
case UnmanagedMethods.WindowActivate.WA_ACTIVE:
case UnmanagedMethods.WindowActivate.WA_CLICKACTIVE:
_isActive = true;
Activated?.Invoke();
break;
case UnmanagedMethods.WindowActivate.WA_INACTIVE:
_isActive = false;
Deactivated?.Invoke();
break;
}
return IntPtr.Zero;
case UnmanagedMethods.WindowsMessage.WM_DESTROY:
if (Closed != null)
{
UnmanagedMethods.UnregisterClass(_className, Marshal.GetHINSTANCE(GetType().Module));
Closed();
}
return IntPtr.Zero;
case UnmanagedMethods.WindowsMessage.WM_DPICHANGED:
var dpi = (int)wParam & 0xffff;
var newDisplayRect = (UnmanagedMethods.RECT)Marshal.PtrToStructure(lParam, typeof(UnmanagedMethods.RECT));
Position = new Point(newDisplayRect.left, newDisplayRect.top);
_scaling = dpi / 96.0;
ScalingChanged?.Invoke(_scaling);
return IntPtr.Zero;
case UnmanagedMethods.WindowsMessage.WM_KEYDOWN:
case UnmanagedMethods.WindowsMessage.WM_SYSKEYDOWN:
e = new RawKeyEventArgs(
WindowsKeyboardDevice.Instance,
timestamp,
RawKeyEventType.KeyDown,
KeyInterop.KeyFromVirtualKey((int)wParam), WindowsKeyboardDevice.Instance.Modifiers);
break;
case UnmanagedMethods.WindowsMessage.WM_KEYUP:
case UnmanagedMethods.WindowsMessage.WM_SYSKEYUP:
e = new RawKeyEventArgs(
WindowsKeyboardDevice.Instance,
timestamp,
RawKeyEventType.KeyUp,
KeyInterop.KeyFromVirtualKey((int)wParam), WindowsKeyboardDevice.Instance.Modifiers);
break;
case UnmanagedMethods.WindowsMessage.WM_CHAR:
// Ignore control chars
if (wParam.ToInt32() >= 32)
{
e = new RawTextInputEventArgs(WindowsKeyboardDevice.Instance, timestamp,
new string((char)wParam.ToInt32(), 1));
}
break;
case UnmanagedMethods.WindowsMessage.WM_LBUTTONDOWN:
case UnmanagedMethods.WindowsMessage.WM_RBUTTONDOWN:
case UnmanagedMethods.WindowsMessage.WM_MBUTTONDOWN:
e = new RawMouseEventArgs(
WindowsMouseDevice.Instance,
timestamp,
_owner,
msg == (int)UnmanagedMethods.WindowsMessage.WM_LBUTTONDOWN
? RawMouseEventType.LeftButtonDown
: msg == (int)UnmanagedMethods.WindowsMessage.WM_RBUTTONDOWN
? RawMouseEventType.RightButtonDown
: RawMouseEventType.MiddleButtonDown,
DipFromLParam(lParam), GetMouseModifiers(wParam));
break;
case UnmanagedMethods.WindowsMessage.WM_LBUTTONUP:
case UnmanagedMethods.WindowsMessage.WM_RBUTTONUP:
case UnmanagedMethods.WindowsMessage.WM_MBUTTONUP:
e = new RawMouseEventArgs(
WindowsMouseDevice.Instance,
timestamp,
_owner,
msg == (int) UnmanagedMethods.WindowsMessage.WM_LBUTTONUP
? RawMouseEventType.LeftButtonUp
: msg == (int) UnmanagedMethods.WindowsMessage.WM_RBUTTONUP
? RawMouseEventType.RightButtonUp
: RawMouseEventType.MiddleButtonUp,
DipFromLParam(lParam), GetMouseModifiers(wParam));
break;
case UnmanagedMethods.WindowsMessage.WM_MOUSEMOVE:
if (!_trackingMouse)
{
var tm = new UnmanagedMethods.TRACKMOUSEEVENT
{
cbSize = Marshal.SizeOf(typeof(UnmanagedMethods.TRACKMOUSEEVENT)),
dwFlags = 2,
hwndTrack = _hwnd,
dwHoverTime = 0,
};
UnmanagedMethods.TrackMouseEvent(ref tm);
}
e = new RawMouseEventArgs(
WindowsMouseDevice.Instance,
timestamp,
_owner,
RawMouseEventType.Move,
DipFromLParam(lParam), GetMouseModifiers(wParam));
break;
case UnmanagedMethods.WindowsMessage.WM_MOUSEWHEEL:
e = new RawMouseWheelEventArgs(
WindowsMouseDevice.Instance,
timestamp,
_owner,
ScreenToClient(DipFromLParam(lParam)),
new Vector(0, ((int)wParam >> 16) / wheelDelta), GetMouseModifiers(wParam));
break;
case UnmanagedMethods.WindowsMessage.WM_MOUSEHWHEEL:
e = new RawMouseWheelEventArgs(
WindowsMouseDevice.Instance,
timestamp,
_owner,
ScreenToClient(DipFromLParam(lParam)),
new Vector(-((int)wParam >> 16) / wheelDelta,0), GetMouseModifiers(wParam));
break;
case UnmanagedMethods.WindowsMessage.WM_MOUSELEAVE:
_trackingMouse = false;
e = new RawMouseEventArgs(
WindowsMouseDevice.Instance,
timestamp,
_owner,
RawMouseEventType.LeaveWindow,
new Point(), WindowsKeyboardDevice.Instance.Modifiers);
break;
case UnmanagedMethods.WindowsMessage.WM_NCLBUTTONDOWN:
case UnmanagedMethods.WindowsMessage.WM_NCRBUTTONDOWN:
case UnmanagedMethods.WindowsMessage.WM_NCMBUTTONDOWN:
e = new RawMouseEventArgs(
WindowsMouseDevice.Instance,
timestamp,
_owner,
msg == (int)UnmanagedMethods.WindowsMessage.WM_NCLBUTTONDOWN
? RawMouseEventType.NonClientLeftButtonDown
: msg == (int)UnmanagedMethods.WindowsMessage.WM_NCRBUTTONDOWN
? RawMouseEventType.RightButtonDown
: RawMouseEventType.MiddleButtonDown,
new Point(0, 0), GetMouseModifiers(wParam));
break;
case UnmanagedMethods.WindowsMessage.WM_PAINT:
if (Paint != null)
{
UnmanagedMethods.PAINTSTRUCT ps;
if (UnmanagedMethods.BeginPaint(_hwnd, out ps) != IntPtr.Zero)
{
UnmanagedMethods.RECT r;
UnmanagedMethods.GetUpdateRect(_hwnd, out r, false);
var f = Scaling;
Paint(new Rect(r.left / f, r.top / f, (r.right - r.left) / f, (r.bottom - r.top) / f));
UnmanagedMethods.EndPaint(_hwnd, ref ps);
}
}
return IntPtr.Zero;
case UnmanagedMethods.WindowsMessage.WM_SIZE:
if (Resized != null &&
(wParam == (IntPtr)UnmanagedMethods.SizeCommand.Restored ||
wParam == (IntPtr)UnmanagedMethods.SizeCommand.Maximized))
{
var clientSize = new Size((int)lParam & 0xffff, (int)lParam >> 16);
Resized(clientSize / Scaling);
}
return IntPtr.Zero;
}
if (e != null && Input != null)
{
Input(e);
if (e.Handled)
{
return IntPtr.Zero;
}
}
return UnmanagedMethods.DefWindowProc(hWnd, msg, wParam, lParam);
}
public void Impl_Input_Should_Pass_Input_To_InputManager()
{
var inputManagerMock = new Mock<IInputManager>();
var services = TestServices.StyledWindow.With(inputManager: inputManagerMock.Object);
using (UnitTestApplication.Start(services))
{
var impl = new Mock<ITopLevelImpl>();
impl.SetupAllProperties();
var target = new TestTopLevel(impl.Object);
var input = new RawKeyEventArgs(
new Mock<IKeyboardDevice>().Object,
0,
RawKeyEventType.KeyDown,
Key.A, InputModifiers.None);
impl.Object.Input(input);
inputManagerMock.Verify(x => x.ProcessInput(input));
}
}
private void KListener_KeyDown(object sender, RawKeyEventArgs args)
{
//Console.WriteLine(args.Key.ToString());
if (args.Key.ToString() == "Return") {
// Verifica se a janela está focalizada
if (IsActive) {
// Seja não estiver editando
if (editando == false) {
tbLeitor.Focus();
editando = true;
//Console.WriteLine("Editando");
}
else {
//Console.WriteLine("Devo inicializar");
editando = false;
IncluirLeitor(tbLeitor.Text);
tbLeitor.Text = "";
}
}
}
}
