private void PopEntry()
{
if (curIndex == -1)
{
return;
}
ProgramID id = mEventList.ElementAt(curIndex);
mEventList.RemoveAt(curIndex);
mEvents.Remove(id);
if (curIndex >= mEventList.Count)
{
curIndex = mEventList.Count - 1;
}
if (curIndex < 0)
{
//btnIgnore.IsEnabled = false;
IgnoreSB.IsEnabled = false;
consGrid.Items.Clear();
curIndex = -1;
Emptied?.Invoke(this, new EventArgs());
return;
}
UpdateIndex();
LoadCurrent();
}
private void BtnIgnoreAll_Click(object sender, RoutedEventArgs e)
{
mEventList.Clear();
mEvents.Clear();
IgnoreSB.IsEnabled = false;
consGrid.Items.Clear();
curIndex = -1;
Emptied?.Invoke(this, new EventArgs());
}
public void UpdateState()
{
this.IgnoreSB.IsEnabled = tweaksGrid.Items.IsEmpty ? false : true;
this.RestoreSB.IsEnabled = tweaksGrid.Items.IsEmpty ? false : true;
if (tweaksGrid.Items.IsEmpty)
{
Emptied?.Invoke(this, new EventArgs());
}
else if (tweaksGrid.SelectedItem == null)
{
tweaksGrid.SelectedItem = tweaksGrid.Items[0];
}
}
public void UpdateState()
{
this.IgnoreSB.IsEnabled = rulesGrid.Items.IsEmpty ? false : true;
this.ApproveSB.IsEnabled = rulesGrid.Items.IsEmpty ? false : true;
this.RejectSB.IsEnabled = rulesGrid.Items.IsEmpty ? false : true;
if (rulesGrid.Items.IsEmpty)
{
Emptied?.Invoke(this, new EventArgs());
}
else if (rulesGrid.SelectedItem == null)
{
rulesGrid.SelectedItem = rulesGrid.Items[0];
}
}
public void Execute(ExecutionType executionType)
{
var next = Dequeue(executionType);
if (next != null)
{
next.Completed += OnActionExecutionComplete;
next.Execute(_battleSystem);
}
else
{
LogEx.Log <BattleSystem>("No more battle actions left to execute.");
// TODO: Move Turn Count somewhere else.
//TurnCount++;
Reset();
Emptied.InvokeSafe(this);
}
}
public void Remove(int index)
{
if (IsEmpty)
{
Debug.LogWarning("Deck: Nothing to remove - deck is empty!");
return;
}
else if (!IndexIsWithinRange(index))
{
Debug.LogWarning("Deck: Nothing to remove - index out of range");
return;
}
T removedItem = _cards[index];
_cards.RemoveAt(index);
CardRemoved?.Invoke(removedItem);
if (_cards.Count == 0)
{
Emptied?.Invoke();
}
}
/// <summary>
/// This is called in Update when Options.Count == 0.
/// </summary>
public virtual void OnEmpty()
{
Emptied?.Invoke(this, EventArgs.Empty);
}
/// <summary>
/// Normally a <pre>video</pre> element doesn't have a <pre>change</pre> event.
/// We force one and a use it as a proxy for all the Media Events.
/// </summary>
/// <param name="args">The event args - Value contains our JSON</param>
protected virtual void OnChange(ChangeEventArgs args)
{
var ThisEvent = args?.Value?.ToString();
VideoEventData videoData = new VideoEventData();
try
{
videoData = JsonSerializer.Deserialize <VideoEventData>(ThisEvent, serializationOptions);
}
catch (Exception ex)
{
LoggerFactory
.CreateLogger(nameof(VideoExComponentBase))
.LogError(ex, "Failed to convert the JSON: {0}", ThisEvent);
}
switch (videoData.EventName)
{
case VideoEvents.Abort:
Abort?.Invoke(videoData.State);
AbortEvent.InvokeAsync(videoData.State);
break;
case VideoEvents.CanPlay:
CanPlay?.Invoke(videoData.State);
CanPlayEvent.InvokeAsync(videoData.State);
break;
case VideoEvents.CanPlayThrough:
CanPlayThrough?.Invoke(videoData.State);
CanPlayThroughEvent.InvokeAsync(videoData.State);
break;
case VideoEvents.DurationChange:
DurationChange?.Invoke(videoData.State);
DurationChangeEvent.InvokeAsync(videoData.State);
break;
case VideoEvents.Emptied:
Emptied?.Invoke(videoData.State);
EmptiedEvent.InvokeAsync(videoData.State);
break;
case VideoEvents.Ended:
Ended?.Invoke(videoData.State);
EndedEvent.InvokeAsync(videoData.State);
break;
case VideoEvents.Error:
Error?.Invoke(videoData.State);
ErrorEvent.InvokeAsync(videoData.State);
break;
case VideoEvents.LoadedData:
LoadedData?.Invoke(videoData.State);
LoadedDataEvent.InvokeAsync(videoData.State);
break;
case VideoEvents.LoadedMetadata:
LoadedMetadata?.Invoke(videoData.State);
LoadedMetadataEvent.InvokeAsync(videoData.State);
break;
case VideoEvents.LoadStart:
LoadStart?.Invoke(videoData.State);
LoadStartEvent.InvokeAsync(videoData.State);
break;
case VideoEvents.Pause:
Pause?.Invoke(videoData.State);
PauseEvent.InvokeAsync(videoData.State);
break;
case VideoEvents.Play:
Play?.Invoke(videoData.State);
PlayEvent.InvokeAsync(videoData.State);
break;
case VideoEvents.Playing:
Playing?.Invoke(videoData.State);
PlayingEvent.InvokeAsync(videoData.State);
break;
case VideoEvents.Progress:
Progress?.Invoke(videoData.State);
ProgressEvent.InvokeAsync(videoData.State);
break;
case VideoEvents.RateChange:
RateChange?.Invoke(videoData.State);
RateChangeEvent.InvokeAsync(videoData.State);
break;
case VideoEvents.Seeked:
Seeking?.Invoke(videoData.State);
SeekingEvent.InvokeAsync(videoData.State);
break;
case VideoEvents.Seeking:
Seeking?.Invoke(videoData.State);
SeekingEvent.InvokeAsync(videoData.State);
break;
case VideoEvents.Stalled:
Stalled?.Invoke(videoData.State);
StalledEvent.InvokeAsync(videoData.State);
break;
case VideoEvents.Suspend:
Suspend?.Invoke(videoData.State);
SuspendEvent.InvokeAsync(videoData.State);
break;
case VideoEvents.TimeUpdate:
TimeUpdate?.Invoke(videoData.State);
TimeUpdateEvent.InvokeAsync(videoData.State);
break;
case VideoEvents.VolumeChange:
VolumeChange?.Invoke(videoData.State);
VolumeChangeEvent.InvokeAsync(videoData.State);
break;
case VideoEvents.Waiting:
Waiting?.Invoke(videoData.State);
WaitingEvent.InvokeAsync(videoData.State);
break;
default:
break;
}
// Here is our catch-all event handler call!
EventFired?.Invoke(videoData);
}
