release 3.0

built by GitHub Actions:
https://github.com/JFormDesigner/FlatLaf/actions/runs/3554848392

.editorconfig

@@ -6,3 +6,231 @@ insert_final_newline = true
 charset = latin1
 indent_style = tab
 indent_size = 4
+
+[*.java]
+indent_style = tab
+ij_continuation_indent_size = 4
+ij_java_align_consecutive_assignments = false
+ij_java_align_consecutive_variable_declarations = false
+ij_java_align_group_field_declarations = false
+ij_java_align_multiline_annotation_parameters = false
+ij_java_align_multiline_array_initializer_expression = false
+ij_java_align_multiline_assignment = false
+ij_java_align_multiline_binary_operation = false
+ij_java_align_multiline_chained_methods = false
+ij_java_align_multiline_extends_list = false
+ij_java_align_multiline_for = true
+ij_java_align_multiline_method_parentheses = false
+ij_java_align_multiline_parameters = false
+ij_java_align_multiline_parameters_in_calls = false
+ij_java_align_multiline_parenthesized_expression = false
+ij_java_align_multiline_resources = false
+ij_java_align_multiline_ternary_operation = false
+ij_java_align_multiline_text_blocks = false
+ij_java_align_multiline_throws_list = false
+ij_java_align_subsequent_simple_methods = false
+ij_java_align_throws_keyword = false
+ij_java_annotation_parameter_wrap = off
+ij_java_array_initializer_new_line_after_left_brace = false
+ij_java_array_initializer_right_brace_on_new_line = false
+ij_java_array_initializer_wrap = normal
+ij_java_assert_statement_colon_on_next_line = false
+ij_java_assert_statement_wrap = off
+ij_java_assignment_wrap = off
+ij_java_binary_operation_sign_on_next_line = false
+ij_java_binary_operation_wrap = off
+ij_java_blank_lines_after_anonymous_class_header = 0
+ij_java_blank_lines_after_class_header = 0
+ij_java_blank_lines_after_imports = 1
+ij_java_blank_lines_after_package = 1
+ij_java_blank_lines_around_class = 1
+ij_java_blank_lines_around_field = 0
+ij_java_blank_lines_around_field_in_interface = 0
+ij_java_blank_lines_around_initializer = 1
+ij_java_blank_lines_around_method = 1
+ij_java_blank_lines_around_method_in_interface = 1
+ij_java_blank_lines_before_class_end = 0
+ij_java_blank_lines_before_imports = 1
+ij_java_blank_lines_before_method_body = 0
+ij_java_blank_lines_before_package = 0
+ij_java_block_brace_style = next_line_if_wrapped
+ij_java_block_comment_at_first_column = true
+ij_java_call_parameters_new_line_after_left_paren = false
+ij_java_call_parameters_right_paren_on_new_line = false
+ij_java_call_parameters_wrap = normal
+ij_java_case_statement_on_separate_line = true
+ij_java_catch_on_new_line = false
+ij_java_class_annotation_wrap = split_into_lines
+ij_java_class_brace_style = next_line
+ij_java_class_count_to_use_import_on_demand = 99
+ij_java_class_names_in_javadoc = 1
+ij_java_do_not_indent_top_level_class_members = false
+ij_java_do_not_wrap_after_single_annotation = false
+ij_java_do_while_brace_force = never
+ij_java_doc_add_blank_line_after_description = true
+ij_java_doc_add_blank_line_after_param_comments = false
+ij_java_doc_add_blank_line_after_return = false
+ij_java_doc_add_p_tag_on_empty_lines = true
+ij_java_doc_align_exception_comments = true
+ij_java_doc_align_param_comments = true
+ij_java_doc_do_not_wrap_if_one_line = false
+ij_java_doc_enable_formatting = true
+ij_java_doc_enable_leading_asterisks = true
+ij_java_doc_indent_on_continuation = false
+ij_java_doc_keep_empty_lines = true
+ij_java_doc_keep_empty_parameter_tag = true
+ij_java_doc_keep_empty_return_tag = true
+ij_java_doc_keep_empty_throws_tag = true
+ij_java_doc_keep_invalid_tags = true
+ij_java_doc_param_description_on_new_line = false
+ij_java_doc_preserve_line_breaks = false
+ij_java_doc_use_throws_not_exception_tag = true
+ij_java_else_on_new_line = false
+ij_java_enum_constants_wrap = off
+ij_java_extends_keyword_wrap = split_into_lines
+ij_java_extends_list_wrap = normal
+ij_java_field_annotation_wrap = split_into_lines
+ij_java_finally_on_new_line = false
+ij_java_for_brace_force = never
+ij_java_for_statement_new_line_after_left_paren = false
+ij_java_for_statement_right_paren_on_new_line = false
+ij_java_for_statement_wrap = off
+ij_java_generate_final_locals = false
+ij_java_generate_final_parameters = false
+ij_java_if_brace_force = never
+ij_java_imports_layout = java.**,javax.**,*,$*
+ij_java_indent_case_from_switch = true
+ij_java_insert_inner_class_imports = false
+ij_java_insert_override_annotation = true
+ij_java_keep_blank_lines_before_right_brace = 1
+ij_java_keep_blank_lines_between_package_declaration_and_header = 1
+ij_java_keep_blank_lines_in_code = 1
+ij_java_keep_blank_lines_in_declarations = 1
+ij_java_keep_control_statement_in_one_line = false
+ij_java_keep_first_column_comment = false
+ij_java_keep_indents_on_empty_lines = false
+ij_java_keep_line_breaks = false
+ij_java_keep_multiple_expressions_in_one_line = false
+ij_java_keep_simple_blocks_in_one_line = false
+ij_java_keep_simple_classes_in_one_line = false
+ij_java_keep_simple_lambdas_in_one_line = false
+ij_java_keep_simple_methods_in_one_line = false
+ij_java_label_indent_absolute = false
+ij_java_label_indent_size = 0
+ij_java_lambda_brace_style = end_of_line
+ij_java_layout_static_imports_separately = true
+ij_java_line_comment_add_space = false
+ij_java_line_comment_at_first_column = true
+ij_java_method_annotation_wrap = split_into_lines
+ij_java_method_brace_style = next_line_if_wrapped
+ij_java_method_call_chain_wrap = normal
+ij_java_method_parameters_new_line_after_left_paren = false
+ij_java_method_parameters_right_paren_on_new_line = false
+ij_java_method_parameters_wrap = normal
+ij_java_modifier_list_wrap = false
+ij_java_names_count_to_use_import_on_demand = 3
+ij_java_parameter_annotation_wrap = off
+ij_java_parentheses_expression_new_line_after_left_paren = false
+ij_java_parentheses_expression_right_paren_on_new_line = false
+ij_java_place_assignment_sign_on_next_line = false
+ij_java_prefer_longer_names = true
+ij_java_prefer_parameters_wrap = false
+ij_java_repeat_synchronized = true
+ij_java_replace_instanceof_and_cast = false
+ij_java_replace_null_check = true
+ij_java_replace_sum_lambda_with_method_ref = true
+ij_java_resource_list_new_line_after_left_paren = false
+ij_java_resource_list_right_paren_on_new_line = false
+ij_java_resource_list_wrap = normal
+ij_java_space_after_closing_angle_bracket_in_type_argument = false
+ij_java_space_after_colon = true
+ij_java_space_after_comma = true
+ij_java_space_after_comma_in_type_arguments = true
+ij_java_space_after_for_semicolon = true
+ij_java_space_after_quest = true
+ij_java_space_after_type_cast = true
+ij_java_space_before_annotation_array_initializer_left_brace = true
+ij_java_space_before_annotation_parameter_list = false
+ij_java_space_before_array_initializer_left_brace = true
+ij_java_space_before_catch_keyword = true
+ij_java_space_before_catch_left_brace = true
+ij_java_space_before_catch_parentheses = false
+ij_java_space_before_class_left_brace = true
+ij_java_space_before_colon = true
+ij_java_space_before_colon_in_foreach = true
+ij_java_space_before_comma = false
+ij_java_space_before_do_left_brace = true
+ij_java_space_before_else_keyword = true
+ij_java_space_before_else_left_brace = true
+ij_java_space_before_finally_keyword = true
+ij_java_space_before_finally_left_brace = true
+ij_java_space_before_for_left_brace = true
+ij_java_space_before_for_parentheses = false
+ij_java_space_before_for_semicolon = false
+ij_java_space_before_if_left_brace = true
+ij_java_space_before_if_parentheses = false
+ij_java_space_before_method_call_parentheses = false
+ij_java_space_before_method_left_brace = true
+ij_java_space_before_method_parentheses = false
+ij_java_space_before_opening_angle_bracket_in_type_parameter = false
+ij_java_space_before_quest = true
+ij_java_space_before_switch_left_brace = true
+ij_java_space_before_switch_parentheses = false
+ij_java_space_before_synchronized_left_brace = true
+ij_java_space_before_synchronized_parentheses = false
+ij_java_space_before_try_left_brace = true
+ij_java_space_before_try_parentheses = false
+ij_java_space_before_type_parameter_list = false
+ij_java_space_before_while_keyword = true
+ij_java_space_before_while_left_brace = true
+ij_java_space_before_while_parentheses = false
+ij_java_space_inside_one_line_enum_braces = false
+ij_java_space_within_empty_array_initializer_braces = false
+ij_java_space_within_empty_method_call_parentheses = false
+ij_java_space_within_empty_method_parentheses = false
+ij_java_spaces_around_additive_operators = true
+ij_java_spaces_around_assignment_operators = true
+ij_java_spaces_around_bitwise_operators = true
+ij_java_spaces_around_equality_operators = true
+ij_java_spaces_around_lambda_arrow = true
+ij_java_spaces_around_logical_operators = true
+ij_java_spaces_around_method_ref_dbl_colon = false
+ij_java_spaces_around_multiplicative_operators = true
+ij_java_spaces_around_relational_operators = true
+ij_java_spaces_around_shift_operators = true
+ij_java_spaces_around_type_bounds_in_type_parameters = true
+ij_java_spaces_around_unary_operator = false
+ij_java_spaces_within_angle_brackets = false
+ij_java_spaces_within_annotation_parentheses = true
+ij_java_spaces_within_array_initializer_braces = true
+ij_java_spaces_within_braces = false
+ij_java_spaces_within_brackets = false
+ij_java_spaces_within_cast_parentheses = false
+ij_java_spaces_within_catch_parentheses = true
+ij_java_spaces_within_for_parentheses = true
+ij_java_spaces_within_if_parentheses = true
+ij_java_spaces_within_method_call_parentheses = true
+ij_java_spaces_within_method_parentheses = true
+ij_java_spaces_within_parentheses = false
+ij_java_spaces_within_switch_parentheses = true
+ij_java_spaces_within_synchronized_parentheses = true
+ij_java_spaces_within_try_parentheses = true
+ij_java_spaces_within_while_parentheses = true
+ij_java_special_else_if_treatment = true
+ij_java_subclass_name_suffix = Impl
+ij_java_ternary_operation_signs_on_next_line = true
+ij_java_ternary_operation_wrap = on_every_item
+ij_java_test_name_suffix = Test
+ij_java_throws_keyword_wrap = normal
+ij_java_throws_list_wrap = normal
+ij_java_use_external_annotations = false
+ij_java_use_fq_class_names = false
+ij_java_use_relative_indents = false
+ij_java_use_single_class_imports = true
+ij_java_variable_annotation_wrap = off
+ij_java_visibility = public
+ij_java_while_brace_force = never
+ij_java_while_on_new_line = false
+ij_java_wrap_comments = false
+ij_java_wrap_first_method_in_call_chain = false
+ij_java_wrap_long_lines = false

.gitattributes

@@ -15,8 +15,14 @@
 # BINARY FILES:
 #   Disable line ending normalize on checkin.
 
+*.dll binary
+*.dylib binary
 *.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/workflows/ci.yml

@@ -0,0 +1,142 @@
+# 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
+
+on:
+  push:
+    branches:
+      - '*'
+    tags:
+      - '[0-9]*'
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        # test against
+        # - Java 8 (minimum requirement)
+        # - Java LTS versions (11, 17, ...)
+        # - lastest Java version(s)
+        java:
+          - 8
+          - 11  # LTS
+          - 17  # LTS
+        toolchain: [""]
+        include:
+          - java: 17
+            toolchain: 19  # latest
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - uses: gradle/wrapper-validation-action@v1
+        if: matrix.java == '8'
+
+      - name: Setup Java ${{ matrix.java }}
+        uses: actions/setup-java@v3
+        with:
+          java-version: ${{ matrix.java }}
+          distribution: adopt  # Java 8 and 11 are pre-installed on ubuntu-latest
+          cache: gradle
+
+      - name: Build with Gradle
+        run: ./gradlew build -Dtoolchain=${{ matrix.toolchain }}
+
+      - name: Upload artifacts
+        uses: actions/upload-artifact@v3
+        if: matrix.java == '11'
+        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' || startsWith( github.ref, 'refs/heads/develop-' )) &&
+      github.repository == 'JFormDesigner/FlatLaf'
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Setup Java 11
+        uses: actions/setup-java@v3
+        with:
+          java-version: 11
+          distribution: adopt  # pre-installed on ubuntu-latest
+          cache: gradle
+
+      - name: Publish snapshot to oss.sonatype.org
+        run: ./gradlew publish :flatlaf-theme-editor:build -PskipFonts -Dorg.gradle.internal.publish.checksums.insecure=true
+        env:
+          OSSRH_USERNAME: ${{ secrets.OSSRH_USERNAME }}
+          OSSRH_PASSWORD: ${{ secrets.OSSRH_PASSWORD }}
+
+      - name: Upload theme editor
+        uses: sebastianpopp/ftp-action@releases/v2
+        with:
+          host: ${{ secrets.FTP_SERVER }}
+          user: ${{ secrets.FTP_USERNAME }}
+          password: ${{ secrets.FTP_PASSWORD }}
+          forceSsl: true
+          localDir: "flatlaf-theme-editor/build/libs"
+          remoteDir: "snapshots"
+          options: "--only-newer --no-recursion --verbose=1"
+
+
+  release:
+    runs-on: ubuntu-latest
+    needs: build
+    if: |
+      github.event_name == 'push' &&
+      startsWith( github.ref, 'refs/tags/' ) &&
+      github.repository == 'JFormDesigner/FlatLaf'
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Setup Java 11
+        uses: actions/setup-java@v3
+        with:
+          java-version: 11
+          distribution: adopt  # pre-installed on ubuntu-latest
+          cache: gradle
+
+      - name: Release a new stable version to Maven Central
+        run: ./gradlew publish :flatlaf-demo:build :flatlaf-theme-editor:build -PskipFonts -Prelease
+        env:
+          OSSRH_USERNAME: ${{ secrets.OSSRH_USERNAME }}
+          OSSRH_PASSWORD: ${{ secrets.OSSRH_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: Upload theme editor
+        uses: sebastianpopp/ftp-action@releases/v2
+        with:
+          host: ${{ secrets.FTP_SERVER }}
+          user: ${{ secrets.FTP_USERNAME }}
+          password: ${{ secrets.FTP_PASSWORD }}
+          forceSsl: true
+          localDir: "flatlaf-theme-editor/build/libs"
+          remoteDir: "."
+          options: "--only-newer --no-recursion --verbose=1"

.github/workflows/fonts.yml

@@ -0,0 +1,59 @@
+# 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'
+
+jobs:
+    Fonts:
+        strategy:
+            matrix:
+                font:
+                    - inter
+                    - jetbrains-mono
+                    - roboto
+
+        runs-on: ubuntu-latest
+        if: |
+            github.event_name == 'push' &&
+            github.repository == 'JFormDesigner/FlatLaf'
+
+        steps:
+            - uses: actions/checkout@v3
+
+            - name: Setup Java 11
+              uses: actions/setup-java@v3
+              with:
+                  java-version: 11
+                  distribution: adopt  # pre-installed on ubuntu-latest
+                  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 oss.sonatype.org
+              run: ./gradlew :flatlaf-fonts-${{ matrix.font }}:publish -Dorg.gradle.internal.publish.checksums.insecure=true
+              env:
+                  OSSRH_USERNAME: ${{ secrets.OSSRH_USERNAME }}
+                  OSSRH_PASSWORD: ${{ secrets.OSSRH_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:
+                  OSSRH_USERNAME: ${{ secrets.OSSRH_USERNAME }}
+                  OSSRH_PASSWORD: ${{ secrets.OSSRH_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

@@ -0,0 +1,50 @@
+# 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
+
+on:
+    push:
+        branches:
+            - '*'
+        tags:
+            - '[0-9]*'
+        paths:
+            - 'flatlaf-natives/**'
+            - '.github/workflows/natives.yml'
+            - 'gradle/wrapper/gradle-wrapper.properties'
+
+jobs:
+    Natives:
+        strategy:
+            matrix:
+                os:
+                    - windows
+                    - ubuntu
+
+        runs-on: ${{ matrix.os }}-latest
+
+        steps:
+            - uses: actions/checkout@v3
+
+            - uses: gradle/wrapper-validation-action@v1
+
+            - name: Setup Java 11
+              uses: actions/setup-java@v3
+              with:
+                  java-version: 11
+                  distribution: adopt
+                  cache: gradle
+
+            - name: Build with Gradle
+              # --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: Upload artifacts
+              uses: actions/upload-artifact@v3
+              with:
+                  name: FlatLaf-natives-build-artifacts-${{ matrix.os }}
+                  path: |
+                      flatlaf-core/src/main/resources/com/formdev/flatlaf/natives
+                      flatlaf-natives/flatlaf-natives-*/build

.gitignore

@@ -9,3 +9,7 @@ out/
 *.iml
 *.ipr
 *.iws
+*.xcuserstate
+*.xcworkspacedata
+.vs/
+.vscode/

.travis.yml

@@ -1,29 +0,0 @@
-language: java
-sudo: false
-
-jdk:
-  - openjdk8
-  - openjdk9
-  - openjdk11
-  - openjdk13
-
-before_cache:
-  - rm -f  $HOME/.gradle/caches/modules-2/modules-2.lock
-  - rm -fr $HOME/.gradle/caches/*/plugin-resolution/
-cache:
-  directories:
-    - $HOME/.gradle/caches/
-    - $HOME/.gradle/wrapper/
-
-before_install:
-  - ./gradlew --version
-  - java -version
-
-deploy:
-  provider: script
-  script: ./gradlew bintrayUpload
-  skip_cleanup: true # to upload artifacts created during the build
-  on:
-    branch: master
-    jdk: openjdk11
-    tags: true

README.md

@@ -11,20 +11,30 @@ scales on **HiDPI** displays and runs on Java 8 or newer.
 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 Demo](images/FlatLightDemo.png)
+![FlatLaf Light](images/flat_light.png)
 
-![Flat Dark Demo](images/FlatDarkDemo.png)
+![FlatLaf Dark](images/flat_dark.png)
 
 
 IntelliJ Platform Themes
 ------------------------
 
-FlatLaf can use 3rd party themes created for IntelliJ Platform:
+FlatLaf can use 3rd party themes created for IntelliJ Platform (see
+[IntelliJ Themes Pack](flatlaf-intellij-themes)):
 
-![Cyan Light Demo](images/CyanLightDemo.png)
+![IntelliJ Platform Themes](images/intellij_platform_themes.png)
 
-![Dark Purple Demo](images/DarkPurpleDemo.png)
 
+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>
+
+[Become a Sponsor](https://www.formdev.com/flatlaf/sponsor/)
 
 Demo
 ----
@@ -38,29 +48,212 @@ Requires Java 8 or newer.
 Download
 --------
 
-FlatLaf binaries are available on **JCenter** and **Maven Central**.
+FlatLaf binaries are available on **Maven Central**.
 
 If you use Maven or Gradle, add a dependency with following coordinates to your
 build script:
 
     groupId:     com.formdev
     artifactId:  flatlaf
-    version:     0.23.1
+    version:     (see button below)
 
 Otherwise download `flatlaf-<version>.jar` here:
 
-[![Download](https://api.bintray.com/packages/jformdesigner/flatlaf/flatlaf/images/download.svg)](https://bintray.com/jformdesigner/flatlaf/flatlaf/_latestVersion)
+[![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)
+
+
+### Snapshots
+
+FlatLaf snapshot binaries are available on
+[Sonatype OSSRH](https://oss.sonatype.org/content/repositories/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
+[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)
+docs).
 
 
 Addons
 ------
 
-- [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 use FlatLaf, add following code to your main method before you create any
+Swing component:
+
+~~~java
+FlatLightLaf.setup();
+
+// create UI here...
+~~~
 
 
 Documentation
 -------------
 
 For more information and documentation visit
-[FlatLaf Home](https://www.formdev.com/flatlaf/)
+[FlatLaf Home](https://www.formdev.com/flatlaf/):
+
+- [Themes](https://www.formdev.com/flatlaf/themes/)
+- [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 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
+--------------------------
+
+- ![New](images/new.svg)
+  [JProfiler](https://www.ej-technologies.com/products/jprofiler/overview.html)
+  12 (**commercial**) - the award-winning all-in-one Java profiler
+- ![New](images/new.svg) [JFormDesigner](https://www.formdev.com/) 8
+  (**commercial**) - Java/Swing GUI Designer
+- ![New](images/new.svg) [Jeyla Studio](https://www.jeylastudio.com/) - Salon
+  Software
+- ![New](images/new.svg) [Fanurio](https://www.fanuriotimetracking.com/) 3.3.2
+  (**commercial**) - time tracking and billing for freelancers and teams
+- ![New](images/new.svg) [Antares](https://www.antarescircuit.io/) - a free,
+  powerful platform for designing, simulating and explaining digital circuits
+- ![New](images/new.svg)
+  [Logisim-evolution](https://github.com/logisim-evolution/logisim-evolution)
+  3.6 - Digital logic design tool and simulator
+- ![New](images/new.svg) [Cinecred](https://loadingbyte.com/cinecred/) - create
+  beautiful film credit sequences
+- ![New](images/new.svg) [tinyMediaManager](https://www.tinymediamanager.org/)
+  v4 (**commercial**) - a media management tool
+- ![New](images/new.svg) [Weasis](https://nroduit.github.io/) - medical DICOM
+  viewer used in healthcare by hospitals, health networks, etc
+- ![New](images/new.svg)
+  [Makelangelo Software](https://github.com/MarginallyClever/Makelangelo-software)
+  7.3.0 - for plotters, especially the wall-hanging polargraph
+- ![Hot](images/hot.svg) [Ultorg](https://www.ultorg.com/) (**commercial**) - a
+  visual query system for relational databases
+- [MooInfo](https://github.com/rememberber/MooInfo) - visual implementation of
+  OSHI, to view information about the system and hardware
+- [Jailer](https://github.com/Wisser/Jailer) 11.2 - database subsetting and
+  relational data browsing tool
+- ![Hot](images/hot.svg) [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
+- ![Hot](images/hot.svg)
+  [install4j](https://www.ej-technologies.com/products/install4j/overview.html)
+  9.0 (**commercial**) - the powerful multi-platform Java installer builder
+- ![Hot](images/hot.svg) [DbVisualizer](https://www.dbvis.com/) 12.0
+  (**commercial**) - the universal database tool for developers, analysts and
+  DBAs
+- ![Hot](images/hot.svg) [MagicPlot](https://magicplot.com/) 3.0
+  (**commercial**) - Software for nonlinear fitting, plotting and data analysis
+- ![Hot](images/hot.svg)
+  [Thermo-Calc](https://thermocalc.com/products/thermo-calc/) 2021a
+  (**commercial**) - Thermodynamics and Properties Software
+- ![Hot](images/hot.svg) [OWASP ZAP](https://www.zaproxy.org/) 2.10 - the worlds
+  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
+- [BurpCustomizer](https://github.com/CoreyD97/BurpCustomizer) - adds more
+  FlatLaf themes to Burp Suite
+- ![Hot](images/hot.svg) [JOSM](https://josm.openstreetmap.de/) - an extensible
+  editor for [OpenStreetMap](https://www.openstreetmap.org/) (requires FlatLaf
+  JOSM plugin)
+- ![Hot](images/hot.svg) [jAlbum](https://jalbum.net/) 21 (**commercial**) -
+  creates photo album websites
+- [PDF Studio](https://www.qoppa.com/pdfstudio/) 2021 (**commercial**) - create,
+  review and edit PDF documents
+- [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),
+  [MegaMekLab](https://github.com/MegaMek/megameklab) and
+  [MekHQ](https://github.com/MegaMek/mekhq) v0.47.5+ - a sci-fi tabletop
+  BattleTech simulator suite handling battles, unit building, and campaigns
+- [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
+- [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**)
+- [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
+- [Android Tool](https://github.com/fast-geek/Android-Tool) - makes popular adb
+  and fastboot commands easier to use
+- and more...

build.gradle.kts

@@ -5,7 +5,7 @@
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
- *     http://www.apache.org/licenses/LICENSE-2.0
+ *     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,
@@ -14,11 +14,16 @@
  * limitations under the License.
  */
 
-version = "0.23.1"
+val releaseVersion = "3.0"
+val developmentVersion = "3.1-SNAPSHOT"
+
+version = if( rootProject.hasProperty( "release" ) ) releaseVersion else developmentVersion
 
 allprojects {
+	version = rootProject.version
+
 	repositories {
-		jcenter()
+		mavenCentral()
 	}
 }
 
@@ -32,4 +37,48 @@ println( "----------------------------------------------------------------------
 println( "FlatLaf Version: ${version}" )
 println( "Gradle ${gradle.gradleVersion} at ${gradle.gradleHomeDir}" )
 println( "Java ${System.getProperty( "java.version" )}" )
+val toolchainJavaVersion = System.getProperty( "toolchain" )
+if( !toolchainJavaVersion.isNullOrEmpty() )
+	println( "Java toolchain ${toolchainJavaVersion}" )
 println()
+
+
+allprojects {
+	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(
+				"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
+			)
+
+			// add META-INF/LICENSE to all created JARs
+			from( "${rootDir}/LICENSE" ) {
+				into( "META-INF" )
+			}
+		}
+
+		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
+		}
+	}
+}

buildSrc/build.gradle.kts

@@ -0,0 +1,24 @@
+/*
+ * Copyright 2020 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 {
+	`kotlin-dsl`
+}
+
+// required for kotlin-dsl or embedded-kotlin plugins
+repositories {
+	mavenCentral()
+}

buildSrc/src/main/java/ReorderJarEntries.java

@@ -0,0 +1,80 @@
+/*
+ * Copyright 2020 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 java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.nio.file.Files;
+import java.nio.file.StandardOpenOption;
+import java.util.function.Predicate;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipInputStream;
+import java.util.zip.ZipOutputStream;
+
+/**
+ * Reorders entries in a JAR file so that .properties files are placed before .class files,
+ * which is necessary to workaround an issue in NetBeans 11.3 (and older).
+ * See issues #13 and #93.
+ *
+ * @author Karl Tauber
+ */
+public class ReorderJarEntries
+{
+	public static void reorderJarEntries( File jarFile )
+		throws IOException
+	{
+		ByteArrayOutputStream outStream = new ByteArrayOutputStream( (int) jarFile.length() + 1000 );
+
+		try( ZipOutputStream zipOutStream = new ZipOutputStream( outStream ) ) {
+			// 1st pass: copy .properties files
+			copyFiles( zipOutStream, jarFile, name -> name.endsWith( ".properties" ) );
+
+			// 2st pass: copy other files
+			copyFiles( zipOutStream, jarFile, name -> !name.endsWith( ".properties" ) );
+		}
+
+		// replace JAR
+		Files.write( jarFile.toPath(), outStream.toByteArray(),
+			StandardOpenOption.CREATE, StandardOpenOption.TRUNCATE_EXISTING );
+	}
+
+	private static void copyFiles( ZipOutputStream dest, File jarFile, Predicate<String> filter )
+		throws IOException
+	{
+		try( ZipInputStream zipInputStream = new ZipInputStream( new FileInputStream( jarFile ) ) ) {
+			ZipEntry entry;
+			while( (entry = zipInputStream.getNextEntry()) != null ) {
+				if( filter.test( entry.getName() ) ) {
+					dest.putNextEntry( entry );
+					copyFile( zipInputStream, dest );
+				}
+			}
+		}
+	}
+
+	private static void copyFile( InputStream src, OutputStream dest )
+		throws IOException
+	{
+		byte[] buf = new byte[8*1024];
+		int len;
+		while( (len = src.read( buf )) > 0 )
+			dest.write( buf, 0, len );
+		dest.flush();
+	}
+}

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

@@ -0,0 +1,46 @@
+/*
+ * 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 {
+	`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.set( false )
+		}
+	}
+}
+
+tasks {
+	withType<CppCompile>().configureEach {
+		doFirst {
+			println( "Used Tool Chain:" )
+			println( "  - ${toolChain.get()}" )
+			println( "Available Tool Chains:" )
+			toolChains.forEach {
+				println( "  - $it" )
+			}
+		}
+	}
+}

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

@@ -0,0 +1,48 @@
+/*
+ * Copyright 2020 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
+}
+
+if( JavaVersion.current() >= JavaVersion.VERSION_1_9 ) {
+	sourceSets {
+		create( "java9" ) {
+			java {
+				setSrcDirs( listOf( "src/main/java9" ) )
+			}
+		}
+	}
+
+	dependencies {
+		add( "java9Implementation", sourceSets.main.get().output )
+	}
+
+	tasks {
+		named<JavaCompile>( "compileJava9Java" ) {
+			sourceCompatibility = "9"
+			targetCompatibility = "9"
+		}
+
+		jar {
+			manifest.attributes( "Multi-Release" to "true" )
+
+			into( "META-INF/versions/9" ) {
+				from( sourceSets["java9"].output )
+			}
+		}
+	}
+}

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" ).buildDir.resolve( "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

@@ -0,0 +1,69 @@
+/*
+ * Copyright 2020 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 ModuleInfoExtension {
+	var paths: ArrayList<String> = ArrayList()
+
+	fun dependsOn( vararg paths: String ) {
+		this.paths.addAll( paths )
+	}
+}
+
+val extension = project.extensions.create<ModuleInfoExtension>( "flatlafModuleInfo" )
+
+
+plugins {
+	java
+}
+
+if( JavaVersion.current() >= JavaVersion.VERSION_1_9 ) {
+	sourceSets {
+		create( "module-info" ) {
+			java {
+				// include "src/main/java" and "src/main/java9" here to get compile errors if classes are
+				// used from other modules that are not specified in module dependencies
+				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
+				exclude {
+					if( it.isDirectory )
+						return@exclude false
+					val java9file = file( "${projectDir}/src/main/java9/${it.path}" )
+					java9file.exists() && java9file != it.file
+				}
+			}
+		}
+	}
+
+	tasks {
+		named<JavaCompile>( "compileModuleInfoJava" ) {
+			sourceCompatibility = "9"
+			targetCompatibility = "9"
+
+			dependsOn( extension.paths )
+
+			options.compilerArgs.add( "--module-path" )
+			options.compilerArgs.add( configurations.runtimeClasspath.get().asPath
+				+ File.pathSeparator + configurations.compileClasspath.get().asPath )
+		}
+
+		jar {
+			from( sourceSets["module-info"].output ) {
+				include( "module-info.class" )
+			}
+		}
+	}
+}

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

@@ -0,0 +1,112 @@
+/*
+ * Copyright 2020 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 PublishExtension {
+	var artifactId: String? = null
+	var name: String? = null
+	var description: String? = null
+}
+
+val extension = project.extensions.create<PublishExtension>( "flatlafPublish" )
+
+
+plugins {
+	`maven-publish`
+	signing
+}
+
+publishing {
+	publications {
+		create<MavenPublication>( "maven" ) {
+			afterEvaluate {
+				artifactId = extension.artifactId
+			}
+			groupId = "com.formdev"
+
+			from( components["java"] )
+
+			pom {
+				afterEvaluate {
+					this@pom.name.set( extension.name )
+					this@pom.description.set( extension.description )
+				}
+				url.set( "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" )
+					}
+				}
+
+				developers {
+					developer {
+						name.set( "Karl Tauber" )
+						organization.set( "FormDev Software GmbH" )
+						organizationUrl.set( "https://www.formdev.com/" )
+					}
+				}
+
+				scm {
+					connection.set( "scm:git:git://github.com/JFormDesigner/FlatLaf.git" )
+					url.set( "https://github.com/JFormDesigner/FlatLaf" )
+				}
+
+				issueManagement {
+					system.set( "GitHub" )
+					url.set( "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( rootProject.hasProperty( "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
+			}
+		}
+	}
+}
+
+signing {
+	// get from gradle.properties
+	val signingKey: String? by project
+	val signingPassword: String? by project
+
+	val key = System.getenv( "SIGNING_KEY" ) ?: signingKey
+	val password = System.getenv( "SIGNING_PASSWORD" ) ?: signingPassword
+
+	useInMemoryPgpKeys( key, password )
+	sign( publishing.publications["maven"] )
+}
+
+// disable signing of snapshots
+tasks.withType<Sign>().configureEach {
+	onlyIf { rootProject.hasProperty( "release" ) }
+}

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

@@ -0,0 +1,26 @@
+/*
+ * 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 = System.getProperty( "toolchain" )
+if( !toolchainJavaVersion.isNullOrEmpty() ) {
+	java.toolchain {
+		languageVersion.set( JavaLanguageVersion.of( toolchainJavaVersion ) )
+	}
+}

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

@@ -0,0 +1,377 @@
+eclipse.preferences.version=1
+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
+org.eclipse.jdt.core.formatter.align_variable_declarations_on_columns=false
+org.eclipse.jdt.core.formatter.align_with_spaces=false
+org.eclipse.jdt.core.formatter.alignment_for_additive_operator=16
+org.eclipse.jdt.core.formatter.alignment_for_arguments_in_allocation_expression=16
+org.eclipse.jdt.core.formatter.alignment_for_arguments_in_annotation=0
+org.eclipse.jdt.core.formatter.alignment_for_arguments_in_enum_constant=16
+org.eclipse.jdt.core.formatter.alignment_for_arguments_in_explicit_constructor_call=16
+org.eclipse.jdt.core.formatter.alignment_for_arguments_in_method_invocation=16
+org.eclipse.jdt.core.formatter.alignment_for_arguments_in_qualified_allocation_expression=16
+org.eclipse.jdt.core.formatter.alignment_for_assignment=0
+org.eclipse.jdt.core.formatter.alignment_for_bitwise_operator=16
+org.eclipse.jdt.core.formatter.alignment_for_compact_if=16
+org.eclipse.jdt.core.formatter.alignment_for_compact_loops=16
+org.eclipse.jdt.core.formatter.alignment_for_conditional_expression=48
+org.eclipse.jdt.core.formatter.alignment_for_conditional_expression_chain=0
+org.eclipse.jdt.core.formatter.alignment_for_enum_constants=16
+org.eclipse.jdt.core.formatter.alignment_for_expressions_in_array_initializer=16
+org.eclipse.jdt.core.formatter.alignment_for_expressions_in_for_loop_header=0
+org.eclipse.jdt.core.formatter.alignment_for_logical_operator=16
+org.eclipse.jdt.core.formatter.alignment_for_method_declaration=0
+org.eclipse.jdt.core.formatter.alignment_for_module_statements=16
+org.eclipse.jdt.core.formatter.alignment_for_multiple_fields=16
+org.eclipse.jdt.core.formatter.alignment_for_multiplicative_operator=16
+org.eclipse.jdt.core.formatter.alignment_for_parameterized_type_references=0
+org.eclipse.jdt.core.formatter.alignment_for_parameters_in_constructor_declaration=16
+org.eclipse.jdt.core.formatter.alignment_for_parameters_in_method_declaration=16
+org.eclipse.jdt.core.formatter.alignment_for_record_components=16
+org.eclipse.jdt.core.formatter.alignment_for_relational_operator=0
+org.eclipse.jdt.core.formatter.alignment_for_resources_in_try=80
+org.eclipse.jdt.core.formatter.alignment_for_selector_in_method_invocation=16
+org.eclipse.jdt.core.formatter.alignment_for_shift_operator=0
+org.eclipse.jdt.core.formatter.alignment_for_string_concatenation=16
+org.eclipse.jdt.core.formatter.alignment_for_superclass_in_type_declaration=33
+org.eclipse.jdt.core.formatter.alignment_for_superinterfaces_in_enum_declaration=33
+org.eclipse.jdt.core.formatter.alignment_for_superinterfaces_in_record_declaration=33
+org.eclipse.jdt.core.formatter.alignment_for_superinterfaces_in_type_declaration=33
+org.eclipse.jdt.core.formatter.alignment_for_throws_clause_in_constructor_declaration=32
+org.eclipse.jdt.core.formatter.alignment_for_throws_clause_in_method_declaration=32
+org.eclipse.jdt.core.formatter.alignment_for_type_arguments=0
+org.eclipse.jdt.core.formatter.alignment_for_type_parameters=0
+org.eclipse.jdt.core.formatter.alignment_for_union_type_in_multicatch=16
+org.eclipse.jdt.core.formatter.blank_lines_after_imports=1
+org.eclipse.jdt.core.formatter.blank_lines_after_last_class_body_declaration=0
+org.eclipse.jdt.core.formatter.blank_lines_after_package=1
+org.eclipse.jdt.core.formatter.blank_lines_before_abstract_method=1
+org.eclipse.jdt.core.formatter.blank_lines_before_field=0
+org.eclipse.jdt.core.formatter.blank_lines_before_first_class_body_declaration=0
+org.eclipse.jdt.core.formatter.blank_lines_before_imports=1
+org.eclipse.jdt.core.formatter.blank_lines_before_member_type=1
+org.eclipse.jdt.core.formatter.blank_lines_before_method=1
+org.eclipse.jdt.core.formatter.blank_lines_before_new_chunk=1
+org.eclipse.jdt.core.formatter.blank_lines_before_package=0
+org.eclipse.jdt.core.formatter.blank_lines_between_import_groups=0
+org.eclipse.jdt.core.formatter.blank_lines_between_statement_group_in_switch=0
+org.eclipse.jdt.core.formatter.blank_lines_between_type_declarations=1
+org.eclipse.jdt.core.formatter.brace_position_for_annotation_type_declaration=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_anonymous_type_declaration=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_array_initializer=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_block=next_line_on_wrap
+org.eclipse.jdt.core.formatter.brace_position_for_block_in_case=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_constructor_declaration=next_line_on_wrap
+org.eclipse.jdt.core.formatter.brace_position_for_enum_constant=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_enum_declaration=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_lambda_body=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_method_declaration=next_line_on_wrap
+org.eclipse.jdt.core.formatter.brace_position_for_record_constructor=next_line_on_wrap
+org.eclipse.jdt.core.formatter.brace_position_for_record_declaration=next_line
+org.eclipse.jdt.core.formatter.brace_position_for_switch=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_type_declaration=next_line
+org.eclipse.jdt.core.formatter.comment.align_tags_descriptions_grouped=true
+org.eclipse.jdt.core.formatter.comment.align_tags_names_descriptions=false
+org.eclipse.jdt.core.formatter.comment.clear_blank_lines_in_block_comment=true
+org.eclipse.jdt.core.formatter.comment.clear_blank_lines_in_javadoc_comment=false
+org.eclipse.jdt.core.formatter.comment.count_line_length_from_starting_position=true
+org.eclipse.jdt.core.formatter.comment.format_block_comments=true
+org.eclipse.jdt.core.formatter.comment.format_header=false
+org.eclipse.jdt.core.formatter.comment.format_html=true
+org.eclipse.jdt.core.formatter.comment.format_javadoc_comments=true
+org.eclipse.jdt.core.formatter.comment.format_line_comments=true
+org.eclipse.jdt.core.formatter.comment.format_source_code=true
+org.eclipse.jdt.core.formatter.comment.indent_parameter_description=false
+org.eclipse.jdt.core.formatter.comment.indent_root_tags=false
+org.eclipse.jdt.core.formatter.comment.indent_tag_description=false
+org.eclipse.jdt.core.formatter.comment.insert_new_line_before_root_tags=insert
+org.eclipse.jdt.core.formatter.comment.insert_new_line_between_different_tags=do not insert
+org.eclipse.jdt.core.formatter.comment.insert_new_line_for_parameter=do not insert
+org.eclipse.jdt.core.formatter.comment.line_length=80
+org.eclipse.jdt.core.formatter.comment.new_lines_at_block_boundaries=true
+org.eclipse.jdt.core.formatter.comment.new_lines_at_javadoc_boundaries=true
+org.eclipse.jdt.core.formatter.comment.preserve_white_space_between_code_and_line_comments=false
+org.eclipse.jdt.core.formatter.compact_else_if=true
+org.eclipse.jdt.core.formatter.continuation_indentation=1
+org.eclipse.jdt.core.formatter.continuation_indentation_for_array_initializer=1
+org.eclipse.jdt.core.formatter.disabling_tag=@formatter\:off
+org.eclipse.jdt.core.formatter.enabling_tag=@formatter\:on
+org.eclipse.jdt.core.formatter.format_guardian_clause_on_one_line=false
+org.eclipse.jdt.core.formatter.format_line_comment_starting_on_first_column=false
+org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_annotation_declaration_header=true
+org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_enum_constant_header=true
+org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_enum_declaration_header=true
+org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_record_header=true
+org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_type_header=true
+org.eclipse.jdt.core.formatter.indent_breaks_compare_to_cases=true
+org.eclipse.jdt.core.formatter.indent_empty_lines=false
+org.eclipse.jdt.core.formatter.indent_statements_compare_to_block=true
+org.eclipse.jdt.core.formatter.indent_statements_compare_to_body=true
+org.eclipse.jdt.core.formatter.indent_switchstatements_compare_to_cases=true
+org.eclipse.jdt.core.formatter.indent_switchstatements_compare_to_switch=true
+org.eclipse.jdt.core.formatter.indentation.size=4
+org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_enum_constant=insert
+org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_field=insert
+org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_local_variable=insert
+org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_method=insert
+org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_package=insert
+org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_parameter=do not insert
+org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_type=insert
+org.eclipse.jdt.core.formatter.insert_new_line_after_label=do not insert
+org.eclipse.jdt.core.formatter.insert_new_line_after_opening_brace_in_array_initializer=do not insert
+org.eclipse.jdt.core.formatter.insert_new_line_after_type_annotation=do not insert
+org.eclipse.jdt.core.formatter.insert_new_line_at_end_of_file_if_missing=insert
+org.eclipse.jdt.core.formatter.insert_new_line_before_catch_in_try_statement=do not insert
+org.eclipse.jdt.core.formatter.insert_new_line_before_closing_brace_in_array_initializer=do not insert
+org.eclipse.jdt.core.formatter.insert_new_line_before_else_in_if_statement=do not insert
+org.eclipse.jdt.core.formatter.insert_new_line_before_finally_in_try_statement=do not insert
+org.eclipse.jdt.core.formatter.insert_new_line_before_while_in_do_statement=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_additive_operator=insert
+org.eclipse.jdt.core.formatter.insert_space_after_and_in_type_parameter=insert
+org.eclipse.jdt.core.formatter.insert_space_after_arrow_in_switch_case=insert
+org.eclipse.jdt.core.formatter.insert_space_after_arrow_in_switch_default=insert
+org.eclipse.jdt.core.formatter.insert_space_after_assignment_operator=insert
+org.eclipse.jdt.core.formatter.insert_space_after_at_in_annotation=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_at_in_annotation_type_declaration=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_bitwise_operator=insert
+org.eclipse.jdt.core.formatter.insert_space_after_closing_angle_bracket_in_type_arguments=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_closing_angle_bracket_in_type_parameters=insert
+org.eclipse.jdt.core.formatter.insert_space_after_closing_brace_in_block=insert
+org.eclipse.jdt.core.formatter.insert_space_after_closing_paren_in_cast=insert
+org.eclipse.jdt.core.formatter.insert_space_after_colon_in_assert=insert
+org.eclipse.jdt.core.formatter.insert_space_after_colon_in_case=insert
+org.eclipse.jdt.core.formatter.insert_space_after_colon_in_conditional=insert
+org.eclipse.jdt.core.formatter.insert_space_after_colon_in_for=insert
+org.eclipse.jdt.core.formatter.insert_space_after_colon_in_labeled_statement=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_allocation_expression=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_annotation=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_array_initializer=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_constructor_declaration_parameters=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_constructor_declaration_throws=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_enum_constant_arguments=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_enum_declarations=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_explicitconstructorcall_arguments=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_for_increments=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_for_inits=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_method_declaration_parameters=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_method_declaration_throws=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_method_invocation_arguments=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_multiple_field_declarations=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_multiple_local_declarations=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_parameterized_type_reference=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_record_components=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_superinterfaces=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_switch_case_expressions=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_type_arguments=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_type_parameters=insert
+org.eclipse.jdt.core.formatter.insert_space_after_ellipsis=insert
+org.eclipse.jdt.core.formatter.insert_space_after_lambda_arrow=insert
+org.eclipse.jdt.core.formatter.insert_space_after_logical_operator=insert
+org.eclipse.jdt.core.formatter.insert_space_after_multiplicative_operator=insert
+org.eclipse.jdt.core.formatter.insert_space_after_not_operator=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_parameterized_type_reference=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_type_arguments=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_type_parameters=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_brace_in_array_initializer=insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_bracket_in_array_allocation_expression=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_bracket_in_array_reference=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_annotation=insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_cast=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_catch=insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_constructor_declaration=insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_enum_constant=insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_for=insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_if=insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_method_declaration=insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_method_invocation=insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_parenthesized_expression=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_record_declaration=insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_switch=insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_synchronized=insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_try=insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_while=insert
+org.eclipse.jdt.core.formatter.insert_space_after_postfix_operator=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_prefix_operator=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_question_in_conditional=insert
+org.eclipse.jdt.core.formatter.insert_space_after_question_in_wildcard=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_relational_operator=insert
+org.eclipse.jdt.core.formatter.insert_space_after_semicolon_in_for=insert
+org.eclipse.jdt.core.formatter.insert_space_after_semicolon_in_try_resources=insert
+org.eclipse.jdt.core.formatter.insert_space_after_shift_operator=insert
+org.eclipse.jdt.core.formatter.insert_space_after_string_concatenation=insert
+org.eclipse.jdt.core.formatter.insert_space_after_unary_operator=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_additive_operator=insert
+org.eclipse.jdt.core.formatter.insert_space_before_and_in_type_parameter=insert
+org.eclipse.jdt.core.formatter.insert_space_before_arrow_in_switch_case=insert
+org.eclipse.jdt.core.formatter.insert_space_before_arrow_in_switch_default=insert
+org.eclipse.jdt.core.formatter.insert_space_before_assignment_operator=insert
+org.eclipse.jdt.core.formatter.insert_space_before_at_in_annotation_type_declaration=insert
+org.eclipse.jdt.core.formatter.insert_space_before_bitwise_operator=insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_parameterized_type_reference=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_type_arguments=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_type_parameters=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_brace_in_array_initializer=insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_bracket_in_array_allocation_expression=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_bracket_in_array_reference=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_annotation=insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_cast=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_catch=insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_constructor_declaration=insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_enum_constant=insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_for=insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_if=insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_method_declaration=insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_method_invocation=insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_parenthesized_expression=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_record_declaration=insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_switch=insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_synchronized=insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_try=insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_while=insert
+org.eclipse.jdt.core.formatter.insert_space_before_colon_in_assert=insert
+org.eclipse.jdt.core.formatter.insert_space_before_colon_in_case=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_colon_in_conditional=insert
+org.eclipse.jdt.core.formatter.insert_space_before_colon_in_default=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_colon_in_for=insert
+org.eclipse.jdt.core.formatter.insert_space_before_colon_in_labeled_statement=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_allocation_expression=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_annotation=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_array_initializer=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_constructor_declaration_parameters=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_constructor_declaration_throws=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_enum_constant_arguments=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_enum_declarations=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_explicitconstructorcall_arguments=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_for_increments=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_for_inits=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_method_declaration_parameters=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_method_declaration_throws=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_method_invocation_arguments=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_multiple_field_declarations=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_multiple_local_declarations=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_parameterized_type_reference=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_record_components=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_superinterfaces=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_switch_case_expressions=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_type_arguments=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_type_parameters=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_ellipsis=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_lambda_arrow=insert
+org.eclipse.jdt.core.formatter.insert_space_before_logical_operator=insert
+org.eclipse.jdt.core.formatter.insert_space_before_multiplicative_operator=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_angle_bracket_in_parameterized_type_reference=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_angle_bracket_in_type_arguments=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_angle_bracket_in_type_parameters=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_annotation_type_declaration=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_anonymous_type_declaration=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_array_initializer=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_block=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_constructor_declaration=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_enum_constant=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_enum_declaration=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_method_declaration=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_record_constructor=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_record_declaration=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_switch=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_type_declaration=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_bracket_in_array_allocation_expression=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_bracket_in_array_reference=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_bracket_in_array_type_reference=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_annotation=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_annotation_type_member_declaration=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_catch=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_constructor_declaration=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_enum_constant=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_for=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_if=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_method_declaration=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_method_invocation=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_parenthesized_expression=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_record_declaration=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_switch=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_synchronized=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_try=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_while=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_parenthesized_expression_in_return=insert
+org.eclipse.jdt.core.formatter.insert_space_before_parenthesized_expression_in_throw=insert
+org.eclipse.jdt.core.formatter.insert_space_before_postfix_operator=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_prefix_operator=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_question_in_conditional=insert
+org.eclipse.jdt.core.formatter.insert_space_before_question_in_wildcard=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_relational_operator=insert
+org.eclipse.jdt.core.formatter.insert_space_before_semicolon=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_semicolon_in_for=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_semicolon_in_try_resources=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_shift_operator=insert
+org.eclipse.jdt.core.formatter.insert_space_before_string_concatenation=insert
+org.eclipse.jdt.core.formatter.insert_space_before_unary_operator=do not insert
+org.eclipse.jdt.core.formatter.insert_space_between_brackets_in_array_type_reference=do not insert
+org.eclipse.jdt.core.formatter.insert_space_between_empty_braces_in_array_initializer=do not insert
+org.eclipse.jdt.core.formatter.insert_space_between_empty_brackets_in_array_allocation_expression=do not insert
+org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_annotation_type_member_declaration=do not insert
+org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_constructor_declaration=do not insert
+org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_enum_constant=do not insert
+org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_method_declaration=do not insert
+org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_method_invocation=do not insert
+org.eclipse.jdt.core.formatter.join_lines_in_comments=true
+org.eclipse.jdt.core.formatter.join_wrapped_lines=true
+org.eclipse.jdt.core.formatter.keep_annotation_declaration_on_one_line=one_line_never
+org.eclipse.jdt.core.formatter.keep_anonymous_type_declaration_on_one_line=one_line_never
+org.eclipse.jdt.core.formatter.keep_code_block_on_one_line=one_line_never
+org.eclipse.jdt.core.formatter.keep_else_statement_on_same_line=false
+org.eclipse.jdt.core.formatter.keep_empty_array_initializer_on_one_line=false
+org.eclipse.jdt.core.formatter.keep_enum_constant_declaration_on_one_line=one_line_never
+org.eclipse.jdt.core.formatter.keep_enum_declaration_on_one_line=one_line_never
+org.eclipse.jdt.core.formatter.keep_if_then_body_block_on_one_line=one_line_never
+org.eclipse.jdt.core.formatter.keep_imple_if_on_one_line=false
+org.eclipse.jdt.core.formatter.keep_lambda_body_block_on_one_line=one_line_never
+org.eclipse.jdt.core.formatter.keep_loop_body_block_on_one_line=one_line_never
+org.eclipse.jdt.core.formatter.keep_method_body_on_one_line=one_line_never
+org.eclipse.jdt.core.formatter.keep_record_constructor_on_one_line=one_line_never
+org.eclipse.jdt.core.formatter.keep_record_declaration_on_one_line=one_line_never
+org.eclipse.jdt.core.formatter.keep_simple_do_while_body_on_same_line=false
+org.eclipse.jdt.core.formatter.keep_simple_for_body_on_same_line=false
+org.eclipse.jdt.core.formatter.keep_simple_getter_setter_on_one_line=false
+org.eclipse.jdt.core.formatter.keep_simple_while_body_on_same_line=false
+org.eclipse.jdt.core.formatter.keep_then_statement_on_same_line=false
+org.eclipse.jdt.core.formatter.keep_type_declaration_on_one_line=one_line_never
+org.eclipse.jdt.core.formatter.lineSplit=120
+org.eclipse.jdt.core.formatter.never_indent_block_comments_on_first_column=false
+org.eclipse.jdt.core.formatter.never_indent_line_comments_on_first_column=false
+org.eclipse.jdt.core.formatter.number_of_blank_lines_after_code_block=0
+org.eclipse.jdt.core.formatter.number_of_blank_lines_at_beginning_of_code_block=0
+org.eclipse.jdt.core.formatter.number_of_blank_lines_at_beginning_of_method_body=0
+org.eclipse.jdt.core.formatter.number_of_blank_lines_at_end_of_code_block=0
+org.eclipse.jdt.core.formatter.number_of_blank_lines_at_end_of_method_body=0
+org.eclipse.jdt.core.formatter.number_of_blank_lines_before_code_block=0
+org.eclipse.jdt.core.formatter.number_of_empty_lines_to_preserve=1
+org.eclipse.jdt.core.formatter.parentheses_positions_in_annotation=common_lines
+org.eclipse.jdt.core.formatter.parentheses_positions_in_catch_clause=common_lines
+org.eclipse.jdt.core.formatter.parentheses_positions_in_enum_constant_declaration=common_lines
+org.eclipse.jdt.core.formatter.parentheses_positions_in_for_statment=common_lines
+org.eclipse.jdt.core.formatter.parentheses_positions_in_if_while_statement=common_lines
+org.eclipse.jdt.core.formatter.parentheses_positions_in_lambda_declaration=common_lines
+org.eclipse.jdt.core.formatter.parentheses_positions_in_method_delcaration=common_lines
+org.eclipse.jdt.core.formatter.parentheses_positions_in_method_invocation=common_lines
+org.eclipse.jdt.core.formatter.parentheses_positions_in_record_declaration=common_lines
+org.eclipse.jdt.core.formatter.parentheses_positions_in_switch_statement=common_lines
+org.eclipse.jdt.core.formatter.parentheses_positions_in_try_clause=common_lines
+org.eclipse.jdt.core.formatter.put_empty_statement_on_new_line=true
+org.eclipse.jdt.core.formatter.tabulation.char=tab
+org.eclipse.jdt.core.formatter.tabulation.size=4
+org.eclipse.jdt.core.formatter.text_block_indentation=0
+org.eclipse.jdt.core.formatter.use_on_off_tags=false
+org.eclipse.jdt.core.formatter.use_tabs_only_for_leading_indentations=false
+org.eclipse.jdt.core.formatter.wrap_before_additive_operator=true
+org.eclipse.jdt.core.formatter.wrap_before_assignment_operator=false
+org.eclipse.jdt.core.formatter.wrap_before_bitwise_operator=true
+org.eclipse.jdt.core.formatter.wrap_before_conditional_operator=true
+org.eclipse.jdt.core.formatter.wrap_before_logical_operator=false
+org.eclipse.jdt.core.formatter.wrap_before_multiplicative_operator=true
+org.eclipse.jdt.core.formatter.wrap_before_or_operator_multicatch=true
+org.eclipse.jdt.core.formatter.wrap_before_relational_operator=true
+org.eclipse.jdt.core.formatter.wrap_before_shift_operator=true
+org.eclipse.jdt.core.formatter.wrap_before_string_concatenation=true
+org.eclipse.jdt.core.formatter.wrap_outer_expressions_when_nested=true
+org.eclipse.jdt.core.javaFormatter=org.eclipse.jdt.core.defaultJavaFormatter

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

@@ -0,0 +1,3 @@
+eclipse.preferences.version=1
+formatter_profile=_FlatLaf
+formatter_settings_version=19

flatlaf-core/build.gradle.kts

@@ -5,7 +5,7 @@
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
- *     http://www.apache.org/licenses/LICENSE-2.0
+ *     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,
@@ -14,134 +14,113 @@
  * limitations under the License.
  */
 
-version = rootProject.version
-
 plugins {
 	`java-library`
-	`maven-publish`
-	id( "com.jfrog.bintray" ) version "1.8.4"
+	`flatlaf-toolchain`
+	`flatlaf-module-info`
+	`flatlaf-java9`
+	`flatlaf-publish`
 }
 
-if( JavaVersion.current() >= JavaVersion.VERSION_1_9 ) {
-	sourceSets {
-		create( "module-info" ) {
-			java {
-				// include "src/main/java" here to get compile errors if classes are
-				// used from other modules that are not specified in module dependencies
-				setSrcDirs( listOf( "src/main/module-info", "src/main/java" ) )
-			}
-		}
-	}
+val sigtest = configurations.create( "sigtest" )
+
+dependencies {
+	testImplementation( "org.junit.jupiter:junit-jupiter-api:5.7.2" )
+	testImplementation( "org.junit.jupiter:junit-jupiter-params" )
+	testRuntimeOnly( "org.junit.jupiter:junit-jupiter-engine" )
+
+	// https://github.com/jtulach/netbeans-apitest
+	sigtest( "org.netbeans.tools:sigtest-maven-plugin:1.7" )
 }
 
 java {
-	sourceCompatibility = JavaVersion.VERSION_1_8
-	targetCompatibility = JavaVersion.VERSION_1_8
+	withSourcesJar()
+	withJavadocJar()
 }
 
 tasks {
-	assemble {
-		dependsOn(
-			"sourcesJar",
-			"javadocJar"
-		)
+	compileJava {
+		// generate JNI headers
+		options.headerOutputDirectory.set( buildDir.resolve( "generated/jni-headers" ) )
 	}
 
-	if( JavaVersion.current() >= JavaVersion.VERSION_1_9 ) {
-		named<JavaCompile>( "compileModuleInfoJava" ) {
-			sourceCompatibility = "9"
-			targetCompatibility = "9"
-		}
-	}
-	
 	jar {
 		archiveBaseName.set( "flatlaf" )
 
-		if( JavaVersion.current() >= JavaVersion.VERSION_1_9 ) {
-			from( sourceSets["module-info"].output ) {
-				include( "module-info.class" )
+		doLast {
+			ReorderJarEntries.reorderJarEntries( outputs.files.singleFile );
+		}
+	}
+
+	named<Jar>( "sourcesJar" ) {
+		archiveBaseName.set( "flatlaf" )
+	}
+
+	named<Jar>( "javadocJar" ) {
+		archiveBaseName.set( "flatlaf" )
+	}
+
+	check {
+		dependsOn( "sigtestCheck" )
+	}
+
+	test {
+		useJUnitPlatform()
+		testLogging.exceptionFormat = org.gradle.api.tasks.testing.logging.TestExceptionFormat.FULL
+
+		if( JavaVersion.current() >= JavaVersion.VERSION_1_9 )
+			jvmArgs( listOf( "--add-opens", "java.desktop/javax.swing.plaf.basic=ALL-UNNAMED" ) )
+	}
+
+	register( "sigtestGenerate" ) {
+		group = "verification"
+		dependsOn( "jar" )
+
+		doLast {
+			ant.withGroovyBuilder {
+				"taskdef"(
+					"name" to "sigtest",
+					"classname" to "org.netbeans.apitest.Sigtest",
+					"classpath" to sigtest.asPath )
+
+				"sigtest"(
+					"action" to "generate",
+					"fileName" to "${project.name}-sigtest.txt",
+					"classpath" to jar.get().outputs.files.asPath,
+					"packages" to "com.formdev.flatlaf,com.formdev.flatlaf.themes,com.formdev.flatlaf.util",
+					"version" to version,
+					"release" to "1.8", // Java version
+					"failonerror" to "true" )
 			}
 		}
 	}
 
-	javadoc {
-		options {
-			this as StandardJavadocDocletOptions
-			tags = listOf( "uiDefault", "clientProperty" )
-		}
-		isFailOnError = false
-	}
+	register( "sigtestCheck" ) {
+		group = "verification"
+		dependsOn( "jar" )
 
-	register( "sourcesJar", Jar::class ) {
-		archiveBaseName.set( "flatlaf" )
-		archiveClassifier.set( "sources" )
+		doLast {
+			ant.withGroovyBuilder {
+				"taskdef"(
+					"name" to "sigtest",
+					"classname" to "org.netbeans.apitest.Sigtest",
+					"classpath" to sigtest.asPath )
 
-		from( sourceSets.main.get().allJava )
-	}
-
-	register( "javadocJar", Jar::class ) {
-		archiveBaseName.set( "flatlaf" )
-		archiveClassifier.set( "javadoc" )
-
-		from( javadoc )
-	}
-}
-
-publishing {
-	publications {
-		create<MavenPublication>( "maven" ) {
-			artifactId = "flatlaf"
-			groupId = "com.formdev"
-
-			from( components["java"] )
-
-			artifact( tasks["sourcesJar"] )
-			artifact( tasks["javadocJar"] )
-
-			pom {
-				name.set( "FlatLaf" )
-				description.set( "Flat Look and Feel" )
-				url.set( "https://github.com/JFormDesigner/FlatLaf" )
-
-				licenses {
-					license {
-						name.set( "The Apache License, Version 2.0" )
-						url.set( "http://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/" )
-					}
-				}
-
-				scm {
-					url.set( "https://github.com/JFormDesigner/FlatLaf" )
-				}
+				"sigtest"(
+					"action" to "check",
+					"fileName" to "${project.name}-sigtest.txt",
+					"classpath" to jar.get().outputs.files.asPath,
+					"packages" to "com.formdev.flatlaf,com.formdev.flatlaf.util",
+					"version" to version,
+					"release" to "1.8", // Java version
+					"failonerror" to "true" )
 			}
 		}
 	}
 }
 
-bintray {
-	user = System.getenv( "BINTRAY_USER" ) ?: System.getProperty( "bintray.user" )
-	key = System.getenv( "BINTRAY_KEY" ) ?: System.getProperty( "bintray.key" )
-
-	setPublications( "maven" )
-
-	with( pkg ) {
-		repo = "flatlaf"
-		name = "flatlaf"
-		setLicenses( "Apache-2.0" )
-		vcsUrl = "https://github.com/JFormDesigner/FlatLaf"
-
-		with( version ) {
-			name = project.version.toString()
-		}
-
-		publish = true
-	}
+flatlafPublish {
+	artifactId = "flatlaf"
+	name = "FlatLaf"
+	description = "Flat Look and Feel"
 }

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

@@ -16,27 +16,56 @@
 
 package com.formdev.flatlaf;
 
+import javax.swing.UIManager;
+
 /**
  * A Flat LaF that has a dark color scheme and looks like Darcula LaF.
- *
- * The UI defaults are loaded from FlatDarculaLaf.properties, FlatDarkLaf.properties and FlatLaf.properties
+ * <p>
+ * The UI defaults are loaded from {@code FlatDarculaLaf.properties},
+ * {@code FlatDarkLaf.properties} and {@code FlatLaf.properties}.
  *
  * @author Karl Tauber
  */
 public class FlatDarculaLaf
 	extends FlatDarkLaf
 {
-	public static boolean install( ) {
-		return install( new FlatDarculaLaf() );
+	public static final String NAME = "FlatLaf Darcula";
+
+	/**
+	 * 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 );
 	}
 
 	@Override
 	public String getName() {
-		return "Flat Darcula";
+		return NAME;
 	}
 
 	@Override
 	public String getDescription() {
-		return "Flat Darcula Look and Feel";
+		return "FlatLaf Darcula Look and Feel";
 	}
 }

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

@@ -16,28 +16,56 @@
 
 package com.formdev.flatlaf;
 
+import javax.swing.UIManager;
+
 /**
  * A Flat LaF that has a dark color scheme.
- *
- * The UI defaults are loaded from FlatDarkLaf.properties and FlatLaf.properties
+ * <p>
+ * The UI defaults are loaded from {@code FlatDarkLaf.properties} and {@code FlatLaf.properties}.
  *
  * @author Karl Tauber
  */
 public class FlatDarkLaf
 	extends FlatLaf
 {
-	public static boolean install( ) {
-		return install( new FlatDarkLaf() );
+	public static final String NAME = "FlatLaf Dark";
+
+	/**
+	 * 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 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, FlatDarkLaf.class );
 	}
 
 	@Override
 	public String getName() {
-		return "Flat Dark";
+		return NAME;
 	}
 
 	@Override
 	public String getDescription() {
-		return "Flat Dark Look and Feel";
+		return "FlatLaf Dark Look and Feel";
 	}
 
 	@Override

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

@@ -17,6 +17,8 @@
 package com.formdev.flatlaf;
 
 import java.io.InputStream;
+import javax.swing.LookAndFeel;
+import javax.swing.UIDefaults;
 
 /**
  * Addon for FlatLaf UI defaults.
@@ -24,7 +26,7 @@ import java.io.InputStream;
  * 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>
@@ -45,8 +47,25 @@ public abstract class FlatDefaultsAddon
 	 */
 	public InputStream getDefaults( Class<?> lafClass ) {
 		Class<?> addonClass = this.getClass();
-		String propertiesName = "/" + addonClass.getPackage().getName().replace( '.', '/' )
+		String propertiesName = '/' + addonClass.getPackage().getName().replace( '.', '/' )
 			+ '/' + lafClass.getSimpleName() + ".properties";
 		return addonClass.getResourceAsStream( propertiesName );
 	}
+
+	/**
+	 * Allows modifying UI defaults after loading UI defaults.
+	 * The default implementation does nothing.
+	 */
+	public void afterDefaultsLoading( LookAndFeel laf, UIDefaults defaults ) {
+	}
+
+	/**
+	 * Returns the priority used to sort addon loading.
+	 * The order is only important if you want to overwrite UI defaults of other addons.
+	 * Lower numbers mean higher priority.
+	 * Returns 10000 by default.
+	 */
+	public int getPriority() {
+		return 10000;
+	}
 }

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

@@ -0,0 +1,89 @@
+/*
+ * Copyright 2020 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;
+
+/**
+ * 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
+ * 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.
+ * <p>
+ * Use the {@code *_DARK} colors only in {@code *_dark.svg} files.
+ * <p>
+ * The colors are based on IntelliJ Platform
+ *   <a href="https://jetbrains.design/intellij/principles/icons/#action-icons">Action icons</a>
+ * and
+ *   <a href="https://jetbrains.design/intellij/principles/icons/#noun-icons">Noun icons</a>
+ * <p>
+ * These colors may be changed by IntelliJ Platform themes.
+ * <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 )}.
+ *
+ * @author Karl Tauber
+ */
+public enum FlatIconColors
+{
+	// colors for action icons
+	// see https://jetbrains.design/intellij/principles/icons/#action-icons
+	ACTIONS_RED				( 0xDB5860, "Actions.Red", true, false ),
+	ACTIONS_RED_DARK		( 0xC75450, "Actions.Red", false, true ),
+	ACTIONS_YELLOW			( 0xEDA200, "Actions.Yellow", true, false ),
+	ACTIONS_YELLOW_DARK		( 0xF0A732, "Actions.Yellow", false, true ),
+	ACTIONS_GREEN			( 0x59A869, "Actions.Green", true, false ),
+	ACTIONS_GREEN_DARK		( 0x499C54, "Actions.Green", false, true ),
+	ACTIONS_BLUE			( 0x389FD6, "Actions.Blue", true, false ),
+	ACTIONS_BLUE_DARK		( 0x3592C4, "Actions.Blue", false, true ),
+	ACTIONS_GREY			( 0x6E6E6E, "Actions.Grey", true, false ),
+	ACTIONS_GREY_DARK		( 0xAFB1B3, "Actions.Grey", false, true ),
+	ACTIONS_GREYINLINE		( 0x7F8B91, "Actions.GreyInline", true, false ),
+	ACTIONS_GREYINLINE_DARK	( 0x7F8B91, "Actions.GreyInline", false, true ),
+
+	// colors for object icons
+	// see https://jetbrains.design/intellij/principles/icons/#noun-icons
+	OBJECTS_GREY			( 0x9AA7B0, "Objects.Grey" ),
+	OBJECTS_BLUE			( 0x40B6E0, "Objects.Blue" ),
+	OBJECTS_GREEN			( 0x62B543, "Objects.Green" ),
+	OBJECTS_YELLOW			( 0xF4AF3D, "Objects.Yellow" ),
+	OBJECTS_YELLOW_DARK		( 0xD9A343, "Objects.YellowDark" ),
+	OBJECTS_PURPLE			( 0xB99BF8, "Objects.Purple" ),
+	OBJECTS_PINK			( 0xF98B9E, "Objects.Pink" ),
+	OBJECTS_RED				( 0xF26522, "Objects.Red" ),
+	OBJECTS_RED_STATUS		( 0xE05555, "Objects.RedStatus" ),
+	OBJECTS_GREEN_ANDROID	( 0xA4C639, "Objects.GreenAndroid" ),
+	OBJECTS_BLACK_TEXT		( 0x231F20, "Objects.BlackText" );
+
+	public final int rgb;
+	public final String key;
+
+	public final boolean light;
+	public final boolean dark;
+
+	FlatIconColors( int rgb, String key ) {
+		this( rgb, key, true, true );
+	}
+
+	FlatIconColors( int rgb, String key, boolean light, boolean dark ) {
+		this.rgb = rgb;
+		this.key = key;
+		this.light = light;
+		this.dark = dark;
+	}
+}

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

@@ -0,0 +1,660 @@
+/*
+ * Copyright 2020 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 javax.swing.InputMap;
+import javax.swing.JTextField;
+import javax.swing.KeyStroke;
+import javax.swing.LookAndFeel;
+import javax.swing.UIDefaults;
+import javax.swing.UIDefaults.LazyValue;
+import javax.swing.UIManager;
+import javax.swing.plaf.InputMapUIResource;
+import com.formdev.flatlaf.util.SystemInfo;
+import static javax.swing.text.DefaultEditorKit.*;
+import java.util.function.BooleanSupplier;
+
+/**
+ * @author Karl Tauber
+ */
+class FlatInputMaps
+{
+	static void initInputMaps( UIDefaults defaults ) {
+		initBasicInputMaps( defaults );
+		initTextComponentInputMaps( defaults );
+
+		if( SystemInfo.isMacOS )
+			initMacInputMaps( defaults );
+	}
+
+	private static void initBasicInputMaps( UIDefaults defaults ) {
+		if( SystemInfo.isMacOS ) {
+			defaults.put( "Button.focusInputMap", new UIDefaults.LazyInputMap( new Object[] {
+				"SPACE", "pressed",
+				"released SPACE", "released"
+			} ) );
+		}
+
+		modifyInputMap( defaults, "ComboBox.ancestorInputMap",
+			"SPACE", "spacePopup",
+
+			"UP", mac( "selectPrevious2", "selectPrevious" ),
+			"DOWN", mac( "selectNext2", "selectNext" ),
+			"KP_UP", mac( "selectPrevious2", "selectPrevious" ),
+			"KP_DOWN", mac( "selectNext2", "selectNext" ),
+
+			mac( "alt UP", null ), "togglePopup",
+			mac( "alt DOWN", null ), "togglePopup",
+			mac( "alt KP_UP", null ), "togglePopup",
+			mac( "alt KP_DOWN", null ), "togglePopup"
+		);
+
+		if( !SystemInfo.isMacOS ) {
+			modifyInputMap( defaults, "FileChooser.ancestorInputMap",
+				"F2", "editFileName",
+				"BACK_SPACE", "Go Up"
+			);
+		}
+
+		// 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 ) {
+			Object[] newBindings = new Object[bindings.length + rtlBindings.length];
+			System.arraycopy( bindings, 0, newBindings, 0, bindings.length );
+			System.arraycopy( rtlBindings, 0, newBindings, bindings.length, rtlBindings.length );
+			defaults.put( "PopupMenu.selectedWindowInputMapBindings.RightToLeft", newBindings );
+		}
+
+		modifyInputMap( defaults, "TabbedPane.ancestorInputMap",
+			"ctrl TAB", "navigateNext",
+			"shift ctrl TAB", "navigatePrevious"
+		);
+
+		// swap Home/End with Ctrl+Home/End to make it consistent with List and Tree
+		modifyInputMap( () -> {
+				return UIManager.getBoolean( "Table.consistentHomeEndKeyBehavior" );
+			},
+			defaults, "Table.ancestorInputMap",
+			"HOME", "selectFirstRow",
+			"END", "selectLastRow",
+			"shift HOME", "selectFirstRowExtendSelection",
+			"shift END", "selectLastRowExtendSelection",
+			mac( "ctrl HOME", null ), "selectFirstColumn",
+			mac( "ctrl END", null ), "selectLastColumn",
+			mac( "shift ctrl HOME", null ), "selectFirstColumnExtendSelection",
+			mac( "shift ctrl END", null ), "selectLastColumnExtendSelection"
+		);
+
+		if( !SystemInfo.isMacOS ) {
+			modifyInputMap( defaults, "Tree.focusInputMap",
+				"ADD", "expand",
+				"SUBTRACT", "collapse"
+			);
+		}
+	}
+
+	private static void initTextComponentInputMaps( UIDefaults defaults ) {
+		Object[] commonTextComponentBindings = {
+			// move caret one character (without selecting text)
+			"LEFT", backwardAction,
+			"RIGHT", forwardAction,
+			"KP_LEFT", backwardAction,
+			"KP_RIGHT", forwardAction,
+
+			// move caret one character and select text
+			"shift LEFT", selectionBackwardAction,
+			"shift RIGHT", selectionForwardAction,
+			"shift KP_LEFT", selectionBackwardAction,
+			"shift KP_RIGHT", selectionForwardAction,
+
+			// move caret to word (without selecting text)
+			mac( "ctrl LEFT", "alt LEFT" ), previousWordAction,
+			mac( "ctrl RIGHT", "alt RIGHT" ), nextWordAction,
+			mac( "ctrl KP_LEFT", "alt KP_LEFT" ), previousWordAction,
+			mac( "ctrl KP_RIGHT", "alt KP_RIGHT" ), nextWordAction,
+
+			// move caret to word and select text
+			mac( "ctrl shift LEFT", "shift alt LEFT" ), selectionPreviousWordAction,
+			mac( "ctrl shift RIGHT", "shift alt RIGHT" ), selectionNextWordAction,
+			mac( "ctrl shift KP_LEFT", "shift alt KP_LEFT" ), selectionPreviousWordAction,
+			mac( "ctrl shift KP_RIGHT", "shift alt KP_RIGHT" ), selectionNextWordAction,
+
+			// move caret to line begin/end (without selecting text)
+			mac( "HOME", "meta LEFT" ), beginLineAction,
+			mac( "END", "meta RIGHT" ), endLineAction,
+
+			// move caret to line begin/end and select text
+			mac( "shift HOME", "shift meta LEFT" ), selectionBeginLineAction,
+			mac( "shift END", "shift meta RIGHT" ), selectionEndLineAction,
+
+			// select all/none
+			mac( "ctrl A", "meta A" ), selectAllAction,
+			mac( "ctrl BACK_SLASH", "meta BACK_SLASH" ), "unselect", // DefaultEditorKit.unselectAction
+
+			// delete previous/next character
+			"BACK_SPACE", deletePrevCharAction,
+			"shift BACK_SPACE", deletePrevCharAction,
+			"ctrl H", deletePrevCharAction,
+			"DELETE", deleteNextCharAction,
+
+			// delete previous/next word
+			mac( "ctrl BACK_SPACE", "alt BACK_SPACE" ), deletePrevWordAction,
+			mac( "ctrl DELETE", "alt DELETE" ), deleteNextWordAction,
+
+			// clipboard
+			mac( "ctrl X", "meta X" ), cutAction,
+			mac( "ctrl C", "meta C" ), copyAction,
+			mac( "ctrl V", "meta V" ), pasteAction,
+			"CUT", cutAction,
+			"COPY", copyAction,
+			"PASTE", pasteAction,
+			mac( "shift DELETE", null ), cutAction,
+			mac( "control INSERT", null ), copyAction,
+			mac( "shift INSERT", null ), pasteAction,
+
+			// misc
+			"control shift O", "toggle-componentOrientation", // DefaultEditorKit.toggleComponentOrientation
+		};
+
+		Object[] macCommonTextComponentBindings = SystemInfo.isMacOS ? new Object[] {
+			// move caret one character (without selecting text)
+			"ctrl B", backwardAction,
+			"ctrl F", forwardAction,
+
+			// move caret to document begin/end (without selecting text)
+			"HOME", beginAction,
+			"END", endAction,
+			"meta UP", beginAction,
+			"meta DOWN", endAction,
+			"meta KP_UP", beginAction,
+			"meta KP_DOWN", endAction,
+			"ctrl P", beginAction,
+			"ctrl N", endAction,
+			"ctrl V", endAction,
+
+			// move caret to line begin/end (without selecting text)
+			"meta KP_LEFT", beginLineAction,
+			"meta KP_RIGHT", endLineAction,
+			"ctrl A", beginLineAction,
+			"ctrl E", endLineAction,
+
+			// move caret to document begin/end and select text
+			"shift meta UP", selectionBeginAction,
+			"shift meta DOWN", selectionEndAction,
+			"shift meta KP_UP", selectionBeginAction,
+			"shift meta KP_DOWN", selectionEndAction,
+			"shift HOME", selectionBeginAction,
+			"shift END", selectionEndAction,
+
+			// move caret to line begin/end and select text
+			"shift meta KP_LEFT", selectionBeginLineAction,
+			"shift meta KP_RIGHT", selectionEndLineAction,
+			"shift UP", selectionBeginLineAction,
+			"shift DOWN", selectionEndLineAction,
+			"shift KP_UP", selectionBeginLineAction,
+			"shift KP_DOWN", selectionEndLineAction,
+
+			// delete previous/next word
+			"ctrl W", deletePrevWordAction,
+			"ctrl D", deleteNextCharAction,
+		} : null;
+
+		Object[] singleLineTextComponentBindings = {
+			"ENTER", JTextField.notifyAction,
+		};
+
+		Object[] macSingleLineTextComponentBindings = SystemInfo.isMacOS ? new Object[] {
+			// move caret to line begin/end (without selecting text)
+			"UP", beginLineAction,
+			"DOWN", endLineAction,
+			"KP_UP", beginLineAction,
+			"KP_DOWN", endLineAction,
+		} : null;
+
+		Object[] formattedTextComponentBindings = {
+			// reset
+			"ESCAPE", "reset-field-edit",
+
+			// increment/decrement
+			"UP", "increment",
+			"DOWN", "decrement",
+			"KP_UP", "increment",
+			"KP_DOWN", "decrement",
+		};
+
+		Object[] passwordTextComponentBindings = {
+			// move caret to line begin/end (without selecting text)
+			mac( "ctrl LEFT", "alt LEFT" ), beginLineAction,
+			mac( "ctrl RIGHT", "alt RIGHT" ), endLineAction,
+			mac( "ctrl KP_LEFT", "alt KP_LEFT" ), beginLineAction,
+			mac( "ctrl KP_RIGHT", "alt KP_RIGHT" ), endLineAction,
+
+			// move caret to line begin/end and select text
+			mac( "ctrl shift LEFT", "shift alt LEFT" ), selectionBeginLineAction,
+			mac( "ctrl shift RIGHT", "shift alt RIGHT" ), selectionEndLineAction,
+			mac( "ctrl shift KP_LEFT", "shift alt KP_LEFT" ), selectionBeginLineAction,
+			mac( "ctrl shift KP_RIGHT", "shift alt KP_RIGHT" ), selectionEndLineAction,
+
+			// delete previous/next word
+			mac( "ctrl BACK_SPACE", "alt BACK_SPACE" ), null,
+			mac( "ctrl DELETE", "alt DELETE" ), null,
+		};
+
+		Object[] multiLineTextComponentBindings = {
+			// move caret one line (without selecting text)
+			"UP", upAction,
+			"DOWN", downAction,
+			"KP_UP", upAction,
+			"KP_DOWN", downAction,
+
+			// move caret one line and select text
+			"shift UP", selectionUpAction,
+			"shift DOWN", selectionDownAction,
+			"shift KP_UP", selectionUpAction,
+			"shift KP_DOWN", selectionDownAction,
+
+			// move caret one page (without selecting text)
+			"PAGE_UP", pageUpAction,
+			"PAGE_DOWN", pageDownAction,
+
+			// move caret one page and select text
+			"shift PAGE_UP", "selection-page-up", // DefaultEditorKit.selectionPageUpAction
+			"shift PAGE_DOWN", "selection-page-down", // DefaultEditorKit.selectionPageDownAction
+			mac( "ctrl shift PAGE_UP", "shift meta PAGE_UP" ), "selection-page-left", // DefaultEditorKit.selectionPageLeftAction
+			mac( "ctrl shift PAGE_DOWN", "shift meta PAGE_DOWN" ), "selection-page-right", // DefaultEditorKit.selectionPageRightAction
+
+			// move caret to document begin/end (without selecting text)
+			mac( "ctrl HOME", "meta UP" ), beginAction,
+			mac( "ctrl END", "meta DOWN" ), endAction,
+
+			// move caret to document begin/end and select text
+			mac( "ctrl shift HOME", "shift meta UP" ), selectionBeginAction,
+			mac( "ctrl shift END", "shift meta DOWN" ), selectionEndAction,
+
+			// misc
+			"ENTER", insertBreakAction,
+			"TAB", insertTabAction,
+
+			// links
+			mac( "ctrl T", "meta T" ), "next-link-action",
+			mac( "ctrl shift T", "shift meta T" ), "previous-link-action",
+			mac( "ctrl SPACE", "meta SPACE" ), "activate-link-action",
+		};
+
+		Object[] macMultiLineTextComponentBindings = SystemInfo.isMacOS ? new Object[] {
+			// move caret one line (without selecting text)
+			"ctrl N", downAction,
+			"ctrl P", upAction,
+
+			// move caret to beginning/end of paragraph and select text
+			"shift alt UP", selectionBeginParagraphAction,
+			"shift alt DOWN", selectionEndParagraphAction,
+			"shift alt KP_UP", selectionBeginParagraphAction,
+			"shift alt KP_DOWN", selectionEndParagraphAction,
+
+			// move caret one page (without selecting text)
+			"ctrl V", pageDownAction,
+		} : null;
+
+		defaults.put( "TextField.focusInputMap", new LazyInputMapEx(
+			commonTextComponentBindings,
+			macCommonTextComponentBindings,
+			singleLineTextComponentBindings,
+			macSingleLineTextComponentBindings
+		) );
+		defaults.put( "FormattedTextField.focusInputMap", new LazyInputMapEx(
+			commonTextComponentBindings,
+			macCommonTextComponentBindings,
+			singleLineTextComponentBindings,
+			macSingleLineTextComponentBindings,
+			formattedTextComponentBindings
+		) );
+		defaults.put( "PasswordField.focusInputMap", new LazyInputMapEx(
+			commonTextComponentBindings,
+			macCommonTextComponentBindings,
+			singleLineTextComponentBindings,
+			macSingleLineTextComponentBindings,
+			passwordTextComponentBindings
+		) );
+
+		Object multiLineInputMap = new LazyInputMapEx(
+			commonTextComponentBindings,
+			macCommonTextComponentBindings,
+			multiLineTextComponentBindings,
+			macMultiLineTextComponentBindings
+		);
+		defaults.put( "TextArea.focusInputMap", multiLineInputMap );
+		defaults.put( "TextPane.focusInputMap", multiLineInputMap );
+		defaults.put( "EditorPane.focusInputMap", multiLineInputMap );
+	}
+
+	private static void initMacInputMaps( UIDefaults defaults ) {
+		// list
+		modifyInputMap( defaults, "List.focusInputMap",
+			"meta A", "selectAll",
+			"meta C", "copy",
+			"meta V", "paste",
+			"meta X", "cut",
+
+			// let parent scroll pane do the macOS typical scrolling without changing selection
+			"HOME", null,
+			"END", null,
+			"PAGE_UP", null,
+			"PAGE_DOWN", null,
+
+			"ctrl A", null,
+			"ctrl BACK_SLASH", null,
+			"ctrl C", null,
+			"ctrl DOWN", null,
+			"ctrl END", null,
+			"ctrl HOME", null,
+			"ctrl INSERT", null,
+			"ctrl KP_DOWN", null,
+			"ctrl KP_LEFT", null,
+			"ctrl KP_RIGHT", null,
+			"ctrl KP_UP", null,
+			"ctrl LEFT", null,
+			"ctrl PAGE_DOWN", null,
+			"ctrl PAGE_UP", null,
+			"ctrl RIGHT", null,
+			"ctrl SLASH", null,
+			"ctrl SPACE", null,
+			"ctrl UP", null,
+			"ctrl V", null,
+			"ctrl X", null,
+			"SPACE", null,
+			"shift ctrl DOWN", null,
+			"shift ctrl END", null,
+			"shift ctrl HOME", null,
+			"shift ctrl KP_DOWN", null,
+			"shift ctrl KP_LEFT", null,
+			"shift ctrl KP_RIGHT", null,
+			"shift ctrl KP_UP", null,
+			"shift ctrl LEFT", null,
+			"shift ctrl PAGE_DOWN", null,
+			"shift ctrl PAGE_UP", null,
+			"shift ctrl RIGHT", null,
+			"shift ctrl SPACE", null,
+			"shift ctrl UP", null,
+			"shift DELETE", null,
+			"shift INSERT", null,
+			"shift SPACE", null
+		);
+		modifyInputMap( defaults, "List.focusInputMap.RightToLeft",
+			"ctrl KP_LEFT", null,
+			"ctrl KP_RIGHT", null,
+			"ctrl LEFT", null,
+			"ctrl RIGHT", null,
+			"shift ctrl KP_LEFT", null,
+			"shift ctrl KP_RIGHT", null,
+			"shift ctrl LEFT", null,
+			"shift ctrl RIGHT", null
+		);
+
+		// scrollpane
+		modifyInputMap( defaults, "ScrollPane.ancestorInputMap",
+			"END", "scrollEnd",
+			"HOME", "scrollHome",
+
+			"ctrl END", null,
+			"ctrl HOME", null,
+			"ctrl PAGE_DOWN", null,
+			"ctrl PAGE_UP", null
+		);
+		modifyInputMap( defaults, "ScrollPane.ancestorInputMap.RightToLeft",
+			"ctrl PAGE_DOWN", null,
+			"ctrl PAGE_UP", null
+		);
+
+		// tabbedpane
+		modifyInputMap( defaults, "TabbedPane.ancestorInputMap",
+			"ctrl UP", null,
+			"ctrl KP_UP", null
+		);
+		modifyInputMap( defaults, "TabbedPane.focusInputMap",
+			"ctrl DOWN", null,
+			"ctrl KP_DOWN", null
+		);
+
+		// table
+		modifyInputMap( defaults, "Table.ancestorInputMap",
+			"alt TAB", "focusHeader",
+			"shift alt TAB", "focusHeader",
+			"meta A", "selectAll",
+			"meta C", "copy",
+			"meta V", "paste",
+			"meta X", "cut",
+
+			// let parent scroll pane do the macOS typical scrolling without changing selection
+			"HOME", null,
+			"END", null,
+			"PAGE_UP", null,
+			"PAGE_DOWN", null,
+
+			"ctrl A", null,
+			"ctrl BACK_SLASH", null,
+			"ctrl C", null,
+			"ctrl DOWN", null,
+			"ctrl END", null,
+			"ctrl HOME", null,
+			"ctrl INSERT", null,
+			"ctrl KP_DOWN", null,
+			"ctrl KP_LEFT", null,
+			"ctrl KP_RIGHT", null,
+			"ctrl KP_UP", null,
+			"ctrl LEFT", null,
+			"ctrl PAGE_DOWN", null,
+			"ctrl PAGE_UP", null,
+			"ctrl RIGHT", null,
+			"ctrl SLASH", null,
+			"ctrl SPACE", null,
+			"ctrl UP", null,
+			"ctrl V", null,
+			"ctrl X", null,
+			"F2", null,
+			"F8", null,
+			"SPACE", null,
+			"shift ctrl DOWN", null,
+			"shift ctrl END", null,
+			"shift ctrl HOME", null,
+			"shift ctrl KP_DOWN", null,
+			"shift ctrl KP_LEFT", null,
+			"shift ctrl KP_RIGHT", null,
+			"shift ctrl KP_UP", null,
+			"shift ctrl LEFT", null,
+			"shift ctrl PAGE_DOWN", null,
+			"shift ctrl PAGE_UP", null,
+			"shift ctrl RIGHT", null,
+			"shift ctrl SPACE", null,
+			"shift ctrl UP", null,
+			"shift DELETE", null,
+			"shift INSERT", null,
+			"shift SPACE", null
+		);
+		modifyInputMap( defaults, "Table.ancestorInputMap.RightToLeft",
+			"ctrl KP_LEFT", null,
+			"ctrl KP_RIGHT", null,
+			"ctrl LEFT", null,
+			"ctrl RIGHT", null,
+			"shift ctrl KP_LEFT", null,
+			"shift ctrl KP_RIGHT", null,
+			"shift ctrl LEFT", null,
+			"shift ctrl RIGHT", null
+		);
+
+		// tree node expanding/collapsing
+		modifyInputMap( defaults, "Tree.focusInputMap",
+			"LEFT", "selectParent",
+			"RIGHT", "selectChild",
+			"KP_LEFT", "selectParent",
+			"KP_RIGHT", "selectChild",
+			"shift LEFT", "selectParent",
+			"shift RIGHT", "selectChild",
+			"shift KP_LEFT", "selectParent",
+			"shift KP_RIGHT", "selectChild",
+			"alt LEFT", "selectParent",
+			"alt RIGHT", "selectChild",
+			"alt KP_LEFT", "selectParent",
+			"alt KP_RIGHT", "selectChild",
+
+			"shift HOME", "selectFirstExtendSelection",
+			"shift END", "selectLastExtendSelection",
+
+		    "meta A", "selectAll",
+		    "meta C", "copy",
+		    "meta V", "paste",
+		    "meta X", "cut",
+
+			// let parent scroll pane do the macOS typical scrolling without changing selection
+			"HOME", null,
+			"END", null,
+			"PAGE_UP", null,
+			"PAGE_DOWN", null,
+
+		    "ctrl LEFT", null,
+			"ctrl RIGHT", null,
+			"ctrl KP_LEFT", null,
+			"ctrl KP_RIGHT", null,
+
+			"ctrl A", null,
+			"ctrl BACK_SLASH", null,
+			"ctrl C", null,
+			"ctrl DOWN", null,
+			"ctrl END", null,
+			"ctrl HOME", null,
+			"ctrl INSERT", null,
+			"ctrl KP_DOWN", null,
+			"ctrl KP_UP", null,
+			"ctrl PAGE_DOWN", null,
+			"ctrl PAGE_UP", null,
+			"ctrl SLASH", null,
+			"ctrl SPACE", null,
+			"ctrl UP", null,
+			"ctrl V", null,
+			"ctrl X", null,
+			"F2", null,
+			"SPACE", null,
+			"shift ctrl DOWN", null,
+			"shift ctrl END", null,
+			"shift ctrl HOME", null,
+			"shift ctrl KP_DOWN", null,
+			"shift ctrl KP_UP", null,
+			"shift ctrl PAGE_DOWN", null,
+			"shift ctrl PAGE_UP", null,
+			"shift ctrl SPACE", null,
+			"shift ctrl UP", null,
+			"shift DELETE", null,
+			"shift INSERT", null,
+			"shift PAGE_DOWN", null,
+			"shift PAGE_UP", null,
+			"shift SPACE", null
+		);
+		defaults.put( "Tree.focusInputMap.RightToLeft", new UIDefaults.LazyInputMap( new Object[] {
+			"LEFT", "selectChild",
+			"RIGHT", "selectParent",
+			"KP_LEFT", "selectChild",
+			"KP_RIGHT", "selectParent",
+			"shift LEFT", "selectChild",
+			"shift RIGHT", "selectParent",
+			"shift KP_LEFT", "selectChild",
+			"shift KP_RIGHT", "selectParent",
+			"alt LEFT", "selectChild",
+			"alt RIGHT", "selectParent",
+			"alt KP_LEFT", "selectChild",
+			"alt KP_RIGHT", "selectParent"
+		} ) );
+	}
+
+	private static void modifyInputMap( UIDefaults defaults, String key, Object... bindings ) {
+		modifyInputMap( null, defaults, key, bindings );
+	}
+
+	private static void modifyInputMap( BooleanSupplier condition, UIDefaults defaults, String key, Object... bindings ) {
+		// Note: not using `defaults.get(key)` here because this would resolve a lazy value
+		defaults.put( key, new LazyModifyInputMap( condition, defaults.remove( key ), bindings ) );
+	}
+
+	private static <T> T mac( T value, T macValue ) {
+		return SystemInfo.isMacOS ? macValue : value;
+	}
+
+	//---- class LazyInputMapEx -----------------------------------------------
+
+	/**
+	 * Lazily creates an input map.
+	 * Similar to {@link UIDefaults.LazyInputMap}, but can use multiple bindings arrays.
+	 */
+	private static class LazyInputMapEx
+		implements LazyValue
+	{
+		private final Object[][] bindingsArray;
+
+		LazyInputMapEx( Object[]... bindingsArray ) {
+			this.bindingsArray = bindingsArray;
+		}
+
+		@Override
+		public Object createValue( UIDefaults table ) {
+			InputMap inputMap = new InputMapUIResource();
+			for( Object[] bindings : bindingsArray )
+				LookAndFeel.loadKeyBindings( inputMap, bindings );
+			return inputMap;
+		}
+	}
+
+	//---- class LazyModifyInputMap -------------------------------------------
+
+	/**
+	 * Takes a (lazy) base input map and lazily applies modifications to it specified in bindings.
+	 */
+	private static class LazyModifyInputMap
+		implements LazyValue
+	{
+		private final BooleanSupplier condition;
+		private final Object baseInputMap;
+		private final Object[] bindings;
+
+		LazyModifyInputMap( BooleanSupplier condition, Object baseInputMap, Object[] bindings ) {
+			this.condition = condition;
+			this.baseInputMap = baseInputMap;
+			this.bindings = bindings;
+		}
+
+		@Override
+		public Object createValue( UIDefaults table ) {
+			// get base input map
+			InputMap inputMap = (baseInputMap instanceof LazyValue)
+				? (InputMap) ((LazyValue)baseInputMap).createValue( table )
+				: (InputMap) baseInputMap;
+
+			if( condition != null && !condition.getAsBoolean() )
+				return inputMap;
+
+			// modify input map (replace or remove)
+			for( int i = 0; i < bindings.length; i += 2 ) {
+				KeyStroke keyStroke = KeyStroke.getKeyStroke( (String) bindings[i] );
+				if( bindings[i + 1] != null )
+					inputMap.put( keyStroke, bindings[i + 1] );
+				else
+					inputMap.remove( keyStroke );
+			}
+
+			return inputMap;
+		}
+	}
+}

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

@@ -16,27 +16,56 @@
 
 package com.formdev.flatlaf;
 
+import javax.swing.UIManager;
+
 /**
  * A Flat LaF that has a light color scheme and looks like IntelliJ LaF.
- *
- * The UI defaults are loaded from FlatIntelliJLaf.properties, FlatLightLaf.properties and FlatLaf.properties
+ * <p>
+ * The UI defaults are loaded from {@code FlatIntelliJLaf.properties},
+ * {@code FlatLightLaf.properties} and {@code FlatLaf.properties}.
  *
  * @author Karl Tauber
  */
 public class FlatIntelliJLaf
 	extends FlatLightLaf
 {
-	public static boolean install( ) {
-		return install( new FlatIntelliJLaf() );
+	public static final String NAME = "FlatLaf IntelliJ";
+
+	/**
+	 * 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 );
 	}
 
 	@Override
 	public String getName() {
-		return "Flat IntelliJ";
+		return NAME;
 	}
 
 	@Override
 	public String getDescription() {
-		return "Flat IntelliJ Look and Feel";
+		return "FlatLaf IntelliJ Look and Feel";
 	}
 }

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

@@ -16,28 +16,56 @@
 
 package com.formdev.flatlaf;
 
+import javax.swing.UIManager;
+
 /**
  * A Flat LaF that has a light color scheme.
- *
- * The UI defaults are loaded from FlatLightLaf.properties and FlatLaf.properties
+ * <p>
+ * The UI defaults are loaded from {@code FlatLightLaf.properties} and {@code FlatLaf.properties}.
  *
  * @author Karl Tauber
  */
 public class FlatLightLaf
 	extends FlatLaf
 {
-	public static boolean install( ) {
-		return install( new FlatLightLaf() );
+	public static final String NAME = "FlatLaf Light";
+
+	/**
+	 * 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 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, FlatLightLaf.class );
 	}
 
 	@Override
 	public String getName() {
-		return "Flat Light";
+		return NAME;
 	}
 
 	@Override
 	public String getDescription() {
-		return "Flat Light Look and Feel";
+		return "FlatLaf Light Look and Feel";
 	}
 
 	@Override

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

@@ -0,0 +1,126 @@
+/*
+ * Copyright 2020 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.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.ArrayList;
+import java.util.Properties;
+
+/**
+ * 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}.
+ * <p>
+ * The properties are applied after loading the base theme and may overwrite base properties.
+ * All features of FlatLaf properties files are available.
+ *
+ * @author Karl Tauber
+ */
+public class FlatPropertiesLaf
+	extends FlatLaf
+{
+	private final String name;
+	private final String baseTheme;
+	private final boolean dark;
+	private final Properties properties;
+
+	public FlatPropertiesLaf( String name, File propertiesFile )
+		throws IOException
+	{
+		this( name, new FileInputStream( propertiesFile ) );
+	}
+
+	public FlatPropertiesLaf( String name, InputStream in )
+		throws IOException
+	{
+		this( name, loadProperties( in ) );
+	}
+
+	private static Properties loadProperties( InputStream in )
+		throws IOException
+	{
+		Properties properties = new Properties();
+		try( InputStream in2 = in ) {
+			properties.load( in2 );
+		}
+		return properties;
+	}
+
+	public FlatPropertiesLaf( String name, Properties properties ) {
+		this.name = name;
+		this.properties = properties;
+
+		baseTheme = properties.getProperty( "@baseTheme", "light" );
+		dark = "dark".equalsIgnoreCase( baseTheme ) || "darcula".equalsIgnoreCase( baseTheme );
+	}
+
+	@Override
+	public String getName() {
+		return name;
+	}
+
+	@Override
+	public String getDescription() {
+		return name;
+	}
+
+	@Override
+	public boolean isDark() {
+		return dark;
+	}
+
+	public Properties getProperties() {
+		return properties;
+	}
+
+	@Override
+	protected ArrayList<Class<?>> getLafClassesForDefaultsLoading() {
+		ArrayList<Class<?>> lafClasses = new ArrayList<>();
+		lafClasses.add( FlatLaf.class );
+		switch( baseTheme.toLowerCase() ) {
+			default:
+			case "light":
+				lafClasses.add( FlatLightLaf.class );
+				break;
+
+			case "dark":
+				lafClasses.add( FlatDarkLaf.class );
+				break;
+
+			case "intellij":
+				lafClasses.add( FlatLightLaf.class );
+				lafClasses.add( FlatIntelliJLaf.class );
+				break;
+
+			case "darcula":
+				lafClasses.add( FlatDarkLaf.class );
+				lafClasses.add( FlatDarculaLaf.class );
+				break;
+		}
+		return lafClasses;
+	}
+
+	@Override
+	protected Properties getAdditionalDefaults() {
+		return properties;
+	}
+}

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

@@ -0,0 +1,199 @@
+/*
+ * Copyright 2020 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 javax.swing.SwingUtilities;
+import com.formdev.flatlaf.util.UIScale;
+
+/**
+ * Defines/documents own system properties used in FlatLaf.
+ *
+ * @author Karl Tauber
+ */
+public interface FlatSystemProperties
+{
+	/**
+	 * Specifies a custom scale factor used to scale the UI.
+	 * <p>
+	 * If Java runtime scales (Java 9 or later), this scale factor is applied on top
+	 * of the Java system scale factor. Java 8 does not scale and this scale factor
+	 * replaces the user scale factor that FlatLaf computes based on the font.
+	 * 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";
+
+	/**
+	 * Specifies whether user scaling mode is enabled.
+	 * <p>
+	 * <strong>Allowed Values</strong> {@code false} and {@code true}<br>
+	 * <strong>Default</strong> {@code true}
+	 */
+	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
+	 * is used because there are rendering issues (in Java) with Ubuntu fonts.
+	 * <p>
+	 * <strong>Allowed Values</strong> {@code false} and {@code true}<br>
+	 * <strong>Default</strong> {@code false}
+	 */
+	String USE_UBUNTU_FONT = "flatlaf.useUbuntuFont";
+
+	/**
+	 * Specifies whether native window decorations should be used
+	 * when creating {@code JFrame} or {@code JDialog}.
+	 * <p>
+	 * 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>
+	 * This system property has higher priority than client property
+	 * {@link FlatClientProperties#USE_WINDOW_DECORATIONS} and
+	 * UI default {@code TitlePane.useWindowDecorations}.
+	 * <p>
+	 * (requires Window 10/11)
+	 * <p>
+	 * <strong>Allowed Values</strong> {@code false} and {@code true}<br>
+	 * <strong>Default</strong> none
+	 */
+	String USE_WINDOW_DECORATIONS = "flatlaf.useWindowDecorations";
+
+	/**
+	 * 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://github.com/JetBrains/JetBrainsRuntime/wiki">JetBrains Runtime</a>
+	 * (based on OpenJDK).
+	 * <p>
+	 * Setting this to {@code false} disables using JetBrains Runtime custom window decorations.
+	 * Then FlatLaf native window decorations are used.
+	 * <p>
+	 * (requires Window 10/11)
+	 * <p>
+	 * <strong>Allowed Values</strong> {@code false} and {@code true}<br>
+	 * <strong>Default</strong> {@code false} (since v2; was {@code true} in v1)
+	 */
+	String USE_JETBRAINS_CUSTOM_DECORATIONS = "flatlaf.useJetBrainsCustomDecorations";
+
+	/**
+	 * Specifies whether the menu bar is embedded into the window title pane
+	 * if window decorations are enabled.
+	 * <p>
+	 * 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 Window 10/11)
+	 * <p>
+	 * <strong>Allowed Values</strong> {@code false} and {@code true}<br>
+	 * <strong>Default</strong> none
+	 */
+	String MENUBAR_EMBEDDED = "flatlaf.menuBarEmbedded";
+
+	/**
+	 * Specifies whether animations are enabled.
+	 * <p>
+	 * <strong>Allowed Values</strong> {@code false} and {@code true}<br>
+	 * <strong>Default</strong> {@code true}
+	 */
+	String ANIMATION = "flatlaf.animation";
+
+	/**
+	 * Specifies whether vertical text position is corrected when UI is scaled on HiDPI screens.
+	 * <p>
+	 * <strong>Allowed Values</strong> {@code false} and {@code true}<br>
+	 * <strong>Default</strong> {@code true}
+	 */
+	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 a directory in which the native FlatLaf libraries have been extracted.
+	 * 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"}, then {@link System#loadLibrary(String)} is
+	 * used to load the native library.
+	 * 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}.
+	 * (supported since FlatLaf 2.6)
+	 * <p>
+	 * If the native library can not 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.
+	 *
+	 * @since 2
+	 */
+	String NATIVE_LIBRARY_PATH = "flatlaf.nativeLibraryPath";
+
+	/**
+	 * Checks whether a system property is set and returns {@code true} if its value
+	 * is {@code "true"} (case-insensitive), otherwise it returns {@code false}.
+	 * If the system property is not set, {@code defaultValue} is returned.
+	 */
+	static boolean getBoolean( String key, boolean defaultValue ) {
+		String value = System.getProperty( key );
+		return (value != null) ? Boolean.parseBoolean( value ) : defaultValue;
+	}
+
+	/**
+	 * Checks whether a system property is set and returns {@code Boolean.TRUE} if its value
+	 * is {@code "true"} (case-insensitive) or returns {@code Boolean.FALSE} if its value
+	 * is {@code "false"} (case-insensitive). Otherwise {@code defaultValue} is returned.
+	 */
+	static Boolean getBooleanStrict( String key, Boolean defaultValue ) {
+		String value = System.getProperty( key );
+		if( "true".equalsIgnoreCase( value ) )
+			return Boolean.TRUE;
+		if( "false".equalsIgnoreCase( value ) )
+			return Boolean.FALSE;
+		return defaultValue;
+	}
+}

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

@@ -16,6 +16,7 @@
 
 package com.formdev.flatlaf;
 
+import java.awt.Color;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.InputStreamReader;
@@ -29,12 +30,14 @@ import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
-import java.util.logging.Level;
 import javax.swing.UIDefaults;
 import javax.swing.plaf.ColorUIResource;
 import com.formdev.flatlaf.json.Json;
 import com.formdev.flatlaf.json.ParseException;
+import com.formdev.flatlaf.util.ColorFunctions;
+import com.formdev.flatlaf.util.LoggingFacade;
 import com.formdev.flatlaf.util.StringUtils;
+import com.formdev.flatlaf.util.SystemInfo;
 
 /**
  * This class supports loading IntelliJ .theme.json files and using them as a Laf.
@@ -56,6 +59,8 @@ public class IntelliJTheme
 	public final boolean dark;
 	public final String author;
 
+	private final boolean isMaterialUILite;
+
 	private final Map<String, String> colors;
 	private final Map<String, Object> ui;
 	private final Map<String, Object> icons;
@@ -64,20 +69,30 @@ public class IntelliJTheme
 
 	/**
 	 * 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 ) {
-			FlatLaf.LOG.log( Level.SEVERE, "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.
@@ -86,7 +101,7 @@ public class IntelliJTheme
 	 * Using a buffered input stream is not necessary.
 	 */
 	public static FlatLaf createLaf( InputStream in )
-		throws IOException, ParseException
+		throws IOException
 	{
 		return createLaf( new IntelliJTheme( in ) );
 	}
@@ -106,17 +121,21 @@ public class IntelliJTheme
 	 */
 	@SuppressWarnings( "unchecked" )
 	public IntelliJTheme( InputStream in )
-		throws IOException, ParseException
+		throws IOException
 	{
 		Map<String, Object> json;
 	    try( Reader reader = new InputStreamReader( in, StandardCharsets.UTF_8 ) ) {
 	    		json = (Map<String, Object>) Json.parse( reader );
+		} catch( ParseException ex ) {
+			throw new IOException( ex.getMessage(), ex );
 		}
 
 	    name = (String) json.get( "name" );
 	    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" );
@@ -132,6 +151,8 @@ public class IntelliJTheme
 		defaults.put( "Button.paintShadow", true );
 		defaults.put( "Button.shadowWidth", dark ? 2 : 1 );
 
+		Map<Object, Object> themeSpecificDefaults = removeThemeSpecificDefaults( defaults );
+
 		loadNamedColors( defaults );
 
 		// convert Json "ui" structure to UI defaults
@@ -143,7 +164,24 @@ public class IntelliJTheme
 		applyColorPalette( defaults );
 		applyCheckBoxColors( defaults );
 
-		// IDEA uses a SVG icon for the help button, but paints the background with Button.startBackground and Button.endBackground
+		// copy values
+		for( Map.Entry<String, String> e : uiKeyCopying.entrySet() ) {
+			Object value = defaults.get( e.getValue() );
+			if( value != null )
+				defaults.put( 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 );
+
+		// 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 an 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 )
@@ -152,7 +190,7 @@ public class IntelliJTheme
 			helpButtonBorderColor = defaults.get( "Button.borderColor" );
 		defaults.put( "HelpButton.background", helpButtonBackground );
 		defaults.put( "HelpButton.borderColor", helpButtonBorderColor );
-		defaults.put( "HelpButton.disabledBackground", defaults.get( "Panel.background" ) );
+		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" ) );
@@ -183,6 +221,74 @@ public class IntelliJTheme
 			if( !uiKeys.contains( "Spinner.background" ) )
 				defaults.put( "Spinner.background", textFieldBackground );
 		}
+
+		// 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 DesktopPane background (use Panel.background and make it 5% darker/lighter)
+		Color desktopBackgroundBase = defaults.getColor( "Panel.background" );
+		Color desktopBackground = ColorFunctions.applyFunctions( desktopBackgroundBase,
+			new ColorFunctions.HSLIncreaseDecrease( 2, dark, 5, false, true ) );
+		defaults.put( "Desktop.background", new ColorUIResource( desktopBackground ) );
+
+		// fix List and Table background colors in Material UI Lite themes
+		if( isMaterialUILite ) {
+			defaults.put( "List.background", defaults.get( "Tree.background" ) );
+			defaults.put( "Table.background", defaults.get( "Tree.background" ) );
+		}
+
+		// limit tree row height
+		int rowHeight = defaults.getInt( "Tree.rowHeight" );
+		if( rowHeight > 22 )
+			defaults.put( "Tree.rowHeight", 22 );
+
+		// apply theme specific UI defaults at the end to allow overwriting
+		for( Map.Entry<Object, Object> e : themeSpecificDefaults.entrySet() ) {
+			Object key = e.getKey();
+			Object value = e.getValue();
+
+			// append styles to existing styles
+			if( key instanceof String && ((String)key).startsWith( "[style]" ) ) {
+				Object oldValue = defaults.get( key );
+				if( oldValue != null )
+					value = oldValue + "; " + value;
+			}
+
+			defaults.put( key, value );
+		}
+	}
+
+	private Map<Object, Object> removeThemeSpecificDefaults( UIDefaults defaults ) {
+		// search for theme specific UI defaults keys
+		ArrayList<String> themeSpecificKeys = new ArrayList<>();
+		for( Object key : defaults.keySet() ) {
+			if( key instanceof String && ((String)key).startsWith( "[" ) && !((String)key).startsWith( "[style]" ) )
+				themeSpecificKeys.add( (String) key );
+		}
+
+		// remove theme specific UI defaults and remember only those for current theme
+		Map<Object, Object> themeSpecificDefaults = new HashMap<>();
+		String currentThemePrefix = '[' + name.replace( ' ', '_' ) + ']';
+		String currentThemeAndAuthorPrefix = '[' + name.replace( ' ', '_' ) + "---" + author.replace( ' ', '_' ) + ']';
+		String currentAuthorPrefix = "[author-" + author.replace( ' ', '_' ) + ']';
+		String allThemesPrefix = "[*]";
+		String[] prefixes = { currentThemePrefix, currentThemeAndAuthorPrefix, currentAuthorPrefix, allThemesPrefix };
+		for( String key : themeSpecificKeys ) {
+			Object value = defaults.remove( key );
+			for( String prefix : prefixes ) {
+				if( key.startsWith( prefix ) ) {
+					themeSpecificDefaults.put( key.substring( prefix.length() ), value );
+					break;
+				}
+			}
+		}
+
+		return themeSpecificDefaults;
 	}
 
 	/**
@@ -196,11 +302,11 @@ public class IntelliJTheme
 
 		for( Map.Entry<String, String> e : colors.entrySet() ) {
 			String value = e.getValue();
-			ColorUIResource color = UIDefaultsLoader.parseColor( value );
+			ColorUIResource color = parseColor( value );
 			if( color != null ) {
 				String key = e.getKey();
 				namedColors.put( key, color );
-				defaults.put( "ColorPalette." + e.getKey(), color );
+				defaults.put( "ColorPalette." + key, color );
 			}
 		}
 	}
@@ -211,11 +317,29 @@ public class IntelliJTheme
 	@SuppressWarnings( "unchecked" )
 	private void apply( String key, Object value, UIDefaults defaults, ArrayList<Object> defaultsKeysCache, Set<String> uiKeys ) {
 		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 ), defaults, defaultsKeysCache, uiKeys );
+				else if( map.containsKey( "os.default" ) )
+					apply( key, map.get( "os.default" ), defaults, defaultsKeysCache, uiKeys );
+			} else {
+				for( Map.Entry<String, Object> e : map.entrySet() )
+					apply( key + '.' + e.getKey(), e.getValue(), defaults, defaultsKeysCache, uiKeys );
+			}
 		} else {
+			if( "".equals( value ) )
+				return; // ignore empty value
+
 			uiKeys.add( key );
 
+			// fix ComboBox size and Spinner border in all Material UI Lite themes
+			if( isMaterialUILite && (key.equals( "ComboBox.padding" ) || key.equals( "Spinner.border" )) )
+				return; // ignore
+
 			// map keys
 			key = uiKeyMapping.getOrDefault( key, key );
 			if( key.isEmpty() )
@@ -243,9 +367,9 @@ public class IntelliJTheme
 
 				// parse value
 				try {
-					uiValue = UIDefaultsLoader.parseValue( key, valueStr );
+					uiValue = UIDefaultsLoader.parseValue( key, valueStr, null );
 				} catch( RuntimeException ex ) {
-					UIDefaultsLoader.logParseError( Level.CONFIG, key, valueStr, ex );
+					UIDefaultsLoader.logParseError( key, valueStr, ex, false );
 					return; // ignore invalid value
 				}
 			}
@@ -265,12 +389,16 @@ public class IntelliJTheme
 
 				// replace all values in UI defaults that match the wildcard key
 				for( Object k : defaultsKeysCache ) {
+					if( k.equals( "Desktop.background" ) ||
+						k.equals( "DesktopIcon.background" ) )
+					  continue;
+
 					if( k instanceof String ) {
 						// support replacing of mapped keys
 						// (e.g. set ComboBox.buttonEditableBackground to *.background
 						// because it is mapped from ComboBox.ArrowButton.background)
 						String km = uiKeyInverseMapping.getOrDefault( k, (String) k );
-						if( km.endsWith( tail ) && !noWildcardReplace.contains( k ) && !((String)k).startsWith( "CheckBox.icon." ) )
+						if( km.endsWith( tail ) && !((String)k).startsWith( "CheckBox.icon." ) )
 							defaults.put( k, uiValue );
 					}
 				}
@@ -320,11 +448,19 @@ public class IntelliJTheme
 		ColorUIResource color = namedColors.get( value );
 
 		// parse color
-		return (color != null) ? color : UIDefaultsLoader.parseColor( value );
+		return (color != null) ? color : parseColor( value );
+	}
+
+	private ColorUIResource parseColor( String value ) {
+		try {
+			return UIDefaultsLoader.parseColor( value );
+		} catch( IllegalArgumentException ex ) {
+			return null;
+		}
 	}
 
 	/**
-	 * Because IDEA uses SVGs for check boxes and radio buttons the colors for
+	 * 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.
 	 */
@@ -362,6 +498,10 @@ public class IntelliJTheme
 
 			String newKey = checkboxKeyMapping.get( key );
 			if( newKey != null ) {
+				String checkBoxIconPrefix = "CheckBox.icon.";
+				if( !dark && newKey.startsWith( checkBoxIconPrefix ) )
+					newKey = "CheckBox.icon[filled].".concat( newKey.substring( checkBoxIconPrefix.length() ) );
+
 				ColorUIResource color = toColor( (String) value );
 				if( color != null ) {
 					defaults.put( newKey, color );
@@ -392,22 +532,51 @@ public class IntelliJTheme
 			}
 		}
 
-		// remove hover and pressed colors
+		// update hover, pressed and focused colors
 		if( checkboxModified ) {
-			defaults.remove( "CheckBox.icon.hoverBorderColor" );
-			defaults.remove( "CheckBox.icon.focusedBackground" );
-			defaults.remove( "CheckBox.icon.hoverBackground" );
-			defaults.remove( "CheckBox.icon.pressedBackground" );
-			defaults.remove( "CheckBox.icon.selectedHoverBackground" );
-			defaults.remove( "CheckBox.icon.selectedPressedBackground" );
+			// for non-filled checkbox/radiobutton used in dark themes
+			defaults.remove( "CheckBox.icon.focusWidth" );
+			defaults.put( "CheckBox.icon.hoverBorderColor", defaults.get( "CheckBox.icon.focusedBorderColor" ) );
+
+			// for filled checkbox/radiobutton used in light themes
+			defaults.remove( "CheckBox.icon[filled].focusWidth" );
+			defaults.put( "CheckBox.icon[filled].hoverBorderColor", defaults.get( "CheckBox.icon[filled].focusedBorderColor" ) );
+			defaults.put( "CheckBox.icon[filled].focusedSelectedBackground", defaults.get( "CheckBox.icon[filled].selectedBackground" ) );
+
+			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 = {
+					"CheckBox.icon.focusedBorderColor",
+					"CheckBox.icon.focusedSelectedBorderColor",
+					"CheckBox.icon[filled].focusedBorderColor",
+					"CheckBox.icon[filled].focusedSelectedBorderColor",
+				};
+				for( String key : focusedBorderColorKeys ) {
+					Color color = defaults.getColor( key );
+					if( color != null ) {
+						defaults.put( key, new ColorUIResource( new Color(
+							(color.getRGB() & 0xffffff) | 0xa6000000, true ) ) );
+					}
+				}
+			}
 		}
 	}
 
-	private static Map<String, String> uiKeyMapping = 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 Set<String> noWildcardReplace = new HashSet<>();
+	private void copyIfNotSet( UIDefaults defaults, String destKey, String srcKey, Set<String> uiKeys ) {
+		if( !uiKeys.contains( destKey ) )
+			defaults.put( destKey, defaults.get( srcKey ) );
+	}
+
+	/** Rename UI default keys (key --> value). */
+	private static final Map<String, String> uiKeyMapping = new HashMap<>();
+	/** Copy UI default keys (value --> key). */
+	private static final Map<String, String> uiKeyCopying = new HashMap<>();
+	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 {
 		// ComboBox
@@ -417,15 +586,39 @@ public class IntelliJTheme
 		uiKeyMapping.put( "ComboBox.ArrowButton.disabledIconColor",     "ComboBox.buttonDisabledArrowColor" );
 		uiKeyMapping.put( "ComboBox.ArrowButton.iconColor",             "ComboBox.buttonArrowColor" );
 		uiKeyMapping.put( "ComboBox.ArrowButton.nonEditableBackground", "ComboBox.buttonBackground" );
+		uiKeyCopying.put( "ComboBox.buttonSeparatorColor",              "Component.borderColor" );
+		uiKeyCopying.put( "ComboBox.buttonDisabledSeparatorColor",      "Component.disabledBorderColor" );
+
+		// Component
+		uiKeyMapping.put( "Component.inactiveErrorFocusColor",   "Component.error.borderColor" );
+		uiKeyMapping.put( "Component.errorFocusColor",           "Component.error.focusedBorderColor" );
+		uiKeyMapping.put( "Component.inactiveWarningFocusColor", "Component.warning.borderColor" );
+		uiKeyMapping.put( "Component.warningFocusColor",         "Component.warning.focusedBorderColor" );
 
 		// Link
 		uiKeyMapping.put( "Link.activeForeground", "Component.linkColor" );
 
+		// 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" );
+		uiKeyCopying.put( "MenuItem.selectionBackground",            "List.selectionBackground" );
+		uiKeyCopying.put( "CheckBoxMenuItem.selectionBackground",    "List.selectionBackground" );
+		uiKeyCopying.put( "RadioButtonMenuItem.selectionBackground", "List.selectionBackground" );
+
 		// ProgressBar
 		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" );
 
 		// ScrollBar
 		uiKeyMapping.put( "ScrollBar.trackColor", "ScrollBar.track" );
@@ -436,21 +629,44 @@ public class IntelliJTheme
 
 		// Slider
 		uiKeyMapping.put( "Slider.trackWidth", "" ); // ignore (used in Material Theme UI Lite)
+		uiKeyCopying.put( "Slider.trackValueColor", "ProgressBar.foreground" );
+		uiKeyCopying.put( "Slider.thumbColor", "ProgressBar.foreground" );
+		uiKeyCopying.put( "Slider.trackColor", "ProgressBar.background" );
+
+		// Spinner
+		uiKeyCopying.put( "Spinner.buttonSeparatorColor",         "Component.borderColor" );
+		uiKeyCopying.put( "Spinner.buttonDisabledSeparatorColor", "Component.disabledBorderColor" );
+
+		// TabbedPane
+		uiKeyCopying.put( "TabbedPane.selectedBackground",     "DefaultTabs.underlinedTabBackground" );
+		uiKeyCopying.put( "TabbedPane.selectedForeground",     "DefaultTabs.underlinedTabForeground" );
+		uiKeyCopying.put( "TabbedPane.inactiveUnderlineColor", "DefaultTabs.inactiveUnderlineColor" );
+
+		// 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" );
 		checkboxKeyMapping.put( "Checkbox.Border.Disabled",     "CheckBox.icon.disabledBorderColor" );
 		checkboxKeyMapping.put( "Checkbox.Focus.Thin.Default",  "CheckBox.icon.focusedBorderColor" );
-		checkboxKeyMapping.put( "Checkbox.Focus.Wide",          "CheckBox.icon.focusedColor" );
+		checkboxKeyMapping.put( "Checkbox.Focus.Wide",          "CheckBox.icon.focusColor" );
 		checkboxKeyMapping.put( "Checkbox.Foreground.Disabled", "CheckBox.icon.disabledCheckmarkColor" );
 		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" );
@@ -459,16 +675,6 @@ public class IntelliJTheme
 		Map.Entry<String, String>[] entries = checkboxDuplicateColors.entrySet().toArray( new Map.Entry[checkboxDuplicateColors.size()] );
 		for( Map.Entry<String, String> e : entries )
 			checkboxDuplicateColors.put( e.getValue(), e.getKey() );
-
-		// because FlatLaf uses Button.background and Button.borderColor,
-		// but IDEA uses Button.startBackground and Button.startBorderColor,
-		// our default button background and border colors may be replaced by
-		// wildcard *.background and *.borderColor colors
-		noWildcardReplace.add( "Button.background" );
-		noWildcardReplace.add( "Button.borderColor" );
-		noWildcardReplace.add( "Button.default.background" );
-		noWildcardReplace.add( "Button.default.borderColor" );
-		noWildcardReplace.add( "ToggleButton.background" );
 	}
 
 	//---- class ThemeLaf -----------------------------------------------------
@@ -489,7 +695,7 @@ public class IntelliJTheme
 
 		@Override
 		public String getDescription() {
-			return theme.name;
+			return getName();
 		}
 
 		@Override
@@ -502,19 +708,12 @@ public class IntelliJTheme
 		}
 
 		@Override
-		public UIDefaults getDefaults() {
-			UIDefaults defaults = super.getDefaults();
+		void applyAdditionalDefaults( UIDefaults defaults ) {
 			theme.applyProperties( defaults );
-			super.invokePostInitialization( defaults );
-			return defaults;
 		}
 
 		@Override
-		void invokePostInitialization( UIDefaults defaults ) {
-		}
-
-		@Override
-		ArrayList<Class<?>> getLafClassesForDefaultsLoading() {
+		protected ArrayList<Class<?>> getLafClassesForDefaultsLoading() {
 			ArrayList<Class<?>> lafClasses = new ArrayList<>();
 			lafClasses.add( FlatLaf.class );
 			lafClasses.add( theme.dark ? FlatDarkLaf.class : FlatLightLaf.class );

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

@@ -17,6 +17,8 @@
 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;
@@ -27,10 +29,11 @@ import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 import java.util.StringTokenizer;
-import java.util.logging.Level;
 import javax.swing.text.StyleContext;
+import com.formdev.flatlaf.util.LoggingFacade;
 import com.formdev.flatlaf.util.StringUtils;
 import com.formdev.flatlaf.util.SystemInfo;
+import com.formdev.flatlaf.util.UIScale;
 
 /**
  * @author Karl Tauber
@@ -38,7 +41,7 @@ import com.formdev.flatlaf.util.SystemInfo;
 class LinuxFontPolicy
 {
 	static Font getFont() {
-		return SystemInfo.IS_KDE ? getKDEFont() : getGnomeFont();
+		return SystemInfo.isKDE ? getKDEFont() : getGnomeFont();
 	}
 
 	/**
@@ -53,29 +56,50 @@ 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();
+			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)
+		// --> use Liberation Sans font
+		if( family.startsWith( "Ubuntu" ) &&
+			!SystemInfo.isJetBrainsJVM &&
+			!FlatSystemProperties.getBoolean( FlatSystemProperties.USE_UBUNTU_FONT, false ) )
+		  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;
 
@@ -84,13 +108,52 @@ class LinuxFontPolicy
 		if( logicalFamily != null )
 			family = logicalFamily;
 
-		return createFont( family, style, size, dsize );
+		return createFontEx( family, style, size, dsize );
+	}
+
+	/**
+	 * Create a font for the given family, style and size.
+	 * If the font family does not match any font on the system,
+	 * then the last word (usually a font weight) from the family name is removed and tried again.
+	 * E.g. family 'URW Bookman Light' is not found, but 'URW Bookman' is found.
+	 * If still not found, then font of family 'Dialog' is returned.
+	 */
+	private static Font createFontEx( String family, int style, int size, double dsize ) {
+		for(;;) {
+			Font font = createFont( family, style, size, dsize );
+
+			if( Font.DIALOG.equals( family ) )
+				return font;
+
+			// if the font family does not match any font on the system, "Dialog" family is returned
+			if( !Font.DIALOG.equals( font.getFamily() ) ) {
+				// check for font problems
+				// - font height much larger than expected (e.g. font Inter; Oracle Java 8)
+				// - character width is zero (e.g. font Cantarell; Fedora; Oracle Java 8)
+				FontMetrics fm = StyleContext.getDefaultStyleContext().getFontMetrics( font );
+				if( fm.getHeight() > size * 2 || fm.stringWidth( "a" ) == 0 )
+					return createFont( Font.DIALOG, style, size, dsize );
+
+				return font;
+			}
+
+			// find last word in family
+			int index = family.lastIndexOf( ' ' );
+			if( index < 0 )
+				return createFont( Font.DIALOG, style, size, dsize );
+
+			// check whether last work contains some font weight (e.g. Ultra-Bold or Heavy)
+			String lastWord = family.substring( index + 1 ).toLowerCase();
+			if( lastWord.contains( "bold" ) || lastWord.contains( "heavy" ) || lastWord.contains( "black" ) )
+				style |= Font.BOLD;
+
+			// remove last word from family and try again
+			family = family.substring( 0, index );
+		}
 	}
 
 	private static Font createFont( String family, int style, int size, double dsize ) {
-		// using StyleContext.getFont() here because it uses
-		// sun.font.FontUtilities.getCompositeFontUIResource()
-		Font font = new StyleContext().getFont( family, style, size );
+		Font font = FlatLaf.createCompositeFont( family, style, size );
 
 		// set font size in floating points
 		font = font.deriveFont( style, (float) dsize );
@@ -99,11 +162,15 @@ class LinuxFontPolicy
 	}
 
 	private static double getGnomeFontScale() {
+		// do not scale font here if JRE scales
+		if( isSystemScaling() )
+			return 96. / 72.;
+
 		// see class com.sun.java.swing.plaf.gtk.PangoFonts background information
 
 		Object value = Toolkit.getDefaultToolkit().getDesktopProperty( "gnome.Xft/DPI" );
 		if( value instanceof Integer ) {
-			int dpi = ((Integer)value).intValue() / 1024;
+			int dpi = (Integer) value / 1024;
 			if( dpi == -1 )
 				dpi = 96;
 			if( dpi < 50 )
@@ -130,7 +197,7 @@ 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.
@@ -162,13 +229,13 @@ class LinuxFontPolicy
 				if( "1".equals( strs.get( 5 ) ) )
 					style |= Font.ITALIC;
 			} catch( RuntimeException ex ) {
-				FlatLaf.LOG.log( Level.CONFIG, "FlatLaf: Failed to parse 'font=" + generalFont + "'.", ex );
+				LoggingFacade.INSTANCE.logConfig( "FlatLaf: Failed to parse 'font=" + generalFont + "'.", ex );
 			}
 		}
 
 		// font dpi
 		int dpi = 96;
-		if( forceFontDPI != null ) {
+		if( forceFontDPI != null && !isSystemScaling() ) {
 			try {
 				dpi = Integer.parseInt( forceFontDPI );
 				if( dpi <= 0 )
@@ -176,7 +243,7 @@ class LinuxFontPolicy
 				if( dpi < 50 )
 					dpi = 50;
 			} catch( NumberFormatException ex ) {
-				FlatLaf.LOG.log( Level.CONFIG, "FlatLaf: Failed to parse 'forceFontDPI=" + forceFontDPI + "'.", ex );
+				LoggingFacade.INSTANCE.logConfig( "FlatLaf: Failed to parse 'forceFontDPI=" + forceFontDPI + "'.", ex );
 			}
 		}
 
@@ -211,11 +278,11 @@ class LinuxFontPolicy
 		// read config file
 		ArrayList<String> lines = new ArrayList<>( 200 );
 		try( BufferedReader reader = new BufferedReader( new FileReader( file ) ) ) {
-			String line = null;
+			String line;
 			while( (line = reader.readLine()) != null )
 				lines.add( line );
 		} catch( IOException ex ) {
-			FlatLaf.LOG.log( Level.CONFIG, "FlatLaf: Failed to read '" + filename + "'.", ex );
+			LoggingFacade.INSTANCE.logConfig( "FlatLaf: Failed to read '" + filename + "'.", ex );
 		}
 		return lines;
 	}
@@ -247,4 +314,18 @@ class LinuxFontPolicy
 		}
 		return null;
 	}
+
+	/**
+	 * Returns true if the JRE scales, which is the case if:
+	 *   - environment variable GDK_SCALE is set and running on Java 9 or later
+	 *   - running on JetBrains Runtime 11 or later and scaling is enabled in system Settings
+	 */
+	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/MnemonicHandler.java

@@ -0,0 +1,267 @@
+/*
+ * Copyright 2020 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.Container;
+import java.awt.EventQueue;
+import java.awt.KeyEventPostProcessor;
+import java.awt.KeyboardFocusManager;
+import java.awt.Window;
+import java.awt.event.KeyEvent;
+import java.awt.event.WindowAdapter;
+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;
+import javax.swing.JMenuBar;
+import javax.swing.JRootPane;
+import javax.swing.JTabbedPane;
+import javax.swing.MenuElement;
+import javax.swing.MenuSelectionManager;
+import javax.swing.SwingUtilities;
+import javax.swing.UIManager;
+import javax.swing.event.ChangeEvent;
+import javax.swing.event.ChangeListener;
+import com.formdev.flatlaf.util.SystemInfo;
+
+/**
+ * Show/hide mnemonics.
+ *
+ * @author Karl Tauber
+ */
+class MnemonicHandler
+	implements KeyEventPostProcessor, ChangeListener
+{
+	private static boolean showMnemonics;
+	private static WeakReference<Window> lastShowMnemonicWindow;
+	private static WindowListener windowListener;
+
+	static boolean isShowMnemonics() {
+		return showMnemonics || !UIManager.getBoolean( "Component.hideMnemonics" );
+	}
+
+	void install() {
+		KeyboardFocusManager.getCurrentKeyboardFocusManager().addKeyEventPostProcessor( this );
+		MenuSelectionManager.defaultManager().addChangeListener( this );
+	}
+
+	void uninstall() {
+		KeyboardFocusManager.getCurrentKeyboardFocusManager().removeKeyEventPostProcessor( this );
+		MenuSelectionManager.defaultManager().removeChangeListener( this );
+	}
+
+	@Override
+	public boolean postProcessKeyEvent( KeyEvent e ) {
+		int keyCode = e.getKeyCode();
+		if( SystemInfo.isMacOS ) {
+			// Ctrl+Alt keys must be pressed on Mac
+			if( keyCode == KeyEvent.VK_CONTROL || keyCode == KeyEvent.VK_ALT )
+				showMnemonics( shouldShowMnemonics( e ) && e.isControlDown() && e.isAltDown(), e.getComponent() );
+		} else {
+			// Alt key must be pressed on Windows and Linux
+			if( SystemInfo.isWindows )
+				return processKeyEventOnWindows( e );
+
+			if( keyCode == KeyEvent.VK_ALT )
+				showMnemonics( shouldShowMnemonics( e ), e.getComponent() );
+		}
+
+		return false;
+	}
+
+	private boolean shouldShowMnemonics( KeyEvent e ) {
+		return e.getID() == KeyEvent.KEY_PRESSED ||
+			MenuSelectionManager.defaultManager().getSelectedPath().length > 0;
+	}
+
+	private static int altPressedEventCount;
+	private static boolean selectMenuOnAltReleased;
+
+	/**
+	 * Special Alt key behavior on Windows.
+	 *
+	 * Press-and-release Alt key selects first menu (if available) and moves focus
+	 * temporary to menu bar. If menu bar has focus (some menu is selected),
+	 * pressing Alt key unselects menu and moves focus back to permanent focus owner.
+	 */
+	private boolean processKeyEventOnWindows( KeyEvent e ) {
+		if( e.getKeyCode() != KeyEvent.VK_ALT ) {
+			selectMenuOnAltReleased = false;
+			return false;
+		}
+
+		if( e.getID() == KeyEvent.KEY_PRESSED ) {
+			altPressedEventCount++;
+
+			if( altPressedEventCount == 1 && !e.isConsumed() ) {
+				MenuSelectionManager menuSelectionManager = MenuSelectionManager.defaultManager();
+				selectMenuOnAltReleased = (menuSelectionManager.getSelectedPath().length == 0);
+
+				// if menu is selected when Alt key is pressed then clear menu selection
+				if( !selectMenuOnAltReleased )
+					menuSelectionManager.clearSelectedPath();
+			}
+
+			// show mnemonics
+			showMnemonics( shouldShowMnemonics( e ), e.getComponent() );
+
+			// avoid that the system menu of the window gets focus
+			e.consume();
+			return true;
+
+		} else if( e.getID() == KeyEvent.KEY_RELEASED ) {
+			altPressedEventCount = 0;
+
+			boolean mnemonicsShown = false;
+			if( selectMenuOnAltReleased && !e.isConsumed() ) {
+				MenuSelectionManager menuSelectionManager = MenuSelectionManager.defaultManager();
+				if( menuSelectionManager.getSelectedPath().length == 0 ) {
+					// get menu bar and first menu
+					Component c = e.getComponent();
+					JRootPane rootPane = SwingUtilities.getRootPane( c );
+					JMenuBar menuBar = (rootPane != null) ? rootPane.getJMenuBar() : null;
+					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
+					if( firstMenu != null ) {
+						menuSelectionManager.setSelectedPath( new MenuElement[] { menuBar, firstMenu } );
+						showMnemonics( true, c );
+						mnemonicsShown = true;
+					}
+				}
+			}
+			selectMenuOnAltReleased = false;
+
+			// hide mnemonics
+			if( !mnemonicsShown )
+				showMnemonics( shouldShowMnemonics( e ), e.getComponent() );
+		}
+		return false;
+	}
+
+	@Override
+	public void stateChanged( ChangeEvent e ) {
+		MenuElement[] selectedPath = MenuSelectionManager.defaultManager().getSelectedPath();
+		if( selectedPath.length == 0 && altPressedEventCount == 0 ) {
+			// hide mnemonics when menu selection was canceled
+			showMnemonics( false, null );
+		}
+	}
+
+	static void showMnemonics( boolean show, Component c ) {
+		if( show == showMnemonics )
+			return;
+
+		showMnemonics = show;
+
+		// check whether it is necessary to repaint
+		if( !UIManager.getBoolean( "Component.hideMnemonics" ) )
+			return;
+
+		if( show ) {
+			// get root pane
+			JRootPane rootPane = SwingUtilities.getRootPane( c );
+			if( rootPane == null )
+				return;
+
+			// get window
+			Window window = SwingUtilities.getWindowAncestor( rootPane );
+			if( window == null )
+				return;
+
+			// repaint components with mnemonics in focused window
+			repaintMnemonics( window );
+
+			// hide mnemonics if window is deactivated (e.g. Alt+Tab to another window)
+			windowListener = new WindowAdapter() {
+				@Override
+				public void windowDeactivated( WindowEvent e ) {
+					altPressedEventCount = 0;
+					selectMenuOnAltReleased = false;
+
+					// use invokeLater() to avoid that the listener is removed
+					// while the listener queue is iterated to fire this event
+					EventQueue.invokeLater( () -> {
+						showMnemonics( false, null );
+					} );
+				}
+			};
+			window.addWindowListener( windowListener );
+
+			lastShowMnemonicWindow = new WeakReference<>( window );
+		} else if( lastShowMnemonicWindow != null ) {
+			Window window = lastShowMnemonicWindow.get();
+			if( window != null ) {
+				repaintMnemonics( window );
+
+				if( windowListener != null ) {
+					window.removeWindowListener( windowListener );
+					windowListener = null;
+				}
+			}
+
+			lastShowMnemonicWindow = null;
+		}
+	}
+
+	private static void repaintMnemonics( Container container ) {
+		for( Component c : container.getComponents() ) {
+			if( !c.isVisible() )
+				continue;
+
+			if( hasMnemonic( c ) )
+				c.repaint();
+
+			if( c instanceof Container )
+				repaintMnemonics( (Container) c );
+		}
+	}
+
+	private static boolean hasMnemonic( Component c ) {
+		if( c instanceof JLabel && ((JLabel)c).getDisplayedMnemonicIndex() >= 0 )
+			return true;
+
+		if( c instanceof AbstractButton && ((AbstractButton)c).getDisplayedMnemonicIndex() >= 0 )
+			return true;
+
+		if( c instanceof JTabbedPane ) {
+			JTabbedPane tabPane = (JTabbedPane) c;
+			int tabCount = tabPane.getTabCount();
+			for( int i = 0; i < tabCount; i++ ) {
+				if( tabPane.getDisplayedMnemonicIndexAt( i ) >= 0 )
+					return true;
+			}
+		}
+
+		return false;
+	}
+}

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

@@ -0,0 +1,336 @@
+/*
+ * 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;
+
+/**
+ * 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 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;
+
+		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( !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)
+			? 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 supress mouse events when mouse is moved within safe triangle
+		if( subMenuEventQueue == null )
+			subMenuEventQueue = new SubMenuEventQueue();
+
+		// 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 );
+
+			Toolkit.getDefaultToolkit().getSystemEventQueue().push( this );
+		}
+
+		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;

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

@@ -0,0 +1,55 @@
+/*
+ * Copyright 2020 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.Graphics;
+import java.awt.Graphics2D;
+import com.formdev.flatlaf.util.AnimatedIcon;
+
+/**
+ * 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.
+ * This makes it possible to use a share icon instance for multiple components.
+ *
+ * @author Karl Tauber
+ */
+public abstract class FlatAnimatedIcon
+	extends FlatAbstractIcon
+	implements AnimatedIcon
+{
+	public FlatAnimatedIcon( int width, int height, Color color ) {
+		super( width, height, color );
+	}
+
+	@Override
+	public void paintIcon( Component c, Graphics g, int x, int y ) {
+		super.paintIcon( c, g, x, y );
+		AnimatedIcon.AnimationSupport.saveIconLocation( this, c, x, y );
+	}
+
+	@Override
+	protected void paintIcon( Component c, Graphics2D g ) {
+		AnimatedIcon.AnimationSupport.paintIcon( this, c, g, 0, 0 );
+	}
+}

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

@@ -21,13 +21,17 @@ 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;
 
 /**
  * "ascendingSort" icon for {@link javax.swing.table.JTableHeader}.
  *
- * @uiDefault Component.arrowType				String	triangle (default) or chevron
+ * @uiDefault Component.arrowType				String	chevron (default) or triangle
  * @uiDefault Table.sortIconColor				Color
  *
  * @author Karl Tauber
@@ -35,8 +39,8 @@ import com.formdev.flatlaf.ui.FlatUIUtils;
 public class FlatAscendingSortIcon
 	extends FlatAbstractIcon
 {
-	protected final boolean chevron = "chevron".equals( 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,10 +48,31 @@ 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,5, 5,1, 9,5 );
+			Path2D path = FlatUIUtils.createPath( false, 1,4, 5,0, 9,4 );
 			g.setStroke( new BasicStroke( 1f ) );
 			g.draw( path );
 		} else {

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

@@ -0,0 +1,89 @@
+/*
+ * Copyright 2020 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.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;
+
+/**
+ * "caps lock" icon for {@link javax.swing.JPasswordField}.
+ *
+ * @uiDefault PasswordField.capsLockIconColor			Color
+ *
+ * @author Karl Tauber
+ */
+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="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>
+		*/
+
+		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

@@ -23,66 +23,138 @@ 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; "outlined"/null (default) or "filled"
  * @uiDefault Component.focusWidth						int
+ * @uiDefault Component.borderWidth						int
  * @uiDefault Component.focusColor						Color
- * @uiDefault CheckBox.icon.focusedColor				Color	optional; defaults to Component.focusColor
- * @uiDefault CheckBox.icon.borderColor					Color
- * @uiDefault CheckBox.icon.disabledBorderColor			Color
- * @uiDefault CheckBox.icon.selectedBorderColor			Color
- * @uiDefault CheckBox.icon.focusedBorderColor			Color
- * @uiDefault CheckBox.icon.hoverBorderColor			Color	optional
- * @uiDefault CheckBox.icon.selectedFocusedBorderColor	Color	optional
- * @uiDefault CheckBox.icon.background					Color
- * @uiDefault CheckBox.icon.disabledBackground			Color
- * @uiDefault CheckBox.icon.focusedBackground			Color	optional
- * @uiDefault CheckBox.icon.hoverBackground				Color	optional
- * @uiDefault CheckBox.icon.pressedBackground			Color	optional
- * @uiDefault CheckBox.icon.selectedBackground			Color
- * @uiDefault CheckBox.icon.selectedHoverBackground		Color	optional
- * @uiDefault CheckBox.icon.selectedPressedBackground	Color	optional
- * @uiDefault CheckBox.icon.checkmarkColor				Color
- * @uiDefault CheckBox.icon.disabledCheckmarkColor		Color
+ * @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.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.disabledSelectedBorderColor	Color	optional; CheckBox.icon.disabledBorderColor is used if not specified
+ * @uiDefault CheckBox.icon.disabledSelectedBackground	Color	optional; CheckBox.icon.disabledBackground is used if not specified
+ * @uiDefault CheckBox.icon.disabledCheckmarkColor		Color
+ *
+ * @uiDefault CheckBox.icon.focusedBorderColor			Color	optional
+ * @uiDefault CheckBox.icon.focusedBackground			Color	optional
+ * @uiDefault CheckBox.icon.focusedSelectedBorderColor	Color	optional; CheckBox.icon.focusedBorderColor is used if not specified
+ * @uiDefault CheckBox.icon.focusedSelectedBackground	Color	optional; CheckBox.icon.focusedBackground is used if not specified
+ * @uiDefault CheckBox.icon.focusedCheckmarkColor		Color	optional; CheckBox.icon.checkmarkColor is used if not specified
+ *
+ * @uiDefault CheckBox.icon.hoverBorderColor			Color	optional
+ * @uiDefault CheckBox.icon.hoverBackground				Color	optional
+ * @uiDefault CheckBox.icon.hoverSelectedBorderColor	Color	optional; CheckBox.icon.hoverBorderColor is used if not specified
+ * @uiDefault CheckBox.icon.hoverSelectedBackground		Color	optional; CheckBox.icon.hoverBackground is used if not specified
+ * @uiDefault CheckBox.icon.hoverCheckmarkColor			Color	optional; CheckBox.icon.checkmarkColor is used if not specified
+ *
+ * @uiDefault CheckBox.icon.pressedBorderColor			Color	optional
+ * @uiDefault CheckBox.icon.pressedBackground			Color	optional
+ * @uiDefault CheckBox.icon.pressedSelectedBorderColor	Color	optional; CheckBox.icon.pressedBorderColor is used if not specified
+ * @uiDefault CheckBox.icon.pressedSelectedBackground	Color	optional; CheckBox.icon.pressedBackground is used if not specified
+ * @uiDefault CheckBox.icon.pressedCheckmarkColor		Color	optional; CheckBox.icon.checkmarkColor is used if not specified
+ *
  * @author Karl Tauber
  */
 public class FlatCheckBoxIcon
 	extends FlatAbstractIcon
 {
-	public final int focusWidth = UIManager.getInt( "Component.focusWidth" );
-	protected final Color focusColor = FlatUIUtils.getUIColor( "CheckBox.icon.focusedColor",
-		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 );
+	@Styleable protected int arc = FlatUIUtils.getUIInt( "CheckBox.arc", 2 );
 
-	protected final Color borderColor = UIManager.getColor( "CheckBox.icon.borderColor" );
-	protected final Color disabledBorderColor = UIManager.getColor( "CheckBox.icon.disabledBorderColor" );
-	protected final Color selectedBorderColor = UIManager.getColor( "CheckBox.icon.selectedBorderColor" );
-	protected final Color focusedBorderColor = UIManager.getColor( "CheckBox.icon.focusedBorderColor" );
-	protected final Color hoverBorderColor = UIManager.getColor( "CheckBox.icon.hoverBorderColor" );
-	protected final Color selectedFocusedBorderColor = UIManager.getColor( "CheckBox.icon.selectedFocusedBorderColor" );
-	protected final Color background = UIManager.getColor( "CheckBox.icon.background" );
-	protected final Color disabledBackground = UIManager.getColor( "CheckBox.icon.disabledBackground" );
-	protected final Color focusedBackground = UIManager.getColor( "CheckBox.icon.focusedBackground" );
-	protected final Color hoverBackground = UIManager.getColor( "CheckBox.icon.hoverBackground" );
-	protected final Color pressedBackground = UIManager.getColor( "CheckBox.icon.pressedBackground" );
-	protected final Color selectedBackground = UIManager.getColor( "CheckBox.icon.selectedBackground" );
-	protected final Color selectedHoverBackground = UIManager.getColor( "CheckBox.icon.selectedHoverBackground" );
-	protected final Color selectedPressedBackground = UIManager.getColor( "CheckBox.icon.selectedPressedBackground" );
-	protected final Color checkmarkColor = UIManager.getColor( "CheckBox.icon.checkmarkColor" );
-	protected final Color disabledCheckmarkColor = UIManager.getColor( "CheckBox.icon.disabledCheckmarkColor" );
+	// enabled
+	@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 );
+
+	// disabled
+	@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 );
+
+	// focused
+	@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 );
+
+	// hover
+	@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 );
+
+	// pressed
+	/** @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 );
+
+	protected String getPropertyPrefix() {
+		return "CheckBox.";
+	}
+
+	protected static Color getUIColor( String key, String style ) {
+		if( style != null ) {
+			Color color = UIManager.getColor( styleKey( key, style ) );
+			if( color != null )
+				return color;
+		}
+		return UIManager.getColor( key );
+	}
+
+	/** @since 2 */
+	protected static float getUIFloat( String key, float defaultValue, String style ) {
+		if( style != null ) {
+			float value = FlatUIUtils.getUIFloat( styleKey( key, style ), Float.MIN_VALUE );
+			if( value != Float.MIN_VALUE )
+				return value;
+		}
+		return FlatUIUtils.getUIFloat( key, defaultValue );
+	}
+
+	private static String styleKey( String key, String style ) {
+		return key.replace( ".icon.", ".icon[" + style + "]." );
+	}
 
 	static final int ICON_SIZE = 15;
 
@@ -90,74 +162,140 @@ 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 g2 ) {
-		boolean indeterminate = c instanceof JComponent && clientPropertyEquals( (JComponent) c, SELECTED_STATE, SELECTED_STATE_INDETERMINATE );
-		boolean selected = indeterminate || (c instanceof AbstractButton && ((AbstractButton)c).isSelected());
+	protected void paintIcon( Component c, Graphics2D g ) {
+		boolean indeterminate = isIndeterminate( c );
+		boolean selected = indeterminate || isSelected( c );
+		boolean isFocused = FlatUIUtils.isPermanentFocusOwner( c );
+		float bw = selected
+			? (disabledSelectedBorderWidth != Float.MIN_VALUE && !c.isEnabled()
+				? disabledSelectedBorderWidth
+				: (selectedBorderWidth != Float.MIN_VALUE ? selectedBorderWidth : borderWidth))
+			: borderWidth;
 
 		// paint focused border
-		if( c.hasFocus() && focusWidth > 0 ) {
-			g2.setColor( focusColor );
-			paintFocusBorder( g2 );
+		if( isFocused && focusWidth > 0 && FlatButtonUI.isFocusPainted( c ) ) {
+			g.setColor( getFocusColor( c ) );
+			paintFocusBorder( c, g );
 		}
 
 		// paint border
-		g2.setColor( FlatButtonUI.buttonStateColor( c,
-			selected ? selectedBorderColor : borderColor,
-			disabledBorderColor,
-			selected && selectedFocusedBorderColor != null ? selectedFocusedBorderColor : focusedBorderColor,
-			hoverBorderColor,
-			null ) );
-		paintBorder( g2 );
+		g.setColor( getBorderColor( c, selected ) );
+		paintBorder( c, g, bw );
 
 		// paint background
-		FlatUIUtils.setColor( g2, FlatButtonUI.buttonStateColor( c,
-			selected ? selectedBackground : background,
-			disabledBackground,
-			focusedBackground,
-			selected && selectedHoverBackground != null ? selectedHoverBackground : hoverBackground,
-			selected && selectedPressedBackground != null ? selectedPressedBackground : pressedBackground ),
-			background );
-		paintBackground( g2 );
+		Color bg = FlatUIUtils.deriveColor( getBackground( c, selected ),
+			selected ? selectedBackground : background );
+		if( bg.getAlpha() < 255 ) {
+			// fill background with default color before filling with non-opaque background
+			g.setColor( selected ? selectedBackground : background );
+			paintBackground( c, g, bw );
+		}
+		g.setColor( bg );
+		paintBackground( c, g, bw );
 
 		// paint checkmark
-		if( selected || indeterminate ) {
-			g2.setColor( c.isEnabled() ? checkmarkColor : disabledCheckmarkColor );
+		if( selected ) {
+			g.setColor( getCheckmarkColor( c ) );
 			if( indeterminate )
-				paintIndeterminate( g2 );
+				paintIndeterminate( c, g );
 			else
-				paintCheckmark( g2 );
+				paintCheckmark( c, g );
 		}
 	}
 
-	protected void paintFocusBorder( Graphics2D g2 ) {
-		// the outline focus border is painted outside of the icon
-		int wh = ICON_SIZE - 1 + (focusWidth * 2);
-		int arcwh = arc + (focusWidth * 2);
-		g2.fillRoundRect( -focusWidth + 1, -focusWidth, wh, wh, arcwh, arcwh );
+	protected void paintFocusBorder( Component c, Graphics2D g ) {
+		// 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( Graphics2D g2 ) {
+	protected void paintBorder( Component c, Graphics2D g, float borderWidth ) {
+		if( borderWidth == 0 )
+			return;
+
 		int arcwh = arc;
-		g2.fillRoundRect( 1, 0, 14, 14, arcwh, arcwh );
+		g.fillRoundRect( 1, 0, 14, 14, arcwh, arcwh );
 	}
 
-	protected void paintBackground( Graphics2D g2 ) {
-		int arcwh = arc - 1;
-		g2.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( Graphics2D g2 ) {
-		Path2D.Float path = new Path2D.Float();
+	protected void paintCheckmark( Component c, Graphics2D g ) {
+		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 );
 
-		g2.setStroke( new BasicStroke( 1.9f, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND ) );
-		g2.draw( path );
+		g.setStroke( new BasicStroke( 1.9f, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND ) );
+		g.draw( path );
 	}
 
-	protected void paintIndeterminate( Graphics2D g2 ) {
-		g2.fill( new RoundRectangle2D.Float( 3.75f, 5.75f, 8.5f, 2.5f, 2f, 2f ) );
+	protected void paintIndeterminate( Component c, Graphics2D g ) {
+		g.fill( new RoundRectangle2D.Float( 3.75f, 5.75f, 8.5f, 2.5f, 2f, 2f ) );
+	}
+
+	protected boolean isIndeterminate( Component c ) {
+		return c instanceof JComponent && clientPropertyEquals( (JComponent) c, SELECTED_STATE, SELECTED_STATE_INDETERMINATE );
+	}
+
+	protected boolean isSelected( Component c ) {
+		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 ) {
+		return FlatButtonUI.buttonStateColor( c,
+			selected ? selectedBorderColor : borderColor,
+			(selected && disabledSelectedBorderColor != null) ? disabledSelectedBorderColor : disabledBorderColor,
+			(selected && focusedSelectedBorderColor != null) ? focusedSelectedBorderColor : focusedBorderColor,
+			(selected && hoverSelectedBorderColor != null) ? hoverSelectedBorderColor : hoverBorderColor,
+			(selected && pressedSelectedBorderColor != null) ? pressedSelectedBorderColor : pressedBorderColor );
+	}
+
+	protected Color getBackground( Component c, boolean selected ) {
+		return FlatButtonUI.buttonStateColor( c,
+			selected ? selectedBackground : background,
+			(selected && disabledSelectedBackground != null) ? disabledSelectedBackground : disabledBackground,
+			(selected && focusedSelectedBackground != null) ? focusedSelectedBackground : focusedBackground,
+			(selected && hoverSelectedBackground != null) ? hoverSelectedBackground : hoverBackground,
+			(selected && pressedSelectedBackground != null) ? pressedSelectedBackground : pressedBackground );
+	}
+
+	protected Color getCheckmarkColor( Component c ) {
+		return FlatButtonUI.buttonStateColor( c,
+			checkmarkColor,
+			disabledCheckmarkColor,
+			focusedCheckmarkColor,
+			hoverCheckmarkColor,
+			pressedCheckmarkColor );
 	}
 }

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

@@ -21,30 +21,49 @@ 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 Menu.selectionForeground							Color
+ * @uiDefault CheckBoxMenuItem.icon.checkmarkColor				Color
+ * @uiDefault CheckBoxMenuItem.icon.disabledCheckmarkColor		Color
+ * @uiDefault MenuItem.selectionForeground						Color
+ * @uiDefault MenuItem.selectionType							String
  *
  * @author Karl Tauber
  */
 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( "Menu.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();
@@ -57,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 );
@@ -66,10 +85,15 @@ public class FlatCheckBoxMenuItemIcon
 		g2.draw( path );
 	}
 
-	private Color getCheckmarkColor( Component c ) {
-		if( c instanceof JMenuItem && ((JMenuItem)c).isArmed() )
+	protected Color getCheckmarkColor( Component c ) {
+		if( c instanceof JMenuItem && ((JMenuItem)c).isArmed() && !isUnderlineSelection() )
 			return selectionForeground;
 
 		return c.isEnabled() ? checkmarkColor : disabledCheckmarkColor;
 	}
+
+	protected boolean isUnderlineSelection() {
+		// not storing value of "MenuItem.selectionType" in class to allow changing at runtime
+		return "underline".equals( UIManager.getString( "MenuItem.selectionType" ) );
+	}
 }

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,37 +17,31 @@
 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;
 
 /**
  * "descendingSort" icon for {@link javax.swing.table.JTableHeader}.
  *
- * @uiDefault Component.arrowType				String	triangle (default) or chevron
+ * @uiDefault Component.arrowType				String	chevron (default) or triangle
  * @uiDefault Table.sortIconColor				Color
  *
  * @author Karl Tauber
  */
 public class FlatDescendingSortIcon
-	extends FlatAbstractIcon
+	extends FlatAscendingSortIcon
 {
-	protected final boolean chevron = "chevron".equals( 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,1, 5,5, 9,1 );
+			Path2D path = FlatUIUtils.createPath( false, 1,0, 5,4, 9,0 );
 			g.setStroke( new BasicStroke( 1f ) );
 			g.draw( path );
 		} else {

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;
 
 /**
@@ -31,6 +36,8 @@ import com.formdev.flatlaf.ui.FlatUIUtils;
  *
  * @uiDefault Component.focusWidth						int
  * @uiDefault Component.focusColor						Color
+ * @uiDefault HelpButton.innerFocusWidth				int or float	optional; defaults to Component.innerFocusWidth
+ * @uiDefault HelpButton.borderWidth					int		optional; default is 1
  * @uiDefault HelpButton.borderColor					Color
  * @uiDefault HelpButton.disabledBorderColor			Color
  * @uiDefault HelpButton.focusedBorderColor				Color
@@ -48,27 +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" );
+	@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 ) {
 		/*
@@ -76,20 +98,27 @@ 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 = c.hasFocus();
+		boolean enabled = c == null || c.isEnabled();
+		boolean focused = c != null && FlatUIUtils.isPermanentFocusOwner( c );
 
-		// paint focused border
-		if( focused ) {
+		float xy = 0.5f;
+		float wh = iconSize() - 1;
+
+		// paint outer focus border
+		if( focused && FlatButtonUI.isFocusPainted( c ) ) {
 			g2.setColor( focusColor );
-			g2.fill( new Ellipse2D.Float( 0.5f, 0.5f, iconSize - 1, iconSize - 1 ) );
+			g2.fill( new Ellipse2D.Float( xy, xy, wh, wh ) );
 		}
 
+		xy += focusWidth;
+		wh -= (focusWidth * 2);
+
 		// paint border
 		g2.setColor( FlatButtonUI.buttonStateColor( c,
 			borderColor,
@@ -97,43 +126,56 @@ public class FlatHelpButtonIcon
 			focusedBorderColor,
 			hoverBorderColor,
 			null ) );
-		g2.fill( new Ellipse2D.Float( focusWidth + 0.5f, focusWidth + 0.5f, 21, 21 ) );
+		g2.fill( new Ellipse2D.Float( xy, xy, wh, wh ) );
+
+		xy += borderWidth;
+		wh -= (borderWidth * 2);
+
+		// paint inner focus border
+		if( innerFocusWidth > 0 && focused && FlatButtonUI.isFocusPainted( c ) ) {
+			g2.setColor( focusColor );
+			g2.fill( new Ellipse2D.Float( xy, xy, wh, wh ) );
+
+			xy += innerFocusWidth;
+			wh -= (innerFocusWidth * 2);
+		}
 
 		// paint background
-		FlatUIUtils.setColor( g2, FlatButtonUI.buttonStateColor( c,
+		g2.setColor( FlatUIUtils.deriveColor( FlatButtonUI.buttonStateColor( c,
 			background,
 			disabledBackground,
 			focusedBackground,
 			hoverBackground,
-			pressedBackground ), background );
-		g2.fill( new Ellipse2D.Float( focusWidth + 1.5f, focusWidth + 1.5f, 19, 19 ) );
+			pressedBackground ), background ) );
+		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/FlatInternalFrameAbstractIcon.java

@@ -0,0 +1,61 @@
+/*
+ * Copyright 2019 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
+ *
+ *     http://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.Dimension;
+import java.awt.Graphics2D;
+import javax.swing.UIManager;
+import com.formdev.flatlaf.ui.FlatButtonUI;
+import com.formdev.flatlaf.ui.FlatUIUtils;
+
+/**
+ * Base class for internal frame icons.
+ *
+ * @uiDefault InternalFrame.buttonSize					Dimension
+ * @uiDefault InternalFrame.buttonHoverBackground		Color
+ * @uiDefault InternalFrame.buttonPressedBackground		Color
+ *
+ * @author Karl Tauber
+ */
+public abstract class FlatInternalFrameAbstractIcon
+	extends FlatAbstractIcon
+{
+	private final Color hoverBackground;
+	private final Color pressedBackground;
+
+	public FlatInternalFrameAbstractIcon() {
+		this( UIManager.getDimension( "InternalFrame.buttonSize" ),
+			UIManager.getColor( "InternalFrame.buttonHoverBackground" ),
+			UIManager.getColor( "InternalFrame.buttonPressedBackground" ) );
+	}
+
+	public FlatInternalFrameAbstractIcon( Dimension size, Color hoverBackground, Color pressedBackground ) {
+		super( size.width, size.height, null );
+		this.hoverBackground = hoverBackground;
+		this.pressedBackground = pressedBackground;
+	}
+
+	protected void paintBackground( Component c, Graphics2D g ) {
+		Color background = FlatButtonUI.buttonStateColor( c, null, null, null, hoverBackground, pressedBackground );
+		if( background != null ) {
+			g.setColor( FlatUIUtils.deriveColor( background, c.getBackground() ) );
+			g.fillRect( 0, 0, width, height );
+		}
+	}
+}

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

@@ -17,35 +17,51 @@
 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;
 
 /**
  * "close" icon for {@link javax.swing.JInternalFrame}.
  *
- * @uiDefault InternalFrame.iconColor			Color
+ * @uiDefault InternalFrame.buttonSize					Dimension
+ * @uiDefault InternalFrame.closeHoverBackground		Color
+ * @uiDefault InternalFrame.closePressedBackground		Color
+ * @uiDefault InternalFrame.closeHoverForeground		Color
+ * @uiDefault InternalFrame.closePressedForeground		Color
  *
  * @author Karl Tauber
  */
 public class FlatInternalFrameCloseIcon
-	extends FlatAbstractIcon
+	extends FlatInternalFrameAbstractIcon
 {
+	private final Color hoverForeground = UIManager.getColor( "InternalFrame.closeHoverForeground" );
+	private final Color pressedForeground = UIManager.getColor( "InternalFrame.closePressedForeground" );
+
 	public FlatInternalFrameCloseIcon() {
-		super( 16, 16, UIManager.getColor( "InternalFrame.iconColor" ) );
+		super( UIManager.getDimension( "InternalFrame.buttonSize" ),
+			UIManager.getColor( "InternalFrame.closeHoverBackground" ),
+			UIManager.getColor( "InternalFrame.closePressedBackground" ) );
 	}
 
 	@Override
 	protected void paintIcon( Component c, Graphics2D g ) {
-		float mx = 8;
-		float my = 8;
+		paintBackground( c, g );
+
+		g.setColor( FlatButtonUI.buttonStateColor( c, c.getForeground(), null, null, hoverForeground, pressedForeground ) );
+
+		float mx = width / 2;
+		float my = height / 2;
 		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/FlatInternalFrameIconifyIcon.java

@@ -18,24 +18,23 @@ package com.formdev.flatlaf.icons;
 
 import java.awt.Component;
 import java.awt.Graphics2D;
-import javax.swing.UIManager;
 
 /**
  * "iconify" icon for {@link javax.swing.JInternalFrame}.
  *
- * @uiDefault InternalFrame.iconColor			Color
- *
  * @author Karl Tauber
  */
 public class FlatInternalFrameIconifyIcon
-	extends FlatAbstractIcon
+	extends FlatInternalFrameAbstractIcon
 {
 	public FlatInternalFrameIconifyIcon() {
-		super( 16, 16, UIManager.getColor( "InternalFrame.iconColor" ) );
 	}
 
 	@Override
 	protected void paintIcon( Component c, Graphics2D g ) {
-		g.fillRect( 3, 8, 10, 1 );
+		paintBackground( c, g );
+
+		g.setColor( c.getForeground() );
+		g.fillRect( (width / 2) - 4, height / 2, 8, 1 );
 	}
 }

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

@@ -18,25 +18,24 @@ package com.formdev.flatlaf.icons;
 
 import java.awt.Component;
 import java.awt.Graphics2D;
-import javax.swing.UIManager;
 import com.formdev.flatlaf.ui.FlatUIUtils;
 
 /**
  * "maximize" icon for {@link javax.swing.JInternalFrame}.
  *
- * @uiDefault InternalFrame.iconColor			Color
- *
  * @author Karl Tauber
  */
 public class FlatInternalFrameMaximizeIcon
-	extends FlatAbstractIcon
+	extends FlatInternalFrameAbstractIcon
 {
 	public FlatInternalFrameMaximizeIcon() {
-		super( 16, 16, UIManager.getColor( "InternalFrame.iconColor" ) );
 	}
 
 	@Override
 	protected void paintIcon( Component c, Graphics2D g ) {
-		g.fill( FlatUIUtils.createRectangle( 3, 3, 10, 10, 1 ) );
+		paintBackground( c, g );
+
+		g.setColor( c.getForeground() );
+		g.fill( FlatUIUtils.createRectangle( (width / 2) - 4, (height / 2) - 4, 8, 8, 1 ) );
 	}
 }

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

@@ -21,30 +21,32 @@ import java.awt.Graphics2D;
 import java.awt.geom.Area;
 import java.awt.geom.Path2D;
 import java.awt.geom.Rectangle2D;
-import javax.swing.UIManager;
 import com.formdev.flatlaf.ui.FlatUIUtils;
 
 /**
- * "minimize" (actually "restore") icon for {@link javax.swing.JInternalFrame}.
- *
- * @uiDefault InternalFrame.iconColor			Color
+ * "restore" (or "minimize") icon for {@link javax.swing.JInternalFrame}.
  *
  * @author Karl Tauber
  */
-public class FlatInternalFrameMinimizeIcon
-	extends FlatAbstractIcon
+public class FlatInternalFrameRestoreIcon
+	extends FlatInternalFrameAbstractIcon
 {
-	public FlatInternalFrameMinimizeIcon() {
-		super( 16, 16, UIManager.getColor( "InternalFrame.iconColor" ) );
+	public FlatInternalFrameRestoreIcon() {
 	}
 
 	@Override
 	protected void paintIcon( Component c, Graphics2D g ) {
-		Path2D r1 = FlatUIUtils.createRectangle( 5, 3, 8, 8, 1 );
-		Path2D r2 = FlatUIUtils.createRectangle( 3, 5, 8, 8, 1 );
+		paintBackground( c, g );
+
+		g.setColor( c.getForeground() );
+
+		int x = (width / 2) - 4;
+		int y = (height / 2) - 4;
+		Path2D r1 = FlatUIUtils.createRectangle( x + 1, y - 1, 8, 8, 1 );
+		Path2D r2 = FlatUIUtils.createRectangle( x - 1, y + 1, 8, 8, 1 );
 
 		Area area = new Area( r1 );
-		area.subtract( new Area( new Rectangle2D.Float( 3, 5, 8, 8 ) ) );
+		area.subtract( new Area( new Rectangle2D.Float( x - 1, y + 1, 8, 8 ) ) );
 		g.fill( area );
 
 		g.fill( r2 );

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

@@ -21,39 +21,58 @@ 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}.
  *
- * @uiDefault Component.arrowType				String	triangle (default) or chevron
+ * @uiDefault Component.arrowType				String	chevron (default) or triangle
  * @uiDefault Menu.icon.arrowColor				Color
  * @uiDefault Menu.icon.disabledArrowColor		Color
  * @uiDefault Menu.selectionForeground			Color
+ * @uiDefault MenuItem.selectionType			String
  *
  * @author Karl Tauber
  */
 public class FlatMenuArrowIcon
 	extends FlatAbstractIcon
 {
-	protected final boolean chevron = "chevron".equals( 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 ) );
@@ -64,10 +83,15 @@ public class FlatMenuArrowIcon
 		}
 	}
 
-	private Color getArrowColor( Component c ) {
-		if( c instanceof JMenu && ((JMenu)c).isSelected() )
+	protected Color getArrowColor( Component c ) {
+		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() {
+		// not storing value of "MenuItem.selectionType" in class to allow changing at runtime
+		return "underline".equals( UIManager.getString( "MenuItem.selectionType" ) );
 	}
 }

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

@@ -16,46 +16,59 @@
 
 package com.formdev.flatlaf.icons;
 
+import java.awt.Component;
 import java.awt.Graphics2D;
 import java.awt.geom.Ellipse2D;
-import com.formdev.flatlaf.ui.FlatUIUtils;
+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 = FlatUIUtils.getUIInt( "RadioButton.icon.centerDiameter", 8 );
+	@Styleable protected float centerDiameter = getUIFloat( "RadioButton.icon.centerDiameter", 8, style );
 
 	@Override
-	protected void paintFocusBorder( Graphics2D g2 ) {
-		// the outline focus border is painted outside of the icon
-		int wh = ICON_SIZE + (focusWidth * 2);
-		g2.fillOval( -focusWidth, -focusWidth, wh, wh );
+	protected String getPropertyPrefix() {
+		return "RadioButton.";
 	}
 
 	@Override
-	protected void paintBorder( Graphics2D g2 ) {
-		g2.fillOval( 0, 0, 15, 15 );
+	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 paintBackground( Graphics2D g2 ) {
-		g2.fillOval( 1, 1, 13, 13 );
+	protected void paintBorder( Component c, Graphics2D g, float borderWidth ) {
+		if( borderWidth == 0 )
+			return;
+
+		g.fillOval( 0, 0, 15, 15 );
 	}
 
 	@Override
-	protected void paintCheckmark( Graphics2D g2 ) {
+	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
+	protected void paintCheckmark( Component c, Graphics2D g ) {
 		float xy = (ICON_SIZE - centerDiameter) / 2f;
-		g2.fill( new Ellipse2D.Float( xy, xy, centerDiameter, centerDiameter ) );
+		g.fill( new Ellipse2D.Float( xy, xy, centerDiameter, centerDiameter ) );
 	}
 }

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

@@ -0,0 +1,110 @@
+/*
+ * Copyright 2020 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.BasicStroke;
+import java.awt.Color;
+import java.awt.Component;
+import java.awt.Dimension;
+import java.awt.Graphics2D;
+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;
+
+/**
+ * "close" icon for closable tabs in {@link javax.swing.JTabbedPane}.
+ *
+ * @uiDefault TabbedPane.closeSize						Dimension
+ * @uiDefault TabbedPane.closeArc						int
+ * @uiDefault TabbedPane.closeCrossPlainSize			float
+ * @uiDefault TabbedPane.closeCrossFilledSize			float
+ * @uiDefault TabbedPane.closeCrossLineWidth			float
+ * @uiDefault TabbedPane.closeBackground				Color
+ * @uiDefault TabbedPane.closeForeground				Color
+ * @uiDefault TabbedPane.closeHoverBackground			Color
+ * @uiDefault TabbedPane.closeHoverForeground			Color
+ * @uiDefault TabbedPane.closePressedBackground			Color
+ * @uiDefault TabbedPane.closePressedForeground			Color
+ *
+ * @author Karl Tauber
+ */
+public class FlatTabbedPaneCloseIcon
+	extends FlatAbstractIcon
+{
+	@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, closeBackground, null, null, closeHoverBackground, closePressedBackground );
+		if( bg != null ) {
+			g.setColor( FlatUIUtils.deriveColor( bg, c.getBackground() ) );
+			g.fillRoundRect( (width - closeSize.width) / 2, (height - closeSize.height) / 2,
+				closeSize.width, closeSize.height, closeArc, closeArc );
+		}
+
+		// set cross color
+		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) ? closeCrossFilledSize : closeCrossPlainSize) / 2;
+
+		// paint cross
+		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,16 +16,23 @@
 
 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;
 
 /**
  * "collapsed" icon for {@link javax.swing.JTree}.
  *
- * @uiDefault Component.arrowType				String	triangle (default) or chevron
+ * @uiDefault Component.arrowType				String	chevron (default) or triangle
  * @uiDefault Tree.icon.collapsedColor			Color
  *
  * @author Karl Tauber
@@ -34,6 +41,7 @@ public class FlatTreeCollapsedIcon
 	extends FlatAbstractIcon
 {
 	private final boolean chevron;
+	private Path2D path;
 
 	public FlatTreeCollapsedIcon() {
 		this( UIManager.getColor( "Tree.icon.collapsedColor" ) );
@@ -41,24 +49,59 @@ public class FlatTreeCollapsedIcon
 
 	FlatTreeCollapsedIcon( Color color ) {
 		super( 11, 11, color );
-		chevron = "chevron".equals( UIManager.getString( "Component.arrowType" ) );
+		chevron = FlatUIUtils.isChevron( UIManager.getString( "Component.arrowType" ) );
 	}
 
 	@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 opend part
+				2,13.5,
+				// top-left of opend part
+				FlatUIUtils.ROUNDED, 4.5,7.5, arc,
+				// top-right of opend 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

@@ -0,0 +1,83 @@
+/*
+ * Copyright 2020 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.Dimension;
+import java.awt.Graphics2D;
+import java.awt.RenderingHints;
+import javax.swing.UIManager;
+import com.formdev.flatlaf.ui.FlatButtonUI;
+import com.formdev.flatlaf.ui.FlatUIUtils;
+import com.formdev.flatlaf.util.HiDPIUtils;
+
+/**
+ * Base class for window icons.
+ *
+ * @uiDefault TitlePane.buttonSize						Dimension
+ * @uiDefault TitlePane.buttonHoverBackground			Color
+ * @uiDefault TitlePane.buttonPressedBackground			Color
+ *
+ * @author Karl Tauber
+ */
+public abstract class FlatWindowAbstractIcon
+	extends FlatAbstractIcon
+{
+	private final Color hoverBackground;
+	private final Color pressedBackground;
+
+	public FlatWindowAbstractIcon() {
+		this( UIManager.getDimension( "TitlePane.buttonSize" ),
+			UIManager.getColor( "TitlePane.buttonHoverBackground" ),
+			UIManager.getColor( "TitlePane.buttonPressedBackground" ) );
+	}
+
+	public FlatWindowAbstractIcon( Dimension size, Color hoverBackground, Color pressedBackground ) {
+		super( size.width, size.height, null );
+		this.hoverBackground = hoverBackground;
+		this.pressedBackground = pressedBackground;
+	}
+
+	@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 );
+		if( background != null ) {
+			// disable antialiasing for background rectangle painting to avoid blury edges when scaled (e.g. at 125% or 175%)
+			Object oldHint = g.getRenderingHint( RenderingHints.KEY_ANTIALIASING );
+			g.setRenderingHint( RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_OFF );
+
+			g.setColor( FlatUIUtils.deriveColor( background, c.getBackground() ) );
+			g.fillRect( 0, 0, width, height );
+
+			g.setRenderingHint( RenderingHints.KEY_ANTIALIASING, oldHint );
+		}
+	}
+
+	protected Color getForeground( Component c ) {
+		return c.getForeground();
+	}
+}

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

@@ -0,0 +1,72 @@
+/*
+ * Copyright 2020 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.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.FlatButtonUI;
+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
+ *
+ * @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" ) );
+	}
+
+	@Override
+	protected void paintIconAt1x( Graphics2D g, int x, int y, int width, int height, double scaleFactor ) {
+		int iwh = (int) (10 * scaleFactor);
+		int ix = x + ((width - iwh) / 2);
+		int iy = y + ((height - iwh) / 2);
+		int ix2 = ix + iwh - 1;
+		int iy2 = iy + iwh - 1;
+		float thickness = SystemInfo.isWindows_11_orLater ? (float) scaleFactor : (int) scaleFactor;
+
+		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

@@ -0,0 +1,41 @@
+/*
+ * Copyright 2020 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.Graphics2D;
+
+/**
+ * "iconify" icon for windows (frames and dialogs).
+ *
+ * @author Karl Tauber
+ */
+public class FlatWindowIconifyIcon
+	extends FlatWindowAbstractIcon
+{
+	public FlatWindowIconifyIcon() {
+	}
+
+	@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 ix = x + ((width - iw) / 2);
+		int iy = y + ((height - ih) / 2);
+
+		g.fillRect( ix, iy, iw, ih );
+	}
+}

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

@@ -0,0 +1,46 @@
+/*
+ * Copyright 2020 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.Graphics2D;
+import com.formdev.flatlaf.ui.FlatUIUtils;
+import com.formdev.flatlaf.util.SystemInfo;
+
+/**
+ * "maximize" icon for windows (frames and dialogs).
+ *
+ * @author Karl Tauber
+ */
+public class FlatWindowMaximizeIcon
+	extends FlatWindowAbstractIcon
+{
+	public FlatWindowMaximizeIcon() {
+	}
+
+	@Override
+	protected void paintIconAt1x( Graphics2D g, int x, int y, int width, int height, double scaleFactor ) {
+		int iwh = (int) (10 * scaleFactor);
+		int ix = x + ((width - iwh) / 2);
+		int iy = y + ((height - iwh) / 2);
+		float thickness = SystemInfo.isWindows_11_orLater ? (float) scaleFactor : (int) scaleFactor;
+		int arc = Math.max( (int) (1.5 * scaleFactor), 2 );
+
+		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

@@ -0,0 +1,71 @@
+/*
+ * Copyright 2020 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.Graphics2D;
+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).
+ *
+ * @author Karl Tauber
+ */
+public class FlatWindowRestoreIcon
+	extends FlatWindowAbstractIcon
+{
+	public FlatWindowRestoreIcon() {
+	}
+
+	@Override
+	protected void paintIconAt1x( Graphics2D g, int x, int y, int width, int height, double scaleFactor ) {
+		int iwh = (int) (10 * scaleFactor);
+		int ix = x + ((width - iwh) / 2);
+		int iy = y + ((height - iwh) / 2);
+		float thickness = SystemInfo.isWindows_11_orLater ? (float) scaleFactor : (int) scaleFactor;
+		int arc = Math.max( (int) (1.5 * scaleFactor), 2 );
+		int arcOuter = (int) (arc + (1.5 * scaleFactor));
+
+		int rwh = (int) (8 * scaleFactor);
+		int ro2 = iwh - rwh;
+
+		// 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 );
+		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/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

@@ -17,15 +17,15 @@
 package com.formdev.flatlaf.ui;
 
 import static com.formdev.flatlaf.util.UIScale.scale;
-import java.awt.BasicStroke;
 import java.awt.Color;
+import java.awt.Container;
 import java.awt.Dimension;
 import java.awt.Graphics;
 import java.awt.Graphics2D;
-import java.awt.Shape;
 import java.awt.event.MouseAdapter;
 import java.awt.event.MouseEvent;
-import java.awt.geom.Path2D;
+import javax.swing.JComponent;
+import javax.swing.SwingUtilities;
 import javax.swing.plaf.UIResource;
 import javax.swing.plaf.basic.BasicArrowButton;
 
@@ -38,35 +38,38 @@ public class FlatArrowButton
 	extends BasicArrowButton
 	implements UIResource
 {
-	public static final int DEFAULT_ARROW_WIDTH = 8;
+	public static final int DEFAULT_ARROW_WIDTH = 9;
 
-	private final boolean chevron;
-	private final Color foreground;
-	private final Color disabledForeground;
-	private final Color hoverForeground;
-	private final Color hoverBackground;
+	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;
 
 	public FlatArrowButton( int direction, String type, Color foreground, Color disabledForeground,
-		Color hoverForeground, Color hoverBackground )
+		Color hoverForeground, Color hoverBackground, Color pressedForeground, Color pressedBackground )
 	{
 		super( direction, Color.WHITE, Color.WHITE, Color.WHITE, Color.WHITE );
-
-		this.chevron = "chevron".equals( type );
-		this.foreground = foreground;
-		this.disabledForeground = disabledForeground;
-		this.hoverForeground = hoverForeground;
-		this.hoverBackground = hoverBackground;
+		updateStyle( type, foreground, disabledForeground, hoverForeground, hoverBackground,
+			pressedForeground, pressedBackground );
 
 		setOpaque( false );
 		setBorder( null );
 
-		if( hoverForeground != null || hoverBackground != null ) {
+		if( hoverForeground != null || hoverBackground != null ||
+			pressedForeground != null || pressedBackground != null )
+		{
 			addMouseListener( new MouseAdapter() {
 				@Override
 				public void mouseEntered( MouseEvent e ) {
@@ -79,10 +82,39 @@ public class FlatArrowButton
 					hover = false;
 					repaint();
 				}
+
+				@Override
+				public void mousePressed( MouseEvent e ) {
+					if( SwingUtilities.isLeftMouseButton( e ) ) {
+						pressed = true;
+						repaint();
+					}
+				}
+
+				@Override
+				public void mouseReleased( MouseEvent e ) {
+					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;
 	}
@@ -91,26 +123,73 @@ 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;
 	}
 
-	public int getXOffset() {
+	protected boolean isPressed() {
+		return pressed;
+	}
+
+	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;
+	}
+
+	protected Color deriveForeground( Color foreground ) {
+		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() );
@@ -123,58 +202,45 @@ public class FlatArrowButton
 
 	@Override
 	public void paint( Graphics g ) {
-		Graphics2D g2 = (Graphics2D)g;
-		FlatUIUtils.setRenderingHints( g2 );
+		Object[] oldRenderingHints = FlatUIUtils.setRenderingHints( g );
 
-		int width = getWidth();
-		int height = getHeight();
-		boolean enabled = isEnabled();
+		// paint hover or pressed background
+		if( isEnabled() ) {
+			Color background = (pressedBackground != null && isPressed())
+				? pressedBackground
+				: (hoverBackground != null && isHover()
+					? hoverBackground
+					: null);
 
-		// paint hover background
-		if( enabled && isHover() && hoverBackground != null ) {
-			g.setColor( hoverBackground );
-			g.fillRect( 0, 0, width, height );
+			if( background != null ) {
+				g.setColor( deriveBackground( background ) );
+				paintBackground( (Graphics2D) g );
+			}
 		}
 
-		int direction = getDirection();
-		boolean vert = (direction == NORTH || direction == SOUTH);
-
-		int w = scale( arrowWidth + (chevron ? 0 : 1) );
-		int h = scale( (arrowWidth / 2) + (chevron ? 0 : 1) );
-		int rw = vert ? w : h;
-		int rh = vert ? h : w;
-		int x = Math.round( (width - rw) / 2f + scale( (float) xOffset ) );
-		int y = Math.round( (height - rh) / 2f + scale( (float) yOffset ) );
-
-		// optimization for small chevron arrows (e.g. OneTouchButtons in SplitPane)
-		if( x + rw >= width && x > 0 )
-			x--;
-		if( y + rh >= height && y > 0 )
-			y--;
-
 		// paint arrow
-		g.setColor( enabled
-			? (isHover() && hoverForeground != null ? hoverForeground : foreground)
-			: disabledForeground );
-		g.translate( x, y );
-		Shape arrowShape = createArrowShape( direction, chevron, w, h );
-		if( chevron ) {
-			g2.setStroke( new BasicStroke( scale( 1f ) ) );
-			g2.draw( arrowShape );
-		} else {
-			// triangle
-			g2.fill( arrowShape );
-		}
-		g.translate( -x, -y );
+		g.setColor( deriveForeground( getArrowColor() ) );
+		paintArrow( (Graphics2D) g );
+
+		FlatUIUtils.resetRenderingHints( g, oldRenderingHints );
 	}
 
-	public static Shape createArrowShape( int direction, boolean chevron, float w, float h ) {
-		switch( direction ) {
-			case NORTH:	return FlatUIUtils.createPath( !chevron, 0,h, (w / 2f),0, w,h );
-			case SOUTH:	return FlatUIUtils.createPath( !chevron, 0,0, (w / 2f),h, w,0 );
-			case WEST:	return FlatUIUtils.createPath( !chevron, h,0, 0,(w / 2f), h,w );
-			case EAST:	return FlatUIUtils.createPath( !chevron, 0,0, h,(w / 2f), 0,w );
-			default:	return new Path2D.Float();
+	protected void paintBackground( Graphics2D g ) {
+		g.fillRect( 0, 0, getWidth(), getHeight() );
+	}
+
+	protected void paintArrow( Graphics2D g ) {
+		int x = 0;
+
+		// move arrow for round borders
+		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,
+			getArrowWidth(), getArrowThickness(), getXOffset(), getYOffset() );
 	}
 }

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

@@ -22,49 +22,90 @@ 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 javax.swing.text.JTextComponent;
+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 focus border.
- *
- * Because there is empty space (if focus border is not painted),
+ * 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.focusColor			Color
- * @uiDefault Component.borderColor			Color
- * @uiDefault Component.disabledBorderColor	Color
- * @uiDefault Component.focusedBorderColor	Color
+ * @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
+ * @uiDefault Component.focusedBorderColor				Color
+ *
+ * @uiDefault Component.error.borderColor				Color
+ * @uiDefault Component.error.focusedBorderColor		Color
+ * @uiDefault Component.warning.borderColor				Color
+ * @uiDefault Component.warning.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 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 );
+
+	@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" );
+	@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 ) {
@@ -72,24 +113,75 @@ public class FlatBorder
 		try {
 			FlatUIUtils.setRenderingHints( g2 );
 
-			boolean isCellEditor = isTableCellEditor( c );
-			float focusWidth = isCellEditor ? 0 : getFocusWidth();
-			float borderWidth = getBorderWidth( c );
-			float arc = isCellEditor ? 0 : getArc();
+			float focusWidth = scale( (float) getFocusWidth( c ) );
+			float focusInnerWidth = 0;
+			float borderWidth = scale( getBorderWidth( c ) );
+			float arc = scale( (float) getArc( c ) );
+			Color outlineColor = getOutlineColor( c );
+			Color focusColor = null;
 
-			if( isFocused( c ) ) {
-				g2.setColor( getFocusColor( c ) );
-				FlatUIUtils.paintComponentOuterBorder( g2, x, y, width, height, focusWidth,
-					getLineWidth() + scale( innerFocusWidth ), arc );
+			// paint outer border
+			if( outlineColor != null || isFocused( c ) ) {
+				float innerWidth = !isCellEditor( c ) && !(c instanceof JScrollPane)
+					? (outlineColor != null ? innerOutlineWidth : getInnerFocusWidth( c ))
+					: 0;
+
+				if( focusWidth > 0 || innerWidth > 0 ) {
+					focusColor = (outlineColor != null) ? outlineColor : getFocusColor( c );
+					focusInnerWidth = borderWidth + scale( innerWidth );
+				}
 			}
 
-			g2.setPaint( getBorderColor( c ) );
-			FlatUIUtils.paintComponentBorder( g2, x, y, width, height, focusWidth, borderWidth, arc );
+			// paint border
+			Paint borderColor = (outlineColor != null) ? outlineColor : getBorderColor( c );
+			FlatUIUtils.paintOutlinedComponent( g2, x, y, width, height,
+				focusWidth, 1, focusInnerWidth, borderWidth, arc,
+				focusColor, borderColor, null );
 		} finally {
 			g2.dispose();
 		}
 	}
 
+	/**
+	 * Returns the outline color of the component border specified in client property
+	 * {@link FlatClientProperties#OUTLINE}.
+	 */
+	protected Color getOutlineColor( Component c ) {
+		if( !(c instanceof JComponent) )
+			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:
+					return isFocused( c ) ? errorFocusedBorderColor : errorBorderColor;
+
+				case FlatClientProperties.OUTLINE_WARNING:
+					return isFocused( c ) ? warningFocusedBorderColor : warningBorderColor;
+			}
+		} else if( outline instanceof Color ) {
+			Color color = (Color) outline;
+			// use color functions to compute color for unfocused state
+			if( !isFocused( c ) && customBorderColor instanceof DerivedColor )
+				color = ((DerivedColor)customBorderColor).derive( color );
+			return color;
+		} else if( outline instanceof Color[] && ((Color[])outline).length >= 2 )
+			return ((Color[])outline)[isFocused( c ) ? 0 : 1];
+
+		return null;
+	}
+
 	protected Color getFocusColor( Component c ) {
 		return focusColor;
 	}
@@ -109,71 +201,87 @@ public class FlatBorder
 				return false;
 		}
 
-		return c.isEnabled() && (!(c instanceof JTextComponent) || ((JTextComponent)c).isEditable());
+		return c.isEnabled();
 	}
 
 	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( view.hasFocus() )
-					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) ? editorComponent.hasFocus() : false;
-		} else if( c instanceof JSpinner ) {
-			JComponent editor = ((JSpinner)c).getEditor();
-			if( editor instanceof JSpinner.DefaultEditor ) {
-				JTextField textField = ((JSpinner.DefaultEditor)editor).getTextField();
-				if( textField != null )
-					return textField.hasFocus();
-			}
-			return false;
-		} else
-			return c.hasFocus();
+		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 );
 	}
 
-	protected boolean isTableCellEditor( Component c ) {
-		return FlatUIUtils.isTableCellEditor( c );
+	protected boolean isCellEditor( Component c ) {
+		return FlatUIUtils.isCellEditor( c );
 	}
 
 	@Override
 	public Insets getBorderInsets( Component c, Insets insets ) {
-		boolean isCellEditor = isTableCellEditor( c );
-		float ow = (isCellEditor ? 0 : getFocusWidth()) + getLineWidth();
+		float focusWidth = scale( (float) getFocusWidth( 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
+			insets.top = insets.bottom = 0;
+
+			// remove right/left insets to avoid that text is truncated (e.g. in file chooser)
+			if( c.getComponentOrientation().isLeftToRight() )
+				insets.right = 0;
+			else
+				insets.left = 0;
+		}
+
 		return insets;
 	}
 
-	protected float getFocusWidth() {
-		return scale( (float) focusWidth );
+	/**
+	 * Returns the (unscaled) thickness of the outer focus border.
+	 */
+	protected int getFocusWidth( Component c ) {
+		if( isCellEditor( c ) )
+			return 0;
+
+		return focusWidth;
 	}
 
-	protected float getLineWidth() {
-		return scale( 1f );
+	/**
+	 * Returns the (unscaled) thickness of the inner focus border.
+	 */
+	protected float getInnerFocusWidth( Component c ) {
+		return innerFocusWidth;
 	}
 
+	/**
+	 * Returns the (unscaled) line thickness used to compute the border insets.
+	 * This may be different to {@link #getBorderWidth}.
+	 */
+	protected int getLineWidth( Component c ) {
+		return 1;
+	}
+
+	/**
+	 * Returns the (unscaled) line thickness used to paint the border.
+	 * This may be different to {@link #getLineWidth}.
+	 */
 	protected float getBorderWidth( Component c ) {
-		return getLineWidth();
+		return borderWidth;
 	}
 
-	protected float getArc() {
+	/**
+	 * Returns the (unscaled) arc diameter of the border.
+	 */
+	protected int getArc( Component c ) {
 		return 0;
 	}
 }

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

@@ -16,62 +16,124 @@
 
 package com.formdev.flatlaf.ui;
 
-import static com.formdev.flatlaf.util.UIScale.scale;
 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.JButton;
+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.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.default.borderWidth		int
- * @uiDefault Button.arc						int
+ * @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
  *
  * @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 defaultBorderWidth = UIManager.getInt( "Button.default.borderWidth" );
-	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" );
+
+	@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 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.isHelpButton( c ) )
-			super.paintBorder( c, g, x, y, width, 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
+	protected boolean isFocused( Component c ) {
+		return FlatButtonUI.isFocusPainted( c ) && super.isFocused( c );
 	}
 
 	@Override
@@ -95,22 +157,45 @@ public class FlatButtonBorder
 
 	@Override
 	public Insets getBorderInsets( Component c, Insets insets ) {
-		insets = super.getBorderInsets( c, insets );
+		if( FlatButtonUI.isToolBarButton( c ) ) {
+			// In toolbars, use button margin only if explicitly set.
+			// Otherwise, use toolbar margin specified in UI defaults.
+			Insets margin = (c instanceof AbstractButton)
+				? ((AbstractButton)c).getMargin()
+				: null;
 
-		// use smaller left and right insets for icon-only buttons (so that they are square)
-		if( FlatButtonUI.isIconOnlyButton( c ) && ((JButton)c).getMargin() instanceof UIResource )
-			insets.left = insets.right = Math.min( insets.top, insets.bottom );
+			FlatUIUtils.setInsets( insets, UIScale.scale( FlatUIUtils.addInsets( toolbarSpacingInsets,
+				(margin != null && !(margin instanceof UIResource)) ? margin : toolbarMargin ) ) );
+		} else {
+			insets = super.getBorderInsets( c, insets );
+
+			// use smaller left and right insets for icon-only or single-character buttons (so that they are square)
+			if( FlatButtonUI.isIconOnlyOrSingleCharacterButton( c ) && ((AbstractButton)c).getMargin() instanceof UIResource )
+				insets.left = insets.right = Math.min( insets.top, insets.bottom );
+		}
 
 		return insets;
 	}
 
 	@Override
-	protected float getBorderWidth( Component c ) {
-		return FlatButtonUI.isDefaultButton( c ) ? scale( (float) defaultBorderWidth ) : super.getBorderWidth( c );
+	protected int getFocusWidth( Component c ) {
+		return FlatToggleButtonUI.isTabButton( c ) ? 0 : super.getFocusWidth( c );
 	}
 
 	@Override
-	protected float getArc() {
-		return scale( (float) arc );
+	protected float getBorderWidth( Component c ) {
+		return FlatButtonUI.isDefaultButton( c ) ? defaultBorderWidth : borderWidth;
+	}
+
+	@Override
+	protected int getArc( Component c ) {
+		if( isCellEditor( c ) )
+			return 0;
+
+		switch( FlatButtonUI.getButtonType( c ) ) {
+			case FlatButtonUI.TYPE_SQUARE: return 0;
+			case FlatButtonUI.TYPE_ROUND_RECT: return Short.MAX_VALUE;
+			default: return arc;
+		}
 	}
 }

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

@@ -20,27 +20,46 @@ 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;
 import java.awt.GradientPaint;
 import java.awt.Graphics;
 import java.awt.Graphics2D;
+import java.awt.Insets;
 import java.awt.Rectangle;
 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.border.Border;
+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 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.LoggingFacade;
 import com.formdev.flatlaf.util.UIScale;
 
 /**
@@ -57,73 +76,136 @@ import com.formdev.flatlaf.util.UIScale;
  *
  * <!-- FlatButtonUI -->
  *
- * @uiDefault Component.focusWidth				int
- * @uiDefault Button.arc						int
  * @uiDefault Button.minimumWidth				int
  * @uiDefault Button.iconTextGap				int
  * @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
  * @uiDefault Button.shadowColor				Color	optional
  * @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 focusWidth;
-	protected int arc;
-	protected int minimumWidth;
+	@Styleable protected int minimumWidth;
 	protected int iconTextGap;
 
+	protected Color background;
+	protected Color foreground;
+
 	protected Color startBackground;
 	protected Color endBackground;
-	protected Color focusedBackground;
-	protected Color hoverBackground;
-	protected Color pressedBackground;
-	protected Color disabledText;
+	@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 Color toolbarHoverBackground;
-	protected Color toolbarPressedBackground;
+	@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 static ComponentUI instance;
+	private Map<String, Object> oldStyleValues;
+	private AtomicBoolean borderShared;
 
 	public static ComponentUI createUI( JComponent c ) {
-		if( instance == null )
-			instance = new FlatButtonUI();
-		return instance;
+		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
@@ -133,41 +215,56 @@ public class FlatButtonUI
 		if( !defaults_initialized ) {
 			String prefix = getPropertyPrefix();
 
-			focusWidth = UIManager.getInt( "Component.focusWidth" );
-			arc = UIManager.getInt( "Button.arc" );
 			minimumWidth = UIManager.getInt( prefix + "minimumWidth" );
 			iconTextGap = FlatUIUtils.getUIInt( prefix + "iconTextGap", 4 );
 
+			background = UIManager.getColor( prefix + "background" );
+			foreground = UIManager.getColor( prefix + "foreground" );
+
 			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" );
-
-			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;
-			}
+			disabledSelectedBackground = UIManager.getColor( prefix + "disabledSelectedBackground" );
+			disabledSelectedForeground = UIManager.getColor( prefix + "disabledSelectedForeground" );
 
 			defaultBackground = FlatUIUtils.getUIColor( "Button.default.startBackground", "Button.default.background" );
 			defaultEndBackground = UIManager.getColor( "Button.default.endBackground" );
 			defaultForeground = UIManager.getColor( "Button.default.foreground" );
 			defaultFocusedBackground = UIManager.getColor( "Button.default.focusedBackground" );
+			defaultFocusedForeground = UIManager.getColor( "Button.default.focusedForeground" );
 			defaultHoverBackground = UIManager.getColor( "Button.default.hoverBackground" );
+			defaultHoverForeground = UIManager.getColor( "Button.default.hoverForeground" );
 			defaultPressedBackground = UIManager.getColor( "Button.default.pressedBackground" );
+			defaultPressedForeground = UIManager.getColor( "Button.default.pressedForeground" );
 			defaultBoldText = UIManager.getBoolean( "Button.default.boldText" );
 
+			paintShadow = UIManager.getBoolean( "Button.paintShadow" );
+			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;
 		}
 
@@ -180,41 +277,187 @@ public class FlatButtonUI
 		LookAndFeel.installProperty( b, "opaque", false );
 		LookAndFeel.installProperty( b, "iconTextGap", scale( iconTextGap ) );
 
-		MigLayoutVisualPadding.install( b, focusWidth );
+		MigLayoutVisualPadding.install( b );
 	}
 
 	@Override
 	protected void uninstallDefaults( AbstractButton b ) {
 		super.uninstallDefaults( b );
 
+		oldStyleValues = null;
+		borderShared = null;
+
 		MigLayoutVisualPadding.uninstall( b );
 		defaults_initialized = false;
 	}
 
+	@Override
+	protected BasicButtonListener createButtonListener( AbstractButton b ) {
+		return new FlatButtonListener( b );
+	}
+
+	protected void propertyChange( AbstractButton b, PropertyChangeEvent e ) {
+		switch( e.getPropertyName() ) {
+			case SQUARE_SIZE:
+			case MINIMUM_WIDTH:
+			case MINIMUM_HEIGHT:
+				b.revalidate();
+				break;
+
+			case BUTTON_TYPE:
+				b.revalidate();
+				b.repaint();
+				break;
+
+			case OUTLINE:
+				b.repaint();
+				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();
+				b.repaint();
+				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 );
+		}
+
+		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();
 	}
 
+	public static boolean isFocusPainted( Component c ) {
+		return !(c instanceof AbstractButton) || ((AbstractButton)c).isFocusPainted();
+	}
+
 	static boolean isDefaultButton( Component c ) {
 		return c instanceof JButton && ((JButton)c).isDefaultButton();
 	}
 
-	static boolean isIconOnlyButton( Component c ) {
-		if( !(c instanceof JButton) )
+	/**
+	 * Returns true if the button has an icon but no text,
+	 * 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) )
 			return false;
 
-		Icon icon = ((JButton)c).getIcon();
-		String text = ((JButton)c).getText();
+		Icon icon = ((AbstractButton)c).getIcon();
+		String text = ((AbstractButton)c).getText();
 		return (icon != null && (text == null || text.isEmpty())) ||
-			(icon == null && text != null && ("...".equals( text ) || text.length() == 1));
+			(icon == null && text != null &&
+			 ("...".equals( text ) ||
+			  text.length() == 1 ||
+			  (text.length() == 2 && Character.isSurrogatePair( text.charAt( 0 ), text.charAt( 1 ) ))));
+	}
+
+	static final int TYPE_OTHER = -1;
+	static final int TYPE_SQUARE = 0;
+	static final int TYPE_ROUND_RECT = 1;
+
+	static int getButtonType( Component c ) {
+		if( !(c instanceof AbstractButton) )
+			return TYPE_OTHER;
+
+		String value = getButtonTypeStr( (AbstractButton) c );
+		if( value == null )
+			return TYPE_OTHER;
+
+		switch( value ) {
+			case BUTTON_TYPE_SQUARE:		return TYPE_SQUARE;
+			case BUTTON_TYPE_ROUND_RECT:	return TYPE_ROUND_RECT;
+			default:						return TYPE_OTHER;
+		}
 	}
 
 	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( JComponent c ) {
-		return c.getParent() instanceof JToolBar;
+	static boolean isToolBarButton( Component c ) {
+		return c.getParent() instanceof JToolBar ||
+			(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
@@ -228,41 +471,103 @@ public class FlatButtonUI
 			return;
 		}
 
-		if( isContentAreaFilled( c ) ) {
-			Color background = getBackground( c );
-			if( background != null ) {
-				Graphics2D g2 = (Graphics2D) g.create();
-				try {
-					FlatUIUtils.setRenderingHints( g2 );
+		if( isContentAreaFilled( c ) )
+			paintBackground( g, c );
 
-					Border border = c.getBorder();
-					float focusWidth = (border instanceof FlatBorder) ? scale( (float) this.focusWidth ) : 0;
-					float arc = (border instanceof FlatButtonBorder || isToolBarButton( c )) ? scale( (float) this.arc ) : 0;
-					boolean def = isDefaultButton( c );
+		paint( g, c );
+	}
 
-					// paint shadow
-					Color shadowColor = def ? defaultShadowColor : this.shadowColor;
-					if( shadowColor != null && shadowWidth > 0 && focusWidth > 0 && !c.hasFocus() && c.isEnabled() ) {
-						g2.setColor( shadowColor );
-						g2.fill( new RoundRectangle2D.Float( focusWidth, focusWidth + UIScale.scale( (float) shadowWidth ),
-							c.getWidth() - focusWidth * 2, c.getHeight() - focusWidth * 2, arc, arc ) );
-					}
+	protected void paintBackground( Graphics g, JComponent c ) {
+		Color background = getBackground( c );
+		if( background == null )
+			return;
 
-					// paint background
-					Color startBg = def ? defaultBackground : startBackground;
-					Color endBg = def ? defaultEndBackground : endBackground;
-					if( background == startBg && endBg != null && !startBg.equals( endBg ) )
-						g2.setPaint( new GradientPaint( 0, 0, startBg, 0, c.getHeight(), endBg ) );
-					else
-						FlatUIUtils.setColor( g2, background, def ? defaultBackground : c.getBackground() );
-					FlatUIUtils.paintComponentBackground( g2, 0, 0, c.getWidth(), c.getHeight(), focusWidth, arc );
-				} finally {
-					g2.dispose();
-				}
+		Graphics2D g2 = (Graphics2D) g.create();
+		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;
+
+			// 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 && 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( 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 ),
+					width - focusWidth * 2, height - focusWidth * 2, arc, arc ) );
+			}
+
+			// paint background
+			Color startBg = def ? defaultBackground : startBackground;
+			Color endBg = def ? defaultEndBackground : endBackground;
+			if( background == startBg && endBg != null && !startBg.equals( endBg ) )
+				g2.setPaint( new GradientPaint( 0, 0, startBg, 0, height, endBg ) );
+			else
+				g2.setColor( FlatUIUtils.deriveColor( background, getBackgroundBase( c, def ) ) );
+
+			FlatUIUtils.paintComponentBackground( g2, x, y, width, height, focusWidth, arc );
+		} finally {
+			g2.dispose();
+		}
+	}
+
+	@Override
+	public void paint( Graphics g, JComponent c ) {
+		super.paint( FlatLabelUI.createGraphicsHTMLTextYCorrection( g, c ), c );
+	}
+
+	@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;
 			}
 		}
 
-		paint( g, c );
+		super.paintIcon( g, c, iconRect );
 	}
 
 	@Override
@@ -281,10 +586,12 @@ public class FlatButtonUI
 			}
 		}
 
-		paintText( g, b, textRect, text, b.isEnabled() ? getForeground( b ) : disabledText );
+		paintText( g, b, textRect, text, getForeground( b ) );
 	}
 
 	public static void paintText( Graphics g, AbstractButton b, Rectangle textRect, String text, Color foreground ) {
+		if(foreground == null)
+			foreground=Color.red;
 		FontMetrics fm = b.getFontMetrics( b.getFont() );
 		int mnemonicIndex = FlatLaf.isShowMnemonics() ? b.getDisplayedMnemonicIndex() : -1;
 
@@ -294,53 +601,132 @@ public class FlatButtonUI
 	}
 
 	protected Color getBackground( JComponent c ) {
-		if( !c.isEnabled() )
-			return null;
+		boolean toolBarButton = isToolBarButton( c ) || isBorderlessButton( c );
+
+		// selected state
+		if( ((AbstractButton)c).isSelected() ) {
+			// in toolbar, if toolbarDisabledSelectedBackground is null,
+			// use same background colors for disabled and enabled because
+			// we assume that toolbar icon is shown disabled
+			return buttonStateColor( c,
+				toolBarButton ? toolbarSelectedBackground : selectedBackground,
+				toolBarButton
+					? (toolbarDisabledSelectedBackground != null ? toolbarDisabledSelectedBackground : toolbarSelectedBackground)
+					: disabledSelectedBackground,
+				null,
+				null,
+				toolBarButton ? toolbarPressedBackground : pressedBackground );
+		}
 
 		// toolbar button
-		if( isToolBarButton( c ) ) {
-			ButtonModel model = ((AbstractButton)c).getModel();
-			if( model.isPressed() )
-				return toolbarPressedBackground;
-			if( model.isRollover() )
-				return toolbarHoverBackground;
-
-			// use background of toolbar
-			return c.getParent().getBackground();
+		if( toolBarButton ) {
+			Color bg = c.getBackground();
+			return buttonStateColor( c,
+				isCustomBackground( bg ) ? bg : null,
+				null,
+				null,
+				toolbarHoverBackground,
+				toolbarPressedBackground );
 		}
 
 		boolean def = isDefaultButton( c );
 		return buttonStateColor( c,
-			def ? defaultBackground : c.getBackground(),
-			null,
-			def ? defaultFocusedBackground : focusedBackground,
+			getBackgroundBase( c, def ),
+			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 ) )
+			return bg;
+
+		return def ? defaultBackground : bg;
+	}
+
+	protected boolean isCustomBackground( Color bg ) {
+		return bg != background && (startBackground == null || bg != startBackground);
+	}
+
 	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( focusedColor != null && c.hasFocus() )
+			if( hoverColor != null && model.isRollover() )
+				return hoverColor;
+		}
+
+		if( focusedColor != null && isFocusPainted( c ) && FlatUIUtils.isPermanentFocusOwner( c ) )
 			return focusedColor;
 
 		return enabledColor;
 	}
 
 	protected Color getForeground( JComponent c ) {
+		boolean toolBarButton = isToolBarButton( c ) || isBorderlessButton( c );
+
+		// selected state
+		if( ((AbstractButton)c).isSelected() ) {
+			return buttonStateColor( c,
+				toolBarButton
+					? (toolbarSelectedForeground != null ? toolbarSelectedForeground : c.getForeground())
+					: selectedForeground,
+				toolBarButton
+					? (toolbarDisabledSelectedForeground != null ? toolbarDisabledSelectedForeground : disabledText)
+					: (disabledSelectedForeground != null ? disabledSelectedForeground : disabledText),
+				null,
+				null,
+				toolBarButton ? toolbarPressedForeground : pressedForeground );
+		}
+
+		// toolbar button
+		if( toolBarButton ) {
+			return buttonStateColor( c,
+				c.getForeground(),
+				disabledText,
+				null,
+				toolbarHoverForeground,
+				toolbarPressedForeground );
+		}
+
 		boolean def = isDefaultButton( c );
-		return def ? defaultForeground : c.getForeground();
+		return buttonStateColor( c,
+			getForegroundBase( c, def ),
+			disabledText,
+			isCustomForeground( c.getForeground() ) ? 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;
+
+		return def ? defaultForeground : fg;
+	}
+
+	protected boolean isCustomForeground( Color fg ) {
+		return fg != foreground;
 	}
 
 	@Override
@@ -349,14 +735,85 @@ public class FlatButtonUI
 			return new Dimension( helpButtonIcon.getIconWidth(), helpButtonIcon.getIconHeight() );
 
 		Dimension prefSize = super.getPreferredSize( c );
+		if( prefSize == null )
+			return null;
 
-		// make button square if it is a icon-only button
-		// or apply minimum width, if not in toolbar and not a icon-only button
-		if( isIconOnlyButton( c ) )
+		// increase width when using bold font for default button
+		prefSize.width += defaultBoldPlainWidthDiff( c );
+
+		// make square or apply minimum width/height
+		boolean isIconOnlyOrSingleCharacter = isIconOnlyOrSingleCharacterButton( c );
+		if( clientPropertyBoolean( c, SQUARE_SIZE, squareSize ) ) {
+			// 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( !isToolBarButton( c ) )
-			prefSize.width = Math.max( prefSize.width, scale( minimumWidth + (focusWidth * 2) ) );
+		} else if( !isIconOnlyOrSingleCharacter && !isToolBarButton( c ) &&
+			c.getBorder() instanceof FlatButtonBorder && hasDefaultMargins( c ) )
+		{
+			// apply minimum width/height
+			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 );
+	}
+
+	//---- class FlatButtonListener -------------------------------------------
+
+	protected class FlatButtonListener
+		extends BasicButtonListener
+	{
+		private final AbstractButton b;
+
+		protected FlatButtonListener( AbstractButton b ) {
+			super( b );
+			this.b = b;
+		}
+
+		@Override
+		public void propertyChange( PropertyChangeEvent e ) {
+			super.propertyChange( e );
+			FlatButtonUI.this.propertyChange( b, e );
+		}
+
+		@Override
+		public void stateChanged( ChangeEvent e ) {
+			super.stateChanged( e );
+
+			// 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 );
+			}
+		}
+	}
 }

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

@@ -0,0 +1,292 @@
+/*
+ * Copyright 2020 FormDev Software GmbH
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.formdev.flatlaf.ui;
+
+import static com.formdev.flatlaf.FlatClientProperties.*;
+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.JFormattedTextField;
+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.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
+ */
+public class FlatCaret
+	extends DefaultCaret
+	implements UIResource
+{
+	private static final String KEY_CARET_INFO = "FlatLaf.internal.caretInfo";
+
+	private final String selectAllOnFocusPolicy;
+	private final boolean selectAllOnMouseClick;
+
+	private boolean inInstall;
+	private boolean wasFocused;
+	private boolean wasTemporaryLost;
+	private boolean isMousePressed;
+	private boolean isWordSelection;
+	private boolean isLineSelection;
+	private int dragSelectionStart;
+	private int dragSelectionEnd;
+
+	public FlatCaret( String selectAllOnFocusPolicy, boolean selectAllOnMouseClick ) {
+		this.selectAllOnFocusPolicy = selectAllOnFocusPolicy;
+		this.selectAllOnMouseClick = selectAllOnMouseClick;
+	}
+
+	@Override
+	public void install( JTextComponent c ) {
+		// get caret info if switched theme
+		long[] ci = (long[]) c.getClientProperty( KEY_CARET_INFO );
+		if( ci != null ) {
+			c.putClientProperty( KEY_CARET_INFO, null );
+
+			// 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 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(),
+		} );
+
+		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 focusGained( FocusEvent e ) {
+		if( !inInstall && !wasTemporaryLost && (!isMousePressed || selectAllOnMouseClick) )
+			selectAllOnFocusGained();
+		wasTemporaryLost = false;
+		wasFocused = true;
+
+		super.focusGained( e );
+	}
+
+	@Override
+	public void focusLost( FocusEvent e ) {
+		wasTemporaryLost = e.isTemporary();
+		super.focusLost( e );
+	}
+
+	@Override
+	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() || FlatUIUtils.isCellEditor( c ) )
+			return;
+
+		Object selectAllOnFocusPolicy = c.getClientProperty( SELECT_ALL_ON_FOCUS_POLICY );
+		if( selectAllOnFocusPolicy == null )
+			selectAllOnFocusPolicy = this.selectAllOnFocusPolicy;
+
+		if( selectAllOnFocusPolicy == null || SELECT_ALL_ON_FOCUS_POLICY_NEVER.equals( selectAllOnFocusPolicy ) )
+			return;
+
+		if( !SELECT_ALL_ON_FOCUS_POLICY_ALWAYS.equals( selectAllOnFocusPolicy ) ) {
+			// policy is "once" (or null or unknown)
+
+			// 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() )
+				return;
+		}
+
+		// select all
+		if( c instanceof JFormattedTextField ) {
+			EventQueue.invokeLater( () -> {
+				if( getComponent() == null )
+					return; // was deinstalled
+
+				select( 0, doc.getLength() );
+			} );
+		} else {
+			select( 0, doc.getLength() );
+		}
+	}
+
+	private void select( int mark, int dot ) {
+		if( mark != getMark() )
+			setDot( mark );
+		if( dot != getDot() )
+			moveDot( dot );
+	}
+
+	/** @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

@@ -16,62 +16,148 @@
 
 package com.formdev.flatlaf.ui;
 
-import static com.formdev.flatlaf.util.UIScale.scale;
+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.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}.
  *
  * <!-- BasicCheckBoxMenuItemUI -->
  *
- * @uiDefault CheckBoxMenuItem.font								Font
- * @uiDefault CheckBoxMenuItem.background						Color
- * @uiDefault CheckBoxMenuItem.foreground						Color
- * @uiDefault CheckBoxMenuItem.disabledForeground				Color
- * @uiDefault CheckBoxMenuItem.selectionBackground				Color
- * @uiDefault CheckBoxMenuItem.selectionForeground				Color
- * @uiDefault CheckBoxMenuItem.acceleratorForeground			Color
- * @uiDefault CheckBoxMenuItem.acceleratorSelectionForeground	Color
- * @uiDefault MenuItem.acceleratorFont							Font		defaults to MenuItem.font
- * @uiDefault MenuItem.acceleratorDelimiter						String
- * @uiDefault CheckBoxMenuItem.border							Border
- * @uiDefault CheckBoxMenuItem.borderPainted					boolean
- * @uiDefault CheckBoxMenuItem.margin							Insets
- * @uiDefault CheckBoxMenuItem.arrowIcon						Icon
- * @uiDefault CheckBoxMenuItem.checkIcon						Icon
- * @uiDefault CheckBoxMenuItem.opaque							boolean
- * @uiDefault CheckBoxMenuItem.evenHeight						boolean
+ * @uiDefault CheckBoxMenuItem.font									Font
+ * @uiDefault CheckBoxMenuItem.background							Color
+ * @uiDefault CheckBoxMenuItem.foreground							Color
+ * @uiDefault CheckBoxMenuItem.disabledForeground					Color
+ * @uiDefault CheckBoxMenuItem.selectionBackground					Color
+ * @uiDefault CheckBoxMenuItem.selectionForeground					Color
+ * @uiDefault CheckBoxMenuItem.acceleratorForeground				Color
+ * @uiDefault CheckBoxMenuItem.acceleratorSelectionForeground		Color
+ * @uiDefault MenuItem.acceleratorFont								Font		defaults to MenuItem.font
+ * @uiDefault MenuItem.acceleratorDelimiter							String
+ * @uiDefault CheckBoxMenuItem.border								Border
+ * @uiDefault CheckBoxMenuItem.borderPainted						boolean
+ * @uiDefault CheckBoxMenuItem.margin								Insets
+ * @uiDefault CheckBoxMenuItem.arrowIcon							Icon
+ * @uiDefault CheckBoxMenuItem.checkIcon							Icon
+ * @uiDefault CheckBoxMenuItem.opaque								boolean
+ *
+ * <!-- FlatCheckBoxMenuItemUI -->
+ *
+ * @uiDefault MenuItem.iconTextGap									int
  *
  * @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();
 
-		// scale
-		defaultTextIconGap = scale( defaultTextIconGap );
+		LookAndFeel.installProperty( menuItem, "iconTextGap", FlatUIUtils.getUIInt( "MenuItem.iconTextGap", 4 ) );
+
+		renderer = createRenderer();
+	}
+
+	@Override
+	protected void uninstallDefaults() {
+		super.uninstallDefaults();
+
+		FlatMenuItemRenderer.clearClientProperties( menuItem.getParent() );
+		renderer = null;
+		oldStyleValues = null;
+	}
+
+	protected FlatMenuItemRenderer createRenderer() {
+		return new FlatMenuItemRenderer( menuItem, checkIcon, arrowIcon, acceleratorFont, acceleratorDelimiter );
 	}
 
-	/**
-	 * Scale defaultTextIconGap again if iconTextGap property has changed.
-	 */
 	@Override
 	protected PropertyChangeListener createPropertyChangeListener( JComponent c ) {
-		PropertyChangeListener superListener = super.createPropertyChangeListener( c );
-		return e -> {
-			superListener.propertyChange( e );
-			if( e.getPropertyName() == "iconTextGap" )
-				defaultTextIconGap = scale( defaultTextIconGap );
-		};
+		return 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();
+	}
+
+	@Override
+	public void paint( Graphics g, JComponent c ) {
+		renderer.paintMenuItem( g, selectionBackground, selectionForeground, disabledForeground,
+			acceleratorForeground, acceleratorSelectionForeground );
 	}
 }

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

@@ -42,16 +42,25 @@ import javax.swing.plaf.ComponentUI;
 public class FlatCheckBoxUI
 	extends FlatRadioButtonUI
 {
-	private static ComponentUI instance;
-
 	public static ComponentUI createUI( JComponent c ) {
-		if( instance == null )
-			instance = new FlatCheckBoxUI();
-		return instance;
+		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/FlatColorChooserUI.java

@@ -16,12 +16,9 @@
 
 package com.formdev.flatlaf.ui;
 
-import java.awt.Dimension;
 import javax.swing.JComponent;
-import javax.swing.UIManager;
 import javax.swing.plaf.ComponentUI;
 import javax.swing.plaf.basic.BasicColorChooserUI;
-import com.formdev.flatlaf.util.UIScale;
 
 /**
  * Provides the Flat LaF UI delegate for {@link javax.swing.JColorChooser}.
@@ -43,21 +40,4 @@ public class FlatColorChooserUI
 	public static ComponentUI createUI( JComponent c ) {
 		return  new FlatColorChooserUI();
 	}
-
-	@Override
-	public void installUI( JComponent c ) {
-		if( UIScale.getUserScaleFactor() != 1f ) {
-			// temporary scale swatch sizes
-			Dimension swatchSize = UIManager.getDimension( "ColorChooser.swatchesSwatchSize" );
-			Dimension swatchSize2 = UIManager.getDimension( "ColorChooser.swatchesRecentSwatchSize" );
-			UIManager.put( "ColorChooser.swatchesSwatchSize", UIScale.scale( swatchSize ) );
-			UIManager.put( "ColorChooser.swatchesRecentSwatchSize", UIScale.scale( swatchSize2 ) );
-
-			super.installUI( c );
-
-			UIManager.put( "ColorChooser.swatchesSwatchSize", null );
-			UIManager.put( "ColorChooser.swatchesRecentSwatchSize", null );
-		} else
-			super.installUI( c );
-	}
 }

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

@@ -0,0 +1,382 @@
+/*
+ * Copyright 2020 FormDev Software GmbH
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.formdev.flatlaf.ui;
+
+import java.awt.Color;
+import java.awt.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;
+import java.awt.LayoutManager;
+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;
+import javax.swing.JLayeredPane;
+import javax.swing.JRootPane;
+import javax.swing.JToolTip;
+import javax.swing.LookAndFeel;
+import javax.swing.SwingConstants;
+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;
+
+/**
+ * Provides the Flat LaF UI delegate for {@link javax.swing.JInternalFrame.JDesktopIcon}.
+ *
+ * <!-- BasicDesktopIconUI -->
+ *
+ * @uiDefault DesktopIcon.border					Border
+ *
+ * <!-- FlatDesktopIconUI -->
+ *
+ * @uiDefault DesktopIcon.background				Color
+ * @uiDefault DesktopIcon.foreground				Color
+ * @uiDefault DesktopIcon.iconSize					Dimension
+ * @uiDefault DesktopIcon.closeSize					Dimension
+ * @uiDefault DesktopIcon.closeIcon					Icon
+ *
+ * @author Karl Tauber
+ */
+public class FlatDesktopIconUI
+	extends BasicDesktopIconUI
+{
+	private Dimension iconSize;
+	private Dimension closeSize;
+
+	private JLabel dockIcon;
+	private JButton closeButton;
+	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 );
+
+		dockIcon = null;
+		closeButton = null;
+	}
+
+	@Override
+	protected void installComponents() {
+		dockIcon = new JLabel();
+		dockIcon.setHorizontalAlignment( SwingConstants.CENTER );
+
+		closeButton = new JButton();
+		closeButton.setIcon( UIManager.getIcon( "DesktopIcon.closeIcon" ) );
+		closeButton.setFocusable( false );
+		closeButton.setBorder( BorderFactory.createEmptyBorder() );
+		closeButton.setOpaque( true );
+		closeButton.setBackground( FlatUIUtils.nonUIResource( desktopIcon.getBackground() ) );
+		closeButton.setForeground( FlatUIUtils.nonUIResource( desktopIcon.getForeground() ) );
+		closeButton.setVisible( false );
+
+		desktopIcon.setLayout( new FlatDesktopIconLayout() );
+		desktopIcon.add( closeButton );
+		desktopIcon.add( dockIcon );
+	}
+
+	@Override
+	protected void uninstallComponents() {
+		hideTitleTip();
+
+		desktopIcon.remove( dockIcon );
+		desktopIcon.remove( closeButton );
+		desktopIcon.setLayout( null );
+	}
+
+	@Override
+	protected void installDefaults() {
+		super.installDefaults();
+
+		LookAndFeel.installColors( desktopIcon, "DesktopIcon.background", "DesktopIcon.foreground" );
+
+		iconSize = UIManager.getDimension( "DesktopIcon.iconSize" );
+		closeSize = UIManager.getDimension( "DesktopIcon.closeSize" );
+	}
+
+	@Override
+	protected void installListeners() {
+		super.installListeners();
+
+		closeListener = e -> {
+			if( frame.isClosable() )
+				frame.doDefaultCloseAction();
+		};
+		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
+	protected void uninstallListeners() {
+		super.uninstallListeners();
+
+		closeButton.removeActionListener( closeListener );
+		closeButton.removeMouseListener( mouseInputListener );
+		closeListener = null;
+		mouseInputListener = null;
+
+		desktopIcon.removePropertyChangeListener( "ancestor", ancestorListener );
+		ancestorListener = null;
+	}
+
+	@Override
+	protected MouseInputListener createMouseInputListener() {
+		mouseInputListener = new MouseInputAdapter() {
+			@Override
+			public void mouseReleased( MouseEvent e ) {
+				if( frame.isIcon() && desktopIcon.contains( e.getX(), e.getY() ) ) {
+					hideTitleTip();
+					closeButton.setVisible( false );
+
+					try {
+						frame.setIcon( false );
+					} catch( PropertyVetoException ex ) {
+						// ignore
+					}
+				}
+			}
+
+			@Override
+			public void mouseEntered( MouseEvent e ) {
+				showTitleTip();
+				if( frame.isClosable() )
+					closeButton.setVisible( true );
+			}
+
+			@Override
+			public void mouseExited( MouseEvent e ) {
+				hideTitleTip();
+				closeButton.setVisible( false );
+			}
+		};
+		return mouseInputListener;
+	}
+
+	private void showTitleTip() {
+		JRootPane rootPane = SwingUtilities.getRootPane( desktopIcon );
+		if( rootPane == null )
+			return;
+
+		if( titleTip == null ) {
+			titleTip = new JToolTip();
+			rootPane.getLayeredPane().add( titleTip, JLayeredPane.POPUP_LAYER );
+		}
+		titleTip.setTipText( frame.getTitle() );
+		titleTip.setSize( titleTip.getPreferredSize() );
+
+		int tx = (desktopIcon.getWidth() - titleTip.getWidth()) / 2;
+		int ty = -(titleTip.getHeight() + UIScale.scale( 4 ));
+		Point pt = SwingUtilities.convertPoint( desktopIcon, tx, ty, titleTip.getParent() );
+		if( pt.x + titleTip.getWidth() > rootPane.getWidth() )
+			pt.x = rootPane.getWidth() - titleTip.getWidth();
+		if( pt.x < 0 )
+			pt.x = 0;
+		titleTip.setLocation( pt );
+		titleTip.repaint();
+	}
+
+	private void hideTitleTip() {
+		if( titleTip == null )
+			return;
+
+		titleTip.setVisible( false );
+		titleTip.getParent().remove( titleTip );
+		titleTip = null;
+	}
+
+	@Override
+	public Dimension getPreferredSize( JComponent c ) {
+		return UIScale.scale( iconSize );
+	}
+
+	@Override
+	public Dimension getMinimumSize( JComponent c ) {
+		return getPreferredSize( c );
+	}
+
+	@Override
+	public Dimension getMaximumSize( JComponent c ) {
+		return getPreferredSize( c );
+	}
+
+	@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 )
+				updateDockIconPreview();
+		} );
+	}
+
+	protected void updateDockIconPreview() {
+		// make sure that frame is not selected
+		if( frame.isSelected() ) {
+			try {
+				frame.setSelected( false );
+			} catch( PropertyVetoException ex ) {
+				// ignore
+			}
+		}
+
+		// 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 {
+			frame.paint( g );
+		} finally {
+			g.dispose();
+		}
+
+		// compute preview size (keep ratio; also works with non-square preview)
+		Insets insets = desktopIcon.getInsets();
+		int previewWidth = UIScale.scale( iconSize.width ) - insets.left - insets.right;
+		int previewHeight = UIScale.scale( iconSize.height ) - insets.top - insets.bottom;
+		float frameRatio = ((float) frameHeight / (float) frameWidth);
+		if( ((float) previewWidth / (float) frameWidth) > ((float) previewHeight / (float) frameHeight) )
+			previewWidth = Math.round( previewHeight / frameRatio );
+		else
+			previewHeight = Math.round( previewWidth * frameRatio );
+
+		// 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 ) );
+	}
+
+	//---- class DockIcon -----------------------------------------------------
+
+	private class FlatDesktopIconLayout
+		implements LayoutManager
+	{
+		@Override public void addLayoutComponent( String name, Component comp ) {}
+		@Override public void removeLayoutComponent( Component comp ) {}
+
+		@Override
+		public Dimension preferredLayoutSize( Container parent ) {
+			return dockIcon.getPreferredSize();
+		}
+
+		@Override
+		public Dimension minimumLayoutSize( Container parent ) {
+			return dockIcon.getMinimumSize();
+		}
+
+		@Override
+		public void layoutContainer( Container parent ) {
+			Insets insets = parent.getInsets();
+
+			// dock icon
+			dockIcon.setBounds( insets.left, insets.top,
+				parent.getWidth() - insets.left - insets.right,
+				parent.getHeight() - insets.top - insets.bottom );
+
+			// close button in upper right corner
+			Dimension cSize = UIScale.scale( closeSize );
+			closeButton.setBounds( parent.getWidth() - cSize.width, 0, cSize.width, cSize.height );
+		}
+	}
+}

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

@@ -0,0 +1,136 @@
+/*
+ * Copyright 2020 FormDev Software GmbH
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.formdev.flatlaf.ui;
+
+import java.awt.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.JDesktopIcon;
+import javax.swing.plaf.ComponentUI;
+import javax.swing.plaf.basic.BasicDesktopPaneUI;
+
+/**
+ * Provides the Flat LaF UI delegate for {@link javax.swing.JDesktopPane}.
+ *
+ * <!-- BasicDesktopPaneUI -->
+ *
+ * @uiDefault Desktop.background					Color
+ * @uiDefault Desktop.minOnScreenInsets				Insets
+ *
+ * @author Karl Tauber
+ */
+public class FlatDesktopPaneUI
+	extends BasicDesktopPaneUI
+{
+	private LayoutDockListener layoutDockListener;
+	private boolean layoutDockPending;
+
+	public static ComponentUI createUI( JComponent c ) {
+		return new FlatDesktopPaneUI();
+	}
+
+	@Override
+	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 LayoutDockListener -------------------------------------------
+
+	private class LayoutDockListener
+		extends ComponentAdapter
+		implements ContainerListener
+	{
+		@Override
+		public void componentAdded( ContainerEvent e ) {
+			layoutDockLaterOnce();
+		}
+
+		@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

@@ -0,0 +1,265 @@
+/*
+ * Copyright 2020 FormDev Software GmbH
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.formdev.flatlaf.ui;
+
+import java.awt.Color;
+import java.awt.Component;
+import java.awt.Graphics;
+import java.awt.Graphics2D;
+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;
+
+/**
+ * Paints a drop shadow border around the component.
+ * Supports 1-sided, 2-side, 3-sided or 4-sided drop shadows.
+ * <p>
+ * The shadow insets allow specifying drop shadow thickness for each side.
+ * A zero or negative value hides the drop shadow on that side.
+ * A negative value can be used to indent the drop shadow on corners.
+ * E.g. -4 on left indents drop shadow at top-left and bottom-left corners by 4 pixels.
+ *
+ * @author Karl Tauber
+ */
+public class FlatDropShadowBorder
+	extends FlatEmptyBorder
+	implements StyleableBorder
+{
+	@Styleable protected Color shadowColor;
+	@Styleable protected Insets shadowInsets;
+	@Styleable protected float shadowOpacity;
+
+	private int shadowSize;
+	private Image shadowImage;
+	private Color lastShadowColor;
+	private float lastShadowOpacity;
+	private int lastShadowSize;
+	private double lastSystemScaleFactor;
+	private float lastUserScaleFactor;
+
+	public FlatDropShadowBorder() {
+		this( null );
+	}
+
+	public FlatDropShadowBorder( Color shadowColor ) {
+		this( shadowColor, 4, 0.5f );
+	}
+
+	public FlatDropShadowBorder( Color shadowColor, int shadowSize, float shadowOpacity ) {
+		this( shadowColor, new Insets( -shadowSize, -shadowSize, shadowSize, shadowSize ), shadowOpacity );
+	}
+
+	public FlatDropShadowBorder( Color shadowColor, Insets shadowInsets, float shadowOpacity ) {
+		super( nonNegativeInsets( shadowInsets ) );
+
+		this.shadowColor = shadowColor;
+		this.shadowInsets = shadowInsets;
+		this.shadowOpacity = shadowOpacity;
+
+		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 )
+			return;
+
+		HiDPIUtils.paintAtScale1x( (Graphics2D) g, x, y, width, height, this::paintImpl );
+	}
+
+	private void paintImpl( Graphics2D g, int x, int y, int width, int height, double scaleFactor ) {
+		Color shadowColor = (this.shadowColor != null) ? this.shadowColor : g.getColor();
+		int shadowSize = scale( this.shadowSize, scaleFactor );
+
+		// create and cache shadow image
+		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;
+		}
+
+/*debug
+		int m = shadowImage.getWidth( null );
+		Color oldColor = g.getColor();
+		g.setColor( Color.lightGray );
+		g.drawRect( x - m - 1, y - m - 1, m + 1, m + 1 );
+		g.setColor( Color.white );
+		g.fillRect( x - m, y - m, m, m );
+		g.drawImage( shadowImage, x - m, y - m, null );
+		g.setColor( oldColor );
+debug*/
+
+		int left = scale( shadowInsets.left, scaleFactor );
+		int right = scale( shadowInsets.right, scaleFactor );
+		int top = scale( shadowInsets.top, scaleFactor );
+		int bottom = scale( shadowInsets.bottom, scaleFactor );
+
+		// shadow outer coordinates
+		int x1o = x - Math.min( left, 0 );
+		int y1o = y - Math.min( top, 0 );
+		int x2o = x + width + Math.min( right, 0 );
+		int y2o = y + height + Math.min( bottom, 0 );
+
+		// shadow inner coordinates
+		int x1i = x1o + shadowSize;
+		int y1i = y1o + shadowSize;
+		int x2i = x2o - shadowSize;
+		int y2i = y2o - shadowSize;
+
+		int wh = (shadowSize * 2) - 1;
+		int center = shadowSize - 1;
+
+		// left-top edge
+		if( left > 0 || top > 0 ) {
+			g.drawImage( shadowImage, x1o, y1o, x1i, y1i,
+				0, 0, center, center, null );
+		}
+
+		// top shadow
+		if( top > 0 ) {
+			g.drawImage( shadowImage, x1i, y1o, x2i, y1i,
+				center, 0, center + 1, center, null );
+		}
+
+		// right-top edge
+		if( right > 0 || top > 0 ) {
+			g.drawImage( shadowImage, x2i, y1o, x2o, y1i,
+				center, 0, wh, center, null );
+		}
+
+		// left shadow
+		if( left > 0 ) {
+			g.drawImage( shadowImage, x1o, y1i, x1i, y2i,
+				0, center, center, center + 1, null );
+		}
+
+		// right shadow
+		if( right > 0 ) {
+			g.drawImage( shadowImage, x2i, y1i, x2o, y2i,
+				center, center, wh, center + 1, null );
+		}
+
+		// left-bottom edge
+		if( left > 0 || bottom > 0 ) {
+			g.drawImage( shadowImage, x1o, y2i, x1i, y2o,
+				0, center, center, wh, null );
+		}
+
+		// bottom shadow
+		if( bottom > 0 ) {
+			g.drawImage( shadowImage, x1i, y2i, x2i, y2o,
+				center, center, center + 1, wh, null );
+		}
+
+		// right-bottom edge
+		if( right > 0 || bottom > 0 ) {
+			g.drawImage( shadowImage, x2i, y2i, x2o, y2o,
+				center, center, wh, wh, null );
+		}
+	}
+
+	private int scale( int value, double scaleFactor ) {
+		return (int) Math.ceil( UIScale.scale( value ) * scaleFactor );
+	}
+
+	private static BufferedImage createShadowImage( Color shadowColor, int shadowSize,
+		float shadowOpacity, float scaleFactor )
+	{
+		int shadowRGB = shadowColor.getRGB() & 0xffffff;
+		int shadowAlpha = (int) (255 * shadowOpacity);
+		Color startColor = new Color( shadowRGB | ((shadowAlpha & 0xff) << 24), true );
+		Color midColor = new Color( shadowRGB | (((shadowAlpha / 2) & 0xff) << 24), true );
+		Color endColor = new Color( shadowRGB, true );
+
+/*debug
+		startColor = Color.red;
+		midColor = Color.green;
+		endColor = Color.blue;
+debug*/
+
+		int wh = (shadowSize * 2) - 1;
+		int center = shadowSize - 1;
+
+		RadialGradientPaint p = new RadialGradientPaint( center, center,
+			shadowSize - (0.75f * scaleFactor),
+			new float[] { 0, 0.35f, 1 },
+			new Color[] { startColor, midColor, endColor } );
+
+		BufferedImage image = new BufferedImage( wh, wh, BufferedImage.TYPE_INT_ARGB );
+
+		Graphics2D g = image.createGraphics();
+		try {
+			g.setPaint( p );
+			g.fillRect( 0, 0, wh, wh );
+		} finally {
+			g.dispose();
+		}
+
+		return image;
+	}
+}