public DurationFieldBinder( StorageObjectID storageobjectID, EditorFile file, DurationField <T> field ) : base( storageobjectID, file, null //TODO ) { this.field = field; obj = this.Object(); field.ItemAdded += Field_ItemAdded; field.ItemMoved += Field_ItemMoved; field.ItemChanged += Field_ItemChanged; field.ItemRemoved += Field_ItemRemoved; listener_added = obj.CreateListen(IOEvent.ChildAdded, Storage_ChildAdded); listener_rekeyed = obj.Graph.CreateListen(Storage_ChildRekeyed, storageobjectID, IOEvent.ChildRekeyed); listener_contentsset = obj.CreateListen(IOEvent.ChildContentsSet, Storage_ChildContentsSet); listener_removed = obj.CreateListen(IOEvent.ChildRemoved, Storage_ChildRemoved); }
public PolylineData( IStorageObject storage, EditorFile file, float constant = 0 ) : base( storage.ID, file, FactoryInstance ) { this.storage = storage; if (storage.IsEmpty) { Add(0f, constant); } listener_add = storage.CreateListen(IOEvent.ChildAdded, (key, pt_objID) => { var t = float.Parse(key); var v = float.Parse(storage.Graph[pt_objID].ReadAllString()); Add_ram(t, v); }); listener_rekey = storage.Graph.CreateListen( msg => { var t0 = float.Parse(msg.Relation); var t1 = float.Parse(msg.NewRelation); MoveX_ram(t0, t1); }, storage.ID, IOEvent.ChildRekeyed ); listener_contentsset = storage.CreateListen(IOEvent.ChildContentsSet, (key, pt_objID) => { var t = float.Parse(key); var v1 = float.Parse(storage.Graph[pt_objID].ReadAllString()); MoveY_ram(t, v1); }); listener_remove = storage.CreateListen(IOEvent.ChildRemoved, (key, pt_objID) => { var t = float.Parse(key); var v = float.Parse(storage.Graph[pt_objID].ReadAllString()); RemoveExact_ram(t, v); }); }
private void Listeners_ItemInserted(IOListener listener, int i) { var j = messages.Count - 1; readylisteners.Insert(i, j); for (; j >= 0; j--) { listener.Process(messages[j]); } }
public TimeMarkerUnit( IStorageObject storage, EditorFile file ) : base( storage.ID, file, null ) { this.storage = storage; listener_added = storage.CreateListen(IOEvent.ChildAdded, (key, newmarker_objID) => { var name = key; var time = Time.FromTicks(int.Parse(storage.Graph[newmarker_objID].ReadAllString())); markers.Add(name, new ObservableProperty <Time>(time)); }); listener_rekeyed = storage .Graph .CreateListen( msg => { var oldname = msg.Relation; var newname = msg.NewRelation; var prop = markers[oldname]; markers.Remove(oldname); markers.Add(newname, prop); }, storage.ID, IOEvent.ChildRekeyed ); listener_contentsset = storage.CreateListen(IOEvent.ChildContentsSet, (key, marker_objID) => { var name = key; var newtime = Time.FromTicks(int.Parse(storage.Graph[marker_objID].ReadAllString())); markers[name].Value = newtime; }); listener_removed = storage.CreateListen(IOEvent.ChildRemoved, (name, oldmarker_objID) => { markers.Remove(name); }); }
public PropertyBinder( IStorageObject storageobject, ObservableProperty <T> property, Func <IStorageObject, T> deserializer, Action <IStorageObject, T> serializer ) { this.storageobject = storageobject; this.property = property; this.deserializer = deserializer; this.serializer = serializer; listener = storageobject.CreateListen(IOEvent.ObjectContentsSet, StorageObject_ContentsSet); property.AfterChange += Property_AfterChange; storageobject.Graph.Listeners.Add(listener); }
private void Listeners_ItemInserted(IOListener listener, int i) { int[] indicies_msg; lock (locker) { var lookup_subject_this = lookup_subject.Lookup( listener.Filter.Subject, () => new KeyValuePair <ShiftableBitArray, ShiftableBitArray>( new ShiftableBitArray(), new ShiftableBitArray() ) ); var lookup_verb_this = lookup_verb.Lookup( listener.Filter.Verb, () => new KeyValuePair <ShiftableBitArray, ShiftableBitArray>( new ShiftableBitArray(), new ShiftableBitArray() ) ); foreach (var subject in lookup_subject) { subject.Value.Key.Insert(i, subject.Key == listener.Filter.Subject); } foreach (var verb in lookup_verb) { verb.Value.Key.Insert(i, verb.Key == listener.Filter.Verb); } indicies_msg = lookup_subject_this.Value.AllOnes(lookup_verb_this.Value).ToArray(); } for (int j = 0; j < indicies_msg.Length; j++) { listener.Responder(Messages[indicies_msg[j]]); } }
private void Listeners_ItemWithdrawn(IOListener listener, int i) { lock (locker) { var lookup_subject_this = lookup_subject[listener.Filter.Subject]; var lookup_verb_this = lookup_verb[listener.Filter.Verb]; foreach (var subject in lookup_subject) { subject.Value.Key.Withdraw(i); } foreach (var verb in lookup_verb) { verb.Value.Key.Withdraw(i); } } }
public FunctionEditorScreen( StorageObjectID storageobjectID, EditorFile file ) : base( storageobjectID, file ) { container = file[FunctionContainer.ItemName] as FunctionContainer; var obj = file.Storage[storageobjectID]; var activefunctionsource_vec_obj = obj.GetOrMake("active-function-source-vec"); listener_activefunctionsourcefile_add = activefunctionsource_vec_obj.CreateListen(IOEvent.ChildAdded, (key, activefunctionsource_objID) => { if (ActiveFunctionSourceFile.Value != null) { throw new InvalidOperationException(); } ActiveFunctionSourceFile.Value = container.FunctionSources[activefunctionsource_objID]; }); listener_activefunctionsourcefile_remove = activefunctionsource_vec_obj.CreateListen(IOEvent.ChildRemoved, (key, activefunctionsource_objID) => { if (ActiveFunctionSourceFile.Value == null) { throw new InvalidOperationException(); } ActiveFunctionSourceFile.Value = null; }); }
private BoundList( StorageObjectID storageobjectID, EditorFile file, FactorySet <T> factoryset, ViewerSet <T> viewerset, BoundList <T> master ) : base( storageobjectID, file, null //TODO ) { this.factoryset = factoryset; this.viewerset = viewerset; this.master = master; hub_obj = File.Storage[StorageObjectID]; var propertybinders = new Dictionary <string, PropertyBinder <string> >(); listener_add = hub_obj.CreateListen( IOEvent.ChildAdded, (key, objID) => { int i = int.Parse(key); if (Objects.Count > i && Objects.HasItemAt(i) && Objects[i].StorageObjectID == objID) { return; } var obj = master == null ? FactorySet.Load(objID, File) : master[objID]; var namedobj = obj as INamedObject; if (namedobj != null) { if (master == null) { var name_obj = File .Storage [objID] .GetOrMake("name"); var name_val = name_obj.ReadAllString(); if (map_name.ContainsKey(name_val)) { if (master == null) { if (AutomaticallyAvoidNameCollisionsWithUnderlines) { name_val += "_"; } else { throw new ArgumentException($"Name \"{name_val}\" already in use."); } } } name_obj.WriteAllString(name_val); var binder = namedobj.Name.Bind(name_obj); namedobj.Name.AfterChange += propertybinders.Rename; propertybinders.Add(binder.Property.Value, binder); } } if (Objects.Contains(obj)) { throw new InvalidOperationException(); } Objects.Insert(i, obj); if (master == null) { if (isallowedtobindobjects) { obj.Bind(); } } } ); listener_remove = hub_obj.CreateListen( IOEvent.ChildRemoved, (key, objID) => { var i = int.Parse(key); var obj = Objects.FirstOrDefault(_ => _.StorageObjectID == objID); if (obj != null) { var namedobj = obj as INamedObject; if (namedobj != null) { if (master == null) { namedobj.Name.AfterChange -= propertybinders.Rename; propertybinders[namedobj.Name.Value].Dispose(); propertybinders.Remove(namedobj.Name.Value); } } if (master == null) { obj.Unbind(); } Objects.Remove(obj); } } ); listener_move = hub_obj .Graph .CreateListen( msg => { var old_i = int.Parse(msg.Relation); var new_i = int.Parse(msg.NewRelation); Objects.Move(old_i, new_i); }, hub_obj.ID, IOEvent.ChildRekeyed ); Objects.ItemInserted += (obj, i) => { if (!hub_obj.HasChild(obj.StorageObjectID)) { if (master == null) { throw new InvalidOperationException(); } hub_obj.Add(i.ToString(), obj.StorageObjectID); } var namedobj = obj as INamedObject; if (namedobj != null) { namedobj.Name.BeforeChange += Object_Renaming; namedobj.Name.AfterChange += Object_Renamed; map_name.Add(namedobj.Name.Value, obj); map_name_inverse.Add(obj, namedobj.Name.Value); } map_storageobjectID.Add(obj.StorageObjectID, obj); map_storageobjectID_inverse.Add(obj, obj.StorageObjectID); }; Objects.ItemWithdrawn += (obj, i) => { if (hub_obj.HasChild(obj.StorageObjectID)) { hub_obj.Remove(obj.StorageObjectID); } var namedobj = obj as INamedObject; if (namedobj != null) { namedobj.Name.BeforeChange -= Object_Renaming; namedobj.Name.AfterChange -= Object_Renamed; namedobj.Name.AfterChange -= propertybinders.Rename; map_name.Remove(namedobj.Name.Value); map_name_inverse.Remove(obj); } map_storageobjectID.Remove(obj.StorageObjectID); map_storageobjectID_inverse.Remove(obj); }; Objects.ItemMoved += (item, oldindex, newindex) => { var sign = Math.Sign(newindex - oldindex); for (int i = oldindex; i != newindex; i += sign) { if (isallowedtobindobjects) { throw new NotImplementedException(); } else { // The bound list is still loading items from storage. // The 'moving' is really just initialization to sync with // the back-end store, if the code ran this else clause. } } }; }
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); }); }
private void Listeners_ItemWithdrawn(IOListener listener, int i) { //this is unsafe readylisteners.RemoveAt(i); }