Merge PR #1051: Zooming API

Notes:
- Gradle 9+ requires Java 17 to run
- using Java 21 on GitHub Actions
- not using Java 25 because Kotlin does not yet support it and output some warnings

.editorconfig

@@ -7,6 +7,11 @@ charset = latin1
 indent_style = tab
 indent_size = 4
 
+[{*.yaml,*.yml}]
+end_of_line = lf
+indent_style = space
+indent_size = 2
+
 [*.java]
 indent_style = tab
 ij_continuation_indent_size = 4

.gitattributes

@@ -20,7 +20,9 @@
 *.gif binary
 *.jar binary
 *.lib binary
+*.otf binary
 *.png binary
 *.sketch binary
 *.so binary
+*.ttf binary
 *.zip binary

.github/FUNDING.yml

@@ -0,0 +1 @@
+custom: https://www.formdev.com/flatlaf/sponsor/

.github/actions/cache-gradle/action.yml

@@ -0,0 +1,32 @@
+# https://docs.github.com/en/actions/tutorials/create-actions/create-a-composite-action#creating-a-composite-action-within-the-same-repository
+
+# cache uses two files:
+#
+#   - gradle-wrapper-<os>-<arch>-<hash>:
+#       contains the Gradle wrapper/distribution (~/.gradle/wrapper)
+#       and is updated when the Gradle version changed
+#   - gradle-caches-<os>-<arch>-<hash>:
+#       contains the Gradle caches (~/.gradle/caches), buildSrc/build and buildSrc/.gradle
+#       and is updated when Gradle related files were changed
+#       buildSrc/.gradle is needed so that buildSrc tasks are UP-TO-DATE
+
+name: 'Cache Gradle'
+runs:
+  using: "composite"
+  steps:
+
+    - name: Cache '.gradle/wrapper'
+      uses: actions/cache@v4
+      with:
+        key: gradle-wrapper-${{ runner.os }}-${{ runner.arch }}-${{ hashFiles( 'gradle/wrapper/gradle-wrapper.properties' ) }}
+        path: |
+          ~/.gradle/wrapper
+
+    - name: Cache '.gradle/caches' and 'buildSrc/build'
+      uses: actions/cache@v4
+      with:
+        key: gradle-caches-${{ runner.os }}-${{ runner.arch }}-${{ hashFiles( '**/*.gradle*', 'gradle/**', 'gradle.properties', 'buildSrc/src/**' ) }}
+        path: |
+          ~/.gradle/caches
+          buildSrc/build
+          buildSrc/.gradle

.github/workflows/ci.yml

@@ -1,4 +1,5 @@
-# https://help.github.com/actions/language-and-framework-guides/building-and-testing-java-with-gradle
+# https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions
+# https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-java-with-gradle
 
 name: CI
 
@@ -8,111 +9,82 @@ on:
       - '*'
     tags:
       - '[0-9]*'
-  pull_request:
-    branches: 
-      - '*'
+    paths-ignore:
+      - '**.md'
+      - '.*'
+      - '**/.settings/**'
+      - 'flatlaf-core/svg/**'
+      - 'flatlaf-natives/**'
+      - 'flatlaf-testing/dumps/**'
+      - 'flatlaf-testing/misc/**'
+      - 'images/**'
 
 jobs:
   build:
     runs-on: ubuntu-latest
 
-    strategy:
-      matrix:
-        # test against
-        # - Java 1.8 (minimum requirement)
-        # - Java 9 (first version with JPMS)
-        # - Java LTS versions (11, 17, ...)
-        # - lastest Java version(s)
-        java:
-          - 1.8
-          - 9
-          - 11  # LTS
-          - 14
-          - 15
-
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v4
 
-      - uses: gradle/wrapper-validation-action@v1
-        if: matrix.java == '1.8'
+      - uses: gradle/actions/wrapper-validation@v4
 
-      - name: Setup Java ${{ matrix.java }}
-        uses: actions/setup-java@v1
+      - name: Setup Java 21
+        uses: actions/setup-java@v4
         with:
-          java-version: ${{ matrix.java }}
+          java-version: 21
+          distribution: temurin  # pre-installed on ubuntu-latest
 
-      - name: Cache Gradle wrapper
-        uses: actions/cache@v1
-        with:
-          path: ~/.gradle/wrapper
-          key: ${{ runner.os }}-gradle-wrapper-${{ hashFiles('gradle/wrapper/gradle-wrapper.properties') }}
+      - name: Cache Gradle
+        uses: ./.github/actions/cache-gradle
 
-      - name: Cache Gradle cache
-        uses: actions/cache@v2
-        with:
-          path: ~/.gradle/caches
-          key: ${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle.kts') }}
-          restore-keys: ${{ runner.os }}-gradle
 
-      - name: Build with Gradle
+        # test against
+        # - Java 8 (minimum requirement)
+        # - Java LTS versions (11, 17, ...)
+        # - latest Java version(s)
+
+      - name: Build with Java 11 LTS
+        if: github.repository == 'JFormDesigner/FlatLaf'
+        run: ./gradlew build clean -Dtoolchain=11
+
+      - name: Build with Java 17 LTS
+        if: github.repository == 'JFormDesigner/FlatLaf'
+        run: ./gradlew build clean -Dtoolchain=17
+
+      - name: Build with Java 21 LTS
+        if: github.repository == 'JFormDesigner/FlatLaf'
+        run: ./gradlew build clean -Dtoolchain=21
+
+      - name: Build with Java 25 LTS
+        if: github.repository == 'JFormDesigner/FlatLaf'
+        run: ./gradlew build clean -Dtoolchain=25
+
+
+        # build with Java 8 for snapshot
+
+      - name: Build with Java 8
         run: ./gradlew build
 
-      - name: Upload artifacts
-        uses: actions/upload-artifact@v2
-        if: matrix.java == '11'
+      - name: Upload artifacts to GitHub Actions
+        uses: actions/upload-artifact@v4
         with:
           name: FlatLaf-build-artifacts
           path: |
             flatlaf-*/build/libs
+            flatlaf-*/flatlaf-*/build/libs
             !**/*-javadoc.jar
             !**/*-sources.jar
 
 
-  snapshot:
-    runs-on: ubuntu-latest
-    needs: build
-    if: |
-      github.event_name == 'push' &&
-      github.ref == 'refs/heads/main' &&
-      github.repository == 'JFormDesigner/FlatLaf'
-
-    steps:
-      - uses: actions/checkout@v2
-
-      - name: Setup Java 11
-        uses: actions/setup-java@v1
-        with:
-          java-version: 11
-
-      - name: Cache Gradle wrapper
-        uses: actions/cache@v1
-        with:
-          path: ~/.gradle/wrapper
-          key: ${{ runner.os }}-gradle-wrapper-${{ hashFiles('gradle/wrapper/gradle-wrapper.properties') }}
-
-      - name: Cache Gradle cache
-        uses: actions/cache@v2
-        with:
-          path: ~/.gradle/caches
-          key: ${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle.kts') }}
-          restore-keys: ${{ runner.os }}-gradle
-
-      - name: Publish snapshot to oss.sonatype.org
-        run: ./gradlew publish :flatlaf-theme-editor:build -Dorg.gradle.internal.publish.checksums.insecure=true
+      - name: Publish snapshot to Sonatype Central
+        if: |
+          github.repository == 'JFormDesigner/FlatLaf' &&
+          github.event_name == 'push' &&
+          (github.ref == 'refs/heads/main' || startsWith( github.ref, 'refs/heads/develop-' ))
+        run: ./gradlew publish -PskipFonts -Dorg.gradle.internal.publish.checksums.insecure=true -Dorg.gradle.parallel=false
         env:
-          OSSRH_USERNAME: ${{ secrets.OSSRH_USERNAME }}
-          OSSRH_PASSWORD: ${{ secrets.OSSRH_PASSWORD }}
-
-      - name: Upload theme editor
-        uses: sebastianpopp/ftp-action@releases/v2
-        with:
-          host: ${{ secrets.FTP_SERVER }}
-          user: ${{ secrets.FTP_USERNAME }}
-          password: ${{ secrets.FTP_PASSWORD }}
-          forceSsl: true
-          localDir: "flatlaf-theme-editor/build/libs"
-          remoteDir: "snapshots"
-          options: "--only-newer --no-recursion --verbose=1"
+          SONATYPE_USERNAME: ${{ secrets.SONATYPE_USERNAME }}
+          SONATYPE_PASSWORD: ${{ secrets.SONATYPE_PASSWORD }}
 
 
   release:
@@ -124,52 +96,31 @@ jobs:
       github.repository == 'JFormDesigner/FlatLaf'
 
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v4
 
-      - name: Setup Java 11
-        uses: actions/setup-java@v1
+      - name: Setup Java 21
+        uses: actions/setup-java@v4
         with:
-          java-version: 11
+          java-version: 21
+          distribution: temurin  # pre-installed on ubuntu-latest
 
-      - name: Cache Gradle wrapper
-        uses: actions/cache@v1
-        with:
-          path: ~/.gradle/wrapper
-          key: ${{ runner.os }}-gradle-wrapper-${{ hashFiles('gradle/wrapper/gradle-wrapper.properties') }}
+      - name: Cache Gradle
+        uses: ./.github/actions/cache-gradle
 
-      - name: Cache Gradle cache
-        uses: actions/cache@v2
-        with:
-          path: ~/.gradle/caches
-          key: ${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle.kts') }}
-          restore-keys: ${{ runner.os }}-gradle
-
-      - name: Release a new stable version to Maven Central
-        run: ./gradlew publish :flatlaf-demo:build :flatlaf-theme-editor:build -Drelease=true
+      - name: Release a new stable version to Maven Central and build demo and theme editor
+        run: ./gradlew publishToSonatype closeSonatypeStagingRepository :flatlaf-demo:build :flatlaf-theme-editor:build -PskipFonts -Prelease -Dorg.gradle.parallel=false
         env:
-          OSSRH_USERNAME: ${{ secrets.OSSRH_USERNAME }}
-          OSSRH_PASSWORD: ${{ secrets.OSSRH_PASSWORD }}
+          SONATYPE_USERNAME: ${{ secrets.SONATYPE_USERNAME }}
+          SONATYPE_PASSWORD: ${{ secrets.SONATYPE_PASSWORD }}
           SIGNING_KEY:      ${{ secrets.SIGNING_KEY }}
           SIGNING_PASSWORD: ${{ secrets.SIGNING_PASSWORD }}
 
-      - name: Upload demo
-        uses: sebastianpopp/ftp-action@releases/v2
-        with:
-          host: ${{ secrets.FTP_SERVER }}
-          user: ${{ secrets.FTP_USERNAME }}
-          password: ${{ secrets.FTP_PASSWORD }}
-          forceSsl: true
-          localDir: "flatlaf-demo/build/libs"
-          remoteDir: "."
-          options: "--only-newer --no-recursion --verbose=1"
+      - name: Install lftp
+        run: sudo apt-get -y install lftp
 
-      - name: Upload theme editor
-        uses: sebastianpopp/ftp-action@releases/v2
-        with:
-          host: ${{ secrets.FTP_SERVER }}
-          user: ${{ secrets.FTP_USERNAME }}
-          password: ${{ secrets.FTP_PASSWORD }}
-          forceSsl: true
-          localDir: "flatlaf-theme-editor/build/libs"
-          remoteDir: "."
-          options: "--only-newer --no-recursion --verbose=1"
+      - name: Upload demo and theme editor
+        run: >
+          lftp -c "set ftp:ssl-force true;
+            open -u ${{ secrets.FTP_USERNAME }},${{ secrets.FTP_PASSWORD }} ${{ secrets.FTP_SERVER }};
+            mput flatlaf-demo/build/libs/flatlaf-demo-*.jar;
+            mput flatlaf-theme-editor/build/libs/flatlaf-theme-editor-*.jar"

.github/workflows/error-prone.yml

@@ -0,0 +1,40 @@
+# https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions
+# https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-java-with-gradle
+
+name: Error Prone
+
+on:
+  push:
+    branches:
+      - '*'
+    tags:
+      - '[0-9]*'
+    paths-ignore:
+      - '**.md'
+      - '.*'
+      - '**/.settings/**'
+      - 'flatlaf-core/svg/**'
+      - 'flatlaf-natives/**'
+      - 'flatlaf-testing/dumps/**'
+      - 'flatlaf-testing/misc/**'
+      - 'images/**'
+
+jobs:
+  error-prone:
+    runs-on: ubuntu-latest
+    if: github.repository == 'JFormDesigner/FlatLaf'
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Setup Java 21
+        uses: actions/setup-java@v4
+        with:
+          java-version: 21
+          distribution: temurin  # pre-installed on ubuntu-latest
+
+      - name: Cache Gradle
+        uses: ./.github/actions/cache-gradle
+
+      - name: Check with Error Prone
+        run: ./gradlew errorprone

.github/workflows/fonts.yml

@@ -0,0 +1,64 @@
+# https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions
+# https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-java-with-gradle
+
+name: Fonts
+
+on:
+    push:
+        branches:
+            - '*'
+        tags:
+            - 'fonts/*-[0-9]*'
+        paths:
+            - 'flatlaf-fonts/**'
+            - '.github/workflows/fonts.yml'
+            - 'gradle/wrapper/gradle-wrapper.properties'
+            - '!**.md'
+            - '!**/.settings/**'
+
+jobs:
+    Fonts:
+        strategy:
+            matrix:
+                font:
+                    - inter
+                    - jetbrains-mono
+                    - roboto
+                    - roboto-mono
+
+        runs-on: ubuntu-latest
+        if: |
+            github.event_name == 'push' &&
+            github.repository == 'JFormDesigner/FlatLaf'
+
+        steps:
+            - uses: actions/checkout@v4
+
+            - name: Setup Java 21
+              uses: actions/setup-java@v4
+              with:
+                  java-version: 21
+                  distribution: temurin  # pre-installed on ubuntu-latest
+
+            - name: Cache Gradle
+              uses: ./.github/actions/cache-gradle
+
+            - name: Build with Gradle
+              run: ./gradlew :flatlaf-fonts-${{ matrix.font }}:build
+              if: startsWith( github.ref, format( 'refs/tags/fonts/{0}-', matrix.font ) ) != true
+
+            - name: Publish snapshot to Sonatype Central
+              run: ./gradlew :flatlaf-fonts-${{ matrix.font }}:publish -Dorg.gradle.internal.publish.checksums.insecure=true
+              env:
+                  SONATYPE_USERNAME: ${{ secrets.SONATYPE_USERNAME }}
+                  SONATYPE_PASSWORD: ${{ secrets.SONATYPE_PASSWORD }}
+              if: github.ref == 'refs/heads/main' || startsWith( github.ref, 'refs/heads/develop-' )
+
+            - name: Release a new stable version to Maven Central
+              run: ./gradlew :flatlaf-fonts-${{ matrix.font }}:build :flatlaf-fonts-${{ matrix.font }}:publish -Prelease
+              env:
+                  SONATYPE_USERNAME: ${{ secrets.SONATYPE_USERNAME }}
+                  SONATYPE_PASSWORD: ${{ secrets.SONATYPE_PASSWORD }}
+                  SIGNING_KEY:      ${{ secrets.SIGNING_KEY }}
+                  SIGNING_PASSWORD: ${{ secrets.SIGNING_PASSWORD }}
+              if: startsWith( github.ref, format( 'refs/tags/fonts/{0}-', matrix.font ) )

.github/workflows/natives.yml

@@ -1,4 +1,5 @@
-# https://help.github.com/actions/language-and-framework-guides/building-and-testing-java-with-gradle
+# https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions
+# https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-java-with-gradle
 
 name: Native Libraries
 
@@ -9,50 +10,122 @@ on:
         tags:
             - '[0-9]*'
         paths:
-            - 'flatlaf-natives/flatlaf-natives-windows/**'
-            - '.github/workflows/natives.yml'
-    pull_request:
-        branches:
-            - '*'
-        paths:
-            - 'flatlaf-natives/flatlaf-natives-windows/**'
+            - 'flatlaf-natives/**'
             - '.github/workflows/natives.yml'
+            - 'gradle/wrapper/gradle-wrapper.properties'
+            - '!**.md'
+            - '!**/.settings/**'
 
 jobs:
-    Windows:
-        runs-on: windows-latest
+    Natives:
+        strategy:
+            matrix:
+                os:
+                    - windows-latest
+                    - macos-latest
+                    - ubuntu-latest
+                    - ubuntu-24.04-arm
+
+        runs-on: ${{ matrix.os }}
 
         steps:
-            - uses: actions/checkout@v2
+            - uses: actions/checkout@v4
 
-            - uses: gradle/wrapper-validation-action@v1
+            - uses: gradle/actions/wrapper-validation@v4
 
-            - name: Setup Java 1.8
-              uses: actions/setup-java@v1
+            - name: apt update (Linux)
+              if: matrix.os == 'ubuntu-latest' || matrix.os == 'ubuntu-24.04-arm'
+              run: sudo apt-get update
+
+            - name: install libxt-dev and libgtk-3-dev (Linux)
+              if: matrix.os == 'ubuntu-latest' || matrix.os == 'ubuntu-24.04-arm'
+              run: sudo apt-get install libxt-dev libgtk-3-dev
+
+#           - name: Download libgtk-3.so for arm64 (Linux)
+#             if: matrix.os == 'ubuntu-latest'
+#             working-directory: flatlaf-natives/flatlaf-natives-linux/lib/aarch64
+#             run: |
+#               pwd
+#               ls -l /usr/lib/x86_64-linux-gnu/libgtk*
+#               wget --no-verbose https://ports.ubuntu.com/pool/main/g/gtk%2b3.0/libgtk-3-0_3.24.18-1ubuntu1_arm64.deb
+#               ls -l
+#               ar -x libgtk-3-0_3.24.18-1ubuntu1_arm64.deb data.tar.xz
+#               tar -xvf data.tar.xz --wildcards --to-stdout "./usr/lib/aarch64-linux-gnu/libgtk-3.so.0.*" > libgtk-3.so
+#               rm libgtk-3-0_3.24.18-1ubuntu1_arm64.deb data.tar.xz
+#               ls -l
+
+#           - name: install g++-aarch64-linux-gnu (Linux)
+#             if: matrix.os == 'ubuntu-latest'
+#             run: sudo apt-get install g++-aarch64-linux-gnu
+
+            - name: Setup Java 21
+              uses: actions/setup-java@v4
               with:
-                  java-version: 1.8
+                  java-version: 21
+                  distribution: temurin
 
-            - name: Cache Gradle wrapper
-              uses: actions/cache@v1
-              with:
-                  path: ~/.gradle/wrapper
-                  key: ${{ runner.os }}-gradle-wrapper-${{ hashFiles('gradle/wrapper/gradle-wrapper.properties') }}
-
-            - name: Cache Gradle cache
-              uses: actions/cache@v2
-              with:
-                  path: |
-                    ~/.gradle/caches
-                    !~/.gradle/caches/modules-2/modules-2.lock
-                  key: ${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle.kts') }}
-                  restore-keys: ${{ runner.os }}-gradle
+            - name: Cache Gradle
+              uses: ./.github/actions/cache-gradle
 
             - name: Build with Gradle
-              run: ./gradlew :flatlaf-natives-windows:build
+              # --no-daemon is necessary on Windows otherwise caching Gradle would fail with:
+              #   tar.exe: Couldn't open ~/.gradle/caches/modules-2/modules-2.lock: Permission denied
+              run: ./gradlew build-natives --no-daemon
+
+            - name: Sign Windows DLLs
+              if: matrix.os == 'windows-latest'
+              uses: skymatic/code-sign-action@v3
+              with:
+                certificate: '${{ secrets.CODE_SIGN_CERT_BASE64 }}'
+                password: '${{ secrets.CODE_SIGN_CERT_PASSWORD }}'
+                certificatesha1: '${{ secrets.CODE_SIGN_CERT_SHA1 }}'
+                folder: 'flatlaf-core/src/main/resources/com/formdev/flatlaf/natives'
+
+            - name: Sign macOS natives
+              if: matrix.os == 'DISABLED--macos-latest'
+              env:
+                CERT_BASE64: ${{ secrets.CODE_SIGN_CERT_BASE64 }}
+                CERT_PASSWORD: ${{ secrets.CODE_SIGN_CERT_PASSWORD }}
+                CERT_IDENTITY: ${{ secrets.CODE_SIGN_CERT_IDENTITY }}
+              run: |
+                # https://docs.github.com/en/actions/use-cases-and-examples/deploying/installing-an-apple-certificate-on-macos-runners-for-xcode-development
+                # create variables
+                CERTIFICATE_PATH=$RUNNER_TEMP/cert.p12
+                KEYCHAIN_PATH=$RUNNER_TEMP/signing.keychain-db
+                KEYCHAIN_PASSWORD=$CERT_PASSWORD
+                # decode certificate
+                printenv CERT_BASE64 | base64 --decode > $CERTIFICATE_PATH
+                # create temporary keychain
+                security create-keychain -p "$KEYCHAIN_PASSWORD" $KEYCHAIN_PATH
+                security set-keychain-settings -lut 21600 $KEYCHAIN_PATH
+                security unlock-keychain -p "$KEYCHAIN_PASSWORD" $KEYCHAIN_PATH
+                # import certificate to keychain
+                security import $CERTIFICATE_PATH -P "$CERT_PASSWORD" -A -t cert -f pkcs12 -k $KEYCHAIN_PATH
+                # set partition list (required for codesign)
+                security set-key-partition-list -S apple-tool:,apple: -k "$KEYCHAIN_PASSWORD" $KEYCHAIN_PATH
+                # add keychain to keychain search list
+                security list-keychains -d user -s $KEYCHAIN_PATH
+                # sign code
+                codesign --sign "$CERT_IDENTITY" --force --verbose=4 --timestamp \
+                  flatlaf-core/src/main/resources/com/formdev/flatlaf/natives/libflatlaf-macos-*.dylib
+                codesign --display --verbose=4 flatlaf-core/src/main/resources/com/formdev/flatlaf/natives/libflatlaf-macos-*.dylib
+                # cleanup
+                security delete-keychain $KEYCHAIN_PATH
+
+            - name: Set artifacts pattern
+              shell: bash
+              run: |
+                case ${{ matrix.os }} in
+                    windows-latest)    echo "artifactPattern=flatlaf-windows-*.dll"      >> $GITHUB_ENV ;;
+                    macos-latest)      echo "artifactPattern=libflatlaf-macos-*.dylib"   >> $GITHUB_ENV ;;
+                    ubuntu-latest)     echo "artifactPattern=libflatlaf-linux-x86_64.so" >> $GITHUB_ENV ;;
+                    ubuntu-24.04-arm)  echo "artifactPattern=libflatlaf-linux-arm64.so"  >> $GITHUB_ENV ;;
+                esac
 
             - name: Upload artifacts
-              uses: actions/upload-artifact@v2
+              uses: actions/upload-artifact@v4
               with:
-                  name: FlatLaf-natives-windows-build-artifacts
+                  name: FlatLaf-natives-build-artifacts-${{ matrix.os }}
                   path: |
-                      flatlaf-natives/flatlaf-natives-windows/build
+                      flatlaf-core/src/main/resources/com/formdev/flatlaf/natives/${{ env.artifactPattern }}
+                      flatlaf-natives/flatlaf-natives-*/build

.github/workflows/pr-snapshots.yml

@@ -0,0 +1,39 @@
+# https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions
+
+name: PR Snapshots
+
+on:
+  pull_request:
+    paths-ignore:
+      - '**.md'
+      - '.*'
+      - '**/.settings/**'
+      - 'flatlaf-core/svg/**'
+      - 'flatlaf-testing/dumps/**'
+      - 'flatlaf-testing/misc/**'
+      - 'images/**'
+
+jobs:
+  snapshot:
+    runs-on: ubuntu-latest
+    if: github.repository == 'JFormDesigner/FlatLaf'
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Setup Java 21
+        uses: actions/setup-java@v4
+        with:
+          java-version: 21
+          distribution: temurin  # pre-installed on ubuntu-latest
+
+      - name: Cache Gradle
+        uses: ./.github/actions/cache-gradle
+
+      - name: Publish PR snapshot to Sonatype Central
+        run: >
+          ./gradlew publish -PskipFonts -Dorg.gradle.internal.publish.checksums.insecure=true -Dorg.gradle.parallel=false
+          -Pgithub.event.pull_request.number=${{ github.event.pull_request.number }}
+        env:
+          SONATYPE_USERNAME: ${{ secrets.SONATYPE_USERNAME }}
+          SONATYPE_PASSWORD: ${{ secrets.SONATYPE_PASSWORD }}

.gitignore

@@ -5,9 +5,12 @@ build/
 .project
 .settings/
 .idea/
+.consulo/
 out/
 *.iml
 *.ipr
 *.iws
+*.xcuserstate
+*.xcworkspacedata
 .vs/
 .vscode/

README.md

@@ -6,14 +6,19 @@ Swing desktop applications.
 
 It looks almost flat (no shadows or gradients), clean, simple and elegant.
 FlatLaf comes with **Light**, **Dark**, **IntelliJ** and **Darcula** themes,
-scales on **HiDPI** displays and runs on Java 8 or newer.
+scales on **HiDPI** displays and runs on Java 8 or newer (LTS and latest).
 
 The look is heavily inspired by **Darcula** and **IntelliJ** themes from
 IntelliJ IDEA 2019.2+ and uses almost the same colors and icons.
 
-![Flat Light](images/flat_light.png)
+![FlatLaf Light](images/flat_light.png)
 
-![Flat Dark](images/flat_dark.png)
+![FlatLaf Dark](images/flat_dark.png)
+
+macOS Themes
+------------
+
+![FlatLaf macOS themes](images/flat_macos_themes.png)
 
 
 IntelliJ Platform Themes
@@ -25,6 +30,27 @@ FlatLaf can use 3rd party themes created for IntelliJ Platform (see
 ![IntelliJ Platform Themes](images/intellij_platform_themes.png)
 
 
+Sponsors
+--------
+
+### Current Sponsors
+
+<a href="https://www.soptim.de/"><img src="https://www.formdev.com/flatlaf/sponsor/soptim.svg" width="200" alt="SOPTIM" title="SOPTIM - your expert in software solutions for the energy industry"></a>
+&nbsp; &nbsp; &nbsp; &nbsp;
+<a href="https://exocharts.com/"><img src="https://www.formdev.com/flatlaf/sponsor/Exocharts.png" width="200" alt="Exocharts" title="Exocharts - Professional Grade OrderFlow"></a>
+
+<!-- [![None Sponsors](images/none-sponsors.png)](https://www.formdev.com/flatlaf/sponsor/) -->
+
+[Become a Sponsor](https://www.formdev.com/flatlaf/sponsor/)
+
+### Previous Sponsors
+
+<a href="https://www.ej-technologies.com/"><img src="https://www.formdev.com/flatlaf/sponsor/ej-technologies.png" width="200" alt="ej-technologies" title="ej-technologies - Java APM, Java Profiler, Java Installer Builder"></a>
+&nbsp; &nbsp; &nbsp; &nbsp;
+<a href="https://www.dbvis.com/"><img src="https://www.formdev.com/flatlaf/sponsor/dbvisualizer.svg" width="200" alt="DbVisualizer" title="DbVisualizer - SQL Client and Editor"></a>
+&nbsp; &nbsp; &nbsp; &nbsp;
+<a href="https://www.dscsag.com/"><img src="https://www.formdev.com/flatlaf/sponsor/DSC.png" height="48" alt="DSC Software AG" title="DSC Software AG - Your Companion for Integrative PLM"></a>
+
 Demo
 ----
 
@@ -46,18 +72,23 @@ build script:
     artifactId:  flatlaf
     version:     (see button below)
 
-Otherwise download `flatlaf-<version>.jar` here:
+Otherwise, download `flatlaf-<version>.jar` here:
 
-[![Maven Central](https://maven-badges.herokuapp.com/maven-central/com.formdev/flatlaf/badge.svg?style=flat-square&color=007ec6)](https://maven-badges.herokuapp.com/maven-central/com.formdev/flatlaf)
+[![Maven Central](https://img.shields.io/maven-central/v/com.formdev/flatlaf?style=flat-square)](https://central.sonatype.com/artifact/com.formdev/flatlaf)
+
+See also
+[Native Libraries distribution](https://www.formdev.com/flatlaf/native-libraries/)
+for instructions on how to redistribute FlatLaf native libraries with your
+application.
 
 
 ### Snapshots
 
 FlatLaf snapshot binaries are available on
-[Sonatype OSSRH](https://oss.sonatype.org/content/repositories/snapshots/com/formdev/flatlaf/).
+[Sonatype Central](https://central.sonatype.com/service/rest/repository/browse/maven-snapshots/com/formdev/flatlaf/).
 To access the latest snapshot, change the FlatLaf version in your dependencies
-to `<version>-SNAPSHOT` (e.g. `0.27-SNAPSHOT`) and add the repository
-`https://oss.sonatype.org/content/repositories/snapshots/` to your build (see
+to `<version>-SNAPSHOT` (e.g. `3.7-SNAPSHOT`) and add the repository
+`https://central.sonatype.com/repository/maven-snapshots/` to your build (see
 [Maven](https://maven.apache.org/guides/mini/guide-multiple-repositories.html)
 and
 [Gradle](https://docs.gradle.org/current/userguide/declaring_repositories.html#sec:declaring_custom_repository)
@@ -74,6 +105,8 @@ Addons
 - [SwingX](flatlaf-swingx) - support for SwingX components
 - [JIDE Common Layer](flatlaf-jide-oss) - support for JIDE Common Layer
   components
+- [Fonts](flatlaf-fonts) - some font families bundled in easy-to-use and
+  redistributable JARs
 
 
 Getting started
@@ -99,14 +132,26 @@ For more information and documentation visit
 - [Customizing](https://www.formdev.com/flatlaf/customizing/)
 - [How to Customize](https://www.formdev.com/flatlaf/how-to-customize/)
 - [Properties Files](https://www.formdev.com/flatlaf/properties-files/)
+- [Components UI Properties](https://www.formdev.com/flatlaf/components/)
+- [Typography](https://www.formdev.com/flatlaf/typography/)
 - [Client Properties](https://www.formdev.com/flatlaf/client-properties/)
 - [System Properties](https://www.formdev.com/flatlaf/system-properties/)
 
 
+Theme Editor
+------------
+
+The Theme Editor that supports editing FlatLaf theme properties files. See
+[Theme Editor documentation](https://www.formdev.com/flatlaf/theme-editor/) for
+details and downloads.
+
+![Theme Editor](images/theme-editor@1.5x.png)
+
+
 Buzz
 ----
 
-- [What others say about FlatLaf on Twitter](https://twitter.com/search?f=live&q=flatlaf)
+- [FlatLaf 3.1 (and 3.0) announcement on Reddit](https://www.reddit.com/r/java/comments/12xgrsu/flatlaf_31_and_30_swing_look_and_feel/)
 - [FlatLaf 1.0 announcement on Reddit](https://www.reddit.com/r/java/comments/lsbcwe/flatlaf_10_swing_look_and_feel/)
 - [FlatLaf announcement on Reddit](https://www.reddit.com/r/java/comments/dl0hu3/flatlaf_flat_look_and_feel/)
 
@@ -114,89 +159,231 @@ Buzz
 Applications using FlatLaf
 --------------------------
 
-- [Apache NetBeans](https://netbeans.apache.org/) 11.3 - IDE for Java, PHP, HTML
-  and much more
-- [jclasslib bytecode viewer](https://github.com/ingokegel/jclasslib) 5.5
-- [KeyStore Explorer](https://keystore-explorer.org/) 5.4.3
-- ![New](images/new.svg)
+### Featured
+
+- ![Sponsor](images/sponsor.svg) [JFormDesigner](https://www.formdev.com/)
+  (**commercial**) - Java/Swing GUI Designer (from the FlatLaf creators)
+- ![Sponsor](images/sponsor.svg)
+  [JProfiler](https://www.ej-technologies.com/products/jprofiler/overview.html)
+  (**commercial**) - the award-winning all-in-one Java profiler
+- ![Sponsor](images/sponsor.svg)
   [install4j](https://www.ej-technologies.com/products/install4j/overview.html)
-  9.0 (**commercial**) - the powerful multi-platform Java installer builder
-- ![New](images/new.svg) [DbVisualizer](https://www.dbvis.com/) 12.0
+  (**commercial**) - the powerful multi-platform Java installer builder
+- ![Sponsor](images/sponsor.svg) [DbVisualizer](https://www.dbvis.com/)
   (**commercial**) - the universal database tool for developers, analysts and
   DBAs
-- ![New](images/new.svg) [MagicPlot](https://magicplot.com/) 3.0
-  (**commercial**) - Software for nonlinear fitting, plotting and data analysis
+- ![Hot](images/hot.svg) [Apache NetBeans](https://netbeans.apache.org/) - IDE
+  for Java, PHP, HTML and much more
+- ![Sponsor](images/sponsor.svg)
+  [Thermo-Calc](https://thermocalc.com/products/thermo-calc/) (**commercial**) -
+  Thermodynamics and Properties Software
+
+### Data
+
+- ![Hot](images/hot.svg) [Ultorg](https://www.ultorg.com/) (**commercial**) - a
+  visual query system for relational databases
+- [Jailer](https://github.com/Wisser/Jailer) - database subsetting and
+  relational data browsing tool
+- ![Hot](images/hot.svg) [MagicPlot](https://magicplot.com/) (**commercial**) -
+  Software for nonlinear fitting, plotting and data analysis
+- [Constellation](https://www.constellation-app.com/) - Data Visualization and
+  Analytics (based on NetBeans platform)
+- [Kafka Visualizer](https://github.com/kumait/kafkavisualizer) - Kafka GUI
+  client
 - ![New](images/new.svg)
-  [Thermo-Calc](https://thermocalc.com/products/thermo-calc/) 2021a
-  (**commercial**) - Thermodynamics and Properties Software
-- [OWASP ZAP](https://www.zaproxy.org/) 2.10 - the worlds most widely used web
-  app scanner
+  [RedisFront](https://github.com/dromara/RedisFront/blob/master/README_EN.md) -
+  Cross-platform redis GUI
 - ![New](images/new.svg)
+  [Zettelkasten](https://github.com/Zettelkasten-Team/Zettelkasten) - knowledge
+  management tool
+- ![New](images/new.svg) [QStudio](https://www.timestored.com/qstudio/) - free
+  SQL editor
+
+### Security
+
+- ![Hot](images/hot.svg) [ZAP](https://www.zaproxy.org/) - the world's most
+  widely used web app scanner
+- ![Hot](images/hot.svg)
   [Burp Suite Professional and Community Edition](https://portswigger.net/burp/pro)
-  2020.11.2 (**commercial**) - the leading software for web security testing
-- ![New](images/new.svg)
-  [BurpCustomizer](https://github.com/CoreyD97/BurpCustomizer) - adds more
+  (**commercial**) - the leading software for web security testing
+- [Ghidra](https://github.com/NationalSecurityAgency/ghidra) - a software
+  reverse engineering (SRE) framework
+- [jadx](https://github.com/skylot/jadx) - Dex to Java decompiler
+- [BurpCustomizer](https://github.com/CoreyD97/BurpCustomizer) - adds more
   FlatLaf themes to Burp Suite
-- [JOSM](https://josm.openstreetmap.de/) - an extensible editor for
-  [OpenStreetMap](https://www.openstreetmap.org/) (requires FlatLaf JOSM plugin)
-- [jAlbum](https://jalbum.net/) 21 (**commercial**) - creates photo album
-  websites
-- [XMLmind XML Editor](https://www.xmlmind.com/xmleditor/) 9.3 (**commercial**)
-- [Total Validator](https://www.totalvalidator.com/) 15 (**commercial**) -
-  checks your website
-- [j-lawyer](https://github.com/jlawyerorg/j-lawyer-org) - Kanzleisoftware
-- [MegaMek](https://github.com/MegaMek/megamek) v0.47.4 and
-  [MekHQ](https://github.com/MegaMek/mekhq) v0.47.5 - a turn-based sci-fi board
-  game
-- [GUIslice Builder](https://github.com/ImpulseAdventure/GUIslice-Builder)
-  0.13.b024 - GUI builder for
-  [GUIslice](https://github.com/ImpulseAdventure/GUIslice), a lightweight GUI
-  framework for embedded displays
-- [Rest Suite](https://github.com/supanadit/restsuite) - Rest API testing
-- [ControllerBuddy](https://github.com/bwRavencl/ControllerBuddy) - advanced
-  gamepad mapping software
-- [SpringRemote](https://github.com/HaleyWang/SpringRemote) - remote Linux SSH
-  connections manager
-- [jEnTunnel](https://github.com/ggrandes/jentunnel) - manage SSH Tunnels made
-  easy
+- [Total Validator](https://www.totalvalidator.com/) (**commercial**) - checks
+  your website
+- [JPass](https://github.com/gaborbata/jpass) - password manager with strong
+  encryption
+
+### Software Development
+
+- [jclasslib bytecode viewer](https://github.com/ingokegel/jclasslib)
+- [KeyStore Explorer](https://keystore-explorer.org/)
+- [muCommander](https://github.com/mucommander/mucommander) - lightweight
+  cross-platform file manager
+- [Guiffy](https://www.guiffy.com/) (**commercial**) - advanced cross-platform
+  Diff/Merge
+- [HashGarten](https://github.com/jonelo/HashGarten) - cross-platform Swing GUI
+  for Jacksum
+- [Pseudo Assembler IDE](https://github.com/tomasz-herman/PseudoAssemblerIDE) -
+  IDE for Pseudo-Assembler
+- [Linotte](https://github.com/cpc6128/LangageLinotte) - French programming
+  language created to learn programming
+- [lsfusion platform](https://github.com/lsfusion/platform) - information
+  systems development platform
+- ![New](images/new.svg) [Consulo](https://github.com/consulo/consulo) - open
+  source cross-platform multi-language IDE (Java, .NET, JS, etc)
+- [Convertigo](https://github.com/convertigo/convertigo) - low code & no code
+  mobile & web platform
+- ![New](images/new.svg) [EduMIPS64](https://github.com/EduMIPS64/edumips64) -
+  visual MIPS64 CPU simulator
+- ![New](images/new.svg) [Launch4j](https://launch4j.sourceforge.net/) -
+  cross-platform Java executable wrapper
+
+### Electrical
+
+- [Antares](https://www.antarescircuit.io/) - a free, powerful platform for
+  designing, simulating and explaining digital circuits
+- [Logisim-evolution](https://github.com/logisim-evolution/logisim-evolution) -
+  Digital logic design tool and simulator
+- ![New](images/new.svg) [OpenPnP](https://github.com/openpnp/openpnp) - SMT
+  Pick and Place Hardware and Software
+- ![New](images/new.svg)
+  [TrainControl](https://github.com/bob123456678/TrainControl) - control Marklin
+  / Trix / DCC digital model train layout
+- [Makelangelo Software](https://github.com/MarginallyClever/Makelangelo-software) -
+  for plotters, especially the wall-hanging polargraph
+- [GUIslice Builder](https://github.com/ImpulseAdventure/GUIslice-Builder) - GUI
+  builder for [GUIslice](https://github.com/ImpulseAdventure/GUIslice), a
+  lightweight GUI framework for embedded displays
+- [ThunderFocus](https://github.com/marcocipriani01/ThunderFocus) -
+  Arduino-based telescope focuser
+- [RemoteLight](https://github.com/Drumber/RemoteLight) - multifunctional LED
+  control software
+
+### Media
+
+- ![Hot](images/hot.svg) [jAlbum](https://jalbum.net/) (**commercial**) -
+  creates photo album websites
+- [MediathekView](https://mediathekview.de/) - search in media libraries of
+  various German broadcasters
+- ![New](images/new.svg) [Pixelitor](https://github.com/lbalazscs/Pixelitor) -
+  image editor
+- [Cinecred](https://loadingbyte.com/cinecred/) - create beautiful film credit
+  sequences
+- [tinyMediaManager](https://www.tinymediamanager.org/) (**commercial**) - a
+  media management tool
+- [Weasis](https://nroduit.github.io/) - medical DICOM viewer used in healthcare
+  by hospitals, health networks, etc
+- [Shutter Encoder](https://www.shutterencoder.com/)
+  ([source code](https://github.com/paulpacifico/shutter-encoder)) -
+  professional video converter and compression tool
+- [Sound Analysis](https://github.com/tomasz-herman/SoundAnalysis) - analyze
+  sound files in time or frequency domain
+- [Novel-Grabber](https://github.com/Flameish/Novel-Grabber) - download novels
+  from any webnovel and lightnovel site
+- [lectureStudio](https://www.lecturestudio.org/) - digitize your lectures with
+  ease
+- ![New](images/new.svg) [Nortantis](https://jandjheydorn.com/nortantis) -
+  fantasy map generator and editor
+
+### Modelling / Planning
+
+- ![New](images/new.svg) [OpenRocket](https://github.com/openrocket/openrocket) -
+  model-rocketry aerodynamics and trajectory simulation software
+- ![New](images/new.svg)
+  [Warteschlangensimulator](https://github.com/A-Herzog/Warteschlangensimulator) -
+  discrete-event stochastic simulator
+- ![New](images/new.svg) [Gephi](https://github.com/gephi/gephi) - the Open
+  Graph Viz Platform
+- [Astah](https://astah.net/) (**commercial**) - create UML, ER Diagram,
+  Flowchart, Data Flow Diagram, Requirement Diagram, SysML diagrams and more
+- [IGMAS+](https://www.gfz-potsdam.de/igmas) - Interactive Gravity and Magnetic
+  Application System
+- ![New](images/new.svg) [StarPlan](https://www.progotec.de/) (**commercial**) -
+  die Stundenplan Software für Bildungseinrichtungen
+- ![New](images/new.svg) [SSPlot](https://github.com/babaissarkar/ssplot) -
+  plotting utility for plotting CSV data
+
+### Documents
+
+- [Big Faceless (BFO) PDF Viewer](https://bfo.com/) (**commercial**) - Swing PDF
+  Viewer
+- [PDF Studio](https://www.qoppa.com/pdfstudio/) (**commercial**) - create,
+  review and edit PDF documents
+- [XMLmind XML Editor](https://www.xmlmind.com/xmleditor/) (**commercial**)
+
+### Geo
+
+- ![Hot](images/hot.svg) [JOSM](https://josm.openstreetmap.de/) - an extensible
+  editor for [OpenStreetMap](https://www.openstreetmap.org/) (requires FlatLaf
+  JOSM plugin)
+- [Mapton](https://mapton.org/)
+  ([source code](https://github.com/trixon/mapton)) - some kind of map
+  application (based on NetBeans platform)
+- [MeteoInfo](https://github.com/meteoinfo/MeteoInfo) - GIS and scientific
+  computation environment for meteorological community
+
+### Business / Legal
+
+- ![New](images/new.svg) ![Sponsor](images/sponsor.svg)
+  [Lisheane ERP](https://www.lisheane.ch/) (**commercial**) - backoffice
+  applikation
+- ![Sponsor](images/sponsor.svg)
+  [j-lawyer](https://github.com/jlawyerorg/j-lawyer-org) - Kanzleisoftware
+- ![Sponsor](images/sponsor.svg) [Jeyla Studio](https://www.jeylastudio.com/) -
+  Salon Software
+- [Fanurio](https://www.fanuriotimetracking.com/) (**commercial**) - time
+  tracking and billing for freelancers and teams
+- [Jes](https://www.jes-eur.de) - Die Java-EÜR
 - [mendelson AS2](https://sourceforge.net/projects/mec-as2/),
   [AS4](https://sourceforge.net/projects/mendelson-as4/) and
   [OFTP2](https://sourceforge.net/projects/mendelson-oftp2/) (open-source) and
   [mendelson AS2](https://mendelson-e-c.com/as2/),
   [AS4](https://mendelson-e-c.com/as4/) and
   [OFTP2](https://mendelson-e-c.com/oftp2) (**commercial**)
-- ![New](images/new.svg) [IGMAS+](https://www.gfz-potsdam.de/igmas) -
-  Interactive Gravity and Magnetic Application System
-- [MeteoInfo](https://github.com/meteoinfo/MeteoInfo) 2.2 - GIS and scientific
-  computation environment for meteorological community
-- [lsfusion platform](https://github.com/lsfusion/platform) 4 - information
-  systems development platform
-- [JPass](https://github.com/gaborbata/jpass) - password manager with strong
-  encryption
-- [Jes - Die Java-E<>R](https://www.jes-eur.de)
-- [Mapton](https://mapton.org/) 2.0
-  ([source code](https://github.com/trixon/mapton)) - some kind of map
-  application (based on NetBeans platform)
-- [Pseudo Assembler IDE](https://github.com/tomasz-herman/PseudoAssemblerIDE) -
-  IDE for Pseudo-Assembler
-- [Linotte](https://github.com/cpc6128/LangageLinotte) 3.1 - French programming
-  language created to learn programming
-- [MEKA](https://github.com/Waikato/meka) 1.9.3 - multi-label classifiers and
-  evaluation procedures using the Weka machine learning framework
-- [Shutter Encoder](https://www.shutterencoder.com/) 14.2
-  ([source code](https://github.com/paulpacifico/shutter-encoder)) -
-  professional video converter and compression tool (screenshots show **old**
-  look)
-- [Sound Analysis](https://github.com/tomasz-herman/SoundAnalysis) - analyze
-  sound files in time or frequency domain
-- [RemoteLight](https://github.com/Drumber/RemoteLight) - multifunctional LED
-  control software
-- [ThunderFocus](https://github.com/marcocipriani01/ThunderFocus) -
-  Arduino-based telescope focuser
-- [Novel-Grabber](https://github.com/Flameish/Novel-Grabber) - download novels
-  from any webnovel and lightnovel site
-- [lectureStudio](https://www.lecturestudio.org/) 4.3.1060 - digitize your
-  lectures with ease
+
+### Messaging
+
+- [Spark](https://github.com/igniterealtime/Spark) - cross-platform IM client
+  optimized for businesses and organizations
+- [Chatty](https://github.com/chatty/chatty) - Twitch Chat Client
+
+### Gaming
+
+- ![Sponsor](images/sponsor.svg) [BGBlitz](https://www.bgblitz.com/)
+  (**commercial**) - professional Backgammon
+- ![New](images/new.svg) [josé](https://peteschaefer.github.io/jose/) - a
+  graphical chess tool
+- ![New](images/new.svg) [MCreator](https://github.com/MCreator/MCreator) - make
+  Minecraft Java Edition mods, Minecraft Bedrock Edition Add-Ons, and data packs
+- [MapTool](https://github.com/RPTools/maptool) - virtual Tabletop for playing
+  role-playing games
+- [MegaMek](https://github.com/MegaMek/megamek),
+  [MegaMekLab](https://github.com/MegaMek/megameklab) and
+  [MekHQ](https://github.com/MegaMek/mekhq) - a sci-fi tabletop BattleTech
+  simulator suite handling battles, unit building, and campaigns
+- [ControllerBuddy](https://github.com/bwRavencl/ControllerBuddy) - advanced
+  gamepad mapping software
+
+### Utilities
+
+- [MooInfo](https://github.com/rememberber/MooInfo) - visual implementation of
+  OSHI, to view information about the system and hardware
+- [Linux Task Manager (LTM)](https://github.com/ajee10x/LTM-LinuxTaskManager) -
+  GUI for monitoring and managing various aspects of a Linux system
+- [Rest Suite](https://github.com/supanadit/restsuite) - Rest API testing
+- [SpringRemote](https://github.com/HaleyWang/SpringRemote) - remote Linux SSH
+  connections manager
+- [jEnTunnel](https://github.com/ggrandes/jentunnel) - manage SSH Tunnels made
+  easy
 - [Android Tool](https://github.com/fast-geek/Android-Tool) - makes popular adb
   and fastboot commands easier to use
-- and more...
+- ![New](images/new.svg) [Termora](https://github.com/TermoraDev/termora) -
+  Terminal emulator and SSH client
+
+### Miscellaneous
+
+- [MEKA](https://github.com/Waikato/meka) - multi-label classifiers and
+  evaluation procedures using the Weka machine learning framework

build.gradle.kts

@@ -14,22 +14,30 @@
  * limitations under the License.
  */
 
-val releaseVersion = "1.6.4"
-val developmentVersion = "2.0-SNAPSHOT"
+import io.github.gradlenexus.publishplugin.CloseNexusStagingRepository
+import net.ltgt.gradle.errorprone.errorprone
+import org.gradle.kotlin.dsl.withType
 
-version = if( java.lang.Boolean.getBoolean( "release" ) ) releaseVersion else developmentVersion
 
-allprojects {
+// initialize version
+group = "com.formdev"
+version = property( if( hasProperty( "release" ) ) "flatlaf.releaseVersion" else "flatlaf.developmentVersion" ) as String
+
+// for PR snapshots change version to 'PR-<pr_number>-SNAPSHOT'
+val pullRequestNumber = findProperty( "github.event.pull_request.number" )
+if( pullRequestNumber != null )
+	version = "PR-${pullRequestNumber}-SNAPSHOT"
+
+// apply version to all subprojects
+subprojects {
 	version = rootProject.version
-
-	repositories {
-		mavenCentral()
-	}
 }
 
-// check required Java version
-if( JavaVersion.current() < JavaVersion.VERSION_1_8 )
-	throw RuntimeException( "Java 8 or later required (running ${System.getProperty( "java.version" )})" )
+
+// initialize toolchain version (default is Java 8)
+val toolchainJavaVersion: String by extra {
+	System.getProperty( "toolchain", "8" )
+}
 
 // log version, Gradle and Java versions
 println()
@@ -37,10 +45,20 @@ println( "----------------------------------------------------------------------
 println( "FlatLaf Version: ${version}" )
 println( "Gradle ${gradle.gradleVersion} at ${gradle.gradleHomeDir}" )
 println( "Java ${System.getProperty( "java.version" )}" )
+println( "Java toolchain ${toolchainJavaVersion}" )
 println()
 
 
+plugins {
+	alias( libs.plugins.gradle.nexus.publish.plugin )
+	alias( libs.plugins.errorprone ) apply false
+}
+
 allprojects {
+	repositories {
+		mavenCentral()
+	}
+
 	tasks {
 		withType<JavaCompile>().configureEach {
 			sourceCompatibility = "1.8"
@@ -64,6 +82,10 @@ allprojects {
 			}
 		}
 
+		withType<AbstractArchiveTask>().configureEach {
+			isPreserveFileTimestamps = true
+		}
+
 		withType<Javadoc>().configureEach {
 			options {
 				this as StandardJavadocDocletOptions
@@ -76,6 +98,101 @@ allprojects {
 				links( "https://docs.oracle.com/en/java/javase/11/docs/api/" )
 			}
 			isFailOnError = false
+
+			// use Java 25 to generate javadoc
+			val javaToolchains = (project as ExtensionAware).extensions.getByName("javaToolchains") as JavaToolchainService
+			javadocTool.set( javaToolchains.javadocToolFor {
+				languageVersion.set( JavaLanguageVersion.of( 25 ) )
+			} )
+		}
+
+		// mark some publishing related tasks as not compatible with configuration cache
+		withType<Sign>().configureEach {
+			notCompatibleWithConfigurationCache( "not compatible" )
+		}
+		withType<PublishToMavenRepository>().configureEach {
+			notCompatibleWithConfigurationCache( "not compatible" )
+		}
+		withType<CloseNexusStagingRepository>().configureEach {
+			notCompatibleWithConfigurationCache( "not compatible" )
+		}
+	}
+
+
+	//---- Error Prone ----
+
+	tasks.register( "errorprone" ) {
+		group = "verification"
+		tasks.withType<JavaCompile>().forEach {
+			dependsOn( it )
+		}
+	}
+
+	val useErrorProne = gradle.startParameter.taskNames.contains( "errorprone" )
+	if( useErrorProne ) {
+		plugins.withType<JavaPlugin> {
+			apply( plugin = libs.plugins.errorprone.get().pluginId )
+
+			dependencies {
+				"errorprone"( libs.errorprone )
+			}
+
+			tasks.withType<JavaCompile>().configureEach {
+				options.compilerArgs.add( "-Werror" )
+				options.errorprone {
+					disable(
+						"ReferenceEquality",	// reports usage of '==' for objects
+						"StringSplitter",		// reports String.split()
+						"JavaTimeDefaultTimeZone",	// reports Year.now()
+						"MissingSummary",		// reports `/** @since 2 */`
+						"InvalidBlockTag",		// reports @uiDefault in javadoc
+						"AlreadyChecked",		// reports false positives
+						"InlineMeSuggester",	// suggests using Error Prone annotations for deprecated methods
+						"TypeParameterUnusedInFormals",
+						"UnsynchronizedOverridesSynchronized",
+						"NonApiType",			// reports ArrayList/HashSet in parameter or return type
+					)
+					when( project.name ) {
+						"flatlaf-intellij-themes" -> disable(
+							"MutablePublicArray",	// reports FlatAllIJThemes.INFOS
+						)
+						"flatlaf-theme-editor" -> disable(
+							"CatchAndPrintStackTrace",
+						)
+						"flatlaf-testing" -> disable(
+							"CatchAndPrintStackTrace",
+							"JdkObsolete",			// reports Hashtable used for JSlider.setLabelTable()
+							"JavaUtilDate",			// reports usage of class Date
+						)
+					}
+				}
+
+				// Error Prone requires at lease Java 11
+				val java = (project as ExtensionAware).extensions.getByName("java") as JavaPluginExtension
+				val javaToolchains = (project as ExtensionAware).extensions.getByName("javaToolchains") as JavaToolchainService
+				if( java.toolchain.languageVersion.get().asInt() < 11 ) {
+					javaCompiler.set( javaToolchains.compilerFor {
+						languageVersion.set( JavaLanguageVersion.of( 11 ) )
+					} )
+				}
+			}
+		}
+	}
+}
+
+nexusPublishing {
+	repositories {
+		sonatype {
+			// see https://central.sonatype.org/publish/publish-portal-ossrh-staging-api/
+			nexusUrl = uri( "https://ossrh-staging-api.central.sonatype.com/service/local/" )
+			snapshotRepositoryUrl = uri( "https://central.sonatype.com/repository/maven-snapshots/" )
+
+			// get from gradle.properties
+			val sonatypeUsername: String? by project
+			val sonatypePassword: String? by project
+
+			username = System.getenv( "SONATYPE_USERNAME" ) ?: sonatypeUsername
+			password = System.getenv( "SONATYPE_PASSWORD" ) ?: sonatypePassword
 		}
 	}
 }

buildSrc/src/main/java/ReorderJarEntries.java

@@ -45,7 +45,7 @@ public class ReorderJarEntries
 			// 1st pass: copy .properties files
 			copyFiles( zipOutStream, jarFile, name -> name.endsWith( ".properties" ) );
 
-			// 2st pass: copy other files
+			// 2nd pass: copy other files
 			copyFiles( zipOutStream, jarFile, name -> !name.endsWith( ".properties" ) );
 		}
 

buildSrc/src/main/kotlin/flatlaf-cpp-library.gradle.kts

@@ -0,0 +1,53 @@
+/*
+ * Copyright 2022 FormDev Software GmbH
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import org.gradle.kotlin.dsl.support.serviceOf
+
+plugins {
+	`cpp-library`
+}
+
+library {
+	// disable debuggable for release builds to make shared libraries smaller
+	binaries.configureEach( CppSharedLibrary::class ) {
+		with( compileTask.get() ) {
+			if( name.contains( "Release" ) )
+				isDebuggable = false
+		}
+		with( linkTask.get() ) {
+			if( name.contains( "Release" ) )
+				debuggable = false
+		}
+	}
+}
+
+tasks {
+	withType<CppCompile>().configureEach {
+		doFirst {
+			println( "Used Tool Chain:" )
+			println( "  - ${toolChain.get()}" )
+		}
+
+		if( !project.gradle.serviceOf<BuildFeatures>().configurationCache.active.get() ) {
+			doFirst {
+				println( "Available Tool Chains:" )
+				toolChains.forEach {
+					println( "  - $it" )
+				}
+			}
+		}
+	}
+}

buildSrc/src/main/kotlin/flatlaf-java9.gradle.kts

@@ -18,7 +18,14 @@ plugins {
 	java
 }
 
-if( JavaVersion.current() >= JavaVersion.VERSION_1_9 ) {
+// for Eclipse IDE project import, exclude if:
+// - plugin "eclipse" is applied; e.g. if running in Eclipse IDE with buildship plugin
+// - no taskNames specified at command line; e.g. if buildship synchronizes projects
+val exclude =
+	rootProject.plugins.hasPlugin( "eclipse" ) &&
+	gradle.startParameter.taskNames.isEmpty()
+
+if( !exclude ) {
 	sourceSets {
 		create( "java9" ) {
 			java {
@@ -28,13 +35,20 @@ if( JavaVersion.current() >= JavaVersion.VERSION_1_9 ) {
 	}
 
 	dependencies {
-		add( "java9Compile", sourceSets.main.get().output )
+		add( "java9Implementation", sourceSets.main.get().output )
 	}
 
 	tasks {
 		named<JavaCompile>( "compileJava9Java" ) {
 			sourceCompatibility = "9"
 			targetCompatibility = "9"
+
+			// if global toolchain is Java 8, then use Java 11 to build
+			if( java.toolchain.languageVersion.get().asInt() < 9 ) {
+				javaCompiler.set( javaToolchains.compilerFor {
+					languageVersion.set( JavaLanguageVersion.of( 11 ) )
+				} )
+			}
 		}
 
 		jar {

buildSrc/src/main/kotlin/flatlaf-jni-headers.gradle.kts

@@ -0,0 +1,36 @@
+/*
+ * Copyright 2022 FormDev Software GmbH
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+open class JniHeadersExtension {
+	var headers: List<String> = emptyList()
+}
+
+val extension = project.extensions.create<JniHeadersExtension>( "flatlafJniHeaders" )
+
+
+tasks {
+	register<Copy>( "jni-headers" ) {
+		// depend on :flatlaf-core:compileJava because it generates the JNI headers
+		dependsOn( ":flatlaf-core:compileJava" )
+
+		from( project( ":flatlaf-core" ).layout.buildDirectory.dir( "generated/jni-headers" ) )
+		into( "src/main/headers" )
+		include( extension.headers )
+		filter<org.apache.tools.ant.filters.FixCrLfFilter>(
+			"eol" to org.apache.tools.ant.filters.FixCrLfFilter.CrLf.newInstance( "lf" )
+		)
+	}
+}

buildSrc/src/main/kotlin/flatlaf-module-info.gradle.kts

@@ -29,7 +29,14 @@ plugins {
 	java
 }
 
-if( JavaVersion.current() >= JavaVersion.VERSION_1_9 ) {
+// for Eclipse IDE project import, exclude if:
+// - plugin "eclipse" is applied; e.g. if running in Eclipse IDE with buildship plugin
+// - no taskNames specified at command line; e.g. if buildship synchronizes projects
+val exclude =
+	rootProject.plugins.hasPlugin( "eclipse" ) &&
+	gradle.startParameter.taskNames.isEmpty()
+
+if( !exclude ) {
 	sourceSets {
 		create( "module-info" ) {
 			java {
@@ -38,10 +45,11 @@ if( JavaVersion.current() >= JavaVersion.VERSION_1_9 ) {
 				setSrcDirs( listOf( "src/main/module-info", "src/main/java", "src/main/java9" ) )
 
 				// exclude Java 8 source file if an equally named Java 9+ source file exists
+				val projectDir = projectDir // necessary for configuration cache
 				exclude {
 					if( it.isDirectory )
 						return@exclude false
-					val java9file = file( "${projectDir}/src/main/java9/${it.path}" )
+					val java9file = File( "${projectDir}/src/main/java9/${it.path}" )
 					java9file.exists() && java9file != it.file
 				}
 			}
@@ -58,15 +66,18 @@ if( JavaVersion.current() >= JavaVersion.VERSION_1_9 ) {
 			options.compilerArgs.add( "--module-path" )
 			options.compilerArgs.add( configurations.runtimeClasspath.get().asPath
 				+ File.pathSeparator + configurations.compileClasspath.get().asPath )
+
+			// if global toolchain is Java 8, then use Java 11 to build
+			if( java.toolchain.languageVersion.get().asInt() < 9 ) {
+				javaCompiler.set( javaToolchains.compilerFor {
+					languageVersion.set( JavaLanguageVersion.of( 11 ) )
+				} )
+			}
 		}
 
 		jar {
-			manifest.attributes( "Multi-Release" to "true" )
-
-			into( "META-INF/versions/9" ) {
-				from( sourceSets["module-info"].output ) {
-					include( "module-info.class" )
-				}
+			from( sourceSets["module-info"].output ) {
+				include( "module-info.class" )
 			}
 		}
 	}

buildSrc/src/main/kotlin/flatlaf-publish.gradle.kts

@@ -15,10 +15,13 @@
  */
 
 
+open class NativeArtifact( val fileName: String, val classifier: String, val extension: String ) {}
+
 open class PublishExtension {
 	var artifactId: String? = null
 	var name: String? = null
 	var description: String? = null
+	var nativeArtifacts: List<NativeArtifact>? = null
 }
 
 val extension = project.extensions.create<PublishExtension>( "flatlafPublish" )
@@ -41,54 +44,44 @@ publishing {
 
 			pom {
 				afterEvaluate {
-					this@pom.name.set( extension.name )
-					this@pom.description.set( extension.description )
+					this@pom.name = extension.name
+					this@pom.description = extension.description
 				}
-				url.set( "https://github.com/JFormDesigner/FlatLaf" )
+				url = "https://github.com/JFormDesigner/FlatLaf"
 
 				licenses {
 					license {
-						name.set( "The Apache License, Version 2.0" )
-						url.set( "https://www.apache.org/licenses/LICENSE-2.0.txt" )
+						name = "The Apache License, Version 2.0"
+						url = "https://www.apache.org/licenses/LICENSE-2.0.txt"
 					}
 				}
 
 				developers {
 					developer {
-						name.set( "Karl Tauber" )
-						organization.set( "FormDev Software GmbH" )
-						organizationUrl.set( "https://www.formdev.com/" )
+						name = "Karl Tauber"
+						organization = "FormDev Software GmbH"
+						organizationUrl = "https://www.formdev.com/"
 					}
 				}
 
 				scm {
-					connection.set( "scm:git:git://github.com/JFormDesigner/FlatLaf.git" )
-					url.set( "https://github.com/JFormDesigner/FlatLaf" )
+					connection = "scm:git:git://github.com/JFormDesigner/FlatLaf.git"
+					url = "https://github.com/JFormDesigner/FlatLaf"
 				}
 
 				issueManagement {
-					system.set( "GitHub" )
-					url.set( "https://github.com/JFormDesigner/FlatLaf/issues" )
+					system = "GitHub"
+					url = "https://github.com/JFormDesigner/FlatLaf/issues"
 				}
 			}
-		}
-	}
 
-	repositories {
-		maven {
-			name = "OSSRH"
-
-			val releasesRepoUrl = "https://oss.sonatype.org/service/local/staging/deploy/maven2/"
-			val snapshotsRepoUrl = "https://oss.sonatype.org/content/repositories/snapshots/"
-			url = uri( if( java.lang.Boolean.getBoolean( "release" ) ) releasesRepoUrl else snapshotsRepoUrl )
-
-			credentials {
-				// get from gradle.properties
-				val ossrhUsername: String? by project
-				val ossrhPassword: String? by project
-
-				username = System.getenv( "OSSRH_USERNAME" ) ?: ossrhUsername
-				password = System.getenv( "OSSRH_PASSWORD" ) ?: ossrhPassword
+			afterEvaluate {
+				extension.nativeArtifacts?.forEach {
+					artifact( file( it.fileName ) ) {
+						classifier = it.classifier
+						extension = it.extension
+					}
+				}
 			}
 		}
 	}
@@ -108,5 +101,25 @@ signing {
 
 // disable signing of snapshots
 tasks.withType<Sign>().configureEach {
-	onlyIf { java.lang.Boolean.getBoolean( "release" ) }
+	onlyIf { rootProject.hasProperty( "release" ) }
+}
+
+tasks {
+	// check whether parallel build is enabled
+	withType<AbstractPublishToMaven>().configureEach {
+		doFirst {
+			if( System.getProperty( "org.gradle.parallel" ) == "true" )
+				throw RuntimeException( "Publishing does not work correctly with enabled parallel build. Disable parallel build with VM option '-Dorg.gradle.parallel=false'." )
+		}
+	}
+
+	register( "publishToSonatypeAndCloseStagingRepo" ) {
+		group = "publishing"
+		description = "Publish to Sonatype Maven Central and close staging repository"
+
+		dependsOn(
+			"publishToSonatype",
+			":closeSonatypeStagingRepository"
+		)
+	}
 }

buildSrc/src/main/kotlin/flatlaf-toolchain.gradle.kts

@@ -0,0 +1,25 @@
+/*
+ * Copyright 2022 FormDev Software GmbH
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+plugins {
+	java
+}
+
+val toolchainJavaVersion: String by rootProject.extra
+
+java.toolchain {
+	languageVersion = JavaLanguageVersion.of( toolchainJavaVersion )
+}

flatlaf-core/.settings/org.eclipse.core.resources.prefs

@@ -0,0 +1,2 @@
+eclipse.preferences.version=1
+encoding/<project>=ISO-8859-1

flatlaf-core/.settings/org.eclipse.jdt.core.prefs

@@ -1,4 +1,7 @@
 eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8
+org.eclipse.jdt.core.compiler.compliance=1.8
+org.eclipse.jdt.core.compiler.source=1.8
 org.eclipse.jdt.core.formatter.align_assignment_statements_on_columns=false
 org.eclipse.jdt.core.formatter.align_fields_grouping_blank_lines=2147483647
 org.eclipse.jdt.core.formatter.align_type_members_on_columns=false

flatlaf-core/build.gradle.kts

@@ -14,8 +14,11 @@
  * limitations under the License.
  */
 
+import Flatlaf_publish_gradle.NativeArtifact
+
 plugins {
 	`java-library`
+	`flatlaf-toolchain`
 	`flatlaf-module-info`
 	`flatlaf-java9`
 	`flatlaf-publish`
@@ -24,12 +27,11 @@ plugins {
 val sigtest = configurations.create( "sigtest" )
 
 dependencies {
-	testImplementation( "org.junit.jupiter:junit-jupiter-api:5.7.2" )
-	testImplementation( "org.junit.jupiter:junit-jupiter-params" )
-	testRuntimeOnly( "org.junit.jupiter:junit-jupiter-engine" )
+	testImplementation( libs.junit )
+	testRuntimeOnly( libs.junit.launcher )
 
 	// https://github.com/jtulach/netbeans-apitest
-	sigtest( "org.netbeans.tools:sigtest-maven-plugin:1.4" )
+	sigtest( libs.sigtest )
 }
 
 java {
@@ -40,16 +42,11 @@ java {
 tasks {
 	compileJava {
 		// generate JNI headers
-		options.headerOutputDirectory.set( buildDir.resolve( "generated/jni-headers" ) )
-	}
-
-	processResources {
-		// build native libraries
-		dependsOn( ":flatlaf-natives-windows:assemble" )
+		options.headerOutputDirectory = layout.buildDirectory.dir( "generated/jni-headers" )
 	}
 
 	jar {
-		archiveBaseName.set( "flatlaf" )
+		archiveBaseName = "flatlaf"
 
 		doLast {
 			ReorderJarEntries.reorderJarEntries( outputs.files.singleFile );
@@ -57,11 +54,32 @@ tasks {
 	}
 
 	named<Jar>( "sourcesJar" ) {
-		archiveBaseName.set( "flatlaf" )
+		archiveBaseName = "flatlaf"
 	}
 
 	named<Jar>( "javadocJar" ) {
-		archiveBaseName.set( "flatlaf" )
+		archiveBaseName = "flatlaf"
+	}
+
+	register<Zip>( "jarNoNatives" ) {
+		group = "build"
+		dependsOn( "jar" )
+
+		archiveBaseName = "flatlaf"
+		archiveClassifier = "no-natives"
+		archiveExtension = "jar"
+		destinationDirectory = layout.buildDirectory.dir( "libs" )
+
+		from( zipTree( jar.get().archiveFile.get().asFile ) )
+		exclude( "com/formdev/flatlaf/natives/**" )
+	}
+
+	withType<AbstractPublishToMaven>().configureEach {
+		dependsOn( "jarNoNatives" )
+	}
+
+	withType<Sign>().configureEach {
+		dependsOn( "jarNoNatives" )
 	}
 
 	check {
@@ -71,27 +89,40 @@ tasks {
 	test {
 		useJUnitPlatform()
 		testLogging.exceptionFormat = org.gradle.api.tasks.testing.logging.TestExceptionFormat.FULL
+
+		if( java.toolchain.languageVersion.get().asInt() >= 9 )
+			jvmArgs( listOf( "--add-opens", "java.desktop/javax.swing.plaf.basic=ALL-UNNAMED" ) )
 	}
 
 	register( "sigtestGenerate" ) {
 		group = "verification"
 		dependsOn( "jar" )
 
+		// necessary for configuration cache
+		val classpath = sigtest.asPath
+		val signatureFile = "${project.name}-sigtest.txt"
+		val jarPath = jar.get().outputs.files.asPath
+		val version = version
+
 		doLast {
 			ant.withGroovyBuilder {
 				"taskdef"(
 					"name" to "sigtest",
 					"classname" to "org.netbeans.apitest.Sigtest",
-					"classpath" to sigtest.asPath )
+					"classpath" to classpath )
 
 				"sigtest"(
 					"action" to "generate",
-					"fileName" to "${project.name}-sigtest.txt",
-					"classpath" to jar.get().outputs.files.asPath,
-					"packages" to "com.formdev.flatlaf,com.formdev.flatlaf.util",
+					"fileName" to signatureFile,
+					"classpath" to jarPath,
+					"packages" to "com.formdev.flatlaf,com.formdev.flatlaf.themes,com.formdev.flatlaf.util",
 					"version" to version,
 					"release" to "1.8", // Java version
 					"failonerror" to "true" )
+
+				"fixcrlf"(
+					"file" to signatureFile,
+					"eol" to "lf" )
 			}
 		}
 	}
@@ -100,17 +131,23 @@ tasks {
 		group = "verification"
 		dependsOn( "jar" )
 
+		// necessary for configuration cache
+		val classpath = sigtest.asPath
+		val signatureFile = "${project.name}-sigtest.txt"
+		val jarPath = jar.get().outputs.files.asPath
+		val version = version
+
 		doLast {
 			ant.withGroovyBuilder {
 				"taskdef"(
 					"name" to "sigtest",
 					"classname" to "org.netbeans.apitest.Sigtest",
-					"classpath" to sigtest.asPath )
+					"classpath" to classpath )
 
 				"sigtest"(
 					"action" to "check",
-					"fileName" to "${project.name}-sigtest.txt",
-					"classpath" to jar.get().outputs.files.asPath,
+					"fileName" to signatureFile,
+					"classpath" to jarPath,
 					"packages" to "com.formdev.flatlaf,com.formdev.flatlaf.util",
 					"version" to version,
 					"release" to "1.8", // Java version
@@ -124,4 +161,17 @@ flatlafPublish {
 	artifactId = "flatlaf"
 	name = "FlatLaf"
 	description = "Flat Look and Feel"
+
+	val natives = "src/main/resources/com/formdev/flatlaf/natives"
+	nativeArtifacts = listOf(
+		NativeArtifact( tasks.getByName( "jarNoNatives" ).outputs.files.asPath, "no-natives", "jar" ),
+
+		NativeArtifact( "${natives}/flatlaf-windows-x86.dll",       "windows-x86",    "dll" ),
+		NativeArtifact( "${natives}/flatlaf-windows-x86_64.dll",    "windows-x86_64", "dll" ),
+		NativeArtifact( "${natives}/flatlaf-windows-arm64.dll",     "windows-arm64",  "dll" ),
+		NativeArtifact( "${natives}/libflatlaf-macos-arm64.dylib",  "macos-arm64",    "dylib" ),
+		NativeArtifact( "${natives}/libflatlaf-macos-x86_64.dylib", "macos-x86_64",   "dylib" ),
+		NativeArtifact( "${natives}/libflatlaf-linux-x86_64.so",    "linux-x86_64",   "so" ),
+		NativeArtifact( "${natives}/libflatlaf-linux-arm64.so",     "linux-arm64",    "so" ),
+	)
 }

flatlaf-core/flatlaf-core-sigtest.txt

@@ -1,5 +1,5 @@
 #Signature file v4.1
-#Version 1.6
+#Version 3.6.2
 
 CLSS public abstract interface com.formdev.flatlaf.FlatClientProperties
 fld public final static java.lang.String BUTTON_TYPE = "JButton.buttonType"
@@ -11,15 +11,26 @@ fld public final static java.lang.String BUTTON_TYPE_TAB = "tab"
 fld public final static java.lang.String BUTTON_TYPE_TOOLBAR_BUTTON = "toolBarButton"
 fld public final static java.lang.String COMPONENT_FOCUS_OWNER = "JComponent.focusOwner"
 fld public final static java.lang.String COMPONENT_ROUND_RECT = "JComponent.roundRect"
+fld public final static java.lang.String COMPONENT_TITLE_BAR_CAPTION = "JComponent.titleBarCaption"
+fld public final static java.lang.String FULL_WINDOW_CONTENT = "FlatLaf.fullWindowContent"
+fld public final static java.lang.String FULL_WINDOW_CONTENT_BUTTONS_BOUNDS = "FlatLaf.fullWindowContent.buttonsBounds"
+fld public final static java.lang.String FULL_WINDOW_CONTENT_BUTTONS_PLACEHOLDER = "FlatLaf.fullWindowContent.buttonsPlaceholder"
+fld public final static java.lang.String GLASS_PANE_FULL_HEIGHT = "JRootPane.glassPaneFullHeight"
+fld public final static java.lang.String MACOS_WINDOW_BUTTONS_SPACING = "FlatLaf.macOS.windowButtonsSpacing"
+fld public final static java.lang.String MACOS_WINDOW_BUTTONS_SPACING_LARGE = "large"
+fld public final static java.lang.String MACOS_WINDOW_BUTTONS_SPACING_MEDIUM = "medium"
 fld public final static java.lang.String MENU_BAR_EMBEDDED = "JRootPane.menuBarEmbedded"
 fld public final static java.lang.String MINIMUM_HEIGHT = "JComponent.minimumHeight"
 fld public final static java.lang.String MINIMUM_WIDTH = "JComponent.minimumWidth"
 fld public final static java.lang.String OUTLINE = "JComponent.outline"
 fld public final static java.lang.String OUTLINE_ERROR = "error"
+fld public final static java.lang.String OUTLINE_SUCCESS = "success"
 fld public final static java.lang.String OUTLINE_WARNING = "warning"
 fld public final static java.lang.String PLACEHOLDER_TEXT = "JTextField.placeholderText"
+fld public final static java.lang.String POPUP_BORDER_CORNER_RADIUS = "Popup.borderCornerRadius"
 fld public final static java.lang.String POPUP_DROP_SHADOW_PAINTED = "Popup.dropShadowPainted"
 fld public final static java.lang.String POPUP_FORCE_HEAVY_WEIGHT = "Popup.forceHeavyWeight"
+fld public final static java.lang.String POPUP_ROUNDED_BORDER_WIDTH = "Popup.roundedBorderWidth"
 fld public final static java.lang.String PROGRESS_BAR_LARGE_HEIGHT = "JProgressBar.largeHeight"
 fld public final static java.lang.String PROGRESS_BAR_SQUARE = "JProgressBar.square"
 fld public final static java.lang.String SCROLL_BAR_SHOW_BUTTONS = "JScrollBar.showButtons"
@@ -30,7 +41,13 @@ fld public final static java.lang.String SELECT_ALL_ON_FOCUS_POLICY = "JTextFiel
 fld public final static java.lang.String SELECT_ALL_ON_FOCUS_POLICY_ALWAYS = "always"
 fld public final static java.lang.String SELECT_ALL_ON_FOCUS_POLICY_NEVER = "never"
 fld public final static java.lang.String SELECT_ALL_ON_FOCUS_POLICY_ONCE = "once"
+fld public final static java.lang.String SELECT_ALL_ON_MOUSE_CLICK = "JTextField.selectAllOnMouseClick"
+fld public final static java.lang.String SPLIT_PANE_EXPANDABLE_SIDE = "JSplitPane.expandableSide"
+fld public final static java.lang.String SPLIT_PANE_EXPANDABLE_SIDE_LEFT = "left"
+fld public final static java.lang.String SPLIT_PANE_EXPANDABLE_SIDE_RIGHT = "right"
 fld public final static java.lang.String SQUARE_SIZE = "JButton.squareSize"
+fld public final static java.lang.String STYLE = "FlatLaf.style"
+fld public final static java.lang.String STYLE_CLASS = "FlatLaf.styleClass"
 fld public final static java.lang.String TABBED_PANE_ALIGN_CENTER = "center"
 fld public final static java.lang.String TABBED_PANE_ALIGN_FILL = "fill"
 fld public final static java.lang.String TABBED_PANE_ALIGN_LEADING = "leading"
@@ -59,6 +76,14 @@ fld public final static java.lang.String TABBED_PANE_TAB_CLOSE_TOOLTIPTEXT = "JT
 fld public final static java.lang.String TABBED_PANE_TAB_HEIGHT = "JTabbedPane.tabHeight"
 fld public final static java.lang.String TABBED_PANE_TAB_ICON_PLACEMENT = "JTabbedPane.tabIconPlacement"
 fld public final static java.lang.String TABBED_PANE_TAB_INSETS = "JTabbedPane.tabInsets"
+fld public final static java.lang.String TABBED_PANE_TAB_ROTATION = "JTabbedPane.tabRotation"
+fld public final static java.lang.String TABBED_PANE_TAB_ROTATION_AUTO = "auto"
+fld public final static java.lang.String TABBED_PANE_TAB_ROTATION_LEFT = "left"
+fld public final static java.lang.String TABBED_PANE_TAB_ROTATION_NONE = "none"
+fld public final static java.lang.String TABBED_PANE_TAB_ROTATION_RIGHT = "right"
+fld public final static java.lang.String TABBED_PANE_TAB_TYPE = "JTabbedPane.tabType"
+fld public final static java.lang.String TABBED_PANE_TAB_TYPE_CARD = "card"
+fld public final static java.lang.String TABBED_PANE_TAB_TYPE_UNDERLINED = "underlined"
 fld public final static java.lang.String TABBED_PANE_TAB_WIDTH_MODE = "JTabbedPane.tabWidthMode"
 fld public final static java.lang.String TABBED_PANE_TAB_WIDTH_MODE_COMPACT = "compact"
 fld public final static java.lang.String TABBED_PANE_TAB_WIDTH_MODE_EQUAL = "equal"
@@ -67,12 +92,29 @@ fld public final static java.lang.String TABBED_PANE_TRAILING_COMPONENT = "JTabb
 fld public final static java.lang.String TAB_BUTTON_SELECTED_BACKGROUND = "JToggleButton.tab.selectedBackground"
 fld public final static java.lang.String TAB_BUTTON_UNDERLINE_COLOR = "JToggleButton.tab.underlineColor"
 fld public final static java.lang.String TAB_BUTTON_UNDERLINE_HEIGHT = "JToggleButton.tab.underlineHeight"
+fld public final static java.lang.String TAB_BUTTON_UNDERLINE_PLACEMENT = "JToggleButton.tab.underlinePlacement"
+fld public final static java.lang.String TEXT_FIELD_CLEAR_CALLBACK = "JTextField.clearCallback"
+fld public final static java.lang.String TEXT_FIELD_LEADING_COMPONENT = "JTextField.leadingComponent"
+fld public final static java.lang.String TEXT_FIELD_LEADING_ICON = "JTextField.leadingIcon"
 fld public final static java.lang.String TEXT_FIELD_PADDING = "JTextField.padding"
+fld public final static java.lang.String TEXT_FIELD_SHOW_CLEAR_BUTTON = "JTextField.showClearButton"
+fld public final static java.lang.String TEXT_FIELD_TRAILING_COMPONENT = "JTextField.trailingComponent"
+fld public final static java.lang.String TEXT_FIELD_TRAILING_ICON = "JTextField.trailingIcon"
 fld public final static java.lang.String TITLE_BAR_BACKGROUND = "JRootPane.titleBarBackground"
 fld public final static java.lang.String TITLE_BAR_FOREGROUND = "JRootPane.titleBarForeground"
+fld public final static java.lang.String TITLE_BAR_HEIGHT = "JRootPane.titleBarHeight"
+fld public final static java.lang.String TITLE_BAR_SHOW_CLOSE = "JRootPane.titleBarShowClose"
+fld public final static java.lang.String TITLE_BAR_SHOW_ICON = "JRootPane.titleBarShowIcon"
+fld public final static java.lang.String TITLE_BAR_SHOW_ICONIFFY = "JRootPane.titleBarShowIconify"
+fld public final static java.lang.String TITLE_BAR_SHOW_MAXIMIZE = "JRootPane.titleBarShowMaximize"
+fld public final static java.lang.String TITLE_BAR_SHOW_TITLE = "JRootPane.titleBarShowTitle"
 fld public final static java.lang.String TREE_PAINT_SELECTION = "JTree.paintSelection"
+fld public final static java.lang.String TREE_WIDE_CELL_RENDERER = "JTree.wideCellRenderer"
 fld public final static java.lang.String TREE_WIDE_SELECTION = "JTree.wideSelection"
 fld public final static java.lang.String USE_WINDOW_DECORATIONS = "JRootPane.useWindowDecorations"
+fld public final static java.lang.String WINDOW_STYLE = "Window.style"
+fld public final static java.lang.String WINDOW_STYLE_SMALL = "small"
+meth public static <%0 extends java.lang.Object> {%%0} clientProperty(javax.swing.JComponent,java.lang.String,{%%0},java.lang.Class<{%%0}>)
 meth public static boolean clientPropertyBoolean(javax.swing.JComponent,java.lang.String,boolean)
 meth public static boolean clientPropertyEquals(javax.swing.JComponent,java.lang.String,java.lang.Object)
 meth public static int clientPropertyInt(javax.swing.JComponent,java.lang.String,int)
@@ -165,8 +207,10 @@ meth public boolean isSupportedLookAndFeel()
 meth public final boolean equals(java.lang.Object)
 meth public final int hashCode()
 meth public java.lang.String getID()
+meth public java.util.Map<java.lang.String,java.lang.String> getExtraDefaults()
 meth public javax.swing.Icon getDisabledIcon(javax.swing.JComponent,javax.swing.Icon)
 meth public javax.swing.UIDefaults getDefaults()
+meth public static <%0 extends java.lang.Object> {%%0} getStyleableValue(javax.swing.JComponent,java.lang.String)
 meth public static boolean install(javax.swing.LookAndFeel)
  anno 0 java.lang.Deprecated()
 meth public static boolean isLafDark()
@@ -174,29 +218,50 @@ meth public static boolean isShowMnemonics()
 meth public static boolean isUseNativeWindowDecorations()
 meth public static boolean setup(javax.swing.LookAndFeel)
 meth public static boolean supportsNativeWindowDecorations()
+meth public static java.lang.Object parseDefaultsValue(java.lang.String,java.lang.String,java.lang.Class<?>)
+meth public static java.lang.String getPreferredFontFamily()
+meth public static java.lang.String getPreferredLightFontFamily()
+meth public static java.lang.String getPreferredMonospacedFontFamily()
+meth public static java.lang.String getPreferredSemiboldFontFamily()
+meth public static java.lang.String getUIKeyLightOrDarkPrefix(boolean)
+meth public static java.util.Map<java.lang.String,java.lang.Class<?>> getStyleableInfos(javax.swing.JComponent)
+meth public static java.util.Map<java.lang.String,java.lang.String> getGlobalExtraDefaults()
+meth public static java.util.Set<java.lang.String> getUIKeyPlatformPrefixes()
+meth public static java.util.Set<java.lang.String> getUIKeySpecialPrefixes()
+meth public static java.util.function.Function<java.lang.String,java.awt.Color> getSystemColorGetter()
 meth public static javax.swing.UIDefaults$ActiveValue createActiveFontValue(float)
+meth public static void disableWindowsD3Donscreen()
 meth public static void hideMnemonics()
 meth public static void initIconColors(javax.swing.UIDefaults,boolean)
 meth public static void installLafInfo(java.lang.String,java.lang.Class<? extends javax.swing.LookAndFeel>)
 meth public static void registerCustomDefaultsSource(java.io.File)
 meth public static void registerCustomDefaultsSource(java.lang.String)
 meth public static void registerCustomDefaultsSource(java.lang.String,java.lang.ClassLoader)
+meth public static void registerCustomDefaultsSource(java.net.URL)
 meth public static void repaintAllFramesAndDialogs()
 meth public static void revalidateAndRepaintAllFramesAndDialogs()
 meth public static void runWithUIDefaultsGetter(java.util.function.Function<java.lang.Object,java.lang.Object>,java.lang.Runnable)
+meth public static void setGlobalExtraDefaults(java.util.Map<java.lang.String,java.lang.String>)
+meth public static void setPreferredFontFamily(java.lang.String)
+meth public static void setPreferredLightFontFamily(java.lang.String)
+meth public static void setPreferredMonospacedFontFamily(java.lang.String)
+meth public static void setPreferredSemiboldFontFamily(java.lang.String)
+meth public static void setSystemColorGetter(java.util.function.Function<java.lang.String,java.awt.Color>)
 meth public static void setUseNativeWindowDecorations(boolean)
 meth public static void showMnemonics(java.awt.Component)
 meth public static void unregisterCustomDefaultsSource(java.io.File)
 meth public static void unregisterCustomDefaultsSource(java.lang.String)
 meth public static void unregisterCustomDefaultsSource(java.lang.String,java.lang.ClassLoader)
+meth public static void unregisterCustomDefaultsSource(java.net.URL)
 meth public static void updateUI()
 meth public static void updateUILater()
 meth public void initialize()
 meth public void registerUIDefaultsGetter(java.util.function.Function<java.lang.Object,java.lang.Object>)
+meth public void setExtraDefaults(java.util.Map<java.lang.String,java.lang.String>)
 meth public void uninitialize()
 meth public void unregisterUIDefaultsGetter(java.util.function.Function<java.lang.Object,java.lang.Object>)
 supr javax.swing.plaf.basic.BasicLookAndFeel
-hfds DESKTOPFONTHINTS,aquaLoaded,customDefaultsSources,desktopPropertyListener,desktopPropertyName,desktopPropertyName2,mnemonicHandler,oldPopupFactory,postInitialization,uiDefaultsGetters,updateUIPending
+hfds DESKTOPFONTHINTS,aquaLoaded,customDefaultsSources,desktopPropertyListener,desktopPropertyName,desktopPropertyName2,extraDefaults,globalExtraDefaults,linuxPopupMenuCanceler,mnemonicHandler,oldPopupFactory,postInitialization,preferredFontFamily,preferredLightFontFamily,preferredMonospacedFontFamily,preferredSemiboldFontFamily,subMenuUsabilityHelperInstalled,systemColorGetter,uiDefaultsGetters,uiKeyPlatformPrefixes,uiKeySpecialPrefixes,updateUIPending
 hcls ActiveFont,FlatUIDefaults,ImageIconUIResource
 
 CLSS public abstract interface static com.formdev.flatlaf.FlatLaf$DisabledIconProvider
@@ -231,10 +296,17 @@ hfds baseTheme,dark,name,properties
 CLSS public abstract interface com.formdev.flatlaf.FlatSystemProperties
 fld public final static java.lang.String ANIMATION = "flatlaf.animation"
 fld public final static java.lang.String MENUBAR_EMBEDDED = "flatlaf.menuBarEmbedded"
+fld public final static java.lang.String NATIVE_LIBRARY_PATH = "flatlaf.nativeLibraryPath"
+fld public final static java.lang.String REUSE_VISIBLE_POPUP_WINDOW = "flatlaf.reuseVisiblePopupWindow"
 fld public final static java.lang.String UI_SCALE = "flatlaf.uiScale"
 fld public final static java.lang.String UI_SCALE_ALLOW_SCALE_DOWN = "flatlaf.uiScale.allowScaleDown"
 fld public final static java.lang.String UI_SCALE_ENABLED = "flatlaf.uiScale.enabled"
+fld public final static java.lang.String UPDATE_UI_ON_SYSTEM_FONT_CHANGE = "flatlaf.updateUIOnSystemFontChange"
 fld public final static java.lang.String USE_JETBRAINS_CUSTOM_DECORATIONS = "flatlaf.useJetBrainsCustomDecorations"
+ anno 0 java.lang.Deprecated()
+fld public final static java.lang.String USE_NATIVE_LIBRARY = "flatlaf.useNativeLibrary"
+fld public final static java.lang.String USE_ROUNDED_POPUP_BORDER = "flatlaf.useRoundedPopupBorder"
+fld public final static java.lang.String USE_SUB_MENU_SAFE_TRIANGLE = "flatlaf.useSubMenuSafeTriangle"
 fld public final static java.lang.String USE_TEXT_Y_CORRECTION = "flatlaf.useTextYCorrection"
 fld public final static java.lang.String USE_UBUNTU_FONT = "flatlaf.useUbuntuFont"
 fld public final static java.lang.String USE_WINDOW_DECORATIONS = "flatlaf.useWindowDecorations"
@@ -253,7 +325,7 @@ meth public static boolean setup(java.io.InputStream)
 meth public static com.formdev.flatlaf.FlatLaf createLaf(com.formdev.flatlaf.IntelliJTheme)
 meth public static com.formdev.flatlaf.FlatLaf createLaf(java.io.InputStream) throws java.io.IOException
 supr java.lang.Object
-hfds checkboxDuplicateColors,checkboxKeyMapping,colors,icons,isMaterialUILite,namedColors,ui,uiKeyCopying,uiKeyInverseMapping,uiKeyMapping
+hfds checkboxDuplicateColors,checkboxKeyMapping,jsonColors,jsonIcons,jsonUI,namedColors,uiKeyCopying,uiKeyDoNotOverride,uiKeyExcludesContains,uiKeyExcludesStartsWith,uiKeyInverseMapping,uiKeyMapping
 
 CLSS public static com.formdev.flatlaf.IntelliJTheme$ThemeLaf
  outer com.formdev.flatlaf.IntelliJTheme
@@ -266,6 +338,26 @@ meth public java.lang.String getName()
 supr com.formdev.flatlaf.FlatLaf
 hfds theme
 
+CLSS public com.formdev.flatlaf.themes.FlatMacDarkLaf
+cons public init()
+fld public final static java.lang.String NAME = "FlatLaf macOS Dark"
+meth public boolean isDark()
+meth public java.lang.String getDescription()
+meth public java.lang.String getName()
+meth public static boolean setup()
+meth public static void installLafInfo()
+supr com.formdev.flatlaf.FlatDarkLaf
+
+CLSS public com.formdev.flatlaf.themes.FlatMacLightLaf
+cons public init()
+fld public final static java.lang.String NAME = "FlatLaf macOS Light"
+meth public boolean isDark()
+meth public java.lang.String getDescription()
+meth public java.lang.String getName()
+meth public static boolean setup()
+meth public static void installLafInfo()
+supr com.formdev.flatlaf.FlatLightLaf
+
 CLSS public abstract interface com.formdev.flatlaf.util.AnimatedIcon
 innr public static AnimationSupport
 intf javax.swing.Icon
@@ -328,9 +420,19 @@ innr public static Fade
 innr public static HSLChange
 innr public static HSLIncreaseDecrease
 innr public static Mix
+innr public static Mix2
 meth public !varargs static java.awt.Color applyFunctions(java.awt.Color,com.formdev.flatlaf.util.ColorFunctions$ColorFunction[])
 meth public static float clamp(float)
+meth public static float luma(java.awt.Color)
+meth public static java.awt.Color darken(java.awt.Color,float)
+meth public static java.awt.Color desaturate(java.awt.Color,float)
+meth public static java.awt.Color fade(java.awt.Color,float)
+meth public static java.awt.Color lighten(java.awt.Color,float)
 meth public static java.awt.Color mix(java.awt.Color,java.awt.Color,float)
+meth public static java.awt.Color saturate(java.awt.Color,float)
+meth public static java.awt.Color shade(java.awt.Color,float)
+meth public static java.awt.Color spin(java.awt.Color,float)
+meth public static java.awt.Color tint(java.awt.Color,float)
 supr java.lang.Object
 
 CLSS public abstract interface static com.formdev.flatlaf.util.ColorFunctions$ColorFunction
@@ -380,6 +482,16 @@ meth public java.lang.String toString()
 meth public void apply(float[])
 supr java.lang.Object
 
+CLSS public static com.formdev.flatlaf.util.ColorFunctions$Mix2
+ outer com.formdev.flatlaf.util.ColorFunctions
+cons public init(java.awt.Color,float)
+fld public final float weight
+fld public final java.awt.Color color1
+intf com.formdev.flatlaf.util.ColorFunctions$ColorFunction
+meth public java.lang.String toString()
+meth public void apply(float[])
+supr java.lang.Object
+
 CLSS public com.formdev.flatlaf.util.CubicBezierEasing
 cons public init(float,float,float,float)
 fld public final static com.formdev.flatlaf.util.CubicBezierEasing EASE
@@ -400,6 +512,17 @@ meth public java.lang.String toString()
 supr javax.swing.plaf.ColorUIResource
 hfds baseOfDefaultColorRGB,functions,hasBaseOfDefaultColor
 
+CLSS public com.formdev.flatlaf.util.FontUtils
+cons public init()
+meth public static boolean installFont(java.net.URL)
+meth public static java.awt.Font getCompositeFont(java.lang.String,int,int)
+meth public static java.awt.Font[] getAllFonts()
+meth public static java.lang.String[] getAvailableFontFamilyNames()
+meth public static void loadFontFamily(java.lang.String)
+meth public static void registerFontFamilyLoader(java.lang.String,java.lang.Runnable)
+supr java.lang.Object
+hfds loadersMap
+
 CLSS public com.formdev.flatlaf.util.Graphics2DProxy
 cons public init(java.awt.Graphics2D)
 meth public boolean drawImage(java.awt.Image,int,int,int,int,int,int,int,int,java.awt.Color,java.awt.image.ImageObserver)
@@ -528,15 +651,32 @@ hfds alpha,hsl,rgb
 
 CLSS public com.formdev.flatlaf.util.HiDPIUtils
 cons public init()
+innr public abstract interface static DirtyRegionCallback
 innr public abstract interface static Painter
+innr public static HiDPIRepaintManager
 meth public static float computeTextYCorrection(java.awt.Graphics2D)
 meth public static java.awt.Graphics2D createGraphicsTextYCorrection(java.awt.Graphics2D)
+meth public static void addDirtyRegion(javax.swing.JComponent,int,int,int,int,com.formdev.flatlaf.util.HiDPIUtils$DirtyRegionCallback)
 meth public static void drawStringUnderlineCharAtWithYCorrection(javax.swing.JComponent,java.awt.Graphics2D,java.lang.String,int,int,int)
 meth public static void drawStringWithYCorrection(javax.swing.JComponent,java.awt.Graphics2D,java.lang.String,int,int)
+meth public static void installHiDPIRepaintManager()
 meth public static void paintAtScale1x(java.awt.Graphics2D,int,int,int,int,com.formdev.flatlaf.util.HiDPIUtils$Painter)
 meth public static void paintAtScale1x(java.awt.Graphics2D,javax.swing.JComponent,com.formdev.flatlaf.util.HiDPIUtils$Painter)
+meth public static void repaint(java.awt.Component)
+meth public static void repaint(java.awt.Component,int,int,int,int)
+meth public static void repaint(java.awt.Component,java.awt.Rectangle)
 supr java.lang.Object
-hfds useTextYCorrection
+hfds CORRECTION_INTER,CORRECTION_OPEN_SANS,CORRECTION_SEGOE_UI,CORRECTION_TAHOMA,SCALE_FACTORS,useDebugScaleFactor,useTextYCorrection
+
+CLSS public abstract interface static com.formdev.flatlaf.util.HiDPIUtils$DirtyRegionCallback
+ outer com.formdev.flatlaf.util.HiDPIUtils
+meth public abstract void addDirtyRegion(javax.swing.JComponent,int,int,int,int)
+
+CLSS public static com.formdev.flatlaf.util.HiDPIUtils$HiDPIRepaintManager
+ outer com.formdev.flatlaf.util.HiDPIUtils
+cons public init()
+meth public void addDirtyRegion(javax.swing.JComponent,int,int,int,int)
+supr javax.swing.RepaintManager
 
 CLSS public abstract interface static com.formdev.flatlaf.util.HiDPIUtils$Painter
  outer com.formdev.flatlaf.util.HiDPIUtils
@@ -566,6 +706,8 @@ meth public static java.util.List<java.awt.Image> getResolutionVariants(java.awt
 supr java.lang.Object
 
 CLSS public com.formdev.flatlaf.util.NativeLibrary
+cons public init(java.io.File,boolean)
+cons public init(java.lang.String,boolean)
 cons public init(java.lang.String,java.lang.ClassLoader,boolean)
 meth public boolean isLoaded()
 supr java.lang.Object
@@ -589,32 +731,72 @@ meth public void paintIcon(java.awt.Component,java.awt.Graphics,int,int)
 supr java.lang.Object
 hfds iconHeight,iconWidth,imageIcon,lastImage,lastSystemScaleFactor,lastUserScaleFactor
 
+CLSS public com.formdev.flatlaf.util.SoftCache<%0 extends java.lang.Object, %1 extends java.lang.Object>
+cons public init()
+cons public init(int)
+intf java.util.Map<{com.formdev.flatlaf.util.SoftCache%0},{com.formdev.flatlaf.util.SoftCache%1}>
+meth public boolean containsKey(java.lang.Object)
+meth public boolean containsValue(java.lang.Object)
+meth public boolean isEmpty()
+meth public int size()
+meth public java.util.Collection<{com.formdev.flatlaf.util.SoftCache%1}> values()
+meth public java.util.Set<java.util.Map$Entry<{com.formdev.flatlaf.util.SoftCache%0},{com.formdev.flatlaf.util.SoftCache%1}>> entrySet()
+meth public java.util.Set<{com.formdev.flatlaf.util.SoftCache%0}> keySet()
+meth public void clear()
+meth public void forEach(java.util.function.BiConsumer<? super {com.formdev.flatlaf.util.SoftCache%0},? super {com.formdev.flatlaf.util.SoftCache%1}>)
+meth public void putAll(java.util.Map<? extends {com.formdev.flatlaf.util.SoftCache%0},? extends {com.formdev.flatlaf.util.SoftCache%1}>)
+meth public void replaceAll(java.util.function.BiFunction<? super {com.formdev.flatlaf.util.SoftCache%0},? super {com.formdev.flatlaf.util.SoftCache%1},? extends {com.formdev.flatlaf.util.SoftCache%1}>)
+meth public {com.formdev.flatlaf.util.SoftCache%1} get(java.lang.Object)
+meth public {com.formdev.flatlaf.util.SoftCache%1} put({com.formdev.flatlaf.util.SoftCache%0},{com.formdev.flatlaf.util.SoftCache%1})
+meth public {com.formdev.flatlaf.util.SoftCache%1} remove(java.lang.Object)
+supr java.lang.Object
+hfds map,queue
+hcls CacheReference
+
 CLSS public com.formdev.flatlaf.util.StringUtils
 cons public init()
 meth public static boolean isEmpty(java.lang.String)
+meth public static boolean isTrimmedEmpty(java.lang.String)
 meth public static java.lang.String removeLeading(java.lang.String,java.lang.String)
 meth public static java.lang.String removeTrailing(java.lang.String,java.lang.String)
+meth public static java.lang.String substringTrimmed(java.lang.String,int)
+meth public static java.lang.String substringTrimmed(java.lang.String,int,int)
 meth public static java.util.List<java.lang.String> split(java.lang.String,char)
+meth public static java.util.List<java.lang.String> split(java.lang.String,char,boolean,boolean)
+supr java.lang.Object
+
+CLSS public com.formdev.flatlaf.util.SwingUtils
+cons public init()
+meth public static <%0 extends java.awt.Component> {%%0} getComponentByName(java.awt.Container,java.lang.String)
 supr java.lang.Object
 
 CLSS public com.formdev.flatlaf.util.SystemInfo
 cons public init()
+fld public final static boolean isAARCH64
+fld public final static boolean isGNOME
 fld public final static boolean isJava_11_orLater
+fld public final static boolean isJava_12_orLater
 fld public final static boolean isJava_15_orLater
+fld public final static boolean isJava_17_orLater
+fld public final static boolean isJava_18_orLater
 fld public final static boolean isJava_9_orLater
 fld public final static boolean isJetBrainsJVM
 fld public final static boolean isJetBrainsJVM_11_orLater
 fld public final static boolean isKDE
 fld public final static boolean isLinux
+fld public final static boolean isMacFullWindowContentSupported
 fld public final static boolean isMacOS
 fld public final static boolean isMacOS_10_11_ElCapitan_orLater
 fld public final static boolean isMacOS_10_14_Mojave_orLater
 fld public final static boolean isMacOS_10_15_Catalina_orLater
 fld public final static boolean isProjector
+fld public final static boolean isUnknownOS
 fld public final static boolean isWebswing
 fld public final static boolean isWinPE
 fld public final static boolean isWindows
 fld public final static boolean isWindows_10_orLater
+fld public final static boolean isWindows_11_orLater
+fld public final static boolean isX86
 fld public final static boolean isX86_64
 fld public final static long javaVersion
 fld public final static long osVersion
@@ -627,6 +809,7 @@ cons public init()
 meth public static boolean isSystemScalingEnabled()
 meth public static double getSystemScaleFactor(java.awt.Graphics2D)
 meth public static double getSystemScaleFactor(java.awt.GraphicsConfiguration)
+meth public static float computeFontScaleFactor(java.awt.Font)
 meth public static float getUserScaleFactor()
 meth public static float scale(float)
 meth public static float unscale(float)
@@ -933,6 +1116,34 @@ CLSS public abstract interface !annotation java.lang.annotation.Target
 intf java.lang.annotation.Annotation
 meth public abstract java.lang.annotation.ElementType[] value()
 
+CLSS public abstract interface java.util.Map<%0 extends java.lang.Object, %1 extends java.lang.Object>
+innr public abstract interface static Entry
+meth public abstract boolean containsKey(java.lang.Object)
+meth public abstract boolean containsValue(java.lang.Object)
+meth public abstract boolean equals(java.lang.Object)
+meth public abstract boolean isEmpty()
+meth public abstract int hashCode()
+meth public abstract int size()
+meth public abstract java.util.Collection<{java.util.Map%1}> values()
+meth public abstract java.util.Set<java.util.Map$Entry<{java.util.Map%0},{java.util.Map%1}>> entrySet()
+meth public abstract java.util.Set<{java.util.Map%0}> keySet()
+meth public abstract void clear()
+meth public abstract void putAll(java.util.Map<? extends {java.util.Map%0},? extends {java.util.Map%1}>)
+meth public abstract {java.util.Map%1} get(java.lang.Object)
+meth public abstract {java.util.Map%1} put({java.util.Map%0},{java.util.Map%1})
+meth public abstract {java.util.Map%1} remove(java.lang.Object)
+meth public boolean remove(java.lang.Object,java.lang.Object)
+meth public boolean replace({java.util.Map%0},{java.util.Map%1},{java.util.Map%1})
+meth public void forEach(java.util.function.BiConsumer<? super {java.util.Map%0},? super {java.util.Map%1}>)
+meth public void replaceAll(java.util.function.BiFunction<? super {java.util.Map%0},? super {java.util.Map%1},? extends {java.util.Map%1}>)
+meth public {java.util.Map%1} compute({java.util.Map%0},java.util.function.BiFunction<? super {java.util.Map%0},? super {java.util.Map%1},? extends {java.util.Map%1}>)
+meth public {java.util.Map%1} computeIfAbsent({java.util.Map%0},java.util.function.Function<? super {java.util.Map%0},? extends {java.util.Map%1}>)
+meth public {java.util.Map%1} computeIfPresent({java.util.Map%0},java.util.function.BiFunction<? super {java.util.Map%0},? super {java.util.Map%1},? extends {java.util.Map%1}>)
+meth public {java.util.Map%1} getOrDefault(java.lang.Object,{java.util.Map%1})
+meth public {java.util.Map%1} merge({java.util.Map%0},{java.util.Map%1},java.util.function.BiFunction<? super {java.util.Map%1},? super {java.util.Map%1},? extends {java.util.Map%1}>)
+meth public {java.util.Map%1} putIfAbsent({java.util.Map%0},{java.util.Map%1})
+meth public {java.util.Map%1} replace({java.util.Map%0},{java.util.Map%1})
+
 CLSS public abstract interface javax.swing.Icon
 meth public abstract int getIconHeight()
 meth public abstract int getIconWidth()
@@ -967,6 +1178,31 @@ meth public void provideErrorFeedback(java.awt.Component)
 meth public void uninitialize()
 supr java.lang.Object
 
+CLSS public javax.swing.RepaintManager
+cons public init()
+meth public boolean isCompletelyDirty(javax.swing.JComponent)
+meth public boolean isDoubleBufferingEnabled()
+meth public java.awt.Dimension getDoubleBufferMaximumSize()
+meth public java.awt.Image getOffscreenBuffer(java.awt.Component,int,int)
+meth public java.awt.Image getVolatileOffscreenBuffer(java.awt.Component,int,int)
+meth public java.awt.Rectangle getDirtyRegion(javax.swing.JComponent)
+meth public java.lang.String toString()
+meth public static javax.swing.RepaintManager currentManager(java.awt.Component)
+meth public static javax.swing.RepaintManager currentManager(javax.swing.JComponent)
+meth public static void setCurrentManager(javax.swing.RepaintManager)
+meth public void addDirtyRegion(java.applet.Applet,int,int,int,int)
+meth public void addDirtyRegion(java.awt.Window,int,int,int,int)
+meth public void addDirtyRegion(javax.swing.JComponent,int,int,int,int)
+meth public void addInvalidComponent(javax.swing.JComponent)
+meth public void markCompletelyClean(javax.swing.JComponent)
+meth public void markCompletelyDirty(javax.swing.JComponent)
+meth public void paintDirtyRegions()
+meth public void removeInvalidComponent(javax.swing.JComponent)
+meth public void setDoubleBufferMaximumSize(java.awt.Dimension)
+meth public void setDoubleBufferingEnabled(boolean)
+meth public void validateInvalidComponents()
+supr java.lang.Object
+
 CLSS public abstract javax.swing.border.AbstractBorder
 cons public init()
 intf java.io.Serializable

flatlaf-core/src/main/java/com/formdev/flatlaf/FlatClientProperties.java

@@ -17,8 +17,12 @@
 package com.formdev.flatlaf;
 
 import java.awt.Color;
+import java.awt.IllegalComponentStateException;
+import java.awt.Window;
 import java.util.Objects;
 import javax.swing.JComponent;
+import javax.swing.JFormattedTextField;
+import javax.swing.JSpinner;
 import javax.swing.SwingConstants;
 
 /**
@@ -31,7 +35,7 @@ public interface FlatClientProperties
 	//---- JButton ------------------------------------------------------------
 
 	/**
-	 * Specifies type of a button.
+	 * Specifies type of button.
 	 * <p>
 	 * <strong>Components</strong> {@link javax.swing.JButton} and {@link javax.swing.JToggleButton}<br>
 	 * <strong>Value type</strong> {@link java.lang.String}<br>
@@ -100,6 +104,17 @@ public interface FlatClientProperties
 	 */
 	String BUTTON_TYPE_BORDERLESS = "borderless";
 
+	/**
+	 * Specifies whether the button preferred size will be made square (quadratically).
+	 * <p>
+	 * <strong>Components</strong> {@link javax.swing.JButton} and {@link javax.swing.JToggleButton}<br>
+	 * <strong>Value type</strong> {@link java.lang.Boolean}
+	 */
+	String SQUARE_SIZE = "JButton.squareSize";
+
+
+	//---- JCheckBox ----------------------------------------------------------
+
 	/**
 	 * Specifies selected state of a checkbox.
 	 * <p>
@@ -116,13 +131,6 @@ public interface FlatClientProperties
 	 */
 	String SELECTED_STATE_INDETERMINATE = "indeterminate";
 
-	/**
-	 * Specifies whether the button preferred size will be made square (quadratically).
-	 * <p>
-	 * <strong>Components</strong> {@link javax.swing.JButton} and {@link javax.swing.JToggleButton}<br>
-	 * <strong>Value type</strong> {@link java.lang.Boolean}
-	 */
-	String SQUARE_SIZE = "JButton.squareSize";
 
 	//---- JComponent ---------------------------------------------------------
 
@@ -214,6 +222,7 @@ public interface FlatClientProperties
 	 * <strong>Allowed Values</strong>
 	 *     {@link #OUTLINE_ERROR},
 	 *     {@link #OUTLINE_WARNING},
+	 *     {@link #OUTLINE_SUCCESS},
 	 *     any color (type {@link java.awt.Color}) or
 	 *     an array of two colors (type {@link java.awt.Color}[2]) where the first color
 	 *     is for focused state and the second for unfocused state
@@ -234,6 +243,14 @@ public interface FlatClientProperties
 	 */
 	String OUTLINE_WARNING = "warning";
 
+	/**
+	 * Paint the component border in another color (usually greenish) to indicate a success.
+	 *
+	 * @see #OUTLINE
+	 * @since 3.6
+	 */
+	String OUTLINE_SUCCESS = "success";
+
 	/**
 	 * Specifies a callback that is invoked to check whether a component is permanent focus owner.
 	 * Used to paint focus indicators.
@@ -253,8 +270,157 @@ public interface FlatClientProperties
 	 */
 	String COMPONENT_FOCUS_OWNER = "JComponent.focusOwner";
 
+	/**
+	 * Specifies whether a component shown in a window title bar area should behave as caption
+	 * (left-click allows moving window, right-click shows window system menu).
+	 * The caption component does not receive mouse pressed/released/clicked/dragged events,
+	 * but it gets mouse entered/exited/moved events.
+	 * <p>
+	 * Since 3.4, this client property also supports using a function that can check
+	 * whether a given location in the component should behave as caption.
+	 * Useful for components that do not use mouse input on whole component bounds.
+	 *
+	 * <pre>{@code
+	 * myComponent.putClientProperty( "JComponent.titleBarCaption",
+	 *     (Function<Point, Boolean>) pt -> {
+	 *         // parameter pt contains mouse location (in myComponent coordinates)
+	 *         // return true if the component is not interested in mouse input at the given location
+	 *         // return false if the component wants process mouse input at the given location
+	 *         // return null if the component children should be checked
+	 *         return ...; // check here
+	 *     } );
+	 * }</pre>
+	 * <b>Warning</b>:
+	 * <ul>
+	 *   <li>This function is invoked often when mouse is moved over window title bar area
+	 *       and should therefore return quickly.
+	 *   <li>This function is invoked on 'AWT-Windows' thread (not 'AWT-EventQueue' thread)
+	 *       while processing Windows messages.
+	 *       It <b>must not</b> change any component property or layout because this could cause a dead lock.
+	 * </ul>
+	 * <p>
+	 * <strong>Component</strong> {@link javax.swing.JComponent}<br>
+	 * <strong>Value type</strong> {@link java.lang.Boolean} or {@link java.util.function.Function}&lt;Point, Boolean&gt;
+	 *
+	 * @since 2.5
+	 */
+	String COMPONENT_TITLE_BAR_CAPTION = "JComponent.titleBarCaption";
+
+
+	//---- Panel --------------------------------------------------------------
+
+	/**
+	 * Marks the panel as placeholder for the iconfify/maximize/close buttons
+	 * in fullWindowContent mode. See {@link #FULL_WINDOW_CONTENT}.
+	 * <p>
+	 * If fullWindowContent mode is enabled, the preferred size of the panel is equal
+	 * to the size of the iconfify/maximize/close buttons. Otherwise is is {@code 0,0}.
+	 * <p>
+	 * You're responsible to layout that panel at the top-left or top-right corner,
+	 * depending on platform, where the iconfify/maximize/close buttons are located.
+	 * <p>
+	 * Syntax of the value string is: {@code "win|mac [horizontal|vertical] [zeroInFullScreen] [leftToRight|rightToLeft]"}.
+	 * <p>
+	 * The string must start with {@code "win"} (for Windows or Linux) or
+	 * with {@code "mac"} (for macOS) and specifies the platform where the placeholder
+	 * should be used. On macOS, you need the placeholder in the top-left corner,
+	 * but on Windows/Linux you need it in the top-right corner. So if your application supports
+	 * fullWindowContent mode on both platforms, you can add two placeholders to your layout
+	 * and FlatLaf automatically uses only one of them. The other gets size {@code 0,0}.
+	 * <p>
+	 * Optionally, you can append following options to the value string (separated by space characters):
+	 * <ul>
+	 *   <li>{@code "horizontal"} - preferred height is zero
+	 *   <li>{@code "vertical"} - preferred width is zero
+	 *   <li>{@code "zeroInFullScreen"} - in full-screen mode on macOS, preferred size is {@code 0,0}
+	 *   <li>{@code "leftToRight"} - in right-to-left component orientation, preferred size is {@code 0,0}
+	 *   <li>{@code "rightToLeft"} - in left-to-right component orientation, preferred size is {@code 0,0}
+	 * </ul>
+	 *
+	 * Example for adding placeholder to top-left corner on macOS:
+	 * <pre>{@code
+	 * JPanel placeholder = new JPanel();
+	 * placeholder.putClientProperty( FlatClientProperties.FULL_WINDOW_CONTENT_BUTTONS_PLACEHOLDER, "mac" );
+     *
+     * JToolBar toolBar = new JToolBar();
+     * // add tool bar items
+     *
+	 * JPanel toolBarPanel = new JPanel( new BorderLayout() );
+	 * toolBarPanel.add( placeholder, BorderLayout.WEST );
+	 * toolBarPanel.add( toolBar, BorderLayout.CENTER );
+	 *
+	 * frame.getContentPane().add( toolBarPanel, BorderLayout.NORTH );
+	 * }</pre>
+	 *
+	 * Or add placeholder as first item to the tool bar:
+	 * <pre>{@code
+	 * JPanel placeholder = new JPanel();
+	 * placeholder.putClientProperty( FlatClientProperties.FULL_WINDOW_CONTENT_BUTTONS_PLACEHOLDER, "mac" );
+	 *
+	 * JToolBar toolBar = new JToolBar();
+	 * toolBar.add( placeholder );
+	 * // add tool bar items
+	 *
+	 * frame.getContentPane().add( toolBar, BorderLayout.NORTH );
+	 * }</pre>
+	 *
+	 * If a tabbed pane is located at the top, you can add the placeholder
+	 * as leading component to that tabbed pane:
+	 * <pre>{@code
+	 * JPanel placeholder = new JPanel();
+	 * placeholder.putClientProperty( FlatClientProperties.FULL_WINDOW_CONTENT_BUTTONS_PLACEHOLDER, "mac" );
+	 *
+	 * tabbedPane.putClientProperty( FlatClientProperties.TABBED_PANE_LEADING_COMPONENT, placeholder );
+	 * }</pre>
+	 * <p>
+	 * <strong>Component</strong> {@link javax.swing.JPanel}<br>
+	 * <strong>Value type</strong> {@link java.lang.String}
+	 *
+	 * @since 3.4
+	 */
+	String FULL_WINDOW_CONTENT_BUTTONS_PLACEHOLDER = "FlatLaf.fullWindowContent.buttonsPlaceholder";
+
+
 	//---- Popup --------------------------------------------------------------
 
+	/**
+	 * Specifies the popup border corner radius if the component is shown in a popup
+	 * or if the component is the owner of another component that is shown in a popup.
+	 * <p>
+	 * Note that this is not available on all platforms since it requires special support.
+	 * Supported platforms:
+	 * <ul>
+	 * <li><strong>Windows 11</strong>: Only two corner radiuses are supported
+	 *     by the OS: {@code DWMWCP_ROUND} is 8px and {@code DWMWCP_ROUNDSMALL} is 4px.
+	 *     If this value is {@code 1 - 4}, then {@code DWMWCP_ROUNDSMALL} is used.
+	 *     If it is {@code >= 5}, then {@code DWMWCP_ROUND} is used.
+	 * <li><strong>macOS</strong> (10.14 and later): Any corner radius is supported.
+	 * </ul>
+	 * <strong>Component</strong> {@link javax.swing.JComponent}<br>
+	 * <strong>Value type</strong> {@link java.lang.Integer}<br>
+	 *
+	 * @since 3.1
+	 */
+	String POPUP_BORDER_CORNER_RADIUS = "Popup.borderCornerRadius";
+
+	/**
+	 * Specifies the popup rounded border width if the component is shown in a popup
+	 * or if the component is the owner of another component that is shown in a popup.
+	 * <p>
+	 * Only used if popup uses rounded border.
+	 * <p>
+	 * Note that this is not available on all platforms since it requires special support.
+	 * Supported platforms:
+	 * <ul>
+	 * <li><strong>macOS</strong> (10.14 and later)
+	 * </ul>
+	 * <strong>Component</strong> {@link javax.swing.JComponent}<br>
+	 * <strong>Value type</strong> {@link java.lang.Integer} or {@link java.lang.Float}<br>
+	 *
+	 * @since 3.3
+	 */
+	String POPUP_ROUNDED_BORDER_WIDTH = "Popup.roundedBorderWidth";
+
 	/**
 	 * Specifies whether a drop shadow is painted if the component is shown in a popup
 	 * or if the component is the owner of another component that is shown in a popup.
@@ -273,6 +439,7 @@ public interface FlatClientProperties
 	 */
 	String POPUP_FORCE_HEAVY_WEIGHT = "Popup.forceHeavyWeight";
 
+
 	//---- JProgressBar -------------------------------------------------------
 
 	/**
@@ -291,6 +458,7 @@ public interface FlatClientProperties
 	 */
 	String PROGRESS_BAR_SQUARE = "JProgressBar.square";
 
+
 	//---- JRootPane ----------------------------------------------------------
 
 	/**
@@ -304,7 +472,7 @@ public interface FlatClientProperties
 	 * {@link FlatSystemProperties#USE_WINDOW_DECORATIONS}, but higher priority
 	 * than UI default {@code TitlePane.useWindowDecorations}.
 	 * <p>
-	 * (requires Window 10)
+	 * (requires Windows 10/11)
 	 * <p>
 	 * <strong>Component</strong> {@link javax.swing.JRootPane}<br>
 	 * <strong>Value type</strong> {@link java.lang.Boolean}
@@ -324,23 +492,65 @@ public interface FlatClientProperties
 	 * {@link FlatSystemProperties#MENUBAR_EMBEDDED}, but higher priority
 	 * than UI default {@code TitlePane.menuBarEmbedded}.
 	 * <p>
-	 * (requires Window 10)
+	 * (requires Windows 10/11)
 	 * <p>
 	 * <strong>Component</strong> {@link javax.swing.JRootPane}<br>
 	 * <strong>Value type</strong> {@link java.lang.Boolean}
 	 */
 	String MENU_BAR_EMBEDDED = "JRootPane.menuBarEmbedded";
 
+	/**
+	 * Specifies whether the content pane (and the glass pane) should be extended
+	 * into the window title bar area
+	 * (requires enabled window decorations). Default is {@code false}.
+	 * <p>
+	 * On macOS, use client property {@code apple.awt.fullWindowContent}
+	 * (see <a href="https://www.formdev.com/flatlaf/macos/#full_window_content">macOS Full window content</a>).
+	 * <p>
+	 * Setting this enables/disables full window content
+	 * for the {@code JFrame} or {@code JDialog} that contains the root pane.
+	 * <p>
+	 * If {@code true}, the content pane (and the glass pane) is extended into
+	 * the title bar area. The window icon and title are hidden.
+	 * Only the iconfify/maximize/close buttons stay visible in the upper right corner
+	 * (and overlap the content pane).
+	 * <p>
+	 * The user can left-click-and-drag on the title bar area to move the window,
+	 * except when clicking on a component that processes mouse events (e.g. buttons or menus).
+	 * <p>
+	 * (requires Windows 10/11)
+	 * <p>
+	 * <strong>Component</strong> {@link javax.swing.JRootPane}<br>
+	 * <strong>Value type</strong> {@link java.lang.Boolean}
+	 *
+	 * @since 3.4
+	 */
+	String FULL_WINDOW_CONTENT = "FlatLaf.fullWindowContent";
+
+	/**
+	 * Contains the current bounds of the iconfify/maximize/close buttons
+	 * (in root pane coordinates) if fullWindowContent mode is enabled.
+	 * Otherwise its value is {@code null}.
+	 * <p>
+	 * <b>Note</b>: Do not set this client property. It is set by FlatLaf.
+	 * <p>
+	 * <strong>Component</strong> {@link javax.swing.JRootPane}<br>
+	 * <strong>Value type</strong> {@link java.awt.Rectangle}
+	 *
+	 * @since 3.4
+	 */
+	String FULL_WINDOW_CONTENT_BUTTONS_BOUNDS = "FlatLaf.fullWindowContent.buttonsBounds";
+
 	/**
 	 * Specifies whether the window icon should be shown in the window title bar
-	 * (requires enabled window decorations).
+	 * (requires enabled window decorations). Default is UI property {@code TitlePane.showIcon}.
 	 * <p>
 	 * Setting this shows/hides the windows icon
 	 * for the {@code JFrame} or {@code JDialog} that contains the root pane.
 	 * <p>
 	 * This client property has higher priority than UI default {@code TitlePane.showIcon}.
 	 * <p>
-	 * (requires Window 10)
+	 * (requires Windows 10/11)
 	 * <p>
 	 * <strong>Component</strong> {@link javax.swing.JRootPane}<br>
 	 * <strong>Value type</strong> {@link java.lang.Boolean}
@@ -349,10 +559,74 @@ public interface FlatClientProperties
 	 */
 	String TITLE_BAR_SHOW_ICON = "JRootPane.titleBarShowIcon";
 
+	/**
+	 * Specifies whether the window title should be shown in the window title bar
+	 * (requires enabled window decorations). Default is {@code true}.
+	 * <p>
+	 * Setting this shows/hides the windows title
+	 * for the {@code JFrame} or {@code JDialog} that contains the root pane.
+	 * <p>
+	 * (requires Windows 10/11)
+	 * <p>
+	 * <strong>Component</strong> {@link javax.swing.JRootPane}<br>
+	 * <strong>Value type</strong> {@link java.lang.Boolean}
+	 *
+	 * @since 3
+	 */
+	String TITLE_BAR_SHOW_TITLE = "JRootPane.titleBarShowTitle";
+
+	/**
+	 * Specifies whether the "iconify" button should be shown in the window title bar
+	 * (requires enabled window decorations). Default is {@code true}.
+	 * <p>
+	 * Setting this shows/hides the "iconify" button
+	 * for the {@code JFrame} that contains the root pane.
+	 * <p>
+	 * (requires Windows 10/11)
+	 * <p>
+	 * <strong>Component</strong> {@link javax.swing.JRootPane}<br>
+	 * <strong>Value type</strong> {@link java.lang.Boolean}
+	 *
+	 * @since 3
+	 */
+	String TITLE_BAR_SHOW_ICONIFFY = "JRootPane.titleBarShowIconify";
+
+	/**
+	 * Specifies whether the "maximize/restore" button should be shown in the window title bar
+	 * (requires enabled window decorations). Default is {@code true}.
+	 * <p>
+	 * Setting this shows/hides the "maximize/restore" button
+	 * for the {@code JFrame} that contains the root pane.
+	 * <p>
+	 * (requires Windows 10/11)
+	 * <p>
+	 * <strong>Component</strong> {@link javax.swing.JRootPane}<br>
+	 * <strong>Value type</strong> {@link java.lang.Boolean}
+	 *
+	 * @since 3
+	 */
+	String TITLE_BAR_SHOW_MAXIMIZE = "JRootPane.titleBarShowMaximize";
+
+	/**
+	 * Specifies whether the "close" button should be shown in the window title bar
+	 * (requires enabled window decorations). Default is {@code true}.
+	 * <p>
+	 * Setting this shows/hides the "close" button
+	 * for the {@code JFrame} or {@code JDialog} that contains the root pane.
+	 * <p>
+	 * (requires Windows 10/11)
+	 * <p>
+	 * <strong>Component</strong> {@link javax.swing.JRootPane}<br>
+	 * <strong>Value type</strong> {@link java.lang.Boolean}
+	 *
+	 * @since 3
+	 */
+	String TITLE_BAR_SHOW_CLOSE = "JRootPane.titleBarShowClose";
+
 	/**
 	 * Background color of window title bar (requires enabled window decorations).
 	 * <p>
-	 * (requires Window 10)
+	 * (requires Windows 10/11)
 	 * <p>
 	 * <strong>Component</strong> {@link javax.swing.JRootPane}<br>
 	 * <strong>Value type</strong> {@link java.awt.Color}
@@ -364,7 +638,7 @@ public interface FlatClientProperties
 	/**
 	 * Foreground color of window title bar (requires enabled window decorations).
 	 * <p>
-	 * (requires Window 10)
+	 * (requires Windows 10/11)
 	 * <p>
 	 * <strong>Component</strong> {@link javax.swing.JRootPane}<br>
 	 * <strong>Value type</strong> {@link java.awt.Color}
@@ -373,6 +647,62 @@ public interface FlatClientProperties
 	 */
 	String TITLE_BAR_FOREGROUND = "JRootPane.titleBarForeground";
 
+	/**
+	 * Specifies the preferred height of title bar (requires enabled window decorations).
+	 * <p>
+	 * (requires Windows 10/11)
+	 * <p>
+	 * <strong>Component</strong> {@link javax.swing.JRootPane}<br>
+	 * <strong>Value type</strong> {@link java.lang.Integer}
+	 *
+	 * @since 3.5.2
+	 */
+	String TITLE_BAR_HEIGHT = "JRootPane.titleBarHeight";
+
+	/**
+	 * Specifies whether the glass pane should have full height and overlap the title bar,
+	 * if FlatLaf window decorations are enabled. Default is {@code false}.
+	 * <p>
+	 * (requires Windows 10/11)
+	 * <p>
+	 * <strong>Component</strong> {@link javax.swing.JRootPane}<br>
+	 * <strong>Value type</strong> {@link java.lang.Boolean}
+	 *
+	 * @since 3.1
+	 */
+	String GLASS_PANE_FULL_HEIGHT = "JRootPane.glassPaneFullHeight";
+
+	/**
+	 * Specifies the style of the window title bar.
+	 * Besides the default title bar style, you can use a Utility-style title bar,
+	 * which is smaller than the default title bar.
+	 * <p>
+	 * On Windows 10/11, this requires FlatLaf window decorations.
+	 * On macOS, Java supports this out of the box.
+	 * <p>
+	 * Note that this client property must be set before the window becomes displayable.
+	 * Otherwise, an {@link IllegalComponentStateException} is thrown.
+	 * <p>
+	 * <strong>Component</strong> {@link javax.swing.JRootPane}<br>
+	 * <strong>Value type</strong> {@link java.lang.String}<br>
+	 * <strong>Allowed Values</strong>
+	 *     {@link #WINDOW_STYLE_SMALL}
+	 *
+	 * @since 3.2
+	 */
+	String WINDOW_STYLE = "Window.style";
+
+	/**
+	 * The window has Utility-style title bar, which is smaller than default title bar.
+	 * <p>
+	 * This is the same as using {@link Window#setType}( {@link Window.Type#UTILITY} ).
+	 *
+	 * @see #WINDOW_STYLE
+	 * @since 3.2
+	 */
+	String WINDOW_STYLE_SMALL = "small";
+
+
 	//---- JScrollBar / JScrollPane -------------------------------------------
 
 	/**
@@ -391,6 +721,42 @@ public interface FlatClientProperties
 	 */
 	String SCROLL_PANE_SMOOTH_SCROLLING = "JScrollPane.smoothScrolling";
 
+
+	//---- JSplitPane ---------------------------------------------------------
+
+	/**
+	 * Specifies what side of the spilt pane is allowed to expand
+	 * via one-touch expanding arrow buttons.
+	 * Requires that one-touch expanding is enabled with
+	 * {@link javax.swing.JSplitPane#setOneTouchExpandable(boolean)}.
+	 * <p>
+	 * <strong>Component</strong> {@link javax.swing.JSplitPane}<br>
+	 * <strong>Value type</strong> {@link java.lang.String}<br>
+	 * <strong>Allowed Values</strong>
+	 *     {@link #SPLIT_PANE_EXPANDABLE_SIDE_LEFT} or
+	 *     {@link #SPLIT_PANE_EXPANDABLE_SIDE_RIGHT}
+	 *
+	 * @since 2.2
+	 */
+	String SPLIT_PANE_EXPANDABLE_SIDE = "JSplitPane.expandableSide";
+
+	/**
+	 * Allow expanding only left/top side of the split pane.
+	 *
+	 * @see #SPLIT_PANE_EXPANDABLE_SIDE
+	 * @since 2.2
+	 */
+	String SPLIT_PANE_EXPANDABLE_SIDE_LEFT = "left";
+
+	/**
+	 * Allow expanding only right/bottom side of the split pane.
+	 *
+	 * @see #SPLIT_PANE_EXPANDABLE_SIDE
+	 * @since 2.2
+	 */
+	String SPLIT_PANE_EXPANDABLE_SIDE_RIGHT = "right";
+
+
 	//---- JTabbedPane --------------------------------------------------------
 
 	/**
@@ -656,7 +1022,7 @@ public interface FlatClientProperties
 	 * <strong>Component</strong> {@link javax.swing.JTabbedPane}<br>
 	 * <strong>Value type</strong> {@link java.lang.Integer} or {@link java.lang.String}<br>
 	 * <strong>Allowed Values</strong>
-	 *     {@link SwingConstants#LEADING} (default)
+	 *     {@link SwingConstants#LEADING} (default),
 	 *     {@link SwingConstants#TRAILING},
 	 *     {@link SwingConstants#CENTER},
 	 *     {@link #TABBED_PANE_ALIGN_LEADING} (default),
@@ -760,12 +1126,65 @@ public interface FlatClientProperties
 	 */
 	String TABBED_PANE_TAB_ICON_PLACEMENT = "JTabbedPane.tabIconPlacement";
 
+	/**
+	 * Specifies the rotation of the tabs (title, icon, etc.).
+	 * <p>
+	 * <strong>Component</strong> {@link javax.swing.JTabbedPane}<br>
+	 * <strong>Value type</strong> {@link java.lang.Integer} or {@link java.lang.String}<br>
+	 * <strong>Allowed Values</strong>
+	 *     {@link SwingConstants#LEFT},
+	 *     {@link SwingConstants#RIGHT},
+	 *     {@link #TABBED_PANE_TAB_ROTATION_NONE} (default),
+	 *     {@link #TABBED_PANE_TAB_ROTATION_AUTO},
+	 *     {@link #TABBED_PANE_TAB_ROTATION_LEFT} or
+	 *     {@link #TABBED_PANE_TAB_ROTATION_RIGHT}
+	 *
+	 * @since 3.3
+	 */
+	String TABBED_PANE_TAB_ROTATION = "JTabbedPane.tabRotation";
+
+	/**
+	 * Tabs are not rotated.
+	 *
+	 * @see #TABBED_PANE_TAB_ROTATION
+	 * @since 3.3
+	 */
+	String TABBED_PANE_TAB_ROTATION_NONE = "none";
+
+	/**
+	 * Tabs are rotated depending on tab placement.
+	 * <p>
+	 * For top and bottom tab placement, the tabs are not rotated.<br>
+	 * For left tab placement, the tabs are rotated counter-clockwise.<br>
+	 * For right tab placement, the tabs are rotated clockwise.
+	 *
+	 * @see #TABBED_PANE_TAB_ROTATION
+	 * @since 3.3
+	 */
+	String TABBED_PANE_TAB_ROTATION_AUTO = "auto";
+
+	/**
+	 * Tabs are rotated counter-clockwise.
+	 *
+	 * @see #TABBED_PANE_TAB_ROTATION
+	 * @since 3.3
+	 */
+	String TABBED_PANE_TAB_ROTATION_LEFT = "left";
+
+	/**
+	 * Tabs are rotated clockwise.
+	 *
+	 * @see #TABBED_PANE_TAB_ROTATION
+	 * @since 3.3
+	 */
+	String TABBED_PANE_TAB_ROTATION_RIGHT = "right";
+
 	/**
 	 * Specifies a component that will be placed at the leading edge of the tabs area.
 	 * <p>
-	 * For top and bottom tab placement, the layed out component size will be
+	 * For top and bottom tab placement, the laid out component size will be
 	 * the preferred component width and the tab area height.<br>
-	 * For left and right tab placement, the layed out component size will be
+	 * For left and right tab placement, the laid out component size will be
 	 * the tab area width and the preferred component height.
 	 * <p>
 	 * <strong>Component</strong> {@link javax.swing.JTabbedPane}<br>
@@ -776,9 +1195,9 @@ public interface FlatClientProperties
 	/**
 	 * Specifies a component that will be placed at the trailing edge of the tabs area.
 	 * <p>
-	 * For top and bottom tab placement, the layed out component size will be
+	 * For top and bottom tab placement, the laid out component size will be
 	 * the available horizontal space (minimum is preferred component width) and the tab area height.<br>
-	 * For left and right tab placement, the layed out component size will be
+	 * For left and right tab placement, the laid out component size will be
 	 * the tab area width and the available vertical space (minimum is preferred component height).
 	 * <p>
 	 * <strong>Component</strong> {@link javax.swing.JTabbedPane}<br>
@@ -786,17 +1205,21 @@ public interface FlatClientProperties
 	 */
 	String TABBED_PANE_TRAILING_COMPONENT = "JTabbedPane.trailingComponent";
 
+
 	//---- JTextField ---------------------------------------------------------
 
 	/**
 	 * Specifies whether all text is selected when the text component gains focus.
 	 * <p>
-	 * <strong>Component</strong> {@link javax.swing.JTextField} (and subclasses)<br>
+	 * <strong>Components</strong> {@link javax.swing.text.JTextComponent} (and subclasses),
+	 * {@link javax.swing.JComboBox} (since 3.6) and {@link javax.swing.JSpinner} (since 3.6)<br>
 	 * <strong>Value type</strong> {@link java.lang.String}<br>
 	 * <strong>Allowed Values</strong>
 	 *     {@link #SELECT_ALL_ON_FOCUS_POLICY_NEVER},
 	 *     {@link #SELECT_ALL_ON_FOCUS_POLICY_ONCE} (default) or
 	 *     {@link #SELECT_ALL_ON_FOCUS_POLICY_ALWAYS}
+	 *
+	 * @see #SELECT_ALL_ON_MOUSE_CLICK
 	 */
 	String SELECT_ALL_ON_FOCUS_POLICY = "JTextField.selectAllOnFocusPolicy";
 
@@ -811,6 +1234,12 @@ public interface FlatClientProperties
 	 * Select all text when the text component gains focus for the first time
 	 * and selection was not modified (is at end of text).
 	 * This is the default.
+	 * <p>
+	 * <b>Limitations:</b>
+	 * For {@link JFormattedTextField} and {@link JSpinner} this behaves
+	 * as {@link #SELECT_ALL_ON_FOCUS_POLICY_ALWAYS}.
+     * This is because of special behavior of {@link JFormattedTextField}
+     * that did not allow implementation of {@code "once"}.
 	 *
 	 * @see #SELECT_ALL_ON_FOCUS_POLICY
 	 */
@@ -823,6 +1252,19 @@ public interface FlatClientProperties
 	 */
 	String SELECT_ALL_ON_FOCUS_POLICY_ALWAYS = "always";
 
+	/**
+	 * Specifies whether all text is selected when when clicking with the mouse
+	 * into the text field (and if "select all on focus" policy is enabled).
+	 * <p>
+	 * <strong>Components</strong> {@link javax.swing.text.JTextComponent} (and subclasses),
+	 * {@link javax.swing.JComboBox} and {@link javax.swing.JSpinner}<br>
+	 * <strong>Value type</strong> {@link java.lang.Boolean}
+	 *
+	 * @see #SELECT_ALL_ON_FOCUS_POLICY
+	 * @since 3.6
+	 */
+	String SELECT_ALL_ON_MOUSE_CLICK = "JTextField.selectAllOnMouseClick";
+
 	/**
 	 * Placeholder text that is only painted if the text field is empty.
 	 * <p>
@@ -863,10 +1305,118 @@ public interface FlatClientProperties
 	 */
 	String TEXT_FIELD_TRAILING_ICON = "JTextField.trailingIcon";
 
+	/**
+	 * Specifies a component that will be placed at the leading edge of the text field.
+	 * <p>
+	 * The component will be positioned inside and aligned to the visible text field border.
+	 * There is no gap between the visible border and the component.
+	 * The laid out component size will be the preferred component width
+	 * and the inner text field height.
+	 * <p>
+	 * The component should be not opaque because the text field border is painted
+	 * slightly inside the usually visible border in some cases.
+	 * E.g. when focused (in some themes) or when an outline color is specified
+	 * (see {@link #OUTLINE}).
+	 * <p>
+	 * The component is prepared in the following way:
+	 * <ul>
+	 * <li>Component client property {@link #STYLE_CLASS} is set to {@code inTextField}.
+	 * <li>If component is a button or toggle button, client property {@link #BUTTON_TYPE}
+	 *     is set to {@link #BUTTON_TYPE_TOOLBAR_BUTTON}
+	 *     and button cursor is set to default cursor (if not set).
+	 * <li>If component is a toolbar, client property {@link #STYLE_CLASS}
+	 *     is set to {@code inTextField} on all toolbar children
+	 *     and toolbar cursor is set to default cursor (if not set).
+	 * </ul>
+	 * Because text fields use the text cursor by default and the cursor is inherited by child components,
+	 * it may be necessary to explicitly set component cursor if you e.g. need the default arrow cursor.
+	 * E.g. {@code comp.setCursor( Cursor.getDefaultCursor() )}.
+	 * <p>
+	 * Styling is used to modify insets/margins and appearance of buttons and toolbars
+	 * so that they fit nicely into the text field and do not increase text field height.
+	 * See styles {@code [style]Button.inTextField} and {@code [style]ToolBar.inTextField}
+	 * in {@code Flat[Light|Dark]Laf.properties}.
+	 * <p>
+	 * <strong>Component</strong> {@link javax.swing.JTextField} (and subclasses)<br>
+	 * <strong>Value type</strong> {@link javax.swing.JComponent}
+	 *
+	 * @since 2
+	 */
+	String TEXT_FIELD_LEADING_COMPONENT = "JTextField.leadingComponent";
+
+	/**
+	 * Specifies a component that will be placed at the trailing edge of the text field.
+	 * <p>
+	 * See {@link #TEXT_FIELD_LEADING_COMPONENT} for details.
+	 * <p>
+	 * <strong>Component</strong> {@link javax.swing.JTextField} (and subclasses)<br>
+	 * <strong>Value type</strong> {@link javax.swing.JComponent}
+	 *
+	 * @since 2
+	 */
+	String TEXT_FIELD_TRAILING_COMPONENT = "JTextField.trailingComponent";
+
+	/**
+	 * Specifies whether a "clear" (or "cancel") button is shown on the trailing side
+	 * if the text field is not empty, editable and enabled. Default is {@code false}.
+	 * <p>
+	 * <strong>Component</strong> {@link javax.swing.JTextField} (and subclasses)<br>
+	 * <strong>Value type</strong> {@link java.lang.Boolean}
+	 *
+	 * @since 2
+	 */
+	String TEXT_FIELD_SHOW_CLEAR_BUTTON = "JTextField.showClearButton";
+
+	/**
+	 * Specifies the callback that is invoked when a "clear" (or "cancel") button is clicked.
+	 * If a callback is specified than it is responsible for clearing the text field.
+	 * Without callback, the text field clears itself.
+	 * <p>
+	 * Either use a {@link java.lang.Runnable}:
+	 * <pre>{@code
+	 * myTextField.putClientProperty( "JTextField.clearCallback",
+	 *     (Runnable) () -> {
+	 *         // clear field here or cancel search
+	 *     } );
+	 * }</pre>
+	 * Or use a {@link java.util.function.Consumer}&lt;javax.swing.text.JTextComponent&gt;
+	 * that receives the text field as parameter:
+	 * <pre>{@code
+	 * myTextField.putClientProperty( "JTextField.clearCallback",
+	 *     (Consumer<JTextComponent>) textField -> {
+	 *         // clear field here or cancel search
+	 *     } );
+	 * }</pre>
+	 * <p>
+	 * <strong>Component</strong> {@link javax.swing.JTextField} (and subclasses)<br>
+	 * <strong>Value type</strong> {@link java.lang.Runnable}
+	 * or {@link java.util.function.Consumer}&lt;javax.swing.text.JTextComponent&gt;
+	 *
+	 * @see #TEXT_FIELD_SHOW_CLEAR_BUTTON
+	 * @since 2
+	 */
+	String TEXT_FIELD_CLEAR_CALLBACK = "JTextField.clearCallback";
+
+
 	//---- JToggleButton ------------------------------------------------------
 
 	/**
-	 * Height of underline if toggle button type is {@link #BUTTON_TYPE_TAB}.
+	 * Placement of underline if toggle button type is {@link #BUTTON_TYPE_TAB}
+	 * <p>
+	 * <strong>Component</strong> {@link javax.swing.JToggleButton}<br>
+	 * <strong>Value type</strong> {@link java.lang.Integer}<br>
+	 * <strong>Allowed Values</strong>
+	 *     {@link SwingConstants#BOTTOM} (default),
+	 *     {@link SwingConstants#TOP},
+	 *     {@link SwingConstants#LEFT} or
+	 *     {@link SwingConstants#RIGHT}
+	 *
+	 * @since 2.3
+	 */
+	String TAB_BUTTON_UNDERLINE_PLACEMENT = "JToggleButton.tab.underlinePlacement";
+
+	/**
+	 * Thickness of underline if toggle button type is {@link #BUTTON_TYPE_TAB}.
 	 * <p>
 	 * <strong>Component</strong> {@link javax.swing.JToggleButton}<br>
 	 * <strong>Value type</strong> {@link java.lang.Integer}
@@ -889,16 +1439,27 @@ public interface FlatClientProperties
 	 */
 	String TAB_BUTTON_SELECTED_BACKGROUND = "JToggleButton.tab.selectedBackground";
 
+
 	//---- JTree --------------------------------------------------------------
 
 	/**
-	 * Override if a tree shows a wide selection. Default is {@code true}.
+	 * Specifies whether tree shows a wide selection. Default is {@code true}.
 	 * <p>
 	 * <strong>Component</strong> {@link javax.swing.JTree}<br>
 	 * <strong>Value type</strong> {@link java.lang.Boolean}
 	 */
 	String TREE_WIDE_SELECTION = "JTree.wideSelection";
 
+	/**
+	 * Specifies whether tree uses a wide cell renderer. Default is {@code false}.
+	 * <p>
+	 * <strong>Component</strong> {@link javax.swing.JTree}<br>
+	 * <strong>Value type</strong> {@link java.lang.Boolean}
+	 *
+	 * @since 3.6
+	 */
+	String TREE_WIDE_CELL_RENDERER = "JTree.wideCellRenderer";
+
 	/**
 	 * Specifies whether tree item selection is painted. Default is {@code true}.
 	 * If set to {@code false}, then the tree cell renderer is responsible for painting selection.
@@ -908,6 +1469,45 @@ public interface FlatClientProperties
 	 */
 	String TREE_PAINT_SELECTION = "JTree.paintSelection";
 
+
+	//---- macOS --------------------------------------------------------------
+
+	/**
+	 * Specifies the spacing around the macOS window close/minimize/zoom buttons.
+	 * Useful if <a href="https://www.formdev.com/flatlaf/macos/#full_window_content">full window content</a>
+	 * is enabled.
+	 * <p>
+	 * (requires macOS 10.14+ for "medium" spacing and macOS 11+ for "large" spacing, requires Java 17+)
+	 * <p>
+	 * <strong>Component</strong> {@link javax.swing.JRootPane}<br>
+	 * <strong>Value type</strong> {@link java.lang.String}<br>
+	 * <strong>Allowed Values</strong>
+	 *     {@link #MACOS_WINDOW_BUTTONS_SPACING_MEDIUM} or
+	 *     {@link #MACOS_WINDOW_BUTTONS_SPACING_LARGE} (requires macOS 11+)
+	 *
+	 * @since 3.4
+	 */
+	String MACOS_WINDOW_BUTTONS_SPACING = "FlatLaf.macOS.windowButtonsSpacing";
+
+	/**
+	 * Add medium spacing around the macOS window close/minimize/zoom buttons.
+	 *
+	 * @see #MACOS_WINDOW_BUTTONS_SPACING
+	 * @since 3.4
+	 */
+	String MACOS_WINDOW_BUTTONS_SPACING_MEDIUM = "medium";
+
+	/**
+	 * Add large spacing around the macOS window close/minimize/zoom buttons.
+	 * <p>
+	 * (requires macOS 11+; "medium" is used on older systems)
+	 *
+	 * @see #MACOS_WINDOW_BUTTONS_SPACING
+	 * @since 3.4
+	 */
+	String MACOS_WINDOW_BUTTONS_SPACING_LARGE = "large";
+
+
 	//---- helper methods -----------------------------------------------------
 
 	/**

flatlaf-core/src/main/java/com/formdev/flatlaf/FlatDarculaLaf.java

@@ -34,6 +34,8 @@ public class FlatDarculaLaf
 	/**
 	 * Sets the application look and feel to this LaF
 	 * using {@link UIManager#setLookAndFeel(javax.swing.LookAndFeel)}.
+	 *
+	 * @since 1.2
 	 */
 	public static boolean setup() {
 		return setup( new FlatDarculaLaf() );

flatlaf-core/src/main/java/com/formdev/flatlaf/FlatDarkLaf.java

@@ -33,6 +33,8 @@ public class FlatDarkLaf
 	/**
 	 * Sets the application look and feel to this LaF
 	 * using {@link UIManager#setLookAndFeel(javax.swing.LookAndFeel)}.
+	 *
+	 * @since 1.2
 	 */
 	public static boolean setup() {
 		return setup( new FlatDarkLaf() );

flatlaf-core/src/main/java/com/formdev/flatlaf/FlatDefaultsAddon.java

@@ -26,7 +26,7 @@ import javax.swing.UIDefaults;
  * Allows loading of additional .properties files from addon JARs.
  * {@link java.util.ServiceLoader} is used to load extensions of this class from addon JARs.
  * <p>
- * If you extend this class in a addon JAR, you also have to add a text file named
+ * If you extend this class in an addon JAR, you also have to add a text file named
  * {@code META-INF/services/com.formdev.flatlaf.FlatDefaultsAddon}
  * to the addon JAR. The file must contain a single line with the class name.
  * <p>
@@ -48,7 +48,7 @@ public abstract class FlatDefaultsAddon
 	public InputStream getDefaults( Class<?> lafClass ) {
 		Class<?> addonClass = this.getClass();
 		String propertiesName = '/' + addonClass.getPackage().getName().replace( '.', '/' )
-			+ '/' + lafClass.getSimpleName() + ".properties";
+			+ '/' + UIDefaultsLoader.simpleClassName( lafClass ) + ".properties";
 		return addonClass.getResourceAsStream( propertiesName );
 	}
 
@@ -61,7 +61,7 @@ public abstract class FlatDefaultsAddon
 
 	/**
 	 * Returns the priority used to sort addon loading.
-	 * The order is only important if you want overwrite UI defaults of other addons.
+	 * The order is only important if you want to overwrite UI defaults of other addons.
 	 * Lower numbers mean higher priority.
 	 * Returns 10000 by default.
 	 */

flatlaf-core/src/main/java/com/formdev/flatlaf/FlatIconColors.java

@@ -19,7 +19,7 @@ package com.formdev.flatlaf;
 /**
  * Default color palette for action icons and object icons.
  * <p>
- * The idea is to use only this well defined set of colors in SVG icons and
+ * The idea is to use only this well-defined set of colors in SVG icons, and
  * then they are replaced at runtime to dark variants or to other theme colors.
  * Then a single SVG icon (light variant) can be used for dark themes too.
  * IntelliJ Platform uses this mechanism to allow themes to change IntelliJ Platform icons.
@@ -35,7 +35,7 @@ package com.formdev.flatlaf;
  * <p>
  * You may use these colors also in your application (outside of SVG icons), but do
  * not use the RGB values defined in this enum.<br>
- * Instead use {@code UIManager.getColor( FlatIconColors.ACTIONS_GREY.key )}.
+ * Instead, use {@code UIManager.getColor( FlatIconColors.ACTIONS_GREY.key )}.
  *
  * @author Karl Tauber
  */

flatlaf-core/src/main/java/com/formdev/flatlaf/FlatInputMaps.java

@@ -50,7 +50,8 @@ class FlatInputMaps
 		}
 
 		modifyInputMap( defaults, "ComboBox.ancestorInputMap",
-			"SPACE", "spacePopup",
+// Space key still shows popup, but from FlatComboBoxUI.FlatKeySelectionManager
+//			"SPACE", "spacePopup",
 
 			"UP", mac( "selectPrevious2", "selectPrevious" ),
 			"DOWN", mac( "selectNext2", "selectNext" ),
@@ -70,7 +71,7 @@ class FlatInputMaps
 			);
 		}
 
-		// join ltr and rtl bindings to fix up/down/etc keys in right-to-left component orientation
+		// join ltr and rtl bindings to fix up/down/etc. keys in right-to-left component orientation
 		Object[] bindings = (Object[]) defaults.get( "PopupMenu.selectedWindowInputMapBindings" );
 		Object[] rtlBindings = (Object[]) defaults.get( "PopupMenu.selectedWindowInputMapBindings.RightToLeft" );
 		if( bindings != null && rtlBindings != null ) {
@@ -596,7 +597,7 @@ class FlatInputMaps
 	//---- class LazyInputMapEx -----------------------------------------------
 
 	/**
-	 * Lazily creates a input map.
+	 * Lazily creates an input map.
 	 * Similar to {@link UIDefaults.LazyInputMap}, but can use multiple bindings arrays.
 	 */
 	private static class LazyInputMapEx

flatlaf-core/src/main/java/com/formdev/flatlaf/FlatIntelliJLaf.java

@@ -34,6 +34,8 @@ public class FlatIntelliJLaf
 	/**
 	 * Sets the application look and feel to this LaF
 	 * using {@link UIManager#setLookAndFeel(javax.swing.LookAndFeel)}.
+	 *
+	 * @since 1.2
 	 */
 	public static boolean setup() {
 		return setup( new FlatIntelliJLaf() );

flatlaf-core/src/main/java/com/formdev/flatlaf/FlatLaf.java

@@ -20,6 +20,7 @@ import java.awt.Color;
 import java.awt.Component;
 import java.awt.EventQueue;
 import java.awt.Font;
+import java.awt.GraphicsEnvironment;
 import java.awt.Image;
 import java.awt.RenderingHints;
 import java.awt.Toolkit;
@@ -36,6 +37,7 @@ import java.util.ArrayList;
 import java.util.Collections;
 import java.util.Enumeration;
 import java.util.HashMap;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Locale;
 import java.util.Map;
@@ -43,6 +45,7 @@ import java.util.MissingResourceException;
 import java.util.Properties;
 import java.util.ResourceBundle;
 import java.util.ServiceLoader;
+import java.util.Set;
 import java.util.function.Consumer;
 import java.util.function.Function;
 import java.util.function.IntUnaryOperator;
@@ -52,6 +55,7 @@ import javax.swing.ImageIcon;
 import javax.swing.JComponent;
 import javax.swing.JDialog;
 import javax.swing.JFrame;
+import javax.swing.JMenuBar;
 import javax.swing.LookAndFeel;
 import javax.swing.PopupFactory;
 import javax.swing.RootPaneContainer;
@@ -62,16 +66,21 @@ import javax.swing.UIDefaults.LazyValue;
 import javax.swing.UIManager;
 import javax.swing.UnsupportedLookAndFeelException;
 import javax.swing.plaf.ColorUIResource;
+import javax.swing.plaf.ComponentUI;
 import javax.swing.plaf.FontUIResource;
 import javax.swing.plaf.IconUIResource;
 import javax.swing.plaf.UIResource;
 import javax.swing.plaf.basic.BasicLookAndFeel;
+import javax.swing.plaf.metal.MetalLookAndFeel;
 import javax.swing.text.StyleContext;
 import javax.swing.text.html.HTMLEditorKit;
 import com.formdev.flatlaf.ui.FlatNativeWindowBorder;
 import com.formdev.flatlaf.ui.FlatPopupFactory;
 import com.formdev.flatlaf.ui.FlatRootPaneUI;
 import com.formdev.flatlaf.ui.FlatUIUtils;
+import com.formdev.flatlaf.ui.JavaCompatibility2;
+import com.formdev.flatlaf.ui.FlatStylingSupport.StyleableUI;
+import com.formdev.flatlaf.util.FontUtils;
 import com.formdev.flatlaf.util.GrayFilter;
 import com.formdev.flatlaf.util.LoggingFacade;
 import com.formdev.flatlaf.util.MultiResolutionImageSupport;
@@ -92,6 +101,9 @@ public abstract class FlatLaf
 	private static List<Object> customDefaultsSources;
 	private static Map<String, String> globalExtraDefaults;
 	private Map<String, String> extraDefaults;
+	private static Function<String, Color> systemColorGetter;
+	private static Set<String> uiKeyPlatformPrefixes;
+	private static Set<String> uiKeySpecialPrefixes;
 
 	private String desktopPropertyName;
 	private String desktopPropertyName2;
@@ -102,13 +114,62 @@ public abstract class FlatLaf
 
 	private PopupFactory oldPopupFactory;
 	private MnemonicHandler mnemonicHandler;
+	private boolean subMenuUsabilityHelperInstalled;
+	private LinuxPopupMenuCanceler linuxPopupMenuCanceler;
 
 	private Consumer<UIDefaults> postInitialization;
 	private List<Function<Object, Object>> uiDefaultsGetters;
 
+	private static String preferredFontFamily;
+	private static String preferredLightFontFamily;
+	private static String preferredSemiboldFontFamily;
+	private static String preferredMonospacedFontFamily;
+
+	static {
+		// see disableWindowsD3Donscreen() for details
+		// https://github.com/JFormDesigner/FlatLaf/issues/887
+		if( SystemInfo.isWindows &&
+			System.getProperty( "sun.java2d.d3d.onscreen" ) == null &&
+			System.getProperty( "sun.java2d.d3d" ) == null &&
+			System.getProperty( "sun.java2d.noddraw" ) == null )
+		  System.setProperty( "sun.java2d.d3d.onscreen", "false" );
+	}
+
+	/**
+	 * Disable usage of Windows Direct3D (DirectX) onscreen surfaces because this may lead to
+	 * repaint issues (ghosting) on some systems (probably depending on graphics card/driver).
+	 * Problem occurs usually when a small heavy-weight popup window (menu, combobox, tooltip) is shown.
+	 * <p>
+	 * Sets system property {@code sun.java2d.d3d.onscreen} to {@code false},
+	 * but only if {@code sun.java2d.d3d.onscreen}, {@code sun.java2d.d3d}
+	 * and {@code sun.java2d.noddraw} are not yet set.
+	 * <p>
+	 * <strong>Note</strong>: Must be invoked very early before the graphics environment is created.
+	 * <p>
+	 * This method is automatically invoked when loading this class,
+	 * which is usually before the graphics environment is created.
+	 * E.g. when doing {@code FlatLightLaf.setup()} or
+	 * {@code UIManager.setLookAndFeel( "com.formdev.flatlaf.FlatLightLaf" )}.
+	 * <p>
+	 * However, it may be invoked too late if you use some methods from {@link UIManager}
+	 * of {@link GraphicsEnvironment} before setting look and feel.
+	 * E.g. {@link UIManager#put(Object, Object)}.
+	 * In that case invoke this method yourself very early.
+	 * <p>
+	 * <strong>Tip</strong>: How to find out when the graphics environment is created?
+	 * Set a breakpoint at constructor of class {@link GraphicsEnvironment} and look at the stack.
+	 *
+	 * @since 3.5.2
+	 */
+	public static void disableWindowsD3Donscreen() {
+		// dummy method used to trigger invocation of "static {...}" block
+	}
+
 	/**
 	 * Sets the application look and feel to the given LaF
 	 * using {@link UIManager#setLookAndFeel(javax.swing.LookAndFeel)}.
+	 *
+	 * @since 1.2
 	 */
 	public static boolean setup( LookAndFeel newLookAndFeel ) {
 		try {
@@ -165,18 +226,13 @@ public abstract class FlatLaf
 	 * Returns whether FlatLaf supports custom window decorations.
 	 * This depends on the operating system and on the used Java runtime.
 	 * <p>
-	 * This method returns {@code true} on Windows 10 (see exception below), {@code false} otherwise.
+	 * This method returns {@code true} on Windows 10/11 (see exception below)
+	 * and on Linux, otherwise returns {@code false}.
 	 * <p>
-	 * Returns also {@code false} on Windows 10 if:
-	 * <ul>
-	 * <li>FlatLaf native window border support is available (requires Windows 10)</li>
-	 * <li>running in
-	 * <a href="https://confluence.jetbrains.com/display/JBR/JetBrains+Runtime">JetBrains Runtime 11 (or later)</a>
-	 * (<a href="https://github.com/JetBrains/JetBrainsRuntime">source code on github</a>)
-	 * and JBR supports custom window decorations
-	 * </li>
-	 * </ul>
-	 * In this cases, custom decorations are enabled by the root pane.
+	 * Returns also {@code false} on Windows 10/11 if
+	 * FlatLaf native window border support is available (requires Windows 10/11).
+	 * <p>
+	 * In these cases, custom decorations are enabled by the root pane.
 	 * Usage of {@link JFrame#setDefaultLookAndFeelDecorated(boolean)} or
 	 * {@link JDialog#setDefaultLookAndFeelDecorated(boolean)} is not necessary.
 	 */
@@ -189,7 +245,7 @@ public abstract class FlatLaf
 			FlatNativeWindowBorder.isSupported() )
 		  return false;
 
-		return SystemInfo.isWindows_10_orLater;
+		return SystemInfo.isWindows_10_orLater || SystemInfo.isLinux;
 	}
 
 	@Override
@@ -229,6 +285,15 @@ public abstract class FlatLaf
 
 	@Override
 	public void initialize() {
+		// do not initialize if this is not the current look and feel
+		//    This is only necessary for special Laf usage. E.g. in GUI builders,
+		//    which may use multiple Lafs and may invoke this method directly.
+		//    This avoids that listeners and factories are installed multiple times.
+		//    In case of the NetBeans GUI builder, which does not invoke uninitialize(),
+		//    this also avoids that listeners stay registered in the system.
+		if( UIManager.getLookAndFeel() != this )
+			return;
+
 		if( SystemInfo.isMacOS )
 			initializeAqua();
 
@@ -242,6 +307,13 @@ public abstract class FlatLaf
 		mnemonicHandler = new MnemonicHandler();
 		mnemonicHandler.install();
 
+		// install submenu usability helper
+		subMenuUsabilityHelperInstalled = SubMenuUsabilityHelper.install();
+
+		// install Linux popup menu canceler
+		if( SystemInfo.isLinux )
+			linuxPopupMenuCanceler = new LinuxPopupMenuCanceler();
+
 		// listen to desktop property changes to update UI if system font or scaling changes
 		if( SystemInfo.isWindows ) {
 			// Windows 10 allows increasing font size independent of scaling:
@@ -259,6 +331,9 @@ public abstract class FlatLaf
 		}
 		if( desktopPropertyName != null ) {
 			desktopPropertyListener = e -> {
+				if( !FlatSystemProperties.getBoolean( FlatSystemProperties.UPDATE_UI_ON_SYSTEM_FONT_CHANGE, true ) )
+					return;
+
 				String propertyName = e.getPropertyName();
 				if( desktopPropertyName.equals( propertyName ) || propertyName.equals( desktopPropertyName2 ) )
 					reSetLookAndFeel();
@@ -293,10 +368,30 @@ public abstract class FlatLaf
 					String.format( "a, address { color: #%06x; }", linkColor.getRGB() & 0xffffff ) );
 			}
 		};
+
+		// Initialize UIScale user scale factor immediately after FlatLaf was activated,
+		// which is necessary to ensure that UIScale.setZoomFactor(float)
+		// scales FlatLaf defaultDont correctly even if UIScale.scale() was not yet used.
+		// In other words: Without this, UIScale.setZoomFactor(float) would
+		// not work correctly if invoked between FlatLaf.setup() and crating UI.
+		PropertyChangeListener listener = new PropertyChangeListener() {
+			@Override
+			public void propertyChange( PropertyChangeEvent e ) {
+				if( "lookAndFeel".equals( e.getPropertyName() ) ) {
+					UIManager.removePropertyChangeListener( this );
+					UIScale.getUserScaleFactor();
+				}
+			}
+		};
+		UIManager.addPropertyChangeListener( listener );
 	}
 
 	@Override
 	public void uninitialize() {
+		// do not uninitialize if this is not the current look and feel
+		if( UIManager.getLookAndFeel() != this )
+			return;
+
 		// remove desktop property listener
 		if( desktopPropertyListener != null ) {
 			Toolkit toolkit = Toolkit.getDefaultToolkit();
@@ -321,6 +416,18 @@ public abstract class FlatLaf
 			mnemonicHandler = null;
 		}
 
+		// uninstall submenu usability helper
+		if( subMenuUsabilityHelperInstalled ) {
+			SubMenuUsabilityHelper.uninstall();
+			subMenuUsabilityHelperInstalled = false;
+		}
+
+		// uninstall Linux popup menu canceler
+		if( linuxPopupMenuCanceler != null ) {
+			linuxPopupMenuCanceler.uninstall();
+			linuxPopupMenuCanceler = null;
+		}
+
 		// restore default link color
 		new HTMLEditorKit().getStyleSheet().addRule( "a, address { color: blue; }" );
 		postInitialization = null;
@@ -349,7 +456,7 @@ public abstract class FlatLaf
 				Method m = UIManager.class.getMethod( "createLookAndFeel", String.class );
 				aquaLaf = (BasicLookAndFeel) m.invoke( null, "Mac OS X" );
 			} else
-				aquaLaf = (BasicLookAndFeel) Class.forName( aquaLafClassName ).getDeclaredConstructor().newInstance();
+				aquaLaf = Class.forName( aquaLafClassName ).asSubclass( BasicLookAndFeel.class ).getDeclaredConstructor().newInstance();
 		} catch( Exception ex ) {
 			LoggingFacade.INSTANCE.logSevere( "FlatLaf: Failed to initialize Aqua look and feel '" + aquaLafClassName + "'.", ex );
 			throw new IllegalStateException();
@@ -434,10 +541,10 @@ public abstract class FlatLaf
 
 		// load defaults from properties
 		List<Class<?>> lafClassesForDefaultsLoading = getLafClassesForDefaultsLoading();
-		if( lafClassesForDefaultsLoading != null )
-			UIDefaultsLoader.loadDefaultsFromProperties( lafClassesForDefaultsLoading, addons, getAdditionalDefaults(), isDark(), defaults );
-		else
-			UIDefaultsLoader.loadDefaultsFromProperties( getClass(), addons, getAdditionalDefaults(), isDark(), defaults );
+		if( lafClassesForDefaultsLoading == null )
+			lafClassesForDefaultsLoading = UIDefaultsLoader.getLafClassesForDefaultsLoading( getClass() );
+		UIDefaultsLoader.loadDefaultsFromProperties( lafClassesForDefaultsLoading, addons,
+			this::applyAdditionalProperties, getAdditionalDefaults(), isDark(), defaults );
 
 		// setup default font after loading defaults from properties
 		// to allow defining "defaultFont" in properties
@@ -454,9 +561,6 @@ public abstract class FlatLaf
 		// initialize text antialiasing
 		putAATextInfo( defaults );
 
-		// apply additional defaults (e.g. from IntelliJ themes)
-		applyAdditionalDefaults( defaults );
-
 		// allow addons modifying UI defaults
 		for( FlatDefaultsAddon addon : addons )
 			addon.afterDefaultsLoading( this, defaults );
@@ -466,6 +570,9 @@ public abstract class FlatLaf
 			return UIScale.getUserScaleFactor();
 		} );
 
+		// add lazy UI delegate class loading (if necessary)
+		addLazyUIdelegateClassLoading( defaults );
+
 		if( postInitialization != null ) {
 			postInitialization.accept( defaults );
 			postInitialization = null;
@@ -474,7 +581,8 @@ public abstract class FlatLaf
 		return defaults;
 	}
 
-	void applyAdditionalDefaults( UIDefaults defaults ) {
+	// apply additional properties (e.g. from IntelliJ themes)
+	void applyAdditionalProperties( Properties properties ) {
 	}
 
 	protected List<Class<?>> getLafClassesForDefaultsLoading() {
@@ -501,7 +609,7 @@ public abstract class FlatLaf
 		// which can happen in applications that use some plugin system
 		// and load FlatLaf in a plugin that uses its own classloader.
 		// (e.g. Apache NetBeans)
-		if( defaults.get( "FileChooser.fileNameHeaderText" ) != null )
+		if( defaults.get( "TabbedPane.moreTabsButtonToolTipText" ) != null )
 			return;
 
 		// load FlatLaf resource bundle and add content to defaults
@@ -539,13 +647,17 @@ public abstract class FlatLaf
 		Object activeFont = new ActiveFont( null, null, -1, 0, 0, 0, 0 );
 
 		// override fonts
+		List<String> fontKeys = new ArrayList<>( 50 );
 		for( Object key : defaults.keySet() ) {
 			if( key instanceof String && (((String)key).endsWith( ".font" ) || ((String)key).endsWith( "Font" )) )
-				defaults.put( key, activeFont );
+				fontKeys.add( (String) key );
 		}
+		for( String key : fontKeys )
+			defaults.put( key, activeFont );
 
 		// add fonts that are not set in BasicLookAndFeel
 		defaults.put( "RootPane.font", activeFont );
+		defaults.put( "TitlePane.font", activeFont );
 	}
 
 	private void initDefaultFont( UIDefaults defaults ) {
@@ -594,6 +706,13 @@ public abstract class FlatLaf
 		if( uiFont == null )
 			uiFont = createCompositeFont( Font.SANS_SERIF, Font.PLAIN, 12 );
 
+		// use preferred font family (if specified)
+		if( preferredFontFamily != null ) {
+			FontUIResource preferredFont = createCompositeFont( preferredFontFamily, uiFont.getStyle(), uiFont.getSize() );
+			if( !ActiveFont.isFallbackFont( preferredFont ) || ActiveFont.isDialogFamily( preferredFontFamily ) )
+				uiFont = preferredFont;
+		}
+
 		// get/remove "defaultFont" from defaults if set in properties files
 		// (use remove() to avoid that ActiveFont.createValue() gets invoked)
 		Object defaultFont = defaults.remove( "defaultFont" );
@@ -604,16 +723,30 @@ public abstract class FlatLaf
 			uiFont = ((ActiveFont)defaultFont).derive( baseFont, fontSize -> {
 				return Math.round( fontSize * UIScale.computeFontScaleFactor( baseFont ) );
 			} );
-		};
+		} else if( defaultFont instanceof LazyValue )
+			uiFont = ActiveFont.toUIResource( (Font) ((LazyValue)defaultFont).createValue( defaults ) );
 
 		// increase font size if system property "flatlaf.uiScale" is set
 		uiFont = UIScale.applyCustomScaleFactor( uiFont );
 
+		// apply zoom factor to font size
+		float zoomFactor = UIScale.getZoomFactor();
+		if( zoomFactor != 1 ) {
+			// see also UIScale.setZoomFactor()
+			int unzoomedFontSize = uiFont.getSize();
+			defaults.put( "defaultFont.unzoomedSize", unzoomedFontSize );
+			int newFontSize = Math.max( Math.round( unzoomedFontSize * zoomFactor ), 1 );
+			uiFont = new FontUIResource( uiFont.deriveFont( (float) newFontSize ) );
+		}
+
 		// set default font
 		defaults.put( "defaultFont", uiFont );
 	}
 
 	static FontUIResource createCompositeFont( String family, int style, int size ) {
+		// load lazy font family
+		FontUtils.loadFontFamily( family );
+
 		// using StyleContext.getFont() here because it uses
 		// sun.font.FontUtilities.getCompositeFontUIResource()
 		// and creates a composite font that is able to display all Unicode characters
@@ -649,6 +782,53 @@ public abstract class FlatLaf
 		}
 	}
 
+	/**
+	 * Handle UI delegate classes if running in special application where multiple class loaders are involved.
+	 * E.g. in Eclipse plugin or in LibreOffice extension.
+	 * <p>
+	 * Problem: Swing runs in Java's system classloader and FlatLaf is loaded in plugin classloader.
+	 * When Swing tries to load UI delegate class in {@link UIDefaults#getUIClass(String, ClassLoader)},
+	 * invoked from {@link UIDefaults#getUI(JComponent)}, it uses the component's classloader,
+	 * which is Java's system classloader for core Swing components,
+	 * and can not find FlatLaf UI delegates.
+	 * <p>
+	 * Solution: Add lazy values for UI delegate class names.
+	 * Those lazy values use FlatLaf classloader to load UI delegate class.
+	 * This is similar to what {@link UIDefaults#getUIClass(String, ClassLoader)} does.
+	 * <p>
+	 * Not using {@code defaults.put( "ClassLoader", FlatLaf.class.getClassLoader() )},
+	 * which would work for FlatLaf UI delegates, but it would break custom
+	 * UI delegates used in other classloaders.
+	 */
+	private static void addLazyUIdelegateClassLoading( UIDefaults defaults ) {
+		if( FlatLaf.class.getClassLoader() == ClassLoader.getSystemClassLoader() )
+			return; // not necessary
+
+		Map<String, LazyValue> map = new HashMap<>();
+		for( Map.Entry<Object, Object> e : defaults.entrySet() ) {
+			Object key = e.getKey();
+			Object value = e.getValue();
+			if( key instanceof String && ((String)key).endsWith( "UI" ) &&
+				value instanceof String && !defaults.containsKey( value ) )
+			{
+				String className = (String) value;
+				map.put( className, (LazyValue) t -> {
+					try {
+						Class<?> uiClass = FlatLaf.class.getClassLoader().loadClass( className );
+						if( ComponentUI.class.isAssignableFrom( uiClass ) )
+							return uiClass;
+					} catch( ClassNotFoundException ex ) {
+						// ignore
+					}
+
+					// let UIDefaults.getUIClass() try to load UI delegate class
+					return null;
+				} );
+			}
+		}
+		defaults.putAll( map );
+	}
+
 	private void putAATextInfo( UIDefaults defaults ) {
 		if ( SystemInfo.isMacOS && SystemInfo.isJetBrainsJVM ) {
 			// The awt.font.desktophints property suggests sub-pixel anti-aliasing
@@ -758,8 +938,7 @@ public abstract class FlatLaf
 	 * <p>
 	 * Invoke this method before setting the look and feel.
 	 * <p>
-	 * If using Java modules, the package must be opened in {@code module-info.java}.
-	 * Otherwise use {@link #registerCustomDefaultsSource(URL)}.
+	 * If using Java modules, it is not necessary to open the package in {@code module-info.java}.
 	 *
 	 * @param packageName a package name (e.g. "com.myapp.resources")
 	 */
@@ -806,9 +985,9 @@ public abstract class FlatLaf
 	 * <p>
 	 * See {@link #registerCustomDefaultsSource(String)} for details.
 	 * <p>
-	 * This method is useful if using Java modules and the package containing the properties files
-	 * is not opened in {@code module-info.java}.
 	 * E.g. {@code FlatLaf.registerCustomDefaultsSource( MyApp.class.getResource( "/com/myapp/themes/" ) )}.
+	 * <p>
+	 * If using Java modules, it is not necessary to open the package in {@code module-info.java}.
 	 *
 	 * @param packageUrl a package URL
 	 * @since 2
@@ -861,14 +1040,14 @@ public abstract class FlatLaf
 	 * E.g. using {@link UIManager#setLookAndFeel(LookAndFeel)} or {@link #setup(LookAndFeel)}.
 	 * <p>
 	 * The global extra defaults are useful for smaller additional defaults that may change.
-	 * E.g. accent color. Otherwise FlatLaf properties files should be used.
+	 * Otherwise, FlatLaf properties files should be used.
 	 * See {@link #registerCustomDefaultsSource(String)}.
 	 * <p>
 	 * The keys and values are strings in same format as in FlatLaf properties files.
 	 * <p>
-	 * Sample that setups "FlatLaf Light" theme with red accent color:
+	 * Sample that setups "FlatLaf Light" theme with white background color:
 	 * <pre>{@code
-	 * FlatLaf.setGlobalExtraDefaults( Collections.singletonMap( "@accentColor", "#f00" ) );
+	 * FlatLaf.setGlobalExtraDefaults( Collections.singletonMap( "@background", "#fff" ) );
 	 * FlatLightLaf.setup();
 	 * }</pre>
 	 *
@@ -893,15 +1072,15 @@ public abstract class FlatLaf
 	 * E.g. using {@link UIManager#setLookAndFeel(LookAndFeel)} or {@link #setup(LookAndFeel)}.
 	 * <p>
 	 * The extra defaults are useful for smaller additional defaults that may change.
-	 * E.g. accent color. Otherwise FlatLaf properties files should be used.
+	 * Otherwise, FlatLaf properties files should be used.
 	 * See {@link #registerCustomDefaultsSource(String)}.
 	 * <p>
 	 * The keys and values are strings in same format as in FlatLaf properties files.
 	 * <p>
-	 * Sample that setups "FlatLaf Light" theme with red accent color:
+	 * Sample that setups "FlatLaf Light" theme with white background color:
 	 * <pre>{@code
 	 * FlatLaf laf = new FlatLightLaf();
-	 * laf.setExtraDefaults( Collections.singletonMap( "@accentColor", "#f00" ) );
+	 * laf.setExtraDefaults( Collections.singletonMap( "@background", "#fff" ) );
 	 * FlatLaf.setup( laf );
 	 * }</pre>
 	 *
@@ -943,6 +1122,122 @@ public abstract class FlatLaf
 		return val;
 	}
 
+	/**
+	 * Returns the system color getter function, or {@code null}.
+	 *
+	 * @since 3
+	 */
+	public static Function<String, Color> getSystemColorGetter() {
+		return systemColorGetter;
+	}
+
+	/**
+	 * Sets a system color getter function that is invoked when function
+	 * {@code systemColor()} is used in FlatLaf properties files.
+	 * <p>
+	 * The name of the system color is passed as parameter to the function.
+	 * The function should return {@code null} for unknown system colors.
+	 * <p>
+	 * Can be used to change the accent color:
+	 * <pre>{@code
+	 * FlatLaf.setSystemColorGetter( name -> {
+	 *     return name.equals( "accent" ) ? Color.red : null;
+	 * } );
+	 * FlatLightLaf.setup();
+	 * }</pre>
+	 *
+	 * @since 3
+	 */
+	public static void setSystemColorGetter( Function<String, Color> systemColorGetter ) {
+		FlatLaf.systemColorGetter = systemColorGetter;
+	}
+
+	/**
+	 * Returns UI key prefix, used in FlatLaf properties files, for light or dark themes.
+	 * Return value is either {@code [light]} or {@code [dark]}.
+	 *
+	 * @since 3.6
+	 */
+	public static String getUIKeyLightOrDarkPrefix( boolean dark ) {
+		return dark ? "[dark]" : "[light]";
+	}
+
+	/**
+	 * Returns set of UI key prefixes, used in FlatLaf properties files, for current platform.
+	 * If UI keys in properties files start with a prefix (e.g. {@code [someprefix]Button.background}),
+	 * then they are only used if that prefix is contained in this set
+	 * (or is one of {@code [light]} or {@code [dark]} depending on current theme).
+	 * <p>
+	 * By default, the set contains one or more of following prefixes:
+	 * <ul>
+	 *   <li>{@code [win]} on Windows
+	 *   <li>{@code [mac]} on macOS
+	 *   <li>{@code [linux]} on Linux
+	 *   <li>{@code [unknown]} on other platforms
+	 *   <li>{@code [gnome]} on Linux with GNOME desktop environment
+	 *   <li>{@code [kde]} on Linux with KDE desktop environment
+	 *   <li>on Linux, the value of the environment variable {@code XDG_CURRENT_DESKTOP},
+	 *       split at colons and converted to lower case (e.g. if value of  {@code XDG_CURRENT_DESKTOP}
+	 *       is {@code ubuntu:GNOME}, then {@code [ubuntu]} and {@code [gnome]})
+	 * </ul>
+	 * <p>
+	 * You can add own prefixes to the set.
+	 * The prefixes must start with '[' and end with ']' characters, otherwise they will be ignored.
+	 *
+	 * @since 3.6
+	 */
+	public static Set<String> getUIKeyPlatformPrefixes() {
+		if( uiKeyPlatformPrefixes == null ) {
+			uiKeyPlatformPrefixes = new HashSet<>();
+			uiKeyPlatformPrefixes.add(
+				SystemInfo.isWindows ? "[win]" :
+				SystemInfo.isMacOS ? "[mac]" :
+				SystemInfo.isLinux ? "[linux]" : "[unknown]" );
+
+			// Linux
+			if( SystemInfo.isLinux ) {
+				if( SystemInfo.isGNOME )
+					uiKeyPlatformPrefixes.add( "[gnome]" );
+				else if( SystemInfo.isKDE )
+					uiKeyPlatformPrefixes.add( "[kde]" );
+
+				// add values from XDG_CURRENT_DESKTOP for other desktops
+				String desktop = System.getenv( "XDG_CURRENT_DESKTOP" );
+				if( desktop != null ) {
+					// XDG_CURRENT_DESKTOP is a colon-separated list of strings
+					// https://specifications.freedesktop.org/desktop-entry-spec/latest/recognized-keys.html#key-onlyshowin
+					// e.g. "ubuntu:GNOME" on Ubuntu 24.10 or "GNOME-Classic:GNOME" on CentOS 7
+					for( String desk : StringUtils.split( desktop.toLowerCase( Locale.ENGLISH ), ':', true, true ) )
+						uiKeyPlatformPrefixes.add( '[' + desk + ']' );
+				}
+			}
+		}
+		return uiKeyPlatformPrefixes;
+	}
+
+	/**
+	 * Returns set of special UI key prefixes, used in FlatLaf properties files.
+	 * Unlike other prefixes, properties with special prefixes are preserved.
+	 * You can access them using `UIManager`. E.g. `UIManager.get( "[someSpecialPrefix]someKey" )`.
+	 * <p>
+	 * By default, the set contains following special prefixes:
+	 * <ul>
+	 *   <li>{@code [style]}
+	 * </ul>
+	 * <p>
+	 * You can add own prefixes to the set.
+	 * The prefixes must start with '[' and end with ']' characters, otherwise they will be ignored.
+	 *
+	 * @since 3.6
+	 */
+	public static Set<String> getUIKeySpecialPrefixes() {
+		if( uiKeySpecialPrefixes == null ) {
+			uiKeySpecialPrefixes = new HashSet<>();
+			uiKeySpecialPrefixes.add( "[style]" );
+		}
+		return uiKeySpecialPrefixes;
+	}
+
 	private static void reSetLookAndFeel() {
 		EventQueue.invokeLater( () -> {
 			LookAndFeel lookAndFeel = UIManager.getLookAndFeel();
@@ -950,7 +1245,7 @@ public abstract class FlatLaf
 				// re-set current LaF
 				UIManager.setLookAndFeel( lookAndFeel );
 
-				// must fire property change events ourself because old and new LaF are the same
+				// must fire property change events ourselves because old and new LaF are the same
 				PropertyChangeEvent e = new PropertyChangeEvent( UIManager.class, "lookAndFeel", lookAndFeel, lookAndFeel );
 				for( PropertyChangeListener l : UIManager.getPropertyChangeListeners() )
 					l.propertyChange( e );
@@ -994,7 +1289,7 @@ public abstract class FlatLaf
 	/**
 	 * Returns whether native window decorations are supported on current platform.
 	 * <p>
-	 * This requires Windows 10, but may be disabled if running in special environments
+	 * This requires Windows 10/11, but may be disabled if running in special environments
 	 * (JetBrains Projector, Webswing or WinPE) or if loading native library fails.
 	 * If system property {@link FlatSystemProperties#USE_WINDOW_DECORATIONS} is set to
 	 * {@code false}, then this method also returns {@code false}.
@@ -1036,12 +1331,23 @@ public abstract class FlatLaf
 
 	/**
 	 * Revalidate and repaint all displayable frames and dialogs.
+	 * <p>
+	 * Useful to update UI after changing {@code TitlePane.menuBarEmbedded}.
 	 *
 	 * @since 1.1.2
 	 */
 	public static void revalidateAndRepaintAllFramesAndDialogs() {
 		for( Window w : Window.getWindows() ) {
 			if( isDisplayableFrameOrDialog( w ) ) {
+				// revalidate menu bar
+				JMenuBar menuBar = (w instanceof JFrame)
+					? ((JFrame)w).getJMenuBar()
+					: (w instanceof JDialog
+						? ((JDialog)w).getJMenuBar()
+						: null);
+				if( menuBar != null )
+					menuBar.revalidate();
+
 				w.revalidate();
 				w.repaint();
 			}
@@ -1050,6 +1356,9 @@ public abstract class FlatLaf
 
 	/**
 	 * Repaint all displayable frames and dialogs.
+	 * <p>
+	 * Useful to update UI after changing {@code TitlePane.unifiedBackground},
+	 * {@code MenuItem.selectionType} or {@code Component.hideMnemonics}.
 	 *
 	 * @since 1.1.2
 	 */
@@ -1186,28 +1495,150 @@ public abstract class FlatLaf
 	 */
 	public static final Object NULL_VALUE = new Object();
 
+	/**
+	 * Returns information about styleable values of a component.
+	 * <p>
+	 * This is equivalent to: {@code ((StyleableUI)c.getUI()).getStyleableInfos(c)}
+	 *
+	 * @since 2.5
+	 */
+	public static Map<String, Class<?>> getStyleableInfos( JComponent c ) {
+		ComponentUI ui = JavaCompatibility2.getUI( c );
+		return (ui instanceof StyleableUI) ? ((StyleableUI)ui).getStyleableInfos( c ) : null;
+	}
+
+	/**
+	 * Returns the (styled) value for the given key from the given component.
+	 * <p>
+	 * This is equivalent to: {@code ((StyleableUI)c.getUI()).getStyleableValue(c, key)}
+	 *
+	 * @since 2.5
+	 */
+	@SuppressWarnings( "unchecked" )
+	public static <T> T getStyleableValue( JComponent c, String key ) {
+		ComponentUI ui = JavaCompatibility2.getUI( c );
+		return (ui instanceof StyleableUI) ? (T) ((StyleableUI)ui).getStyleableValue( c, key ) : null;
+	}
+
+	/**
+	 * Returns the preferred font family to be used for (nearly) all fonts; or {@code null}.
+	 *
+	 * @since 3
+	 */
+	public static String getPreferredFontFamily() {
+		return preferredFontFamily;
+	}
+
+	/**
+	 * Sets the preferred font family to be used for (nearly) all fonts.
+	 * <p>
+	 * <strong>Note</strong>: This must be invoked <strong>before</strong> setting
+	 * the application look and feel.
+	 *
+	 * @since 3
+	 */
+	public static void setPreferredFontFamily( String preferredFontFamily ) {
+		FlatLaf.preferredFontFamily = preferredFontFamily;
+	}
+
+	/**
+	 * Returns the preferred font family to be used for "light" fonts; or {@code null}.
+	 *
+	 * @since 3
+	 */
+	public static String getPreferredLightFontFamily() {
+		return preferredLightFontFamily;
+	}
+
+	/**
+	 * Sets the preferred font family to be used for "light" fonts.
+	 * <p>
+	 * <strong>Note</strong>: This must be invoked <strong>before</strong> setting
+	 * the application look and feel.
+	 *
+	 * @since 3
+	 */
+	public static void setPreferredLightFontFamily( String preferredLightFontFamily ) {
+		FlatLaf.preferredLightFontFamily = preferredLightFontFamily;
+	}
+
+	/**
+	 * Returns the preferred font family to be used for "semibold" fonts; or {@code null}.
+	 *
+	 * @since 3
+	 */
+	public static String getPreferredSemiboldFontFamily() {
+		return preferredSemiboldFontFamily;
+	}
+
+	/**
+	 * Sets the preferred font family to be used for "semibold" fonts.
+	 * <p>
+	 * <strong>Note</strong>: This must be invoked <strong>before</strong> setting
+	 * the application look and feel.
+	 *
+	 * @since 3
+	 */
+	public static void setPreferredSemiboldFontFamily( String preferredSemiboldFontFamily ) {
+		FlatLaf.preferredSemiboldFontFamily = preferredSemiboldFontFamily;
+	}
+
+	/**
+	 * Returns the preferred font family to be used for monospaced fonts; or {@code null}.
+	 *
+	 * @since 3
+	 */
+	public static String getPreferredMonospacedFontFamily() {
+		return preferredMonospacedFontFamily;
+	}
+
+	/**
+	 * Sets the preferred font family to be used for monospaced fonts.
+	 * <p>
+	 * <strong>Note</strong>: This must be invoked <strong>before</strong> setting
+	 * the application look and feel.
+	 *
+	 * @since 3
+	 */
+	public static void setPreferredMonospacedFontFamily( String preferredMonospacedFontFamily ) {
+		FlatLaf.preferredMonospacedFontFamily = preferredMonospacedFontFamily;
+	}
+
 	//---- class FlatUIDefaults -----------------------------------------------
 
 	private class FlatUIDefaults
 		extends UIDefaults
 	{
+		private UIDefaults metalDefaults;
+
 		FlatUIDefaults( int initialCapacity, float loadFactor ) {
 			super( initialCapacity, loadFactor );
 		}
 
 		@Override
 		public Object get( Object key ) {
-			Object value = getValue( key );
-			return (value != null) ? (value != NULL_VALUE ? value : null) : super.get( key );
+			return get( key, null );
 		}
 
 		@Override
 		public Object get( Object key, Locale l ) {
-			Object value = getValue( key );
-			return (value != null) ? (value != NULL_VALUE ? value : null) : super.get( key, l );
+			Object value = getFromUIDefaultsGetters( key );
+			if( value != null )
+				return (value != NULL_VALUE) ? value : null;
+
+			value = super.get( key, l );
+			if( value != null )
+				return value;
+
+			// get file chooser texts from Metal
+			return (key instanceof String && ((String)key).startsWith( "FileChooser." ))
+				? getFromMetal( (String) key, l )
+				: null;
 		}
 
-		private Object getValue( Object key ) {
+		private Object getFromUIDefaultsGetters( Object key ) {
+			// use local variable for getters to avoid potential multi-threading issues
+			List<Function<Object, Object>> uiDefaultsGetters = FlatLaf.this.uiDefaultsGetters;
 			if( uiDefaultsGetters == null )
 				return null;
 
@@ -1219,6 +1650,22 @@ public abstract class FlatLaf
 
 			return null;
 		}
+
+		private synchronized Object getFromMetal( String key, Locale l ) {
+			if( metalDefaults == null ) {
+				metalDefaults = new MetalLookAndFeel() {
+					// avoid unnecessary initialization
+					@Override protected void initClassDefaults( UIDefaults table ) {}
+					@Override protected void initSystemColorDefaults( UIDefaults table ) {}
+				}.getDefaults();
+
+				// empty not needed defaults (to save memory) because we're only interested
+				// in resource bundle strings, which are stored in another internal map
+				metalDefaults.clear();
+			}
+
+			return metalDefaults.get( key, l );
+		}
 	}
 
 	//---- class ActiveFont ---------------------------------------------------
@@ -1261,8 +1708,9 @@ public abstract class FlatLaf
 			this.scaleSize = scaleSize;
 		}
 
+		// using synchronized to avoid exception if invoked at the same time on multiple threads
 		@Override
-		public Object createValue( UIDefaults table ) {
+		public synchronized Object createValue( UIDefaults table ) {
 			if( inCreateValue )
 				throw new IllegalStateException( "FlatLaf: endless recursion in font" );
 
@@ -1300,7 +1748,7 @@ public abstract class FlatLaf
 			int newStyle = (style != -1)
 				? style
 				: (styleChange != 0)
-					? baseStyle & ~((styleChange >> 16) & 0xffff) | (styleChange & 0xffff)
+					? (baseStyle & ~((styleChange >> 16) & 0xffff)) | (styleChange & 0xffff)
 					: baseStyle;
 
 			// new size
@@ -1316,30 +1764,64 @@ public abstract class FlatLaf
 
 			// create font for family
 			if( families != null && !families.isEmpty() ) {
+				String preferredFamily = preferredFamily( families );
+				if( preferredFamily != null ) {
+					Font font = createCompositeFont( preferredFamily, newStyle, newSize );
+					if( !isFallbackFont( font ) || isDialogFamily( preferredFamily ) )
+						return toUIResource( font );
+				}
+
 				for( String family : families ) {
 					Font font = createCompositeFont( family, newStyle, newSize );
-					if( !isFallbackFont( font ) || family.equalsIgnoreCase( Font.DIALOG ) )
+					if( !isFallbackFont( font ) || isDialogFamily( family ) )
 						return toUIResource( font );
 				}
 			}
 
 			// derive font
-			if( newStyle != baseStyle || newSize != baseSize )
+			if( newStyle != baseStyle || newSize != baseSize ) {
+				// hack for font "Ubuntu Medium" on Linux, which curiously belongs
+				// to family "Ubuntu Light" and using deriveFont() would create a light font
+				if( "Ubuntu Medium".equalsIgnoreCase( baseFont.getName() ) &&
+					"Ubuntu Light".equalsIgnoreCase( baseFont.getFamily() ) )
+				{
+					Font font = createCompositeFont( "Ubuntu Medium", newStyle, newSize );
+					if( !isFallbackFont( font ) )
+						return toUIResource( font );
+				}
+
 				return toUIResource( baseFont.deriveFont( newStyle, newSize ) );
-			else
+			} else
 				return toUIResource( baseFont );
 		}
 
-		private FontUIResource toUIResource( Font font ) {
+		private static FontUIResource toUIResource( Font font ) {
 			// make sure that font is a UIResource for LaF switching
 			return (font instanceof FontUIResource)
 				? (FontUIResource) font
 				: new FontUIResource( font );
 		}
 
-		private boolean isFallbackFont( Font font ) {
+		private static boolean isFallbackFont( Font font ) {
 			return Font.DIALOG.equalsIgnoreCase( font.getFamily() );
 		}
+
+		private static boolean isDialogFamily( String family ) {
+			return family.equalsIgnoreCase( Font.DIALOG );
+		}
+
+		private static String preferredFamily( List<String> families ) {
+			for( String family : families ) {
+				family = family.toLowerCase( Locale.ENGLISH );
+				if( family.endsWith( " light" ) || family.endsWith( "-thin" ) )
+					return preferredLightFontFamily;
+				if( family.endsWith( " semibold" ) || family.endsWith( "-medium" ) )
+					return preferredSemiboldFontFamily;
+				if( family.equals( "monospaced" ) )
+					return preferredMonospacedFontFamily;
+			}
+			return null;
+		}
 	}
 
 	//---- class ImageIconUIResource ------------------------------------------

flatlaf-core/src/main/java/com/formdev/flatlaf/FlatLightLaf.java

@@ -33,6 +33,8 @@ public class FlatLightLaf
 	/**
 	 * Sets the application look and feel to this LaF
 	 * using {@link UIManager#setLookAndFeel(javax.swing.LookAndFeel)}.
+	 *
+	 * @since 1.2
 	 */
 	public static boolean setup() {
 		return setup( new FlatLightLaf() );

flatlaf-core/src/main/java/com/formdev/flatlaf/FlatPropertiesLaf.java

@@ -20,15 +20,21 @@ import java.io.File;
 import java.io.FileInputStream;
 import java.io.IOException;
 import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.Reader;
+import java.nio.charset.StandardCharsets;
 import java.util.ArrayList;
+import java.util.Locale;
 import java.util.Properties;
+import com.formdev.flatlaf.themes.FlatMacDarkLaf;
+import com.formdev.flatlaf.themes.FlatMacLightLaf;
 
 /**
  * A Flat LaF that is able to load UI defaults from properties passed to the constructor.
  * <p>
  * Specify the base theme in the properties with {@code @baseTheme=<baseTheme>}.
  * Allowed values for {@code <baseTheme>} are {@code light} (the default), {@code dark},
- * {@code intellij} or {@code darcula}.
+ * {@code intellij}, {@code darcula}, {@code maclight} or {@code macdark}.
  * <p>
  * The properties are applied after loading the base theme and may overwrite base properties.
  * All features of FlatLaf properties files are available.
@@ -59,8 +65,8 @@ public class FlatPropertiesLaf
 		throws IOException
 	{
 		Properties properties = new Properties();
-		try( InputStream in2 = in ) {
-			properties.load( in2 );
+		try( Reader reader = new InputStreamReader( in, StandardCharsets.UTF_8 )) {
+			properties.load( reader );
 		}
 		return properties;
 	}
@@ -70,7 +76,8 @@ public class FlatPropertiesLaf
 		this.properties = properties;
 
 		baseTheme = properties.getProperty( "@baseTheme", "light" );
-		dark = "dark".equalsIgnoreCase( baseTheme ) || "darcula".equalsIgnoreCase( baseTheme );
+		dark = "dark".equalsIgnoreCase( baseTheme ) || "darcula".equalsIgnoreCase( baseTheme ) ||
+			"macdark".equalsIgnoreCase( baseTheme );
 	}
 
 	@Override
@@ -96,7 +103,7 @@ public class FlatPropertiesLaf
 	protected ArrayList<Class<?>> getLafClassesForDefaultsLoading() {
 		ArrayList<Class<?>> lafClasses = new ArrayList<>();
 		lafClasses.add( FlatLaf.class );
-		switch( baseTheme.toLowerCase() ) {
+		switch( baseTheme.toLowerCase( Locale.ENGLISH ) ) {
 			default:
 			case "light":
 				lafClasses.add( FlatLightLaf.class );
@@ -115,6 +122,16 @@ public class FlatPropertiesLaf
 				lafClasses.add( FlatDarkLaf.class );
 				lafClasses.add( FlatDarculaLaf.class );
 				break;
+
+			case "maclight":
+				lafClasses.add( FlatLightLaf.class );
+				lafClasses.add( FlatMacLightLaf.class );
+				break;
+
+			case "macdark":
+				lafClasses.add( FlatDarkLaf.class );
+				lafClasses.add( FlatMacDarkLaf.class );
+				break;
 		}
 		return lafClasses;
 	}

flatlaf-core/src/main/java/com/formdev/flatlaf/FlatSystemProperties.java

@@ -16,6 +16,10 @@
 
 package com.formdev.flatlaf;
 
+import javax.swing.JFileChooser;
+import javax.swing.JPopupMenu;
+import javax.swing.SwingUtilities;
+import com.formdev.flatlaf.util.SystemFileChooser;
 import com.formdev.flatlaf.util.UIScale;
 
 /**
@@ -34,7 +38,7 @@ public interface FlatSystemProperties
 	 * To replace the Java 9+ system scale factor, use system property "sun.java2d.uiScale",
 	 * which has the same syntax as this one.
 	 * <p>
-	 * Since FlatLaf 1.1.2: Scale factors less then 100% are allowed.
+	 * Since FlatLaf 1.1.2: Scale factors less than 100% are allowed.
 	 * <p>
 	 * <strong>Allowed Values</strong> e.g. {@code 1.5}, {@code 1.5x}, {@code 150%} or {@code 144dpi} (96dpi is 100%)<br>
 	 */
@@ -81,7 +85,7 @@ public interface FlatSystemProperties
 	 * {@link FlatClientProperties#USE_WINDOW_DECORATIONS} and
 	 * UI default {@code TitlePane.useWindowDecorations}.
 	 * <p>
-	 * (requires Window 10)
+	 * (requires Windows 10/11)
 	 * <p>
 	 * <strong>Allowed Values</strong> {@code false} and {@code true}<br>
 	 * <strong>Default</strong> none
@@ -92,17 +96,20 @@ public interface FlatSystemProperties
 	 * Specifies whether JetBrains Runtime custom window decorations should be used
 	 * when creating {@code JFrame} or {@code JDialog}.
 	 * Requires that the application runs in a
-	 * <a href="https://confluence.jetbrains.com/display/JBR/JetBrains+Runtime">JetBrains Runtime</a>
+	 * <a href="https://github.com/JetBrains/JetBrainsRuntime/wiki">JetBrains Runtime</a>
 	 * (based on OpenJDK).
 	 * <p>
 	 * Setting this to {@code false} disables using JetBrains Runtime custom window decorations.
 	 * Then FlatLaf native window decorations are used.
 	 * <p>
-	 * (requires Window 10)
+	 * (requires Windows 10/11)
 	 * <p>
 	 * <strong>Allowed Values</strong> {@code false} and {@code true}<br>
-	 * <strong>Default</strong> {@code true}
+	 * <strong>Default</strong> {@code false} (since v2; was {@code true} in v1)
+	 *
+	 * @deprecated No longer used since FlatLaf 3.3. Retained for API compatibility.
 	 */
+	@Deprecated
 	String USE_JETBRAINS_CUSTOM_DECORATIONS = "flatlaf.useJetBrainsCustomDecorations";
 
 	/**
@@ -116,7 +123,7 @@ public interface FlatSystemProperties
 	 * {@link FlatClientProperties#MENU_BAR_EMBEDDED} and
 	 * UI default {@code TitlePane.menuBarEmbedded}.
 	 * <p>
-	 * (requires Window 10)
+	 * (requires Windows 10/11)
 	 * <p>
 	 * <strong>Allowed Values</strong> {@code false} and {@code true}<br>
 	 * <strong>Default</strong> none
@@ -131,6 +138,37 @@ public interface FlatSystemProperties
 	 */
 	String ANIMATION = "flatlaf.animation";
 
+	/**
+	 * Specifies whether native rounded popup borders should be used (if supported by operating system).
+	 * <p>
+	 * (requires Windows 11 or macOS)
+	 * <p>
+	 * <strong>Allowed Values</strong> {@code false} and {@code true}<br>
+	 * <strong>Default</strong> {@code true}; except in FlatLaf 3.5.x on macOS 14.4+ where it was {@code false}
+	 *
+	 * @since 3.5.2
+	 */
+	String USE_ROUNDED_POPUP_BORDER = "flatlaf.useRoundedPopupBorder";
+
+	/**
+	 * Species whether popup windows may be reused without (temporary) hiding them.
+	 * E.g. if "moving" a tooltip to follow the mouse pointer, normally it is necessary
+	 * to hide the tooltip and show it again at the new location, which causes some
+	 * flicker with heavy-weight popup windows that FlatLaf uses on all platforms.
+	 * <p>
+	 * If {@code true}, hiding popup window is deferred for an event cycle,
+	 * which allows reusing still visible popup window and avoids flicker when "moving" the popup.
+	 * <p>
+	 * Note that {@link JPopupMenu} popup windows (menus and combobox lists) are newer reused.
+	 * <p>
+	 * <strong>Allowed Values</strong> {@code false} and {@code true}<br>
+	 * <strong>Default</strong> {@code true}
+	 *
+	 * @since 3.6.2
+	 */
+	String REUSE_VISIBLE_POPUP_WINDOW = "flatlaf.reuseVisiblePopupWindow";
+
+
 	/**
 	 * Specifies whether vertical text position is corrected when UI is scaled on HiDPI screens.
 	 * <p>
@@ -139,6 +177,88 @@ public interface FlatSystemProperties
 	 */
 	String USE_TEXT_Y_CORRECTION = "flatlaf.useTextYCorrection";
 
+	/**
+	 * Specifies whether FlatLaf updates the UI when the system font changes.
+	 * If {@code true}, {@link SwingUtilities#updateComponentTreeUI(java.awt.Component)}
+	 * gets invoked for all windows if the system font has changed.
+	 * This is the similar to when switching to another look and feel (theme).
+	 * Applications that do not work correctly when switching look and feel,
+	 * should disable this option to avoid corrupted UI.
+	 * <p>
+	 * <strong>Allowed Values</strong> {@code false} and {@code true}<br>
+	 * <strong>Default</strong> {@code true}
+	 *
+	 * @since 2.5
+	 */
+	String UPDATE_UI_ON_SYSTEM_FONT_CHANGE = "flatlaf.updateUIOnSystemFontChange";
+
+	/**
+	 * Specifies whether FlatLaf native library should be used.
+	 * <p>
+	 * Setting this to {@code false} disables loading native library,
+	 * which also disables some features that depend on the native library.
+	 * <p>
+	 * <strong>Allowed Values</strong> {@code false} and {@code true}<br>
+	 * <strong>Default</strong> {@code true}
+	 *
+	 * @since 3.2
+	 */
+	String USE_NATIVE_LIBRARY = "flatlaf.useNativeLibrary";
+
+	/**
+	 * Specifies a directory in which the FlatLaf native libraries are searched for.
+	 * The path can be absolute or relative to current application working directory.
+	 * This can be used to avoid extraction of the native libraries to the temporary directory at runtime.
+	 * <p>
+	 * If the value is {@code "system"} (supported since FlatLaf 2.6),
+	 * then {@link System#loadLibrary(String)} is used to load the native library.
+	 * This searches for the native library in classloader of caller
+	 * (using {@link ClassLoader#findLibrary(String)}) and in paths specified
+	 * in system properties {@code sun.boot.library.path} and {@code java.library.path}.
+	 * <p>
+	 * If the native library can not be loaded from the given path (or via {@link System#loadLibrary(String)}),
+	 * then the embedded native library is extracted to the temporary directory and loaded from there.
+	 * <p>
+	 * The file names of the native libraries must be either:
+	 * <ul>
+	 *   <li>the same as in flatlaf.jar in package 'com/formdev/flatlaf/natives' (required for "system") or
+	 *   <li>when downloaded from Maven central then as described here:
+	 *     <a href="https://www.formdev.com/flatlaf/native-libraries/">https://www.formdev.com/flatlaf/native-libraries/</a>
+	 *     (requires FlatLaf 3.4)
+	 * </ul>
+	 * <p>
+	 * <strong>Note</strong>: Since FlatLaf 3.1 it is recommended to download the
+	 * FlatLaf native libraries from Maven central and distribute them with your
+	 * application in the same directory as flatlaf.jar.
+	 * Then it is <strong>not necessary</strong> to set this system property.
+	 * See <a href="https://www.formdev.com/flatlaf/native-libraries/">https://www.formdev.com/flatlaf/native-libraries/</a>
+	 * for details.
+	 *
+	 * @since 2
+	 */
+	String NATIVE_LIBRARY_PATH = "flatlaf.nativeLibraryPath";
+
+	/**
+	 * Specifies whether safe triangle is used to improve usability of submenus.
+	 * <p>
+	 * <strong>Allowed Values</strong> {@code false} and {@code true}<br>
+	 * <strong>Default</strong> {@code true}
+	 *
+	 * @since 3.5.1
+	 */
+	String USE_SUB_MENU_SAFE_TRIANGLE = "flatlaf.useSubMenuSafeTriangle";
+
+	/**
+	 * Specifies whether {@link SystemFileChooser} uses operating system file dialogs.
+	 * If set to {@code false}, the {@link JFileChooser} is used instead.
+	 * <p>
+	 * <strong>Allowed Values</strong> {@code false} and {@code true}<br>
+	 * <strong>Default</strong> {@code true}
+	 *
+	 * @since 3.7
+	 */
+	String USE_SYSTEM_FILE_CHOOSER = "flatlaf.useSystemFileChooser";
+
 	/**
 	 * Checks whether a system property is set and returns {@code true} if its value
 	 * is {@code "true"} (case-insensitive), otherwise it returns {@code false}.

flatlaf-core/src/main/java/com/formdev/flatlaf/IntelliJTheme.java

@@ -16,27 +16,27 @@
 
 package com.formdev.flatlaf;
 
-import java.awt.Color;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.InputStreamReader;
 import java.io.Reader;
 import java.nio.charset.StandardCharsets;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.Collections;
-import java.util.Enumeration;
 import java.util.HashMap;
 import java.util.HashSet;
+import java.util.Iterator;
+import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.Properties;
 import java.util.Set;
-import javax.swing.UIDefaults;
-import javax.swing.plaf.ColorUIResource;
 import com.formdev.flatlaf.json.Json;
 import com.formdev.flatlaf.json.ParseException;
-import com.formdev.flatlaf.util.ColorFunctions;
 import com.formdev.flatlaf.util.LoggingFacade;
 import com.formdev.flatlaf.util.StringUtils;
+import com.formdev.flatlaf.util.SystemInfo;
 
 /**
  * This class supports loading IntelliJ .theme.json files and using them as a Laf.
@@ -58,13 +58,11 @@ public class IntelliJTheme
 	public final boolean dark;
 	public final String author;
 
-	private final boolean isMaterialUILite;
+	private Map<String, String> jsonColors;
+	private Map<String, Object> jsonUI;
+	private Map<String, Object> jsonIcons;
 
-	private final Map<String, String> colors;
-	private final Map<String, Object> ui;
-	private final Map<String, Object> icons;
-
-	private Map<String, ColorUIResource> namedColors = Collections.emptyMap();
+	private Map<String, String> namedColors = Collections.emptyMap();
 
 	/**
 	 * Loads a IntelliJ .theme.json file from the given input stream,
@@ -72,12 +70,14 @@ public class IntelliJTheme
 	 *
 	 * The input stream is automatically closed.
 	 * Using a buffered input stream is not necessary.
+	 *
+	 * @since 1.2
 	 */
 	public static boolean setup( InputStream in ) {
 		try {
 		    return FlatLaf.setup( createLaf( in ) );
 		} catch( Exception ex ) {
-			LoggingFacade.INSTANCE.logSevere(  "FlatLaf: Failed to load IntelliJ theme", ex );
+			LoggingFacade.INSTANCE.logSevere( "FlatLaf: Failed to load IntelliJ theme", ex );
 		    return false;
 		}
 	}
@@ -131,164 +131,252 @@ public class IntelliJTheme
 	    dark = Boolean.parseBoolean( (String) json.get( "dark" ) );
 	    author = (String) json.get( "author" );
 
-		isMaterialUILite = author.equals( "Mallowigi" );
-
-	    colors = (Map<String, String>) json.get( "colors" );
-	    ui = (Map<String, Object>) json.get( "ui" );
-	    icons = (Map<String, Object>) json.get( "icons" );
+	    jsonColors = (Map<String, String>) json.get( "colors" );
+	    jsonUI = (Map<String, Object>) json.get( "ui" );
+	    jsonIcons = (Map<String, Object>) json.get( "icons" );
 	}
 
-	private void applyProperties( UIDefaults defaults ) {
-		if( ui == null )
+	private void applyProperties( Properties properties ) {
+		if( jsonUI == null )
 			return;
 
-		defaults.put( "Component.isIntelliJTheme", true );
+		put( properties, "Component.isIntelliJTheme", "true" );
 
 		// enable button shadows
-		defaults.put( "Button.paintShadow", true );
-		defaults.put( "Button.shadowWidth", dark ? 2 : 1 );
+		put( properties, "Button.paintShadow", "true" );
+		put( properties, "Button.shadowWidth", dark ? "2" : "1" );
 
-		Map<Object, Object> themeSpecificDefaults = removeThemeSpecificDefaults( defaults );
+		Map<String, String> themeSpecificProps = removeThemeSpecificProps( properties );
+		Set<String> jsonUIKeys = new HashSet<>();
 
-		loadNamedColors( defaults );
+		// Json node "colors"
+		loadNamedColors( properties, jsonUIKeys );
 
-		// convert Json "ui" structure to UI defaults
-		ArrayList<Object> defaultsKeysCache = new ArrayList<>();
-		Set<String> uiKeys = new HashSet<>();
-		for( Map.Entry<String, Object> e : ui.entrySet() )
-			apply( e.getKey(), e.getValue(), defaults, defaultsKeysCache, uiKeys );
+		// convert Json "ui" structure to UI properties
+		for( Map.Entry<String, Object> e : jsonUI.entrySet() )
+			apply( e.getKey(), e.getValue(), properties, jsonUIKeys );
 
-		applyColorPalette( defaults );
-		applyCheckBoxColors( defaults );
+		// set FlatLaf variables
+		copyIfSetInJson( properties, jsonUIKeys, "@background", "Panel.background", "*.background" );
+		copyIfSetInJson( properties, jsonUIKeys, "@foreground", "CheckBox.foreground", "*.foreground" );
+		copyIfSetInJson( properties, jsonUIKeys, "@accentBaseColor",
+			"ColorPalette.accent", // Material UI Lite, Hiberbee
+			"ColorPalette.accentColor", // Dracula, One Dark
+			"ProgressBar.foreground",
+			"*.selectionBackground" );
+		copyIfSetInJson( properties, jsonUIKeys, "@accentUnderlineColor", "*.underlineColor", "TabbedPane.underlineColor" );
+		copyIfSetInJson( properties, jsonUIKeys, "@selectionBackground", "*.selectionBackground" );
+		copyIfSetInJson( properties, jsonUIKeys, "@selectionForeground", "*.selectionForeground" );
+		copyIfSetInJson( properties, jsonUIKeys, "@selectionInactiveBackground", "*.selectionInactiveBackground" );
+		copyIfSetInJson( properties, jsonUIKeys, "@selectionInactiveForeground", "*.selectionInactiveForeground" );
+
+		// Json node "icons/ColorPalette"
+		applyIconsColorPalette( properties );
+
+		// apply "CheckBox.icon." colors
+		applyCheckBoxColors( properties );
 
 		// copy values
-		for( Map.Entry<String, String> e : uiKeyCopying.entrySet() )
-			defaults.put( e.getKey(), defaults.get( e.getValue() ) );
+		for( Map.Entry<String, String> e : uiKeyCopying.entrySet() ) {
+			Object value = properties.get( e.getValue() );
+			if( value != null )
+				put( properties, e.getKey(), value );
+		}
 
 		// IDEA does not paint button background if disabled, but FlatLaf does
-		Object panelBackground = defaults.get( "Panel.background" );
-		defaults.put( "Button.disabledBackground", panelBackground );
-		defaults.put( "ToggleButton.disabledBackground", panelBackground );
+		put( properties, "Button.disabledBackground", "@disabledBackground" );
+		put( properties, "ToggleButton.disabledBackground", "@disabledBackground" );
 
-		// fix Button borders
-		copyIfNotSet( defaults, "Button.focusedBorderColor", "Component.focusedBorderColor", uiKeys );
-		defaults.put( "Button.hoverBorderColor", defaults.get( "Button.focusedBorderColor" ) );
-		defaults.put( "HelpButton.hoverBorderColor", defaults.get( "Button.focusedBorderColor" ) );
-
-		// IDEA uses a SVG icon for the help button, but paints the background with Button.startBackground and Button.endBackground
-		Object helpButtonBackground = defaults.get( "Button.startBackground" );
-		Object helpButtonBorderColor = defaults.get( "Button.startBorderColor" );
-		if( helpButtonBackground == null )
-			helpButtonBackground = defaults.get( "Button.background" );
-		if( helpButtonBorderColor == null )
-			helpButtonBorderColor = defaults.get( "Button.borderColor" );
-		defaults.put( "HelpButton.background", helpButtonBackground );
-		defaults.put( "HelpButton.borderColor", helpButtonBorderColor );
-		defaults.put( "HelpButton.disabledBackground", panelBackground );
-		defaults.put( "HelpButton.disabledBorderColor", defaults.get( "Button.disabledBorderColor" ) );
-		defaults.put( "HelpButton.focusedBorderColor", defaults.get( "Button.focusedBorderColor" ) );
-		defaults.put( "HelpButton.focusedBackground", defaults.get( "Button.focusedBackground" ) );
+		// fix Button
+		fixStartEnd( properties, jsonUIKeys, "Button.startBackground", "Button.endBackground", "Button.background" );
+		fixStartEnd( properties, jsonUIKeys, "Button.startBorderColor", "Button.endBorderColor", "Button.borderColor" );
+		fixStartEnd( properties, jsonUIKeys, "Button.default.startBackground", "Button.default.endBackground", "Button.default.background" );
+		fixStartEnd( properties, jsonUIKeys, "Button.default.startBorderColor", "Button.default.endBorderColor", "Button.default.borderColor" );
 
 		// IDEA uses TextField.background for editable ComboBox and Spinner
-		defaults.put( "ComboBox.editableBackground", defaults.get( "TextField.background" ) );
-		defaults.put( "Spinner.background", defaults.get( "TextField.background" ) );
-
-		// Spinner arrow button always has same colors as ComboBox arrow button
-		defaults.put( "Spinner.buttonBackground", defaults.get( "ComboBox.buttonEditableBackground" ) );
-		defaults.put( "Spinner.buttonArrowColor", defaults.get( "ComboBox.buttonArrowColor" ) );
-		defaults.put( "Spinner.buttonDisabledArrowColor", defaults.get( "ComboBox.buttonDisabledArrowColor" ) );
+		Object textFieldBackground = get( properties, themeSpecificProps, "TextField.background" );
+		put( properties, "ComboBox.editableBackground", textFieldBackground );
+		put( properties, "Spinner.background", textFieldBackground );
 
 		// some themes specify colors for TextField.background, but forget to specify it for other components
-		// (probably because those components are not used in IntelliJ)
-		if( uiKeys.contains( "TextField.background" ) ) {
-			Object textFieldBackground = defaults.get( "TextField.background" );
-			if( !uiKeys.contains( "FormattedTextField.background" ) )
-				defaults.put( "FormattedTextField.background", textFieldBackground );
-			if( !uiKeys.contains( "PasswordField.background" ) )
-				defaults.put( "PasswordField.background", textFieldBackground );
-			if( !uiKeys.contains( "EditorPane.background" ) )
-				defaults.put( "EditorPane.background", textFieldBackground );
-			if( !uiKeys.contains( "TextArea.background" ) )
-				defaults.put( "TextArea.background", textFieldBackground );
-			if( !uiKeys.contains( "TextPane.background" ) )
-				defaults.put( "TextPane.background", textFieldBackground );
-			if( !uiKeys.contains( "Spinner.background" ) )
-				defaults.put( "Spinner.background", textFieldBackground );
-		}
+		// (probably because those components are not used in IntelliJ IDEA)
+		putAll( properties, textFieldBackground,
+			"EditorPane.background",
+			"FormattedTextField.background",
+			"PasswordField.background",
+			"TextArea.background",
+			"TextPane.background"
+		);
+		putAll( properties, get( properties, themeSpecificProps, "TextField.selectionBackground" ),
+			"EditorPane.selectionBackground",
+			"FormattedTextField.selectionBackground",
+			"PasswordField.selectionBackground",
+			"TextArea.selectionBackground",
+			"TextPane.selectionBackground"
+		);
+		putAll( properties, get( properties, themeSpecificProps, "TextField.selectionForeground" ),
+			"EditorPane.selectionForeground",
+			"FormattedTextField.selectionForeground",
+			"PasswordField.selectionForeground",
+			"TextArea.selectionForeground",
+			"TextPane.selectionForeground"
+		);
 
-		// fix ToggleButton
-		if( !uiKeys.contains( "ToggleButton.startBackground" ) && !uiKeys.contains( "*.startBackground" ) )
-			defaults.put( "ToggleButton.startBackground", defaults.get( "Button.startBackground" ) );
-		if( !uiKeys.contains( "ToggleButton.endBackground" ) && !uiKeys.contains( "*.endBackground" ) )
-			defaults.put( "ToggleButton.endBackground", defaults.get( "Button.endBackground" ) );
-		if( !uiKeys.contains( "ToggleButton.foreground" ) && uiKeys.contains( "Button.foreground" ) )
-			defaults.put( "ToggleButton.foreground", defaults.get( "Button.foreground" ) );
+		// fix disabled and not-editable backgrounds for text components, combobox and spinner
+		// (IntelliJ IDEA does not use those colors; instead it used background color of parent)
+		putAll( properties, "@disabledBackground",
+			"ComboBox.disabledBackground",
+			"EditorPane.disabledBackground", "EditorPane.inactiveBackground",
+			"FormattedTextField.disabledBackground", "FormattedTextField.inactiveBackground",
+			"PasswordField.disabledBackground", "PasswordField.inactiveBackground",
+			"Spinner.disabledBackground",
+			"TextArea.disabledBackground", "TextArea.inactiveBackground",
+			"TextField.disabledBackground", "TextField.inactiveBackground",
+			"TextPane.disabledBackground", "TextPane.inactiveBackground"
+		);
 
 		// fix DesktopPane background (use Panel.background and make it 5% darker/lighter)
-		Color desktopBackgroundBase = defaults.getColor( "Panel.background" );
-		Color desktopBackground = ColorFunctions.applyFunctions( desktopBackgroundBase,
-			new ColorFunctions.HSLIncreaseDecrease( 2, dark, 5, false, true ) );
-		defaults.put( "Desktop.background", new ColorUIResource( desktopBackground ) );
-
-		// fix List and Table background colors in Material UI Lite themes
-		if( isMaterialUILite ) {
-			defaults.put( "List.background", defaults.get( "Tree.background" ) );
-			defaults.put( "Table.background", defaults.get( "Tree.background" ) );
-		}
+		put( properties, "Desktop.background", dark ? "lighten($Panel.background,5%)" : "darken($Panel.background,5%)" );
 
 		// limit tree row height
-		int rowHeight = defaults.getInt( "Tree.rowHeight" );
+		String rowHeightStr = (String) properties.get( "Tree.rowHeight" );
+		int rowHeight = (rowHeightStr != null) ? Integer.parseInt( rowHeightStr ) : 0;
 		if( rowHeight > 22 )
-			defaults.put( "Tree.rowHeight", 22 );
+			put( properties, "Tree.rowHeight", "22" );
 
-		// apply theme specific UI defaults at the end to allow overwriting
-		defaults.putAll( themeSpecificDefaults );
+		// get (and remove) theme specific wildcard replacements, which override all other properties that end with same suffix
+		HashMap<String, String> wildcardProps = new HashMap<>();
+		Iterator<Map.Entry<String, String>> it = themeSpecificProps.entrySet().iterator();
+		while( it.hasNext() ) {
+			Map.Entry<String, String> e = it.next();
+			String key = e.getKey();
+			if( key.startsWith( "*." ) ) {
+				wildcardProps.put( key, e.getValue() );
+				it.remove();
+			}
+		}
+
+		// override properties with theme specific wildcard replacements
+		if( !wildcardProps.isEmpty() ) {
+			for( Map.Entry<String, String> e : wildcardProps.entrySet() )
+				applyWildcard( properties, e.getKey(), e.getValue() );
+		}
+
+		// apply theme specific properties at the end to allow overwriting
+		for( Map.Entry<String, String> e : themeSpecificProps.entrySet() ) {
+			String key = e.getKey();
+			String value = e.getValue();
+
+			// append styles to existing styles
+			if( key.startsWith( "[style]" ) ) {
+				String oldValue = (String) properties.get( key );
+				if( oldValue != null )
+					value = oldValue + "; " + value;
+			}
+
+			put( properties, key, value );
+		}
+
+		// let Java release memory
+		jsonColors = null;
+		jsonUI = null;
+		jsonIcons = null;
 	}
 
-	private Map<Object, Object> removeThemeSpecificDefaults( UIDefaults defaults ) {
-		// search for theme specific UI defaults keys
+	private String get( Properties properties, Map<String, String> themeSpecificProps, String key ) {
+		return themeSpecificProps.getOrDefault( key, (String) properties.get( key ) );
+	}
+
+	private void put( Properties properties, Object key, Object value ) {
+		if( value != null )
+			properties.put( key, value );
+		else
+			properties.remove( key );
+	}
+
+	private void putAll( Properties properties, Object value, String... keys ) {
+		for( String key : keys )
+			put( properties, key, value );
+	}
+
+	private void copyIfSetInJson( Properties properties, Set<String> jsonUIKeys, String destKey, String... srcKeys ) {
+		for( String srcKey : srcKeys ) {
+			if( jsonUIKeys.contains( srcKey ) ) {
+				Object value = properties.get( srcKey );
+				if( value != null ) {
+					put( properties, destKey, value );
+					break;
+				}
+			}
+		}
+	}
+
+	private void fixStartEnd( Properties properties, Set<String> jsonUIKeys, String startKey, String endKey, String key ) {
+		if( jsonUIKeys.contains( startKey ) && jsonUIKeys.contains( endKey ) )
+			put( properties, key, "$" + startKey );
+	}
+
+	private Map<String, String> removeThemeSpecificProps( Properties properties ) {
+		// search for theme specific properties keys
 		ArrayList<String> themeSpecificKeys = new ArrayList<>();
-		for( Object key : defaults.keySet() ) {
-			if( key instanceof String && ((String)key).startsWith( "[" ) && !((String)key).startsWith( "[style]" ) )
+		for( Object key : properties.keySet() ) {
+			if( ((String)key).startsWith( "{" ) )
 				themeSpecificKeys.add( (String) key );
 		}
 
-		// remove theme specific UI defaults and remember only those for current theme
-		Map<Object, Object> themeSpecificDefaults = new HashMap<>();
-		String currentThemePrefix = '[' + name.replace( ' ', '_' ) + ']';
-		String currentThemeAndAuthorPrefix = '[' + name.replace( ' ', '_' ) + "---" + author.replace( ' ', '_' ) + ']';
-		String currentAuthorPrefix = "[author-" + author.replace( ' ', '_' ) + ']';
-		String allThemesPrefix = "[*]";
-		String[] prefixes = { currentThemePrefix, currentThemeAndAuthorPrefix, currentAuthorPrefix, allThemesPrefix };
+		// special prefixes (priority from highest to lowest)
+		String currentThemePrefix = '{' + name.replace( ' ', '_' ) + '}';
+		String currentThemeAndAuthorPrefix = '{' + name.replace( ' ', '_' ) + "---" + author.replace( ' ', '_' ) + '}';
+		String currentAuthorPrefix = "{author-" + author.replace( ' ', '_' ) + '}';
+		String lightOrDarkPrefix = dark ? "{*-dark}" : "{*-light}";
+		String allThemesPrefix = "{*}";
+		String[] prefixes = { currentThemePrefix, currentThemeAndAuthorPrefix, currentAuthorPrefix, lightOrDarkPrefix, allThemesPrefix };
+
+		// collect values for special prefixes in its own maps
+		@SuppressWarnings( "unchecked" )
+		Map<String, String>[] maps = new Map[prefixes.length];
+		for( int i = 0; i < maps.length; i++ )
+			maps[i] = new HashMap<>();
+
+		// remove theme specific properties and remember only those for current theme
 		for( String key : themeSpecificKeys ) {
-			Object value = defaults.remove( key );
-			for( String prefix : prefixes ) {
+			String value = (String) properties.remove( key );
+			for( int i = 0; i < prefixes.length; i++ ) {
+				String prefix = prefixes[i];
 				if( key.startsWith( prefix ) ) {
-					themeSpecificDefaults.put( key.substring( prefix.length() ), value );
+					maps[i].put( key.substring( prefix.length() ), value );
 					break;
 				}
 			}
 		}
 
-		return themeSpecificDefaults;
+		// copy values into single map (from lowest to highest priority)
+		Map<String, String> themeSpecificProps = new HashMap<>();
+		for( int i = maps.length - 1; i >= 0; i-- )
+			themeSpecificProps.putAll( maps[i] );
+		return themeSpecificProps;
 	}
 
 	/**
 	 * http://www.jetbrains.org/intellij/sdk/docs/reference_guide/ui_themes/themes_customize.html#defining-named-colors
 	 */
-	private void loadNamedColors( UIDefaults defaults ) {
-		if( colors == null )
+	private void loadNamedColors( Properties properties, Set<String> jsonUIKeys ) {
+		if( jsonColors == null )
 			return;
 
 		namedColors = new HashMap<>();
 
-		for( Map.Entry<String, String> e : colors.entrySet() ) {
+		for( Map.Entry<String, String> e : jsonColors.entrySet() ) {
 			String value = e.getValue();
-			ColorUIResource color = UIDefaultsLoader.parseColor( value );
-			if( color != null ) {
+			if( canParseColor( value ) ) {
 				String key = e.getKey();
-				namedColors.put( key, color );
-				defaults.put( "ColorPalette." + key, color );
+				namedColors.put( key, value );
+
+				String uiKey = "ColorPalette." + key;
+				put( properties, uiKey, value );
+
+				// this is only necessary for copyIfSetInJson() (used for accent color)
+				jsonUIKeys.add( uiKey );
 			}
 		}
 	}
@@ -297,18 +385,36 @@ public class IntelliJTheme
 	 * http://www.jetbrains.org/intellij/sdk/docs/reference_guide/ui_themes/themes_customize.html#custom-ui-control-colors
 	 */
 	@SuppressWarnings( "unchecked" )
-	private void apply( String key, Object value, UIDefaults defaults, ArrayList<Object> defaultsKeysCache, Set<String> uiKeys ) {
+	private void apply( String key, Object value, Properties properties, Set<String> jsonUIKeys ) {
 		if( value instanceof Map ) {
-			for( Map.Entry<String, Object> e : ((Map<String, Object>)value).entrySet() )
-				apply( key + '.' + e.getKey(), e.getValue(), defaults, defaultsKeysCache, uiKeys );
+			Map<String, Object> map = (Map<String, Object>)value;
+			if( map.containsKey( "os.default" ) || map.containsKey( "os.windows" ) || map.containsKey( "os.mac" ) || map.containsKey( "os.linux" ) ) {
+				String osKey = SystemInfo.isWindows ? "os.windows"
+					: SystemInfo.isMacOS ? "os.mac"
+					: SystemInfo.isLinux ? "os.linux" : null;
+				if( osKey != null && map.containsKey( osKey ) )
+					apply( key, map.get( osKey ), properties, jsonUIKeys );
+				else if( map.containsKey( "os.default" ) )
+					apply( key, map.get( "os.default" ), properties, jsonUIKeys );
+			} else {
+				for( Map.Entry<String, Object> e : map.entrySet() )
+					apply( key + '.' + e.getKey(), e.getValue(), properties, jsonUIKeys );
+			}
 		} else {
 			if( "".equals( value ) )
 				return; // ignore empty value
 
-			uiKeys.add( key );
+			// ignore some properties that affect sizes
+			if( key.endsWith( ".border" ) ||
+				key.endsWith( ".rowHeight" ) ||
+				key.equals( "ComboBox.padding" ) ||
+				key.equals( "Spinner.padding" ) ||
+				key.equals( "Tree.leftChildIndent" ) ||
+				key.equals( "Tree.rightChildIndent" ) )
+			  return; // ignore
 
-			// fix ComboBox size and Spinner border in all Material UI Lite themes
-			if( isMaterialUILite && (key.equals( "ComboBox.padding" ) || key.equals( "Spinner.border" )) )
+			// ignore icons
+			if( key.endsWith( "Icon" ) )
 				return; // ignore
 
 			// map keys
@@ -316,10 +422,31 @@ public class IntelliJTheme
 			if( key.isEmpty() )
 				return; // ignore key
 
-			String valueStr = value.toString();
+			// exclude properties (1st level)
+			int dot = key.indexOf( '.' );
+			if( dot > 0 && uiKeyExcludesStartsWith.contains( key.substring( 0, dot + 1 ) ) )
+				return;
+
+			// exclude properties (2st level)
+			int dot2 = (dot > 0) ? key.indexOf( '.', dot + 1 ) : -1;
+			if( dot2 > 0 && uiKeyExcludesStartsWith.contains( key.substring( 0, dot2 + 1 ) ) )
+				return;
+
+			// exclude properties (contains)
+			for( String s : uiKeyExcludesContains ) {
+				if( key.contains( s ) )
+					return;
+			}
+
+			if( uiKeyDoNotOverride.contains( key ) && jsonUIKeys.contains( key ) )
+				return;
+
+			jsonUIKeys.add( key );
+
+			String valueStr = value.toString().trim();
 
 			// map named colors
-			Object uiValue = namedColors.get( valueStr );
+			String uiValue = namedColors.get( valueStr );
 
 			// parse value
 			if( uiValue == null ) {
@@ -338,46 +465,64 @@ public class IntelliJTheme
 
 				// parse value
 				try {
-					uiValue = UIDefaultsLoader.parseValue( key, valueStr, null );
+					UIDefaultsLoader.parseValue( key, valueStr, null );
+					uiValue = valueStr;
 				} catch( RuntimeException ex ) {
-					UIDefaultsLoader.logParseError( key, valueStr, ex, false );
+					UIDefaultsLoader.logParseError( key, valueStr, ex, true );
 					return; // ignore invalid value
 				}
 			}
 
-			if( key.startsWith( "*." ) ) {
-				// wildcard
-				String tail = key.substring( 1 );
+			// wildcards
+			if( applyWildcard( properties, key, uiValue ) )
+				return;
 
-				// because we can not iterate over the UI defaults keys while
-				// modifying UI defaults in the same loop, we have to copy the keys
-				if( defaultsKeysCache.size() != defaults.size() ) {
-					defaultsKeysCache.clear();
-					Enumeration<Object> e = defaults.keys();
-					while( e.hasMoreElements() )
-						defaultsKeysCache.add( e.nextElement() );
-				}
-
-				// replace all values in UI defaults that match the wildcard key
-				for( Object k : defaultsKeysCache ) {
-					if( k.equals( "Desktop.background" ) ||
-						k.equals( "DesktopIcon.background" ) )
-					  continue;
-
-					if( k instanceof String ) {
-						// support replacing of mapped keys
-						// (e.g. set ComboBox.buttonEditableBackground to *.background
-						// because it is mapped from ComboBox.ArrowButton.background)
-						String km = uiKeyInverseMapping.getOrDefault( k, (String) k );
-						if( km.endsWith( tail ) && !((String)k).startsWith( "CheckBox.icon." ) )
-							defaults.put( k, uiValue );
-					}
-				}
-			} else
-				defaults.put( key, uiValue );
+			put( properties, key, uiValue );
 		}
 	}
 
+	private boolean applyWildcard( Properties properties, String key, String value ) {
+		if( !key.startsWith( "*." ) )
+			return false;
+
+		String tail = key.substring( 1 );
+
+		// because we can not iterate over the properties keys while
+		// modifying properties in the same loop, we have to copy the keys
+		String[] keys = properties.keySet().toArray( new String[properties.size()] );
+
+		// replace all values in properties that match the wildcard key
+		for( String k : keys ) {
+			if( k.startsWith( "*" ) ||
+				k.startsWith( "@" ) ||
+				k.startsWith( "HelpButton." ) ||
+				k.startsWith( "JX" ) ||
+				k.startsWith( "Jide" ) ||
+				k.startsWith( "ProgressBar.selection" ) ||
+				k.startsWith( "TitlePane." ) ||
+				k.startsWith( "ToggleButton.tab." ) ||
+				k.equals( "Desktop.background" ) ||
+				k.equals( "DesktopIcon.background" ) ||
+				k.equals( "TabbedPane.focusColor" ) ||
+				k.endsWith( ".hoverBackground" ) ||
+				k.endsWith( ".pressedBackground" ) )
+			  continue;
+
+			// support replacing of mapped keys
+			// (e.g. set ComboBox.buttonEditableBackground to *.background
+			// because it is mapped from ComboBox.ArrowButton.background)
+			String km = uiKeyInverseMapping.getOrDefault( k, k );
+			if( km.endsWith( tail ) && !k.startsWith( "CheckBox.icon." ) )
+				put( properties, k, value );
+		}
+
+		// Note: also add wildcards to properties and let UIDefaultsLoader
+		//       process it on BasicLookAndFeel UI defaults
+		put( properties, key, value );
+
+		return true;
+	}
+
 	private String fixColorIfValid( String newColorStr, String colorStr ) {
 		try {
 			// check whether it is valid
@@ -389,11 +534,11 @@ public class IntelliJTheme
 		}
 	}
 
-	private void applyColorPalette( UIDefaults defaults ) {
-		if( icons == null )
+	private void applyIconsColorPalette( Properties properties ) {
+		if( jsonIcons == null )
 			return;
 
-		Object palette = icons.get( "ColorPalette" );
+		Object palette = jsonIcons.get( "ColorPalette" );
 		if( !(palette instanceof Map) )
 			return;
 
@@ -402,36 +547,48 @@ public class IntelliJTheme
 		for( Map.Entry<String, Object> e : colorPalette.entrySet() ) {
 			String key = e.getKey();
 			Object value = e.getValue();
-			if( key.startsWith( "Checkbox." ) || !(value instanceof String) )
+			if( key.startsWith( "Checkbox." ) || key.startsWith( "#" ) || !(value instanceof String) )
 				continue;
 
 			if( dark )
 				key = StringUtils.removeTrailing( key, ".Dark" );
 
-			ColorUIResource color = toColor( (String) value );
+			String color = toColor( (String) value );
 			if( color != null )
-				defaults.put( key, color );
+				put( properties, key, color );
 		}
 	}
 
-	private ColorUIResource toColor( String value ) {
+	private String toColor( String value ) {
+		if( value.startsWith( "##" ) )
+			value = fixColorIfValid( value.substring( 1 ), value );
+
 		// map named colors
-		ColorUIResource color = namedColors.get( value );
+		String color = namedColors.get( value );
 
 		// parse color
-		return (color != null) ? color : UIDefaultsLoader.parseColor( value );
+		return (color != null) ? color : (canParseColor( value ) ? value : null);
+	}
+
+	private boolean canParseColor( String value ) {
+		try {
+			return UIDefaultsLoader.parseColor( value ) != null;
+		} catch( IllegalArgumentException ex ) {
+			LoggingFacade.INSTANCE.logSevere( "FlatLaf: Failed to parse color: '" + value + '\'', ex );
+			return false;
+		}
 	}
 
 	/**
 	 * Because IDEA uses SVGs for check boxes and radio buttons, the colors for
-	 * this two components are specified in "icons > ColorPalette".
-	 * FlatLaf uses vector icons and expects colors for the two components in UI defaults.
+	 * these two components are specified in "icons > ColorPalette".
+	 * FlatLaf uses vector icons and expects colors for the two components in properties.
 	 */
-	private void applyCheckBoxColors( UIDefaults defaults ) {
-		if( icons == null )
+	private void applyCheckBoxColors( Properties properties ) {
+		if( jsonIcons == null )
 			return;
 
-		Object palette = icons.get( "ColorPalette" );
+		Object palette = jsonIcons.get( "ColorPalette" );
 		if( !(palette instanceof Map) )
 			return;
 
@@ -444,18 +601,6 @@ public class IntelliJTheme
 			if( !key.startsWith( "Checkbox." ) || !(value instanceof String) )
 				continue;
 
-			if( key.equals( "Checkbox.Background.Default" ) ||
-				key.equals( "Checkbox.Foreground.Selected" ) )
-			{
-				// This two keys do not work correctly in IDEA because they
-				// map SVG color "#ffffff" to another color, but checkBox.svg and
-				// radio.svg (in package com.intellij.ide.ui.laf.icons.intellij)
-				// use "#fff". So use white to get same appearance as in IDEA.
-				value = "#ffffff";
-			}
-
-			String key2 = checkboxDuplicateColors.get( key );
-
 			if( dark )
 				key = StringUtils.removeTrailing( key, ".Dark" );
 
@@ -465,10 +610,11 @@ public class IntelliJTheme
 				if( !dark && newKey.startsWith( checkBoxIconPrefix ) )
 					newKey = "CheckBox.icon[filled].".concat( newKey.substring( checkBoxIconPrefix.length() ) );
 
-				ColorUIResource color = toColor( (String) value );
+				String color = toColor( (String) value );
 				if( color != null ) {
-					defaults.put( newKey, color );
+					put( properties, newKey, color );
 
+					String key2 = checkboxDuplicateColors.get( key + ".Dark");
 					if( key2 != null ) {
 						// When IDEA replaces colors in SVGs it uses color values and not the keys
 						// from com.intellij.ide.ui.UITheme.colorPalette, but there are some keys that
@@ -487,7 +633,7 @@ public class IntelliJTheme
 
 						String newKey2 = checkboxKeyMapping.get( key2 );
 						if( newKey2 != null )
-							defaults.put( newKey2, color );
+							put( properties, newKey2, color );
 					}
 				}
 
@@ -498,65 +644,118 @@ public class IntelliJTheme
 		// update hover, pressed and focused colors
 		if( checkboxModified ) {
 			// for non-filled checkbox/radiobutton used in dark themes
-			defaults.remove( "CheckBox.icon.focusWidth" );
-			defaults.put( "CheckBox.icon.hoverBorderColor", defaults.get( "CheckBox.icon.focusedBorderColor" ) );
+			properties.remove( "CheckBox.icon.focusWidth" );
+			put( properties, "CheckBox.icon.hoverBorderColor", properties.get( "CheckBox.icon.focusedBorderColor" ) );
 
 			// for filled checkbox/radiobutton used in light themes
-			defaults.remove( "CheckBox.icon[filled].focusWidth" );
-			defaults.put( "CheckBox.icon[filled].hoverBorderColor", defaults.get( "CheckBox.icon[filled].focusedBorderColor" ) );
-			defaults.put( "CheckBox.icon[filled].focusedSelectedBackground", defaults.get( "CheckBox.icon[filled].selectedBackground" ) );
+			properties.remove( "CheckBox.icon[filled].focusWidth" );
+			put( properties, "CheckBox.icon[filled].hoverBorderColor", properties.get( "CheckBox.icon[filled].focusedBorderColor" ) );
+			put( properties, "CheckBox.icon[filled].focusedSelectedBackground", properties.get( "CheckBox.icon[filled].selectedBackground" ) );
 
 			if( dark ) {
 				// IDEA Darcula checkBoxFocused.svg, checkBoxSelectedFocused.svg,
 				// radioFocused.svg and radioSelectedFocused.svg
 				// use opacity=".65" for the border
 				// --> add alpha to focused border colors
-				String[] focusedBorderColorKeys = new String[] {
+				String[] focusedBorderColorKeys = {
 					"CheckBox.icon.focusedBorderColor",
 					"CheckBox.icon.focusedSelectedBorderColor",
 					"CheckBox.icon[filled].focusedBorderColor",
 					"CheckBox.icon[filled].focusedSelectedBorderColor",
 				};
 				for( String key : focusedBorderColorKeys ) {
-					Color color = defaults.getColor( key );
-					if( color != null ) {
-						defaults.put( key, new ColorUIResource( new Color(
-							(color.getRGB() & 0xffffff) | 0xa6000000, true ) ) );
-					}
+					Object color = properties.get( key );
+					if( color != null )
+						put( properties, key, "fade(" + color + ", 65%)" );
 				}
 			}
 		}
 	}
 
-	private void copyIfNotSet( UIDefaults defaults, String destKey, String srcKey, Set<String> uiKeys ) {
-		if( !uiKeys.contains( destKey ) )
-			defaults.put( destKey, defaults.get( srcKey ) );
-	}
-
+	private static final Set<String> uiKeyExcludesStartsWith;
+	private static final String[] uiKeyExcludesContains;
+	private static final Set<String> uiKeyDoNotOverride;
 	/** Rename UI default keys (key --> value). */
-	private static Map<String, String> uiKeyMapping = new HashMap<>();
+	private static final Map<String, String> uiKeyMapping = new HashMap<>();
 	/** Copy UI default keys (value --> key). */
-	private static Map<String, String> uiKeyCopying = new HashMap<>();
-	private static Map<String, String> uiKeyInverseMapping = new HashMap<>();
-	private static Map<String, String> checkboxKeyMapping = new HashMap<>();
-	private static Map<String, String> checkboxDuplicateColors = new HashMap<>();
+	private static final Map<String, String> uiKeyCopying = new LinkedHashMap<>();
+	private static final Map<String, String> uiKeyInverseMapping = new HashMap<>();
+	private static final Map<String, String> checkboxKeyMapping = new HashMap<>();
+	private static final Map<String, String> checkboxDuplicateColors = new HashMap<>();
 
 	static {
+		// IntelliJ UI properties that are not used in FlatLaf
+		uiKeyExcludesStartsWith = new HashSet<>( Arrays.asList(
+			"ActionButton.", "ActionToolbar.", "ActionsList.", "AppInspector.", "AssignedMnemonic.", "Autocomplete.",
+			"AvailableMnemonic.",
+			"Badge.", "Banner.", "BigSpinner.", "Bookmark.", "BookmarkIcon.", "BookmarkMnemonicAssigned.", "BookmarkMnemonicAvailable.",
+			"BookmarkMnemonicCurrent.", "BookmarkMnemonicIcon.", "Borders.", "Breakpoint.",
+			"Canvas.", "CellEditor.", "Code.", "CodeWithMe.", "ColumnControlButton.", "CombinedDiff.", "ComboBoxButton.",
+			"CompilationCharts.", "CompletionPopup.", "ComplexPopup.", "Content.", "ContextHelp.", "CurrentMnemonic.", "Counter.",
+			"Debugger.", "DebuggerPopup.", "DebuggerTabs.", "DefaultTabs.", "Dialog.", "DialogWrapper.",
+			"DisclosureButton.", "DragAndDrop.",
+			"Editor.", "EditorGroupsTabs.", "EditorTabs.",
+			"FileColor.", "FindPopup.", "FlameGraph.", "Focus.",
+			"Git.", "Github.", "GotItTooltip.", "Group.", "Gutter.", "GutterTooltip.",
+			"HeaderColor.", "HelpTooltip.", "Hg.",
+			"IconBadge.", "InformationHint.", "InlineBanner.", "InplaceRefactoringPopup.",
+			"Lesson.", "LineProfiler.", "Link.", "LiveIndicator.",
+			"MainMenu.", "MainToolbar.", "MainWindow.", "MemoryIndicator.", "MlModelBinding.", "MnemonicIcon.",
+			"NavBar.", "NewClass.", "NewPSD.", "Notification.", "Notifications.", "NotificationsToolwindow.",
+			"OnePixelDivider.", "OptionButton.", "Outline.",
+			"ParameterInfo.", "PresentationAssistant.", "Plugins.", "Profiler.", "ProgressIcon.", "PsiViewer.",
+			"Resizable.", "Review.", "ReviewList.", "RunToolbar.", "RunWidget.",
+			"ScreenView.", "SearchEverywhere.", "SearchFieldWithExtension.", "SearchMatch.", "SearchOption.",
+			"SearchResults.", "SegmentedButton.", "Settings.", "SidePanel.", "Space.", "SpeedSearch.", "StateWidget.",
+			"StatusBar.", "StripeToolbar.",
+			"Tag.", "TipOfTheDay.", "ToolbarComboWidget.", "ToolWindow.", "TrialWidget.",
+			"UIDesigner.", "UnattendedHostStatus.",
+			"ValidationTooltip.", "VersionControl.",
+			"WelcomeScreen.",
+
+			// lower case
+			"darcula.", "dropArea.", "icons.", "intellijlaf.", "macOSWindow.", "material.", "tooltips.",
+
+			// possible typos in .theme.json files
+			"Checkbox.", "Toolbar.", "Tooltip.", "UiDesigner.", "link."
+		) );
+		uiKeyExcludesContains = new String[] {
+			".darcula."
+		};
+
+		uiKeyDoNotOverride = new HashSet<>( Arrays.asList(
+			"TabbedPane.selectedForeground"
+		) );
+
+		// "*."
+		uiKeyMapping.put( "*.fontFace", "" ); // ignore (used in OnePauintxi themes)
+		uiKeyMapping.put( "*.fontSize", "" ); // ignore (used in OnePauintxi themes)
+
+		// Button
+		uiKeyMapping.put( "Button.minimumSize", "" ); // ignore (used in Material Theme UI Lite)
+
+		// CheckBox.iconSize
+		uiKeyMapping.put( "CheckBox.iconSize", "" ); // ignore (used in Rider themes)
+
 		// ComboBox
 		uiKeyMapping.put( "ComboBox.background",                        "" ); // ignore
+		uiKeyMapping.put( "ComboBox.buttonBackground",                  "" ); // ignore
 		uiKeyMapping.put( "ComboBox.nonEditableBackground",             "ComboBox.background" );
 		uiKeyMapping.put( "ComboBox.ArrowButton.background",            "ComboBox.buttonEditableBackground" );
 		uiKeyMapping.put( "ComboBox.ArrowButton.disabledIconColor",     "ComboBox.buttonDisabledArrowColor" );
 		uiKeyMapping.put( "ComboBox.ArrowButton.iconColor",             "ComboBox.buttonArrowColor" );
 		uiKeyMapping.put( "ComboBox.ArrowButton.nonEditableBackground", "ComboBox.buttonBackground" );
-		uiKeyCopying.put( "ComboBox.buttonSeparatorColor",              "Component.borderColor" );
-		uiKeyCopying.put( "ComboBox.buttonDisabledSeparatorColor",      "Component.disabledBorderColor" );
 
 		// Component
 		uiKeyMapping.put( "Component.inactiveErrorFocusColor",   "Component.error.borderColor" );
 		uiKeyMapping.put( "Component.errorFocusColor",           "Component.error.focusedBorderColor" );
 		uiKeyMapping.put( "Component.inactiveWarningFocusColor", "Component.warning.borderColor" );
 		uiKeyMapping.put( "Component.warningFocusColor",         "Component.warning.focusedBorderColor" );
+		uiKeyMapping.put( "Component.inactiveSuccessFocusColor", "Component.success.borderColor" );
+		uiKeyMapping.put( "Component.successFocusColor",         "Component.success.focusedBorderColor" );
+
+		// Label
+		uiKeyMapping.put( "Label.disabledForegroundColor", "" ); // ignore (used in Material Theme UI Lite)
 
 		// Link
 		uiKeyMapping.put( "Link.activeForeground", "Component.linkColor" );
@@ -564,10 +763,7 @@ public class IntelliJTheme
 		// Menu
 		uiKeyMapping.put( "Menu.border",                "Menu.margin" );
 		uiKeyMapping.put( "MenuItem.border",            "MenuItem.margin" );
-		uiKeyCopying.put( "CheckBoxMenuItem.margin",    "MenuItem.margin" );
-		uiKeyCopying.put( "RadioButtonMenuItem.margin", "MenuItem.margin" );
 		uiKeyMapping.put( "PopupMenu.border",           "PopupMenu.borderInsets" );
-		uiKeyCopying.put( "MenuItem.underlineSelectionColor", "TabbedPane.underlineColor" );
 
 		// IDEA uses List.selectionBackground also for menu selection
 		uiKeyCopying.put( "Menu.selectionBackground",                "List.selectionBackground" );
@@ -575,13 +771,14 @@ public class IntelliJTheme
 		uiKeyCopying.put( "CheckBoxMenuItem.selectionBackground",    "List.selectionBackground" );
 		uiKeyCopying.put( "RadioButtonMenuItem.selectionBackground", "List.selectionBackground" );
 
-		// ProgressBar
+		// ProgressBar: IDEA uses ProgressBar.trackColor and ProgressBar.progressColor
 		uiKeyMapping.put( "ProgressBar.background",    "" ); // ignore
 		uiKeyMapping.put( "ProgressBar.foreground",    "" ); // ignore
 		uiKeyMapping.put( "ProgressBar.trackColor",    "ProgressBar.background" );
 		uiKeyMapping.put( "ProgressBar.progressColor", "ProgressBar.foreground" );
-		uiKeyCopying.put( "ProgressBar.selectionForeground", "ProgressBar.background" );
-		uiKeyCopying.put( "ProgressBar.selectionBackground", "ProgressBar.foreground" );
+
+		// RadioButton
+		uiKeyMapping.put( "RadioButton.iconSize", "" ); // ignore (used in Rider themes)
 
 		// ScrollBar
 		uiKeyMapping.put( "ScrollBar.trackColor", "ScrollBar.track" );
@@ -591,29 +788,30 @@ public class IntelliJTheme
 		uiKeyMapping.put( "Separator.separatorColor", "Separator.foreground" );
 
 		// Slider
+		uiKeyMapping.put( "Slider.buttonColor", "Slider.thumbColor" );
+		uiKeyMapping.put( "Slider.buttonBorderColor", "" ); // ignore
+		uiKeyMapping.put( "Slider.thumb", "" ); // ignore (used in Material Theme UI Lite)
+		uiKeyMapping.put( "Slider.track", "" ); // ignore (used in Material Theme UI Lite)
+		uiKeyMapping.put( "Slider.trackDisabled", "" ); // ignore (used in Material Theme UI Lite)
 		uiKeyMapping.put( "Slider.trackWidth", "" ); // ignore (used in Material Theme UI Lite)
-		uiKeyCopying.put( "Slider.trackValueColor", "ProgressBar.foreground" );
-		uiKeyCopying.put( "Slider.thumbColor", "ProgressBar.foreground" );
-		uiKeyCopying.put( "Slider.trackColor", "ProgressBar.background" );
 
-		// Spinner
-		uiKeyCopying.put( "Spinner.buttonSeparatorColor",         "Component.borderColor" );
-		uiKeyCopying.put( "Spinner.buttonDisabledSeparatorColor", "Component.disabledBorderColor" );
+		// TabbedPane
+		uiKeyMapping.put( "DefaultTabs.underlinedTabBackground", "TabbedPane.selectedBackground" );
+		uiKeyMapping.put( "DefaultTabs.underlinedTabForeground", "TabbedPane.selectedForeground" );
+		uiKeyMapping.put( "DefaultTabs.inactiveUnderlineColor",  "TabbedPane.inactiveUnderlineColor" );
+		uiKeyMapping.put( "TabbedPane.tabAreaInsets", "" ); // ignore (used in Material Theme UI Lite)
+
+		// TableHeader
+		uiKeyMapping.put( "TableHeader.cellBorder", "" ); // ignore (used in Material Theme UI Lite)
+		uiKeyMapping.put( "TableHeader.height", "" ); // ignore (used in Material Theme UI Lite)
 
 		// TitlePane
-		uiKeyCopying.put( "TitlePane.inactiveBackground",     "TitlePane.background" );
 		uiKeyMapping.put( "TitlePane.infoForeground",         "TitlePane.foreground" );
 		uiKeyMapping.put( "TitlePane.inactiveInfoForeground", "TitlePane.inactiveForeground" );
 
 		for( Map.Entry<String, String> e : uiKeyMapping.entrySet() )
 			uiKeyInverseMapping.put( e.getValue(), e.getKey() );
 
-		uiKeyCopying.put( "ToggleButton.tab.underlineColor",         "TabbedPane.underlineColor" );
-		uiKeyCopying.put( "ToggleButton.tab.disabledUnderlineColor", "TabbedPane.disabledUnderlineColor" );
-		uiKeyCopying.put( "ToggleButton.tab.selectedBackground",     "TabbedPane.selectedBackground" );
-		uiKeyCopying.put( "ToggleButton.tab.hoverBackground",        "TabbedPane.hoverColor" );
-		uiKeyCopying.put( "ToggleButton.tab.focusBackground",        "TabbedPane.focusColor" );
-
 		checkboxKeyMapping.put( "Checkbox.Background.Default",  "CheckBox.icon.background" );
 		checkboxKeyMapping.put( "Checkbox.Background.Disabled", "CheckBox.icon.disabledBackground" );
 		checkboxKeyMapping.put( "Checkbox.Border.Default",      "CheckBox.icon.borderColor" );
@@ -666,17 +864,15 @@ public class IntelliJTheme
 		}
 
 		@Override
-		void applyAdditionalDefaults( UIDefaults defaults ) {
-			theme.applyProperties( defaults );
+		void applyAdditionalProperties( Properties properties ) {
+			theme.applyProperties( properties );
 		}
 
 		@Override
 		protected ArrayList<Class<?>> getLafClassesForDefaultsLoading() {
-			ArrayList<Class<?>> lafClasses = new ArrayList<>();
-			lafClasses.add( FlatLaf.class );
-			lafClasses.add( theme.dark ? FlatDarkLaf.class : FlatLightLaf.class );
-			lafClasses.add( theme.dark ? FlatDarculaLaf.class : FlatIntelliJLaf.class );
-			lafClasses.add( ThemeLaf.class );
+			ArrayList<Class<?>> lafClasses = UIDefaultsLoader.getLafClassesForDefaultsLoading( getClass() );
+			lafClasses.add( 1, theme.dark ? FlatDarkLaf.class : FlatLightLaf.class );
+			lafClasses.add( 2, theme.dark ? FlatDarculaLaf.class : FlatIntelliJLaf.class );
 			return lafClasses;
 		}
 	}

flatlaf-core/src/main/java/com/formdev/flatlaf/LinuxFontPolicy.java

@@ -17,18 +17,22 @@
 package com.formdev.flatlaf;
 
 import java.awt.Font;
+import java.awt.FontMetrics;
 import java.awt.GraphicsConfiguration;
 import java.awt.GraphicsEnvironment;
 import java.awt.Toolkit;
 import java.io.BufferedReader;
 import java.io.File;
-import java.io.FileReader;
+import java.io.FileInputStream;
 import java.io.IOException;
+import java.io.InputStreamReader;
+import java.nio.charset.StandardCharsets;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
+import java.util.Locale;
 import java.util.StringTokenizer;
-
+import javax.swing.text.StyleContext;
 import com.formdev.flatlaf.util.LoggingFacade;
 import com.formdev.flatlaf.util.StringUtils;
 import com.formdev.flatlaf.util.SystemInfo;
@@ -67,7 +71,7 @@ class LinuxFontPolicy
 			if( word.endsWith( "," ) )
 				word = word.substring( 0, word.length() - 1 ).trim();
 
-			String lword = word.toLowerCase();
+			String lword = word.toLowerCase( Locale.ENGLISH );
 			if( lword.equals( "italic" ) || lword.equals( "oblique" ) )
 				style |= Font.ITALIC;
 			else if( lword.equals( "bold" ) )
@@ -103,11 +107,11 @@ class LinuxFontPolicy
 			size = 1;
 
 		// handle logical font names
-		String logicalFamily = mapFcName( family.toLowerCase() );
+		String logicalFamily = mapFcName( family.toLowerCase( Locale.ENGLISH ) );
 		if( logicalFamily != null )
 			family = logicalFamily;
 
-		return createFontEx( family, style, size, dsize );
+		return createFontEx( family, style, size );
 	}
 
 	/**
@@ -117,21 +121,32 @@ class LinuxFontPolicy
 	 * 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 ) {
+	private static Font createFontEx( String family, int style, int size ) {
 		for(;;) {
-			Font font = createFont( family, style, size, dsize );
+			Font font = FlatLaf.createCompositeFont( family, style, size );
+
+			if( Font.DIALOG.equals( family ) )
+				return font;
 
 			// if the font family does not match any font on the system, "Dialog" family is returned
-			if( !"Dialog".equals( font.getFamily() ) || "Dialog".equals( family ) )
+			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 FlatLaf.createCompositeFont( Font.DIALOG, style, size );
+
 				return font;
+			}
 
 			// find last word in family
 			int index = family.lastIndexOf( ' ' );
 			if( index < 0 )
-				return createFont( "Dialog", style, size, dsize );
+				return FlatLaf.createCompositeFont( Font.DIALOG, style, size );
 
 			// check whether last work contains some font weight (e.g. Ultra-Bold or Heavy)
-			String lastWord = family.substring( index + 1 ).toLowerCase();
+			String lastWord = family.substring( index + 1 ).toLowerCase( Locale.ENGLISH );
 			if( lastWord.contains( "bold" ) || lastWord.contains( "heavy" ) || lastWord.contains( "black" ) )
 				style |= Font.BOLD;
 
@@ -140,15 +155,6 @@ class LinuxFontPolicy
 		}
 	}
 
-	private static Font createFont( String family, int style, int size, double dsize ) {
-		Font font = FlatLaf.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( isSystemScaling() )
@@ -158,7 +164,7 @@ class LinuxFontPolicy
 
 		Object value = Toolkit.getDefaultToolkit().getDesktopProperty( "gnome.Xft/DPI" );
 		if( value instanceof Integer ) {
-			int dpi = ((Integer)value).intValue() / 1024;
+			int dpi = (Integer) value / 1024;
 			if( dpi == -1 )
 				dpi = 96;
 			if( dpi < 50 )
@@ -185,10 +191,10 @@ class LinuxFontPolicy
 	}
 
 	/**
-	 * Gets the default font for KDE for KDE configuration files.
+	 * Gets the default font for KDE from KDE configuration files.
 	 *
 	 * The Swing fonts are not updated when the user changes system font size
-	 * (System Settings > Fonts > Force Font DPI). A application restart is necessary.
+	 * (System Settings > Fonts > Force Font DPI). An application restart is necessary.
 	 * This is the same behavior as in native KDE applications.
 	 *
 	 * The "display scale factor" (kdeglobals: [KScreen] > ScaleFactor) is not used
@@ -242,9 +248,10 @@ class LinuxFontPolicy
 		if( size < 1 )
 			size = 1;
 
-		return createFont( family, style, size, dsize );
+		return FlatLaf.createCompositeFont( family, style, size );
 	}
 
+	@SuppressWarnings( "MixedMutabilityReturnType" ) // Error Prone
 	private static List<String> readConfig( String filename ) {
 		File userHome = new File( System.getProperty( "user.home" ) );
 
@@ -265,8 +272,10 @@ class LinuxFontPolicy
 
 		// read config file
 		ArrayList<String> lines = new ArrayList<>( 200 );
-		try( BufferedReader reader = new BufferedReader( new FileReader( file ) ) ) {
-			String line = null;
+		try( BufferedReader reader = new BufferedReader( new InputStreamReader(
+			new FileInputStream( file ), StandardCharsets.US_ASCII ) ) )
+		{
+			String line;
 			while( (line = reader.readLine()) != null )
 				lines.add( line );
 		} catch( IOException ex ) {

flatlaf-core/src/main/java/com/formdev/flatlaf/LinuxPopupMenuCanceler.java

@@ -0,0 +1,166 @@
+/*
+ * Copyright 2025 FormDev Software GmbH
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.formdev.flatlaf;
+
+import java.awt.Component;
+import java.awt.Window;
+import java.awt.event.ComponentEvent;
+import java.awt.event.ComponentListener;
+import java.awt.event.WindowAdapter;
+import java.awt.event.WindowEvent;
+import javax.swing.JPopupMenu;
+import javax.swing.MenuElement;
+import javax.swing.MenuSelectionManager;
+import javax.swing.SwingUtilities;
+import javax.swing.event.ChangeEvent;
+import javax.swing.event.ChangeListener;
+
+/**
+ * Cancels (hides) popup menus on Linux.
+ * <p>
+ * On Linux, popups are not hidden under following conditions, which results in
+ * misplaced popups:
+ * <ul>
+ *   <li>window moved or resized
+ *   <li>window maximized or restored
+ *   <li>window iconified
+ *   <li>window deactivated (e.g. activated other application)
+ * </ul>
+ *
+ * On Windows and macOS, popups are automatically hidden.
+ * <p>
+ * The implementation is similar to what's done in
+ * {@code javax.swing.plaf.basic.BasicPopupMenuUI.MouseGrabber},
+ * but only hides popup in some conditions.
+ *
+ * @author Karl Tauber
+ */
+class LinuxPopupMenuCanceler
+	extends WindowAdapter
+	implements ChangeListener, ComponentListener
+{
+	private MenuElement[] lastPathSelectedPath;
+	private Window window;
+
+	LinuxPopupMenuCanceler() {
+		MenuSelectionManager msm = MenuSelectionManager.defaultManager();
+		msm.addChangeListener( this );
+
+		lastPathSelectedPath = msm.getSelectedPath();
+		if( lastPathSelectedPath.length > 0 )
+			addWindowListeners( lastPathSelectedPath[0] );
+	}
+
+	void uninstall() {
+		MenuSelectionManager.defaultManager().removeChangeListener( this );
+	}
+
+	private void addWindowListeners( MenuElement selected ) {
+		removeWindowListeners();
+
+		// see BasicPopupMenuUI.MouseGrabber.grabWindow()
+		Component invoker = selected.getComponent();
+		if( invoker instanceof JPopupMenu )
+			invoker = ((JPopupMenu)invoker).getInvoker();
+		window = (invoker instanceof Window)
+			? (Window) invoker
+			: SwingUtilities.windowForComponent( invoker );
+
+		if( window != null ) {
+			window.addWindowListener( this );
+			window.addComponentListener( this );
+		}
+	}
+
+	private void removeWindowListeners() {
+		if( window != null ) {
+			window.removeWindowListener( this );
+			window.removeComponentListener( this );
+			window = null;
+		}
+	}
+
+	private void cancelPopupMenu() {
+		try {
+			MenuSelectionManager msm = MenuSelectionManager.defaultManager();
+			MenuElement[] selectedPath = msm.getSelectedPath();
+			for( MenuElement e : selectedPath ) {
+				if( e instanceof JPopupMenu )
+					((JPopupMenu)e).putClientProperty( "JPopupMenu.firePopupMenuCanceled", true );
+			}
+			msm.clearSelectedPath();
+		} catch( RuntimeException ex ) {
+			removeWindowListeners();
+			throw ex;
+		} catch( Error ex ) {
+			removeWindowListeners();
+			throw ex;
+		}
+	}
+
+	//---- ChangeListener ----
+
+	@Override
+	public void stateChanged( ChangeEvent e ) {
+		MenuElement[] selectedPath = MenuSelectionManager.defaultManager().getSelectedPath();
+
+		if( selectedPath.length == 0 )
+			removeWindowListeners();
+		else if( lastPathSelectedPath.length == 0 )
+			addWindowListeners( selectedPath[0] );
+
+		lastPathSelectedPath = selectedPath;
+	}
+
+	//---- WindowListener ----
+
+	@Override
+	public void windowIconified( WindowEvent e ) {
+		cancelPopupMenu();
+	}
+
+	@Override
+	public void windowDeactivated( WindowEvent e ) {
+		cancelPopupMenu();
+	}
+
+	@Override
+	public void windowClosing( WindowEvent e ) {
+		cancelPopupMenu();
+	}
+
+	//---- ComponentListener ----
+
+	@Override
+	public void componentResized( ComponentEvent e ) {
+		cancelPopupMenu();
+	}
+
+	@Override
+	public void componentMoved( ComponentEvent e ) {
+		cancelPopupMenu();
+	}
+
+	@Override
+	public void componentShown( ComponentEvent e ) {
+	}
+
+	@Override
+	public void componentHidden( ComponentEvent e ) {
+		cancelPopupMenu();
+	}
+}

flatlaf-core/src/main/java/com/formdev/flatlaf/SubMenuUsabilityHelper.java

@@ -0,0 +1,360 @@
+/*
+ * Copyright 2022 FormDev Software GmbH
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.formdev.flatlaf;
+
+import java.awt.AWTEvent;
+import java.awt.Color;
+import java.awt.Component;
+import java.awt.Container;
+import java.awt.Dimension;
+import java.awt.EventQueue;
+import java.awt.Graphics;
+import java.awt.Graphics2D;
+import java.awt.MouseInfo;
+import java.awt.Point;
+import java.awt.PointerInfo;
+import java.awt.Polygon;
+import java.awt.Rectangle;
+import java.awt.Toolkit;
+import java.awt.Window;
+import java.awt.event.MouseEvent;
+import javax.swing.JComponent;
+import javax.swing.JLayeredPane;
+import javax.swing.JMenu;
+import javax.swing.JPopupMenu;
+import javax.swing.MenuElement;
+import javax.swing.MenuSelectionManager;
+import javax.swing.RootPaneContainer;
+import javax.swing.SwingUtilities;
+import javax.swing.Timer;
+import javax.swing.UIManager;
+import javax.swing.event.ChangeEvent;
+import javax.swing.event.ChangeListener;
+import com.formdev.flatlaf.ui.FlatUIUtils;
+import com.formdev.flatlaf.util.LoggingFacade;
+
+/**
+ * Improves usability of submenus by using a
+ * <a href="https://height.app/blog/guide-to-build-context-menus#safe-triangle">safe triangle</a>
+ * to avoid that the submenu closes while the user moves the mouse to it.
+ *
+ * @author Karl Tauber
+ */
+class SubMenuUsabilityHelper
+	implements ChangeListener
+{
+	private static final String KEY_USE_SAFE_TRIANGLE = "Menu.useSafeTriangle";
+	private static final String KEY_SHOW_SAFE_TRIANGLE = "FlatLaf.debug.menu.showSafeTriangle";
+
+	// Using a static field to ensure that there is only one instance in the system.
+	// Multiple instances would freeze the application.
+	// https://github.com/apache/netbeans/issues/4231#issuecomment-1179616607
+	private static SubMenuUsabilityHelper instance;
+
+	private boolean eventQueuePushNotSupported;
+	private SubMenuEventQueue subMenuEventQueue;
+	private SafeTrianglePainter safeTrianglePainter;
+	private boolean changePending;
+
+	// mouse location in screen coordinates
+	private int mouseX;
+	private int mouseY;
+
+	// target popup bounds in screen coordinates
+	private int targetX;
+	private int targetTopY;
+	private int targetBottomY;
+
+	private Rectangle invokerBounds;
+
+	static synchronized boolean install() {
+		if( instance != null )
+			return false;
+
+		if( !FlatSystemProperties.getBoolean( FlatSystemProperties.USE_SUB_MENU_SAFE_TRIANGLE, true ) )
+			return false;
+
+		instance = new SubMenuUsabilityHelper();
+		MenuSelectionManager.defaultManager().addChangeListener( instance );
+		return true;
+	}
+
+	static synchronized void uninstall() {
+		if( instance == null )
+			return;
+
+		MenuSelectionManager.defaultManager().removeChangeListener( instance );
+		instance.uninstallEventQueue();
+		instance = null;
+	}
+
+	@Override
+	public void stateChanged( ChangeEvent e ) {
+		if( eventQueuePushNotSupported || !FlatUIUtils.getUIBoolean( KEY_USE_SAFE_TRIANGLE, true ))
+			return;
+
+		// handle menu selection change later, but only once in case of temporary changes
+		// e.g. moving mouse from one menu item to another one, fires two events:
+		//    1. old menu item is removed from menu selection
+		//    2. new menu item is added to menu selection
+		synchronized( this ) {
+			if( changePending )
+				return;
+			changePending = true;
+		}
+
+		EventQueue.invokeLater( () -> {
+			synchronized( this ) {
+				changePending = false;
+			}
+			menuSelectionChanged();
+		} );
+	}
+
+	private void menuSelectionChanged() {
+		MenuElement[] path = MenuSelectionManager.defaultManager().getSelectedPath();
+
+/*debug
+		System.out.println( "--- " + path.length );
+		for( int i = 0; i < path.length; i++ )
+			System.out.println( "   " + i + ": " + path[i].getClass().getName() );
+debug*/
+
+		// find submenu in menu selection
+		int subMenuIndex = findSubMenu( path );
+
+		// uninstall if there is no submenu in selection
+		if( subMenuIndex < 0 || subMenuIndex != path.length - 1 ) {
+			uninstallEventQueue();
+			return;
+		}
+
+		// get current mouse location
+		PointerInfo pointerInfo = MouseInfo.getPointerInfo();
+		Point mouseLocation = (pointerInfo != null) ? pointerInfo.getLocation() : new Point();
+		mouseX = mouseLocation.x;
+		mouseY = mouseLocation.y;
+
+		// check whether popup is showing, which is e.g. not the case if it is empty
+		JPopupMenu popup = (JPopupMenu) path[subMenuIndex];
+		if( !popup.isShowing() ) {
+			uninstallEventQueue();
+			return;
+		}
+
+		// get invoker screen bounds
+		Component invoker = popup.getInvoker();
+		invokerBounds = (invoker != null && invoker.isShowing())
+			? new Rectangle( invoker.getLocationOnScreen(), invoker.getSize() )
+			: null;
+
+		// check whether mouse location is within invoker
+		if( invokerBounds != null && !invokerBounds.contains( mouseX, mouseY ) ) {
+			uninstallEventQueue();
+			return;
+		}
+
+		// compute top/bottom target locations
+		Point popupLocation = popup.getLocationOnScreen();
+		Dimension popupSize = popup.getSize();
+		targetX = (mouseX < popupLocation.x + (popupSize.width / 2))
+			? popupLocation.x
+			: popupLocation.x + popupSize.width;
+		targetTopY = popupLocation.y;
+		targetBottomY = popupLocation.y + popupSize.height;
+
+		// install own event queue to suppress mouse events when mouse is moved within safe triangle
+		if( subMenuEventQueue == null ) {
+			SubMenuEventQueue queue = new SubMenuEventQueue();
+
+			try {
+				Toolkit toolkit = Toolkit.getDefaultToolkit();
+				toolkit.getSystemEventQueue().push( queue );
+
+				// check whether push() worked
+				// (e.g. SWTSwing uses own event queue that does not support push())
+				if( toolkit.getSystemEventQueue() != queue ) {
+					eventQueuePushNotSupported = true;
+					LoggingFacade.INSTANCE.logSevere( "FlatLaf: Failed to push submenu event queue. Disabling submenu safe triangle.", null );
+					return;
+				}
+
+				subMenuEventQueue = queue;
+			} catch( RuntimeException ex ) {
+				// catch runtime exception from EventQueue.push()
+				eventQueuePushNotSupported = true;
+				LoggingFacade.INSTANCE.logSevere( "FlatLaf: Failed to push submenu event queue. Disabling submenu safe triangle.", ex );
+				return;
+			}
+		}
+
+		// create safe triangle painter
+		if( safeTrianglePainter == null && UIManager.getBoolean( KEY_SHOW_SAFE_TRIANGLE ) )
+			safeTrianglePainter = new SafeTrianglePainter( popup );
+	}
+
+	private void uninstallEventQueue() {
+		if( subMenuEventQueue != null ) {
+			subMenuEventQueue.uninstall();
+			subMenuEventQueue = null;
+		}
+
+		if( safeTrianglePainter != null ) {
+			safeTrianglePainter.uninstall();
+			safeTrianglePainter = null;
+		}
+	}
+
+	private int findSubMenu( MenuElement[] path ) {
+		for( int i = path.length - 1; i >= 1; i-- ) {
+			if( path[i] instanceof JPopupMenu &&
+				path[i - 1] instanceof JMenu &&
+				!((JMenu)path[i - 1]).isTopLevelMenu() )
+			  return i;
+		}
+		return -1;
+	}
+
+	private Polygon createSafeTriangle() {
+		return new Polygon(
+			new int[] { mouseX, targetX, targetX },
+			new int[] { mouseY, targetTopY, targetBottomY },
+			3 );
+	}
+
+	//---- class SubMenuEventQueue --------------------------------------------
+
+	private class SubMenuEventQueue
+		extends EventQueue
+	{
+		private Timer mouseUpdateTimer;
+		private Timer timeoutTimer;
+
+		private int newMouseX;
+		private int newMouseY;
+		private AWTEvent lastMouseEvent;
+
+		SubMenuEventQueue() {
+			// timer used to slightly delay update of mouse location used for safe triangle
+			mouseUpdateTimer = new Timer( 50, e -> {
+				mouseX = newMouseX;
+				mouseY = newMouseY;
+
+				if( safeTrianglePainter != null )
+					safeTrianglePainter.repaint();
+			} );
+			mouseUpdateTimer.setRepeats( false );
+
+			// timer used to timeout safe triangle when mouse stops moving
+			timeoutTimer = new Timer( 200, e -> {
+				if( invokerBounds != null && !invokerBounds.contains( newMouseX, newMouseY ) ) {
+					// post last mouse event, which selects menu item at mouse location
+					if( lastMouseEvent != null ) {
+						postEvent( lastMouseEvent );
+						lastMouseEvent = null;
+					}
+
+					uninstallEventQueue();
+					return;
+				}
+			} );
+			timeoutTimer.setRepeats( false );
+		}
+
+		void uninstall() {
+			mouseUpdateTimer.stop();
+			mouseUpdateTimer = null;
+
+			timeoutTimer.stop();
+			timeoutTimer = null;
+
+			lastMouseEvent = null;
+
+			super.pop();
+		}
+
+		@Override
+		protected void dispatchEvent( AWTEvent e ) {
+			int id = e.getID();
+
+			if( e instanceof MouseEvent &&
+				(id == MouseEvent.MOUSE_MOVED || id == MouseEvent.MOUSE_DRAGGED) )
+			{
+				newMouseX = ((MouseEvent)e).getXOnScreen();
+				newMouseY = ((MouseEvent)e).getYOnScreen();
+
+				if( safeTrianglePainter != null )
+					safeTrianglePainter.repaint();
+
+				mouseUpdateTimer.stop();
+				timeoutTimer.stop();
+
+				// check whether mouse moved within safe triangle
+				if( createSafeTriangle().contains( newMouseX, newMouseY ) ) {
+					// update mouse location delayed (this changes the safe triangle)
+					mouseUpdateTimer.start();
+
+					timeoutTimer.start();
+
+					// remember last mouse event, which will be posted if the mouse stops moving
+					lastMouseEvent = e;
+
+					// ignore mouse event
+					return;
+				}
+
+				// update mouse location immediately (this changes the safe triangle)
+				mouseX = newMouseX;
+				mouseY = newMouseY;
+			}
+
+			super.dispatchEvent( e );
+		}
+	}
+
+	//---- class SafeTrianglePainter ------------------------------------------
+
+	private class SafeTrianglePainter
+		extends JComponent
+	{
+		SafeTrianglePainter( JPopupMenu popup ) {
+			Window window = SwingUtilities.windowForComponent( popup.getInvoker() );
+			if( window instanceof RootPaneContainer ) {
+				JLayeredPane layeredPane = ((RootPaneContainer)window).getLayeredPane();
+				setSize( layeredPane.getSize() );
+				layeredPane.add( this, Integer.valueOf( JLayeredPane.POPUP_LAYER + 1 ) );
+			}
+		}
+
+		void uninstall() {
+			Container parent = getParent();
+			if( parent != null ) {
+				parent.remove( this );
+				parent.repaint();
+			}
+		}
+
+		@Override
+		protected void paintComponent( Graphics g ) {
+			Point locationOnScreen = getLocationOnScreen();
+			g.translate( -locationOnScreen.x, -locationOnScreen.y );
+
+			g.setColor( Color.red );
+			((Graphics2D)g).draw( createSafeTriangle() );
+		}
+	}
+}

flatlaf-core/src/main/java/com/formdev/flatlaf/icons/FlatAbstractIcon.java

@@ -57,6 +57,8 @@ public abstract class FlatAbstractIcon
 //			g2.setColor( Color.blue );
 //			g2.drawRect( x, y, getIconWidth() - 1, getIconHeight() - 1 );
 
+			paintBackground( c, g2, x, y );
+
 			g2.translate( x, y );
 			UIScale.scaleGraphics( g2 );
 
@@ -69,7 +71,11 @@ public abstract class FlatAbstractIcon
 		}
 	}
 
-	protected abstract void paintIcon( Component c, Graphics2D g2 );
+	/** @since 3.5.2 */
+	protected void paintBackground( Component c, Graphics2D g, int x, int y ) {
+	}
+
+	protected abstract void paintIcon( Component c, Graphics2D g );
 
 	@Override
 	public int getIconWidth() {

flatlaf-core/src/main/java/com/formdev/flatlaf/icons/FlatAnimatedIcon.java

@@ -23,13 +23,13 @@ import java.awt.Graphics2D;
 import com.formdev.flatlaf.util.AnimatedIcon;
 
 /**
- * Base class for animated icons that scales width and height, creates and initializes
+ * Base class for animated icons that scale width and height, creates and initializes
  * a scaled graphics context for icon painting.
  * <p>
  * Subclasses do not need to scale icon painting.
  * <p>
  * This class does not store any state information (needed for animation) in its instance.
- * Instead a client property is set on the painted component.
+ * Instead, a client property is set on the painted component.
  * This makes it possible to use a share icon instance for multiple components.
  *
  * @author Karl Tauber

flatlaf-core/src/main/java/com/formdev/flatlaf/icons/FlatAscendingSortIcon.java

@@ -51,7 +51,7 @@ public class FlatAscendingSortIcon
 		boolean chevron = this.chevron;
 		Color sortIconColor = this.sortIconColor;
 
-		// Because this icons are always shared for all table headers,
+		// Because this icon is always shared for all table headers,
 		// get icon specific style from FlatTableHeaderUI.
 		JTableHeader tableHeader = (JTableHeader) SwingUtilities.getAncestorOfClass( JTableHeader.class, c );
 		if( tableHeader != null ) {

flatlaf-core/src/main/java/com/formdev/flatlaf/icons/FlatCapsLockIcon.java

@@ -16,9 +16,12 @@
 
 package com.formdev.flatlaf.icons;
 
+import java.awt.BasicStroke;
 import java.awt.Color;
 import java.awt.Component;
 import java.awt.Graphics2D;
+import java.awt.RenderingHints;
+import java.awt.geom.Area;
 import java.awt.geom.Path2D;
 import java.awt.geom.Rectangle2D;
 import java.awt.geom.RoundRectangle2D;
@@ -36,6 +39,8 @@ import com.formdev.flatlaf.ui.FlatUIUtils;
 public class FlatCapsLockIcon
 	extends FlatAbstractIcon
 {
+	private Path2D path;
+
 	public FlatCapsLockIcon() {
 		super( 16, 16, UIManager.getColor( "PasswordField.capsLockIconColor" ) );
 	}
@@ -49,22 +54,36 @@ public class FlatCapsLockIcon
 		}
 	}
 
+	/** @since 2.5 */
+	public Object getStyleableValue( String key ) {
+		switch( key ) {
+			case "capsLockIconColor": return color;
+			default: return null;
+		}
+	}
+
 	@Override
 	protected void paintIcon( Component c, Graphics2D g ) {
 		/*
 			<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 16 16">
 			  <g fill="none" fill-rule="evenodd">
 			    <rect width="16" height="16" fill="#6E6E6E" rx="3"/>
-			    <rect width="6" height="2" x="5" y="11.5" fill="#FFF"/>
-    			<path fill="#FFF" d="M2,8 L8,2 L14,8 L11,8 L11,10 L5,10 L5,8 L2,8 Z"/>
+			    <rect width="5" height="2" x="5.5" y="11.5" stroke="#FFF" stroke-linejoin="round"/>
+			    <path stroke="#FFF" stroke-linejoin="round" d="M2.5,7.5 L8,2 L13.5,7.5 L10.5,7.5 L10.5,9.5 L5.5,9.5 L5.5,7.5 L2.5,7.5 Z"/>
 			  </g>
 			</svg>
 		*/
 
-		Path2D path = new Path2D.Float( Path2D.WIND_EVEN_ODD );
-		path.append( new RoundRectangle2D.Float( 0, 0, 16, 16, 6, 6 ), false );
-		path.append( new Rectangle2D.Float( 5, 11.5f, 6, 2 ), false );
-		path.append( FlatUIUtils.createPath( 2,8, 8,2, 14,8, 11,8, 11,10, 5,10, 5,8 ), false );
+		g.setRenderingHint( RenderingHints.KEY_STROKE_CONTROL, RenderingHints.VALUE_STROKE_PURE );
+		BasicStroke stroke = new BasicStroke( 1, BasicStroke.CAP_SQUARE, BasicStroke.JOIN_ROUND );
+
+		if( path == null ) {
+			path = new Path2D.Float( Path2D.WIND_EVEN_ODD );
+			path.append( new RoundRectangle2D.Float( 0, 0, 16, 16, 6, 6 ), false );
+			path.append( new Area( stroke.createStrokedShape( new Rectangle2D.Float( 5.5f, 11.5f, 5, 2 ) ) ), false );
+			path.append( new Area( stroke.createStrokedShape( FlatUIUtils.createPath(
+				2.5,7.5, 8,2, 13.5,7.5, 10.5,7.5, 10.5,9.5, 5.5,9.5, 5.5,7.5, 2.5,7.5 ) ) ), false );
+		}
 		g.fill( path );
 	}
 }

flatlaf-core/src/main/java/com/formdev/flatlaf/icons/FlatCheckBoxIcon.java

@@ -17,6 +17,7 @@
 package com.formdev.flatlaf.icons;
 
 import static com.formdev.flatlaf.FlatClientProperties.*;
+import static com.formdev.flatlaf.ui.FlatUIUtils.stateColor;
 import java.awt.BasicStroke;
 import java.awt.Color;
 import java.awt.Component;
@@ -48,6 +49,8 @@ import com.formdev.flatlaf.ui.FlatUIUtils;
  * @uiDefault CheckBox.icon.borderWidth					int or float	optional; defaults to Component.borderWidth
  * @uiDefault CheckBox.icon.selectedBorderWidth			int or float	optional; defaults to CheckBox.icon.borderWidth
  * @uiDefault CheckBox.icon.disabledSelectedBorderWidth	int or float	optional; defaults to CheckBox.icon.selectedBorderWidth
+ * @uiDefault CheckBox.icon.indeterminateBorderWidth			int or float	optional; defaults to CheckBox.icon.selectedBorderWidth
+ * @uiDefault CheckBox.icon.disabledIndeterminateBorderWidth	int or float	optional; defaults to CheckBox.icon.disabledSelectedBorderWidth
  * @uiDefault CheckBox.arc								int
  *
  * @uiDefault CheckBox.icon.focusColor					Color	optional; defaults to Component.focusColor
@@ -56,30 +59,45 @@ import com.formdev.flatlaf.ui.FlatUIUtils;
  * @uiDefault CheckBox.icon.selectedBorderColor			Color
  * @uiDefault CheckBox.icon.selectedBackground			Color
  * @uiDefault CheckBox.icon.checkmarkColor				Color
+ * @uiDefault CheckBox.icon.indeterminateBorderColor	Color	optional; defaults to CheckBox.icon.selectedBorderColor
+ * @uiDefault CheckBox.icon.indeterminateBackground		Color	optional; defaults to CheckBox.icon.selectedBackground
+ * @uiDefault CheckBox.icon.indeterminateCheckmarkColor	Color	optional; defaults to CheckBox.icon.checkmarkColor
  *
- * @uiDefault CheckBox.icon.disabledBorderColor			Color
- * @uiDefault CheckBox.icon.disabledBackground			Color
- * @uiDefault CheckBox.icon.disabledSelectedBorderColor	Color	optional; CheckBox.icon.disabledBorderColor is used if not specified
- * @uiDefault CheckBox.icon.disabledSelectedBackground	Color	optional; CheckBox.icon.disabledBackground is used if not specified
- * @uiDefault CheckBox.icon.disabledCheckmarkColor		Color
+ * @uiDefault CheckBox.icon.disabledBorderColor					Color
+ * @uiDefault CheckBox.icon.disabledBackground					Color
+ * @uiDefault CheckBox.icon.disabledSelectedBorderColor			Color	optional; defaults to CheckBox.icon.disabledBorderColor
+ * @uiDefault CheckBox.icon.disabledSelectedBackground			Color	optional; defaults to CheckBox.icon.disabledBackground
+ * @uiDefault CheckBox.icon.disabledCheckmarkColor				Color
+ * @uiDefault CheckBox.icon.disabledIndeterminateBorderColor	Color	optional; defaults to CheckBox.icon.disabledSelectedBorderColor
+ * @uiDefault CheckBox.icon.disabledIndeterminateBackground		Color	optional; defaults to CheckBox.icon.disabledSelectedBackground
+ * @uiDefault CheckBox.icon.disabledIndeterminateCheckmarkColor	Color	optional; defaults to CheckBox.icon.disabledCheckmarkColor
  *
- * @uiDefault CheckBox.icon.focusedBorderColor			Color	optional
- * @uiDefault CheckBox.icon.focusedBackground			Color	optional
- * @uiDefault CheckBox.icon.focusedSelectedBorderColor	Color	optional; CheckBox.icon.focusedBorderColor is used if not specified
- * @uiDefault CheckBox.icon.focusedSelectedBackground	Color	optional; CheckBox.icon.focusedBackground is used if not specified
- * @uiDefault CheckBox.icon.focusedCheckmarkColor		Color	optional; CheckBox.icon.checkmarkColor is used if not specified
+ * @uiDefault CheckBox.icon.focusedBorderColor					Color	optional
+ * @uiDefault CheckBox.icon.focusedBackground					Color	optional
+ * @uiDefault CheckBox.icon.focusedSelectedBorderColor			Color	optional; defaults to CheckBox.icon.focusedBorderColor
+ * @uiDefault CheckBox.icon.focusedSelectedBackground			Color	optional; defaults to CheckBox.icon.focusedBackground
+ * @uiDefault CheckBox.icon.focusedCheckmarkColor				Color	optional; defaults to CheckBox.icon.checkmarkColor
+ * @uiDefault CheckBox.icon.focusedIndeterminateBorderColor		Color	optional; defaults to CheckBox.icon.focusedSelectedBorderColor
+ * @uiDefault CheckBox.icon.focusedIndeterminateBackground		Color	optional; defaults to CheckBox.icon.focusedSelectedBackground
+ * @uiDefault CheckBox.icon.focusedIndeterminateCheckmarkColor	Color	optional; defaults to CheckBox.icon.focusedCheckmarkColor
  *
- * @uiDefault CheckBox.icon.hoverBorderColor			Color	optional
- * @uiDefault CheckBox.icon.hoverBackground				Color	optional
- * @uiDefault CheckBox.icon.hoverSelectedBorderColor	Color	optional; CheckBox.icon.hoverBorderColor is used if not specified
- * @uiDefault CheckBox.icon.hoverSelectedBackground		Color	optional; CheckBox.icon.hoverBackground is used if not specified
- * @uiDefault CheckBox.icon.hoverCheckmarkColor			Color	optional; CheckBox.icon.checkmarkColor is used if not specified
+ * @uiDefault CheckBox.icon.hoverBorderColor					Color	optional
+ * @uiDefault CheckBox.icon.hoverBackground						Color	optional
+ * @uiDefault CheckBox.icon.hoverSelectedBorderColor			Color	optional; defaults to CheckBox.icon.hoverBorderColor
+ * @uiDefault CheckBox.icon.hoverSelectedBackground				Color	optional; defaults to CheckBox.icon.hoverBackground
+ * @uiDefault CheckBox.icon.hoverCheckmarkColor					Color	optional; defaults to CheckBox.icon.checkmarkColor
+ * @uiDefault CheckBox.icon.hoverIndeterminateBorderColor		Color	optional; defaults to CheckBox.icon.hoverSelectedBorderColor
+ * @uiDefault CheckBox.icon.hoverIndeterminateBackground		Color	optional; defaults to CheckBox.icon.hoverSelectedBackground
+ * @uiDefault CheckBox.icon.hoverIndeterminateCheckmarkColor	Color	optional; defaults to CheckBox.icon.hoverCheckmarkColor
  *
- * @uiDefault CheckBox.icon.pressedBorderColor			Color	optional
- * @uiDefault CheckBox.icon.pressedBackground			Color	optional
- * @uiDefault CheckBox.icon.pressedSelectedBorderColor	Color	optional; CheckBox.icon.pressedBorderColor is used if not specified
- * @uiDefault CheckBox.icon.pressedSelectedBackground	Color	optional; CheckBox.icon.pressedBackground is used if not specified
- * @uiDefault CheckBox.icon.pressedCheckmarkColor		Color	optional; CheckBox.icon.checkmarkColor is used if not specified
+ * @uiDefault CheckBox.icon.pressedBorderColor					Color	optional
+ * @uiDefault CheckBox.icon.pressedBackground					Color	optional
+ * @uiDefault CheckBox.icon.pressedSelectedBorderColor			Color	optional; defaults to CheckBox.icon.pressedBorderColor
+ * @uiDefault CheckBox.icon.pressedSelectedBackground			Color	optional; defaults to CheckBox.icon.pressedBackground
+ * @uiDefault CheckBox.icon.pressedCheckmarkColor				Color	optional; defaults to CheckBox.icon.checkmarkColor
+ * @uiDefault CheckBox.icon.pressedIndeterminateBorderColor		Color	optional; defaults to CheckBox.icon.pressedSelectedBorderColor
+ * @uiDefault CheckBox.icon.pressedIndeterminateBackground		Color	optional; defaults to CheckBox.icon.pressedSelectedBackground
+ * @uiDefault CheckBox.icon.pressedIndeterminateCheckmarkColor	Color	optional; defaults to CheckBox.icon.pressedCheckmarkColor
  *
  * @author Karl Tauber
  */
@@ -92,6 +110,8 @@ public class FlatCheckBoxIcon
 	/** @since 2 */ @Styleable protected float borderWidth = getUIFloat( "CheckBox.icon.borderWidth", FlatUIUtils.getUIFloat( "Component.borderWidth", 1 ), style );
 	/** @since 2 */ @Styleable protected float selectedBorderWidth = getUIFloat( "CheckBox.icon.selectedBorderWidth", Float.MIN_VALUE, style );
 	/** @since 2 */ @Styleable protected float disabledSelectedBorderWidth = getUIFloat( "CheckBox.icon.disabledSelectedBorderWidth", Float.MIN_VALUE, style );
+	/** @since 3.6 */ @Styleable protected float indeterminateBorderWidth = getUIFloat( "CheckBox.icon.indeterminateBorderWidth", Float.MIN_VALUE, style );
+	/** @since 3.6 */ @Styleable protected float disabledIndeterminateBorderWidth = getUIFloat( "CheckBox.icon.disabledIndeterminateBorderWidth", Float.MIN_VALUE, style );
 	@Styleable protected int arc = FlatUIUtils.getUIInt( "CheckBox.arc", 2 );
 
 	// enabled
@@ -100,6 +120,9 @@ public class FlatCheckBoxIcon
 	@Styleable protected Color selectedBorderColor = getUIColor( "CheckBox.icon.selectedBorderColor", style );
 	@Styleable protected Color selectedBackground = getUIColor( "CheckBox.icon.selectedBackground", style );
 	@Styleable protected Color checkmarkColor = getUIColor( "CheckBox.icon.checkmarkColor", style );
+	/** @since 3.6 */ @Styleable protected Color indeterminateBorderColor = getUIColor( "CheckBox.icon.indeterminateBorderColor", style );
+	/** @since 3.6 */ @Styleable protected Color indeterminateBackground = getUIColor( "CheckBox.icon.indeterminateBackground", style );
+	/** @since 3.6 */ @Styleable protected Color indeterminateCheckmarkColor = getUIColor( "CheckBox.icon.indeterminateCheckmarkColor", style );
 
 	// disabled
 	@Styleable protected Color disabledBorderColor = getUIColor( "CheckBox.icon.disabledBorderColor", style );
@@ -107,6 +130,9 @@ public class FlatCheckBoxIcon
 	/** @since 2 */ @Styleable protected Color disabledSelectedBorderColor = getUIColor( "CheckBox.icon.disabledSelectedBorderColor", style );
 	/** @since 2 */ @Styleable protected Color disabledSelectedBackground = getUIColor( "CheckBox.icon.disabledSelectedBackground", style );
 	@Styleable protected Color disabledCheckmarkColor = getUIColor( "CheckBox.icon.disabledCheckmarkColor", style );
+	/** @since 3.6 */ @Styleable protected Color disabledIndeterminateBorderColor = getUIColor( "CheckBox.icon.disabledIndeterminateBorderColor", style );
+	/** @since 3.6 */ @Styleable protected Color disabledIndeterminateBackground = getUIColor( "CheckBox.icon.disabledIndeterminateBackground", style );
+	/** @since 3.6 */ @Styleable protected Color disabledIndeterminateCheckmarkColor = getUIColor( "CheckBox.icon.disabledIndeterminateCheckmarkColor", style );
 
 	// focused
 	@Styleable protected Color focusedBorderColor = getUIColor( "CheckBox.icon.focusedBorderColor", style );
@@ -114,6 +140,9 @@ public class FlatCheckBoxIcon
 	/** @since 2 */ @Styleable protected Color focusedSelectedBorderColor = getUIColor( "CheckBox.icon.focusedSelectedBorderColor", style );
 	/** @since 2 */ @Styleable protected Color focusedSelectedBackground = getUIColor( "CheckBox.icon.focusedSelectedBackground", style );
 	/** @since 2 */ @Styleable protected Color focusedCheckmarkColor = getUIColor( "CheckBox.icon.focusedCheckmarkColor", style );
+	/** @since 3.6 */ @Styleable protected Color focusedIndeterminateBorderColor = getUIColor( "CheckBox.icon.focusedIndeterminateBorderColor", style );
+	/** @since 3.6 */ @Styleable protected Color focusedIndeterminateBackground = getUIColor( "CheckBox.icon.focusedIndeterminateBackground", style );
+	/** @since 3.6 */ @Styleable protected Color focusedIndeterminateCheckmarkColor = getUIColor( "CheckBox.icon.focusedIndeterminateCheckmarkColor", style );
 
 	// hover
 	@Styleable protected Color hoverBorderColor = getUIColor( "CheckBox.icon.hoverBorderColor", style );
@@ -121,6 +150,9 @@ public class FlatCheckBoxIcon
 	/** @since 2 */ @Styleable protected Color hoverSelectedBorderColor = getUIColor( "CheckBox.icon.hoverSelectedBorderColor", style );
 	/** @since 2 */ @Styleable protected Color hoverSelectedBackground = getUIColor( "CheckBox.icon.hoverSelectedBackground", style );
 	/** @since 2 */ @Styleable protected Color hoverCheckmarkColor = getUIColor( "CheckBox.icon.hoverCheckmarkColor", style );
+	/** @since 3.6 */ @Styleable protected Color hoverIndeterminateBorderColor = getUIColor( "CheckBox.icon.hoverIndeterminateBorderColor", style );
+	/** @since 3.6 */ @Styleable protected Color hoverIndeterminateBackground = getUIColor( "CheckBox.icon.hoverIndeterminateBackground", style );
+	/** @since 3.6 */ @Styleable protected Color hoverIndeterminateCheckmarkColor = getUIColor( "CheckBox.icon.hoverIndeterminateCheckmarkColor", style );
 
 	// pressed
 	/** @since 2 */ @Styleable protected Color pressedBorderColor = getUIColor( "CheckBox.icon.pressedBorderColor", style );
@@ -128,6 +160,9 @@ public class FlatCheckBoxIcon
 	/** @since 2 */ @Styleable protected Color pressedSelectedBorderColor = getUIColor( "CheckBox.icon.pressedSelectedBorderColor", style );
 	/** @since 2 */ @Styleable protected Color pressedSelectedBackground = getUIColor( "CheckBox.icon.pressedSelectedBackground", style );
 	/** @since 2 */ @Styleable protected Color pressedCheckmarkColor = getUIColor( "CheckBox.icon.pressedCheckmarkColor", style );
+	/** @since 3.6 */ @Styleable protected Color pressedIndeterminateBorderColor = getUIColor( "CheckBox.icon.pressedIndeterminateBorderColor", style );
+	/** @since 3.6 */ @Styleable protected Color pressedIndeterminateBackground = getUIColor( "CheckBox.icon.pressedIndeterminateBackground", style );
+	/** @since 3.6 */ @Styleable protected Color pressedIndeterminateCheckmarkColor = getUIColor( "CheckBox.icon.pressedIndeterminateCheckmarkColor", style );
 
 	protected String getPropertyPrefix() {
 		return "CheckBox.";
@@ -172,16 +207,27 @@ public class FlatCheckBoxIcon
 		return FlatStylingSupport.getAnnotatedStyleableInfos( this );
 	}
 
+	/** @since 2.5 */
+	public Object getStyleableValue( String key ) {
+		return FlatStylingSupport.getAnnotatedStyleableValue( this, key );
+	}
+
 	@Override
 	protected void paintIcon( Component c, Graphics2D g ) {
 		boolean indeterminate = isIndeterminate( c );
 		boolean selected = indeterminate || isSelected( c );
 		boolean isFocused = FlatUIUtils.isPermanentFocusOwner( c );
-		float bw = selected
-			? (disabledSelectedBorderWidth != Float.MIN_VALUE && !c.isEnabled()
-				? disabledSelectedBorderWidth
-				: (selectedBorderWidth != Float.MIN_VALUE ? selectedBorderWidth : borderWidth))
-			: borderWidth;
+		float bw = Float.MIN_VALUE;
+		if( !c.isEnabled() ) {
+			bw = (indeterminate && disabledIndeterminateBorderWidth != Float.MIN_VALUE)
+				? disabledIndeterminateBorderWidth
+				: (selected ? disabledSelectedBorderWidth : selectedBorderWidth);
+		}
+		if( bw == Float.MIN_VALUE ) {
+			bw = (indeterminate && indeterminateBorderWidth != Float.MIN_VALUE)
+				? indeterminateBorderWidth
+				: ((selected && selectedBorderWidth != Float.MIN_VALUE) ? selectedBorderWidth : borderWidth);
+		}
 
 		// paint focused border
 		if( isFocused && focusWidth > 0 && FlatButtonUI.isFocusPainted( c ) ) {
@@ -190,15 +236,15 @@ public class FlatCheckBoxIcon
 		}
 
 		// paint border
-		g.setColor( getBorderColor( c, selected ) );
+		g.setColor( getBorderColor( c, selected, indeterminate ) );
 		paintBorder( c, g, bw );
 
 		// paint background
-		Color bg = FlatUIUtils.deriveColor( getBackground( c, selected ),
-			selected ? selectedBackground : background );
+		Color baseBg = stateColor( indeterminate, indeterminateBackground, selected, selectedBackground, background );
+		Color bg = FlatUIUtils.deriveColor( getBackground( c, selected, indeterminate ), baseBg );
 		if( bg.getAlpha() < 255 ) {
 			// fill background with default color before filling with non-opaque background
-			g.setColor( selected ? selectedBackground : background );
+			g.setColor( baseBg );
 			paintBackground( c, g, bw );
 		}
 		g.setColor( bg );
@@ -206,7 +252,7 @@ public class FlatCheckBoxIcon
 
 		// paint checkmark
 		if( selected ) {
-			g.setColor( getCheckmarkColor( c ) );
+			g.setColor( getCheckmarkColor( c, indeterminate ) );
 			if( indeterminate )
 				paintIndeterminate( c, g );
 			else
@@ -237,7 +283,7 @@ public class FlatCheckBoxIcon
 	}
 
 	protected void paintCheckmark( Component c, Graphics2D g ) {
-		Path2D.Float path = new Path2D.Float();
+		Path2D.Float path = new Path2D.Float( Path2D.WIND_NON_ZERO, 3 );
 		path.moveTo( 4.5f, 7.5f );
 		path.lineTo( 6.6f, 10f );
 		path.lineTo( 11.25f, 3.5f );
@@ -267,30 +313,33 @@ public class FlatCheckBoxIcon
 		return focusColor;
 	}
 
-	protected Color getBorderColor( Component c, boolean selected ) {
+	/** @since 3.6 */
+	protected Color getBorderColor( Component c, boolean selected, boolean indeterminate ) {
 		return FlatButtonUI.buttonStateColor( c,
-			selected ? selectedBorderColor : borderColor,
-			(selected && disabledSelectedBorderColor != null) ? disabledSelectedBorderColor : disabledBorderColor,
-			(selected && focusedSelectedBorderColor != null) ? focusedSelectedBorderColor : focusedBorderColor,
-			(selected && hoverSelectedBorderColor != null) ? hoverSelectedBorderColor : hoverBorderColor,
-			(selected && pressedSelectedBorderColor != null) ? pressedSelectedBorderColor : pressedBorderColor );
+			stateColor( indeterminate, indeterminateBorderColor,         selected, selectedBorderColor,         borderColor ),
+			stateColor( indeterminate, disabledIndeterminateBorderColor, selected, disabledSelectedBorderColor, disabledBorderColor ),
+			stateColor( indeterminate, focusedIndeterminateBorderColor,  selected, focusedSelectedBorderColor,  focusedBorderColor ),
+			stateColor( indeterminate, hoverIndeterminateBorderColor,    selected, hoverSelectedBorderColor,    hoverBorderColor ),
+			stateColor( indeterminate, pressedIndeterminateBorderColor,  selected, pressedSelectedBorderColor,  pressedBorderColor ) );
 	}
 
-	protected Color getBackground( Component c, boolean selected ) {
+	/** @since 3.6 */
+	protected Color getBackground( Component c, boolean selected, boolean indeterminate ) {
 		return FlatButtonUI.buttonStateColor( c,
-			selected ? selectedBackground : background,
-			(selected && disabledSelectedBackground != null) ? disabledSelectedBackground : disabledBackground,
-			(selected && focusedSelectedBackground != null) ? focusedSelectedBackground : focusedBackground,
-			(selected && hoverSelectedBackground != null) ? hoverSelectedBackground : hoverBackground,
-			(selected && pressedSelectedBackground != null) ? pressedSelectedBackground : pressedBackground );
+			stateColor( indeterminate, indeterminateBackground,          selected, selectedBackground,          background ),
+			stateColor( indeterminate, disabledIndeterminateBackground,  selected, disabledSelectedBackground,  disabledBackground ),
+			stateColor( indeterminate, focusedIndeterminateBackground,   selected, focusedSelectedBackground,   focusedBackground ),
+			stateColor( indeterminate, hoverIndeterminateBackground,     selected, hoverSelectedBackground,     hoverBackground ),
+			stateColor( indeterminate, pressedIndeterminateBackground,   selected, pressedSelectedBackground,   pressedBackground ) );
 	}
 
-	protected Color getCheckmarkColor( Component c ) {
+	/** @since 3.6 */
+	protected Color getCheckmarkColor( Component c, boolean indeterminate ) {
 		return FlatButtonUI.buttonStateColor( c,
-			checkmarkColor,
-			disabledCheckmarkColor,
-			focusedCheckmarkColor,
-			hoverCheckmarkColor,
-			pressedCheckmarkColor );
+			stateColor( indeterminate, indeterminateCheckmarkColor, checkmarkColor ),
+			stateColor( indeterminate, disabledIndeterminateCheckmarkColor, disabledCheckmarkColor ),
+			stateColor( indeterminate, focusedIndeterminateCheckmarkColor, focusedCheckmarkColor ),
+			stateColor( indeterminate, hoverIndeterminateCheckmarkColor, hoverCheckmarkColor ),
+			stateColor( indeterminate, pressedIndeterminateCheckmarkColor, pressedCheckmarkColor ) );
 	}
 }

flatlaf-core/src/main/java/com/formdev/flatlaf/icons/FlatCheckBoxMenuItemIcon.java

@@ -59,6 +59,11 @@ public class FlatCheckBoxMenuItemIcon
 		return FlatStylingSupport.getAnnotatedStyleableInfos( this );
 	}
 
+	/** @since 2.5 */
+	public Object getStyleableValue( String key ) {
+		return FlatStylingSupport.getAnnotatedStyleableValue( this, key );
+	}
+
 	@Override
 	protected void paintIcon( Component c, Graphics2D g2 ) {
 		boolean selected = (c instanceof AbstractButton) && ((AbstractButton)c).isSelected();
@@ -71,7 +76,7 @@ public class FlatCheckBoxMenuItemIcon
 	}
 
 	protected void paintCheckmark( Graphics2D g2 ) {
-		Path2D.Float path = new Path2D.Float();
+		Path2D.Float path = new Path2D.Float( Path2D.WIND_NON_ZERO, 3 );
 		path.moveTo( 4.5f, 7.5f );
 		path.lineTo( 6.6f, 10f );
 		path.lineTo( 11.25f, 3.5f );

flatlaf-core/src/main/java/com/formdev/flatlaf/icons/FlatClearIcon.java

@@ -20,7 +20,6 @@ import java.awt.Color;
 import java.awt.Component;
 import java.awt.Graphics2D;
 import java.awt.geom.Ellipse2D;
-import java.awt.geom.Line2D;
 import java.awt.geom.Path2D;
 import java.util.Map;
 import javax.swing.AbstractButton;
@@ -47,8 +46,16 @@ public class FlatClearIcon
 	@Styleable protected Color clearIconHoverColor = UIManager.getColor( "SearchField.clearIconHoverColor" );
 	@Styleable protected Color clearIconPressedColor = UIManager.getColor( "SearchField.clearIconPressedColor" );
 
+	private final boolean ignoreButtonState;
+
 	public FlatClearIcon() {
+		this( false );
+	}
+
+	/** @since 2 */
+	public FlatClearIcon( boolean ignoreButtonState ) {
 		super( 16, 16, null );
+		this.ignoreButtonState = ignoreButtonState;
 	}
 
 	/** @since 2 */
@@ -61,9 +68,14 @@ public class FlatClearIcon
 		return FlatStylingSupport.getAnnotatedStyleableInfos( this );
 	}
 
+	/** @since 2.5 */
+	public Object getStyleableValue( String key ) {
+		return FlatStylingSupport.getAnnotatedStyleableValue( this, key );
+	}
+
 	@Override
 	protected void paintIcon( Component c, Graphics2D g ) {
-		if( c instanceof AbstractButton ) {
+		if( !ignoreButtonState && c instanceof AbstractButton ) {
 			ButtonModel model = ((AbstractButton)c).getModel();
 			if( model.isPressed() || model.isRollover() ) {
 				/*
@@ -90,9 +102,11 @@ public class FlatClearIcon
 
 		// paint cross
 		g.setColor( clearIconColor );
-		Path2D path = new Path2D.Float( Path2D.WIND_EVEN_ODD );
-		path.append( new Line2D.Float( 5,5, 11,11 ), false );
-		path.append( new Line2D.Float( 5,11, 11,5 ), false );
+		Path2D path = new Path2D.Float( Path2D.WIND_EVEN_ODD, 4 );
+		path.moveTo( 5, 5 );
+		path.lineTo( 11, 11 );
+		path.moveTo( 5, 11 );
+		path.lineTo( 11, 5 );
 		g.draw( path );
 	}
 }

flatlaf-core/src/main/java/com/formdev/flatlaf/icons/FlatFileChooserDetailsViewIcon.java

@@ -39,21 +39,25 @@ public class FlatFileChooserDetailsViewIcon
 		/*
 			<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 16 16">
 			  <g fill="none" fill-rule="evenodd">
-			    <rect width="2" height="2" x="2" y="3" fill="#6E6E6E"/>
-			    <rect width="2" height="2" x="2" y="7" fill="#6E6E6E"/>
-			    <rect width="2" height="2" x="2" y="11" fill="#6E6E6E"/>
-			    <rect width="8" height="2" x="6" y="3" fill="#6E6E6E"/>
-			    <rect width="8" height="2" x="6" y="7" fill="#6E6E6E"/>
-			    <rect width="8" height="2" x="6" y="11" fill="#6E6E6E"/>
+			    <rect width="2" height="1" x="2" y="3" fill="#6E6E6E" rx=".5"/>
+			    <rect width="2" height="1" x="2" y="6" fill="#6E6E6E" rx=".5"/>
+			    <rect width="2" height="1" x="2" y="9" fill="#6E6E6E" rx=".5"/>
+			    <rect width="2" height="1" x="2" y="12" fill="#6E6E6E" rx=".5"/>
+			    <rect width="8" height="1" x="6" y="3" fill="#6E6E6E" rx=".5"/>
+			    <rect width="8" height="1" x="6" y="6" fill="#6E6E6E" rx=".5"/>
+			    <rect width="8" height="1" x="6" y="9" fill="#6E6E6E" rx=".5"/>
+			    <rect width="8" height="1" x="6" y="12" fill="#6E6E6E" rx=".5"/>
 			  </g>
 			</svg>
 		*/
 
-		g.fillRect( 2, 3, 2, 2 );
-		g.fillRect( 2, 7, 2, 2 );
-		g.fillRect( 2, 11, 2, 2 );
-		g.fillRect( 6, 3, 8, 2 );
-		g.fillRect( 6, 7, 8, 2 );
-		g.fillRect( 6, 11, 8, 2 );
+		g.fillRoundRect( 2, 3, 2, 1, 1, 1 );
+		g.fillRoundRect( 2, 6, 2, 1, 1, 1 );
+		g.fillRoundRect( 2, 9, 2, 1, 1, 1 );
+		g.fillRoundRect( 2, 12, 2, 1, 1, 1 );
+		g.fillRoundRect( 6, 3, 8, 1, 1, 1 );
+		g.fillRoundRect( 6, 6, 8, 1, 1, 1 );
+		g.fillRoundRect( 6, 9, 8, 1, 1, 1 );
+		g.fillRoundRect( 6, 12, 8, 1, 1, 1 );
 	}
 }

flatlaf-core/src/main/java/com/formdev/flatlaf/icons/FlatFileChooserHomeFolderIcon.java

@@ -16,8 +16,10 @@
 
 package com.formdev.flatlaf.icons;
 
+import java.awt.BasicStroke;
 import java.awt.Component;
 import java.awt.Graphics2D;
+import java.awt.RenderingHints;
 import javax.swing.UIManager;
 import com.formdev.flatlaf.ui.FlatUIUtils;
 
@@ -39,10 +41,22 @@ public class FlatFileChooserHomeFolderIcon
 	protected void paintIcon( Component c, Graphics2D g ) {
 		/*
 			<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 16 16">
-			  <polygon fill="#6E6E6E" fill-rule="evenodd" points="2 8 8 2 14 8 12 8 12 13 9 13 9 10 7 10 7 13 4 13 4 8"/>
+			  <g fill="none" fill-rule="evenodd">
+			    <polyline stroke="#6E6E6E" stroke-linejoin="round" points="6.5 13 6.5 9.5 9.5 9.5 9.5 13"/>
+			    <path stroke="#6E6E6E" d="M3.5,6.5 L3.5,12.5 C3.5,13.0522847 3.94771525,13.5 4.5,13.5 L11.5,13.5 C12.0522847,13.5 12.5,13.0522847 12.5,12.5 L12.5,6.5 L12.5,6.5"/>
+			    <polyline stroke="#6E6E6E" stroke-linecap="round" stroke-linejoin="round" points="1.5 8.5 8 2 14.5 8.5"/>
+			  </g>
 			</svg>
 		*/
 
-		g.fill( FlatUIUtils.createPath( 2,8, 8,2, 14,8, 12,8, 12,13, 9,13, 9,10, 7,10, 7,13, 4,13, 4,8 ) );
+		g.setRenderingHint( RenderingHints.KEY_STROKE_CONTROL, RenderingHints.VALUE_STROKE_PURE );
+		g.setStroke( new BasicStroke( 1, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND ) );
+
+		g.draw( FlatUIUtils.createPath( false, 6.5,13, 6.5,9.5, 9.5,9.5, 9.5,13 ) );
+		g.draw( FlatUIUtils.createPath( false, 3.5,6.5,
+			3.5,12.5,  FlatUIUtils.QUAD_TO, 3.5,13.5,  4.5,13.5,
+			11.5,13.5, FlatUIUtils.QUAD_TO, 12.5,13.5, 12.5,12.5,
+			12.5,6.5 ) );
+		g.draw( FlatUIUtils.createPath( false, 1.5,8.5, 8,2, 14.5,8.5 ) );
 	}
 }

flatlaf-core/src/main/java/com/formdev/flatlaf/icons/FlatFileChooserListViewIcon.java

@@ -16,8 +16,11 @@
 
 package com.formdev.flatlaf.icons;
 
+import java.awt.BasicStroke;
 import java.awt.Component;
 import java.awt.Graphics2D;
+import java.awt.RenderingHints;
+import java.awt.geom.RoundRectangle2D;
 import javax.swing.UIManager;
 
 /**
@@ -39,17 +42,20 @@ public class FlatFileChooserListViewIcon
 		/*
 			<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 16 16">
 			  <g fill="none" fill-rule="evenodd">
-			    <rect width="4" height="4" x="3" y="3" fill="#6E6E6E"/>
-			    <rect width="4" height="4" x="3" y="9" fill="#6E6E6E"/>
-			    <rect width="4" height="4" x="9" y="9" fill="#6E6E6E"/>
-			    <rect width="4" height="4" x="9" y="3" fill="#6E6E6E"/>
+			    <rect width="4" height="4" x="2.5" y="2.5" stroke="#6E6E6E" rx="1.5"/>
+			    <rect width="4" height="4" x="2.5" y="9.5" stroke="#6E6E6E" rx="1.5"/>
+			    <rect width="4" height="4" x="9.5" y="9.5" stroke="#6E6E6E" rx="1.5"/>
+			    <rect width="4" height="4" x="9.5" y="2.5" stroke="#6E6E6E" rx="1.5"/>
 			  </g>
 			</svg>
 		*/
 
-		g.fillRect( 3, 3, 4, 4 );
-		g.fillRect( 3, 9, 4, 4 );
-		g.fillRect( 9, 9, 4, 4 );
-		g.fillRect( 9, 3, 4, 4 );
+		g.setRenderingHint( RenderingHints.KEY_STROKE_CONTROL, RenderingHints.VALUE_STROKE_PURE );
+		g.setStroke( new BasicStroke( 1, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND ) );
+
+		g.draw( new RoundRectangle2D.Float( 2.5f, 2.5f, 4, 4, 2, 2 ) );
+		g.draw( new RoundRectangle2D.Float( 2.5f, 9.5f, 4, 4, 2, 2 ) );
+		g.draw( new RoundRectangle2D.Float( 9.5f, 9.5f, 4, 4, 2, 2 ) );
+		g.draw( new RoundRectangle2D.Float( 9.5f, 2.5f, 4, 4, 2, 2 ) );
 	}
 }

flatlaf-core/src/main/java/com/formdev/flatlaf/icons/FlatFileChooserNewFolderIcon.java

@@ -16,10 +16,13 @@
 
 package com.formdev.flatlaf.icons;
 
+import java.awt.BasicStroke;
+import java.awt.Color;
 import java.awt.Component;
 import java.awt.Graphics2D;
+import java.awt.RenderingHints;
+import java.awt.geom.Line2D;
 import javax.swing.UIManager;
-import com.formdev.flatlaf.ui.FlatUIUtils;
 
 /**
  * "new folder" icon for {@link javax.swing.JFileChooser}.
@@ -31,6 +34,8 @@ import com.formdev.flatlaf.ui.FlatUIUtils;
 public class FlatFileChooserNewFolderIcon
 	extends FlatAbstractIcon
 {
+	private final Color greenColor = UIManager.getColor( "Actions.Green" );
+
 	public FlatFileChooserNewFolderIcon() {
 		super( 16, 16, UIManager.getColor( "Actions.Grey" ) );
 	}
@@ -40,13 +45,20 @@ public class FlatFileChooserNewFolderIcon
 		/*
 			<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 16 16">
 			  <g fill="none" fill-rule="evenodd">
-			    <polygon fill="#6E6E6E" points="2 3 5.5 3 7 5 14 5 14 8 11 8 11 10 9 10 9 13 2 13"/>
-			    <path fill="#59A869" d="M14,11 L16,11 L16,13 L14,13 L14,15 L12,15 L12,13 L10,13 L10,11 L12,11 L12,9 L14,9 L14,11 Z"/>
+			    <path stroke="#6E6E6E" d="M13,13.5 L3,13.5 C2.17157288,13.5 1.5,12.8284271 1.5,12 L1.5,4 C1.5,3.17157288 2.17157288,2.5 3,2.5 L6.29289322,2.5 C6.42550146,2.5 6.55267842,2.55267842 6.64644661,2.64644661 L8.5,4.5 L8.5,4.5 L13,4.5 C13.8284271,4.5 14.5,5.17157288 14.5,6 L14.5,12 C14.5,12.8284271 13.8284271,13.5 13,13.5 Z"/>
+			    <line x1="5.5" x2="10.5" y1="9" y2="9" stroke="#59A869" stroke-linecap="round"/>
+			    <line x1="8" x2="8" y1="6.5" y2="11.5" stroke="#59A869" stroke-linecap="round"/>
 			  </g>
 			</svg>
 		*/
 
-		g.fill( FlatUIUtils.createPath( 2,3, 5.5,3, 7,5, 14,5, 14,8, 11,8, 11,10, 9,10, 9,13, 2,13 ) );
-		g.fill( FlatUIUtils.createPath( 14,11, 16,11, 16,13, 14,13, 14,15, 12,15, 12,13, 10,13, 10,11, 12,11, 12,9, 14,9, 14,11 ) );
+		g.setRenderingHint( RenderingHints.KEY_STROKE_CONTROL, RenderingHints.VALUE_STROKE_PURE );
+		g.setStroke( new BasicStroke( 1, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND ) );
+
+		g.draw( FlatFileViewDirectoryIcon.createFolderPath() );
+
+		g.setColor( greenColor );
+		g.draw( new Line2D.Float( 5.5f, 9, 10.5f, 9 ) );
+		g.draw( new Line2D.Float( 8, 6.5f, 8, 11.5f ) );
 	}
 }

flatlaf-core/src/main/java/com/formdev/flatlaf/icons/FlatFileChooserUpFolderIcon.java

@@ -16,9 +16,12 @@
 
 package com.formdev.flatlaf.icons;
 
+import java.awt.BasicStroke;
 import java.awt.Color;
 import java.awt.Component;
 import java.awt.Graphics2D;
+import java.awt.RenderingHints;
+import java.awt.geom.Line2D;
 import javax.swing.UIManager;
 import com.formdev.flatlaf.ui.FlatUIUtils;
 
@@ -44,15 +47,20 @@ public class FlatFileChooserUpFolderIcon
 		/*
 			<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 16 16">
 			  <g fill="none" fill-rule="evenodd">
-			    <polygon fill="#6E6E6E" points="2 3 5.5 3 7 5 9 5 9 9 13 9 13 5 14 5 14 13 2 13"/>
-			    <path fill="#389FD6" d="M12,4 L12,8 L10,8 L10,4 L8,4 L11,1 L14,4 L12,4 Z"/>
+			    <path stroke="#6E6E6E" d="M13,13.5 L3,13.5 C2.17157288,13.5 1.5,12.8284271 1.5,12 L1.5,4 C1.5,3.17157288 2.17157288,2.5 3,2.5 L6.29289322,2.5 C6.42550146,2.5 6.55267842,2.55267842 6.64644661,2.64644661 L8.5,4.5 L8.5,4.5 L13,4.5 C13.8284271,4.5 14.5,5.17157288 14.5,6 L14.5,12 C14.5,12.8284271 13.8284271,13.5 13,13.5 Z"/>
+			    <line x1="8" x2="8" y1="6.5" y2="11.5" stroke="#389FD6" stroke-linecap="round"/>
+			    <polyline stroke="#389FD6" stroke-linecap="round" stroke-linejoin="round" points="5.5 9 8 6.5 10.5 9"/>
 			  </g>
 			</svg>
 		*/
 
-		g.fill( FlatUIUtils.createPath( 2,3, 5.5,3, 7,5, 9,5, 9,9, 13,9, 13,5, 14,5, 14,13, 2,13 ) );
+		g.setRenderingHint( RenderingHints.KEY_STROKE_CONTROL, RenderingHints.VALUE_STROKE_PURE );
+		g.setStroke( new BasicStroke( 1, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND ) );
+
+		g.draw( FlatFileViewDirectoryIcon.createFolderPath() );
 
 		g.setColor( blueColor );
-		g.fill( FlatUIUtils.createPath( 12,4, 12,8, 10,8, 10,4, 8,4, 11,1, 14,4, 12,4 ) );
+		g.draw( new Line2D.Float( 8, 6.5f, 8, 11.5f ) );
+		g.draw( FlatUIUtils.createPath( false, 5.5,9, 8,6.5, 10.5,9 ) );
 	}
 }

flatlaf-core/src/main/java/com/formdev/flatlaf/icons/FlatFileViewComputerIcon.java

@@ -16,10 +16,12 @@
 
 package com.formdev.flatlaf.icons;
 
+import java.awt.BasicStroke;
 import java.awt.Component;
 import java.awt.Graphics2D;
-import java.awt.geom.Path2D;
-import java.awt.geom.Rectangle2D;
+import java.awt.RenderingHints;
+import java.awt.geom.Line2D;
+import java.awt.geom.RoundRectangle2D;
 import javax.swing.UIManager;
 
 /**
@@ -41,17 +43,18 @@ public class FlatFileViewComputerIcon
 		/*
 			<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 16 16">
 			  <g fill="none" fill-rule="evenodd">
-			    <path fill="#6E6E6E" d="M2,3 L14,3 L14,11 L2,11 L2,3 Z M4,5 L4,9 L12,9 L12,5 L4,5 Z"/>
-			    <rect width="12" height="2" x="2" y="12" fill="#6E6E6E"/>
+			    <rect width="11" height="7" x="2.5" y="3.5" stroke="#6E6E6E" rx="1"/>
+			    <line x1="8" x2="8" y1="11" y2="12" stroke="#6E6E6E"/>
+			    <line x1="4.5" x2="11.5" y1="12.5" y2="12.5" stroke="#6E6E6E" stroke-linecap="round"/>
 			  </g>
 			</svg>
 		*/
 
-		Path2D path = new Path2D.Float( Path2D.WIND_EVEN_ODD );
-		path.append( new Rectangle2D.Float( 2, 3, 12, 8 ), false );
-		path.append( new Rectangle2D.Float( 4, 5, 8, 4 ), false );
-		g.fill( path );
+		g.setRenderingHint( RenderingHints.KEY_STROKE_CONTROL, RenderingHints.VALUE_STROKE_PURE );
+		g.setStroke( new BasicStroke( 1, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND ) );
 
-		g.fillRect( 2, 12, 12, 2 );
+		g.draw( new RoundRectangle2D.Float( 2.5f, 3.5f, 11, 7, 2, 2 ) );
+		g.drawLine( 8, 11, 8, 12 );
+		g.draw( new Line2D.Float( 4.5f, 12.5f, 11.5f, 12.5f ) );
 	}
 }

flatlaf-core/src/main/java/com/formdev/flatlaf/icons/FlatFileViewDirectoryIcon.java

@@ -18,6 +18,8 @@ package com.formdev.flatlaf.icons;
 
 import java.awt.Component;
 import java.awt.Graphics2D;
+import java.awt.RenderingHints;
+import java.awt.geom.Path2D;
 import javax.swing.UIManager;
 import com.formdev.flatlaf.ui.FlatUIUtils;
 
@@ -31,6 +33,8 @@ import com.formdev.flatlaf.ui.FlatUIUtils;
 public class FlatFileViewDirectoryIcon
 	extends FlatAbstractIcon
 {
+	private Path2D path;
+
 	public FlatFileViewDirectoryIcon() {
 		super( 16, 16, UIManager.getColor( "Objects.Grey" ) );
 	}
@@ -39,10 +43,32 @@ public class FlatFileViewDirectoryIcon
 	protected void paintIcon( Component c, Graphics2D g ) {
 		/*
 			<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 16 16">
-			  <polygon fill="#6E6E6E" fill-rule="evenodd" points="1 2 6 2 8 4 15 4 15 13 1 13"/>
+			  <path fill="none" stroke="#6E6E6E" d="M13,13.5 L3,13.5 C2.17157288,13.5 1.5,12.8284271 1.5,12 L1.5,4 C1.5,3.17157288 2.17157288,2.5 3,2.5 L6.29289322,2.5 C6.42550146,2.5 6.55267842,2.55267842 6.64644661,2.64644661 L8.5,4.5 L8.5,4.5 L13,4.5 C13.8284271,4.5 14.5,5.17157288 14.5,6 L14.5,12 C14.5,12.8284271 13.8284271,13.5 13,13.5 Z"/>
 			</svg>
 		*/
 
-		g.fill( FlatUIUtils.createPath( 1,2, 6,2, 8,4, 15,4, 15,13, 1,13 ) );
+		g.setRenderingHint( RenderingHints.KEY_STROKE_CONTROL, RenderingHints.VALUE_STROKE_PURE );
+
+		if( path == null )
+			path = createFolderPath();
+		g.draw( path );
+	}
+
+	static Path2D createFolderPath() {
+		double arc = 1.5;
+		double arc2 = 0.5;
+		return FlatUIUtils.createPath(
+			// bottom-right
+			14.5,13.5-arc,  FlatUIUtils.QUAD_TO, 14.5,13.5, 14.5-arc,13.5,
+			// bottom-left
+			1.5+arc,13.5,   FlatUIUtils.QUAD_TO, 1.5,13.5,  1.5,13.5-arc,
+			// top-left
+			1.5,2.5+arc,    FlatUIUtils.QUAD_TO, 1.5,2.5,   1.5+arc,2.5,
+			// top-mid-left
+			6.5-arc2,2.5,   FlatUIUtils.QUAD_TO, 6.5,2.5,   6.5+arc2,2.5+arc2,
+			// top-mid-right
+			8.5,4.5,
+			// top-right
+			14.5-arc,4.5,   FlatUIUtils.QUAD_TO, 14.5,4.5,  14.5,4.5+arc );
 	}
 }

flatlaf-core/src/main/java/com/formdev/flatlaf/icons/FlatFileViewFileIcon.java

@@ -16,8 +16,11 @@
 
 package com.formdev.flatlaf.icons;
 
+import java.awt.BasicStroke;
 import java.awt.Component;
 import java.awt.Graphics2D;
+import java.awt.RenderingHints;
+import java.awt.geom.Path2D;
 import javax.swing.UIManager;
 import com.formdev.flatlaf.ui.FlatUIUtils;
 
@@ -31,6 +34,8 @@ import com.formdev.flatlaf.ui.FlatUIUtils;
 public class FlatFileViewFileIcon
 	extends FlatAbstractIcon
 {
+	private Path2D path;
+
 	public FlatFileViewFileIcon() {
 		super( 16, 16, UIManager.getColor( "Objects.Grey" ) );
 	}
@@ -39,14 +44,33 @@ public class FlatFileViewFileIcon
 	protected void paintIcon( Component c, Graphics2D g ) {
 		/*
 			<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 16 16">
-			  <g fill="none" fill-rule="evenodd">
-			    <polygon fill="#6E6E6E" points="8 6 8 1 13 1 13 15 3 15 3 6"/>
-			    <polygon fill="#6E6E6E" points="3 5 7 5 7 1"/>
+			  <g fill="none" fill-rule="evenodd" stroke-linejoin="round">
+			    <path stroke="#6E6E6E" d="M4,1.5 L8.8,1.5 L8.8,1.5 L13.5,6.2 L13.5,13 C13.5,13.8284271 12.8284271,14.5 12,14.5 L4,14.5 C3.17157288,14.5 2.5,13.8284271 2.5,13 L2.5,3 C2.5,2.17157288 3.17157288,1.5 4,1.5 Z"/>
+			    <path stroke="#6E6E6E" d="M8.5,2 L8.5,5 C8.5,5.82842712 9.17157288,6.5 10,6.5 L13,6.5 L13,6.5"/>
 			  </g>
 			</svg>
 		*/
 
-		g.fill( FlatUIUtils.createPath( 8,6, 8,1, 13,1, 13,15, 3,15, 3,6 ) );
-		g.fill( FlatUIUtils.createPath( 3,5, 7,5, 7,1 ) );
+		g.setRenderingHint( RenderingHints.KEY_STROKE_CONTROL, RenderingHints.VALUE_STROKE_PURE );
+		g.setStroke( new BasicStroke( 1, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND ) );
+
+		if( path == null ) {
+			double arc = 1.5;
+			path = FlatUIUtils.createPath( false,
+				// top-left
+				2.5,1.5+arc,    FlatUIUtils.QUAD_TO, 2.5,1.5,   2.5+arc,1.5,
+				// top-right
+				8.8,1.5, 13.5,6.2,
+				// bottom-right
+				13.5,14.5-arc,  FlatUIUtils.QUAD_TO, 13.5,14.5, 13.5-arc,14.5,
+				// bottom-left
+				2.5+arc,14.5,   FlatUIUtils.QUAD_TO, 2.5,14.5,  2.5,14.5-arc,
+				FlatUIUtils.CLOSE_PATH,
+
+				FlatUIUtils.MOVE_TO, 8.5,2,
+				8.5,6.5-arc,    FlatUIUtils.QUAD_TO, 8.5,6.5,   8.5+arc,6.5,
+				13,6.5 );
+		}
+		g.draw( path );
 	}
 }

flatlaf-core/src/main/java/com/formdev/flatlaf/icons/FlatFileViewFloppyDriveIcon.java

@@ -16,9 +16,10 @@
 
 package com.formdev.flatlaf.icons;
 
+import java.awt.BasicStroke;
 import java.awt.Component;
 import java.awt.Graphics2D;
-import java.awt.geom.Path2D;
+import java.awt.RenderingHints;
 import javax.swing.UIManager;
 import com.formdev.flatlaf.ui.FlatUIUtils;
 
@@ -40,18 +41,22 @@ public class FlatFileViewFloppyDriveIcon
 	protected void paintIcon( Component c, Graphics2D g ) {
 		/*
 			<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 16 16">
-			  <g fill="none" fill-rule="evenodd">
-			    <path fill="#6E6E6E" d="M11,14 L11,11 L5,11 L5,14 L2,14 L2,2 L14,2 L14,14 L11,14 Z M4,4 L4,8 L12,8 L12,4 L4,4 Z"/>
-			    <rect width="4" height="2" x="6" y="12" fill="#6E6E6E"/>
+			  <g fill="none" fill-rule="evenodd" stroke-linejoin="round">
+			    <path stroke="#6E6E6E" d="M3.5,2.5 L11.5,2.5 L11.5,2.5 L13.5,4.5 L13.5,12.5 C13.5,13.0522847 13.0522847,13.5 12.5,13.5 L3.5,13.5 C2.94771525,13.5 2.5,13.0522847 2.5,12.5 L2.5,3.5 C2.5,2.94771525 2.94771525,2.5 3.5,2.5 Z"/>
+			    <polyline stroke="#6E6E6E" points="4.5 13 4.5 9.5 11.5 9.5 11.5 13"/>
+			    <polyline stroke="#6E6E6E" points="5.5 3 5.5 5.5 10.5 5.5 10.5 3"/>
 			  </g>
 			</svg>
 		*/
 
-		Path2D path = new Path2D.Float( Path2D.WIND_EVEN_ODD );
-		path.append( FlatUIUtils.createPath( 11,14, 11,11, 5,11, 5,14, 2,14, 2,2, 14,2, 14,14, 11,14 ), false );
-		path.append( FlatUIUtils.createPath( 4,4, 4,8, 12,8, 12,4, 4,4 ), false );
-		g.fill( path );
+		g.setRenderingHint( RenderingHints.KEY_STROKE_CONTROL, RenderingHints.VALUE_STROKE_PURE );
+		g.setStroke( new BasicStroke( 1, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND ) );
 
-		g.fillRect( 6, 12, 4, 2 );
+		g.draw( FlatUIUtils.createPath( 3.5,2.5, 11.5,2.5, 11.5,2.5, 13.5,4.5,
+			13.5,12.5, FlatUIUtils.QUAD_TO, 13.5,13.5, 12.5,13.5,
+			3.5,13.5,  FlatUIUtils.QUAD_TO, 2.5,13.5,  2.5,12.5,
+			2.5,3.5,   FlatUIUtils.QUAD_TO, 2.5,2.5,   3.5,2.5 ) );
+		g.draw( FlatUIUtils.createPath( false, 4.5,13, 4.5,9.5, 11.5,9.5, 11.5,13 ) );
+		g.draw( FlatUIUtils.createPath( false, 5.5,3, 5.5,5.5, 10.5,5.5, 10.5,3 ) );
 	}
 }

flatlaf-core/src/main/java/com/formdev/flatlaf/icons/FlatFileViewHardDriveIcon.java

@@ -16,10 +16,12 @@
 
 package com.formdev.flatlaf.icons;
 
+import java.awt.BasicStroke;
 import java.awt.Component;
 import java.awt.Graphics2D;
-import java.awt.geom.Path2D;
-import java.awt.geom.Rectangle2D;
+import java.awt.RenderingHints;
+import java.awt.geom.Ellipse2D;
+import java.awt.geom.RoundRectangle2D;
 import javax.swing.UIManager;
 
 /**
@@ -40,14 +42,19 @@ public class FlatFileViewHardDriveIcon
 	protected void paintIcon( Component c, Graphics2D g ) {
 		/*
 			<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 16 16">
-			  <path fill="#6E6E6E" fill-rule="evenodd" d="M2,6 L14,6 L14,10 L2,10 L2,6 Z M12,8 L12,9 L13,9 L13,8 L12,8 Z M10,8 L10,9 L11,9 L11,8 L10,8 Z"/>
+			  <g fill="none" fill-rule="evenodd">
+			    <rect width="11" height="5" x="2.5" y="5.5" stroke="#6E6E6E" rx="1"/>
+			    <circle cx="11.5" cy="8.5" r="1" fill="#6E6E6E"/>
+			    <circle cx="9.5" cy="8.5" r="1" fill="#6E6E6E"/>
+			  </g>
 			</svg>
 		*/
 
-		Path2D path = new Path2D.Float( Path2D.WIND_EVEN_ODD );
-		path.append( new Rectangle2D.Float( 2, 6, 12, 4 ), false );
-		path.append( new Rectangle2D.Float( 12, 8, 1, 1 ), false );
-		path.append( new Rectangle2D.Float( 10, 8, 1, 1 ), false );
-		g.fill( path );
+		g.setRenderingHint( RenderingHints.KEY_STROKE_CONTROL, RenderingHints.VALUE_STROKE_PURE );
+		g.setStroke( new BasicStroke( 1, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND ) );
+
+		g.draw( new RoundRectangle2D.Float( 2.5f, 5.5f, 11, 5, 2, 2 ) );
+		g.fill( new Ellipse2D.Float( 10.8f, 7.8f, 1.4f, 1.4f ) );
+		g.fill( new Ellipse2D.Float( 8.8f, 7.8f, 1.4f, 1.4f ) );
 	}
 }

flatlaf-core/src/main/java/com/formdev/flatlaf/icons/FlatHelpButtonIcon.java

@@ -17,9 +17,11 @@
 package com.formdev.flatlaf.icons;
 
 import static com.formdev.flatlaf.util.UIScale.*;
+import java.awt.BasicStroke;
 import java.awt.Color;
 import java.awt.Component;
 import java.awt.Graphics2D;
+import java.awt.RenderingHints;
 import java.awt.geom.Ellipse2D;
 import java.awt.geom.Path2D;
 import java.util.Map;
@@ -84,6 +86,11 @@ public class FlatHelpButtonIcon
 		return FlatStylingSupport.getAnnotatedStyleableInfos( this );
 	}
 
+	/** @since 2.5 */
+	public Object getStyleableValue( String key ) {
+		return FlatStylingSupport.getAnnotatedStyleableValue( this, key );
+	}
+
 	@Override
 	protected void paintIcon( Component c, Graphics2D g2 ) {
 		/*
@@ -91,13 +98,14 @@ public class FlatHelpButtonIcon
 			  <g fill="none" fill-rule="evenodd">
 			    <circle cx="11" cy="11" r="10.5" fill="#6E6E6E"/>
 			    <circle cx="11" cy="11" r="9.5" fill="#FFF"/>
-			    <path fill="#6E6E6E" d="M10,17 L12,17 L12,15 L10,15 L10,17 Z M11,5 C8.8,5 7,6.8 7,9 L9,9 C9,7.9 9.9,7 11,7 C12.1,7 13,7.9 13,9 C13,11 10,10.75 10,14 L12,14 C12,11.75 15,11.5 15,9 C15,6.8 13.2,5 11,5 Z"/>
+			    <path stroke="#6E6E6E" stroke-linecap="round" stroke-width="2" d="M8,8.5 C8.25,7 9.66585007,6 11,6 C12.5,6 14,7 14,8.5 C14,10.5 11,11 11,13"/>
+			    <circle cx="11" cy="16" r="1.2" fill="#6E6E6E"/>
 			  </g>
 			</svg>
 		*/
 
-		boolean enabled = c.isEnabled();
-		boolean focused = FlatUIUtils.isPermanentFocusOwner( c );
+		boolean enabled = c == null || c.isEnabled();
+		boolean focused = c != null && FlatUIUtils.isPermanentFocusOwner( c );
 
 		float xy = 0.5f;
 		float wh = iconSize() - 1;
@@ -142,22 +150,19 @@ public class FlatHelpButtonIcon
 		g2.fill( new Ellipse2D.Float( xy, xy, wh, wh ) );
 
 		// paint question mark
-		Path2D q = new Path2D.Float();
-		q.moveTo( 11, 5 );
-		q.curveTo( 8.8,5, 7,6.8, 7,9 );
-		q.lineTo( 9, 9 );
-		q.curveTo( 9,7.9, 9.9,7, 11,7 );
-		q.curveTo( 12.1,7, 13,7.9, 13,9 );
-		q.curveTo( 13,11, 10,10.75, 10,14 );
-		q.lineTo( 12, 14 );
-		q.curveTo( 12,11.75, 15,11.5, 15,9 );
-		q.curveTo( 15,6.8, 13.2,5, 11,5 );
-		q.closePath();
+		Path2D q = new Path2D.Float( Path2D.WIND_NON_ZERO, 10 );
+		q.moveTo( 8,8.5 );
+		q.curveTo( 8.25,7, 9.66585007,6, 11,6 );
+		q.curveTo( 12.5,6, 14,7, 14,8.5 );
+		q.curveTo( 14,10.5, 11,11, 11,13 );
+
+		g2.setRenderingHint( RenderingHints.KEY_STROKE_CONTROL, RenderingHints.VALUE_STROKE_PURE );
+		g2.setStroke( new BasicStroke( 2, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND ) );
 
 		g2.translate( focusWidth, focusWidth );
 		g2.setColor( enabled ? questionMarkColor : disabledQuestionMarkColor );
-		g2.fill( q );
-		g2.fillRect( 10, 15, 2, 2 );
+		g2.draw( q );
+		g2.fill( new Ellipse2D.Float( 9.8f, 14.8f, 2.4f, 2.4f ) );
 	}
 
 	@Override

flatlaf-core/src/main/java/com/formdev/flatlaf/icons/FlatInternalFrameCloseIcon.java

@@ -20,7 +20,6 @@ import java.awt.BasicStroke;
 import java.awt.Color;
 import java.awt.Component;
 import java.awt.Graphics2D;
-import java.awt.geom.Line2D;
 import java.awt.geom.Path2D;
 import javax.swing.UIManager;
 import com.formdev.flatlaf.ui.FlatButtonUI;
@@ -54,13 +53,15 @@ public class FlatInternalFrameCloseIcon
 
 		g.setColor( FlatButtonUI.buttonStateColor( c, c.getForeground(), null, null, hoverForeground, pressedForeground ) );
 
-		float mx = width / 2;
-		float my = height / 2;
+		float mx = width / 2f;
+		float my = height / 2f;
 		float r = 3.25f;
 
-		Path2D path = new Path2D.Float( Path2D.WIND_EVEN_ODD );
-		path.append( new Line2D.Float( mx - r, my - r, mx + r, my + r ), false );
-		path.append( new Line2D.Float( mx - r, my + r, mx + r, my - r ), false );
+		Path2D path = new Path2D.Float( Path2D.WIND_EVEN_ODD, 4 );
+		path.moveTo( mx - r, my - r );
+		path.lineTo( mx + r, my + r );
+		path.moveTo( mx - r, my + r );
+		path.lineTo( mx + r, my - r );
 		g.setStroke( new BasicStroke( 1f ) );
 		g.draw( path );
 	}

flatlaf-core/src/main/java/com/formdev/flatlaf/icons/FlatMenuArrowIcon.java

@@ -61,9 +61,14 @@ public class FlatMenuArrowIcon
 		return FlatStylingSupport.getAnnotatedStyleableInfos( this );
 	}
 
+	/** @since 2.5 */
+	public Object getStyleableValue( String key ) {
+		return FlatStylingSupport.getAnnotatedStyleableValue( this, key );
+	}
+
 	@Override
 	protected void paintIcon( Component c, Graphics2D g ) {
-		if( !c.getComponentOrientation().isLeftToRight() )
+		if( c != null && !c.getComponentOrientation().isLeftToRight() )
 			g.rotate( Math.toRadians( 180 ), width / 2., height / 2. );
 
 		g.setColor( getArrowColor( c ) );
@@ -82,7 +87,7 @@ public class FlatMenuArrowIcon
 		if( c instanceof JMenu && ((JMenu)c).isSelected() && !isUnderlineSelection() )
 			return selectionForeground;
 
-		return c.isEnabled() ? arrowColor : disabledArrowColor;
+		return c == null || c.isEnabled() ? arrowColor : disabledArrowColor;
 	}
 
 	protected boolean isUnderlineSelection() {

flatlaf-core/src/main/java/com/formdev/flatlaf/icons/FlatMenuItemArrowIcon.java

@@ -21,14 +21,16 @@ import java.awt.Graphics;
 import java.awt.Graphics2D;
 
 /**
- * "arrow" icon for {@link javax.swing.JMenuItem}.
+ * "arrow" icon for {@link javax.swing.JMenuItem}, {@link javax.swing.JCheckBoxMenuItem}
+ * and {@link javax.swing.JRadioButtonMenuItem}.
  *
  * @author Karl Tauber
  */
 public class FlatMenuItemArrowIcon
-	extends FlatMenuArrowIcon
+	extends FlatAbstractIcon
 {
 	public FlatMenuItemArrowIcon() {
+		super( 6, 10, null );
 	}
 
 	@Override

flatlaf-core/src/main/java/com/formdev/flatlaf/icons/FlatOptionPaneErrorIcon.java

@@ -19,7 +19,7 @@ package com.formdev.flatlaf.icons;
 import java.awt.Shape;
 import java.awt.geom.Ellipse2D;
 import java.awt.geom.Path2D;
-import java.awt.geom.Rectangle2D;
+import java.awt.geom.RoundRectangle2D;
 
 /**
  * "Error" icon for {@link javax.swing.JOptionPane}.
@@ -40,8 +40,8 @@ public class FlatOptionPaneErrorIcon
 		<svg xmlns="http://www.w3.org/2000/svg" width="32" height="32" viewBox="0 0 32 32">
 		  <g fill="none" fill-rule="evenodd">
 		    <circle cx="16" cy="16" r="14" fill="#DB5860"/>
-		    <rect width="4" height="11" x="14" y="7" fill="#FFF"/>
-		    <rect width="4" height="4" x="14" y="21" fill="#FFF"/>
+		    <rect width="4" height="12" x="14" y="7" fill="#FFF" rx="2"/>
+		    <circle cx="16" cy="23" r="2" fill="#FFF"/>
 		  </g>
 		</svg>
 	*/
@@ -54,8 +54,8 @@ public class FlatOptionPaneErrorIcon
 	@Override
 	protected Shape createInside() {
 		Path2D inside = new Path2D.Float( Path2D.WIND_EVEN_ODD );
-		inside.append( new Rectangle2D.Float( 14, 7, 4, 11 ), false );
-		inside.append( new Rectangle2D.Float( 14, 21, 4, 4 ), false );
+		inside.append( new RoundRectangle2D.Float( 14, 7, 4, 12, 4, 4 ), false );
+		inside.append( new Ellipse2D.Float( 14, 21, 4, 4 ), false );
 		return inside;
 	}
 }

flatlaf-core/src/main/java/com/formdev/flatlaf/icons/FlatOptionPaneInformationIcon.java

@@ -19,7 +19,7 @@ package com.formdev.flatlaf.icons;
 import java.awt.Shape;
 import java.awt.geom.Ellipse2D;
 import java.awt.geom.Path2D;
-import java.awt.geom.Rectangle2D;
+import java.awt.geom.RoundRectangle2D;
 
 /**
  * "Information" icon for {@link javax.swing.JOptionPane}.
@@ -40,8 +40,8 @@ public class FlatOptionPaneInformationIcon
 		<svg xmlns="http://www.w3.org/2000/svg" width="32" height="32" viewBox="0 0 32 32">
 		  <g fill="none" fill-rule="evenodd">
 		    <circle cx="16" cy="16" r="14" fill="#389FD6"/>
-		    <rect width="4" height="11" x="14" y="14" fill="#FFF"/>
-		    <rect width="4" height="4" x="14" y="7" fill="#FFF"/>
+		    <rect width="4" height="12" x="14" y="13" fill="#FFF" rx="2"/>
+		    <circle cx="16" cy="9" r="2" fill="#FFF"/>
 		  </g>
 		</svg>
 	*/
@@ -54,8 +54,8 @@ public class FlatOptionPaneInformationIcon
 	@Override
 	protected Shape createInside() {
 		Path2D inside = new Path2D.Float( Path2D.WIND_EVEN_ODD );
-		inside.append( new Rectangle2D.Float( 14, 14, 4, 11 ), false );
-		inside.append( new Rectangle2D.Float( 14, 7, 4, 4 ), false );
+		inside.append( new RoundRectangle2D.Float( 14, 13, 4, 12, 4, 4 ), false );
+		inside.append( new Ellipse2D.Float( 14, 7, 4, 4 ), false );
 		return inside;
 	}
 }

flatlaf-core/src/main/java/com/formdev/flatlaf/icons/FlatOptionPaneQuestionIcon.java

@@ -16,10 +16,10 @@
 
 package com.formdev.flatlaf.icons;
 
+import java.awt.BasicStroke;
 import java.awt.Shape;
 import java.awt.geom.Ellipse2D;
 import java.awt.geom.Path2D;
-import java.awt.geom.Rectangle2D;
 
 /**
  * "Question" icon for {@link javax.swing.JOptionPane}.
@@ -40,8 +40,8 @@ public class FlatOptionPaneQuestionIcon
 		<svg xmlns="http://www.w3.org/2000/svg" width="32" height="32" viewBox="0 0 32 32">
 		  <g fill="none" fill-rule="evenodd">
 		    <circle cx="16" cy="16" r="14" fill="#389FD6"/>
-		    <rect width="4" height="4" x="14" y="22" fill="#FFF"/>
-		    <path fill="#FFF" d="M14,20 C14,20 18,20 18,20 C18,16 23,16 23,12 C23,8 20,6 16,6 C12,6 9,8 9,12 C9,12 13,12 13,12 C13,10 14,9 16,9 C18,9 19,10 19,12 C19,15 14,15 14,20 Z"/>
+		    <circle cx="16" cy="24" r="1.7" fill="#FFF"/>
+		    <path stroke="#FFF" stroke-linecap="round" stroke-width="3" d="M11.5,11.75 C11.75,9.5 13.75,8 16,8 C18.25,8 20.5,9.5 20.5,11.75 C20.5,14.75 16,15.5 16,19"/>
 		  </g>
 		</svg>
 	*/
@@ -53,21 +53,17 @@ public class FlatOptionPaneQuestionIcon
 
 	@Override
 	protected Shape createInside() {
-		Path2D q = new Path2D.Float();
-		q.moveTo( 14, 20 );
-		q.lineTo( 18, 20 );
-		q.curveTo( 18, 16, 23, 16, 23, 12 );
-		q.curveTo( 23, 8, 20, 6, 16, 6 );
-		q.curveTo( 12, 6, 9, 8, 9, 12 );
-		q.curveTo( 9, 12, 13, 12, 13, 12 );
-		q.curveTo( 13, 10, 14, 9, 16, 9 );
-		q.curveTo( 18, 9, 19, 10, 19, 12 );
-		q.curveTo( 19, 15, 14, 15, 14, 20 );
-		q.closePath();
+		Path2D q = new Path2D.Float( Path2D.WIND_NON_ZERO, 10 );
+		q.moveTo( 11.5,11.75 );
+		q.curveTo( 11.75,9.5, 13.75,8, 16,8 );
+		q.curveTo( 18.25,8, 20.5,9.5, 20.5,11.75 );
+		q.curveTo( 20.5,14.75, 16,15.5, 16,19 );
+
+		BasicStroke stroke = new BasicStroke( 3, BasicStroke.CAP_ROUND, BasicStroke.JOIN_MITER );
 
 		Path2D inside = new Path2D.Float( Path2D.WIND_EVEN_ODD );
-		inside.append( new Rectangle2D.Float( 14, 22, 4, 4 ), false );
-		inside.append( q, false );
+		inside.append( new Ellipse2D.Float( 14.3f, 22.3f, 3.4f, 3.4f ), false );
+		inside.append( stroke.createStrokedShape( q ), false );
 		return inside;
 	}
 }

flatlaf-core/src/main/java/com/formdev/flatlaf/icons/FlatOptionPaneWarningIcon.java

@@ -17,8 +17,9 @@
 package com.formdev.flatlaf.icons;
 
 import java.awt.Shape;
+import java.awt.geom.Ellipse2D;
 import java.awt.geom.Path2D;
-import java.awt.geom.Rectangle2D;
+import java.awt.geom.RoundRectangle2D;
 import com.formdev.flatlaf.ui.FlatUIUtils;
 
 /**
@@ -39,23 +40,24 @@ public class FlatOptionPaneWarningIcon
 	/*
 		<svg xmlns="http://www.w3.org/2000/svg" width="32" height="32" viewBox="0 0 32 32">
 		  <g fill="none" fill-rule="evenodd">
-		    <polygon fill="#EDA200" points="16 2 31 28 1 28"/>
-		    <rect width="4" height="8" x="14" y="10" fill="#FFF"/>
-		    <rect width="4" height="4" x="14" y="21" fill="#FFF"/>
+		    <path fill="#EDA200" d="M17.7364863,3.038851 L30.2901269,25.0077221 C30.8381469,25.966757 30.5049534,27.1884663 29.5459185,27.7364863 C29.2437231,27.9091694 28.9016945,28 28.5536406,28 L3.44635936,28 C2.34178986,28 1.44635936,27.1045695 1.44635936,26 C1.44635936,25.6519461 1.53718999,25.3099175 1.70987307,25.0077221 L14.2635137,3.038851 C14.8115337,2.0798161 16.033243,1.74662265 16.9922779,2.29464259 C17.3023404,2.47182119 17.5593077,2.72878844 17.7364863,3.038851 Z"/>
+		    <rect width="4" height="11" x="14" y="8" fill="#FFF" rx="2"/>
+		    <circle cx="16" cy="23" r="2" fill="#FFF"/>
 		  </g>
 		</svg>
 	*/
 
 	@Override
 	protected Shape createOutside() {
-		return FlatUIUtils.createPath( 16,2, 31,28, 1,28 );
+		return FlatUIUtils.createRoundTrianglePath( 16,0, 32,28, 0,28, 4 );
+
 	}
 
 	@Override
 	protected Shape createInside() {
 		Path2D inside = new Path2D.Float( Path2D.WIND_EVEN_ODD );
-		inside.append( new Rectangle2D.Float( 14, 10, 4, 8 ), false );
-		inside.append( new Rectangle2D.Float( 14, 21, 4, 4 ), false );
+		inside.append( new RoundRectangle2D.Float( 14, 8, 4, 11, 4, 4 ), false );
+		inside.append( new Ellipse2D.Float( 14, 21, 4, 4 ), false );
 		return inside;
 	}
 }

flatlaf-core/src/main/java/com/formdev/flatlaf/icons/FlatRevealIcon.java

@@ -0,0 +1,56 @@
+/*
+ * Copyright 2021 FormDev Software GmbH
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.formdev.flatlaf.icons;
+
+import java.awt.Component;
+import java.awt.Graphics2D;
+import java.awt.geom.Area;
+import java.awt.geom.Ellipse2D;
+import java.awt.geom.Path2D;
+import java.awt.geom.Rectangle2D;
+import javax.swing.UIManager;
+
+/**
+ * "eye" icon for {@link javax.swing.JPasswordField}.
+ *
+ * @uiDefault PasswordField.revealIconColor				Color
+ *
+ * @author Karl Tauber
+ * @since 2
+ */
+public class FlatRevealIcon
+	extends FlatAbstractIcon
+{
+	public FlatRevealIcon() {
+		super( 16, 16, UIManager.getColor( "PasswordField.revealIconColor" ) );
+	}
+
+	@Override
+	protected void paintIcon( Component c, Graphics2D g ) {
+		Path2D path = new Path2D.Float( Path2D.WIND_EVEN_ODD );
+		path.append( new Ellipse2D.Float( 5.15f, 6.15f, 5.7f, 5.7f ), false );
+		path.append( new Ellipse2D.Float( 6, 7, 4, 4 ), false );
+		g.fill( path );
+
+		Path2D path2 = new Path2D.Float( Path2D.WIND_EVEN_ODD );
+		path2.append( new Ellipse2D.Float( 2.15f, 4.15f, 11.7f, 11.7f ), false );
+		path2.append( new Ellipse2D.Float( 3, 5, 10, 10 ), false );
+		Area area = new Area( path2 );
+		area.subtract( new Area( new Rectangle2D.Float( 0, 9.5f, 16, 16 ) ) );
+		g.fill( area );
+	}
+}

flatlaf-core/src/main/java/com/formdev/flatlaf/icons/FlatSearchIcon.java

@@ -45,8 +45,17 @@ public class FlatSearchIcon
 	@Styleable protected Color searchIconHoverColor = UIManager.getColor( "SearchField.searchIconHoverColor" );
 	@Styleable protected Color searchIconPressedColor = UIManager.getColor( "SearchField.searchIconPressedColor" );
 
+	private final boolean ignoreButtonState;
+	private Area area;
+
 	public FlatSearchIcon() {
+		this( false );
+	}
+
+	/** @since 2 */
+	public FlatSearchIcon( boolean ignoreButtonState ) {
 		super( 16, 16, null );
+		this.ignoreButtonState = ignoreButtonState;
 	}
 
 	/** @since 2 */
@@ -59,6 +68,11 @@ public class FlatSearchIcon
 		return FlatStylingSupport.getAnnotatedStyleableInfos( this );
 	}
 
+	/** @since 2.5 */
+	public Object getStyleableValue( String key ) {
+		return FlatStylingSupport.getAnnotatedStyleableValue( this, key );
+	}
+
 	@Override
 	protected void paintIcon( Component c, Graphics2D g ) {
 		/*
@@ -70,13 +84,17 @@ public class FlatSearchIcon
 			</svg>
 		*/
 
-		g.setColor( FlatButtonUI.buttonStateColor( c, searchIconColor, searchIconColor,
-			null, searchIconHoverColor, searchIconPressedColor ) );
+		g.setColor( ignoreButtonState
+			? searchIconColor
+			: FlatButtonUI.buttonStateColor( c, searchIconColor, searchIconColor,
+				null, searchIconHoverColor, searchIconPressedColor ) );
 
 		// paint magnifier
-		Area area = new Area( new Ellipse2D.Float( 2, 2, 10, 10 ) );
-		area.subtract( new Area( new Ellipse2D.Float( 3, 3, 8, 8 ) ) );
-		area.add( new Area( FlatUIUtils.createPath( 10.813,9.75, 14,12.938, 12.938,14, 9.75,10.813 ) ) );
+		if( area == null ) {
+			area = new Area( new Ellipse2D.Float( 2, 2, 10, 10 ) );
+			area.subtract( new Area( new Ellipse2D.Float( 3, 3, 8, 8 ) ) );
+			area.add( new Area( FlatUIUtils.createPath( 10.813,9.75, 14,12.938, 12.938,14, 9.75,10.813 ) ) );
+		}
 		g.fill( area );
 	}
 }

flatlaf-core/src/main/java/com/formdev/flatlaf/icons/FlatSearchWithHistoryIcon.java

@@ -30,6 +30,12 @@ public class FlatSearchWithHistoryIcon
 	extends FlatSearchIcon
 {
 	public FlatSearchWithHistoryIcon() {
+		this( false );
+	}
+
+	/** @since 2 */
+	public FlatSearchWithHistoryIcon( boolean ignoreButtonState ) {
+		super( ignoreButtonState );
 	}
 
 	@Override

flatlaf-core/src/main/java/com/formdev/flatlaf/icons/FlatTabbedPaneCloseIcon.java

@@ -21,7 +21,6 @@ import java.awt.Color;
 import java.awt.Component;
 import java.awt.Dimension;
 import java.awt.Graphics2D;
-import java.awt.geom.Line2D;
 import java.awt.geom.Path2D;
 import java.util.Map;
 import javax.swing.UIManager;
@@ -76,6 +75,11 @@ public class FlatTabbedPaneCloseIcon
 		return FlatStylingSupport.getAnnotatedStyleableInfos( this );
 	}
 
+	/** @since 2.5 */
+	public Object getStyleableValue( String key ) {
+		return FlatStylingSupport.getAnnotatedStyleableValue( this, key );
+	}
+
 	@Override
 	protected void paintIcon( Component c, Graphics2D g ) {
 		// paint background
@@ -86,18 +90,20 @@ public class FlatTabbedPaneCloseIcon
 				closeSize.width, closeSize.height, closeArc, closeArc );
 		}
 
-		// set cross color
+		// set color of cross
 		Color fg = FlatButtonUI.buttonStateColor( c, closeForeground, null, null, closeHoverForeground, closePressedForeground );
 		g.setColor( FlatUIUtils.deriveColor( fg, c.getForeground() ) );
 
-		float mx = width / 2;
-		float my = height / 2;
+		float mx = width / 2f;
+		float my = height / 2f;
 		float r = ((bg != null) ? closeCrossFilledSize : closeCrossPlainSize) / 2;
 
 		// paint cross
-		Path2D path = new Path2D.Float( Path2D.WIND_EVEN_ODD );
-		path.append( new Line2D.Float( mx - r, my - r, mx + r, my + r ), false );
-		path.append( new Line2D.Float( mx - r, my + r, mx + r, my - r ), false );
+		Path2D path = new Path2D.Float( Path2D.WIND_EVEN_ODD, 4 );
+		path.moveTo( mx - r, my - r );
+		path.lineTo( mx + r, my + r );
+		path.moveTo( mx - r, my + r );
+		path.lineTo( mx + r, my - r );
 		g.setStroke( new BasicStroke( closeCrossLineWidth ) );
 		g.draw( path );
 	}

flatlaf-core/src/main/java/com/formdev/flatlaf/icons/FlatTreeClosedIcon.java

@@ -18,8 +18,9 @@ package com.formdev.flatlaf.icons;
 
 import java.awt.Component;
 import java.awt.Graphics2D;
+import java.awt.RenderingHints;
+import java.awt.geom.Path2D;
 import javax.swing.UIManager;
-import com.formdev.flatlaf.ui.FlatUIUtils;
 
 /**
  * "closed" icon for {@link javax.swing.JTree} used by {@link javax.swing.tree.DefaultTreeCellRenderer}.
@@ -31,6 +32,8 @@ import com.formdev.flatlaf.ui.FlatUIUtils;
 public class FlatTreeClosedIcon
 	extends FlatAbstractIcon
 {
+	private Path2D path;
+
 	public FlatTreeClosedIcon() {
 		super( 16, 16, UIManager.getColor( "Tree.icon.closedColor" ) );
 	}
@@ -41,10 +44,14 @@ public class FlatTreeClosedIcon
 
 		/*
 			<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 16 16">
-			  <polygon fill="#6E6E6E" fill-rule="evenodd" points="1 2 6 2 8 4 15 4 15 13 1 13"/>
+			  <path fill="none" stroke="#6E6E6E" d="M13,13.5 L3,13.5 C2.17157288,13.5 1.5,12.8284271 1.5,12 L1.5,4 C1.5,3.17157288 2.17157288,2.5 3,2.5 L6.29289322,2.5 C6.42550146,2.5 6.55267842,2.55267842 6.64644661,2.64644661 L8.5,4.5 L8.5,4.5 L13,4.5 C13.8284271,4.5 14.5,5.17157288 14.5,6 L14.5,12 C14.5,12.8284271 13.8284271,13.5 13,13.5 Z"/>
 			</svg>
 		*/
 
-		g.fill( FlatUIUtils.createPath( 1,2, 6,2, 8,4, 15,4, 15,13, 1,13 ) );
+		g.setRenderingHint( RenderingHints.KEY_STROKE_CONTROL, RenderingHints.VALUE_STROKE_PURE );
+
+		if( path == null )
+			path = FlatFileViewDirectoryIcon.createFolderPath();
+		g.draw( path );
 	}
 }

flatlaf-core/src/main/java/com/formdev/flatlaf/icons/FlatTreeCollapsedIcon.java

@@ -16,9 +16,11 @@
 
 package com.formdev.flatlaf.icons;
 
+import java.awt.BasicStroke;
 import java.awt.Color;
 import java.awt.Component;
 import java.awt.Graphics2D;
+import java.awt.geom.Path2D;
 import java.util.function.Function;
 import javax.swing.JTree;
 import javax.swing.SwingUtilities;
@@ -39,6 +41,7 @@ public class FlatTreeCollapsedIcon
 	extends FlatAbstractIcon
 {
 	private final boolean chevron;
+	private Path2D path;
 
 	public FlatTreeCollapsedIcon() {
 		this( UIManager.getColor( "Tree.icon.collapsedColor" ) );
@@ -59,10 +62,15 @@ public class FlatTreeCollapsedIcon
 
 		if( chevron ) {
 			// chevron arrow
-			g.fill( FlatUIUtils.createPath( 3,1, 3,2.5, 6,5.5, 3,8.5, 3,10, 4.5,10, 9,5.5, 4.5,1 ) );
+			g.setStroke( new BasicStroke( 1f, BasicStroke.CAP_ROUND, BasicStroke.JOIN_MITER ) );
+			if( path == null )
+				path = FlatUIUtils.createPath( false, 3.5,1.5, 7.5,5.5, 3.5,9.5 );
+			g.draw( path );
 		} else {
 			// triangle arrow
-			g.fill( FlatUIUtils.createPath( 2,1, 2,10, 10,5.5 ) );
+			if( path == null )
+				path = FlatUIUtils.createPath( 2,1, 2,10, 10,5.5 );
+			g.fill( path );
 		}
 	}
 
@@ -76,7 +84,7 @@ public class FlatTreeCollapsedIcon
 	}
 
 	/**
-	 * Because this icons are always shared for all trees,
+	 * Because this icon is always shared for all trees,
 	 * get icon specific style from FlatTreeUI.
 	 */
 	static <T> T getStyleFromTreeUI( Component c, Function<FlatTreeUI, T> f ) {

flatlaf-core/src/main/java/com/formdev/flatlaf/icons/FlatTreeLeafIcon.java

@@ -16,10 +16,14 @@
 
 package com.formdev.flatlaf.icons;
 
+import java.awt.BasicStroke;
 import java.awt.Component;
 import java.awt.Graphics2D;
+import java.awt.RenderingHints;
+import java.awt.geom.Line2D;
+import java.awt.geom.RoundRectangle2D;
 import javax.swing.UIManager;
-import com.formdev.flatlaf.ui.FlatUIUtils;
+import com.formdev.flatlaf.util.ColorFunctions;
 
 /**
  * "leaf" icon for {@link javax.swing.JTree} used by {@link javax.swing.tree.DefaultTreeCellRenderer}.
@@ -42,13 +46,22 @@ public class FlatTreeLeafIcon
 		/*
 			<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 16 16">
 			  <g fill="none" fill-rule="evenodd">
-			    <polygon fill="#6E6E6E" points="8 6 8 1 13 1 13 15 3 15 3 6"/>
-			    <polygon fill="#6E6E6E" points="3 5 7 5 7 1"/>
+			    <rect width="11" height="13" x="2.5" y="1.5" stroke="#6E6E6E" rx="1.5"/>
+			    <line x1="5.5" x2="10.5" y1="5.5" y2="5.5" stroke="#6E6E6E" stroke-linecap="round" stroke-opacity=".6"/>
+			    <line x1="5.5" x2="10.5" y1="8" y2="8" stroke="#6E6E6E" stroke-linecap="round" stroke-opacity=".6"/>
+			    <line x1="5.5" x2="10.5" y1="10.5" y2="10.5" stroke="#6E6E6E" stroke-linecap="round" stroke-opacity=".6"/>
 			  </g>
 			</svg>
 		*/
 
-		g.fill( FlatUIUtils.createPath( 8,6, 8,1, 13,1, 13,15, 3,15, 3,6 ) );
-		g.fill( FlatUIUtils.createPath( 3,5, 7,5, 7,1 ) );
+		g.setRenderingHint( RenderingHints.KEY_STROKE_CONTROL, RenderingHints.VALUE_STROKE_PURE );
+		g.setStroke( new BasicStroke( 1, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND ) );
+
+		g.draw( new RoundRectangle2D.Float( 2.5f, 1.5f, 11, 13, 3, 3 ) );
+
+		g.setColor( ColorFunctions.fade( g.getColor(), 0.6f ) );
+		g.draw( new Line2D.Float( 5.5f, 5.5f, 10.5f, 5.5f ) );
+		g.draw( new Line2D.Float( 5.5f, 8, 10.5f, 8 ) );
+		g.draw( new Line2D.Float( 5.5f, 10.5f, 10.5f, 10.5f ) );
 	}
 }

flatlaf-core/src/main/java/com/formdev/flatlaf/icons/FlatTreeOpenIcon.java

@@ -16,8 +16,11 @@
 
 package com.formdev.flatlaf.icons;
 
+import java.awt.BasicStroke;
 import java.awt.Component;
 import java.awt.Graphics2D;
+import java.awt.RenderingHints;
+import java.awt.geom.Path2D;
 import javax.swing.UIManager;
 import com.formdev.flatlaf.ui.FlatUIUtils;
 
@@ -31,6 +34,8 @@ import com.formdev.flatlaf.ui.FlatUIUtils;
 public class FlatTreeOpenIcon
 	extends FlatAbstractIcon
 {
+	private Path2D path;
+
 	public FlatTreeOpenIcon() {
 		super( 16, 16, UIManager.getColor( "Tree.icon.openColor" ) );
 	}
@@ -41,14 +46,38 @@ public class FlatTreeOpenIcon
 
 		/*
 			<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 16 16">
-			  <g fill="none" fill-rule="evenodd">
-			    <polygon fill="#6E6E6E" points="1 2 6 2 8 4 14 4 14 6 3.5 6 1 11"/>
-			    <polygon fill="#6E6E6E" points="4 7 16 7 13 13 1 13"/>
-			  </g>
+			  <path fill="none" stroke="#6E6E6E" d="M2,13.5 L4.11538462,8.42307692 C4.34828895,7.86410651 4.89444872,7.5 5.5,7.5 L14.75,7.5 C15.0261424,7.5 15.25,7.72385763 15.25,8 C15.25,8.06601301 15.2369281,8.13137261 15.2115385,8.19230769 L13.3846154,12.5769231 C13.151711,13.1358935 12.6055513,13.5 12,13.5 L3,13.5 C2.17157288,13.5 1.5,12.8284271 1.5,12 L1.5,4 C1.5,3.17157288 2.17157288,2.5 3,2.5 L6.29289322,2.5 C6.42550146,2.5 6.55267842,2.55267842 6.64644661,2.64644661 L8.5,4.5 L8.5,4.5 L12,4.5 C12.8284271,4.5 13.5,5.17157288 13.5,6 L13.5,6.5 L13.5,6.5"/>
 			</svg>
 		*/
 
-		g.fill( FlatUIUtils.createPath( 1,2, 6,2, 8,4, 14,4, 14,6, 3.5,6, 1,11 ) );
-		g.fill( FlatUIUtils.createPath( 4,7, 16,7, 13,13, 1,13 ) );
+		g.setRenderingHint( RenderingHints.KEY_STROKE_CONTROL, RenderingHints.VALUE_STROKE_PURE );
+		g.setStroke( new BasicStroke( 1, BasicStroke.CAP_BUTT, BasicStroke.JOIN_MITER ) );
+
+		if( path == null ) {
+			double arc = 1.5;
+			double arc2 = 0.5;
+			path = FlatUIUtils.createPath( false,
+				// bottom-left of opened part
+				2,13.5,
+				// top-left of opened part
+				FlatUIUtils.ROUNDED, 4.5,7.5, arc,
+				// top-right of opened part
+				FlatUIUtils.ROUNDED, 15.5,7.5, arc2,
+
+				// bottom-right
+				FlatUIUtils.ROUNDED, 13,13.5, arc,
+				// bottom-left
+				1.5+arc,13.5,   FlatUIUtils.QUAD_TO, 1.5,13.5,  1.5,13.5-arc,
+				// top-left
+				1.5,2.5+arc,    FlatUIUtils.QUAD_TO, 1.5,2.5,   1.5+arc,2.5,
+				// top-mid-left
+				6.5-arc2,2.5,   FlatUIUtils.QUAD_TO, 6.5,2.5,   6.5+arc2,2.5+arc2,
+				// top-mid-right
+				8.5,4.5,
+				// top-right
+				13.5-arc,4.5,   FlatUIUtils.QUAD_TO, 13.5,4.5,  13.5,4.5+arc,
+				13.5,6.5 );
+		}
+		g.draw( path );
 	}
 }

flatlaf-core/src/main/java/com/formdev/flatlaf/icons/FlatWindowAbstractIcon.java

@@ -18,59 +18,141 @@ package com.formdev.flatlaf.icons;
 
 import java.awt.Color;
 import java.awt.Component;
+import java.awt.Container;
 import java.awt.Dimension;
 import java.awt.Graphics2D;
-import javax.swing.UIManager;
+import java.awt.Insets;
+import java.awt.Window;
+import javax.swing.SwingUtilities;
 import com.formdev.flatlaf.ui.FlatButtonUI;
+import com.formdev.flatlaf.ui.FlatTitlePane;
 import com.formdev.flatlaf.ui.FlatUIUtils;
+import com.formdev.flatlaf.util.DerivedColor;
 import com.formdev.flatlaf.util.HiDPIUtils;
+import com.formdev.flatlaf.util.UIScale;
 
 /**
  * Base class for window icons.
  *
  * @uiDefault TitlePane.buttonSize						Dimension
- * @uiDefault TitlePane.buttonHoverBackground			Color
- * @uiDefault TitlePane.buttonPressedBackground			Color
+ * @uiDefault TitlePane.buttonInsets					Insets	optional
+ * @uiDefault TitlePane.buttonArc						int		optional
+ * @uiDefault TitlePane.buttonSymbolHeight				int
+ * @uiDefault TitlePane.buttonBackground				Color	optional
+ * @uiDefault TitlePane.buttonForeground				Color	optional
+ * @uiDefault TitlePane.buttonInactiveBackground		Color	optional
+ * @uiDefault TitlePane.buttonInactiveForeground		Color	optional
+ * @uiDefault TitlePane.buttonHoverBackground			Color	optional
+ * @uiDefault TitlePane.buttonHoverForeground			Color	optional
+ * @uiDefault TitlePane.buttonPressedBackground			Color	optional
+ * @uiDefault TitlePane.buttonPressedForeground			Color	optional
  *
  * @author Karl Tauber
  */
 public abstract class FlatWindowAbstractIcon
 	extends FlatAbstractIcon
 {
-	private final Color hoverBackground;
-	private final Color pressedBackground;
+	/** @since 3.6 */ protected final Insets insets;
+	/** @since 3.6 */ protected final int arc;
+	/** @since 3.6 */ protected final int symbolHeight;
 
-	public FlatWindowAbstractIcon() {
-		this( UIManager.getDimension( "TitlePane.buttonSize" ),
-			UIManager.getColor( "TitlePane.buttonHoverBackground" ),
-			UIManager.getColor( "TitlePane.buttonPressedBackground" ) );
+	/** @since 3.6 */ protected final Color background;
+	/** @since 3.6 */ protected final Color foreground;
+	/** @since 3.6 */ protected final Color inactiveBackground;
+	/** @since 3.6 */ protected final Color inactiveForeground;
+	protected final Color hoverBackground;
+	/** @since 3.6 */ protected final Color hoverForeground;
+	protected final Color pressedBackground;
+	/** @since 3.6 */ protected final Color pressedForeground;
+
+	/** @since 3.2 */
+	protected FlatWindowAbstractIcon( String windowStyle ) {
+		this( windowStyle, null, null, null, null, null, null, null, null );
 	}
 
-	public FlatWindowAbstractIcon( Dimension size, Color hoverBackground, Color pressedBackground ) {
+	/** @since 3.6 */
+	protected FlatWindowAbstractIcon( String windowStyle,
+		Color background, Color foreground, Color inactiveBackground, Color inactiveForeground,
+		Color hoverBackground, Color hoverForeground, Color pressedBackground, Color pressedForeground )
+	{
+		this( FlatUIUtils.getSubUIDimension( "TitlePane.buttonSize", windowStyle ),
+			FlatUIUtils.getSubUIInsets( "TitlePane.buttonInsets", windowStyle ),
+			FlatUIUtils.getSubUIInt( "TitlePane.buttonArc", windowStyle, 0 ),
+			FlatUIUtils.getSubUIInt( "TitlePane.buttonSymbolHeight", windowStyle, 10 ),
+			(background != null) ? background : FlatUIUtils.getSubUIColor( "TitlePane.buttonBackground", windowStyle ),
+			(foreground != null) ? foreground : FlatUIUtils.getSubUIColor( "TitlePane.buttonForeground", windowStyle ),
+			(inactiveBackground != null) ? inactiveBackground : FlatUIUtils.getSubUIColor( "TitlePane.buttonInactiveBackground", windowStyle ),
+			(inactiveForeground != null) ? inactiveForeground : FlatUIUtils.getSubUIColor( "TitlePane.buttonInactiveForeground", windowStyle ),
+			(hoverBackground != null) ? hoverBackground : FlatUIUtils.getSubUIColor( "TitlePane.buttonHoverBackground", windowStyle ),
+			(hoverForeground != null) ? hoverForeground : FlatUIUtils.getSubUIColor( "TitlePane.buttonHoverForeground", windowStyle ),
+			(pressedBackground != null) ? pressedBackground : FlatUIUtils.getSubUIColor( "TitlePane.buttonPressedBackground", windowStyle ),
+			(pressedForeground != null) ? pressedForeground : FlatUIUtils.getSubUIColor( "TitlePane.buttonPressedForeground", windowStyle ) );
+	}
+
+	/** @since 3.6 */
+	protected FlatWindowAbstractIcon( Dimension size, Insets insets, int arc, int symbolHeight,
+		Color background, Color foreground, Color inactiveBackground, Color inactiveForeground,
+		Color hoverBackground, Color hoverForeground, Color pressedBackground, Color pressedForeground )
+	{
 		super( size.width, size.height, null );
+		this.insets = (insets != null) ? insets : new Insets( 0, 0, 0, 0 );
+		this.arc = arc;
+		this.symbolHeight = symbolHeight;
+
+		this.background = background;
+		this.foreground = foreground;
+		this.inactiveBackground = inactiveBackground;
+		this.inactiveForeground = inactiveForeground;
 		this.hoverBackground = hoverBackground;
+		this.hoverForeground = hoverForeground;
 		this.pressedBackground = pressedBackground;
+		this.pressedForeground = pressedForeground;
 	}
 
 	@Override
 	protected void paintIcon( Component c, Graphics2D g ) {
-		paintBackground( c, g );
-
 		g.setColor( getForeground( c ) );
 		HiDPIUtils.paintAtScale1x( g, 0, 0, width, height, this::paintIconAt1x );
 	}
 
 	protected abstract void paintIconAt1x( Graphics2D g, int x, int y, int width, int height, double scaleFactor );
 
-	protected void paintBackground( Component c, Graphics2D g ) {
-		Color background = FlatButtonUI.buttonStateColor( c, null, null, null, hoverBackground, pressedBackground );
+	/** @since 3.5.2 */
+	@Override
+	protected void paintBackground( Component c, Graphics2D g, int x, int y ) {
+		Color bg = null;
+		if( background != null || inactiveBackground != null ) {
+			Window window = SwingUtilities.windowForComponent( c );
+			bg = (window == null || window.isActive()) ? background : inactiveBackground;
+		}
+
+		Color background = FlatButtonUI.buttonStateColor( c, bg, null, null, hoverBackground, pressedBackground );
 		if( background != null ) {
-			g.setColor( FlatUIUtils.deriveColor( background, c.getBackground() ) );
-			g.fillRect( 0, 0, width, height );
+			Insets insets = UIScale.scale( this.insets );
+			float arc = UIScale.scale( (float) this.arc );
+
+			// derive color from title pane background
+			if( background instanceof DerivedColor ) {
+				Container titlePane = SwingUtilities.getAncestorOfClass( FlatTitlePane.class, c );
+				Component baseComp = (titlePane != null) ? titlePane : c;
+				background = FlatUIUtils.deriveColor( background, baseComp.getBackground() );
+			}
+
+			g.setColor( background );
+			FlatUIUtils.paintComponentBackground( g, insets.left, insets.top,
+				c.getWidth() - insets.left - insets.right,
+				c.getHeight() - insets.top - insets.bottom,
+				0, arc );
 		}
 	}
 
 	protected Color getForeground( Component c ) {
-		return c.getForeground();
+		Color fg = null;
+		if( foreground != null || inactiveForeground != null ) {
+			Window window = SwingUtilities.windowForComponent( c );
+			fg = (window == null || window.isActive()) ? foreground : inactiveForeground;
+		}
+		return FlatButtonUI.buttonStateColor( c, (fg != null) ? fg : c.getForeground(),
+			null, null, hoverForeground, pressedForeground );
 	}
 }

flatlaf-core/src/main/java/com/formdev/flatlaf/icons/FlatWindowCloseIcon.java

@@ -17,54 +17,61 @@
 package com.formdev.flatlaf.icons;
 
 import java.awt.BasicStroke;
-import java.awt.Color;
-import java.awt.Component;
 import java.awt.Graphics2D;
-import java.awt.geom.Line2D;
 import java.awt.geom.Path2D;
-import javax.swing.UIManager;
-import com.formdev.flatlaf.ui.FlatButtonUI;
+import com.formdev.flatlaf.ui.FlatUIUtils;
+import com.formdev.flatlaf.util.SystemInfo;
 
 /**
  * "close" icon for windows (frames and dialogs).
  *
- * @uiDefault TitlePane.closeHoverBackground			Color
- * @uiDefault TitlePane.closePressedBackground			Color
- * @uiDefault TitlePane.closeHoverForeground			Color
- * @uiDefault TitlePane.closePressedForeground			Color
+ * @uiDefault TitlePane.closeBackground					Color	optional
+ * @uiDefault TitlePane.closeForeground					Color	optional
+ * @uiDefault TitlePane.closeInactiveBackground			Color	optional
+ * @uiDefault TitlePane.closeInactiveForeground			Color	optional
+ * @uiDefault TitlePane.closeHoverBackground			Color	optional
+ * @uiDefault TitlePane.closeHoverForeground			Color	optional
+ * @uiDefault TitlePane.closePressedBackground			Color	optional
+ * @uiDefault TitlePane.closePressedForeground			Color	optional
  *
  * @author Karl Tauber
  */
 public class FlatWindowCloseIcon
 	extends FlatWindowAbstractIcon
 {
-	private final Color hoverForeground = UIManager.getColor( "TitlePane.closeHoverForeground" );
-	private final Color pressedForeground = UIManager.getColor( "TitlePane.closePressedForeground" );
-
 	public FlatWindowCloseIcon() {
-		super( UIManager.getDimension( "TitlePane.buttonSize" ),
-			UIManager.getColor( "TitlePane.closeHoverBackground" ),
-			UIManager.getColor( "TitlePane.closePressedBackground" ) );
+		this( null );
+	}
+
+	/** @since 3.2 */
+	public FlatWindowCloseIcon( String windowStyle ) {
+		super( windowStyle,
+			FlatUIUtils.getSubUIColor( "TitlePane.closeBackground", windowStyle ),
+			FlatUIUtils.getSubUIColor( "TitlePane.closeForeground", windowStyle ),
+			FlatUIUtils.getSubUIColor( "TitlePane.closeInactiveBackground", windowStyle ),
+			FlatUIUtils.getSubUIColor( "TitlePane.closeInactiveForeground", windowStyle ),
+			FlatUIUtils.getSubUIColor( "TitlePane.closeHoverBackground", windowStyle ),
+			FlatUIUtils.getSubUIColor( "TitlePane.closeHoverForeground", windowStyle ),
+			FlatUIUtils.getSubUIColor( "TitlePane.closePressedBackground", windowStyle ),
+			FlatUIUtils.getSubUIColor( "TitlePane.closePressedForeground", windowStyle ) );
 	}
 
 	@Override
 	protected void paintIconAt1x( Graphics2D g, int x, int y, int width, int height, double scaleFactor ) {
-		int iwh = (int) (10 * scaleFactor);
+		int iwh = (int) (symbolHeight * scaleFactor);
 		int ix = x + ((width - iwh) / 2);
 		int iy = y + ((height - iwh) / 2);
 		int ix2 = ix + iwh - 1;
 		int iy2 = iy + iwh - 1;
-		int thickness = (int) scaleFactor;
+		boolean isWindows10 = SystemInfo.isWindows_10_orLater && !SystemInfo.isWindows_11_orLater;
+		float thickness = Math.max( isWindows10 ? (int) scaleFactor : (float) scaleFactor, 1 );
 
-		Path2D path = new Path2D.Float( Path2D.WIND_EVEN_ODD );
-		path.append( new Line2D.Float( ix, iy, ix2, iy2 ), false );
-		path.append( new Line2D.Float( ix, iy2, ix2, iy ), false );
+		Path2D path = new Path2D.Float( Path2D.WIND_EVEN_ODD, 4 );
+		path.moveTo( ix, iy );
+		path.lineTo( ix2, iy2 );
+		path.moveTo( ix, iy2 );
+		path.lineTo( ix2, iy );
 		g.setStroke( new BasicStroke( thickness ) );
 		g.draw( path );
 	}
-
-	@Override
-	protected Color getForeground( Component c ) {
-		return FlatButtonUI.buttonStateColor( c, c.getForeground(), null, null, hoverForeground, pressedForeground );
-	}
 }

flatlaf-core/src/main/java/com/formdev/flatlaf/icons/FlatWindowIconifyIcon.java

@@ -27,12 +27,18 @@ public class FlatWindowIconifyIcon
 	extends FlatWindowAbstractIcon
 {
 	public FlatWindowIconifyIcon() {
+		this( null );
+	}
+
+	/** @since 3.2 */
+	public FlatWindowIconifyIcon( String windowStyle ) {
+		super( windowStyle );
 	}
 
 	@Override
 	protected void paintIconAt1x( Graphics2D g, int x, int y, int width, int height, double scaleFactor ) {
-		int iw = (int) (10 * scaleFactor);
-		int ih = (int) scaleFactor;
+		int iw = (int) (symbolHeight * scaleFactor);
+		int ih = Math.max( (int) scaleFactor, 1 );
 		int ix = x + ((width - iw) / 2);
 		int iy = y + ((height - ih) / 2);
 

flatlaf-core/src/main/java/com/formdev/flatlaf/icons/FlatWindowMaximizeIcon.java

@@ -18,6 +18,7 @@ package com.formdev.flatlaf.icons;
 
 import java.awt.Graphics2D;
 import com.formdev.flatlaf.ui.FlatUIUtils;
+import com.formdev.flatlaf.util.SystemInfo;
 
 /**
  * "maximize" icon for windows (frames and dialogs).
@@ -28,15 +29,25 @@ public class FlatWindowMaximizeIcon
 	extends FlatWindowAbstractIcon
 {
 	public FlatWindowMaximizeIcon() {
+		this( null );
+	}
+
+	/** @since 3.2 */
+	public FlatWindowMaximizeIcon( String windowStyle ) {
+		super( windowStyle );
 	}
 
 	@Override
 	protected void paintIconAt1x( Graphics2D g, int x, int y, int width, int height, double scaleFactor ) {
-		int iwh = (int) (10 * scaleFactor);
+		int iwh = (int) (symbolHeight * scaleFactor);
 		int ix = x + ((width - iwh) / 2);
 		int iy = y + ((height - iwh) / 2);
-		int thickness = (int) scaleFactor;
+		boolean isWindows10 = SystemInfo.isWindows_10_orLater && !SystemInfo.isWindows_11_orLater;
+		float thickness = Math.max( isWindows10 ? (int) scaleFactor : (float) scaleFactor, 1 );
+		int arc = Math.max( (int) (1.5 * scaleFactor), 2 );
 
-		g.fill( FlatUIUtils.createRectangle( ix, iy, iwh, iwh, thickness ) );
+		g.fill( SystemInfo.isWindows_11_orLater
+			? FlatUIUtils.createRoundRectangle( ix, iy, iwh, iwh, thickness, arc, arc, arc, arc )
+			: FlatUIUtils.createRectangle( ix, iy, iwh, iwh, thickness ) );
 	}
 }

flatlaf-core/src/main/java/com/formdev/flatlaf/icons/FlatWindowRestoreIcon.java

@@ -21,6 +21,7 @@ import java.awt.geom.Area;
 import java.awt.geom.Path2D;
 import java.awt.geom.Rectangle2D;
 import com.formdev.flatlaf.ui.FlatUIUtils;
+import com.formdev.flatlaf.util.SystemInfo;
 
 /**
  * "restore" icon for windows (frames and dialogs).
@@ -31,25 +32,47 @@ public class FlatWindowRestoreIcon
 	extends FlatWindowAbstractIcon
 {
 	public FlatWindowRestoreIcon() {
+		this( null );
+	}
+
+	/** @since 3.2 */
+	public FlatWindowRestoreIcon( String windowStyle ) {
+		super( windowStyle );
 	}
 
 	@Override
 	protected void paintIconAt1x( Graphics2D g, int x, int y, int width, int height, double scaleFactor ) {
-		int iwh = (int) (10 * scaleFactor);
+		int iwh = (int) (symbolHeight * scaleFactor);
 		int ix = x + ((width - iwh) / 2);
 		int iy = y + ((height - iwh) / 2);
-		int thickness = (int) scaleFactor;
+		boolean isWindows10 = SystemInfo.isWindows_10_orLater && !SystemInfo.isWindows_11_orLater;
+		float thickness = Math.max( isWindows10 ? (int) scaleFactor : (float) scaleFactor, 1 );
+		int arc = Math.max( (int) (1.5 * scaleFactor), 2 );
+		int arcOuter = (int) (arc + (1.5 * scaleFactor));
 
-		int rwh = (int) (8 * scaleFactor);
+		int rwh = (int) ((symbolHeight - 2) * scaleFactor);
 		int ro2 = iwh - rwh;
 
-		Path2D r1 = FlatUIUtils.createRectangle( ix + ro2, iy, rwh, rwh, thickness );
-		Path2D r2 = FlatUIUtils.createRectangle( ix, iy + ro2, rwh, rwh, thickness );
+		// upper-right rectangle
+		Path2D r1 = SystemInfo.isWindows_11_orLater
+			? FlatUIUtils.createRoundRectangle( ix + ro2, iy, rwh, rwh, thickness, arc, arcOuter, arc, arc )
+			: FlatUIUtils.createRectangle( ix + ro2, iy, rwh, rwh, thickness );
 
+		// lower-left rectangle
+		Path2D r2 = SystemInfo.isWindows_11_orLater
+			? FlatUIUtils.createRoundRectangle( ix, iy + ro2, rwh, rwh, thickness, arc, arc, arc, arc )
+			: FlatUIUtils.createRectangle( ix, iy + ro2, rwh, rwh, thickness );
+
+		// paint upper-right rectangle
 		Area area = new Area( r1 );
-		area.subtract( new Area( new Rectangle2D.Float( ix, iy + ro2, rwh, rwh ) ) );
+		if( SystemInfo.isWindows_11_orLater ) {
+			area.subtract( new Area( new Rectangle2D.Float( ix, (float) (iy + scaleFactor), rwh, rwh ) ) );
+			area.subtract( new Area( new Rectangle2D.Float( (float) (ix + scaleFactor), iy + ro2, rwh, rwh ) ) );
+		} else
+			area.subtract( new Area( new Rectangle2D.Float( ix, iy + ro2, rwh, rwh ) ) );
 		g.fill( area );
 
+		// paint lower-left rectangle
 		g.fill( r2 );
 	}
 }

flatlaf-core/src/main/java/com/formdev/flatlaf/json/JsonParser.java

@@ -502,9 +502,9 @@ class JsonParser {
   }
 
   private boolean isHexDigit() {
-    return current >= '0' && current <= '9'
-        || current >= 'a' && current <= 'f'
-        || current >= 'A' && current <= 'F';
+    return (current >= '0' && current <= '9')
+        || (current >= 'a' && current <= 'f')
+        || (current >= 'A' && current <= 'F');
   }
 
   private boolean isEndOfText() {

flatlaf-core/src/main/java/com/formdev/flatlaf/json/Location.java

@@ -69,7 +69,7 @@ public class Location {
     if (obj == null) {
       return false;
     }
-    if (getClass() != obj.getClass()) {
+    if (!(obj instanceof Location)) {
       return false;
     }
     Location other = (Location)obj;

flatlaf-core/src/main/java/com/formdev/flatlaf/resources/EmptyPackage.java

@@ -18,8 +18,8 @@ package com.formdev.flatlaf.resources;
 
 /**
  * The only purpose of this file is to add a .class file to this package to make it non-empty.
- * Otherwise the compiler outputs a warning because this package is opend in module-info.java.
- * Also when using --patch-module (e.g. from an IDE), an error would occur for empty packages.
+ * Otherwise, the compiler outputs a warning because this package is opened in module-info.java.
+ * Also, when using --patch-module (e.g. from an IDE), an error would occur for empty packages.
  *
  * @author Karl Tauber
  */

flatlaf-core/src/main/java/com/formdev/flatlaf/themes/FlatMacDarkLaf.java

@@ -0,0 +1,68 @@
+/*
+ * Copyright 2022 FormDev Software GmbH
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.formdev.flatlaf.themes;
+
+import javax.swing.UIManager;
+import com.formdev.flatlaf.FlatDarkLaf;
+
+/**
+ * A Flat LaF that imitates macOS dark look.
+ * <p>
+ * The UI defaults are loaded from {@code FlatMacDarkLaf.properties},
+ * {@code FlatDarkLaf.properties} and {@code FlatLaf.properties}.
+ *
+ * @author Karl Tauber
+ * @since 3
+ */
+public class FlatMacDarkLaf
+	extends FlatDarkLaf
+{
+	public static final String NAME = "FlatLaf macOS Dark";
+
+	/**
+	 * Sets the application look and feel to this LaF
+	 * using {@link UIManager#setLookAndFeel(javax.swing.LookAndFeel)}.
+	 */
+	public static boolean setup() {
+		return setup( new FlatMacDarkLaf() );
+	}
+
+	/**
+	 * Adds this look and feel to the set of available look and feels.
+	 * <p>
+	 * Useful if your application uses {@link UIManager#getInstalledLookAndFeels()}
+	 * to query available LaFs and display them to the user in a combobox.
+	 */
+	public static void installLafInfo() {
+		installLafInfo( NAME, FlatMacDarkLaf.class );
+	}
+
+	@Override
+	public String getName() {
+		return NAME;
+	}
+
+	@Override
+	public String getDescription() {
+		return "FlatLaf macOS Dark Look and Feel";
+	}
+
+	@Override
+	public boolean isDark() {
+		return true;
+	}
+}

flatlaf-core/src/main/java/com/formdev/flatlaf/themes/FlatMacLightLaf.java

@@ -0,0 +1,68 @@
+/*
+ * Copyright 2022 FormDev Software GmbH
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.formdev.flatlaf.themes;
+
+import javax.swing.UIManager;
+import com.formdev.flatlaf.FlatLightLaf;
+
+/**
+ * A Flat LaF that imitates macOS light look.
+ * <p>
+ * The UI defaults are loaded from {@code FlatMacLightLaf.properties},
+ * {@code FlatLightLaf.properties} and {@code FlatLaf.properties}.
+ *
+ * @author Karl Tauber
+ * @since 3
+ */
+public class FlatMacLightLaf
+	extends FlatLightLaf
+{
+	public static final String NAME = "FlatLaf macOS Light";
+
+	/**
+	 * Sets the application look and feel to this LaF
+	 * using {@link UIManager#setLookAndFeel(javax.swing.LookAndFeel)}.
+	 */
+	public static boolean setup() {
+		return setup( new FlatMacLightLaf() );
+	}
+
+	/**
+	 * Adds this look and feel to the set of available look and feels.
+	 * <p>
+	 * Useful if your application uses {@link UIManager#getInstalledLookAndFeels()}
+	 * to query available LaFs and display them to the user in a combobox.
+	 */
+	public static void installLafInfo() {
+		installLafInfo( NAME, FlatMacLightLaf.class );
+	}
+
+	@Override
+	public String getName() {
+		return NAME;
+	}
+
+	@Override
+	public String getDescription() {
+		return "FlatLaf macOS Light Look and Feel";
+	}
+
+	@Override
+	public boolean isDark() {
+		return false;
+	}
+}

flatlaf-core/src/main/java/com/formdev/flatlaf/ui/FlatArrowButton.java

@@ -25,6 +25,7 @@ import java.awt.Graphics2D;
 import java.awt.event.MouseAdapter;
 import java.awt.event.MouseEvent;
 import javax.swing.JComponent;
+import javax.swing.SwingUtilities;
 import javax.swing.plaf.UIResource;
 import javax.swing.plaf.basic.BasicArrowButton;
 
@@ -37,7 +38,7 @@ public class FlatArrowButton
 	extends BasicArrowButton
 	implements UIResource
 {
-	public static final int DEFAULT_ARROW_WIDTH = 8;
+	public static final int DEFAULT_ARROW_WIDTH = 9;
 
 	protected boolean chevron;
 	protected Color foreground;
@@ -48,8 +49,10 @@ public class FlatArrowButton
 	protected Color pressedBackground;
 
 	private int arrowWidth = DEFAULT_ARROW_WIDTH;
+	private float arrowThickness = 1;
 	private float xOffset = 0;
 	private float yOffset = 0;
+	private boolean roundBorderAutoXOffset = true;
 
 	private boolean hover;
 	private boolean pressed;
@@ -82,14 +85,18 @@ public class FlatArrowButton
 
 				@Override
 				public void mousePressed( MouseEvent e ) {
-					pressed = true;
-					repaint();
+					if( SwingUtilities.isLeftMouseButton( e ) ) {
+						pressed = true;
+						repaint();
+					}
 				}
 
 				@Override
 				public void mouseReleased( MouseEvent e ) {
-					pressed = false;
-					repaint();
+					if( SwingUtilities.isLeftMouseButton( e ) ) {
+						pressed = false;
+						repaint();
+					}
 				}
 			} );
 		}
@@ -116,6 +123,16 @@ public class FlatArrowButton
 		this.arrowWidth = arrowWidth;
 	}
 
+	/** @since 3 */
+	public float getArrowThickness() {
+		return arrowThickness;
+	}
+
+	/** @since 3 */
+	public void setArrowThickness( float arrowThickness ) {
+		this.arrowThickness = arrowThickness;
+	}
+
 	protected boolean isHover() {
 		return hover;
 	}
@@ -140,6 +157,16 @@ public class FlatArrowButton
 		this.yOffset = yOffset;
 	}
 
+	/** @since 3 */
+	public boolean isRoundBorderAutoXOffset() {
+		return roundBorderAutoXOffset;
+	}
+
+	/** @since 3 */
+	public void setRoundBorderAutoXOffset( boolean roundBorderAutoXOffset ) {
+		this.roundBorderAutoXOffset = roundBorderAutoXOffset;
+	}
+
 	protected Color deriveBackground( Color background ) {
 		return background;
 	}
@@ -203,14 +230,17 @@ public class FlatArrowButton
 	}
 
 	protected void paintArrow( Graphics2D g ) {
-		boolean vert = (direction == NORTH || direction == SOUTH);
 		int x = 0;
 
 		// move arrow for round borders
-		Container parent = getParent();
-		if( vert && parent instanceof JComponent && FlatUIUtils.hasRoundBorder( (JComponent) parent ) )
-			x -= scale( parent.getComponentOrientation().isLeftToRight() ? 1 : -1 );
+		if( isRoundBorderAutoXOffset() ) {
+			Container parent = getParent();
+			boolean vert = (direction == NORTH || direction == SOUTH);
+			if( vert && parent instanceof JComponent && FlatUIUtils.hasRoundBorder( (JComponent) parent ) )
+				x -= scale( parent.getComponentOrientation().isLeftToRight() ? 1 : -1 );
+		}
 
-		FlatUIUtils.paintArrow( g, x, 0, getWidth(), getHeight(), getDirection(), chevron, arrowWidth, xOffset, yOffset );
+		FlatUIUtils.paintArrow( g, x, 0, getWidth(), getHeight(), getDirection(), chevron,
+			getArrowWidth(), getArrowThickness(), getXOffset(), getYOffset() );
 	}
 }

flatlaf-core/src/main/java/com/formdev/flatlaf/ui/FlatBorder.java

@@ -28,7 +28,6 @@ import javax.swing.JComboBox;
 import javax.swing.JComponent;
 import javax.swing.JScrollPane;
 import javax.swing.JSpinner;
-import javax.swing.JViewport;
 import javax.swing.UIManager;
 import javax.swing.plaf.basic.BasicBorders;
 import com.formdev.flatlaf.FlatClientProperties;
@@ -60,6 +59,8 @@ import com.formdev.flatlaf.util.DerivedColor;
  * @uiDefault Component.error.focusedBorderColor		Color
  * @uiDefault Component.warning.borderColor				Color
  * @uiDefault Component.warning.focusedBorderColor		Color
+ * @uiDefault Component.success.borderColor				Color
+ * @uiDefault Component.success.focusedBorderColor		Color
  * @uiDefault Component.custom.borderColor				Color
  *
  * @author Karl Tauber
@@ -82,6 +83,8 @@ public class FlatBorder
 	@Styleable(dot=true) protected Color errorFocusedBorderColor = UIManager.getColor( "Component.error.focusedBorderColor" );
 	@Styleable(dot=true) protected Color warningBorderColor = UIManager.getColor( "Component.warning.borderColor" );
 	@Styleable(dot=true) protected Color warningFocusedBorderColor = UIManager.getColor( "Component.warning.focusedBorderColor" );
+	/** @since 3.6 */ @Styleable(dot=true) protected Color successBorderColor = UIManager.getColor( "Component.success.borderColor" );
+	/** @since 3.6 */ @Styleable(dot=true) protected Color successFocusedBorderColor = UIManager.getColor( "Component.success.focusedBorderColor" );
 	@Styleable(dot=true) protected Color customBorderColor = UIManager.getColor( "Component.custom.borderColor" );
 
 	// only used via styling (not in UI defaults, but has likewise client properties)
@@ -101,6 +104,12 @@ public class FlatBorder
 		return FlatStylingSupport.getAnnotatedStyleableInfos( this );
 	}
 
+	/** @since 2.5 */
+	@Override
+	public Object getStyleableValue( String key ) {
+		return FlatStylingSupport.getAnnotatedStyleableValue( this, key );
+	}
+
 	@Override
 	public void paintBorder( Component c, Graphics g, int x, int y, int width, int height ) {
 		Graphics2D g2 = (Graphics2D) g.create();
@@ -130,7 +139,7 @@ public class FlatBorder
 			Paint borderColor = (outlineColor != null) ? outlineColor : getBorderColor( c );
 			FlatUIUtils.paintOutlinedComponent( g2, x, y, width, height,
 				focusWidth, 1, focusInnerWidth, borderWidth, arc,
-				focusColor, borderColor, null );
+				focusColor, borderColor, null, c instanceof JScrollPane );
 		} finally {
 			g2.dispose();
 		}
@@ -163,6 +172,9 @@ public class FlatBorder
 
 				case FlatClientProperties.OUTLINE_WARNING:
 					return isFocused( c ) ? warningFocusedBorderColor : warningBorderColor;
+
+				case FlatClientProperties.OUTLINE_SUCCESS:
+					return isFocused( c ) ? successFocusedBorderColor : successBorderColor;
 			}
 		} else if( outline instanceof Color ) {
 			Color color = (Color) outline;
@@ -189,8 +201,7 @@ public class FlatBorder
 	protected boolean isEnabled( Component c ) {
 		if( c instanceof JScrollPane ) {
 			// check whether view component is disabled
-			JViewport viewport = ((JScrollPane)c).getViewport();
-			Component view = (viewport != null) ? viewport.getView() : null;
+			Component view = FlatScrollPaneUI.getView( (JScrollPane) c );
 			if( view != null && !isEnabled( view ) )
 				return false;
 		}
@@ -273,7 +284,7 @@ public class FlatBorder
 	}
 
 	/**
-	 * Returns the (unscaled) arc diameter of the border.
+	 * Returns the (unscaled) arc diameter of the border corners.
 	 */
 	protected int getArc( Component c ) {
 		return 0;

flatlaf-core/src/main/java/com/formdev/flatlaf/ui/FlatButtonBorder.java

@@ -42,6 +42,13 @@ import com.formdev.flatlaf.util.UIScale;
  * @uiDefault Button.disabledBorderColor		Color
  * @uiDefault Button.focusedBorderColor			Color
  * @uiDefault Button.hoverBorderColor			Color	optional
+ * @uiDefault Button.pressedBorderColor			Color	optional
+ *
+ * @uiDefault Button.selectedBorderColor		Color	optional
+ * @uiDefault Button.disabledSelectedBorderColor Color	optional
+ * @uiDefault Button.focusedSelectedBorderColor	Color	optional
+ * @uiDefault Button.hoverSelectedBorderColor	Color	optional
+ * @uiDefault Button.pressedSelectedBorderColor	Color	optional
  *
  * @uiDefault Button.default.borderWidth		int or float
  * @uiDefault Button.default.borderColor		Color
@@ -49,6 +56,7 @@ import com.formdev.flatlaf.util.UIScale;
  * @uiDefault Button.default.endBorderColor		Color	optional; if set, a gradient paint is used
  * @uiDefault Button.default.focusedBorderColor	Color
  * @uiDefault Button.default.focusColor			Color
+ * @uiDefault Button.default.pressedBorderColor	Color	optional
  * @uiDefault Button.default.hoverBorderColor	Color	optional
  *
  * @uiDefault Button.toolbar.focusWidth			int or float		optional; default is 1.5
@@ -65,6 +73,13 @@ public class FlatButtonBorder
 
 	protected Color endBorderColor = UIManager.getColor( "Button.endBorderColor" );
 	@Styleable protected Color hoverBorderColor = UIManager.getColor( "Button.hoverBorderColor" );
+	/** @since 3.5 */ @Styleable protected Color pressedBorderColor = UIManager.getColor( "Button.pressedBorderColor" );
+
+	/** @since 3.5 */ @Styleable protected Color selectedBorderColor = UIManager.getColor( "Button.selectedBorderColor" );
+	/** @since 3.5 */ @Styleable protected Color disabledSelectedBorderColor = UIManager.getColor( "Button.disabledSelectedBorderColor" );
+	/** @since 3.5 */ @Styleable protected Color focusedSelectedBorderColor = UIManager.getColor( "Button.focusedSelectedBorderColor" );
+	/** @since 3.5 */ @Styleable protected Color hoverSelectedBorderColor = UIManager.getColor( "Button.hoverSelectedBorderColor" );
+	/** @since 3.5 */ @Styleable protected Color pressedSelectedBorderColor = UIManager.getColor( "Button.pressedSelectedBorderColor" );
 
 	@Styleable(dot=true) protected float defaultBorderWidth = FlatUIUtils.getUIFloat( "Button.default.borderWidth", 1 );
 	@Styleable(dot=true) protected Color defaultBorderColor = FlatUIUtils.getUIColor( "Button.default.startBorderColor", "Button.default.borderColor" );
@@ -72,6 +87,7 @@ public class FlatButtonBorder
 	@Styleable(dot=true) protected Color defaultFocusedBorderColor = UIManager.getColor( "Button.default.focusedBorderColor" );
 	@Styleable(dot=true) protected Color defaultFocusColor = UIManager.getColor( "Button.default.focusColor" );
 	@Styleable(dot=true) protected Color defaultHoverBorderColor = UIManager.getColor( "Button.default.hoverBorderColor" );
+	/** @since 3.5 */ @Styleable(dot=true) protected Color defaultPressedBorderColor = UIManager.getColor( "Button.default.pressedBorderColor" );
 
 	/** @since 1.4 */ @Styleable(dot=true) protected float toolbarFocusWidth = FlatUIUtils.getUIFloat( "Button.toolbar.focusWidth", 1.5f );
 	/** @since 1.4 */ @Styleable(dot=true) protected Color toolbarFocusColor = UIManager.getColor( "Button.toolbar.focusColor" );
@@ -139,12 +155,13 @@ public class FlatButtonBorder
 	@Override
 	protected Paint getBorderColor( Component c ) {
 		boolean def = FlatButtonUI.isDefaultButton( c );
+		boolean selected = (c instanceof AbstractButton && ((AbstractButton)c).isSelected());
 		Paint color = FlatButtonUI.buttonStateColor( c,
-			def ? defaultBorderColor : borderColor,
-			disabledBorderColor,
-			def ? defaultFocusedBorderColor : focusedBorderColor,
-			def ? defaultHoverBorderColor : hoverBorderColor,
-			null );
+			def ? defaultBorderColor : ((selected && selectedBorderColor != null) ? selectedBorderColor : borderColor),
+			(selected && disabledSelectedBorderColor != null) ? disabledSelectedBorderColor : disabledBorderColor,
+			def ? defaultFocusedBorderColor : ((selected && focusedSelectedBorderColor != null) ? focusedSelectedBorderColor : focusedBorderColor),
+			def ? defaultHoverBorderColor : ((selected && hoverSelectedBorderColor != null) ? hoverSelectedBorderColor : hoverBorderColor),
+			def ? defaultPressedBorderColor : ((selected && pressedSelectedBorderColor != null) ? pressedSelectedBorderColor : pressedBorderColor) );
 
 		// change to gradient paint if start/end colors are specified
 		Color startBg = def ? defaultBorderColor : borderColor;
@@ -159,7 +176,7 @@ public class FlatButtonBorder
 	public Insets getBorderInsets( Component c, Insets insets ) {
 		if( FlatButtonUI.isToolBarButton( c ) ) {
 			// In toolbars, use button margin only if explicitly set.
-			// Otherwise use toolbar margin specified in UI defaults.
+			// Otherwise, use toolbar margin specified in UI defaults.
 			Insets margin = (c instanceof AbstractButton)
 				? ((AbstractButton)c).getMargin()
 				: null;

flatlaf-core/src/main/java/com/formdev/flatlaf/ui/FlatButtonUI.java

@@ -20,6 +20,7 @@ import static com.formdev.flatlaf.FlatClientProperties.*;
 import static com.formdev.flatlaf.util.UIScale.scale;
 import java.awt.Color;
 import java.awt.Component;
+import java.awt.Container;
 import java.awt.Dimension;
 import java.awt.Font;
 import java.awt.FontMetrics;
@@ -28,6 +29,7 @@ import java.awt.Graphics;
 import java.awt.Graphics2D;
 import java.awt.Insets;
 import java.awt.Rectangle;
+import java.awt.event.FocusEvent;
 import java.awt.geom.RoundRectangle2D;
 import java.beans.PropertyChangeEvent;
 import java.util.Map;
@@ -38,20 +40,29 @@ import javax.swing.ButtonModel;
 import javax.swing.Icon;
 import javax.swing.JButton;
 import javax.swing.JComponent;
+import javax.swing.JTextField;
 import javax.swing.JToggleButton;
 import javax.swing.JToolBar;
 import javax.swing.LookAndFeel;
+import javax.swing.SwingConstants;
+import javax.swing.SwingUtilities;
 import javax.swing.UIManager;
+import javax.swing.event.ChangeEvent;
 import javax.swing.plaf.ButtonUI;
 import javax.swing.plaf.ComponentUI;
+import javax.swing.plaf.ToolBarUI;
 import javax.swing.plaf.UIResource;
 import javax.swing.plaf.basic.BasicButtonListener;
 import javax.swing.plaf.basic.BasicButtonUI;
+import javax.swing.plaf.basic.BasicHTML;
+import javax.swing.text.View;
+import com.formdev.flatlaf.FlatClientProperties;
 import com.formdev.flatlaf.FlatLaf;
 import com.formdev.flatlaf.icons.FlatHelpButtonIcon;
 import com.formdev.flatlaf.ui.FlatStylingSupport.Styleable;
 import com.formdev.flatlaf.ui.FlatStylingSupport.StyleableUI;
 import com.formdev.flatlaf.ui.FlatStylingSupport.UnknownStyleException;
+import com.formdev.flatlaf.util.HiDPIUtils;
 import com.formdev.flatlaf.util.LoggingFacade;
 import com.formdev.flatlaf.util.UIScale;
 
@@ -74,20 +85,27 @@ import com.formdev.flatlaf.util.UIScale;
  * @uiDefault Button.startBackground			Color	optional; if set, a gradient paint is used and Button.background is ignored
  * @uiDefault Button.endBackground				Color	optional; if set, a gradient paint is used
  * @uiDefault Button.focusedBackground			Color	optional
+ * @uiDefault Button.focusedForeground			Color	optional
  * @uiDefault Button.hoverBackground			Color	optional
+ * @uiDefault Button.hoverForeground			Color	optional
  * @uiDefault Button.pressedBackground			Color	optional
+ * @uiDefault Button.pressedForeground			Color	optional
  * @uiDefault Button.selectedBackground			Color
  * @uiDefault Button.selectedForeground			Color
  * @uiDefault Button.disabledBackground			Color	optional
  * @uiDefault Button.disabledText				Color
  * @uiDefault Button.disabledSelectedBackground	Color
+ * @uiDefault Button.disabledSelectedForeground	Color	optional
  * @uiDefault Button.default.background			Color
  * @uiDefault Button.default.startBackground	Color	optional; if set, a gradient paint is used and Button.default.background is ignored
  * @uiDefault Button.default.endBackground		Color	optional; if set, a gradient paint is used
  * @uiDefault Button.default.foreground			Color
  * @uiDefault Button.default.focusedBackground	Color	optional
+ * @uiDefault Button.default.focusedForeground	Color	optional
  * @uiDefault Button.default.hoverBackground	Color	optional
+ * @uiDefault Button.default.hoverForeground	Color	optional
  * @uiDefault Button.default.pressedBackground	Color	optional
+ * @uiDefault Button.default.pressedForeground	Color	optional
  * @uiDefault Button.default.boldText			boolean
  * @uiDefault Button.paintShadow				boolean	default is false
  * @uiDefault Button.shadowWidth				int		default is 2
@@ -95,8 +113,13 @@ import com.formdev.flatlaf.util.UIScale;
  * @uiDefault Button.default.shadowColor		Color	optional
  * @uiDefault Button.toolbar.spacingInsets		Insets
  * @uiDefault Button.toolbar.hoverBackground	Color
+ * @uiDefault Button.toolbar.hoverForeground	Color	optional
  * @uiDefault Button.toolbar.pressedBackground	Color
+ * @uiDefault Button.toolbar.pressedForeground	Color	optional
  * @uiDefault Button.toolbar.selectedBackground	Color
+ * @uiDefault Button.toolbar.selectedForeground	Color	optional
+ * @uiDefault Button.toolbar.disabledSelectedBackground	Color	optional
+ * @uiDefault Button.toolbar.disabledSelectedForeground	Color	optional
  *
  * @author Karl Tauber
  */
@@ -113,20 +136,27 @@ public class FlatButtonUI
 	protected Color startBackground;
 	protected Color endBackground;
 	@Styleable protected Color focusedBackground;
+	/** @since 2.3 */ @Styleable protected Color focusedForeground;
 	@Styleable protected Color hoverBackground;
+	/** @since 2.3 */ @Styleable protected Color hoverForeground;
 	@Styleable protected Color pressedBackground;
+	/** @since 2.3 */ @Styleable protected Color pressedForeground;
 	@Styleable protected Color selectedBackground;
 	@Styleable protected Color selectedForeground;
 	@Styleable protected Color disabledBackground;
 	@Styleable protected Color disabledText;
 	@Styleable protected Color disabledSelectedBackground;
+	/** @since 2.3 */ @Styleable protected Color disabledSelectedForeground;
 
 	@Styleable(dot=true) protected Color defaultBackground;
 	protected Color defaultEndBackground;
 	@Styleable(dot=true) protected Color defaultForeground;
 	@Styleable(dot=true) protected Color defaultFocusedBackground;
+	/** @since 2.3 */ @Styleable(dot=true) protected Color defaultFocusedForeground;
 	@Styleable(dot=true) protected Color defaultHoverBackground;
+	/** @since 2.3 */ @Styleable(dot=true) protected Color defaultHoverForeground;
 	@Styleable(dot=true) protected Color defaultPressedBackground;
+	/** @since 2.3 */ @Styleable(dot=true) protected Color defaultPressedForeground;
 	@Styleable(dot=true) protected boolean defaultBoldText;
 
 	@Styleable protected boolean paintShadow;
@@ -135,8 +165,13 @@ public class FlatButtonUI
 	@Styleable(dot=true) protected Color defaultShadowColor;
 
 	@Styleable(dot=true) protected Color toolbarHoverBackground;
+	/** @since 2.3 */ @Styleable(dot=true) protected Color toolbarHoverForeground;
 	@Styleable(dot=true) protected Color toolbarPressedBackground;
+	/** @since 2.3 */ @Styleable(dot=true) protected Color toolbarPressedForeground;
 	@Styleable(dot=true) protected Color toolbarSelectedBackground;
+	/** @since 2.3 */ @Styleable(dot=true) protected Color toolbarSelectedForeground;
+	/** @since 2.3 */ @Styleable(dot=true) protected Color toolbarDisabledSelectedBackground;
+	/** @since 2.3 */ @Styleable(dot=true) protected Color toolbarDisabledSelectedForeground;
 
 	// only used via styling (not in UI defaults, but has likewise client properties)
 	/** @since 2 */ @Styleable protected String buttonType;
@@ -153,7 +188,7 @@ public class FlatButtonUI
 	private AtomicBoolean borderShared;
 
 	public static ComponentUI createUI( JComponent c ) {
-		return FlatUIUtils.canUseSharedUI( c )
+		return FlatUIUtils.canUseSharedUI( c ) && !FlatUIUtils.needsLightAWTPeer( c )
 			? FlatUIUtils.createSharedUI( FlatButtonUI.class, () -> new FlatButtonUI( true ) )
 			: new FlatButtonUI( false );
 	}
@@ -165,6 +200,13 @@ public class FlatButtonUI
 
 	@Override
 	public void installUI( JComponent c ) {
+		if( FlatUIUtils.needsLightAWTPeer( c ) )
+			FlatUIUtils.runWithLightAWTPeerUIDefaults( () -> installUIImpl( c ) );
+		else
+			installUIImpl( c );
+	}
+
+	private void installUIImpl( JComponent c ) {
 		super.installUI( c );
 
 		installStyle( (AbstractButton) c );
@@ -186,20 +228,27 @@ public class FlatButtonUI
 			startBackground = UIManager.getColor( prefix + "startBackground" );
 			endBackground = UIManager.getColor( prefix + "endBackground" );
 			focusedBackground = UIManager.getColor( prefix + "focusedBackground" );
+			focusedForeground = UIManager.getColor( prefix + "focusedForeground" );
 			hoverBackground = UIManager.getColor( prefix + "hoverBackground" );
+			hoverForeground = UIManager.getColor( prefix + "hoverForeground" );
 			pressedBackground = UIManager.getColor( prefix + "pressedBackground" );
+			pressedForeground = UIManager.getColor( prefix + "pressedForeground" );
 			selectedBackground = UIManager.getColor( prefix + "selectedBackground" );
 			selectedForeground = UIManager.getColor( prefix + "selectedForeground" );
 			disabledBackground = UIManager.getColor( prefix + "disabledBackground" );
 			disabledText = UIManager.getColor( prefix + "disabledText" );
 			disabledSelectedBackground = UIManager.getColor( prefix + "disabledSelectedBackground" );
+			disabledSelectedForeground = UIManager.getColor( prefix + "disabledSelectedForeground" );
 
 			defaultBackground = FlatUIUtils.getUIColor( "Button.default.startBackground", "Button.default.background" );
 			defaultEndBackground = UIManager.getColor( "Button.default.endBackground" );
 			defaultForeground = UIManager.getColor( "Button.default.foreground" );
 			defaultFocusedBackground = UIManager.getColor( "Button.default.focusedBackground" );
+			defaultFocusedForeground = UIManager.getColor( "Button.default.focusedForeground" );
 			defaultHoverBackground = UIManager.getColor( "Button.default.hoverBackground" );
+			defaultHoverForeground = UIManager.getColor( "Button.default.hoverForeground" );
 			defaultPressedBackground = UIManager.getColor( "Button.default.pressedBackground" );
+			defaultPressedForeground = UIManager.getColor( "Button.default.pressedForeground" );
 			defaultBoldText = UIManager.getBoolean( "Button.default.boldText" );
 
 			paintShadow = UIManager.getBoolean( "Button.paintShadow" );
@@ -208,8 +257,13 @@ public class FlatButtonUI
 			defaultShadowColor = UIManager.getColor( "Button.default.shadowColor" );
 
 			toolbarHoverBackground = UIManager.getColor( prefix + "toolbar.hoverBackground" );
+			toolbarHoverForeground = UIManager.getColor( prefix + "toolbar.hoverForeground" );
 			toolbarPressedBackground = UIManager.getColor( prefix + "toolbar.pressedBackground" );
+			toolbarPressedForeground = UIManager.getColor( prefix + "toolbar.pressedForeground" );
 			toolbarSelectedBackground = UIManager.getColor( prefix + "toolbar.selectedBackground" );
+			toolbarSelectedForeground = UIManager.getColor( prefix + "toolbar.selectedForeground" );
+			toolbarDisabledSelectedBackground = UIManager.getColor( prefix + "toolbar.disabledSelectedBackground" );
+			toolbarDisabledSelectedForeground = UIManager.getColor( prefix + "toolbar.disabledSelectedForeground" );
 
 			helpButtonIcon = UIManager.getIcon( "HelpButton.icon" );
 			defaultMargin = UIManager.getInsets( prefix + "margin" );
@@ -226,8 +280,6 @@ public class FlatButtonUI
 
 		LookAndFeel.installProperty( b, "opaque", false );
 		LookAndFeel.installProperty( b, "iconTextGap", scale( iconTextGap ) );
-
-		MigLayoutVisualPadding.install( b );
 	}
 
 	@Override
@@ -237,10 +289,23 @@ public class FlatButtonUI
 		oldStyleValues = null;
 		borderShared = null;
 
-		MigLayoutVisualPadding.uninstall( b );
 		defaults_initialized = false;
 	}
 
+	@Override
+	protected void installListeners( AbstractButton b ) {
+		super.installListeners( b );
+
+		MigLayoutVisualPadding.install( b );
+	}
+
+	@Override
+	protected void uninstallListeners( AbstractButton b ) {
+		super.uninstallListeners( b );
+
+		MigLayoutVisualPadding.uninstall( b );
+	}
+
 	@Override
 	protected BasicButtonListener createButtonListener( AbstractButton b ) {
 		return new FlatButtonListener( b );
@@ -248,6 +313,10 @@ public class FlatButtonUI
 
 	protected void propertyChange( AbstractButton b, PropertyChangeEvent e ) {
 		switch( e.getPropertyName() ) {
+			case BasicHTML.propertyKey:
+				FlatHTML.updateRendererCSSFontBaseSize( b );
+				break;
+
 			case SQUARE_SIZE:
 			case MINIMUM_WIDTH:
 			case MINIMUM_HEIGHT:
@@ -256,19 +325,23 @@ public class FlatButtonUI
 
 			case BUTTON_TYPE:
 				b.revalidate();
-				b.repaint();
+				HiDPIUtils.repaint( b );
+				break;
+
+			case OUTLINE:
+				HiDPIUtils.repaint( b );
 				break;
 
 			case STYLE:
 			case STYLE_CLASS:
 				if( shared && FlatStylingSupport.hasStyleProperty( b ) ) {
 					// unshare component UI if necessary
-					// updateUI() invokes applyStyle() from installUI()
+					// updateUI() invokes installStyle() from installUI()
 					b.updateUI();
 				} else
 					installStyle( b );
 				b.revalidate();
-				b.repaint();
+				HiDPIUtils.repaint( b );
 				break;
 		}
 	}
@@ -308,6 +381,15 @@ public class FlatButtonUI
 			return ((FlatHelpButtonIcon)helpButtonIcon).applyStyleProperty( key, value );
 		}
 
+		// update internal values; otherwise isCustomBackground() and isCustomForeground() would return wrong results
+		switch( key ) {
+			case "background":	background = (Color) value; break;
+			case "foreground":	foreground = (Color) value; break;
+		}
+
+		if( "iconTextGap".equals( key ) && value instanceof Integer )
+			value = UIScale.scale( (Integer) value );
+
 		if( borderShared == null )
 			borderShared = new AtomicBoolean( true );
 		return FlatStylingSupport.applyToAnnotatedObjectOrBorder( this, key, value, b, borderShared );
@@ -322,6 +404,18 @@ public class FlatButtonUI
 		return infos;
 	}
 
+	/** @since 2.5 */
+	@Override
+	public Object getStyleableValue( JComponent c, String key ) {
+		if( key.startsWith( "help." ) ) {
+			return (helpButtonIcon instanceof FlatHelpButtonIcon)
+				? ((FlatHelpButtonIcon)helpButtonIcon).getStyleableValue( key.substring( "help.".length() ) )
+				: null;
+		}
+
+		return FlatStylingSupport.getAnnotatedStyleableValue( this, c.getBorder(), key );
+	}
+
 	static boolean isContentAreaFilled( Component c ) {
 		return !(c instanceof AbstractButton) || ((AbstractButton)c).isContentAreaFilled();
 	}
@@ -336,7 +430,7 @@ public class FlatButtonUI
 
 	/**
 	 * Returns true if the button has an icon but no text,
-	 * or it it does not have an icon and the text is either "..." or one character.
+	 * or it does not have an icon and the text is either "..." or one character.
 	 */
 	static boolean isIconOnlyOrSingleCharacterButton( Component c ) {
 		if( !(c instanceof JButton) && !(c instanceof JToggleButton) )
@@ -420,11 +514,21 @@ public class FlatButtonUI
 		try {
 			FlatUIUtils.setRenderingHints( g2 );
 
+			boolean def = isDefaultButton( c );
 			boolean isToolBarButton = isToolBarButton( c );
 			float focusWidth = isToolBarButton ? 0 : FlatUIUtils.getBorderFocusWidth( c );
 			float arc = FlatUIUtils.getBorderArc( c );
+			float textFieldArc = 0;
 
-			boolean def = isDefaultButton( c );
+			// if toolbar button is in leading/trailing component of a text field,
+			// increase toolbar button arc to match text field arc (if necessary)
+			if( isToolBarButton &&
+				FlatClientProperties.clientProperty( c, STYLE_CLASS, "", String.class ).contains( "inTextField" ) )
+			{
+				JTextField textField = (JTextField) SwingUtilities.getAncestorOfClass( JTextField.class, c );
+				if( textField != null )
+					textFieldArc = FlatUIUtils.getBorderArc( textField );
+			}
 
 			int x = 0;
 			int y = 0;
@@ -437,8 +541,15 @@ public class FlatButtonUI
 				y += spacing.top;
 				width -= spacing.left + spacing.right;
 				height -= spacing.top + spacing.bottom;
+
+				// reduce text field arc
+				textFieldArc -= spacing.top + spacing.bottom;
 			}
 
+			// increase toolbar button arc to match text field arc (if necessary)
+			if( arc < textFieldArc )
+				arc = textFieldArc;
+
 			// paint shadow
 			Color shadowColor = def ? defaultShadowColor : this.shadowColor;
 			if( paintShadow &&
@@ -465,9 +576,69 @@ public class FlatButtonUI
 		}
 	}
 
+	/**
+	 * Similar to BasicButtonUI.paint(), but does not use zero insets for HTML text,
+	 * which is done in BasicButtonUI.layout() since Java 19.
+	 * See https://github.com/openjdk/jdk/pull/8407
+	 * and https://github.com/openjdk/jdk/pull/8407#issuecomment-1761583430
+	 */
 	@Override
 	public void paint( Graphics g, JComponent c ) {
-		super.paint( FlatLabelUI.createGraphicsHTMLTextYCorrection( g, c ), c );
+		g = FlatLabelUI.createGraphicsHTMLTextYCorrection( g, c );
+
+		AbstractButton b = (AbstractButton) c;
+
+		// layout
+		String clippedText = layout( b, b.getFontMetrics( b.getFont() ), b.getWidth(), b.getHeight() );
+
+		// not used in FlatLaf, but invoked for compatibility with BasicButtonUI.paint()
+		clearTextShiftOffset();
+
+		// not used in FlatLaf, but invoked for compatibility with BasicButtonUI.paint()
+		ButtonModel model = b.getModel();
+		if( model.isArmed() && model.isPressed() )
+			paintButtonPressed( g, b );
+
+		// paint icon
+		if( b.getIcon() != null )
+			paintIcon( g, b, iconR );
+
+		// paint text
+		if( clippedText != null && !clippedText.isEmpty() ) {
+			View view = (View) b.getClientProperty( BasicHTML.propertyKey );
+			if( view != null ) {
+				// update foreground color in HTML view, which is necessary
+				// for selected and pressed states
+				// (only for enabled buttons, because UIManager.getColor("textInactiveText")
+				// is used for disabled components; see: javax.swing.text.GlyphView.paint())
+				if( b.isEnabled() )
+					FlatHTML.updateRendererCSSForeground( view, getForeground( b ) );
+
+				view.paint( g, textR ); // HTML text
+			} else
+				paintText( g, b, textR, clippedText );
+		}
+
+		// not used in FlatLaf, but invoked for compatibility with BasicButtonUI.paint()
+		if( b.isFocusPainted() && b.hasFocus() )
+			paintFocus( g, b, viewR, textR, iconR );
+	}
+
+	@Override
+	protected void paintIcon( Graphics g, JComponent c, Rectangle iconRect ) {
+		// correct icon location when using bold font for default button
+		int xOffset = defaultBoldPlainWidthDiff( c ) / 2;
+		if( xOffset > 0 ) {
+			boolean ltr = c.getComponentOrientation().isLeftToRight();
+			switch( ((AbstractButton)c).getHorizontalTextPosition() ) {
+				case SwingConstants.RIGHT:    iconRect.x -= xOffset; break;
+				case SwingConstants.LEFT:     iconRect.x += xOffset; break;
+				case SwingConstants.TRAILING: iconRect.x -= ltr ? xOffset : -xOffset; break;
+				case SwingConstants.LEADING:  iconRect.x += ltr ? xOffset : -xOffset; break;
+			}
+		}
+
+		super.paintIcon( g, c, iconRect );
 	}
 
 	@Override
@@ -499,15 +670,19 @@ public class FlatButtonUI
 	}
 
 	protected Color getBackground( JComponent c ) {
-		boolean toolBarButton = isToolBarButton( c ) || isBorderlessButton( c );
+		boolean def = isDefaultButton( c );
+		boolean toolBarButton = !def && (isToolBarButton( c ) || isBorderlessButton( c ));
 
 		// selected state
 		if( ((AbstractButton)c).isSelected() ) {
-			// in toolbar use same background colors for disabled and enabled because
+			// in toolbar, if toolbarDisabledSelectedBackground is null,
+			// use same background colors for disabled and enabled because
 			// we assume that toolbar icon is shown disabled
 			return buttonStateColor( c,
 				toolBarButton ? toolbarSelectedBackground : selectedBackground,
-				toolBarButton ? toolbarSelectedBackground : disabledSelectedBackground,
+				toolBarButton
+					? (toolbarDisabledSelectedBackground != null ? toolbarDisabledSelectedBackground : toolbarSelectedBackground)
+					: disabledSelectedBackground,
 				null,
 				null,
 				toolBarButton ? toolbarPressedBackground : pressedBackground );
@@ -524,7 +699,6 @@ public class FlatButtonUI
 				toolbarPressedBackground );
 		}
 
-		boolean def = isDefaultButton( c );
 		return buttonStateColor( c,
 			getBackgroundBase( c, def ),
 			disabledBackground,
@@ -534,6 +708,9 @@ public class FlatButtonUI
 	}
 
 	protected Color getBackgroundBase( JComponent c, boolean def ) {
+		if( FlatUIUtils.isAWTPeer( c ) )
+			return background;
+
 		// use component background if explicitly set
 		Color bg = c.getBackground();
 		if( isCustomBackground( bg ) )
@@ -549,6 +726,9 @@ public class FlatButtonUI
 	public static Color buttonStateColor( Component c, Color enabledColor, Color disabledColor,
 		Color focusedColor, Color hoverColor, Color pressedColor )
 	{
+		if( c == null )
+			return enabledColor;
+
 		if( !c.isEnabled() )
 			return disabledColor;
 
@@ -569,18 +749,49 @@ public class FlatButtonUI
 	}
 
 	protected Color getForeground( JComponent c ) {
-		if( !c.isEnabled() )
-			return disabledText;
+		Color fg = c.getForeground();
+		boolean def = isDefaultButton( c );
+		boolean toolBarButton = !def && (isToolBarButton( c ) || isBorderlessButton( c ));
 
-		if( ((AbstractButton)c).isSelected() && !(isToolBarButton( c ) || isBorderlessButton( c )) )
-			return selectedForeground;
+		// selected state
+		if( ((AbstractButton)c).isSelected() ) {
+			return buttonStateColor( c,
+				toolBarButton
+					? (toolbarSelectedForeground != null ? toolbarSelectedForeground : fg)
+					: (isCustomForeground( fg ) ? fg : selectedForeground),
+				toolBarButton
+					? (toolbarDisabledSelectedForeground != null ? toolbarDisabledSelectedForeground : disabledText)
+					: (disabledSelectedForeground != null ? disabledSelectedForeground : disabledText),
+				null,
+				null,
+				toolBarButton ? toolbarPressedForeground : pressedForeground );
+		}
 
+		// toolbar button
+		if( toolBarButton ) {
+			return buttonStateColor( c,
+				fg,
+				disabledText,
+				null,
+				toolbarHoverForeground,
+				toolbarPressedForeground );
+		}
+
+		return buttonStateColor( c,
+			getForegroundBase( c, def ),
+			disabledText,
+			isCustomForeground( fg ) ? null : (def ? defaultFocusedForeground : focusedForeground),
+			def ? defaultHoverForeground : hoverForeground,
+			def ? defaultPressedForeground : pressedForeground );
+	}
+
+	/** @since 2.3 */
+	protected Color getForegroundBase( JComponent c, boolean def ) {
 		// use component foreground if explicitly set
 		Color fg = c.getForeground();
 		if( isCustomForeground( fg ) )
 			return fg;
 
-		boolean def = isDefaultButton( c );
 		return def ? defaultForeground : fg;
 	}
 
@@ -597,6 +808,9 @@ public class FlatButtonUI
 		if( prefSize == null )
 			return null;
 
+		// increase width when using bold font for default button
+		prefSize.width += defaultBoldPlainWidthDiff( c );
+
 		// make square or apply minimum width/height
 		boolean isIconOnlyOrSingleCharacter = isIconOnlyOrSingleCharacterButton( c );
 		if( clientPropertyBoolean( c, SQUARE_SIZE, squareSize ) ) {
@@ -617,11 +831,89 @@ public class FlatButtonUI
 		return prefSize;
 	}
 
+	private int defaultBoldPlainWidthDiff( JComponent c ) {
+		if( defaultBoldText && isDefaultButton( c ) && c.getFont() instanceof UIResource ) {
+			String text = ((AbstractButton)c).getText();
+			if( text == null || text.isEmpty() )
+				return 0;
+
+			Font font = c.getFont();
+			Font boldFont = font.deriveFont( Font.BOLD );
+			int boldWidth = c.getFontMetrics( boldFont ).stringWidth( text );
+			int plainWidth = c.getFontMetrics( font ).stringWidth( text );
+			if( boldWidth > plainWidth )
+				return boldWidth - plainWidth;
+		}
+
+		return 0;
+	}
+
 	private boolean hasDefaultMargins( JComponent c ) {
 		Insets margin = ((AbstractButton)c).getMargin();
 		return margin instanceof UIResource && Objects.equals( margin, defaultMargin );
 	}
 
+	@Override
+	public int getBaseline( JComponent c, int width, int height ) {
+		return getBaselineImpl( c, width, height );
+	}
+
+	/**
+	 * Similar to BasicButtonUI.getBaseline(), but does not use zero insets for HTML text,
+	 * which is done in BasicButtonUI.layout() since Java 19.
+	 * See https://github.com/openjdk/jdk/pull/8407
+	 * and https://github.com/openjdk/jdk/pull/8407#issuecomment-1761583430
+	 */
+	static int getBaselineImpl( JComponent c, int width, int height ) {
+		if( width < 0 || height < 0 )
+			throw new IllegalArgumentException();
+
+		AbstractButton b = (AbstractButton) c;
+		String text = b.getText();
+		if( text == null || text.isEmpty() )
+			return -1;
+
+		FontMetrics fm = b.getFontMetrics( b.getFont() );
+		layout( b, fm, width, height );
+
+		View view = (View) b.getClientProperty( BasicHTML.propertyKey );
+		if( view != null ) {
+			// HTML text
+			int baseline = BasicHTML.getHTMLBaseline( view, textR.width, textR.height );
+			return (baseline >= 0) ? textR.y + baseline : baseline;
+		} else
+			return textR.y + fm.getAscent();
+	}
+
+	/**
+	 * Similar to BasicButtonUI.layout(), but does not use zero insets for HTML text,
+	 * which is done in BasicButtonUI.layout() since Java 19.
+	 * See https://github.com/openjdk/jdk/pull/8407
+	 * and https://github.com/openjdk/jdk/pull/8407#issuecomment-1761583430
+	 */
+	private static String layout( AbstractButton b, FontMetrics fm, int width, int height ) {
+		// compute view rectangle
+		Insets insets = b.getInsets();
+		viewR.setBounds( insets.left, insets.top,
+			width - insets.left - insets.right,
+			height - insets.top - insets.bottom );
+
+		// reset rectangles
+		textR.setBounds( 0, 0, 0, 0 );
+		iconR.setBounds( 0, 0, 0, 0 );
+
+		String text = b.getText();
+		return SwingUtilities.layoutCompoundLabel( b, fm, text, b.getIcon(),
+			b.getVerticalAlignment(), b.getHorizontalAlignment(),
+			b.getVerticalTextPosition(), b.getHorizontalTextPosition(),
+			viewR, iconR, textR,
+			(text != null) ? b.getIconTextGap() : 0 );
+	}
+
+	private static Rectangle viewR = new Rectangle();
+	private static Rectangle textR = new Rectangle();
+	private static Rectangle iconR = new Rectangle();
+
 	//---- class FlatButtonListener -------------------------------------------
 
 	protected class FlatButtonListener
@@ -639,5 +931,32 @@ public class FlatButtonUI
 			super.propertyChange( e );
 			FlatButtonUI.this.propertyChange( b, e );
 		}
+
+		@Override
+		public void stateChanged( ChangeEvent e ) {
+			HiDPIUtils.repaint( b );
+
+			// if button is in toolbar, repaint button groups
+			AbstractButton b = (AbstractButton) e.getSource();
+			Container parent = b.getParent();
+			if( parent instanceof JToolBar ) {
+				JToolBar toolBar = (JToolBar) parent;
+				ToolBarUI ui = toolBar.getUI();
+				if( ui instanceof FlatToolBarUI )
+					((FlatToolBarUI)ui).repaintButtonGroup( b );
+			}
+		}
+
+		@Override
+		public void focusGained( FocusEvent e ) {
+			super.focusGained( e );
+			HiDPIUtils.repaint( b );
+		}
+
+		@Override
+		public void focusLost( FocusEvent e ) {
+			super.focusLost( e );
+			HiDPIUtils.repaint( b );
+		}
 	}
 }

flatlaf-core/src/main/java/com/formdev/flatlaf/ui/FlatCaret.java

@@ -17,6 +17,7 @@
 package com.formdev.flatlaf.ui;
 
 import static com.formdev.flatlaf.FlatClientProperties.*;
+import java.awt.Container;
 import java.awt.EventQueue;
 import java.awt.Rectangle;
 import java.awt.event.ActionEvent;
@@ -24,7 +25,9 @@ import java.awt.event.FocusEvent;
 import java.awt.event.MouseEvent;
 import javax.swing.Action;
 import javax.swing.ActionMap;
+import javax.swing.JComboBox;
 import javax.swing.JFormattedTextField;
+import javax.swing.JSpinner;
 import javax.swing.SwingUtilities;
 import javax.swing.UIManager;
 import javax.swing.plaf.UIResource;
@@ -33,6 +36,7 @@ import javax.swing.text.DefaultCaret;
 import javax.swing.text.DefaultEditorKit;
 import javax.swing.text.Document;
 import javax.swing.text.JTextComponent;
+import javax.swing.text.Position;
 import javax.swing.text.Utilities;
 
 /**
@@ -48,12 +52,15 @@ public class FlatCaret
 {
 	private static final String KEY_CARET_INFO = "FlatLaf.internal.caretInfo";
 
+	// selectAllOnFocusPolicy
+	private static final int NEVER = 0, ONCE = 1, ALWAYS = 2;
+
 	private final String selectAllOnFocusPolicy;
 	private final boolean selectAllOnMouseClick;
 
 	private boolean inInstall;
 	private boolean wasFocused;
-	private boolean wasTemporaryLost;
+	private boolean wasFocusTemporaryLost;
 	private boolean isMousePressed;
 	private boolean isWordSelection;
 	private boolean isLineSelection;
@@ -94,13 +101,19 @@ public class FlatCaret
 			// restore selection
 			select( (int) ci[1], (int) ci[0] );
 
+			if( ci[4] != 0 )
+				wasFocused = true;
+
 			// if text component is focused, then caret and selection are visible,
 			// but when switching theme, the component does not yet have
-			// an highlighter and the selection is not painted
+			// a highlighter and the selection is not painted
 			// --> make selection temporary invisible later, then the caret
 			//     adds selection highlights to the text component highlighter
 			if( isSelectionVisible() ) {
 				EventQueue.invokeLater( () -> {
+					if( getComponent() == null )
+						return; // was deinstalled
+
 					if( isSelectionVisible() ) {
 						setSelectionVisible( false );
 						setSelectionVisible( true );
@@ -118,6 +131,7 @@ public class FlatCaret
 			getMark(),
 			getBlinkRate(),
 			System.currentTimeMillis(),
+			wasFocused ? 1 : 0,
 		} );
 
 		super.deinstall( c );
@@ -137,11 +151,36 @@ public class FlatCaret
 		super.adjustVisibility( nloc );
 	}
 
+	@Override
+	public void setDot( int dot ) {
+		super.setDot( dot );
+
+		// mark as focused if invoked from JTextComponent.setCaretPosition()
+		// to disable SELECT_ALL_ON_FOCUS_POLICY_ONCE if application explicitly changes selection
+		if( !wasFocused &&
+			getSelectAllOnFocusPolicy() == ONCE &&
+			StackUtils.wasInvokedFrom( JTextComponent.class.getName(), "setCaretPosition", 6 ) )
+		  wasFocused = true;
+	}
+
+	@Override
+	public void moveDot( int dot ) {
+		super.moveDot( dot );
+
+		// mark as focused if invoked from JTextComponent.moveCaretPosition()
+		// to disable SELECT_ALL_ON_FOCUS_POLICY_ONCE if application explicitly changes selection
+		if( !wasFocused &&
+			getSelectAllOnFocusPolicy() == ONCE &&
+			StackUtils.wasInvokedFrom( JTextComponent.class.getName(), "moveCaretPosition", 6 ) )
+		  wasFocused = true;
+	}
+
 	@Override
 	public void focusGained( FocusEvent e ) {
-		if( !inInstall && !wasTemporaryLost && (!isMousePressed || selectAllOnMouseClick) )
+		if( !inInstall && !wasFocusTemporaryLost && (!isMousePressed || isSelectAllOnMouseClick()) )
 			selectAllOnFocusGained();
-		wasTemporaryLost = false;
+
+		wasFocusTemporaryLost = false;
 		wasFocused = true;
 
 		super.focusGained( e );
@@ -149,7 +188,7 @@ public class FlatCaret
 
 	@Override
 	public void focusLost( FocusEvent e ) {
-		wasTemporaryLost = e.isTemporary();
+		wasFocusTemporaryLost = e.isTemporary();
 		super.focusLost( e );
 	}
 
@@ -229,42 +268,73 @@ public class FlatCaret
 		if( doc == null || !c.isEnabled() || !c.isEditable() || FlatUIUtils.isCellEditor( c ) )
 			return;
 
-		Object selectAllOnFocusPolicy = c.getClientProperty( SELECT_ALL_ON_FOCUS_POLICY );
-		if( selectAllOnFocusPolicy == null )
-			selectAllOnFocusPolicy = this.selectAllOnFocusPolicy;
-
-		if( SELECT_ALL_ON_FOCUS_POLICY_NEVER.equals( selectAllOnFocusPolicy ) )
+		int selectAllOnFocusPolicy = getSelectAllOnFocusPolicy();
+		if( selectAllOnFocusPolicy == NEVER )
 			return;
 
-		if( !SELECT_ALL_ON_FOCUS_POLICY_ALWAYS.equals( selectAllOnFocusPolicy ) ) {
-			// policy is "once" (or null or unknown)
-
+		if( selectAllOnFocusPolicy == ONCE && !isMousePressed ) {
 			// was already focused?
-			if( wasFocused )
-				return;
-
-			// check whether selection was modified before gaining focus
-			int dot = getDot();
-			int mark = getMark();
-			if( dot != mark || dot != doc.getLength() )
+			if( wasFocused && !(c instanceof JFormattedTextField) )
 				return;
 		}
 
 		// select all
 		if( c instanceof JFormattedTextField ) {
 			EventQueue.invokeLater( () -> {
-				select( 0, doc.getLength() );
+				// Warning: do not use variables from outside of this runnable
+				//          because they may be out-of-date when this runnable is executed
+
+				JTextComponent c2 = getComponent();
+				if( c2 == null )
+					return; // was deinstalled
+
+				select( 0, c2.getDocument().getLength() );
 			} );
-		} else {
+		} else
 			select( 0, doc.getLength() );
-		}
 	}
 
 	private void select( int mark, int dot ) {
 		if( mark != getMark() )
-			setDot( mark );
+			setDot( mark, Position.Bias.Forward );
 		if( dot != getDot() )
-			moveDot( dot );
+			moveDot( dot, Position.Bias.Forward );
+	}
+
+	private int getSelectAllOnFocusPolicy() {
+		Object value = getClientProperty( SELECT_ALL_ON_FOCUS_POLICY );
+		// Note: using String.valueOf() because selectAllOnFocusPolicy may be null
+		switch( String.valueOf( value instanceof String ? value : selectAllOnFocusPolicy ) ) {
+			default:
+			case SELECT_ALL_ON_FOCUS_POLICY_NEVER:  return NEVER;
+			case SELECT_ALL_ON_FOCUS_POLICY_ONCE:   return ONCE;
+			case SELECT_ALL_ON_FOCUS_POLICY_ALWAYS: return ALWAYS;
+		}
+	}
+
+	private boolean isSelectAllOnMouseClick() {
+		Object value = getClientProperty( SELECT_ALL_ON_MOUSE_CLICK );
+		return (value instanceof Boolean) ? (boolean) value : selectAllOnMouseClick;
+	}
+
+	private Object getClientProperty( String key ) {
+		JTextComponent c = getComponent();
+		if( c == null )
+			return null;
+
+		Object value = c.getClientProperty( key );
+		if( value != null )
+			return value;
+
+		Container parent = c.getParent();
+		if( parent instanceof JComboBox )
+			return ((JComboBox<?>)parent).getClientProperty( key );
+		if( parent instanceof JSpinner.DefaultEditor ) {
+			parent = parent.getParent();
+			if( parent instanceof JSpinner )
+				return ((JSpinner)parent).getClientProperty( key );
+		}
+		return null;
 	}
 
 	/** @since 1.4 */

flatlaf-core/src/main/java/com/formdev/flatlaf/ui/FlatCheckBoxMenuItemUI.java

@@ -16,18 +16,21 @@
 
 package com.formdev.flatlaf.ui;
 
-import java.awt.Color;
 import java.awt.Dimension;
 import java.awt.Graphics;
 import java.beans.PropertyChangeListener;
+import java.lang.invoke.MethodHandles;
 import java.util.Map;
 import javax.swing.Icon;
 import javax.swing.JComponent;
+import javax.swing.JMenuItem;
 import javax.swing.LookAndFeel;
 import javax.swing.plaf.ComponentUI;
 import javax.swing.plaf.basic.BasicCheckBoxMenuItemUI;
+import javax.swing.plaf.basic.BasicMenuItemUI;
+import com.formdev.flatlaf.ui.FlatStylingSupport.StyleableField;
+import com.formdev.flatlaf.ui.FlatStylingSupport.StyleableLookupProvider;
 import com.formdev.flatlaf.ui.FlatStylingSupport.StyleableUI;
-import com.formdev.flatlaf.ui.FlatStylingSupport.UnknownStyleException;
 import com.formdev.flatlaf.util.LoggingFacade;
 
 /**
@@ -58,9 +61,15 @@ import com.formdev.flatlaf.util.LoggingFacade;
  *
  * @author Karl Tauber
  */
+@StyleableField( cls=BasicMenuItemUI.class, key="selectionBackground" )
+@StyleableField( cls=BasicMenuItemUI.class, key="selectionForeground" )
+@StyleableField( cls=BasicMenuItemUI.class, key="disabledForeground" )
+@StyleableField( cls=BasicMenuItemUI.class, key="acceleratorForeground" )
+@StyleableField( cls=BasicMenuItemUI.class, key="acceleratorSelectionForeground" )
+
 public class FlatCheckBoxMenuItemUI
 	extends BasicCheckBoxMenuItemUI
-	implements StyleableUI
+	implements StyleableUI, StyleableLookupProvider
 {
 	private FlatMenuItemRenderer renderer;
 	private Map<String, Object> oldStyleValues;
@@ -89,17 +98,28 @@ public class FlatCheckBoxMenuItemUI
 	protected void uninstallDefaults() {
 		super.uninstallDefaults();
 
+		FlatMenuItemRenderer.clearClientProperties( menuItem.getParent() );
 		renderer = null;
 		oldStyleValues = null;
 	}
 
+	@Override
+	protected void installComponents( JMenuItem menuItem ) {
+		super.installComponents( menuItem );
+
+		// update HTML renderer if necessary
+		FlatHTML.updateRendererCSSFontBaseSize( menuItem );
+	}
+
 	protected FlatMenuItemRenderer createRenderer() {
 		return new FlatMenuItemRenderer( menuItem, checkIcon, arrowIcon, acceleratorFont, acceleratorDelimiter );
 	}
 
 	@Override
 	protected PropertyChangeListener createPropertyChangeListener( JComponent c ) {
-		return FlatStylingSupport.createPropertyChangeListener( c, this::installStyle, super.createPropertyChangeListener( c ) );
+		return FlatHTML.createPropertyChangeListener(
+			FlatStylingSupport.createPropertyChangeListener( c, this::installStyle,
+				super.createPropertyChangeListener( c ) ) );
 	}
 
 	/** @since 2 */
@@ -118,29 +138,27 @@ public class FlatCheckBoxMenuItemUI
 
 	/** @since 2 */
 	protected Object applyStyleProperty( String key, Object value ) {
-		try {
-			return renderer.applyStyleProperty( key, value );
-		} catch ( UnknownStyleException ex ) {
-			// ignore
-		}
-
-		Object oldValue;
-		switch( key ) {
-			// BasicMenuItemUI
-			case "selectionBackground": oldValue = selectionBackground; selectionBackground = (Color) value; return oldValue;
-			case "selectionForeground": oldValue = selectionForeground; selectionForeground = (Color) value; return oldValue;
-			case "disabledForeground": oldValue = disabledForeground; disabledForeground = (Color) value; return oldValue;
-			case "acceleratorForeground": oldValue = acceleratorForeground; acceleratorForeground = (Color) value; return oldValue;
-			case "acceleratorSelectionForeground": oldValue = acceleratorSelectionForeground; acceleratorSelectionForeground = (Color) value; return oldValue;
-		}
-
-		return FlatStylingSupport.applyToAnnotatedObjectOrComponent( this, menuItem, key, value );
+		return FlatMenuItemUI.applyStyleProperty( menuItem, this, renderer, key, value );
 	}
 
 	/** @since 2 */
 	@Override
 	public Map<String, Class<?>> getStyleableInfos( JComponent c ) {
-		return FlatMenuItemUI.getStyleableInfos( renderer );
+		return FlatMenuItemUI.getStyleableInfos( this, renderer );
+	}
+
+	/** @since 2.5 */
+	@Override
+	public Object getStyleableValue( JComponent c, String key ) {
+		return FlatMenuItemUI.getStyleableValue( this, renderer, key );
+	}
+
+	/** @since 2.5 */
+	@Override
+	public MethodHandles.Lookup getLookupForStyling() {
+		// MethodHandles.lookup() is caller sensitive and must be invoked in this class,
+		// otherwise it is not possible to access protected fields in JRE superclass
+		return MethodHandles.lookup();
 	}
 
 	@Override

flatlaf-core/src/main/java/com/formdev/flatlaf/ui/FlatCheckBoxUI.java

@@ -43,7 +43,7 @@ public class FlatCheckBoxUI
 	extends FlatRadioButtonUI
 {
 	public static ComponentUI createUI( JComponent c ) {
-		return FlatUIUtils.canUseSharedUI( c )
+		return FlatUIUtils.canUseSharedUI( c ) && !FlatUIUtils.needsLightAWTPeer( c )
 			? FlatUIUtils.createSharedUI( FlatCheckBoxUI.class, () -> new FlatCheckBoxUI( true ) )
 			: new FlatCheckBoxUI( false );
 	}

flatlaf-core/src/main/java/com/formdev/flatlaf/ui/FlatComboBoxUI.java

@@ -24,6 +24,7 @@ import java.awt.Component;
 import java.awt.ComponentOrientation;
 import java.awt.Container;
 import java.awt.Dimension;
+import java.awt.EventQueue;
 import java.awt.FontMetrics;
 import java.awt.Graphics;
 import java.awt.Graphics2D;
@@ -42,15 +43,18 @@ import java.awt.event.MouseEvent;
 import java.awt.event.MouseListener;
 import java.awt.geom.Rectangle2D;
 import java.beans.PropertyChangeListener;
+import java.lang.invoke.MethodHandles;
 import java.util.Map;
 import java.util.concurrent.atomic.AtomicBoolean;
 import javax.swing.AbstractAction;
 import javax.swing.BorderFactory;
 import javax.swing.CellRendererPane;
+import javax.swing.ComboBoxModel;
 import javax.swing.DefaultListCellRenderer;
 import javax.swing.InputMap;
 import javax.swing.JButton;
 import javax.swing.JComboBox;
+import javax.swing.JComboBox.KeySelectionManager;
 import javax.swing.JComponent;
 import javax.swing.JList;
 import javax.swing.JPanel;
@@ -69,8 +73,12 @@ import javax.swing.plaf.basic.BasicComboBoxUI;
 import javax.swing.plaf.basic.BasicComboPopup;
 import javax.swing.plaf.basic.ComboPopup;
 import javax.swing.text.JTextComponent;
+import com.formdev.flatlaf.icons.FlatCheckBoxMenuItemIcon;
 import com.formdev.flatlaf.ui.FlatStylingSupport.Styleable;
+import com.formdev.flatlaf.ui.FlatStylingSupport.StyleableField;
+import com.formdev.flatlaf.ui.FlatStylingSupport.StyleableLookupProvider;
 import com.formdev.flatlaf.ui.FlatStylingSupport.StyleableUI;
+import com.formdev.flatlaf.util.HiDPIUtils;
 import com.formdev.flatlaf.util.LoggingFacade;
 import com.formdev.flatlaf.util.SystemInfo;
 
@@ -86,20 +94,24 @@ import com.formdev.flatlaf.util.SystemInfo;
  * @uiDefault ComboBox.padding					Insets
  * @uiDefault ComboBox.squareButton				boolean	default is true
  *
+ * <!-- BasicComboPopup -->
+ *
+ * @uiDefault ComboBox.selectionBackground		Color
+ * @uiDefault ComboBox.selectionForeground		Color
+ *
  * <!-- FlatComboBoxUI -->
  *
  * @uiDefault ComboBox.minimumWidth				int
  * @uiDefault ComboBox.editorColumns			int
  * @uiDefault ComboBox.maximumRowCount			int
- * @uiDefault ComboBox.buttonStyle				String	auto (default), button or none
+ * @uiDefault ComboBox.buttonStyle				String	auto (default), button, mac or none
  * @uiDefault Component.arrowType				String	chevron (default) or triangle
- * @uiDefault Component.isIntelliJTheme			boolean
  * @uiDefault ComboBox.editableBackground		Color	optional; defaults to ComboBox.background
  * @uiDefault ComboBox.focusedBackground		Color	optional
  * @uiDefault ComboBox.disabledBackground		Color
  * @uiDefault ComboBox.disabledForeground		Color
- * @uiDefault ComboBox.buttonBackground			Color
- * @uiDefault ComboBox.buttonEditableBackground	Color
+ * @uiDefault ComboBox.buttonBackground			Color	optional
+ * @uiDefault ComboBox.buttonEditableBackground	Color	optional
  * @uiDefault ComboBox.buttonFocusedBackground	Color	optional; defaults to ComboBox.focusedBackground
  * @uiDefault ComboBox.buttonSeparatorWidth		int or float	optional; defaults to Component.borderWidth
  * @uiDefault ComboBox.buttonSeparatorColor		Color	optional
@@ -109,19 +121,24 @@ import com.formdev.flatlaf.util.SystemInfo;
  * @uiDefault ComboBox.buttonHoverArrowColor	Color
  * @uiDefault ComboBox.buttonPressedArrowColor	Color
  * @uiDefault ComboBox.popupBackground			Color	optional
+ * @uiDefault ComboBox.popupInsets				Insets
+ * @uiDefault ComboBox.selectionInsets			Insets
+ * @uiDefault ComboBox.selectionArc				int
  *
  * @author Karl Tauber
  */
+@StyleableField( cls=BasicComboBoxUI.class, key="padding" )
+
 public class FlatComboBoxUI
 	extends BasicComboBoxUI
-	implements StyleableUI
+	implements StyleableUI, StyleableLookupProvider
 {
 	@Styleable protected int minimumWidth;
 	@Styleable protected int editorColumns;
 	@Styleable protected String buttonStyle;
 	@Styleable protected String arrowType;
-	protected boolean isIntelliJTheme;
 
+	private Color background;
 	@Styleable protected Color editableBackground;
 	@Styleable protected Color focusedBackground;
 	@Styleable protected Color disabledBackground;
@@ -139,6 +156,9 @@ public class FlatComboBoxUI
 	@Styleable protected Color buttonPressedArrowColor;
 
 	@Styleable protected Color popupBackground;
+	/** @since 3 */ @Styleable protected Insets popupInsets;
+	/** @since 3 */ @Styleable protected Insets selectionInsets;
+	/** @since 3 */ @Styleable protected int selectionArc;
 
 	private MouseListener hoverListener;
 	protected boolean hover;
@@ -155,8 +175,18 @@ public class FlatComboBoxUI
 
 	@Override
 	public void installUI( JComponent c ) {
+		if( FlatUIUtils.needsLightAWTPeer( c ) )
+			FlatUIUtils.runWithLightAWTPeerUIDefaults( () -> installUIImpl( c ) );
+		else
+			installUIImpl( c );
+	}
+
+	private void installUIImpl( JComponent c ) {
 		super.installUI( c );
 
+		// install key selection manager that shows popup when Space key is pressed
+		comboBox.setKeySelectionManager( new FlatKeySelectionManager( comboBox.getKeySelectionManager() ) );
+
 		installStyle();
 	}
 
@@ -191,10 +221,12 @@ public class FlatComboBoxUI
 
 			private void repaintArrowButton() {
 				if( arrowButton != null && !comboBox.isEditable() )
-					arrowButton.repaint();
+					HiDPIUtils.repaint( arrowButton );
 			}
 		};
 		comboBox.addMouseListener( hoverListener );
+
+		MigLayoutVisualPadding.install( comboBox );
 	}
 
 	@Override
@@ -203,6 +235,8 @@ public class FlatComboBoxUI
 
 		comboBox.removeMouseListener( hoverListener );
 		hoverListener = null;
+
+		MigLayoutVisualPadding.uninstall( comboBox );
 	}
 
 	@Override
@@ -215,8 +249,8 @@ public class FlatComboBoxUI
 		editorColumns = UIManager.getInt( "ComboBox.editorColumns" );
 		buttonStyle = UIManager.getString( "ComboBox.buttonStyle" );
 		arrowType = UIManager.getString( "Component.arrowType" );
-		isIntelliJTheme = UIManager.getBoolean( "Component.isIntelliJTheme" );
 
+		background = UIManager.getColor( "ComboBox.background" );
 		editableBackground = UIManager.getColor( "ComboBox.editableBackground" );
 		focusedBackground = UIManager.getColor( "ComboBox.focusedBackground" );
 		disabledBackground = UIManager.getColor( "ComboBox.disabledBackground" );
@@ -234,6 +268,9 @@ public class FlatComboBoxUI
 		buttonPressedArrowColor = UIManager.getColor( "ComboBox.buttonPressedArrowColor" );
 
 		popupBackground = UIManager.getColor( "ComboBox.popupBackground" );
+		popupInsets = UIManager.getInsets( "ComboBox.popupInsets" );
+		selectionInsets = UIManager.getInsets( "ComboBox.selectionInsets" );
+		selectionArc = UIManager.getInt( "ComboBox.selectionArc" );
 
 		// set maximumRowCount
 		int maximumRowCount = UIManager.getInt( "ComboBox.maximumRowCount" );
@@ -241,14 +278,13 @@ public class FlatComboBoxUI
 			comboBox.setMaximumRowCount( maximumRowCount );
 
 		paddingBorder = new CellPaddingBorder( padding );
-
-		MigLayoutVisualPadding.install( comboBox );
 	}
 
 	@Override
 	protected void uninstallDefaults() {
 		super.uninstallDefaults();
 
+		background = null;
 		editableBackground = null;
 		focusedBackground = null;
 		disabledBackground = null;
@@ -270,8 +306,6 @@ public class FlatComboBoxUI
 
 		oldStyleValues = null;
 		borderShared = null;
-
-		MigLayoutVisualPadding.uninstall( comboBox );
 	}
 
 	@Override
@@ -281,15 +315,21 @@ public class FlatComboBoxUI
 			public void layoutContainer( Container parent ) {
 				super.layoutContainer( parent );
 
-				if( arrowButton != null ) {
+				// on macOS, a Swing combo box is used for AWT component java.awt.Choice
+				// and the font may be (temporary) null
+
+				if( arrowButton != null && comboBox.getFont() != null ) {
 					// limit button width to height of a raw combobox (without insets)
 					FontMetrics fm = comboBox.getFontMetrics( comboBox.getFont() );
 					int maxButtonWidth = fm.getHeight() + scale( padding.top ) + scale( padding.bottom );
+					int minButtonWidth = (maxButtonWidth * 3) / 4;
 
+					// make button square (except if width is limited)
 					Insets insets = getInsets();
-					int buttonWidth = Math.min( parent.getPreferredSize().height - insets.top - insets.bottom, maxButtonWidth );
+					int buttonWidth = Math.min( Math.max( parent.getHeight() - insets.top - insets.bottom, minButtonWidth ), maxButtonWidth );
+
 					if( buttonWidth != arrowButton.getWidth() ) {
-						// set width of arrow button to preferred height of combobox
+						// set width of arrow button
 						int xOffset = comboBox.getComponentOrientation().isLeftToRight()
 							? arrowButton.getWidth() - buttonWidth
 							: 0;
@@ -312,15 +352,15 @@ public class FlatComboBoxUI
 			@Override
 			public void focusGained( FocusEvent e ) {
 				super.focusGained( e );
-				if( comboBox != null && comboBox.isEditable() )
-					comboBox.repaint();
+				if( comboBox != null )
+					HiDPIUtils.repaint( comboBox );
 			}
 
 			@Override
 			public void focusLost( FocusEvent e ) {
 				super.focusLost( e );
-				if( comboBox != null && comboBox.isEditable() )
-					comboBox.repaint();
+				if( comboBox != null )
+					HiDPIUtils.repaint( comboBox );
 			}
 		};
 	}
@@ -347,11 +387,12 @@ public class FlatComboBoxUI
 				switch( propertyName ) {
 					case PLACEHOLDER_TEXT:
 						if( editor != null )
-							editor.repaint();
+							HiDPIUtils.repaint( editor );
 						break;
 
 					case COMPONENT_ROUND_RECT:
-						comboBox.repaint();
+					case OUTLINE:
+						HiDPIUtils.repaint( comboBox );
 						break;
 
 					case MINIMUM_WIDTH:
@@ -362,7 +403,7 @@ public class FlatComboBoxUI
 					case STYLE_CLASS:
 						installStyle();
 						comboBox.revalidate();
-						comboBox.repaint();
+						HiDPIUtils.repaint( comboBox );
 						break;
 				}
 			}
@@ -482,13 +523,6 @@ public class FlatComboBoxUI
 
 	/** @since 2 */
 	protected Object applyStyleProperty( String key, Object value ) {
-		// BasicComboBoxUI
-		if( key.equals( "padding" ) ) {
-			Object oldValue = padding;
-			padding = (Insets) value;
-			return oldValue;
-		}
-
 		if( borderShared == null )
 			borderShared = new AtomicBoolean( true );
 		return FlatStylingSupport.applyToAnnotatedObjectOrBorder( this, key, value, comboBox, borderShared );
@@ -497,11 +531,21 @@ public class FlatComboBoxUI
 	/** @since 2 */
 	@Override
 	public Map<String, Class<?>> getStyleableInfos( JComponent c ) {
-		Map<String, Class<?>> infos = new FlatStylingSupport.StyleableInfosMap<>();
-		infos.put( "padding", Insets.class );
-		FlatStylingSupport.collectAnnotatedStyleableInfos( this, infos );
-		FlatStylingSupport.collectStyleableInfos( comboBox.getBorder(), infos );
-		return infos;
+		return FlatStylingSupport.getAnnotatedStyleableInfos( this, comboBox.getBorder() );
+	}
+
+	/** @since 2.5 */
+	@Override
+	public Object getStyleableValue( JComponent c, String key ) {
+		return FlatStylingSupport.getAnnotatedStyleableValue( this, comboBox.getBorder(), key );
+	}
+
+	/** @since 2.5 */
+	@Override
+	public MethodHandles.Lookup getLookupForStyling() {
+		// MethodHandles.lookup() is caller sensitive and must be invoked in this class,
+		// otherwise it is not possible to access protected fields in JRE superclass
+		return MethodHandles.lookup();
 	}
 
 	@Override
@@ -529,7 +573,9 @@ public class FlatComboBoxUI
 		int height = c.getHeight();
 		int arrowX = arrowButton.getX();
 		int arrowWidth = arrowButton.getWidth();
-		boolean paintButton = (comboBox.isEditable() || "button".equals( buttonStyle )) && !"none".equals( buttonStyle );
+		boolean paintButton = (comboBox.isEditable() || "button".equals( buttonStyle )) &&
+			!"none".equals( buttonStyle ) &&
+			!isMacStyle();
 		boolean enabled = comboBox.isEnabled();
 		boolean isLeftToRight = comboBox.getComponentOrientation().isLeftToRight();
 
@@ -539,25 +585,36 @@ public class FlatComboBoxUI
 			FlatUIUtils.paintComponentBackground( g2, 0, 0, width, height, focusWidth, arc );
 
 			// paint arrow button background
-			if( enabled && !isCellRenderer ) {
-				g2.setColor( paintButton
+			if( enabled && !isCellRenderer && arrowButton.isVisible() ) {
+				Color buttonColor = paintButton
 					? buttonEditableBackground
 					: (buttonFocusedBackground != null || focusedBackground != null) && isPermanentFocusOwner( comboBox )
 						? (buttonFocusedBackground != null ? buttonFocusedBackground : focusedBackground)
-						: buttonBackground );
-				Shape oldClip = g2.getClip();
-				if( isLeftToRight )
-					g2.clipRect( arrowX, 0, width - arrowX, height );
-				else
-					g2.clipRect( 0, 0, arrowX + arrowWidth, height );
-				FlatUIUtils.paintComponentBackground( g2, 0, 0, width, height, focusWidth, arc );
-				g2.setClip( oldClip );
+						: buttonBackground;
+				if( buttonColor != null ) {
+					g2.setColor( buttonColor );
+					if( isMacStyle() ) {
+						Insets insets = comboBox.getInsets();
+						int gap = scale( 2 );
+						FlatUIUtils.paintComponentBackground( g2, arrowX + gap, insets.top + gap,
+							arrowWidth - (gap * 2), height - insets.top - insets.bottom - (gap * 2),
+							0, arc - focusWidth );
+					} else {
+						Shape oldClip = g2.getClip();
+						if( isLeftToRight )
+							g2.clipRect( arrowX, 0, width - arrowX, height );
+						else
+							g2.clipRect( 0, 0, arrowX + arrowWidth, height );
+						FlatUIUtils.paintComponentBackground( g2, 0, 0, width, height, focusWidth, arc );
+						g2.setClip( oldClip );
+					}
+				}
 			}
 
 			// paint vertical line between value and arrow button
-			if( paintButton ) {
+			if( paintButton && arrowButton.isVisible() ) {
 				Color separatorColor = enabled ? buttonSeparatorColor : buttonDisabledSeparatorColor;
-				if( separatorColor != null ) {
+				if( separatorColor != null && buttonSeparatorWidth > 0 ) {
 					g2.setColor( separatorColor );
 					float lw = scale( buttonSeparatorWidth );
 					float lx = isLeftToRight ? arrowX : arrowX + arrowWidth - lw;
@@ -596,7 +653,7 @@ public class FlatComboBoxUI
 
 		boolean shouldValidate = (c instanceof JPanel);
 
-		paddingBorder.install( c );
+		paddingBorder.install( c, 0 );
 		currentValuePane.paintComponent( g, c, comboBox, bounds.x, bounds.y, bounds.width, bounds.height, shouldValidate );
 		paddingBorder.uninstall();
 
@@ -611,6 +668,9 @@ public class FlatComboBoxUI
 
 	protected Color getBackground( boolean enabled ) {
 		if( enabled ) {
+			if( FlatUIUtils.isAWTPeer( comboBox ) )
+				return background;
+
 			Color background = comboBox.getBackground();
 
 			// always use explicitly set color
@@ -623,7 +683,7 @@ public class FlatComboBoxUI
 
 			return (editableBackground != null && comboBox.isEditable()) ? editableBackground : background;
 		} else
-			return isIntelliJTheme ? FlatUIUtils.getParentBackground( comboBox ) : disabledBackground;
+			return disabledBackground;
 	}
 
 	protected Color getForeground( boolean enabled ) {
@@ -670,7 +730,7 @@ public class FlatComboBoxUI
 
 	@Override
 	protected Dimension getSizeForComponent( Component comp ) {
-		paddingBorder.install( comp );
+		paddingBorder.install( comp, 0 );
 		Dimension size = super.getSizeForComponent( comp );
 		paddingBorder.uninstall();
 		return size;
@@ -686,6 +746,10 @@ public class FlatComboBoxUI
 		return parentParent != null && !comboBox.getBackground().equals( parentParent.getBackground() );
 	}
 
+	private boolean isMacStyle() {
+		return "mac".equals( buttonStyle );
+	}
+
 	/** @since 1.3 */
 	public static boolean isPermanentFocusOwner( JComboBox<?> comboBox ) {
 		if( comboBox.isEditable() ) {
@@ -693,7 +757,7 @@ public class FlatComboBoxUI
 				return true;
 
 			Component editorComponent = comboBox.getEditor().getEditorComponent();
-			return (editorComponent != null) ? FlatUIUtils.isPermanentFocusOwner( editorComponent ) : false;
+			return editorComponent != null && FlatUIUtils.isPermanentFocusOwner( editorComponent );
 		} else
 			return FlatUIUtils.isPermanentFocusOwner( comboBox );
 	}
@@ -720,6 +784,21 @@ public class FlatComboBoxUI
 				buttonHoverArrowColor, null, buttonPressedArrowColor, null );
 		}
 
+		@Override
+		public int getArrowWidth() {
+			return isMacStyle() ? (getWidth() % 2 == 0 ? 6 : 7) : super.getArrowWidth();
+		}
+
+		@Override
+		public float getArrowThickness() {
+			return isMacStyle() ? 1.5f : super.getArrowThickness();
+		}
+
+		@Override
+		public boolean isRoundBorderAutoXOffset() {
+			return isMacStyle() ? false : super.isRoundBorderAutoXOffset();
+		}
+
 		@Override
 		protected boolean isHover() {
 			return super.isHover() || (!comboBox.isEditable() ? hover : false);
@@ -737,6 +816,20 @@ public class FlatComboBoxUI
 
 			return super.getArrowColor();
 		}
+
+		@Override
+		protected void paintArrow( Graphics2D g ) {
+			if( isMacStyle() && !comboBox.isEditable() ) {
+				// for style "mac", paint up and down arrows if combobox is not editable
+				int height = getHeight();
+				int h = Math.round( height / 2f );
+				FlatUIUtils.paintArrow( g, 0, 0, getWidth(), h, SwingConstants.NORTH, chevron,
+					getArrowWidth(), getArrowThickness(), getXOffset(), getYOffset() + 1.25f );
+				FlatUIUtils.paintArrow( g, 0, height - h, getWidth(), h, SwingConstants.SOUTH, chevron,
+					getArrowWidth(), getArrowThickness(), getXOffset(), getYOffset() - 1.25f );
+			} else
+				super.paintArrow( g );
+		}
 	}
 
 	//---- class FlatComboPopup -----------------------------------------------
@@ -771,18 +864,25 @@ public class FlatComboBoxUI
 				}
 			}
 
+			// for style "mac", add width of "checked item" icon
+			boolean isPopupOverComboBox = isPopupOverComboBox();
+			int selectedIndex = -1;
+			if( isPopupOverComboBox && (selectedIndex = comboBox.getSelectedIndex()) >= 0 )
+				displayWidth += MacCheckedItemIcon.INSTANCE.getIconWidth() + scale( CellPaddingBorder.MAC_STYLE_GAP );
+
 			// add width of vertical scroll bar
 			JScrollBar verticalScrollBar = scroller.getVerticalScrollBar();
 			if( verticalScrollBar != null )
 				displayWidth += verticalScrollBar.getPreferredSize().width;
 
 			// make popup wider if necessary
+			int pw0 = pw;
 			if( displayWidth > pw ) {
 				// limit popup width to screen width
 				GraphicsConfiguration gc = comboBox.getGraphicsConfiguration();
 				if( gc != null ) {
 					Rectangle screenBounds = gc.getBounds();
-					Insets screenInsets = Toolkit.getDefaultToolkit().getScreenInsets( gc );
+					Insets screenInsets = FlatUIUtils.getScreenInsets( gc );
 					displayWidth = Math.min( displayWidth, screenBounds.width - screenInsets.left - screenInsets.right );
 				} else {
 					Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
@@ -796,6 +896,30 @@ public class FlatComboBoxUI
 					px -= diff;
 			}
 
+			// for style "mac", place popup over combobox
+			Rectangle cellBounds;
+			if( isPopupOverComboBox && selectedIndex >= 0 &&
+				(cellBounds = list.getCellBounds( 0, 0 )) != null )
+			{
+				Insets comboBoxInsets = comboBox.getInsets();
+				Insets listInsets = list.getInsets();
+				Insets popupInsets = getInsets();
+
+				// position popup so that selected item is at same Y position as combobox
+				py -= (cellBounds.height * (selectedIndex + 1)) + comboBoxInsets.top + listInsets.top + popupInsets.top;
+
+				// position popup slightly to the left so that a small part of the right side of the combobox stays visible
+				int offset = Math.min( pw - pw0, MacCheckedItemIcon.INSTANCE.getIconWidth() ) + scale( 4 );
+				if( comboBox.getComponentOrientation().isLeftToRight() )
+					px -= offset + comboBoxInsets.right + listInsets.right;
+				else
+					px += offset + comboBoxInsets.left + listInsets.left;
+
+				// not invoking super.computePopupBounds() here to let
+				// JPopupMenu.adjustPopupLocationToFitScreen() fix the location if necessary
+				return new Rectangle( px, py, pw, ph );
+			}
+
 			return super.computePopupBounds( px, py, pw, ph );
 		}
 
@@ -803,17 +927,15 @@ public class FlatComboBoxUI
 		protected void configurePopup() {
 			super.configurePopup();
 
-			// make opaque to avoid that background shines thru border (e.g. at 150% scaling)
+			// make opaque to avoid that background shines through border (e.g. at 150% scaling)
 			setOpaque( true );
 
+			// set popup border
+			// use non-UIResource to avoid that it is overwritten when making
+			// popup visible (see JPopupMenu.setInvoker()) in theme editor preview
 			Border border = UIManager.getBorder( "PopupMenu.border" );
 			if( border != null )
-				setBorder( border );
-		}
-
-		@Override
-		protected void configureList() {
-			super.configureList();
+				setBorder( FlatUIUtils.nonUIResource( border ) );
 
 			list.setCellRenderer( new PopupListCellRenderer() );
 			updateStyle();
@@ -821,7 +943,21 @@ public class FlatComboBoxUI
 
 		void updateStyle() {
 			if( popupBackground != null )
-		        list.setBackground( popupBackground );
+				list.setBackground( popupBackground );
+
+			// set popup background because it may shine through when scaled (e.g. at 150%)
+			// use non-UIResource to avoid that it is overwritten when making
+			// popup visible (see JPopupMenu.setInvoker()) in theme editor preview
+			setBackground( FlatUIUtils.nonUIResource( list.getBackground() ) );
+
+			scroller.setViewportBorder( (popupInsets != null) ? new FlatEmptyBorder( popupInsets ) : null );
+			scroller.setOpaque( false );
+
+			if( list.getUI() instanceof FlatListUI ) {
+				FlatListUI ui = (FlatListUI) list.getUI();
+				ui.selectionInsets = selectionInsets;
+				ui.selectionArc = selectionArc;
+			}
 		}
 
 		@Override
@@ -854,6 +990,29 @@ public class FlatComboBoxUI
 				}
 			}
 
+			// improve location of selected item in popup if list is large and scrollable
+			if( list.getHeight() == 0 ) {
+				// If popup is shown for the first time (or after a laf switch) and is scrollable,
+				// then BasicComboPopup scrolls the selected item to the top of the visible area.
+				// But for usability it would be better to have selected item somewhere
+				// in the middle of the visible area so that the user can see items above
+				// the selected item, which are usually more "important".
+
+				int selectedIndex = list.getSelectedIndex();
+				if( selectedIndex >= 1 ) {
+					int maximumRowCount = comboBox.getMaximumRowCount();
+					if( selectedIndex < maximumRowCount ) {
+						// selected item is in the first visible items --> scroll to top
+						list.scrollRectToVisible( new Rectangle() );
+					} else {
+						// scroll the selected item to the middle of the visible area
+						int firstVisibleIndex = Math.max( selectedIndex - (maximumRowCount / 2), 0 );
+						if( firstVisibleIndex > 0 )
+							list.ensureIndexIsVisible( firstVisibleIndex );
+					}
+				}
+			}
+
 			super.show( invoker, x, y );
 		}
 
@@ -863,6 +1022,15 @@ public class FlatComboBoxUI
 			paddingBorder.uninstall();
 		}
 
+		private boolean isPopupOverComboBox() {
+			return isMacStyle() &&
+				!comboBox.isEditable() &&
+				comboBox.getItemCount() > 0 &&
+				comboBox.getItemCount() <= comboBox.getMaximumRowCount() &&
+				// for compatibility with Aqua Laf
+				!clientPropertyBoolean( comboBox, "JComboBox.isPopDown", false );
+		}
+
 		//---- class PopupListCellRenderer -----
 
 		private class PopupListCellRenderer
@@ -880,7 +1048,14 @@ public class FlatComboBoxUI
 				Component c = renderer.getListCellRendererComponent( list, value, index, isSelected, cellHasFocus );
 				c.applyComponentOrientation( comboBox.getComponentOrientation() );
 
-				paddingBorder.install( c );
+				// style "mac"
+				if( isPopupOverComboBox() && c instanceof JComponent ) {
+					int selectedIndex = comboBox.getSelectedIndex();
+					((JComponent)c).putClientProperty( CellPaddingBorder.KEY_MAC_STYLE_HINT,
+						(selectedIndex >= 0) ? (index == selectedIndex) : null );
+				}
+
+				paddingBorder.install( c, Math.round( FlatUIUtils.getBorderFocusWidth( comboBox ) ) );
 
 				return c;
 			}
@@ -896,22 +1071,33 @@ public class FlatComboBoxUI
 	 * which vertically aligns text in popup list with text in combobox.
 	 * <p>
 	 * The renderer border is painted on the outer side of this border.
+	 * <p>
+	 * For button style "mac", also used to increase insets on left side for
+	 * "checked item" icon and to paint "checked item" icon for selected combobox item.
 	 */
 	private static class CellPaddingBorder
 		extends AbstractBorder
 	{
+		static final String KEY_MAC_STYLE_HINT = "FlatLaf.internal.FlatComboBoxUI.macStyleHint";
+		static final int MAC_STYLE_GAP = 4;
+
 		private Insets padding;
 		private JComponent rendererComponent;
 		private Border rendererBorder;
+		private int focusWidth;
 
 		CellPaddingBorder( Insets padding ) {
 			this.padding = padding;
 		}
 
-		void install( Component c ) {
+		// using synchronized to avoid problems with code that modifies combo box
+		// (model, selection, etc.) not on AWT thread (which should be not done)
+		synchronized void install( Component c, int focusWidth ) {
 			if( !(c instanceof JComponent) )
 				return;
 
+			this.focusWidth = focusWidth;
+
 			JComponent jc = (JComponent) c;
 			Border oldBorder = jc.getBorder();
 			if( oldBorder == this )
@@ -940,10 +1126,12 @@ public class FlatComboBoxUI
 		 * there is no single place to uninstall it.
 		 * This is the reason why this method is called from various places.
 		 */
-		void uninstall() {
+		synchronized void uninstall() {
 			if( rendererComponent == null )
 				return;
 
+			rendererComponent.putClientProperty( KEY_MAC_STYLE_HINT, null );
+
 			if( rendererComponent.getBorder() == this )
 				rendererComponent.setBorder( rendererBorder );
 			rendererComponent = null;
@@ -951,9 +1139,9 @@ public class FlatComboBoxUI
 		}
 
 		@Override
-		public Insets getBorderInsets( Component c, Insets insets ) {
+		synchronized public Insets getBorderInsets( Component c, Insets insets ) {
 			Insets padding = scale( this.padding );
-			if( rendererBorder != null ) {
+			if( rendererBorder != null && !(rendererBorder instanceof CellPaddingBorder) ) {
 				Insets insideInsets = rendererBorder.getBorderInsets( c );
 				insets.top = Math.max( padding.top, insideInsets.top );
 				insets.left = Math.max( padding.left, insideInsets.left );
@@ -965,6 +1153,24 @@ public class FlatComboBoxUI
 				insets.bottom = padding.bottom;
 				insets.right = padding.right;
 			}
+
+			// if used in popup list, add focus width for exact vertical alignment
+			// of text in popup list with text in combobox
+			insets.left += focusWidth;
+			insets.right += focusWidth;
+
+			// style "mac"
+			if( c instanceof JComponent ) {
+				Boolean macStyleHint = clientPropertyBooleanStrict( (JComponent) c, KEY_MAC_STYLE_HINT, null );
+				if( macStyleHint != null ) {
+					int indent = MacCheckedItemIcon.INSTANCE.getIconWidth() + scale( MAC_STYLE_GAP );
+					if( c.getComponentOrientation().isLeftToRight() )
+						insets.left += indent;
+					else
+						insets.right += indent;
+				}
+			}
+
 			return insets;
 		}
 
@@ -972,6 +1178,35 @@ public class FlatComboBoxUI
 		public void paintBorder( Component c, Graphics g, int x, int y, int width, int height ) {
 			if( rendererBorder != null )
 				rendererBorder.paintBorder( c, g, x, y, width, height );
+
+			// style "mac"
+			if( c instanceof JComponent ) {
+				Boolean macStyleHint = clientPropertyBooleanStrict( (JComponent) c, KEY_MAC_STYLE_HINT, null );
+				if( macStyleHint == Boolean.TRUE ) {
+					// paint "checked item" icon
+					int ix = c.getComponentOrientation().isLeftToRight()
+						? x + scale( padding.left )
+						: x + width - scale( padding.right ) - MacCheckedItemIcon.INSTANCE.getIconWidth();
+					MacCheckedItemIcon.INSTANCE.paintIcon( c, g, ix, y + ((height - MacCheckedItemIcon.INSTANCE.getIconHeight()) / 2) );
+				}
+			}
+		}
+	}
+
+	//---- class MacCheckedItemIcon -------------------------------------------
+
+	/**
+	 * Use for style "mac" to mark checked item.
+	 */
+	private static class MacCheckedItemIcon
+		extends FlatCheckBoxMenuItemIcon
+	{
+		static MacCheckedItemIcon INSTANCE = new MacCheckedItemIcon();
+
+		@Override
+		protected void paintIcon( Component c, Graphics2D g2 ) {
+			g2.setColor( c.getForeground() );
+			paintCheckmark( g2 );
 		}
 	}
 
@@ -1001,4 +1236,46 @@ public class FlatComboBoxUI
 			}
 		}
 	}
+
+	//---- class FlatKeySelectionManager --------------------------------------
+
+	/**
+	 * Key selection manager that delegates to the default manager.
+	 * Shows the popup if Space key is pressed and "typed characters" buffer is empty.
+	 * If items contain spaces (e.g. "a b") it is still possible to select them
+	 * by pressing keys 'a', 'Space' and 'b'.
+	 */
+	private class FlatKeySelectionManager
+		implements JComboBox.KeySelectionManager, UIResource
+	{
+		private final KeySelectionManager delegate;
+		private final long timeFactor;
+		private long lastTime;
+
+		FlatKeySelectionManager( JComboBox.KeySelectionManager delegate ) {
+			this.delegate = delegate;
+
+			Long value = (Long) UIManager.get( "ComboBox.timeFactor" );
+			timeFactor = (value != null) ? value : 1000;
+		}
+
+		@SuppressWarnings( "rawtypes" )
+		@Override
+		public int selectionForKey( char aKey, ComboBoxModel aModel ) {
+			long time = EventQueue.getMostRecentEventTime();
+			long oldLastTime = lastTime;
+			lastTime = time;
+
+			// SPACE key shows popup if not yet visible
+			if( aKey == ' ' &&
+				time - oldLastTime >= timeFactor &&
+				!comboBox.isPopupVisible() )
+			{
+				comboBox.setPopupVisible( true );
+				return -1;
+			}
+
+			return delegate.selectionForKey( aKey, aModel );
+		}
+	}
 }

flatlaf-core/src/main/java/com/formdev/flatlaf/ui/FlatDropShadowBorder.java

@@ -74,7 +74,7 @@ public class FlatDropShadowBorder
 
 		this.shadowColor = shadowColor;
 		this.shadowInsets = shadowInsets;
-		this.shadowOpacity = shadowOpacity;
+		this.shadowOpacity = Math.min( Math.max( shadowOpacity, 0f ), 1f );
 
 		shadowSize = maxInset( shadowInsets );
 	}
@@ -107,6 +107,12 @@ public class FlatDropShadowBorder
 		return FlatStylingSupport.getAnnotatedStyleableInfos( this );
 	}
 
+	/** @since 2.5 */
+	@Override
+	public Object getStyleableValue( String key ) {
+		return FlatStylingSupport.getAnnotatedStyleableValue( this, key );
+	}
+
 	@Override
 	public void paintBorder( Component c, Graphics g, int x, int y, int width, int height ) {
 		if( shadowSize <= 0 )

flatlaf-core/src/main/java/com/formdev/flatlaf/ui/FlatEditorPaneUI.java

@@ -44,8 +44,8 @@ import com.formdev.flatlaf.util.LoggingFacade;
  * <!-- BasicEditorPaneUI -->
  *
  * @uiDefault EditorPane.font					Font
- * @uiDefault EditorPane.background				Color	also used if not editable
- * @uiDefault EditorPane.foreground				Color
+ * @uiDefault EditorPane.background				Color
+ * @uiDefault EditorPane.foreground				Color	also used if not editable
  * @uiDefault EditorPane.caretForeground		Color
  * @uiDefault EditorPane.selectionBackground	Color
  * @uiDefault EditorPane.selectionForeground	Color
@@ -59,7 +59,6 @@ import com.formdev.flatlaf.util.LoggingFacade;
  * <!-- FlatEditorPaneUI -->
  *
  * @uiDefault Component.minimumWidth			int
- * @uiDefault Component.isIntelliJTheme			boolean
  * @uiDefault EditorPane.focusedBackground		Color	optional
  *
  * @author Karl Tauber
@@ -69,7 +68,6 @@ public class FlatEditorPaneUI
 	implements StyleableUI
 {
 	@Styleable protected int minimumWidth;
-	protected boolean isIntelliJTheme;
 	private Color background;
 	@Styleable protected Color disabledBackground;
 	@Styleable protected Color inactiveBackground;
@@ -101,7 +99,6 @@ public class FlatEditorPaneUI
 
 		String prefix = getPropertyPrefix();
 		minimumWidth = UIManager.getInt( "Component.minimumWidth" );
-		isIntelliJTheme = UIManager.getBoolean( "Component.isIntelliJTheme" );
 		background = UIManager.getColor( prefix + ".background" );
 		disabledBackground = UIManager.getColor( prefix + ".disabledBackground" );
 		inactiveBackground = UIManager.getColor( prefix + ".inactiveBackground" );
@@ -174,7 +171,7 @@ public class FlatEditorPaneUI
 			case FlatClientProperties.STYLE_CLASS:
 				installStyle.run();
 				c.revalidate();
-				c.repaint();
+				HiDPIUtils.repaint( c );
 				break;
 		}
 	}
@@ -209,6 +206,12 @@ public class FlatEditorPaneUI
 		return FlatStylingSupport.getAnnotatedStyleableInfos( this );
 	}
 
+	/** @since 2.5 */
+	@Override
+	public Object getStyleableValue( JComponent c, String key ) {
+		return FlatStylingSupport.getAnnotatedStyleableValue( this, key );
+	}
+
 	private void updateBackground() {
 		FlatTextFieldUI.updateBackground( getComponent(), background,
 			disabledBackground, inactiveBackground,
@@ -246,11 +249,11 @@ public class FlatEditorPaneUI
 
 	@Override
 	protected void paintBackground( Graphics g ) {
-		paintBackground( g, getComponent(), isIntelliJTheme, focusedBackground );
+		paintBackground( g, getComponent(), focusedBackground );
 	}
 
-	static void paintBackground( Graphics g, JTextComponent c, boolean isIntelliJTheme, Color focusedBackground ) {
-		g.setColor( FlatTextFieldUI.getBackground( c, isIntelliJTheme, focusedBackground ) );
+	static void paintBackground( Graphics g, JTextComponent c, Color focusedBackground ) {
+		g.setColor( FlatTextFieldUI.getBackground( c, focusedBackground ) );
 		g.fillRect( 0, 0, c.getWidth(), c.getHeight() );
 	}
 }

flatlaf-core/src/main/java/com/formdev/flatlaf/ui/FlatEmptyBorder.java

@@ -56,7 +56,7 @@ public class FlatEmptyBorder
 	protected static Insets scaleInsets( Component c, Insets insets,
 		int top, int left, int bottom, int right )
 	{
-		boolean leftToRight = left == right || c.getComponentOrientation().isLeftToRight();
+		boolean leftToRight = left == right || c == null || c.getComponentOrientation().isLeftToRight();
 		insets.left = scale( leftToRight ? left : right );
 		insets.top = scale( top );
 		insets.right = scale( leftToRight ? right : left );
@@ -76,4 +76,9 @@ public class FlatEmptyBorder
 		right = insets.right;
 		return oldInsets;
 	}
+
+	/** @since 2.5 */
+	public Insets getStyleableValue() {
+		return new Insets( top, left, bottom, right );
+	}
 }

flatlaf-core/src/main/java/com/formdev/flatlaf/ui/FlatFileChooserUI.java

@@ -19,11 +19,24 @@ package com.formdev.flatlaf.ui;
 import java.awt.BorderLayout;
 import java.awt.Component;
 import java.awt.Dimension;
+import java.awt.Graphics;
+import java.awt.Graphics2D;
+import java.awt.Image;
 import java.awt.Insets;
+import java.awt.LayoutManager;
+import java.awt.Rectangle;
+import java.awt.RenderingHints;
+import java.beans.PropertyChangeEvent;
+import java.beans.PropertyChangeListener;
 import java.io.File;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.function.Function;
 import javax.swing.AbstractButton;
+import javax.swing.BorderFactory;
 import javax.swing.Box;
 import javax.swing.BoxLayout;
+import javax.swing.ButtonGroup;
 import javax.swing.Icon;
 import javax.swing.ImageIcon;
 import javax.swing.JButton;
@@ -34,12 +47,18 @@ import javax.swing.JPanel;
 import javax.swing.JScrollPane;
 import javax.swing.JTable;
 import javax.swing.JToggleButton;
+import javax.swing.JToolBar;
+import javax.swing.Scrollable;
+import javax.swing.SwingConstants;
 import javax.swing.UIManager;
+import javax.swing.filechooser.FileSystemView;
 import javax.swing.filechooser.FileView;
 import javax.swing.plaf.ComponentUI;
 import javax.swing.plaf.metal.MetalFileChooserUI;
 import javax.swing.table.TableCellRenderer;
 import com.formdev.flatlaf.FlatClientProperties;
+import com.formdev.flatlaf.icons.FlatFileViewDirectoryIcon;
+import com.formdev.flatlaf.util.LoggingFacade;
 import com.formdev.flatlaf.util.ScaledImageIcon;
 import com.formdev.flatlaf.util.SystemInfo;
 import com.formdev.flatlaf.util.UIScale;
@@ -133,12 +152,22 @@ import com.formdev.flatlaf.util.UIScale;
  * @uiDefault FileChooser.listViewActionLabelText				String
  * @uiDefault FileChooser.detailsViewActionLabelText			String
  *
+ * <!-- FlatFileChooserUI -->
+ *
+ * @uiDefault FileChooser.shortcuts.buttonSize					Dimension	optional; default is 84,64
+ * @uiDefault FileChooser.shortcuts.iconSize					Dimension	optional; default is 32,32
+ * @uiDefault FileChooser.shortcuts.filesFunction				Function&lt;File[], File[]&gt;
+ * @uiDefault FileChooser.shortcuts.displayNameFunction			Function&lt;File, String&gt;
+ * @uiDefault FileChooser.shortcuts.iconFunction				Function&lt;File, Icon&gt;
+ *
  * @author Karl Tauber
  */
 public class FlatFileChooserUI
 	extends MetalFileChooserUI
 {
 	private final FlatFileView fileView = new FlatFileView();
+	private FlatShortcutsPanel shortcutsPanel;
+	private JScrollPane shortcutsScrollPane;
 
 	public static ComponentUI createUI( JComponent c ) {
 		return new FlatFileChooserUI( (JFileChooser) c );
@@ -153,6 +182,29 @@ public class FlatFileChooserUI
 		super.installComponents( fc );
 
 		patchUI( fc );
+
+		if( !UIManager.getBoolean( "FileChooser.noPlacesBar" ) ) { // same as in Windows L&F
+			FlatShortcutsPanel panel = createShortcutsPanel( fc );
+			if( panel.getComponentCount() > 0 ) {
+				shortcutsPanel = panel;
+				shortcutsScrollPane = new JScrollPane( shortcutsPanel,
+					JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED, JScrollPane.HORIZONTAL_SCROLLBAR_NEVER );
+				shortcutsScrollPane.setBorder( BorderFactory.createEmptyBorder() );
+				fc.add( shortcutsScrollPane, BorderLayout.LINE_START );
+				fc.addPropertyChangeListener( shortcutsPanel );
+			}
+		}
+	}
+
+	@Override
+	public void uninstallComponents( JFileChooser fc ) {
+		super.uninstallComponents( fc );
+
+		if( shortcutsPanel != null ) {
+			fc.removePropertyChangeListener( shortcutsPanel );
+			shortcutsPanel = null;
+			shortcutsScrollPane = null;
+		}
 	}
 
 	private void patchUI( JFileChooser fc ) {
@@ -192,6 +244,27 @@ public class FlatFileChooserUI
 		} catch( ArrayIndexOutOfBoundsException ex ) {
 			// ignore
 		}
+
+		// put north, center and south components into a new panel so that
+		// the shortcuts panel (at west) gets full height
+		LayoutManager layout = fc.getLayout();
+		if( layout instanceof BorderLayout ) {
+			BorderLayout borderLayout = (BorderLayout) layout;
+			borderLayout.setHgap( 8 );
+
+			Component north = borderLayout.getLayoutComponent( BorderLayout.NORTH );
+			Component lineEnd = borderLayout.getLayoutComponent( BorderLayout.LINE_END );
+			Component center = borderLayout.getLayoutComponent( BorderLayout.CENTER );
+			Component south = borderLayout.getLayoutComponent( BorderLayout.SOUTH );
+			if( north != null && lineEnd != null && center != null && south != null ) {
+				JPanel p = new JPanel( new BorderLayout( 0, 11 ) );
+				p.add( north, BorderLayout.NORTH );
+				p.add( lineEnd, BorderLayout.LINE_END );
+				p.add( center, BorderLayout.CENTER );
+				p.add( south, BorderLayout.SOUTH );
+				fc.add( p, BorderLayout.CENTER );
+			}
+		}
 	}
 
 	@Override
@@ -250,9 +323,19 @@ public class FlatFileChooserUI
 		return p;
 	}
 
+	/** @since 2.3 */
+	protected FlatShortcutsPanel createShortcutsPanel( JFileChooser fc ) {
+		return new FlatShortcutsPanel( fc );
+	}
+
 	@Override
 	public Dimension getPreferredSize( JComponent c ) {
-		return UIScale.scale( super.getPreferredSize( c ) );
+		Dimension prefSize = super.getPreferredSize( c );
+		Dimension minSize = getMinimumSize( c );
+		int shortcutsPanelWidth = (shortcutsScrollPane != null) ? shortcutsScrollPane.getPreferredSize().width : 0;
+		return new Dimension(
+			Math.max( prefSize.width, minSize.width + shortcutsPanelWidth ),
+			Math.max( prefSize.height, minSize.height ) );
 	}
 
 	@Override
@@ -273,9 +356,12 @@ public class FlatFileChooserUI
 			fileView.clearIconCache();
 	}
 
-	private boolean doNotUseSystemIcons() {
+	private static boolean doNotUseSystemIcons() {
 		// Java 17 32bit craches on Windows when using system icons
-		return SystemInfo.isWindows && SystemInfo.isJava_17_orLater && !SystemInfo.isX86_64;
+		// fixed in Java 18+, fix backported in Java 17.0.3+ (see https://bugs.openjdk.java.net/browse/JDK-8277299)
+		return SystemInfo.isWindows &&
+			SystemInfo.isX86 &&
+			(SystemInfo.isJava_17_orLater && SystemInfo.javaVersion < SystemInfo.toVersion( 17, 0, 3, 0 ));
 	}
 
 	//---- class FlatFileView -------------------------------------------------
@@ -290,27 +376,331 @@ public class FlatFileChooserUI
 			if( icon != null )
 				return icon;
 
-			// get system icon
-			if( f != null ) {
-				icon = getFileChooser().getFileSystemView().getSystemIcon( f );
+			// new proxy icon
+			//
+			// Note: Since this is a super light weight icon object, we do not add it
+			//       to the icon cache here. This keeps cache small in case of large directories
+			//       with thousands of files when icons of all files are only needed to compute
+			//       the layout of list/table, but never painted because located outside of visible area.
+			//       When an icon needs to be painted, the proxy adds it to the icon cache
+			//       and loads the real icon.
+			return new FlatFileViewIcon( f );
+		}
 
-				if( icon != null ) {
-					if( icon instanceof ImageIcon )
-						icon = new ScaledImageIcon( (ImageIcon) icon );
-					cacheIcon( f, icon );
+		//---- class FlatFileViewIcon -----------------------------------------
+
+		/**
+		 * A proxy icon that has a fixed (scaled) width/height (16x16) and
+		 * gets/loads the real (system) icon only for painting.
+		 * Avoids unnecessary getting/loading system icons.
+		 */
+		private class FlatFileViewIcon
+			implements Icon
+		{
+			private final File f;
+			private Icon realIcon;
+
+			FlatFileViewIcon( File f ) {
+				this.f = f;
+			}
+
+			@Override
+			public int getIconWidth() {
+				return UIScale.scale( 16 );
+			}
+
+			@Override
+			public int getIconHeight() {
+				return UIScale.scale( 16 );
+			}
+
+			@Override
+			public void paintIcon( Component c, Graphics g, int x, int y ) {
+				// get icon on demand
+				if( realIcon == null ) {
+					// get system icon
+					try {
+						if( f != null )
+							realIcon = getFileChooser().getFileSystemView().getSystemIcon( f );
+					} catch( NullPointerException ex ) {
+						// Java 21 may throw a NPE for exe files that use default Windows exe icon
+					}
+
+					// get default icon
+					if( realIcon == null )
+						realIcon = FlatFileView.super.getIcon( f );
+
+					if( realIcon instanceof ImageIcon )
+						realIcon = new ScaledImageIcon( (ImageIcon) realIcon );
+
+					cacheIcon( f, this );
+				}
+
+				realIcon.paintIcon( c, g, x, y );
+			}
+		}
+	}
+
+	//---- class FlatShortcutsPanel -------------------------------------------
+
+	/** @since 2.3 */
+	public static class FlatShortcutsPanel
+		extends JToolBar
+		implements PropertyChangeListener, Scrollable
+	{
+		private final JFileChooser fc;
+
+		private final Dimension buttonSize;
+		private final Dimension iconSize;
+		private final Function<File[], File[]> filesFunction;
+		private final Function<File, String> displayNameFunction;
+		private final Function<File, Icon> iconFunction;
+
+		protected final File[] files;
+		protected final JToggleButton[] buttons;
+		protected final ButtonGroup buttonGroup = new ButtonGroup();
+
+		@SuppressWarnings( "unchecked" )
+		public FlatShortcutsPanel( JFileChooser fc ) {
+			super( JToolBar.VERTICAL );
+			this.fc = fc;
+			setFloatable( false );
+			putClientProperty( FlatClientProperties.STYLE, "hoverButtonGroupBackground: null" );
+
+			buttonSize = UIScale.scale( getUIDimension( "FileChooser.shortcuts.buttonSize", 84, 64 ) );
+			iconSize = getUIDimension( "FileChooser.shortcuts.iconSize", 32, 32 );
+
+			filesFunction = (Function<File[], File[]>) UIManager.get( "FileChooser.shortcuts.filesFunction" );
+			displayNameFunction = (Function<File, String>) UIManager.get( "FileChooser.shortcuts.displayNameFunction" );
+			iconFunction = (Function<File, Icon>) UIManager.get( "FileChooser.shortcuts.iconFunction" );
+
+			FileSystemView fsv = fc.getFileSystemView();
+			File[] files = JavaCompatibility2.getChooserShortcutPanelFiles( fsv );
+			if( filesFunction != null )
+				files = filesFunction.apply( files );
+
+			// create toolbar buttons
+			ArrayList<File> filesList = new ArrayList<>();
+			ArrayList<JToggleButton> buttonsList = new ArrayList<>();
+			for( File file : files ) {
+				if( file == null )
+					continue;
+
+				// wrap drive path
+				if( fsv.isFileSystemRoot( file ) )
+					file = fsv.createFileObject( file.getAbsolutePath() );
+
+				String name = getDisplayName( fsv, file );
+				Icon icon = getIcon( fsv, file );
+				if( name == null )
+					continue;
+
+				// remove path from name
+				int lastSepIndex = name.lastIndexOf( File.separatorChar );
+				if( lastSepIndex >= 0 && lastSepIndex < name.length() - 1 )
+					name = name.substring( lastSepIndex + 1 );
+
+				// scale icon (if necessary)
+				if( icon instanceof ImageIcon )
+					icon = new ScaledImageIcon( (ImageIcon) icon, iconSize.width, iconSize.height );
+				else if( icon != null )
+					icon = new ShortcutIcon( icon, iconSize.width, iconSize.height );
+
+				// create button
+				JToggleButton button = createButton( name, icon, file.toString() );
+				File f = file;
+				button.addActionListener( e -> {
+					fc.setCurrentDirectory( f );
+				} );
+
+				add( button );
+				buttonGroup.add( button );
+
+				filesList.add( file );
+				buttonsList.add( button );
+			}
+
+			this.files = filesList.toArray( new File[filesList.size()] );
+			this.buttons = buttonsList.toArray( new JToggleButton[buttonsList.size()] );
+
+			directoryChanged( fc.getCurrentDirectory() );
+		}
+
+		private Dimension getUIDimension( String key, int defaultWidth, int defaultHeight ) {
+			Dimension size = UIManager.getDimension( key );
+			if( size == null )
+				size = new Dimension( defaultWidth, defaultHeight );
+			return size;
+		}
+
+		/** @since 3.5 */
+		protected JToggleButton createButton( String name, Icon icon, String toolTip ) {
+			JToggleButton button = new JToggleButton( name, icon );
+			button.setToolTipText( toolTip );
+			button.setVerticalTextPosition( SwingConstants.BOTTOM );
+			button.setHorizontalTextPosition( SwingConstants.CENTER );
+			button.setAlignmentX( Component.CENTER_ALIGNMENT );
+			button.setIconTextGap( 0 );
+			button.setPreferredSize( buttonSize );
+			button.setMaximumSize( buttonSize );
+			return button;
+		}
+
+		protected String getDisplayName( FileSystemView fsv, File file ) {
+			if( displayNameFunction != null ) {
+				String name = displayNameFunction.apply( file );
+				if( name != null )
+					return name;
+			}
+
+			return fsv.getSystemDisplayName( file );
+		}
+
+		protected Icon getIcon( FileSystemView fsv, File file ) {
+			if( iconFunction != null ) {
+				Icon icon = iconFunction.apply( file );
+				if( icon != null )
 					return icon;
+			}
+
+			if( doNotUseSystemIcons() )
+				return new FlatFileViewDirectoryIcon();
+
+			try {
+				// Java 17+ supports getting larger system icons
+				try {
+					if( SystemInfo.isJava_17_orLater ) {
+						Method m = fsv.getClass().getMethod( "getSystemIcon", File.class, int.class, int.class );
+						return (Icon) m.invoke( fsv, file, iconSize.width, iconSize.height );
+					} else if( iconSize.width > 16 || iconSize.height > 16 ) {
+						Class<?> cls = Class.forName( "sun.awt.shell.ShellFolder" );
+						if( cls.isInstance( file ) ) {
+							Method m = file.getClass().getMethod( "getIcon", boolean.class );
+							m.setAccessible( true );
+							Image image = (Image) m.invoke( file, true );
+							if( image != null )
+								return new ImageIcon( image );
+						}
+					}
+				} catch( Exception ex ) {
+					// do not log InaccessibleObjectException because access
+					// may be denied via VM option '--illegal-access=deny' (default in Java 16)
+					// (not catching InaccessibleObjectException here because it is new in Java 9, but FlatLaf also runs on Java 8)
+					if( !"java.lang.reflect.InaccessibleObjectException".equals( ex.getClass().getName() ) )
+						LoggingFacade.INSTANCE.logSevere( null, ex );
+				}
+
+				// get system icon in default size 16x16
+				return fsv.getSystemIcon( file );
+			} catch( NullPointerException ex ) {
+				// Java 21 may throw a NPE for exe files that use default Windows exe icon
+				return new FlatFileViewDirectoryIcon();
+			}
+		}
+
+		protected void directoryChanged( File file ) {
+			if( file != null ) {
+				String absolutePath = file.getAbsolutePath();
+				for( int i = 0; i < files.length; i++ ) {
+					// also compare path because otherwise selecting "Documents"
+					// in "Look in" combobox would not select "Documents" shortcut item
+					if( files[i].equals( file ) || files[i].getAbsolutePath().equals( absolutePath ) ) {
+						buttons[i].setSelected( true );
+						return;
+					}
 				}
 			}
 
-			// get default icon
-			icon = super.getIcon( f );
+			buttonGroup.clearSelection();
+		}
 
-			if( icon instanceof ImageIcon ) {
-				icon = new ScaledImageIcon( (ImageIcon) icon );
-				cacheIcon( f, icon );
+		//---- interface PropertyChangeListener ----
+
+		@Override
+		public void propertyChange( PropertyChangeEvent e ) {
+			switch( e.getPropertyName() ) {
+				case JFileChooser.DIRECTORY_CHANGED_PROPERTY:
+					directoryChanged( fc.getCurrentDirectory() );
+					break;
 			}
+		}
 
-			return icon;
+		//---- interface Scrollable ----
+
+		@Override
+		public Dimension getPreferredScrollableViewportSize() {
+			if( getComponentCount() > 0 ) {
+				Insets insets = getInsets();
+				int height = (getComponent( 0 ).getPreferredSize().height * 5) + insets.top + insets.bottom;
+				return new Dimension( getPreferredSize().width, height );
+			}
+			return getPreferredSize();
+		}
+
+		@Override
+		public int getScrollableUnitIncrement( Rectangle visibleRect, int orientation, int direction ) {
+			if( orientation == SwingConstants.VERTICAL && getComponentCount() > 0 )
+				return getComponent( 0 ).getPreferredSize().height;
+
+			return getScrollableBlockIncrement( visibleRect, orientation, direction ) / 10;
+		}
+
+		@Override
+		public int getScrollableBlockIncrement( Rectangle visibleRect, int orientation, int direction ) {
+			return (orientation == SwingConstants.VERTICAL) ? visibleRect.height : visibleRect.width;
+		}
+
+		@Override
+		public boolean getScrollableTracksViewportWidth() {
+			return true;
+		}
+
+		@Override
+		public boolean getScrollableTracksViewportHeight() {
+			return false;
+		}
+	}
+
+	//---- class ShortcutIcon -------------------------------------------------
+
+	private static class ShortcutIcon
+		implements Icon
+	{
+		private final Icon icon;
+		private final int iconWidth;
+		private final int iconHeight;
+
+		ShortcutIcon( Icon icon, int iconWidth, int iconHeight ) {
+			this.icon = icon;
+			this.iconWidth = iconWidth;
+			this.iconHeight = iconHeight;
+		}
+
+		@Override
+		public void paintIcon( Component c, Graphics g, int x, int y ) {
+			Graphics2D g2 = (Graphics2D) g.create();
+			try {
+				// set rendering hint for the case that the icon is a bitmap (not used for vector icons)
+				g2.setRenderingHint( RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BICUBIC );
+
+				double scale = (double) getIconWidth() / (double) icon.getIconWidth();
+				g2.translate( x, y );
+				g2.scale( scale, scale );
+
+				icon.paintIcon( c, g2, 0, 0 );
+			} finally {
+				g2.dispose();
+			}
+		}
+
+		@Override
+		public int getIconWidth() {
+			return UIScale.scale( iconWidth );
+		}
+
+		@Override
+		public int getIconHeight() {
+			return UIScale.scale( iconHeight );
 		}
 	}
 }

flatlaf-core/src/main/java/com/formdev/flatlaf/ui/FlatFormattedTextFieldUI.java

@@ -40,7 +40,6 @@ import javax.swing.plaf.ComponentUI;
  * <!-- FlatTextFieldUI -->
  *
  * @uiDefault Component.minimumWidth					int
- * @uiDefault Component.isIntelliJTheme					boolean
  * @uiDefault FormattedTextField.placeholderForeground	Color
  * @uiDefault FormattedTextField.focusedBackground		Color	optional
  * @uiDefault FormattedTextField.iconTextGap			int		optional, default is 4

flatlaf-core/src/main/java/com/formdev/flatlaf/ui/FlatHTML.java

@@ -0,0 +1,290 @@
+/*
+ * Copyright 2024 FormDev Software GmbH
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.formdev.flatlaf.ui;
+
+import java.awt.Color;
+import java.awt.Font;
+import java.beans.PropertyChangeEvent;
+import java.beans.PropertyChangeListener;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Set;
+import java.util.function.BiConsumer;
+import javax.swing.AbstractButton;
+import javax.swing.JComponent;
+import javax.swing.JLabel;
+import javax.swing.JToolTip;
+import javax.swing.plaf.basic.BasicHTML;
+import javax.swing.text.AttributeSet;
+import javax.swing.text.Document;
+import javax.swing.text.LabelView;
+import javax.swing.text.Style;
+import javax.swing.text.StyleConstants;
+import javax.swing.text.View;
+import javax.swing.text.html.CSS;
+import javax.swing.text.html.HTMLDocument;
+import javax.swing.text.html.StyleSheet;
+
+/**
+ * @author Karl Tauber
+ * @since 3.5
+ */
+public class FlatHTML
+{
+	private FlatHTML() {}
+
+	/**
+	 * Adds CSS rule BASE_SIZE to the style sheet of the HTML view,
+	 * which re-calculates font sizes based on current component font size.
+	 * This is necessary for "absolute-size" keywords (e.g. "x-large")
+	 * for "font-size" attributes in default style sheet (see javax/swing/text/html/default.css).
+	 * See also <a href="https://developer.mozilla.org/en-US/docs/Web/CSS/font-size#values">CSS font-size</a>.
+	 * <p>
+	 * This method should be invoked after {@link BasicHTML#updateRenderer(JComponent, String)}.
+	 */
+	public static void updateRendererCSSFontBaseSize( JComponent c ) {
+		View view = (View) c.getClientProperty( BasicHTML.propertyKey );
+		if( view == null )
+			return;
+
+//		dumpViews( view, 0 );
+
+		Document doc = view.getDocument();
+		if( !(doc instanceof HTMLDocument) )
+			return;
+
+		// add BASE_SIZE rule if necessary
+		//  - if point size at index 7 is not 36, then probably HTML text contains BASE_SIZE rule
+		//  - if point size at index 4 is equal to given font size, then it is not necessary to add BASE_SIZE rule
+		StyleSheet styleSheet = ((HTMLDocument)doc).getStyleSheet();
+/*debug
+		for( int i = 1; i <= 7; i++ )
+			System.out.println( i+": "+ styleSheet.getPointSize( i ) );
+debug*/
+		Font font = c.getFont();
+		if( styleSheet.getPointSize( 7 ) != 36f ||
+			font == null || styleSheet.getPointSize( 4 ) == font.getSize() )
+		  return;
+
+		// check whether view uses "absolute-size" keywords (e.g. "x-large") for font-size
+		if( !usesAbsoluteSizeKeywordForFontSize( view ) )
+			return;
+
+		// get HTML text from component
+		String text;
+		if( c instanceof JLabel )
+			text = ((JLabel)c).getText();
+		else if( c instanceof AbstractButton )
+			text = ((AbstractButton)c).getText();
+		else if( c instanceof JToolTip )
+			text = ((JToolTip)c).getTipText();
+		else
+			return;
+		if( text == null || !BasicHTML.isHTMLString( text ) )
+			return;
+
+		// BASE_SIZE rule is parsed in javax.swing.text.html.StyleSheet.addRule()
+		String style = "<style>BASE_SIZE " + font.getSize() + "</style>";
+		String openTag = "";
+		String closeTag = "";
+
+		int headIndex;
+		int styleIndex;
+
+		int insertIndex;
+		if( (headIndex = indexOfTag( text, "head", true )) >= 0 ) {
+			// there is a <head> tag --> insert after <head> tag
+			insertIndex = headIndex;
+		} else if( (styleIndex = indexOfTag( text, "style", false )) >= 0 ) {
+			// there is a <style> tag --> insert before <style> tag
+			insertIndex = styleIndex;
+		} else {
+			// no <head> or <style> tag --> insert <head> tag after <html> tag
+			insertIndex = "<html>".length();
+			openTag = "<head>";
+			closeTag = "</head>";
+		}
+
+		String newText = text.substring( 0, insertIndex )
+			+ openTag + style + closeTag
+			+ text.substring( insertIndex );
+
+		BasicHTML.updateRenderer( c, newText );
+
+		// for unit tests
+		if( testUpdateRenderer != null )
+			testUpdateRenderer.accept( c, newText );
+	}
+
+	// for unit tests
+	static BiConsumer<JComponent, String> testUpdateRenderer;
+
+	/**
+	 * Returns start or end index of a HTML tag.
+	 * Checks only for leading '<' character and (case-ignore) tag name.
+	 */
+	private static int indexOfTag( String html, String tag, boolean endIndex ) {
+		int tagLength = tag.length();
+		int maxLength = html.length() - tagLength - 2;
+		char lastTagChar = tag.charAt( tagLength - 1 );
+
+		for( int i = "<html>".length(); i < maxLength; i++ ) {
+			// check for leading '<' and last tag name character
+			if( html.charAt( i ) == '<' && Character.toLowerCase( html.charAt( i + tagLength ) ) == lastTagChar ) {
+				// compare tag characters from last to first
+				for( int j = tagLength - 2; j >= 0; j-- ) {
+					if( Character.toLowerCase( html.charAt( i + 1 + j ) ) != tag.charAt( j ) )
+						break; // not equal
+
+					if( j == 0 ) {
+						// tag found
+						return endIndex ? html.indexOf( '>', i + tagLength ) + 1 : i;
+					}
+				}
+			}
+		}
+
+		return -1;
+	}
+
+	private static final Set<String> absoluteSizeKeywordsSet = new HashSet<>( Arrays.asList(
+		"xx-small", "x-small", "small", "medium", "large", "x-large", "xx-large" ) );
+
+	/**
+	 * Checks whether view uses "absolute-size" keywords (e.g. "x-large") for font-size
+	 * (see javax/swing/text/html/default.css).
+	 */
+	private static boolean usesAbsoluteSizeKeywordForFontSize( View view ) {
+		AttributeSet attributes = view.getAttributes();
+		if( attributes != null ) {
+			Object fontSize = attributes.getAttribute( CSS.Attribute.FONT_SIZE );
+			if( fontSize != null ) {
+				if( absoluteSizeKeywordsSet.contains( fontSize.toString() ) )
+					return true;
+			}
+		}
+
+		int viewCount = view.getViewCount();
+		for( int i = 0; i < viewCount; i++ ) {
+			if( usesAbsoluteSizeKeywordForFontSize( view.getView( i ) ) )
+				return true;
+		}
+
+		return false;
+	}
+
+	/**
+	 * Updates foreground in style sheet of the HTML view.
+	 * Adds "body { color: #&lt;foreground-hex&gt;; }"
+	 */
+	public static void updateRendererCSSForeground( View view, Color foreground ) {
+		Document doc = view.getDocument();
+		if( !(doc instanceof HTMLDocument) || foreground == null )
+			return;
+
+		// add foreground rule if necessary
+		//  - use tag 'body' because BasicHTML.createHTMLView() also uses this tag
+		//    to set font and color styles to component font/color
+		//    see: SwingUtilities2.displayPropertiesToCSS()
+		//  - this color is not used if component is disabled;
+		//    JTextComponent.getDisabledTextColor() is used for disabled text components;
+		//    UIManager.getColor("textInactiveText") is used for other disabled components
+		//    see: javax.swing.text.GlyphView.paint()
+		Style bodyStyle = ((HTMLDocument)doc).getStyle( "body" );
+		if( bodyStyle == null ) {
+			StyleSheet styleSheet = ((HTMLDocument)doc).getStyleSheet();
+			styleSheet.addRule( String.format( "body { color: #%06x; }", foreground.getRGB() & 0xffffff ) );
+			clearViewCaches( view );
+		} else if( !foreground.equals( bodyStyle.getAttribute( StyleConstants.Foreground ) ) ) {
+			bodyStyle.addAttribute( StyleConstants.Foreground, foreground );
+			clearViewCaches( view );
+		}
+	}
+
+	/**
+	 * Clears cached values in view so that CSS changes take effect.
+	 */
+	private static void clearViewCaches( View view ) {
+		if( view instanceof LabelView )
+			((LabelView)view).changedUpdate( null, null, null );
+
+		int viewCount = view.getViewCount();
+		for( int i = 0; i < viewCount; i++ )
+			clearViewCaches( view.getView( i ) );
+	}
+
+	public static PropertyChangeListener createPropertyChangeListener( PropertyChangeListener superListener ) {
+		return e -> {
+			if( superListener != null )
+				superListener.propertyChange( e );
+			propertyChange( e );
+		};
+	}
+
+	/**
+	 * Invokes {@link #updateRendererCSSFontBaseSize(JComponent)}
+	 * for {@link BasicHTML#propertyKey} property change events,
+	 * which are fired when {@link BasicHTML#updateRenderer(JComponent, String)}
+	 * updates the HTML view.
+	 */
+	public static void propertyChange( PropertyChangeEvent e ) {
+		if( BasicHTML.propertyKey.equals( e.getPropertyName() ) && e.getNewValue() instanceof View )
+			updateRendererCSSFontBaseSize( (JComponent) e.getSource() );
+	}
+
+/*debug
+	public static void dumpView( JComponent c ) {
+		View view = (View) c.getClientProperty( BasicHTML.propertyKey );
+		if( view != null )
+			dumpViews( view, 0 );
+	}
+
+	public static void dumpViews( View view, int indent ) {
+		for( int i = 0; i < indent; i++ )
+			System.out.print( "    " );
+
+		System.out.printf( "%s @%-8x   %3d,%2d",
+			view.getClass().isAnonymousClass() ? view.getClass().getName() : view.getClass().getSimpleName(),
+			System.identityHashCode( view ),
+			(int) view.getPreferredSpan( View.X_AXIS ),
+			(int) view.getPreferredSpan( View.Y_AXIS ) );
+
+		AttributeSet attrs = view.getAttributes();
+		if( attrs != null ) {
+			Object fontSize = attrs.getAttribute( CSS.Attribute.FONT_SIZE );
+			System.out.printf( "  %-8s", fontSize );
+		}
+
+		if( view instanceof javax.swing.text.GlyphView ) {
+			javax.swing.text.GlyphView gview = ((javax.swing.text.GlyphView)view);
+			java.awt.Font font = gview.getFont();
+			System.out.printf( "   %3d-%-3d  %s %2d (@%x)  #%06x  '%s'",
+				gview.getStartOffset(), gview.getEndOffset() - 1,
+				font.getName(), font.getSize(), System.identityHashCode( font ),
+				gview.getForeground().getRGB() & 0xffffff,
+				gview.getText( gview.getStartOffset(), gview.getEndOffset() ) );
+		}
+		System.out.println();
+
+		int viewCount = view.getViewCount();
+		for( int i = 0; i < viewCount; i++ ) {
+			View child = view.getView( i );
+			dumpViews( child, indent + 1 );
+		}
+	}
+debug*/
+}

flatlaf-core/src/main/java/com/formdev/flatlaf/ui/FlatInternalFrameTitlePane.java

@@ -213,6 +213,13 @@ public class FlatInternalFrameTitlePane
 				case "componentOrientation":
 					applyComponentOrientation( frame.getComponentOrientation() );
 					break;
+
+				case "opaque":
+					// Do not invoke super.propertyChange() here because it always
+					// invokes repaint(), which would cause endless repainting.
+					// The opaque flag is temporary changed in FlatUIUtils.hasOpaqueBeenExplicitlySet(),
+					// invoked from FlatInternalFrameUI.update().
+					return;
 			}
 
 			super.propertyChange( e );

flatlaf-core/src/main/java/com/formdev/flatlaf/ui/FlatInternalFrameUI.java

@@ -179,6 +179,32 @@ public class FlatInternalFrameUI
 		return FlatStylingSupport.getAnnotatedStyleableInfos( this, frame.getBorder() );
 	}
 
+	/** @since 2.5 */
+	@Override
+	public Object getStyleableValue( JComponent c, String key ) {
+		return FlatStylingSupport.getAnnotatedStyleableValue( this, frame.getBorder(), key );
+	}
+
+	@Override
+	public void update( Graphics g, JComponent c ) {
+		// The internal frame actually should be opaque and fill its background,
+		// but it must be non-opaque to allow translucent resize handles (outside of visual bounds).
+		// To avoid that parent may shine through internal frame (e.g. if menu bar is non-opaque),
+		// fill background excluding insets (translucent resize handles),
+		// but only if opaque was not set explicitly by application to false.
+		// If applications has set internal frame opacity to false, do not fill background (for compatibility).
+		if( !c.isOpaque() && !FlatUIUtils.hasOpaqueBeenExplicitlySet( c ) ) {
+			Insets insets = c.getInsets();
+
+			g.setColor( c.getBackground() );
+			g.fillRect( insets.left, insets.top,
+				c.getWidth() - insets.left - insets.right,
+				c.getHeight() - insets.top - insets.bottom );
+		}
+
+		super.update( g, c );
+	}
+
 	//---- class FlatInternalFrameBorder --------------------------------------
 
 	public static class FlatInternalFrameBorder
@@ -233,6 +259,23 @@ public class FlatInternalFrameUI
 			return infos;
 		}
 
+		/** @since 2.5 */
+		@Override
+		public Object getStyleableValue( String key ) {
+			switch( key ) {
+				case "borderMargins": return getStyleableValue();
+
+				case "activeDropShadowColor": return activeDropShadowBorder.getStyleableValue( "shadowColor" );
+				case "activeDropShadowInsets": return activeDropShadowBorder.getStyleableValue( "shadowInsets" );
+				case "activeDropShadowOpacity": return activeDropShadowBorder.getStyleableValue( "shadowOpacity" );
+				case "inactiveDropShadowColor": return inactiveDropShadowBorder.getStyleableValue( "shadowColor" );
+				case "inactiveDropShadowInsets": return inactiveDropShadowBorder.getStyleableValue( "shadowInsets" );
+				case "inactiveDropShadowOpacity": return inactiveDropShadowBorder.getStyleableValue( "shadowOpacity" );
+			}
+
+			return FlatStylingSupport.getAnnotatedStyleableValue( this, key );
+		}
+
 		@Override
 		public Insets getBorderInsets( Component c, Insets insets ) {
 			if( c instanceof JInternalFrame && ((JInternalFrame)c).isMaximum() ) {