public DownloadingViewModel(IUnityContainer container) : base(container)
{
PauseAllCommand = new RelayCommand(() =>
{
foreach (var task in TransferTasks)
{
if (PauseCommand.CanExecute(task))
{
PauseCommand.Execute(task);
}
}
},
() => TransferTasks?.Any() ?? false);
CancelAllCommand = new RelayCommand(() =>
{
foreach (var task in TransferTasks)
{
if (CancelCommand.CanExecute(task))
{
CancelCommand.Execute(task);
}
}
},
() => TransferTasks?.Any() ?? false);
}
private void RaiseCanExecuteChangedEvents()
{
PauseCommand.RaiseCanExecuteChanged();
RestartCommand.RaiseCanExecuteChanged();
AbortCommand.RaiseCanExecuteChanged();
StopSaveCommand.RaiseCanExecuteChanged();
}
/// <summary>
/// plays the currently selected song, if no song is selected it plays the first one inside the playlist,
/// if no song is inside the playlist, the random function is used to get a song from the library
/// </summary>
private void Play()
{
if (_mediaPlayer.IsPlaying())
{
if (PlaybackPaused)
{
Pause();
return;
}
_mediaPlayer.Stop();
}
if (CurrentSong == null && PlaylistService != null)
{
CurrentSong = PlaylistService.GetNextPlaylistItem(SequentialPlayback == false, null, true);
}
if (CurrentSong == null)
{
return;
}
_mediaPlayer.Play(CurrentSong);
PlaybackPaused = false;
PreviousSongCommand.RaiseCanExecuteChanged();
PauseCommand.RaiseCanExecuteChanged();
((IPlayerView)View).SetArtistAndTitle(CurrentSong.Song.Artist, CurrentSong.Song.Title);
int durationOfSongInMs = _mediaPlayer.GetDurationOfPlayedSong();
((IPlayerView)View).SetSongDuration(durationOfSongInMs);
}
private void RefreshCommandExecuteStatus()
{
ConnectCommand.RaiseCanExecuteChanged();
ClearAlarmCommand.RaiseCanExecuteChanged();
SendGCodeFileCommand.RaiseCanExecuteChanged();
StartProbeCommand.RaiseCanExecuteChanged();
StartProbeHeightMapCommand.RaiseCanExecuteChanged();
StopCommand.RaiseCanExecuteChanged();
PauseCommand.RaiseCanExecuteChanged();
SoftResetCommand.RaiseCanExecuteChanged();
HomingCycleCommand.RaiseCanExecuteChanged();
FeedHoldCommand.RaiseCanExecuteChanged();
CycleStartCommand.RaiseCanExecuteChanged();
EmergencyStopCommand.RaiseCanExecuteChanged();
LaserOnCommand.RaiseCanExecuteChanged();
LaserOffCommand.RaiseCanExecuteChanged();
SpindleOnCommand.RaiseCanExecuteChanged();
SpindleOffCommand.RaiseCanExecuteChanged();
GotoFavorite1Command.RaiseCanExecuteChanged();
GotoFavorite2Command.RaiseCanExecuteChanged();
SetFavorite1Command.RaiseCanExecuteChanged();
SetFavorite2Command.RaiseCanExecuteChanged();
GotoWorkspaceHomeCommand.RaiseCanExecuteChanged();
SetWorkspaceHomeCommand.RaiseCanExecuteChanged();
}
private void RaiseButtonsCommandsCanExecuteChanged()
{
RaisePropertyChanged(nameof(AreButtonsEnabled));
PlayCommand.RaiseCanExecuteChanged();
PauseCommand.RaiseCanExecuteChanged();
StopCommand.RaiseCanExecuteChanged();
}
private void AddCommandToList(PauseCommand c)
{
if (!RequestedPauseCommands.Contains(c))
{
RequestedPauseCommands.Add(c);
}
}
private void UpdateCommands()
{
PlayCommand.OnCanExecuteChanged();
PauseCommand.OnCanExecuteChanged();
StopCommand.OnCanExecuteChanged();
RestartCommand.OnCanExecuteChanged();
CaptureImageCommand.OnCanExecuteChanged();
}
public ControlBarVM(FGM m) : base(m)
{
PauseTheFlight = new PauseCommand(PauseThread);
PlayTheFlight = new PlayCommand(ContinueRunning);
IncreaseTheSpeed = new PlusCommand(IncreaseSpeed);
DecreaseTheSpeed = new MinusCommand(DecreaseSpeed);
StopTheFlight = new StopCommand(StopFlight);
}
private void RaisePauseChanged()
{
IsPaused = CancellationTokenSource?.IsPaused ?? false;
RaisePropertiesChanged(() => CanPause, () => CanResume);
PauseCommand.RaiseCanExecuteChanged();
ResumeCommand.RaiseCanExecuteChanged();
CancelCurrentOperationCommand.RaiseCanExecuteChanged();
}
private void RaiseCommandCanExecuteChanged()
{
PlayCommand.RaiseCanExecuteChanged();
PauseCommand.RaiseCanExecuteChanged();
StopCommand.RaiseCanExecuteChanged();
NextCommand.RaiseCanExecuteChanged();
PreviousCommand.RaiseCanExecuteChanged();
RaisePropertyChanged(nameof(CurrentMedia));
}
public void Create()
{
var log = A.Fake <ILogger>();
var radio = A.Fake <IRadio>();
var command = new PauseCommand(log, radio);
Assert.NotNull(command);
}
private void OnMediaOpenend()
{
_progressTimer?.Start();
CurrentTrack = _playerManager.CurrentTrack;
PlayNextCommand.RaiseCanExecuteChanged();
PauseCommand.RaiseCanExecuteChanged();
LoadCoverSource(CurrentTrack);
}
private void RaisePlayerStatusChanged()
{
MoveNextCommand.RaiseCanExecuteChanged();
MovePreviousCommand.RaiseCanExecuteChanged();
PauseCommand.RaiseCanExecuteChanged();
ResumeCommand.RaiseCanExecuteChanged();
SkipToPercentageCommand.RaiseCanExecuteChanged();
RaisePropertyChanged(nameof(Playing));
}
public void Execute(PauseCommand command)
{
var now = DateTime.Now;
var endTime = now.AddSeconds(command.TimeOutMilliseconds);
var timeOutTimeSpan = endTime - now;
LogHandler?.Invoke("Start to Execute Pause Command");
try
{
while (DateTime.Now < endTime)
{
if (command.RefreshInterval > 0)
{
// do something
var retrunCommand = CommandExecutor.SharedInstance.brain.Arm.CanResume(
CommandExecutor.SharedInstance.RegisterId.Value);
if (!string.IsNullOrEmpty(retrunCommand))
{
LogHandler?.Invoke("Will resume!");
JsonSerializerSettings settings = new JsonSerializerSettings {
TypeNameHandling = TypeNameHandling.Auto
};
var resumeCommand = JsonConvert.DeserializeObject <ResumeCommand>(retrunCommand, settings);
break;
}
else
{
LogHandler?.Invoke($"Will sleep {command.RefreshInterval}ms");
Thread.Sleep(command.RefreshInterval);
}
}
else
{
LogHandler?.Invoke($"Will sleep {timeOutTimeSpan.Seconds}s");
Thread.Sleep(timeOutTimeSpan);
}
}
}
finally
{
// unlock
lock (CommandExecutor.SharedInstance)
{
CommandStore.SharedInstance.CurrentCommand = null;
CommandExecutor.SharedInstance.IsWaitingResponse = false;
}
new Thread(() => {
LogHandler?.Invoke($"Will sleep 500ms for safty");
Thread.Sleep(500);
CommandExecutor.SharedInstance.Execute();
}).Start();
}
}
public void CheckName()
{
var log = A.Fake <ILogger>();
var radio = A.Fake <IRadio>();
var command = new PauseCommand(log, radio);
Assert.Contains("-pa", command.Name);
Assert.Contains("--pause", command.Name);
Assert.Contains("Pause playing", command.Description);
}
/// <summary>
/// Pauses this instance.
/// </summary>
public void Pause()
{
if (PauseCommand?.CanExecute(null) == true)
{
PauseCommand?.Execute(null);
MediaState = MediaState == MediaState.Paused ? MediaState.Playing : MediaState.Paused;
OnMediaStateChanged();
}
}
/// <summary>
/// Updates UI bound to play/pause properties.
/// </summary>
private void UpdateViews()
{
OnPropertyChanged("IsPaused");
OnPropertyChanged("IsShowingPauseDisplay");
OnPropertyChanged("IsPauseButtonVisible");
UpdateClockView();
PlayCommand.RaiseCanExecuteChanged();
PauseCommand.RaiseCanExecuteChanged();
GameViewModel.MoveCommand.RaiseCanExecuteChanged();
GameViewModel.UndoCommand.RaiseCanExecuteChanged();
GameViewModel.RedoCommand.RaiseCanExecuteChanged();
}
private void UpdateCommands()
{
RemoveSelectedVideoCommand.RaiseCanExecuteChanged();
AddMarkerCommand.RaiseCanExecuteChanged();
RemoveSelectedMarkerCommand.RaiseCanExecuteChanged();
PlayCommand.RaiseCanExecuteChanged();
PauseCommand.RaiseCanExecuteChanged();
StopCommand.RaiseCanExecuteChanged();
Plus5Command.RaiseCanExecuteChanged();
Minus5Command.RaiseCanExecuteChanged();
}
public VocalizedViewModel(TextToSpeech textToSpeech, IAudioPlayer audioPlayer, ISettingsService settingsService)
{
TextToSpeech = textToSpeech;
AudioPlayer = audioPlayer;
AudioPlayer.OutputDevice = settingsService.settings.generalSettings.AudioOutDevice;
AudioPlayer.AudioFile = TextToSpeech.AudioFile;
this.settingsService = settingsService;
settings = settingsService.settings;
PlayCmd = new PlayCommand(this);
StopCmd = new StopCommand(this);
PauseCmd = new PauseCommand(this);
}
public async Task Execute()
{
var log = A.Fake <ILogger>();
var radio = A.Fake <IRadio>();
var command = new PauseCommand(log, radio);
var result = await command.Execute(new string[0]);
A.CallTo(() => radio.Pause()).MustHaveHappened();
Assert.Equal(CommandResult.OK, result);
}
private void PauseButton_Checked(object sender, RoutedEventArgs e)
{
if (PauseCommand == null)
{
return;
}
var parameter = PauseCommandParameter ?? DataContext;
if (PauseCommand.CanExecute(parameter))
{
PauseCommand.Execute(parameter);
}
}
/// <summary>
/// Pauses or resumes game and sends game pause state to clients.
/// This functions works only game is ready and running.
/// </summary>
private void PauseGame()
{
if (PlayerCount != 2)
{
return;
}
IsPaused = !IsPaused;
var pauseCommand = new PauseCommand {
Value = IsPaused
};
_gameServer.SendAll(GameChannelType.Reliable, pauseCommand);
}
public InputHandler()
{
_buttonShoot = Keyboard.Key.Space;
buttonShoot = new ShootCommand();
_buttonLeft = Keyboard.Key.A;
_buttonRight = Keyboard.Key.D;
_buttonUp = Keyboard.Key.W;
_buttonDown = Keyboard.Key.S;
_buttonBigShoot = Keyboard.Key.LAlt;
_buttonSelect = Keyboard.Key.Return;
_mouseShoot = Mouse.Button.Left;
_mouseBigShoot = Mouse.Button.Right;
_P = Keyboard.Key.P;
_R = Keyboard.Key.R;
_ArrowUp = Keyboard.Key.Up;
_ESC = Keyboard.Key.Escape;
nrShoot = 11;
nrSelect = 14;
nrBigShoot = 10;
turnCommand = new TurnCommand();
moveCommandArray = new Command[4];
for(int i = 0; i < moveCommandArray.Length; i++)
{
moveCommandArray[i] = new MoveCommand();
}
menuUpCommand = new MenuUpCommand();
menuDownCommand = new MenuDownCommand();
menuSelectCommand = new MenuSelectCommand();
turnCommandJoystick = new TurnCommandJoystick();
PausePressedCommand = new PausePressedCommand();
ResumePressedCommand = new ResumePressedCommand();
UpgradePressedCommand = new UpgradePressedCommand();
ESCPressedCommand = new ESCPressedCommand();
dialogEnterCommand = new DialogEnterCommand();
RequestedCommands = new List<Command>();
RequestedMenuCommands = new List<MenuCommand>();
RequestedDialogCommands = new List<DialogCommand>();
requestedPauseCommands = new List<PauseCommand>();
RequestedGameCommands = new List<GameCommand>();
ConfigureJoystick(0);
mousePosition = Mouse.GetPosition();
}
void Start()
{
// Get both controller and display model
controller = dotMatrix.GetController();
displayModel = dotMatrix.GetDisplayModel();
// Go through all alignments
for (int vp = 0; vp < 3; vp++)
{
for (int hp = 0; hp < 3; hp++)
{
for (int ta = 0; ta < 3; ta++)
{
TextCommand testText = new TextCommand((vp == 0 ? "Top" : (vp == 1 ? "Middle" : "Bottom")) + "\n" + (hp == 0 ? "Left" : (hp == 1 ? "Center" : "Right")))
{
VerPosition = (vp == 0 ? TextCommand.VerPositions.Top : (vp == 1 ? TextCommand.VerPositions.Middle : TextCommand.VerPositions.Bottom)),
HorPosition = (hp == 0 ? TextCommand.HorPositions.Left : (hp == 1 ? TextCommand.HorPositions.Center : TextCommand.HorPositions.Right)),
TextAlignment = (ta == 0 ? TextCommand.TextAlignments.Left : (ta == 1 ? TextCommand.TextAlignments.Center : TextCommand.TextAlignments.Right)),
Movement = AbsCmdPosition.Movements.None
};
controller.AddCommand(testText);
PauseCommand pause = new PauseCommand(1f);
controller.AddCommand(pause);
}
}
}
// Clear
controller.AddCommand(new ClearCommand());
// Basic multiple line scrolling text
string[] multiLine = new string[] { "Welcome", "back", "to 90s" };
TextCommand text = new TextCommand(multiLine)
{
Font = TextCommand.Fonts.Large,
Movement = AbsCmdPosition.Movements.MoveUpAndStop,
DotsPerSecond = 20,
VerPosition = AbsCmdPosition.VerPositions.Top,
HorPosition = AbsCmdPosition.HorPositions.Left
};
controller.AddCommand(text);
// Add callback "ScrollDone" that is called when Controller reaches this command
controller.AddCommand(new CallbackCommand(ScrollDone));
wordsToRandomPositions = false;
}
public MainViewModel()
{
timer = ServiceLocator.Current.GetInstance <ITimerService>();
timer.Tick += Timer_Tick;
timer.Start(new TimeSpan(0, 0, 0, 0, 001));
initializeSimulation();
X = 400;
Y = 400;
isRandomPlacement = false;
this.setXAndY();
Add = new AddBoidCommand(this);
Exit = new ExitCommand(this);
Pause = new PauseCommand(this);
Sliders = new SliderHandler(this);
ChangePlacement = new PlacementCommand(this);
}
private void PlayPauseButton_Click(object sender, RoutedEventArgs e)
{
if (!MediaPlaying)
{
Play();
if (PlayCommand != null && PlayCommand.CanExecute(EMPTY_PARAMETER))
{
PlayCommand.Execute(EMPTY_PARAMETER);
}
}
else
{
Pause();
if (PauseCommand != null && PauseCommand.CanExecute(EMPTY_PARAMETER))
{
PauseCommand.Execute(EMPTY_PARAMETER);
}
}
}
public DownloadingViewModel(IUnityContainer container) : base(container)
{
PauseAllCommand = new RelayCommand(() => TransferTasks.ForEach(item =>
{
if (PauseCommand.CanExecute(item))
{
PauseCommand.Execute(item);
}
}),
() => TransferTasks?.Any() ?? false);
CancelAllCommand = new RelayCommand(() => TransferTasks.ForEach(item =>
{
if (CancelCommand.CanExecute(item))
{
CancelCommand.Execute(item);
}
}),
() => TransferTasks?.Any() ?? false);
}
public ReactiveTimerViewModel(ReactiveTimerModel _model)
{
Model = _model.AddTo(DisposeCollection);
ReadOnlyReactiveTimer =
Observable.Merge(
Model.ReactiveTimer,
Model.ChangeStop().Select(_ => (long)0)
).ToReadOnlyReactivePropertySlim()
.AddTo(DisposeCollection);
StartCommand = Model.CanStart().ToReactiveCommand().AddTo(DisposeCollection);
StartCommand.Subscribe(start).AddTo(DisposeCollection);
PauseCommand = Model.CanPause().ToReactiveCommand().AddTo(DisposeCollection);
PauseCommand.Subscribe(pause).AddTo(DisposeCollection);
StopCommand = Model.CanStop().ToReactiveCommand().AddTo(DisposeCollection);
StopCommand.Subscribe(stop).AddTo(DisposeCollection);
}
void Start()
{
// Get controller
controller = dotMatrix.GetController();
controller.DefaultSpeedDotsPerSecond = 45f;
// Set basic loop that is repeated forever
TextCommand text = new TextCommand("Bus Line 42A")
{
Movement = TextCommand.Movements.MoveUpAndStop,
DotsPerSecond = 25f,
Repeat = true
};
PauseCommand pause = new PauseCommand(7f)
{
Repeat = true
};
ClearCommand clear = new ClearCommand()
{
Method = ClearCommand.Methods.MoveUp,
DotsPerSecond = 25f,
Repeat = true
};
nextStopMessage = new TextCommand("(placeholder)");
controller.AddCommand(text);
controller.AddCommand(pause);
controller.AddCommand(clear);
controller.AddCommand(nextStopMessage);
// Set first next stop
setRandomNextStop();
}
public Singleplayer()
{
playfield = new PlayField();
ball = new Ball();
paddle = new Paddle();
scoreboard = new ScoreBoard();
timer = new DispatcherTimer();
timer.Interval = new TimeSpan(0, 0, 0, 0, 10);
timer.IsEnabled = false;
timer.Tick += timer_Tick;
StartCommand = new StartCommand(this);
StopCommand = new StopCommand(this);
PlayCommand = new PlayCommand(this);
PauseCommand = new PauseCommand(this);
MoveLeftCommand = new MoveLeftCommand(this);
MoveRightCommand = new MoveRightCommand(this);
StopMovingCommand = new StopMovingCommand(this);
InitializeGame();
}
private void ProcessPauseRequest(PauseCommand request) {
switch (request) {
case PauseCommand.AutoPause:
if (PauseState == PauseState.Paused) { return; }
if (PauseState == PauseState.AutoPaused) {
D.Warn("Attempt to GuiAutoPause when already paused.");
return;
}
PauseState = PauseState.AutoPaused;
break;
case PauseCommand.AutoResume:
if (PauseState == PauseState.Paused) { return; }
if (PauseState == PauseState.NotPaused) {
D.Warn("Attempt to GuiAutoResume when not paused.");
return;
}
PauseState = Common.PauseState.NotPaused;
break;
case PauseCommand.ManualPause:
if (PauseState == PauseState.Paused) {
D.Warn("Attempt to PriorityPause when already paused.");
return;
}
PauseState = PauseState.Paused;
break;
case PauseCommand.ManualResume:
if (PauseState == PauseState.NotPaused) {
D.Warn("Atttempt to PriorityResume when not paused.");
return;
}
PauseState = PauseState.NotPaused;
break;
case PauseCommand.None:
default:
throw new NotImplementedException(ErrorMessages.UnanticipatedSwitchValue.Inject(request));
}
}
