void ListView_ColumnReordered (object sender, ColumnReorderedEventArgs e)
{
_eventsText.AppendText (
"ColumnReordered => " + e.Header.Text + " | " + e.NewDisplayIndex.ToString ()
+ " | " + e.OldDisplayIndex.ToString () + " | " + e.Cancel
+ Environment.NewLine);
}
protected override void OnColumnReordered(ColumnReorderedEventArgs e)
{
int i = Math.Min(e.NewDisplayIndex, e.OldDisplayIndex);
index = index != -1 ? Math.Min(i + 1, index) : i + 1;
base.OnColumnReordered(e);
}
//protected override void InitLayout()
//{
// this.OwnerDraw = true;
// this.View = View.Details;
// this.DoubleBuffered = true;
// //this.DrawItem += new DrawListViewItemEventHandler(OnDrawItem);
// //this.DrawSubItem += new DrawListViewSubItemEventHandler(OnDrawSubItem);
// //this.DrawColumnHeader += new DrawListViewColumnHeaderEventHandler(OnDrawColumnHeader);
// // Add handlers for various events to compensate for an
// // extra DrawItem event that occurs the first time the mouse
// // moves over each row.
// //this.MouseMove += new MouseEventHandler(OnMouseMove);
// //this.ColumnWidthChanged += new ColumnWidthChangedEventHandler(OnColumnWidthChanged);
// //this.Invalidated += new InvalidateEventHandler(OnInvalidated);
// //this.MouseClick += new MouseEventHandler(OnMouseClick);
// //currenttStateImageList = defaultStateImageList;
// base.InitLayout();
//}
private void DoubleBufferedListView_ColumnReordered(object sender, ColumnReorderedEventArgs e)
{
if (e.NewDisplayIndex == 0 | e.OldDisplayIndex == 0)
{
e.Cancel = true;
}
}
/* D O C O L U M N R E O R D E R */
/*----------------------------------------------------------------------------
* %%Function: DoColumnReorder
* %%Qualified: AzLog.AzLogWindow.DoColumnReorder
* %%Contact: rlittle
*
* Handle a drag of the column header (reordering the columns)
* ----------------------------------------------------------------------------*/
private void DoColumnReorder(object sender, ColumnReorderedEventArgs e)
{
m_azlvs.MoveColumn(e.OldDisplayIndex, e.NewDisplayIndex);
// just notify it of the move, this doesn't change anything until we save because the listview already did the move for us.
DirtyView(true);
// really, this is just about remembering the tab order...
}
private void HandleColumnReordered(object sender, ColumnReorderedEventArgs e)
{
// Disallow reordering the checkbox column, either by moving it or moving something into its place
if (HasCheckBoxColumn && (e.OldDisplayIndex == 0 || e.NewDisplayIndex == 0))
{
e.Cancel = true;
return;
}
// At this point, we want to re-arrange the dependent parts of the display (the filter bar and the main data area)
// to reflect the re-ordering of the columns.
// However, the system has not actually re-ordered them. So we must simulate the order it is going to change
// them to.
// Now we want an array of integers showing how they are re-ordered.
// columnDisplayOrder[i] is the position that element i in the old (previous, not original) order will have in the new order.
// Note that we cannot depend on e.OldDisplayIndex. In Windows, this is the position in the
// most recent previous display order; in Mono, it is the position in the original sequence.
// However, both systems seem to pass us the columns with each header having its pre-change
// DisplayIndex intact.
var columnDisplayOrder = Enumerable.Range(0, Columns.Count).ToList();
var reorderedColumnHeader = columnDisplayOrder[e.Header.DisplayIndex];
columnDisplayOrder.Remove(reorderedColumnHeader);
columnDisplayOrder.Insert(e.NewDisplayIndex, reorderedColumnHeader);
// Let affected browse view update its columns of data
if (ColumnDragDropReordered != null)
{
ColumnDragDropReordered(this, new ColumnDragDropReorderedEventArgs(columnDisplayOrder));
}
//Adjust the browseViewer column ordering whenever columns are moved.
m_bv.OrderForColumnsDisplay = m_orderForColumnsDisplay;
}
private void fixesLV_ColumnReordered(object sender, ColumnReorderedEventArgs e)
{
if (e.NewDisplayIndex == 0 | e.OldDisplayIndex == 0)
{
e.Cancel = true;
}
}
void SortableListView_ColumnReordered(object sender, ColumnReorderedEventArgs e)
{
if (e.OldDisplayIndex == this._sortColumn)
{
this._sortColumn = e.NewDisplayIndex;
this.ListViewItemSorter = new ListViewItemComparer(this._sortColumn, this._sortOrder);
}
}
private void SortableListView_ColumnReordered(object sender, ColumnReorderedEventArgs e)
{
if (e.OldDisplayIndex == this.int_1)
{
this.int_1 = e.NewDisplayIndex;
base.ListViewItemSorter = new Class23(this.int_1, this.int_0);
}
}
private void lvApp_ColumnReordered(object sender, ColumnReorderedEventArgs e)
{
// if locked listview
if (ListViewUtil.IsLockedUpdate(lvApp))
{
return;
}
List <int> IndexOrderList = new List <int>();
if (e.OldDisplayIndex < e.NewDisplayIndex)
{
for (int i = 0; i < e.OldDisplayIndex; i++)
{
IndexOrderList.Add(ListViewUtil.GetIndexByDisplayIndex(lvApp, i));
}
for (int i = e.OldDisplayIndex + 1; i <= e.NewDisplayIndex; i++)
{
IndexOrderList.Add(ListViewUtil.GetIndexByDisplayIndex(lvApp, i));
}
IndexOrderList.Add(e.Header.Index);
for (int i = e.NewDisplayIndex + 1; i < lvApp.Columns.Count; i++)
{
IndexOrderList.Add(ListViewUtil.GetIndexByDisplayIndex(lvApp, i));
}
}
else if (e.OldDisplayIndex > e.NewDisplayIndex)
{
for (int i = 0; i < e.NewDisplayIndex; i++)
{
IndexOrderList.Add(ListViewUtil.GetIndexByDisplayIndex(lvApp, i));
}
IndexOrderList.Add(e.Header.Index);
for (int i = e.NewDisplayIndex; i < e.OldDisplayIndex; i++)
{
IndexOrderList.Add(ListViewUtil.GetIndexByDisplayIndex(lvApp, i));
}
for (int i = e.OldDisplayIndex + 1; i < lvApp.Columns.Count; i++)
{
IndexOrderList.Add(ListViewUtil.GetIndexByDisplayIndex(lvApp, i));
}
}
for (int i = 0; i < IndexOrderList.Count; i++)
{
iniSettings.Write(
lvApp.Columns[IndexOrderList[i]].Text.Replace(" ", "").Replace("∧", "").Replace("∨", ""),
i.ToString(),
"ColumnHeaderDisplayIndex");
}
}
public void Ctor_Int_Int_ColumnHeader(int oldDisplayIndex, int newDisplayIndex, ColumnHeader header)
{
var e = new ColumnReorderedEventArgs(oldDisplayIndex, newDisplayIndex, header);
Assert.Equal(oldDisplayIndex, e.OldDisplayIndex);
Assert.Equal(newDisplayIndex, e.NewDisplayIndex);
Assert.Equal(header, e.Header);
Assert.False(e.Cancel);
}
/// <summary>
///
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void listView_ColumnReordered(object sender, ColumnReorderedEventArgs e)
{
Properties.Settings.Default.columns.Clear();
foreach (ColumnHeader col in listView.Columns)
{
System.Diagnostics.Trace.WriteLine(col.DisplayIndex);
Properties.Settings.Default.columns.Add(String.Format("{0},{1}", col.Text, col.DisplayIndex));
}
Properties.Settings.Default.Save();
}
private void OnColumnReordered(object sender, ColumnReorderedEventArgs e)
{ //****************************************
ColumnBinding MyBinding = _Columns[e.OldDisplayIndex];
//****************************************
_Columns.RemoveAt(e.OldDisplayIndex);
_Columns.Insert(e.NewDisplayIndex, MyBinding);
foreach (BoundItem MyItem in _ListView.Items)
{
MyItem.RefreshContents();
}
}
public void TestColumnReorderedEventArgs()
{
int oldindex = 7;
int newindex = 26;
ColumnHeader ch = new ColumnHeader();
ch.Text = "TestHeader";
ColumnReorderedEventArgs e = new ColumnReorderedEventArgs(oldindex, newindex, ch);
Assert.AreEqual(oldindex, e.OldDisplayIndex, "A1");
Assert.AreEqual(newindex, e.NewDisplayIndex, "A2");
Assert.AreEqual(ch, e.Header, "A3");
Assert.AreEqual(false, e.Cancel, "A4");
}
//============================================================================*
// OnColumnReordered()
//============================================================================*
protected override void OnColumnReordered(ColumnReorderedEventArgs args)
{
base.OnColumnReordered(args);
if (!m_fInitialized)
{
return;
}
if (args.NewDisplayIndex == args.OldDisplayIndex)
{
return;
}
foreach (ColumnHeader Column in Columns)
{
if (args.NewDisplayIndex > args.OldDisplayIndex)
{
if (Column.DisplayIndex > args.OldDisplayIndex && Column.DisplayIndex > 0)
{
m_DataFiles.Preferences.SetColumnIndex(m_eListViewType, Column.Text, Column.DisplayIndex - 1);
}
if (Column.DisplayIndex == args.NewDisplayIndex)
{
break;
}
}
else
{
if (Column.DisplayIndex >= args.NewDisplayIndex && Column.DisplayIndex < args.OldDisplayIndex && Column.DisplayIndex < Columns.Count - 1)
{
m_DataFiles.Preferences.SetColumnIndex(m_eListViewType, Column.Text, Column.DisplayIndex + 1);
}
if (Column.DisplayIndex == args.OldDisplayIndex)
{
break;
}
}
}
m_DataFiles.Preferences.SetColumnIndex(m_eListViewType, args.Header.Text, args.NewDisplayIndex);
}
void _listView_ColumnReordered(object sender, ColumnReorderedEventArgs e)
{
if (!this._isCreatingColumns) // not sure if required
{
// This gets called before columns are reordered, so we must reproduce the reorder to find out the new one
List <ColumnHeader> list = new List <ColumnHeader>(this._listView.Columns.Cast <ColumnHeader>());
list.OrderBy(λ => λ.DisplayIndex);
ColumnHeader item = list[e.OldDisplayIndex];
list.RemoveAt(e.OldDisplayIndex);
list.Insert(e.NewDisplayIndex, item);
for (int n = 0; n < list.Count; n++)
{
Column col = (Column)list[n].Tag;
col.DisplayIndex = n;
}
this.SaveColumnUserPreferences();
}
}
private void lvDesign_ColumnReordered(object sender, ColumnReorderedEventArgs e)
{
var layout = XDocument.Parse(LayoutXml.OuterXml);
var cells = layout.Descendants().First().Descendants().First().Descendants();
var source = cells.ElementAt(e.OldDisplayIndex);
var target = cells.ElementAt(e.NewDisplayIndex);
if (e.OldDisplayIndex > e.NewDisplayIndex)
{
target.AddBeforeSelf(source);
}
else
{
target.AddAfterSelf(source);
}
source.Remove();
LayoutXml.LoadXml(layout.ToString());
IsLayoutXmlChanged = true;
}
private void _tgMsgs_ColumnReordered(object sender, ColumnReorderedEventArgs e)
{
Config.Instance.ForumColumnOrder = _tgMsgs.ColumnsOrder;
}
private void lvTask_ColumnReordered(object sender, ColumnReorderedEventArgs e)
{
}
protected override void OnColumnReordered(ColumnReorderedEventArgs e)
{
base.OnColumnReordered(e);
saveColumIndices(e.OldDisplayIndex, e.NewDisplayIndex);
}
private void FastObjectListView1_ColumnReordered(object sender, ColumnReorderedEventArgs e)
{
// we have to set it manually to have it available when we call save
e.Header.DisplayIndex = e.NewDisplayIndex;
SaveColumns();
}
public void ColumnReordered(object sender, ColumnReorderedEventArgs e)
{
columnReordered++;
}
private void historyListView_ColumnReordered(object sender, ColumnReorderedEventArgs e)
{
PersistColumnSettings();
}
/// <summary>
/// On column reorder we update the settings.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void listView_ColumnReordered(object sender, ColumnReorderedEventArgs e)
{
m_columnsChanged = true;
}
//Prevent column reorder
private void listViewAccountsDisplay_ColumnReordered(object sender, ColumnReorderedEventArgs e)
{
e.Cancel = true;
}
private void listView1_ColumnReordered(object sender, ColumnReorderedEventArgs e)
{
}
private void olstpeople_ColumnReordered(object sender, ColumnReorderedEventArgs e)
{
int x = 5;
}
private void LV_ColumnReordered(object sender, ColumnReorderedEventArgs e)
{
e.Cancel = !m_Presenter.ReorderColumns(e.OldDisplayIndex, e.NewDisplayIndex);
}
private void listView2_ColumnReordered(object sender, ColumnReorderedEventArgs e)
{
//MessageBox.Show("BBB");
}
private void GridColumnReordered(object sender, ColumnReorderedEventArgs e)
{
Config.Instance.FavoritesColumnOrder = _grid.ColumnsOrder;
}
private void TgMsgsColumnReordered(object sender, ColumnReorderedEventArgs e)
{
Config.Instance.SearchColumnOrder = _tgMsgs.ColumnsOrder;
}
void tcEventLoggerList1_ColumnReordered(object sender, ColumnReorderedEventArgs e)
{
mustSaveSettings = true;
}
