public bool Export() { if (!Initialize()) return false; EventResult result = EventResult.Success; try { BackgroundTask task = new BackgroundTask(DoExport, true); ProgressDialog.Show(task, DesktopWindow, true, ProgressBarStyle.Continuous); if (_canceled) result = EventResult.MinorFailure; return !_canceled; } catch { result = EventResult.MinorFailure; throw; } finally { AuditHelper.LogExportStudies(_exportedInstances, EventSource.CurrentUser, result); } }
public void AnonymizeStudy() { _component = new AnonymizeStudyComponent(Context.SelectedStudy); if (ApplicationComponentExitCode.Accepted == ApplicationComponent.LaunchAsDialog(Context.DesktopWindow, _component, SR.TitleAnonymizeStudy)) { if (LocalStorageMonitor.IsMaxUsedSpaceExceeded) { Context.DesktopWindow.ShowMessageBox(SR.MessageCannotAnonymizeMaxDiskUsageExceeded, MessageBoxActions.Ok); return; } BackgroundTask task = null; try { task = new BackgroundTask(Anonymize, false, Context.SelectedStudy); ProgressDialog.Show(task, Context.DesktopWindow, true); } catch(Exception e) { Platform.Log(LogLevel.Error, e); Context.DesktopWindow.ShowMessageBox(SR.MessageAnonymizeStudyFailed, MessageBoxActions.Ok); } finally { if (task != null) task.Dispose(); } } }
public ImageServerDbGenerator(ServerPartition partition, DateTime startDate, int totalStudies, int studiesPerDay, int percentWeekend) { _startDate = startDate; _totalStudies = totalStudies; _studiesPerDay = studiesPerDay; _percentWeekend = percentWeekend; _partition = partition; _backroundTask = new BackgroundTask(Run, true); }
public static bool Load(StudyFilterComponent component, IDesktopWindow desktopWindow, bool allowCancel, IEnumerable<string> paths, bool recursive) { bool success = false; BackgroundTask task = new BackgroundTask(LoadWorker, allowCancel, new State(component, paths, recursive)); task.Terminated += delegate(object sender, BackgroundTaskTerminatedEventArgs e) { success = e.Reason == BackgroundTaskTerminatedReason.Completed; }; ProgressDialog.Show(task, desktopWindow, true, ProgressBarStyle.Continuous); return success; }
public static void Create(IDesktopWindow desktopWindow, IImageViewer viewer) { IDisplaySet selectedDisplaySet = viewer.SelectedImageBox.DisplaySet; string name = String.Format("{0} - Dynamic TE", selectedDisplaySet.Name); IDisplaySet t2DisplaySet = new DisplaySet(name, ""); double currentSliceLocation = 0.0; BackgroundTask task = new BackgroundTask( delegate(IBackgroundTaskContext context) { int i = 0; foreach (IPresentationImage image in selectedDisplaySet.PresentationImages) { IImageSopProvider imageSopProvider = image as IImageSopProvider; if (imageSopProvider == null) continue; ImageSop imageSop = imageSopProvider.ImageSop; Frame frame = imageSopProvider.Frame; if (frame.SliceLocation != currentSliceLocation) { currentSliceLocation = frame.SliceLocation; try { DynamicTePresentationImage t2Image = CreateT2Image(imageSop, frame); t2DisplaySet.PresentationImages.Add(t2Image); } catch (Exception e) { Platform.Log(LogLevel.Error, e); desktopWindow.ShowMessageBox("Unable to create T2 series. Please check the log for details.", MessageBoxActions.Ok); break; } } string message = String.Format("Processing {0} of {1} images", i, selectedDisplaySet.PresentationImages.Count); i++; BackgroundTaskProgress progress = new BackgroundTaskProgress(i, selectedDisplaySet.PresentationImages.Count, message); context.ReportProgress(progress); } }, false); ProgressDialog.Show(task, desktopWindow, true, ProgressBarStyle.Blocks); viewer.LogicalWorkspace.ImageSets[0].DisplaySets.Add(t2DisplaySet); }
public ImageServerDbGenerator(string aeTitle, string host, int port, DateTime startDate, int totalStudies, int studiesPerDay, int percentWeekend) { _startDate = startDate; _totalStudies = totalStudies; _studiesPerDay = studiesPerDay; _percentWeekend = percentWeekend; _partition = null; _aeTitle = aeTitle; _host = host; _port = port; _backroundTask = new BackgroundTask(Run, true); }
protected void RetrieveAnnotationsFromAimService(object[] searchResults) { string errorMsg = null; BackgroundTask task = new BackgroundTask( delegate(IBackgroundTaskContext context) { try { int cnt = 0; BackgroundTaskProgress progress; List<string> tmpAnnotations = new List<string>(); aim_dotnet.DcmModel dcmModel = new aim_dotnet.DcmModel(); foreach (AIMSearchResult result in searchResults) { cnt++; if (result.RetrievedAnnotation == null) continue; progress = new BackgroundTaskProgress(cnt, searchResults.Length + 1, "Saving Annotation " + cnt); context.ReportProgress(progress); string tmpFileName = System.IO.Path.GetTempFileName(); dcmModel.WriteAnnotationToFile(result.RetrievedAnnotation, tmpFileName); tmpAnnotations.Add(tmpFileName); } dcmModel = null; if (tmpAnnotations.Count > 0) { progress = new BackgroundTaskProgress(searchResults.Length, searchResults.Length + 1, "Importing Annotations"); context.ReportProgress(progress); this.ImportDicomFiles(tmpAnnotations); } } catch (Exception ex) { errorMsg = ex.Message; Platform.Log(LogLevel.Error, ex, "Failed to import annotation(s)"); } context.Complete(null); }, true); ProgressDialog.Show(task, this.Context.DesktopWindow, true, ProgressBarStyle.Blocks); if (!string.IsNullOrEmpty(errorMsg)) this.Context.DesktopWindow.ShowMessageBox(errorMsg, MessageBoxActions.Ok); }
public void Load(string[] files, IDesktopWindow desktop, out bool cancelled) { Platform.CheckForNullReference(files, "files"); _total = 0; _failed = 0; bool userCancelled = false; if (desktop != null) { BackgroundTask task = new BackgroundTask( delegate(IBackgroundTaskContext context) { for (int i = 0; i < files.Length; i++) { LoadSop(files[i]); int percentComplete = (int)(((float)(i + 1) / files.Length) * 100); string message = String.Format(SR.MessageFormatOpeningImages, i, files.Length); BackgroundTaskProgress progress = new BackgroundTaskProgress(percentComplete, message); context.ReportProgress(progress); if (context.CancelRequested) { userCancelled = true; break; } } context.Complete(null); }, true); ProgressDialog.Show(task, desktop, true, ProgressBarStyle.Blocks); cancelled = userCancelled; } else { foreach (string file in files) LoadSop(file); cancelled = false; } if (Failed > 0) throw new LoadSopsException(Total, Failed); }
public void Open() { var studyLoaders = new List<IStudyLoader>(); int sopCount = 0; foreach (var studyItem in base.Context.SelectedStudies) { if (!studyItem.Server.IsSupported<IStudyLoader>()) return; var loader = studyItem.Server.GetService<IStudyLoader>(); studyLoaders.Add(loader); sopCount += loader.Start(new StudyLoaderArgs(studyItem.StudyInstanceUid, studyItem.Server)); } bool success = false; var component = new StudyFilterComponent {BulkOperationsMode = true}; var task = new BackgroundTask(c => { c.ReportProgress(new BackgroundTaskProgress(0, sopCount, SR.MessageLoading)); if (c.CancelRequested) c.Cancel(); int progress = 0; foreach (IStudyLoader localStudyLoader in studyLoaders) { Sop sop; while ((sop = localStudyLoader.LoadNextSop()) != null) { component.Items.Add(new SopDataSourceStudyItem(sop)); c.ReportProgress(new BackgroundTaskProgress(Math.Min(sopCount, ++progress) - 1, sopCount, SR.MessageLoading)); if (c.CancelRequested) c.Cancel(); sop.Dispose(); } } success = true; component.Refresh(true); c.Complete(); }, true); ProgressDialog.Show(task, this.Context.DesktopWindow, true, ProgressBarStyle.Continuous); if (success) { component.BulkOperationsMode = false; base.Context.DesktopWindow.Workspaces.AddNew(component, SR.TitleStudyFilters); } }
/// <summary> /// Releases all resources used by this <see cref="ProgressGraphic"/>. /// </summary> protected override void Dispose(bool disposing) { if (disposing) { _progressProvider = null; _synchronizationContext = null; if (_updateTask != null) { _updateTask.RequestCancel(); _updateTask = null; } } base.Dispose(disposing); }
/// <summary> /// Creates and executes a new <see cref="BackgroundTask"/> based on the specified arguments. /// </summary> /// <param name="method">The method to run in the background.</param> /// <param name="supportsCancel">Indicates whether the task supports cancellation or not.</param> /// <param name="terminateHandler">Method that will be called when the task terminates.</param> /// <param name="progressHandler">Optional method to handle progress updates, may be null.</param> /// <param name="userState">Optional state to be passed to the background task, may be null.</param> /// <returns>A running <see cref="BackgroundTask"/> object.</returns> public static BackgroundTask CreateAndRun( BackgroundTaskMethod method, bool supportsCancel, EventHandler <BackgroundTaskTerminatedEventArgs> terminateHandler, EventHandler <BackgroundTaskProgressEventArgs> progressHandler, object userState) { Platform.CheckForNullReference(method, "method"); Platform.CheckForNullReference(terminateHandler, "terminateHandler"); BackgroundTask task = new BackgroundTask(method, supportsCancel, userState); task.Terminated += terminateHandler; if (progressHandler != null) { task.ProgressUpdated += progressHandler; } task.Run(); return(task); }
public static bool Load(StudyFilterComponent component, IDesktopWindow desktopWindow, bool allowCancel, IEnumerable<string> paths, bool recursive) { BackgroundTaskTerminatedEventArgs evArgs = null; try { using (var task = new BackgroundTask(LoadWorker, allowCancel, new State(component, paths, recursive))) { task.Terminated += (s, e) => evArgs = e; ProgressDialog.Show(task, desktopWindow, true, ProgressBarStyle.Continuous); } } catch (Exception ex) { ExceptionHandler.Report(ex, desktopWindow); return false; } if (evArgs.Reason == BackgroundTaskTerminatedReason.Exception && evArgs.Exception != null) ExceptionHandler.Report(evArgs.Exception, desktopWindow); return evArgs.Reason == BackgroundTaskTerminatedReason.Completed; }
public void ChangeToSyntax(TransferSyntax syntax) { _syntax = syntax; BackgroundTask task = null; try { task = new BackgroundTask(ChangeToSyntax, false, Context.SelectedStudy); ProgressDialog.Show(task, this.Context.DesktopWindow, true); } catch(Exception e) { Platform.Log(LogLevel.Error, e); string message = String.Format("An error occurred while compressing; folder must be deleted manually: {0}", _tempPath); this.Context.DesktopWindow.ShowMessageBox(message, MessageBoxActions.Ok); } finally { _tempPath = null; if (task != null) task.Dispose(); } }
public void SendAnnotations(List<string> annotations) { if (annotations != null && annotations.Count > 0) { try { SynchronizationContext.Post((delegate { if (!AimDataServiceLoginTool.CredentialsValid) AimDataServiceLoginTool.RequestLogin(); if (AimDataServiceLoginTool.CredentialsValid) { var task = new BackgroundTask(delegate { foreach (string annotation in annotations) { if (annotation != null) { var result = AimeWebService.Submit( AimDataServiceLoginTool.Credentials.ApiKey, annotation); if (result.Contains("fail")) { throw new Exception(result); } } } }, false); task.Run(); } }), null); } catch (Exception ex) { // TODO: Smarter handling of invalid credentials/expiring credentials if (ex.Message.Contains("401")) AimDataServiceLoginTool.Credentials = null; // AimAnnotationComponents handles the exception from here. throw (ex); } } }
/// <summary> /// Creates and displays <see cref="ProgressGraphic"/>. /// </summary> /// <remarks> /// This method will invoke each graphic's <see cref="IDrawable.Draw"/> method, so do not call it from a draw routine in the same scene graph! /// </remarks> /// <param name="task">The <see cref="BackgroundTask"/> to execute. The task is automatically started if it is not already running.</param> /// <param name="parentCollections">The graphics collections on which the progress graphic should be shown.</param> /// <param name="autoClose">A value indicating whether or not the progress graphic should be automatically removed when the task is terminated.</param> /// <param name="progressBarStyle">The style of the progress bar.</param> public static void Show(BackgroundTask task, IEnumerable<GraphicCollection> parentCollections, bool autoClose = _defaultAutoClose, ProgressBarGraphicStyle progressBarStyle = _defaultStyle) { if (!task.IsRunning) task.Run(); var provider = new BackgroundTaskProgressAdapter(task); foreach (var parentCollection in parentCollections) Show(provider, parentCollection, autoClose, progressBarStyle); }
private void Dump() { if (this.ContextBase is IImageViewerToolContext) { IImageViewerToolContext context = this.ContextBase as IImageViewerToolContext; _desktopWindow = context.DesktopWindow; IImageSopProvider image = context.Viewer.SelectedPresentationImage as IImageSopProvider; if (image == null) { _desktopWindow.ShowMessageBox(SR.MessagePleaseSelectAnImage, MessageBoxActions.Ok); return; } IDicomMessageSopDataSource dataSource = image.ImageSop.DataSource as IDicomMessageSopDataSource; if (dataSource == null || dataSource.SourceMessage == null) { _desktopWindow.ShowMessageBox(SR.MessageUnknownDataSource, MessageBoxActions.Ok); return; } //Fix for Ticket #623 - HH - It turns out that for memory usage optimization the pixel data tag is stripped from the in memory dataset. //So while there are probably many better ways to address the missing pixel data tag a small hack was introduced because this entire utility will //be completely refactored in the very near future to make use of the methods the pacs uses to parse the tags. //Addendum to Comment above - HH 07/27/07 - Turns out that our implementation continues to remove the pixel data for optimization at this time so //the workaround is still needed. //Addendum to Comment above - JY 09/16/08 - Somewhere along the line, things were changed that made this line redundant - the only reference to //it after this point is at +11 lines or so, and all it does is get file.Filename. Therefore, I am commenting this line out. //file = new DicomFile(file.Filename); if (_component == null) { _component = new DicomEditorComponent(); } else { _component.Clear(); } _component.Load(dataSource.SourceMessage); } else if (this.ContextBase is ILocalImageExplorerToolContext) { ILocalImageExplorerToolContext context = this.ContextBase as ILocalImageExplorerToolContext; _desktopWindow = context.DesktopWindow; List<string> files = new List<string>(); if (context.SelectedPaths.Count == 0) return; foreach (string rawPath in context.SelectedPaths) { if (string.IsNullOrEmpty(rawPath)) continue; FileProcessor.Process(rawPath, "*.*", files.Add, true); } if (files.Count == 0) { context.DesktopWindow.ShowMessageBox(SR.MessageNoFilesSelected, MessageBoxActions.Ok); return; } if (_component == null) { _component = new DicomEditorComponent(); } else { _component.Clear(); } bool userCancelled = false; BackgroundTask task = new BackgroundTask(delegate(IBackgroundTaskContext backgroundcontext) { int i = 0; foreach (string file in files) { if (backgroundcontext.CancelRequested) { backgroundcontext.Cancel(); userCancelled = true; return; } try { _component.Load(file); } catch (DicomException e) { backgroundcontext.Error(e); return; } backgroundcontext.ReportProgress(new BackgroundTaskProgress((int)(((double)(i + 1) / (double)files.Count) * 100.0), SR.MessageDumpProgressBar)); i++; } backgroundcontext.Complete(null); }, true); try { ProgressDialog.Show(task, _desktopWindow, true); } catch (Exception e) { ExceptionHandler.Report(e, SR.MessageFailedDump, _desktopWindow); return; } if (userCancelled == true) return; } //common to both contexts if (_shelf != null) { _shelf.Activate(); } else { _shelf = ApplicationComponent.LaunchAsShelf( _desktopWindow, _component, SR.TitleDicomEditor, "Dicom Editor", ShelfDisplayHint.DockRight | ShelfDisplayHint.DockAutoHide); _shelf.Closed += OnShelfClosed; } _component.UpdateComponent(); }
public BackgroundTaskContext(BackgroundTask owner, DoWorkEventArgs doWorkArgs) { _owner = owner; _doWorkArgs = doWorkArgs; }
private void OnVolumeLoaderTaskTerminated(object sender, BackgroundTaskTerminatedEventArgs e) { BackgroundTask volumeLoaderTask = sender as BackgroundTask; if (volumeLoaderTask != null) { volumeLoaderTask.Terminated -= OnVolumeLoaderTaskTerminated; volumeLoaderTask.Dispose(); } _volumeLoaderTask = null; }
//TODO (CR Sept 2010): same comment as with the ProgressGraphic stuff; the API is unclear //as to what it is doing (return value) because it's trying to account for the async loading. /// <summary> /// Attempts to start loading the overlay data asynchronously, if not already loaded. /// </summary> /// <param name="progress">A value between 0 and 1 indicating the progress of the asynchronous loading operation.</param> /// <param name="message">A string message detailing the progress of the asynchronous loading operation.</param> /// <returns></returns> public bool BeginLoad(out float progress, out string message) { // update the last access time _largeObjectData.UpdateLastAccessTime(); // if the data is already available without blocking, return success immediately //TODO (CR Sept 2010): because unloading the volume involves disposing it, if every operation that uses it //isn't in the same lock (e.g. lock(_syncVolumeDataLock)) you could be getting a disposed/null volume here. VolumeData volume = _volume; if (volume != null) { message = SR.MessageFusionComplete; progress = 1f; return true; } lock (_syncLoaderLock) { message = SR.MessageFusionInProgress; progress = 0; if (_volumeLoaderTask == null) { // if the data is available now, return success volume = _volume; if (volume != null) { message = SR.MessageFusionComplete; progress = 1f; return true; } _volumeLoaderTask = new BackgroundTask(c => this.LoadVolume(c), false, null) {ThreadUICulture = Application.CurrentUICulture}; _volumeLoaderTask.Run(); _volumeLoaderTask.Terminated += OnVolumeLoaderTaskTerminated; } else { if (_volumeLoaderTask.LastBackgroundTaskProgress != null) { message = _volumeLoaderTask.LastBackgroundTaskProgress.Progress.Message; progress = _volumeLoaderTask.LastBackgroundTaskProgress.Progress.Percent/100f; } } } return false; }
public void Export(string path) { BackgroundTask task = new BackgroundTask( delegate { _studyBuilder.Publish(path); }, false); ProgressDialog.Show(task, base.Host.DesktopWindow, true, ProgressBarStyle.Marquee); }
public BackgroundTaskContext(BackgroundTask owner, DoWorkEventArgs doWorkArgs) { _owner = owner; _doWorkArgs = doWorkArgs; }
private void MoveFolders(SortableResultList<ScanResultEntry> list) { progressBar1.Minimum = 0; progressBar1.Maximum = 100; progressBar1.Value = 0; _moveFolderBackgroundTask = new BackgroundTask(DoMoveFolderAsync, true, list); _moveFolderBackgroundTask.ProgressUpdated += delegate(object sender, BackgroundTaskProgressEventArgs ev) { progressBar1.Value = ev.Progress.Percent; }; _moveFolderBackgroundTask.Terminated += delegate { progressBar1.Value = 0; MoveFolderButton.Text = "Move Folders"; MoveFolderButton.Enabled = true; }; MoveFolderButton.Text = "Stop"; _moveFolderBackgroundTask.Run(); }
public void Run() { CreateBaseDataSet(); _tempFileDirectory = System.IO.Path.Combine(System.IO.Path.GetTempPath(), "ClearCanvas"); _tempFileDirectory = System.IO.Path.Combine(_tempFileDirectory, "BitmapImport"); DeleteEmptyFolders(_tempFileDirectory); _tempFileDirectory = System.IO.Path.Combine(_tempFileDirectory, System.IO.Path.GetRandomFileName()); Directory.CreateDirectory(_tempFileDirectory); BackgroundTask task = new BackgroundTask(Process, true); task.Terminated += delegate { OnComplete(); task.Dispose(); }; lock (_waitShowProgressLock) { task.Run(); Monitor.Wait(_waitShowProgressLock); if (_showProgress) { ProgressDialogComponent progressComponent = new ProgressDialogComponent(task, true, ProgressBarStyle.Blocks); LaunchAsShelf(DesktopWindow, progressComponent, SR.TitleImportingImages, ShelfDisplayHint.DockFloat); } Monitor.Pulse(_waitShowProgressLock); } }
/// <summary> /// Creates and displays a <see cref="ProgressGraphic"/>. /// </summary> /// <remarks> /// This method will invoke the graphic's <see cref="IDrawable.Draw"/> method, so do not call it from a draw routine in the same scene graph! /// </remarks> /// <param name="task">The <see cref="BackgroundTask"/> to execute. The task is automatically started if it is not already running.</param> /// <param name="parentCollection">The graphics collection on which the progress graphic should be shown.</param> /// <param name="autoClose">A value indicating whether or not the progress graphic should be automatically removed when the task is terminated.</param> /// <param name="progressBarStyle">The style of the progress bar.</param> public static void Show(BackgroundTask task, GraphicCollection parentCollection, bool autoClose = _defaultAutoClose, ProgressBarGraphicStyle progressBarStyle = _defaultStyle) { if (!task.IsRunning) task.Run(); Show(new BackgroundTaskProgressAdapter(task), parentCollection, autoClose, progressBarStyle); }
public void PublishToServer() { AENavigatorComponent aeNavigator = new AENavigatorComponent(); aeNavigator.IsReadOnly = true; aeNavigator.ShowCheckBoxes = false; aeNavigator.ShowLocalDataStoreNode = false; aeNavigator.ShowTitlebar = false; aeNavigator.ShowTools = false; SimpleComponentContainer dialogContainer = new SimpleComponentContainer(aeNavigator); DialogBoxAction code = this.Host.DesktopWindow.ShowDialogBox(dialogContainer, SR.SelectDestination ); if (code != DialogBoxAction.Ok) return; if (aeNavigator.SelectedServers == null || aeNavigator.SelectedServers.Servers == null || aeNavigator.SelectedServers.Servers.Count == 0) { return; } if (aeNavigator.SelectedServers.Servers.Count < 1) { return; } BackgroundTask task = new BackgroundTask( delegate { foreach (Server destinationAE in aeNavigator.SelectedServers.Servers) { _studyBuilder.Publish(ServerTree.GetClientAETitle(), destinationAE.AETitle, destinationAE.Host, destinationAE.Port); } }, false); ProgressDialog.Show(task, base.Host.DesktopWindow, true, ProgressBarStyle.Marquee); }
public void PublishToLocalDataStore() { try { DicomServerConfigurationHelper.Refresh(true); string aeTitle = DicomServerConfigurationHelper.AETitle; int port = DicomServerConfigurationHelper.Port; BackgroundTask task = new BackgroundTask( delegate { _studyBuilder.Publish(aeTitle, aeTitle, IPAddress.Loopback.ToString(), port); }, false); ProgressDialog.Show(task, base.Host.DesktopWindow, true, ProgressBarStyle.Marquee); } catch (Exception e) { ExceptionHandler.Report(e, SR.ExceptionLocalDataStoreNotFound , base.Host.DesktopWindow); } }
public void Run() { if (NumberOfImagesToExport <= 5) { BlockingOperation.Run(delegate { Export(null); }); Complete(); } else { ItemsToExport.ForEach(delegate(IClipboardItem item) { item.Lock(); }); BackgroundTask task = new BackgroundTask(Export, true) {ThreadUICulture = Application.CurrentUICulture}; ProgressDialogComponent progressComponent = new ProgressDialogComponent(task, true, ProgressBarStyle.Blocks); _progressComponentShelf = LaunchAsShelf(DesktopWindow, progressComponent, SR.TitleExportingImages, "ExportingImages", ShelfDisplayHint.DockFloat); _progressComponentShelf.Closed += delegate { Complete(); task.Dispose(); }; } }
void send_series(string studyUid, string seriesUid) { AEInformation destination = get_server(); if (destination != null) { BackgroundTask task = new BackgroundTask( delegate(IBackgroundTaskContext context) { DicomSendServiceClient sender = new DicomSendServiceClient(); sender.Open(); SendSeriesRequest series_request = new SendSeriesRequest(); series_request.DestinationAEInformation = destination; series_request.StudyInstanceUid = studyUid; List<string> seriesUids = new List<string>(); seriesUids.Add(seriesUid); series_request.SeriesInstanceUids = seriesUids; sender.SendSeries(series_request); sender.Close(); }, true); task.Run(); LocalDataStoreActivityMonitorComponentManager.ShowSendReceiveActivityComponent(this.Context.DesktopWindow); } }
public void LaunchMpr() { Exception exception = null; IPresentationImage currentImage = this.Context.Viewer.SelectedPresentationImage; if (currentImage == null) return; // gather the source frames which MPR will operate on. exceptions are reported. BackgroundTaskParams @params; try { @params = new BackgroundTaskParams(FilterSourceFrames(currentImage.ParentDisplaySet, currentImage)); } catch (Exception ex) { ExceptionHandler.Report(ex, SR.ExceptionMprLoadFailure, base.Context.DesktopWindow); return; } // execute the task to create an MPR component. exceptions (either thrown or passed via task) are reported, but any created component must be disposed BackgroundTask task = new BackgroundTask(LoadVolume, true, @params); task.Terminated += (sender, e) => exception = e.Exception; try { ProgressDialog.Show(task, base.Context.DesktopWindow, true, ProgressBarStyle.Blocks); } catch (Exception ex) { exception = ex; if (_viewer != null) { _viewer.Dispose(); _viewer = null; } } finally { task.Dispose(); } if (exception != null) { ExceptionHandler.Report(exception, SR.ExceptionMprLoadFailure, base.Context.DesktopWindow); return; } // launch the created MPR component as a workspace. any exceptions here are just reported. try { LaunchImageViewerArgs args = new LaunchImageViewerArgs(ViewerLaunchSettings.WindowBehaviour); args.Title = _viewer.Title; MprViewerComponent.Launch(_viewer, args); } catch (Exception ex) { ExceptionHandler.Report(ex, SR.ExceptionMprLoadFailure, base.Context.DesktopWindow); } finally { _viewer = null; } }
public void StartAsync() { ScanResultSet = new ScanResultSet(); LoadDeletedStudies(); LoadSIQEntries(); _worker = new BackgroundTask(StartScaning, true, this); _worker.ProgressUpdated += WorkerProgressUpdated; _worker.Terminated += WorkerTerminated; _worker.Run(); }
/// <summary> /// Creates and executes a new <see cref="BackgroundTask"/> based on the specified arguments. /// </summary> /// <param name="method">The method to run in the background.</param> /// <param name="supportsCancel">Indicates whether the task supports cancellation or not.</param> /// <param name="terminateHandler">Method that will be called when the task terminates.</param> /// <param name="progressHandler">Optional method to handle progress updates, may be null.</param> /// <param name="userState">Optional state to be passed to the background task, may be null.</param> /// <returns>A running <see cref="BackgroundTask"/> object.</returns> public static BackgroundTask CreateAndRun( BackgroundTaskMethod method, bool supportsCancel, EventHandler<BackgroundTaskTerminatedEventArgs> terminateHandler, EventHandler<BackgroundTaskProgressEventArgs> progressHandler, object userState) { Platform.CheckForNullReference(method, "method"); Platform.CheckForNullReference(terminateHandler, "terminateHandler"); BackgroundTask task = new BackgroundTask(method, supportsCancel, userState); task.Terminated += terminateHandler; if (progressHandler != null) { task.ProgressUpdated += progressHandler; } task.Run(); return task; }
public BackgroundTaskProgressAdapter(BackgroundTask backgroundTask) { _backgroundTask = backgroundTask; }