processing
diff --git a/‎.gitignore‎
Lines changed: 16 additions & 9 deletions b/‎.gitignore‎
Lines changed: 16 additions & 9 deletions
diff --git a/‎.idea/jarRepositories.xml‎
Lines changed: 10 additions & 0 deletions b/‎.idea/jarRepositories.xml‎
Lines changed: 10 additions & 0 deletions
diff --git a/‎app/ant/processing/app/gradle/GradleService.java‎
Lines changed: 15 additions & 0 deletions b/‎app/ant/processing/app/gradle/GradleService.java‎
Lines changed: 15 additions & 0 deletions
diff --git a/‎app/build.gradle.kts‎
Lines changed: 21 additions & 30 deletions b/‎app/build.gradle.kts‎
Lines changed: 21 additions & 30 deletions
diff --git a/‎app/src/main/resources/defaults.txt‎
Lines changed: 3 additions & 0 deletions b/‎app/src/main/resources/defaults.txt‎
Lines changed: 3 additions & 0 deletions
diff --git a/‎app/src/processing/app/Language.java‎
Lines changed: 0 additions & 1 deletion b/‎app/src/processing/app/Language.java‎
Lines changed: 0 additions & 1 deletion
diff --git a/‎app/src/processing/app/Preferences.java‎
Lines changed: 2 additions & 0 deletions b/‎app/src/processing/app/Preferences.java‎
Lines changed: 2 additions & 0 deletions
diff --git a/‎app/src/processing/app/Processing.kt‎
Lines changed: 3 additions & 1 deletion b/‎app/src/processing/app/Processing.kt‎
Lines changed: 3 additions & 1 deletion
diff --git a/‎app/src/processing/app/gradle/Debugger.kt‎
Lines changed: 43 additions & 0 deletions b/‎app/src/processing/app/gradle/Debugger.kt‎
Lines changed: 43 additions & 0 deletions
diff --git a/‎app/src/processing/app/gradle/Exceptions.kt‎
Lines changed: 103 additions & 0 deletions b/‎app/src/processing/app/gradle/Exceptions.kt‎
Lines changed: 103 additions & 0 deletions
@@ -98,20 +98,27 @@ bin-test
 processing-examples
 
 # Maven ignores
+.kotlin
 .gradle
-core/build/
-build/publish/
-app/build
-java/build/
+.build/
+/core/build/
+/build/publish/
+/app/build
+/java/build/
 /build/reports
 /java/bin
 /java/libraries/svg/bin
 /java/preprocessor/build
 /java/lsp/build
-/.kotlin/sessions
-/core/examples/build
-
-.build/
-/app/windows/obj
 /java/gradle/build
+/core/examples/build
 /java/gradle/example/.processing
+/app/windows/obj
+/java/android/example/build
+/java/android/example/.processing
+/java/gradle/example/build
+/java/gradle/example/gradle/wrapper/gradle-wrapper.jar
+/java/gradle/example/gradle/wrapper/gradle-wrapper.properties
+/java/gradle/example/gradlew
+/java/gradle/example/gradlew.bat
+/java/gradle/example/.kotlin/errors
@@ -0,0 +1,15 @@
+package processing.app.gradle;
+
+import processing.app.ui.Editor;
+
+public class GradleService {
+    public GradleService(Editor editor) { }
+
+    public void setEnabled(boolean enabled) {}
+    public boolean getEnabled() { return false; }
+    public void prepare(){}
+    public void run() {}
+    public void export(){}
+    public void stop() {}
+    public void startService() {}
+}
@@ -1,6 +1,8 @@
 import org.gradle.internal.jvm.Jvm
+import org.gradle.kotlin.dsl.support.zipTo
 import org.gradle.internal.os.OperatingSystem
 import org.gradle.nativeplatform.platform.internal.DefaultNativePlatform
+import org.jetbrains.compose.ExperimentalComposeLibrary
 import org.jetbrains.compose.desktop.application.dsl.TargetFormat
 import org.jetbrains.compose.desktop.application.tasks.AbstractJPackageTask
 import org.jetbrains.compose.internal.de.undercouch.gradle.tasks.download.Download
@@ -49,14 +51,18 @@ compose.desktop {
     application {
         mainClass = "processing.app.ProcessingKt"
 
-        jvmArgs(*listOf(
-            Pair("processing.version", rootProject.version),
-            Pair("processing.revision", findProperty("revision") ?: Int.MAX_VALUE),
-            Pair("processing.contributions.source", "https://contributions.processing.org/contribs"),
-            Pair("processing.download.page", "https://processing.org/download/"),
-            Pair("processing.download.latest", "https://processing.org/download/latest.txt"),
-            Pair("processing.tutorials", "https://processing.org/tutorials/"),
-        ).map { "-D${it.first}=${it.second}" }.toTypedArray())
+
+        val variables = mapOf(
+            "processing.group" to (rootProject.group.takeIf { it != "" } ?: "processing"),
+            "processing.version" to rootProject.version,
+            "processing.revision" to (findProperty("revision") ?: Int.MAX_VALUE),
+            "processing.contributions.source" to "https://contributions.processing.org/contribs",
+            "processing.download.page" to "https://processing.org/download/",
+            "processing.download.latest" to "https://processing.org/download/latest.txt",
+            "processing.tutorials" to "https://processing.org/tutorials/"
+        )
+
+        jvmArgs(*variables.entries.map { "-D${it.key}=${it.value}" }.toTypedArray())
 
         nativeDistributions{
             modules("jdk.jdi", "java.compiler", "jdk.accessibility", "java.management.rmi", "java.scripting")
@@ -110,20 +116,21 @@ dependencies {
     implementation(compose.ui)
     implementation(compose.components.resources)
     implementation(compose.components.uiToolingPreview)
+    implementation(compose.materialIconsExtended)
 
     implementation(compose.desktop.currentOs)
 
     implementation(libs.compottie)
     implementation(libs.kaml)
     implementation(libs.markdown)
     implementation(libs.markdownJVM)
+    implementation(gradleApi())
+    implementation(libs.clikt)
 
     testImplementation(kotlin("test"))
     testImplementation(libs.mockitoKotlin)
     testImplementation(libs.junitJupiter)
     testImplementation(libs.junitJupiterParams)
-
-    implementation(libs.clikt)
 }
 
 tasks.test {
@@ -405,23 +412,6 @@ tasks.register<Copy>("includeJavaModeResources") {
     from(java.layout.buildDirectory.dir("resources-bundled"))
     into(composeResources("../"))
 }
-// TODO: Move to java mode
-tasks.register<Copy>("renameWindres") {
-    dependsOn("includeSharedAssets","includeJavaModeResources")
-    val dir = composeResources("modes/java/application/launch4j/bin/")
-    val os = DefaultNativePlatform.getCurrentOperatingSystem()
-    val platform = when {
-        os.isWindows -> "windows"
-        os.isMacOsX -> "macos"
-        else -> "linux"
-    }
-    from(dir) {
-        include("*-$platform*")
-        rename("(.*)-$platform(.*)", "$1$2")
-    }
-    duplicatesStrategy = DuplicatesStrategy.INCLUDE
-    into(dir)
-}
 tasks.register("includeProcessingResources"){
     dependsOn(
         "includeJdk",
@@ -430,8 +420,7 @@ tasks.register("includeProcessingResources"){
         "includeSharedAssets",
         "includeProcessingExamples",
         "includeProcessingWebsiteExamples",
-        "includeJavaModeResources",
-        "renameWindres"
+        "includeJavaModeResources"
     )
     finalizedBy("signResources")
 }
@@ -510,9 +499,9 @@ tasks.register("signResources"){
         }
         file(composeResources("Info.plist")).delete()
     }
+}
 
 
-}
 tasks.register("setExecutablePermissions") {
     description = "Sets executable permissions on binaries in Processing.app resources"
     group = "compose desktop"
@@ -537,6 +526,8 @@ tasks.register("setExecutablePermissions") {
 afterEvaluate {
     tasks.named("prepareAppResources").configure {
         dependsOn("includeProcessingResources")
+        // Make sure all libraries are bundled in the maven repository distributed with the app
+        dependsOn(listOf("core","java:preprocessor", "java:gradle").map { project(":$it").tasks.named("publishAllPublicationsToAppRepository") })
     }
     tasks.named("createDistributable").configure {
         finalizedBy("setExecutablePermissions")
 
@@ -186,6 +186,9 @@ console.temp.days = 7
 console.scrollback.lines = 500
 console.scrollback.chars = 40000
 
+# run java sketches with Gradle aka the Modern Build System
+run.use_gradle = false
+
 # Any additional Java options when running.
 # If you change this and can't run things, it's your own durn fault.
 run.options =
 
@@ -183,7 +183,6 @@ static public Language init() {
     return instance;
   }
 
-
   static private String get(String key) {
     LanguageBundle bundle = init().bundle;
 
 
@@ -393,6 +393,8 @@ static public String getSketchbookPath() {
 
 
   static protected void setSketchbookPath(String path) {
+    // Unify path seperator for all platforms
+    path = path.replace(File.separatorChar, '/');
     set("sketchbook.path.four", path); //$NON-NLS-1$
   }
 }
@@ -10,6 +10,7 @@ import com.github.ajalt.clikt.parameters.arguments.multiple
 import com.github.ajalt.clikt.parameters.options.flag
 import com.github.ajalt.clikt.parameters.options.help
 import com.github.ajalt.clikt.parameters.options.option
+import processing.app.gradle.api.Sketch
 import processing.app.ui.Start
 
 class Processing: SuspendingCliktCommand("processing"){
@@ -40,7 +41,8 @@ suspend fun main(args: Array<String>){
    Processing()
         .subcommands(
             LSP(),
-            LegacyCLI(args)
+            LegacyCLI(args),
+            Sketch()
         )
         .main(args)
 }
 
@@ -0,0 +1,43 @@
+package processing.app.gradle
+
+import com.sun.jdi.Bootstrap
+import com.sun.jdi.VirtualMachine
+import com.sun.jdi.connect.AttachingConnector
+import kotlinx.coroutines.delay
+import processing.app.Messages
+import kotlin.time.Duration.Companion.seconds
+import kotlin.time.TimeSource
+
+class Debugger {
+    companion object {
+        suspend fun connect(port: Int?): VirtualMachine? {
+            try {
+                Messages.log("Attaching to VM $port")
+                val connector = Bootstrap.virtualMachineManager().allConnectors()
+                    .firstOrNull { it.name() == "com.sun.jdi.SocketAttach" }
+                        as AttachingConnector?
+                    ?: throw IllegalStateException("No socket attach connector found")
+                val args = connector.defaultArguments()
+                args["port"]?.setValue(port?.toString() ?: "5005")
+
+                // Try to attach the debugger, retrying if it fails
+                val start = TimeSource.Monotonic.markNow()
+                while (start.elapsedNow() < 10.seconds) {
+                    try {
+                        val sketch = connector.attach(args)
+                        sketch.resume()
+                        Messages.log("Attached to VM: ${sketch.name()}")
+                        return sketch
+                    } catch (e: Exception) {
+                        Messages.log("Error while attaching to VM: ${e.message}... Retrying")
+                    }
+                    delay(250)
+                }
+            } catch (e: Exception) {
+                Messages.log("Error while attaching to VM: ${e.message}")
+                return null
+            }
+            return null
+        }
+    }
+}
@@ -0,0 +1,103 @@
+package processing.app.gradle
+
+import com.sun.jdi.ObjectReference
+import com.sun.jdi.StackFrame
+import com.sun.jdi.StringReference
+import com.sun.jdi.VirtualMachine
+import com.sun.jdi.event.ExceptionEvent
+import com.sun.jdi.request.EventRequest
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
+import processing.app.Messages
+
+// TODO: Consider adding a panel to the footer
+class Exceptions {
+    companion object {
+        suspend fun listen(vm: VirtualMachine) {
+            try {
+                val manager = vm.eventRequestManager()
+
+                val request = manager.createExceptionRequest(null, false, true)
+                request.setSuspendPolicy(EventRequest.SUSPEND_EVENT_THREAD)
+                request.enable()
+
+                val queue = vm.eventQueue()
+                while (true) {
+                    val eventSet = queue.remove()
+                    for (event in eventSet) {
+                        if (event is ExceptionEvent) {
+                            printExceptionDetails(event)
+                            event.thread().resume()
+                        }
+                    }
+                    eventSet.resume()
+                    delay(10)
+                }
+            } catch (e: Exception) {
+                Messages.log("Error while listening for exceptions: ${e.message}")
+            }
+        }
+
+        fun printExceptionDetails(event: ExceptionEvent) {
+            val exception = event.exception()
+            val thread = event.thread()
+            val location = event.location()
+            val stackFrames = thread.frames()
+
+            println("\n🚨 Exception Caught 🚨")
+            println("Type       : ${exception.referenceType().name()}")
+            // TODO: Fix exception message retrieval
+//        println("Message    : ${getExceptionMessage(exception)}")
+            println("Thread     : ${thread.name()}")
+            println("Location   : ${location.sourcePath()}:${location.lineNumber()}\n")
+
+            // TODO: Map to .pde file again
+            // TODO: Communicate back to Editor
+
+            // Separate stack frames
+            val userFrames = mutableListOf<StackFrame>()
+            val processingFrames = mutableListOf<StackFrame>()
+
+            stackFrames.forEach { frame ->
+                val className = frame.location().declaringType().name()
+                if (className.startsWith("processing.")) {
+                    processingFrames.add(frame)
+                } else {
+                    userFrames.add(frame)
+                }
+            }
+
+            // Print user frames first
+            println("🔍 Stacktrace (Your Code First):")
+            userFrames.forEachIndexed { index, frame -> printStackFrame(index, frame) }
+
+            // Print Processing frames second
+            if (processingFrames.isNotEmpty()) {
+                println("\n🔧 Processing Stacktrace (Hidden Initially):")
+                processingFrames.forEachIndexed { index, frame -> printStackFrame(index, frame) }
+            }
+
+            println("──────────────────────────────────\n")
+        }
+
+        fun printStackFrame(index: Int, frame: StackFrame) {
+            val location = frame.location()
+            val method = location.method()
+            println(
+                "   #$index ${location.sourcePath()}:${location.lineNumber()} -> ${
+                    method.declaringType().name()
+                }.${method.name()}()"
+            )
+        }
+
+        // Extracts the exception's message
+        fun getExceptionMessage(exception: ObjectReference): String {
+            val messageMethod = exception.referenceType().methodsByName("getMessage").firstOrNull() ?: return "Unknown"
+            val messageValue =
+                exception.invokeMethod(null, messageMethod, emptyList(), ObjectReference.INVOKE_SINGLE_THREADED)
+            return (messageValue as? StringReference)?.value() ?: "Unknown"
+        }
+    }
+}
Original file line number	Diff line number	Diff line change
`@@ -183,7 +183,6 @@ static public Language init() {`
`183`	`183`	`return instance;`
`184`	`184`	`}`
`185`	`185`
`186`		`-`
`187`	`186`	`static private String get(String key) {`
`188`	`187`	`LanguageBundle bundle = init().bundle;`
`189`	`188`
Original file line number	Diff line number	Diff line change
`@@ -393,6 +393,8 @@ static public String getSketchbookPath() {`
`393`	`393`
`394`	`394`
`395`	`395`	`static protected void setSketchbookPath(String path) {`
	`396`	`+ // Unify path seperator for all platforms`
	`397`	`+ path = path.replace(File.separatorChar, '/');`
`396`	`398`	`set("sketchbook.path.four", path); //$NON-NLS-1$`
`397`	`399`	`}`
`398`	`400`	`}`