public void Set(VirtualKeyCode key, KeyState keyState)
{
if(_modifierKeyState.ContainsKey(key))
_modifierKeyState[key] = keyState;
else
_modifierKeyState.Add(key, keyState);
}
public KeyEvent Init(KeyEventArg arg, KeyState state)
{
this.arg = arg;
this.state = state;
return this;
}
void ApplyKey(int idx)
{
EffectKeyframe prevKey = (_curKey >= 0) ? Keyframes[_curKey] : null;
EffectKeyframe key = Keyframes[idx];
float transitionTime = (prevKey != null) ? SpeedScale*prevKey.BlendTime : 0.0f;
//looping around, pop to first frame if configured for that
if ((prevKey != null) && (idx == 0) && !BlendWhenLooping)
transitionTime = 0.0f;
for (int i = 0; i < key.LightKeys.Length; i++)
{
LightState curState = key.LightKeys[i];
HueMessenger.Instance.SetState(curState.LightIdx, curState.on, curState.fade, curState.color, transitionTime);
}
if (Mathf.Approximately(key.BlendTime, 0.0f))
_curState = KeyState.kHolding;
else
_curState = KeyState.kBlending;
_curKey = idx;
_curTransitionTime = transitionTime;
_timeStamp = Time.time;
}
private void SendKey(Win32APIImports.VirtualKeys key, KeyState keyState)
{
const uint KEYEVENTF_KEYUP = 0x0002;
var isExtended = false;
uint flags = 0;
if (keyState == KeyState.Up)
flags = KEYEVENTF_KEYUP;
if (key == Win32APIImports.VirtualKeys.RightMenu
|| key == Win32APIImports.VirtualKeys.RightControl
|| key == Win32APIImports.VirtualKeys.Insert
|| key == Win32APIImports.VirtualKeys.Delete
|| key == Win32APIImports.VirtualKeys.Home
|| key == Win32APIImports.VirtualKeys.End
|| key == Win32APIImports.VirtualKeys.Prior
|| key == Win32APIImports.VirtualKeys.Next
|| key == Win32APIImports.VirtualKeys.Up
|| key == Win32APIImports.VirtualKeys.Left
|| key == Win32APIImports.VirtualKeys.Down
|| key == Win32APIImports.VirtualKeys.Right
)
{
isExtended = true;
}
if (isExtended)
flags |= 1;
Win32APIImports.keybd_event((byte)key, Win32APIImports.MapVirtualKey((byte)key, 0), flags, UIntPtr.Zero);
}
private static KeyState GetKeyState(KeyState lastState, bool isKeyPressed, ref bool hasChanged)
{
switch (lastState)
{
case KeyState.Released:
if (isKeyPressed)
{
hasChanged = true;
}
return isKeyPressed ? KeyState.Pressing : KeyState.Released;
case KeyState.Pressing:
hasChanged = true;
return isKeyPressed ? KeyState.Pressed : KeyState.Releasing;
case KeyState.Pressed:
if (!isKeyPressed)
{
hasChanged = true;
}
return isKeyPressed ? KeyState.Pressed : KeyState.Releasing;
case KeyState.Releasing:
hasChanged = true;
return isKeyPressed ? KeyState.Pressing : KeyState.Released;
default:
throw new ArgumentOutOfRangeException(nameof(lastState), lastState, null);
}
}
public KeyboardCondition(string name, Keys key, Operator inputOperator, KeyState keystate)
{
Name = name;
Key = key;
Operator = inputOperator;
KeyState = keystate;
}
//Updating states (called from ControlsManager)
public void UpdateKeyState(Keys key, KeyState state)
{
if (key == Keys.None || KeyStates[key] == state && !_alwaysNotify) return;
KeyStates[key] = state;
_doNotify = true;
}
public void ExistsAsync_AnyKeyState_ReturnsExpectedResult(KeyState keyState, bool expectedResult)
{
// Arrange
var operationResult = new Mock<IOperationResult<ObserveState>>();
operationResult.SetupGet(m => m.Success).Returns(true);
operationResult.SetupGet(m => m.Status).Returns(ResponseStatus.Success);
operationResult.SetupGet(m => m.Value).Returns(new ObserveState()
{
KeyState = keyState
});
var mockRequestExecuter = new Mock<IRequestExecuter>();
mockRequestExecuter.Setup(m => m.SendWithRetryAsync(It.IsAny<Observe>(), null, null)).Returns(Task.FromResult(operationResult.Object));
// Act
bool result;
using (var bucket = new CouchbaseBucket(mockRequestExecuter.Object, new DefaultConverter(), new DefaultTranscoder()))
{
result = bucket.ExistsAsync("key").Result;
}
// Assert
Assert.AreEqual(expectedResult, result);
}
public KeyBinding(InputEvents source, Keys binding, KeyEventHandler target, KeyState type = KeyState.Up)
{
this.source = source;
this._binding = binding;
this._target = target;
this._type = type;
this.IsRegistered = false;
}
/// <summary>
/// Initializes a new instance of the <see cref="T:SharpDX.RawInput.KeyboardInputEventArgs"/> class.
///
/// </summary>
/// <param name="rawInput">The raw input.</param>
internal MyKeyboardInputArgs(ref RawInput rawInput)
{
Device = rawInput.Header.Device;
Key = (Keys)rawInput.Data.Keyboard.VKey;
MakeCode = (int)rawInput.Data.Keyboard.MakeCode;
ScanCodeFlags = rawInput.Data.Keyboard.Flags;
State = rawInput.Data.Keyboard.Message;
ExtraInformation = rawInput.Data.Keyboard.ExtraInformation;
}
/// <summary>
/// Raises the KeyboardLockDownKeyPressed event by invoking each subscribed delegate asynchronously.
/// </summary>
/// <param name="pressedKeys">The keys that are pressed.</param>
/// <param name="state">The state of the keys.</param>
static void OnLockedDownKeyboardKeyPressed(KeysEx pressedKeys, KeyState state)
{
foreach (EventHandler<KeyboardLockDownKeyPressedEventArgs> pressedEvent in LockedDownKeyboardKeyPressed.GetInvocationList())
{
var args = new KeyboardLockDownKeyPressedEventArgs(pressedKeys, state);
AsyncCallback callback = ar => ((EventHandler<KeyboardLockDownKeyPressedEventArgs>)ar.AsyncState).EndInvoke(ar);
pressedEvent.BeginInvoke(null, args, callback, pressedEvent);
}
}
public void DlsReceivingReturnSync()
{
InstallTypeShouldBe(InstallType.Dls);
KeyTypeShouldBe(KeyType.Standard | KeyType.MBR);
KeyStateShouldBe(KeyType.Standard, KeyState.NotifiedBound, KeyState.ActivationEnabled, KeyState.ActivationDenied);
KeyStateShouldBe(KeyType.MBR, KeyState.ActivationEnabled);
KeyStateWrapper = KeyState.Returned;
}
public void DlsRecieveSync(KeyState keyState)
{
InstallTypeShouldBe(InstallType.Dls);
KeyTypeShouldBe(KeyType.All);
KeyStateShouldBe(KeyType.Standard, KeyState.NotifiedBound, KeyState.ActivationEnabled, KeyState.ActivationDenied);
KeyStateShouldBe(KeyType.MBR, KeyState.Fulfilled, KeyState.ActivationEnabled);
KeyStateShouldBe(KeyType.MAT, KeyState.Fulfilled);
KeyStateWrapper = keyState;
}
private bool IsOneOfKeysState(KeyState s, KeyCode[] keys)
{
if (state == s)
{
for (int i = 0; i < keys.Length; ++i)
{
if (keys[i] == arg.key)
return true;
}
}
return false;
}
public KeyManager()
{
m_pActions = new Dictionary<KeyState, string>();
bool b = File.Exists(g_pPath);
if (b)
{
string[] g = File.ReadAllLines(g_pPath);
foreach (string c in g)
{
string s = c.Replace(" ", "");
if (s == null || s.Length == 0 || s.StartsWith("//"))
continue;
string[] p = s.Replace(":", "").Replace("]", "").Split('[', '=');
KeyState k = new KeyState();
k.m_bAlt = k.m_bCtrl = k.m_bShift = false;
if (p.Length == 3)
{
string[] p2 = p[1].ToLower().Split(',');
if (p2.Length != 3)
throw new Exception();
p = new string[] { p[0], p[2]};//use offset
k.m_bCtrl = p2[0] == "d" ? true : false;
k.m_bShift = p2[1] == "d" ? true : false;
k.m_bAlt = p2[2] == "d" ? true : false;
}
else if (p.Length != 2)
throw new Exception();
p[0] = p[0].Replace("System.Windows.Forms.Keys.", "");
k.m_eKeys = (Keys)Enum.Parse(typeof(Keys), p[0]);
m_pActions.Add(k, p[1]);
}
}
else
{
string[] g = new string[]
{
"//Keys := Action, have a look at msdn (System.Windows.Forms.Keys) for possible keys",
"//Use [Control, Shift, Alt] to specify specific states, where 'D' indicates 'Pressed' and 'U' indictes 'Up'",
"//For example G [D, U, D] := RandomAction",
"//Use whitespace as needed, it will be ignored, all actions start with a tag, UI specifies that the action performs UI actions",
"//SEL states that a selection is performed and MOD that lrent modifying happens. These tags are only for the sake of readability",
"",
"//Start of declerations",
"I := UI_Open_Inventory",
"A [D, U, U] := SEL_All",
};
File.WriteAllLines(g_pPath, g);
}
}
void OnTriggerEnter(Collider other) {
//If the player picked up this key, update the state to reflect it
if (state == KeyState.notPickedUp && other.gameObject.tag == "Player") {
state = KeyState.onPlayer;
other.gameObject.GetComponent<PlayerMovement>().keyOnPlayer = this;
SoundManager.myInstance.Play("Key_Get");
//Tutorial key goes straight to the lock
if (name == "TutorialKey") {
state = KeyState.inLobby;
}
return;
}
}
public void Process(PreviewKeyDownEventArgs a_Args, Form1 a_Window)
{
KeyState k = new KeyState();
k.m_bCtrl = a_Args.Control;
k.m_bShift = a_Args.Shift;
k.m_bAlt = a_Args.Alt;
k.m_eKeys = a_Args.KeyCode;
if (m_pActions.ContainsKey(k))
{
string s = m_pActions[k];
System.Reflection.MethodInfo m = a_Window.GetType().GetMethod(s, System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
if(m != null)
m.Invoke(a_Window, null);
GameLibrary.SystemLog.Append(GameLibrary.LogImportance.Information, "Action performed : " + s);
}
}
/// <summary>
/// Create an input condition which checks whether a certain key is in a certain key state.
/// HACK: For now the dispatcher of the application is used because an exception is thrown otherwise.
/// </summary>
/// <param name = "key">The key you want to check.</param>
/// <param name = "keyState">The key state on which the condition should validate to true.</param>
public KeyInputCondition( Key key, KeyState keyState )
: this(
() =>
{
bool down = false;
Application app = Application.Current;
if ( app != null )
{
down = app.Dispatcher.CheckAccess()
? Keyboard.IsKeyDown( key )
: (bool)app.Dispatcher.Invoke( new Func<bool>( () => Keyboard.IsKeyDown( key ) ) );
}
return down;
},
keyState
) {}
private void OnTriggerEnter(Collider body)
{
if (body.tag == "Player")
{
var handScript = body.GetComponent<PlayerScript>();
/*
* Check if the item holster already has an item attached.
*/
if (handScript.itemHolster.childCount == 0)
{
transform.parent = handScript.itemHolster;
transform.localPosition = Vector3.zero;
transform.localRotation = Quaternion.Euler(new Vector3(7.5f, 174, 0));
handle.transform.localRotation = Quaternion.identity;
_currentState = KeyState.PickedUp;
}
}
}
public void Update(float timeSinceLastUpdate, bool isDown)
{
switch (keyState)
{
case KeyState.JustPressed:
if (isDown)
{
keyState = KeyState.Pressed;
timeInState = timeSinceLastUpdate;
}
else
{
keyState = KeyState.JustReleased;
timeInState = 0;
}
break;
case KeyState.Pressed:
if (isDown)
timeInState += timeSinceLastUpdate;
else
keyState = KeyState.JustReleased;
break;
case KeyState.JustReleased:
if (isDown)
{
keyState = KeyState.JustPressed;
timeInState = 0;
}
else
{
keyState = KeyState.Released;
timeInState += timeSinceLastUpdate;
}
break;
case KeyState.Released:
if (isDown)
keyState = KeyState.JustPressed;
else
timeInState += timeSinceLastUpdate;
break;
}
}
public KeyboardHookEventArgs(uint keyCode,
uint scanCode,
uint flags,
uint time,
IntPtr extraInfo,
KeyState state,
bool getModifiers = true)
{
this.KeyCode = keyCode;
this.State = state;
this.ScanCode = scanCode;
this.Flags = flags;
this.Time = time;
this.ExtraInfo = extraInfo;
if (getModifiers)
{
this.GetModifers();
}
this.CapsOn = GetAsyncKeyState((int)Keys.CapsLock) != 0;
}
public bool ReceiveInput (string Key, KeyState State)
{
if (State == KeyState.KeyHeld)
{
if (Input.GetKey(Key))
{
return true;
}
else
{
return false;
}
}
else if (State == KeyState.KeyDown)
{
if (Input.GetKeyDown(Key))
{
return true;
}
else
{
return false;
}
}
else if (State == KeyState.KeyUp)
{
if (Input.GetKeyUp(Key))
{
return true;
}
else
{
return false;
}
}
else
{
return false;
}
}
public void Update(KeyboardState keyBoardState, GameTime gameTime)
{
bool pressed = keyBoardState.IsKeyDown(key);
if (keyState == KeyState.Up && pressed)
{
if(KeyFirstPressed != null)
KeyFirstPressed(key, gameTime);
}
else if (keyState == KeyState.Down && pressed)
{
if (KeyPressed != null)
KeyPressed(key, gameTime);
}
else if (keyState == KeyState.Down && !pressed)
{
if (KeyReleased != null)
KeyReleased(key, gameTime);
}
keyState = pressed ? KeyState.Down : KeyState.Up;
}
// Update is called once per frame
void FixedUpdate()
{
if(!enabled)
return;
grounded = Grounded();
CaptureKeyState();
MoveControl();
if(grounded)
{
if(shouldJump)
{
jumpSound.Play();
shouldJump = false;
rigidbody.AddForce(jumpPower * transform.up, forcemode);
}
}
mOldKeyState = mKeyState;
}
// Will be invoked when oa tool run 'oa3tool.exe /report' in command line.
public bool OaToolReportKey(KeyInfo key, KeyState keyState, string hardwareId, OemOptionalInfo oemOptionalInfo, string trackingInfo)
{
bool isFailed = false;
if (keyState != KeyState.Bound && keyState != KeyState.Returned)
throw new NotSupportedException(string.Format("oa3tool.exe to {0} is not supported", keyState));
try
{
bool isBound = keyState == KeyState.Bound;
key.FactoryFloorBoundKey(isBound);
if (isBound)
keyRepository.UpdateKey(key, null, null, hardwareId, oemOptionalInfo, trackingInfo, true);
else
keyRepository.UpdateKey(key, null, null, string.Empty, new OemOptionalInfo(), null, true);
}
catch (Exception ex)
{
ExceptionHandler.HandleException(ex);
isFailed = true;
}
return !isFailed;
}
public KeyboardEvent(Key key, KeyState state)
{
Key = key;
State = state;
}
public bool ProcessHookMessage(ref Message m)
{
try
{
ushort virtualKeyCode = (ushort)m.WParam;
Keys key = (Keys)virtualKeyCode;
if (key == Keys.Packet)
{
return(false);
}
KeyState state = (KeyState)(((long)m.LParam & 0x80000000) > 0 ? 0 : 1);
DecisionRecord record = GetRecord(virtualKeyCode, state);
if (record == null && Timeouts < MaxTimeouts)
{
bool reported = false;
int currentTime = Environment.TickCount, startTime = Environment.TickCount;
while (record == null)
{
bool peeked = false;
NativeMessage rawMessage;
while (!(peeked = Win32.PeekMessage(out rawMessage, Handle, Win32.WM_INPUT, Win32.WM_INPUT, PM_REMOVE)))
{
currentTime = Environment.TickCount;
if (!reported && GetTickCountDifference(startTime, currentTime) > 0)
{
Console.WriteLine($"UNRECORDED INPUT {key} {state}");
reported = true;
}
if (GetTickCountDifference(startTime, currentTime) > MaxWaitingTime)
{
Console.WriteLine($"IDLE FOR RAW INPUT TIMED OUT {key} {state}");
Timeouts++;
break;
}
}
if (!peeked)
{
break;
}
if (!reported && GetTickCountDifference(startTime, currentTime) > 0)
{
Console.WriteLine($"UNRECORDED INPUT {key} {state}");
reported = true;
}
if (rawMessage.msg == Win32.WM_INPUT)
{
ProcessRawInput(rawMessage.lParam);
record = GetRecord(virtualKeyCode, state);
}
else
{
return(false);
}
}
if (reported && record != null)
{
Console.WriteLine($"IDLE FOR RAW INPUT SUCCESSFUL, WAITED FOR {(currentTime < startTime ? uint.MaxValue - startTime + currentTime : currentTime - startTime)}ms - {key} {state}");
}
}
if (record != null)
{
Timeouts = 0;
}
Console.WriteLine($"Hook: {key} {state}");
bool block = (record?.Decision).GetValueOrDefault();
m.Result = (IntPtr)(block ? 1 : 0);
if (block)
{
Console.WriteLine($"Key press: {key} {state} is being blocked!");
}
return(true);
}
catch (Exception e)
{
Console.WriteLine(e);
}
return(false);
}
/// <summary>
/// Registers a callback which got called if one of the given keys changed their state to the specific one.
/// </summary>
/// <param name="keys">The keys which has to be watched for.</param>
/// <param name="state">The key state which has to be watched for.</param>
/// <param name="callback">The callback to be called.</param>
/// <returns>A token which represends the current callback to be used for <see cref="DW.WPFToolkit.Helpers.KeyboardWatcher.RemoveCallback" />.</returns>
public KeyboardWatchToken AddCallback(IEnumerable <Key> keys, KeyState state, Action <KeyStateChangedArgs> callback)
{
return(AddCallback(keys, new[] { state }, callback));
}
/// <summary>
/// Is the key currently pressed?
/// </summary>
/// <param name="keyState">The KeyState to check.</param>
/// <returns></returns>
public static bool IsPressed(this KeyState keyState)
{
return((keyState == KeyState.Pressed) || (keyState == KeyState.Pressing));
}
public static bool SendKeyboardAction(byte key, KeyState state)
{
return(keybd_event(key, 0, (uint)state, (UIntPtr)0));
}
public static bool TryGetMouseData(IntPtr wParam, IntPtr lParam, out VirtualKeyCode key, out KeyState state)
{
var msg = (WindowsMessage)(uint)wParam.ToInt32();
int mouseData = 0;
switch (msg)
{
case WindowsMessage.Lbuttondblclk:
case WindowsMessage.Nclbuttondblclk:
case WindowsMessage.Lbuttondown:
case WindowsMessage.Nclbuttondown:
key = VirtualKeyCode.Lbutton;
state = KeyState.Down;
return(true);
case WindowsMessage.Lbuttonup:
case WindowsMessage.Nclbuttonup:
key = VirtualKeyCode.Lbutton;
state = KeyState.Up;
return(true);
case WindowsMessage.Mbuttondown:
case WindowsMessage.Ncmbuttondown:
case WindowsMessage.Mbuttondblclk:
case WindowsMessage.Ncmbuttondblclk:
key = VirtualKeyCode.Mbutton;
state = KeyState.Down;
return(true);
case WindowsMessage.Mbuttonup:
case WindowsMessage.Ncmbuttonup:
key = VirtualKeyCode.Mbutton;
state = KeyState.Up;
return(true);
case WindowsMessage.Rbuttondblclk:
case WindowsMessage.Ncrbuttondblclk:
case WindowsMessage.Rbuttondown:
case WindowsMessage.Ncrbuttondown:
key = VirtualKeyCode.Rbutton;
state = KeyState.Down;
return(true);
case WindowsMessage.Rbuttonup:
case WindowsMessage.Ncrbuttonup:
key = VirtualKeyCode.Rbutton;
state = KeyState.Up;
return(true);
case WindowsMessage.Xbuttondblclk:
case WindowsMessage.Ncxbuttondblclk:
case WindowsMessage.Xbuttondown:
case WindowsMessage.Ncxbuttondown:
mouseData = Marshal.ReadInt32(lParam, 8);
if (HIWORD(mouseData) == 0x1)
{
key = VirtualKeyCode.Xbutton1;
state = KeyState.Down;
}
else
{
key = VirtualKeyCode.Xbutton2;
state = KeyState.Down;
}
return(true);
case WindowsMessage.Xbuttonup:
case WindowsMessage.Ncxbuttonup:
mouseData = Marshal.ReadInt32(lParam, 8);
if (HIWORD(mouseData) == 0x1)
{
key = VirtualKeyCode.Xbutton1;
state = KeyState.Up;
}
else
{
key = VirtualKeyCode.Xbutton2;
state = KeyState.Up;
}
return(true);
case WindowsMessage.Mousewheel:
case WindowsMessage.Mousehwheel:
key = VirtualKeyCode.Scroll;
state = KeyState.Pressed;
return(true);
case WindowsMessage.Mousemove:
case WindowsMessage.Ncmousemove:
key = VirtualKeyCode.Invalid;
state = KeyState.Pressed;
return(true);
default:
key = VirtualKeyCode.Invalid;
state = KeyState.None;
return(false);
}
}
public HdPubKey GenerateNewKey(string label, KeyState keyState, bool isInternal, bool toFile = true)
{
// BIP44-ish derivation scheme
// m / purpose' / coin_type' / account' / change / address_index
var change = isInternal ? 1 : 0;
lock (HdPubKeysLock)
{
IEnumerable <HdPubKey> relevantHdPubKeys;
if (isInternal)
{
relevantHdPubKeys = HdPubKeys.Where(x => x.IsInternal);
}
else
{
relevantHdPubKeys = HdPubKeys.Where(x => !x.IsInternal);
}
KeyPath path;
if (!relevantHdPubKeys.Any())
{
path = new KeyPath($"{change}/0");
}
else
{
int largestIndex = relevantHdPubKeys.Max(x => x.Index);
List <int> missingIndexes = Enumerable.Range(0, largestIndex).Except(relevantHdPubKeys.Select(x => x.Index)).ToList();
if (missingIndexes.Any())
{
int smallestMissingIndex = missingIndexes.Min();
path = relevantHdPubKeys.First(x => x.Index == (smallestMissingIndex - 1)).NonHardenedKeyPath.Increment();
}
else
{
path = relevantHdPubKeys.First(x => x.Index == largestIndex).NonHardenedKeyPath.Increment();
}
}
var fullPath = AccountKeyPath.Derive(path);
var pubKey = ExtPubKey.Derive(path).PubKey;
var hdPubKey = new HdPubKey(pubKey, fullPath, label, keyState);
HdPubKeys.Add(hdPubKey);
lock (HdPubKeyScriptBytesLock)
{
HdPubKeyScriptBytes.Add(hdPubKey.P2wpkhScript.ToCompressedBytes());
}
lock (ScriptHdPubkeyMapLock)
{
ScriptHdPubkeyMap.Add(hdPubKey.P2wpkhScript, hdPubKey);
}
if (toFile)
{
ToFile();
}
return(hdPubKey);
}
}
public void PressKey(Keys key) => KeyStatePool[(int)key] = new KeyState
{
IsPressed = true, KeyDownFirstChance = true
};
public override Level determination(KeyState keyState, int track, float audioTime)
{
return(Level.MISS);
}
public ExtraKeyState(KeyState k)
{
KeyState = k;
}
public KeyEventArgs(Keys key, KeyState eventType)
{
Key = key;
EventType = eventType;
}
public override void Input()
{
_keyboardOld = _keyboard;
_keyboard = Keyboard.GetState();
String inputString = "";
foreach (Keys key in _keyboard.GetPressedKeys())
{
inputString = "";
if (_keyboardOld.IsKeyUp(key))
{
if (key >= Keys.D0 && key <= Keys.Z)
{
inputString = ((char)key).ToString();
}
switch (key) //Switch for other keys without shift
{
case Keys.Back:
{
if (this.Text.Length > 0 && _cursor > 0)
{
this.Text = this.Text.Remove(_cursor - 1, 1);
_cursor -= 1;
if (_cursor < 0)
{
_cursor = 0;
}
}
}
break;
case Keys.Enter:
{
_inputFinished = this.Text != "";
}
break;
case Keys.NumPad0: inputString = "0"; break;
case Keys.NumPad1: inputString = "1"; break;
case Keys.NumPad2: inputString = "2"; break;
case Keys.NumPad3: inputString = "3"; break;
case Keys.NumPad4: inputString = "4"; break;
case Keys.NumPad5: inputString = "5"; break;
case Keys.NumPad6: inputString = "6"; break;
case Keys.NumPad7: inputString = "7"; break;
case Keys.NumPad8: inputString = "8"; break;
case Keys.NumPad9: inputString = "9"; break;
case Keys.Subtract: inputString = "-"; break;
case Keys.Add: inputString = "+"; break;
case Keys.Multiply: inputString = "*"; break;
case Keys.Divide: inputString = "/"; break;
case Keys.OemPeriod: inputString = "."; break;
case Keys.OemComma: inputString = ","; break;
case Keys.OemMinus: inputString = "-"; break;
case Keys.OemPlus: inputString = "+"; break;
case Keys.OemQuestion: inputString = "#"; break;
case Keys.OemBackslash: inputString = "<"; break;
case Keys.Space: inputString = " "; break;
case Keys.OemOpenBrackets: inputString = "\\"; break;
case Keys.Left: _cursor -= 1;
if (_cursor < 0)
{
_cursor = 0;
}
break;
case Keys.Right: _cursor += 1;
if (_cursor > this.Text.Length)
{
_cursor = this.Text.Length;
}
break;
}
if (_keyboard.IsKeyDown(Keys.CapsLock))
{
currentKeyState = currentKeyState == KeyState.CapslockPressed ? KeyState.Idle : KeyState.CapslockPressed;
}
if (currentKeyState != KeyState.CapslockPressed)
{
if (_keyboard.IsKeyDown(Keys.RightShift) ||
_keyboard.IsKeyDown(Keys.LeftShift))
{
currentKeyState = KeyState.ShiftPressed;
}
else
{
currentKeyState = KeyState.Idle;
}
}
if (currentKeyState == KeyState.ShiftPressed || currentKeyState == KeyState.CapslockPressed)
{
if (key >= Keys.A && key <= Keys.Z)
{
inputString = inputString.ToUpper();
}
else
{
switch (inputString) //Switch for other keys with shift
{
case "0": inputString = "="; break;
case "1": inputString = "!"; break;
case "2": inputString = "\""; break;
case "3": inputString = "§"; break;
case "4": inputString = "$"; break;
case "5": inputString = "%"; break;
case "6": inputString = "&"; break;
case "7": inputString = "/"; break;
case "8": inputString = "("; break;
case "9": inputString = ")"; break;
case ".": inputString = ":"; break;
case ",": inputString = ";"; break;
case "-": inputString = "_"; break;
case "+": inputString = "*"; break;
case "#": inputString = "\'"; break;
case "<": inputString = ">"; break;
case "\\": inputString = "?"; break;
}
}
}
else
{
inputString = inputString.ToLower();
}
if (this.Text.Length > 0 && this.Text.Length != _cursor)
{
this.Text = this.Text.Substring(0, _cursor) + inputString + this.Text.Substring(_cursor, this.Text.Length - (_cursor));
}
else
{
this.Text += inputString;
}
if (inputString != "")
{
_cursor += 1;
}
}
}
if (this.Text.Length > 0 && this.Text.Length != _cursor)
{
this.Text = this.Text.Substring(0, _cursor) + "_" + this.Text.Substring(_cursor, this.Text.Length - (_cursor));
}
}
public KeyEventArgs(Keys keyCode, KeyState oldState, KeyState newState)
{
KeyCode = keyCode;
OldState = oldState;
NewState = newState;
}
protected override bool processKey(KeyState Key)
{
if (Key.Pressed && Key.IsUnmodified)
{
Invalidate();
switch (Key.Key)
{
case KeyCode.B:
if (Storage.SaveTapeIfRequired(Computer))
{
Computer.TapeLoadBlank();
Settings.LastTapeFile = Computer.TapeFilePath;
MessageCallback("Blank Tape Loaded");
}
break;
case KeyCode.E:
if (Storage.SaveTapeIfRequired(Computer))
{
Computer.TapeEject();
MessageCallback("Tape Ejected");
}
break;
case KeyCode.L:
if (Storage.SaveTapeIfRequired(Computer))
{
Load();
}
break;
case KeyCode.P:
Computer.TapePlay();
MessageCallback("Playing Tape");
break;
case KeyCode.S:
Computer.TapeStop();
MessageCallback("Tape Stopped");
break;
case KeyCode.R:
Computer.TapeRecord();
switch (Computer.TapeStatus)
{
case TRS80.TapeStatus.WriteEngaged:
MessageCallback("Waiting to Record");
break;
case TRS80.TapeStatus.Writing:
MessageCallback("Recording");
break;
}
break;
case KeyCode.W:
Computer.TapeRewind();
MessageCallback("Tape Rewound");
break;
case KeyCode.X:
Computer.TapeUserSelectedSpeed = Computer.TapeUserSelectedSpeed == TRS80.Baud.High ? TRS80.Baud.Low : TRS80.Baud.High;
break;
case KeyCode.F8:
if (!Computer.IsRunning)
{
CurrentMode = ViewMode.Normal;
}
return(base.processKey(Key));
default:
return(base.processKey(Key));
}
return(true);
}
else
{
return(base.processKey(Key));
}
}
private static void InputManager_OnMouseEvent(VirtualKeyCode key, KeyState state, int x, int y)
{
}
public void ReleaseKey(Keys key) => KeyStatePool[(int)key] = new KeyState
{
IsPressed = false
};
public KeyEntry(KeyEventArg arg, KeyState state)
{
this.arg = arg;
this.state = state;
}
public static bool SendKeyboardAction(Keys key, KeyState state)
{
return(SendKeyboardAction((byte)key.GetHashCode(), state));
}
public void ResetSpace() => State &= ~KeyState.Space;
public KeyInfo(KeyState keyState)
: this()
{
KeyState = keyState;
}
/// <summary>
/// Initializes a new instance of the <see cref="DW.WPFToolkit.Helpers.KeyStateChangedArgs" /> class.
/// </summary>
/// <param name="key">The key which state has been changed.</param>
/// <param name="state">The actual state of the key.</param>
public KeyStateChangedArgs(Key key, KeyState state)
{
Key = key;
State = state;
}
/// <summary>
/// Registers a callback which got called if the specific key changed its state to the given one.
/// </summary>
/// <param name="key">The key which has to be watched for.</param>
/// <param name="state">The key state which has to be watched for.</param>
/// <param name="callback">The callback to be called.</param>
/// <returns>A token which represends the current callback to be used for <see cref="DW.WPFToolkit.Helpers.KeyboardWatcher.RemoveCallback" />.</returns>
public KeyboardWatchToken AddCallback(Key key, KeyState state, Action <KeyStateChangedArgs> callback)
{
return(AddCallback(new[] { key }, new[] { state }, callback));
}
private void PopulateSeleneseMethods()
{
KeyState keyState = new KeyState();
WindowSelector windows = new WindowSelector(this.driver);
// Note the we use the names used by the CommandProcessor
this.seleneseMethods.Add("addLocationStrategy", new AddLocationStrategy(this.elementFinder));
this.seleneseMethods.Add("addSelection", new AddSelection(this.elementFinder));
this.seleneseMethods.Add("altKeyDown", new AltKeyDown(keyState));
this.seleneseMethods.Add("altKeyUp", new AltKeyUp(keyState));
this.seleneseMethods.Add("assignId", new AssignId(this.elementFinder));
this.seleneseMethods.Add("attachFile", new AttachFile(this.elementFinder));
this.seleneseMethods.Add("captureScreenshotToString", new CaptureScreenshotToString());
this.seleneseMethods.Add("click", new Click(this.alertOverride, this.elementFinder));
this.seleneseMethods.Add("clickAt", new ClickAt(this.alertOverride, this.elementFinder));
this.seleneseMethods.Add("check", new Check(this.alertOverride, this.elementFinder));
this.seleneseMethods.Add("chooseCancelOnNextConfirmation", new SetNextConfirmationState(false));
this.seleneseMethods.Add("chooseOkOnNextConfirmation", new SetNextConfirmationState(true));
this.seleneseMethods.Add("close", new Close());
this.seleneseMethods.Add("createCookie", new CreateCookie());
this.seleneseMethods.Add("controlKeyDown", new ControlKeyDown(keyState));
this.seleneseMethods.Add("controlKeyUp", new ControlKeyUp(keyState));
this.seleneseMethods.Add("deleteAllVisibleCookies", new DeleteAllVisibleCookies());
this.seleneseMethods.Add("deleteCookie", new DeleteCookie());
this.seleneseMethods.Add("doubleClick", new DoubleClick(this.elementFinder));
this.seleneseMethods.Add("dragdrop", new DragAndDrop(this.elementFinder));
this.seleneseMethods.Add("dragAndDrop", new DragAndDrop(this.elementFinder));
this.seleneseMethods.Add("dragAndDropToObject", new DragAndDropToObject(this.elementFinder));
this.seleneseMethods.Add("fireEvent", new FireEvent(this.elementFinder));
this.seleneseMethods.Add("focus", new FireNamedEvent(this.elementFinder, "focus"));
this.seleneseMethods.Add("getAlert", new GetAlert(this.alertOverride));
this.seleneseMethods.Add("getAllButtons", new GetAllButtons());
this.seleneseMethods.Add("getAllFields", new GetAllFields());
this.seleneseMethods.Add("getAllLinks", new GetAllLinks());
this.seleneseMethods.Add("getAllWindowTitles", new GetAllWindowTitles());
this.seleneseMethods.Add("getAttribute", new GetAttribute(this.elementFinder));
this.seleneseMethods.Add("getAttributeFromAllWindows", new GetAttributeFromAllWindows());
this.seleneseMethods.Add("getBodyText", new GetBodyText());
this.seleneseMethods.Add("getConfirmation", new GetConfirmation(this.alertOverride));
this.seleneseMethods.Add("getCookie", new GetCookie());
this.seleneseMethods.Add("getCookieByName", new GetCookieByName());
this.seleneseMethods.Add("getElementHeight", new GetElementHeight(this.elementFinder));
this.seleneseMethods.Add("getElementIndex", new GetElementIndex(this.elementFinder));
this.seleneseMethods.Add("getElementPositionLeft", new GetElementPositionLeft(this.elementFinder));
this.seleneseMethods.Add("getElementPositionTop", new GetElementPositionTop(this.elementFinder));
this.seleneseMethods.Add("getElementWidth", new GetElementWidth(this.elementFinder));
this.seleneseMethods.Add("getEval", new GetEval(this.mutator));
this.seleneseMethods.Add("getHtmlSource", new GetHtmlSource());
this.seleneseMethods.Add("getLocation", new GetLocation());
this.seleneseMethods.Add("getSelectedId", new FindFirstSelectedOptionProperty(this.elementFinder, "id"));
this.seleneseMethods.Add("getSelectedIds", new FindSelectedOptionProperties(this.elementFinder, "id"));
this.seleneseMethods.Add("getSelectedIndex", new FindFirstSelectedOptionProperty(this.elementFinder, "index"));
this.seleneseMethods.Add("getSelectedIndexes", new FindSelectedOptionProperties(this.elementFinder, "index"));
this.seleneseMethods.Add("getSelectedLabel", new FindFirstSelectedOptionProperty(this.elementFinder, "text"));
this.seleneseMethods.Add("getSelectedLabels", new FindSelectedOptionProperties(this.elementFinder, "text"));
this.seleneseMethods.Add("getSelectedValue", new FindFirstSelectedOptionProperty(this.elementFinder, "value"));
this.seleneseMethods.Add("getSelectedValues", new FindSelectedOptionProperties(this.elementFinder, "value"));
this.seleneseMethods.Add("getSelectOptions", new GetSelectOptions(this.elementFinder));
this.seleneseMethods.Add("getSpeed", new NoOp("0"));
this.seleneseMethods.Add("getTable", new GetTable(this.elementFinder));
this.seleneseMethods.Add("getText", new GetText(this.elementFinder));
this.seleneseMethods.Add("getTitle", new GetTitle());
this.seleneseMethods.Add("getValue", new GetValue(this.elementFinder));
this.seleneseMethods.Add("getXpathCount", new GetXpathCount());
this.seleneseMethods.Add("getCssCount", new GetCssCount());
this.seleneseMethods.Add("goBack", new GoBack());
this.seleneseMethods.Add("highlight", new Highlight(this.elementFinder));
this.seleneseMethods.Add("isAlertPresent", new IsAlertPresent(this.alertOverride));
this.seleneseMethods.Add("isChecked", new IsChecked(this.elementFinder));
this.seleneseMethods.Add("isConfirmationPresent", new IsConfirmationPresent(this.alertOverride));
this.seleneseMethods.Add("isCookiePresent", new IsCookiePresent());
this.seleneseMethods.Add("isEditable", new IsEditable(this.elementFinder));
this.seleneseMethods.Add("isElementPresent", new IsElementPresent(this.elementFinder));
this.seleneseMethods.Add("isOrdered", new IsOrdered(this.elementFinder));
this.seleneseMethods.Add("isSomethingSelected", new IsSomethingSelected());
this.seleneseMethods.Add("isTextPresent", new IsTextPresent());
this.seleneseMethods.Add("isVisible", new IsVisible(this.elementFinder));
this.seleneseMethods.Add("keyDown", new KeyEvent(this.elementFinder, keyState, "doKeyDown"));
this.seleneseMethods.Add("keyPress", new TypeKeys(this.alertOverride, this.elementFinder));
this.seleneseMethods.Add("keyUp", new KeyEvent(this.elementFinder, keyState, "doKeyUp"));
this.seleneseMethods.Add("metaKeyDown", new MetaKeyDown(keyState));
this.seleneseMethods.Add("metaKeyUp", new MetaKeyUp(keyState));
this.seleneseMethods.Add("mouseOver", new MouseEvent(this.elementFinder, "mouseover"));
this.seleneseMethods.Add("mouseOut", new MouseEvent(this.elementFinder, "mouseout"));
this.seleneseMethods.Add("mouseDown", new MouseEvent(this.elementFinder, "mousedown"));
this.seleneseMethods.Add("mouseDownAt", new MouseEventAt(this.elementFinder, "mousedown"));
this.seleneseMethods.Add("mouseMove", new MouseEvent(this.elementFinder, "mousemove"));
this.seleneseMethods.Add("mouseMoveAt", new MouseEventAt(this.elementFinder, "mousemove"));
this.seleneseMethods.Add("mouseUp", new MouseEvent(this.elementFinder, "mouseup"));
this.seleneseMethods.Add("mouseUpAt", new MouseEventAt(this.elementFinder, "mouseup"));
this.seleneseMethods.Add("open", new Open(this.baseUrl));
this.seleneseMethods.Add("openWindow", new OpenWindow(new GetEval(this.mutator)));
this.seleneseMethods.Add("refresh", new Refresh());
this.seleneseMethods.Add("removeAllSelections", new RemoveAllSelections(this.elementFinder));
this.seleneseMethods.Add("removeSelection", new RemoveSelection(this.elementFinder));
this.seleneseMethods.Add("runScript", new RunScript(this.mutator));
this.seleneseMethods.Add("select", new SelectOption(this.alertOverride, this.elementFinder));
this.seleneseMethods.Add("selectFrame", new SelectFrame(windows));
this.seleneseMethods.Add("selectWindow", new SelectWindow(windows));
this.seleneseMethods.Add("setBrowserLogLevel", new NoOp(null));
this.seleneseMethods.Add("setContext", new NoOp(null));
this.seleneseMethods.Add("setSpeed", new NoOp(null));
this.seleneseMethods.Add("setTimeout", new SetTimeout(this.timer));
this.seleneseMethods.Add("shiftKeyDown", new ShiftKeyDown(keyState));
this.seleneseMethods.Add("shiftKeyUp", new ShiftKeyUp(keyState));
this.seleneseMethods.Add("submit", new Submit(this.alertOverride, this.elementFinder));
this.seleneseMethods.Add("type", new Selenium.Internal.SeleniumEmulation.Type(this.alertOverride, this.elementFinder, keyState));
this.seleneseMethods.Add("typeKeys", new TypeKeys(this.alertOverride, this.elementFinder));
this.seleneseMethods.Add("uncheck", new Uncheck(this.elementFinder));
this.seleneseMethods.Add("useXpathLibrary", new NoOp(null));
this.seleneseMethods.Add("waitForCondition", new WaitForCondition(this.mutator));
this.seleneseMethods.Add("waitForFrameToLoad", new NoOp(null));
this.seleneseMethods.Add("waitForPageToLoad", new WaitForPageToLoad());
this.seleneseMethods.Add("waitForPopUp", new WaitForPopup(windows));
this.seleneseMethods.Add("windowFocus", new WindowFocus());
this.seleneseMethods.Add("windowMaximize", new WindowMaximize());
}
protected virtual void ProcessKeyEvent(char asciiChar, Key key, ScanCode scanCode, KeyState keyState, bool shiftPressed, bool ctrlPressed, bool altPressed)
{
var keyEvent = new KeyEvent(
ActiveApplicationMonitor.GetActiveApplicationName(),
asciiChar,
scanCode,
key,
keyState,
shiftPressed,
altPressed,
ctrlPressed,
DateTime.Now
);
switch (keyState)
{
case KeyState.Up:
FireKeyUpEvent(keyEvent);
break;
case KeyState.Down:
FireKeyDownEvent(keyEvent);
break;
}
FireKeyActivityEvent(keyEvent);
}
public KeyEntry(KeyEventArg arg, KeyState state)
{
this.arg = arg;
this.state = state;
}
/// <summary>
/// Convert can code into a key
/// </summary>
/// <param name="scancode">The scancode.</param>
/// <returns></returns>
public KeyEvent ConvertScanCode(byte scancode)
{
var key = new KeyEvent();
if (scancode == 0)
{
return(key);
}
if (keyState == KeyState.Normal)
{
if (scancode == 0xE0)
{
keyState = KeyState.Escaped;
return(key);
}
key.KeyPress = ((scancode & 0x80) != 0) ? KeyEvent.KeyPressType.Break : key.KeyPress = KeyEvent.KeyPressType.Make;
key.KeyType = KeyType.RegularKey;
switch (scancode)
{
case 1: key.Character = (char)27; break;
case 2: key.Character = '1'; break;
case 3: key.Character = '2'; break;
case 4: key.Character = '3'; break;
case 5: key.Character = '4'; break;
case 6: key.Character = '5'; break;
case 7: key.Character = '6'; break;
case 8: key.Character = '7'; break;
case 9: key.Character = '8'; break;
case 10: key.Character = '9'; break;
case 11: key.Character = '0'; break;
case 12: key.Character = '-'; break;
case 13: key.Character = '='; break;
case 14: key.Character = '\b'; break;
case 15: key.Character = '\t'; break;
case 16: key.Character = 'q'; break;
case 17: key.Character = 'w'; break;
case 18: key.Character = 'e'; break;
case 19: key.Character = 'r'; break;
case 20: key.Character = 't'; break;
case 21: key.Character = 'y'; break;
case 22: key.Character = 'u'; break;
case 23: key.Character = 'i'; break;
case 24: key.Character = 'o'; break;
case 25: key.Character = 'p'; break;
case 26: key.Character = '['; break;
case 27: key.Character = ']'; break;
case 28: key.Character = '\n'; break;
case 29: key.KeyType = KeyType.LeftControl; break;
case 30: key.Character = 'a'; break;
case 31: key.Character = 's'; break;
case 32: key.Character = 'd'; break;
case 33: key.Character = 'f'; break;
case 34: key.Character = 'g'; break;
case 35: key.Character = 'h'; break;
case 36: key.Character = 'j'; break;
case 37: key.Character = 'k'; break;
case 38: key.Character = 'l'; break;
case 39: key.Character = ';'; break;
case 40: key.Character = '\''; break;
case 41: key.Character = '`'; break;
case 42: key.KeyType = KeyType.LeftShift; break;
case 43: key.Character = '\\'; break;
case 44: key.Character = 'z'; break;
case 45: key.Character = 'x'; break;
case 46: key.Character = 'c'; break;
case 47: key.Character = 'v'; break;
case 48: key.Character = 'b'; break;
case 49: key.Character = 'n'; break;
case 50: key.Character = 'm'; break;
case 51: key.Character = ','; break;
case 52: key.Character = '.'; break;
case 53: key.Character = '/'; break;
case 54: key.KeyType = KeyType.RightShift; break;
case 55: key.Character = '*'; break;
case 56: key.KeyType = KeyType.LeftAlt; break;
case 57: key.Character = ' '; break;
case 58: key.KeyType = KeyType.CapsLock; break;
case 59: key.KeyType = KeyType.F1; break;
case 60: key.KeyType = KeyType.F2; break;
case 61: key.KeyType = KeyType.F3; break;
case 62: key.KeyType = KeyType.F4; break;
case 63: key.KeyType = KeyType.F5; break;
case 64: key.KeyType = KeyType.F6; break;
case 65: key.KeyType = KeyType.F7; break;
case 66: key.KeyType = KeyType.F8; break;
case 67: key.KeyType = KeyType.F9; break;
case 68: key.KeyType = KeyType.F10; break;
case 69: key.KeyType = KeyType.NumLock; break;
case 70: key.KeyType = KeyType.ScrollLock; break;
case 71: key.KeyType = KeyType.Home; break;
case 72: key.KeyType = KeyType.UpArrow; break;
case 73: key.KeyType = KeyType.PageUp; break;
case 74: key.Character = '-'; break;
case 75: key.KeyType = KeyType.LeftArrow; break;
case 76: key.Character = (char)0; break;
case 77: key.KeyType = KeyType.RightArrow; break;
case 78: key.Character = '+'; break;
case 79: key.KeyType = KeyType.End; break;
case 80: key.KeyType = KeyType.DownArrow; break;
case 81: key.KeyType = KeyType.PageDown; break;
case 82: key.KeyType = KeyType.Insert; break;
case 83: key.KeyType = KeyType.Delete; break;
case 86: key.Character = '\\'; break;
case 87: key.KeyType = KeyType.F11; break;
case 88: key.KeyType = KeyType.F12; break;
case 129: key.Character = (char)27; break;
case 130: key.Character = '!'; break;
case 131: key.Character = '@'; break;
case 132: key.Character = '#'; break;
case 133: key.Character = '$'; break;
case 134: key.Character = '%'; break;
case 135: key.Character = '^'; break;
case 136: key.Character = '&'; break;
case 137: key.Character = '*'; break;
case 138: key.Character = '('; break;
case 139: key.Character = ')'; break;
case 140: key.Character = '_'; break;
case 141: key.Character = '+'; break;
case 142: key.Character = '\b'; break;
case 143: key.Character = '\t'; break;
case 144: key.Character = 'Q'; break;
case 145: key.Character = 'W'; break;
case 146: key.Character = 'E'; break;
case 147: key.Character = 'R'; break;
case 148: key.Character = 'T'; break;
case 149: key.Character = 'Y'; break;
case 150: key.Character = 'U'; break;
case 151: key.Character = 'I'; break;
case 152: key.Character = 'O'; break;
case 153: key.Character = 'P'; break;
case 154: key.Character = '{'; break;
case 155: key.Character = '}'; break;
case 156: key.Character = '\n'; break;
case 157: key.KeyType = KeyType.RightControl; break;
case 158: key.Character = 'A'; break;
case 159: key.Character = 'S'; break;
case 160: key.Character = 'D'; break;
case 161: key.Character = 'F'; break;
case 162: key.Character = 'G'; break;
case 163: key.Character = 'H'; break;
case 164: key.Character = 'J'; break;
case 165: key.Character = 'K'; break;
case 166: key.Character = 'L'; break;
case 167: key.Character = ':'; break;
case 168: key.Character = '"'; break;
case 169: key.Character = '~'; break;
case 170: key.KeyType = KeyType.LeftShift; break;
case 171: key.Character = '|'; break;
case 172: key.Character = 'Z'; break;
case 173: key.Character = 'X'; break;
case 174: key.Character = 'C'; break;
case 175: key.Character = 'V'; break;
case 176: key.Character = 'B'; break;
case 177: key.Character = 'N'; break;
case 178: key.Character = 'M'; break;
case 179: key.Character = '<'; break;
case 180: key.Character = '>'; break;
case 181: key.Character = '?'; break;
case 182: key.KeyType = KeyType.RightShift; break;
case 183: key.Character = '*'; break;
case 184: key.KeyType = KeyType.RightAlt; break;
case 185: key.Character = ' '; break;
case 186: key.KeyType = KeyType.CapsLock; break;
case 187: key.KeyType = KeyType.F1; break;
case 188: key.KeyType = KeyType.F2; break;
case 189: key.KeyType = KeyType.F3; break;
case 190: key.KeyType = KeyType.F4; break;
case 191: key.KeyType = KeyType.F5; break;
case 192: key.KeyType = KeyType.F6; break;
case 193: key.KeyType = KeyType.F7; break;
case 194: key.KeyType = KeyType.F8; break;
case 195: key.KeyType = KeyType.F9; break;
case 196: key.KeyType = KeyType.F10; break;
case 197: key.KeyType = KeyType.NumLock; break;
case 198: key.KeyType = KeyType.ScrollLock; break;
case 199: key.KeyType = KeyType.Home; break;
case 200: key.KeyType = KeyType.UpArrow; break;
case 201: key.KeyType = KeyType.PageUp; break;
case 202: key.Character = '-'; break;
case 203: key.KeyType = KeyType.LeftArrow; break;
case 205: key.KeyType = KeyType.RightArrow; break;
case 206: key.Character = '+'; break;
case 207: key.KeyType = KeyType.End; break;
case 208: key.KeyType = KeyType.DownArrow; break;
case 209: key.KeyType = KeyType.PageDown; break;
case 210: key.KeyType = KeyType.Insert; break;
case 211: key.KeyType = KeyType.Delete; break;
case 214: key.Character = '|'; break;
case 215: key.KeyType = KeyType.F11; break;
case 216: key.KeyType = KeyType.F12; break;
default: break;
}
keyState = KeyState.Normal;
return(key);
}
else if ((keyState == KeyState.Escaped) || (keyState == KeyState.EscapeBreak))
{
if (scancode == 0xE0)
{
key.KeyType = KeyType.RegularKey;
key.KeyPress = (((scancode & 0x80) != 0) || (keyState == KeyState.EscapeBreak)) ? key.KeyPress = KeyEvent.KeyPressType.Break : key.KeyPress = KeyEvent.KeyPressType.Make;
if (scancode == 0xF0)
{
keyState = KeyState.EscapeBreak;
return(key);
}
switch (scancode)
{
case 0x1C: key.Character = '\n'; break;
case 0x1D: key.KeyType = KeyType.LeftControl; break;
case 0x2A: key.KeyType = KeyType.LeftShift; break;
case 0x35: key.Character = '/'; break;
case 0x36: key.KeyType = KeyType.RightShift; break;
case 0x37: key.KeyType = KeyType.ControlPrintScreen; break;
case 0x38: key.KeyType = KeyType.LeftAlt; break; // ?
case 0x46: key.KeyType = KeyType.ScrollLock; break;
case 0x47: key.KeyType = KeyType.Home; break;
case 0x48: key.KeyType = KeyType.UpArrow; break;
case 0x49: key.KeyType = KeyType.PageUp; break;
case 0x4B: key.KeyType = KeyType.LeftArrow; break;
case 0x4D: key.KeyType = KeyType.RightArrow; break;
case 0x4F: key.KeyType = KeyType.End; break;
case 0x50: key.KeyType = KeyType.DownArrow; break;
case 0x51: key.KeyType = KeyType.PageDown; break;
case 0x52: key.KeyType = KeyType.Insert; break;
case 0x53: key.KeyType = KeyType.Delete; break;
case 0x5B: key.KeyType = KeyType.LeftWindow; break;
case 0x5C: key.KeyType = KeyType.RightWindow; break;
case 0x5D: key.KeyType = KeyType.Menu; break;
//case 0x37: key.KeyType = Key.Special.Power; break;
//case 0x3F: key.KeyType = Key.Special.Sleep; break;
//case 0x5E: key.KeyType = Key.Special.Wake; break;
default: break;
}
keyState = KeyState.Normal;
return(key);
}
else if (keyState == KeyState.Espaced2)
{
keyState = KeyState.Normal;
return(key);
}
}
return(key);
}
IEnumerator EnterLockCoroutine() {
inEnterLockCoroutine = true;
//Find the appropriate lock in the game world
string targetLockName = "";
switch (gameObject.name) {
case "ACKey":
targetLockName = "ACLock";
break;
case "FutureKey":
targetLockName = "FutureLock";
break;
case "NatureKey":
targetLockName = "NatureLock";
break;
case "TutorialKey":
targetLockName = "TutorialLock";
break;
}
GameObject lockGO = GameObject.Find(targetLockName);
Vector3 lockPos = lockGO.transform.position + 0.5f*lockGO.transform.up;
Quaternion lockRot = Quaternion.Euler(lockGO.transform.rotation.eulerAngles + 90*Vector3.up);
Quaternion turnRot = Quaternion.Euler(lockRot.eulerAngles + 90*Vector3.right);
Vector3 startPos = transform.position;
Quaternion startRot = transform.rotation;
print(lockPos);
float t = 0;
while (state != KeyState.inLock) {
float percent = t / enterLockTime;
transform.position = Vector3.Lerp(startPos, lockPos, percent);
transform.rotation = Quaternion.Lerp(startRot, lockRot, percent);
if (t > enterLockTime) {
state = KeyState.inLock;
}
t += Time.deltaTime;
yield return 0;
}
yield return new WaitForSeconds(0.5f);
print("Turning key");
//plays the key turning sfx
SoundManager.myInstance.Play("Key_Unlock");
//Turn the key. Like Bob Segar. Wait, no that's Turn the Page. Disregard.
t = 0;
while (t < keyTurnTime) {
float percent = t / keyTurnTime;
transform.rotation = Quaternion.Lerp(lockRot, turnRot, percent);
t += Time.deltaTime;
yield return 0;
}
if (name != "TutorialKey") {
Lobby.S.numKeysInLock = Lobby.S.numKeysInLock + 1;
}
else {
TutorialRoom.S.UnlockLobbyDoor();
}
inEnterLockCoroutine = false;
}
/// <summary>
/// Creates a new instance.
/// </summary>
/// <param name="key">Key.</param>
/// <param name="modifiers">Key Modifiers.</param>
public KeyHook(Keys key,ModifierKeys modifiers,KeyState state)
{
this.Key = key;
this.Modifiers = modifiers;
this.State = state;
}
internal static Mock <IMetastore <JObject> > CreateMetastoreMock(
Partition partition,
KeyManagementService kms,
KeyState metaIK,
KeyState metaSK,
CryptoKeyHolder cryptoKeyHolder,
IMetastore <JObject> metastore)
{
CryptoKey systemKey = cryptoKeyHolder.SystemKey;
Mock <IMetastore <JObject> > metastoreSpy = new Mock <IMetastore <JObject> >();
metastoreSpy
.Setup(x => x.Load(It.IsAny <string>(), It.IsAny <DateTimeOffset>()))
.Returns <string, DateTimeOffset>(metastore.Load);
metastoreSpy
.Setup(x => x.LoadLatest(It.IsAny <string>()))
.Returns <string>(metastore.LoadLatest);
metastoreSpy
.Setup(x => x.Store(It.IsAny <string>(), It.IsAny <DateTimeOffset>(), It.IsAny <JObject>()))
.Returns <string, DateTimeOffset, JObject>(metastore.Store);
if (metaSK != KeyState.Empty)
{
if (metaSK == KeyState.Retired)
{
// We create a revoked copy of the same key
DateTimeOffset created = systemKey.GetCreated();
systemKey = systemKey
.WithKey(bytes => Crypto.GenerateKeyFromBytes(bytes, created, true));
}
EnvelopeKeyRecord systemKeyRecord = new EnvelopeKeyRecord(
systemKey.GetCreated(), null, kms.EncryptKey(systemKey), systemKey.IsRevoked());
metastore.Store(
partition.SystemKeyId,
systemKeyRecord.Created,
systemKeyRecord.ToJson());
}
if (metaIK != KeyState.Empty)
{
CryptoKey intermediateKey = cryptoKeyHolder.IntermediateKey;
if (metaIK == KeyState.Retired)
{
// We create a revoked copy of the same key
DateTimeOffset created = intermediateKey.GetCreated();
intermediateKey = intermediateKey
.WithKey(bytes => Crypto.GenerateKeyFromBytes(bytes, created, true));
}
EnvelopeKeyRecord intermediateKeyRecord = new EnvelopeKeyRecord(
intermediateKey.GetCreated(),
new KeyMeta(partition.SystemKeyId, systemKey.GetCreated()),
Crypto.EncryptKey(intermediateKey, systemKey),
intermediateKey.IsRevoked());
metastore.Store(
partition.IntermediateKeyId,
intermediateKeyRecord.Created,
intermediateKeyRecord.ToJson());
}
return(metastoreSpy);
}
public KeyboardData(int virtualCode, KeyStates keyState)
{
Key = new KeyboardCode(virtualCode);
State = new KeyState(keyState);
}
public void Update()
{
KeyState = Keyboard.GetState();
// Directional controls
// Horizontal
if (KeyState.IsKeyDown(Keys.Left))
{
Left = true;
Right = false;
}
else if (KeyState.IsKeyDown(Keys.Right))
{
Left = false;
Right = true;
}
if (KeyState.IsKeyUp(Keys.Left))
{
Left = false;
}
if (KeyState.IsKeyUp(Keys.Right))
{
Right = false;
}
// Vertical
if (KeyState.IsKeyDown(Keys.Up))
{
Up = true;
Down = false;
}
else if (KeyState.IsKeyDown(Keys.Down))
{
Up = false;
Down = true;
}
if (KeyState.IsKeyUp(Keys.Up))
{
Up = false;
}
if (KeyState.IsKeyUp(Keys.Down))
{
Down = false;
}
// Panning
// Vertical
if (KeyState.IsKeyDown(Keys.NumPad8))
{
PanU = true;
PanD = false;
}
else if (KeyState.IsKeyDown(Keys.NumPad2))
{
PanU = false;
PanD = true;
}
if (KeyState.IsKeyUp(Keys.NumPad8))
{
PanU = false;
}
if (KeyState.IsKeyUp(Keys.NumPad2))
{
PanD = false;
}
// Horizontal
if (KeyState.IsKeyDown(Keys.NumPad4))
{
PanL = true;
PanR = false;
}
else if (KeyState.IsKeyDown(Keys.NumPad6))
{
PanL = false;
PanR = true;
}
if (KeyState.IsKeyUp(Keys.NumPad4))
{
PanL = false;
}
if (KeyState.IsKeyUp(Keys.NumPad6))
{
PanR = false;
}
// Control game states
if (KeyState.IsKeyDown(Keys.F1) && PrevKeyState.IsKeyUp(Keys.F1))
{
State = InputState.Play;
}
else if (KeyState.IsKeyDown(Keys.F5) && PrevKeyState.IsKeyUp(Keys.F5))
{
State = InputState.Playtest;
}
else if (KeyState.IsKeyDown(Keys.F8) && PrevKeyState.IsKeyUp(Keys.F8))
{
State = InputState.RunLog;
}
else if (KeyState.IsKeyDown(Keys.F12) && PrevKeyState.IsKeyUp(Keys.F12))
{
State = InputState.Edit;
}
PrevKeyState = KeyState;
PrevState = State;
}
// Token: 0x0600155D RID: 5469 RVA: 0x0000E4CD File Offset: 0x0000C6CD
public static bool IsPressed(KeyState k)
{
return((byte)(GameState.Current.PlayerData.KeyState & k) != 0);
}
public static TrackSection LoadTrackSection(StreamReader stream, int keys)
{
TrackSection section;
try {
string line = stream.ReadLine();
int noChrs = line.Count();
section = new TrackSection(int.Parse(line.Substring(1, noChrs - 2)));
section.initNoteLists(keys);
Console.WriteLine(String.Format("Begin section at: {0}ms.", section.Begin));
string[] tokens;
// Init temp array to test for non-terminated hold notes
int[] holdNoteStartTimes = new int[3];
for (int i = 0; i < holdNoteStartTimes.Length; ++i)
{
holdNoteStartTimes[i] = InvalidTime;
}
while (!stream.EndOfStream)
{
if ((char)stream.Peek() == ']')
{
// End of a track section
stream.ReadLine();
break;
}
line = stream.ReadLine();
tokens = line.Split(',');
// Get time
int time = int.Parse(tokens[0]);
Console.Write(String.Format("Time: {0};", time));
// Extract state
for (int i = 0; i < keys; ++i)
{
KeyState stateID = (KeyState)int.Parse(tokens[i + 1]);
switch (stateID)
{
case KeyState.Tap:
section.notes[i].AddLast(new Note(time));
break;
case KeyState.Hold:
holdNoteStartTimes[i] = time;
break;
case KeyState.Release:
section.notes[i].AddLast(new Note(holdNoteStartTimes[i], time - holdNoteStartTimes[i]));
holdNoteStartTimes[i] = InvalidTime;
break;
}
section.End = time;
Console.Write(String.Format(" {0}", stateID));
}
Console.WriteLine();
}
bool holdsLeft = false;
for (int i = 0; !holdsLeft && i < keys; ++i)
{
holdsLeft |= holdNoteStartTimes[i] != InvalidTime;
}
if (holdsLeft)
{
throw new InvalidDataException("Corrupt section!");
}
} catch (Exception e) {
Console.Error.WriteLine(e.Message);
section = null;
}
return(section);
}
private float v(KeyState s)
{
return(s == KeyState.Down ? 1f : 0f);
}
protected override bool processKey(KeyState Key)
{
if (Key.Pressed)
{
Invalidate();
if (Key.IsUnmodified)
{
switch (Key.Key)
{
case KeyCode.A:
if (CmdFile is null)
{
InvokeAssembler(false);
}
return(true);
case KeyCode.C:
Clear();
return(true);
case KeyCode.D:
Disassemble();
return(true);
case KeyCode.F:
if (CmdFile?.Valid ?? false)
{
MakeFloppyFromFile(out string _, CmdFile.FilePath);
}
return(true);
case KeyCode.L:
Load();
Invalidate();
return(true);
case KeyCode.R:
Run();
Invalidate();
return(true);
case KeyCode.F8:
if (!Computer.HasRunYet)
{
CurrentMode = ViewMode.Normal;
}
return(base.processKey(Key));
}
}
else if (Key.Alt)
{
switch (Key.Key)
{
case KeyCode.Y:
var ret = base.processKey(Key);
Activate(); // since we're already here it won't happen.
return(ret);
}
}
}
return(base.processKey(Key));
}
