SwingTree.java

package swingtree;

import org.jspecify.annotations.Nullable;
import org.slf4j.Logger;
import swingtree.api.IconDeclaration;
import swingtree.api.Painter;
import swingtree.style.StyleSheet;
import swingtree.threading.EventProcessor;

import javax.swing.ImageIcon;
import javax.swing.LookAndFeel;
import javax.swing.UIDefaults;
import javax.swing.UIManager;
import javax.swing.plaf.FontUIResource;
import javax.swing.plaf.UIResource;
import javax.swing.text.StyleContext;
import java.awt.*;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.beans.PropertyChangeSupport;
import java.io.BufferedReader;
import java.io.File;
import java.io.IOException;
import java.lang.reflect.Method;
import java.nio.file.Files;
import java.util.List;
import java.util.*;
import java.util.concurrent.TimeUnit;
import java.util.function.Supplier;

import static java.nio.charset.StandardCharsets.UTF_8;

/**
 *  A {@link SwingTree} is a singleton that holds global configuration context for the SwingTree library.
 *  This includes the {@link EventProcessor} that is used to process events, as well as the
 *  {@link StyleSheet} that is used to style components.
 *  <br>
 *  You may access the singleton instance of the {@link SwingTree} class through the {@link #get()} method.
 *
 * @author Daniel Nepp
 */
public final class SwingTree
{
    private static final Logger log = org.slf4j.LoggerFactory.getLogger(SwingTree.class);

    private static final String _DEFAULT_FONT = "defaultFont";

    private static @Nullable LazyRef<SwingTree> _INSTANCE = new LazyRef<>(SwingTree::new);

    /**
     * Returns the singleton instance of the {@link SwingTree}.
     * Note that this method will create the singleton if it does not exist.
     * @return the singleton instance of the {@link SwingTree}.
     */
    public static SwingTree get() {
        if ( _INSTANCE == null )
            initialize();
        if ( _INSTANCE == null )
            throw new IllegalStateException("Failed to initialize SwingTree singleton!");

        return _INSTANCE.get();
    }

    /**
     *  Clears the singleton instance of the {@link SwingTree}.
     *  This is useful for testing purposes, or if you want to
     *  reconfigure your application with a different {@link SwingTreeInitConfig}.
     *  (see {@link #initialiseUsing(SwingTreeConfigurator)}).
     */
    public static void clear() { _INSTANCE = null; }

    /**
     *  A lazy initialization of the singleton instance of the {@link SwingTree} class
     *  causing it to be recreated the next time it is requested through {@link #get()}.<br>
     *  This is useful for testing purposes, also in cases where
     *  the UI scale changes (through the reference font).<br>
     *  Also see {@link #initialiseUsing(SwingTreeConfigurator)}.
     */
    public static void initialize() {
        _INSTANCE = new LazyRef<>(SwingTree::new);
    }

    /**
     *  A lazy initialization of the singleton instance of the {@link SwingTree} class
     *  causing it to be recreated the next time it is requested through {@link #get()},<br>
     *  but with a {@link SwingTreeConfigurator} that is used
     *  to configure the {@link SwingTree} instance.<br>
     *  This is useful for testing purposes, but also in cases where
     *  the UI scale must be initialized or changed manually (through the reference font).<br>
     *  Also see {@link #initialize()}.
     *
     * @param configurator the {@link SwingTreeConfigurator} that is used
     *                     to configure the {@link SwingTree} instance.
     */
    public static void initialiseUsing( SwingTreeConfigurator configurator ) {
        _INSTANCE = new LazyRef<>(()->new SwingTree(configurator));
    }

    private SwingTreeInitConfig _config;

    private final LazyRef<UiScale> _uiScale;
    private final Map<IconDeclaration, ImageIcon> _iconCache = new HashMap<>();


    private SwingTree() { this(config -> config); }

    private SwingTree( SwingTreeConfigurator configurator ) {
        _config = _resolveConfiguration(configurator);
        _uiScale = new LazyRef<>( () -> new UiScale(_config) );
        _establishMainFont(_config);
    }

    private SwingTreeInitConfig _resolveConfiguration( SwingTreeConfigurator configurator ) {
        try {
            Objects.requireNonNull(configurator);
            SwingTreeInitConfig config = configurator.configure(SwingTreeInitConfig.standard());
            Objects.requireNonNull(config);
            return config;
        } catch (Exception ex) {
            log.error("Error resolving SwingTree configuration", ex);
            ex.printStackTrace();
            return SwingTreeInitConfig.standard();
        }
    }

    private static void _establishMainFont( SwingTreeInitConfig config ) {
        try {
            if (config.fontInstallation() == SwingTreeInitConfig.FontInstallation.HARD)
                config.defaultFont().ifPresent(font -> {
                    if (font instanceof FontUIResource)
                        _installFontInUIManager((FontUIResource) font);
                    else
                        _installFontInUIManager(new FontUIResource(font));
                });
        } catch (Exception ex) {
            log.error("Error installing font in UIManager", ex);
            ex.printStackTrace();
        }
    }

    private static void _installFontInUIManager(javax.swing.plaf.FontUIResource f){
        Enumeration<Object> keys = UIManager.getDefaults().keys();
        while ( keys.hasMoreElements() ) {
            Object key = keys.nextElement();
            Object value = UIManager.get (key);
            if ( value instanceof javax.swing.plaf.FontUIResource )
                UIManager.put(key, f);
        }
    }

    /**
     *  The icon cash is a hash map that uses an {@link IconDeclaration} as a key
     *  and an {@link ImageIcon} as a value. This is used to cache icons that are loaded
     *  from the file system using convenience methods like
     *  {@link swingtree.UI#findIcon(String)} and {@link swingtree.UI#findIcon(IconDeclaration)} or
     *  {@link swingtree.UI#findSvgIcon(String)}, {@link swingtree.UI#findSvgIcon(IconDeclaration)}.<br>
     *  Note that the map returned by this method is mutable and can be used to add or remove icons
     *  from the cache. <b>You may also want to consider this as a possible source of memory leaks.</b>
     *
     * @return The icon cache of this context, which is used to cache icons
     *         that are loaded from the file system.
     */
    public Map<IconDeclaration, ImageIcon> getIconCache() { return _iconCache; }

    /**
     * Returns the user scale factor is a scaling factor is used by SwingTree's
     * style engine to scale the UI during painting.
     * Note that this is different from the system/Graphics2D scale factor, which is
     * the scale factor that the JRE uses to scale everything through the
     * {@link java.awt.geom.AffineTransform} of the {@link Graphics2D}.
     * <p>
     * Use this scaling factor for painting operations that are not performed
     * by SwingTree's style engine, e.g. custom painting
     * (see {@link swingtree.style.ComponentStyleDelegate#painter(UI.Layer, Painter)}).
     * <p>
     * You can configure this scaling factor through the library initialization
     * method {@link SwingTree#initialiseUsing(SwingTreeConfigurator)},
     * or directly through the system property "swingtree.uiScale".
     *
     * @return The user scale factor.
     */
    public float getUiScaleFactor() {
        return _uiScale.get().getUserScaleFactor();
    }

    /**
     * Sets the user scale factor is a scaling factor that is used by SwingTree's
     * style engine to scale the UI during painting.
     * Note that this is different from the system/Graphics2D scale factor, which is
     * the scale factor that the JRE uses to scale everything through the
     * {@link java.awt.geom.AffineTransform} of the {@link Graphics2D}.
     * <p>
     * Use this scaling factor for painting operations that are not performed
     * by SwingTree's style engine, e.g. custom painting
     * (see {@link swingtree.style.ComponentStyleDelegate#painter(UI.Layer, Painter)}).
     * <p>
     * You can configure this scaling factor through the library initialization
     * method {@link SwingTree#initialiseUsing(SwingTreeConfigurator)},
     * or directly through the system property "swingtree.uiScale".
     *
     * @param scaleFactor The user scale factor.
     */
    public void setUiScaleFactor( float scaleFactor ) {
        log.debug("Changing UI scale factor from {} to {} now.", _uiScale.get().getUserScaleFactor(), scaleFactor);
        _uiScale.get().setUserScaleFactor(scaleFactor);
    }

    /**
     * Adds a property change listener to the user scale factor, so
     * when the user scale factor changes, the property "swingtree.uiScale" is fired.
     * The user scale factor is a scaling factor that is used by SwingTree's
     * style engine to scale the UI during painting.
     * Note that this is different from the system/Graphics2D scale factor, which is
     * the scale factor that the JRE uses to scale everything through the
     * {@link java.awt.geom.AffineTransform} of the {@link Graphics2D}.
     * <p>
     * Use this scaling factor for painting operations that are not performed
     * by SwingTree's style engine, e.g. custom painting
     * (see {@link swingtree.style.ComponentStyleDelegate#painter(UI.Layer, Painter)}).
     * <p>
     * You can configure this scaling factor through the library initialization
     * method {@link SwingTree#initialiseUsing(SwingTreeConfigurator)},
     * or directly through the system property "swingtree.uiScale".
     *
     * @param listener The property change listener to add.
     */
    public void addUiScaleChangeListener(PropertyChangeListener listener) {
        _uiScale.get().addPropertyChangeListener(listener);
    }

    /**
     * Removes the provided property change listener from the user scale factor
     * property with the name "swingtree.uiScale".
     * The user scale factor is a scaling factor that is used by SwingTree's
     * style engine to scale the UI during painting.
     * Note that this is different from the system/Graphics2D scale factor, which is
     * the scale factor that the JRE uses to scale everything through the
     * {@link java.awt.geom.AffineTransform} of the {@link Graphics2D}.
     * <p>
     * Use this scaling factor for painting operations that are not performed
     * by SwingTree's style engine, e.g. custom painting
     * (see {@link swingtree.style.ComponentStyleDelegate#painter(UI.Layer, Painter)}).
     * <p>
     * You can configure this scaling factor through the library initialization
     * method {@link SwingTree#initialiseUsing(SwingTreeConfigurator)},
     * or directly through the system property "swingtree.uiScale".
     *
     * @param listener The property change listener to remove.
     */
    public void removeUiScaleChangeListener(PropertyChangeListener listener) {
        _uiScale.get().removePropertyChangeListener(listener);
    }

    /**
     * Returns whether system scaling is enabled.
     * System scaling means that the JRE scales everything
     * through the {@link java.awt.geom.AffineTransform} of the {@link Graphics2D}.
     * If this is the case, then we do not have to do scaled painting
     * and can use the original size of icons, gaps, etc.
     * @return true if system scaling is enabled.
     */
    public boolean isSystemScalingEnabled() { return UiScale._isSystemScalingEnabled(); }

    /**
     * Returns the system scale factor for the given graphics context.
     * The system scale factor is the scale factor that the JRE uses
     * to scale everything (text, icons, gaps, etc).
     *
     * @param g The graphics context to get the system scale factor for.
     * @return The system scale factor for the given graphics context.
     */
    public double getSystemScaleFactorOf( Graphics2D g ) {
        return UiScale._getSystemScaleFactorOf(g);
    }

    /**
     * Returns the system scale factor.
     * The system scale factor is the scale factor that the JRE uses
     * to scale everything (text, icons, gaps, etc) irrespective of the
     * current look and feel, as this is the scale factor that is used
     * by the {@link java.awt.geom.AffineTransform} of the {@link Graphics2D}.
     *
     * @return The system scale factor.
     */
    public double getSystemScaleFactor() {
        return UiScale._getSystemScaleFactor();
    }

    /**
     *  The {@link EventProcessor} is a simple interface whose implementations
     *  delegate tasks to threads that are capable of processing GUI or application events.
     *  As part of this singleton, the SwingTree library maintains a global
     *  {@link EventProcessor} that is used consistently by all declarative builders.
     *
     * @return The currently configured {@link EventProcessor} that is used to process
     *         GUI and application events.
     */
    public EventProcessor getEventProcessor() {
        return _config.eventProcessor();
    }

    /**
     * Sets the {@link EventProcessor} that is used to process GUI and application events.
     * You may not pass null as an argument, because SwingTree requires an event processor to function.
     *
     * @param eventProcessor the {@link EventProcessor} that is used to process GUI and application events.
     * @throws NullPointerException if eventProcessor is null!
     */
    public void setEventProcessor( EventProcessor eventProcessor ) {
        try {
            _config = _config.eventProcessor(Objects.requireNonNull(eventProcessor));
        } catch (Exception ex) {
            log.error("Error setting event processor", ex);
            ex.printStackTrace();
        }
    }

    /**
     *  The {@link StyleSheet} is an abstract class whose extensions are used to declare
     *  component styles through a CSS like DSL API.
     *  As part of this singleton, the SwingTree library maintains a global
     *  {@link StyleSheet} that is used consistently by all declarative builders.
     *  Use this method to access this global style sheet.
     *
     * @return The currently configured {@link StyleSheet} that is used to style components.
     */
    public StyleSheet getStyleSheet() {
        return _config.styleSheet();
    }

    /**
     * Sets the {@link StyleSheet} that is used to style components.
     * Use {@link StyleSheet#none()} instead of null to switch off global styling.
     * @param styleSheet The {@link StyleSheet} that is used to style components.
     * @throws NullPointerException if styleSheet is null!
     */
    public void setStyleSheet( StyleSheet styleSheet ) {
        try {
            _config = _config.styleSheet(Objects.requireNonNull(styleSheet));
        } catch ( Exception ex ) {
            log.error("Error setting style sheet", ex);
            ex.printStackTrace();
        }
    }

    /**
     *  Returns the default animation interval in milliseconds
     *  which is a property that
     *  determines the delay between two consecutive animation steps.
     *  You can think of it as the time between the heartbeats of the animation.
     *  The smaller the interval, the higher the refresh rate and
     *  the smoother the animation will look.
     *  However, the smaller the interval, the more CPU time will be used.
     *  The default interval is 16 ms which corresponds to almost 60 fps.
     *  <br>
     *  This property is used as default value by the {@link swingtree.animation.LifeTime}
     *  object which is used to define the duration of an {@link swingtree.animation.Animation}.
     *  The value returned by this is used by animations
     *  if no other interval is specified through {@link swingtree.animation.LifeTime#withInterval(long, TimeUnit)}.
     * @return The default animation interval in milliseconds.
     */
    public long getDefaultAnimationInterval() {
        return _config.defaultAnimationInterval();
    }

    /**
     *  Sets the default animation interval in milliseconds
     *  which is a property that
     *  determines the delay between two consecutive animation steps.
     *  You can think of it as the time between the heartbeats of the animation.
     *  The smaller the interval, the higher the refresh rate and
     *  the smoother the animation will look.
     *  However, the smaller the interval, the more CPU time will be used.
     *  The default interval is 16 ms which corresponds to almost 60 fps.
     *  <br>
     *  This property is used as default value by the {@link swingtree.animation.LifeTime}
     *  object which is used to define the duration of an {@link swingtree.animation.Animation}.
     *  The value returned by this is used by animations
     *  if no other interval is specified through {@link swingtree.animation.LifeTime#withInterval(long, TimeUnit)}.
     * @param defaultAnimationInterval The default animation interval in milliseconds.
     */
    public void setDefaultAnimationInterval( long defaultAnimationInterval ) {
        _config = _config.defaultAnimationInterval(defaultAnimationInterval);
    }

    /**
     *  Exposes a set of system properties in the form of a nicely formatted string.
     *  These are used by the SwingTree library to determine the system configuration
     *  and to adjust the UI accordingly.
     *
     * @return A string containing system information.
     */
    public String getSystemInfo() {
        return SystemInfo.getAsPrettyString();
    }

    /**
     * This class handles scaling in SwingTree UIs.
     * It computes user scaling factor based on font size and
     * provides methods to scale integer, float, {@link Dimension} and {@link Insets}.
     * This class is look and feel independent.
     * <p>
     * Two scaling modes are supported by SwingTree for HiDPI displays:
     * <p>
     * <h2>1) system scaling mode</h2>
     *
     * This mode is supported since Java 9 on all platforms and in some Java 8 VMs
     * (e.g. Apple and JetBrains). The JRE determines the scale factor per-display and
     * adds a scaling transformation to the graphics object.
     * E.g. invokes {@code java.awt.Graphics2D.scale( 1.5, 1.5 )} for 150%.
     * So the JRE does the scaling itself.
     * E.g. when you draw a 10px line, a 15px line is drawn on screen.
     * The scale factor may be different for each connected display.
     * The scale factor may change for a window when moving the window from one display to another one.
     * <p>
     * <h2>2) user scaling mode</h2>
     *
     * This mode is mainly for Java 8 compatibility, but is also used on Linux
     * or if the default font is changed.
     * The user scale factor is computed based on the used font.
     * The JRE does not scale anything.
     * So we have to invoke {@link UI#scale(float)} where necessary.
     * There is only one user scale factor for all displays.
     * The user scale factor may change if the active LaF, "defaultFont" or "Label.font" has changed.
     * If system scaling mode is available the user scale factor is usually 1,
     * but may be larger on Linux or if the default font is changed.
     *
     * @author Daniel Nepp, but a derivative work originally from Karl Tauber (com.formdev.flatlaf.util.UIScale)
     */
    static final class UiScale
    {
        private final SwingTreeInitConfig config;
        private @Nullable PropertyChangeSupport changeSupport;

        private static @Nullable Boolean jreHiDPI;

        private float scaleFactor = 1;
        private boolean initialized;


        private UiScale( SwingTreeInitConfig config ) // private to prevent instantiation from outside
        {
            this.config = config;
            try {
                // add user scale factor to allow layout managers (e.g. MigLayout) to use it
                UIManager.put( "laf.scaleFactor", (UIDefaults.ActiveValue) t -> {
                    return this.scaleFactor;
                });

                if ( config.scalingStrategy() == SwingTreeInitConfig.Scaling.NONE ) {
                    this.scaleFactor = 1;
                    this.initialized = true;
                    return;
                }

                if ( config.scalingStrategy() == SwingTreeInitConfig.Scaling.FROM_DEFAULT_FONT ) {
                    Font uiScaleReferenceFont = config.defaultFont().orElse(null);
                    if ( uiScaleReferenceFont != null ) {
                        UIManager.getDefaults().put(_DEFAULT_FONT, uiScaleReferenceFont);
                        log.debug("Setting default font ('{}') to in UIManager to {}", _DEFAULT_FONT, uiScaleReferenceFont);
                    }
                }

                if ( config.scalingStrategy() == SwingTreeInitConfig.Scaling.FROM_SYSTEM_FONT ) {
                    float defaultScale = this.scaleFactor;
                    Font highDPIFont = _calculateDPIAwarePlatformFont();
                    boolean updated = _initialize( highDPIFont );
                    if ( this.scaleFactor != defaultScale ) {
                        UIManager.getDefaults().put(_DEFAULT_FONT, highDPIFont);
                        log.debug("Setting default font ('{}') to in UIManager to {}", _DEFAULT_FONT, highDPIFont);
                    }
                    if ( updated )
                        _setScalePropertyListeners();
                }
                else
                    _initialize();

            } catch (Exception ex) {
                log.error("Error initializing "+ UiScale.class.getSimpleName(), ex);
                // Usually there should be no exception, if there is one, the library will still work, but
                // the UI may not be scaled correctly. Please report this exception to the library author.
            }
        }

        private Font _calculateDPIAwarePlatformFont()
        {
            FontUIResource dpiAwareFont = null;

            // determine UI font based on operating system
            if( SystemInfo.isWindows ) {
                Font winFont = (Font) Toolkit.getDefaultToolkit().getDesktopProperty( "win.messagebox.font" );
                if( winFont != null ) {
                    if( SystemInfo.isWinPE ) {
                        // on WinPE use "win.defaultGUI.font", which is usually Tahoma,
                        // because Segoe UI font is not available on WinPE
                        Font winPEFont = (Font) Toolkit.getDefaultToolkit().getDesktopProperty( "win.defaultGUI.font" );
                        if ( winPEFont != null )
                            dpiAwareFont = _createCompositeFont( winPEFont.getFamily(), winPEFont.getStyle(), winFont.getSize() );
                    }
                    else
                        dpiAwareFont = _createCompositeFont( winFont.getFamily(), winFont.getStyle(), winFont.getSize() );
                }

            } else if ( SystemInfo.isMacOS ) {
                String fontName;
                if( SystemInfo.isMacOS_10_15_Catalina_orLater ) {
                    if ( SystemInfo.isJetBrainsJVM_11_orLater ) {
                        // See https://youtrack.jetbrains.com/issue/JBR-1915
                        fontName = ".AppleSystemUIFont";
                    } else {
                        // use Helvetica Neue font
                        fontName = "Helvetica Neue";
                    }
                } else if( SystemInfo.isMacOS_10_11_ElCapitan_orLater ) {
                    // use San Francisco Text font
                    fontName = ".SF NS Text";
                } else {
                    // default font on older systems (see com.apple.laf.AquaFonts)
                    fontName = "Lucida Grande";
                }

                dpiAwareFont = _createCompositeFont( fontName, Font.PLAIN, 13 );

            } else if( SystemInfo.isLinux ) {
                try {
                    Font font = LinuxFontPolicy.getFont();
                    dpiAwareFont = (font instanceof FontUIResource) ? (FontUIResource) font : new FontUIResource( font );
                } catch (Exception e) {
                    log.error("Failed to find linux font for scaling!", e);
                }
            }

            // fallback
            if( dpiAwareFont == null )
                dpiAwareFont = _createCompositeFont( Font.SANS_SERIF, Font.PLAIN, 12 );

            // Todo: Look at ActiveFont in FlatLaf to see if we need to do anything with it here.
            // Comment from FlatLaf code base below:
            /*
                // get/remove "defaultFont" from defaults if set in properties files
                // (use remove() to avoid that ActiveFont.createValue() gets invoked)
                Object defaultFont = defaults.remove( _DEFAULT_FONT );
                // use font from OS as base font and derive the UI font from it
                if( defaultFont instanceof ActiveFont ) {
                    Font baseFont = uiFont;
                    uiFont = ((ActiveFont)defaultFont).derive( baseFont, fontSize -> {
                        return Math.round( fontSize * computeFontScaleFactor( baseFont ) );
                    } );
                }
            */

            // increase font size if system property "swingtree.uiScale" is set
            dpiAwareFont = _applyCustomScaleFactor( dpiAwareFont );

            return dpiAwareFont;
        }

        private static FontUIResource _createCompositeFont( String family, int style, int size ) {
            // using StyleContext.getFont() here because it uses
            // sun.font.FontUtilities.getCompositeFontUIResource()
            // and creates a composite font that is able to display all Unicode characters
            Font font = StyleContext.getDefaultStyleContext().getFont( family, style, size );
            return (font instanceof FontUIResource) ? (FontUIResource) font : new FontUIResource( font );
        }

        public void addPropertyChangeListener( PropertyChangeListener listener ) {
            if( changeSupport == null )
                changeSupport = new PropertyChangeSupport( UiScale.class );
            changeSupport.addPropertyChangeListener( listener );
        }

        public void removePropertyChangeListener( PropertyChangeListener listener ) {
            if( changeSupport == null )
                return;
            changeSupport.removePropertyChangeListener( listener );
        }

        //---- system scaling (Java 9) --------------------------------------------

        /**
         * Returns whether system scaling is enabled.
         * System scaling means that the JRE scales everything
         * through the {@link java.awt.geom.AffineTransform} of the {@link Graphics2D}.
         * If this is the case, then we do not have to do scaled painting
         * and can use the original size of icons, gaps, etc.
         */
        static boolean _isSystemScalingEnabled() {
            if ( jreHiDPI != null )
                return jreHiDPI;

            jreHiDPI = false;

            if ( SystemInfo.isJava_9_orLater ) {
                // Java 9 and later supports per-monitor scaling
                jreHiDPI = true;
            } else if ( SystemInfo.isJetBrainsJVM ) {
                // IntelliJ IDEA ships its own JetBrains Java 8 JRE that may support per-monitor scaling
                // see com.intellij.ui.JreHiDpiUtil.isJreHiDPIEnabled()
                try {
                    GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
                    Class<?> sunGeClass = Class.forName( "sun.java2d.SunGraphicsEnvironment" );
                    if( sunGeClass.isInstance( ge ) ) {
                        Method m = sunGeClass.getDeclaredMethod( "isUIScaleOn" );
                        jreHiDPI = (Boolean) m.invoke( ge );
                    }
                } catch( Throwable ex ) {
                    // ignore
                }
            }

            return jreHiDPI;
        }

        /**
         * Returns the system scale factor for the given graphics context.
         * The system scale factor is the scale factor that the JRE uses
         * to scale everything (text, icons, gaps, etc).
         *
         * @param g The graphics context to get the system scale factor for.
         * @return The system scale factor for the given graphics context.
         */
        private static double _getSystemScaleFactorOf( Graphics2D g ) {
            return _isSystemScalingEnabled() ? _getSystemScaleFactorOf( g.getDeviceConfiguration() ) : 1;
        }

        /**
         * @param gc The graphics configuration to get the system scale factor for.
         * @return The system scale factor for the given graphics configuration.
         */
        private static double _getSystemScaleFactorOf( GraphicsConfiguration gc ) {
            return (_isSystemScalingEnabled() && gc != null) ? gc.getDefaultTransform().getScaleX() : 1;
        }

        //---- user scaling (Java 8) ----------------------------------------------

        private void _initialize()
        {
            boolean updated = _initialize( _getDefaultFont() );
            if ( updated )
                _setScalePropertyListeners();
        }

        private boolean _initialize( Font uiScaleReferenceFont )
        {
            if ( initialized )
                return false;

            initialized = true;

            if ( !config.isUiScaleFactorEnabled() )
                return false;

            _setUserScaleFactor( _calculateScaleFactor( uiScaleReferenceFont ) );

            return true;
        }

        private void _setScalePropertyListeners() {
            // listener to update scale factor if LaF changed, "defaultFont" or "Label.font" changed
            PropertyChangeListener listener = new PropertyChangeListener() {
                @Override
                public void propertyChange( PropertyChangeEvent e ) {
                    switch( e.getPropertyName() ) {
                        case "lookAndFeel":
                            // it is not necessary (and possible) to remove listener of old LaF defaults
                            if( e.getNewValue() instanceof LookAndFeel)
                                UIManager.getLookAndFeelDefaults().addPropertyChangeListener( this );

                            _setUserScaleFactor( _calculateScaleFactor( _getDefaultFont() ) );
                            break;

                        case _DEFAULT_FONT:
                        case "Label.font":
                            _setUserScaleFactor( _calculateScaleFactor( _getDefaultFont() ) );
                            break;
                    }
                }
            };
            UIManager.addPropertyChangeListener( listener );
            UIManager.getDefaults().addPropertyChangeListener( listener );
            UIManager.getLookAndFeelDefaults().addPropertyChangeListener( listener );
        }

        private Font _getDefaultFont() {
            // use font size to calculate scale factor (instead of DPI)
            // because even if we are on a HiDPI display it is not sure
            // that a larger font size is set by the current LaF
            // (e.g. can avoid large icons with small text)
            Font font = UIManager.getFont( _DEFAULT_FONT );
            if ( font == null )
                font = UIManager.getFont( "Label.font" );

            return font;
        }

        /**
         * Computes the scale factor based on the given font.
         * @param font font to compute scale factor from
         * @return scale factor, normalized
         */
        private float _calculateScaleFactor( Font font ) {
            // apply custom scale factor specified in system property "swingtree.uiScale"
            float customScaleFactor = config.uiScaleFactor();
            if ( customScaleFactor > 0 ) {
                return customScaleFactor;
            }

            return _normalize(_internalComputeScaleFactorFrom( font ) );
        }

        /**
         * Computes the scale factor based on the given font.
         * @param font font to compute scale factor from
         * @return scale factor
         */
        private float _internalComputeScaleFactorFrom( Font font ) {
            if ( SystemInfo.isWindows ) {
                // Special handling for Windows to be compatible with OS scaling,
                // which distinguish between "screen scaling" and "text scaling".
                //  - Windows "screen scaling" scales everything (text, icon, gaps, etc)
                //    and may have different scaling factors for each screen.
                //  - Windows "text scaling" increases only the font size, but on all screens.
                //
                // Both can be changed by the user in the Windows 10 Settings:
                //  - Settings > Display > Scale and layout
                //  - Settings > Ease of Access > Display > Make text bigger (100% - 225%)
                if( font instanceof UIResource) {
                    Font uiFont = (Font) Toolkit.getDefaultToolkit().getDesktopProperty( "win.messagebox.font" );
                    if( uiFont == null || uiFont.getSize() == font.getSize() ) {
                        if( _isSystemScalingEnabled() ) {
                            // Do not apply own scaling if the JRE scales using Windows screen scale factor.
                            // If user increases font size in Windows 10 settings, desktop property
                            // "win.messagebox.font" is changed and SwingTree uses the larger font.
                            return 1;
                        } else {
                            // If the JRE does not scale (Java 8), the size of the UI font
                            // (usually from desktop property "win.messagebox.font")
                            // combines the Windows screen and text scale factors.
                            // But the font in desktop property "win.defaultGUI.font" is only
                            // scaled with the Windows screen scale factor. So use it to compute
                            // our scale factor that is equal to Windows screen scale factor.
                            Font winFont = (Font) Toolkit.getDefaultToolkit().getDesktopProperty( "win.defaultGUI.font" );
                            return _computeScaleFactorFromFontSize( (winFont != null) ? winFont : font );
                        }
                    }
                }

                // If font was explicitly set from outside (is not a UIResource),
                // or was set in SwingTree properties files (is a UIResource),
                // use it to compute scale factor. This allows applications to
                // use custom fonts (e.g. that the user can change in UI) and
                // get scaling if a larger font size is used.
                // E.g. SwingTree Demo supports increasing font size in "Font" menu and UI scales.
            }

            return _computeScaleFactorFromFontSize( font );
        }

        private static float _computeScaleFactorFromFontSize(Font font ) {
            // default font size
            float fontSizeDivider = 12f;

            if( SystemInfo.isWindows ) {
                // Windows LaF uses Tahoma font rather than the actual Windows system font (Segoe UI),
                // and its size is always ca. 10% smaller than the actual system font size.
                // Tahoma 11 is used at 100%
                if( "Tahoma".equals( font.getFamily() ) )
                    fontSizeDivider = 11f;
            } else if( SystemInfo.isMacOS ) {
                // default font size on macOS is 13
                fontSizeDivider = 13f;
            } else if( SystemInfo.isLinux ) {
                // default font size for Unity and Gnome is 15 and for KDE it is 13
                fontSizeDivider = SystemInfo.isKDE ? 13f : 15f;
            }

            return font.getSize() / fontSizeDivider;
        }

        /**
         * Applies a custom scale factor given in system property "swingtree.uiScale"
         * to the given font.
         */
        private FontUIResource _applyCustomScaleFactor( FontUIResource font )
        {
            if ( !config.isUiScaleFactorEnabled() )
                return font;

            float scaleFactor = config.uiScaleFactor();
            if ( scaleFactor <= 0 )
                return font;

            float fontScaleFactor = _computeScaleFactorFromFontSize( font );
            if ( scaleFactor == fontScaleFactor )
                return font;

            int newFontSize = Math.max( Math.round( (font.getSize() / fontScaleFactor) * scaleFactor ), 1 );
            return new FontUIResource( font.deriveFont( (float) newFontSize ) );
        }

        /**
         * Returns the user scale factor is a scaling factor is used by SwingTree's
         * style engine to scale the UI during painting.
         * Note that this is different from the system scale factor, which is
         * the scale factor that the JRE uses to scale everything through the
         * {@link java.awt.geom.AffineTransform} of the {@link Graphics2D}.
         * <p>
         * Use this scaling factor for painting operations that are not performed
         * by SwingTree's style engine, e.g. custom painting
         * (see {@link swingtree.style.ComponentStyleDelegate#painter(UI.Layer, Painter)}).
         * <p>
         * You can configure this scaling factor through the library initialization
         * method {@link SwingTree#initialiseUsing(SwingTreeConfigurator)},
         * or through the system property "swingtree.uiScale".
         *
         * @return The user scale factor.
         */
        public float getUserScaleFactor() {
            _initialize();
            return scaleFactor;
        }

        public void setUserScaleFactor( float scaleFactor ) {
            _initialize();
            _setUserScaleFactor( _normalize(scaleFactor) );
        }

        private float _normalize( float scaleFactor ) {
            if ( scaleFactor < 1f ) {
                scaleFactor = config.isUiScaleDownAllowed()
                        ? Math.round( scaleFactor * 10f ) / 10f // round small scale factor to 1/10
                        : 1f;
            }
            else if ( scaleFactor > 1f ) // round scale factor to 1/4
                scaleFactor = Math.round( scaleFactor * 4f ) / 4f;

            return scaleFactor;
        }

        /**
         * Sets the user scale factor.
         */
        private void _setUserScaleFactor(float scaleFactor) {
            // minimum scale factor
            scaleFactor = Math.max( scaleFactor, 0.1f );

            float oldScaleFactor = this.scaleFactor;
            this.scaleFactor = scaleFactor;

            if ( changeSupport != null )
                changeSupport.firePropertyChange( "userScaleFactor", oldScaleFactor, scaleFactor );
        }

        /**
         * Returns true if the JRE scales, which is the case if:
         *   - environment variable GDK_SCALE is set and running on Java 9 or later
         *   - running on JetBrains Runtime 11 or later and scaling is enabled in system Settings
         */
        static boolean _isSystemScaling() {
            if( GraphicsEnvironment.isHeadless() )
                return true;

            GraphicsConfiguration gc = GraphicsEnvironment.getLocalGraphicsEnvironment()
                                                          .getDefaultScreenDevice()
                                                          .getDefaultConfiguration();

            return UiScale._getSystemScaleFactorOf( gc ) > 1;
        }

        static double _getSystemScaleFactor() {
            if ( GraphicsEnvironment.isHeadless() )
                return 1;

            return UiScale._getSystemScaleFactorOf(
                                GraphicsEnvironment.getLocalGraphicsEnvironment()
                                                   .getDefaultScreenDevice()
                                                   .getDefaultConfiguration()
                            );
        }

    }

    /**
     * Provides information about the current system.
     *
     * @author Daniel Nepp, but originally a derivative work of
     *         Karl Tauber (com.formdev.flatlaf.util.SystemInfo)
     */
    private static final class SystemInfo
    {
        // platforms
        public static final boolean isWindows;
        public static final boolean isMacOS;
        public static final boolean isLinux;

        // OS versions
        public static final long osVersion;
        public static final boolean isWindows_10_orLater;
        /** <strong>Note</strong>: This requires Java 8u321, 11.0.14, 17.0.2 or 18 (or later).
         * (see https://bugs.openjdk.java.net/browse/JDK-8274840)
         **/
        public static final boolean isWindows_11_orLater;
        public static final boolean isMacOS_10_11_ElCapitan_orLater;
        public static final boolean isMacOS_10_14_Mojave_orLater;
        public static final boolean isMacOS_10_15_Catalina_orLater;

        // OS architecture
        public static final boolean isX86;
        public static final boolean isX86_64;
        public static final boolean isAARCH64;

        // Java versions
        public static final long javaVersion;
        public static final boolean isJava_9_orLater;
        public static final boolean isJava_11_orLater;
        public static final boolean isJava_15_orLater;
        public static final boolean isJava_17_orLater;
        public static final boolean isJava_18_orLater;

        // Java VMs
        public static final boolean isJetBrainsJVM;
        public static final boolean isJetBrainsJVM_11_orLater;

        // UI toolkits
        public static final boolean isKDE;

        // other
        public static final boolean isProjector;
        public static final boolean isWebswing;
        public static final boolean isWinPE;

        static {
            // platforms
            String osName = System.getProperty( "os.name" ).toLowerCase( Locale.ENGLISH );
            isWindows = osName.startsWith( "windows" );
            isMacOS = osName.startsWith( "mac" );
            isLinux = osName.startsWith( "linux" );

            // OS versions
            osVersion = scanVersion( System.getProperty( "os.version" ) );
            isWindows_10_orLater = (isWindows && osVersion >= toVersion( 10, 0, 0, 0 ));
            isWindows_11_orLater = (isWindows_10_orLater && osName.length() > "windows ".length() &&
                    scanVersion( osName.substring( "windows ".length() ) ) >= toVersion( 11, 0, 0, 0 ));
            isMacOS_10_11_ElCapitan_orLater = (isMacOS && osVersion >= toVersion( 10, 11, 0, 0 ));
            isMacOS_10_14_Mojave_orLater = (isMacOS && osVersion >= toVersion( 10, 14, 0, 0 ));
            isMacOS_10_15_Catalina_orLater = (isMacOS && osVersion >= toVersion( 10, 15, 0, 0 ));

            // OS architecture
            String osArch = System.getProperty( "os.arch" );
            isX86 = osArch.equals( "x86" );
            isX86_64 = osArch.equals( "amd64" ) || osArch.equals( "x86_64" );
            isAARCH64 = osArch.equals( "aarch64" );

            // Java versions
            javaVersion = scanVersion( System.getProperty( "java.version" ) );
            isJava_9_orLater = (javaVersion >= toVersion( 9, 0, 0, 0 ));
            isJava_11_orLater = (javaVersion >= toVersion( 11, 0, 0, 0 ));
            isJava_15_orLater = (javaVersion >= toVersion( 15, 0, 0, 0 ));
            isJava_17_orLater = (javaVersion >= toVersion( 17, 0, 0, 0 ));
            isJava_18_orLater = (javaVersion >= toVersion( 18, 0, 0, 0 ));

            // Java VMs
            isJetBrainsJVM = System.getProperty( "java.vm.vendor", "Unknown" )
                    .toLowerCase( Locale.ENGLISH ).contains( "jetbrains" );
            isJetBrainsJVM_11_orLater = isJetBrainsJVM && isJava_11_orLater;

            // UI toolkits
            isKDE = (isLinux && System.getenv( "KDE_FULL_SESSION" ) != null);

            // other
            isProjector = Boolean.getBoolean( "org.jetbrains.projector.server.enable" );
            isWebswing = (System.getProperty( "webswing.rootDir" ) != null);
            isWinPE = isWindows && "X:\\Windows\\System32".equalsIgnoreCase( System.getProperty( "user.dir" ) );
        }

        public static long scanVersion( String version ) {
            int major = 1;
            int minor = 0;
            int micro = 0;
            int patch = 0;
            try {
                StringTokenizer st = new StringTokenizer( version, "._-+" );
                major = Integer.parseInt( st.nextToken() );
                minor = Integer.parseInt( st.nextToken() );
                micro = Integer.parseInt( st.nextToken() );
                patch = Integer.parseInt( st.nextToken() );
            } catch( Exception ex ) {
                // ignore
            }

            return toVersion( major, minor, micro, patch );
        }

        public static long toVersion( int major, int minor, int micro, int patch ) {
            return ((long) major << 48) + ((long) minor << 32) + ((long) micro << 16) + patch;
        }

        static String getAsPrettyString() {
            return SystemInfo.class.getSimpleName() + "[\n" +
                    "    isWindows=" + isWindows + ",\n" +
                    "    isMacOS=" + isMacOS + ",\n" +
                    "    isLinux=" + isLinux + ",\n" +
                    "    osVersion=" + osVersion + ",\n" +
                    "    isWindows_10_orLater=" + isWindows_10_orLater + ",\n" +
                    "    isWindows_11_orLater=" + isWindows_11_orLater + ",\n" +
                    "    isMacOS_10_11_ElCapitan_orLater=" + isMacOS_10_11_ElCapitan_orLater + ",\n" +
                    "    isMacOS_10_14_Mojave_orLater=" + isMacOS_10_14_Mojave_orLater + ",\n" +
                    "    isMacOS_10_15_Catalina_orLater=" + isMacOS_10_15_Catalina_orLater + ",\n" +
                    "    isX86=" + isX86 + ",\n" +
                    "    isX86_64=" + isX86_64 + ",\n" +
                    "    isAARCH64=" + isAARCH64 + ",\n" +
                    "    javaVersion=" + javaVersion + ",\n" +
                    "    isJava_9_orLater=" + isJava_9_orLater + ",\n" +
                    "    isJava_11_orLater=" + isJava_11_orLater + ",\n" +
                    "    isJava_15_orLater=" + isJava_15_orLater + ",\n" +
                    "    isJava_17_orLater=" + isJava_17_orLater + ",\n" +
                    "    isJava_18_orLater=" + isJava_18_orLater + ",\n" +
                    "    isJetBrainsJVM=" + isJetBrainsJVM + ",\n" +
                    "    isJetBrainsJVM_11_orLater=" + isJetBrainsJVM_11_orLater + ",\n" +
                    "    isKDE=" + isKDE + ",\n" +
                    "    isProjector=" + isProjector + ",\n" +
                    "    isWebswing=" + isWebswing + ",\n" +
                    "    isWinPE=" + isWinPE + "\n" +
                    "]\n";
        }
    }

    private static class LinuxFontPolicy
    {
        static Font getFont() {
            return SystemInfo.isKDE ? getKDEFont() : getGnomeFont();
        }

        /**
         * Gets the default font for Gnome.
         */
        private static Font getGnomeFont() {
            // see class com.sun.java.swing.plaf.gtk.PangoFonts background information

            Object fontName = Toolkit.getDefaultToolkit().getDesktopProperty( "gnome.Gtk/FontName" );
            if( !(fontName instanceof String) )
                fontName = "sans 10";

            String family = "";
            int style = Font.PLAIN;
            double dsize = 10;

            // parse pango font description
            // see https://developer.gnome.org/pango/1.46/pango-Fonts.html#pango-font-description-from-string
            StringTokenizer st = new StringTokenizer( (String) fontName );
            while( st.hasMoreTokens() ) {
                String word = st.nextToken();

                // remove trailing ',' (e.g. in "Ubuntu Condensed, 11" or "Ubuntu Condensed, Bold 11")
                if( word.endsWith( "," ) )
                    word = word.substring( 0, word.length() - 1 ).trim();

                String lword = word.toLowerCase(Locale.ENGLISH);
                if( lword.equals( "italic" ) || lword.equals( "oblique" ) )
                    style |= Font.ITALIC;
                else if( lword.equals( "bold" ) )
                    style |= Font.BOLD;
                else if( Character.isDigit( word.charAt( 0 ) ) ) {
                    try {
                        dsize = Double.parseDouble( word );
                    } catch( NumberFormatException ex ) {
                        // ignore
                    }
                } else {
                    // remove '-' from "Semi-Bold", "Extra-Light", etc
                    if( lword.startsWith( "semi-" ) || lword.startsWith( "demi-" ) )
                        word = word.substring( 0, 4 ) + word.substring( 5 );
                    else if( lword.startsWith( "extra-" ) || lword.startsWith( "ultra-" ) )
                        word = word.substring( 0, 5 ) + word.substring( 6 );

                    family = family.isEmpty() ? word : (family + ' ' + word);
                }
            }

            // Ubuntu font is rendered poorly (except if running in JetBrains VM)
            // --> use Liberation Sans font
            String useUbuntu = "swingtree.USE_UBUNTU_FONT";

            if( family.startsWith( "Ubuntu" ) && !SystemInfo.isJetBrainsJVM && !getBoolean( useUbuntu, false ) )
                family = "Liberation Sans";

            // scale font size
            dsize *= getGnomeFontScale();
            int size = (int) (dsize + 0.5);
            if( size < 1 )
                size = 1;

            // handle logical font names
            String logicalFamily = mapFcName( family.toLowerCase(Locale.ENGLISH) );
            if( logicalFamily != null )
                family = logicalFamily;

            return createFontEx( family, style, size, dsize );
        }

        /**
         * Checks whether a system property is set and returns {@code true} if its value
         * is {@code "true"} (case-insensitive), otherwise it returns {@code false}.
         * If the system property is not set, {@code defaultValue} is returned.
         */
        static boolean getBoolean( String key, boolean defaultValue ) {
            String value = System.getProperty( key );
            return (value != null) ? Boolean.parseBoolean( value ) : defaultValue;
        }

        /**
         * Create a font for the given family, style and size.
         * If the font family does not match any font on the system,
         * then the last word (usually a font weight) from the family name is removed and tried again.
         * E.g. family 'URW Bookman Light' is not found, but 'URW Bookman' is found.
         * If still not found, then font of family 'Dialog' is returned.
         */
        private static Font createFontEx( String family, int style, int size, double dsize ) {
            for(;;) {
                Font font = createFont( family, style, size, dsize );

                if( Font.DIALOG.equals( family ) )
                    return font;

                // if the font family does not match any font on the system, "Dialog" family is returned
                if( !Font.DIALOG.equals( font.getFamily() ) ) {
                    // check for font problems
                    // - font height much larger than expected (e.g. font Inter; Oracle Java 8)
                    // - character width is zero (e.g. font Cantarell; Fedora; Oracle Java 8)
                    FontMetrics fm = StyleContext.getDefaultStyleContext().getFontMetrics( font );
                    if( fm.getHeight() > size * 2 || fm.stringWidth( "a" ) == 0 )
                        return createFont( Font.DIALOG, style, size, dsize );

                    return font;
                }

                // find last word in family
                int index = family.lastIndexOf( ' ' );
                if( index < 0 )
                    return createFont( Font.DIALOG, style, size, dsize );

                // check whether last work contains some font weight (e.g. Ultra-Bold or Heavy)
                String lastWord = family.substring( index + 1 ).toLowerCase(Locale.ENGLISH);
                if( lastWord.contains( "bold" ) || lastWord.contains( "heavy" ) || lastWord.contains( "black" ) )
                    style |= Font.BOLD;

                // remove last word from family and try again
                family = family.substring( 0, index );
            }
        }

        private static Font createFont( String family, int style, int size, double dsize ) {
            Font font = UiScale._createCompositeFont( family, style, size );

            // set font size in floating points
            font = font.deriveFont( style, (float) dsize );

            return font;
        }

        private static double getGnomeFontScale() {
            // do not scale font here if JRE scales
            if( UiScale._isSystemScaling() )
                return 96. / 72.;

            // see class com.sun.java.swing.plaf.gtk.PangoFonts background information

            Object value = Toolkit.getDefaultToolkit().getDesktopProperty( "gnome.Xft/DPI" );
            if( value instanceof Integer ) {
                int dpi = (Integer) value / 1024;
                if( dpi == -1 )
                    dpi = 96;
                if( dpi < 50 )
                    dpi = 50;
                return dpi / 72.0;
            } else {
                return GraphicsEnvironment.getLocalGraphicsEnvironment()
                                          .getDefaultScreenDevice()
                                          .getDefaultConfiguration()
                                          .getNormalizingTransform()
                                          .getScaleY();
            }
        }

        /**
         * map GTK/fontconfig names to equivalent JDK logical font name
         */
        private static @Nullable String mapFcName( String name ) {
            switch( name ) {
                case "sans":        return "sansserif";
                case "sans-serif":  return "sansserif";
                case "serif":       return "serif";
                case "monospace":   return "monospaced";
            }
            return null;
        }

        /**
         * Gets the default font for KDE from KDE configuration files.
         * <p>
         * The Swing fonts are not updated when the user changes system font size
         * (System Settings > Fonts > Force Font DPI). A application restart is necessary.
         * This is the same behavior as in native KDE applications.
         * <p>
         * The "display scale factor" (kdeglobals: [KScreen] > ScaleFactor) is not used
         * KDE also does not use it to calculate font size. Only forceFontDPI is used by KDE.
         * If user changes "display scale factor" (System Settings > Display and Monitors >
         * Displays > Scale Display), the forceFontDPI is also changed to reflect the scale factor.
         */
        private static Font getKDEFont() {
            List<String> kdeglobals = readConfig( "kdeglobals" );
            List<String> kcmfonts   = readConfig( "kcmfonts" );

            String generalFont  = getConfigEntry( kdeglobals, "General", "font" );
            String forceFontDPI = getConfigEntry( kcmfonts, "General", "forceFontDPI" );

            String family = "sansserif";
            int style = Font.PLAIN;
            int size = 10;

            if ( generalFont != null ) {
                List<String> strs = StringUtils.split( generalFont, ',' );
                try {
                    family = strs.get( 0 );
                    size = Integer.parseInt( strs.get( 1 ) );
                    if( "75".equals( strs.get( 4 ) ) )
                        style |= Font.BOLD;
                    if( "1".equals( strs.get( 5 ) ) )
                        style |= Font.ITALIC;
                } catch ( RuntimeException ex ) {
                    log.error("Failed to parse KDE system font from String '"+generalFont+"'.", ex);
                }
            }

            // font dpi
            int dpi = 96;
            if( forceFontDPI != null && !UiScale._isSystemScaling() ) {
                try {
                    dpi = Integer.parseInt( forceFontDPI );
                    if( dpi <= 0 )
                        dpi = 96;
                    if( dpi < 50 )
                        dpi = 50;
                } catch( NumberFormatException ex ) {
                    log.error("Failed to parse DPI scale from font size String '"+forceFontDPI+"'", ex);
                }
            }

            // scale font size
            double fontScale = dpi / 72.0;
            double dsize = size * fontScale;
            size = (int) (dsize + 0.5);
            if( size < 1 )
                size = 1;

            return createFont( family, style, size, dsize );
        }

        private static List<String> readConfig( String filename ) {
            File userHome = new File( System.getProperty( "user.home" ) );

            // search for config file
            String[] configDirs = {
                    ".config", // KDE 5
                    ".kde4/share/config", // KDE 4
                    ".kde/share/config"// KDE 3
            };
            File file = null;
            for( String configDir : configDirs ) {
                file = new File( userHome, configDir + "/" + filename );
                if( file.isFile() )
                    break;
            }
            if( file == null || !file.isFile() )
                return Collections.emptyList();

            // read config file
            ArrayList<String> lines = new ArrayList<>( 200 );
            try( BufferedReader reader = Files.newBufferedReader(file.toPath(), UTF_8) ) {
                String line;
                while( (line = reader.readLine()) != null )
                    lines.add( line );
            } catch( IOException ex ) {
                log.error("Failed to read KDE font config files for determining DPI scale factor.", ex);
            }
            return Collections.unmodifiableList(lines);
        }

        private static @Nullable String getConfigEntry( List<String> config, String group, String key ) {
            int groupLength = group.length();
            int keyLength = key.length();
            boolean inGroup = false;
            for( String line : config ) {
                if( !inGroup ) {
                    if( line.length() >= groupLength + 2 &&
                            line.charAt( 0 ) == '[' &&
                            line.charAt( groupLength + 1 ) == ']' &&
                            line.indexOf( group ) == 1 )
                    {
                        inGroup = true;
                    }
                } else {
                    if( line.startsWith( "[" ) )
                        return null;

                    if( line.length() >= keyLength + 2 &&
                            line.charAt( keyLength ) == '=' &&
                            line.startsWith( key ) )
                    {
                        return line.substring( keyLength + 1 );
                    }
                }
            }
            return null;
        }

    }

    private static class LazyRef<T> {
        private final Supplier<T> supplier;
        private volatile @Nullable T value;

        LazyRef( Supplier<T> supplier ) {
            this.supplier = Objects.requireNonNull( supplier );
        }

        T get() {
            @Nullable T value = this.value;
            if( value == null ) {
                synchronized( this ) {
                    value = this.value;
                    if ( value == null )
                        this.value = value = supplier.get();
                }
            }
            return value;
        }
    }
}