public void SimulationPropertySetterTest() { var simulation = MockRepository.GenerateStub<MySimulation>(); var handler = new MySimulationHandler(simulation); // This should not throw, it's the first simulation. Assert.Throws<InvalidOperationException>(() => handler.Simulation = simulation); }
public override void Reallocate() { // This will allocate memory on the device. The CUDA context needs to be set up. MyKernelFactory.Instance.SetCurrent(0); // TODO(HonzaS): cache the ordered nodes if they have been ordered in model changes. foreach (MyNode node in MySimulationHandler.OrderNetworkNodes(m_project.Network)) { node.ReallocateMemoryBlocks(); } }
public MyProjectRunner(MyLogLevel level = MyLogLevel.DEBUG) { // why not to directly ask for TypeMap.GetInstance<MySimulation> ? // because in Typemap configuration, MySimulation is set to be singleton - this causes problems when MyProjectRunner // is instantiated multiple times - second and following instances obtain an instance of MySimulation from the first // MyProjectRunner instance. If the first MyProjectRunner instance was Shutdown-ed, the MySimulation instance is also // cleared and any following Shutdown on other MyProjectRunner instances will cause freeze/inifnite hang. // This code creates new MySimulation instance for each MyProjectRunner instance. // Other solution could be to not have a MySimulation as a singleton in TypeMap configuration - and it could work just OK, // because in BrainSim, the TypeMap's GetInstance on MySimulation is only on one place in MainForm. However, this may change // in future or the change itself may have other consequences, so for now I pick this solution, as it is safer. MySimulation simulation = new MyLocalSimulation(TypeMap.GetInstance <MyValidator>(), TypeMap.GetInstance <IMyExecutionPlanner>()); SimulationHandler = new MySimulationHandler(simulation); m_resultIdCounter = 0; SimulationHandler.ProgressChanged += SimulationHandler_ProgressChanged; SimulationHandler.StepPerformed += SimulationHandler_StepPerformed; m_monitors = new List <Tuple <int, uint, MonitorFunc> >(); m_results = new Hashtable(); Project = new MyProject(); var path = MyResources.GetEntryAssemblyPath(); if (MyConfiguration.ModulesSearchPath.Count == 0) { MyConfiguration.SetupModuleSearchPath(); } MyConfiguration.ProcessCommandParams(); try { if (MyConfiguration.Modules.Count == 0) { MyConfiguration.LoadModules(); } } catch (Exception e) { MyLog.WARNING.WriteLine(e.Message); throw; } MyLog.Level = level; }
public void SimulationStateChangedOnNodesTest() { var simulation = new MyLocalSimulation(); var handler = new MySimulationHandler(simulation); MyProject project = new MyProject { Network = new MyNetwork() }; project.CreateWorld(typeof(MyTestingWorld)); var node = project.CreateNode<TestingNode>(); node.Event = new AutoResetEvent(false); project.Network.AddChild(node); var connection = new MyConnection(project.Network.GroupInputNodes[0], project.Network.Children[0]); connection.Connect(); project.Network.PrepareConnections(); handler.Project = project; handler.UpdateMemoryModel(); handler.StartSimulation(oneStepOnly: false); node.Event.WaitOne(); Assert.Equal(MySimulationHandler.SimulationState.STOPPED, node.PreviousState); Assert.Equal(MySimulationHandler.SimulationState.RUNNING, node.CurrentState); handler.PauseSimulation(); node.Event.WaitOne(); Assert.Equal(MySimulationHandler.SimulationState.RUNNING, node.PreviousState); Assert.Equal(MySimulationHandler.SimulationState.PAUSED, node.CurrentState); handler.StartSimulation(oneStepOnly: true); node.Event.WaitOne(); // Here the sim goes from paused to RUNNING_STEP. Assert.Equal(MySimulationHandler.SimulationState.PAUSED, node.PreviousState); Assert.Equal(MySimulationHandler.SimulationState.RUNNING_STEP, node.CurrentState); node.Event.WaitOne(); // Here it goes to PAUSED. Assert.Equal(MySimulationHandler.SimulationState.RUNNING_STEP, node.PreviousState); Assert.Equal(MySimulationHandler.SimulationState.PAUSED, node.CurrentState); handler.StopSimulation(); node.Event.WaitOne(); Assert.Equal(MySimulationHandler.SimulationState.PAUSED, node.PreviousState); Assert.Equal(MySimulationHandler.SimulationState.STOPPED, node.CurrentState); handler.Finish(); }
private void SetupAfterModelChange(IModelChanges modelChanges, List <MyNode> changersActivated) { // Clean up memory. IterateNodes(modelChanges.RemovedNodes, DestroyNode); // This must happen before UpdateMemoryModel() because some nodes touch kernels in UpdateMemoryBlocks(). MyKernelFactory.Instance.SetCurrent(0); // Refresh topological ordering. List <MyNode> orderedNodes = MySimulationHandler.OrderNetworkNodes(m_project.Network); // Update the whole memory model. // TODO(HonzaS): This may break things, check. // We'll need to forbid changing of count after the simulation has started with the exception of added nodes. // However, the added nodes may lead to reallocation of blocks - deal with it. bool updatesNotConverged = UpdateMemoryModel(m_project, orderedNodes); Validator.ClearValidation(); // Validate new nodes. IterateNodes(modelChanges.AddedNodes, ValidateNode); Validator.AssertError(!updatesNotConverged, m_project.Network, "Possible infinite loop in memory block sizes."); if (!Validator.ValidationSucessfull) { throw new InvalidOperationException("Validation failed for the changed model."); } // Reschedule. Schedule(m_project, modelChanges.AddedNodes); // Init nodes IterateNodes(modelChanges.AddedNodes, InitNode); // Allocate memory IEnumerable <MyWorkingNode> nodesToAllocate = modelChanges.AddedNodes.Where(node => MyMemoryManager.Instance.IsRegistered(node)); IterateNodes(nodesToAllocate, AllocateNode); foreach (MyNode node in changersActivated) { EmitModelChanged(node); } }
private void SimulationHandler_StateChanged(object sender, MySimulationHandler.StateEventArgs e) { if (!Visible && !(m_mainForm.Project.World is SchoolWorld)) return; // time measurements if (m_currentLtStopwatch != null) if (e.NewState == MySimulationHandler.SimulationState.PAUSED) m_currentLtStopwatch.Stop(); else if (e.NewState == MySimulationHandler.SimulationState.RUNNING || e.NewState == MySimulationHandler.SimulationState.RUNNING_STEP) m_currentLtStopwatch.Start(); // workspace panel enable/disable if (e.NewState == MySimulationHandler.SimulationState.RUNNING || e.NewState == MySimulationHandler.SimulationState.RUNNING_STEP || e.NewState == MySimulationHandler.SimulationState.PAUSED) { disableLearningTaskPanel(); } else { enableLearningTaskPanel(); } // autosave if (e.NewState == MySimulationHandler.SimulationState.PAUSED || e.NewState == MySimulationHandler.SimulationState.STOPPED) if (Properties.School.Default.AutosaveEnabled) { if (String.IsNullOrEmpty(m_autosaveFilePath)) { string filename = GetAutosaveFilename(); m_autosaveFilePath = Path.Combine(Properties.School.Default.AutosaveFolder, filename); } ExportDataGridViewData(m_autosaveFilePath); } if (e.NewState == MySimulationHandler.SimulationState.STOPPED) m_autosaveFilePath = null; // buttons UpdateButtons(); }
public MyProjectRunner(MyLogLevel level = MyLogLevel.DEBUG) { MySimulation simulation = TypeMap.GetInstance <MySimulation>(); SimulationHandler = new MySimulationHandler(simulation); m_resultIdCounter = 0; SimulationHandler.ProgressChanged += SimulationHandler_ProgressChanged; SimulationHandler.StepPerformed += SimulationHandler_StepPerformed; m_monitors = new List <Tuple <int, uint, MonitorFunc> >(); m_results = new Hashtable(); Project = new MyProject(); var path = MyResources.GetEntryAssemblyPath(); if (MyConfiguration.ModulesSearchPath.Count == 0) { MyConfiguration.SetupModuleSearchPath(); } MyConfiguration.ProcessCommandParams(); try { if (MyConfiguration.Modules.Count == 0) { MyConfiguration.LoadModules(); } } catch (Exception e) { MyLog.WARNING.WriteLine(e.Message); throw; } MyLog.Level = level; }
private void StateChanged(object sender, MySimulationHandler.StateEventArgs e) { if (e.NewState == MySimulationHandler.SimulationState.STOPPED || e.NewState == MySimulationHandler.SimulationState.PAUSED) OpenFile(); m_continueEvent.Set(); }
public override void OnSimulationStateChanged(MySimulationHandler.StateEventArgs args) { PreviousState = args.OldState; CurrentState = args.NewState; if (Event != null) Event.Set(); }
public void OnStateChanged(object sender, MySimulationHandler.StateEventArgs args) { foreach (MyWorkingNode node in NodePartitioning.SelectMany(nodeList => nodeList)) node.OnSimulationStateChanged(args); }
void SimulationHandler_StateChanged(object sender, MySimulationHandler.StateEventArgs e) { Active = e.NewState != MySimulationHandler.SimulationState.STOPPED; if (!Active) { peekLabel.Visible = false; } CloseButton = e.NewState == MySimulationHandler.SimulationState.PAUSED || e.NewState == MySimulationHandler.SimulationState.STOPPED; if (Observer != null) { Observer.Active = Active; } Observer.TriggerViewReset(); glControl.Invalidate(); updateViewToolStripMenuItem.Enabled = snapshotToolStripMenuItem.Enabled = e.NewState == MySimulationHandler.SimulationState.PAUSED; }
private void SimulationHandler_StateChanged(object sender, MySimulationHandler.StateEventArgs e) { if (e.OldState != MySimulationHandler.SimulationState.STOPPED) return; richTextBox_messages.Clear(); FindGuiNodes(); }
void SimulationHandler_StateChanged(object sender, MySimulationHandler.StateEventArgs e) { toolStrip1.Enabled = e.NewState == MySimulationHandler.SimulationState.STOPPED; updateModelButton.Enabled = toolStrip1.Enabled; }
//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(); }
public MainForm() { this.Font = SystemFonts.MessageBoxFont; InitializeComponent(); MySimulation simulation = null; try { simulation = TypeMap.GetInstance<MySimulation>(); } catch (Exception e) { MessageBox.Show("An error occured when initializing simulation. Please make sure you have a supported CUDA-enabled graphics card and apropriate drivers." + "Technical details: " + e.Message, "Simulation Initialization Error", MessageBoxButtons.OK, MessageBoxIcon.Error); // this way you do not have to tweak form Close and Closing events and it works even with any worker threads still running Environment.Exit(1); } SimulationHandler = new MySimulationHandler(simulation); SimulationHandler.StateChanged += SimulationHandler_StateChanged; SimulationHandler.ProgressChanged += SimulationHandler_ProgressChanged; SimulationHandler.SimulationStopped += SimulationHandler_SimulationStopped; // must be created in advance to grab possible error logs ConsoleView = new ConsoleForm(this); var assemblyName = Assembly.GetExecutingAssembly().GetName(); MyLog.INFO.WriteLine(assemblyName.Name + " version " + assemblyName.Version); MyConfiguration.SetupModuleSearchPath(); MyConfiguration.ProcessCommandParams(); try { MyConfiguration.LoadModules(); } catch (Exception e) { MessageBox.Show(e.Message, "Fatal error occured during initialization", MessageBoxButtons.OK, MessageBoxIcon.Error); Environment.Exit(1); } UndoManager = new UndoManager(Settings.Default.UndoHistorySize); Documentation = new MyDocProvider(); foreach (MyModuleConfig module in MyConfiguration.Modules) { Documentation.LoadXMLDoc(module.Assembly); } NodePropertyView = new NodePropertyForm(this); MemoryBlocksView = new MemoryBlocksForm(this); TaskView = new TaskForm(this); TaskPropertyView = new TaskPropertyForm(this); DashboardPropertyView = new DashboardPropertyForm(this); SimulationHandler.StateChanged += DashboardPropertyView.OnSimulationStateChanged; // Link the Task and Node property views to the dashboard's PropertyChanged. DashboardPropertyView.PropertyValueChanged += RefreshPropertyViews; // Link the Node and Task property views' PropertyChanged to the dashboard so that it can refresh etc. NodePropertyView.PropertyChanged += DashboardPropertyView.OnPropertyExternallyChanged; TaskPropertyView.PropertyChanged += DashboardPropertyView.OnPropertyExternallyChanged; TaskView.PropertyChanged += DashboardPropertyView.OnPropertyExternallyChanged; GraphViews = new Dictionary<MyNodeGroup, GraphLayoutForm>(); TextEditors = new Dictionary<IScriptableNode, TextEditForm>(); ObserverViews = new List<ObserverForm>(); ValidationView = new ValidationForm(this, TypeMap.GetInstance<MyValidator>()); HelpView = new NodeHelpForm(this) { StartPosition = FormStartPosition.CenterScreen }; DebugView = new DebugForm(this); PopulateWorldList(); CreateNewProject(); CreateNetworkView(); m_views = new List<DockContent>() { NetworkView, DashboardPropertyView, NodePropertyView, MemoryBlocksView, TaskView, TaskPropertyView, ConsoleView, ValidationView, DebugView, HelpView }; foreach (var form in UIPlugins.GetBrainSimUIExtensions(this)) m_views.Add(form); foreach (DockContent view in m_views) { ToolStripMenuItem viewMenuItem = new ToolStripMenuItem(view.Text); viewMenuItem.Click += viewToolStripMenuItem_Click; viewMenuItem.Tag = view; viewMenuItem.Name = view.Text; viewToolStripMenuItem.DropDownItems.Add(viewMenuItem); } ((ToolStripMenuItem)viewToolStripMenuItem.DropDownItems.Find(HelpView.Text, false).First()).ShortcutKeys = Keys.F1; viewToolStripMenuItem.DropDownItems.Add(new ToolStripSeparator()); showHideObserversMenuItem = new ToolStripMenuItem("Show/Hide all observers"); showHideObserversMenuItem.ShortcutKeys = Keys.Control | Keys.H; showHideObserversMenuItem.Click += showHideObserversMenuItem_Click; showHideObserversMenuItem.Checked = true; viewToolStripMenuItem.DropDownItems.Add(showHideObserversMenuItem); ToolStripMenuItem resetViewsMenuItem = new ToolStripMenuItem("Reset Views Layout"); resetViewsMenuItem.ShortcutKeys = Keys.Control | Keys.W; resetViewsMenuItem.Click += resetViewsMenuItem_Click; viewToolStripMenuItem.DropDownItems.Add(resetViewsMenuItem); ToolStripMenuItem nodeSettingsMenuItem = new ToolStripMenuItem("Configure node selection..."); nodeSettingsMenuItem.ShortcutKeys = Keys.Control | Keys.L; nodeSettingsMenuItem.Click += nodeSettingsMenuItem_Click; viewToolStripMenuItem.DropDownItems.Add(nodeSettingsMenuItem); modeDropDownList.SelectedIndex = 0; AddTimerMenuItem(timerToolStripSplitButton, timerItem_Click, 0); AddTimerMenuItem(timerToolStripSplitButton, timerItem_Click, 10); AddTimerMenuItem(timerToolStripSplitButton, timerItem_Click, 20); AddTimerMenuItem(timerToolStripSplitButton, timerItem_Click, 50); AddTimerMenuItem(timerToolStripSplitButton, timerItem_Click, 100); AddTimerMenuItem(timerToolStripSplitButton, timerItem_Click, 500); timerItem_Click(timerToolStripSplitButton.DropDownItems[Settings.Default.StepDelay], EventArgs.Empty); AddTimerMenuItem(observerTimerToolButton, observerTimerItem_Click, 0); AddTimerMenuItem(observerTimerToolButton, observerTimerItem_Click, 20); AddTimerMenuItem(observerTimerToolButton, observerTimerItem_Click, 100); AddTimerMenuItem(observerTimerToolButton, observerTimerItem_Click, 500); AddTimerMenuItem(observerTimerToolButton, observerTimerItem_Click, 1000); AddTimerMenuItem(observerTimerToolButton, observerTimerItem_Click, 5000); observerTimerItem_Click(observerTimerToolButton.DropDownItems[Settings.Default.ObserverPeriod], EventArgs.Empty); PropertyDescriptor descriptor = TypeDescriptor.GetProperties(typeof(MyWorkingNode))["DataFolder"]; EditorAttribute editor = (EditorAttribute)descriptor.Attributes[typeof(EditorAttribute)]; editor.GetType().GetField("typeName", BindingFlags.NonPublic | BindingFlags.Instance).SetValue(editor, typeof(MyFolderDialog).AssemblyQualifiedName); editor.GetType().GetField("baseTypeName", BindingFlags.NonPublic | BindingFlags.Instance).SetValue(editor, typeof(UITypeEditor).AssemblyQualifiedName); autosaveTextBox.Text = Settings.Default.AutosaveInterval.ToString(); autosaveTextBox_Validating(this, new CancelEventArgs()); autosaveButton.Checked = Settings.Default.AutosaveEnabled; }
void SimulationHandler_StateChanged(object sender, MySimulationHandler.StateEventArgs e) { MySimulationHandler simulatinHandler = sender as MySimulationHandler; runToolButton.Enabled = simulatinHandler.CanStart; stepInButton.Enabled = simulatinHandler.CanStepInto; stepOutButton.Enabled = simulatinHandler.CanStepOut; stepOverButton.Enabled = simulatinHandler.CanStepOver; pauseToolButton.Enabled = simulatinHandler.CanPause; if (e.NewState == MySimulationHandler.SimulationState.PAUSED && simulatinHandler.Simulation.InDebugMode) { noDebugLabel.Visible = false; toolStrip.Enabled = true; if (m_executionPlan == null) { UpdateDebugListView(); } MyExecutionBlock currentBlock = simulatinHandler.Simulation.CurrentDebuggedBlocks[0]; m_selectedNodeView = null; if (currentBlock != null && currentBlock.CurrentChild != null) { m_selectedNodeView = debugTreeView.AllNodes.FirstOrDefault(node => (node.Tag is MyDebugNode && (node.Tag as MyDebugNode).Executable == currentBlock.CurrentChild)); }; debugTreeView.Invalidate(); //debugTreeView.Invoke((MethodInvoker)(() => debugTreeView.SelectedNode = m_selectedNodeView)); } else if (e.NewState == MySimulationHandler.SimulationState.STOPPED) { m_executionPlan = null; debugTreeView.Model = null; noDebugLabel.Visible = true; toolStrip.Enabled = false; if (this.IsFloat) { this.Hide(); } } }
public void FileCanBeReadWhenSimulationIsNotRunning() { string directory = Path.GetFullPath(@"Data\"); const string fileName = "csv_file_test.brain"; m_outputFileFullPath = Path.GetTempFileName(); var outputFileName = Path.GetFileName(m_outputFileFullPath); var outputFileDirectory = Path.GetDirectoryName(m_outputFileFullPath); string projectPath = directory + fileName; var simulation = new MyLocalSimulation(); // TODO(HonzaS): This should not be required! // The referenced assemblies get loaded only if a Type is required here. But since the serializer // is just looking for types by name, it doesn't force the runtime to load all of the assemblies. // In this case, we would miss the BasicNodes if the following line was deleted. // Two solutions: 1) Use the Managed Extensibility Framework or 2) load all referenced assemblies // explicitely (as a part of the BS testing framework). var csvNode = new MyCsvFileWriterNode(); MyProject project = MyProject.Deserialize(File.ReadAllText(projectPath), Path.GetDirectoryName(projectPath)); var handler = new MySimulationHandler(simulation) { Project = project }; // The CSV node MyNode node = project.Network.GetChildNodeById(6); PropertyInfo fileNameProperty = node.GetType().GetProperty("OutputFile", BindingFlags.Instance | BindingFlags.Public); fileNameProperty.SetValue(node, outputFileName); PropertyInfo directoryProperty = node.GetType().GetProperty("OutputDirectory", BindingFlags.Instance | BindingFlags.Public); directoryProperty.SetValue(node, outputFileDirectory); handler.UpdateMemoryModel(); handler.StateChanged += StateChanged; try { handler.StartSimulation(); m_continueEvent.WaitOne(); Assert.Throws<IOException>(() => { File.Open(m_outputFileFullPath, FileMode.Open, FileAccess.ReadWrite); }); // Every time we change simulation state, the StateChanged method gets notified. // We're changing the state several times here and the StateChanged methods checks that // the file that the Csv node uses is available for writing. // First, go through start->pause->stop. handler.PauseSimulation(); m_continueEvent.WaitOne(); handler.StopSimulation(); m_continueEvent.WaitOne(); // Now, try start->stop only. handler.StartSimulation(); m_continueEvent.WaitOne(); handler.StopSimulation(); m_continueEvent.WaitOne(); // The file should have been successfully opened three times - every time the simulation was paused or stopped. Assert.Equal(3, m_openCount); } finally { handler.Finish(); File.Delete(m_outputFileFullPath); m_outputFileFullPath = null; } }
private void SimulationHandler_SimulationStopped(object sender, MySimulationHandler.SimulationStoppedEventArgs args) { ValidationView.UpdateListView(); foreach (GraphLayoutForm graphView in GraphViews.Values) graphView.ReloadContent(); }
public MyProjectRunner(MyLogLevel level = MyLogLevel.DEBUG) { MySimulation simulation = TypeMap.GetInstance<MySimulation>(); SimulationHandler = new MySimulationHandler(simulation); m_resultIdCounter = 0; SimulationHandler.ProgressChanged += SimulationHandler_ProgressChanged; SimulationHandler.StepPerformed += SimulationHandler_StepPerformed; m_monitors = new List<Tuple<int, uint, MonitorFunc>>(); m_results = new Hashtable(); Project = new MyProject(); var path = MyResources.GetEntryAssemblyPath(); if (MyConfiguration.ModulesSearchPath.Count == 0) MyConfiguration.SetupModuleSearchPath(); MyConfiguration.ProcessCommandParams(); try { if (MyConfiguration.Modules.Count == 0) MyConfiguration.LoadModules(); } catch (Exception e) { MyLog.WARNING.WriteLine(e.Message); throw; } MyLog.Level = level; }
void SimulationHandler_StateChanged(object sender, MySimulationHandler.StateEventArgs e) { //UpdateConsole(); }
void SimulationHandler_StateChanged(object sender, MySimulationHandler.StateEventArgs e) { scintilla.Enabled = e.NewState == MySimulationHandler.SimulationState.STOPPED; SetupEditorStyle(); }
void SimulationHandler_StateChanged(object sender, MySimulationHandler.StateEventArgs e) { nodesToolStrip.Enabled = e.NewState == MySimulationHandler.SimulationState.STOPPED; updateModelButton.Enabled = nodesToolStrip.Enabled; if (e.NewState == MySimulationHandler.SimulationState.STOPPED) ResetNodeColours(); }
public void OnStateChanged(object sender, MySimulationHandler.StateEventArgs args) { foreach (MyWorkingNode node in AllNodes) node.OnSimulationStateChanged(args); }