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);
}
}
public FeedInfo(String uri, String title, String imageUri)
{
_uri = new Uri(uri);
_title = title;
if (imageUri != null)
{
_imageUri = new Uri(imageUri);
}
_feedItems = new ObservableVector<object>();
}
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 OnGeometriesChanged(IObservableVector <Geometry> sender, IVectorChangedEventArgs e)
{
Invalidate();
}
public GroupInfo(TKey key, IObservableVector <TElement> source)
: base(source)
{
Key = key;
}
/// <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 Items_VectorChanged(IObservableVector <object> sender, IVectorChangedEventArgs @event)
{
Debug.WriteLine($"{sender.GetHashCode()}");
Debug.WriteLine($"{ListView1.Items.GetHashCode()}");
}
void OnCommandsChanged(IObservableVector <ICommandBarElement> sender, IVectorChangedEventArgs args)
{
UpdateVisibility();
}
private void Items_VectorChanged(IObservableVector <object> sender, IVectorChangedEventArgs @event)
{
CheckForEmptyView();
}
void OnVectorChanged(
IObservableVector <object> sender,
IVectorChangedEventArgs e)
{
// We need to build up NotifyCollectionChangedEventArgs here to raise the event.
// There is opportunity to make this faster by caching the args if it does
// show up as a perf issue.
// Also note that we do not access the data - we just add nullptr. We just
// need the count.
global::System.Collections.Specialized.NotifyCollectionChangedAction action;
int oldStartingIndex = -1;
int newStartingIndex = -1;
var oldItems = new List <object>();
var newItems = new List <object>();
switch (e.CollectionChange)
{
case CollectionChange.ItemInserted:
action = global::System.Collections.Specialized.NotifyCollectionChangedAction.Add;
newStartingIndex = (int)e.Index;
newItems.Add(null);
OnItemsSourceChanged(new NotifyCollectionChangedEventArgs(action, newItems, newStartingIndex));
break;
case CollectionChange.ItemRemoved:
action = global::System.Collections.Specialized.NotifyCollectionChangedAction.Remove;
oldStartingIndex = (int)e.Index;
oldItems.Add(null);
OnItemsSourceChanged(new NotifyCollectionChangedEventArgs(action, oldItems, oldStartingIndex));
break;
case CollectionChange.ItemChanged:
action = global::System.Collections.Specialized.NotifyCollectionChangedAction.Replace;
oldStartingIndex = (int)e.Index;
newStartingIndex = oldStartingIndex;
newItems.Add(null);
oldItems.Add(null);
OnItemsSourceChanged(new NotifyCollectionChangedEventArgs(action, newItems, oldItems, newStartingIndex));
break;
case CollectionChange.Reset:
action = global::System.Collections.Specialized.NotifyCollectionChangedAction.Reset;
OnItemsSourceChanged(new NotifyCollectionChangedEventArgs(action));
break;
default:
throw new InvalidOperationException("Unsupported collection change");
}
// Uno specific: WinUI uses an internal overload of NotifyCollectionChangedEventArgs constructor with 5 args,
// we use a specific overload for each case instead
//OnItemsSourceChanged(
// new NotifyCollectionChangedEventArgs(
// action,
// newItems,
// oldItems,
// newStartingIndex,
// oldStartingIndex);
}
private void ItemsCollectionChanged(IObservableVector <object> sender, IVectorChangedEventArgs e)
{
selectItemsButton.IsEnabled = listView.Items.Count > 0;
}
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 OnItemsVectorChanged(IObservableVector <object> sender, IVectorChangedEventArgs @event)
{
SynchronizeItems();
}
private void SubscribeToItemChange(IObservableVector <ICommandBarElement> commands)
{
commands.VectorChanged += Commands_VectorChanged;
}
internal DependencyObjectCollection(IObservableVector <Windows.UI.Xaml.DependencyObject> underlying)
{
_underlyingCollection = underlying;
VectorChanged -= null;
}
private void OnFiguresVectorChanged(IObservableVector <PathFigure> sender, IVectorChangedEventArgs?args)
{
_svgElement.InvalidateMeasure();
}
//public SensorMapToScatterLine(ScatterLineSeries lineSeries, IObservableVector<StationSensor> sensors )
public SensorMapToScatterLine(LineSeries lineSeries, IObservableVector <StationSensor> sensors)
{
//m_ScatterLineSeries = lineSeries;
m_LineSeries = lineSeries;
m_Sensors = sensors;
}
public FeedInfo(String uri)
{
_uri = new Uri(uri);
_feedItems = new ObservableVector<object>();
}
private void ItemsChanged(IObservableVector<object> sender, IVectorChangedEventArgs @event)
{
ItemWidth = ThisView.ActualWidth/ThisView.Items.Count;
}
private void Commands_VectorChanged(IObservableVector <ICommandBarElement> sender, IVectorChangedEventArgs @event) => Update();
public bool LoadFeedsFromDB()
{
try
{
_feeds = new ObservableVector<object>(
new ObservableCollection<object>(
PersistenceHelper.GetFeedsFromDBAsync().AsTask().Result.OfType<object>()));
return _feeds.Count != 0;
}
catch
{
Debug.WriteLine("Failed to get feeds from DB due to an error.");
return false;
}
}
private void OnVectorChanged(IObservableVector <object> sender, IVectorChangedEventArgs e)
{
this.ProcessEvent(sender, e);
}
private void Commands_VectorChanged(IObservableVector<ICommandBarElement> sender, IVectorChangedEventArgs @event) => Update();
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 HandlePlaybackListChanges(IObservableVector<MediaPlaybackItem> vector)
{
if (vector.Count > 0)
{
CanSkipNext = true;
CanSkipPrevious = true;
}
else
{
CanSkipNext = false;
CanSkipPrevious = false;
}
}
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 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
}
public void LoadFeedsFromTheInternet()
{
_feeds = new ObservableVector<object>();
PersistenceHelper.GetUserFeedsAsync().AsTask().ContinueWith(t =>
{
foreach (var uri in t.Result)
{
try
{
var fi = new FeedInfo(uri);
fi.BeginLoad();
_feeds.Add(fi);
}
catch
{
Debug.WriteLine("Failed to load FeedInfo");
}
}
if (_feeds.Count > 0)
{
SelectedFeed = (FeedInfo)_feeds[0];
}
});
}
private void OnItemsChanged(IObservableVector <object> sender, IVectorChangedEventArgs @event)
{
UpdateSuggestionList();
}
public static CollectionViewGroupCollectionItem Create(object group, IObservableVector <object> items)
{
return(new CollectionViewGroupCollectionItem(group, items));
}
public CollectionViewGroupCollectionItem(object group, IObservableVector <object> items)
{
Group = group;
GroupItems = items;
}
private async void Items_VectorChanged(IObservableVector<MediaPlaybackItem> sender, IVectorChangedEventArgs args)
{
if (disposed) return;
await dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
if (disposed) return;
HandlePlaybackListChanges(sender);
});
}
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();
}
void OnCommandsChanged(IObservableVector<ICommandBarElement> sender, IVectorChangedEventArgs args)
{
UpdateMore();
}
void IWeakEventListener.ReceiveEvent(object sender, object args)
{
NotifyCurrentItemChangedEventArgs currentItemChangedArgs = args as NotifyCurrentItemChangedEventArgs;
if (currentItemChangedArgs != null)
{
this.HandleCurrentItemChanged(sender, currentItemChangedArgs);
}
else
{
IObservableVector <object> iov = sender as IObservableVector <object>;
if (iov != null)
{
IVectorChangedEventArgs vectorArgs = args as IVectorChangedEventArgs;
NotifyCollectionChangedAction action = NotifyCollectionChangedAction.Add;
int index = (int)vectorArgs.Index;
var collectionView = sender as ICollectionView;
var changedItems = new List <object>();
var oldItems = new List <object>();
NotifyCollectionChangedEventArgs args2 = new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset);
switch (vectorArgs.CollectionChange)
{
case CollectionChange.ItemChanged:
action = NotifyCollectionChangedAction.Replace;
changedItems.Add(collectionView[index]);
oldItems.Add(this.InternalList[index]);
args2 = new NotifyCollectionChangedEventArgs(action, changedItems, oldItems, index);
break;
case CollectionChange.ItemInserted:
action = NotifyCollectionChangedAction.Add;
changedItems.Add(collectionView[index]);
args2 = new NotifyCollectionChangedEventArgs(action, changedItems, index);
break;
case CollectionChange.ItemRemoved:
action = NotifyCollectionChangedAction.Remove;
oldItems.Add(this.InternalList[index]);
args2 = new NotifyCollectionChangedEventArgs(action, oldItems, index);
break;
case CollectionChange.Reset:
action = NotifyCollectionChangedAction.Reset;
args2 = new NotifyCollectionChangedEventArgs(action);
break;
}
this.HandleCollectionChanged(sender, args2);
}
else
{
INotifyPropertyChanged inpc = sender as INotifyPropertyChanged;
if (inpc != null)
{
string propertyName = ((PropertyChangedEventArgs)args).PropertyName;
NestedPropertyInfo info;
if (this.nestedObjectInfos != null && this.nestedObjectInfos.TryGetValue(sender, out info))
{
this.NestedPropertyChanged(sender, info.rootItems, propertyName, info.nestedPropertyPath);
PropertyChangedEventArgs arguments = new PropertyChangedEventArgs(info.nestedPropertyPath + propertyName);
foreach (var rootItem in info.rootItems)
{
this.HandlePropertyChanged(rootItem, arguments);
}
}
else
{
if (this.nestedObjectInfos != null && this.nestedObjectInfos.Count > 0)
{
this.NestedPropertyChanged(sender, new HashSet <object> {
sender
}, propertyName);
}
this.HandlePropertyChanged(sender, (PropertyChangedEventArgs)args);
}
}
}
}
}
