public Download AddDownload(string url, string installationPath)
{
var download = new Download(url, installationPath);
_downloads.Add(download);
return(download);
}
public void Adding_Selected_ItemContainers_Should_Update_Selection()
{
var items = new AvaloniaList <ItemContainer>(new[]
{
new ItemContainer(),
new ItemContainer(),
});
var target = new TestSelector
{
Items = items,
Template = Template(),
};
target.ApplyTemplate();
target.Presenter.ApplyTemplate();
items.Add(new ItemContainer {
IsSelected = true
});
items.Add(new ItemContainer {
IsSelected = true
});
Assert.Equal(2, target.SelectedIndex);
Assert.Equal(items[2], target.SelectedItem);
Assert.Equal(new[] { items[2], items[3] }, target.SelectedItems);
}
protected override void Initialize(AvaloniaList <TreeNode> nodes)
{
if (_application.ApplicationLifetime is Lifetimes.ISingleViewApplicationLifetime single)
{
nodes.Add(new LogicalTreeNode(single.MainView, Owner));
}
if (_application.ApplicationLifetime is Lifetimes.IClassicDesktopStyleApplicationLifetime classic)
{
for (int i = 0; i < classic.Windows.Count; i++)
{
var window = classic.Windows[i];
if (window is Views.MainWindow)
{
continue;
}
nodes.Add(new LogicalTreeNode(window, Owner));
}
_subscriptions = new System.Reactive.Disposables.CompositeDisposable()
{
Window.WindowOpenedEvent.AddClassHandler(typeof(Window), (s, e) =>
{
if (s is Views.MainWindow)
{
return;
}
nodes.Add(new LogicalTreeNode((IAvaloniaObject)s !, Owner));
}),
private void Build(MenuModel model, AvaloniaList <object> menu)
{
int count = model.Count;
for (int i = 0; i < count; i++)
{
bool isSubmenu = false;
MenuItem menuItem;
switch (model.GetTypeAt(i))
{
case CefMenuItemType.Separator:
menu.Add(new Separator());
continue;
case CefMenuItemType.Check:
menuItem = new MenuItem();
menuItem.Icon = new CheckBox()
{
IsChecked = model.IsCheckedAt(i), Margin = new Thickness(-2, 0, 0, 0), BorderThickness = new Thickness()
};
break;
case CefMenuItemType.Radio:
menuItem = new MenuItem();
menuItem.Icon = new RadioButton()
{
IsChecked = model.IsCheckedAt(i), Margin = new Thickness(-2, 0, 0, 0), BorderThickness = new Thickness()
};
break;
case CefMenuItemType.Command:
menuItem = new MenuItem();
break;
case CefMenuItemType.Submenu:
isSubmenu = true;
menuItem = new MenuItem();
if (model.IsEnabledAt(i))
{
Build(model.GetSubMenuAt(i), (AvaloniaList <object>)menuItem.Items);
}
break;
default:
continue;
}
if (!isSubmenu)
{
menuItem.Click += MenuItem_Click;
menuItem.Tag = model.GetCommandIdAt(i);
}
menuItem.Header = model.GetLabelAt(i).Replace('&', '_');
menuItem.IsEnabled = model.IsEnabledAt(i);
//menuItem.Foreground = model.GetColorAt(i, CefMenuColorType.Text, out CefColor color) ? new SolidColorBrush(color.ToColor()) : SystemColors.MenuTextBrush;
menu.Add(menuItem);
}
}
public void Adding_And_Selecting_Item_With_AutoScrollToSelectedItem_Should_NotHide_FirstItem()
{
using (UnitTestApplication.Start(TestServices.StyledWindow))
{
var items = new AvaloniaList <string>();
var wnd = new Window()
{
Width = 100, Height = 100, IsVisible = true
};
var target = new ListBox()
{
VerticalAlignment = Layout.VerticalAlignment.Top,
AutoScrollToSelectedItem = true,
Width = 50,
VirtualizationMode = ItemVirtualizationMode.Simple,
ItemTemplate = new FuncDataTemplate <object>((c, _) => new Border()
{
Height = 10
}),
Items = items,
};
wnd.Content = target;
var lm = wnd.LayoutManager;
lm.ExecuteInitialLayoutPass();
var panel = target.Presenter.Panel;
items.Add("Item 1");
target.Selection.Select(0);
lm.ExecuteLayoutPass();
Assert.Equal(1, panel.Children.Count);
items.Add("Item 2");
target.Selection.Select(1);
lm.ExecuteLayoutPass();
Assert.Equal(2, panel.Children.Count);
//make sure we have enough space to show all items
Assert.True(panel.Bounds.Height >= panel.Children.Sum(c => c.Bounds.Height));
//make sure we show items and they completelly visible, not only partially
Assert.True(panel.Children[0].Bounds.Top >= 0 && panel.Children[0].Bounds.Bottom <= panel.Bounds.Height, "first item is not completelly visible!");
Assert.True(panel.Children[1].Bounds.Top >= 0 && panel.Children[1].Bounds.Bottom <= panel.Bounds.Height, "second item is not completelly visible!");
}
}
private void Initialize()
{
var list = new AvaloniaList <object>();
var menuItemCopyCellContents = new TabMenuItem("Copy - _Cell Contents");
menuItemCopyCellContents.Click += MenuItemCopyCellContents_Click;
list.Add(menuItemCopyCellContents);
list.Add(new Separator());
var menuItemCopyColumn = new TabMenuItem("Copy - Co_lumn");
menuItemCopyColumn.Click += MenuItemCopyColumn_Click;
list.Add(menuItemCopyColumn);
var menuItemCopyRow = new TabMenuItem("Copy - _Row");
menuItemCopyRow.Click += MenuItemCopyRow_Click;
list.Add(menuItemCopyRow);
list.Add(new Separator());
var menuItemCopySelected = new TabMenuItem("Copy - _Selected");
menuItemCopySelected.Click += MenuItemCopySelected_Click;
list.Add(menuItemCopySelected);
var menuItemCopySelectedCsv = new TabMenuItem("Copy - Selected - CSV");
menuItemCopySelectedCsv.Click += MenuItemCopySelectedCsv_Click;
list.Add(menuItemCopySelectedCsv);
list.Add(new Separator());
var menuItemCopyDataGrid = new TabMenuItem("Copy - _DataGrid");
menuItemCopyDataGrid.Click += MenuItemCopyDataGrid_Click;
list.Add(menuItemCopyDataGrid);
var menuItemCopyDataGridCsv = new TabMenuItem("Copy - DataGrid - CS_V");
menuItemCopyDataGridCsv.Click += MenuItemCopyDataGridCsv_Click;
list.Add(menuItemCopyDataGridCsv);
Items = list;
DataGrid.CellPointerPressed += DataGrid_CellPointerPressed;
}
// Adds a context menu to the text block
/*private void AddHeaderContextMenu()
* {
* ContextMenu contextMenu = new();
*
* var keymap = AvaloniaLocator.Current.GetService<PlatformHotkeyConfiguration>();
*
* var list = new AvaloniaList<object>();
*
* MenuItem menuItemCopy = new MenuItem() { Header = "_Copy - Column" };
* menuItemCopy.Click += delegate
* {
* ClipBoardUtils.SetTextAsync(ColumnText);
* };
* list.Add(menuItemCopy);
*
* //list.Add(new Separator());
*
* contextMenu.Items = list;
*
* //this.ContextMenu = contextMenu;
* }*/
// Adds a context menu to the text block
private void AddTextBlockContextMenu(TextBlock textBlock)
{
var contextMenu = new ContextMenu();
var keymap = AvaloniaLocator.Current.GetService <PlatformHotkeyConfiguration>();
var list = new AvaloniaList <object>();
var menuItemCopy = new TabMenuItem("_Copy - Cell Contents");
menuItemCopy.Click += delegate
{
ClipBoardUtils.SetText(textBlock.Text);
};
list.Add(menuItemCopy);
list.Add(new Separator());
var menuItemCopyDataGrid = new TabMenuItem("Copy - _DataGrid");
menuItemCopyDataGrid.Click += delegate
{
string text = DataGrid.ToStringTable();
if (text != null)
{
ClipBoardUtils.SetText(text);
}
};
list.Add(menuItemCopyDataGrid);
var menuItemCopyDataGridCsv = new TabMenuItem("Copy - DataGrid - C_SV");
menuItemCopyDataGridCsv.Click += delegate
{
string text = DataGrid.ToCsv();
if (text != null)
{
ClipBoardUtils.SetText(text);
}
};
list.Add(menuItemCopyDataGridCsv);
//list.Add(new Separator());
contextMenu.Items = list;
textBlock.ContextMenu = contextMenu;
}
public void Handles_Selection_Made_In_CollectionChanged()
{
// Tests the following scenario:
//
// - Items changes from empty to having 1 item
// - ViewModel auto-selects item 0 in CollectionChanged
// - SelectionModel receives CollectionChanged
// - And so adjusts the selected item from 0 to 1, which is past the end of the items.
//
// There's not much we can do about this situation because the order in which
// CollectionChanged handlers are called can't be known (the problem also exists with
// WPF). The best we can do is not select an invalid index.
var target = CreateTarget(createData: false);
var data = new AvaloniaList <string>();
data.CollectionChanged += (s, e) =>
{
target.Select(0);
};
target.Source = data;
data.Add("foo");
Assert.Equal(0, target.SelectedIndex);
Assert.Equal(new[] { 0 }, target.SelectedIndexes);
Assert.Equal("foo", target.SelectedItem);
Assert.Equal(new[] { "foo" }, target.SelectedItems);
Assert.Equal(0, target.AnchorIndex);
}
public bool TryLoadAppContext(out AppContext appContext)
{
if (!File.Exists(_path))
{
appContext = null;
return(false);
}
FileStream stream = null;
try
{
stream = File.Open(_path, FileMode.OpenOrCreate, FileAccess.Read);
DataContractJsonSerializer jsonSerializer =
new DataContractJsonSerializer(typeof(SerializableAppContext));
SerializableAppContext loadedValue = (SerializableAppContext)jsonSerializer.ReadObject(stream);
var context = new AppContext
{
vehiclePlatesMap = new Dictionary <int, AvaloniaList <ITelemetryPlate> >()
};
if (loadedValue.PlateData != null)
{
foreach (var kvp in loadedValue.PlateData)
{
AvaloniaList <ITelemetryPlate> list = new AvaloniaList <ITelemetryPlate>();
foreach (var plateData in kvp.Value)
{
ITelemetryPlate plate = _telemetryPlateFactory.Create(
plateData.PlateName,
plateData.TelemetryCodeKey,
plateData.Units,
plateData.MinThreshold,
plateData.MaxThreshold,
plateData.DecimalPlaces);
list.Add(plate);
}
context.vehiclePlatesMap.Add(kvp.Key, list);
}
}
context.mainWindowWidth = loadedValue.MainWindowWidth;
context.mainWindowHeight = loadedValue.MainWindowHeight;
context.mainWindowPosition = new Avalonia.PixelPoint(loadedValue.MainWindowPosX, loadedValue.MainWindowPosY);
appContext = context;
}
catch (Exception err)
{
_log.Error("Error occured during loading the app context.", err);
appContext = null;
return(false);
}
finally
{
stream.Dispose();
}
return(true);
}
public bool AddViewToRegion(object view, string region)
{
var itemsControl = this.Find <ItemsControl>(region);
if (itemsControl == null)
{
return(false);
}
if (!(itemsControl.Items is IList items))
{
items = new AvaloniaList <object>();
itemsControl.Items = items;
}
items.Add(view);
if (view is Control control)
{
control.IsVisible = false;
}
return(true);
}
public void CreateDerivedList_Handles_Add()
{
var source = new AvaloniaList <int>(new[] { 0, 1, 2, 3 });
var target = source.CreateDerivedList(x => new Wrapper(x));
source.Add(4);
var result = target.Select(x => x.Value).ToList();
Assert.Equal(source, result);
}
private static void AppendItems(AvaloniaList <TreeNodeModel> list, TreeNodeModel node)
{
list.Add(node);
if (node.IsExpanded)
{
foreach (var ch in node.Children)
{
AppendItems(list, ch);
}
}
}
public void Setting_SelectedIndex_During_Initialize_Should_Select_Item_When_AlwaysSelected_Is_Used()
{
var listBox = new ListBox
{
SelectionMode = SelectionMode.Single | SelectionMode.AlwaysSelected
};
listBox.BeginInit();
listBox.SelectedIndex = 1;
var items = new AvaloniaList <string>();
listBox.Items = items;
items.Add("A");
items.Add("B");
items.Add("C");
listBox.EndInit();
Assert.Equal("B", listBox.SelectedItem);
}
public void RemoveListener_Stops_Listening_To_Events()
{
var source = new AvaloniaList <string>();
var listener = new Listener();
CollectionChangedEventManager.Instance.AddListener(source, listener);
CollectionChangedEventManager.Instance.RemoveListener(source, listener);
source.Add("foo");
Assert.Empty(listener.Received);
}
public void Setting_SelectedIndex_During_CollectionChanged_Results_In_Correct_Selection()
{
// Issue #4496
var data = new AvaloniaList <string>();
var target = CreateTarget();
var binding = new MockBinding(target, data);
target.Source = data;
data.Add("foo");
Assert.Equal(0, target.SelectedIndex);
}
public void AddListener_Listens_To_Events()
{
var source = new AvaloniaList <string>();
var listener = new Listener();
CollectionChangedEventManager.Instance.AddListener(source, listener);
Assert.Empty(listener.Received);
source.Add("foo");
Assert.Equal(1, listener.Received.Count);
}
public void First_Item_Should_Be_Selected_When_Added()
{
var items = new AvaloniaList <string>();
var target = new TestSelector
{
Items = items,
Template = Template(),
};
target.ApplyTemplate();
items.Add("foo");
Assert.Equal(0, target.SelectedIndex);
Assert.Equal("foo", target.SelectedItem);
}
public static void AddContextMenu(TextBox textBox)
{
var contextMenu = new ContextMenu()
{
Foreground = Theme.Foreground,
};
var keymap = AvaloniaLocator.Current.GetService <PlatformHotkeyConfiguration>();
var list = new AvaloniaList <object>();
if (!textBox.IsReadOnly)
{
var menuItemCut = new TabMenuItem("Cut");
menuItemCut.Click += delegate { SendTextBoxKey(textBox, keymap.Cut); };
list.Add(menuItemCut);
}
var menuItemCopy = new TabMenuItem("_Copy");
menuItemCopy.Click += delegate { SendTextBoxKey(textBox, keymap.Copy); };
list.Add(menuItemCopy);
if (!textBox.IsReadOnly)
{
var menuItemPaste = new TabMenuItem("Paste");
menuItemPaste.Click += delegate { SendTextBoxKey(textBox, keymap.Paste); };
list.Add(menuItemPaste);
}
//list.Add(new Separator());
contextMenu.Items = list;
textBox.ContextMenu = contextMenu;
}
public void First_Item_Should_Be_Selected_When_Added()
{
var items = new AvaloniaList<string>();
var target = new TestSelector
{
Items = items,
Template = Template(),
};
target.ApplyTemplate();
items.Add("foo");
Assert.Equal(0, target.SelectedIndex);
Assert.Equal("foo", target.SelectedItem);
}
private AvaloniaList <MenuItem> Populate(NativeMenu nativeMenu)
{
var result = new AvaloniaList <MenuItem>();
foreach (var menuItem in nativeMenu.Items)
{
if (menuItem is NativeMenuItemSeparator)
{
result.Add(new MenuItem {
Header = "-"
});
}
else if (menuItem is NativeMenuItem item)
{
var newItem = new MenuItem
{
protected virtual IEnumerable <string> ProcessString()
{
var l = new AvaloniaList <string>(); // create a list
var items = this.GetLogicalDescendants().OfType <NavigationViewItem>(); //gets the NavigationViewItem descendants
foreach (NavigationViewItem nav in items)
{
if (nav.Header != null)
{
l.Add(nav.Header.ToString()); //sets the strings
// Debug.WriteLine(nav.Header);
}
}
// Debug.WriteLine($"(in strings processing) there are {items.Count()} strings");
ItemsAsStrings = l;
return(ItemsAsStrings); // returns the list
}
public void Adding_Item_Should_Raise_CollectionChanged()
{
var target = new AvaloniaList <int>(new[] { 1, 2 });
var raised = false;
target.CollectionChanged += (s, e) =>
{
Assert.Equal(target, s);
Assert.Equal(NotifyCollectionChangedAction.Add, e.Action);
Assert.Equal(new[] { 3 }, e.NewItems.Cast <int>());
Assert.Equal(2, e.NewStartingIndex);
raised = true;
};
target.Add(3);
Assert.True(raised);
}
public void Adding_Items_Should_Fire_LogicalChildren_CollectionChanged()
{
var target = new ItemsControl();
var items = new AvaloniaList <string> {
"Foo"
};
var called = false;
target.Template = GetTemplate();
target.Items = items;
target.ApplyTemplate();
target.Presenter.ApplyTemplate();
((ILogical)target).LogicalChildren.CollectionChanged += (s, e) =>
called = e.Action == NotifyCollectionChangedAction.Add;
items.Add("Bar");
Assert.True(called);
}
public async Task <Download?> DownloadAsync(Server server)
{
if (server.DownloadUrl == null)
{
throw new ArgumentNullException(nameof(server.DownloadUrl));
}
var download = new Download(server.DownloadUrl, server.InstallationPath);
if (!download.CanStart())
{
return(null);
}
_downloads.Remove(_downloads.FirstOrDefault(d => d.ForkAndVersion == download.ForkAndVersion));
_downloads.Add(download);
await download.StartAsync(_http);
return(download);
}
public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
{
if (value == null)
{
return(AvaloniaProperty.UnsetValue);
}
var list = value as IEnumerable <IWizardPageVM>;
var result = new AvaloniaList <WizardPage>();
foreach (IWizardPageVM wizardPageVM in list)
{
IWizardPageVM vm = wizardPageVM as IWizardPageVM;
WizardPage wizardPage = new WizardPage();
wizardPage.DataContext = vm;
result.Add(wizardPage);
}
return(result);
}
protected override void OnTemplateApplied(TemplateAppliedEventArgs e)
{
base.OnTemplateApplied(e);
this.clickButton = this.EnforceInstance <Button>(e, "PART_Button");
this.menu = this.EnforceInstance <ContextMenu>(e, "PART_Menu");
this.InitializeVisualElementsContainer();
if (this.menu != null && this.Items != null /*&& this.ItemsSource == null*/)
{
var list = new AvaloniaList <object>();
foreach (var newItem in this.Items)
{
this.TryRemoveVisualFromOldTree(newItem);
list.Add(newItem);
}
menu.Items = list;
}
this.RaisePropertyChanged(MenuStyleProperty, null, (IStyle)MenuStyle);
//RaisePropertyChanged<IStyle>(MenuStyleProperty, null, MenuStyle);
//this.OnPropertyChanged<IStyle>(MenuStyleProperty, null, new Data.BindingValue<IStyle>( MenuStyle), Data.BindingPriority.Style);
}
public object ConvertFrom(IValueContext context, CultureInfo culture, object value)
{
var result = new AvaloniaList <T>();
var values = ((string)value).Split(',');
foreach (var s in values)
{
object v;
if (TypeUtilities.TryConvert(typeof(T), s, culture, out v))
{
result.Add((T)v);
}
else
{
throw new InvalidCastException($"Could not convert '{s}' to {typeof(T)}.");
}
}
return(result);
}
public void Adding_Selected_Item_Should_Update_Selection()
{
var items = new AvaloniaList <Item>(new[]
{
new Item(),
new Item(),
});
var target = new SelectingItemsControl
{
Items = items,
Template = Template(),
};
Prepare(target);
items.Add(new Item {
IsSelected = true
});
Assert.Equal(2, target.SelectedIndex);
Assert.Equal(items[2], target.SelectedItem);
}
// TextBlock control doesn't allow selecting text, so add a Copy command to the context menu
public static void AddContextMenu(TextBlock textBlock)
{
var contextMenu = new ContextMenu();
var keymap = AvaloniaLocator.Current.GetService <PlatformHotkeyConfiguration>();
var list = new AvaloniaList <object>();
var menuItemCopy = new TabMenuItem()
{
Header = "_Copy",
Foreground = Brushes.Black,
};
menuItemCopy.Click += delegate
{
ClipBoardUtils.SetText(textBlock.Text);
};
list.Add(menuItemCopy);
contextMenu.Items = list;
textBlock.ContextMenu = contextMenu;
}
private void Initialize()
{
var list = new AvaloniaList <object>();
var menuItemRefresh = new TabMenuItem("_Refresh");
menuItemRefresh.Click += MenuItemRefresh_Click;
list.Add(menuItemRefresh);
var menuItemReload = new TabMenuItem("_Reload");
menuItemReload.Click += MenuItemReload_Click;
list.Add(menuItemReload);
var menuItemReset = new TabMenuItem("Re_set");
menuItemReset.Click += MenuItemReset_Click;
list.Add(menuItemReset);
#if DEBUG
var menuItemDebug = new TabMenuItem("_Debug");
menuItemDebug.Click += MenuItemDebug_Click;
list.Add(menuItemDebug);
list.Add(new Separator());
_checkboxAutoLoad = new CheckBox()
{
IsChecked = TabInstance.Project.UserSettings.AutoLoad,
};
var menuItemAutoLoad = new TabMenuItem()
{
Header = "_AutoLoad",
Icon = _checkboxAutoLoad,
};
menuItemAutoLoad.Click += MenuItemAutoLoad_Click;
list.Add(menuItemAutoLoad);
#endif
Items = list;
}
public void Adding_Selected_Item_Should_Update_Selection()
{
var items = new AvaloniaList<Item>(new[]
{
new Item(),
new Item(),
});
var target = new SelectingItemsControl
{
Items = items,
Template = Template(),
};
target.ApplyTemplate();
target.Presenter.ApplyTemplate();
items.Add(new Item { IsSelected = true });
Assert.Equal(2, target.SelectedIndex);
Assert.Equal(items[2], target.SelectedItem);
}
public void Adding_Item_Should_Raise_CollectionChanged()
{
var target = new AvaloniaList<int>(new[] { 1, 2 });
var raised = false;
target.CollectionChanged += (s, e) =>
{
Assert.Equal(target, s);
Assert.Equal(NotifyCollectionChangedAction.Add, e.Action);
Assert.Equal(new[] { 3 }, e.NewItems.Cast<int>());
Assert.Equal(2, e.NewStartingIndex);
raised = true;
};
target.Add(3);
Assert.True(raised);
}
public void HotKeyManager_Should_Release_Reference_When_Control_In_Item_Template_Detached()
{
using (UnitTestApplication.Start(TestServices.StyledWindow))
{
var styler = new Mock <Styler>();
AvaloniaLocator.CurrentMutable
.Bind <IWindowingPlatform>().ToConstant(new WindowingPlatformMock())
.Bind <IStyler>().ToConstant(styler.Object);
var gesture1 = new KeyGesture(Key.A, KeyModifiers.Control);
var weakReferences = new List <WeakReference>();
var tl = new Window {
SizeToContent = SizeToContent.WidthAndHeight, IsVisible = true
};
var lm = tl.LayoutManager;
var keyGestures = new AvaloniaList <KeyGesture> {
gesture1
};
var listBox = new ListBox
{
Width = 100,
Height = 100,
VirtualizationMode = ItemVirtualizationMode.None,
// Create a button with binding to the KeyGesture in the template and add it to references list
ItemTemplate = new FuncDataTemplate(typeof(KeyGesture), (o, scope) =>
{
var keyGesture = o as KeyGesture;
var button = new Button
{
DataContext = keyGesture, [!Button.HotKeyProperty] = new Binding("")
};
weakReferences.Add(new WeakReference(button, true));
return(button);
})
};
// Add the listbox and render it
tl.Content = listBox;
lm.ExecuteInitialLayoutPass();
listBox.Items = keyGestures;
lm.ExecuteLayoutPass();
// Let the button detach when clearing the source items
keyGestures.Clear();
lm.ExecuteLayoutPass();
// Add it again to double check,and render
keyGestures.Add(gesture1);
lm.ExecuteLayoutPass();
keyGestures.Clear();
lm.ExecuteLayoutPass();
// The button should be collected since it's detached from the listbox
GC.Collect();
GC.WaitForPendingFinalizers();
GC.Collect();
GC.WaitForPendingFinalizers();
Assert.True(weakReferences.Count > 0);
foreach (var weakReference in weakReferences)
{
Assert.Null(weakReference.Target);
}
}
}
public void Adding_Items_Should_Fire_LogicalChildren_CollectionChanged()
{
var target = new ItemsControl();
var items = new AvaloniaList<string> { "Foo" };
var called = false;
target.Template = GetTemplate();
target.Items = items;
target.ApplyTemplate();
target.Presenter.ApplyTemplate();
((ILogical)target).LogicalChildren.CollectionChanged += (s, e) =>
called = e.Action == NotifyCollectionChangedAction.Add;
items.Add("Bar");
Assert.True(called);
}
