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 DrawKey() { int scanCode = this.scanCode; int extended = this.extended; ButtonEffect effect; if (MappingsManager.IsEmptyMapping(Map) == false) { // Remapped or disabled? if (MappingsManager.IsDisabledMapping(Map)) { // Disabled if (MappingsManager.IsMappingPending(Map)) { effect = ButtonEffect.DisabledPending; } else { effect = ButtonEffect.Disabled; } } else { // Is this key mapped under the current filter? if (MappingsManager.IsMappingPending(Map)) { effect = ButtonEffect.MappedPending; } else { effect = ButtonEffect.Mapped; } // Either way, we want the button to show what it is (will be) mapped to: scanCode = Map.To.ScanCode; extended = Map.To.Extended; } } else { // Not mapped now, but was this key mapped before under the current filter?? var km = MappingsManager.GetClearedMapping(scanCode, extended); if (MappingsManager.IsEmptyMapping(km)) { effect = ButtonEffect.None; } else if (MappingsManager.IsDisabledMapping(km)) { effect = ButtonEffect.EnabledPending; } else { effect = ButtonEffect.UnmappedPending; } } var keybmp = ButtonImages.GetButtonImage( scanCode, extended, button, horizontalStretch, verticalStretch, scale, effect); SetImage(keybmp); }
private void SetButtonImages() { // Set the buttons' bitmap as required. Always call SetImage as that // handles releasing the existing bitmap if any.. // From key is straightforward. float scale = (DpiInfo.Dpi / 96F); if (FromKeyPictureBox.Image == null && map.IsEmpty()) { FromKeyPictureBox.SetImage(ButtonImages.GetButtonImage (-1, -1, BlankButton.Blank, 0, 0, scale, ButtonEffect.None)); } else { FromKeyPictureBox.SetImage(ButtonImages.GetButtonImage (map.From.Scancode, map.From.Extended, BlankButton.Blank, 0, 0, scale, ButtonEffect.None)); } // To Key depends more on state int scancode = 0; int extended = 0; ButtonEffect effect = ButtonEffect.None; // 'Disabled' is a special case of 'Mapped' if (disabled) { effect = MappingsManager.IsMappingPending(map) ? ButtonEffect.DisabledPending : ButtonEffect.Disabled; } else { if (!mapped) { // Not mapped. What are we doing then?? if (capturingToKey) { scancode = map.To.Scancode; extended = map.To.Extended; if (map.To.Scancode == 0) { // Can't map to a disabled key - show button as disabled.. effect = ButtonEffect.Disabled; } else { effect = ButtonEffect.MappedPending; } } else if (capturingFromKey) { if (map.IsEmpty()) { // Show a blank key. scancode = -1; extended = -1; } } } else { // Mapped to a specific key scancode = map.To.Scancode; extended = map.To.Extended; effect = MappingsManager.IsMappingPending(map) ? ButtonEffect.MappedPending : ButtonEffect.Mapped; } } ToKeyPictureBox.SetImage(ButtonImages.GetButtonImage(scancode, extended, BlankButton.Blank, 0, 0, scale, effect)); }
private void GetButtons() { if (showAllButtons) { buttonCount = 8; return; } // Assume there are some normal unmapped keys! buttonCount = 1; // See what's currently mapped by looking at the current mapping list var currentMaps = MappingsManager.GetMappings(MappingFilter.Current); foreach (var map in currentMaps) { if (MappingsManager.IsMappingPending(map, MappingFilter.Boot)) { // Pending if (MappingsManager.IsDisabledMapping(map)) { if (!pendingDisabled) { pendingDisabled = true; buttonCount++; } } else { if (!pendingMapped) { pendingMapped = true; buttonCount++; } } } else { // Actual if (MappingsManager.IsDisabledMapping(map)) { if (!disabledKeys) { disabledKeys = true; buttonCount++; } } else { if (!mappedKeys) { mappedKeys = true; buttonCount++; } } } } // Now look at the cleared keys. var maps = MappingsManager.ClearedMappings; foreach (var map in maps) { // Has this cleared key been remapped (in which case we ignore it) bool remapped = false; foreach (var currentmap in MappingsManager.GetMappings(MappingFilter.Current)) { if (currentmap.From == map.From) { remapped = true; break; } } if (remapped) { continue; } if (MappingsManager.IsDisabledMapping(map)) { if (!pendingEnabled) { pendingEnabled = true; buttonCount++; } } else { if (!pendingUnmapped) { pendingUnmapped = true; buttonCount++; } } } }
private void GetButtons() { if (this._showAllButtons) { this._buttonCount = 8; return; } // Assume there are some normal unmapped keys! this._buttonCount = 1; // See what's currently mapped by looking at the current mapping list Collection <KeyMapping> currentMaps = MappingsManager.GetMappings(MappingFilter.Current); foreach (KeyMapping map in currentMaps) { if (MappingsManager.IsMappingPending(map, MappingFilter.All)) { // Pending if (MappingsManager.IsDisabledMapping(map)) { if (!this._pendingdisabled) { this._pendingdisabled = true; this._buttonCount++; } } else { if (!this._pendingmapped) { this._pendingmapped = true; this._buttonCount++; } } } else { // Actual if (MappingsManager.IsDisabledMapping(map)) { if (!this._disabledkeys) { this._disabledkeys = true; this._buttonCount++; } } else { if (!this._mappedkeys) { this._mappedkeys = true; this._buttonCount++; } } } } // Now look at the cleared keys. IEnumerable <KeyMapping> maps = MappingsManager.ClearedMappings; foreach (KeyMapping map in maps) { // Has this cleared key been remapped (in which case we ignore it) bool remapped = false; foreach (KeyMapping currentmap in MappingsManager.GetMappings(MappingFilter.Current)) { if (currentmap.From == map.From) { remapped = true; break; } } if (remapped) { continue; } if (MappingsManager.IsDisabledMapping(map)) { if (!this._pendingenabled) { this._pendingenabled = true; this._buttonCount++; } } else { if (!this._pendingunmapped) { this._pendingunmapped = true; this._buttonCount++; } } } }