public static void AddTimedEvents(this EventsCollection eventsCollection, IEnumerable <TimedEvent> events)
        {
            ThrowIfArgument.IsNull(nameof(eventsCollection), eventsCollection);
            ThrowIfArgument.IsNull(nameof(events), events);

            using (var timedEventsManager = eventsCollection.ManageTimedEvents())
            {
                timedEventsManager.Events.Add(events.Where(e => e.Event is ChannelEvent || e.Event is MetaEvent || e.Event is SysExEvent));
            }
        }
        /// <summary>
        /// Adds collection of chords to the specified <see cref="EventsCollection"/>.
        /// </summary>
        /// <param name="eventsCollection"><see cref="EventsCollection"/> to add chords to.</param>
        /// <param name="chords">Chords to add to the <paramref name="eventsCollection"/>.</param>
        /// <exception cref="ArgumentNullException">
        /// <para>One of the following errors occured:</para>
        /// <list type="bullet">
        /// <item>
        /// <description><paramref name="eventsCollection"/> is <c>null</c>.</description>
        /// </item>
        /// <item>
        /// <description><paramref name="chords"/> is <c>null</c>.</description>
        /// </item>
        /// </list>
        /// </exception>
        public static void AddChords(this EventsCollection eventsCollection, IEnumerable <Chord> chords)
        {
            ThrowIfArgument.IsNull(nameof(eventsCollection), eventsCollection);
            ThrowIfArgument.IsNull(nameof(chords), chords);

            using (var chordsManager = eventsCollection.ManageChords())
            {
                chordsManager.Chords.Add(chords);
            }
        }
        /// <summary>
        /// Removes all the <see cref="Chord"/> that match the conditions defined by the specified predicate.
        /// </summary>
        /// <param name="eventsCollection"><see cref="EventsCollection"/> to search for chords to remove.</param>
        /// <param name="match">The predicate that defines the conditions of the <see cref="Chord"/> to remove.</param>
        /// <param name="notesTolerance">Notes tolerance that defines maximum distance of notes from the
        /// start of the first note of a chord. Notes within this tolerance will be considered as a chord.</param>
        /// <exception cref="ArgumentNullException"><paramref name="eventsCollection"/> is <c>null</c>.</exception>
        /// <exception cref="ArgumentOutOfRangeException"><paramref name="notesTolerance"/> is negative.</exception>
        public static void RemoveChords(this EventsCollection eventsCollection, Predicate <Chord> match = null, long notesTolerance = 0)
        {
            ThrowIfArgument.IsNull(nameof(eventsCollection), eventsCollection);
            ThrowIfNotesTolerance.IsNegative(nameof(notesTolerance), notesTolerance);

            using (var chordsManager = eventsCollection.ManageChords(notesTolerance))
            {
                chordsManager.Chords.RemoveAll(match ?? (c => true));
            }
        }
예제 #4
0
        /// <summary>
        /// Adds collection of notes to the specified <see cref="EventsCollection"/>.
        /// </summary>
        /// <param name="eventsCollection"><see cref="EventsCollection"/> to add notes to.</param>
        /// <param name="notes">Notes to add to the <paramref name="eventsCollection"/>.</param>
        /// <exception cref="ArgumentNullException">
        /// <para>One of the following errors occured:</para>
        /// <list type="bullet">
        /// <item>
        /// <description><paramref name="eventsCollection"/> is <c>null</c>.</description>
        /// </item>
        /// <item>
        /// <description><paramref name="notes"/> is <c>null</c>.</description>
        /// </item>
        /// </list>
        /// </exception>
        public static void AddNotes(this EventsCollection eventsCollection, IEnumerable <Note> notes)
        {
            ThrowIfArgument.IsNull(nameof(eventsCollection), eventsCollection);
            ThrowIfArgument.IsNull(nameof(notes), notes);

            using (var notesManager = eventsCollection.ManageNotes())
            {
                notesManager.Notes.Add(notes);
            }
        }
        /// <summary>
        /// Adds collection of timed events to the specified <see cref="EventsCollection"/>.
        /// </summary>
        /// <param name="eventsCollection"><see cref="EventsCollection"/> to add timed events to.</param>
        /// <param name="events">Timed events to add to the <paramref name="eventsCollection"/>.</param>
        /// <exception cref="ArgumentNullException">
        /// <para>One of the following errors occured:</para>
        /// <list type="bullet">
        /// <item>
        /// <description><paramref name="eventsCollection"/> is <c>null</c>.</description>
        /// </item>
        /// <item>
        /// <description><paramref name="events"/> is <c>null</c>.</description>
        /// </item>
        /// </list>
        /// </exception>
        public static void AddTimedEvents(this EventsCollection eventsCollection, IEnumerable <TimedEvent> events)
        {
            ThrowIfArgument.IsNull(nameof(eventsCollection), eventsCollection);
            ThrowIfArgument.IsNull(nameof(events), events);

            using (var timedEventsManager = eventsCollection.ManageTimedEvents())
            {
                timedEventsManager.Events.Add(events);
            }
        }
예제 #6
0
 public GroupsViewModel(string key, ulong parameter)
     : base(key, parameter)
 {
     _groups             = new GroupsCollection(parameter);
     _events             = new EventsCollection(parameter);
     _manage             = new GroupsManageCollection(parameter);
     Refresh             = new RelayCommand(() => Groups.Refresh());
     RefreshEvents       = new RelayCommand(() => Events.Refresh());
     RefreshGroupsManage = new RelayCommand(() => GroupsManage.Refresh());
 }
예제 #7
0
        /// <summary>
        /// Gets notes contained in the specified collection of <see cref="MidiEvent"/>.
        /// </summary>
        /// <param name="events">Collection of<see cref="MidiFile"/> to search for notes.</param>
        /// <returns>Collection of notes contained in <paramref name="events"/> ordered by time.</returns>
        /// <exception cref="ArgumentNullException"><paramref name="events"/> is <c>null</c>.</exception>
        public static IEnumerable <Note> GetNotes(this IEnumerable <MidiEvent> events)
        {
            ThrowIfArgument.IsNull(nameof(events), events);

            var eventsCollection = new EventsCollection();

            eventsCollection.AddRange(events);

            return(eventsCollection.ManageNotes().Notes.ToList());
        }
예제 #8
0
        /// <summary>
        /// Initializes a new instance of the <see cref="ChordsManager"/> with the specified events
        /// collection, notes tolerance and comparison delegate for events that have same time.
        /// </summary>
        /// <param name="eventsCollection"><see cref="EventsCollection"/> that holds chord events to manage.</param>
        /// <param name="notesTolerance">Notes tolerance that defines maximum distance of notes from the
        /// start of the first note of a chord. Notes within this tolerance will be considered as a chord.</param>
        /// <param name="sameTimeEventsComparison">Delegate to compare events with the same absolute time.</param>
        /// <exception cref="ArgumentNullException"><paramref name="eventsCollection"/> is <c>null</c>.</exception>
        /// <exception cref="ArgumentOutOfRangeException"><paramref name="notesTolerance"/> is negative.</exception>
        public ChordsManager(EventsCollection eventsCollection, long notesTolerance = 0, Comparison <MidiEvent> sameTimeEventsComparison = null)
        {
            ThrowIfArgument.IsNull(nameof(eventsCollection), eventsCollection);
            ThrowIfNotesTolerance.IsNegative(nameof(notesTolerance), notesTolerance);

            _notesManager = eventsCollection.ManageNotes(sameTimeEventsComparison);

            Chords = new ChordsCollection(CreateChords(_notesManager.Notes, notesTolerance));
            Chords.CollectionChanged += OnChordsCollectionChanged;
        }
예제 #9
0
 private void Details(object sender, ItemClickEventArgs e)
 {
     if (!(EventsCollection.ContainerFromItem(e.ClickedItem) is ListViewItem container))
     {
         return;
     }
     if (container.Content is Event selectedEvent)
     {
         Frame.Navigate(typeof(EventDetails), selectedEvent);
     }
 }
예제 #10
0
        /// <summary>
        /// Extracts objects of the specified types from a <see cref="EventsCollection"/>.
        /// </summary>
        /// <param name="eventsCollection"><see cref="EventsCollection"/> to extract objects from.</param>
        /// <param name="objectType">Combination of desired objects types.</param>
        /// <param name="settings">Settings according to which objects should be detected and built.</param>
        /// <returns>Collection of objects of the specified types extracted from <paramref name="eventsCollection"/>.
        /// Objects are ordered by time.</returns>
        /// <exception cref="ArgumentNullException"><paramref name="eventsCollection"/> is <c>null</c>.</exception>
        public static ICollection <ITimedObject> GetObjects(
            this EventsCollection eventsCollection,
            ObjectType objectType,
            ObjectDetectionSettings settings = null)
        {
            ThrowIfArgument.IsNull(nameof(eventsCollection), eventsCollection);

            return(eventsCollection
                   .GetTimedEventsLazy()
                   .GetObjectsFromSortedTimedObjects(eventsCollection.Count / 2, objectType, settings));
        }
        /// <summary>
        /// Gets chords contained in the specified collection of <see cref="MidiEvent"/>.
        /// </summary>
        /// <param name="events">Collection of<see cref="MidiFile"/> to search for chords.</param>
        /// <param name="notesTolerance">Notes tolerance that defines maximum distance of notes from the
        /// start of the first note of a chord. Notes within this tolerance will be considered as a chord.</param>
        /// <returns>Collection of chords contained in <paramref name="events"/> ordered by time.</returns>
        /// <exception cref="ArgumentNullException"><paramref name="events"/> is <c>null</c>.</exception>
        public static IEnumerable <Chord> GetChords(this IEnumerable <MidiEvent> events, long notesTolerance = 0)
        {
            ThrowIfArgument.IsNull(nameof(events), events);
            ThrowIfNotesTolerance.IsNegative(nameof(notesTolerance), notesTolerance);

            var eventsCollection = new EventsCollection();

            eventsCollection.AddRange(events);

            return(eventsCollection.ManageChords(notesTolerance).Chords.ToList());
        }
예제 #12
0
        private static IEnumerable <TimedEvent> CreateTimedEvents(EventsCollection events)
        {
            ThrowIfArgument.IsNull(nameof(events), events);

            var time = 0L;

            foreach (var midiEvent in events)
            {
                time += midiEvent.DeltaTime;
                yield return(new TimedEvent(midiEvent.Clone(), time));
            }
        }
예제 #13
0
        public static void AreEqual(EventsCollection eventsCollection1, EventsCollection eventsCollection2, bool compareDeltaTimes, string message = null)
        {
            var areEqual = EventsCollectionEquality.Equals(
                eventsCollection1,
                eventsCollection2,
                new MidiEventEqualityCheckSettings {
                CompareDeltaTimes = compareDeltaTimes
            },
                out var eventsComparingMessage);

            Assert.IsTrue(areEqual, $"{message} {eventsComparingMessage}");
        }
예제 #14
0
        private void RemoveTimedEvents_EventsCollection_WithoutPredicate(
            ContainerType containerType,
            ICollection <MidiEvent> midiEvents)
        {
            var eventsCollection = new EventsCollection();

            eventsCollection.AddRange(midiEvents);

            switch (containerType)
            {
            case ContainerType.EventsCollection:
            {
                Assert.AreEqual(
                    midiEvents.Count,
                    eventsCollection.RemoveTimedEvents(),
                    "Invalid count of removed timed events.");

                var expectedEventsCollection = new EventsCollection();
                MidiAsserts.AreEqual(expectedEventsCollection, eventsCollection, true, "Events are invalid.");
                Assert.IsTrue(
                    eventsCollection.All(e => midiEvents.Any(ee => object.ReferenceEquals(e, ee))),
                    "There are new events references.");
            }
            break;

            case ContainerType.TrackChunk:
            {
                var trackChunk = new TrackChunk(eventsCollection);

                Assert.AreEqual(
                    midiEvents.Count,
                    trackChunk.RemoveTimedEvents(),
                    "Invalid count of removed timed events.");

                var expectedTrackChunk = new TrackChunk();
                MidiAsserts.AreEqual(expectedTrackChunk, trackChunk, true, "Events are invalid.");
                Assert.IsTrue(
                    trackChunk.Events.All(e => midiEvents.Any(ee => object.ReferenceEquals(e, ee))),
                    "There are new events references.");
            }
            break;

            case ContainerType.TrackChunks:
            case ContainerType.File:
            {
                RemoveTimedEvents_TrackChunks_WithoutPredicate(
                    containerType == ContainerType.File,
                    new[] { midiEvents });
            }
            break;
            }
        }
예제 #15
0
        /// <summary>
        /// Performs the specified action on each <see cref="Note"/> contained in the <see cref="EventsCollection"/>.
        /// </summary>
        /// <param name="eventsCollection"><see cref="EventsCollection"/> to search for notes to process.</param>
        /// <param name="action">The action to perform on each <see cref="Note"/> contained in the
        /// <paramref name="eventsCollection"/>.</param>
        /// <param name="match">The predicate that defines the conditions of the <see cref="Note"/> to process.</param>
        /// <exception cref="ArgumentNullException">
        /// <para>One of the following errors occured:</para>
        /// <list type="bullet">
        /// <item>
        /// <description><paramref name="eventsCollection"/> is <c>null</c>.</description>
        /// </item>
        /// <item>
        /// <description><paramref name="action"/> is <c>null</c>.</description>
        /// </item>
        /// </list>
        /// </exception>
        public static void ProcessNotes(this EventsCollection eventsCollection, Action <Note> action, Predicate <Note> match = null)
        {
            ThrowIfArgument.IsNull(nameof(eventsCollection), eventsCollection);
            ThrowIfArgument.IsNull(nameof(action), action);

            using (var notesManager = eventsCollection.ManageNotes())
            {
                foreach (var note in notesManager.Notes.Where(n => match?.Invoke(n) != false))
                {
                    action(note);
                }
            }
        }
        /// <summary>
        /// Invoked when application execution is being suspended.  Application state is saved
        /// without knowing whether the application will be terminated or resumed with the contents
        /// of memory still intact.
        /// </summary>
        /// <param name="sender">The source of the suspend request.</param>
        /// <param name="e">Details about the suspend request.</param>
        private void OnSuspending(object sender, SuspendingEventArgs e)
        {
            Task.Run(async() =>
            {
                await SensorCollection?.BeginShutdown();
                await EventsCollection?.BeginShutdown();
            }).Wait();

            var deferral = e.SuspendingOperation.GetDeferral();

            //TODO: Save application state and stop any background activity
            deferral.Complete();
        }
        /// <summary>
        /// Gets timed events contained in the specified <see cref="EventsCollection"/>.
        /// </summary>
        /// <param name="eventsCollection"><see cref="EventsCollection"/> to search for events.</param>
        /// <returns>Collection of timed events contained in <paramref name="eventsCollection"/> ordered by time.</returns>
        /// <exception cref="ArgumentNullException"><paramref name="eventsCollection"/> is <c>null</c>.</exception>
        public static ICollection <TimedEvent> GetTimedEvents(this EventsCollection eventsCollection)
        {
            ThrowIfArgument.IsNull(nameof(eventsCollection), eventsCollection);

            var result = new List <TimedEvent>(eventsCollection.Count);

            foreach (var timedEvent in eventsCollection.GetTimedEventsLazy())
            {
                result.Add(timedEvent);
            }

            return(result);
        }
        /// <summary>
        /// Performs the specified action on each <see cref="TimedEvent"/> contained in the <see cref="EventsCollection"/>.
        /// </summary>
        /// <param name="eventsCollection"><see cref="EventsCollection"/> to search for events to process.</param>
        /// <param name="action">The action to perform on each <see cref="TimedEvent"/> contained in the
        /// <paramref name="eventsCollection"/>.</param>
        /// <param name="match">The predicate that defines the conditions of the <see cref="TimedEvent"/> to process.</param>
        /// <exception cref="ArgumentNullException"><paramref name="eventsCollection"/> is null. -or-
        /// <paramref name="action"/> is null.</exception>
        public static void ProcessTimedEvents(this EventsCollection eventsCollection, Action <TimedEvent> action, Predicate <TimedEvent> match = null)
        {
            ThrowIfArgument.IsNull(nameof(eventsCollection), eventsCollection);
            ThrowIfArgument.IsNull(nameof(action), action);

            using (var timedEventsManager = eventsCollection.ManageTimedEvents())
            {
                foreach (var timedEvent in timedEventsManager.Events.Where(e => match?.Invoke(e) != false))
                {
                    action(timedEvent);
                }
            }
        }
        internal static void SortAndUpdateEvents(this EventsCollection eventsCollection, IEnumerable <TimedEvent> timedEvents)
        {
            var time = 0L;
            var i    = 0;

            foreach (var e in timedEvents.OrderBy(e => e.Time))
            {
                var midiEvent = e.Event;
                midiEvent.DeltaTime   = e.Time - time;
                eventsCollection[i++] = midiEvent;

                time = e.Time;
            }
        }
예제 #20
0
        /// <summary>
        /// Performs the specified action on each <see cref="Chord"/> contained in the <see cref="EventsCollection"/>.
        /// </summary>
        /// <param name="eventsCollection"><see cref="EventsCollection"/> to search for chords to process.</param>
        /// <param name="action">The action to perform on each <see cref="Chord"/> contained in the
        /// <paramref name="eventsCollection"/>.</param>
        /// <param name="match">The predicate that defines the conditions of the <see cref="Chord"/> to process.</param>
        /// <param name="notesTolerance">Notes tolerance that defines maximum distance of notes from the
        /// start of the first note of a chord. Notes within this tolerance will be considered as a chord.</param>
        /// <exception cref="ArgumentNullException"><paramref name="eventsCollection"/> is null. -or-
        /// <paramref name="action"/> is null.</exception>
        /// <exception cref="ArgumentOutOfRangeException"><paramref name="notesTolerance"/> is negative.</exception>
        public static void ProcessChords(this EventsCollection eventsCollection, Action <Chord> action, Predicate <Chord> match = null, long notesTolerance = 0)
        {
            ThrowIfArgument.IsNull(nameof(eventsCollection), eventsCollection);
            ThrowIfArgument.IsNull(nameof(action), action);
            ThrowIfNotesTolerance.IsNegative(nameof(notesTolerance), notesTolerance);

            using (var chordsManager = eventsCollection.ManageChords(notesTolerance))
            {
                foreach (var chord in chordsManager.Chords.Where(c => match?.Invoke(c) != false))
                {
                    action(chord);
                }
            }
        }
        private void GetNotes_DetectionSettings_EventsCollection(
            ContainerType containerType,
            NoteDetectionSettings settings,
            ICollection <MidiEvent> midiEvents,
            ICollection <Note> expectedNotes)
        {
            switch (containerType)
            {
            case ContainerType.EventsCollection:
            {
                var eventsCollection = new EventsCollection();
                eventsCollection.AddRange(midiEvents);

                var notes = eventsCollection.GetNotes(settings);
                MidiAsserts.AreEqual(expectedNotes, notes, "Notes are invalid.");

                var timedObjects = eventsCollection.GetObjects(ObjectType.Note, new ObjectDetectionSettings {
                        NoteDetectionSettings = settings
                    });
                MidiAsserts.AreEqual(expectedNotes, timedObjects, "Notes are invalid from GetObjects.");
            }
            break;

            case ContainerType.TrackChunk:
            {
                var trackChunk = new TrackChunk(midiEvents);

                var notes = trackChunk.GetNotes(settings);
                MidiAsserts.AreEqual(expectedNotes, notes, "Notes are invalid.");

                var timedObjects = trackChunk.GetObjects(ObjectType.Note, new ObjectDetectionSettings {
                        NoteDetectionSettings = settings
                    });
                MidiAsserts.AreEqual(expectedNotes, timedObjects, "Notes are invalid from GetObjects.");
            }
            break;

            case ContainerType.TrackChunks:
            case ContainerType.File:
            {
                GetNotes_DetectionSettings_TrackChunks(
                    containerType == ContainerType.File,
                    settings,
                    new[] { midiEvents },
                    expectedNotes);
            }
            break;
            }
        }
예제 #22
0
 // Token: 0x06002A5E RID: 10846 RVA: 0x00137824 File Offset: 0x00135A24
 private static string smethod_0(EventsCollection eventsCollection_0)
 {
     for (int i = 0; i < eventsCollection_0.Count; i++)
     {
         if (eventsCollection_0[i].GetType() == typeof(SequenceTrackNameEvent))
         {
             string text = ((SequenceTrackNameEvent)eventsCollection_0[i]).Text.ToLower();
             if (text.Contains("part") || text == "t1 gems" || text == "events" || text == "beat")
             {
                 return(text);
             }
         }
     }
     return("");
 }
예제 #23
0
 // Token: 0x06002A60 RID: 10848 RVA: 0x00137BB0 File Offset: 0x00135DB0
 private static void smethod_2(EventsCollection eventsCollection_0, Song gclass27_0)
 {
     if (!GClass30.bool_0)
     {
         gclass27_0.list_0 = new List <float>();
         for (int i = 0; i < eventsCollection_0.Count; i++)
         {
             NoteOnEvent noteOnEvent = eventsCollection_0[i] as NoteOnEvent;
             if (noteOnEvent != null && noteOnEvent.OffEvent != null && (noteOnEvent.NoteNumber == 12 || noteOnEvent.NoteNumber == 13))
             {
                 gclass27_0.list_0.Add(gclass27_0.method_52((uint)noteOnEvent.AbsoluteTime));
             }
         }
     }
 }
예제 #24
0
        private static void AddTimedEventsToEventsCollection(EventsCollection eventsCollection, IEnumerable <ITimedObject> timedObjects)
        {
            var time = 0L;

            foreach (TimedEvent timedEvent in timedObjects)
            {
                var midiEvent = timedEvent.Event;
                if (midiEvent is ChannelEvent || midiEvent is MetaEvent || midiEvent is SysExEvent)
                {
                    midiEvent.DeltaTime = timedEvent.Time - time;
                    eventsCollection._events.Add(midiEvent);

                    time = timedEvent.Time;
                }
            }
        }
예제 #25
0
        public static string GenerateTrackData(TrackChunk track)
        {
            if (track == null)
            {
                return(null);
            }

            StringBuilder    output      = new StringBuilder();
            EventsCollection trackEvents = track.Events;

            foreach (MidiEvent currentEvent in trackEvents)
            {
                output.Append($"{currentEvent.ToString()}\n");
            }

            return(output.ToString());
        }
        private void GetChords_EventsCollection(
            ContainerType containerType,
            ICollection <MidiEvent> midiEvents,
            ICollection <Chord> expectedChords)
        {
            switch (containerType)
            {
            case ContainerType.EventsCollection:
            {
                var eventsCollection = new EventsCollection();
                eventsCollection.AddRange(midiEvents);

                var chords = eventsCollection.GetChords();
                MidiAsserts.AreEqual(expectedChords, chords, "Chords are invalid.");

                var timedObjects = eventsCollection.GetObjects(ObjectType.Chord);
                MidiAsserts.AreEqual(expectedChords, timedObjects, "Chords are invalid from GetObjects.");
            }
            break;

            case ContainerType.TrackChunk:
            {
                var trackChunk = new TrackChunk(midiEvents);

                var chords = trackChunk.GetChords();
                MidiAsserts.AreEqual(expectedChords, chords, "Chords are invalid.");

                var timedObjects = trackChunk.GetObjects(ObjectType.Chord);
                MidiAsserts.AreEqual(expectedChords, timedObjects, "Chords are invalid from GetObjects.");
            }
            break;

            case ContainerType.TrackChunks:
            case ContainerType.File:
            {
                GetChords_TrackChunks(
                    containerType == ContainerType.File,
                    new[] { midiEvents },
                    expectedChords);
            }
            break;
            }
        }
예제 #27
0
 private void CreateCommands()
 {
     RefreshEventsCommand = new Command(() =>
     {
         try
         {
             IsBusy = true;
             EventsCollection.Clear();
             cts.Cancel();
             cts.Dispose();
             cts = new CancellationTokenSource();
             LoadEvents(_type, true);
         }
         catch (Exception) {}
         finally
         {
             IsBusy = false;
         }
     });
 }
예제 #28
0
        async void SyncSchedules()
        {
            if (!IsBusy)
            {
                Exception Error = null;
                BarberSchedulesList.Clear();
                EventsCollection.Clear();

                try
                {
                    IsBusy = true;
                    var Repository = new Repository();
                    var Items      = await Repository.GetSchedule();

                    foreach (var Schedule in Items)
                    {
                        BarberSchedulesList.Add(Schedule);

                        eventAppointment.From      = Schedule.DateTime;
                        eventAppointment.To        = eventAppointment.From.AddHours(0.5);
                        eventAppointment.EventName = Schedule.Service;
                        eventAppointment.Color     = Color.ForestGreen;

                        EventsCollection.Add(eventAppointment);
                    }
                }
                catch (Exception ex)
                {
                    Error = ex;
                }
                finally
                {
                    IsBusy = false;
                }
                if (Error != null)
                {
                    await _pageDialogService.DisplayAlertAsync("Erro", Error.Message, "OK");
                }
            }
            return;
        }
예제 #29
0
 // Token: 0x06002A64 RID: 10852 RVA: 0x0013819C File Offset: 0x0013639C
 private static void smethod_6(EventsCollection eventsCollection_0, Song gclass27_0)
 {
     if (!GClass30.bool_0)
     {
         for (int i = 0; i < eventsCollection_0.Count; i++)
         {
             TextEvent textEvent = eventsCollection_0[i] as TextEvent;
             if (textEvent != null)
             {
                 if (textEvent.Text.Contains("[section ") && !textEvent.Text.Contains("_ENDOFSONG"))
                 {
                     gclass27_0.method_0(new GClass22(textEvent.Text.Substring(9, textEvent.Text.Length - 10), (uint)textEvent.AbsoluteTime), false);
                 }
                 else if (textEvent.Text.Contains("[prc_"))
                 {
                     gclass27_0.method_0(new GClass22(textEvent.Text.Substring(5, textEvent.Text.Length - 6), (uint)textEvent.AbsoluteTime), false);
                 }
             }
         }
         gclass27_0.method_15();
     }
 }
예제 #30
0
        private void LoadEvents(int type, bool updateRequested)
        {
            Device.BeginInvokeOnMainThread(async() =>
            {
                IsBusy = true;
                try
                {
                    cts.Token.ThrowIfCancellationRequested();
                    List <Models.Event> events = new List <Models.Event>();
                    if (Preferences.ContainsKey("events_key"))
                    {
                        var eventsSerialized = Preferences.Get("events_key", "null");
                        if (eventsSerialized is null || eventsSerialized.Length <= 0 || updateRequested)
                        {
                            //events = await App.EventManager.GetDataListAsync("event/type=" + type);

                            events           = await App.EventManager.GetDataListAsync("event");
                            eventsSerialized = JsonConvert.SerializeObject(events, Newtonsoft.Json.Formatting.None,
                                                                           new JsonSerializerSettings
                            {
                                NullValueHandling = NullValueHandling.Ignore
                            });
                            Preferences.Set("events_key", eventsSerialized);
                            events = events.FindAll(x => x.Type == type);
                        }
                        else
                        {
                            events = JsonConvert.DeserializeObject <List <Models.Event> >(eventsSerialized);
                            events = events.FindAll(x => x.Type == type);
                        }

                        foreach (var item in events)
                        {
                            EventsCollection.Add(item);
                        }
                        //EventsCollection = new ObservableCollection<Models.Event>(events);
                    }
                    IsBusy = false;
                } catch (OperationCanceledException) { IsBusy = false; }