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

.gitbugtraq

@@ -0,0 +1,8 @@
+# links issue numbers in git commit messages to issue tracker 
+# https://github.com/mstrap/bugtraq
+# for SmartGit - https://www.syntevo.com/smartgit/
+
+[bugtraq]
+url = "https://github.com/JFormDesigner/FlatLaf/issues/%BUGID%"
+loglinkregex = "#[0-9]{1,5}"
+logregex = "[0-9]{1,5}"

.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,99 +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
+      - 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 -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 }}
+          SONATYPE_USERNAME: ${{ secrets.SONATYPE_USERNAME }}
+          SONATYPE_PASSWORD: ${{ secrets.SONATYPE_PASSWORD }}
 
 
   release:
@@ -112,41 +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 -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 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,48 +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
-                  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)
@@ -67,20 +98,25 @@ docs).
 Addons
 ------
 
-- [IntelliJ Themes Pack](flatlaf-intellij-themes)
-- [Extras](flatlaf-extras)
-- [SwingX](flatlaf-swingx)
-- [JIDE Common Layer](flatlaf-jide-oss)
+- [IntelliJ Themes Pack](flatlaf-intellij-themes) - bundles many popular
+  open-source 3rd party themes
+- [Extras](flatlaf-extras) - SVG icon, tri-state check box, UI inspectors, and
+  more
+- [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
 ---------------
 
-To enable FlatLaf, add following code to your main method before you create any
+To use FlatLaf, add following code to your main method before you create any
 Swing component:
 
 ~~~java
-FlatLightLaf.install();
+FlatLightLaf.setup();
 
 // create UI here...
 ~~~
@@ -96,103 +132,258 @@ 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/)
 
 
 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.1"
-val developmentVersion = "1.2-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,29 +45,154 @@ 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"
 			targetCompatibility = "1.8"
 
 			options.encoding = "ISO-8859-1"
+			options.isDeprecation = false
 		}
 
 		withType<Jar>().configureEach {
 			// manifest for all created JARs
-			manifest.attributes(mapOf(
+			manifest.attributes(
 				"Implementation-Vendor" to "FormDev Software GmbH",
 				"Implementation-Copyright" to "Copyright (C) 2019-${java.time.LocalDate.now().year} FormDev Software GmbH. All rights reserved.",
-				"Implementation-Version" to project.version))
+				"Implementation-Version" to project.version
+			)
 
 			// add META-INF/LICENSE to all created JARs
-			from("${rootDir}/LICENSE") {
-				into("META-INF")
+			from( "${rootDir}/LICENSE" ) {
+				into( "META-INF" )
+			}
+		}
+
+		withType<AbstractArchiveTask>().configureEach {
+			isPreserveFileTimestamps = true
+		}
+
+		withType<Javadoc>().configureEach {
+			options {
+				this as StandardJavadocDocletOptions
+
+				title = "${project.name} $version"
+				header = title
+				isUse = true
+				tags = listOf( "uiDefault", "clientProperty" )
+				addStringOption( "Xdoclint:all,-missing", "-Xdoclint:all,-missing" )
+				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,13 +14,26 @@
  * limitations under the License.
  */
 
+import Flatlaf_publish_gradle.NativeArtifact
+
 plugins {
 	`java-library`
+	`flatlaf-toolchain`
 	`flatlaf-module-info`
 	`flatlaf-java9`
 	`flatlaf-publish`
 }
 
+val sigtest = configurations.create( "sigtest" )
+
+dependencies {
+	testImplementation( libs.junit )
+	testRuntimeOnly( libs.junit.launcher )
+
+	// https://github.com/jtulach/netbeans-apitest
+	sigtest( libs.sigtest )
+}
+
 java {
 	withSourcesJar()
 	withJavadocJar()
@@ -29,38 +42,118 @@ 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 );
 		}
 	}
 
-	javadoc {
-		options {
-			this as StandardJavadocDocletOptions
-			use( true )
-			tags = listOf( "uiDefault", "clientProperty" )
-			addStringOption( "Xdoclint:all,-missing", "-Xdoclint:all,-missing" )
+	named<Jar>( "sourcesJar" ) {
+		archiveBaseName = "flatlaf"
+	}
+
+	named<Jar>( "javadocJar" ) {
+		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 {
+		dependsOn( "sigtestCheck" )
+	}
+
+	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 classpath )
+
+				"sigtest"(
+					"action" to "generate",
+					"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" )
+			}
 		}
-		isFailOnError = false
 	}
 
-	named<Jar>("sourcesJar" ) {
-		archiveBaseName.set( "flatlaf" )
-	}
+	register( "sigtestCheck" ) {
+		group = "verification"
+		dependsOn( "jar" )
 
-	named<Jar>("javadocJar" ) {
-		archiveBaseName.set( "flatlaf" )
+		// 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 classpath )
+
+				"sigtest"(
+					"action" to "check",
+					"fileName" to signatureFile,
+					"classpath" to jarPath,
+					"packages" to "com.formdev.flatlaf,com.formdev.flatlaf.util",
+					"version" to version,
+					"release" to "1.8", // Java version
+					"failonerror" to "true" )
+			}
+		}
 	}
 }
 
@@ -68,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/src/main/java/com/formdev/flatlaf/FlatDarculaLaf.java

@@ -16,6 +16,8 @@
 
 package com.formdev.flatlaf;
 
+import javax.swing.UIManager;
+
 /**
  * A Flat LaF that has a dark color scheme and looks like Darcula LaF.
  * <p>
@@ -29,10 +31,30 @@ public class FlatDarculaLaf
 {
 	public static final String NAME = "FlatLaf Darcula";
 
-	public static boolean install() {
-		return install( new 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() );
 	}
 
+	/**
+	 * @deprecated use {@link #setup()} instead; this method will be removed in a future version
+	 */
+	@Deprecated
+	public static boolean install() {
+		return setup();
+	}
+
+	/**
+	 * 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, FlatDarculaLaf.class );
 	}

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

@@ -33,9 +33,19 @@ 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() );
+	}
+
+	/**
+	 * @deprecated use {@link #setup()} instead; this method will be removed in a future version
+	 */
+	@Deprecated
 	public static boolean install() {
-		return install( new FlatDarkLaf() );
+		return setup();
 	}
 
 	/**

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

@@ -16,6 +16,8 @@
 
 package com.formdev.flatlaf;
 
+import javax.swing.UIManager;
+
 /**
  * A Flat LaF that has a light color scheme and looks like IntelliJ LaF.
  * <p>
@@ -29,10 +31,30 @@ public class FlatIntelliJLaf
 {
 	public static final String NAME = "FlatLaf IntelliJ";
 
-	public static boolean install() {
-		return install( new 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() );
 	}
 
+	/**
+	 * @deprecated use {@link #setup()} instead; this method will be removed in a future version
+	 */
+	@Deprecated
+	public static boolean install() {
+		return setup();
+	}
+
+	/**
+	 * 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, FlatIntelliJLaf.class );
 	}

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

@@ -33,9 +33,19 @@ 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() );
+	}
+
+	/**
+	 * @deprecated use {@link #setup()} instead; this method will be removed in a future version
+	 */
+	@Deprecated
 	public static boolean install() {
-		return install( new FlatLightLaf() );
+		return setup();
 	}
 
 	/**

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,12 @@
 
 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;
+
 /**
  * Defines/documents own system properties used in FlatLaf.
  *
@@ -32,6 +38,8 @@ 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 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>
 	 */
 	String UI_SCALE = "flatlaf.uiScale";
@@ -44,6 +52,17 @@ public interface FlatSystemProperties
 	 */
 	String UI_SCALE_ENABLED = "flatlaf.uiScale.enabled";
 
+	/**
+	 * Specifies whether values smaller than 100% are allowed for the user scale factor
+	 * (see {@link UIScale#getUserScaleFactor()}).
+	 * <p>
+	 * <strong>Allowed Values</strong> {@code false} and {@code true}<br>
+	 * <strong>Default</strong> {@code false}
+	 *
+	 * @since 1.1.2
+	 */
+	String UI_SCALE_ALLOW_SCALE_DOWN = "flatlaf.uiScale.allowScaleDown";
+
 	/**
 	 * Specifies whether Ubuntu font should be used on Ubuntu Linux.
 	 * By default, if not running in a JetBrains Runtime, the Liberation Sans font
@@ -55,15 +74,18 @@ public interface FlatSystemProperties
 	String USE_UBUNTU_FONT = "flatlaf.useUbuntuFont";
 
 	/**
-	 * Specifies whether FlatLaf native window decorations should be used
+	 * Specifies whether native window decorations should be used
 	 * when creating {@code JFrame} or {@code JDialog}.
 	 * <p>
-	 * Setting this to {@code true} forces using FlatLaf native window decorations
-	 * even if they are not enabled by the application.
+	 * Setting this to {@code true} forces using native window decorations
+	 * even if they are not enabled by the application.<br>
+	 * Setting this to {@code false} disables using native window decorations.
 	 * <p>
-	 * Setting this to {@code false} disables using FlatLaf native window decorations.
+	 * This system property has higher priority than client property
+	 * {@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
@@ -74,28 +96,37 @@ 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 true} forces using JetBrains Runtime custom window decorations
-	 * even if they are not enabled by the application.
-	 * <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> none
+	 * <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";
 
 	/**
-	 * Specifies whether menubar is embedded into custom window decorations.
+	 * Specifies whether the menu bar is embedded into the window title pane
+	 * if window decorations are enabled.
 	 * <p>
-	 * (requires Window 10)
+	 * Setting this to {@code true} forces embedding.<br>
+	 * Setting this to {@code false} disables embedding.
+	 * <p>
+	 * This system property has higher priority than client property
+	 * {@link FlatClientProperties#MENU_BAR_EMBEDDED} and
+	 * UI default {@code TitlePane.menuBarEmbedded}.
+	 * <p>
+	 * (requires Windows 10/11)
 	 * <p>
 	 * <strong>Allowed Values</strong> {@code false} and {@code true}<br>
-	 * <strong>Default</strong> {@code true}
+	 * <strong>Default</strong> none
 	 */
 	String MENUBAR_EMBEDDED = "flatlaf.menuBarEmbedded";
 
@@ -107,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>
@@ -115,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,26 +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.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.
@@ -57,30 +58,38 @@ 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,
-	 * creates a Laf instance for it and installs it.
+	 * creates a Laf instance for it and sets it up.
 	 *
 	 * The input stream is automatically closed.
 	 * Using a buffered input stream is not necessary.
+	 *
+	 * @since 1.2
 	 */
-	public static boolean install( InputStream in ) {
+	public static boolean setup( InputStream in ) {
 		try {
-		    return FlatLaf.install( createLaf( in ) );
+		    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;
 		}
 	}
 
+	/**
+	 * @deprecated use {@link #setup(InputStream)} instead; this method will be removed in a future version
+	 */
+	@Deprecated
+	public static boolean install( InputStream in ) {
+		return setup( in );
+	}
+
 	/**
 	 * Loads a IntelliJ .theme.json file from the given input stream and
 	 * creates a Laf instance for it.
@@ -122,157 +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 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" ) );
-		}
+		// fix DesktopPane background (use Panel.background and make it 5% darker/lighter)
+		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( "[" ) )
+		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 currentAuthorPrefix = "[author-" + author.replace( ' ', '_' ) + ']';
-		String allThemesPrefix = "[*]";
-		String[] prefixes = { currentThemePrefix, 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 );
 			}
 		}
 	}
@@ -281,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
@@ -300,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 ) {
@@ -322,42 +465,64 @@ public class IntelliJTheme
 
 				// parse value
 				try {
-					uiValue = UIDefaultsLoader.parseValue( key, valueStr );
+					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 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
@@ -369,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;
 
@@ -382,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;
 
@@ -424,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" );
 
@@ -445,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
@@ -467,7 +633,7 @@ public class IntelliJTheme
 
 						String newKey2 = checkboxKeyMapping.get( key2 );
 						if( newKey2 != null )
-							defaults.put( newKey2, color );
+							put( properties, newKey2, color );
 					}
 				}
 
@@ -478,52 +644,102 @@ 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].selectedFocusedBackground", 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.selectedFocusedBorderColor",
+					"CheckBox.icon.focusedSelectedBorderColor",
 					"CheckBox.icon[filled].focusedBorderColor",
-					"CheckBox.icon[filled].selectedFocusedBorderColor",
+					"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" );
@@ -535,6 +751,11 @@ public class IntelliJTheme
 		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" );
@@ -542,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" );
@@ -553,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" );
@@ -569,25 +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" );
+
+		// 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" );
@@ -598,7 +822,7 @@ public class IntelliJTheme
 		checkboxKeyMapping.put( "Checkbox.Background.Selected", "CheckBox.icon.selectedBackground" );
 		checkboxKeyMapping.put( "Checkbox.Border.Selected",     "CheckBox.icon.selectedBorderColor" );
 		checkboxKeyMapping.put( "Checkbox.Foreground.Selected", "CheckBox.icon.checkmarkColor" );
-		checkboxKeyMapping.put( "Checkbox.Focus.Thin.Selected", "CheckBox.icon.selectedFocusedBorderColor" );
+		checkboxKeyMapping.put( "Checkbox.Focus.Thin.Selected", "CheckBox.icon.focusedSelectedBorderColor" );
 
 		checkboxDuplicateColors.put( "Checkbox.Background.Default.Dark", "Checkbox.Background.Selected.Dark" );
 		checkboxDuplicateColors.put( "Checkbox.Border.Default.Dark",     "Checkbox.Border.Selected.Dark" );
@@ -640,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;
@@ -55,24 +59,38 @@ class LinuxFontPolicy
 
 		String family = "";
 		int style = Font.PLAIN;
-		int size = 10;
+		double dsize = 10;
 
+		// parse pango font description
+		// see https://developer.gnome.org/pango/1.46/pango-Fonts.html#pango-font-description-from-string
 		StringTokenizer st = new StringTokenizer( (String) fontName );
 		while( st.hasMoreTokens() ) {
 			String word = st.nextToken();
 
-			if( word.equalsIgnoreCase( "italic" ) )
+			// remove trailing ',' (e.g. in "Ubuntu Condensed, 11" or "Ubuntu Condensed, Bold 11")
+			if( word.endsWith( "," ) )
+				word = word.substring( 0, word.length() - 1 ).trim();
+
+			String lword = word.toLowerCase( Locale.ENGLISH );
+			if( lword.equals( "italic" ) || lword.equals( "oblique" ) )
 				style |= Font.ITALIC;
-			else if( word.equalsIgnoreCase( "bold" ) )
+			else if( lword.equals( "bold" ) )
 				style |= Font.BOLD;
 			else if( Character.isDigit( word.charAt( 0 ) ) ) {
 				try {
-					size = Integer.parseInt( word );
+					dsize = Double.parseDouble( word );
 				} catch( NumberFormatException ex ) {
 					// ignore
 				}
-			} else
+			} else {
+				// remove '-' from "Semi-Bold", "Extra-Light", etc
+				if( lword.startsWith( "semi-" ) || lword.startsWith( "demi-" ) )
+					word = word.substring( 0, 4 ) + word.substring( 5 );
+				else if( lword.startsWith( "extra-" ) || lword.startsWith( "ultra-" ) )
+					word = word.substring( 0, 5 ) + word.substring( 6 );
+
 				family = family.isEmpty() ? word : (family + ' ' + word);
+			}
 		}
 
 		// Ubuntu font is rendered poorly (except if running in JetBrains VM)
@@ -83,26 +101,58 @@ class LinuxFontPolicy
 		  family = "Liberation Sans";
 
 		// scale font size
-		double dsize = size * getGnomeFontScale();
-		size = (int) (dsize + 0.5);
+		dsize *= getGnomeFontScale();
+		int size = (int) (dsize + 0.5);
 		if( size < 1 )
 			size = 1;
 
 		// handle logical font names
-		String logicalFamily = mapFcName( family.toLowerCase() );
+		String logicalFamily = mapFcName( family.toLowerCase( Locale.ENGLISH ) );
 		if( logicalFamily != null )
 			family = logicalFamily;
 
-		return createFont( family, style, size, dsize );
+		return createFontEx( family, style, size );
 	}
 
-	private static Font createFont( String family, int style, int size, double dsize ) {
-		Font font = FlatLaf.createCompositeFont( family, style, size );
+	/**
+	 * Create a font for the given family, style and size.
+	 * If the font family does not match any font on the system,
+	 * then the last word (usually a font weight) from the family name is removed and tried again.
+	 * E.g. family 'URW Bookman Light' is not found, but 'URW Bookman' is found.
+	 * If still not found, then font of family 'Dialog' is returned.
+	 */
+	private static Font createFontEx( String family, int style, int size ) {
+		for(;;) {
+			Font font = FlatLaf.createCompositeFont( family, style, size );
 
-		// set font size in floating points
-		font = font.deriveFont( style, (float) dsize );
+			if( Font.DIALOG.equals( family ) )
+				return font;
 
-		return font;
+			// if the font family does not match any font on the system, "Dialog" family is returned
+			if( !Font.DIALOG.equals( font.getFamily() ) ) {
+				// check for font problems
+				// - font height much larger than expected (e.g. font Inter; Oracle Java 8)
+				// - character width is zero (e.g. font Cantarell; Fedora; Oracle Java 8)
+				FontMetrics fm = StyleContext.getDefaultStyleContext().getFontMetrics( font );
+				if( fm.getHeight() > size * 2 || fm.stringWidth( "a" ) == 0 )
+					return FlatLaf.createCompositeFont( Font.DIALOG, style, size );
+
+				return font;
+			}
+
+			// find last word in family
+			int index = family.lastIndexOf( ' ' );
+			if( index < 0 )
+				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( Locale.ENGLISH );
+			if( lastWord.contains( "bold" ) || lastWord.contains( "heavy" ) || lastWord.contains( "black" ) )
+				style |= Font.BOLD;
+
+			// remove last word from family and try again
+			family = family.substring( 0, index );
+		}
 	}
 
 	private static double getGnomeFontScale() {
@@ -114,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 )
@@ -141,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
@@ -198,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" ) );
 
@@ -221,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 ) {
@@ -265,6 +318,9 @@ class LinuxFontPolicy
 	 *   - running on JetBrains Runtime 11 or later and scaling is enabled in system Settings
 	 */
 	private static boolean isSystemScaling() {
+		if( GraphicsEnvironment.isHeadless() )
+			return true;
+
 		GraphicsConfiguration gc = GraphicsEnvironment.getLocalGraphicsEnvironment()
 			.getDefaultScreenDevice().getDefaultConfiguration();
 		return UIScale.getSystemScaleFactor( gc ) > 1;

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/MnemonicHandler.java

@@ -28,6 +28,7 @@ import java.awt.event.WindowEvent;
 import java.awt.event.WindowListener;
 import java.lang.ref.WeakReference;
 import javax.swing.AbstractButton;
+import javax.swing.JDialog;
 import javax.swing.JFrame;
 import javax.swing.JLabel;
 import javax.swing.JMenu;
@@ -137,10 +138,17 @@ class MnemonicHandler
 					// get menu bar and first menu
 					Component c = e.getComponent();
 					JRootPane rootPane = SwingUtilities.getRootPane( c );
-					Window window = (rootPane != null) ? SwingUtilities.getWindowAncestor( rootPane ) : null;
 					JMenuBar menuBar = (rootPane != null) ? rootPane.getJMenuBar() : null;
-					if( menuBar == null && window instanceof JFrame )
-						menuBar = ((JFrame)window).getJMenuBar();
+					if( menuBar == null ) {
+						// get menu bar from frame/dialog because there
+						// may be multiple nested root panes in a frame/dialog
+						// (e.g. each internal frame has its own root pane)
+						Window window = SwingUtilities.getWindowAncestor( c );
+						if( window instanceof JFrame )
+							menuBar = ((JFrame)window).getJMenuBar();
+						else if( window instanceof JDialog )
+							menuBar = ((JDialog)window).getJMenuBar();
+					}
 					JMenu firstMenu = (menuBar != null) ? menuBar.getMenu( 0 ) : null;
 
 					// select first menu and show mnemonics

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

@@ -39,7 +39,7 @@ public abstract class FlatAbstractIcon
 {
 	protected final int width;
 	protected final int height;
-	protected final Color color;
+	protected Color color;
 
 	public FlatAbstractIcon( int width, int height, Color color ) {
 		this.width = width;
@@ -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

@@ -21,7 +21,11 @@ import java.awt.Color;
 import java.awt.Component;
 import java.awt.Graphics2D;
 import java.awt.geom.Path2D;
+import javax.swing.SwingUtilities;
 import javax.swing.UIManager;
+import javax.swing.plaf.TableHeaderUI;
+import javax.swing.table.JTableHeader;
+import com.formdev.flatlaf.ui.FlatTableHeaderUI;
 import com.formdev.flatlaf.ui.FlatUIUtils;
 
 /**
@@ -35,8 +39,8 @@ import com.formdev.flatlaf.ui.FlatUIUtils;
 public class FlatAscendingSortIcon
 	extends FlatAbstractIcon
 {
-	protected final boolean chevron = FlatUIUtils.isChevron( UIManager.getString( "Component.arrowType" ) );
-	protected final Color sortIconColor = UIManager.getColor( "Table.sortIconColor" );
+	protected boolean chevron = FlatUIUtils.isChevron( UIManager.getString( "Component.arrowType" ) );
+	protected Color sortIconColor = UIManager.getColor( "Table.sortIconColor" );
 
 	public FlatAscendingSortIcon() {
 		super( 10, 5, null );
@@ -44,7 +48,28 @@ public class FlatAscendingSortIcon
 
 	@Override
 	protected void paintIcon( Component c, Graphics2D g ) {
+		boolean chevron = this.chevron;
+		Color sortIconColor = this.sortIconColor;
+
+		// 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 ) {
+			TableHeaderUI ui = tableHeader.getUI();
+			if( ui instanceof FlatTableHeaderUI ) {
+				FlatTableHeaderUI fui = (FlatTableHeaderUI) ui;
+				if( fui.arrowType != null )
+					chevron = FlatUIUtils.isChevron( fui.arrowType );
+				if( fui.sortIconColor != null )
+					sortIconColor = fui.sortIconColor;
+			}
+		}
+
 		g.setColor( sortIconColor );
+		paintArrow( c, g, chevron );
+	}
+
+	protected void paintArrow( Component c, Graphics2D g, boolean chevron ) {
 		if( chevron ) {
 			// chevron arrow
 			Path2D path = FlatUIUtils.createPath( false, 1,4, 5,0, 9,4 );

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

@@ -16,12 +16,17 @@
 
 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;
 import javax.swing.UIManager;
+import com.formdev.flatlaf.ui.FlatStylingSupport.UnknownStyleException;
 import com.formdev.flatlaf.ui.FlatUIUtils;
 
 /**
@@ -34,26 +39,51 @@ import com.formdev.flatlaf.ui.FlatUIUtils;
 public class FlatCapsLockIcon
 	extends FlatAbstractIcon
 {
+	private Path2D path;
+
 	public FlatCapsLockIcon() {
 		super( 16, 16, UIManager.getColor( "PasswordField.capsLockIconColor" ) );
 	}
 
+	/** @since 2 */
+	public Object applyStyleProperty( String key, Object value ) {
+		Object oldValue;
+		switch( key ) {
+			case "capsLockIconColor": oldValue = color; color = (Color) value; return oldValue;
+			default: throw new UnknownStyleException( key );
+		}
+	}
+
+	/** @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="12" 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, 12, 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,89 +17,156 @@
 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;
 import java.awt.Graphics2D;
 import java.awt.geom.Path2D;
 import java.awt.geom.RoundRectangle2D;
+import java.util.Map;
 import javax.swing.AbstractButton;
 import javax.swing.JComponent;
 import javax.swing.UIManager;
 import com.formdev.flatlaf.ui.FlatButtonUI;
+import com.formdev.flatlaf.ui.FlatStylingSupport;
+import com.formdev.flatlaf.ui.FlatStylingSupport.Styleable;
 import com.formdev.flatlaf.ui.FlatUIUtils;
 
 /**
  * Icon for {@link javax.swing.JCheckBox}.
- *
- * Note: If Component.focusWidth is greater than zero, then the outline focus border
+ * <p>
+ * <strong>Note</strong>:
+ *       If Component.focusWidth is greater than zero, then the outer focus border
  *       is painted outside of the icon bounds. Make sure that the checkbox
  *       has margins, which are equal or greater than focusWidth.
  *
- * @uiDefault CheckBox.icon.style						String	optional; "outline"/null (default) or "filled"
+ * @uiDefault CheckBox.icon.style						String	optional; "outlined"/null (default) or "filled"
  * @uiDefault Component.focusWidth						int
+ * @uiDefault Component.borderWidth						int
  * @uiDefault Component.focusColor						Color
- * @uiDefault CheckBox.icon.focusWidth					int		optional; defaults to Component.focusWidth
+ * @uiDefault CheckBox.icon.focusWidth					int or float	optional; defaults to Component.focusWidth
+ * @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
  * @uiDefault CheckBox.icon.borderColor					Color
  * @uiDefault CheckBox.icon.background					Color
  * @uiDefault CheckBox.icon.selectedBorderColor			Color
  * @uiDefault CheckBox.icon.selectedBackground			Color
  * @uiDefault CheckBox.icon.checkmarkColor				Color
- * @uiDefault CheckBox.icon.disabledBorderColor			Color
- * @uiDefault CheckBox.icon.disabledBackground			Color
- * @uiDefault CheckBox.icon.disabledCheckmarkColor		Color
- * @uiDefault CheckBox.icon.focusedBorderColor			Color	optional
- * @uiDefault CheckBox.icon.focusedBackground			Color	optional
- * @uiDefault CheckBox.icon.selectedFocusedBorderColor	Color	optional; CheckBox.icon.focusedBorderColor is used if not specified
- * @uiDefault CheckBox.icon.selectedFocusedBackground	Color	optional; CheckBox.icon.focusedBackground is used if not specified
- * @uiDefault CheckBox.icon.selectedFocusedCheckmarkColor	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.selectedHoverBackground		Color	optional; CheckBox.icon.hoverBackground is used if not specified
- * @uiDefault CheckBox.icon.pressedBackground			Color	optional
- * @uiDefault CheckBox.icon.selectedPressedBackground	Color	optional; CheckBox.icon.pressedBackground is used if not specified
- * @uiDefault CheckBox.arc								int
+ * @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; 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; 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; 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; 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
  */
 public class FlatCheckBoxIcon
 	extends FlatAbstractIcon
 {
-	protected final String style = UIManager.getString( "CheckBox.icon.style" );
-	public final int focusWidth = getUIInt( "CheckBox.icon.focusWidth",
-		UIManager.getInt( "Component.focusWidth" ), style );
-	protected final Color focusColor = FlatUIUtils.getUIColor( "CheckBox.icon.focusColor",
-		UIManager.getColor( "Component.focusColor" ) );
-	protected final int arc = FlatUIUtils.getUIInt( "CheckBox.arc", 2 );
+	protected final String style = UIManager.getString( getPropertyPrefix() + "icon.style" );
+	@Styleable protected float focusWidth = getUIFloat( "CheckBox.icon.focusWidth", UIManager.getInt( "Component.focusWidth" ), style );
+	@Styleable protected Color focusColor = FlatUIUtils.getUIColor( "CheckBox.icon.focusColor", UIManager.getColor( "Component.focusColor" ) );
+	/** @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
-	protected final Color borderColor = getUIColor( "CheckBox.icon.borderColor", style );
-	protected final Color background = getUIColor( "CheckBox.icon.background", style );
-	protected final Color selectedBorderColor = getUIColor( "CheckBox.icon.selectedBorderColor", style );
-	protected final Color selectedBackground = getUIColor( "CheckBox.icon.selectedBackground", style );
-	protected final Color checkmarkColor = getUIColor( "CheckBox.icon.checkmarkColor", style );
+	@Styleable protected Color borderColor = getUIColor( "CheckBox.icon.borderColor", style );
+	@Styleable protected Color background = getUIColor( "CheckBox.icon.background", style );
+	@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
-	protected final Color disabledBorderColor = getUIColor( "CheckBox.icon.disabledBorderColor", style );
-	protected final Color disabledBackground = getUIColor( "CheckBox.icon.disabledBackground", style );
-	protected final Color disabledCheckmarkColor = getUIColor( "CheckBox.icon.disabledCheckmarkColor", style );
+	@Styleable protected Color disabledBorderColor = getUIColor( "CheckBox.icon.disabledBorderColor", style );
+	@Styleable protected Color disabledBackground = getUIColor( "CheckBox.icon.disabledBackground", style );
+	/** @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
-	protected final Color focusedBorderColor = getUIColor( "CheckBox.icon.focusedBorderColor", style );
-	protected final Color focusedBackground = getUIColor( "CheckBox.icon.focusedBackground", style );
-	protected final Color selectedFocusedBorderColor = getUIColor( "CheckBox.icon.selectedFocusedBorderColor", style );
-	protected final Color selectedFocusedBackground = getUIColor( "CheckBox.icon.selectedFocusedBackground", style );
-	protected final Color selectedFocusedCheckmarkColor = getUIColor( "CheckBox.icon.selectedFocusedCheckmarkColor", style );
+	@Styleable protected Color focusedBorderColor = getUIColor( "CheckBox.icon.focusedBorderColor", style );
+	@Styleable protected Color focusedBackground = getUIColor( "CheckBox.icon.focusedBackground", style );
+	/** @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
-	protected final Color hoverBorderColor = getUIColor( "CheckBox.icon.hoverBorderColor", style );
-	protected final Color hoverBackground = getUIColor( "CheckBox.icon.hoverBackground", style );
-	protected final Color selectedHoverBackground = getUIColor( "CheckBox.icon.selectedHoverBackground", style );
+	@Styleable protected Color hoverBorderColor = getUIColor( "CheckBox.icon.hoverBorderColor", style );
+	@Styleable protected Color hoverBackground = getUIColor( "CheckBox.icon.hoverBackground", style );
+	/** @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
-	protected final Color pressedBackground = getUIColor( "CheckBox.icon.pressedBackground", style );
-	protected final Color selectedPressedBackground = getUIColor( "CheckBox.icon.selectedPressedBackground", style );
+	/** @since 2 */ @Styleable protected Color pressedBorderColor = getUIColor( "CheckBox.icon.pressedBorderColor", style );
+	@Styleable protected Color pressedBackground = getUIColor( "CheckBox.icon.pressedBackground", style );
+	/** @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.";
+	}
 
 	protected static Color getUIColor( String key, String style ) {
 		if( style != null ) {
@@ -110,13 +177,14 @@ public class FlatCheckBoxIcon
 		return UIManager.getColor( key );
 	}
 
-	protected static int getUIInt( String key, int defaultValue, String style ) {
+	/** @since 2 */
+	protected static float getUIFloat( String key, float defaultValue, String style ) {
 		if( style != null ) {
-			Object value = UIManager.get( styleKey( key, style ) );
-			if( value instanceof Integer )
-				return (Integer) value;
+			float value = FlatUIUtils.getUIFloat( styleKey( key, style ), Float.MIN_VALUE );
+			if( value != Float.MIN_VALUE )
+				return value;
 		}
-		return FlatUIUtils.getUIInt( key, defaultValue );
+		return FlatUIUtils.getUIFloat( key, defaultValue );
 	}
 
 	private static String styleKey( String key, String style ) {
@@ -129,11 +197,37 @@ public class FlatCheckBoxIcon
 		super( ICON_SIZE, ICON_SIZE, null );
 	}
 
+	/** @since 2 */
+	public Object applyStyleProperty( String key, Object value ) {
+		return FlatStylingSupport.applyToAnnotatedObject( this, key, value );
+	}
+
+	/** @since 2 */
+	public Map<String, Class<?>> getStyleableInfos() {
+		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 = 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 ) ) {
@@ -142,23 +236,23 @@ public class FlatCheckBoxIcon
 		}
 
 		// paint border
-		g.setColor( getBorderColor( c, selected ) );
-		paintBorder( c, g );
+		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 );
-			paintBackground( c, g );
+			g.setColor( baseBg );
+			paintBackground( c, g, bw );
 		}
 		g.setColor( bg );
-		paintBackground( c, g );
+		paintBackground( c, g, bw );
 
 		// paint checkmark
-		if( selected || indeterminate ) {
-			g.setColor( getCheckmarkColor( c, selected, isFocused ) );
+		if( selected ) {
+			g.setColor( getCheckmarkColor( c, indeterminate ) );
 			if( indeterminate )
 				paintIndeterminate( c, g );
 			else
@@ -167,24 +261,29 @@ public class FlatCheckBoxIcon
 	}
 
 	protected void paintFocusBorder( Component c, Graphics2D g ) {
-		// the outline focus border is painted outside of the icon
-		int wh = ICON_SIZE - 1 + (focusWidth * 2);
-		int arcwh = arc + (focusWidth * 2);
-		g.fillRoundRect( -focusWidth + 1, -focusWidth, wh, wh, arcwh, arcwh );
+		// the outer focus border is painted outside of the icon
+		float wh = ICON_SIZE - 1 + (focusWidth * 2);
+		float arcwh = arc + (focusWidth * 2);
+		g.fill( new RoundRectangle2D.Float( -focusWidth + 1, -focusWidth, wh, wh, arcwh, arcwh ) );
 	}
 
-	protected void paintBorder( Component c, Graphics2D g ) {
+	protected void paintBorder( Component c, Graphics2D g, float borderWidth ) {
+		if( borderWidth == 0 )
+			return;
+
 		int arcwh = arc;
 		g.fillRoundRect( 1, 0, 14, 14, arcwh, arcwh );
 	}
 
-	protected void paintBackground( Component c, Graphics2D g ) {
-		int arcwh = arc - 1;
-		g.fillRoundRect( 2, 1, 12, 12, arcwh, arcwh );
+	protected void paintBackground( Component c, Graphics2D g, float borderWidth ) {
+		float xy = borderWidth;
+		float wh = 14 - (borderWidth * 2);
+		float arcwh = arc - borderWidth;
+		g.fill( new RoundRectangle2D.Float( 1 + xy, xy, wh, wh, arcwh, arcwh ) );
 	}
 
 	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 );
@@ -205,33 +304,42 @@ public class FlatCheckBoxIcon
 		return c instanceof AbstractButton && ((AbstractButton)c).isSelected();
 	}
 
+	/** @since 2 */
+	public float getFocusWidth() {
+		return focusWidth;
+	}
+
 	protected Color getFocusColor( Component c ) {
 		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,
-			disabledBorderColor,
-			selected && selectedFocusedBorderColor != null ? selectedFocusedBorderColor : focusedBorderColor,
-			hoverBorderColor,
-			null );
+			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,
-			disabledBackground,
-			(selected && selectedFocusedBackground != null) ? selectedFocusedBackground : focusedBackground,
-			(selected && selectedHoverBackground != null) ? selectedHoverBackground : hoverBackground,
-			(selected && selectedPressedBackground != null) ? selectedPressedBackground : 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, boolean selected, boolean isFocused ) {
-		return c.isEnabled()
-			? ((selected && isFocused && selectedFocusedCheckmarkColor != null)
-				? selectedFocusedCheckmarkColor
-				: checkmarkColor)
-			: disabledCheckmarkColor;
+	/** @since 3.6 */
+	protected Color getCheckmarkColor( Component c, boolean indeterminate ) {
+		return FlatButtonUI.buttonStateColor( c,
+			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

@@ -21,15 +21,18 @@ import java.awt.Color;
 import java.awt.Component;
 import java.awt.Graphics2D;
 import java.awt.geom.Path2D;
+import java.util.Map;
 import javax.swing.AbstractButton;
 import javax.swing.JMenuItem;
 import javax.swing.UIManager;
+import com.formdev.flatlaf.ui.FlatStylingSupport;
+import com.formdev.flatlaf.ui.FlatStylingSupport.Styleable;
 
 /**
  * Icon for {@link javax.swing.JCheckBoxMenuItem}.
  *
- * @uiDefault MenuItemCheckBox.icon.checkmarkColor				Color
- * @uiDefault MenuItemCheckBox.icon.disabledCheckmarkColor		Color
+ * @uiDefault CheckBoxMenuItem.icon.checkmarkColor				Color
+ * @uiDefault CheckBoxMenuItem.icon.disabledCheckmarkColor		Color
  * @uiDefault MenuItem.selectionForeground						Color
  * @uiDefault MenuItem.selectionType							String
  *
@@ -38,14 +41,29 @@ import javax.swing.UIManager;
 public class FlatCheckBoxMenuItemIcon
 	extends FlatAbstractIcon
 {
-	protected final Color checkmarkColor = UIManager.getColor( "MenuItemCheckBox.icon.checkmarkColor" );
-	protected final Color disabledCheckmarkColor = UIManager.getColor( "MenuItemCheckBox.icon.disabledCheckmarkColor" );
-	protected final Color selectionForeground = UIManager.getColor( "MenuItem.selectionForeground" );
+	@Styleable protected Color checkmarkColor = UIManager.getColor( "CheckBoxMenuItem.icon.checkmarkColor" );
+	@Styleable protected Color disabledCheckmarkColor = UIManager.getColor( "CheckBoxMenuItem.icon.disabledCheckmarkColor" );
+	@Styleable protected Color selectionForeground = UIManager.getColor( "MenuItem.selectionForeground" );
 
 	public FlatCheckBoxMenuItemIcon() {
 		super( 15, 15, null );
 	}
 
+	/** @since 2 */
+	public Object applyStyleProperty( String key, Object value ) {
+		return FlatStylingSupport.applyToAnnotatedObject( this, key, value );
+	}
+
+	/** @since 2 */
+	public Map<String, Class<?>> getStyleableInfos() {
+		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();
@@ -58,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

@@ -0,0 +1,112 @@
+/*
+ * 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.Color;
+import java.awt.Component;
+import java.awt.Graphics2D;
+import java.awt.geom.Ellipse2D;
+import java.awt.geom.Path2D;
+import java.util.Map;
+import javax.swing.AbstractButton;
+import javax.swing.ButtonModel;
+import javax.swing.UIManager;
+import com.formdev.flatlaf.ui.FlatStylingSupport;
+import com.formdev.flatlaf.ui.FlatStylingSupport.Styleable;
+import com.formdev.flatlaf.ui.FlatUIUtils;
+
+/**
+ * "clear" icon for search fields.
+ *
+ * @uiDefault SearchField.clearIconColor				Color
+ * @uiDefault SearchField.clearIconHoverColor			Color
+ * @uiDefault SearchField.clearIconPressedColor			Color
+ *
+ * @author Karl Tauber
+ * @since 1.5
+ */
+public class FlatClearIcon
+	extends FlatAbstractIcon
+{
+	@Styleable protected Color clearIconColor = UIManager.getColor( "SearchField.clearIconColor" );
+	@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 */
+	public Object applyStyleProperty( String key, Object value ) {
+		return FlatStylingSupport.applyToAnnotatedObject( this, key, value );
+	}
+
+	/** @since 2 */
+	public Map<String, Class<?>> getStyleableInfos() {
+		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( !ignoreButtonState && c instanceof AbstractButton ) {
+			ButtonModel model = ((AbstractButton)c).getModel();
+			if( model.isPressed() || model.isRollover() ) {
+				/*
+					<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 16 16">
+					  <path fill="#7F8B91" fill-opacity=".5" fill-rule="evenodd" d="M8,1.75 C11.4517797,1.75 14.25,4.54822031 14.25,8 C14.25,11.4517797 11.4517797,14.25 8,14.25 C4.54822031,14.25 1.75,11.4517797 1.75,8 C1.75,4.54822031 4.54822031,1.75 8,1.75 Z M10.5,4.5 L8,7 L5.5,4.5 L4.5,5.5 L7,8 L4.5,10.5 L5.5,11.5 L8,9 L10.5,11.5 L11.5,10.5 L9,8 L11.5,5.5 L10.5,4.5 Z"/>
+					</svg>
+				*/
+
+				// paint filled circle with cross
+				g.setColor( model.isPressed() ? clearIconPressedColor : clearIconHoverColor );
+				Path2D path = new Path2D.Float( Path2D.WIND_EVEN_ODD );
+				path.append( new Ellipse2D.Float( 1.75f, 1.75f, 12.5f, 12.5f ), false );
+				path.append( FlatUIUtils.createPath( 4.5,5.5, 5.5,4.5, 8,7,  10.5,4.5, 11.5,5.5, 9,8,  11.5,10.5, 10.5,11.5, 8,9,  5.5,11.5, 4.5,10.5, 7,8 ), false );
+				g.fill( path );
+				return;
+			}
+		}
+
+		/*
+			<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 16 16">
+			  <path fill="none" stroke="#7F8B91" stroke-linecap="square" stroke-opacity=".5" d="M5,5 L11,11 M5,11 L11,5"/>
+			</svg>
+		*/
+
+		// paint cross
+		g.setColor( clearIconColor );
+		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/FlatDescendingSortIcon.java

@@ -17,11 +17,9 @@
 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 javax.swing.UIManager;
 import com.formdev.flatlaf.ui.FlatUIUtils;
 
 /**
@@ -33,18 +31,14 @@ import com.formdev.flatlaf.ui.FlatUIUtils;
  * @author Karl Tauber
  */
 public class FlatDescendingSortIcon
-	extends FlatAbstractIcon
+	extends FlatAscendingSortIcon
 {
-	protected final boolean chevron = FlatUIUtils.isChevron( UIManager.getString( "Component.arrowType" ) );
-	protected final Color sortIconColor = UIManager.getColor( "Table.sortIconColor" );
-
 	public FlatDescendingSortIcon() {
-		super( 10, 5, null );
+		super();
 	}
 
 	@Override
-	protected void paintIcon( Component c, Graphics2D g ) {
-		g.setColor( sortIconColor );
+	protected void paintArrow( Component c, Graphics2D g, boolean chevron ) {
 		if( chevron ) {
 			// chevron arrow
 			Path2D path = FlatUIUtils.createPath( false, 1,0, 5,4, 9,0 );

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,13 +17,18 @@
 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;
 import javax.swing.UIManager;
 import com.formdev.flatlaf.ui.FlatButtonUI;
+import com.formdev.flatlaf.ui.FlatStylingSupport;
+import com.formdev.flatlaf.ui.FlatStylingSupport.Styleable;
 import com.formdev.flatlaf.ui.FlatUIUtils;
 
 /**
@@ -50,29 +55,42 @@ import com.formdev.flatlaf.ui.FlatUIUtils;
 public class FlatHelpButtonIcon
 	extends FlatAbstractIcon
 {
-	protected final int focusWidth = UIManager.getInt( "Component.focusWidth" );
-	protected final Color focusColor = UIManager.getColor( "Component.focusColor" );
-	protected final float innerFocusWidth = FlatUIUtils.getUIFloat( "HelpButton.innerFocusWidth", FlatUIUtils.getUIFloat( "Component.innerFocusWidth", 0 ) );
-	protected final int borderWidth = FlatUIUtils.getUIInt( "HelpButton.borderWidth", 1 );
+	@Styleable protected int focusWidth = UIManager.getInt( "Component.focusWidth" );
+	@Styleable protected Color focusColor = UIManager.getColor( "Component.focusColor" );
+	@Styleable protected float innerFocusWidth = FlatUIUtils.getUIFloat( "HelpButton.innerFocusWidth", FlatUIUtils.getUIFloat( "Component.innerFocusWidth", 0 ) );
+	@Styleable protected int borderWidth = FlatUIUtils.getUIInt( "HelpButton.borderWidth", 1 );
 
-	protected final Color borderColor = UIManager.getColor( "HelpButton.borderColor" );
-	protected final Color disabledBorderColor = UIManager.getColor( "HelpButton.disabledBorderColor" );
-	protected final Color focusedBorderColor = UIManager.getColor( "HelpButton.focusedBorderColor" );
-	protected final Color hoverBorderColor = UIManager.getColor( "HelpButton.hoverBorderColor" );
-	protected final Color background = UIManager.getColor( "HelpButton.background" );
-	protected final Color disabledBackground = UIManager.getColor( "HelpButton.disabledBackground" );
-	protected final Color focusedBackground = UIManager.getColor( "HelpButton.focusedBackground" );
-	protected final Color hoverBackground = UIManager.getColor( "HelpButton.hoverBackground" );
-	protected final Color pressedBackground = UIManager.getColor( "HelpButton.pressedBackground" );
-	protected final Color questionMarkColor = UIManager.getColor( "HelpButton.questionMarkColor" );
-	protected final Color disabledQuestionMarkColor = UIManager.getColor( "HelpButton.disabledQuestionMarkColor" );
-
-	protected final int iconSize = 22 + (focusWidth * 2);
+	@Styleable protected Color borderColor = UIManager.getColor( "HelpButton.borderColor" );
+	@Styleable protected Color disabledBorderColor = UIManager.getColor( "HelpButton.disabledBorderColor" );
+	@Styleable protected Color focusedBorderColor = UIManager.getColor( "HelpButton.focusedBorderColor" );
+	@Styleable protected Color hoverBorderColor = UIManager.getColor( "HelpButton.hoverBorderColor" );
+	@Styleable protected Color background = UIManager.getColor( "HelpButton.background" );
+	@Styleable protected Color disabledBackground = UIManager.getColor( "HelpButton.disabledBackground" );
+	@Styleable protected Color focusedBackground = UIManager.getColor( "HelpButton.focusedBackground" );
+	@Styleable protected Color hoverBackground = UIManager.getColor( "HelpButton.hoverBackground" );
+	@Styleable protected Color pressedBackground = UIManager.getColor( "HelpButton.pressedBackground" );
+	@Styleable protected Color questionMarkColor = UIManager.getColor( "HelpButton.questionMarkColor" );
+	@Styleable protected Color disabledQuestionMarkColor = UIManager.getColor( "HelpButton.disabledQuestionMarkColor" );
 
 	public FlatHelpButtonIcon() {
 		super( 0, 0, null );
 	}
 
+	/** @since 2 */
+	public Object applyStyleProperty( String key, Object value ) {
+		return FlatStylingSupport.applyToAnnotatedObject( this, key, value );
+	}
+
+	/** @since 2 */
+	public Map<String, Class<?>> getStyleableInfos() {
+		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 ) {
 		/*
@@ -80,16 +98,17 @@ 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;
+		float wh = iconSize() - 1;
 
 		// paint outer focus border
 		if( focused && FlatButtonUI.isFocusPainted( c ) ) {
@@ -131,31 +150,32 @@ 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
 	public int getIconWidth() {
-		return scale( iconSize );
+		return scale( iconSize() );
 	}
 
 	@Override
 	public int getIconHeight() {
-		return scale( iconSize );
+		return scale( iconSize() );
+	}
+
+	private int iconSize() {
+		return 22 + (focusWidth * 2);
 	}
 }

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

@@ -21,9 +21,12 @@ import java.awt.Color;
 import java.awt.Component;
 import java.awt.Graphics2D;
 import java.awt.geom.Path2D;
+import java.util.Map;
 import javax.swing.JMenu;
 import javax.swing.UIManager;
+import com.formdev.flatlaf.ui.FlatStylingSupport;
 import com.formdev.flatlaf.ui.FlatUIUtils;
+import com.formdev.flatlaf.ui.FlatStylingSupport.Styleable;
 
 /**
  * "arrow" icon for {@link javax.swing.JMenu}.
@@ -39,22 +42,37 @@ import com.formdev.flatlaf.ui.FlatUIUtils;
 public class FlatMenuArrowIcon
 	extends FlatAbstractIcon
 {
-	protected final boolean chevron = FlatUIUtils.isChevron( UIManager.getString( "Component.arrowType" ) );
-	protected final Color arrowColor = UIManager.getColor( "Menu.icon.arrowColor" );
-	protected final Color disabledArrowColor = UIManager.getColor( "Menu.icon.disabledArrowColor" );
-	protected final Color selectionForeground = UIManager.getColor( "Menu.selectionForeground" );
+	@Styleable protected String arrowType = UIManager.getString( "Component.arrowType" );
+	@Styleable protected Color arrowColor = UIManager.getColor( "Menu.icon.arrowColor" );
+	@Styleable protected Color disabledArrowColor = UIManager.getColor( "Menu.icon.disabledArrowColor" );
+	@Styleable protected Color selectionForeground = UIManager.getColor( "Menu.selectionForeground" );
 
 	public FlatMenuArrowIcon() {
 		super( 6, 10, null );
 	}
 
+	/** @since 2 */
+	public Object applyStyleProperty( String key, Object value ) {
+		return FlatStylingSupport.applyToAnnotatedObject( this, key, value );
+	}
+
+	/** @since 2 */
+	public Map<String, Class<?>> getStyleableInfos() {
+		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 ) );
-		if( chevron ) {
+		if( FlatUIUtils.isChevron( arrowType ) ) {
 			// chevron arrow
 			Path2D path = FlatUIUtils.createPath( false, 1,1, 5,5, 1,9 );
 			g.setStroke( new BasicStroke( 1f ) );
@@ -69,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/FlatRadioButtonIcon.java

@@ -19,38 +19,51 @@ package com.formdev.flatlaf.icons;
 import java.awt.Component;
 import java.awt.Graphics2D;
 import java.awt.geom.Ellipse2D;
+import com.formdev.flatlaf.ui.FlatStylingSupport.Styleable;
 
 /**
  * Icon for {@link javax.swing.JRadioButton}.
- *
- * Note: If Component.focusWidth is greater than zero, then the outline focus border
+ * <p>
+ * <strong>Note</strong>:
+ *       If Component.focusWidth is greater than zero, then the outer focus border
  *       is painted outside of the icon bounds. Make sure that the radiobutton
  *       has margins, which are equal or greater than focusWidth.
  *
- * @uiDefault RadioButton.icon.centerDiameter			int
+ * @uiDefault RadioButton.icon.style					String	optional; "outlined"/null (default) or "filled"
+ * @uiDefault RadioButton.icon.centerDiameter			int or float
  *
  * @author Karl Tauber
  */
 public class FlatRadioButtonIcon
 	extends FlatCheckBoxIcon
 {
-	protected final int centerDiameter = getUIInt( "RadioButton.icon.centerDiameter", 8, style );
+	@Styleable protected float centerDiameter = getUIFloat( "RadioButton.icon.centerDiameter", 8, style );
 
 	@Override
-	protected void paintFocusBorder( Component c, Graphics2D g ) {
-		// the outline focus border is painted outside of the icon
-		int wh = ICON_SIZE + (focusWidth * 2);
-		g.fillOval( -focusWidth, -focusWidth, wh, wh );
+	protected String getPropertyPrefix() {
+		return "RadioButton.";
 	}
 
 	@Override
-	protected void paintBorder( Component c, Graphics2D g ) {
+	protected void paintFocusBorder( Component c, Graphics2D g ) {
+		// the outer focus border is painted outside of the icon
+		float wh = ICON_SIZE + (focusWidth * 2);
+		g.fill( new Ellipse2D.Float( -focusWidth, -focusWidth, wh, wh ) );
+	}
+
+	@Override
+	protected void paintBorder( Component c, Graphics2D g, float borderWidth ) {
+		if( borderWidth == 0 )
+			return;
+
 		g.fillOval( 0, 0, 15, 15 );
 	}
 
 	@Override
-	protected void paintBackground( Component c, Graphics2D g ) {
-		g.fillOval( 1, 1, 13, 13 );
+	protected void paintBackground( Component c, Graphics2D g, float borderWidth ) {
+		float xy = borderWidth;
+		float wh = 15 - (borderWidth * 2);
+		g.fill( new Ellipse2D.Float( xy, xy, wh, wh ) );
 	}
 
 	@Override

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

@@ -0,0 +1,100 @@
+/*
+ * 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.Color;
+import java.awt.Component;
+import java.awt.Graphics2D;
+import java.awt.geom.Area;
+import java.awt.geom.Ellipse2D;
+import java.util.Map;
+import javax.swing.UIManager;
+import com.formdev.flatlaf.ui.FlatButtonUI;
+import com.formdev.flatlaf.ui.FlatStylingSupport;
+import com.formdev.flatlaf.ui.FlatStylingSupport.Styleable;
+import com.formdev.flatlaf.ui.FlatUIUtils;
+
+/**
+ * "search" icon for search fields.
+ *
+ * @uiDefault SearchField.searchIconColor				Color
+ * @uiDefault SearchField.searchIconHoverColor			Color
+ * @uiDefault SearchField.searchIconPressedColor		Color
+ *
+ * @author Karl Tauber
+ * @since 1.5
+ */
+public class FlatSearchIcon
+	extends FlatAbstractIcon
+{
+	@Styleable protected Color searchIconColor = UIManager.getColor( "SearchField.searchIconColor" );
+	@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 */
+	public Object applyStyleProperty( String key, Object value ) {
+		return FlatStylingSupport.applyToAnnotatedObject( this, key, value );
+	}
+
+	/** @since 2 */
+	public Map<String, Class<?>> getStyleableInfos() {
+		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 ) {
+		/*
+			<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 16 16">
+			  <g fill="none" fill-opacity=".9" fill-rule="evenodd">
+			    <polygon fill="#7F8B91" points="10.813 9.75 14 12.938 12.938 14 9.75 10.813"/>
+			    <path fill="#7F8B91" d="M7,2 C9.76142375,2 12,4.23857625 12,7 C12,9.76142375 9.76142375,12 7,12 C4.23857625,12 2,9.76142375 2,7 C2,4.23857625 4.23857625,2 7,2 Z M7,3 C4.790861,3 3,4.790861 3,7 C3,9.209139 4.790861,11 7,11 C9.209139,11 11,9.209139 11,7 C11,4.790861 9.209139,3 7,3 Z"/>
+			  </g>
+			</svg>
+		*/
+
+		g.setColor( ignoreButtonState
+			? searchIconColor
+			: FlatButtonUI.buttonStateColor( c, searchIconColor, searchIconColor,
+				null, searchIconHoverColor, searchIconPressedColor ) );
+
+		// paint magnifier
+		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

@@ -0,0 +1,61 @@
+/*
+ * 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 com.formdev.flatlaf.ui.FlatUIUtils;
+
+/**
+ * "search with history" icon for search fields.
+ *
+ * @author Karl Tauber
+ * @since 1.5
+ */
+public class FlatSearchWithHistoryIcon
+	extends FlatSearchIcon
+{
+	public FlatSearchWithHistoryIcon() {
+		this( false );
+	}
+
+	/** @since 2 */
+	public FlatSearchWithHistoryIcon( boolean ignoreButtonState ) {
+		super( ignoreButtonState );
+	}
+
+	@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-opacity=".9" fill-rule="evenodd">
+			    <polygon fill="#7F8B91" points="8.813 9.75 12 12.938 10.938 14 7.75 10.813"/>
+			    <path fill="#7F8B91" d="M5,2 C7.76142375,2 10,4.23857625 10,7 C10,9.76142375 7.76142375,12 5,12 C2.23857625,12 0,9.76142375 0,7 C0,4.23857625 2.23857625,2 5,2 Z M5,3 C2.790861,3 1,4.790861 1,7 C1,9.209139 2.790861,11 5,11 C7.209139,11 9,9.209139 9,7 C9,4.790861 7.209139,3 5,3 Z"/>
+			    <polygon fill="#7F8B91" points="11 7 16 7 13.5 10"/>
+			  </g>
+			</svg>
+		*/
+
+		// paint magnifier
+		g.translate( -2, 0 );
+		super.paintIcon( c, g );
+		g.translate( 2, 0 );
+
+		// paint history arrow
+		g.fill( FlatUIUtils.createPath( 11,7, 16,7, 13.5,10 ) );
+	}
+}

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

@@ -21,10 +21,12 @@ 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;
 import com.formdev.flatlaf.ui.FlatButtonUI;
+import com.formdev.flatlaf.ui.FlatStylingSupport;
+import com.formdev.flatlaf.ui.FlatStylingSupport.Styleable;
 import com.formdev.flatlaf.ui.FlatUIUtils;
 
 /**
@@ -47,44 +49,61 @@ import com.formdev.flatlaf.ui.FlatUIUtils;
 public class FlatTabbedPaneCloseIcon
 	extends FlatAbstractIcon
 {
-	protected final Dimension size = UIManager.getDimension( "TabbedPane.closeSize" );
-	protected final int arc = UIManager.getInt( "TabbedPane.closeArc" );
-	protected final float crossPlainSize = FlatUIUtils.getUIFloat( "TabbedPane.closeCrossPlainSize", 7.5f );
-	protected final float crossFilledSize = FlatUIUtils.getUIFloat( "TabbedPane.closeCrossFilledSize", crossPlainSize );
-	protected final float closeCrossLineWidth = FlatUIUtils.getUIFloat( "TabbedPane.closeCrossLineWidth", 1f );
-	protected final Color background = UIManager.getColor( "TabbedPane.closeBackground" );
-	protected final Color foreground = UIManager.getColor( "TabbedPane.closeForeground" );
-	protected final Color hoverBackground = UIManager.getColor( "TabbedPane.closeHoverBackground" );
-	protected final Color hoverForeground = UIManager.getColor( "TabbedPane.closeHoverForeground" );
-	protected final Color pressedBackground = UIManager.getColor( "TabbedPane.closePressedBackground" );
-	protected final Color pressedForeground = UIManager.getColor( "TabbedPane.closePressedForeground" );
+	@Styleable protected Dimension closeSize = UIManager.getDimension( "TabbedPane.closeSize" );
+	@Styleable protected int closeArc = UIManager.getInt( "TabbedPane.closeArc" );
+	@Styleable protected float closeCrossPlainSize = FlatUIUtils.getUIFloat( "TabbedPane.closeCrossPlainSize", 7.5f );
+	@Styleable protected float closeCrossFilledSize = FlatUIUtils.getUIFloat( "TabbedPane.closeCrossFilledSize", closeCrossPlainSize );
+	@Styleable protected float closeCrossLineWidth = FlatUIUtils.getUIFloat( "TabbedPane.closeCrossLineWidth", 1f );
+	@Styleable protected Color closeBackground = UIManager.getColor( "TabbedPane.closeBackground" );
+	@Styleable protected Color closeForeground = UIManager.getColor( "TabbedPane.closeForeground" );
+	@Styleable protected Color closeHoverBackground = UIManager.getColor( "TabbedPane.closeHoverBackground" );
+	@Styleable protected Color closeHoverForeground = UIManager.getColor( "TabbedPane.closeHoverForeground" );
+	@Styleable protected Color closePressedBackground = UIManager.getColor( "TabbedPane.closePressedBackground" );
+	@Styleable protected Color closePressedForeground = UIManager.getColor( "TabbedPane.closePressedForeground" );
 
 	public FlatTabbedPaneCloseIcon() {
 		super( 16, 16, null );
 	}
 
+	/** @since 2 */
+	public Object applyStyleProperty( String key, Object value ) {
+		return FlatStylingSupport.applyToAnnotatedObject( this, key, value );
+	}
+
+	/** @since 2 */
+	public Map<String, Class<?>> getStyleableInfos() {
+		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
-		Color bg = FlatButtonUI.buttonStateColor( c, background, null, null, hoverBackground, pressedBackground );
+		Color bg = FlatButtonUI.buttonStateColor( c, closeBackground, null, null, closeHoverBackground, closePressedBackground );
 		if( bg != null ) {
 			g.setColor( FlatUIUtils.deriveColor( bg, c.getBackground() ) );
-			g.fillRoundRect( (width - size.width) / 2, (height - size.height) / 2,
-				size.width, size.height, arc, arc );
+			g.fillRoundRect( (width - closeSize.width) / 2, (height - closeSize.height) / 2,
+				closeSize.width, closeSize.height, closeArc, closeArc );
 		}
 
-		// set cross color
-		Color fg = FlatButtonUI.buttonStateColor( c, foreground, null, null, hoverForeground, pressedForeground );
+		// 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 r = ((bg != null) ? crossFilledSize : crossPlainSize) / 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,18 +32,26 @@ import com.formdev.flatlaf.ui.FlatUIUtils;
 public class FlatTreeClosedIcon
 	extends FlatAbstractIcon
 {
+	private Path2D path;
+
 	public FlatTreeClosedIcon() {
 		super( 16, 16, UIManager.getColor( "Tree.icon.closedColor" ) );
 	}
 
 	@Override
 	protected void paintIcon( Component c, Graphics2D g ) {
+		FlatTreeCollapsedIcon.setStyleColorFromTreeUI( c, g, ui -> ui.iconClosedColor );
+
 		/*
 			<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,10 +16,17 @@
 
 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;
 import javax.swing.UIManager;
+import javax.swing.plaf.TreeUI;
+import com.formdev.flatlaf.ui.FlatTreeUI;
 import com.formdev.flatlaf.ui.FlatUIUtils;
 
 /**
@@ -34,6 +41,7 @@ public class FlatTreeCollapsedIcon
 	extends FlatAbstractIcon
 {
 	private final boolean chevron;
+	private Path2D path;
 
 	public FlatTreeCollapsedIcon() {
 		this( UIManager.getColor( "Tree.icon.collapsedColor" ) );
@@ -46,19 +54,54 @@ public class FlatTreeCollapsedIcon
 
 	@Override
 	protected void paintIcon( Component c, Graphics2D g ) {
+		setStyleColorFromTreeUI( c, g );
 		rotate( c, g );
 
+		String arrowType = getStyleFromTreeUI( c, ui -> ui.iconArrowType );
+		boolean chevron = (arrowType != null) ? FlatUIUtils.isChevron( arrowType ) : this.chevron;
+
 		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 );
 		}
 	}
 
+	void setStyleColorFromTreeUI( Component c, Graphics2D g ) {
+		setStyleColorFromTreeUI( c, g, ui -> ui.iconCollapsedColor );
+	}
+
 	void rotate( Component c, Graphics2D g ) {
 		if( !c.getComponentOrientation().isLeftToRight() )
 			g.rotate( Math.toRadians( 180 ), width / 2., height / 2. );
 	}
+
+	/**
+	 * 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 ) {
+		JTree tree = (c instanceof JTree)
+			? (JTree) c
+			: (JTree) SwingUtilities.getAncestorOfClass( JTree.class, c );
+		if( tree != null ) {
+			TreeUI ui = tree.getUI();
+			if( ui instanceof FlatTreeUI )
+				return f.apply( (FlatTreeUI) ui );
+		}
+		return null;
+	}
+
+	static void setStyleColorFromTreeUI( Component c, Graphics2D g, Function<FlatTreeUI, Color> f ) {
+		Color color = getStyleFromTreeUI( c, f );
+		if( color != null )
+			g.setColor( color );
+	}
 }

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

@@ -34,6 +34,11 @@ public class FlatTreeExpandedIcon
 		super( UIManager.getColor( "Tree.icon.expandedColor" ) );
 	}
 
+	@Override
+	void setStyleColorFromTreeUI( Component c, Graphics2D g ) {
+		setStyleColorFromTreeUI( c, g, ui -> ui.iconExpandedColor );
+	}
+
 	@Override
 	void rotate( Component c, Graphics2D g ) {
 		g.rotate( Math.toRadians( 90 ), width / 2., height / 2. );

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}.
@@ -37,16 +41,27 @@ public class FlatTreeLeafIcon
 
 	@Override
 	protected void paintIcon( Component c, Graphics2D g ) {
+		FlatTreeCollapsedIcon.setStyleColorFromTreeUI( c, g, ui -> ui.iconLeafColor );
+
 		/*
 			<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,22 +34,50 @@ import com.formdev.flatlaf.ui.FlatUIUtils;
 public class FlatTreeOpenIcon
 	extends FlatAbstractIcon
 {
+	private Path2D path;
+
 	public FlatTreeOpenIcon() {
 		super( 16, 16, UIManager.getColor( "Tree.icon.openColor" ) );
 	}
 
 	@Override
 	protected void paintIcon( Component c, Graphics2D g ) {
+		FlatTreeCollapsedIcon.setStyleColorFromTreeUI( c, g, ui -> ui.iconOpenColor );
+
 		/*
 			<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

@@ -0,0 +1,28 @@
+/*
+ * 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.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 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
+ */
+interface EmptyPackage
+{
+}

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,19 +38,21 @@ public class FlatArrowButton
 	extends BasicArrowButton
 	implements UIResource
 {
-	public static final int DEFAULT_ARROW_WIDTH = 8;
+	public static final int DEFAULT_ARROW_WIDTH = 9;
 
-	protected final boolean chevron;
-	protected final Color foreground;
-	protected final Color disabledForeground;
-	protected final Color hoverForeground;
-	protected final Color hoverBackground;
-	protected final Color pressedForeground;
-	protected final Color pressedBackground;
+	protected boolean chevron;
+	protected Color foreground;
+	protected Color disabledForeground;
+	protected Color hoverForeground;
+	protected Color hoverBackground;
+	protected Color pressedForeground;
+	protected Color pressedBackground;
 
 	private int arrowWidth = DEFAULT_ARROW_WIDTH;
-	private int xOffset = 0;
-	private int yOffset = 0;
+	private float arrowThickness = 1;
+	private float xOffset = 0;
+	private float yOffset = 0;
+	private boolean roundBorderAutoXOffset = true;
 
 	private boolean hover;
 	private boolean pressed;
@@ -58,14 +61,8 @@ public class FlatArrowButton
 		Color hoverForeground, Color hoverBackground, Color pressedForeground, Color pressedBackground )
 	{
 		super( direction, Color.WHITE, Color.WHITE, Color.WHITE, Color.WHITE );
-
-		this.chevron = FlatUIUtils.isChevron( type );
-		this.foreground = foreground;
-		this.disabledForeground = disabledForeground;
-		this.hoverForeground = hoverForeground;
-		this.hoverBackground = hoverBackground;
-		this.pressedForeground = pressedForeground;
-		this.pressedBackground = pressedBackground;
+		updateStyle( type, foreground, disabledForeground, hoverForeground, hoverBackground,
+			pressedForeground, pressedBackground );
 
 		setOpaque( false );
 		setBorder( null );
@@ -88,19 +85,36 @@ 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();
+					}
 				}
 			} );
 		}
 	}
 
+	/** @since 2 */
+	public void updateStyle( String type, Color foreground, Color disabledForeground,
+		Color hoverForeground, Color hoverBackground, Color pressedForeground, Color pressedBackground )
+	{
+		this.chevron = FlatUIUtils.isChevron( type );
+		this.foreground = foreground;
+		this.disabledForeground = disabledForeground;
+		this.hoverForeground = hoverForeground;
+		this.hoverBackground = hoverBackground;
+		this.pressedForeground = pressedForeground;
+		this.pressedBackground = pressedBackground;
+	}
+
 	public int getArrowWidth() {
 		return arrowWidth;
 	}
@@ -109,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;
 	}
@@ -117,22 +141,32 @@ public class FlatArrowButton
 		return pressed;
 	}
 
-	public int getXOffset() {
+	public float getXOffset() {
 		return xOffset;
 	}
 
-	public void setXOffset( int xOffset ) {
+	public void setXOffset( float xOffset ) {
 		this.xOffset = xOffset;
 	}
 
-	public int getYOffset() {
+	public float getYOffset() {
 		return yOffset;
 	}
 
-	public void setYOffset( int yOffset ) {
+	public void setYOffset( float yOffset ) {
 		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;
 	}
@@ -141,6 +175,21 @@ public class FlatArrowButton
 		return FlatUIUtils.deriveColor( foreground, this.foreground );
 	}
 
+	/**
+	 * Returns the color used to paint the arrow.
+	 *
+	 * @since 1.2
+	 */
+	protected Color getArrowColor() {
+		return isEnabled()
+			? (pressedForeground != null && isPressed()
+				? pressedForeground
+				: (hoverForeground != null && isHover()
+					? hoverForeground
+					: foreground))
+			: disabledForeground;
+	}
+
 	@Override
 	public Dimension getPreferredSize() {
 		return scale( super.getPreferredSize() );
@@ -170,13 +219,7 @@ public class FlatArrowButton
 		}
 
 		// paint arrow
-		g.setColor( deriveForeground( isEnabled()
-			? (pressedForeground != null && isPressed()
-				? pressedForeground
-				: (hoverForeground != null && isHover()
-					? hoverForeground
-					: foreground))
-			: disabledForeground ) );
+		g.setColor( deriveForeground( getArrowColor() ) );
 		paintArrow( (Graphics2D) g );
 
 		FlatUIUtils.resetRenderingHints( g, oldRenderingHints );
@@ -187,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

@@ -22,34 +22,34 @@ import java.awt.Component;
 import java.awt.Graphics;
 import java.awt.Graphics2D;
 import java.awt.Insets;
-import java.awt.KeyboardFocusManager;
 import java.awt.Paint;
+import java.util.Map;
 import javax.swing.JComboBox;
 import javax.swing.JComponent;
 import javax.swing.JScrollPane;
 import javax.swing.JSpinner;
-import javax.swing.JTable;
-import javax.swing.JTextField;
-import javax.swing.JTree;
-import javax.swing.JViewport;
-import javax.swing.SwingUtilities;
 import javax.swing.UIManager;
 import javax.swing.plaf.basic.BasicBorders;
 import com.formdev.flatlaf.FlatClientProperties;
+import com.formdev.flatlaf.ui.FlatStylingSupport.Styleable;
+import com.formdev.flatlaf.ui.FlatStylingSupport.StyleableBorder;
 import com.formdev.flatlaf.util.DerivedColor;
 
 /**
  * Border for various components (e.g. {@link javax.swing.JTextField}).
- *
+ * <p>
  * There is empty space around the component border, if Component.focusWidth is greater than zero,
  * which is used to paint outer focus border.
- *
+ * <p>
  * Because there is empty space (if outer focus border is not painted),
  * UI delegates that use this border (or subclasses) must invoke
- * {@link FlatUIUtils#paintParentBackground} to paint the empty space correctly.
+ * {@link FlatUIUtils#paintParentBackground} to fill the empty space correctly.
  *
  * @uiDefault Component.focusWidth						int
  * @uiDefault Component.innerFocusWidth					int or float
+ * @uiDefault Component.innerOutlineWidth				int or float
+ * @uiDefault Component.borderWidth						int or float
+ *
  * @uiDefault Component.focusColor						Color
  * @uiDefault Component.borderColor						Color
  * @uiDefault Component.disabledBorderColor				Color
@@ -59,26 +59,56 @@ 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
  */
 public class FlatBorder
 	extends BasicBorders.MarginBorder
+	implements StyleableBorder
 {
-	protected final int focusWidth = UIManager.getInt( "Component.focusWidth" );
-	protected final float innerFocusWidth = FlatUIUtils.getUIFloat( "Component.innerFocusWidth", 0 );
-	protected final float innerOutlineWidth = FlatUIUtils.getUIFloat( "Component.innerOutlineWidth", 0 );
-	protected final Color focusColor = UIManager.getColor( "Component.focusColor" );
-	protected final Color borderColor = UIManager.getColor( "Component.borderColor" );
-	protected final Color disabledBorderColor = UIManager.getColor( "Component.disabledBorderColor" );
-	protected final Color focusedBorderColor = UIManager.getColor( "Component.focusedBorderColor" );
+	@Styleable protected int focusWidth = UIManager.getInt( "Component.focusWidth" );
+	@Styleable protected float innerFocusWidth = FlatUIUtils.getUIFloat( "Component.innerFocusWidth", 0 );
+	@Styleable protected float innerOutlineWidth = FlatUIUtils.getUIFloat( "Component.innerOutlineWidth", 0 );
+	/** @since 2 */ @Styleable protected float borderWidth = FlatUIUtils.getUIFloat( "Component.borderWidth", 1 );
 
-	protected final Color errorBorderColor = UIManager.getColor( "Component.error.borderColor" );
-	protected final Color errorFocusedBorderColor = UIManager.getColor( "Component.error.focusedBorderColor" );
-	protected final Color warningBorderColor = UIManager.getColor( "Component.warning.borderColor" );
-	protected final Color warningFocusedBorderColor = UIManager.getColor( "Component.warning.focusedBorderColor" );
-	protected final Color customBorderColor = UIManager.getColor( "Component.custom.borderColor" );
+	@Styleable protected Color focusColor = UIManager.getColor( "Component.focusColor" );
+	@Styleable protected Color borderColor = UIManager.getColor( "Component.borderColor" );
+	@Styleable protected Color disabledBorderColor = UIManager.getColor( "Component.disabledBorderColor" );
+	@Styleable protected Color focusedBorderColor = UIManager.getColor( "Component.focusedBorderColor" );
+
+	@Styleable(dot=true) protected Color errorBorderColor = UIManager.getColor( "Component.error.borderColor" );
+	@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)
+	/** @since 2 */ @Styleable protected String outline;
+	/** @since 2 */ @Styleable protected Color outlineColor;
+	/** @since 2 */ @Styleable protected Color outlineFocusedColor;
+
+	/** @since 2 */
+	@Override
+	public Object applyStyleProperty( String key, Object value ) {
+		return FlatStylingSupport.applyToAnnotatedObject( this, key, value );
+	}
+
+	/** @since 2 */
+	@Override
+	public Map<String, Class<?>> getStyleableInfos() {
+		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 ) {
@@ -87,9 +117,11 @@ public class FlatBorder
 			FlatUIUtils.setRenderingHints( g2 );
 
 			float focusWidth = scale( (float) getFocusWidth( c ) );
-			float borderWidth = scale( (float) getBorderWidth( c ) );
+			float focusInnerWidth = 0;
+			float borderWidth = scale( getBorderWidth( c ) );
 			float arc = scale( (float) getArc( c ) );
 			Color outlineColor = getOutlineColor( c );
+			Color focusColor = null;
 
 			// paint outer border
 			if( outlineColor != null || isFocused( c ) ) {
@@ -98,15 +130,16 @@ public class FlatBorder
 					: 0;
 
 				if( focusWidth > 0 || innerWidth > 0 ) {
-					g2.setColor( (outlineColor != null) ? outlineColor : getFocusColor( c ) );
-					FlatUIUtils.paintComponentOuterBorder( g2, x, y, width, height,
-						focusWidth, borderWidth + scale( innerWidth ), arc );
+					focusColor = (outlineColor != null) ? outlineColor : getFocusColor( c );
+					focusInnerWidth = borderWidth + scale( innerWidth );
 				}
 			}
 
 			// paint border
-			g2.setPaint( (outlineColor != null) ? outlineColor : getBorderColor( c ) );
-			FlatUIUtils.paintComponentBorder( g2, x, y, width, height, focusWidth, borderWidth, arc );
+			Paint borderColor = (outlineColor != null) ? outlineColor : getBorderColor( c );
+			FlatUIUtils.paintOutlinedComponent( g2, x, y, width, height,
+				focusWidth, 1, focusInnerWidth, borderWidth, arc,
+				focusColor, borderColor, null, c instanceof JScrollPane );
 		} finally {
 			g2.dispose();
 		}
@@ -121,6 +154,17 @@ public class FlatBorder
 			return null;
 
 		Object outline = ((JComponent)c).getClientProperty( FlatClientProperties.OUTLINE );
+		if( outline == null )
+			outline = this.outline;
+		if( outline == null ) {
+			if( outlineColor != null && outlineFocusedColor != null )
+				outline = new Color[] { outlineFocusedColor, outlineColor };
+			else if( outlineColor != null )
+				outline = outlineColor;
+			else if( outlineFocusedColor != null )
+				outline = outlineFocusedColor;
+		}
+
 		if( outline instanceof String ) {
 			switch( (String) outline ) {
 				case FlatClientProperties.OUTLINE_ERROR:
@@ -128,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;
@@ -154,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;
 		}
@@ -164,37 +210,13 @@ public class FlatBorder
 	}
 
 	protected boolean isFocused( Component c ) {
-		if( c instanceof JScrollPane ) {
-			JViewport viewport = ((JScrollPane)c).getViewport();
-			Component view = (viewport != null) ? viewport.getView() : null;
-			if( view != null ) {
-				if( FlatUIUtils.isPermanentFocusOwner( view ) )
-					return true;
-
-				if( (view instanceof JTable && ((JTable)view).isEditing()) ||
-					(view instanceof JTree && ((JTree)view).isEditing()) )
-				{
-					Component focusOwner = KeyboardFocusManager.getCurrentKeyboardFocusManager().getFocusOwner();
-					if( focusOwner != null )
-						return SwingUtilities.isDescendingFrom( focusOwner, view );
-				}
-			}
-			return false;
-		} else if( c instanceof JComboBox && ((JComboBox<?>)c).isEditable() ) {
-			Component editorComponent = ((JComboBox<?>)c).getEditor().getEditorComponent();
-			return (editorComponent != null) ? FlatUIUtils.isPermanentFocusOwner( editorComponent ) : false;
-		} else if( c instanceof JSpinner ) {
-			if( FlatUIUtils.isPermanentFocusOwner( c ) )
-				return true;
-
-			JComponent editor = ((JSpinner)c).getEditor();
-			if( editor instanceof JSpinner.DefaultEditor ) {
-				JTextField textField = ((JSpinner.DefaultEditor)editor).getTextField();
-				if( textField != null )
-					return FlatUIUtils.isPermanentFocusOwner( textField );
-			}
-			return false;
-		} else
+		if( c instanceof JScrollPane )
+			return FlatScrollPaneUI.isPermanentFocusOwner( (JScrollPane) c );
+		else if( c instanceof JComboBox )
+			return FlatComboBoxUI.isPermanentFocusOwner( (JComboBox<?>) c );
+		else if( c instanceof JSpinner )
+			return FlatSpinnerUI.isPermanentFocusOwner( (JSpinner) c );
+		else
 			return FlatUIUtils.isPermanentFocusOwner( c );
 	}
 
@@ -205,13 +227,14 @@ public class FlatBorder
 	@Override
 	public Insets getBorderInsets( Component c, Insets insets ) {
 		float focusWidth = scale( (float) getFocusWidth( c ) );
-		float ow = focusWidth + scale( (float) getLineWidth( c ) );
+		int ow = Math.round( focusWidth + scale( (float) getLineWidth( c ) ) );
 
 		insets = super.getBorderInsets( c, insets );
-		insets.top = Math.round( scale( (float) insets.top ) + ow );
-		insets.left = Math.round( scale( (float) insets.left ) + ow );
-		insets.bottom = Math.round( scale( (float) insets.bottom ) + ow );
-		insets.right = Math.round( scale( (float) insets.right ) + ow );
+
+		insets.top = scale( insets.top ) + ow;
+		insets.left = scale( insets.left ) + ow;
+		insets.bottom = scale( insets.bottom ) + ow;
+		insets.right = scale( insets.right ) + ow;
 
 		if( isCellEditor( c ) ) {
 			// remove top and bottom insets if used as cell editor
@@ -256,12 +279,12 @@ public class FlatBorder
 	 * Returns the (unscaled) line thickness used to paint the border.
 	 * This may be different to {@link #getLineWidth}.
 	 */
-	protected int getBorderWidth( Component c ) {
-		return getLineWidth( c );
+	protected float getBorderWidth( Component c ) {
+		return borderWidth;
 	}
 
 	/**
-	 * 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

@@ -20,69 +20,131 @@ import java.awt.Color;
 import java.awt.Component;
 import java.awt.GradientPaint;
 import java.awt.Graphics;
+import java.awt.Graphics2D;
 import java.awt.Insets;
 import java.awt.Paint;
 import javax.swing.AbstractButton;
 import javax.swing.UIManager;
 import javax.swing.plaf.UIResource;
+import com.formdev.flatlaf.ui.FlatStylingSupport.Styleable;
 import com.formdev.flatlaf.util.UIScale;
 
 /**
  * Border for {@link javax.swing.JButton}.
  *
+ * @uiDefault Button.arc						int
+ * @uiDefault Button.innerFocusWidth			int or float	optional; defaults to Component.innerFocusWidth
+ * @uiDefault Button.borderWidth				int or float	optional; defaults to Component.borderWidth
+ *
  * @uiDefault Button.borderColor				Color
  * @uiDefault Button.startBorderColor			Color	optional; if set, a gradient paint is used and Button.borderColor is ignored
  * @uiDefault Button.endBorderColor				Color	optional; if set, a gradient paint is used
  * @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
  * @uiDefault Button.default.startBorderColor	Color	optional; if set, a gradient paint is used and Button.default.borderColor is ignored
  * @uiDefault Button.default.endBorderColor		Color	optional; if set, a gradient paint is used
- * @uiDefault Button.default.hoverBorderColor	Color	optional
  * @uiDefault Button.default.focusedBorderColor	Color
  * @uiDefault Button.default.focusColor			Color
- * @uiDefault Button.borderWidth				int
- * @uiDefault Button.default.borderWidth		int
- * @uiDefault Button.innerFocusWidth			int or float	optional; defaults to Component.innerFocusWidth
+ * @uiDefault Button.default.pressedBorderColor	Color	optional
+ * @uiDefault Button.default.hoverBorderColor	Color	optional
+ *
+ * @uiDefault Button.toolbar.focusWidth			int or float		optional; default is 1.5
+ * @uiDefault Button.toolbar.focusColor			Color	optional; defaults to Component.focusColor
  * @uiDefault Button.toolbar.margin				Insets
  * @uiDefault Button.toolbar.spacingInsets		Insets
- * @uiDefault Button.arc						int
  *
  * @author Karl Tauber
  */
 public class FlatButtonBorder
 	extends FlatBorder
 {
-	protected final Color borderColor = FlatUIUtils.getUIColor( "Button.startBorderColor", "Button.borderColor" );
-	protected final Color endBorderColor = UIManager.getColor( "Button.endBorderColor" );
-	protected final Color disabledBorderColor = UIManager.getColor( "Button.disabledBorderColor" );
-	protected final Color focusedBorderColor = UIManager.getColor( "Button.focusedBorderColor" );
-	protected final Color hoverBorderColor = UIManager.getColor( "Button.hoverBorderColor" );
-	protected final Color defaultBorderColor = FlatUIUtils.getUIColor( "Button.default.startBorderColor", "Button.default.borderColor" );
-	protected final Color defaultEndBorderColor = UIManager.getColor( "Button.default.endBorderColor" );
-	protected final Color defaultHoverBorderColor = UIManager.getColor( "Button.default.hoverBorderColor" );
-	protected final Color defaultFocusedBorderColor = UIManager.getColor( "Button.default.focusedBorderColor" );
-	protected final Color defaultFocusColor = UIManager.getColor( "Button.default.focusColor" );
-	protected final int borderWidth = UIManager.getInt( "Button.borderWidth" );
-	protected final int defaultBorderWidth = UIManager.getInt( "Button.default.borderWidth" );
-	protected final float buttonInnerFocusWidth = FlatUIUtils.getUIFloat( "Button.innerFocusWidth", innerFocusWidth );
-	protected final Insets toolbarMargin = UIManager.getInsets( "Button.toolbar.margin" );
-	protected final Insets toolbarSpacingInsets = UIManager.getInsets( "Button.toolbar.spacingInsets" );
-	protected final int arc = UIManager.getInt( "Button.arc" );
+	@Styleable protected int arc = UIManager.getInt( "Button.arc" );
+
+	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" );
+	protected Color defaultEndBorderColor = UIManager.getColor( "Button.default.endBorderColor" );
+	@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" );
+	@Styleable(dot=true) protected Insets toolbarMargin = UIManager.getInsets( "Button.toolbar.margin" );
+	@Styleable(dot=true) protected Insets toolbarSpacingInsets = UIManager.getInsets( "Button.toolbar.spacingInsets" );
+
+	public FlatButtonBorder() {
+		innerFocusWidth = FlatUIUtils.getUIFloat( "Button.innerFocusWidth", innerFocusWidth );
+		borderWidth = FlatUIUtils.getUIFloat( "Button.borderWidth", borderWidth );
+
+		borderColor = FlatUIUtils.getUIColor( "Button.startBorderColor", "Button.borderColor" );
+		disabledBorderColor = UIManager.getColor( "Button.disabledBorderColor" );
+		focusedBorderColor = UIManager.getColor( "Button.focusedBorderColor" );
+	}
 
 	@Override
 	public void paintBorder( Component c, Graphics g, int x, int y, int width, int height ) {
 		if( FlatButtonUI.isContentAreaFilled( c ) &&
 			!FlatButtonUI.isToolBarButton( c ) &&
+			(!FlatButtonUI.isBorderlessButton( c ) || FlatUIUtils.isPermanentFocusOwner( c )) &&
 			!FlatButtonUI.isHelpButton( c ) &&
 			!FlatToggleButtonUI.isTabButton( c ) )
 		  super.paintBorder( c, g, x, y, width, height );
+		else if( FlatButtonUI.isToolBarButton( c ) && isFocused( c ) )
+			paintToolBarFocus( c, g, x, y, width, height );
+	}
+
+	/** @since 1.4 */
+	protected void paintToolBarFocus( Component c, Graphics g, int x, int y, int width, int height ) {
+		Graphics2D g2 = (Graphics2D) g.create();
+		try {
+			FlatUIUtils.setRenderingHints( g2 );
+
+			float focusWidth = UIScale.scale( toolbarFocusWidth );
+			float arc = UIScale.scale( (float) getArc( c ) );
+			Color outlineColor = getOutlineColor( c );
+
+			Insets spacing = UIScale.scale( toolbarSpacingInsets );
+			x += spacing.left;
+			y += spacing.top;
+			width -= spacing.left + spacing.right;
+			height -= spacing.top + spacing.bottom;
+
+			Color color = (outlineColor != null) ? outlineColor : getFocusColor( c );
+			// not using focus border painting of paintOutlinedComponent() here
+			// because its round edges look too "thick"
+			FlatUIUtils.paintOutlinedComponent( g2, x, y, width, height, 0, 0, 0, focusWidth, arc, null, color, null );
+		} finally {
+			g2.dispose();
+		}
 	}
 
 	@Override
 	protected Color getFocusColor( Component c ) {
-		return FlatButtonUI.isDefaultButton( c ) ? defaultFocusColor : super.getFocusColor( c );
+		return (toolbarFocusColor != null && FlatButtonUI.isToolBarButton( c ))
+			? toolbarFocusColor
+			: (FlatButtonUI.isDefaultButton( c ) ? defaultFocusColor : super.getFocusColor( c ));
 	}
 
 	@Override
@@ -93,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;
@@ -113,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;
@@ -137,12 +200,7 @@ public class FlatButtonBorder
 	}
 
 	@Override
-	protected float getInnerFocusWidth( Component c ) {
-		return buttonInnerFocusWidth;
-	}
-
-	@Override
-	protected int getBorderWidth( Component c ) {
+	protected float getBorderWidth( Component c ) {
 		return FlatButtonUI.isDefaultButton( c ) ? defaultBorderWidth : borderWidth;
 	}
 

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,22 +29,41 @@ 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;
+import java.util.Objects;
+import java.util.concurrent.atomic.AtomicBoolean;
 import javax.swing.AbstractButton;
 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;
 
 /**
@@ -65,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
@@ -86,15 +113,21 @@ 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
  */
 public class FlatButtonUI
 	extends BasicButtonUI
+	implements StyleableUI
 {
-	protected int minimumWidth;
+	@Styleable protected int minimumWidth;
 	protected int iconTextGap;
 
 	protected Color background;
@@ -102,38 +135,81 @@ public class FlatButtonUI
 
 	protected Color startBackground;
 	protected Color endBackground;
-	protected Color focusedBackground;
-	protected Color hoverBackground;
-	protected Color pressedBackground;
-	protected Color selectedBackground;
-	protected Color selectedForeground;
-	protected Color disabledBackground;
-	protected Color disabledText;
-	protected Color disabledSelectedBackground;
+	@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;
 
-	protected Color defaultBackground;
+	@Styleable(dot=true) protected Color defaultBackground;
 	protected Color defaultEndBackground;
-	protected Color defaultForeground;
-	protected Color defaultFocusedBackground;
-	protected Color defaultHoverBackground;
-	protected Color defaultPressedBackground;
-	protected boolean defaultBoldText;
+	@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;
 
-	protected int shadowWidth;
-	protected Color shadowColor;
-	protected Color defaultShadowColor;
+	@Styleable protected boolean paintShadow;
+	@Styleable protected int shadowWidth;
+	@Styleable protected Color shadowColor;
+	@Styleable(dot=true) protected Color defaultShadowColor;
 
-	protected Insets toolbarSpacingInsets;
-	protected Color toolbarHoverBackground;
-	protected Color toolbarPressedBackground;
-	protected Color toolbarSelectedBackground;
+	@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;
+	/** @since 2 */ @Styleable protected boolean squareSize;
+	/** @since 2 */ @Styleable protected int minimumHeight;
 
 	private Icon helpButtonIcon;
+	private Insets defaultMargin;
 
+	private final boolean shared;
+	private boolean helpButtonIconShared = true;
 	private boolean defaults_initialized = false;
+	private Map<String, Object> oldStyleValues;
+	private AtomicBoolean borderShared;
 
 	public static ComponentUI createUI( JComponent c ) {
-		return FlatUIUtils.createSharedUI( FlatButtonUI.class, FlatButtonUI::new );
+		return FlatUIUtils.canUseSharedUI( c ) && !FlatUIUtils.needsLightAWTPeer( c )
+			? FlatUIUtils.createSharedUI( FlatButtonUI.class, () -> new FlatButtonUI( true ) )
+			: new FlatButtonUI( false );
+	}
+
+	/** @since 2 */
+	protected FlatButtonUI( boolean shared ) {
+		this.shared = shared;
+	}
+
+	@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 );
 	}
 
 	@Override
@@ -152,39 +228,47 @@ 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" );
-
-			if( UIManager.getBoolean( "Button.paintShadow" ) ) {
-				shadowWidth = FlatUIUtils.getUIInt( "Button.shadowWidth", 2 );
-				shadowColor = UIManager.getColor( "Button.shadowColor" );
-				defaultShadowColor = UIManager.getColor( "Button.default.shadowColor" );
-			} else {
-				shadowWidth = 0;
-				shadowColor = null;
-				defaultShadowColor = null;
-			}
+			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" );
 
-			toolbarSpacingInsets = UIManager.getInsets( "Button.toolbar.spacingInsets" );
+			paintShadow = UIManager.getBoolean( "Button.paintShadow" );
+			shadowWidth = FlatUIUtils.getUIInt( "Button.shadowWidth", 2 );
+			shadowColor = UIManager.getColor( "Button.shadowColor" );
+			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" );
 
+			helpButtonIconShared = true;
 			defaults_initialized = true;
 		}
 
@@ -196,18 +280,32 @@ public class FlatButtonUI
 
 		LookAndFeel.installProperty( b, "opaque", false );
 		LookAndFeel.installProperty( b, "iconTextGap", scale( iconTextGap ) );
-
-		MigLayoutVisualPadding.install( b );
 	}
 
 	@Override
 	protected void uninstallDefaults( AbstractButton b ) {
 		super.uninstallDefaults( b );
 
-		MigLayoutVisualPadding.uninstall( b );
+		oldStyleValues = null;
+		borderShared = null;
+
 		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 );
@@ -215,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:
@@ -223,11 +325,97 @@ 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 installStyle() from installUI()
+					b.updateUI();
+				} else
+					installStyle( b );
+				b.revalidate();
+				HiDPIUtils.repaint( b );
 				break;
 		}
 	}
 
+	/** @since 2 */
+	protected void installStyle( AbstractButton b ) {
+		try {
+			applyStyle( b, FlatStylingSupport.getResolvedStyle( b, getStyleType() ) );
+		} catch( RuntimeException ex ) {
+			LoggingFacade.INSTANCE.logSevere( null, ex );
+		}
+	}
+
+	/** @since 2 */
+	String getStyleType() {
+		return "Button";
+	}
+
+	/** @since 2 */
+	protected void applyStyle( AbstractButton b, Object style ) {
+		oldStyleValues = FlatStylingSupport.parseAndApply( oldStyleValues, style,
+			(key, value) -> applyStyleProperty( b, key, value ) );
+	}
+
+	/** @since 2 */
+	protected Object applyStyleProperty( AbstractButton b, String key, Object value ) {
+		if( key.startsWith( "help." ) ) {
+			if( !(helpButtonIcon instanceof FlatHelpButtonIcon) )
+				return new UnknownStyleException( key );
+
+			if( helpButtonIconShared ) {
+				helpButtonIcon = FlatStylingSupport.cloneIcon( helpButtonIcon );
+				helpButtonIconShared = false;
+			}
+
+			key = key.substring( "help.".length() );
+			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 );
+	}
+
+	/** @since 2 */
+	@Override
+	public Map<String, Class<?>> getStyleableInfos( JComponent c ) {
+		Map<String, Class<?>> infos = FlatStylingSupport.getAnnotatedStyleableInfos( this, c.getBorder() );
+		if( helpButtonIcon instanceof FlatHelpButtonIcon )
+			FlatStylingSupport.putAllPrefixKey( infos, "help.", ((FlatHelpButtonIcon)helpButtonIcon).getStyleableInfos() );
+		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();
 	}
@@ -242,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) )
@@ -265,11 +453,11 @@ public class FlatButtonUI
 		if( !(c instanceof AbstractButton) )
 			return TYPE_OTHER;
 
-		Object value = ((AbstractButton)c).getClientProperty( BUTTON_TYPE );
-		if( !(value instanceof String) )
+		String value = getButtonTypeStr( (AbstractButton) c );
+		if( value == null )
 			return TYPE_OTHER;
 
-		switch( (String) value ) {
+		switch( value ) {
 			case BUTTON_TYPE_SQUARE:		return TYPE_SQUARE;
 			case BUTTON_TYPE_ROUND_RECT:	return TYPE_ROUND_RECT;
 			default:						return TYPE_OTHER;
@@ -277,12 +465,27 @@ public class FlatButtonUI
 	}
 
 	static boolean isHelpButton( Component c ) {
-		return c instanceof JButton && clientPropertyEquals( (JButton) c, BUTTON_TYPE, BUTTON_TYPE_HELP );
+		return c instanceof JButton && BUTTON_TYPE_HELP.equals( getButtonTypeStr( (JButton) c ) );
 	}
 
 	static boolean isToolBarButton( Component c ) {
 		return c.getParent() instanceof JToolBar ||
-			(c instanceof AbstractButton && clientPropertyEquals( (AbstractButton) c, BUTTON_TYPE, BUTTON_TYPE_TOOLBAR_BUTTON ));
+			(c instanceof AbstractButton && BUTTON_TYPE_TOOLBAR_BUTTON.equals( getButtonTypeStr( (AbstractButton) c ) ));
+	}
+
+	static boolean isBorderlessButton( Component c ) {
+		return c instanceof AbstractButton && BUTTON_TYPE_BORDERLESS.equals( getButtonTypeStr( (AbstractButton) c ) );
+	}
+
+	static String getButtonTypeStr( AbstractButton c ) {
+		// get from client property
+		Object value = c.getClientProperty( BUTTON_TYPE );
+		if( value instanceof String )
+			return (String) value;
+
+		// get from styling property
+		ButtonUI ui = c.getUI();
+		return (ui instanceof FlatButtonUI) ? ((FlatButtonUI)ui).buttonType : null;
 	}
 
 	@Override
@@ -311,29 +514,48 @@ 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;
 			int width = c.getWidth();
 			int height = c.getHeight();
 
-			if( isToolBarButton ) {
-				Insets spacing = UIScale.scale( toolbarSpacingInsets );
+			if( isToolBarButton && c.getBorder() instanceof FlatButtonBorder ) {
+				Insets spacing = UIScale.scale( ((FlatButtonBorder)c.getBorder()).toolbarSpacingInsets );
 				x += spacing.left;
 				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( !isToolBarButton && shadowColor != null && shadowWidth > 0 && focusWidth > 0 &&
-				!(isFocusPainted( c ) && FlatUIUtils.isPermanentFocusOwner( c )) && c.isEnabled() )
+			if( paintShadow &&
+				shadowColor != null && shadowWidth > 0 && focusWidth > 0 && c.isEnabled() &&
+				!isToolBarButton && !isBorderlessButton( c ) &&
+				!(isFocusPainted( c ) && FlatUIUtils.isPermanentFocusOwner( c )) )
 			{
 				g2.setColor( shadowColor );
 				g2.fill( new RoundRectangle2D.Float( focusWidth, focusWidth + UIScale.scale( (float) shadowWidth ),
@@ -354,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
@@ -388,47 +670,47 @@ public class FlatButtonUI
 	}
 
 	protected Color getBackground( JComponent c ) {
+		boolean def = isDefaultButton( c );
+		boolean toolBarButton = !def && (isToolBarButton( c ) || isBorderlessButton( c ));
+
+		// selected state
 		if( ((AbstractButton)c).isSelected() ) {
-			// in toolbar use same 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
-			boolean toolBarButton = isToolBarButton( c );
 			return buttonStateColor( c,
 				toolBarButton ? toolbarSelectedBackground : selectedBackground,
-				toolBarButton ? toolbarSelectedBackground : disabledSelectedBackground,
-				null, null,
+				toolBarButton
+					? (toolbarDisabledSelectedBackground != null ? toolbarDisabledSelectedBackground : toolbarSelectedBackground)
+					: disabledSelectedBackground,
+				null,
+				null,
 				toolBarButton ? toolbarPressedBackground : pressedBackground );
 		}
 
-		if( !c.isEnabled() )
-			return disabledBackground;
-
 		// toolbar button
-		if( isToolBarButton( c ) ) {
-			ButtonModel model = ((AbstractButton)c).getModel();
-			if( model.isPressed() )
-				return toolbarPressedBackground;
-			if( model.isRollover() )
-				return toolbarHoverBackground;
-
-			// use component background if explicitly set
+		if( toolBarButton ) {
 			Color bg = c.getBackground();
-			if( isCustomBackground( bg ) )
-				return bg;
-
-			// do not paint background
-			return null;
+			return buttonStateColor( c,
+				isCustomBackground( bg ) ? bg : null,
+				null,
+				null,
+				toolbarHoverBackground,
+				toolbarPressedBackground );
 		}
 
-		boolean def = isDefaultButton( c );
 		return buttonStateColor( c,
 			getBackgroundBase( c, def ),
-			null,
+			disabledBackground,
 			isCustomBackground( c.getBackground() ) ? null : (def ? defaultFocusedBackground : focusedBackground),
 			def ? defaultHoverBackground : hoverBackground,
 			def ? defaultPressedBackground : pressedBackground );
 	}
 
 	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 ) )
@@ -444,16 +726,21 @@ public class FlatButtonUI
 	public static Color buttonStateColor( Component c, Color enabledColor, Color disabledColor,
 		Color focusedColor, Color hoverColor, Color pressedColor )
 	{
-		AbstractButton b = (c instanceof AbstractButton) ? (AbstractButton) c : null;
+		if( c == null )
+			return enabledColor;
 
 		if( !c.isEnabled() )
 			return disabledColor;
 
-		if( pressedColor != null && b != null && b.getModel().isPressed() )
-			return pressedColor;
+		if( c instanceof AbstractButton ) {
+			ButtonModel model = ((AbstractButton)c).getModel();
 
-		if( hoverColor != null && b != null && b.getModel().isRollover() )
-			return hoverColor;
+			if( pressedColor != null && model.isPressed() )
+				return pressedColor;
+
+			if( hoverColor != null && model.isRollover() )
+				return hoverColor;
+		}
 
 		if( focusedColor != null && isFocusPainted( c ) && FlatUIUtils.isPermanentFocusOwner( c ) )
 			return focusedColor;
@@ -462,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 ) )
-			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;
 	}
 
@@ -490,24 +808,112 @@ 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, false ) ) {
+		if( clientPropertyBoolean( c, SQUARE_SIZE, squareSize ) ) {
 			// make button square (increase width or height so that they are equal)
 			prefSize.width = prefSize.height = Math.max( prefSize.width, prefSize.height );
 		} else if( isIconOnlyOrSingleCharacter && ((AbstractButton)c).getIcon() == null ) {
 			// make single-character-no-icon button square (increase width)
 			prefSize.width = Math.max( prefSize.width, prefSize.height );
-		} else if( !isIconOnlyOrSingleCharacter && !isToolBarButton( c ) && c.getBorder() instanceof FlatButtonBorder ) {
+		} else if( !isIconOnlyOrSingleCharacter && !isToolBarButton( c ) &&
+			c.getBorder() instanceof FlatButtonBorder && hasDefaultMargins( c ) )
+		{
 			// apply minimum width/height
-			float focusWidth = FlatUIUtils.getBorderFocusWidth( c );
-			prefSize.width = Math.max( prefSize.width, scale( FlatUIUtils.minimumWidth( c, minimumWidth ) ) + Math.round( focusWidth * 2 ) );
-			prefSize.height = Math.max( prefSize.height, scale( FlatUIUtils.minimumHeight( c, 0 ) ) + Math.round( focusWidth * 2 ) );
+			int fw = Math.round( FlatUIUtils.getBorderFocusWidth( c ) * 2 );
+			prefSize.width = Math.max( prefSize.width, scale( FlatUIUtils.minimumWidth( c, minimumWidth ) ) + fw );
+			prefSize.height = Math.max( prefSize.height, scale( FlatUIUtils.minimumHeight( c, minimumHeight ) ) + fw );
 		}
 
 		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
@@ -525,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,17 +17,32 @@
 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;
 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;
+import javax.swing.text.BadLocationException;
 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;
 
 /**
  * Caret that can select all text on focus gained.
+ * Also fixes Swing's double-click-and-drag behavior so that dragging after
+ * a double-click extends selection by whole words.
  *
  * @author Karl Tauber
  */
@@ -35,12 +50,22 @@ public class FlatCaret
 	extends DefaultCaret
 	implements UIResource
 {
+	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;
+	private int dragSelectionStart;
+	private int dragSelectionEnd;
 
 	public FlatCaret( String selectAllOnFocusPolicy, boolean selectAllOnMouseClick ) {
 		this.selectAllOnFocusPolicy = selectAllOnFocusPolicy;
@@ -49,23 +74,113 @@ public class FlatCaret
 
 	@Override
 	public void install( JTextComponent c ) {
-		super.install( c );
+		// get caret info if switched theme
+		long[] ci = (long[]) c.getClientProperty( KEY_CARET_INFO );
+		if( ci != null ) {
+			c.putClientProperty( KEY_CARET_INFO, null );
 
-		// the dot and mark are lost when switching LaF
-		// --> move dot to end of text so that all text may be selected when it gains focus
-		Document doc = c.getDocument();
-		if( doc != null && getDot() == 0 && getMark() == 0 ) {
-			int length = doc.getLength();
-			if( length > 0 )
-				setDot( length );
+			// if caret info is too old assume that switched from FlatLaf
+			// to another Laf and back to FlatLaf
+			if( System.currentTimeMillis() - 500 > ci[3] )
+				ci = null;
+		}
+		if( ci != null ) {
+			// when switching theme, it is necessary to set blink rate before
+			// invoking super.install() otherwise the caret does not blink
+			setBlinkRate( (int) ci[2] );
+		}
+
+		inInstall = true;
+		try {
+			super.install( c );
+		} finally {
+			inInstall = false;
+		}
+
+		if( ci != null ) {
+			// 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
+			// 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 );
+					}
+				} );
+			}
 		}
 	}
 
+	@Override
+	public void deinstall( JTextComponent c ) {
+		// remember dot and mark (the selection) when switching theme
+		c.putClientProperty( KEY_CARET_INFO, new long[] {
+			getDot(),
+			getMark(),
+			getBlinkRate(),
+			System.currentTimeMillis(),
+			wasFocused ? 1 : 0,
+		} );
+
+		super.deinstall( c );
+	}
+
+	@Override
+	protected void adjustVisibility( Rectangle nloc ) {
+		JTextComponent c = getComponent();
+		if( c != null && c.getUI() instanceof FlatTextFieldUI ) {
+			// need to fix x location because JTextField.scrollRectToVisible() uses insets.left
+			// (as BasicTextUI.getVisibleEditorRect() does),
+			// but FlatTextFieldUI.getVisibleEditorRect() may add some padding
+			Rectangle r = ((FlatTextFieldUI)c.getUI()).getVisibleEditorRect();
+			if( r != null )
+				nloc.x -= r.x - c.getInsets().left;
+		}
+		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( !wasTemporaryLost && (!isMousePressed || selectAllOnMouseClick) )
+		if( !inInstall && !wasFocusTemporaryLost && (!isMousePressed || isSelectAllOnMouseClick()) )
 			selectAllOnFocusGained();
-		wasTemporaryLost = false;
+
+		wasFocusTemporaryLost = false;
 		wasFocused = true;
 
 		super.focusGained( e );
@@ -73,7 +188,7 @@ public class FlatCaret
 
 	@Override
 	public void focusLost( FocusEvent e ) {
-		wasTemporaryLost = e.isTemporary();
+		wasFocusTemporaryLost = e.isTemporary();
 		super.focusLost( e );
 	}
 
@@ -81,50 +196,161 @@ public class FlatCaret
 	public void mousePressed( MouseEvent e ) {
 		isMousePressed = true;
 		super.mousePressed( e );
+
+		JTextComponent c = getComponent();
+
+		// left double-click starts word selection
+		isWordSelection = e.getClickCount() == 2 && SwingUtilities.isLeftMouseButton( e ) && !e.isConsumed();
+
+		// left triple-click starts line selection
+		isLineSelection = e.getClickCount() == 3 && SwingUtilities.isLeftMouseButton( e ) && (!e.isConsumed() || c.getDragEnabled());
+
+		// select line
+		// (this is also done in DefaultCaret.mouseClicked(), but this event is
+		// sent when the mouse is released, which is too late for triple-click-and-drag)
+		if( isLineSelection ) {
+			ActionMap actionMap = c.getActionMap();
+			Action selectLineAction = (actionMap != null)
+				? actionMap.get( DefaultEditorKit.selectLineAction )
+				: null;
+			if( selectLineAction != null ) {
+				selectLineAction.actionPerformed( new ActionEvent( c,
+					ActionEvent.ACTION_PERFORMED, null, e.getWhen(), e.getModifiers() ) );
+			}
+		}
+
+		// remember selection where word/line selection starts to keep it always selected while dragging
+		if( isWordSelection || isLineSelection ) {
+			int mark = getMark();
+			int dot = getDot();
+			dragSelectionStart = Math.min( dot, mark );
+			dragSelectionEnd = Math.max( dot, mark );
+		}
 	}
 
 	@Override
 	public void mouseReleased( MouseEvent e ) {
 		isMousePressed = false;
+		isWordSelection = false;
+		isLineSelection = false;
 		super.mouseReleased( e );
 	}
 
+	@Override
+	public void mouseDragged( MouseEvent e ) {
+		if( (isWordSelection || isLineSelection) &&
+			!e.isConsumed() && SwingUtilities.isLeftMouseButton( e ) )
+		{
+			// fix Swing's double/triple-click-and-drag behavior so that dragging after
+			// a double/triple-click extends selection by whole words/lines
+			JTextComponent c = getComponent();
+			int pos = c.viewToModel( e.getPoint() );
+			if( pos < 0 )
+				return;
+
+			try {
+				if( pos > dragSelectionEnd )
+					select( dragSelectionStart, isWordSelection ? Utilities.getWordEnd( c, pos ) : Utilities.getRowEnd( c, pos ) );
+				else if( pos < dragSelectionStart )
+					select( dragSelectionEnd, isWordSelection ? Utilities.getWordStart( c, pos ) : Utilities.getRowStart( c, pos ) );
+				else
+					select( dragSelectionStart, dragSelectionEnd );
+			} catch( BadLocationException ex ) {
+				UIManager.getLookAndFeel().provideErrorFeedback( c );
+			}
+		} else
+			super.mouseDragged( e );
+	}
+
 	protected void selectAllOnFocusGained() {
 		JTextComponent c = getComponent();
 		Document doc = c.getDocument();
-		if( doc == null || !c.isEnabled() || !c.isEditable() )
+		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( () -> {
-				setDot( 0 );
-				moveDot( 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 {
-			setDot( 0 );
-			moveDot( doc.getLength() );
+		} else
+			select( 0, doc.getLength() );
+	}
+
+	private void select( int mark, int dot ) {
+		if( mark != getMark() )
+			setDot( mark, Position.Bias.Forward );
+		if( dot != getDot() )
+			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 */
+	public void scrollCaretToVisible() {
+		JTextComponent c = getComponent();
+		if( c == null || c.getUI() == null )
+			return;
+
+		try {
+			Rectangle loc = c.getUI().modelToView( c, getDot(), getDotBias() );
+			if( loc != null ) {
+				adjustVisibility( loc );
+				damage( loc );
+			}
+		} catch( BadLocationException ex ) {
+			// ignore
 		}
 	}
 }

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

@@ -18,11 +18,20 @@ package com.formdev.flatlaf.ui;
 
 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.util.LoggingFacade;
 
 /**
  * Provides the Flat LaF UI delegate for {@link javax.swing.JCheckBoxMenuItem}.
@@ -52,15 +61,30 @@ import javax.swing.plaf.basic.BasicCheckBoxMenuItemUI;
  *
  * @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, StyleableLookupProvider
 {
 	private FlatMenuItemRenderer renderer;
+	private Map<String, Object> oldStyleValues;
 
 	public static ComponentUI createUI( JComponent c ) {
 		return new FlatCheckBoxMenuItemUI();
 	}
 
+	@Override
+	public void installUI( JComponent c ) {
+		super.installUI( c );
+
+		installStyle();
+	}
+
 	@Override
 	protected void installDefaults() {
 		super.installDefaults();
@@ -74,13 +98,69 @@ 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 FlatHTML.createPropertyChangeListener(
+			FlatStylingSupport.createPropertyChangeListener( c, this::installStyle,
+				super.createPropertyChangeListener( c ) ) );
+	}
+
+	/** @since 2 */
+	protected void installStyle() {
+		try {
+			applyStyle( FlatStylingSupport.getResolvedStyle( menuItem, "CheckBoxMenuItem" ) );
+		} catch( RuntimeException ex ) {
+			LoggingFacade.INSTANCE.logSevere( null, ex );
+		}
+	}
+
+	/** @since 2 */
+	protected void applyStyle( Object style ) {
+		oldStyleValues = FlatStylingSupport.parseAndApply( oldStyleValues, style, this::applyStyleProperty );
+	}
+
+	/** @since 2 */
+	protected Object applyStyleProperty( String key, Object value ) {
+		return FlatMenuItemUI.applyStyleProperty( menuItem, this, renderer, key, value );
+	}
+
+	/** @since 2 */
+	@Override
+	public Map<String, Class<?>> getStyleableInfos( JComponent c ) {
+		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
 	protected Dimension getPreferredMenuItemSize( JComponent c, Icon checkIcon, Icon arrowIcon, int defaultTextIconGap ) {
 		return renderer.getPreferredMenuItemSize();

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

@@ -43,11 +43,24 @@ public class FlatCheckBoxUI
 	extends FlatRadioButtonUI
 {
 	public static ComponentUI createUI( JComponent c ) {
-		return FlatUIUtils.createSharedUI( FlatCheckBoxUI.class, FlatCheckBoxUI::new );
+		return FlatUIUtils.canUseSharedUI( c ) && !FlatUIUtils.needsLightAWTPeer( c )
+			? FlatUIUtils.createSharedUI( FlatCheckBoxUI.class, () -> new FlatCheckBoxUI( true ) )
+			: new FlatCheckBoxUI( false );
+	}
+
+	/** @since 2 */
+	protected FlatCheckBoxUI( boolean shared ) {
+		super( shared );
 	}
 
 	@Override
 	public String getPropertyPrefix() {
 		return "CheckBox.";
 	}
+
+	/** @since 2 */
+	@Override
+	String getStyleType() {
+		return "CheckBox";
+	}
 }

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

@@ -16,10 +16,12 @@
 
 package com.formdev.flatlaf.ui;
 
+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.Image;
 import java.awt.Insets;
@@ -28,11 +30,13 @@ import java.awt.Point;
 import java.awt.event.ActionListener;
 import java.awt.event.MouseEvent;
 import java.awt.image.BufferedImage;
+import java.beans.PropertyChangeListener;
 import java.beans.PropertyVetoException;
 import javax.swing.BorderFactory;
 import javax.swing.ImageIcon;
 import javax.swing.JButton;
 import javax.swing.JComponent;
+import javax.swing.JDesktopPane;
 import javax.swing.event.MouseInputAdapter;
 import javax.swing.event.MouseInputListener;
 import javax.swing.JLabel;
@@ -45,6 +49,7 @@ import javax.swing.SwingUtilities;
 import javax.swing.UIManager;
 import javax.swing.plaf.ComponentUI;
 import javax.swing.plaf.basic.BasicDesktopIconUI;
+import com.formdev.flatlaf.util.MultiResolutionImageSupport;
 import com.formdev.flatlaf.util.UIScale;
 
 /**
@@ -75,11 +80,21 @@ public class FlatDesktopIconUI
 	private JToolTip titleTip;
 	private ActionListener closeListener;
 	private MouseInputListener mouseInputListener;
+	private PropertyChangeListener ancestorListener;
 
 	public static ComponentUI createUI( JComponent c ) {
 		return new FlatDesktopIconUI();
 	}
 
+	@Override
+	public void installUI( JComponent c ) {
+		super.installUI( c );
+
+		// update dock icon preview if already iconified
+		if( c.isDisplayable() )
+			updateDockIconPreviewLater();
+	}
+
 	@Override
 	public void uninstallUI( JComponent c ) {
 		super.uninstallUI( c );
@@ -136,6 +151,17 @@ public class FlatDesktopIconUI
 		};
 		closeButton.addActionListener( closeListener );
 		closeButton.addMouseListener( mouseInputListener );
+
+		ancestorListener = e -> {
+			if( e.getNewValue() != null ) {
+				// update dock icon preview if desktopIcon is added to desktop (internal frame was iconified)
+				updateDockIconPreviewLater();
+			} else {
+				// remove preview icon to release memory
+				dockIcon.setIcon( null );
+			}
+		};
+		desktopIcon.addPropertyChangeListener( "ancestor", ancestorListener );
 	}
 
 	@Override
@@ -146,6 +172,9 @@ public class FlatDesktopIconUI
 		closeButton.removeMouseListener( mouseInputListener );
 		closeListener = null;
 		mouseInputListener = null;
+
+		desktopIcon.removePropertyChangeListener( "ancestor", ancestorListener );
+		ancestorListener = null;
 	}
 
 	@Override
@@ -228,15 +257,30 @@ public class FlatDesktopIconUI
 		return getPreferredSize( c );
 	}
 
-	void updateDockIcon() {
+	@Override
+	public void update( Graphics g, JComponent c ) {
+		if( c.isOpaque() ) {
+			// fill background with color derived from desktop pane
+			Color background = c.getBackground();
+			JDesktopPane desktopPane = desktopIcon.getDesktopPane();
+			g.setColor( (desktopPane != null)
+				? FlatUIUtils.deriveColor( background, desktopPane.getBackground() )
+				: background );
+			g.fillRect( 0, 0, c.getWidth(), c.getHeight() );
+		}
+
+		paint( g, c );
+	}
+
+	private void updateDockIconPreviewLater() {
 		// use invoke later to make sure that components are updated when switching LaF
 		EventQueue.invokeLater( () -> {
 			if( dockIcon != null )
-				updateDockIconLater();
+				updateDockIconPreview();
 		} );
 	}
 
-	private void updateDockIconLater() {
+	protected void updateDockIconPreview() {
 		// make sure that frame is not selected
 		if( frame.isSelected() ) {
 			try {
@@ -246,13 +290,22 @@ public class FlatDesktopIconUI
 			}
 		}
 
+		// layout internal frame title pane, which was recreated when switching Laf
+		// (directly invoke doLayout() because frame.validate() does not work here
+		// because frame is not displayable)
+		if( !frame.isValid() )
+			frame.doLayout();
+		for( Component c : frame.getComponents() ) {
+			if( !c.isValid() )
+				c.doLayout();
+		}
+
 		// paint internal frame to buffered image
 		int frameWidth = Math.max( frame.getWidth(), 1 );
 		int frameHeight = Math.max( frame.getHeight(), 1 );
 		BufferedImage frameImage = new BufferedImage( frameWidth, frameHeight, BufferedImage.TYPE_INT_ARGB );
 		Graphics2D g = frameImage.createGraphics();
 		try {
-			//TODO fix missing internal frame header when switching LaF
 			frame.paint( g );
 		} finally {
 			g.dispose();
@@ -270,6 +323,27 @@ public class FlatDesktopIconUI
 
 		// scale preview
 		Image previewImage = frameImage.getScaledInstance( previewWidth, previewHeight, Image.SCALE_SMOOTH );
+		if( MultiResolutionImageSupport.isAvailable() ) {
+			// On HiDPI screens, create preview images for 1x, 2x and current scale factor.
+			// The icon then chooses the best resolution for painting, which is usually
+			// the one for the current scale factor. But if changing scale factor or
+			// moving window to another screen with different scale factor, then another
+			// resolution may be used because the preview icon is not updated.
+			Image previewImage2x = frameImage.getScaledInstance( previewWidth * 2, previewHeight * 2, Image.SCALE_SMOOTH );
+			double scaleFactor = UIScale.getSystemScaleFactor( desktopIcon.getGraphicsConfiguration() );
+			if( scaleFactor != 1 && scaleFactor != 2 ) {
+				Image previewImageCurrent = frameImage.getScaledInstance(
+					(int) Math.round( previewWidth * scaleFactor ),
+					(int) Math.round( previewHeight * scaleFactor ),
+					Image.SCALE_SMOOTH );
+
+				// the images must be ordered by resolution
+				previewImage = (scaleFactor < 2)
+					? MultiResolutionImageSupport.create( 0, previewImage, previewImageCurrent, previewImage2x )
+					: MultiResolutionImageSupport.create( 0, previewImage, previewImage2x, previewImageCurrent );
+			} else
+				previewImage = MultiResolutionImageSupport.create( 0, previewImage, previewImage2x );
+		}
 		dockIcon.setIcon( new ImageIcon( previewImage ) );
 	}
 

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

@@ -16,11 +16,16 @@
 
 package com.formdev.flatlaf.ui;
 
-import javax.swing.DefaultDesktopManager;
+import java.awt.Component;
+import java.awt.Dimension;
+import java.awt.EventQueue;
+import java.awt.event.ComponentAdapter;
+import java.awt.event.ComponentEvent;
+import java.awt.event.ContainerEvent;
+import java.awt.event.ContainerListener;
 import javax.swing.JComponent;
-import javax.swing.JInternalFrame;
+import javax.swing.JInternalFrame.JDesktopIcon;
 import javax.swing.plaf.ComponentUI;
-import javax.swing.plaf.UIResource;
 import javax.swing.plaf.basic.BasicDesktopPaneUI;
 
 /**
@@ -36,30 +41,96 @@ import javax.swing.plaf.basic.BasicDesktopPaneUI;
 public class FlatDesktopPaneUI
 	extends BasicDesktopPaneUI
 {
+	private LayoutDockListener layoutDockListener;
+	private boolean layoutDockPending;
+
 	public static ComponentUI createUI( JComponent c ) {
 		return new FlatDesktopPaneUI();
 	}
 
 	@Override
-	protected void installDesktopManager() {
-		desktopManager = desktop.getDesktopManager();
-		if( desktopManager == null ) {
-			desktopManager = new FlatDesktopManager();
-			desktop.setDesktopManager( desktopManager );
+	public void installUI( JComponent c ) {
+		super.installUI( c );
+
+		layoutDockLaterOnce();
+	}
+
+	@Override
+	protected void installListeners() {
+		super.installListeners();
+
+		layoutDockListener = new LayoutDockListener();
+		desktop.addContainerListener( layoutDockListener );
+		desktop.addComponentListener( layoutDockListener );
+	}
+
+	@Override
+	protected void uninstallListeners() {
+		super.uninstallListeners();
+
+		desktop.removeContainerListener( layoutDockListener );
+		desktop.removeComponentListener( layoutDockListener );
+		layoutDockListener = null;
+	}
+
+	private void layoutDockLaterOnce() {
+		if( layoutDockPending )
+			return;
+		layoutDockPending = true;
+
+		EventQueue.invokeLater( () -> {
+			layoutDockPending = false;
+			if( desktop != null )
+				layoutDock();
+		} );
+	}
+
+	protected void layoutDock() {
+		Dimension desktopSize = desktop.getSize();
+		int x = 0;
+		int y = desktopSize.height;
+		int rowHeight = 0;
+
+		for( Component c : desktop.getComponents() ) {
+			if( !(c instanceof JDesktopIcon) )
+				continue;
+
+			JDesktopIcon icon = (JDesktopIcon) c;
+			Dimension iconSize = icon.getPreferredSize();
+
+			if( x + iconSize.width > desktopSize.width ) {
+				// new row
+				x = 0;
+				y -= rowHeight;
+				rowHeight = 0;
+			}
+
+			icon.setLocation( x, y - iconSize.height );
+
+			x += iconSize.width;
+			rowHeight = Math.max( iconSize.height, rowHeight );
 		}
 	}
 
-	//---- class FlatDesktopManager -------------------------------------------
+	//---- class LayoutDockListener -------------------------------------------
 
-	private class FlatDesktopManager
-		extends DefaultDesktopManager
-		implements UIResource
+	private class LayoutDockListener
+		extends ComponentAdapter
+		implements ContainerListener
 	{
 		@Override
-		public void iconifyFrame( JInternalFrame f ) {
-			super.iconifyFrame( f );
+		public void componentAdded( ContainerEvent e ) {
+			layoutDockLaterOnce();
+		}
 
-			((FlatDesktopIconUI)f.getDesktopIcon().getUI()).updateDockIcon();
+		@Override
+		public void componentRemoved( ContainerEvent e ) {
+			layoutDockLaterOnce();
+		}
+
+		@Override
+		public void componentResized( ComponentEvent e ) {
+			layoutDockLaterOnce();
 		}
 	}
 }

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

@@ -24,6 +24,9 @@ import java.awt.Image;
 import java.awt.Insets;
 import java.awt.RadialGradientPaint;
 import java.awt.image.BufferedImage;
+import java.util.Map;
+import com.formdev.flatlaf.ui.FlatStylingSupport.Styleable;
+import com.formdev.flatlaf.ui.FlatStylingSupport.StyleableBorder;
 import com.formdev.flatlaf.util.HiDPIUtils;
 import com.formdev.flatlaf.util.UIScale;
 
@@ -40,14 +43,17 @@ import com.formdev.flatlaf.util.UIScale;
  */
 public class FlatDropShadowBorder
 	extends FlatEmptyBorder
+	implements StyleableBorder
 {
-	private final Color shadowColor;
-	private final Insets shadowInsets;
-	private final float shadowOpacity;
+	@Styleable protected Color shadowColor;
+	@Styleable protected Insets shadowInsets;
+	@Styleable protected float shadowOpacity;
 
-	private final int shadowSize;
+	private int shadowSize;
 	private Image shadowImage;
 	private Color lastShadowColor;
+	private float lastShadowOpacity;
+	private int lastShadowSize;
 	private double lastSystemScaleFactor;
 	private float lastUserScaleFactor;
 
@@ -64,17 +70,49 @@ public class FlatDropShadowBorder
 	}
 
 	public FlatDropShadowBorder( Color shadowColor, Insets shadowInsets, float shadowOpacity ) {
-		super( Math.max( shadowInsets.top, 0 ), Math.max( shadowInsets.left, 0 ),
-			Math.max( shadowInsets.bottom, 0 ), Math.max( shadowInsets.right, 0 ) );
+		super( nonNegativeInsets( shadowInsets ) );
+
 		this.shadowColor = shadowColor;
 		this.shadowInsets = shadowInsets;
-		this.shadowOpacity = shadowOpacity;
+		this.shadowOpacity = Math.min( Math.max( shadowOpacity, 0f ), 1f );
 
-		shadowSize = Math.max(
+		shadowSize = maxInset( shadowInsets );
+	}
+
+	private static Insets nonNegativeInsets( Insets shadowInsets ) {
+		return new Insets( Math.max( shadowInsets.top, 0 ), Math.max( shadowInsets.left, 0 ),
+			Math.max( shadowInsets.bottom, 0 ), Math.max( shadowInsets.right, 0 ) );
+	}
+
+	private int maxInset( Insets shadowInsets ) {
+		return Math.max(
 			Math.max( shadowInsets.left, shadowInsets.right ),
 			Math.max( shadowInsets.top, shadowInsets.bottom ) );
 	}
 
+	/** @since 2 */
+	@Override
+	public Object applyStyleProperty( String key, Object value ) {
+		Object oldValue = FlatStylingSupport.applyToAnnotatedObject( this, key, value );
+		if( key.equals( "shadowInsets" ) ) {
+			applyStyleProperty( nonNegativeInsets( shadowInsets ) );
+			shadowSize = maxInset( shadowInsets );
+		}
+		return oldValue;
+	}
+
+	/** @since 2 */
+	@Override
+	public Map<String, Class<?>> getStyleableInfos() {
+		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 )
@@ -91,12 +129,16 @@ public class FlatDropShadowBorder
 		float userScaleFactor = UIScale.getUserScaleFactor();
 		if( shadowImage == null ||
 			!shadowColor.equals( lastShadowColor ) ||
+			lastShadowOpacity != shadowOpacity ||
+			lastShadowSize != shadowSize ||
 			lastSystemScaleFactor != scaleFactor ||
 			lastUserScaleFactor != userScaleFactor )
 		{
 			shadowImage = createShadowImage( shadowColor, shadowSize, shadowOpacity,
 				(float) (scaleFactor * userScaleFactor) );
 			lastShadowColor = shadowColor;
+			lastShadowOpacity = shadowOpacity;
+			lastShadowSize = shadowSize;
 			lastSystemScaleFactor = scaleFactor;
 			lastUserScaleFactor = userScaleFactor;
 		}

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

@@ -17,19 +17,26 @@
 package com.formdev.flatlaf.ui;
 
 import static com.formdev.flatlaf.util.UIScale.scale;
+import java.awt.Color;
 import java.awt.Dimension;
 import java.awt.Graphics;
 import java.awt.Graphics2D;
+import java.awt.Insets;
+import java.awt.event.FocusListener;
 import java.beans.PropertyChangeEvent;
+import java.util.Map;
 import javax.swing.JComponent;
 import javax.swing.JEditorPane;
 import javax.swing.UIManager;
 import javax.swing.plaf.ComponentUI;
-import javax.swing.plaf.UIResource;
 import javax.swing.plaf.basic.BasicEditorPaneUI;
+import javax.swing.text.Caret;
 import javax.swing.text.JTextComponent;
 import com.formdev.flatlaf.FlatClientProperties;
+import com.formdev.flatlaf.ui.FlatStylingSupport.Styleable;
+import com.formdev.flatlaf.ui.FlatStylingSupport.StyleableUI;
 import com.formdev.flatlaf.util.HiDPIUtils;
+import com.formdev.flatlaf.util.LoggingFacade;
 
 /**
  * Provides the Flat LaF UI delegate for {@link javax.swing.JEditorPane}.
@@ -37,8 +44,8 @@ import com.formdev.flatlaf.util.HiDPIUtils;
  * <!-- 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
@@ -52,28 +59,52 @@ import com.formdev.flatlaf.util.HiDPIUtils;
  * <!-- FlatEditorPaneUI -->
  *
  * @uiDefault Component.minimumWidth			int
- * @uiDefault Component.isIntelliJTheme			boolean
+ * @uiDefault EditorPane.focusedBackground		Color	optional
  *
  * @author Karl Tauber
  */
 public class FlatEditorPaneUI
 	extends BasicEditorPaneUI
+	implements StyleableUI
 {
-	protected int minimumWidth;
-	protected boolean isIntelliJTheme;
+	@Styleable protected int minimumWidth;
+	private Color background;
+	@Styleable protected Color disabledBackground;
+	@Styleable protected Color inactiveBackground;
+	@Styleable protected Color focusedBackground;
+
+	private Color oldDisabledBackground;
+	private Color oldInactiveBackground;
+
+	private Insets defaultMargin;
 
 	private Object oldHonorDisplayProperties;
+	private FocusListener focusListener;
+	private Map<String, Object> oldStyleValues;
 
 	public static ComponentUI createUI( JComponent c ) {
 		return new FlatEditorPaneUI();
 	}
 
+	@Override
+	public void installUI( JComponent c ) {
+		super.installUI( c );
+
+		installStyle();
+	}
+
 	@Override
 	protected void installDefaults() {
 		super.installDefaults();
 
+		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" );
+		focusedBackground = UIManager.getColor( prefix + ".focusedBackground" );
+
+		defaultMargin = UIManager.getInsets( prefix + ".margin" );
 
 		// use component font and foreground for HTML text
 		oldHonorDisplayProperties = getComponent().getClientProperty( JEditorPane.HONOR_DISPLAY_PROPERTIES );
@@ -84,34 +115,124 @@ public class FlatEditorPaneUI
 	protected void uninstallDefaults() {
 		super.uninstallDefaults();
 
+		background = null;
+		disabledBackground = null;
+		inactiveBackground = null;
+		focusedBackground = null;
+
+		oldDisabledBackground = null;
+		oldInactiveBackground = null;
+
+		oldStyleValues = null;
+
 		getComponent().putClientProperty( JEditorPane.HONOR_DISPLAY_PROPERTIES, oldHonorDisplayProperties );
 	}
 
 	@Override
-	protected void propertyChange( PropertyChangeEvent e ) {
-		super.propertyChange( e );
-		propertyChange( getComponent(), e );
+	protected void installListeners() {
+		super.installListeners();
+
+		// necessary to update focus background
+		focusListener = new FlatUIUtils.RepaintFocusListener( getComponent(), c -> focusedBackground != null );
+		getComponent().addFocusListener( focusListener );
 	}
 
-	static void propertyChange( JTextComponent c, PropertyChangeEvent e ) {
+	@Override
+	protected void uninstallListeners() {
+		super.uninstallListeners();
+
+		getComponent().removeFocusListener( focusListener );
+		focusListener = null;
+	}
+
+	@Override
+	protected Caret createCaret() {
+		return new FlatCaret( null, false );
+	}
+
+	@Override
+	protected void propertyChange( PropertyChangeEvent e ) {
+		// invoke updateBackground() before super.propertyChange()
+		String propertyName = e.getPropertyName();
+		if( "editable".equals( propertyName ) || "enabled".equals( propertyName ) )
+			updateBackground();
+
+		super.propertyChange( e );
+		propertyChange( getComponent(), e, this::installStyle );
+	}
+
+	static void propertyChange( JTextComponent c, PropertyChangeEvent e, Runnable installStyle ) {
 		switch( e.getPropertyName() ) {
 			case FlatClientProperties.MINIMUM_WIDTH:
 				c.revalidate();
 				break;
+
+			case FlatClientProperties.STYLE:
+			case FlatClientProperties.STYLE_CLASS:
+				installStyle.run();
+				c.revalidate();
+				HiDPIUtils.repaint( c );
+				break;
 		}
 	}
 
+	/** @since 2 */
+	protected void installStyle() {
+		try {
+			applyStyle( FlatStylingSupport.getResolvedStyle( getComponent(), "EditorPane" ) );
+		} catch( RuntimeException ex ) {
+			LoggingFacade.INSTANCE.logSevere( null, ex );
+		}
+	}
+
+	/** @since 2 */
+	protected void applyStyle( Object style ) {
+		oldDisabledBackground = disabledBackground;
+		oldInactiveBackground = inactiveBackground;
+
+		oldStyleValues = FlatStylingSupport.parseAndApply( oldStyleValues, style, this::applyStyleProperty );
+
+		updateBackground();
+	}
+
+	/** @since 2 */
+	protected Object applyStyleProperty( String key, Object value ) {
+		return FlatStylingSupport.applyToAnnotatedObjectOrComponent( this, getComponent(), key, value );
+	}
+
+	/** @since 2 */
+	@Override
+	public Map<String, Class<?>> getStyleableInfos( JComponent c ) {
+		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,
+			oldDisabledBackground, oldInactiveBackground );
+	}
+
 	@Override
 	public Dimension getPreferredSize( JComponent c ) {
-		return applyMinimumWidth( c, super.getPreferredSize( c ), minimumWidth );
+		return applyMinimumWidth( c, super.getPreferredSize( c ), minimumWidth, defaultMargin );
 	}
 
 	@Override
 	public Dimension getMinimumSize( JComponent c ) {
-		return applyMinimumWidth( c, super.getMinimumSize( c ), minimumWidth );
+		return applyMinimumWidth( c, super.getMinimumSize( c ), minimumWidth, defaultMargin );
 	}
 
-	static Dimension applyMinimumWidth( JComponent c, Dimension size, int minimumWidth ) {
+	static Dimension applyMinimumWidth( JComponent c, Dimension size, int minimumWidth, Insets defaultMargin ) {
+		// do not apply minimum width if JTextComponent.margin is set
+		if( !FlatTextFieldUI.hasDefaultMargins( c, defaultMargin ) )
+			return size;
+
 		// Assume that text area is in a scroll pane (that displays the border)
 		// and subtract 1px border line width.
 		// Using "(scale( 1 ) * 2)" instead of "scale( 2 )" to deal with rounding
@@ -128,14 +249,11 @@ public class FlatEditorPaneUI
 
 	@Override
 	protected void paintBackground( Graphics g ) {
-		JTextComponent c = getComponent();
+		paintBackground( g, getComponent(), focusedBackground );
+	}
 
-		// for compatibility with IntelliJ themes
-		if( isIntelliJTheme && (!c.isEnabled() || !c.isEditable()) && (c.getBackground() instanceof UIResource) ) {
-			FlatUIUtils.paintParentBackground( g, c );
-			return;
-		}
-
-		super.paintBackground( g );
+	static void paintBackground( Graphics g, JTextComponent c, Color focusedBackground ) {
+		g.setColor( FlatTextFieldUI.getBackground( c, focusedBackground ) );
+		g.fillRect( 0, 0, c.getWidth(), c.getHeight() );
 	}
 }