Ensure that all models compile in headless mode

Author: ERSUCC

src/main/BackingModelManager.scala

@@ -4,7 +4,7 @@ import org.nlogo.ls.gui.{ GUILevelSpaceMenu, LevelSpaceMenu, ModelCodeTab, Model
 
 import org.nlogo.app.App
 import org.nlogo.app.codetab.CodeTab
-import org.nlogo.workspace.AbstractWorkspaceScala
+import org.nlogo.workspace.AbstractWorkspace
 
 import scala.collection.Map
 import scala.collection.parallel.mutable.ParHashMap
@@ -52,7 +52,7 @@ class BackingModelManager extends LSModelManager {
   }
 
   def registerTab(filePath: String, model: ChildModel)
-                 (f: AbstractWorkspaceScala => ModelCodeTab): Option[ModelCodeTab] = {
+                 (f: AbstractWorkspace => ModelCodeTab): Option[ModelCodeTab] = {
     if (backingModels.get(filePath).isDefined) {
       None
     } else {
@@ -63,7 +63,7 @@ class BackingModelManager extends LSModelManager {
   }
 
   def registerTab(filePath: String)
-                 (f: AbstractWorkspaceScala => ModelCodeTab): Option[ModelCodeTab] = {
+                 (f: AbstractWorkspace => ModelCodeTab): Option[ModelCodeTab] = {
     if (backingModels.get(filePath).isDefined) {
       None
     } else {
@@ -93,5 +93,5 @@ class HeadlessBackingModelManager extends LSModelManager {
   def removeTab(tab: ModelCodeTab): Unit = {}
   def existingTab(filePath: String): Option[ModelCodeTab] = None
   def registerTab(filePath: String)
-                 (f: AbstractWorkspaceScala => ModelCodeTab): Option[ModelCodeTab] = None
+                 (f: AbstractWorkspace => ModelCodeTab): Option[ModelCodeTab] = None
 }

src/main/ChildModel.scala

@@ -3,14 +3,14 @@ package org.nlogo.ls
 import javax.swing.{ JFrame, SwingUtilities }
 
 import org.nlogo.api.{ CommandRunnable, ExtensionException, Version, Workspace }
-import org.nlogo.workspace.AbstractWorkspaceScala
+import org.nlogo.workspace.AbstractWorkspace
 
 import scala.concurrent.ExecutionContext.Implicits.global
 import scala.concurrent.Future
 import scala.jdk.CollectionConverters.IterableHasAsScala
 
 abstract class ChildModel(val parentWorkspace: Workspace, val modelID: Int) {
-  lazy val evaluator = new Evaluator(modelID, name, workspace, parentWorkspace.asInstanceOf[AbstractWorkspaceScala])
+  lazy val evaluator = new Evaluator(modelID, name, workspace, parentWorkspace.asInstanceOf[AbstractWorkspace])
 
   private var _name: Option[String] = None
   def name_= (newName: String): Unit = {
@@ -46,7 +46,7 @@ abstract class ChildModel(val parentWorkspace: Workspace, val modelID: Int) {
   def frame: Option[JFrame]
 
   def setSpeed(d: Double): Unit
-  def workspace: AbstractWorkspaceScala
+  def workspace: AbstractWorkspace
 
   // can't change once model is loaded
   lazy val usesLevelSpace: Boolean =

src/main/Evaluator.scala

@@ -6,14 +6,24 @@ import org.nlogo.api.{ Context, MersenneTwisterFast, SimpleJobOwner, Workspace }
 import org.nlogo.core.{ AgentKind, LogoList, Nobody }
 import org.nlogo.nvm.{ ExclusiveJob, Procedure, Reporter }
 import org.nlogo.prim.{ _constboolean, _constdouble, _constlist, _conststring, _nobody }
-import org.nlogo.workspace.{ AbstractWorkspaceScala, Plotting }
+import org.nlogo.workspace.{ AbstractWorkspace, Plotting }
 
 object RNG {
-  def apply(ctx: Context): RNG = ctx.workspace match {
-    case p: Plotting  if p.plotRNG eq ctx.getRNG => PlotRNG
-    case w: Workspace if w.mainRNG eq ctx.getRNG => MainRNG
-    case w: Workspace if w.auxRNG  eq ctx.getRNG => MainRNG
-    case _ => LocalRNG
+  def apply(ctx: Context): RNG = {
+    if (ctx.workspace.workspaceContext.workspaceGUI) {
+      ctx.workspace match {
+        case p: Plotting  if p.plotRNG eq ctx.getRNG => PlotRNG
+        case w: Workspace if w.mainRNG eq ctx.getRNG => MainRNG
+        case w: Workspace if w.auxRNG  eq ctx.getRNG => MainRNG
+        case _ => LocalRNG
+      }
+    } else {
+      ctx.workspace match {
+        case w: Workspace if w.mainRNG eq ctx.getRNG => MainRNG
+        case w: Workspace if w.auxRNG  eq ctx.getRNG => MainRNG
+        case _ => LocalRNG
+      }
+    }
   }
 }
 
@@ -27,16 +37,22 @@ case object AuxRNG extends RNG {
   override def apply(ws: Workspace): MersenneTwisterFast = ws.auxRNG
 }
 case object PlotRNG extends RNG {
-  override def apply(ws: Workspace): MersenneTwisterFast = ws match {
-    case p: Plotting => p.plotRNG
-    case _ => ws.auxRNG
+  override def apply(ws: Workspace): MersenneTwisterFast = {
+    if (ws.workspaceContext.workspaceGUI) {
+      ws match {
+        case p: Plotting => p.plotRNG
+        case _ => ws.auxRNG
+      }
+    } else {
+      ws.auxRNG
+    }
   }
 }
 case object LocalRNG extends RNG {
   override def apply(ws: Workspace): MersenneTwisterFast = ws.mainRNG.clone
 }
 
-class Evaluator(modelID: Int, name: String, ws: AbstractWorkspaceScala, parentWS: AbstractWorkspaceScala) {
+class Evaluator(modelID: Int, name: String, ws: AbstractWorkspace, parentWS: AbstractWorkspace) {
 
   val mainOwner = new SimpleJobOwner(name, MainRNG(ws), AgentKind.Observer)
   val auxOwner = new SimpleJobOwner(name, AuxRNG(ws), AgentKind.Observer)

src/main/GUIPanel.scala

@@ -8,9 +8,9 @@ import org.nlogo.app.interfacetab.CommandCenter
 import org.nlogo.swing.{ ScrollPane, SplitPane, Transparent }
 import org.nlogo.theme.InterfaceColors
 import org.nlogo.window.{ Events, GUIWorkspace, TickCounterLabel }
-import org.nlogo.workspace.AbstractWorkspaceScala
+import org.nlogo.workspace.AbstractWorkspace
 
-abstract class ModelPanel(ws: AbstractWorkspaceScala, panel: JPanel, verticalScroll: Int, resizeWeight: Int)
+abstract class ModelPanel(ws: AbstractWorkspace, panel: JPanel, verticalScroll: Int, resizeWeight: Int)
 extends JPanel with Events.OutputEvent.Handler {
   setLayout(new BorderLayout)
 
@@ -91,5 +91,5 @@ extends ModelPanel(ws, panel, ScrollPaneConstants.VERTICAL_SCROLLBAR_ALWAYS, 1)
   }
 }
 
-class HeadlessPanel(ws: AbstractWorkspaceScala, panel: JPanel)
+class HeadlessPanel(ws: AbstractWorkspace, panel: JPanel)
 extends ModelPanel(ws, panel, ScrollPaneConstants.VERTICAL_SCROLLBAR_NEVER, 0)

src/main/HeadlessChildModel.scala

@@ -24,9 +24,13 @@ class HeadlessChildModel (parentWorkspace: AbstractWorkspace, path: String, mode
       null) {
 
     override def sendOutput(oo: OutputObject, toOutputArea: Boolean): Unit = {
-      frame.foreach { f => onEDT {
-        new org.nlogo.window.Events.OutputEvent(false, oo, false, !toOutputArea, System.currentTimeMillis).raise(f)
-      }}
+      if (LevelSpace.isHeadless) {
+        workspace.sendOutput(oo, toOutputArea)
+      } else {
+        frame.foreach { f => onEDT {
+          new org.nlogo.window.Events.OutputEvent(false, oo, false, !toOutputArea, System.currentTimeMillis).raise(f)
+        }}
+      }
     }
 
     override def runtimeError(owner: JobOwner, context: Context, instruction: Instruction, ex: Exception): Unit = {
@@ -54,12 +58,14 @@ class HeadlessChildModel (parentWorkspace: AbstractWorkspace, path: String, mode
     scheduledRepaint.setRepeats(false)
     // Since we never block on painting child models, we don't care if we have a world lock or not.
     override def updateDisplay(ignored: Boolean): Unit = {
-      frame.foreach { f =>
-        if (f.isVisible && !scheduledRepaint.isRunning) {
-          // Not that if we don't max(0) here, the conversion to int can underflow
-          val nextRepaint = (minTimeBetweenRepaints - timeSinceLastRepaint).max(0).toInt
-          scheduledRepaint.setDelay(nextRepaint)
-          scheduledRepaint.start()
+      if (!LevelSpace.isHeadless) {
+        frame.foreach { f =>
+          if (f.isVisible && !scheduledRepaint.isRunning) {
+            // Not that if we don't max(0) here, the conversion to int can underflow
+            val nextRepaint = (minTimeBetweenRepaints - timeSinceLastRepaint).max(0).toInt
+            scheduledRepaint.setDelay(nextRepaint)
+            scheduledRepaint.start()
+          }
         }
       }
     }
@@ -76,7 +82,8 @@ class HeadlessChildModel (parentWorkspace: AbstractWorkspace, path: String, mode
     workspace.requestDisplayUpdate(false)
   }
 
-  def isVisible: Boolean = frame.exists(_.isVisible)
+  def isVisible: Boolean =
+    !LevelSpace.isHeadless && frame.exists(_.isVisible)
 
   def setSpeed(d: Double): Unit = {}
 

src/main/LevelSpace.scala

@@ -165,8 +165,10 @@ class LevelSpace extends DefaultClassManager { // This can be accessed by both t
     }
 
   def updateModelMenu(): Unit = {
-    EventQueue.invokeLater { () =>
-      modelManager.updateChildModels(models)
+    if (!LevelSpace.isHeadless) {
+      EventQueue.invokeLater { () =>
+        modelManager.updateChildModels(models)
+      }
     }
   }
 

src/main/LevelSpaceMenu.scala

@@ -13,13 +13,13 @@ import org.nlogo.app.codetab.CodeTab
 import org.nlogo.awt.UserCancelException
 import org.nlogo.fileformat.FileFormat
 import org.nlogo.swing.{ FileDialog, Menu, MenuItem }
-import org.nlogo.workspace.{ AbstractWorkspaceScala, ModelsLibrary, ModelTracker, SaveModel }
+import org.nlogo.workspace.{ AbstractWorkspace, ModelsLibrary, ModelTracker, SaveModel }
 
 trait ModelManager {
   def removeTab(tab: ModelCodeTab): Unit
   def existingTab(filePath: String): Option[CodeTab]
   def registerTab(filePath: String)
-                 (f: AbstractWorkspaceScala => ModelCodeTab): Option[ModelCodeTab]
+                 (f: AbstractWorkspace => ModelCodeTab): Option[ModelCodeTab]
 }
 
 trait LevelSpaceMenu extends JMenu

src/main/ModelCodeTab.scala

@@ -11,11 +11,11 @@ import org.nlogo.core.{ I18N, Model }
 import org.nlogo.fileformat.{ FailedConversionResult, FileFormat }
 import org.nlogo.swing.OptionPane
 import org.nlogo.window.Events.ModelSavedEvent
-import org.nlogo.workspace.{ AbstractWorkspaceScala, OpenModel, OpenModelFromURI, SaveModel, ModelsLibrary }
+import org.nlogo.workspace.{ AbstractWorkspace, ModelsLibrary, ModelTracker, OpenModel, OpenModelFromURI, SaveModel }
 
 import java.nio.file.Paths
 
-class ModelCodeTab(workspace: AbstractWorkspaceScala, tabManager: TabManager, modelManager: ModelManager)
+class ModelCodeTab(workspace: AbstractWorkspace, tabManager: TabManager, modelManager: ModelManager)
 extends CodeTab(workspace, tabManager)
 with ModelSavedEvent.Handler {
   val tabName      = workspace.getModelFileName
@@ -105,11 +105,16 @@ with ModelSavedEvent.Handler {
     }
     currentModel = currentModel.map(_.copy(code = innerSource)) orElse Some(Model(code = innerSource))
     currentModel.foreach { model =>
-      SaveModel(model, loader, controller, workspace, Version).foreach {
-        _.apply().foreach { _ =>
-          changedSourceWarning()
-          dirty = false
-        }
+      workspace match {
+        case tracker: ModelTracker =>
+          SaveModel(model, loader, controller, workspace.asInstanceOf[ModelTracker], Version).foreach {
+            _.apply().foreach { _ =>
+              changedSourceWarning()
+              dirty = false
+            }
+          }
+
+        case _ =>
       }
     }
   }

src/main/NotifyingJob.scala

@@ -3,10 +3,10 @@ package org.nlogo.ls
 import org.nlogo.agent.AgentSet
 import org.nlogo.api.JobOwner
 import org.nlogo.nvm.{ConcurrentJob, HaltException, Job, Procedure}
-import org.nlogo.workspace.AbstractWorkspaceScala
+import org.nlogo.workspace.AbstractWorkspace
 
 class NotifyingJob(override val notifyObject: AnyRef,
-                   workspace: AbstractWorkspaceScala,
+                   workspace: AbstractWorkspace,
                    owner: JobOwner,
                    agentSet: AgentSet,
                    procedure: Procedure)