|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System.Collections;
namespace System.Windows.Forms;
public partial class ListView
{
// Overrides ListViewItemCollection methods and properties to automatically update
// the native listview.
//
internal class ListViewNativeItemCollection : ListViewItemCollection.IInnerList
{
private readonly ListView _owner;
public ListViewNativeItemCollection(ListView owner)
{
_owner = owner;
}
public int Count
{
get
{
_owner.ApplyUpdateCachedItems();
return _owner.VirtualMode ? _owner.VirtualListSize : _owner._itemCount;
}
}
public bool OwnerIsVirtualListView => _owner.VirtualMode;
public bool OwnerIsDesignMode => _owner.DesignMode;
public ListViewItem this[int displayIndex]
{
get => GetItemByIndexInternal(displayIndex, throwInVirtualMode: true)!;
set
{
_owner.ApplyUpdateCachedItems();
if (_owner.VirtualMode)
{
throw new InvalidOperationException(SR.ListViewCantModifyTheItemCollInAVirtualListView);
}
ArgumentOutOfRangeException.ThrowIfNegative(displayIndex);
ArgumentOutOfRangeException.ThrowIfGreaterThanOrEqual(displayIndex, _owner._itemCount);
if (_owner.ExpectingMouseUp)
{
_owner.ItemCollectionChangedInMouseDown = true;
}
RemoveAt(displayIndex);
Insert(displayIndex, value);
}
}
public ListViewItem? GetItemByIndex(int index) =>
GetItemByIndexInternal(index, throwInVirtualMode: false);
private ListViewItem? GetItemByIndexInternal(int index, [NotNullWhen(true)] bool throwInVirtualMode)
{
_owner.ApplyUpdateCachedItems();
if (_owner.VirtualMode)
{
// If we are showing virtual items, we need to get the item from the user.
RetrieveVirtualItemEventArgs rVI = new(index);
_owner.OnRetrieveVirtualItem(rVI);
if (rVI.Item is null)
{
return !throwInVirtualMode ? null : throw new InvalidOperationException(SR.ListViewVirtualItemRequired);
}
rVI.Item.SetItemIndex(_owner, index);
return rVI.Item;
}
else
{
ArgumentOutOfRangeException.ThrowIfNegative(index);
ArgumentOutOfRangeException.ThrowIfGreaterThanOrEqual(index, _owner._itemCount);
if (_owner.IsHandleCreated && !_owner.ListViewHandleDestroyed)
{
_owner._listItemsTable.TryGetValue(DisplayIndexToID(index), out ListViewItem? item);
return item!;
}
else
{
Debug.Assert(_owner._listViewItems is not null, "listItemsArray is null, but the handle isn't created");
return _owner._listViewItems[index];
}
}
}
public ListViewItem Add(ListViewItem value)
{
if (_owner.VirtualMode)
{
throw new InvalidOperationException(SR.ListViewCantAddItemsToAVirtualListView);
}
else
{
Debug.Assert(!_owner.FlipViewToLargeIconAndSmallIcon || Count == 0, "the FlipView... bit is turned off after adding 1 item.");
// PERF.
// Get the Checked bit before adding it to the back end.
// This saves a call into NativeListView to retrieve the real index.
bool valueChecked = value.Checked;
_owner.InsertItems(_owner._itemCount, [value], true);
if (_owner.IsHandleCreated && !_owner.CheckBoxes && valueChecked)
{
_owner.UpdateSavedCheckedItems(value, true /*addItem*/);
}
if (_owner.ExpectingMouseUp)
{
_owner.ItemCollectionChangedInMouseDown = true;
}
return value;
}
}
public void AddRange(params ListViewItem[] values)
{
ArgumentNullException.ThrowIfNull(values);
if (_owner.VirtualMode)
{
throw new InvalidOperationException(SR.ListViewCantAddItemsToAVirtualListView);
}
IComparer? comparer = _owner._listItemSorter;
_owner._listItemSorter = null;
Debug.Assert(!_owner.FlipViewToLargeIconAndSmallIcon || Count == 0, "the FlipView... bit is turned off after adding 1 item.");
bool[]? checkedValues = null;
if (_owner.IsHandleCreated && !_owner.CheckBoxes)
{
// PERF.
// Cache the Checked bit before adding the item to the list view.
// This saves a bunch of calls to native list view when we want to UpdateSavedCheckedItems.
checkedValues = new bool[values.Length];
for (int i = 0; i < values.Length; i++)
{
checkedValues[i] = values[i].Checked;
}
}
try
{
_owner.BeginUpdate();
_owner.InsertItems(_owner._itemCount, values, true);
if (_owner.IsHandleCreated && !_owner.CheckBoxes)
{
for (int i = 0; i < values.Length; i++)
{
if (checkedValues![i])
{
_owner.UpdateSavedCheckedItems(values[i], true /*addItem*/);
}
}
}
}
finally
{
_owner._listItemSorter = comparer;
_owner.EndUpdate();
}
if (_owner.ExpectingMouseUp)
{
_owner.ItemCollectionChangedInMouseDown = true;
}
if (comparer is not null ||
((_owner.Sorting != SortOrder.None) && !_owner.VirtualMode))
{
_owner.Sort();
}
}
private int DisplayIndexToID(int displayIndex)
{
Debug.Assert(!_owner.VirtualMode, "in virtual mode, this method does not make any sense");
if (_owner.IsHandleCreated && !_owner.ListViewHandleDestroyed)
{
// Obtain internal index of the item
LVITEMW lvItem = new()
{
mask = LIST_VIEW_ITEM_FLAGS.LVIF_PARAM,
iItem = displayIndex
};
PInvokeCore.SendMessage(_owner, PInvoke.LVM_GETITEMW, (WPARAM)0, ref lvItem);
return PARAM.ToInt(lvItem.lParam);
}
else
{
return this[displayIndex]._id;
}
}
public void Clear()
{
if (_owner._itemCount <= 0)
{
return;
}
_owner.ApplyUpdateCachedItems();
if (_owner.IsHandleCreated && !_owner.ListViewHandleDestroyed)
{
// Walk the items to see which ones are selected.
// We use the LVM_GETNEXTITEM message to see what the next selected item is
// so we can avoid checking selection for each one.
int count = _owner.Items.Count;
int nextSelected = (int)PInvokeCore.SendMessage(
_owner,
PInvoke.LVM_GETNEXTITEM,
(WPARAM)(-1),
(LPARAM)PInvoke.LVNI_SELECTED);
for (int i = 0; i < count; i++)
{
ListViewItem item = _owner.Items[i];
Debug.Assert(item is not null, $"Failed to get item at index {i}");
if (item is null)
{
continue;
}
// If it's the one we're looking for, ask for the next one.
if (i == nextSelected)
{
item.StateSelected = true;
nextSelected = (int)PInvokeCore.SendMessage(
_owner,
PInvoke.LVM_GETNEXTITEM,
(WPARAM)nextSelected, (LPARAM)PInvoke.LVNI_SELECTED);
}
else
{
// Otherwise it's false.
item.StateSelected = false;
}
item.UnHost(i, false);
}
Debug.Assert(_owner._listViewItems is null, "listItemsArray not null, even though handle created");
PInvokeCore.SendMessage(_owner, PInvoke.LVM_DELETEALLITEMS);
// There's a problem in the list view that if it's in small icon, it won't pick up the small icon
// sizes until it changes from large icon, so we flip it twice here...
if (_owner.View == View.SmallIcon)
{
if (Application.ComCtlSupportsVisualStyles)
{
_owner.FlipViewToLargeIconAndSmallIcon = true;
}
else
{
Debug.Assert(!_owner.FlipViewToLargeIconAndSmallIcon, "we only set this when comctl 6.0 is loaded");
_owner.View = View.LargeIcon;
_owner.View = View.SmallIcon;
}
}
}
else
{
int count = _owner.Items.Count;
for (int i = 0; i < count; i++)
{
ListViewItem item = _owner.Items[i];
item?.UnHost(i, true);
}
Debug.Assert(_owner._listViewItems is not null, "listItemsArray is null, but the handle isn't created");
_owner._listViewItems.Clear();
}
_owner._listItemsTable.Clear();
if (_owner.IsHandleCreated && !_owner.CheckBoxes)
{
_owner._savedCheckedItems = null;
}
_owner._itemCount = 0;
if (_owner.ExpectingMouseUp)
{
_owner.ItemCollectionChangedInMouseDown = true;
}
}
public bool Contains(ListViewItem item)
{
_owner.ApplyUpdateCachedItems();
if (_owner.IsHandleCreated && !_owner.ListViewHandleDestroyed)
{
return _owner._listItemsTable.TryGetValue(item._id, out ListViewItem? itemOut)
&& itemOut == item;
}
else
{
Debug.Assert(_owner._listViewItems is not null, "listItemsArray is null, but the handle isn't created");
return _owner._listViewItems.Contains(item);
}
}
public ListViewItem Insert(int index, ListViewItem item)
{
int count;
if (_owner.VirtualMode)
{
count = Count;
}
else
{
count = _owner._itemCount;
}
ArgumentOutOfRangeException.ThrowIfNegative(index);
ArgumentOutOfRangeException.ThrowIfGreaterThan(index, count);
if (_owner.VirtualMode)
{
throw new InvalidOperationException(SR.ListViewCantAddItemsToAVirtualListView);
}
Debug.Assert(!_owner.FlipViewToLargeIconAndSmallIcon || Count == 0, "the FlipView... bit is turned off after adding 1 item.");
if (index < count)
{
// if we're not inserting at the end, force the add.
_owner.ApplyUpdateCachedItems();
}
_owner.InsertItems(index, [item], true);
if (_owner.IsHandleCreated && !_owner.CheckBoxes && item.Checked)
{
_owner.UpdateSavedCheckedItems(item, true /*addItem*/);
}
if (_owner.ExpectingMouseUp)
{
_owner.ItemCollectionChangedInMouseDown = true;
}
return item;
}
public int IndexOf(ListViewItem item)
{
Debug.Assert(!_owner.VirtualMode, "in virtual mode, this function does not make any sense");
for (int i = 0; i < Count; i++)
{
if (item == this[i])
{
return i;
}
}
return -1;
}
public void Remove(ListViewItem item)
{
int index = _owner.VirtualMode ? Count - 1 : IndexOf(item);
Debug.Assert(!_owner.FlipViewToLargeIconAndSmallIcon || Count == 0, "the FlipView... bit is turned off after adding 1 item.");
if (_owner.VirtualMode)
{
throw new InvalidOperationException(SR.ListViewCantRemoveItemsFromAVirtualListView);
}
if (index != -1)
{
RemoveAt(index);
}
}
public void RemoveAt(int index)
{
if (_owner.VirtualMode)
{
throw new InvalidOperationException(SR.ListViewCantRemoveItemsFromAVirtualListView);
}
ArgumentOutOfRangeException.ThrowIfNegative(index);
ArgumentOutOfRangeException.ThrowIfGreaterThanOrEqual(index, _owner._itemCount);
Debug.Assert(!_owner.FlipViewToLargeIconAndSmallIcon || Count == 0, "the FlipView... bit is turned off after adding 1 item.");
if (_owner.IsHandleCreated && !_owner.CheckBoxes && this[index].Checked)
{
_owner.UpdateSavedCheckedItems(this[index], addItem: false);
}
_owner.ApplyUpdateCachedItems();
int itemID = DisplayIndexToID(index);
this[index].Focused = false;
this[index].UnHost(true);
if (_owner.IsHandleCreated)
{
Debug.Assert(_owner._listViewItems is null, "listItemsArray not null, even though handle created");
if (PInvokeCore.SendMessage(_owner, PInvoke.LVM_DELETEITEM, (WPARAM)index) == 0)
{
throw new ArgumentOutOfRangeException(nameof(index), index, string.Format(SR.InvalidArgument, nameof(index), index));
}
}
else
{
Debug.Assert(_owner._listViewItems is not null, "listItemsArray is null, but the handle isn't created");
_owner._listViewItems.RemoveAt(index);
}
_owner._itemCount--;
_owner._listItemsTable.Remove(itemID);
if (_owner.ExpectingMouseUp)
{
_owner.ItemCollectionChangedInMouseDown = true;
}
}
public void CopyTo(Array dest, int index)
{
if (_owner._itemCount > 0)
{
for (int displayIndex = 0; displayIndex < Count; ++displayIndex)
{
dest.SetValue(this[displayIndex], index++);
}
}
}
public IEnumerator GetEnumerator()
{
ListViewItem[] items = new ListViewItem[_owner._itemCount];
CopyTo(items, 0);
return items.GetEnumerator();
}
}
}
|