/// <summary>
/// Applies all given transactions
/// </summary>
/// <param name="ops">Operation list</param>
private void ApplyTransaction(List <UndoRedoOperationBase> ops)
{
int i = 0;
while (i < ops.Count)
{
UndoRedoOperationBase r = ops[i];
DataRow row = r.Row;
switch (r.OperationType)
{
case UndoRedoOperationBaseType.NewRow:
UndoRedoRowOperation rowOp = (UndoRedoRowOperation)r;
DataTable sourceTable = rowOp.Table;
DataRow newRow = sourceTable.NewRow();
if (rowOp.WasDeleted)
{
RestoreRowFields(rowOp, newRow);
}
bool flag = true;
int j = i + 1;
while (flag & j < ops.Count)
{
if (ops[j].OperationType == UndoRedoOperationBaseType.ChangeField)
{
UndoRedoFieldOperation f = (UndoRedoFieldOperation)ops[j];
newRow[f.ColumnName] = f.NewValue;
i = j - 1;
}
else
{
flag = false;
}
j++;
}
sourceTable.Rows.Add(newRow);
for (int n = r.ID; n < m_operations.Count; ++n)
{
if (m_operations[n].Row == row)
{
m_operations[n].Row = newRow;
}
}
break;
case UndoRedoOperationBaseType.DeleteRow:
//((UndoRedoRowOperation)r).Table.Rows.Remove(row);
((UndoRedoRowOperation)r).Row.Delete();
break;
case UndoRedoOperationBaseType.ChangeField:
UndoRedoFieldOperation fieldOp = (UndoRedoFieldOperation)r;
row[fieldOp.ColumnName] = fieldOp.NewValue;
break;
}
i++;
}
}
/// <summary>
/// Handler for when the field value actually changes. The application has now
/// had a chance to set the proposed value, so we can record it as the new value.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void OnColumnChanged(object sender, DataColumnChangeEventArgs e)
{
if (m_doLogging)
{
for (int i = 0; i < waitingForChangedEventList.Count; i++)
{
UndoRedoFieldOperation r = (UndoRedoFieldOperation)waitingForChangedEventList[i];
if ((r.Row == e.Row) && (r.ColumnName == e.Column.ColumnName))
{
r.NewValue = e.ProposedValue;
waitingForChangedEventList.RemoveAt(i);
break;
}
}
}
}
/// <summary>
/// Handler for when a field changes. This records only the current (old) field value.
/// The OnColumnChanged handler records the new value, giving the application a chance
/// to change the proposed value.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void OnColumnChanging(object sender, DataColumnChangeEventArgs e)
{
if (m_doLogging)
{
object oldVal = e.Row[e.Column];
int trnIdx = m_operations.Count;
UndoRedoFieldOperation record = new UndoRedoFieldOperation
(trnIdx, e.Row.Table, e.Row, e.Column.ColumnName, oldVal, e.ProposedValue);
if (m_trasaction)
{
record.TransactionId = curentTransactionID;
}
OnRedoUndoOperationAdding(new UndoRedoEventArgs(record));
m_operations.Add(record);
OnRedoUndoOperationAdded(new UndoRedoEventArgs(record));
waitingForChangedEventList.Add(record);
if (m_uncomittedRows.ContainsKey(e.Row))
{
m_uncomittedRows[e.Row].Add(trnIdx);
}
}
}
