void ISchedulable.Schedule(TaskScheduler scheduler, IFuture future)
 {
     _Future = future;
     _Scheduler = scheduler;
     _Future.RegisterOnDispose(this.OnDisposed);
     QueueStep();
 }

		public CacheRecord(IFuture future)
		{
			this.future = future;
			this.wait = new CountedEventWaitHandle(false, EventResetMode.ManualReset, "CacheRecord.Wait");
			this.refs = 1;
			CacheRecord.cacheRecordsExtant.crement(1);
		}

        public Menu(Game game, string description, IFuture future, params IMenuItem[] items)
        {
            Game = game;
            Description = description;
            Font = game.UIText;

            Items.AddRange(items);
        }

		private IFuture GetAccessFuture(AccessMethod accessMethod, FutureFeatures openDocFeatures, params IFuture[] methodParams)
		{
			IFuture[] array = new IFuture[2 + methodParams.Length];
			array[0] = this.GetOpenDocumentFuture(openDocFeatures);
			array[1] = new ConstantFuture(new IntParameter((int)accessMethod));
			Array.Copy(methodParams, 0, array, 2, methodParams.Length);
			return new ApplyFuture(new ApplyVerbPresent(), array);
		}

		public void RequestRenderRegion(IFuture asynchronousImageBoundsFuture)
		{
			if (this.renderRegion == null)
			{
				AsyncRef asyncRef = (AsyncRef)asynchronousImageBoundsFuture.Realize("LatentRegionHolder.RequestRenderRegion");
				asyncRef.AddCallback(new AsyncRecord.CompleteCallback(this.ImageBoundsAvailable));
				new PersistentInterest(asyncRef);
			}
		}

		public IFuture GetUserBounds(LatentRegionHolder latentRegionHolder, FutureFeatures features)
		{
			if (this.cachedUserBounds == null || this.lastUserBoundsRequest_latentRegionHolder != latentRegionHolder || this.lastUserBoundsRequest_features != features)
			{
				this.lastUserBoundsRequest_latentRegionHolder = latentRegionHolder;
				this.lastUserBoundsRequest_features = features;
				this.cachedUserBounds = this.backingSource.GetUserBounds(latentRegionHolder, features);
			}
			return this.cachedUserBounds;
		}

		public AsyncRecord(AsyncScheduler scheduler, IFuture cacheKeyToEvict, IFuture future)
		{
			this._cacheKeyToEvict = cacheKeyToEvict;
			this._future = future;
			this.scheduler = scheduler;
			this._present = null;
			this.asyncState = AsyncState.Prequeued;
			this.queuePriority = 0;
			this.qtpRef = new AsyncRef(this, "qRef");
		}

		public RenderRegion GetRenderRegionSynchronously(IFuture synchronousImageBoundsFuture)
		{
			Present present = synchronousImageBoundsFuture.Realize("LatentRegionHolder.GetRenderRegionSynchronously");
			this.StoreRenderRegion(present);
			if (this.renderRegion == null)
			{
				throw new Exception("Render region request failed, gasp: " + present.ToString());
			}
			return this.renderRegion;
		}

        void ISchedulable.Schedule(TaskScheduler scheduler, IFuture future)
        {
            if (future == null)
                throw new ArgumentNullException("future");

            _Future = future;
            _Scheduler = scheduler;
            _Future.RegisterOnDispose(this.OnDisposed);
            QueueStep();
        }

		public override Present Get(IFuture future, string refCredit)
		{
			if (SizeSensitiveCache.oneEntryAtATime)
			{
				Present present = base.Lookup(future);
				if (present != null)
				{
					return present;
				}
			}
			return base.Get(future, refCredit);
		}

        void QueueStepOnComplete (IFuture f) {
            if (_WakeDiscardingResult && f.Failed) {
                Abort(f.Error);
                return;
            }

            if (WakeCondition != null) {
                _WakePrevious = WakeCondition;
                WakeCondition = null;
            }

            _Scheduler.QueueWorkItem(_Step);
        }

		public UserBoundsRefVerb(LatentRegionHolder latentRegionHolder, IFuture delayedStaticBoundsFuture)
		{
			RenderRegion renderRegion = latentRegionHolder.renderRegion;
			if (renderRegion == null)
			{
				this.userRegion = null;
			}
			else
			{
				this.userRegion = renderRegion.Copy(new DirtyEvent());
			}
			this.delayedStaticBoundsFuture = delayedStaticBoundsFuture;
		}

		public OpenDocumentSensitivePrioritizedFuture(OpenDocumentSensitivePrioritizer prioritizer, IFuture future, IFuture openDocumentFuture)
		{
			this.prioritizer = prioritizer;
			this.future = future;
			this.openDocumentFuture = openDocumentFuture;
			object obj;
			Monitor.Enter(obj = OpenDocumentSensitivePrioritizedFuture.nextIdentityMutex);
			try
			{
				this._identity = OpenDocumentSensitivePrioritizedFuture.nextIdentity;
				OpenDocumentSensitivePrioritizedFuture.nextIdentity++;
			}
			finally
			{
				Monitor.Exit(obj);
			}
		}

		public Present Get(IFuture future, string refCredit)
		{
			string text = this.makeCachePathname(future, "fresh.");
			string text2 = this.makeCachePathname(future, "stale.");
			Monitor.Enter(this);
			try
			{
				long num;
				Present present = this.Fetch(text, out num);
				if (present != null)
				{
					D.Sayf(10, "fresh hit! {0}", new object[]
					{
						"fresh."
					});
					Present result = present;
					return result;
				}
				present = this.Fetch(text2, out num);
				if (present != null)
				{
					File.Move(text2, text);
					this.IncrementFreshCount(num);
					D.Sayf(10, "stale hit! {0} {1}", new object[]
					{
						"stale.",
						num
					});
					Present result = present;
					return result;
				}
			}
			finally
			{
				Monitor.Exit(this);
			}
			Present result2 = future.Realize(refCredit);
			this.ScheduleDeferredWrite(result2, text, future.ToString());
			D.Sayf(10, "miss", new object[0]);
			return result2;
		}

		public Present Lookup(IFuture future)
		{
			Monitor.Enter(this);
			CacheRecord cacheRecord;
			try
			{
				if (!this.cache.ContainsKey(future))
				{
					return null;
				}
				cacheRecord = this.cache[future];
				this.Touch(cacheRecord, false);
				cacheRecord.AddReference();
			}
			finally
			{
				Monitor.Exit(this);
			}
			Present result = cacheRecord.WaitResult("lookup", this.hashName);
			cacheRecord.DropReference();
			return result;
		}

		public bool Contains(IFuture future)
		{
			Monitor.Enter(this);
			bool result;
			try
			{
				if (this.cache.ContainsKey(future))
				{
					this.Touch(this.cache[future], false);
					result = true;
				}
				else
				{
					result = false;
				}
			}
			finally
			{
				Monitor.Exit(this);
			}
			return result;
		}

		public void Flush()
		{
			this.cachedCoordSys = null;
			this.cachedRendererCredit = null;
			this.cachedUserBounds = null;
			this.cachedImageRequest = null;
		}

        static void DispatchNewMessage (Peer from, string message) {
            _MessageBuilder.Remove(0, _MessageBuilder.Length);
            if (from != null) {
                _MessageBuilder.Append("<");
                _MessageBuilder.Append(from);
                _MessageBuilder.Append("> ");
                _MessageBuilder.Append(message);
            } else {
                _MessageBuilder.Append("*** ");
                _MessageBuilder.Append(message);
            }

            Messages.Add(new Message { From = from, Text = message, DisplayText = _MessageBuilder.ToString() });

            if (Messages.Count > MaxMessagesToStore) {
                int numToRemove = MaxMessagesToStore / 2;
                Messages.RemoveRange(0, numToRemove);
                MessageIdBase += numToRemove;
            }

            if (WaitingForMessages != null) {
                WaitingForMessages.Complete();
                WaitingForMessages = null;
            }
        }

        public ProcessWatcher(TaskScheduler scheduler, params string[] processNames)
        {
            Scheduler = scheduler;

            foreach (var pname in processNames) {
                var invariant = Path.GetFileNameWithoutExtension(pname).ToLowerInvariant();
                ProcessNames.Add(invariant);

                foreach (var process in Process.GetProcessesByName(invariant)) {
                    RunningProcessIds.Add(process.Id);
                    NewProcesses.Enqueue(process);
                }
            }

            try {
                var query = new WqlEventQuery(@"SELECT * FROM Win32_ProcessStartTrace");
                Watcher = new ManagementEventWatcher(query);
                Watcher.Options.BlockSize = 1;
                Watcher.EventArrived += new EventArrivedEventHandler(OnEventArrived);
                Watcher.Start();
                WatcherEnabled = true;
            } catch {
                Watcher = null;
                WatcherEnabled = false;

                TimerTask = Scheduler.Start(InitTimer(), TaskExecutionPolicy.RunAsBackgroundTask);
            }
        }

 IEnumerator<object> BeginSearch()
 {
     ActiveSearchQuery = PendingSearchQuery;
     PendingSearchQuery = null;
     ActiveSearch = Program.Scheduler.Start(
         PerformSearch(ActiveSearchQuery),
         TaskExecutionPolicy.RunAsBackgroundTask
     );
     yield break;
 }