Example #1
0
        /// <summary>
        /// 实现F12调出调试窗口
        /// </summary>
        /// <param name="browserControl"></param>
        /// <param name="browser"></param>
        /// <param name="type"></param>
        /// <param name="windowsKeyCode"></param>
        /// <param name="nativeKeyCode"></param>
        /// <param name="modifiers"></param>
        /// <param name="isSystemKey"></param>
        /// <returns></returns>
        public bool OnKeyEvent(IWebBrowser browserControl, IBrowser browser, KeyType type, int windowsKeyCode, int nativeKeyCode, CefEventFlags modifiers, bool isSystemKey)
        {
            if (type != KeyType.KeyUp)
            {
                return(false);
            }

            //todo 使用System.Windows.Input.Key.F12来实现
            //目前windowsKeyCode和System.Windows.Input.Key.F12无法对应 没有深入研究
            if (windowsKeyCode == F12KeyCode)
            {
                Console.WriteLine("F12");
                browser.ShowDevTools();
                return(true);
            }

            if (windowsKeyCode == F5KeyCode)
            {
                Console.WriteLine("F5");
                if (browser.MainFrame?.Url != null)
                {
                    if (browser.MainFrame.Url.StartsWith("chrome-devtools:", StringComparison.OrdinalIgnoreCase))
                    {
                        //chrome-devtools://devtools/devtools_app.html
                        return(false);
                    }
                }

                browser.Reload(true);
                return(true);
            }

            return(false);
        }
        public bool OnKeyEvent(IWebBrowser browserControl, IBrowser browser, KeyType type, int windowsKeyCode, int nativeKeyCode, CefEventFlags modifiers, bool isSystemKey)
        {
            if (type == KeyType.KeyUp && Enum.IsDefined(typeof(Keys), windowsKeyCode))
            {
                var key = (Keys)windowsKeyCode;
                switch (key)
                {
                case Keys.F1:    //F1事件,打开钱箱
                    PublicUtil.openMoneyBox();
                    break;

                case Keys.F4:    //F4事件,释放内存
                    MainForm.ClearMemory();
                    break;

                case Keys.F5:    //F5事件,刷新
                    browser.Reload();
                    break;

                case Keys.F12:    //F12事件,调出开发者工具
                    browser.ShowDevTools();
                    break;
                }
            }
            return(false);
        }
        public bool OnPreKeyEvent(IWebBrowser browserControl, IBrowser browser, KeyType type, int windowsKeyCode, int nativeKeyCode, CefEventFlags modifiers, bool isSystemKey, ref bool isKeyboardShortcut)
        {
            if (type != KeyType.KeyUp)
            {
                return(false);
            }

            Keys key = (Keys)windowsKeyCode | modifiers.GetKey();

            switch (key)
            {
            case Keys.F5 | Keys.None:
                browser.Reload();
                return(true);

            case Keys.F9 | Keys.None:
            case Keys.F12 | Keys.None:
                browser.ShowDevTools();
                return(true);
            }

            if (key == (Keys.Control | Keys.P))
            {
                var relativePath = String.Format(@".\output-{0}.pdf", Guid.NewGuid().ToString());
                var fullPath     = Path.GetFullPath(relativePath);
                Debug.WriteLine(browser.GetType());
                PdfPrintSettings pdfPrintSettings = new PdfPrintSettings();
                pdfPrintSettings.Landscape          = true;
                pdfPrintSettings.BackgroundsEnabled = true;
                browser.PrintToPdfAsync(fullPath, pdfPrintSettings).ContinueWith(OnPrintToPdfCompleted, fullPath);
                return(true);
            }

            return(false);
        }
Example #4
0
 bool IContextMenuHandler.OnContextMenuCommand(IWebBrowser browserControl, IBrowser browser, IFrame frame, IContextMenuParams parameters, int commandId, CefEventFlags eventFlags)
 {
     if (commandId == (int)CefMenuCommand.Reload)
     {
         browser.Reload();
     }
     return false;
 }
Example #5
0
 public bool OnPreKeyEvent(IWebBrowser browserControl, IBrowser browser, KeyType type, int windowsKeyCode, int nativeKeyCode, CefEventFlags modifiers, bool isSystemKey, ref bool isKeyboardShortcut)
 {
     if (windowsKeyCode == VK_F5)
     {
         browser.Reload();
     }
     return(false);
 }
Example #6
0
        public bool OnPreKeyEvent(IWebBrowser chromiumWebBrowser, IBrowser browser, KeyType type, int windowsKeyCode,
                                  int nativeKeyCode, CefEventFlags modifiers, bool isSystemKey, ref bool isKeyboardShortcut)
        {
            const int vkF5  = 0x74;
            const int vkF11 = 0x7A;
            const int vkF12 = 0x7B;

            switch (windowsKeyCode)
            {
            case vkF5:
                if (modifiers == CefEventFlags.ControlDown)
                {
                    browser.Reload(true);     //强制忽略缓存
                }
                else
                {
                    browser.Reload();
                }
                return(true);

            case vkF11:
                MainForm._mainForm.BeginInvoke(new Action(() =>
                {
                    if (IsMaxWindow)
                    {
                        MainForm._mainForm.FormBorderStyle = FormBorderStyle.FixedSingle;
                        MainForm._mainForm.WindowState     = FormWindowState.Normal;
                    }
                    else
                    {
                        MainForm._mainForm.FormBorderStyle = FormBorderStyle.None;
                        MainForm._mainForm.WindowState     = FormWindowState.Maximized;
                    }
                    IsMaxWindow = !IsMaxWindow;
                }));
                return(true);

            case vkF12:
                browser.ShowDevTools();
                return(true);
            }

            return(false);
        }
        public bool OnPreKeyEvent(IWebBrowser browserControl, IBrowser browser, KeyType type, int windowsKeyCode, int nativeKeyCode, CefEventFlags modifiers, bool isSystemKey, ref bool isKeyboardShortcut)
        {
            const int VK_F5 = 0x74;

            if (windowsKeyCode == VK_F5 && nativeKeyCode != 0)
            {
                browser.Reload(); //此处可以添加想要实现的代码段
                //var chromiumWebBrowser = (ChromiumWebBrowser)browserControl;
                //chromiumWebBrowser.
                //chromiumWebBrowser.Load(browser.MainFrame.Url);
            }
            return(false);
        }
Example #8
0
        public bool OnPreKeyEvent(IWebBrowser browserControl, IBrowser browser, KeyType type, int windowsKeyCode, int nativeKeyCode, CefEventFlags modifiers, bool isSystemKey, ref bool isKeyboardShortcut)
        {
            switch ((Keys)windowsKeyCode)
            {
            case Keys.F12:
                browser.ShowDevTools();
                break;

            case Keys.F5:
                browser.Reload();     //此处可以添加想要实现的代码段
                break;
            }
            return(false);
        }
Example #9
0
 public bool OnKeyEvent(IWebBrowser browserControl, IBrowser browser, KeyType type, int windowsKeyCode, int nativeKeyCode, CefEventFlags modifiers, bool isSystemKey)
 {
     if (type == KeyType.KeyUp)
     {
         if (windowsKeyCode == (int)Keys.F5)
         {
             browser.Reload(true); //无视缓存刷新
         }
         else if (windowsKeyCode == (int)Keys.F12)
         {
             browser.ShowDevTools(); //开发者模式
         }
     }
     return(false);
 }
Example #10
0
        public bool OnKeyEvent(IWebBrowser chromiumWebBrowser, IBrowser browser, KeyType type, int windowsKeyCode, int nativeKeyCode, CefEventFlags modifiers, bool isSystemKey)
        {
            if (type == KeyType.KeyUp)
            {
                switch (windowsKeyCode)
                {
                case KEY_F5:
                    browser.Reload();
                    break;

                case KEY_F12:
                    browser.ShowDevTools();
                    break;
                }
            }
            return(false);
        }
Example #11
0
        bool IContextMenuHandler.OnContextMenuCommand(IWebBrowser browserControl, IBrowser browser, IFrame frame, IContextMenuParams parameters, CefMenuCommand commandId, CefEventFlags eventFlags)
        {
            ////命令的执行
            if (commandId == (CefMenuCommand)26501)
            {
                browser.GetHost().ShowDevTools();
                return(true);
            }
            if (commandId == (CefMenuCommand)26502)
            {
                browser.GetHost().CloseDevTools();
                return(true);
            }

            if (commandId == CefMenuCommand.Reload)
            {
                browser.Reload();
                return(true);
            }
            if (commandId == CefMenuCommand.Back)
            {
                browser.GoBack();
                return(true);
            }
            if (commandId == CefMenuCommand.Forward)
            {
                browser.GoForward();
                return(true);
            }
            if (commandId == CefMenuCommand.Print)
            {
                browser.Print();
                return(true);
            }
            if (commandId == CefMenuCommand.Copy)
            {
                return(true);
            }
            return(false);
        }
Example #12
0
        public bool RunContextMenu(IWebBrowser browserControl, IBrowser browser, IFrame frame, IContextMenuParams parameters, IMenuModel model,
                                   IRunContextMenuCallback callback)
        {
            callback.Dispose();

            ActionExtension.InvokeInMainThread(() => {
                var menu = new ContextMenu {
                    Items =
                    {
                        new MenuItem {
                            Header  = "Back",
                            Command = new DelegateCommand(browser.GoBack, () => browser.CanGoBack)
                        },
                        new MenuItem {
                            Header  = "Forward",
                            Command = new DelegateCommand(browser.GoForward, () => browser.CanGoForward)
                        },
                        new MenuItem {
                            Header  = "Refresh",
                            Command = new DelegateCommand(() => browser.Reload(true))
                        },
                        new Separator(),
                        new MenuItem {
                            Header  = "Select All",
                            Command = new DelegateCommand(() => browser.FocusedFrame.SelectAll())
                        },
                        new MenuItem {
                            Header           = "Open Page In Default Browser",
                            Command          = new DelegateCommand <string>(WindowsHelper.ViewInBrowser),
                            CommandParameter = frame.Url
                        },
                    }
                };

                menu.IsOpen = true;
            });

            return(true);
        }
Example #13
0
        public bool RunContextMenu(IWebBrowser browserControl, IBrowser browser, IFrame frame, IContextMenuParams parameters, IMenuModel model,
                IRunContextMenuCallback callback) {
            callback.Dispose();

            Application.Current.Dispatcher.Invoke(() => {
                var menu = new ContextMenu {
                    Items = {
                        new MenuItem {
                            Header = "Back",
                            Command = new DelegateCommand(browser.GoBack, () => browser.CanGoBack)
                        },
                        new MenuItem {
                            Header = "Forward",
                            Command = new DelegateCommand(browser.GoForward, () => browser.CanGoForward)
                        },
                        new MenuItem {
                            Header = "Refresh",
                            Command = new DelegateCommand(() => browser.Reload(true))
                        },
                        new Separator(),
                        new MenuItem {
                            Header = "Select All",
                            Command = new DelegateCommand(() => browser.FocusedFrame.SelectAll())
                        },
                        new MenuItem {
                            Header = "Open Page In Default Browser",
                            Command = new DelegateCommand<string>(WindowsHelper.ViewInBrowser),
                            CommandParameter = frame.Url
                        },
                    }
                };

                menu.IsOpen = true;
            });
            
            return true;
        }
Example #14
0
        public bool OnContextMenuCommand(IWebBrowser browserControl, IBrowser browser, IFrame frame, IContextMenuParams parameters, CefMenuCommand commandId, CefEventFlags eventFlags)
        {
            switch (commandId)
            {
                case CefMenuCommand.Copy://复制
                    var selectText= parameters.SelectionText;//获取选中的内容
                    frame.Copy();
                    break;
                case CefMenuCommand.Paste://粘贴
                    frame.Paste();
                    break;
                case CefMenuCommand.Print://打印
                    browser.Print();
                    break;
                case CefMenuCommand.ViewSource://查看源码
                    frame.ViewSource();
                    break;
                case CefMenuCommand.Reload://刷新
                    browser.Reload();
                    break;
            }

            return true;
        }
Example #15
0
        protected virtual void ExecuteCommand(IBrowser browser, ContextMenuExecuteModel model)
        {
            // If the user chose a replacement word for a misspelling, replace it here.
            if (model.MenuCommand >= CefMenuCommand.SpellCheckSuggestion0 &&
                model.MenuCommand <= CefMenuCommand.SpellCheckSuggestion4)
            {
                int sugestionIndex = ((int)model.MenuCommand) - (int)CefMenuCommand.SpellCheckSuggestion0;
                if (sugestionIndex < model.DictionarySuggestions.Count)
                {
                    var suggestion = model.DictionarySuggestions[sugestionIndex];
                    browser.ReplaceMisspelling(suggestion);
                }

                return;
            }

            switch (model.MenuCommand)
            {
            // Navigation.
            case CefMenuCommand.Back:
            {
                browser.GoBack();
                break;
            }

            case CefMenuCommand.Forward:
            {
                browser.GoForward();
                break;
            }

            case CefMenuCommand.Reload:
            {
                browser.Reload();
                break;
            }

            case CefMenuCommand.ReloadNoCache:
            {
                browser.Reload(ignoreCache: true);
                break;
            }

            case CefMenuCommand.StopLoad:
            {
                browser.StopLoad();
                break;
            }

            //Editing
            case CefMenuCommand.Undo:
            {
                browser.FocusedFrame.Undo();
                break;
            }

            case CefMenuCommand.Redo:
            {
                browser.FocusedFrame.Redo();
                break;
            }

            case CefMenuCommand.Cut:
            {
                browser.FocusedFrame.Cut();
                break;
            }

            case CefMenuCommand.Copy:
            {
                browser.FocusedFrame.Copy();
                break;
            }

            case CefMenuCommand.Paste:
            {
                browser.FocusedFrame.Paste();
                break;
            }

            case CefMenuCommand.Delete:
            {
                browser.FocusedFrame.Delete();
                break;
            }

            case CefMenuCommand.SelectAll:
            {
                browser.FocusedFrame.SelectAll();
                break;
            }

            // Miscellaneous.
            case CefMenuCommand.Print:
            {
                browser.GetHost().Print();
                break;
            }

            case CefMenuCommand.ViewSource:
            {
                browser.FocusedFrame.ViewSource();
                break;
            }

            case CefMenuCommand.Find:
            {
                browser.GetHost().Find(0, model.SelectionText, true, false, false);
                break;
            }

            // Spell checking.
            case CefMenuCommand.AddToDictionary:
            {
                browser.GetHost().AddWordToDictionary(model.MisspelledWord);
                break;
            }

            case (CefMenuCommand)26501:
            {
                browser.GetHost().ShowDevTools(inspectElementAtX: model.XCoord, inspectElementAtY: model.YCoord);
                break;
            }

            case (CefMenuCommand)26502:
            {
                browser.GetHost().CloseDevTools();
                break;
            }
            }
        }
Example #16
0
        bool IContextMenuHandler.RunContextMenu(IWebBrowser chromiumWebBrowser, IBrowser browser, IFrame frame, IContextMenuParams parameters, IMenuModel model, IRunContextMenuCallback callback)
        {
            //NOTE: Return false to use the built in Context menu - in WPF this requires you integrate into your existing message loop, read the General Usage Guide for more details
            //https://github.com/cefsharp/CefSharp/wiki/General-Usage#multithreadedmessageloop
            //return false;

            var webBrowser = (ChromiumWebBrowser)chromiumWebBrowser;

            //IMenuModel is only valid in the context of this method, so need to read the values before invoking on the UI thread
            var menuItems = GetMenuItems(model).ToList();

            webBrowser.Dispatcher.Invoke(() =>
            {
                var menu = new ContextMenu
                {
                    IsOpen = true
                };

                RoutedEventHandler handler = null;

                handler = (s, e) =>
                {
                    menu.Closed -= handler;

                    //If the callback has been disposed then it's already been executed
                    //so don't call Cancel
                    if (!callback.IsDisposed)
                    {
                        callback.Cancel();
                    }
                };

                menu.Closed += handler;

                foreach (var item in menuItems)
                {
                    if (item.Item2 == CefMenuCommand.NotFound && string.IsNullOrWhiteSpace(item.Item1))
                    {
                        menu.Items.Add(new Separator());
                        continue;
                    }

                    menu.Items.Add(new MenuItem
                    {
                        Header    = item.Item1.Replace("&", "_"),
                        IsEnabled = item.Item3,
                        Command   = new RelayCommand(() =>
                        {
                            //BUG: CEF currently not executing callbacks correctly so we manually map the commands below
                            //see https://github.com/cefsharp/CefSharp/issues/1767
                            //The following line worked in previous versions, it doesn't now, so custom EXAMPLE below
                            //callback.Continue(item.Item2, CefEventFlags.None);

                            //NOTE: Note all menu item options below have been tested, you can work out the rest
                            switch (item.Item2)
                            {
                            case CefMenuCommand.Back:
                                {
                                    browser.GoBack();
                                    break;
                                }

                            case CefMenuCommand.Forward:
                                {
                                    browser.GoForward();
                                    break;
                                }

                            case CefMenuCommand.Cut:
                                {
                                    browser.FocusedFrame.Cut();
                                    break;
                                }

                            case CefMenuCommand.Copy:
                                {
                                    browser.FocusedFrame.Copy();
                                    break;
                                }

                            case CefMenuCommand.Paste:
                                {
                                    browser.FocusedFrame.Paste();
                                    break;
                                }

                            case CefMenuCommand.Print:
                                {
                                    browser.GetHost().Print();
                                    break;
                                }

                            case CefMenuCommand.ViewSource:
                                {
                                    browser.FocusedFrame.ViewSource();
                                    break;
                                }

                            case CefMenuCommand.Undo:
                                {
                                    browser.FocusedFrame.Undo();
                                    break;
                                }

                            case CefMenuCommand.StopLoad:
                                {
                                    browser.StopLoad();
                                    break;
                                }

                            case CefMenuCommand.SelectAll:
                                {
                                    browser.FocusedFrame.SelectAll();
                                    break;
                                }

                            case CefMenuCommand.Redo:
                                {
                                    browser.FocusedFrame.Redo();
                                    break;
                                }

                            case CefMenuCommand.Find:
                                {
                                    browser.GetHost().Find(0, parameters.SelectionText, true, false, false);
                                    break;
                                }

                            case CefMenuCommand.AddToDictionary:
                                {
                                    browser.GetHost().AddWordToDictionary(parameters.MisspelledWord);
                                    break;
                                }

                            case CefMenuCommand.Reload:
                                {
                                    browser.Reload();
                                    break;
                                }

                            case CefMenuCommand.ReloadNoCache:
                                {
                                    browser.Reload(ignoreCache: true);
                                    break;
                                }

                            case (CefMenuCommand)26501:
                                {
                                    browser.GetHost().ShowDevTools();
                                    break;
                                }

                            case (CefMenuCommand)26502:
                                {
                                    browser.GetHost().CloseDevTools();
                                    break;
                                }
                            }
                        })
                    });
                }
                webBrowser.ContextMenu = menu;
            });

            return(true);
        }
Example #17
0
        public bool OnKeyEvent(IWebBrowser chromiumWebBrowser, IBrowser browser, KeyType type, int windowsKeyCode, int nativeKeyCode, CefEventFlags modifiers, bool isSystemKey)
        {
            if (type == KeyType.KeyUp && Enum.IsDefined(typeof(Keys), windowsKeyCode))
            {
                var key = (Keys)windowsKeyCode;
                switch (key)
                {
                case Keys.F12:
                    browser.ShowDevTools();
                    break;

                case Keys.F5:

                    if (modifiers == CefEventFlags.ControlDown)
                    {
                        //MessageBox.Show("ctrl+f5");
                        browser.Reload(true);     //强制忽略缓存
                    }
                    else
                    {
                        //MessageBox.Show("f5");
                        browser.Reload();
                    }
                    break;
                }
            }

            #region 手动设置
            //const int VK_SHIFT = 0xA;
            //const int VK_CONTROL = 0x11;
            //const int VK_MENU = 0x12; // alt

            //const int VK_LEFT = 0x25;
            //const int VK_RIGHT = 0x27;

            //const int VK_F1 = 0x70;
            //const int VK_F2 = 0x71;
            //const int VK_F3 = 0x72;
            //const int VK_F4 = 0x73;
            //const int VK_F5 = 0x74;
            //const int VK_F6 = 0x75;
            //const int VK_F7 = 0x76;
            //const int VK_F8 = 0x77;
            //const int VK_F9 = 0x78;
            //const int VK_F10 = 0x79;
            //const int VK_F11 = 0x7A;
            //const int VK_F12 = 0x7B;

            //switch (modifiers)
            //{
            //    case CefEventFlags.None:
            //        switch (windowsKeyCode)
            //        {
            //            case VK_F5:
            //                browser.Reload(); //刷新
            //                break;
            //            case VK_F12:
            //                browser.ShowDevTools(); //开发工具
            //                break;
            //        }
            //        break;
            //    case CefEventFlags.CapsLockOn:
            //        break;
            //    case CefEventFlags.ShiftDown:
            //        break;
            //    case CefEventFlags.ControlDown:
            //        break;
            //    case CefEventFlags.AltDown:
            //        switch (windowsKeyCode)
            //        {
            //            case (VK_LEFT):
            //                if (browser.CanGoBack)
            //                    browser.GoBack();
            //                break;
            //            case (VK_RIGHT):
            //                if (browser.CanGoForward)
            //                    browser.GoForward();
            //                break;
            //        }
            //        break;
            //    case CefEventFlags.LeftMouseButton:
            //        break;
            //    case CefEventFlags.MiddleMouseButton:
            //        break;
            //    case CefEventFlags.RightMouseButton:
            //        break;
            //    case CefEventFlags.CommandDown:
            //        break;
            //    case CefEventFlags.NumLockOn:
            //        break;
            //    case CefEventFlags.IsKeyPad:
            //        break;
            //    case CefEventFlags.IsLeft:
            //        break;
            //    case CefEventFlags.IsRight:
            //        break;
            //    case CefEventFlags.AltGrDown:
            //        break;
            //    default:
            //        break;
            //}
            #endregion

            return(false);
        }