public StatusViewSwitch(ScenarioModel scenarioModel) : this()
{
DataContext = scenarioModel;
tbScenarioName.Text = scenarioModel.ScenarioName;
ItemView toSelect = null;
foreach (var state in scenarioModel.AcceptedValues)
{
var itemView = new ItemView();
itemView.Icon = Icons.Icon.NavigateNext;
itemView.Content = state;
itemView.Margin = new Thickness(0, 0, 0, 1);
if (scenarioModel.ScenarioValue != null && scenarioModel.ScenarioValue.Equals(state))
{
toSelect = itemView;
}
listItemsStates.Children.Add(itemView);
}
Loaded += (o, e) =>
{
if (toSelect != null)
{
toSelect.Selected = true;
toSelect.Focus();
}
};
listItemsStates.SelectionChanged += (o, e) =>
{
var selectedItem = listItemsStates.GetSelectedItems().FirstOrDefault() as ItemView;
if (selectedItem != null && selectedItem.Content.ToString() != scenarioModel.ScenarioValue)
{
scenarioModel.ScenarioValue = selectedItem.Content.ToString();
StateChanged?.Invoke(this, new RoutedEventArgs());
}
};
}
public void ConditionalExitActionIsNotCalled()
{
var evt = new ManualResetEvent(false);
var exitActionCalled = false;
Action exitAction = () => exitActionCalled = true;
StateMachine.AddAutomaticTransition(TestStates.Collapsed, TestStates.FadingIn);
StateMachine.AddExitAction(TestStates.Collapsed, exitAction, () => false);
_stateChangedSubscription = StateChanged.Where(args => args.ToState == TestStates.FadingIn).Subscribe(args =>
{
evt.Set();
_stateChangedSubscription.Dispose();
});
StateMachine.Start();
evt.WaitOne();
Assert.False(exitActionCalled);
}
public void Write(BinaryState state, WriteBinaryStateMode mode)
{
// TODO: Implement animations here.
foreach (var output in _outputs)
{
output.Write(state, WriteBinaryStateMode.NoCommit);
}
if (mode == WriteBinaryStateMode.Commit)
{
foreach (var output in _outputs)
{
output.Write(state);
}
}
var oldState = _state;
_state = state;
StateChanged?.Invoke(this, new BinaryStateChangedEventArgs(oldState, _state));
}
/// <summary>
/// Updates a User.
/// </summary>
/// <param name="attributes"></param>
/// <returns></returns>
public async Task <User> Update(UserAttributes attributes)
{
if (CurrentSession == null || string.IsNullOrEmpty(CurrentSession.AccessToken))
{
throw new Exception("Not Logged in.");
}
try
{
var result = await api.UpdateUser(CurrentSession.AccessToken, attributes);
CurrentUser = result;
StateChanged?.Invoke(this, new ClientStateChanged(AuthState.UserUpdated));
return(result);
}
catch (RequestException ex)
{
throw ParseRequestException(ex);
}
}
protected virtual void OnStateChanged(StateChange stateChange)
{
using (Trace.Log())
{
connectionState = stateChange.NewState;
Console.WriteLine($"{stateChange.OldState} {stateChange.NewState}");
if (stateChange.NewState == ConnectionState.Disconnected)
{
if (stateChange.OldState == ConnectionState.Disconnected)
{
hubConnection?.Start();
}
else if (reconnect)
{
Task.Delay(1000).ContinueWith((t) => hubConnection?.Start());
}
}
StateChanged?.Invoke(stateChange);
}
}
private void MqttCallback(DeviceMessage deviceMessage)
{
var oldState = _state;
var payload = Encoding.UTF8.GetString(deviceMessage.Payload);
if (payload == "pressed")
{
_state = BinaryState.High;
}
else
{
_state = BinaryState.Low;
}
if (_state == oldState)
{
return;
}
StateChanged?.Invoke(this, new BinaryStateChangedEventArgs(oldState, _state));
}
public void SingleEntryActionIsCalled()
{
var evt = new ManualResetEvent(false);
var entryActionCalled = false;
Action entryAction = () => entryActionCalled = true;
StateMachine.AddAutomaticTransition(TestStates.Collapsed, TestStates.FadingIn);
StateMachine.AddEntryAction(TestStates.FadingIn, entryAction);
_stateChangedSubscription = StateChanged.Where(args => args.ToState == TestStates.FadingIn).Subscribe(args =>
{
_stateChangedSubscription.Dispose();
evt.Set();
});
StateMachine.Start();
evt.WaitOne();
Assert.True(entryActionCalled);
}
//it will start actual recording, append if there is data
//in the wave file through the RecordCaptureData()
public void StartRecording(IAudioMediaAsset asset)
{
StateChanged mStateChanged = new StateChanged(mState);
mState = AudioRecorderState.Recording;
FireEvent(mStateChanged);
m_Channels = asset.Channels;
m_SampleRate = asset.SampleRate;
m_bitDepth = asset.BitDepth;
mAsset = new AudioMediaAsset(m_Channels, m_bitDepth, m_SampleRate);
mAsset = asset.Copy() as AudioMediaAsset;
AssetManager manager = mAsset.Manager as AssetManager;
sProjectDirectory = manager.DirPath;
InputFormat = GetInputFormat();
m_sFileName = GetFileName();
BinaryWriter bw = new BinaryWriter(File.Create(m_sFileName));
CreateRIFF(bw);
CreateCaptureBuffer();
InitRecording(true);
}
public void Expand()
{
if (Expanded)
{
return;
}
if (StateChanging != null)
{
CancelEventArgs args = new CancelEventArgs();
StateChanging(this, args);
if (args.Cancel)
{
return;
}
}
Expanded = true;
ArrangeLayout();
StateChanged?.Invoke(this, null);
}
public void Connect(IntPtr hwnd, uint attitudeFrequency)
{
try
{
UnsubscribeEvents();
_simConnect?.Dispose();
_attitudeTimer?.Dispose();
_simConnect = new SimConnectImpl(AppName, hwnd, WM_USER_SIMCONNECT, null, 0);
_attitudeTimer = new Timer(RequestAttitudeData, null, 100, 1000 / attitudeFrequency);
SubscribeEvents();
StateChanged?.Invoke(false);
}
catch (COMException e)
{
Console.Error.WriteLine("Exception caught: " + e);
StateChanged?.Invoke(true);
}
}
/// <summary>
/// Change the state.
/// </summary>
public void SetState
(
bool newState
)
{
Log.Trace
(
nameof(BusyState) + "::" + nameof(SetState)
+ ": newState="
+ newState
);
lock (_lock)
{
if (newState != _currentState)
{
if (newState)
{
_waitHandle.Reset();
_thread = Thread.CurrentThread;
}
else
{
_waitHandle.Set();
}
_currentState = newState;
if (UseAsync)
{
StateChanged.RaiseAsync(this);
}
else
{
StateChanged.Raise(this);
}
}
}
}
/// <summary>
/// Starte den Automaten beim jeweiligen Zustand
/// </summary>
/// <param name="state"></param>
public void Start(Enum stateEnum)
{
int stateNumber = EnumHelper.ToInt(stateEnum);
if (stateNumber < 0)
{
Log.Error($"Fsm;Start;{Name}; Statename {stateEnum} existiert nicht");
return;
}
ActState = states[stateNumber];
StateChanged?.Invoke(this,
new FsmTransition
{
Time = DateTime.Now,
Fsm = Name,
LastState = "",
ActState = ActState.StateEnum.ToString(),
Input = ""
});
IsRunning = true;
CheckActStateInputs(); // gleich beim Start entsprechend reagieren
}
public void Close()
{
logger.Debug("Close()");
if (socket != null)
{
socket.Close();
socket = null;
}
if (syncEvent != null)
{
syncEvent.Close();
syncEvent = null;
}
state = ClientState.Closed;
isAuthenticated = false;
StateChanged?.Invoke();
}
public void Open()
{
_messageQueue.Open();
StateChanged?.Invoke();
var histAdapter = _parent.HistoryMessageAdapterEx;
ThreadingHelper
.Thread(() => CultureInfo.InvariantCulture.DoInCulture(() =>
{
while (!_messageQueue.IsClosed)
{
try
{
var sended = histAdapter.SendOutMessage();
var processed = false;
while (_messageQueue.TryDequeue(out var message, true, false))
{
NewOutMessage?.Invoke(message);
processed = true;
}
if (!sended && !processed && !_messageQueue.IsClosed)
{
Thread.Sleep(1000);
}
}
catch (Exception ex)
{
_parent.SendOutError(ex);
}
}
StateChanged?.Invoke();
}))
.Name("History emulation channel thread.")
.Launch();
}
private void RevertButton_Click(object sender, EventArgs e)
{
using (PerfSection p10 = new PerfSection("Perforce - Check in scenario component: " + mTopic.Name))
{
Cursor.Current = Cursors.WaitCursor;
PerforceChangeList newlist = CoreGlobals.getPerforce().GetNewChangeList("Scenario Topic: " + GetTopicAlias(mTopic.Name) + " Scenario: " + Path.GetFileNameWithoutExtension(CoreGlobals.ScenarioFile));
foreach (string file in mTopic.Files)
{
if (newlist.ReOpenFile(file) == false)
{
CoreGlobals.ShowMessage("Error re-opening: " + file);
return;
}
}
if (newlist.Revert() == false)
{
CoreGlobals.ShowMessage("Error reverting in files");
}
mTopic.UpdateState();
UpdateUI();
if (!mbPaused && StateChanged != null)
{
StateChanged.Invoke(this, null);
}
using (PerfSection p1 = new PerfSection("Clean list"))
{
//CoreGlobals.getPerforce().CleanEmptyChangeLists("Scenario Topic: ");
if (CoreGlobals.getPerforce().HasFilesOpen(newlist.ID) == false)
{
CoreGlobals.getPerforce().getConnection().P4DeleteList(newlist.ID);
}
}
Cursor.Current = Cursors.Default;
}
}
public bool Connect(string host, int port = 25456)
{
logger.Debug("Connect() " + host + " " + port);
if (state != ClientState.Disconnected)
{
logger.Warn("Connect(...) invalid state: " + state);
return(false);
}
state = ClientState.Connecting;
StateChanged?.Invoke();
this.Host = host;
this.Port = port;
Task.Run(() =>
{
CommunicationLoop();
});
return(true);
}
public async Task InitAsync()
{
if (isInitialized)
{
throw new ServiceProviderInvalidException("ServiceProvider уже инициализирован");
}
logger.Debug("Инициализация...");
isInitialized = true;
InitService();
StateChanged?.Invoke(this, new ServiceStateChangedEventArgs(ServiceState.ExpectingOnline));
if (!await CheckAvailability())
{
logger.Debug("Сервис не запущен, запускаю встроенный сервис...");
CreateEmbedService();
}
else
{
logger.Debug("Сервис запущен внешне");
}
}
private void HandleOpenState(bool opened)
{
// TODO: find a way to remove javascript
if (opened)
{
ExecuteAfterRender(async() =>
{
await JSRunner.OpenModal(ElementRef, ElementId);
});
}
else
{
ExecuteAfterRender(async() =>
{
await JSRunner.CloseModal(ElementRef, ElementId);
});
}
StateChanged?.Invoke(this, new ModalStateEventArgs(opened));
DirtyClasses();
DirtyStyles();
}
//возврат книг
public void Return_book(Book book)
{
if (Books_in_Lib.Count() != 0)
{
int num = Book_Index(book);
if (num == -1)
{
Console.WriteLine("Книгу брали не из данной библиотеки");
}
else
{
Books_in_Lib.RemoveAt(num);
Book_Subscr newbook = new Book_Subscr(book, null, DateTime.Today.Date);
Books_in_Lib.Add(newbook);
state = Book_State.inLib;
StateChanged?.Invoke(this, state);
}
}
else
{
Console.WriteLine("Возврат не возможен, в библиотеке нет книг");
}
}
// We ensure that our event is raised on the Automation thread .. (Eases concurrency issues in handling it, though it will get passed on to the main thread...)
void OnStateChanged(StateChangeType stateChangeType)
{
StateChangeEventArgs stateChangedArgs;
switch (stateChangeType)
{
case StateChangeType.Multiple:
stateChangedArgs = s_stateChangeMultiple;
break;
case StateChangeType.Move:
stateChangedArgs = s_stateChangeMove;
break;
case StateChangeType.TextChange:
stateChangedArgs = s_stateChangeTextChange;
break;
default:
throw new ArgumentOutOfRangeException(nameof(stateChangeType));
}
StateChanged?.Invoke(this, stateChangedArgs);
}
/// <summary>
/// Log in a user given a User supplied OTP received via mobile.
/// </summary>
/// <param name="phone">The user's phone number.</param>
/// <param name="token">Token sent to the user's phone.</param>
/// <returns></returns>
public async Task <Session> VerifyOTP(string phone, string token)
{
try
{
await DestroySession();
var session = await api.VerifyMobileOTP(phone, token);
if (session?.AccessToken != null)
{
await PersistSession(session);
StateChanged?.Invoke(this, new ClientStateChanged(AuthState.SignedIn));
return(session);
}
return(null);
}
catch (RequestException ex)
{
throw ExceptionHandler.Parse(ex);
}
}
/// <summary>
/// Signs in a User.
/// </summary>
/// <param name="email"></param>
/// <param name="password"></param>
/// <returns></returns>
public async Task <Session> SignIn(string email, string password)
{
await DestroySession();
try
{
var result = await api.SignInWithEmail(email, password);
if (result?.User?.ConfirmedAt != null)
{
await PersistSession(result);
StateChanged?.Invoke(this, new ClientStateChanged(AuthState.SignedIn));
return(result);
}
return(null);
}
catch (RequestException ex)
{
throw ParseRequestException(ex);
}
}
void ProcessEvent(string eventInfo)
{
if (string.IsNullOrWhiteSpace(eventInfo))
{
return;
}
var info = eventInfo.Split(new char[] { '#' }, StringSplitOptions.RemoveEmptyEntries);
switch (info[0])
{
case "RaiseMessage":
RaiseMessage?.Invoke(info[1]);
break;
case "StateMessageChanged":
StateMessageChanged?.Invoke(info[1]);
break;
case "StateChanged":
StateChanged?.Invoke((PhoneState)Enum.Parse(typeof(PhoneState), info[1]));
break;
}
}
private void RegisterStateChangedEvent()
{
_stateChangedCallback = (error, state, _) =>
{
var prevState = _state.Value;
_state.Value = state;
if (prevState != state)
{
StateChanged?.Invoke(this, new ScreenMirroringStateChangedEventArgs(state));
}
if (error != ScreenMirroringErrorCode.None)
{
ErrorOccurred?.Invoke(this, new ScreenMirroringErrorOccurredEventArgs(
ScreenMirroringError.InvalidOperation));
}
};
Native.SetStateChangedCb(Handle, _stateChangedCallback).
ThrowIfError("Failed to initialize StateChanged event.");
}
/// <summary>
/// Call the AI to place his penguin
/// </summary>
public void PlacePenguin()
{
switch (CurrentPlayer.PlayerType)
{
case PlayerType.AIEasy: //Easy difficulty AI
Coordinates posEasy = _aiEasy.PlacementPenguin();
PlacePenguinManual(posEasy.X, posEasy.Y);
break;
case PlayerType.AIMedium:
// This should normaly be a medium AI
Coordinates posM = _aiEasy.PlacementPenguin();
PlacePenguinManual(posM.X, posM.Y);
break;
case PlayerType.AIHard:
// This should normaly be a hard AI
Coordinates posH = _aiEasy.PlacementPenguin();
PlacePenguinManual(posH.X, posH.Y);
break;
}
StateChanged?.Invoke(this, null);
}
public void AutomaticTransitionWithConditionIsMade()
{
var evt = new ManualResetEvent(false);
var transitionMade = false;
StateMachine.AddAutomaticTransition(TestStates.Collapsed, TestStates.FadingIn, () => true);
_stateChangedSubscription = StateChanged.Where(args => args.ToState == TestStates.FadingIn).Subscribe(args =>
{
transitionMade = true;
_stateChangedSubscription.Dispose();
evt.Set();
});
StateMachine.Start();
while (!evt.WaitOne(50))
{
DispatcherHelper.DoEvents();
}
Assert.True(transitionMade);
}
private void controlClick(object sender, MouseEventArgs e)
{
var command = getCommand(e.X, e.Y, e.Button);
if (!command.HasValue)
{
return;
}
_lastClick = command;
_showPreview = false;
if (e.Button == MouseButtons.Middle)
{
States = null;
return;
}
setButtonState(command.Value, _states);
Refresh();
StateChanged?.Invoke(this, null);
}
private void makeProhibitedValuesIgnored()
{
if (_states == null)
{
return;
}
bool stateChanged = false;
for (int i = 0; i < _states.Length; i++)
{
stateChanged = _states[i] == FilterValueState.Prohibited;
if (stateChanged)
{
_states[i] = FilterValueState.Ignored;
}
}
if (stateChanged)
{
StateChanged?.Invoke(this, null);
}
}
public void SetState(string id, params IParameter[] parameters)
{
if (id == null)
{
throw new ArgumentNullException(nameof(id));
}
string oldState = GetState();
for (int i = 0; i < States.Count; i++)
{
var state = States[i];
if (state.Id.Equals(id, StringComparison.OrdinalIgnoreCase))
{
bool stateIsAlreadyActive = i == _index;
if (stateIsAlreadyActive && _turnOffIfStateIsAppliedTwice)
{
if (state.Id == BinaryActuatorState.Off.ToString())
{
// The state is already "Off".
return;
}
TurnOff();
return;
}
_index = i;
state.Apply(parameters);
StateChanged?.Invoke(this, new StateMachineStateChangedEventArgs(oldState, state.Id));
return;
}
}
throw new NotSupportedException("StateMachineActuator '" + Id + "' does not support state '" + id + "'.");
}
private void SetState(GlobalThreadState newState)
{
GlobalThreadState oldState;
lock (stateLock)
{
oldState = State;
if (oldState == GlobalThreadState.PENDING_SHUTDOWN && newState == GlobalThreadState.PENDING_SHUTDOWN)
{
// when the state is already in PENDING_SHUTDOWN, its transition to itself
// will be refused but we do not throw exception here
return;
}
else if (oldState == GlobalThreadState.DEAD)
{
// when the state is already in NOT_RUNNING, all its transitions
// will be refused but we do not throw exception here
return;
}
else if (!oldState.IsValidTransition(newState))
{
log.LogError("{LogPrefix}Unexpected state transition from {OldState} to {NewState}", logPrefix, oldState,
newState);
throw new StreamsException($"Unexpected state transition from {oldState} to {newState}");
}
else
{
log.LogInformation("{LogPrefix}State transition from {OldState} to {NewState}", logPrefix, oldState,
newState);
}
State = newState;
}
StateChanged?.Invoke(this, oldState, State);
}
