private void InvokeTimeChanged()
{
if ((!haltEvents) && (TimeChanged != null))
{
TimeChanged.Invoke(this, new EventArgs());
}
}
private void OnTimeChanged()
{
if (TimeChanged != null)
{
TimeChanged.Invoke(this, new EventArgs());
}
}
private void timeEntryControl_TimeChanged(object sender, EventArgs e)
{
if (TimeChanged != null)
{
TimeChanged.Invoke(this, e);
}
}
private void valueChanged(object sender, EventArgs e)
{
if (FrameMask != null)
{
FrameMask.Time = (int)numericUpDown1.Value;
TimeChanged?.Invoke(this);
}
else
{
TimeChanged?.Invoke(this);
}
}
async void UpdateTime()
{
var delayToNextMinute = 60 - DateTime.Now.Second;
await Task.Delay(delayToNextMinute * 1000);
while (true)
{
Time = DateTime.Now.ToString("hh:mm tt");
TimeChanged?.Invoke(this, new EventArgs());
await Task.Delay(60000);
}
}
void OnTimeInSecondsChanged(ChangeEvent <float> evt)
{
if (m_Clip == null)
{
return;
}
int frameValue = Mathematics.Missing.roundToInt(evt.newValue * m_Clip.SampleRate);
m_FrameField.SetValueWithoutNotify(frameValue);
TimeChanged?.Invoke(evt.newValue);
}
private void ChangeElapsedTime(object state)
{
if (_isTimerMode)
{
RunTimer();
}
else
{
RunStopwatch();
}
TimeChanged?.Invoke(this, EventArgs.Empty);
}
public void Reset()
{
MIDITime = 0;
var pause = Paused;
Paused = true;
TimeChanged?.Invoke();
if (!pause)
{
PauseChanged?.Invoke();
}
}
void OnFrameChanged(ChangeEvent <int> evt)
{
if (m_Clip == null)
{
return;
}
float secondsValue = evt.newValue / m_Clip.SampleRate;
{
m_SecondsField.SetValueWithoutNotify(secondsValue);
TimeChanged?.Invoke(secondsValue);
}
}
private void VlcMediaPlayerTimeChanged(object sender, EventArgs e)
{
if (_disposing || _isStopping)
{
return;
}
Dispatcher.BeginInvoke(DispatcherPriority.Normal, new Action(() =>
{
OnPropertyChanged(() => Time);
TimeChanged?.Invoke(this, new EventArgs());
}));
}
private void dt_ticker(object sender, object e)
{
DateTime newTime = rtc_controller.GetTime();
if (CompareTime(newTime, current_time))
{
current_time = newTime;
if (TimeChanged != null)
{
TimeChanged.Invoke(this, new TimeEventArgs(current_time));
}
}
}
IEnumerator TimeRoutine()
{
while (Hour < MaxHour)
{
if (timeScale == 0f)
{
yield return(new WaitForTimeUnpaused());
}
var timeStep = 1f / (TimeSpeed * timeScale);
yield return(new WaitForTimeElapsed(timeStep));
Minute += 1;
MinuteTicked?.Invoke(this, new TimeEventArgs(Minute, Hour, Year));
var hourChanged = Minute >= 60;
Hour += hourChanged ? 1 : 0;
Minute %= 60;
if (hourChanged)
{
if (Hour >= MorningHour && Hour <= EveningHour)
{
WorkingHourTicked?.Invoke(this,
new TimeEventArgs(Minute, Hour, Year));
}
}
TimeChanged?.Invoke(this, new TimeEventArgs(Minute, Hour, Year));
if (Hour == MorningHour && Minute == 0)
{
Morning?.Invoke(this, EventArgs.Empty);
}
if (Hour == EveningHour && Minute == 0)
{
Evening?.Invoke(this, EventArgs.Empty);
}
}
Year += 1;
Hour = MinHour;
Minute = 0;
TimeChanged?.Invoke(this, new TimeEventArgs(Minute, Hour, Year));
YearTicked?.Invoke(this, new TimeEventArgs(Minute, Hour, Year));
StopTime();
}
public void Seek(float position)
{
var allowedPosition = Math.Max(Math.Min(position, stopPosition), startPosition);
if (mediaPlayer.State == VLCState.Ended)
{
mediaPlayer.Stop();
PlayUntillBuffered();
}
mediaPlayer.Position = allowedPosition;
time = mediaPlayer.Time;
TimeChanged?.Invoke(this, time);
}
private void TbSeasons_Checked(object sender, RoutedEventArgs e)
{
ToggleButton clicked = sender as ToggleButton;
foreach (var tb in tbSeasons)
{
if (tb.IsChecked == true && tb != clicked)
{
tb.IsEnabled = true;
tb.IsChecked = false;
return;
}
}
TimeChanged?.Invoke(this, e);
}
private void TbYears_Checked(object sender, RoutedEventArgs e)
{
ToggleButton clicked = sender as ToggleButton;
foreach (var tb in tbYears)
{
if (tb.IsEnabled == false)
{
tb.IsEnabled = true;
tb.IsChecked = false;
break;
}
}
clicked.IsEnabled = false;
TimeChanged?.Invoke(this, e);
}
public void Pause()
{
if (Paused)
{
return;
}
MIDITime += (DateTime.UtcNow - Time).TotalSeconds * Speed;
var pause = Paused;
Paused = true;
TimeChanged?.Invoke();
if (!pause)
{
PauseChanged?.Invoke();
}
}
protected void HangleTextChange(UIChangeEventArgs evt)
{
Text = (string)evt.Value;
Console.WriteLine($"{ID} alterou texto:" + Text);
TextChanged?.Invoke(Text);
switch (InputType)
{
case InputType.Date: {
bool ok = System.DateTime.TryParseExact(Text, "HH:mm", CultureInfo.InvariantCulture, DateTimeStyles.None, out DateTime dt);
DateTime = dt;
if (ok)
{
DateTimeChanged?.Invoke(dt);
}
break;
}
case InputType.Time: {
bool ok = System.TimeSpan.TryParse(Text, out TimeSpan tm);
Time = tm;
if (ok)
{
TimeChanged?.Invoke(tm);
}
else
{
TimeChanged?.Invoke(null);
}
break;
}
case InputType.Number: {
bool ok = decimal.TryParse(Text, out decimal dc);
DecimalValue = dc;
Console.WriteLine($"alterou numero {dc.ToString()}");
if (ok)
{
DecimalValueChanged?.Invoke(dc);
}
else
{
DecimalValueChanged?.Invoke(null);
}
break;
}
}
}
public void Add(Period period)
{
try
{
Time = Time.Plus(period);
}
catch (IndexOutOfRangeException)
{
string message = "Time out of range";
if (Time.Calendar != CalendarSystem.Iso)
{
message += ". Try changing calendar to ISO to fix";
}
MessageBox.Show(message, "Time error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
TimeChanged?.Invoke(this, new EventArgs());
}
public void Update()
{
if (state != TimerState.Running)
{
return;
}
second++;
if (second == 59)
{
second = 0;
minute++;
}
if (minute == 59)
{
minute = 0;
hour++;
}
if (hour == 24)
{
hour = 1;
day++;
}
if (day == 31)
{
day = 1;
month++;
}
if (month == 12)
{
month = 1;
year++;
}
if (lastTime != CurrentTime)
{
TimeChanged?.Invoke();
}
lastTime = currentTime;
}
public void RunClock(int times)
{
for (int i = 0; i < times; ++i)
{
Thread.Sleep(100);
DateTime currentTime = DateTime.Now;
if (currentTime.Second != this.second)
{
TimeEventArgs timeEventArgs = new TimeEventArgs()
{
Hour = this.hour,
Minute = this.minute,
Second = this.second
};
TimeChanged?.Invoke(this, timeEventArgs);
this.hour = currentTime.Hour;
this.minute = currentTime.Minute;
this.second = currentTime.Second;
}
}
}
private void TimerCallback(object state = null)
{
try
{
_SyncContext.Post((o) =>
{
// grab the current date and time so both events, if elligible,
// are raised with the same event args
var now = DateTime.Now;
// set the main clock
MainClockInfo.SetRawDateTimeNow(now);
// and the auxiliary clocks
if (AuxiliaryClocksInfo != null)
{
foreach (var aux in AuxiliaryClocksInfo)
{
aux.SetRawDateTimeNow(now);
}
}
// always raise the time changed event since this callback is called
// every 1 second and the clock service has a 1 second 'granularity'
TimeChanged?.Invoke(this, EventArgs.Empty);
// raise the date changed event if the day has changed from the old backup date
if (_oldDate == null || _oldDate.Day != now.Day)
{
DateChanged?.Invoke(this, EventArgs.Empty);
_oldDate = now;
}
}, null);
}
catch
{
// silently ignore expections occuring in the event handlers.
}
}
private void DispatcherTimerOnTick(
object sender, System.EventArgs eventArgs)
{
Increment(timerStep);
TimeChanged?.Invoke(this, System.EventArgs.Empty);
}
private void OnTimeChanged()
{
TimeChangedEventArgs eventArgs = new TimeChangedEventArgs(currentTime);
TimeChanged?.Invoke(this, eventArgs);
}
public void Navigate(double time)
{
Time = DateTime.UtcNow;
MIDITime = time;
TimeChanged?.Invoke();
}
private void TimerOnElapsed(object sender, ElapsedEventArgs e) => TimeChanged?.Invoke(e.SignalTime);
private void OnTimeChanged()
{
TimeChanged?.Invoke(this, timed);
}
void dispatchTimer_Tick(object sender, object e)
{
TimeChanged?.Invoke(GetTime());
}
private void TbSeasons_Unchecked(object sender, RoutedEventArgs e)
{
TimeChanged?.Invoke(this, e);
}
protected virtual void OnTxtTimeChanged(object sender, EventArgs e)
{
_comboBox.Entry.ModifyText(Gtk.StateType.Normal, TextColor);
TimeChanged?.Invoke(this, e);
}
protected virtual void OnTimeChanged(EventArgs e) => TimeChanged?.Invoke(this, e);