private void DeleteSectionsFromDataSource()
{
// store intermediary sections and indices to be deleted, than delete
using (var sectionIndicesToBeDeleted = new NSMutableIndexSet())
{
var sectionsToBeDeleted = new List <int>();
foreach (var indexElementPair in GalleryDataSource.ImageCollection.Select((pair, index) =>
new { index, pair }))
{
if (indexElementPair.pair.Value.Count != 0)
{
continue;
}
sectionsToBeDeleted.Add(indexElementPair.index);
sectionIndicesToBeDeleted.Add((nuint)indexElementPair.index);
}
var sortedSectionsToBeDeleted = sectionsToBeDeleted.OrderByDescending(x => x);
foreach (var section in sortedSectionsToBeDeleted)
{
GalleryDataSource.ImageCollection.Remove(GalleryDataSource.ImageCollection.Keys[section]);
}
GalleryCollectionView.DeleteSections(sectionIndicesToBeDeleted);
}
}
/// Items will be inserted according to their completion state, maintaining their initial ordering.
/// e.g. if items are [complete(0), incomplete(1), incomplete(2), completed(3)], they will be inserted
/// into to sections of the items array. [incomplete(1), incomplete(2)] will be inserted at index 0 of the
/// list. [complete(0), completed(3)] will be inserted at the index of the list.
public NSIndexSet InsertItems(IEnumerable <ListItem> items)
{
int initialCount = Count;
int incompleteItemsCount = 0;
int completedItemsCount = 0;
foreach (ListItem item in items)
{
if (item.IsComplete)
{
completedItemsCount++;
this.items.Add(item);
}
else
{
incompleteItemsCount++;
this.items.Insert(0, item);
}
}
NSMutableIndexSet insertedIndexes = new NSMutableIndexSet();
insertedIndexes.AddIndexesInRange(new NSRange(0, incompleteItemsCount));
insertedIndexes.AddIndexesInRange(new NSRange(incompleteItemsCount + initialCount, completedItemsCount));
return(insertedIndexes);
}
public void hideCell(string name)
{
var removePaths = new List<NSIndexPath> ();
var removeSections = new NSMutableIndexSet ();
for (int section = 0; section < numberOfSections(); section++) {
for (int row = 0; row < numberOfRowsInSection(section); row++) {
var indexPath = NSIndexPath.FromItemSection (row, section);
var cell = indexedCells [indexPath];
if (cell.name == name && cell.visible) {
cell.visible = false;
removePaths.Add (indexPath);
cellCount [section] = cellCount [section] - 1;
if (cellCount [section] == 0) {
removeSections.Add ((nuint)section);
}
}
}
}
recalcIndexedCells ();
if (removeSections.Count == 0) {
tableView.DeleteRows (removePaths.ToArray (), UITableViewRowAnimation.Top);
} else {
tableView.DeleteSections (removeSections, UITableViewRowAnimation.Top);
}
}
public void hideCell(string name)
{
var removePaths = new List <NSIndexPath> ();
var removeSections = new NSMutableIndexSet();
for (int section = 0; section < numberOfSections(); section++)
{
for (int row = 0; row < numberOfRowsInSection(section); row++)
{
var indexPath = NSIndexPath.FromItemSection(row, section);
var cell = indexedCells [indexPath];
if (cell.name == name && cell.visible)
{
cell.visible = false;
removePaths.Add(indexPath);
cellCount [section] = cellCount [section] - 1;
if (cellCount [section] == 0)
{
removeSections.Add((nuint)section);
}
}
}
}
recalcIndexedCells();
if (removeSections.Count == 0)
{
tableView.DeleteRows(removePaths.ToArray(), UITableViewRowAnimation.Top);
}
else
{
tableView.DeleteSections(removeSections, UITableViewRowAnimation.Top);
}
}
public void handleCollectionChanges(IEnumerable <CollectionChange> changes)
{
lock (animationLock)
{
if (changes.Any(c => c.Type == CollectionChangeType.Reload))
{
tableView.ReloadData();
return;
}
tableView.BeginUpdates();
foreach (var change in changes)
{
NSIndexPath indexPath = NSIndexPath.FromRowSection(change.Index.Row, change.Index.Section);
NSIndexPath[] indexPaths = { indexPath };
NSMutableIndexSet indexSet = (NSMutableIndexSet)NSIndexSet.FromIndex(change.Index.Section).MutableCopy();
switch (change.Type)
{
case CollectionChangeType.AddRow:
tableView.InsertRows(indexPaths, UITableViewRowAnimation.Automatic);
break;
case CollectionChangeType.RemoveRow:
tableView.DeleteRows(indexPaths, UITableViewRowAnimation.Automatic);
break;
case CollectionChangeType.UpdateRow:
tableView.ReloadRows(indexPaths, UITableViewRowAnimation.Automatic);
break;
case CollectionChangeType.MoveRow:
if (change.OldIndex.HasValue)
{
NSIndexPath oldIndexPath = NSIndexPath.FromRowSection(change.OldIndex.Value.Row, change.OldIndex.Value.Section);
tableView.MoveRow(oldIndexPath, indexPath);
dataSource.RefreshHeader(tableView, change.OldIndex.Value.Section);
}
break;
case CollectionChangeType.AddSection:
tableView.InsertSections(indexSet, UITableViewRowAnimation.Automatic);
break;
case CollectionChangeType.RemoveSection:
tableView.DeleteSections(indexSet, UITableViewRowAnimation.Automatic);
break;
}
dataSource.RefreshHeader(tableView, change.Index.Section);
}
tableView.EndUpdates();
}
}
private static void performChangesetUpdates <TSection, THeader, TModel, TKey>(
this UITableView tableView,
Diffing <TSection, THeader, TModel, TKey> .Changeset changes)
where TKey : IEquatable <TKey>
where TSection : IAnimatableSectionModel <THeader, TModel, TKey>, new()
where TModel : IDiffable <TKey>, IEquatable <TModel>
where THeader : IDiffable <TKey>
{
NSIndexSet newIndexSet(List <int> indexes)
{
var indexSet = new NSMutableIndexSet();
foreach (var i in indexes)
{
indexSet.Add((nuint)i);
}
return(indexSet as NSIndexSet);
}
tableView.DeleteSections(newIndexSet(changes.DeletedSections), UITableViewRowAnimation.Fade);
// Updated sections doesn't mean reload entire section, somebody needs to update the section view manually
// otherwise all cells will be reloaded for nothing.
tableView.InsertSections(newIndexSet(changes.InsertedSections), UITableViewRowAnimation.Fade);
foreach (var(from, to) in changes.MovedSections)
{
tableView.MoveSection(from, to);
}
tableView.DeleteRows(
changes.DeletedItems.Select(item => NSIndexPath.FromRowSection(item.itemIndex, item.sectionIndex)).ToArray(),
UITableViewRowAnimation.Top
);
tableView.InsertRows(
changes.InsertedItems.Select(item =>
NSIndexPath.FromItemSection(item.itemIndex, item.sectionIndex)).ToArray(),
UITableViewRowAnimation.Automatic
);
tableView.ReloadRows(
changes.UpdatedItems.Select(item => NSIndexPath.FromRowSection(item.itemIndex, item.sectionIndex))
.ToArray(),
// No animation so it doesn't fade showing the cells behind it
UITableViewRowAnimation.None
);
foreach (var(from, to) in changes.MovedItems)
{
tableView.MoveRow(
NSIndexPath.FromRowSection(from.itemIndex, from.sectionIndex),
NSIndexPath.FromRowSection(to.itemIndex, to.sectionIndex)
);
}
}
NSIndexSet[] SynchronizeAlbums(PHChange changeInstance)
{
// updated index set
var updatedIndexSets = new List <NSIndexSet>();
// notify changes of albums
foreach (var i in AlbumsFetchArray.Select((value, index) => KeyValuePair.Create(index, value)))
{
var section = i.Key;
var albumsFetchResult = i.Value;
var updatedIndexSet = new NSMutableIndexSet();
updatedIndexSets.Add(updatedIndexSet);
var albumsChangeDetail = changeInstance.GetFetchResultChangeDetails(albumsFetchResult);
if (albumsChangeDetail == null)
{
continue;
}
// update albumsFetchArray
AlbumsFetchArray[section] = albumsChangeDetail.FetchResultAfterChanges;
if (!albumsChangeDetail.HasIncrementalChanges)
{
NotifySubscribers((_) => _.ReloadedAlbumsInSection(this, section));
continue;
}
// sync removed albums
var removedIndexes = albumsChangeDetail.RemovedIndexes;
removedIndexes.EnumerateIndexes((nuint insertedIndex, ref bool stop) =>
{
RemoveAt(indexPath: NSIndexPath.FromRowSection((nint)insertedIndex, section));
});
// sync inserted albums
var insertedIndexes = albumsChangeDetail.InsertedIndexes;
insertedIndexes.EnumerateIndexes((nuint insertedIndex, ref bool stop) =>
{
var insertedAlbum = albumsChangeDetail.FetchResultAfterChanges[(nint)insertedIndex] as PHAssetCollection;
FetchAlbum(insertedAlbum);
FetchedAlbumsArray[section].Insert((int)insertedIndex, insertedAlbum);
updatedIndexSet.Add(insertedIndex);
});
// sync updated albums
var updatedIndexes = albumsChangeDetail.ChangedIndexes;
updatedIndexes.EnumerateIndexes((nuint updatedIndex, ref bool stop) =>
{
var updatedAlbum = albumsChangeDetail.FetchResultAfterChanges[(nint)updatedIndex] as PHAssetCollection;
FetchAlbum(updatedAlbum);
updatedIndexSet.Add(updatedIndex);
});
}
return(updatedIndexSets.ToArray());
}
public static NSIndexSet FromArray(nuint[] items)
{
if (items == null)
{
return(new NSIndexSet());
}
var indexSet = new NSMutableIndexSet();
foreach (var index in items)
{
indexSet.Add(index);
}
return(indexSet);
}
protected override void HandleCollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
{
if (TableView == null || !Enabled)
{
return;
}
switch (e.Action)
{
case NotifyCollectionChangedAction.Add:
{
var count = e.NewItems.Count;
var paths = new NSMutableIndexSet();
for (var i = 0; i < count; i++)
{
var itemIndex = e.NewStartingIndex + i;
paths.Add((nuint)(itemIndex));
BindGroup(DataSource[itemIndex]);
}
TableView.InsertSections(paths, AddAnimation);
}
break;
case NotifyCollectionChangedAction.Remove:
{
var count = e.OldItems.Count;
var paths = new NSMutableIndexSet();
for (var i = 0; i < count; i++)
{
var itemIndex = e.OldStartingIndex + i;
paths.Add((nuint)(itemIndex));
UnbindGroup(DataSource[itemIndex]);
}
TableView.DeleteSections(paths, DeleteAnimation);
}
break;
default:
TableView.ReloadData();
break;
}
}
private NSIndexSet GetSelectionIndexesFilter(NSTableView tableView, NSIndexSet proposedSelectionIndexes)
{
var selectionIndexes = new NSMutableIndexSet(proposedSelectionIndexes);
foreach (int index in proposedSelectionIndexes)
{
if (index < DataContext.AvailableSerialPorts.Count())
{
var port = DataContext.AvailableSerialPorts[(int)index];
if (DataContext.DisabledSerialPorts.Contains(port.PortName))
{
selectionIndexes.Remove((nuint)index);
}
}
}
return(selectionIndexes);
}
public void DelAction()
{
var trashedFile = Path.GetTempFileName();
var removeRows = new Dictionary <nuint, Entity> ();
foreach (var row in FileResults.SelectedRows.ToArray())
{
int converted;
if (false == Int32.TryParse(row.ToString(), out converted))
{
continue;
}
var path = ((EntityDataSource)FileResults.DataSource).Entities [converted].Path;
removeRows [row] = ((EntityDataSource)FileResults.DataSource).Entities [converted];
System.IO.File.AppendAllText(trashedFile, path + '\n');
}
AppDelegate.Debug(trashedFile);
var process = Process.Start("/usr/bin/osascript", NSBundle.MainBundle.ResourcePath + "/santas_helper.scpt " + trashedFile);
process.WaitForExit();
var rowsToVanish = new NSMutableIndexSet();
foreach (var key in removeRows.Keys)
{
// Maybe they hit cancel when authenticating
if (Directory.Exists(removeRows[key].Path) || File.Exists(removeRows[key].Path))
{
continue;
}
rowsToVanish.Add(key);
((EntityDataSource)FileResults.DataSource)._entities.Remove(removeRows[key]);
}
BeginInvokeOnMainThread(() => FileResults.RemoveRows(rowsToVanish, NSTableViewAnimation.Fade));
}
public static NSIndexSet FromArray(int[] items)
{
if (items == null)
{
return(new NSIndexSet());
}
var indexSet = new NSMutableIndexSet();
foreach (var index in items)
{
if (index < 0)
{
throw new ArgumentException("One of the items values is negative");
}
indexSet.Add((nuint)(uint)index);
}
return(indexSet);
}
public void SetCheckIndexSet(nint row, bool isSelected)
{
if (CheckIndexSet == null)
{
CheckIndexSet = new NSMutableIndexSet();
}
nuint index = (nuint)row;
if (isSelected)
{
CheckIndexSet.Add(index);
}
else
{
CheckIndexSet.Remove(index);
}
Console.WriteLine("{0}", CheckIndexSet.Count);
}
/// <inheritdoc/>
public override NSIndexSet GetSelectionIndexes(NSTableView tableView, NSIndexSet proposedSelectionIndexes)
{
var selectionIndexes = new NSMutableIndexSet(proposedSelectionIndexes);
if (proposedSelectionIndexes.Count > 0)
{
foreach (var index in proposedSelectionIndexes)
{
if ((int)index < DataContext.AvailableSerialPorts.Count())
{
var port = DataContext.AvailableSerialPorts[(int)index];
if (DataContext.DisabledSerialPorts.Contains(port.PortName))
{
selectionIndexes.Remove(index);
}
}
}
}
return(selectionIndexes);
}
public void RemoveViewsInSet(List <UIView> viewsToRemove)
{
var indicesToRemove = new NSMutableIndexSet();
foreach (UIView view in viewsToRemove)
{
var index = ContainerView.IndexForView(view);
if (index > -1)
{
indicesToRemove.Add((nuint)index);
}
}
if (indicesToRemove.Count == 0)
{
return;
}
ContainerView.RemoveArrangedViewsAtIndexes(indicesToRemove);
ScrollView.SetNeedsLayout();
}
public void InsertObjectsTest()
{
var v1 = (NSString)"1";
var v2 = (NSString)"2";
var v3 = (NSString)"3";
var v4 = (NSString)"4";
using (var arr = new NSMutableArray <NSString> (v1, v2)) {
var iset = new NSMutableIndexSet();
iset.Add(1);
iset.Add(2);
Assert.Throws <ArgumentNullException> (() => arr.InsertObjects((NSString[])null, iset), "InsertObjects ANE 1");
Assert.AreEqual(2, arr.Count, "Count 1");
Assert.Throws <ArgumentNullException> (() => arr.InsertObjects(new NSString [] { null, null }, iset), "InsertObjects ANE 2");
Assert.AreEqual(2, arr.Count, "Count 2");
Assert.Throws <ArgumentNullException> (() => arr.InsertObjects(new NSString [] { v1, null }, iset), "InsertObjects ANE 3");
Assert.AreEqual(2, arr.Count, "Count 3");
Assert.Throws <ArgumentNullException> (() => arr.InsertObjects(new NSString [] { v1 }, null), "InsertObjects ANE 4");
Assert.AreEqual(2, arr.Count, "Count 4");
arr.InsertObjects(new NSString [] { v3, v4 }, iset);
Assert.AreEqual(4, arr.Count, "InsertObjects 1");
Assert.AreSame(v1, arr [0], "a [0]");
Assert.AreSame(v3, arr [1], "a [1]");
Assert.AreSame(v4, arr [2], "a [2]");
Assert.AreSame(v2, arr [3], "a [3]");
iset.Clear();
iset.Add(9);
Assert.Throws <IndexOutOfRangeException> (() => arr.InsertObjects(new NSString [] { v1 }, iset), "InsertObjects ANE 5");
}
}
public AnnotationsTableDelegate(List <Annotation> itemList, object viewController)
{
AnnotationList = itemList;
ViewController = viewController;
var d = (from annotation in AnnotationList.ToList()
group annotation by annotation.GuideCardName into annotationgroup
select annotationgroup.Key);
if (GuidCardList == null)
{
GuidCardList = new List <string>();
}
else
{
GuidCardList.Clear();
}
GuidCardList.AddRange(d.ToList());
if (GroupIndexSet == null)
{
GroupIndexSet = new NSMutableIndexSet();
}
else
{
GroupIndexSet.Clear();
}
GroupIndexSet.Add(0);
foreach (var guideCard in GuidCardList)
{
var cardlist = AnnotationList.FindAll((item) => item.GuideCardName == guideCard);
GroupIndexSet.Add((nuint)cardlist.Count + 1);
}
Console.WriteLine("result count:{0}", d);
}
private void ItemsCollectionChanged(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e)
{
var itemsToAdd = Enumerable.Empty <FileNodeViewModel>();
var itemsToRemove = Enumerable.Empty <FileNodeViewModel>();
var indexSetToAdd = new NSMutableIndexSet();
var indexSetToRemove = new NSMutableIndexSet();
var children = NSArray.FromArray <FileNodeViewModel>(Children).ToList();
if ((sender != null) && (e != null))
{
switch (e.Action)
{
case System.Collections.Specialized.NotifyCollectionChangedAction.Add:
var newItems = new List <FileNodeViewModel>();
for (int i = 0; i < e.NewItems.Count; ++i)
{
var item = (FileNodeViewModel)e.NewItems[i];
var index = (e.NewStartingIndex < 0) ? (children.Count + i) : (e.NewStartingIndex + i);
indexSetToAdd.Add((uint)index);
newItems.Add(item);
}
itemsToAdd = newItems;
break;
case System.Collections.Specialized.NotifyCollectionChangedAction.Remove:
var oldItems = new List <FileNodeViewModel>();
for (int i = 0; i < e.OldItems.Count; ++i)
{
var item = (FileNodeViewModel)e.OldItems[i];
var index = e.OldStartingIndex < 0 ? children.IndexOf(item) : (e.OldStartingIndex + i);
indexSetToRemove.Add((uint)index);
oldItems.Add(item);
}
itemsToRemove = oldItems;
break;
case System.Collections.Specialized.NotifyCollectionChangedAction.Move:
oldItems = new List <FileNodeViewModel>();
for (int i = 0; i < e.OldItems.Count; ++i)
{
var item = (FileNodeViewModel)e.OldItems[i];
var index = e.OldStartingIndex + i; // children.IndexOf(item);
indexSetToRemove.Add((uint)index);
oldItems.Add(item);
}
itemsToRemove = oldItems;
newItems = new List <FileNodeViewModel>();
for (int i = 0; i < e.NewItems.Count; ++i)
{
var item = (FileNodeViewModel)e.NewItems[i];
var index = e.NewStartingIndex + i;
// TODO Is this actually possible? Is it really a bug?
////if (e.NewStartingIndex > e.OldStartingIndex)
////{
//// --index; // NOTE: Probably a bug here: if we delete multiple consecutive, gotta fix it up?
////}
indexSetToAdd.Add((uint)index);
newItems.Add(item);
}
itemsToAdd = newItems;
break;
default:
INTV.Shared.Utility.ErrorReporting.ReportNotImplementedError("Unhandled collection change: " + e.Action);
break;
}
}
else if ((sender == null) && (e == null) && (Items != null))
{
// Replaced model, so re-populate NSArray w/ the new one.
itemsToRemove = children.Except(Items);
foreach (var item in itemsToRemove)
{
for (uint idx = 0; idx < Children.Count; ++idx)
{
var element = Children.ValueAt(idx);
if (element == item.Handle)
{
indexSetToRemove.Add(idx);
}
}
}
itemsToAdd = Items.Except(children);
uint i = 0;
foreach (var item in itemsToAdd)
{
indexSetToAdd.Add(i);
++i;
}
}
if (itemsToRemove.Any())
{
WillChange(NSKeyValueChange.Removal, indexSetToRemove, (NSString)ItemsPropertyName);
Children.RemoveObjectsAtIndexes(indexSetToRemove);
ItemCount = (uint)Children.Count;
DidChange(NSKeyValueChange.Removal, indexSetToRemove, (NSString)ItemsPropertyName);
}
if (itemsToAdd.Any())
{
WillChange(NSKeyValueChange.Insertion, indexSetToAdd, (NSString)ItemsPropertyName);
Children.InsertObjects(itemsToAdd.ToArray(), indexSetToAdd);
ItemCount = (uint)Children.Count;
DidChange(NSKeyValueChange.Insertion, indexSetToAdd, (NSString)ItemsPropertyName);
}
if ((sender == null) && (e == null))
{
RaisePropertyChanged(StatusPropertyName); // addresses some lack-of-update problems (drop stuff here not going away)
}
}
public override void MouseDown(NSEvent theEvent)
{
if (theEvent.Type == NSEventType.LeftMouseDown)
{
uint index;
bool haveIndex = RectangleFromPoint(theEvent.LocationInWindow, out index);
NSMutableIndexSet indexSet = new NSMutableIndexSet(selectionIndexesBinding.GetData<NSIndexSet>());
if ((theEvent.ModifierFlags & NSEventModifierMask.CommandKeyMask) != 0)
{
if (!haveIndex)
// We did not select or unselect anything. Don't mess with the current selection
return;
if (indexSet.Contains(index))
indexSet.Remove(index);
else
indexSet.Add(index);
}
else
{
indexSet.Clear();
if (haveIndex)
indexSet.Add(index);
}
selectionIndexesBinding.SetData(indexSet);
// TODO: Start a drag operation
}
else
base.MouseDown(theEvent);
}
private uint[] SelectItems(Func<ImageViewItem,bool> isSelected)
{
var set = new NSMutableIndexSet();
imageView.SelectItemsAt(set, false);
for (int idx = 0; idx < imageViewItems.Count; ++idx)
{
var item = imageViewItems[idx];
if (isSelected(item))
set.Add((uint) idx);
}
imageView.SelectItemsAt(set, false);
return set.Count == 0 ? new uint[0] : set.ToArray();
}
public override void ViewDidLoad()
{
base.ViewDidLoad();
InitTableCell();
InitTable();
btn_copyCell.Title = "Copy clicked cell value";
btn_copyRow.Title = "Copy selected row";
btn_updateRow.Title = "Update row";
btn_updateColumn.Title = "Update column";
btn_addRow.Title = "Add row";
tf_row.PlaceholderString = "RowIndex";
tf_column.PlaceholderString = "C0";
tbl.Activated += (sender, e) => {
var ds = (TableDataSource)tbl.DataSource;
var tableRow = ds.Data[(int)tbl.ClickedRow];
var clickedColumn = tbl.TableColumns()[(int)tbl.ClickedColumn];
var cellValue = tableRow.GetValue(clickedColumn.Identifier).Text;
_cellValue = cellValue;
};
btn_copyCell.Activated += (sender, e) =>
_clipboard.CopyString(_cellValue);
btn_copyRow.Activated += (sender, e) => {
if (tbl.SelectedRow == -1)
{
return;
}
var ds = (TableDataSource)tbl.DataSource;
var tableRow = ds.Data[(int)tbl.SelectedRow];
var rowValue = string.Empty;
foreach (var column in tbl.TableColumns())
{
if (!string.IsNullOrEmpty(rowValue))
{
rowValue += "\t";
}
rowValue += tableRow.GetValue(column.Identifier).Text;
}
_clipboard.CopyString(rowValue);
};
btn_updateRow.Activated += (sender, e) => {
if (int.TryParse(tf_row.StringValue, out int rowIndex))
{
var ds = (TableDataSource)tbl.DataSource;
if (ds.Data.Count > rowIndex &&
rowIndex >= 0)
{
var tableRow = (SimpleTableRow)ds.Data[rowIndex];
var rand = new Random();
var min = 0;
var max = 900;
foreach (var column in tbl.TableColumns())
{
tableRow.DataCell[column.Identifier] =
nameof(SimpleTableRow) + " " + rand.Next(min, max);
}
var rowIndexSet = new NSIndexSet(rowIndex);
var columnIndexSet = new NSMutableIndexSet();
for (int i = 0; i < tbl.TableColumns().Length; i++)
{
columnIndexSet.Add(new NSIndexSet(i));
}
tbl.ReloadData(rowIndexSet, columnIndexSet);
}
}
};
btn_updateColumn.Activated += (sender, e) => {
var foundColumnIndex = tbl.FindColumn((NSString)tf_column.StringValue);
if (foundColumnIndex < 0)
{
return;
}
var column = tbl.TableColumns()[foundColumnIndex];
var ds = (TableDataSource)tbl.DataSource;
var rand = new Random();
var min = 0;
var max = 900;
foreach (var row in ds.Data)
{
var tableRow = (SimpleTableRow)row;
tableRow.DataCell[column.Identifier] =
nameof(SimpleTableRow) + " " + rand.Next(min, max);
}
var columnIndexSet = new NSIndexSet(foundColumnIndex);
var rowIndexSet = new NSMutableIndexSet();
for (int i = 0; i < ds.Data.Count; i++)
{
rowIndexSet.Add(new NSIndexSet(i));
}
tbl.ReloadData(rowIndexSet, columnIndexSet);
};
btn_addRow.Activated += (sender, e) => {
var tableRow = new SimpleTableRow();
foreach (var column in tbl.TableColumns())
{
tableRow.DataCell.Add(column.Identifier, column.Identifier);
}
var ds = (TableDataSource)tbl.DataSource;
ds.AddRow(tableRow);
};
//ordinary table
var ordinaryTbl = (BaseOrdinaryTable)tbl;
ordinaryTbl.SelectedRowIsChanged += (sender, e) =>
Console.WriteLine("Selected row is changed");
ordinaryTbl.WasKeyDown += (sender, e) => {
var theEvent = (NSEvent)sender;
Console.WriteLine("key code of pressed key: " + theEvent.KeyCode);
if (KeyDefinder.SpaceKey(theEvent))
{
Console.WriteLine("Space key was pressed");
}
};
}
/// Items will be inserted according to their completion state, maintaining their initial ordering.
/// e.g. if items are [complete(0), incomplete(1), incomplete(2), completed(3)], they will be inserted
/// into to sections of the items array. [incomplete(1), incomplete(2)] will be inserted at index 0 of the
/// list. [complete(0), completed(3)] will be inserted at the index of the list.
public NSIndexSet InsertItems(IEnumerable<ListItem> items)
{
int initialCount = Count;
int incompleteItemsCount = 0;
int completedItemsCount = 0;
foreach (ListItem item in items) {
if (item.IsComplete) {
completedItemsCount++;
this.items.Add (item);
} else {
incompleteItemsCount++;
this.items.Insert (0, item);
}
}
NSMutableIndexSet insertedIndexes = new NSMutableIndexSet ();
insertedIndexes.AddIndexesInRange (new NSRange (0, incompleteItemsCount));
insertedIndexes.AddIndexesInRange (new NSRange (incompleteItemsCount + initialCount, completedItemsCount));
return insertedIndexes;
}
