Exemple #1
0
 public WeakTimer(IWeakTimerSubscriber subscriber)
 {
     _subscriber = new WeakReference<IWeakTimerSubscriber>(subscriber);
     _timer = new DispatcherTimer();
     
     _timer.Tick += delegate { OnTick(); };
     _timer.Start();
 }
Exemple #2
0
        public TextPresenter()
        {
            this.caretTimer = new DispatcherTimer();
            this.caretTimer.Interval = TimeSpan.FromMilliseconds(500);
            this.caretTimer.Tick += this.CaretTimerTick;

            this.canScrollHorizontally = this.GetObservable(TextWrappingProperty)
                .Select(x => x == TextWrapping.NoWrap);

            Observable.Merge(
                this.GetObservable(SelectionStartProperty),
                this.GetObservable(SelectionEndProperty))
                .Subscribe(_ => this.InvalidateFormattedText());

            this.GetObservable(TextPresenter.CaretIndexProperty)
                .Subscribe(this.CaretIndexChanged);
        }
Exemple #3
0
        /// <summary>
        /// Starts a new timer.
        /// </summary>
        /// <param name="action">
        /// The method to call on timer tick. If the method returns false, the timer will stop.
        /// </param>
        /// <param name="interval">The interval at which to tick.</param>
        /// <param name="priority">The priority to use.</param>
        /// <returns>An <see cref="IDisposable"/> used to cancel the timer.</returns>
        public static IDisposable Run(Func<bool> action, TimeSpan interval, DispatcherPriority priority = DispatcherPriority.Normal)
        {
            var timer = new DispatcherTimer(priority);

            timer.Interval = interval;
            timer.Tick += (s, e) =>
            {
                if (!action())
                {
                    timer.Stop();
                }
            };

            timer.Start();

            return Disposable.Create(() => timer.Stop());
        }
        /// <summary>
        /// Runs a method once, after the specified interval.
        /// </summary>
        /// <param name="action">
        /// The method to call after the interval has elapsed.
        /// </param>
        /// <param name="interval">The interval after which to call the method.</param>
        /// <param name="priority">The priority to use.</param>
        /// <returns>An <see cref="IDisposable"/> used to cancel the timer.</returns>
        public static IDisposable RunOnce(
            Action action,
            TimeSpan interval,
            DispatcherPriority priority = DispatcherPriority.Normal)
        {
            var timer = new DispatcherTimer(priority) { Interval = interval };

            timer.Tick += (s, e) =>
            {
                action();
                timer.Stop();
            };

            timer.Start();

            return Disposable.Create(() => timer.Stop());
        }