/* * ***************************************************************************** * Copyright (C) 2014-2026 Dennis Sheirer * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see * **************************************************************************** */ package io.github.dsheirer.gui.theme; import com.formdev.flatlaf.FlatLightLaf; import com.google.common.eventbus.Subscribe; import com.jidesoft.plaf.LookAndFeelFactory; import io.github.dsheirer.eventbus.MyEventBus; import io.github.dsheirer.preference.PreferenceType; import io.github.dsheirer.preference.UserPreferences; import java.awt.Color; import java.awt.EventQueue; import java.awt.Window; import java.lang.ref.WeakReference; import java.util.Iterator; import java.util.LinkedHashSet; import java.util.Set; import java.util.concurrent.atomic.AtomicBoolean; import javafx.application.Platform; import javafx.scene.Scene; import javax.swing.LookAndFeel; import javax.swing.SwingUtilities; import javax.swing.UIDefaults; import javax.swing.UIManager; import javax.swing.plaf.ColorUIResource; import javax.swing.plaf.metal.MetalLookAndFeel; import org.slf4j.Logger; import org.slf4j.LoggerFactory; /** * Centralized theme manager that drives both Swing and JavaFX appearance from the user * preference selection. * *

Each {@link Theme} pairs a FlatLaf look-and-feel class with a dark/light flag. When a * theme is applied: *

*/ public class ThemeManager { private final static Logger mLog = LoggerFactory.getLogger(ThemeManager.class); private static final String DARK_STYLESHEET = "/sdrtrunk_dark.css"; private static final ThemeManager INSTANCE = new ThemeManager(); private final Set> mScenes = new LinkedHashSet<>(); private final AtomicBoolean mWindowListenerAttached = new AtomicBoolean(); private final Set> mSwingRoots = new LinkedHashSet<>(); private final String mDarkStylesheetUrl; private volatile UserPreferences mUserPreferences; private volatile Theme mCurrentTheme = Theme.LIGHT; private volatile double mCurrentGuiScale = 1.0d; private volatile boolean mComplementaryAliasColors = false; /** Data URL of the currently-active per-theme accent stylesheet, or null. */ private volatile String mAccentStylesheetUrl; private ThemeManager() { java.net.URL url = ThemeManager.class.getResource(DARK_STYLESHEET); mDarkStylesheetUrl = (url != null) ? url.toExternalForm() : null; if(mDarkStylesheetUrl == null) { mLog.warn("Dark stylesheet [{}] not found on classpath - dark themes will only affect Swing.", DARK_STYLESHEET); } } public static ThemeManager getInstance() { return INSTANCE; } /** * Bind the theme manager to the user preferences and apply the current preference immediately. * Safe to call multiple times - subsequent calls update the reference and re-apply. */ public void initialize(UserPreferences userPreferences) { if(userPreferences == null) { return; } boolean firstBind = (mUserPreferences == null); mUserPreferences = userPreferences; mCurrentTheme = userPreferences.getApplicationPreference().getTheme(); mCurrentGuiScale = userPreferences.getApplicationPreference().getGuiScale(); mComplementaryAliasColors = userPreferences.getApplicationPreference().isComplementaryAliasColors(); if(firstBind) { MyEventBus.getGlobalEventBus().register(this); attachJavaFxWindowListener(); } //applyAll installs the Swing LAF *and* computes the per-theme accent stylesheet URL so it //is ready before any Scene.register call. At init time the FX-side scene walk is a no-op //because nothing has registered yet, but mAccentStylesheetUrl gets populated for later //register(...) calls. applyAll(mCurrentTheme); } /** * Install a listener on {@link javafx.stage.Window#getWindows()} so that every JavaFX window * created in the application (including ad-hoc {@code Alert}, {@code TextInputDialog} and * other transient dialogs spawned by the playlist editor and similar) automatically picks up * the current theme without each call site needing to remember to register its Scene. Idle * cost is one listener invocation per window opened; the listener short-circuits when the FX * toolkit is not yet started. */ private void attachJavaFxWindowListener() { if(mWindowListenerAttached.get()) { return; } Runnable attach = () -> { //Attach once, even if several attempts were scheduled before the first one ran if(!mWindowListenerAttached.compareAndSet(false, true)) { return; } try { javafx.stage.Window.getWindows().addListener( (javafx.collections.ListChangeListener) change -> { while(change.next()) { if(change.wasAdded()) { for(javafx.stage.Window w: change.getAddedSubList()) { themeWindowWhenSceneReady(w); } } } }); //Also cover any windows that already existed when we installed the listener. for(javafx.stage.Window w: javafx.stage.Window.getWindows()) { themeWindowWhenSceneReady(w); } } catch(Throwable t) { mLog.warn("Unable to attach JavaFX Window list listener for auto-theming", t); } }; if(Platform.isFxApplicationThread()) { attach.run(); } else { try { Platform.runLater(attach); } catch(IllegalStateException ignored) { //FX toolkit not started yet, which is the case when initialize() runs at application //startup, before the first JFXPanel. register() attaches the listener once the //first JavaFX scene is registered, which happens after the toolkit starts. } } } private void themeWindowWhenSceneReady(javafx.stage.Window window) { if(window == null) { return; } Scene scene = window.getScene(); if(scene != null) { applyToScene(scene, isDarkMode()); } else { //The Scene may be assigned after the Window is added to the list (the //typical Alert/Dialog lifecycle). Listen once for the assignment. window.sceneProperty().addListener((obs, oldScene, newScene) -> { if(newScene != null) { applyToScene(newScene, isDarkMode()); } }); } } /** * @return the currently active theme. */ public Theme getCurrentTheme() { return mCurrentTheme; } /** * @return true if the currently active theme is dark. */ public boolean isDarkMode() { return mCurrentTheme != null && mCurrentTheme.isDark(); } /** * Provides the color to render user-selected content (e.g. an alias) against a background in the current theme. * @param color selected by the user. * @param background that the color is rendered against. * @return the color, or a readable alternative when the user enabled complementary alias colors, dark mode is * active and the color lacks contrast with the background. */ public Color getReadableColor(Color color, Color background) { return mComplementaryAliasColors && isDarkMode() ? ColorContrast.getReadable(color, background) : color; } public void register(Scene scene) { if(scene == null) { return; } synchronized(mScenes) { pruneDeadReferencesAndCheckPresent(scene); mScenes.add(new WeakReference<>(scene)); } //The toolkit is running once a scene exists, so attach the window listener if initialize() //couldn't, so that ad-hoc dialogs and alerts are themed attachJavaFxWindowListener(); applyToScene(scene, isDarkMode()); } /** * Register a Swing component that may be temporarily detached from any Window's component tree * (e.g. swappable right-pane components in the Channel tab). Registered components get * {@link SwingUtilities#updateComponentTreeUI(java.awt.Component)} called on them whenever the * theme is applied, so they pick up the current palette even if they weren't attached when the * user toggled. */ public void registerSwing(java.awt.Component component) { if(component == null) { return; } synchronized(mSwingRoots) { Iterator> it = mSwingRoots.iterator(); while(it.hasNext()) { java.awt.Component existing = it.next().get(); if(existing == null || existing == component) { it.remove(); } } mSwingRoots.add(new WeakReference<>(component)); } } @Subscribe public void onPreferenceUpdated(PreferenceType type) { if(type != PreferenceType.APPLICATION || mUserPreferences == null) { return; } Theme updated = mUserPreferences.getApplicationPreference().getTheme(); double updatedScale = mUserPreferences.getApplicationPreference().getGuiScale(); boolean updatedComplementary = mUserPreferences.getApplicationPreference().isComplementaryAliasColors(); if(updatedComplementary != mComplementaryAliasColors) { mComplementaryAliasColors = updatedComplementary; //The Swing table renderers look up the alias color each time they paint. EventQueue.invokeLater(() -> { for(Window window: Window.getWindows()) { window.repaint(); } }); } if(updated == mCurrentTheme && Math.abs(updatedScale - mCurrentGuiScale) < 1e-6) { return; } mCurrentTheme = updated; mCurrentGuiScale = updatedScale; applyAll(updated); } private void applyAll(Theme theme) { applySwingLookAndFeel(theme); //Compute the per-theme accent stylesheet on the calling thread so the data URL is ready //before the FX apply runs. Capture the previous URL so we can remove it from each Scene. String previousAccentUrl = mAccentStylesheetUrl; String nextAccentUrl = buildAccentStylesheet(theme); mAccentStylesheetUrl = nextAccentUrl; Runnable fxApply = () -> { synchronized(mScenes) { Iterator> it = mScenes.iterator(); while(it.hasNext()) { Scene scene = it.next().get(); if(scene == null) { it.remove(); } else { applyToScene(scene, theme.isDark(), previousAccentUrl, nextAccentUrl); } } } for(javafx.stage.Window window: javafx.stage.Window.getWindows()) { Scene scene = window.getScene(); if(scene != null) { applyToScene(scene, theme.isDark(), previousAccentUrl, nextAccentUrl); } } }; if(Platform.isFxApplicationThread()) { fxApply.run(); } else { try { Platform.runLater(fxApply); } catch(IllegalStateException ignored) { //FX toolkit not started yet - scenes will be themed at registration time instead. } } } /** * Apply the current theme to a single Scene. Used when a new Scene is registered or appears * mid-session. The accent-stylesheet swap is handled by the (previousUrl, nextUrl) overload. */ private void applyToScene(Scene scene, boolean darkMode) { applyToScene(scene, darkMode, null, mAccentStylesheetUrl); } /** * Update a Scene's stylesheets to match the current theme: ensures the dark-mode CSS is * present iff {@code darkMode}, removes {@code previousAccentUrl} if present, and ensures * {@code nextAccentUrl} is present so theme-specific accent colours are applied. */ private void applyToScene(Scene scene, boolean darkMode, String previousAccentUrl, String nextAccentUrl) { Runnable r = () -> { if(mDarkStylesheetUrl != null) { scene.getStylesheets().remove(mDarkStylesheetUrl); if(darkMode) { scene.getStylesheets().add(mDarkStylesheetUrl); } } if(previousAccentUrl != null && !previousAccentUrl.equals(nextAccentUrl)) { scene.getStylesheets().remove(previousAccentUrl); } if(nextAccentUrl != null && !scene.getStylesheets().contains(nextAccentUrl)) { scene.getStylesheets().add(nextAccentUrl); } }; if(Platform.isFxApplicationThread()) { r.run(); } else { Platform.runLater(r); } } /** * Build a small per-theme stylesheet that overrides Modena's accent and surface colours so * each theme reads visibly different in the JavaFX panels. Returns a {@code data:} URL that * can be added to a Scene's stylesheets list directly. */ private String buildAccentStylesheet(Theme theme) { try { UIDefaults laf = UIManager.getLookAndFeelDefaults(); boolean dark = theme.isDark(); String base = hex(laf.getColor("Panel.background"), dark ? 0x2b2b2b : 0xf2f2f2); String inner = hex(laf.getColor("TextField.background"), dark ? 0x313335 : 0xffffff); String innerAlt = hex(laf.getColor("Table.alternateRowColor"), dark ? 0x353739 : 0xfafafa); String accent = hex(laf.getColor("Component.accentColor"), hexInt(laf.getColor("List.selectionBackground"), dark ? 0x4a90d9 : 0x2675bf)); String selectionBg = hex(laf.getColor("List.selectionBackground"), dark ? 0x214283 : 0x2675bf); String selectionFg = hex(laf.getColor("List.selectionForeground"), 0xffffff); String text = hex(laf.getColor("Label.foreground"), dark ? 0xe6e6e6 : 0x1e1e1e); String border = hex(laf.getColor("Component.borderColor"), dark ? 0x4f5356 : 0xc4c4c4); //JavaFX side of the GUI scale: setting -fx-font-size on .root cascades through //Modena because most sizes are em-relative. Modena's default is 12px; multiplying //by mCurrentGuiScale and rounding to one decimal gives a clean scaled baseline. double scaledFontSize = Math.round(12.0d * mCurrentGuiScale * 10.0d) / 10.0d; StringBuilder css = new StringBuilder(); css.append(".root {"); css.append("-fx-font-size: ").append(scaledFontSize).append("px;"); css.append("-fx-base: ").append(base).append(";"); css.append("-fx-background: ").append(base).append(";"); css.append("-fx-control-inner-background: ").append(inner).append(";"); css.append("-fx-control-inner-background-alt: ").append(innerAlt).append(";"); css.append("-fx-accent: ").append(accent).append(";"); css.append("-fx-default-button: ").append(accent).append(";"); css.append("-fx-focus-color: ").append(accent).append(";"); css.append("-fx-faint-focus-color: ").append(accent).append("22;"); css.append("-fx-selection-bar: ").append(selectionBg).append(";"); css.append("-fx-selection-bar-text: ").append(selectionFg).append(";"); css.append("-fx-selection-bar-non-focused: ").append(innerAlt).append(";"); css.append("-fx-text-fill: ").append(text).append(";"); css.append("-fx-text-base-color: ").append(text).append(";"); css.append("-fx-text-background-color: ").append(text).append(";"); css.append("-fx-mark-color: ").append(text).append(";"); css.append("}"); css.append(".table-row-cell:filled:selected, .list-cell:filled:selected,") .append(" .tree-cell:filled:selected, .tree-table-row-cell:filled:selected {") .append("-fx-background: ").append(selectionBg).append(";") .append("-fx-background-color: ").append(selectionBg).append(";") .append("-fx-text-fill: ").append(selectionFg).append(";") .append("-fx-table-cell-border-color: ").append(border).append(";") .append("}"); css.append(".button:default {") .append("-fx-base: ").append(accent).append(";") .append("-fx-text-fill: ").append(selectionFg).append(";") .append("}"); css.append(".scroll-bar .thumb {") .append("-fx-background-color: ").append(border).append(";") .append("-fx-background-radius: 3;") .append("}"); css.append(".scroll-bar .thumb:hover {") .append("-fx-background-color: ").append(accent).append(";") .append("}"); //URL-encode the body; java.net.URLEncoder is fine for our restricted charset. String encoded = java.net.URLEncoder.encode(css.toString(), java.nio.charset.StandardCharsets.UTF_8); return "data:text/css," + encoded; } catch(Throwable t) { mLog.warn("Unable to build per-theme accent stylesheet for theme " + theme, t); return null; } } private static String hex(Color c, int fallbackRgb) { int rgb = (c != null) ? (c.getRGB() & 0xFFFFFF) : (fallbackRgb & 0xFFFFFF); return String.format("#%06x", rgb); } private static int hexInt(Color c, int fallbackRgb) { return (c != null) ? (c.getRGB() & 0xFFFFFF) : (fallbackRgb & 0xFFFFFF); } private void applySwingLookAndFeel(Theme theme) { //FlatLaf reads the flatlaf.uiScale system property when its LAF instance is initialised. //Set it before constructing the LAF so this theme apply picks up the user's zoom factor. //We also clear any previous UIManager-stored override so the system property takes effect. System.setProperty("flatlaf.uiScale", String.valueOf(mCurrentGuiScale)); UIManager.put("flatlaf.uiScale", null); //Install the LAF synchronously on the calling thread so any Swing components constructed //immediately afterwards (in particular the main JFrame) find a fully populated UIDefaults //set. UIManager.setLookAndFeel is safe to call before the EDT is running. LookAndFeel newLaf = instantiate(theme); try { UIManager.setLookAndFeel(newLaf); } catch(Exception e) { mLog.error("Unable to apply Swing look-and-feel for theme = " + theme, e); return; } try { //JIDE 3.6.18 has compile-time `instanceof WindowsLookAndFeel` checks throughout //LookAndFeelFactory. The 3-arg overload lets us hand JIDE an explicit Metal LAF //instance for type detection while leaving the real (FlatLaf) defaults table in place; //JIDE's Metal branch matches first. LookAndFeelFactory.installJideExtension(UIManager.getLookAndFeelDefaults(), new MetalLookAndFeel(), LookAndFeelFactory.VSNET_STYLE); } catch(Throwable t) { mLog.warn("Unable to install JIDE LAF extension after theme change", t); } //JIDE's Metal-flavored extension overwrites FlatLaf's color/font/border defaults for //standard Swing component keys. Re-apply FlatLaf's defaults on top of JIDE's install so //the inner panels pick up the right colours. JIDE's UI delegate registrations live under //Jide-prefixed keys that FlatLaf does not define, so they survive untouched. try { UIDefaults flatFresh = instantiate(theme).getDefaults(); UIDefaults active = UIManager.getLookAndFeelDefaults(); for(java.util.Map.Entry entry: flatFresh.entrySet()) { Object key = entry.getKey(); Object value = entry.getValue(); String keyName = String.valueOf(key); if(keyName.startsWith("Jide") || keyName.contains(".Jide")) { continue; } if(value != null) { active.put(key, value); } } } catch(Throwable t) { mLog.warn("Unable to re-apply FlatLaf defaults after JIDE install", t); } //Brute-force the standard component colour keys via UIManager.put which writes to the //user-defaults layer that takes precedence over the LAF defaults. Colours are read from //the FlatLaf-installed defaults so each theme contributes its own palette. applyExplicitOverrides(theme); //Re-rendering already-realized Swing windows must happen on the EDT. Also walk any Swing //components explicitly registered via registerSwing(...) - they may be detached from any //Window's tree at toggle time (e.g. swappable channel-tab right components). Runnable updateRealized = () -> { for(Window window: Window.getWindows()) { SwingUtilities.updateComponentTreeUI(window); } synchronized(mSwingRoots) { Iterator> it = mSwingRoots.iterator(); while(it.hasNext()) { java.awt.Component c = it.next().get(); if(c == null) { it.remove(); } else { SwingUtilities.updateComponentTreeUI(c); } } } }; if(EventQueue.isDispatchThread()) { updateRealized.run(); } else { EventQueue.invokeLater(updateRealized); } } /** * Reflectively instantiate the FlatLaf class for the given theme. Falls back to * {@link FlatLightLaf} if the class is missing - that should not happen in a normal build but * keeps the app usable if a theme jar is removed. */ private LookAndFeel instantiate(Theme theme) { try { Class cls = Class.forName(theme.getLafClassName()); return (LookAndFeel) cls.getDeclaredConstructor().newInstance(); } catch(Throwable t) { mLog.error("Unable to instantiate LAF [{}] for theme {} - falling back to FlatLightLaf", theme.getLafClassName(), theme, t); return new FlatLightLaf(); } } private void applyExplicitOverrides(Theme theme) { boolean darkMode = theme.isDark(); //CRITICAL: read from UIManager.getLookAndFeelDefaults() (LAF layer only) rather than //UIManager.getColor() / UIManager.getDefaults() (which is the merged view). The merged //view returns user-defaults entries from earlier applyExplicitOverrides calls instead of //the fresh LAF values, which means a second theme switch picks up the previous theme's //palette and the toggle appears broken after the first change. UIDefaults laf = UIManager.getLookAndFeelDefaults(); ColorUIResource bgPanel = uir(laf.getColor("Panel.background"), darkMode ? 0x2b2b2b : 0xf2f2f2); ColorUIResource bgRaised = uir(laf.getColor("Button.background"), darkMode ? 0x3c3f41 : 0xffffff); ColorUIResource bgInput = uir(laf.getColor("TextField.background"), darkMode ? 0x313335 : 0xffffff); ColorUIResource bgSelection = uir(laf.getColor("List.selectionBackground"), darkMode ? 0x214283 : 0x2675bf); ColorUIResource fgPrimary = uir(laf.getColor("Label.foreground"), darkMode ? 0xe6e6e6 : 0x1e1e1e); ColorUIResource fgSelection = uir(laf.getColor("List.selectionForeground"), 0xffffff); ColorUIResource fgDisabled = uir(laf.getColor("Label.disabledForeground"), darkMode ? 0x6a6a6a : 0x8c8c8c); ColorUIResource border = uir(laf.getColor("Component.borderColor"), darkMode ? 0x4f5356 : 0xc4c4c4); ColorUIResource altRow = uir(laf.getColor("Table.alternateRowColor"), darkMode ? 0x353739 : 0xfafafa); //Use a slightly brighter foreground than FlatLaf's default in dark mode so text reads //sharper on the JIDE-flavoured surfaces. Light themes keep their own contrast. if(darkMode && fgPrimary.getRed() < 0xd0) { fgPrimary = new ColorUIResource(0xe6e6e6); } String[] simpleComponents = { "Button", "ToggleButton", "CheckBox", "RadioButton", "Label", "Menu", "MenuItem", "CheckBoxMenuItem", "RadioButtonMenuItem", "MenuBar", "PopupMenu", "Panel", "Viewport", "ScrollPane", "Separator", "ToolBar", "ToolTip", "FormattedTextField", "TitledBorder", "TabbedPane", "OptionPane", "ProgressBar", "Spinner", "Slider", "ComboBox", "EditorPane", "PasswordField" }; for(String c: simpleComponents) { UIManager.put(c + ".background", bgPanel); UIManager.put(c + ".foreground", fgPrimary); UIManager.put(c + ".disabledForeground", fgDisabled); UIManager.put(c + ".disabledText", fgDisabled); } for(String c: new String[]{"Button", "ToggleButton", "ComboBox", "Spinner"}) { UIManager.put(c + ".background", bgRaised); } for(String c: new String[]{"TextField", "TextArea", "TextPane", "EditorPane", "FormattedTextField", "PasswordField"}) { UIManager.put(c + ".background", bgInput); UIManager.put(c + ".foreground", fgPrimary); UIManager.put(c + ".caretForeground", fgPrimary); UIManager.put(c + ".inactiveForeground", fgDisabled); UIManager.put(c + ".selectionBackground", bgSelection); UIManager.put(c + ".selectionForeground", fgSelection); } for(String c: new String[]{"Table", "Tree", "List"}) { UIManager.put(c + ".background", bgInput); UIManager.put(c + ".foreground", fgPrimary); UIManager.put(c + ".selectionBackground", bgSelection); UIManager.put(c + ".selectionForeground", fgSelection); } UIManager.put("Table.gridColor", border); UIManager.put("Table.alternateRowColor", altRow); UIManager.put("TableHeader.background", bgRaised); UIManager.put("TableHeader.foreground", fgPrimary); UIManager.put("TableHeader.cellBorder", javax.swing.BorderFactory.createMatteBorder(0, 0, 1, 1, border)); //Tab labels: selected tabs sit on the raised surface (which is white in light themes), //not on the blue selection background, so the selected-tab text is the primary //foreground - not the white selection foreground that is right for row selections. UIManager.put("TabbedPane.foreground", fgPrimary); UIManager.put("TabbedPane.background", bgPanel); UIManager.put("TabbedPane.selectedForeground", fgPrimary); UIManager.put("TabbedPane.selected", bgRaised); UIManager.put("TabbedPane.contentAreaColor", bgPanel); UIManager.put("TabbedPane.darkShadow", border); UIManager.put("TabbedPane.shadow", border); UIManager.put("MenuItem.selectionBackground", bgSelection); UIManager.put("MenuItem.selectionForeground", fgSelection); UIManager.put("Menu.selectionBackground", bgSelection); UIManager.put("Menu.selectionForeground", fgSelection); UIManager.put("SplitPane.background", bgPanel); UIManager.put("SplitPane.dividerFocusColor", bgSelection); UIManager.put("SplitPaneDivider.draggingColor", bgSelection); UIManager.put("Component.borderColor", border); UIManager.put("Component.disabledBorderColor", border); UIManager.put("Separator.foreground", border); UIManager.put("Separator.background", bgPanel); UIManager.put("ToolTip.background", bgRaised); UIManager.put("ToolTip.foreground", fgPrimary); //JIDE components read their colours from JIDE-specific UIManager keys, not the standard //Swing keys. Seed those from the same palette so JIDE widgets follow the theme. UIManager.put("JideTabbedPane.background", bgPanel); UIManager.put("JideTabbedPane.foreground", fgPrimary); UIManager.put("JideTabbedPane.tabAreaBackground", bgPanel); UIManager.put("JideTabbedPane.selectedTabBackground", bgRaised); UIManager.put("JideTabbedPane.activeTabBackground", bgRaised); UIManager.put("JideTabbedPane.tabListBackground", bgRaised); UIManager.put("JideTabbedPane.selectedTabTextForeground", fgPrimary); UIManager.put("JideTabbedPane.unselectedTabTextForeground", fgPrimary); UIManager.put("JideTabbedPane.activeTabTextForeground", fgPrimary); UIManager.put("JideTabbedPane.shadow", border); UIManager.put("JideTabbedPane.darkShadow", border); UIManager.put("JideTabbedPane.light", bgRaised); UIManager.put("JideTabbedPane.highlight", bgRaised); UIManager.put("JideSplitPane.background", bgPanel); UIManager.put("JideSplitPaneDivider.background", bgPanel); UIManager.put("JideSplitPane.dividerColor", border); UIManager.put("JideButton.background", bgRaised); UIManager.put("JideButton.foreground", fgPrimary); UIManager.put("JideButton.selectedBackground", bgSelection); UIManager.put("JideButton.selectedForeground", fgSelection); UIManager.put("JideButton.shadow", border); UIManager.put("JideButton.darkShadow", border); UIManager.put("JideButton.light", bgRaised); UIManager.put("JideButton.highlight", bgRaised); UIManager.put("JideLabel.background", bgPanel); UIManager.put("JideLabel.foreground", fgPrimary); } /** * Convert a {@link Color} to a {@link ColorUIResource}, falling back to {@code fallbackRgb} if * the input is null. Existing UIResource colours are returned as-is. */ private static ColorUIResource uir(Color c, int fallbackRgb) { if(c == null) { return new ColorUIResource(fallbackRgb); } if(c instanceof ColorUIResource cuir) { return cuir; } return new ColorUIResource(c); } private void pruneDeadReferencesAndCheckPresent(Scene scene) { Iterator> it = mScenes.iterator(); while(it.hasNext()) { Scene existing = it.next().get(); if(existing == null) { it.remove(); } else if(existing == scene) { it.remove(); } } } }