public void LoadFile(string path)
{
if (!string.IsNullOrEmpty(path) && System.IO.File.Exists(path))
{
Reset();
Data = XmlConverter.ToObject(path, typeof(DMXCommandFile)) as DMXCommandFile;
Data.AcceptChanges();
int priority = 0;
if (Data != null)
{
Data.AcceptChanges();
WorkFile = path;
SetWatcher(WorkFile);
List <string> cc = new List <string>();
foreach (EventObject e in Data.Events)
{
e.Priority = priority++;
e.DeactivateMe += e_DeactivateMe;
if (!cc.Contains(e.EventType))
{
cc.Add(e.EventType);
}
}
cc.Sort();
Cues = new ObservableCollection <string>(cc);
}
}
else
{
MessageBox.Show("File Not Found:\r\n\r\n" + path, "DMX Commander", MessageBoxButton.OK, MessageBoxImage.Error);
}
}
/// <summary>
/// Commits the current changes since the last checkpoint to the ChangeLog, making it available for Rollback as a unit.
/// </summary>
public void Checkpoint(string name)
{
lock (SyncRoot)
{
// Get changes
var changes = Data.GetChanges();
// Do nothing when no changes
if (changes == null)
{
return;
}
// Do not check constraints on changes (may be orphaned)
changes.EnforceConstraints = false;
// Truncate existing log (remove any roll-forwards entries)
if (_logIndex < _changeLog.Count - 1)
{
while (_changeLog.Count > (_logIndex + 1))
{
_changeLog.RemoveAt(_changeLog.Count - 1);
}
}
// Add change log entry
var logEntry = new DataSetChangeLogEntry(DateTime.UtcNow, name, changes);
_changeLog.Add(logEntry);
_logIndex++;
// Commit changes
Data.AcceptChanges();
}
}
private void Save_Click(object sender, RoutedEventArgs e)
{
fsw.EnableRaisingEvents = false;
Data.Save();
Data.AcceptChanges();
SetWatcher(Data.INIPath);
}
public void Save(string scriptFile)
{
if (Data != null && Data.IsDirty())
{
if (DebugLogging.Enable)
{
OutputWindowMessage.WriteMessage("Table: Saving change to table: \"{0}\" to scriptfile: \"{1}\"", Name, scriptFile);
}
//if detils of Merge.Blah are filled in then update the current Merge.MergeStatement with the new datatable and then get the script and overwrite the existing script..
//if it is not filled in, we need to create a new one and build a new merge
Data.AcceptChanges();
if (Merge.MergeStatement == null)
{
Merge.MergeStatement = new MergeStatementBuilder(Columns, SchemaName, Name, KeyColumns).Build();
Merge.File = scriptFile;
}
Merge.MergeStatement.SetInlineTableData(Data, Columns);
var script = Merge.MergeStatement.GetScript();
string originalScript = null;
using (var sr = new StreamReader(Merge.File))
{
originalScript = sr.ReadToEnd();
}
string outputScript = null;
if (!string.IsNullOrEmpty(Merge.OriginalScript))
{
outputScript = originalScript.Replace(Merge.OriginalScript, "");
}
else
{
outputScript = originalScript;
}
Merge.OriginalScript = script;
outputScript = outputScript + "\r\nGO\r\n" + script;
outputScript = outputScript.Replace("\r\nGO\r\n\r\nGO\r\n", "\r\nGO\r\n");
using (var sw = new StreamWriter(Merge.File, false))
{
sw.Write(outputScript);
}
Data.SetClean();
if (DebugLogging.Enable)
{
OutputWindowMessage.WriteMessage("Table: Saving change to table: \"{0}\" to scriptfile: \"{1}\" Completed", Name, scriptFile);
}
}
}
void LoadFile()
{
Reset();
Data = XmlConverter.ToObject(WorkFile, typeof(VesselDataObject)) as VesselDataObject;
Data.AcceptChanges();
if (Data.Vessels.Count > 0)
{
SelectedVessel = Data.Vessels[0];
}
SetWatcher(WorkFile);
}
private void SaveAs_Click(object sender, RoutedEventArgs e)
{
fsw.EnableRaisingEvents = false;
SaveFileDialog diag = new SaveFileDialog();
diag.Title = "Save Artemis.ini as...";
diag.InitialDirectory = Configuration.InstalledPath;
diag.FileName = System.IO.Path.Combine(Configuration.InstalledPath, "artemis.ini");
diag.Filter = "Artemis INI files(*artemis*.ini)|*artemis*.ini|INI files (*.ini)|*.ini|All files (*.*)|*.*";
if (diag.ShowDialog() == true)
{
Data.Save(diag.FileName);
SetWatcher(Data.INIPath);
Data.AcceptChanges();
}
}
public bool Save()
{
bool retVal = false;
if (string.IsNullOrEmpty(WorkFile))
{
return(SaveAs());
}
System.Xml.XmlDocument doc = XmlConverter.ToXmlDocument(Data, true);
try
{
fsw.EnableRaisingEvents = false;
doc.Save(WorkFile);
SetWatcher(WorkFile);
Data.AcceptChanges();
retVal = true;
}
catch (Exception ex)
{
MessageBox.Show("Unable to save file. \r\n\r\nError from Windows:\r\n\r\n" + ex.Message, "DMX Commander", MessageBoxButton.OK, MessageBoxImage.Error);
}
return(retVal);
}
public void New()
{
if (Data.Changed)
{
switch (MessageBox.Show("Do you wish to save the current file first?", "DMX Commander", MessageBoxButton.YesNoCancel, MessageBoxImage.Question))
{
case MessageBoxResult.Cancel:
return;
case MessageBoxResult.Yes:
if (!Save())
{
if (!SaveAs())
{
return;
}
}
break;
}
}
WorkFile = null;
this.Data = new DMXCommandFile();
Data.AcceptChanges();
}
/// <summary>
/// Loads 2DA data from the specified read.
/// </summary>
/// <param name="reader">The reader to read the data from.</param>
/// <param name="lineNumberCallback">
/// The line number callback. For each line read from the reader, the callback will
/// be invoked once, with the number of the line read passed as an argument.
/// </param>
/// <exception cref="InvalidDataException">
/// 2DA data in the reader is not in a correct format, is corrupted, or does not match
/// the schema.
/// </exception>
public void Load(TextReader reader, Action <int> lineNumberCallback)
{
int lineNumber = 0;
if (reader == null)
{
throw new ArgumentNullException("reader");
}
try
{
isLoading = true;
Data.Clear();
Data.Columns.Clear();
string signatureLine = reader.ReadLine().TrimEnd();
++lineNumber;
if (signatureLine != validSignature)
{
throw new InvalidDataException(string.Format(
"Error at line {0}: '{1}' is not a valid 2DA signature",
lineNumber,
signatureLine));
}
if (lineNumberCallback != null)
{
lineNumberCallback(lineNumber);
}
string defaultValueLine = reader.ReadLine().TrimEnd();
++lineNumber;
if (defaultValueLine == null)
{
throw new InvalidDataException(string.Format(
"Error at line {0}: default value line is missing",
lineNumber));
}
if (defaultValueLine.Length != 0)
{
if (!defaultValueLine.StartsWith(defaultValueMarker))
{
throw new InvalidDataException(string.Format(
"Error at line {0}: default value line must either be blank, or begin with '{1}'",
lineNumber,
defaultValueMarker));
}
DefaultString = defaultValueLine.Remove(0, defaultValueMarker.Length).TrimStart();
}
if (lineNumberCallback != null)
{
lineNumberCallback(lineNumber);
}
string columnNamesLine = null;
do
{
columnNamesLine = reader.ReadLine().TrimEnd();
++lineNumber;
} while (columnNamesLine == "");
if (columnNamesLine == null)
{
throw new InvalidDataException(string.Format(
"Error at line {0}: column names line is missing",
lineNumber));
}
var rowNumberColumn = new DataColumn("#", typeof(int));
rowNumberColumn.AllowDBNull = true;
Data.Columns.Add(rowNumberColumn);
var columnNames = GetFieldValues(columnNamesLine);
foreach (string columnName in columnNames)
{
var column = new DataColumn(columnName, typeof(string));
TwoDASchema.Column schemaColumn = null;
if (Schema != null && Schema.Columns != null)
{
schemaColumn = Schema.Columns.FirstOrDefault(c => c.Name == columnName);
}
if (schemaColumn == null)
{
column.DataType = typeof(string);
column.MaxLength = 267;
column.AllowDBNull = true;
column.DefaultValue = DBNull.Value;
}
else
{
column.AllowDBNull = schemaColumn.AllowBlanks;
switch (schemaColumn.DataType)
{
case TwoDASchema.DataType.String:
column.DataType = typeof(string);
column.MaxLength = 267;
break;
case TwoDASchema.DataType.Float:
column.DataType = typeof(float);
break;
case TwoDASchema.DataType.Integer:
case TwoDASchema.DataType.HexInteger:
case TwoDASchema.DataType.StrRef:
column.DataType = typeof(int);
break;
}
}
Data.Columns.Add(column);
}
FillSchemaColumns();
if (lineNumberCallback != null)
{
lineNumberCallback(lineNumber);
}
string line;
while ((line = reader.ReadLine()) != null)
{
++lineNumber;
line = line.TrimEnd();
if (line.Length == 0)
{
continue;
}
DataRow row = Data.NewRow();
IEnumerable <string> fieldValues = GetFieldValues(line);
int columnIndex = 0;
foreach (string fieldValue in fieldValues)
{
if (columnIndex >= Data.Columns.Count)
{
throw new InvalidDataException(string.Format(
"Error at line {0}: too many field values",
lineNumber));
}
object actualValue =
fieldValue == BlankEntry ?
(object)DBNull.Value :
fieldValue;
var schemaColumn = schemaColumns[columnIndex];
if (schemaColumn != null && actualValue != DBNull.Value)
{
switch (schemaColumn.DataType)
{
case TwoDASchema.DataType.Integer:
case TwoDASchema.DataType.StrRef:
{
actualValue = int.Parse(fieldValue, CultureInfo.InvariantCulture);
} break;
case TwoDASchema.DataType.HexInteger:
{
if (fieldValue.StartsWith("0x", StringComparison.OrdinalIgnoreCase))
{
actualValue = int.Parse(fieldValue.Substring(2), NumberStyles.HexNumber, CultureInfo.InvariantCulture);
}
else
{
actualValue = int.Parse(fieldValue, CultureInfo.InvariantCulture);
}
} break;
case TwoDASchema.DataType.Float:
{
actualValue = float.Parse(fieldValue, CultureInfo.InvariantCulture);
} break;
}
}
try
{
row[columnIndex] = actualValue;
}
catch (ArgumentException ex)
{
throw new InvalidDataException(string.Format(
"Error at line {0}: {1}",
lineNumber,
ex.Message), ex);
}
++columnIndex;
}
Data.Rows.Add(row);
if (lineNumberCallback != null)
{
lineNumberCallback(lineNumber);
}
}
Data.AcceptChanges();
IsModified = false;
}
catch (DataException ex)
{
throw new InvalidDataException(string.Format(
"Error at line {0}: {1}",
lineNumber,
ex.Message), ex);
}
finally
{
isLoading = false;
}
undoStack.Clear();
redoStack.Clear();
OnPropertyChanged(new PropertyChangedEventArgs("CanUndo"));
OnPropertyChanged(new PropertyChangedEventArgs("CanRedo"));
}
/// <summary>
/// Rolls-back the DataSet by the specified number of checkpoint "steps".
/// </summary>
public void Undo(int steps)
{
lock (SyncRoot)
{
// Validate request
if ((steps < 1) || (steps > (_logIndex + 1)))
{
throw new InvalidOperationException();
}
// Disable constraints during update (if enabled)
var enforceConstraints = Data.EnforceConstraints;
if (enforceConstraints)
{
Data.EnforceConstraints = false;
}
// Undo any outstanding changes before Checkpoint
Data.RejectChanges();
// Rollback the specified number of steps...
while (steps-- > 0)
{
// Get change log entry
var logEntry = _changeLog[_logIndex];
var changes = logEntry.Changes;
// Reverse changes to DataSet
foreach (DataTable changedTable in changes.Tables)
{
foreach (DataRow changedRow in changedTable.Rows)
{
// Reverse action
switch (changedRow.RowState)
{
case DataRowState.Added:
{
// Reverse INSERT...
// Find the original row
var primaryKeyStatement = GetPrimaryKeyFilterExpression(changedRow);
var existingRows = Data.Tables[changedTable.TableName].Select(primaryKeyStatement);
if (existingRows.Length == 0)
{
throw new InvalidOperationException(Resources.DataSetChangeLogUndoInsertError);
}
var row = existingRows[0];
// Delete the row
row.Delete();
break;
}
case DataRowState.Modified:
{
// Reverse UPDATE...
// Find the original row
var primaryKeyStatement = GetPrimaryKeyFilterExpression(changedRow);
var existingRows = Data.Tables[changedTable.TableName].Select(primaryKeyStatement);
if (existingRows.Length == 0)
{
throw new InvalidOperationException(Resources.DataSetChangeLogUndoUpdateError);
}
var row = existingRows[0];
// Restore the original row values
for (var i = 0; i < changedTable.Columns.Count; i++)
{
row[i] = changedRow[i, DataRowVersion.Original];
}
break;
}
case DataRowState.Deleted:
{
// Reverse DELETE...
// Insert the original row
var table = Data.Tables[changedTable.TableName];
var row = table.NewRow();
for (var i = 0; i < changedTable.Columns.Count; i++)
{
row[i] = changedRow[i, DataRowVersion.Original];
}
table.Rows.Add(row);
break;
}
}
}
}
// Commit changes
Data.AcceptChanges();
// Move change log pointer backwards (do not remove forward entries until next Checkpoint, to allow roll-forward until that time)
_logIndex--;
}
// Restore constraints after update (if previously enabled)
if (enforceConstraints)
{
Data.EnforceConstraints = true;
}
}
}
/// <summary>
/// Rolls the DataSet forwards by the specified number of checkpoint "steps".
/// </summary>
public void Redo(int steps)
{
lock (SyncRoot)
{
// Validate request
if ((steps < 1) || (steps > (_changeLog.Count - _logIndex)))
{
throw new InvalidOperationException();
}
// Disable constraints during update (if enabled)
var enforceConstraints = Data.EnforceConstraints;
if (enforceConstraints)
{
Data.EnforceConstraints = false;
}
// Undo any outstanding changes before Checkpoint
Data.RejectChanges();
// Rollforward the specified number of steps...
while (steps-- > 0)
{
// Get change log entry
var logEntry = _changeLog[_logIndex + 1];
var changes = logEntry.Changes;
// Re-apply changes to DataSet
foreach (DataTable changedTable in changes.Tables)
{
foreach (DataRow changedRow in changedTable.Rows)
{
// Re-apply action
switch (changedRow.RowState)
{
case DataRowState.Added:
{
// Re-apply INSERT...
// Insert the changed row
Data.Tables[changedTable.TableName].Rows.Add(changedRow.ItemArray);
break;
}
case DataRowState.Modified:
{
// Re-apply UPDATE...
// Find the original row
var primaryKeyStatement = GetPrimaryKeyFilterExpression(changedRow);
var existingRows = Data.Tables[changedTable.TableName].Select(primaryKeyStatement);
if (existingRows.Length == 0)
{
throw new InvalidOperationException(Resources.DataSetChangeLogRedoUpdateError);
}
var row = existingRows[0];
// Update row values
row.ItemArray = changedRow.ItemArray;
break;
}
case DataRowState.Deleted:
{
// Re-apply DELETE...
// Temporarily un-delete change row to allow access to key information
changedRow.RejectChanges();
// Find the original row
var primaryKeyStatement = GetPrimaryKeyFilterExpression(changedRow);
var existingRows = Data.Tables[changedTable.TableName].Select(primaryKeyStatement);
if (existingRows.Length == 0)
{
throw new InvalidOperationException(Resources.DataSetChangeLogRedoDeleteError);
}
var row = existingRows[0];
// Restore change row to original state
changedRow.Delete();
// Delete the row
row.Delete();
break;
}
}
}
}
// Commit changes
Data.AcceptChanges();
// Move change log pointer forwards
_logIndex++;
}
// Restore constraints after update (if previously enabled)
if (enforceConstraints)
{
Data.EnforceConstraints = true;
}
}
}
