Processing Gradle Plugin

.gitignore

@@ -66,6 +66,19 @@ gen-external-apklibs
 hs_err_pid*
 replay_pid*
 
+# Maven ignores
+.kotlin
+.gradle
+.build/
+/core/build/
+/build/publish/
+/app/build
+/java/build/
+/build/reports
+/java/bin
+/java/libraries/svg/bin
+/java/preprocessor/build
+/java/lsp/build
 ### Gradle ###
 .gradle
 **/build/
@@ -123,4 +136,16 @@ generated/
 !java/libraries/serial/library/jssc.jar
 /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
+/java/gradle/hotreload/build
+*.iml

app/utils/build.gradle.kts

@@ -1,5 +1,6 @@
 plugins {
     id("java")
+    alias(libs.plugins.mavenPublish)
 }
 
 repositories {
@@ -11,6 +12,15 @@ dependencies {
     testImplementation("org.junit.jupiter:junit-jupiter")
 }
 
+publishing{
+    repositories{
+        maven {
+            name = "App"
+            url = uri(project(":app").layout.buildDirectory.dir("resources-bundled/common/repository").get().asFile.absolutePath)
+        }
+    }
+}
+
 tasks.test {
     useJUnitPlatform()
 }

core/build.gradle.kts

@@ -15,6 +15,7 @@ sourceSets{
     main{
         java{
             srcDirs("src")
+            exclude("**/*.jnilib")
         }
         resources{
             srcDirs("src")
@@ -34,10 +35,21 @@ dependencies {
 
     testImplementation(libs.junit)
 }
+publishing{
+    repositories{
+        maven {
+            name = "App"
+            url = uri(project(":app").layout.buildDirectory.dir("resources-bundled/common/repository").get().asFile.absolutePath)
+        }
+    }
+}
 
 mavenPublishing{
     publishToMavenCentral(SonatypeHost.CENTRAL_PORTAL)
-    signAllPublications()
+
+    // Only sign if signing is set up
+    if(project.hasProperty("signing.keyId") || project.hasProperty("signing.signingInMemoryKey"))
+        signAllPublications()
 
     pom{
         name.set("Processing Core")
@@ -77,3 +89,6 @@ tasks.withType<Jar> {
 tasks.compileJava{
     options.encoding = "UTF-8"
 }
+tasks.javadoc{
+    options.encoding = "UTF-8"
+}

core/src/processing/core/PApplet.java

@@ -705,7 +705,7 @@ public class PApplet implements PConstants {
   protected boolean exitCalled;
 
   // ok to be static because it's not possible to mix enabled/disabled
-  static protected boolean disableAWT;
+  static protected boolean disableAWT = System.getProperty("processing.awt.disable", "false").equals("true");;
 
   // messages to send if attached as an external vm
 
@@ -9940,19 +9940,21 @@ static public void runSketch(final String[] args,
       System.exit(1);
     }
 
-    boolean external = false;
-    int[] location = null;
-    int[] editorLocation = null;
+    boolean external = System.getProperty("processing.external", "false").equals("true");;
+    int[] location = System.getProperty("processing.location", null) != null ?
+      parseInt(split(System.getProperty("processing.location"), ',')) : null;
 
+    int[] editorLocation = System.getProperty("processing.editor.location", null) != null ?
+      parseInt(split(System.getProperty("processing.editor.location"), ',')) : null;
     String name = null;
     int windowColor = 0;
     int stopColor = 0xff808080;
-    boolean hideStop = false;
+    boolean hideStop = System.getProperty("processing.stop.hide", "false").equals("true");
 
     int displayNum = -1;  // use default
-    boolean present = false;
-    boolean fullScreen = false;
-    float uiScale = 0;
+    boolean present = System.getProperty("processing.present", "false").equals("true");
+    boolean fullScreen = System.getProperty("processing.fullscreen", "false").equals("true");
+    float uiScale = parseInt(System.getProperty("processing.uiScale", "0"), 0);
 
     String param, value;
     String folder = calcSketchPath();

java/gradle/build.gradle.kts

@@ -0,0 +1,41 @@
+plugins{
+    `java-gradle-plugin`
+    alias(libs.plugins.gradlePublish)
+
+    kotlin("jvm") version libs.versions.kotlin
+}
+
+repositories {
+    mavenCentral()
+    maven("https://jogamp.org/deployment/maven")
+}
+
+dependencies{
+    implementation(project(":java:preprocessor"))
+
+    implementation(libs.composeGradlePlugin)
+    implementation(libs.kotlinGradlePlugin)
+    implementation(libs.kotlinComposePlugin)
+
+    testImplementation(project(":core"))
+    testImplementation(libs.junit)
+}
+
+// TODO: CI/CD for publishing the plugin to the Gradle Plugin Portal
+gradlePlugin{
+    plugins{
+        create("processing.java"){
+            id = "org.processing.java"
+            implementationClass = "org.processing.java.gradle.ProcessingPlugin"
+        }
+    }
+}
+publishing{
+    repositories{
+        mavenLocal()
+        maven {
+            name = "App"
+            url = uri(project(":app").layout.buildDirectory.dir("resources-bundled/common/repository").get().asFile.absolutePath)
+        }
+    }
+}

java/gradle/example/brightness.pde

@@ -0,0 +1,28 @@
+/**
+ * Brightness
+ * by Rusty Robison.
+ *
+ * Brightness is the relative lightness or darkness of a color.
+ * Move the cursor vertically over each bar to alter its brightness.
+ */
+
+int barWidth = 20;
+int lastBar = -1;
+
+
+void setup() {
+  size(640, 360, P2D);
+  colorMode(HSB, width, 100, height);
+  noStroke();
+  background(0);
+}
+
+void draw() {
+  int whichBar = mouseX / barWidth;
+  if (whichBar != lastBar) {
+    int barX = whichBar * barWidth;
+    fill(barX, 100, mouseY);
+    rect(barX, 0, barWidth, height);
+    lastBar = whichBar;
+  }
+}

java/gradle/example/build.gradle.kts

@@ -0,0 +1,3 @@
+plugins{
+    id("org.processing.java")
+}

java/gradle/example/settings.gradle.kts

@@ -0,0 +1,5 @@
+rootProject.name = "processing-gradle-plugin-demo"
+
+pluginManagement {
+    includeBuild("../../../")
+}

java/gradle/src/main/kotlin/DependenciesTask.kt

@@ -0,0 +1,79 @@
+package org.processing.java.gradle
+
+import org.gradle.api.DefaultTask
+import org.gradle.api.GradleException
+import org.gradle.api.file.RegularFileProperty
+import org.gradle.api.tasks.InputFile
+import org.gradle.api.tasks.TaskAction
+import java.io.File
+import java.io.ObjectInputStream
+
+/*
+* The DependenciesTask resolves the dependencies for the sketch based on the libraries used
+ */
+abstract class DependenciesTask: DefaultTask() {
+    @InputFile
+    val librariesMetaData: RegularFileProperty = project.objects.fileProperty()
+
+    @InputFile
+    val sketchMetaData: RegularFileProperty = project.objects.fileProperty()
+
+    init{
+        librariesMetaData.convention(project.layout.buildDirectory.file("processing/libraries"))
+        sketchMetaData.convention(project.layout.buildDirectory.file("processing/sketch"))
+    }
+
+    @TaskAction
+    fun execute() {
+        val sketchMetaFile = sketchMetaData.get().asFile
+        val librariesMetaFile = librariesMetaData.get().asFile
+
+        val libraries = librariesMetaFile.inputStream().use { input ->
+            ObjectInputStream(input).readObject() as ArrayList<LibrariesTask.Library>
+        }
+
+        val sketch = sketchMetaFile.inputStream().use { input ->
+            ObjectInputStream(input).readObject() as PDETask.SketchMeta
+        }
+
+        val dependencies = mutableSetOf<File>()
+
+        // Loop over the import statements in the sketch and import the relevant jars from the libraries
+        sketch.importStatements.forEach import@{ statement ->
+            libraries.forEach { library ->
+                library.jars.forEach { jar ->
+                    jar.classes.forEach { className ->
+                        if (className.startsWith(statement)) {
+                            dependencies.addAll(library.jars.map { it.path } )
+                            return@import
+                        }
+                    }
+                }
+            }
+        }
+        project.dependencies.add("implementation",  project.files(dependencies) )
+
+        // TODO: Mutating the dependencies of configuration ':implementation' after it has been resolved or consumed. This
+
+        // TODO: Add only if user is compiling for P2D or P3D
+        // Add JOGL and Gluegen dependencies
+        project.dependencies.add("runtimeOnly", "org.jogamp.jogl:jogl-all-main:2.5.0")
+        project.dependencies.add("runtimeOnly", "org.jogamp.gluegen:gluegen-rt:2.5.0")
+
+        val os = System.getProperty("os.name").lowercase()
+        val arch = System.getProperty("os.arch").lowercase()
+
+        val variant = when {
+            os.contains("mac") -> "macosx-universal"
+            os.contains("win") && arch.contains("64") -> "windows-amd64"
+            os.contains("linux") && arch.contains("aarch64") -> "linux-aarch64"
+            os.contains("linux") && arch.contains("arm") -> "linux-arm"
+            os.contains("linux") && arch.contains("amd64") -> "linux-amd64"
+            else -> throw GradleException("Unsupported OS/architecture: $os / $arch")
+        }
+
+        project.dependencies.add("runtimeOnly", "org.jogamp.gluegen:gluegen-rt:2.5.0:natives-$variant")
+        project.dependencies.add("runtimeOnly", "org.jogamp.jogl:nativewindow:2.5.0:natives-$variant")
+        project.dependencies.add("runtimeOnly", "org.jogamp.jogl:newt:2.5.0:natives-$variant")
+    }
+}

java/gradle/src/main/kotlin/LibrariesTask.kt

@@ -0,0 +1,81 @@
+package org.processing.java.gradle
+
+import org.gradle.api.DefaultTask
+import org.gradle.api.file.ConfigurableFileCollection
+import org.gradle.api.file.RegularFileProperty
+import org.gradle.api.tasks.InputFiles
+import org.gradle.api.tasks.OutputFile
+import org.gradle.api.tasks.TaskAction
+import java.io.File
+import java.io.ObjectOutputStream
+import java.util.jar.JarFile
+
+/*
+The libraries task scans the sketchbook libraries folder for all the libraries
+This task stores the resulting information in a file that can be used later to resolve dependencies
+ */
+abstract class LibrariesTask : DefaultTask() {
+
+    @InputFiles
+    val libraryDirectories: ConfigurableFileCollection = project.files()
+
+    @OutputFile
+    val librariesMetaData: RegularFileProperty = project.objects.fileProperty()
+
+    init{
+        librariesMetaData.convention { project.gradle.gradleUserHomeDir.resolve("common/processing/libraries") }
+    }
+
+     data class Jar(
+        val path: File,
+        val classes: List<String>
+    ) : java.io.Serializable
+
+    data class Library(
+        val jars: List<Jar>
+    ) : java.io.Serializable
+
+    @TaskAction
+    fun execute() {
+        val output = libraryDirectories.flatMap { librariesDirectory ->
+            if (!librariesDirectory.exists()) {
+                logger.error("Libraries directory (${librariesDirectory.path}) does not exist. Libraries will not be imported.")
+                return@flatMap emptyList()
+            }
+            val libraries = librariesDirectory
+                .listFiles { file -> file.isDirectory }
+                ?.map { folder ->
+                    // Find all the jars in the sketchbook
+                    val jars = folder.resolve("library")
+                        .listFiles{ file -> file.extension == "jar" }
+                        ?.map{ file ->
+
+                            // Inside each jar, look for the defined classes
+                            val jar = JarFile(file)
+                            val classes = jar.entries().asSequence()
+                                .filter { entry -> entry.name.endsWith(".class") }
+                                .map { entry -> entry.name }
+                                .map { it.substringBeforeLast('/').replace('/', '.') }
+                                .distinct()
+                                .toList()
+
+                            // Return a reference to the jar and its classes
+                            return@map Jar(
+                                path = file,
+                                classes = classes
+                            )
+                        }?: emptyList()
+
+                    // Save the parsed jars and which folder
+                    return@map Library(
+                        jars = jars
+                    )
+                }?: emptyList()
+
+            return@flatMap libraries
+        }
+        val meta = ObjectOutputStream(librariesMetaData.get().asFile.outputStream())
+        meta.writeObject(output)
+        meta.close()
+    }
+}