release 0.34

(see https://github.com/mikaelgrev/miglayout/pull/76)

.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

.travis.yml

@@ -19,11 +19,21 @@ 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
+stages:
+  - name: test
+  - name: snapshot
+    if: branch = master AND type IN (push) AND tag IS blank
+  - name: release
+    if: type IN (push) AND tag IS present
+
+jobs:
+  include:
+    # publish snapshot to oss.jfrog.org
+    - stage: snapshot
+      jdk: openjdk11
+      script: ./gradlew artifactoryPublish
+
+    # release a new stable version to bintray
+    - stage: release
+      jdk: openjdk11
+      script: ./gradlew bintrayUpload -Drelease=true

CHANGELOG.md

@@ -1,6 +1,213 @@
 FlatLaf Change Log
 ==================
 
+## 0.34
+
+- Menus: New menu item renderer brings stable left margins, right aligned
+  accelerators and larger gap between text and accelerator. This makes menus
+  look more modern and more similar to native platform menus.
+- New underline menu selection style that displays selected menu items similar
+  to tabs (to enable use `UIManager.put( "MenuItem.selectionType", "underline"
+  );`).
+- Menus: Fixed text color of selected menu items that use HTML. (issue #87)
+- Menus: On Windows, pressing <kbd>F10</kbd> now activates the menu bar without
+  showing a menu popup (as usual on Windows platform). On other platforms the
+  first menu popup is shown.
+- Menus: On Windows, releasing <kbd>Alt</kbd> key now activates the menu bar (as
+  usual on Windows platform). (issue #43)
+- Menus: Fixed inconsistent left padding in menu items. (issue #3)
+- Menus: Fixed: Setting `iconTextGap` property on a menu item did increase left
+  and right margins. (issue #54)
+- Hide mnemonics if window is deactivated (e.g. <kbd>Alt+Tab</kbd> to another
+  window). (issue #43)
+- macOS: Enabled drop shadows for popup menus and combobox popups. (issue #94)
+- macOS: Fixed NPE if using `JMenuBar` in `JInternalFrame` and macOS screen menu
+  bar is enabled (with `-Dapple.laf.useScreenMenuBar=true`). (issue #90)
+
+
+## 0.33
+
+- Improved creation of disabled grayscale icons used in disabled buttons, labels
+  and tabs. They now have more contrast and are lighter in light themes and
+  darker in dark themes. (issue #70)
+- IntelliJ Themes: Fixed ComboBox size and Spinner border in all Material UI
+  Lite themes and limit tree row height in all Material UI Lite themes and some
+  other themes.
+- IntelliJ Themes: Material UI Lite themes did not work when using
+  [IntelliJ Themes Pack](flatlaf-intellij-themes) addon. (PR #88, issue #89)
+- IntelliJ Themes: Added Java 9 module descriptor to
+  `flatlaf-intellij-themes-<version>.jar`.
+
+
+## 0.32
+
+- New [IntelliJ Themes Pack](flatlaf-intellij-themes) addon bundles many popular
+  open-source 3rd party themes from JetBrains Plugins Repository into a JAR and
+  provides Java classes to use them.
+- IntelliJ Themes: Fixed button and toggle button colors. (issue #86)
+- Updated IntelliJ Themes in demo to the latest versions.
+- ToggleButton: Compute selected background color based on current component
+  background. (issue #32)
+
+
+## 0.31
+
+- Focus indication border (or background) no longer hidden when temporary
+  loosing focus (e.g. showing a popup menu).
+- List, Table and Tree: Item selection color of focused components no longer
+  change from blue to gray when temporary loosing focus (e.g. showing a popup
+  menu).
+
+
+## 0.30
+
+- Windows: Fixed rendering of Unicode characters. Previously not all Unicode
+  characters were rendered on Windows. (issue #81)
+
+
+## 0.29
+
+- Linux: Fixed scaling if `GDK_SCALE` environment variable is set or if running
+  on JetBrains Runtime. (issue #69)
+- Tree: Fixed repainting wide selection on focus gained/lost.
+- ComboBox: No longer ignore `JComboBox.prototypeDisplayValue` when computing
+  popup width. (issue #80)
+- Support changing default font used for all components with automatic scaling
+  UI if using larger font. Use `UIManager.put( "defaultFont", myFont );`
+- No longer use system property `sun.java2d.uiScale`. (Java 8 only)
+- Support specifying custom scale factor in system property `flatlaf.uiScale`
+  also for Java 9 and later.
+- Demo: Support using own FlatLaf themes (`.properties` files) that are located
+  in working directory of Demo application. Shown in the "Themes" list under
+  category "Current Directory".
+
+
+## 0.28
+
+- PasswordField: Warn about enabled Caps Lock.
+- TabbedPane: Support <kbd>Ctrl+TAB</kbd> / <kbd>Ctrl+Shift+TAB</kbd> to switch
+  to next / previous tab.
+- TextField, FormattedTextField and PasswordField: Support round borders (see UI
+  default value `TextComponent.arc`). (issue #65)
+- IntelliJ Themes: Added Gradianto themes to demo.
+- Button, CheckBox and RadioButton: Fixed NPE when button has children. (PR #68)
+- ScrollBar: Improved colors.
+- Reviewed (and tested) all key bindings on Windows and macOS. Linux key
+  bindings are equal to Windows key bindings. macOS key bindings are slightly
+  different for platform specific behavior.
+- UI default values are no longer based on Metal/Aqua UI defaults.
+
+
+## 0.27
+
+- Support `JInternalFrame` and `JDesktopPane`. (issues #39 and #11)
+- Table: Support positioning the column sort arrow in header right, left, top or
+  bottom. (issue #34)
+- ProgressBar: Fixed visual artifacts in indeterminate mode, on HiDPI screens at
+  125%, 150% and 175% scaling, when the progress moves around.
+- TabbedPane: New option to allow tab separators to take full height (to enable
+  use `UIManager.put( "TabbedPane.tabSeparatorsFullHeight", true );`). (issue
+  #59, PR #62)
+- CheckBox and RadioButton: Do not fill background if `contentAreaFilled` is
+  `false`. (issue #58, PR #63)
+- ToggleButton: Make toggle button square if it has an icon but no text or text
+  is "..." or a single character.
+- ToolBar: No longer use special rollover border for buttons in toolbar. (issue
+  #36)
+- ToolBar: Added empty space around buttons in toolbar and toolbar itself (see
+  UI default values `Button.toolbar.spacingInsets` and `ToolBar.borderMargins`).
+  (issue #56)
+- Fixed "illegal reflective access operation" warning on macOS when using Java
+  12 or later. (issue #60, PR #61)
+
+
+## 0.26
+
+- Menus:
+  - Changed menu bar and popup menu background colors (made brighter in light
+    themes and darker in dark themes).
+  - Highlight items in menu bar on mouse hover. (issue #49)
+  - Popup menus now have empty space at the top and bottom.
+  - Menu items now have larger left and right margins.
+  - Made `JMenu`, `JMenuItem`, `JCheckBoxMenuItem` and `JRadioButtonMenuItem`
+    non-opaque.
+- TextField, FormattedTextField and PasswordField: Select all text when a text
+  field gains focus for the first time and selection was not set explicitly.
+  This can be configured to newer or always select all text on focus gain (see
+  UI default value `TextComponent.selectAllOnFocusPolicy`).
+- ProgressBar: Made progress bar paint smooth in indeterminate mode.
+
+
+## 0.25.1
+
+Re-release of 0.25 because of problems with Maven Central.
+
+
+## 0.25
+
+- Hide menu mnemonics by default and show them only when <kbd>Alt</kbd> key is
+  pressed. (issue #43)
+- Menu: Fixed vertical alignment of sub-menus. (issue #42)
+- TabbedPane: In scroll-tab-layout, the cropped line is now hidden. (issue #40)
+- Tree: UI default value `Tree.textBackground` now has a valid color and is no
+  longer `null`.
+- Tree on macOS: Fixed <kbd>Left</kbd> and <kbd>Right</kbd> keys to collapse or
+  expand nodes.
+- ComboBox on macOS: Fixed keyboard navigation and show/hide popup.
+- Button and ToggleButton: Support per component minimum height (set client
+  property `JComponent.minimumHeight` to an integer). (issue #44)
+- Button and ToggleButton: Do not apply minimum width if button border was
+  changed (is no longer an instance of `FlatButtonBorder`).
+- ToggleButton: Renamed toggle button type "underline" to "tab" (value of client
+  property `JButton.buttonType` is now `tab`).
+- ToggleButton: Support per component styling for tab-style toggle buttons with
+  client properties `JToggleButton.tab.underlineHeight` (integer),
+  `JToggleButton.tab.underlineColor` (Color) and
+  `JToggleButton.tab.selectedBackground` (Color). (issue #45)
+- ToggleButton: No longer use focus width for tab-style toggle buttons to
+  compute component size, which reduces/fixes component size in "Flat IntelliJ"
+  and "Flat Darcula" themes.
+- TabbedPane: Support per component tab height (set client property
+  `JTabbedPane.tabHeight` to an integer).
+- ProgressBar: Support square painting (set client property
+  `JProgressBar.square` to `true`) and larger height even if no string is
+  painted (set client property `JProgressBar.largeHeight` to `true`).
+
+
+## 0.24
+
+- Support smooth scrolling with touchpads and high precision mouse wheels.
+  (issue #27)
+- Changed `.properties` file loading order: Now all core `.properties` files are
+  loaded before loading addon `.properties` files. This makes it easier to
+  overwrite core values in addons. Also, addon loading order can be specified.
+- TableHeader: Paint column borders if renderer has changed, but delegates to
+  the system default renderer (e.g. done in NetBeans).
+- Label and ToolTip: Fixed font sizes for HTML headings.
+- Button and ToggleButton: Support square button style (set client property
+  `JButton.buttonType` to `square`).
+- ToggleButton: Support underline toggle button style (set client property
+  `JButton.buttonType` to `underline`).
+- Button and TextComponent: Support per component minimum width (set client
+  property `JComponent.minimumWidth` to an integer).
+- ScrollPane with Table: The border of buttons that are added to one of the four
+  scroll pane corners are now removed if the center component is a table. Also,
+  these corner buttons are made not focusable.
+- Table: Replaced `Table.showGrid` with `Table.showHorizontalLines` and
+  `Table.showVerticalLines`. (issue #38)
+- ProgressBar: Now uses blueish color for the progress part in "Flat Dark"
+  theme. In the "Flat Darcula" theme, it remains light gray.
+- Improved Swing system colors `controlHighlight`, `controlLtHighlight`,
+  `controlShadow` and `controlDkShadow`.
+
+
+## 0.23.1
+
+- Tree: Fixed wide selection if scrolled horizontally.
+- ComboBox: Fixed NPE in Oracle SQL Developer settings.
+- IntelliJ Themes: Fixed checkbox colors in Material UI Lite dark themes.
+
+
 ## 0.23
 
 - Updated colors in "Flat Light" and "Flat IntelliJ" themes with colors from
@@ -8,6 +215,8 @@ FlatLaf Change Log
   platform colors.
 - Tree: Support wide selection (enabled by default).
 - Table: Hide grid and changed intercell spacing to zero.
+- List, Table and Tree: Added colors for drag-and-drop. Added "enable drag and
+  drop" checkbox to Demo on "Data Components" tab.
 - List and Tree: Hide cell focus indicator (black rectangle) by default. Can be
   enabled with `List.showCellFocusIndicator=true` /
   `Tree.showCellFocusIndicator=true`, but then the cell focus indicator is shown
@@ -23,6 +232,8 @@ FlatLaf Change Log
 - Fixed link color (in HTML text) and separator color in IntelliJ platform
   themes.
 - Use logging instead of printing errors to `System.err`.
+- Updated IntelliJ Themes in demo to the latest versions.
+- IntelliJ Themes: Fixed link and separator colors.
 
 
 ## 0.22

README.md

@@ -19,7 +19,8 @@ IntelliJ IDEA 2019.2+ and uses almost the same colors and icons.
 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)
 
@@ -45,18 +46,67 @@ build script:
 
     groupId:     com.formdev
     artifactId:  flatlaf
-    version:     0.23
+    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)
 
 
+### Snapshots
+
+FlatLaf snapshot binaries are available in
+[JFrog Artifactory](https://oss.jfrog.org/artifactory/oss-snapshot-local/com/formdev/).
+To access the latest snapshot, change the FlatLaf version(s) in the dependencies
+to `<version>-SNAPSHOT` (e.g. `0.27-SNAPSHOT`) and add the repository
+`https://oss.jfrog.org/artifactory/oss-snapshot-local` 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)
+
+
+Projects using FlatLaf
+----------------------
+
+- [NetBeans](https://netbeans.apache.org/) 11.3
+- [jclasslib bytecode viewer](https://github.com/ingokegel/jclasslib) 5.5
+- [KeyStore Explorer](https://keystore-explorer.org/) 5.4.3
+- [OWASP Zed Attack Proxy (ZAP)](https://www.zaproxy.org/) (in weekly releases)
+- [XMLmind XML Editor](https://www.xmlmind.com/xmleditor/) 9.3 (commercial)
+- [Total Validator](https://www.totalvalidator.com/) 15 (commercial)
+- [j-lawyer](https://github.com/jlawyerorg/j-lawyer-org)
+- [MegaMek](https://github.com/MegaMek/megamek) v0.47.4 and
+  [MekHQ](https://github.com/MegaMek/mekhq) v0.47.5
+- [GUIslice Builder](https://github.com/ImpulseAdventure/GUIslice-Builder)
+  0.13.b024
+- [Rest Suite](https://github.com/supanadit/restsuite)
+- [ControllerBuddy](https://github.com/bwRavencl/ControllerBuddy)
+- [SpringRemote](https://github.com/HaleyWang/SpringRemote)
+- [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)
+- [MeteoInfo](https://github.com/meteoinfo/MeteoInfo) 2.1.6
+- [lsfusion platform](https://github.com/lsfusion/platform)
+- and more...
+
+
+Buzz
+----
+
+- [What others say about FlatLaf on Twitter](https://twitter.com/search?f=live&q=flatlaf)
+- [FlatLaf announcement on Reddit](https://www.reddit.com/r/java/comments/dl0hu3/flatlaf_flat_look_and_feel/)
 
 
 Documentation

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,9 +14,14 @@
  * limitations under the License.
  */
 
-version = "0.23"
+val releaseVersion = "0.34"
+val developmentVersion = "0.35-SNAPSHOT"
+
+version = if( java.lang.Boolean.getBoolean( "release" ) ) releaseVersion else developmentVersion
 
 allprojects {
+	version = rootProject.version
+
 	repositories {
 		jcenter()
 	}
@@ -33,3 +38,39 @@ println( "FlatLaf Version: ${version}" )
 println( "Gradle ${gradle.gradleVersion} at ${gradle.gradleHomeDir}" )
 println( "Java ${System.getProperty( "java.version" )}" )
 println()
+
+
+extra["bintray.user"] = System.getenv( "BINTRAY_USER" ) ?: System.getProperty( "bintray.user" )
+extra["bintray.key"]  = System.getenv( "BINTRAY_KEY" )  ?: System.getProperty( "bintray.key" )
+
+// if true, do not upload to bintray
+extra["bintray.dryRun"] = false
+
+// if true, uploaded artifacts are visible to all
+// if false, only visible to owner when logged into bintray
+extra["bintray.publish"] = true
+
+
+allprojects {
+	tasks {
+		withType<JavaCompile>().configureEach {
+			sourceCompatibility = "1.8"
+			targetCompatibility = "1.8"
+
+			options.encoding = "ISO-8859-1"
+		}
+
+		withType<Jar>().configureEach {
+			// manifest for all created JARs
+			manifest.attributes(mapOf(
+				"Implementation-Vendor" to "FormDev Software GmbH",
+				"Implementation-Copyright" to "Copyright (C) ${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")
+			}
+		}
+	}
+}

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();
+	}
+}

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,16 +14,20 @@
  * limitations under the License.
  */
 
-version = rootProject.version
-
 plugins {
 	`java-library`
 	`maven-publish`
-	id( "com.jfrog.bintray" ) version "1.8.4"
+	id( "com.jfrog.bintray" )
+	id( "com.jfrog.artifactory" )
 }
 
 if( JavaVersion.current() >= JavaVersion.VERSION_1_9 ) {
 	sourceSets {
+		create( "java9" ) {
+			java {
+				setSrcDirs( listOf( "src/main/java9" ) )
+			}
+		}
 		create( "module-info" ) {
 			java {
 				// include "src/main/java" here to get compile errors if classes are
@@ -34,11 +38,6 @@ if( JavaVersion.current() >= JavaVersion.VERSION_1_9 ) {
 	}
 }
 
-java {
-	sourceCompatibility = JavaVersion.VERSION_1_8
-	targetCompatibility = JavaVersion.VERSION_1_8
-}
-
 tasks {
 	assemble {
 		dependsOn(
@@ -53,21 +52,32 @@ tasks {
 			targetCompatibility = "9"
 		}
 	}
-	
+
 	jar {
 		archiveBaseName.set( "flatlaf" )
 
 		if( JavaVersion.current() >= JavaVersion.VERSION_1_9 ) {
+			manifest.attributes( "Multi-Release" to "true" )
+
+			into( "META-INF/versions/9" ) {
+				from( sourceSets["java9"].output )
+			}
+
 			from( sourceSets["module-info"].output ) {
 				include( "module-info.class" )
 			}
 		}
+
+		doLast {
+			ReorderJarEntries.reorderJarEntries( outputs.files.singleFile );
+		}
 	}
 
 	javadoc {
 		options {
 			this as StandardJavadocDocletOptions
 			tags = listOf( "uiDefault", "clientProperty" )
+			addStringOption( "Xdoclint:all,-missing", "-Xdoclint:all,-missing" )
 		}
 		isFailOnError = false
 	}
@@ -106,7 +116,7 @@ publishing {
 				licenses {
 					license {
 						name.set( "The Apache License, Version 2.0" )
-						url.set( "http://www.apache.org/licenses/LICENSE-2.0.txt" )
+						url.set( "https://www.apache.org/licenses/LICENSE-2.0.txt" )
 					}
 				}
 
@@ -127,8 +137,8 @@ publishing {
 }
 
 bintray {
-	user = System.getenv( "BINTRAY_USER" ) ?: System.getProperty( "bintray.user" )
-	key = System.getenv( "BINTRAY_KEY" ) ?: System.getProperty( "bintray.key" )
+	user = rootProject.extra["bintray.user"] as String?
+	key = rootProject.extra["bintray.key"] as String?
 
 	setPublications( "maven" )
 
@@ -142,6 +152,29 @@ bintray {
 			name = project.version.toString()
 		}
 
-		publish = true
+		publish = rootProject.extra["bintray.publish"] as Boolean
+		dryRun = rootProject.extra["bintray.dryRun"] as Boolean
 	}
 }
+
+artifactory {
+	setContextUrl( "https://oss.jfrog.org" )
+
+	publish( closureOf<org.jfrog.gradle.plugin.artifactory.dsl.PublisherConfig> {
+		repository( delegateClosureOf<groovy.lang.GroovyObject> {
+			setProperty( "repoKey", "oss-snapshot-local" )
+			setProperty( "username", rootProject.extra["bintray.user"] as String? )
+			setProperty( "password", rootProject.extra["bintray.key"] as String? )
+		} )
+
+		defaults( delegateClosureOf<groovy.lang.GroovyObject> {
+			invokeMethod( "publications", "maven" )
+			setProperty( "publishArtifacts", true )
+			setProperty( "publishPom", true )
+		} )
+	} )
+
+	resolve( delegateClosureOf<org.jfrog.gradle.plugin.artifactory.dsl.ResolverConfig> {
+		setProperty( "repoKey", "jcenter" )
+	} )
+}

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

@@ -16,6 +16,7 @@
 
 package com.formdev.flatlaf;
 
+import java.awt.Color;
 import java.util.Objects;
 import javax.swing.JComponent;
 
@@ -27,14 +28,34 @@ public interface FlatClientProperties
 	/**
 	 * Specifies type of a button.
 	 * <p>
-	 * <strong>Component</strong> {@link javax.swing.JButton}<br>
+	 * <strong>Components</strong> {@link javax.swing.JButton} and {@link javax.swing.JToggleButton}<br>
 	 * <strong>Value type</strong> {@link java.lang.String}<br>
-	 * <strong>Allowed Values</strong> {@link BUTTON_TYPE_HELP}
+	 * <strong>Allowed Values</strong> {@link #BUTTON_TYPE_SQUARE} and {@link #BUTTON_TYPE_HELP}
 	 */
 	String BUTTON_TYPE = "JButton.buttonType";
 
+	/**
+	 * Paint the button with square edges.
+	 * <p>
+	 * <strong>Components</strong> {@link javax.swing.JButton} and {@link javax.swing.JToggleButton}
+	 *
+	 * @see #BUTTON_TYPE
+	 */
+	String BUTTON_TYPE_SQUARE = "square";
+
+	/**
+	 * Paint the toggle button in tab style.
+	 * <p>
+	 * <strong>Components</strong> {@link javax.swing.JToggleButton}
+	 *
+	 * @see #BUTTON_TYPE
+	 */
+	String BUTTON_TYPE_TAB = "tab";
+
 	/**
 	 * Paint a help button (circle with question mark).
+	 * <p>
+	 * <strong>Components</strong> {@link javax.swing.JButton}
 	 *
 	 * @see #BUTTON_TYPE
 	 */
@@ -45,7 +66,7 @@ public interface FlatClientProperties
 	 * <p>
 	 * <strong>Component</strong> {@link javax.swing.JCheckBox}<br>
 	 * <strong>Value type</strong> {@link java.lang.String}<br>
-	 * <strong>Allowed Values</strong> {@link SELECTED_STATE_INDETERMINATE}
+	 * <strong>Allowed Values</strong> {@link #SELECTED_STATE_INDETERMINATE}
 	 */
 	String SELECTED_STATE = "JButton.selectedState";
 
@@ -56,6 +77,38 @@ public interface FlatClientProperties
 	 */
 	String SELECTED_STATE_INDETERMINATE = "indeterminate";
 
+	/**
+	 * Specifies minimum width of a component.
+	 * <p>
+	 * <strong>Component</strong> {@link javax.swing.JButton}, {@link javax.swing.JToggleButton} and {@link javax.swing.text.JTextComponent}<br>
+	 * <strong>Value type</strong> {@link java.lang.Integer}<br>
+	 */
+	String MINIMUM_WIDTH = "JComponent.minimumWidth";
+
+	/**
+	 * Specifies minimum height of a component.
+	 * <p>
+	 * <strong>Component</strong> {@link javax.swing.JButton} and {@link javax.swing.JToggleButton}<br>
+	 * <strong>Value type</strong> {@link java.lang.Integer}<br>
+	 */
+	String MINIMUM_HEIGHT = "JComponent.minimumHeight";
+
+	/**
+	 * Specifies whether the progress bar has always the larger height even if no string is painted.
+	 * <p>
+	 * <strong>Component</strong> {@link javax.swing.JProgressBar}<br>
+	 * <strong>Value type</strong> {@link java.lang.Boolean}
+	 */
+	String PROGRESS_BAR_LARGE_HEIGHT = "JProgressBar.largeHeight";
+
+	/**
+	 * Specifies whether the progress bar is paint with square edges.
+	 * <p>
+	 * <strong>Component</strong> {@link javax.swing.JProgressBar}<br>
+	 * <strong>Value type</strong> {@link java.lang.Boolean}
+	 */
+	String PROGRESS_BAR_SQUARE = "JProgressBar.square";
+
 	/**
 	 * Specifies whether the decrease/increase arrow buttons of a scrollbar are shown.
 	 * <p>
@@ -80,14 +133,80 @@ public interface FlatClientProperties
 	 */
 	String TABBED_PANE_HAS_FULL_BORDER = "JTabbedPane.hasFullBorder";
 
+	/**
+	 * Specifies the height of a tab.
+	 * <p>
+	 * <strong>Component</strong> {@link javax.swing.JTabbedPane}<br>
+	 * <strong>Value type</strong> {@link java.lang.Integer}
+	 */
+	String TABBED_PANE_TAB_HEIGHT = "JTabbedPane.tabHeight";
+
+	/**
+	 * Specifies whether all text is selected when the text component gains focus.
+	 * <p>
+	 * <strong>Component</strong> {@link javax.swing.JTextField} (and subclasses)<br>
+	 * <strong>Value type</strong> {@link java.lang.String}<br>
+	 * <strong>Allowed Values</strong> {@link #SELECT_ALL_ON_FOCUS_POLICY_NEVER},
+	 * {@link #SELECT_ALL_ON_FOCUS_POLICY_ONCE} (default) or
+	 * {@link #SELECT_ALL_ON_FOCUS_POLICY_ALWAYS}
+	 */
+	String SELECT_ALL_ON_FOCUS_POLICY = "JTextField.selectAllOnFocusPolicy";
+
+	/**
+	 * Never select all text when the text component gains focus.
+	 *
+	 * @see #SELECT_ALL_ON_FOCUS_POLICY
+	 */
+	String SELECT_ALL_ON_FOCUS_POLICY_NEVER = "never";
+
+	/**
+	 * Select all text when the text component gains focus for the first time
+	 * and selection was not modified (is at end of text).
+	 * This is the default.
+	 *
+	 * @see #SELECT_ALL_ON_FOCUS_POLICY
+	 */
+	String SELECT_ALL_ON_FOCUS_POLICY_ONCE = "once";
+
+	/**
+	 * Always select all text when the text component gains focus.
+	 *
+	 * @see #SELECT_ALL_ON_FOCUS_POLICY
+	 */
+	String SELECT_ALL_ON_FOCUS_POLICY_ALWAYS = "always";
+
 	/**
 	 * Placeholder text that is only painted if the text field is empty.
 	 * <p>
-	 * <strong>Component</strong> {@link javax.swing.JTextField} or {@link javax.swing.JComboBox}<br>
+	 * <strong>Component</strong> {@link javax.swing.JTextField} (and subclasses) or {@link javax.swing.JComboBox}<br>
 	 * <strong>Value type</strong> {@link java.lang.String}
 	 */
 	String PLACEHOLDER_TEXT = "JTextField.placeholderText";
 
+	/**
+	 * Height of underline if toggle button type is {@link #BUTTON_TYPE_TAB}.
+	 * <p>
+	 * <strong>Component</strong> {@link javax.swing.JToggleButton}<br>
+	 * <strong>Value type</strong> {@link java.lang.Integer}
+	 */
+	String TAB_BUTTON_UNDERLINE_HEIGHT = "JToggleButton.tab.underlineHeight";
+
+	/**
+	 * Color of underline if toggle button type is {@link #BUTTON_TYPE_TAB}.
+	 * <p>
+	 * <strong>Component</strong> {@link javax.swing.JToggleButton}<br>
+	 * <strong>Value type</strong> {@link java.awt.Color}
+	 */
+	String TAB_BUTTON_UNDERLINE_COLOR = "JToggleButton.tab.underlineColor";
+
+	/**
+	 * Background color if selected and toggle button type is {@link #BUTTON_TYPE_TAB}.
+	 * <p>
+	 * <strong>Component</strong> {@link javax.swing.JToggleButton}<br>
+	 * <strong>Value type</strong> {@link java.awt.Color}
+	 */
+	String TAB_BUTTON_SELECTED_BACKGROUND = "JToggleButton.tab.selectedBackground";
+
 	/**
 	 * Checks whether a client property of a component has the given value.
 	 */
@@ -103,4 +222,22 @@ public interface FlatClientProperties
 		Object value = c.getClientProperty( key );
 		return (value instanceof Boolean) ? (boolean) value : defaultValue;
 	}
+
+	/**
+	 * Checks whether a client property of a component is an integer and returns its value.
+	 * If the client property is not set, or not an integer, defaultValue is returned.
+	 */
+	static int clientPropertyInt( JComponent c, String key, int defaultValue ) {
+		Object value = c.getClientProperty( key );
+		return (value instanceof Integer) ? (int) value : defaultValue;
+	}
+
+	/**
+	 * Checks whether a client property of a component is a color and returns its value.
+	 * If the client property is not set, or not a color, defaultValue is returned.
+	 */
+	static Color clientPropertyColor( JComponent c, String key, Color defaultValue ) {
+		Object value = c.getClientProperty( key );
+		return (value instanceof Color) ? (Color) value : defaultValue;
+	}
 }

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.
@@ -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 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,644 @@
+/*
+ * 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.plaf.InputMapUIResource;
+import com.formdev.flatlaf.util.SystemInfo;
+import static javax.swing.text.DefaultEditorKit.*;
+
+/**
+ * @author Karl Tauber
+ */
+class FlatInputMaps
+{
+	static void initInputMaps( UIDefaults defaults ) {
+		initBasicInputMaps( defaults );
+		initTextComponentInputMaps( defaults );
+
+		if( SystemInfo.IS_MAC )
+			initMacInputMaps( defaults );
+	}
+
+	private static void initBasicInputMaps( UIDefaults defaults ) {
+		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.IS_MAC ) {
+			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"
+		);
+
+		modifyInputMap( defaults, "Table.ancestorInputMap",
+			// swap to make it consistent with List and Tree
+			"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.IS_MAC ) {
+			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.IS_MAC ? 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.IS_MAC ? 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.IS_MAC ? 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 ) {
+		// Note: not using `defaults.get(key)` here because this would resolve the lazy value
+		defaults.put( key, new LazyModifyInputMap( defaults.remove( key ), bindings ) );
+	}
+
+	private static <T> T mac( T value, T macValue ) {
+		return SystemInfo.IS_MAC ? macValue : value;
+	}
+
+	//---- class LazyInputMapEx -----------------------------------------------
+
+	/**
+	 * Lazily creates a 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 Object baseInputMap;
+		private final Object[] bindings;
+
+		LazyModifyInputMap( Object baseInputMap, Object[] bindings ) {
+			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;
+
+			// 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/FlatLaf.java

@@ -18,34 +18,46 @@ package com.formdev.flatlaf;
 
 import java.awt.Color;
 import java.awt.Component;
-import java.awt.Container;
 import java.awt.EventQueue;
 import java.awt.Font;
-import java.awt.KeyEventPostProcessor;
-import java.awt.KeyboardFocusManager;
+import java.awt.Image;
+import java.awt.RenderingHints;
 import java.awt.Toolkit;
 import java.awt.Window;
-import java.awt.event.KeyEvent;
+import java.awt.image.FilteredImageSource;
+import java.awt.image.ImageFilter;
+import java.awt.image.ImageProducer;
 import java.beans.PropertyChangeEvent;
 import java.beans.PropertyChangeListener;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
 import java.util.List;
+import java.util.Map;
+import java.util.Properties;
+import java.util.ServiceLoader;
 import java.util.function.Consumer;
+import java.util.function.Function;
 import java.util.logging.Level;
 import java.util.logging.Logger;
-import javax.swing.AbstractButton;
-import javax.swing.JLabel;
-import javax.swing.JTabbedPane;
+import javax.swing.BorderFactory;
+import javax.swing.Icon;
+import javax.swing.ImageIcon;
+import javax.swing.JComponent;
 import javax.swing.LookAndFeel;
 import javax.swing.PopupFactory;
 import javax.swing.SwingUtilities;
 import javax.swing.UIDefaults;
 import javax.swing.UIManager;
 import javax.swing.UnsupportedLookAndFeelException;
+import javax.swing.UIDefaults.ActiveValue;
 import javax.swing.plaf.ColorUIResource;
 import javax.swing.plaf.FontUIResource;
+import javax.swing.plaf.UIResource;
 import javax.swing.plaf.basic.BasicLookAndFeel;
-import javax.swing.plaf.metal.MetalLookAndFeel;
+import javax.swing.text.StyleContext;
 import javax.swing.text.html.HTMLEditorKit;
+import com.formdev.flatlaf.util.GrayFilter;
+import com.formdev.flatlaf.util.MultiResolutionImageSupport;
 import com.formdev.flatlaf.util.SystemInfo;
 import com.formdev.flatlaf.util.UIScale;
 
@@ -58,14 +70,15 @@ public abstract class FlatLaf
 	extends BasicLookAndFeel
 {
 	static final Logger LOG = Logger.getLogger( FlatLaf.class.getName() );
-
-	private BasicLookAndFeel base;
+	private static final String DESKTOPFONTHINTS = "awt.font.desktophints";
 
 	private String desktopPropertyName;
 	private PropertyChangeListener desktopPropertyListener;
 
-	private KeyEventPostProcessor mnemonicListener;
-	private static boolean showMnemonics;
+	private static boolean aquaLoaded;
+	private static boolean updateUIPending;
+
+	private MnemonicHandler mnemonicHandler;
 
 	private Consumer<UIDefaults> postInitialization;
 
@@ -104,23 +117,36 @@ public abstract class FlatLaf
 		return true;
 	}
 
+	@Override
+	public Icon getDisabledIcon( JComponent component, Icon icon ) {
+		if( icon instanceof ImageIcon ) {
+			Object grayFilter = UIManager.get( "Component.grayFilter" );
+			ImageFilter filter = (grayFilter instanceof ImageFilter)
+				? (ImageFilter) grayFilter
+				: GrayFilter.createDisabledIconFilter( isDark() ); // fallback
+
+			Function<Image, Image> mapper = img -> {
+				ImageProducer producer = new FilteredImageSource( img.getSource(), filter );
+				return Toolkit.getDefaultToolkit().createImage( producer );
+			};
+
+			Image image = ((ImageIcon)icon).getImage();
+			return new ImageIconUIResource( MultiResolutionImageSupport.map( image, mapper ) );
+		}
+
+		return null;
+	}
+
 	@Override
 	public void initialize() {
-		getBase().initialize();
+		if( SystemInfo.IS_MAC )
+			initializeAqua();
 
 		super.initialize();
 
-		// make sure that a plain popup factory is used (otherwise sub-menu rendering
-		// is "jittery" on Mac, where AquaLookAndFeel installs its own popup factory)
-		if( PopupFactory.getSharedInstance().getClass() != PopupFactory.class )
-			PopupFactory.setSharedInstance( new PopupFactory() );
-
-		// add mnemonic listener
-		mnemonicListener = e -> {
-			checkShowMnemonics( e );
-			return false;
-		};
-		KeyboardFocusManager.getCurrentKeyboardFocusManager().addKeyEventPostProcessor( mnemonicListener );
+		// install mnemonic handler
+		mnemonicHandler = new MnemonicHandler();
+		mnemonicHandler.install();
 
 		// listen to desktop property changes to update UI if system font or scaling changes
 		if( SystemInfo.IS_WINDOWS ) {
@@ -135,9 +161,19 @@ public abstract class FlatLaf
 		}
 		if( desktopPropertyName != null ) {
 			desktopPropertyListener = e -> {
-				reSetLookAndFeel();
+				String propertyName = e.getPropertyName();
+				if( desktopPropertyName.equals( propertyName ) )
+					reSetLookAndFeel();
+				else if( DESKTOPFONTHINTS.equals( propertyName ) ) {
+					if( UIManager.getLookAndFeel() instanceof FlatLaf ) {
+						putAATextInfo( UIManager.getLookAndFeelDefaults() );
+						updateUILater();
+					}
+				}
 			};
-			Toolkit.getDefaultToolkit().addPropertyChangeListener( desktopPropertyName, desktopPropertyListener );
+			Toolkit toolkit = Toolkit.getDefaultToolkit();
+			toolkit.addPropertyChangeListener( desktopPropertyName, desktopPropertyListener );
+			toolkit.addPropertyChangeListener( DESKTOPFONTHINTS, desktopPropertyListener );
 		}
 
 		// Following code should be ideally in initialize(), but needs color from UI defaults.
@@ -157,103 +193,155 @@ public abstract class FlatLaf
 	public void uninitialize() {
 		// remove desktop property listener
 		if( desktopPropertyListener != null ) {
-			Toolkit.getDefaultToolkit().removePropertyChangeListener( desktopPropertyName, desktopPropertyListener );
+			Toolkit toolkit = Toolkit.getDefaultToolkit();
+			toolkit.removePropertyChangeListener( desktopPropertyName, desktopPropertyListener );
+			toolkit.removePropertyChangeListener( DESKTOPFONTHINTS, desktopPropertyListener );
 			desktopPropertyName = null;
 			desktopPropertyListener = null;
 		}
 
-		// remove mnemonic listener
-		if( mnemonicListener != null ) {
-			KeyboardFocusManager.getCurrentKeyboardFocusManager().removeKeyEventPostProcessor( mnemonicListener );
-			mnemonicListener = null;
+		// uninstall mnemonic handler
+		if( mnemonicHandler != null ) {
+			mnemonicHandler.uninstall();
+			mnemonicHandler = null;
 		}
 
 		// restore default link color
 		new HTMLEditorKit().getStyleSheet().addRule( "a { color: blue; }" );
 		postInitialization = null;
 
-		if( base != null )
-			base.uninitialize();
-
 		super.uninitialize();
 	}
 
 	/**
-	 * Get/create base LaF. This is used to grab base UI defaults from different LaFs.
-	 * E.g. on Mac from system dependent LaF, otherwise from Metal LaF.
+	 * Initialize Aqua LaF on macOS, which is required for using Mac screen menubar.
+	 * (at least on Java 8, since 9 it seems to work without it)
+	 * <p>
+	 * This loads the native library "osxui" and initializes JRSUI.
+	 * Because both are not unloaded/uninitialized, Aqua LaF is initialized only once.
 	 */
-	private BasicLookAndFeel getBase() {
-		if( base == null ) {
-			if( SystemInfo.IS_MAC ) {
-				// use Mac Aqua LaF as base
-				String aquaLafClassName = "com.apple.laf.AquaLookAndFeel";
-				try {
-					base = (BasicLookAndFeel) Class.forName( aquaLafClassName ).newInstance();
-				} catch( Exception ex ) {
-					LOG.log( Level.SEVERE, "FlatLaf: Failed to initialize base look and feel '" + aquaLafClassName + "'.", ex );
-					throw new IllegalStateException();
-				}
+	private void initializeAqua() {
+		if( aquaLoaded )
+			return;
+
+		aquaLoaded = true;
+
+		// create macOS Aqua LaF
+		String aquaLafClassName = "com.apple.laf.AquaLookAndFeel";
+		BasicLookAndFeel aquaLaf;
+		try {
+			if( SystemInfo.IS_JAVA_9_OR_LATER ) {
+				Method m = UIManager.class.getMethod( "createLookAndFeel", String.class );
+				aquaLaf = (BasicLookAndFeel) m.invoke( null, "Mac OS X" );
 			} else
-				base = new MetalLookAndFeel();
+				aquaLaf = (BasicLookAndFeel) Class.forName( aquaLafClassName ).newInstance();
+		} catch( Exception ex ) {
+			LOG.log( Level.SEVERE, "FlatLaf: Failed to initialize Aqua look and feel '" + aquaLafClassName + "'.", ex );
+			throw new IllegalStateException();
 		}
-		return base;
+
+		// remember popup factory because aquaLaf.initialize() installs its own
+		// factory, which makes sub-menu rendering "jittery"
+		PopupFactory oldPopupFactory = PopupFactory.getSharedInstance();
+
+		// initialize Aqua LaF
+		aquaLaf.initialize();
+		aquaLaf.uninitialize();
+
+		// restore popup factory
+		PopupFactory.setSharedInstance( oldPopupFactory );
 	}
 
 	@Override
 	public UIDefaults getDefaults() {
-		UIDefaults defaults = getBase().getDefaults();
+		UIDefaults defaults = super.getDefaults();
 
 		// add Metal resource bundle, which is required for FlatFileChooserUI
 		defaults.addResourceBundle( "com.sun.swing.internal.plaf.metal.resources.metal" );
 
-		// initialize some defaults (for overriding) that are used in basic UI delegates,
-		// but are not set in MetalLookAndFeel or BasicLookAndFeel
-		Color control = defaults.getColor( "control" );
-		defaults.put( "EditorPane.disabledBackground", control );
-		defaults.put( "EditorPane.inactiveBackground", control );
-		defaults.put( "FormattedTextField.disabledBackground", control );
-		defaults.put( "PasswordField.disabledBackground", control );
-		defaults.put( "TextArea.disabledBackground", control );
-		defaults.put( "TextArea.inactiveBackground", control );
-		defaults.put( "TextField.disabledBackground", control );
-		defaults.put( "TextPane.disabledBackground", control );
-		defaults.put( "TextPane.inactiveBackground", control );
-
-		// initialize some own defaults (for overriding)
-		defaults.put( "Spinner.disabledBackground", control );
-		defaults.put( "Spinner.disabledForeground", control );
-
-		// remember MenuBarUI from Mac Aqua LaF if Mac screen menubar is enabled
-		boolean useScreenMenuBar = SystemInfo.IS_MAC && "true".equals( System.getProperty( "apple.laf.useScreenMenuBar" ) );
-		Object aquaMenuBarUI = useScreenMenuBar ? defaults.get( "MenuBarUI" ) : null;
+		// initialize some defaults (for overriding) that are used in UI delegates,
+		// but are not set in BasicLookAndFeel
+		putDefaults( defaults, defaults.getColor( "control" ),
+			"EditorPane.disabledBackground",
+			"EditorPane.inactiveBackground",
+			"FormattedTextField.disabledBackground",
+			"PasswordField.disabledBackground",
+			"Spinner.disabledBackground",
+			"TextArea.disabledBackground",
+			"TextArea.inactiveBackground",
+			"TextField.disabledBackground",
+			"TextPane.disabledBackground",
+			"TextPane.inactiveBackground" );
+		putDefaults( defaults, defaults.getColor( "textInactiveText" ),
+			"Button.disabledText",
+			"CheckBox.disabledText",
+			"CheckBoxMenuItem.disabledForeground",
+			"Menu.disabledForeground",
+			"MenuItem.disabledForeground",
+			"RadioButton.disabledText",
+			"RadioButtonMenuItem.disabledForeground",
+			"Spinner.disabledForeground",
+			"ToggleButton.disabledText" );
+		putDefaults( defaults, defaults.getColor( "textText" ),
+			"DesktopIcon.foreground" );
 
 		initFonts( defaults );
 		initIconColors( defaults, isDark() );
+		FlatInputMaps.initInputMaps( defaults );
+
+		// get addons and sort them by priority
+		ServiceLoader<FlatDefaultsAddon> addonLoader = ServiceLoader.load( FlatDefaultsAddon.class );
+		List<FlatDefaultsAddon> addons = new ArrayList<>();
+		for( FlatDefaultsAddon addon : addonLoader )
+			addons.add( addon );
+		addons.sort( (addon1, addon2) -> addon1.getPriority() - addon2.getPriority() );
 
 		// load defaults from properties
 		List<Class<?>> lafClassesForDefaultsLoading = getLafClassesForDefaultsLoading();
 		if( lafClassesForDefaultsLoading != null )
-			UIDefaultsLoader.loadDefaultsFromProperties( lafClassesForDefaultsLoading, defaults );
+			UIDefaultsLoader.loadDefaultsFromProperties( lafClassesForDefaultsLoading, addons, getAdditionalDefaults(), isDark(), defaults );
 		else
-			UIDefaultsLoader.loadDefaultsFromProperties( getClass(), defaults );
+			UIDefaultsLoader.loadDefaultsFromProperties( getClass(), addons, getAdditionalDefaults(), isDark(), defaults );
 
 		// use Aqua MenuBarUI if Mac screen menubar is enabled
-		if( useScreenMenuBar )
-			defaults.put( "MenuBarUI", aquaMenuBarUI );
+		if( SystemInfo.IS_MAC && Boolean.getBoolean( "apple.laf.useScreenMenuBar" ) ) {
+			defaults.put( "MenuBarUI", "com.apple.laf.AquaMenuBarUI" );
 
-		invokePostInitialization( defaults );
+			// add defaults necessary for AquaMenuBarUI
+			defaults.put( "MenuBar.backgroundPainter", BorderFactory.createEmptyBorder() );
+		}
 
-		return defaults;
-	}
+		// initialize text antialiasing
+		putAATextInfo( defaults );
+
+		// apply additional defaults (e.g. from IntelliJ themes)
+		applyAdditionalDefaults( defaults );
+
+		// allow addons modifying UI defaults
+		for( FlatDefaultsAddon addon : addons )
+			addon.afterDefaultsLoading( this, defaults );
+
+		// add user scale factor to allow layout managers (e.g. MigLayout) to use it
+		defaults.put( "laf.scaleFactor", (ActiveValue) t -> {
+			return UIScale.getUserScaleFactor();
+		} );
 
-	void invokePostInitialization( UIDefaults defaults ) {
 		if( postInitialization != null ) {
 			postInitialization.accept( defaults );
 			postInitialization = null;
 		}
+
+		return defaults;
 	}
 
-	List<Class<?>> getLafClassesForDefaultsLoading() {
+	void applyAdditionalDefaults( UIDefaults defaults ) {
+	}
+
+	protected List<Class<?>> getLafClassesForDefaultsLoading() {
+		return null;
+	}
+
+	protected Properties getAdditionalDefaults() {
 		return null;
 	}
 
@@ -263,17 +351,19 @@ public abstract class FlatLaf
 		if( SystemInfo.IS_WINDOWS ) {
 			Font winFont = (Font) Toolkit.getDefaultToolkit().getDesktopProperty( "win.messagebox.font" );
 			if( winFont != null )
-				uiFont = new FontUIResource( winFont );
+				uiFont = createCompositeFont( winFont.getFamily(), winFont.getStyle(), winFont.getSize() );
 
 		} else if( SystemInfo.IS_MAC ) {
-			Font font = defaults.getFont( "Label.font" );
-
+			String fontName;
 			if( SystemInfo.IS_MAC_OS_10_11_EL_CAPITAN_OR_LATER ) {
 				// use San Francisco Text font
-				font = new FontUIResource( ".SF NS Text", font.getStyle(), font.getSize() );
+				fontName = ".SF NS Text";
+			} else {
+				// default font on older systems (see com.apple.laf.AquaFonts)
+				fontName = "Lucida Grande";
 			}
 
-			uiFont = (font instanceof FontUIResource) ? (FontUIResource) font : new FontUIResource( font );
+			uiFont = createCompositeFont( fontName, Font.PLAIN, 13 );
 
 		} else if( SystemInfo.IS_LINUX ) {
 			Font font = LinuxFontPolicy.getFont();
@@ -281,19 +371,34 @@ public abstract class FlatLaf
 		}
 
 		if( uiFont == null )
-			return;
+			uiFont = createCompositeFont( Font.SANS_SERIF, Font.PLAIN, 12 );
 
 		uiFont = UIScale.applyCustomScaleFactor( uiFont );
 
+		// use active value for all fonts to allow changing fonts in all components
+		// (similar as in Nimbus L&F) with:
+		//     UIManager.put( "defaultFont", myFont );
+		Object activeFont =  new ActiveFont( 1 );
+
 		// override fonts
 		for( Object key : defaults.keySet() ) {
-			if( key instanceof String && ((String)key).endsWith( ".font" ) )
-				defaults.put( key, uiFont );
+			if( key instanceof String && (((String)key).endsWith( ".font" ) || ((String)key).endsWith( "Font" )) )
+				defaults.put( key, activeFont );
 		}
-		defaults.put( "MenuItem.acceleratorFont", uiFont );
 
 		// use smaller font for progress bar
-		defaults.put( "ProgressBar.font", UIScale.scaleFont( uiFont, 0.85f ) );
+		defaults.put( "ProgressBar.font", new ActiveFont( 0.85f ) );
+
+		// set default font
+		defaults.put( "defaultFont", uiFont );
+	}
+
+	static FontUIResource createCompositeFont( String family, int style, int size ) {
+		// using StyleContext.getFont() here because it uses
+		// sun.font.FontUtilities.getCompositeFontUIResource()
+		// and creates a composite font that is able to display all Unicode characters
+		Font font = new StyleContext().getFont( family, style, size );
+		return (font instanceof FontUIResource) ? (FontUIResource) font : new FontUIResource( font );
 	}
 
 	/**
@@ -309,30 +414,52 @@ public abstract class FlatLaf
 	 *   <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.
 	 */
 	public static void initIconColors( UIDefaults defaults, boolean dark ) {
-		// colors for action icons
-		// see https://jetbrains.design/intellij/principles/icons/#action-icons
-		defaults.put( "Actions.Red",            new ColorUIResource( !dark ? 0xDB5860 : 0xC75450 ) );
-		defaults.put( "Actions.Yellow",         new ColorUIResource( !dark ? 0xEDA200 : 0xF0A732 ) );
-		defaults.put( "Actions.Green",          new ColorUIResource( !dark ? 0x59A869 : 0x499C54 ) );
-		defaults.put( "Actions.Blue",           new ColorUIResource( !dark ? 0x389FD6 : 0x3592C4 ) );
-		defaults.put( "Actions.Grey",           new ColorUIResource( !dark ? 0x6E6E6E : 0xAFB1B3 ) );
-		defaults.put( "Actions.GreyInline",     new ColorUIResource( !dark ? 0x7F8B91 : 0x7F8B91 ) );
+		for( FlatIconColors c : FlatIconColors.values() ) {
+			if( c.light == !dark || c.dark == dark )
+				defaults.put( c.key, new ColorUIResource( c.rgb ) );
+		}
+	}
 
-		// colors for object icons
-		// see https://jetbrains.design/intellij/principles/icons/#noun-icons
-		defaults.put( "Objects.Grey",           new ColorUIResource( 0x9AA7B0 ) );
-		defaults.put( "Objects.Blue",           new ColorUIResource( 0x40B6E0 ) );
-		defaults.put( "Objects.Green",          new ColorUIResource( 0x62B543 ) );
-		defaults.put( "Objects.Yellow",         new ColorUIResource( 0xF4AF3D ) );
-		defaults.put( "Objects.YellowDark",     new ColorUIResource( 0xD9A343 ) );
-		defaults.put( "Objects.Purple",         new ColorUIResource( 0xB99BF8 ) );
-		defaults.put( "Objects.Pink",           new ColorUIResource( 0xF98B9E ) );
-		defaults.put( "Objects.Red",            new ColorUIResource( 0xF26522 ) );
-		defaults.put( "Objects.RedStatus",      new ColorUIResource( 0xE05555 ) );
-		defaults.put( "Objects.GreenAndroid",   new ColorUIResource( 0xA4C639 ) );
-		defaults.put( "Objects.BlackText",      new ColorUIResource( 0x231F20 ) );
+	private void putAATextInfo( UIDefaults defaults ) {
+		if( SystemInfo.IS_JAVA_9_OR_LATER ) {
+			Object desktopHints = Toolkit.getDefaultToolkit().getDesktopProperty( DESKTOPFONTHINTS );
+			if( desktopHints instanceof Map ) {
+				@SuppressWarnings( "unchecked" )
+				Map<Object, Object> hints = (Map<Object, Object>) desktopHints;
+				Object aaHint = hints.get( RenderingHints.KEY_TEXT_ANTIALIASING );
+				if( aaHint != null &&
+					aaHint != RenderingHints.VALUE_TEXT_ANTIALIAS_OFF &&
+					aaHint != RenderingHints.VALUE_TEXT_ANTIALIAS_DEFAULT )
+				{
+					defaults.put( RenderingHints.KEY_TEXT_ANTIALIASING, aaHint );
+					defaults.put( RenderingHints.KEY_TEXT_LCD_CONTRAST,
+						hints.get( RenderingHints.KEY_TEXT_LCD_CONTRAST ) );
+				}
+			}
+		} else {
+			// Java 8
+			try {
+				Object key = Class.forName( "sun.swing.SwingUtilities2" )
+					.getField( "AA_TEXT_PROPERTY_KEY" )
+					.get( null );
+				Object value = Class.forName( "sun.swing.SwingUtilities2$AATextInfo" )
+					.getMethod( "getAATextInfo", boolean.class )
+					.invoke( null, true );
+				defaults.put( key, value );
+			} catch( Exception ex ) {
+				Logger.getLogger( FlatLaf.class.getName() ).log( Level.SEVERE, null, ex );
+				throw new RuntimeException( ex );
+			}
+		}
+	}
+
+	private void putDefaults( UIDefaults defaults, Object value, String... keys ) {
+		for( String key : keys )
+			defaults.put( key, value );
 	}
 
 	private static void reSetLookAndFeel() {
@@ -356,7 +483,7 @@ public abstract class FlatLaf
 	}
 
 	/**
-	 * Update UI of all application windows.
+	 * Update UI of all application windows immediately.
 	 * Invoke after changing LaF.
 	 */
 	public static void updateUI() {
@@ -364,73 +491,83 @@ public abstract class FlatLaf
 			SwingUtilities.updateComponentTreeUI( w );
 	}
 
-	public static boolean isShowMnemonics() {
-		return showMnemonics || !UIManager.getBoolean( "Component.hideMnemonics" );
-	}
+	/**
+	 * Update UI of all application windows later.
+	 */
+	public static void updateUILater() {
+		synchronized( FlatLaf.class ) {
+			if( updateUIPending )
+				return;
 
-	private static void checkShowMnemonics( KeyEvent e ) {
-		int keyCode = e.getKeyCode();
-		if( SystemInfo.IS_MAC ) {
-			// Ctrl+Alt keys must be pressed on Mac
-			if( keyCode == KeyEvent.VK_CONTROL || keyCode == KeyEvent.VK_ALT )
-				showMnemonics( e.getID() == KeyEvent.KEY_PRESSED && e.isControlDown() && e.isAltDown() );
-		} else {
-			// Alt key must be pressed on Windows and Linux
-			if( keyCode == KeyEvent.VK_ALT )
-				showMnemonics( e.getID() == KeyEvent.KEY_PRESSED );
+			updateUIPending = true;
 		}
-	}
 
-	private static void showMnemonics( boolean show ) {
-		if( show == showMnemonics )
-			return;
-
-		showMnemonics = show;
-
-		// check whether it is necessary to repaint
-		if( !UIManager.getBoolean( "Component.hideMnemonics" ) )
-			return;
-
-		// get focus owner
-		Component focusOwner = KeyboardFocusManager.getCurrentKeyboardFocusManager().getFocusOwner();
-		if( focusOwner == null )
-			return;
-
-		// get focused window
-		Window window = SwingUtilities.windowForComponent( focusOwner );
-		if( window == null )
-			return;
-
-		// repaint components with mnemonics in focused window
-		repaintMnemonics( window );
-	}
-
-	private static void repaintMnemonics( Container container ) {
-		for( Component c : container.getComponents() ) {
-			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;
+		EventQueue.invokeLater( () -> {
+			updateUI();
+			synchronized( FlatLaf.class ) {
+				updateUIPending = false;
 			}
+		} );
+	}
+
+	public static boolean isShowMnemonics() {
+		return MnemonicHandler.isShowMnemonics();
+	}
+
+	public static void showMnemonics( Component c ) {
+		MnemonicHandler.showMnemonics( true, c );
+	}
+
+	public static void hideMnemonics() {
+		MnemonicHandler.showMnemonics( false, null );
+	}
+
+	//---- class ActiveFont ---------------------------------------------------
+
+	private static class ActiveFont
+		implements ActiveValue
+	{
+		private final float scaleFactor;
+
+		// cache (scaled) font
+		private Font font;
+		private Font lastDefaultFont;
+
+		ActiveFont( float scaleFactor ) {
+			this.scaleFactor = scaleFactor;
 		}
 
-		return false;
+		@Override
+		public Object createValue( UIDefaults table ) {
+			Font defaultFont = UIManager.getFont( "defaultFont" );
+
+			if( lastDefaultFont != defaultFont ) {
+				lastDefaultFont = defaultFont;
+
+				if( scaleFactor != 1 ) {
+					// scale font
+					int newFontSize = Math.round( defaultFont.getSize() * scaleFactor );
+					font = new FontUIResource( defaultFont.deriveFont( (float) newFontSize ) );
+				} else {
+					// make sure that font is a UIResource for LaF switching
+					font = (defaultFont instanceof UIResource)
+						? defaultFont
+						: new FontUIResource( defaultFont );
+				}
+			}
+
+			return font;
+		}
+	}
+
+	//---- class ImageIconUIResource ------------------------------------------
+
+	private static class ImageIconUIResource
+		extends ImageIcon
+		implements UIResource
+	{
+		ImageIconUIResource( Image image ) {
+			super( image );
+		}
 	}
 }

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

@@ -0,0 +1,122 @@
+/*
+ * 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;
+	}
+
+	@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/IntelliJTheme.java

@@ -86,7 +86,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,11 +106,13 @@ 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" );
@@ -132,6 +134,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
@@ -183,6 +187,42 @@ 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" ) );
+
+		// 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
+		defaults.putAll( themeSpecificDefaults );
+	}
+
+	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( "[" ) )
+				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( ' ', '_' ) + ']';
+		for( String key : themeSpecificKeys ) {
+			Object value = defaults.remove( key );
+			if( key.startsWith( currentThemePrefix ) )
+				themeSpecificDefaults.put( key.substring( currentThemePrefix.length() ), value );
+		}
+
+		return themeSpecificDefaults;
 	}
 
 	/**
@@ -200,7 +240,7 @@ public class IntelliJTheme
 			if( color != null ) {
 				String key = e.getKey();
 				namedColors.put( key, color );
-				defaults.put( "ColorPalette." + e.getKey(), color );
+				defaults.put( "ColorPalette." + key, color );
 			}
 		}
 	}
@@ -216,6 +256,11 @@ public class IntelliJTheme
 		} else {
 			uiKeys.add( key );
 
+			// fix ComboBox size and Spinner border in all Material UI Lite themes
+			boolean isMaterialUILite = author.equals( "Mallowigi" );
+			if( isMaterialUILite && (key.equals( "ComboBox.padding" ) || key.equals( "Spinner.border" )) )
+				return; // ignore
+
 			// map keys
 			key = uiKeyMapping.getOrDefault( key, key );
 			if( key.isEmpty() )
@@ -270,7 +315,7 @@ public class IntelliJTheme
 						// (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 );
 					}
 				}
@@ -355,33 +400,43 @@ public class IntelliJTheme
 				value = "#ffffff";
 			}
 
+			String key2 = checkboxDuplicateColors.get( key );
+
 			if( dark )
 				key = StringUtils.removeTrailing( key, ".Dark" );
 
 			String newKey = checkboxKeyMapping.get( key );
 			if( newKey != null ) {
 				ColorUIResource color = toColor( (String) value );
-				if( color != null )
+				if( color != null ) {
 					defaults.put( newKey, color );
 
+					if( key2 != null ) {
+						// When IDEA replaces colors in SVGs it uses color values and not the keys
+						// from com.intellij.ide.ui.UITheme.colorPalette, but there are some keys that
+						// have same color value:
+						//   - Checkbox.Background.Default.Dark  has same color as  Checkbox.Background.Selected.Dark
+						//   - Checkbox.Border.Default.Dark      has same color as  Checkbox.Border.Selected.Dark
+						//   - Checkbox.Focus.Thin.Default.Dark  has same color as  Checkbox.Focus.Thin.Selected.Dark
+						//
+						// So if only e.g. Checkbox.Background.Default.Dark is specified in .theme.json,
+						// then this color is also used for Checkbox.Background.Selected.Dark.
+						//
+						// If Checkbox.Background.Default.Dark and Checkbox.Background.Selected.Dark
+						// are specified in .theme.json, then the later specified is used for both.
+						if( dark )
+							key2 = StringUtils.removeTrailing( key2, ".Dark" );
+
+						String newKey2 = checkboxKeyMapping.get( key2 );
+						if( newKey2 != null )
+							defaults.put( newKey2, color );
+					}
+				}
+
 				checkboxModified = true;
 			}
 		}
 
-		// When IDEA replaces colors in SVGs it uses color values and not the keys
-		// from com.intellij.ide.ui.UITheme.colorPalette, but there are some keys that
-		// have same color value:
-		//   - Checkbox.Background.Default.Dark  has same color as  Checkbox.Background.Selected.Dark
-		//   - Checkbox.Border.Default.Dark      has same color as  Checkbox.Border.Selected.Dark
-		//   - Checkbox.Focus.Thin.Default.Dark  has same color as  Checkbox.Focus.Thin.Selected.Dark
-		//
-		// So if only e.g. Checkbox.Background.Default.Dark is specified in .theme.json,
-		// then this color is also used for Checkbox.Background.Selected.Dark.
-		// Occurs e.g. in "Dark purple" theme.
-		fixCheckBoxColor( defaults, colorPalette, "Checkbox.Background.Default.Dark", "Checkbox.Background.Selected.Dark" );
-		fixCheckBoxColor( defaults, colorPalette, "Checkbox.Border.Default.Dark",     "Checkbox.Border.Selected.Dark" );
-		fixCheckBoxColor( defaults, colorPalette, "Checkbox.Focus.Thin.Default.Dark", "Checkbox.Focus.Thin.Selected.Dark" );
-
 		// remove hover and pressed colors
 		if( checkboxModified ) {
 			defaults.remove( "CheckBox.icon.hoverBorderColor" );
@@ -391,24 +446,17 @@ public class IntelliJTheme
 			defaults.remove( "CheckBox.icon.selectedHoverBackground" );
 			defaults.remove( "CheckBox.icon.selectedPressedBackground" );
 		}
-	}
 
-	private void fixCheckBoxColor( UIDefaults defaults, Map<String, Object> colorPalette, String key1, String key2 ) {
-		if( colorPalette.containsKey( key1 ) == colorPalette.containsKey( key2 ) )
-			return;
-
-		String newKey1 = checkboxKeyMapping.get( StringUtils.removeTrailing( key1, ".Dark" ) );
-		String newKey2 = checkboxKeyMapping.get( StringUtils.removeTrailing( key2, ".Dark" ) );
-		if( colorPalette.containsKey( key1 ) )
-			defaults.put( newKey2, defaults.get( newKey1 ) );
-		else
-			defaults.put( newKey1, defaults.get( newKey2 ) );
+		// copy values
+		for( Map.Entry<String, String> e : uiKeyCopying.entrySet() )
+			defaults.put( e.getKey(), defaults.get( e.getValue() ) );
 	}
 
 	private static Map<String, String> uiKeyMapping = new HashMap<>();
+	private static Map<String, String> uiKeyCopying = new HashMap<>();
 	private static Map<String, String> uiKeyInverseMapping = new HashMap<>();
 	private static Map<String, String> checkboxKeyMapping = new HashMap<>();
-	private static Set<String> noWildcardReplace = new HashSet<>();
+	private static Map<String, String> checkboxDuplicateColors = new HashMap<>();
 
 	static {
 		// ComboBox
@@ -441,6 +489,12 @@ public class IntelliJTheme
 		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" );
@@ -453,15 +507,13 @@ public class IntelliJTheme
 		checkboxKeyMapping.put( "Checkbox.Foreground.Selected", "CheckBox.icon.checkmarkColor" );
 		checkboxKeyMapping.put( "Checkbox.Focus.Thin.Selected", "CheckBox.icon.selectedFocusedBorderColor" );
 
-		// 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" );
+		checkboxDuplicateColors.put( "Checkbox.Background.Default.Dark", "Checkbox.Background.Selected.Dark" );
+		checkboxDuplicateColors.put( "Checkbox.Border.Default.Dark",     "Checkbox.Border.Selected.Dark" );
+		checkboxDuplicateColors.put( "Checkbox.Focus.Thin.Default.Dark", "Checkbox.Focus.Thin.Selected.Dark" );
+		@SuppressWarnings( "unchecked" )
+		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() );
 	}
 
 	//---- class ThemeLaf -----------------------------------------------------
@@ -495,19 +547,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,7 @@
 package com.formdev.flatlaf;
 
 import java.awt.Font;
+import java.awt.GraphicsConfiguration;
 import java.awt.GraphicsEnvironment;
 import java.awt.Toolkit;
 import java.io.BufferedReader;
@@ -28,9 +29,9 @@ 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.StringUtils;
 import com.formdev.flatlaf.util.SystemInfo;
+import com.formdev.flatlaf.util.UIScale;
 
 /**
  * @author Karl Tauber
@@ -88,9 +89,7 @@ class LinuxFontPolicy
 	}
 
 	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,6 +98,10 @@ 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" );
@@ -168,7 +171,7 @@ class LinuxFontPolicy
 
 		// font dpi
 		int dpi = 96;
-		if( forceFontDPI != null ) {
+		if( forceFontDPI != null && !isSystemScaling() ) {
 			try {
 				dpi = Integer.parseInt( forceFontDPI );
 				if( dpi <= 0 )
@@ -247,4 +250,15 @@ 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() {
+		GraphicsConfiguration gc = GraphicsEnvironment.getLocalGraphicsEnvironment()
+			.getDefaultScreenDevice().getDefaultConfiguration();
+		return UIScale.getSystemScaleFactor( gc ) > 1;
+	}
 }

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

@@ -0,0 +1,259 @@
+/*
+ * 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.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.IS_MAC ) {
+			// 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.IS_WINDOWS )
+				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 );
+					Window window = (rootPane != null) ? SwingUtilities.getWindowAncestor( rootPane ) : null;
+					JMenuBar menuBar = (rootPane != null) ? rootPane.getJMenuBar() : null;
+					if( menuBar == null && window instanceof JFrame )
+						menuBar = ((JFrame)window).getJMenuBar();
+					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/UIDefaultsLoader.java

@@ -28,7 +28,6 @@ import java.util.List;
 import java.util.Locale;
 import java.util.Map;
 import java.util.Properties;
-import java.util.ServiceLoader;
 import java.util.function.Function;
 import java.util.logging.Level;
 import javax.swing.UIDefaults;
@@ -42,6 +41,7 @@ import com.formdev.flatlaf.ui.FlatEmptyBorder;
 import com.formdev.flatlaf.ui.FlatLineBorder;
 import com.formdev.flatlaf.util.ColorFunctions;
 import com.formdev.flatlaf.util.DerivedColor;
+import com.formdev.flatlaf.util.GrayFilter;
 import com.formdev.flatlaf.util.HSLColor;
 import com.formdev.flatlaf.util.StringUtils;
 import com.formdev.flatlaf.util.SystemInfo;
@@ -63,13 +63,13 @@ class UIDefaultsLoader
 	private static final String TYPE_PREFIX = "{";
 	private static final String TYPE_PREFIX_END = "}";
 	private static final String VARIABLE_PREFIX = "@";
-	@Deprecated
-	private static final String REF_PREFIX = VARIABLE_PREFIX + "@";
 	private static final String PROPERTY_PREFIX = "$";
 	private static final String OPTIONAL_PREFIX = "?";
 	private static final String GLOBAL_PREFIX = "*.";
 
-	static void loadDefaultsFromProperties( Class<?> lookAndFeelClass, UIDefaults defaults ) {
+	static void loadDefaultsFromProperties( Class<?> lookAndFeelClass, List<FlatDefaultsAddon> addons,
+		Properties additionalDefaults, boolean dark, UIDefaults defaults )
+	{
 		// determine classes in class hierarchy in reverse order
 		ArrayList<Class<?>> lafClasses = new ArrayList<>();
 		for( Class<?> lafClass = lookAndFeelClass;
@@ -79,47 +79,69 @@ class UIDefaultsLoader
 			lafClasses.add( 0, lafClass );
 		}
 
-		loadDefaultsFromProperties( lafClasses, defaults );
+		loadDefaultsFromProperties( lafClasses, addons, additionalDefaults, dark, defaults );
 	}
 
-	static void loadDefaultsFromProperties( List<Class<?>> lafClasses, UIDefaults defaults ) {
+	static void loadDefaultsFromProperties( List<Class<?>> lafClasses, List<FlatDefaultsAddon> addons,
+		Properties additionalDefaults, boolean dark, UIDefaults defaults )
+	{
 		try {
-			List<ClassLoader> addonClassLoaders = new ArrayList<>();
-
-			// load properties files
+			// load core properties files
 			Properties properties = new Properties();
-			ServiceLoader<FlatDefaultsAddon> addonLoader = ServiceLoader.load( FlatDefaultsAddon.class );
 			for( Class<?> lafClass : lafClasses ) {
-				// load core properties
-				String propertiesName = "/" + lafClass.getName().replace( '.', '/' ) + ".properties";
+				String propertiesName = '/' + lafClass.getName().replace( '.', '/' ) + ".properties";
 				try( InputStream in = lafClass.getResourceAsStream( propertiesName ) ) {
 					if( in != null )
 						properties.load( in );
 				}
+			}
 
-				// load properties from addons
-				for( FlatDefaultsAddon addon : addonLoader ) {
+			// load properties from addons
+			for( FlatDefaultsAddon addon : addons ) {
+				for( Class<?> lafClass : lafClasses ) {
 					try( InputStream in = addon.getDefaults( lafClass ) ) {
 						if( in != null )
 							properties.load( in );
 					}
-
-					ClassLoader addonClassLoader = addon.getClass().getClassLoader();
-					if( !addonClassLoaders.contains( addonClassLoader ) )
-						addonClassLoaders.add( addonClassLoader );
 				}
 			}
 
+			// collect addon class loaders
+			List<ClassLoader> addonClassLoaders = new ArrayList<>();
+			for( FlatDefaultsAddon addon : addons ) {
+				ClassLoader addonClassLoader = addon.getClass().getClassLoader();
+				if( !addonClassLoaders.contains( addonClassLoader ) )
+					addonClassLoaders.add( addonClassLoader );
+			}
+
+			// add additional defaults
+			if( additionalDefaults != null )
+				properties.putAll( additionalDefaults );
+
 			// collect all platform specific keys (but do not modify properties)
 			ArrayList<String> platformSpecificKeys = new ArrayList<>();
-			for( Object key : properties.keySet() ) {
-				if( ((String)key).startsWith( "[" ) )
-					platformSpecificKeys.add( (String) key );
+			for( Object okey : properties.keySet() ) {
+				String key = (String) okey;
+				if( key.startsWith( "[" ) &&
+					(key.startsWith( "[win]" ) ||
+					 key.startsWith( "[mac]" ) ||
+					 key.startsWith( "[linux]" ) ||
+					 key.startsWith( "[light]" ) ||
+					 key.startsWith( "[dark]" )) )
+				  platformSpecificKeys.add( key );
 			}
 
 			// remove platform specific properties and re-add only properties
 			// for current platform, but with platform prefix removed
 			if( !platformSpecificKeys.isEmpty() ) {
+				// handle light/dark specific properties
+				String lightOrDarkPrefix = dark ? "[dark]" : "[light]";
+				for( String key : platformSpecificKeys ) {
+					if( key.startsWith( lightOrDarkPrefix ) )
+						properties.put( key.substring( lightOrDarkPrefix.length() ), properties.remove( key ) );
+				}
+
+				// handle platform specific properties
 				String platformPrefix =
 					SystemInfo.IS_WINDOWS ? "[win]" :
 					SystemInfo.IS_MAC ? "[mac]" :
@@ -189,12 +211,6 @@ class UIDefaultsLoader
 		else if( !value.startsWith( VARIABLE_PREFIX ) )
 			return value;
 
-		// for compatibility
-		if( value.startsWith( REF_PREFIX ) ) {
-			FlatLaf.LOG.log( Level.WARNING, "FlatLaf: Usage of '@@' in .properties files is deprecated. Use '$' instead." );
-			value = value.substring( REF_PREFIX.length() );
-		}
-
 		boolean optional = false;
 		if( value.startsWith( OPTIONAL_PREFIX ) ) {
 			value = value.substring( OPTIONAL_PREFIX.length() );
@@ -212,7 +228,8 @@ class UIDefaultsLoader
 		return resolveValue( properties, newValue );
 	}
 
-	private enum ValueType { UNKNOWN, STRING, INTEGER, FLOAT, BORDER, ICON, INSETS, DIMENSION, COLOR, SCALEDINTEGER, INSTANCE, CLASS }
+	private enum ValueType { UNKNOWN, STRING, CHARACTER, INTEGER, FLOAT, BORDER, ICON, INSETS, DIMENSION, COLOR,
+		SCALEDINTEGER, SCALEDFLOAT, SCALEDINSETS, SCALEDDIMENSION, INSTANCE, CLASS, GRAYFILTER }
 
 	static Object parseValue( String key, String value ) {
 		return parseValue( key, value, v -> v, Collections.emptyList() );
@@ -275,13 +292,18 @@ class UIDefaultsLoader
 				valueType = ValueType.DIMENSION;
 			else if( key.endsWith( "Width" ) || key.endsWith( "Height" ) )
 				valueType = ValueType.INTEGER;
+			else if( key.endsWith( "Char" ) )
+				valueType = ValueType.CHARACTER;
 			else if( key.endsWith( "UI" ) )
 				valueType = ValueType.STRING;
+			else if( key.endsWith( "grayFilter" ) )
+				valueType = ValueType.GRAYFILTER;
 		}
 
 		// parse value
 		switch( valueType ) {
 			case STRING:		return value;
+			case CHARACTER:		return parseCharacter( value );
 			case INTEGER:		return parseInteger( value, true );
 			case FLOAT:			return parseFloat( value, true );
 			case BORDER:		return parseBorder( value, resolver, addonClassLoaders );
@@ -290,8 +312,12 @@ class UIDefaultsLoader
 			case DIMENSION:		return parseDimension( value );
 			case COLOR:			return parseColorOrFunction( value, resolver, true );
 			case SCALEDINTEGER:	return parseScaledInteger( value );
+			case SCALEDFLOAT:	return parseScaledFloat( value );
+			case SCALEDINSETS:	return parseScaledInsets( value );
+			case SCALEDDIMENSION:return parseScaledDimension( value );
 			case INSTANCE:		return parseInstance( value, addonClassLoaders );
 			case CLASS:			return parseClass( value, addonClassLoaders );
+			case GRAYFILTER:	return parseGrayFilter( value );
 			case UNKNOWN:
 			default:
 				// colors
@@ -316,16 +342,17 @@ class UIDefaultsLoader
 
 	private static Object parseBorder( String value, Function<String, String> resolver, List<ClassLoader> addonClassLoaders ) {
 		if( value.indexOf( ',' ) >= 0 ) {
-			// top,left,bottom,right[,lineColor]
+			// top,left,bottom,right[,lineColor[,lineThickness]]
 			List<String> parts = split( value, ',' );
 			Insets insets = parseInsets( value );
-			ColorUIResource lineColor = (parts.size() == 5)
+			ColorUIResource lineColor = (parts.size() >= 5)
 				? (ColorUIResource) parseColorOrFunction( resolver.apply( parts.get( 4 ) ), resolver, true )
 				: null;
+			float lineThickness = (parts.size() >= 6) ? parseFloat( parts.get( 5 ), true ) : 1f;
 
 			return (LazyValue) t -> {
 				return (lineColor != null)
-					? new FlatLineBorder( insets, lineColor )
+					? new FlatLineBorder( insets, lineColor, lineThickness )
 					: new FlatEmptyBorder( insets );
 			};
 		} else
@@ -480,8 +507,8 @@ class UIDefaultsLoader
 			throw new IllegalArgumentException( "missing parameters in function '" + value + "'" );
 
 		switch( function ) {
-			case "rgb":			return parseColorRgbOrRgba( false, params );
-			case "rgba":		return parseColorRgbOrRgba( true, params );
+			case "rgb":			return parseColorRgbOrRgba( false, params, resolver, reportError );
+			case "rgba":		return parseColorRgbOrRgba( true, params, resolver, reportError );
 			case "hsl":			return parseColorHslOrHsla( false, params );
 			case "hsla":		return parseColorHslOrHsla( true, params );
 			case "lighten":		return parseColorLightenOrDarken( true, params, resolver, reportError );
@@ -492,17 +519,28 @@ class UIDefaultsLoader
 	}
 
 	/**
-	 * Syntax: rgb(red,green,blue) or rgba(red,green,blue,alpha)
-	 *   - red: an integer 0-255
-	 *   - green: an integer 0-255
-	 *   - blue: an integer 0-255
-	 *   - alpha: an integer 0-255
+	 * Syntax: rgb(red,green,blue) or rgba(red,green,blue,alpha) or rgba(color,alpha)
+	 *   - red:   an integer 0-255 or a percentage 0-100%
+	 *   - green: an integer 0-255 or a percentage 0-100%
+	 *   - blue:  an integer 0-255 or a percentage 0-100%
+	 *   - alpha: an integer 0-255 or a percentage 0-100%
 	 */
-	private static ColorUIResource parseColorRgbOrRgba( boolean hasAlpha, List<String> params ) {
-		int red = parseInteger( params.get( 0 ), 0, 255 );
-		int green = parseInteger( params.get( 1 ), 0, 255 );
-		int blue = parseInteger( params.get( 2 ), 0, 255 );
-		int alpha = hasAlpha ? parseInteger( params.get( 3 ), 0, 255 ) : 255;
+	private static ColorUIResource parseColorRgbOrRgba( boolean hasAlpha, List<String> params,
+		Function<String, String> resolver, boolean reportError )
+	{
+		if( hasAlpha && params.size() == 2 ) {
+			// syntax rgba(color,alpha), which allows adding alpha to any color
+			String colorStr = params.get( 0 );
+			int alpha = parseInteger( params.get( 1 ), 0, 255, true );
+
+			ColorUIResource color = (ColorUIResource) parseColorOrFunction( resolver.apply( colorStr ), resolver, reportError );
+			return new ColorUIResource( new Color( ((alpha & 0xff) << 24) | (color.getRGB() & 0xffffff), true ) );
+		}
+
+		int red = parseInteger( params.get( 0 ), 0, 255, true );
+		int green = parseInteger( params.get( 1 ), 0, 255, true );
+		int blue = parseInteger( params.get( 2 ), 0, 255, true );
+		int alpha = hasAlpha ? parseInteger( params.get( 3 ), 0, 255, true ) : 255;
 
 		return hasAlpha
 			? new ColorUIResource( new Color( red, green, blue, alpha ) )
@@ -517,7 +555,7 @@ class UIDefaultsLoader
 	 *   - alpha: a percentage 0-100%
 	 */
 	private static ColorUIResource parseColorHslOrHsla( boolean hasAlpha, List<String> params ) {
-		int hue = parseInteger( params.get( 0 ), 0, 360 );
+		int hue = parseInteger( params.get( 0 ), 0, 360, false );
 		int saturation = parsePercentage( params.get( 1 ) );
 		int lightness = parsePercentage( params.get( 2 ) );
 		int alpha = hasAlpha ? parsePercentage( params.get( 3 ) ) : 100;
@@ -527,35 +565,37 @@ class UIDefaultsLoader
 	}
 
 	/**
-	 * Syntax: lighten([color,]amount[,options]) or darken([color,]amount[,options])
+	 * Syntax: lighten(color,amount[,options]) or darken(color,amount[,options])
 	 *   - color: a color (e.g. #f00) or a color function
 	 *   - amount: percentage 0-100%
-	 *   - options: [relative] [autoInverse] [lazy]
+	 *   - options: [relative] [autoInverse] [lazy] [derived]
 	 */
 	private static Object parseColorLightenOrDarken( boolean lighten, List<String> params,
 		Function<String, String> resolver, boolean reportError )
 	{
-		boolean isDerived = params.get( 0 ).endsWith( "%" );
-		String colorStr = isDerived ? null : params.get( 0 );
-		int nextParam = isDerived ? 0 : 1;
-		int amount = parsePercentage( params.get( nextParam++ ) );
+		String colorStr = params.get( 0 );
+		int amount = parsePercentage( params.get( 1 ) );
 		boolean relative = false;
 		boolean autoInverse = false;
 		boolean lazy = false;
+		boolean derived = false;
 
-		if( params.size() > nextParam ) {
-			String options = params.get( nextParam++ );
+		if( params.size() > 2 ) {
+			String options = params.get( 2 );
 			relative = options.contains( "relative" );
 			autoInverse = options.contains( "autoInverse" );
 			lazy = options.contains( "lazy" );
+			derived = options.contains( "derived" );
 		}
 
 		ColorFunctions.ColorFunction function = lighten
 			? new ColorFunctions.Lighten( amount, relative, autoInverse )
 			: new ColorFunctions.Darken( amount, relative, autoInverse );
 
-		if( isDerived )
-			return new DerivedColor( function );
+		if( derived ) {
+			ColorUIResource color = (ColorUIResource) parseColorOrFunction( resolver.apply( colorStr ), resolver, reportError );
+			return new DerivedColor( ColorFunctions.applyFunctions( color, function ), function );
+		}
 
 		if( lazy ) {
 			return (LazyValue) t -> {
@@ -586,7 +626,18 @@ class UIDefaultsLoader
 		return val;
 	}
 
-	private static Integer parseInteger( String value, int min, int max ) {
+	private static Character parseCharacter( String value ) {
+		if( value.length() != 1 )
+			throw new IllegalArgumentException( "invalid character '" + value + "'" );
+		return value.charAt( 0 );
+	}
+
+	private static Integer parseInteger( String value, int min, int max, boolean allowPercentage ) {
+		if( allowPercentage && value.endsWith( "%" ) ) {
+			int percent = parsePercentage( value );
+			return (max * percent) / 100;
+		}
+
 		Integer integer = parseInteger( value, true );
 		if( integer.intValue() < min || integer.intValue() > max )
 			throw new NumberFormatException( "integer '" + value + "' out of range (" + min + '-' + max + ')' );
@@ -620,6 +671,42 @@ class UIDefaultsLoader
 		};
 	}
 
+	private static ActiveValue parseScaledFloat( String value ) {
+		float val = parseFloat( value, true );
+		return (ActiveValue) t -> {
+			return UIScale.scale( val );
+		};
+	}
+
+	private static ActiveValue parseScaledInsets( String value ) {
+		Insets insets = parseInsets( value );
+		return (ActiveValue) t -> {
+			return UIScale.scale( insets );
+		};
+	}
+
+	private static ActiveValue parseScaledDimension( String value ) {
+		Dimension dimension = parseDimension( value );
+		return (ActiveValue) t -> {
+			return UIScale.scale( dimension );
+		};
+	}
+
+	private static Object parseGrayFilter( String value ) {
+		List<String> numbers = split( value, ',' );
+		try {
+			int brightness = Integer.parseInt( numbers.get( 0 ) );
+			int contrast = Integer.parseInt( numbers.get( 1 ) );
+			int alpha = Integer.parseInt( numbers.get( 2 ) );
+
+			return (LazyValue) t -> {
+				return new GrayFilter( brightness, contrast, alpha );
+			};
+		} catch( NumberFormatException ex ) {
+			throw new IllegalArgumentException( "invalid gray filter '" + value + "'" );
+		}
+	}
+
 	/**
 	 * Split string and trim parts.
 	 */

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

@@ -47,7 +47,7 @@ public class FlatAscendingSortIcon
 		g.setColor( sortIconColor );
 		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,59 @@
+/*
+ * 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.Component;
+import java.awt.Graphics2D;
+import java.awt.geom.Path2D;
+import java.awt.geom.Rectangle2D;
+import java.awt.geom.RoundRectangle2D;
+import javax.swing.UIManager;
+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
+{
+	public FlatCapsLockIcon() {
+		super( 16, 16, UIManager.getColor( "PasswordField.capsLockIconColor" ) );
+	}
+
+	@Override
+	protected void paintIcon( Component c, Graphics2D g ) {
+		/*
+			<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 16 16">
+			  <g fill="none" fill-rule="evenodd">
+			    <rect width="16" height="16" fill="#6E6E6E" rx="3"/>
+			    <rect width="6" height="2" x="5" y="12" fill="#FFF"/>
+    			<path fill="#FFF" d="M2,8 L8,2 L14,8 L11,8 L11,10 L5,10 L5,8 L2,8 Z"/>
+			  </g>
+			</svg>
+		*/
+
+		Path2D path = new Path2D.Float( Path2D.WIND_EVEN_ODD );
+		path.append( new RoundRectangle2D.Float( 0, 0, 16, 16, 6, 6 ), false );
+		path.append( new Rectangle2D.Float( 5, 12, 6, 2 ), false );
+		path.append( FlatUIUtils.createPath( 2,8, 8,2, 14,8, 11,8, 11,10, 5,10, 5,8 ), false );
+		g.fill( path );
+	}
+}

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

@@ -96,7 +96,7 @@ public class FlatCheckBoxIcon
 		boolean selected = indeterminate || (c instanceof AbstractButton && ((AbstractButton)c).isSelected());
 
 		// paint focused border
-		if( c.hasFocus() && focusWidth > 0 ) {
+		if( FlatUIUtils.isPermanentFocusOwner( c ) && focusWidth > 0 ) {
 			g2.setColor( focusColor );
 			paintFocusBorder( g2 );
 		}

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

@@ -30,7 +30,8 @@ import javax.swing.UIManager;
  *
  * @uiDefault MenuItemCheckBox.icon.checkmarkColor				Color
  * @uiDefault MenuItemCheckBox.icon.disabledCheckmarkColor		Color
- * @uiDefault Menu.selectionForeground							Color
+ * @uiDefault MenuItem.selectionForeground						Color
+ * @uiDefault MenuItem.selectionType							String
  *
  * @author Karl Tauber
  */
@@ -39,7 +40,7 @@ public class FlatCheckBoxMenuItemIcon
 {
 	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" );
+	protected final Color selectionForeground = UIManager.getColor( "MenuItem.selectionForeground" );
 
 	public FlatCheckBoxMenuItemIcon() {
 		super( 15, 15, null );
@@ -67,9 +68,14 @@ public class FlatCheckBoxMenuItemIcon
 	}
 
 	private Color getCheckmarkColor( Component c ) {
-		if( c instanceof JMenuItem && ((JMenuItem)c).isArmed() )
+		if( c instanceof JMenuItem && ((JMenuItem)c).isArmed() && !isUnderlineSelection() )
 			return selectionForeground;
 
 		return c.isEnabled() ? checkmarkColor : disabledCheckmarkColor;
 	}
+
+	private 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/FlatDescendingSortIcon.java

@@ -47,7 +47,7 @@ public class FlatDescendingSortIcon
 		g.setColor( sortIconColor );
 		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/FlatHelpButtonIcon.java

@@ -82,7 +82,7 @@ public class FlatHelpButtonIcon
 		*/
 
 		boolean enabled = c.isEnabled();
-		boolean focused = c.hasFocus();
+		boolean focused = FlatUIUtils.isPermanentFocusOwner( c );
 
 		// paint focused border
 		if( focused ) {

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

@@ -0,0 +1,60 @@
+/*
+ * 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.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 ) {
+			FlatUIUtils.setColor( g, background, c.getBackground() );
+			g.fillRect( 0, 0, width, height );
+		}
+	}
+}

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

@@ -17,30 +17,42 @@
 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.buttonHoverBackground		Color
+ * @uiDefault InternalFrame.buttonPressedBackground		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 );

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/FlatInternalFrameMinimizeIcon.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
- *
  * @author Karl Tauber
  */
 public class FlatInternalFrameMinimizeIcon
-	extends FlatAbstractIcon
+	extends FlatInternalFrameAbstractIcon
 {
 	public FlatInternalFrameMinimizeIcon() {
-		super( 16, 16, UIManager.getColor( "InternalFrame.iconColor" ) );
 	}
 
 	@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

@@ -32,6 +32,7 @@ import com.formdev.flatlaf.ui.FlatUIUtils;
  * @uiDefault Menu.icon.arrowColor				Color
  * @uiDefault Menu.icon.disabledArrowColor		Color
  * @uiDefault Menu.selectionForeground			Color
+ * @uiDefault MenuItem.selectionType			String
  *
  * @author Karl Tauber
  */
@@ -65,9 +66,14 @@ public class FlatMenuArrowIcon
 	}
 
 	private Color getArrowColor( Component c ) {
-		if( c instanceof JMenu && ((JMenu)c).isSelected() )
+		if( c instanceof JMenu && ((JMenu)c).isSelected() && !isUnderlineSelection() )
 			return selectionForeground;
 
 		return c.isEnabled() ? arrowColor : disabledArrowColor;
 	}
+
+	private 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/ui/FlatBorder.java

@@ -73,14 +73,16 @@ public class FlatBorder
 			FlatUIUtils.setRenderingHints( g2 );
 
 			boolean isCellEditor = isTableCellEditor( c );
-			float focusWidth = isCellEditor ? 0 : getFocusWidth();
+			float focusWidth = isCellEditor ? 0 : getFocusWidth( c );
 			float borderWidth = getBorderWidth( c );
-			float arc = isCellEditor ? 0 : getArc();
+			float arc = isCellEditor ? 0 : getArc( c );
 
 			if( isFocused( c ) ) {
+				float innerFocusWidth = !(c instanceof JScrollPane) ? this.innerFocusWidth : 0;
+
 				g2.setColor( getFocusColor( c ) );
 				FlatUIUtils.paintComponentOuterBorder( g2, x, y, width, height, focusWidth,
-					getLineWidth() + scale( innerFocusWidth ), arc );
+					getLineWidth( c ) + scale( innerFocusWidth ), arc );
 			}
 
 			g2.setPaint( getBorderColor( c ) );
@@ -117,7 +119,7 @@ public class FlatBorder
 			JViewport viewport = ((JScrollPane)c).getViewport();
 			Component view = (viewport != null) ? viewport.getView() : null;
 			if( view != null ) {
-				if( view.hasFocus() )
+				if( FlatUIUtils.isPermanentFocusOwner( view ) )
 					return true;
 
 				if( (view instanceof JTable && ((JTable)view).isEditing()) ||
@@ -131,17 +133,17 @@ public class FlatBorder
 			return false;
 		} else if( c instanceof JComboBox && ((JComboBox<?>)c).isEditable() ) {
 			Component editorComponent = ((JComboBox<?>)c).getEditor().getEditorComponent();
-			return (editorComponent != null) ? editorComponent.hasFocus() : false;
+			return (editorComponent != null) ? FlatUIUtils.isPermanentFocusOwner( editorComponent ) : 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 FlatUIUtils.isPermanentFocusOwner( textField );
 			}
 			return false;
 		} else
-			return c.hasFocus();
+			return FlatUIUtils.isPermanentFocusOwner( c );
 	}
 
 	protected boolean isTableCellEditor( Component c ) {
@@ -151,7 +153,7 @@ public class FlatBorder
 	@Override
 	public Insets getBorderInsets( Component c, Insets insets ) {
 		boolean isCellEditor = isTableCellEditor( c );
-		float ow = (isCellEditor ? 0 : getFocusWidth()) + getLineWidth();
+		float ow = (isCellEditor ? 0 : getFocusWidth( c )) + getLineWidth( c );
 
 		insets = super.getBorderInsets( c, insets );
 		insets.top = Math.round( scale( (float) insets.top ) + ow );
@@ -161,19 +163,19 @@ public class FlatBorder
 		return insets;
 	}
 
-	protected float getFocusWidth() {
+	protected float getFocusWidth( Component c ) {
 		return scale( (float) focusWidth );
 	}
 
-	protected float getLineWidth() {
+	protected float getLineWidth( Component c ) {
 		return scale( 1f );
 	}
 
 	protected float getBorderWidth( Component c ) {
-		return getLineWidth();
+		return getLineWidth( c );
 	}
 
-	protected float getArc() {
+	protected float getArc( Component c ) {
 		return 0;
 	}
 }

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

@@ -23,9 +23,10 @@ import java.awt.GradientPaint;
 import java.awt.Graphics;
 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.util.UIScale;
 
 /**
  * Border for {@link javax.swing.JButton}.
@@ -43,6 +44,8 @@ import javax.swing.plaf.UIResource;
  * @uiDefault Button.default.focusedBorderColor	Color
  * @uiDefault Button.default.focusColor			Color
  * @uiDefault Button.default.borderWidth		int
+ * @uiDefault Button.toolbar.margin				Insets
+ * @uiDefault Button.toolbar.spacingInsets		Insets
  * @uiDefault Button.arc						int
  *
  * @author Karl Tauber
@@ -61,12 +64,17 @@ public class FlatButtonBorder
 	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 Insets toolbarMargin = UIManager.getInsets( "Button.toolbar.margin" );
+	protected final Insets toolbarSpacingInsets = UIManager.getInsets( "Button.toolbar.spacingInsets" );
 	protected final int arc = UIManager.getInt( "Button.arc" );
 
 	@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.isHelpButton( c ) &&
+			!FlatToggleButtonUI.isTabButton( c ) )
+		  super.paintBorder( c, g, x, y, width, height );
 	}
 
 	@Override
@@ -95,22 +103,38 @@ 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 buttons (so that they are square)
+			if( FlatButtonUI.isIconOnlyButton( c ) && ((AbstractButton)c).getMargin() instanceof UIResource )
+				insets.left = insets.right = Math.min( insets.top, insets.bottom );
+		}
 
 		return insets;
 	}
 
+	@Override
+	protected float getFocusWidth( Component c ) {
+		return FlatToggleButtonUI.isTabButton( c ) ? 0 : super.getFocusWidth(c );
+	}
+
 	@Override
 	protected float getBorderWidth( Component c ) {
 		return FlatButtonUI.isDefaultButton( c ) ? scale( (float) defaultBorderWidth ) : super.getBorderWidth( c );
 	}
 
 	@Override
-	protected float getArc() {
-		return scale( (float) arc );
+	protected float getArc( Component c ) {
+		return FlatButtonUI.isSquareButton( c ) ? 0 : scale( (float) arc );
 	}
 }

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

@@ -26,19 +26,23 @@ 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 javax.swing.AbstractButton;
 import javax.swing.ButtonModel;
 import javax.swing.Icon;
 import javax.swing.JButton;
 import javax.swing.JComponent;
+import javax.swing.JToggleButton;
 import javax.swing.JToolBar;
 import javax.swing.LookAndFeel;
 import javax.swing.UIManager;
 import javax.swing.border.Border;
 import javax.swing.plaf.ComponentUI;
 import javax.swing.plaf.UIResource;
+import javax.swing.plaf.basic.BasicButtonListener;
 import javax.swing.plaf.basic.BasicButtonUI;
 import com.formdev.flatlaf.FlatLaf;
 import com.formdev.flatlaf.util.UIScale;
@@ -79,6 +83,7 @@ import com.formdev.flatlaf.util.UIScale;
  * @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.pressedBackground	Color
  *
@@ -111,6 +116,7 @@ public class FlatButtonUI
 	protected Color shadowColor;
 	protected Color defaultShadowColor;
 
+	protected Insets toolbarSpacingInsets;
 	protected Color toolbarHoverBackground;
 	protected Color toolbarPressedBackground;
 
@@ -163,6 +169,7 @@ public class FlatButtonUI
 			defaultPressedBackground = UIManager.getColor( "Button.default.pressedBackground" );
 			defaultBoldText = UIManager.getBoolean( "Button.default.boldText" );
 
+			toolbarSpacingInsets = UIManager.getInsets( "Button.toolbar.spacingInsets" );
 			toolbarHoverBackground = UIManager.getColor( prefix + "toolbar.hoverBackground" );
 			toolbarPressedBackground = UIManager.getColor( prefix + "toolbar.pressedBackground" );
 
@@ -180,7 +187,7 @@ public class FlatButtonUI
 		LookAndFeel.installProperty( b, "opaque", false );
 		LookAndFeel.installProperty( b, "iconTextGap", scale( iconTextGap ) );
 
-		MigLayoutVisualPadding.install( b, focusWidth );
+		MigLayoutVisualPadding.install( b, getFocusWidth( b ) );
 	}
 
 	@Override
@@ -191,6 +198,26 @@ public class FlatButtonUI
 		defaults_initialized = false;
 	}
 
+	@Override
+	protected BasicButtonListener createButtonListener( AbstractButton b ) {
+		return new BasicButtonListener( b ) {
+			@Override
+			public void propertyChange( PropertyChangeEvent e ) {
+				super.propertyChange( e );
+				FlatButtonUI.this.propertyChange( b, e );
+			}
+		};
+	}
+
+	protected void propertyChange( AbstractButton b, PropertyChangeEvent e ) {
+		switch( e.getPropertyName() ) {
+			case MINIMUM_WIDTH:
+			case MINIMUM_HEIGHT:
+				b.revalidate();
+				break;
+		}
+	}
+
 	static boolean isContentAreaFilled( Component c ) {
 		return !(c instanceof AbstractButton) || ((AbstractButton)c).isContentAreaFilled();
 	}
@@ -200,20 +227,24 @@ public class FlatButtonUI
 	}
 
 	static boolean isIconOnlyButton( Component c ) {
-		if( !(c instanceof JButton) )
+		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));
 	}
 
+	static boolean isSquareButton( Component c ) {
+		return c instanceof AbstractButton && clientPropertyEquals( (AbstractButton) c, BUTTON_TYPE, BUTTON_TYPE_SQUARE );
+	}
+
 	static boolean isHelpButton( Component c ) {
 		return c instanceof JButton && clientPropertyEquals( (JButton) c, BUTTON_TYPE, BUTTON_TYPE_HELP );
 	}
 
-	static boolean isToolBarButton( JComponent c ) {
+	static boolean isToolBarButton( Component c ) {
 		return c.getParent() instanceof JToolBar;
 	}
 
@@ -228,43 +259,64 @@ public class FlatButtonUI
 			return;
 		}
 
-		if( isContentAreaFilled( c ) ) {
-			Color background = getBackground( c );
-			if( background != null ) {
-				Graphics2D g2 = (Graphics2D) g.create();
-				try {
-					FlatUIUtils.setRenderingHints( g2 );
-
-					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 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 ) );
-					}
-
-					// 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();
-				}
-			}
-		}
+		if( isContentAreaFilled( c ) )
+			paintBackground( g, c );
 
 		paint( g, c );
 	}
 
+	protected void paintBackground( Graphics g, JComponent c ) {
+		Color background = getBackground( c );
+		if( background != null ) {
+			Graphics2D g2 = (Graphics2D) g.create();
+			try {
+				FlatUIUtils.setRenderingHints( g2 );
+
+				Border border = c.getBorder();
+				boolean isToolBarButton = isToolBarButton( c );
+				float focusWidth = (border instanceof FlatBorder && !isToolBarButton) ? scale( (float) getFocusWidth( c ) ) : 0;
+				float arc = ((border instanceof FlatButtonBorder && !isSquareButton( c )) || isToolBarButton)
+					? scale( (float) this.arc ) : 0;
+				boolean def = isDefaultButton( c );
+
+				int x = 0;
+				int y = 0;
+				int width = c.getWidth();
+				int height = c.getHeight();
+
+				if( isToolBarButton ) {
+					Insets spacing = UIScale.scale( toolbarSpacingInsets );
+					x += spacing.left;
+					y += spacing.top;
+					width -= spacing.left + spacing.right;
+					height -= spacing.top + spacing.bottom;
+				}
+
+				// paint shadow
+				Color shadowColor = def ? defaultShadowColor : this.shadowColor;
+				if( !isToolBarButton && shadowColor != null && shadowWidth > 0 && focusWidth > 0 &&
+					!FlatUIUtils.isPermanentFocusOwner( c ) && c.isEnabled() )
+				{
+					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
+					FlatUIUtils.setColor( g2, background, def ? defaultBackground : c.getBackground() );
+
+				FlatUIUtils.paintComponentBackground( g2, x, y, width, height, focusWidth, arc );
+			} finally {
+				g2.dispose();
+			}
+		}
+	}
+
 	@Override
 	protected void paintText( Graphics g, AbstractButton b, Rectangle textRect, String text ) {
 		if( isHelpButton( b ) )
@@ -332,7 +384,7 @@ public class FlatButtonUI
 		if( hoverColor != null && b != null && b.getModel().isRollover() )
 			return hoverColor;
 
-		if( focusedColor != null && c.hasFocus() )
+		if( focusedColor != null && FlatUIUtils.isPermanentFocusOwner( c ) )
 			return focusedColor;
 
 		return enabledColor;
@@ -349,14 +401,23 @@ 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 ) )
 			prefSize.width = Math.max( prefSize.width, prefSize.height );
-		else if( !isToolBarButton( c ) )
-			prefSize.width = Math.max( prefSize.width, scale( minimumWidth + (focusWidth * 2) ) );
+		else if( !isToolBarButton( c ) && c.getBorder() instanceof FlatButtonBorder ) {
+			int focusWidth = getFocusWidth( c );
+			prefSize.width = Math.max( prefSize.width, scale( FlatUIUtils.minimumWidth( c, minimumWidth ) + (focusWidth * 2) ) );
+			prefSize.height = Math.max( prefSize.height, scale( FlatUIUtils.minimumHeight( c, 0 ) + (focusWidth * 2) ) );
+		}
 
 		return prefSize;
 	}
+
+	protected int getFocusWidth( JComponent c ) {
+		return focusWidth;
+	}
 }

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

@@ -0,0 +1,128 @@
+/*
+ * 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.event.FocusEvent;
+import java.awt.event.MouseEvent;
+import javax.swing.JFormattedTextField;
+import javax.swing.plaf.UIResource;
+import javax.swing.text.DefaultCaret;
+import javax.swing.text.Document;
+import javax.swing.text.JTextComponent;
+
+/**
+ * Caret that can select all text on focus gained.
+ *
+ * @author Karl Tauber
+ */
+class FlatCaret
+	extends DefaultCaret
+	implements UIResource
+{
+	private final String selectAllOnFocusPolicy;
+
+	private boolean wasFocused;
+	private boolean wasTemporaryLost;
+	private boolean isMousePressed;
+
+	FlatCaret( String selectAllOnFocusPolicy ) {
+		this.selectAllOnFocusPolicy = selectAllOnFocusPolicy;
+	}
+
+	@Override
+	public void install( JTextComponent c ) {
+		super.install( c );
+
+		// the dot and mark are lost when switching LaF
+		// --> move dot to end of text so that all text may be selected when it gains focus
+		Document doc = c.getDocument();
+		if( doc != null && getDot() == 0 && getMark() == 0 ) {
+			int length = doc.getLength();
+			if( length > 0 )
+				setDot( length );
+		}
+	}
+
+	@Override
+	public void focusGained( FocusEvent e ) {
+		if( !wasTemporaryLost && !isMousePressed )
+			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 );
+	}
+
+	@Override
+	public void mouseReleased( MouseEvent e ) {
+		isMousePressed = false;
+		super.mouseReleased( e );
+	}
+
+	private void selectAllOnFocusGained() {
+		JTextComponent c = getComponent();
+		Document doc = c.getDocument();
+		if( doc == null || !c.isEnabled() || !c.isEditable() )
+			return;
+
+		Object selectAllOnFocusPolicy = c.getClientProperty( SELECT_ALL_ON_FOCUS_POLICY );
+		if( selectAllOnFocusPolicy == null )
+			selectAllOnFocusPolicy = this.selectAllOnFocusPolicy;
+
+		if( SELECT_ALL_ON_FOCUS_POLICY_NEVER.equals( selectAllOnFocusPolicy ) )
+			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( () -> {
+				setDot( 0 );
+				moveDot( doc.getLength() );
+			} );
+		} else {
+			setDot( 0 );
+			moveDot( doc.getLength() );
+		}
+	}
+}

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

@@ -16,9 +16,11 @@
 
 package com.formdev.flatlaf.ui;
 
-import static com.formdev.flatlaf.util.UIScale.scale;
-import java.beans.PropertyChangeListener;
+import java.awt.Dimension;
+import java.awt.Graphics;
+import javax.swing.Icon;
 import javax.swing.JComponent;
+import javax.swing.LookAndFeel;
 import javax.swing.plaf.ComponentUI;
 import javax.swing.plaf.basic.BasicCheckBoxMenuItemUI;
 
@@ -27,29 +29,34 @@ import javax.swing.plaf.basic.BasicCheckBoxMenuItemUI;
  *
  * <!-- 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
  */
 public class FlatCheckBoxMenuItemUI
 	extends BasicCheckBoxMenuItemUI
 {
+	private FlatMenuItemRenderer renderer;
+
 	public static ComponentUI createUI( JComponent c ) {
 		return new FlatCheckBoxMenuItemUI();
 	}
@@ -58,20 +65,30 @@ public class FlatCheckBoxMenuItemUI
 	protected void installDefaults() {
 		super.installDefaults();
 
-		// scale
-		defaultTextIconGap = scale( defaultTextIconGap );
+		LookAndFeel.installProperty( menuItem, "iconTextGap", FlatUIUtils.getUIInt( "MenuItem.iconTextGap", 4 ) );
+
+		renderer = createRenderer();
 	}
 
-	/**
-	 * 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 );
-		};
+	protected void uninstallDefaults() {
+		super.uninstallDefaults();
+
+		renderer = null;
+	}
+
+	protected FlatMenuItemRenderer createRenderer() {
+		return new FlatMenuItemRenderer( menuItem, checkIcon, arrowIcon, acceleratorFont, acceleratorDelimiter );
+	}
+
+	@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/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/FlatComboBoxUI.java

@@ -28,6 +28,8 @@ import java.awt.Insets;
 import java.awt.LayoutManager;
 import java.awt.Rectangle;
 import java.awt.Shape;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
 import java.awt.event.FocusEvent;
 import java.awt.event.FocusListener;
 import java.awt.event.MouseListener;
@@ -35,12 +37,16 @@ import java.awt.geom.Rectangle2D;
 import java.beans.PropertyChangeEvent;
 import java.beans.PropertyChangeListener;
 import java.lang.ref.WeakReference;
+import javax.swing.AbstractAction;
 import javax.swing.BorderFactory;
+import javax.swing.DefaultListCellRenderer;
+import javax.swing.InputMap;
 import javax.swing.JButton;
 import javax.swing.JComboBox;
 import javax.swing.JComponent;
 import javax.swing.JList;
 import javax.swing.JPanel;
+import javax.swing.KeyStroke;
 import javax.swing.ListCellRenderer;
 import javax.swing.LookAndFeel;
 import javax.swing.SwingConstants;
@@ -53,6 +59,7 @@ import javax.swing.plaf.basic.BasicComboPopup;
 import javax.swing.plaf.basic.ComboPopup;
 import javax.swing.text.JTextComponent;
 import com.formdev.flatlaf.FlatClientProperties;
+import com.formdev.flatlaf.util.SystemInfo;
 import com.formdev.flatlaf.util.UIScale;
 
 /**
@@ -270,6 +277,19 @@ public class FlatComboBoxUI
 		editor.applyComponentOrientation( comboBox.getComponentOrientation() );
 
 		updateEditorColors();
+
+		// macOS
+		if( SystemInfo.IS_MAC && editor instanceof JTextComponent ) {
+			// delegate actions from editor text field to combobox, which is necessary
+			// because text field on macOS already handle those keys
+			InputMap inputMap = ((JTextComponent)editor).getInputMap();
+			new EditorDelegateAction( inputMap, KeyStroke.getKeyStroke( "UP" ) );
+			new EditorDelegateAction( inputMap, KeyStroke.getKeyStroke( "KP_UP" ) );
+			new EditorDelegateAction( inputMap, KeyStroke.getKeyStroke( "DOWN" ) );
+			new EditorDelegateAction( inputMap, KeyStroke.getKeyStroke( "KP_DOWN" ) );
+			new EditorDelegateAction( inputMap, KeyStroke.getKeyStroke( "HOME" ) );
+			new EditorDelegateAction( inputMap, KeyStroke.getKeyStroke( "END" ) );
+		}
 	}
 
 	private void updateEditorColors() {
@@ -348,6 +368,8 @@ public class FlatComboBoxUI
 	public void paintCurrentValue( Graphics g, Rectangle bounds, boolean hasFocus ) {
 		ListCellRenderer<Object> renderer = comboBox.getRenderer();
 		uninstallCellPaddingBorder( renderer );
+		if( renderer == null )
+			renderer = new DefaultListCellRenderer();
 		Component c = renderer.getListCellRendererComponent( listBox, comboBox.getSelectedItem(), -1, false, false );
 		c.setFont( comboBox.getFont() );
 		c.applyComponentOrientation( comboBox.getComponentOrientation() );
@@ -438,12 +460,12 @@ public class FlatComboBoxUI
 	//---- class FlatComboPopup -----------------------------------------------
 
 	@SuppressWarnings( { "rawtypes", "unchecked" } )
-	private class FlatComboPopup
+	protected class FlatComboPopup
 		extends BasicComboPopup
 	{
 		private CellPaddingBorder paddingBorder;
 
-		FlatComboPopup( JComboBox combo ) {
+		protected FlatComboPopup( JComboBox combo ) {
 			super( combo );
 
 			// BasicComboPopup listens to JComboBox.componentOrientation and updates
@@ -458,13 +480,8 @@ public class FlatComboBoxUI
 
 		@Override
 		protected Rectangle computePopupBounds( int px, int py, int pw, int ph ) {
-			// get maximum display size of all items, ignoring prototype value
-			Object prototype = comboBox.getPrototypeDisplayValue();
-			if( prototype != null )
-				comboBox.setPrototypeDisplayValue( null );
+			// get maximum display size of all items
 			Dimension displaySize = getDisplaySize();
-			if( prototype != null )
-				comboBox.setPrototypeDisplayValue( prototype );
 
 			// make popup wider if necessary
 			if( displaySize.width > pw ) {
@@ -520,6 +537,8 @@ public class FlatComboBoxUI
 				CellPaddingBorder.uninstall( renderer );
 				CellPaddingBorder.uninstall( lastRendererComponent );
 
+				if( renderer == null )
+					renderer = new DefaultListCellRenderer();
 				Component c = renderer.getListCellRendererComponent( list, value, index, isSelected, cellHasFocus );
 				c.applyComponentOrientation( comboBox.getComponentOrientation() );
 
@@ -603,4 +622,31 @@ public class FlatComboBoxUI
 				rendererBorder.paintBorder( c, g, x, y, width, height );
 		}
 	}
+
+	//---- class EditorDelegateAction -----------------------------------------
+
+	/**
+	 * Delegates actions from editor text field to combobox.
+	 */
+	private class EditorDelegateAction
+		extends AbstractAction
+	{
+		private final KeyStroke keyStroke;
+
+		EditorDelegateAction( InputMap inputMap, KeyStroke keyStroke ) {
+			this.keyStroke = keyStroke;
+
+			// add to input map
+			inputMap.put( keyStroke, this );
+		}
+
+		@Override
+		public void actionPerformed( ActionEvent e ) {
+			ActionListener action = comboBox.getActionForKeyStroke( keyStroke );
+			if( action != null ) {
+				action.actionPerformed( new ActionEvent( comboBox, e.getID(),
+					e.getActionCommand(), e.getWhen(), e.getModifiers() ) );
+			}
+		}
+	}
 }

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

@@ -0,0 +1,308 @@
+/*
+ * 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.Container;
+import java.awt.Dimension;
+import java.awt.EventQueue;
+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.PropertyVetoException;
+import javax.swing.BorderFactory;
+import javax.swing.ImageIcon;
+import javax.swing.JButton;
+import javax.swing.JComponent;
+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.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;
+
+	public static ComponentUI createUI( JComponent c ) {
+		return new FlatDesktopIconUI();
+	}
+
+	@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 );
+	}
+
+	@Override
+	protected void uninstallListeners() {
+		super.uninstallListeners();
+
+		closeButton.removeActionListener( closeListener );
+		closeButton.removeMouseListener( mouseInputListener );
+		closeListener = null;
+		mouseInputListener = 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 );
+	}
+
+	void updateDockIcon() {
+		// use invoke later to make sure that components are updated when switching LaF
+		EventQueue.invokeLater( () -> {
+			if( dockIcon != null )
+				updateDockIconLater();
+		} );
+	}
+
+	private void updateDockIconLater() {
+		// make sure that frame is not selected
+		if( frame.isSelected() ) {
+			try {
+				frame.setSelected( false );
+			} catch( PropertyVetoException ex ) {
+				// ignore
+			}
+		}
+
+		// paint internal frame to buffered image
+		int frameWidth = Math.max( frame.getWidth(), 1 );
+		int frameHeight = Math.max( frame.getHeight(), 1 );
+		BufferedImage frameImage = new BufferedImage( frameWidth, frameHeight, BufferedImage.TYPE_INT_ARGB );
+		Graphics2D g = frameImage.createGraphics();
+		try {
+			//TODO fix missing internal frame header when switching LaF
+			frame.paint( g );
+		} finally {
+			g.dispose();
+		}
+
+		// 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 );
+		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,65 @@
+/*
+ * 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 javax.swing.DefaultDesktopManager;
+import javax.swing.JComponent;
+import javax.swing.JInternalFrame;
+import javax.swing.plaf.ComponentUI;
+import javax.swing.plaf.UIResource;
+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
+{
+	public static ComponentUI createUI( JComponent c ) {
+		return new FlatDesktopPaneUI();
+	}
+
+	@Override
+	protected void installDesktopManager() {
+		desktopManager = desktop.getDesktopManager();
+		if( desktopManager == null ) {
+			desktopManager = new FlatDesktopManager();
+			desktop.setDesktopManager( desktopManager );
+		}
+	}
+
+	//---- class FlatDesktopManager -------------------------------------------
+
+	private class FlatDesktopManager
+		extends DefaultDesktopManager
+		implements UIResource
+	{
+		@Override
+		public void iconifyFrame( JInternalFrame f ) {
+			super.iconifyFrame( f );
+
+			((FlatDesktopIconUI)f.getDesktopIcon().getUI()).updateDockIcon();
+		}
+	}
+}

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

@@ -98,6 +98,7 @@ public class FlatEditorPaneUI
 		// and subtract 1px border line width.
 		// Using "(scale( 1 ) * 2)" instead of "scale( 2 )" to deal with rounding
 		// issues. E.g. at scale factor 1.5 the first returns 4, but the second 3.
+		int minimumWidth = FlatUIUtils.minimumWidth( getComponent(), this.minimumWidth );
 		size.width = Math.max( size.width, scale( minimumWidth ) - (scale( 1 ) * 2) );
 		return size;
 	}

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

@@ -50,9 +50,10 @@ public class FlatEmptyBorder
 
 	@Override
 	public Insets getBorderInsets( Component c, Insets insets ) {
-		insets.left = scale( left );
+		boolean leftToRight = left == right || c.getComponentOrientation().isLeftToRight();
+		insets.left = scale( leftToRight ? left : right );
 		insets.top = scale( top );
-		insets.right = scale( right );
+		insets.right = scale( leftToRight ? right : left );
 		insets.bottom = scale( bottom );
 		return insets;
 	}

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

@@ -39,10 +39,12 @@ import javax.swing.plaf.ComponentUI;
  *
  * <!-- FlatTextFieldUI -->
  *
+ * @uiDefault TextComponent.arc							int
  * @uiDefault Component.focusWidth						int
  * @uiDefault Component.minimumWidth					int
  * @uiDefault Component.isIntelliJTheme					boolean
  * @uiDefault FormattedTextField.placeholderForeground	Color
+ * @uiDefault TextComponent.selectAllOnFocusPolicy		String	never, once (default) or always
  *
  * @author Karl Tauber
  */

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

@@ -0,0 +1,190 @@
+/*
+ * 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.BorderLayout;
+import java.awt.Color;
+import java.awt.Dimension;
+import java.awt.Graphics;
+import java.awt.LayoutManager;
+import java.beans.PropertyChangeEvent;
+import java.beans.PropertyChangeListener;
+import javax.swing.BorderFactory;
+import javax.swing.BoxLayout;
+import javax.swing.Icon;
+import javax.swing.JInternalFrame;
+import javax.swing.JLabel;
+import javax.swing.JPanel;
+import javax.swing.LookAndFeel;
+import javax.swing.UIManager;
+import javax.swing.border.Border;
+import javax.swing.plaf.basic.BasicInternalFrameTitlePane;
+import com.formdev.flatlaf.util.UIScale;
+
+/**
+ * Provides the Flat LaF internal frame title bar.
+ *
+ * @author Karl Tauber
+ */
+public class FlatInternalFrameTitlePane
+	extends BasicInternalFrameTitlePane
+{
+	private JLabel titleLabel;
+	private JPanel buttonPanel;
+
+	public FlatInternalFrameTitlePane( JInternalFrame f ) {
+		super( f );
+	}
+
+	@Override
+	protected void installDefaults() {
+		super.installDefaults();
+
+		LookAndFeel.installBorder( this, "InternalFrameTitlePane.border" );
+	}
+
+	@Override
+	protected PropertyChangeListener createPropertyChangeListener() {
+		return new FlatPropertyChangeHandler();
+	}
+
+	@Override
+	protected LayoutManager createLayout() {
+		return new BorderLayout( UIScale.scale( 4 ), 0 );
+	}
+
+	@Override
+	protected void createButtons() {
+		super.createButtons();
+
+		iconButton.setContentAreaFilled( false );
+		maxButton.setContentAreaFilled( false );
+		closeButton.setContentAreaFilled( false );
+
+		Border emptyBorder = BorderFactory.createEmptyBorder();
+		iconButton.setBorder( emptyBorder );
+		maxButton.setBorder( emptyBorder );
+		closeButton.setBorder( emptyBorder );
+
+		updateButtonsVisibility();
+	}
+
+	@Override
+	protected void addSubComponents() {
+		titleLabel = new JLabel( frame.getTitle() );
+		titleLabel.setFont( FlatUIUtils.nonUIResource( getFont() ) );
+		titleLabel.setMinimumSize( new Dimension( UIScale.scale( 32 ), 1 ) );
+		updateFrameIcon();
+		updateColors();
+
+		buttonPanel = new JPanel();
+		buttonPanel.setLayout( new BoxLayout( buttonPanel, BoxLayout.LINE_AXIS ) );
+		buttonPanel.setOpaque( false );
+
+		buttonPanel.add( iconButton );
+		buttonPanel.add( maxButton );
+		buttonPanel.add( closeButton );
+
+		add( titleLabel, BorderLayout.CENTER );
+		add( buttonPanel, BorderLayout.LINE_END );
+	}
+
+	private void updateFrameIcon() {
+		Icon frameIcon = frame.getFrameIcon();
+		if( frameIcon == UIManager.getIcon( "InternalFrame.icon" ) )
+			frameIcon = null;
+		titleLabel.setIcon( frameIcon );
+	}
+
+	private void updateColors() {
+		Color background = FlatUIUtils.nonUIResource( frame.isSelected() ? selectedTitleColor : notSelectedTitleColor );
+		Color foreground = FlatUIUtils.nonUIResource( frame.isSelected() ? selectedTextColor : notSelectedTextColor );
+
+		titleLabel.setForeground( foreground );
+		iconButton.setBackground( background );
+		iconButton.setForeground( foreground );
+		maxButton.setBackground( background );
+		maxButton.setForeground( foreground );
+		closeButton.setBackground( background );
+		closeButton.setForeground( foreground );
+	}
+
+	private void updateButtonsVisibility() {
+		iconButton.setVisible( frame.isIconifiable() );
+		maxButton.setVisible( frame.isMaximizable() );
+		closeButton.setVisible( frame.isClosable() );
+	}
+
+	/**
+	 * Does nothing because FlatLaf internal frames do not have system menus.
+	 */
+	@Override
+	protected void assembleSystemMenu() {
+	}
+
+	/**
+	 * Does nothing because FlatLaf internal frames do not have system menus.
+	 */
+	@Override
+	protected void showSystemMenu() {
+	}
+
+	@Override
+	public void paintComponent( Graphics g ) {
+		paintTitleBackground( g );
+	}
+
+	//---- class FlatPropertyChangeHandler ------------------------------------
+
+	private class FlatPropertyChangeHandler
+		extends PropertyChangeHandler
+	{
+		@Override
+		public void propertyChange( PropertyChangeEvent e ) {
+			switch( e.getPropertyName() ) {
+				case JInternalFrame.TITLE_PROPERTY:
+					titleLabel.setText( frame.getTitle() );
+					break;
+
+				case JInternalFrame.FRAME_ICON_PROPERTY:
+					updateFrameIcon();
+					break;
+
+				case JInternalFrame.IS_SELECTED_PROPERTY:
+					updateColors();
+					break;
+
+				case "iconable":
+				case "maximizable":
+				case "closable":
+					updateButtonsVisibility();
+					enableActions();
+					revalidate();
+					repaint();
+
+					// do not invoke super.propertyChange() because this adds/removes the buttons
+					return;
+
+				case "componentOrientation":
+					applyComponentOrientation( frame.getComponentOrientation() );
+					break;
+			}
+
+			super.propertyChange( e );
+		}
+	}
+}

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

@@ -0,0 +1,155 @@
+/*
+ * 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.util.UIScale.scale;
+import java.awt.Color;
+import java.awt.Component;
+import java.awt.Graphics;
+import java.awt.Graphics2D;
+import java.awt.Insets;
+import javax.swing.JComponent;
+import javax.swing.JInternalFrame;
+import javax.swing.LookAndFeel;
+import javax.swing.UIManager;
+import javax.swing.plaf.ComponentUI;
+import javax.swing.plaf.basic.BasicInternalFrameUI;
+
+/**
+ * Provides the Flat LaF UI delegate for {@link javax.swing.JInternalFrame}.
+ *
+ * <!-- BasicInternalFrameUI -->
+ *
+ * @uiDefault control											Color
+ * @uiDefault InternalFrame.icon								Icon
+ * @uiDefault InternalFrame.border								Border
+ * @uiDefault InternalFrame.layoutTitlePaneAtOrigin				boolean
+ *
+ * <!-- BasicInternalFrameTitlePane -->
+ *
+ * @uiDefault InternalFrame.titleFont							Font
+ * @uiDefault InternalFrame.icon								Icon
+ * @uiDefault InternalFrame.maximizeIcon						Icon
+ * @uiDefault InternalFrame.minimizeIcon						Icon
+ * @uiDefault InternalFrame.iconifyIcon							Icon
+ * @uiDefault InternalFrame.closeIcon							Icon
+ * @uiDefault InternalFrame.activeTitleBackground				Color
+ * @uiDefault InternalFrame.activeTitleForeground				Color
+ * @uiDefault InternalFrame.inactiveTitleBackground				Color
+ * @uiDefault InternalFrame.inactiveTitleForeground				Color
+ * @uiDefault InternalFrame.closeButtonToolTip					String
+ * @uiDefault InternalFrame.iconButtonToolTip					String
+ * @uiDefault InternalFrame.restoreButtonToolTip				String
+ * @uiDefault InternalFrame.maxButtonToolTip					String
+ * @uiDefault InternalFrameTitlePane.closeButtonText			String
+ * @uiDefault InternalFrameTitlePane.minimizeButtonText			String
+ * @uiDefault InternalFrameTitlePane.restoreButtonText			String
+ * @uiDefault InternalFrameTitlePane.maximizeButtonText			String
+ * @uiDefault InternalFrameTitlePane.moveButtonText				String
+ * @uiDefault InternalFrameTitlePane.sizeButtonText				String
+ * @uiDefault InternalFrameTitlePane.closeButton.mnemonic		Integer
+ * @uiDefault InternalFrameTitlePane.minimizeButton.mnemonic	Integer
+ * @uiDefault InternalFrameTitlePane.restoreButton.mnemonic		Integer
+ * @uiDefault InternalFrameTitlePane.maximizeButton.mnemonic	Integer
+ * @uiDefault InternalFrameTitlePane.moveButton.mnemonic		Integer
+ * @uiDefault InternalFrameTitlePane.sizeButton.mnemonic		Integer
+ *
+ * <!-- FlatInternalFrameUI -->
+ *
+ * @uiDefault InternalFrame.activeBorderColor					Color
+ * @uiDefault InternalFrame.inactiveBorderColor					Color
+ * @uiDefault InternalFrame.borderLineWidth						int
+ * @uiDefault InternalFrame.borderMargins						Insets
+ *
+ * <!-- FlatInternalFrameTitlePane -->
+ *
+ * @uiDefault InternalFrameTitlePane.border						Border
+ *
+ * @author Karl Tauber
+ */
+public class FlatInternalFrameUI
+	extends BasicInternalFrameUI
+{
+	public static ComponentUI createUI( JComponent c ) {
+		return new FlatInternalFrameUI( (JInternalFrame) c );
+	}
+
+	public FlatInternalFrameUI( JInternalFrame b ) {
+		super( b );
+	}
+
+	@Override
+	public void installUI( JComponent c ) {
+		super.installUI( c );
+
+		LookAndFeel.installProperty( frame, "opaque", false );
+	}
+
+	@Override
+	protected JComponent createNorthPane( JInternalFrame w ) {
+		return new FlatInternalFrameTitlePane( w );
+	}
+
+	//---- class FlatInternalFrameBorder --------------------------------------
+
+	public static class FlatInternalFrameBorder
+		extends FlatEmptyBorder
+	{
+		private final Color activeBorderColor = UIManager.getColor( "InternalFrame.activeBorderColor" );
+		private final Color inactiveBorderColor = UIManager.getColor( "InternalFrame.inactiveBorderColor" );
+		private final int borderLineWidth = FlatUIUtils.getUIInt( "InternalFrame.borderLineWidth", 1 );
+
+		public FlatInternalFrameBorder() {
+			super( UIManager.getInsets( "InternalFrame.borderMargins" ) );
+		}
+
+		@Override
+		public Insets getBorderInsets( Component c, Insets insets ) {
+			if( c instanceof JInternalFrame && ((JInternalFrame)c).isMaximum() ) {
+				insets.left = scale( Math.min( borderLineWidth, left ) );
+				insets.top = scale( Math.min( borderLineWidth, top ) );
+				insets.right = scale( Math.min( borderLineWidth, right ) );
+				insets.bottom = scale( Math.min( borderLineWidth, bottom ) );
+				return insets;
+			}
+
+			return super.getBorderInsets( c, insets );
+		}
+
+		@Override
+		public void paintBorder( Component c, Graphics g, int x, int y, int width, int height ) {
+			JInternalFrame f = (JInternalFrame) c;
+
+			Insets insets = getBorderInsets( c );
+			float lineWidth = scale( (float) borderLineWidth );
+
+			Graphics2D g2 = (Graphics2D) g.create();
+			try {
+				FlatUIUtils.setRenderingHints( g2 );
+				g2.setColor( f.isSelected() ? activeBorderColor : inactiveBorderColor );
+				g2.fill( FlatUIUtils.createRectangle(
+					x + insets.left - lineWidth,
+					y + insets.top - lineWidth,
+					width - insets.left - insets.right + (lineWidth * 2),
+					height - insets.top - insets.bottom + (lineWidth * 2),
+					lineWidth ) );
+			} finally {
+				g2.dispose();
+			}
+		}
+	}
+}

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

@@ -20,12 +20,14 @@ import java.awt.Color;
 import java.awt.FontMetrics;
 import java.awt.Graphics;
 import java.awt.Rectangle;
+import java.beans.PropertyChangeEvent;
 import javax.swing.Icon;
 import javax.swing.JComponent;
 import javax.swing.JLabel;
 import javax.swing.SwingUtilities;
 import javax.swing.UIManager;
 import javax.swing.plaf.ComponentUI;
+import javax.swing.plaf.basic.BasicHTML;
 import javax.swing.plaf.basic.BasicLabelUI;
 import com.formdev.flatlaf.FlatLaf;
 import com.formdev.flatlaf.util.UIScale;
@@ -77,6 +79,51 @@ public class FlatLabelUI
 		defaults_initialized = false;
 	}
 
+	@Override
+	protected void installComponents( JLabel c ) {
+		super.installComponents( c );
+
+		// update HTML renderer if necessary
+		updateHTMLRenderer( c, c.getText(), false );
+	}
+
+	@Override
+	public void propertyChange( PropertyChangeEvent e ) {
+		String name = e.getPropertyName();
+		if( name == "text" || name == "font" || name == "foreground" ) {
+			JLabel label = (JLabel) e.getSource();
+			updateHTMLRenderer( label, label.getText(), true );
+		} else
+			super.propertyChange( e );
+	}
+
+	/**
+	 * Checks whether text contains HTML headings and adds a special CSS rule to
+	 * re-calculate heading font sizes based on current component font size.
+	 */
+	static void updateHTMLRenderer( JComponent c, String text, boolean always ) {
+		if( BasicHTML.isHTMLString( text ) &&
+			c.getClientProperty( "html.disable" ) != Boolean.TRUE &&
+			text.contains( "<h" ) &&
+			(text.contains( "<h1" ) || text.contains( "<h2" ) || text.contains( "<h3" ) ||
+			 text.contains( "<h4" ) || text.contains( "<h5" ) || text.contains( "<h6" )) )
+		{
+			int headIndex = text.indexOf( "<head>" );
+
+			String style = "<style>BASE_SIZE " + c.getFont().getSize() + "</style>";
+			if( headIndex < 0 )
+				style = "<head>" + style + "</head>";
+
+			int insertIndex = headIndex >= 0 ? (headIndex + "<head>".length()) : "<html>".length();
+			text = text.substring( 0, insertIndex )
+				+ style
+				+ text.substring( insertIndex );
+		} else if( !always )
+			return; // not necessary to invoke BasicHTML.updateRenderer()
+
+		BasicHTML.updateRenderer( c, text );
+	}
+
 	@Override
 	protected void paintEnabledText( JLabel l, Graphics g, String s, int textX, int textY ) {
 		int mnemIndex = FlatLaf.isShowMnemonics() ? l.getDisplayedMnemonicIndex() : -1;

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

@@ -26,9 +26,9 @@ import java.awt.Insets;
 /**
  * Line border for various components.
  *
- * Paints a scaled 1px thick line around the component.
- * The line thickness is not included in the border insets.
- * The insets should be at least 1,1,1,1.
+ * Paints a scaled (usually 1px thick) line around the component.
+ * The line thickness is not added to the border insets.
+ * The insets should be at least have line thickness (usually 1,1,1,1).
  *
  * @author Karl Tauber
  */
@@ -36,10 +36,24 @@ public class FlatLineBorder
 	extends FlatEmptyBorder
 {
 	private final Color lineColor;
+	private final float lineThickness;
 
 	public FlatLineBorder( Insets insets, Color lineColor ) {
+		this( insets, lineColor, 1f );
+	}
+
+	public FlatLineBorder( Insets insets, Color lineColor, float lineThickness ) {
 		super( insets );
 		this.lineColor = lineColor;
+		this.lineThickness = lineThickness;
+	}
+
+	public Color getLineColor() {
+		return lineColor;
+	}
+
+	public float getLineThickness() {
+		return lineThickness;
 	}
 
 	@Override
@@ -48,7 +62,7 @@ public class FlatLineBorder
 		try {
 			FlatUIUtils.setRenderingHints( g2 );
 			g2.setColor( lineColor );
-			FlatUIUtils.paintComponentBorder( g2, x, y, width, height, 0f, scale( 1f ), 0f );
+			FlatUIUtils.paintComponentBorder( g2, x, y, width, height, 0f, scale( lineThickness ), 0f );
 		} finally {
 			g2.dispose();
 		}

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

@@ -81,7 +81,7 @@ public class FlatListUI
 		selectionInactiveBackground = UIManager.getColor( "List.selectionInactiveBackground" );
 		selectionInactiveForeground = UIManager.getColor( "List.selectionInactiveForeground" );
 
-		toggleSelectionColors( list.hasFocus() );
+		toggleSelectionColors();
 	}
 
 	@Override
@@ -100,13 +100,13 @@ public class FlatListUI
 			@Override
 			public void focusGained( FocusEvent e ) {
 				super.focusGained( e );
-				toggleSelectionColors( true );
+				toggleSelectionColors();
 			}
 
 			@Override
 			public void focusLost( FocusEvent e ) {
 				super.focusLost( e );
-				toggleSelectionColors( false );
+				toggleSelectionColors();
 			}
 		};
 	}
@@ -120,8 +120,8 @@ public class FlatListUI
 	 * already used in applications. Then either the inactive colors are not used,
 	 * or the application has to be changed to extend a FlatLaf renderer.
 	 */
-	private void toggleSelectionColors( boolean focused ) {
-		if( focused ) {
+	private void toggleSelectionColors() {
+		if( FlatUIUtils.isPermanentFocusOwner( list ) ) {
 			if( list.getSelectionBackground() == selectionInactiveBackground )
 				list.setSelectionBackground( selectionBackground );
 			if( list.getSelectionForeground() == selectionInactiveForeground )

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

@@ -29,13 +29,26 @@ import javax.swing.plaf.basic.BasicBorders;
 public class FlatMarginBorder
 	extends BasicBorders.MarginBorder
 {
+	private final int left, right, top, bottom;
+
+	public FlatMarginBorder() {
+		left = right = top = bottom = 0;
+	}
+
+	public FlatMarginBorder( Insets insets ) {
+		left = insets.left;
+		top = insets.top;
+		right = insets.right;
+		bottom = insets.bottom;
+	}
+
 	@Override
 	public Insets getBorderInsets( Component c, Insets insets ) {
 		insets = super.getBorderInsets( c, insets );
-		insets.top = scale( insets.top );
-		insets.left = scale( insets.left );
-		insets.bottom = scale( insets.bottom );
-		insets.right = scale( insets.right );
+		insets.top = scale( insets.top + top );
+		insets.left = scale( insets.left + left );
+		insets.bottom = scale( insets.bottom + bottom );
+		insets.right = scale( insets.right + right );
 		return insets;
 	}
 }

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

@@ -16,9 +16,20 @@
 
 package com.formdev.flatlaf.ui;
 
+import java.awt.event.ActionEvent;
+import javax.swing.AbstractAction;
+import javax.swing.ActionMap;
 import javax.swing.JComponent;
+import javax.swing.JMenu;
+import javax.swing.JMenuBar;
+import javax.swing.MenuElement;
+import javax.swing.MenuSelectionManager;
+import javax.swing.SwingUtilities;
+import javax.swing.plaf.ActionMapUIResource;
 import javax.swing.plaf.ComponentUI;
 import javax.swing.plaf.basic.BasicMenuBarUI;
+import com.formdev.flatlaf.FlatLaf;
+import com.formdev.flatlaf.util.SystemInfo;
 
 /**
  * Provides the Flat LaF UI delegate for {@link javax.swing.JMenuBar}.
@@ -38,4 +49,45 @@ public class FlatMenuBarUI
 	public static ComponentUI createUI( JComponent c ) {
 		return new FlatMenuBarUI();
 	}
+
+	/*
+	 * WARNING: This class is not used on macOS if screen menu bar is enabled.
+	 *          Do not add any functionality here.
+	 */
+
+	@Override
+	protected void installKeyboardActions() {
+		super.installKeyboardActions();
+
+		ActionMap map = SwingUtilities.getUIActionMap( menuBar );
+		if( map == null ) {
+			map = new ActionMapUIResource();
+			SwingUtilities.replaceUIActionMap( menuBar, map );
+		}
+		map.put( "takeFocus", new TakeFocus() );
+	}
+
+	//---- class TakeFocus ----------------------------------------------------
+
+	/**
+	 * Activates the menu bar and shows mnemonics.
+	 * On Windows, the popup of the first menu is not shown.
+	 * On other platforms, the popup of the first menu is shown.
+	 */
+	private static class TakeFocus
+		extends AbstractAction
+	{
+		@Override
+		public void actionPerformed( ActionEvent e ) {
+			JMenuBar menuBar = (JMenuBar) e.getSource();
+			JMenu menu = menuBar.getMenu( 0 );
+			if( menu != null ) {
+				MenuSelectionManager.defaultManager().setSelectedPath( SystemInfo.IS_WINDOWS
+					? new MenuElement[] { menuBar, menu }
+					: new MenuElement[] { menuBar, menu, menu.getPopupMenu() } );
+
+				FlatLaf.showMnemonics( menuBar );
+			}
+		}
+	}
 }

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

@@ -0,0 +1,49 @@
+/*
+ * 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.util.UIScale.scale;
+import java.awt.Component;
+import java.awt.Insets;
+import javax.swing.JMenuBar;
+import javax.swing.UIManager;
+
+/**
+ * Border for {@link javax.swing.JMenu}, {@link javax.swing.JMenuItem},
+ * {@link javax.swing.JCheckBoxMenuItem} and {@link javax.swing.JRadioButtonMenuItem}.
+ *
+ * @uiDefault MenuBar.itemMargins				Insets
+ *
+ * @author Karl Tauber
+ */
+public class FlatMenuItemBorder
+	extends FlatMarginBorder
+{
+	private final Insets menuBarItemMargins = UIManager.getInsets( "MenuBar.itemMargins" );
+
+	@Override
+	public Insets getBorderInsets( Component c, Insets insets ) {
+		if( c.getParent() instanceof JMenuBar ) {
+			insets.top = scale( menuBarItemMargins.top );
+			insets.left = scale( menuBarItemMargins.left );
+			insets.bottom = scale( menuBarItemMargins.bottom + 1 );
+			insets.right = scale( menuBarItemMargins.right );
+			return insets;
+		} else
+			return super.getBorderInsets( c, insets );
+	}
+}

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

@@ -0,0 +1,516 @@
+/*
+ * 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.util.UIScale.scale;
+import java.awt.Color;
+import java.awt.Component;
+import java.awt.Dimension;
+import java.awt.Font;
+import java.awt.FontMetrics;
+import java.awt.Graphics;
+import java.awt.Graphics2D;
+import java.awt.Insets;
+import java.awt.Paint;
+import java.awt.Rectangle;
+import java.awt.event.InputEvent;
+import java.awt.event.KeyEvent;
+import java.text.AttributedCharacterIterator;
+import javax.swing.Icon;
+import javax.swing.JMenu;
+import javax.swing.JMenuItem;
+import javax.swing.KeyStroke;
+import javax.swing.SwingUtilities;
+import javax.swing.UIManager;
+import javax.swing.plaf.basic.BasicHTML;
+import javax.swing.text.View;
+import com.formdev.flatlaf.FlatLaf;
+import com.formdev.flatlaf.util.Graphics2DProxy;
+
+/**
+ * Renderer for menu items.
+ *
+ * @uiDefault MenuItem.minimumWidth									int
+ * @uiDefault MenuItem.minimumIconSize								Dimension
+ * @uiDefault MenuItem.textAcceleratorGap							int
+ * @uiDefault MenuItem.textNoAcceleratorGap							int
+ * @uiDefault MenuItem.acceleratorArrowGap							int
+ * @uiDefault MenuItem.checkBackground								Color
+ * @uiDefault MenuItem.underlineSelectionBackground					Color
+ * @uiDefault MenuItem.underlineSelectionCheckBackground			Color
+ * @uiDefault MenuItem.underlineSelectionColor						Color
+ * @uiDefault MenuItem.underlineSelectionHeight						Color
+ *
+ * @author Karl Tauber
+ */
+public class FlatMenuItemRenderer
+{
+	protected final JMenuItem menuItem;
+	protected final Icon checkIcon;
+	protected final Icon arrowIcon;
+	protected final Font acceleratorFont;
+	protected final String acceleratorDelimiter;
+
+	protected final int minimumWidth = UIManager.getInt( "MenuItem.minimumWidth" );
+	protected final Dimension minimumIconSize;
+	protected final int textAcceleratorGap = FlatUIUtils.getUIInt( "MenuItem.textAcceleratorGap", 28 );
+	protected final int textNoAcceleratorGap = FlatUIUtils.getUIInt( "MenuItem.textNoAcceleratorGap", 6 );
+	protected final int acceleratorArrowGap = FlatUIUtils.getUIInt( "MenuItem.acceleratorArrowGap", 2 );
+
+	protected final Color checkBackground = UIManager.getColor( "MenuItem.checkBackground" );
+	protected final Insets checkMargins = UIManager.getInsets( "MenuItem.checkMargins" );
+
+	protected final Color underlineSelectionBackground = UIManager.getColor( "MenuItem.underlineSelectionBackground" );
+	protected final Color underlineSelectionCheckBackground = UIManager.getColor( "MenuItem.underlineSelectionCheckBackground" );
+	protected final Color underlineSelectionColor = UIManager.getColor( "MenuItem.underlineSelectionColor" );
+	protected final int underlineSelectionHeight = UIManager.getInt( "MenuItem.underlineSelectionHeight" );
+
+	protected FlatMenuItemRenderer( JMenuItem menuItem, Icon checkIcon, Icon arrowIcon,
+		Font acceleratorFont, String acceleratorDelimiter )
+	{
+		this.menuItem = menuItem;
+		this.checkIcon = checkIcon;
+		this.arrowIcon = arrowIcon;
+		this.acceleratorFont = acceleratorFont;
+		this.acceleratorDelimiter = acceleratorDelimiter;
+
+		Dimension minimumIconSize = UIManager.getDimension( "MenuItem.minimumIconSize" );
+		this.minimumIconSize = (minimumIconSize != null) ? minimumIconSize : new Dimension( 16, 16 );
+	}
+
+	protected Dimension getPreferredMenuItemSize() {
+		int width = 0;
+		int height = 0;
+		boolean isTopLevelMenu = isTopLevelMenu( menuItem );
+
+		Rectangle viewRect = new Rectangle( 0, 0, Integer.MAX_VALUE, Integer.MAX_VALUE );
+		Rectangle iconRect = new Rectangle();
+		Rectangle textRect = new Rectangle();
+
+		// layout icon and text
+		SwingUtilities.layoutCompoundLabel( menuItem,
+			menuItem.getFontMetrics( menuItem.getFont() ), menuItem.getText(), getIconForLayout(),
+			menuItem.getVerticalAlignment(), menuItem.getHorizontalAlignment(),
+			menuItem.getVerticalTextPosition(), menuItem.getHorizontalTextPosition(),
+			viewRect, iconRect, textRect, scale( menuItem.getIconTextGap() ) );
+
+		// union icon and text rectangles
+		Rectangle labelRect = iconRect.union( textRect );
+		width += labelRect.width;
+		height = Math.max( labelRect.height, height );
+
+		// accelerator size
+		String accelText = getAcceleratorText();
+		if( accelText != null ) {
+			// gap between text and accelerator
+			width += scale( !isTopLevelMenu ? textAcceleratorGap : menuItem.getIconTextGap() );
+
+			FontMetrics accelFm = menuItem.getFontMetrics( acceleratorFont );
+			width += SwingUtilities.computeStringWidth( accelFm, accelText );
+			height = Math.max( accelFm.getHeight(), height );
+		}
+
+		// arrow size
+		if( !isTopLevelMenu && arrowIcon != null ) {
+			// gap between text and arrow
+			if( accelText == null )
+				width += scale( textNoAcceleratorGap );
+
+			// gap between accelerator and arrow
+			width += scale( acceleratorArrowGap );
+
+			width += arrowIcon.getIconWidth();
+			height = Math.max( arrowIcon.getIconHeight(), height );
+		}
+
+		// add insets
+		Insets insets = menuItem.getInsets();
+		width += insets.left + insets.right;
+		height += insets.top + insets.bottom;
+
+		// minimum width
+		if( !isTopLevelMenu ) {
+			int minimumWidth = FlatUIUtils.minimumWidth( menuItem, this.minimumWidth );
+			width = Math.max( width, scale( minimumWidth ) );
+		}
+
+		return new Dimension( width, height );
+	}
+
+	private void layout( Rectangle viewRect, Rectangle iconRect, Rectangle textRect,
+		Rectangle accelRect, Rectangle arrowRect, Rectangle labelRect )
+	{
+		boolean isTopLevelMenu = isTopLevelMenu( menuItem );
+
+		// layout arrow
+		if( !isTopLevelMenu && arrowIcon != null ) {
+			arrowRect.width = arrowIcon.getIconWidth();
+			arrowRect.height = arrowIcon.getIconHeight();
+		} else
+			arrowRect.setSize( 0, 0 );
+		arrowRect.y = viewRect.y + centerOffset( viewRect.height, arrowRect.height );
+
+		// layout accelerator
+		String accelText = getAcceleratorText();
+		if( accelText != null ) {
+			FontMetrics accelFm = menuItem.getFontMetrics( acceleratorFont );
+			accelRect.width = SwingUtilities.computeStringWidth( accelFm, accelText );
+			accelRect.height = accelFm.getHeight();
+
+			accelRect.y = viewRect.y + centerOffset( viewRect.height, accelRect.height );
+		} else
+			accelRect.setBounds( 0, 0, 0, 0 );
+
+		// compute horizontal positions of accelerator and arrow
+		int accelArrowGap = !isTopLevelMenu ? scale( acceleratorArrowGap ) : 0;
+		if( menuItem.getComponentOrientation().isLeftToRight() ) {
+			// left-to-right
+			arrowRect.x = viewRect.x + viewRect.width - arrowRect.width;
+			accelRect.x = arrowRect.x - accelArrowGap - accelRect.width;
+		} else {
+			// right-to-left
+			arrowRect.x = viewRect.x;
+			accelRect.x = arrowRect.x + accelArrowGap + arrowRect.width;
+		}
+
+		// width of accelerator, arrow and gap
+		int accelArrowWidth = accelRect.width + arrowRect.width;
+		if( accelText != null )
+			accelArrowWidth += scale( !isTopLevelMenu ? textAcceleratorGap : menuItem.getIconTextGap() );
+		if( !isTopLevelMenu && arrowIcon != null ) {
+			if( accelText == null )
+				accelArrowWidth += scale( textNoAcceleratorGap );
+			accelArrowWidth += scale( acceleratorArrowGap );
+		}
+
+		// label rectangle is view rectangle subtracted by accelerator, arrow and gap
+		labelRect.setBounds( viewRect );
+		labelRect.width -= accelArrowWidth;
+		if( !menuItem.getComponentOrientation().isLeftToRight() )
+			labelRect.x += accelArrowWidth;
+
+		// layout icon and text
+		SwingUtilities.layoutCompoundLabel( menuItem,
+			menuItem.getFontMetrics( menuItem.getFont() ), menuItem.getText(), getIconForLayout(),
+			menuItem.getVerticalAlignment(), menuItem.getHorizontalAlignment(),
+			menuItem.getVerticalTextPosition(), menuItem.getHorizontalTextPosition(),
+			labelRect, iconRect, textRect, scale( menuItem.getIconTextGap() ) );
+	}
+
+	private static int centerOffset( int wh1, int wh2 ) {
+		return (wh1 / 2) - (wh2 / 2);
+	}
+
+	protected void paintMenuItem( Graphics g, Color selectionBackground, Color selectionForeground,
+		Color disabledForeground, Color acceleratorForeground, Color acceleratorSelectionForeground )
+	{
+		Rectangle viewRect = new Rectangle( menuItem.getWidth(), menuItem.getHeight() );
+
+		// subtract insets
+		Insets insets = menuItem.getInsets();
+		viewRect.x += insets.left;
+		viewRect.y += insets.top;
+		viewRect.width -= (insets.left + insets.right);
+		viewRect.height -= (insets.top + insets.bottom);
+
+		Rectangle iconRect = new Rectangle();
+		Rectangle textRect = new Rectangle();
+		Rectangle accelRect = new Rectangle();
+		Rectangle arrowRect = new Rectangle();
+		Rectangle labelRect = new Rectangle();
+
+		layout( viewRect, iconRect, textRect, accelRect, arrowRect, labelRect );
+
+/*debug
+		g.setColor( Color.green ); g.drawRect( viewRect.x, viewRect.y, viewRect.width - 1, viewRect.height - 1 );
+		g.setColor( Color.red ); g.drawRect( labelRect.x, labelRect.y, labelRect.width - 1, labelRect.height - 1 );
+		g.setColor( Color.blue ); g.drawRect( iconRect.x, iconRect.y, iconRect.width - 1, iconRect.height - 1 );
+		g.setColor( Color.cyan ); g.drawRect( textRect.x, textRect.y, textRect.width - 1, textRect.height - 1 );
+		g.setColor( Color.magenta ); g.drawRect( accelRect.x, accelRect.y, accelRect.width - 1, accelRect.height - 1 );
+		g.setColor( Color.orange ); g.drawRect( arrowRect.x, arrowRect.y, arrowRect.width - 1, arrowRect.height - 1 );
+debug*/
+
+		paintBackground( g, selectionBackground );
+		paintIcon( g, iconRect, getIconForPainting() );
+		paintText( g, textRect, menuItem.getText(), selectionForeground, disabledForeground );
+		paintAccelerator( g, accelRect, getAcceleratorText(), acceleratorForeground, acceleratorSelectionForeground, disabledForeground );
+		if( !isTopLevelMenu( menuItem ) )
+			paintArrowIcon( g, arrowRect, arrowIcon );
+	}
+
+	protected void paintBackground( Graphics g, Color selectionBackground ) {
+		boolean armedOrSelected = isArmedOrSelected( menuItem );
+		if( menuItem.isOpaque() || armedOrSelected ) {
+			int width = menuItem.getWidth();
+			int height = menuItem.getHeight();
+
+			// paint background
+			g.setColor( armedOrSelected
+				? (isUnderlineSelection() ? underlineSelectionBackground : selectionBackground)
+				: menuItem.getBackground() );
+			g.fillRect( 0, 0, width, height );
+
+			// paint underline
+			if( armedOrSelected && isUnderlineSelection() ) {
+				int underlineHeight = scale( underlineSelectionHeight );
+				g.setColor( underlineSelectionColor );
+				if( isTopLevelMenu( menuItem ) ) {
+					// paint underline at bottom
+					g.fillRect( 0, height - underlineHeight, width, underlineHeight );
+				} else if( menuItem.getComponentOrientation().isLeftToRight() ) {
+					// paint underline at left side
+					g.fillRect( 0, 0, underlineHeight, height );
+				} else {
+					// paint underline at right side
+					g.fillRect( width - underlineHeight, 0, underlineHeight, height );
+				}
+			}
+		}
+	}
+
+	protected void paintIcon( Graphics g, Rectangle iconRect, Icon icon ) {
+		// if checkbox/radiobutton menu item is selected and also has a custom icon,
+		// then use filled icon background to indicate selection (instead of using checkIcon)
+		if( menuItem.isSelected() && checkIcon != null && icon != checkIcon ) {
+			Rectangle r = FlatUIUtils.addInsets( iconRect, scale( checkMargins ) );
+			g.setColor( isUnderlineSelection() ? underlineSelectionCheckBackground : checkBackground );
+			g.fillRect( r.x, r.y, r.width, r.height );
+		}
+
+		paintIcon( g, menuItem, icon, iconRect );
+	}
+
+	protected void paintText( Graphics g, Rectangle textRect, String text, Color selectionForeground, Color disabledForeground ) {
+		View htmlView = (View) menuItem.getClientProperty( BasicHTML.propertyKey );
+		if( htmlView != null ) {
+			paintHTMLText( g, menuItem, textRect, htmlView, isUnderlineSelection() ? null : selectionForeground );
+			return;
+		}
+
+		int mnemonicIndex = FlatLaf.isShowMnemonics() ? menuItem.getDisplayedMnemonicIndex() : -1;
+		Color foreground = menuItem.getForeground();
+
+		paintText( g, menuItem, textRect, text, mnemonicIndex, menuItem.getFont(),
+			foreground, isUnderlineSelection() ? foreground : selectionForeground, disabledForeground );
+	}
+
+	protected void paintAccelerator( Graphics g, Rectangle accelRect, String accelText,
+		Color foreground, Color selectionForeground, Color disabledForeground )
+	{
+		paintText( g, menuItem, accelRect, accelText, -1, acceleratorFont,
+			foreground, isUnderlineSelection() ? foreground : selectionForeground, disabledForeground );
+	}
+
+	protected void paintArrowIcon( Graphics g, Rectangle arrowRect, Icon arrowIcon ) {
+		paintIcon( g, menuItem, arrowIcon, arrowRect );
+	}
+
+	protected static void paintIcon( Graphics g, JMenuItem menuItem, Icon icon, Rectangle iconRect ) {
+		if( icon == null )
+			return;
+
+		// center because the real icon may be smaller than dimension in iconRect
+		int x = iconRect.x + centerOffset( iconRect.width, icon.getIconWidth() );
+		int y = iconRect.y + centerOffset( iconRect.height, icon.getIconHeight() );
+
+		// paint
+		icon.paintIcon( menuItem, g, x, y );
+	}
+
+	protected static void paintText( Graphics g, JMenuItem menuItem,
+		Rectangle textRect, String text, int mnemonicIndex, Font font,
+		Color foreground, Color selectionForeground, Color disabledForeground )
+	{
+		if( text == null || text.isEmpty() )
+			return;
+
+		FontMetrics fm = menuItem.getFontMetrics( font );
+
+		Font oldFont = g.getFont();
+		g.setFont( font );
+		g.setColor( !menuItem.isEnabled()
+			? disabledForeground
+			: (isArmedOrSelected( menuItem )
+				? selectionForeground
+				: foreground) );
+
+		FlatUIUtils.drawStringUnderlineCharAt( menuItem, g, text, mnemonicIndex,
+			textRect.x, textRect.y + fm.getAscent() );
+
+		g.setFont( oldFont );
+	}
+
+	protected static void paintHTMLText( Graphics g, JMenuItem menuItem,
+		Rectangle textRect, View htmlView, Color selectionForeground )
+	{
+		if( isArmedOrSelected( menuItem ) && selectionForeground != null )
+			g = new GraphicsProxyWithTextColor( (Graphics2D) g, selectionForeground );
+
+		htmlView.paint( g, textRect );
+	}
+
+	protected static boolean isArmedOrSelected( JMenuItem menuItem ) {
+		return menuItem.isArmed() || (menuItem instanceof JMenu && menuItem.isSelected());
+	}
+
+	protected static boolean isTopLevelMenu( JMenuItem menuItem ) {
+		return menuItem instanceof JMenu && ((JMenu)menuItem).isTopLevelMenu();
+	}
+
+	private boolean isUnderlineSelection() {
+		return "underline".equals( UIManager.getString( "MenuItem.selectionType" ) );
+	}
+
+	private Icon getIconForPainting() {
+		Icon icon = menuItem.getIcon();
+
+		if( icon == null && checkIcon != null && !isTopLevelMenu( menuItem ) )
+			return checkIcon;
+
+		if( icon == null )
+			return null;
+
+		if( !menuItem.isEnabled() )
+			return menuItem.getDisabledIcon();
+
+		if( menuItem.getModel().isPressed() && menuItem.isArmed() ) {
+			Icon pressedIcon = menuItem.getPressedIcon();
+			if( pressedIcon != null )
+				return pressedIcon;
+		}
+
+		return icon;
+	}
+
+	private Icon getIconForLayout() {
+		Icon icon = menuItem.getIcon();
+
+		if( isTopLevelMenu( menuItem ) )
+			return (icon != null) ? new MinSizeIcon( icon ) : null;
+
+		return new MinSizeIcon( (icon != null) ? icon : checkIcon );
+	}
+
+	private KeyStroke cachedAccelerator;
+	private String cachedAcceleratorText;
+
+	private String getAcceleratorText() {
+		KeyStroke accelerator = menuItem.getAccelerator();
+		if( accelerator == null )
+			return null;
+
+		if( accelerator == cachedAccelerator )
+			return cachedAcceleratorText;
+
+		StringBuilder buf = new StringBuilder();
+		int modifiers = accelerator.getModifiers();
+		if( modifiers != 0 )
+			buf.append( InputEvent.getModifiersExText( modifiers ) ).append( acceleratorDelimiter );
+
+		int keyCode = accelerator.getKeyCode();
+		if( keyCode != 0 )
+			buf.append( KeyEvent.getKeyText( keyCode ) );
+		else
+			buf.append( accelerator.getKeyChar() );
+
+		cachedAccelerator = accelerator;
+		cachedAcceleratorText = buf.toString();
+
+		return cachedAcceleratorText;
+	}
+
+	//---- class MinSizeIcon --------------------------------------------------
+
+	private class MinSizeIcon
+		implements Icon
+	{
+		private final Icon delegate;
+
+		MinSizeIcon( Icon delegate ) {
+			this.delegate = delegate;
+		}
+
+		@Override
+		public int getIconWidth() {
+			int iconWidth = (delegate != null) ? delegate.getIconWidth() : 0;
+			return Math.max( iconWidth, scale( minimumIconSize.width ) );
+		}
+
+		@Override
+		public int getIconHeight() {
+			int iconHeight = (delegate != null) ? delegate.getIconHeight() : 0;
+			return Math.max( iconHeight, scale( minimumIconSize.height ) );
+		}
+
+		@Override
+		public void paintIcon( Component c, Graphics g, int x, int y ) {
+		}
+	}
+
+	//---- class GraphicsProxyWithTextColor -----------------------------------
+
+	private static class GraphicsProxyWithTextColor
+		extends Graphics2DProxy
+	{
+		private final Color textColor;
+
+		GraphicsProxyWithTextColor( Graphics2D delegate, Color textColor ) {
+			super( delegate );
+			this.textColor = textColor;
+		}
+
+		@Override
+		public void drawString( String str, int x, int y ) {
+			Paint oldPaint = getPaint();
+			setPaint( textColor );
+			super.drawString( str, x, y );
+			setPaint( oldPaint );
+		}
+
+		@Override
+		public void drawString( String str, float x, float y ) {
+			Paint oldPaint = getPaint();
+			setPaint( textColor );
+			super.drawString( str, x, y );
+			setPaint( oldPaint );
+		}
+
+		@Override
+		public void drawString( AttributedCharacterIterator iterator, int x, int y ) {
+			Paint oldPaint = getPaint();
+			setPaint( textColor );
+			super.drawString( iterator, x, y );
+			setPaint( oldPaint );
+		}
+
+		@Override
+		public void drawString( AttributedCharacterIterator iterator, float x, float y ) {
+			Paint oldPaint = getPaint();
+			setPaint( textColor );
+			super.drawString( iterator, x, y );
+			setPaint( oldPaint );
+		}
+
+		@Override
+		public void drawChars( char[] data, int offset, int length, int x, int y ) {
+			Paint oldPaint = getPaint();
+			setPaint( textColor );
+			super.drawChars( data, offset, length, x, y );
+			setPaint( oldPaint );
+		}
+	}
+}

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

@@ -16,9 +16,11 @@
 
 package com.formdev.flatlaf.ui;
 
-import static com.formdev.flatlaf.util.UIScale.scale;
-import java.beans.PropertyChangeListener;
+import java.awt.Dimension;
+import java.awt.Graphics;
+import javax.swing.Icon;
 import javax.swing.JComponent;
+import javax.swing.LookAndFeel;
 import javax.swing.plaf.ComponentUI;
 import javax.swing.plaf.basic.BasicMenuItemUI;
 
@@ -27,29 +29,34 @@ import javax.swing.plaf.basic.BasicMenuItemUI;
  *
  * <!-- BasicMenuItemUI -->
  *
- * @uiDefault MenuItem.font								Font
- * @uiDefault MenuItem.background						Color
- * @uiDefault MenuItem.foreground						Color
- * @uiDefault MenuItem.disabledForeground				Color
- * @uiDefault MenuItem.selectionBackground				Color
- * @uiDefault MenuItem.selectionForeground				Color
- * @uiDefault MenuItem.acceleratorForeground			Color
- * @uiDefault MenuItem.acceleratorSelectionForeground	Color
- * @uiDefault MenuItem.acceleratorFont					Font		defaults to MenuItem.font
- * @uiDefault MenuItem.acceleratorDelimiter				String
- * @uiDefault MenuItem.border							Border
- * @uiDefault MenuItem.borderPainted					boolean
- * @uiDefault MenuItem.margin							Insets
- * @uiDefault MenuItem.arrowIcon						Icon
- * @uiDefault MenuItem.checkIcon						Icon
- * @uiDefault MenuItem.opaque							boolean
- * @uiDefault MenuItem.evenHeight						boolean
+ * @uiDefault MenuItem.font											Font
+ * @uiDefault MenuItem.background									Color
+ * @uiDefault MenuItem.foreground									Color
+ * @uiDefault MenuItem.disabledForeground							Color
+ * @uiDefault MenuItem.selectionBackground							Color
+ * @uiDefault MenuItem.selectionForeground							Color
+ * @uiDefault MenuItem.acceleratorForeground						Color
+ * @uiDefault MenuItem.acceleratorSelectionForeground				Color
+ * @uiDefault MenuItem.acceleratorFont								Font		defaults to MenuItem.font
+ * @uiDefault MenuItem.acceleratorDelimiter							String
+ * @uiDefault MenuItem.border										Border
+ * @uiDefault MenuItem.borderPainted								boolean
+ * @uiDefault MenuItem.margin										Insets
+ * @uiDefault MenuItem.arrowIcon									Icon
+ * @uiDefault MenuItem.checkIcon									Icon
+ * @uiDefault MenuItem.opaque										boolean
+ *
+ * <!-- FlatMenuItemUI -->
+ *
+ * @uiDefault MenuItem.iconTextGap									int
  *
  * @author Karl Tauber
  */
 public class FlatMenuItemUI
 	extends BasicMenuItemUI
 {
+	private FlatMenuItemRenderer renderer;
+
 	public static ComponentUI createUI( JComponent c ) {
 		return new FlatMenuItemUI();
 	}
@@ -58,20 +65,30 @@ public class FlatMenuItemUI
 	protected void installDefaults() {
 		super.installDefaults();
 
-		// scale
-		defaultTextIconGap = scale( defaultTextIconGap );
+		LookAndFeel.installProperty( menuItem, "iconTextGap", FlatUIUtils.getUIInt( "MenuItem.iconTextGap", 4 ) );
+
+		renderer = createRenderer();
 	}
 
-	/**
-	 * 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 );
-		};
+	protected void uninstallDefaults() {
+		super.uninstallDefaults();
+
+		renderer = null;
+	}
+
+	protected FlatMenuItemRenderer createRenderer() {
+		return new FlatMenuItemRenderer( menuItem, checkIcon, arrowIcon, acceleratorFont, acceleratorDelimiter );
+	}
+
+	@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/FlatMenuUI.java

@@ -16,9 +16,19 @@
 
 package com.formdev.flatlaf.ui;
 
-import static com.formdev.flatlaf.util.UIScale.scale;
-import java.beans.PropertyChangeListener;
+import java.awt.Color;
+import java.awt.Dimension;
+import java.awt.Font;
+import java.awt.Graphics;
+import java.awt.event.MouseEvent;
+import javax.swing.ButtonModel;
+import javax.swing.Icon;
 import javax.swing.JComponent;
+import javax.swing.JMenu;
+import javax.swing.JMenuItem;
+import javax.swing.LookAndFeel;
+import javax.swing.UIManager;
+import javax.swing.event.MouseInputListener;
 import javax.swing.plaf.ComponentUI;
 import javax.swing.plaf.basic.BasicMenuUI;
 
@@ -27,32 +37,39 @@ import javax.swing.plaf.basic.BasicMenuUI;
  *
  * <!-- BasicMenuUI -->
  *
- * @uiDefault Menu.font								Font
- * @uiDefault Menu.background						Color
- * @uiDefault Menu.foreground						Color
- * @uiDefault Menu.disabledForeground				Color
- * @uiDefault Menu.selectionBackground				Color
- * @uiDefault Menu.selectionForeground				Color
- * @uiDefault Menu.acceleratorForeground			Color
- * @uiDefault Menu.acceleratorSelectionForeground	Color
- * @uiDefault MenuItem.acceleratorFont				Font		defaults to MenuItem.font
- * @uiDefault MenuItem.acceleratorDelimiter			String
- * @uiDefault Menu.border							Border
- * @uiDefault Menu.borderPainted					boolean
- * @uiDefault Menu.margin							Insets
- * @uiDefault Menu.arrowIcon						Icon
- * @uiDefault Menu.checkIcon						Icon
- * @uiDefault Menu.opaque							boolean
- * @uiDefault Menu.evenHeight						boolean
- * @uiDefault Menu.crossMenuMnemonic				boolean	default is false
- * @uiDefault Menu.useMenuBarBackgroundForTopLevel	boolean	default is false
- * @uiDefault MenuBar.background					Color	used if Menu.useMenuBarBackgroundForTopLevel is true
+ * @uiDefault Menu.font												Font
+ * @uiDefault Menu.background										Color
+ * @uiDefault Menu.foreground										Color
+ * @uiDefault Menu.disabledForeground								Color
+ * @uiDefault Menu.selectionBackground								Color
+ * @uiDefault Menu.selectionForeground								Color
+ * @uiDefault Menu.acceleratorForeground							Color
+ * @uiDefault Menu.acceleratorSelectionForeground					Color
+ * @uiDefault MenuItem.acceleratorFont								Font		defaults to MenuItem.font
+ * @uiDefault MenuItem.acceleratorDelimiter							String
+ * @uiDefault Menu.border											Border
+ * @uiDefault Menu.borderPainted									boolean
+ * @uiDefault Menu.margin											Insets
+ * @uiDefault Menu.arrowIcon										Icon
+ * @uiDefault Menu.checkIcon										Icon
+ * @uiDefault Menu.opaque											boolean
+ * @uiDefault Menu.crossMenuMnemonic								boolean	default is false
+ * @uiDefault Menu.useMenuBarBackgroundForTopLevel					boolean	default is false
+ * @uiDefault MenuBar.background									Color	used if Menu.useMenuBarBackgroundForTopLevel is true
+ *
+ * <!-- FlatMenuUI -->
+ *
+ * @uiDefault MenuItem.iconTextGap									int
+ * @uiDefault MenuBar.hoverBackground								Color
  *
  * @author Karl Tauber
  */
 public class FlatMenuUI
 	extends BasicMenuUI
 {
+	private Color hoverBackground;
+	private FlatMenuItemRenderer renderer;
+
 	public static ComponentUI createUI( JComponent c ) {
 		return new FlatMenuUI();
 	}
@@ -61,20 +78,83 @@ public class FlatMenuUI
 	protected void installDefaults() {
 		super.installDefaults();
 
-		// scale
-		defaultTextIconGap = scale( defaultTextIconGap );
+		LookAndFeel.installProperty( menuItem, "iconTextGap", FlatUIUtils.getUIInt( "MenuItem.iconTextGap", 4 ) );
+
+		menuItem.setRolloverEnabled( true );
+
+		hoverBackground = UIManager.getColor( "MenuBar.hoverBackground" );
+		renderer = createRenderer();
 	}
 
-	/**
-	 * 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 );
+	protected void uninstallDefaults() {
+		super.uninstallDefaults();
+
+		hoverBackground = null;
+		renderer = null;
+	}
+
+	protected FlatMenuItemRenderer createRenderer() {
+		return new FlatMenuRenderer( menuItem, checkIcon, arrowIcon, acceleratorFont, acceleratorDelimiter );
+	}
+
+	@Override
+	protected MouseInputListener createMouseInputListener( JComponent c ) {
+		return new BasicMenuUI.MouseInputHandler() {
+			@Override
+			public void mouseEntered( MouseEvent e ) {
+				super.mouseEntered( e );
+				rollover( e, true );
+			}
+
+			@Override
+			public void mouseExited( MouseEvent e ) {
+				super.mouseExited( e );
+				rollover( e, false );
+			}
+
+			private void rollover( MouseEvent e, boolean rollover ) {
+				JMenu menu = (JMenu) e.getSource();
+				if( menu.isTopLevelMenu() && menu.isRolloverEnabled() ) {
+					menu.getModel().setRollover( rollover );
+					menu.repaint();
+				}
+			}
 		};
 	}
+
+	@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 );
+	}
+
+	//---- class FlatMenuRenderer ---------------------------------------------
+
+	protected class FlatMenuRenderer
+		extends FlatMenuItemRenderer
+	{
+		protected FlatMenuRenderer( JMenuItem menuItem, Icon checkIcon, Icon arrowIcon,
+			Font acceleratorFont, String acceleratorDelimiter )
+		{
+			super( menuItem, checkIcon, arrowIcon, acceleratorFont, acceleratorDelimiter );
+		}
+
+		@Override
+		protected void paintBackground( Graphics g, Color selectionBackground ) {
+			ButtonModel model = menuItem.getModel();
+			if( model.isRollover() && !model.isArmed() && !model.isSelected() &&
+				model.isEnabled() && ((JMenu)menuItem).isTopLevelMenu() )
+			{
+				FlatUIUtils.setColor( g, hoverBackground, menuItem.getBackground() );
+				g.fillRect( 0, 0, menuItem.getWidth(), menuItem.getHeight() );
+			} else
+				super.paintBackground( g, selectionBackground );
+		}
+	}
 }

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

@@ -0,0 +1,45 @@
+/*
+ * 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 javax.swing.JComponent;
+import javax.swing.plaf.ComponentUI;
+import javax.swing.plaf.basic.BasicPanelUI;
+
+/**
+ * Provides the Flat LaF UI delegate for {@link javax.swing.JPanel}.
+ *
+ * <!-- BasicPanelUI -->
+ *
+ * @uiDefault Panel.font				Font	unused
+ * @uiDefault Panel.background			Color	only used if opaque
+ * @uiDefault Panel.foreground			Color
+ * @uiDefault Panel.border				Border
+ *
+ * @author Karl Tauber
+ */
+public class FlatPanelUI
+	extends BasicPanelUI
+{
+	private static ComponentUI instance;
+
+	public static ComponentUI createUI( JComponent c ) {
+		if( instance == null )
+			instance = new FlatPanelUI();
+		return instance;
+	}
+}

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

@@ -20,15 +20,21 @@ import static com.formdev.flatlaf.util.UIScale.scale;
 import java.awt.Color;
 import java.awt.Dimension;
 import java.awt.Graphics;
+import java.awt.Toolkit;
 import java.awt.event.FocusListener;
+import java.awt.event.KeyAdapter;
+import java.awt.event.KeyEvent;
+import java.awt.event.KeyListener;
 import java.beans.PropertyChangeEvent;
+import javax.swing.Icon;
 import javax.swing.JComponent;
 import javax.swing.LookAndFeel;
 import javax.swing.UIManager;
 import javax.swing.plaf.ComponentUI;
 import javax.swing.plaf.basic.BasicPasswordFieldUI;
+import javax.swing.text.Caret;
+import javax.swing.text.JTextComponent;
 import com.formdev.flatlaf.FlatClientProperties;
-import com.formdev.flatlaf.util.SystemInfo;
 
 /**
  * Provides the Flat LaF UI delegate for {@link javax.swing.JPasswordField}.
@@ -51,22 +57,28 @@ import com.formdev.flatlaf.util.SystemInfo;
  *
  * <!-- FlatPasswordFieldUI -->
  *
+ * @uiDefault TextComponent.arc						int
  * @uiDefault Component.focusWidth					int
  * @uiDefault Component.minimumWidth				int
  * @uiDefault Component.isIntelliJTheme				boolean
  * @uiDefault PasswordField.placeholderForeground	Color
+ * @uiDefault PasswordField.capsLockIcon			Icon
+ * @uiDefault TextComponent.selectAllOnFocusPolicy	String	never, once (default) or always
  *
  * @author Karl Tauber
  */
 public class FlatPasswordFieldUI
 	extends BasicPasswordFieldUI
 {
+	protected int arc;
 	protected int focusWidth;
 	protected int minimumWidth;
 	protected boolean isIntelliJTheme;
 	protected Color placeholderForeground;
+	protected Icon capsLockIcon;
 
 	private FocusListener focusListener;
+	private KeyListener capsLockListener;
 
 	public static ComponentUI createUI( JComponent c ) {
 		return new FlatPasswordFieldUI();
@@ -76,15 +88,13 @@ public class FlatPasswordFieldUI
 	protected void installDefaults() {
 		super.installDefaults();
 
-		// use other echoChar on Mac because the default is too large in SF font
-		if( SystemInfo.IS_MAC )
-			LookAndFeel.installProperty( getComponent(), "echoChar", '\u2022' );
-
 		String prefix = getPropertyPrefix();
+		arc = UIManager.getInt( "TextComponent.arc" );
 		focusWidth = UIManager.getInt( "Component.focusWidth" );
 		minimumWidth = UIManager.getInt( "Component.minimumWidth" );
 		isIntelliJTheme = UIManager.getBoolean( "Component.isIntelliJTheme" );
 		placeholderForeground = UIManager.getColor( prefix + ".placeholderForeground" );
+		capsLockIcon = UIManager.getIcon( "PasswordField.capsLockIcon" );
 
 		LookAndFeel.installProperty( getComponent(), "opaque", focusWidth == 0 );
 
@@ -96,6 +106,7 @@ public class FlatPasswordFieldUI
 		super.uninstallDefaults();
 
 		placeholderForeground = null;
+		capsLockIcon = null;
 
 		MigLayoutVisualPadding.uninstall( getComponent() );
 	}
@@ -105,7 +116,23 @@ public class FlatPasswordFieldUI
 		super.installListeners();
 
 		focusListener = new FlatUIUtils.RepaintFocusListener( getComponent() );
+		capsLockListener = new KeyAdapter() {
+			@Override
+			public void keyPressed( KeyEvent e ) {
+				repaint( e );
+			}
+			@Override
+			public void keyReleased( KeyEvent e ) {
+				repaint( e );
+			}
+			private void repaint( KeyEvent e ) {
+				if( e.getKeyCode() == KeyEvent.VK_CAPS_LOCK )
+					e.getComponent().repaint();
+			}
+		};
+
 		getComponent().addFocusListener( focusListener );
+		getComponent().addKeyListener( capsLockListener );
 	}
 
 	@Override
@@ -113,7 +140,14 @@ public class FlatPasswordFieldUI
 		super.uninstallListeners();
 
 		getComponent().removeFocusListener( focusListener );
+		getComponent().removeKeyListener( capsLockListener );
 		focusListener = null;
+		capsLockListener = null;
+	}
+
+	@Override
+	protected Caret createCaret() {
+		return new FlatCaret( UIManager.getString( "TextComponent.selectAllOnFocusPolicy" ) );
 	}
 
 	@Override
@@ -126,11 +160,23 @@ public class FlatPasswordFieldUI
 
 	@Override
 	protected void paintSafely( Graphics g ) {
-		FlatTextFieldUI.paintBackground( g, getComponent(), focusWidth, isIntelliJTheme );
+		FlatTextFieldUI.paintBackground( g, getComponent(), focusWidth, arc, isIntelliJTheme );
 		FlatTextFieldUI.paintPlaceholder( g, getComponent(), placeholderForeground );
+		paintCapsLock( g );
 		super.paintSafely( g );
 	}
 
+	protected void paintCapsLock( Graphics g ) {
+		JTextComponent c = getComponent();
+		if( !FlatUIUtils.isPermanentFocusOwner( c ) ||
+			!Toolkit.getDefaultToolkit().getLockingKeyState( KeyEvent.VK_CAPS_LOCK ) )
+		  return;
+
+		int y = (c.getHeight() - capsLockIcon.getIconHeight()) / 2;
+		int x = c.getWidth() - capsLockIcon.getIconWidth() - y;
+		capsLockIcon.paintIcon( c, g, x, y );
+	}
+
 	@Override
 	protected void paintBackground( Graphics g ) {
 		// background is painted elsewhere
@@ -147,6 +193,7 @@ public class FlatPasswordFieldUI
 	}
 
 	private Dimension applyMinimumWidth( Dimension size, JComponent c ) {
+		int minimumWidth = FlatUIUtils.minimumWidth( getComponent(), this.minimumWidth );
 		int focusWidth = (c.getBorder() instanceof FlatBorder) ? this.focusWidth : 0;
 		size.width = Math.max( size.width, scale( minimumWidth + (focusWidth * 2) ) );
 		return size;

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

@@ -16,7 +16,12 @@
 
 package com.formdev.flatlaf.ui;
 
+import java.awt.Component;
+import java.awt.Container;
+import java.awt.Insets;
+import javax.swing.JScrollPane;
 import javax.swing.UIManager;
+import com.formdev.flatlaf.util.UIScale;
 
 /**
  * Border for {@link javax.swing.JPopupMenu}.
@@ -33,4 +38,18 @@ public class FlatPopupMenuBorder
 		super( UIManager.getInsets( "PopupMenu.borderInsets" ),
 			UIManager.getColor( "PopupMenu.borderColor" ) );
 	}
+
+	@Override
+	public Insets getBorderInsets( Component c, Insets insets ) {
+		if( c instanceof Container &&
+			((Container)c).getComponentCount() > 0 &&
+			((Container)c).getComponent( 0 ) instanceof JScrollPane )
+		{
+			// e.g. for combobox popups
+			insets.left = insets.top = insets.right = insets.bottom = UIScale.scale( 1 );
+			return insets;
+		}
+
+		return super.getBorderInsets( c, insets );
+	}
 }

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

@@ -19,6 +19,7 @@ package com.formdev.flatlaf.ui;
 import javax.swing.JComponent;
 import javax.swing.plaf.ComponentUI;
 import javax.swing.plaf.basic.BasicPopupMenuUI;
+import com.formdev.flatlaf.util.SystemInfo;
 
 /**
  * Provides the Flat LaF UI delegate for {@link javax.swing.JPopupMenu}.
@@ -35,7 +36,28 @@ import javax.swing.plaf.basic.BasicPopupMenuUI;
 public class FlatPopupMenuUI
 	extends BasicPopupMenuUI
 {
+	private boolean oldLightWeightPopupEnabled;
+
 	public static ComponentUI createUI( JComponent c ) {
 		return new FlatPopupMenuUI();
 	}
+
+	@Override
+	public void installDefaults() {
+		super.installDefaults();
+
+		// use heavy-weight popups on macOS to get nice drop shadow from OS
+		if( SystemInfo.IS_MAC ) {
+			oldLightWeightPopupEnabled = popupMenu.isLightWeightPopupEnabled();
+			popupMenu.setLightWeightPopupEnabled( false );
+		}
+	}
+
+	@Override
+	protected void uninstallDefaults() {
+		super.uninstallDefaults();
+
+		if( SystemInfo.IS_MAC )
+			popupMenu.setLightWeightPopupEnabled( oldLightWeightPopupEnabled );
+	}
 }

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

@@ -16,6 +16,7 @@
 
 package com.formdev.flatlaf.ui;
 
+import static com.formdev.flatlaf.FlatClientProperties.*;
 import java.awt.Dimension;
 import java.awt.FontMetrics;
 import java.awt.Graphics;
@@ -23,6 +24,7 @@ import java.awt.Graphics2D;
 import java.awt.Insets;
 import java.awt.geom.Area;
 import java.awt.geom.RoundRectangle2D;
+import java.beans.PropertyChangeListener;
 import javax.swing.JComponent;
 import javax.swing.JProgressBar;
 import javax.swing.LookAndFeel;
@@ -60,6 +62,8 @@ public class FlatProgressBarUI
 	protected Dimension horizontalSize;
 	protected Dimension verticalSize;
 
+	private PropertyChangeListener propertyChangeListener;
+
 	public static ComponentUI createUI( JComponent c ) {
 		return new FlatProgressBarUI();
 	}
@@ -75,11 +79,35 @@ public class FlatProgressBarUI
 		verticalSize = UIManager.getDimension( "ProgressBar.verticalSize" );
 	}
 
+	@Override
+	protected void installListeners() {
+		super.installListeners();
+
+		propertyChangeListener = e -> {
+			switch( e.getPropertyName() ) {
+				case PROGRESS_BAR_LARGE_HEIGHT:
+				case PROGRESS_BAR_SQUARE:
+					progressBar.revalidate();
+					progressBar.repaint();
+					break;
+			}
+		};
+		progressBar.addPropertyChangeListener( propertyChangeListener );
+	}
+
+	@Override
+	protected void uninstallListeners() {
+		super.uninstallListeners();
+
+		progressBar.removePropertyChangeListener( propertyChangeListener );
+		propertyChangeListener = null;
+	}
+
 	@Override
 	public Dimension getPreferredSize( JComponent c ) {
 		Dimension size = super.getPreferredSize( c );
 
-		if( progressBar.isStringPainted() ) {
+		if( progressBar.isStringPainted() || clientPropertyBoolean( c, PROGRESS_BAR_LARGE_HEIGHT, false ) ) {
 			// recalculate progress height/width to make it smaller
 			Insets insets = progressBar.getInsets();
 			FontMetrics fm = progressBar.getFontMetrics( progressBar.getFont() );
@@ -122,7 +150,9 @@ public class FlatProgressBarUI
 			return;
 
 		boolean horizontal = (progressBar.getOrientation() == JProgressBar.HORIZONTAL);
-		int arc = Math.min( UIScale.scale( this.arc ), horizontal ? height : width );
+		int arc = clientPropertyBoolean( c, PROGRESS_BAR_SQUARE, false )
+			? 0
+			: Math.min( UIScale.scale( this.arc ), horizontal ? height : width );
 
 		FlatUIUtils.setRenderingHints( (Graphics2D) g );
 
@@ -163,4 +193,19 @@ public class FlatProgressBarUI
 				paintString( g, x, y, width, height, amountFull, insets );
 		}
 	}
+
+	@Override
+	protected void setAnimationIndex( int newValue ) {
+		super.setAnimationIndex( newValue );
+
+		// On HiDPI screens at 125%, 150% and 175% scaling, it occurs that antialiased painting
+		// may paint one pixel outside of the clipping area. This results in visual artifacts
+		// in indeterminate mode when the progress moves around.
+		// Unfortunately it is not safe to invoke getBox() from here (may throw NPE),
+		// which makes it impractical to get progress box and repaint increased box.
+		// Only solution is to repaint whole progress bar.
+		double systemScaleFactor = UIScale.getSystemScaleFactor( progressBar.getGraphicsConfiguration() );
+		if( (int) systemScaleFactor != systemScaleFactor )
+			progressBar.repaint();
+	}
 }

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

@@ -16,9 +16,11 @@
 
 package com.formdev.flatlaf.ui;
 
-import static com.formdev.flatlaf.util.UIScale.scale;
-import java.beans.PropertyChangeListener;
+import java.awt.Dimension;
+import java.awt.Graphics;
+import javax.swing.Icon;
 import javax.swing.JComponent;
+import javax.swing.LookAndFeel;
 import javax.swing.plaf.ComponentUI;
 import javax.swing.plaf.basic.BasicRadioButtonMenuItemUI;
 
@@ -43,13 +45,18 @@ import javax.swing.plaf.basic.BasicRadioButtonMenuItemUI;
  * @uiDefault RadioButtonMenuItem.arrowIcon							Icon
  * @uiDefault RadioButtonMenuItem.checkIcon							Icon
  * @uiDefault RadioButtonMenuItem.opaque							boolean
- * @uiDefault RadioButtonMenuItem.evenHeight						boolean
+ *
+ * <!-- FlatRadioButtonMenuItemUI -->
+ *
+ * @uiDefault MenuItem.iconTextGap									int
  *
  * @author Karl Tauber
  */
 public class FlatRadioButtonMenuItemUI
 	extends BasicRadioButtonMenuItemUI
 {
+	private FlatMenuItemRenderer renderer;
+
 	public static ComponentUI createUI( JComponent c ) {
 		return new FlatRadioButtonMenuItemUI();
 	}
@@ -58,20 +65,30 @@ public class FlatRadioButtonMenuItemUI
 	protected void installDefaults() {
 		super.installDefaults();
 
-		// scale
-		defaultTextIconGap = scale( defaultTextIconGap );
+		LookAndFeel.installProperty( menuItem, "iconTextGap", FlatUIUtils.getUIInt( "MenuItem.iconTextGap", 4 ) );
+
+		renderer = createRenderer();
 	}
 
-	/**
-	 * 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 );
-		};
+	protected void uninstallDefaults() {
+		super.uninstallDefaults();
+
+		renderer = null;
+	}
+
+	protected FlatMenuItemRenderer createRenderer() {
+		return new FlatMenuItemRenderer( menuItem, checkIcon, arrowIcon, acceleratorFont, acceleratorDelimiter );
+	}
+
+	@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/FlatRadioButtonUI.java

@@ -101,6 +101,8 @@ public class FlatRadioButtonUI
 	@Override
 	public Dimension getPreferredSize( JComponent c ) {
 		Dimension size = super.getPreferredSize( c );
+		if( size == null )
+			return null;
 
 		// small insets fix
 		int focusWidth = getIconFocusWidth( c );
@@ -118,11 +120,13 @@ public class FlatRadioButtonUI
 
 	@Override
 	public void paint( Graphics g, JComponent c ) {
-		// fill background even if opaque if
-		// - used as cell renderer (because of selection background)
-		// - if background was explicitly set to a non-UIResource color
+		// fill background even if not opaque if
+		// - contentAreaFilled is true and
+		//   - used as cell renderer (because of selection background)
+		//   - or if background was explicitly set to a non-UIResource color
 		if( !c.isOpaque() &&
-			(c.getParent() instanceof CellRendererPane || !(c.getBackground() instanceof UIResource)) )
+			((AbstractButton)c).isContentAreaFilled() &&
+			(c.getParent() instanceof CellRendererPane || !(c.getBackground() instanceof UIResource)))
 		{
 			g.setColor( c.getBackground() );
 			g.fillRect( 0, 0, c.getWidth(), c.getHeight() );

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

@@ -0,0 +1,38 @@
+/*
+ * 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 javax.swing.JComponent;
+import javax.swing.plaf.ComponentUI;
+import javax.swing.plaf.basic.BasicRootPaneUI;
+
+/**
+ * Provides the Flat LaF UI delegate for {@link javax.swing.JRootPane}.
+ *
+ * @author Karl Tauber
+ */
+public class FlatRootPaneUI
+	extends BasicRootPaneUI
+{
+	private static ComponentUI instance;
+
+	public static ComponentUI createUI( JComponent c ) {
+		if( instance == null )
+			instance = new FlatRootPaneUI();
+		return instance;
+	}
+}

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

@@ -17,6 +17,7 @@
 package com.formdev.flatlaf.ui;
 
 import static com.formdev.flatlaf.util.UIScale.scale;
+import java.awt.Component;
 import javax.swing.UIManager;
 
 /**
@@ -32,7 +33,7 @@ public class FlatRoundBorder
 	protected final int arc = UIManager.getInt( "Component.arc" );
 
 	@Override
-	protected float getArc() {
+	protected float getArc( Component c ) {
 		return scale( (float) arc );
 	}
 }

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

@@ -25,9 +25,11 @@ import java.awt.event.MouseEvent;
 import java.beans.PropertyChangeEvent;
 import java.beans.PropertyChangeListener;
 import java.util.Objects;
+import javax.swing.InputMap;
 import javax.swing.JButton;
 import javax.swing.JComponent;
 import javax.swing.JScrollPane;
+import javax.swing.SwingUtilities;
 import javax.swing.UIManager;
 import javax.swing.plaf.ComponentUI;
 import javax.swing.plaf.basic.BasicScrollBarUI;
@@ -127,9 +129,24 @@ public class FlatScrollBarUI
 			public void propertyChange( PropertyChangeEvent e ) {
 				super.propertyChange( e );
 
-				if( FlatClientProperties.SCROLL_BAR_SHOW_BUTTONS.equals( e.getPropertyName() ) ) {
-					scrollbar.revalidate();
-					scrollbar.repaint();
+				switch( e.getPropertyName() ) {
+					case FlatClientProperties.SCROLL_BAR_SHOW_BUTTONS:
+						scrollbar.revalidate();
+						scrollbar.repaint();
+						break;
+
+					case "componentOrientation":
+						// this is missing in BasicScrollBarUI.Handler.propertyChange()
+						InputMap inputMap = (InputMap) UIManager.get( "ScrollBar.ancestorInputMap" );
+						if( !scrollbar.getComponentOrientation().isLeftToRight() ) {
+							InputMap rtlInputMap = (InputMap) UIManager.get( "ScrollBar.ancestorInputMap.RightToLeft" );
+							if( rtlInputMap != null ) {
+								rtlInputMap.setParent( inputMap );
+								inputMap = rtlInputMap;
+							}
+						}
+						SwingUtilities.replaceUIInputMap( scrollbar, JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT, inputMap );
+						break;
 				}
 			}
 		};

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

@@ -14,22 +14,37 @@
  * limitations under the License.
  */
 
+/*
+ * Smooth scrolling code partly based on code from IntelliJ IDEA Community Edition,
+ * which is licensed under the Apache 2.0 license. Copyright 2000-2016 JetBrains s.r.o.
+ * See: https://github.com/JetBrains/intellij-community/blob/31e1b5a8e43219b9571951bab6457cfb3012e3ef/platform/platform-api/src/com/intellij/ui/components/SmoothScrollPane.java#L141-L185
+ *
+ */
 package com.formdev.flatlaf.ui;
 
 import java.awt.Component;
 import java.awt.Graphics;
 import java.awt.Insets;
+import java.awt.Rectangle;
 import java.awt.event.ContainerEvent;
 import java.awt.event.ContainerListener;
 import java.awt.event.FocusEvent;
 import java.awt.event.FocusListener;
+import java.awt.event.MouseWheelEvent;
+import java.awt.event.MouseWheelListener;
 import java.beans.PropertyChangeEvent;
 import java.beans.PropertyChangeListener;
+import javax.swing.BorderFactory;
+import javax.swing.JButton;
 import javax.swing.JComponent;
 import javax.swing.JScrollBar;
 import javax.swing.JScrollPane;
+import javax.swing.JTable;
 import javax.swing.JViewport;
 import javax.swing.LookAndFeel;
+import javax.swing.ScrollPaneConstants;
+import javax.swing.Scrollable;
+import javax.swing.SwingConstants;
 import javax.swing.UIManager;
 import javax.swing.plaf.ComponentUI;
 import javax.swing.plaf.basic.BasicScrollPaneUI;
@@ -46,6 +61,10 @@ import com.formdev.flatlaf.FlatClientProperties;
  * @uiDefault ScrollPane.border				Border
  * @uiDefault ScrollPane.viewportBorder		Border
  *
+ * <!-- FlatScrollPaneUI -->
+ *
+ * @uiDefault ScrollPane.smoothScrolling		boolean
+ *
  * @author Karl Tauber
  */
 public class FlatScrollPaneUI
@@ -90,6 +109,130 @@ public class FlatScrollPaneUI
 		handler = null;
 	}
 
+	@Override
+	protected MouseWheelListener createMouseWheelListener() {
+		return new BasicScrollPaneUI.MouseWheelHandler() {
+			@Override
+			public void mouseWheelMoved( MouseWheelEvent e ) {
+				// Note: Getting UI value "ScrollPane.smoothScrolling" here to allow
+				// applications to turn smooth scrolling on or off at any time
+				// (e.g. in application options dialog).
+				if( UIManager.getBoolean( "ScrollPane.smoothScrolling" ) &&
+					scrollpane.isWheelScrollingEnabled() &&
+					e.getScrollType() == MouseWheelEvent.WHEEL_UNIT_SCROLL &&
+					e.getPreciseWheelRotation() != 0 &&
+					e.getPreciseWheelRotation() != e.getWheelRotation() )
+				{
+					mouseWheelMovedSmooth( e );
+				} else
+					super.mouseWheelMoved( e );
+			}
+		};
+	}
+
+	private static final double EPSILON = 1e-5d;
+
+	private void mouseWheelMovedSmooth( MouseWheelEvent e ) {
+		// return if there is no viewport
+		JViewport viewport = scrollpane.getViewport();
+		if( viewport == null )
+			return;
+
+		// find scrollbar to scroll
+		JScrollBar scrollbar = scrollpane.getVerticalScrollBar();
+		if( scrollbar == null || !scrollbar.isVisible() || e.isShiftDown() ) {
+			scrollbar = scrollpane.getHorizontalScrollBar();
+			if( scrollbar == null || !scrollbar.isVisible() )
+				return;
+		}
+
+		// consume event
+		e.consume();
+
+		// get precise wheel rotation
+		double rotation = e.getPreciseWheelRotation();
+
+		// get unit and block increment
+		int unitIncrement;
+		int blockIncrement;
+		int orientation = scrollbar.getOrientation();
+		Component view = viewport.getView();
+		if( view instanceof Scrollable ) {
+			Scrollable scrollable = (Scrollable) view;
+
+			// Use (0, 0) view position to obtain constant unit increment of first item
+			// (which might otherwise be variable on smaller-than-unit scrolling).
+			Rectangle visibleRect = new Rectangle( viewport.getViewSize() );
+			unitIncrement = scrollable.getScrollableUnitIncrement( visibleRect, orientation, 1 );
+			blockIncrement = scrollable.getScrollableBlockIncrement( visibleRect, orientation, 1 );
+
+			if( unitIncrement > 0 ) {
+				// For the case that the first item (e.g. in a list) is larger
+				// than the other items, get the unit increment of the second item
+				// and use the smaller one.
+				if( orientation == SwingConstants.VERTICAL ) {
+					visibleRect.y += unitIncrement;
+					visibleRect.height -= unitIncrement;
+				} else {
+					visibleRect.x += unitIncrement;
+					visibleRect.width -= unitIncrement;
+				}
+				int unitIncrement2 = scrollable.getScrollableUnitIncrement( visibleRect, orientation, 1 );
+				if( unitIncrement2 > 0 )
+					unitIncrement = Math.min( unitIncrement, unitIncrement2 );
+			}
+		} else {
+			int direction = rotation < 0 ? -1 : 1;
+			unitIncrement = scrollbar.getUnitIncrement( direction );
+			blockIncrement = scrollbar.getBlockIncrement( direction );
+		}
+
+		// limit scroll amount (number of units to scroll) for small viewports
+		// (e.g. vertical scrolling in file chooser)
+		int scrollAmount = e.getScrollAmount();
+		int viewportWH = (orientation == SwingConstants.VERTICAL)
+			? viewport.getHeight()
+			: viewport.getWidth();
+		if( unitIncrement * scrollAmount > viewportWH )
+			scrollAmount = Math.max( viewportWH / unitIncrement, 1 );
+
+		// compute relative delta
+		double delta = rotation * scrollAmount * unitIncrement;
+		boolean adjustDelta = Math.abs( rotation ) < (1.0 + EPSILON);
+		double adjustedDelta = adjustDelta
+			? Math.max( -blockIncrement, Math.min( delta, blockIncrement ) )
+			: delta;
+
+		// compute new value
+		int value = scrollbar.getValue();
+		double minDelta = scrollbar.getMinimum() - value;
+		double maxDelta = scrollbar.getMaximum() - scrollbar.getModel().getExtent() - value;
+		double boundedDelta = Math.max( minDelta, Math.min( adjustedDelta, maxDelta ) );
+		int newValue = value + (int) Math.round( boundedDelta );
+
+		// set new value
+		if( newValue != value )
+			scrollbar.setValue( newValue );
+
+/*debug
+		System.out.println( String.format( "%4d  %9f / %4d %4d / %12f %5s %12f / %4d %4d %4d / %12f %12f %12f / %4d",
+			e.getWheelRotation(),
+			e.getPreciseWheelRotation(),
+			unitIncrement,
+			blockIncrement,
+			delta,
+			adjustDelta,
+			adjustedDelta,
+			value,
+			scrollbar.getMinimum(),
+			scrollbar.getMaximum(),
+			minDelta,
+			maxDelta,
+			boundedDelta,
+			newValue ) );
+*/
+	}
+
 	@Override
 	protected PropertyChangeListener createPropertyChangeListener() {
 		return new BasicScrollPaneUI.PropertyChangeHandler() {
@@ -97,17 +240,35 @@ public class FlatScrollPaneUI
 			public void propertyChange( PropertyChangeEvent e ) {
 				super.propertyChange( e );
 
-				if( FlatClientProperties.SCROLL_BAR_SHOW_BUTTONS.equals( e.getPropertyName() ) ) {
-					JScrollBar vsb = scrollpane.getVerticalScrollBar();
-					JScrollBar hsb = scrollpane.getHorizontalScrollBar();
-					if( vsb != null ) {
-						vsb.revalidate();
-						vsb.repaint();
-					}
-					if( hsb != null ) {
-						hsb.revalidate();
-						hsb.repaint();
-					}
+				switch( e.getPropertyName() ) {
+					case FlatClientProperties.SCROLL_BAR_SHOW_BUTTONS:
+						JScrollBar vsb = scrollpane.getVerticalScrollBar();
+						JScrollBar hsb = scrollpane.getHorizontalScrollBar();
+						if( vsb != null ) {
+							vsb.revalidate();
+							vsb.repaint();
+						}
+						if( hsb != null ) {
+							hsb.revalidate();
+							hsb.repaint();
+						}
+						break;
+
+					case ScrollPaneConstants.LOWER_LEFT_CORNER:
+					case ScrollPaneConstants.LOWER_RIGHT_CORNER:
+					case ScrollPaneConstants.UPPER_LEFT_CORNER:
+					case ScrollPaneConstants.UPPER_RIGHT_CORNER:
+						// remove border from buttons added to corners
+						Object corner = e.getNewValue();
+						if( corner instanceof JButton &&
+							((JButton)corner).getBorder() instanceof FlatButtonBorder &&
+							scrollpane.getViewport() != null &&
+							scrollpane.getViewport().getView() instanceof JTable )
+						{
+							((JButton)corner).setBorder( BorderFactory.createEmptyBorder() );
+							((JButton)corner).setFocusable( false );
+						}
+					break;
 				}
 			}
 		};

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

@@ -201,7 +201,7 @@ public class FlatSliderUI
 		}
 
 		if( coloredTrack != null ) {
-			FlatUIUtils.setColor( g, slider.hasFocus() ? focusColor : (hover ? hoverColor : thumbColor), thumbColor );
+			FlatUIUtils.setColor( g, FlatUIUtils.isPermanentFocusOwner( slider ) ? focusColor : (hover ? hoverColor : thumbColor), thumbColor );
 			((Graphics2D)g).fill( coloredTrack );
 		}
 
@@ -212,7 +212,7 @@ public class FlatSliderUI
 	@Override
 	public void paintThumb( Graphics g ) {
 		FlatUIUtils.setColor( g, slider.isEnabled()
-			? (slider.hasFocus() ? focusColor : (hover ? hoverColor : thumbColor))
+			? (FlatUIUtils.isPermanentFocusOwner( slider ) ? focusColor : (hover ? hoverColor : thumbColor))
 			: disabledForeground,
 			thumbColor );
 

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

@@ -326,6 +326,7 @@ public class FlatSpinnerUI
 			Dimension editorSize = (editor != null) ? editor.getPreferredSize() : new Dimension( 0, 0 );
 
 			// the arrows width is the same as the inner height so that the arrows area is square
+			int minimumWidth = FlatUIUtils.minimumWidth( spinner, FlatSpinnerUI.this.minimumWidth );
 			int innerHeight = editorSize.height + padding.top + padding.bottom;
 			return new Dimension(
 				Math.max( insets.left + insets.right + editorSize.width + padding.left + padding.right + innerHeight, scale( minimumWidth + (focusWidth * 2) ) ),

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

@@ -26,15 +26,21 @@ import java.awt.FontMetrics;
 import java.awt.Graphics;
 import java.awt.Graphics2D;
 import java.awt.Insets;
+import java.awt.KeyboardFocusManager;
 import java.awt.Rectangle;
 import java.awt.Shape;
+import java.awt.event.InputEvent;
+import java.awt.event.KeyEvent;
 import java.awt.geom.Path2D;
 import java.awt.geom.Rectangle2D;
 import java.beans.PropertyChangeEvent;
 import java.beans.PropertyChangeListener;
+import java.util.Collections;
+import java.util.Set;
 import javax.swing.JButton;
 import javax.swing.JComponent;
 import javax.swing.JTabbedPane;
+import javax.swing.KeyStroke;
 import javax.swing.UIManager;
 import javax.swing.plaf.ComponentUI;
 import javax.swing.plaf.UIResource;
@@ -82,6 +88,7 @@ import com.formdev.flatlaf.util.UIScale;
  * @uiDefault TabbedPane.tabSelectionHeight				int
  * @uiDefault TabbedPane.contentSeparatorHeight			int
  * @uiDefault TabbedPane.showTabSeparators				boolean
+ * @uiDefault TabbedPane.tabSeparatorsFullHeight		boolean
  * @uiDefault TabbedPane.hasFullBorder					boolean
  *
  * @author Karl Tauber
@@ -89,6 +96,9 @@ import com.formdev.flatlaf.util.UIScale;
 public class FlatTabbedPaneUI
 	extends BasicTabbedPaneUI
 {
+	private static Set<KeyStroke> focusForwardTraversalKeys;
+	private static Set<KeyStroke> focusBackwardTraversalKeys;
+
 	protected Color disabledForeground;
 	protected Color selectedBackground;
 	protected Color selectedForeground;
@@ -103,6 +113,7 @@ public class FlatTabbedPaneUI
 	protected int tabSelectionHeight;
 	protected int contentSeparatorHeight;
 	protected boolean showTabSeparators;
+	protected boolean tabSeparatorsFullHeight;
 	protected boolean hasFullBorder;
 	protected boolean tabsOverlapBorder;
 
@@ -128,6 +139,7 @@ public class FlatTabbedPaneUI
 		tabSelectionHeight = UIManager.getInt( "TabbedPane.tabSelectionHeight" );
 		contentSeparatorHeight = UIManager.getInt( "TabbedPane.contentSeparatorHeight" );
 		showTabSeparators = UIManager.getBoolean( "TabbedPane.showTabSeparators" );
+		tabSeparatorsFullHeight = UIManager.getBoolean( "TabbedPane.tabSeparatorsFullHeight" );
 		hasFullBorder = UIManager.getBoolean( "TabbedPane.hasFullBorder" );
 		tabsOverlapBorder = UIManager.getBoolean( "TabbedPane.tabsOverlapBorder" );
 
@@ -139,11 +151,27 @@ public class FlatTabbedPaneUI
 		tabHeight = scale( tabHeight );
 		tabSelectionHeight = scale( tabSelectionHeight );
 
+		// replace focus forward/backward traversal keys with TAB/Shift+TAB because
+		// the default also includes Ctrl+TAB/Ctrl+Shift+TAB, which we need to switch tabs
+		if( focusForwardTraversalKeys == null ) {
+			focusForwardTraversalKeys = Collections.singleton( KeyStroke.getKeyStroke( KeyEvent.VK_TAB, 0 ) );
+			focusBackwardTraversalKeys = Collections.singleton( KeyStroke.getKeyStroke( KeyEvent.VK_TAB, InputEvent.SHIFT_MASK ) );
+		}
+		// Ideally we should use `LookAndFeel.installProperty( tabPane, "focusTraversalKeysForward", keys )` here
+		// instead of `tabPane.setFocusTraversalKeys()`, but WindowsTabbedPaneUI also uses later method
+		// and switching from Windows LaF to FlatLaf would not replace the keys and Ctrl+TAB would not work.
+		tabPane.setFocusTraversalKeys( KeyboardFocusManager.FORWARD_TRAVERSAL_KEYS, focusForwardTraversalKeys );
+		tabPane.setFocusTraversalKeys( KeyboardFocusManager.BACKWARD_TRAVERSAL_KEYS, focusBackwardTraversalKeys );
+
 		MigLayoutVisualPadding.install( tabPane, null );
 	}
 
 	@Override
 	protected void uninstallDefaults() {
+		// restore focus forward/backward traversal keys
+		tabPane.setFocusTraversalKeys( KeyboardFocusManager.FORWARD_TRAVERSAL_KEYS, null );
+		tabPane.setFocusTraversalKeys( KeyboardFocusManager.BACKWARD_TRAVERSAL_KEYS, null );
+
 		super.uninstallDefaults();
 
 		disabledForeground = null;
@@ -169,6 +197,7 @@ public class FlatTabbedPaneUI
 				switch( e.getPropertyName() ) {
 					case TABBED_PANE_SHOW_TAB_SEPARATORS:
 					case TABBED_PANE_HAS_FULL_BORDER:
+					case TABBED_PANE_TAB_HEIGHT:
 						tabPane.revalidate();
 						tabPane.repaint();
 						break;
@@ -181,7 +210,7 @@ public class FlatTabbedPaneUI
 	protected JButton createScrollButton( int direction ) {
 		// this method is invoked before installDefaults(), so we can not use color fields here
 		return new FlatArrowButton( direction, UIManager.getString( "Component.arrowType" ),
-			UIManager.getColor( "TabbedPane.shadow" ),
+			UIManager.getColor( "TabbedPane.foreground" ),
 			UIManager.getColor( "TabbedPane.disabledForeground" ), null,
 			UIManager.getColor( "TabbedPane.hoverColor" ) );
 	}
@@ -215,6 +244,7 @@ public class FlatTabbedPaneUI
 
 	@Override
 	protected int calculateTabHeight( int tabPlacement, int tabIndex, int fontHeight ) {
+		int tabHeight = clientPropertyInt( tabPane, TABBED_PANE_TAB_HEIGHT, this.tabHeight );
 		return Math.max( tabHeight, super.calculateTabHeight( tabPlacement, tabIndex, fontHeight ) - 2 /* was added by superclass */ );
 	}
 
@@ -288,7 +318,7 @@ public class FlatTabbedPaneUI
 		boolean enabled = tabPane.isEnabled();
 		g.setColor( enabled && tabPane.isEnabledAt( tabIndex ) && getRolloverTab() == tabIndex
 			? hoverColor
-			: (enabled && isSelected && tabPane.hasFocus()
+			: (enabled && isSelected && FlatUIUtils.isPermanentFocusOwner( tabPane )
 				? focusColor
 				: (selectedBackground != null && enabled && isSelected
 					? selectedBackground
@@ -305,7 +335,7 @@ public class FlatTabbedPaneUI
 			!isLastInRun( tabIndex ) )
 		{
 			float sepWidth = UIScale.scale( 1f );
-			float offset = UIScale.scale( 5f );
+			float offset = tabSeparatorsFullHeight ? 0 : UIScale.scale( 5f );
 
 			g.setColor( (tabSeparatorColor != null) ? tabSeparatorColor : contentAreaColor );
 			if( tabPlacement == LEFT || tabPlacement == RIGHT ) {

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

@@ -17,18 +17,27 @@
 package com.formdev.flatlaf.ui;
 
 import java.awt.Color;
+import java.awt.Component;
 import java.awt.Container;
 import java.awt.Dimension;
 import java.awt.Graphics;
 import java.awt.Graphics2D;
+import java.awt.Insets;
 import java.awt.Rectangle;
 import java.awt.geom.Rectangle2D;
+import java.util.Objects;
+import javax.swing.Icon;
 import javax.swing.JComponent;
+import javax.swing.JLabel;
 import javax.swing.JScrollPane;
 import javax.swing.JTable;
+import javax.swing.SwingConstants;
 import javax.swing.UIManager;
+import javax.swing.border.Border;
 import javax.swing.plaf.ComponentUI;
+import javax.swing.plaf.UIResource;
 import javax.swing.plaf.basic.BasicTableHeaderUI;
+import javax.swing.table.TableCellRenderer;
 import javax.swing.table.TableColumn;
 import javax.swing.table.TableColumnModel;
 import com.formdev.flatlaf.util.UIScale;
@@ -47,6 +56,7 @@ import com.formdev.flatlaf.util.UIScale;
  * @uiDefault TableHeader.separatorColor		Color
  * @uiDefault TableHeader.bottomSeparatorColor	Color
  * @uiDefault TableHeader.height				int
+ * @uiDefault TableHeader.sortIconPosition		String	right (default), left, top or bottom
  *
  * @author Karl Tauber
  */
@@ -56,6 +66,7 @@ public class FlatTableHeaderUI
 	protected Color separatorColor;
 	protected Color bottomSeparatorColor;
 	protected int height;
+	protected int sortIconPosition;
 
 	public static ComponentUI createUI( JComponent c ) {
 		return new FlatTableHeaderUI();
@@ -68,12 +79,33 @@ public class FlatTableHeaderUI
 		separatorColor = UIManager.getColor( "TableHeader.separatorColor" );
 		bottomSeparatorColor = UIManager.getColor( "TableHeader.bottomSeparatorColor" );
 		height = UIManager.getInt( "TableHeader.height" );
+		switch( Objects.toString( UIManager.getString( "TableHeader.sortIconPosition" ), "right" ) ) {
+			default:
+			case "right":	sortIconPosition = SwingConstants.RIGHT; break;
+			case "left":	sortIconPosition = SwingConstants.LEFT; break;
+			case "top":		sortIconPosition = SwingConstants.TOP; break;
+			case "bottom":	sortIconPosition = SwingConstants.BOTTOM; break;
+		}
+
+		// use own renderer if necessary
+		if( sortIconPosition != SwingConstants.RIGHT ) {
+			TableCellRenderer defaultRenderer = header.getDefaultRenderer();
+			if( defaultRenderer instanceof UIResource )
+				header.setDefaultRenderer( new FlatTableCellHeaderRenderer( defaultRenderer ) );
+		}
 	}
 
 	@Override
 	protected void uninstallDefaults() {
 		super.uninstallDefaults();
 
+		// restore default renderer
+		TableCellRenderer defaultRenderer = header.getDefaultRenderer();
+		if( defaultRenderer instanceof FlatTableCellHeaderRenderer ) {
+			((FlatTableCellHeaderRenderer)defaultRenderer).reset();
+			header.setDefaultRenderer( ((FlatTableCellHeaderRenderer)defaultRenderer).delegate );
+		}
+
 		separatorColor = null;
 		bottomSeparatorColor = null;
 	}
@@ -81,10 +113,14 @@ public class FlatTableHeaderUI
 	@Override
 	public void paint( Graphics g, JComponent c ) {
 		// do not paint borders if JTableHeader.setDefaultRenderer() was used
-		String rendererClassName = header.getDefaultRenderer().getClass().getName();
-		boolean paintBorders =
-			rendererClassName.equals( "sun.swing.table.DefaultTableCellHeaderRenderer" ) ||
-			rendererClassName.equals( "sun.swing.FilePane$AlignableTableHeaderRenderer" );
+		TableCellRenderer defaultRenderer = header.getDefaultRenderer();
+		boolean paintBorders = isSystemDefaultRenderer( defaultRenderer );
+		if( !paintBorders && header.getColumnModel().getColumnCount() > 0 ) {
+			// check whether the renderer delegates to the system default renderer
+			Component rendererComponent = defaultRenderer.getTableCellRendererComponent(
+				header.getTable(), "", false, false, -1, 0 );
+			paintBorders = isSystemDefaultRenderer( rendererComponent );
+		}
 
 		if( paintBorders )
 			paintColumnBorders( g, c );
@@ -95,6 +131,12 @@ public class FlatTableHeaderUI
 			paintDraggedColumnBorders( g, c );
 	}
 
+	private boolean isSystemDefaultRenderer( Object headerRenderer ) {
+		String rendererClassName = headerRenderer.getClass().getName();
+		return rendererClassName.equals( "sun.swing.table.DefaultTableCellHeaderRenderer" ) ||
+			   rendererClassName.equals( "sun.swing.FilePane$AlignableTableHeaderRenderer" );
+	}
+
 	private void paintColumnBorders( Graphics g, JComponent c ) {
 		int width = c.getWidth();
 		int height = c.getHeight();
@@ -203,4 +245,83 @@ public class FlatTableHeaderUI
 		parent = parent.getParent();
 		return (parent instanceof JScrollPane) ? (JScrollPane) parent : null;
 	}
+
+	//---- class FlatTableCellHeaderRenderer ----------------------------------
+
+	/**
+	 * A delegating header renderer that is only used to paint sort arrows at
+	 * top, bottom or left position.
+	 */
+	private class FlatTableCellHeaderRenderer
+		implements TableCellRenderer, Border, UIResource
+	{
+		private final TableCellRenderer delegate;
+
+		private int oldHorizontalTextPosition = -1;
+		private Border origBorder;
+		private Icon sortIcon;
+
+		FlatTableCellHeaderRenderer( TableCellRenderer delegate ) {
+			this.delegate = delegate;
+		}
+
+		@Override
+		public Component getTableCellRendererComponent( JTable table, Object value, boolean isSelected,
+			boolean hasFocus, int row, int column )
+		{
+			Component c = delegate.getTableCellRendererComponent( table, value, isSelected, hasFocus, row, column );
+			if( !(c instanceof JLabel) )
+				return c;
+
+			JLabel l = (JLabel) c;
+
+			if( sortIconPosition == SwingConstants.LEFT ) {
+				if( oldHorizontalTextPosition < 0 )
+					oldHorizontalTextPosition = l.getHorizontalTextPosition();
+				l.setHorizontalTextPosition( SwingConstants.RIGHT );
+			} else {
+				// top or bottom
+				sortIcon = l.getIcon();
+				origBorder = l.getBorder();
+				l.setIcon( null );
+				l.setBorder( this );
+			}
+
+			return l;
+		}
+
+		void reset() {
+			if( sortIconPosition == SwingConstants.LEFT && oldHorizontalTextPosition >= 0 ) {
+				Component c = getTableCellRendererComponent( header.getTable(), "", false, false, -1, 0 );
+				if( c instanceof JLabel && ((JLabel)c).getHorizontalTextPosition() == SwingConstants.RIGHT )
+					((JLabel)c).setHorizontalTextPosition( oldHorizontalTextPosition );
+			}
+		}
+
+		@Override
+		public void paintBorder( Component c, Graphics g, int x, int y, int width, int height ) {
+			if( origBorder != null )
+				origBorder.paintBorder( c, g, x, y, width, height );
+
+			if( sortIcon != null ) {
+				int xi = x + ((width - sortIcon.getIconWidth()) / 2);
+				int yi = (sortIconPosition == SwingConstants.TOP)
+					? y + UIScale.scale( 1 )
+					: y + height - sortIcon.getIconHeight()
+						- 1 // for gap
+						- (int) (1 * UIScale.getUserScaleFactor()); // for bottom border
+				sortIcon.paintIcon( c, g, xi, yi );
+			}
+		}
+
+		@Override
+		public Insets getBorderInsets( Component c ) {
+			return (origBorder != null) ? origBorder.getBorderInsets( c ) : new Insets( 0, 0, 0, 0 );
+		}
+
+		@Override
+		public boolean isBorderOpaque() {
+			return (origBorder != null) ? origBorder.isBorderOpaque() : false;
+		}
+	}
 }

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

@@ -56,7 +56,8 @@ import com.formdev.flatlaf.util.UIScale;
  * <!-- FlatTableUI -->
  *
  * @uiDefault Table.rowHeight							int
- * @uiDefault Table.showGrid							boolean
+ * @uiDefault Table.showHorizontalLines					boolean
+ * @uiDefault Table.showVerticalLines					boolean
  * @uiDefault Table.intercellSpacing					Dimension
  * @uiDefault Table.selectionInactiveBackground			Color
  * @uiDefault Table.selectionInactiveForeground			Color
@@ -72,7 +73,8 @@ import com.formdev.flatlaf.util.UIScale;
 public class FlatTableUI
 	extends BasicTableUI
 {
-	protected boolean showGrid;
+	protected boolean showHorizontalLines;
+	protected boolean showVerticalLines;
 	protected Dimension intercellSpacing;
 
 	protected Color selectionBackground;
@@ -102,7 +104,8 @@ public class FlatTableUI
 	protected void installDefaults() {
 		super.installDefaults();
 
-		showGrid = UIManager.getBoolean( "Table.showGrid" );
+		showHorizontalLines = UIManager.getBoolean( "Table.showHorizontalLines" );
+		showVerticalLines = UIManager.getBoolean( "Table.showVerticalLines" );
 		intercellSpacing = UIManager.getDimension( "Table.intercellSpacing" );
 
 		selectionBackground = UIManager.getColor( "Table.selectionBackground" );
@@ -110,16 +113,19 @@ public class FlatTableUI
 		selectionInactiveBackground = UIManager.getColor( "Table.selectionInactiveBackground" );
 		selectionInactiveForeground = UIManager.getColor( "Table.selectionInactiveForeground" );
 
-		toggleSelectionColors( table.hasFocus() );
+		toggleSelectionColors();
 
 		int rowHeight = FlatUIUtils.getUIInt( "Table.rowHeight", 16 );
 		if( rowHeight > 0 )
 			LookAndFeel.installProperty( table, "rowHeight", UIScale.scale( rowHeight ) );
 
-		if( !showGrid ) {
+		if( !showHorizontalLines ) {
 			oldShowHorizontalLines = table.getShowHorizontalLines();
+			table.setShowHorizontalLines( false );
+		}
+		if( !showVerticalLines ) {
 			oldShowVerticalLines = table.getShowVerticalLines();
-			table.setShowGrid( false );
+			table.setShowVerticalLines( false );
 		}
 
 		if( intercellSpacing != null ) {
@@ -137,19 +143,15 @@ public class FlatTableUI
 		selectionInactiveBackground = null;
 		selectionInactiveForeground = null;
 
-		// restore old show grid
-		if( !showGrid ) {
-			if( !table.getShowHorizontalLines() )
-				table.setShowHorizontalLines( oldShowHorizontalLines );
-			if( !table.getShowVerticalLines() )
-				table.setShowVerticalLines( oldShowVerticalLines );
-		}
+		// restore old show horizontal/vertical lines (if not modified)
+		if( !showHorizontalLines && oldShowHorizontalLines && !table.getShowHorizontalLines() )
+			table.setShowHorizontalLines( true );
+		if( !showVerticalLines && oldShowVerticalLines && !table.getShowVerticalLines() )
+			table.setShowVerticalLines( true );
 
-		// restore old intercell spacing
-		if( intercellSpacing != null ) {
-			if( table.getIntercellSpacing().equals( intercellSpacing ) )
-				table.setIntercellSpacing( oldIntercellSpacing );
-		}
+		// restore old intercell spacing (if not modified)
+		if( intercellSpacing != null && table.getIntercellSpacing().equals( intercellSpacing ) )
+			table.setIntercellSpacing( oldIntercellSpacing );
 	}
 
 	@Override
@@ -158,13 +160,13 @@ public class FlatTableUI
 			@Override
 			public void focusGained( FocusEvent e ) {
 				super.focusGained( e );
-				toggleSelectionColors( true );
+				toggleSelectionColors();
 			}
 
 			@Override
 			public void focusLost( FocusEvent e ) {
 				super.focusLost( e );
-				toggleSelectionColors( false );
+				toggleSelectionColors();
 			}
 		};
 	}
@@ -178,8 +180,8 @@ public class FlatTableUI
 	 * already used in applications. Then either the inactive colors are not used,
 	 * or the application has to be changed to extend a FlatLaf renderer.
 	 */
-	private void toggleSelectionColors( boolean focused ) {
-		if( focused ) {
+	private void toggleSelectionColors() {
+		if( FlatUIUtils.isPermanentFocusOwner( table ) ) {
 			if( table.getSelectionBackground() == selectionInactiveBackground )
 				table.setSelectionBackground( selectionBackground );
 			if( table.getSelectionForeground() == selectionInactiveForeground )

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

@@ -117,6 +117,7 @@ public class FlatTextAreaUI
 		// and subtract 1px border line width.
 		// Using "(scale( 1 ) * 2)" instead of "scale( 2 )" to deal with rounding
 		// issues. E.g. at scale factor 1.5 the first returns 4, but the second 3.
+		int minimumWidth = FlatUIUtils.minimumWidth( getComponent(), this.minimumWidth );
 		size.width = Math.max( size.width, scale( minimumWidth ) - (scale( 1 ) * 2) );
 		return size;
 	}

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

@@ -0,0 +1,39 @@
+/*
+ * 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.ui;
+
+import static com.formdev.flatlaf.util.UIScale.scale;
+import java.awt.Component;
+import javax.swing.UIManager;
+
+/**
+ * Border for various text components (e.g. {@link javax.swing.JTextField}).
+ *
+ * @uiDefault Component.arc					int
+ *
+ * @author Karl Tauber
+ */
+public class FlatTextBorder
+	extends FlatBorder
+{
+	protected final int arc = UIManager.getInt( "TextComponent.arc" );
+
+	@Override
+	protected float getArc( Component c ) {
+		return scale( (float) arc );
+	}
+}

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

@@ -32,9 +32,11 @@ import javax.swing.JSpinner;
 import javax.swing.JTextField;
 import javax.swing.LookAndFeel;
 import javax.swing.UIManager;
+import javax.swing.border.Border;
 import javax.swing.plaf.ComponentUI;
 import javax.swing.plaf.UIResource;
 import javax.swing.plaf.basic.BasicTextFieldUI;
+import javax.swing.text.Caret;
 import javax.swing.text.JTextComponent;
 import com.formdev.flatlaf.FlatClientProperties;
 
@@ -58,16 +60,19 @@ import com.formdev.flatlaf.FlatClientProperties;
  *
  * <!-- FlatTextFieldUI -->
  *
+ * @uiDefault TextComponent.arc					int
  * @uiDefault Component.focusWidth				int
  * @uiDefault Component.minimumWidth			int
  * @uiDefault Component.isIntelliJTheme			boolean
  * @uiDefault TextField.placeholderForeground	Color
+ * @uiDefault TextComponent.selectAllOnFocusPolicy	String	never, once (default) or always
  *
  * @author Karl Tauber
  */
 public class FlatTextFieldUI
 	extends BasicTextFieldUI
 {
+	protected int arc;
 	protected int focusWidth;
 	protected int minimumWidth;
 	protected boolean isIntelliJTheme;
@@ -84,6 +89,7 @@ public class FlatTextFieldUI
 		super.installDefaults();
 
 		String prefix = getPropertyPrefix();
+		arc = UIManager.getInt( "TextComponent.arc" );
 		focusWidth = UIManager.getInt( "Component.focusWidth" );
 		minimumWidth = UIManager.getInt( "Component.minimumWidth" );
 		isIntelliJTheme = UIManager.getBoolean( "Component.isIntelliJTheme" );
@@ -119,6 +125,11 @@ public class FlatTextFieldUI
 		focusListener = null;
 	}
 
+	@Override
+	protected Caret createCaret() {
+		return new FlatCaret( UIManager.getString( "TextComponent.selectAllOnFocusPolicy" ) );
+	}
+
 	@Override
 	protected void propertyChange( PropertyChangeEvent e ) {
 		super.propertyChange( e );
@@ -129,7 +140,7 @@ public class FlatTextFieldUI
 
 	@Override
 	protected void paintSafely( Graphics g ) {
-		paintBackground( g, getComponent(), focusWidth, isIntelliJTheme );
+		paintBackground( g, getComponent(), focusWidth, arc, isIntelliJTheme );
 		paintPlaceholder( g, getComponent(), placeholderForeground );
 		super.paintSafely( g );
 	}
@@ -139,13 +150,15 @@ public class FlatTextFieldUI
 		// background is painted elsewhere
 	}
 
-	static void paintBackground( Graphics g, JTextComponent c, int focusWidth, boolean isIntelliJTheme ) {
+	static void paintBackground( Graphics g, JTextComponent c, int focusWidth, int arc, boolean isIntelliJTheme ) {
+		Border border = c.getBorder();
+
 		// do not paint background if:
 		//   - not opaque and
 		//   - border is not a flat border and
 		//   - opaque was explicitly set (to false)
 		// (same behaviour as in AquaTextFieldUI)
-		if( !c.isOpaque() && !(c.getBorder() instanceof FlatBorder) && FlatUIUtils.hasOpaqueBeenExplicitlySet( c ) )
+		if( !c.isOpaque() && !(border instanceof FlatBorder) && FlatUIUtils.hasOpaqueBeenExplicitlySet( c ) )
 			return;
 
 		// fill background if opaque to avoid garbage if user sets opaque to true
@@ -157,7 +170,8 @@ public class FlatTextFieldUI
 		try {
 			FlatUIUtils.setRenderingHints( g2 );
 
-			float fFocusWidth = (c.getBorder() instanceof FlatBorder) ? scale( (float) focusWidth ) : 0;
+			float fFocusWidth = (border instanceof FlatBorder) ? scale( (float) focusWidth ) : 0;
+			float fArc = (border instanceof FlatTextBorder) ? scale( (float) arc ) : 0;
 
 			Color background = c.getBackground();
 			g2.setColor( !(background instanceof UIResource)
@@ -165,7 +179,7 @@ public class FlatTextFieldUI
 				: (isIntelliJTheme && (!c.isEnabled() || !c.isEditable())
 					? FlatUIUtils.getParentBackground( c )
 					: background) );
-			FlatUIUtils.paintComponentBackground( g2, 0, 0, c.getWidth(), c.getHeight(), fFocusWidth, 0 );
+			FlatUIUtils.paintComponentBackground( g2, 0, 0, c.getWidth(), c.getHeight(), fFocusWidth, fArc );
 		} finally {
 			g2.dispose();
 		}
@@ -217,6 +231,7 @@ public class FlatTextFieldUI
 			(parent != null && parent.getParent() instanceof JSpinner) )
 		  return size;
 
+		int minimumWidth = FlatUIUtils.minimumWidth( getComponent(), this.minimumWidth );
 		int focusWidth = (c.getBorder() instanceof FlatBorder) ? this.focusWidth : 0;
 		size.width = Math.max( size.width, scale( minimumWidth + (focusWidth * 2) ) );
 		return size;

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

@@ -98,6 +98,7 @@ public class FlatTextPaneUI
 		// and subtract 1px border line width.
 		// Using "(scale( 1 ) * 2)" instead of "scale( 2 )" to deal with rounding
 		// issues. E.g. at scale factor 1.5 the first returns 4, but the second 3.
+		int minimumWidth = FlatUIUtils.minimumWidth( getComponent(), this.minimumWidth );
 		size.width = Math.max( size.width, scale( minimumWidth ) - (scale( 1 ) * 2) );
 		return size;
 	}

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

@@ -16,12 +16,18 @@
 
 package com.formdev.flatlaf.ui;
 
+import static com.formdev.flatlaf.FlatClientProperties.*;
 import java.awt.Color;
+import java.awt.Component;
+import java.awt.Graphics;
+import java.beans.PropertyChangeEvent;
 import javax.swing.AbstractButton;
 import javax.swing.ButtonModel;
 import javax.swing.JComponent;
+import javax.swing.JToggleButton;
 import javax.swing.UIManager;
 import javax.swing.plaf.ComponentUI;
+import com.formdev.flatlaf.util.UIScale;
 
 /**
  * Provides the Flat LaF UI delegate for {@link javax.swing.JToggleButton}.
@@ -55,6 +61,13 @@ import javax.swing.plaf.ComponentUI;
  * @uiDefault ToggleButton.disabledSelectedBackground	Color
  * @uiDefault ToggleButton.toolbar.selectedBackground	Color
  *
+ * @uiDefault ToggleButton.tab.underlineHeight			int
+ * @uiDefault ToggleButton.tab.underlineColor			Color
+ * @uiDefault ToggleButton.tab.disabledUnderlineColor	Color
+ * @uiDefault ToggleButton.tab.selectedBackground		Color	optional
+ * @uiDefault ToggleButton.tab.hoverBackground			Color
+ * @uiDefault ToggleButton.tab.focusBackground			Color
+ *
  *
  * @author Karl Tauber
  */
@@ -67,6 +80,13 @@ public class FlatToggleButtonUI
 
 	protected Color toolbarSelectedBackground;
 
+	protected int tabUnderlineHeight;
+	protected Color tabUnderlineColor;
+	protected Color tabDisabledUnderlineColor;
+	protected Color tabSelectedBackground;
+	protected Color tabHoverBackground;
+	protected Color tabFocusBackground;
+
 	private boolean defaults_initialized = false;
 
 	private static ComponentUI instance;
@@ -93,6 +113,13 @@ public class FlatToggleButtonUI
 
 			toolbarSelectedBackground = UIManager.getColor( "ToggleButton.toolbar.selectedBackground" );
 
+			tabUnderlineHeight = UIManager.getInt( "ToggleButton.tab.underlineHeight" );
+			tabUnderlineColor = UIManager.getColor( "ToggleButton.tab.underlineColor" );
+			tabDisabledUnderlineColor = UIManager.getColor( "ToggleButton.tab.disabledUnderlineColor" );
+			tabSelectedBackground = UIManager.getColor( "ToggleButton.tab.selectedBackground" );
+			tabHoverBackground = UIManager.getColor( "ToggleButton.tab.hoverBackground" );
+			tabFocusBackground = UIManager.getColor( "ToggleButton.tab.focusBackground" );
+
 			defaults_initialized = true;
 		}
 	}
@@ -103,6 +130,61 @@ public class FlatToggleButtonUI
 		defaults_initialized = false;
 	}
 
+	@Override
+	protected void propertyChange( AbstractButton b, PropertyChangeEvent e ) {
+		super.propertyChange( b, e );
+
+		switch( e.getPropertyName() ) {
+			case BUTTON_TYPE:
+				if( BUTTON_TYPE_TAB.equals( e.getOldValue() ) || BUTTON_TYPE_TAB.equals( e.getNewValue() ) ) {
+					MigLayoutVisualPadding.uninstall( b );
+					MigLayoutVisualPadding.install( b, getFocusWidth( b ) );
+					b.revalidate();
+				}
+
+				b.repaint();
+				break;
+
+			case TAB_BUTTON_UNDERLINE_HEIGHT:
+			case TAB_BUTTON_UNDERLINE_COLOR:
+			case TAB_BUTTON_SELECTED_BACKGROUND:
+				b.repaint();
+				break;
+		}
+	}
+
+	static boolean isTabButton( Component c ) {
+		return c instanceof JToggleButton && clientPropertyEquals( (JToggleButton) c, BUTTON_TYPE, BUTTON_TYPE_TAB );
+	}
+
+	@Override
+	protected void paintBackground( Graphics g, JComponent c ) {
+		if( isTabButton( c ) ) {
+			int height = c.getHeight();
+			int width = c.getWidth();
+			boolean selected = ((AbstractButton)c).isSelected();
+
+			// paint background
+			Color background = buttonStateColor( c,
+				selected ? clientPropertyColor( c, TAB_BUTTON_SELECTED_BACKGROUND, tabSelectedBackground ) : null,
+				null, tabFocusBackground, tabHoverBackground, null );
+			if( background != null ) {
+				g.setColor( background );
+				g.fillRect( 0, 0, width, height );
+			}
+
+			// paint underline if selected
+			if( selected ) {
+				int underlineHeight = UIScale.scale( clientPropertyInt( c, TAB_BUTTON_UNDERLINE_HEIGHT, tabUnderlineHeight ) );
+				g.setColor( c.isEnabled()
+					? clientPropertyColor( c, TAB_BUTTON_UNDERLINE_COLOR, tabUnderlineColor )
+					: tabDisabledUnderlineColor );
+				g.fillRect( 0, height - underlineHeight, width, underlineHeight );
+			}
+		} else
+			super.paintBackground( g, c );
+	}
+
 	@Override
 	protected Color getBackground( JComponent c ) {
 		ButtonModel model = ((AbstractButton)c).getModel();
@@ -130,4 +212,9 @@ public class FlatToggleButtonUI
 
 		return super.getForeground( c );
 	}
+
+	@Override
+	protected int getFocusWidth( JComponent c ) {
+		return isTabButton( c ) ? 0 : super.getFocusWidth( c );
+	}
 }

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

@@ -29,6 +29,7 @@ import javax.swing.UIManager;
 /**
  * Border for {@link javax.swing.JToolBar}.
  *
+ * @uiDefault ToolBar.borderMargins				Insets
  * @uiDefault ToolBar.gripColor					Color
  *
  * @author Karl Tauber
@@ -42,6 +43,10 @@ public class FlatToolBarBorder
 
 	protected final Color gripColor = UIManager.getColor( "ToolBar.gripColor" );
 
+	public FlatToolBarBorder() {
+		super( UIManager.getInsets( "ToolBar.borderMargins" ) );
+	}
+
 	@Override
 	public void paintBorder( Component c, Graphics g, int x, int y, int width, int height ) {
 		// paint grip

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

@@ -16,18 +16,14 @@
 
 package com.formdev.flatlaf.ui;
 
-import static com.formdev.flatlaf.util.UIScale.scale;
 import java.awt.Component;
 import java.awt.Insets;
 import java.awt.event.ContainerEvent;
 import java.awt.event.ContainerListener;
 import javax.swing.AbstractButton;
 import javax.swing.JComponent;
-import javax.swing.UIManager;
 import javax.swing.border.Border;
-import javax.swing.border.EmptyBorder;
 import javax.swing.plaf.ComponentUI;
-import javax.swing.plaf.UIResource;
 import javax.swing.plaf.basic.BasicToolBarUI;
 
 /**
@@ -45,28 +41,15 @@ import javax.swing.plaf.basic.BasicToolBarUI;
  * @uiDefault ToolBar.floatingForeground				Color
  * @uiDefault ToolBar.isRollover						boolean
  *
- * <!-- FlatToolBarUI -->
- *
- * @uiDefault ToolBar.buttonMargins						Insets
- *
  * @author Karl Tauber
  */
 public class FlatToolBarUI
 	extends BasicToolBarUI
 {
-	private Border rolloverBorder;
-
 	public static ComponentUI createUI( JComponent c ) {
 		return new FlatToolBarUI();
 	}
 
-	@Override
-	public void uninstallUI( JComponent c ) {
-		super.uninstallUI( c );
-
-		rolloverBorder = null;
-	}
-
 	@Override
 	protected ContainerListener createToolBarContListener() {
 		return new ToolBarContListener() {
@@ -90,26 +73,15 @@ public class FlatToolBarUI
 		};
 	}
 
-	@Override
-	protected Border createRolloverBorder() {
-		return getRolloverBorder();
-	}
-
-	@Override
-	protected Border createNonRolloverBorder() {
-		return getRolloverBorder();
-	}
-
-	@Override
-	protected Border getNonRolloverBorder( AbstractButton b ) {
-		return getRolloverBorder();
-	}
-
-	private Border getRolloverBorder() {
-		if( rolloverBorder == null )
-			rolloverBorder = new FlatRolloverMarginBorder();
-		return rolloverBorder;
-	}
+	// disable rollover border
+	@Override protected void setBorderToRollover( Component c ) {}
+	@Override protected void setBorderToNonRollover( Component c ) {}
+	@Override protected void setBorderToNormal( Component c ) {}
+	@Override protected void installRolloverBorders( JComponent c ) {}
+	@Override protected void installNonRolloverBorders( JComponent c ) {}
+	@Override protected void installNormalBorders( JComponent c ) {}
+	@Override protected Border createRolloverBorder() { return null; }
+	@Override protected Border createNonRolloverBorder() { return null; }
 
 	@Override
 	public void setOrientation( int orientation ) {
@@ -123,46 +95,4 @@ public class FlatToolBarUI
 
 		super.setOrientation( orientation );
 	}
-
-	//---- class FlatRolloverMarginBorder -------------------------------------
-
-	/**
-	 * Uses button margin only if explicitly set.
-	 * Otherwise uses insets specified in constructor.
-	 */
-	private static class FlatRolloverMarginBorder
-		extends EmptyBorder
-	{
-		public FlatRolloverMarginBorder() {
-			super( UIManager.getInsets( "ToolBar.buttonMargins" ) );
-		}
-
-		@Override
-		public Insets getBorderInsets( Component c, Insets insets ) {
-			Insets margin = (c instanceof AbstractButton)
-				? ((AbstractButton) c).getMargin()
-				: null;
-
-			if( margin == null || margin instanceof UIResource ) {
-				insets.top = top;
-				insets.left = left;
-				insets.bottom = bottom;
-				insets.right = right;
-			} else {
-				// margin explicitly set
-				insets.top = margin.top;
-				insets.left = margin.left;
-				insets.bottom = margin.bottom;
-				insets.right = margin.right;
-			}
-
-			// scale
-			insets.top = scale( insets.top );
-			insets.left = scale( insets.left );
-			insets.bottom = scale( insets.bottom );
-			insets.right = scale( insets.right );
-
-			return insets;
-		}
-	}
 }

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

@@ -21,11 +21,13 @@ import java.awt.FontMetrics;
 import java.awt.Graphics;
 import java.awt.Graphics2D;
 import java.awt.Insets;
+import java.beans.PropertyChangeListener;
 import java.util.List;
 import javax.swing.JComponent;
 import javax.swing.JToolTip;
 import javax.swing.SwingUtilities;
 import javax.swing.plaf.ComponentUI;
+import javax.swing.plaf.basic.BasicHTML;
 import javax.swing.plaf.basic.BasicToolTipUI;
 import com.formdev.flatlaf.util.StringUtils;
 
@@ -47,6 +49,8 @@ import com.formdev.flatlaf.util.StringUtils;
 public class FlatToolTipUI
 	extends BasicToolTipUI
 {
+	private static PropertyChangeListener sharedPropertyChangedListener;
+
 	private static ComponentUI instance;
 
 	public static ComponentUI createUI( JComponent c ) {
@@ -55,6 +59,38 @@ public class FlatToolTipUI
 		return instance;
 	}
 
+	@Override
+	public void installUI( JComponent c ) {
+		super.installUI( c );
+
+		// update HTML renderer if necessary
+		FlatLabelUI.updateHTMLRenderer( c, ((JToolTip)c).getTipText(), false );
+	}
+
+	@Override
+	protected void installListeners( JComponent c ) {
+		super.installListeners( c );
+
+		if( sharedPropertyChangedListener == null ) {
+			sharedPropertyChangedListener = e -> {
+				String name = e.getPropertyName();
+				if( name == "text" || name == "font" || name == "foreground" ) {
+					JToolTip toolTip = (JToolTip) e.getSource();
+					FlatLabelUI.updateHTMLRenderer( toolTip, toolTip.getTipText(), false );
+				}
+			};
+		}
+
+		c.addPropertyChangeListener( sharedPropertyChangedListener );
+	}
+
+	@Override
+	protected void uninstallListeners( JComponent c ) {
+		super.uninstallListeners( c );
+
+		c.removePropertyChangeListener( sharedPropertyChangedListener );
+	}
+
 	@Override
 	public Dimension getPreferredSize( JComponent c ) {
 		if( isMultiLine( c ) ) {
@@ -99,6 +135,6 @@ public class FlatToolTipUI
 
 	private boolean isMultiLine( JComponent c ) {
 		String text = ((JToolTip)c).getTipText();
-		return c.getClientProperty( "html" ) == null && text != null && text.indexOf( '\n' ) >= 0;
+		return c.getClientProperty( BasicHTML.propertyKey ) == null && text != null && text.indexOf( '\n' ) >= 0;
 	}
 }

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

@@ -221,7 +221,7 @@ public class FlatTreeUI
 		TreePath path, int row, boolean isExpanded, boolean hasBeenExpanded, boolean isLeaf )
 	{
 		boolean isEditing = (editingComponent != null && editingRow == row);
-		boolean hasFocus = tree.hasFocus();
+		boolean hasFocus = FlatUIUtils.isPermanentFocusOwner( tree );
 		boolean cellHasFocus = hasFocus && (row == getLeadSelectionRow());
 		boolean isSelected = tree.isRowSelected( row );
 		boolean isDropRow = isDropRow( row );
@@ -232,7 +232,7 @@ public class FlatTreeUI
 			g.setColor( isDropRow
 				? UIManager.getColor( "Tree.dropCellBackground" )
 				: (hasFocus ? selectionBackground : selectionInactiveBackground) );
-			g.fillRect( 0, bounds.y, clipBounds.width, bounds.height );
+			g.fillRect( 0, bounds.y, tree.getWidth(), bounds.height );
 
 			// paint expand/collapse icon
 			if( shouldPaintExpandControl( path, row, isExpanded, hasBeenExpanded, isLeaf ) ) {

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

@@ -20,9 +20,11 @@ import java.awt.Color;
 import java.awt.Component;
 import java.awt.Container;
 import java.awt.Dimension;
+import java.awt.Font;
 import java.awt.Graphics;
 import java.awt.Graphics2D;
 import java.awt.Insets;
+import java.awt.KeyboardFocusManager;
 import java.awt.Rectangle;
 import java.awt.RenderingHints;
 import java.awt.Shape;
@@ -37,8 +39,10 @@ import java.util.function.Consumer;
 import javax.swing.JComponent;
 import javax.swing.LookAndFeel;
 import javax.swing.UIManager;
-import javax.swing.plaf.ColorUIResource;
+import javax.swing.plaf.UIResource;
+import com.formdev.flatlaf.FlatClientProperties;
 import com.formdev.flatlaf.util.DerivedColor;
+import com.formdev.flatlaf.util.Graphics2DProxy;
 import com.formdev.flatlaf.util.HiDPIUtils;
 import com.formdev.flatlaf.util.JavaCompatibility;
 import com.formdev.flatlaf.util.UIScale;
@@ -82,6 +86,13 @@ public class FlatUIUtils
 			insets1.right + insets2.right );
 	}
 
+	public static void setInsets( Insets dest, Insets src ) {
+		dest.top = src.top;
+		dest.left = src.left;
+		dest.bottom = src.bottom;
+		dest.right = src.right;
+	}
+
 	public static Color getUIColor( String key, int defaultColorRGB ) {
 		Color color = UIManager.getColor( key );
 		return (color != null) ? color : new Color( defaultColorRGB );
@@ -108,13 +119,29 @@ public class FlatUIUtils
 	}
 
 	public static Color nonUIResource( Color c ) {
-		return (c instanceof ColorUIResource) ? new Color( c.getRGB(), true ) : c;
+		return (c instanceof UIResource) ? new Color( c.getRGB(), true ) : c;
+	}
+
+	public static Font nonUIResource( Font font ) {
+		return (font instanceof UIResource) ? font.deriveFont( font.getStyle() ) : font;
+	}
+
+	public static int minimumWidth( JComponent c, int minimumWidth ) {
+		return FlatClientProperties.clientPropertyInt( c, FlatClientProperties.MINIMUM_WIDTH, minimumWidth );
+	}
+
+	public static int minimumHeight( JComponent c, int minimumHeight ) {
+		return FlatClientProperties.clientPropertyInt( c, FlatClientProperties.MINIMUM_HEIGHT, minimumHeight );
 	}
 
 	public static boolean isTableCellEditor( Component c ) {
 		return c instanceof JComponent && Boolean.TRUE.equals( ((JComponent)c).getClientProperty( "JComboBox.isTableCellEditor" ) );
 	}
 
+	public static boolean isPermanentFocusOwner( Component c ) {
+		return (KeyboardFocusManager.getCurrentKeyboardFocusManager().getPermanentFocusOwner() == c);
+	}
+
 	/**
 	 * Sets rendering hints used for painting.
 	 */
@@ -146,7 +173,7 @@ public class FlatUIUtils
 		double systemScaleFactor = UIScale.getSystemScaleFactor( g );
 		if( systemScaleFactor != 1 && systemScaleFactor != 2 ) {
 			// paint at scale 1x to avoid clipping on right and bottom edges at 125%, 150% or 175%
-			HiDPIUtils.paintAtScale1x( g, x, y, width, height, systemScaleFactor,
+			HiDPIUtils.paintAtScale1x( g, x, y, width, height,
 				(g2d, x2, y2, width2, height2, scaleFactor) -> {
 					paintComponentOuterBorderImpl( g2d, x2, y2, width2, height2,
 						(float) (focusWidth * scaleFactor), (float) (lineWidth * scaleFactor), (float) (arc * scaleFactor) );
@@ -160,13 +187,22 @@ public class FlatUIUtils
 	private static void paintComponentOuterBorderImpl( Graphics2D g, int x, int y, int width, int height,
 		float focusWidth, float lineWidth, float arc )
 	{
-		float outerRadius = (arc > 0) ? arc + focusWidth - UIScale.scale( 2f ) : focusWidth;
 		float ow = focusWidth + lineWidth;
-		float innerRadius = outerRadius - ow;
+		float outerArc = arc + (focusWidth * 2);
+		float innerArc = arc - (lineWidth * 2);
+
+		// reduce outer arc slightly for small arcs to make the curve slightly wider
+		if( arc > 0 && arc < UIScale.scale( 10 ) )
+			outerArc -= UIScale.scale( 2f );
+
+		if( outerArc < 0 )
+			outerArc = 0;
+		if( innerArc < 0 )
+			innerArc = 0;
 
 		Path2D path = new Path2D.Float( Path2D.WIND_EVEN_ODD );
-		path.append( createRoundRectanglePath( x, y, width, height, outerRadius, outerRadius, outerRadius, outerRadius ), false );
-		path.append( createRoundRectanglePath( x + ow, y + ow, width - (ow * 2), height - (ow * 2), innerRadius, innerRadius, innerRadius, innerRadius ), false );
+		path.append( new RoundRectangle2D.Float( x, y, width, height, outerArc, outerArc ), false );
+		path.append( new RoundRectangle2D.Float( x + ow, y + ow, width - (ow * 2), height - (ow * 2), innerArc, innerArc ), false );
 		g.fill( path );
 	}
 
@@ -186,7 +222,7 @@ public class FlatUIUtils
 		double systemScaleFactor = UIScale.getSystemScaleFactor( g );
 		if( systemScaleFactor != 1 && systemScaleFactor != 2 ) {
 			// paint at scale 1x to avoid clipping on right and bottom edges at 125%, 150% or 175%
-			HiDPIUtils.paintAtScale1x( g, x, y, width, height, systemScaleFactor,
+			HiDPIUtils.paintAtScale1x( g, x, y, width, height,
 				(g2d, x2, y2, width2, height2, scaleFactor) -> {
 					paintComponentBorderImpl( g2d, x2, y2, width2, height2,
 						(float) (focusWidth * scaleFactor), (float) (lineWidth * scaleFactor), (float) (arc * scaleFactor) );
@@ -200,7 +236,12 @@ public class FlatUIUtils
 	private static void paintComponentBorderImpl( Graphics2D g, int x, int y, int width, int height,
 		float focusWidth, float lineWidth, float arc )
 	{
-		float arc2 = arc > lineWidth ? arc - lineWidth : 0f;
+		float arc2 = arc - (lineWidth * 2);
+
+		if( arc < 0 )
+			arc = 0;
+		if( arc2 < 0 )
+			arc2 = 0;
 
 		RoundRectangle2D.Float r1 = new RoundRectangle2D.Float(
 			x + focusWidth, y + focusWidth,
@@ -231,7 +272,7 @@ public class FlatUIUtils
 		double systemScaleFactor = UIScale.getSystemScaleFactor( g );
 		if( systemScaleFactor != 1 && systemScaleFactor != 2 ) {
 			// paint at scale 1x to avoid clipping on right and bottom edges at 125%, 150% or 175%
-			HiDPIUtils.paintAtScale1x( g, x, y, width, height, systemScaleFactor,
+			HiDPIUtils.paintAtScale1x( g, x, y, width, height,
 				(g2d, x2, y2, width2, height2, scaleFactor) -> {
 					paintComponentBackgroundImpl( g2d, x2, y2, width2, height2,
 						(float) (focusWidth * scaleFactor), (float) (arc * scaleFactor) );
@@ -245,6 +286,9 @@ public class FlatUIUtils
 	private static void paintComponentBackgroundImpl( Graphics2D g, int x, int y, int width, int height,
 		float focusWidth, float arc )
 	{
+		if( arc < 0 )
+			arc = 0;
+
 		g.fill( new RoundRectangle2D.Float(
 			x + focusWidth, y + focusWidth,
 			width - focusWidth * 2, height - focusWidth * 2, arc, arc ) );
@@ -384,6 +428,23 @@ public class FlatUIUtils
 	public static void drawStringUnderlineCharAt( JComponent c, Graphics g,
 		String text, int underlinedIndex, int x, int y )
 	{
+		// scale underline height if necessary
+		if( underlinedIndex >= 0 && UIScale.getUserScaleFactor() > 1 ) {
+			g = new Graphics2DProxy( (Graphics2D) g ) {
+				@Override
+				public void fillRect( int x, int y, int width, int height ) {
+					if( height == 1 ) {
+						// scale height and correct y position
+						// (using 0.9f so that underline height is 1 at scale factor 1.5x)
+						height = Math.round( UIScale.scale( 0.9f ) );
+						y += height - 1;
+					}
+
+					super.fillRect( x, y, width, height );
+				}
+			};
+		}
+
 		JavaCompatibility.drawStringUnderlineCharAt( c, g, text, underlinedIndex, x, y );
 	}
 

flatlaf-core/src/main/java/com/formdev/flatlaf/util/DerivedColor.java

@@ -32,8 +32,8 @@ public class DerivedColor
 {
 	private final ColorFunction[] functions;
 
-	public DerivedColor( ColorFunction... functions ) {
-		super( Color.red );
+	public DerivedColor( Color defaultColor, ColorFunction... functions ) {
+		super( (defaultColor != null) ? defaultColor : Color.red );
 		this.functions = functions;
 	}
 

flatlaf-core/src/main/java/com/formdev/flatlaf/util/Graphics2DProxy.java

@@ -0,0 +1,479 @@
+/*
+ * 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.util;
+
+import java.awt.Color;
+import java.awt.Composite;
+import java.awt.Font;
+import java.awt.FontMetrics;
+import java.awt.Graphics;
+import java.awt.Graphics2D;
+import java.awt.GraphicsConfiguration;
+import java.awt.Image;
+import java.awt.Paint;
+import java.awt.Polygon;
+import java.awt.Rectangle;
+import java.awt.RenderingHints;
+import java.awt.RenderingHints.Key;
+import java.awt.Shape;
+import java.awt.Stroke;
+import java.awt.font.FontRenderContext;
+import java.awt.font.GlyphVector;
+import java.awt.geom.AffineTransform;
+import java.awt.image.BufferedImage;
+import java.awt.image.BufferedImageOp;
+import java.awt.image.ImageObserver;
+import java.awt.image.RenderedImage;
+import java.awt.image.renderable.RenderableImage;
+import java.text.AttributedCharacterIterator;
+import java.util.Map;
+
+/**
+ * A proxy for {@link Graphics2D}.
+ *
+ * @author Karl Tauber
+ */
+public class Graphics2DProxy
+	extends Graphics2D
+{
+	private final Graphics2D delegate;
+
+	public Graphics2DProxy( Graphics2D delegate ) {
+		this.delegate = delegate;
+	}
+
+	@Override
+	public Graphics create() {
+		return delegate.create();
+	}
+
+	@Override
+	public Graphics create( int x, int y, int width, int height ) {
+		return delegate.create( x, y, width, height );
+	}
+
+	@Override
+	public Color getColor() {
+		return delegate.getColor();
+	}
+
+	@Override
+	public void setColor( Color c ) {
+		delegate.setColor( c );
+	}
+
+	@Override
+	public void setPaintMode() {
+		delegate.setPaintMode();
+	}
+
+	@Override
+	public void setXORMode( Color c1 ) {
+		delegate.setXORMode( c1 );
+	}
+
+	@Override
+	public Font getFont() {
+		return delegate.getFont();
+	}
+
+	@Override
+	public void setFont( Font font ) {
+		delegate.setFont( font );
+	}
+
+	@Override
+	public FontMetrics getFontMetrics() {
+		return delegate.getFontMetrics();
+	}
+
+	@Override
+	public FontMetrics getFontMetrics( Font f ) {
+		return delegate.getFontMetrics( f );
+	}
+
+	@Override
+	public Rectangle getClipBounds() {
+		return delegate.getClipBounds();
+	}
+
+	@Override
+	public void clipRect( int x, int y, int width, int height ) {
+		delegate.clipRect( x, y, width, height );
+	}
+
+	@Override
+	public void setClip( int x, int y, int width, int height ) {
+		delegate.setClip( x, y, width, height );
+	}
+
+	@Override
+	public Shape getClip() {
+		return delegate.getClip();
+	}
+
+	@Override
+	public void setClip( Shape clip ) {
+		delegate.setClip( clip );
+	}
+
+	@Override
+	public void copyArea( int x, int y, int width, int height, int dx, int dy ) {
+		delegate.copyArea( x, y, width, height, dx, dy );
+	}
+
+	@Override
+	public void drawLine( int x1, int y1, int x2, int y2 ) {
+		delegate.drawLine( x1, y1, x2, y2 );
+	}
+
+	@Override
+	public void fillRect( int x, int y, int width, int height ) {
+		delegate.fillRect( x, y, width, height );
+	}
+
+	@Override
+	public void drawRect( int x, int y, int width, int height ) {
+		delegate.drawRect( x, y, width, height );
+	}
+
+	@Override
+	public void clearRect( int x, int y, int width, int height ) {
+		delegate.clearRect( x, y, width, height );
+	}
+
+	@Override
+	public void drawRoundRect( int x, int y, int width, int height, int arcWidth, int arcHeight ) {
+		delegate.drawRoundRect( x, y, width, height, arcWidth, arcHeight );
+	}
+
+	@Override
+	public void fillRoundRect( int x, int y, int width, int height, int arcWidth, int arcHeight ) {
+		delegate.fillRoundRect( x, y, width, height, arcWidth, arcHeight );
+	}
+
+	@Override
+	public void drawOval( int x, int y, int width, int height ) {
+		delegate.drawOval( x, y, width, height );
+	}
+
+	@Override
+	public void fillOval( int x, int y, int width, int height ) {
+		delegate.fillOval( x, y, width, height );
+	}
+
+	@Override
+	public void drawArc( int x, int y, int width, int height, int startAngle, int arcAngle ) {
+		delegate.drawArc( x, y, width, height, startAngle, arcAngle );
+	}
+
+	@Override
+	public void fillArc( int x, int y, int width, int height, int startAngle, int arcAngle ) {
+		delegate.fillArc( x, y, width, height, startAngle, arcAngle );
+	}
+
+	@Override
+	public void drawPolyline( int[] xPoints, int[] yPoints, int nPoints ) {
+		delegate.drawPolyline( xPoints, yPoints, nPoints );
+	}
+
+	@Override
+	public void drawPolygon( int[] xPoints, int[] yPoints, int nPoints ) {
+		delegate.drawPolygon( xPoints, yPoints, nPoints );
+	}
+
+	@Override
+	public void drawPolygon( Polygon p ) {
+		delegate.drawPolygon( p );
+	}
+
+	@Override
+	public void fillPolygon( int[] xPoints, int[] yPoints, int nPoints ) {
+		delegate.fillPolygon( xPoints, yPoints, nPoints );
+	}
+
+	@Override
+	public void fillPolygon( Polygon p ) {
+		delegate.fillPolygon( p );
+	}
+
+	@Override
+	public void drawChars( char[] data, int offset, int length, int x, int y ) {
+		delegate.drawChars( data, offset, length, x, y );
+	}
+
+	@Override
+	public void drawBytes( byte[] data, int offset, int length, int x, int y ) {
+		delegate.drawBytes( data, offset, length, x, y );
+	}
+
+	@Override
+	public boolean drawImage( Image img, int x, int y, ImageObserver observer ) {
+		return delegate.drawImage( img, x, y, observer );
+	}
+
+	@Override
+	public boolean drawImage( Image img, int x, int y, int width, int height, ImageObserver observer ) {
+		return delegate.drawImage( img, x, y, width, height, observer );
+	}
+
+	@Override
+	public boolean drawImage( Image img, int x, int y, Color bgcolor, ImageObserver observer ) {
+		return delegate.drawImage( img, x, y, bgcolor, observer );
+	}
+
+	@Override
+	public boolean drawImage( Image img, int x, int y, int width, int height, Color bgcolor, ImageObserver observer ) {
+		return delegate.drawImage( img, x, y, width, height, bgcolor, observer );
+	}
+
+	@Override
+	public boolean drawImage( Image img, int dx1, int dy1, int dx2, int dy2, int sx1, int sy1, int sx2, int sy2, ImageObserver observer ) {
+		return delegate.drawImage( img, dx1, dy1, dx2, dy2, sx1, sy1, sx2, sy2, observer );
+	}
+
+	@Override
+	public boolean drawImage( Image img, int dx1, int dy1, int dx2, int dy2, int sx1, int sy1, int sx2, int sy2, Color bgcolor, ImageObserver observer ) {
+		return delegate.drawImage( img, dx1, dy1, dx2, dy2, sx1, sy1, sx2, sy2, bgcolor, observer );
+	}
+
+	@Override
+	public void dispose() {
+		delegate.dispose();
+	}
+
+	@Override
+	public void finalize() {
+		delegate.finalize();
+	}
+
+	@Override
+	public String toString() {
+		return delegate.toString();
+	}
+
+	@SuppressWarnings( "deprecation" )
+	@Override
+	public Rectangle getClipRect() {
+		return delegate.getClipRect();
+	}
+
+	@Override
+	public boolean hitClip( int x, int y, int width, int height ) {
+		return delegate.hitClip( x, y, width, height );
+	}
+
+	@Override
+	public Rectangle getClipBounds( Rectangle r ) {
+		return delegate.getClipBounds( r );
+	}
+
+	@Override
+	public void draw3DRect( int x, int y, int width, int height, boolean raised ) {
+		delegate.draw3DRect( x, y, width, height, raised );
+	}
+
+	@Override
+	public void fill3DRect( int x, int y, int width, int height, boolean raised ) {
+		delegate.fill3DRect( x, y, width, height, raised );
+	}
+
+	@Override
+	public void draw( Shape s ) {
+		delegate.draw( s );
+	}
+
+	@Override
+	public boolean drawImage( Image img, AffineTransform xform, ImageObserver obs ) {
+		return delegate.drawImage( img, xform, obs );
+	}
+
+	@Override
+	public void drawImage( BufferedImage img, BufferedImageOp op, int x, int y ) {
+		delegate.drawImage( img, op, x, y );
+	}
+
+	@Override
+	public void drawRenderedImage( RenderedImage img, AffineTransform xform ) {
+		delegate.drawRenderedImage( img, xform );
+	}
+
+	@Override
+	public void drawRenderableImage( RenderableImage img, AffineTransform xform ) {
+		delegate.drawRenderableImage( img, xform );
+	}
+
+	@Override
+	public void drawString( String str, int x, int y ) {
+		delegate.drawString( str, x, y );
+	}
+
+	@Override
+	public void drawString( String str, float x, float y ) {
+		delegate.drawString( str, x, y );
+	}
+
+	@Override
+	public void drawString( AttributedCharacterIterator iterator, int x, int y ) {
+		delegate.drawString( iterator, x, y );
+	}
+
+	@Override
+	public void drawString( AttributedCharacterIterator iterator, float x, float y ) {
+		delegate.drawString( iterator, x, y );
+	}
+
+	@Override
+	public void drawGlyphVector( GlyphVector g, float x, float y ) {
+		delegate.drawGlyphVector( g, x, y );
+	}
+
+	@Override
+	public void fill( Shape s ) {
+		delegate.fill( s );
+	}
+
+	@Override
+	public boolean hit( Rectangle rect, Shape s, boolean onStroke ) {
+		return delegate.hit( rect, s, onStroke );
+	}
+
+	@Override
+	public GraphicsConfiguration getDeviceConfiguration() {
+		return delegate.getDeviceConfiguration();
+	}
+
+	@Override
+	public void setComposite( Composite comp ) {
+		delegate.setComposite( comp );
+	}
+
+	@Override
+	public void setPaint( Paint paint ) {
+		delegate.setPaint( paint );
+	}
+
+	@Override
+	public void setStroke( Stroke s ) {
+		delegate.setStroke( s );
+	}
+
+	@Override
+	public void setRenderingHint( Key hintKey, Object hintValue ) {
+		delegate.setRenderingHint( hintKey, hintValue );
+	}
+
+	@Override
+	public Object getRenderingHint( Key hintKey ) {
+		return delegate.getRenderingHint( hintKey );
+	}
+
+	@Override
+	public void setRenderingHints( Map<?, ?> hints ) {
+		delegate.setRenderingHints( hints );
+	}
+
+	@Override
+	public void addRenderingHints( Map<?, ?> hints ) {
+		delegate.addRenderingHints( hints );
+	}
+
+	@Override
+	public RenderingHints getRenderingHints() {
+		return delegate.getRenderingHints();
+	}
+
+	@Override
+	public void translate( int x, int y ) {
+		delegate.translate( x, y );
+	}
+
+	@Override
+	public void translate( double tx, double ty ) {
+		delegate.translate( tx, ty );
+	}
+
+	@Override
+	public void rotate( double theta ) {
+		delegate.rotate( theta );
+	}
+
+	@Override
+	public void rotate( double theta, double x, double y ) {
+		delegate.rotate( theta, x, y );
+	}
+
+	@Override
+	public void scale( double sx, double sy ) {
+		delegate.scale( sx, sy );
+	}
+
+	@Override
+	public void shear( double shx, double shy ) {
+		delegate.shear( shx, shy );
+	}
+
+	@Override
+	public void transform( AffineTransform Tx ) {
+		delegate.transform( Tx );
+	}
+
+	@Override
+	public void setTransform( AffineTransform Tx ) {
+		delegate.setTransform( Tx );
+	}
+
+	@Override
+	public AffineTransform getTransform() {
+		return delegate.getTransform();
+	}
+
+	@Override
+	public Paint getPaint() {
+		return delegate.getPaint();
+	}
+
+	@Override
+	public Composite getComposite() {
+		return delegate.getComposite();
+	}
+
+	@Override
+	public void setBackground( Color color ) {
+		delegate.setBackground( color );
+	}
+
+	@Override
+	public Color getBackground() {
+		return delegate.getBackground();
+	}
+
+	@Override
+	public Stroke getStroke() {
+		return delegate.getStroke();
+	}
+
+	@Override
+	public void clip( Shape s ) {
+		delegate.clip( s );
+	}
+
+	@Override
+	public FontRenderContext getFontRenderContext() {
+		return delegate.getFontRenderContext();
+	}
+}

flatlaf-core/src/main/java/com/formdev/flatlaf/util/GrayFilter.java

@@ -0,0 +1,87 @@
+// Copyright 2000-2020 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
+package com.formdev.flatlaf.util;
+
+import java.awt.image.RGBImageFilter;
+
+// based on https://github.com/JetBrains/intellij-community/blob/3840eab54746f5c4f301bb3ac78f00a980b5fd6e/platform/util/ui/src/com/intellij/util/ui/UIUtil.java#L253-L347
+
+/**
+ * An image filter that turns an image into a grayscale image.
+ * Used for icons in disabled buttons and labels.
+ */
+public class GrayFilter
+	extends RGBImageFilter
+{
+	private final float brightness;
+	private final float contrast;
+	private final int alpha;
+
+	private final int origContrast;
+	private final int origBrightness;
+
+	public static GrayFilter createDisabledIconFilter( boolean dark ) {
+		return dark
+			? new GrayFilter( -20, -70, 100 )
+			: new GrayFilter(  25, -25, 100 );
+	}
+
+	/**
+	 * @param brightness in range [-100..100] where 0 has no effect
+	 * @param contrast in range [-100..100] where 0 has no effect
+	 * @param alpha in range [0..100] where 0 is transparent, 100 has no effect
+	 */
+	public GrayFilter( int brightness, int contrast, int alpha ) {
+		this.origBrightness = Math.max( -100, Math.min( 100, brightness ) );
+		this.origContrast = Math.max( -100, Math.min( 100, contrast ) );
+		this.alpha = Math.max( 0, Math.min( 100, alpha ) );
+
+		this.brightness = (float) (Math.pow( origBrightness, 3 ) / (100f * 100f)); // cubic in [0..100]
+		this.contrast = origContrast / 100f;
+
+		canFilterIndexColorModel = true;
+	}
+
+	public GrayFilter() {
+		this( 0, 0, 100 );
+	}
+
+	public int getBrightness() {
+		return origBrightness;
+	}
+
+	public int getContrast() {
+		return origContrast;
+	}
+
+	public int getAlpha() {
+		return alpha;
+	}
+
+	@Override
+	public int filterRGB( int x, int y, int rgb ) {
+		// use NTSC conversion formula
+		int gray = (int)(
+			0.30 * (rgb >> 16 & 0xff) +
+			0.59 * (rgb >> 8 & 0xff) +
+			0.11 * (rgb & 0xff));
+
+		if( brightness >= 0 )
+			gray = (int) ((gray + brightness * 255) / (1 + brightness));
+		else
+			gray = (int) (gray / (1 - brightness));
+
+		if( contrast >= 0 ) {
+			if( gray >= 127 )
+				gray = (int) (gray + (255 - gray) * contrast);
+			else
+				gray = (int) (gray - gray * contrast);
+		} else
+			gray = (int) (127 + (gray - 127) * (contrast + 1));
+
+		int a = (alpha != 100)
+			? (((rgb >> 24) & 0xff) * alpha / 100) << 24
+			: (rgb & 0xff000000);
+
+		return a | (gray << 16) | (gray << 8) | gray;
+	}
+}

flatlaf-core/src/main/java/com/formdev/flatlaf/util/HiDPIUtils.java

@@ -34,10 +34,6 @@ public class HiDPIUtils
 		paintAtScale1x( g, 0, 0, c.getWidth(), c.getHeight(), painter );
 	}
 
-	public static void paintAtScale1x( Graphics2D g, int x, int y, int width, int height, Painter painter ) {
-		paintAtScale1x( g, x, y, width, height, UIScale.getSystemScaleFactor( g ), painter );
-	}
-
 	/**
 	 * Paint at system scale factor 1x to avoid rounding issues at 125%, 150% and 175% scaling.
 	 * <p>
@@ -46,38 +42,29 @@ public class HiDPIUtils
 	 * <p>
 	 * Uses the same scaling calculation as the JRE uses.
 	 */
-	public static void paintAtScale1x( Graphics2D g, int x, int y, int width, int height,
-		double scaleFactor, Painter painter )
-	{
-		if( scaleFactor == 1 ) {
+	public static void paintAtScale1x( Graphics2D g, int x, int y, int width, int height, Painter painter ) {
+		// save original transform
+		AffineTransform transform = g.getTransform();
+
+		// check whether scaled
+		if( transform.getScaleX() == 1 && transform.getScaleY() == 1 ) {
 			painter.paint( g, x, y, width, height, 1 );
 			return;
 		}
 
-		// save original transform
-		AffineTransform transform = g.getTransform();
-
 		// scale rectangle
 		Rectangle2D.Double scaledRect = scale( transform, x, y, width, height );
 
 		try {
-			// unscale to factor 1.0
-			double scale = 1.0 / scaleFactor;
-			g.scale( scale, scale );
-
-			// compute origin delta x/y
-			double dx = Math.floor( scaledRect.x ) - transform.getTranslateX();
-			double dy = Math.floor( scaledRect.y ) - transform.getTranslateY();
-
-			// move origin to make sure that origin x/y are at whole numbers
-			if( dx != 0 || dy != 0 )
-				g.translate( dx, dy );
+			// unscale to factor 1.0 and move origin (to whole numbers)
+			g.setTransform( new AffineTransform( 1, 0, 0, 1,
+				Math.floor( scaledRect.x ), Math.floor( scaledRect.y ) ) );
 
 			int swidth = (int) scaledRect.width;
 			int sheight = (int) scaledRect.height;
 
 			// paint
-			painter.paint( g, 0, 0, swidth, sheight, scaleFactor );
+			painter.paint( g, 0, 0, swidth, sheight, transform.getScaleX() );
 		} finally {
 			// restore original transform
 			g.setTransform( transform );

flatlaf-core/src/main/java/com/formdev/flatlaf/util/MultiResolutionImageSupport.java

@@ -0,0 +1,44 @@
+/*
+ * 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.util;
+
+import java.awt.Image;
+import java.util.function.Function;
+
+/**
+ * Support for multi-resolution images available since Java 9.
+ *
+ * @author Karl Tauber
+ */
+public class MultiResolutionImageSupport
+{
+	public static boolean isAvailable() {
+		return false;
+	}
+
+	public static boolean isMultiResolutionImage( Image image ) {
+		return false;
+	}
+
+	public static Image create( int baseImageIndex, Image... resolutionVariants ) {
+		return resolutionVariants[baseImageIndex];
+	}
+
+	public static Image map( Image image, Function<Image, Image> mapper ) {
+		return mapper.apply( image );
+	}
+}

flatlaf-core/src/main/java/com/formdev/flatlaf/util/UIScale.java

@@ -24,6 +24,7 @@ import java.awt.GraphicsEnvironment;
 import java.awt.Insets;
 import java.beans.PropertyChangeEvent;
 import java.beans.PropertyChangeListener;
+import java.beans.PropertyChangeSupport;
 import java.lang.reflect.Method;
 import javax.swing.LookAndFeel;
 import javax.swing.UIManager;
@@ -48,12 +49,15 @@ import javax.swing.plaf.UIResource;
  *
  * 2) user scaling mode
  *
- * This mode is mainly for Java 8 compatibility, but is also used on Linux.
+ * This mode is mainly for Java 8 compatibility, but is also used on Linux
+ * or if the default font is changed.
  * The user scale factor is computed based on the used font.
  * The JRE does not scale anything.
  * So we have to invoke {@link #scale(float)} where necessary.
  * There is only one user scale factor for all displays.
- * The user scale factor may change if the active LaF or "Label.font" has changed.
+ * The user scale factor may change if the active LaF, "defaultFont" or "Label.font" has changed.
+ * If system scaling mode is available the user scale factor is usually 1,
+ * but may be larger on Linux or if the default font is changed.
  *
  * @author Karl Tauber
  */
@@ -61,6 +65,20 @@ public class UIScale
 {
 	private static final boolean DEBUG = false;
 
+	private static PropertyChangeSupport changeSupport;
+
+	public static void addPropertyChangeListener( PropertyChangeListener listener ) {
+		if( changeSupport == null )
+			changeSupport = new PropertyChangeSupport( UIScale.class );
+		changeSupport.addPropertyChangeListener( listener );
+	}
+
+	public static void removePropertyChangeListener( PropertyChangeListener listener ) {
+		if( changeSupport == null )
+			return;
+		changeSupport.removePropertyChangeListener( listener );
+	}
+
 	//---- system scaling (Java 9) --------------------------------------------
 
 	private static Boolean jreHiDPI;
@@ -97,7 +115,7 @@ public class UIScale
 	}
 
 	public static double getSystemScaleFactor( GraphicsConfiguration gc ) {
-		return isSystemScalingEnabled() ? gc.getDefaultTransform().getScaleX() : 1;
+		return (isSystemScalingEnabled() && gc != null) ? gc.getDefaultTransform().getScaleX() : 1;
 	}
 
 	//---- user scaling (Java 8) ----------------------------------------------
@@ -110,27 +128,33 @@ public class UIScale
 			return;
 		initialized = true;
 
-		if( isUserScalingEnabled() ) {
-			// listener to update scale factor if LaF changed or if Label.font changed
-			// (e.g. option "Override default fonts" in IntelliJ IDEA)
-			PropertyChangeListener listener = new PropertyChangeListener() {
-				@Override
-				public void propertyChange( PropertyChangeEvent e ) {
-					String propName = e.getPropertyName();
-					if( "lookAndFeel".equals( propName ) ) {
+		if( !isUserScalingEnabled() )
+			return;
+
+		// listener to update scale factor if LaF changed, "defaultFont" or "Label.font" changed
+		PropertyChangeListener listener = new PropertyChangeListener() {
+			@Override
+			public void propertyChange( PropertyChangeEvent e ) {
+				switch( e.getPropertyName() ) {
+					case "lookAndFeel":
 						// it is not necessary (and possible) to remove listener of old LaF defaults
 						if( e.getNewValue() instanceof LookAndFeel )
 							UIManager.getLookAndFeelDefaults().addPropertyChangeListener( this );
 						updateScaleFactor();
-					} else if( "Label.font".equals( propName ) )
-						updateScaleFactor();
-				}
-			};
-			UIManager.addPropertyChangeListener( listener );
-			UIManager.getLookAndFeelDefaults().addPropertyChangeListener( listener );
+						break;
 
-			updateScaleFactor();
-		}
+					case "defaultFont":
+					case "Label.font":
+						updateScaleFactor();
+						break;
+				}
+			}
+		};
+		UIManager.addPropertyChangeListener( listener );
+		UIManager.getDefaults().addPropertyChangeListener( listener );
+		UIManager.getLookAndFeelDefaults().addPropertyChangeListener( listener );
+
+		updateScaleFactor();
 	}
 
 	private static void updateScaleFactor() {
@@ -141,7 +165,9 @@ public class UIScale
 		// because even if we are on a HiDPI display it is not sure
 		// that a larger font size is set by the current LaF
 		// (e.g. can avoid large icons with small text)
-		Font font = UIManager.getFont( "Label.font" );
+		Font font = UIManager.getFont( "defaultFont" );
+		if( font == null )
+			font = UIManager.getFont( "Label.font" );
 
 		setUserScaleFactor( computeScaleFactor( font ) );
 	}
@@ -156,6 +182,9 @@ public class UIScale
 			// Tahoma 11 is used at 100%
 			if( "Tahoma".equals( font.getFamily() ) )
 				fontSizeDivider = 11f;
+		} else if( SystemInfo.IS_MAC ) {
+			// default font size on macOS is 13
+			fontSizeDivider = 13f;
 		} else if( SystemInfo.IS_LINUX ) {
 			// default font size for Unity and Gnome is 15 and for KDE it is 13
 			fontSizeDivider = SystemInfo.IS_KDE ? 13f : 15f;
@@ -165,26 +194,17 @@ public class UIScale
 	}
 
 	private static boolean isUserScalingEnabled() {
-		if( isSystemScalingEnabled() && !SystemInfo.IS_LINUX )
-			return false; // disable user scaling if JRE scales
-
 		// same as in IntelliJ IDEA
 		String hidpi = System.getProperty( "hidpi" );
 		return (hidpi != null) ? Boolean.parseBoolean( hidpi ) : true;
 	}
 
 	/**
-	 * Applies a custom scale factor given in system properties "flatlaf.uiScale"
-	 * or "sun.java2d.uiScale" to the given font.
+	 * Applies a custom scale factor given in system property "flatlaf.uiScale"
+	 * to the given font.
 	 */
 	public static FontUIResource applyCustomScaleFactor( FontUIResource font ) {
-		if( UIScale.isSystemScalingEnabled() )
-			return font;
-
 		String uiScale = System.getProperty( "flatlaf.uiScale" );
-		if( uiScale == null )
-			uiScale = System.getProperty( "sun.java2d.uiScale" );
-
 		float scaleFactor = parseScaleFactor( uiScale );
 		if( scaleFactor <= 0 )
 			return font;
@@ -194,15 +214,7 @@ public class UIScale
 			return font;
 
 		int newFontSize = Math.round( (font.getSize() / fontScaleFactor) * scaleFactor );
-		return new FontUIResource( font.getFamily(), font.getStyle(), newFontSize );
-	}
-
-	/**
-	 * Scales the given font.
-	 */
-	public static FontUIResource scaleFont( FontUIResource font, float scaleFactor ) {
-		int newFontSize = Math.round( font.getSize() * scaleFactor );
-		return new FontUIResource( font.getFamily(), font.getStyle(), newFontSize );
+		return new FontUIResource( font.deriveFont( (float) newFontSize ) );
 	}
 
 	/**
@@ -242,10 +254,14 @@ public class UIScale
 		else // round scale factor to 1/4
 			scaleFactor = Math.round( scaleFactor * 4f ) / 4f;
 
+		float oldScaleFactor = UIScale.scaleFactor;
 		UIScale.scaleFactor = scaleFactor;
 
 		if( DEBUG )
 			System.out.println( "HiDPI scale factor " + scaleFactor );
+
+		if( changeSupport != null )
+			changeSupport.firePropertyChange( "userScaleFactor", oldScaleFactor, scaleFactor );
 	}
 
 	public static float scale( float value ) {

flatlaf-core/src/main/java9/com/formdev/flatlaf/util/MultiResolutionImageSupport.java

@@ -0,0 +1,96 @@
+/*
+ * 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.util;
+
+import java.awt.Image;
+import java.awt.image.AbstractMultiResolutionImage;
+import java.awt.image.BaseMultiResolutionImage;
+import java.awt.image.MultiResolutionImage;
+import java.util.ArrayList;
+import java.util.IdentityHashMap;
+import java.util.List;
+import java.util.function.Function;
+import javax.swing.ImageIcon;
+
+/**
+ * Support for multi-resolution images available since Java 9.
+ *
+ * @author Karl Tauber
+ */
+public class MultiResolutionImageSupport
+{
+	public static boolean isAvailable() {
+		return true;
+	}
+
+	public static boolean isMultiResolutionImage( Image image ) {
+		return image instanceof MultiResolutionImage;
+	}
+
+	public static Image create( int baseImageIndex, Image... resolutionVariants ) {
+		return new BaseMultiResolutionImage( baseImageIndex, resolutionVariants );
+	}
+
+	public static Image map( Image image, Function<Image, Image> mapper ) {
+		return image instanceof MultiResolutionImage
+			? new MappedMultiResolutionImage( image, mapper )
+			: mapper.apply( image );
+	}
+
+	//---- class MappedMultiResolutionImage -----------------------------------
+
+	private static class MappedMultiResolutionImage
+		extends AbstractMultiResolutionImage
+	{
+		private final Image mrImage;
+		private final Function<Image, Image> mapper;
+		private final IdentityHashMap<Image, Image> cache = new IdentityHashMap<>();
+
+		MappedMultiResolutionImage( Image mrImage, Function<Image, Image> mapper ) {
+			assert mrImage instanceof MultiResolutionImage;
+
+			this.mrImage = mrImage;
+			this.mapper = mapper;
+		}
+
+		@Override
+		public Image getResolutionVariant( double destImageWidth, double destImageHeight ) {
+			Image variant = ((MultiResolutionImage)mrImage).getResolutionVariant( destImageWidth, destImageHeight );
+			return mapAndCacheImage( variant );
+		}
+
+		@Override
+		public List<Image> getResolutionVariants() {
+			List<Image> variants = ((MultiResolutionImage)mrImage).getResolutionVariants();
+			List<Image> mappedVariants = new ArrayList<>();
+			for( Image image : variants )
+				mappedVariants.add( mapAndCacheImage( image ) );
+			return mappedVariants;
+		}
+
+		@Override
+		protected Image getBaseImage() {
+			return mapAndCacheImage( mrImage );
+		}
+
+		private Image mapAndCacheImage( Image image ) {
+			return cache.computeIfAbsent( image, img -> {
+				return new ImageIcon( mapper.apply( img ) ).getImage();
+			} );
+		}
+	}
+}

flatlaf-core/src/main/resources/com/formdev/flatlaf/FlatDarculaLaf.properties

@@ -30,6 +30,12 @@ Component.innerFocusWidth=0
 Component.arrowType=triangle
 
 
+#---- ProgressBar ----
+
+ProgressBar.foreground=#a0a0a0
+ProgressBar.selectionForeground=@background
+
+
 #---- RadioButton ----
 
 RadioButton.icon.centerDiameter=5

flatlaf-core/src/main/resources/com/formdev/flatlaf/FlatDarkLaf.properties

@@ -28,13 +28,13 @@
 @selectionInactiveForeground=@foreground
 @disabledText=#777777
 @textComponentBackground=#45494A
+@menuBackground=darken(@background,5%)
+@menuHoverBackground=lighten(@menuBackground,10%)
+@menuCheckBackground=lighten(@menuBackground,10%)
+@menuCheckHoverBackground=lighten(@menuBackground,20%)
 @cellFocusColor=#000000
 @icon=#adadad
 
-# Button
-@buttonHoverBackground=lighten(3%,autoInverse)
-@buttonPressedBackground=lighten(6%,autoInverse)
-
 # Drop (use lazy colors for IntelliJ platform themes, which usually do not specify these colors)
 @dropCellBackground=darken(List.selectionBackground,10%,lazy)
 @dropCellForeground=lazy(List.selectionForeground)
@@ -56,7 +56,7 @@
 *.disabledBackground=@background
 *.disabledForeground=@disabledText
 *.disabledText=@disabledText
-*.acceleratorForeground=#bbbbbb
+*.acceleratorForeground=darken(@foreground,15%)
 *.acceleratorSelectionForeground=@selectionForeground
 
 
@@ -64,17 +64,16 @@
 
 activeCaption=#434E60
 inactiveCaption=#393C3D
-controlHighlight=#616669
-controlLtHighlight=#303234
-controlShadow=#afb3b5
-controlDkShadow=#d7d9da
+controlHighlight=darken($controlShadow,20%)
+controlLtHighlight=darken($controlShadow,25%)
+controlDkShadow=lighten($controlShadow,10%)
 
 
 #---- Button ----
 
 Button.background=#4c5052
-Button.hoverBackground=@buttonHoverBackground
-Button.pressedBackground=@buttonPressedBackground
+Button.hoverBackground=lighten($Button.background,3%,derived autoInverse)
+Button.pressedBackground=lighten($Button.background,6%,derived autoInverse)
 
 Button.borderColor=#5e6060
 Button.disabledBorderColor=#5e6060
@@ -83,16 +82,16 @@ Button.hoverBorderColor=$Button.focusedBorderColor
 
 Button.default.background=#365880
 Button.default.foreground=#bbbbbb
-Button.default.hoverBackground=@buttonHoverBackground
-Button.default.pressedBackground=@buttonPressedBackground
+Button.default.hoverBackground=lighten($Button.default.background,3%,derived autoInverse)
+Button.default.pressedBackground=lighten($Button.default.background,6%,derived autoInverse)
 Button.default.borderColor=#4c708c
 Button.default.hoverBorderColor=#537699
 Button.default.focusedBorderColor=#537699
 Button.default.focusColor=#43688c
 Button.default.boldText=true
 
-Button.toolbar.hoverBackground=#4c5052
-Button.toolbar.pressedBackground=#555a5d
+Button.toolbar.hoverBackground=lighten($Button.background,1%,derived autoInverse)
+Button.toolbar.pressedBackground=lighten($Button.background,4%,derived autoInverse)
 
 
 #---- CheckBox ----
@@ -105,8 +104,8 @@ CheckBox.icon.hoverBorderColor=$CheckBox.icon.focusedBorderColor
 CheckBox.icon.selectedFocusedBorderColor=#466D94
 CheckBox.icon.background=#43494A
 CheckBox.icon.disabledBackground=@background
-CheckBox.icon.hoverBackground=@buttonHoverBackground
-CheckBox.icon.pressedBackground=@buttonPressedBackground
+CheckBox.icon.hoverBackground=lighten($CheckBox.icon.background,3%,derived autoInverse)
+CheckBox.icon.pressedBackground=lighten($CheckBox.icon.background,6%,derived autoInverse)
 CheckBox.icon.selectedBackground=#43494A
 CheckBox.icon.checkmarkColor=#A7A7A7
 CheckBox.icon.disabledCheckmarkColor=#606060
@@ -129,6 +128,35 @@ Component.disabledBorderColor=#646464
 Component.focusedBorderColor=#466d94
 Component.focusColor=#3d6185
 Component.linkColor=#589df6
+Component.grayFilter=-20,-70,100
+
+
+#---- Desktop ----
+
+Desktop.background=#3E434C
+
+
+#---- DesktopIcon ----
+
+DesktopIcon.background=lighten($Desktop.background,10%)
+
+
+#---- InternalFrame ----
+
+InternalFrame.activeTitleBackground=darken(@background,10%)
+InternalFrame.activeTitleForeground=@foreground
+InternalFrame.inactiveTitleBackground=darken(@background,5%)
+InternalFrame.inactiveTitleForeground=@disabledText
+
+InternalFrame.activeBorderColor=lighten($Component.borderColor,10%)
+InternalFrame.inactiveBorderColor=$Component.borderColor
+
+InternalFrame.buttonHoverBackground=lighten($InternalFrame.activeTitleBackground,10%,derived autoInverse)
+InternalFrame.buttonPressedBackground=lighten($InternalFrame.activeTitleBackground,20%,derived autoInverse)
+InternalFrame.closeHoverBackground=lazy(Actions.Red)
+InternalFrame.closePressedBackground=darken(Actions.Red,10%,lazy)
+InternalFrame.closeHoverForeground=#fff
+InternalFrame.closePressedForeground=#fff
 
 
 #---- List ----
@@ -145,6 +173,7 @@ Menu.icon.disabledArrowColor=#606060
 #---- MenuBar ----
 
 MenuBar.borderColor=#515151
+MenuBar.hoverBackground=@menuHoverBackground
 
 
 #---- MenuItemCheckBox ----
@@ -153,25 +182,30 @@ MenuItemCheckBox.icon.checkmarkColor=#A7A7A7
 MenuItemCheckBox.icon.disabledCheckmarkColor=#606060
 
 
+#---- PasswordField ----
+
+PasswordField.capsLockIconColor=#ffffff64
+
+
 #---- PopupMenu ----
 
-PopupMenu.borderColor=#515151
+PopupMenu.borderColor=#5e5e5e
 
 
 #---- ProgressBar ----
 
 ProgressBar.background=#555555
-ProgressBar.foreground=#a0a0a0
-ProgressBar.selectionForeground=@background
+ProgressBar.foreground=#4A88C7
+ProgressBar.selectionForeground=@foreground
 ProgressBar.selectionBackground=@foreground
 
 
 #---- ScrollBar ----
 
 ScrollBar.track=#3F4244
-ScrollBar.thumb=#5B5E5F
-ScrollBar.hoverTrackColor=#434647
-ScrollBar.hoverThumbColor=#666868
+ScrollBar.thumb=lighten($ScrollBar.track,10%)
+ScrollBar.hoverTrackColor=lighten($ScrollBar.track,4%)
+ScrollBar.hoverThumbColor=lighten($ScrollBar.thumb,10%)
 
 
 #---- Separator ----
@@ -184,7 +218,7 @@ Separator.foreground=#515151
 Slider.trackColor=#646464
 Slider.thumbColor=#A6A6A6
 Slider.tickColor=#888888
-Slider.hoverColor=darken(15%,autoInverse)
+Slider.hoverColor=darken($Slider.thumbColor,15%,derived autoInverse)
 Slider.disabledForeground=#4c5052
 
 
@@ -207,23 +241,23 @@ TabbedPane.contentAreaColor=#323232
 #---- Table ----
 
 Table.background=@textComponentBackground
-Table.gridColor=#4F5152
+Table.gridColor=lighten($Table.background,3%)
 
 
 #---- TableHeader ----
 
-TableHeader.background=#45494A
-TableHeader.separatorColor=#585858
-TableHeader.bottomSeparatorColor=#585858
+TableHeader.background=@textComponentBackground
+TableHeader.separatorColor=lighten($TableHeader.background,10%)
+TableHeader.bottomSeparatorColor=$TableHeader.separatorColor
 
 
 #---- ToggleButton ----
 
-ToggleButton.selectedBackground=#64696C
+ToggleButton.selectedBackground=lighten($ToggleButton.background,10%,derived autoInverse)
 ToggleButton.selectedForeground=@foreground
-ToggleButton.disabledSelectedBackground=#525658
+ToggleButton.disabledSelectedBackground=lighten($ToggleButton.background,3%,derived autoInverse)
 
-ToggleButton.toolbar.selectedBackground=#5c6164
+ToggleButton.toolbar.selectedBackground=lighten($ToggleButton.background,7%,derived autoInverse)
 
 
 #---- ToolTip ----

flatlaf-core/src/main/resources/com/formdev/flatlaf/FlatLaf.properties

@@ -21,21 +21,26 @@ CheckBoxUI=com.formdev.flatlaf.ui.FlatCheckBoxUI
 CheckBoxMenuItemUI=com.formdev.flatlaf.ui.FlatCheckBoxMenuItemUI
 ColorChooserUI=com.formdev.flatlaf.ui.FlatColorChooserUI
 ComboBoxUI=com.formdev.flatlaf.ui.FlatComboBoxUI
+DesktopIconUI=com.formdev.flatlaf.ui.FlatDesktopIconUI
+DesktopPaneUI=com.formdev.flatlaf.ui.FlatDesktopPaneUI
 EditorPaneUI=com.formdev.flatlaf.ui.FlatEditorPaneUI
 FileChooserUI=com.formdev.flatlaf.ui.FlatFileChooserUI
 FormattedTextFieldUI=com.formdev.flatlaf.ui.FlatFormattedTextFieldUI
+InternalFrameUI=com.formdev.flatlaf.ui.FlatInternalFrameUI
 LabelUI=com.formdev.flatlaf.ui.FlatLabelUI
 ListUI=com.formdev.flatlaf.ui.FlatListUI
 MenuUI=com.formdev.flatlaf.ui.FlatMenuUI
 MenuBarUI=com.formdev.flatlaf.ui.FlatMenuBarUI
 MenuItemUI=com.formdev.flatlaf.ui.FlatMenuItemUI
 OptionPaneUI=com.formdev.flatlaf.ui.FlatOptionPaneUI
+PanelUI=com.formdev.flatlaf.ui.FlatPanelUI
 PasswordFieldUI=com.formdev.flatlaf.ui.FlatPasswordFieldUI
 PopupMenuUI=com.formdev.flatlaf.ui.FlatPopupMenuUI
 PopupMenuSeparatorUI=com.formdev.flatlaf.ui.FlatPopupMenuSeparatorUI
 ProgressBarUI=com.formdev.flatlaf.ui.FlatProgressBarUI
 RadioButtonUI=com.formdev.flatlaf.ui.FlatRadioButtonUI
 RadioButtonMenuItemUI=com.formdev.flatlaf.ui.FlatRadioButtonMenuItemUI
+RootPaneUI=com.formdev.flatlaf.ui.FlatRootPaneUI
 ScrollBarUI=com.formdev.flatlaf.ui.FlatScrollBarUI
 ScrollPaneUI=com.formdev.flatlaf.ui.FlatScrollPaneUI
 SeparatorUI=com.formdev.flatlaf.ui.FlatSeparatorUI
@@ -59,6 +64,7 @@ ViewportUI=com.formdev.flatlaf.ui.FlatViewportUI
 #---- variables ----
 
 @textComponentMargin=2,6,2,6
+@menuItemMargin=3,6,3,6
 
 
 #---- system colors ----
@@ -80,11 +86,44 @@ textHighlightText=@selectionForeground
 textInactiveText=@disabledText
 control=@background
 controlText=@foreground
+controlShadow=$Component.borderColor
 scrollbar=$ScrollBar.track
 info=$ToolTip.background
 infoText=@foreground
 
 
+#---- unused colors ----
+
+# Colors that are defined in BasicLookAndFeel but are not used in FlatLaf.
+# Keep them for compatibility (if used in 3rd party app) and give them useful values.
+
+*.shadow=$controlShadow
+*.darkShadow=$controlDkShadow
+*.light=$controlHighlight
+*.highlight=$controlLtHighlight
+
+ComboBox.buttonShadow=$controlShadow
+ComboBox.buttonDarkShadow=$controlDkShadow
+ComboBox.buttonHighlight=$controlLtHighlight
+
+InternalFrame.borderColor=$control
+InternalFrame.borderShadow=$controlShadow
+InternalFrame.borderDarkShadow=$controlDkShadow
+InternalFrame.borderHighlight=$controlLtHighlight
+InternalFrame.borderLight=$controlHighlight
+
+Label.disabledShadow=$controlShadow
+
+ScrollBar.trackHighlight=$controlDkShadow
+ScrollBar.thumbHighlight=$controlLtHighlight
+ScrollBar.thumbDarkShadow=$controlDkShadow
+ScrollBar.thumbShadow=$controlShadow
+
+Slider.focus=$controlDkShadow
+
+TabbedPane.focus=$controlText
+
+
 #---- Button ----
 
 Button.border=com.formdev.flatlaf.ui.FlatButtonBorder
@@ -98,6 +137,9 @@ Button.defaultButtonFollowsFocus=false
 
 Button.default.borderWidth=1
 
+Button.toolbar.margin=3,3,3,3
+Button.toolbar.spacingInsets=1,2,1,2
+
 
 #---- Caret ----
 
@@ -116,22 +158,27 @@ CheckBox.rollover=true
 
 #---- CheckBoxMenuItem ----
 
-CheckBoxMenuItem.border=com.formdev.flatlaf.ui.FlatMarginBorder
+CheckBoxMenuItem.border=com.formdev.flatlaf.ui.FlatMenuItemBorder
 CheckBoxMenuItem.checkIcon=com.formdev.flatlaf.icons.FlatCheckBoxMenuItemIcon
 CheckBoxMenuItem.arrowIcon=com.formdev.flatlaf.icons.FlatMenuItemArrowIcon
-CheckBoxMenuItem.margin=2,2,2,2
+CheckBoxMenuItem.margin=@menuItemMargin
+CheckBoxMenuItem.opaque=false
+CheckBoxMenuItem.borderPainted=true
+CheckBoxMenuItem.background=@menuBackground
 
 
 #---- ColorChooser ----
 
-ColorChooser.swatchesSwatchSize=16,16
-ColorChooser.swatchesRecentSwatchSize=16,16
+ColorChooser.swatchesSwatchSize={scaledDimension}16,16
+ColorChooser.swatchesRecentSwatchSize={scaledDimension}16,16
+ColorChooser.swatchesDefaultRecentColor=$control
 
 
 #---- ComboBox ----
 
 ComboBox.border=com.formdev.flatlaf.ui.FlatRoundBorder
 ComboBox.padding=2,6,2,6
+[mac]ComboBox.showPopupOnNavigation=true
 
 
 #---- Component ----
@@ -144,6 +191,14 @@ Component.arrowType=chevron
 Component.hideMnemonics=true
 
 
+#---- DesktopIcon ----
+
+DesktopIcon.border=4,4,4,4
+DesktopIcon.iconSize=64,64
+DesktopIcon.closeSize=20,20
+DesktopIcon.closeIcon=com.formdev.flatlaf.icons.FlatInternalFrameCloseIcon
+
+
 #---- EditorPane ----
 
 EditorPane.border=com.formdev.flatlaf.ui.FlatMarginBorder
@@ -158,6 +213,7 @@ FileChooser.upFolderIcon=com.formdev.flatlaf.icons.FlatFileChooserUpFolderIcon
 FileChooser.homeFolderIcon=com.formdev.flatlaf.icons.FlatFileChooserHomeFolderIcon
 FileChooser.detailsViewIcon=com.formdev.flatlaf.icons.FlatFileChooserDetailsViewIcon
 FileChooser.listViewIcon=com.formdev.flatlaf.icons.FlatFileChooserListViewIcon
+FileChooser.usesSingleFilePane=true
 
 
 #---- FileView ----
@@ -171,7 +227,7 @@ FileView.floppyDriveIcon=com.formdev.flatlaf.icons.FlatFileViewFloppyDriveIcon
 
 #---- FormattedTextField ----
 
-FormattedTextField.border=com.formdev.flatlaf.ui.FlatBorder
+FormattedTextField.border=com.formdev.flatlaf.ui.FlatTextBorder
 FormattedTextField.margin=@textComponentMargin
 FormattedTextField.background=@textComponentBackground
 FormattedTextField.placeholderForeground=@disabledText
@@ -193,9 +249,27 @@ HelpButton.questionMarkColor=$CheckBox.icon.checkmarkColor
 HelpButton.disabledQuestionMarkColor=$CheckBox.icon.disabledCheckmarkColor
 
 
+#---- InternalFrame ----
+
+InternalFrame.border=com.formdev.flatlaf.ui.FlatInternalFrameUI$FlatInternalFrameBorder
+InternalFrame.borderLineWidth=1
+InternalFrame.borderMargins=6,6,6,6
+InternalFrame.buttonSize=24,24
+InternalFrame.closeIcon=com.formdev.flatlaf.icons.FlatInternalFrameCloseIcon
+InternalFrame.iconifyIcon=com.formdev.flatlaf.icons.FlatInternalFrameIconifyIcon
+InternalFrame.maximizeIcon=com.formdev.flatlaf.icons.FlatInternalFrameMaximizeIcon
+InternalFrame.minimizeIcon=com.formdev.flatlaf.icons.FlatInternalFrameMinimizeIcon
+InternalFrame.windowBindings=null
+
+
+#---- InternalFrameTitlePane ----
+
+InternalFrameTitlePane.border=0,8,0,0
+
+
 #---- List ----
 
-List.border=1,0,1,0
+List.border=0,0,0,0
 List.cellMargins=1,6,1,6
 List.cellFocusColor=@cellFocusColor
 List.cellNoFocusBorder=com.formdev.flatlaf.ui.FlatListCellBorder$Default
@@ -210,21 +284,49 @@ List.dropLineColor=@dropLineColor
 
 #---- Menu ----
 
-Menu.border=com.formdev.flatlaf.ui.FlatMarginBorder
+Menu.border=com.formdev.flatlaf.ui.FlatMenuItemBorder
 Menu.arrowIcon=com.formdev.flatlaf.icons.FlatMenuArrowIcon
-Menu.margin=2,2,2,2
+Menu.checkIcon=null
+Menu.margin=@menuItemMargin
+Menu.submenuPopupOffsetX={scaledInteger}-4
+Menu.submenuPopupOffsetY={scaledInteger}-4
+Menu.opaque=false
+Menu.borderPainted=true
+Menu.background=@menuBackground
 
 
 #---- MenuBar ----
 
 MenuBar.border=com.formdev.flatlaf.ui.FlatMenuBarBorder
+MenuBar.background=@menuBackground
+MenuBar.itemMargins=3,8,3,8
 
 
 #---- MenuItem ----
 
-MenuItem.border=com.formdev.flatlaf.ui.FlatMarginBorder
+MenuItem.border=com.formdev.flatlaf.ui.FlatMenuItemBorder
 MenuItem.arrowIcon=com.formdev.flatlaf.icons.FlatMenuItemArrowIcon
-MenuItem.margin=2,2,2,2
+MenuItem.checkIcon=null
+MenuItem.margin=@menuItemMargin
+MenuItem.opaque=false
+MenuItem.borderPainted=true
+MenuItem.background=@menuBackground
+MenuItem.checkBackground=@menuCheckBackground
+MenuItem.checkMargins=2,2,2,2
+MenuItem.minimumWidth=72
+MenuItem.minimumIconSize=16,16
+MenuItem.iconTextGap=6
+MenuItem.textAcceleratorGap=24
+MenuItem.textNoAcceleratorGap=6
+MenuItem.acceleratorArrowGap=2
+MenuItem.acceleratorDelimiter=-
+[mac]MenuItem.acceleratorDelimiter=
+
+# for MenuItem.selectionType=underline
+MenuItem.underlineSelectionBackground=@menuHoverBackground
+MenuItem.underlineSelectionCheckBackground=@menuCheckHoverBackground
+MenuItem.underlineSelectionColor=$TabbedPane.underlineColor
+MenuItem.underlineSelectionHeight=3
 
 
 #---- OptionPane ----
@@ -252,16 +354,19 @@ OptionPane.warningIcon=com.formdev.flatlaf.icons.FlatOptionPaneWarningIcon
 
 #---- PasswordField ----
 
-PasswordField.border=com.formdev.flatlaf.ui.FlatBorder
+PasswordField.border=com.formdev.flatlaf.ui.FlatTextBorder
 PasswordField.margin=@textComponentMargin
 PasswordField.background=@textComponentBackground
 PasswordField.placeholderForeground=@disabledText
+PasswordField.echoChar=\u2022
+PasswordField.capsLockIcon=com.formdev.flatlaf.icons.FlatCapsLockIcon
 
 
 #---- PopupMenu ----
 
 PopupMenu.border=com.formdev.flatlaf.ui.FlatPopupMenuBorder
-PopupMenu.borderInsets=1,1,1,1
+PopupMenu.borderInsets=4,1,4,1
+PopupMenu.background=@menuBackground
 
 
 #---- PopupMenuSeparator ----
@@ -277,6 +382,8 @@ ProgressBar.border=com.formdev.flatlaf.ui.FlatEmptyBorder
 ProgressBar.arc=4
 ProgressBar.horizontalSize=146,4
 ProgressBar.verticalSize=4,146
+ProgressBar.cycleTime=4000
+ProgressBar.repaintInterval=15
 
 
 #---- RadioButton ----
@@ -291,10 +398,13 @@ RadioButton.rollover=true
 
 #---- RadioButtonMenuItem ----
 
-RadioButtonMenuItem.border=com.formdev.flatlaf.ui.FlatMarginBorder
+RadioButtonMenuItem.border=com.formdev.flatlaf.ui.FlatMenuItemBorder
 RadioButtonMenuItem.checkIcon=com.formdev.flatlaf.icons.FlatRadioButtonMenuItemIcon
 RadioButtonMenuItem.arrowIcon=com.formdev.flatlaf.icons.FlatMenuItemArrowIcon
-RadioButtonMenuItem.margin=2,2,2,2
+RadioButtonMenuItem.margin=@menuItemMargin
+RadioButtonMenuItem.opaque=false
+RadioButtonMenuItem.borderPainted=true
+RadioButtonMenuItem.background=@menuBackground
 
 
 #---- ScrollBar ----
@@ -304,6 +414,7 @@ ScrollBar.showButtons=false
 ScrollBar.squareButtons=false
 ScrollBar.buttonArrowColor=$ComboBox.buttonArrowColor
 ScrollBar.buttonDisabledArrowColor=$ComboBox.buttonDisabledArrowColor
+ScrollBar.allowsAbsolutePositioning=true
 
 
 #---- ScrollPane ----
@@ -311,6 +422,7 @@ ScrollBar.buttonDisabledArrowColor=$ComboBox.buttonDisabledArrowColor
 ScrollPane.border=com.formdev.flatlaf.ui.FlatBorder
 ScrollPane.background=$ScrollBar.track
 ScrollPane.fillUpperCorner=true
+ScrollPane.smoothScrolling=true
 
 
 #---- Separator ----
@@ -363,13 +475,15 @@ TabbedPane.tabAreaInsets=0,0,0,0
 TabbedPane.selectedTabPadInsets=0,0,0,0
 TabbedPane.tabRunOverlay=0
 TabbedPane.tabsOverlapBorder=true
-TabbedPane.shadow=$ComboBox.buttonArrowColor
+TabbedPane.shadow=@background
+TabbedPane.contentBorderInsets=null
 
 
 #---- Table ----
 
 Table.rowHeight=20
-Table.showGrid=false
+Table.showHorizontalLines=false
+Table.showVerticalLines=false
 Table.intercellSpacing={dimension}0,0
 Table.scrollPaneBorder=com.formdev.flatlaf.ui.FlatBorder
 Table.ascendingSortIcon=com.formdev.flatlaf.icons.FlatAscendingSortIcon
@@ -380,6 +494,8 @@ Table.cellFocusColor=@cellFocusColor
 Table.cellNoFocusBorder=com.formdev.flatlaf.ui.FlatTableCellBorder$Default
 Table.focusCellHighlightBorder=com.formdev.flatlaf.ui.FlatTableCellBorder$Focused
 Table.focusSelectedCellHighlightBorder=com.formdev.flatlaf.ui.FlatTableCellBorder$Selected
+Table.focusCellBackground=@textComponentBackground
+Table.focusCellForeground=@foreground
 Table.selectionInactiveBackground=@selectionInactiveBackground
 Table.selectionInactiveForeground=@selectionInactiveForeground
 Table.dropCellBackground=@dropCellBackground
@@ -392,6 +508,7 @@ Table.dropLineShortColor=@dropLineShortColor
 
 TableHeader.height=25
 TableHeader.cellBorder=2,3,2,3
+TableHeader.focusCellBackground=$TableHeader.background
 
 
 #---- TextArea ----
@@ -401,9 +518,16 @@ TextArea.margin=@textComponentMargin
 TextArea.background=@textComponentBackground
 
 
+#---- TextComponent ----
+
+# allowed values: "never", "once" (default) or "always"
+TextComponent.selectAllOnFocusPolicy=once
+TextComponent.arc=0
+
+
 #---- TextField ----
 
-TextField.border=com.formdev.flatlaf.ui.FlatBorder
+TextField.border=com.formdev.flatlaf.ui.FlatTextBorder
 TextField.margin=@textComponentMargin
 TextField.background=@textComponentBackground
 TextField.placeholderForeground=@disabledText
@@ -435,27 +559,36 @@ ToggleButton.pressedBackground=$Button.pressedBackground
 ToggleButton.toolbar.hoverBackground=$Button.toolbar.hoverBackground
 ToggleButton.toolbar.pressedBackground=$Button.toolbar.pressedBackground
 
+# button type "tab"
+ToggleButton.tab.underlineHeight=2
+ToggleButton.tab.underlineColor=$TabbedPane.underlineColor
+ToggleButton.tab.disabledUnderlineColor=$TabbedPane.disabledUnderlineColor
+ToggleButton.tab.selectedBackground=$?TabbedPane.selectedBackground
+ToggleButton.tab.hoverBackground=$TabbedPane.hoverColor
+ToggleButton.tab.focusBackground=$TabbedPane.focusColor
+
 
 #---- ToolBar ----
 
 ToolBar.border=com.formdev.flatlaf.ui.FlatToolBarBorder
+ToolBar.borderMargins=2,2,2,2
 ToolBar.isRollover=true
-ToolBar.buttonMargins=3,3,3,3
 ToolBar.gripColor=@icon
 ToolBar.dockingBackground=@background
+ToolBar.dockingForeground=@foreground
 ToolBar.floatingBackground=@background
+ToolBar.floatingForeground=@disabledText
 
 ToolBar.separatorSize=null
 ToolBar.separatorWidth=7
 ToolBar.separatorColor=$Separator.foreground
 
+ToolBar.spacingBorder=$Button.toolbar.spacingInsets
 
-#---- ToolTip ----
 
-ToolTip.border=4,6,4,6,$Component.borderColor
-ToolTip.borderInactive=null
-ToolTip.backgroundInactive=$ToolTip.background
-ToolTip.foregroundInactive=@disabledText
+#---- ToolTipManager ----
+
+ToolTipManager.enableToolTipMode=activeApplication
 
 
 #---- Tree ----
@@ -463,13 +596,15 @@ ToolTip.foregroundInactive=@disabledText
 Tree.border=1,1,1,1
 Tree.selectionInactiveBackground=@selectionInactiveBackground
 Tree.selectionInactiveForeground=@selectionInactiveForeground
-Tree.textBackground=null
+Tree.textBackground=$Tree.background
 Tree.selectionBorderColor=@cellFocusColor
 Tree.dropCellBackground=@dropCellBackground
 Tree.dropCellForeground=@dropCellForeground
 Tree.dropLineColor=@dropLineColor
+Tree.rendererFillBackground=false
 Tree.rendererMargins=1,2,1,2
 Tree.wideSelection=true
+Tree.repaintWholeRow=true
 Tree.paintLines=false
 Tree.leftChildIndent=7
 Tree.rightChildIndent=11

flatlaf-core/src/main/resources/com/formdev/flatlaf/FlatLightLaf.properties

@@ -28,13 +28,13 @@
 @selectionInactiveForeground=@foreground
 @disabledText=#8C8C8C
 @textComponentBackground=#ffffff
+@menuBackground=#fff
+@menuHoverBackground=darken(@menuBackground,10%)
+@menuCheckBackground=darken(@menuBackground,10%)
+@menuCheckHoverBackground=darken(@menuBackground,20%)
 @cellFocusColor=#000000
 @icon=#afafaf
 
-# Button
-@buttonHoverBackground=darken(3%,autoInverse)
-@buttonPressedBackground=darken(10%,autoInverse)
-
 # Drop (use lazy colors for IntelliJ platform themes, which usually do not specify these colors)
 @dropCellBackground=lighten(List.selectionBackground,10%,lazy)
 @dropCellForeground=lazy(List.selectionForeground)
@@ -56,7 +56,7 @@
 *.disabledBackground=@background
 *.disabledForeground=@disabledText
 *.disabledText=@disabledText
-*.acceleratorForeground=#505050
+*.acceleratorForeground=lighten(@foreground,30%)
 *.acceleratorSelectionForeground=@selectionForeground
 
 
@@ -66,16 +66,15 @@ activeCaption=#99b4d1
 inactiveCaption=#bfcddb
 controlHighlight=#e3e3e3
 controlLtHighlight=#fff
-controlShadow=#a0a0a0
-controlDkShadow=#696969
+controlDkShadow=darken($controlShadow,15%)
 
 
 #---- Button ----
 
 Button.background=#ffffff
 Button.focusedBackground=#e3f1fa
-Button.hoverBackground=@buttonHoverBackground
-Button.pressedBackground=@buttonPressedBackground
+Button.hoverBackground=darken($Button.background,3%,derived autoInverse)
+Button.pressedBackground=darken($Button.background,10%,derived autoInverse)
 
 Button.borderColor=$Component.borderColor
 Button.disabledBorderColor=$Component.disabledBorderColor
@@ -85,16 +84,16 @@ Button.hoverBorderColor=$Button.focusedBorderColor
 Button.default.background=$Button.background
 Button.default.foreground=@foreground
 Button.default.focusedBackground=$Button.focusedBackground
-Button.default.hoverBackground=@buttonHoverBackground
-Button.default.pressedBackground=@buttonPressedBackground
+Button.default.hoverBackground=$Button.hoverBackground
+Button.default.pressedBackground=$Button.pressedBackground
 Button.default.borderColor=#4F9EE3
 Button.default.hoverBorderColor=$Button.hoverBorderColor
 Button.default.focusedBorderColor=$Button.focusedBorderColor
 Button.default.focusColor=$Component.focusColor
 Button.default.borderWidth=2
 
-Button.toolbar.hoverBackground=#dfdfdf
-Button.toolbar.pressedBackground=#d8d8d8
+Button.toolbar.hoverBackground=darken($Button.background,12%,derived autoInverse)
+Button.toolbar.pressedBackground=darken($Button.background,15%,derived autoInverse)
 
 
 #---- CheckBox ----
@@ -107,8 +106,8 @@ CheckBox.icon.hoverBorderColor=$CheckBox.icon.focusedBorderColor
 CheckBox.icon.background=#FFFFFF
 CheckBox.icon.disabledBackground=@background
 CheckBox.icon.focusedBackground=$Button.focusedBackground
-CheckBox.icon.hoverBackground=@buttonHoverBackground
-CheckBox.icon.pressedBackground=@buttonPressedBackground
+CheckBox.icon.hoverBackground=$Button.hoverBackground
+CheckBox.icon.pressedBackground=$Button.pressedBackground
 CheckBox.icon.selectedBackground=#FFFFFF
 CheckBox.icon.checkmarkColor=#4F9EE3
 CheckBox.icon.disabledCheckmarkColor=#ABABAB
@@ -131,6 +130,17 @@ Component.disabledBorderColor=#cfcfcf
 Component.focusedBorderColor=#87afda
 Component.focusColor=#97c3f3
 Component.linkColor=#2470B3
+Component.grayFilter=25,-25,100
+
+
+#---- Desktop ----
+
+Desktop.background=#E6EBF0
+
+
+#---- DesktopIcon ----
+
+DesktopIcon.background=darken($Desktop.background,10%)
 
 
 #---- HelpButton ----
@@ -138,6 +148,24 @@ Component.linkColor=#2470B3
 HelpButton.questionMarkColor=#4F9EE3
 
 
+#---- InternalFrame ----
+
+InternalFrame.activeTitleBackground=#fff
+InternalFrame.activeTitleForeground=@foreground
+InternalFrame.inactiveTitleBackground=#fafafa
+InternalFrame.inactiveTitleForeground=@disabledText
+
+InternalFrame.activeBorderColor=darken($Component.borderColor,20%)
+InternalFrame.inactiveBorderColor=$Component.borderColor
+
+InternalFrame.buttonHoverBackground=darken($InternalFrame.activeTitleBackground,10%,derived autoInverse)
+InternalFrame.buttonPressedBackground=darken($InternalFrame.activeTitleBackground,20%,derived autoInverse)
+InternalFrame.closeHoverBackground=lazy(Actions.Red)
+InternalFrame.closePressedBackground=darken(Actions.Red,10%,lazy)
+InternalFrame.closeHoverForeground=#fff
+InternalFrame.closePressedForeground=#fff
+
+
 #---- List ----
 
 List.background=@textComponentBackground
@@ -152,6 +180,7 @@ Menu.icon.disabledArrowColor=#ABABAB
 #---- MenuBar ----
 
 MenuBar.borderColor=#cdcdcd
+MenuBar.hoverBackground=@menuHoverBackground
 
 
 #---- MenuItemCheckBox ----
@@ -160,6 +189,11 @@ MenuItemCheckBox.icon.checkmarkColor=#4F9EE3
 MenuItemCheckBox.icon.disabledCheckmarkColor=#ABABAB
 
 
+#---- PasswordField ----
+
+PasswordField.capsLockIconColor=#00000064
+
+
 #---- PopupMenu ----
 
 PopupMenu.borderColor=#adadad
@@ -176,9 +210,9 @@ ProgressBar.selectionBackground=@foreground
 #---- ScrollBar ----
 
 ScrollBar.track=#F5F5F5
-ScrollBar.thumb=#DBDBDB
-ScrollBar.hoverTrackColor=#e6e6e6
-ScrollBar.hoverThumbColor=#c6c6c6
+ScrollBar.thumb=darken($ScrollBar.track,10%)
+ScrollBar.hoverTrackColor=darken($ScrollBar.track,3%)
+ScrollBar.hoverThumbColor=darken($ScrollBar.thumb,10%)
 
 
 #---- Separator ----
@@ -191,7 +225,7 @@ Separator.foreground=#d1d1d1
 Slider.trackColor=#c4c4c4
 Slider.thumbColor=#6e6e6e
 Slider.tickColor=#888888
-Slider.hoverColor=lighten(15%,autoInverse)
+Slider.hoverColor=lighten($Slider.thumbColor,15%,derived autoInverse)
 Slider.disabledForeground=#c0c0c0
 
 
@@ -214,27 +248,28 @@ TabbedPane.contentAreaColor=#bfbfbf
 #---- Table ----
 
 Table.background=@textComponentBackground
-Table.gridColor=#F7F7F7
+Table.gridColor=darken($Table.background,3%)
 
 
 #---- TableHeader ----
 
-TableHeader.background=#ffffff
-TableHeader.separatorColor=#e5e5e5
-TableHeader.bottomSeparatorColor=#e5e5e5
+TableHeader.background=@textComponentBackground
+TableHeader.separatorColor=darken($TableHeader.background,10%)
+TableHeader.bottomSeparatorColor=$TableHeader.separatorColor
 
 
 #---- ToggleButton ----
 
-ToggleButton.selectedBackground=#cfcfcf
+ToggleButton.selectedBackground=darken($ToggleButton.background,20%,derived autoInverse)
 ToggleButton.selectedForeground=@foreground
-ToggleButton.disabledSelectedBackground=#dfdfdf
+ToggleButton.disabledSelectedBackground=darken($ToggleButton.background,13%,derived autoInverse)
 
-ToggleButton.toolbar.selectedBackground=#cfcfcf
+ToggleButton.toolbar.selectedBackground=$ToggleButton.selectedBackground
 
 
 #---- ToolTip ----
 
+ToolTip.border=4,6,4,6,$InternalFrame.activeBorderColor
 ToolTip.background=#fafafa
 
 

flatlaf-core/src/main/resources/com/formdev/flatlaf/IntelliJTheme$ThemeLaf.properties

@@ -16,6 +16,16 @@
 
 #---- Button ----
 
+Button.startBackground=$Button.background
+Button.endBackground=$Button.background
+Button.startBorderColor=$Button.borderColor
+Button.endBorderColor=$Button.borderColor
+
+Button.default.startBackground=$Button.default.background
+Button.default.endBackground=$Button.default.background
+Button.default.startBorderColor=$Button.default.borderColor
+Button.default.endBorderColor=$Button.default.borderColor
+
 Button.hoverBorderColor=null
 Button.default.hoverBorderColor=null
 
@@ -23,3 +33,32 @@ Button.default.hoverBorderColor=null
 #---- HelpButton ----
 
 HelpButton.hoverBorderColor=null
+
+
+#---- ToggleButton ----
+
+ToggleButton.startBackground=$ToggleButton.background
+ToggleButton.endBackground=$ToggleButton.background
+[dark]ToggleButton.selectedBackground=lighten($ToggleButton.background,15%,derived autoInverse)
+[dark]ToggleButton.disabledSelectedBackground=lighten($ToggleButton.background,5%,derived autoInverse)
+
+
+#---- theme specific ----
+
+[Gruvbox_Dark_Hard]ToggleButton.selectedBackground=$ToggleButton.selectedBackground
+[Gruvbox_Dark_Hard]ToggleButton.toolbar.selectedBackground=$ToggleButton.toolbar.selectedBackground
+
+[Gruvbox_Dark_Medium]ToggleButton.selectedBackground=$ToggleButton.selectedBackground
+[Gruvbox_Dark_Medium]ToggleButton.toolbar.selectedBackground=$ToggleButton.toolbar.selectedBackground
+
+[Gruvbox_Dark_Soft]ToggleButton.selectedBackground=$ToggleButton.selectedBackground
+[Gruvbox_Dark_Soft]ToggleButton.toolbar.selectedBackground=$ToggleButton.toolbar.selectedBackground
+
+[Hiberbee_Dark]ToggleButton.selectedBackground=$ToggleButton.selectedBackground
+[Hiberbee_Dark]ToggleButton.selectedBackground=$ToggleButton.selectedBackground
+[Hiberbee_Dark]ToggleButton.toolbar.selectedBackground=$ToggleButton.toolbar.selectedBackground
+
+[High_contrast]ToggleButton.selectedBackground=#fff
+[High_contrast]ToggleButton.selectedForeground=#000
+[High_contrast]ToggleButton.disabledSelectedBackground=#444
+[High_contrast]ToggleButton.toolbar.selectedBackground=#fff

flatlaf-core/svg/CapsLockIcon.svg

@@ -0,0 +1,7 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 16 16">
+  <g fill="none" fill-rule="evenodd">
+    <rect width="16" height="16" fill="#6E6E6E" rx="3"/>
+    <rect width="6" height="2" x="5" y="12" fill="#FFF"/>
+    <path fill="#FFF" d="M2,8 L8,2 L14,8 L11,8 L11,10 L5,10 L5,8 L2,8 Z"/>
+  </g>
+</svg>

flatlaf-demo/DemoLaf.properties

@@ -0,0 +1,13 @@
+# This file demonstrates using a FlatLaf theme file in the FlatLaf Demo application.
+# Must be in the working directory of the Demo application.
+# Shown in the "Themes" list under category "Current Directory".
+#
+# Modifications to this file are automatically loaded by the FlatLaf Demo application
+# when the Demo window is activated.
+
+
+# base theme (light, dark, intellij or darcula)
+@baseTheme=light
+
+# add you theme defaults here
+@background=#ccc

flatlaf-demo/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,46 +14,56 @@
  * limitations under the License.
  */
 
-version = rootProject.version
-
 plugins {
 	`java-library`
-	id( "com.jfrog.bintray" ) version "1.8.4"
+	id( "com.jfrog.bintray" )
+
+	// Although artifactory plugin is not used in this subproject, the plugin is required
+	// because otherwise gradle fails with following error:
+	//     Caused by: org.codehaus.groovy.runtime.typehandling.GroovyCastException:
+	//     Cannot cast object 'task ':bintrayUpload''
+	//     with class 'com.jfrog.bintray.gradle.tasks.BintrayUploadTask_Decorated'
+	//     to class 'com.jfrog.bintray.gradle.tasks.BintrayUploadTask'
+	id( "com.jfrog.artifactory" )
 }
 
 dependencies {
 	implementation( project( ":flatlaf-core" ) )
 	implementation( project( ":flatlaf-extras" ) )
+	implementation( project( ":flatlaf-intellij-themes" ) )
 	implementation( "com.miglayout:miglayout-swing:5.2" )
 	implementation( "com.jgoodies:jgoodies-forms:1.9.0" )
 }
 
-java {
-	sourceCompatibility = JavaVersion.VERSION_1_8
-	targetCompatibility = JavaVersion.VERSION_1_8
-}
-
 tasks {
 	jar {
 		dependsOn( ":flatlaf-core:jar" )
 		dependsOn( ":flatlaf-extras:jar" )
+		dependsOn( ":flatlaf-intellij-themes:jar" )
 
 		manifest {
 			attributes( "Main-Class" to "com.formdev.flatlaf.demo.FlatLafDemo" )
+
+			if( JavaVersion.current() >= JavaVersion.VERSION_1_9 )
+				attributes( "Multi-Release" to "true" )
 		}
 
-		exclude( "META-INF/versions/**" )
+		exclude( "module-info.class" )
 
 		// include all dependencies in jar
 		from( {
-			configurations.runtimeClasspath.get().filter { it.name.endsWith( "jar" ) }.map { zipTree( it ) }
+			configurations.runtimeClasspath.get()
+				.filter { it.name.endsWith( "jar" ) }
+				.map { zipTree( it ).matching {
+					exclude( "META-INF/LICENSE" )
+				} }
 		} )
 	}
 }
 
 bintray {
-	user = System.getenv( "BINTRAY_USER" ) ?: System.getProperty( "bintray.user" )
-	key = System.getenv( "BINTRAY_KEY" ) ?: System.getProperty( "bintray.key" )
+	user = rootProject.extra["bintray.user"] as String?
+	key = rootProject.extra["bintray.key"] as String?
 
 	setConfigurations( "archives" )
 
@@ -67,6 +77,7 @@ bintray {
 			name = project.version.toString()
 		}
 
-		publish = true
+		publish = rootProject.extra["bintray.publish"] as Boolean
+		dryRun = rootProject.extra["bintray.dryRun"] as Boolean
 	}
 }

flatlaf-demo/src/main/java/com/formdev/flatlaf/demo/BasicComponentsPanel.java

@@ -17,6 +17,7 @@
 package com.formdev.flatlaf.demo;
 
 import javax.swing.*;
+import javax.swing.text.DefaultEditorKit;
 import net.miginfocom.swing.*;
 
 /**
@@ -37,6 +38,8 @@ class BasicComponentsPanel
 		JLabel buttonLabel = new JLabel();
 		JButton button1 = new JButton();
 		JButton button2 = new JButton();
+		JButton button5 = new JButton();
+		JButton button6 = new JButton();
 		JButton button3 = new JButton();
 		JButton button4 = new JButton();
 		JButton button13 = new JButton();
@@ -111,6 +114,10 @@ class BasicComponentsPanel
 		JScrollPane scrollPane12 = new JScrollPane();
 		JTextPane textPane4 = new JTextPane();
 		JTextPane textPane5 = new JTextPane();
+		JPopupMenu popupMenu1 = new JPopupMenu();
+		JMenuItem cutMenuItem = new JMenuItem();
+		JMenuItem copyMenuItem = new JMenuItem();
+		JMenuItem pasteMenuItem = new JMenuItem();
 
 		//======== this ========
 		setLayout(new MigLayout(
@@ -166,10 +173,21 @@ class BasicComponentsPanel
 		button2.setEnabled(false);
 		add(button2, "cell 2 1");
 
+		//---- button5 ----
+		button5.setText("square");
+		button5.putClientProperty("JButton.buttonType", "square");
+		add(button5, "cell 3 1");
+
+		//---- button6 ----
+		button6.setText("square");
+		button6.setEnabled(false);
+		button6.putClientProperty("JButton.buttonType", "square");
+		add(button6, "cell 4 1");
+
 		//---- button3 ----
 		button3.setText("Help");
 		button3.putClientProperty("JButton.buttonType", "help");
-		add(button3, "cell 3 1");
+		add(button3, "cell 4 1");
 
 		//---- button4 ----
 		button4.setText("Help");
@@ -247,6 +265,8 @@ class BasicComponentsPanel
 
 		//---- comboBoxLabel ----
 		comboBoxLabel.setText("JComboBox:");
+		comboBoxLabel.setDisplayedMnemonic('C');
+		comboBoxLabel.setLabelFor(comboBox1);
 		add(comboBoxLabel, "cell 0 4");
 
 		//---- comboBox1 ----
@@ -290,17 +310,18 @@ class BasicComponentsPanel
 		add(comboBox4, "cell 4 4,growx");
 
 		//---- comboBox5 ----
-		comboBox5.setPrototypeDisplayValue("12345");
 		comboBox5.setModel(new DefaultComboBoxModel<>(new String[] {
 			"wide popup if text is longer",
 			"aa",
 			"bbb",
 			"cccc"
 		}));
-		add(comboBox5, "cell 5 4,growx");
+		add(comboBox5, "cell 5 4,growx,wmax 100");
 
 		//---- spinnerLabel ----
 		spinnerLabel.setText("JSpinner:");
+		spinnerLabel.setLabelFor(spinner1);
+		spinnerLabel.setDisplayedMnemonic('S');
 		add(spinnerLabel, "cell 0 5");
 		add(spinner1, "cell 1 5,growx");
 
@@ -315,10 +336,13 @@ class BasicComponentsPanel
 
 		//---- textFieldLabel ----
 		textFieldLabel.setText("JTextField:");
+		textFieldLabel.setDisplayedMnemonic('T');
+		textFieldLabel.setLabelFor(textField1);
 		add(textFieldLabel, "cell 0 6");
 
 		//---- textField1 ----
 		textField1.setText("editable");
+		textField1.setComponentPopupMenu(popupMenu1);
 		add(textField1, "cell 1 6,growx");
 
 		//---- textField2 ----
@@ -343,10 +367,13 @@ class BasicComponentsPanel
 
 		//---- formattedTextFieldLabel ----
 		formattedTextFieldLabel.setText("JFormattedTextField:");
+		formattedTextFieldLabel.setLabelFor(formattedTextField1);
+		formattedTextFieldLabel.setDisplayedMnemonic('O');
 		add(formattedTextFieldLabel, "cell 0 7");
 
 		//---- formattedTextField1 ----
 		formattedTextField1.setText("editable");
+		formattedTextField1.setComponentPopupMenu(popupMenu1);
 		add(formattedTextField1, "cell 1 7,growx");
 
 		//---- formattedTextField2 ----
@@ -569,7 +596,30 @@ class BasicComponentsPanel
 		//---- textPane5 ----
 		textPane5.setText("no scroll pane");
 		add(textPane5, "cell 5 11,growx");
+
+		//======== popupMenu1 ========
+		{
+
+			//---- cutMenuItem ----
+			cutMenuItem.setText("Cut");
+			cutMenuItem.setMnemonic('C');
+			popupMenu1.add(cutMenuItem);
+
+			//---- copyMenuItem ----
+			copyMenuItem.setText("Copy");
+			copyMenuItem.setMnemonic('O');
+			popupMenu1.add(copyMenuItem);
+
+			//---- pasteMenuItem ----
+			pasteMenuItem.setText("Paste");
+			pasteMenuItem.setMnemonic('P');
+			popupMenu1.add(pasteMenuItem);
+		}
 		// JFormDesigner - End of component initialization  //GEN-END:initComponents
+
+		cutMenuItem.addActionListener( new DefaultEditorKit.CutAction() );
+		copyMenuItem.addActionListener( new DefaultEditorKit.CopyAction() );
+		pasteMenuItem.addActionListener( new DefaultEditorKit.PasteAction() );
 	}
 
 	// JFormDesigner - Variables declaration - DO NOT MODIFY  //GEN-BEGIN:variables

flatlaf-demo/src/main/java/com/formdev/flatlaf/demo/BasicComponentsPanel.jfd

@@ -1,4 +1,4 @@
-JFDML JFormDesigner: "7.0.0.0.194" Java: "11.0.2" encoding: "UTF-8"
+JFDML JFormDesigner: "7.0.0.0.194" Java: "13.0.1" encoding: "UTF-8"
 
 new FormModel {
 	contentType: "form/swing"
@@ -54,12 +54,27 @@ new FormModel {
 			}, new FormLayoutConstraints( class net.miginfocom.layout.CC ) {
 				"value": "cell 2 1"
 			} )
+			add( new FormComponent( "javax.swing.JButton" ) {
+				name: "button5"
+				"text": "square"
+				"$client.JButton.buttonType": "square"
+			}, new FormLayoutConstraints( class net.miginfocom.layout.CC ) {
+				"value": "cell 3 1"
+			} )
+			add( new FormComponent( "javax.swing.JButton" ) {
+				name: "button6"
+				"text": "square"
+				"enabled": false
+				"$client.JButton.buttonType": "square"
+			}, new FormLayoutConstraints( class net.miginfocom.layout.CC ) {
+				"value": "cell 4 1"
+			} )
 			add( new FormComponent( "javax.swing.JButton" ) {
 				name: "button3"
 				"text": "Help"
 				"$client.JButton.buttonType": "help"
 			}, new FormLayoutConstraints( class net.miginfocom.layout.CC ) {
-				"value": "cell 3 1"
+				"value": "cell 4 1"
 			} )
 			add( new FormComponent( "javax.swing.JButton" ) {
 				name: "button4"
@@ -168,6 +183,8 @@ new FormModel {
 			add( new FormComponent( "javax.swing.JLabel" ) {
 				name: "comboBoxLabel"
 				"text": "JComboBox:"
+				"displayedMnemonic": 67
+				"labelFor": new FormReference( "comboBox1" )
 			}, new FormLayoutConstraints( class net.miginfocom.layout.CC ) {
 				"value": "cell 0 4"
 			} )
@@ -225,7 +242,6 @@ new FormModel {
 			} )
 			add( new FormComponent( "javax.swing.JComboBox" ) {
 				name: "comboBox5"
-				"prototypeDisplayValue": "12345"
 				"model": new javax.swing.DefaultComboBoxModel {
 					selectedItem: "wide popup if text is longer"
 					addElement( "wide popup if text is longer" )
@@ -234,11 +250,13 @@ new FormModel {
 					addElement( "cccc" )
 				}
 			}, new FormLayoutConstraints( class net.miginfocom.layout.CC ) {
-				"value": "cell 5 4,growx"
+				"value": "cell 5 4,growx,wmax 100"
 			} )
 			add( new FormComponent( "javax.swing.JLabel" ) {
 				name: "spinnerLabel"
 				"text": "JSpinner:"
+				"labelFor": new FormReference( "spinner1" )
+				"displayedMnemonic": 83
 			}, new FormLayoutConstraints( class net.miginfocom.layout.CC ) {
 				"value": "cell 0 5"
 			} )
@@ -266,12 +284,15 @@ new FormModel {
 			add( new FormComponent( "javax.swing.JLabel" ) {
 				name: "textFieldLabel"
 				"text": "JTextField:"
+				"displayedMnemonic": 84
+				"labelFor": new FormReference( "textField1" )
 			}, new FormLayoutConstraints( class net.miginfocom.layout.CC ) {
 				"value": "cell 0 6"
 			} )
 			add( new FormComponent( "javax.swing.JTextField" ) {
 				name: "textField1"
 				"text": "editable"
+				"componentPopupMenu": &FormReference0 new FormReference( "popupMenu1" )
 			}, new FormLayoutConstraints( class net.miginfocom.layout.CC ) {
 				"value": "cell 1 6,growx"
 			} )
@@ -306,12 +327,15 @@ new FormModel {
 			add( new FormComponent( "javax.swing.JLabel" ) {
 				name: "formattedTextFieldLabel"
 				"text": "JFormattedTextField:"
+				"labelFor": new FormReference( "formattedTextField1" )
+				"displayedMnemonic": 79
 			}, new FormLayoutConstraints( class net.miginfocom.layout.CC ) {
 				"value": "cell 0 7"
 			} )
 			add( new FormComponent( "javax.swing.JFormattedTextField" ) {
 				name: "formattedTextField1"
 				"text": "editable"
+				"componentPopupMenu": #FormReference0
 			}, new FormLayoutConstraints( class net.miginfocom.layout.CC ) {
 				"value": "cell 1 7,growx"
 			} )
@@ -570,7 +594,28 @@ new FormModel {
 			} )
 		}, new FormLayoutConstraints( null ) {
 			"location": new java.awt.Point( 0, 0 )
-			"size": new java.awt.Dimension( 790, 715 )
+			"size": new java.awt.Dimension( 790, 440 )
+		} )
+		add( new FormContainer( "javax.swing.JPopupMenu", new FormLayoutManager( class javax.swing.JPopupMenu ) ) {
+			name: "popupMenu1"
+			add( new FormComponent( "javax.swing.JMenuItem" ) {
+				name: "cutMenuItem"
+				"text": "Cut"
+				"mnemonic": 67
+			} )
+			add( new FormComponent( "javax.swing.JMenuItem" ) {
+				name: "copyMenuItem"
+				"text": "Copy"
+				"mnemonic": 79
+			} )
+			add( new FormComponent( "javax.swing.JMenuItem" ) {
+				name: "pasteMenuItem"
+				"text": "Paste"
+				"mnemonic": 80
+			} )
+		}, new FormLayoutConstraints( null ) {
+			"location": new java.awt.Point( 0, 500 )
+			"size": new java.awt.Dimension( 91, 87 )
 		} )
 	}
 }

flatlaf-demo/src/main/java/com/formdev/flatlaf/demo/ControlBar.java

@@ -63,7 +63,7 @@ class ControlBar
 				(SystemInfo.IS_LINUX && className.equals( "com.sun.java.swing.plaf.gtk.GTKLookAndFeel") ) )
 				name += " (F9)";
 			else if( className.equals( MetalLookAndFeel.class.getName() ) )
-				name += " (F10)";
+				name += " (F12)";
 			else if( className.equals( NimbusLookAndFeel.class.getName() ) )
 				name += " (F11)";
 
@@ -83,6 +83,11 @@ class ControlBar
 				} );
 			}
 		} );
+
+		UIScale.addPropertyChangeListener( e -> {
+			// update info label because user scale factor may change
+			updateInfoLabel();
+		} );
 	}
 
 	void initialize( JFrame frame, JTabbedPane tabbedPane ) {
@@ -101,7 +106,7 @@ class ControlBar
 			registerSwitchToLookAndFeel( KeyEvent.VK_F9, "com.apple.laf.AquaLookAndFeel" );
 		else if( SystemInfo.IS_LINUX )
 			registerSwitchToLookAndFeel( KeyEvent.VK_F9, "com.sun.java.swing.plaf.gtk.GTKLookAndFeel" );
-		registerSwitchToLookAndFeel( KeyEvent.VK_F10, MetalLookAndFeel.class.getName() );
+		registerSwitchToLookAndFeel( KeyEvent.VK_F12, MetalLookAndFeel.class.getName() );
 		registerSwitchToLookAndFeel( KeyEvent.VK_F11, NimbusLookAndFeel.class.getName() );
 
 		// register ESC key to close frame

flatlaf-demo/src/main/java/com/formdev/flatlaf/demo/DataComponentsPanel.java

@@ -21,6 +21,7 @@ import java.awt.datatransfer.StringSelection;
 import java.awt.datatransfer.Transferable;
 import javax.swing.*;
 import javax.swing.table.*;
+import javax.swing.tree.*;
 import net.miginfocom.swing.*;
 
 /**
@@ -80,6 +81,11 @@ class DataComponentsPanel
 		JScrollPane scrollPane5 = new JScrollPane();
 		table1 = new JTable();
 		dndCheckBox = new JCheckBox();
+		JPopupMenu popupMenu2 = new JPopupMenu();
+		JMenuItem menuItem3 = new JMenuItem();
+		JMenuItem menuItem4 = new JMenuItem();
+		JMenuItem menuItem5 = new JMenuItem();
+		JMenuItem menuItem6 = new JMenuItem();
 
 		//======== this ========
 		setLayout(new MigLayout(
@@ -125,6 +131,7 @@ class DataComponentsPanel
 				@Override
 				public String getElementAt(int i) { return values[i]; }
 			});
+			list1.setComponentPopupMenu(popupMenu2);
 			scrollPane1.setViewportView(list1);
 		}
 		add(scrollPane1, "cell 1 0,growx");
@@ -171,6 +178,33 @@ class DataComponentsPanel
 			//---- tree1 ----
 			tree1.setShowsRootHandles(true);
 			tree1.setEditable(true);
+			tree1.setModel(new DefaultTreeModel(
+				new DefaultMutableTreeNode("JTree") {
+					{
+						DefaultMutableTreeNode node1 = new DefaultMutableTreeNode("colors");
+							node1.add(new DefaultMutableTreeNode("blue"));
+							node1.add(new DefaultMutableTreeNode("violet"));
+							node1.add(new DefaultMutableTreeNode("red"));
+							node1.add(new DefaultMutableTreeNode("yellow"));
+						add(node1);
+						node1 = new DefaultMutableTreeNode("sports");
+							node1.add(new DefaultMutableTreeNode("basketball"));
+							node1.add(new DefaultMutableTreeNode("soccer"));
+							node1.add(new DefaultMutableTreeNode("football"));
+							node1.add(new DefaultMutableTreeNode("hockey"));
+						add(node1);
+						node1 = new DefaultMutableTreeNode("food");
+							node1.add(new DefaultMutableTreeNode("hot dogs"));
+							DefaultMutableTreeNode node2 = new DefaultMutableTreeNode("pizza");
+								node2.add(new DefaultMutableTreeNode("pizza aglio e olio"));
+								node2.add(new DefaultMutableTreeNode("pizza margherita bianca"));
+							node1.add(node2);
+							node1.add(new DefaultMutableTreeNode("ravioli"));
+							node1.add(new DefaultMutableTreeNode("bananas"));
+						add(node1);
+					}
+				}));
+			tree1.setComponentPopupMenu(popupMenu2);
 			scrollPane3.setViewportView(tree1);
 		}
 		add(scrollPane3, "cell 1 1,growx");
@@ -260,6 +294,7 @@ class DataComponentsPanel
 					}))));
 			}
 			table1.setAutoCreateRowSorter(true);
+			table1.setComponentPopupMenu(popupMenu2);
 			scrollPane5.setViewportView(table1);
 		}
 		add(scrollPane5, "cell 1 2 2 1,growx,width 300");
@@ -269,6 +304,27 @@ class DataComponentsPanel
 		dndCheckBox.setMnemonic('D');
 		dndCheckBox.addActionListener(e -> dndChanged());
 		add(dndCheckBox, "cell 0 3 3 1");
+
+		//======== popupMenu2 ========
+		{
+
+			//---- menuItem3 ----
+			menuItem3.setText("Some Action");
+			popupMenu2.add(menuItem3);
+
+			//---- menuItem4 ----
+			menuItem4.setText("More Action");
+			popupMenu2.add(menuItem4);
+			popupMenu2.addSeparator();
+
+			//---- menuItem5 ----
+			menuItem5.setText("No Action");
+			popupMenu2.add(menuItem5);
+
+			//---- menuItem6 ----
+			menuItem6.setText("Noop Action");
+			popupMenu2.add(menuItem6);
+		}
 		// JFormDesigner - End of component initialization  //GEN-END:initComponents
 
 		((JComboBox)((DefaultCellEditor)table1.getColumnModel().getColumn( 3 ).getCellEditor()).getComponent()).setEditable( true );

flatlaf-demo/src/main/java/com/formdev/flatlaf/demo/DataComponentsPanel.jfd

@@ -1,4 +1,4 @@
-JFDML JFormDesigner: "7.0.0.0.194" Java: "11.0.2" encoding: "UTF-8"
+JFDML JFormDesigner: "7.0.1.0.272" Java: "13.0.2" encoding: "UTF-8"
 
 new FormModel {
 	contentType: "form/swing"
@@ -39,6 +39,7 @@ new FormModel {
 						addElement( "item 14" )
 						addElement( "item 15" )
 					}
+					"componentPopupMenu": new FormReference( "popupMenu2" )
 					auxiliary() {
 						"JavaCodeGenerator.typeParameters": "String"
 						"JavaCodeGenerator.variableLocal": false
@@ -89,6 +90,61 @@ new FormModel {
 					name: "tree1"
 					"showsRootHandles": true
 					"editable": true
+					"model": new javax.swing.tree.DefaultTreeModel( new javax.swing.tree.DefaultMutableTreeNode {
+						userObject: "JTree"
+						add( new javax.swing.tree.DefaultMutableTreeNode {
+							userObject: "colors"
+							add( new javax.swing.tree.DefaultMutableTreeNode {
+								userObject: "blue"
+							} )
+							add( new javax.swing.tree.DefaultMutableTreeNode {
+								userObject: "violet"
+							} )
+							add( new javax.swing.tree.DefaultMutableTreeNode {
+								userObject: "red"
+							} )
+							add( new javax.swing.tree.DefaultMutableTreeNode {
+								userObject: "yellow"
+							} )
+						} )
+						add( new javax.swing.tree.DefaultMutableTreeNode {
+							userObject: "sports"
+							add( new javax.swing.tree.DefaultMutableTreeNode {
+								userObject: "basketball"
+							} )
+							add( new javax.swing.tree.DefaultMutableTreeNode {
+								userObject: "soccer"
+							} )
+							add( new javax.swing.tree.DefaultMutableTreeNode {
+								userObject: "football"
+							} )
+							add( new javax.swing.tree.DefaultMutableTreeNode {
+								userObject: "hockey"
+							} )
+						} )
+						add( new javax.swing.tree.DefaultMutableTreeNode {
+							userObject: "food"
+							add( new javax.swing.tree.DefaultMutableTreeNode {
+								userObject: "hot dogs"
+							} )
+							add( new javax.swing.tree.DefaultMutableTreeNode {
+								userObject: "pizza"
+								add( new javax.swing.tree.DefaultMutableTreeNode {
+									userObject: "pizza aglio e olio"
+								} )
+								add( new javax.swing.tree.DefaultMutableTreeNode {
+									userObject: "pizza margherita bianca"
+								} )
+							} )
+							add( new javax.swing.tree.DefaultMutableTreeNode {
+								userObject: "ravioli"
+							} )
+							add( new javax.swing.tree.DefaultMutableTreeNode {
+								userObject: "bananas"
+							} )
+						} )
+					} )
+					"componentPopupMenu": new FormReference( "popupMenu2" )
 					auxiliary() {
 						"JavaCodeGenerator.variableLocal": false
 					}
@@ -245,6 +301,7 @@ new FormModel {
 						add( null )
 					} )
 					"autoCreateRowSorter": true
+					"componentPopupMenu": new FormReference( "popupMenu2" )
 					auxiliary() {
 						"JavaCodeGenerator.variableLocal": false
 					}
@@ -267,5 +324,29 @@ new FormModel {
 			"location": new java.awt.Point( 0, 0 )
 			"size": new java.awt.Dimension( 790, 715 )
 		} )
+		add( new FormContainer( "javax.swing.JPopupMenu", new FormLayoutManager( class javax.swing.JPopupMenu ) ) {
+			name: "popupMenu2"
+			add( new FormComponent( "javax.swing.JMenuItem" ) {
+				name: "menuItem3"
+				"text": "Some Action"
+			} )
+			add( new FormComponent( "javax.swing.JMenuItem" ) {
+				name: "menuItem4"
+				"text": "More Action"
+			} )
+			add( new FormComponent( "javax.swing.JPopupMenu$Separator" ) {
+				name: "separator1"
+			} )
+			add( new FormComponent( "javax.swing.JMenuItem" ) {
+				name: "menuItem5"
+				"text": "No Action"
+			} )
+			add( new FormComponent( "javax.swing.JMenuItem" ) {
+				name: "menuItem6"
+				"text": "Noop Action"
+			} )
+		}, new FormLayoutConstraints( null ) {
+			"location": new java.awt.Point( 0, 740 )
+		} )
 	}
 }

flatlaf-demo/src/main/java/com/formdev/flatlaf/demo/DemoFrame.java

@@ -19,6 +19,9 @@ package com.formdev.flatlaf.demo;
 import java.awt.*;
 import java.awt.event.*;
 import javax.swing.*;
+import javax.swing.text.DefaultEditorKit;
+import com.formdev.flatlaf.FlatLaf;
+import com.formdev.flatlaf.demo.extras.*;
 import com.formdev.flatlaf.demo.intellijthemes.*;
 import com.formdev.flatlaf.extras.FlatSVGIcon;
 import net.miginfocom.swing.*;
@@ -51,6 +54,57 @@ class DemoFrame
 		DemoPrefs.getState().putInt( FlatLafDemo.KEY_TAB, tabbedPane.getSelectedIndex() );
 	}
 
+	private void menuItemActionPerformed( ActionEvent e ) {
+		SwingUtilities.invokeLater( () -> {
+			JOptionPane.showMessageDialog( this, e.getActionCommand(), "Menu Item", JOptionPane.PLAIN_MESSAGE );
+		} );
+	}
+
+	private void underlineMenuSelection() {
+		UIManager.put( "MenuItem.selectionType", underlineMenuSelectionMenuItem.isSelected() ? "underline" : null );
+	}
+
+	private void fontFamilyChanged( ActionEvent e ) {
+		String fontFamily = e.getActionCommand();
+
+		Font font = UIManager.getFont( "defaultFont" );
+		Font newFont = new Font( fontFamily, font.getStyle(), font.getSize() );
+		UIManager.put( "defaultFont", newFont );
+
+		FlatLaf.updateUI();
+	}
+
+	private void fontSizeChanged( ActionEvent e ) {
+		String fontSizeStr = e.getActionCommand();
+
+		Font font = UIManager.getFont( "defaultFont" );
+		Font newFont = font.deriveFont( (float) Integer.parseInt( fontSizeStr ) );
+		UIManager.put( "defaultFont", newFont );
+
+		FlatLaf.updateUI();
+	}
+
+	private void restoreFont() {
+		UIManager.put( "defaultFont", null );
+		FlatLaf.updateUI();
+	}
+
+	private void incrFont() {
+		Font font = UIManager.getFont( "defaultFont" );
+		Font newFont = font.deriveFont( (float) (font.getSize() + 1) );
+		UIManager.put( "defaultFont", newFont );
+
+		FlatLaf.updateUI();
+	}
+
+	private void decrFont() {
+		Font font = UIManager.getFont( "defaultFont" );
+		Font newFont = font.deriveFont( (float) Math.max( font.getSize() - 1, 8 ) );
+		UIManager.put( "defaultFont", newFont );
+
+		FlatLaf.updateUI();
+	}
+
 	private void initComponents() {
 		// JFormDesigner - Component initialization - DO NOT MODIFY  //GEN-BEGIN:initComponents
 		JMenuBar menuBar1 = new JMenuBar();
@@ -68,9 +122,24 @@ class DemoFrame
 		JMenuItem deleteMenuItem = new JMenuItem();
 		JMenu viewMenu = new JMenu();
 		JCheckBoxMenuItem checkBoxMenuItem1 = new JCheckBoxMenuItem();
+		JMenu menu1 = new JMenu();
+		JMenu subViewsMenu = new JMenu();
+		JMenu subSubViewsMenu = new JMenu();
+		JMenuItem errorLogViewMenuItem = new JMenuItem();
+		JMenuItem searchViewMenuItem = new JMenuItem();
+		JMenuItem projectViewMenuItem = new JMenuItem();
+		JMenuItem structureViewMenuItem = new JMenuItem();
+		JMenuItem propertiesViewMenuItem = new JMenuItem();
+		JMenuItem menuItem1 = new JMenuItem();
 		JRadioButtonMenuItem radioButtonMenuItem1 = new JRadioButtonMenuItem();
 		JRadioButtonMenuItem radioButtonMenuItem2 = new JRadioButtonMenuItem();
 		JRadioButtonMenuItem radioButtonMenuItem3 = new JRadioButtonMenuItem();
+		fontMenu = new JMenu();
+		JMenuItem restoreFontMenuItem = new JMenuItem();
+		JMenuItem incrFontMenuItem = new JMenuItem();
+		JMenuItem decrFontMenuItem = new JMenuItem();
+		JMenu optionsMenu = new JMenu();
+		underlineMenuSelectionMenuItem = new JCheckBoxMenuItem();
 		JMenu helpMenu = new JMenu();
 		JMenuItem aboutMenuItem = new JMenuItem();
 		JToolBar toolBar1 = new JToolBar();
@@ -88,6 +157,7 @@ class DemoFrame
 		DataComponentsPanel dataComponentsPanel = new DataComponentsPanel();
 		TabsPanel tabsPanel = new TabsPanel();
 		OptionPanePanel optionPanePanel = new OptionPanePanel();
+		ExtrasPanel extrasPanel1 = new ExtrasPanel();
 		controlBar = new ControlBar();
 		IJThemesPanel themesPanel = new IJThemesPanel();
 
@@ -103,27 +173,35 @@ class DemoFrame
 			//======== fileMenu ========
 			{
 				fileMenu.setText("File");
+				fileMenu.setMnemonic('F');
 
 				//---- newMenuItem ----
 				newMenuItem.setText("New");
 				newMenuItem.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_N, Toolkit.getDefaultToolkit().getMenuShortcutKeyMask()));
+				newMenuItem.setMnemonic('N');
+				newMenuItem.addActionListener(e -> menuItemActionPerformed(e));
 				fileMenu.add(newMenuItem);
 
 				//---- openMenuItem ----
 				openMenuItem.setText("Open");
 				openMenuItem.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_O, Toolkit.getDefaultToolkit().getMenuShortcutKeyMask()));
+				openMenuItem.setMnemonic('O');
+				openMenuItem.addActionListener(e -> menuItemActionPerformed(e));
 				fileMenu.add(openMenuItem);
 				fileMenu.addSeparator();
 
 				//---- closeMenuItem ----
 				closeMenuItem.setText("Close");
 				closeMenuItem.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_W, Toolkit.getDefaultToolkit().getMenuShortcutKeyMask()));
+				closeMenuItem.setMnemonic('C');
+				closeMenuItem.addActionListener(e -> menuItemActionPerformed(e));
 				fileMenu.add(closeMenuItem);
 				fileMenu.addSeparator();
 
 				//---- exitMenuItem ----
 				exitMenuItem.setText("Exit");
 				exitMenuItem.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_Q, Toolkit.getDefaultToolkit().getMenuShortcutKeyMask()));
+				exitMenuItem.setMnemonic('X');
 				exitMenuItem.addActionListener(e -> exitActionPerformed());
 				fileMenu.add(exitMenuItem);
 			}
@@ -132,37 +210,47 @@ class DemoFrame
 			//======== editMenu ========
 			{
 				editMenu.setText("Edit");
+				editMenu.setMnemonic('E');
 
 				//---- undoMenuItem ----
 				undoMenuItem.setText("Undo");
 				undoMenuItem.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_Z, Toolkit.getDefaultToolkit().getMenuShortcutKeyMask()));
+				undoMenuItem.setMnemonic('U');
+				undoMenuItem.addActionListener(e -> menuItemActionPerformed(e));
 				editMenu.add(undoMenuItem);
 
 				//---- redoMenuItem ----
 				redoMenuItem.setText("Redo");
 				redoMenuItem.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_Y, Toolkit.getDefaultToolkit().getMenuShortcutKeyMask()));
+				redoMenuItem.setMnemonic('R');
+				redoMenuItem.addActionListener(e -> menuItemActionPerformed(e));
 				editMenu.add(redoMenuItem);
 				editMenu.addSeparator();
 
 				//---- cutMenuItem ----
 				cutMenuItem.setText("Cut");
 				cutMenuItem.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_X, Toolkit.getDefaultToolkit().getMenuShortcutKeyMask()));
+				cutMenuItem.setMnemonic('C');
 				editMenu.add(cutMenuItem);
 
 				//---- copyMenuItem ----
 				copyMenuItem.setText("Copy");
 				copyMenuItem.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_C, Toolkit.getDefaultToolkit().getMenuShortcutKeyMask()));
+				copyMenuItem.setMnemonic('O');
 				editMenu.add(copyMenuItem);
 
 				//---- pasteMenuItem ----
 				pasteMenuItem.setText("Paste");
 				pasteMenuItem.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_V, Toolkit.getDefaultToolkit().getMenuShortcutKeyMask()));
+				pasteMenuItem.setMnemonic('P');
 				editMenu.add(pasteMenuItem);
 				editMenu.addSeparator();
 
 				//---- deleteMenuItem ----
 				deleteMenuItem.setText("Delete");
 				deleteMenuItem.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_DELETE, 0));
+				deleteMenuItem.setMnemonic('D');
+				deleteMenuItem.addActionListener(e -> menuItemActionPerformed(e));
 				editMenu.add(deleteMenuItem);
 			}
 			menuBar1.add(editMenu);
@@ -170,34 +258,135 @@ class DemoFrame
 			//======== viewMenu ========
 			{
 				viewMenu.setText("View");
+				viewMenu.setMnemonic('V');
 
 				//---- checkBoxMenuItem1 ----
 				checkBoxMenuItem1.setText("Show Toolbar");
 				checkBoxMenuItem1.setSelected(true);
+				checkBoxMenuItem1.setMnemonic('T');
+				checkBoxMenuItem1.addActionListener(e -> menuItemActionPerformed(e));
 				viewMenu.add(checkBoxMenuItem1);
+
+				//======== menu1 ========
+				{
+					menu1.setText("Show View");
+					menu1.setMnemonic('V');
+
+					//======== subViewsMenu ========
+					{
+						subViewsMenu.setText("Sub Views");
+						subViewsMenu.setMnemonic('S');
+
+						//======== subSubViewsMenu ========
+						{
+							subSubViewsMenu.setText("Sub sub Views");
+							subSubViewsMenu.setMnemonic('U');
+
+							//---- errorLogViewMenuItem ----
+							errorLogViewMenuItem.setText("Error Log");
+							errorLogViewMenuItem.setMnemonic('E');
+							errorLogViewMenuItem.addActionListener(e -> menuItemActionPerformed(e));
+							subSubViewsMenu.add(errorLogViewMenuItem);
+						}
+						subViewsMenu.add(subSubViewsMenu);
+
+						//---- searchViewMenuItem ----
+						searchViewMenuItem.setText("Search");
+						searchViewMenuItem.setMnemonic('S');
+						searchViewMenuItem.addActionListener(e -> menuItemActionPerformed(e));
+						subViewsMenu.add(searchViewMenuItem);
+					}
+					menu1.add(subViewsMenu);
+
+					//---- projectViewMenuItem ----
+					projectViewMenuItem.setText("Project");
+					projectViewMenuItem.setMnemonic('P');
+					projectViewMenuItem.addActionListener(e -> menuItemActionPerformed(e));
+					menu1.add(projectViewMenuItem);
+
+					//---- structureViewMenuItem ----
+					structureViewMenuItem.setText("Structure");
+					structureViewMenuItem.setMnemonic('T');
+					structureViewMenuItem.addActionListener(e -> menuItemActionPerformed(e));
+					menu1.add(structureViewMenuItem);
+
+					//---- propertiesViewMenuItem ----
+					propertiesViewMenuItem.setText("Properties");
+					propertiesViewMenuItem.setMnemonic('O');
+					propertiesViewMenuItem.addActionListener(e -> menuItemActionPerformed(e));
+					menu1.add(propertiesViewMenuItem);
+				}
+				viewMenu.add(menu1);
+
+				//---- menuItem1 ----
+				menuItem1.setText("<html>some <b color=\"red\">HTML</b> <i color=\"blue\">text</i></html>");
+				viewMenu.add(menuItem1);
 				viewMenu.addSeparator();
 
 				//---- radioButtonMenuItem1 ----
 				radioButtonMenuItem1.setText("Details");
 				radioButtonMenuItem1.setSelected(true);
+				radioButtonMenuItem1.setMnemonic('D');
+				radioButtonMenuItem1.addActionListener(e -> menuItemActionPerformed(e));
 				viewMenu.add(radioButtonMenuItem1);
 
 				//---- radioButtonMenuItem2 ----
 				radioButtonMenuItem2.setText("Small Icons");
+				radioButtonMenuItem2.setMnemonic('S');
+				radioButtonMenuItem2.addActionListener(e -> menuItemActionPerformed(e));
 				viewMenu.add(radioButtonMenuItem2);
 
 				//---- radioButtonMenuItem3 ----
 				radioButtonMenuItem3.setText("Large Icons");
+				radioButtonMenuItem3.setMnemonic('L');
+				radioButtonMenuItem3.addActionListener(e -> menuItemActionPerformed(e));
 				viewMenu.add(radioButtonMenuItem3);
 			}
 			menuBar1.add(viewMenu);
 
+			//======== fontMenu ========
+			{
+				fontMenu.setText("Font");
+
+				//---- restoreFontMenuItem ----
+				restoreFontMenuItem.setText("Restore Font");
+				restoreFontMenuItem.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_0, KeyEvent.CTRL_MASK));
+				restoreFontMenuItem.addActionListener(e -> restoreFont());
+				fontMenu.add(restoreFontMenuItem);
+
+				//---- incrFontMenuItem ----
+				incrFontMenuItem.setText("Increase Font Size");
+				incrFontMenuItem.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_PLUS, KeyEvent.CTRL_MASK));
+				incrFontMenuItem.addActionListener(e -> incrFont());
+				fontMenu.add(incrFontMenuItem);
+
+				//---- decrFontMenuItem ----
+				decrFontMenuItem.setText("Decrease Font Size");
+				decrFontMenuItem.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_MINUS, KeyEvent.CTRL_MASK));
+				decrFontMenuItem.addActionListener(e -> decrFont());
+				fontMenu.add(decrFontMenuItem);
+			}
+			menuBar1.add(fontMenu);
+
+			//======== optionsMenu ========
+			{
+				optionsMenu.setText("Options");
+
+				//---- underlineMenuSelectionMenuItem ----
+				underlineMenuSelectionMenuItem.setText("Use underline menu selection");
+				underlineMenuSelectionMenuItem.addActionListener(e -> underlineMenuSelection());
+				optionsMenu.add(underlineMenuSelectionMenuItem);
+			}
+			menuBar1.add(optionsMenu);
+
 			//======== helpMenu ========
 			{
 				helpMenu.setText("Help");
+				helpMenu.setMnemonic('H');
 
 				//---- aboutMenuItem ----
 				aboutMenuItem.setText("About");
+				aboutMenuItem.setMnemonic('A');
 				aboutMenuItem.addActionListener(e -> aboutActionPerformed());
 				helpMenu.add(aboutMenuItem);
 			}
@@ -260,6 +449,7 @@ class DemoFrame
 				tabbedPane.addTab("Data Components", dataComponentsPanel);
 				tabbedPane.addTab("SplitPane & Tabs", tabsPanel);
 				tabbedPane.addTab("Option Pane", optionPanePanel);
+				tabbedPane.addTab("Extras", extrasPanel1);
 			}
 			contentPanel.add(tabbedPane, "cell 0 0");
 		}
@@ -288,9 +478,35 @@ class DemoFrame
 		pasteButton.setIcon( new FlatSVGIcon( "com/formdev/flatlaf/demo/icons/menu-paste.svg" ) );
 		refreshButton.setIcon( new FlatSVGIcon( "com/formdev/flatlaf/demo/icons/refresh.svg" ) );
 		showToggleButton.setIcon( new FlatSVGIcon( "com/formdev/flatlaf/demo/icons/show.svg" ) );
+
+		cutMenuItem.addActionListener( new DefaultEditorKit.CutAction() );
+		copyMenuItem.addActionListener( new DefaultEditorKit.CopyAction() );
+		pasteMenuItem.addActionListener( new DefaultEditorKit.PasteAction() );
+
+		// add font families
+		fontMenu.addSeparator();
+		String[] fontFamilies = { "Arial", "Comic Sans MS", "Courier New", "Dialog",
+			"Monospaced", "SansSerif", "Serif", "Tahoma", "Verdana" };
+		for( String fontFamily : fontFamilies ) {
+			JMenuItem fontItem = new JMenuItem( fontFamily );
+			fontItem.addActionListener( this::fontFamilyChanged );
+			fontMenu.add( fontItem );
+		}
+
+		// add font sizes
+		fontMenu.addSeparator();
+		int[] fontSizes = { 8, 10, 12, 14, 16, 18, 20, 24, 28 };
+		for( int fontSize : fontSizes ) {
+			String fontSizeStr = Integer.toString( fontSize );
+			JMenuItem fontItem = new JMenuItem( fontSizeStr );
+			fontItem.addActionListener( this::fontSizeChanged );
+			fontMenu.add( fontItem );
+		}
 	}
 
 	// JFormDesigner - Variables declaration - DO NOT MODIFY  //GEN-BEGIN:variables
+	private JMenu fontMenu;
+	private JCheckBoxMenuItem underlineMenuSelectionMenuItem;
 	private JTabbedPane tabbedPane;
 	private ControlBar controlBar;
 	// JFormDesigner - End of variables declaration  //GEN-END:variables