static void GridHelpers_VectorChanged(IObservableVector<object> sender, IVectorChangedEventArgs @event)
{
//so, jetzt für jedes Item eine Gridrow anlegen, aber nur wie hoch?
foreach (var item in sender)
{
}
}
private void HistoryChanged(IObservableVector<object> sender, IVectorChangedEventArgs @event)
{
if (InstantMessagingHistory.Items.Count > 0)
{
var lastItem = InstantMessagingHistory.Items[InstantMessagingHistory.Items.Count - 1];
InstantMessagingHistory.UpdateLayout();
InstantMessagingHistory.ScrollIntoView(lastItem);
}
}
private void ItemsOnVectorChanged(IObservableVector<object> sender, IVectorChangedEventArgs @event)
{
if (listBox == null) return;
var lastItem = listBox.Items.LastOrDefault();
if (lastItem != null)
{
listBox.UpdateLayout();
listBox.ScrollIntoView(lastItem);
}
}
private void ActionCollection_VectorChanged(IObservableVector<DependencyObject> sender, IVectorChangedEventArgs eventArgs)
{
CollectionChange collectionChange = eventArgs.CollectionChange;
if (collectionChange == null)
{
foreach (DependencyObject current in this)
ActionCollection.VerifyType(current);
}
if (collectionChange == CollectionChange.ItemInserted || collectionChange == CollectionChange.ItemChanged)
{
DependencyObject item = this[(int)eventArgs.Index];
ActionCollection.VerifyType(item);
}
}
private void BehaviorCollection_VectorChanged(IObservableVector<DependencyObject> sender, IVectorChangedEventArgs eventArgs)
{
if (eventArgs.CollectionChange == null)
{
foreach (IBehavior current in this.oldCollection)
{
if (current.AssociatedObject != null)
{
current.Detach();
}
}
this.oldCollection.Clear();
foreach (DependencyObject dependencyObject in this.AsEnumerable())
this.oldCollection.Add(this.VerifiedAttach(dependencyObject));
return;
}
int index = (int)eventArgs.Index;
DependencyObject item = this[index];
switch (eventArgs.CollectionChange)
{
case CollectionChange.ItemInserted:
this.oldCollection.Insert(index, this.VerifiedAttach(item));
return;
case CollectionChange.ItemRemoved:
{
IBehavior behavior = this.oldCollection[index];
if (behavior.AssociatedObject != null)
{
behavior.Detach();
}
this.oldCollection.RemoveAt(index);
return;
}
case CollectionChange.ItemChanged:
{
IBehavior behavior = this.oldCollection[index];
if (behavior.AssociatedObject != null)
{
behavior.Detach();
}
this.oldCollection[index] = this.VerifiedAttach(item);
return;
}
default:
return;
}
}
private static void OnVectorChanged(IObservableVector<DependencyObject> sender, IVectorChangedEventArgs e)
{
switch (e.CollectionChange)
{
case CollectionChange.ItemInserted:
case CollectionChange.ItemChanged:
VerifyType(sender[(int)e.Index]);
break;
case CollectionChange.Reset:
foreach (var item in sender)
{
VerifyType(item);
}
break;
}
}
private static void OnVectorChanged(IObservableVector<DependencyObject> sender, IVectorChangedEventArgs e)
{
var associatedObject = ((TriggerActionCollection) sender)._associatedObject;
switch (e.CollectionChange)
{
case CollectionChange.ItemInserted:
case CollectionChange.ItemChanged:
var item = sender[(int) e.Index];
VerifyType(item);
OnItemAdded(item, associatedObject);
break;
case CollectionChange.ItemRemoved:
OnItemRemoved(sender[(int)e.Index]);
break;
case CollectionChange.Reset:
foreach (var x in sender) { VerifyType(x); }
foreach (var x in sender) { OnItemRemoved(x); }
foreach (var x in sender) { OnItemAdded(x, associatedObject); }
break;
}
}
private void ItemsChanged(IObservableVector <object> sender, IVectorChangedEventArgs @event)
{
ItemWidth = ThisView.ActualWidth / ThisView.Items.Count;
}
private void ItemsChanged(IObservableVector <object> sender, IVectorChangedEventArgs @event)
{
ItemHeight.Value = ActualHeight / Items.Count;
}
//Modifies the Owner FrameworkElement when Collection is modified
private void VisualStateChanged(object sender, IVectorChangedEventArgs e)
{
RefreshStateTriggers();
}
internal void OnOwnerSourceCollectionChanged(IVectorChangedEventArgs args)
{
this.OnItemsChanged(args);
}
/// <summary>
/// 컨트롤에서 발생한 이벤트를 이용해서 뷰모델의 프로퍼티에 작업
/// </summary>
/// <param name="sender"></param>
/// <param name="event"></param>
void ControlToViewModel_VectorChanged(IObservableVector<object> sender, IVectorChangedEventArgs @event)
{
if (_isLock == true) return;
_isLock = true;
//Reset, ItemInserted만 발생함
switch (@event.CollectionChange)
{
case CollectionChange.Reset:
((IList)SelectedItems).Clear();
break;
case CollectionChange.ItemInserted:
var item = sender.ElementAt((int)@event.Index);
((IList)SelectedItems).Add(item);
break;
case CollectionChange.ItemRemoved:
if (true) { } //디버그
break;
case CollectionChange.ItemChanged:
if (true) { } //디버그
break;
}
_isLock = false;
}
private void OnItemsVectorChanged(IObservableVector <object> sender, IVectorChangedEventArgs @event)
{
SynchronizeItems();
}
private void ItemsCollectionChanged(IObservableVector <object> sender, IVectorChangedEventArgs e)
{
selectItemsButton.IsEnabled = listView.Items.Count > 0;
}
private void BehaviorCollection_VectorChanged(IObservableVector <DependencyObject> sender, IVectorChangedEventArgs eventArgs)
{
if (eventArgs.CollectionChange == CollectionChange.Reset)
{
foreach (IBehavior behavior in this.oldCollection)
{
if (behavior.AssociatedObject != null)
{
behavior.Detach();
}
}
this.oldCollection.Clear();
foreach (DependencyObject newItem in this)
{
this.oldCollection.Add(this.VerifiedAttach(newItem));
}
#if DEBUG
this.VerifyOldCollectionIntegrity();
#endif
return;
}
int eventIndex = (int)eventArgs.Index;
DependencyObject changedItem = this[eventIndex];
switch (eventArgs.CollectionChange)
{
case CollectionChange.ItemInserted:
this.oldCollection.Insert(eventIndex, this.VerifiedAttach(changedItem));
break;
case CollectionChange.ItemChanged:
IBehavior oldItem = this.oldCollection[eventIndex];
if (oldItem.AssociatedObject != null)
{
oldItem.Detach();
}
this.oldCollection[eventIndex] = this.VerifiedAttach(changedItem);
break;
case CollectionChange.ItemRemoved:
oldItem = this.oldCollection[eventIndex];
if (oldItem.AssociatedObject != null)
{
oldItem.Detach();
}
this.oldCollection.RemoveAt(eventIndex);
break;
default:
Debug.Assert(false, "Unsupported collection operation attempted.");
break;
}
#if DEBUG
this.VerifyOldCollectionIntegrity();
#endif
}
private void OnVectorChanged(IObservableVector <T> sender, IVectorChangedEventArgs @event)
{
VectorChanged?.Invoke(this, @event);
}
private void SecondaryCommands_VectorChanged(IObservableVector <ICommandBarElement> sender, IVectorChangedEventArgs @event)
{
System.Diagnostics.Debug.WriteLine("Secondary vector changed, " + sender.Count + " elements in sender");
UpdateCommandsVisibilityTracking(sender);
}
private void ItemsChanged(IObservableVector<object> sender, IVectorChangedEventArgs @event)
{
ItemHeight.Value = ActualHeight/Items.Count;
}
private void ItemsChanged(IObservableVector<object> sender, IVectorChangedEventArgs @event)
{
ItemWidth = ThisView.ActualWidth/ThisView.Items.Count;
}
private void Commands_VectorChanged(IObservableVector <ICommandBarElement> sender, IVectorChangedEventArgs @event)
{
if (myCommandBar.PrimaryCommands.Count > 0 || myCommandBar.SecondaryCommands.Count > 0)
{
titleText.Margin = new Thickness(20, -12, 20, 0);
}
else
{
titleText.Margin = new Thickness(20, 0, 20, 0);
}
}
private void Item_VideoTracksChanged(MediaPlaybackItem sender, IVectorChangedEventArgs args)
{
Log($"item.VideoTracksChanged: CollectionChange:{args.CollectionChange} Index:{args.Index} Total:{sender.VideoTracks.Count}");
switch (args.CollectionChange)
{
case CollectionChange.Reset:
foreach (VideoTrack track in sender.VideoTracks)
{
track.OpenFailed += VideoTrack_OpenFailed;
}
break;
case CollectionChange.ItemInserted:
VideoTrack newTrack = sender.VideoTracks[(int)args.Index];
newTrack.OpenFailed += VideoTrack_OpenFailed;
break;
}
}
public void RaiseVectorChanged(IVectorChangedEventArgs args)
{
VectorChanged?.Invoke(this, args);
}
private async void Items_VectorChanged(IObservableVector<MediaPlaybackItem> sender, IVectorChangedEventArgs args)
{
if (disposed) return;
await dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
if (disposed) return;
HandlePlaybackListChanges(sender);
});
}
// <SnippetVideoTracksChanged>
private async void MediaPlaybackItem_VideoTracksChanged(MediaPlaybackItem sender, IVectorChangedEventArgs args)
{
await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
{
videoTracksComboBox.Items.Clear();
for (int index = 0; index < sender.VideoTracks.Count; index++)
{
var videoTrack = sender.VideoTracks[index];
ComboBoxItem item = new ComboBoxItem();
item.Content = String.IsNullOrEmpty(videoTrack.Label) ? "Track " + index : videoTrack.Label;
item.Tag = index;
videoTracksComboBox.Items.Add(item);
}
});
}
private void OnVectorChanged(IObservableVector <object> sender, IVectorChangedEventArgs e)
{
this.ProcessEvent(sender, e);
}
// </SnippetAudioTracksSelectionChanged>
// <SnippetTimedMetadataTracksChanged>
private async void MediaPlaybackItem_TimedMetadataTracksChanged(MediaPlaybackItem sender, IVectorChangedEventArgs args)
{
await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
{
for (int index = 0; index < sender.TimedMetadataTracks.Count; index++)
{
var timedMetadataTrack = sender.TimedMetadataTracks[index];
ToggleButton toggle = new ToggleButton()
{
Content = String.IsNullOrEmpty(timedMetadataTrack.Label) ? "Track " + index : timedMetadataTrack.Label,
Tag = (uint)index
};
toggle.Checked += Toggle_Checked;
toggle.Unchecked += Toggle_Unchecked;
MetadataButtonPanel.Children.Add(toggle);
}
});
}
private static void ColorItemsVectorChanged(IObservableVector <object> sender, IVectorChangedEventArgs args)
{
// If the index is at the end we can ignore
if (args.Index == (sender.Count - 1))
{
return;
}
// Only need to handle Inserted and Removed because we'll handle everything else in the
// ColorContainerContentChanging method
if ((args.CollectionChange == CollectionChange.ItemInserted) || (args.CollectionChange == CollectionChange.ItemRemoved))
{
_itemsForList.TryGetValue(sender, out Windows.UI.Xaml.Controls.ListViewBase listViewBase);
if (listViewBase == null)
{
return;
}
int index = (int)args.Index;
for (int i = index; i < sender.Count; i++)
{
var itemContainer = listViewBase.ContainerFromIndex(i) as Control;
if (itemContainer != null)
{
SetItemContainerBackground(listViewBase, itemContainer, i);
}
}
}
}
// </SnippetToggleUnchecked>
// <SnippetAudioTracksChanged_CodecCheck>
private async void SnippetAudioTracksChanged_CodecCheck(MediaPlaybackItem sender, IVectorChangedEventArgs args)
{
if (args.CollectionChange == CollectionChange.ItemInserted)
{
var insertedTrack = sender.AudioTracks[(int)args.Index];
var decoderStatus = insertedTrack.SupportInfo.DecoderStatus;
if (decoderStatus != MediaDecoderStatus.FullySupported)
{
if (decoderStatus == MediaDecoderStatus.Degraded)
{
ShowMessageToUser(string.Format("Track {0} can play but playback will be degraded. {1}",
insertedTrack.Name, insertedTrack.SupportInfo.DegradationReason));
}
else
{
// status is MediaDecoderStatus.UnsupportedSubtype or MediaDecoderStatus.UnsupportedEncoderProperties
ShowMessageToUser(string.Format("Track {0} uses an unsupported media format.", insertedTrack.Name));
}
Windows.Media.MediaProperties.AudioEncodingProperties props = insertedTrack.GetEncodingProperties();
await HelpUserInstallCodec(props);
}
else
{
insertedTrack.OpenFailed += InsertedTrack_OpenFailed;
}
}
}
private void Commands_VectorChanged(IObservableVector <ICommandBarElement> sender, IVectorChangedEventArgs @event) => Update();
private void OnItemsVectorChanged(IObservableVector <MenuFlyoutItemBase> sender, IVectorChangedEventArgs e)
{
if (m_flyout != null)
{
var index = e.Index;
switch (e.CollectionChange)
{
case CollectionChange.ItemInserted:
m_flyout.Items.Insert((int)index, (MenuFlyoutItem)Items[(int)index]);
break;
case CollectionChange.ItemRemoved:
m_flyout.Items.RemoveAt((int)index);
break;
default:
break;
}
}
}
private void OnItemsChanged(IObservableVector <object> sender, IVectorChangedEventArgs @event)
{
UpdateSuggestionList();
}
internal void OnViewChanged(IObservableVector<object> sender, IVectorChangedEventArgs e)
{
// handle action
var rows = Rows;
var index = (int)e.Index;
var rowIndex = GetRowIndex(index);
var topRow = -1;
if (_cellPanel != null)
{
_cellPanel.UpdateViewRange();
var viewRange = _cellPanel.ViewRange;
topRow = viewRange.Row;
}
switch (e.CollectionChange)
{
case CollectionChange.ItemInserted:
// create the new bound row
var r = CreateBoundRow(sender[index]);
if (rowIndex < 0)
{
rowIndex = rows.Count;
}
// add the new bound row to the rows collection
if (rowIndex > -1)
{
rows.Insert(rowIndex, r);
}
else
{
LoadRows();
}
if (index <= topRow)
{
if (Math.Abs(ScrollPosition.Y) >= HeaderMeasureHeight)
{
ScrollPosition = new Point(ScrollPosition.X, ScrollPosition.Y - _cellPanel.Rows.DefaultSize);
}
}
break;
case CollectionChange.ItemRemoved:
if (rowIndex > -1)
{
rows.RemoveAt(rowIndex);
}
else
{
LoadRows();
}
if (index <= topRow)
{
if (Math.Abs(ScrollPosition.Y) >= HeaderMeasureHeight)
{
ScrollPosition = new Point(ScrollPosition.X, ScrollPosition.Y + _cellPanel.Rows.DefaultSize);
}
}
break;
case CollectionChange.ItemChanged:
rows[rowIndex].DataItem = sender[index];
_cellPanel.Invalidate(new CellRange(rowIndex, 0, rowIndex, Columns.Count - 1));
break;
default: // Reset, Move
if (_cellPanel != null)
{
_cellPanel.currentpointerOverRow = -1;
_cellPanel.currentPressedRow = -1;
_cellPanel.footerHeight = 0;
pointerOverPoint = null;
}
LoadRows();
break;
}
// ensure scrollbars are in sync
InvalidateArrange();
}
private void DependencyCollectionView_VectorChanged(IObservableVector <object> sender, IVectorChangedEventArgs @event)
{
switch (@event.CollectionChange)
{
case CollectionChange.ItemChanged:
break;
default:
RefreshPositionValues();
break;
}
}
public static NotifyCollectionChangedEventArgs ConvertToDataSourceChangedEventArgs(this IVectorChangedEventArgs args)
{
NotifyCollectionChangedEventArgs newArgs = null;
switch (args.CollectionChange)
{
case CollectionChange.ItemInserted:
List <object> addedItems = new List <object>();
addedItems.Add(null);
newArgs = new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Add, addedItems, args.Index);
break;
case CollectionChange.ItemRemoved:
List <object> removedItems = new List <object>();
removedItems.Add(null);
newArgs = new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Remove, removedItems, args.Index);
break;
case CollectionChange.ItemChanged:
newArgs = new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Replace, null, args.Index);
break;
case CollectionChange.Reset:
newArgs = new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset);
break;
default:
throw new InvalidOperationException();
}
return(newArgs);
}
private void SetsView_OnItemsChanged(object sender, IVectorChangedEventArgs e)
{
_allTextEditors = GetAllTextEditors();
}
private void DependencyObjectCollectionVectorChanged(IObservableVector <DependencyObject> sender, IVectorChangedEventArgs e)
{
var index = (int)e.Index;
switch (e.CollectionChange)
{
case CollectionChange.Reset:
foreach (var item in this)
{
VerifyType(item);
}
RaiseCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset));
_oldItems.Clear();
break;
case CollectionChange.ItemInserted:
VerifyType(this[index]);
RaiseCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Add, this[index], index));
_oldItems.Insert(index, (T)this[index]);
break;
case CollectionChange.ItemRemoved:
RaiseCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Remove, _oldItems[index], index));
_oldItems.RemoveAt(index);
break;
case CollectionChange.ItemChanged:
VerifyType(this[index]);
RaiseCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Replace, this[index], _oldItems[index]));
_oldItems[index] = (T)this[index];
break;
default:
throw new ArgumentOutOfRangeException();
}
}
private void BehaviorCollection_VectorChanged(IObservableVector<DependencyObject> sender, IVectorChangedEventArgs eventArgs)
{
if (eventArgs.CollectionChange == CollectionChange.Reset)
{
foreach (IBehavior behavior in this.oldCollection)
{
if (behavior.AssociatedObject != null)
{
behavior.Detach();
}
}
this.oldCollection.Clear();
foreach (DependencyObject newItem in this)
{
this.oldCollection.Add(this.VerifiedAttach(newItem));
}
#if DEBUG
this.VerifyOldCollectionIntegrity();
#endif
return;
}
int eventIndex = (int)eventArgs.Index;
DependencyObject changedItem = this[eventIndex];
switch (eventArgs.CollectionChange)
{
case CollectionChange.ItemInserted:
this.oldCollection.Insert(eventIndex, this.VerifiedAttach(changedItem));
break;
case CollectionChange.ItemChanged:
IBehavior oldItem = this.oldCollection[eventIndex];
if (oldItem.AssociatedObject != null)
{
oldItem.Detach();
}
this.oldCollection[eventIndex] = this.VerifiedAttach(changedItem);
break;
case CollectionChange.ItemRemoved:
oldItem = this.oldCollection[eventIndex];
if (oldItem.AssociatedObject != null)
{
oldItem.Detach();
}
this.oldCollection.RemoveAt(eventIndex);
break;
default:
Debug.Assert(false, "Unsupported collection operation attempted.");
break;
}
#if DEBUG
this.VerifyOldCollectionIntegrity();
#endif
}
private void OnColumnDefinitions_CollectionChanged(object sender, IVectorChangedEventArgs change)
{
this.InvalidateMeasure();
ObserveColumnDefinitions(_columnDefinitions.InnerList);
}
private void OnRowDefinitions_CollectionChanged(object sender, IVectorChangedEventArgs e)
{
this.InvalidateMeasure();
ObserveRowDefinitions(_rowDefinitions.InnerList);
}
internal void OnViewChanged(IObservableVector <object> sender, IVectorChangedEventArgs e)
{
//Debug.WriteLine("OnViewChanged------------");
// handle action
var rows = Rows;
var index = (int)e.Index;
var rowIndex = GetRowIndex(index);
var topRow = -1;
if (ItemsUpdatingScrollMode == ItemsUpdatingScrollMode.KeepItemsInView)
{
if (_cellPanel != null &&
addRemoveItemHanlder.CurrentTopRow == -1)
{
//_cellPanel.UpdateViewRange();
var viewRange = _cellPanel.ViewRange;
topRow = viewRange.Row;
addRemoveItemHanlder.CurrentTopRow = viewRange.Row;
}
topRow = addRemoveItemHanlder.CurrentTopRow;
}
//Debug.WriteLine("topRow : " + topRow);
switch (e.CollectionChange)
{
case CollectionChange.ItemInserted:
// create the new bound row
var r = CreateBoundRow(sender[index]);
if (rowIndex < 0)
{
rowIndex = rows.Count;
}
// add the new bound row to the rows collection
if (rowIndex > -1)
{
rows.Insert(rowIndex, r);
}
else
{
LoadRows();
}
if (ItemsUpdatingScrollMode == ItemsUpdatingScrollMode.KeepItemsInView)
{
addRemoveItemHanlder.AddTotalCount++;
if (index <= topRow)
{
if (Math.Abs(ScrollPosition.Y) >= HeaderMeasureHeight)
{
//Debug.WriteLine("Add : " + Rows.Count);
addRemoveItemHanlder.AddItemLessThanTopCount++;
addRemoveItemHanlder.CurrentTopRow++;
//ScrollPosition = new Point(ScrollPosition.X, ScrollPosition.Y - _cellPanel.Rows.DefaultSize);
}
}
}
break;
case CollectionChange.ItemRemoved:
if (rowIndex > -1)
{
rows.RemoveAt(rowIndex);
}
else
{
LoadRows();
}
if (ItemsUpdatingScrollMode == ItemsUpdatingScrollMode.KeepItemsInView)
{
addRemoveItemHanlder.RemoveTotalCount++;
if (index <= topRow)
{
if (Math.Abs(ScrollPosition.Y) >= HeaderMeasureHeight)
{
//Debug.WriteLine("Remove : " + Rows.Count);
addRemoveItemHanlder.RemoveItemLessThanTopCount++;
addRemoveItemHanlder.CurrentTopRow--;
//ScrollPosition = new Point(ScrollPosition.X, ScrollPosition.Y + _cellPanel.Rows.DefaultSize);
}
}
}
break;
case CollectionChange.ItemChanged:
rows[rowIndex].DataItem = sender[index];
_cellPanel.Invalidate(new CellRange(rowIndex, 0, rowIndex, Columns.Count - 1));
break;
default: // Reset, Move
if (_cellPanel != null)
{
_cellPanel.currentpointerOverRow = -1;
_cellPanel.currentPressedRow = -1;
_cellPanel.footerHeight = 0;
pointerOverPoint = null;
}
addRemoveItemHanlder.Reset();
LoadRows();
break;
}
// ensure scrollbars are in sync
InvalidateArrange();
}
private void Item_AudioTracksChanged(MediaPlaybackItem sender, IVectorChangedEventArgs args)
{
Log($"item.AudioTracksChanged: CollectionChange:{args.CollectionChange} Index:{args.Index} Total:{sender.AudioTracks.Count}");
switch (args.CollectionChange)
{
case CollectionChange.Reset:
foreach (AudioTrack track in sender.AudioTracks)
{
// Tracks are added once as a source discovers them in the source media.
// This occurs prior to the track media being opened.
// Register here so that we can receive the Track.OpenFailed event.
track.OpenFailed += AudioTrack_OpenFailed;
}
break;
case CollectionChange.ItemInserted:
// Additional tracks added after loading the main source should be registered here.
AudioTrack newTrack = sender.AudioTracks[(int)args.Index];
newTrack.OpenFailed += AudioTrack_OpenFailed;
break;
}
}
private void Commands_VectorChanged(IObservableVector <ICommandBarElement> sender, IVectorChangedEventArgs @event)
{
topCommands.Clear();
foreach (AppBarButton item in sender)
{
topCommands.Add(new TopAppBarContext {
Command = item.Command, Icon = (item.DataContext as Xamarin.Forms.ToolbarItem).Icon.File
});
}
itemsControl.ItemsSource = topCommands;
}
private void Item_TimedMetadataTracksChanged(MediaPlaybackItem sender, IVectorChangedEventArgs args)
{
Log($"item.TimedMetadataTracksChanged: CollectionChange:{args.CollectionChange} Index:{args.Index} Total:{sender.TimedMetadataTracks.Count}");
// This is the proper time to register for timed metadata Events the app cares to consume.
// See the Metadata scenario for more details.
}
void OnCommandsChanged(IObservableVector <ICommandBarElement> sender, IVectorChangedEventArgs args)
{
UpdateVisibility();
}
private void Commands_VectorChanged(IObservableVector<ICommandBarElement> sender, IVectorChangedEventArgs @event) => Update();
private void Items_VectorChanged(IObservableVector <object> sender, IVectorChangedEventArgs @event)
{
Debug.WriteLine($"{sender.GetHashCode()}");
Debug.WriteLine($"{ListView1.Items.GetHashCode()}");
}
void OnCommandsChanged(IObservableVector<ICommandBarElement> sender, IVectorChangedEventArgs args)
{
UpdateMore();
}
private static void OnVectorChanged(IObservableVector <DependencyObject> sender, IVectorChangedEventArgs e)
{
switch (e.CollectionChange)
{
case CollectionChange.ItemInserted:
case CollectionChange.ItemChanged:
VerifyType(sender[(int)e.Index]);
break;
case CollectionChange.Reset:
foreach (var item in sender)
{
VerifyType(item);
}
break;
}
}
