public void BeginUpdateLayout()
 {
     if (updateLayoutOperation == null || updateLayoutOperation.Status == DispatcherOperationStatus.Completed)
     {
         updateLayoutOperation = Dispatcher.CurrentDispatcher.BeginInvoke(DispatcherPriority.Background, (Action)UpdateLayout);
     }
 }

        public void InvokeParametersTest()
        {
            int value = 0;

            DispatcherOperation operation0 = new DispatcherOperation(() => value = 1);
            operation0.Invoke();
            Assert.AreEqual(1, value);
        }

 /// <summary>
 ///     Cancels a pending DispatcherOperation
 /// </summary>
 internal void Cancel()
 {
     if (IsPending)
     {
         _operation.Abort();
     }
     _operation = null;
 }

 internal void Cancel()
 {
     if (_operation != null)
     {
         Debug.Assert(_operation.Status == DispatcherOperationStatus.Pending);
         _operation.Abort();
         _operation = null;
     }
 }

        internal void Request(object arg)
        {
            if (_operation == null)
            {
                Debug.Assert(_callback != null);

                _operation =
                    Dispatcher.CurrentDispatcher.BeginInvoke(
                        DispatcherPriority.Loaded,
                        new DispatcherOperationCallback(DispatcherOperation), arg);
            }
        }

        /// <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);
        }

        /// <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;
            }
        }

        /// <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();
            }
        }

		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>
 /// Initializes a new instance of the <see cref="DispatcherOperationProxy"/> class.
 /// </summary>
 /// <param name="operation">The operation.</param>
 public DispatcherOperationProxy(DispatcherOperation operation)
 {
     _operation = 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();
                    }
                }
            }

 public abstract void Initialize(DispatcherOperation operation);

 private object DispatcherOperation(object arg)
 {
     try
     {
         Debug.Assert(_operation != null && _operation.Status == DispatcherOperationStatus.Executing);
         _callback(arg);
     }
     finally
     {
         _operation = null;
     }
     return null;
 }

            // 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();
                }

            }

 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;
        }

		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;
		}

        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 DispatcherOperationTaskMapping(DispatcherOperation operation)
 {
     Operation = operation;
 }

        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);
        }