private void exportStateButton_Click(object sender, EventArgs e)
{
if (saveMemFileDialog.ShowDialog(this) == DialogResult.OK)
{
try
{
string dataFolder = MyProject.MakeDataFolderFromFileName(saveMemFileDialog.FileName);
MyMemoryBlockSerializer.ExportTempStorage(Project, dataFolder);
MyNetworkState networkState = new MyNetworkState()
{
ProjectName = Project.Name,
MemoryBlocksLocation = dataFolder,
SimulationStep = SimulationHandler.SimulationStep
};
YAXSerializer serializer = new YAXSerializer(typeof(MyNetworkState),
YAXExceptionHandlingPolicies.ThrowErrorsOnly,
YAXExceptionTypes.Warning);
serializer.SerializeToFile(networkState, saveMemFileDialog.FileName);
MyLog.INFO.WriteLine("Saving state: " + saveMemFileDialog.FileName);
}
catch (Exception ex)
{
MyLog.ERROR.WriteLine("Saving state failed: " + ex.Message);
}
}
}
/// <summary>
/// Loads project from file
/// </summary>
/// <param name="path">Path to .brain/.brainz file</param>
public void OpenProject(string path)
{
MyLog.INFO.WriteLine("Loading project: " + path);
string content;
try
{
string newProjectName = MyProject.MakeNameFromPath(path);
content = ProjectLoader.LoadProject(path,
MyMemoryBlockSerializer.GetTempStorage(newProjectName));
using (MyMemoryManager.Backup backup = MyMemoryManager.GetBackup())
{
Project = MyProject.Deserialize(content, Path.GetDirectoryName(path));
backup.Forget();
}
Project.FileName = path;
}
catch (Exception e)
{
MyLog.ERROR.WriteLine("Project loading failed: " + e.Message);
throw;
}
}
private void SaveProjectAs()
{
if (saveFileDialog.ShowDialog(this) != DialogResult.OK)
{
return;
}
string newName = saveFileDialog.FileName;
string oldProjectDataPath = MyMemoryBlockSerializer.GetTempStorage(Project);
string newProjectDataPath = MyMemoryBlockSerializer.GetTempStorage(MyProject.MakeNameFromPath(newName));
if (newProjectDataPath != oldProjectDataPath)
{
CopyDirectory(oldProjectDataPath, newProjectDataPath);
}
else
{
MyLog.WARNING.WriteLine("Projects with the same filename share the same temporal folder where the state is saved.");
}
Project.FileName = newName; // Also sets the name;
SaveProject();
m_recentMenu.AddFile(newName);
}
private void SaveBlocks(IEnumerable <MyWorkingNode> nodeList)
{
MyMemoryBlockSerializer serializer = new MyMemoryBlockSerializer();
var isFirst = true;
foreach (MyWorkingNode node in nodeList)
{
if (SaveAllNodesData || node.SaveOnStop)
{
foreach (MyAbstractMemoryBlock mb in MyMemoryManager.Instance.GetBlocks(node))
{
if (mb.Persistable)
{
if (isFirst)
{
MyLog.INFO.WriteLine("Saving state to: " + MyMemoryBlockSerializer.GetTempStorage(m_project));
}
isFirst = false;
serializer.SaveBlock(mb);
}
}
}
}
}
private void LoadBlocks(IEnumerable <MyWorkingNode> nodeList)
{
MyMemoryBlockSerializer serializer = new MyMemoryBlockSerializer();
var isFirst = true;
foreach (MyWorkingNode node in nodeList)
{
if (LoadAllNodesData || node.LoadOnStart)
{
foreach (MyAbstractMemoryBlock mb in MyMemoryManager.Instance.GetBlocks(node))
{
if (mb.Persistable)
{
if (isFirst)
{
MyLog.INFO.WriteLine("Loading state from: " + MyMemoryBlockSerializer.GetTempStorage(m_project));
}
isFirst = false;
serializer.LoadBlock(mb, GlobalDataFolder);
}
}
}
}
}
private void clearDataButton_Click(object sender, EventArgs e)
{
if (MessageBox.Show("Clear all temporal data for node: " + (Target as MyWorkingNode).Name + "?",
"Clear data", MessageBoxButtons.OKCancel, MessageBoxIcon.Question) == DialogResult.OK)
{
MyMemoryBlockSerializer.ClearTempData(Target as MyWorkingNode);
}
}
private void clearDataButton_Click(object sender, EventArgs e)
{
if (MessageBox.Show("Clear all temporal data for project: " + Project.Name + "?",
"Clear data", MessageBoxButtons.OKCancel, MessageBoxIcon.Question) == DialogResult.OK)
{
MyMemoryBlockSerializer.ClearTempStorage(Project);
exportStateButton.Enabled = false;
clearDataButton.Enabled = false;
}
}
private bool OpenProject(string fileName)
{
MyLog.INFO.WriteLine("--------------");
MyLog.INFO.WriteLine("Loading project: " + fileName);
try
{
TextReader reader = new StreamReader(fileName);
string content = reader.ReadToEnd();
reader.Close();
Project = MyProject.Deserialize(content, Path.GetDirectoryName(fileName));
Properties.Settings.Default.LastProject = fileName;
saveFileDialog.FileName = fileName;
m_savedProjectRepresentation = content;
CloseAllGraphLayouts();
CloseAllObservers();
CreateNetworkView();
OpenGraphLayout(Project.Network);
if (Project.World != null)
{
SelectWorldInWorldList(Project.World);
}
if (Project.Observers != null)
{
foreach (MyAbstractObserver observer in Project.Observers)
{
observer.RestoreTargetFromIdentifier(Project);
if (observer.GenericTarget != null)
{
ShowObserverView(observer);
}
}
}
Project.Observers = null;
exportStateButton.Enabled = MyMemoryBlockSerializer.TempDataExists(Project);
clearDataButton.Enabled = exportStateButton.Enabled;
Text = TITLE_TEXT + " - " + Project.Name;
return(true);
}
catch (Exception e)
{
MyLog.ERROR.WriteLine("Project loading failed: " + e.Message);
return(false);
}
}
internal override void ValidateMandatory(MyValidator validator)
{
base.ValidateMandatory(validator);
if (LoadOnStart || validator.Simulation.LoadAllNodesData)
{
if (MyMemoryBlockSerializer.TempDataExists(this))
{
validator.AddInfo(this, "Node will load data from temporal storage.");
}
else if (DataFolder != null && DataFolder != String.Empty)
{
validator.AddInfo(this, "Node will load data from user defined folder: " + DataFolder);
}
else if (validator.Simulation.LoadAllNodesData && !(String.IsNullOrEmpty(validator.Simulation.GlobalDataFolder)))
{
validator.AddInfo(this, "Node will load data from user defined folder: "
+ validator.Simulation.GlobalDataFolder + "\\" + MyMemoryBlockSerializer.GetNodeFolder(this));
}
else if (validator.Simulation.LoadAllNodesData && (String.IsNullOrEmpty(validator.Simulation.GlobalDataFolder)))
{
validator.AddInfo(this, "Node will load data from temporal storage.");
}
else
{
validator.AddWarning(this, "LoadOnStart is active but no temporal data and no local or global data folder is set. Data will NOT be loaded.");
}
}
validator.AssertInfo(!(SaveOnStop || validator.Simulation.SaveAllNodesData), this, "Node will save data to temporal storage before stop.");
foreach (PropertyInfo pInfo in GetInfo().OwnedMemoryBlocks)
{
MyAbstractMemoryBlock mb = (pInfo.GetValue(this) as MyAbstractMemoryBlock);
validator.AssertError(mb.Count >= 0, this, "Size of " + mb.Name + " memory block cannot be negative.");
}
List <PropertyInfo> inputBlocks = GetInfo().InputBlocks;
for (int i = 0; i < inputBlocks.Count; i++)
{
PropertyInfo pInfo = inputBlocks[i];
if (GetAbstractInput(i) != pInfo.GetValue(this))
{
validator.AddError(this, "Incompatible memory block for \"" + pInfo.Name + "\" (" + GetAbstractInput(i).GetType().GenericTypeArguments[0].Name + " != " + pInfo.PropertyType.GenericTypeArguments[0].Name + ")");
}
}
}
/// <summary>
/// Saves project to given path
/// </summary>
/// <param name="path">Path for saving .brain/.brainz file</param>
public void SaveProject(string path)
{
MyLog.INFO.WriteLine("Saving project: " + path);
try
{
string fileContent = Project.Serialize(Path.GetDirectoryName(path));
ProjectLoader.SaveProject(path, fileContent,
MyMemoryBlockSerializer.GetTempStorage(Project));
}
catch (Exception e)
{
MyLog.ERROR.WriteLine("Project saving failed: " + e.Message);
throw;
}
}
/// <summary>
/// Saves project to given path
/// </summary>
/// <param name="path">Path for saving .brain/.brainz file</param>
public void SaveProject(string path = null)
{
if (!string.IsNullOrEmpty(path))
{
Project.FileName = path;
}
MyLog.INFO.WriteLine("Saving project: " + Project.FileName);
try
{
string fileContent = Project.Serialize();
ProjectLoader.SaveProject(Project.FileName, fileContent,
MyMemoryBlockSerializer.GetTempStorage(Project));
}
catch (Exception e)
{
MyLog.ERROR.WriteLine("Project saving failed: " + e.Message);
throw;
}
}
private void SaveBlocks(List <MyWorkingNode> nodeList)
{
MyMemoryBlockSerializer serializer = new MyMemoryBlockSerializer();
for (int j = 0; j < nodeList.Count; j++)
{
MyWorkingNode node = nodeList[j];
if (SaveAllNodesData || node.SaveOnStop)
{
foreach (MyAbstractMemoryBlock mb in MyMemoryManager.Instance.GetBlocks(node))
{
if (mb.Persistable)
{
serializer.SaveBlock(mb);
}
}
}
}
}
private void LoadBlocks(List <MyWorkingNode> nodeList)
{
MyMemoryBlockSerializer serializer = new MyMemoryBlockSerializer();
for (int j = 0; j < nodeList.Count; j++)
{
MyWorkingNode node = nodeList[j];
if (LoadAllNodesData || node.LoadOnStart)
{
foreach (MyAbstractMemoryBlock mb in MyMemoryManager.Instance.GetBlocks(node))
{
if (mb.Persistable)
{
serializer.LoadBlock(mb, GlobalDataFolder);
}
}
}
}
}
//TODO: this should be done by data binding but menu items cannot do that (add this support)
void SimulationHandler_StateChanged(object sender, MySimulationHandler.StateEventArgs e)
{
runToolButton.Enabled = SimulationHandler.CanStart;
startToolStripMenuItem.Enabled = SimulationHandler.CanStart;
pauseToolButton.Enabled = SimulationHandler.CanPause;
pauseToolStripMenuItem.Enabled = SimulationHandler.CanPause;
stopToolButton.Enabled = SimulationHandler.CanStop;
stopToolStripMenuItem.Enabled = SimulationHandler.CanStop;
debugToolButton.Enabled = SimulationHandler.CanStartDebugging;
debugToolStripMenuItem.Enabled = SimulationHandler.CanStartDebugging;
stepOverToolButton.Enabled = SimulationHandler.CanStepOver;
stepOverToolStripMenuItem.Enabled = SimulationHandler.CanStepOver;
stepIntoToolStripMenuItem.Enabled = SimulationHandler.CanStepInto;
stepOutToolStripMenuItem.Enabled = SimulationHandler.CanStepOut;
reloadButton.Enabled = SimulationHandler.State == MySimulationHandler.SimulationState.STOPPED;
simStatusLabel.Text = SimulationHandler.State.GetAttributeProperty((DescriptionAttribute x) => x.Description);
//TODO: this is awful, binding is needed here for sure
newProjectToolButton.Enabled = SimulationHandler.State == MySimulationHandler.SimulationState.STOPPED;
newProjectToolStripMenuItem.Enabled = SimulationHandler.State == MySimulationHandler.SimulationState.STOPPED;
openProjectToolButton.Enabled = SimulationHandler.State == MySimulationHandler.SimulationState.STOPPED;
openProjectToolStripMenuItem.Enabled = SimulationHandler.State == MySimulationHandler.SimulationState.STOPPED;
saveProjectToolButton.Enabled = SimulationHandler.State == MySimulationHandler.SimulationState.STOPPED;
saveProjectAsToolStripMenuItem.Enabled = SimulationHandler.State == MySimulationHandler.SimulationState.STOPPED;
saveProjectToolStripMenuItem.Enabled = SimulationHandler.State == MySimulationHandler.SimulationState.STOPPED;
copySelectionToolStripMenuItem.Enabled = pasteSelectionToolStripMenuItem.Enabled =
SimulationHandler.State == MySimulationHandler.SimulationState.STOPPED;
worldList.Enabled = SimulationHandler.State == MySimulationHandler.SimulationState.STOPPED;
NodePropertyView.CanEdit = SimulationHandler.State == MySimulationHandler.SimulationState.STOPPED;
updateMemoryBlocksToolStripMenuItem.Enabled = SimulationHandler.State == MySimulationHandler.SimulationState.STOPPED;
MemoryBlocksView.Enabled = SimulationHandler.State == MySimulationHandler.SimulationState.STOPPED ||
SimulationHandler.State == MySimulationHandler.SimulationState.PAUSED;
if (SimulationHandler.State == MySimulationHandler.SimulationState.STOPPED)
{
stepStatusLabel.Text = String.Empty;
statusStrip.BackColor = STATUS_BAR_BLUE;
exportStateButton.Enabled = MyMemoryBlockSerializer.TempDataExists(Project);
clearDataButton.Enabled = exportStateButton.Enabled;
}
else if (SimulationHandler.State == MySimulationHandler.SimulationState.PAUSED)
{
statusStrip.BackColor = Color.Chocolate;
}
else
{
statusStrip.BackColor = STATUS_BAR_BLUE_BUILDING;
}
RefreshUndoRedoButtons();
}
