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();
}
