public void AttachBorder(LabelingBorders border)
{
if (border == null)
{
throw new ArgumentNullException("border", "'border' cannot be null");
}
List <int> prevIndices = new List <int>();
foreach (int prevIndex in this.SelectedIndices)
{
prevIndices.Add(prevIndex);
}
_border = border;
Items.Clear();
int index = 0;
foreach (var text in _border.GetLabelNames(true))
{
Items.Add(text);
if (prevIndices.Contains(index))
{
SelectedIndices.Add(index);
}
index++;
}
}
private void OnItemSelectTask(object sender, EventArgs e)
{
item_select_step_timer_.Restart();
while (item_select_step_timer_.ElapsedMilliseconds < ITEM_SELECT_STEP)
{
if (item_select_index_ >= VirtualListSize)
{
break;
}
SelectedIndices.Add(item_select_index_++);
}
ItemSelectBusyStatusChanging?.Invoke(this, EventArgs.Empty);
if (item_select_index_ >= VirtualListSize)
{
item_select_task_.Stop();
ItemSelectBusy = false;
ItemSelectBusyStatusChanged?.Invoke(this, EventArgs.Empty);
OnSelectedIndexChanged(EventArgs.Empty);
}
}
protected override void OnKeyDown(KeyEventArgs e)
{
if (e.KeyData == (Keys.Control | Keys.A))
{
/* === CTRL + A (全選択) === */
SelectAllItems();
#if false
item_select_busy_ = true;
for (var value = 0; value < items_.Count; value++)
{
SelectedIndices.Add(value);
}
item_select_busy_ = false;
OnSelectedIndexChanged(EventArgs.Empty);
#endif
}
else if ((!ReadOnly) && (e.KeyData == (Keys.Delete)))
{
/* === Delete (削除) === */
ItemRemoveAt((IEnumerable <int>)SelectedIndices);
}
base.OnKeyDown(e);
}
/// <summary>
/// Select the row that is displaying the given model object. All other rows are deselected.
/// </summary>
/// <param name="modelObject">Model object to select</param>
/// <param name="setFocus">Should the object be focused as well?</param>
public override void SelectObject(object modelObject, bool setFocus)
{
// Without a data source, we can't do this.
if (VirtualListDataSource == null)
{
return;
}
// Check that the object is in the list (plus not all data sources can locate objects)
int index = VirtualListDataSource.GetObjectIndex(modelObject);
if (index < 0 || index >= VirtualListSize)
{
return;
}
// If the given model is already selected, don't do anything else (prevents an flicker)
if (SelectedIndices.Count == 1 && SelectedIndices[0] == index)
{
return;
}
// Finally, select the row
SelectedIndices.Clear();
SelectedIndices.Add(index);
if (setFocus && SelectedItem != null)
{
SelectedItem.Focused = true;
}
}
public void SelectAllItem()
{
//// foreach (ListViewItem lvi in Items) { lvi.Selected = true; }
for (int i = 0; i < VirtualListSize; i++)
{
SelectedIndices.Add(i);
}
}
/* ----------------------------------------------------------------- */
///
/// Select
///
/// <summary>
/// 項目を選択します。
/// </summary>
///
/* ----------------------------------------------------------------- */
public void Select(int index)
{
if (index < 0 || index >= Count)
{
return;
}
SelectedIndices.Clear();
SelectedIndices.Add(index);
}
public void SelectItemByDefault()
{
if (Items.Count <= 0)
{
return;
}
SelectedIndices.Clear();
SelectedIndices.Add(0);
}
private void selectAllToolStripMenuItem_Click(object sender, EventArgs e)
{
SelectedIndices.Clear();
for (int x = 0; x < TotalCount; x++)
{
SelectedIndices.Add(x);
}
printBox.Refresh();
}
private void Display(int selectIndex)
{
Display();
if (selectIndex != -1)
{
SelectedIndices.Add(selectIndex % PageSize);
EnsureVisible(SelectedIndices[0]);
}
}
/// <summary>
/// Sets the item as selected
/// </summary>
/// <param name="itemIndex"></param>
/// <param name="checkedValue"></param>
public void SetItemSelected(int itemIndex, bool checkedValue)
{
if (checkedValue)
{
SelectedIndices.Add(Items[itemIndex]);
}
else
{
SelectedIndices.Remove(itemIndex);
}
}
// ------------------------------------------------------------------------
// restore given selection
// ------------------------------------------------------------------------
private void RestoreSelection(Dictionary <string, int> selection)
{
SelectedIndices.Clear();
for (int pos = 0; pos < _list.Count; ++pos)
{
if (selection.ContainsKey(_list[pos].fullPath))
{
SelectedIndices.Add(pos);
}
}
}
public void SelectVirtualItem(int index)
{
SelectedIndices.Clear();
if (index > -1)
{
SelectedIndices.Add(index);
EnsureVisible(index);
Items[index].Focused = true;
}
Focus();
}
/* ----------------------------------------------------------------- */
///
/// SelectMore
///
/// <summary>
/// 既に選択されている項目を保持したまま、項目を選択します。
/// </summary>
///
/* ----------------------------------------------------------------- */
public void SelectMore(int index)
{
if (index < 0 || index >= Count)
{
return;
}
if (SelectedIndices.Contains(index))
{
return;
}
SelectedIndices.Add(index);
}
/* ----------------------------------------------------------------- */
///
/// Select
///
/// <summary>
/// 項目を選択します。
/// </summary>
///
/* ----------------------------------------------------------------- */
public void Select(IEnumerable <int> indices)
{
SelectedIndices.Clear();
foreach (var index in indices)
{
if (index < 0 || index >= Count)
{
continue;
}
SelectedIndices.Add(index);
}
}
public virtual bool Select(int index)
{
if (index < 0 || index >= Items.Count)
{
return(false);
}
SelectedIndices.Clear();
SelectedIndices.Add(index);
Items[index]?.EnsureVisible();
return(true);
}
public bool SelectMatch(String words, UIExtension.SelectTask selectTask, bool caseSensitive, bool wholeWord, bool findReplace)
{
if (Items.Count == 0)
{
return(false);
}
if (SelectedIndices.Count == 0)
{
SelectedIndices.Add(0);
}
int selIndex = SelectedIndices[0];
int matchIndex = -1;
switch (selectTask)
{
case UIExtension.SelectTask.SelectFirstTask:
matchIndex = FindTask(words, 0, true, caseSensitive, wholeWord, findReplace);
break;
case UIExtension.SelectTask.SelectNextTask:
matchIndex = FindTask(words, (selIndex + 1), true, caseSensitive, wholeWord, findReplace);
break;
case UIExtension.SelectTask.SelectNextTaskInclCurrent:
matchIndex = FindTask(words, selIndex, true, caseSensitive, wholeWord, findReplace);
break;
case UIExtension.SelectTask.SelectPrevTask:
matchIndex = FindTask(words, (selIndex - 1), false, caseSensitive, wholeWord, findReplace);
break;
case UIExtension.SelectTask.SelectLastTask:
matchIndex = FindTask(words, (Items.Count - 1), false, caseSensitive, wholeWord, findReplace);
break;
}
if (matchIndex != -1)
{
SelectedIndices.Clear();
SelectedIndices.Add(matchIndex);
EnsureSelectionVisible();
return(true);
}
return(false);
}
/* ----------------------------------------------------------------- */
///
/// SelectMore
///
/// <summary>
/// 既に選択されている項目を保持したまま、項目を選択します。
/// </summary>
///
/* ----------------------------------------------------------------- */
public void SelectMore(IEnumerable <int> indices)
{
foreach (var index in indices)
{
if (index < 0 || index >= Count)
{
return;
}
if (SelectedIndices.Contains(index))
{
return;
}
SelectedIndices.Add(index);
}
}
public void AddCircleDiagramNode(CircleDiagramNode node)
{
var lvItem = new ListViewItem {
Text = node.Text.Trim().Replace("\r\n", " "), Name = node.Name
};
var targetGroup = Groups[node.StartCircleNumber.ToString()]
?? Groups[Consts.NoneGroup];
if (targetGroup != null)
{
lvItem.Group = targetGroup;
}
var newListItem = Items.Add(lvItem);
SelectedIndices.Clear();
SelectedIndices.Add(newListItem.Index);
}
protected override void OnVirtualItemsSelectionRangeChanged(ListViewVirtualItemsSelectionRangeChangedEventArgs e)
{
base.OnVirtualItemsSelectionRangeChanged(e);
if (e.IsSelected)
{
ItemSelectBusy = true;
SelectedIndices.Clear();
for (var index = e.StartIndex; index <= e.EndIndex; index++)
{
SelectedIndices.Add(index);
}
ItemSelectBusy = false;
OnSelectedIndexChanged(EventArgs.Empty);
}
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Fill the feature grid (i.e. list) from the DB.
/// </summary>
/// ------------------------------------------------------------------------------------
public void Load()
{
_ignoreCheckChanges = true;
BeginUpdate();
Items.Clear();
LoadFeatures();
CurrentMask = _emptyMask;
AdjustColumnWidth();
if (Items.Count > 0)
{
SelectedIndices.Add(0);
}
EndUpdate();
_ignoreCheckChanges = false;
}
public UIActionState TrySelectAllText(bool perform)
{
if (Items.Count == 0)
{
return(UIActionVisibility.Disabled);
}
if (perform)
{
SelectedIndices.Clear();
for (int i = 0; i < Items.Count; i++)
{
SelectedIndices.Add(i);
}
}
return(UIActionVisibility.Enabled);
}
private void deleteToolStripMenuItem_Click(object sender, EventArgs e)
{
if (SelectedIndices == null || SelectedIndices.Count <= 0)
{
return;
}
int s = SelectedIndices[0];
List <SearchListViewItem> items = new List <SearchListViewItem>();
foreach (int x in SelectedIndices)
{
items.Add(GetItemAtIndex(x));
}
foreach (SearchListViewItem item in items)
{
RemoveItem(item);
}
vertSBar.Maximum = a.Count - MaxItemsPerPage;
if (vertSBar.Maximum <= 0)
{
vertSBar.Maximum = 0;
isVertSBarVisible = false;
}
else if (vertSBar.Value >= vertSBar.Maximum)
{
vertSBar.Value = vertSBar.Maximum - 1;
}
parentControl.SetProgBarText("Results: " + a.Count.ToString("N0"));
SelectedIndices.Clear();
if (s >= TotalCount)
{
s = TotalCount - 1;
}
SelectedIndices.Add(s);
//vertSBar.Value = s;
}
internal void SelectItems(int highItem)
{
if (HighestItemSelected <= highItem)
{
for (int i = HighestItemSelected; i <= highItem; ++i)
{
SelectedIndices.Add(i);
}
}
else
{
for (int i = HighestItemSelected; i > highItem; --i)
{
SelectedIndices.Remove(i);
}
}
HighestItemSelected = highItem;
}
public void newItem_PropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e)
{
ListViewItemViewModel item = ((ListViewItemViewModel)sender);
if (item.Selected || item.Focused)
{
int index = Items.IndexOf(item);
if (index > -1)
{
SelectedIndices.Add(index);
}
}
if (item.Checked)
{
int index = Items.IndexOf(item);
if (index > -1)
{
CheckedIndices.Add(index);
}
}
}
/*
* public ObjectCollection Items
* {
* get{return _dataSource.dataArray;}
* set{_dataSource.dataArray = value;}
* }
*/
public void SetSelected(int index, bool value)
{
if (index < 0 || index >= Items.Count)
{
throw new ArgumentOutOfRangeException("Index of out range");
}
if (SelectionMode == SelectionMode.None)
{
throw new InvalidOperationException();
}
if (value)
{
SelectedIndices.Add(index);
tableView.SelectRows(new NSIndexSet((uint)index), true);
}
else
{
SelectedIndices.Remove(index);
tableView.DeselectRow(index);
}
}
// ********************************************************************************
/// <summary>
///
/// </summary>
/// <param name="bNext"></param>
/// <returns></returns>
/// <created>UPh,25.10.2015</created>
/// <changed>UPh,25.10.2015</changed>
// ********************************************************************************
internal void SelectNextItem(bool bNext)
{
if (VirtualListSize == 0)
{
return;
}
if (SelectedIndices.Count == 0)
{
SelectedIndices.Add(0);
return;
}
int sel = SelectedIndices[0];
if (bNext)
{
if (sel >= VirtualListSize - 1)
{
return;
}
sel++;
}
else
{
if (sel <= 0)
{
return;
}
sel--;
}
SelectedIndices.Clear();
SelectedIndices.Add(sel);
EnsureVisible(sel);
}
/// <summary>
/// Select the rows that is displaying any of the given model object. All other rows are deselected.
/// </summary>
/// <param name="modelObjects">A collection of model objects</param>
/// <remarks>This method has O(n) performance where n is the number of model objects passed.
/// Do not use this to select all the rows in the list -- use SelectAll() for that.</remarks>
public override void SelectObjects(IList <object> modelObjects)
{
// Without a data source, we can't do this.
if (VirtualListDataSource == null)
{
return;
}
SelectedIndices.Clear();
if (modelObjects == null)
{
return;
}
foreach (object modelObject in modelObjects)
{
int index = VirtualListDataSource.GetObjectIndex(modelObject);
if (index >= 0 && index < VirtualListSize)
{
SelectedIndices.Add(index);
}
}
}
/// <summary>
/// Adds a new element to the combo
/// </summary>
/// <param name="item">item to add</param>
/// <param name="index">position to adding</param>
public int AddItem(object item, int index = -1)
{
var newItem = CreateItem(item);
if (index == -1 || index == ListViewItemViewModels.Count)
{
ListViewItemViewModels.Add(newItem);
SortElements();
ListViewItemViewModels_CollectionChanged();
if (newItem.Selected)
{
SelectedIndices.Add(newItem.Index);
}
if (newItem.Checked)
{
CheckedIndices.Add(newItem.Index);
}
return(newItem.Index);
}
ListViewItemViewModels.Insert(index, newItem);
SortElements();
return(index);
}
public MeshList() : base()
{
//Activate double buffering
this.SetStyle(ControlStyles.OptimizedDoubleBuffer | ControlStyles.AllPaintingInWmPaint, true);
//Enable the OnNotifyMessage event so we get a chance to filter out
// Windows messages before they get to the form's WndProc
this.SetStyle(ControlStyles.EnableNotifyMessage, true);
this.DrawMode = DrawMode.OwnerDrawFixed;
this.DrawItem += Ditem;
HashSet <int> _selIndex = new HashSet <int>();
HashSet <int> _newSet = new HashSet <int>();
bool updating = false;
SelectedIndexChanged += (sender, args) =>
{
if (updating)
{
return;
}
var mpos = PointToClient(Cursor.Position);
var index = IndexFromPoint(mpos);
if (index != -1 &&
Items[index] is MeshListItem checkable &&
mpos.X < ItemHeight)
{
// undo selection
_newSet.Clear();
foreach (int i in SelectedIndices)
{
_newSet.Add(i);
}
if (!_newSet.SetEquals(_selIndex))
{
updating = true;
BeginUpdate();
SelectedIndices.Clear();
SelectedIndex = -1;
foreach (var v in _selIndex)
{
SelectedIndices.Add(v);
}
EndUpdate();
updating = false;
}
// toggle visibility
{
if (SelectedIndices.Contains(index))
{
bool state = !checkable.Visible;
foreach (var s in SelectedItems)
{
if (s is MeshListItem mesh)
{
mesh.Visible = state;
}
}
}
else
{
checkable.Visible = !checkable.Visible;
}
ItemVisiblilityChanged?.Invoke(this, new EventArgs());
Invalidate();
}
return;
}
_selIndex.Clear();
foreach (int v in SelectedIndices)
{
_selIndex.Add(v);
}
};
}
private void OnSelectedItems_CollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
{
if (e.Action == NotifyCollectionChangedAction.Add && ChangeSource != ChangeSourceEnum.FromSelectedIndices)
{
int index = Items.IndexOf(e.NewItems[0]);
if (index == -1)
{
if (SelectedItems.IndexOf(e.NewItems[0]) != -1)
{
ChangeSource = ChangeSourceEnum.FromSelectedIndices;
SelectedItems.Remove(e.NewItems[0]);
ChangeSource = ChangeSourceEnum.None;
}
return;
}
if (SelectedItems.Cast <object>().Where(x => x == e.NewItems[0]).Count() > 1)
{
ChangeSource = ChangeSourceEnum.FromSelectedIndices;
SelectedItems.Remove(e.NewItems[0]);
ChangeSource = ChangeSourceEnum.None;
return;
}
((MultiSelectItem)itemContainers[index]).IsSelected = true;
contentPresenter.Children.Add(GeneratePanelItem(e.NewItems[0]));
ChangeSource = ChangeSourceEnum.FromSelectedItems;
SelectedIndices.Add(index);
if (!(SelectedIndices is INotifyCollectionChanged))
{
OnSelectedIndices_CollectionChanged(this, new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Add, index));
}
RaiseEvent(new System.Windows.Controls.SelectionChangedEventArgs(SelectionChangedEvent, new object[0], e.NewItems));
}
else if (e.Action == NotifyCollectionChangedAction.Remove && ChangeSource != ChangeSourceEnum.FromSelectedIndices)
{
int index = Items.IndexOf(e.OldItems[0]);
if (index == -1)
{
return;
}
((MultiSelectItem)itemContainers[index]).IsSelected = false;
contentPresenter.Children.RemoveAt(e.OldStartingIndex);
ChangeSource = ChangeSourceEnum.FromSelectedItems;
int indexSelectedIndex = SelectedIndices.IndexOf(index);
SelectedIndices.Remove(index);
if (!(SelectedIndices is INotifyCollectionChanged))
{
OnSelectedIndices_CollectionChanged(this, new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Remove, index, indexSelectedIndex));
}
RaiseEvent(new System.Windows.Controls.SelectionChangedEventArgs(SelectionChangedEvent, e.OldItems, new object[0]));
}
else if (e.Action == NotifyCollectionChangedAction.Reset && ChangeSource != ChangeSourceEnum.FromSelectedIndices)
{
foreach (var item in itemContainers)
{
((MultiSelectItem)item).IsSelected = false;
}
contentPresenter.Children.Clear();
ChangeSource = ChangeSourceEnum.FromSelectedItems;
SelectedIndices.Clear();
if (!(SelectedIndices is INotifyCollectionChanged))
{
OnSelectedIndices_CollectionChanged(this, new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset));
}
RaiseEvent(new System.Windows.Controls.SelectionChangedEventArgs(SelectionChangedEvent, new object[0], new object[0]));
}
ChangeSource = ChangeSourceEnum.None;
}
