public MainFormController(ICCTrayMultiConfiguration configuration, ISynchronizeInvoke owner, MainForm mainForm)
		{
            this.mainForm = mainForm;
			this.configuration = configuration;

			serverMonitors = configuration.GetServerMonitors();
			for (int i = 0; i < serverMonitors.Length; i++)
			{
				serverMonitors[i] = new SynchronizedServerMonitor(serverMonitors[i], owner);
			}
			aggregatedServerMonitor = new AggregatingServerMonitor(serverMonitors);
			queueIconProvider = new ResourceIntegrationQueueIconProvider();

			projectMonitors = configuration.GetProjectStatusMonitors(serverMonitors);
			execRunners = new BuildTransitionExecRunner[projectMonitors.Length];
			for (int i = 0; i < projectMonitors.Length; i++)
			{
				execRunners[i] = new BuildTransitionExecRunner(projectMonitors[i], configuration.Execs);
				projectMonitors[i] = new SynchronizedProjectMonitor(projectMonitors[i], owner);
			}
			aggregatedProjectMonitor = new AggregatingProjectMonitor(projectMonitors);
			projectStateIconProvider = new ConfigurableProjectStateIconProvider(configuration.Icons);
			projectStateIconAdaptor = new ProjectStateIconAdaptor(aggregatedProjectMonitor, projectStateIconProvider);
			soundPlayer = new BuildTransitionSoundPlayer(aggregatedProjectMonitor, new AudioPlayer(), configuration.Audio);
			LampController lampController = new LampController(configuration.X10,null);
			x10Controller = new X10Controller(aggregatedProjectMonitor,new DateTimeProvider(),configuration.X10,lampController);
			
			growlController = new GrowlController(aggregatedProjectMonitor, configuration.Growl);

#if !DISABLE_COM
			IBalloonMessageProvider balloonMessageProvider = new ConfigurableBalloonMessageProvider(configuration.BalloonMessages);
			speakerForTheDead = new SpeakingProjectMonitor(aggregatedProjectMonitor, balloonMessageProvider, configuration.Speech);
#endif
		}

        public static void InitializeCompile(ISynchronizeInvoke _isi, RichTextBox _rtMain, Button _Compile)
        {
            CompileRich     = _rtMain;
            MainForm        = _isi;
            CompileButton   = _Compile;

            if (!Directory.Exists("Source"))
                Directory.CreateDirectory("Source");

            if (Settings.Default.CoreGit == "")
            {
                CompileRich.AppendText("Core will not compile\nReason: No Core git settings");
                CompileButton.Enabled = true;
                return;
            }

            if (!File.Exists("Source\\Core\\CMakeLists.txt"))
                CloneGit(GitTypes.Core);
            else
                PullGit(GitTypes.Core);

            if (!Directory.Exists("Database"))
                CloneGit(GitTypes.Database);
            else
                PullGit(GitTypes.Database);
        }

 /// <summary>
 /// Downloads a page and all its references into a Site Storage
 /// </summary>
 /// <param name="url">The url of the page to download</param>
 /// <param name="storage">The storage into which to store the page and its references</param>
 /// <param name="rootFileName">The rootfile name for the ISiteStorage</param>
 /// <param name="target">An object implementing the
 /// ISynchronizeInvoke interface.  All events will be delivered
 /// through this target, ensuring that they are delivered to the
 /// correct thread.</param>
 public AsyncPageDownload(
     string url,
     ISiteStorage storage,
     string rootFileName,
     ISynchronizeInvoke target) : this (url, storage, rootFileName, "", target)
 {
 }

 public SBOBet(string text1, ISynchronizeInvoke invoke1, string text2, string text3, string text4, bool flag1, bool flag2, bool flag3, bool flag4, bool flag5, bool flag6, bool flag7, bool flag8, EnumCollection.eSpiderMethod method1, int num2, int num3, int num4, int num1)
 {
     this._strLoginName = "";
     this._strSynidNextRunning = "-1";
     this._strSynidNextToday = "-1";
     this._strSynidNextEarly = "-1";
     this._strSynidNextRunningTmp = "-1";
     this._strSynidNextTodayTmp = "-1";
     this._strSynidNextEarlyTmp = "-1";
     this._objMatchOutRightList = new List<MatchOutRight>();
     this._objMatchOddEvenList = new List<MatchOddEven>();
     this._objMatchTotalGoalList = new List<MatchTotalGoal>();
     this._isToSaveBetList = false;
     try
     {
         this.DoNew(text1, "SBOBet", num1, invoke1, text2, text3, text4);
         this.Init(flag1, flag2, flag3, flag4, flag5, flag6, flag7, flag8, method1, num2, num3, num4);
     }
     catch (Exception exception1)
     {
         ProjectData.SetProjectError(exception1);
         Exception exception = exception1;
         base._objErrorLogger.write(base._strName + ": EXCEPTION IN New: " + exception.Message);
         this.WriteProgramLogger(base._strName + ": EXCEPTION IN New: " + exception.Message);
         ProjectData.ClearProjectError();
     }
 }

 public static DemoModel Create(ISynchronizeInvoke syncObject)
 {
     var visualContext = new VisualContext();
     var shaders = new Shaders(visualContext, () => new ShaderFile(visualContext, syncObject));
     var textures = new Textures(visualContext);
     return new DemoModel(visualContext, shaders, textures, true);
 }

        public Explorer(ISynchronizeInvoke sync, object searchField, Label searchOverlay, Timer timer, Label status, TreeView fileList, string[] extensions, string runnerID, bool splitIntoDirectories)
        {
            this.target = sync;
            this.searchOverlay = searchOverlay;
            this.status = status;
            this.fileList = fileList;
            this.extensions = extensions;
            this.runnerID = runnerID;
            this.splitIntoDirectories = splitIntoDirectories;
            this.FilterTimer = timer;

            // If we have a search field, monitor it for changes.
            if (searchField != null)
            {
                if (searchField is TextBox)
                {
                    if (timer == null)
                        throw new Exception("Explorer tasked without a timer! Bad Hannah.");

                    this.searchField = (TextBox)searchField;

                    timer.Tick += OnFilterTimerTick;
                    this.searchField.TextChanged += OnFilterChanged;

                    if (searchOverlay != null)
                        searchOverlay.MouseUp += OnOverlayMouseUp;
                }
                else
                {
                    hardFilter = searchField.ToString().ToLower();
                }
            }
        }

 public WizardSolutionProcessor(ISynchronizeInvoke target, ConfigFile config, DTE applicationObject, AddInSettings settings)
     : base(target)
 {
     m_configuration = config;
     m_applicationObject = applicationObject;
     m_settings = settings;
 }

        public GameMonitorDisplayViewModel(ISynchronizeInvoke synchronizeInvoke, string fileNameAndPath, PollWatcherFactory pollWatcherFactory, Func<Type, ILog> loggerFactory)
        {
            this.synchronizeInvoke = synchronizeInvoke;
            logger = loggerFactory(typeof(GameMonitorDisplayViewModel));

            LoadGameToBeMonitored(fileNameAndPath, pollWatcherFactory);
        }

		public FwFdoUI(IHelpTopicProvider helpTopicProvider, ISynchronizeInvoke synchronizeInvoke)
		{
			m_helpTopicProvider = helpTopicProvider;
			m_synchronizeInvoke = synchronizeInvoke;
			m_activityMonitor = new UserActivityMonitor();
			m_activityMonitor.StartMonitoring();
		}

 public ShaderFile(VisualContext visualContext, ISynchronizeInvoke syncObject)
 {
     this.visualContext = visualContext;
     //establish watcher
     shaderWatcher.Changed += (object sender, FileSystemEventArgs e) => LoadShader(e.FullPath);
     shaderWatcher.SynchronizingObject = syncObject;
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="AsyncCreateXSD"/> class.
 /// </summary>
 /// <param name="isi">The isi.</param>
 /// <param name="xmlDoc">The XML doc.</param>
 /// <param name="FileName">Name of the file.</param>
 public AsyncCreateXSD(ISynchronizeInvoke isi, XmlDocument xmlDoc, string FileName)
     : base(isi)
 {
     // populate private vars
     _xmlDoc = xmlDoc;
     _fileName = FileName;
 }

 private static void InvokeIfRequired(ISynchronizeInvoke control, MethodInvoker action)
 {
     if (control.InvokeRequired)
         control.Invoke(action, new object[0]);
     else
         action();
 }

		public DelegateAsynchronousOperation(
			ISynchronizeInvoke target,
			AsyncrhonousOperationHandler handler)
			:base(target)
		{
			this.m_handler = handler;
		}

		public ProgressCollector(ISynchronizeInvoke eventThread, CancellationToken cancellationToken)
		{
			if (eventThread == null)
				throw new ArgumentNullException("eventThread");
			this.eventThread = eventThread;
			this.cancellationToken = cancellationToken;
			this.root = new MonitorImpl(this, null, 1);
		}

 /// <summary>
 /// Initializes a new instance of the <see cref="EventProvider"/> class.
 /// </summary>
 /// <param name="dataProvider">The data provider to get data from</param>
 /// <param name="interval">The interval in milliseconds the timer should fetch the data.</param>
 /// <param name="synchronizingObject">The synchronizing object. Specify your Form or Control here so that you don't have to invoke when handling events.</param>
 /// <param name="enabled">if set to <c>true</c> this class will immediately start fetching data from Spotify.</param>
 public EventProvider(DataProvider dataProvider, double interval, ISynchronizeInvoke synchronizingObject, bool enabled)
 {
     this.DataProvider = dataProvider;
     this.timer = new Timer(interval) { AutoReset = false };
     this.timer.Elapsed += (s, e) => this.UpdateData();
     this.EventSynchronizingObject = synchronizingObject;
     this.Enabled = enabled;
 }

        /// <summary>
        /// ThreadController constructor.
        /// </summary>
        public ThreadController(ISynchronizeInvoke invokeObject)
        {
            this.threadRunning = false;
            this.threadAborted = false;
            this.threadPaused = false;

            this.invokeObject = invokeObject;
        }

        public simulatedPICNetwork(string newPipeName, ISynchronizeInvoke eInvoke)
        {
            _pipename = newPipeName;

            _eventHandler = eInvoke;
            _pipe = new NamedPipeServerStream(_pipename, PipeDirection.InOut, 10, PipeTransmissionMode.Byte,
                                              PipeOptions.Asynchronous);
        }

        public SynchronizedProjectMonitor(IProjectMonitor projectMonitor, ISynchronizeInvoke synchronizeInvoke)
        {
            this.projectMonitor = projectMonitor;
            this.synchronizeInvoke = synchronizeInvoke;

            projectMonitor.Polled += new MonitorPolledEventHandler(ProjectMonitor_Polled);
            projectMonitor.BuildOccurred += new MonitorBuildOccurredEventHandler(ProjectMonitor_BuildOccurred);
        }

        public static void InitializeCompile(ISynchronizeInvoke _isi, RichTextBox _rtMain, Button _btnCompile)
        {
            MainForm    = _isi;
            MainRich    = _rtMain;
            MainButton  = _btnCompile;

            CompileCore();
            frmMain.SetStatus("Compiling");
        }

        public RuntimeEnvironment(string extension, ISynchronizeInvoke synchronizingObject, TimeSpan workFolderStateMinimumIdle)
        {
            AxCryptExtension = extension;

            _workFolderWatcher = CreateFileWatcher(WorkFolder.FullName);
            _workFolderWatcher.FileChanged += HandleWorkFolderFileChangedEvent;

            _delayedWorkFolderStateChanged = new DelayedAction(OnWorkFolderStateChanged, workFolderStateMinimumIdle, synchronizingObject);
        }