#region Imports
|
|
using DPumpHydr.WinFrmUI.RLT.Child.Crown;
|
using System;
|
using System.Collections.Generic;
|
using System.Collections.ObjectModel;
|
using System.Collections.Specialized;
|
using System.ComponentModel;
|
using System.Drawing;
|
using System.Linq;
|
using System.Windows.Forms;
|
using static DPumpHydr.WinFrmUI.RLT.Helper.CrownHelper;
|
|
#endregion
|
|
namespace DPumpHydr.WinFrmUI.RLT.Controls
|
{
|
#region CrownListView
|
|
public class CrownListView : CrownScrollView
|
{
|
#region Event Region
|
|
public event EventHandler SelectedIndicesChanged;
|
|
#endregion
|
|
#region Field Region
|
|
private int _itemHeight = 20;
|
private readonly int _iconSize = 16;
|
|
private ObservableCollection<CrownListItem> _items;
|
private int _anchoredItemStart = -1;
|
private int _anchoredItemEnd = -1;
|
|
#endregion
|
|
#region Property Region
|
|
[Browsable(false)]
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
|
public ObservableCollection<CrownListItem> Items
|
{
|
get => _items;
|
set
|
{
|
if (_items != null)
|
{
|
_items.CollectionChanged -= Items_CollectionChanged;
|
}
|
|
_items = value;
|
|
_items.CollectionChanged += Items_CollectionChanged;
|
|
UpdateListBox();
|
}
|
}
|
|
[Browsable(false)]
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
|
public List<int> SelectedIndices { get; }
|
|
[Category("Appearance")]
|
[Description("Determines the height of the individual list view items.")]
|
[DefaultValue(20)]
|
public int ItemHeight
|
{
|
get => _itemHeight;
|
set
|
{
|
_itemHeight = value;
|
UpdateListBox();
|
}
|
}
|
|
[Category("Behaviour")]
|
[Description("Determines whether multiple list view items can be selected at once.")]
|
[DefaultValue(false)]
|
public bool MultiSelect { get; set; }
|
|
[Category("Appearance")]
|
[Description("Determines whether icons are rendered with the list items.")]
|
[DefaultValue(false)]
|
public bool ShowIcons { get; set; }
|
|
#endregion
|
|
#region Constructor Region
|
|
public CrownListView()
|
{
|
Items = new ObservableCollection<CrownListItem>();
|
SelectedIndices = new List<int>();
|
}
|
|
#endregion
|
|
#region Event Handler Region
|
|
private void Items_CollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
|
{
|
if (e.NewItems != null)
|
{
|
using (Graphics g = CreateGraphics())
|
{
|
// Set the area size of all new items
|
foreach (CrownListItem item in e.NewItems)
|
{
|
item.TextChanged += Item_TextChanged;
|
UpdateItemSize(item, g);
|
}
|
}
|
|
// Find the starting index of the new item list and update anything past that
|
if (e.NewStartingIndex < (Items.Count - 1))
|
{
|
for (int i = e.NewStartingIndex; i <= Items.Count - 1; i++)
|
{
|
UpdateItemPosition(Items[i], i);
|
}
|
}
|
}
|
|
if (e.OldItems != null)
|
{
|
foreach (CrownListItem item in e.OldItems)
|
{
|
item.TextChanged -= Item_TextChanged;
|
}
|
|
// Find the starting index of the old item list and update anything past that
|
if (e.OldStartingIndex < (Items.Count - 1))
|
{
|
for (int i = e.OldStartingIndex; i <= Items.Count - 1; i++)
|
{
|
UpdateItemPosition(Items[i], i);
|
}
|
}
|
}
|
|
if (Items.Count == 0)
|
{
|
if (SelectedIndices.Count > 0)
|
{
|
SelectedIndices.Clear();
|
|
SelectedIndicesChanged?.Invoke(this, null);
|
}
|
}
|
|
UpdateContentSize();
|
}
|
|
private void Item_TextChanged(object sender, EventArgs e)
|
{
|
CrownListItem item = (CrownListItem)sender;
|
|
UpdateItemSize(item);
|
UpdateContentSize(item);
|
Invalidate();
|
}
|
|
protected override void OnMouseDown(MouseEventArgs e)
|
{
|
base.OnMouseDown(e);
|
|
if (Items.Count == 0)
|
{
|
return;
|
}
|
|
if (e.Button is not MouseButtons.Left and not MouseButtons.Right)
|
{
|
return;
|
}
|
|
Point pos = OffsetMousePosition;
|
|
List<int> range = ItemIndexesInView().ToList();
|
|
int top = range.Min();
|
int bottom = range.Max();
|
int width = Math.Max(ContentSize.Width, Viewport.Width);
|
|
for (int i = top; i <= bottom; i++)
|
{
|
Rectangle rect = new(0, i * ItemHeight, width, ItemHeight);
|
|
if (rect.Contains(pos))
|
{
|
if (MultiSelect && ModifierKeys == Keys.Shift)
|
{
|
SelectAnchoredRange(i);
|
}
|
else if (MultiSelect && ModifierKeys == Keys.Control)
|
{
|
ToggleItem(i);
|
}
|
else
|
{
|
SelectItem(i);
|
}
|
}
|
}
|
}
|
|
protected override void OnKeyDown(KeyEventArgs e)
|
{
|
base.OnKeyDown(e);
|
|
if (Items.Count == 0)
|
{
|
return;
|
}
|
|
if (e.KeyCode is not Keys.Down and not Keys.Up)
|
{
|
return;
|
}
|
|
if (MultiSelect && ModifierKeys == Keys.Shift)
|
{
|
if (e.KeyCode == Keys.Up)
|
{
|
if (_anchoredItemEnd - 1 >= 0)
|
{
|
SelectAnchoredRange(_anchoredItemEnd - 1);
|
EnsureVisible();
|
}
|
}
|
else if (e.KeyCode == Keys.Down)
|
{
|
if (_anchoredItemEnd + 1 <= Items.Count - 1)
|
{
|
SelectAnchoredRange(_anchoredItemEnd + 1);
|
}
|
}
|
}
|
else
|
{
|
if (e.KeyCode == Keys.Up)
|
{
|
if (_anchoredItemEnd - 1 >= 0)
|
{
|
SelectItem(_anchoredItemEnd - 1);
|
}
|
}
|
else if (e.KeyCode == Keys.Down)
|
{
|
if (_anchoredItemEnd + 1 <= Items.Count - 1)
|
{
|
SelectItem(_anchoredItemEnd + 1);
|
}
|
}
|
}
|
|
EnsureVisible();
|
}
|
|
#endregion
|
|
#region Method Region
|
|
public int GetItemIndex(CrownListItem item)
|
{
|
return Items.IndexOf(item);
|
}
|
|
public void SelectItem(int index)
|
{
|
if (index < 0 || index > Items.Count - 1)
|
{
|
throw new IndexOutOfRangeException($"Value '{index}' is outside of valid range.");
|
}
|
|
SelectedIndices.Clear();
|
SelectedIndices.Add(index);
|
|
SelectedIndicesChanged?.Invoke(this, null);
|
|
_anchoredItemStart = index;
|
_anchoredItemEnd = index;
|
|
Invalidate();
|
}
|
|
public void SelectItems(IEnumerable<int> indexes)
|
{
|
SelectedIndices.Clear();
|
|
List<int> list = indexes.ToList();
|
|
foreach (int index in list)
|
{
|
if (index < 0 || index > Items.Count - 1)
|
{
|
throw new IndexOutOfRangeException($"Value '{index}' is outside of valid range.");
|
}
|
|
SelectedIndices.Add(index);
|
}
|
|
SelectedIndicesChanged?.Invoke(this, null);
|
|
_anchoredItemStart = list[list.Count - 1];
|
_anchoredItemEnd = list[list.Count - 1];
|
|
Invalidate();
|
}
|
|
public void ToggleItem(int index)
|
{
|
if (SelectedIndices.Contains(index))
|
{
|
SelectedIndices.Remove(index);
|
|
// If we just removed both the anchor start AND end then reset them
|
if (_anchoredItemStart == index && _anchoredItemEnd == index)
|
{
|
if (SelectedIndices.Count > 0)
|
{
|
_anchoredItemStart = SelectedIndices[0];
|
_anchoredItemEnd = SelectedIndices[0];
|
}
|
else
|
{
|
_anchoredItemStart = -1;
|
_anchoredItemEnd = -1;
|
}
|
}
|
|
// If we just removed the anchor start then update it accordingly
|
if (_anchoredItemStart == index)
|
{
|
if (_anchoredItemEnd < index)
|
{
|
_anchoredItemStart = index - 1;
|
}
|
else if (_anchoredItemEnd > index)
|
{
|
_anchoredItemStart = index + 1;
|
}
|
else
|
{
|
_anchoredItemStart = _anchoredItemEnd;
|
}
|
}
|
|
// If we just removed the anchor end then update it accordingly
|
if (_anchoredItemEnd == index)
|
{
|
if (_anchoredItemStart < index)
|
{
|
_anchoredItemEnd = index - 1;
|
}
|
else if (_anchoredItemStart > index)
|
{
|
_anchoredItemEnd = index + 1;
|
}
|
else
|
{
|
_anchoredItemEnd = _anchoredItemStart;
|
}
|
}
|
}
|
else
|
{
|
SelectedIndices.Add(index);
|
_anchoredItemStart = index;
|
_anchoredItemEnd = index;
|
}
|
|
SelectedIndicesChanged?.Invoke(this, null);
|
|
Invalidate();
|
}
|
|
public void SelectItems(int startRange, int endRange)
|
{
|
SelectedIndices.Clear();
|
|
if (startRange == endRange)
|
{
|
SelectedIndices.Add(startRange);
|
}
|
|
if (startRange < endRange)
|
{
|
for (int i = startRange; i <= endRange; i++)
|
{
|
SelectedIndices.Add(i);
|
}
|
}
|
else if (startRange > endRange)
|
{
|
for (int i = startRange; i >= endRange; i--)
|
{
|
SelectedIndices.Add(i);
|
}
|
}
|
|
SelectedIndicesChanged?.Invoke(this, null);
|
|
Invalidate();
|
}
|
|
private void SelectAnchoredRange(int index)
|
{
|
_anchoredItemEnd = index;
|
SelectItems(_anchoredItemStart, index);
|
}
|
|
private void UpdateListBox()
|
{
|
using (Graphics g = CreateGraphics())
|
{
|
for (int i = 0; i <= Items.Count - 1; i++)
|
{
|
CrownListItem item = Items[i];
|
UpdateItemSize(item, g);
|
UpdateItemPosition(item, i);
|
}
|
}
|
|
UpdateContentSize();
|
}
|
|
private void UpdateItemSize(CrownListItem item)
|
{
|
using Graphics g = CreateGraphics();
|
UpdateItemSize(item, g);
|
}
|
|
private void UpdateItemSize(CrownListItem item, Graphics g)
|
{
|
SizeF size = g.MeasureString(item.Text, Font);
|
size.Width++;
|
|
if (ShowIcons)
|
{
|
size.Width += _iconSize + 8;
|
}
|
|
item.Area = new(item.Area.Left, item.Area.Top, (int)size.Width, item.Area.Height);
|
}
|
|
private void UpdateItemPosition(CrownListItem item, int index)
|
{
|
item.Area = new(2, index * ItemHeight, item.Area.Width, ItemHeight);
|
}
|
|
private void UpdateContentSize()
|
{
|
int highestWidth = 0;
|
|
foreach (CrownListItem item in Items)
|
{
|
if (item.Area.Right + 1 > highestWidth)
|
{
|
highestWidth = item.Area.Right + 1;
|
}
|
}
|
|
int width = highestWidth;
|
int height = Items.Count * ItemHeight;
|
|
if (ContentSize.Width != width || ContentSize.Height != height)
|
{
|
ContentSize = new(width, height);
|
Invalidate();
|
}
|
}
|
|
private void UpdateContentSize(CrownListItem item)
|
{
|
int itemWidth = item.Area.Right + 1;
|
|
if (itemWidth == ContentSize.Width)
|
{
|
UpdateContentSize();
|
return;
|
}
|
|
if (itemWidth > ContentSize.Width)
|
{
|
ContentSize = new(itemWidth, ContentSize.Height);
|
Invalidate();
|
}
|
}
|
|
public void EnsureVisible()
|
{
|
if (SelectedIndices.Count == 0)
|
{
|
return;
|
}
|
|
int itemTop = -1;
|
|
if (!MultiSelect)
|
{
|
itemTop = SelectedIndices[0] * ItemHeight;
|
}
|
else
|
{
|
itemTop = _anchoredItemEnd * ItemHeight;
|
}
|
|
int itemBottom = itemTop + ItemHeight;
|
|
if (itemTop < Viewport.Top)
|
{
|
VScrollTo(itemTop);
|
}
|
|
if (itemBottom > Viewport.Bottom)
|
{
|
VScrollTo(itemBottom - Viewport.Height);
|
}
|
}
|
|
private IEnumerable<int> ItemIndexesInView()
|
{
|
int top = (Viewport.Top / ItemHeight) - 1;
|
|
if (top < 0)
|
{
|
top = 0;
|
}
|
|
int bottom = ((Viewport.Top + Viewport.Height) / ItemHeight) + 1;
|
|
if (bottom > Items.Count)
|
{
|
bottom = Items.Count;
|
}
|
|
IEnumerable<int> result = Enumerable.Range(top, bottom - top);
|
return result;
|
}
|
|
private IEnumerable<CrownListItem> ItemsInView()
|
{
|
IEnumerable<int> indexes = ItemIndexesInView();
|
List<CrownListItem> result = indexes.Select(index => Items[index]).ToList();
|
return result;
|
}
|
|
#endregion
|
|
#region Paint Region
|
|
protected override void PaintContent(Graphics g)
|
{
|
List<int> range = ItemIndexesInView().ToList();
|
|
if (range.Count == 0)
|
{
|
return;
|
}
|
|
int top = range.Min();
|
int bottom = range.Max();
|
|
for (int i = top; i <= bottom; i++)
|
{
|
int width = Math.Max(ContentSize.Width, Viewport.Width);
|
Rectangle rect = new(0, i * ItemHeight, width, ItemHeight);
|
|
// Background
|
bool odd = i % 2 != 0;
|
Color bgColor = !odd ? ThemeProvider.Theme.Colors.HeaderBackground : ThemeProvider.Theme.Colors.GreyBackground;
|
|
if (SelectedIndices.Count > 0 && SelectedIndices.Contains(i))
|
{
|
bgColor = Focused ? ThemeProvider.Theme.Colors.BlueSelection : ThemeProvider.Theme.Colors.GreySelection;
|
}
|
|
using (SolidBrush b = new(bgColor))
|
{
|
g.FillRectangle(b, rect);
|
}
|
|
// DEBUG: Border
|
/*using (var p = new(ThemeProvider.Theme.Colors.DarkBorder))
|
{
|
g.DrawLine(p, new Point(rect.Left, rect.Bottom - 1), new Point(rect.Right, rect.Bottom - 1));
|
}*/
|
|
// Icon
|
if (ShowIcons && Items[i].Icon != null)
|
{
|
g.DrawImageUnscaled(Items[i].Icon, new Point(rect.Left + 5, rect.Top + (rect.Height / 2) - (_iconSize / 2)));
|
}
|
|
// Text
|
using (SolidBrush b = new(ThemeProvider.Theme.Colors.LightText)) //Items[i].TextColor
|
{
|
StringFormat stringFormat = new()
|
{
|
Alignment = StringAlignment.Near,
|
LineAlignment = StringAlignment.Center
|
};
|
|
Font modFont = new(Font, Items[i].FontStyle);
|
|
Rectangle modRect = new(rect.Left + 2, rect.Top, rect.Width, rect.Height);
|
|
if (ShowIcons)
|
{
|
modRect.X += _iconSize + 8;
|
}
|
|
g.DrawString(Items[i].Text, modFont, b, modRect, stringFormat);
|
}
|
}
|
}
|
|
#endregion
|
}
|
|
#endregion
|
}
|
