public override void Execute(CoroutineExecutionContext context) { var window = Window.GetWindow(context.View as DependencyObject); window.Close(); base.Execute(context); }
public void Execute(CoroutineExecutionContext context) { Exception error = null; var worker = new BackgroundWorker(); worker.DoWork += (s, e) => { try { _work(); } catch (Exception ex) { error = ex; } }; worker.RunWorkerCompleted += (s, e) => { if (error == null && _onSuccess != null) _onSuccess.OnUIThread(); if (error != null && _onFail != null) { Caliburn.Micro.Execute.OnUIThread(() => _onFail(error)); } Completed(this, new ResultCompletionEventArgs { Error = error }); }; worker.RunWorkerAsync(); }
public async void Execute(CoroutineExecutionContext context) { await this.ProgressViewModel.ShowProgress(); await Task.Run(() => { var hashes = hashRepository.GetMurMurs(); var dirs = hashes.GroupBy(x => Path.GetDirectoryName(x.Key).ToLower()) .Select(x => new { Dir = x.Key, Files = x.Select(f => f.Value).ToList() }) .ToList() .AsParallel(); CopyDirectories = dirs.SelectMany((x, i) => dirs.Skip(i + 1).Select(y => new DirectoryCopyResultModel { Directory1 = x.Dir, Directory2 = y.Dir, Directory1Files = x.Files.Count, Directory2Files = y.Files.Count, CopyCount = Math.Max(x.Files.Count, y.Files.Count) - DiffCount(x.Files, y.Files) })) .Where(x => x.CopyCount > 0 && x.CopyPercentage >= 0.5) .OrderByDescending(x => x.CopyPercentage) .ThenByDescending(x => x.Directory1Files) .ToList(); }); await this.ProgressViewModel.CloseProgress(); Completed(this, new ResultCompletionEventArgs()); }
/// <summary> /// Called by the bootstrapper's constructor at runtime to start the framework. /// </summary>B protected virtual void StartRuntime() { EventAggregator.HandlerResultProcessing = (target, result) => { var task = result as Task; if (task != null) { result = new IResult[] { task.AsResult() }; } var coroutine = result as IEnumerable<IResult>; if (coroutine != null) { var viewAware = target as IViewAware; var view = viewAware != null ? viewAware.GetView() : null; var context = new CoroutineExecutionContext { Target = target, View = view }; Coroutine.BeginExecute(coroutine.GetEnumerator(), context); } }; AssemblySourceCache.Install(); AssemblySource.Instance.AddRange(SelectAssemblies()); Configure(); IoC.GetInstance = GetInstance; IoC.GetAllInstances = GetAllInstances; IoC.BuildUp = BuildUp; }
public static void ExecuteSynchronized(this IResult result, CoroutineExecutionContext executionContext = null) { IoC.BuildUp(result); var reset = new ManualResetEvent(false); result.Completed+= (s,e)=>reset.Set(); result.Execute(executionContext); reset.WaitOne(); }
public override void Execute(CoroutineExecutionContext context) { if(Workspace != null && Workspace.ReplExecutor != null) { Workspace.ReplExecutor.Execute(code, sourceFile); OnCompleted(null); } }
public void Execute(CoroutineExecutionContext context) { _lambda(context); var completedHandler = Completed; if (completedHandler != null) completedHandler(this, new ResultCompletionEventArgs()); }
/// <summary> /// Called when the execution of the decorated result has completed. /// </summary> /// <param name="context">The context.</param> /// <param name="innerResult">The decorated result.</param> /// <param name="args">The <see cref="ResultCompletionEventArgs" /> instance containing the event data.</param> protected override void OnInnerResultCompleted(CoroutineExecutionContext context, IResult innerResult, ResultCompletionEventArgs args) { if (args.Error != null || !args.WasCancelled) { OnCompleted(new ResultCompletionEventArgs {Error = args.Error}); } else { Log.Info(string.Format("Executing coroutine because {0} was cancelled.", innerResult.GetType().Name)); Continue(context); } }
public void Execute(CoroutineExecutionContext context) { var dialog = new FolderBrowserDialog(); if(!String.IsNullOrEmpty(SelectedFolder)) dialog.SelectedPath = SelectedFolder; var result = dialog.ShowDialog(); SelectedFolder = dialog.SelectedPath; Completed(this, new ResultCompletionEventArgs { WasCancelled = result != DialogResult.OK }); }
/// <summary> /// Executes the result using the specified context. /// </summary> /// <param name="context">The context.</param> public void Execute(CoroutineExecutionContext context) { if (innerTask.IsCompleted) OnCompleted(innerTask); else innerTask.ContinueWith(OnCompleted, System.Threading.SynchronizationContext.Current != null ? TaskScheduler.FromCurrentSynchronizationContext() : TaskScheduler.Current); }
public override void Execute(CoroutineExecutionContext context) { var windowManager = IoC.Get<IWindowManager>(); if(dialogViewModel == null) { dialogViewModel = IoC.GetInstance(dialogViewModelType, null); } var result = windowManager.ShowDialog(dialogViewModel, settings:Settings); OnCompleted(null, result.HasValue && !result.Value); }
public void Execute(CoroutineExecutionContext context) { var result = System.Windows.MessageBoxResult.Yes; if (Settings.Default.ConfirmExit) { result = MessageBox.Show("Are you sure you want to exit?", "Confirm", MessageBoxButton.YesNo); } Completed(this, new ResultCompletionEventArgs { WasCancelled = (result != System.Windows.MessageBoxResult.Yes) }); }
public override void Execute(CoroutineExecutionContext context) { try { Caliburn.Micro.Execute.OnUIThread(() => Application.Current.MainWindow.Close()); } catch (Exception ex) { OnCompleted(ex); } }
public override void Execute(CoroutineExecutionContext context) { var dialog = Mode == FileDialogMode.Open ? new OpenFileDialog() as FileDialog : new SaveFileDialog(); dialog.FileName = fileName; dialog.Title = title; dialog.Filter = filter; dialog.ShowDialog(); File = dialog.FileName; base.Execute(context); }
/// <summary> /// Executes the result using the specified context. /// </summary> /// <param name="context">The context.</param> public void Execute(CoroutineExecutionContext context) { this.context = context; try { innerResult.Completed += InnerResultCompleted; IoC.BuildUp(innerResult); innerResult.Execute(this.context); } catch (Exception ex) { InnerResultCompleted(innerResult, new ResultCompletionEventArgs { Error = ex }); } }
/// <summary> /// Executes the result using the specified context. /// </summary> /// <param name="context">The context.</param> public void Execute(CoroutineExecutionContext context) { var eventArgs = new ResultCompletionEventArgs(); try { toExecute(); } catch (Exception ex) { eventArgs.Error = ex; } Completed(this, eventArgs); }
/// <summary> /// Executes a coroutine. /// </summary> /// <param name="coroutine">The coroutine to execute.</param> /// <param name="context">The context to execute the coroutine within.</param> /// /// <param name="callback">The completion callback for the coroutine.</param> public static void BeginExecute(IEnumerator<IResult> coroutine, CoroutineExecutionContext context = null, EventHandler<ResultCompletionEventArgs> callback = null) { Log.Info("Executing coroutine."); var enumerator = CreateParentEnumerator(coroutine); IoC.BuildUp(enumerator); if (callback != null) { ExecuteOnCompleted(enumerator, callback); } ExecuteOnCompleted(enumerator, Completed); enumerator.Execute(context ?? new CoroutineExecutionContext()); }
public override void Execute(CoroutineExecutionContext context) { try { //some of this is synchronous which can mess up the UI (especially on startup), so we execute it on a seperate thread Task.Factory.StartNew(() => workspace.SetWorkspaceDirectory(workspaceDirectory)) .ContinueWith(t2 => OnCompleted(t2.Exception)); } catch (Exception ex) { OnCompleted(ex); } }
public void Execute(CoroutineExecutionContext context) { if (_templatesDirectory.Exists) { ZipFile.CreateFromDirectory(_templatesDirectory.FullName, Path.Combine( Environment.GetFolderPath(Environment.SpecialFolder.Desktop), string.Format("templates-{0}.zip", DateTime.Now.ToFileTime())), CompressionLevel.Optimal, true); } Completed(this, new ResultCompletionEventArgs()); }
/// <summary> /// Executes a coroutine asynchronous. /// </summary> /// <param name="coroutine">The coroutine to execute.</param> /// <param name="context">The context to execute the coroutine within.</param> /// <returns>A task that represents the asynchronous coroutine.</returns> public static Task ExecuteAsync(IEnumerator<IResult> coroutine, CoroutineExecutionContext context = null) { var taskSource = new TaskCompletionSource<object>(); BeginExecute(coroutine, context, (s, e) => { if (e.Error != null) taskSource.SetException(e.Error); else if (e.WasCancelled) taskSource.SetCanceled(); else taskSource.SetResult(null); }); return taskSource.Task; }
public async void Execute(CoroutineExecutionContext context) { var result = System.Windows.MessageBoxResult.Yes; var connectionHandler = IoC.Get<IConnectionHandler>(); if (Settings.Default.Connection_ConfirmOnCloseConnected && connectionHandler.ConnectionRequestState == ConnectionRequestState.Start) { result = MessageBox.Show("You are connected, you want to exit?", "Confirm", MessageBoxButton.YesNo); if (result == System.Windows.MessageBoxResult.Yes) await connectionHandler.StopSession(); } if (Completed != null) Completed(this, new ResultCompletionEventArgs { WasCancelled = (result != System.Windows.MessageBoxResult.Yes) }); }
/// <summary> /// Extension method to convert an IResult to <see cref="Task" /> /// </summary> /// <param name="source"> The IResult to be converted. </param> /// <param name="context"> Optional execution context. </param> public static Task AsTask(this IResult source, CoroutineExecutionContext context = null) { var tcs = new TaskCompletionSource<bool>(); source.Completed += (sender, args) => { if (args.WasCancelled) tcs.SetCanceled(); else if (args.Error != null) tcs.SetException(args.Error); else tcs.SetResult(true); }; source.Execute(context); return tcs.Task; }
public void Execute(CoroutineExecutionContext context) { if (_templatesDirectory.Parent != null) { using (ZipArchive archive = ZipFile.OpenRead(_importFile)) { foreach (ZipArchiveEntry entry in archive.Entries) { entry.ExtractToFile(Path.Combine(_templatesDirectory.FullName, entry.Name), true); } } } Completed(this, new ResultCompletionEventArgs()); }
void Continue(CoroutineExecutionContext context) { IResult continueResult; try { continueResult = coroutine(); } catch (Exception ex) { OnCompleted(new ResultCompletionEventArgs {Error = ex}); return; } try { continueResult.Completed += ContinueCompleted; IoC.BuildUp(continueResult); continueResult.Execute(context); } catch (Exception ex) { ContinueCompleted(continueResult, new ResultCompletionEventArgs {Error = ex}); } }
public override void Execute(CoroutineExecutionContext context) { Exception ex = null; try { if (!String.IsNullOrEmpty(newFile)) { document.SaveAs(newFile); } else if (document.IsDirty) { document.Save(); } } catch(Exception e) { ex = e; } OnCompleted(ex); }
/// <summary> /// Executes a coroutine asynchronous. /// </summary> /// <param name="coroutine">The coroutine to execute.</param> /// <param name="context">The context to execute the coroutine within.</param> /// <returns>A task that represents the asynchronous coroutine.</returns> public static Task ExecuteAsync(IEnumerator <IResult> coroutine, CoroutineExecutionContext context = null) { var taskSource = new TaskCompletionSource <object>(); BeginExecute(coroutine, context, (s, e) => { if (e.Error != null) { taskSource.SetException(e.Error); } else if (e.WasCancelled) { taskSource.SetCanceled(); } else { taskSource.SetResult(null); } }); return(taskSource.Task); }
public void Execute(CoroutineExecutionContext context) { var view = context.View as FrameworkElement; //bottom up search while(view != null) { var indicator = view as BusyIndicator; if(indicator != null) { indicator.IsBusy = !hide; break; } view = view.Parent as FrameworkElement; } //top down search if(view == null) { var queue = new Queue<FrameworkElement>(); queue.Enqueue(App.Current.RootVisual as FrameworkElement); while(queue.Count > 0) { var current = queue.Dequeue(); if(current == null) continue; var indicator = current as BusyIndicator; if(indicator != null) { indicator.IsBusy = !hide; break; } var count = VisualTreeHelper.GetChildrenCount(current); for(var i = 0; i < count; i++) { queue.Enqueue(VisualTreeHelper.GetChild(current, i) as FrameworkElement); } } } Completed(this, new ResultCompletionEventArgs()); }
public void Execute(CoroutineExecutionContext context) { var path = Path.GetDirectoryName(Assembly.GetAssembly(typeof(InstallContextAction)).Location); var psi = new ProcessStartInfo(); psi.FileName = Path.Combine(path, "SlavApp.Minion.ElevatedRunner.exe"); psi.Verb = "runas"; if (Settings["context"] == "1") { psi.Arguments = "context uninstall"; Settings["context"] = "0"; } else { psi.Arguments = "context install"; Settings["context"] = "1"; } var process = new Process(); process.StartInfo = psi; process.Start(); process.WaitForExit(); Settings.Save(); Completed(this, new ResultCompletionEventArgs()); }
/// <summary> /// Executes the result using the specified context. /// </summary> /// <param name = "context">The context.</param> public void Execute(CoroutineExecutionContext context) { this.context = context; ChildCompleted(null, new ResultCompletionEventArgs()); }
public static void BeginExecute(this IResult result, CoroutineExecutionContext executionContext = null) { IEnumerable<IResult> results = new[] {result}; results.BeginExecute(executionContext); }
public static void BeginExecute(this IEnumerable<IResult> results, CoroutineExecutionContext executionContext = null) { Coroutine.BeginExecute(results.GetEnumerator(), executionContext); }
public void Execute(CoroutineExecutionContext context) { var view = (FrameworkElement)context.View; var storyboard = (Storyboard)view.Resources["AddCreditsStoryboard"]; storyboard.Begin(); }