public void SetState(TerminalState new_state) { input_fix = true; cached_command_text = command_text; command_text = ""; switch (new_state) { case TerminalState.Close: open_target = 0; break; case TerminalState.OpenSmall: open_target = Screen.height * MaxHeight * SmallTerminalRatio; if (current_open_t > open_target) { // Prevent resizing from OpenFull to OpenSmall if window y position // is greater than OpenSmall's target open_target = 0; state = TerminalState.Close; return; } real_window_size = open_target; scroll_position.y = int.MaxValue; break; case TerminalState.OpenFull: default: real_window_size = Screen.height * MaxHeight; open_target = real_window_size; break; } state = new_state; }
public void Disconnect() { if (State != TerminalState.Disabled) { _state = TerminalState.Available; } }
/// <summary> /// Places the operator Terminal in mock mode /// This does not take any input from the user /// </summary> public static void DisableMock() { MockMode = false; MockState = TerminalState.LOGIN; MockPacket = null; return; }
public void SetCurrentInputAsNullTest() { var terminalState = new TerminalState(); var isInputSet = terminalState.TrySetCurrentInput(null); Assert.IsFalse(isInputSet); }
/// <summary> /// Places the operator Terminal in mock mode /// This does not take any input from the user /// </summary> public static void EnableMock() { MockMode = true; MockState = TerminalState.LOGIN; MockPacket = null; return; }
public void GetDefaultCurrentInputTest() { var terminalState = new TerminalState(); var actual = terminalState.GetCurrentInput(); Assert.IsNull(actual); }
public void SetCurrentInputAsEmptyTest() { var terminalState = new TerminalState(); var isInputSet = terminalState.TrySetCurrentInput(string.Empty); Assert.IsFalse(isInputSet); }
private void SetTerminalsStateTo(PhoneNumber source, PhoneNumber target, TerminalState state) { var sourceTerminal = GetTerminalByPhoneNumber(source) as TestTerminal; var targetTerminal = GetTerminalByPhoneNumber(target) as TestTerminal; if (sourceTerminal != null) sourceTerminal.State = state; if (targetTerminal != null) targetTerminal.State = state; }
/// <summary> /// Uses or Unlocks a power-up. /// </summary> /// <param name="powerUpID">The ID of the power-up being used.</param> public void usePowerUp(int powerUpID) { //UNLOCK ABILITY //check for enough charge and that another ability isnt currently being unlocked if (charge >= powerUps[powerUpID].getChargeRequired() && terminalState == TerminalState.Idle && powerUps[powerUpID].isLocked()) { //tooltip tipManager.DismissTip(3); // unlock button tipManager.ShowTip(9); //cannot charge //set unlocking to true terminalState = TerminalState.Unlocking; unlockID = powerUpID; } //USE ABILITY else if (powerUps[powerUpID].isLocked() == false && terminalState == TerminalState.Idle && powerUps[powerUpID].OnCoolDown() == false) { //dismiss tool tip tipManager.DismissTip(4); tipManager.DismissTip(5); //show cooldowntip tipManager.ShowTip(8); terminalState = TerminalState.UsingPowerUp; useID = powerUpID; } }
public Terminal(string model) { Model = model; Random rand = new Random(); Number = "+375 " + rand.Next(100000, 999999).ToString(); //Generate random number IsConnected = TerminalState.off; }
public void GetDefaultHistoricalCommandsTest() { var terminalState = new TerminalState(); var previousCommands = terminalState.GetPreviousTerminalCommands(); Assert.IsNotNull(previousCommands); Assert.IsEmpty(previousCommands); }
public void GetDefaultInputHistoryLimitTest() { var terminalState = new TerminalState(); var actual = terminalState.GetCommandHistoryLimit(); Assert.IsNotNull(actual); Assert.AreEqual(actual, 0); }
/// <summary> /// check for terminal ready on pin change /// </summary> /// <param name="sender">Serial port</param> /// <param name="e">Pin arguments</param> private void Terminal_PinChanged(object sender, SerialPinChangedEventArgs e) { if (State != lastState) { lastState = State; TerminalStateChanged(State); } }
bool SetupTTY(int stdin) { // Ensure that we are using a real terminal, // rather than some short of file redirection.thing. if (!Terminal.IsTerminal(stdin)) { Debug.Print("[Linux] Terminal.IsTerminal({0}) returned false.", stdin); return(false); } //original_stdin = Libc.dup(stdin); int ret = Terminal.GetAttributes(stdin, out original_state); if (ret < 0) { Debug.Print("[Linux] Terminal.GetAttributes({0}) failed. Error: {1}", stdin, ret); return(false); } // Retrieve current keyboard mode ret = Libc.ioctl(stdin, KeyboardIoctlCode.GetMode, ref original_mode); if (ret != 0) { Debug.Print("[Linux] Libc.ioctl({0}, KeyboardIoctlCode.GetMode) failed. Error: {1}", stdin, ret); return(false); } // Update terminal state current_state = original_state; current_state.LocalMode &= ~(/*LocalFlags.ECHO |*/ LocalFlags.ICANON | LocalFlags.ISIG); current_state.InputMode &= ~( InputFlags.ISTRIP | InputFlags.IGNCR | InputFlags.ICRNL | InputFlags.INLCR | InputFlags.IXOFF | InputFlags.IXON); current_state.ControlCharacters.VMIN = 0; current_state.ControlCharacters.VTIME = 0; Terminal.SetAttributes(stdin, OptionalActions.FLUSH, ref current_state); // Request keycodes int mode = 0x02; // K_MEDIUMRAW ret = Libc.ioctl(stdin, KeyboardIoctlCode.SetMode, mode); if (ret != 0) { Debug.Print("[Linux] Libc.ioctl({0}, KeyboardIoctlCode.SetMode, {1}) failed. Error: {2}", stdin, mode, ret); ExitTTY(this, EventArgs.Empty); return(false); } // Ensure we reset the original keyboard/terminal state on exit, // even if we crash. HookEvents(); return(true); }
public void AddHistoricalCommandAsNullTest() { var terminalState = new TerminalState(); var isHistoryLimitSet = terminalState.TrySetCommandHistoryLimit(10); var isAddHistoricalCommandSuccess = terminalState.TryAddHistoricalCommand(null); Assert.IsTrue(isHistoryLimitSet); Assert.IsFalse(isAddHistoricalCommandSuccess); }
public void Connect(IPort port) { Port = port; State = TerminalState.On; Port = port; Port.State = PortState.Connected; Port.OnInComingCall += Port_InComingCall; Port.OnCallResponce += Port_OnCallResponce; }
public void SetInputLengthLimitTest() { var terminalState = new TerminalState(); var expected = 20; var isLimitSet = terminalState.TrySetTerminalInputLengthLimit(expected); var actual = terminalState.GetInputLengthLimit(); Assert.IsTrue(isLimitSet); Assert.AreEqual(expected, actual); }
public void NonTruncatedEmptyInputTest() { var terminalState = new TerminalState(); var isInputLengthSet = terminalState.TrySetTerminalInputLengthLimit(1); var isInputTruncated = terminalState.TryTruncateInput(string.Empty, out var truncatedInput); Assert.IsTrue(isInputLengthSet); Assert.IsFalse(isInputTruncated); Assert.IsNull(truncatedInput); }
public void SetTerminalState(TerminalType type, TerminalState state) { for (int i = 0; i < m_terminalList.Count; i++) { if (m_terminalList[i].m_type == type) { m_terminalList[i].m_state = state; } } }
public void InvalidInputEmptyTest() { var terminalState = new TerminalState(); var isInputLengthSet = terminalState.TrySetTerminalInputLengthLimit(1); var isInputValid = terminalState.TryValidateInput(string.Empty, out var validInput); Assert.IsTrue(isInputLengthSet); Assert.IsFalse(isInputValid); Assert.IsNull(validInput); }
public void SetCurrentInputOverLengthLimitTest() { var terminalState = new TerminalState(); var stringOverLengthLimit = "this is a really long test"; var isLengthLimitSet = terminalState.TrySetTerminalInputLengthLimit(10); var isInputSet = terminalState.TrySetCurrentInput(stringOverLengthLimit); Assert.IsTrue(isLengthLimitSet); Assert.IsFalse(isInputSet); }
/// <summary> /// For testing the update delegates without risking infinite loop of conventional means. /// ONLY USE FOR UNIT TESTS /// </summary> /// <param name="terminalState"></param> /// <returns>Whether or not the console will continue to run</returns> public bool _RunUpdateDelegateOnce(TerminalState terminalState) { currentState = terminalState; userID = "123456789"; if (updateDelegates[(int)terminalState] != null) { return(updateDelegates[(int)terminalState]()); } return(false); }
public void ToggleState(TerminalState new_state) { if (state == new_state) { SetState(TerminalState.Close); } else { SetState(new_state); } }
public void InitializeTerminalState(TerminalState terminalState, int inputLengthCharacterLimit, int inputHistoryLimit) { Debug.Assert(inputLengthCharacterLimit > 0, "Input length character limit is invalid."); Debug.Assert(inputHistoryLimit > 0, "Input history limit is invalid."); var isInputLengthSetSuccess = terminalState.TrySetTerminalInputLengthLimit(inputLengthCharacterLimit); var isInputHistorySetSuccess = terminalState.TrySetCommandHistoryLimit(inputHistoryLimit); Debug.Assert(isInputLengthSetSuccess, "Failed to set maximum input length."); Debug.Assert(isInputHistorySetSuccess, "Failed to set maximum input history limit."); }
public void ValidInputTest() { var terminalState = new TerminalState(); var expected = "test"; var isInputLengthSet = terminalState.TrySetTerminalInputLengthLimit(10); var isInputValid = terminalState.TryValidateInput(expected, out var validInput); Assert.IsTrue(isInputLengthSet); Assert.IsTrue(isInputValid); Assert.AreEqual(expected, validInput); }
public void AddHistoricalCommandWithEmptyOutputTest() { var terminalState = new TerminalState(); var terminalCommand = new TerminalCommand { TerminalCommandInput = "testInput", TerminalCommandOutput = string.Empty }; var isHistoryLimitSet = terminalState.TrySetCommandHistoryLimit(10); var isAddHistoricalCommandSuccess = terminalState.TryAddHistoricalCommand(terminalCommand); Assert.IsTrue(isHistoryLimitSet); Assert.IsFalse(isAddHistoricalCommandSuccess); }
public void SetCurrentInputTest() { var terminalState = new TerminalState(); var expected = "test"; var isLengthLimitSet = terminalState.TrySetTerminalInputLengthLimit(10); var isInputSet = terminalState.TrySetCurrentInput(expected); var actual = terminalState.GetCurrentInput(); Assert.IsTrue(isLengthLimitSet); Assert.IsTrue(isInputSet); Assert.AreEqual(actual, expected); }
/// <summary> /// Start the game with terminal state in idle and all powerups being initialised /// Show Gaze and Communication terminal ToolTips /// </summary> void Start() { terminalState = TerminalState.Idle; if (audioSource == null) { audioSource = GetComponent <AudioSource> (); } tipManager.ShowTip(0); tipManager.ShowTip(6); }
public void Answer() { if (State == TerminalState.Ring) { TerminalDefaultEventArg terminalDefaultEventArg = new TerminalDefaultEventArg(); terminalDefaultEventArg.TerminalStateArg = _state; OnAnswered(terminalDefaultEventArg); _state = terminalDefaultEventArg.TerminalStateArg; } }
public void TruncatedInputTest() { var terminalState = new TerminalState(); var input = "test"; var lengthLimit = 1; var isInputLengthSet = terminalState.TrySetTerminalInputLengthLimit(lengthLimit); var isInputTruncated = terminalState.TryTruncateInput(input, out var truncatedInput); Assert.IsTrue(isInputLengthSet); Assert.IsTrue(isInputTruncated); Assert.AreNotEqual(input, truncatedInput); Assert.AreEqual(truncatedInput.Length, lengthLimit); }
/// <summary> /// Initializes a new VT100 terminal with the given Serial Port /// </summary> /// <param name="InOut">Serial Port. Automatically opened if closed</param> public VTconsole(SerialPort InOut) { Terminal = InOut; lastState = State; TerminalStateChanged += new TerminalStateChangedHandler(VTconsole_TerminalStateChanged); Terminal.DtrEnable = true; Terminal.RtsEnable = true; Terminal.PinChanged += new SerialPinChangedEventHandler(Terminal_PinChanged); if (!Terminal.IsOpen) { Terminal.Open(); } }
public CallList MakeCall(string senderName, string recieverName, int duration) { TermianlMessageEvent?.Invoke("\nBeep beep.."); IsConnected = TerminalState.calling; //Terminal switches to 'calling' state during the call TermianlMessageEvent?.Invoke("\nCall Started"); CallList CallInfo = new CallList(); Thread.Sleep(duration * 1000); //Sleep imitates process of calling TermianlMessageEvent?.Invoke("\nCall Finished\n"); IsConnected = TerminalState.connected; //Terminal switches back after call return(CallInfo); }
public bool CallTo(PhoneNumberStruct number) { if (State == TerminalState.Available) { CallingEventArgs callingEventArgs = new CallingEventArgs(); callingEventArgs.PhoneNumberArg = number; callingEventArgs.TerminalStateArg = TerminalState.Available; OnCallingTo(callingEventArgs); _state = callingEventArgs.TerminalStateArg; } return false; }
public void ClearCurrentInputTest() { var terminalState = new TerminalState(); var previousInput = "exists"; var isLengthLimitSet = terminalState.TrySetTerminalInputLengthLimit(10); var isInputSet = terminalState.TrySetCurrentInput(previousInput); terminalState.ClearCurrentInput(); var actual = terminalState.GetCurrentInput(); Assert.IsTrue(isLengthLimitSet); Assert.IsTrue(isInputSet); Assert.IsNotNull(actual); Assert.IsEmpty(actual); }
private void TerminalOnStateChangedEvent(object sender, TerminalState oldState, TerminalState newState) { IsRegisteredTerminalPluged = newState != TerminalState.Unplagged; }
private void WriteXml(TerminalState state) { this.WriteXmlBase((State)state); }
public void SetTerminalState(TerminalState state) { terminalState = state; }
public void InsertIntoPort() { State = TerminalState.Online; if (InsertedIntoPort != null) InsertedIntoPort(this, EventArgs.Empty); }
protected virtual void OnStateChanged(TerminalState state) { if (StateChanged != null) StateChanged(this, state); }
public bool Ring() { if (State == TerminalState.Available) { _state = TerminalState.Ring; OnRinging(new TerminalDefaultEventArg()); return true; } else { return false; } }
public void Connect(PhoneNumber phoneNumber) { if (State == TerminalState.Unplagged) throw new StateException($"{this} unplagged"); if (State == TerminalState.Online) throw new StateException($"{this} already online"); State = TerminalState.Online; var r = new ConnectRequest(ConnectRequest.UnprotectedConnection, PhoneNumber, phoneNumber); OnConnectingEvent(r); SendRequest(r); }
protected void Validate(TerminalState terminalState) { this.ValidateBase((State)terminalState); }
public void UnPlug() { if (_state == TerminalState.Available) { _state = TerminalState.Disabled; } }
// Constructor public PBXTerminal() { _state = TerminalState.Available; }
public void EndCall() { if (State != TerminalState.Disabled) { TerminalDefaultEventArg terminalDefaultEventArg = new TerminalDefaultEventArg(); terminalDefaultEventArg.TerminalStateArg = _state; OnEndedCall(terminalDefaultEventArg); _state = TerminalState.Available; } }
private void OnStateChangingEvent(TerminalState terminalState) { StateChangingEvent?.Invoke(MACAddress, terminalState); }
private void PortOnUnbindPortEvent(object sender, IPort port) { if (State != TerminalState.Unplagged) State = TerminalState.Offline; }
public void Disconnect() { if (State == TerminalState.Unplagged) throw new StateException($"{this} unplagged"); if (State != TerminalState.Online) return; State = TerminalState.Offline; OnDisconnectEvent(); }
public CallInfo(PhoneNumber target, PhoneNumber source, TerminalState state) { Target = target; Source = source; State = state; }
public void Plug() { if (State != TerminalState.Unplagged) return; State = TerminalState.Offline; }
public void RemoveFromPort() { State = TerminalState.Offline; if (RemovedFromPort != null) RemovedFromPort(this, EventArgs.Empty); }
public void ProcessRequest(object sender, IRequest request) { if (sender == null) throw new ArgumentNullException(nameof(sender)); if (request == null) throw new ArgumentNullException(nameof(request)); if (State == TerminalState.Unplagged) throw new StateException($"{this} unplagged"); var senderMac = sender as string; if (senderMac == null || senderMac != _registeredPortMAC) return; if (request is ConnectRequest) { if (State == TerminalState.Online) { var r = new ConnectResponse((ConnectRequest)request, ConnectResponse.TerminalBusy); OnSendResponseEvent(r); } else { State = TerminalState.Online; var r = new ConnectResponse((ConnectRequest)request, ConnectResponse.TerminalOk); OnSendResponseEvent(r); } return; } if (State == TerminalState.Offline) return; ProcessRequestWhenConnect(request); }
private void SetTerminalStateTo(PhoneNumber source, TerminalState state) { var sourceTerminal = GetTerminalByPhoneNumber(source) as TestTerminal; if (sourceTerminal != null) sourceTerminal.State = state; }
public void ProcessResponse(object sender, IResponse response) { if (sender == null) throw new ArgumentNullException(nameof(sender)); if (response == null) throw new ArgumentNullException(nameof(response)); if (State == TerminalState.Unplagged) throw new StateException($"{this} unplagged"); if (State == TerminalState.Offline) return; var senderMac = sender as string; if (senderMac == null || (senderMac != _registeredPortMAC && senderMac != MACAddress)) return; if (response is ConnectResponse) { if (response.Code == ConnectResponse.TerminalOk) OnConnectSucceededEvent((ConnectResponse)response); else { State = TerminalState.Offline; OnConnectFailedEvent((ConnectResponse)response); } return; } if (response is DropedResponse) { State = TerminalState.Offline; OnDropedEvent((DropedResponse)response); return; } ProcessResponseWhenConnect(response); }
internal static State State(string typeName) { DesignByContract.Check.Require(!string.IsNullOrEmpty(typeName), string.Format(CommonStrings.XMustNotBeNullOrEmpty, "typeName")); State state = null; switch (typeName) { case "NON_TERMINAL_STATE": state = new NonTerminalState(); break; case "TERMINAL_STATE": state = new TerminalState(); break; default: throw new NotSupportedException("type not supported: " + typeName); } DesignByContract.Check.Ensure(state != null, "state must not be null."); return state; }
public virtual void RemovePort(IPort port) { if (port == null) throw new ArgumentNullException(nameof(port)); if (port.MACAddress != _registeredPortMAC) throw new RegistrationException($"{this} did'n register {port}"); if (!IsPortRegistered) return; port.StateChangedEvent -= PortOnStateChangedEvent; port.ProcessRequestEvent -= ProcessRequest; port.ProcessResponseEvent -= ProcessResponse; port.UnbindPortEvent -= PortOnUnbindPortEvent; _registeredPortMAC = null; IsRegisteredPortNotClosed = false; if (State != TerminalState.Unplagged) State = TerminalState.Offline; OnRemovePort(port); }
private void ReadXml(TerminalState state) { Check.Require(state != null, "terminalState must not be null."); reader.ReadStartElement(); reader.MoveToContent(); this.ReadXmlBase((State)state); reader.ReadEndElement(); reader.MoveToContent(); }
public void Unplug() { if (State == TerminalState.Unplagged) return; State = TerminalState.Unplagged; }
private void OnStateChangedEvent(TerminalState oldstate) { StateChangedEvent?.Invoke(MACAddress, oldstate, _state); }
public void Plug() { if (_state == TerminalState.Disabled) { _state = TerminalState.Available; } }