protected override bool OnKeyPress(KeyPressEvent e)
{
if (Focused && IsEnabledInHierarchy() && browserHost != null)
{
browserHost.SendFocusEvent(true);
try
{
//_logger.Debug(string.Format("KeyDown: system key {0}, key {1}", arg.SystemKey, arg.Key));
CefKeyEvent keyEvent = new CefKeyEvent()
{
EventType = CefKeyEventType.Char,
WindowsKeyCode = (int)e.KeyChar
};
keyEvent.Modifiers = GetCurrentKeyboardModifiers();
browserHost.SendKeyEvent(keyEvent);
}
catch (Exception ex)
{
Log.Error("WebBrowserControl: Caught exception in OnKeyDown(): " + ex.Message);
}
//arg.Handled = true;
return(true);
}
return(base.OnKeyPress(e));
}
private void OnKeyEvent(ref Message m)
{
var keyEvent = new CefKeyEvent();
keyEvent.WindowsKeyCode = m.WParam.ToInt32();
keyEvent.NativeKeyCode = (int)m.LParam.ToInt64();
keyEvent.IsSystemKey = m.Msg == NativeMethods.WM_SYSCHAR ||
m.Msg == NativeMethods.WM_SYSKEYDOWN ||
m.Msg == NativeMethods.WM_SYSKEYUP;
if (m.Msg == NativeMethods.WM_KEYDOWN || m.Msg == NativeMethods.WM_SYSKEYDOWN)
{
keyEvent.EventType = CefKeyEventType.RawKeyDown;
}
else if (m.Msg == NativeMethods.WM_KEYUP || m.Msg == NativeMethods.WM_SYSKEYUP)
{
keyEvent.EventType = CefKeyEventType.KeyUp;
}
else
{
keyEvent.EventType = CefKeyEventType.Char;
}
keyEvent.Modifiers = GetKeyboardModifiers(ref m);
if (this.Renderer != null)
{
this.Renderer.SendKeyEvent(keyEvent);
}
}
public void HandleEvents()
{
var menuController = _inputProcessor[0];
foreach (var button in _buttons)
{
var currentState = menuController.GetButtonState(button);
if (currentState == GameControllerButtonState.None)
{
continue;
}
var eventType = currentState == GameControllerButtonState.Down
? CefKeyEventType.KeyDown
: CefKeyEventType.KeyUp;
var cefKeyEvent = new CefKeyEvent
{
EventType = eventType,
WindowsKeyCode = (short)InputProcessor.GetVirtualKey(button)
};
_browser.GetHost().SendKeyEvent(cefKeyEvent);
}
}
private void OnGUI()
{
Event e = Event.current;
if (e.isKey)
{
var ev = new CefKeyEvent();
//ev.Character = e.character;
ev.WindowsKeyCode = (int)e.keyCode;
ev.NativeKeyCode = (int)e.keyCode;
ev.Modifiers =
(e.modifiers.HasFlag(EventModifiers.CapsLock) ? CefEventFlags.CapsLockOn : 0) |
(e.modifiers.HasFlag(EventModifiers.Control) ? CefEventFlags.ControlDown : 0) |
(e.modifiers.HasFlag(EventModifiers.Command) ? CefEventFlags.CommandDown : 0) |
(e.modifiers.HasFlag(EventModifiers.Alt) ? CefEventFlags.AltDown : 0) |
(e.modifiers.HasFlag(EventModifiers.Shift) ? CefEventFlags.ShiftDown : 0);
if (e.type == EventType.KeyDown)
{
ev.EventType = CefKeyEventType.KeyDown;
cefClient.SendKey(ev);
}
else if (e.type == EventType.KeyUp)
{
ev.EventType = CefKeyEventType.Char;
cefClient.SendKey(ev);
ev.EventType = CefKeyEventType.KeyUp;
cefClient.SendKey(ev);
}
}
}
void ICefWebBrowserInternal.OnPreviewKeyEvent(CefKeyEvent keyEvent)
{
this.DispatchIfRequired(() =>
{
if (keyEvent.EventType == CefKeyEventType.RawKeyDown)
{
var keys = (Keys)keyEvent.WindowsKeyCode;
if ((keyEvent.Modifiers & CefEventFlags.ControlDown) == CefEventFlags.ControlDown)
{
keys |= Keys.Control;
}
if ((keyEvent.Modifiers & CefEventFlags.ShiftDown) == CefEventFlags.ShiftDown)
{
keys |= Keys.Shift;
}
if ((keyEvent.Modifiers & CefEventFlags.AltDown) == CefEventFlags.AltDown)
{
keys |= Keys.Alt;
}
var source = PresentationSource.FromDependencyObject(this);
var key = KeyInterop.KeyFromVirtualKey((int)keys);
var args = new System.Windows.Input.KeyEventArgs(Keyboard.PrimaryDevice, source, 0, key)
{
RoutedEvent = PreviewKeyDownEvent
};
RaiseEvent(args);
}
}, true);
}
private IInputEventListener NewKeyListener(IInputSource inputSource)
{
return(new AnonymousEventListener <KeyEvent>(e =>
{
if (e.Device.Source != inputSource)
{
return;
}
var key = ToWinFormsKeys(e.Key);
var cefEvent = new CefKeyEvent()
{
WindowsKeyCode = (int)key,
NativeKeyCode = (int)key
};
if (e.IsDown)
{
cefEvent.EventType = CefKeyEventType.KeyDown;
}
else
{
cefEvent.EventType = CefKeyEventType.KeyUp;
}
webRenderer.BrowserHost.SendKeyEvent(cefEvent);
}));
}
protected override bool OnKeyUp(KeyEvent e)
{
if (IsEnabledInHierarchy() && browserHost != null)
{
browserHost.SendFocusEvent(true);
try
{
//_logger.Debug(string.Format("KeyDown: system key {0}, key {1}", arg.SystemKey, arg.Key));
CefKeyEvent keyEvent = new CefKeyEvent()
{
EventType = CefKeyEventType.KeyUp,
WindowsKeyCode = (int)e.Key /*KeyInterop.VirtualKeyFromKey(arg.Key == Key.System ? arg.SystemKey : arg.Key)*/,
NativeKeyCode = (int)e.Key, /*0*/
/*IsSystemKey = e.Key == EKeys.System*/
};
keyEvent.Modifiers = GetCurrentKeyboardModifiers();
browserHost.SendKeyEvent(keyEvent);
}
catch (Exception ex)
{
Log.Error("WebBrowserControl: Caught exception in OnKeyDown(): " + ex.Message);
}
//arg.Handled = true;
}
return(base.OnKeyUp(e));
}
public void SendKey(CefKeyEvent e)
{
if (this.sHost == null)
{
return;
}
this.sHost.SendKeyEvent(e);
}
protected override bool OnKeyEvent(CefBrowser browser, CefKeyEvent keyEvent, IntPtr osEvent)
{
//var host = browser.GetHost();
//host.SendKeyEvent(keyEvent);
//System.Diagnostics.Debug.WriteLine(keyEvent.Character);
//Console.WriteLine(keyEvent.Character);
return(base.OnKeyEvent(browser, keyEvent, osEvent));
}
protected override bool OnKeyEvent(CefBrowser browser, CefKeyEvent keyEvent, IntPtr osEvent)
{
var e = new KeyEventArgs(keyEvent, osEvent);
_owner.OnKeyEvent(e);
return(e.Handled);
}
public void SendKeyEvent(CefKeyEvent keyEvent)
{
if (this.Browser != null)
{
var host = this.Browser.GetHost();
host.SendKeyEvent(keyEvent);
}
}
protected override bool OnKeyEvent(CefBrowser browser, CefKeyEvent keyEvent, IntPtr osEvent)
{
//对按键的处理
switch (keyEvent.WindowsKeyCode)
{
case 27:
MainForm.Instance.Invoke(new Action(() =>
{
MainForm.Instance.searchOpen = false;
MainForm.Instance.CloseSearch();
MainForm.Instance.PanelSearch.Visible = false;
}
));
break;
case 68:
if (keyEvent.IsSystemKey)
{
MainForm.Instance.Invoke(new Action(() =>
{
MainForm.Instance.textBoxXP1.Focus();
MainForm.Instance.textBoxXP1.SelectAll();
}
));
}
break;
case 123: //功能键 F12 的KeyCode
if (keyEvent.EventType.Equals(CefKeyEventType.RawKeyDown))
{
PublicClass.DevTools(_core, browser);
}
break;
case 116: //F5刷新功能
if (keyEvent.EventType.Equals(CefKeyEventType.RawKeyDown))
{
PublicClass.ReflashBrowser(browser, _core);
}
break;
case 122: //F11全屏和非全屏功能
if (keyEvent.EventType.Equals(CefKeyEventType.KeyUp))
{
//bool fullForm = false;
//if (MainForm.Instance.WindowState == System.Windows.Forms.FormWindowState.Maximized
// && MainForm.Instance.ToolsPanel.Visible)
// fullForm = true;
PublicClass.ScreenFuction(""); //,fullForm);
}
break;
}
GC.Collect();
return(base.OnKeyEvent(browser, keyEvent, osEvent));
}
internal void Inject(Key keyToInject)
{
var keyEvent = new CefKeyEvent()
{
EventType = CefKeyEventType.Char,
WindowsKeyCode = KeyInterop.VirtualKeyFromKey(keyToInject)
};
_browserHost.SendKeyEvent(keyEvent);
}
protected override bool OnPreKeyEvent(CefBrowser browser, CefKeyEvent keyEvent, IntPtr os_event, out bool isKeyboardShortcut)
{
var e = new PreKeyEventArgs(keyEvent, os_event);
_owner.OnPreKeyEvent(e);
isKeyboardShortcut = e.IsKeyboardShortcut;
return(e.Handled);
}
/// <summary>
/// 同时处理keydown和up事件
/// </summary>
/// <param name="keyboardEvent"></param>
private static void HandleKeyboardEvent(SDL_KeyboardEvent keyboardEvent)
{
//SimpleInputSnapshot snapshot = _privateSnapshot;
CefKeyEvent keyEvent = new CefKeyEvent();
keyEvent.Modifiers = GetModifiersFromSDL(keyboardEvent.keysym.mod);
keyEvent.WindowsKeyCode = (int)(GetWindowsKeycodeFromSDLKeycode(keyboardEvent.keysym.scancode));
keyEvent.NativeKeyCode = (int)keyboardEvent.keysym.scancode;
keyEvent.EventType = keyboardEvent.state == 0 ? CefKeyEventType.RawKeyDown:CefKeyEventType.KeyUp;
_host.SendKeyEvent(keyEvent);
}
protected override bool OnPreKeyEvent(CefBrowser browser, CefKeyEvent keyEvent, IntPtr os_event, out bool isKeyboardShortcut)
{
var handler = OwnerWebView.KeyPressed;
if (handler != null && !browser.IsPopup)
{
handler(keyEvent, out var handled);
isKeyboardShortcut = false;
return(handled);
}
return(base.OnPreKeyEvent(browser, keyEvent, os_event, out isKeyboardShortcut));
}
/// <summary>
/// Called before a keyboard event is sent to the renderer. |event| contains
/// information about the keyboard event. |os_event| is the operating system
/// event message, if any. Return true if the event was handled or false
/// otherwise. If the event will be handled in OnKeyEvent() as a keyboard
/// shortcut set |is_keyboard_shortcut| to true and return false.
/// </summary>
/// <param name="browser"></param>
/// <param name="keyEvent"></param>
/// <param name="os_event"></param>
/// <param name="isKeyboardShortcut"></param>
/// <returns></returns>
protected override bool OnPreKeyEvent(CefBrowser browser, CefKeyEvent keyEvent, IntPtr os_event, out bool isKeyboardShortcut)
{
if (keyEvent == null)
{
throw new ArgumentNullException("keyEvent");
}
isKeyboardShortcut = false;
Application.Current.Window.TriggerKeyPress(keyEvent.WindowsKeyCode, keyEvent.Modifiers, keyEvent.EventType);
return(false);
}
protected override bool OnPreKeyEvent(CefBrowser browser, CefKeyEvent keyEvent, IntPtr os_event, out bool isKeyboardShortcut)
{
if (keyEvent.EventType == CefKeyEventType.RawKeyDown)
{
webBrowser.OnPreviewKeyDown(keyEvent.Modifiers == CefEventFlags.AltDown,
keyEvent.Modifiers == CefEventFlags.ControlDown,
keyEvent.Modifiers == CefEventFlags.ShiftDown,
keyEvent.FocusOnEditableField,
keyEvent.WindowsKeyCode,
keyEvent.Character);
}
return(base.OnPreKeyEvent(browser, keyEvent, os_event, out isKeyboardShortcut));
}
private void OnKeyEvent(ref Message m)
{
CefKeyEvent keyEvent = new CefKeyEvent();
keyEvent.WindowsKeyCode = m.WParam.ToInt32();
keyEvent.NativeKeyCode = (int)m.LParam.ToInt64();
keyEvent.IsSystemKey = m.Msg == 262 || m.Msg == 260 || m.Msg == 261;
keyEvent.EventType = m.Msg == 256 || m.Msg == 260 ? CefKeyEventType.RawKeyDown : (m.Msg == 257 || m.Msg == 261 ? CefKeyEventType.KeyUp : CefKeyEventType.Char);
keyEvent.Modifiers = this.GetKeyboardModifiers(ref m);
if (this.Renderer == null)
{
return;
}
this.Renderer.SendKeyEvent(keyEvent);
}
/// <summary>
/// Sends the KeyPress event to the browser.
/// </summary>
/// <param name="c">The character associated with the key.</param>
/// <param name="ctrlKey">The Control key flag.</param>
/// <param name="altKey">The Alt key flag.</param>
/// <param name="shiftKey">The Shift key flag.</param>
/// <param name="metaKey">The Meta key flag.</param>
/// <param name="extendedKey">The extended key flag.</param>
public void SendKeyPress(char c, bool ctrlKey = false, bool altKey = false, bool shiftKey = false, bool metaKey = false, bool extendedKey = false)
{
CefBrowserHost browserHost = this.BrowserObject?.Host;
if (browserHost is null)
{
return;
}
CefEventFlags modifiers = CefEventFlags.None;
if (KeycodeConverter.IsShiftRequired(c))
{
shiftKey = !shiftKey;
}
if (shiftKey)
{
modifiers |= CefEventFlags.ShiftDown;
}
if (altKey)
{
modifiers |= CefEventFlags.AltDown;
}
if (ctrlKey)
{
modifiers |= CefEventFlags.ControlDown;
}
if (metaKey)
{
modifiers |= CefEventFlags.CommandDown;
}
VirtualKeys key = KeycodeConverter.CharacterToVirtualKey(c);
var k = new CefKeyEvent();
k.Type = CefKeyEventType.Char;
k.Modifiers = (uint)modifiers;
k.IsSystemKey = altKey;
k.WindowsKeyCode = PlatformInfo.IsLinux ? (int)key : c;
k.NativeKeyCode = KeycodeConverter.VirtualKeyToNativeKeyCode(key, modifiers, extendedKey);
k.Character = c;
k.UnmodifiedCharacter = c;
this.BrowserObject?.Host?.SendKeyEvent(k);
}
private void SendKeyChange(CefKeyEventType eventType, char c, bool ctrlKey, bool altKey, bool shiftKey, bool metaKey, int repeatCount, bool extendedKey)
{
CefBrowserHost browserHost = this.BrowserObject?.Host;
if (browserHost is null)
{
return;
}
CefEventFlags modifiers = CefEventFlags.None;
if (KeycodeConverter.IsShiftRequired(c))
{
shiftKey = !shiftKey;
}
VirtualKeys key = KeycodeConverter.CharacterToVirtualKey(c);
if (shiftKey)
{
modifiers |= CefEventFlags.ShiftDown;
}
if (altKey)
{
modifiers |= CefEventFlags.AltDown;
}
if (ctrlKey)
{
modifiers |= CefEventFlags.ControlDown;
}
if (metaKey)
{
modifiers |= CefEventFlags.CommandDown;
}
var k = new CefKeyEvent();
k.Type = eventType;
k.Modifiers = (uint)modifiers;
k.IsSystemKey = altKey;
k.WindowsKeyCode = (int)key;
k.NativeKeyCode = KeycodeConverter.VirtualKeyToNativeKeyCode(key, modifiers, extendedKey);
k.Character = c;
k.UnmodifiedCharacter = c;
this.BrowserObject?.Host?.SendKeyEvent(k);
}
protected override bool OnKeyEvent(CefBrowser browser, CefKeyEvent keyEvent, IntPtr osEvent)
{
if (keyEvent.WindowsKeyCode == Convert.ToInt32(Keys.F5))
{
browser.Reload();
}
if (keyEvent.WindowsKeyCode == Convert.ToInt32(Keys.F12))
{
CefWindowInfo windowInfo = CefWindowInfo.Create();
windowInfo.SetAsPopup(IntPtr.Zero, "DevTools");
browser.GetHost().ShowDevTools(windowInfo, new CefWebDevToolsClient(), new CefBrowserSettings(), new CefPoint(0, 0));
}
return(base.OnKeyEvent(browser, keyEvent, osEvent));
}
private void SendKeyChange(CefKeyEventType eventType, VirtualKeys key, bool ctrlKey, bool altKey, bool shiftKey, bool metaKey, int repeatCount, bool extendedKey)
{
if (key < VirtualKeys.None || key > VirtualKeys.OemClear)
{
throw new ArgumentOutOfRangeException(nameof(key));
}
CefBrowserHost browserHost = this.BrowserObject?.Host;
if (browserHost is null)
{
return;
}
CefEventFlags modifiers = CefEventFlags.None;
if (shiftKey)
{
modifiers |= CefEventFlags.ShiftDown;
}
if (altKey)
{
modifiers |= CefEventFlags.AltDown;
}
if (ctrlKey)
{
modifiers |= CefEventFlags.ControlDown;
}
if (metaKey)
{
modifiers |= CefEventFlags.CommandDown;
}
var k = new CefKeyEvent();
k.Type = eventType;
k.Modifiers = (uint)modifiers;
k.IsSystemKey = altKey;
k.WindowsKeyCode = (int)key;
k.NativeKeyCode = KeycodeConverter.VirtualKeyToNativeKeyCode(key, modifiers, extendedKey);
k.Character = (char)key;
k.UnmodifiedCharacter = (char)key;
this.BrowserObject?.Host?.SendKeyEvent(k);
}
protected override bool OnKeyEvent(CefBrowser browser, CefKeyEvent keyEvent, IntPtr osEvent)
{
switch (keyEvent.WindowsKeyCode)
{
case (int)Keys.F12:
{
var host = browser.GetHost();
var wi = CefWindowInfo.Create();
wi.SetAsPopup(IntPtr.Zero, "医汇通 - 开发调试工具");
host.ShowDevTools(wi, new DevToolsWebClient(), new CefBrowserSettings());
//var devToolsUrl = webBrowser.Browser.GetHost().GetDevToolsUrl(true);
//var isShow = false;
//foreach (Form field in Application.OpenForms)
//{
// if (field.Text.EndsWith("开发调试工具"))
// {
// ((DevTools)field).LoadUrl(devToolsUrl);
// field.Activate();
// isShow = true;
// }
//}
//if (!isShow)
//{
// var devtool = new DevTools(devToolsUrl);
// devtool.Size = new Size(this.Size.Width, devtool.Size.Height);
// var point = this.PointToScreen(new Point(0, 0));
// devtool.Location = new Point(point.X, point.Y + this.Size.Height - devtool.Size.Height);
// devtool.Show();
//}
break;
}
case (int)Keys.F5:
{
browser.ReloadIgnoreCache();
break;
}
default:
break;
}
return(base.OnKeyEvent(browser, keyEvent, osEvent));
}
public void KeyboardEvent(int character, KeyboardEventType type)
{
CefKeyEvent keyEvent = new CefKeyEvent()
{
EventType = CefKeyEventType.Char,
WindowsKeyCode = character
};
if (type == KeyboardEventType.Down)
{
keyEvent.EventType = CefKeyEventType.KeyDown;
}
if (type == KeyboardEventType.Up)
{
keyEvent.EventType = CefKeyEventType.KeyUp;
}
_lifespanHandler.MainBrowser.GetHost().SendKeyEvent(keyEvent);
}
protected override bool OnPreKeyEvent(CefBrowser browser, CefKeyEvent keyEvent, IntPtr os_event, out bool isKeyboardShortcut)
{
if (keyEvent.WindowsKeyCode == 17)
{
MainForm.Instance.Invoke(new Action(() =>
{
MainForm.Instance.cefCtrlDown = true; //Ctrl按下
MainForm.Instance.textBox2.ForeColor = Color.Black;
}
));
}
if (keyEvent.EventType == CefKeyEventType.KeyUp)
{
MainForm.Instance.Invoke(new Action(() =>
{
MainForm.Instance.cefCtrlDown = false; //Ctrl按下
}
));
}
return(base.OnPreKeyEvent(browser, keyEvent, os_event, out isKeyboardShortcut));
}
private void HandleKeyNotification(KeyNotification n, CallerInfo caller)
{
var keyEvent = new CefKeyEvent()
{
//Modifiers = (CefEventFlags)((int)(FKeyboard.Modifiers) >> 15)
};
switch (n.Kind)
{
case KeyNotificationKind.KeyDown:
var keyDown = n as KeyDownNotification;
keyEvent.EventType = CefKeyEventType.KeyDown;
keyEvent.WindowsKeyCode = (int)keyDown.KeyCode;
keyEvent.NativeKeyCode = (int)keyDown.KeyCode;
break;
case KeyNotificationKind.KeyPress:
var keyPress = n as KeyPressNotification;
keyEvent.EventType = CefKeyEventType.Char;
keyEvent.Character = keyPress.KeyChar;
keyEvent.UnmodifiedCharacter = keyPress.KeyChar;
keyEvent.WindowsKeyCode = (int)keyPress.KeyChar;
keyEvent.NativeKeyCode = (int)keyPress.KeyChar;
break;
case KeyNotificationKind.KeyUp:
var keyUp = n as KeyUpNotification;
keyEvent.EventType = CefKeyEventType.KeyUp;
keyEvent.WindowsKeyCode = (int)keyUp.KeyCode;
keyEvent.NativeKeyCode = (int)keyUp.KeyCode;
break;
default:
break;
}
webRenderer.BrowserHost.SendKeyEvent(keyEvent);
}
internal static void SendKeyEvent(this WebView webview, CefKeyEvent keyEvent)
{
webview.GetCefBrowser()?.GetHost()?.SendKeyEvent(keyEvent);
}
private void AttachEventHandlers(WpfCefBrowser browser)
{
browser.GotKeyboardFocus += (sender, arg) =>
{
try
{
if (_browserHost != null)
{
_browserHost.SendFocusEvent(true);
}
}
catch (Exception ex)
{
_logger.ErrorException("WpfCefBrowser: Caught exception in GotFocus()", ex);
}
};
browser.LostKeyboardFocus += (sender, arg) =>
{
try
{
if (_browserHost != null)
{
_browserHost.SendFocusEvent(false);
}
}
catch (Exception ex)
{
_logger.ErrorException("WpfCefBrowser: Caught exception in LostFocus()", ex);
}
};
browser.MouseLeave += (sender, arg) =>
{
try
{
if (_browserHost != null)
{
CefMouseEvent mouseEvent = new CefMouseEvent()
{
X = 0,
Y = 0
};
mouseEvent.Modifiers = GetMouseModifiers();
_browserHost.SendMouseMoveEvent(mouseEvent, true);
}
}
catch (Exception ex)
{
_logger.ErrorException("WpfCefBrowser: Caught exception in MouseLeave()", ex);
}
};
browser.MouseMove += (sender, arg) =>
{
try
{
if (_browserHost != null)
{
Point cursorPos = arg.GetPosition(this);
CefMouseEvent mouseEvent = new CefMouseEvent()
{
X = (int)cursorPos.X,
Y = (int)cursorPos.Y
};
mouseEvent.Modifiers = GetMouseModifiers();
_browserHost.SendMouseMoveEvent(mouseEvent, false);
}
}
catch (Exception ex)
{
_logger.ErrorException("WpfCefBrowser: Caught exception in MouseMove()", ex);
}
};
browser.MouseDown += (sender, arg) =>
{
try
{
if (_browserHost != null)
{
Focus();
Point cursorPos = arg.GetPosition(this);
CefMouseEvent mouseEvent = new CefMouseEvent()
{
X = (int)cursorPos.X,
Y = (int)cursorPos.Y,
};
mouseEvent.Modifiers = GetMouseModifiers();
if (arg.ChangedButton == MouseButton.Left)
{
_browserHost.SendMouseClickEvent(mouseEvent, CefMouseButtonType.Left, false, arg.ClickCount);
}
else if (arg.ChangedButton == MouseButton.Middle)
{
_browserHost.SendMouseClickEvent(mouseEvent, CefMouseButtonType.Middle, false, arg.ClickCount);
}
else if (arg.ChangedButton == MouseButton.Right)
{
_browserHost.SendMouseClickEvent(mouseEvent, CefMouseButtonType.Right, false, arg.ClickCount);
}
}
}
catch (Exception ex)
{
_logger.ErrorException("WpfCefBrowser: Caught exception in MouseDown()", ex);
}
};
browser.MouseUp += (sender, arg) =>
{
try
{
if (_browserHost != null)
{
Point cursorPos = arg.GetPosition(this);
CefMouseEvent mouseEvent = new CefMouseEvent()
{
X = (int)cursorPos.X,
Y = (int)cursorPos.Y,
};
mouseEvent.Modifiers = GetMouseModifiers();
if (arg.ChangedButton == MouseButton.Left)
{
_browserHost.SendMouseClickEvent(mouseEvent, CefMouseButtonType.Left, true, 1);
}
else if (arg.ChangedButton == MouseButton.Middle)
{
_browserHost.SendMouseClickEvent(mouseEvent, CefMouseButtonType.Middle, true, 1);
}
else if (arg.ChangedButton == MouseButton.Right)
{
_browserHost.SendMouseClickEvent(mouseEvent, CefMouseButtonType.Right, true, 1);
}
}
}
catch (Exception ex)
{
_logger.ErrorException("WpfCefBrowser: Caught exception in MouseUp()", ex);
}
};
browser.MouseWheel += (sender, arg) =>
{
try
{
if (_browserHost != null)
{
Point cursorPos = arg.GetPosition(this);
CefMouseEvent mouseEvent = new CefMouseEvent()
{
X = (int)cursorPos.X,
Y = (int)cursorPos.Y,
};
_browserHost.SendMouseWheelEvent(mouseEvent, 0, arg.Delta);
}
}
catch (Exception ex)
{
_logger.ErrorException("WpfCefBrowser: Caught exception in MouseWheel()", ex);
}
};
// TODO: require more intelligent processing
browser.PreviewTextInput += (sender, arg) =>
{
if (_browserHost != null)
{
_logger.Debug("TextInput: text {0}", arg.Text);
foreach (var c in arg.Text)
{
CefKeyEvent keyEvent = new CefKeyEvent()
{
EventType = CefKeyEventType.Char,
WindowsKeyCode = (int)c,
};
keyEvent.Modifiers = GetKeyboardModifiers();
_browserHost.SendKeyEvent(keyEvent);
}
}
arg.Handled = true;
};
// TODO: require more intelligent processing
browser.PreviewKeyDown += (sender, arg) =>
{
try
{
if (_browserHost != null)
{
CefKeyEvent keyEvent = new CefKeyEvent()
{
EventType = CefKeyEventType.RawKeyDown,
WindowsKeyCode = KeyInterop.VirtualKeyFromKey(arg.Key == Key.System ? arg.SystemKey : arg.Key),
NativeKeyCode = 0,
IsSystemKey = arg.Key == Key.System,
};
keyEvent.Modifiers = GetKeyboardModifiers();
_browserHost.SendKeyEvent(keyEvent);
}
}
catch (Exception ex)
{
_logger.ErrorException("WpfCefBrowser: Caught exception in PreviewKeyDown()", ex);
}
arg.Handled = HandledKeys.Contains(arg.Key);
};
// TODO: require more intelligent processing
browser.PreviewKeyUp += (sender, arg) =>
{
try
{
if (_browserHost != null)
{
//_logger.Debug(string.Format("KeyUp: system key {0}, key {1}", arg.SystemKey, arg.Key));
CefKeyEvent keyEvent = new CefKeyEvent()
{
EventType = CefKeyEventType.KeyUp,
WindowsKeyCode = KeyInterop.VirtualKeyFromKey(arg.Key == Key.System ? arg.SystemKey : arg.Key),
NativeKeyCode = 0,
IsSystemKey = arg.Key == Key.System,
};
keyEvent.Modifiers = GetKeyboardModifiers();
_browserHost.SendKeyEvent(keyEvent);
}
}
catch (Exception ex)
{
_logger.ErrorException("WpfCefBrowser: Caught exception in PreviewKeyUp()", ex);
}
arg.Handled = true;
};
}
protected override bool OnPreKeyEvent(CefBrowser browser, CefKeyEvent keyEvent, IntPtr os_event, out bool isKeyboardShortcut)
{
return(base.OnPreKeyEvent(browser, keyEvent, os_event, out isKeyboardShortcut));
}
