private void doProgressChanged(object sender, System.ComponentModel.ProgressChangedEventArgs e) { if (ProgressChanged != null) { ProgressChanged.Invoke(sender, e); } }
private void HandleProgressChanged(object sender, ProgressChangedEventArgs e) { if (ProgressChanged != null) { ProgressChanged.Invoke(this, e); } }
private void _backgroundWorker_ProgressChanged(object sender, ProgressChangedEventArgs e) { if (ProgressChanged != null) { ProgressChanged.Invoke(this, e); } }
protected virtual void OnProgressChanged(string message, int progress) { if (ProgressChanged != null) { ProgressChanged.Invoke(this, new ProgressChangedEventArgs(message, progress)); } }
private void OnProgressEvent(ProgressEventArgs eventArgs) { if (ProgressChanged != null) { ProgressChanged.Invoke(this, eventArgs); } }
private void SharedTestTimerOnElapsed(object sender, ElapsedEventArgs e) { if (IsTestRunning) { if (IsTestCanceled) { IsTestRunning = false; IsTestCanceled = true; TestComplete.Invoke(TestSysResult.Canceled); } else if (e.SignalTime - BeginTime > _testTimeout) { // timeout IsTestRunning = false; ProgressChanged.Invoke(100, TestSysStepResult.Bad, "МУК не включает Emerson"); TestComplete.Invoke(TestSysResult.Fail); } else { if (LastReceivedData.Diagnostic3Parsed.MukIsSwitchingEmersionOn) { IsTestRunning = false; LastReceivedData = null; ProgressChanged.Invoke(100, TestSysStepResult.Good, "Включение Emerson осуществлено"); TestComplete.Invoke(TestSysResult.Success); } } } }
public ScreenCaptureWorker(IScreenCaptureService screenCaptureService, Size canvasBounds, int captureFps, int idleTimeout) : base(idleTimeout) { _screenCaptureService = screenCaptureService; CaptureInterval = CalculateHaltInterval(captureFps); CanvasBounds = canvasBounds; ProgressHandler = new Progress <ScreenCaptureProgressArgs>(progressArgs => { ProgressChanged.Invoke(this, progressArgs); }); }
public ScreenCaptureWorker(IScreenCaptureService screenCaptureService, int captureInterval) { _screenCaptureService = screenCaptureService; CaptureInterval = captureInterval; _progressHandler = new Progress <ScreenCaptureProgressArgs>(progressArgs => { ProgressChanged.Invoke(this, progressArgs); }); }
private void EndGetStreamCallback(IAsyncResult ar) { FtpState state = (FtpState)ar.AsyncState; Stream requestStream = null; // End the asynchronous call to get the request stream. try { requestStream = state.Request.EndGetRequestStream(ar); // Copy the file contents to the request stream. const int bufferLength = 2048; byte[] buffer = new byte[bufferLength]; int count = 0; int readBytes = 0; FileStream stream = File.OpenRead(state.FileName); do { readBytes = stream.Read(buffer, 0, bufferLength); requestStream.Write(buffer, 0, readBytes); count += readBytes; Ctrl.Invoke(new Action(delegate() { if (ProgressChanged != null) { ProgressChanged.Invoke(this, new ProgressEventArgs(stream.Length, count, readBytes)); } })); }while (readBytes != 0); stream.Close(); Console.WriteLine("Writing {0} bytes to the stream.", count); // IMPORTANT: Close the request stream before sending the request. requestStream.Close(); // Asynchronously get the response to the upload request. state.Request.BeginGetResponse( new AsyncCallback(EndGetResponseCallback), state ); } // Return exceptions to the main application thread. catch (Exception e) { if (UploadError != null) { ThreadExceptionEventArgs arg = new ThreadExceptionEventArgs(e); UploadError.Invoke(this, arg); } } }
/// <summary> /// Creates the entire database of songs based on user's music collection /// </summary> /// <returns></returns> public static async Task CheckMusicCollection() { if (LoadCollectionCompleted == false) { return; } LoadCollectionCompleted = false; IReadOnlyList <StorageFile> musicFiles = await StorageHelper.ScanFolder(KnownFolders.MusicLibrary); bool result = RefreshDatabase(); StorageFolder coversFolder = await ApplicationData.Current.LocalFolder.CreateFolderAsync("Covers", CreationCollisionOption.OpenIfExists); Song aux = null; int totalCount = musicFiles.Count; double currentValue = 0; double percentagePerItem = Convert.ToDouble(100) / Convert.ToDouble(totalCount); List <Song> listOfSongs = new List <Song>(); foreach (StorageFile file in musicFiles) { if (Stop) { Stop = false; break; } aux = await CreateSongObjectByFile(file, listOfSongs); if (aux != null) { listOfSongs.Add(aux); } currentValue = currentValue + percentagePerItem; ProgressChanged.Invoke(Convert.ToInt16(currentValue), true); } ProgressChanged.Invoke(100, false); ApplicationSettings.IsCollectionLoaded = true; LoadCollectionCompleted = true; }
void onTick() { if (workPermited) { ticksDone++; ProgressChanged.Invoke(); if (ticksDone >= ticksNeed) { ticksDone = 0; Timer.OneSecond -= onTick; output.AddOutput(); startTicking(); } } }
public IEnumerable <DbAlbum> ReadAlbums() { this.StartedReadingAlbums.Invoke(); int counter = 0; foreach (var album in _deserializedAlbums) { counter++; yield return(album); ProgressChanged.Invoke(counter, _deserializedAlbums.Count); } FinishedReadingAlbums.Invoke(); }
void IYieldFrame.Update(float delta, uint frameCount) { _time -= delta; Value01 = 1f - Mathf.Clamp01(_time / _seconds); if (ProgressChanged != null) { ProgressChanged.Invoke(Value01); } if (!keepWaiting) { if (Complete != null) { Complete.Invoke(); } } }
public IEnumerable <DbAlbum> ReadAlbums(SortOrder sortOrder) { this.StartedReadingAlbums.Invoke(); uint sortAtom = 0; switch (sortOrder) { case SortOrder.DateAdded: sortAtom = (uint)SchemaMap.kiIndex_DateAdded; break; case SortOrder.Album: sortAtom = (uint)SchemaMap.kiIndex_Title; break; case SortOrder.Artist: sortAtom = (uint)SchemaMap.kiIndex_DisplayArtist; break; default: throw new ArgumentOutOfRangeException("sortOrder"); } //querying all albums, creates a property bag inside this method to query the database ZuneQueryList albums = GetAlbumQueryListSorted(sortAtom); albums.AddRef(); var uniqueIds = albums.GetUniqueIds(); for (int i = 0; i < uniqueIds.Count; i++) { object uniqueId = uniqueIds[i]; yield return(GetAlbumMin((int)uniqueId)); ProgressChanged.Invoke(i, uniqueIds.Count - 1); } FinishedReadingAlbums.Invoke(); albums.Release(); albums.Dispose(); }
private void informAboutProgressChange(int depencyIndex, string depencyName, int progress = -1) { if (ProgressChanged == null) { return; } ProgressState ps = new ProgressState() { Progress = progress }; if (progress < 0) { ps.AllDepenciesCount = _allDependencies.Count; ps.CurrentDepencyName = depencyName; ps.Extracting = false; ps.FinishedCount = depencyIndex; } Task.Run(() => ProgressChanged.Invoke(ps)); }
public void OnProgressChanged(ProgressChangedEventArgs e) { ProgressChanged.Invoke(this, e); }
protected virtual void OnProgressChanged(object sender, ProgressChangedArgs e) => ProgressChanged?.Invoke(sender, e);
private void OnProgressChanged(ProgressData progressData) => ProgressChanged?.Invoke(this, progressData);
public void OnProgressChanged(SeekBar seekBar, int val, bool b) { ProgressChanged?.Invoke(seekBar, val, b); }
public void Report(double progress) { ProgressChanged.Invoke(this, new ProgressEventArgs(progress)); }
public void ReportAdd(long value) { Progress += value; ProgressChanged?.Invoke(Progress); }
public void Import(Project to, Project from, Mode mode = Mode.Group) { if (from == null) { throw new ArgumentNullException(nameof(from)); } if (to == null) { throw new ArgumentNullException(nameof(to)); } if (from.Equals(to)) { throw new FieldAccessException(); } var count = 0; int processes; void notifyProgress() { ProgressChanged.Invoke(1F * count / processes); } if (mode == Mode.Group) { processes = from.Groups.Count; if (from.Encryted) { processes += from.DailyAdmins.Count; from.DailyAdmins.ForEach((it) => { if (!to.DailyAdmins.Contains(it)) { to.DailyAdmins.Add(it); } count++; notifyProgress(); }); } foreach (Group g in from.Groups) { Group sameName = to.Groups.Find((it) => it.Name == g.Name); if (sameName == null) { var clone = g.Clone() as Group; clone.Record.Clear(); to.Groups.Add(clone); } else { bool cancel = false; switch (GroupDuplicated.Invoke(sameName, g)) { case DialogResult.Yes: foreach (Person p in g.People) { Person duplicate = sameName.People.Find((it) => it.Name == p.Name); if (duplicate == null) { sameName.People.Add(p); } else { switch (MemberDuplicated.Invoke(duplicate, p)) { case DialogResult.Yes: sameName.People.Remove(duplicate); sameName.People.Add(p); break; case DialogResult.Cancel: cancel = true; break; default: break; } } if (cancel) { break; } } if (!cancel) { sameName.InitalScore = g.InitalScore; sameName.ChosenColor = System.Drawing.Color.FromArgb(g.ChosenColor.ToArgb()); } break; case DialogResult.Cancel: cancel = true; break; default: break; } if (cancel) { break; } } count++; notifyProgress(); } } else { var people = new List <Person>(); foreach (Group g in from.Groups) { g.People.ForEach((person) => people.Add(person)); } processes = people.Count; foreach (Person person in people) { var find = to.FindPerson(person.ID); if (find != null) { person.Record.ForEach((r) => { if (!find.Group.Record.Exists((it) => it.Time == r.Time)) { find.Group.Record.Add(new Score(r.Value, r.Reason, find.ID, r.Time, to)); } }); } count++; notifyProgress(); } } }
private void OnProgressChanged(int current, int max, object data = null) { ProgressChanged?.Invoke(this, new Tuple <int, int, object>(current, max, data)); }
public FFmpegDownloadViewModel(FFmpegSettings FFmpegSettings, FFmpegDownloadModel DownloadModel, IFFmpegViewsProvider FFmpegViewsProvider, IMessageProvider MessageProvider) { this.FFmpegSettings = FFmpegSettings; _downloadModel = DownloadModel; _messageProvider = MessageProvider; StartCommand = _downloaderProgress .Select(M => M.State) .Select(M => M == FFmpegDownloaderState.Ready) .ToReactiveCommand() .WithSubscribe(async() => { var progress = new Progress <FFmpegDownloaderProgress>(M => _downloaderProgress.Value = M); _downloadTask = DownloadModel.Start(progress); var result = await _downloadTask; AfterDownload?.Invoke(result); }); CanCancel = _downloaderProgress .Select(M => M.State) .Select(M => M == FFmpegDownloaderState.Downloading) .ToReadOnlyReactivePropertySlim(); SelectFolderCommand = _downloaderProgress .Select(M => M.State) .Select(M => M == FFmpegDownloaderState.Ready) .ToReactiveCommand() .WithSubscribe(FFmpegViewsProvider.PickFolder); OpenFolderCommand = new ReactiveCommand() .WithSubscribe(() => { var path = FFmpegSettings.GetFolderPath(); if (Directory.Exists(path)) { Process.Start(path); } }); Status = _downloaderProgress .Select(M => { switch (M.State) { case FFmpegDownloaderState.Error: return(M.ErrorMessage); case FFmpegDownloaderState.Downloading: return($"{FFmpegDownloaderState.Downloading} ({M.DownloadProgress}%)"); default: return(M.State.ToString()); } }) .ToReadOnlyReactivePropertySlim(); Progress = _downloaderProgress .Where(M => M.State == FFmpegDownloaderState.Downloading) .Select(M => M.DownloadProgress) .ToReadOnlyReactivePropertySlim(); Progress.Subscribe(M => ProgressChanged?.Invoke(M)); InProgress = _downloaderProgress .Select(M => M.State) .Select(M => M == FFmpegDownloaderState.Downloading || M == FFmpegDownloaderState.Extracting) .ToReadOnlyReactivePropertySlim(); IsDone = _downloaderProgress .Select(M => M.State) .Select(M => M == FFmpegDownloaderState.Done || M == FFmpegDownloaderState.Cancelled || M == FFmpegDownloaderState.Error) .ToReadOnlyReactivePropertySlim(); }
private void Downloader_DownloadProgressChangedEvent(object sender, ProgressChangedEventArgs e) { ProgressChanged?.Invoke(this, e); }
private void progressChanged(DownloadOperation downloadOperation) { int progress = (int)(100 * ((double)downloadOperation.Progress.BytesReceived / (double)downloadOperation.Progress.TotalBytesToReceive)); ProgressChanged.Invoke(this, progress); }
private void Z_ProgressEvent(object sender, int e) { ProgressChanged?.Invoke(this, new ProgressChangedEventArgs(e, null)); }
protected void OnLoadProgressChanged(ProgressChangedEventArgs e) { ProgressChanged.Invoke(this, e); }
private void Szip_ProgressChange(object sender, ProgressChangedEventArgs e) { ProgressChanged?.Invoke(this, e); }
protected void ChangeProgress(Progress progress) { ProgressChanged?.Invoke(this, new EventArgs <Progress>(progress)); }