private void HandleKeyEvent(XKeyEvent evt)
{
bool pressed = evt.type == XEventName.KeyPress;
if (Settings.DEBUG_PRINTINPUTKEYS)
{
ISLogger.Write("DEBUG: KEY {0} (raw {1})", (LinuxKeyCode)evt.keycode, evt.keycode);
}
//Raise a hotkey pressed event instead of an input event
if (pressed)
{
if (CheckForHotkey(evt))
{
return;
}
}
WindowsVirtualKey key = KeyTranslator.LinuxToWindows((LinuxKeyCode)evt.keycode);
if (pressed)
{
OnInputReceived(new ISInputData(ISInputCode.IS_KEYDOWN, (short)key, 0));
}
else
{
OnInputReceived(new ISInputData(ISInputCode.IS_KEYUP, (short)key, 0));
}
}
private bool CheckForHotkey(XKeyEvent evt)
{
if (evt.type != XEventName.KeyPress)
{
return(false);
}
foreach (var hk in hotkeys)
{
if (hk.Key == KeyTranslator.LinuxToWindows((LinuxKeyCode)evt.keycode) &&
((LinuxKeyMask)evt.state).HasFlag(ConvertMask(hk.Modifiers)))
{
if (hk is FunctionHotkey fhk)
{
OnFunctionHotkeyPressed(fhk.Function);
}
else if (hk is ClientHotkey chk)
{
OnClientHotkeyPressed(chk.TargetClient);
}
return(true);
}
}
return(false);
}
public void HandleKeyPress(XKeyEvent e, XWindow window, XWindow root, XWindow subwindow)
{
if (Convert.ToBoolean(main_win.LookupKeysym(ref e) == XKeySym.XK_q))
{
Console.WriteLine("Cleaning up and exiting...");
//pix.Free ();
gc.Dispose();
bg_color.Dispose();
handle_color.Dispose();
resize_top_left_win.Dispose();
resize_top_right_win.Dispose();
resize_bottom_left_win.Dispose();
resize_bottom_right_win.Dispose();
resize_main_win.Dispose();
main_win.Dispose();
ev.Dispose();
s.Dispose();
dpy.Dispose();
Environment.Exit(0);
}
}
private ConsoleKey X11ToConsoleKey(XKeyEvent ev)
{
var intKeySym = (int)_mainWin.LookupKeysym(ref ev);
if (intKeySym >= (int)XKeySym.XK_a)
{
intKeySym -= (int)XKeySym.XK_a - (int)XKeySym.XK_A;
}
return((ConsoleKey)intKeySym);
}
private bool TranslateKeyEvent(ref XKeyEvent e, out Key key)
{
if (xkb_supported)
{
return(TranslateKeyXkb(e.display, e.keycode, out key));
}
else
{
return(TranslateKeyX11(ref e, out key));
}
}
private bool TranslateKeyX11(ref XKeyEvent e, out Key key)
{
XKey keysym = (XKey)API.LookupKeysym(ref e, 0);
XKey keysym2 = (XKey)API.LookupKeysym(ref e, 1);
key = X11KeyMap.TranslateXKey(keysym);
if (key == Key.Unknown)
{
key = X11KeyMap.TranslateXKey(keysym2);
}
if (key == Key.Unknown)
{
Debug.Print("KeyCode {0} (Keysym: {1}, {2}) not mapped.", e.keycode, (XKey)keysym, (XKey)keysym2);
}
return(key != Key.Unknown);
}
private Gdk.FilterReturn FilterFunction(IntPtr xEvent, Gdk.Event evnt)
{
XKeyEvent xKeyEvent = (XKeyEvent)Marshal.PtrToStructure(
xEvent,
typeof(XKeyEvent));
if (xKeyEvent.type == KeyPress)
{
if (xKeyEvent.keycode == this.keycode &&
xKeyEvent.state == (uint)this.modifiers)
{
this.OnPressed(EventArgs.Empty);
}
}
return(Gdk.FilterReturn.Continue);
}
private Gdk.FilterReturn FilterFunction(IntPtr xEvent, Gdk.Event evnt)
{
XKeyEvent xKeyEvent = (XKeyEvent)Marshal.PtrToStructure(
xEvent,
typeof(XKeyEvent));
if (xKeyEvent.type == KeyPress)
{
for (var i = 0; i < keycodes.Count; i++)
{
if (xKeyEvent.keycode == keycodes[i] && (xKeyEvent.state & modifiers[i]) == this.modifiers[i])
{
this.OnPressed(new KeyPressedEventArgs(originalModifier[i], originalKey[i]));
break;
}
}
}
return(Gdk.FilterReturn.Continue);
}
private Gdk.FilterReturn FilterKey(IntPtr xeventPtr, Gdk.Event gdkEvent)
{
Console.WriteLine("filter " + gdkEvent.Type);
if (DateTime.Now - last_raise < raise_delay)
{
return(Gdk.FilterReturn.Continue);
}
last_raise = DateTime.Now;
XKeyEvent xevent = (XKeyEvent)Marshal.PtrToStructure(xeventPtr, typeof(XKeyEvent));
if (xevent.type != XEventName.KeyPress)
{
return(Gdk.FilterReturn.Continue);
}
int keycode = (int)xevent.keycode;
object x = key_map[keycode];
Console.WriteLine("filter " + keycode);
if (x == null)
{
return(Gdk.FilterReturn.Continue);
}
SpecialKey key = (SpecialKey)key_map[keycode];
if (key_registrations[keycode] != null)
{
x = key_registrations[keycode];
if (x is SpecialKeyPressedHandler)
{
((SpecialKeyPressedHandler)x)(this, key);
}
return(Gdk.FilterReturn.Remove);
}
return(Gdk.FilterReturn.Continue);
}
void handleKeyPressEvent(XKeyEvent e, XWindow window, XWindow root, XWindow subwindow)
{
XKeySym ks = window.KeycodeToKeysym(e.keycode);
if (ks == XKeySym.NoSymbol)
{
return;
}
switch (ks)
{
case XKeySym.XK_Delete:
Console.WriteLine("Window manager is restarting...");
restart();
break;
case XKeySym.XK_End:
Console.WriteLine("Window manager is quitting.");
quitNicely();
break;
}
}
public RCode HandleSystemEvent()
{
while (Xlib.XPending(display) > 0)
{
Xlib.XNextEvent(display, ev);
XAnyEvent xevent = Marshal.PtrToStructure <XAnyEvent>(ev);
switch (xevent.type)
{
case (int)Event.ClientMessage:
XClientMessageEvent xClientMessageEvent = Marshal.PtrToStructure <XClientMessageEvent>(ev);
if (xClientMessageEvent.data == (IntPtr)deleteWindowMessage)
{
PixelGameEngine.Instance.Terminate();
}
break;
case (int)Event.KeyPress:
case (int)Event.KeyRelease:
XKeyEvent xKeyEvent = Marshal.PtrToStructure <XKeyEvent>(ev);
KeySym sym = XlibExt.XLookupKeysym(new XKeyEvent[] { xKeyEvent }, 0);
pge.Input.UpdateKeyState((int)mapKeys[(long)sym], xevent.type == (int)Event.KeyPress);
break;
case (int)Event.ButtonPress:
case (int)Event.ButtonRelease:
XButtonEvent xButtonEvent = Marshal.PtrToStructure <XButtonEvent>(ev);
bool pressed = xevent.type == (int)Event.ButtonPress;
switch (xButtonEvent.button)
{
case 1:
case 2:
case 3:
pge.Input.UpdateMouseState((int)xButtonEvent.button - 1, pressed);
break;
case 4:
pge.Input.UpdateMouseWheel(120);
break;
case 5:
pge.Input.UpdateMouseWheel(-120);
break;
case 6:
case 7:
case 8:
case 9:
pge.Input.UpdateMouseState((int)xButtonEvent.button - 3, pressed);
break;
}
break;
case (int)Event.MotionNotify:
XMotionEvent xMotionEvent = Marshal.PtrToStructure <XMotionEvent>(ev);
pge.Input.UpdateMouse(xMotionEvent.x, xMotionEvent.y);
break;
case (int)Event.EnterNotify:
pge.Input.UpdateMouseFocus(true);
break;
case (int)Event.LeaveNotify:
pge.Input.UpdateMouseFocus(false);
break;
case (int)Event.FocusIn:
pge.Input.UpdateKeyFocus(true);
break;
case (int)Event.FocusOut:
pge.Input.UpdateKeyFocus(false);
break;
}
}
return(RCode.OK);
}
public static extern IntPtr XLookupKeysym(ref XKeyEvent key_event, int index);
public static extern int XLookupString(ref XKeyEvent even, StringBuilder bufferReturn, int bytesBuffer, out int keysymReturn, IntPtr xComposeStatus);
internal static extern KeySym LookupKeysym(ref XKeyEvent key_event, int index);
public static extern int XLookupString(ref XKeyEvent event_struct, [Out] byte[] buffer_return,
int bytes_buffer, [Out] KeySym[] keysym_return, IntPtr status_in_out);
internal static extern int XLookupString(ref XKeyEvent @event, IntPtr buffer_return, int bytes_buffer,
out ULONG keysym_return, IntPtr status_in_out);
public override void EnterMessageLoop(bool runInBackground)
{
IntPtr e = System.Runtime.InteropServices.Marshal.AllocHGlobal(24 * sizeof(long));
bool running = true;
while (running)
{
while (XPending(_display) != 0)
{
XNextEvent(_display, e);
if (XFilterEvent(e, IntPtr.Zero))
{
continue;
}
XAnyEvent anyEvent = (XAnyEvent)System.Runtime.InteropServices.Marshal.PtrToStructure(e, typeof(XAnyEvent));
switch ((Event)anyEvent.type)
{
case Event.ClientMessage:
{
running = false;
break;
}
case Event.ConfigureNotify:
{
XConfigureEvent configureEvent = (XConfigureEvent)System.Runtime.InteropServices.Marshal.PtrToStructure(e, typeof(XConfigureEvent));
LocationChanged?.Invoke(this, configureEvent.x, configureEvent.y);
SizeChanged?.Invoke(this, configureEvent.width, configureEvent.height);
break;
}
case Event.FocusIn:
{
Activated?.Invoke(this);
break;
}
case Event.FocusOut:
{
Deactivated?.Invoke(this);
break;
}
case Event.MotionNotify:
{
XMotionEvent motionEvent = (XMotionEvent)System.Runtime.InteropServices.Marshal.PtrToStructure(e, typeof(XMotionEvent));
MouseMove?.Invoke(this, motionEvent.x, motionEvent.y);
break;
}
case Event.ButtonPress:
{
XButtonEvent buttonEvent = (XButtonEvent)System.Runtime.InteropServices.Marshal.PtrToStructure(e, typeof(XButtonEvent));
switch ((Button)buttonEvent.button)
{
case Button.Button1:
{
MouseButtonDown?.Invoke(this, buttonEvent.x, buttonEvent.y, MouseButton.Left);
break;
}
case Button.Button2:
{
MouseButtonDown?.Invoke(this, buttonEvent.x, buttonEvent.y, MouseButton.Middle);
break;
}
case Button.Button3:
{
MouseButtonDown?.Invoke(this, buttonEvent.x, buttonEvent.y, MouseButton.Right);
break;
}
case Button.Button4:
{
MouseWheel?.Invoke(this, buttonEvent.x, buttonEvent.y, 120);
break;
}
case Button.Button5:
{
MouseWheel?.Invoke(this, buttonEvent.x, buttonEvent.y, -120);
break;
}
}
break;
}
case Event.ButtonRelease:
{
XButtonEvent buttonEvent = (XButtonEvent)System.Runtime.InteropServices.Marshal.PtrToStructure(e, typeof(XButtonEvent));
switch ((Button)buttonEvent.button)
{
case Button.Button1:
{
MouseButtonUp?.Invoke(this, buttonEvent.x, buttonEvent.y, MouseButton.Left);
break;
}
case Button.Button2:
{
MouseButtonUp?.Invoke(this, buttonEvent.x, buttonEvent.y, MouseButton.Middle);
break;
}
case Button.Button3:
{
MouseButtonUp?.Invoke(this, buttonEvent.x, buttonEvent.y, MouseButton.Right);
break;
}
}
break;
}
case Event.KeyPress:
{
XKeyEvent keyEvent = (XKeyEvent)System.Runtime.InteropServices.Marshal.PtrToStructure(e, typeof(XKeyEvent));
KeySym ks = XLookupKeysym(ref keyEvent, 0);
Key key = NoesisKey(ks);
if (key != Key.None)
{
KeyDown?.Invoke(this, key);
}
if (_xic != IntPtr.Zero)
{
Status status = 0;
byte[] buffer = new byte[256];
KeySym ret_ks = (KeySym)0;
int size = Xutf8LookupString(_xic, e, buffer, 255, ref ret_ks, ref status);
if (size > 0 && ((int)status == XLookupChars || (int)status == XLookupBoth))
{
buffer[size] = 0;
Decoder decoder = _utf8.GetDecoder();
char[] text = new char[256];
int bytesUsed = 0;
int charsUsed = 0;
bool completed = false;
decoder.Convert(buffer, 0, size, text, 0, 255, true, out bytesUsed, out charsUsed, out completed);
for (int i = 0; i < charsUsed; ++i)
{
Char?.Invoke(this, text[i]);
}
}
}
break;
}
case Event.KeyRelease:
{
XKeyEvent keyEvent = (XKeyEvent)System.Runtime.InteropServices.Marshal.PtrToStructure(e, typeof(XKeyEvent));
KeySym ks = XLookupKeysym(ref keyEvent, 0);
Key key = NoesisKey(ks);
if (key != Key.None)
{
KeyUp?.Invoke(this, key);
}
break;
}
}
}
Render?.Invoke(this);
}
System.Runtime.InteropServices.Marshal.FreeHGlobal(e);
}
internal static extern int Xutf8LookupString(XIC ic, ref XKeyEvent @event, IntPtr buffer_return, int bytes_buffere,
IntPtr keysym_return, out int status_return);
// Refreshes the keycodes lookup table based
// on the current keyboard layout.
internal void RefreshKeycodes(IntPtr display)
{
// Approach inspired by GLFW: http://www.glfw.org/
// Huge props to the GLFW team!
if (xkb_supported)
{
unsafe
{
// Xkb.GetKeyboard appears to be broken (multiple bug reports across distros)
// so use Xkb.AllocKeyboard with Xkb.GetNames instead.
XkbDesc *keyboard = Xkb.AllocKeyboard(display);
if (keyboard != null)
{
Xkb.GetNames(display, XkbNamesMask.All, keyboard);
for (int i = 0; i < keycodes.Length; i++)
{
keycodes[i] = Key.Unknown;
}
// Map all alphanumeric keys of this layout
// Symbols are handled in GetKey() instead.
for (int i = keyboard->min_key_code; i <= keyboard->max_key_code; ++i)
{
string name = new string((sbyte *)keyboard->names->keys[i].name, 0, Xkb.KeyNameLength);
Key key = Key.Unknown;
switch (name)
{
case "TLDE":
key = Key.Tilde;
break;
case "AE01":
key = Key.Number1;
break;
case "AE02":
key = Key.Number2;
break;
case "AE03":
key = Key.Number3;
break;
case "AE04":
key = Key.Number4;
break;
case "AE05":
key = Key.Number5;
break;
case "AE06":
key = Key.Number6;
break;
case "AE07":
key = Key.Number7;
break;
case "AE08":
key = Key.Number8;
break;
case "AE09":
key = Key.Number9;
break;
case "AE10":
key = Key.Number0;
break;
case "AE11":
key = Key.Minus;
break;
case "AE12":
key = Key.Plus;
break;
case "AD01":
key = Key.Q;
break;
case "AD02":
key = Key.W;
break;
case "AD03":
key = Key.E;
break;
case "AD04":
key = Key.R;
break;
case "AD05":
key = Key.T;
break;
case "AD06":
key = Key.Y;
break;
case "AD07":
key = Key.U;
break;
case "AD08":
key = Key.I;
break;
case "AD09":
key = Key.O;
break;
case "AD10":
key = Key.P;
break;
case "AD11":
key = Key.BracketLeft;
break;
case "AD12":
key = Key.BracketRight;
break;
case "AC01":
key = Key.A;
break;
case "AC02":
key = Key.S;
break;
case "AC03":
key = Key.D;
break;
case "AC04":
key = Key.F;
break;
case "AC05":
key = Key.G;
break;
case "AC06":
key = Key.H;
break;
case "AC07":
key = Key.J;
break;
case "AC08":
key = Key.K;
break;
case "AC09":
key = Key.L;
break;
case "AC10":
key = Key.Semicolon;
break;
case "AC11":
key = Key.Quote;
break;
case "AB01":
key = Key.Z;
break;
case "AB02":
key = Key.X;
break;
case "AB03":
key = Key.C;
break;
case "AB04":
key = Key.V;
break;
case "AB05":
key = Key.B;
break;
case "AB06":
key = Key.N;
break;
case "AB07":
key = Key.M;
break;
case "AB08":
key = Key.Comma;
break;
case "AB09":
key = Key.Period;
break;
case "AB10":
key = Key.Slash;
break;
case "BKSL":
key = Key.BackSlash;
break;
case "LSGT":
key = Key.Unknown;
break;
default:
key = Key.Unknown;
break;
}
keycodes[i] = key;
}
Xkb.FreeKeyboard(keyboard, 0, true);
}
}
}
// Translate unknown keys (and symbols) using
// regular layout-dependent GetKey()
for (int i = 0; i < 256; i++)
{
if (keycodes[i] == Key.Unknown)
{
// TranslateKeyCode expects a XKeyEvent structure
// Make one up
XKeyEvent e = new XKeyEvent();
e.display = display;
e.keycode = i;
Key key = Key.Unknown;
if (TranslateKeyEvent(ref e, out key))
{
keycodes[i] = key;
}
}
}
}
internal bool TranslateKey(ref XKeyEvent e, out Key key)
{
return(TranslateKey(e.keycode, out key));
}
public static extern KeySym XLookupKeysym(ref XKeyEvent key_event, int index);
/// <summary> Initializing constructor. </summary>
/// <param name="evt"> The event to wrap. <see cref="XKeyEvent"/> </param>
public XrwKeyEvent(ref XKeyEvent evt)
{
Event = evt;
}
