public void DrawLine(int cell1, int cell2, char value) { if (!IsValidIndex(cell1) || !IsValidIndex(cell2)) { return; } if (cell1 == cell2) { this[cell1] = value; return; } var x1 = cell1 % _layout.Size; var y1 = cell1 / _layout.Size; var x2 = cell2 % _layout.Size; var y2 = cell2 / _layout.Size; var length = Math.Max(Math.Abs(x2 - x1), Math.Abs(y2 - y1)); for (var i = 0; i <= length; ++i) { var x = x1 + (x2 - x1) * (2 * i + 1) / (length * 2); var y = y1 + (y2 - y1) * (2 * i + 1) / (length * 2); SetValue(x, y, value); } DataChangedEvent.Invoke(); }
private void OnInitialDataChangedEvent(DataChangedEvent e) { try { if (e.LocalAccountId == LocalAccountId) { Dispatcher.Run(async delegate { try { // There's a good reason why we lock here. You initially might think "Well, it's on the UI thread, no reason // to lock when something's on the UI thread, right?" // However, some things like Live Tiles will load the view items group on a background thread, and will // enumerate over the items within the view items group from their background thread. // Therefore, a new change could come in on the UI thread while the background thread is enumerating over // the items in the view group. That would therefore cause an exception in the enumeration. // So far we haven't seen any cases of this lock causing deadlocks, and it's 100% isolated from the main data write // lock, so there shouldn't be any concerns about this causing delays using (await DataChangeLock.LockForWriteAsync(callerName: this.GetType() + ".OnInitialDataChanged")) { OnDataChangedEvent(e); } } catch (Exception ex) { TelemetryExtension.Current?.TrackException(ex); } }); } } catch (Exception ex) { TelemetryExtension.Current?.TrackException(ex); } }
public void DataChanged(AccountDataStore dataStore, DataChangedEvent e) { try { if (LayoutMode != LayoutModes.Normal && e.LocalAccountId == MainScreenViewModel.CurrentLocalAccountId) { Dispatcher.Run(delegate { try { if (LayoutMode != LayoutModes.Normal) { UpdateEditMode(); } } catch (Exception ex) { TelemetryExtension.Current?.TrackException(ex); } }); } } catch (Exception ex) { TelemetryExtension.Current?.TrackException(ex); } }
private bool HandleModifyingChildrenRecursively(DataChangedEvent e) { IViewItemChildrenHelper[] childrenHelpers; lock (this) { childrenHelpers = _children.ToArray(); } bool changed = false; // Make sure that children are in the right place (and add existing/new) foreach (var childrenHandler in childrenHelpers) { if (childrenHandler.HandleChanges(e)) { changed = true; } } // And do the same for children recursively foreach (var child in childrenHelpers.SelectMany(i => i.GetChildren())) { if (child.HandleModifyingChildrenRecursively(e)) { changed = true; } } return(changed); }
private async void AccountDataStore_DataChangedEvent(object sender, DataChangedEvent e) { lock (_changedItemListeners) { for (int i = 0; i < _changedItemListeners.Count; i++) { IDataChangeListener listener; _changedItemListeners[i].TryGetTarget(out listener); if (listener == null) { _changedItemListeners.RemoveAt(i); i--; } else { listener.HandleDataChangedEvent(e); } } } // If there's no semester right now, nothing needs changing if (CurrentSemesterId == Guid.Empty) { return; } // If the changes are for this account if (e.LocalAccountId == CurrentLocalAccountId) { try { // We fall back to current thread since the view model should remain correct even // if the view is disconnected. await Dispatcher.RunOrFallbackToCurrentThreadAsync(async delegate { try { // If this semester was deleted if (e.DeletedItems.Contains(CurrentSemesterId)) { await SetCurrentSemester(Guid.Empty); return; } } catch (Exception ex) { TelemetryExtension.Current?.TrackException(ex); } }); } catch (Exception ex) { TelemetryExtension.Current?.TrackException(ex); } } }
protected override void OnDataChangedEvent(DataChangedEvent e) { if (Items != null && _semester != null && _cachedSemesterItems == null) { Guid[] classIdentifiers = _semester.Classes.Select(i => i.Identifier).ToArray(); DateTime todayAsUtc = DateTime.SpecifyKind(Today, DateTimeKind.Utc); // Remove items that were deleted Items.RemoveWhere(i => e.DeletedItems.Contains(i.Identifier)); // Look through edited items foreach (var edited in e.EditedItems.OfType <DataItemMegaItem>()) { var matched = Items.FirstOrDefault(i => i.Identifier == edited.Identifier); // If the edited item should be in our collection if (ShouldIncludeItem(edited, classIdentifiers, todayAsUtc)) { // If there was a matching, we need to update it if (matched != null) { matched.PopulateFromDataItem(edited); AssignClass(edited, matched); // And then add/remove (a.k.a. resort) Items.Remove(matched); Add(matched); } // Otherwise we need to create a view item else { Add(edited); } } // Otherwise it shouldn't be in our collection else { // If there was a matching, we need to remove it since it's no longer needed if (matched != null) { Items.Remove(matched); } } } // Any items that are no longer have a class need to be removed Items.RemoveWhere(i => !i.Class.IsNoClassClass && !_semester.Classes.Contains(i.Class)); // Add new items foreach (var newItem in e.NewItems.OfType <DataItemMegaItem>().Where(ShouldIncludeItemFunction(classIdentifiers, todayAsUtc))) { Add(newItem); } } }
public char this[int index] { get { return(_layout[index]); } set { SetValue(index % _layout.Size, index / _layout.Size, value); DataChangedEvent.Invoke(); } }
public bool Remove(string key) { if (dataDict.TryGetValue(key, out var oldValue) && dataDict.Remove(key)) { DataChangedEvent?.Invoke(key, null, oldValue); return(true); } return(false); }
public char this[int x, int y] { get { return(_layout[x, y]); } set { SetValue(x, y, value); DataChangedEvent.Invoke(); } }
protected static void OnDataChanged(DataEventArgs e) { if (DataChangedEvent != null) { foreach (EventHandler <DataEventArgs> dataChangedEvent in DataChangedEvent.GetInvocationList()) { dataChangedEvent(null, e); } } }
public void HandleDataChangedEvent(DataChangedEvent e) { if (e.LocalAccountId == _localAccountId && e.WasLocalChanges) { var changedItems = e.NewItems.Union(e.EditedItems).OfType <T>().Select(i => i.Identifier).ToArray(); if (changedItems.Length > 0 && ChangedItems != null) { ChangedItems.Invoke(this, changedItems); } } }
public void Set(string key, string value) { if (key == null) { throw new ArgumentNullException("key"); } dataDict.TryGetValue(key, out var oldValue); dataDict[key] = value; DataChangedEvent?.Invoke(key, value, oldValue); }
protected override void OnDataChangedEvent(DataChangedEvent e) { if (Semester != null) { if (Semester.HandleDataChangedEvent(e)) { if (OnChangesOccurred != null) { OnChangesOccurred(this, e); } } } }
public void HandleDataChangedEvent(DataChangedEvent e) { if (e.LocalAccountId == _localAccountId) { if (e.DeletedItems.Contains(_identifier)) { _dispatcher.Run(delegate { Deleted?.Invoke(this, new EventArgs()); }); } } }
protected override void OnDataChangedEvent(DataChangedEvent e) { ViewItemSemester s = Item?.Class?.Semester; if (s != null) { s.HandleDataChangedEvent(e); Item.HandleDataChangedEvent(e); // And update the class var newClass = s.Classes.FirstOrDefault(c => c.Identifier == (Item.DataItem as DataItemMegaItem).UpperIdentifier); Item.GetType().GetRuntimeProperty("Class").SetValue(Item, newClass); } }
protected override void OnDataChangedEvent(DataChangedEvent e) { if (School != null) { bool changed = School.HandleDataChangedEvent(e); if (changed) { // Sort years here since changes in semester dates changes year sort School.Years.Sort(); School.CalculateEverything(); } } }
public void DrawEllipse(int cell1, int cell2, char value) { if (!IsValidIndex(cell1) || !IsValidIndex(cell2)) { return; } var x1 = cell1 % _layout.Size; var x2 = cell2 % _layout.Size; var y1 = cell1 / _layout.Size; var y2 = cell2 / _layout.Size; if (x1 > x2) { var t = x1; x1 = x2; x2 = t; } if (y1 > y2) { var t = y1; y1 = y2; y2 = t; } var d = (x1 + x2) / 2f; var d2 = (y1 + y2) / 2f; var num = (x2 - x1) / 2f + 0.5f; var num2 = (y2 - y1) / 2f + 0.5f; for (int i = x1; i <= x2; i++) { for (int j = y1; j <= y2; j++) { if ((i - d) * (i - d) / (num * num) + (j - d2) * (j - d2) / (num2 * num2) <= 1f) { SetValue(i, j, value); } } } DataChangedEvent.Invoke(); }
private static void AccountDataStore_DataChangedEvent(object sender, DataChangedEvent e) { lock (_viewItemsGroups) { for (int i = 0; i < _viewItemsGroups.Count; i++) { BaseAccountViewItemsGroup model; if (_viewItemsGroups[i].TryGetTarget(out model)) { model.OnInitialDataChangedEvent(e); } else { _viewItemsGroups.RemoveAt(i); i--; } } } }
internal virtual bool HandleDataChangedEvent(DataChangedEvent e) { bool changed = false; // Apply the edits to self and descendants if (HandleUpdatingSelfAndDescendants(e)) { changed = true; } // Modify the children if (HandleModifyingChildrenRecursively(e)) { changed = true; } if (HandleDataChangedEventAfterBase(e)) { changed = true; } return(changed); }
public void DrawRectangle(int cell1, int cell2, char value) { if (!IsValidIndex(cell1) || !IsValidIndex(cell2)) { return; } var x1 = cell1 % _layout.Size; var y1 = cell1 / _layout.Size; var x2 = cell2 % _layout.Size; var y2 = cell2 / _layout.Size; if (x1 > x2) { var t = x1; x1 = x2; x2 = t; } if (y1 > y2) { var t = y1; y1 = y2; y2 = t; } for (var x = x1; x <= x2; ++x) { for (var y = y1; y <= y2; ++y) { SetValue(x, y, value); } } DataChangedEvent.Invoke(); }
private bool HandleUpdatingSelfAndDescendants(DataChangedEvent e) { bool changed = false; // First edit this item itself if (this is BaseViewItem && (this as BaseViewItem).HasData) { BaseViewItem baseViewItem = this as BaseViewItem; BaseDataItem editedItem = e.EditedItems.FirstOrDefault(i => i.Identifier == baseViewItem.Identifier); if (editedItem != null) { baseViewItem.PopulateFromDataItem(editedItem); changed = true; } } IViewItemChildrenHelper[] childrenHelpers; lock (this) { childrenHelpers = _children.ToArray(); } // Then edit all children foreach (var child in childrenHelpers.SelectMany(i => i.GetChildren())) { if (child.HandleUpdatingSelfAndDescendants(e)) { changed = true; } } return(changed); }
private void OnTypeChanged() { _content = CreateContent(Type); DataChangedEvent?.Invoke(); LayoutChangedEvent?.Invoke(); }
private void OnTypeChanged() { CreateContent(null, null); DataChangedEvent?.Invoke(); LayoutChangedEvent?.Invoke(); }
private void OnTypeChanged() { Content = LootFactory.CreateLoot(Type); DataChangedEvent?.Invoke(); LayoutChangedEvent?.Invoke(); }
public DataChangedEventDictionary(DataChangedEvent dataChangedEvent) { _dataChangedEvent = dataChangedEvent; _dictionary = new Dictionary <Type, Type>(); }
private void OnTypeChanged() { Content = RequirementFactory.CreateRequirement(Type); DataChangedEvent?.Invoke(); LayoutChangedEvent?.Invoke(); }
private void ViewModelSchedule_OnChangesOccurred(object sender, DataChangedEvent e) { UpdateAvailableItemsAndTriggerUpdateDisplay(); }
public bool HandleChanges(DataChangedEvent e) { bool changed = false; List <V> toRemove = new List <V>(); List <V> toReSort = new List <V>(); foreach (V child in Children) { // If it was deleted, then we mark it for remove if (e.DeletedItems.Contains(child.Identifier)) { toRemove.Add(child); } else { D edited = e.EditedItems.OfType <D>().FirstOrDefault(i => i.Identifier == child.Identifier); // If it was edited if (edited != null) { // If it's still a child, we'll need to re-sort it if (IsChild.Invoke(edited)) { toReSort.Add(child); } // Otherwise it's no longer a child, so remove it from this parent else { toRemove.Add(child); } } } } if (toRemove.Count > 0 || toReSort.Count > 0) { changed = true; } // Now remove all that need removing foreach (V item in toRemove) { RemoveChildMethod.Invoke(item); } // And re-sort all that need re-sorting foreach (V item in toReSort) { // First remove RemoveChildMethod.Invoke(item); // Then re-add AddChildMethod.Invoke(item); } // And also add items that currently aren't children, but were edited and may be new children if (FilterAndAddChildren(e.EditedItems.Where(i => !Children.Any(c => c.Identifier == i.Identifier)))) { changed = true; } // And now add the new items if (FilterAndAddChildren(e.NewItems)) { changed = true; } return(changed); }
private void ScheduleViewItemsGroup_OnChangesOccurred(object sender, DataChangedEvent e) { EnsureChangesPropagated(); }
protected override void OnDataChangedEvent(DataChangedEvent e) { base.OnDataChangedEvent(e); if (_semester != null) { // Look through edited items if (Class.HomeworkAndExams != null) { foreach (var edited in e.EditedItems.OfType <DataItemMegaItem>()) { var matched = Class.HomeworkAndExams.FirstOrDefault(i => i.Identifier == edited.Identifier); // If found matching if (matched != null) { // If no longer under this class, we need to re-assign the class if (matched is ViewItemHomework) { var h = matched as ViewItemHomework; if (h.Class.Identifier != edited.UpperIdentifier) { if (edited.UpperIdentifier == _semester.NoClassClass.Identifier) { h.Class = _semester.NoClassClass; } else { h.Class = _semester.Classes.FirstOrDefault(i => i.Identifier == edited.UpperIdentifier); } } } else if (matched is ViewItemExam) { var exam = matched as ViewItemExam; if (exam.Class.Identifier != edited.UpperIdentifier) { if (edited.UpperIdentifier == _semester.NoClassClass.Identifier) { exam.Class = _semester.NoClassClass; } else { exam.Class = _semester.Classes.FirstOrDefault(i => i.Identifier == edited.UpperIdentifier); } } } } } } // Re-assigning classes needs to be done before, otherwise we'll no longer have a reference to the object _semester.HandleDataChangedEvent(e); // Only calculates if needed if (IsGradesLoaded) { Class.CalculateEverything(); } // If we previously didn't have old items, see whether we do now if (!HasPastCompletedHomework) { bool hasPastCompleted = e.EditedItems.Concat(e.NewItems).OfType <DataItemMegaItem>().Any( h => IsPastCompletedHomeworkFunction(_classId, TodayAsUtc).Invoke(h)); if (hasPastCompleted) { HasPastCompletedHomework = true; } } if (!HasPastCompletedExams) { bool hasPastCompleted = e.EditedItems.Concat(e.NewItems).OfType <DataItemMegaItem>().Any( exam => IsPastCompletedExamFunction(_classId, TodayAsUtc).Invoke(exam)); if (hasPastCompleted) { HasPastCompletedExams = true; } } if (UnassignedItems != null) { // Remove any deleted if (e.DeletedItems.Any()) { UnassignedItems.RemoveWhere(i => e.DeletedItems.Contains(i.Identifier)); } List <DataItemMegaItem> potentialNew = new List <DataItemMegaItem>(e.NewItems.OfType <DataItemMegaItem>()); // Look through edited foreach (var edited in e.EditedItems.OfType <DataItemMegaItem>()) { var matching = UnassignedItems.FirstOrDefault(i => i.Identifier == edited.Identifier); if (matching != null) { // If it should be removed if (!IsUnassignedChild(edited)) { UnassignedItems.Remove(matching); } // Otherwise it needs to be updated and then re-sorted else { matching.PopulateFromDataItem(edited); UnassignedItems.Remove(matching); UnassignedItems.InsertSorted(matching); } } // New else { potentialNew.Add(edited); } } foreach (var newItem in potentialNew) { if (IsUnassignedChild(newItem)) { BaseViewItemHomeworkExam newViewItem; if (newItem.MegaItemType == PowerPlannerSending.MegaItemType.Homework) { newViewItem = new ViewItemHomework(newItem) { Class = this.Class, WeightCategory = ViewItemWeightCategory.UNASSIGNED }; } else if (newItem.MegaItemType == PowerPlannerSending.MegaItemType.Exam) { newViewItem = new ViewItemExam(newItem) { Class = this.Class, WeightCategory = ViewItemWeightCategory.UNASSIGNED }; } else { continue; } UnassignedItems.InsertSorted(newViewItem); } } HasUnassignedItems = UnassignedItems.Count > 0; } } }