private HScrollBar horizontalScrollBar;
private VScrollBar verticalScrollBar;
private Control editingControl;
- private bool new_row_commited = true;
private bool is_autogenerating_columns = false;
- private bool in_binding_context_changed = false;
+ private bool is_binding = false;
+ private bool new_row_editing = false;
// These are used to implement selection behaviour with SHIFT pressed.
private int selected_row = -1;
columnHeadersVisible = true;
columns = CreateColumnsInstance();
columns.CollectionChanged += OnColumnCollectionChanged;
+ currentCellAddress = new Point (-1, -1);
dataMember = String.Empty;
defaultCellStyle = new DataGridViewCellStyle();
defaultCellStyle.BackColor = SystemColors.Window;
[DefaultValue (true)]
public bool AllowUserToAddRows {
- get { return allowUserToAddRows; }
+ get {
+ if (allowUserToAddRows && DataManager != null)
+ return DataManager.AllowNew;
+ return allowUserToAddRows;
+ }
set {
if (allowUserToAddRows != value) {
allowUserToAddRows = value;
[DefaultValue (true)]
public bool AllowUserToDeleteRows {
- get { return allowUserToDeleteRows; }
+ get {
+ if (allowUserToDeleteRows && DataManager != null)
+ return DataManager.AllowRemove;
+ return allowUserToDeleteRows;
+ }
set {
if (allowUserToDeleteRows != value) {
allowUserToDeleteRows = value;
get { return dataMember; }
set {
if (dataMember != value) {
- ClearBinding ();
-
dataMember = value;
+ ReBind ();
OnDataMemberChanged(EventArgs.Empty);
-
- DoBinding ();
}
}
}
if (!(value == null || value is IList || value is IListSource || value is IBindingList || value is IBindingListView))
throw new NotSupportedException ("Type cannot be bound.");
- ClearBinding ();
-
dataSource = value;
+ ReBind ();
OnDataSourceChanged (EventArgs.Empty);
-
- DoBinding ();
}
}
[DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
public int NewRowIndex {
get {
- if (!allowUserToAddRows || ColumnCount == 0) {
+ if (!AllowUserToAddRows || ColumnCount == 0) {
return -1;
}
return rows.Count - 1;
if (value < 0) {
throw new ArgumentException("RowCount must be >= 0.");
}
- if (value < 1 && allowUserToAddRows) {
+ if (value < 1 && AllowUserToAddRows) {
throw new ArgumentException("RowCount must be >= 1 if AllowUserToAddRows is true.");
}
if (dataSource != null) {
return false;
}
}
-
+
DataGridViewCell cell = currentCell;
Type editType = cell.EditType;
if (e.Cancel)
return false;
- // If the user begins an edit in the NewRow, add a new row
- if (CurrentCell.RowIndex == NewRowIndex) {
- new_row_commited = false;
- OnUserAddedRow (new DataGridViewRowEventArgs (Rows[NewRowIndex]));
- }
-
cell.SetIsInEditMode (true);
// The cell has an editing control we need to setup
public bool CancelEdit ()
{
- if (currentCell != null && currentCell.IsInEditMode) {
- // The user's typing caused a new row to be created, but
- // now they are canceling that typing, we have to remove
- // the new row we added.
- if (!new_row_commited) {
- DataGridViewRow delete_row = EditingRow;
- Rows.RemoveInternal (delete_row);
- editing_row = Rows[currentCell.RowIndex];
- OnUserDeletedRow (new DataGridViewRowEventArgs (delete_row));
- new_row_commited = true;
+ if (currentCell != null) {
+ if (currentCell.IsInEditMode) {
+ currentCell.SetIsInEditMode (false);
+ currentCell.DetachEditingControl ();
}
- currentCell.SetIsInEditMode (false);
- currentCell.DetachEditingControl ();
- OnCellEndEdit (new DataGridViewCellEventArgs (currentCell.ColumnIndex, currentCell.RowIndex));
+ if (currentCell.RowIndex == NewRowIndex) {
+ if (DataManager != null)
+ DataManager.CancelCurrentEdit ();
+
+ new_row_editing = false;
+ PrepareEditingRow (true, false);
+ OnUserDeletedRow (new DataGridViewRowEventArgs (EditingRow));
+ }
}
return true;
currentCell.Value = currentCell.ParseFormattedValue (currentCell.EditedFormattedValue,
currentCell.InheritedStyle, null, null);
} catch (Exception e) {
- Console.WriteLine (e);
DataGridViewDataErrorEventArgs args = new DataGridViewDataErrorEventArgs (e, currentCell.ColumnIndex, currentCell.RowIndex,
DataGridViewDataErrorContexts.Commit);
OnDataError (false, args);
if (args.ThrowException)
throw e;
+ return false;
}
return true;
}
for (int index = first_row_index; index < Rows.Count; index++) {
DataGridViewRow row = GetRowInternal (index);
- if (rowTop + row.Height < ClientSize.Height) {
+ if (rowTop + row.Height <= ClientSize.Height) {
result++;
rowTop += row.Height;
} else {
return true;
if (!CommitEdit (context)) {
+ if (DataManager != null)
+ DataManager.EndCurrentEdit ();
if (EditingControl != null)
EditingControl.Focus ();
return false;
}
currentCell.SetIsInEditMode (false);
- new_row_commited = true;
+ currentCell.DetachEditingControl ();
OnCellEndEdit (new DataGridViewCellEventArgs (currentCell.ColumnIndex, currentCell.RowIndex));
Focus ();
+ if (currentCell.RowIndex == NewRowIndex) {
+ new_row_editing = false;
+ PrepareEditingRow (false, false);
+ }
return true;
}
if (Rows.Count == 0)
return;
- IBindingList bindingList = DataSource as IBindingList;
if (dataGridViewColumn.IsDataBound) {
+ IBindingList bindingList = DataManager.List as IBindingList;
if (bindingList != null && bindingList.SupportsSorting) {
bindingList.ApplySort (DataManager.GetItemProperties()[dataGridViewColumn.DataPropertyName], direction);
dataGridViewColumn.HeaderCell.SortGlyphDirection = sortOrder;
protected override void OnBindingContextChanged (EventArgs e)
{
base.OnBindingContextChanged(e);
- if (!in_binding_context_changed) {
- in_binding_context_changed = true;
- ReBind();
- in_binding_context_changed = true;
- }
+ ReBind();
}
protected virtual void OnBorderStyleChanged (EventArgs e)
horizontalScrollBar.Minimum = 0;
horizontalScrollBar.Maximum = gridWidth;
horizontalScrollBar.SmallChange = Columns[first_col_index].Width;
- horizontalScrollBar.LargeChange = ClientSize.Width - rowHeadersWidth;
+ int largeChange = ClientSize.Width - rowHeadersWidth;
+ if (largeChange <= 0)
+ largeChange = ClientSize.Width;
+ horizontalScrollBar.LargeChange = largeChange;
}
if (verticalVisible) {
verticalScrollBar.Minimum = 0;
verticalScrollBar.Maximum = gridHeight;
verticalScrollBar.SmallChange = first_row_height + 1;
- verticalScrollBar.LargeChange = ClientSize.Height - columnHeadersHeight;
+ int largeChange = ClientSize.Height - columnHeadersHeight;
+ if (largeChange <= 0)
+ largeChange = ClientSize.Height;
+ verticalScrollBar.LargeChange = largeChange;
}
}
if (selected_columns != null)
selected_columns.InternalClear ();
- if (Rows.Count > 0 && Columns.Count > 0 && currentCell != null &&
- currentCell.RowIndex >= e.RowIndex)
- MoveCurrentCell (0, Math.Min (e.RowIndex, Rows.Count - 2), true, false, false, true);
+ if (Rows.Count == 0) {
+ MoveCurrentCell (-1, -1, true, false, false, true);
+ } else if (Columns.Count == 0) {
+ MoveCurrentCell (-1, -1, true, false, false, true);
+ } else {
+ int nextRowIndex = e.RowIndex;
+ if (nextRowIndex >= Rows.Count)
+ nextRowIndex = Rows.Count - 1;
+ MoveCurrentCell (currentCell != null ? currentCell.ColumnIndex : 0, nextRowIndex,
+ true, false, false, true);
+ }
+
Invalidate ();
OnRowsRemoved (e);
}
protected virtual void OnUserAddedRow (DataGridViewRowEventArgs e)
{
- editing_row = null;
+ // Switch the current editing row with a real
+ int newRowIndex = NewRowIndex;
+ int currentColumnIndex = currentCell != null ? currentCell.ColumnIndex : 0;
+ new_row_editing = true;
PrepareEditingRow (false, false);
+ if (DataManager != null)
+ DataManager.AddNew (); // will raise OnListPositionChanged
+ else
+ MoveCurrentCell (currentColumnIndex, NewRowIndex, true, false, false, true);
- e = new DataGridViewRowEventArgs (editing_row);
-
+ e = new DataGridViewRowEventArgs (Rows[NewRowIndex]);
DataGridViewRowEventHandler eh = (DataGridViewRowEventHandler)(Events [UserAddedRowEvent]);
if (eh != null) eh (this, e);
}
{
DataGridViewRowEventHandler eh = (DataGridViewRowEventHandler)(Events [UserDeletedRowEvent]);
if (eh != null) eh (this, e);
-
}
protected virtual void OnUserDeletingRow (DataGridViewRowCancelEventArgs e)
if (cell != null && !cell.Visible)
throw new InvalidOperationException ("cell is not visible");
+ // Always update the current cell address property
+ // If the row has moved it would be out of date.
+ if (currentCell != null) {
+ if (setAnchorCellAddress) {
+ anchor_cell.X = currentCell.ColumnIndex;
+ anchor_cell.Y = currentCell.RowIndex;
+ }
+ currentCellAddress.X = currentCell.ColumnIndex;
+ currentCellAddress.Y = currentCell.RowIndex;
+ }
+
if (cell != currentCell) {
if (currentCell != null) {
if (currentCell.IsInEditMode && !EndEdit ())
return false;
+ else if (currentCell.RowIndex == NewRowIndex && new_row_editing)
+ CancelEdit ();
OnCellLeave (new DataGridViewCellEventArgs(currentCell.ColumnIndex, currentCell.RowIndex));
OnRowLeave (new DataGridViewCellEventArgs (currentCell.ColumnIndex, currentCell.RowIndex));
}
anchor_cell = new Point (columnIndex, rowIndex);
currentCellAddress = new Point (columnIndex, rowIndex);
- UpdateBindingPosition (currentCell.RowIndex);
- OnRowEnter (new DataGridViewCellEventArgs (cell.ColumnIndex, cell.RowIndex));
- OnCellEnter (new DataGridViewCellEventArgs(cell.ColumnIndex, cell.RowIndex));
+ if (cell != null) {
+ UpdateBindingPosition (cell.RowIndex);
+ OnRowEnter (new DataGridViewCellEventArgs (cell.ColumnIndex, cell.RowIndex));
+ OnCellEnter (new DataGridViewCellEventArgs(cell.ColumnIndex, cell.RowIndex));
+ }
OnCurrentCellChanged (EventArgs.Empty);
- if (editMode == DataGridViewEditMode.EditOnEnter)
- BeginEdit (true);
+
+ if (cell != null) {
+ // If the user begins an edit in the NewRow, add a new row
+ if (AllowUserToAddRows && cell.RowIndex == NewRowIndex && !is_binding && !new_row_editing) {
+ // OnUserAddedRow will add a real row and reset the current cell
+ OnUserAddedRow (new DataGridViewRowEventArgs (Rows[NewRowIndex]));
+ } else {
+ if (editMode == DataGridViewEditMode.EditOnEnter)
+ BeginEdit (true);
+ }
+ }
} else {
- if (throughMouseClick)
+ if (cell != null && throughMouseClick)
BeginEdit (true);
}
}
internal void SetSelectedRowCoreInternal (int rowIndex, bool selected) {
- SetSelectedRowCore (rowIndex, selected);
+ if (rowIndex >= 0 && rowIndex < Rows.Count)
+ SetSelectedRowCore (rowIndex, selected);
}
protected virtual void SetSelectedRowCore (int rowIndex, bool selected) {
internal void PrepareEditingRow (bool cell_changed, bool column_changed)
{
+ if (new_row_editing) {
+ if (editing_row != null) {
+ Rows.RemoveInternal (editing_row);
+ editing_row = null;
+ }
+ return;
+ }
+
bool show = false;
show = ColumnCount > 0 && AllowUserToAddRows;
Rows.RemoveInternal (editing_row);
editing_row = null;
} else if (show) {
- if (editing_row != null) {
- if (cell_changed) {
- // The row changed, it's no longer an editing row.
- editing_row = null;
- } else if (column_changed) {
- // The number of columns has changed, we need a new editing row.
- Rows.RemoveInternal (editing_row);
- editing_row = null;
- }
+ if (editing_row != null && (cell_changed || column_changed)) {
+ // The row changed, it's no longer an editing row.
+ // or
+ // The number of columns has changed, we need a new editing row.
+ Rows.RemoveInternal (editing_row);
+ editing_row = null;
}
if (editing_row == null) {
editing_row = RowTemplateFull;
Rows.AddInternal (editing_row, false);
}
}
-
-
}
internal DataGridViewRow EditingRow {
columns.ClearAutoGeneratedColumns ();
rows.Clear ();
PrepareEditingRow (false, true);
- if (DataManager != null)
+ if (DataManager != null) {
DataManager.ListChanged -= OnListChanged;
+ DataManager.PositionChanged -= OnListPositionChanged;
+ }
}
private void DoBinding ()
DataGridViewColumn col = CreateColumnByType (property.PropertyType);
col.Name = property.DisplayName;
col.DataPropertyName = property.DisplayName;
- col.ReadOnly = property.IsReadOnly;
+ col.ReadOnly = !DataManager.AllowEdit || property.IsReadOnly;
col.SetIsDataBound (true);
col.ValueType = property.PropertyType;
col.AutoGenerated = true;
is_autogenerating_columns = false;
}
+ // DataBind both autogenerated and not columns if there is a matching property
+ foreach (PropertyDescriptor property in DataManager.GetItemProperties()) {
+ foreach (DataGridViewColumn col in Columns) {
+ if (col.DataPropertyName == property.Name)
+ col.SetIsDataBound (true);
+ }
+ }
+
foreach (object element in DataManager.List)
AddBoundRow (element);
DataManager.ListChanged += OnListChanged;
+ DataManager.PositionChanged += OnListPositionChanged;
OnDataBindingComplete (new DataGridViewBindingCompleteEventArgs (ListChangedType.Reset));
+ OnListPositionChanged (this, EventArgs.Empty);
+ } else {
+ if (Rows.Count > 0 && Columns.Count > 0)
+ MoveCurrentCell (0, 0, true, false, false, false);
}
- if (Rows.Count > 0 && Columns.Count > 0)
- MoveCurrentCell (0, 0, true, false, false, false);
+
PerformLayout();
Invalidate ();
}
private void MoveCurrentCell (int x, int y, bool select, bool isControl, bool isShift, bool scroll)
{
- if (!SetCurrentCellAddressCore (x, y, true, false, false))
+ if (x == -1 || y == -1)
+ x = y = -1;
+
+ if (!SetCurrentCellAddressCore (x, y, true, false, false)) {
+ ClearSelection ();
+ return;
+ }
+ if (x == -1 && y == -1) {
+ ClearSelection ();
return;
+ }
bool full_row_selected = Rows.SharedRow(CurrentCellAddress.Y).Selected;
bool full_col_selected = Columns[CurrentCellAddress.X].Selected;
private int ColumnIndexToDisplayIndex (int index)
{
+ if (index == -1)
+ return index;
return Columns[index].DisplayIndex;
}
AddBoundRow (DataManager[args.NewIndex]);
break;
case ListChangedType.ItemDeleted:
- Rows.RemoveAt (args.NewIndex);
+ Rows.RemoveAtInternal (args.NewIndex);
break;
case ListChangedType.ItemChanged:
break;
Invalidate ();
}
+ private void OnListPositionChanged (object sender, EventArgs args)
+ {
+ if (Rows.Count > 0 && Columns.Count > 0 && DataManager.Position != -1)
+ MoveCurrentCell (currentCell != null ? currentCell.ColumnIndex : 0, DataManager.Position,
+ true, false, false, true);
+ else
+ MoveCurrentCell (-1, -1, true, false, false, true);
+ }
private void ReBind ()
{
- ClearBinding ();
- DoBinding ();
+ if (!is_binding) {
+ is_binding = true;
+ ClearBinding ();
+ DoBinding ();
+ is_binding = false;
+ }
}
private bool MouseOverColumnResize (int col, int mousex)
object val1 = row1.Cells[column].FormattedValue;
object val2 = row2.Cells[column].FormattedValue;
+ object val1NullValue = row1.Cells[column].InheritedStyle.NullValue;
+ object val2NullValue = row2.Cells[column].InheritedStyle.NullValue;
- if (val1 == null && val2 == null)
+ if (val1 == val1NullValue && val2 == val2NullValue)
return 0;
- if (val1 == null)
+ if (val1 == val1NullValue)
return direction;
- if (val2 == null)
+ if (val2 == val2NullValue)
return -1 * direction;
if (numeric_sort)
projects / mono.git / blobdiff