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;
}
