public void Init(Func< bool > shouldPauseCb, ITimeProvider time, WeaponConfig config, Rect levelBounds, int shotDirection)
        {
            base.Init( shouldPauseCb, time, config, levelBounds );

            PrefabPoolManager.Prepare( ShotPrefabLink, 8);
            ShotDirection = shotDirection;
        }

 public BrowserExecutionContextCreator(IBrowserStepExecutionStrategyFactory stepExecutionStrategyFactory,
     IWebDriverFactory webDriverFactory, ITimeProvider timeProvider)
 {
     _stepExecutionStrategyFactory = stepExecutionStrategyFactory;
     _webDriverFactory = webDriverFactory;
     _timeProvider = timeProvider;
 }

 public virtual void Init(Func<bool> shouldPauseCb, ITimeProvider time, WeaponConfig config, Rect levelBounds)
 {
     base.Init( shouldPauseCb, time);
     Config = config;
     LevelBounds = levelBounds;
     ShotFiredTimeStamp = Time.Time;
 }

 public SecureCookieProvider(ITimeProvider timeProvider)
 {
     string key = ConfigurationManager.AppSettings.Get("CookieKey");
     string salt = ConfigurationManager.AppSettings.Get("CookieSalt");
     crypto = CryptoFactory.Rijndael(key, salt);
     this.timeProvider = timeProvider;
 }

        public static bool EvalDailyTrigger(this IDailyScheduledTask task, ITimeProvider timeProvider)
        {
            if (task.RepeatIntervalInDays <= 0 || ((Int32)(timeProvider.Time.Date - task.StartTime.Date).TotalDays % task.RepeatIntervalInDays != 0))
                return false;

            return TimeHelpers.AreTimesEqualToTheSecond(timeProvider.Time, task.StartTime);
        }

 public static IReaderStrategy Create(
     ISourceDefinitionConfigurator sources, ITimeProvider timeProvider, IPrincipal runAs)
 {
     var builder = new Builder();
     sources.ConfigureSourceProcessingStrategy(builder);
     return builder.Build(timeProvider, runAs);
 }

        public MainWindow(ITimeProvider provider)
        {

            LogTimeCommand = new DelegateCommand( ActionLogTime );
            _provider = provider;
            DataContext = this;

            Directory.CreateDirectory( "Work" );

            var doc = XDocument.Load( "config.xml" );
            _breakElements = doc.XPathSelectElements("//Break").ToList();

         
            var catList = doc.XPathSelectElements("//Category").Select(e => e.Value).ToList();
            Cats = new ObservableCollection< string >(catList);
            
#if DEBUG

            for ( var i = 0; i < 10; ++i )
            {
                Cats.Add( "Project "+i );
            }
#endif



            InitializeComponent();


            _dumpBreaks();


            list.IsEnabled = false;


            // Disable updater for now, fake time
           /* {
                startTime.Text = "8:00";
                _doNotUpdate = true;
            }*/

            //_doNotUpdate = false;
            _updater = Task.Run( () =>
            {

                while ( true )
                {
                    if ( DoNotUpdate == false )
                    {
                        startTime.Dispatcher.Invoke( () => startTime.Text = DateTime.Now.ToString( "HH:mm:ss" ) );
                    }
                    //startTime.Dispatcher.Invoke(() =>  startTime.Text = SystemClock.Instance.Now.ToString("HH:mm", null));
                   


                    Thread.Sleep( 1000 );
                }
            } ).ContinueWith( ErrorFunc );

        }

        public SystemInformationProvider(ITimeProvider timeProvider, IMachineNameProvider machineNameProvider, ISystemPerformanceDataProvider systemPerformanceDataProvider, IHttpStatusCodeCheckResultProvider httpStatusCodeCheckResultProvider)
        {
            if (timeProvider == null)
            {
                throw new ArgumentNullException("timeProvider");
            }

            if (machineNameProvider == null)
            {
                throw new ArgumentNullException("machineNameProvider");
            }

            if (systemPerformanceDataProvider == null)
            {
                throw new ArgumentNullException("systemPerformanceDataProvider");
            }

            if (httpStatusCodeCheckResultProvider == null)
            {
                throw new ArgumentNullException("httpStatusCodeCheckResultProvider");
            }

            this.timeProvider = timeProvider;
            this.machineNameProvider = machineNameProvider;
            this.systemPerformanceDataProvider = systemPerformanceDataProvider;
            this.httpStatusCodeCheckResultProvider = httpStatusCodeCheckResultProvider;
        }

        protected ReaderSubscriptionBase(
            IPublisher publisher,
            Guid subscriptionId,
            CheckpointTag @from,
            IReaderStrategy readerStrategy,
            ITimeProvider timeProvider,
            long? checkpointUnhandledBytesThreshold,
            int? checkpointProcessedEventsThreshold,
            bool stopOnEof,
            int? stopAfterNEvents)
        {
            if (publisher == null) throw new ArgumentNullException("publisher");
            if (readerStrategy == null) throw new ArgumentNullException("readerStrategy");
            if (timeProvider == null) throw new ArgumentNullException("timeProvider");
            if (checkpointProcessedEventsThreshold > 0 && stopAfterNEvents > 0)
                throw new ArgumentException("checkpointProcessedEventsThreshold > 0 && stopAfterNEvents > 0");

            _publisher = publisher;
            _readerStrategy = readerStrategy;
            _timeProvider = timeProvider;
            _checkpointUnhandledBytesThreshold = checkpointUnhandledBytesThreshold;
            _checkpointProcessedEventsThreshold = checkpointProcessedEventsThreshold;
            _stopOnEof = stopOnEof;
            _stopAfterNEvents = stopAfterNEvents;
            _subscriptionId = subscriptionId;
            _lastPassedOrCheckpointedEventPosition = null;

            _eventFilter = readerStrategy.EventFilter;

            _positionTagger = readerStrategy.PositionTagger;
            _positionTracker = new PositionTracker(_positionTagger);
            _positionTracker.UpdateByCheckpointTagInitial(@from);
        }

 protected CommandCreator(IOutputManager outputManager, ITimeProvider timeProvider, IMessagesRepository messagesRepository, IFollowingRepository followingRepository)
 {
     OutputManager = outputManager;
     TimeProvider = timeProvider;
     MessagesRepository = messagesRepository;
     FollowingRepository = followingRepository;
 }

 public static bool EvalWeeklyTrigger(this IWeeklyScheduledTask task, ITimeProvider timeProvider)
 {
     if (task.RepeatIntervalInWeeks <= 0 || (((Int32)(timeProvider.Time.Date - task.StartTime.Date).TotalDays / 7) % task.RepeatIntervalInWeeks != 0)) return false;
     var dayOfWeek = (int)timeProvider.Time.DayOfWeek;
     var daysOfWeek = (DaysOfWeek)(1 << dayOfWeek);
     return task.DaysOfWeekToActivate.HasFlag(daysOfWeek) && TimeHelpers.AreTimesEqualToTheSecond(timeProvider.Time, task.StartTime);
 }

 public void CalculateStoreOmittedOrPartlyCompletedShotPoints(DrillingDepartmentId id, ITimeProvider provider)
 {
     // Check if this was previously done
     // Store the data
     // TODO - SHOULD THIS BE VISUALISED
     // Issue OmittedOrPartlyCompletedShotPointsStored event
 }

        public void AddPlannedWorkgroup(DrillingDepartmentId id, RequestId requestId, WorkgroupEntity we, ITimeProvider provider)
        {
            // Create the Planned Workgroup
            DoWork("Create a Planned Workgroup and add to the Drilling Department Structure");

            RecordAndRealizeThat(new PlannedWorkgroupAddedToDepartment(id, requestId, we, provider.GetUtcNow()));
        }

        public override sealed IProjectionProcessingPhase[] CreateProcessingPhases(
            IPublisher publisher, Guid projectionCorrelationId, PartitionStateCache partitionStateCache,
            Action updateStatistics, CoreProjection coreProjection, ProjectionNamesBuilder namingBuilder,
            ITimeProvider timeProvider, IODispatcher ioDispatcher,
            CoreProjectionCheckpointWriter coreProjectionCheckpointWriter)
        {
            var definesFold = _sourceDefinition.DefinesFold;

            var readerStrategy = CreateReaderStrategy(timeProvider);

            var zeroCheckpointTag = readerStrategy.PositionTagger.MakeZeroCheckpointTag();

            var checkpointManager = CreateCheckpointManager(
                projectionCorrelationId, publisher, ioDispatcher, namingBuilder, coreProjectionCheckpointWriter,
                definesFold, readerStrategy);


            var resultWriter = CreateFirstPhaseResultWriter(
                checkpointManager as IEmittedEventWriter, zeroCheckpointTag, namingBuilder);

            var firstPhase = CreateFirstProcessingPhase(
                publisher, projectionCorrelationId, partitionStateCache, updateStatistics, coreProjection,
                _subscriptionDispatcher, zeroCheckpointTag, checkpointManager, readerStrategy, resultWriter);

            return CreateProjectionProcessingPhases(
                publisher, projectionCorrelationId, namingBuilder, partitionStateCache, coreProjection, ioDispatcher,
                firstPhase);
        }

 public override IProjectionProcessingPhase[] CreateProcessingPhases(
     IPublisher publisher, Guid projectionCorrelationId, PartitionStateCache partitionStateCache,
     Action updateStatistics, CoreProjection coreProjection, ProjectionNamesBuilder namingBuilder,
     ITimeProvider timeProvider, IODispatcher ioDispatcher,
     CoreProjectionCheckpointWriter coreProjectionCheckpointWriter)
 {
     return new IProjectionProcessingPhase[] {_phase1, _phase2};
 }

 public void ArchiveAction(ActionId actionId, ITimeProvider time)
 {
     var action = GetActionOrThrow(actionId);
     if (!action.Archived)
     {
         Apply(new ActionArchived(_aggState.Id, actionId, action.Project, time.GetUtcNow()));
     }
 }

 public static CheckpointStrategy Create(
     ISourceDefinitionConfigurator sources, ProjectionConfig config, ITimeProvider timeProvider)
 {
     var builder = new Builder();
     sources.ConfigureSourceProcessingStrategy(builder);
     return builder.Build(
         config, config.RunAs, Processing.ReaderStrategy.Create(sources, timeProvider, config.RunAs));
 }

 public void Register(
     TFChunkDb db, QueuedHandler mainQueue, ISubscriber mainBus, TimerService timerService,
     ITimeProvider timeProvider, IHttpForwarder httpForwarder, HttpService[] httpServices, IPublisher networkSendService)
 {
     _projections = new EventStore.Projections.Core.Projections(
         db, mainQueue, mainBus, timerService, timeProvider, httpForwarder, httpServices, networkSendService,
         projectionWorkerThreadCount: _projectionWorkerThreadCount, runProjections: _runProjections);
 }

 public QueueListener(IQueueListenerConfiguration config, IQueue queue, IScenarioRunner scenarioRunner, IProgressReporter progressReporter, ITimeProvider timeProvider)
 {
     _config = config;
     _queue = queue;
     _scenarioRunner = scenarioRunner;
     _progressReporter = progressReporter;
     _timeProvider = timeProvider;
 }

 public TransactionFileEventReader(IPublisher publisher, Guid distibutionPointCorrelationId, EventPosition @from, ITimeProvider timeProvider, bool stopOnEof = false, bool deliverEndOfTFPosition = true)
     : base(publisher, distibutionPointCorrelationId, stopOnEof)
 {
     if (publisher == null) throw new ArgumentNullException("publisher");
     _from = @from;
     _deliverEndOfTfPosition = deliverEndOfTFPosition;
     _timeProvider = timeProvider;
 }