private void Stop() { Elapsed = TimeSpan.FromSeconds(0); _cancelationSource?.Cancel(); _cancelationSource = null; StartCommand.RaiseCanExecuteChanged(); }
private async Task StartService(ServiceViewModel service, bool start) { try { var svc = service.Service; IsBusy = true; if (start) { svc.Start(); } else { svc.Stop(); } await Task.Run(() => { svc.WaitForStatus(start ? ServiceControllerStatus.Running : ServiceControllerStatus.Stopped, TimeSpan.FromSeconds(10)); }); } catch (System.ServiceProcess.TimeoutException) { UI.MessageBoxService.ShowMessage("Operation timed out.", Constants.AppName); } catch (Exception ex) { UI.MessageBoxService.ShowMessage($"Error: {ex.Message}", Constants.AppName); } finally { IsBusy = false; service.Refresh(); StartCommand.RaiseCanExecuteChanged(); StopCommand.RaiseCanExecuteChanged(); } }
private void UpdateFromModel(Model.Models.Tournament tournament) { //Set values _name = tournament.Name; _startDate = tournament.StartTime ?? DateTime.Now; _description = tournament.Description; _maximumMatchDururationInMinutes = tournament.MatchDuration ?? 30; _teamCount = Model.TeamCount ?? 16; //Raise property changed for values RaisePropertyChanged(() => Name); RaisePropertyChanged(() => Description); RaisePropertyChanged(() => MaximumMatchDurationInMinutes); RaisePropertyChanged(() => TeamCount); //Raise property changed for calculated values RaisePropertyChanged(() => StartDate); RaisePropertyChanged(() => StartTime); RaisePropertyChanged(() => State); RaisePropertyChanged(() => FinalMatch); RaisePropertyChanged(() => Matches); RaisePropertyChanged(() => HasChanges); RaisePropertyChanged(() => TournamentEditable); //Raise property changed for commands SaveChangesCommand.RaiseCanExecuteChanged(); StartCommand.RaiseCanExecuteChanged(); AddTeamCommand.RaiseCanExecuteChanged(); RemoveTeamCommand.RaiseCanExecuteChanged(); AddPlayAreaCommand.RaiseCanExecuteChanged(); RemovePlayAreaCommand.RaiseCanExecuteChanged(); GenerateWinnerCertificatesCommand.RaiseCanExecuteChanged(); }
public async Task Start() { if (ActionDescription == CancelDownload) { _cancellationTokenSource.Cancel(); return; } ActionDescription = CancelDownload; Status = "Downloading"; try { await DownloadFFMpeg.DownloadArchive(P => { Progress = P; Status = $"Downloading ({P}%)"; }, Settings.Proxy.GetWebProxy(), _cancellationTokenSource.Token); } catch (WebException webException) when(webException.Status == WebExceptionStatus.RequestCanceled) { Status = "Cancelled"; return; } catch (Exception e) { Status = $"Failed - {e.Message}"; return; } _cancellationTokenSource.Dispose(); // No cancelling after download StartCommand.RaiseCanExecuteChanged(false); Status = "Extracting"; try { await DownloadFFMpeg.ExtractTo(TargetFolder); } catch (UnauthorizedAccessException) { Status = "Can't extract to specified directory"; return; } catch { Status = "Extraction failed"; return; } // Update FFMpeg folder setting Settings.FFMpeg.FolderPath = TargetFolder; Status = "Done"; }
private void Task_PropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e) { if ("Status".Equals(e.PropertyName)) { StartCommand.RaiseCanExecuteChanged(); } }
private void CanChangeStage() { if (canCut) { CutCommand.RaiseCanExecuteChanged(); } else if (canFlowering) { FloweringStageCommand.RaiseCanExecuteChanged(); } else if (canGrowth) { GrowthStageCommand.RaiseCanExecuteChanged(); } else if (canGermination) { GerminationStageCommand.RaiseCanExecuteChanged(); } else if (canSeed) { SeedStageCommand.RaiseCanExecuteChanged(); } else if (canStart) { StartCommand.RaiseCanExecuteChanged(); } }
private void StopwatchStateChanged() { StartCommand.RaiseCanExecuteChanged(); StopCommand.RaiseCanExecuteChanged(); ResetCommand.RaiseCanExecuteChanged(); LapCommand.RaiseCanExecuteChanged(); }
private void RefreshCamCommands() { ScanCommand.RaiseCanExecuteChanged(); StartCommand.RaiseCanExecuteChanged(); StopCommand.RaiseCanExecuteChanged(); RefreshCommand.RaiseCanExecuteChanged(); }
private async void Start() { try { CancellationTokenSource = new CancellationTokenSource(); RunTask = true; StartCommand.RaiseCanExecuteChanged(); CancelCommand.RaiseCanExecuteChanged(); var tasks = new List <Task>(); tasks.AddRange(new List <Task>() { InitializeProgressBar(ProgressBarOneText, new Progress <int>(p => ProgressBarOneValue = p), CancellationTokenSource.Token), InitializeProgressBar(ProgressBarTwoText, new Progress <int>(p => ProgressBarTwoValue = p), CancellationTokenSource.Token), InitializeProgressBar(ProgressBarThreeText, new Progress <int>(p => ProgressBarThreeValue = p), CancellationTokenSource.Token), }); await Task.WhenAll(tasks); } catch (OperationCanceledException) { } finally { RunTask = false; StartCommand.RaiseCanExecuteChanged(); CancelCommand.RaiseCanExecuteChanged(); } }
private void RaiseCanExecute() { StartCommand.RaiseCanExecuteChanged(); RestoreCommand.RaiseCanExecuteChanged(); StopCommand.RaiseCanExecuteChanged(); SuspendCommand.RaiseCanExecuteChanged(); ResumeCommand.RaiseCanExecuteChanged(); }
private void RaiseCanExecuteChanged() { StartCommand.RaiseCanExecuteChanged(); StopCommand.RaiseCanExecuteChanged(); SettingsCommand.RaiseCanExecuteChanged(); RaiseCanExecuteIncrDecrChanged(); }
void StatusUpdate() { StartCommand.RaiseCanExecuteChanged(); StopCommand.RaiseCanExecuteChanged(); Time = _connectionController.TimeSeconds; Amount = _connectionController.Amount; Status = _connectionController.Status; }
private void pingable_PingStatsUpdated(object sender, EventArgs e) { Application.Current.Dispatcher.Invoke(() => { StartCommand.RaiseCanExecuteChanged(); StopCommand.RaiseCanExecuteChanged(); }); }
private void RefreshCommands() { InstallCommand.RaiseCanExecuteChanged(); UninstallCommand.RaiseCanExecuteChanged(); StartCommand.RaiseCanExecuteChanged(); StopCommand.RaiseCanExecuteChanged(); RaisePropertyChanged("ServiceStatus"); RaisePropertyChanged("IsWorking"); }
private void Stop(object o) { IsNotStarted = true; StartCommand.RaiseCanExecuteChanged(); StopCommand.RaiseCanExecuteChanged(); token.Cancel(); token.Dispose(); token = new CancellationTokenSource(); //MessageBox.Show("Stop dupa"); }
private void StartKeySpam() { worker = new BackgroundWorker(); //worker.WorkerReportsProgress = true; worker.WorkerSupportsCancellation = true; worker.DoWork += keySpamTask; worker.RunWorkerAsync(); running = true; StartCommand.RaiseCanExecuteChanged(); LoadSettingCommand.RaiseCanExecuteChanged(); }
private async System.Threading.Tasks.Task OnStart() { try { await _service.ChangeTaskStatusAsync(Task, TaskStatus.TaskInProgress); } catch (TimeoutException timeoutEx) { _eventAggregator.GetEvent <TimeoutErrorEvent>().Publish(timeoutEx); } StartCommand.RaiseCanExecuteChanged(); }
private void Cancel() { if (CancellationTokenSource != null) { CancellationTokenSource.Cancel(); } RunTask = false; StartCommand.RaiseCanExecuteChanged(); CancelCommand.RaiseCanExecuteChanged(); }
public void StartCounter() { Background = Brushes.White; Current = StartTime; if (_cancelationSource == null) { _cancelationSource = new CancellationTokenSource(); RunPeriodic(100, _cancelationSource.Token, UpdateCounter).ConfigureAwait(true); StopCommand.RaiseCanExecuteChanged(); StartCommand.RaiseCanExecuteChanged(); } }
private async void OnStop() { _captureStarted = false; capture.Dispose(); capture = null; //PipelineResult = new PipelineResult(); StartCommand.RaiseCanExecuteChanged(); StopCommand.RaiseCanExecuteChanged(); TakeScreenShotCommand.RaiseCanExecuteChanged(); CalibrateColorSkinCommand.RaiseCanExecuteChanged(); ActivateCalibrateColorSkinCommand.RaiseCanExecuteChanged(); }
private void OnComplete(bool?selected) { if (selected == true) { service.CompleteTask(Task); } else if (selected == false) { service.StartTask(Task); } CompleteCommand.RaiseCanExecuteChanged(); StartCommand.RaiseCanExecuteChanged(); }
public GeneralViewModel(IGoBot goBot, IPlayerPokemonViewModel playerPokemonViewModel, ILiveStatisticsViewModel liveStatisticsViewModel, ILogger logger) { _goBot = goBot; LiveStatisticsViewModel = liveStatisticsViewModel; PlayerPokemonViewModel = playerPokemonViewModel; Logger = logger; StartCommand = DelegateCommand.FromAsyncHandler(StartBot, CanStartBot); StopCommand = new DelegateCommand(StopBot, CanStopBot); StartCommand.RaiseCanExecuteChanged(); }
private void buildCommands() { StartCommand = new DelegateCommand(async() => { this.service.startAsync(); CancelCommand.RaiseCanExecuteChanged(); StartCommand.RaiseCanExecuteChanged(); }, () => !this.service.IsStarted()); CancelCommand = new DelegateCommand(async() => { this.service.cancelAsync(); CancelCommand.RaiseCanExecuteChanged(); StartCommand.RaiseCanExecuteChanged(); }, () => this.service.IsStarted()); }
private void LoadSetting() { //Microsoft.Win32.OpenFileDialog openFileDialog = new Microsoft.Win32.OpenFileDialog(); //openFileDialog.Filter = "Tian Files (*.tian)|*.tian|Dino Files (*.dino)|*.dino|3girl Files (*.3girl)|*.3girl|All Files (*.*)|*.*"; //if (openFileDialog.ShowDialog() == true) //{ // SettingFilePath = openFileDialog.FileName; //} //var dir = System.IO.Directory.GetCurrentDirectory(); //var ext = Path.GetExtension(SettingFilePath); foreach (string fileName in fileNames) { if (File.Exists(fileName)) { SettingFilePath = Path.Combine(System.IO.Directory.GetCurrentDirectory(), fileName); } } if (string.IsNullOrEmpty(SettingFilePath)) { MessageBox.Show("Invalid setting file!"); } StreamReader settingFile = new StreamReader(SettingFilePath); string line = ""; validKeyList = new List <IntPtr>(); ProcessName = settingFile.ReadLine(); while ((line = settingFile.ReadLine()) != null) { string[] lineArr = line.Split(','); if (lineArr.Length > 0 && keyDictionary.ContainsKey(lineArr[0])) { validKeyList.Add(keyDictionary[lineArr[0]]); } if (lineArr.Length == 2 && !string.IsNullOrEmpty(lineArr[1])) { try { delayTime = int.Parse(lineArr[1].Trim()); } catch (Exception e) { delayTime = 1; } delayTimeList.Add(delayTime); } } StartCommand.RaiseCanExecuteChanged(); }
private async void Start(object o) { IsNotStarted = false; StopCommand.RaiseCanExecuteChanged(); StartCommand.RaiseCanExecuteChanged(); trigger.InputDevice = selectedRecordDevice; trigger.OutputDevide = selectedPlayDevice; trigger.SetUpTrigger(selectedMode, selectedRecordDevice, selectedPlayDevice, treshold, minimalInterval, sameInterval, intervalCountEnabled, intervalCount, intervals, duration, delay, token.Token); try { await trigger.StartTrigger(); } catch (OperationCanceledException) { } Stop(null); //MessageBox.Show("Dupa"); }
public MainViewModel() { var app = App.Current as App; app.TimerEnableChanged += (s, a) => { TimerEnabled = a.TimerEnabled; StartCommand.RaiseCanExecuteChanged(); StopCommand.RaiseCanExecuteChanged(); TimerStatusMessage = "Web Chacker: " + (TimerEnabled ? "Enabled" : "Disabled"); }; app.Pulsed += (s, a) => { WorkingTimeMessage = a.WorkingMinutes != 1 ? $"Working: {a.WorkingMinutes} times (Last pulse: {DateTime.Now})" : $"Working: {a.WorkingMinutes} time (Last pulse: {DateTime.Now})"; }; }
private async System.Threading.Tasks.Task OnComplete(bool?selected) { try { if (selected == true) { await _service.ChangeTaskStatusAsync(Task, TaskStatus.TaskComplete); } else if (selected == false) { await _service.ChangeTaskStatusAsync(Task, TaskStatus.TaskNotStarted); } } catch (TimeoutException timeoutEx) { _eventAggregator.GetEvent <TimeoutErrorEvent>().Publish(timeoutEx); } CompleteCommand.RaiseCanExecuteChanged(); StartCommand.RaiseCanExecuteChanged(); }
private async Task Load() { capture = new VideoCapture(); capture.Open(0, VideoCaptureAPIs.ANY); if (!capture.IsOpened()) { return; } else { //backSub = OpenCvSharp.BackgroundSubtractorMOG.Create(); _currentFrame = (await ReadVideoStreamAsync()); //EqualizeHistogramFilter filter = new EqualizeHistogramFilter(new EqualizeHistogramConfig { IsActive = true }); //filter.Apply(colorMat); await GetBackground(); _captureStarted = true; StartCommand.RaiseCanExecuteChanged(); StopCommand.RaiseCanExecuteChanged(); TakeScreenShotCommand.RaiseCanExecuteChanged(); CalibrateBackgroundCommand.RaiseCanExecuteChanged(); CalibrateColorSkinCommand.RaiseCanExecuteChanged(); ActivateCalibrateColorSkinCommand.RaiseCanExecuteChanged(); Tracker.RunAsync(); while (_captureStarted) { _currentFrame = await ReadVideoStreamAsync(); await Pipeline.RunAsync(_currentFrame); //Tracker.Tracker.DetectHandFrom(Pipeline); DisplayOutput(Pipeline, Tracker, _showDebug); FrameRate.Tick(); } } }
private void StopKeySpam() { running = false; StartCommand.RaiseCanExecuteChanged(); worker.CancelAsync(); }
private void RaiseCommands() { StartCommand.RaiseCanExecuteChanged(); ListenCommand.RaiseCanExecuteChanged(); }