Add PDE window utilities for Compose and Swing

app/build.gradle.kts

@@ -1,6 +1,7 @@
 import org.gradle.internal.jvm.Jvm
 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
@@ -119,6 +120,8 @@ dependencies {
  implementation(libs.markdown)
  implementation(libs.markdownJVM)
 
+ @OptIn(ExperimentalComposeLibrary::class)
+ testImplementation(compose.uiTest)
  testImplementation(kotlin("test"))
  testImplementation(libs.mockitoKotlin)
  testImplementation(libs.junitJupiter)

app/src/processing/app/ui/Editor.java

@@ -1057,6 +1057,7 @@ public void buildDevelopMenu(){
  var updateTrigger = new JMenuItem(Language.text("menu.develop.check_for_updates"));
  updateTrigger.addActionListener(e -> {
  Preferences.unset("update.last");
+ Preferences.setInteger("update.beta_welcome", 0);
  new UpdateCheck(base);
  });
  developMenu.add(updateTrigger);

app/src/processing/app/ui/WelcomeToBeta.kt

@@ -41,6 +41,8 @@ import processing.app.Base.getVersionName
 import processing.app.ui.theme.LocalLocale
 import processing.app.ui.theme.LocalTheme
 import processing.app.ui.theme.Locale
+import processing.app.ui.theme.PDEComposeWindow
+import processing.app.ui.theme.PDESwingWindow
 import processing.app.ui.theme.ProcessingTheme
 import java.awt.Cursor
 import java.awt.Dimension
@@ -54,46 +56,20 @@ import javax.swing.SwingUtilities
 
 class WelcomeToBeta {
  companion object{
- val windowSize = Dimension(400, 200)
- val windowTitle = Locale()["beta.window.title"]
-
  @JvmStatic
  fun showWelcomeToBeta() {
- val mac = SystemInfo.isMacFullWindowContentSupported
  SwingUtilities.invokeLater {
- JFrame(windowTitle).apply {
- val close = {
- Preferences.set("update.beta_welcome", getRevision().toString())
- dispose()
- }
- rootPane.putClientProperty("apple.awt.transparentTitleBar", mac)
- rootPane.putClientProperty("apple.awt.fullWindowContent", mac)
- defaultCloseOperation = JFrame.DISPOSE_ON_CLOSE
- contentPane.add(ComposePanel().apply {
- size = windowSize
- setContent {
- ProcessingTheme {
- Box(modifier = Modifier.padding(top = if (mac) 22.dp else 0.dp)) {
- welcomeToBeta(close)
- }
- }
- }
- })
- pack()
- background = java.awt.Color.white
- setLocationRelativeTo(null)
- addKeyListener(object : KeyAdapter() {
- override fun keyPressed(e: KeyEvent) {
- if (e.keyCode == KeyEvent.VK_ESCAPE) close()
- }
- })
- isResizable = false
- isVisible = true
- requestFocus()
+ val close = {
+ Preferences.set("update.beta_welcome", getRevision().toString())
+ }
+
+ PDESwingWindow("beta.window.title", onClose = close) {
+ welcomeToBeta(close)
  }
  }
  }
 
+ val windowSize = Dimension(400, 200)
  @Composable
  fun welcomeToBeta(close: () -> Unit = {}) {
  Row(
@@ -194,18 +170,9 @@ class WelcomeToBeta {
  @JvmStatic
  fun main(args: Array<String>) {
  application {
- val windowState = rememberWindowState(
- size = DpSize.Unspecified,
- position = WindowPosition(Alignment.Center)
- )
-
- Window(onCloseRequest = ::exitApplication, state = windowState, title = windowTitle) {
- ProcessingTheme {
- Surface(color = colors.background) {
- welcomeToBeta {
- exitApplication()
- }
- }
+ PDEComposeWindow(titleKey = "beta.window.title", onClose = ::exitApplication){
+ welcomeToBeta {
+ exitApplication()
  }
  }
  }

app/src/processing/app/ui/theme/Locale.kt

@@ -1,24 +1,41 @@
 package processing.app.ui.theme
 
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.CompositionLocalProvider
-import androidx.compose.runtime.compositionLocalOf
-import processing.app.LocalPreferences
-import processing.app.Messages
-import processing.app.Platform
-import processing.app.PlatformStart
-import processing.app.watchFile
+import androidx.compose.runtime.*
+import androidx.compose.ui.platform.LocalLayoutDirection
+import androidx.compose.ui.unit.LayoutDirection
+import processing.app.*
 import java.io.File
 import java.io.InputStream
 import java.util.*
 
-class Locale(language: String = "") : Properties() {
+/**
+ * The Locale class extends the standard Java Properties class
+ * to provide localization capabilities.
+ * It loads localization resources from property files based on the specified language code.
+ * The class also provides a method to change the current locale and update the application accordingly.
+ * Usage:
+ * ```
+ * val locale = Locale("es") { newLocale ->
+ * // Handle locale change, e.g., update UI or restart application
+ * }
+ * val localizedString = locale["someKey"]
+ * ```
+ */
+class Locale(language: String = "", val setLocale: ((java.util.Locale) -> Unit)? = null) : Properties() {
+ var locale: java.util.Locale = java.util.Locale.getDefault()
+
  init {
- val locale = java.util.Locale.getDefault()
- load(ClassLoader.getSystemResourceAsStream("PDE.properties"))
- load(ClassLoader.getSystemResourceAsStream("PDE_${locale.language}.properties") ?: InputStream.nullInputStream())
- load(ClassLoader.getSystemResourceAsStream("PDE_${locale.toLanguageTag()}.properties") ?: InputStream.nullInputStream())
- load(ClassLoader.getSystemResourceAsStream("PDE_${language}.properties") ?: InputStream.nullInputStream())
+ loadResourceUTF8("PDE.properties")
+ loadResourceUTF8("PDE_${locale.language}.properties")
+ loadResourceUTF8("PDE_${locale.toLanguageTag()}.properties")
+ loadResourceUTF8("PDE_${language}.properties")
+ }
+
+ fun loadResourceUTF8(path: String) {
+ val stream = ClassLoader.getSystemResourceAsStream(path)
+ stream?.reader(charset = Charsets.UTF_8)?.use { reader ->
+ load(reader)
+ }
  }
 
  @Deprecated("Use get instead", ReplaceWith("get(key)"))
@@ -28,18 +45,86 @@ class Locale(language: String = "") : Properties() {
  return value
  }
  operator fun get(key: String): String = getProperty(key, key)
+ fun set(locale: java.util.Locale) {
+ setLocale?.invoke(locale)
+ }
 }
-val LocalLocale = compositionLocalOf { Locale() }
+/**
+ * A CompositionLocal to provide access to the Locale instance
+ * throughout the composable hierarchy. see [LocaleProvider]
+ * Usage:
+ * ```
+ * val locale = LocalLocale.current
+ * val localizedString = locale["someKey"]
+ * ```
+ */
+val LocalLocale = compositionLocalOf<Locale> { error("No Locale Set") }
+
+/**
+ * This composable function sets up a locale provider that manages application localization.
+ * It initializes the locale from a language file, watches for changes to that file, and updates
+ * the locale accordingly. It uses a [Locale] class to handle loading of localized resources.
+ *
+ * Usage:
+ * ```
+ * LocaleProvider {
+ * // Your app content here
+ * }
+ * ```
+ *
+ * To access the locale:
+ * ```
+ * val locale = LocalLocale.current
+ * val localizedString = locale["someKey"]
+ * ```
+ *
+ * To change the locale:
+ * ```
+ * locale.set(java.util.Locale("es"))
+ * ```
+ * This will update the `language.txt` file and reload the locale.
+ */
 @Composable
 fun LocaleProvider(content: @Composable () -> Unit) {
- PlatformStart()
+ val preferencesFolderOverride: File? = System.getProperty("processing.app.preferences.folder")?.let { File(it) }
+
+ val settingsFolder = preferencesFolderOverride ?: remember{
+ Platform.init()
+ Platform.getSettingsFolder()
+ }
+ val languageFile = settingsFolder.resolve("language.txt")
+ remember(languageFile){
+ if(languageFile.exists()) return@remember
 
- val settingsFolder = Platform.getSettingsFolder()
- val languageFile = File(settingsFolder, "language.txt")
- watchFile(languageFile)
+ Messages.log("Creating language file at ${languageFile.absolutePath}")
+ settingsFolder.mkdirs()
+ languageFile.writeText(java.util.Locale.getDefault().language)
+ }
+
+ val update = watchFile(languageFile)
+ var code by remember(languageFile, update){ mutableStateOf(languageFile.readText().substring(0, 2)) }
+ remember(code) {
+ val locale = java.util.Locale(code)
+ java.util.Locale.setDefault(locale)
+ }
+
+ fun setLocale(locale: java.util.Locale) {
+ Messages.log("Setting locale to ${locale.language}")
+ languageFile.writeText(locale.language)
+ code = locale.language
+ }
+
+
+ val locale = Locale(code, ::setLocale)
+ remember(code) { Messages.log("Loaded Locale: $code") }
+ val dir = when(locale["locale.direction"]) {
+ "rtl" -> LayoutDirection.Rtl
+ else -> LayoutDirection.Ltr
+ }
 
- val locale = Locale(languageFile.readText().substring(0, 2))
- CompositionLocalProvider(LocalLocale provides locale) {
- content()
+ CompositionLocalProvider(LocalLayoutDirection provides dir) {
+ CompositionLocalProvider(LocalLocale provides locale) {
+ content()
+ }
  }
 }