/// <summary> /// Called when [rendering]. /// </summary> /// <param name="sender">The sender.</param> /// <param name="e">The <see cref="EventArgs"/> instance containing the event data.</param> private void OnRendering(object sender, EventArgs e) { if (this.isDirty) { if (this.LowPriorityRendering) { // if we called render previously... if (this.previousRenderCall != null) { var previousStatus = this.previousRenderCall.Status; // ... and the operation didn't finish yet - then skip the current call if (previousStatus == System.Windows.Threading.DispatcherOperationStatus.Pending || previousStatus == System.Windows.Threading.DispatcherOperationStatus.Executing) { return; } } this.previousRenderCall = this.Dispatcher.BeginInvoke(this.renderDelegate, System.Windows.Threading.DispatcherPriority.Input); } else { this.renderDelegate(); } this.IsDirty = this.AutoRender; } }
public void BeginUpdateLayout() { if (updateLayoutOperation == null || updateLayoutOperation.Status == DispatcherOperationStatus.Completed) { updateLayoutOperation = Dispatcher.CurrentDispatcher.BeginInvoke(DispatcherPriority.Background, (Action)UpdateLayout); } }
/// <summary> /// Cancels a pending DispatcherOperation /// </summary> internal void Cancel() { if (IsPending) { _operation.Abort(); } _operation = null; }
public void InvokeParametersTest() { int value = 0; DispatcherOperation operation0 = new DispatcherOperation(() => value = 1); operation0.Invoke(); Assert.AreEqual(1, value); }
internal void Cancel() { if (_operation != null) { Debug.Assert(_operation.Status == DispatcherOperationStatus.Pending); _operation.Abort(); _operation = null; } }
public void Enqueue(object userState) { if (userState == null) throw new ArgumentNullException("userState"); CurrentContext = userState as BackgroundActionContext; if (CurrentContext == null) throw new NotSupportedException("Not support non BackgroundActionContext type userState"); _latestOperation = UIDispatcher.BeginInvoke(() => DoWork(userState), DispatcherPriority.Background); }
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 (); }
internal void Reprioritize(DispatcherOperation op, DispatcherPriority oldpriority) { int oldp = (int)oldpriority; PokableQueue q = priority_queues [oldp]; lock (q) { q.Remove(op); } Queue(op.Priority, op); hooks.EmitOperationPriorityChanged(op); }
/// <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); }
internal void Request(object arg) { if (_operation == null) { Debug.Assert(_callback != null); _operation = Dispatcher.CurrentDispatcher.BeginInvoke( DispatcherPriority.Loaded, new DispatcherOperationCallback(DispatcherOperation), arg); } }
private bool TryDequeue(out DispatcherOperation operation) { while (disableProcessingRequests == 0 && queue.TryPeek(out operation) && operation.Priority != DispatcherPriority.Inactive) { queue.Dequeue(); if (operation.Status != DispatcherOperationStatus.Pending) { continue; } return(true); } operation = null; return(false); }
void Queue(DispatcherPriority priority, DispatcherOperation x) { int p = ((int)priority); PokableQueue q = priority_queues [p]; lock (q){ int flag = 1 << p; q.Enqueue(x); queue_bits |= flag; } hooks.EmitOperationPosted(x); if (Thread.CurrentThread != base_thread) { wait.Set(); } }
private static void PrintOnConsole(string message, object color, DispatcherPriority priority = DispatcherPriority.Background) { DateTime TimeStamp = DateTime.Now; message = $"[{TimeStamp.ToLongTimeString()}] {message}"; LogString msg = new LogString() { Text = message, Color = color }; LastOperation = Instance.Dispatcher.BeginInvoke(priority, new Action(() => { logs.Add(msg); ScrollToEnd(); })); }
private static void PrintOnConsole(string message, object color, DispatcherPriority priority = DispatcherPriority.Background) { DateTime TimeStamp = DateTime.Now; message = $"[{TimeStamp.ToLongTimeString()}] {message}\n"; LastOperation = _Instance.Dispatcher.BeginInvoke( priority, new Action(() => { TextRange msg = new TextRange(_Instance.Console.Document.ContentEnd, _Instance.Console.Document.ContentEnd) { Text = message }; msg.ApplyPropertyValue(TextElement.ForegroundProperty, color); ScrollToEnd(); }) ); }
public DispatcherOperation BeginInvoke(DispatcherPriority priority, Delegate method, object arg, params object [] args) { if (priority < 0 || priority > DispatcherPriority.Send) { throw new InvalidEnumArgumentException("priority"); } if (priority == DispatcherPriority.Inactive) { throw new ArgumentException("priority can not be inactive", "priority"); } if (method == null) { throw new ArgumentNullException("method"); } DispatcherOperation op = new DispatcherOperation(this, priority, method, arg, args); Queue(priority, op); return(op); }
public object Invoke(DispatcherPriority priority, Delegate method) { if (priority < 0 || priority > DispatcherPriority.Send) { throw new InvalidEnumArgumentException("priority"); } if (priority == DispatcherPriority.Inactive) { throw new ArgumentException("priority can not be inactive", "priority"); } if (method == null) { throw new ArgumentNullException("method"); } DispatcherOperation op = new DispatcherOperation(this, priority, method); Queue(priority, op); PushFrame(new DispatcherFrame()); throw new NotImplementedException(); }
private void Invoke(DispatcherOperation operation) { queue.Enqueue(operation.Priority, operation); DispatcherOperation currentOperation; while (TryDequeue(out currentOperation)) { currentOperation.Invoke(); if (currentOperation == operation) { return; } } if (disableProcessingRequests > 0) { throw new Granular.Exception("Can't invoke an operation while the dispatcher processing is disabled"); } throw new Granular.Exception("Can't invoke an inactive or aborted operation"); }
public DispatcherOperationEvent(DispatcherOperation op, TimeSpan timeout) { _operation = op; _timeout = timeout; _event = new ManualResetEvent(false); _eventClosed = false; lock (DispatcherLock) { // We will set our event once the operation is completed or aborted. _operation.Aborted += new EventHandler(OnCompletedOrAborted); _operation.Completed += new EventHandler(OnCompletedOrAborted); // Since some other thread is dispatching this operation, it could // have been dispatched while we were setting up the handlers. // We check the state again and set the event ourselves if this // happened. if (_operation._status != DispatcherOperationStatus.Pending && _operation._status != DispatcherOperationStatus.Executing) { _event.Set(); } } }
/// <summary> /// Invalidates the realization state of all items being hosted by this panel. After the invalidation, the panel will have its reality updated, which will occur asynchronously unless subsequently forced by <see cref="UpdateReality"/>. /// </summary> public void InvalidateReality() { if (RealizeOperation != null) { RealizeOperation.Abort(); } object state = null; Action action = null; action = delegate { RealizeOperation = null; state = RealizeCore(state); if (state != null && RealizeOperation == null) { RealizeOperation = Dispatcher.BeginInvoke(action, RealizationPriority); } }; RealizeOperation = Dispatcher.BeginInvoke(action, RealizationPriority); }
private object DispatcherOperation(object arg) { try { Debug.Assert(_operation != null && _operation.Status == DispatcherOperationStatus.Executing); _callback(arg); } finally { _operation = null; } return null; }
static void WindowActivating(object sender, WindowActivateEventArgs e) { if (Keyboard.FocusedElement == null && _lastFocusedElement != null && _lastFocusedElement.IsAlive) { var elementToSetFocus = _lastFocusedElement.Target as ILayoutElement; if (elementToSetFocus != null) { var manager = elementToSetFocus.Root.Manager; if (manager == null) return; IntPtr parentHwnd; if (!manager.GetParentWindowHandle(out parentHwnd)) return; if (e.HwndActivating != parentHwnd) return; _setFocusAsyncOperation = Dispatcher.CurrentDispatcher.BeginInvoke(new Action(() => { try { SetFocusOnLastElement(elementToSetFocus); } finally { _setFocusAsyncOperation = null; } }), DispatcherPriority.Input); } } }
/// <summary> /// Ensures that all items being hosted by this panel are properly realized or virtualized. /// </summary> public void UpdateReality() { RealizeOperation.Abort(); RealizeOperation = null; object state = null; do { state = RealizeCore(state); } while (state != null); }
void CollectLayoutItemsDeleted() { if (_collectLayoutItemsOperations != null) return; _collectLayoutItemsOperations = Dispatcher.BeginInvoke(new Action(() => { _collectLayoutItemsOperations = null; foreach (var itemToRemove in _layoutItems.Where(item => item.LayoutElement.Root != Layout).ToArray()) { if (itemToRemove != null && itemToRemove.Model != null && itemToRemove.Model is UIElement) { //((ILogicalChildrenContainer)this).InternalRemoveLogicalChild(itemToRemove.Model as UIElement); } itemToRemove.Detach(); _layoutItems.Remove(itemToRemove); } })); }
private void RecordGazePointToList(double x, double y, double ts) { gazeStream = Dispatcher.BeginInvoke(new SetEyePointDeligate(setPos), x, y, ts); }
public DispatcherOperationTaskMapping(DispatcherOperation operation) { Operation = operation; }
// Note: we pass "exitWhenRequested=false" to the base // DispatcherFrame construsctor because we do not want to exit // this frame if the dispatcher is shutting down. This is // because we may need to invoke operations during the shutdown process. public DispatcherOperationFrame(DispatcherOperation op, TimeSpan timeout) : base(false) { _operation = op; // We will exit this frame once the operation is completed or aborted. _operation.Aborted += new EventHandler(OnCompletedOrAborted); _operation.Completed += new EventHandler(OnCompletedOrAborted); // We will exit the frame if the operation is not completed within // the requested timeout. if(timeout.TotalMilliseconds > 0) { _waitTimer = new Timer(new TimerCallback(OnTimeout), null, timeout, TimeSpan.FromMilliseconds(-1)); } // Some other thread could have aborted the operation while we were // setting up the handlers. We check the state again and mark the // frame as "should not continue" if this happened. if(_operation._status != DispatcherOperationStatus.Pending) { Exit(); } }
private void InvokeAsync(DispatcherOperation operation) { queue.Enqueue(operation.Priority, operation); ProcessQueueAsync(); }
bool IWeakEventListener.ReceiveWeakEvent(Type managerType, object sender, EventArgs eventArgs) { var propertyChangedEventArgs = eventArgs as PropertyChangedEventArgs; if (propertyChangedEventArgs == null) return false; Debug.Assert(propertyChangedEventArgs.PropertyName == nameof(ICommandItem.IsVisible), "Unexpected PropertyChanged event occurred."); // Avoid unnecessary updates. if (_coerceVisibilityOperation != null && _coerceVisibilityOperation.Status == DispatcherOperationStatus.Pending) return true; // Do not take action immediately. There could be several visibility changes coming. _coerceVisibilityOperation = WindowsHelper.Dispatcher.BeginInvoke(_coerceVisibilityAction); return true; }
/// <summary> /// Initializes a new instance of the <see cref="DispatcherOperationProxy"/> class. /// </summary> /// <param name="operation">The operation.</param> public DispatcherOperationProxy(DispatcherOperation operation) { _operation = operation; }
private static void InvokeInSecurityContext(Object state) { DispatcherOperation operation = (DispatcherOperation)state; operation.InvokeImpl(); }
public abstract void Initialize(DispatcherOperation operation);
/// <summary> /// Открыть порт /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void btn_openPort_Click(object sender, RoutedEventArgs e) { try { if (Port != null) { bufReader.Abort(); recvDispatcher.Abort(); Port.Close(); Port = null; log_out("Порт закрыт", false); btn_openPort.Content = "Открыть порт"; } else { int baudRate; int dataBits = 8; string selectedPort = cb_port.SelectedValue.ToString(); string selectedSpeed = (cb_speed.Text ?? "").ToString(); if (!int.TryParse(selectedSpeed, out baudRate) || baudRate <= 0) throw new Exception("Введите корректное значение скорости"); if (selectedPort == string.Empty) throw new Exception("Выберите порт"); Port = new SerialPort(selectedPort, baudRate, Parity.None, dataBits, StopBits.One) { Handshake = System.IO.Ports.Handshake.None }; Port.Open(); recvDispatcher = Dispatcher.BeginInvoke(recvAction, DispatcherPriority.Background); bufReader.Start(); log_in(string.Format("Открыт порт {0}, скорость {1}", selectedPort, baudRate)); btn_openPort.Content = "Закрыть порт"; } } catch (UnauthorizedAccessException ex) { log_out(ex.Message, false, false); Port = null; } catch (Exception ex) { log_out(ex.Message, false, false); } }
public DispatcherOperation BeginInvoke (Delegate d, params object[] args) { DispatcherOperation op = null; lock (queuedOperations) { op = new DispatcherOperation (d, args); queuedOperations.Enqueue (op); if (!pending) { if (callback == null) callback = new TickCallHandler (dispatcher_callback); NativeMethods.time_manager_add_dispatcher_call (NativeMethods.surface_get_time_manager (Deployment.Current.Surface.Native), callback, IntPtr.Zero); pending = true; } } return op; }
/// <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; }
public DispatcherOperationEvent(DispatcherOperation op, TimeSpan timeout) { _operation = op; _timeout = timeout; _event = new ManualResetEvent(false); _eventClosed = false; lock(DispatcherLock) { // We will set our event once the operation is completed or aborted. _operation.Aborted += new EventHandler(OnCompletedOrAborted); _operation.Completed += new EventHandler(OnCompletedOrAborted); // Since some other thread is dispatching this operation, it could // have been dispatched while we were setting up the handlers. // We check the state again and set the event ourselves if this // happened. if(_operation._status != DispatcherOperationStatus.Pending && _operation._status != DispatcherOperationStatus.Executing) { _event.Set(); } } }
/// <summary> /// Handles the <see cref="CompositionTarget.Rendering"/> event. /// </summary> /// <param name="sender">The sender is in fact a the UI <see cref="Dispatcher"/>.</param> /// <param name="e">Is in fact <see cref="RenderingEventArgs"/>.</param> private void OnRendering(object sender, EventArgs e) { if (!renderTimer.IsRunning) return; // Check if there is a deferred updateAndRenderOperation in progress. if (updateAndRenderOperation != null) { // If the deferred updateAndRenderOperation has not yet ended... var status = updateAndRenderOperation.Status; if (status == DispatcherOperationStatus.Pending || status == DispatcherOperationStatus.Executing) { // ... return immediately. return; } updateAndRenderOperation = null; // Ensure that at least every other cycle is done at DispatcherPriority.Render. // Uncomment if animation stutters, but no need as far as I can see. // this.lastRenderingDuration = TimeSpan.Zero; } // If rendering took too long last time... if (lastRenderingDuration > MaxRenderingDuration) { // ... enqueue an updateAndRenderAction at DispatcherPriority.Input. updateAndRenderOperation = Dispatcher.BeginInvoke( updateAndRenderAction, DispatcherPriority.Input); } else { UpdateAndRender(); } }
void OnLayoutRootPropertyChanged(object sender, PropertyChangedEventArgs e) { if (e.PropertyName == "RootPanel") { if (IsInitialized) { var layoutRootPanel = CreateUIElementForModel(Layout.RootPanel) as LayoutPanelControl; LayoutRootPanel = layoutRootPanel; } } else if (e.PropertyName == "ActiveContent") { if (Layout.ActiveContent != null) { //Debug.WriteLine(new StackTrace().ToString()); //set focus on active element only after a layout pass is completed //it's possible that it is not yet visible in the visual tree if (_setFocusAsyncOperation == null) { _setFocusAsyncOperation = Dispatcher.BeginInvoke(new Action(() => { if (Layout.ActiveContent != null) FocusElementManager.SetFocusOnLastElement(Layout.ActiveContent); _setFocusAsyncOperation = null; }), DispatcherPriority.Background); } } if (!_insideInternalSetActiveContent) ActiveContent = Layout.ActiveContent != null ? Layout.ActiveContent.Content : null; } }
void UpdateUnread() { if (_updateUnreadOperation == null && Container != null) _updateUnreadOperation = ApplicationService.BeginInvoke(new Action(() => { _updateUnreadOperation = null; if (Container.IsVisibleLayout) _unreadCount = 0; var title = GetDefaultTitle(); Container.Title = _unreadCount == 0 ? title : string.Format("{0} {1}", title, _unreadCount); })); }
public DispatcherHookEventArgs(DispatcherOperation operation) { this.operation = operation; }
public DispatcherOperation BeginInvoke (Delegate d, params object[] args) { DispatcherOperation op = null; if (Deployment.IsShuttingDown) { /* DRT #232: some object calls us from the dtor, which happens to run upon shutdown. Here we access * Deployment::Current::Surface, which may have been destroyed if we're shutting down (and accessing * it again will recreate it, which is very bad). So just bail out if this is the case. */ return new DispatcherOperation (null, null); // return a dummy object } lock (queuedOperations) { op = new DispatcherOperation (d, args); queuedOperations.Enqueue (op); if (time_manager == IntPtr.Zero) { if (callback == null) callback = new TickCallHandler (dispatcher_callback); time_manager = NativeMethods.surface_get_time_manager_reffed (Deployment.Current.Surface.Native); NativeMethods.time_manager_add_dispatcher_call (time_manager, callback, IntPtr.Zero); } } return op; }
public DispatcherOperationAsyncResult(DispatcherOperation operation) { operation.ThrowIfNull("operation"); this._AsyncWaitHandle = new Lazy<WaitHandle>(this.AsyncWaitHandleFactory); this.Operation = operation; }
/// <summary> /// Parses the current document content /// </summary> public void Parse() { IsParsing = true; string code = ""; Dispatcher.Invoke(new Action(() => code = Editor.Text)); GC.Collect(); DModule newAst = null; //try { SyntaxTree = null; using (var sr = new StringReader(code)) using (var parser = DParser.Create(sr)) { var sw = new Stopwatch(); code = null; sw.Restart(); newAst = parser.Parse(); sw.Stop(); SyntaxTree = newAst; ParseTime = sw.Elapsed.TotalMilliseconds; } /*} catch (Exception ex) { ErrorLogger.Log(ex, ErrorType.Warning, ErrorOrigin.Parser); }*/ lastSelectedBlock = null; lastSelectedStatement = null; if (newAst != null) { newAst.FileName = AbsoluteFilePath; newAst.ModuleName = ProposedModuleName; } //TODO: Make semantic highlighting 1) faster and 2) redraw symbols immediately UpdateSemanticHighlighting(true); //CanRefreshSemanticHighlightings = false; UpdateTypeLookupData(); if (postParseOperation != null && postParseOperation.Status != DispatcherOperationStatus.Completed) postParseOperation.Abort(); postParseOperation = Dispatcher.BeginInvoke(new Action(() => { try { if (GlobalProperties.Instance.ShowSpeedInfo) CoreManager.Instance.MainWindow.SecondLeftStatusText = Math.Round((decimal)ParseTime, 3).ToString() + "ms (Parsing duration)"; UpdateFoldings(); CoreManager.ErrorManagement.RefreshErrorList(); RefreshErrorHighlightings(); } catch (Exception ex) { ErrorLogger.Log(ex, ErrorType.Warning, ErrorOrigin.System); } }), DispatcherPriority.ApplicationIdle); IsParsing = false; }
private void work() { while (!m_disposed) { bool getInput = false; using (m_lockHelper.GetLock()) { if (m_disposed) { continue; } else if (m_workWaiting) { getInput = true; m_workWaiting = false; } else { m_lockHelper.Wait(); continue; } } if (getInput && !m_disposed) { m_operation = Dispatcher.BeginInvoke(DispatcherPriority.Background, m_preWork); if (!m_disposed && m_operation.Wait() == DispatcherOperationStatus.Completed) { bool processInput = (bool)m_operation.Result; m_operation = null; if (processInput) { bool workSucceeded = false; try { m_work(); workSucceeded = true; } catch (Exception ex) { if (Util.IsCriticalException(ex)) { throw; } else { OnClientException(new NotifyWorkerClientExceptionEventArgs(ex)); } } if (!m_disposed && workSucceeded) { // Aside from just calling m_postWork, // we want to call OnClientException with null to clear // out a LastException, if one exists...all on the Dispatcher thread m_operation = Dispatcher.BeginInvoke(DispatcherPriority.Background, new Action(delegate() { m_postWork(); OnClientException(null); })); if (!m_disposed) { m_operation.Wait(); } m_operation = null; } // if (!m_disposed && workSucceeded) } // if (processInput && !m_disposed) } // if Operation completed } // if (getInput) } // while (!m_disposed) }
public void BeginInvoke(DispatcherOperation operation) { queue.Enqueue(operation.Priority, operation); ProcessQueue(); }