コード例 #1
0
ファイル: TextHandDisp.cs プロジェクト: sowrd299/DreamRabbit
    public override void Disp(Card[] hand, CanPlay canPlay)
    {
        string s = "";

        for (int i = 0; i < hand.Length; ++i)
        {
            s += "\n" + (canPlay(hand[i])? i.ToString() + ":" : "") + hand[i].Name;
        }
        t.text = s;
    }
コード例 #2
0
ファイル: SpotifyClient.cs プロジェクト: jmrein/Blotify
 /// <summary>
 /// Right after Spotify has launched, properties like CanPlay will be disabled.
 /// Give it a few tries to sort itself out.
 /// It may also be disabled for reasons, in which case, give up after a bit.
 /// </summary>
 private void WaitForPlay()
 {
     waitForPlayableDisposable.Add(CanPlay.Where(canPlay => canPlay).Subscribe(canPlay =>
     {
         waitForPlayableDisposable.Dispose();
     }));
     waitForPlayableDisposable.Add(Observable.Timer(TimeSpan.Zero, TimeSpan.FromMilliseconds(500)).Subscribe(i =>
     {
         updateRequested.OnNext(Unit.Default);
         if (i > 3)
         {
             waitForPlayableDisposable.Dispose();
         }
     }));
 }
コード例 #3
0
 public abstract void Disp(Card[] hand, CanPlay p);
コード例 #4
0
        /// <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);
        }