public void UpdateHeartbeat()
        {
            // Create or Update External XML For Last Update Check DateTime
            if (!File.Exists(CheckUpdateFile))
            {
                DateTime DateTimeNow = DateTime.Now;
                XmlWriterSettings wSettings = new XmlWriterSettings();
                wSettings.Indent = true;
                XmlWriter writer = XmlWriter.Create(CheckUpdateFile, wSettings);
                writer.WriteStartDocument();
                writer.WriteComment("This file is generated by WWIV5TelnetServer - DO NOT MODIFY.");
                writer.WriteStartElement("WWIV5UpdateStamp");
                writer.WriteStartElement("LastChecked");
                writer.WriteElementString("DateTime", DateTimeNow.ToString());
                writer.WriteEndElement();
                writer.WriteEndElement();
                writer.WriteEndDocument();
                writer.Flush();
                writer.Close();
            }

            // Do Update Check
            updateTimer = new System.Timers.Timer(1000 * 60 * 60); // Hourly - Release Code
            //updateTimer = new System.Timers.Timer(1000 * 10); // 10 Seconds for Testing Only
            updateTimer.Elapsed += new ElapsedEventHandler(DoUpdateCheck);
            updateTimer.AutoReset = true;
            updateTimer.Enabled = true;
            if (Properties.Settings.Default.checkUpdates == "On Startup")
            {
                DoUpdateCheck(null, null);
            }
        }

 /// <summary>
 /// Start timer function
 /// </summary>
 private void StartTimer()
 {
     timer = new Timer(TimerInterval);
     timer.Elapsed += new ElapsedEventHandler(TimerEvent);
     timer.AutoReset = true;
     timer.Enabled = true;
 }

 protected override void InitializeImpl()
 {
     this._timers = this.TimerJobs
         .Where(j => j.Item1 > 0.0)
         .OrderBy(j => j.Item1)
         .Select(j =>
         {
             Timer timer = new Timer(j.Item1);
             timer.Elapsed += (sender, e) =>
             {
                 timer.Stop();
                 try
                 {
                     this.Host.RequestManager.Execute<Object>(Request.Parse(j.Item2));
                 }
                 finally
                 {
                     timer.Start();
                 }
             };
             return timer;
         }).ToList();
     this.RunInitializingJobs();
     base.InitializeImpl();
 }

 public HomeViewModel()
 {
     timer = new Timer(1000);
     timer.Elapsed += TimerElapsed;
     timer.AutoReset = true;
     timer.Start();
 }

 public SamplingTargetPointGenerator(int samplesPerSecond)
 {
     workerTimer = new Timer(1000 / samplesPerSecond);
     workerTimer.Elapsed += this.WorkerTimerElapsed;
     workerTimer.AutoReset = false;
     workerTimer.Start();
 }

 public Server()
 {
     config = new INIReader(System.IO.File.ReadAllLines("config.ini"));
     chat = new ServerChat();
     instance = this;
     vehicleController = new ServerVehicleController();
     api = new ServerApi(this);
     gamemodeManager = new GamemodeManager(api);
     gamemodeManager.loadFromFile("gamemodes/" + config.getString("gamemode"));
     server = new TcpListener(IPAddress.Any, config.getInt("game_port"));
     server.Start();
     server.BeginAcceptTcpClient(onIncomingConnection, null);
     playerpool = new List<ServerPlayer>();
     Timer timer = new Timer();
     timer.Elapsed += onBroadcastTimer;
     timer.Interval = config.getInt("broadcast_interval");
     timer.Enabled = true;
     timer.Start();
     UDPStartPort = config.getInt("udp_start_port");
     Timer timer_slow = new Timer();
     timer_slow.Elapsed += timer_slow_Elapsed;
     timer_slow.Interval = config.getInt("slow_interval");
     timer_slow.Enabled = true;
     timer_slow.Start();
     http_server = new HTTPServer();
     Console.WriteLine("Started game server on port " + config.getInt("game_port").ToString());
     Console.WriteLine("Started http server on port " + config.getInt("http_port").ToString());
 }

		protected override void Run ()
		{
			if (!Taskbar.TaskbarManager.IsPlatformSupported) {
				return;
			}
			
			bool areFileExtensionsRegistered = this.Initialize ();
			
			if (!areFileExtensionsRegistered) {
				return;
			}
			
			this.updateTimer = new Timer (1000);
			this.updateTimer.Elapsed += this.OnUpdateTimerEllapsed;
			this.updateTimer.AutoReset = false;
			
			this.recentFiles = DesktopService.RecentFiles;
			this.recentFiles.Changed += this.OnRecentFilesChanged;

			try {
				UpdateJumpList();
			} catch (Exception ex) {
				MonoDevelop.Core.LoggingService.LogError ("Could not update jumplists", ex);
			}
		}

        public ExchangesWindow()
        {
            InitializeComponent();
            DataContext = this;

            Exchanges = new ObservableCollection<Exchange>();

            List<Exchange> tmpExchanges;
            using (var entityContext = new MyDBContext())
            {
                tmpExchanges = entityContext.Exchanges.Include("Sessions").OrderBy(x => x.Name).ToList();
            }
            foreach (Exchange e in tmpExchanges)
            {
                Exchanges.Add(e);
            }

            ExchangesGrid.ItemsSource = Exchanges;

            _filterTimer = new Timer();
            _filterTimer.Enabled = false;
            _filterTimer.AutoReset = false;
            _filterTimer.Interval = 100; //milliseconds
            _filterTimer.Elapsed += _filterTimer_Elapsed;
        }

 /// <summary>
 /// Creates a new Instance of the ServerLog
 /// </summary>
 public ServerLog()
 {
     _buffer = new StringBuilder(4096);
     _writetimer = new Timer();
     _writetimer.Interval = 5000;
     _writetimer.Elapsed += _writetimer_Elapsed;
 }

 public MainWindow()
 {
     InitializeComponent();
     _timer = new Timer(30000);
     _timer.Elapsed += new ElapsedEventHandler(_timer_Elapsed);
     _timer.Enabled = true;
 }

        public Ux2CampaignService()
        {
            InitializeComponent();
            //this.cExcHandler = new GanoExceptionHandling(EXC_URL, cErrorFile);

            LoadSettings();

            if (!EventLog.SourceExists(EVENT_LOG_SOURCE))
                EventLog.CreateEventSource(EVENT_LOG_SOURCE, EVENT_LOG);

            try
            {
                this.cScheduleTimer = new System.Timers.Timer(this.cInterval);
                this.cScheduleTimer.Elapsed += new ElapsedEventHandler(cScheduleTimer_Elapsed);
                this.cScheduleTimer.Enabled = true;

                EventLog.WriteEntry(EVENT_LOG_SOURCE, "Ux2 Campaign Service Started on " + DateTime.Now.ToString() + "\n" +
                    "Settings loaded from " + Path.GetDirectoryName(Application.ExecutablePath) + "\\" + SETTINGS_FILE + "\n" +
                    "Processing Interval: " + this.cInterval + "ms\n" +
                    "Max Campaign Age: " + this.cMaxAge + "hours");

                this.cProcessor = new ScheduleProcessor(this.cConnectionString, cMaxAge);
                this.cProcessorCaller = new CallScheduleProcessor(this.cProcessor.ProcessSchedules);
            }
            catch (Exception exc)
            {
                //this.cExcHandler.LogExceptionQuiet(null, exc);
                EventLog.WriteEntry(EVENT_LOG_SOURCE, exc.Message);
            }
        }

 public Object CreateMainLoopTimer(MainServerLoop mainLoop, uint period)
 {
     myTimer = new Timer(period);
     myTimer.Elapsed += (sender, e) => {mainLoop();};
     myTimer.Enabled = true;
     return myTimer;
 }

        private void btnStart_Click(object sender, RoutedEventArgs e)
        {
            this.txtID.Text = string.Empty;
            this.txtName.Text = string.Empty;
            this.LblResult.Text = string.Empty;

            try
            {
                Init();
                int interval = 20;
                timer = new Timer();
                timer.Interval = interval;
                timer.Elapsed += new ElapsedEventHandler(timer_Elapsed);
                timer.AutoReset = true;
                timer.Enabled = true;
                timer.Start();

                this.btnStart.IsEnabled = false;
                this.btnStop.IsEnabled = true;
                this.btnStop.Focus();
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message, "Error");
            }
        }

 /// <summary>Constructs a Rx timer stage</summary>
 /// <param name="observer">the observer</param>
 /// <param name="initialDelay">the initial delay in milli-seconds</param>
 /// <param name="period">the period in milli-seconds</param>
 public RxTimerStage(IObserver<PeriodicEvent> observer, long initialDelay, long period)
 {
     _observer = observer;
     _timer = new Timer(period);
     _timer.Elapsed += (sender, e) => OnTimedEvent(sender, e, _observer, _value);
     _timer.Enabled = true;
 }

        /// <summary>
        /// Create an new Instance of the TCP-Listener on Port 5000
        /// </summary>
        internal Server()
        {
            try
            {
                AnrlDB.AnrlDataContext db = new AnrlDB.AnrlDataContext();
                if (!db.DatabaseExists())
                {
                    db.CreateDatabase();
                }

                CalculateTabels = new System.Timers.Timer(20000);
                CalculateTabels.Elapsed += new ElapsedEventHandler(CalculateTabels_Elapsed);
                CalculateTabels.Start();

                running = true;
                this.tcpListener = new TcpListener(IPAddress.Any, 5000);
                this.listenThread = new Thread(new ThreadStart(ListenForClients));
                this.listenThread.Start();
                db.Dispose();
            }
            catch (Exception ex)
            {
                Logger.Log("Exception in Server.Server" + ex.ToString(), 11);
            }
        }

 public void DisposeTimer() {
   if (tmTimeout != null) {
     tmTimeout.Enabled = false;
     tmTimeout.Dispose();
     tmTimeout = null;
   }
 }

        public Step2(Global g)
        {
            this.Opacity = 0.0f;
            this.g = g;

               // this.BackgroundImage = g.getTheme("bg");
            InitializeComponent();
            initTheme();
            noFocus.Select();

            System.Timers.Timer aTimer = new System.Timers.Timer();
            aTimer.Elapsed += new ElapsedEventHandler(OnTimedEvent);
            aTimer.Interval = 500;
            aTimer.Enabled = true;
            DateTime t1 = DateTime.Now;
            string H = t1.Hour.ToString();
            if (H.Length == 1) H = "0" + H;

            string M = t1.Minute.ToString();
            if (M.Length == 1) M = "0" + M;

            if (t1.Second % 2 == 0)
                SetTime(H + ":" + M);
            else
                SetTime(H + " " + M);

            //pbs.Add("1", pictureBox1);
               // pbs.Add("2", pictureBox2);
               // pbs.Add("3", pictureBox3);
               // pbs.Add("4", pictureBox4);

            loadMENU0();

            g.playVoice("5");
        }

 public SweepGenerator(IWorkContextAccessor workContextAccessor) {
     _workContextAccessor = workContextAccessor;
     _timer = new Timer();
     _timer.Elapsed += Elapsed;
     Logger = NullLogger.Instance;
     Interval = TimeSpan.FromMinutes(1);
 }

        public AudioPlayer()
        {
            InitializeComponent();
            timerUpdate = new Timer();

            this.timerUpdate.Interval = 50;
            this.timerUpdate.Elapsed += new ElapsedEventHandler(timerUpdate_Elapsed);
            this.pictureBoxWaveForm.MouseDown += new MouseButtonEventHandler(pictureBoxWaveForm_MouseDown);
            this.wavePosition.MouseDown += new MouseButtonEventHandler(pictureBoxWaveForm_MouseDown);
            
            
            this.wavePosition.Width = 2;
            this.wavePosition.Height = this.pictureBoxWaveForm.Height;
            this.wavePosition.Opacity = 0.5;
            this.wavePosition.Fill = Brushes.Red;

           
            _mixer = BassMix.BASS_Mixer_StreamCreate(44100, 2, BASSFlag.BASS_SAMPLE_FLOAT);
            if (_mixer == 0)
            {
                MessageBox.Show("Could not create mixer!");
                Bass.BASS_Free();
                return;
            }

            _mixerStallSync = new SYNCPROC(OnMixerStall);
            Bass.BASS_ChannelSetSync(_mixer, BASSSync.BASS_SYNC_STALL, 0L, _mixerStallSync, IntPtr.Zero);

            timerUpdate.Start();
            Bass.BASS_ChannelPlay(_mixer, false);


            newtrack(@"D:\OAIBC\2-13 California.mp3", null);

        }

        public void Setup(int delay, System.Collections.IList assemblies)
#endif
		{
            log.Info("Setting up watcher");

			files = new FileInfo[assemblies.Count];
			fileWatchers = new FileSystemWatcher[assemblies.Count];

			for (int i = 0; i < assemblies.Count; i++)
			{
                log.Debug("Setting up FileSystemWatcher for {0}", assemblies[i]);
                
				files[i] = new FileInfo((string)assemblies[i]);

				fileWatchers[i] = new FileSystemWatcher();
				fileWatchers[i].Path = files[i].DirectoryName;
				fileWatchers[i].Filter = files[i].Name;
				fileWatchers[i].NotifyFilter = NotifyFilters.Size | NotifyFilters.LastWrite;
				fileWatchers[i].Changed += new FileSystemEventHandler(OnChanged);
				fileWatchers[i].EnableRaisingEvents = false;
			}

			timer = new System.Timers.Timer(delay);
			timer.AutoReset = false;
			timer.Enabled = false;
			timer.Elapsed += new ElapsedEventHandler(OnTimer);
		}