private void Copy(string sourcePath, string destinationPath) { byte[] buffer = new byte[1024 * 1024]; // 1MB buffer using (FileStream source = new FileStream(sourcePath, FileMode.Open, FileAccess.Read)) { using (FileStream dest = new FileStream(destinationPath, FileMode.CreateNew, FileAccess.Write)) { int currentBlockSize; while ((currentBlockSize = source.Read(buffer, 0, buffer.Length)) > 0) { _totalBytes += currentBlockSize; double persentage = _totalBytes * 100.0 / _totalLength; dest.Write(buffer, 0, currentBlockSize); var cancelFlag = false; OnProgressChanged?.Invoke(persentage, ref cancelFlag); if (cancelFlag) { // Delete dest file here break; } } } } CopyCompleted(); }
public AudioControlPanel() { InitializeComponent(); MusicProgress.OnProgressChanged += x => OnProgressChanged?.Invoke(x); VolumeBar.OnValueChanged += x => { if (x >= 25 && x < 75) { VolumeAdj.Content = FindResource("Volume_025"); } else if (x >= 75) { VolumeAdj.Content = FindResource("Volume_075"); } else if (x >= 1) { VolumeAdj.Content = FindResource("Volume_0"); } else { VolumeAdj.Content = FindResource("Volume_off"); } OnVolumeChanged?.Invoke(x); }; }
private void QueueInvokeProgressChanged(ISampleProvider sampleProvider, float progress) { eventInvokeQueue.Enqueue(() => OnProgressChanged?.Invoke(this, new ProgressChangedEventArgs(sampleProvider, progress)) ); }
public void BeginProcessing() { OnProgressChanged?.Invoke(0); //Read and load excel to json objects var reader = new OpenXmlLoader(spreadSheetFilePath); reader.LoadExcelDataToJsonFile(); OnProgressChanged?.Invoke(20); var pdf = new PdfGeneratorEngine(); pdf.GenerateSalarySlipsPdfs(); OnProgressChanged?.Invoke(50); var poster = new EmailPoster(); poster.OnProgressChanged += (d) => { var progress = 50 + d; OnProgressChanged?.Invoke(progress); }; poster.SendEmails(); OnProgressFinished?.Invoke(this, new SendEmailsFinishedEventArgs() { FailedEmails = poster.ErrorEmails, SuccessEmails = poster.SuccessEmails }); }
public void OpenFastfile(string path) { OnProgressChanged?.Invoke(20); ffData = GetFFData(path); OnProgressChanged?.Invoke(40); zoneData = GetZoneData(); OnProgressChanged?.Invoke(60); assetData = GetAssetData(); OnProgressChanged?.Invoke(80); foreach (RawFileData r in assetData.RawFiles) { OnRawfileDiscovered?.Invoke(r.Index, r.Name, r.OriginalName, r.OriginalSize); } OnProgressChanged?.Invoke(100); foreach (LocalizedStringData ls in assetData.LocalizedString) { OnLocalizedStringDiscovered?.Invoke(ls.Index, ls.Prefix, ls.Key); } OnProgressChanged?.Invoke(0); }
//----------------------------- protected void invokeProgressChanged(double progress) { if (OnProgressChanged != null) { OnProgressChanged.Invoke(progress); } }
public ValidationResults Validate(CRMSolution solution) { ValidationResults allValidatorsResult = new ValidationResults(); if (Validators == null || Validators.Count == 0) { throw new InvalidOperationException("No Validators exist, please change the validation settings first"); } //publish all customizations first if the settings allow it if (MySettings.AlwaysPublish) { OnProgressChanged?.Invoke(this, new ProgressEventArgs("Publishing customizations")); PublishAllXmlRequest publishRequest = new PublishAllXmlRequest(); CRMService.Execute(publishRequest); } // start the validators foreach (IValidator validator in Validators) { validator.OnValidatorError += (s, e) => { OnError?.Invoke(s, e); }; validator.OnValidatorProgress += (s, e) => { OnProgressChanged?.Invoke(s, new ProgressEventArgs(e.Message)); }; ValidationResults validatorResult = validator.Validate(); allValidatorsResult.AddResultSet(validatorResult); } return(allValidatorsResult); }
public async Task CopyAsync() { const int bufferSize = 1024 * 1024; var buffer = new byte[bufferSize]; foreach (var fileInfo in _sourceFiles) { var sourceFilePath = fileInfo.FullName; var referenceSourcePath = sourceFilePath.Replace(_sourcePath, ""); var checkChars = new[] { @"\", "/" }; if (checkChars.Any(x => referenceSourcePath.StartsWith(x))) { referenceSourcePath = referenceSourcePath.Substring(1); } var targetFilePath = Path.Combine(_targetPath, referenceSourcePath); var prevCopiedSize = 0L; var fileCopy = new FileCopy(sourceFilePath, targetFilePath); fileCopy.OnProgressChanged += (copiedSize, totalSize, progress) => { Interlocked.Add(ref TotalCopiedSize, copiedSize - prevCopiedSize); OnProgressChanged?.Invoke(TotalCopiedSize, TotalSize, TotalProgress); prevCopiedSize = copiedSize; }; await fileCopy.CopyAsync(); } OnComplete?.Invoke(); }
public void Copy() { byte[] buffer = new byte[1024 * 1024]; // 1MB buffer bool cancel = false; using (FileStream oldFile = new FileStream(oldPath, FileMode.Open, FileAccess.Read)) { long fileLength = oldFile.Length; using (FileStream newFile = new FileStream(newPath, FileMode.CreateNew, FileAccess.Write)) { long totalBytes = 0; int currentBlockSize = 0; while ((currentBlockSize = oldFile.Read(buffer, 0, buffer.Length)) > 0) { totalBytes += currentBlockSize; double persentage = (double)totalBytes * 100.0 / fileLength; newFile.Write(buffer, 0, currentBlockSize); cancel = false; OnProgressChanged?.Invoke(persentage, ref cancel); if (cancel) { break; } } OnComplete?.Invoke(); } } }
private void _downloadProgressChanged(object sender, long bytesReceived) { _downloadedAmount = bytesReceived; var progress = (int)((_totalDownloadedAmount + _downloadedAmount) / (double)TotalAmountToDownload * 100); OnProgressChanged?.Invoke(this, progress); }
bool HashFiles() { foreach (var fileSystemItem in fileSystemItems) { OnProgressChanged?.Invoke(this, fileSystemItem.name); manualResetEvent.WaitOne(); if (backgroundWorker.CancellationPending) { return(false); } if (fileSystemItem.type == FileSystemItemType.Directory || FileSystemItemAccess.Default != fileSystemItem.access) { hashWriter.WriteResultLine(new HashedFileSystemItem(fileSystemItem, hash: null)); } else { if (!HashAndAddToResult(fileSystemItem)) { return(false); } } } hashWriter.CloseFile(); return(true); }
private void FFmpegProcess_Process_Output(string data) { if (data == null) { return; } try { receivedMessagesLog.AppendLine(data); ConversionCompleteEventArgs convertCompleteEvent; ConvertProgressEventArgs progressEvent; if ((progressEvent = RegexEngine.IsProgressData(data)) != null) { progressEvent.TotalDuration = metadata.Duration; progress = progressEvent.ProcessedDuration.TotalSeconds / progressEvent.TotalDuration.TotalSeconds * 100.0; OnProgressChanged?.Invoke(this, progressEvent); } } catch (Exception ex) { Stop(); } }
public void Increment() { if (_currentValue + 1 <= _maxValue) { Interlocked.Increment(ref _currentValue); OnProgressChanged?.Invoke(this, null); } }
private void _workerProgressChanged(object sender, ProgressChangedEventArgs e) { if (e.ProgressPercentage == 100) { OnDownloadComplete?.Invoke(this); } OnProgressChanged?.Invoke(this, e.ProgressPercentage); }
private void ReportMissingItem(HashedFileSystemItem hashedFileSystemItemA, string file) { string result = hashedFileSystemItemA.name + "," + hashedFileSystemItemA.type + ",MISSING_FROM," + file; if (WriteOutputToFile) { output.WriteLine(result); } OnProgressChanged?.Invoke(this, hashedFileSystemItemA.name + "(" + hashedFileSystemItemA.type + ")" + " missing from " + file); }
private void OnProgressChangedInternal(int progress, int maxProgress) { try { OnProgressChanged?.Invoke((double)_Progress / _MaxProgress); } catch (Exception exception) { _Log.WriteException(exception); } }
protected void IncrementProgress(int percentage) { log.Debug($"Task '{Title}' (Id: {TaskId}) - Progression: {ProgressionPercentage}"); ProgressionPercentage = percentage; OnProgressChanged?.Invoke(this, percentage); if (percentage == 100) { OnTaskFinished?.Invoke(this, System.EventArgs.Empty); } }
public FileDownloader(string downloadUrl, string savePath) { DownloadUrl = downloadUrl; SavePath = savePath; _downloadClient.DownloadFileCompleted += (s, e) => { OnDownloadCompleted?.Invoke(!e.Cancelled && e.Error == null); }; _downloadClient.DownloadProgressChanged += (sender, args) => OnProgressChanged?.Invoke(args.ProgressPercentage, "Downloading..."); }
public void SaveFastfile() { OnProgressChanged?.Invoke(33); WriteAssetData(); OnProgressChanged?.Invoke(66); WriteZoneData(); OnProgressChanged?.Invoke(100); WriteFastFile(); OnProgressChanged?.Invoke(0); }
private void NotifySubscribers(int totalUnits, int currentProgress, string description) { if (OnProgressChanged != null) { OnProgressChanged.Invoke(this, new ProgressEventArgs { Type = ProgressEventArgs.ProcessorType.ModelBuilder, Description = description, CurrentProgress = currentProgress, TotalUnits = totalUnits }); } }
public void CompressZlibArchive(string input, string output) { OnProgressChanged?.Invoke(10); byte[] data = File.ReadAllBytes(input); OnProgressChanged?.Invoke(90); data = ZlibInflate(data); OnProgressChanged?.Invoke(100); File.WriteAllBytes(output, data); OnProgressChanged?.Invoke(0); }
public void ExtractAllRawfiles(string baseDir) { for (int i = 0; i < assetData.RawFiles.Count; ++i) { string filePath = baseDir + "\\" + assetData.RawFiles[i].Name.Replace('/', '\\'); int progress = (i * 100) / assetData.RawFiles.Count; OnProgressChanged?.Invoke(progress + 1); OnProgressChanged?.Invoke(progress); ExtractRawFile(filePath, i); } }
private void ProcessOnProgressChanged(ProgressEventArgs e) { if (OnProgressChanged != null) { OnProgressChanged.Invoke(this, new ProgressEventArgs { Type = e.Type, Description = e.Description, CurrentProgress = e.CurrentProgress, TotalUnits = e.TotalUnits }); } }
private void setProgress(int currentIndex, string currentFileName, int totalNumberOfFiles) { if (totalNumberOfFiles == 0 || currentIndex > totalNumberOfFiles) { OnProgressChanged?.Invoke(totalNumberOfFiles, String.Empty, totalNumberOfFiles, 100); OnCompleted?.Invoke(); } else { var perc = (((float)currentIndex / (float)totalNumberOfFiles) * 100); var perv = (float)Math.Round(perc, 0); OnProgressChanged?.Invoke(currentIndex, currentFileName, totalNumberOfFiles, perc); } }
private void exporter_BatchExported(object sender, BatchExportedEventArgs e) { TotalExported = e.TotalExported; TotalProcessed = e.TotalProcessed; if (OnProgressChanged != null) { OnProgressChanged.Invoke(this, new ProgressEventArgs { Type = ProgressEventArgs.ProcessorType.TmExporter, Description = string.Empty, CurrentProgress = e.TotalExported, TotalUnits = TotalUnits }); } }
public void SaveAsFastfile(string what, string where) { OnProgressChanged?.Invoke(33); byte[] decompressed = File.ReadAllBytes(what); OnProgressChanged?.Invoke(66); byte[] compressed = ZlibInflate(decompressed); OnProgressChanged?.Invoke(100); using (FileStream fs = new FileStream(where, FileMode.Create)) { fs.Write(FFData.HeaderIW3Unsigned, 0, FFData.HeaderIW3Unsigned.Length); fs.Write(FFData.HeaderIW3VersionUnsigned, 0, FFData.HeaderIW3VersionUnsigned.Length); fs.Write(compressed, 0, compressed.Length); } OnProgressChanged?.Invoke(0); }
public void DetectEvents() { if (Events.Count > 0) { return; } OnProgressChanged?.Invoke(0, "Detecting events..."); double count = Solution.Entries.Count; double progress = 0; int done = 0; UnknownCount = 0; foreach (var e in Solution.Entries) { var message = e.Message ?? e.Error.ParsedMessage; if (message == null) { throw new NullReferenceException("Message is not defined"); } var s_name = Solution.TryGetSenderNameFromMessage(message); var s_id = Solution.TryGetSenderIdFromMessage(message); var t_name = Solution.TryGetTargetNameFromMessage(message); var t_id = Solution.TryGetTargetIdFromMessage(message); var source = Solution.TryGetBrokerByNameOrId(s_name, s_id); var target = Solution.TryGetBrokerByNameOrId(t_name, t_id); if (source == null || target == null) { UnknownCount++; Solution.LinkingErrors.Add(new Error() { Message = source == null ? "Unknown source id and name" : "Unknown target id and name", Content = e.Content, DateTime = e.DateTime, Direction = e.Direction, ErrorType = ErrorType.Syntax, Kind = e.Kind, ParsedMessage = message, Index = e.Index, RawLogLine = e.RawLogLine, Exception = new NullReferenceException("Unknown target or source") }); } Events.Add(new Event() { Entry = e, Source = source, Target = target }); done++; progress = (done / count) * 100; OnProgressChanged?.Invoke(progress, "Linking events..."); } }
private void ReportDiff(HashedFileSystemItem hashedFileSystemItemA, HashedFileSystemItem hashedFileSystemItemB) { string result = hashedFileSystemItemA.name + "," + hashedFileSystemItemA.type + ",HASH_MISMATCH," + File1 + "," + hashedFileSystemItemA.Hash + "," + File2 + "," + hashedFileSystemItemB.Hash; if (WriteOutputToFile) { output.WriteLine(result); } string message = "Hash check failed : " + hashedFileSystemItemA.name + "(" + hashedFileSystemItemA.type + ")" + " : " + "\n" + File1 + " : " + hashedFileSystemItemA.Hash + "\n" + File2 + " : " + hashedFileSystemItemB.Hash; OnProgressChanged?.Invoke(this, message); }
private void DownloadNewFiles(List <string> list) { using (WebClient webClient = new WebClient() { Encoding = Encoding.UTF8 }) { list.ForEach(o => { TryRun(new Action(() => { Directory.CreateDirectory(Path.Combine(Environment.CurrentDirectory, ".updatemachine", o.Substring(0, o.LastIndexOf('/') <= 0 ? 0 : o.LastIndexOf('/')))); webClient.DownloadFile(Path.Combine(url, o).Replace('\\', '/'), Path.Combine(Environment.CurrentDirectory, ".updatemachine", o)); }), 3); OnProgressChanged?.Invoke(list.IndexOf(o) + 1, list.Count); }); } }
/// <summary> /// Update progress /// </summary> private void UpdateProgress() { //get total progress float totalProgress = 0; foreach (IProgressSource <float> tracker in _trackersCollection) { totalProgress += tracker.Progress; } //get normalized progress totalProgress = _count > 0 ? Mathf.Clamp01(totalProgress / _count) : 1f; //set progress if changed if (!Mathf.Approximately(Progress, totalProgress)) { Progress = totalProgress; OnProgressChanged?.Invoke(Progress); } }