public OpenGLRenderer()
{
var windowCloseDelegate = new Action(() =>
{
NativeDumpDebugInfo();
//Environment.Exit(0);
});
var mouseDelegate = new MouseMoveEventHandler(ProcessMouseMoveEvent);
var keyboardEvent = new KeyboardEventHandler(ProcessKeyPressedEvent);
var mouseDownEvent = new MouseButtonEventHandler(ProcessMouseDownEvent);
var mouseUpEvent = new MouseButtonEventHandler(ProcessMouseUpEvent);
_unmanaged_references.Add(GCHandle.Alloc(windowCloseDelegate));
_unmanaged_references.Add(GCHandle.Alloc(mouseDelegate));
_unmanaged_references.Add(GCHandle.Alloc(mouseDownEvent));
_unmanaged_references.Add(GCHandle.Alloc(mouseUpEvent));
_unmanaged_references.Add(GCHandle.Alloc(keyboardEvent));
NativeRegisterWindowCloseCallback(windowCloseDelegate);
NativeRegisterKeyboardCallback(keyboardEvent);
NativeRegisterMouseDownCallback(mouseDownEvent);
NativeRegisterMouseMoveCallback(mouseDelegate);
NativeRegisterMouseUpCallback(mouseUpEvent);
}
private void RemoveHandlerInternal(uint key, KeyboardEventHandler handler)
{
if (_messageHandlers.ContainsKey(key))
{
_messageHandlers[key] -= handler;
}
}
public static void Subscribe(KeyModifiers modifiers, Keys key, KeyboardEventHandler handler)
{
if ((modifiers & KeyModifiers.Control) == KeyModifiers.LControl ||
(modifiers & KeyModifiers.Control) == KeyModifiers.RControl ||
(modifiers & KeyModifiers.Alt) == KeyModifiers.LAlt ||
(modifiers & KeyModifiers.Alt) == KeyModifiers.RAlt ||
(modifiers & KeyModifiers.Shift) == KeyModifiers.LShift ||
(modifiers & KeyModifiers.Shift) == KeyModifiers.RShift ||
(modifiers & KeyModifiers.Win) == KeyModifiers.LWin ||
(modifiers & KeyModifiers.Win) == KeyModifiers.RWin)
{
if (hook == IntPtr.Zero)
{
subscriptions = new Dictionary <Subscription, KeyboardEventHandler>(
new Subscription.SubscriptionEqualityComparer());
hook = NativeMethods.SetWindowsHookEx(NativeMethods.WH_KEYBOARD_LL,
keyboardHookProcedure,
System.Diagnostics.Process.GetCurrentProcess().MainModule.BaseAddress, 0);
}
var newSubscription = new Subscription(modifiers, key);
KeyboardEventHandler handlers;
if (subscriptions.TryGetValue(newSubscription, out handlers))
{
subscriptions[newSubscription] = handlers + handler;
}
else
{
subscriptions[newSubscription] = handler;
}
}
else
{
NativeMethods.MOD mods = 0;
if (modifiers.HasFlag(KeyModifiers.Control))
{
mods |= NativeMethods.MOD.MOD_CONTROL;
}
if (modifiers.HasFlag(KeyModifiers.Alt))
{
mods |= NativeMethods.MOD.MOD_ALT;
}
if (modifiers.HasFlag(KeyModifiers.Shift))
{
mods |= NativeMethods.MOD.MOD_SHIFT;
}
if (modifiers.HasFlag(KeyModifiers.Win))
{
mods |= NativeMethods.MOD.MOD_WIN;
}
NativeMethods.RegisterHotKey(Windawesome.HandleStatic, registeredHotkeys.Count, mods, key);
registeredHotkeys.Add(handler);
}
hasKeyOnlySubscriptions |= modifiers == KeyModifiers.None;
}
private void AddHandlerInternal(uint key, KeyboardEventHandler handler)
{
if (!_messageHandlers.ContainsKey(key))
{
_messageHandlers.Add(key, null);
}
_messageHandlers[key] += handler;
}
private void HandleKeyboardMessage(KeyboardMessageEventArgs message, KeyboardEventHandler handler)
{
if (this._disabled)
{
return;
}
handler?.Invoke(this, message);
}
// 主线程循环
internal static void MainThreadUpdate()
{
FocusEventHandler.MainThreadUpdate();
ScreenResizeEventHandler.MainThreadUpdate();
CollisionEventHandler.MainThreadUpdate();
TriggerEventHandler.MainThreadUpdate();
PointerEventHandlerForScreen.MainThreadUpdate();
PointerEventHandlerForUI.MainThreadUpdate();
PointerEventHandlerForMesh.MainThreadUpdate();
KeyboardEventHandler.MainThreadUpdate();
FrameLoopEventHandler.MainThreadUpdate();
IntervalEventHandler.MainThreadUpdate();
CustomEventHandler.MainThreadUpdate();
TraceEventHandler.MainThreadUpdate();
}
/// <summary>
/// Installs the specified hook.
/// </summary>
/// <param name="hook">The hook.</param>
/// <param name="handler">The handler.</param>
/// <param name="hold">if set to <c>true</c> [hold].</param>
public void Install(KeyboardHook hook, KeyboardEventHandler handler, bool hold = false)
{
if (!this.IsDefined() || handler == null)
{
return;
}
hook.AddHandler(this.KeyCode, KeyDirection.Up, this.Modifier, handler);
if (hold)
{
hook.AddHandler(this.KeyCode, KeyDirection.Down, this.Modifier, handler);
}
this._hook = hook;
this._handler = handler;
this._registeredKeycode = this.KeyCode;
this._registeredModifier = this.Modifier;
this._isHoldHotkey = true;
}
/// <summary>
/// Uninstalls the specified hook.
/// </summary>
public void Uninstall()
{
if (!this.IsHooked() || this._handler == null || this._hook == null)
{
return;
}
this._hook.RemoveHandler(this._registeredKeycode, this._registeredModifier, KeyDirection.Up, this._handler);
if (this._isHoldHotkey)
{
this._hook.RemoveHandler(this._registeredKeycode, this._registeredModifier, KeyDirection.Down, this._handler);
}
this._hook = null;
this._handler = null;
this._isHoldHotkey = false;
this._registeredKeycode = KeyCode.None;
this._registeredModifier = Modifiers.None;
}
public void RemoveHandler(KeyCode keyCode, KeyboardEventHandler handler) => RemoveHandler((ushort)keyCode, Modifiers.None, KeyDirection.Any, handler);
public void AddHandler(ushort keyValue, Modifiers modifiers, KeyboardEventHandler handler) => AddHandler(keyValue, modifiers, KeyDirection.Up, handler);
public void AddHandler(KeyCode keyCode, Modifiers modifiers, KeyboardEventHandler handler) => AddHandler((ushort)keyCode, modifiers, KeyDirection.Up, handler);
/// <summary> 移除键盘按键事件侦听 </summary> /// <param name="keyCode">侦听的按键键值</param> /// <param name="listener">键盘按键事件侦听函数 ( Params - 侦听按键键值，按键事件类型 ) </param> public void RemoveKeyboardListener(KeyCode keyCode, Action <KeyCode, KeyboardEventType> listener) => KeyboardEventHandler.RemoveListener(keyCode, listener);
public void handleKeypress()
{
KeyboardEventHandler handler = KeyboardEvent;
// UP BUTTON
if (Input.GetKeyDown(KeyCode.UpArrow))
{
activeKeys["UP"] = true;
handler("up", "keyDown");
}
else
{
if (Input.GetKeyUp(KeyCode.UpArrow))
{
activeKeys["UP"] = false;
handler("up", "keyUp");
}
}
// RIGHT BUTTON
if (Input.GetKeyDown(KeyCode.RightArrow))
{
activeKeys["RIGHT"] = true;
handler("right", "keyDown");
}
else
{
if (Input.GetKeyUp(KeyCode.RightArrow))
{
activeKeys["RIGHT"] = false;
handler("right", "keyUp");
}
}
// DOWN BUTTON
if (Input.GetKeyDown(KeyCode.DownArrow))
{
activeKeys["DOWN"] = true;
handler("down", "keyDown");
}
else
{
if (Input.GetKeyUp(KeyCode.DownArrow))
{
activeKeys["DOWN"] = false;
handler("down", "keyUp");
}
}
// LEFT BUTTON
if (Input.GetKeyDown(KeyCode.LeftArrow))
{
// do something with the left direction
activeKeys["LEFT"] = true;
handler("left", "keyDown");
}
else
{
if (Input.GetKeyUp(KeyCode.LeftArrow))
{
activeKeys["LEFT"] = false;
handler("left", "keyUp");
}
}
// SPACE BUTTON
if (Input.GetKeyDown(KeyCode.Space))
{
activeKeys["SPACE"] = true;
handler("space", "keyDown");
}
else
{
if (Input.GetKeyDown(KeyCode.Space))
{
activeKeys["SPACE"] = false;
handler("space", "keyUp");
}
}
}
private void BindEvents()
{
Image fsImg = FindName("fullScreen") as Image;
fsImg.MouseLeftButtonUp += new MouseEventHandler(OnFullScreenClicked);
BrowserHost.FullScreenChange += new EventHandler(BrowserHost_FullScreenChange);
BrowserHost.Resize += BrowserHost_FullScreenChange;
Image zoomInImg = FindName("zoomin") as Image;
zoomInImg.MouseLeftButtonUp += new MouseEventHandler(zoomInImg_MouseLeftButtonUp);
Image zoomOutImg = FindName("zoomout") as Image;
zoomOutImg.MouseLeftButtonUp += new MouseEventHandler(zoomOutImg_MouseLeftButtonUp);
Image firstImg = FindName("first") as Image;
firstImg.MouseLeftButtonUp += new MouseEventHandler(firstImg_MouseLeftButtonUp);
Image prevImg = FindName("prev") as Image;
prevImg.MouseLeftButtonUp += new MouseEventHandler(prevImg_MouseLeftButtonUp);
Image nextImg = FindName("next") as Image;
nextImg.MouseLeftButtonUp += new MouseEventHandler(nextImg_MouseLeftButtonUp);
Image lastImg = FindName("last") as Image;
lastImg.MouseLeftButtonUp += new MouseEventHandler(lastImg_MouseLeftButtonUp);
KeyUp += new KeyboardEventHandler(Page_KeyUp);
}
/// <summary> 添加键盘按键事件侦听 </summary> /// <param name="keyCode">侦听的按键键值</param> /// <param name="listener">键盘按键事件侦听函数 ( Params - 侦听按键键值，按键事件类型 ) </param> /// <param name="priority">设置侦听函数执行优先级，数值越高优先级越高。同数值情况下，先添加的侦听函数优先级更高，默认为 0 </param> public void AddKeyboardListener(KeyCode keyCode, Action <KeyCode, KeyboardEventType> listener, int priority = 0) => KeyboardEventHandler.AddListener(keyCode, listener, priority);
public void RemoveHandler(ushort keyValue, Modifiers modifiers, KeyboardEventHandler handler) => RemoveHandler(keyValue, modifiers, KeyDirection.Any, handler);
public void RemoveHandler(ushort keyValue, Modifiers modifiers, KeyDirection direction, KeyboardEventHandler handler)
{
foreach (var key in GetHandlerKeys(keyValue, modifiers, direction))
{
RemoveHandlerInternal(key, handler ?? throw new ArgumentNullException(nameof(handler)));
}
}
private static extern void NativeRegisterKeyboardCallback(KeyboardEventHandler pHandler);
public void RegisterKey(Keys key, KeyboardEventHandler eventHandler)
{
int keyIdx = -1;
for (int idx = 0; idx < m_registeredKeys.Count; ++idx)
{
if (m_registeredKeys[idx].Key == key)
{
keyIdx = idx;
break;
}
}
if (keyIdx != -1)
{
m_registeredKeys[keyIdx].AddHandler(eventHandler);
}
else
{
RegisteredKey rk = new RegisteredKey(key);
rk.AddHandler(eventHandler);
m_registeredKeys.Add(rk);
}
}
public void RemoveHandler(KeyboardEventHandler handler)
{
OnKeyboardEvent -= handler;
}
public void AddHandler(KeyboardEventHandler handler)
{
OnKeyboardEvent += handler;
}
public void UnregisterKey(Keys key, KeyboardEventHandler eventHandler)
{
for (int idx = 0; idx < m_registeredKeys.Count; ++idx)
{
if (m_registeredKeys[idx].Key == key)
{
m_registeredKeys[idx].RemoveHandler(eventHandler);
if (m_registeredKeys[idx].Empty)
{
m_registeredKeys.RemoveAt(idx);
}
break;
}
}
}
public void RemoveHandler(KeyCode keyCode, Modifiers modifiers, KeyDirection direction, KeyboardEventHandler handler) => RemoveHandler((ushort)keyCode, modifiers, direction, handler);
public void RemoveHandler(ushort keyValue, KeyboardEventHandler handler) => RemoveHandler(keyValue, Modifiers.None, KeyDirection.Up, handler);
public Keyboard(KeyboardEventHandler onkeydown)
{
this.onKeyDown = onkeydown;
}
/// <summary>
/// The mechanism used to call the type-specific handler on the
/// target.
/// </summary>
/// <param name="genericHandler">
/// The generic handler to call in a type-specific way.
/// </param>
/// <param name="genericTarget">
/// The target to call the handler on.
/// </param>
/// <ExternalAPI/>
protected override void InvokeEventHandler(Delegate genericHandler, object genericTarget)
{
KeyboardEventHandler handler = (KeyboardEventHandler)genericHandler;
handler(genericTarget, this);
}
public static extern IntPtr SetWindowsHookEx(int id, KeyboardEventHandler eventHandler, IntPtr moduleName, IntPtr threadId);
public KeyboardMouseHook(KeyboardEventHandler eventKeyDown)
{
//Create an event using a delegate to fire whenever data is received by the hook
myEventKeyOrMouse = eventKeyDown;
_Keyboardproc = KeyboardHookCallback;
_KeyboardhookID = SetKeyboardHook(_Keyboardproc);
_Mouseproc = MouseHookCallback;
_MousehookID = SetMouseHook(_Mouseproc);
Modifiers = KeyModifiers.None;
}
