private void OnLogUpdated() { if (logTask == null || logTask.Status == DispatcherOperationStatus.Completed || logTask.Status == DispatcherOperationStatus.Aborted) { logTask = Dispatcher.InvokeAsync(() => { terminal.Text = log.text; terminalScroll.ScrollToBottom(); }); } }
public void BeginUpdateLayout() { if (updateLayoutOperation == null || updateLayoutOperation.Status == DispatcherOperationStatus.Completed) { #if MIGRATION updateLayoutOperation = Dispatcher.INTERNAL_GetCurrentDispatcher().InvokeAsync(UpdateLayout, DispatcherPriority.Render); #else updateLayoutOperation = CoreDispatcher.INTERNAL_GetCurrentDispatcher().InvokeAsync(UpdateLayout, DispatcherPriority.Render); #endif } }
public RunOnceToken(DispatcherOperation operation) { if (operation != null && operation.Status != DispatcherOperationStatus.Completed && operation.Status != DispatcherOperationStatus.Aborted) { _operation = operation; _operation.Completed += OnCompletedOrAborted; _operation.Aborted += OnCompletedOrAborted; } }
/// <summary> /// 检测当前是否正在执行操作,并发出提示。 /// </summary> /// <param name="showWarning">是否发出提示。</param> /// <returns>当前是否正在执行操作。</returns> private bool isInOperation(bool showWarning = true) { if (this.TaskbarItemInfo.ProgressState == TaskbarItemProgressState.None) { return(false); } if (showWarning && (this.showMessageBox == null || this.showMessageBox.Status == DispatcherOperationStatus.Completed)) { this.showMessageBox = this.Dispatcher.BeginInvoke(new Action(() => MessageBox.Show(Properties.Resources.HintWait, this.Title, MessageBoxButton.OK, MessageBoxImage.Exclamation))); } return(true); }
protected override void Reprioritize(DispatcherOperation op, DispatcherPriority oldpriority) { int oldp = (int)oldpriority; PokableQueue q = this.priorityQueues[oldp]; lock (q) { q.Remove(op); } this.Queue(op.Priority, op); }
public void Invoke(Dispatcher dispatcher) { List <DispatcherOperation> operations = new List <>(); for (int i = 0; i < _delegates.Length; i++) { DispatcherOperation operation = dispatcher.BeginInvoke(_delegates[i], _parameters[i]); operations.Add(operation); } // check status of all operations before completion }
public void DoEvents() { DispatcherFrame nestedFrame = new DispatcherFrame(); DispatcherOperation exitOperation = Dispatcher.CurrentDispatcher.BeginInvoke(DispatcherPriority.Background, exitFrameCallback, nestedFrame); Dispatcher.PushFrame(nestedFrame); if (exitOperation.Status != DispatcherOperationStatus.Completed) { exitOperation.Abort(); } }
private void QueueRenderText() { if (CurrentDispatcherOperation != null) { CurrentDispatcherOperation.Abort(); } CurrentDispatcherOperation = Dispatcher.BeginInvoke(RenderTextAction, DispatcherPriority.Render, null); CurrentDispatcherOperation.Aborted += (o, e) => { CurrentDispatcherOperation = null; }; CurrentDispatcherOperation.Completed += (o, e) => { CurrentDispatcherOperation = null; }; }
private void OnGetContext(HttpListenerContext context, Exception error) { if (!_dispatcher.CheckAccess()) { DispatcherOperation op = _dispatcher.BeginInvoke(DispatcherPriority.Background, new Action(() => OnGetContext(context, error))); Thread.Sleep(100); op.Wait(); return; } UrlDetails url = new UrlDetails(context.Request.RawUrl); }
private void Scanner_evAdvertisementReceived(ElaTagClassLibrary.ElaTags.Interoperability.ElaBaseData device) { var formattedData = $"{device.timestamp};" + $"{device.macaddress};" + $"{device.localname};" + $"{device.rssi};"; DispatcherOperation op = Dispatcher.BeginInvoke((Action)(() => { this.lvBleDevice.Items.Add(formattedData); })); }
/// <summary> /// /// </summary> public DPFCanvas() { this.updateAndRenderAction = this.UpdateAndRender; this.updateAndRenderOperation = null; this.renderTimer = new Stopwatch(); this.MaxRenderingDuration = TimeSpan.FromMilliseconds(20.0); this.Loaded += this.OnLoaded; this.Unloaded += this.OnUnloaded; this.ClearColor = global::SharpDX.Color.Gray; this.IsShadowMapEnabled = false; this.IsMSAAEnabled = true; }
// Waits for a DispatcherOperation to complete. // Stops waiting if the proxy is done (disposed or error). private bool _WaitForOperation(DispatcherOperation op) { while (DispatcherOperationStatus.Completed != op.Wait(TimeSpan.FromMilliseconds(500))) { if (this.IsControllerProxyDone) { return(false); } } return(true); }
void VisibleChanged(object sender, DependencyPropertyChangedEventArgs e) { if ((bool)e.NewValue == true) { result = Dispatcher.BeginInvoke( DispatcherPriority.ContextIdle, new Action(delegate() { this.ArcContainer.Focus(); })); } }
internal void Request(object arg) { if (_operation == null) { Debug.Assert(_callback != null); _operation = Dispatcher.CurrentDispatcher.BeginInvoke( DispatcherPriority.Loaded, new DispatcherOperationCallback(DispatcherOperation), arg); } }
/// <summary> /// /// </summary> public DPFCanvas() { updateAndRenderAction = UpdateAndRender; updateAndRenderOperation = null; renderTimer = new Stopwatch(); MaxRenderingDuration = TimeSpan.FromMilliseconds(20.0); Loaded += OnLoaded; Unloaded += OnUnloaded; ClearColor = global::SharpDX.Color.Gray; IsShadowMapEnabled = false; IsMSAAEnabled = true; }
/// <summary> /// Requests that a new DispatcherOperation be placed on the Dispatcher queue /// </summary> /// <param name="arg">The object to send the callback in its arg parameter.</param> internal void Request(object arg) { if (_operation != null) { Cancel(); } _operation = Dispatcher.CurrentDispatcher.BeginInvoke( DispatcherPriority.Background, new DispatcherOperationCallback(DispatcherOperation), arg); }
public void TestDispatcherOpOnThread() { Thread t = new Thread(new ThreadStart(thread)); Dispatcher d = Dispatcher.CurrentDispatcher; t.Start(); op = Dispatcher.CurrentDispatcher.BeginInvoke(DispatcherPriority.Normal, (Action) delegate { Console.WriteLine("Some methods"); }); wait.Set(); wait2.WaitOne(); }
public void Dispose() { var operation = _operation; if (operation == null) { return; } _operation = null; operation.Completed -= OnCompletedOrAborted; operation.Aborted -= OnCompletedOrAborted; }
/// <summary> /// Executes the specified delegate synchronously on the thread the Dispatcher is associated with. /// </summary> public void Invoke(Delegate d, object args) { if (CheckAccess()) { DispatcherOperation.Invoke(d, args); } else { DispatcherOperation operation = AddOperation(d, args, new AutoResetEvent(false)); operation.Wait(); } }
/// <summary> /// Moves the window back to its original position. /// Used to provide feedback that panning has hit an edge. /// </summary> /// <param name="animateBack">Whether to animate or snap back to the original position</param> public void EndPanningFeedback(bool animateBack) { if (_hwndSource != null && _isProvidingPanningFeedback) { _isProvidingPanningFeedback = false; if (_updatePanningOperation != null) { _updatePanningOperation.Abort(); _updatePanningOperation = null; } UnsafeNativeMethods.EndPanningFeedback(Handle, animateBack); } }
private object DispatcherOperation(object arg) { try { Debug.Assert(_operation != null && _operation.Status == DispatcherOperationStatus.Executing); _callback(arg); } finally { _operation = null; } return(null); }
private void RaisePropertyChangedEventBody(DependencyPropertyChangedEventArgs e, ChangeType changeType) { if (propertyChangedCounter > 0) { return; } propertyChangedCounter++; RaisePropertyChanged(ExtendedPropertyChangedEventArgs.FromDependencyPropertyChanged(e), changeType); propertyChangedCounter--; notifyOperation = null; }
/// <summary> /// /// </summary> private async void PositionTask() { if (m_operation != null && m_operation.Status != DispatcherOperationStatus.Completed) { m_operation.Abort(); } await Task.Delay(800); m_operation = Application.Current.Dispatcher.BeginInvoke( new Action(() => StartValidation()), DispatcherPriority.Background); }
public static void DoInvoke(Delegate delegateItem, params object[] parameter) { DispatcherOperation op = Dispatcher.CurrentDispatcher.BeginInvoke(delegateItem, DispatcherPriority.Background, parameter); while (op.Status != DispatcherOperationStatus.Completed) { System.Windows.Forms.Application.DoEvents(); //DoEvents(); } }
/************************************************************************************************************************************/ /* Private Methods */ /************************************************************************************************************************************/ /// <summary> /// Notifies all currently queued nodes. /// </summary> private void NotifyNodes() { BusNode node; while (_updatedNodes.Count > 0) { //Debug.WriteLine("Notifying nodes."); node = (BusNode)_updatedNodes.Dequeue(); Notify(node); } _notification = null; }
public static void DoEvents() { var frame = new DispatcherFrame(); DispatcherOperation dispatcherOperation = Dispatcher.CurrentDispatcher.BeginInvoke(DispatcherPriority.Background, ExitFrameCallback, frame); Dispatcher.PushFrame(frame); if (dispatcherOperation.Status == DispatcherOperationStatus.Completed) { return; } dispatcherOperation.Abort(); }
public void NotifyCollectionChanged() { //OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset)); if (_lastDispatcherOperation != null) { //Pending: The operation is pending and is still in the System.Windows.Threading.Dispatcher queue. if (_lastDispatcherOperation.Status == DispatcherOperationStatus.Pending) { return; } } _lastDispatcherOperation = ApplicationDispatcher.BeginInvoke(DispatcherPriority.Background, OnCollectionChanged, new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset)); }
/// <summary> /// Queues a node to be notified /// </summary> /// <param name="node">The node to call the listeners for.</param> public void QueueNotification(BusNode node) { if (!_updatedNodes.Contains(node)) { //Debug.WriteLine("Queueing notification..."); _updatedNodes.Enqueue(node); } // add the node to the queue and start the notifier if neccessary. if (_notification == null) { _notification = _dispatcher.BeginInvoke(DispatcherPriority.ApplicationIdle, new Action(NotifyNodes)); } }
/// <summary> /// Handles the ExportCalculated event of the exporter control. /// </summary> /// <param name="sender">The source of the event.</param> /// <param name="e">The <see cref="TheBoxSoftware.Documentation.Exporting.ExportCalculatedEventArgs"/> instance containing the event data.</param> private void exporter_ExportCalculated(object sender, ExportCalculatedEventArgs e) { DispatcherOperation op = this.Dispatcher.BeginInvoke( DispatcherPriority.Normal, new Action <ExportCalculatedEventArgs>( p => { this.progressIndicator.Value = 0; this.progressIndicator.Minimum = 0; this.progressIndicator.Maximum = p.NumberOfSteps; this.progressText.Text = "Started export"; }), e); }
private void CreateThreadForCancelJob(object jobId) { try { TranslationJob.CancelJob(cc, new Guid((string)jobId)); cc.ExecuteQuery(); DispatcherOperation dop = Dispatcher.BeginInvoke(new Action <string>(PrintResult), "Done"); } catch (Exception e) { DispatcherOperation dop = Dispatcher.BeginInvoke(new Action <string>(PrintResult), e.ToString()); } }
static DispatcherOperation() { Default = new DispatcherOperation(); }
/// <summary> /// Constructs an instance of the DispatcherHookEventArgs class. /// </summary> /// <param name="operation"> /// The operation in question. /// </param> public DispatcherHookEventArgs(DispatcherOperation operation) { _operation = operation; }