public MainWindow() { InitializeComponent(); var keyHandler = new KeyHandler(this, DisplayControl); KeyDown += keyHandler.OnKeyDown; }
public Daleks() : super("Daleks") { setSize(1020, 820); setResizable(false); this.addWindowListener(new FrameListener()); var menuBar = new MenuBar(); this.setMenuBar(menuBar); var menu = new Menu("File"); menuBar.add(menu); var menuItem = new MenuItem("New Game"); menu.add(menuItem); menuItem.addActionListener(p => newGame()); menuItem = new MenuItem("-"); menu.add(menuItem); menuItem = new MenuItem("Exit"); menu.add(menuItem); menuItem.addActionListener(p => dispose()); this.setLayout(new BorderLayout()); this.add(status = new Label("To start: File > New Game"), BorderLayout.SOUTH); this.keyHandler = new KeyHandler(this); this.addKeyListener(keyHandler); this.timer = new Timer(true); }
public void Run() { Log.InfoFormat("Starting timer with a sample rate of {0} ms", _sampleRateMilliseconds); var timer = new Timer(); timer.AutoReset = true; timer.Interval = _sampleRateMilliseconds; timer.Elapsed += (s, e) => Tick(); timer.Start(); var keyHandler = new KeyHandler(); keyHandler.WaitForExit(); }
public void TickChatSystem() { if (IsChatVisible()) { if (OpenTK.Input.Keyboard.GetState().IsKeyDown(OpenTK.Input.Key.Escape)) // TODO: Better method for this! { CloseChat(); return; } if (!WVis) { KeyHandler.GetKBState(); WVis = true; } ChatBox.Selected = true; } }
public static bool HandleKeys(KeyHandler handler) { if (Interactive) { while (Console.KeyAvailable) { ConsoleKey key = Console.ReadKey(true).Key; if (!handler(key)) { return(false); } } } return(true); }
/// <summary> /// Maps a key /// </summary> /// <param name="keyCombination">The combo</param> /// <param name="keyHandler">The handler</param> public KeyboardMapper Map(KeyCombination keyCombination, KeyHandler keyHandler) { #if DEBUG if (DebugMode) { Debug.Log("KeyboardMapper.Map: " + keyCombination); } #endif if (!_mappings.ContainsKey(keyCombination)) { _mappings.Add(keyCombination, new List <KeyHandler>()); } _mappings[keyCombination].Add(keyHandler); return(this); }
/// <summary> /// Constructs the player object. /// </summary> /// <param name="game"></param> /// <param name="GameScreen"></param> /// <param name="keyBinds"></param> public Player(GameRoot game, GameScreen GameScreen, KeyBinds keyBinds) : base(game, GameScreen) { this.KeyBinds = keyBinds; this.keyHandler = new KeyHandler(); // The players texture is set here instead of load // content because the StartPosition requires the textures size this.Texture = GameRoot.ResourceManager.GetTexture("BluePlayer"); this.shootingSound = GameRoot.ResourceManager.GetSound("PlayerShoot"); this.damageSound = GameRoot.ResourceManager.GetSound("Destroy"); this.MaxHealth = 150; this.Health = MaxHealth; this.Speed = 450.0f; this.exhaustAnimation = new Animation(GameRoot, GameScreen, GameRoot.ResourceManager.GetTexture("ExhaustAnimation"), 0.075f, true); this.GameScreen.Components.Add(exhaustAnimation); }
// Check if player is in combat without pressing any keys. // Player might be targetting something else than the enemy target. private void RunTargetSwitchHandler() { var now = DateTime.Now; _timeSinceLastAttackInCombat = now; Task.Run(() => { while (_isInCombat) { if ((now - _timeSinceLastAttackInCombat).Seconds > 1) { KeyHandler.PressKey(Keys.Tab); } Thread.Sleep(500); } }); }
private void setHotkey(string key) { try { if (gkh != null) { gkh.Unregiser(); } KeysConverter kc = new KeysConverter(); Keys mykey = (Keys)kc.ConvertFromString(key); gkh = new KeyHandler(mykey, this); gkh.Register(); defaultHotkeyLabel.Text = "Default Hotkey: " + key; } catch (Exception) { MessageBox.Show("Please try a real key"); } }
public static Player CreatePlayer(Transform Parent, Vector2 Position) { GameObject NewObject = GameObject.CreatePrimitive(PrimitiveType.Sphere); NewObject.transform.parent = Parent; NewObject.transform.localScale = new Vector3(.5f, .5f, .5f); NewObject.transform.position = Parent.position + Parent.rotation * new Vector3(Position.x / Parent.localScale.x, Position.y / Parent.localScale.y, -.5f / Parent.localScale.z); NewObject.GetComponent <Renderer>().material.color = Color.black; Player NewPlayer = NewObject.AddComponent <Player>(); KeyHandler Resetter = NewObject.AddComponent <KeyHandler>(); Resetter.Key = KeyCode.R; Resetter.Event = new UnityEngine.Events.UnityEvent(); Resetter.Event.AddListener(NewPlayer.RandomizePosition); return(NewPlayer); }
protected override void SetupBehaviour() { EventManager.On("CombatChanged", (Event ev) => { _isInCombat = (bool)ev.Data; }); EventManager.On("KeyPressRequested", (Event ev) => { var keyRequest = (KeyPressRequest)ev.Data; if (keyRequest.ModifierKey != Keys.None) { KeyHandler.ModifiedKeypress(keyRequest.ModifierKey, keyRequest.Key); if (keyRequest.ModifierKey == Keys.LControlKey && keyRequest.Key == Keys.D1) { _isFollowing = true; } if (keyRequest.ModifierKey == Keys.LControlKey && keyRequest.Key == Keys.D9) { KeyHandler.PressKey(Keys.S, 1500); } if (keyRequest.ModifierKey == Keys.LControlKey && keyRequest.Key == Keys.D2) { if (!_isFollowing) { return; } _isFollowing = false; KeyHandler.PressKey(Keys.S, 10); } } else { KeyHandler.PressKey(keyRequest.Key); } }); EventManager.On("WrongFacing", (Event _) => { KeyHandler.PressKey(Keys.D, 75); }); }
/// <summary> /// Repeatedly prompts the user for a key press, until any of the specified escape keys /// are pressed. /// <para/> /// If the pressed key if available in the specified handlers, the corresponding handler /// is called. If not, it is ignored and the loop continues. /// </summary> /// <param name="handlers">Collection of keys to handle and their handlers.</param> /// <param name="postKeyPress"> /// Optional action to run after any key press, not counting the ignored keys and escape /// keys. /// </param> /// <param name="escapeKeys"> /// The keys that will break the loop. If not specified, defaults to the escape key. /// </param> public static void WaitForKeysLoop(IEnumerable <KeyHandler> handlers, Action <ConsoleKey> postKeyPress = null, IEnumerable <ConsoleKey> escapeKeys = null) { if (handlers is null) { throw new ArgumentNullException(nameof(handlers)); } List <KeyHandler> handlersList = handlers.ToList(); if (handlersList.Count == 0) { throw new ArgumentException("Specify at least one handler.", nameof(handlers)); } // If the escapeKeys parameter is not specified, default it to the Escape key. if (escapeKeys is null) { escapeKeys = new[] { ConsoleKey.Escape } } ; // Ensure that none of the escape keys are specified in the handlers. if (handlersList.Any(h => escapeKeys.Any(k => k == h.Key))) { throw new ArgumentException("Specified escape keys should not be specified in the handlers.", nameof(escapeKeys)); } List <ConsoleKey> escapeKeysList = escapeKeys.ToList(); ConsoleKey key = Console.ReadKey(intercept: true).Key; while (!escapeKeysList.Any(k => k == key)) { KeyHandler handler = handlersList.FirstOrDefault(h => h.Key == key); if (handler != null) { handler.Action?.Invoke(key); postKeyPress?.Invoke(key); } key = Console.ReadKey(intercept: true).Key; } } }
public TheAppContext() { ourKeyHandler = new KeyHandler(); // Initialize Tray Icon trayIcon = new NotifyIcon() { Icon = Resources.AppIcon, ContextMenu = new ContextMenu(new MenuItem[] { new MenuItem("Reload Settings", ReloadSettings), new MenuItem("Exit", Exit) }), Visible = true }; Form1 f1 = new Form1(); f1.ShowDialog(); }
public static void OnKeyPressed(this Widget w, KeyHandler handler) { if (Program.WidgetKeyHandlers.ContainsKey(w)) { Console.WriteLine("Warning: overwriting key handler for widget"); } Program.WidgetKeyHandlers[w] = e => { if (w.CPointer != IntPtr.Zero) { return(handler(e)); } Program.WidgetKeyHandlers.Remove(w); return(true); }; }
public MainPage() { this.InitializeComponent(); Window.Current.CoreWindow.KeyDown += CoreWindow_KeyDown; Window.Current.CoreWindow.KeyUp += CoreWindow_KeyUp; keyHandler = new KeyHandler(this); cameraServer = new CameraServer(UpdateImageAsync); // Not using MVVM here, directly using imperative code to change image source MovementController movementController = new MovementController(); Task.Factory.StartNew(movementController.MonitorForMovement); StreamSocketListener listener = new StreamSocketListener(); listener.BindEndpointAsync(new HostName(SELF_IP_ADDRESS), SELF_CAMERA_PORT); // It's okay to not use await here because we can register an event handler before the endpoint is bounded listener.ConnectionReceived += Listener_ConnectionReceived; }
public UnityVehicleCmdGenerator(UserInputManager.Lib.UserInputManager manager) { _lastCmd = new VehicleCmd(); _inputManager = manager; // 界面不会影响车辆控制 var keyhandler = new KeyHandler(Layer.Ui, BlockType.None); _inputManager.RegisterKeyhandler(keyhandler); keyhandler.BindKeyAction(UserInputKey.MoveVertical, data => _lastCmd.MoveVertical = data.Axis); keyhandler.BindKeyAction(UserInputKey.MoveHorizontal, data => _lastCmd.MoveHorizontal = data.Axis); keyhandler.BindKeyAction(UserInputKey.VehicleSpeedUp, data => _lastCmd.IsSpeedup = true); keyhandler.BindKeyAction(UserInputKey.VehicleBrake, data => _lastCmd.IsHandbrake = true); keyhandler.BindKeyAction(UserInputKey.VehicleHorn, data => _lastCmd.IsHornOn = true); keyhandler.BindKeyAction(UserInputKey.VehicleLeftShift, data => _lastCmd.IsLeftShift = true); keyhandler.BindKeyAction(UserInputKey.VehicleRightShift, data => _lastCmd.IsRightShift = true); keyhandler.BindKeyAction(UserInputKey.VehicleStunt, data => _lastCmd.IsStunt = true); }
void Update() { if (uiHandler != null) { bool open = KeyHandler.IsKeyDown("Inventory_Open"); bool close = KeyHandler.IsKeyDown("GUI_Close"); if (open && !inventoryOpen) { inventoryOpen = true; OpenInventory(); } else if ((open && inventoryOpen) || (open || close)) { inventoryOpen = false; CloseInventory(); } } }
void Page_Loaded(object sender, RoutedEventArgs e) { this.Focus(); Page.Keyhandler = new KeyHandler(); Page.Keyhandler.Attach(this); //Page.MouseHandler = new MouseHandler(); //Page.MouseHandler.Attach(this); Page.SceneLoop = new SceneLoop(); Page.SceneLoop.Attach(this.mainCanvas); view = new TankView(); view.Ended += new EventHandler(view_Ended); this.mainCanvas.Children.Add(view); }
private static void Init() { if (SDL.SDL_Init(SDL.SDL_INIT_VIDEO) != 0) { throw new SdlException(nameof(SDL.SDL_Init)); } if (SDL_ttf.TTF_Init() != 0) { throw new SdlException(nameof(SDL_ttf.TTF_Init)); } _window = SDL.SDL_CreateWindow("Langton`s Ant", 0, 0, 640, 480, SDL.SDL_WindowFlags.SDL_WINDOW_SHOWN); if (_window == IntPtr.Zero) { throw new SdlException(nameof(SDL.SDL_CreateWindow)); } _renderer = SDL.SDL_CreateRenderer( _window, -1, SDL.SDL_RendererFlags.SDL_RENDERER_ACCELERATED | SDL.SDL_RendererFlags.SDL_RENDERER_PRESENTVSYNC); if (_renderer == IntPtr.Zero) { throw new SdlException(nameof(SDL.SDL_CreateRenderer)); } _font = SDL_ttf.TTF_OpenFont(_fontPath, 14); KeydownHandler = new KeyHandler(); KeydownHandler.Add(SDL.SDL_Keycode.SDLK_ESCAPE, () => _quit = true); KeydownHandler.Add(SDL.SDL_Keycode.SDLK_F5, LoadWorld); KeydownHandler.Add(SDL.SDL_Keycode.SDLK_F2, () => _speed -= 10); KeydownHandler.Add(SDL.SDL_Keycode.SDLK_F3, () => _speed += 10); KeydownHandler.Add(SDL.SDL_Keycode.SDLK_F4, () => _speed = 0); KeydownHandler.Add(SDL.SDL_Keycode.SDLK_z, () => GetWorldRenderer().AddZoom(-10)); KeydownHandler.Add(SDL.SDL_Keycode.SDLK_x, () => GetWorldRenderer().AddZoom(10)); KeydownHandler.Add(SDL.SDL_Keycode.SDLK_c, () => GetWorldRenderer().ResetZoom()); KeydownHandler.Add(SDL.SDL_Keycode.SDLK_RIGHT, () => GetWorldRenderer().MoveZoom(10, 0)); KeydownHandler.Add(SDL.SDL_Keycode.SDLK_UP, () => GetWorldRenderer().MoveZoom(0, -10)); KeydownHandler.Add(SDL.SDL_Keycode.SDLK_LEFT, () => GetWorldRenderer().MoveZoom(-10, 0)); KeydownHandler.Add(SDL.SDL_Keycode.SDLK_DOWN, () => GetWorldRenderer().MoveZoom(0, 10)); }
public void TestBackwardsTab() { _keyHandler.Handle(Tab); // Nothing happens when no auto complete handler is set Assert.Equal("Hello", _keyHandler.Text); _keyHandler = new KeyHandler(new Console2(), _history, _autoCompleteHandler); "Hi ".Select(c => c.ToConsoleKeyInfo()).ToList().ForEach(_keyHandler.Handle); // Bring up the first Autocomplete _keyHandler.Handle(Tab); _completions.Reverse().ToList().ForEach(completion => { _keyHandler.Handle(ShiftTab); Assert.Equal($"Hi {completion}", _keyHandler.Text); }); }
public static void CreateHook(KeyHandler _kh) { Process _this = Process.GetCurrentProcess(); ProcessModule mod = _this.MainModule; hd = HookFunc; kh = _kh; hhk = API.SetWindowsHookEx(13, hd, API.GetModuleHandle(mod.ModuleName), 0); Console.WriteLine("CreateHook HAS RUN"); //13 is the parameter specifying that we're gonna do a low-level keyboard hook //MessageBox.Show(Marshal.GetLastWin32Error().ToString()); //for debugging //Note that this could be a Console.WriteLine(), as well. I just happened //to be debugging this in a Windows Application //to get the errors, in VS 2005+ (possibly before) do Tools -> Error Lookup }
protected override void SetupBehaviour() { EventManager.On(HWnd, "KeyPressRequested", (Event ev) => { var keyRequest = (KeyPressRequest)ev.Data; if (keyRequest.ModifierKey != Keys.None) { if (keyRequest.ModifierKey == Keys.F1) { var converter = TypeDescriptor.GetConverter(typeof(Keys)); var key = (Keys)converter.ConvertFromString("F" + keyRequest.Key.ToString().Replace("D", "")); if (key == Keys.F8) { _isFollowing = true; } else if (key == Keys.F9) { if (_isFollowing) { _isFollowing = false; KeyHandler.PressKey(Keys.S, 10); } } KeyHandler.PressKey(key); } else { KeyHandler.ModifiedKeypress(keyRequest.ModifierKey, keyRequest.Key); } } else { KeyHandler.PressKey(keyRequest.Key); } }); EventManager.On(HWnd, "WrongFacing", (Event _) => { KeyHandler.PressKey(Keys.D, 75); }); }
private void InitKeyBinding() { var handler = new KeyHandler(UiConstant.maxMapWindowLayer, BlockType.None); handler.BindKeyAction(UserInputKey.ShowMaxMap, (data) => { ShowMap(!_adapter.Enable); }); _adapter.RegisterOpenKey(handler); keyReceive = new KeyHandler(UiConstant.maxMapWindowKeyBlockLayer, BlockType.All); keyReceive.BindKeyAction(UserInputKey.HideWindow, (data) => { if (_adapter.Enable) { ShowMap(!_adapter.Enable); } }); }
private void InitKeyBinding() { var handler = new KeyHandler(UiConstant.rangingWindowLayer, BlockType.None); handler.BindKeyAction(UserInputKey.CheckRanging, (data) => { Debug.Log("CheckRanging.........................."); var selfPlayer = adapter.GetPlayerEntity(); if (selfPlayer.gamePlay.IsObserving()) { return; } var playerTrans = selfPlayer.characterContoller.Value.transform; var cameraPos = selfPlayer.cameraObj.MainCamera.transform.position; var cameraForword = selfPlayer.cameraObj.MainCamera.transform.forward; RaycastHit hit; int bricksLayer = LayerMask.NameToLayer("Player"); //不检测player层级的东西 int layerMask = 1 << bricksLayer; layerMask = ~layerMask; if (Physics.Raycast(cameraPos, cameraForword, out hit, int.MaxValue, layerMask)) { var hitPos = hit.point; var distance = Vector3.Distance(hitPos, playerTrans.position); distance = Mathf.Max(distance, 1); //Debug.Log("name:" + hit.collider.gameObject.name); if (adapter.RangeInfo == null) { adapter.RangeInfo = new RangingInfo((long)distance, hitPos); } else { adapter.RangeInfo.distance = (long)distance; adapter.RangeInfo.contactPos = hitPos; } } RefreshGui(); }); adapter.RegisterKeyReceive(handler); }
public void Page_Loaded(object o, EventArgs e) { // Required to initialize variables _splash = new Splash(); canvas.Children.Add(_splash); _splash.SetValue(Canvas.ZIndexProperty, 20000); KeyHandler = new KeyHandler(); KeyHandler.Attach(this); Focus(); gameLoop = new GameLoop(); gameLoop.Attach(parentCanvas); gameLoop.Update += gameLoop_Update; Fps fps = new Fps(); canvas.Children.Add(fps); fps.SetValue(Canvas.ZIndexProperty, 1000); _mainMenu = new MainMenu(); canvas.Children.Add(_mainMenu); _mainMenu.MenuItemSelected += mainMenu_MenuItemSelected; Page_SizeChanged(null, null); }
/// <summary> /// Reads the specified prompt. /// </summary> /// <param name="prompt">The prompt.</param> /// <param name="default">The default.</param> /// <returns></returns> public static string Read(string prompt = "", string @default = "") { Console.Write(prompt); KeyHandler keyHandler = new KeyHandler(new Console2(), _history, AutoCompletionHandler); string text = GetText(keyHandler); if (string.IsNullOrWhiteSpace(text) && !string.IsNullOrWhiteSpace(@default)) { text = @default; } else { if (HistoryEnabled) { _history.Add(text); } } return(text); }
/// <summary> /// The primary tick entry point from the OpenGL window. /// </summary> /// <param name="sender">The sending object</param> /// <param name="e">The frame event details, including delta timing</param> static void Window_UpdateFrame(object sender, FrameEventArgs e) { Delta = ((double)Ticker.ElapsedTicks) / ((double)Stopwatch.Frequency); Ticker.Reset(); Ticker.Start(); try { GlobalTickTime += Delta; MouseHandler.Tick(); KeyHandler.Tick(); UIConsole.Tick(); ClientCommands.Tick(); ClientNetworkBase.Tick(); TickWorld(); } catch (Exception ex) { SysConsole.Output(OutputType.ERROR, "Error / updateframe: " + ex.ToString()); } }
private void InitKeyReveiver() { keyReveiver = new KeyHandler(UiConstant.weaponBagWindowKeyBlockLayer, BlockType.All); for (int i = 0; i < _haveBagForIndexList.Count; i++) { if (_haveBagForIndexList[i]) { var index = i - 1; keyReveiver.BindKeyAction(UserInputKey.Switch1 + index, (data) => { btnGroupTab.SetSelect(index); CloseView(); }); keyReveiver.BindKeyAction(UserInputKey.HideWindow, (data) => { CloseView(); }); } } _pointerKeyHandler = new PointerKeyHandler(UiConstant.weaponBagWindowKeyBlockLayer, BlockType.All); }
public KeyHandlerTests() { _completions = new string[] { "World", "Angel", "Love" }; _history = new List <string>(new string[] { "dotnet run", "git init", "clear" }); _keyHandler = new KeyHandler(new Console2(), _history, null); _keyInfo = new ConsoleKeyInfo('H', ConsoleKey.H, false, false, false); _keyHandler.Handle(_keyInfo); _keyInfo = new ConsoleKeyInfo('e', ConsoleKey.E, false, false, false); _keyHandler.Handle(_keyInfo); _keyInfo = new ConsoleKeyInfo('l', ConsoleKey.L, false, false, false); _keyHandler.Handle(_keyInfo); _keyInfo = new ConsoleKeyInfo('l', ConsoleKey.L, false, false, false); _keyHandler.Handle(_keyInfo); _keyInfo = new ConsoleKeyInfo('o', ConsoleKey.O, false, false, false); _keyHandler.Handle(_keyInfo); }
protected override void MouseLeftDown() { MDown = true; Selected = true; /* KeyHandlerState khs = */ KeyHandler.GetKBState(); int xs = GetX(); for (int i = 0; i < Text.Length; i++) { if (xs + Fonts.MeasureFancyText(Text.Substring(0, i)) > MouseHandler.MouseX()) { MinCursor = i; MaxCursor = i; MStart = i; return; } } MinCursor = Text.Length; MaxCursor = Text.Length; MStart = Text.Length; }
private void InitKeyReveiver() { var keyhandler = new KeyHandler(UiConstant.chatWindowLayer, BlockType.None); keyhandler.BindKeyAction(UserInputKey.SendChatMessage, (data) => { if (ChatListState != EUIChatListState.Send) { SwitchToSendState(); } }); _switchKeyHandler = new KeyHandler(UiConstant.chatWindowKeyBlockLayer, BlockType.All); _switchKeyHandler.BindKeyAction(UserInputKey.SendChatMessage, (data) => { SendMessage(); }); _switchKeyHandler.BindKeyAction(UserInputKey.SwitchChatChannel, (data) => { SwitchChannel(); UpdateChannel(); }); _chatState.RegisterOpenKey(keyhandler); }
static private KeyHandler globalKeyHandler; // handles global keys like fullscreen and exit static void Main() { var settings = new RLSettings { BitmapFile = "font14x14.png", CharWidth = 14, CharHeight = 14, Width = 80, Height = 45, ResizeType = RLResizeType.ResizeCells, // Display more tiles on screen if the console gets bigger, dont just increase size of existing Scale = 1f, StartWindowState = RLWindowState.Normal, WindowBorder = RLWindowBorder.Resizable, Title = "Apprentice" }; Engine.Init(settings); // Generate new world World = new GameWorld(30, 30, 50, 50); // For now we just spawn player at random position in the demi-plane Coord playerSpawn = Map.RandomOpenPosition(World.DemiPlane, SingletonRandom.DefaultRNG); Player = new Player(playerSpawn); World.DemiPlane.Add(Player); // Changes active map too // Global key commands setup globalKeyHandler = new GlobalKeyHandler(); globalKeyHandler.StartHandling(); // UI setup GameScreen = new GameScreen(); SpellsPanel = new SpellsPanel(Screen.SizeC(0), Screen.SizeC(0), Screen.WidthMinus(0), Screen.HeightMinus(0)); MessageRecallPanel = new MessageRecallPanel(Screen.SizeC(0), Screen.SizeC(0), Screen.WidthMinus(0), Screen.HeightMinus(0)); // Show UI and get game underway GameScreen.Show(); Engine.Run(); }
protected override void SetupBehaviour() { EventManager.On(HWnd, "KeyPressRequested", (Event ev) => { var keyRequest = (KeyPressRequest)ev.Data; if (keyRequest.ModifierKey != Keys.None) { if (keyRequest.ModifierKey == Keys.F1) { var converter = TypeDescriptor.GetConverter(typeof(Keys)); var key = (Keys)converter.ConvertFromString("F" + keyRequest.Key.ToString().Replace("D", "")); KeyHandler.PressKey(key); return; } KeyHandler.ModifiedKeypress(keyRequest.ModifierKey, keyRequest.Key); } else { KeyHandler.PressKey(keyRequest.Key); } }); }
public void TickChatSystem() { if (IsChatVisible()) { ChatBottomLastTick = ChatIsAtBottom(); if (ChatBox.TriedToEscape) { CloseChat(); return; } if (!WVis) { KeyHandler.GetKBState(); WVis = true; } ChatBox.Selected = true; } else { ChatBottomLastTick = true; } }
public KeyHandlerTests() { _autoCompleteHandler = new AutoCompleteHandler(); _completions = _autoCompleteHandler.GetSuggestions("", 0); _history = new List <string>(new string[] { "dotnet run", "git init", "clear" }); _keyHandler = new KeyHandler(new Console2(), _history, null); _keyInfo = new ConsoleKeyInfo('H', ConsoleKey.H, false, false, false); _keyHandler.Handle(_keyInfo); _keyInfo = new ConsoleKeyInfo('e', ConsoleKey.E, false, false, false); _keyHandler.Handle(_keyInfo); _keyInfo = new ConsoleKeyInfo('l', ConsoleKey.L, false, false, false); _keyHandler.Handle(_keyInfo); _keyInfo = new ConsoleKeyInfo('l', ConsoleKey.L, false, false, false); _keyHandler.Handle(_keyInfo); _keyInfo = new ConsoleKeyInfo('o', ConsoleKey.O, false, false, false); _keyHandler.Handle(_keyInfo); }
/// <summary> /// Returns true if the specified mapping exists /// </summary> /// <param name="keyCombination">The combo to check for</param> /// <param name="keyHandler">The handler to check for</param> /// <returns></returns> public bool Maps(KeyCombination keyCombination, KeyHandler keyHandler) { if (_mappings.ContainsKey(keyCombination)) return _mappings[keyCombination].Contains(keyHandler); return false; }
/// <summary> /// Maps a key /// </summary> /// <param name="keyCombination">The combo</param> /// <param name="keyHandler">The handler</param> public KeyboardMapper Map(KeyCombination keyCombination, KeyHandler keyHandler) { #if DEBUG if (DebugMode) Debug.Log("KeyboardMapper.Map: " + keyCombination); #endif if (!_mappings.ContainsKey(keyCombination)) _mappings.Add(keyCombination, new List<KeyHandler>()); _mappings[keyCombination].Add(keyHandler); return this; }
public Handler(ConsoleKeyInfo myConsoleKeyInfo, KeyHandler myKeyHandler) { CKI = myConsoleKeyInfo; KeyHandler = myKeyHandler; }
public static Handler Control (char c, KeyHandler h, bool resetCompletion = true) { return new Handler ((char) (c - 'A' + 1), h, resetCompletion); }
void EditLoop () { ConsoleKeyInfo cki; while (!done){ cki = Console.ReadKey (true); bool handled = false; foreach (Handler handler in handlers){ ConsoleKeyInfo t = handler.CKI; if (t.Key == cki.Key && t.Modifiers == cki.Modifiers){ handled = true; handler.KeyHandler (); last_handler = handler.KeyHandler; break; } else if (t.KeyChar == cki.KeyChar && t.Key == ConsoleKey.Zoom){ handled = true; handler.KeyHandler (); last_handler = handler.KeyHandler; break; } } if (handled){ if (searching != 0){ if (last_handler != CmdReverseSearch){ searching = 0; SetPrompt (prompt); } } continue; } if (cki.KeyChar != (char) 0) HandleChar (cki.KeyChar); } }
public static Handler Control (char c, KeyHandler h) { return new Handler ((char) (c - 'A' + 1), h); }
public Handler (char c, KeyHandler h) { KeyHandler = h; // Use the "Zoom" as a flag that we only have a character. CKI = new ConsoleKeyInfo (c, ConsoleKey.Zoom, false, false, false); }
public Handler (ConsoleKey key, KeyHandler h, bool resetCompletion = true) { CKI = new ConsoleKeyInfo ((char) 0, key, false, false, false); KeyHandler = h; ResetCompletion = resetCompletion; }
protected void AddKeyHandler(Keys key, KeyHandler handler) { KeyHandlers[key] = (object)handler; }
void EditLoop () { ConsoleKeyInfo cki; while (!done){ ConsoleModifiers mod; cki = Console.ReadKey (true); mod = cki.Modifiers; bool handled = false; if (_tabExpander.Running) { _tabExpander.Start(text.ToString()); bool skipKeyHandling = _tabExpander.HandleKey(cki); RenderTabExpander(); max_rendered = _tabExpander.GetExpandedCommand().Length; if (skipKeyHandling) { continue; } } foreach (Handler handler in handlers){ ConsoleKeyInfo t = handler.CKI; if ((t.Key == cki.Key && t.Modifiers == mod) || (t.KeyChar == cki.KeyChar && t.Key == ConsoleKey.Zoom) ){ if (_tabExpander.Running) { _tabExpander.Abort(true); RenderTabExpander(); } handled = true; handler.KeyHandler (); last_handler = handler.KeyHandler; break; } } if (handled){ if (searching != 0){ if (last_handler != CmdReverseSearch){ searching = 0; SetPrompt (prompt); } } continue; } if (cki.KeyChar != (char)0) { if (_tabExpander.Running && _tabExpander.HasSelection) { _tabExpander.Accept(); RenderTabExpander(); } HandleChar(cki.KeyChar); } } }
public static Handler Alt(Char myChar, ConsoleKey myConsoleKey, KeyHandler myKeyHandler) { var cki = new ConsoleKeyInfo((char) myChar, myConsoleKey, false, true, false); return new Handler (cki, myKeyHandler); }
public static Handler Control(Char myChar, KeyHandler myKeyHandler) { return new Handler((char) (myChar - 'A' + 1), myKeyHandler); }
/// <summary> /// Unmaps a key /// </summary> /// <param name="keyCombination">The combo</param> /// <param name="keyHandler">The handler</param> public KeyboardMapper Unmap(KeyCombination keyCombination, KeyHandler keyHandler) { #if DEBUG if (DebugMode) Debug.Log("KeyboardMapper.Unmap: " + keyCombination); #endif if (_mappings.ContainsKey(keyCombination)) { _mappings[keyCombination].Remove(keyHandler); if (_mappings[keyCombination].Count == 0) _mappings.Remove(keyCombination); } if (_oneShotMappings.ContainsKey(keyCombination)) { _oneShotMappings[keyCombination].Remove(keyHandler); if (_oneShotMappings[keyCombination].Count == 0) _oneShotMappings.Remove(keyCombination); } return this; }
public Handler (ConsoleKey key, KeyHandler h) { CKI = new ConsoleKeyInfo ((char) 0, key, false, false, false); KeyHandler = h; }
public Handler(ConsoleKey myKey, KeyHandler myKeyHandler) { CKI = new ConsoleKeyInfo ((char) 0, myKey, false, false, false); KeyHandler = myKeyHandler; }
public Handler (ConsoleKeyInfo cki, KeyHandler h) { CKI = cki; KeyHandler = h; }
public static void CreateHook(KeyHandler _kh) { Process _this = Process.GetCurrentProcess(); ProcessModule mod = _this.MainModule; hd = HookFunc; kh = _kh; hhk = API.SetWindowsHookEx(13, hd, API.GetModuleHandle(mod.ModuleName), 0); //13 is the parameter specifying that we're gonna do a low-level keyboard hook //MessageBox.Show(Marshal.GetLastWin32Error().ToString()); //for debugging //Note that this could be a Console.WriteLine(), as well. I just happened //to be debugging this in a Windows Application //to get the errors, in VS 2005+ (possibly before) do Tools -> Error Lookup }
public static Handler Alt (char c, ConsoleKey k, KeyHandler h) { ConsoleKeyInfo cki = new ConsoleKeyInfo ((char) c, k, false, true, false); return new Handler (cki, h); }
private void Form1_Load(object sender, EventArgs e) { KeyHandler ghk; ghk = new KeyHandler(Keys.F1, this); ghk.Register(); }
public Handler (ConsoleKeyInfo cki, KeyHandler h, bool resetCompletion = true) { CKI = cki; KeyHandler = h; ResetCompletion = resetCompletion; }
public Handler (char c, KeyHandler h, bool resetCompletion = true) { KeyHandler = h; // Use the "Zoom" as a flag that we only have a character. CKI = new ConsoleKeyInfo (c, ConsoleKey.Zoom, false, false, false); ResetCompletion = resetCompletion; }
public void Run() { CameraCapture.Start(); var keyHandler = new KeyHandler(); keyHandler.KeyEvent += keyHandler_KeyEvent; keyHandler.WaitForExit(); Stop(); }
public Handler(Char myChar, KeyHandler myKeyHandler) { KeyHandler = myKeyHandler; // Use the "Zoom" as a flag that we only have a character. CKI = new ConsoleKeyInfo(myChar, ConsoleKey.Zoom, false, false, false); }
private KeyHandler SetupKeyHandler() { // Reinstantiate the handler. m_keyHandler = new KeyHandler(); // Start at the end KeyAction quit = new KeyAction(this.Quit, null, null); m_keyHandler.AddAction("q", quit); // Scrolling KeyAction scrollup = new KeyAction(null, null, GetRenderer().Camera.ScrollUp); m_keyHandler.AddAction("uparrow", scrollup); KeyAction scrolldown = new KeyAction(null, null, GetRenderer().Camera.ScrollDown); m_keyHandler.AddAction("downarrow", scrolldown); KeyAction scrollleft = new KeyAction(null, null, GetRenderer().Camera.ScrollLeft); m_keyHandler.AddAction("leftarrow", scrollleft); KeyAction scrollright = new KeyAction(null, null, GetRenderer().Camera.ScrollRight); m_keyHandler.AddAction("rightarrow", scrollright); return m_keyHandler; }
private void EditLoop() { ConsoleKeyInfo cki; while (!done) { ConsoleModifiers mod; cki = Console.ReadKey(true); if (cki.Key == ConsoleKey.Escape) { cki = Console.ReadKey(true); mod = ConsoleModifiers.Alt; } else mod = cki.Modifiers; var handled = false; foreach (var handler in handlers) { var t = handler.CKI; if (t.Key == cki.Key && t.Modifiers == mod) { handled = true; handler.KeyHandler(); last_handler = handler.KeyHandler; break; } if (t.KeyChar == cki.KeyChar && t.Key == ConsoleKey.Zoom) { handled = true; handler.KeyHandler(); last_handler = handler.KeyHandler; break; } } if (handled) { if (searching != 0) { if (last_handler != CmdReverseSearch) { searching = 0; SetPrompt(Prompt); } } continue; } if (cki.KeyChar != (char) 0) HandleChar(cki.KeyChar); } }