+2007-03-01 Gert Driesen <drieseng@users.sourceforge.net>
+
+ * ListView.cs: Add fireEvent argument to ReorderColumn since the
+ ColumnReordered event must not be signaled when modifying DisplayIndex
+ of a ColumnHeader. Added internal ReorderColumns method which takes
+ care of drawing, and updating the internal DisplayIndex of the
+ ColumnHeader. Added AddColumn method which is invoked from
+ ColumnHeaderCollection when adding or inserting columns, and which
+ ensures that reorder_columns_indices is kept in sync. Avoid redrawing
+ after adding each ColumnHeader in ColumnHeaderCollection.AddRange.
+ Recalculated dispay indices after removing a ColumnHeader.
+ * ColumnHeader.cs: Save DisplayIndex separately from ListView to
+ match MS. Allows last display index to be returned after ListView
+ is disposed. Update actual location of ColumnHeader when DisplayIndex
+ is modified.
+
2007-03-01 Everaldo Canuto <everaldo@simios.org>
* LinkLabel.cs: Improve CalcTrimRectangle.
private string name = String.Empty;
private object tag;
#endif
+ private int display_index = -1;
// internal variables
Rectangle column_rect = Rectangle.Empty;
get { return format; }
}
+ internal int InternalDisplayIndex {
+ get { return display_index; }
+ set { display_index = value; }
+ }
+
internal void CalcColumnHeader ()
- {
+ {
if (text_alignment == HorizontalAlignment.Center)
format.Alignment = StringAlignment.Center;
else if (text_alignment == HorizontalAlignment.Right)
#endregion // Private Internal Methods Properties
#region Public Instance Properties
+
#if NET_2_0
[Localizable (true)]
[RefreshProperties (RefreshProperties.Repaint)]
public int DisplayIndex {
get {
if (owner == null)
- return -1;
+ return display_index;
return owner.GetReorderedColumnIndex (this);
- }
+ }
set {
- if (owner == null)
+ if (owner == null) {
+ display_index = value;
return;
+ }
if (value < 0 || value >= owner.Columns.Count)
- throw new ArgumentOutOfRangeException ("value");
+ throw new ArgumentOutOfRangeException ("DisplayIndex");
- owner.ReorderColumn (this, value);
+ owner.ReorderColumn (this, value, false);
}
}
return -1;
}
#endif
-
+
internal ColumnHeader GetReorderedColumn (int index)
{
if (reordered_column_indices == null)
return Columns [reordered_column_indices [index]];
}
- internal void ReorderColumn (ColumnHeader col, int index)
+ internal void ReorderColumn (ColumnHeader col, int index, bool fireEvent)
{
#if NET_2_0
- ColumnReorderedEventHandler eh = (ColumnReorderedEventHandler) (Events [ColumnReorderedEvent]);
- if (eh != null){
- ColumnReorderedEventArgs args = new ColumnReorderedEventArgs (col.Index, index, col);
-
- eh (this, args);
- if (args.Cancel){
- header_control.Invalidate ();
- item_control.Invalidate ();
- return;
+ if (fireEvent) {
+ ColumnReorderedEventHandler eh = (ColumnReorderedEventHandler) (Events [ColumnReorderedEvent]);
+ if (eh != null){
+ ColumnReorderedEventArgs args = new ColumnReorderedEventArgs (col.Index, index, col);
+
+ eh (this, args);
+ if (args.Cancel) {
+ header_control.Invalidate ();
+ item_control.Invalidate ();
+ return;
+ }
}
}
#endif
+ int column_count = Columns.Count;
+
if (reordered_column_indices == null) {
- reordered_column_indices = new int [Columns.Count];
- for (int i = 0; i < Columns.Count; i++)
+ reordered_column_indices = new int [column_count];
+ for (int i = 0; i < column_count; i++)
reordered_column_indices [i] = i;
}
return;
int[] curr = reordered_column_indices;
- int[] result = new int [Columns.Count];
+ int [] result = new int [column_count];
int curr_idx = 0;
- for (int i = 0; i < Columns.Count; i++) {
- if (curr_idx < Columns.Count && curr [curr_idx] == col.Index)
+ for (int i = 0; i < column_count; i++) {
+ if (curr_idx < column_count && curr [curr_idx] == col.Index)
curr_idx++;
if (i == index)
result [i] = curr [curr_idx++];
}
- reordered_column_indices = result;
- LayoutDetails ();
- header_control.Invalidate ();
- item_control.Invalidate ();
+ ReorderColumns (result, true);
+ }
+
+ internal void ReorderColumns (int [] display_indices, bool redraw)
+ {
+ reordered_column_indices = display_indices;
+ for (int i = 0; i < Columns.Count; i++) {
+ ColumnHeader col = Columns [i];
+ col.InternalDisplayIndex = reordered_column_indices [i];
+ }
+ if (redraw && view == View.Details && IsHandleCreated) {
+ LayoutDetails ();
+ header_control.Invalidate ();
+ item_control.Invalidate ();
+ }
}
- Size LargeIconItemSize {
+ internal void AddColumn (ColumnHeader newCol, int index, bool redraw)
+ {
+ int column_count = Columns.Count;
+ newCol.SetListView (this);
+
+ int [] display_indices = new int [column_count];
+ for (int i = 0; i < column_count; i++) {
+ ColumnHeader col = Columns [i];
+ if (i == index) {
+ display_indices [i] = index;
+ } else {
+ int display_index = col.InternalDisplayIndex;
+ if (display_index < index) {
+ display_indices [i] = display_index;
+ } else {
+ display_indices [i] = (display_index + 1);
+ }
+ }
+ }
+
+ ReorderColumns (display_indices, redraw);
+ Invalidate ();
+ }
+
+ Size LargeIconItemSize
+ {
get {
int image_w = LargeImageList == null ? 12 : LargeImageList.ImageSize.Width;
int image_h = LargeImageList == null ? 2 : LargeImageList.ImageSize.Height;
if (drag_to_index > GetReorderedIndex (clicked_column))
drag_to_index--;
if (owner.GetReorderedColumn (drag_to_index) != clicked_column)
- owner.ReorderColumn (clicked_column, drag_to_index);
+ owner.ReorderColumn (clicked_column, drag_to_index, true);
drag_to_index = -1;
Invalidate ();
}
#region Public Methods
public virtual int Add (ColumnHeader value)
{
- int idx;
- value.SetListView (this.owner);
- idx = list.Add (value);
- if (owner.IsHandleCreated) {
- owner.Redraw (true);
- }
+ int idx = list.Add (value);
+ owner.AddColumn (value, idx, true);
return idx;
}
public virtual void AddRange (ColumnHeader [] values)
{
foreach (ColumnHeader colHeader in values) {
- colHeader.SetListView (this.owner);
- Add (colHeader);
+ int idx = list.Add (colHeader);
+ owner.AddColumn (colHeader, idx, false);
}
- owner.Redraw (true);
+ owner.Redraw (true);
}
public virtual void Clear ()
foreach (ColumnHeader col in list)
col.SetListView (null);
list.Clear ();
- owner.Redraw (true);
+ owner.ReorderColumns (new int [0], true);
}
public bool Contains (ColumnHeader value)
if (index < 0 || index > list.Count)
throw new ArgumentOutOfRangeException ("index");
- value.SetListView (owner);
list.Insert (index, value);
- owner.Redraw (true);
+ owner.AddColumn (value, index, true);
}
#if NET_2_0
public virtual void Remove (ColumnHeader column)
{
- // TODO: Update Column internal index ?
+ if (!Contains (column))
+ return;
+
list.Remove (column);
column.SetListView (null);
- owner.Redraw (true);
+
+ int rem_display_index = column.InternalDisplayIndex;
+ int [] display_indices = new int [list.Count];
+ for (int i = 0; i < display_indices.Length; i++) {
+ ColumnHeader col = (ColumnHeader) list [i];
+ int display_index = col.InternalDisplayIndex;
+ if (display_index < rem_display_index) {
+ display_indices [i] = display_index;
+ } else {
+ display_indices [i] = (display_index - 1);
+ }
+ }
+
+ column.InternalDisplayIndex = -1;
+ owner.ReorderColumns (display_indices, true);
}
#if NET_2_0
+2007-03-01 Gert Driesen <drieseng@users.sourceforge.net>
+
+ * ListViewCollectionsTest.cs: Added ColumnHeader.Index tests.
+ * ColumnHeaderTest.cs: Added more DisplayIndex tests.
+
2007-02-29 Carlos Alberto Cortez <calberto.cortez@gmail.com>
* ListViewTest.cs: Add test for VirtualMode and VirtualSize,
[TestFixture]
public class ColumnHeaderTest
{
+#if NET_2_0
+ [SetUp]
+ public void SetUp ()
+ {
+ columnReordered = 0;
+ }
+#endif
+
[Test]
public void DefaultValuesTest ()
{
#if NET_2_0
[Test]
- public void DisplayIndexTest ()
+ public void DisplayIndex_ListView_Created ()
{
- ColumnHeader col = new ColumnHeader ();
- col.DisplayIndex = -66;
- col.DisplayIndex = 66;
+ ColumnHeader colA = new ColumnHeader ();
+ ColumnHeader colB = new ColumnHeader ();
+ ColumnHeader colC = new ColumnHeader ();
+ ColumnHeader colD = new ColumnHeader ();
+ colA.DisplayIndex = 2;
+ colD.DisplayIndex = 0;
+ colB.DisplayIndex = 3;
+ colC.DisplayIndex = 1;
+ Form form = new Form ();
+ form.ShowInTaskbar = false;
ListView lv = new ListView ();
- lv.Columns.Add (col);
+ lv.ColumnReordered += new ColumnReorderedEventHandler (ColumnReordered);
+ lv.View = View.Details;
+ lv.Columns.Add (colA);
+ lv.Columns.Add (colB);
+ lv.Columns.Add (colC);
+ form.Controls.Add (lv);
+ form.Show ();
- try {
- col.DisplayIndex = -1;
- Assert.Fail ("1");
- } catch (ArgumentOutOfRangeException) {
- }
+ Assert.AreEqual (0, colA.DisplayIndex, "#A1");
+ Assert.AreEqual (1, colB.DisplayIndex, "#A2");
+ Assert.AreEqual (2, colC.DisplayIndex, "#A3");
+ Assert.AreEqual (0, colD.DisplayIndex, "#A4");
+ Assert.AreEqual (0, columnReordered, "#A5");
- try {
- col.DisplayIndex = lv.Columns.Count;
- Assert.Fail ("2");
- } catch (ArgumentOutOfRangeException) {
- }
+ colC.DisplayIndex = 0;
+ Assert.AreEqual (1, colA.DisplayIndex, "#B1");
+ Assert.AreEqual (2, colB.DisplayIndex, "#B2");
+ Assert.AreEqual (0, colC.DisplayIndex, "#B3");
+ Assert.AreEqual (0, colD.DisplayIndex, "#B4");
+ Assert.AreEqual (0, columnReordered, "#B5");
+
+ colC.DisplayIndex = 2;
+ Assert.AreEqual (0, colA.DisplayIndex, "#C1");
+ Assert.AreEqual (1, colB.DisplayIndex, "#C2");
+ Assert.AreEqual (2, colC.DisplayIndex, "#C3");
+ Assert.AreEqual (0, colD.DisplayIndex, "#C4");
+ Assert.AreEqual (0, columnReordered, "#C5");
+
+ colB.DisplayIndex = 2;
+ Assert.AreEqual (0, colA.DisplayIndex, "#D1");
+ Assert.AreEqual (2, colB.DisplayIndex, "#D2");
+ Assert.AreEqual (1, colC.DisplayIndex, "#D3");
+ Assert.AreEqual (0, colD.DisplayIndex, "#D4");
+ Assert.AreEqual (0, columnReordered, "#D5");
- Assert.AreEqual (0, col.DisplayIndex, "3");
+ colD.DisplayIndex = 1;
+ lv.Columns.Add (colD);
+
+ Assert.AreEqual (0, colA.DisplayIndex, "#E1");
+ Assert.AreEqual (2, colB.DisplayIndex, "#E2");
+ Assert.AreEqual (1, colC.DisplayIndex, "#E3");
+ Assert.AreEqual (3, colD.DisplayIndex, "#E4");
+ Assert.AreEqual (0, columnReordered, "#E5");
}
- [Test]
+ [Test]
public void DisplayIndex_ListView_Disposed ()
{
ListView lv = new ListView ();
lv.Columns.Add (colA);
ColumnHeader colB = new ColumnHeader ();
lv.Columns.Add (colB);
+ ColumnHeader colC = new ColumnHeader ();
+ lv.Columns.Add (colC);
+ Assert.AreEqual (0, colA.DisplayIndex, "#A1");
+ Assert.AreEqual (1, colB.DisplayIndex, "#A2");
+ Assert.AreEqual (2, colC.DisplayIndex, "#A3");
+ colA.DisplayIndex = 2;
+ lv.Columns.Remove (colB);
lv.Dispose ();
- colA.DisplayIndex = 1;
- Assert.AreEqual (1, colA.DisplayIndex, "#1");
- Assert.AreEqual (1, colB.DisplayIndex, "#2");
+ Assert.AreEqual (1, colA.DisplayIndex, "#B1");
+ Assert.AreEqual (-1, colB.DisplayIndex, "#B2");
+ Assert.AreEqual (0, colC.DisplayIndex, "#B3");
+ colA.DisplayIndex = 255;
+ Assert.AreEqual (255, colA.DisplayIndex, "#C1");
+ Assert.AreEqual (-1, colB.DisplayIndex, "#C2");
+ Assert.AreEqual (0, colC.DisplayIndex, "#C3");
+ }
+
+ [Test]
+ public void DisplayIndex_ListView_NotCreated ()
+ {
+ ColumnHeader colA = new ColumnHeader ();
+ colA.DisplayIndex = -66;
+ Assert.AreEqual (-66, colA.DisplayIndex, "#A1");
+ colA.DisplayIndex = 66;
+ Assert.AreEqual (66, colA.DisplayIndex, "#A2");
+
+ ColumnHeader colB = new ColumnHeader ();
+ colB.DisplayIndex = 0;
+ Assert.AreEqual (0, colB.DisplayIndex, "#A3");
+
+ ColumnHeader colC = new ColumnHeader ();
+ colC.DisplayIndex = 1;
+ Assert.AreEqual (1, colC.DisplayIndex, "#A4");
+
+ ListView lv = new ListView ();
+ lv.ColumnReordered += new ColumnReorderedEventHandler (ColumnReordered);
+ lv.View = View.Details;
+ lv.Columns.Add (colA);
+ lv.Columns.Add (colB);
+ lv.Columns.Add (colC);
+
+ try {
+ colA.DisplayIndex = -1;
+ Assert.Fail ("#B1");
+ } catch (ArgumentOutOfRangeException ex) {
+ Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#B2");
+ Assert.IsNull (ex.InnerException, "#B3");
+ Assert.IsNotNull (ex.Message, "#B4");
+ Assert.IsNotNull (ex.ParamName, "#B5");
+ Assert.AreEqual ("DisplayIndex", ex.ParamName, "#B6");
+ }
+
+ try {
+ colA.DisplayIndex = lv.Columns.Count;
+ Assert.Fail ("#C1");
+ } catch (ArgumentOutOfRangeException ex) {
+ Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#C2");
+ Assert.IsNull (ex.InnerException, "#C3");
+ Assert.IsNotNull (ex.Message, "#C4");
+ Assert.IsNotNull (ex.ParamName, "#C5");
+ Assert.AreEqual ("DisplayIndex", ex.ParamName, "#C6");
+ }
+
+ Assert.AreEqual (0, colA.DisplayIndex, "#D1");
+ Assert.AreEqual (1, colB.DisplayIndex, "#D2");
+ Assert.AreEqual (2, colC.DisplayIndex, "#D3");
+ Assert.AreEqual (0, columnReordered, "#D4");
}
[Test]
col.Width = 10;
Assert.AreEqual (10, col.Width);
}
+
+#if NET_2_0
+ public void ColumnReordered (object sender, ColumnReorderedEventArgs e)
+ {
+ columnReordered++;
+ }
+
+ private int columnReordered;
+#endif
}
}
Assert.AreSame (listview, colA.ListView, "#A4");
Assert.IsNull (colB.ListView, "#A5");
Assert.AreSame (listview, colC.ListView, "#A6");
+ Assert.AreEqual (0, colA.Index, "#A7");
+ Assert.AreEqual (-1, colB.Index, "#A8");
+ Assert.AreEqual (1, colC.Index, "#A9");
listview.Columns.Remove (colC);
Assert.AreEqual (1, listview.Columns.Count, "#B1");
Assert.AreSame (listview, colA.ListView, "#B3");
Assert.IsNull (colB.ListView, "#B4");
Assert.IsNull (colC.ListView, "#B5");
+ Assert.AreEqual (0, colA.Index, "#B6");
+ Assert.AreEqual (-1, colB.Index, "#B7");
+ Assert.AreEqual (-1, colC.Index, "#B8");
listview.Columns.Remove (colA);
Assert.AreEqual (0, listview.Columns.Count, "#C1");
Assert.IsNull (colA.ListView, "#C2");
Assert.IsNull (colB.ListView, "#C3");
Assert.IsNull (colC.ListView, "#C4");
+ Assert.AreEqual (-1, colA.Index, "#C5");
+ Assert.AreEqual (-1, colB.Index, "#C6");
+ Assert.AreEqual (-1, colC.Index, "#C7");
}
[Test]
projects / mono.git / commitdiff