public static bool IsMappingPending(KeyMapping map, MappingFilter filter) { if (_unsavedMappings.Contains(map)) { return(false); } // Did this mapping exist at boot or logon time? switch (filter) { case MappingFilter.ClearedUser: case MappingFilter.ClearedBoot: return(true); // A cleared mapping is by definition pending case MappingFilter.All: return(!(_savedBootMappings.Contains(map) | _savedUserMappings.Contains(map))); case MappingFilter.Boot: return(!(_savedBootMappings.Contains(map))); case MappingFilter.User: return(!(_savedUserMappings.Contains(map))); } return(true); }
public KeyPictureBox(int scancode, int extended, BlankButton button, float scale, int horizontalStretch, int verticalStretch) { _scancode = scancode; _extended = extended; _button = button; _scale = scale; _horizontalStretch = horizontalStretch; _verticalStretch = verticalStretch; _dragIconScale = 0.75F; _dragbox = Rectangle.Empty; Map = MappingsManager.GetKeyMapping(_scancode, _extended); _mapped = (Map.To.Scancode != -1); this.AllowDrop = true; // Box controls itself. this.DragOver += KeyPictureBoxDragOver; this.DragDrop += KeyPictureBoxDragDrop; this.DragLeave += KeyPictureBoxDragLeave; this.GiveFeedback += KeyPictureBoxGiveFeedback; this.MouseDown += KeyPictureBoxMouseDown; this.MouseMove += KeyPictureBoxMouseMove; this.MouseUp += KeyPictureBoxMouseUp; this.QueryContinueDrag += KeyPictureBoxQueryContinueDrag; DrawKey(); this.Width = this.Image.Width; this.Height = this.Image.Height; }
private static Collection <KeyMapping> GetMappingsFromScancodeMap(byte[] map, MappingType type) { // Transform the byte array into keymappings var maps = new Collection <KeyMapping>(); int count = 0; int length = map.GetLength(0); // How many mappings are there? // (Make sure there are at least 8 bytes in the array) if (length > 8) { count = map[8] - 1; } if (count == 0) { return(maps); } const int start = 12; for (int i = 0; i < count; i++) { // Make sure we don't extend beyond array bounds if (length >= (start + (i * 4) + 3)) { // First pair is the action - what the mapped key does. int word1 = map[start + (i * 4)]; int word2 = map[start + (i * 4) + 1]; var tokey = new Key(word1, word2); // Second pair is the physical key which performs the new action word1 = map[start + (i * 4) + 2]; word2 = map[start + (i * 4) + 3]; var fromkey = new Key(word1, word2); var mapping = new KeyMapping(fromkey, tokey); if (mapping.IsValid()) { mapping.SetType(type); maps.Add(mapping); } else // Just ignore it and hope it goes away. // A manually added - or garbled - entry could be invalid. { } } } return(maps); }
public static void DeleteMapping(KeyMapping map) { if (!map.IsValid()) throw new ArgumentException("Can't delete an invalid map"); PushMappingsOntoUndoStack(); if (mappings.Contains(map)) { mappings.Remove(map); } RaiseMappingsChangedEvent(); }
public static void DeleteMapping(KeyMapping map) { if (!map.IsValid()) { throw new ArgumentException("Can't delete an invalid map"); } PushMappingsOntoUndoStack(); if (mappings.Contains(map)) { mappings.Remove(map); } RaiseMappingsChangedEvent(); }
public static void DeleteMapping(KeyMapping map, MappingFilter filter) { if (!map.IsValid()) { throw new ArgumentException("Can't delete an invalid map"); } PushMappingsOntoUndoStack(); switch (filter) { case MappingFilter.All: // Could be mapped in both HKCU and HKLM so // remove the HKCU mapping first, but not both.. if (_userMappings.Contains(map)) { _userMappings.Remove(map); } else if (_bootMappings.Contains(map)) { _bootMappings.Remove(map); } break; case MappingFilter.Boot: if (_bootMappings.Contains(map)) { _bootMappings.Remove(map); } break; case MappingFilter.User: if (_userMappings.Contains(map)) { _userMappings.Remove(map); } break; default: break; } RaiseMappingsChangedEvent(); }
public static void ShowEditMappingForm(KeyMapping km, bool useCapture) { AddEditMapping mf = new AddEditMapping(km, useCapture); Properties.Settings userSettings = new Properties.Settings(); Point savedLocation = userSettings.EditMappingFormLocation; if (savedLocation.IsEmpty == false) { mf.Location = savedLocation; } else { PositionChildForm(mf, ChildFormPosition.MiddleLeft); } mf.ShowDialog(_mainForm); }
public static bool IsMapped(KeyMapping map, MappingFilter filter) { Collection <KeyMapping> maps; switch (filter) { case MappingFilter.All: maps = _allMappings; break; case MappingFilter.Boot: maps = _bootMappings; break; case MappingFilter.Current: maps = currentFilteredMappings; break; case MappingFilter.User: maps = _userMappings; break; case MappingFilter.ClearedUser: maps = clearedUserMappings; break; case MappingFilter.ClearedBoot: maps = clearedBootMappings; break; default: maps = new Collection <KeyMapping>(); break; } return(maps.Contains(map)); }
private static byte[] GetMappingsAsByteArray(Collection <KeyMapping> maps) { // Turn mappings into a byte[] int count = maps.Count; int size = (16 + (count * 4)); // Check they are all zero. var bytemappings = new byte[size]; // Allow for the null mapping at the end bytemappings[8] = (byte)(count + 1); const int start = 12; for (int i = 0; i < count; i++) { // Make sure we don't extend beyond array bounds if (size <= (start + (i * 4) + 3)) { break; } KeyMapping map = maps[i]; // First pair is the action - what the mapped key does. bytemappings[start + (i * 4)] = (byte)map.To.Scancode; bytemappings[start + (i * 4) + 1] = (byte)map.To.Extended; // Second pair is the physical key which performs the new action bytemappings[start + (i * 4) + 2] = (byte)map.From.Scancode; bytemappings[start + (i * 4) + 3] = (byte)map.From.Extended; } return(bytemappings); }
public static bool IsDisabledMapping(KeyMapping map) { return(map.To.Scancode == 0 && map.To.Extended == 0); }
public static bool IsEmptyMapping(KeyMapping map) { return(map.To.Scancode == -1 && map.To.Extended == -1); }
public static bool IsMapped(KeyMapping map) { return(mappings.Contains(map)); }
public static void DeleteMapping(KeyMapping map) { DeleteMapping(map, Filter); }
public static bool IsMapped(KeyMapping map) { return mappings.Contains(map); }
public static bool IsDisabledMapping(KeyMapping map) { return (map.To.Scancode == 0 && map.To.Extended == 0); }
private static bool AddMapping(KeyMapping map, bool noStackNoEventRaised) { if (!map.IsValid()) { return(false); } int scancode = map.From.Scancode; int extended = map.From.Extended; // If user is remapping Left Ctrl, Left Alt, or Delete then s/he must confirm // that it could be goodbye to CTRL-ALT-DEL if ((scancode == 29 && extended == 0) || (scancode == 56 && extended == 0) || (scancode == 83 && extended == 224)) { string action = IsDisabledMapping(map) ? "disable " : "remap "; string warning = "You are attempting to " + action + map.From.Name + " which is required for CTRL-ALT-DELETE." + (char)13 + "If you continue you may not be able to log on" + " to your PC."; string question = "Are you really sure you want to " + action + "this key?"; TaskDialogResult dr = FormsManager.ShowTaskDialog(question, warning, "Key Mapper", TaskDialogButtons.Yes | TaskDialogButtons.No, TaskDialogIcon.Question); if (dr != TaskDialogResult.Yes) { return(false); } } // If user is remapping Pause, then suggest they will want to disable Num Lock as well. bool disableNumLock = false; if (scancode == 29 && extended == 225 && IsDisabledMapping(map) == false) { // Is Num Lock already disabled or remapped? bool numLockIsDisabled = false; bool numLockIsMapped = false; foreach (KeyMapping km in mappings) { if (km.From.Scancode == 69) { if (IsDisabledMapping(km)) { numLockIsDisabled = true; } else { numLockIsMapped = true; } } } if (numLockIsDisabled == false) { string warning = "If you remap Pause, the Num Lock key will be disabled" + (numLockIsMapped ? ((char)13 + "and your existing Num Lock mapping will be removed.") : "."); const string question = "Do you still want to remap Pause?"; TaskDialogResult dr = FormsManager.ShowTaskDialog(question, warning, "Key Mapper", TaskDialogButtons.Yes | TaskDialogButtons.No, TaskDialogIcon.Question); if (dr != TaskDialogResult.Yes) { return(false); } disableNumLock = true; } } if (noStackNoEventRaised == false) { PushMappingsOntoUndoStack(); } // Check for any existing mappings for this key // if they exist, this mapping needs to replace them. KeyMapping existingMap = GetKeyMapping(map.From.Scancode, map.From.Extended); if (existingMap.IsEmpty() == false) { mappings.Remove(existingMap); } mappings.Add(map); if (disableNumLock) { var nl = new KeyMapping(new Key(69, 0), new Key(0, 0)); AddMapping(nl, true); } if (noStackNoEventRaised == false) { RaiseMappingsChangedEvent(); } return(true); }
private void MapSelected() { if (disabled) // Nono - Can't map while disabled. Shouldn't be here anyway! return; if (mapped) { // Unmap. MappingsManager.DeleteMapping(map); SetMapToBlankMapping(); Close(); return; } if (capturingToKey) { // Ah, but have we caught a "to" key yet? if (!map.IsValid()) return; capturingToKey = false; StopCapture(); MappingsManager.AddMapping(map); Close(); return; } if (selectingFromKeyFromLists) { Key selectedKey = GetKeyFromListboxValue(); // Have we been sent a dud?? if (selectedKey.Scancode == 0) { // Something went wrong. map = new KeyMapping(); } else { SetMapToBlankMapping(selectedKey.Scancode, selectedKey.Extended); // Need to move panel back to where it was and set the image in the picturebox KeyListsPanel.Location = savedPanelLocation; FromKeyPictureBox.SetImage(ButtonImages.GetButtonImage(map.From.Scancode, map.From.Extended)); selectingFromKeyFromLists = false; keyThreshold = 1; SetListOptionsComboIndex(); SetupForm(); return; } } if (capturingFromKey == false) { // Not mapped, not capturing From or To keys, so this is mapping from list. // Need to call method to create map from name. if (CreateMappingFromListboxValue()) { MappingsManager.AddMapping(map); Close(); } return; } else { // Setting the From key. Map has already been created from keypress capturingFromKey = false; StopCapture(); direction = FadeDirection.FromBlankToUnmapped; SetupForm(); Transition(); } }
private void DisableButtonClick(object sender, EventArgs e) { // Disable or enable, close form anyway. if (disabled) { // Enable MappingsManager.DeleteMapping(map); } else { // Disable map = new KeyMapping(map.From, new Key(0, 0)); MappingsManager.AddMapping(map); } Close(); }
private bool CreateMappingFromListboxValue() { map = new KeyMapping(map.From, GetKeyFromListboxValue()); return true; }
public static bool IsMappingPending(KeyMapping map) { return IsMappingPending(map, Filter); }
public static void ShowEditMappingForm(KeyMapping km, bool useCapture) { AddEditMapping mf = new AddEditMapping(km, useCapture); Properties.Settings userSettings = new Properties.Settings(); Point savedLocation = userSettings.EditMappingFormLocation; if (savedLocation.IsEmpty == false) mf.Location = savedLocation; else PositionChildForm(mf, ChildFormPosition.MiddleLeft); mf.ShowDialog(_mainForm); }
public static bool IsMappingPending(KeyMapping map) { return(IsMappingPending(map, Filter)); }
private void OnKeyPress(object sender, KeyMapperKeyPressedEventArgs e) { int scancode = e.Key.Scancode; int extended = e.Key.Extended; if (capturingFromKey) { // Have we been sent a dud?? if (scancode == 0) { // Can't use a disabled key as From map = new KeyMapping(); } else { SetMapToBlankMapping(scancode, extended); } } else { // Can't tell from the passed key whether it's mapped or not as // if it is, we get the mapped scancode and have no way of telling // what the original key was (it's possible 2 keys could be mapped to the // same key, meaning can't just do a reverse lookup.) // So, mapping to a mapped key is de facto allowed. map = new KeyMapping(map.From, new Key(scancode, extended)); } SetupForm(); }
public static bool AddMapping(KeyMapping map) { return(AddMapping(map, false)); }
private static bool AddMapping(KeyMapping map, bool noStackNoEventRaised) { if (!map.IsValid()) { return false; } int scancode = map.From.Scancode; int extended = map.From.Extended; // If user is remapping Left Ctrl, Left Alt, or Delete then s/he must confirm // that it could be goodbye to CTRL-ALT-DEL if ((scancode == 29 && extended == 0) || (scancode == 56 && extended == 0) || (scancode == 83 && extended == 224)) { string action = IsDisabledMapping(map) ? "disable " : "remap "; string warning = "You are attempting to " + action + map.From.Name + " which is required for CTRL-ALT-DELETE." + (char)13 + "If you continue you may not be able to log on" + " to your PC."; string question = "Are you really sure you want to " + action + "this key?"; TaskDialogResult dr = FormsManager.ShowTaskDialog(question, warning, "Key Mapper", TaskDialogButtons.Yes | TaskDialogButtons.No, TaskDialogIcon.Question); if (dr != TaskDialogResult.Yes) return false; } // If user is remapping Pause, then suggest they will want to disable Num Lock as well. bool disableNumLock = false; if (scancode == 29 && extended == 225 && IsDisabledMapping(map) == false) { // Is Num Lock already disabled or remapped? bool numLockIsDisabled = false; bool numLockIsMapped = false; foreach (KeyMapping km in mappings) if (km.From.Scancode == 69) { if (IsDisabledMapping(km)) numLockIsDisabled = true; else numLockIsMapped = true; } if (numLockIsDisabled == false) { string warning = "If you remap Pause, the Num Lock key will be disabled" + (numLockIsMapped ? ((char)13 + "and your existing Num Lock mapping will be removed.") : "."); const string question = "Do you still want to remap Pause?"; TaskDialogResult dr = FormsManager.ShowTaskDialog(question, warning, "Key Mapper", TaskDialogButtons.Yes | TaskDialogButtons.No, TaskDialogIcon.Question); if (dr != TaskDialogResult.Yes) return false; disableNumLock = true; } } if (noStackNoEventRaised == false) PushMappingsOntoUndoStack(); // Check for any existing mappings for this key // if they exist, this mapping needs to replace them. KeyMapping existingMap = GetKeyMapping(map.From.Scancode, map.From.Extended); if (existingMap.IsEmpty() == false) mappings.Remove(existingMap); mappings.Add(map); if (disableNumLock) { var nl = new KeyMapping(new Key(69, 0), new Key(0, 0)); AddMapping(nl, true); } if (noStackNoEventRaised == false) RaiseMappingsChangedEvent(); return true; }
public static bool IsMapped(KeyMapping map, MappingFilter filter) { Collection<KeyMapping> maps; switch (filter) { case MappingFilter.All: maps = _allMappings; break; case MappingFilter.Boot: maps = _bootMappings; break; case MappingFilter.Current: maps = currentFilteredMappings; break; case MappingFilter.User: maps = _userMappings; break; case MappingFilter.ClearedUser: maps = clearedUserMappings; break; case MappingFilter.ClearedBoot: maps = clearedBootMappings; break; default: maps = new Collection<KeyMapping>(); break; } return maps.Contains(map); }
private static Collection<KeyMapping> GetMappingsFromScancodeMap(byte[] map) { // Transform the byte array into keymappings var maps = new Collection<KeyMapping>(); int count = 0; int length = map.GetLength(0); // How many mappings are there? // (Make sure there are at least 8 bytes in the array) if (length > 8) count = map[8] - 1; if (count == 0) { return maps; } const int start = 12; for (int i = 0; i < count; i++) { // Make sure we don't extend beyond array bounds if (length >= (start + (i * 4) + 3)) { // First pair is the action - what the mapped key does. int word1 = map[start + (i * 4)]; int word2 = map[start + (i * 4) + 1]; var tokey = new Key(word1, word2); // Second pair is the physical key which performs the new action word1 = map[start + (i * 4) + 2]; word2 = map[start + (i * 4) + 3]; var fromkey = new Key(word1, word2); var mapping = new KeyMapping(fromkey, tokey); if (mapping.IsValid()) { maps.Add(mapping); } else // Just ignore it and hope it goes away. // A manually added - or garbled - entry could be invalid. { } } } return maps; }
public static bool IsEmptyMapping(KeyMapping map) { return (map.To.Scancode == -1 && map.To.Extended == -1); }
public static void DeleteMapping(KeyMapping map) { DeleteMapping(map, Filter); }
public static bool IsMappingPending(KeyMapping map, MappingFilter filter = MappingFilter.Boot) { if (unsavedMappings.Contains(map)) return false; // Did this mapping exist at boot or logon time? switch (filter) { case MappingFilter.ClearedBoot: return true; // A cleared mapping is by definition pending case MappingFilter.Boot: return !(savedBootMappings.Contains(map)); } return true; }
public static void DeleteMapping(KeyMapping map, MappingFilter filter) { if (!map.IsValid()) throw new ArgumentException("Can't delete an invalid map"); PushMappingsOntoUndoStack(); switch (filter) { case MappingFilter.All: // Could be mapped in both HKCU and HKLM so // remove the HKCU mapping first, but not both.. if (_userMappings.Contains(map)) { _userMappings.Remove(map); } else if (_bootMappings.Contains(map)) { _bootMappings.Remove(map); } break; case MappingFilter.Boot: if (_bootMappings.Contains(map)) { _bootMappings.Remove(map); } break; case MappingFilter.User: if (_userMappings.Contains(map)) { _userMappings.Remove(map); } break; default: break; } RaiseMappingsChangedEvent(); }
public static bool AddMapping(KeyMapping map) { return AddMapping(map, false); }
private void SetMapToBlankMapping() { map = MappingsManager.GetEmptyMapping(map.From); }
public AddEditMapping(KeyMapping map, bool useCapture) { InitializeComponent(); // There are four startup states for this form. // 1) Choose a From key by capturing it // 2) Choose a mapping for a specific From key // 3) Display a given mapping From and To. Includes disabled. // 4) Select a From key from the lists // Map is a struct so it can't be null. if (map.IsEmpty()) { if (useCapture) { // We are capturing the 'from' key. capturingFromKey = true; } else { selectingFromKeyFromLists = true; } } else { mapped = (map.To.Scancode > 0); disabled = (map.To.Scancode == 0); } newMapping = !map.IsValid(); this.map = map; // Default has the KeyLists panel in the frame. if (mapped | disabled) { SwopPanelPositions(KeyListsPanel, MappingPanel); } else if (capturingFromKey) { SwopPanelPositions(EmptyPanel, KeyListsPanel); } if (selectingFromKeyFromLists) { // Need to move the lists to the left where the box while remembering where it was savedPanelLocation = KeyListsPanel.Location; KeyListsPanel.Left = FromKeyPictureBox.Left; keyThreshold = -1; // Show all keys as possible map-ees } else keyThreshold = 1; SetListOptionsComboIndex(); PopulateKeyLists(); // Add event handlers now values have been assigned GroupsListbox.SelectedIndexChanged += GroupsListboxSelectedIndexChanged; KeysByGroupListbox.SelectedIndexChanged += KeysByGroupListboxSelectedIndexChanged; ListOptionsCombo.SelectedIndexChanged += ListOptionsComboSelectedIndexChanged; KeysByGroupListbox.DoubleClick += KeysByGroupListboxDoubleClick; SetupForm(); }
private void SetMapToBlankMapping(int scancode, int extended) { map = MappingsManager.GetEmptyMapping(new Key(scancode, extended)); }