private void tick(object sender, EventArgs e)
{
if (frames == null || frames.Length <= 0)
{
return;
}
if (animation == null)
{
return;
}
timer--;
if (timer <= 0)
{
index++;
if (index >= animation.Length)
{
index = 0;
if (animation.PlayType == PlayType.OnlyOnce)
{
index = animation.Length - 1;
}
}
timer = frames[index].Time;
player.Size = new Size(framesBitmaps[index].Width + 4, framesBitmaps[index].Height + 4);
player.Image = framesBitmaps[index];
}
TimeChanged?.Invoke(index, timer);
}
private static void NtpUpdateTimer_Tick()
{
while (Thread.CurrentThread.IsAlive)
{
int trackedErrors = 0;
foreach (string server in NtpServersList)
{
try
{
CurrentNtpTime = GetNetworkTime(server);
TimeChanged?.Invoke();
break;
}
catch (Exception)
{
trackedErrors++;
}
}
NtpTimeFetchError = NtpServersList.Count == trackedErrors;
Thread.Sleep(100);
}
}
private void OnTimeChanged()
{
if (TimeChanged != null)
{
TimeChanged.Invoke(this, new EventArgs());
}
}
public AnimatableTimer()
{
TimeDescriptor.AddValueChanged(this, (sender, r) =>
{
TimeChanged?.Invoke(this);
});
}
private void timeEntryControl_TimeChanged(object sender, EventArgs e)
{
if (TimeChanged != null)
{
TimeChanged.Invoke(this, e);
}
}
private void InvokeTimeChanged()
{
if ((!haltEvents) && (TimeChanged != null))
{
TimeChanged.Invoke(this, new EventArgs());
}
}
private IEnumerator TimerCoroutine()
{
while (seconds > 0)
{
yield return(new WaitForSeconds(1));
seconds--;
TimeChanged?.Invoke(seconds);
}
int index = 0;
int maxScore = 0;
for (int i = 0; i < scores.Count; i++)
{
if (scores[i] > maxScore)
{
maxScore = scores[i];
index = i;
}
}
GameEnded?.Invoke(index);
}
public override void OnStartServer()
{
NetworkManagerMageBall networkManager = (NetworkManagerMageBall)NetworkManager.singleton;
minutes = networkManager.MatchLength;
TimeChanged?.Invoke(minutes, seconds);
timerRoutine = StartCoroutine(Timer(networkManager));
}
/* ----------------------------------------------------------------- */
///
/// OnTimeChanged
///
/// <summary>
/// システムの時刻が変更された時に発生するイベントです。
/// </summary>
///
/* ----------------------------------------------------------------- */
protected virtual void OnTimeChanged(EventArgs e)
{
if (Power.Mode == PowerModes.Suspend)
{
return;
}
Reset();
TimeChanged?.Invoke(this, e);
}
private void Add1Button_Click(object sender, EventArgs e)
{
TimeUnit buttonUnit = _addButtonUnits[(Button)sender];
TimeChanged?.Invoke(this, new TimeEventArgs(new Dictionary <TimeUnit, int>()
{
{ buttonUnit, 1 }
}));
}
/// <summary>
/// Handles timer "Elapsed" event.
/// Invokes TimeChanged if values of minutes have changed since last tick.
/// </summary>
/// <param name="sender">The object that raised the event.</param>
/// <param name="args">Event arguments. Not used.</param>
private static void OnTimerElapsed(object sender, EventArgs args)
{
DateTime _now = DateTime.Now;
if (_previousDateTime.Minute != _now.Minute)
{
TimeChanged?.Invoke(null, _now);
_previousDateTime = _now;
}
}
public virtual int _GetUniqueIdentifier()
{
var hashCode = 399326290;
hashCode = hashCode * -1521134295 + (Id?.GetHashCode() ?? 0);
hashCode = hashCode * -1521134295 + (TimeChanged?.GetHashCode() ?? 0);
hashCode = hashCode * -1521134295 + (Description?.GetHashCode() ?? 0);
hashCode = hashCode * -1521134295 + (User?.GetHashCode() ?? 0);
return(hashCode);
}
protected override void UpdateValuesFromModalController()
{
var newTime = BareUIHelper.NSDateToDateTime(ModalController.DatePicker.Date).TimeOfDay;
if (newTime != Time)
{
Time = newTime;
TimeChanged?.Invoke(this, Time);
}
}
private void ResetTimeLeft()
{
TimeSpan t = TimeSpan.FromMilliseconds(_millisecondsLeft);
TimeLeft = string.Empty;
TimeLeft = t.Hours > 0 || t.Minutes > 0 ?
string.Format("{0:D2}:{1:D2}:{2:D2}", t.Hours, t.Minutes, t.Seconds) :
string.Format("{0:D2}:{1:D2}:{2:D2}:{3:D1}", t.Hours, t.Minutes, t.Seconds, t.Milliseconds);
TimeChanged?.Invoke(this, new EventArgs());
}
private void ChangeElapsedTime(object state)
{
if (_isTimerMode)
{
RunTimer();
}
else
{
RunStopwatch();
}
TimeChanged?.Invoke(this, EventArgs.Empty);
}
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 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);
}
}
public void Reset()
{
MIDITime = 0;
var pause = Paused;
Paused = true;
TimeChanged?.Invoke();
if (!pause)
{
PauseChanged?.Invoke();
}
}
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));
}
}
}
void OnFrameChanged(ChangeEvent <int> evt)
{
if (m_Clip == null)
{
return;
}
float secondsValue = evt.newValue / m_Clip.SampleRate;
{
m_SecondsField.SetValueWithoutNotify(secondsValue);
TimeChanged?.Invoke(secondsValue);
}
}
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);
}
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();
}
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);
}
/// <summary>Initializes the TimeService and waits for a valid time from the server</summary>
/// <param name="timeServiceName">Host name of the time service server to use</param>
/// <param name="timeZoneOffset">Timezone offset (in minutes) to use for the service</param>
public static void InitTimeService(string timeServiceName, int timeZoneOffset)
{
// Get the address for the time service.
// It is considered bad practice to hard code the address
// as the service will likely load balance to a variety
// of physical IP addresses.
IPHostEntry entry = Dns.GetHostEntry(timeServiceName);
if (entry == null || entry.AddressList == null)
{
throw new ApplicationException("DNS failure");
}
// It is possible (at least on the emulator) that
// an address in the list may be null, so loop
// over them until a valid one is found.
IPAddress timeServiceAddress = null;
for (int i = 0; i < entry.AddressList.Length; ++i)
{
timeServiceAddress = entry.AddressList[i];
if (timeServiceAddress != null)
{
break;
}
}
// need to have a valid one to continue
if (timeServiceAddress == null)
{
throw new ApplicationException("DNS failure");
}
TimeService.Settings = new TimeServiceSettings
{
PrimaryServer = timeServiceAddress.GetAddressBytes( )
, RefreshTime = 10
, AutoDayLightSavings = true
};
TimeService.SetTimeZoneOffset(timeZoneOffset);
// Start the service and wait for initial time update/sync from server
TimeService.SystemTimeChanged += TimeService_SystemTimeChanged;
TimeService.Start( );
TimeChanged.WaitOne( );
TimeService.SystemTimeChanged -= TimeService_SystemTimeChanged;
}
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());
}
