public static bool Matches(ScheduledItem item, ActionType updateEvent)
{
VisualElementScheduledItem <ActionType> vItem = item as VisualElementScheduledItem <ActionType>;
if (vItem != null)
{
return(EqualityComparer <ActionType> .Default.Equals(vItem.updateEvent, updateEvent));
}
return(false);
}
public void Schedule(ScheduledItem item)
{
if (item == null)
{
return;
}
ScheduledItem scheduledItem = item as ScheduledItem;
if (scheduledItem == null)
{
throw new NotSupportedException("Scheduled Item type is not supported by this scheduler");
}
if (m_TransactionMode)
{
if (m_UnscheduleTransactions.Remove(scheduledItem))
{
// The item was unscheduled then rescheduled in the same transaction.
}
else if (m_ScheduledItems.Contains(scheduledItem) || m_ScheduleTransactions.Contains(scheduledItem))
{
throw new ArgumentException(string.Concat("Cannot schedule function ", scheduledItem, " more than once"));
}
else
{
m_ScheduleTransactions.Add(scheduledItem);
}
}
else
{
if (m_ScheduledItems.Contains(scheduledItem))
{
throw new ArgumentException(string.Concat("Cannot schedule function ", scheduledItem, " more than once"));
}
else
{
m_ScheduledItems.Add(scheduledItem);
}
}
}
public void Unschedule(ScheduledItem item)
{
ScheduledItem sItem = item as ScheduledItem;
if (sItem != null)
{
if (m_TransactionMode)
{
if (m_UnscheduleTransactions.Contains(sItem))
{
throw new ArgumentException("Cannot unschedule scheduled function twice" + sItem);
}
else if (m_ScheduleTransactions.Remove(sItem))
{
// A item has been scheduled then unscheduled in the same transaction. which is valid.
}
else if (m_ScheduledItems.Contains(sItem))
{
// Only add it to m_UnscheduleTransactions if it is in m_ScheduledItems.
// if it was successfully removed from m_ScheduleTransaction we are fine.
m_UnscheduleTransactions.Add(sItem);
}
else
{
throw new ArgumentException("Cannot unschedule unknown scheduled function " + sItem);
}
}
else
{
if (!PrivateUnSchedule(sItem))
{
throw new ArgumentException("Cannot unschedule unknown scheduled function " + sItem);
}
}
sItem.OnItemUnscheduled(); // Call OnItemUnscheduled immediately after successful removal even if we are in transaction mode
}
}
public void Schedule(ScheduledItem item)
{
bool flag = item == null;
if (!flag)
{
bool flag2 = item == null;
if (flag2)
{
throw new NotSupportedException("Scheduled Item type is not supported by this scheduler");
}
bool transactionMode = this.m_TransactionMode;
if (transactionMode)
{
bool flag3 = this.m_UnscheduleTransactions.Remove(item);
if (!flag3)
{
bool flag4 = this.m_ScheduledItems.Contains(item) || this.m_ScheduleTransactions.Contains(item);
if (flag4)
{
throw new ArgumentException("Cannot schedule function " + item + " more than once");
}
this.m_ScheduleTransactions.Add(item);
}
}
else
{
bool flag5 = this.m_ScheduledItems.Contains(item);
if (flag5)
{
throw new ArgumentException("Cannot schedule function " + item + " more than once");
}
this.m_ScheduledItems.Add(item);
}
}
}
public void Unschedule(ScheduledItem item)
{
bool flag = item != null;
if (flag)
{
bool transactionMode = this.m_TransactionMode;
if (transactionMode)
{
bool flag2 = this.m_UnscheduleTransactions.Contains(item);
if (flag2)
{
throw new ArgumentException("Cannot unschedule scheduled function twice" + ((item != null) ? item.ToString() : null));
}
bool flag3 = this.m_ScheduleTransactions.Remove(item);
if (!flag3)
{
bool flag4 = this.m_ScheduledItems.Contains(item);
if (!flag4)
{
throw new ArgumentException("Cannot unschedule unknown scheduled function " + ((item != null) ? item.ToString() : null));
}
this.m_UnscheduleTransactions.Add(item);
}
}
else
{
bool flag5 = !this.PrivateUnSchedule(item);
if (flag5)
{
throw new ArgumentException("Cannot unschedule unknown scheduled function " + ((item != null) ? item.ToString() : null));
}
}
item.OnItemUnscheduled();
}
}
public void UpdateScheduledEvents()
{
try
{
m_TransactionMode = true;
// TODO: On a GAME Panel game time should be per frame and not change during a frame.
// TODO: On an Editor Panel time should be real time
long currentTime = Panel.TimeSinceStartupMs();
int itemsCount = m_ScheduledItems.Count;
const long maxMsPerUpdate = 20;
long maxTime = currentTime + maxMsPerUpdate;
int startIndex = m_LastUpdatedIndex + 1;
if (startIndex >= itemsCount)
{
startIndex = 0;
}
for (int i = 0; i < itemsCount; i++)
{
currentTime = Panel.TimeSinceStartupMs();
if (!disableThrottling && currentTime >= maxTime)
{
//We spent too much time on this frame updating items, we break for now, we'll resume next frame
break;
}
int index = startIndex + i;
if (index >= itemsCount)
{
index -= itemsCount;
}
ScheduledItem scheduledItem = m_ScheduledItems[index];
bool unscheduleItem = false;
if (currentTime - scheduledItem.delayMs >= scheduledItem.startMs)
{
TimerState timerState = new TimerState {
start = scheduledItem.startMs, now = currentTime
};
if (!m_UnscheduleTransactions.Contains(scheduledItem)) // Don't execute items that have been marked for future removal
{
scheduledItem.PerformTimerUpdate(timerState);
}
scheduledItem.startMs = currentTime;
scheduledItem.delayMs = scheduledItem.intervalMs;
if (scheduledItem.ShouldUnschedule())
{
unscheduleItem = true;
}
}
if (unscheduleItem || (scheduledItem.endTimeMs > 0 && currentTime > scheduledItem.endTimeMs))
{
// if the scheduledItem has been unscheduled explicitly in PerformTimerUpdate then
// it will be in m_UnscheduleTransactions and we shouldn't unschedule it again
if (!m_UnscheduleTransactions.Contains(scheduledItem))
{
Unschedule(scheduledItem);
}
}
m_LastUpdatedIndex = index;
}
}
finally
{
m_TransactionMode = false;
// Rule: remove unscheduled transactions first
foreach (var item in m_UnscheduleTransactions)
{
PrivateUnSchedule(item);
}
m_UnscheduleTransactions.Clear();
// Then add scheduled transactions
foreach (var item in m_ScheduleTransactions)
{
Schedule(item);
}
m_ScheduleTransactions.Clear();
}
}
bool PrivateUnSchedule(ScheduledItem sItem)
{
return(m_ScheduleTransactions.Remove(sItem) || RemovedScheduledItemAt(m_ScheduledItems.IndexOf(sItem)));
}
public void UpdateScheduledEvents()
{
try
{
this.m_TransactionMode = true;
long num = Panel.TimeSinceStartupMs();
int count = this.m_ScheduledItems.Count;
long num2 = num + 20L;
int num3 = this.m_LastUpdatedIndex + 1;
bool flag = num3 >= count;
if (flag)
{
num3 = 0;
}
for (int i = 0; i < count; i++)
{
num = Panel.TimeSinceStartupMs();
bool flag2 = !this.disableThrottling && num >= num2;
if (flag2)
{
break;
}
int num4 = num3 + i;
bool flag3 = num4 >= count;
if (flag3)
{
num4 -= count;
}
ScheduledItem scheduledItem = this.m_ScheduledItems[num4];
bool flag4 = false;
bool flag5 = num - scheduledItem.delayMs >= scheduledItem.startMs;
if (flag5)
{
TimerState state = new TimerState
{
start = scheduledItem.startMs,
now = num
};
bool flag6 = !this.m_UnscheduleTransactions.Contains(scheduledItem);
if (flag6)
{
scheduledItem.PerformTimerUpdate(state);
}
scheduledItem.startMs = num;
scheduledItem.delayMs = scheduledItem.intervalMs;
bool flag7 = scheduledItem.ShouldUnschedule();
if (flag7)
{
flag4 = true;
}
}
bool flag8 = flag4 || (scheduledItem.endTimeMs > 0L && num > scheduledItem.endTimeMs);
if (flag8)
{
bool flag9 = !this.m_UnscheduleTransactions.Contains(scheduledItem);
if (flag9)
{
this.Unschedule(scheduledItem);
}
}
this.m_LastUpdatedIndex = num4;
}
}
finally
{
this.m_TransactionMode = false;
foreach (ScheduledItem current in this.m_UnscheduleTransactions)
{
this.PrivateUnSchedule(current);
}
this.m_UnscheduleTransactions.Clear();
foreach (ScheduledItem current2 in this.m_ScheduleTransactions)
{
this.Schedule(current2);
}
this.m_ScheduleTransactions.Clear();
}
}
