GROOVY-11932: Allow theme switching light/dark/system in groovyConsole (allow custom themes)

Author: paulk-asert

subprojects/groovy-console/src/main/groovy/groovy/console/ui/Console.groovy

@@ -845,7 +845,7 @@ class Console implements CaretListener, HyperlinkListener, ComponentListener, Fo
         swing.lightThemeMenuItem.selected = (currentTheme == 'LIGHT')
         swing.darkThemeMenuItem.selected = (currentTheme == 'DARK')
         swing.systemThemeMenuItem.selected = (currentTheme == 'SYSTEM')
-        statusLabel.text = 'Theme changed to: ' + ThemeManager.themeLabel
+        statusLabel.text = 'Theme changed to: ' + ThemeManager.themeLabel + (ThemeManager.isUsingCustomTheme() ? ' (custom)' : '')
 
         // repaint
         inputEditor.textEditor.repaint()
@@ -1279,17 +1279,19 @@ class Console implements CaretListener, HyperlinkListener, ComponentListener, Fo
     void largeIcons(EventObject evt = null) { applyIconSize(Icons.SIZE_LARGE) }
 
     void scaleIconsWithFont(EventObject evt = null) {
-        boolean enabled = evt?.source?.isSelected()
+        setScaleIconsWithFont(evt?.source?.isSelected() as boolean)
+    }
+
+    void setScaleIconsWithFont(boolean enabled) {
         prefs.putBoolean('scaleIconsWithFont', enabled)
         if (enabled) {
             applyIconSize(iconSizeFromFont(inputArea.font.size))
         } else {
             applyIconSize(prefs.getInt('iconSize', Icons.SIZE_NORMAL))
         }
-        updateIconSizeMenuEnabled()
     }
 
-    private void applyIconSize(int size) {
+    void applyIconSize(int size) {
         // only persist the preset when not tracking the font
         if (!prefs.getBoolean('scaleIconsWithFont', false)) {
             prefs.putInt('iconSize', size)
@@ -1299,6 +1301,15 @@ class Console implements CaretListener, HyperlinkListener, ComponentListener, Fo
         toolbar?.repaint()
     }
 
+    void reapplyTheme() {
+        switchTheme(ThemeManager.currentMode)
+    }
+
+    void reloadThemes() {
+        ThemeManager.reloadThemes()
+        reapplyTheme()
+    }
+
     private static int iconSizeFromFont(int fontSize) {
         Math.max(10, Math.min(48, Math.round(fontSize * 1.33f) as int))
     }
@@ -1316,14 +1327,7 @@ class Console implements CaretListener, HyperlinkListener, ComponentListener, Fo
         prefs.getInt('iconSize', Icons.SIZE_NORMAL)
     }
 
-    private void updateIconSizeMenuEnabled() {
-        boolean scaling = prefs.getBoolean('scaleIconsWithFont', false)
-        swing.smallIconsAction.enabled = !scaling
-        swing.normalIconsAction.enabled = !scaling
-        swing.largeIconsAction.enabled = !scaling
-    }
-
-    void largerFont(EventObject evt = null) {
+void largerFont(EventObject evt = null) {
         updateFontSize(inputArea.font.size + 2)
     }
 

subprojects/groovy-console/src/main/groovy/groovy/console/ui/ConsolePreferences.groovy

@@ -24,6 +24,8 @@ import org.codehaus.groovy.tools.shell.util.MessageSource
 
 import javax.swing.JDialog
 import javax.swing.JFileChooser
+import javax.swing.JOptionPane
+import javax.swing.filechooser.FileNameExtensionFilter
 import java.awt.Dimension
 
 class ConsolePreferences {
@@ -38,6 +40,18 @@ class ConsolePreferences {
     @Bindable
     int loopModeDelay
 
+    @Bindable
+    int iconSize
+
+    @Bindable
+    boolean scaleIconsWithFont
+
+    @Bindable
+    String customLightThemePath
+
+    @Bindable
+    String customDarkThemePath
+
     private final console
     private final MessageSource T
 
@@ -50,6 +64,10 @@ class ConsolePreferences {
 
         maxOutputChars = console.loadMaxOutputChars()
         loopModeDelay = console.prefs.getInt('loopModeDelay', DEFAULT_LOOP_MODE_DELAY_MILLIS)
+        iconSize = console.prefs.getInt('iconSize', Icons.SIZE_NORMAL)
+        scaleIconsWithFont = console.prefs.getBoolean('scaleIconsWithFont', false)
+        customLightThemePath = ThemeManager.customLightPath ?: ''
+        customDarkThemePath  = ThemeManager.customDarkPath  ?: ''
         console.maxOutputChars = maxOutputChars
     }
 
@@ -114,6 +132,79 @@ class ConsolePreferences {
 
                 vstrut(12)
 
+                vbox(border: compoundBorder([
+                        titledBorder(T['prefs.appearance.settings.title']),
+                        emptyBorder([6, 8, 8, 8])])) {
+                    hbox {
+                        label "${T['prefs.icon.size']}:"
+                        hstrut(8)
+                        buttonGroup(id: 'iconSizeGroup')
+                        radioButton(text: T['prefs.icon.size.small'],  id: 'iconSizeSmall',
+                                buttonGroup: iconSizeGroup, selected: iconSize == Icons.SIZE_SMALL,
+                                enabled: !scaleIconsWithFont,
+                                actionPerformed: { iconSize = Icons.SIZE_SMALL })
+                        hstrut(4)
+                        radioButton(text: T['prefs.icon.size.normal'], id: 'iconSizeNormal',
+                                buttonGroup: iconSizeGroup, selected: iconSize == Icons.SIZE_NORMAL,
+                                enabled: !scaleIconsWithFont,
+                                actionPerformed: { iconSize = Icons.SIZE_NORMAL })
+                        hstrut(4)
+                        radioButton(text: T['prefs.icon.size.large'],  id: 'iconSizeLarge',
+                                buttonGroup: iconSizeGroup, selected: iconSize == Icons.SIZE_LARGE,
+                                enabled: !scaleIconsWithFont,
+                                actionPerformed: { iconSize = Icons.SIZE_LARGE })
+                        hglue()
+                    }
+
+                    vstrut(4)
+
+                    hbox {
+                        checkBox(text: T['prefs.scale.icons.with.font'], id: 'scaleIconsCheckBox',
+                                selected: scaleIconsWithFont,
+                                actionPerformed: this.&onScaleWithFontToggled)
+                        hglue()
+                    }
+
+                    vstrut(10)
+
+                    hbox {
+                        label "${T['prefs.custom.light.theme']}:"
+                        hstrut(6)
+                        label(id: 'customLightPathLabel',
+                                text: customLightThemePath ?: T['prefs.no.file.selected'])
+                        hglue()
+                        button(text: T['prefs.select'], actionPerformed: this.&onSelectLightTheme)
+                        hstrut(4)
+                        button(text: T['prefs.clear'], id: 'clearLightButton',
+                                enabled: customLightThemePath as boolean,
+                                actionPerformed: this.&onClearLightTheme)
+                    }
+
+                    vstrut(4)
+
+                    hbox {
+                        label "${T['prefs.custom.dark.theme']}:"
+                        hstrut(6)
+                        label(id: 'customDarkPathLabel',
+                                text: customDarkThemePath ?: T['prefs.no.file.selected'])
+                        hglue()
+                        button(text: T['prefs.select'], actionPerformed: this.&onSelectDarkTheme)
+                        hstrut(4)
+                        button(text: T['prefs.clear'], id: 'clearDarkButton',
+                                enabled: customDarkThemePath as boolean,
+                                actionPerformed: this.&onClearDarkTheme)
+                    }
+
+                    vstrut(8)
+
+                    hbox {
+                        hglue()
+                        button(text: T['prefs.reload.themes'], actionPerformed: this.&onReloadThemes)
+                    }
+                }
+
+                vstrut(12)
+
                 hbox {
                     button T['prefs.reset.defaults'], id: 'resetPrefsButton', actionPerformed: this.&onReset
                     hglue()
@@ -144,6 +235,13 @@ class ConsolePreferences {
     private void onReset(EventObject event) {
         console.swing.txtMaxOutputChars.text = DEFAULT_MAX_OUTPUT_CHARS
         console.swing.txtLoopModeDelay.text = DEFAULT_LOOP_MODE_DELAY_MILLIS
+        iconSize = Icons.SIZE_NORMAL
+        scaleIconsWithFont = false
+        console.swing.iconSizeNormal.selected = true
+        console.swing.scaleIconsCheckBox.selected = false
+        setIconSizeRadiosEnabled(true)
+        updateLightPathLabel(null)
+        updateDarkPathLabel(null)
     }
 
     private void onClose(EventObject event) {
@@ -157,6 +255,26 @@ class ConsolePreferences {
 
         console.setOutputPreferences(console.swing.outputFileCheckBox.enabled, outputFile)
 
+        // apply appearance settings
+        boolean previousScale = console.prefs.getBoolean('scaleIconsWithFont', false)
+        int previousIcon = console.prefs.getInt('iconSize', Icons.SIZE_NORMAL)
+        if (scaleIconsWithFont != previousScale) {
+            console.setScaleIconsWithFont(scaleIconsWithFont)
+        } else if (!scaleIconsWithFont && iconSize != previousIcon) {
+            console.applyIconSize(iconSize)
+        }
+
+        // apply custom theme paths — reapply theme only if something actually changed
+        String previousLight = ThemeManager.customLightPath ?: ''
+        String previousDark  = ThemeManager.customDarkPath  ?: ''
+        String newLight = customLightThemePath ?: ''
+        String newDark  = customDarkThemePath  ?: ''
+        if (newLight != previousLight || newDark != previousDark) {
+            ThemeManager.customLightPath = newLight ?: null
+            ThemeManager.customDarkPath  = newDark  ?: null
+            console.reloadThemes()
+        }
+
         dialog.dispose()
     }
 
@@ -173,6 +291,59 @@ class ConsolePreferences {
         console.swing.outputFileName.text = outputFile.path
     }
 
+    private void onScaleWithFontToggled(EventObject event) {
+        scaleIconsWithFont = event.source.selected
+        setIconSizeRadiosEnabled(!scaleIconsWithFont)
+    }
+
+    private void setIconSizeRadiosEnabled(boolean enabled) {
+        console.swing.iconSizeSmall.enabled = enabled
+        console.swing.iconSizeNormal.enabled = enabled
+        console.swing.iconSizeLarge.enabled = enabled
+    }
+
+    private void onSelectLightTheme(EventObject event) { pickThemeFile { it -> updateLightPathLabel(it) } }
+    private void onSelectDarkTheme (EventObject event) { pickThemeFile { it -> updateDarkPathLabel(it)  } }
+    private void onClearLightTheme (EventObject event) { updateLightPathLabel(null) }
+    private void onClearDarkTheme  (EventObject event) { updateDarkPathLabel(null)  }
+
+    private void onReloadThemes(EventObject event) {
+        // apply any staged path changes first so Reload uses current selections
+        ThemeManager.customLightPath = customLightThemePath ?: null
+        ThemeManager.customDarkPath  = customDarkThemePath  ?: null
+        console.reloadThemes()
+    }
+
+    private void pickThemeFile(Closure onPicked) {
+        JFileChooser fileChooser = new JFileChooser()
+        fileChooser.fileFilter = new FileNameExtensionFilter('Groovy theme files (*.theme)', 'theme')
+        def groovyDir = new File(System.getProperty('user.home'), '.groovy')
+        fileChooser.currentDirectory = groovyDir.isDirectory() ? groovyDir : new File(System.getProperty('user.home'))
+        if (fileChooser.showOpenDialog(dialog) != JFileChooser.APPROVE_OPTION) return
+        File picked = fileChooser.selectedFile
+        try {
+            picked.withReader('UTF-8') { r -> ThemeManager.parseTheme(r) }
+        } catch (Exception ex) {
+            JOptionPane.showMessageDialog(dialog,
+                    "Could not parse theme file:\n${picked.absolutePath}\n\n${ex.message}",
+                    'Invalid Theme File', JOptionPane.WARNING_MESSAGE)
+            return
+        }
+        onPicked(picked.absolutePath)
+    }
+
+    private void updateLightPathLabel(String path) {
+        customLightThemePath = path ?: ''
+        console.swing.customLightPathLabel.text = path ?: T['prefs.no.file.selected']
+        console.swing.clearLightButton.enabled = path as boolean
+    }
+
+    private void updateDarkPathLabel(String path) {
+        customDarkThemePath = path ?: ''
+        console.swing.customDarkPathLabel.text = path ?: T['prefs.no.file.selected']
+        console.swing.clearDarkButton.enabled = path as boolean
+    }
+
     // Useful for testing gui
     static void main(args) {
         javax.swing.UIManager.setLookAndFeel(javax.swing.UIManager.getSystemLookAndFeelClassName())

subprojects/groovy-console/src/main/groovy/groovy/console/ui/ThemeManager.groovy

@@ -149,19 +149,69 @@ class ThemeManager {
         buildSwingStyles(activeTheme, fontFamily)
     }
 
+    /**
+     * Returns the attributes for a single theme style key as a plain map
+     * (foreground/background Colors plus bold/italic/underline Booleans).
+     * Consumed by SmartDocumentFilter so ANTLR-token-driven highlighting
+     * picks up the same theme values as the regex-based GroovyFilter styles.
+     * Returns an empty map if the theme doesn't define the key.
+     */
+    static Map getStyleAttrs(String key) {
+        if (!key) return [:]
+        activeTheme.styles[key.toLowerCase()] ?: [:]
+    }
+
     // --- theme loading + parsing ---
 
     private static final Map<String, Object> themeCache = [:]
 
+    static String getCustomLightPath() { prefs.get('themeCustomLightPath', null) }
+    static String getCustomDarkPath()  { prefs.get('themeCustomDarkPath',  null) }
+
+    static void setCustomLightPath(String path) {
+        path ? prefs.put('themeCustomLightPath', path) : prefs.remove('themeCustomLightPath')
+    }
+
+    static void setCustomDarkPath(String path) {
+        path ? prefs.put('themeCustomDarkPath', path) : prefs.remove('themeCustomDarkPath')
+    }
+
+    /** True iff the theme currently in use is loaded from a user-supplied file. */
+    static boolean isUsingCustomTheme() {
+        def file = customFileForCurrentMode()
+        file?.exists() && file.canRead()
+    }
+
+    /** Clear the parsed-theme cache so next lookup re-reads from disk/classpath. */
+    static void reloadThemes() {
+        synchronized (themeCache) { themeCache.clear() }
+    }
+
+    private static File customFileForCurrentMode() {
+        String path = isDark() ? customDarkPath : customLightPath
+        path ? new File(path) : null
+    }
+
     private static Map getActiveTheme() {
+        def file = customFileForCurrentMode()
+        if (file?.exists() && file.canRead()) {
+            try {
+                return themeCache.computeIfAbsent('custom:' + file.absolutePath) { key ->
+                    file.withReader('UTF-8') { r -> parseTheme(r) }
+                }
+            } catch (Exception ignored) {
+                // fall through to bundled on parse failure
+            }
+        }
         loadBundledTheme(isDark() ? 'dark' : 'light')
     }
 
     private static Map loadBundledTheme(String name) {
-        themeCache.computeIfAbsent(name) { key ->
-            def resource = ThemeManager.classLoader.getResourceAsStream("groovy/console/ui/themes/${key}.theme")
+        themeCache.computeIfAbsent('bundled:' + name) { key ->
+            String resourcePath = "groovy/console/ui/themes/${name}.theme"
+            def resource = ThemeManager.classLoader.getResourceAsStream(resourcePath)
             if (!resource) {
-                throw new IllegalStateException("Missing bundled theme resource: ${key}.theme")
+                throw new IllegalStateException("Missing bundled theme resource: ${resourcePath}")
             }
             resource.withStream { stream ->
                 parseTheme(new InputStreamReader(stream, 'UTF-8'))