Exemplo n.º 1
1
            /// <summary>
            /// U idle modu prvo saljemo ENQ karakter i startamo timer
            /// Ukoliko uredjaj ne odovori timer handler ce se pozvati kad istekne timer
            /// </summary>
            /// <param name="protocol"></param>
            /// <param name="message"></param>
            public override void Send(Protocol protocol, string message)
            {
                log.DebugFormat("IdleState:Send:Message={0}",message);

                try
                {
                    _message = message;
                    _message_sent = true;

                    protocol.SendEnq();
                    protocol.AckTimer.Interval = Timeout.NoResponseTimeOut;
                    _timerHandler = new ElapsedEventHandler(bind<object, ElapsedEventArgs, Protocol>(TimeoutHandler, protocol));
                    protocol.AckTimer.Elapsed += _timerHandler;
                    protocol.AckTimer.Start();
                }
                catch (Exception ex)
                {
                    log.Error(ex.ToString());
                    throw;
                }
            }
Exemplo n.º 2
0
 public Debouncer(double timeout_ms, ElapsedEventHandler action)
 {
     this.timeout_ms = timeout_ms;
     timer           = new System.Timers.Timer(timeout_ms);
     timer.AutoReset = false;
     timer.Elapsed  += action;
 }
Exemplo n.º 3
0
        private static void RecycleVlcControl(VlcControl oldControl, Form hostForm)
        {
            oldControl.Stop();
            oldControl.ResetMedia();
//            hostForm.Controls.Remove(oldControl);
//            oldControl.Dispose();

            var timer = new TimerX {
                Interval = 1
            };
            ElapsedEventHandler handler = (s, e) =>
            {
                hostForm.BeginInvoke(new Action(() =>
                {
                    //   CreateVlcControl(hostForm);
                    timer.Enabled = false;
                    oldControl.SetMedia(new FileInfo(source));
                    oldControl.Play();
                }));
            };


            timer.Elapsed  += handler;
            timer.AutoReset = false;
            timer.Enabled   = true;
        }
Exemplo n.º 4
0
        void PasteSetup()
        {
            if (!Directory.Exists(PasteSync))
                return;

            var dir = new DirectoryInfo(PasteSync);

            var check = new ElapsedEventHandler(delegate(object s, ElapsedEventArgs e)
            {
                foreach (FileInfo file in dir.GetFiles())
                {
                    string id = file.Name, nick = File.ReadAllText(file.FullName), info = string.Empty;

                    int z = nick.IndexOf(' ');
                    if (z != -1)
                    {
                        info = string.Concat(" - ", nick.Substring(z + 1));
                        nick = nick.Substring(0, z);
                    }

                    Message(Channel, string.Format("{0} pasted {1}{2}{3}", new string[] { nick, PasteURI, id, info }));
                    file.Delete();
                }
            });

            paste = new Timer(PasteFreq);

            foreach (FileInfo file in dir.GetFiles())
                file.Delete();

            paste.Elapsed += check;
            paste.Start();
        }
Exemplo n.º 5
0
 public TimerBela(double interval, ElapsedEventHandler eventHandler, int gameId) : base(interval)
 {
     Elapsed         += eventHandler;
     AutoReset        = false;
     GameId           = gameId;
     OriginalInterval = interval;
 }
Exemplo n.º 6
0
        private static void StartTimedDelegate(int interval, ElapsedEventHandler handler)
        {
            Timer t = new Timer(interval);

            t.Elapsed += handler;
            t.Start();
        }
Exemplo n.º 7
0
        public bool SetTimerPrincipale(DateTime date,TimeSpan intervallo,ElapsedEventHandler start)
        {
            TimeSpan data = date - DateTime.Now;
            _intervalloPrincipale = intervallo;
            /*
            #region deregistro
            foreach (MyInternalTimer timer in _timers.Values)
            {
                _timerPrincipale.RemoveEventHandler(timer.Start);
            }
            _timerPrincipale.RemoveEventHandler(SetNextIntervalloPrincipale);
            _timerPrincipale = new MyInternalTimer((long)data.TotalMilliseconds);
            #endregion

            #region registro
            //TODO non devo agganciare al timer principale i secondari ma li faccio partire immediatamente
            //quando il timer scatta (funzione scatto timer principale)
            foreach (MyInternalTimer timer in _timers.Values)
            {
                _timerPrincipale.AddEventHandler(timer.Start);
            }

            #endregion
            */
            _timerPrincipale = new MyInternalTimer((long)data.TotalMilliseconds);
            _timerPrincipale.AddEventHandler(start);
            _timerPrincipale.Start();
            _timerPrincipale.AddEventHandler(SetNextIntervalloPrincipale);
            return true;
        }
Exemplo n.º 8
0
        //Displays animation on level up.

        public void levelUp()
        {
            timer.Elapsed -= OnTimedEvent;
            ElapsedEventHandler OnLevelUp = UponMyDeath;

            lineTimer.Elapsed += OnLevelUp;
            lineTimer.Enabled  = true;
            while (timerCounter < 8)
            {
                if (timerCounter % 2 == 0)
                {
                    board.drawBoard(ConsoleColor.White);
                }
                else
                {
                    board.drawBoard();
                }
            }

            lineTimer.Stop();
            lineTimer.Elapsed -= OnLevelUp;
            timerCounter       = 0;
            timer.Elapsed     += OnTimedEvent;
            timer.Interval     = ms / level;
        }
Exemplo n.º 9
0
 /// <summary>
 /// Démarre le timer
 /// </summary>
 /// <param name="tickMethod">Méthode à appeler lors de chaque tick</param>
 private void SetTimer(ElapsedEventHandler tickMethod)
 {
     _timer           = new Timer(15);
     _timer.Elapsed  += tickMethod;
     _timer.AutoReset = true;
     _timer.Enabled   = true;
 }
Exemplo n.º 10
0
        public void Restart(bool autoReset, ElapsedEventHandler cb)
        {
            Debug.WriteLineIf(DEBUG, "Reset! " + _sysTime.ElapsedMilliseconds.ToString());
            _sysTime.Restart();

            if (!_started)
            {
                _timer.Stop(); // restart the timer
                Debug.WriteLineIf(DEBUG, "RE-Starting!");
            }
            else
            {
                return;
            }

            _cb = cb;
            _timer.AutoReset = true;
            _timer.Interval  = 200;
            _timer.Enabled   = true;
            _timer.Start();
            _started   = true;
            _interval  = (long)_period;
            _autoReset = autoReset;

            Debug.WriteLineIf(DEBUG, "Started! " + _sysTime.ElapsedMilliseconds.ToString());
        }
Exemplo n.º 11
0
        static void Callback(object state)
        {
            Timer timer = (Timer)state;

            if (timer.Enabled == false)
            {
                return;
            }
            ElapsedEventHandler events = timer.Elapsed;

            if (!timer.autoReset)
            {
                timer.Enabled = false;
            }
            if (events == null)
            {
                return;
            }

            ElapsedEventArgs arg = new ElapsedEventArgs(DateTime.Now);

            if (timer.so != null && timer.so.InvokeRequired)
            {
                timer.so.BeginInvoke(events, new object [2] {
                    timer, arg
                });
            }
            else
            {
                try {
                    events(timer, arg);
                } catch {
                }
            }
        }
Exemplo n.º 12
0
    void Start()
    {
        shipElapsed   = new ElapsedEventHandler(OnShipTimedEvent);
        scoreElapsed  = new ElapsedEventHandler(OnScoreTimedEvent);
        splashElapsed = new ElapsedEventHandler(OnSplashTimedEvent);
        gameElapsed   = new ElapsedEventHandler(OnGameTimedEvent);

        shipTimer.Elapsed   += shipElapsed;
        scoreTimer.Elapsed  += scoreElapsed;
        splashTimer.Elapsed += splashElapsed;
        gameTimer.Elapsed   += gameElapsed;
        scoreBoard.text      = "Score: " + score.ToString();
        StartGame();
        shipTimer.Interval = 5000;

        scoreTimer.Interval = 10000;

        splashTimer.Interval = 1000;

        gameTimer.Interval = 1000;
        gameTimer.Enabled  = true;

        roundTime  = 180;
        splashText = GameObject.Find("SplashText").GetComponent <TextMesh>();
    }
Exemplo n.º 13
0
        private void RemoveShootingHandler(int counter, ElapsedEventHandler playerShootingHandler)
        {
            switch (counter)
            {
            case 0:
                QuarterSecondNotifier.QuarterSecondElapsed4 -= playerShootingHandler;
                return;

            case 1:
                QuarterSecondNotifier.QuarterSecondElapsed1 -= playerShootingHandler;
                return;

            case 2:
                QuarterSecondNotifier.QuarterSecondElapsed2 -= playerShootingHandler;
                return;

            case 3:
                QuarterSecondNotifier.QuarterSecondElapsed3 -= playerShootingHandler;
                return;

            case 4:
                QuarterSecondNotifier.QuarterSecondElapsed4 -= playerShootingHandler;
                return;

            default:
                return;
            }
        }
Exemplo n.º 14
0
        public Scheduler(TimeSpan ts, ElapsedEventHandler elapsed)
        {
            var timeChecker = new Timer(ts.TotalMilliseconds);

            timeChecker.Elapsed += elapsed;
            timeChecker.Enabled  = true;
        }
Exemplo n.º 15
0
 private void StartTimer(ElapsedEventHandler elapsedEventHandler)
 {
     _timer          = new();
     _timer.Interval = _timerInterval;
     _timer.Elapsed += elapsedEventHandler;
     _timer.Start();
 }
Exemplo n.º 16
0
    public IAsyncResult BeginInvoke(Delegate method, object[] args)
    {
        ElapsedEventHandler handler = (ElapsedEventHandler)method;
        InvokeDelegate      D       = Invoke;

        return(D.BeginInvoke(handler, args, CallbackMethod, null));
    }
Exemplo n.º 17
0
        internal void TickInternal(double dt)
        {
            m_elapsed += dt;
            if (m_elapsed >= m_interval)
            {
                m_elapsed -= m_interval;

                if (!this.m_autoReset)
                {
                    Enabled = false;
                }

                try
                {
                    ElapsedEventHandler intervalElapsed = this.onIntervalElapsed;
                    if (intervalElapsed != null)
                    {
                        ElapsedEventArgs elapsedEventArgs = new ElapsedEventArgs();
                        intervalElapsed(this, elapsedEventArgs);
                    }
                }
                catch
                {
                }
            }
        }
Exemplo n.º 18
0
 public void DoTimer(double interval, ElapsedEventHandler elapseEvent)
 {
     Timer aTimer = new Timer(interval);
     aTimer.Elapsed += new ElapsedEventHandler(elapseEvent);
     aTimer.Elapsed += new ElapsedEventHandler((s, e) => ((Timer)s).Stop());
     aTimer.Start();
 }
Exemplo n.º 19
0
 void StartTimer(ref Timer t, string intervalKey, ElapsedEventHandler elapsed)
 {
     t           = new Timer(mIConstants[intervalKey]);
     t.AutoReset = true;
     t.Elapsed  += elapsed;
     t.Start();
 }
Exemplo n.º 20
0
 private void Start_time_click(object sender, RoutedEventArgs e)
 {
     if (timerActive == false && procList.SelectedProcess != null)
     {
         timerActive             = true;
         startTimeBut.Content    = "Stop!";
         selectedProcess.Content = "";
         timedProcLabel.Content  = StringHandling.UppercaseFirst(procList.SelectedProcess.ProcessName);
         int timeSecs = ((int)timeSlider.Value) * 60;
         ElapsedEventHandler handler = delegate(object anotherSender, ElapsedEventArgs args)
         {
             procList.killProcess(procList.SelectedProcess);
             timerActive = false;
             Application.Current.Dispatcher.Invoke((Action) delegate()
             {
                 startTimeBut.Content      = "Start!";
                 timedProcLabel.Content    = "";
                 timerRunningLabel.Content = "H: 0 M: 0 S: 0";
             });
         };
         curTimer = new ExTimer(timeSecs, handler, timerRunningLabel);
     }
     else if (timerActive == true && curTimer != null)
     {
         curTimer.stop();
         curTimer                  = null;
         startTimeBut.Content      = "Start!";
         timerActive               = false;
         timedProcLabel.Content    = "";
         timerRunningLabel.Content = "H: 0 M: 0 S: 0";
     }
 }
Exemplo n.º 21
0
        public void init()
        {
            sendhandler = new ElapsedEventHandler(sendFunc);
            overHandler = new ElapsedEventHandler(overPrint);

            timer20.Elapsed += sendhandler;
        }
Exemplo n.º 22
0
 static GameOfLife()
 {
     timer      = new Timer(1000);
     cells      = new string[NUM_CELLS, NUM_CELLS];
     curHandler = null;
     erase();
 }
Exemplo n.º 23
0
 internal void makeTimer(ElapsedEventHandler handler)
 {
     displayRefreshTimer           = new Timer(1000 / this.framerate);
     displayRefreshTimer.Elapsed  += handler;
     displayRefreshTimer.AutoReset = true;
     displayRefreshTimer.Enabled   = true;
 }
Exemplo n.º 24
0
 internal static void SetTimer(ElapsedEventHandler onTimedEvent)
 {
     timer           = new Timer(1200);
     timer.Elapsed  += onTimedEvent;
     timer.AutoReset = true;
     timer.Enabled   = true;
 }
Exemplo n.º 25
0
 public static void Start(ElapsedEventHandler handler, TimeSpan timeSpan)
 {
     _timer = new Timer(timeSpan.TotalMilliseconds);
     _timer.Elapsed += handler;
     _timer.AutoReset = true;
     _timer.Enabled = true;
 }
Exemplo n.º 26
0
 public TimerTask(int interval, bool repeat, IAsyncResult ar, ElapsedEventHandler handler)
 {
     _timer           = new Timer();
     _timer.Elapsed  += handler;
     _timer.AutoReset = repeat;
     _timer.Interval  = interval;
 }
Exemplo n.º 27
0
        /// <summary>
        /// Creates a
        /// </summary>
        /// <param name="callback"></param>
        /// <param name="time"></param>
        /// <param name="countdownStart"></param>
        public Countdown(SteamNerd steamNerd, SteamID chat, ElapsedEventHandler callback, float seconds, int countdownStart)
        {
            _countdownTimers = new Timer[countdownStart];

            MainTimer           = new Timer(seconds * 1000);
            MainTimer.AutoReset = false;
            MainTimer.Elapsed  += callback;
            MainTimer.Start();

            for (var i = 1; i <= countdownStart; i++)
            {
                if (seconds - i <= 0)
                {
                    return;
                }

                var timer           = new Timer(seconds - i);
                var countdownString = string.Format("{0}...", i);

                timer           = new Timer((seconds - i) * 1000);
                timer.AutoReset = false;
                timer.Elapsed  += (src, e) => steamNerd.SendMessage(countdownString, chat);
                timer.Start();

                _countdownTimers[i - 1] = timer;
            }
        }
Exemplo n.º 28
0
 public void OnBeat(ElapsedEventHandler handler)
 {
     lock (this._lock)
     {
         this._handler = handler;
     }
 }
Exemplo n.º 29
0
        public static async Task <IEnumerable <FlightDto> > GetFlightsWithDelay(this IFlightService service)
        {
            var taskCompletionSource = new TaskCompletionSource <IEnumerable <FlightDto> >();
            var timer = new Timer(TimerDelay);

            timer.Enabled   = true;
            timer.AutoReset = false;

            try
            {
                ElapsedEventHandler timerOnElapsed =
                    async(obj, args) =>
                {
                    taskCompletionSource.SetResult(await service.GetAll());
                    timer.Enabled = false;
                };

                timer.Elapsed += timerOnElapsed;
            }
            catch (Exception ex)
            {
                taskCompletionSource.SetException(ex);
            }

            return(await taskCompletionSource.Task);
        }
Exemplo n.º 30
0
        private void StartTimeoutTracking(int timeoutInSeconds)
        {
            ElapsedEventHandler handler = null;

            if (timeoutInSeconds == 0)
            {
                this.SetEndProcessingAction(new Action(this.EndProcessingDoNothing));
            }
            else if (timeoutInSeconds > 0)
            {
                lock (this._timerLock)
                {
                    System.Timers.Timer timer = new System.Timers.Timer {
                        Interval  = timeoutInSeconds * 0x3e8,
                        AutoReset = false
                    };
                    this._timer = timer;
                    if (handler == null)
                    {
                        handler = (_, eventArgs) => this.SetEndProcessingAction(new Action(this.EndProcessingDoNothing));
                    }
                    this._timer.Elapsed += handler;
                    this._timer.Start();
                }
            }
        }
Exemplo n.º 31
0
 public void StartTimer(ref Timer timer, ElapsedEventHandler Event)
 {
     timer          = new Timer();
     timer.Interval = interval;
     timer.Elapsed += new ElapsedEventHandler(Event);
     timer.Start();
 }
Exemplo n.º 32
0
        private ElapsedEventHandler CheckerBuilder(Timer timer, ChannelWithEmptyTime channel)
        {
            var res = new ElapsedEventHandler((sender, args) =>
            {
                var vc = client.GetChannel(channel.VoiceChannelId) as SocketVoiceChannel;
                if (vc == null)
                {
                    timer.Dispose();
                    return;
                }

                if (vc.Users.Any())
                {
                    channel.EmptyTimeSpan = null;
                    return;
                }
                else
                {
                    channel.EmptyTimeSpan  = channel.EmptyTimeSpan ?? TimeSpan.Zero;
                    channel.EmptyTimeSpan += TimeSpan.FromMilliseconds(timer.Interval);
                }

                if (channel.EmptyTimeSpan > TimeSpan.FromMinutes(1))
                {
                    vc.DeleteAsync().GetAwaiter().GetResult();
                    timer.Dispose();
                }
            });

            return(res);
        }
Exemplo n.º 33
0
 private void MyTimerCallback(object state)
 {
     if (state == this.cookie)
     {
         if (!this.autoReset)
         {
             this.enabled = false;
         }
         FILE_TIME lpSystemTimeAsFileTime = new FILE_TIME();
         GetSystemTimeAsFileTime(ref lpSystemTimeAsFileTime);
         ElapsedEventArgs e = new ElapsedEventArgs(lpSystemTimeAsFileTime.ftTimeLow, lpSystemTimeAsFileTime.ftTimeHigh);
         try
         {
             ElapsedEventHandler onIntervalElapsed = this.onIntervalElapsed;
             if (onIntervalElapsed != null)
             {
                 if ((this.SynchronizingObject != null) && this.SynchronizingObject.InvokeRequired)
                 {
                     this.SynchronizingObject.BeginInvoke(onIntervalElapsed, new object[] { this, e });
                 }
                 else
                 {
                     onIntervalElapsed(this, e);
                 }
             }
         }
         catch
         {
         }
     }
 }
Exemplo n.º 34
0
        public void InititateTimer(int interval, ElapsedEventHandler eventHandler)
        {
            var timer = new Timer(interval);

            timer.Elapsed += eventHandler;
            timer.Start();
        }
Exemplo n.º 35
0
 public Stopwatch(double time, ElapsedEventHandler after)
 {
     this.time       = time;
     timer           = new Timer();
     timer.Elapsed  += after;
     timer.AutoReset = false;
 }
Exemplo n.º 36
0
 public BackupUtility(ref IReliableStateManager stateManager, BackupConfig config, ElapsedEventHandler callback)
 {
     _stateManager = stateManager;
     _backupConfig = config;
     _timer = new Timer();
     _timer.Elapsed += callback;
     _timer.Interval = _backupConfig.BackupInterval;
 }
Exemplo n.º 37
0
 public Insomniac()
 {
   m_timer=new Timer();
   m_handler = new ElapsedEventHandler(handleWakeup);
   m_timer.Elapsed+=m_handler;
   m_timer.Interval=timeToAwake;
   m_timer.Start();
 }
Exemplo n.º 38
0
		private static Timer CreateTimer(ElapsedEventHandler elapsedEventHandler, int timeout, bool continuous, bool startAtCreation)
		{
			Timer timer = new Timer((double)(timeout * 0x3e8));
			timer.Elapsed += elapsedEventHandler;
			timer.AutoReset = continuous;
			timer.Enabled = startAtCreation;
			return timer;
		}
Exemplo n.º 39
0
		public PswsTimer(ElapsedEventHandler elapsedEventHandler, int timeout, bool continuous, bool startAtCreation)
		{
			this.timeout = new BoundedInteger(timeout, 1, 0x7fffffff);
			this.elapsedEventHandler = elapsedEventHandler;
			this.continuous = continuous;
			this.timer = PswsTimer.CreateTimer(elapsedEventHandler, this.timeout.Value, this.continuous, startAtCreation);
			this.disposed = false;
		}
Exemplo n.º 40
0
        // ReSharper restore PrivateFieldCanBeConvertedToLocalVariable

        /// <summary>
        /// Constructs a new GaugeTimer that invokes the provided handler.
        /// 
        /// If the interval millis override is provided, it'll be used. Otherwise a
        /// ConfigurableValue for "mjolnir.gaugeIntervalMillis" || 5000 will be used.
        /// 
        /// intervalMillisOverride should typically only be used for testing.
        /// </summary>
        /// <param name="onTick">Event handler to invoke on tick</param>
        /// <param name="intervalMillisOverride">Interval override (for unit testing)</param>
        internal GaugeTimer(ElapsedEventHandler onTick, IConfigurableValue<long> intervalMillisOverride = null)
        {
            _gaugeIntervalMillis = intervalMillisOverride ?? new ConfigurableValue<long>("mjolnir.gaugeIntervalMillis", 5000, UpdateStatsGaugeInterval);

            _timer = new Timer(_gaugeIntervalMillis.Value) { AutoReset = true };
            _timer.Elapsed += onTick;
            _timer.Enabled = true;
        }
Exemplo n.º 41
0
 public AsyncTimer(ElapsedEventHandler action, int ticks, int interval)
 {
     this.Timer = new Timer(interval);            
     this.Ticks = ticks;
     this.Timer.Elapsed += action;
     this.Timer.Elapsed += TickCounter;
     this.Timer.Enabled = true;
 }
Exemplo n.º 42
0
 public void FlashBoxStart()
 {
     IsFlashing = true;
     FlashTimer.Enabled = true;
     FlashTimer.AutoReset = true;
     FlashEvent = new ElapsedEventHandler((sender, e) => FlashBoxTick(sender, e));
     FlashTimer.Elapsed += FlashEvent;
 }
Exemplo n.º 43
0
        public static void Run(Int32 interval, ElapsedEventHandler eventHandler)
        {
            Timer timer;

            timer = new Timer(interval);
            timer.Elapsed += new ElapsedEventHandler(eventHandler);
            timer.Enabled = true;
            timer.AutoReset = true;
        }
Exemplo n.º 44
0
 public LicenseTimer(LicenseManagerLauncher licenseManagerLauncher)
 {
     Elapsed += new ElapsedEventHandler(licenseTimerElapsed);
     AutoReset = true;
     Interval = EXPIRED_REMINDER_FREQUENCY.TotalMilliseconds;
     lastPeriodicLicenseWarning = DateTime.UtcNow;
     this.licenseManagerLauncher = licenseManagerLauncher;
     Start();
 }
Exemplo n.º 45
0
        private static Timer CreateTimer(double interval, ElapsedEventHandler elapsedEventHandler)
        {
            WriteDebugOutput($"Creating new timer with interval of {interval}");

            var timer = new Timer(interval);
            timer.Elapsed += elapsedEventHandler;
            timer.Enabled = true;
            return timer;
        }
Exemplo n.º 46
0
        public bool SetTimer(TimeSpan data,ElapsedEventHandler ev)
        {
            if (!_timers.ContainsKey(data))
            {
                MyInternalTimer timerApertura = new MyInternalTimer((long)data.TotalMilliseconds+1);
                _timers.Add(data, timerApertura);
            }
            _timers[data].AddEventHandler(ev);
            _timers[data].Start();

            return true;
        }
Exemplo n.º 47
0
 public EmailBox(string Email, string Password, string ImapServer, string SmtpServer, int ImapPort, int SmtpPort, bool SmtpSSL, bool ImapSSL, int interval, ElapsedEventHandler handler)
 {
     this.Email = Email;
     this.Password = Password;
     this.ImapServer = ImapServer;
     this.SmtpServer = SmtpServer;
     this.ImapPort = ImapPort;
     this.SmtpPort = SmtpPort;
     this.ImapSSL = ImapSSL;
     this.SmtpSSL = SmtpSSL;
     emailTimer = new System.Timers.Timer(interval);
     this.emailTimer.Elapsed += handler;
 }
Exemplo n.º 48
0
 private EasingTimer(int n, TimerFunction func, List<angleXYZ> angles, int dir, rotateAxisType rotateAxis, timerUPFunction funcUp = null)
     : base(100)
 {
     this.firstAngle = 0;
     this.rotateN = n;
     this.begin_time = DateTime.Now;
     this.func = new ElapsedEventHandler(func);
     this.Elapsed += this.func;
     this._run = false;
     this.dir = dir;
     this.rotateAxis = rotateAxis;
     this.funcUp = funcUp;
 }
Exemplo n.º 49
0
        protected void Application_Start()
        {
            AreaRegistration.RegisterAllAreas();
            WebApiConfig.Register(GlobalConfiguration.Configuration);
            FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
            RouteTable.Routes.MapHubs();
            RouteConfig.RegisterRoutes(RouteTable.Routes);
            BundleConfig.RegisterBundles(BundleTable.Bundles);
            AuthConfig.RegisterAuth();

            GlobalQuarterSecondTimerCounter = 1;

            quarterSecondTimerHandler = (sender, e) => UpdateCounter();
            GlobalQuarterSecondTimer.Enabled = true;
            GlobalQuarterSecondTimer.Elapsed += quarterSecondTimerHandler;
        }
Exemplo n.º 50
0
 public LogicControl(Ballz game)
 {
     Game = game;
     state = GameState.Unknown;
     ButtonRepeat = new Timer(62.5);
     ButtonRepeat.AutoReset = true;
     repeatHandler = (s,e)=>{};
     ButtonRepeat.Elapsed += repeatHandler;
     ButtonDelay = new Timer(1000);
     ButtonDelay.AutoReset = false;
     ButtonDelay.Elapsed += (s, e) =>
     {
         ButtonRepeat.Stop();
         ButtonRepeat.Start();
     };
 }
Exemplo n.º 51
0
        //TODO: keeping this *only* for testing purposes -- but not sure that even makes sense
        internal PdhHelper(bool isPreVista, IEnumerable<string> computerNames, IEnumerable<string> counters, bool ignoreBadStatusCodes)
        {
            this._isPreVista = isPreVista;
            this._ignoreBadStatusCodes = ignoreBadStatusCodes;
            this._backgroundTask = (state, eventArgs) => { _firstRead.Set(); _backgroundTimer.Stop(); _backgroundTimer.Elapsed -= _backgroundTask; };
            this._backgroundTimer.Elapsed += this._backgroundTask;
            ConnectToDataSource();

            List<string> validPaths = ParsePaths(counters.PrefixWithComputerNames(computerNames)).ToList();

            if (validPaths.Count == 0)
                throw new Exception(string.Format(CultureInfo.CurrentCulture, GetEventResources.CounterPathIsInvalid, new object[] { string.Empty }));

            OpenQuery();
            AddCounters(validPaths);
            PerformFirstRead();
        }
Exemplo n.º 52
0
        public static String Add(int delay, ElapsedEventHandler action, bool repeat = false)
        {
            String id = Tools.md5(String.Format("{0}", Bot.EpochTimestampMS + (ulong)timers.Count));
            Timer t = new Timer(delay);
            t.Elapsed += action;
            if (!repeat)
                t.Elapsed += delegate
                {
                    t.Stop();
                    Remove(id);
                };

            lock (timers)
            {
                timers.Add(id, t);
                t.Start();
                return id;
            }
        }
Exemplo n.º 53
0
        public void SetTimer(int momentoApertura, int durataApertura, string name,
            ElapsedEventHandler Apri, ElapsedEventHandler Chiudi)
        {
            Timer timerApertura = new Timer(momentoApertura);
            Timer timerChiusura = new Timer(momentoApertura + durataApertura);

            timerApertura.Elapsed += Apri;
            timerChiusura.Elapsed += Chiudi;

            timerApertura.Start();
            timerChiusura.Start();
            timerApertura.AutoReset = false;
            timerChiusura.AutoReset = false;

            Timer[] timerPerValvola = new Timer[2];
            timerPerValvola[0] = timerApertura;
            timerPerValvola[1] = timerChiusura;

            _timers.Add(name, timerPerValvola);
        }
Exemplo n.º 54
0
 public MyDigitalClock()
 {
     InitializeComponent();
     deleg = new MethodInvoker(invoke);
     timer = new ElapsedEventHandler(lblTimeInvoke);
     Process[] MyProc = Process.GetProcessesByName("time");
     if (MyProc.Length == 1 || MyProc.Length == 0)
     {
         close = false;
     }
     else if (MyProc.Length == 2)
     {
         MessageBox.Show("Can't run as the program is already running");
         close = true;
     }
     ReadFile();
     SetOptions();
     myTime = new System.Timers.Timer(1000);
     myTime.Enabled = true;
     myTime.Elapsed += timer;
 }
Exemplo n.º 55
0
        public ExTimer(int seconds, ElapsedEventHandler handler, Label labelToUpdate)
        {
            time = seconds;
            timeElapsed = 0;

            // Process kill timer.
            timer.Elapsed += handler;
            timer.Elapsed += timer_Elapsed;
            timer.Interval = seconds * 1000; // Seconds to miliseconds.
            timer.Enabled = true;
            GC.KeepAlive(timer);

            this.labelToUpdate = labelToUpdate;
            if (labelToUpdate != null)
            {
                // UI timer.
                UITimer.Elapsed += updateLabel;
                UITimer.Interval = 1000; // Each second.
                UITimer.Enabled = true; // Only enable, if update is wanted.
                GC.KeepAlive(UITimer);
            }
        }
Exemplo n.º 56
0
 private void InitilizeProgressTimer()
 {
     stopWatch.Start();
     bool throwing = false;
     try
     {
         progressTimer = new Timer
         {
             AutoReset = false,
             Interval = progressInterval.TotalMilliseconds
         };
         progressTimerOnElapsed = (sender, args) =>
         {
             ProgressRecord pr;
             if (progressStatus.TryGetProgressRecord(out pr))
             {
                 this.progress(pr);
             }
             progressTimer.Enabled = true;
         };
         progressTimer.Elapsed += progressTimerOnElapsed;
         progressTimer.Enabled = true;
     }
     catch (Exception)
     {
         throwing = true;
         throw;
     }
     finally
     {
         if (throwing && progressTimer != null)
         {
             progressTimer.Elapsed -= progressTimerOnElapsed;
             progressTimer.Enabled = false;
             progressTimer.Dispose();
             progressTimer = null;
         }
     }
 }
Exemplo n.º 57
0
        public ServiceScheduler()
        {
            Services.WundergroundQuery();

            try
            {
                Timer tmrTimersTimer = new Timer();
                int second = 1000;
                int minute = second*60;
                tmrTimersTimer.Interval = 10 * minute; //
                // Anonymous delegate
                ElapsedEventHandler handler = new ElapsedEventHandler(delegate(object o, ElapsedEventArgs e)
                {
                    Services.WundergroundQuery();
                });
                tmrTimersTimer.Elapsed += handler;
                tmrTimersTimer.Start();
            }
            catch (Exception ex)
            {

            }
        }
Exemplo n.º 58
0
        /// <summary>
        /// Creates a 
        /// </summary>
        /// <param name="callback"></param>
        /// <param name="time"></param>
        /// <param name="countdownStart"></param>
        public Countdown(SteamNerd steamNerd, SteamID chat, ElapsedEventHandler callback, float seconds, int countdownStart)
        {
            _countdownTimers = new Timer[countdownStart];

            MainTimer = new Timer(seconds * 1000);
            MainTimer.AutoReset = false;
            MainTimer.Elapsed += callback;
            MainTimer.Start();

            for (var i = 1; i <= countdownStart; i++)
            {
                if (seconds - i <= 0) return;

                var timer = new Timer(seconds - i);
                var countdownString = string.Format("{0}...", i);

                timer = new Timer((seconds - i) * 1000);
                timer.AutoReset = false;
                timer.Elapsed += (src, e) => steamNerd.SendMessage(countdownString, chat);
                timer.Start();

                _countdownTimers[i - 1] = timer;
            }
        }
Exemplo n.º 59
0
 /// <summary>
 /// Constructeur surchargé initalisant un Timer, lui affectant une méthode de réaction et un interval de temps
 /// </summary>
 /// <param name="interval">Interval avant que la méthode de réaction ne soit appelée</param>
 /// <param name="eventManager">Méthode de réaction à appeler lorsque le Timer attaint 0</param>
 public Minuteur(double interval, ElapsedEventHandler eventManager)
     : this(eventManager)
 {
     this.Timer = interval;
 }
Exemplo n.º 60
0
 /// <summary>
 /// Constructeur par défault
 /// Instancie un nouveau Timer et lui affecte une méthode de réaction
 /// </summary>
 /// <param name="eventManager">Méthode de réaction à appeler lorsque le Timer atteint 0</param>
 public Minuteur(ElapsedEventHandler eventManager)
 {
     timer = new Timer();
     timer.Elapsed += eventManager; //affecte la méthode de réaction à l'évènement Elapsed
     timer.AutoReset = true; //permet de recommencer le compte à rebours une fois fini
 }