public List <ControllerMapping> GetMappings(string MidiDeviceName, MappingFilter filter) { List <ControllerMapping> mappings = new List <ControllerMapping>(); DataTable t = GetTable(MidiDeviceName); for (int i = 0; i < t.Rows.Count; i++) { ControllerMapping mapping = GetRow(MidiDeviceName, i); mapping.CatCmd = CatCmdDb.Get(mapping.CatCmd.CatCommandId); if (filter == MappingFilter.None) { mappings.Add(mapping); } else if (filter == MappingFilter.Active) { if (mapping.CatCmd.CatCommandId != CatCmd.None) { mappings.Add(mapping); } } else if (filter == MappingFilter.InActive) { if (mapping.CatCmd.CatCommandId == CatCmd.None) { mappings.Add(mapping); } } } return(mappings); }
public static Collection <KeyMapping> GetMappings(MappingFilter filter) { switch (filter) { case MappingFilter.All: return(_allMappings); case MappingFilter.Current: return(currentFilteredMappings); case MappingFilter.Boot: return(_bootMappings); case MappingFilter.User: return(_userMappings); case MappingFilter.ClearedUser: return(clearedUserMappings); case MappingFilter.ClearedBoot: return(clearedBootMappings); } return(null); }
public static KeyMapping GetClearedMapping(int scancode, int extended, MappingFilter filter) { // If all mappings, look at boot mappings first // in case the key was mapped in both. if (filter == MappingFilter.All || filter == MappingFilter.Boot) { foreach (KeyMapping mapping in clearedBootMappings) { if (mapping.From.Scancode == scancode && mapping.From.Extended == extended) { return(mapping); } } } if (filter == MappingFilter.All || filter == MappingFilter.User) { foreach (KeyMapping mapping in clearedUserMappings) { if (mapping.From.Scancode == scancode && mapping.From.Extended == extended) { return(mapping); } } } return(GetEmptyMapping(new Key(scancode, extended))); }
public static int GetMappingCount(MappingFilter filter) { switch (filter) { case MappingFilter.All: return(_allMappings.Count); case MappingFilter.Current: return(currentFilteredMappings.Count); case MappingFilter.Boot: return(_bootMappings.Count); case MappingFilter.User: return(_userMappings.Count); case MappingFilter.ClearedUser: return(clearedUserMappings.Count); case MappingFilter.ClearedBoot: return(clearedBootMappings.Count); default: return(0); } }
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); }
private void AddRowsToGrid(MappingFilter filter) { Collection <KeyMapping> maps = MappingsManager.GetMappings(filter); foreach (KeyMapping map in maps) { if (filter == MappingFilter.ClearedUser || filter == MappingFilter.ClearedBoot) { if (this._keylist.Contains(map.From)) { // Don't add an entry for a cleared key which has been remapped. break; } } else { this._keylist.Add(map.From); } int index = this.grdMappings.Rows.Add(map.ToString()); this.grdMappings.Rows[index].Tag = map; string cellvalue = string.Empty; switch (filter) { case MappingFilter.Boot: cellvalue = "Boot"; break; case MappingFilter.User: cellvalue = "User"; break; case MappingFilter.ClearedUser: case MappingFilter.ClearedBoot: cellvalue = "Cleared"; // Need to store the row to a little array as // don't want to have to access each cell to decide whether // to show the delete button for it or not. this._clearedKeys.Add(index); break; } this.grdMappings.Rows[index].Cells[1].Value = cellvalue; if (MappingsManager.IsMappingPending(map, filter)) { this.grdMappings.Rows[index].Cells[2].Value = "Pending"; } else { this.grdMappings.Rows[index].Cells[2].Value = "Mapped"; } } }
private void LoadUserSettings() { Properties.Settings userSettings = new Properties.Settings(); // As user.config is writeable (if you can find it!) // don't want to trust the settings. bool firstrun = true; Point savedPosition = Point.Empty; int savedWidth = 0; MappingFilter oldFilter = MappingFilter.All; firstrun = (userSettings.UserHasSavedSettings == false); savedPosition = userSettings.KeyboardFormLocation; savedWidth = userSettings.KeyboardFormWidth; _hasNumberPad = userSettings.KeyboardFormHasNumberPad; _isMacKeyboard = userSettings.KeyboardFormHasMacKeyboard; oldFilter = (MappingFilter)userSettings.LastMappingsFilter; //if (firstrun == false) //{ // // AppController.SwitchKeyboardLayout((KeyboardLayoutType)userSettings.KeyboardLayout); //} if (firstrun || savedPosition.IsEmpty || savedPosition.X == -32000) { FormsManager.PositionMainForm(); } else { this.Location = savedPosition; } if (firstrun || savedWidth < this.MinimumSize.Width) { FormsManager.SizeMainForm(); } else { this.Width = savedWidth; } // If there are boot mappings and no user mappings and the last view mode was boot, then // start in boot mode - as long as user has the rights to change them (or is running Vista) if (oldFilter == MappingFilter.Boot && MappingsManager.GetMappingCount(MappingFilter.Boot) > 0 && MappingsManager.GetMappingCount(MappingFilter.User) == 0 && (AppController.UserCanWriteBootMappings || operatingSystemCapability.ImplementsUAC)) { MappingsManager.SetFilter(MappingFilter.Boot); } }
private void AddRowsToGrid(MappingFilter filter) { Collection<KeyMapping> maps = MappingsManager.GetMappings(filter); foreach (KeyMapping map in maps) { if (filter == MappingFilter.ClearedBoot) { if (_keylist.Contains(map.From)) { // Don't add an entry for a cleared key which has been remapped. break; } } else { _keylist.Add(map.From); } int index = grdMappings.Rows.Add(map.ToString()); grdMappings.Rows[index].Tag = map; string cellvalue = string.Empty; switch (filter) { case MappingFilter.Boot: cellvalue = "Boot"; break; case MappingFilter.ClearedBoot: cellvalue = "Cleared"; // Need to store the row to a little array as // don't want to have to access each cell to decide whether // to show the delete button for it or not. _clearedKeys.Add(index); break; } grdMappings.Rows[index].Cells[1].Value = cellvalue; if (MappingsManager.IsMappingPending(map, filter)) grdMappings.Rows[index].Cells[2].Value = "Pending"; else grdMappings.Rows[index].Cells[2].Value = "Mapped"; } }
private void AddUpdateFilter(MappingFilter mappingFilter) { if (MappingFilterList.FirstOrDefault(x => x.FilterName == mappingFilter.FilterName) == null) { // new filter MappingFilterList.Add(mappingFilter); } else { // replace existing MappingFilterList[MappingFilterList.FindIndex(x => x.FilterName == mappingFilter.FilterName)] = mappingFilter; } DisplayCurrentFilterList(); }
private void CopyFilterBack() { MappingFilter mappingFilter = new MappingFilter(); mappingFilter.FilterName = textBoxFilterName.Text.Trim(); mappingFilter.FilterType = (FilterType)(filterTypeSelector.SelectedValue ?? FilterType.Exclude); mappingFilter.FieldToMatch = filterFieldNames.Text; mappingFilter.FilterMatchType = (FilterMatchType)(matchTypeSelector.SelectedValue ?? FilterMatchType.StringMatchIgnoreCase); mappingFilter.MatchingValue = textBoxTextToMatch.Text.Trim(); if (ValidateFilter(mappingFilter)) { AddUpdateFilter(mappingFilter); ClearFilterSettings(); } }
public static int GetMappingCount(MappingFilter filter) { switch (filter) { case MappingFilter.Current: return(currentFilteredMappings.Count); case MappingFilter.Boot: return(mappings.Count); case MappingFilter.ClearedBoot: return(clearedBootMappings.Count); default: return(0); } }
public static Collection <KeyMapping> GetMappings(MappingFilter filter) { switch (filter) { case MappingFilter.Current: return(currentFilteredMappings); case MappingFilter.Boot: return(mappings); case MappingFilter.ClearedBoot: return(clearedBootMappings); default: throw new NotImplementedException(); } }
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 SetFilter(MappingFilter filter) { // This is a bit problematic as this causes a change which can't be undone // without setting the filter back. Well, problematic unless: // a) Implement event codes (or simply "Undo set filter" // but would need to know what previous filters were each time.) // or b) .. just clear the stacks. if (filter != MappingFilter.All && filter != MappingFilter.Boot && filter != MappingFilter.User) { throw new ArgumentException("Mappings Filter is not valid"); } undostack.Clear(); redostack.Clear(); Filter = filter; RaiseMappingsChangedEvent(); }
private bool ValidateFilter(MappingFilter mappingFilter) { if (mappingFilter.FilterName == string.Empty) { MessageBox.Show("Please add a name for the filter"); return(false); } if (mappingFilter.FieldToMatch == string.Empty) { MessageBox.Show("Please add a field to match"); return(false); } if (mappingFilter.FieldToMatch == "-") { MessageBox.Show("Please add a named field to match"); return(false); } 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)); }
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 Collection<KeyMapping> GetMappings(MappingFilter filter) { switch (filter) { case MappingFilter.Current: return currentFilteredMappings; case MappingFilter.Boot: return mappings; case MappingFilter.ClearedBoot: return clearedBootMappings; default: throw new NotImplementedException(); } }
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 string ExportMappingsAsRegistryFile(MappingFilter filter, bool useTempFile) { // This is the required format: // Windows Registry Editor Version 5.00 // [HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Keyboard Layout] // "Scancode Map"=hex:00,00,00,00,00,00,00,00,02,00,00,00,2a,00,3a,00,00,00,00,00 // [HKEY_CURRENT_USER\Keyboard Layout] // "Scancode Map"=hex:00,00,00,00,00,00,00,00,04,00,00,00,5d,e0,1c,e0,1d,00,5b,e0,2a,00,3a,00,00,00,00,00 // Where there are no mappings, delete the value: // "Scancode Map"=- string filename; if (useTempFile) { filename = Path.GetTempPath() + Path.GetRandomFileName() + ".reg"; } else { var fd = new SaveFileDialog { AddExtension = true, DefaultExt = "reg", Filter = "Registry files (*.reg)|*.reg", InitialDirectory = Environment.GetFolderPath(Environment.SpecialFolder.DesktopDirectory), OverwritePrompt = true, FileName = "Key Mappings", AutoUpgradeEnabled = true }; DialogResult dr = fd.ShowDialog(); if (dr != DialogResult.OK) { return(String.Empty); } filename = fd.FileName; } int bootMappingCount = GetMappingCount(MappingFilter.Boot); using (var sw = new StreamWriter(filename, false, Encoding.Unicode)) { sw.WriteLine("Windows Registry Editor Version 5.00"); sw.WriteLine(); if (filter == MappingFilter.Boot || filter == MappingFilter.All) { sw.WriteLine(@"[HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Keyboard Layout]"); sw.Write("\"Scancode Map\"="); if (bootMappingCount > 0) { sw.Write("hex:"); WriteMappingsToStream(sw, GetMappingsAsByteArray(GetMappings(MappingFilter.Boot))); } else { sw.Write("-"); } sw.WriteLine(); if (bootMappingCount > 0) { sw.WriteLine(); } } if (filter == MappingFilter.User || filter == MappingFilter.All) { sw.WriteLine(@"[HKEY_CURRENT_USER\Keyboard Layout]"); sw.Write("\"Scancode Map\"="); if (GetMappingCount(MappingFilter.User) > 0) { sw.Write("hex:"); WriteMappingsToStream(sw, GetMappingsAsByteArray(GetMappings(MappingFilter.User))); } else { sw.Write("-"); } sw.WriteLine(); } } return(filename); }
public static int GetMappingCount(MappingFilter filter) { switch (filter) { case MappingFilter.Current: return currentFilteredMappings.Count; case MappingFilter.Boot: return mappings.Count; case MappingFilter.ClearedBoot: return clearedBootMappings.Count; default: return 0; } }
protected override void LoadFilterModelData(MappingFilter filter) { filter.Stores = LoadStores(); }
public static Collection<KeyMapping> GetMappings(MappingFilter filter) { switch (filter) { case MappingFilter.All: return _allMappings; case MappingFilter.Current: return currentFilteredMappings; case MappingFilter.Boot: return _bootMappings; case MappingFilter.User: return _userMappings; case MappingFilter.ClearedUser: return clearedUserMappings; case MappingFilter.ClearedBoot: return clearedBootMappings; } return null; }
public static int GetMappingCount(MappingFilter filter) { switch (filter) { case MappingFilter.All: return _allMappings.Count; case MappingFilter.Current: return currentFilteredMappings.Count; case MappingFilter.Boot: return _bootMappings.Count; case MappingFilter.User: return _userMappings.Count; case MappingFilter.ClearedUser: return clearedUserMappings.Count; case MappingFilter.ClearedBoot: return clearedBootMappings.Count; default: return 0; } }
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); }
public static KeyMapping GetClearedMapping(int scancode, int extended, MappingFilter filter) { // If all mappings, look at boot mappings first // in case the key was mapped in both. if (filter == MappingFilter.All || filter == MappingFilter.Boot) { foreach (KeyMapping mapping in clearedBootMappings) { if (mapping.From.Scancode == scancode && mapping.From.Extended == extended) return mapping; } } if (filter == MappingFilter.All || filter == MappingFilter.User) foreach (KeyMapping mapping in clearedUserMappings) { if (mapping.From.Scancode == scancode && mapping.From.Extended == extended) return mapping; } return GetEmptyMapping(new Key(scancode, extended)); }
public static void SetFilter(MappingFilter filter) { // This is a bit problematic as this causes a change which can't be undone // without setting the filter back. Well, problematic unless: // a) Implement event codes (or simply "Undo set filter" // but would need to know what previous filters were each time.) // or b) .. just clear the stacks. if (filter != MappingFilter.All && filter != MappingFilter.Boot && filter != MappingFilter.User) throw new ArgumentException("Mappings Filter is not valid"); undostack.Clear(); redostack.Clear(); Filter = filter; RaiseMappingsChangedEvent(); }
public static string ExportMappingsAsRegistryFile(MappingFilter filter, bool useTempFile) { // This is the required format: // Windows Registry Editor Version 5.00 // [HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Keyboard Layout] // "Scancode Map"=hex:00,00,00,00,00,00,00,00,02,00,00,00,2a,00,3a,00,00,00,00,00 // [HKEY_CURRENT_USER\Keyboard Layout] // "Scancode Map"=hex:00,00,00,00,00,00,00,00,04,00,00,00,5d,e0,1c,e0,1d,00,5b,e0,2a,00,3a,00,00,00,00,00 // Where there are no mappings, delete the value: // "Scancode Map"=- string filename; if (useTempFile) filename = Path.GetTempPath() + Path.GetRandomFileName() + ".reg"; else { var fd = new SaveFileDialog { AddExtension = true, DefaultExt = "reg", Filter = "Registry files (*.reg)|*.reg", InitialDirectory = Environment.GetFolderPath(Environment.SpecialFolder.DesktopDirectory), OverwritePrompt = true, FileName = "Key Mappings", AutoUpgradeEnabled = true }; DialogResult dr = fd.ShowDialog(); if (dr != DialogResult.OK) { return String.Empty; } filename = fd.FileName; } int bootMappingCount = GetMappingCount(MappingFilter.Boot); using (var sw = new StreamWriter(filename, false, Encoding.Unicode)) { sw.WriteLine("Windows Registry Editor Version 5.00"); sw.WriteLine(); if (filter == MappingFilter.Boot || filter == MappingFilter.All) { sw.WriteLine(@"[HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Keyboard Layout]"); sw.Write("\"Scancode Map\"="); if (bootMappingCount > 0) { sw.Write("hex:"); WriteMappingsToStream(sw, GetMappingsAsByteArray(GetMappings(MappingFilter.Boot))); } else { sw.Write("-"); } sw.WriteLine(); if (bootMappingCount > 0) sw.WriteLine(); } if (filter == MappingFilter.User || filter == MappingFilter.All) { sw.WriteLine(@"[HKEY_CURRENT_USER\Keyboard Layout]"); sw.Write("\"Scancode Map\"="); if (GetMappingCount(MappingFilter.User) > 0) { sw.Write("hex:"); WriteMappingsToStream(sw, GetMappingsAsByteArray(GetMappings(MappingFilter.User))); } else sw.Write("-"); sw.WriteLine(); } } return filename; }