Esempio n. 1
0
        public static void ScootAndOverwrite <T>(
            this DurationField <T> field,
            T item,
            Duration duration
            )
        {
            foreach (var oldstaff in field.Intersecting(duration).ToArray())
            {
                field.Remove(oldstaff);

                foreach (var cutduration in oldstaff.Duration.Subtract(duration))
                {
                    field.Add(oldstaff.Value, cutduration);
                }
            }

            field.Add(item, duration);
        }
Esempio n. 2
0
        //public Duration this[T item] {
        //    get { return field1[item]; }
        //    set {
        //        field1[item] = value;
        //        field2[item] = new Duration {
        //            Start = value.Start - Length,
        //            Length = value.Length
        //        };
        //    }
        //}

        public void Add(T item, Duration duration)
        {
            var start = duration.Start;

            start %= Length;

            field1.Add(item, new Duration {
                Start  = start,
                Length = duration.Length
            });

            field2.Add(item, new Duration {
                Start  = start - Length,
                Length = duration.Length
            });
        }
Esempio n. 3
0
        private void Storage_ChildAdded(string key, StorageObjectID child)
        {
            var duration =
                CodeTools.ReadDuration(key);

            if (!events.Contains(duration))
            {
                lock (locker) {
                    if (events.Contains(duration))
                    {
                        return;
                    }
                    events.Add(duration);
                }

                var contents = Deserializer(File.Storage[child]);
                field.Add(contents, duration);
            }
        }
Esempio n. 4
0
        public MelodyTrack(
            StorageObjectID storageobjectID,
            EditorFile file
            ) :
            base(
                storageobjectID,
                file,
                null     //TODO
                )
        {
            obj = this.Object();

            notes_field.GeneralDuration.AfterChange += GeneralDuration_AfterChange;

            next_noteID_obj = obj.GetOrMake("next_noteID");
            listener_nextnodeID_contentsset =
                next_noteID_obj.CreateListen(IOEvent.ObjectContentsSet, () => {
                if (!int.TryParse(next_noteID_obj.ReadAllString(), out next_noteID))
                {
                    next_noteID_obj.WriteAllString("0");
                }
            });

            notes_obj            = obj.GetOrMake("notes");
            listener_notes_added =
                notes_obj.CreateListen(IOEvent.ChildAdded, (key, new_note_objID) => {
                var noteID       = new NoteID(int.Parse(key));
                var new_note_obj = notes_obj.Graph[new_note_objID];
                var contents     = new_note_obj.ReadAllString().Split('\n');
                var duration     = CodeTools.ReadDuration(contents[0]);
                var tone         = new SemiTone(int.Parse(contents[1]));

                var note =
                    new Note(
                        noteID,
                        duration,
                        tone
                        );

                notes_field.Add(noteID, duration);
                notes_lookup.Add(noteID, note);
                FieldChanged?.Invoke(duration);
            });

            listener_notes_changed =
                notes_obj.CreateListen(IOEvent.ChildContentsSet, (key, changed_note_objID) => {
                var noteID       = new NoteID(int.Parse(key));
                var new_note_obj = notes_obj.Graph[changed_note_objID];
                var contents     = new_note_obj.ReadAllString().Split('\n');
                var duration     = CodeTools.ReadDuration(contents[0]);
                var tone         = new SemiTone(int.Parse(contents[1]));

                Note oldnote;
                if (notes_lookup.TryGetValue(noteID, out oldnote))
                {
                    if (oldnote.Duration != duration ||
                        oldnote.Tone != tone)
                    {
                        var newnote =
                            new Note(
                                noteID,
                                duration,
                                tone
                                );

                        var oldnoteduration =
                            oldnote.Duration;

                        notes_lookup[noteID] = newnote;
                        notes_field.Move(noteID, oldnoteduration, duration);
                        FieldChanged?.Invoke(oldnoteduration.Union(duration));
                    }
                }
            });

            listener_notes_removed =
                notes_obj.CreateListen(IOEvent.ChildRemoved, (key, old_note_objID) => {
                var noteID = new NoteID(int.Parse(key));

                var oldnote = notes_lookup[noteID];

                notes_field.Remove(noteID, oldnote.Duration);
                notes_lookup.Remove(noteID);
                FieldChanged?.Invoke(oldnote.Duration);
            });
        }